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 ls, err := tangled.RepoLanguages(ctx, xrpcc, currentRef, repo.RepoIdentifier())
186 if err != nil {
187 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
188 l.Error("failed to call XRPC repo.languages", "err", xrpcerr)
189 return nil, xrpcerr
190 }
191 return nil, err
192 }
193
194 if ls == nil || ls.Languages == nil {
195 return nil, nil
196 }
197
198 for _, lang := range ls.Languages {
199 langs = append(langs, models.RepoLanguage{
200 RepoAt: repo.RepoAt(),
201 RepoDid: repo.RepoDid,
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 repoId := repo.RepoIdentifier()
263
264 branchesBytes, err := tangled.RepoBranches(ctx, xrpcc, "", 0, repoId)
265 if err != nil {
266 return nil, fmt.Errorf("failed to call repoBranches: %w", err)
267 }
268
269 var branchesResp types.RepoBranchesResponse
270 if err := json.Unmarshal(branchesBytes, &branchesResp); err != nil {
271 return nil, fmt.Errorf("failed to unmarshal branches response: %w", err)
272 }
273
274 // if no ref specified, use default branch or first available
275 if ref == "" {
276 for _, branch := range branchesResp.Branches {
277 if branch.IsDefault {
278 ref = branch.Name
279 break
280 }
281 }
282 }
283
284 // if ref is still empty, this means the default branch is not set
285 if ref == "" {
286 return &types.RepoIndexResponse{
287 IsEmpty: true,
288 Branches: branchesResp.Branches,
289 }, nil
290 }
291
292 // now run the remaining queries in parallel
293 var wg sync.WaitGroup
294 var errs error
295
296 var (
297 tagsResp types.RepoTagsResponse
298 treeResp *tangled.RepoTree_Output
299 logResp types.RepoLogResponse
300 readmeContent string
301 readmeFileName string
302 )
303
304 // tags
305 wg.Go(func() {
306 tagsBytes, err := tangled.RepoTags(ctx, xrpcc, "", 0, repoId)
307 if err != nil {
308 errs = errors.Join(errs, fmt.Errorf("failed to call repoTags: %w", err))
309 return
310 }
311
312 if err := json.Unmarshal(tagsBytes, &tagsResp); err != nil {
313 errs = errors.Join(errs, fmt.Errorf("failed to unmarshal repoTags: %w", err))
314 }
315 })
316
317 // tree/files
318 wg.Go(func() {
319 resp, err := tangled.RepoTree(ctx, xrpcc, "", ref, repoId)
320 if err != nil {
321 errs = errors.Join(errs, fmt.Errorf("failed to call repoTree: %w", err))
322 return
323 }
324 treeResp = resp
325 })
326
327 // commits
328 wg.Go(func() {
329 logBytes, err := tangled.RepoLog(ctx, xrpcc, "", 50, "", ref, repoId)
330 if err != nil {
331 errs = errors.Join(errs, fmt.Errorf("failed to call repoLog: %w", err))
332 return
333 }
334
335 if err := json.Unmarshal(logBytes, &logResp); err != nil {
336 errs = errors.Join(errs, fmt.Errorf("failed to unmarshal repoLog: %w", err))
337 }
338 })
339
340 wg.Wait()
341
342 if errs != nil {
343 return nil, errs
344 }
345
346 var files []types.NiceTree
347 if treeResp != nil && treeResp.Files != nil {
348 for _, file := range treeResp.Files {
349 niceFile := types.NiceTree{
350 Name: file.Name,
351 Mode: file.Mode,
352 Size: file.Size,
353 }
354
355 if file.Last_commit != nil {
356 when, _ := time.Parse(time.RFC3339, file.Last_commit.When)
357 niceFile.LastCommit = &types.LastCommitInfo{
358 Hash: plumbing.NewHash(file.Last_commit.Hash),
359 Message: file.Last_commit.Message,
360 When: when,
361 }
362 }
363 files = append(files, niceFile)
364 }
365 }
366
367 if treeResp != nil && treeResp.Readme != nil {
368 readmeFileName = treeResp.Readme.Filename
369 readmeContent = treeResp.Readme.Contents
370 }
371
372 result := &types.RepoIndexResponse{
373 IsEmpty: false,
374 Ref: ref,
375 Readme: readmeContent,
376 ReadmeFileName: readmeFileName,
377 Commits: logResp.Commits,
378 Description: logResp.Description,
379 Files: files,
380 Branches: branchesResp.Branches,
381 Tags: tagsResp.Tags,
382 TotalCommits: logResp.Total,
383 }
384
385 return result, nil
386}