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