package server import ( "context" "errors" "net/http" "os" "strconv" "strings" "gitlab.com/Timfa/bluegit/internal/access" "gitlab.com/Timfa/bluegit/internal/ci" "gitlab.com/Timfa/bluegit/internal/diskusage" "gitlab.com/Timfa/bluegit/internal/gitrepo" "gitlab.com/Timfa/bluegit/internal/i18n" "gitlab.com/Timfa/bluegit/internal/state" "gitlab.com/Timfa/bluegit/internal/store" ) // forkReserveBytes: zoveel moet er naast de upstream-grootte vrij blijven. const forkReserveBytes = 512 << 20 // canReadRepo: openbaar, of de gebruiker heeft minstens leesrechten. func (s *Server) canReadRepo(ctx context.Context, userID int64, repo store.Repo) bool { if repo.Visibility == "public" { return true } if userID == 0 { return false } role, err := s.Store.EffectiveRole(ctx, userID, repo.ID) return err == nil && role.CanRead() } // ForkInfo is wat de repo-pagina over de fork-relatie toont. type ForkInfo struct { IsFork bool Upstream *store.Repo // nil als de kijker upstream niet mag zien Forks int // zichtbare forks van deze repo } func (s *Server) forkInfo(ctx context.Context, userID int64, repo store.Repo) ForkInfo { var fi ForkInfo if up, _ := s.Store.ForkOf(ctx, repo.ID); up != 0 { fi.IsFork = true if u, err := s.Store.RepoByID(ctx, up); err == nil && s.canReadRepo(ctx, userID, u) { fi.Upstream = &u } } fi.Forks = len(s.visibleForks(ctx, userID, repo)) return fi } func (s *Server) visibleForks(ctx context.Context, userID int64, repo store.Repo) []store.Repo { ids, _ := s.Store.ForkIDs(ctx, repo.ID) if len(ids) == 0 { return nil } list, _ := s.Store.ReposByIDs(ctx, ids) var out []store.Repo for _, f := range list { if s.canReadRepo(ctx, userID, f) { out = append(out, f) } } return out } // ForkTarget is een plek waar de gebruiker een fork mag maken. type ForkTarget struct { Value string // "" = eigen account, anders groepspad Label string } func (s *Server) forkTargets(ctx context.Context, user store.User) []ForkTarget { out := []ForkTarget{{Value: "", Label: user.Username}} groups, _ := s.Store.ListGroups(ctx, user.ID) for _, g := range groups { if role, err := s.Store.GroupRole(ctx, g.ID, user.ID); err == nil && role.CanWriteCode() { out = append(out, ForkTarget{Value: g.Path, Label: g.Path}) } } return out } // opForkRepo maakt een fork met alle branches en tags. Doel: eigen account // of een groep waar de gebruiker minstens developer is. Een fork van een // privé repo is privé. func (s *Server) opForkRepo(ctx context.Context, user store.User, upstream store.Repo, groupPath, rawName string) (store.Repo, error) { if s.StoragePath() == "" { return store.Repo{}, fail(503, i18n.E("err.noStorage")) } if !s.canReadRepo(ctx, user.ID, upstream) { return store.Repo{}, fail(404, i18n.E("err.notFound")) } if strings.TrimSpace(rawName) == "" { rawName = upstream.Name } name, err := slugKind("repo", rawName) if err != nil { return store.Repo{}, fail(400, err) } ownerKind, ownerID, ownerPath := "user", user.ID, user.Username if gp := strings.TrimSpace(groupPath); gp != "" { g, err := s.Store.GroupByPath(ctx, gp) if err != nil { return store.Repo{}, fail(404, i18n.E("err.groupMissing")) } role, err := s.Store.GroupRole(ctx, g.ID, user.ID) if err != nil || !role.AtLeast(access.RoleDeveloper) { return store.Repo{}, fail(403, i18n.E("err.forbidden")) } ownerKind, ownerID, ownerPath = "group", g.ID, g.Path } if _, err := s.Store.RepoByPath(ctx, ownerPath, name); err == nil { return store.Repo{}, fail(409, i18n.E("err.forkExists", ownerPath+"/"+name)) } src := gitrepo.Dir(s.StoragePath(), upstream.OwnerPath, upstream.Name) if size, err := state.DirSize(ctx, src); err == nil { if du, err := diskusage.Usage(s.StoragePath()); err == nil && du.Free < size+forkReserveBytes { return store.Repo{}, fail(507, i18n.E("err.forkDisk")) } } repo, err := s.Store.CreateRepo(ctx, ownerKind, ownerID, name, upstream.Description, upstream.DefaultBranch, upstream.Visibility) if err != nil { return store.Repo{}, fail(400, err) } dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name) if err := gitrepo.Fork(s.Git, src, dir, s.HookBin); err != nil { _ = s.Store.DeleteRepo(ctx, repo.ID) _ = os.RemoveAll(dir) return store.Repo{}, fail(500, i18n.E("err.forkGit", err.Error())) } if err := s.Store.SetForkOf(ctx, repo.ID, upstream.ID); err != nil { return store.Repo{}, fail(500, err) } s.syncRepos(ctx, []int64{repo.ID}) return repo, nil } // forkMustStayPrivate: een fork van een privé upstream mag niet openbaar. func (s *Server) forkMustStayPrivate(ctx context.Context, repo store.Repo) bool { up, _ := s.Store.ForkOf(ctx, repo.ID) if up == 0 { return false } u, err := s.Store.RepoByID(ctx, up) return err == nil && u.Visibility != "public" } func (s *Server) forkPost(w http.ResponseWriter, r *http.Request) { u, repo, _, ok := s.guard(w, r, access.RoleReadonly) if !ok || !s.csrfOK(w, r) { return } if u.ID == 0 { http.Redirect(w, r, "/login", http.StatusSeeOther) return } fork, err := s.opForkRepo(r.Context(), u, repo, r.FormValue("namespace"), r.FormValue("name")) if !s.uiOK(w, r, repoURL(repo), err) { return } s.redirect(w, r, repoURL(fork), s.tr(r, "flash.forked"), "") } func (s *Server) forksPage(w http.ResponseWriter, r *http.Request) { u, repo, role, ok := s.guard(w, r, access.RoleReadonly) if !ok { return } v := s.repoView(w, r, repo, role, s.tr(r, "fork.listTitle")) v.ForkList = s.visibleForks(r.Context(), u.ID, repo) v.Fork = s.forkInfo(r.Context(), u.ID, repo) s.render(w, "forks", v) } func forkJSON(fork store.Repo, upstream store.Repo) map[string]any { out := projectJSON(fork) out["forked_from"] = upstream.FullPath() return out } func (s *Server) apiForkProject(w http.ResponseWriter, r *http.Request) { repo, _, ok := s.apiRepo(w, r, access.RoleReadonly) if !ok { return } var body struct { Namespace string `json:"namespace"` Name string `json:"name"` } if err := readJSON(r, &body); err != nil { s.writeAPIErr(w, r, fail(400, i18n.E("err.json"))) return } fork, err := s.opForkRepo(r.Context(), apiUser(r), repo, body.Namespace, body.Name) if !s.apiOK(w, r, err) { return } writeJSON(w, http.StatusCreated, forkJSON(fork, repo)) } func (s *Server) apiListForks(w http.ResponseWriter, r *http.Request) { repo, _, ok := s.apiRepo(w, r, access.RoleReadonly) if !ok { return } s.writeProjects(w, r, s.visibleForks(r.Context(), apiUser(r).ID, repo)) } // SyncResult is de uitkomst van een upstream-synchronisatie. type SyncResult struct { Branch string `json:"branch"` Before string `json:"before"` After string `json:"after"` UpToDate bool `json:"up_to_date"` } // opSyncUpstream zet branch (standaard de standaardbranch) van upstream // fast-forward door naar de fork. Geen force: bij afwijking 409. Vereist // schrijfrechten op de fork en leesrechten op upstream; zonder leesrechten // noemt de fout de upstream niet. func (s *Server) opSyncUpstream(ctx context.Context, user store.User, fork store.Repo, branch string) (SyncResult, error) { role, err := s.Store.EffectiveRole(ctx, user.ID, fork.ID) if err != nil || !role.CanWriteCode() { return SyncResult{}, fail(403, i18n.E("err.forbidden")) } upID, _ := s.Store.ForkOf(ctx, fork.ID) if upID == 0 { return SyncResult{}, fail(400, i18n.E("err.notFork")) } up, err := s.Store.RepoByID(ctx, upID) if err != nil || !s.canReadRepo(ctx, user.ID, up) { return SyncResult{}, fail(403, i18n.E("err.upstreamNoAccess")) } branch = strings.TrimSpace(branch) if branch == "" { branch = fork.DefaultBranch } if !safeBranchName(branch) { return SyncResult{}, fail(400, i18n.E("err.upstreamBranch", branch)) } updir := gitrepo.Dir(s.StoragePath(), up.OwnerPath, up.Name) dir := gitrepo.Dir(s.StoragePath(), fork.OwnerPath, fork.Name) upSHA := gitOne(ctx, s.Git, updir, "rev-parse", "--verify", "--quiet", "refs/heads/"+branch) if !shaLike(upSHA) { return SyncResult{}, fail(404, i18n.E("err.upstreamBranch", branch)) } res := SyncResult{Branch: branch, Before: gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "--quiet", "refs/heads/"+branch)} if res.Before == upSHA { res.After, res.UpToDate = upSHA, true return res, nil } patterns, _ := s.Store.ProtectedPatterns(ctx, fork.ID) env := append(os.Environ(), gitrepo.PushEnv(role, patterns, nil)...) if err := s.postReceive(ctx, fork, user, dir, func() error { return gitrepo.PushBranch(ctx, s.Git, updir, dir, branch, env) }); err != nil { if errors.Is(err, gitrepo.ErrNotFastForward) { return res, fail(409, i18n.E("err.syncNotFF", branch)) } return res, fail(400, err) } res.After = gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "--quiet", "refs/heads/"+branch) return res, nil } func safeBranchName(b string) bool { return b != "" && !strings.HasPrefix(b, "-") && !strings.Contains(b, "..") && !strings.ContainsAny(b, " ~^:?*[\\") } func (s *Server) syncUpstreamPost(w http.ResponseWriter, r *http.Request) { u, repo, _, ok := s.guard(w, r, access.RoleDeveloper) if !ok || !s.csrfOK(w, r) { return } res, err := s.opSyncUpstream(r.Context(), u, repo, r.FormValue("branch")) if !s.uiOK(w, r, repoURL(repo), err) { return } msg := "flash.synced" if res.UpToDate { msg = "flash.syncUpToDate" } s.redirect(w, r, repoURL(repo), s.tr(r, msg, res.Branch), "") } func (s *Server) apiSyncUpstream(w http.ResponseWriter, r *http.Request) { repo, _, ok := s.apiRepo(w, r, access.RoleDeveloper) if !ok { return } var body struct { Branch string `json:"branch"` } if err := readJSON(r, &body); err != nil { s.writeAPIErr(w, r, fail(400, i18n.E("err.json"))) return } res, err := s.opSyncUpstream(r.Context(), apiUser(r), repo, body.Branch) if !s.apiOK(w, r, err) { return } writeJSON(w, http.StatusOK, res) } // forkMirror is de branch in upstream die een fork-branch spiegelt. // Pipelines op forks/... krijgen nooit geheimen (zie runner). func forkMirror(forkID int64, branch string) string { return ci.ForkBranchPrefix + strconv.FormatInt(forkID, 10) + "/" + branch } // opCreateForkMR maakt in upstream een MR met als bron een branch uit de // fork. De bron wordt gespiegeld naar forks// in upstream // (geen push-hook, dus geen push-pipeline). Vereist leesrechten op de fork // en de rol die in upstream MR's mag maken. func (s *Server) opCreateForkMR(ctx context.Context, user store.User, fork store.Repo, source, target, title, description string, draft bool) (store.Repo, store.MergeRequest, error) { if !s.canReadRepo(ctx, user.ID, fork) { return store.Repo{}, store.MergeRequest{}, fail(404, i18n.E("err.notFound")) } upID, _ := s.Store.ForkOf(ctx, fork.ID) if upID == 0 { return store.Repo{}, store.MergeRequest{}, fail(400, i18n.E("err.notFork")) } up, err := s.Store.RepoByID(ctx, upID) if err != nil || !s.canReadRepo(ctx, user.ID, up) { return store.Repo{}, store.MergeRequest{}, fail(403, i18n.E("err.upstreamNoAccess")) } role, err := s.Store.EffectiveRole(ctx, user.ID, up.ID) if err != nil || !role.CanWriteCode() { return store.Repo{}, store.MergeRequest{}, fail(403, i18n.E("err.upstreamMRRole")) } source = strings.TrimSpace(source) target = strings.TrimSpace(target) if target == "" { target = up.DefaultBranch } if !safeBranchName(source) || !safeBranchName(target) { return store.Repo{}, store.MergeRequest{}, fail(400, i18n.E("err.branches")) } dir := gitrepo.Dir(s.StoragePath(), fork.OwnerPath, fork.Name) updir := gitrepo.Dir(s.StoragePath(), up.OwnerPath, up.Name) if !shaLike(gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "--quiet", "refs/heads/"+source)) { return store.Repo{}, store.MergeRequest{}, fail(404, i18n.E("err.upstreamBranch", source)) } if !shaLike(gitOne(ctx, s.Git, updir, "rev-parse", "--verify", "--quiet", "refs/heads/"+target)) { return store.Repo{}, store.MergeRequest{}, fail(404, i18n.E("err.upstreamBranch", target)) } mirror := forkMirror(fork.ID, source) if err := gitrepo.FetchBranch(ctx, s.Git, dir, updir, source, mirror); err != nil { return store.Repo{}, store.MergeRequest{}, fail(500, err) } s.refsChanged(up) mr, err := s.opCreateMR(ctx, user, up, title, description, mirror, target, draft) if err != nil { return store.Repo{}, store.MergeRequest{}, err } _ = s.Store.SetMRForkSource(ctx, mr.ID, fork.ID, source) return up, mr, nil } // refreshForkMRs: na een push in een fork de gespiegelde branches in // upstream bijwerken; AfterPush van upstream start de MR-pipelines. func (s *Server) refreshForkMRs(fork store.Repo, user store.User, branch string) { ctx := context.Background() list, err := s.Store.OpenForkMRs(ctx, fork.ID, branch) if err != nil || len(list) == 0 { return } dir := gitrepo.Dir(s.StoragePath(), fork.OwnerPath, fork.Name) for _, m := range list { up, err := s.Store.RepoByID(ctx, m.UpstreamID) if err != nil || !s.canReadRepo(ctx, user.ID, up) { continue } updir := gitrepo.Dir(s.StoragePath(), up.OwnerPath, up.Name) _ = s.postReceive(ctx, up, user, updir, func() error { return gitrepo.FetchBranch(ctx, s.Git, dir, updir, branch, m.Mirror) }) } } func (s *Server) forkMRPost(w http.ResponseWriter, r *http.Request) { u, repo, _, ok := s.guard(w, r, access.RoleReadonly) if !ok || !s.csrfOK(w, r) { return } 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") if !s.uiOK(w, r, repoURL(repo)+"/-/merge-requests/new", err) { return } s.redirect(w, r, repoURL(up)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10), s.tr(r, "flash.mrOpened"), "") } func (s *Server) apiForkMR(w http.ResponseWriter, r *http.Request) { repo, _, ok := s.apiRepo(w, r, access.RoleReadonly) if !ok { return } var body struct { Source string `json:"source_branch"` Target string `json:"target_branch"` Title string `json:"title"` Description string `json:"description"` Draft bool `json:"draft"` } if err := readJSON(r, &body); err != nil { s.writeAPIErr(w, r, fail(400, i18n.E("err.json"))) return } up, mr, err := s.opCreateForkMR(r.Context(), apiUser(r), repo, body.Source, body.Target, body.Title, body.Description, body.Draft) if !s.apiOK(w, r, err) { return } out := s.mrJSON(up, mr) out["source_project"] = repo.FullPath() out["source_project_branch"] = body.Source writeJSON(w, http.StatusCreated, out) }