BlueGit

timfa bluegit

Files

bluegit / internal / server / backup_test.go

backup_test.go

backup_test.go 15.5 KiB Download Raw
1package server
2
3import (
4 "context"
5 "encoding/json"
6 "io"
7 "net/http"
8 "net/http/httptest"
9 "net/url"
10 "os"
11 "path/filepath"
12 "strings"
13 "sync"
14 "testing"
15 "time"
16
17 "gitlab.com/Timfa/bluegit/internal/auth"
18 "gitlab.com/Timfa/bluegit/internal/backup"
19 "gitlab.com/Timfa/bluegit/internal/config"
20 "gitlab.com/Timfa/bluegit/internal/store"
21)
22
23type backupEnv struct {
24 srv *Server
25 st *store.Store
26 base string
27 tim store.User
28 tok string
29}
30
31func newBackupEnv(t *testing.T) *backupEnv {
32 t.Helper()
33 stateDir, storage := t.TempDir(), t.TempDir()
34 st, err := store.Open(filepath.Join(stateDir, "bluegit.db"), bytes32())
35 if err != nil {
36 t.Fatal(err)
37 }
38 t.Cleanup(func() { _ = st.Close() })
39 _ = os.WriteFile(filepath.Join(stateDir, "secret.key"), bytes32(), 0o600)
40 cfg := config.Config{
41 Listen: "127.0.0.1:0", StoragePath: storage, StatePath: stateDir,
42 Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test", BaseURL: "https://auth.timfalken.com"},
43 Git: config.Git{Binary: "git", DefaultBranch: "master"},
44 }
45 srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: "/bin/true", StateDir: stateDir}
46 ts := httptest.NewServer(srv.Handler())
47 t.Cleanup(ts.Close)
48 srv.Cfg.BaseURL = ts.URL
49 tim, err := st.UpsertUser(context.Background(), 1, "tim", "", false)
50 if err != nil {
51 t.Fatal(err)
52 }
53 if !tim.InstanceAdmin {
54 t.Skip("eerste gebruiker is geen beheerder")
55 }
56 _ = os.MkdirAll(filepath.Join(storage, "repos", "tim", "app.git"), 0o755)
57 _ = os.WriteFile(filepath.Join(storage, "repos", "tim", "app.git", "HEAD"), []byte("ref: refs/heads/master\n"), 0o644)
58 srv.backupInit()
59 srv.backupNote.Delay = 20 * time.Millisecond
60 return &backupEnv{srv: srv, st: st, base: ts.URL, tim: tim, tok: issue(t, st, tim.ID, "api")}
61}
62
63func keyed(t *testing.T, method, u, key string, body io.Reader) (int, []byte) {
64 t.Helper()
65 req, _ := http.NewRequest(method, u, body)
66 if key != "" {
67 req.Header.Set("Authorization", "Bearer "+key)
68 }
69 res, err := http.DefaultClient.Do(req)
70 if err != nil {
71 t.Fatal(err)
72 }
73 defer res.Body.Close()
74 b, _ := io.ReadAll(res.Body)
75 return res.StatusCode, b
76}
77
78// fakeBackup speelt de backup server: hij controleert elke handtekening.
79type fakeBackup struct {
80 mu sync.Mutex
81 secret string
82 notifies int
83 rollback []string
84 calls []string
85 bodies map[string]string
86 badSig int
87 ts *httptest.Server
88}
89
90func newFakeBackup(t *testing.T) *fakeBackup {
91 f := &fakeBackup{}
92 f.ts = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
93 body, _ := io.ReadAll(r.Body)
94 f.mu.Lock()
95 defer f.mu.Unlock()
96 if err := backup.Verify(r, f.secret, body, time.Now()); err != nil {
97 f.badSig++
98 http.Error(w, `{"error":"sig"}`, 401)
99 return
100 }
101 switch r.URL.Path {
102 case "/api/v1/notify":
103 f.notifies++
104 w.WriteHeader(204)
105 case "/api/v1/archives":
106 _ = json.NewEncoder(w).Encode(map[string]any{"archives": []backup.Archive{{Name: "bluegit-20261115-120000.tar.gz", CreatedAt: time.Date(2026, 11, 15, 12, 0, 0, 0, time.UTC), Size: 3 << 20}}})
107 case "/api/v1/status":
108 _, _ = w.Write([]byte(`{"version":"test","archive_interval":"24h0m0s","retention_days":30,"rollback":{"state":"idle"}}`))
109 case "/api/v1/rollback":
110 var in struct{ Archive string }
111 _ = json.Unmarshal(body, &in)
112 f.rollback = append(f.rollback, in.Archive)
113 w.WriteHeader(202)
114 case "/api/v1/admin/actions":
115 _, _ = w.Write([]byte(`{"actions":[
116 {"name":"status","method":"GET","path":"/api/v1/admin/status","bluegit":true},
117 {"name":"config","method":"GET","path":"/api/v1/admin/config","bluegit":true},
118 {"name":"config.update","method":"PUT","path":"/api/v1/admin/config","bluegit":true},
119 {"name":"sync","method":"POST","path":"/api/v1/admin/sync","bluegit":true},
120 {"name":"archive.delete","method":"DELETE","path":"/api/v1/admin/archives/{name}","bluegit":true,"params":["name"]},
121 {"name":"archive.download","method":"GET","path":"/api/v1/admin/archives/{name}/download","params":["name"]},
122 {"name":"rollback","method":"POST","path":"/api/v1/admin/rollback","bluegit":true},
123 {"name":"disconnect","method":"POST","path":"/api/v1/admin/disconnect","bluegit":true}]}`))
124 case "/api/v1/admin/config":
125 if r.Method == "PUT" {
126 f.calls = append(f.calls, "PUT config")
127 if f.bodies == nil {
128 f.bodies = map[string]string{}
129 }
130 f.bodies["config"] = string(body)
131 }
132 _, _ = w.Write([]byte(`{"fields":[{"key":"archive_interval","label":"Archiefinterval","kind":"duration","value":"24h"},{"key":"retention_days","label":"Bewaartermijn","kind":"int","value":"30"}],"data_dir":"/var/lib/bluegit-backup"}`))
133 case "/api/v1/admin/rollback":
134 var in struct{ Archive, Confirm string }
135 _ = json.Unmarshal(body, &in)
136 if in.Confirm != in.Archive {
137 http.Error(w, `{"error":"confirm"}`, 400)
138 return
139 }
140 f.rollback = append(f.rollback, in.Archive)
141 w.WriteHeader(202)
142 default:
143 if r.URL.Path == "/api/v1/admin/sync" || r.URL.Path == "/api/v1/admin/disconnect" || strings.HasPrefix(r.URL.Path, "/api/v1/admin/archives/") {
144 f.calls = append(f.calls, r.Method+" "+r.URL.Path+" "+string(body))
145 _, _ = w.Write([]byte(`{}`))
146 return
147 }
148 http.NotFound(w, r)
149 }
150 }))
151 t.Cleanup(f.ts.Close)
152 return f
153}
154
155type addedServer struct {
156 ID string `json:"id"`
157 Key string `json:"key"`
158}
159
160func addBackupServer(t *testing.T, e *backupEnv, name string) addedServer {
161 t.Helper()
162 code, b := rapi(t, e.base, e.tok, "POST", "/admin/backup/servers", map[string]any{"name": name})
163 if code != 201 {
164 t.Fatalf("server toevoegen: %d %s", code, b)
165 }
166 var a addedServer
167 _ = json.Unmarshal(b, &a)
168 if !strings.HasPrefix(a.Key, "bgbk_") || a.ID == "" {
169 t.Fatalf("%s", b)
170 }
171 return a
172}
173
174func TestBackupKeyAndKeyedAPI(t *testing.T) {
175 e := newBackupEnv(t)
176 // Zonder key: 401. Met een gewoon toegangstoken: ook 401.
177 if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/manifest", "", nil); code != 401 {
178 t.Fatalf("zonder key: %d", code)
179 }
180 if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/manifest", e.tok, nil); code != 401 {
181 t.Fatalf("bg_-token: %d", code)
182 }
183 // Alleen een beheerder maakt een backup server.
184 bob, _ := e.st.UpsertUser(context.Background(), 2, "bob", "", false)
185 if code, _ := rapi(t, e.base, issue(t, e.st, bob.ID, "api"), "POST", "/admin/backup/servers", map[string]any{"name": "x"}); code != 403 {
186 t.Fatalf("bob maakt server: %d", code)
187 }
188 k := addBackupServer(t, e, "nas")
189 code, b := keyed(t, "GET", e.base+"/api/v1/backup/info", k.Key, nil)
190 var info struct {
191 InstanceID string `json:"instance_id"`
192 Name string `json:"name"`
193 }
194 _ = json.Unmarshal(b, &info)
195 if code != 200 || info.InstanceID == "" || info.Name != "nas" {
196 t.Fatalf("info: %d %s", code, b)
197 }
198 code, b = keyed(t, "GET", e.base+"/api/v1/backup/manifest", k.Key, nil)
199 var m backup.Manifest
200 _ = json.Unmarshal(b, &m)
201 if code != 200 || m.Instance != info.InstanceID {
202 t.Fatalf("manifest: %d %.300s", code, b)
203 }
204 have := map[string]bool{}
205 for _, f := range m.Files {
206 have[f.Path] = true
207 }
208 for _, want := range []string{"state/bluegit.db", "state/secret.key", "data/repos/tim/app.git/HEAD"} {
209 if !have[want] {
210 t.Fatalf("manifest mist %s: %v", want, have)
211 }
212 }
213 code, b = keyed(t, "GET", e.base+"/api/v1/backup/file?path="+url.QueryEscape("data/repos/tim/app.git/HEAD"), k.Key, nil)
214 if code != 200 || string(b) != "ref: refs/heads/master\n" {
215 t.Fatalf("file: %d %q", code, b)
216 }
217 code, b = keyed(t, "GET", e.base+"/api/v1/backup/file?path=state/bluegit.db", k.Key, nil)
218 if code != 200 || !strings.HasPrefix(string(b), "SQLite format 3") {
219 t.Fatalf("db-kopie: %d %.20q", code, b)
220 }
221 for _, bad := range []string{"state/backup.json", "state/storage_path", "../../etc/passwd", "data/repos/../../x"} {
222 if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/file?path="+url.QueryEscape(bad), k.Key, nil); code != 404 {
223 t.Fatalf("%s: %d", bad, code)
224 }
225 }
226 // Een tweede server met een eigen key; nieuwe key voor de eerste.
227 k2 := addBackupServer(t, e, "offsite")
228 code, b = rapi(t, e.base, e.tok, "POST", "/admin/backup/servers/"+k.ID+"/key", nil)
229 var rot addedServer
230 _ = json.Unmarshal(b, &rot)
231 if code != 201 || rot.Key == k.Key {
232 t.Fatalf("nieuwe key: %d %s", code, b)
233 }
234 if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/info", k.Key, nil); code != 401 {
235 t.Fatalf("oude key werkt nog: %d", code)
236 }
237 if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/info", rot.Key, nil); code != 200 {
238 t.Fatalf("nieuwe key: %d", code)
239 }
240 if code, b := rapi(t, e.base, e.tok, "PUT", "/admin/backup/servers/"+k2.ID, map[string]any{"name": "Offsite 2"}); code != 200 || !strings.Contains(string(b), "Offsite 2") {
241 t.Fatalf("hernoemen: %d %s", code, b)
242 }
243 // Verwijderen: die key werkt niet meer, de andere wel.
244 if code, _ := rapi(t, e.base, e.tok, "DELETE", "/admin/backup/servers/"+k.ID, nil); code != 204 {
245 t.Fatalf("verwijderen: %d", code)
246 }
247 if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/info", rot.Key, nil); code != 401 {
248 t.Fatalf("na verwijderen: %d", code)
249 }
250 if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/info", k2.Key, nil); code != 200 {
251 t.Fatalf("andere server: %d", code)
252 }
253 if code, _ := rapi(t, e.base, e.tok, "GET", "/admin/backup/servers/onbekend", nil); code != 404 {
254 t.Fatalf("onbekend: %d", code)
255 }
256}
257
258func TestBackupMultipleServersAndControl(t *testing.T) {
259 e := newBackupEnv(t)
260 fa, fb := newFakeBackup(t), newFakeBackup(t)
261 ka, kb := addBackupServer(t, e, "nas"), addBackupServer(t, e, "offsite")
262 fa.secret, fb.secret = backup.SigningSecret(ka.Key), backup.SigningSecret(kb.Key)
263 for _, c := range []struct {
264 key, url string
265 }{{ka.Key, fa.ts.URL}, {kb.Key, fb.ts.URL}} {
266 code, b := keyed(t, "POST", e.base+"/api/v1/backup/connect", c.key, strings.NewReader(`{"server_url":"`+c.url+`","server_id":"s"}`))
267 if code != 200 {
268 t.Fatalf("connect: %d %s", code, b)
269 }
270 }
271 if code, _ := keyed(t, "POST", e.base+"/api/v1/backup/connect", ka.Key, strings.NewReader(`{"server_url":"ftp://x"}`)); code != 400 {
272 t.Fatalf("ftp-adres: %d", code)
273 }
274
275 // Een schrijvende actie geeft een ondertekende melding aan beide.
276 if code, b := rapi(t, e.base, e.tok, "POST", "/projects", map[string]any{"name": "Notify"}); code/100 != 2 {
277 t.Fatalf("project: %d %s", code, b)
278 }
279 deadline := time.Now().Add(5 * time.Second)
280 for {
281 fa.mu.Lock()
282 na := fa.notifies
283 fa.mu.Unlock()
284 fb.mu.Lock()
285 nb := fb.notifies
286 fb.mu.Unlock()
287 if na > 0 && nb > 0 {
288 break
289 }
290 if time.Now().After(deadline) {
291 t.Fatalf("meldingen: %d en %d", na, nb)
292 }
293 time.Sleep(20 * time.Millisecond)
294 }
295
296 // Lijst via de API en op de pagina.
297 code, b := rapi(t, e.base, e.tok, "GET", "/admin/backup", nil)
298 if code != 200 || strings.Count(string(b), `"connected":true`) != 2 {
299 t.Fatalf("admin backup: %d %s", code, b)
300 }
301 code, b = rapi(t, e.base, e.tok, "GET", "/admin/backup/servers/"+ka.ID, nil)
302 if code != 200 || !strings.Contains(string(b), "bluegit-20261115-120000.tar.gz") || !strings.Contains(string(b), `"retention_days"`) {
303 t.Fatalf("server: %d %s", code, b)
304 }
305 tc, csrf := sessionClient(t, e.st, e.base, e.tim.ID)
306 res, _ := tc.Get(e.base + "/admin/backup")
307 page := body(t, res)
308 for _, want := range []string{"nas", "offsite", `/admin/backup/s/` + ka.ID, `/admin/backup/s/` + kb.ID, `href="/admin/backup"`} {
309 if !strings.Contains(page, want) {
310 t.Fatalf("lijst mist %s: %.600s", want, page)
311 }
312 }
313 res, _ = tc.Get(e.base + "/admin/backup/s/" + ka.ID)
314 page = body(t, res)
315 for _, want := range []string{"bluegit-20261115-120000.tar.gz", `class="backup-danger"`, `name="understood"`, `name="confirm"`,
316 `act/config.update`, `name="retention_days" value="30"`, `act/sync`, `act/archive.delete`} {
317 if !strings.Contains(page, want) {
318 t.Fatalf("pagina mist %s: %.600s", want, page)
319 }
320 }
321
322 // Instellingen en sync vanuit BlueGit (formulier en API).
323 res, _ = tc.PostForm(e.base+"/admin/backup/s/"+ka.ID+"/act/config.update", url.Values{"csrf": {csrf}, "retention_days": {"9"}})
324 res.Body.Close()
325 if code, b := rapi(t, e.base, e.tok, "POST", "/admin/backup/servers/"+ka.ID+"/actions/sync", nil); code != 200 {
326 t.Fatalf("sync: %d %s", code, b)
327 }
328 if code, _ := rapi(t, e.base, e.tok, "POST", "/admin/backup/servers/"+ka.ID+"/actions/archive.download", map[string]any{"name": "x"}); code != 404 {
329 t.Fatalf("niet-BlueGit-actie: %d", code)
330 }
331 if code, _ := rapi(t, e.base, e.tok, "POST", "/admin/backup/servers/"+ka.ID+"/actions/archive.delete", map[string]any{"name": "bluegit-20261115-120000.tar.gz"}); code != 200 {
332 t.Fatalf("archief verwijderen: %d", code)
333 }
334 fa.mu.Lock()
335 if fa.bodies["config"] != `{"retention_days":"9"}` {
336 t.Fatalf("config %q", fa.bodies["config"])
337 }
338 calls := strings.Join(fa.calls, "|")
339 fa.mu.Unlock()
340 if !strings.Contains(calls, `POST /api/v1/admin/sync {"wait":"false"}`) || !strings.Contains(calls, "DELETE /api/v1/admin/archives/bluegit-20261115-120000.tar.gz") {
341 t.Fatalf("calls %s", calls)
342 }
343
344 // Rollback: zonder vinkje niets, verkeerde bevestiging 400, dan goed.
345 arch := "bluegit-20261115-120000.tar.gz"
346 res, _ = tc.PostForm(e.base+"/admin/backup/s/"+ka.ID+"/act/rollback", url.Values{"csrf": {csrf}, "archive": {arch}, "confirm": {arch}})
347 res.Body.Close()
348 if code, _ := rapi(t, e.base, e.tok, "POST", "/admin/backup/servers/"+ka.ID+"/actions/rollback", map[string]any{"archive": arch, "confirm": "ja"}); code != 400 {
349 t.Fatalf("verkeerde bevestiging: %d", code)
350 }
351 fa.mu.Lock()
352 if len(fa.rollback) != 0 {
353 t.Fatal("rollback zonder vinkje of bevestiging")
354 }
355 fa.mu.Unlock()
356 res, _ = tc.PostForm(e.base+"/admin/backup/s/"+ka.ID+"/act/rollback", url.Values{"csrf": {csrf}, "archive": {arch}, "confirm": {arch}, "understood": {"1"}})
357 res.Body.Close()
358 if code, b := rapi(t, e.base, e.tok, "POST", "/admin/backup/servers/"+ka.ID+"/actions/rollback", map[string]any{"archive": arch, "confirm": arch}); code != 202 {
359 t.Fatalf("rollback api: %d %s", code, b)
360 }
361 // Verwijderen laat de backup server ontkoppelen.
362 if code, _ := rapi(t, e.base, e.tok, "DELETE", "/admin/backup/servers/"+kb.ID, nil); code != 204 {
363 t.Fatalf("verwijderen: %d", code)
364 }
365 fb.mu.Lock()
366 if !strings.Contains(strings.Join(fb.calls, "|"), "POST /api/v1/admin/disconnect") {
367 t.Fatalf("geen disconnect: %v", fb.calls)
368 }
369 fb.mu.Unlock()
370 fa.mu.Lock()
371 defer fa.mu.Unlock()
372 if len(fa.rollback) != 2 || fa.badSig != 0 {
373 t.Fatalf("rollbacks %v, foute handtekeningen %d", fa.rollback, fa.badSig)
374 }
375}
376
377func TestBackupRestoreStagesAndRestarts(t *testing.T) {
378 e := newBackupEnv(t)
379 restarted := make(chan struct{}, 1)
380 e.srv.RequestRestart = func() { restarted <- struct{}{} }
381 k := addBackupServer(t, e, "nas")
382 // Ongeldig archief: 400, niets klaargezet.
383 if code, _ := keyed(t, "POST", e.base+"/api/v1/backup/restore", k.Key, strings.NewReader("x")); code != 400 {
384 t.Fatalf("ongeldig: %d", code)
385 }
386 if backup.HasPending(e.srv.StateDir) {
387 t.Fatal("READY na fout")
388 }
389 // Een archief uit het eigen manifest terugsturen.
390 tarball := buildTarFromInstance(t, e, k.Key)
391 code, b := keyed(t, "POST", e.base+"/api/v1/backup/restore", k.Key, strings.NewReader(tarball))
392 if code != 202 {
393 t.Fatalf("restore: %d %s", code, b)
394 }
395 select {
396 case <-restarted:
397 case <-time.After(3 * time.Second):
398 t.Fatal("geen herstart")
399 }
400 if !backup.HasPending(e.srv.StateDir) {
401 t.Fatal("geen READY")
402 }
403 restoreBusy.Store(false)
404}
405
406func buildTarFromInstance(t *testing.T, e *backupEnv, key string) string {
407 t.Helper()
408 _, b := keyed(t, "GET", e.base+"/api/v1/backup/manifest", key, nil)
409 var m backup.Manifest
410 _ = json.Unmarshal(b, &m)
411 var sb strings.Builder
412 files := map[string]string{}
413 for _, f := range m.Files {
414 _, data := keyed(t, "GET", e.base+"/api/v1/backup/file?path="+url.QueryEscape(f.Path), key, nil)
415 files[f.Path] = string(data)
416 }
417 writeTarGz(t, &sb, files)
418 return sb.String()
419}