BlueGit

timfa bluegit

Files

bluegit / internal / server / repo_handlers.go

repo_handlers.go

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