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