BlueGit

timfa bluegit

Files

bluegit / internal / server / api.go

api.go

api.go 6.9 KiB Download Raw
1package server
2
3import (
4 "io"
5 "net/http"
6 "os"
7 "path/filepath"
8 "strconv"
9 "strings"
10
11 "gitlab.com/Timfa/bluegit/internal/access"
12 "gitlab.com/Timfa/bluegit/internal/ci"
13 "gitlab.com/Timfa/bluegit/internal/gitrepo"
14 "gitlab.com/Timfa/bluegit/internal/i18n"
15 "gitlab.com/Timfa/bluegit/internal/store"
16)
17
18type releaseRequest struct {
19 Tag string `json:"tag"`
20 Commit string `json:"commit"`
21 Name string `json:"name"`
22 Body string `json:"body"`
23 // Replace: een job mag zijn eigen release vervangen (zie checkReplace).
24 Replace bool `json:"replace"`
25 Assets []struct {
26 Job string `json:"job"`
27 Path string `json:"path"`
28 Name string `json:"name"`
29 } `json:"assets"`
30}
31
32func (s *Server) createRelease(w http.ResponseWriter, r *http.Request) {
33 repo, err := s.Store.RepoByPath(r.Context(), r.PathValue("owner"), r.PathValue("repo"))
34 if err != nil {
35 s.writeAPIErr(w, r, fail(http.StatusNotFound, i18n.E("err.notFound")))
36 return
37 }
38 token := tokenFrom(r)
39 var job store.Job
40 var author store.User
41 if strings.HasPrefix(token, "bgj_") {
42 job, err = s.Store.JobByToken(r.Context(), token)
43 if err != nil || job.RepoID != repo.ID || job.Status != "running" {
44 s.writeAPIErr(w, r, fail(http.StatusUnauthorized, i18n.E("err.jobToken")))
45 return
46 }
47 } else {
48 author = apiUser(r)
49 if author.ID == 0 {
50 s.writeAPIErr(w, r, fail(http.StatusUnauthorized, i18n.E("err.apiAuth")))
51 return
52 }
53 role, err := s.Store.EffectiveRole(r.Context(), author.ID, repo.ID)
54 if err == nil && !role.CanRead() && repo.Visibility != "public" {
55 s.writeAPIErr(w, r, fail(http.StatusNotFound, i18n.E("err.notFound")))
56 return
57 }
58 if err != nil || !role.AtLeast(access.RoleMaintainer) {
59 s.writeAPIErr(w, r, fail(http.StatusForbidden, i18n.E("err.onlyAdmin")))
60 return
61 }
62 }
63 var req releaseRequest
64 if err := readJSON(r, &req); err != nil {
65 s.writeAPIErr(w, r, fail(http.StatusBadRequest, i18n.E("err.json")))
66 return
67 }
68 id, err := s.opPublishRelease(r.Context(), repo, author, job, req)
69 if !s.apiOK(w, r, err) {
70 return
71 }
72 writeJSON(w, http.StatusCreated, map[string]any{"id": id, "tag": req.Tag, "commit": req.Commit})
73}
74
75func (s *Server) releaseAsset(w http.ResponseWriter, r *http.Request) {
76 _, repo, _, ok := s.guardReleases(w, r)
77 if !ok {
78 return
79 }
80 rel, err := s.Store.ReleaseByTag(r.Context(), repo.ID, r.PathValue("tag"))
81 if err != nil {
82 http.NotFound(w, r)
83 return
84 }
85 name := r.PathValue("name")
86 for _, a := range rel.Assets {
87 if a.Name == name {
88 w.Header().Set("Content-Disposition", "attachment; filename=\""+strings.ReplaceAll(name, "\"", "")+"\"")
89 http.ServeFile(w, r, a.StoragePath)
90 return
91 }
92 }
93 http.NotFound(w, r)
94}
95
96// jobLogAPI geeft de volledige console-output van een job, met geheimen gemaskeerd.
97// Een persoonlijk token is verplicht, ook bij een publieke repo. Job-tokens tellen niet.
98func (s *Server) jobLogAPI(w http.ResponseWriter, r *http.Request) {
99 repo, err := s.Store.RepoByPath(r.Context(), r.PathValue("owner"), r.PathValue("repo"))
100 if err != nil {
101 http.NotFound(w, r)
102 return
103 }
104 if !s.authorizeRepoRead(w, r, repo) {
105 return
106 }
107 id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
108 if err != nil || id <= 0 {
109 http.NotFound(w, r)
110 return
111 }
112 job, err := s.Store.JobByID(r.Context(), repo.ID, id)
113 if err != nil {
114 http.NotFound(w, r)
115 return
116 }
117 text := ci.Mask(job.Log, s.maskSecrets(r.Context(), repo))
118 w.Header().Set("Content-Type", "text/plain; charset=utf-8")
119 w.Header().Set("Cache-Control", "no-store")
120 _, _ = w.Write([]byte(text))
121}
122
123// authorizeRepoRead eist een persoonlijk token. Op een publieke repo volstaat
124// elk geldig token. Op een privérepo moet het token de repo mogen lezen.
125func (s *Server) authorizeRepoRead(w http.ResponseWriter, r *http.Request, repo store.Repo) bool {
126 token := bearer(r)
127 if token == "" {
128 http.Error(w, s.tr(r, "err.tokenAbsent"), http.StatusUnauthorized)
129 return false
130 }
131 if strings.HasPrefix(token, "bgj_") {
132 job, err := s.Store.JobByToken(r.Context(), token)
133 if err == nil && job.Status == "running" && job.RepoID == repo.ID {
134 return true
135 }
136 http.Error(w, s.tr(r, "err.tokenBad"), http.StatusUnauthorized)
137 return false
138 }
139 if !strings.HasPrefix(token, "bg_") {
140 http.Error(w, s.tr(r, "err.tokenBad"), http.StatusUnauthorized)
141 return false
142 }
143 u, err := s.Store.UserByToken(r.Context(), token)
144 if err != nil {
145 http.Error(w, s.tr(r, "err.tokenBad"), http.StatusUnauthorized)
146 return false
147 }
148 role, err := s.Store.EffectiveRole(r.Context(), u.ID, repo.ID)
149 if err != nil {
150 http.Error(w, s.tr(r, "err.rights"), http.StatusInternalServerError)
151 return false
152 }
153 if !role.CanRead() && repo.Visibility != "public" {
154 http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
155 return false
156 }
157 return true
158}
159
160// commitDiffAPI geeft de unified diff van één commit.
161func (s *Server) commitDiffAPI(w http.ResponseWriter, r *http.Request) {
162 repo, err := s.Store.RepoByPath(r.Context(), r.PathValue("owner"), r.PathValue("repo"))
163 if err != nil {
164 http.NotFound(w, r)
165 return
166 }
167 if !s.authorizeRepoRead(w, r, repo) {
168 return
169 }
170 sha := r.PathValue("sha")
171 if !safeSHA(sha) || s.Git == "" || s.StoragePath() == "" {
172 http.NotFound(w, r)
173 return
174 }
175 text, err := gitrepo.CommitDiff(r.Context(), s.Git, gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name), sha)
176 if err != nil {
177 http.NotFound(w, r)
178 return
179 }
180 writePlain(w, text)
181}
182
183// mrDiffAPI geeft de three-dot diff van een merge request.
184func (s *Server) mrDiffAPI(w http.ResponseWriter, r *http.Request) {
185 repo, err := s.Store.RepoByPath(r.Context(), r.PathValue("owner"), r.PathValue("repo"))
186 if err != nil {
187 http.NotFound(w, r)
188 return
189 }
190 if !s.authorizeRepoRead(w, r, repo) {
191 return
192 }
193 number, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
194 if err != nil || number <= 0 || s.Git == "" || s.StoragePath() == "" {
195 http.NotFound(w, r)
196 return
197 }
198 mr, err := s.Store.MergeRequestByNumber(r.Context(), repo.ID, number)
199 if err != nil || safeRev(mr.SourceBranch, "") != mr.SourceBranch || safeRev(mr.TargetBranch, "") != mr.TargetBranch {
200 http.NotFound(w, r)
201 return
202 }
203 text, err := gitrepo.CompareDiff(r.Context(), s.Git, gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name), mr.TargetBranch, mr.SourceBranch)
204 if err != nil {
205 http.NotFound(w, r)
206 return
207 }
208 writePlain(w, text)
209}
210
211func writePlain(w http.ResponseWriter, text string) {
212 w.Header().Set("Content-Type", "text/plain; charset=utf-8")
213 w.Header().Set("Cache-Control", "no-store")
214 _, _ = w.Write([]byte(text))
215}
216
217func bearer(r *http.Request) string {
218 h := r.Header.Get("Authorization")
219 if strings.HasPrefix(strings.ToLower(h), "bearer ") {
220 return strings.TrimSpace(h[7:])
221 }
222 return ""
223}
224
225func copyRelease(src, dst string) error {
226 if err := os.MkdirAll(filepath.Dir(dst), 0o755); err != nil {
227 return err
228 }
229 in, err := os.Open(src)
230 if err != nil {
231 return err
232 }
233 defer in.Close()
234 out, err := os.OpenFile(dst, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0o644)
235 if err != nil {
236 return err
237 }
238 defer out.Close()
239 _, err = io.Copy(out, in)
240 return err
241}