| 1 | package server |
| 2 | |
| 3 | import ( |
| 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 | |
| 23 | type backupEnv struct { |
| 24 | srv *Server |
| 25 | st *store.Store |
| 26 | base string |
| 27 | tim store.User |
| 28 | tok string |
| 29 | } |
| 30 | |
| 31 | func 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 | |
| 63 | func 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. |
| 79 | type 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 | |
| 90 | func 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 | |
| 155 | type addedServer struct { |
| 156 | ID string `json:"id"` |
| 157 | Key string `json:"key"` |
| 158 | } |
| 159 | |
| 160 | func 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 | |
| 174 | func 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 | |
| 258 | func 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 | |
| 377 | func 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 | |
| 406 | func 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 | } |