BlueGit

timfa bluegit

Files

bluegit / internal / server / repo_handlers.go

repo_handlers.go

repo_handlers.go 14.7 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 && strings.Trim(r.URL.Path, "/") == repo.FullPath() {
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 }
75 return v
76}
77
78func (s *Server) repoHome(w http.ResponseWriter, r *http.Request) {
79 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
80 if !ok {
81 return
82 }
83 v := s.repoView(w, r, repo, role, repo.Name)
84 v.Wide = true
85 s.fillOverview(r, &v, repo)
86 v.Heat = s.heatmap(r.Context(), 0, []int64{repo.ID}, s.langOf(r))
87 s.render(w, "repo", v)
88}
89
90func (s *Server) treeRoot(w http.ResponseWriter, r *http.Request) {
91 r.SetPathValue("path", "")
92 s.tree(w, r)
93}
94
95func (s *Server) tree(w http.ResponseWriter, r *http.Request) {
96 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
97 if !ok {
98 return
99 }
100 rel, err := cleanRel(r.PathValue("path"))
101 if err != nil {
102 http.NotFound(w, r)
103 return
104 }
105 v := s.repoView(w, r, repo, role, rel)
106 v.Wide = true
107 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
108 if _, err := gitrepo.Tree(r.Context(), s.Git, dir, v.Rev, rel); err != nil && rel != "" {
109 http.NotFound(w, r)
110 return
111 }
112 s.fillFiles(r, &v, repo, rel, false)
113 s.render(w, "files", v)
114}
115
116func (s *Server) blob(w http.ResponseWriter, r *http.Request) {
117 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
118 if !ok {
119 return
120 }
121 rel, err := cleanRel(r.PathValue("path"))
122 if err != nil || rel == "" {
123 http.NotFound(w, r)
124 return
125 }
126 v := s.repoView(w, r, repo, role, rel)
127 v.Wide = true
128 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
129 if _, _, err := gitrepo.Blob(r.Context(), s.Git, dir, v.Rev, rel, 1); err != nil {
130 http.NotFound(w, r)
131 return
132 }
133 s.fillFiles(r, &v, repo, rel, true)
134 s.render(w, "files", v)
135}
136
137func (s *Server) commits(w http.ResponseWriter, r *http.Request) {
138 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
139 if !ok {
140 return
141 }
142 v := s.repoView(w, r, repo, role, "title.commits")
143 v.Page = "commits"
144 v.Wide = true
145 v.Query = clipQuery(r.URL.Query().Get("q"))
146 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
147 s.branchList(r, &v, repo)
148 page := commitPageNum(r.URL.Query().Get("page"))
149 list, more := s.commitWindow(r.Context(), dir, v.Rev, v.Query, (page-1)*commitPageSize, commitPageSize)
150 lang := i18n.Parse(v.Lang)
151 rows := s.presentCommits(r.Context(), repo.ID, list, lang)
152 for i := range rows {
153 s.attachHeadPipeline(r.Context(), repo, &rows[i], lang)
154 }
155 v.Commits = rows
156 v.CommitDays = groupCommitDays(rows, lang)
157 if page > 1 {
158 v.CommitPrev = commitListURL(repo.FullPath(), v.Rev, v.Query, page-1)
159 }
160 if more {
161 v.CommitNext = commitListURL(repo.FullPath(), v.Rev, v.Query, page+1)
162 }
163 s.render(w, "commits", v)
164}
165
166func (s *Server) commit(w http.ResponseWriter, r *http.Request) {
167 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
168 if !ok {
169 return
170 }
171 sha := r.PathValue("sha")
172 if !safeSHA(sha) {
173 http.NotFound(w, r)
174 return
175 }
176 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
177 c, err := gitrepo.Show(r.Context(), s.Git, dir, sha)
178 if err != nil {
179 http.NotFound(w, r)
180 return
181 }
182 v := s.repoView(w, r, repo, role, c.Subject)
183 v.Page = "commit"
184 v.Wide = true
185 lang := i18n.Parse(v.Lang)
186 rows := s.presentCommits(r.Context(), repo.ID, []gitrepo.Commit{c}, lang)
187 s.attachHeadPipeline(r.Context(), repo, &rows[0], lang)
188 v.Commit = &rows[0]
189 parents, files, err := gitrepo.CommitPatch(r.Context(), s.Git, dir, c.SHA)
190 if err != nil && s.Log != nil {
191 s.Log.Warn("commitdiff", "sha", c.SHA, "err", err)
192 }
193 v.CommitDiff = presentCommitDiff(repo.FullPath(), c.SHA, parents, files)
194 s.render(w, "commit", v)
195}
196
197func (s *Server) mergeRequests(w http.ResponseWriter, r *http.Request) {
198 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
199 if !ok {
200 return
201 }
202 s.absorbMergedMRs(r.Context(), repo)
203 v := s.repoView(w, r, repo, role, "title.mrs")
204 v.Page = "mrs"
205 v.Wide = true
206 all, _ := s.Store.ListMergeRequests(r.Context(), repo.ID)
207 v.Flow = s.flowMRs(r, repo, role, all)
208 s.render(w, "mrs", v)
209}
210
211func (s *Server) createMR(w http.ResponseWriter, r *http.Request) {
212 u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)
213 if !ok || !s.csrfOK(w, r) {
214 return
215 }
216 source := safeRev(r.FormValue("source"), "")
217 target := safeRev(r.FormValue("target"), repo.DefaultBranch)
218 desc := desctpl.Expand(r.FormValue("description"), s.mrVars(r, repo, source, target))
219 mr, err := s.opCreateMR(r.Context(), u, repo, r.FormValue("title"), desc, source, target, r.FormValue("draft") == "1")
220 if err == nil {
221 err = s.Store.SetMergeOptions(r.Context(), mr.ID, r.FormValue("remove_source_branch") == "1", r.FormValue("squash") == "1", r.FormValue("squash_commit_message"))
222 }
223 if !s.uiOK(w, r, repoURL(repo)+"/-/merge-requests", err) {
224 return
225 }
226 num := strconv.FormatInt(mr.Number, 10)
227 s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+num, s.tr(r, "flash.mrOpened"), "")
228}
229
230func (s *Server) showMR(w http.ResponseWriter, r *http.Request) {
231 u, repo, role, ok := s.guard(w, r, access.RoleReadonly)
232 if !ok {
233 return
234 }
235 s.absorbMergedMRs(r.Context(), repo)
236 n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
237 if err != nil {
238 http.NotFound(w, r)
239 return
240 }
241 mr, err := s.Store.MergeRequestByNumber(r.Context(), repo.ID, n)
242 if err != nil {
243 http.NotFound(w, r)
244 return
245 }
246 v := s.repoView(w, r, repo, role, mr.Title)
247 v.Page = "mr"
248 v.MR = &mr
249 v.Wide = true
250 patterns, _ := s.Store.ProtectedPatterns(r.Context(), repo.ID)
251 v.CanComment = role.AtLeast(access.RoleReadonly)
252 v.CanMerge = mr.Status == "open" && role.CanMerge(access.BranchProtected(patterns, mr.TargetBranch))
253 v.CanApply = mr.Status == "open" && role.CanPushBranch(access.BranchProtected(patterns, mr.SourceBranch))
254 v.MergeBlocks = s.mergeBlocks(r, repo, mr)
255 v.CanForce = v.CanMerge && role.CanManageSettings() && len(v.MergeBlocks) > 0
256 s.fillMRPipeline(r, &v, repo, mr)
257 s.fillReviews(r, &v, repo, mr, role)
258 if u.ID != 0 {
259 mine := u.ID == mr.AuthorID || role.CanManageSettings()
260 v.CanClose = mr.Status == "open" && mine
261 v.CanReopen = mr.Status == "closed" && mine
262 }
263 s.finishMR(r, &v, repo, mr, u)
264 s.render(w, "mr", v)
265}
266
267func (s *Server) createNote(w http.ResponseWriter, r *http.Request) {
268 u, repo, _, ok := s.guard(w, r, access.RoleReadonly)
269 if !ok || !s.csrfOK(w, r) {
270 return
271 }
272 n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
273 if err != nil {
274 http.NotFound(w, r)
275 return
276 }
277 back := repoURL(repo) + "/-/merge-requests/" + r.PathValue("number")
278 parent, _ := strconv.ParseInt(r.FormValue("parent"), 10, 64)
279 start, _ := strconv.Atoi(r.FormValue("line_start"))
280 end, _ := strconv.Atoi(r.FormValue("line_end"))
281 if _, err := s.opAddNote(r, u, repo, n, r.FormValue("body"), r.FormValue("path"), start, end, parent); !s.uiOK(w, r, back, err) {
282 return
283 }
284 s.redirect(w, r, back, s.tr(r, "flash.note"), "")
285}
286
287func (s *Server) mergeMR(w http.ResponseWriter, r *http.Request) {
288 u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)
289 if !ok || !s.csrfOK(w, r) {
290 return
291 }
292 n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
293 if err != nil {
294 http.NotFound(w, r)
295 return
296 }
297 back := repoURL(repo) + "/-/merge-requests/" + r.PathValue("number")
298 out, err := s.opMergeMR(r, u, repo, n, formMergeChoice(r))
299 if !s.uiOK(w, r, back, err) {
300 return
301 }
302 notice := s.tr(r, out.Notice)
303 if out.Arg != "" {
304 notice = s.tr(r, out.Notice, out.Arg)
305 }
306 s.redirect(w, r, back, notice, "")
307}
308
309func formMergeChoice(r *http.Request) mergeChoice {
310 remove := r.FormValue("remove_source_branch") == "1"
311 squash := r.FormValue("squash") == "1"
312 message := r.FormValue("squash_commit_message")
313 return mergeChoice{
314 FromForm: true,
315 Remove: &remove,
316 Squash: &squash,
317 Message: &message,
318 Force: r.FormValue("force") == "1",
319 Confirm: r.FormValue("confirm_force") == "1",
320 }
321}
322
323func (s *Server) closeMR(w http.ResponseWriter, r *http.Request) {
324 u, repo, _, ok := s.guard(w, r, access.RoleReadonly)
325 if !ok || !s.csrfOK(w, r) {
326 return
327 }
328 n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
329 if err != nil {
330 http.NotFound(w, r)
331 return
332 }
333 back := repoURL(repo) + "/-/merge-requests/" + r.PathValue("number")
334 if !s.uiOK(w, r, back, s.opCloseMR(r.Context(), u, repo, n, false)) {
335 return
336 }
337 s.redirect(w, r, back, s.tr(r, "flash.closed"), "")
338}
339
340func (s *Server) mrFromRequest(r *http.Request, repoID int64) (store.MergeRequest, error) {
341 n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
342 if err != nil {
343 return store.MergeRequest{}, err
344 }
345 return s.Store.MergeRequestByNumber(r.Context(), repoID, n)
346}
347
348func (s *Server) pipelines(w http.ResponseWriter, r *http.Request) {
349 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
350 if !ok {
351 return
352 }
353 if id := strings.TrimSpace(r.URL.Query().Get("show")); id != "" {
354 if n, err := strconv.ParseInt(id, 10, 64); err == nil && n > 0 {
355 http.Redirect(w, r, repoURL(repo)+"/-/pipelines/"+id, http.StatusSeeOther)
356 return
357 }
358 }
359 v := s.repoView(w, r, repo, role, "title.pipelines")
360 v.Wide = true
361 v.Page = "pipelines"
362 s.fillPipelines(r, &v, repo)
363 if wantsJSON(r) {
364 s.writePipeList(w, v)
365 return
366 }
367 s.render(w, "pipelines", v)
368}
369
370func (s *Server) pipeline(w http.ResponseWriter, r *http.Request) {
371 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
372 if !ok {
373 return
374 }
375 id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
376 if err != nil {
377 http.NotFound(w, r)
378 return
379 }
380 p, err := s.Store.PipelineByID(r.Context(), repo.ID, id)
381 if err != nil {
382 http.NotFound(w, r)
383 return
384 }
385 v := s.repoView(w, r, repo, role, "title.pipeline")
386 v.Wide = true
387 v.Page = "pipelines"
388 v.Pipe = &p
389 jobs, _ := s.Store.JobsByPipeline(r.Context(), p.ID)
390 v.Jobs = jobs
391 ranks := s.queueRanks(r.Context())
392 tr := func(key string, args ...any) string { return s.tr(r, key, args...) }
393 v.PipeStatus = displayStatus(p.Status, jobs)
394 v.PipeLabel = tr("pipe." + v.PipeStatus)
395 v.PipeSource = s.pipelineSourceText(r, repo, p)
396 v.PipeJobs = linksFor(jobs, ranks, tr)
397 v.PipeStages = stageViews(jobs, ranks, tr)
398 v.PipeFailed = jobsFailed(jobs)
399 v.Live = jobsLive(p.Status, jobs)
400 v.LiveURL = repoURL(repo) + "/-/pipelines/" + strconv.FormatInt(p.ID, 10)
401 if wantsJSON(r) {
402 s.writePipeDetail(w, v)
403 return
404 }
405 s.render(w, "pipeline", v)
406}
407
408func (s *Server) runPipeline(w http.ResponseWriter, r *http.Request) {
409 u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)
410 if !ok || !s.csrfOK(w, r) {
411 return
412 }
413 if _, err := s.opRunPipeline(r.Context(), u, repo, r.FormValue("ref"), "web"); !s.uiOK(w, r, repoURL(repo)+"/-/pipelines", err) {
414 return
415 }
416 s.redirect(w, r, repoURL(repo)+"/-/pipelines", s.tr(r, "flash.pipeline"), "")
417}
418
419func (s *Server) releases(w http.ResponseWriter, r *http.Request) {
420 _, repo, role, ok := s.guardReleases(w, r)
421 if !ok {
422 return
423 }
424 v := s.repoView(w, r, repo, role, "title.releases")
425 v.Page = "releases"
426 v.Wide = true
427 v.Releases, _ = s.Store.ListReleases(r.Context(), repo.ID)
428 s.render(w, "releases", v)
429}
430
431func (s *Server) createRepo(w http.ResponseWriter, r *http.Request) {
432 u, ok := s.loginRequired(w, r)
433 if !ok || !s.csrfOK(w, r) {
434 return
435 }
436 repo, err := s.opCreateRepo(r.Context(), u, r.FormValue("name"), r.FormValue("description"), r.FormValue("group"), r.FormValue("visibility"), false)
437 if err != nil {
438 if statusOf(err) == http.StatusForbidden {
439 http.Error(w, s.trErr(r, err), http.StatusForbidden)
440 return
441 }
442 s.failCreate(w, r, s.trErr(r, err))
443 return
444 }
445 s.finishCreate(w, r, repoURL(repo), s.tr(r, "flash.repoCreated"))
446}
447
448func (s *Server) createGroup(w http.ResponseWriter, r *http.Request) {
449 u, ok := s.loginRequired(w, r)
450 if !ok || !s.csrfOK(w, r) {
451 return
452 }
453 g, err := s.opCreateGroup(r.Context(), u, r.FormValue("name"), r.FormValue("description"), r.FormValue("default_role"))
454 if err != nil {
455 s.failCreate(w, r, s.trErr(r, err))
456 return
457 }
458 s.finishCreate(w, r, "/groups/"+g.Path, s.tr(r, "flash.groupCreated"))
459}
460
461func toEntries(base string, in []gitrepo.Entry) []EntryRow {
462 var out []EntryRow
463 for _, e := range in {
464 p := e.Name
465 if base != "" {
466 p = base + "/" + e.Name
467 }
468 out = append(out, EntryRow{Name: e.Name, Type: e.Type, Path: p})
469 }
470 return out
471}
472
473func cleanRel(p string) (string, error) {
474 p = strings.TrimPrefix(p, "/")
475 if p == "" || p == "." {
476 return "", nil
477 }
478 if strings.HasPrefix(p, "/") || strings.Contains(p, "\\") || strings.Contains(p, "..") {
479 return "", errBadID
480 }
481 return p, nil
482}
483
484func safeRev(s, fallback string) string {
485 if s == "" {
486 return fallback
487 }
488 if strings.HasPrefix(s, "-") || strings.Contains(s, "..") || strings.ContainsAny(s, " \t\n~^:?*[\\") {
489 return fallback
490 }
491 return s
492}
493
494func safeSHA(s string) bool {
495 if len(s) < 7 || len(s) > 64 {
496 return false
497 }
498 for _, c := range s {
499 if (c < '0' || c > '9') && (c < 'a' || c > 'f') && (c < 'A' || c > 'F') {
500 return false
501 }
502 }
503 return true
504}