From 1bb37814eb7fd50866542490f8dee26e82faadfd Mon Sep 17 00:00:00 2001 From: Seongmin Lee Date: Wed, 1 Apr 2026 22:54:27 +0900 Subject: [PATCH] appview: revert use of knotmirror from appview This reverts commit 35ceae65d94dc95c4095aa9aa56a8282c65c6369. Manually perserved knotmirror changes. Signed-off-by: Seongmin Lee --- appview/config/config.go | 39 +++++++--------- appview/pulls/pulls.go | 98 +++++++++++++++++++++++++++++++++------- appview/repo/archive.go | 28 ++++++++---- appview/repo/artifact.go | 12 ++++- appview/repo/branches.go | 17 +++++-- appview/repo/compare.go | 14 ++++-- appview/repo/index.go | 79 +++++++++++++++++++++----------- appview/repo/log.go | 28 ++++++++---- appview/repo/settings.go | 12 ++++- appview/repo/tags.go | 31 +++++++++---- appview/repo/tree.go | 13 ++++-- 11 files changed, 264 insertions(+), 107 deletions(-) diff --git a/appview/config/config.go b/appview/config/config.go index d029339b..a1c215bc 100644 --- a/appview/config/config.go +++ b/appview/config/config.go @@ -46,10 +46,6 @@ type PlcConfig struct { PLCURL string `env:"URL, default=https://plc.directory"` } -type KnotMirrorConfig struct { - Url string `env:"URL, default=https://mirror.tangled.network"` -} - type JetstreamConfig struct { Endpoint string `env:"ENDPOINT, default=wss://jetstream1.us-east.bsky.network/subscribe"` } @@ -158,24 +154,23 @@ func (cfg RedisConfig) ToURL() string { } type Config struct { - Core CoreConfig `env:",prefix=TANGLED_"` - Jetstream JetstreamConfig `env:",prefix=TANGLED_JETSTREAM_"` - Knotstream ConsumerConfig `env:",prefix=TANGLED_KNOTSTREAM_"` - Spindlestream ConsumerConfig `env:",prefix=TANGLED_SPINDLESTREAM_"` - Resend ResendConfig `env:",prefix=TANGLED_RESEND_"` - Posthog PosthogConfig `env:",prefix=TANGLED_POSTHOG_"` - Camo CamoConfig `env:",prefix=TANGLED_CAMO_"` - Avatar AvatarConfig `env:",prefix=TANGLED_AVATAR_"` - OAuth OAuthConfig `env:",prefix=TANGLED_OAUTH_"` - Redis RedisConfig `env:",prefix=TANGLED_REDIS_"` - Plc PlcConfig `env:",prefix=TANGLED_PLC_"` - Pds PdsConfig `env:",prefix=TANGLED_PDS_"` - Cloudflare Cloudflare `env:",prefix=TANGLED_CLOUDFLARE_"` - Label LabelConfig `env:",prefix=TANGLED_LABEL_"` - Bluesky BlueskyConfig `env:",prefix=TANGLED_BLUESKY_"` - Sites SitesConfig `env:",prefix=TANGLED_SITES_"` - KnotMirror KnotMirrorConfig `env:",prefix=TANGLED_KNOTMIRROR_"` - Ogre OgreConfig `env:",prefix=TANGLED_OGRE_"` + Core CoreConfig `env:",prefix=TANGLED_"` + Jetstream JetstreamConfig `env:",prefix=TANGLED_JETSTREAM_"` + Knotstream ConsumerConfig `env:",prefix=TANGLED_KNOTSTREAM_"` + Spindlestream ConsumerConfig `env:",prefix=TANGLED_SPINDLESTREAM_"` + Resend ResendConfig `env:",prefix=TANGLED_RESEND_"` + Posthog PosthogConfig `env:",prefix=TANGLED_POSTHOG_"` + Camo CamoConfig `env:",prefix=TANGLED_CAMO_"` + Avatar AvatarConfig `env:",prefix=TANGLED_AVATAR_"` + OAuth OAuthConfig `env:",prefix=TANGLED_OAUTH_"` + Redis RedisConfig `env:",prefix=TANGLED_REDIS_"` + Plc PlcConfig `env:",prefix=TANGLED_PLC_"` + Pds PdsConfig `env:",prefix=TANGLED_PDS_"` + Cloudflare Cloudflare `env:",prefix=TANGLED_CLOUDFLARE_"` + Label LabelConfig `env:",prefix=TANGLED_LABEL_"` + Bluesky BlueskyConfig `env:",prefix=TANGLED_BLUESKY_"` + Sites SitesConfig `env:",prefix=TANGLED_SITES_"` + Ogre OgreConfig `env:",prefix=TANGLED_OGRE_"` } func LoadConfig(ctx context.Context) (*Config, error) { diff --git a/appview/pulls/pulls.go b/appview/pulls/pulls.go index b708f750..3d22ed26 100644 --- a/appview/pulls/pulls.go +++ b/appview/pulls/pulls.go @@ -413,8 +413,16 @@ func (s *Pulls) branchDeleteStatus(r *http.Request, repo *models.Repo, pull *mod return nil } - xrpcc := &indigoxrpc.Client{Host: s.config.KnotMirror.Url} - resp, err := tangled.GitTempGetBranch(r.Context(), xrpcc, branch, repo.RepoAt().String()) + scheme := "http" + if !s.config.Core.Dev { + scheme = "https" + } + host := fmt.Sprintf("%s://%s", scheme, repo.Knot) + xrpcc := &indigoxrpc.Client{ + Host: host, + } + + resp, err := tangled.RepoBranch(r.Context(), xrpcc, branch, fmt.Sprintf("%s/%s", repo.Did, repo.Name)) if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { return nil } @@ -430,17 +438,37 @@ func (s *Pulls) resubmitCheck(r *http.Request, repo *models.Repo, pull *models.P return pages.Unknown } - var sourceRepo syntax.ATURI + var knot, ownerDid, repoName string + if pull.PullSource.RepoAt != nil { // fork-based pulls - sourceRepo = *pull.PullSource.RepoAt + sourceRepo, err := db.GetRepoByAtUri(s.db, pull.PullSource.RepoAt.String()) + if err != nil { + s.logger.Error("failed to get source repo", "err", err) + return pages.Unknown + } + + knot = sourceRepo.Knot + ownerDid = sourceRepo.Did + repoName = sourceRepo.Name } else { // pulls within the same repo - sourceRepo = repo.RepoAt() + knot = repo.Knot + ownerDid = repo.Did + repoName = repo.Name + } + + scheme := "http" + if !s.config.Core.Dev { + scheme = "https" + } + host := fmt.Sprintf("%s://%s", scheme, knot) + xrpcc := &indigoxrpc.Client{ + Host: host, } - xrpcc := &indigoxrpc.Client{Host: s.config.KnotMirror.Url} - branchResp, err := tangled.GitTempGetBranch(r.Context(), xrpcc, pull.PullSource.Branch, sourceRepo.String()) + didSlashName := fmt.Sprintf("%s/%s", ownerDid, repoName) + branchResp, err := tangled.RepoBranch(r.Context(), xrpcc, pull.PullSource.Branch, didSlashName) if err != nil { if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { s.logger.Error("failed to call XRPC repo.branches", "err", xrpcerr) @@ -878,9 +906,17 @@ func (s *Pulls) NewPull(w http.ResponseWriter, r *http.Request) { switch r.Method { case http.MethodGet: - xrpcc := &indigoxrpc.Client{Host: s.config.KnotMirror.Url} + scheme := "http" + if !s.config.Core.Dev { + scheme = "https" + } + host := fmt.Sprintf("%s://%s", scheme, f.Knot) + xrpcc := &indigoxrpc.Client{ + Host: host, + } - xrpcBytes, err := tangled.GitTempListBranches(r.Context(), xrpcc, "", 0, f.RepoAt().String()) + repo := fmt.Sprintf("%s/%s", f.Did, f.Name) + xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo) if err != nil { if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { s.logger.Error("failed to call XRPC repo.branches", "err", xrpcerr) @@ -1501,12 +1537,24 @@ func (s *Pulls) CompareBranchesFragment(w http.ResponseWriter, r *http.Request) return } - xrpcc := &indigoxrpc.Client{Host: s.config.KnotMirror.Url} + scheme := "http" + if !s.config.Core.Dev { + scheme = "https" + } + host := fmt.Sprintf("%s://%s", scheme, f.Knot) + xrpcc := &indigoxrpc.Client{ + Host: host, + } - xrpcBytes, err := tangled.GitTempListBranches(r.Context(), xrpcc, "", 0, f.RepoAt().String()) + repo := fmt.Sprintf("%s/%s", f.Did, f.Name) + xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo) if err != nil { + if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { + s.logger.Error("failed to fetch branches", "err", xrpcerr) + s.pages.Error503(w) + return + } s.logger.Error("failed to fetch branches", "err", err) - s.pages.Error503(w) return } @@ -1561,8 +1609,6 @@ func (s *Pulls) CompareForksBranchesFragment(w http.ResponseWriter, r *http.Requ return } - xrpcc := &indigoxrpc.Client{Host: s.config.KnotMirror.Url} - forkVal := r.URL.Query().Get("fork") repoString := strings.SplitN(forkVal, "/", 2) forkOwnerDid := repoString[0] @@ -1578,7 +1624,17 @@ func (s *Pulls) CompareForksBranchesFragment(w http.ResponseWriter, r *http.Requ return } - sourceXrpcBytes, err := tangled.GitTempListBranches(r.Context(), xrpcc, "", 0, repo.RepoAt().String()) + sourceScheme := "http" + if !s.config.Core.Dev { + sourceScheme = "https" + } + sourceHost := fmt.Sprintf("%s://%s", sourceScheme, repo.Knot) + sourceXrpcc := &indigoxrpc.Client{ + Host: sourceHost, + } + + sourceRepo := fmt.Sprintf("%s/%s", forkOwnerDid, repo.Name) + sourceXrpcBytes, err := tangled.RepoBranches(r.Context(), sourceXrpcc, "", 0, sourceRepo) if err != nil { if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { s.logger.Error("failed to call XRPC repo.branches for source", "err", xrpcerr) @@ -1597,7 +1653,17 @@ func (s *Pulls) CompareForksBranchesFragment(w http.ResponseWriter, r *http.Requ return } - targetXrpcBytes, err := tangled.GitTempListBranches(r.Context(), xrpcc, "", 0, f.RepoAt().String()) + targetScheme := "http" + if !s.config.Core.Dev { + targetScheme = "https" + } + targetHost := fmt.Sprintf("%s://%s", targetScheme, f.Knot) + targetXrpcc := &indigoxrpc.Client{ + Host: targetHost, + } + + targetRepo := fmt.Sprintf("%s/%s", f.Did, f.Name) + targetXrpcBytes, err := tangled.RepoBranches(r.Context(), targetXrpcc, "", 0, targetRepo) if err != nil { if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { s.logger.Error("failed to call XRPC repo.branches for target", "err", xrpcerr) diff --git a/appview/repo/archive.go b/appview/repo/archive.go index f224d090..50a6686b 100644 --- a/appview/repo/archive.go +++ b/appview/repo/archive.go @@ -8,7 +8,6 @@ import ( "strings" "github.com/go-chi/chi/v5" - "tangled.org/core/api/tangled" ) func (rp *Repo) DownloadArchive(w http.ResponseWriter, r *http.Request) { @@ -21,19 +20,30 @@ func (rp *Repo) DownloadArchive(w http.ResponseWriter, r *http.Request) { l.Error("failed to get repo and knot", "err", err) return } + scheme := "http" + if !rp.config.Core.Dev { + scheme = "https" + } + host := fmt.Sprintf("%s://%s", scheme, f.Knot) + didSlashRepo := f.DidSlashRepo() // build the xrpc url + u, err := url.Parse(host) + if err != nil { + l.Error("failed to parse host URL", "err", err) + rp.pages.Error503(w) + return + } + + u.Path = "/xrpc/sh.tangled.repo.archive" query := url.Values{} - query.Set("repo", f.RepoAt().String()) - query.Set("ref", ref) query.Set("format", "tar.gz") query.Set("prefix", r.URL.Query().Get("prefix")) - xrpcURL := fmt.Sprintf( - "%s/xrpc/%s?%s", - rp.config.KnotMirror.Url, - tangled.GitTempGetArchiveNSID, - query.Encode(), - ) + query.Set("ref", ref) + query.Set("repo", didSlashRepo) + u.RawQuery = query.Encode() + + xrpcURL := u.String() // make the get request resp, err := http.Get(xrpcURL) diff --git a/appview/repo/artifact.go b/appview/repo/artifact.go index 3cba92c3..95870abf 100644 --- a/appview/repo/artifact.go +++ b/appview/repo/artifact.go @@ -313,9 +313,17 @@ func (rp *Repo) resolveTag(ctx context.Context, f *models.Repo, tagParam string) return nil, err } - xrpcc := &indigoxrpc.Client{Host: rp.config.KnotMirror.Url} + scheme := "http" + if !rp.config.Core.Dev { + scheme = "https" + } + host := fmt.Sprintf("%s://%s", scheme, f.Knot) + xrpcc := &indigoxrpc.Client{ + Host: host, + } - xrpcBytes, err := tangled.GitTempListTags(ctx, xrpcc, "", 0, f.RepoAt().String()) + repo := fmt.Sprintf("%s/%s", f.Did, f.Name) + xrpcBytes, err := tangled.RepoTags(ctx, xrpcc, "", 0, repo) if err != nil { if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { l.Error("failed to call XRPC repo.tags", "err", xrpcerr) diff --git a/appview/repo/branches.go b/appview/repo/branches.go index 25d53c9d..ce38b862 100644 --- a/appview/repo/branches.go +++ b/appview/repo/branches.go @@ -21,11 +21,18 @@ func (rp *Repo) Branches(w http.ResponseWriter, r *http.Request) { l.Error("failed to get repo and knot", "err", err) return } - xrpcc := &indigoxrpc.Client{Host: rp.config.KnotMirror.Url} - - xrpcBytes, err := tangled.GitTempListBranches(r.Context(), xrpcc, "", 0, f.RepoAt().String()) - if err != nil { - l.Error("failed to call XRPC repo.branches", "err", err) + scheme := "http" + if !rp.config.Core.Dev { + scheme = "https" + } + host := fmt.Sprintf("%s://%s", scheme, f.Knot) + xrpcc := &indigoxrpc.Client{ + Host: host, + } + repo := fmt.Sprintf("%s/%s", f.Did, f.Name) + xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo) + if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { + l.Error("failed to call XRPC repo.branches", "err", xrpcerr) rp.pages.Error503(w) return } diff --git a/appview/repo/compare.go b/appview/repo/compare.go index ee2d9f52..92a7fdba 100644 --- a/appview/repo/compare.go +++ b/appview/repo/compare.go @@ -27,9 +27,17 @@ func (rp *Repo) CompareNew(w http.ResponseWriter, r *http.Request) { return } - xrpcc := &indigoxrpc.Client{Host: rp.config.KnotMirror.Url} + scheme := "http" + if !rp.config.Core.Dev { + scheme = "https" + } + host := fmt.Sprintf("%s://%s", scheme, f.Knot) + xrpcc := &indigoxrpc.Client{ + Host: host, + } - branchBytes, err := tangled.GitTempListBranches(r.Context(), xrpcc, "", 0, f.RepoAt().String()) + repo := fmt.Sprintf("%s/%s", f.Did, f.Name) + branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo) if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { l.Error("failed to call XRPC repo.branches", "err", xrpcerr) rp.pages.Error503(w) @@ -66,7 +74,7 @@ func (rp *Repo) CompareNew(w http.ResponseWriter, r *http.Request) { head = queryHead } - tagBytes, err := tangled.GitTempListTags(r.Context(), xrpcc, "", 0, f.RepoAt().String()) + tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo) if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { l.Error("failed to call XRPC repo.tags", "err", xrpcerr) rp.pages.Error503(w) diff --git a/appview/repo/index.go b/appview/repo/index.go index 81d3ae08..1cbf303f 100644 --- a/appview/repo/index.go +++ b/appview/repo/index.go @@ -22,6 +22,7 @@ import ( "tangled.org/core/appview/db" "tangled.org/core/appview/models" "tangled.org/core/appview/pages" + "tangled.org/core/appview/xrpcclient" "tangled.org/core/orm" "tangled.org/core/types" @@ -41,18 +42,37 @@ func (rp *Repo) Index(w http.ResponseWriter, r *http.Request) { return } + scheme := "http" + if !rp.config.Core.Dev { + scheme = "https" + } + host := fmt.Sprintf("%s://%s", scheme, f.Knot) + xrpcc := &indigoxrpc.Client{ + Host: host, + } + user := rp.oauth.GetMultiAccountUser(r) // Build index response from multiple XRPC calls - result, err := rp.buildIndexResponse(r.Context(), f, ref) - if err != nil { - l.Error("failed to build index response", "err", err) - rp.pages.RepoIndexPage(w, pages.RepoIndexParams{ - LoggedInUser: user, - KnotUnreachable: true, - RepoInfo: rp.repoResolver.GetRepoInfo(r, user), - }) - return + result, err := rp.buildIndexResponse(r.Context(), xrpcc, f, ref) + if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { + if errors.Is(xrpcerr, xrpcclient.ErrXrpcUnsupported) { + l.Error("failed to call XRPC repo.index", "err", err) + rp.pages.RepoIndexPage(w, pages.RepoIndexParams{ + LoggedInUser: user, + NeedsKnotUpgrade: true, + RepoInfo: rp.repoResolver.GetRepoInfo(r, user), + }) + return + } else { + l.Error("failed to build index response", "err", err) + rp.pages.RepoIndexPage(w, pages.RepoIndexParams{ + LoggedInUser: user, + KnotUnreachable: true, + RepoInfo: rp.repoResolver.GetRepoInfo(r, user), + }) + return + } } tagMap := make(map[string][]string) @@ -115,7 +135,7 @@ func (rp *Repo) Index(w http.ResponseWriter, r *http.Request) { var languageInfo []types.RepoLanguageDetails if !result.IsEmpty { // TODO: a bit dirty - languageInfo, err = rp.getLanguageInfo(r.Context(), l, f, result.Ref, ref == "") + languageInfo, err = rp.getLanguageInfo(r.Context(), l, f, xrpcc, result.Ref, ref == "") if err != nil { l.Warn("failed to compute language percentages", "err", err) // non-fatal @@ -152,6 +172,7 @@ func (rp *Repo) getLanguageInfo( ctx context.Context, l *slog.Logger, repo *models.Repo, + xrpcc *indigoxrpc.Client, currentRef string, isDefaultRef bool, ) ([]types.RepoLanguageDetails, error) { @@ -164,10 +185,14 @@ func (rp *Repo) getLanguageInfo( if err != nil || langs == nil { // non-fatal, fetch langs from ks via XRPC - xrpcc := &indigoxrpc.Client{Host: rp.config.KnotMirror.Url} - ls, err := tangled.GitTempListLanguages(ctx, xrpcc, currentRef, repo.RepoAt().String()) + didSlashRepo := fmt.Sprintf("%s/%s", repo.Did, repo.Name) + ls, err := tangled.RepoLanguages(ctx, xrpcc, currentRef, didSlashRepo) if err != nil { - return nil, fmt.Errorf("calling knotmirror git.listLanguages: %w", err) + if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { + l.Error("failed to call XRPC repo.languages", "err", xrpcerr) + return nil, xrpcerr + } + return nil, err } if ls == nil || ls.Languages == nil { @@ -236,13 +261,13 @@ func (rp *Repo) getLanguageInfo( } // buildIndexResponse creates a RepoIndexResponse by combining multiple xrpc calls in parallel -func (rp *Repo) buildIndexResponse(ctx context.Context, repo *models.Repo, ref string) (*types.RepoIndexResponse, error) { - xrpcc := &indigoxrpc.Client{Host: rp.config.KnotMirror.Url} +func (rp *Repo) buildIndexResponse(ctx context.Context, xrpcc *indigoxrpc.Client, repo *models.Repo, ref string) (*types.RepoIndexResponse, error) { + didSlashRepo := fmt.Sprintf("%s/%s", repo.Did, repo.Name) // first get branches to determine the ref if not specified - branchesBytes, err := tangled.GitTempListBranches(ctx, xrpcc, "", 0, repo.RepoAt().String()) + branchesBytes, err := tangled.RepoBranches(ctx, xrpcc, "", 0, didSlashRepo) if err != nil { - return nil, fmt.Errorf("calling knotmirror git.listBranches: %w", err) + return nil, fmt.Errorf("failed to call repoBranches: %w", err) } var branchesResp types.RepoBranchesResponse @@ -274,7 +299,7 @@ func (rp *Repo) buildIndexResponse(ctx context.Context, repo *models.Repo, ref s var ( tagsResp types.RepoTagsResponse - treeResp *tangled.GitTempGetTree_Output + treeResp *tangled.RepoTree_Output logResp types.RepoLogResponse readmeContent string readmeFileName string @@ -282,22 +307,22 @@ func (rp *Repo) buildIndexResponse(ctx context.Context, repo *models.Repo, ref s // tags wg.Go(func() { - tagsBytes, err := tangled.GitTempListTags(ctx, xrpcc, "", 0, repo.RepoAt().String()) + tagsBytes, err := tangled.RepoTags(ctx, xrpcc, "", 0, didSlashRepo) if err != nil { - errs = errors.Join(errs, fmt.Errorf("failed to call git.ListTags: %w", err)) + errs = errors.Join(errs, fmt.Errorf("failed to call repoTags: %w", err)) return } if err := json.Unmarshal(tagsBytes, &tagsResp); err != nil { - errs = errors.Join(errs, fmt.Errorf("failed to unmarshal git.ListTags: %w", err)) + errs = errors.Join(errs, fmt.Errorf("failed to unmarshal repoTags: %w", err)) } }) // tree/files wg.Go(func() { - resp, err := tangled.GitTempGetTree(ctx, xrpcc, "", ref, repo.RepoAt().String()) + resp, err := tangled.RepoTree(ctx, xrpcc, "", ref, didSlashRepo) if err != nil { - errs = errors.Join(errs, fmt.Errorf("failed to call git.GetTree: %w", err)) + errs = errors.Join(errs, fmt.Errorf("failed to call repoTree: %w", err)) return } treeResp = resp @@ -305,14 +330,14 @@ func (rp *Repo) buildIndexResponse(ctx context.Context, repo *models.Repo, ref s // commits wg.Go(func() { - logBytes, err := tangled.GitTempListCommits(ctx, xrpcc, "", 50, ref, repo.RepoAt().String()) + logBytes, err := tangled.RepoLog(ctx, xrpcc, "", 50, "", ref, didSlashRepo) if err != nil { - errs = errors.Join(errs, fmt.Errorf("failed to call git.ListCommits: %w", err)) + errs = errors.Join(errs, fmt.Errorf("failed to call repoLog: %w", err)) return } if err := json.Unmarshal(logBytes, &logResp); err != nil { - errs = errors.Join(errs, fmt.Errorf("failed to unmarshal git.ListCommits: %w", err)) + errs = errors.Join(errs, fmt.Errorf("failed to unmarshal repoLog: %w", err)) } }) @@ -354,7 +379,7 @@ func (rp *Repo) buildIndexResponse(ctx context.Context, repo *models.Repo, ref s Readme: readmeContent, ReadmeFileName: readmeFileName, Commits: logResp.Commits, - Description: "", + Description: logResp.Description, Files: files, Branches: branchesResp.Branches, Tags: tagsResp.Tags, diff --git a/appview/repo/log.go b/appview/repo/log.go index dd59c525..d9b9c713 100644 --- a/appview/repo/log.go +++ b/appview/repo/log.go @@ -40,7 +40,14 @@ func (rp *Repo) Log(w http.ResponseWriter, r *http.Request) { ref := chi.URLParam(r, "ref") ref, _ = url.PathUnescape(ref) - xrpcc := &indigoxrpc.Client{Host: rp.config.KnotMirror.Url} + scheme := "http" + if !rp.config.Core.Dev { + scheme = "https" + } + host := fmt.Sprintf("%s://%s", scheme, f.Knot) + xrpcc := &indigoxrpc.Client{ + Host: host, + } limit := int64(60) cursor := "" @@ -50,9 +57,10 @@ func (rp *Repo) Log(w http.ResponseWriter, r *http.Request) { cursor = strconv.Itoa(offset) } - xrpcBytes, err := tangled.GitTempListCommits(r.Context(), xrpcc, cursor, limit, ref, f.RepoAt().String()) - if err != nil { - l.Error("failed to call XRPC repo.log", "err", err) + repo := fmt.Sprintf("%s/%s", f.Did, f.Name) + xrpcBytes, err := tangled.RepoLog(r.Context(), xrpcc, cursor, limit, "", ref, repo) + if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { + l.Error("failed to call XRPC repo.log", "err", xrpcerr) rp.pages.Error503(w) return } @@ -64,9 +72,9 @@ func (rp *Repo) Log(w http.ResponseWriter, r *http.Request) { return } - tagBytes, err := tangled.GitTempListTags(r.Context(), xrpcc, "", 0, f.RepoAt().String()) - if err != nil { - l.Error("failed to call XRPC repo.tags", "err", err) + tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo) + if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { + l.Error("failed to call XRPC repo.tags", "err", xrpcerr) rp.pages.Error503(w) return } @@ -85,9 +93,9 @@ func (rp *Repo) Log(w http.ResponseWriter, r *http.Request) { } } - branchBytes, err := tangled.GitTempListBranches(r.Context(), xrpcc, "", 0, f.RepoAt().String()) - if err != nil { - l.Error("failed to call XRPC repo.branches", "err", err) + branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo) + if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { + l.Error("failed to call XRPC repo.branches", "err", xrpcerr) rp.pages.Error503(w) return } diff --git a/appview/repo/settings.go b/appview/repo/settings.go index 9d0705da..5e20092f 100644 --- a/appview/repo/settings.go +++ b/appview/repo/settings.go @@ -386,9 +386,17 @@ func (rp *Repo) generalSettings(w http.ResponseWriter, r *http.Request) { f, err := rp.repoResolver.Resolve(r) user := rp.oauth.GetMultiAccountUser(r) - xrpcc := &indigoxrpc.Client{Host: rp.config.KnotMirror.Url} + scheme := "http" + if !rp.config.Core.Dev { + scheme = "https" + } + host := fmt.Sprintf("%s://%s", scheme, f.Knot) + xrpcc := &indigoxrpc.Client{ + Host: host, + } - xrpcBytes, err := tangled.GitTempListBranches(r.Context(), xrpcc, "", 0, f.RepoAt().String()) + repo := fmt.Sprintf("%s/%s", f.Did, f.Name) + xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo) var result types.RepoBranchesResponse if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { l.Error("failed to call XRPC repo.branches", "err", xrpcerr) diff --git a/appview/repo/tags.go b/appview/repo/tags.go index 90d08c45..6d778fd6 100644 --- a/appview/repo/tags.go +++ b/appview/repo/tags.go @@ -27,10 +27,18 @@ func (rp *Repo) Tags(w http.ResponseWriter, r *http.Request) { l.Error("failed to get repo and knot", "err", err) return } - xrpcc := &indigoxrpc.Client{Host: rp.config.KnotMirror.Url} - xrpcBytes, err := tangled.GitTempListTags(r.Context(), xrpcc, "", 0, f.RepoAt().String()) - if err != nil { - l.Error("failed to call XRPC repo.tags", "err", err) + scheme := "http" + if !rp.config.Core.Dev { + scheme = "https" + } + host := fmt.Sprintf("%s://%s", scheme, f.Knot) + xrpcc := &indigoxrpc.Client{ + Host: host, + } + repo := fmt.Sprintf("%s/%s", f.Did, f.Name) + xrpcBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo) + if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { + l.Error("failed to call XRPC repo.tags", "err", xrpcerr) rp.pages.Error503(w) return } @@ -82,16 +90,23 @@ func (rp *Repo) Tag(w http.ResponseWriter, r *http.Request) { l.Error("failed to get repo and knot", "err", err) return } + scheme := "http" + if !rp.config.Core.Dev { + scheme = "https" + } + host := fmt.Sprintf("%s://%s", scheme, f.Knot) + xrpcc := &indigoxrpc.Client{ + Host: host, + } + repo := fmt.Sprintf("%s/%s", f.Did, f.Name) tag := chi.URLParam(r, "tag") - xrpcc := &indigoxrpc.Client{Host: rp.config.KnotMirror.Url} - - xrpcBytes, err := tangled.GitTempGetTag(r.Context(), xrpcc, f.RepoAt().String(), tag) + xrpcBytes, err := tangled.RepoTag(r.Context(), xrpcc, repo, tag) if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { // if we don't match an existing tag, and the tag we're trying // to match is "latest", resolve to the most recent tag if tag == "latest" { - tagsBytes, err := tangled.GitTempListTags(r.Context(), xrpcc, "", 1, f.RepoAt().String()) + tagsBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 1, repo) if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { l.Error("failed to call XRPC repo.tags for latest", "err", xrpcerr) rp.pages.Error503(w) diff --git a/appview/repo/tree.go b/appview/repo/tree.go index 04a8e814..d541f934 100644 --- a/appview/repo/tree.go +++ b/appview/repo/tree.go @@ -33,9 +33,16 @@ func (rp *Repo) Tree(w http.ResponseWriter, r *http.Request) { treePath := chi.URLParam(r, "*") treePath, _ = url.PathUnescape(treePath) treePath = strings.TrimSuffix(treePath, "/") - - xrpcc := &indigoxrpc.Client{Host: rp.config.KnotMirror.Url} - xrpcResp, err := tangled.GitTempGetTree(r.Context(), xrpcc, treePath, ref, f.RepoAt().String()) + scheme := "http" + if !rp.config.Core.Dev { + scheme = "https" + } + host := fmt.Sprintf("%s://%s", scheme, f.Knot) + xrpcc := &indigoxrpc.Client{ + Host: host, + } + repo := fmt.Sprintf("%s/%s", f.Did, f.Name) + xrpcResp, err := tangled.RepoTree(r.Context(), xrpcc, treePath, ref, repo) if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { l.Error("failed to call XRPC repo.tree", "err", xrpcerr) rp.pages.Error503(w) -- 2.51.2