BlueGit

timfa bluegit

Files

bluegit / internal / server / forks.go

forks.go

forks.go 14.2 KiB Download Raw
1package server
2
3import (
4 "context"
5 "errors"
6 "net/http"
7 "os"
8 "strconv"
9 "strings"
10 "syscall"
11
12 "gitlab.com/Timfa/bluegit/internal/access"
13 "gitlab.com/Timfa/bluegit/internal/ci"
14 "gitlab.com/Timfa/bluegit/internal/gitrepo"
15 "gitlab.com/Timfa/bluegit/internal/i18n"
16 "gitlab.com/Timfa/bluegit/internal/state"
17 "gitlab.com/Timfa/bluegit/internal/store"
18)
19
20// forkReserveBytes: zoveel moet er naast de upstream-grootte vrij blijven.
21const forkReserveBytes = 512 << 20
22
23// canReadRepo: openbaar, of de gebruiker heeft minstens leesrechten.
24func (s *Server) canReadRepo(ctx context.Context, userID int64, repo store.Repo) bool {
25 if repo.Visibility == "public" {
26 return true
27 }
28 if userID == 0 {
29 return false
30 }
31 role, err := s.Store.EffectiveRole(ctx, userID, repo.ID)
32 return err == nil && role.CanRead()
33}
34
35// ForkInfo is wat de repo-pagina over de fork-relatie toont.
36type ForkInfo struct {
37 IsFork bool
38 Upstream *store.Repo // nil als de kijker upstream niet mag zien
39 Forks int // zichtbare forks van deze repo
40}
41
42func (s *Server) forkInfo(ctx context.Context, userID int64, repo store.Repo) ForkInfo {
43 var fi ForkInfo
44 if up, _ := s.Store.ForkOf(ctx, repo.ID); up != 0 {
45 fi.IsFork = true
46 if u, err := s.Store.RepoByID(ctx, up); err == nil && s.canReadRepo(ctx, userID, u) {
47 fi.Upstream = &u
48 }
49 }
50 fi.Forks = len(s.visibleForks(ctx, userID, repo))
51 return fi
52}
53
54func (s *Server) visibleForks(ctx context.Context, userID int64, repo store.Repo) []store.Repo {
55 ids, _ := s.Store.ForkIDs(ctx, repo.ID)
56 if len(ids) == 0 {
57 return nil
58 }
59 list, _ := s.Store.ReposByIDs(ctx, ids)
60 var out []store.Repo
61 for _, f := range list {
62 if s.canReadRepo(ctx, userID, f) {
63 out = append(out, f)
64 }
65 }
66 return out
67}
68
69// ForkTarget is een plek waar de gebruiker een fork mag maken.
70type ForkTarget struct {
71 Value string // "" = eigen account, anders groepspad
72 Label string
73}
74
75func (s *Server) forkTargets(ctx context.Context, user store.User) []ForkTarget {
76 out := []ForkTarget{{Value: "", Label: user.Username}}
77 groups, _ := s.Store.ListGroups(ctx, user.ID)
78 for _, g := range groups {
79 if role, err := s.Store.GroupRole(ctx, g.ID, user.ID); err == nil && role.CanWriteCode() {
80 out = append(out, ForkTarget{Value: g.Path, Label: g.Path})
81 }
82 }
83 return out
84}
85
86// opForkRepo maakt een fork met alle branches en tags. Doel: eigen account
87// of een groep waar de gebruiker minstens developer is. Een fork van een
88// privé repo is privé.
89func (s *Server) opForkRepo(ctx context.Context, user store.User, upstream store.Repo, groupPath, rawName string) (store.Repo, error) {
90 if s.StoragePath() == "" {
91 return store.Repo{}, fail(503, i18n.E("err.noStorage"))
92 }
93 if !s.canReadRepo(ctx, user.ID, upstream) {
94 return store.Repo{}, fail(404, i18n.E("err.notFound"))
95 }
96 if strings.TrimSpace(rawName) == "" {
97 rawName = upstream.Name
98 }
99 name, err := slugKind("repo", rawName)
100 if err != nil {
101 return store.Repo{}, fail(400, err)
102 }
103 ownerKind, ownerID, ownerPath := "user", user.ID, user.Username
104 if gp := strings.TrimSpace(groupPath); gp != "" {
105 g, err := s.Store.GroupByPath(ctx, gp)
106 if err != nil {
107 return store.Repo{}, fail(404, i18n.E("err.groupMissing"))
108 }
109 role, err := s.Store.GroupRole(ctx, g.ID, user.ID)
110 if err != nil || !role.AtLeast(access.RoleDeveloper) {
111 return store.Repo{}, fail(403, i18n.E("err.forbidden"))
112 }
113 ownerKind, ownerID, ownerPath = "group", g.ID, g.Path
114 }
115 if _, err := s.Store.RepoByPath(ctx, ownerPath, name); err == nil {
116 return store.Repo{}, fail(409, i18n.E("err.forkExists", ownerPath+"/"+name))
117 }
118 src := gitrepo.Dir(s.StoragePath(), upstream.OwnerPath, upstream.Name)
119 if size, err := state.DirSize(ctx, src); err == nil {
120 var st syscall.Statfs_t
121 if syscall.Statfs(s.StoragePath(), &st) == nil && st.Bavail*uint64(st.Bsize) < size+forkReserveBytes {
122 return store.Repo{}, fail(507, i18n.E("err.forkDisk"))
123 }
124 }
125 repo, err := s.Store.CreateRepo(ctx, ownerKind, ownerID, name, upstream.Description, upstream.DefaultBranch, upstream.Visibility)
126 if err != nil {
127 return store.Repo{}, fail(400, err)
128 }
129 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
130 if err := gitrepo.Fork(s.Git, src, dir, s.HookBin); err != nil {
131 _ = s.Store.DeleteRepo(ctx, repo.ID)
132 _ = os.RemoveAll(dir)
133 return store.Repo{}, fail(500, i18n.E("err.forkGit", err.Error()))
134 }
135 if err := s.Store.SetForkOf(ctx, repo.ID, upstream.ID); err != nil {
136 return store.Repo{}, fail(500, err)
137 }
138 s.syncRepos(ctx, []int64{repo.ID})
139 return repo, nil
140}
141
142// forkMustStayPrivate: een fork van een privé upstream mag niet openbaar.
143func (s *Server) forkMustStayPrivate(ctx context.Context, repo store.Repo) bool {
144 up, _ := s.Store.ForkOf(ctx, repo.ID)
145 if up == 0 {
146 return false
147 }
148 u, err := s.Store.RepoByID(ctx, up)
149 return err == nil && u.Visibility != "public"
150}
151
152func (s *Server) forkPost(w http.ResponseWriter, r *http.Request) {
153 u, repo, _, ok := s.guard(w, r, access.RoleReadonly)
154 if !ok || !s.csrfOK(w, r) {
155 return
156 }
157 if u.ID == 0 {
158 http.Redirect(w, r, "/login", http.StatusSeeOther)
159 return
160 }
161 fork, err := s.opForkRepo(r.Context(), u, repo, r.FormValue("namespace"), r.FormValue("name"))
162 if !s.uiOK(w, r, repoURL(repo), err) {
163 return
164 }
165 s.redirect(w, r, repoURL(fork), s.tr(r, "flash.forked"), "")
166}
167
168func (s *Server) forksPage(w http.ResponseWriter, r *http.Request) {
169 u, repo, role, ok := s.guard(w, r, access.RoleReadonly)
170 if !ok {
171 return
172 }
173 v := s.repoView(w, r, repo, role, s.tr(r, "fork.listTitle"))
174 v.ForkList = s.visibleForks(r.Context(), u.ID, repo)
175 v.Fork = s.forkInfo(r.Context(), u.ID, repo)
176 s.render(w, "forks", v)
177}
178
179func forkJSON(fork store.Repo, upstream store.Repo) map[string]any {
180 out := projectJSON(fork)
181 out["forked_from"] = upstream.FullPath()
182 return out
183}
184
185func (s *Server) apiForkProject(w http.ResponseWriter, r *http.Request) {
186 repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)
187 if !ok {
188 return
189 }
190 var body struct {
191 Namespace string `json:"namespace"`
192 Name string `json:"name"`
193 }
194 if err := readJSON(r, &body); err != nil {
195 s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
196 return
197 }
198 fork, err := s.opForkRepo(r.Context(), apiUser(r), repo, body.Namespace, body.Name)
199 if !s.apiOK(w, r, err) {
200 return
201 }
202 writeJSON(w, http.StatusCreated, forkJSON(fork, repo))
203}
204
205func (s *Server) apiListForks(w http.ResponseWriter, r *http.Request) {
206 repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)
207 if !ok {
208 return
209 }
210 s.writeProjects(w, r, s.visibleForks(r.Context(), apiUser(r).ID, repo))
211}
212
213// SyncResult is de uitkomst van een upstream-synchronisatie.
214type SyncResult struct {
215 Branch string `json:"branch"`
216 Before string `json:"before"`
217 After string `json:"after"`
218 UpToDate bool `json:"up_to_date"`
219}
220
221// opSyncUpstream zet branch (standaard de standaardbranch) van upstream
222// fast-forward door naar de fork. Geen force: bij afwijking 409. Vereist
223// schrijfrechten op de fork en leesrechten op upstream; zonder leesrechten
224// noemt de fout de upstream niet.
225func (s *Server) opSyncUpstream(ctx context.Context, user store.User, fork store.Repo, branch string) (SyncResult, error) {
226 role, err := s.Store.EffectiveRole(ctx, user.ID, fork.ID)
227 if err != nil || !role.CanWriteCode() {
228 return SyncResult{}, fail(403, i18n.E("err.forbidden"))
229 }
230 upID, _ := s.Store.ForkOf(ctx, fork.ID)
231 if upID == 0 {
232 return SyncResult{}, fail(400, i18n.E("err.notFork"))
233 }
234 up, err := s.Store.RepoByID(ctx, upID)
235 if err != nil || !s.canReadRepo(ctx, user.ID, up) {
236 return SyncResult{}, fail(403, i18n.E("err.upstreamNoAccess"))
237 }
238 branch = strings.TrimSpace(branch)
239 if branch == "" {
240 branch = fork.DefaultBranch
241 }
242 if !safeBranchName(branch) {
243 return SyncResult{}, fail(400, i18n.E("err.upstreamBranch", branch))
244 }
245 updir := gitrepo.Dir(s.StoragePath(), up.OwnerPath, up.Name)
246 dir := gitrepo.Dir(s.StoragePath(), fork.OwnerPath, fork.Name)
247 upSHA := gitOne(ctx, s.Git, updir, "rev-parse", "--verify", "--quiet", "refs/heads/"+branch)
248 if !shaLike(upSHA) {
249 return SyncResult{}, fail(404, i18n.E("err.upstreamBranch", branch))
250 }
251 res := SyncResult{Branch: branch, Before: gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "--quiet", "refs/heads/"+branch)}
252 if res.Before == upSHA {
253 res.After, res.UpToDate = upSHA, true
254 return res, nil
255 }
256 patterns, _ := s.Store.ProtectedPatterns(ctx, fork.ID)
257 env := append(os.Environ(), gitrepo.PushEnv(role, patterns, nil)...)
258 if err := s.postReceive(ctx, fork, user, dir, func() error {
259 return gitrepo.PushBranch(ctx, s.Git, updir, dir, branch, env)
260 }); err != nil {
261 if errors.Is(err, gitrepo.ErrNotFastForward) {
262 return res, fail(409, i18n.E("err.syncNotFF", branch))
263 }
264 return res, fail(400, err)
265 }
266 res.After = gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "--quiet", "refs/heads/"+branch)
267 return res, nil
268}
269
270func safeBranchName(b string) bool {
271 return b != "" && !strings.HasPrefix(b, "-") && !strings.Contains(b, "..") && !strings.ContainsAny(b, " ~^:?*[\\")
272}
273
274func (s *Server) syncUpstreamPost(w http.ResponseWriter, r *http.Request) {
275 u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)
276 if !ok || !s.csrfOK(w, r) {
277 return
278 }
279 res, err := s.opSyncUpstream(r.Context(), u, repo, r.FormValue("branch"))
280 if !s.uiOK(w, r, repoURL(repo), err) {
281 return
282 }
283 msg := "flash.synced"
284 if res.UpToDate {
285 msg = "flash.syncUpToDate"
286 }
287 s.redirect(w, r, repoURL(repo), s.tr(r, msg, res.Branch), "")
288}
289
290func (s *Server) apiSyncUpstream(w http.ResponseWriter, r *http.Request) {
291 repo, _, ok := s.apiRepo(w, r, access.RoleDeveloper)
292 if !ok {
293 return
294 }
295 var body struct {
296 Branch string `json:"branch"`
297 }
298 if err := readJSON(r, &body); err != nil {
299 s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
300 return
301 }
302 res, err := s.opSyncUpstream(r.Context(), apiUser(r), repo, body.Branch)
303 if !s.apiOK(w, r, err) {
304 return
305 }
306 writeJSON(w, http.StatusOK, res)
307}
308
309// forkMirror is de branch in upstream die een fork-branch spiegelt.
310// Pipelines op forks/... krijgen nooit geheimen (zie runner).
311func forkMirror(forkID int64, branch string) string {
312 return ci.ForkBranchPrefix + strconv.FormatInt(forkID, 10) + "/" + branch
313}
314
315// opCreateForkMR maakt in upstream een MR met als bron een branch uit de
316// fork. De bron wordt gespiegeld naar forks/<forkid>/<branch> in upstream
317// (geen push-hook, dus geen push-pipeline). Vereist leesrechten op de fork
318// en de rol die in upstream MR's mag maken.
319func (s *Server) opCreateForkMR(ctx context.Context, user store.User, fork store.Repo, source, target, title, description string, draft bool) (store.Repo, store.MergeRequest, error) {
320 if !s.canReadRepo(ctx, user.ID, fork) {
321 return store.Repo{}, store.MergeRequest{}, fail(404, i18n.E("err.notFound"))
322 }
323 upID, _ := s.Store.ForkOf(ctx, fork.ID)
324 if upID == 0 {
325 return store.Repo{}, store.MergeRequest{}, fail(400, i18n.E("err.notFork"))
326 }
327 up, err := s.Store.RepoByID(ctx, upID)
328 if err != nil || !s.canReadRepo(ctx, user.ID, up) {
329 return store.Repo{}, store.MergeRequest{}, fail(403, i18n.E("err.upstreamNoAccess"))
330 }
331 role, err := s.Store.EffectiveRole(ctx, user.ID, up.ID)
332 if err != nil || !role.CanWriteCode() {
333 return store.Repo{}, store.MergeRequest{}, fail(403, i18n.E("err.upstreamMRRole"))
334 }
335 source = strings.TrimSpace(source)
336 target = strings.TrimSpace(target)
337 if target == "" {
338 target = up.DefaultBranch
339 }
340 if !safeBranchName(source) || !safeBranchName(target) {
341 return store.Repo{}, store.MergeRequest{}, fail(400, i18n.E("err.branches"))
342 }
343 dir := gitrepo.Dir(s.StoragePath(), fork.OwnerPath, fork.Name)
344 updir := gitrepo.Dir(s.StoragePath(), up.OwnerPath, up.Name)
345 if !shaLike(gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "--quiet", "refs/heads/"+source)) {
346 return store.Repo{}, store.MergeRequest{}, fail(404, i18n.E("err.upstreamBranch", source))
347 }
348 if !shaLike(gitOne(ctx, s.Git, updir, "rev-parse", "--verify", "--quiet", "refs/heads/"+target)) {
349 return store.Repo{}, store.MergeRequest{}, fail(404, i18n.E("err.upstreamBranch", target))
350 }
351 mirror := forkMirror(fork.ID, source)
352 if err := gitrepo.FetchBranch(ctx, s.Git, dir, updir, source, mirror); err != nil {
353 return store.Repo{}, store.MergeRequest{}, fail(500, err)
354 }
355 s.refsChanged(up)
356 mr, err := s.opCreateMR(ctx, user, up, title, description, mirror, target, draft)
357 if err != nil {
358 return store.Repo{}, store.MergeRequest{}, err
359 }
360 _ = s.Store.SetMRForkSource(ctx, mr.ID, fork.ID, source)
361 return up, mr, nil
362}
363
364// refreshForkMRs: na een push in een fork de gespiegelde branches in
365// upstream bijwerken; AfterPush van upstream start de MR-pipelines.
366func (s *Server) refreshForkMRs(fork store.Repo, user store.User, branch string) {
367 ctx := context.Background()
368 list, err := s.Store.OpenForkMRs(ctx, fork.ID, branch)
369 if err != nil || len(list) == 0 {
370 return
371 }
372 dir := gitrepo.Dir(s.StoragePath(), fork.OwnerPath, fork.Name)
373 for _, m := range list {
374 up, err := s.Store.RepoByID(ctx, m.UpstreamID)
375 if err != nil || !s.canReadRepo(ctx, user.ID, up) {
376 continue
377 }
378 updir := gitrepo.Dir(s.StoragePath(), up.OwnerPath, up.Name)
379 _ = s.postReceive(ctx, up, user, updir, func() error {
380 return gitrepo.FetchBranch(ctx, s.Git, dir, updir, branch, m.Mirror)
381 })
382 }
383}
384
385func (s *Server) forkMRPost(w http.ResponseWriter, r *http.Request) {
386 u, repo, _, ok := s.guard(w, r, access.RoleReadonly)
387 if !ok || !s.csrfOK(w, r) {
388 return
389 }
390 up, mr, err := s.opCreateForkMR(r.Context(), u, repo, r.FormValue("source"), r.FormValue("target"), r.FormValue("title"), r.FormValue("description"), r.FormValue("draft") == "1")
391 if !s.uiOK(w, r, repoURL(repo)+"/-/merge-requests/new", err) {
392 return
393 }
394 s.redirect(w, r, repoURL(up)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10), s.tr(r, "flash.mrOpened"), "")
395}
396
397func (s *Server) apiForkMR(w http.ResponseWriter, r *http.Request) {
398 repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)
399 if !ok {
400 return
401 }
402 var body struct {
403 Source string `json:"source_branch"`
404 Target string `json:"target_branch"`
405 Title string `json:"title"`
406 Description string `json:"description"`
407 Draft bool `json:"draft"`
408 }
409 if err := readJSON(r, &body); err != nil {
410 s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
411 return
412 }
413 up, mr, err := s.opCreateForkMR(r.Context(), apiUser(r), repo, body.Source, body.Target, body.Title, body.Description, body.Draft)
414 if !s.apiOK(w, r, err) {
415 return
416 }
417 out := s.mrJSON(up, mr)
418 out["source_project"] = repo.FullPath()
419 out["source_project_branch"] = body.Source
420 writeJSON(w, http.StatusCreated, out)
421}