BlueGit

timfa bluegit

Files

bluegit / internal / server / repo_handlers.go

repo_handlers.go

feat: projectpagina met overzicht en bestanden
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 4 weeks ago
Failed ea0d24ce History
repo_handlers.go 13.8 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/gitrepo"
10 "gitlab.com/Timfa/bluegit/internal/names"
11 "gitlab.com/Timfa/bluegit/internal/store"
12)
13
14func (s *Server) guard(w http.ResponseWriter, r *http.Request, min access.Role) (store.User, store.Repo, access.Role, bool) {
15 owner := r.PathValue("owner")
16 name := strings.TrimSuffix(r.PathValue("repo"), ".git")
17 repo, err := s.Store.RepoByPath(r.Context(), owner, name)
18 if err != nil {
19 http.NotFound(w, r)
20 return store.User{}, store.Repo{}, "", false
21 }
22 p := s.who(r)
23 var role access.Role
24 if p.OK {
25 role, err = s.Store.EffectiveRole(r.Context(), p.User.ID, repo.ID)
26 if err != nil {
27 http.Error(w, "rechten", http.StatusInternalServerError)
28 return store.User{}, store.Repo{}, "", false
29 }
30 }
31 readable := role.CanRead() || repo.Visibility == "public"
32 if !readable {
33 if p.OK {
34 http.Error(w, "geen toegang", http.StatusForbidden)
35 } else {
36 http.NotFound(w, r)
37 }
38 return store.User{}, store.Repo{}, "", false
39 }
40 if min != access.RoleReadonly && !role.AtLeast(min) {
41 http.Error(w, "geen toegang", http.StatusForbidden)
42 return store.User{}, store.Repo{}, "", false
43 }
44 return p.User, repo, role, true
45}
46
47func (s *Server) repoView(w http.ResponseWriter, r *http.Request, repo store.Repo, role access.Role, title string) View {
48 v := s.view(w, r, title)
49 v.Repo = &repo
50 v.Role = role
51 v.CanWrite = role.CanWriteCode()
52 v.CanAdmin = role.CanManageSettings()
53 v.Rev = safeRev(r.URL.Query().Get("rev"), repo.DefaultBranch)
54 v.CloneHTTP = strings.TrimRight(s.Cfg.BaseURL, "/") + "/" + repo.FullPath() + ".git"
55 v.CloneSSH = s.Cfg.CloneSSH(repo.FullPath())
56 return v
57}
58
59func (s *Server) repoHome(w http.ResponseWriter, r *http.Request) {
60 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
61 if !ok {
62 return
63 }
64 v := s.repoView(w, r, repo, role, repo.Name)
65 v.Wide = true
66 s.fillOverview(r, &v, repo)
67 s.render(w, "repo", v)
68}
69
70func (s *Server) treeRoot(w http.ResponseWriter, r *http.Request) {
71 r.SetPathValue("path", "")
72 s.tree(w, r)
73}
74
75func (s *Server) tree(w http.ResponseWriter, r *http.Request) {
76 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
77 if !ok {
78 return
79 }
80 rel, err := cleanRel(r.PathValue("path"))
81 if err != nil {
82 http.NotFound(w, r)
83 return
84 }
85 v := s.repoView(w, r, repo, role, rel)
86 v.Wide = true
87 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
88 if _, err := gitrepo.Tree(r.Context(), s.Git, dir, v.Rev, rel); err != nil && rel != "" {
89 http.NotFound(w, r)
90 return
91 }
92 s.fillFiles(r, &v, repo, rel, false)
93 s.render(w, "files", v)
94}
95
96func (s *Server) blob(w http.ResponseWriter, r *http.Request) {
97 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
98 if !ok {
99 return
100 }
101 rel, err := cleanRel(r.PathValue("path"))
102 if err != nil || rel == "" {
103 http.NotFound(w, r)
104 return
105 }
106 v := s.repoView(w, r, repo, role, rel)
107 v.Wide = true
108 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
109 if _, _, err := gitrepo.Blob(r.Context(), s.Git, dir, v.Rev, rel, 1); err != nil {
110 http.NotFound(w, r)
111 return
112 }
113 s.fillFiles(r, &v, repo, rel, true)
114 s.render(w, "files", v)
115}
116
117func (s *Server) commits(w http.ResponseWriter, r *http.Request) {
118 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
119 if !ok {
120 return
121 }
122 v := s.repoView(w, r, repo, role, "Commits")
123 v.Page = "commits"
124 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
125 list, _ := gitrepo.Log(r.Context(), s.Git, dir, v.Rev, 50)
126 v.Commits = toCommits(list)
127 s.render(w, "commits", v)
128}
129
130func (s *Server) commit(w http.ResponseWriter, r *http.Request) {
131 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
132 if !ok {
133 return
134 }
135 sha := r.PathValue("sha")
136 if !safeSHA(sha) {
137 http.NotFound(w, r)
138 return
139 }
140 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
141 c, err := gitrepo.Show(r.Context(), s.Git, dir, sha)
142 if err != nil {
143 http.NotFound(w, r)
144 return
145 }
146 v := s.repoView(w, r, repo, role, c.Subject)
147 row := toCommits([]gitrepo.Commit{c})[0]
148 v.Commit = &row
149 s.render(w, "commit", v)
150}
151
152func (s *Server) branches(w http.ResponseWriter, r *http.Request) {
153 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
154 if !ok {
155 return
156 }
157 v := s.repoView(w, r, repo, role, "Branches")
158 v.Page = "branches"
159 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
160 names, _ := gitrepo.Branches(r.Context(), s.Git, dir)
161 patterns, _ := s.Store.ProtectedPatterns(r.Context(), repo.ID)
162 for _, name := range names {
163 v.Branches = append(v.Branches, BranchRow{Name: name, Protected: access.BranchProtected(patterns, name)})
164 }
165 s.render(w, "branches", v)
166}
167
168func (s *Server) mergeRequests(w http.ResponseWriter, r *http.Request) {
169 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
170 if !ok {
171 return
172 }
173 v := s.repoView(w, r, repo, role, "Merge requests")
174 v.Page = "mrs"
175 v.MRs, _ = s.Store.ListMergeRequests(r.Context(), repo.ID)
176 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
177 names, _ := gitrepo.Branches(r.Context(), s.Git, dir)
178 for _, name := range names {
179 v.Branches = append(v.Branches, BranchRow{Name: name})
180 }
181 s.render(w, "mrs", v)
182}
183
184func (s *Server) createMR(w http.ResponseWriter, r *http.Request) {
185 u, repo, role, ok := s.guard(w, r, access.RoleDeveloper)
186 if !ok || !s.csrfOK(w, r) {
187 return
188 }
189 if !role.CanWriteCode() {
190 http.Error(w, "geen toegang", http.StatusForbidden)
191 return
192 }
193 source := safeRev(r.FormValue("source"), "")
194 target := safeRev(r.FormValue("target"), repo.DefaultBranch)
195 if source == "" || source == target {
196 s.redirect(w, r, repoURL(repo)+"/-/merge-requests", "", "kies twee verschillende branches")
197 return
198 }
199 mr, err := s.Store.CreateMergeRequest(r.Context(), repo.ID, u.ID, r.FormValue("title"), r.FormValue("description"), source, target)
200 if err != nil {
201 s.redirect(w, r, repoURL(repo)+"/-/merge-requests", "", err.Error())
202 return
203 }
204 s.Dispatch(repo.ID, pushEvent(repo, "merge_request", target, "", u.Username, "merge request !"+strconv.FormatInt(mr.Number, 10)+" geopend: "+mr.Title, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10)))
205 s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10), "Merge request geopend", "")
206}
207
208func (s *Server) showMR(w http.ResponseWriter, r *http.Request) {
209 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
210 if !ok {
211 return
212 }
213 n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
214 if err != nil {
215 http.NotFound(w, r)
216 return
217 }
218 mr, err := s.Store.MergeRequestByNumber(r.Context(), repo.ID, n)
219 if err != nil {
220 http.NotFound(w, r)
221 return
222 }
223 v := s.repoView(w, r, repo, role, mr.Title)
224 v.MR = &mr
225 patterns, _ := s.Store.ProtectedPatterns(r.Context(), repo.ID)
226 v.CanMerge = mr.Status == "open" && role.CanMerge(access.BranchProtected(patterns, mr.TargetBranch))
227 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
228 diff, err := gitrepo.DiffStat(r.Context(), s.Git, dir, mr.TargetBranch, mr.SourceBranch)
229 if err == nil {
230 v.Diff = diff
231 }
232 s.render(w, "mr", v)
233}
234
235func (s *Server) mergeMR(w http.ResponseWriter, r *http.Request) {
236 u, repo, role, ok := s.guard(w, r, access.RoleDeveloper)
237 if !ok || !s.csrfOK(w, r) {
238 return
239 }
240 mr, err := s.mrFromRequest(r, repo.ID)
241 if err != nil || mr.Status != "open" {
242 http.NotFound(w, r)
243 return
244 }
245 patterns, _ := s.Store.ProtectedPatterns(r.Context(), repo.ID)
246 if !role.CanMerge(access.BranchProtected(patterns, mr.TargetBranch)) {
247 http.Error(w, "geen toegang tot de doelbranch", http.StatusForbidden)
248 return
249 }
250 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
251 before, _ := gitrepo.Refs(r.Context(), s.Git, dir)
252 work := s.StoragePath() + "/tmp/merge-" + strconv.FormatInt(mr.ID, 10)
253 email := u.Username + "@users.git.timfalken.com"
254 msg := "Merge branch '" + mr.SourceBranch + "' into '" + mr.TargetBranch + "'"
255 if err := gitrepo.Merge(r.Context(), s.Git, dir, work, mr.SourceBranch, mr.TargetBranch, u.Username, email, msg, role, patterns); err != nil {
256 s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10), "", err.Error())
257 return
258 }
259 _ = s.Store.SetMergeRequestStatus(r.Context(), mr.ID, "merged")
260 after, _ := gitrepo.Refs(r.Context(), s.Git, dir)
261 s.AfterPush(repo, u, before, after)
262 s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10), "Samengevoegd", "")
263}
264
265func (s *Server) closeMR(w http.ResponseWriter, r *http.Request) {
266 u, repo, role, ok := s.guard(w, r, access.RoleDeveloper)
267 if !ok || !s.csrfOK(w, r) {
268 return
269 }
270 mr, err := s.mrFromRequest(r, repo.ID)
271 if err != nil {
272 http.NotFound(w, r)
273 return
274 }
275 if mr.AuthorID != u.ID && !role.CanManageSettings() {
276 http.Error(w, "geen toegang", http.StatusForbidden)
277 return
278 }
279 _ = s.Store.SetMergeRequestStatus(r.Context(), mr.ID, "closed")
280 s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10), "Gesloten", "")
281}
282
283func (s *Server) mrFromRequest(r *http.Request, repoID int64) (store.MergeRequest, error) {
284 n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
285 if err != nil {
286 return store.MergeRequest{}, err
287 }
288 return s.Store.MergeRequestByNumber(r.Context(), repoID, n)
289}
290
291func (s *Server) pipelines(w http.ResponseWriter, r *http.Request) {
292 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
293 if !ok {
294 return
295 }
296 v := s.repoView(w, r, repo, role, "Pipelines")
297 v.Pipes, _ = s.Store.ListPipelines(r.Context(), repo.ID)
298 s.render(w, "pipelines", v)
299}
300
301func (s *Server) pipeline(w http.ResponseWriter, r *http.Request) {
302 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
303 if !ok {
304 return
305 }
306 id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
307 if err != nil {
308 http.NotFound(w, r)
309 return
310 }
311 p, err := s.Store.PipelineByID(r.Context(), repo.ID, id)
312 if err != nil {
313 http.NotFound(w, r)
314 return
315 }
316 v := s.repoView(w, r, repo, role, "Pipeline")
317 v.Pipe = &p
318 v.Jobs, _ = s.Store.JobsByPipeline(r.Context(), p.ID)
319 s.render(w, "pipeline", v)
320}
321
322func (s *Server) runPipeline(w http.ResponseWriter, r *http.Request) {
323 u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)
324 if !ok || !s.csrfOK(w, r) {
325 return
326 }
327 ref := safeRev(r.FormValue("ref"), repo.DefaultBranch)
328 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
329 shaOut, err := gitSHA(r, s.Git, dir, ref)
330 if err != nil {
331 s.redirect(w, r, repoURL(repo)+"/-/pipelines", "", "branch niet gevonden")
332 return
333 }
334 s.startPipeline(r.Context(), repo, shaOut, "refs/heads/"+ref, u.Username)
335 s.redirect(w, r, repoURL(repo)+"/-/pipelines", "Pipeline gestart", "")
336}
337
338func (s *Server) releases(w http.ResponseWriter, r *http.Request) {
339 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
340 if !ok {
341 return
342 }
343 v := s.repoView(w, r, repo, role, "Releases")
344 v.Releases, _ = s.Store.ListReleases(r.Context(), repo.ID)
345 s.render(w, "releases", v)
346}
347
348func (s *Server) createRepo(w http.ResponseWriter, r *http.Request) {
349 u, ok := s.loginRequired(w, r)
350 if !ok || !s.csrfOK(w, r) {
351 return
352 }
353 if s.StoragePath() == "" {
354 s.redirect(w, r, "/", "", strings.TrimSpace(noStorageMsg))
355 return
356 }
357 name, err := names.Slug("repo", r.FormValue("name"))
358 if err != nil {
359 s.redirect(w, r, "/new", "", "Deze naam kan niet.")
360 return
361 }
362 ownerKind := "user"
363 ownerID := u.ID
364 if gpath := strings.TrimSpace(r.FormValue("group")); gpath != "" {
365 g, err := s.Store.GroupByPath(r.Context(), gpath)
366 if err != nil {
367 s.redirect(w, r, "/new", "", "groep niet gevonden")
368 return
369 }
370 role, err := s.Store.GroupRole(r.Context(), g.ID, u.ID)
371 if err != nil || !role.CanManageSettings() {
372 http.Error(w, "geen toegang", http.StatusForbidden)
373 return
374 }
375 ownerKind, ownerID = "group", g.ID
376 }
377 vis := r.FormValue("visibility")
378 if vis != "public" {
379 vis = "private"
380 }
381 repo, err := s.Store.CreateRepo(r.Context(), ownerKind, ownerID, name, r.FormValue("description"), s.Cfg.Git.DefaultBranch, vis)
382 if err != nil {
383 s.redirect(w, r, "/new", "", err.Error())
384 return
385 }
386 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
387 if err := gitrepo.Init(s.Git, dir, repo.DefaultBranch, s.HookBin); err != nil {
388 _ = s.Store.DeleteRepo(r.Context(), repo.ID)
389 s.redirect(w, r, "/new", "", "git init: "+err.Error())
390 return
391 }
392 s.redirect(w, r, repoURL(repo), "Repository aangemaakt", "")
393}
394
395func (s *Server) createGroup(w http.ResponseWriter, r *http.Request) {
396 u, ok := s.loginRequired(w, r)
397 if !ok || !s.csrfOK(w, r) {
398 return
399 }
400 display := strings.TrimSpace(r.FormValue("name"))
401 path, err := names.Slug("group", display)
402 if err != nil {
403 s.redirect(w, r, "/new", "", "Deze naam kan niet.")
404 return
405 }
406 g, err := s.Store.CreateGroup(r.Context(), u.ID, display, path, r.FormValue("description"))
407 if err != nil {
408 s.redirect(w, r, "/new", "", err.Error())
409 return
410 }
411 s.redirect(w, r, "/groups/"+g.Path, "Groep aangemaakt", "")
412}
413
414func toCommits(in []gitrepo.Commit) []CommitRow {
415 var out []CommitRow
416 for _, c := range in {
417 out = append(out, CommitRow{SHA: c.SHA, Short: c.Short, Author: c.Author, Date: c.Date, Subject: c.Subject, Body: c.Body})
418 }
419 return out
420}
421
422func toEntries(base string, in []gitrepo.Entry) []EntryRow {
423 var out []EntryRow
424 for _, e := range in {
425 p := e.Name
426 if base != "" {
427 p = base + "/" + e.Name
428 }
429 out = append(out, EntryRow{Name: e.Name, Type: e.Type, Path: p})
430 }
431 return out
432}
433
434func cleanRel(p string) (string, error) {
435 p = strings.TrimPrefix(p, "/")
436 if p == "" || p == "." {
437 return "", nil
438 }
439 if strings.HasPrefix(p, "/") || strings.Contains(p, "\\") || strings.Contains(p, "..") {
440 return "", errBadID
441 }
442 return p, nil
443}
444
445func safeRev(s, fallback string) string {
446 if s == "" {
447 return fallback
448 }
449 if strings.HasPrefix(s, "-") || strings.Contains(s, "..") || strings.ContainsAny(s, " \t\n~^:?*[\\") {
450 return fallback
451 }
452 return s
453}
454
455func safeSHA(s string) bool {
456 if len(s) < 7 || len(s) > 64 {
457 return false
458 }
459 for _, c := range s {
460 if (c < '0' || c > '9') && (c < 'a' || c > 'f') && (c < 'A' || c > 'F') {
461 return false
462 }
463 }
464 return true
465}