BlueGit

timfa bluegit

Files

bluegit / internal / server / setup.go

setup.go

setup.go 6.5 KiB Download Raw
1package server
2
3import (
4 "context"
5 "net/http"
6 "os"
7 "strings"
8 "time"
9
10 "gitlab.com/Timfa/bluegit/internal/gitrepo"
11 "gitlab.com/Timfa/bluegit/internal/state"
12)
13
14// dirUsage is de laatst getelde grootte van de gekozen map.
15type dirUsage struct {
16 path string
17 n uint64
18 at time.Time
19 running bool
20}
21
22var (
23 // usageTTL is hoe lang een volledige telling geldig blijft.
24 usageTTL = 5 * time.Minute
25 // usageWait is hoe lang de pagina op een nieuwe telling wacht.
26 usageWait = 2 * time.Second
27 // usageLimit stopt een telling die vastloopt.
28 usageLimit = 15 * time.Minute
29)
30
31// bluegitUsage geeft de grootte van de map. De telling draait op de
32// achtergrond en is altijd volledig; de pagina wacht hooguit usageWait.
33// Is er dan nog geen uitkomst, dan geeft counting true en, als die er is,
34// de vorige uitkomst. ok is false als er nog niets te tonen valt.
35func (s *Server) bluegitUsage(path string) (n uint64, counting bool, ok bool) {
36 s.usageMu.Lock()
37 cur := s.usage
38 if cur.path != path {
39 cur = dirUsage{path: path}
40 s.usage = cur
41 }
42 stale := cur.at.IsZero() || time.Since(cur.at) >= usageTTL
43 var done chan struct{}
44 if stale && !cur.running {
45 s.usage.running = true
46 done = make(chan struct{})
47 s.usageDone = done
48 go s.countUsage(path, done)
49 } else if cur.running {
50 done = s.usageDone
51 }
52 s.usageMu.Unlock()
53 if stale && done != nil {
54 select {
55 case <-done:
56 case <-time.After(usageWait):
57 }
58 }
59 s.usageMu.Lock()
60 defer s.usageMu.Unlock()
61 cur = s.usage
62 if cur.path != path {
63 return 0, true, false
64 }
65 if cur.at.IsZero() {
66 return 0, cur.running, false
67 }
68 return cur.n, cur.running, true
69}
70
71func (s *Server) countUsage(path string, done chan struct{}) {
72 defer close(done)
73 ctx, cancel := context.WithTimeout(context.Background(), usageLimit)
74 defer cancel()
75 n, err := state.DirSize(ctx, path)
76 s.usageMu.Lock()
77 defer s.usageMu.Unlock()
78 if s.usage.path != path {
79 return
80 }
81 s.usage.running = false
82 if err != nil {
83 return
84 }
85 s.usage.n = n
86 s.usage.at = time.Now()
87}
88
89func (s *Server) noStorageText(r *http.Request) string {
90 return s.tr(r, "err.noStorage") + "\n"
91}
92
93func allowsWithoutStorage(r *http.Request) bool {
94 switch r.URL.Path {
95 case "/healthz", "/login", "/auth/callback", "/logout", "/setup", "/-/info", "/api/v1/ci/spec", "/api/v1/ci/presets", "/api/v1/openapi.json", "/api/v1/webhooks/openapi.json", "/api/v1/admin/storage", "/api/v1/admin/self-update":
96 return true
97 }
98 return strings.HasPrefix(r.URL.Path, "/assets/")
99}
100
101func isGitPath(path string) bool {
102 return strings.HasSuffix(path, "/info/refs") ||
103 strings.HasSuffix(path, "/git-upload-pack") ||
104 strings.HasSuffix(path, "/git-receive-pack")
105}
106
107func (s *Server) gate(next http.Handler) http.Handler {
108 return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
109 if allowsWithoutStorage(r) || s.StoragePath() != "" {
110 next.ServeHTTP(w, r)
111 return
112 }
113 if isGitPath(r.URL.Path) || strings.HasPrefix(r.URL.Path, "/api/") {
114 http.Error(w, s.noStorageText(r), http.StatusServiceUnavailable)
115 return
116 }
117 if p := s.who(r); p.OK && p.User.InstanceAdmin {
118 http.Redirect(w, r, "/setup", http.StatusFound)
119 return
120 }
121 next.ServeHTTP(w, r)
122 })
123}
124
125// StoragePath is de datadisk. Leeg zolang de beheerder er geen heeft gekozen.
126func (s *Server) StoragePath() string {
127 s.storageMu.RLock()
128 set, path := s.storageSet, s.storage
129 s.storageMu.RUnlock()
130 if set {
131 return path
132 }
133 s.storageMu.Lock()
134 defer s.storageMu.Unlock()
135 if !s.storageSet {
136 s.storage = s.Cfg.StoragePath
137 s.storageSet = true
138 }
139 return s.storage
140}
141
142// AdoptStorage zet het pad dat bij het starten al geldig was.
143func (s *Server) AdoptStorage(path string) {
144 s.storageMu.Lock()
145 s.storage = path
146 s.storageSet = true
147 s.storageMu.Unlock()
148 if path != "" && s.AfterStorage != nil {
149 s.AfterStorage(path)
150 }
151}
152
153func (s *Server) setupPage(w http.ResponseWriter, r *http.Request) {
154 if _, ok := s.adminOnly(w, r); !ok {
155 return
156 }
157 s.renderSetup(w, r, "", "")
158}
159
160func (s *Server) setupSave(w http.ResponseWriter, r *http.Request) {
161 if _, ok := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) {
162 return
163 }
164 info, moved, err := s.opSetStorage(r.FormValue("path"))
165 if err != nil {
166 s.renderSetup(w, r, s.trErr(r, err), strings.TrimSpace(r.FormValue("path")))
167 return
168 }
169 notice := s.tr(r, "err.storageSet", info.Path, state.Format(info.Free))
170 if moved {
171 notice = s.tr(r, "err.storageMoved", info.Path, state.Format(info.Free))
172 }
173 s.redirect(w, r, "/", notice, "")
174}
175
176func samePath(stateDir, path string) (bool, error) {
177 if stateDir == "" {
178 return false, nil
179 }
180 return strings.TrimRight(stateDir, "/") == strings.TrimRight(path, "/"), nil
181}
182
183func (s *Server) adminOnly(w http.ResponseWriter, r *http.Request) (bool, bool) {
184 u, ok := s.loginRequired(w, r)
185 if !ok {
186 return false, false
187 }
188 if !u.InstanceAdmin {
189 http.Error(w, s.tr(r, "err.noStorageAdmin"), http.StatusForbidden)
190 return false, false
191 }
192 return true, true
193}
194
195func (s *Server) renderSetup(w http.ResponseWriter, r *http.Request, problem, prefill string) {
196 v := s.view(w, r, "title.storage")
197 v.Page = "setup"
198 if problem != "" {
199 v.Err = problem
200 }
201 v.MinFree = state.Format(state.MinFreeBytes)
202 v.StoragePath = strings.TrimSpace(prefill)
203 if v.StoragePath == "" {
204 v.StoragePath = s.StoragePath()
205 }
206 if v.StoragePath == "" && s.StateDir != "" {
207 if saved, err := state.Read(s.StateDir); err == nil {
208 v.StoragePath = saved
209 }
210 }
211 if v.StoragePath != "" {
212 info, err := state.Inspect(v.StoragePath)
213 if info.Total > 0 {
214 v.StorageFree = state.Format(info.Free)
215 v.StorageUsed = state.Format(info.Used())
216 v.StorageReserved = state.Format(info.Reserved)
217 v.HasReserved = info.Reserved > 0
218 v.StorageTotal = state.Format(info.Total)
219 v.StoragePercent = state.Percent(info.Used(), info.Total)
220 n, counting, ok := s.bluegitUsage(info.Path)
221 if ok {
222 v.StorageBlueGit = state.Format(n)
223 }
224 v.StoragePartial = counting
225 }
226 if err != nil && v.Err == "" {
227 v.Err = s.trErr(r, err)
228 }
229 }
230 s.attachUpdate(&v, s.langOf(r))
231 s.render(w, "setup", v)
232}
233
234// RefreshHooks zet de pre-receive-hook opnieuw in elke repository die op de datadisk staat.
235func (s *Server) RefreshHooks() {
236 root := s.StoragePath()
237 if root == "" || s.HookBin == "" || s.Store == nil {
238 return
239 }
240 repos, err := s.Store.AllRepos(context.Background())
241 if err != nil {
242 return
243 }
244 for _, repo := range repos {
245 dir := gitrepo.Dir(root, repo.OwnerPath, repo.Name)
246 if _, err := os.Stat(dir); err != nil {
247 continue
248 }
249 if err := gitrepo.InstallHook(dir, s.HookBin); err != nil && s.Log != nil {
250 s.Log.Error("hook", "repo", repo.FullPath(), "err", err)
251 }
252 }
253}