BlueGit

timfa bluegit

Files

bluegit / internal / server / repo_handlers.go

repo_handlers.go

repo_handlers.go 16.3 KiB Download Raw
1package server
2
3import (
4 "net/http"
5 "strconv"
6 "strings"
7
8 "gitlab.com/Timfa/bluegit/internal/access"
9 "gitlab.com/Timfa/bluegit/internal/desctpl"
10 "gitlab.com/Timfa/bluegit/internal/gitrepo"
11 "gitlab.com/Timfa/bluegit/internal/i18n"
12 "gitlab.com/Timfa/bluegit/internal/store"
13)
14
15func (s *Server) guard(w http.ResponseWriter, r *http.Request, min access.Role) (store.User, store.Repo, access.Role, bool) {
16 owner := r.PathValue("owner")
17 name := strings.TrimSuffix(r.PathValue("repo"), ".git")
18 repo, err := s.Store.RepoByPath(r.Context(), owner, name)
19 if err != nil {
20 http.NotFound(w, r)
21 return store.User{}, store.Repo{}, "", false
22 }
23 p := s.who(r)
24 var role access.Role
25 if p.OK {
26 role, err = s.Store.EffectiveRole(r.Context(), p.User.ID, repo.ID)
27 if err != nil {
28 http.Error(w, s.tr(r, "err.rights"), http.StatusInternalServerError)
29 return store.User{}, store.Repo{}, "", false
30 }
31 }
32 if isCrawler(r) {
33 p = principal{}
34 role = access.RoleNone
35 }
36 readable := role.CanRead() || repo.Visibility == "public"
37 if !readable && releaseOnly(repo, role) && (r.Method == http.MethodGet || r.Method == http.MethodHead) && isRepoRootPath(r.URL.Path, repo) {
38 // Privé repo met publieke releases: alleen de Releases-pagina.
39 http.Redirect(w, r, "/"+repo.FullPath()+"/-/releases", http.StatusSeeOther)
40 return store.User{}, store.Repo{}, "", false
41 }
42 if !readable {
43 if isCrawler(r) {
44 s.writeLockedCard(w, r)
45 } else if p.OK {
46 http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
47 } else {
48 http.NotFound(w, r)
49 }
50 return store.User{}, store.Repo{}, "", false
51 }
52 if min != access.RoleReadonly && !role.AtLeast(min) {
53 http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
54 return store.User{}, store.Repo{}, "", false
55 }
56 return p.User, repo, role, true
57}
58
59func (s *Server) repoView(w http.ResponseWriter, r *http.Request, repo store.Repo, role access.Role, title string) View {
60 v := s.view(w, r, title)
61 v.Repo = &repo
62 v.Role = role
63 v.CanWrite = role.CanWriteCode()
64 v.CanAdmin = role.CanManageSettings()
65 v.Rev = safeRev(r.URL.Query().Get("rev"), repo.DefaultBranch)
66 v.CloneHTTP = strings.TrimRight(s.Cfg.BaseURL, "/") + "/" + repo.FullPath() + ".git"
67 v.CloneSSH = s.Cfg.CloneSSH(repo.FullPath())
68 v.ShowReleases = canSeeReleases(repo, role)
69 if releaseOnly(repo, role) {
70 card := releaseOnlyCard(repo)
71 v.Repo = &card
72 v.ReleaseOnly = true
73 v.CloneHTTP, v.CloneSSH, v.Rev = "", "", ""
74 return v
75 }
76 s.fillSideCounts(r, &v, repo, role)
77 return v
78}
79
80func (s *Server) fillSideCounts(r *http.Request, v *View, repo store.Repo, role access.Role) {
81 var viewerID int64
82 if v.User != nil {
83 viewerID = v.User.ID
84 }
85 mrs, issues, err := s.Store.OpenSidebarCounts(r.Context(), repo.ID, viewerID, role.CanTriageIssue())
86 if err != nil {
87 if s.Log != nil {
88 s.Log.Error("zijbalk-telling", "repo", repo.FullPath(), "err", err)
89 }
90 return
91 }
92 v.OpenMRCount = mrs
93 v.OpenIssueCount = issues
94}
95
96func (s *Server) repoHome(w http.ResponseWriter, r *http.Request) {
97 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
98 if !ok {
99 return
100 }
101 v := s.repoView(w, r, repo, role, repo.Name)
102 v.Wide = true
103 s.fillOverview(r, &v, repo)
104 uid := int64(0)
105 if v.User != nil {
106 uid = v.User.ID
107 v.ForkTargets = s.forkTargets(r.Context(), *v.User)
108 }
109 v.Stars, v.Starred = s.starState(r.Context(), uid, repo.ID)
110 v.Fork = s.forkInfo(r.Context(), uid, repo)
111 v.Heat = s.heatmap(r.Context(), 0, []int64{repo.ID}, s.langOf(r))
112 s.render(w, "repo", v)
113}
114
115func (s *Server) treeRoot(w http.ResponseWriter, r *http.Request) {
116 r.SetPathValue("path", "")
117 s.tree(w, r)
118}
119
120func (s *Server) tree(w http.ResponseWriter, r *http.Request) {
121 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
122 if !ok {
123 return
124 }
125 rel, err := cleanRel(r.PathValue("path"))
126 if err != nil {
127 http.NotFound(w, r)
128 return
129 }
130 v := s.repoView(w, r, repo, role, rel)
131 v.Wide = true
132 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
133 if _, err := gitrepo.Tree(r.Context(), s.Git, dir, v.Rev, rel); err != nil && rel != "" {
134 http.NotFound(w, r)
135 return
136 }
137 s.fillFiles(r, &v, repo, rel, false)
138 s.render(w, "files", v)
139}
140
141func (s *Server) blob(w http.ResponseWriter, r *http.Request) {
142 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
143 if !ok {
144 return
145 }
146 rel, err := cleanRel(r.PathValue("path"))
147 if err != nil || rel == "" {
148 http.NotFound(w, r)
149 return
150 }
151 v := s.repoView(w, r, repo, role, rel)
152 v.Wide = true
153 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
154 if _, _, err := gitrepo.Blob(r.Context(), s.Git, dir, v.Rev, rel, 1); err != nil {
155 http.NotFound(w, r)
156 return
157 }
158 s.fillFiles(r, &v, repo, rel, true)
159 s.render(w, "files", v)
160}
161
162func (s *Server) commits(w http.ResponseWriter, r *http.Request) {
163 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
164 if !ok {
165 return
166 }
167 v := s.repoView(w, r, repo, role, "title.commits")
168 v.Page = "commits"
169 v.Wide = true
170 v.Query = clipQuery(r.URL.Query().Get("q"))
171 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
172 s.branchList(r, &v, repo)
173 page := commitPageNum(r.URL.Query().Get("page"))
174 list, more := s.commitWindow(r.Context(), dir, v.Rev, v.Query, (page-1)*commitPageSize, commitPageSize)
175 lang := i18n.Parse(v.Lang)
176 rows := s.presentCommits(r.Context(), repo.ID, list, lang)
177 for i := range rows {
178 s.attachHeadPipeline(r.Context(), repo, &rows[i], lang)
179 }
180 v.Commits = rows
181 v.CommitDays = groupCommitDays(rows, lang)
182 if page > 1 {
183 v.CommitPrev = commitListURL(repo.FullPath(), v.Rev, v.Query, page-1)
184 }
185 if more {
186 v.CommitNext = commitListURL(repo.FullPath(), v.Rev, v.Query, page+1)
187 }
188 s.render(w, "commits", v)
189}
190
191func (s *Server) commit(w http.ResponseWriter, r *http.Request) {
192 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
193 if !ok {
194 return
195 }
196 sha := r.PathValue("sha")
197 if !safeSHA(sha) {
198 http.NotFound(w, r)
199 return
200 }
201 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
202 c, err := gitrepo.Show(r.Context(), s.Git, dir, sha)
203 if err != nil {
204 http.NotFound(w, r)
205 return
206 }
207 v := s.repoView(w, r, repo, role, c.Subject)
208 v.Page = "commit"
209 v.Wide = true
210 lang := i18n.Parse(v.Lang)
211 rows := s.presentCommits(r.Context(), repo.ID, []gitrepo.Commit{c}, lang)
212 s.attachHeadPipeline(r.Context(), repo, &rows[0], lang)
213 v.Commit = &rows[0]
214 parents, files, err := gitrepo.CommitPatch(r.Context(), s.Git, dir, c.SHA)
215 if err != nil && s.Log != nil {
216 s.Log.Warn("commitdiff", "sha", c.SHA, "err", err)
217 }
218 v.CommitDiff = presentCommitDiff(repo.FullPath(), c.SHA, parents, files)
219 s.render(w, "commit", v)
220}
221
222func (s *Server) mergeRequests(w http.ResponseWriter, r *http.Request) {
223 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
224 if !ok {
225 return
226 }
227 s.absorbMergedMRs(r.Context(), repo)
228 v := s.repoView(w, r, repo, role, "title.mrs")
229 v.Page = "mrs"
230 v.Wide = true
231 all, _ := s.Store.ListMergeRequests(r.Context(), repo.ID)
232 v.Flow = s.flowMRs(r, repo, role, all)
233 s.render(w, "mrs", v)
234}
235
236func (s *Server) createMR(w http.ResponseWriter, r *http.Request) {
237 u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)
238 if !ok || !s.csrfOK(w, r) {
239 return
240 }
241 source := safeRev(r.FormValue("source"), "")
242 target := safeRev(r.FormValue("target"), repo.DefaultBranch)
243 desc := desctpl.Expand(r.FormValue("description"), s.mrVars(r, repo, source, target))
244 mr, err := s.opCreateMR(r.Context(), u, repo, r.FormValue("title"), desc, source, target, r.FormValue("draft") == "1")
245 if err == nil {
246 err = s.Store.SetMergeOptions(r.Context(), mr.ID, r.FormValue("remove_source_branch") == "1", r.FormValue("squash") == "1", r.FormValue("squash_commit_message"))
247 }
248 if !s.uiOK(w, r, repoURL(repo)+"/-/merge-requests", err) {
249 return
250 }
251 num := strconv.FormatInt(mr.Number, 10)
252 s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+num, s.tr(r, "flash.mrOpened"), "")
253}
254
255func (s *Server) showMR(w http.ResponseWriter, r *http.Request) {
256 u, repo, role, ok := s.guard(w, r, access.RoleReadonly)
257 if !ok {
258 return
259 }
260 s.absorbMergedMRs(r.Context(), repo)
261 n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
262 if err != nil {
263 http.NotFound(w, r)
264 return
265 }
266 mr, err := s.Store.MergeRequestByNumber(r.Context(), repo.ID, n)
267 if err != nil {
268 http.NotFound(w, r)
269 return
270 }
271 v := s.repoView(w, r, repo, role, mr.Title)
272 v.Page = "mr"
273 v.MR = &mr
274 v.Wide = true
275 patterns, _ := s.Store.ProtectedPatterns(r.Context(), repo.ID)
276 v.CanComment = role.AtLeast(access.RoleReadonly)
277 v.CanMerge = mr.Status == "open" && role.CanMerge(access.BranchProtected(patterns, mr.TargetBranch))
278 v.CanApply = mr.Status == "open" && role.CanPushBranch(access.BranchProtected(patterns, mr.SourceBranch))
279 v.MergeBlocks = s.mergeBlocks(r, repo, mr)
280 v.CanForce = v.CanMerge && role.CanManageSettings() && len(v.MergeBlocks) > 0
281 s.fillMRPipeline(r, &v, repo, mr)
282 s.fillReviews(r, &v, repo, mr, role)
283 if u.ID != 0 {
284 mine := u.ID == mr.AuthorID || role.CanManageSettings()
285 v.CanClose = mr.Status == "open" && mine
286 v.CanReopen = mr.Status == "closed" && mine
287 }
288 s.finishMR(r, &v, repo, mr, u)
289 s.render(w, "mr", v)
290}
291
292func (s *Server) createNote(w http.ResponseWriter, r *http.Request) {
293 u, repo, _, ok := s.guard(w, r, access.RoleReadonly)
294 if !ok || !s.csrfOK(w, r) {
295 return
296 }
297 n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
298 if err != nil {
299 http.NotFound(w, r)
300 return
301 }
302 back := repoURL(repo) + "/-/merge-requests/" + r.PathValue("number")
303 parent, _ := strconv.ParseInt(r.FormValue("parent"), 10, 64)
304 start, _ := strconv.Atoi(r.FormValue("line_start"))
305 end, _ := strconv.Atoi(r.FormValue("line_end"))
306 if _, err := s.opAddNote(r, u, repo, n, r.FormValue("body"), r.FormValue("path"), start, end, parent); !s.uiOK(w, r, back, err) {
307 return
308 }
309 s.redirect(w, r, back, s.tr(r, "flash.note"), "")
310}
311
312func (s *Server) mergeMR(w http.ResponseWriter, r *http.Request) {
313 u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)
314 if !ok || !s.csrfOK(w, r) {
315 return
316 }
317 n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
318 if err != nil {
319 http.NotFound(w, r)
320 return
321 }
322 back := repoURL(repo) + "/-/merge-requests/" + r.PathValue("number")
323 out, err := s.opMergeMR(r, u, repo, n, formMergeChoice(r))
324 if !s.uiOK(w, r, back, err) {
325 return
326 }
327 notice := s.tr(r, out.Notice)
328 if out.Arg != "" {
329 notice = s.tr(r, out.Notice, out.Arg)
330 }
331 s.redirect(w, r, back, notice, "")
332}
333
334func formMergeChoice(r *http.Request) mergeChoice {
335 remove := r.FormValue("remove_source_branch") == "1"
336 squash := r.FormValue("squash") == "1"
337 message := r.FormValue("squash_commit_message")
338 return mergeChoice{
339 FromForm: true,
340 Remove: &remove,
341 Squash: &squash,
342 Message: &message,
343 Force: r.FormValue("force") == "1",
344 Confirm: r.FormValue("confirm_force") == "1",
345 }
346}
347
348func (s *Server) closeMR(w http.ResponseWriter, r *http.Request) {
349 u, repo, _, ok := s.guard(w, r, access.RoleReadonly)
350 if !ok || !s.csrfOK(w, r) {
351 return
352 }
353 n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
354 if err != nil {
355 http.NotFound(w, r)
356 return
357 }
358 back := repoURL(repo) + "/-/merge-requests/" + r.PathValue("number")
359 if !s.uiOK(w, r, back, s.opCloseMR(r.Context(), u, repo, n, false)) {
360 return
361 }
362 s.redirect(w, r, back, s.tr(r, "flash.closed"), "")
363}
364
365func (s *Server) mrFromRequest(r *http.Request, repoID int64) (store.MergeRequest, error) {
366 n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
367 if err != nil {
368 return store.MergeRequest{}, err
369 }
370 return s.Store.MergeRequestByNumber(r.Context(), repoID, n)
371}
372
373func (s *Server) pipelines(w http.ResponseWriter, r *http.Request) {
374 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
375 if !ok {
376 return
377 }
378 if id := strings.TrimSpace(r.URL.Query().Get("show")); id != "" {
379 if n, err := strconv.ParseInt(id, 10, 64); err == nil && n > 0 {
380 http.Redirect(w, r, repoURL(repo)+"/-/pipelines/"+id, http.StatusSeeOther)
381 return
382 }
383 }
384 v := s.repoView(w, r, repo, role, "title.pipelines")
385 v.Wide = true
386 v.Page = "pipelines"
387 s.fillPipelines(r, &v, repo)
388 if wantsJSON(r) {
389 s.writePipeList(w, v)
390 return
391 }
392 s.render(w, "pipelines", v)
393}
394
395func (s *Server) pipeline(w http.ResponseWriter, r *http.Request) {
396 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
397 if !ok {
398 return
399 }
400 id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
401 if err != nil {
402 http.NotFound(w, r)
403 return
404 }
405 p, err := s.Store.PipelineByID(r.Context(), repo.ID, id)
406 if err != nil {
407 http.NotFound(w, r)
408 return
409 }
410 v := s.repoView(w, r, repo, role, "title.pipeline")
411 v.Wide = true
412 v.Page = "pipelines"
413 v.Pipe = &p
414 jobs, _ := s.Store.JobsByPipeline(r.Context(), p.ID)
415 v.Jobs = jobs
416 ranks := s.queueRanks(r.Context())
417 tr := func(key string, args ...any) string { return s.tr(r, key, args...) }
418 v.PipeStatus = displayStatus(s.pipeStatusFor(p), jobs)
419 if blk, ok := s.protectedBlocker(p); ok {
420 v.PipeWait = tr("pipe.waitingFor", strconv.Quote(blk.Name), blk.PipelineID)
421 }
422 if role.CanWriteCode() {
423 v.PipeCancel = cancelView(tr, tr("pipe.cancelPipeline"), tr("pipe.cancelPipeAsk"), jobs)
424 }
425 v.PipeLabel = tr("pipe." + v.PipeStatus)
426 v.PipeSource = s.pipelineSourceText(r, repo, p)
427 v.PipeJobs = linksFor(jobs, ranks, tr)
428 v.PipeStages = stageViews(jobs, ranks, tr)
429 v.PipeFailed = jobsFailed(jobs)
430 v.Live = jobsLive(p.Status, jobs)
431 v.LiveURL = repoURL(repo) + "/-/pipelines/" + strconv.FormatInt(p.ID, 10)
432 if wantsJSON(r) {
433 s.writePipeDetail(w, v)
434 return
435 }
436 s.render(w, "pipeline", v)
437}
438
439func (s *Server) runPipeline(w http.ResponseWriter, r *http.Request) {
440 u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)
441 if !ok || !s.csrfOK(w, r) {
442 return
443 }
444 if _, err := s.opRunPipeline(r.Context(), u, repo, r.FormValue("ref"), "web"); !s.uiOK(w, r, repoURL(repo)+"/-/pipelines", err) {
445 return
446 }
447 s.redirect(w, r, repoURL(repo)+"/-/pipelines", s.tr(r, "flash.pipeline"), "")
448}
449
450func (s *Server) releases(w http.ResponseWriter, r *http.Request) {
451 _, repo, role, ok := s.guardReleases(w, r)
452 if !ok {
453 return
454 }
455 v := s.repoView(w, r, repo, role, "title.releases")
456 v.Page = "releases"
457 v.Wide = true
458 v.Releases, _ = s.Store.ListReleases(r.Context(), repo.ID)
459 s.render(w, "releases", v)
460}
461
462func (s *Server) createRepo(w http.ResponseWriter, r *http.Request) {
463 u, ok := s.loginRequired(w, r)
464 if !ok || !s.csrfOK(w, r) {
465 return
466 }
467 repo, err := s.opCreateRepo(r.Context(), u, r.FormValue("name"), r.FormValue("description"), r.FormValue("group"), r.FormValue("visibility"), false)
468 if err != nil {
469 if statusOf(err) == http.StatusForbidden {
470 http.Error(w, s.trErr(r, err), http.StatusForbidden)
471 return
472 }
473 s.failCreate(w, r, s.trErr(r, err))
474 return
475 }
476 s.finishCreate(w, r, repoURL(repo), s.tr(r, "flash.repoCreated"))
477}
478
479func (s *Server) createGroup(w http.ResponseWriter, r *http.Request) {
480 u, ok := s.loginRequired(w, r)
481 if !ok || !s.csrfOK(w, r) {
482 return
483 }
484 g, err := s.opCreateGroup(r.Context(), u, r.FormValue("name"), r.FormValue("description"), r.FormValue("default_role"))
485 if err != nil {
486 s.failCreate(w, r, s.trErr(r, err))
487 return
488 }
489 s.finishCreate(w, r, "/groups/"+g.Path, s.tr(r, "flash.groupCreated"))
490}
491
492func toEntries(base string, in []gitrepo.Entry) []EntryRow {
493 var out []EntryRow
494 for _, e := range in {
495 p := e.Name
496 if base != "" {
497 p = base + "/" + e.Name
498 }
499 out = append(out, EntryRow{Name: e.Name, Type: e.Type, Path: p})
500 }
501 return out
502}
503
504func cleanRel(p string) (string, error) {
505 p = strings.TrimPrefix(p, "/")
506 if p == "" || p == "." {
507 return "", nil
508 }
509 if strings.HasPrefix(p, "/") || strings.Contains(p, "\\") || strings.Contains(p, "..") {
510 return "", errBadID
511 }
512 return p, nil
513}
514
515func safeRev(s, fallback string) string {
516 if s == "" {
517 return fallback
518 }
519 if strings.HasPrefix(s, "-") || strings.Contains(s, "..") || strings.ContainsAny(s, " \t\n~^:?*[\\") {
520 return fallback
521 }
522 return s
523}
524
525func safeSHA(s string) bool {
526 if len(s) < 7 || len(s) > 64 {
527 return false
528 }
529 for _, c := range s {
530 if (c < '0' || c > '9') && (c < 'a' || c > 'f') && (c < 'A' || c > 'F') {
531 return false
532 }
533 }
534 return true
535}
536
537// isRepoRootPath: /{owner}/{repo}, met of zonder slash, of /{owner}/{repo}/-.
538func isRepoRootPath(p string, repo store.Repo) bool {
539 t := strings.Trim(p, "/")
540 return t == repo.FullPath() || t == repo.FullPath()+"/-"
541}
542
543// repoRootAlias: /{owner}/{repo}/ en /{owner}/{repo}/- gaan naar de projectpagina
544// (of, release-only, naar Releases via guard). Geen toegang: 404 zoals niet-bestaand.
545func (s *Server) repoRootAlias(w http.ResponseWriter, r *http.Request) {
546 _, repo, _, ok := s.guard(w, r, access.RoleReadonly)
547 if !ok {
548 return
549 }
550 http.Redirect(w, r, "/"+repo.FullPath(), http.StatusSeeOther)
551}