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 Ref: currentRef,
203 IsDefaultRef: isDefaultRef,
204 Language: lang.Name,
205 Bytes: lang.Size,
206 })
207 }
208
209 tx, err := rp.db.Begin()
210 if err != nil {
211 return nil, err
212 }
213 defer tx.Rollback()
214
215 // update appview's cache
216 err = db.UpdateRepoLanguages(tx, repo.RepoAt(), currentRef, langs)
217 if err != nil {
218 // non-fatal
219 l.Error("failed to cache lang results", "err", err)
220 }
221
222 err = tx.Commit()
223 if err != nil {
224 return nil, err
225 }
226 }
227
228 var total int64
229 for _, l := range langs {
230 total += l.Bytes
231 }
232
233 var languageStats []types.RepoLanguageDetails
234 for _, l := range langs {
235 percentage := float32(l.Bytes) / float32(total) * 100
236 color := enry.GetColor(l.Language)
237 languageStats = append(languageStats, types.RepoLanguageDetails{
238 Name: l.Language,
239 Percentage: percentage,
240 Color: color,
241 })
242 }
243
244 sort.Slice(languageStats, func(i, j int) bool {
245 if languageStats[i].Name == enry.OtherLanguage {
246 return false
247 }
248 if languageStats[j].Name == enry.OtherLanguage {
249 return true
250 }
251 if languageStats[i].Percentage != languageStats[j].Percentage {
252 return languageStats[i].Percentage > languageStats[j].Percentage
253 }
254 return languageStats[i].Name < languageStats[j].Name
255 })
256
257 return languageStats, nil
258}
259
260// buildIndexResponse creates a RepoIndexResponse by combining multiple xrpc calls in parallel
261func (rp *Repo) buildIndexResponse(ctx context.Context, xrpcc *indigoxrpc.Client, repo *models.Repo, ref string) (*types.RepoIndexResponse, error) {
262 didSlashRepo := fmt.Sprintf("%s/%s", repo.Did, repo.Name)
263
264 // first get branches to determine the ref if not specified
265 branchesBytes, err := tangled.RepoBranches(ctx, xrpcc, "", 0, didSlashRepo)
266 if err != nil {
267 return nil, fmt.Errorf("failed to call repoBranches: %w", err)
268 }
269
270 var branchesResp types.RepoBranchesResponse
271 if err := json.Unmarshal(branchesBytes, &branchesResp); err != nil {
272 return nil, fmt.Errorf("failed to unmarshal branches response: %w", err)
273 }
274
275 // if no ref specified, use default branch or first available
276 if ref == "" {
277 for _, branch := range branchesResp.Branches {
278 if branch.IsDefault {
279 ref = branch.Name
280 break
281 }
282 }
283 }
284
285 // if ref is still empty, this means the default branch is not set
286 if ref == "" {
287 return &types.RepoIndexResponse{
288 IsEmpty: true,
289 Branches: branchesResp.Branches,
290 }, nil
291 }
292
293 // now run the remaining queries in parallel
294 var wg sync.WaitGroup
295 var errs error
296
297 var (
298 tagsResp types.RepoTagsResponse
299 treeResp *tangled.RepoTree_Output
300 logResp types.RepoLogResponse
301 readmeContent string
302 readmeFileName string
303 )
304
305 // tags
306 wg.Go(func() {
307 tagsBytes, err := tangled.RepoTags(ctx, xrpcc, "", 0, didSlashRepo)
308 if err != nil {
309 errs = errors.Join(errs, fmt.Errorf("failed to call repoTags: %w", err))
310 return
311 }
312
313 if err := json.Unmarshal(tagsBytes, &tagsResp); err != nil {
314 errs = errors.Join(errs, fmt.Errorf("failed to unmarshal repoTags: %w", err))
315 }
316 })
317
318 // tree/files
319 wg.Go(func() {
320 resp, err := tangled.RepoTree(ctx, xrpcc, "", ref, didSlashRepo)
321 if err != nil {
322 errs = errors.Join(errs, fmt.Errorf("failed to call repoTree: %w", err))
323 return
324 }
325 treeResp = resp
326 })
327
328 // commits
329 wg.Go(func() {
330 logBytes, err := tangled.RepoLog(ctx, xrpcc, "", 50, "", ref, didSlashRepo)
331 if err != nil {
332 errs = errors.Join(errs, fmt.Errorf("failed to call repoLog: %w", err))
333 return
334 }
335
336 if err := json.Unmarshal(logBytes, &logResp); err != nil {
337 errs = errors.Join(errs, fmt.Errorf("failed to unmarshal repoLog: %w", err))
338 }
339 })
340
341 wg.Wait()
342
343 if errs != nil {
344 return nil, errs
345 }
346
347 var files []types.NiceTree
348 if treeResp != nil && treeResp.Files != nil {
349 for _, file := range treeResp.Files {
350 niceFile := types.NiceTree{
351 Name: file.Name,
352 Mode: file.Mode,
353 Size: file.Size,
354 }
355
356 if file.Last_commit != nil {
357 when, _ := time.Parse(time.RFC3339, file.Last_commit.When)
358 niceFile.LastCommit = &types.LastCommitInfo{
359 Hash: plumbing.NewHash(file.Last_commit.Hash),
360 Message: file.Last_commit.Message,
361 When: when,
362 }
363 }
364 files = append(files, niceFile)
365 }
366 }
367
368 if treeResp != nil && treeResp.Readme != nil {
369 readmeFileName = treeResp.Readme.Filename
370 readmeContent = treeResp.Readme.Contents
371 }
372
373 result := &types.RepoIndexResponse{
374 IsEmpty: false,
375 Ref: ref,
376 Readme: readmeContent,
377 ReadmeFileName: readmeFileName,
378 Commits: logResp.Commits,
379 Description: logResp.Description,
380 Files: files,
381 Branches: branchesResp.Branches,
382 Tags: tagsResp.Tags,
383 TotalCommits: logResp.Total,
384 }
385
386 return result, nil
387}