BlueGit

timfa bluegit

Files

bluegit / internal / server / repo_handlers.go

repo_handlers.go

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