BlueGit

timfa bluegit

Files

bluegit / internal / server / ops_git.go

ops_git.go

fix: verwijder slash-branches en de bron na een push-merge
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
Passed cfe6072c History
ops_git.go 7.8 KiB Download Raw
1package server
2
3import (
4 "context"
5 "net/url"
6 "os"
7 "strings"
8
9 "gitlab.com/Timfa/bluegit/internal/access"
10 "gitlab.com/Timfa/bluegit/internal/gitrepo"
11 "gitlab.com/Timfa/bluegit/internal/i18n"
12 "gitlab.com/Timfa/bluegit/internal/names"
13 "gitlab.com/Timfa/bluegit/internal/store"
14)
15
16// decodeBranch maakt een branchnaam uit een pad of een bevestiging.
17// ServeMux decodeert %2F één keer. Een client die de slash nóg een keer
18// encodeert (%252F) levert anders cursor%2F… en de bevestiging wijkt af.
19func decodeBranch(raw string) string {
20 name := strings.TrimSpace(raw)
21 for i := 0; i < 3; i++ {
22 next, err := url.PathUnescape(name)
23 if err != nil || next == name {
24 return name
25 }
26 name = next
27 }
28 return name
29}
30
31func (s *Server) repoRole(ctx context.Context, user store.User, repo store.Repo) (access.Role, error) {
32 role, err := s.Store.EffectiveRole(ctx, user.ID, repo.ID)
33 if err != nil {
34 return "", fail(500, err)
35 }
36 return role, nil
37}
38
39func (s *Server) opCreateBranch(ctx context.Context, user store.User, repo store.Repo, name, from string) error {
40 role, err := s.repoRole(ctx, user, repo)
41 if err != nil {
42 return err
43 }
44 if !role.CanWriteCode() {
45 return fail(403, i18n.E("err.forbidden"))
46 }
47 name = strings.TrimSpace(name)
48 if err := names.ValidBranch(name); err != nil {
49 return fail(400, err)
50 }
51 from = safeRev(from, repo.DefaultBranch)
52 if from == "" {
53 return fail(400, i18n.E("err.branches"))
54 }
55 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
56 if gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "--quiet", "refs/heads/"+name) != "" {
57 return fail(400, i18n.E("err.branchName", name))
58 }
59 if err := s.postReceive(ctx, repo, user, dir, func() error {
60 return gitrepo.CreateBranch(ctx, s.Git, dir, name, from)
61 }); err != nil {
62 return fail(400, err)
63 }
64 return nil
65}
66
67func (s *Server) branchLockError(ctx context.Context, repo store.Repo, name string) error {
68 if name == repo.DefaultBranch {
69 return i18n.E("err.branchLocked", name)
70 }
71 patterns, _ := s.Store.ProtectedPatterns(ctx, repo.ID)
72 if access.BranchProtected(patterns, name) {
73 return i18n.E("err.branchLocked", name)
74 }
75 return nil
76}
77
78func (s *Server) opDeleteBranch(ctx context.Context, user store.User, repo store.Repo, name, confirm string) error {
79 role, err := s.repoRole(ctx, user, repo)
80 if err != nil {
81 return err
82 }
83 if !role.CanWriteCode() {
84 return fail(403, i18n.E("err.forbidden"))
85 }
86 name = decodeBranch(name)
87 confirm = decodeBranch(confirm)
88 if confirm != name || name == "" {
89 return fail(400, i18n.E("err.branchConfirm"))
90 }
91 if err := s.branchLockError(ctx, repo, name); err != nil {
92 return fail(400, err)
93 }
94 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
95 if err := s.postReceive(ctx, repo, user, dir, func() error {
96 return gitrepo.DeleteBranch(ctx, s.Git, dir, name)
97 }); err != nil {
98 return fail(400, err)
99 }
100 return nil
101}
102
103func (s *Server) opRenameBranch(ctx context.Context, user store.User, repo store.Repo, name, newName, confirm string) error {
104 role, err := s.repoRole(ctx, user, repo)
105 if err != nil {
106 return err
107 }
108 if !role.CanWriteCode() {
109 return fail(403, i18n.E("err.forbidden"))
110 }
111 name = decodeBranch(name)
112 newName = decodeBranch(newName)
113 confirm = decodeBranch(confirm)
114 if confirm != name || name == "" {
115 return fail(400, i18n.E("err.branchConfirm"))
116 }
117 if err := names.ValidBranch(newName); err != nil {
118 return fail(400, err)
119 }
120 if err := s.branchLockError(ctx, repo, name); err != nil {
121 return fail(400, err)
122 }
123 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
124 if gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "--quiet", "refs/heads/"+newName) != "" {
125 return fail(400, i18n.E("err.branchName", newName))
126 }
127 if err := s.postReceive(ctx, repo, user, dir, func() error {
128 if err := gitrepo.RenameBranch(ctx, s.Git, dir, name, newName); err != nil {
129 return err
130 }
131 return s.Store.RenameOpenMRBranches(ctx, repo.ID, name, newName)
132 }); err != nil {
133 return fail(400, err)
134 }
135 return nil
136}
137
138func (s *Server) opCreateTag(ctx context.Context, user store.User, repo store.Repo, name, target, message string) error {
139 role, err := s.repoRole(ctx, user, repo)
140 if err != nil {
141 return err
142 }
143 if !role.CanWriteCode() {
144 return fail(403, i18n.E("err.forbidden"))
145 }
146 name = strings.TrimSpace(name)
147 if err := names.ValidTag(name); err != nil {
148 return fail(400, err)
149 }
150 patterns, _ := s.Store.ProtectedTagPatterns(ctx, repo.ID)
151 if access.BranchProtected(patterns, name) && !role.CanManageSettings() {
152 return fail(403, i18n.E("err.tagProtected", name))
153 }
154 if strings.TrimSpace(target) == "" {
155 target = repo.DefaultBranch
156 }
157 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
158 if err := s.postReceive(ctx, repo, user, dir, func() error {
159 return gitrepo.CreateTag(ctx, s.Git, dir, name, target, message, user.Username, userEmail(user.Username))
160 }); err != nil {
161 return fail(400, err)
162 }
163 return nil
164}
165
166func (s *Server) opDeleteTag(ctx context.Context, user store.User, repo store.Repo, name string) error {
167 role, err := s.repoRole(ctx, user, repo)
168 if err != nil {
169 return err
170 }
171 if !role.CanWriteCode() {
172 return fail(403, i18n.E("err.forbidden"))
173 }
174 name = strings.TrimSpace(name)
175 patterns, _ := s.Store.ProtectedTagPatterns(ctx, repo.ID)
176 if access.BranchProtected(patterns, name) && !role.CanManageSettings() {
177 return fail(403, i18n.E("err.tagProtected", name))
178 }
179 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
180 if err := gitrepo.DeleteTag(ctx, s.Git, dir, name); err != nil {
181 return fail(400, err)
182 }
183 return nil
184}
185
186type fileAction struct {
187 Action string `json:"action"`
188 Path string `json:"file_path"`
189 Content string `json:"content"`
190}
191
192func (s *Server) opWriteFiles(ctx context.Context, user store.User, repo store.Repo, role access.Role, branch, base, title, description string, files map[string]string, deletes []string) (string, error) {
193 if role == "" {
194 var err error
195 role, err = s.repoRole(ctx, user, repo)
196 if err != nil {
197 return "", err
198 }
199 }
200 if !role.CanWriteCode() {
201 return "", fail(403, i18n.E("err.forbidden"))
202 }
203 branch = strings.TrimSpace(branch)
204 if !validBranchName(branch) {
205 return "", fail(400, i18n.E("edit.badBranch"))
206 }
207 title = strings.TrimSpace(title)
208 if title == "" || strings.ContainsAny(title, "\r\n") {
209 return "", fail(400, i18n.E("edit.needMessage"))
210 }
211 if base == "" {
212 base = repo.DefaultBranch
213 }
214 patterns, _ := s.Store.ProtectedPatterns(ctx, repo.ID)
215 if access.BranchProtected(patterns, branch) && !role.CanPushBranch(true) {
216 return "", fail(403, i18n.E("edit.protected"))
217 }
218 if s.StoragePath() == "" {
219 return "", fail(503, i18n.E("err.noStorage"))
220 }
221 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
222 work, err := s.scratchDir("api-commit")
223 if err != nil {
224 return "", fail(500, err)
225 }
226 defer os.RemoveAll(work)
227 if err := s.ensureBranch(ctx, dir, branch, base, work); err != nil {
228 return "", fail(400, err)
229 }
230 if err := s.postReceive(ctx, repo, user, dir, func() error {
231 return gitrepo.CommitChanges(ctx, s.Git, dir, work, branch, user.Username, userEmail(user.Username), title, description, files, deletes, role, patterns)
232 }); err != nil {
233 return "", fail(400, err)
234 }
235 return gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "refs/heads/"+branch), nil
236}
237
238func (s *Server) opCommitActions(ctx context.Context, user store.User, repo store.Repo, branch, base, title, description string, actions []fileAction) (string, error) {
239 files := map[string]string{}
240 var deletes []string
241 for _, a := range actions {
242 path, ok := repoPath(a.Path)
243 if !ok || path == "" {
244 return "", fail(400, i18n.E("err.sugFile"))
245 }
246 switch a.Action {
247 case "", "create", "update":
248 files[path] = a.Content
249 case "delete":
250 deletes = append(deletes, path)
251 default:
252 return "", fail(400, i18n.E("err.sugFile"))
253 }
254 }
255 return s.opWriteFiles(ctx, user, repo, "", branch, base, title, description, files, deletes)
256}