BlueGit

timfa bluegit

Files

bluegit / internal / server / repo_handlers.go

repo_handlers.go

fix: installatiebeheerder ziet andermans gegevens niet
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 4 weeks ago
77270b74 History
repo_handlers.go 13.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/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.FullPath())
65 dir := gitrepo.Dir(s.Cfg.StoragePath, repo.OwnerPath, repo.Name)
66 commits, _ := gitrepo.Log(r.Context(), s.Git, dir, v.Rev, 8)
67 v.Commits = toCommits(commits)
68 entries, err := gitrepo.Tree(r.Context(), s.Git, dir, v.Rev, "")
69 if err == nil {
70 v.Entries = toEntries("", entries)
71 }
72 s.render(w, "repo", v)
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 dir := gitrepo.Dir(s.Cfg.StoragePath, repo.OwnerPath, repo.Name)
87 entries, err := gitrepo.Tree(r.Context(), s.Git, dir, v.Rev, rel)
88 if err != nil {
89 http.NotFound(w, r)
90 return
91 }
92 v.TreePath = rel
93 v.Entries = toEntries(rel, entries)
94 s.render(w, "tree", v)
95}
96
97func (s *Server) blob(w http.ResponseWriter, r *http.Request) {
98 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
99 if !ok {
100 return
101 }
102 rel, err := cleanRel(r.PathValue("path"))
103 if err != nil || rel == "" {
104 http.NotFound(w, r)
105 return
106 }
107 v := s.repoView(w, r, repo, role, rel)
108 dir := gitrepo.Dir(s.Cfg.StoragePath, repo.OwnerPath, repo.Name)
109 text, binary, err := gitrepo.Blob(r.Context(), s.Git, dir, v.Rev, rel, 200_000)
110 if err != nil {
111 http.NotFound(w, r)
112 return
113 }
114 v.BlobPath = rel
115 v.Blob = text
116 v.Binary = binary
117 s.render(w, "blob", v)
118}
119
120func (s *Server) commits(w http.ResponseWriter, r *http.Request) {
121 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
122 if !ok {
123 return
124 }
125 v := s.repoView(w, r, repo, role, "Commits")
126 dir := gitrepo.Dir(s.Cfg.StoragePath, repo.OwnerPath, repo.Name)
127 list, _ := gitrepo.Log(r.Context(), s.Git, dir, v.Rev, 50)
128 v.Commits = toCommits(list)
129 s.render(w, "commits", v)
130}
131
132func (s *Server) commit(w http.ResponseWriter, r *http.Request) {
133 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
134 if !ok {
135 return
136 }
137 sha := r.PathValue("sha")
138 if !safeSHA(sha) {
139 http.NotFound(w, r)
140 return
141 }
142 dir := gitrepo.Dir(s.Cfg.StoragePath, repo.OwnerPath, repo.Name)
143 c, err := gitrepo.Show(r.Context(), s.Git, dir, sha)
144 if err != nil {
145 http.NotFound(w, r)
146 return
147 }
148 v := s.repoView(w, r, repo, role, c.Subject)
149 row := toCommits([]gitrepo.Commit{c})[0]
150 v.Commit = &row
151 s.render(w, "commit", v)
152}
153
154func (s *Server) branches(w http.ResponseWriter, r *http.Request) {
155 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
156 if !ok {
157 return
158 }
159 v := s.repoView(w, r, repo, role, "Branches")
160 dir := gitrepo.Dir(s.Cfg.StoragePath, repo.OwnerPath, repo.Name)
161 names, _ := gitrepo.Branches(r.Context(), s.Git, dir)
162 patterns, _ := s.Store.ProtectedPatterns(r.Context(), repo.ID)
163 for _, name := range names {
164 v.Branches = append(v.Branches, BranchRow{Name: name, Protected: access.BranchProtected(patterns, name)})
165 }
166 s.render(w, "branches", v)
167}
168
169func (s *Server) mergeRequests(w http.ResponseWriter, r *http.Request) {
170 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
171 if !ok {
172 return
173 }
174 v := s.repoView(w, r, repo, role, "Merge requests")
175 v.MRs, _ = s.Store.ListMergeRequests(r.Context(), repo.ID)
176 dir := gitrepo.Dir(s.Cfg.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.Cfg.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.Cfg.StoragePath, repo.OwnerPath, repo.Name)
251 before, _ := gitrepo.Refs(r.Context(), s.Git, dir)
252 work := s.Cfg.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.Cfg.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 als er een blue-ci-cd.yml is", "")
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 name := strings.TrimSpace(r.FormValue("name"))
354 if err := names.ValidRepoName(name); err != nil {
355 s.redirect(w, r, "/new", "", err.Error())
356 return
357 }
358 ownerKind := "user"
359 ownerID := u.ID
360 if gpath := strings.TrimSpace(r.FormValue("group")); gpath != "" {
361 g, err := s.Store.GroupByPath(r.Context(), gpath)
362 if err != nil {
363 s.redirect(w, r, "/new", "", "groep niet gevonden")
364 return
365 }
366 role, err := s.Store.GroupRole(r.Context(), g.ID, u.ID)
367 if err != nil || !role.CanManageSettings() {
368 http.Error(w, "geen toegang", http.StatusForbidden)
369 return
370 }
371 ownerKind, ownerID = "group", g.ID
372 }
373 vis := r.FormValue("visibility")
374 if vis != "public" {
375 vis = "private"
376 }
377 repo, err := s.Store.CreateRepo(r.Context(), ownerKind, ownerID, name, r.FormValue("description"), s.Cfg.Git.DefaultBranch, vis)
378 if err != nil {
379 s.redirect(w, r, "/new", "", err.Error())
380 return
381 }
382 dir := gitrepo.Dir(s.Cfg.StoragePath, repo.OwnerPath, repo.Name)
383 if err := gitrepo.Init(s.Git, dir, repo.DefaultBranch, s.HookBin); err != nil {
384 _ = s.Store.DeleteRepo(r.Context(), repo.ID)
385 s.redirect(w, r, "/new", "", "git init: "+err.Error())
386 return
387 }
388 s.redirect(w, r, repoURL(repo), "Repository aangemaakt", "")
389}
390
391func (s *Server) createGroup(w http.ResponseWriter, r *http.Request) {
392 u, ok := s.loginRequired(w, r)
393 if !ok || !s.csrfOK(w, r) {
394 return
395 }
396 g, err := s.Store.CreateGroup(r.Context(), u.ID, r.FormValue("name"), r.FormValue("path"), r.FormValue("description"))
397 if err != nil {
398 s.redirect(w, r, "/new", "", err.Error())
399 return
400 }
401 s.redirect(w, r, "/groups/"+g.Path, "Groep aangemaakt", "")
402}
403
404func toCommits(in []gitrepo.Commit) []CommitRow {
405 var out []CommitRow
406 for _, c := range in {
407 out = append(out, CommitRow{SHA: c.SHA, Short: c.Short, Author: c.Author, Date: c.Date, Subject: c.Subject, Body: c.Body})
408 }
409 return out
410}
411
412func toEntries(base string, in []gitrepo.Entry) []EntryRow {
413 var out []EntryRow
414 for _, e := range in {
415 p := e.Name
416 if base != "" {
417 p = base + "/" + e.Name
418 }
419 out = append(out, EntryRow{Name: e.Name, Type: e.Type, Path: p})
420 }
421 return out
422}
423
424func cleanRel(p string) (string, error) {
425 p = strings.TrimPrefix(p, "/")
426 if p == "" || p == "." {
427 return "", nil
428 }
429 if strings.HasPrefix(p, "/") || strings.Contains(p, "\\") || strings.Contains(p, "..") {
430 return "", errBadID
431 }
432 return p, nil
433}
434
435func safeRev(s, fallback string) string {
436 if s == "" {
437 return fallback
438 }
439 if strings.HasPrefix(s, "-") || strings.Contains(s, "..") || strings.ContainsAny(s, " \t\n~^:?*[\\") {
440 return fallback
441 }
442 return s
443}
444
445func safeSHA(s string) bool {
446 if len(s) < 7 || len(s) > 64 {
447 return false
448 }
449 for _, c := range s {
450 if (c < '0' || c > '9') && (c < 'a' || c > 'f') && (c < 'A' || c > 'F') {
451 return false
452 }
453 }
454 return true
455}