BlueGit

timfa bluegit

Backup server: Backupserver-Key, meldingen, manifest/restore-API en Beheer > Backup met rollback

timfa Grok Bot · pushed by timfa

Authored 2026-11-15 · 2 days ago

Hash
aceeb5e0a3b88da33bddcfc10b9b11a99cc0302e
Parent
8a121bc7
Pipeline
Passed
20 files changed +2263 −3
README.md +2 −0
@@ -23,6 +23,7 @@ Het logo is de blauwe ster: [`assets/logo.svg`](assets/logo.svg).
23 23 - Periodiek onderhoud van de bare repositories (`git gc --auto`, plus `git maintenance` voor loose objects en incremental-repack als de git-binary dat kent). Standaard elke 24 uur (`git.maintenance_interval`; `off` of `0` zet het uit). Eén repo tegelijk, met lage prioriteit (`nice -n 19`) en gits eigen locking, nooit `--prune=now`. Een fout op één repo slaat die over. Installatiebeheerders zien de status en kunnen een ronde starten via `GET`/`POST /api/v1/admin/git-maintenance`.
24 24 - REST-API. Het schema staat op `/api/v1/openapi.json`.
25 25 - Self-update: de instantie installeert een nieuw AUR-pakket met pacman.
26 - Koppeling met een losse backup server ([bluegit-backup](https://git.timfalken.com/timfa/bluegit-backup)) onder Beheer > Backup: Backupserver-Key, een melding na elke wijziging, de archieflijst en een rollback met waarschuwing. Zie [docs/BACKUP.md](docs/BACKUP.md).
26 27 - Linkpreviews: een gedeelde pagina krijgt een kaart via Open Graph, oEmbed en `/-/card.png`.
27 28
28 29 Een repository hoort bij een gebruiker of bij een groep. De hoogste rol telt.
@@ -116,6 +117,7 @@ git clone http://tim:bg_…@127.0.0.1:8080/tim/demo.git
116 117 - [docs/CI.md](docs/CI.md) beschrijft `blue-ci-cd.yml` en Steve.
117 118 - [docs/AUR.md](docs/AUR.md) beschrijft het pakket en de self-update.
118 119 - [docs/BEHEER.md](docs/BEHEER.md) beschrijft de installatie op git.timfalken.com.
120 - [docs/BACKUP.md](docs/BACKUP.md) beschrijft de koppeling met een losse backup server (bluegit-backup): Backupserver-Key, meldingen, archieven en rollback.
119 121 - [docs/MIGRATIE.md](docs/MIGRATIE.md) beschrijft de overstap van de user-unit naar de system-service.
120 122 - [docs/ROADMAP.md](docs/ROADMAP.md) en [docs/VRAGEN.md](docs/VRAGEN.md) houden bij wat nog openstaat en welke besluiten al vastliggen.
121 123
@@ -23,6 +23,7 @@ Het logo is de blauwe ster: [`assets/logo.svg`](assets/logo.svg).
23- Periodiek onderhoud van de bare repositories (`git gc --auto`, plus `git maintenance` voor loose objects en incremental-repack als de git-binary dat kent). Standaard elke 24 uur (`git.maintenance_interval`; `off` of `0` zet het uit). Eén repo tegelijk, met lage prioriteit (`nice -n 19`) en gits eigen locking, nooit `--prune=now`. Een fout op één repo slaat die over. Installatiebeheerders zien de status en kunnen een ronde starten via `GET`/`POST /api/v1/admin/git-maintenance`.
23- Periodiek onderhoud van de bare repositories (`git gc --auto`, plus `git maintenance` voor loose objects en incremental-repack als de git-binary dat kent). Standaard elke 24 uur (`git.maintenance_interval`; `off` of `0` zet het uit). Eén repo tegelijk, met lage prioriteit (`nice -n 19`) en gits eigen locking, nooit `--prune=now`. Een fout op één repo slaat die over. Installatiebeheerders zien de status en kunnen een ronde starten via `GET`/`POST /api/v1/admin/git-maintenance`.
24- REST-API. Het schema staat op `/api/v1/openapi.json`.
24- REST-API. Het schema staat op `/api/v1/openapi.json`.
25- Self-update: de instantie installeert een nieuw AUR-pakket met pacman.
25- Self-update: de instantie installeert een nieuw AUR-pakket met pacman.
26- Koppeling met een losse backup server ([bluegit-backup](https://git.timfalken.com/timfa/bluegit-backup)) onder Beheer > Backup: Backupserver-Key, een melding na elke wijziging, de archieflijst en een rollback met waarschuwing. Zie [docs/BACKUP.md](docs/BACKUP.md).
26- Linkpreviews: een gedeelde pagina krijgt een kaart via Open Graph, oEmbed en `/-/card.png`.
27- Linkpreviews: een gedeelde pagina krijgt een kaart via Open Graph, oEmbed en `/-/card.png`.
27
28
28Een repository hoort bij een gebruiker of bij een groep. De hoogste rol telt.
29Een repository hoort bij een gebruiker of bij een groep. De hoogste rol telt.
@@ -116,6 +117,7 @@ git clone http://tim:bg_…@127.0.0.1:8080/tim/demo.git
116- [docs/CI.md](docs/CI.md) beschrijft `blue-ci-cd.yml` en Steve.
117- [docs/CI.md](docs/CI.md) beschrijft `blue-ci-cd.yml` en Steve.
117- [docs/AUR.md](docs/AUR.md) beschrijft het pakket en de self-update.
118- [docs/AUR.md](docs/AUR.md) beschrijft het pakket en de self-update.
118- [docs/BEHEER.md](docs/BEHEER.md) beschrijft de installatie op git.timfalken.com.
119- [docs/BEHEER.md](docs/BEHEER.md) beschrijft de installatie op git.timfalken.com.
120- [docs/BACKUP.md](docs/BACKUP.md) beschrijft de koppeling met een losse backup server (bluegit-backup): Backupserver-Key, meldingen, archieven en rollback.
119- [docs/MIGRATIE.md](docs/MIGRATIE.md) beschrijft de overstap van de user-unit naar de system-service.
121- [docs/MIGRATIE.md](docs/MIGRATIE.md) beschrijft de overstap van de user-unit naar de system-service.
120- [docs/ROADMAP.md](docs/ROADMAP.md) en [docs/VRAGEN.md](docs/VRAGEN.md) houden bij wat nog openstaat en welke besluiten al vastliggen.
122- [docs/ROADMAP.md](docs/ROADMAP.md) en [docs/VRAGEN.md](docs/VRAGEN.md) houden bij wat nog openstaat en welke besluiten al vastliggen.
121
123
cmd/bluegit/main.go +28 −0
@@ -11,11 +11,13 @@ import (
11 11 "os/signal"
12 12 "path/filepath"
13 13 "strings"
14 "sync/atomic"
14 15 "syscall"
15 16 "time"
16 17
17 18 "gitlab.com/Timfa/bluegit/internal/access"
18 19 "gitlab.com/Timfa/bluegit/internal/auth"
20 "gitlab.com/Timfa/bluegit/internal/backup"
19 21 "gitlab.com/Timfa/bluegit/internal/config"
20 22 "gitlab.com/Timfa/bluegit/internal/gitrepo"
21 23 "gitlab.com/Timfa/bluegit/internal/runner"
@@ -73,6 +75,13 @@ func serve(args []string) error {
73 75 if err := os.MkdirAll(cfg.StatePath, 0o750); err != nil {
74 76 return err
75 77 }
78 // Een backup die de backup server terugstuurde, staat uitgepakt klaar.
79 // Die komt op zijn plek vóór de database en de sleutel open gaan.
80 if applied, err := backup.ApplyPending(cfg.StatePath); err != nil {
81 return fmt.Errorf("backup terugzetten: %w", err)
82 } else if applied {
83 log.Warn("backup audit", "action", "restore_applied")
84 }
76 85 key, err := loadKey(filepath.Join(cfg.StatePath, "secret.key"))
77 86 if err != nil {
78 87 return err
@@ -103,9 +112,14 @@ func serve(args []string) error {
103 112 }
104 113 ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
105 114 defer stop()
115 var restart atomic.Bool
106 116 srv := &server.Server{
107 117 Cfg: cfg, Store: st, Auth: provider, Dev: dev, Git: cfg.Git.Binary, HookBin: exe, Log: log,
108 118 StateDir: cfg.StatePath,
119 RequestRestart: func() {
120 restart.Store(true)
121 stop()
122 },
109 123 }
110 124 if m, ok := provider.(auth.Mailer); ok && cfg.Auth.ClientSecret != "" {
111 125 srv.Mail = m
@@ -161,7 +175,9 @@ func serve(args []string) error {
161 175 srv.AdoptStorage(dataPath)
162 176 srv.RefreshHooks()
163 177 httpSrv := &http.Server{Addr: cfg.Listen, Handler: srv.Handler(), ReadHeaderTimeout: 10 * time.Second}
178 shutDone := make(chan struct{})
164 179 go func() {
180 defer close(shutDone)
165 181 <-ctx.Done()
166 182 if rn != nil {
167 183 // doNotInterrupt-jobs lopen uit; de website blijft zo lang bereikbaar.
@@ -175,6 +191,18 @@ func serve(args []string) error {
175 191 if err := httpSrv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
176 192 return err
177 193 }
194 if restart.Load() {
195 // Zelfde PID, dus systemd en een testharnas merken alleen een korte
196 // onderbreking. De nieuwe start zet de klaarstaande backup neer.
197 log.Warn("herstart na terugzetten van een backup")
198 <-shutDone
199 _ = st.Close()
200 self, err := os.Executable()
201 if err != nil {
202 return err
203 }
204 return syscall.Exec(self, os.Args, os.Environ())
205 }
178 206 return nil
179 207 }
180 208
@@ -11,11 +11,13 @@ import (
11 "os/signal"
11 "os/signal"
12 "path/filepath"
12 "path/filepath"
13 "strings"
13 "strings"
14 "sync/atomic"
14 "syscall"
15 "syscall"
15 "time"
16 "time"
16
17
17 "gitlab.com/Timfa/bluegit/internal/access"
18 "gitlab.com/Timfa/bluegit/internal/access"
18 "gitlab.com/Timfa/bluegit/internal/auth"
19 "gitlab.com/Timfa/bluegit/internal/auth"
20 "gitlab.com/Timfa/bluegit/internal/backup"
19 "gitlab.com/Timfa/bluegit/internal/config"
21 "gitlab.com/Timfa/bluegit/internal/config"
20 "gitlab.com/Timfa/bluegit/internal/gitrepo"
22 "gitlab.com/Timfa/bluegit/internal/gitrepo"
21 "gitlab.com/Timfa/bluegit/internal/runner"
23 "gitlab.com/Timfa/bluegit/internal/runner"
@@ -73,6 +75,13 @@ func serve(args []string) error {
73 if err := os.MkdirAll(cfg.StatePath, 0o750); err != nil {
75 if err := os.MkdirAll(cfg.StatePath, 0o750); err != nil {
74 return err
76 return err
75 }
77 }
78 // Een backup die de backup server terugstuurde, staat uitgepakt klaar.
79 // Die komt op zijn plek vóór de database en de sleutel open gaan.
80 if applied, err := backup.ApplyPending(cfg.StatePath); err != nil {
81 return fmt.Errorf("backup terugzetten: %w", err)
82 } else if applied {
83 log.Warn("backup audit", "action", "restore_applied")
84 }
76 key, err := loadKey(filepath.Join(cfg.StatePath, "secret.key"))
85 key, err := loadKey(filepath.Join(cfg.StatePath, "secret.key"))
77 if err != nil {
86 if err != nil {
78 return err
87 return err
@@ -103,9 +112,14 @@ func serve(args []string) error {
103 }
112 }
104 ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
113 ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
105 defer stop()
114 defer stop()
115 var restart atomic.Bool
106 srv := &server.Server{
116 srv := &server.Server{
107 Cfg: cfg, Store: st, Auth: provider, Dev: dev, Git: cfg.Git.Binary, HookBin: exe, Log: log,
117 Cfg: cfg, Store: st, Auth: provider, Dev: dev, Git: cfg.Git.Binary, HookBin: exe, Log: log,
108 StateDir: cfg.StatePath,
118 StateDir: cfg.StatePath,
119 RequestRestart: func() {
120 restart.Store(true)
121 stop()
122 },
109 }
123 }
110 if m, ok := provider.(auth.Mailer); ok && cfg.Auth.ClientSecret != "" {
124 if m, ok := provider.(auth.Mailer); ok && cfg.Auth.ClientSecret != "" {
111 srv.Mail = m
125 srv.Mail = m
@@ -161,7 +175,9 @@ func serve(args []string) error {
161 srv.AdoptStorage(dataPath)
175 srv.AdoptStorage(dataPath)
162 srv.RefreshHooks()
176 srv.RefreshHooks()
163 httpSrv := &http.Server{Addr: cfg.Listen, Handler: srv.Handler(), ReadHeaderTimeout: 10 * time.Second}
177 httpSrv := &http.Server{Addr: cfg.Listen, Handler: srv.Handler(), ReadHeaderTimeout: 10 * time.Second}
178 shutDone := make(chan struct{})
164 go func() {
179 go func() {
180 defer close(shutDone)
165 <-ctx.Done()
181 <-ctx.Done()
166 if rn != nil {
182 if rn != nil {
167 // doNotInterrupt-jobs lopen uit; de website blijft zo lang bereikbaar.
183 // doNotInterrupt-jobs lopen uit; de website blijft zo lang bereikbaar.
@@ -175,6 +191,18 @@ func serve(args []string) error {
175 if err := httpSrv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
191 if err := httpSrv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
176 return err
192 return err
177 }
193 }
194 if restart.Load() {
195 // Zelfde PID, dus systemd en een testharnas merken alleen een korte
196 // onderbreking. De nieuwe start zet de klaarstaande backup neer.
197 log.Warn("herstart na terugzetten van een backup")
198 <-shutDone
199 _ = st.Close()
200 self, err := os.Executable()
201 if err != nil {
202 return err
203 }
204 return syscall.Exec(self, os.Args, os.Environ())
205 }
178 return nil
206 return nil
179}
207}
180
208
docs/BACKUP.md added +69 −0
@@ -0,0 +1,69 @@
1 # Backup server (bluegit-backup)
2
3 Een losse backup server ([timfa/bluegit-backup](https://git.timfalken.com/timfa/bluegit-backup)) houdt een kopie bij van alle gegevens en configuratie van één BlueGit. Hij haalt ze langzaam op, krijgt na elke wijziging een melding, maakt periodiek een gecomprimeerd archief, en kan BlueGit naar zo'n archief terugzetten.
4
5 ## In BlueGit
6
7 **Beheer > Backup** (`/admin/backup`, alleen installatiebeheerders):
8
9 - **Backupserver-Key** maken (één keer getoond), vervangen of intrekken. Er is altijd hoogstens één key; een nieuwe key maakt de oude ongeldig en vergeet de gekoppelde server.
10 - **Gekoppelde backup server**: adres, laatste contact, archiefinterval en bewaartermijn.
11 - **Backup-archieven** als lijst, met per archief een rollback. Die staat achter een grote rode waarschuwing, een vinkje ("ik begrijp dat dit niet terug te draaien is"), het intypen van de archiefnaam en een bevestigingsdialoog.
12
13 Dezelfde acties via de API (token van een beheerder, scope `api`/`admin`):
14
15 | | |
16 |---|---|
17 | `GET /api/v1/admin/backup` | status, gekoppelde server, archieven |
18 | `POST /api/v1/admin/backup/key` | nieuwe key, `{"key": "bgbk_…"}` (eenmalig) |
19 | `DELETE /api/v1/admin/backup/key` | key intrekken |
20 | `POST /api/v1/admin/backup/rollback` | `{"archive": "naam", "confirm": "naam"}` |
21
22 ## Protocol
23
24 **De backup server praat met BlueGit** met de key als bearer-token (`Authorization: Bearer bgbk_…`):
25
26 | | |
27 |---|---|
28 | `GET /api/v1/backup/info` | `instance_id`, `base_url`, gekoppelde server |
29 | `POST /api/v1/backup/connect` | `{"server_url", "server_id"}`: waar BlueGit meldingen heen stuurt |
30 | `GET /api/v1/backup/manifest` | alle bestanden: pad, grootte, mtime, mode; de database ook met sha256 |
31 | `GET /api/v1/backup/file?path=…` | één bestand |
32 | `POST /api/v1/backup/restore` | tar.gz met logische paden; BlueGit pakt uit en herstart (202) |
33
34 Vijf mislukte key-pogingen per minuut per IP geven daarna `429`.
35
36 **BlueGit praat met de backup server** met een HMAC-handtekening. Het geheim is `sha256("bluegit-backup-sign:" + key)` als hex; beide kanten leiden het af uit de key. Koppen:
37
38 ```text
39 X-BlueGit-Instance: <instance_id>
40 X-BlueGit-Timestamp: <unix-seconden> (hoogstens 5 minuten verschil)
41 X-BlueGit-Signature: hex(HMAC-SHA256(geheim, METHOD "\n" PAD "\n" TS "\n" sha256hex(body)))
42 ```
43
44 | | |
45 |---|---|
46 | `POST /api/v1/notify` | er is iets veranderd |
47 | `GET /api/v1/archives` | `{"archives": [{name, created_at, size}]}` |
48 | `GET /api/v1/status` | interval, bewaartermijn, stand van de laatste rollback |
49 | `POST /api/v1/rollback` | `{"archive": "naam"}` |
50
51 **Meldingen.** Na elk schrijvend HTTP-verzoek (behalve de backup-API zelf en `git-upload-pack`), na elke push (ook SSH) en bij elke CI-gebeurtenis meldt BlueGit een wijziging. Meldingen worden 2 seconden gebundeld en bij een fout tot vier keer opnieuw geprobeerd. De backup server haalt daarnaast periodiek alles op, dus een gemiste melding kost alleen vertraging. Het adres van de backup server mag een privéadres zijn (de beheerder koppelt hem met een eigen key); de SSRF-regels van webhooks gelden hier niet.
52
53 ## Wat er in een backup zit
54
55 ```text
56 state/bluegit.db consistente kopie (VACUUM INTO), niet het live bestand
57 state/secret.key nodig voor de versleutelde geheimen in de database
58 state/ssh/… SSH-hostkey
59 state/logos/…, state/avatars/…
60 data/repos/… bare repositories
61 data/releases/… release-assets (zonder .incoming)
62 data/artifacts/… CI-artifacts
63 ```
64
65 Niet mee: `config.yml`, `storage_path`, `cache.json`, `backup.json` en `instance_id` (horen bij deze installatie), `data/work`, `*.lock` en symlinks. De koppeling staat in `<state>/backup.json` (0600, alleen de hash van de key) en niet in de database, zodat een rollback naar een oud archief de koppeling niet terugdraait.
66
67 ## Terugzetten
68
69 `POST /api/v1/backup/restore` pakt het archief uit in `<state>/.restore` en `<datadisk>/.restore`; de live gegevens blijven tot dan onaangeroerd. Een ongeldig archief (pad buiten de lijst hierboven, `..`, symlink, geen database of `secret.key`) wordt geweigerd en opgeruimd. Daarna weigert BlueGit schrijvende verzoeken (503), sluit af zoals bij een gewone stop en start zichzelf opnieuw met `exec` (zelfde PID, dus systemd ziet geen crash). Bij de start, vóór de database opengaat, worden de mappen omgewisseld: alles uit de lijst hierboven wordt vervangen, ook wat niet in het archief zat. Een BlueGit zonder datadisk kan geen archief met repositories aannemen; kies eerst de datadisk in `/setup`.
@@ -0,0 +1,69 @@
1# Backup server (bluegit-backup)
2
3Een losse backup server ([timfa/bluegit-backup](https://git.timfalken.com/timfa/bluegit-backup)) houdt een kopie bij van alle gegevens en configuratie van één BlueGit. Hij haalt ze langzaam op, krijgt na elke wijziging een melding, maakt periodiek een gecomprimeerd archief, en kan BlueGit naar zo'n archief terugzetten.
4
5## In BlueGit
6
7**Beheer > Backup** (`/admin/backup`, alleen installatiebeheerders):
8
9- **Backupserver-Key** maken (één keer getoond), vervangen of intrekken. Er is altijd hoogstens één key; een nieuwe key maakt de oude ongeldig en vergeet de gekoppelde server.
10- **Gekoppelde backup server**: adres, laatste contact, archiefinterval en bewaartermijn.
11- **Backup-archieven** als lijst, met per archief een rollback. Die staat achter een grote rode waarschuwing, een vinkje ("ik begrijp dat dit niet terug te draaien is"), het intypen van de archiefnaam en een bevestigingsdialoog.
12
13Dezelfde acties via de API (token van een beheerder, scope `api`/`admin`):
14
15| | |
16|---|---|
17| `GET /api/v1/admin/backup` | status, gekoppelde server, archieven |
18| `POST /api/v1/admin/backup/key` | nieuwe key, `{"key": "bgbk_…"}` (eenmalig) |
19| `DELETE /api/v1/admin/backup/key` | key intrekken |
20| `POST /api/v1/admin/backup/rollback` | `{"archive": "naam", "confirm": "naam"}` |
21
22## Protocol
23
24**De backup server praat met BlueGit** met de key als bearer-token (`Authorization: Bearer bgbk_…`):
25
26| | |
27|---|---|
28| `GET /api/v1/backup/info` | `instance_id`, `base_url`, gekoppelde server |
29| `POST /api/v1/backup/connect` | `{"server_url", "server_id"}`: waar BlueGit meldingen heen stuurt |
30| `GET /api/v1/backup/manifest` | alle bestanden: pad, grootte, mtime, mode; de database ook met sha256 |
31| `GET /api/v1/backup/file?path=…` | één bestand |
32| `POST /api/v1/backup/restore` | tar.gz met logische paden; BlueGit pakt uit en herstart (202) |
33
34Vijf mislukte key-pogingen per minuut per IP geven daarna `429`.
35
36**BlueGit praat met de backup server** met een HMAC-handtekening. Het geheim is `sha256("bluegit-backup-sign:" + key)` als hex; beide kanten leiden het af uit de key. Koppen:
37
38```text
39X-BlueGit-Instance: <instance_id>
40X-BlueGit-Timestamp: <unix-seconden> (hoogstens 5 minuten verschil)
41X-BlueGit-Signature: hex(HMAC-SHA256(geheim, METHOD "\n" PAD "\n" TS "\n" sha256hex(body)))
42```
43
44| | |
45|---|---|
46| `POST /api/v1/notify` | er is iets veranderd |
47| `GET /api/v1/archives` | `{"archives": [{name, created_at, size}]}` |
48| `GET /api/v1/status` | interval, bewaartermijn, stand van de laatste rollback |
49| `POST /api/v1/rollback` | `{"archive": "naam"}` |
50
51**Meldingen.** Na elk schrijvend HTTP-verzoek (behalve de backup-API zelf en `git-upload-pack`), na elke push (ook SSH) en bij elke CI-gebeurtenis meldt BlueGit een wijziging. Meldingen worden 2 seconden gebundeld en bij een fout tot vier keer opnieuw geprobeerd. De backup server haalt daarnaast periodiek alles op, dus een gemiste melding kost alleen vertraging. Het adres van de backup server mag een privéadres zijn (de beheerder koppelt hem met een eigen key); de SSRF-regels van webhooks gelden hier niet.
52
53## Wat er in een backup zit
54
55```text
56state/bluegit.db consistente kopie (VACUUM INTO), niet het live bestand
57state/secret.key nodig voor de versleutelde geheimen in de database
58state/ssh/… SSH-hostkey
59state/logos/…, state/avatars/…
60data/repos/… bare repositories
61data/releases/… release-assets (zonder .incoming)
62data/artifacts/… CI-artifacts
63```
64
65Niet mee: `config.yml`, `storage_path`, `cache.json`, `backup.json` en `instance_id` (horen bij deze installatie), `data/work`, `*.lock` en symlinks. De koppeling staat in `<state>/backup.json` (0600, alleen de hash van de key) en niet in de database, zodat een rollback naar een oud archief de koppeling niet terugdraait.
66
67## Terugzetten
68
69`POST /api/v1/backup/restore` pakt het archief uit in `<state>/.restore` en `<datadisk>/.restore`; de live gegevens blijven tot dan onaangeroerd. Een ongeldig archief (pad buiten de lijst hierboven, `..`, symlink, geen database of `secret.key`) wordt geweigerd en opgeruimd. Daarna weigert BlueGit schrijvende verzoeken (503), sluit af zoals bij een gewone stop en start zichzelf opnieuw met `exec` (zelfde PID, dus systemd ziet geen crash). Bij de start, vóór de database opengaat, worden de mappen omgewisseld: alles uit de lijst hierboven wordt vervangen, ook wat niet in het archief zat. Een BlueGit zonder datadisk kan geen archief met repositories aannemen; kies eerst de datadisk in `/setup`.
docs/BEHEER.md +4 −0
@@ -61,3 +61,7 @@ Sitebeheerders zien in de bovenbalk één tab **Beheer**. Daaronder staan de sub
61 61 ## Releases publiek bij een privé repo
62 62
63 63 Zet in de instellingen van de repo **Zichtbaarheid releases** op *Publiek*. Iedereen kan dan de Releases-pagina zien en de assets downloaden, ook zonder login. De code, de bron-archieven, de pipelines en de rest blijven alleen voor leden. In het overzicht op de startpagina staan zulke repo's onder "Publieke releases", met alleen hun naam en de eerste regel van de beschrijving. Details staan in [agents.md](agents.md#zichtbaarheid-van-releases).
64
65 ## Backup
66
67 Een losse backup server (bluegit-backup) koppel je onder **Beheer > Backup** met een Backupserver-Key. Daar staan ook de archieven en de rollback. Zie [BACKUP.md](BACKUP.md).
@@ -61,3 +61,7 @@ Sitebeheerders zien in de bovenbalk één tab **Beheer**. Daaronder staan de sub
61## Releases publiek bij een privé repo
61## Releases publiek bij een privé repo
62
62
63Zet in de instellingen van de repo **Zichtbaarheid releases** op *Publiek*. Iedereen kan dan de Releases-pagina zien en de assets downloaden, ook zonder login. De code, de bron-archieven, de pipelines en de rest blijven alleen voor leden. In het overzicht op de startpagina staan zulke repo's onder "Publieke releases", met alleen hun naam en de eerste regel van de beschrijving. Details staan in [agents.md](agents.md#zichtbaarheid-van-releases).
63Zet in de instellingen van de repo **Zichtbaarheid releases** op *Publiek*. Iedereen kan dan de Releases-pagina zien en de assets downloaden, ook zonder login. De code, de bron-archieven, de pipelines en de rest blijven alleen voor leden. In het overzicht op de startpagina staan zulke repo's onder "Publieke releases", met alleen hun naam en de eerste regel van de beschrijving. Details staan in [agents.md](agents.md#zichtbaarheid-van-releases).
64
65## Backup
66
67Een losse backup server (bluegit-backup) koppel je onder **Beheer > Backup** met een Backupserver-Key. Daar staan ook de archieven en de rollback. Zie [BACKUP.md](BACKUP.md).
internal/backup/backup_test.go added +266 −0
@@ -0,0 +1,266 @@
1 package backup
2
3 import (
4 "archive/tar"
5 "bytes"
6 "compress/gzip"
7 "net/http"
8 "os"
9 "path/filepath"
10 "strings"
11 "testing"
12 "time"
13 )
14
15 func TestSignVerify(t *testing.T) {
16 sec := SigningSecret("bgbk_x")
17 now := time.Unix(1_800_000_000, 0)
18 body := []byte(`{"archive":"a"}`)
19 req, _ := http.NewRequest("POST", "http://b/api/v1/rollback", bytes.NewReader(body))
20 Sign(req, sec, "inst", body, now)
21 if err := Verify(req, sec, body, now.Add(time.Minute)); err != nil {
22 t.Fatal(err)
23 }
24 if Verify(req, sec, []byte(`{"archive":"b"}`), now) == nil {
25 t.Fatal("andere body geaccepteerd")
26 }
27 if Verify(req, SigningSecret("bgbk_y"), body, now) == nil {
28 t.Fatal("ander geheim geaccepteerd")
29 }
30 if Verify(req, sec, body, now.Add(10*time.Minute)) == nil {
31 t.Fatal("oude timestamp geaccepteerd")
32 }
33 req.URL.Path = "/api/v1/notify"
34 if Verify(req, sec, body, now) == nil {
35 t.Fatal("ander pad geaccepteerd")
36 }
37 }
38
39 func TestKeyLifecycle(t *testing.T) {
40 m := &Manager{Dir: t.TempDir()}
41 if _, ok := m.Check("bgbk_nope"); ok {
42 t.Fatal("check zonder key")
43 }
44 key, c, err := m.NewKey("tim")
45 if err != nil || !strings.HasPrefix(key, KeyPrefix) || c.KeyHash == "" {
46 t.Fatal(key, err)
47 }
48 raw, _ := os.ReadFile(filepath.Join(m.Dir, "backup.json"))
49 if strings.Contains(string(raw), key) {
50 t.Fatal("key staat leesbaar op schijf")
51 }
52 fi, _ := os.Stat(filepath.Join(m.Dir, "backup.json"))
53 if fi.Mode().Perm() != 0o600 {
54 t.Fatalf("mode %v", fi.Mode())
55 }
56 if _, ok := m.Check(key); !ok {
57 t.Fatal("eigen key geweigerd")
58 }
59 if _, err := m.Connect("http://backup:9000/", "srv1"); err != nil {
60 t.Fatal(err)
61 }
62 c, _ = m.Load()
63 if !c.Connected() || c.ServerURL != "http://backup:9000" || c.SignSecret != SigningSecret(key) {
64 t.Fatalf("%+v", c)
65 }
66 key2, _, _ := m.NewKey("tim")
67 if _, ok := m.Check(key); ok {
68 t.Fatal("oude key werkt nog")
69 }
70 if _, ok := m.Check(key2); !ok {
71 t.Fatal("nieuwe key geweigerd")
72 }
73 if c, _ := m.Load(); c.Connected() {
74 t.Fatal("nieuwe key houdt oude server vast")
75 }
76 id1, _ := m.InstanceID()
77 id2, _ := m.InstanceID()
78 if id1 == "" || id1 != id2 {
79 t.Fatal("instance-id niet vast")
80 }
81 _ = m.Revoke()
82 if _, ok := m.Check(key2); ok {
83 t.Fatal("ingetrokken key werkt")
84 }
85 }
86
87 func TestCleanLogical(t *testing.T) {
88 good := []string{"state/bluegit.db", "state/secret.key", "state/ssh/host_ed25519", "data/repos/tim/a.git/HEAD", "data/releases/tim/a/v1/x.tgz"}
89 bad := []string{"", "/etc/passwd", "state/../x", "state/storage_path", "state/backup.json", "state/instance_id", "data/work/1/x", "data/releases/.incoming/x", "data/repos", "state/ssh", "x/y", "data/repos/../../etc", "state//secret.key", "data\\repos\\x"}
90 for _, p := range good {
91 if _, ok := CleanLogical(p); !ok {
92 t.Errorf("geweigerd: %s", p)
93 }
94 }
95 for _, p := range bad {
96 if _, ok := CleanLogical(p); ok {
97 t.Errorf("toegestaan: %s", p)
98 }
99 }
100 }
101
102 func write(t *testing.T, p, s string) {
103 t.Helper()
104 if err := os.MkdirAll(filepath.Dir(p), 0o755); err != nil {
105 t.Fatal(err)
106 }
107 if err := os.WriteFile(p, []byte(s), 0o644); err != nil {
108 t.Fatal(err)
109 }
110 }
111
112 func fakeTree(t *testing.T) Tree {
113 st, data := t.TempDir(), t.TempDir()
114 write(t, filepath.Join(st, "bluegit.db"), "live-db")
115 write(t, filepath.Join(st, "secret.key"), "k")
116 write(t, filepath.Join(st, "storage_path"), data)
117 write(t, filepath.Join(st, "backup.json"), "{}")
118 write(t, filepath.Join(st, "ssh", "host_ed25519"), "hk")
119 write(t, filepath.Join(data, "repos", "tim", "a.git", "HEAD"), "ref: refs/heads/master")
120 write(t, filepath.Join(data, "repos", "tim", "a.git", "index.lock"), "x")
121 write(t, filepath.Join(data, "releases", ".incoming", "x"), "x")
122 write(t, filepath.Join(data, "releases", "tim", "a", "v1", "a.bin"), "bin")
123 write(t, filepath.Join(data, "work", "1", "f"), "x")
124 _ = os.Symlink("/etc/passwd", filepath.Join(data, "repos", "tim", "evil"))
125 return Tree{StateDir: st, DataDir: data, Snapshot: func(dst string) error {
126 return os.WriteFile(dst, []byte("snapshot-db"), 0o600)
127 }}
128 }
129
130 func TestManifestAndResolve(t *testing.T) {
131 tr := fakeTree(t)
132 m, err := tr.Build("inst")
133 if err != nil {
134 t.Fatal(err)
135 }
136 var paths []string
137 for _, e := range m.Files {
138 paths = append(paths, e.Path)
139 }
140 got := strings.Join(paths, ",")
141 want := "data/releases/tim/a/v1/a.bin,data/repos/tim/a.git/HEAD,state/bluegit.db,state/secret.key,state/ssh/host_ed25519"
142 if got != want {
143 t.Fatalf("manifest\n got %s\nwant %s", got, want)
144 }
145 if m.Files[2].SHA256 == "" {
146 t.Fatal("database zonder hash")
147 }
148 p, err := tr.Resolve(DBPath)
149 if err != nil {
150 t.Fatal(err)
151 }
152 if b, _ := os.ReadFile(p); string(b) != "snapshot-db" {
153 t.Fatalf("database komt niet uit de kopie: %s", b)
154 }
155 for _, bad := range []string{"state/storage_path", "data/repos/tim/evil", "data/repos/../../etc/passwd"} {
156 if _, err := tr.Resolve(bad); err == nil {
157 t.Errorf("resolve %s toegestaan", bad)
158 }
159 }
160 }
161
162 type tf struct {
163 name, body string
164 typ byte
165 }
166
167 func tgz(t *testing.T, files []tf) []byte {
168 var buf bytes.Buffer
169 gz := gzip.NewWriter(&buf)
170 tw := tar.NewWriter(gz)
171 for _, f := range files {
172 typ := f.typ
173 if typ == 0 {
174 typ = tar.TypeReg
175 }
176 h := &tar.Header{Name: f.name, Mode: 0o644, Size: int64(len(f.body)), Typeflag: typ, ModTime: time.Unix(1_700_000_000, 0)}
177 if typ == tar.TypeSymlink {
178 h.Size, h.Linkname = 0, "/etc/passwd"
179 }
180 if err := tw.WriteHeader(h); err != nil {
181 t.Fatal(err)
182 }
183 if typ == tar.TypeReg {
184 _, _ = tw.Write([]byte(f.body))
185 }
186 }
187 tw.Close()
188 gz.Close()
189 return buf.Bytes()
190 }
191
192 func TestStageAndApply(t *testing.T) {
193 tr := fakeTree(t)
194 archive := tgz(t, []tf{
195 {name: "state/bluegit.db", body: "old-db"},
196 {name: "state/secret.key", body: "old-key"},
197 {name: "data/repos/tim/b.git/HEAD", body: "ref: refs/heads/main"},
198 })
199 n, err := tr.Stage(bytes.NewReader(archive))
200 if err != nil || n != 3 {
201 t.Fatal(n, err)
202 }
203 if b, _ := os.ReadFile(filepath.Join(tr.StateDir, "bluegit.db")); string(b) != "live-db" {
204 t.Fatal("stage raakte de live database")
205 }
206 if !HasPending(tr.StateDir) {
207 t.Fatal("geen READY")
208 }
209 ok, err := ApplyPending(tr.StateDir)
210 if err != nil || !ok {
211 t.Fatal(ok, err)
212 }
213 check := func(p, want string) {
214 t.Helper()
215 b, err := os.ReadFile(p)
216 if want == "" {
217 if err == nil {
218 t.Errorf("%s bestaat nog", p)
219 }
220 return
221 }
222 if string(b) != want {
223 t.Errorf("%s = %q, wil %q", p, b, want)
224 }
225 }
226 check(filepath.Join(tr.StateDir, "bluegit.db"), "old-db")
227 check(filepath.Join(tr.StateDir, "secret.key"), "old-key")
228 check(filepath.Join(tr.StateDir, "ssh", "host_ed25519"), "")
229 check(filepath.Join(tr.StateDir, "backup.json"), "{}")
230 check(filepath.Join(tr.StateDir, "storage_path"), tr.DataDir)
231 check(filepath.Join(tr.DataDir, "repos", "tim", "b.git", "HEAD"), "ref: refs/heads/main")
232 check(filepath.Join(tr.DataDir, "repos", "tim", "a.git", "HEAD"), "")
233 check(filepath.Join(tr.DataDir, "releases", "tim", "a", "v1", "a.bin"), "")
234 check(filepath.Join(tr.DataDir, "work", "1", "f"), "x")
235 if HasPending(tr.StateDir) {
236 t.Fatal("READY blijft staan")
237 }
238 if ok, _ := ApplyPending(tr.StateDir); ok {
239 t.Fatal("tweede keer toegepast")
240 }
241 }
242
243 func TestStageRejects(t *testing.T) {
244 cases := map[string][]tf{
245 "traversal": {{name: "state/bluegit.db", body: "x"}, {name: "state/secret.key", body: "k"}, {name: "data/repos/../../../etc/x", body: "x"}},
246 "symlink": {{name: "state/bluegit.db", body: "x"}, {name: "state/secret.key", body: "k"}, {name: "data/repos/a/l", typ: tar.TypeSymlink}},
247 "onbekend": {{name: "state/bluegit.db", body: "x"}, {name: "state/secret.key", body: "k"}, {name: "state/storage_path", body: "/"}},
248 "zonder-db": {{name: "state/secret.key", body: "k"}},
249 "zonder-key": {{name: "state/bluegit.db", body: "x"}},
250 }
251 for name, files := range cases {
252 tr := fakeTree(t)
253 if _, err := tr.Stage(bytes.NewReader(tgz(t, files))); err == nil {
254 t.Errorf("%s: geaccepteerd", name)
255 }
256 if HasPending(tr.StateDir) {
257 t.Errorf("%s: READY na fout", name)
258 }
259 if _, err := os.Stat(filepath.Join(tr.StateDir, ".restore")); err == nil {
260 t.Errorf("%s: staging blijft staan", name)
261 }
262 }
263 if _, err := fakeTree(t).Stage(strings.NewReader("geen gzip")); err == nil {
264 t.Error("geen gzip geaccepteerd")
265 }
266 }
@@ -0,0 +1,266 @@
1package backup
2
3import (
4 "archive/tar"
5 "bytes"
6 "compress/gzip"
7 "net/http"
8 "os"
9 "path/filepath"
10 "strings"
11 "testing"
12 "time"
13)
14
15func TestSignVerify(t *testing.T) {
16 sec := SigningSecret("bgbk_x")
17 now := time.Unix(1_800_000_000, 0)
18 body := []byte(`{"archive":"a"}`)
19 req, _ := http.NewRequest("POST", "http://b/api/v1/rollback", bytes.NewReader(body))
20 Sign(req, sec, "inst", body, now)
21 if err := Verify(req, sec, body, now.Add(time.Minute)); err != nil {
22 t.Fatal(err)
23 }
24 if Verify(req, sec, []byte(`{"archive":"b"}`), now) == nil {
25 t.Fatal("andere body geaccepteerd")
26 }
27 if Verify(req, SigningSecret("bgbk_y"), body, now) == nil {
28 t.Fatal("ander geheim geaccepteerd")
29 }
30 if Verify(req, sec, body, now.Add(10*time.Minute)) == nil {
31 t.Fatal("oude timestamp geaccepteerd")
32 }
33 req.URL.Path = "/api/v1/notify"
34 if Verify(req, sec, body, now) == nil {
35 t.Fatal("ander pad geaccepteerd")
36 }
37}
38
39func TestKeyLifecycle(t *testing.T) {
40 m := &Manager{Dir: t.TempDir()}
41 if _, ok := m.Check("bgbk_nope"); ok {
42 t.Fatal("check zonder key")
43 }
44 key, c, err := m.NewKey("tim")
45 if err != nil || !strings.HasPrefix(key, KeyPrefix) || c.KeyHash == "" {
46 t.Fatal(key, err)
47 }
48 raw, _ := os.ReadFile(filepath.Join(m.Dir, "backup.json"))
49 if strings.Contains(string(raw), key) {
50 t.Fatal("key staat leesbaar op schijf")
51 }
52 fi, _ := os.Stat(filepath.Join(m.Dir, "backup.json"))
53 if fi.Mode().Perm() != 0o600 {
54 t.Fatalf("mode %v", fi.Mode())
55 }
56 if _, ok := m.Check(key); !ok {
57 t.Fatal("eigen key geweigerd")
58 }
59 if _, err := m.Connect("http://backup:9000/", "srv1"); err != nil {
60 t.Fatal(err)
61 }
62 c, _ = m.Load()
63 if !c.Connected() || c.ServerURL != "http://backup:9000" || c.SignSecret != SigningSecret(key) {
64 t.Fatalf("%+v", c)
65 }
66 key2, _, _ := m.NewKey("tim")
67 if _, ok := m.Check(key); ok {
68 t.Fatal("oude key werkt nog")
69 }
70 if _, ok := m.Check(key2); !ok {
71 t.Fatal("nieuwe key geweigerd")
72 }
73 if c, _ := m.Load(); c.Connected() {
74 t.Fatal("nieuwe key houdt oude server vast")
75 }
76 id1, _ := m.InstanceID()
77 id2, _ := m.InstanceID()
78 if id1 == "" || id1 != id2 {
79 t.Fatal("instance-id niet vast")
80 }
81 _ = m.Revoke()
82 if _, ok := m.Check(key2); ok {
83 t.Fatal("ingetrokken key werkt")
84 }
85}
86
87func TestCleanLogical(t *testing.T) {
88 good := []string{"state/bluegit.db", "state/secret.key", "state/ssh/host_ed25519", "data/repos/tim/a.git/HEAD", "data/releases/tim/a/v1/x.tgz"}
89 bad := []string{"", "/etc/passwd", "state/../x", "state/storage_path", "state/backup.json", "state/instance_id", "data/work/1/x", "data/releases/.incoming/x", "data/repos", "state/ssh", "x/y", "data/repos/../../etc", "state//secret.key", "data\\repos\\x"}
90 for _, p := range good {
91 if _, ok := CleanLogical(p); !ok {
92 t.Errorf("geweigerd: %s", p)
93 }
94 }
95 for _, p := range bad {
96 if _, ok := CleanLogical(p); ok {
97 t.Errorf("toegestaan: %s", p)
98 }
99 }
100}
101
102func write(t *testing.T, p, s string) {
103 t.Helper()
104 if err := os.MkdirAll(filepath.Dir(p), 0o755); err != nil {
105 t.Fatal(err)
106 }
107 if err := os.WriteFile(p, []byte(s), 0o644); err != nil {
108 t.Fatal(err)
109 }
110}
111
112func fakeTree(t *testing.T) Tree {
113 st, data := t.TempDir(), t.TempDir()
114 write(t, filepath.Join(st, "bluegit.db"), "live-db")
115 write(t, filepath.Join(st, "secret.key"), "k")
116 write(t, filepath.Join(st, "storage_path"), data)
117 write(t, filepath.Join(st, "backup.json"), "{}")
118 write(t, filepath.Join(st, "ssh", "host_ed25519"), "hk")
119 write(t, filepath.Join(data, "repos", "tim", "a.git", "HEAD"), "ref: refs/heads/master")
120 write(t, filepath.Join(data, "repos", "tim", "a.git", "index.lock"), "x")
121 write(t, filepath.Join(data, "releases", ".incoming", "x"), "x")
122 write(t, filepath.Join(data, "releases", "tim", "a", "v1", "a.bin"), "bin")
123 write(t, filepath.Join(data, "work", "1", "f"), "x")
124 _ = os.Symlink("/etc/passwd", filepath.Join(data, "repos", "tim", "evil"))
125 return Tree{StateDir: st, DataDir: data, Snapshot: func(dst string) error {
126 return os.WriteFile(dst, []byte("snapshot-db"), 0o600)
127 }}
128}
129
130func TestManifestAndResolve(t *testing.T) {
131 tr := fakeTree(t)
132 m, err := tr.Build("inst")
133 if err != nil {
134 t.Fatal(err)
135 }
136 var paths []string
137 for _, e := range m.Files {
138 paths = append(paths, e.Path)
139 }
140 got := strings.Join(paths, ",")
141 want := "data/releases/tim/a/v1/a.bin,data/repos/tim/a.git/HEAD,state/bluegit.db,state/secret.key,state/ssh/host_ed25519"
142 if got != want {
143 t.Fatalf("manifest\n got %s\nwant %s", got, want)
144 }
145 if m.Files[2].SHA256 == "" {
146 t.Fatal("database zonder hash")
147 }
148 p, err := tr.Resolve(DBPath)
149 if err != nil {
150 t.Fatal(err)
151 }
152 if b, _ := os.ReadFile(p); string(b) != "snapshot-db" {
153 t.Fatalf("database komt niet uit de kopie: %s", b)
154 }
155 for _, bad := range []string{"state/storage_path", "data/repos/tim/evil", "data/repos/../../etc/passwd"} {
156 if _, err := tr.Resolve(bad); err == nil {
157 t.Errorf("resolve %s toegestaan", bad)
158 }
159 }
160}
161
162type tf struct {
163 name, body string
164 typ byte
165}
166
167func tgz(t *testing.T, files []tf) []byte {
168 var buf bytes.Buffer
169 gz := gzip.NewWriter(&buf)
170 tw := tar.NewWriter(gz)
171 for _, f := range files {
172 typ := f.typ
173 if typ == 0 {
174 typ = tar.TypeReg
175 }
176 h := &tar.Header{Name: f.name, Mode: 0o644, Size: int64(len(f.body)), Typeflag: typ, ModTime: time.Unix(1_700_000_000, 0)}
177 if typ == tar.TypeSymlink {
178 h.Size, h.Linkname = 0, "/etc/passwd"
179 }
180 if err := tw.WriteHeader(h); err != nil {
181 t.Fatal(err)
182 }
183 if typ == tar.TypeReg {
184 _, _ = tw.Write([]byte(f.body))
185 }
186 }
187 tw.Close()
188 gz.Close()
189 return buf.Bytes()
190}
191
192func TestStageAndApply(t *testing.T) {
193 tr := fakeTree(t)
194 archive := tgz(t, []tf{
195 {name: "state/bluegit.db", body: "old-db"},
196 {name: "state/secret.key", body: "old-key"},
197 {name: "data/repos/tim/b.git/HEAD", body: "ref: refs/heads/main"},
198 })
199 n, err := tr.Stage(bytes.NewReader(archive))
200 if err != nil || n != 3 {
201 t.Fatal(n, err)
202 }
203 if b, _ := os.ReadFile(filepath.Join(tr.StateDir, "bluegit.db")); string(b) != "live-db" {
204 t.Fatal("stage raakte de live database")
205 }
206 if !HasPending(tr.StateDir) {
207 t.Fatal("geen READY")
208 }
209 ok, err := ApplyPending(tr.StateDir)
210 if err != nil || !ok {
211 t.Fatal(ok, err)
212 }
213 check := func(p, want string) {
214 t.Helper()
215 b, err := os.ReadFile(p)
216 if want == "" {
217 if err == nil {
218 t.Errorf("%s bestaat nog", p)
219 }
220 return
221 }
222 if string(b) != want {
223 t.Errorf("%s = %q, wil %q", p, b, want)
224 }
225 }
226 check(filepath.Join(tr.StateDir, "bluegit.db"), "old-db")
227 check(filepath.Join(tr.StateDir, "secret.key"), "old-key")
228 check(filepath.Join(tr.StateDir, "ssh", "host_ed25519"), "")
229 check(filepath.Join(tr.StateDir, "backup.json"), "{}")
230 check(filepath.Join(tr.StateDir, "storage_path"), tr.DataDir)
231 check(filepath.Join(tr.DataDir, "repos", "tim", "b.git", "HEAD"), "ref: refs/heads/main")
232 check(filepath.Join(tr.DataDir, "repos", "tim", "a.git", "HEAD"), "")
233 check(filepath.Join(tr.DataDir, "releases", "tim", "a", "v1", "a.bin"), "")
234 check(filepath.Join(tr.DataDir, "work", "1", "f"), "x")
235 if HasPending(tr.StateDir) {
236 t.Fatal("READY blijft staan")
237 }
238 if ok, _ := ApplyPending(tr.StateDir); ok {
239 t.Fatal("tweede keer toegepast")
240 }
241}
242
243func TestStageRejects(t *testing.T) {
244 cases := map[string][]tf{
245 "traversal": {{name: "state/bluegit.db", body: "x"}, {name: "state/secret.key", body: "k"}, {name: "data/repos/../../../etc/x", body: "x"}},
246 "symlink": {{name: "state/bluegit.db", body: "x"}, {name: "state/secret.key", body: "k"}, {name: "data/repos/a/l", typ: tar.TypeSymlink}},
247 "onbekend": {{name: "state/bluegit.db", body: "x"}, {name: "state/secret.key", body: "k"}, {name: "state/storage_path", body: "/"}},
248 "zonder-db": {{name: "state/secret.key", body: "k"}},
249 "zonder-key": {{name: "state/bluegit.db", body: "x"}},
250 }
251 for name, files := range cases {
252 tr := fakeTree(t)
253 if _, err := tr.Stage(bytes.NewReader(tgz(t, files))); err == nil {
254 t.Errorf("%s: geaccepteerd", name)
255 }
256 if HasPending(tr.StateDir) {
257 t.Errorf("%s: READY na fout", name)
258 }
259 if _, err := os.Stat(filepath.Join(tr.StateDir, ".restore")); err == nil {
260 t.Errorf("%s: staging blijft staan", name)
261 }
262 }
263 if _, err := fakeTree(t).Stage(strings.NewReader("geen gzip")); err == nil {
264 t.Error("geen gzip geaccepteerd")
265 }
266}
internal/backup/client.go added +177 −0
@@ -0,0 +1,177 @@
1 package backup
2
3 import (
4 "bytes"
5 "context"
6 "encoding/json"
7 "fmt"
8 "io"
9 "net/http"
10 "sync"
11 "time"
12 )
13
14 // Archive is één archief zoals de backup server het meldt.
15 type Archive struct {
16 Name string `json:"name"`
17 CreatedAt time.Time `json:"created_at"`
18 Size int64 `json:"size"`
19 }
20
21 // RemoteStatus is wat de backup server over zichzelf zegt.
22 type RemoteStatus struct {
23 Version string `json:"version"`
24 LastSync time.Time `json:"last_sync"`
25 SyncError string `json:"sync_error,omitempty"`
26 Rollback struct {
27 State string `json:"state"`
28 Archive string `json:"archive,omitempty"`
29 Error string `json:"error,omitempty"`
30 At time.Time `json:"at,omitempty"`
31 } `json:"rollback"`
32 Interval string `json:"archive_interval"`
33 RetentionDays int `json:"retention_days"`
34 }
35
36 // Client praat ondertekend met de gekoppelde backup server.
37 type Client struct {
38 Manager *Manager
39 HTTP *http.Client
40 Now func() time.Time
41 }
42
43 func (c *Client) do(ctx context.Context, method, p string, in, out any) error {
44 conn, err := c.Manager.Load()
45 if err != nil {
46 return err
47 }
48 if !conn.Connected() {
49 return fmt.Errorf("geen backup server gekoppeld")
50 }
51 inst, err := c.Manager.InstanceID()
52 if err != nil {
53 return err
54 }
55 var body []byte
56 if in != nil {
57 if body, err = json.Marshal(in); err != nil {
58 return err
59 }
60 }
61 req, err := http.NewRequestWithContext(ctx, method, conn.ServerURL+p, bytes.NewReader(body))
62 if err != nil {
63 return err
64 }
65 if in != nil {
66 req.Header.Set("Content-Type", "application/json")
67 }
68 now := time.Now
69 if c.Now != nil {
70 now = c.Now
71 }
72 Sign(req, conn.SignSecret, inst, body, now())
73 hc := c.HTTP
74 if hc == nil {
75 hc = &http.Client{Timeout: 15 * time.Second}
76 }
77 resp, err := hc.Do(req)
78 if err != nil {
79 return err
80 }
81 defer resp.Body.Close()
82 raw, _ := io.ReadAll(io.LimitReader(resp.Body, 4<<20))
83 if resp.StatusCode >= 300 {
84 var e struct {
85 Error string `json:"error"`
86 }
87 _ = json.Unmarshal(raw, &e)
88 if e.Error == "" {
89 e.Error = resp.Status
90 }
91 return fmt.Errorf("backup server: %s", e.Error)
92 }
93 if out != nil {
94 return json.Unmarshal(raw, out)
95 }
96 return nil
97 }
98
99 // Archives vraagt de lijst met archieven op, nieuwste eerst.
100 func (c *Client) Archives(ctx context.Context) ([]Archive, error) {
101 var out struct {
102 Archives []Archive `json:"archives"`
103 }
104 err := c.do(ctx, http.MethodGet, "/api/v1/archives", nil, &out)
105 return out.Archives, err
106 }
107
108 // Status vraagt de toestand van de backup server op.
109 func (c *Client) Status(ctx context.Context) (RemoteStatus, error) {
110 var out RemoteStatus
111 err := c.do(ctx, http.MethodGet, "/api/v1/status", nil, &out)
112 return out, err
113 }
114
115 // Rollback vraagt de backup server om archive terug te zetten. De server
116 // antwoordt meteen; het terugsturen naar BlueGit gebeurt daarna.
117 func (c *Client) Rollback(ctx context.Context, archive string) error {
118 return c.do(ctx, http.MethodPost, "/api/v1/rollback", map[string]string{"archive": archive}, nil)
119 }
120
121 // Notify meldt dat er iets veranderd is.
122 func (c *Client) Notify(ctx context.Context) error {
123 return c.do(ctx, http.MethodPost, "/api/v1/notify", map[string]any{"at": time.Now().UTC()}, nil)
124 }
125
126 // Notifier bundelt wijzigingen: hoogstens één melding per Delay, en bij een
127 // mislukking een paar nieuwe pogingen. De backup server haalt daarnaast
128 // periodiek alles op, dus een gemiste melding kost alleen vertraging.
129 type Notifier struct {
130 Client *Client
131 Delay time.Duration
132 once sync.Once
133 kick chan struct{}
134 }
135
136 // Changed zegt dat er iets veranderd is. Blokkeert nooit.
137 func (n *Notifier) Changed() {
138 if n == nil {
139 return
140 }
141 n.once.Do(func() {
142 n.kick = make(chan struct{}, 1)
143 go n.loop()
144 })
145 select {
146 case n.kick <- struct{}{}:
147 default:
148 }
149 }
150
151 func (n *Notifier) loop() {
152 delay := n.Delay
153 if delay <= 0 {
154 delay = 2 * time.Second
155 }
156 for range n.kick {
157 time.Sleep(delay)
158 // Wat in de tussentijd binnenkwam, zit in deze melding.
159 select {
160 case <-n.kick:
161 default:
162 }
163 conn, err := n.Client.Manager.Load()
164 if err != nil || !conn.Connected() {
165 continue
166 }
167 for try := 0; try < 4; try++ {
168 ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
169 err := n.Client.Notify(ctx)
170 cancel()
171 if err == nil {
172 break
173 }
174 time.Sleep(time.Duration(1<<try) * 2 * time.Second)
175 }
176 }
177 }
@@ -0,0 +1,177 @@
1package backup
2
3import (
4 "bytes"
5 "context"
6 "encoding/json"
7 "fmt"
8 "io"
9 "net/http"
10 "sync"
11 "time"
12)
13
14// Archive is één archief zoals de backup server het meldt.
15type Archive struct {
16 Name string `json:"name"`
17 CreatedAt time.Time `json:"created_at"`
18 Size int64 `json:"size"`
19}
20
21// RemoteStatus is wat de backup server over zichzelf zegt.
22type RemoteStatus struct {
23 Version string `json:"version"`
24 LastSync time.Time `json:"last_sync"`
25 SyncError string `json:"sync_error,omitempty"`
26 Rollback struct {
27 State string `json:"state"`
28 Archive string `json:"archive,omitempty"`
29 Error string `json:"error,omitempty"`
30 At time.Time `json:"at,omitempty"`
31 } `json:"rollback"`
32 Interval string `json:"archive_interval"`
33 RetentionDays int `json:"retention_days"`
34}
35
36// Client praat ondertekend met de gekoppelde backup server.
37type Client struct {
38 Manager *Manager
39 HTTP *http.Client
40 Now func() time.Time
41}
42
43func (c *Client) do(ctx context.Context, method, p string, in, out any) error {
44 conn, err := c.Manager.Load()
45 if err != nil {
46 return err
47 }
48 if !conn.Connected() {
49 return fmt.Errorf("geen backup server gekoppeld")
50 }
51 inst, err := c.Manager.InstanceID()
52 if err != nil {
53 return err
54 }
55 var body []byte
56 if in != nil {
57 if body, err = json.Marshal(in); err != nil {
58 return err
59 }
60 }
61 req, err := http.NewRequestWithContext(ctx, method, conn.ServerURL+p, bytes.NewReader(body))
62 if err != nil {
63 return err
64 }
65 if in != nil {
66 req.Header.Set("Content-Type", "application/json")
67 }
68 now := time.Now
69 if c.Now != nil {
70 now = c.Now
71 }
72 Sign(req, conn.SignSecret, inst, body, now())
73 hc := c.HTTP
74 if hc == nil {
75 hc = &http.Client{Timeout: 15 * time.Second}
76 }
77 resp, err := hc.Do(req)
78 if err != nil {
79 return err
80 }
81 defer resp.Body.Close()
82 raw, _ := io.ReadAll(io.LimitReader(resp.Body, 4<<20))
83 if resp.StatusCode >= 300 {
84 var e struct {
85 Error string `json:"error"`
86 }
87 _ = json.Unmarshal(raw, &e)
88 if e.Error == "" {
89 e.Error = resp.Status
90 }
91 return fmt.Errorf("backup server: %s", e.Error)
92 }
93 if out != nil {
94 return json.Unmarshal(raw, out)
95 }
96 return nil
97}
98
99// Archives vraagt de lijst met archieven op, nieuwste eerst.
100func (c *Client) Archives(ctx context.Context) ([]Archive, error) {
101 var out struct {
102 Archives []Archive `json:"archives"`
103 }
104 err := c.do(ctx, http.MethodGet, "/api/v1/archives", nil, &out)
105 return out.Archives, err
106}
107
108// Status vraagt de toestand van de backup server op.
109func (c *Client) Status(ctx context.Context) (RemoteStatus, error) {
110 var out RemoteStatus
111 err := c.do(ctx, http.MethodGet, "/api/v1/status", nil, &out)
112 return out, err
113}
114
115// Rollback vraagt de backup server om archive terug te zetten. De server
116// antwoordt meteen; het terugsturen naar BlueGit gebeurt daarna.
117func (c *Client) Rollback(ctx context.Context, archive string) error {
118 return c.do(ctx, http.MethodPost, "/api/v1/rollback", map[string]string{"archive": archive}, nil)
119}
120
121// Notify meldt dat er iets veranderd is.
122func (c *Client) Notify(ctx context.Context) error {
123 return c.do(ctx, http.MethodPost, "/api/v1/notify", map[string]any{"at": time.Now().UTC()}, nil)
124}
125
126// Notifier bundelt wijzigingen: hoogstens één melding per Delay, en bij een
127// mislukking een paar nieuwe pogingen. De backup server haalt daarnaast
128// periodiek alles op, dus een gemiste melding kost alleen vertraging.
129type Notifier struct {
130 Client *Client
131 Delay time.Duration
132 once sync.Once
133 kick chan struct{}
134}
135
136// Changed zegt dat er iets veranderd is. Blokkeert nooit.
137func (n *Notifier) Changed() {
138 if n == nil {
139 return
140 }
141 n.once.Do(func() {
142 n.kick = make(chan struct{}, 1)
143 go n.loop()
144 })
145 select {
146 case n.kick <- struct{}{}:
147 default:
148 }
149}
150
151func (n *Notifier) loop() {
152 delay := n.Delay
153 if delay <= 0 {
154 delay = 2 * time.Second
155 }
156 for range n.kick {
157 time.Sleep(delay)
158 // Wat in de tussentijd binnenkwam, zit in deze melding.
159 select {
160 case <-n.kick:
161 default:
162 }
163 conn, err := n.Client.Manager.Load()
164 if err != nil || !conn.Connected() {
165 continue
166 }
167 for try := 0; try < 4; try++ {
168 ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
169 err := n.Client.Notify(ctx)
170 cancel()
171 if err == nil {
172 break
173 }
174 time.Sleep(time.Duration(1<<try) * 2 * time.Second)
175 }
176 }
177}
internal/backup/conn.go added +202 −0
@@ -0,0 +1,202 @@
1 // Package backup is de BlueGit-kant van bluegit-backup: de Backupserver-Key,
2 // de koppeling met één backup server, het manifest van alle gegevens, het
3 // ondertekenen van verzoeken en het terugzetten van een backup bij de start.
4 //
5 // De koppeling staat in <state>/backup.json en het instance-id in
6 // <state>/instance_id. Die twee bestanden horen bij deze installatie en gaan
7 // niet mee in een backup, zodat een rollback de koppeling niet terugdraait.
8 package backup
9
10 import (
11 "crypto/rand"
12 "crypto/sha256"
13 "crypto/subtle"
14 "encoding/hex"
15 "encoding/json"
16 "errors"
17 "os"
18 "path/filepath"
19 "strings"
20 "sync"
21 "time"
22 )
23
24 // KeyPrefix staat voor elke Backupserver-Key.
25 const KeyPrefix = "bgbk_"
26
27 const (
28 connFile = "backup.json"
29 instanceFile = "instance_id"
30 )
31
32 // Conn is de opgeslagen koppeling. De key zelf wordt nooit bewaard.
33 type Conn struct {
34 KeyHash string `json:"key_hash"`
35 SignSecret string `json:"sign_secret"`
36 KeyHint string `json:"key_hint"`
37 CreatedAt time.Time `json:"created_at"`
38 CreatedBy string `json:"created_by"`
39 ServerURL string `json:"server_url,omitempty"`
40 ServerID string `json:"server_id,omitempty"`
41 ConnectedAt time.Time `json:"connected_at,omitempty"`
42 LastSeen time.Time `json:"last_seen,omitempty"`
43 }
44
45 // HasKey zegt of er een key is uitgegeven.
46 func (c Conn) HasKey() bool { return c.KeyHash != "" }
47
48 // Connected zegt of een backup server zich met de key heeft gemeld.
49 func (c Conn) Connected() bool { return c.HasKey() && c.ServerURL != "" }
50
51 // Manager bewaart de koppeling in de state-map.
52 type Manager struct {
53 Dir string
54 mu sync.Mutex
55 }
56
57 // HashKey is de opgeslagen vorm van de key.
58 func HashKey(key string) string {
59 s := sha256.Sum256([]byte(key))
60 return hex.EncodeToString(s[:])
61 }
62
63 // SigningSecret leidt het HMAC-geheim af uit de key. De backup server doet
64 // precies hetzelfde, zodat beide kanten verzoeken kunnen ondertekenen.
65 func SigningSecret(key string) string {
66 s := sha256.Sum256([]byte("bluegit-backup-sign:" + key))
67 return hex.EncodeToString(s[:])
68 }
69
70 // Load leest de koppeling. Geen bestand is een lege koppeling.
71 func (m *Manager) Load() (Conn, error) {
72 m.mu.Lock()
73 defer m.mu.Unlock()
74 return m.load()
75 }
76
77 func (m *Manager) load() (Conn, error) {
78 var c Conn
79 b, err := os.ReadFile(filepath.Join(m.Dir, connFile))
80 if errors.Is(err, os.ErrNotExist) {
81 return c, nil
82 }
83 if err != nil {
84 return c, err
85 }
86 err = json.Unmarshal(b, &c)
87 return c, err
88 }
89
90 func (m *Manager) save(c Conn) error {
91 if m.Dir == "" {
92 return errors.New("geen state-map")
93 }
94 b, err := json.MarshalIndent(c, "", " ")
95 if err != nil {
96 return err
97 }
98 tmp := filepath.Join(m.Dir, connFile+".tmp")
99 if err := os.WriteFile(tmp, b, 0o600); err != nil {
100 return err
101 }
102 return os.Rename(tmp, filepath.Join(m.Dir, connFile))
103 }
104
105 // NewKey maakt een nieuwe key en vervangt de oude. Een gekoppelde backup
106 // server verliest daarmee zijn toegang tot hij de nieuwe key krijgt.
107 func (m *Manager) NewKey(by string) (string, Conn, error) {
108 raw := make([]byte, 32)
109 if _, err := rand.Read(raw); err != nil {
110 return "", Conn{}, err
111 }
112 key := KeyPrefix + hex.EncodeToString(raw)
113 c := Conn{
114 KeyHash: HashKey(key), SignSecret: SigningSecret(key),
115 KeyHint: key[:len(KeyPrefix)+6], CreatedAt: time.Now().UTC(), CreatedBy: by,
116 }
117 m.mu.Lock()
118 defer m.mu.Unlock()
119 if err := m.save(c); err != nil {
120 return "", Conn{}, err
121 }
122 return key, c, nil
123 }
124
125 // Revoke trekt de key in en vergeet de backup server.
126 func (m *Manager) Revoke() error {
127 m.mu.Lock()
128 defer m.mu.Unlock()
129 err := os.Remove(filepath.Join(m.Dir, connFile))
130 if errors.Is(err, os.ErrNotExist) {
131 return nil
132 }
133 return err
134 }
135
136 // Check zegt of key de uitgegeven key is.
137 func (m *Manager) Check(key string) (Conn, bool) {
138 key = strings.TrimSpace(key)
139 if !strings.HasPrefix(key, KeyPrefix) {
140 return Conn{}, false
141 }
142 c, err := m.Load()
143 if err != nil || !c.HasKey() {
144 return Conn{}, false
145 }
146 if subtle.ConstantTimeCompare([]byte(HashKey(key)), []byte(c.KeyHash)) != 1 {
147 return Conn{}, false
148 }
149 return c, true
150 }
151
152 // Connect legt het adres van de backup server vast.
153 func (m *Manager) Connect(serverURL, serverID string) (Conn, error) {
154 m.mu.Lock()
155 defer m.mu.Unlock()
156 c, err := m.load()
157 if err != nil {
158 return c, err
159 }
160 if !c.HasKey() {
161 return c, errors.New("geen key")
162 }
163 c.ServerURL = strings.TrimRight(strings.TrimSpace(serverURL), "/")
164 c.ServerID = serverID
165 c.ConnectedAt = time.Now().UTC()
166 c.LastSeen = c.ConnectedAt
167 return c, m.save(c)
168 }
169
170 // Seen werkt LastSeen bij, hoogstens één keer per minuut naar schijf.
171 func (m *Manager) Seen() {
172 m.mu.Lock()
173 defer m.mu.Unlock()
174 c, err := m.load()
175 if err != nil || !c.HasKey() || time.Since(c.LastSeen) < time.Minute {
176 return
177 }
178 c.LastSeen = time.Now().UTC()
179 _ = m.save(c)
180 }
181
182 // InstanceID is het vaste id van deze installatie. Het wordt één keer
183 // gemaakt en gaat niet mee in een backup.
184 func (m *Manager) InstanceID() (string, error) {
185 m.mu.Lock()
186 defer m.mu.Unlock()
187 p := filepath.Join(m.Dir, instanceFile)
188 if b, err := os.ReadFile(p); err == nil {
189 if id := strings.TrimSpace(string(b)); id != "" {
190 return id, nil
191 }
192 }
193 raw := make([]byte, 16)
194 if _, err := rand.Read(raw); err != nil {
195 return "", err
196 }
197 id := hex.EncodeToString(raw)
198 if err := os.MkdirAll(m.Dir, 0o750); err != nil {
199 return "", err
200 }
201 return id, os.WriteFile(p, []byte(id+"\n"), 0o600)
202 }
@@ -0,0 +1,202 @@
1// Package backup is de BlueGit-kant van bluegit-backup: de Backupserver-Key,
2// de koppeling met één backup server, het manifest van alle gegevens, het
3// ondertekenen van verzoeken en het terugzetten van een backup bij de start.
4//
5// De koppeling staat in <state>/backup.json en het instance-id in
6// <state>/instance_id. Die twee bestanden horen bij deze installatie en gaan
7// niet mee in een backup, zodat een rollback de koppeling niet terugdraait.
8package backup
9
10import (
11 "crypto/rand"
12 "crypto/sha256"
13 "crypto/subtle"
14 "encoding/hex"
15 "encoding/json"
16 "errors"
17 "os"
18 "path/filepath"
19 "strings"
20 "sync"
21 "time"
22)
23
24// KeyPrefix staat voor elke Backupserver-Key.
25const KeyPrefix = "bgbk_"
26
27const (
28 connFile = "backup.json"
29 instanceFile = "instance_id"
30)
31
32// Conn is de opgeslagen koppeling. De key zelf wordt nooit bewaard.
33type Conn struct {
34 KeyHash string `json:"key_hash"`
35 SignSecret string `json:"sign_secret"`
36 KeyHint string `json:"key_hint"`
37 CreatedAt time.Time `json:"created_at"`
38 CreatedBy string `json:"created_by"`
39 ServerURL string `json:"server_url,omitempty"`
40 ServerID string `json:"server_id,omitempty"`
41 ConnectedAt time.Time `json:"connected_at,omitempty"`
42 LastSeen time.Time `json:"last_seen,omitempty"`
43}
44
45// HasKey zegt of er een key is uitgegeven.
46func (c Conn) HasKey() bool { return c.KeyHash != "" }
47
48// Connected zegt of een backup server zich met de key heeft gemeld.
49func (c Conn) Connected() bool { return c.HasKey() && c.ServerURL != "" }
50
51// Manager bewaart de koppeling in de state-map.
52type Manager struct {
53 Dir string
54 mu sync.Mutex
55}
56
57// HashKey is de opgeslagen vorm van de key.
58func HashKey(key string) string {
59 s := sha256.Sum256([]byte(key))
60 return hex.EncodeToString(s[:])
61}
62
63// SigningSecret leidt het HMAC-geheim af uit de key. De backup server doet
64// precies hetzelfde, zodat beide kanten verzoeken kunnen ondertekenen.
65func SigningSecret(key string) string {
66 s := sha256.Sum256([]byte("bluegit-backup-sign:" + key))
67 return hex.EncodeToString(s[:])
68}
69
70// Load leest de koppeling. Geen bestand is een lege koppeling.
71func (m *Manager) Load() (Conn, error) {
72 m.mu.Lock()
73 defer m.mu.Unlock()
74 return m.load()
75}
76
77func (m *Manager) load() (Conn, error) {
78 var c Conn
79 b, err := os.ReadFile(filepath.Join(m.Dir, connFile))
80 if errors.Is(err, os.ErrNotExist) {
81 return c, nil
82 }
83 if err != nil {
84 return c, err
85 }
86 err = json.Unmarshal(b, &c)
87 return c, err
88}
89
90func (m *Manager) save(c Conn) error {
91 if m.Dir == "" {
92 return errors.New("geen state-map")
93 }
94 b, err := json.MarshalIndent(c, "", " ")
95 if err != nil {
96 return err
97 }
98 tmp := filepath.Join(m.Dir, connFile+".tmp")
99 if err := os.WriteFile(tmp, b, 0o600); err != nil {
100 return err
101 }
102 return os.Rename(tmp, filepath.Join(m.Dir, connFile))
103}
104
105// NewKey maakt een nieuwe key en vervangt de oude. Een gekoppelde backup
106// server verliest daarmee zijn toegang tot hij de nieuwe key krijgt.
107func (m *Manager) NewKey(by string) (string, Conn, error) {
108 raw := make([]byte, 32)
109 if _, err := rand.Read(raw); err != nil {
110 return "", Conn{}, err
111 }
112 key := KeyPrefix + hex.EncodeToString(raw)
113 c := Conn{
114 KeyHash: HashKey(key), SignSecret: SigningSecret(key),
115 KeyHint: key[:len(KeyPrefix)+6], CreatedAt: time.Now().UTC(), CreatedBy: by,
116 }
117 m.mu.Lock()
118 defer m.mu.Unlock()
119 if err := m.save(c); err != nil {
120 return "", Conn{}, err
121 }
122 return key, c, nil
123}
124
125// Revoke trekt de key in en vergeet de backup server.
126func (m *Manager) Revoke() error {
127 m.mu.Lock()
128 defer m.mu.Unlock()
129 err := os.Remove(filepath.Join(m.Dir, connFile))
130 if errors.Is(err, os.ErrNotExist) {
131 return nil
132 }
133 return err
134}
135
136// Check zegt of key de uitgegeven key is.
137func (m *Manager) Check(key string) (Conn, bool) {
138 key = strings.TrimSpace(key)
139 if !strings.HasPrefix(key, KeyPrefix) {
140 return Conn{}, false
141 }
142 c, err := m.Load()
143 if err != nil || !c.HasKey() {
144 return Conn{}, false
145 }
146 if subtle.ConstantTimeCompare([]byte(HashKey(key)), []byte(c.KeyHash)) != 1 {
147 return Conn{}, false
148 }
149 return c, true
150}
151
152// Connect legt het adres van de backup server vast.
153func (m *Manager) Connect(serverURL, serverID string) (Conn, error) {
154 m.mu.Lock()
155 defer m.mu.Unlock()
156 c, err := m.load()
157 if err != nil {
158 return c, err
159 }
160 if !c.HasKey() {
161 return c, errors.New("geen key")
162 }
163 c.ServerURL = strings.TrimRight(strings.TrimSpace(serverURL), "/")
164 c.ServerID = serverID
165 c.ConnectedAt = time.Now().UTC()
166 c.LastSeen = c.ConnectedAt
167 return c, m.save(c)
168}
169
170// Seen werkt LastSeen bij, hoogstens één keer per minuut naar schijf.
171func (m *Manager) Seen() {
172 m.mu.Lock()
173 defer m.mu.Unlock()
174 c, err := m.load()
175 if err != nil || !c.HasKey() || time.Since(c.LastSeen) < time.Minute {
176 return
177 }
178 c.LastSeen = time.Now().UTC()
179 _ = m.save(c)
180}
181
182// InstanceID is het vaste id van deze installatie. Het wordt één keer
183// gemaakt en gaat niet mee in een backup.
184func (m *Manager) InstanceID() (string, error) {
185 m.mu.Lock()
186 defer m.mu.Unlock()
187 p := filepath.Join(m.Dir, instanceFile)
188 if b, err := os.ReadFile(p); err == nil {
189 if id := strings.TrimSpace(string(b)); id != "" {
190 return id, nil
191 }
192 }
193 raw := make([]byte, 16)
194 if _, err := rand.Read(raw); err != nil {
195 return "", err
196 }
197 id := hex.EncodeToString(raw)
198 if err := os.MkdirAll(m.Dir, 0o750); err != nil {
199 return "", err
200 }
201 return id, os.WriteFile(p, []byte(id+"\n"), 0o600)
202}
internal/backup/sign.go added +59 −0
@@ -0,0 +1,59 @@
1 package backup
2
3 import (
4 "crypto/hmac"
5 "crypto/sha256"
6 "encoding/hex"
7 "errors"
8 "net/http"
9 "strconv"
10 "strings"
11 "time"
12 )
13
14 // Koppen van een ondertekend verzoek tussen BlueGit en de backup server.
15 const (
16 HeaderInstance = "X-BlueGit-Instance"
17 HeaderTimestamp = "X-BlueGit-Timestamp"
18 HeaderSignature = "X-BlueGit-Signature"
19 )
20
21 // MaxSkew is hoe ver de klokken uit elkaar mogen lopen.
22 const MaxSkew = 5 * time.Minute
23
24 // Signature is hex(HMAC-SHA256(secret, METHOD \n PATH \n TS \n sha256hex(body))).
25 func Signature(secret, method, path, ts string, body []byte) string {
26 sum := sha256.Sum256(body)
27 mac := hmac.New(sha256.New, []byte(secret))
28 mac.Write([]byte(strings.ToUpper(method) + "\n" + path + "\n" + ts + "\n" + hex.EncodeToString(sum[:])))
29 return hex.EncodeToString(mac.Sum(nil))
30 }
31
32 // Sign zet de koppen op een uitgaand verzoek. body is wat er verstuurd wordt.
33 func Sign(req *http.Request, secret, instance string, body []byte, now time.Time) {
34 ts := strconv.FormatInt(now.Unix(), 10)
35 req.Header.Set(HeaderInstance, instance)
36 req.Header.Set(HeaderTimestamp, ts)
37 req.Header.Set(HeaderSignature, Signature(secret, req.Method, req.URL.Path, ts, body))
38 }
39
40 // Verify controleert een binnenkomend ondertekend verzoek.
41 func Verify(r *http.Request, secret string, body []byte, now time.Time) error {
42 ts := r.Header.Get(HeaderTimestamp)
43 n, err := strconv.ParseInt(ts, 10, 64)
44 if err != nil {
45 return errors.New("timestamp ontbreekt")
46 }
47 d := now.Sub(time.Unix(n, 0))
48 if d < 0 {
49 d = -d
50 }
51 if d > MaxSkew {
52 return errors.New("timestamp te oud of in de toekomst")
53 }
54 want := Signature(secret, r.Method, r.URL.Path, ts, body)
55 if !hmac.Equal([]byte(want), []byte(r.Header.Get(HeaderSignature))) {
56 return errors.New("handtekening klopt niet")
57 }
58 return nil
59 }
@@ -0,0 +1,59 @@
1package backup
2
3import (
4 "crypto/hmac"
5 "crypto/sha256"
6 "encoding/hex"
7 "errors"
8 "net/http"
9 "strconv"
10 "strings"
11 "time"
12)
13
14// Koppen van een ondertekend verzoek tussen BlueGit en de backup server.
15const (
16 HeaderInstance = "X-BlueGit-Instance"
17 HeaderTimestamp = "X-BlueGit-Timestamp"
18 HeaderSignature = "X-BlueGit-Signature"
19)
20
21// MaxSkew is hoe ver de klokken uit elkaar mogen lopen.
22const MaxSkew = 5 * time.Minute
23
24// Signature is hex(HMAC-SHA256(secret, METHOD \n PATH \n TS \n sha256hex(body))).
25func Signature(secret, method, path, ts string, body []byte) string {
26 sum := sha256.Sum256(body)
27 mac := hmac.New(sha256.New, []byte(secret))
28 mac.Write([]byte(strings.ToUpper(method) + "\n" + path + "\n" + ts + "\n" + hex.EncodeToString(sum[:])))
29 return hex.EncodeToString(mac.Sum(nil))
30}
31
32// Sign zet de koppen op een uitgaand verzoek. body is wat er verstuurd wordt.
33func Sign(req *http.Request, secret, instance string, body []byte, now time.Time) {
34 ts := strconv.FormatInt(now.Unix(), 10)
35 req.Header.Set(HeaderInstance, instance)
36 req.Header.Set(HeaderTimestamp, ts)
37 req.Header.Set(HeaderSignature, Signature(secret, req.Method, req.URL.Path, ts, body))
38}
39
40// Verify controleert een binnenkomend ondertekend verzoek.
41func Verify(r *http.Request, secret string, body []byte, now time.Time) error {
42 ts := r.Header.Get(HeaderTimestamp)
43 n, err := strconv.ParseInt(ts, 10, 64)
44 if err != nil {
45 return errors.New("timestamp ontbreekt")
46 }
47 d := now.Sub(time.Unix(n, 0))
48 if d < 0 {
49 d = -d
50 }
51 if d > MaxSkew {
52 return errors.New("timestamp te oud of in de toekomst")
53 }
54 want := Signature(secret, r.Method, r.URL.Path, ts, body)
55 if !hmac.Equal([]byte(want), []byte(r.Header.Get(HeaderSignature))) {
56 return errors.New("handtekening klopt niet")
57 }
58 return nil
59}
internal/backup/tree.go added +402 −0
@@ -0,0 +1,402 @@
1 package backup
2
3 import (
4 "archive/tar"
5 "compress/gzip"
6 "crypto/sha256"
7 "encoding/hex"
8 "encoding/json"
9 "errors"
10 "fmt"
11 "io"
12 "io/fs"
13 "os"
14 "path"
15 "path/filepath"
16 "sort"
17 "strings"
18 "time"
19 )
20
21 // Wat er in een backup zit. Logische paden beginnen met state/ of data/.
22 //
23 // state/bluegit.db consistente kopie (VACUUM INTO), niet het live bestand
24 // state/secret.key nodig om de geheimen in de database te lezen
25 // state/ssh/… SSH-hostkey
26 // state/logos/… project- en groepslogo's
27 // state/avatars/… geüploade avatars
28 // data/repos/… bare repositories
29 // data/releases/… gepubliceerde release-assets (zonder .incoming)
30 // data/artifacts/… CI-artifacts
31 //
32 // Niet mee: storage_path, cache.json, backup.json en instance_id (horen bij
33 // de installatie), data/work (tijdelijke werkmappen), lock-bestanden en
34 // symlinks.
35 var (
36 stateFiles = []string{"bluegit.db", "secret.key"}
37 stateDirs = []string{"ssh", "logos", "avatars"}
38 dataDirs = []string{"repos", "releases", "artifacts"}
39 )
40
41 // DBPath is het logische pad van de databasekopie.
42 const DBPath = "state/bluegit.db"
43
44 // Entry is één bestand in het manifest.
45 type Entry struct {
46 Path string `json:"path"`
47 Size int64 `json:"size"`
48 MTime int64 `json:"mtime"` // Unix-milliseconden
49 Mode uint32 `json:"mode"`
50 SHA256 string `json:"sha256,omitempty"`
51 }
52
53 // Manifest is de volledige lijst op één moment.
54 type Manifest struct {
55 Instance string `json:"instance_id"`
56 CreatedAt time.Time `json:"created_at"`
57 Files []Entry `json:"files"`
58 }
59
60 // Tree kent de twee mappen van een installatie.
61 type Tree struct {
62 StateDir string
63 DataDir string // leeg als er geen datadisk is
64 // Snapshot schrijft een consistente kopie van de database naar pad.
65 Snapshot func(dst string) error
66 }
67
68 func (t Tree) snapshotPath() string { return filepath.Join(t.StateDir, ".backup", "snapshot.db") }
69
70 // Build maakt een nieuwe databasekopie en loopt alle bestanden af.
71 func (t Tree) Build(instance string) (Manifest, error) {
72 m := Manifest{Instance: instance, CreatedAt: time.Now().UTC(), Files: []Entry{}}
73 if t.Snapshot != nil {
74 snap := t.snapshotPath()
75 if err := os.MkdirAll(filepath.Dir(snap), 0o700); err != nil {
76 return m, err
77 }
78 tmp := snap + ".new"
79 _ = os.Remove(tmp)
80 if err := t.Snapshot(tmp); err != nil {
81 return m, fmt.Errorf("databasekopie: %w", err)
82 }
83 if err := os.Rename(tmp, snap); err != nil {
84 return m, err
85 }
86 e, err := entryOf(DBPath, snap, true)
87 if err != nil {
88 return m, err
89 }
90 m.Files = append(m.Files, e)
91 }
92 for _, f := range stateFiles[1:] {
93 p := filepath.Join(t.StateDir, f)
94 if e, err := entryOf("state/"+f, p, false); err == nil {
95 m.Files = append(m.Files, e)
96 }
97 }
98 for _, d := range stateDirs {
99 if err := walk(&m, "state/"+d, filepath.Join(t.StateDir, d)); err != nil {
100 return m, err
101 }
102 }
103 if t.DataDir != "" {
104 for _, d := range dataDirs {
105 if err := walk(&m, "data/"+d, filepath.Join(t.DataDir, d)); err != nil {
106 return m, err
107 }
108 }
109 }
110 sort.Slice(m.Files, func(i, j int) bool { return m.Files[i].Path < m.Files[j].Path })
111 return m, nil
112 }
113
114 func entryOf(logical, real string, hash bool) (Entry, error) {
115 fi, err := os.Lstat(real)
116 if err != nil {
117 return Entry{}, err
118 }
119 if !fi.Mode().IsRegular() {
120 return Entry{}, errors.New("geen gewoon bestand")
121 }
122 e := Entry{Path: logical, Size: fi.Size(), MTime: fi.ModTime().UnixMilli(), Mode: uint32(fi.Mode().Perm())}
123 if hash {
124 f, err := os.Open(real)
125 if err != nil {
126 return e, err
127 }
128 defer f.Close()
129 h := sha256.New()
130 if _, err := io.Copy(h, f); err != nil {
131 return e, err
132 }
133 e.SHA256 = hex.EncodeToString(h.Sum(nil))
134 }
135 return e, nil
136 }
137
138 func skipName(name string) bool {
139 return strings.HasSuffix(name, ".lock") || strings.HasPrefix(name, "tmp_") || name == ".incoming"
140 }
141
142 func walk(m *Manifest, logical, root string) error {
143 err := filepath.WalkDir(root, func(p string, d fs.DirEntry, err error) error {
144 if err != nil {
145 if errors.Is(err, fs.ErrNotExist) {
146 return nil
147 }
148 // Een map die tijdens het lopen verdwijnt (git gc) slaan we over.
149 if d != nil && d.IsDir() {
150 return fs.SkipDir
151 }
152 return nil
153 }
154 if p != root && skipName(d.Name()) {
155 if d.IsDir() {
156 return fs.SkipDir
157 }
158 return nil
159 }
160 if d.IsDir() || d.Type()&fs.ModeSymlink != 0 || !d.Type().IsRegular() {
161 return nil
162 }
163 rel, err := filepath.Rel(root, p)
164 if err != nil {
165 return nil
166 }
167 if e, err := entryOf(logical+"/"+filepath.ToSlash(rel), p, false); err == nil {
168 m.Files = append(m.Files, e)
169 }
170 return nil
171 })
172 if errors.Is(err, fs.ErrNotExist) {
173 return nil
174 }
175 return err
176 }
177
178 // CleanLogical controleert een logisch pad en geeft het genormaliseerd terug.
179 func CleanLogical(p string) (string, bool) {
180 if p == "" || strings.Contains(p, "\\") || strings.ContainsRune(p, 0) || strings.HasPrefix(p, "/") {
181 return "", false
182 }
183 c := path.Clean(p)
184 if c != p || c == "." || strings.HasPrefix(c, "../") || strings.Contains(c, "/../") {
185 return "", false
186 }
187 parts := strings.Split(c, "/")
188 for _, part := range parts {
189 if part == ".." || part == "." || part == "" {
190 return "", false
191 }
192 }
193 if len(parts) < 2 {
194 return "", false
195 }
196 switch parts[0] {
197 case "state":
198 if len(parts) == 2 && contains(stateFiles, parts[1]) {
199 return c, true
200 }
201 if len(parts) >= 3 && contains(stateDirs, parts[1]) {
202 return c, true
203 }
204 case "data":
205 if len(parts) >= 3 && contains(dataDirs, parts[1]) && parts[2] != ".incoming" {
206 return c, true
207 }
208 }
209 return "", false
210 }
211
212 func contains(list []string, v string) bool {
213 for _, x := range list {
214 if x == v {
215 return true
216 }
217 }
218 return false
219 }
220
221 // Resolve geeft het echte bestand bij een logisch pad. De database komt
222 // uit de laatste kopie van Build.
223 func (t Tree) Resolve(logical string) (string, error) {
224 c, ok := CleanLogical(logical)
225 if !ok {
226 return "", errors.New("ongeldig pad")
227 }
228 var real string
229 switch {
230 case c == DBPath:
231 real = t.snapshotPath()
232 case strings.HasPrefix(c, "state/"):
233 real = filepath.Join(t.StateDir, filepath.FromSlash(strings.TrimPrefix(c, "state/")))
234 default:
235 if t.DataDir == "" {
236 return "", errors.New("geen datadisk")
237 }
238 real = filepath.Join(t.DataDir, filepath.FromSlash(strings.TrimPrefix(c, "data/")))
239 }
240 fi, err := os.Lstat(real)
241 if err != nil {
242 return "", err
243 }
244 if !fi.Mode().IsRegular() {
245 return "", errors.New("geen gewoon bestand")
246 }
247 return real, nil
248 }
249
250 // ---------- terugzetten ----------
251
252 const restoreDir = ".restore"
253
254 type pending struct {
255 DataDir string `json:"data_dir"`
256 At time.Time `json:"at"`
257 Files int `json:"files"`
258 }
259
260 // Stage pakt een tar.gz met logische paden uit naast de live mappen. Er
261 // verandert nog niets aan de live gegevens; dat doet ApplyPending bij de
262 // volgende start. De database en secret.key moeten in het archief zitten.
263 func (t Tree) Stage(r io.Reader) (int, error) {
264 stateStage := filepath.Join(t.StateDir, restoreDir)
265 _ = os.RemoveAll(stateStage)
266 var dataStage string
267 if t.DataDir != "" {
268 dataStage = filepath.Join(t.DataDir, restoreDir)
269 _ = os.RemoveAll(dataStage)
270 }
271 fail := func(err error) (int, error) {
272 _ = os.RemoveAll(stateStage)
273 if dataStage != "" {
274 _ = os.RemoveAll(dataStage)
275 }
276 return 0, err
277 }
278 gz, err := gzip.NewReader(r)
279 if err != nil {
280 return fail(fmt.Errorf("geen gzip: %w", err))
281 }
282 tr := tar.NewReader(gz)
283 n := 0
284 seenDB, seenKey := false, false
285 for {
286 h, err := tr.Next()
287 if err == io.EOF {
288 break
289 }
290 if err != nil {
291 return fail(err)
292 }
293 if h.Typeflag == tar.TypeDir {
294 continue
295 }
296 if h.Typeflag != tar.TypeReg {
297 return fail(fmt.Errorf("%s: alleen gewone bestanden", h.Name))
298 }
299 c, ok := CleanLogical(strings.TrimPrefix(h.Name, "./"))
300 if !ok {
301 return fail(fmt.Errorf("ongeldig pad in archief: %q", h.Name))
302 }
303 var dst string
304 if strings.HasPrefix(c, "state/") {
305 dst = filepath.Join(stateStage, filepath.FromSlash(c))
306 } else {
307 if dataStage == "" {
308 return fail(errors.New("het archief bevat repositories, maar deze BlueGit heeft nog geen datadisk"))
309 }
310 dst = filepath.Join(dataStage, filepath.FromSlash(c))
311 }
312 seenDB = seenDB || c == DBPath
313 seenKey = seenKey || c == "state/secret.key"
314 if err := os.MkdirAll(filepath.Dir(dst), 0o750); err != nil {
315 return fail(err)
316 }
317 mode := os.FileMode(h.Mode).Perm() & 0o755
318 if mode == 0 {
319 mode = 0o640
320 }
321 f, err := os.OpenFile(dst, os.O_CREATE|os.O_EXCL|os.O_WRONLY, mode|0o600)
322 if err != nil {
323 return fail(err)
324 }
325 if _, err := io.Copy(f, tr); err != nil {
326 f.Close()
327 return fail(err)
328 }
329 if err := f.Close(); err != nil {
330 return fail(err)
331 }
332 _ = os.Chtimes(dst, h.ModTime, h.ModTime)
333 n++
334 }
335 if !seenDB || !seenKey {
336 return fail(errors.New("het archief mist state/bluegit.db of state/secret.key"))
337 }
338 b, _ := json.Marshal(pending{DataDir: t.DataDir, At: time.Now().UTC(), Files: n})
339 if err := os.WriteFile(filepath.Join(stateStage, "READY"), b, 0o600); err != nil {
340 return fail(err)
341 }
342 return n, nil
343 }
344
345 // HasPending zegt of er een uitgepakte backup klaarstaat.
346 func HasPending(stateDir string) bool {
347 _, err := os.Stat(filepath.Join(stateDir, restoreDir, "READY"))
348 return err == nil
349 }
350
351 // ApplyPending zet een klaarstaande backup op zijn plek. Aanroepen bij de
352 // start, vóór de database open gaat. Geen READY: niets te doen.
353 func ApplyPending(stateDir string) (bool, error) {
354 stage := filepath.Join(stateDir, restoreDir)
355 b, err := os.ReadFile(filepath.Join(stage, "READY"))
356 if errors.Is(err, os.ErrNotExist) {
357 return false, nil
358 }
359 if err != nil {
360 return false, err
361 }
362 var p pending
363 if err := json.Unmarshal(b, &p); err != nil {
364 return false, err
365 }
366 for _, f := range []string{"bluegit.db-wal", "bluegit.db-shm"} {
367 _ = os.Remove(filepath.Join(stateDir, f))
368 }
369 for _, name := range append(append([]string{}, stateFiles...), stateDirs...) {
370 if err := swap(filepath.Join(stateDir, name), filepath.Join(stage, "state", name)); err != nil {
371 return false, err
372 }
373 }
374 if p.DataDir != "" {
375 dstage := filepath.Join(p.DataDir, restoreDir)
376 for _, name := range dataDirs {
377 if err := swap(filepath.Join(p.DataDir, name), filepath.Join(dstage, "data", name)); err != nil {
378 return false, err
379 }
380 }
381 _ = os.RemoveAll(dstage)
382 }
383 _ = os.RemoveAll(filepath.Join(stateDir, ".backup"))
384 return true, os.RemoveAll(stage)
385 }
386
387 // swap vervangt live door staged. Ontbreekt staged, dan verdwijnt live.
388 func swap(live, staged string) error {
389 old := live + ".restore-old"
390 _ = os.RemoveAll(old)
391 if _, err := os.Lstat(live); err == nil {
392 if err := os.Rename(live, old); err != nil {
393 return err
394 }
395 }
396 if _, err := os.Lstat(staged); err == nil {
397 if err := os.Rename(staged, live); err != nil {
398 return err
399 }
400 }
401 return os.RemoveAll(old)
402 }
@@ -0,0 +1,402 @@
1package backup
2
3import (
4 "archive/tar"
5 "compress/gzip"
6 "crypto/sha256"
7 "encoding/hex"
8 "encoding/json"
9 "errors"
10 "fmt"
11 "io"
12 "io/fs"
13 "os"
14 "path"
15 "path/filepath"
16 "sort"
17 "strings"
18 "time"
19)
20
21// Wat er in een backup zit. Logische paden beginnen met state/ of data/.
22//
23// state/bluegit.db consistente kopie (VACUUM INTO), niet het live bestand
24// state/secret.key nodig om de geheimen in de database te lezen
25// state/ssh/… SSH-hostkey
26// state/logos/… project- en groepslogo's
27// state/avatars/… geüploade avatars
28// data/repos/… bare repositories
29// data/releases/… gepubliceerde release-assets (zonder .incoming)
30// data/artifacts/… CI-artifacts
31//
32// Niet mee: storage_path, cache.json, backup.json en instance_id (horen bij
33// de installatie), data/work (tijdelijke werkmappen), lock-bestanden en
34// symlinks.
35var (
36 stateFiles = []string{"bluegit.db", "secret.key"}
37 stateDirs = []string{"ssh", "logos", "avatars"}
38 dataDirs = []string{"repos", "releases", "artifacts"}
39)
40
41// DBPath is het logische pad van de databasekopie.
42const DBPath = "state/bluegit.db"
43
44// Entry is één bestand in het manifest.
45type Entry struct {
46 Path string `json:"path"`
47 Size int64 `json:"size"`
48 MTime int64 `json:"mtime"` // Unix-milliseconden
49 Mode uint32 `json:"mode"`
50 SHA256 string `json:"sha256,omitempty"`
51}
52
53// Manifest is de volledige lijst op één moment.
54type Manifest struct {
55 Instance string `json:"instance_id"`
56 CreatedAt time.Time `json:"created_at"`
57 Files []Entry `json:"files"`
58}
59
60// Tree kent de twee mappen van een installatie.
61type Tree struct {
62 StateDir string
63 DataDir string // leeg als er geen datadisk is
64 // Snapshot schrijft een consistente kopie van de database naar pad.
65 Snapshot func(dst string) error
66}
67
68func (t Tree) snapshotPath() string { return filepath.Join(t.StateDir, ".backup", "snapshot.db") }
69
70// Build maakt een nieuwe databasekopie en loopt alle bestanden af.
71func (t Tree) Build(instance string) (Manifest, error) {
72 m := Manifest{Instance: instance, CreatedAt: time.Now().UTC(), Files: []Entry{}}
73 if t.Snapshot != nil {
74 snap := t.snapshotPath()
75 if err := os.MkdirAll(filepath.Dir(snap), 0o700); err != nil {
76 return m, err
77 }
78 tmp := snap + ".new"
79 _ = os.Remove(tmp)
80 if err := t.Snapshot(tmp); err != nil {
81 return m, fmt.Errorf("databasekopie: %w", err)
82 }
83 if err := os.Rename(tmp, snap); err != nil {
84 return m, err
85 }
86 e, err := entryOf(DBPath, snap, true)
87 if err != nil {
88 return m, err
89 }
90 m.Files = append(m.Files, e)
91 }
92 for _, f := range stateFiles[1:] {
93 p := filepath.Join(t.StateDir, f)
94 if e, err := entryOf("state/"+f, p, false); err == nil {
95 m.Files = append(m.Files, e)
96 }
97 }
98 for _, d := range stateDirs {
99 if err := walk(&m, "state/"+d, filepath.Join(t.StateDir, d)); err != nil {
100 return m, err
101 }
102 }
103 if t.DataDir != "" {
104 for _, d := range dataDirs {
105 if err := walk(&m, "data/"+d, filepath.Join(t.DataDir, d)); err != nil {
106 return m, err
107 }
108 }
109 }
110 sort.Slice(m.Files, func(i, j int) bool { return m.Files[i].Path < m.Files[j].Path })
111 return m, nil
112}
113
114func entryOf(logical, real string, hash bool) (Entry, error) {
115 fi, err := os.Lstat(real)
116 if err != nil {
117 return Entry{}, err
118 }
119 if !fi.Mode().IsRegular() {
120 return Entry{}, errors.New("geen gewoon bestand")
121 }
122 e := Entry{Path: logical, Size: fi.Size(), MTime: fi.ModTime().UnixMilli(), Mode: uint32(fi.Mode().Perm())}
123 if hash {
124 f, err := os.Open(real)
125 if err != nil {
126 return e, err
127 }
128 defer f.Close()
129 h := sha256.New()
130 if _, err := io.Copy(h, f); err != nil {
131 return e, err
132 }
133 e.SHA256 = hex.EncodeToString(h.Sum(nil))
134 }
135 return e, nil
136}
137
138func skipName(name string) bool {
139 return strings.HasSuffix(name, ".lock") || strings.HasPrefix(name, "tmp_") || name == ".incoming"
140}
141
142func walk(m *Manifest, logical, root string) error {
143 err := filepath.WalkDir(root, func(p string, d fs.DirEntry, err error) error {
144 if err != nil {
145 if errors.Is(err, fs.ErrNotExist) {
146 return nil
147 }
148 // Een map die tijdens het lopen verdwijnt (git gc) slaan we over.
149 if d != nil && d.IsDir() {
150 return fs.SkipDir
151 }
152 return nil
153 }
154 if p != root && skipName(d.Name()) {
155 if d.IsDir() {
156 return fs.SkipDir
157 }
158 return nil
159 }
160 if d.IsDir() || d.Type()&fs.ModeSymlink != 0 || !d.Type().IsRegular() {
161 return nil
162 }
163 rel, err := filepath.Rel(root, p)
164 if err != nil {
165 return nil
166 }
167 if e, err := entryOf(logical+"/"+filepath.ToSlash(rel), p, false); err == nil {
168 m.Files = append(m.Files, e)
169 }
170 return nil
171 })
172 if errors.Is(err, fs.ErrNotExist) {
173 return nil
174 }
175 return err
176}
177
178// CleanLogical controleert een logisch pad en geeft het genormaliseerd terug.
179func CleanLogical(p string) (string, bool) {
180 if p == "" || strings.Contains(p, "\\") || strings.ContainsRune(p, 0) || strings.HasPrefix(p, "/") {
181 return "", false
182 }
183 c := path.Clean(p)
184 if c != p || c == "." || strings.HasPrefix(c, "../") || strings.Contains(c, "/../") {
185 return "", false
186 }
187 parts := strings.Split(c, "/")
188 for _, part := range parts {
189 if part == ".." || part == "." || part == "" {
190 return "", false
191 }
192 }
193 if len(parts) < 2 {
194 return "", false
195 }
196 switch parts[0] {
197 case "state":
198 if len(parts) == 2 && contains(stateFiles, parts[1]) {
199 return c, true
200 }
201 if len(parts) >= 3 && contains(stateDirs, parts[1]) {
202 return c, true
203 }
204 case "data":
205 if len(parts) >= 3 && contains(dataDirs, parts[1]) && parts[2] != ".incoming" {
206 return c, true
207 }
208 }
209 return "", false
210}
211
212func contains(list []string, v string) bool {
213 for _, x := range list {
214 if x == v {
215 return true
216 }
217 }
218 return false
219}
220
221// Resolve geeft het echte bestand bij een logisch pad. De database komt
222// uit de laatste kopie van Build.
223func (t Tree) Resolve(logical string) (string, error) {
224 c, ok := CleanLogical(logical)
225 if !ok {
226 return "", errors.New("ongeldig pad")
227 }
228 var real string
229 switch {
230 case c == DBPath:
231 real = t.snapshotPath()
232 case strings.HasPrefix(c, "state/"):
233 real = filepath.Join(t.StateDir, filepath.FromSlash(strings.TrimPrefix(c, "state/")))
234 default:
235 if t.DataDir == "" {
236 return "", errors.New("geen datadisk")
237 }
238 real = filepath.Join(t.DataDir, filepath.FromSlash(strings.TrimPrefix(c, "data/")))
239 }
240 fi, err := os.Lstat(real)
241 if err != nil {
242 return "", err
243 }
244 if !fi.Mode().IsRegular() {
245 return "", errors.New("geen gewoon bestand")
246 }
247 return real, nil
248}
249
250// ---------- terugzetten ----------
251
252const restoreDir = ".restore"
253
254type pending struct {
255 DataDir string `json:"data_dir"`
256 At time.Time `json:"at"`
257 Files int `json:"files"`
258}
259
260// Stage pakt een tar.gz met logische paden uit naast de live mappen. Er
261// verandert nog niets aan de live gegevens; dat doet ApplyPending bij de
262// volgende start. De database en secret.key moeten in het archief zitten.
263func (t Tree) Stage(r io.Reader) (int, error) {
264 stateStage := filepath.Join(t.StateDir, restoreDir)
265 _ = os.RemoveAll(stateStage)
266 var dataStage string
267 if t.DataDir != "" {
268 dataStage = filepath.Join(t.DataDir, restoreDir)
269 _ = os.RemoveAll(dataStage)
270 }
271 fail := func(err error) (int, error) {
272 _ = os.RemoveAll(stateStage)
273 if dataStage != "" {
274 _ = os.RemoveAll(dataStage)
275 }
276 return 0, err
277 }
278 gz, err := gzip.NewReader(r)
279 if err != nil {
280 return fail(fmt.Errorf("geen gzip: %w", err))
281 }
282 tr := tar.NewReader(gz)
283 n := 0
284 seenDB, seenKey := false, false
285 for {
286 h, err := tr.Next()
287 if err == io.EOF {
288 break
289 }
290 if err != nil {
291 return fail(err)
292 }
293 if h.Typeflag == tar.TypeDir {
294 continue
295 }
296 if h.Typeflag != tar.TypeReg {
297 return fail(fmt.Errorf("%s: alleen gewone bestanden", h.Name))
298 }
299 c, ok := CleanLogical(strings.TrimPrefix(h.Name, "./"))
300 if !ok {
301 return fail(fmt.Errorf("ongeldig pad in archief: %q", h.Name))
302 }
303 var dst string
304 if strings.HasPrefix(c, "state/") {
305 dst = filepath.Join(stateStage, filepath.FromSlash(c))
306 } else {
307 if dataStage == "" {
308 return fail(errors.New("het archief bevat repositories, maar deze BlueGit heeft nog geen datadisk"))
309 }
310 dst = filepath.Join(dataStage, filepath.FromSlash(c))
311 }
312 seenDB = seenDB || c == DBPath
313 seenKey = seenKey || c == "state/secret.key"
314 if err := os.MkdirAll(filepath.Dir(dst), 0o750); err != nil {
315 return fail(err)
316 }
317 mode := os.FileMode(h.Mode).Perm() & 0o755
318 if mode == 0 {
319 mode = 0o640
320 }
321 f, err := os.OpenFile(dst, os.O_CREATE|os.O_EXCL|os.O_WRONLY, mode|0o600)
322 if err != nil {
323 return fail(err)
324 }
325 if _, err := io.Copy(f, tr); err != nil {
326 f.Close()
327 return fail(err)
328 }
329 if err := f.Close(); err != nil {
330 return fail(err)
331 }
332 _ = os.Chtimes(dst, h.ModTime, h.ModTime)
333 n++
334 }
335 if !seenDB || !seenKey {
336 return fail(errors.New("het archief mist state/bluegit.db of state/secret.key"))
337 }
338 b, _ := json.Marshal(pending{DataDir: t.DataDir, At: time.Now().UTC(), Files: n})
339 if err := os.WriteFile(filepath.Join(stateStage, "READY"), b, 0o600); err != nil {
340 return fail(err)
341 }
342 return n, nil
343}
344
345// HasPending zegt of er een uitgepakte backup klaarstaat.
346func HasPending(stateDir string) bool {
347 _, err := os.Stat(filepath.Join(stateDir, restoreDir, "READY"))
348 return err == nil
349}
350
351// ApplyPending zet een klaarstaande backup op zijn plek. Aanroepen bij de
352// start, vóór de database open gaat. Geen READY: niets te doen.
353func ApplyPending(stateDir string) (bool, error) {
354 stage := filepath.Join(stateDir, restoreDir)
355 b, err := os.ReadFile(filepath.Join(stage, "READY"))
356 if errors.Is(err, os.ErrNotExist) {
357 return false, nil
358 }
359 if err != nil {
360 return false, err
361 }
362 var p pending
363 if err := json.Unmarshal(b, &p); err != nil {
364 return false, err
365 }
366 for _, f := range []string{"bluegit.db-wal", "bluegit.db-shm"} {
367 _ = os.Remove(filepath.Join(stateDir, f))
368 }
369 for _, name := range append(append([]string{}, stateFiles...), stateDirs...) {
370 if err := swap(filepath.Join(stateDir, name), filepath.Join(stage, "state", name)); err != nil {
371 return false, err
372 }
373 }
374 if p.DataDir != "" {
375 dstage := filepath.Join(p.DataDir, restoreDir)
376 for _, name := range dataDirs {
377 if err := swap(filepath.Join(p.DataDir, name), filepath.Join(dstage, "data", name)); err != nil {
378 return false, err
379 }
380 }
381 _ = os.RemoveAll(dstage)
382 }
383 _ = os.RemoveAll(filepath.Join(stateDir, ".backup"))
384 return true, os.RemoveAll(stage)
385}
386
387// swap vervangt live door staged. Ontbreekt staged, dan verdwijnt live.
388func swap(live, staged string) error {
389 old := live + ".restore-old"
390 _ = os.RemoveAll(old)
391 if _, err := os.Lstat(live); err == nil {
392 if err := os.Rename(live, old); err != nil {
393 return err
394 }
395 }
396 if _, err := os.Lstat(staged); err == nil {
397 if err := os.Rename(staged, live); err != nil {
398 return err
399 }
400 }
401 return os.RemoveAll(old)
402}
internal/i18n/catalog_backup.go added +172 −0
@@ -0,0 +1,172 @@
1 package i18n
2
3 func init() {
4 addCatalog(en, map[string]string{
5 "admin.tab.backup": "Backup",
6 "backup.title": "Backup server",
7 "backup.lead": "A separate bluegit-backup server copies all data and configuration of this BlueGit, slowly and incrementally. It is notified after every change, keeps compressed archives, and can roll this BlueGit back to one of them.",
8 "backup.key.title": "Backupserver-Key",
9 "backup.key.once": "Copy this key now and add it to the backup server. It is shown only once.",
10 "backup.key.active": "Active key: %s…",
11 "backup.key.by": "created by %s",
12 "backup.key.none": "No key yet. Generate one and add it to the backup server with bluegit-backup connect.",
13 "backup.key.replaceAsk": "Replace the key? The connected backup server loses access until it gets the new key.",
14 "backup.key.replace": "Generate new key",
15 "backup.key.new": "Generate Backupserver-Key",
16 "backup.key.revokeAsk": "Revoke the key and disconnect the backup server? Its archives stay on the backup server.",
17 "backup.key.revoke": "Revoke key",
18 "backup.instance": "Instance ID: %s",
19 "backup.server.title": "Connected backup server",
20 "backup.server.connected": "Connected: %s",
21 "backup.server.seen": "last contact",
22 "backup.server.settings": "Archive interval %s, archives kept for %d days",
23 "backup.server.rollback": "last rollback: %s (%s)",
24 "backup.server.unreachable": "The backup server cannot be reached: %s",
25 "backup.server.none": "No backup server has connected with the key yet.",
26 "backup.archives.title": "Backup archives",
27 "backup.archives.none": "The backup server has no archives yet.",
28 "backup.warn.title": "Warning: a rollback cannot be undone",
29 "backup.warn.body": "A rollback replaces ALL data of this BlueGit (database, repositories, releases, artifacts, logos, keys) with the archive. Everything that changed after the archive date is lost for good, also on the backup server. BlueGit restarts during the rollback.",
30 "backup.col.archive": "Archive",
31 "backup.col.created": "Created",
32 "backup.col.size": "Size",
33 "backup.rollback": "Roll back…",
34 "backup.rollbackAsk": "Really roll BlueGit back to %s? This cannot be undone.",
35 "backup.understood": "I understand that this cannot be undone",
36 "backup.typeName": "Type the archive name to confirm",
37 "backup.rollbackNow": "Roll back now",
38 "backup.ok.key": "New Backupserver-Key generated",
39 "backup.ok.revoked": "Key revoked; backup server disconnected",
40 "backup.ok.rollback": "Rollback to %s started. BlueGit restarts as soon as the backup server has sent the data.",
41 "backup.err.archive": "choose an archive",
42 "backup.err.confirm": "the typed name does not match the archive",
43 "backup.err.none": "no backup server is connected",
44 "backup.err.understood": "tick that you understand the rollback cannot be undone",
45 })
46 addCatalog(nl, map[string]string{
47 "admin.tab.backup": "Backup",
48 "backup.title": "Backup server",
49 "backup.lead": "Een losse bluegit-backup-server kopieert langzaam en stapsgewijs alle gegevens en configuratie van deze BlueGit. Hij krijgt na elke wijziging een melding, bewaart gecomprimeerde archieven en kan deze BlueGit naar één daarvan terugzetten.",
50 "backup.key.title": "Backupserver-Key",
51 "backup.key.once": "Kopieer deze key nu en voeg hem toe aan de backup server. Hij wordt maar één keer getoond.",
52 "backup.key.active": "Actieve key: %s…",
53 "backup.key.by": "gemaakt door %s",
54 "backup.key.none": "Nog geen key. Maak er een en voeg hem toe aan de backup server met bluegit-backup connect.",
55 "backup.key.replaceAsk": "Key vervangen? De gekoppelde backup server verliest zijn toegang tot hij de nieuwe key krijgt.",
56 "backup.key.replace": "Nieuwe key maken",
57 "backup.key.new": "Backupserver-Key maken",
58 "backup.key.revokeAsk": "Key intrekken en de backup server loskoppelen? Zijn archieven blijven op de backup server staan.",
59 "backup.key.revoke": "Key intrekken",
60 "backup.instance": "Instance-id: %s",
61 "backup.server.title": "Gekoppelde backup server",
62 "backup.server.connected": "Gekoppeld: %s",
63 "backup.server.seen": "laatste contact",
64 "backup.server.settings": "Archiefinterval %s, archieven %d dagen bewaard",
65 "backup.server.rollback": "laatste rollback: %s (%s)",
66 "backup.server.unreachable": "De backup server is niet bereikbaar: %s",
67 "backup.server.none": "Er heeft zich nog geen backup server met de key gemeld.",
68 "backup.archives.title": "Backup-archieven",
69 "backup.archives.none": "De backup server heeft nog geen archieven.",
70 "backup.warn.title": "Waarschuwing: een rollback is niet terug te draaien",
71 "backup.warn.body": "Een rollback vervangt ALLE gegevens van deze BlueGit (database, repositories, releases, artifacts, logo's, sleutels) door het archief. Alles wat na de datum van het archief veranderde, is voorgoed weg, ook op de backup server. BlueGit herstart tijdens de rollback.",
72 "backup.col.archive": "Archief",
73 "backup.col.created": "Gemaakt",
74 "backup.col.size": "Grootte",
75 "backup.rollback": "Rollback…",
76 "backup.rollbackAsk": "BlueGit echt terugzetten naar %s? Dit is niet terug te draaien.",
77 "backup.understood": "Ik begrijp dat dit niet terug te draaien is",
78 "backup.typeName": "Typ de naam van het archief ter bevestiging",
79 "backup.rollbackNow": "Nu terugzetten",
80 "backup.ok.key": "Nieuwe Backupserver-Key gemaakt",
81 "backup.ok.revoked": "Key ingetrokken; backup server losgekoppeld",
82 "backup.ok.rollback": "Rollback naar %s gestart. BlueGit herstart zodra de backup server de gegevens heeft gestuurd.",
83 "backup.err.archive": "kies een archief",
84 "backup.err.confirm": "de getypte naam klopt niet met het archief",
85 "backup.err.none": "er is geen backup server gekoppeld",
86 "backup.err.understood": "vink aan dat je begrijpt dat de rollback niet terug te draaien is",
87 })
88 addCatalog(de, map[string]string{
89 "admin.tab.backup": "Backup",
90 "backup.title": "Backup-Server",
91 "backup.lead": "Ein separater bluegit-backup-Server kopiert langsam und schrittweise alle Daten und die Konfiguration dieses BlueGit. Er wird nach jeder Änderung benachrichtigt, bewahrt komprimierte Archive auf und kann dieses BlueGit auf eines davon zurücksetzen.",
92 "backup.key.title": "Backupserver-Key",
93 "backup.key.once": "Kopiere diesen Key jetzt und füge ihn dem Backup-Server hinzu. Er wird nur einmal angezeigt.",
94 "backup.key.active": "Aktiver Key: %s…",
95 "backup.key.by": "erstellt von %s",
96 "backup.key.none": "Noch kein Key. Erstelle einen und füge ihn mit bluegit-backup connect dem Backup-Server hinzu.",
97 "backup.key.replaceAsk": "Key ersetzen? Der verbundene Backup-Server verliert den Zugriff, bis er den neuen Key erhält.",
98 "backup.key.replace": "Neuen Key erstellen",
99 "backup.key.new": "Backupserver-Key erstellen",
100 "backup.key.revokeAsk": "Key widerrufen und den Backup-Server trennen? Seine Archive bleiben auf dem Backup-Server.",
101 "backup.key.revoke": "Key widerrufen",
102 "backup.instance": "Instanz-ID: %s",
103 "backup.server.title": "Verbundener Backup-Server",
104 "backup.server.connected": "Verbunden: %s",
105 "backup.server.seen": "letzter Kontakt",
106 "backup.server.settings": "Archivintervall %s, Archive %d Tage aufbewahrt",
107 "backup.server.rollback": "letzter Rollback: %s (%s)",
108 "backup.server.unreachable": "Der Backup-Server ist nicht erreichbar: %s",
109 "backup.server.none": "Noch hat sich kein Backup-Server mit dem Key gemeldet.",
110 "backup.archives.title": "Backup-Archive",
111 "backup.archives.none": "Der Backup-Server hat noch keine Archive.",
112 "backup.warn.title": "Warnung: Ein Rollback kann nicht rückgängig gemacht werden",
113 "backup.warn.body": "Ein Rollback ersetzt ALLE Daten dieses BlueGit (Datenbank, Repositories, Releases, Artefakte, Logos, Schlüssel) durch das Archiv. Alles, was sich nach dem Archivdatum geändert hat, ist endgültig verloren, auch auf dem Backup-Server. BlueGit startet während des Rollbacks neu.",
114 "backup.col.archive": "Archiv",
115 "backup.col.created": "Erstellt",
116 "backup.col.size": "Größe",
117 "backup.rollback": "Rollback…",
118 "backup.rollbackAsk": "BlueGit wirklich auf %s zurücksetzen? Das kann nicht rückgängig gemacht werden.",
119 "backup.understood": "Ich verstehe, dass dies nicht rückgängig gemacht werden kann",
120 "backup.typeName": "Gib zur Bestätigung den Archivnamen ein",
121 "backup.rollbackNow": "Jetzt zurücksetzen",
122 "backup.ok.key": "Neuer Backupserver-Key erstellt",
123 "backup.ok.revoked": "Key widerrufen; Backup-Server getrennt",
124 "backup.ok.rollback": "Rollback auf %s gestartet. BlueGit startet neu, sobald der Backup-Server die Daten gesendet hat.",
125 "backup.err.archive": "wähle ein Archiv",
126 "backup.err.confirm": "der eingegebene Name passt nicht zum Archiv",
127 "backup.err.none": "kein Backup-Server verbunden",
128 "backup.err.understood": "bestätige, dass der Rollback nicht rückgängig gemacht werden kann",
129 })
130 addCatalog(fr, map[string]string{
131 "admin.tab.backup": "Sauvegarde",
132 "backup.title": "Serveur de sauvegarde",
133 "backup.lead": "Un serveur bluegit-backup séparé copie lentement et progressivement toutes les données et la configuration de ce BlueGit. Il est notifié après chaque modification, conserve des archives compressées et peut ramener ce BlueGit à l’une d’elles.",
134 "backup.key.title": "Backupserver-Key",
135 "backup.key.once": "Copiez cette clé maintenant et ajoutez-la au serveur de sauvegarde. Elle n’est affichée qu’une fois.",
136 "backup.key.active": "Clé active : %s…",
137 "backup.key.by": "créée par %s",
138 "backup.key.none": "Pas encore de clé. Générez-en une et ajoutez-la au serveur avec bluegit-backup connect.",
139 "backup.key.replaceAsk": "Remplacer la clé ? Le serveur connecté perd l’accès jusqu’à ce qu’il reçoive la nouvelle clé.",
140 "backup.key.replace": "Générer une nouvelle clé",
141 "backup.key.new": "Générer une Backupserver-Key",
142 "backup.key.revokeAsk": "Révoquer la clé et déconnecter le serveur ? Ses archives restent sur le serveur de sauvegarde.",
143 "backup.key.revoke": "Révoquer la clé",
144 "backup.instance": "ID d’instance : %s",
145 "backup.server.title": "Serveur de sauvegarde connecté",
146 "backup.server.connected": "Connecté : %s",
147 "backup.server.seen": "dernier contact",
148 "backup.server.settings": "Intervalle d’archivage %s, archives conservées %d jours",
149 "backup.server.rollback": "dernier rollback : %s (%s)",
150 "backup.server.unreachable": "Le serveur de sauvegarde est injoignable : %s",
151 "backup.server.none": "Aucun serveur de sauvegarde ne s’est encore connecté avec la clé.",
152 "backup.archives.title": "Archives de sauvegarde",
153 "backup.archives.none": "Le serveur de sauvegarde n’a pas encore d’archives.",
154 "backup.warn.title": "Attention : un rollback est irréversible",
155 "backup.warn.body": "Un rollback remplace TOUTES les données de ce BlueGit (base de données, dépôts, releases, artefacts, logos, clés) par l’archive. Tout ce qui a changé après la date de l’archive est perdu définitivement, y compris sur le serveur de sauvegarde. BlueGit redémarre pendant le rollback.",
156 "backup.col.archive": "Archive",
157 "backup.col.created": "Créée",
158 "backup.col.size": "Taille",
159 "backup.rollback": "Rollback…",
160 "backup.rollbackAsk": "Vraiment ramener BlueGit à %s ? C’est irréversible.",
161 "backup.understood": "Je comprends que c’est irréversible",
162 "backup.typeName": "Saisissez le nom de l’archive pour confirmer",
163 "backup.rollbackNow": "Restaurer maintenant",
164 "backup.ok.key": "Nouvelle Backupserver-Key générée",
165 "backup.ok.revoked": "Clé révoquée ; serveur déconnecté",
166 "backup.ok.rollback": "Rollback vers %s lancé. BlueGit redémarre dès que le serveur a envoyé les données.",
167 "backup.err.archive": "choisissez une archive",
168 "backup.err.confirm": "le nom saisi ne correspond pas à l’archive",
169 "backup.err.none": "aucun serveur de sauvegarde n’est connecté",
170 "backup.err.understood": "cochez que vous comprenez que le rollback est irréversible",
171 })
172 }
@@ -0,0 +1,172 @@
1package i18n
2
3func init() {
4 addCatalog(en, map[string]string{
5 "admin.tab.backup": "Backup",
6 "backup.title": "Backup server",
7 "backup.lead": "A separate bluegit-backup server copies all data and configuration of this BlueGit, slowly and incrementally. It is notified after every change, keeps compressed archives, and can roll this BlueGit back to one of them.",
8 "backup.key.title": "Backupserver-Key",
9 "backup.key.once": "Copy this key now and add it to the backup server. It is shown only once.",
10 "backup.key.active": "Active key: %s…",
11 "backup.key.by": "created by %s",
12 "backup.key.none": "No key yet. Generate one and add it to the backup server with bluegit-backup connect.",
13 "backup.key.replaceAsk": "Replace the key? The connected backup server loses access until it gets the new key.",
14 "backup.key.replace": "Generate new key",
15 "backup.key.new": "Generate Backupserver-Key",
16 "backup.key.revokeAsk": "Revoke the key and disconnect the backup server? Its archives stay on the backup server.",
17 "backup.key.revoke": "Revoke key",
18 "backup.instance": "Instance ID: %s",
19 "backup.server.title": "Connected backup server",
20 "backup.server.connected": "Connected: %s",
21 "backup.server.seen": "last contact",
22 "backup.server.settings": "Archive interval %s, archives kept for %d days",
23 "backup.server.rollback": "last rollback: %s (%s)",
24 "backup.server.unreachable": "The backup server cannot be reached: %s",
25 "backup.server.none": "No backup server has connected with the key yet.",
26 "backup.archives.title": "Backup archives",
27 "backup.archives.none": "The backup server has no archives yet.",
28 "backup.warn.title": "Warning: a rollback cannot be undone",
29 "backup.warn.body": "A rollback replaces ALL data of this BlueGit (database, repositories, releases, artifacts, logos, keys) with the archive. Everything that changed after the archive date is lost for good, also on the backup server. BlueGit restarts during the rollback.",
30 "backup.col.archive": "Archive",
31 "backup.col.created": "Created",
32 "backup.col.size": "Size",
33 "backup.rollback": "Roll back…",
34 "backup.rollbackAsk": "Really roll BlueGit back to %s? This cannot be undone.",
35 "backup.understood": "I understand that this cannot be undone",
36 "backup.typeName": "Type the archive name to confirm",
37 "backup.rollbackNow": "Roll back now",
38 "backup.ok.key": "New Backupserver-Key generated",
39 "backup.ok.revoked": "Key revoked; backup server disconnected",
40 "backup.ok.rollback": "Rollback to %s started. BlueGit restarts as soon as the backup server has sent the data.",
41 "backup.err.archive": "choose an archive",
42 "backup.err.confirm": "the typed name does not match the archive",
43 "backup.err.none": "no backup server is connected",
44 "backup.err.understood": "tick that you understand the rollback cannot be undone",
45 })
46 addCatalog(nl, map[string]string{
47 "admin.tab.backup": "Backup",
48 "backup.title": "Backup server",
49 "backup.lead": "Een losse bluegit-backup-server kopieert langzaam en stapsgewijs alle gegevens en configuratie van deze BlueGit. Hij krijgt na elke wijziging een melding, bewaart gecomprimeerde archieven en kan deze BlueGit naar één daarvan terugzetten.",
50 "backup.key.title": "Backupserver-Key",
51 "backup.key.once": "Kopieer deze key nu en voeg hem toe aan de backup server. Hij wordt maar één keer getoond.",
52 "backup.key.active": "Actieve key: %s…",
53 "backup.key.by": "gemaakt door %s",
54 "backup.key.none": "Nog geen key. Maak er een en voeg hem toe aan de backup server met bluegit-backup connect.",
55 "backup.key.replaceAsk": "Key vervangen? De gekoppelde backup server verliest zijn toegang tot hij de nieuwe key krijgt.",
56 "backup.key.replace": "Nieuwe key maken",
57 "backup.key.new": "Backupserver-Key maken",
58 "backup.key.revokeAsk": "Key intrekken en de backup server loskoppelen? Zijn archieven blijven op de backup server staan.",
59 "backup.key.revoke": "Key intrekken",
60 "backup.instance": "Instance-id: %s",
61 "backup.server.title": "Gekoppelde backup server",
62 "backup.server.connected": "Gekoppeld: %s",
63 "backup.server.seen": "laatste contact",
64 "backup.server.settings": "Archiefinterval %s, archieven %d dagen bewaard",
65 "backup.server.rollback": "laatste rollback: %s (%s)",
66 "backup.server.unreachable": "De backup server is niet bereikbaar: %s",
67 "backup.server.none": "Er heeft zich nog geen backup server met de key gemeld.",
68 "backup.archives.title": "Backup-archieven",
69 "backup.archives.none": "De backup server heeft nog geen archieven.",
70 "backup.warn.title": "Waarschuwing: een rollback is niet terug te draaien",
71 "backup.warn.body": "Een rollback vervangt ALLE gegevens van deze BlueGit (database, repositories, releases, artifacts, logo's, sleutels) door het archief. Alles wat na de datum van het archief veranderde, is voorgoed weg, ook op de backup server. BlueGit herstart tijdens de rollback.",
72 "backup.col.archive": "Archief",
73 "backup.col.created": "Gemaakt",
74 "backup.col.size": "Grootte",
75 "backup.rollback": "Rollback…",
76 "backup.rollbackAsk": "BlueGit echt terugzetten naar %s? Dit is niet terug te draaien.",
77 "backup.understood": "Ik begrijp dat dit niet terug te draaien is",
78 "backup.typeName": "Typ de naam van het archief ter bevestiging",
79 "backup.rollbackNow": "Nu terugzetten",
80 "backup.ok.key": "Nieuwe Backupserver-Key gemaakt",
81 "backup.ok.revoked": "Key ingetrokken; backup server losgekoppeld",
82 "backup.ok.rollback": "Rollback naar %s gestart. BlueGit herstart zodra de backup server de gegevens heeft gestuurd.",
83 "backup.err.archive": "kies een archief",
84 "backup.err.confirm": "de getypte naam klopt niet met het archief",
85 "backup.err.none": "er is geen backup server gekoppeld",
86 "backup.err.understood": "vink aan dat je begrijpt dat de rollback niet terug te draaien is",
87 })
88 addCatalog(de, map[string]string{
89 "admin.tab.backup": "Backup",
90 "backup.title": "Backup-Server",
91 "backup.lead": "Ein separater bluegit-backup-Server kopiert langsam und schrittweise alle Daten und die Konfiguration dieses BlueGit. Er wird nach jeder Änderung benachrichtigt, bewahrt komprimierte Archive auf und kann dieses BlueGit auf eines davon zurücksetzen.",
92 "backup.key.title": "Backupserver-Key",
93 "backup.key.once": "Kopiere diesen Key jetzt und füge ihn dem Backup-Server hinzu. Er wird nur einmal angezeigt.",
94 "backup.key.active": "Aktiver Key: %s…",
95 "backup.key.by": "erstellt von %s",
96 "backup.key.none": "Noch kein Key. Erstelle einen und füge ihn mit bluegit-backup connect dem Backup-Server hinzu.",
97 "backup.key.replaceAsk": "Key ersetzen? Der verbundene Backup-Server verliert den Zugriff, bis er den neuen Key erhält.",
98 "backup.key.replace": "Neuen Key erstellen",
99 "backup.key.new": "Backupserver-Key erstellen",
100 "backup.key.revokeAsk": "Key widerrufen und den Backup-Server trennen? Seine Archive bleiben auf dem Backup-Server.",
101 "backup.key.revoke": "Key widerrufen",
102 "backup.instance": "Instanz-ID: %s",
103 "backup.server.title": "Verbundener Backup-Server",
104 "backup.server.connected": "Verbunden: %s",
105 "backup.server.seen": "letzter Kontakt",
106 "backup.server.settings": "Archivintervall %s, Archive %d Tage aufbewahrt",
107 "backup.server.rollback": "letzter Rollback: %s (%s)",
108 "backup.server.unreachable": "Der Backup-Server ist nicht erreichbar: %s",
109 "backup.server.none": "Noch hat sich kein Backup-Server mit dem Key gemeldet.",
110 "backup.archives.title": "Backup-Archive",
111 "backup.archives.none": "Der Backup-Server hat noch keine Archive.",
112 "backup.warn.title": "Warnung: Ein Rollback kann nicht rückgängig gemacht werden",
113 "backup.warn.body": "Ein Rollback ersetzt ALLE Daten dieses BlueGit (Datenbank, Repositories, Releases, Artefakte, Logos, Schlüssel) durch das Archiv. Alles, was sich nach dem Archivdatum geändert hat, ist endgültig verloren, auch auf dem Backup-Server. BlueGit startet während des Rollbacks neu.",
114 "backup.col.archive": "Archiv",
115 "backup.col.created": "Erstellt",
116 "backup.col.size": "Größe",
117 "backup.rollback": "Rollback…",
118 "backup.rollbackAsk": "BlueGit wirklich auf %s zurücksetzen? Das kann nicht rückgängig gemacht werden.",
119 "backup.understood": "Ich verstehe, dass dies nicht rückgängig gemacht werden kann",
120 "backup.typeName": "Gib zur Bestätigung den Archivnamen ein",
121 "backup.rollbackNow": "Jetzt zurücksetzen",
122 "backup.ok.key": "Neuer Backupserver-Key erstellt",
123 "backup.ok.revoked": "Key widerrufen; Backup-Server getrennt",
124 "backup.ok.rollback": "Rollback auf %s gestartet. BlueGit startet neu, sobald der Backup-Server die Daten gesendet hat.",
125 "backup.err.archive": "wähle ein Archiv",
126 "backup.err.confirm": "der eingegebene Name passt nicht zum Archiv",
127 "backup.err.none": "kein Backup-Server verbunden",
128 "backup.err.understood": "bestätige, dass der Rollback nicht rückgängig gemacht werden kann",
129 })
130 addCatalog(fr, map[string]string{
131 "admin.tab.backup": "Sauvegarde",
132 "backup.title": "Serveur de sauvegarde",
133 "backup.lead": "Un serveur bluegit-backup séparé copie lentement et progressivement toutes les données et la configuration de ce BlueGit. Il est notifié après chaque modification, conserve des archives compressées et peut ramener ce BlueGit à l’une d’elles.",
134 "backup.key.title": "Backupserver-Key",
135 "backup.key.once": "Copiez cette clé maintenant et ajoutez-la au serveur de sauvegarde. Elle n’est affichée qu’une fois.",
136 "backup.key.active": "Clé active : %s…",
137 "backup.key.by": "créée par %s",
138 "backup.key.none": "Pas encore de clé. Générez-en une et ajoutez-la au serveur avec bluegit-backup connect.",
139 "backup.key.replaceAsk": "Remplacer la clé ? Le serveur connecté perd l’accès jusqu’à ce qu’il reçoive la nouvelle clé.",
140 "backup.key.replace": "Générer une nouvelle clé",
141 "backup.key.new": "Générer une Backupserver-Key",
142 "backup.key.revokeAsk": "Révoquer la clé et déconnecter le serveur ? Ses archives restent sur le serveur de sauvegarde.",
143 "backup.key.revoke": "Révoquer la clé",
144 "backup.instance": "ID d’instance : %s",
145 "backup.server.title": "Serveur de sauvegarde connecté",
146 "backup.server.connected": "Connecté : %s",
147 "backup.server.seen": "dernier contact",
148 "backup.server.settings": "Intervalle d’archivage %s, archives conservées %d jours",
149 "backup.server.rollback": "dernier rollback : %s (%s)",
150 "backup.server.unreachable": "Le serveur de sauvegarde est injoignable : %s",
151 "backup.server.none": "Aucun serveur de sauvegarde ne s’est encore connecté avec la clé.",
152 "backup.archives.title": "Archives de sauvegarde",
153 "backup.archives.none": "Le serveur de sauvegarde n’a pas encore d’archives.",
154 "backup.warn.title": "Attention : un rollback est irréversible",
155 "backup.warn.body": "Un rollback remplace TOUTES les données de ce BlueGit (base de données, dépôts, releases, artefacts, logos, clés) par l’archive. Tout ce qui a changé après la date de l’archive est perdu définitivement, y compris sur le serveur de sauvegarde. BlueGit redémarre pendant le rollback.",
156 "backup.col.archive": "Archive",
157 "backup.col.created": "Créée",
158 "backup.col.size": "Taille",
159 "backup.rollback": "Rollback…",
160 "backup.rollbackAsk": "Vraiment ramener BlueGit à %s ? C’est irréversible.",
161 "backup.understood": "Je comprends que c’est irréversible",
162 "backup.typeName": "Saisissez le nom de l’archive pour confirmer",
163 "backup.rollbackNow": "Restaurer maintenant",
164 "backup.ok.key": "Nouvelle Backupserver-Key générée",
165 "backup.ok.revoked": "Clé révoquée ; serveur déconnecté",
166 "backup.ok.rollback": "Rollback vers %s lancé. BlueGit redémarre dès que le serveur a envoyé les données.",
167 "backup.err.archive": "choisissez une archive",
168 "backup.err.confirm": "le nom saisi ne correspond pas à l’archive",
169 "backup.err.none": "aucun serveur de sauvegarde n’est connecté",
170 "backup.err.understood": "cochez que vous comprenez que le rollback est irréversible",
171 })
172}
internal/server/admin_users.go +3 −2
@@ -27,15 +27,16 @@ func adminTabs(page string) []AdminTab {
27 27 {Key: "admin.tab.runner", Href: "/admin/runner"},
28 28 {Key: "admin.tab.storage", Href: "/setup"},
29 29 {Key: "admin.tab.pipelines", Href: "/admin/pipelines"},
30 {Key: "admin.tab.backup", Href: "/admin/backup"},
30 31 }
31 32 for i := range tabs {
32 tabs[i].On = (page == "adminusers" && i == 0) || (page == "adminrunner" && i == 1) || (page == "setup" && i == 2) || (page == "adminpipelines" && i == 3)
33 tabs[i].On = (page == "adminusers" && i == 0) || (page == "adminrunner" && i == 1) || (page == "setup" && i == 2) || (page == "adminpipelines" && i == 3) || (page == "adminbackup" && i == 4)
33 34 }
34 35 return tabs
35 36 }
36 37
37 38 func isAdminPage(page string) bool {
38 return page == "adminusers" || page == "adminrunner" || page == "setup" || page == "adminpipelines"
39 return page == "adminusers" || page == "adminrunner" || page == "setup" || page == "adminpipelines" || page == "adminbackup"
39 40 }
40 41
41 42 func (s *Server) mountAdmin(mux *http.ServeMux) {
@@ -27,15 +27,16 @@ func adminTabs(page string) []AdminTab {
27 {Key: "admin.tab.runner", Href: "/admin/runner"},
27 {Key: "admin.tab.runner", Href: "/admin/runner"},
28 {Key: "admin.tab.storage", Href: "/setup"},
28 {Key: "admin.tab.storage", Href: "/setup"},
29 {Key: "admin.tab.pipelines", Href: "/admin/pipelines"},
29 {Key: "admin.tab.pipelines", Href: "/admin/pipelines"},
30 {Key: "admin.tab.backup", Href: "/admin/backup"},
30 }
31 }
31 for i := range tabs {
32 for i := range tabs {
32 tabs[i].On = (page == "adminusers" && i == 0) || (page == "adminrunner" && i == 1) || (page == "setup" && i == 2) || (page == "adminpipelines" && i == 3)
33 tabs[i].On = (page == "adminusers" && i == 0) || (page == "adminrunner" && i == 1) || (page == "setup" && i == 2) || (page == "adminpipelines" && i == 3) || (page == "adminbackup" && i == 4)
33 }
34 }
34 return tabs
35 return tabs
35}
36}
36
37
37func isAdminPage(page string) bool {
38func isAdminPage(page string) bool {
38 return page == "adminusers" || page == "adminrunner" || page == "setup" || page == "adminpipelines"
39 return page == "adminusers" || page == "adminrunner" || page == "setup" || page == "adminpipelines" || page == "adminbackup"
39}
40}
40
41
41func (s *Server) mountAdmin(mux *http.ServeMux) {
42func (s *Server) mountAdmin(mux *http.ServeMux) {
internal/server/api_routes.go +4 −0
@@ -191,5 +191,9 @@ var apiCatalog = []apiRoute{
191 191 {http.MethodPost, "/api/v1/admin/self-update/force", access.ScopeAdmin, authUser, "Install the pending self-update now, without waiting for running jobs", (*Server).apiForceUpdate},
192 192 {http.MethodGet, "/api/v1/admin/cache", access.ScopeAdmin, authUser, "Read cache settings and usage", (*Server).apiAdminCache},
193 193 {http.MethodPut, "/api/v1/admin/cache", access.ScopeAdmin, authUser, "Set cache path", (*Server).apiAdminCache},
194 {http.MethodGet, "/api/v1/admin/backup", access.ScopeAdmin, authUser, "Backup server status and archive list (instance admin)", (*Server).apiAdminBackup},
195 {http.MethodPost, "/api/v1/admin/backup/key", access.ScopeAdmin, authUser, "Generate a new Backupserver-Key; shown once, replaces the old key (instance admin)", (*Server).apiAdminBackupKey},
196 {http.MethodDelete, "/api/v1/admin/backup/key", access.ScopeAdmin, authUser, "Revoke the Backupserver-Key and forget the backup server (instance admin)", (*Server).apiAdminBackupRevoke},
197 {http.MethodPost, "/api/v1/admin/backup/rollback", access.ScopeAdmin, authUser, "Roll back to a backup archive. Irreversible. Body {archive, confirm: archive name again} (instance admin)", (*Server).apiAdminBackupRollback},
194 198 {http.MethodPost, "/api/v1/admin/cache/clear", access.ScopeAdmin, authUser, "Clear the read cache", (*Server).apiAdminCacheClear},
195 199 }
@@ -191,5 +191,9 @@ var apiCatalog = []apiRoute{
191 {http.MethodPost, "/api/v1/admin/self-update/force", access.ScopeAdmin, authUser, "Install the pending self-update now, without waiting for running jobs", (*Server).apiForceUpdate},
191 {http.MethodPost, "/api/v1/admin/self-update/force", access.ScopeAdmin, authUser, "Install the pending self-update now, without waiting for running jobs", (*Server).apiForceUpdate},
192 {http.MethodGet, "/api/v1/admin/cache", access.ScopeAdmin, authUser, "Read cache settings and usage", (*Server).apiAdminCache},
192 {http.MethodGet, "/api/v1/admin/cache", access.ScopeAdmin, authUser, "Read cache settings and usage", (*Server).apiAdminCache},
193 {http.MethodPut, "/api/v1/admin/cache", access.ScopeAdmin, authUser, "Set cache path", (*Server).apiAdminCache},
193 {http.MethodPut, "/api/v1/admin/cache", access.ScopeAdmin, authUser, "Set cache path", (*Server).apiAdminCache},
194 {http.MethodGet, "/api/v1/admin/backup", access.ScopeAdmin, authUser, "Backup server status and archive list (instance admin)", (*Server).apiAdminBackup},
195 {http.MethodPost, "/api/v1/admin/backup/key", access.ScopeAdmin, authUser, "Generate a new Backupserver-Key; shown once, replaces the old key (instance admin)", (*Server).apiAdminBackupKey},
196 {http.MethodDelete, "/api/v1/admin/backup/key", access.ScopeAdmin, authUser, "Revoke the Backupserver-Key and forget the backup server (instance admin)", (*Server).apiAdminBackupRevoke},
197 {http.MethodPost, "/api/v1/admin/backup/rollback", access.ScopeAdmin, authUser, "Roll back to a backup archive. Irreversible. Body {archive, confirm: archive name again} (instance admin)", (*Server).apiAdminBackupRollback},
194 {http.MethodPost, "/api/v1/admin/cache/clear", access.ScopeAdmin, authUser, "Clear the read cache", (*Server).apiAdminCacheClear},
198 {http.MethodPost, "/api/v1/admin/cache/clear", access.ScopeAdmin, authUser, "Clear the read cache", (*Server).apiAdminCacheClear},
195}
199}
internal/server/backup.go added +438 −0
@@ -0,0 +1,438 @@
1 package server
2
3 import (
4 "context"
5 "encoding/json"
6 "errors"
7 "io"
8 "net/http"
9 "net/url"
10 "os"
11 "strconv"
12 "strings"
13 "sync/atomic"
14 "time"
15
16 "gitlab.com/Timfa/bluegit/internal/backup"
17 "gitlab.com/Timfa/bluegit/internal/i18n"
18 )
19
20 // Beheer > Backup: één losse backup server (repo bluegit-backup) haalt met
21 // een Backupserver-Key alle gegevens op, krijgt een melding bij elke
22 // wijziging, en kan een archief terugsturen (rollback). Het protocol staat
23 // in docs/BACKUP.md.
24
25 // maxRestoreBytes begrenst een terug te zetten archief (64 GiB).
26 const maxRestoreBytes = 64 << 30
27
28 var (
29 restoreBusy atomic.Bool
30 backupFails updateLimiter
31 )
32
33 // BackupView is de stand op Beheer > Backup.
34 type BackupView struct {
35 Conn backup.Conn
36 NewKey string
37 Archives []backup.Archive
38 Remote *backup.RemoteStatus
39 RemoteErr string
40 InstanceID string
41 }
42
43 func (s *Server) backupInit() {
44 s.backupOnce.Do(func() {
45 s.backupMgr = &backup.Manager{Dir: s.StateDir}
46 s.backupHTTP = &http.Client{Timeout: 15 * time.Second}
47 s.backupNote = &backup.Notifier{Client: s.backupClient()}
48 })
49 }
50
51 func (s *Server) backupClient() *backup.Client {
52 return &backup.Client{Manager: s.backupMgr, HTTP: s.backupHTTP}
53 }
54
55 // BackupManager geeft de koppeling (ook voor tests).
56 func (s *Server) BackupManager() *backup.Manager {
57 s.backupInit()
58 return s.backupMgr
59 }
60
61 // BackupChanged meldt een wijziging aan de gekoppelde backup server.
62 func (s *Server) BackupChanged() {
63 if s.StateDir == "" {
64 return
65 }
66 s.backupInit()
67 s.backupNote.Changed()
68 }
69
70 func (s *Server) backupTree() backup.Tree {
71 return backup.Tree{
72 StateDir: s.StateDir, DataDir: s.StoragePath(),
73 Snapshot: func(dst string) error { return s.Store.Snapshot(context.Background(), dst) },
74 }
75 }
76
77 func (s *Server) mountBackup(mux *http.ServeMux) {
78 mux.HandleFunc("GET /api/v1/backup/info", s.backupKeyed(s.backupInfo))
79 mux.HandleFunc("POST /api/v1/backup/connect", s.backupKeyed(s.backupConnect))
80 mux.HandleFunc("GET /api/v1/backup/manifest", s.backupKeyed(s.backupManifest))
81 mux.HandleFunc("GET /api/v1/backup/file", s.backupKeyed(s.backupFile))
82 mux.HandleFunc("POST /api/v1/backup/restore", s.backupKeyed(s.backupRestore))
83 mux.HandleFunc("GET /admin/backup", s.adminBackup)
84 mux.HandleFunc("POST /admin/backup/key", s.adminBackupKey)
85 mux.HandleFunc("POST /admin/backup/revoke", s.adminBackupRevoke)
86 mux.HandleFunc("POST /admin/backup/rollback", s.adminBackupRollback)
87 }
88
89 // backupWatch meldt na elk schrijvend verzoek een wijziging. De backup
90 // server haalt daarna alleen op wat veranderd is; een melding te veel kost
91 // dus weinig. Tijdens het terugzetten van een backup wordt niet geschreven.
92 func (s *Server) backupWatch(next http.Handler) http.Handler {
93 return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
94 switch r.Method {
95 case http.MethodGet, http.MethodHead, http.MethodOptions:
96 next.ServeHTTP(w, r)
97 return
98 }
99 if restoreBusy.Load() {
100 http.Error(w, "backup wordt teruggezet; BlueGit herstart zo\n", http.StatusServiceUnavailable)
101 return
102 }
103 next.ServeHTTP(w, r)
104 if strings.HasPrefix(r.URL.Path, "/api/v1/backup/") || strings.HasSuffix(r.URL.Path, "/git-upload-pack") {
105 return
106 }
107 s.BackupChanged()
108 })
109 }
110
111 func backupErr(w http.ResponseWriter, code int, msg string) {
112 writeJSON(w, code, map[string]string{"error": msg})
113 }
114
115 // backupKeyed eist de Backupserver-Key als bearer-token.
116 func (s *Server) backupKeyed(h func(http.ResponseWriter, *http.Request)) http.HandlerFunc {
117 return func(w http.ResponseWriter, r *http.Request) {
118 w.Header().Set("Cache-Control", "no-store")
119 if s.StateDir == "" {
120 backupErr(w, http.StatusNotFound, "backup niet beschikbaar")
121 return
122 }
123 s.backupInit()
124 if _, ok := s.backupMgr.Check(bearer(r)); !ok {
125 // Alleen mislukte pogingen tellen: hoogstens 5 per minuut per IP.
126 if !backupFails.allow(clientIP(r), time.Now()) {
127 backupErr(w, http.StatusTooManyRequests, "te veel mislukte pogingen")
128 return
129 }
130 backupErr(w, http.StatusUnauthorized, "ongeldige Backupserver-Key")
131 return
132 }
133 s.backupMgr.Seen()
134 h(w, r)
135 }
136 }
137
138 func (s *Server) backupInfo(w http.ResponseWriter, r *http.Request) {
139 id, err := s.backupMgr.InstanceID()
140 if err != nil {
141 backupErr(w, 500, err.Error())
142 return
143 }
144 c, _ := s.backupMgr.Load()
145 writeJSON(w, http.StatusOK, map[string]any{
146 "instance_id": id, "base_url": s.Cfg.BaseURL, "server_url": c.ServerURL, "server_id": c.ServerID,
147 "has_storage": s.StoragePath() != "",
148 })
149 }
150
151 func (s *Server) backupConnect(w http.ResponseWriter, r *http.Request) {
152 var in struct {
153 ServerURL string `json:"server_url"`
154 ServerID string `json:"server_id"`
155 }
156 if err := json.NewDecoder(io.LimitReader(r.Body, 1<<16)).Decode(&in); err != nil {
157 backupErr(w, 400, "ongeldige JSON")
158 return
159 }
160 u, err := url.Parse(strings.TrimSpace(in.ServerURL))
161 if err != nil || (u.Scheme != "http" && u.Scheme != "https") || u.Host == "" {
162 backupErr(w, 400, "server_url moet een http(s)-adres zijn")
163 return
164 }
165 c, err := s.backupMgr.Connect(u.String(), strings.TrimSpace(in.ServerID))
166 if err != nil {
167 backupErr(w, 500, err.Error())
168 return
169 }
170 id, _ := s.backupMgr.InstanceID()
171 if s.Log != nil {
172 s.Log.Info("backup audit", "action", "connect", "server", c.ServerURL, "server_id", c.ServerID)
173 }
174 writeJSON(w, http.StatusOK, map[string]any{"instance_id": id, "server_url": c.ServerURL})
175 }
176
177 func (s *Server) backupManifest(w http.ResponseWriter, r *http.Request) {
178 id, err := s.backupMgr.InstanceID()
179 if err != nil {
180 backupErr(w, 500, err.Error())
181 return
182 }
183 m, err := s.backupTree().Build(id)
184 if err != nil {
185 backupErr(w, 500, err.Error())
186 return
187 }
188 writeJSON(w, http.StatusOK, m)
189 }
190
191 func (s *Server) backupFile(w http.ResponseWriter, r *http.Request) {
192 real, err := s.backupTree().Resolve(r.URL.Query().Get("path"))
193 if err != nil {
194 backupErr(w, http.StatusNotFound, "bestand niet gevonden")
195 return
196 }
197 f, err := os.Open(real)
198 if err != nil {
199 backupErr(w, http.StatusNotFound, "bestand niet gevonden")
200 return
201 }
202 defer f.Close()
203 fi, err := f.Stat()
204 if err != nil {
205 backupErr(w, 500, err.Error())
206 return
207 }
208 w.Header().Set("Content-Type", "application/octet-stream")
209 w.Header().Set("Content-Length", strconv.FormatInt(fi.Size(), 10))
210 w.Header().Set("X-Backup-Mtime", strconv.FormatInt(fi.ModTime().UnixMilli(), 10))
211 _, _ = io.Copy(w, f)
212 }
213
214 // backupRestore neemt een tar.gz aan, pakt het naast de live gegevens uit
215 // en herstart BlueGit. Bij de start komt de backup op zijn plek.
216 func (s *Server) backupRestore(w http.ResponseWriter, r *http.Request) {
217 if !s.restoring.TryLock() {
218 backupErr(w, http.StatusConflict, "er loopt al een restore")
219 return
220 }
221 defer s.restoring.Unlock()
222 restoreBusy.Store(true)
223 n, err := s.backupTree().Stage(http.MaxBytesReader(w, r.Body, maxRestoreBytes))
224 if err != nil {
225 restoreBusy.Store(false)
226 if s.Log != nil {
227 s.Log.Warn("backup audit", "action", "restore_failed", "err", err)
228 }
229 backupErr(w, http.StatusBadRequest, err.Error())
230 return
231 }
232 if s.Log != nil {
233 s.Log.Warn("backup audit", "action", "restore_staged", "files", n)
234 }
235 writeJSON(w, http.StatusAccepted, map[string]any{"files": n, "restarting": s.RequestRestart != nil})
236 if f, ok := w.(http.Flusher); ok {
237 f.Flush()
238 }
239 if s.RequestRestart != nil {
240 go func() {
241 time.Sleep(300 * time.Millisecond)
242 s.RequestRestart()
243 }()
244 }
245 }
246
247 // ---------- Beheer > Backup ----------
248
249 func (s *Server) backupView(r *http.Request) *BackupView {
250 s.backupInit()
251 bv := &BackupView{}
252 bv.Conn, _ = s.backupMgr.Load()
253 bv.InstanceID, _ = s.backupMgr.InstanceID()
254 if bv.Conn.Connected() {
255 ctx, cancel := context.WithTimeout(r.Context(), 8*time.Second)
256 defer cancel()
257 arch, err := s.backupClient().Archives(ctx)
258 if err != nil {
259 bv.RemoteErr = err.Error()
260 } else {
261 bv.Archives = arch
262 if st, err := s.backupClient().Status(ctx); err == nil {
263 bv.Remote = &st
264 }
265 }
266 }
267 return bv
268 }
269
270 func (s *Server) adminBackup(w http.ResponseWriter, r *http.Request) {
271 if ok, _ := s.adminOnly(w, r); !ok {
272 return
273 }
274 v := s.view(w, r, "title.admin")
275 v.Page = "adminbackup"
276 v.Backup = s.backupView(r)
277 if c, err := r.Cookie("bluegit_backup_key"); err == nil && c.Value != "" {
278 v.Backup.NewKey = c.Value
279 http.SetCookie(w, &http.Cookie{Name: "bluegit_backup_key", Value: "", Path: "/admin/backup", MaxAge: -1})
280 }
281 s.render(w, "adminbackup", v)
282 }
283
284 func (s *Server) adminBackupKey(w http.ResponseWriter, r *http.Request) {
285 if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) {
286 return
287 }
288 s.backupInit()
289 key, _, err := s.backupMgr.NewKey(s.who(r).User.Username)
290 if err != nil {
291 s.redirect(w, r, "/admin/backup", "", err.Error())
292 return
293 }
294 if s.Log != nil {
295 s.Log.Info("backup audit", "action", "new_key", "by", s.who(r).User.Username)
296 }
297 // Eenmalig tonen: kort, HttpOnly cookie alleen voor deze pagina.
298 http.SetCookie(w, &http.Cookie{
299 Name: "bluegit_backup_key", Value: key, Path: "/admin/backup", MaxAge: 60, HttpOnly: true,
300 SameSite: http.SameSiteStrictMode, Secure: strings.HasPrefix(s.Cfg.BaseURL, "https://"),
301 })
302 s.redirect(w, r, "/admin/backup", s.tr(r, "backup.ok.key"), "")
303 }
304
305 func (s *Server) adminBackupRevoke(w http.ResponseWriter, r *http.Request) {
306 if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) {
307 return
308 }
309 s.backupInit()
310 if err := s.backupMgr.Revoke(); err != nil {
311 s.redirect(w, r, "/admin/backup", "", err.Error())
312 return
313 }
314 if s.Log != nil {
315 s.Log.Info("backup audit", "action", "revoke", "by", s.who(r).User.Username)
316 }
317 s.redirect(w, r, "/admin/backup", s.tr(r, "backup.ok.revoked"), "")
318 }
319
320 func (s *Server) startRollback(ctx context.Context, by, archive, confirm string) error {
321 s.backupInit()
322 archive = strings.TrimSpace(archive)
323 if archive == "" {
324 return fail(400, i18n.E("backup.err.archive"))
325 }
326 if strings.TrimSpace(confirm) != archive {
327 return fail(400, i18n.E("backup.err.confirm"))
328 }
329 c, _ := s.backupMgr.Load()
330 if !c.Connected() {
331 return fail(409, i18n.E("backup.err.none"))
332 }
333 if err := s.backupClient().Rollback(ctx, archive); err != nil {
334 return fail(502, err)
335 }
336 if s.Log != nil {
337 s.Log.Warn("backup audit", "action", "rollback", "by", by, "archive", archive)
338 }
339 return nil
340 }
341
342 func (s *Server) adminBackupRollback(w http.ResponseWriter, r *http.Request) {
343 if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) {
344 return
345 }
346 if r.FormValue("understood") != "1" {
347 s.redirect(w, r, "/admin/backup", "", s.tr(r, "backup.err.understood"))
348 return
349 }
350 if err := s.startRollback(r.Context(), s.who(r).User.Username, r.FormValue("archive"), r.FormValue("confirm")); err != nil {
351 s.redirect(w, r, "/admin/backup", "", s.trErr(r, unwrapFail(err)))
352 return
353 }
354 s.redirect(w, r, "/admin/backup", s.tr(r, "backup.ok.rollback", r.FormValue("archive")), "")
355 }
356
357 func unwrapFail(err error) error {
358 var oe interface{ Unwrap() error }
359 if errors.As(err, &oe) && oe.Unwrap() != nil {
360 return oe.Unwrap()
361 }
362 return err
363 }
364
365 // ---------- API voor beheerders ----------
366
367 func (s *Server) apiAdminBackup(w http.ResponseWriter, r *http.Request) {
368 if !apiUser(r).InstanceAdmin {
369 s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden")))
370 return
371 }
372 bv := s.backupView(r)
373 out := map[string]any{
374 "instance_id": bv.InstanceID, "has_key": bv.Conn.HasKey(), "key_hint": bv.Conn.KeyHint,
375 "connected": bv.Conn.Connected(), "server_url": bv.Conn.ServerURL, "server_id": bv.Conn.ServerID,
376 "archives": bv.Archives, "remote_error": bv.RemoteErr,
377 }
378 if bv.Conn.Connected() {
379 out["last_seen"] = rfcTime(bv.Conn.LastSeen)
380 }
381 if bv.Archives == nil {
382 out["archives"] = []backup.Archive{}
383 }
384 if bv.Remote != nil {
385 out["remote"] = bv.Remote
386 }
387 writeJSON(w, http.StatusOK, out)
388 }
389
390 func (s *Server) apiAdminBackupKey(w http.ResponseWriter, r *http.Request) {
391 if !apiUser(r).InstanceAdmin {
392 s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden")))
393 return
394 }
395 s.backupInit()
396 key, c, err := s.backupMgr.NewKey(apiUser(r).Username)
397 if err != nil {
398 s.writeAPIErr(w, r, fail(500, err))
399 return
400 }
401 if s.Log != nil {
402 s.Log.Info("backup audit", "action", "new_key", "by", apiUser(r).Username)
403 }
404 writeJSON(w, http.StatusCreated, map[string]any{"key": key, "key_hint": c.KeyHint, "created_at": rfcTime(c.CreatedAt)})
405 }
406
407 func (s *Server) apiAdminBackupRevoke(w http.ResponseWriter, r *http.Request) {
408 if !apiUser(r).InstanceAdmin {
409 s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden")))
410 return
411 }
412 s.backupInit()
413 if err := s.backupMgr.Revoke(); err != nil {
414 s.writeAPIErr(w, r, fail(500, err))
415 return
416 }
417 writeJSON(w, http.StatusNoContent, nil)
418 }
419
420 func (s *Server) apiAdminBackupRollback(w http.ResponseWriter, r *http.Request) {
421 if !apiUser(r).InstanceAdmin {
422 s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden")))
423 return
424 }
425 var in struct {
426 Archive string `json:"archive"`
427 Confirm string `json:"confirm"`
428 }
429 if err := readJSON(r, &in); err != nil {
430 s.writeAPIErr(w, r, fail(400, i18n.E("backup.err.archive")))
431 return
432 }
433 if err := s.startRollback(r.Context(), apiUser(r).Username, in.Archive, in.Confirm); err != nil {
434 s.writeAPIErr(w, r, err)
435 return
436 }
437 writeJSON(w, http.StatusAccepted, map[string]any{"archive": in.Archive, "state": "started"})
438 }
@@ -0,0 +1,438 @@
1package server
2
3import (
4 "context"
5 "encoding/json"
6 "errors"
7 "io"
8 "net/http"
9 "net/url"
10 "os"
11 "strconv"
12 "strings"
13 "sync/atomic"
14 "time"
15
16 "gitlab.com/Timfa/bluegit/internal/backup"
17 "gitlab.com/Timfa/bluegit/internal/i18n"
18)
19
20// Beheer > Backup: één losse backup server (repo bluegit-backup) haalt met
21// een Backupserver-Key alle gegevens op, krijgt een melding bij elke
22// wijziging, en kan een archief terugsturen (rollback). Het protocol staat
23// in docs/BACKUP.md.
24
25// maxRestoreBytes begrenst een terug te zetten archief (64 GiB).
26const maxRestoreBytes = 64 << 30
27
28var (
29 restoreBusy atomic.Bool
30 backupFails updateLimiter
31)
32
33// BackupView is de stand op Beheer > Backup.
34type BackupView struct {
35 Conn backup.Conn
36 NewKey string
37 Archives []backup.Archive
38 Remote *backup.RemoteStatus
39 RemoteErr string
40 InstanceID string
41}
42
43func (s *Server) backupInit() {
44 s.backupOnce.Do(func() {
45 s.backupMgr = &backup.Manager{Dir: s.StateDir}
46 s.backupHTTP = &http.Client{Timeout: 15 * time.Second}
47 s.backupNote = &backup.Notifier{Client: s.backupClient()}
48 })
49}
50
51func (s *Server) backupClient() *backup.Client {
52 return &backup.Client{Manager: s.backupMgr, HTTP: s.backupHTTP}
53}
54
55// BackupManager geeft de koppeling (ook voor tests).
56func (s *Server) BackupManager() *backup.Manager {
57 s.backupInit()
58 return s.backupMgr
59}
60
61// BackupChanged meldt een wijziging aan de gekoppelde backup server.
62func (s *Server) BackupChanged() {
63 if s.StateDir == "" {
64 return
65 }
66 s.backupInit()
67 s.backupNote.Changed()
68}
69
70func (s *Server) backupTree() backup.Tree {
71 return backup.Tree{
72 StateDir: s.StateDir, DataDir: s.StoragePath(),
73 Snapshot: func(dst string) error { return s.Store.Snapshot(context.Background(), dst) },
74 }
75}
76
77func (s *Server) mountBackup(mux *http.ServeMux) {
78 mux.HandleFunc("GET /api/v1/backup/info", s.backupKeyed(s.backupInfo))
79 mux.HandleFunc("POST /api/v1/backup/connect", s.backupKeyed(s.backupConnect))
80 mux.HandleFunc("GET /api/v1/backup/manifest", s.backupKeyed(s.backupManifest))
81 mux.HandleFunc("GET /api/v1/backup/file", s.backupKeyed(s.backupFile))
82 mux.HandleFunc("POST /api/v1/backup/restore", s.backupKeyed(s.backupRestore))
83 mux.HandleFunc("GET /admin/backup", s.adminBackup)
84 mux.HandleFunc("POST /admin/backup/key", s.adminBackupKey)
85 mux.HandleFunc("POST /admin/backup/revoke", s.adminBackupRevoke)
86 mux.HandleFunc("POST /admin/backup/rollback", s.adminBackupRollback)
87}
88
89// backupWatch meldt na elk schrijvend verzoek een wijziging. De backup
90// server haalt daarna alleen op wat veranderd is; een melding te veel kost
91// dus weinig. Tijdens het terugzetten van een backup wordt niet geschreven.
92func (s *Server) backupWatch(next http.Handler) http.Handler {
93 return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
94 switch r.Method {
95 case http.MethodGet, http.MethodHead, http.MethodOptions:
96 next.ServeHTTP(w, r)
97 return
98 }
99 if restoreBusy.Load() {
100 http.Error(w, "backup wordt teruggezet; BlueGit herstart zo\n", http.StatusServiceUnavailable)
101 return
102 }
103 next.ServeHTTP(w, r)
104 if strings.HasPrefix(r.URL.Path, "/api/v1/backup/") || strings.HasSuffix(r.URL.Path, "/git-upload-pack") {
105 return
106 }
107 s.BackupChanged()
108 })
109}
110
111func backupErr(w http.ResponseWriter, code int, msg string) {
112 writeJSON(w, code, map[string]string{"error": msg})
113}
114
115// backupKeyed eist de Backupserver-Key als bearer-token.
116func (s *Server) backupKeyed(h func(http.ResponseWriter, *http.Request)) http.HandlerFunc {
117 return func(w http.ResponseWriter, r *http.Request) {
118 w.Header().Set("Cache-Control", "no-store")
119 if s.StateDir == "" {
120 backupErr(w, http.StatusNotFound, "backup niet beschikbaar")
121 return
122 }
123 s.backupInit()
124 if _, ok := s.backupMgr.Check(bearer(r)); !ok {
125 // Alleen mislukte pogingen tellen: hoogstens 5 per minuut per IP.
126 if !backupFails.allow(clientIP(r), time.Now()) {
127 backupErr(w, http.StatusTooManyRequests, "te veel mislukte pogingen")
128 return
129 }
130 backupErr(w, http.StatusUnauthorized, "ongeldige Backupserver-Key")
131 return
132 }
133 s.backupMgr.Seen()
134 h(w, r)
135 }
136}
137
138func (s *Server) backupInfo(w http.ResponseWriter, r *http.Request) {
139 id, err := s.backupMgr.InstanceID()
140 if err != nil {
141 backupErr(w, 500, err.Error())
142 return
143 }
144 c, _ := s.backupMgr.Load()
145 writeJSON(w, http.StatusOK, map[string]any{
146 "instance_id": id, "base_url": s.Cfg.BaseURL, "server_url": c.ServerURL, "server_id": c.ServerID,
147 "has_storage": s.StoragePath() != "",
148 })
149}
150
151func (s *Server) backupConnect(w http.ResponseWriter, r *http.Request) {
152 var in struct {
153 ServerURL string `json:"server_url"`
154 ServerID string `json:"server_id"`
155 }
156 if err := json.NewDecoder(io.LimitReader(r.Body, 1<<16)).Decode(&in); err != nil {
157 backupErr(w, 400, "ongeldige JSON")
158 return
159 }
160 u, err := url.Parse(strings.TrimSpace(in.ServerURL))
161 if err != nil || (u.Scheme != "http" && u.Scheme != "https") || u.Host == "" {
162 backupErr(w, 400, "server_url moet een http(s)-adres zijn")
163 return
164 }
165 c, err := s.backupMgr.Connect(u.String(), strings.TrimSpace(in.ServerID))
166 if err != nil {
167 backupErr(w, 500, err.Error())
168 return
169 }
170 id, _ := s.backupMgr.InstanceID()
171 if s.Log != nil {
172 s.Log.Info("backup audit", "action", "connect", "server", c.ServerURL, "server_id", c.ServerID)
173 }
174 writeJSON(w, http.StatusOK, map[string]any{"instance_id": id, "server_url": c.ServerURL})
175}
176
177func (s *Server) backupManifest(w http.ResponseWriter, r *http.Request) {
178 id, err := s.backupMgr.InstanceID()
179 if err != nil {
180 backupErr(w, 500, err.Error())
181 return
182 }
183 m, err := s.backupTree().Build(id)
184 if err != nil {
185 backupErr(w, 500, err.Error())
186 return
187 }
188 writeJSON(w, http.StatusOK, m)
189}
190
191func (s *Server) backupFile(w http.ResponseWriter, r *http.Request) {
192 real, err := s.backupTree().Resolve(r.URL.Query().Get("path"))
193 if err != nil {
194 backupErr(w, http.StatusNotFound, "bestand niet gevonden")
195 return
196 }
197 f, err := os.Open(real)
198 if err != nil {
199 backupErr(w, http.StatusNotFound, "bestand niet gevonden")
200 return
201 }
202 defer f.Close()
203 fi, err := f.Stat()
204 if err != nil {
205 backupErr(w, 500, err.Error())
206 return
207 }
208 w.Header().Set("Content-Type", "application/octet-stream")
209 w.Header().Set("Content-Length", strconv.FormatInt(fi.Size(), 10))
210 w.Header().Set("X-Backup-Mtime", strconv.FormatInt(fi.ModTime().UnixMilli(), 10))
211 _, _ = io.Copy(w, f)
212}
213
214// backupRestore neemt een tar.gz aan, pakt het naast de live gegevens uit
215// en herstart BlueGit. Bij de start komt de backup op zijn plek.
216func (s *Server) backupRestore(w http.ResponseWriter, r *http.Request) {
217 if !s.restoring.TryLock() {
218 backupErr(w, http.StatusConflict, "er loopt al een restore")
219 return
220 }
221 defer s.restoring.Unlock()
222 restoreBusy.Store(true)
223 n, err := s.backupTree().Stage(http.MaxBytesReader(w, r.Body, maxRestoreBytes))
224 if err != nil {
225 restoreBusy.Store(false)
226 if s.Log != nil {
227 s.Log.Warn("backup audit", "action", "restore_failed", "err", err)
228 }
229 backupErr(w, http.StatusBadRequest, err.Error())
230 return
231 }
232 if s.Log != nil {
233 s.Log.Warn("backup audit", "action", "restore_staged", "files", n)
234 }
235 writeJSON(w, http.StatusAccepted, map[string]any{"files": n, "restarting": s.RequestRestart != nil})
236 if f, ok := w.(http.Flusher); ok {
237 f.Flush()
238 }
239 if s.RequestRestart != nil {
240 go func() {
241 time.Sleep(300 * time.Millisecond)
242 s.RequestRestart()
243 }()
244 }
245}
246
247// ---------- Beheer > Backup ----------
248
249func (s *Server) backupView(r *http.Request) *BackupView {
250 s.backupInit()
251 bv := &BackupView{}
252 bv.Conn, _ = s.backupMgr.Load()
253 bv.InstanceID, _ = s.backupMgr.InstanceID()
254 if bv.Conn.Connected() {
255 ctx, cancel := context.WithTimeout(r.Context(), 8*time.Second)
256 defer cancel()
257 arch, err := s.backupClient().Archives(ctx)
258 if err != nil {
259 bv.RemoteErr = err.Error()
260 } else {
261 bv.Archives = arch
262 if st, err := s.backupClient().Status(ctx); err == nil {
263 bv.Remote = &st
264 }
265 }
266 }
267 return bv
268}
269
270func (s *Server) adminBackup(w http.ResponseWriter, r *http.Request) {
271 if ok, _ := s.adminOnly(w, r); !ok {
272 return
273 }
274 v := s.view(w, r, "title.admin")
275 v.Page = "adminbackup"
276 v.Backup = s.backupView(r)
277 if c, err := r.Cookie("bluegit_backup_key"); err == nil && c.Value != "" {
278 v.Backup.NewKey = c.Value
279 http.SetCookie(w, &http.Cookie{Name: "bluegit_backup_key", Value: "", Path: "/admin/backup", MaxAge: -1})
280 }
281 s.render(w, "adminbackup", v)
282}
283
284func (s *Server) adminBackupKey(w http.ResponseWriter, r *http.Request) {
285 if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) {
286 return
287 }
288 s.backupInit()
289 key, _, err := s.backupMgr.NewKey(s.who(r).User.Username)
290 if err != nil {
291 s.redirect(w, r, "/admin/backup", "", err.Error())
292 return
293 }
294 if s.Log != nil {
295 s.Log.Info("backup audit", "action", "new_key", "by", s.who(r).User.Username)
296 }
297 // Eenmalig tonen: kort, HttpOnly cookie alleen voor deze pagina.
298 http.SetCookie(w, &http.Cookie{
299 Name: "bluegit_backup_key", Value: key, Path: "/admin/backup", MaxAge: 60, HttpOnly: true,
300 SameSite: http.SameSiteStrictMode, Secure: strings.HasPrefix(s.Cfg.BaseURL, "https://"),
301 })
302 s.redirect(w, r, "/admin/backup", s.tr(r, "backup.ok.key"), "")
303}
304
305func (s *Server) adminBackupRevoke(w http.ResponseWriter, r *http.Request) {
306 if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) {
307 return
308 }
309 s.backupInit()
310 if err := s.backupMgr.Revoke(); err != nil {
311 s.redirect(w, r, "/admin/backup", "", err.Error())
312 return
313 }
314 if s.Log != nil {
315 s.Log.Info("backup audit", "action", "revoke", "by", s.who(r).User.Username)
316 }
317 s.redirect(w, r, "/admin/backup", s.tr(r, "backup.ok.revoked"), "")
318}
319
320func (s *Server) startRollback(ctx context.Context, by, archive, confirm string) error {
321 s.backupInit()
322 archive = strings.TrimSpace(archive)
323 if archive == "" {
324 return fail(400, i18n.E("backup.err.archive"))
325 }
326 if strings.TrimSpace(confirm) != archive {
327 return fail(400, i18n.E("backup.err.confirm"))
328 }
329 c, _ := s.backupMgr.Load()
330 if !c.Connected() {
331 return fail(409, i18n.E("backup.err.none"))
332 }
333 if err := s.backupClient().Rollback(ctx, archive); err != nil {
334 return fail(502, err)
335 }
336 if s.Log != nil {
337 s.Log.Warn("backup audit", "action", "rollback", "by", by, "archive", archive)
338 }
339 return nil
340}
341
342func (s *Server) adminBackupRollback(w http.ResponseWriter, r *http.Request) {
343 if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) {
344 return
345 }
346 if r.FormValue("understood") != "1" {
347 s.redirect(w, r, "/admin/backup", "", s.tr(r, "backup.err.understood"))
348 return
349 }
350 if err := s.startRollback(r.Context(), s.who(r).User.Username, r.FormValue("archive"), r.FormValue("confirm")); err != nil {
351 s.redirect(w, r, "/admin/backup", "", s.trErr(r, unwrapFail(err)))
352 return
353 }
354 s.redirect(w, r, "/admin/backup", s.tr(r, "backup.ok.rollback", r.FormValue("archive")), "")
355}
356
357func unwrapFail(err error) error {
358 var oe interface{ Unwrap() error }
359 if errors.As(err, &oe) && oe.Unwrap() != nil {
360 return oe.Unwrap()
361 }
362 return err
363}
364
365// ---------- API voor beheerders ----------
366
367func (s *Server) apiAdminBackup(w http.ResponseWriter, r *http.Request) {
368 if !apiUser(r).InstanceAdmin {
369 s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden")))
370 return
371 }
372 bv := s.backupView(r)
373 out := map[string]any{
374 "instance_id": bv.InstanceID, "has_key": bv.Conn.HasKey(), "key_hint": bv.Conn.KeyHint,
375 "connected": bv.Conn.Connected(), "server_url": bv.Conn.ServerURL, "server_id": bv.Conn.ServerID,
376 "archives": bv.Archives, "remote_error": bv.RemoteErr,
377 }
378 if bv.Conn.Connected() {
379 out["last_seen"] = rfcTime(bv.Conn.LastSeen)
380 }
381 if bv.Archives == nil {
382 out["archives"] = []backup.Archive{}
383 }
384 if bv.Remote != nil {
385 out["remote"] = bv.Remote
386 }
387 writeJSON(w, http.StatusOK, out)
388}
389
390func (s *Server) apiAdminBackupKey(w http.ResponseWriter, r *http.Request) {
391 if !apiUser(r).InstanceAdmin {
392 s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden")))
393 return
394 }
395 s.backupInit()
396 key, c, err := s.backupMgr.NewKey(apiUser(r).Username)
397 if err != nil {
398 s.writeAPIErr(w, r, fail(500, err))
399 return
400 }
401 if s.Log != nil {
402 s.Log.Info("backup audit", "action", "new_key", "by", apiUser(r).Username)
403 }
404 writeJSON(w, http.StatusCreated, map[string]any{"key": key, "key_hint": c.KeyHint, "created_at": rfcTime(c.CreatedAt)})
405}
406
407func (s *Server) apiAdminBackupRevoke(w http.ResponseWriter, r *http.Request) {
408 if !apiUser(r).InstanceAdmin {
409 s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden")))
410 return
411 }
412 s.backupInit()
413 if err := s.backupMgr.Revoke(); err != nil {
414 s.writeAPIErr(w, r, fail(500, err))
415 return
416 }
417 writeJSON(w, http.StatusNoContent, nil)
418}
419
420func (s *Server) apiAdminBackupRollback(w http.ResponseWriter, r *http.Request) {
421 if !apiUser(r).InstanceAdmin {
422 s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden")))
423 return
424 }
425 var in struct {
426 Archive string `json:"archive"`
427 Confirm string `json:"confirm"`
428 }
429 if err := readJSON(r, &in); err != nil {
430 s.writeAPIErr(w, r, fail(400, i18n.E("backup.err.archive")))
431 return
432 }
433 if err := s.startRollback(r.Context(), apiUser(r).Username, in.Archive, in.Confirm); err != nil {
434 s.writeAPIErr(w, r, err)
435 return
436 }
437 writeJSON(w, http.StatusAccepted, map[string]any{"archive": in.Archive, "state": "started"})
438}
internal/server/backup_tar_test.go added +22 −0
@@ -0,0 +1,22 @@
1 package server
2
3 import (
4 "archive/tar"
5 "compress/gzip"
6 "io"
7 "testing"
8 )
9
10 func writeTarGz(t *testing.T, w io.Writer, files map[string]string) {
11 t.Helper()
12 gz := gzip.NewWriter(w)
13 tw := tar.NewWriter(gz)
14 for name, data := range files {
15 if err := tw.WriteHeader(&tar.Header{Name: name, Mode: 0o640, Size: int64(len(data)), Typeflag: tar.TypeReg}); err != nil {
16 t.Fatal(err)
17 }
18 _, _ = tw.Write([]byte(data))
19 }
20 _ = tw.Close()
21 _ = gz.Close()
22 }
@@ -0,0 +1,22 @@
1package server
2
3import (
4 "archive/tar"
5 "compress/gzip"
6 "io"
7 "testing"
8)
9
10func writeTarGz(t *testing.T, w io.Writer, files map[string]string) {
11 t.Helper()
12 gz := gzip.NewWriter(w)
13 tw := tar.NewWriter(gz)
14 for name, data := range files {
15 if err := tw.WriteHeader(&tar.Header{Name: name, Mode: 0o640, Size: int64(len(data)), Typeflag: tar.TypeReg}); err != nil {
16 t.Fatal(err)
17 }
18 _, _ = tw.Write([]byte(data))
19 }
20 _ = tw.Close()
21 _ = gz.Close()
22}
internal/server/backup_test.go added +302 −0
@@ -0,0 +1,302 @@
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 badSig int
85 ts *httptest.Server
86 }
87
88 func newFakeBackup(t *testing.T) *fakeBackup {
89 f := &fakeBackup{}
90 f.ts = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
91 body, _ := io.ReadAll(r.Body)
92 f.mu.Lock()
93 defer f.mu.Unlock()
94 if err := backup.Verify(r, f.secret, body, time.Now()); err != nil {
95 f.badSig++
96 http.Error(w, `{"error":"sig"}`, 401)
97 return
98 }
99 switch r.URL.Path {
100 case "/api/v1/notify":
101 f.notifies++
102 w.WriteHeader(204)
103 case "/api/v1/archives":
104 _ = 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}}})
105 case "/api/v1/status":
106 _, _ = w.Write([]byte(`{"version":"test","archive_interval":"24h0m0s","retention_days":30,"rollback":{"state":"idle"}}`))
107 case "/api/v1/rollback":
108 var in struct{ Archive string }
109 _ = json.Unmarshal(body, &in)
110 f.rollback = append(f.rollback, in.Archive)
111 w.WriteHeader(202)
112 default:
113 http.NotFound(w, r)
114 }
115 }))
116 t.Cleanup(f.ts.Close)
117 return f
118 }
119
120 func TestBackupKeyAndKeyedAPI(t *testing.T) {
121 e := newBackupEnv(t)
122 // Zonder key: 401. Met een gewoon toegangstoken: ook 401.
123 if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/manifest", "", nil); code != 401 {
124 t.Fatalf("zonder key: %d", code)
125 }
126 if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/manifest", e.tok, nil); code != 401 {
127 t.Fatalf("bg_-token: %d", code)
128 }
129 // Alleen een beheerder maakt een key.
130 bob, _ := e.st.UpsertUser(context.Background(), 2, "bob", "", false)
131 if code, _ := rapi(t, e.base, issue(t, e.st, bob.ID, "api"), "POST", "/admin/backup/key", nil); code != 403 {
132 t.Fatalf("bob maakt key: %d", code)
133 }
134 code, b := rapi(t, e.base, e.tok, "POST", "/admin/backup/key", nil)
135 if code != 201 {
136 t.Fatalf("key: %d %s", code, b)
137 }
138 var k struct{ Key string }
139 _ = json.Unmarshal(b, &k)
140 if !strings.HasPrefix(k.Key, "bgbk_") {
141 t.Fatalf("key %q", k.Key)
142 }
143 code, b = keyed(t, "GET", e.base+"/api/v1/backup/info", k.Key, nil)
144 var info struct {
145 InstanceID string `json:"instance_id"`
146 }
147 _ = json.Unmarshal(b, &info)
148 if code != 200 || info.InstanceID == "" {
149 t.Fatalf("info: %d %s", code, b)
150 }
151 code, b = keyed(t, "GET", e.base+"/api/v1/backup/manifest", k.Key, nil)
152 var m backup.Manifest
153 _ = json.Unmarshal(b, &m)
154 if code != 200 || m.Instance != info.InstanceID {
155 t.Fatalf("manifest: %d %.300s", code, b)
156 }
157 have := map[string]bool{}
158 for _, f := range m.Files {
159 have[f.Path] = true
160 }
161 for _, want := range []string{"state/bluegit.db", "state/secret.key", "data/repos/tim/app.git/HEAD"} {
162 if !have[want] {
163 t.Fatalf("manifest mist %s: %v", want, have)
164 }
165 }
166 code, b = keyed(t, "GET", e.base+"/api/v1/backup/file?path="+url.QueryEscape("data/repos/tim/app.git/HEAD"), k.Key, nil)
167 if code != 200 || string(b) != "ref: refs/heads/master\n" {
168 t.Fatalf("file: %d %q", code, b)
169 }
170 code, b = keyed(t, "GET", e.base+"/api/v1/backup/file?path=state/bluegit.db", k.Key, nil)
171 if code != 200 || !strings.HasPrefix(string(b), "SQLite format 3") {
172 t.Fatalf("db-kopie: %d %.20q", code, b)
173 }
174 for _, bad := range []string{"state/backup.json", "state/storage_path", "../../etc/passwd", "data/repos/../../x"} {
175 if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/file?path="+url.QueryEscape(bad), k.Key, nil); code != 404 {
176 t.Fatalf("%s: %d", bad, code)
177 }
178 }
179 // Intrekken: de key werkt niet meer.
180 if code, _ := rapi(t, e.base, e.tok, "DELETE", "/admin/backup/key", nil); code != 204 {
181 t.Fatalf("revoke: %d", code)
182 }
183 if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/info", k.Key, nil); code != 401 {
184 t.Fatalf("na intrekken: %d", code)
185 }
186 }
187
188 func TestBackupConnectNotifyArchivesRollback(t *testing.T) {
189 e := newBackupEnv(t)
190 fb := newFakeBackup(t)
191 _, b := rapi(t, e.base, e.tok, "POST", "/admin/backup/key", nil)
192 var k struct{ Key string }
193 _ = json.Unmarshal(b, &k)
194 fb.secret = backup.SigningSecret(k.Key)
195 code, b := keyed(t, "POST", e.base+"/api/v1/backup/connect", k.Key, strings.NewReader(`{"server_url":"`+fb.ts.URL+`","server_id":"s1"}`))
196 if code != 200 {
197 t.Fatalf("connect: %d %s", code, b)
198 }
199 if code, _ := keyed(t, "POST", e.base+"/api/v1/backup/connect", k.Key, strings.NewReader(`{"server_url":"ftp://x"}`)); code != 400 {
200 t.Fatalf("ftp-adres: %d", code)
201 }
202
203 // Een schrijvende actie geeft een ondertekende melding.
204 if code, b := rapi(t, e.base, e.tok, "POST", "/projects", map[string]any{"name": "Notify"}); code/100 != 2 {
205 t.Fatalf("project: %d %s", code, b)
206 }
207 deadline := time.Now().Add(5 * time.Second)
208 for {
209 fb.mu.Lock()
210 n := fb.notifies
211 fb.mu.Unlock()
212 if n > 0 {
213 break
214 }
215 if time.Now().After(deadline) {
216 t.Fatal("geen melding ontvangen")
217 }
218 time.Sleep(20 * time.Millisecond)
219 }
220
221 // Archieven via de API en op de beheerpagina, met de waarschuwing.
222 code, b = rapi(t, e.base, e.tok, "GET", "/admin/backup", nil)
223 if code != 200 || !strings.Contains(string(b), "bluegit-20261115-120000.tar.gz") || !strings.Contains(string(b), `"connected":true`) {
224 t.Fatalf("admin backup: %d %s", code, b)
225 }
226 tc, csrf := sessionClient(t, e.st, e.base, e.tim.ID)
227 res, _ := tc.Get(e.base + "/admin/backup")
228 page := body(t, res)
229 for _, want := range []string{"bluegit-20261115-120000.tar.gz", `class="backup-danger"`, `name="understood"`, `name="confirm"`, `href="/admin/backup"`} {
230 if !strings.Contains(page, want) {
231 t.Fatalf("pagina mist %s: %.600s", want, page)
232 }
233 }
234
235 // Rollback: verkeerde bevestiging, dan goed.
236 if code, _ := rapi(t, e.base, e.tok, "POST", "/admin/backup/rollback", map[string]any{"archive": "bluegit-20261115-120000.tar.gz", "confirm": "ja"}); code != 400 {
237 t.Fatalf("verkeerde bevestiging: %d", code)
238 }
239 res, _ = tc.PostForm(e.base+"/admin/backup/rollback", url.Values{"csrf": {csrf}, "archive": {"bluegit-20261115-120000.tar.gz"}, "confirm": {"bluegit-20261115-120000.tar.gz"}})
240 res.Body.Close()
241 fb.mu.Lock()
242 if len(fb.rollback) != 0 {
243 t.Fatal("rollback zonder vinkje")
244 }
245 fb.mu.Unlock()
246 res, _ = tc.PostForm(e.base+"/admin/backup/rollback", url.Values{"csrf": {csrf}, "archive": {"bluegit-20261115-120000.tar.gz"}, "confirm": {"bluegit-20261115-120000.tar.gz"}, "understood": {"1"}})
247 res.Body.Close()
248 if code, b := rapi(t, e.base, e.tok, "POST", "/admin/backup/rollback", map[string]any{"archive": "bluegit-20261115-120000.tar.gz", "confirm": "bluegit-20261115-120000.tar.gz"}); code != 202 {
249 t.Fatalf("rollback api: %d %s", code, b)
250 }
251 fb.mu.Lock()
252 defer fb.mu.Unlock()
253 if len(fb.rollback) != 2 || fb.badSig != 0 {
254 t.Fatalf("rollbacks %v, foute handtekeningen %d", fb.rollback, fb.badSig)
255 }
256 }
257
258 func TestBackupRestoreStagesAndRestarts(t *testing.T) {
259 e := newBackupEnv(t)
260 restarted := make(chan struct{}, 1)
261 e.srv.RequestRestart = func() { restarted <- struct{}{} }
262 _, b := rapi(t, e.base, e.tok, "POST", "/admin/backup/key", nil)
263 var k struct{ Key string }
264 _ = json.Unmarshal(b, &k)
265 // Ongeldig archief: 400, niets klaargezet.
266 if code, _ := keyed(t, "POST", e.base+"/api/v1/backup/restore", k.Key, strings.NewReader("x")); code != 400 {
267 t.Fatalf("ongeldig: %d", code)
268 }
269 if backup.HasPending(e.srv.StateDir) {
270 t.Fatal("READY na fout")
271 }
272 // Een archief uit het eigen manifest terugsturen.
273 tarball := buildTarFromInstance(t, e, k.Key)
274 code, b := keyed(t, "POST", e.base+"/api/v1/backup/restore", k.Key, strings.NewReader(tarball))
275 if code != 202 {
276 t.Fatalf("restore: %d %s", code, b)
277 }
278 select {
279 case <-restarted:
280 case <-time.After(3 * time.Second):
281 t.Fatal("geen herstart")
282 }
283 if !backup.HasPending(e.srv.StateDir) {
284 t.Fatal("geen READY")
285 }
286 restoreBusy.Store(false)
287 }
288
289 func buildTarFromInstance(t *testing.T, e *backupEnv, key string) string {
290 t.Helper()
291 _, b := keyed(t, "GET", e.base+"/api/v1/backup/manifest", key, nil)
292 var m backup.Manifest
293 _ = json.Unmarshal(b, &m)
294 var sb strings.Builder
295 files := map[string]string{}
296 for _, f := range m.Files {
297 _, data := keyed(t, "GET", e.base+"/api/v1/backup/file?path="+url.QueryEscape(f.Path), key, nil)
298 files[f.Path] = string(data)
299 }
300 writeTarGz(t, &sb, files)
301 return sb.String()
302 }
@@ -0,0 +1,302 @@
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 badSig int
85 ts *httptest.Server
86}
87
88func newFakeBackup(t *testing.T) *fakeBackup {
89 f := &fakeBackup{}
90 f.ts = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
91 body, _ := io.ReadAll(r.Body)
92 f.mu.Lock()
93 defer f.mu.Unlock()
94 if err := backup.Verify(r, f.secret, body, time.Now()); err != nil {
95 f.badSig++
96 http.Error(w, `{"error":"sig"}`, 401)
97 return
98 }
99 switch r.URL.Path {
100 case "/api/v1/notify":
101 f.notifies++
102 w.WriteHeader(204)
103 case "/api/v1/archives":
104 _ = 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}}})
105 case "/api/v1/status":
106 _, _ = w.Write([]byte(`{"version":"test","archive_interval":"24h0m0s","retention_days":30,"rollback":{"state":"idle"}}`))
107 case "/api/v1/rollback":
108 var in struct{ Archive string }
109 _ = json.Unmarshal(body, &in)
110 f.rollback = append(f.rollback, in.Archive)
111 w.WriteHeader(202)
112 default:
113 http.NotFound(w, r)
114 }
115 }))
116 t.Cleanup(f.ts.Close)
117 return f
118}
119
120func TestBackupKeyAndKeyedAPI(t *testing.T) {
121 e := newBackupEnv(t)
122 // Zonder key: 401. Met een gewoon toegangstoken: ook 401.
123 if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/manifest", "", nil); code != 401 {
124 t.Fatalf("zonder key: %d", code)
125 }
126 if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/manifest", e.tok, nil); code != 401 {
127 t.Fatalf("bg_-token: %d", code)
128 }
129 // Alleen een beheerder maakt een key.
130 bob, _ := e.st.UpsertUser(context.Background(), 2, "bob", "", false)
131 if code, _ := rapi(t, e.base, issue(t, e.st, bob.ID, "api"), "POST", "/admin/backup/key", nil); code != 403 {
132 t.Fatalf("bob maakt key: %d", code)
133 }
134 code, b := rapi(t, e.base, e.tok, "POST", "/admin/backup/key", nil)
135 if code != 201 {
136 t.Fatalf("key: %d %s", code, b)
137 }
138 var k struct{ Key string }
139 _ = json.Unmarshal(b, &k)
140 if !strings.HasPrefix(k.Key, "bgbk_") {
141 t.Fatalf("key %q", k.Key)
142 }
143 code, b = keyed(t, "GET", e.base+"/api/v1/backup/info", k.Key, nil)
144 var info struct {
145 InstanceID string `json:"instance_id"`
146 }
147 _ = json.Unmarshal(b, &info)
148 if code != 200 || info.InstanceID == "" {
149 t.Fatalf("info: %d %s", code, b)
150 }
151 code, b = keyed(t, "GET", e.base+"/api/v1/backup/manifest", k.Key, nil)
152 var m backup.Manifest
153 _ = json.Unmarshal(b, &m)
154 if code != 200 || m.Instance != info.InstanceID {
155 t.Fatalf("manifest: %d %.300s", code, b)
156 }
157 have := map[string]bool{}
158 for _, f := range m.Files {
159 have[f.Path] = true
160 }
161 for _, want := range []string{"state/bluegit.db", "state/secret.key", "data/repos/tim/app.git/HEAD"} {
162 if !have[want] {
163 t.Fatalf("manifest mist %s: %v", want, have)
164 }
165 }
166 code, b = keyed(t, "GET", e.base+"/api/v1/backup/file?path="+url.QueryEscape("data/repos/tim/app.git/HEAD"), k.Key, nil)
167 if code != 200 || string(b) != "ref: refs/heads/master\n" {
168 t.Fatalf("file: %d %q", code, b)
169 }
170 code, b = keyed(t, "GET", e.base+"/api/v1/backup/file?path=state/bluegit.db", k.Key, nil)
171 if code != 200 || !strings.HasPrefix(string(b), "SQLite format 3") {
172 t.Fatalf("db-kopie: %d %.20q", code, b)
173 }
174 for _, bad := range []string{"state/backup.json", "state/storage_path", "../../etc/passwd", "data/repos/../../x"} {
175 if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/file?path="+url.QueryEscape(bad), k.Key, nil); code != 404 {
176 t.Fatalf("%s: %d", bad, code)
177 }
178 }
179 // Intrekken: de key werkt niet meer.
180 if code, _ := rapi(t, e.base, e.tok, "DELETE", "/admin/backup/key", nil); code != 204 {
181 t.Fatalf("revoke: %d", code)
182 }
183 if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/info", k.Key, nil); code != 401 {
184 t.Fatalf("na intrekken: %d", code)
185 }
186}
187
188func TestBackupConnectNotifyArchivesRollback(t *testing.T) {
189 e := newBackupEnv(t)
190 fb := newFakeBackup(t)
191 _, b := rapi(t, e.base, e.tok, "POST", "/admin/backup/key", nil)
192 var k struct{ Key string }
193 _ = json.Unmarshal(b, &k)
194 fb.secret = backup.SigningSecret(k.Key)
195 code, b := keyed(t, "POST", e.base+"/api/v1/backup/connect", k.Key, strings.NewReader(`{"server_url":"`+fb.ts.URL+`","server_id":"s1"}`))
196 if code != 200 {
197 t.Fatalf("connect: %d %s", code, b)
198 }
199 if code, _ := keyed(t, "POST", e.base+"/api/v1/backup/connect", k.Key, strings.NewReader(`{"server_url":"ftp://x"}`)); code != 400 {
200 t.Fatalf("ftp-adres: %d", code)
201 }
202
203 // Een schrijvende actie geeft een ondertekende melding.
204 if code, b := rapi(t, e.base, e.tok, "POST", "/projects", map[string]any{"name": "Notify"}); code/100 != 2 {
205 t.Fatalf("project: %d %s", code, b)
206 }
207 deadline := time.Now().Add(5 * time.Second)
208 for {
209 fb.mu.Lock()
210 n := fb.notifies
211 fb.mu.Unlock()
212 if n > 0 {
213 break
214 }
215 if time.Now().After(deadline) {
216 t.Fatal("geen melding ontvangen")
217 }
218 time.Sleep(20 * time.Millisecond)
219 }
220
221 // Archieven via de API en op de beheerpagina, met de waarschuwing.
222 code, b = rapi(t, e.base, e.tok, "GET", "/admin/backup", nil)
223 if code != 200 || !strings.Contains(string(b), "bluegit-20261115-120000.tar.gz") || !strings.Contains(string(b), `"connected":true`) {
224 t.Fatalf("admin backup: %d %s", code, b)
225 }
226 tc, csrf := sessionClient(t, e.st, e.base, e.tim.ID)
227 res, _ := tc.Get(e.base + "/admin/backup")
228 page := body(t, res)
229 for _, want := range []string{"bluegit-20261115-120000.tar.gz", `class="backup-danger"`, `name="understood"`, `name="confirm"`, `href="/admin/backup"`} {
230 if !strings.Contains(page, want) {
231 t.Fatalf("pagina mist %s: %.600s", want, page)
232 }
233 }
234
235 // Rollback: verkeerde bevestiging, dan goed.
236 if code, _ := rapi(t, e.base, e.tok, "POST", "/admin/backup/rollback", map[string]any{"archive": "bluegit-20261115-120000.tar.gz", "confirm": "ja"}); code != 400 {
237 t.Fatalf("verkeerde bevestiging: %d", code)
238 }
239 res, _ = tc.PostForm(e.base+"/admin/backup/rollback", url.Values{"csrf": {csrf}, "archive": {"bluegit-20261115-120000.tar.gz"}, "confirm": {"bluegit-20261115-120000.tar.gz"}})
240 res.Body.Close()
241 fb.mu.Lock()
242 if len(fb.rollback) != 0 {
243 t.Fatal("rollback zonder vinkje")
244 }
245 fb.mu.Unlock()
246 res, _ = tc.PostForm(e.base+"/admin/backup/rollback", url.Values{"csrf": {csrf}, "archive": {"bluegit-20261115-120000.tar.gz"}, "confirm": {"bluegit-20261115-120000.tar.gz"}, "understood": {"1"}})
247 res.Body.Close()
248 if code, b := rapi(t, e.base, e.tok, "POST", "/admin/backup/rollback", map[string]any{"archive": "bluegit-20261115-120000.tar.gz", "confirm": "bluegit-20261115-120000.tar.gz"}); code != 202 {
249 t.Fatalf("rollback api: %d %s", code, b)
250 }
251 fb.mu.Lock()
252 defer fb.mu.Unlock()
253 if len(fb.rollback) != 2 || fb.badSig != 0 {
254 t.Fatalf("rollbacks %v, foute handtekeningen %d", fb.rollback, fb.badSig)
255 }
256}
257
258func TestBackupRestoreStagesAndRestarts(t *testing.T) {
259 e := newBackupEnv(t)
260 restarted := make(chan struct{}, 1)
261 e.srv.RequestRestart = func() { restarted <- struct{}{} }
262 _, b := rapi(t, e.base, e.tok, "POST", "/admin/backup/key", nil)
263 var k struct{ Key string }
264 _ = json.Unmarshal(b, &k)
265 // Ongeldig archief: 400, niets klaargezet.
266 if code, _ := keyed(t, "POST", e.base+"/api/v1/backup/restore", k.Key, strings.NewReader("x")); code != 400 {
267 t.Fatalf("ongeldig: %d", code)
268 }
269 if backup.HasPending(e.srv.StateDir) {
270 t.Fatal("READY na fout")
271 }
272 // Een archief uit het eigen manifest terugsturen.
273 tarball := buildTarFromInstance(t, e, k.Key)
274 code, b := keyed(t, "POST", e.base+"/api/v1/backup/restore", k.Key, strings.NewReader(tarball))
275 if code != 202 {
276 t.Fatalf("restore: %d %s", code, b)
277 }
278 select {
279 case <-restarted:
280 case <-time.After(3 * time.Second):
281 t.Fatal("geen herstart")
282 }
283 if !backup.HasPending(e.srv.StateDir) {
284 t.Fatal("geen READY")
285 }
286 restoreBusy.Store(false)
287}
288
289func buildTarFromInstance(t *testing.T, e *backupEnv, key string) string {
290 t.Helper()
291 _, b := keyed(t, "GET", e.base+"/api/v1/backup/manifest", key, nil)
292 var m backup.Manifest
293 _ = json.Unmarshal(b, &m)
294 var sb strings.Builder
295 files := map[string]string{}
296 for _, f := range m.Files {
297 _, data := keyed(t, "GET", e.base+"/api/v1/backup/file?path="+url.QueryEscape(f.Path), key, nil)
298 files[f.Path] = string(data)
299 }
300 writeTarGz(t, &sb, files)
301 return sb.String()
302}
internal/server/events.go +2 −0
@@ -45,6 +45,7 @@ func (s *Server) postReceive(ctx context.Context, repo store.Repo, user store.Us
45 45 // git http, SSH en postReceive zijn de enige aanroepers.
46 46 func (s *Server) AfterPush(repo store.Repo, user store.User, before, after map[string]string) {
47 47 s.refsChanged(repo)
48 s.BackupChanged()
48 49 for ref, sha := range after {
49 50 if b, ok := strings.CutPrefix(ref, "refs/heads/"); ok && before[ref] != sha && !isZero(sha) && s.Store != nil {
50 51 s.refreshForkMRs(repo, user, b)
@@ -234,6 +235,7 @@ func changedFiles(ctx context.Context, gitBin, dir, sha, before string, all []st
234 235 }
235 236
236 237 func (s *Server) Dispatch(repoID int64, ev webhook.Event) {
238 s.BackupChanged()
237 239 ctx := context.Background()
238 240 repo, err := s.Store.RepoByID(ctx, repoID)
239 241 if err != nil {
@@ -45,6 +45,7 @@ func (s *Server) postReceive(ctx context.Context, repo store.Repo, user store.Us
45// git http, SSH en postReceive zijn de enige aanroepers.
45// git http, SSH en postReceive zijn de enige aanroepers.
46func (s *Server) AfterPush(repo store.Repo, user store.User, before, after map[string]string) {
46func (s *Server) AfterPush(repo store.Repo, user store.User, before, after map[string]string) {
47 s.refsChanged(repo)
47 s.refsChanged(repo)
48 s.BackupChanged()
48 for ref, sha := range after {
49 for ref, sha := range after {
49 if b, ok := strings.CutPrefix(ref, "refs/heads/"); ok && before[ref] != sha && !isZero(sha) && s.Store != nil {
50 if b, ok := strings.CutPrefix(ref, "refs/heads/"); ok && before[ref] != sha && !isZero(sha) && s.Store != nil {
50 s.refreshForkMRs(repo, user, b)
51 s.refreshForkMRs(repo, user, b)
@@ -234,6 +235,7 @@ func changedFiles(ctx context.Context, gitBin, dir, sha, before string, all []st
234}
235}
235
236
236func (s *Server) Dispatch(repoID int64, ev webhook.Event) {
237func (s *Server) Dispatch(repoID int64, ev webhook.Event) {
238 s.BackupChanged()
237 ctx := context.Background()
239 ctx := context.Background()
238 repo, err := s.Store.RepoByID(ctx, repoID)
240 repo, err := s.Store.RepoByID(ctx, repoID)
239 if err != nil {
241 if err != nil {
internal/server/server.go +14 −1
@@ -23,6 +23,7 @@ import (
23 23 "gitlab.com/Timfa/bluegit/internal/access"
24 24 "gitlab.com/Timfa/bluegit/internal/activity"
25 25 "gitlab.com/Timfa/bluegit/internal/auth"
26 "gitlab.com/Timfa/bluegit/internal/backup"
26 27 "gitlab.com/Timfa/bluegit/internal/card"
27 28 "gitlab.com/Timfa/bluegit/internal/cispec"
28 29 "gitlab.com/Timfa/bluegit/internal/config"
@@ -77,6 +78,15 @@ type Server struct {
77 78 graphCache *gitgraph.Cache
78 79
79 80 gitMaint gitMaintState
81
82 // RequestRestart herstart het proces (main: opnieuw exec'en). Nodig na
83 // het uitpakken van een backup. Nil: alleen bij de volgende start.
84 RequestRestart func()
85 backupOnce sync.Once
86 backupMgr *backup.Manager
87 backupNote *backup.Notifier
88 backupHTTP *http.Client
89 restoring sync.Mutex
80 90 }
81 91
82 92 type principal struct {
@@ -269,7 +279,8 @@ func (s *Server) Handler() http.Handler {
269 279 mux.HandleFunc("POST /{owner}/{repo}/-/webhooks/copy", s.repoWebhookCopy)
270 280 mux.HandleFunc("POST /{owner}/{repo}/-/delete", s.deleteRepo)
271 281
272 return s.realIP(s.withSession(s.secure(s.gate(mux))))
282 s.mountBackup(mux)
283 return s.realIP(s.withSession(s.secure(s.backupWatch(s.gate(mux)))))
273 284 }
274 285
275 286 func (s *Server) realIP(next http.Handler) http.Handler {
@@ -333,6 +344,7 @@ func (s *Server) mustTemplates() {
333 344 return label
334 345 },
335 346 "printf": fmt.Sprintf,
347 "mb": func(n int64) float64 { return float64(n) / (1 << 20) },
336 348 "dict": func(kv ...any) (map[string]any, error) {
337 349 if len(kv)%2 != 0 {
338 350 return nil, fmt.Errorf("dict")
@@ -601,6 +613,7 @@ func randomState() (string, error) {
601 613
602 614 // View is de gegevensset voor elk scherm.
603 615 type View struct {
616 Backup *BackupView
604 617 RunnerList []RunnerView
605 618 RunnerPref string
606 619 NewRunnerToken string
@@ -23,6 +23,7 @@ import (
23 "gitlab.com/Timfa/bluegit/internal/access"
23 "gitlab.com/Timfa/bluegit/internal/access"
24 "gitlab.com/Timfa/bluegit/internal/activity"
24 "gitlab.com/Timfa/bluegit/internal/activity"
25 "gitlab.com/Timfa/bluegit/internal/auth"
25 "gitlab.com/Timfa/bluegit/internal/auth"
26 "gitlab.com/Timfa/bluegit/internal/backup"
26 "gitlab.com/Timfa/bluegit/internal/card"
27 "gitlab.com/Timfa/bluegit/internal/card"
27 "gitlab.com/Timfa/bluegit/internal/cispec"
28 "gitlab.com/Timfa/bluegit/internal/cispec"
28 "gitlab.com/Timfa/bluegit/internal/config"
29 "gitlab.com/Timfa/bluegit/internal/config"
@@ -77,6 +78,15 @@ type Server struct {
77 graphCache *gitgraph.Cache
78 graphCache *gitgraph.Cache
78
79
79 gitMaint gitMaintState
80 gitMaint gitMaintState
81
82 // RequestRestart herstart het proces (main: opnieuw exec'en). Nodig na
83 // het uitpakken van een backup. Nil: alleen bij de volgende start.
84 RequestRestart func()
85 backupOnce sync.Once
86 backupMgr *backup.Manager
87 backupNote *backup.Notifier
88 backupHTTP *http.Client
89 restoring sync.Mutex
80}
90}
81
91
82type principal struct {
92type principal struct {
@@ -269,7 +279,8 @@ func (s *Server) Handler() http.Handler {
269 mux.HandleFunc("POST /{owner}/{repo}/-/webhooks/copy", s.repoWebhookCopy)
279 mux.HandleFunc("POST /{owner}/{repo}/-/webhooks/copy", s.repoWebhookCopy)
270 mux.HandleFunc("POST /{owner}/{repo}/-/delete", s.deleteRepo)
280 mux.HandleFunc("POST /{owner}/{repo}/-/delete", s.deleteRepo)
271
281
272 return s.realIP(s.withSession(s.secure(s.gate(mux))))
282 s.mountBackup(mux)
283 return s.realIP(s.withSession(s.secure(s.backupWatch(s.gate(mux)))))
273}
284}
274
285
275func (s *Server) realIP(next http.Handler) http.Handler {
286func (s *Server) realIP(next http.Handler) http.Handler {
@@ -333,6 +344,7 @@ func (s *Server) mustTemplates() {
333 return label
344 return label
334 },
345 },
335 "printf": fmt.Sprintf,
346 "printf": fmt.Sprintf,
347 "mb": func(n int64) float64 { return float64(n) / (1 << 20) },
336 "dict": func(kv ...any) (map[string]any, error) {
348 "dict": func(kv ...any) (map[string]any, error) {
337 if len(kv)%2 != 0 {
349 if len(kv)%2 != 0 {
338 return nil, fmt.Errorf("dict")
350 return nil, fmt.Errorf("dict")
@@ -601,6 +613,7 @@ func randomState() (string, error) {
601
613
602// View is de gegevensset voor elk scherm.
614// View is de gegevensset voor elk scherm.
603type View struct {
615type View struct {
616 Backup *BackupView
604 RunnerList []RunnerView
617 RunnerList []RunnerView
605 RunnerPref string
618 RunnerPref string
606 NewRunnerToken string
619 NewRunnerToken string
internal/server/static/style.css +11 −0
@@ -1874,3 +1874,14 @@ span.starbtn {
1874 1874 }
1875 1875 span.starbtn.btn { border: 1px solid var(--line); border-radius: var(--radius); color: var(--ink); }
1876 1876 span.starbtn.starred { color: #9a6700; }
1877
1878 /* Beheer > Backup: de waarschuwing bij rollback moet niet te missen zijn. */
1879 .backup-danger {
1880 border: 2px solid #cf222e; background: #ffebe9; color: #82071e;
1881 border-radius: 6px; padding: 12px 16px; margin: 0 0 16px;
1882 }
1883 .backup-danger strong { font-size: 1.15em; }
1884 .backup-danger-text { color: #82071e; font-weight: 600; max-width: 32em; }
1885 .backup-rollback form { display: grid; gap: 8px; margin-top: 8px; }
1886 .backup-rollback summary { cursor: pointer; }
1887 .backup-key { word-break: break-all; }
@@ -1874,3 +1874,14 @@ span.starbtn {
1874}
1874}
1875span.starbtn.btn { border: 1px solid var(--line); border-radius: var(--radius); color: var(--ink); }
1875span.starbtn.btn { border: 1px solid var(--line); border-radius: var(--radius); color: var(--ink); }
1876span.starbtn.starred { color: #9a6700; }
1876span.starbtn.starred { color: #9a6700; }
1877
1878/* Beheer > Backup: de waarschuwing bij rollback moet niet te missen zijn. */
1879.backup-danger {
1880 border: 2px solid #cf222e; background: #ffebe9; color: #82071e;
1881 border-radius: 6px; padding: 12px 16px; margin: 0 0 16px;
1882}
1883.backup-danger strong { font-size: 1.15em; }
1884.backup-danger-text { color: #82071e; font-weight: 600; max-width: 32em; }
1885.backup-rollback form { display: grid; gap: 8px; margin-top: 8px; }
1886.backup-rollback summary { cursor: pointer; }
1887.backup-key { word-break: break-all; }
internal/server/templates/backup.html added +79 −0
@@ -0,0 +1,79 @@
1 {{define "adminbackup"}}
2 {{template "layout-start" .}}
3 <h1>{{t "backup.title"}}</h1>
4 <p class="muted">{{t "backup.lead"}}</p>
5 {{with .Backup}}
6 <section class="panel" id="backup-key">
7 <h2>{{t "backup.key.title"}}</h2>
8 {{if .NewKey}}
9 <p><strong>{{t "backup.key.once"}}</strong></p>
10 <p class="code backup-key">{{.NewKey}}</p>
11 {{end}}
12 {{if .Conn.HasKey}}
13 <p>{{t "backup.key.active" .Conn.KeyHint}} <span class="muted">{{t "backup.key.by" .Conn.CreatedBy}} · {{date .Conn.CreatedAt}}</span></p>
14 {{else}}
15 <p class="muted">{{t "backup.key.none"}}</p>
16 {{end}}
17 <form method="post" action="/admin/backup/key"{{if .Conn.HasKey}} data-confirm="{{t "backup.key.replaceAsk"}}"{{end}}>
18 <input type="hidden" name="csrf" value="{{$.CSRF}}">
19 <button type="submit">{{if .Conn.HasKey}}{{t "backup.key.replace"}}{{else}}{{t "backup.key.new"}}{{end}}</button>
20 </form>
21 {{if .Conn.HasKey}}
22 <form method="post" action="/admin/backup/revoke" data-confirm="{{t "backup.key.revokeAsk"}}">
23 <input type="hidden" name="csrf" value="{{$.CSRF}}">
24 <button type="submit" class="danger">{{t "backup.key.revoke"}}</button>
25 </form>
26 {{end}}
27 <p class="muted">{{t "backup.instance" .InstanceID}}</p>
28 </section>
29
30 <section class="panel" id="backup-server">
31 <h2>{{t "backup.server.title"}}</h2>
32 {{if .Conn.Connected}}
33 <p>{{t "backup.server.connected" .Conn.ServerURL}} <span class="muted">{{t "backup.server.seen"}} {{date .Conn.LastSeen}}</span></p>
34 {{with .Remote}}<p class="muted">{{t "backup.server.settings" .Interval .RetentionDays}}{{if .Rollback.State}} · {{t "backup.server.rollback" .Rollback.State .Rollback.Archive}}{{end}}</p>{{end}}
35 {{if .RemoteErr}}<p class="backup-danger-text">{{t "backup.server.unreachable" .RemoteErr}}</p>{{end}}
36 {{else}}
37 <p class="muted">{{t "backup.server.none"}}</p>
38 {{end}}
39 </section>
40
41 {{if .Conn.Connected}}
42 <section class="panel" id="backup-archives">
43 <h2>{{t "backup.archives.title"}}</h2>
44 {{if .Archives}}
45 <div class="backup-danger" role="alert">
46 <strong>{{t "backup.warn.title"}}</strong>
47 <p>{{t "backup.warn.body"}}</p>
48 </div>
49 <div class="hscroll">
50 <table class="rui-table backup-archives">
51 <thead><tr><th>{{t "backup.col.archive"}}</th><th>{{t "backup.col.created"}}</th><th>{{t "backup.col.size"}}</th><th></th></tr></thead>
52 <tbody>
53 {{range .Archives}}<tr>
54 <td><code>{{.Name}}</code></td>
55 <td>{{date .CreatedAt}}</td>
56 <td>{{printf "%.1f MB" (mb .Size)}}</td>
57 <td class="act">
58 <details class="backup-rollback">
59 <summary class="danger">{{t "backup.rollback"}}</summary>
60 <form method="post" action="/admin/backup/rollback" data-confirm="{{t "backup.rollbackAsk" .Name}}">
61 <input type="hidden" name="csrf" value="{{$.CSRF}}">
62 <input type="hidden" name="archive" value="{{.Name}}">
63 <p class="backup-danger-text">{{t "backup.warn.body"}}</p>
64 <label><input type="checkbox" name="understood" value="1" required> {{t "backup.understood"}}</label>
65 <label>{{t "backup.typeName"}} <input type="text" name="confirm" required autocomplete="off" placeholder="{{.Name}}"></label>
66 <button type="submit" class="danger">{{t "backup.rollbackNow"}}</button>
67 </form>
68 </details>
69 </td>
70 </tr>{{end}}
71 </tbody>
72 </table>
73 </div>
74 {{else}}<p class="muted">{{t "backup.archives.none"}}</p>{{end}}
75 </section>
76 {{end}}
77 {{end}}
78 {{template "layout-end" .}}
79 {{end}}
@@ -0,0 +1,79 @@
1{{define "adminbackup"}}
2{{template "layout-start" .}}
3<h1>{{t "backup.title"}}</h1>
4<p class="muted">{{t "backup.lead"}}</p>
5{{with .Backup}}
6<section class="panel" id="backup-key">
7 <h2>{{t "backup.key.title"}}</h2>
8 {{if .NewKey}}
9 <p><strong>{{t "backup.key.once"}}</strong></p>
10 <p class="code backup-key">{{.NewKey}}</p>
11 {{end}}
12 {{if .Conn.HasKey}}
13 <p>{{t "backup.key.active" .Conn.KeyHint}} <span class="muted">{{t "backup.key.by" .Conn.CreatedBy}} · {{date .Conn.CreatedAt}}</span></p>
14 {{else}}
15 <p class="muted">{{t "backup.key.none"}}</p>
16 {{end}}
17 <form method="post" action="/admin/backup/key"{{if .Conn.HasKey}} data-confirm="{{t "backup.key.replaceAsk"}}"{{end}}>
18 <input type="hidden" name="csrf" value="{{$.CSRF}}">
19 <button type="submit">{{if .Conn.HasKey}}{{t "backup.key.replace"}}{{else}}{{t "backup.key.new"}}{{end}}</button>
20 </form>
21 {{if .Conn.HasKey}}
22 <form method="post" action="/admin/backup/revoke" data-confirm="{{t "backup.key.revokeAsk"}}">
23 <input type="hidden" name="csrf" value="{{$.CSRF}}">
24 <button type="submit" class="danger">{{t "backup.key.revoke"}}</button>
25 </form>
26 {{end}}
27 <p class="muted">{{t "backup.instance" .InstanceID}}</p>
28</section>
29
30<section class="panel" id="backup-server">
31 <h2>{{t "backup.server.title"}}</h2>
32 {{if .Conn.Connected}}
33 <p>{{t "backup.server.connected" .Conn.ServerURL}} <span class="muted">{{t "backup.server.seen"}} {{date .Conn.LastSeen}}</span></p>
34 {{with .Remote}}<p class="muted">{{t "backup.server.settings" .Interval .RetentionDays}}{{if .Rollback.State}} · {{t "backup.server.rollback" .Rollback.State .Rollback.Archive}}{{end}}</p>{{end}}
35 {{if .RemoteErr}}<p class="backup-danger-text">{{t "backup.server.unreachable" .RemoteErr}}</p>{{end}}
36 {{else}}
37 <p class="muted">{{t "backup.server.none"}}</p>
38 {{end}}
39</section>
40
41{{if .Conn.Connected}}
42<section class="panel" id="backup-archives">
43 <h2>{{t "backup.archives.title"}}</h2>
44 {{if .Archives}}
45 <div class="backup-danger" role="alert">
46 <strong>{{t "backup.warn.title"}}</strong>
47 <p>{{t "backup.warn.body"}}</p>
48 </div>
49 <div class="hscroll">
50 <table class="rui-table backup-archives">
51 <thead><tr><th>{{t "backup.col.archive"}}</th><th>{{t "backup.col.created"}}</th><th>{{t "backup.col.size"}}</th><th></th></tr></thead>
52 <tbody>
53 {{range .Archives}}<tr>
54 <td><code>{{.Name}}</code></td>
55 <td>{{date .CreatedAt}}</td>
56 <td>{{printf "%.1f MB" (mb .Size)}}</td>
57 <td class="act">
58 <details class="backup-rollback">
59 <summary class="danger">{{t "backup.rollback"}}</summary>
60 <form method="post" action="/admin/backup/rollback" data-confirm="{{t "backup.rollbackAsk" .Name}}">
61 <input type="hidden" name="csrf" value="{{$.CSRF}}">
62 <input type="hidden" name="archive" value="{{.Name}}">
63 <p class="backup-danger-text">{{t "backup.warn.body"}}</p>
64 <label><input type="checkbox" name="understood" value="1" required> {{t "backup.understood"}}</label>
65 <label>{{t "backup.typeName"}} <input type="text" name="confirm" required autocomplete="off" placeholder="{{.Name}}"></label>
66 <button type="submit" class="danger">{{t "backup.rollbackNow"}}</button>
67 </form>
68 </details>
69 </td>
70 </tr>{{end}}
71 </tbody>
72 </table>
73 </div>
74 {{else}}<p class="muted">{{t "backup.archives.none"}}</p>{{end}}
75</section>
76{{end}}
77{{end}}
78{{template "layout-end" .}}
79{{end}}
internal/store/store.go +7 −0
@@ -1063,3 +1063,10 @@ func (s *Store) encrypt(plain string) (nonce, ct []byte, err error) {
1063 1063 func (s *Store) decrypt(nonce, ct []byte) (string, error) {
1064 1064 return secretbox.Decrypt(s.key, nonce, ct)
1065 1065 }
1066
1067 // Snapshot schrijft een consistente kopie van de database naar dst
1068 // (VACUUM INTO). dst mag nog niet bestaan. Gebruikt door de backup server.
1069 func (s *Store) Snapshot(ctx context.Context, dst string) error {
1070 _, err := s.db.ExecContext(ctx, `VACUUM INTO ?`, dst)
1071 return err
1072 }
@@ -1063,3 +1063,10 @@ func (s *Store) encrypt(plain string) (nonce, ct []byte, err error) {
1063func (s *Store) decrypt(nonce, ct []byte) (string, error) {
1063func (s *Store) decrypt(nonce, ct []byte) (string, error) {
1064 return secretbox.Decrypt(s.key, nonce, ct)
1064 return secretbox.Decrypt(s.key, nonce, ct)
1065}
1065}
1066
1067// Snapshot schrijft een consistente kopie van de database naar dst
1068// (VACUUM INTO). dst mag nog niet bestaan. Gebruikt door de backup server.
1069func (s *Store) Snapshot(ctx context.Context, dst string) error {
1070 _, err := s.db.ExecContext(ctx, `VACUUM INTO ?`, dst)
1071 return err
1072}