lewis.moe
Monorepo for Tangled
1package repo
2
3import (
4 "errors"
5 "fmt"
6 "log/slog"
7 "net/http"
8 "net/url"
9 "slices"
10 "sort"
11 "strings"
12 "sync"
13 "time"
14
15 "context"
16 "encoding/json"
17
18 indigoxrpc "github.com/bluesky-social/indigo/xrpc"
19 "github.com/go-git/go-git/v5/plumbing"
20 "tangled.org/core/api/tangled"
21 "tangled.org/core/appview/commitverify"
22 "tangled.org/core/appview/db"
23 "tangled.org/core/appview/models"
24 "tangled.org/core/appview/pages"
25 "tangled.org/core/appview/xrpcclient"
26 "tangled.org/core/orm"
27 "tangled.org/core/types"
28
29 "github.com/go-chi/chi/v5"
30 "github.com/go-enry/go-enry/v2"
31)
32
33func (rp *Repo) Index(w http.ResponseWriter, r *http.Request) {
34 l := rp.logger.With("handler", "RepoIndex")
35
36 ref := chi.URLParam(r, "ref")
37 ref, _ = url.PathUnescape(ref)
38
39 f, err := rp.repoResolver.Resolve(r)
40 if err != nil {
41 l.Error("failed to fully resolve repo", "err", err)
42 return
43 }
44
45 scheme := "http"
46 if !rp.config.Core.Dev {
47 scheme = "https"
48 }
49 host := fmt.Sprintf("%s://%s", scheme, f.Knot)
50 xrpcc := &indigoxrpc.Client{
51 Host: host,
52 }
53
54 user := rp.oauth.GetMultiAccountUser(r)
55
56 // Build index response from multiple XRPC calls
57 result, err := rp.buildIndexResponse(r.Context(), xrpcc, f, ref)
58 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
59 if errors.Is(xrpcerr, xrpcclient.ErrXrpcUnsupported) {
60 l.Error("failed to call XRPC repo.index", "err", err)
61 rp.pages.RepoIndexPage(w, pages.RepoIndexParams{
62 LoggedInUser: user,
63 NeedsKnotUpgrade: true,
64 RepoInfo: rp.repoResolver.GetRepoInfo(r, user),
65 })
66 return
67 } else {
68 l.Error("failed to build index response", "err", err)
69 rp.pages.RepoIndexPage(w, pages.RepoIndexParams{
70 LoggedInUser: user,
71 KnotUnreachable: true,
72 RepoInfo: rp.repoResolver.GetRepoInfo(r, user),
73 })
74 return
75 }
76 }
77
78 tagMap := make(map[string][]string)
79 for _, tag := range result.Tags {
80 hash := tag.Hash
81 if tag.Tag != nil {
82 hash = tag.Tag.Target.String()
83 }
84 tagMap[hash] = append(tagMap[hash], tag.Name)
85 }
86
87 for _, branch := range result.Branches {
88 hash := branch.Hash
89 tagMap[hash] = append(tagMap[hash], branch.Name)
90 }
91
92 sortFiles(result.Files)
93
94 slices.SortFunc(result.Branches, func(a, b types.Branch) int {
95 if a.Name == result.Ref {
96 return -1
97 }
98 if a.IsDefault {
99 return -1
100 }
101 if b.IsDefault {
102 return 1
103 }
104 if a.Commit != nil && b.Commit != nil {
105 if a.Commit.Committer.When.Before(b.Commit.Committer.When) {
106 return 1
107 } else {
108 return -1
109 }
110 }
111 return strings.Compare(a.Name, b.Name) * -1
112 })
113
114 commitCount := len(result.Commits)
115 branchCount := len(result.Branches)
116 tagCount := len(result.Tags)
117 fileCount := len(result.Files)
118
119 commitCount, branchCount, tagCount = balanceIndexItems(commitCount, branchCount, tagCount, fileCount)
120 commitsTrunc := result.Commits[:min(commitCount, len(result.Commits))]
121 tagsTrunc := result.Tags[:min(tagCount, len(result.Tags))]
122 branchesTrunc := result.Branches[:min(branchCount, len(result.Branches))]
123
124 emails := uniqueEmails(commitsTrunc)
125 emailToDidMap, err := db.GetEmailToDid(rp.db, emails, true)
126 if err != nil {
127 l.Error("failed to get email to did map", "err", err)
128 }
129
130 vc, err := commitverify.GetVerifiedCommits(rp.db, emailToDidMap, commitsTrunc)
131 if err != nil {
132 l.Error("failed to GetVerifiedObjectCommits", "err", err)
133 }
134
135 // TODO: a bit dirty
136 languageInfo, err := rp.getLanguageInfo(r.Context(), l, f, xrpcc, result.Ref, ref == "")
137 if err != nil {
138 l.Warn("failed to compute language percentages", "err", err)
139 // non-fatal
140 }
141
142 var shas []string
143 for _, c := range commitsTrunc {
144 shas = append(shas, c.Hash.String())
145 }
146 pipelines, err := getPipelineStatuses(rp.db, f, shas)
147 if err != nil {
148 l.Error("failed to fetch pipeline statuses", "err", err)
149 // non-fatal
150 }
151
152 rp.pages.RepoIndexPage(w, pages.RepoIndexParams{
153 LoggedInUser: user,
154 RepoInfo: rp.repoResolver.GetRepoInfo(r, user),
155 TagMap: tagMap,
156 RepoIndexResponse: *result,
157 CommitsTrunc: commitsTrunc,
158 TagsTrunc: tagsTrunc,
159 // ForkInfo: forkInfo, // TODO: reinstate this after xrpc properly lands
160 BranchesTrunc: branchesTrunc,
161 EmailToDid: emailToDidMap,
162 VerifiedCommits: vc,
163 Languages: languageInfo,
164 Pipelines: pipelines,
165 })
166}
167
168func (rp *Repo) getLanguageInfo(
169 ctx context.Context,
170 l *slog.Logger,
171 repo *models.Repo,
172 xrpcc *indigoxrpc.Client,
173 currentRef string,
174 isDefaultRef bool,
175) ([]types.RepoLanguageDetails, error) {
176 // first attempt to fetch from db
177 langs, err := db.GetRepoLanguages(
178 rp.db,
179 orm.FilterEq("repo_at", repo.RepoAt()),
180 orm.FilterEq("ref", currentRef),
181 )
182
183 if err != nil || langs == nil {
184 // non-fatal, fetch langs from ks via XRPC
185 didSlashRepo := fmt.Sprintf("%s/%s", repo.Did, repo.Name)
186 ls, err := tangled.RepoLanguages(ctx, xrpcc, currentRef, didSlashRepo)
187 if err != nil {
188 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
189 l.Error("failed to call XRPC repo.languages", "err", xrpcerr)
190 return nil, xrpcerr
191 }
192 return nil, err
193 }
194
195 if ls == nil || ls.Languages == nil {
196 return nil, nil
197 }
198
199 for _, lang := range ls.Languages {
200 langs = append(langs, models.RepoLanguage{
201 RepoAt: repo.RepoAt(),
202 RepoDid: repo.RepoDid,
203 Ref: currentRef,
204 IsDefaultRef: isDefaultRef,
205 Language: lang.Name,
206 Bytes: lang.Size,
207 })
208 }
209
210 tx, err := rp.db.Begin()
211 if err != nil {
212 return nil, err
213 }
214 defer tx.Rollback()
215
216 // update appview's cache
217 err = db.UpdateRepoLanguages(tx, repo.RepoAt(), currentRef, langs)
218 if err != nil {
219 // non-fatal
220 l.Error("failed to cache lang results", "err", err)
221 }
222
223 err = tx.Commit()
224 if err != nil {
225 return nil, err
226 }
227 }
228
229 var total int64
230 for _, l := range langs {
231 total += l.Bytes
232 }
233
234 var languageStats []types.RepoLanguageDetails
235 for _, l := range langs {
236 percentage := float32(l.Bytes) / float32(total) * 100
237 color := enry.GetColor(l.Language)
238 languageStats = append(languageStats, types.RepoLanguageDetails{
239 Name: l.Language,
240 Percentage: percentage,
241 Color: color,
242 })
243 }
244
245 sort.Slice(languageStats, func(i, j int) bool {
246 if languageStats[i].Name == enry.OtherLanguage {
247 return false
248 }
249 if languageStats[j].Name == enry.OtherLanguage {
250 return true
251 }
252 if languageStats[i].Percentage != languageStats[j].Percentage {
253 return languageStats[i].Percentage > languageStats[j].Percentage
254 }
255 return languageStats[i].Name < languageStats[j].Name
256 })
257
258 return languageStats, nil
259}
260
261// buildIndexResponse creates a RepoIndexResponse by combining multiple xrpc calls in parallel
262func (rp *Repo) buildIndexResponse(ctx context.Context, xrpcc *indigoxrpc.Client, repo *models.Repo, ref string) (*types.RepoIndexResponse, error) {
263 didSlashRepo := fmt.Sprintf("%s/%s", repo.Did, repo.Name)
264
265 // first get branches to determine the ref if not specified
266 branchesBytes, err := tangled.RepoBranches(ctx, xrpcc, "", 0, didSlashRepo)
267 if err != nil {
268 return nil, fmt.Errorf("failed to call repoBranches: %w", err)
269 }
270
271 var branchesResp types.RepoBranchesResponse
272 if err := json.Unmarshal(branchesBytes, &branchesResp); err != nil {
273 return nil, fmt.Errorf("failed to unmarshal branches response: %w", err)
274 }
275
276 // if no ref specified, use default branch or first available
277 if ref == "" {
278 for _, branch := range branchesResp.Branches {
279 if branch.IsDefault {
280 ref = branch.Name
281 break
282 }
283 }
284 }
285
286 // if ref is still empty, this means the default branch is not set
287 if ref == "" {
288 return &types.RepoIndexResponse{
289 IsEmpty: true,
290 Branches: branchesResp.Branches,
291 }, nil
292 }
293
294 // now run the remaining queries in parallel
295 var wg sync.WaitGroup
296 var errs error
297
298 var (
299 tagsResp types.RepoTagsResponse
300 treeResp *tangled.RepoTree_Output
301 logResp types.RepoLogResponse
302 readmeContent string
303 readmeFileName string
304 )
305
306 // tags
307 wg.Go(func() {
308 tagsBytes, err := tangled.RepoTags(ctx, xrpcc, "", 0, didSlashRepo)
309 if err != nil {
310 errs = errors.Join(errs, fmt.Errorf("failed to call repoTags: %w", err))
311 return
312 }
313
314 if err := json.Unmarshal(tagsBytes, &tagsResp); err != nil {
315 errs = errors.Join(errs, fmt.Errorf("failed to unmarshal repoTags: %w", err))
316 }
317 })
318
319 // tree/files
320 wg.Go(func() {
321 resp, err := tangled.RepoTree(ctx, xrpcc, "", ref, didSlashRepo)
322 if err != nil {
323 errs = errors.Join(errs, fmt.Errorf("failed to call repoTree: %w", err))
324 return
325 }
326 treeResp = resp
327 })
328
329 // commits
330 wg.Go(func() {
331 logBytes, err := tangled.RepoLog(ctx, xrpcc, "", 50, "", ref, didSlashRepo)
332 if err != nil {
333 errs = errors.Join(errs, fmt.Errorf("failed to call repoLog: %w", err))
334 return
335 }
336
337 if err := json.Unmarshal(logBytes, &logResp); err != nil {
338 errs = errors.Join(errs, fmt.Errorf("failed to unmarshal repoLog: %w", err))
339 }
340 })
341
342 wg.Wait()
343
344 if errs != nil {
345 return nil, errs
346 }
347
348 var files []types.NiceTree
349 if treeResp != nil && treeResp.Files != nil {
350 for _, file := range treeResp.Files {
351 niceFile := types.NiceTree{
352 Name: file.Name,
353 Mode: file.Mode,
354 Size: file.Size,
355 }
356
357 if file.Last_commit != nil {
358 when, _ := time.Parse(time.RFC3339, file.Last_commit.When)
359 niceFile.LastCommit = &types.LastCommitInfo{
360 Hash: plumbing.NewHash(file.Last_commit.Hash),
361 Message: file.Last_commit.Message,
362 When: when,
363 }
364 }
365 files = append(files, niceFile)
366 }
367 }
368
369 if treeResp != nil && treeResp.Readme != nil {
370 readmeFileName = treeResp.Readme.Filename
371 readmeContent = treeResp.Readme.Contents
372 }
373
374 result := &types.RepoIndexResponse{
375 IsEmpty: false,
376 Ref: ref,
377 Readme: readmeContent,
378 ReadmeFileName: readmeFileName,
379 Commits: logResp.Commits,
380 Description: logResp.Description,
381 Files: files,
382 Branches: branchesResp.Branches,
383 Tags: tagsResp.Tags,
384 TotalCommits: logResp.Total,
385 }
386
387 return result, nil
388}