BlueGit

timfa bluegit

Merge branch 'stage' into master

timfa Grok Bot · pushed by timfa

Authored 2026-11-15 · 2 days ago

Hash
123a4895a1153a8d12a3ed9a3a78b6d03ec70627
Pipeline
Passed
20 files changed +3306 −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 - Een of meer losse backup servers ([bluegit-backup](https://git.timfalken.com/timfa/bluegit-backup)) onder Beheer > Backup: per server een Backupserver-Key, een melding na elke wijziging, de archieflijst, een rollback met waarschuwing en de bediening en instellingen van de backup server zelf. 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 losse backup servers (bluegit-backup): Backupserver-Keys, meldingen, archieven, rollback en bediening vanuit BlueGit.
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- Een of meer losse backup servers ([bluegit-backup](https://git.timfalken.com/timfa/bluegit-backup)) onder Beheer > Backup: per server een Backupserver-Key, een melding na elke wijziging, de archieflijst, een rollback met waarschuwing en de bediening en instellingen van de backup server zelf. 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 losse backup servers (bluegit-backup): Backupserver-Keys, meldingen, archieven, rollback en bediening vanuit BlueGit.
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 +82 −0
@@ -0,0 +1,82 @@
1 # Backup servers (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 Eén BlueGit kan meerdere backup servers hebben (hoogstens 16), elk met een eigen Backupserver-Key. Een backup server hoort bij één BlueGit.
6
7 ## In BlueGit
8
9 **Beheer > Backup** (`/admin/backup`, alleen installatiebeheerders) toont de lijst met backup servers: naam, gekoppeld of wachtend op de key, adres en laatste contact. **Backup server toevoegen** maakt een nieuwe server met een eigen key, die één keer wordt getoond.
10
11 Per backup server (`/admin/backup/s/<id>`) staat dezelfde bediening als in de webinterface van de backup server zelf:
12
13 - **Status**: laatste sync en het resultaat ervan, aantal syncs en meldingen, grootte van de kopie, archieven, de laatste rollback en de versie. Met de knoppen *Nu synchroniseren*, *Nu archiveren* en *Nu opruimen*.
14 - **Instellingen** van de backup server: archiefinterval, bewaartermijn, minimale vrije ruimte, downloadsnelheid, syncintervallen, publiek adres en luisteradres. BlueGit krijgt de velden van de backup server en toont ze zoals ze daar staan.
15 - **Backup-archieven** met *Verwijderen* en *Rollback*. Een rollback 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.
16 - **Backupserver-Key** vervangen (de oude key werkt meteen niet meer; de server moet opnieuw koppelen), de server hernoemen, of key intrekken en de server verwijderen. Bij verwijderen vraagt BlueGit de backup server eerst om te ontkoppelen. De archieven blijven op de backup server staan.
17
18 BlueGit kent de acties niet vooraf. Het vraagt ze op bij de backup server (`GET /api/v1/admin/actions`) en stuurt ze ondertekend door. Alles wat de backup server voor BlueGit openzet, kan dus ook hier. Koppelen en een archief downloaden kan alleen op de backup server zelf.
19
20 Dezelfde acties via de API (token van een beheerder, scope `api`/`admin`):
21
22 | | |
23 |---|---|
24 | `GET /api/v1/admin/backup` | `instance_id` en de lijst met backup servers |
25 | `POST /api/v1/admin/backup/servers` | `{"name"}`: nieuwe backup server; het antwoord bevat eenmalig `key` |
26 | `GET /api/v1/admin/backup/servers/{id}` | server met `remote` (status), `archives` en `config`, zoals de backup server ze meldt |
27 | `PUT /api/v1/admin/backup/servers/{id}` | `{"name"}`: hernoemen |
28 | `POST /api/v1/admin/backup/servers/{id}/key` | nieuwe key (eenmalig in het antwoord) |
29 | `DELETE /api/v1/admin/backup/servers/{id}` | ontkoppelen en vergeten |
30 | `POST /api/v1/admin/backup/servers/{id}/actions/{name}` | actie van de backup server, bijvoorbeeld `config.update` met `{"retention_days": "14"}`, `sync`, `archive`, `prune`, `archive.delete` met `{"name"}`, of `rollback` met `{"archive": "naam", "confirm": "naam"}` |
31
32 Het antwoord van een actie is het antwoord van de backup server, met dezelfde statuscode.
33
34 ## Protocol
35
36 **De backup server praat met BlueGit** met de key als bearer-token (`Authorization: Bearer bgbk_…`):
37
38 | | |
39 |---|---|
40 | `GET /api/v1/backup/info` | `instance_id`, `base_url`, naam en adres van de server bij deze key |
41 | `POST /api/v1/backup/connect` | `{"server_url", "server_id"}`: waar BlueGit meldingen heen stuurt |
42 | `GET /api/v1/backup/manifest` | alle bestanden: pad, grootte, mtime, mode; de database ook met sha256 |
43 | `GET /api/v1/backup/file?path=…` | één bestand |
44 | `POST /api/v1/backup/restore` | tar.gz met logische paden; BlueGit pakt uit en herstart (202) |
45
46 Vijf mislukte key-pogingen per minuut per IP geven daarna `429`.
47
48 **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:
49
50 ```text
51 X-BlueGit-Instance: <instance_id>
52 X-BlueGit-Timestamp: <unix-seconden> (hoogstens 5 minuten verschil)
53 X-BlueGit-Signature: hex(HMAC-SHA256(geheim, METHOD "\n" PAD "\n" TS "\n" sha256hex(body)))
54 ```
55
56 | | |
57 |---|---|
58 | `POST /api/v1/notify` | er is iets veranderd |
59 | `GET /api/v1/archives` | `{"archives": [{name, created_at, size}]}` |
60 | `GET /api/v1/status` | interval, bewaartermijn, stand van de laatste rollback |
61 | `POST /api/v1/rollback` | `{"archive": "naam"}` |
62 | `* /api/v1/admin/…` | de beheeracties van de backup server (lijst: `GET /api/v1/admin/actions`, veld `bluegit: true`) |
63
64 **Meldingen.** Elke gekoppelde backup server krijgt ze, ondertekend met zijn eigen key. 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.
65
66 ## Wat er in een backup zit
67
68 ```text
69 state/bluegit.db consistente kopie (VACUUM INTO), niet het live bestand
70 state/secret.key nodig voor de versleutelde geheimen in de database
71 state/ssh/… SSH-hostkey
72 state/logos/…, state/avatars/…
73 data/repos/… bare repositories
74 data/releases/… release-assets (zonder .incoming)
75 data/artifacts/… CI-artifacts
76 ```
77
78 Niet mee: `config.yml`, `storage_path`, `cache.json`, `backup.json` en `instance_id` (horen bij deze installatie), `data/work`, `*.lock` en symlinks. Elke backup server krijgt bij `GET /api/v1/backup/manifest` een eigen databasekopie (`<state>/.backup/snapshot-<id>.db`); kopieën worden één voor één gemaakt, zodat twee servers die tegelijk synchroniseren elkaars kopie niet vervangen. Verwijderen van een server ruimt zijn kopie op. De koppelingen staan in `<state>/backup.json` (0600, per server alleen de hash van de key) en niet in de database, zodat een rollback naar een oud archief de koppeling niet terugdraait.
79
80 ## Terugzetten
81
82 `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,82 @@
1# Backup servers (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
5Eén BlueGit kan meerdere backup servers hebben (hoogstens 16), elk met een eigen Backupserver-Key. Een backup server hoort bij één BlueGit.
6
7## In BlueGit
8
9**Beheer > Backup** (`/admin/backup`, alleen installatiebeheerders) toont de lijst met backup servers: naam, gekoppeld of wachtend op de key, adres en laatste contact. **Backup server toevoegen** maakt een nieuwe server met een eigen key, die één keer wordt getoond.
10
11Per backup server (`/admin/backup/s/<id>`) staat dezelfde bediening als in de webinterface van de backup server zelf:
12
13- **Status**: laatste sync en het resultaat ervan, aantal syncs en meldingen, grootte van de kopie, archieven, de laatste rollback en de versie. Met de knoppen *Nu synchroniseren*, *Nu archiveren* en *Nu opruimen*.
14- **Instellingen** van de backup server: archiefinterval, bewaartermijn, minimale vrije ruimte, downloadsnelheid, syncintervallen, publiek adres en luisteradres. BlueGit krijgt de velden van de backup server en toont ze zoals ze daar staan.
15- **Backup-archieven** met *Verwijderen* en *Rollback*. Een rollback 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.
16- **Backupserver-Key** vervangen (de oude key werkt meteen niet meer; de server moet opnieuw koppelen), de server hernoemen, of key intrekken en de server verwijderen. Bij verwijderen vraagt BlueGit de backup server eerst om te ontkoppelen. De archieven blijven op de backup server staan.
17
18BlueGit kent de acties niet vooraf. Het vraagt ze op bij de backup server (`GET /api/v1/admin/actions`) en stuurt ze ondertekend door. Alles wat de backup server voor BlueGit openzet, kan dus ook hier. Koppelen en een archief downloaden kan alleen op de backup server zelf.
19
20Dezelfde acties via de API (token van een beheerder, scope `api`/`admin`):
21
22| | |
23|---|---|
24| `GET /api/v1/admin/backup` | `instance_id` en de lijst met backup servers |
25| `POST /api/v1/admin/backup/servers` | `{"name"}`: nieuwe backup server; het antwoord bevat eenmalig `key` |
26| `GET /api/v1/admin/backup/servers/{id}` | server met `remote` (status), `archives` en `config`, zoals de backup server ze meldt |
27| `PUT /api/v1/admin/backup/servers/{id}` | `{"name"}`: hernoemen |
28| `POST /api/v1/admin/backup/servers/{id}/key` | nieuwe key (eenmalig in het antwoord) |
29| `DELETE /api/v1/admin/backup/servers/{id}` | ontkoppelen en vergeten |
30| `POST /api/v1/admin/backup/servers/{id}/actions/{name}` | actie van de backup server, bijvoorbeeld `config.update` met `{"retention_days": "14"}`, `sync`, `archive`, `prune`, `archive.delete` met `{"name"}`, of `rollback` met `{"archive": "naam", "confirm": "naam"}` |
31
32Het antwoord van een actie is het antwoord van de backup server, met dezelfde statuscode.
33
34## Protocol
35
36**De backup server praat met BlueGit** met de key als bearer-token (`Authorization: Bearer bgbk_…`):
37
38| | |
39|---|---|
40| `GET /api/v1/backup/info` | `instance_id`, `base_url`, naam en adres van de server bij deze key |
41| `POST /api/v1/backup/connect` | `{"server_url", "server_id"}`: waar BlueGit meldingen heen stuurt |
42| `GET /api/v1/backup/manifest` | alle bestanden: pad, grootte, mtime, mode; de database ook met sha256 |
43| `GET /api/v1/backup/file?path=…` | één bestand |
44| `POST /api/v1/backup/restore` | tar.gz met logische paden; BlueGit pakt uit en herstart (202) |
45
46Vijf mislukte key-pogingen per minuut per IP geven daarna `429`.
47
48**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:
49
50```text
51X-BlueGit-Instance: <instance_id>
52X-BlueGit-Timestamp: <unix-seconden> (hoogstens 5 minuten verschil)
53X-BlueGit-Signature: hex(HMAC-SHA256(geheim, METHOD "\n" PAD "\n" TS "\n" sha256hex(body)))
54```
55
56| | |
57|---|---|
58| `POST /api/v1/notify` | er is iets veranderd |
59| `GET /api/v1/archives` | `{"archives": [{name, created_at, size}]}` |
60| `GET /api/v1/status` | interval, bewaartermijn, stand van de laatste rollback |
61| `POST /api/v1/rollback` | `{"archive": "naam"}` |
62| `* /api/v1/admin/…` | de beheeracties van de backup server (lijst: `GET /api/v1/admin/actions`, veld `bluegit: true`) |
63
64**Meldingen.** Elke gekoppelde backup server krijgt ze, ondertekend met zijn eigen key. 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.
65
66## Wat er in een backup zit
67
68```text
69state/bluegit.db consistente kopie (VACUUM INTO), niet het live bestand
70state/secret.key nodig voor de versleutelde geheimen in de database
71state/ssh/… SSH-hostkey
72state/logos/…, state/avatars/…
73data/repos/… bare repositories
74data/releases/… release-assets (zonder .incoming)
75data/artifacts/… CI-artifacts
76```
77
78Niet mee: `config.yml`, `storage_path`, `cache.json`, `backup.json` en `instance_id` (horen bij deze installatie), `data/work`, `*.lock` en symlinks. Elke backup server krijgt bij `GET /api/v1/backup/manifest` een eigen databasekopie (`<state>/.backup/snapshot-<id>.db`); kopieën worden één voor één gemaakt, zodat twee servers die tegelijk synchroniseren elkaars kopie niet vervangen. Verwijderen van een server ruimt zijn kopie op. De koppelingen staan in `<state>/backup.json` (0600, per server alleen de hash van de key) en niet in de database, zodat een rollback naar een oud archief de koppeling niet terugdraait.
79
80## Terugzetten
81
82`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 Losse backup servers (bluegit-backup) voeg je toe onder **Beheer > Backup**, elk met een eigen Backupserver-Key. Per server staan daar de status, de instellingen, 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
67Losse backup servers (bluegit-backup) voeg je toe onder **Beheer > Backup**, elk met een eigen Backupserver-Key. Per server staan daar de status, de instellingen, de archieven en de rollback. Zie [BACKUP.md](BACKUP.md).
internal/backup/backup_test.go added +401 −0
@@ -0,0 +1,401 @@
1 package backup
2
3 import (
4 "archive/tar"
5 "bytes"
6 "compress/gzip"
7 "crypto/sha256"
8 "encoding/hex"
9 "errors"
10 "fmt"
11 "net/http"
12 "os"
13 "path/filepath"
14 "strings"
15 "sync"
16 "testing"
17 "time"
18 )
19
20 func TestSignVerify(t *testing.T) {
21 sec := SigningSecret("bgbk_x")
22 now := time.Unix(1_800_000_000, 0)
23 body := []byte(`{"archive":"a"}`)
24 req, _ := http.NewRequest("POST", "http://b/api/v1/rollback", bytes.NewReader(body))
25 Sign(req, sec, "inst", body, now)
26 if err := Verify(req, sec, body, now.Add(time.Minute)); err != nil {
27 t.Fatal(err)
28 }
29 if Verify(req, sec, []byte(`{"archive":"b"}`), now) == nil {
30 t.Fatal("andere body geaccepteerd")
31 }
32 if Verify(req, SigningSecret("bgbk_y"), body, now) == nil {
33 t.Fatal("ander geheim geaccepteerd")
34 }
35 if Verify(req, sec, body, now.Add(10*time.Minute)) == nil {
36 t.Fatal("oude timestamp geaccepteerd")
37 }
38 req.URL.Path = "/api/v1/notify"
39 if Verify(req, sec, body, now) == nil {
40 t.Fatal("ander pad geaccepteerd")
41 }
42 }
43
44 func TestKeyLifecycle(t *testing.T) {
45 m := &Manager{Dir: t.TempDir()}
46 if _, ok := m.Check("bgbk_nope"); ok {
47 t.Fatal("check zonder key")
48 }
49 key, c, err := m.Add(" nas kelder ", "tim")
50 if err != nil || !strings.HasPrefix(key, KeyPrefix) || c.KeyHash == "" || c.Name != "nas kelder" || c.ID == "" {
51 t.Fatal(key, c, err)
52 }
53 raw, _ := os.ReadFile(filepath.Join(m.Dir, "backup.json"))
54 if strings.Contains(string(raw), key) {
55 t.Fatal("key staat leesbaar op schijf")
56 }
57 fi, _ := os.Stat(filepath.Join(m.Dir, "backup.json"))
58 if fi.Mode().Perm() != 0o600 {
59 t.Fatalf("mode %v", fi.Mode())
60 }
61 if got, ok := m.Check(key); !ok || got.ID != c.ID {
62 t.Fatal("eigen key geweigerd")
63 }
64 if _, err := m.Connect(c.ID, "http://backup:9000/", "srv1"); err != nil {
65 t.Fatal(err)
66 }
67 c, _ = m.Get(c.ID)
68 if !c.Connected() || c.ServerURL != "http://backup:9000" || c.SignSecret != SigningSecret(key) {
69 t.Fatalf("%+v", c)
70 }
71 // Een tweede backup server met een eigen key; de eerste blijft werken.
72 keyB, b, err := m.Add("offsite", "tim")
73 if err != nil {
74 t.Fatal(err)
75 }
76 if got, ok := m.Check(keyB); !ok || got.ID != b.ID {
77 t.Fatal("tweede key")
78 }
79 if got, ok := m.Check(key); !ok || got.ID != c.ID {
80 t.Fatal("eerste key werkt niet meer")
81 }
82 if list, _ := m.List(); len(list) != 2 {
83 t.Fatalf("%d servers", len(list))
84 }
85 // Nieuwe key voor de eerste: oude key dood, koppeling weg, tweede blijft.
86 key2, _, err := m.RotateKey(c.ID, "tim")
87 if err != nil {
88 t.Fatal(err)
89 }
90 if _, ok := m.Check(key); ok {
91 t.Fatal("oude key werkt nog")
92 }
93 if _, ok := m.Check(key2); !ok {
94 t.Fatal("nieuwe key geweigerd")
95 }
96 if c, _ := m.Get(c.ID); c.Connected() {
97 t.Fatal("nieuwe key houdt oude server vast")
98 }
99 if _, err := m.Rename(b.ID, "Offsite 2"); err != nil {
100 t.Fatal(err)
101 }
102 if b, _ := m.Get(b.ID); b.Name != "Offsite 2" {
103 t.Fatal(b.Name)
104 }
105 id1, _ := m.InstanceID()
106 id2, _ := m.InstanceID()
107 if id1 == "" || id1 != id2 {
108 t.Fatal("instance-id niet vast")
109 }
110 if err := m.Remove(c.ID); err != nil {
111 t.Fatal(err)
112 }
113 if _, ok := m.Check(key2); ok {
114 t.Fatal("ingetrokken key werkt")
115 }
116 if _, ok := m.Check(keyB); !ok {
117 t.Fatal("andere server verloor zijn key")
118 }
119 if err := m.Remove("bestaatniet"); err != ErrUnknown {
120 t.Fatal(err)
121 }
122 for i := 0; i < MaxServers; i++ {
123 _, _, _ = m.Add("x", "tim")
124 }
125 if _, _, err := m.Add("x", "tim"); err != ErrTooMany {
126 t.Fatal(err)
127 }
128 }
129
130 func TestLegacySingleConn(t *testing.T) {
131 d := t.TempDir()
132 key := "bgbk_" + strings.Repeat("ab", 32)
133 old := `{"key_hash":"` + HashKey(key) + `","sign_secret":"` + SigningSecret(key) + `","key_hint":"bgbk_ababab","server_url":"http://b:8080"}`
134 _ = os.WriteFile(filepath.Join(d, "backup.json"), []byte(old), 0o600)
135 m := &Manager{Dir: d}
136 c, ok := m.Check(key)
137 if !ok || c.ID == "" || c.Name != "backup" || !c.Connected() {
138 t.Fatalf("%+v %v", c, ok)
139 }
140 }
141
142 func TestCleanLogical(t *testing.T) {
143 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"}
144 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"}
145 for _, p := range good {
146 if _, ok := CleanLogical(p); !ok {
147 t.Errorf("geweigerd: %s", p)
148 }
149 }
150 for _, p := range bad {
151 if _, ok := CleanLogical(p); ok {
152 t.Errorf("toegestaan: %s", p)
153 }
154 }
155 }
156
157 func write(t *testing.T, p, s string) {
158 t.Helper()
159 if err := os.MkdirAll(filepath.Dir(p), 0o755); err != nil {
160 t.Fatal(err)
161 }
162 if err := os.WriteFile(p, []byte(s), 0o644); err != nil {
163 t.Fatal(err)
164 }
165 }
166
167 func fakeTree(t *testing.T) Tree {
168 st, data := t.TempDir(), t.TempDir()
169 write(t, filepath.Join(st, "bluegit.db"), "live-db")
170 write(t, filepath.Join(st, "secret.key"), "k")
171 write(t, filepath.Join(st, "storage_path"), data)
172 write(t, filepath.Join(st, "backup.json"), "{}")
173 write(t, filepath.Join(st, "ssh", "host_ed25519"), "hk")
174 write(t, filepath.Join(data, "repos", "tim", "a.git", "HEAD"), "ref: refs/heads/master")
175 write(t, filepath.Join(data, "repos", "tim", "a.git", "index.lock"), "x")
176 write(t, filepath.Join(data, "releases", ".incoming", "x"), "x")
177 write(t, filepath.Join(data, "releases", "tim", "a", "v1", "a.bin"), "bin")
178 write(t, filepath.Join(data, "work", "1", "f"), "x")
179 _ = os.Symlink("/etc/passwd", filepath.Join(data, "repos", "tim", "evil"))
180 return Tree{StateDir: st, DataDir: data, Snapshot: func(dst string) error {
181 return os.WriteFile(dst, []byte("snapshot-db"), 0o600)
182 }}
183 }
184
185 func TestManifestAndResolve(t *testing.T) {
186 tr := fakeTree(t)
187 m, err := tr.Build("inst")
188 if err != nil {
189 t.Fatal(err)
190 }
191 var paths []string
192 for _, e := range m.Files {
193 paths = append(paths, e.Path)
194 }
195 got := strings.Join(paths, ",")
196 want := "data/releases/tim/a/v1/a.bin,data/repos/tim/a.git/HEAD,state/bluegit.db,state/secret.key,state/ssh/host_ed25519"
197 if got != want {
198 t.Fatalf("manifest\n got %s\nwant %s", got, want)
199 }
200 if m.Files[2].SHA256 == "" {
201 t.Fatal("database zonder hash")
202 }
203 p, err := tr.Resolve(DBPath)
204 if err != nil {
205 t.Fatal(err)
206 }
207 if b, _ := os.ReadFile(p); string(b) != "snapshot-db" {
208 t.Fatalf("database komt niet uit de kopie: %s", b)
209 }
210 for _, bad := range []string{"state/storage_path", "data/repos/tim/evil", "data/repos/../../etc/passwd"} {
211 if _, err := tr.Resolve(bad); err == nil {
212 t.Errorf("resolve %s toegestaan", bad)
213 }
214 }
215 }
216
217 type tf struct {
218 name, body string
219 typ byte
220 }
221
222 func tgz(t *testing.T, files []tf) []byte {
223 var buf bytes.Buffer
224 gz := gzip.NewWriter(&buf)
225 tw := tar.NewWriter(gz)
226 for _, f := range files {
227 typ := f.typ
228 if typ == 0 {
229 typ = tar.TypeReg
230 }
231 h := &tar.Header{Name: f.name, Mode: 0o644, Size: int64(len(f.body)), Typeflag: typ, ModTime: time.Unix(1_700_000_000, 0)}
232 if typ == tar.TypeSymlink {
233 h.Size, h.Linkname = 0, "/etc/passwd"
234 }
235 if err := tw.WriteHeader(h); err != nil {
236 t.Fatal(err)
237 }
238 if typ == tar.TypeReg {
239 _, _ = tw.Write([]byte(f.body))
240 }
241 }
242 tw.Close()
243 gz.Close()
244 return buf.Bytes()
245 }
246
247 func TestStageAndApply(t *testing.T) {
248 tr := fakeTree(t)
249 archive := tgz(t, []tf{
250 {name: "state/bluegit.db", body: "old-db"},
251 {name: "state/secret.key", body: "old-key"},
252 {name: "data/repos/tim/b.git/HEAD", body: "ref: refs/heads/main"},
253 })
254 n, err := tr.Stage(bytes.NewReader(archive))
255 if err != nil || n != 3 {
256 t.Fatal(n, err)
257 }
258 if b, _ := os.ReadFile(filepath.Join(tr.StateDir, "bluegit.db")); string(b) != "live-db" {
259 t.Fatal("stage raakte de live database")
260 }
261 if !HasPending(tr.StateDir) {
262 t.Fatal("geen READY")
263 }
264 ok, err := ApplyPending(tr.StateDir)
265 if err != nil || !ok {
266 t.Fatal(ok, err)
267 }
268 check := func(p, want string) {
269 t.Helper()
270 b, err := os.ReadFile(p)
271 if want == "" {
272 if err == nil {
273 t.Errorf("%s bestaat nog", p)
274 }
275 return
276 }
277 if string(b) != want {
278 t.Errorf("%s = %q, wil %q", p, b, want)
279 }
280 }
281 check(filepath.Join(tr.StateDir, "bluegit.db"), "old-db")
282 check(filepath.Join(tr.StateDir, "secret.key"), "old-key")
283 check(filepath.Join(tr.StateDir, "ssh", "host_ed25519"), "")
284 check(filepath.Join(tr.StateDir, "backup.json"), "{}")
285 check(filepath.Join(tr.StateDir, "storage_path"), tr.DataDir)
286 check(filepath.Join(tr.DataDir, "repos", "tim", "b.git", "HEAD"), "ref: refs/heads/main")
287 check(filepath.Join(tr.DataDir, "repos", "tim", "a.git", "HEAD"), "")
288 check(filepath.Join(tr.DataDir, "releases", "tim", "a", "v1", "a.bin"), "")
289 check(filepath.Join(tr.DataDir, "work", "1", "f"), "x")
290 if HasPending(tr.StateDir) {
291 t.Fatal("READY blijft staan")
292 }
293 if ok, _ := ApplyPending(tr.StateDir); ok {
294 t.Fatal("tweede keer toegepast")
295 }
296 }
297
298 func TestStageRejects(t *testing.T) {
299 cases := map[string][]tf{
300 "traversal": {{name: "state/bluegit.db", body: "x"}, {name: "state/secret.key", body: "k"}, {name: "data/repos/../../../etc/x", body: "x"}},
301 "symlink": {{name: "state/bluegit.db", body: "x"}, {name: "state/secret.key", body: "k"}, {name: "data/repos/a/l", typ: tar.TypeSymlink}},
302 "onbekend": {{name: "state/bluegit.db", body: "x"}, {name: "state/secret.key", body: "k"}, {name: "state/storage_path", body: "/"}},
303 "zonder-db": {{name: "state/secret.key", body: "k"}},
304 "zonder-key": {{name: "state/bluegit.db", body: "x"}},
305 }
306 for name, files := range cases {
307 tr := fakeTree(t)
308 if _, err := tr.Stage(bytes.NewReader(tgz(t, files))); err == nil {
309 t.Errorf("%s: geaccepteerd", name)
310 }
311 if HasPending(tr.StateDir) {
312 t.Errorf("%s: READY na fout", name)
313 }
314 if _, err := os.Stat(filepath.Join(tr.StateDir, ".restore")); err == nil {
315 t.Errorf("%s: staging blijft staan", name)
316 }
317 }
318 if _, err := fakeTree(t).Stage(strings.NewReader("geen gzip")); err == nil {
319 t.Error("geen gzip geaccepteerd")
320 }
321 }
322
323 // Vaste vector: bluegit-backup (internal/protocol) test dezelfde waarden.
324 func TestSignatureVector(t *testing.T) {
325 sec := SigningSecret("bgbk_test")
326 if sec != "c04d0bdbac2260c010f61c9b063b28026eed1d2292c928708708821449e72c2a" {
327 t.Fatalf("geheim %s", sec)
328 }
329 if got := Signature(sec, "post", "/api/v1/notify", "1800000000", []byte("{}")); got != "51c5ec72528304632383637b99dfda1e14b68194bbec2d4faa36c9d5ef892548" {
330 t.Fatalf("handtekening %s", got)
331 }
332 }
333
334 // Twee backup servers die tegelijk een manifest ophalen krijgen elk hun
335 // eigen databasekopie; de ene vervangt de kopie van de andere niet.
336 func TestSnapshotPerConnection(t *testing.T) {
337 base := fakeTree(t)
338 var mu sync.Mutex
339 busy := 0
340 n := 0
341 base.Snapshot = func(dst string) error {
342 mu.Lock()
343 busy++
344 n++
345 if busy > 1 {
346 mu.Unlock()
347 return errors.New("twee kopieën tegelijk")
348 }
349 body := fmt.Sprintf("snapshot-%d", n)
350 mu.Unlock()
351 time.Sleep(5 * time.Millisecond)
352 err := os.WriteFile(dst, []byte(body), 0o600)
353 mu.Lock()
354 busy--
355 mu.Unlock()
356 return err
357 }
358 a, b := base, base
359 a.Conn, b.Conn = "aaa", "bbb"
360 var wg sync.WaitGroup
361 errs := make(chan error, 20)
362 for i := 0; i < 10; i++ {
363 for _, tr := range []Tree{a, b} {
364 wg.Add(1)
365 go func(tr Tree) {
366 defer wg.Done()
367 if _, err := tr.Build("inst"); err != nil {
368 errs <- err
369 }
370 }(tr)
371 }
372 }
373 wg.Wait()
374 close(errs)
375 for err := range errs {
376 t.Fatal(err)
377 }
378 ma, err := a.Build("inst")
379 if err != nil {
380 t.Fatal(err)
381 }
382 if _, err := b.Build("inst"); err != nil {
383 t.Fatal(err)
384 }
385 // De kopie van a is niet veranderd door de build van b.
386 p, _ := a.Resolve(DBPath)
387 raw, _ := os.ReadFile(p)
388 sum := sha256.Sum256(raw)
389 for _, e := range ma.Files {
390 if e.Path == DBPath && e.SHA256 != hex.EncodeToString(sum[:]) {
391 t.Fatal("kopie van a is overschreven door b")
392 }
393 }
394 a.RemoveSnapshot()
395 if _, err := a.Resolve(DBPath); err == nil {
396 t.Fatal("kopie niet opgeruimd")
397 }
398 if _, err := b.Resolve(DBPath); err != nil {
399 t.Fatal("kopie van b is mee opgeruimd")
400 }
401 }
@@ -0,0 +1,401 @@
1package backup
2
3import (
4 "archive/tar"
5 "bytes"
6 "compress/gzip"
7 "crypto/sha256"
8 "encoding/hex"
9 "errors"
10 "fmt"
11 "net/http"
12 "os"
13 "path/filepath"
14 "strings"
15 "sync"
16 "testing"
17 "time"
18)
19
20func TestSignVerify(t *testing.T) {
21 sec := SigningSecret("bgbk_x")
22 now := time.Unix(1_800_000_000, 0)
23 body := []byte(`{"archive":"a"}`)
24 req, _ := http.NewRequest("POST", "http://b/api/v1/rollback", bytes.NewReader(body))
25 Sign(req, sec, "inst", body, now)
26 if err := Verify(req, sec, body, now.Add(time.Minute)); err != nil {
27 t.Fatal(err)
28 }
29 if Verify(req, sec, []byte(`{"archive":"b"}`), now) == nil {
30 t.Fatal("andere body geaccepteerd")
31 }
32 if Verify(req, SigningSecret("bgbk_y"), body, now) == nil {
33 t.Fatal("ander geheim geaccepteerd")
34 }
35 if Verify(req, sec, body, now.Add(10*time.Minute)) == nil {
36 t.Fatal("oude timestamp geaccepteerd")
37 }
38 req.URL.Path = "/api/v1/notify"
39 if Verify(req, sec, body, now) == nil {
40 t.Fatal("ander pad geaccepteerd")
41 }
42}
43
44func TestKeyLifecycle(t *testing.T) {
45 m := &Manager{Dir: t.TempDir()}
46 if _, ok := m.Check("bgbk_nope"); ok {
47 t.Fatal("check zonder key")
48 }
49 key, c, err := m.Add(" nas kelder ", "tim")
50 if err != nil || !strings.HasPrefix(key, KeyPrefix) || c.KeyHash == "" || c.Name != "nas kelder" || c.ID == "" {
51 t.Fatal(key, c, err)
52 }
53 raw, _ := os.ReadFile(filepath.Join(m.Dir, "backup.json"))
54 if strings.Contains(string(raw), key) {
55 t.Fatal("key staat leesbaar op schijf")
56 }
57 fi, _ := os.Stat(filepath.Join(m.Dir, "backup.json"))
58 if fi.Mode().Perm() != 0o600 {
59 t.Fatalf("mode %v", fi.Mode())
60 }
61 if got, ok := m.Check(key); !ok || got.ID != c.ID {
62 t.Fatal("eigen key geweigerd")
63 }
64 if _, err := m.Connect(c.ID, "http://backup:9000/", "srv1"); err != nil {
65 t.Fatal(err)
66 }
67 c, _ = m.Get(c.ID)
68 if !c.Connected() || c.ServerURL != "http://backup:9000" || c.SignSecret != SigningSecret(key) {
69 t.Fatalf("%+v", c)
70 }
71 // Een tweede backup server met een eigen key; de eerste blijft werken.
72 keyB, b, err := m.Add("offsite", "tim")
73 if err != nil {
74 t.Fatal(err)
75 }
76 if got, ok := m.Check(keyB); !ok || got.ID != b.ID {
77 t.Fatal("tweede key")
78 }
79 if got, ok := m.Check(key); !ok || got.ID != c.ID {
80 t.Fatal("eerste key werkt niet meer")
81 }
82 if list, _ := m.List(); len(list) != 2 {
83 t.Fatalf("%d servers", len(list))
84 }
85 // Nieuwe key voor de eerste: oude key dood, koppeling weg, tweede blijft.
86 key2, _, err := m.RotateKey(c.ID, "tim")
87 if err != nil {
88 t.Fatal(err)
89 }
90 if _, ok := m.Check(key); ok {
91 t.Fatal("oude key werkt nog")
92 }
93 if _, ok := m.Check(key2); !ok {
94 t.Fatal("nieuwe key geweigerd")
95 }
96 if c, _ := m.Get(c.ID); c.Connected() {
97 t.Fatal("nieuwe key houdt oude server vast")
98 }
99 if _, err := m.Rename(b.ID, "Offsite 2"); err != nil {
100 t.Fatal(err)
101 }
102 if b, _ := m.Get(b.ID); b.Name != "Offsite 2" {
103 t.Fatal(b.Name)
104 }
105 id1, _ := m.InstanceID()
106 id2, _ := m.InstanceID()
107 if id1 == "" || id1 != id2 {
108 t.Fatal("instance-id niet vast")
109 }
110 if err := m.Remove(c.ID); err != nil {
111 t.Fatal(err)
112 }
113 if _, ok := m.Check(key2); ok {
114 t.Fatal("ingetrokken key werkt")
115 }
116 if _, ok := m.Check(keyB); !ok {
117 t.Fatal("andere server verloor zijn key")
118 }
119 if err := m.Remove("bestaatniet"); err != ErrUnknown {
120 t.Fatal(err)
121 }
122 for i := 0; i < MaxServers; i++ {
123 _, _, _ = m.Add("x", "tim")
124 }
125 if _, _, err := m.Add("x", "tim"); err != ErrTooMany {
126 t.Fatal(err)
127 }
128}
129
130func TestLegacySingleConn(t *testing.T) {
131 d := t.TempDir()
132 key := "bgbk_" + strings.Repeat("ab", 32)
133 old := `{"key_hash":"` + HashKey(key) + `","sign_secret":"` + SigningSecret(key) + `","key_hint":"bgbk_ababab","server_url":"http://b:8080"}`
134 _ = os.WriteFile(filepath.Join(d, "backup.json"), []byte(old), 0o600)
135 m := &Manager{Dir: d}
136 c, ok := m.Check(key)
137 if !ok || c.ID == "" || c.Name != "backup" || !c.Connected() {
138 t.Fatalf("%+v %v", c, ok)
139 }
140}
141
142func TestCleanLogical(t *testing.T) {
143 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"}
144 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"}
145 for _, p := range good {
146 if _, ok := CleanLogical(p); !ok {
147 t.Errorf("geweigerd: %s", p)
148 }
149 }
150 for _, p := range bad {
151 if _, ok := CleanLogical(p); ok {
152 t.Errorf("toegestaan: %s", p)
153 }
154 }
155}
156
157func write(t *testing.T, p, s string) {
158 t.Helper()
159 if err := os.MkdirAll(filepath.Dir(p), 0o755); err != nil {
160 t.Fatal(err)
161 }
162 if err := os.WriteFile(p, []byte(s), 0o644); err != nil {
163 t.Fatal(err)
164 }
165}
166
167func fakeTree(t *testing.T) Tree {
168 st, data := t.TempDir(), t.TempDir()
169 write(t, filepath.Join(st, "bluegit.db"), "live-db")
170 write(t, filepath.Join(st, "secret.key"), "k")
171 write(t, filepath.Join(st, "storage_path"), data)
172 write(t, filepath.Join(st, "backup.json"), "{}")
173 write(t, filepath.Join(st, "ssh", "host_ed25519"), "hk")
174 write(t, filepath.Join(data, "repos", "tim", "a.git", "HEAD"), "ref: refs/heads/master")
175 write(t, filepath.Join(data, "repos", "tim", "a.git", "index.lock"), "x")
176 write(t, filepath.Join(data, "releases", ".incoming", "x"), "x")
177 write(t, filepath.Join(data, "releases", "tim", "a", "v1", "a.bin"), "bin")
178 write(t, filepath.Join(data, "work", "1", "f"), "x")
179 _ = os.Symlink("/etc/passwd", filepath.Join(data, "repos", "tim", "evil"))
180 return Tree{StateDir: st, DataDir: data, Snapshot: func(dst string) error {
181 return os.WriteFile(dst, []byte("snapshot-db"), 0o600)
182 }}
183}
184
185func TestManifestAndResolve(t *testing.T) {
186 tr := fakeTree(t)
187 m, err := tr.Build("inst")
188 if err != nil {
189 t.Fatal(err)
190 }
191 var paths []string
192 for _, e := range m.Files {
193 paths = append(paths, e.Path)
194 }
195 got := strings.Join(paths, ",")
196 want := "data/releases/tim/a/v1/a.bin,data/repos/tim/a.git/HEAD,state/bluegit.db,state/secret.key,state/ssh/host_ed25519"
197 if got != want {
198 t.Fatalf("manifest\n got %s\nwant %s", got, want)
199 }
200 if m.Files[2].SHA256 == "" {
201 t.Fatal("database zonder hash")
202 }
203 p, err := tr.Resolve(DBPath)
204 if err != nil {
205 t.Fatal(err)
206 }
207 if b, _ := os.ReadFile(p); string(b) != "snapshot-db" {
208 t.Fatalf("database komt niet uit de kopie: %s", b)
209 }
210 for _, bad := range []string{"state/storage_path", "data/repos/tim/evil", "data/repos/../../etc/passwd"} {
211 if _, err := tr.Resolve(bad); err == nil {
212 t.Errorf("resolve %s toegestaan", bad)
213 }
214 }
215}
216
217type tf struct {
218 name, body string
219 typ byte
220}
221
222func tgz(t *testing.T, files []tf) []byte {
223 var buf bytes.Buffer
224 gz := gzip.NewWriter(&buf)
225 tw := tar.NewWriter(gz)
226 for _, f := range files {
227 typ := f.typ
228 if typ == 0 {
229 typ = tar.TypeReg
230 }
231 h := &tar.Header{Name: f.name, Mode: 0o644, Size: int64(len(f.body)), Typeflag: typ, ModTime: time.Unix(1_700_000_000, 0)}
232 if typ == tar.TypeSymlink {
233 h.Size, h.Linkname = 0, "/etc/passwd"
234 }
235 if err := tw.WriteHeader(h); err != nil {
236 t.Fatal(err)
237 }
238 if typ == tar.TypeReg {
239 _, _ = tw.Write([]byte(f.body))
240 }
241 }
242 tw.Close()
243 gz.Close()
244 return buf.Bytes()
245}
246
247func TestStageAndApply(t *testing.T) {
248 tr := fakeTree(t)
249 archive := tgz(t, []tf{
250 {name: "state/bluegit.db", body: "old-db"},
251 {name: "state/secret.key", body: "old-key"},
252 {name: "data/repos/tim/b.git/HEAD", body: "ref: refs/heads/main"},
253 })
254 n, err := tr.Stage(bytes.NewReader(archive))
255 if err != nil || n != 3 {
256 t.Fatal(n, err)
257 }
258 if b, _ := os.ReadFile(filepath.Join(tr.StateDir, "bluegit.db")); string(b) != "live-db" {
259 t.Fatal("stage raakte de live database")
260 }
261 if !HasPending(tr.StateDir) {
262 t.Fatal("geen READY")
263 }
264 ok, err := ApplyPending(tr.StateDir)
265 if err != nil || !ok {
266 t.Fatal(ok, err)
267 }
268 check := func(p, want string) {
269 t.Helper()
270 b, err := os.ReadFile(p)
271 if want == "" {
272 if err == nil {
273 t.Errorf("%s bestaat nog", p)
274 }
275 return
276 }
277 if string(b) != want {
278 t.Errorf("%s = %q, wil %q", p, b, want)
279 }
280 }
281 check(filepath.Join(tr.StateDir, "bluegit.db"), "old-db")
282 check(filepath.Join(tr.StateDir, "secret.key"), "old-key")
283 check(filepath.Join(tr.StateDir, "ssh", "host_ed25519"), "")
284 check(filepath.Join(tr.StateDir, "backup.json"), "{}")
285 check(filepath.Join(tr.StateDir, "storage_path"), tr.DataDir)
286 check(filepath.Join(tr.DataDir, "repos", "tim", "b.git", "HEAD"), "ref: refs/heads/main")
287 check(filepath.Join(tr.DataDir, "repos", "tim", "a.git", "HEAD"), "")
288 check(filepath.Join(tr.DataDir, "releases", "tim", "a", "v1", "a.bin"), "")
289 check(filepath.Join(tr.DataDir, "work", "1", "f"), "x")
290 if HasPending(tr.StateDir) {
291 t.Fatal("READY blijft staan")
292 }
293 if ok, _ := ApplyPending(tr.StateDir); ok {
294 t.Fatal("tweede keer toegepast")
295 }
296}
297
298func TestStageRejects(t *testing.T) {
299 cases := map[string][]tf{
300 "traversal": {{name: "state/bluegit.db", body: "x"}, {name: "state/secret.key", body: "k"}, {name: "data/repos/../../../etc/x", body: "x"}},
301 "symlink": {{name: "state/bluegit.db", body: "x"}, {name: "state/secret.key", body: "k"}, {name: "data/repos/a/l", typ: tar.TypeSymlink}},
302 "onbekend": {{name: "state/bluegit.db", body: "x"}, {name: "state/secret.key", body: "k"}, {name: "state/storage_path", body: "/"}},
303 "zonder-db": {{name: "state/secret.key", body: "k"}},
304 "zonder-key": {{name: "state/bluegit.db", body: "x"}},
305 }
306 for name, files := range cases {
307 tr := fakeTree(t)
308 if _, err := tr.Stage(bytes.NewReader(tgz(t, files))); err == nil {
309 t.Errorf("%s: geaccepteerd", name)
310 }
311 if HasPending(tr.StateDir) {
312 t.Errorf("%s: READY na fout", name)
313 }
314 if _, err := os.Stat(filepath.Join(tr.StateDir, ".restore")); err == nil {
315 t.Errorf("%s: staging blijft staan", name)
316 }
317 }
318 if _, err := fakeTree(t).Stage(strings.NewReader("geen gzip")); err == nil {
319 t.Error("geen gzip geaccepteerd")
320 }
321}
322
323// Vaste vector: bluegit-backup (internal/protocol) test dezelfde waarden.
324func TestSignatureVector(t *testing.T) {
325 sec := SigningSecret("bgbk_test")
326 if sec != "c04d0bdbac2260c010f61c9b063b28026eed1d2292c928708708821449e72c2a" {
327 t.Fatalf("geheim %s", sec)
328 }
329 if got := Signature(sec, "post", "/api/v1/notify", "1800000000", []byte("{}")); got != "51c5ec72528304632383637b99dfda1e14b68194bbec2d4faa36c9d5ef892548" {
330 t.Fatalf("handtekening %s", got)
331 }
332}
333
334// Twee backup servers die tegelijk een manifest ophalen krijgen elk hun
335// eigen databasekopie; de ene vervangt de kopie van de andere niet.
336func TestSnapshotPerConnection(t *testing.T) {
337 base := fakeTree(t)
338 var mu sync.Mutex
339 busy := 0
340 n := 0
341 base.Snapshot = func(dst string) error {
342 mu.Lock()
343 busy++
344 n++
345 if busy > 1 {
346 mu.Unlock()
347 return errors.New("twee kopieën tegelijk")
348 }
349 body := fmt.Sprintf("snapshot-%d", n)
350 mu.Unlock()
351 time.Sleep(5 * time.Millisecond)
352 err := os.WriteFile(dst, []byte(body), 0o600)
353 mu.Lock()
354 busy--
355 mu.Unlock()
356 return err
357 }
358 a, b := base, base
359 a.Conn, b.Conn = "aaa", "bbb"
360 var wg sync.WaitGroup
361 errs := make(chan error, 20)
362 for i := 0; i < 10; i++ {
363 for _, tr := range []Tree{a, b} {
364 wg.Add(1)
365 go func(tr Tree) {
366 defer wg.Done()
367 if _, err := tr.Build("inst"); err != nil {
368 errs <- err
369 }
370 }(tr)
371 }
372 }
373 wg.Wait()
374 close(errs)
375 for err := range errs {
376 t.Fatal(err)
377 }
378 ma, err := a.Build("inst")
379 if err != nil {
380 t.Fatal(err)
381 }
382 if _, err := b.Build("inst"); err != nil {
383 t.Fatal(err)
384 }
385 // De kopie van a is niet veranderd door de build van b.
386 p, _ := a.Resolve(DBPath)
387 raw, _ := os.ReadFile(p)
388 sum := sha256.Sum256(raw)
389 for _, e := range ma.Files {
390 if e.Path == DBPath && e.SHA256 != hex.EncodeToString(sum[:]) {
391 t.Fatal("kopie van a is overschreven door b")
392 }
393 }
394 a.RemoveSnapshot()
395 if _, err := a.Resolve(DBPath); err == nil {
396 t.Fatal("kopie niet opgeruimd")
397 }
398 if _, err := b.Resolve(DBPath); err != nil {
399 t.Fatal("kopie van b is mee opgeruimd")
400 }
401}
internal/backup/client.go added +261 −0
@@ -0,0 +1,261 @@
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 ServerID string `json:"server_id"`
25 LastSync time.Time `json:"last_sync"`
26 SyncError string `json:"sync_error,omitempty"`
27 Syncs int `json:"syncs"`
28 Notifies int `json:"notifies"`
29 MirrorBytes int64 `json:"mirror_bytes"`
30 LastStats struct {
31 Files int `json:"files"`
32 Downloaded int `json:"downloaded"`
33 Bytes int64 `json:"bytes"`
34 Deleted int `json:"deleted"`
35 } `json:"last_stats"`
36 Archives int `json:"archives"`
37 LastArchive time.Time `json:"last_archive"`
38 ArchiveError string `json:"archive_error,omitempty"`
39 Rollback struct {
40 State string `json:"state"`
41 Archive string `json:"archive,omitempty"`
42 Error string `json:"error,omitempty"`
43 At time.Time `json:"at,omitempty"`
44 } `json:"rollback"`
45 Interval string `json:"archive_interval"`
46 RetentionDays int `json:"retention_days"`
47 RateLimitKiB int64 `json:"rate_limit_kib"`
48 }
49
50 // Client praat ondertekend met de backup servers.
51 type Client struct {
52 Manager *Manager
53 HTTP *http.Client
54 Now func() time.Time
55 }
56
57 // RemoteError is een foutantwoord van de backup server.
58 type RemoteError struct {
59 Status int
60 Msg string
61 }
62
63 func (e *RemoteError) Error() string { return "backup server: " + e.Msg }
64
65 // Call stuurt een ondertekend verzoek naar backup server conn en geeft het
66 // ruwe antwoord terug. in is nil of wordt JSON.
67 func (c *Client) Call(ctx context.Context, conn Conn, method, p string, in any) (int, []byte, error) {
68 if !conn.Connected() {
69 return 0, nil, fmt.Errorf("backup server %s is niet gekoppeld", conn.Name)
70 }
71 inst, err := c.Manager.InstanceID()
72 if err != nil {
73 return 0, nil, err
74 }
75 var body []byte
76 if in != nil {
77 if body, err = json.Marshal(in); err != nil {
78 return 0, nil, err
79 }
80 }
81 req, err := http.NewRequestWithContext(ctx, method, conn.ServerURL+p, bytes.NewReader(body))
82 if err != nil {
83 return 0, nil, err
84 }
85 if in != nil {
86 req.Header.Set("Content-Type", "application/json")
87 }
88 now := time.Now
89 if c.Now != nil {
90 now = c.Now
91 }
92 Sign(req, conn.SignSecret, inst, body, now())
93 hc := c.HTTP
94 if hc == nil {
95 hc = &http.Client{Timeout: 15 * time.Second}
96 }
97 resp, err := hc.Do(req)
98 if err != nil {
99 return 0, nil, err
100 }
101 defer resp.Body.Close()
102 raw, _ := io.ReadAll(io.LimitReader(resp.Body, 4<<20))
103 return resp.StatusCode, raw, nil
104 }
105
106 func (c *Client) do(ctx context.Context, conn Conn, method, p string, in, out any) error {
107 code, raw, err := c.Call(ctx, conn, method, p, in)
108 if err != nil {
109 return err
110 }
111 if code >= 300 {
112 var e struct {
113 Error string `json:"error"`
114 }
115 _ = json.Unmarshal(raw, &e)
116 if e.Error == "" {
117 e.Error = http.StatusText(code)
118 }
119 return &RemoteError{Status: code, Msg: e.Error}
120 }
121 if out != nil {
122 return json.Unmarshal(raw, out)
123 }
124 return nil
125 }
126
127 // Archives vraagt de lijst met archieven op, nieuwste eerst.
128 func (c *Client) Archives(ctx context.Context, conn Conn) ([]Archive, error) {
129 var out struct {
130 Archives []Archive `json:"archives"`
131 }
132 err := c.do(ctx, conn, http.MethodGet, "/api/v1/archives", nil, &out)
133 return out.Archives, err
134 }
135
136 // Status vraagt de toestand van de backup server op.
137 func (c *Client) Status(ctx context.Context, conn Conn) (RemoteStatus, error) {
138 var out RemoteStatus
139 err := c.do(ctx, conn, http.MethodGet, "/api/v1/status", nil, &out)
140 return out, err
141 }
142
143 // RemoteField is één instelling van de backup server.
144 type RemoteField struct {
145 Key string `json:"key"`
146 Label string `json:"label"`
147 Help string `json:"help"`
148 Kind string `json:"kind"`
149 Restart bool `json:"restart"`
150 Value string `json:"value"`
151 }
152
153 // RemoteConfig is GET /api/v1/admin/config van de backup server.
154 type RemoteConfig struct {
155 Fields []RemoteField `json:"fields"`
156 DataDir string `json:"data_dir"`
157 Restart bool `json:"restart_pending"`
158 }
159
160 // Config vraagt de instellingen van de backup server op.
161 func (c *Client) Config(ctx context.Context, conn Conn) (RemoteConfig, error) {
162 var out RemoteConfig
163 err := c.do(ctx, conn, http.MethodGet, "/api/v1/admin/config", nil, &out)
164 return out, err
165 }
166
167 // RemoteAction is één beheeractie die de backup server aanbiedt.
168 type RemoteAction struct {
169 Name string `json:"name"`
170 Method string `json:"method"`
171 Path string `json:"path"`
172 Title string `json:"title"`
173 Signed bool `json:"bluegit"`
174 Params []string `json:"params"`
175 Fields []string `json:"fields"`
176 }
177
178 // Actions vraagt op wat de backup server aanbiedt.
179 func (c *Client) Actions(ctx context.Context, conn Conn) ([]RemoteAction, error) {
180 var out struct {
181 Actions []RemoteAction `json:"actions"`
182 }
183 err := c.do(ctx, conn, http.MethodGet, "/api/v1/admin/actions", nil, &out)
184 return out.Actions, err
185 }
186
187 // Rollback vraagt de backup server om archive terug te zetten. De server
188 // antwoordt meteen; het terugsturen naar BlueGit gebeurt daarna.
189 func (c *Client) Rollback(ctx context.Context, conn Conn, archive string) error {
190 return c.do(ctx, conn, http.MethodPost, "/api/v1/rollback", map[string]string{"archive": archive}, nil)
191 }
192
193 // Notify meldt dat er iets veranderd is.
194 func (c *Client) Notify(ctx context.Context, conn Conn) error {
195 return c.do(ctx, conn, http.MethodPost, "/api/v1/notify", map[string]any{"at": time.Now().UTC()}, nil)
196 }
197
198 // Notifier bundelt wijzigingen: hoogstens één melding per Delay, aan elke
199 // gekoppelde backup server, met een paar nieuwe pogingen bij een fout. De
200 // backup servers halen daarnaast periodiek alles op, dus een gemiste
201 // melding kost alleen vertraging.
202 type Notifier struct {
203 Client *Client
204 Delay time.Duration
205 once sync.Once
206 kick chan struct{}
207 }
208
209 // Changed zegt dat er iets veranderd is. Blokkeert nooit.
210 func (n *Notifier) Changed() {
211 if n == nil {
212 return
213 }
214 n.once.Do(func() {
215 n.kick = make(chan struct{}, 1)
216 go n.loop()
217 })
218 select {
219 case n.kick <- struct{}{}:
220 default:
221 }
222 }
223
224 func (n *Notifier) loop() {
225 delay := n.Delay
226 if delay <= 0 {
227 delay = 2 * time.Second
228 }
229 for range n.kick {
230 time.Sleep(delay)
231 // Wat in de tussentijd binnenkwam, zit in deze melding.
232 select {
233 case <-n.kick:
234 default:
235 }
236 list, err := n.Client.Manager.List()
237 if err != nil {
238 continue
239 }
240 var wg sync.WaitGroup
241 for _, conn := range list {
242 if !conn.Connected() {
243 continue
244 }
245 wg.Add(1)
246 go func(conn Conn) {
247 defer wg.Done()
248 for try := 0; try < 4; try++ {
249 ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
250 err := n.Client.Notify(ctx, conn)
251 cancel()
252 if err == nil {
253 return
254 }
255 time.Sleep(time.Duration(1<<try) * 2 * time.Second)
256 }
257 }(conn)
258 }
259 wg.Wait()
260 }
261 }
@@ -0,0 +1,261 @@
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 ServerID string `json:"server_id"`
25 LastSync time.Time `json:"last_sync"`
26 SyncError string `json:"sync_error,omitempty"`
27 Syncs int `json:"syncs"`
28 Notifies int `json:"notifies"`
29 MirrorBytes int64 `json:"mirror_bytes"`
30 LastStats struct {
31 Files int `json:"files"`
32 Downloaded int `json:"downloaded"`
33 Bytes int64 `json:"bytes"`
34 Deleted int `json:"deleted"`
35 } `json:"last_stats"`
36 Archives int `json:"archives"`
37 LastArchive time.Time `json:"last_archive"`
38 ArchiveError string `json:"archive_error,omitempty"`
39 Rollback struct {
40 State string `json:"state"`
41 Archive string `json:"archive,omitempty"`
42 Error string `json:"error,omitempty"`
43 At time.Time `json:"at,omitempty"`
44 } `json:"rollback"`
45 Interval string `json:"archive_interval"`
46 RetentionDays int `json:"retention_days"`
47 RateLimitKiB int64 `json:"rate_limit_kib"`
48}
49
50// Client praat ondertekend met de backup servers.
51type Client struct {
52 Manager *Manager
53 HTTP *http.Client
54 Now func() time.Time
55}
56
57// RemoteError is een foutantwoord van de backup server.
58type RemoteError struct {
59 Status int
60 Msg string
61}
62
63func (e *RemoteError) Error() string { return "backup server: " + e.Msg }
64
65// Call stuurt een ondertekend verzoek naar backup server conn en geeft het
66// ruwe antwoord terug. in is nil of wordt JSON.
67func (c *Client) Call(ctx context.Context, conn Conn, method, p string, in any) (int, []byte, error) {
68 if !conn.Connected() {
69 return 0, nil, fmt.Errorf("backup server %s is niet gekoppeld", conn.Name)
70 }
71 inst, err := c.Manager.InstanceID()
72 if err != nil {
73 return 0, nil, err
74 }
75 var body []byte
76 if in != nil {
77 if body, err = json.Marshal(in); err != nil {
78 return 0, nil, err
79 }
80 }
81 req, err := http.NewRequestWithContext(ctx, method, conn.ServerURL+p, bytes.NewReader(body))
82 if err != nil {
83 return 0, nil, err
84 }
85 if in != nil {
86 req.Header.Set("Content-Type", "application/json")
87 }
88 now := time.Now
89 if c.Now != nil {
90 now = c.Now
91 }
92 Sign(req, conn.SignSecret, inst, body, now())
93 hc := c.HTTP
94 if hc == nil {
95 hc = &http.Client{Timeout: 15 * time.Second}
96 }
97 resp, err := hc.Do(req)
98 if err != nil {
99 return 0, nil, err
100 }
101 defer resp.Body.Close()
102 raw, _ := io.ReadAll(io.LimitReader(resp.Body, 4<<20))
103 return resp.StatusCode, raw, nil
104}
105
106func (c *Client) do(ctx context.Context, conn Conn, method, p string, in, out any) error {
107 code, raw, err := c.Call(ctx, conn, method, p, in)
108 if err != nil {
109 return err
110 }
111 if code >= 300 {
112 var e struct {
113 Error string `json:"error"`
114 }
115 _ = json.Unmarshal(raw, &e)
116 if e.Error == "" {
117 e.Error = http.StatusText(code)
118 }
119 return &RemoteError{Status: code, Msg: e.Error}
120 }
121 if out != nil {
122 return json.Unmarshal(raw, out)
123 }
124 return nil
125}
126
127// Archives vraagt de lijst met archieven op, nieuwste eerst.
128func (c *Client) Archives(ctx context.Context, conn Conn) ([]Archive, error) {
129 var out struct {
130 Archives []Archive `json:"archives"`
131 }
132 err := c.do(ctx, conn, http.MethodGet, "/api/v1/archives", nil, &out)
133 return out.Archives, err
134}
135
136// Status vraagt de toestand van de backup server op.
137func (c *Client) Status(ctx context.Context, conn Conn) (RemoteStatus, error) {
138 var out RemoteStatus
139 err := c.do(ctx, conn, http.MethodGet, "/api/v1/status", nil, &out)
140 return out, err
141}
142
143// RemoteField is één instelling van de backup server.
144type RemoteField struct {
145 Key string `json:"key"`
146 Label string `json:"label"`
147 Help string `json:"help"`
148 Kind string `json:"kind"`
149 Restart bool `json:"restart"`
150 Value string `json:"value"`
151}
152
153// RemoteConfig is GET /api/v1/admin/config van de backup server.
154type RemoteConfig struct {
155 Fields []RemoteField `json:"fields"`
156 DataDir string `json:"data_dir"`
157 Restart bool `json:"restart_pending"`
158}
159
160// Config vraagt de instellingen van de backup server op.
161func (c *Client) Config(ctx context.Context, conn Conn) (RemoteConfig, error) {
162 var out RemoteConfig
163 err := c.do(ctx, conn, http.MethodGet, "/api/v1/admin/config", nil, &out)
164 return out, err
165}
166
167// RemoteAction is één beheeractie die de backup server aanbiedt.
168type RemoteAction struct {
169 Name string `json:"name"`
170 Method string `json:"method"`
171 Path string `json:"path"`
172 Title string `json:"title"`
173 Signed bool `json:"bluegit"`
174 Params []string `json:"params"`
175 Fields []string `json:"fields"`
176}
177
178// Actions vraagt op wat de backup server aanbiedt.
179func (c *Client) Actions(ctx context.Context, conn Conn) ([]RemoteAction, error) {
180 var out struct {
181 Actions []RemoteAction `json:"actions"`
182 }
183 err := c.do(ctx, conn, http.MethodGet, "/api/v1/admin/actions", nil, &out)
184 return out.Actions, err
185}
186
187// Rollback vraagt de backup server om archive terug te zetten. De server
188// antwoordt meteen; het terugsturen naar BlueGit gebeurt daarna.
189func (c *Client) Rollback(ctx context.Context, conn Conn, archive string) error {
190 return c.do(ctx, conn, http.MethodPost, "/api/v1/rollback", map[string]string{"archive": archive}, nil)
191}
192
193// Notify meldt dat er iets veranderd is.
194func (c *Client) Notify(ctx context.Context, conn Conn) error {
195 return c.do(ctx, conn, http.MethodPost, "/api/v1/notify", map[string]any{"at": time.Now().UTC()}, nil)
196}
197
198// Notifier bundelt wijzigingen: hoogstens één melding per Delay, aan elke
199// gekoppelde backup server, met een paar nieuwe pogingen bij een fout. De
200// backup servers halen daarnaast periodiek alles op, dus een gemiste
201// melding kost alleen vertraging.
202type Notifier struct {
203 Client *Client
204 Delay time.Duration
205 once sync.Once
206 kick chan struct{}
207}
208
209// Changed zegt dat er iets veranderd is. Blokkeert nooit.
210func (n *Notifier) Changed() {
211 if n == nil {
212 return
213 }
214 n.once.Do(func() {
215 n.kick = make(chan struct{}, 1)
216 go n.loop()
217 })
218 select {
219 case n.kick <- struct{}{}:
220 default:
221 }
222}
223
224func (n *Notifier) loop() {
225 delay := n.Delay
226 if delay <= 0 {
227 delay = 2 * time.Second
228 }
229 for range n.kick {
230 time.Sleep(delay)
231 // Wat in de tussentijd binnenkwam, zit in deze melding.
232 select {
233 case <-n.kick:
234 default:
235 }
236 list, err := n.Client.Manager.List()
237 if err != nil {
238 continue
239 }
240 var wg sync.WaitGroup
241 for _, conn := range list {
242 if !conn.Connected() {
243 continue
244 }
245 wg.Add(1)
246 go func(conn Conn) {
247 defer wg.Done()
248 for try := 0; try < 4; try++ {
249 ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
250 err := n.Client.Notify(ctx, conn)
251 cancel()
252 if err == nil {
253 return
254 }
255 time.Sleep(time.Duration(1<<try) * 2 * time.Second)
256 }
257 }(conn)
258 }
259 wg.Wait()
260 }
261}
internal/backup/conn.go added +342 −0
@@ -0,0 +1,342 @@
1 // Package backup is de BlueGit-kant van bluegit-backup: de Backupserver-Keys,
2 // de koppelingen met een of meer backup servers, 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 één backup server. De key zelf wordt nooit bewaard.
33 type Conn struct {
34 ID string `json:"id"`
35 Name string `json:"name"`
36 KeyHash string `json:"key_hash"`
37 SignSecret string `json:"sign_secret"`
38 KeyHint string `json:"key_hint"`
39 CreatedAt time.Time `json:"created_at"`
40 CreatedBy string `json:"created_by"`
41 ServerURL string `json:"server_url,omitempty"`
42 ServerID string `json:"server_id,omitempty"`
43 ConnectedAt time.Time `json:"connected_at,omitempty"`
44 LastSeen time.Time `json:"last_seen,omitempty"`
45 }
46
47 // HasKey zegt of er een key is uitgegeven.
48 func (c Conn) HasKey() bool { return c.KeyHash != "" }
49
50 // Connected zegt of een backup server zich met de key heeft gemeld.
51 func (c Conn) Connected() bool { return c.HasKey() && c.ServerURL != "" }
52
53 // MaxServers begrenst het aantal backup servers per BlueGit.
54 const MaxServers = 16
55
56 // file is backup.json. Eén BlueGit kan meerdere backup servers hebben; een
57 // backup server hoort bij één BlueGit.
58 type file struct {
59 Servers []Conn `json:"servers"`
60 }
61
62 // Manager bewaart de koppelingen in de state-map.
63 type Manager struct {
64 Dir string
65 mu sync.Mutex
66 }
67
68 // HashKey is de opgeslagen vorm van de key.
69 func HashKey(key string) string {
70 s := sha256.Sum256([]byte(key))
71 return hex.EncodeToString(s[:])
72 }
73
74 // SigningSecret leidt het HMAC-geheim af uit de key. De backup server doet
75 // precies hetzelfde, zodat beide kanten verzoeken kunnen ondertekenen.
76 func SigningSecret(key string) string {
77 s := sha256.Sum256([]byte("bluegit-backup-sign:" + key))
78 return hex.EncodeToString(s[:])
79 }
80
81 // List geeft alle backup servers, in volgorde van aanmaken.
82 func (m *Manager) List() ([]Conn, error) {
83 m.mu.Lock()
84 defer m.mu.Unlock()
85 f, err := m.load()
86 return f.Servers, err
87 }
88
89 // Get zoekt een backup server op id.
90 func (m *Manager) Get(id string) (Conn, bool) {
91 list, err := m.List()
92 if err != nil {
93 return Conn{}, false
94 }
95 for _, c := range list {
96 if c.ID == id {
97 return c, true
98 }
99 }
100 return Conn{}, false
101 }
102
103 func (m *Manager) load() (file, error) {
104 var f file
105 b, err := os.ReadFile(filepath.Join(m.Dir, connFile))
106 if errors.Is(err, os.ErrNotExist) {
107 return f, nil
108 }
109 if err != nil {
110 return f, err
111 }
112 if err := json.Unmarshal(b, &f); err != nil {
113 return f, err
114 }
115 if f.Servers == nil {
116 // Oude vorm met één koppeling.
117 var one Conn
118 if json.Unmarshal(b, &one) == nil && one.HasKey() {
119 if one.ID == "" {
120 one.ID = newID()
121 }
122 if one.Name == "" {
123 one.Name = "backup"
124 }
125 f.Servers = []Conn{one}
126 // Meteen bewaren, zodat het id vast is.
127 if err := m.save(f); err != nil {
128 return f, err
129 }
130 }
131 }
132 return f, nil
133 }
134
135 func (m *Manager) save(f file) error {
136 if m.Dir == "" {
137 return errors.New("geen state-map")
138 }
139 if f.Servers == nil {
140 f.Servers = []Conn{}
141 }
142 b, err := json.MarshalIndent(f, "", " ")
143 if err != nil {
144 return err
145 }
146 tmp := filepath.Join(m.Dir, connFile+".tmp")
147 if err := os.WriteFile(tmp, b, 0o600); err != nil {
148 return err
149 }
150 return os.Rename(tmp, filepath.Join(m.Dir, connFile))
151 }
152
153 func (m *Manager) update(id string, fn func(*Conn) error) (Conn, error) {
154 m.mu.Lock()
155 defer m.mu.Unlock()
156 f, err := m.load()
157 if err != nil {
158 return Conn{}, err
159 }
160 for i := range f.Servers {
161 if f.Servers[i].ID == id {
162 if err := fn(&f.Servers[i]); err != nil {
163 return Conn{}, err
164 }
165 return f.Servers[i], m.save(f)
166 }
167 }
168 return Conn{}, ErrUnknown
169 }
170
171 // ErrUnknown: geen backup server met dat id.
172 var ErrUnknown = errors.New("onbekende backup server")
173
174 func newID() string {
175 raw := make([]byte, 6)
176 _, _ = rand.Read(raw)
177 return hex.EncodeToString(raw)
178 }
179
180 func newKey() (string, error) {
181 raw := make([]byte, 32)
182 if _, err := rand.Read(raw); err != nil {
183 return "", err
184 }
185 return KeyPrefix + hex.EncodeToString(raw), nil
186 }
187
188 // CleanName maakt van een naam iets korts en toonbaars.
189 func CleanName(name string) string {
190 name = strings.Join(strings.Fields(name), " ")
191 if r := []rune(name); len(r) > 60 {
192 name = string(r[:60])
193 }
194 return name
195 }
196
197 // Add maakt een nieuwe backup server met een eigen key. De key wordt
198 // alleen hier teruggegeven.
199 func (m *Manager) Add(name, by string) (string, Conn, error) {
200 name = CleanName(name)
201 if name == "" {
202 name = "backup"
203 }
204 key, err := newKey()
205 if err != nil {
206 return "", Conn{}, err
207 }
208 c := Conn{
209 ID: newID(), Name: name, KeyHash: HashKey(key), SignSecret: SigningSecret(key),
210 KeyHint: key[:len(KeyPrefix)+6], CreatedAt: time.Now().UTC(), CreatedBy: by,
211 }
212 m.mu.Lock()
213 defer m.mu.Unlock()
214 f, err := m.load()
215 if err != nil {
216 return "", Conn{}, err
217 }
218 if len(f.Servers) >= MaxServers {
219 return "", Conn{}, ErrTooMany
220 }
221 f.Servers = append(f.Servers, c)
222 if err := m.save(f); err != nil {
223 return "", Conn{}, err
224 }
225 return key, c, nil
226 }
227
228 // ErrTooMany: MaxServers bereikt.
229 var ErrTooMany = errors.New("te veel backup servers")
230
231 // RotateKey geeft een backup server een nieuwe key. Hij verliest zijn
232 // toegang tot hij opnieuw koppelt met de nieuwe key.
233 func (m *Manager) RotateKey(id, by string) (string, Conn, error) {
234 key, err := newKey()
235 if err != nil {
236 return "", Conn{}, err
237 }
238 c, err := m.update(id, func(c *Conn) error {
239 c.KeyHash, c.SignSecret, c.KeyHint = HashKey(key), SigningSecret(key), key[:len(KeyPrefix)+6]
240 c.CreatedAt, c.CreatedBy = time.Now().UTC(), by
241 c.ServerURL, c.ServerID, c.ConnectedAt = "", "", time.Time{}
242 return nil
243 })
244 if err != nil {
245 return "", Conn{}, err
246 }
247 return key, c, nil
248 }
249
250 // Rename geeft een backup server een andere naam.
251 func (m *Manager) Rename(id, name string) (Conn, error) {
252 name = CleanName(name)
253 if name == "" {
254 return Conn{}, errors.New("naam is leeg")
255 }
256 return m.update(id, func(c *Conn) error { c.Name = name; return nil })
257 }
258
259 // Remove trekt de key in en vergeet de backup server.
260 func (m *Manager) Remove(id string) error {
261 m.mu.Lock()
262 defer m.mu.Unlock()
263 f, err := m.load()
264 if err != nil {
265 return err
266 }
267 out := f.Servers[:0]
268 found := false
269 for _, c := range f.Servers {
270 if c.ID == id {
271 found = true
272 continue
273 }
274 out = append(out, c)
275 }
276 if !found {
277 return ErrUnknown
278 }
279 f.Servers = out
280 return m.save(f)
281 }
282
283 // Check zoekt de backup server bij key.
284 func (m *Manager) Check(key string) (Conn, bool) {
285 key = strings.TrimSpace(key)
286 if !strings.HasPrefix(key, KeyPrefix) {
287 return Conn{}, false
288 }
289 list, err := m.List()
290 if err != nil {
291 return Conn{}, false
292 }
293 h := HashKey(key)
294 for _, c := range list {
295 if c.HasKey() && subtle.ConstantTimeCompare([]byte(h), []byte(c.KeyHash)) == 1 {
296 return c, true
297 }
298 }
299 return Conn{}, false
300 }
301
302 // Connect legt het adres van een backup server vast.
303 func (m *Manager) Connect(id, serverURL, serverID string) (Conn, error) {
304 return m.update(id, func(c *Conn) error {
305 c.ServerURL = strings.TrimRight(strings.TrimSpace(serverURL), "/")
306 c.ServerID = serverID
307 c.ConnectedAt = time.Now().UTC()
308 c.LastSeen = c.ConnectedAt
309 return nil
310 })
311 }
312
313 // Seen werkt LastSeen bij, hoogstens één keer per minuut naar schijf.
314 func (m *Manager) Seen(id string) {
315 c, ok := m.Get(id)
316 if !ok || time.Since(c.LastSeen) < time.Minute {
317 return
318 }
319 _, _ = m.update(id, func(c *Conn) error { c.LastSeen = time.Now().UTC(); return nil })
320 }
321
322 // InstanceID is het vaste id van deze installatie. Het wordt één keer
323 // gemaakt en gaat niet mee in een backup.
324 func (m *Manager) InstanceID() (string, error) {
325 m.mu.Lock()
326 defer m.mu.Unlock()
327 p := filepath.Join(m.Dir, instanceFile)
328 if b, err := os.ReadFile(p); err == nil {
329 if id := strings.TrimSpace(string(b)); id != "" {
330 return id, nil
331 }
332 }
333 raw := make([]byte, 16)
334 if _, err := rand.Read(raw); err != nil {
335 return "", err
336 }
337 id := hex.EncodeToString(raw)
338 if err := os.MkdirAll(m.Dir, 0o750); err != nil {
339 return "", err
340 }
341 return id, os.WriteFile(p, []byte(id+"\n"), 0o600)
342 }
@@ -0,0 +1,342 @@
1// Package backup is de BlueGit-kant van bluegit-backup: de Backupserver-Keys,
2// de koppelingen met een of meer backup servers, 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 één backup server. De key zelf wordt nooit bewaard.
33type Conn struct {
34 ID string `json:"id"`
35 Name string `json:"name"`
36 KeyHash string `json:"key_hash"`
37 SignSecret string `json:"sign_secret"`
38 KeyHint string `json:"key_hint"`
39 CreatedAt time.Time `json:"created_at"`
40 CreatedBy string `json:"created_by"`
41 ServerURL string `json:"server_url,omitempty"`
42 ServerID string `json:"server_id,omitempty"`
43 ConnectedAt time.Time `json:"connected_at,omitempty"`
44 LastSeen time.Time `json:"last_seen,omitempty"`
45}
46
47// HasKey zegt of er een key is uitgegeven.
48func (c Conn) HasKey() bool { return c.KeyHash != "" }
49
50// Connected zegt of een backup server zich met de key heeft gemeld.
51func (c Conn) Connected() bool { return c.HasKey() && c.ServerURL != "" }
52
53// MaxServers begrenst het aantal backup servers per BlueGit.
54const MaxServers = 16
55
56// file is backup.json. Eén BlueGit kan meerdere backup servers hebben; een
57// backup server hoort bij één BlueGit.
58type file struct {
59 Servers []Conn `json:"servers"`
60}
61
62// Manager bewaart de koppelingen in de state-map.
63type Manager struct {
64 Dir string
65 mu sync.Mutex
66}
67
68// HashKey is de opgeslagen vorm van de key.
69func HashKey(key string) string {
70 s := sha256.Sum256([]byte(key))
71 return hex.EncodeToString(s[:])
72}
73
74// SigningSecret leidt het HMAC-geheim af uit de key. De backup server doet
75// precies hetzelfde, zodat beide kanten verzoeken kunnen ondertekenen.
76func SigningSecret(key string) string {
77 s := sha256.Sum256([]byte("bluegit-backup-sign:" + key))
78 return hex.EncodeToString(s[:])
79}
80
81// List geeft alle backup servers, in volgorde van aanmaken.
82func (m *Manager) List() ([]Conn, error) {
83 m.mu.Lock()
84 defer m.mu.Unlock()
85 f, err := m.load()
86 return f.Servers, err
87}
88
89// Get zoekt een backup server op id.
90func (m *Manager) Get(id string) (Conn, bool) {
91 list, err := m.List()
92 if err != nil {
93 return Conn{}, false
94 }
95 for _, c := range list {
96 if c.ID == id {
97 return c, true
98 }
99 }
100 return Conn{}, false
101}
102
103func (m *Manager) load() (file, error) {
104 var f file
105 b, err := os.ReadFile(filepath.Join(m.Dir, connFile))
106 if errors.Is(err, os.ErrNotExist) {
107 return f, nil
108 }
109 if err != nil {
110 return f, err
111 }
112 if err := json.Unmarshal(b, &f); err != nil {
113 return f, err
114 }
115 if f.Servers == nil {
116 // Oude vorm met één koppeling.
117 var one Conn
118 if json.Unmarshal(b, &one) == nil && one.HasKey() {
119 if one.ID == "" {
120 one.ID = newID()
121 }
122 if one.Name == "" {
123 one.Name = "backup"
124 }
125 f.Servers = []Conn{one}
126 // Meteen bewaren, zodat het id vast is.
127 if err := m.save(f); err != nil {
128 return f, err
129 }
130 }
131 }
132 return f, nil
133}
134
135func (m *Manager) save(f file) error {
136 if m.Dir == "" {
137 return errors.New("geen state-map")
138 }
139 if f.Servers == nil {
140 f.Servers = []Conn{}
141 }
142 b, err := json.MarshalIndent(f, "", " ")
143 if err != nil {
144 return err
145 }
146 tmp := filepath.Join(m.Dir, connFile+".tmp")
147 if err := os.WriteFile(tmp, b, 0o600); err != nil {
148 return err
149 }
150 return os.Rename(tmp, filepath.Join(m.Dir, connFile))
151}
152
153func (m *Manager) update(id string, fn func(*Conn) error) (Conn, error) {
154 m.mu.Lock()
155 defer m.mu.Unlock()
156 f, err := m.load()
157 if err != nil {
158 return Conn{}, err
159 }
160 for i := range f.Servers {
161 if f.Servers[i].ID == id {
162 if err := fn(&f.Servers[i]); err != nil {
163 return Conn{}, err
164 }
165 return f.Servers[i], m.save(f)
166 }
167 }
168 return Conn{}, ErrUnknown
169}
170
171// ErrUnknown: geen backup server met dat id.
172var ErrUnknown = errors.New("onbekende backup server")
173
174func newID() string {
175 raw := make([]byte, 6)
176 _, _ = rand.Read(raw)
177 return hex.EncodeToString(raw)
178}
179
180func newKey() (string, error) {
181 raw := make([]byte, 32)
182 if _, err := rand.Read(raw); err != nil {
183 return "", err
184 }
185 return KeyPrefix + hex.EncodeToString(raw), nil
186}
187
188// CleanName maakt van een naam iets korts en toonbaars.
189func CleanName(name string) string {
190 name = strings.Join(strings.Fields(name), " ")
191 if r := []rune(name); len(r) > 60 {
192 name = string(r[:60])
193 }
194 return name
195}
196
197// Add maakt een nieuwe backup server met een eigen key. De key wordt
198// alleen hier teruggegeven.
199func (m *Manager) Add(name, by string) (string, Conn, error) {
200 name = CleanName(name)
201 if name == "" {
202 name = "backup"
203 }
204 key, err := newKey()
205 if err != nil {
206 return "", Conn{}, err
207 }
208 c := Conn{
209 ID: newID(), Name: name, KeyHash: HashKey(key), SignSecret: SigningSecret(key),
210 KeyHint: key[:len(KeyPrefix)+6], CreatedAt: time.Now().UTC(), CreatedBy: by,
211 }
212 m.mu.Lock()
213 defer m.mu.Unlock()
214 f, err := m.load()
215 if err != nil {
216 return "", Conn{}, err
217 }
218 if len(f.Servers) >= MaxServers {
219 return "", Conn{}, ErrTooMany
220 }
221 f.Servers = append(f.Servers, c)
222 if err := m.save(f); err != nil {
223 return "", Conn{}, err
224 }
225 return key, c, nil
226}
227
228// ErrTooMany: MaxServers bereikt.
229var ErrTooMany = errors.New("te veel backup servers")
230
231// RotateKey geeft een backup server een nieuwe key. Hij verliest zijn
232// toegang tot hij opnieuw koppelt met de nieuwe key.
233func (m *Manager) RotateKey(id, by string) (string, Conn, error) {
234 key, err := newKey()
235 if err != nil {
236 return "", Conn{}, err
237 }
238 c, err := m.update(id, func(c *Conn) error {
239 c.KeyHash, c.SignSecret, c.KeyHint = HashKey(key), SigningSecret(key), key[:len(KeyPrefix)+6]
240 c.CreatedAt, c.CreatedBy = time.Now().UTC(), by
241 c.ServerURL, c.ServerID, c.ConnectedAt = "", "", time.Time{}
242 return nil
243 })
244 if err != nil {
245 return "", Conn{}, err
246 }
247 return key, c, nil
248}
249
250// Rename geeft een backup server een andere naam.
251func (m *Manager) Rename(id, name string) (Conn, error) {
252 name = CleanName(name)
253 if name == "" {
254 return Conn{}, errors.New("naam is leeg")
255 }
256 return m.update(id, func(c *Conn) error { c.Name = name; return nil })
257}
258
259// Remove trekt de key in en vergeet de backup server.
260func (m *Manager) Remove(id string) error {
261 m.mu.Lock()
262 defer m.mu.Unlock()
263 f, err := m.load()
264 if err != nil {
265 return err
266 }
267 out := f.Servers[:0]
268 found := false
269 for _, c := range f.Servers {
270 if c.ID == id {
271 found = true
272 continue
273 }
274 out = append(out, c)
275 }
276 if !found {
277 return ErrUnknown
278 }
279 f.Servers = out
280 return m.save(f)
281}
282
283// Check zoekt de backup server bij key.
284func (m *Manager) Check(key string) (Conn, bool) {
285 key = strings.TrimSpace(key)
286 if !strings.HasPrefix(key, KeyPrefix) {
287 return Conn{}, false
288 }
289 list, err := m.List()
290 if err != nil {
291 return Conn{}, false
292 }
293 h := HashKey(key)
294 for _, c := range list {
295 if c.HasKey() && subtle.ConstantTimeCompare([]byte(h), []byte(c.KeyHash)) == 1 {
296 return c, true
297 }
298 }
299 return Conn{}, false
300}
301
302// Connect legt het adres van een backup server vast.
303func (m *Manager) Connect(id, serverURL, serverID string) (Conn, error) {
304 return m.update(id, func(c *Conn) error {
305 c.ServerURL = strings.TrimRight(strings.TrimSpace(serverURL), "/")
306 c.ServerID = serverID
307 c.ConnectedAt = time.Now().UTC()
308 c.LastSeen = c.ConnectedAt
309 return nil
310 })
311}
312
313// Seen werkt LastSeen bij, hoogstens één keer per minuut naar schijf.
314func (m *Manager) Seen(id string) {
315 c, ok := m.Get(id)
316 if !ok || time.Since(c.LastSeen) < time.Minute {
317 return
318 }
319 _, _ = m.update(id, func(c *Conn) error { c.LastSeen = time.Now().UTC(); return nil })
320}
321
322// InstanceID is het vaste id van deze installatie. Het wordt één keer
323// gemaakt en gaat niet mee in een backup.
324func (m *Manager) InstanceID() (string, error) {
325 m.mu.Lock()
326 defer m.mu.Unlock()
327 p := filepath.Join(m.Dir, instanceFile)
328 if b, err := os.ReadFile(p); err == nil {
329 if id := strings.TrimSpace(string(b)); id != "" {
330 return id, nil
331 }
332 }
333 raw := make([]byte, 16)
334 if _, err := rand.Read(raw); err != nil {
335 return "", err
336 }
337 id := hex.EncodeToString(raw)
338 if err := os.MkdirAll(m.Dir, 0o750); err != nil {
339 return "", err
340 }
341 return id, os.WriteFile(p, []byte(id+"\n"), 0o600)
342}
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 +434 −0
@@ -0,0 +1,434 @@
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 "sync"
19 "time"
20 )
21
22 // Wat er in een backup zit. Logische paden beginnen met state/ of data/.
23 //
24 // state/bluegit.db consistente kopie (VACUUM INTO), niet het live bestand
25 // state/secret.key nodig om de geheimen in de database te lezen
26 // state/ssh/… SSH-hostkey
27 // state/logos/… project- en groepslogo's
28 // state/avatars/… geüploade avatars
29 // data/repos/… bare repositories
30 // data/releases/… gepubliceerde release-assets (zonder .incoming)
31 // data/artifacts/… CI-artifacts
32 //
33 // Niet mee: storage_path, cache.json, backup.json en instance_id (horen bij
34 // de installatie), data/work (tijdelijke werkmappen), lock-bestanden en
35 // symlinks.
36 var (
37 stateFiles = []string{"bluegit.db", "secret.key"}
38 stateDirs = []string{"ssh", "logos", "avatars"}
39 dataDirs = []string{"repos", "releases", "artifacts"}
40 )
41
42 // DBPath is het logische pad van de databasekopie.
43 const DBPath = "state/bluegit.db"
44
45 // Entry is één bestand in het manifest.
46 type Entry struct {
47 Path string `json:"path"`
48 Size int64 `json:"size"`
49 MTime int64 `json:"mtime"` // Unix-milliseconden
50 Mode uint32 `json:"mode"`
51 SHA256 string `json:"sha256,omitempty"`
52 }
53
54 // Manifest is de volledige lijst op één moment.
55 type Manifest struct {
56 Instance string `json:"instance_id"`
57 CreatedAt time.Time `json:"created_at"`
58 Files []Entry `json:"files"`
59 }
60
61 // Tree kent de twee mappen van een installatie.
62 type Tree struct {
63 StateDir string
64 DataDir string // leeg als er geen datadisk is
65 // Snapshot schrijft een consistente kopie van de database naar pad.
66 Snapshot func(dst string) error
67 // Conn is de koppeling waarvoor de kopie is. Elke backup server krijgt
68 // een eigen databasekopie, zodat twee servers die tegelijk een
69 // manifest ophalen elkaars kopie niet vervangen.
70 Conn string
71 }
72
73 // snapshotMu zorgt dat er maar één databasekopie tegelijk gemaakt wordt.
74 var snapshotMu sync.Mutex
75
76 func (t Tree) snapshotPath() string {
77 name := "snapshot.db"
78 if t.Conn != "" {
79 name = "snapshot-" + safeName(t.Conn) + ".db"
80 }
81 return filepath.Join(t.StateDir, ".backup", name)
82 }
83
84 // RemoveSnapshot ruimt de databasekopie van een koppeling op.
85 func (t Tree) RemoveSnapshot() { _ = os.Remove(t.snapshotPath()) }
86
87 func safeName(s string) string {
88 var b strings.Builder
89 for _, r := range s {
90 if r >= 'a' && r <= 'z' || r >= 'A' && r <= 'Z' || r >= '0' && r <= '9' || r == '-' || r == '_' {
91 b.WriteRune(r)
92 }
93 }
94 return b.String()
95 }
96
97 // Build maakt een nieuwe databasekopie en loopt alle bestanden af.
98 func (t Tree) Build(instance string) (Manifest, error) {
99 m := Manifest{Instance: instance, CreatedAt: time.Now().UTC(), Files: []Entry{}}
100 if t.Snapshot != nil {
101 snap := t.snapshotPath()
102 if err := os.MkdirAll(filepath.Dir(snap), 0o700); err != nil {
103 return m, err
104 }
105 tmp := snap + ".new"
106 snapshotMu.Lock()
107 _ = os.Remove(tmp)
108 err := t.Snapshot(tmp)
109 if err == nil {
110 err = os.Rename(tmp, snap)
111 } else {
112 err = fmt.Errorf("databasekopie: %w", err)
113 }
114 snapshotMu.Unlock()
115 if err != nil {
116 return m, err
117 }
118 e, err := entryOf(DBPath, snap, true)
119 if err != nil {
120 return m, err
121 }
122 m.Files = append(m.Files, e)
123 }
124 for _, f := range stateFiles[1:] {
125 p := filepath.Join(t.StateDir, f)
126 if e, err := entryOf("state/"+f, p, false); err == nil {
127 m.Files = append(m.Files, e)
128 }
129 }
130 for _, d := range stateDirs {
131 if err := walk(&m, "state/"+d, filepath.Join(t.StateDir, d)); err != nil {
132 return m, err
133 }
134 }
135 if t.DataDir != "" {
136 for _, d := range dataDirs {
137 if err := walk(&m, "data/"+d, filepath.Join(t.DataDir, d)); err != nil {
138 return m, err
139 }
140 }
141 }
142 sort.Slice(m.Files, func(i, j int) bool { return m.Files[i].Path < m.Files[j].Path })
143 return m, nil
144 }
145
146 func entryOf(logical, real string, hash bool) (Entry, error) {
147 fi, err := os.Lstat(real)
148 if err != nil {
149 return Entry{}, err
150 }
151 if !fi.Mode().IsRegular() {
152 return Entry{}, errors.New("geen gewoon bestand")
153 }
154 e := Entry{Path: logical, Size: fi.Size(), MTime: fi.ModTime().UnixMilli(), Mode: uint32(fi.Mode().Perm())}
155 if hash {
156 f, err := os.Open(real)
157 if err != nil {
158 return e, err
159 }
160 defer f.Close()
161 h := sha256.New()
162 if _, err := io.Copy(h, f); err != nil {
163 return e, err
164 }
165 e.SHA256 = hex.EncodeToString(h.Sum(nil))
166 }
167 return e, nil
168 }
169
170 func skipName(name string) bool {
171 return strings.HasSuffix(name, ".lock") || strings.HasPrefix(name, "tmp_") || name == ".incoming"
172 }
173
174 func walk(m *Manifest, logical, root string) error {
175 err := filepath.WalkDir(root, func(p string, d fs.DirEntry, err error) error {
176 if err != nil {
177 if errors.Is(err, fs.ErrNotExist) {
178 return nil
179 }
180 // Een map die tijdens het lopen verdwijnt (git gc) slaan we over.
181 if d != nil && d.IsDir() {
182 return fs.SkipDir
183 }
184 return nil
185 }
186 if p != root && skipName(d.Name()) {
187 if d.IsDir() {
188 return fs.SkipDir
189 }
190 return nil
191 }
192 if d.IsDir() || d.Type()&fs.ModeSymlink != 0 || !d.Type().IsRegular() {
193 return nil
194 }
195 rel, err := filepath.Rel(root, p)
196 if err != nil {
197 return nil
198 }
199 if e, err := entryOf(logical+"/"+filepath.ToSlash(rel), p, false); err == nil {
200 m.Files = append(m.Files, e)
201 }
202 return nil
203 })
204 if errors.Is(err, fs.ErrNotExist) {
205 return nil
206 }
207 return err
208 }
209
210 // CleanLogical controleert een logisch pad en geeft het genormaliseerd terug.
211 func CleanLogical(p string) (string, bool) {
212 if p == "" || strings.Contains(p, "\\") || strings.ContainsRune(p, 0) || strings.HasPrefix(p, "/") {
213 return "", false
214 }
215 c := path.Clean(p)
216 if c != p || c == "." || strings.HasPrefix(c, "../") || strings.Contains(c, "/../") {
217 return "", false
218 }
219 parts := strings.Split(c, "/")
220 for _, part := range parts {
221 if part == ".." || part == "." || part == "" {
222 return "", false
223 }
224 }
225 if len(parts) < 2 {
226 return "", false
227 }
228 switch parts[0] {
229 case "state":
230 if len(parts) == 2 && contains(stateFiles, parts[1]) {
231 return c, true
232 }
233 if len(parts) >= 3 && contains(stateDirs, parts[1]) {
234 return c, true
235 }
236 case "data":
237 if len(parts) >= 3 && contains(dataDirs, parts[1]) && parts[2] != ".incoming" {
238 return c, true
239 }
240 }
241 return "", false
242 }
243
244 func contains(list []string, v string) bool {
245 for _, x := range list {
246 if x == v {
247 return true
248 }
249 }
250 return false
251 }
252
253 // Resolve geeft het echte bestand bij een logisch pad. De database komt
254 // uit de laatste kopie van Build.
255 func (t Tree) Resolve(logical string) (string, error) {
256 c, ok := CleanLogical(logical)
257 if !ok {
258 return "", errors.New("ongeldig pad")
259 }
260 var real string
261 switch {
262 case c == DBPath:
263 real = t.snapshotPath()
264 case strings.HasPrefix(c, "state/"):
265 real = filepath.Join(t.StateDir, filepath.FromSlash(strings.TrimPrefix(c, "state/")))
266 default:
267 if t.DataDir == "" {
268 return "", errors.New("geen datadisk")
269 }
270 real = filepath.Join(t.DataDir, filepath.FromSlash(strings.TrimPrefix(c, "data/")))
271 }
272 fi, err := os.Lstat(real)
273 if err != nil {
274 return "", err
275 }
276 if !fi.Mode().IsRegular() {
277 return "", errors.New("geen gewoon bestand")
278 }
279 return real, nil
280 }
281
282 // ---------- terugzetten ----------
283
284 const restoreDir = ".restore"
285
286 type pending struct {
287 DataDir string `json:"data_dir"`
288 At time.Time `json:"at"`
289 Files int `json:"files"`
290 }
291
292 // Stage pakt een tar.gz met logische paden uit naast de live mappen. Er
293 // verandert nog niets aan de live gegevens; dat doet ApplyPending bij de
294 // volgende start. De database en secret.key moeten in het archief zitten.
295 func (t Tree) Stage(r io.Reader) (int, error) {
296 stateStage := filepath.Join(t.StateDir, restoreDir)
297 _ = os.RemoveAll(stateStage)
298 var dataStage string
299 if t.DataDir != "" {
300 dataStage = filepath.Join(t.DataDir, restoreDir)
301 _ = os.RemoveAll(dataStage)
302 }
303 fail := func(err error) (int, error) {
304 _ = os.RemoveAll(stateStage)
305 if dataStage != "" {
306 _ = os.RemoveAll(dataStage)
307 }
308 return 0, err
309 }
310 gz, err := gzip.NewReader(r)
311 if err != nil {
312 return fail(fmt.Errorf("geen gzip: %w", err))
313 }
314 tr := tar.NewReader(gz)
315 n := 0
316 seenDB, seenKey := false, false
317 for {
318 h, err := tr.Next()
319 if err == io.EOF {
320 break
321 }
322 if err != nil {
323 return fail(err)
324 }
325 if h.Typeflag == tar.TypeDir {
326 continue
327 }
328 if h.Typeflag != tar.TypeReg {
329 return fail(fmt.Errorf("%s: alleen gewone bestanden", h.Name))
330 }
331 c, ok := CleanLogical(strings.TrimPrefix(h.Name, "./"))
332 if !ok {
333 return fail(fmt.Errorf("ongeldig pad in archief: %q", h.Name))
334 }
335 var dst string
336 if strings.HasPrefix(c, "state/") {
337 dst = filepath.Join(stateStage, filepath.FromSlash(c))
338 } else {
339 if dataStage == "" {
340 return fail(errors.New("het archief bevat repositories, maar deze BlueGit heeft nog geen datadisk"))
341 }
342 dst = filepath.Join(dataStage, filepath.FromSlash(c))
343 }
344 seenDB = seenDB || c == DBPath
345 seenKey = seenKey || c == "state/secret.key"
346 if err := os.MkdirAll(filepath.Dir(dst), 0o750); err != nil {
347 return fail(err)
348 }
349 mode := os.FileMode(h.Mode).Perm() & 0o755
350 if mode == 0 {
351 mode = 0o640
352 }
353 f, err := os.OpenFile(dst, os.O_CREATE|os.O_EXCL|os.O_WRONLY, mode|0o600)
354 if err != nil {
355 return fail(err)
356 }
357 if _, err := io.Copy(f, tr); err != nil {
358 f.Close()
359 return fail(err)
360 }
361 if err := f.Close(); err != nil {
362 return fail(err)
363 }
364 _ = os.Chtimes(dst, h.ModTime, h.ModTime)
365 n++
366 }
367 if !seenDB || !seenKey {
368 return fail(errors.New("het archief mist state/bluegit.db of state/secret.key"))
369 }
370 b, _ := json.Marshal(pending{DataDir: t.DataDir, At: time.Now().UTC(), Files: n})
371 if err := os.WriteFile(filepath.Join(stateStage, "READY"), b, 0o600); err != nil {
372 return fail(err)
373 }
374 return n, nil
375 }
376
377 // HasPending zegt of er een uitgepakte backup klaarstaat.
378 func HasPending(stateDir string) bool {
379 _, err := os.Stat(filepath.Join(stateDir, restoreDir, "READY"))
380 return err == nil
381 }
382
383 // ApplyPending zet een klaarstaande backup op zijn plek. Aanroepen bij de
384 // start, vóór de database open gaat. Geen READY: niets te doen.
385 func ApplyPending(stateDir string) (bool, error) {
386 stage := filepath.Join(stateDir, restoreDir)
387 b, err := os.ReadFile(filepath.Join(stage, "READY"))
388 if errors.Is(err, os.ErrNotExist) {
389 return false, nil
390 }
391 if err != nil {
392 return false, err
393 }
394 var p pending
395 if err := json.Unmarshal(b, &p); err != nil {
396 return false, err
397 }
398 for _, f := range []string{"bluegit.db-wal", "bluegit.db-shm"} {
399 _ = os.Remove(filepath.Join(stateDir, f))
400 }
401 for _, name := range append(append([]string{}, stateFiles...), stateDirs...) {
402 if err := swap(filepath.Join(stateDir, name), filepath.Join(stage, "state", name)); err != nil {
403 return false, err
404 }
405 }
406 if p.DataDir != "" {
407 dstage := filepath.Join(p.DataDir, restoreDir)
408 for _, name := range dataDirs {
409 if err := swap(filepath.Join(p.DataDir, name), filepath.Join(dstage, "data", name)); err != nil {
410 return false, err
411 }
412 }
413 _ = os.RemoveAll(dstage)
414 }
415 _ = os.RemoveAll(filepath.Join(stateDir, ".backup"))
416 return true, os.RemoveAll(stage)
417 }
418
419 // swap vervangt live door staged. Ontbreekt staged, dan verdwijnt live.
420 func swap(live, staged string) error {
421 old := live + ".restore-old"
422 _ = os.RemoveAll(old)
423 if _, err := os.Lstat(live); err == nil {
424 if err := os.Rename(live, old); err != nil {
425 return err
426 }
427 }
428 if _, err := os.Lstat(staged); err == nil {
429 if err := os.Rename(staged, live); err != nil {
430 return err
431 }
432 }
433 return os.RemoveAll(old)
434 }
@@ -0,0 +1,434 @@
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 "sync"
19 "time"
20)
21
22// Wat er in een backup zit. Logische paden beginnen met state/ of data/.
23//
24// state/bluegit.db consistente kopie (VACUUM INTO), niet het live bestand
25// state/secret.key nodig om de geheimen in de database te lezen
26// state/ssh/… SSH-hostkey
27// state/logos/… project- en groepslogo's
28// state/avatars/… geüploade avatars
29// data/repos/… bare repositories
30// data/releases/… gepubliceerde release-assets (zonder .incoming)
31// data/artifacts/… CI-artifacts
32//
33// Niet mee: storage_path, cache.json, backup.json en instance_id (horen bij
34// de installatie), data/work (tijdelijke werkmappen), lock-bestanden en
35// symlinks.
36var (
37 stateFiles = []string{"bluegit.db", "secret.key"}
38 stateDirs = []string{"ssh", "logos", "avatars"}
39 dataDirs = []string{"repos", "releases", "artifacts"}
40)
41
42// DBPath is het logische pad van de databasekopie.
43const DBPath = "state/bluegit.db"
44
45// Entry is één bestand in het manifest.
46type Entry struct {
47 Path string `json:"path"`
48 Size int64 `json:"size"`
49 MTime int64 `json:"mtime"` // Unix-milliseconden
50 Mode uint32 `json:"mode"`
51 SHA256 string `json:"sha256,omitempty"`
52}
53
54// Manifest is de volledige lijst op één moment.
55type Manifest struct {
56 Instance string `json:"instance_id"`
57 CreatedAt time.Time `json:"created_at"`
58 Files []Entry `json:"files"`
59}
60
61// Tree kent de twee mappen van een installatie.
62type Tree struct {
63 StateDir string
64 DataDir string // leeg als er geen datadisk is
65 // Snapshot schrijft een consistente kopie van de database naar pad.
66 Snapshot func(dst string) error
67 // Conn is de koppeling waarvoor de kopie is. Elke backup server krijgt
68 // een eigen databasekopie, zodat twee servers die tegelijk een
69 // manifest ophalen elkaars kopie niet vervangen.
70 Conn string
71}
72
73// snapshotMu zorgt dat er maar één databasekopie tegelijk gemaakt wordt.
74var snapshotMu sync.Mutex
75
76func (t Tree) snapshotPath() string {
77 name := "snapshot.db"
78 if t.Conn != "" {
79 name = "snapshot-" + safeName(t.Conn) + ".db"
80 }
81 return filepath.Join(t.StateDir, ".backup", name)
82}
83
84// RemoveSnapshot ruimt de databasekopie van een koppeling op.
85func (t Tree) RemoveSnapshot() { _ = os.Remove(t.snapshotPath()) }
86
87func safeName(s string) string {
88 var b strings.Builder
89 for _, r := range s {
90 if r >= 'a' && r <= 'z' || r >= 'A' && r <= 'Z' || r >= '0' && r <= '9' || r == '-' || r == '_' {
91 b.WriteRune(r)
92 }
93 }
94 return b.String()
95}
96
97// Build maakt een nieuwe databasekopie en loopt alle bestanden af.
98func (t Tree) Build(instance string) (Manifest, error) {
99 m := Manifest{Instance: instance, CreatedAt: time.Now().UTC(), Files: []Entry{}}
100 if t.Snapshot != nil {
101 snap := t.snapshotPath()
102 if err := os.MkdirAll(filepath.Dir(snap), 0o700); err != nil {
103 return m, err
104 }
105 tmp := snap + ".new"
106 snapshotMu.Lock()
107 _ = os.Remove(tmp)
108 err := t.Snapshot(tmp)
109 if err == nil {
110 err = os.Rename(tmp, snap)
111 } else {
112 err = fmt.Errorf("databasekopie: %w", err)
113 }
114 snapshotMu.Unlock()
115 if err != nil {
116 return m, err
117 }
118 e, err := entryOf(DBPath, snap, true)
119 if err != nil {
120 return m, err
121 }
122 m.Files = append(m.Files, e)
123 }
124 for _, f := range stateFiles[1:] {
125 p := filepath.Join(t.StateDir, f)
126 if e, err := entryOf("state/"+f, p, false); err == nil {
127 m.Files = append(m.Files, e)
128 }
129 }
130 for _, d := range stateDirs {
131 if err := walk(&m, "state/"+d, filepath.Join(t.StateDir, d)); err != nil {
132 return m, err
133 }
134 }
135 if t.DataDir != "" {
136 for _, d := range dataDirs {
137 if err := walk(&m, "data/"+d, filepath.Join(t.DataDir, d)); err != nil {
138 return m, err
139 }
140 }
141 }
142 sort.Slice(m.Files, func(i, j int) bool { return m.Files[i].Path < m.Files[j].Path })
143 return m, nil
144}
145
146func entryOf(logical, real string, hash bool) (Entry, error) {
147 fi, err := os.Lstat(real)
148 if err != nil {
149 return Entry{}, err
150 }
151 if !fi.Mode().IsRegular() {
152 return Entry{}, errors.New("geen gewoon bestand")
153 }
154 e := Entry{Path: logical, Size: fi.Size(), MTime: fi.ModTime().UnixMilli(), Mode: uint32(fi.Mode().Perm())}
155 if hash {
156 f, err := os.Open(real)
157 if err != nil {
158 return e, err
159 }
160 defer f.Close()
161 h := sha256.New()
162 if _, err := io.Copy(h, f); err != nil {
163 return e, err
164 }
165 e.SHA256 = hex.EncodeToString(h.Sum(nil))
166 }
167 return e, nil
168}
169
170func skipName(name string) bool {
171 return strings.HasSuffix(name, ".lock") || strings.HasPrefix(name, "tmp_") || name == ".incoming"
172}
173
174func walk(m *Manifest, logical, root string) error {
175 err := filepath.WalkDir(root, func(p string, d fs.DirEntry, err error) error {
176 if err != nil {
177 if errors.Is(err, fs.ErrNotExist) {
178 return nil
179 }
180 // Een map die tijdens het lopen verdwijnt (git gc) slaan we over.
181 if d != nil && d.IsDir() {
182 return fs.SkipDir
183 }
184 return nil
185 }
186 if p != root && skipName(d.Name()) {
187 if d.IsDir() {
188 return fs.SkipDir
189 }
190 return nil
191 }
192 if d.IsDir() || d.Type()&fs.ModeSymlink != 0 || !d.Type().IsRegular() {
193 return nil
194 }
195 rel, err := filepath.Rel(root, p)
196 if err != nil {
197 return nil
198 }
199 if e, err := entryOf(logical+"/"+filepath.ToSlash(rel), p, false); err == nil {
200 m.Files = append(m.Files, e)
201 }
202 return nil
203 })
204 if errors.Is(err, fs.ErrNotExist) {
205 return nil
206 }
207 return err
208}
209
210// CleanLogical controleert een logisch pad en geeft het genormaliseerd terug.
211func CleanLogical(p string) (string, bool) {
212 if p == "" || strings.Contains(p, "\\") || strings.ContainsRune(p, 0) || strings.HasPrefix(p, "/") {
213 return "", false
214 }
215 c := path.Clean(p)
216 if c != p || c == "." || strings.HasPrefix(c, "../") || strings.Contains(c, "/../") {
217 return "", false
218 }
219 parts := strings.Split(c, "/")
220 for _, part := range parts {
221 if part == ".." || part == "." || part == "" {
222 return "", false
223 }
224 }
225 if len(parts) < 2 {
226 return "", false
227 }
228 switch parts[0] {
229 case "state":
230 if len(parts) == 2 && contains(stateFiles, parts[1]) {
231 return c, true
232 }
233 if len(parts) >= 3 && contains(stateDirs, parts[1]) {
234 return c, true
235 }
236 case "data":
237 if len(parts) >= 3 && contains(dataDirs, parts[1]) && parts[2] != ".incoming" {
238 return c, true
239 }
240 }
241 return "", false
242}
243
244func contains(list []string, v string) bool {
245 for _, x := range list {
246 if x == v {
247 return true
248 }
249 }
250 return false
251}
252
253// Resolve geeft het echte bestand bij een logisch pad. De database komt
254// uit de laatste kopie van Build.
255func (t Tree) Resolve(logical string) (string, error) {
256 c, ok := CleanLogical(logical)
257 if !ok {
258 return "", errors.New("ongeldig pad")
259 }
260 var real string
261 switch {
262 case c == DBPath:
263 real = t.snapshotPath()
264 case strings.HasPrefix(c, "state/"):
265 real = filepath.Join(t.StateDir, filepath.FromSlash(strings.TrimPrefix(c, "state/")))
266 default:
267 if t.DataDir == "" {
268 return "", errors.New("geen datadisk")
269 }
270 real = filepath.Join(t.DataDir, filepath.FromSlash(strings.TrimPrefix(c, "data/")))
271 }
272 fi, err := os.Lstat(real)
273 if err != nil {
274 return "", err
275 }
276 if !fi.Mode().IsRegular() {
277 return "", errors.New("geen gewoon bestand")
278 }
279 return real, nil
280}
281
282// ---------- terugzetten ----------
283
284const restoreDir = ".restore"
285
286type pending struct {
287 DataDir string `json:"data_dir"`
288 At time.Time `json:"at"`
289 Files int `json:"files"`
290}
291
292// Stage pakt een tar.gz met logische paden uit naast de live mappen. Er
293// verandert nog niets aan de live gegevens; dat doet ApplyPending bij de
294// volgende start. De database en secret.key moeten in het archief zitten.
295func (t Tree) Stage(r io.Reader) (int, error) {
296 stateStage := filepath.Join(t.StateDir, restoreDir)
297 _ = os.RemoveAll(stateStage)
298 var dataStage string
299 if t.DataDir != "" {
300 dataStage = filepath.Join(t.DataDir, restoreDir)
301 _ = os.RemoveAll(dataStage)
302 }
303 fail := func(err error) (int, error) {
304 _ = os.RemoveAll(stateStage)
305 if dataStage != "" {
306 _ = os.RemoveAll(dataStage)
307 }
308 return 0, err
309 }
310 gz, err := gzip.NewReader(r)
311 if err != nil {
312 return fail(fmt.Errorf("geen gzip: %w", err))
313 }
314 tr := tar.NewReader(gz)
315 n := 0
316 seenDB, seenKey := false, false
317 for {
318 h, err := tr.Next()
319 if err == io.EOF {
320 break
321 }
322 if err != nil {
323 return fail(err)
324 }
325 if h.Typeflag == tar.TypeDir {
326 continue
327 }
328 if h.Typeflag != tar.TypeReg {
329 return fail(fmt.Errorf("%s: alleen gewone bestanden", h.Name))
330 }
331 c, ok := CleanLogical(strings.TrimPrefix(h.Name, "./"))
332 if !ok {
333 return fail(fmt.Errorf("ongeldig pad in archief: %q", h.Name))
334 }
335 var dst string
336 if strings.HasPrefix(c, "state/") {
337 dst = filepath.Join(stateStage, filepath.FromSlash(c))
338 } else {
339 if dataStage == "" {
340 return fail(errors.New("het archief bevat repositories, maar deze BlueGit heeft nog geen datadisk"))
341 }
342 dst = filepath.Join(dataStage, filepath.FromSlash(c))
343 }
344 seenDB = seenDB || c == DBPath
345 seenKey = seenKey || c == "state/secret.key"
346 if err := os.MkdirAll(filepath.Dir(dst), 0o750); err != nil {
347 return fail(err)
348 }
349 mode := os.FileMode(h.Mode).Perm() & 0o755
350 if mode == 0 {
351 mode = 0o640
352 }
353 f, err := os.OpenFile(dst, os.O_CREATE|os.O_EXCL|os.O_WRONLY, mode|0o600)
354 if err != nil {
355 return fail(err)
356 }
357 if _, err := io.Copy(f, tr); err != nil {
358 f.Close()
359 return fail(err)
360 }
361 if err := f.Close(); err != nil {
362 return fail(err)
363 }
364 _ = os.Chtimes(dst, h.ModTime, h.ModTime)
365 n++
366 }
367 if !seenDB || !seenKey {
368 return fail(errors.New("het archief mist state/bluegit.db of state/secret.key"))
369 }
370 b, _ := json.Marshal(pending{DataDir: t.DataDir, At: time.Now().UTC(), Files: n})
371 if err := os.WriteFile(filepath.Join(stateStage, "READY"), b, 0o600); err != nil {
372 return fail(err)
373 }
374 return n, nil
375}
376
377// HasPending zegt of er een uitgepakte backup klaarstaat.
378func HasPending(stateDir string) bool {
379 _, err := os.Stat(filepath.Join(stateDir, restoreDir, "READY"))
380 return err == nil
381}
382
383// ApplyPending zet een klaarstaande backup op zijn plek. Aanroepen bij de
384// start, vóór de database open gaat. Geen READY: niets te doen.
385func ApplyPending(stateDir string) (bool, error) {
386 stage := filepath.Join(stateDir, restoreDir)
387 b, err := os.ReadFile(filepath.Join(stage, "READY"))
388 if errors.Is(err, os.ErrNotExist) {
389 return false, nil
390 }
391 if err != nil {
392 return false, err
393 }
394 var p pending
395 if err := json.Unmarshal(b, &p); err != nil {
396 return false, err
397 }
398 for _, f := range []string{"bluegit.db-wal", "bluegit.db-shm"} {
399 _ = os.Remove(filepath.Join(stateDir, f))
400 }
401 for _, name := range append(append([]string{}, stateFiles...), stateDirs...) {
402 if err := swap(filepath.Join(stateDir, name), filepath.Join(stage, "state", name)); err != nil {
403 return false, err
404 }
405 }
406 if p.DataDir != "" {
407 dstage := filepath.Join(p.DataDir, restoreDir)
408 for _, name := range dataDirs {
409 if err := swap(filepath.Join(p.DataDir, name), filepath.Join(dstage, "data", name)); err != nil {
410 return false, err
411 }
412 }
413 _ = os.RemoveAll(dstage)
414 }
415 _ = os.RemoveAll(filepath.Join(stateDir, ".backup"))
416 return true, os.RemoveAll(stage)
417}
418
419// swap vervangt live door staged. Ontbreekt staged, dan verdwijnt live.
420func swap(live, staged string) error {
421 old := live + ".restore-old"
422 _ = os.RemoveAll(old)
423 if _, err := os.Lstat(live); err == nil {
424 if err := os.Rename(live, old); err != nil {
425 return err
426 }
427 }
428 if _, err := os.Lstat(staged); err == nil {
429 if err := os.Rename(staged, live); err != nil {
430 return err
431 }
432 }
433 return os.RemoveAll(old)
434}
internal/i18n/catalog_backup.go added +312 −0
@@ -0,0 +1,312 @@
1 package i18n
2
3 func init() {
4 addCatalog(en, map[string]string{
5 "backup.back": "All backup servers",
6 "backup.servers.title": "Backup servers",
7 "backup.servers.none": "No backup servers yet. Add one, then enter its Backupserver-Key on the backup server.",
8 "backup.servers.add": "Add backup server",
9 "backup.servers.name": "Name",
10 "backup.servers.namePh": "e.g. NAS in the basement",
11 "backup.multi": "One BlueGit can have several backup servers, each with its own key. A backup server belongs to one BlueGit only.",
12 "backup.col.name": "Name",
13 "backup.col.state": "State",
14 "backup.col.address": "Address",
15 "backup.state.connected": "connected",
16 "backup.state.waiting": "waiting for the key",
17 "backup.open": "Manage",
18 "backup.rename": "Rename",
19 "backup.status.lastSync": "Last sync",
20 "backup.status.result": "Last result",
21 "backup.status.resultText": "%d files, %d fetched, %d removed",
22 "backup.status.counts": "Syncs / notifications",
23 "backup.status.mirror": "Copy",
24 "backup.status.rollback": "Rollback",
25 "backup.status.version": "Version",
26 "backup.act.sync": "Sync now",
27 "backup.act.archive": "Archive now",
28 "backup.act.prune": "Clean up now",
29 "backup.config.title": "Backup server settings",
30 "backup.config.save": "Save settings",
31 "backup.config.restart": "A change is waiting for a restart of the backup server.",
32 "backup.archive.delete": "Delete",
33 "backup.archive.deleteAsk": "Delete archive %s on the backup server?",
34 "backup.err.tooMany": "at most %d backup servers",
35 "backup.err.unknown": "unknown backup server",
36 "backup.err.action": "the backup server does not offer this action",
37 "backup.err.remote": "Backup server: %s",
38 "backup.ok.renamed": "Backup server renamed",
39 "backup.ok.action": "Done on the backup server",
40 "admin.tab.backup": "Backup",
41 "backup.title": "Backup server",
42 "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.",
43 "backup.key.title": "Backupserver-Key",
44 "backup.key.once": "Copy this key now and add it to the backup server. It is shown only once.",
45 "backup.key.active": "Active key: %s…",
46 "backup.key.by": "created by %s",
47 "backup.key.none": "No key yet. Generate one and add it to the backup server with bluegit-backup connect.",
48 "backup.key.replaceAsk": "Replace the key? The connected backup server loses access until it gets the new key.",
49 "backup.key.replace": "Generate new key",
50 "backup.key.new": "Generate Backupserver-Key",
51 "backup.key.revokeAsk": "Revoke the key and disconnect the backup server? Its archives stay on the backup server.",
52 "backup.key.revoke": "Revoke key and remove",
53 "backup.instance": "Instance ID: %s",
54 "backup.server.title": "Status",
55 "backup.server.connected": "Connected: %s",
56 "backup.server.seen": "last contact",
57 "backup.server.settings": "Archive interval %s, archives kept for %d days",
58 "backup.server.rollback": "last rollback: %s (%s)",
59 "backup.server.unreachable": "The backup server cannot be reached: %s",
60 "backup.server.none": "No backup server has connected with the key yet.",
61 "backup.archives.title": "Backup archives",
62 "backup.archives.none": "The backup server has no archives yet.",
63 "backup.warn.title": "Warning: a rollback cannot be undone",
64 "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.",
65 "backup.col.archive": "Archive",
66 "backup.col.created": "Created",
67 "backup.col.size": "Size",
68 "backup.rollback": "Roll back…",
69 "backup.rollbackAsk": "Really roll BlueGit back to %s? This cannot be undone.",
70 "backup.understood": "I understand that this cannot be undone",
71 "backup.typeName": "Type the archive name to confirm",
72 "backup.rollbackNow": "Roll back now",
73 "backup.ok.key": "New Backupserver-Key generated",
74 "backup.ok.revoked": "Key revoked; backup server removed",
75 "backup.ok.rollback": "Rollback to %s started. BlueGit restarts as soon as the backup server has sent the data.",
76 "backup.err.archive": "choose an archive",
77 "backup.err.confirm": "the typed name does not match the archive",
78 "backup.err.none": "no backup server is connected",
79 "backup.err.understood": "tick that you understand the rollback cannot be undone",
80 })
81 addCatalog(nl, map[string]string{
82 "backup.back": "Alle backup servers",
83 "backup.servers.title": "Backup servers",
84 "backup.servers.none": "Nog geen backup servers. Voeg er een toe en vul daarna de Backupserver-Key in op de backup server.",
85 "backup.servers.add": "Backup server toevoegen",
86 "backup.servers.name": "Naam",
87 "backup.servers.namePh": "bijv. NAS in de kelder",
88 "backup.multi": "Eén BlueGit kan meerdere backup servers hebben, elk met een eigen key. Een backup server hoort bij maar één BlueGit.",
89 "backup.col.name": "Naam",
90 "backup.col.state": "Status",
91 "backup.col.address": "Adres",
92 "backup.state.connected": "gekoppeld",
93 "backup.state.waiting": "wacht op de key",
94 "backup.open": "Beheren",
95 "backup.rename": "Hernoemen",
96 "backup.status.lastSync": "Laatste sync",
97 "backup.status.result": "Laatste resultaat",
98 "backup.status.resultText": "%d bestanden, %d opgehaald, %d verwijderd",
99 "backup.status.counts": "Syncs / meldingen",
100 "backup.status.mirror": "Kopie",
101 "backup.status.rollback": "Rollback",
102 "backup.status.version": "Versie",
103 "backup.act.sync": "Nu synchroniseren",
104 "backup.act.archive": "Nu archiveren",
105 "backup.act.prune": "Nu opruimen",
106 "backup.config.title": "Instellingen van de backup server",
107 "backup.config.save": "Instellingen opslaan",
108 "backup.config.restart": "Er staat een wijziging klaar die pas na een herstart van de backup server geldt.",
109 "backup.archive.delete": "Verwijderen",
110 "backup.archive.deleteAsk": "Archief %s op de backup server verwijderen?",
111 "backup.err.tooMany": "hoogstens %d backup servers",
112 "backup.err.unknown": "onbekende backup server",
113 "backup.err.action": "de backup server biedt deze actie niet aan",
114 "backup.err.remote": "Backup server: %s",
115 "backup.ok.renamed": "Backup server hernoemd",
116 "backup.ok.action": "Uitgevoerd op de backup server",
117 "admin.tab.backup": "Backup",
118 "backup.title": "Backup server",
119 "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.",
120 "backup.key.title": "Backupserver-Key",
121 "backup.key.once": "Kopieer deze key nu en voeg hem toe aan de backup server. Hij wordt maar één keer getoond.",
122 "backup.key.active": "Actieve key: %s…",
123 "backup.key.by": "gemaakt door %s",
124 "backup.key.none": "Nog geen key. Maak er een en voeg hem toe aan de backup server met bluegit-backup connect.",
125 "backup.key.replaceAsk": "Key vervangen? De gekoppelde backup server verliest zijn toegang tot hij de nieuwe key krijgt.",
126 "backup.key.replace": "Nieuwe key maken",
127 "backup.key.new": "Backupserver-Key maken",
128 "backup.key.revokeAsk": "Key intrekken en de backup server loskoppelen? Zijn archieven blijven op de backup server staan.",
129 "backup.key.revoke": "Key intrekken en verwijderen",
130 "backup.instance": "Instance-id: %s",
131 "backup.server.title": "Status",
132 "backup.server.connected": "Gekoppeld: %s",
133 "backup.server.seen": "laatste contact",
134 "backup.server.settings": "Archiefinterval %s, archieven %d dagen bewaard",
135 "backup.server.rollback": "laatste rollback: %s (%s)",
136 "backup.server.unreachable": "De backup server is niet bereikbaar: %s",
137 "backup.server.none": "Er heeft zich nog geen backup server met de key gemeld.",
138 "backup.archives.title": "Backup-archieven",
139 "backup.archives.none": "De backup server heeft nog geen archieven.",
140 "backup.warn.title": "Waarschuwing: een rollback is niet terug te draaien",
141 "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.",
142 "backup.col.archive": "Archief",
143 "backup.col.created": "Gemaakt",
144 "backup.col.size": "Grootte",
145 "backup.rollback": "Rollback…",
146 "backup.rollbackAsk": "BlueGit echt terugzetten naar %s? Dit is niet terug te draaien.",
147 "backup.understood": "Ik begrijp dat dit niet terug te draaien is",
148 "backup.typeName": "Typ de naam van het archief ter bevestiging",
149 "backup.rollbackNow": "Nu terugzetten",
150 "backup.ok.key": "Nieuwe Backupserver-Key gemaakt",
151 "backup.ok.revoked": "Key ingetrokken; backup server verwijderd",
152 "backup.ok.rollback": "Rollback naar %s gestart. BlueGit herstart zodra de backup server de gegevens heeft gestuurd.",
153 "backup.err.archive": "kies een archief",
154 "backup.err.confirm": "de getypte naam klopt niet met het archief",
155 "backup.err.none": "er is geen backup server gekoppeld",
156 "backup.err.understood": "vink aan dat je begrijpt dat de rollback niet terug te draaien is",
157 })
158 addCatalog(de, map[string]string{
159 "backup.back": "Alle Backup-Server",
160 "backup.servers.title": "Backup-Server",
161 "backup.servers.none": "Noch keine Backup-Server. Füge einen hinzu und trage dann seinen Backupserver-Key auf dem Backup-Server ein.",
162 "backup.servers.add": "Backup-Server hinzufügen",
163 "backup.servers.name": "Name",
164 "backup.servers.namePh": "z. B. NAS im Keller",
165 "backup.multi": "Ein BlueGit kann mehrere Backup-Server haben, jeder mit eigenem Key. Ein Backup-Server gehört nur zu einem BlueGit.",
166 "backup.col.name": "Name",
167 "backup.col.state": "Status",
168 "backup.col.address": "Adresse",
169 "backup.state.connected": "verbunden",
170 "backup.state.waiting": "wartet auf den Key",
171 "backup.open": "Verwalten",
172 "backup.rename": "Umbenennen",
173 "backup.status.lastSync": "Letzte Synchronisierung",
174 "backup.status.result": "Letztes Ergebnis",
175 "backup.status.resultText": "%d Dateien, %d abgerufen, %d entfernt",
176 "backup.status.counts": "Synchronisierungen / Meldungen",
177 "backup.status.mirror": "Kopie",
178 "backup.status.rollback": "Rollback",
179 "backup.status.version": "Version",
180 "backup.act.sync": "Jetzt synchronisieren",
181 "backup.act.archive": "Jetzt archivieren",
182 "backup.act.prune": "Jetzt aufräumen",
183 "backup.config.title": "Einstellungen des Backup-Servers",
184 "backup.config.save": "Einstellungen speichern",
185 "backup.config.restart": "Eine Änderung wartet auf einen Neustart des Backup-Servers.",
186 "backup.archive.delete": "Löschen",
187 "backup.archive.deleteAsk": "Archiv %s auf dem Backup-Server löschen?",
188 "backup.err.tooMany": "höchstens %d Backup-Server",
189 "backup.err.unknown": "unbekannter Backup-Server",
190 "backup.err.action": "der Backup-Server bietet diese Aktion nicht an",
191 "backup.err.remote": "Backup-Server: %s",
192 "backup.ok.renamed": "Backup-Server umbenannt",
193 "backup.ok.action": "Auf dem Backup-Server ausgeführt",
194 "admin.tab.backup": "Backup",
195 "backup.title": "Backup-Server",
196 "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.",
197 "backup.key.title": "Backupserver-Key",
198 "backup.key.once": "Kopiere diesen Key jetzt und füge ihn dem Backup-Server hinzu. Er wird nur einmal angezeigt.",
199 "backup.key.active": "Aktiver Key: %s…",
200 "backup.key.by": "erstellt von %s",
201 "backup.key.none": "Noch kein Key. Erstelle einen und füge ihn mit bluegit-backup connect dem Backup-Server hinzu.",
202 "backup.key.replaceAsk": "Key ersetzen? Der verbundene Backup-Server verliert den Zugriff, bis er den neuen Key erhält.",
203 "backup.key.replace": "Neuen Key erstellen",
204 "backup.key.new": "Backupserver-Key erstellen",
205 "backup.key.revokeAsk": "Key widerrufen und den Backup-Server trennen? Seine Archive bleiben auf dem Backup-Server.",
206 "backup.key.revoke": "Key widerrufen und entfernen",
207 "backup.instance": "Instanz-ID: %s",
208 "backup.server.title": "Status",
209 "backup.server.connected": "Verbunden: %s",
210 "backup.server.seen": "letzter Kontakt",
211 "backup.server.settings": "Archivintervall %s, Archive %d Tage aufbewahrt",
212 "backup.server.rollback": "letzter Rollback: %s (%s)",
213 "backup.server.unreachable": "Der Backup-Server ist nicht erreichbar: %s",
214 "backup.server.none": "Noch hat sich kein Backup-Server mit dem Key gemeldet.",
215 "backup.archives.title": "Backup-Archive",
216 "backup.archives.none": "Der Backup-Server hat noch keine Archive.",
217 "backup.warn.title": "Warnung: Ein Rollback kann nicht rückgängig gemacht werden",
218 "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.",
219 "backup.col.archive": "Archiv",
220 "backup.col.created": "Erstellt",
221 "backup.col.size": "Größe",
222 "backup.rollback": "Rollback…",
223 "backup.rollbackAsk": "BlueGit wirklich auf %s zurücksetzen? Das kann nicht rückgängig gemacht werden.",
224 "backup.understood": "Ich verstehe, dass dies nicht rückgängig gemacht werden kann",
225 "backup.typeName": "Gib zur Bestätigung den Archivnamen ein",
226 "backup.rollbackNow": "Jetzt zurücksetzen",
227 "backup.ok.key": "Neuer Backupserver-Key erstellt",
228 "backup.ok.revoked": "Key widerrufen; Backup-Server getrennt",
229 "backup.ok.rollback": "Rollback auf %s gestartet. BlueGit startet neu, sobald der Backup-Server die Daten gesendet hat.",
230 "backup.err.archive": "wähle ein Archiv",
231 "backup.err.confirm": "der eingegebene Name passt nicht zum Archiv",
232 "backup.err.none": "kein Backup-Server verbunden",
233 "backup.err.understood": "bestätige, dass der Rollback nicht rückgängig gemacht werden kann",
234 })
235 addCatalog(fr, map[string]string{
236 "backup.back": "Tous les serveurs de sauvegarde",
237 "backup.servers.title": "Serveurs de sauvegarde",
238 "backup.servers.none": "Aucun serveur de sauvegarde. Ajoutez-en un, puis saisissez sa Backupserver-Key sur le serveur de sauvegarde.",
239 "backup.servers.add": "Ajouter un serveur de sauvegarde",
240 "backup.servers.name": "Nom",
241 "backup.servers.namePh": "p. ex. NAS au sous-sol",
242 "backup.multi": "Un BlueGit peut avoir plusieurs serveurs de sauvegarde, chacun avec sa propre clé. Un serveur de sauvegarde n'appartient qu'à un seul BlueGit.",
243 "backup.col.name": "Nom",
244 "backup.col.state": "État",
245 "backup.col.address": "Adresse",
246 "backup.state.connected": "connecté",
247 "backup.state.waiting": "en attente de la clé",
248 "backup.open": "Gérer",
249 "backup.rename": "Renommer",
250 "backup.status.lastSync": "Dernière synchronisation",
251 "backup.status.result": "Dernier résultat",
252 "backup.status.resultText": "%d fichiers, %d récupérés, %d supprimés",
253 "backup.status.counts": "Synchronisations / notifications",
254 "backup.status.mirror": "Copie",
255 "backup.status.rollback": "Restauration",
256 "backup.status.version": "Version",
257 "backup.act.sync": "Synchroniser maintenant",
258 "backup.act.archive": "Archiver maintenant",
259 "backup.act.prune": "Nettoyer maintenant",
260 "backup.config.title": "Paramètres du serveur de sauvegarde",
261 "backup.config.save": "Enregistrer les paramètres",
262 "backup.config.restart": "Une modification attend un redémarrage du serveur de sauvegarde.",
263 "backup.archive.delete": "Supprimer",
264 "backup.archive.deleteAsk": "Supprimer l'archive %s sur le serveur de sauvegarde ?",
265 "backup.err.tooMany": "au plus %d serveurs de sauvegarde",
266 "backup.err.unknown": "serveur de sauvegarde inconnu",
267 "backup.err.action": "le serveur de sauvegarde ne propose pas cette action",
268 "backup.err.remote": "Serveur de sauvegarde : %s",
269 "backup.ok.renamed": "Serveur de sauvegarde renommé",
270 "backup.ok.action": "Effectué sur le serveur de sauvegarde",
271 "admin.tab.backup": "Sauvegarde",
272 "backup.title": "Serveur de sauvegarde",
273 "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.",
274 "backup.key.title": "Backupserver-Key",
275 "backup.key.once": "Copiez cette clé maintenant et ajoutez-la au serveur de sauvegarde. Elle n’est affichée qu’une fois.",
276 "backup.key.active": "Clé active : %s…",
277 "backup.key.by": "créée par %s",
278 "backup.key.none": "Pas encore de clé. Générez-en une et ajoutez-la au serveur avec bluegit-backup connect.",
279 "backup.key.replaceAsk": "Remplacer la clé ? Le serveur connecté perd l’accès jusqu’à ce qu’il reçoive la nouvelle clé.",
280 "backup.key.replace": "Générer une nouvelle clé",
281 "backup.key.new": "Générer une Backupserver-Key",
282 "backup.key.revokeAsk": "Révoquer la clé et déconnecter le serveur ? Ses archives restent sur le serveur de sauvegarde.",
283 "backup.key.revoke": "Révoquer la clé et supprimer",
284 "backup.instance": "ID d’instance : %s",
285 "backup.server.title": "État",
286 "backup.server.connected": "Connecté : %s",
287 "backup.server.seen": "dernier contact",
288 "backup.server.settings": "Intervalle d’archivage %s, archives conservées %d jours",
289 "backup.server.rollback": "dernier rollback : %s (%s)",
290 "backup.server.unreachable": "Le serveur de sauvegarde est injoignable : %s",
291 "backup.server.none": "Aucun serveur de sauvegarde ne s’est encore connecté avec la clé.",
292 "backup.archives.title": "Archives de sauvegarde",
293 "backup.archives.none": "Le serveur de sauvegarde n’a pas encore d’archives.",
294 "backup.warn.title": "Attention : un rollback est irréversible",
295 "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.",
296 "backup.col.archive": "Archive",
297 "backup.col.created": "Créée",
298 "backup.col.size": "Taille",
299 "backup.rollback": "Rollback…",
300 "backup.rollbackAsk": "Vraiment ramener BlueGit à %s ? C’est irréversible.",
301 "backup.understood": "Je comprends que c’est irréversible",
302 "backup.typeName": "Saisissez le nom de l’archive pour confirmer",
303 "backup.rollbackNow": "Restaurer maintenant",
304 "backup.ok.key": "Nouvelle Backupserver-Key générée",
305 "backup.ok.revoked": "Clé révoquée ; serveur déconnecté",
306 "backup.ok.rollback": "Rollback vers %s lancé. BlueGit redémarre dès que le serveur a envoyé les données.",
307 "backup.err.archive": "choisissez une archive",
308 "backup.err.confirm": "le nom saisi ne correspond pas à l’archive",
309 "backup.err.none": "aucun serveur de sauvegarde n’est connecté",
310 "backup.err.understood": "cochez que vous comprenez que le rollback est irréversible",
311 })
312 }
@@ -0,0 +1,312 @@
1package i18n
2
3func init() {
4 addCatalog(en, map[string]string{
5 "backup.back": "All backup servers",
6 "backup.servers.title": "Backup servers",
7 "backup.servers.none": "No backup servers yet. Add one, then enter its Backupserver-Key on the backup server.",
8 "backup.servers.add": "Add backup server",
9 "backup.servers.name": "Name",
10 "backup.servers.namePh": "e.g. NAS in the basement",
11 "backup.multi": "One BlueGit can have several backup servers, each with its own key. A backup server belongs to one BlueGit only.",
12 "backup.col.name": "Name",
13 "backup.col.state": "State",
14 "backup.col.address": "Address",
15 "backup.state.connected": "connected",
16 "backup.state.waiting": "waiting for the key",
17 "backup.open": "Manage",
18 "backup.rename": "Rename",
19 "backup.status.lastSync": "Last sync",
20 "backup.status.result": "Last result",
21 "backup.status.resultText": "%d files, %d fetched, %d removed",
22 "backup.status.counts": "Syncs / notifications",
23 "backup.status.mirror": "Copy",
24 "backup.status.rollback": "Rollback",
25 "backup.status.version": "Version",
26 "backup.act.sync": "Sync now",
27 "backup.act.archive": "Archive now",
28 "backup.act.prune": "Clean up now",
29 "backup.config.title": "Backup server settings",
30 "backup.config.save": "Save settings",
31 "backup.config.restart": "A change is waiting for a restart of the backup server.",
32 "backup.archive.delete": "Delete",
33 "backup.archive.deleteAsk": "Delete archive %s on the backup server?",
34 "backup.err.tooMany": "at most %d backup servers",
35 "backup.err.unknown": "unknown backup server",
36 "backup.err.action": "the backup server does not offer this action",
37 "backup.err.remote": "Backup server: %s",
38 "backup.ok.renamed": "Backup server renamed",
39 "backup.ok.action": "Done on the backup server",
40 "admin.tab.backup": "Backup",
41 "backup.title": "Backup server",
42 "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.",
43 "backup.key.title": "Backupserver-Key",
44 "backup.key.once": "Copy this key now and add it to the backup server. It is shown only once.",
45 "backup.key.active": "Active key: %s…",
46 "backup.key.by": "created by %s",
47 "backup.key.none": "No key yet. Generate one and add it to the backup server with bluegit-backup connect.",
48 "backup.key.replaceAsk": "Replace the key? The connected backup server loses access until it gets the new key.",
49 "backup.key.replace": "Generate new key",
50 "backup.key.new": "Generate Backupserver-Key",
51 "backup.key.revokeAsk": "Revoke the key and disconnect the backup server? Its archives stay on the backup server.",
52 "backup.key.revoke": "Revoke key and remove",
53 "backup.instance": "Instance ID: %s",
54 "backup.server.title": "Status",
55 "backup.server.connected": "Connected: %s",
56 "backup.server.seen": "last contact",
57 "backup.server.settings": "Archive interval %s, archives kept for %d days",
58 "backup.server.rollback": "last rollback: %s (%s)",
59 "backup.server.unreachable": "The backup server cannot be reached: %s",
60 "backup.server.none": "No backup server has connected with the key yet.",
61 "backup.archives.title": "Backup archives",
62 "backup.archives.none": "The backup server has no archives yet.",
63 "backup.warn.title": "Warning: a rollback cannot be undone",
64 "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.",
65 "backup.col.archive": "Archive",
66 "backup.col.created": "Created",
67 "backup.col.size": "Size",
68 "backup.rollback": "Roll back…",
69 "backup.rollbackAsk": "Really roll BlueGit back to %s? This cannot be undone.",
70 "backup.understood": "I understand that this cannot be undone",
71 "backup.typeName": "Type the archive name to confirm",
72 "backup.rollbackNow": "Roll back now",
73 "backup.ok.key": "New Backupserver-Key generated",
74 "backup.ok.revoked": "Key revoked; backup server removed",
75 "backup.ok.rollback": "Rollback to %s started. BlueGit restarts as soon as the backup server has sent the data.",
76 "backup.err.archive": "choose an archive",
77 "backup.err.confirm": "the typed name does not match the archive",
78 "backup.err.none": "no backup server is connected",
79 "backup.err.understood": "tick that you understand the rollback cannot be undone",
80 })
81 addCatalog(nl, map[string]string{
82 "backup.back": "Alle backup servers",
83 "backup.servers.title": "Backup servers",
84 "backup.servers.none": "Nog geen backup servers. Voeg er een toe en vul daarna de Backupserver-Key in op de backup server.",
85 "backup.servers.add": "Backup server toevoegen",
86 "backup.servers.name": "Naam",
87 "backup.servers.namePh": "bijv. NAS in de kelder",
88 "backup.multi": "Eén BlueGit kan meerdere backup servers hebben, elk met een eigen key. Een backup server hoort bij maar één BlueGit.",
89 "backup.col.name": "Naam",
90 "backup.col.state": "Status",
91 "backup.col.address": "Adres",
92 "backup.state.connected": "gekoppeld",
93 "backup.state.waiting": "wacht op de key",
94 "backup.open": "Beheren",
95 "backup.rename": "Hernoemen",
96 "backup.status.lastSync": "Laatste sync",
97 "backup.status.result": "Laatste resultaat",
98 "backup.status.resultText": "%d bestanden, %d opgehaald, %d verwijderd",
99 "backup.status.counts": "Syncs / meldingen",
100 "backup.status.mirror": "Kopie",
101 "backup.status.rollback": "Rollback",
102 "backup.status.version": "Versie",
103 "backup.act.sync": "Nu synchroniseren",
104 "backup.act.archive": "Nu archiveren",
105 "backup.act.prune": "Nu opruimen",
106 "backup.config.title": "Instellingen van de backup server",
107 "backup.config.save": "Instellingen opslaan",
108 "backup.config.restart": "Er staat een wijziging klaar die pas na een herstart van de backup server geldt.",
109 "backup.archive.delete": "Verwijderen",
110 "backup.archive.deleteAsk": "Archief %s op de backup server verwijderen?",
111 "backup.err.tooMany": "hoogstens %d backup servers",
112 "backup.err.unknown": "onbekende backup server",
113 "backup.err.action": "de backup server biedt deze actie niet aan",
114 "backup.err.remote": "Backup server: %s",
115 "backup.ok.renamed": "Backup server hernoemd",
116 "backup.ok.action": "Uitgevoerd op de backup server",
117 "admin.tab.backup": "Backup",
118 "backup.title": "Backup server",
119 "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.",
120 "backup.key.title": "Backupserver-Key",
121 "backup.key.once": "Kopieer deze key nu en voeg hem toe aan de backup server. Hij wordt maar één keer getoond.",
122 "backup.key.active": "Actieve key: %s…",
123 "backup.key.by": "gemaakt door %s",
124 "backup.key.none": "Nog geen key. Maak er een en voeg hem toe aan de backup server met bluegit-backup connect.",
125 "backup.key.replaceAsk": "Key vervangen? De gekoppelde backup server verliest zijn toegang tot hij de nieuwe key krijgt.",
126 "backup.key.replace": "Nieuwe key maken",
127 "backup.key.new": "Backupserver-Key maken",
128 "backup.key.revokeAsk": "Key intrekken en de backup server loskoppelen? Zijn archieven blijven op de backup server staan.",
129 "backup.key.revoke": "Key intrekken en verwijderen",
130 "backup.instance": "Instance-id: %s",
131 "backup.server.title": "Status",
132 "backup.server.connected": "Gekoppeld: %s",
133 "backup.server.seen": "laatste contact",
134 "backup.server.settings": "Archiefinterval %s, archieven %d dagen bewaard",
135 "backup.server.rollback": "laatste rollback: %s (%s)",
136 "backup.server.unreachable": "De backup server is niet bereikbaar: %s",
137 "backup.server.none": "Er heeft zich nog geen backup server met de key gemeld.",
138 "backup.archives.title": "Backup-archieven",
139 "backup.archives.none": "De backup server heeft nog geen archieven.",
140 "backup.warn.title": "Waarschuwing: een rollback is niet terug te draaien",
141 "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.",
142 "backup.col.archive": "Archief",
143 "backup.col.created": "Gemaakt",
144 "backup.col.size": "Grootte",
145 "backup.rollback": "Rollback…",
146 "backup.rollbackAsk": "BlueGit echt terugzetten naar %s? Dit is niet terug te draaien.",
147 "backup.understood": "Ik begrijp dat dit niet terug te draaien is",
148 "backup.typeName": "Typ de naam van het archief ter bevestiging",
149 "backup.rollbackNow": "Nu terugzetten",
150 "backup.ok.key": "Nieuwe Backupserver-Key gemaakt",
151 "backup.ok.revoked": "Key ingetrokken; backup server verwijderd",
152 "backup.ok.rollback": "Rollback naar %s gestart. BlueGit herstart zodra de backup server de gegevens heeft gestuurd.",
153 "backup.err.archive": "kies een archief",
154 "backup.err.confirm": "de getypte naam klopt niet met het archief",
155 "backup.err.none": "er is geen backup server gekoppeld",
156 "backup.err.understood": "vink aan dat je begrijpt dat de rollback niet terug te draaien is",
157 })
158 addCatalog(de, map[string]string{
159 "backup.back": "Alle Backup-Server",
160 "backup.servers.title": "Backup-Server",
161 "backup.servers.none": "Noch keine Backup-Server. Füge einen hinzu und trage dann seinen Backupserver-Key auf dem Backup-Server ein.",
162 "backup.servers.add": "Backup-Server hinzufügen",
163 "backup.servers.name": "Name",
164 "backup.servers.namePh": "z. B. NAS im Keller",
165 "backup.multi": "Ein BlueGit kann mehrere Backup-Server haben, jeder mit eigenem Key. Ein Backup-Server gehört nur zu einem BlueGit.",
166 "backup.col.name": "Name",
167 "backup.col.state": "Status",
168 "backup.col.address": "Adresse",
169 "backup.state.connected": "verbunden",
170 "backup.state.waiting": "wartet auf den Key",
171 "backup.open": "Verwalten",
172 "backup.rename": "Umbenennen",
173 "backup.status.lastSync": "Letzte Synchronisierung",
174 "backup.status.result": "Letztes Ergebnis",
175 "backup.status.resultText": "%d Dateien, %d abgerufen, %d entfernt",
176 "backup.status.counts": "Synchronisierungen / Meldungen",
177 "backup.status.mirror": "Kopie",
178 "backup.status.rollback": "Rollback",
179 "backup.status.version": "Version",
180 "backup.act.sync": "Jetzt synchronisieren",
181 "backup.act.archive": "Jetzt archivieren",
182 "backup.act.prune": "Jetzt aufräumen",
183 "backup.config.title": "Einstellungen des Backup-Servers",
184 "backup.config.save": "Einstellungen speichern",
185 "backup.config.restart": "Eine Änderung wartet auf einen Neustart des Backup-Servers.",
186 "backup.archive.delete": "Löschen",
187 "backup.archive.deleteAsk": "Archiv %s auf dem Backup-Server löschen?",
188 "backup.err.tooMany": "höchstens %d Backup-Server",
189 "backup.err.unknown": "unbekannter Backup-Server",
190 "backup.err.action": "der Backup-Server bietet diese Aktion nicht an",
191 "backup.err.remote": "Backup-Server: %s",
192 "backup.ok.renamed": "Backup-Server umbenannt",
193 "backup.ok.action": "Auf dem Backup-Server ausgeführt",
194 "admin.tab.backup": "Backup",
195 "backup.title": "Backup-Server",
196 "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.",
197 "backup.key.title": "Backupserver-Key",
198 "backup.key.once": "Kopiere diesen Key jetzt und füge ihn dem Backup-Server hinzu. Er wird nur einmal angezeigt.",
199 "backup.key.active": "Aktiver Key: %s…",
200 "backup.key.by": "erstellt von %s",
201 "backup.key.none": "Noch kein Key. Erstelle einen und füge ihn mit bluegit-backup connect dem Backup-Server hinzu.",
202 "backup.key.replaceAsk": "Key ersetzen? Der verbundene Backup-Server verliert den Zugriff, bis er den neuen Key erhält.",
203 "backup.key.replace": "Neuen Key erstellen",
204 "backup.key.new": "Backupserver-Key erstellen",
205 "backup.key.revokeAsk": "Key widerrufen und den Backup-Server trennen? Seine Archive bleiben auf dem Backup-Server.",
206 "backup.key.revoke": "Key widerrufen und entfernen",
207 "backup.instance": "Instanz-ID: %s",
208 "backup.server.title": "Status",
209 "backup.server.connected": "Verbunden: %s",
210 "backup.server.seen": "letzter Kontakt",
211 "backup.server.settings": "Archivintervall %s, Archive %d Tage aufbewahrt",
212 "backup.server.rollback": "letzter Rollback: %s (%s)",
213 "backup.server.unreachable": "Der Backup-Server ist nicht erreichbar: %s",
214 "backup.server.none": "Noch hat sich kein Backup-Server mit dem Key gemeldet.",
215 "backup.archives.title": "Backup-Archive",
216 "backup.archives.none": "Der Backup-Server hat noch keine Archive.",
217 "backup.warn.title": "Warnung: Ein Rollback kann nicht rückgängig gemacht werden",
218 "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.",
219 "backup.col.archive": "Archiv",
220 "backup.col.created": "Erstellt",
221 "backup.col.size": "Größe",
222 "backup.rollback": "Rollback…",
223 "backup.rollbackAsk": "BlueGit wirklich auf %s zurücksetzen? Das kann nicht rückgängig gemacht werden.",
224 "backup.understood": "Ich verstehe, dass dies nicht rückgängig gemacht werden kann",
225 "backup.typeName": "Gib zur Bestätigung den Archivnamen ein",
226 "backup.rollbackNow": "Jetzt zurücksetzen",
227 "backup.ok.key": "Neuer Backupserver-Key erstellt",
228 "backup.ok.revoked": "Key widerrufen; Backup-Server getrennt",
229 "backup.ok.rollback": "Rollback auf %s gestartet. BlueGit startet neu, sobald der Backup-Server die Daten gesendet hat.",
230 "backup.err.archive": "wähle ein Archiv",
231 "backup.err.confirm": "der eingegebene Name passt nicht zum Archiv",
232 "backup.err.none": "kein Backup-Server verbunden",
233 "backup.err.understood": "bestätige, dass der Rollback nicht rückgängig gemacht werden kann",
234 })
235 addCatalog(fr, map[string]string{
236 "backup.back": "Tous les serveurs de sauvegarde",
237 "backup.servers.title": "Serveurs de sauvegarde",
238 "backup.servers.none": "Aucun serveur de sauvegarde. Ajoutez-en un, puis saisissez sa Backupserver-Key sur le serveur de sauvegarde.",
239 "backup.servers.add": "Ajouter un serveur de sauvegarde",
240 "backup.servers.name": "Nom",
241 "backup.servers.namePh": "p. ex. NAS au sous-sol",
242 "backup.multi": "Un BlueGit peut avoir plusieurs serveurs de sauvegarde, chacun avec sa propre clé. Un serveur de sauvegarde n'appartient qu'à un seul BlueGit.",
243 "backup.col.name": "Nom",
244 "backup.col.state": "État",
245 "backup.col.address": "Adresse",
246 "backup.state.connected": "connecté",
247 "backup.state.waiting": "en attente de la clé",
248 "backup.open": "Gérer",
249 "backup.rename": "Renommer",
250 "backup.status.lastSync": "Dernière synchronisation",
251 "backup.status.result": "Dernier résultat",
252 "backup.status.resultText": "%d fichiers, %d récupérés, %d supprimés",
253 "backup.status.counts": "Synchronisations / notifications",
254 "backup.status.mirror": "Copie",
255 "backup.status.rollback": "Restauration",
256 "backup.status.version": "Version",
257 "backup.act.sync": "Synchroniser maintenant",
258 "backup.act.archive": "Archiver maintenant",
259 "backup.act.prune": "Nettoyer maintenant",
260 "backup.config.title": "Paramètres du serveur de sauvegarde",
261 "backup.config.save": "Enregistrer les paramètres",
262 "backup.config.restart": "Une modification attend un redémarrage du serveur de sauvegarde.",
263 "backup.archive.delete": "Supprimer",
264 "backup.archive.deleteAsk": "Supprimer l'archive %s sur le serveur de sauvegarde ?",
265 "backup.err.tooMany": "au plus %d serveurs de sauvegarde",
266 "backup.err.unknown": "serveur de sauvegarde inconnu",
267 "backup.err.action": "le serveur de sauvegarde ne propose pas cette action",
268 "backup.err.remote": "Serveur de sauvegarde : %s",
269 "backup.ok.renamed": "Serveur de sauvegarde renommé",
270 "backup.ok.action": "Effectué sur le serveur de sauvegarde",
271 "admin.tab.backup": "Sauvegarde",
272 "backup.title": "Serveur de sauvegarde",
273 "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.",
274 "backup.key.title": "Backupserver-Key",
275 "backup.key.once": "Copiez cette clé maintenant et ajoutez-la au serveur de sauvegarde. Elle n’est affichée qu’une fois.",
276 "backup.key.active": "Clé active : %s…",
277 "backup.key.by": "créée par %s",
278 "backup.key.none": "Pas encore de clé. Générez-en une et ajoutez-la au serveur avec bluegit-backup connect.",
279 "backup.key.replaceAsk": "Remplacer la clé ? Le serveur connecté perd l’accès jusqu’à ce qu’il reçoive la nouvelle clé.",
280 "backup.key.replace": "Générer une nouvelle clé",
281 "backup.key.new": "Générer une Backupserver-Key",
282 "backup.key.revokeAsk": "Révoquer la clé et déconnecter le serveur ? Ses archives restent sur le serveur de sauvegarde.",
283 "backup.key.revoke": "Révoquer la clé et supprimer",
284 "backup.instance": "ID d’instance : %s",
285 "backup.server.title": "État",
286 "backup.server.connected": "Connecté : %s",
287 "backup.server.seen": "dernier contact",
288 "backup.server.settings": "Intervalle d’archivage %s, archives conservées %d jours",
289 "backup.server.rollback": "dernier rollback : %s (%s)",
290 "backup.server.unreachable": "Le serveur de sauvegarde est injoignable : %s",
291 "backup.server.none": "Aucun serveur de sauvegarde ne s’est encore connecté avec la clé.",
292 "backup.archives.title": "Archives de sauvegarde",
293 "backup.archives.none": "Le serveur de sauvegarde n’a pas encore d’archives.",
294 "backup.warn.title": "Attention : un rollback est irréversible",
295 "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.",
296 "backup.col.archive": "Archive",
297 "backup.col.created": "Créée",
298 "backup.col.size": "Taille",
299 "backup.rollback": "Rollback…",
300 "backup.rollbackAsk": "Vraiment ramener BlueGit à %s ? C’est irréversible.",
301 "backup.understood": "Je comprends que c’est irréversible",
302 "backup.typeName": "Saisissez le nom de l’archive pour confirmer",
303 "backup.rollbackNow": "Restaurer maintenant",
304 "backup.ok.key": "Nouvelle Backupserver-Key générée",
305 "backup.ok.revoked": "Clé révoquée ; serveur déconnecté",
306 "backup.ok.rollback": "Rollback vers %s lancé. BlueGit redémarre dès que le serveur a envoyé les données.",
307 "backup.err.archive": "choisissez une archive",
308 "backup.err.confirm": "le nom saisi ne correspond pas à l’archive",
309 "backup.err.none": "aucun serveur de sauvegarde n’est connecté",
310 "backup.err.understood": "cochez que vous comprenez que le rollback est irréversible",
311 })
312}
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" || page == "adminbackupserver") && 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" || page == "adminbackupserver"
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" || page == "adminbackupserver") && 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" || page == "adminbackupserver"
39}
40}
40
41
41func (s *Server) mountAdmin(mux *http.ServeMux) {
42func (s *Server) mountAdmin(mux *http.ServeMux) {
internal/server/api_routes.go +7 −0
@@ -191,5 +191,12 @@ 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, "List backup servers (instance admin)", (*Server).apiAdminBackup},
195 {http.MethodPost, "/api/v1/admin/backup/servers", access.ScopeAdmin, authUser, "Add a backup server. Body {name}. Returns its Backupserver-Key once (instance admin)", (*Server).apiAdminBackupAdd},
196 {http.MethodGet, "/api/v1/admin/backup/servers/{id}", access.ScopeAdmin, authUser, "Backup server with its status, archives and settings, as the backup server reports them (instance admin)", (*Server).apiAdminBackupServer},
197 {http.MethodPut, "/api/v1/admin/backup/servers/{id}", access.ScopeAdmin, authUser, "Rename a backup server. Body {name} (instance admin)", (*Server).apiAdminBackupRename},
198 {http.MethodPost, "/api/v1/admin/backup/servers/{id}/key", access.ScopeAdmin, authUser, "New Backupserver-Key for this backup server; shown once, the old key stops working (instance admin)", (*Server).apiAdminBackupKey},
199 {http.MethodDelete, "/api/v1/admin/backup/servers/{id}", access.ScopeAdmin, authUser, "Disconnect and forget a backup server; its archives stay there (instance admin)", (*Server).apiAdminBackupRemove},
200 {http.MethodPost, "/api/v1/admin/backup/servers/{id}/actions/{name}", access.ScopeAdmin, authUser, "Run an action of the backup server (status, config, config.update, sync, archive, prune, archives, archive.delete, rollback, disconnect). rollback is irreversible and needs {archive, confirm: archive name again} (instance admin)", (*Server).apiAdminBackupAction},
194 201 {http.MethodPost, "/api/v1/admin/cache/clear", access.ScopeAdmin, authUser, "Clear the read cache", (*Server).apiAdminCacheClear},
195 202 }
@@ -191,5 +191,12 @@ 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, "List backup servers (instance admin)", (*Server).apiAdminBackup},
195 {http.MethodPost, "/api/v1/admin/backup/servers", access.ScopeAdmin, authUser, "Add a backup server. Body {name}. Returns its Backupserver-Key once (instance admin)", (*Server).apiAdminBackupAdd},
196 {http.MethodGet, "/api/v1/admin/backup/servers/{id}", access.ScopeAdmin, authUser, "Backup server with its status, archives and settings, as the backup server reports them (instance admin)", (*Server).apiAdminBackupServer},
197 {http.MethodPut, "/api/v1/admin/backup/servers/{id}", access.ScopeAdmin, authUser, "Rename a backup server. Body {name} (instance admin)", (*Server).apiAdminBackupRename},
198 {http.MethodPost, "/api/v1/admin/backup/servers/{id}/key", access.ScopeAdmin, authUser, "New Backupserver-Key for this backup server; shown once, the old key stops working (instance admin)", (*Server).apiAdminBackupKey},
199 {http.MethodDelete, "/api/v1/admin/backup/servers/{id}", access.ScopeAdmin, authUser, "Disconnect and forget a backup server; its archives stay there (instance admin)", (*Server).apiAdminBackupRemove},
200 {http.MethodPost, "/api/v1/admin/backup/servers/{id}/actions/{name}", access.ScopeAdmin, authUser, "Run an action of the backup server (status, config, config.update, sync, archive, prune, archives, archive.delete, rollback, disconnect). rollback is irreversible and needs {archive, confirm: archive name again} (instance admin)", (*Server).apiAdminBackupAction},
194 {http.MethodPost, "/api/v1/admin/cache/clear", access.ScopeAdmin, authUser, "Clear the read cache", (*Server).apiAdminCacheClear},
201 {http.MethodPost, "/api/v1/admin/cache/clear", access.ScopeAdmin, authUser, "Clear the read cache", (*Server).apiAdminCacheClear},
195}
202}
internal/server/backup.go added +742 −0
@@ -0,0 +1,742 @@
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: een of meer losse backup servers (repo bluegit-backup)
21 // halen elk met een eigen Backupserver-Key alle gegevens op, krijgen een
22 // melding bij elke wijziging, en kunnen een archief terugsturen (rollback).
23 // Vanuit BlueGit is elke backup server ook te bedienen: BlueGit stuurt
24 // ondertekende verzoeken naar de beheer-API van de backup server. Het
25 // protocol staat in docs/BACKUP.md.
26
27 // maxRestoreBytes begrenst een terug te zetten archief (64 GiB).
28 const maxRestoreBytes = 64 << 30
29
30 var (
31 restoreBusy atomic.Bool
32 backupFails updateLimiter
33 )
34
35 // BackupView is de stand op Beheer > Backup.
36 type BackupView struct {
37 InstanceID string
38 Servers []backup.Conn
39 Max int
40 // Current is de geopende backup server (detailpagina).
41 Current *BackupServerView
42 NewKey string
43 }
44
45 // BackupServerView is één backup server met wat hij zelf meldt.
46 type BackupServerView struct {
47 Conn backup.Conn
48 Remote *backup.RemoteStatus
49 Archives []backup.Archive
50 Config *backup.RemoteConfig
51 RemoteErr string
52 }
53
54 func (s *Server) backupInit() {
55 s.backupOnce.Do(func() {
56 s.backupMgr = &backup.Manager{Dir: s.StateDir}
57 s.backupHTTP = &http.Client{Timeout: 15 * time.Second}
58 s.backupNote = &backup.Notifier{Client: s.backupClient()}
59 })
60 }
61
62 func (s *Server) backupClient() *backup.Client {
63 return &backup.Client{Manager: s.backupMgr, HTTP: s.backupHTTP}
64 }
65
66 // BackupManager geeft de koppeling (ook voor tests).
67 func (s *Server) BackupManager() *backup.Manager {
68 s.backupInit()
69 return s.backupMgr
70 }
71
72 // BackupChanged meldt een wijziging aan de gekoppelde backup server.
73 func (s *Server) BackupChanged() {
74 if s.StateDir == "" {
75 return
76 }
77 s.backupInit()
78 s.backupNote.Changed()
79 }
80
81 func (s *Server) backupTree(conn string) backup.Tree {
82 return backup.Tree{
83 StateDir: s.StateDir, DataDir: s.StoragePath(), Conn: conn,
84 Snapshot: func(dst string) error { return s.Store.Snapshot(context.Background(), dst) },
85 }
86 }
87
88 func (s *Server) mountBackup(mux *http.ServeMux) {
89 mux.HandleFunc("GET /api/v1/backup/info", s.backupKeyed(s.backupInfo))
90 mux.HandleFunc("POST /api/v1/backup/connect", s.backupKeyed(s.backupConnect))
91 mux.HandleFunc("GET /api/v1/backup/manifest", s.backupKeyed(s.backupManifest))
92 mux.HandleFunc("GET /api/v1/backup/file", s.backupKeyed(s.backupFile))
93 mux.HandleFunc("POST /api/v1/backup/restore", s.backupKeyed(s.backupRestore))
94 mux.HandleFunc("GET /admin/backup", s.adminBackup)
95 mux.HandleFunc("POST /admin/backup/servers", s.adminBackupAdd)
96 mux.HandleFunc("GET /admin/backup/s/{id}", s.adminBackupServer)
97 mux.HandleFunc("POST /admin/backup/s/{id}/key", s.adminBackupKey)
98 mux.HandleFunc("POST /admin/backup/s/{id}/rename", s.adminBackupRename)
99 mux.HandleFunc("POST /admin/backup/s/{id}/remove", s.adminBackupRemove)
100 mux.HandleFunc("POST /admin/backup/s/{id}/act/{name}", s.adminBackupAct)
101 }
102
103 // backupWatch meldt na elk schrijvend verzoek een wijziging. De backup
104 // server haalt daarna alleen op wat veranderd is; een melding te veel kost
105 // dus weinig. Tijdens het terugzetten van een backup wordt niet geschreven.
106 func (s *Server) backupWatch(next http.Handler) http.Handler {
107 return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
108 switch r.Method {
109 case http.MethodGet, http.MethodHead, http.MethodOptions:
110 next.ServeHTTP(w, r)
111 return
112 }
113 if restoreBusy.Load() {
114 http.Error(w, "backup wordt teruggezet; BlueGit herstart zo\n", http.StatusServiceUnavailable)
115 return
116 }
117 next.ServeHTTP(w, r)
118 if strings.HasPrefix(r.URL.Path, "/api/v1/backup/") || strings.HasSuffix(r.URL.Path, "/git-upload-pack") {
119 return
120 }
121 s.BackupChanged()
122 })
123 }
124
125 func backupErr(w http.ResponseWriter, code int, msg string) {
126 writeJSON(w, code, map[string]string{"error": msg})
127 }
128
129 // backupKeyed eist de Backupserver-Key als bearer-token.
130 func (s *Server) backupKeyed(h func(http.ResponseWriter, *http.Request)) http.HandlerFunc {
131 return func(w http.ResponseWriter, r *http.Request) {
132 w.Header().Set("Cache-Control", "no-store")
133 if s.StateDir == "" {
134 backupErr(w, http.StatusNotFound, "backup niet beschikbaar")
135 return
136 }
137 s.backupInit()
138 conn, ok := s.backupMgr.Check(bearer(r))
139 if !ok {
140 // Alleen mislukte pogingen tellen: hoogstens 5 per minuut per IP.
141 if !backupFails.allow(clientIP(r), time.Now()) {
142 backupErr(w, http.StatusTooManyRequests, "te veel mislukte pogingen")
143 return
144 }
145 backupErr(w, http.StatusUnauthorized, "ongeldige Backupserver-Key")
146 return
147 }
148 s.backupMgr.Seen(conn.ID)
149 h(w, r.WithContext(context.WithValue(r.Context(), backupConnKey{}, conn)))
150 }
151 }
152
153 type backupConnKey struct{}
154
155 func backupConnOf(r *http.Request) backup.Conn {
156 c, _ := r.Context().Value(backupConnKey{}).(backup.Conn)
157 return c
158 }
159
160 func (s *Server) backupInfo(w http.ResponseWriter, r *http.Request) {
161 id, err := s.backupMgr.InstanceID()
162 if err != nil {
163 backupErr(w, 500, err.Error())
164 return
165 }
166 c := backupConnOf(r)
167 writeJSON(w, http.StatusOK, map[string]any{
168 "instance_id": id, "base_url": s.Cfg.BaseURL, "name": c.Name, "server_url": c.ServerURL, "server_id": c.ServerID,
169 "has_storage": s.StoragePath() != "",
170 })
171 }
172
173 func (s *Server) backupConnect(w http.ResponseWriter, r *http.Request) {
174 var in struct {
175 ServerURL string `json:"server_url"`
176 ServerID string `json:"server_id"`
177 }
178 if err := json.NewDecoder(io.LimitReader(r.Body, 1<<16)).Decode(&in); err != nil {
179 backupErr(w, 400, "ongeldige JSON")
180 return
181 }
182 u, err := url.Parse(strings.TrimSpace(in.ServerURL))
183 if err != nil || (u.Scheme != "http" && u.Scheme != "https") || u.Host == "" {
184 backupErr(w, 400, "server_url moet een http(s)-adres zijn")
185 return
186 }
187 c, err := s.backupMgr.Connect(backupConnOf(r).ID, u.String(), strings.TrimSpace(in.ServerID))
188 if err != nil {
189 backupErr(w, 500, err.Error())
190 return
191 }
192 id, _ := s.backupMgr.InstanceID()
193 if s.Log != nil {
194 s.Log.Info("backup audit", "action", "connect", "id", c.ID, "name", c.Name, "server", c.ServerURL, "server_id", c.ServerID)
195 }
196 writeJSON(w, http.StatusOK, map[string]any{"instance_id": id, "server_url": c.ServerURL})
197 }
198
199 func (s *Server) backupManifest(w http.ResponseWriter, r *http.Request) {
200 id, err := s.backupMgr.InstanceID()
201 if err != nil {
202 backupErr(w, 500, err.Error())
203 return
204 }
205 m, err := s.backupTree(backupConnOf(r).ID).Build(id)
206 if err != nil {
207 backupErr(w, 500, err.Error())
208 return
209 }
210 writeJSON(w, http.StatusOK, m)
211 }
212
213 func (s *Server) backupFile(w http.ResponseWriter, r *http.Request) {
214 real, err := s.backupTree(backupConnOf(r).ID).Resolve(r.URL.Query().Get("path"))
215 if err != nil {
216 backupErr(w, http.StatusNotFound, "bestand niet gevonden")
217 return
218 }
219 f, err := os.Open(real)
220 if err != nil {
221 backupErr(w, http.StatusNotFound, "bestand niet gevonden")
222 return
223 }
224 defer f.Close()
225 fi, err := f.Stat()
226 if err != nil {
227 backupErr(w, 500, err.Error())
228 return
229 }
230 w.Header().Set("Content-Type", "application/octet-stream")
231 w.Header().Set("Content-Length", strconv.FormatInt(fi.Size(), 10))
232 w.Header().Set("X-Backup-Mtime", strconv.FormatInt(fi.ModTime().UnixMilli(), 10))
233 _, _ = io.Copy(w, f)
234 }
235
236 // backupRestore neemt een tar.gz aan, pakt het naast de live gegevens uit
237 // en herstart BlueGit. Bij de start komt de backup op zijn plek.
238 func (s *Server) backupRestore(w http.ResponseWriter, r *http.Request) {
239 if !s.restoring.TryLock() {
240 backupErr(w, http.StatusConflict, "er loopt al een restore")
241 return
242 }
243 defer s.restoring.Unlock()
244 restoreBusy.Store(true)
245 n, err := s.backupTree("").Stage(http.MaxBytesReader(w, r.Body, maxRestoreBytes))
246 if err != nil {
247 restoreBusy.Store(false)
248 if s.Log != nil {
249 s.Log.Warn("backup audit", "action", "restore_failed", "err", err)
250 }
251 backupErr(w, http.StatusBadRequest, err.Error())
252 return
253 }
254 if s.Log != nil {
255 s.Log.Warn("backup audit", "action", "restore_staged", "files", n, "id", backupConnOf(r).ID, "name", backupConnOf(r).Name)
256 }
257 writeJSON(w, http.StatusAccepted, map[string]any{"files": n, "restarting": s.RequestRestart != nil})
258 if f, ok := w.(http.Flusher); ok {
259 f.Flush()
260 }
261 if s.RequestRestart != nil {
262 go func() {
263 time.Sleep(300 * time.Millisecond)
264 s.RequestRestart()
265 }()
266 }
267 }
268
269 // ---------- Beheer > Backup ----------
270
271 func (s *Server) backupList() *BackupView {
272 s.backupInit()
273 bv := &BackupView{Max: backup.MaxServers}
274 bv.Servers, _ = s.backupMgr.List()
275 bv.InstanceID, _ = s.backupMgr.InstanceID()
276 return bv
277 }
278
279 // backupServerView vraagt status, archieven en instellingen op bij de
280 // backup server.
281 func (s *Server) backupServerView(ctx context.Context, conn backup.Conn) *BackupServerView {
282 v := &BackupServerView{Conn: conn}
283 if !conn.Connected() {
284 return v
285 }
286 ctx, cancel := context.WithTimeout(ctx, 8*time.Second)
287 defer cancel()
288 c := s.backupClient()
289 st, err := c.Status(ctx, conn)
290 if err != nil {
291 v.RemoteErr = err.Error()
292 return v
293 }
294 v.Remote = &st
295 if arch, err := c.Archives(ctx, conn); err == nil {
296 v.Archives = arch
297 } else {
298 v.RemoteErr = err.Error()
299 }
300 if cfg, err := c.Config(ctx, conn); err == nil {
301 v.Config = &cfg
302 } else if v.RemoteErr == "" {
303 v.RemoteErr = err.Error()
304 }
305 return v
306 }
307
308 func (s *Server) adminBackup(w http.ResponseWriter, r *http.Request) {
309 if ok, _ := s.adminOnly(w, r); !ok {
310 return
311 }
312 v := s.view(w, r, "title.admin")
313 v.Page = "adminbackup"
314 v.Backup = s.backupList()
315 s.render(w, "adminbackup", v)
316 }
317
318 func (s *Server) backupConnFromPath(w http.ResponseWriter, r *http.Request) (backup.Conn, bool) {
319 s.backupInit()
320 c, ok := s.backupMgr.Get(r.PathValue("id"))
321 if !ok {
322 http.NotFound(w, r)
323 }
324 return c, ok
325 }
326
327 func backupPath(id string) string { return "/admin/backup/s/" + url.PathEscape(id) }
328
329 func (s *Server) adminBackupServer(w http.ResponseWriter, r *http.Request) {
330 if ok, _ := s.adminOnly(w, r); !ok {
331 return
332 }
333 conn, ok := s.backupConnFromPath(w, r)
334 if !ok {
335 return
336 }
337 v := s.view(w, r, "title.admin")
338 v.Page = "adminbackupserver"
339 v.Backup = s.backupList()
340 v.Backup.Current = s.backupServerView(r.Context(), conn)
341 if c, err := r.Cookie("bluegit_backup_key"); err == nil && c.Value != "" {
342 v.Backup.NewKey = c.Value
343 http.SetCookie(w, &http.Cookie{Name: "bluegit_backup_key", Value: "", Path: backupPath(conn.ID), MaxAge: -1})
344 }
345 s.render(w, "adminbackup", v)
346 }
347
348 // showKeyOnce zet de nieuwe key in een kort, HttpOnly cookie dat alleen de
349 // pagina van die backup server leest.
350 func (s *Server) showKeyOnce(w http.ResponseWriter, id, key string) {
351 http.SetCookie(w, &http.Cookie{
352 Name: "bluegit_backup_key", Value: key, Path: backupPath(id), MaxAge: 60, HttpOnly: true,
353 SameSite: http.SameSiteStrictMode, Secure: strings.HasPrefix(s.Cfg.BaseURL, "https://"),
354 })
355 }
356
357 func (s *Server) backupAudit(action, by string, kv ...any) {
358 if s.Log != nil {
359 s.Log.Info("backup audit", append([]any{"action", action, "by", by}, kv...)...)
360 }
361 }
362
363 func (s *Server) adminBackupAdd(w http.ResponseWriter, r *http.Request) {
364 if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) {
365 return
366 }
367 s.backupInit()
368 by := s.who(r).User.Username
369 key, c, err := s.backupMgr.Add(r.FormValue("name"), by)
370 if err != nil {
371 s.redirect(w, r, "/admin/backup", "", s.backupErrText(r, err))
372 return
373 }
374 s.backupAudit("add", by, "id", c.ID, "name", c.Name)
375 s.showKeyOnce(w, c.ID, key)
376 s.redirect(w, r, backupPath(c.ID), s.tr(r, "backup.ok.key"), "")
377 }
378
379 func (s *Server) backupErrText(r *http.Request, err error) string {
380 switch {
381 case errors.Is(err, backup.ErrTooMany):
382 return s.tr(r, "backup.err.tooMany", backup.MaxServers)
383 case errors.Is(err, backup.ErrUnknown):
384 return s.tr(r, "backup.err.unknown")
385 }
386 return s.trErr(r, unwrapFail(err))
387 }
388
389 func (s *Server) adminBackupKey(w http.ResponseWriter, r *http.Request) {
390 if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) {
391 return
392 }
393 conn, ok := s.backupConnFromPath(w, r)
394 if !ok {
395 return
396 }
397 by := s.who(r).User.Username
398 key, _, err := s.backupMgr.RotateKey(conn.ID, by)
399 if err != nil {
400 s.redirect(w, r, backupPath(conn.ID), "", s.backupErrText(r, err))
401 return
402 }
403 s.backupAudit("new_key", by, "id", conn.ID, "name", conn.Name)
404 s.showKeyOnce(w, conn.ID, key)
405 s.redirect(w, r, backupPath(conn.ID), s.tr(r, "backup.ok.key"), "")
406 }
407
408 func (s *Server) adminBackupRename(w http.ResponseWriter, r *http.Request) {
409 if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) {
410 return
411 }
412 conn, ok := s.backupConnFromPath(w, r)
413 if !ok {
414 return
415 }
416 if _, err := s.backupMgr.Rename(conn.ID, r.FormValue("name")); err != nil {
417 s.redirect(w, r, backupPath(conn.ID), "", s.backupErrText(r, err))
418 return
419 }
420 s.redirect(w, r, backupPath(conn.ID), s.tr(r, "backup.ok.renamed"), "")
421 }
422
423 // removeBackupServer laat de backup server ontkoppelen (als hij bereikbaar
424 // is) en vergeet hem daarna.
425 func (s *Server) removeBackupServer(ctx context.Context, by string, conn backup.Conn) error {
426 if conn.Connected() {
427 ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
428 _, _, _ = s.backupClient().Call(ctx, conn, http.MethodPost, "/api/v1/admin/disconnect", map[string]any{})
429 cancel()
430 }
431 if err := s.backupMgr.Remove(conn.ID); err != nil {
432 return err
433 }
434 s.backupTree(conn.ID).RemoveSnapshot()
435 s.backupAudit("remove", by, "id", conn.ID, "name", conn.Name)
436 return nil
437 }
438
439 func (s *Server) adminBackupRemove(w http.ResponseWriter, r *http.Request) {
440 if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) {
441 return
442 }
443 conn, ok := s.backupConnFromPath(w, r)
444 if !ok {
445 return
446 }
447 if err := s.removeBackupServer(r.Context(), s.who(r).User.Username, conn); err != nil {
448 s.redirect(w, r, backupPath(conn.ID), "", s.backupErrText(r, err))
449 return
450 }
451 s.redirect(w, r, "/admin/backup", s.tr(r, "backup.ok.revoked"), "")
452 }
453
454 // backupAction voert een beheeractie van de backup server uit. BlueGit kent
455 // de acties niet vooraf: de backup server noemt ze (GET /api/v1/admin/actions),
456 // zodat alles wat zijn eigen webinterface kan, ook hier kan.
457 func (s *Server) backupAction(ctx context.Context, by string, conn backup.Conn, name string, in map[string]any) (int, []byte, error) {
458 if !conn.Connected() {
459 return 0, nil, fail(409, i18n.E("backup.err.none"))
460 }
461 ctx, cancel := context.WithTimeout(ctx, 60*time.Second)
462 defer cancel()
463 c := s.backupClient()
464 actions, err := c.Actions(ctx, conn)
465 if err != nil {
466 return 0, nil, fail(502, err)
467 }
468 var act *backup.RemoteAction
469 for i := range actions {
470 if actions[i].Name == name && actions[i].Signed {
471 act = &actions[i]
472 }
473 }
474 if act == nil {
475 return 0, nil, fail(404, i18n.E("backup.err.action"))
476 }
477 str := func(k string) string {
478 v, _ := in[k].(string)
479 return strings.TrimSpace(v)
480 }
481 if name == "rollback" {
482 if str("archive") == "" {
483 return 0, nil, fail(400, i18n.E("backup.err.archive"))
484 }
485 if str("confirm") != str("archive") {
486 return 0, nil, fail(400, i18n.E("backup.err.confirm"))
487 }
488 }
489 if name == "sync" {
490 if _, ok := in["wait"]; !ok {
491 in["wait"] = "false"
492 }
493 }
494 p := act.Path
495 for _, param := range act.Params {
496 v := str(param)
497 if v == "" {
498 return 0, nil, fail(400, i18n.E("backup.err.archive"))
499 }
500 p = strings.ReplaceAll(p, "{"+param+"}", url.PathEscape(v))
501 delete(in, param)
502 }
503 var body any
504 if act.Method != http.MethodGet {
505 body = in
506 }
507 hc := *s.backupHTTP
508 hc.Timeout = 60 * time.Second
509 cl := *c
510 cl.HTTP = &hc
511 code, raw, err := cl.Call(ctx, conn, act.Method, p, body)
512 if err != nil {
513 return 0, nil, fail(502, err)
514 }
515 if act.Method != http.MethodGet {
516 kv := []any{"id", conn.ID, "name", conn.Name, "remote_action", name, "status", code}
517 if a := str("archive"); a != "" {
518 kv = append(kv, "archive", a)
519 }
520 if s.Log != nil && name == "rollback" {
521 s.Log.Warn("backup audit", append([]any{"action", "rollback", "by", by}, kv...)...)
522 } else {
523 s.backupAudit("remote", by, kv...)
524 }
525 }
526 return code, raw, nil
527 }
528
529 func (s *Server) adminBackupAct(w http.ResponseWriter, r *http.Request) {
530 if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) {
531 return
532 }
533 conn, ok := s.backupConnFromPath(w, r)
534 if !ok {
535 return
536 }
537 back := backupPath(conn.ID)
538 name := r.PathValue("name")
539 if name == "rollback" && r.FormValue("understood") != "1" {
540 s.redirect(w, r, back, "", s.tr(r, "backup.err.understood"))
541 return
542 }
543 in := map[string]any{}
544 _ = r.ParseForm()
545 for k, v := range r.PostForm {
546 if k == "csrf" || k == "understood" || len(v) == 0 {
547 continue
548 }
549 in[k] = v[0]
550 }
551 code, raw, err := s.backupAction(r.Context(), s.who(r).User.Username, conn, name, in)
552 if err != nil {
553 s.redirect(w, r, back, "", s.backupErrText(r, err))
554 return
555 }
556 if code >= 300 {
557 var e struct {
558 Error string `json:"error"`
559 }
560 _ = json.Unmarshal(raw, &e)
561 if e.Error == "" {
562 e.Error = http.StatusText(code)
563 }
564 s.redirect(w, r, back, "", s.tr(r, "backup.err.remote", e.Error))
565 return
566 }
567 msg := s.tr(r, "backup.ok.action")
568 if name == "rollback" {
569 msg = s.tr(r, "backup.ok.rollback", in["archive"])
570 }
571 s.redirect(w, r, back, msg, "")
572 }
573
574 // ---------- API voor beheerders ----------
575
576 func backupConnJSON(c backup.Conn) map[string]any {
577 out := map[string]any{
578 "id": c.ID, "name": c.Name, "key_hint": c.KeyHint, "created_at": rfcTime(c.CreatedAt), "created_by": c.CreatedBy,
579 "connected": c.Connected(), "server_url": c.ServerURL, "server_id": c.ServerID,
580 }
581 if c.Connected() {
582 out["connected_at"] = rfcTime(c.ConnectedAt)
583 out["last_seen"] = rfcTime(c.LastSeen)
584 }
585 return out
586 }
587
588 func (s *Server) apiBackupAdmin(w http.ResponseWriter, r *http.Request) bool {
589 if !apiUser(r).InstanceAdmin {
590 s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden")))
591 return false
592 }
593 s.backupInit()
594 return true
595 }
596
597 func (s *Server) apiBackupConn(w http.ResponseWriter, r *http.Request) (backup.Conn, bool) {
598 if !s.apiBackupAdmin(w, r) {
599 return backup.Conn{}, false
600 }
601 c, ok := s.backupMgr.Get(r.PathValue("id"))
602 if !ok {
603 s.writeAPIErr(w, r, fail(404, i18n.E("backup.err.unknown")))
604 }
605 return c, ok
606 }
607
608 func (s *Server) apiAdminBackup(w http.ResponseWriter, r *http.Request) {
609 if !s.apiBackupAdmin(w, r) {
610 return
611 }
612 bv := s.backupList()
613 servers := make([]map[string]any, 0, len(bv.Servers))
614 for _, c := range bv.Servers {
615 servers = append(servers, backupConnJSON(c))
616 }
617 writeJSON(w, http.StatusOK, map[string]any{"instance_id": bv.InstanceID, "max_servers": bv.Max, "servers": servers})
618 }
619
620 func (s *Server) apiAdminBackupAdd(w http.ResponseWriter, r *http.Request) {
621 if !s.apiBackupAdmin(w, r) {
622 return
623 }
624 var in struct {
625 Name string `json:"name"`
626 }
627 _ = readJSON(r, &in)
628 by := apiUser(r).Username
629 key, c, err := s.backupMgr.Add(in.Name, by)
630 if errors.Is(err, backup.ErrTooMany) {
631 s.writeAPIErr(w, r, fail(409, err))
632 return
633 }
634 if err != nil {
635 s.writeAPIErr(w, r, fail(500, err))
636 return
637 }
638 s.backupAudit("add", by, "id", c.ID, "name", c.Name)
639 out := backupConnJSON(c)
640 out["key"] = key
641 writeJSON(w, http.StatusCreated, out)
642 }
643
644 func (s *Server) apiAdminBackupServer(w http.ResponseWriter, r *http.Request) {
645 c, ok := s.apiBackupConn(w, r)
646 if !ok {
647 return
648 }
649 v := s.backupServerView(r.Context(), c)
650 out := backupConnJSON(c)
651 out["archives"] = v.Archives
652 if v.Archives == nil {
653 out["archives"] = []backup.Archive{}
654 }
655 if v.Remote != nil {
656 out["remote"] = v.Remote
657 }
658 if v.Config != nil {
659 out["config"] = v.Config
660 }
661 out["remote_error"] = v.RemoteErr
662 writeJSON(w, http.StatusOK, out)
663 }
664
665 func (s *Server) apiAdminBackupRename(w http.ResponseWriter, r *http.Request) {
666 c, ok := s.apiBackupConn(w, r)
667 if !ok {
668 return
669 }
670 var in struct {
671 Name string `json:"name"`
672 }
673 if err := readJSON(r, &in); err != nil {
674 s.writeAPIErr(w, r, fail(400, err))
675 return
676 }
677 c, err := s.backupMgr.Rename(c.ID, in.Name)
678 if err != nil {
679 s.writeAPIErr(w, r, fail(400, err))
680 return
681 }
682 writeJSON(w, http.StatusOK, backupConnJSON(c))
683 }
684
685 func (s *Server) apiAdminBackupKey(w http.ResponseWriter, r *http.Request) {
686 c, ok := s.apiBackupConn(w, r)
687 if !ok {
688 return
689 }
690 by := apiUser(r).Username
691 key, c, err := s.backupMgr.RotateKey(c.ID, by)
692 if err != nil {
693 s.writeAPIErr(w, r, fail(500, err))
694 return
695 }
696 s.backupAudit("new_key", by, "id", c.ID, "name", c.Name)
697 out := backupConnJSON(c)
698 out["key"] = key
699 writeJSON(w, http.StatusCreated, out)
700 }
701
702 func (s *Server) apiAdminBackupRemove(w http.ResponseWriter, r *http.Request) {
703 c, ok := s.apiBackupConn(w, r)
704 if !ok {
705 return
706 }
707 if err := s.removeBackupServer(r.Context(), apiUser(r).Username, c); err != nil {
708 s.writeAPIErr(w, r, fail(500, err))
709 return
710 }
711 writeJSON(w, http.StatusNoContent, nil)
712 }
713
714 func (s *Server) apiAdminBackupAction(w http.ResponseWriter, r *http.Request) {
715 c, ok := s.apiBackupConn(w, r)
716 if !ok {
717 return
718 }
719 in := map[string]any{}
720 if r.ContentLength != 0 {
721 if err := readJSON(r, &in); err != nil {
722 s.writeAPIErr(w, r, fail(400, err))
723 return
724 }
725 }
726 code, raw, err := s.backupAction(r.Context(), apiUser(r).Username, c, r.PathValue("name"), in)
727 if err != nil {
728 s.writeAPIErr(w, r, err)
729 return
730 }
731 w.Header().Set("Content-Type", "application/json")
732 w.WriteHeader(code)
733 _, _ = w.Write(raw)
734 }
735
736 func unwrapFail(err error) error {
737 var oe interface{ Unwrap() error }
738 if errors.As(err, &oe) && oe.Unwrap() != nil {
739 return oe.Unwrap()
740 }
741 return err
742 }
@@ -0,0 +1,742 @@
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: een of meer losse backup servers (repo bluegit-backup)
21// halen elk met een eigen Backupserver-Key alle gegevens op, krijgen een
22// melding bij elke wijziging, en kunnen een archief terugsturen (rollback).
23// Vanuit BlueGit is elke backup server ook te bedienen: BlueGit stuurt
24// ondertekende verzoeken naar de beheer-API van de backup server. Het
25// protocol staat in docs/BACKUP.md.
26
27// maxRestoreBytes begrenst een terug te zetten archief (64 GiB).
28const maxRestoreBytes = 64 << 30
29
30var (
31 restoreBusy atomic.Bool
32 backupFails updateLimiter
33)
34
35// BackupView is de stand op Beheer > Backup.
36type BackupView struct {
37 InstanceID string
38 Servers []backup.Conn
39 Max int
40 // Current is de geopende backup server (detailpagina).
41 Current *BackupServerView
42 NewKey string
43}
44
45// BackupServerView is één backup server met wat hij zelf meldt.
46type BackupServerView struct {
47 Conn backup.Conn
48 Remote *backup.RemoteStatus
49 Archives []backup.Archive
50 Config *backup.RemoteConfig
51 RemoteErr string
52}
53
54func (s *Server) backupInit() {
55 s.backupOnce.Do(func() {
56 s.backupMgr = &backup.Manager{Dir: s.StateDir}
57 s.backupHTTP = &http.Client{Timeout: 15 * time.Second}
58 s.backupNote = &backup.Notifier{Client: s.backupClient()}
59 })
60}
61
62func (s *Server) backupClient() *backup.Client {
63 return &backup.Client{Manager: s.backupMgr, HTTP: s.backupHTTP}
64}
65
66// BackupManager geeft de koppeling (ook voor tests).
67func (s *Server) BackupManager() *backup.Manager {
68 s.backupInit()
69 return s.backupMgr
70}
71
72// BackupChanged meldt een wijziging aan de gekoppelde backup server.
73func (s *Server) BackupChanged() {
74 if s.StateDir == "" {
75 return
76 }
77 s.backupInit()
78 s.backupNote.Changed()
79}
80
81func (s *Server) backupTree(conn string) backup.Tree {
82 return backup.Tree{
83 StateDir: s.StateDir, DataDir: s.StoragePath(), Conn: conn,
84 Snapshot: func(dst string) error { return s.Store.Snapshot(context.Background(), dst) },
85 }
86}
87
88func (s *Server) mountBackup(mux *http.ServeMux) {
89 mux.HandleFunc("GET /api/v1/backup/info", s.backupKeyed(s.backupInfo))
90 mux.HandleFunc("POST /api/v1/backup/connect", s.backupKeyed(s.backupConnect))
91 mux.HandleFunc("GET /api/v1/backup/manifest", s.backupKeyed(s.backupManifest))
92 mux.HandleFunc("GET /api/v1/backup/file", s.backupKeyed(s.backupFile))
93 mux.HandleFunc("POST /api/v1/backup/restore", s.backupKeyed(s.backupRestore))
94 mux.HandleFunc("GET /admin/backup", s.adminBackup)
95 mux.HandleFunc("POST /admin/backup/servers", s.adminBackupAdd)
96 mux.HandleFunc("GET /admin/backup/s/{id}", s.adminBackupServer)
97 mux.HandleFunc("POST /admin/backup/s/{id}/key", s.adminBackupKey)
98 mux.HandleFunc("POST /admin/backup/s/{id}/rename", s.adminBackupRename)
99 mux.HandleFunc("POST /admin/backup/s/{id}/remove", s.adminBackupRemove)
100 mux.HandleFunc("POST /admin/backup/s/{id}/act/{name}", s.adminBackupAct)
101}
102
103// backupWatch meldt na elk schrijvend verzoek een wijziging. De backup
104// server haalt daarna alleen op wat veranderd is; een melding te veel kost
105// dus weinig. Tijdens het terugzetten van een backup wordt niet geschreven.
106func (s *Server) backupWatch(next http.Handler) http.Handler {
107 return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
108 switch r.Method {
109 case http.MethodGet, http.MethodHead, http.MethodOptions:
110 next.ServeHTTP(w, r)
111 return
112 }
113 if restoreBusy.Load() {
114 http.Error(w, "backup wordt teruggezet; BlueGit herstart zo\n", http.StatusServiceUnavailable)
115 return
116 }
117 next.ServeHTTP(w, r)
118 if strings.HasPrefix(r.URL.Path, "/api/v1/backup/") || strings.HasSuffix(r.URL.Path, "/git-upload-pack") {
119 return
120 }
121 s.BackupChanged()
122 })
123}
124
125func backupErr(w http.ResponseWriter, code int, msg string) {
126 writeJSON(w, code, map[string]string{"error": msg})
127}
128
129// backupKeyed eist de Backupserver-Key als bearer-token.
130func (s *Server) backupKeyed(h func(http.ResponseWriter, *http.Request)) http.HandlerFunc {
131 return func(w http.ResponseWriter, r *http.Request) {
132 w.Header().Set("Cache-Control", "no-store")
133 if s.StateDir == "" {
134 backupErr(w, http.StatusNotFound, "backup niet beschikbaar")
135 return
136 }
137 s.backupInit()
138 conn, ok := s.backupMgr.Check(bearer(r))
139 if !ok {
140 // Alleen mislukte pogingen tellen: hoogstens 5 per minuut per IP.
141 if !backupFails.allow(clientIP(r), time.Now()) {
142 backupErr(w, http.StatusTooManyRequests, "te veel mislukte pogingen")
143 return
144 }
145 backupErr(w, http.StatusUnauthorized, "ongeldige Backupserver-Key")
146 return
147 }
148 s.backupMgr.Seen(conn.ID)
149 h(w, r.WithContext(context.WithValue(r.Context(), backupConnKey{}, conn)))
150 }
151}
152
153type backupConnKey struct{}
154
155func backupConnOf(r *http.Request) backup.Conn {
156 c, _ := r.Context().Value(backupConnKey{}).(backup.Conn)
157 return c
158}
159
160func (s *Server) backupInfo(w http.ResponseWriter, r *http.Request) {
161 id, err := s.backupMgr.InstanceID()
162 if err != nil {
163 backupErr(w, 500, err.Error())
164 return
165 }
166 c := backupConnOf(r)
167 writeJSON(w, http.StatusOK, map[string]any{
168 "instance_id": id, "base_url": s.Cfg.BaseURL, "name": c.Name, "server_url": c.ServerURL, "server_id": c.ServerID,
169 "has_storage": s.StoragePath() != "",
170 })
171}
172
173func (s *Server) backupConnect(w http.ResponseWriter, r *http.Request) {
174 var in struct {
175 ServerURL string `json:"server_url"`
176 ServerID string `json:"server_id"`
177 }
178 if err := json.NewDecoder(io.LimitReader(r.Body, 1<<16)).Decode(&in); err != nil {
179 backupErr(w, 400, "ongeldige JSON")
180 return
181 }
182 u, err := url.Parse(strings.TrimSpace(in.ServerURL))
183 if err != nil || (u.Scheme != "http" && u.Scheme != "https") || u.Host == "" {
184 backupErr(w, 400, "server_url moet een http(s)-adres zijn")
185 return
186 }
187 c, err := s.backupMgr.Connect(backupConnOf(r).ID, u.String(), strings.TrimSpace(in.ServerID))
188 if err != nil {
189 backupErr(w, 500, err.Error())
190 return
191 }
192 id, _ := s.backupMgr.InstanceID()
193 if s.Log != nil {
194 s.Log.Info("backup audit", "action", "connect", "id", c.ID, "name", c.Name, "server", c.ServerURL, "server_id", c.ServerID)
195 }
196 writeJSON(w, http.StatusOK, map[string]any{"instance_id": id, "server_url": c.ServerURL})
197}
198
199func (s *Server) backupManifest(w http.ResponseWriter, r *http.Request) {
200 id, err := s.backupMgr.InstanceID()
201 if err != nil {
202 backupErr(w, 500, err.Error())
203 return
204 }
205 m, err := s.backupTree(backupConnOf(r).ID).Build(id)
206 if err != nil {
207 backupErr(w, 500, err.Error())
208 return
209 }
210 writeJSON(w, http.StatusOK, m)
211}
212
213func (s *Server) backupFile(w http.ResponseWriter, r *http.Request) {
214 real, err := s.backupTree(backupConnOf(r).ID).Resolve(r.URL.Query().Get("path"))
215 if err != nil {
216 backupErr(w, http.StatusNotFound, "bestand niet gevonden")
217 return
218 }
219 f, err := os.Open(real)
220 if err != nil {
221 backupErr(w, http.StatusNotFound, "bestand niet gevonden")
222 return
223 }
224 defer f.Close()
225 fi, err := f.Stat()
226 if err != nil {
227 backupErr(w, 500, err.Error())
228 return
229 }
230 w.Header().Set("Content-Type", "application/octet-stream")
231 w.Header().Set("Content-Length", strconv.FormatInt(fi.Size(), 10))
232 w.Header().Set("X-Backup-Mtime", strconv.FormatInt(fi.ModTime().UnixMilli(), 10))
233 _, _ = io.Copy(w, f)
234}
235
236// backupRestore neemt een tar.gz aan, pakt het naast de live gegevens uit
237// en herstart BlueGit. Bij de start komt de backup op zijn plek.
238func (s *Server) backupRestore(w http.ResponseWriter, r *http.Request) {
239 if !s.restoring.TryLock() {
240 backupErr(w, http.StatusConflict, "er loopt al een restore")
241 return
242 }
243 defer s.restoring.Unlock()
244 restoreBusy.Store(true)
245 n, err := s.backupTree("").Stage(http.MaxBytesReader(w, r.Body, maxRestoreBytes))
246 if err != nil {
247 restoreBusy.Store(false)
248 if s.Log != nil {
249 s.Log.Warn("backup audit", "action", "restore_failed", "err", err)
250 }
251 backupErr(w, http.StatusBadRequest, err.Error())
252 return
253 }
254 if s.Log != nil {
255 s.Log.Warn("backup audit", "action", "restore_staged", "files", n, "id", backupConnOf(r).ID, "name", backupConnOf(r).Name)
256 }
257 writeJSON(w, http.StatusAccepted, map[string]any{"files": n, "restarting": s.RequestRestart != nil})
258 if f, ok := w.(http.Flusher); ok {
259 f.Flush()
260 }
261 if s.RequestRestart != nil {
262 go func() {
263 time.Sleep(300 * time.Millisecond)
264 s.RequestRestart()
265 }()
266 }
267}
268
269// ---------- Beheer > Backup ----------
270
271func (s *Server) backupList() *BackupView {
272 s.backupInit()
273 bv := &BackupView{Max: backup.MaxServers}
274 bv.Servers, _ = s.backupMgr.List()
275 bv.InstanceID, _ = s.backupMgr.InstanceID()
276 return bv
277}
278
279// backupServerView vraagt status, archieven en instellingen op bij de
280// backup server.
281func (s *Server) backupServerView(ctx context.Context, conn backup.Conn) *BackupServerView {
282 v := &BackupServerView{Conn: conn}
283 if !conn.Connected() {
284 return v
285 }
286 ctx, cancel := context.WithTimeout(ctx, 8*time.Second)
287 defer cancel()
288 c := s.backupClient()
289 st, err := c.Status(ctx, conn)
290 if err != nil {
291 v.RemoteErr = err.Error()
292 return v
293 }
294 v.Remote = &st
295 if arch, err := c.Archives(ctx, conn); err == nil {
296 v.Archives = arch
297 } else {
298 v.RemoteErr = err.Error()
299 }
300 if cfg, err := c.Config(ctx, conn); err == nil {
301 v.Config = &cfg
302 } else if v.RemoteErr == "" {
303 v.RemoteErr = err.Error()
304 }
305 return v
306}
307
308func (s *Server) adminBackup(w http.ResponseWriter, r *http.Request) {
309 if ok, _ := s.adminOnly(w, r); !ok {
310 return
311 }
312 v := s.view(w, r, "title.admin")
313 v.Page = "adminbackup"
314 v.Backup = s.backupList()
315 s.render(w, "adminbackup", v)
316}
317
318func (s *Server) backupConnFromPath(w http.ResponseWriter, r *http.Request) (backup.Conn, bool) {
319 s.backupInit()
320 c, ok := s.backupMgr.Get(r.PathValue("id"))
321 if !ok {
322 http.NotFound(w, r)
323 }
324 return c, ok
325}
326
327func backupPath(id string) string { return "/admin/backup/s/" + url.PathEscape(id) }
328
329func (s *Server) adminBackupServer(w http.ResponseWriter, r *http.Request) {
330 if ok, _ := s.adminOnly(w, r); !ok {
331 return
332 }
333 conn, ok := s.backupConnFromPath(w, r)
334 if !ok {
335 return
336 }
337 v := s.view(w, r, "title.admin")
338 v.Page = "adminbackupserver"
339 v.Backup = s.backupList()
340 v.Backup.Current = s.backupServerView(r.Context(), conn)
341 if c, err := r.Cookie("bluegit_backup_key"); err == nil && c.Value != "" {
342 v.Backup.NewKey = c.Value
343 http.SetCookie(w, &http.Cookie{Name: "bluegit_backup_key", Value: "", Path: backupPath(conn.ID), MaxAge: -1})
344 }
345 s.render(w, "adminbackup", v)
346}
347
348// showKeyOnce zet de nieuwe key in een kort, HttpOnly cookie dat alleen de
349// pagina van die backup server leest.
350func (s *Server) showKeyOnce(w http.ResponseWriter, id, key string) {
351 http.SetCookie(w, &http.Cookie{
352 Name: "bluegit_backup_key", Value: key, Path: backupPath(id), MaxAge: 60, HttpOnly: true,
353 SameSite: http.SameSiteStrictMode, Secure: strings.HasPrefix(s.Cfg.BaseURL, "https://"),
354 })
355}
356
357func (s *Server) backupAudit(action, by string, kv ...any) {
358 if s.Log != nil {
359 s.Log.Info("backup audit", append([]any{"action", action, "by", by}, kv...)...)
360 }
361}
362
363func (s *Server) adminBackupAdd(w http.ResponseWriter, r *http.Request) {
364 if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) {
365 return
366 }
367 s.backupInit()
368 by := s.who(r).User.Username
369 key, c, err := s.backupMgr.Add(r.FormValue("name"), by)
370 if err != nil {
371 s.redirect(w, r, "/admin/backup", "", s.backupErrText(r, err))
372 return
373 }
374 s.backupAudit("add", by, "id", c.ID, "name", c.Name)
375 s.showKeyOnce(w, c.ID, key)
376 s.redirect(w, r, backupPath(c.ID), s.tr(r, "backup.ok.key"), "")
377}
378
379func (s *Server) backupErrText(r *http.Request, err error) string {
380 switch {
381 case errors.Is(err, backup.ErrTooMany):
382 return s.tr(r, "backup.err.tooMany", backup.MaxServers)
383 case errors.Is(err, backup.ErrUnknown):
384 return s.tr(r, "backup.err.unknown")
385 }
386 return s.trErr(r, unwrapFail(err))
387}
388
389func (s *Server) adminBackupKey(w http.ResponseWriter, r *http.Request) {
390 if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) {
391 return
392 }
393 conn, ok := s.backupConnFromPath(w, r)
394 if !ok {
395 return
396 }
397 by := s.who(r).User.Username
398 key, _, err := s.backupMgr.RotateKey(conn.ID, by)
399 if err != nil {
400 s.redirect(w, r, backupPath(conn.ID), "", s.backupErrText(r, err))
401 return
402 }
403 s.backupAudit("new_key", by, "id", conn.ID, "name", conn.Name)
404 s.showKeyOnce(w, conn.ID, key)
405 s.redirect(w, r, backupPath(conn.ID), s.tr(r, "backup.ok.key"), "")
406}
407
408func (s *Server) adminBackupRename(w http.ResponseWriter, r *http.Request) {
409 if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) {
410 return
411 }
412 conn, ok := s.backupConnFromPath(w, r)
413 if !ok {
414 return
415 }
416 if _, err := s.backupMgr.Rename(conn.ID, r.FormValue("name")); err != nil {
417 s.redirect(w, r, backupPath(conn.ID), "", s.backupErrText(r, err))
418 return
419 }
420 s.redirect(w, r, backupPath(conn.ID), s.tr(r, "backup.ok.renamed"), "")
421}
422
423// removeBackupServer laat de backup server ontkoppelen (als hij bereikbaar
424// is) en vergeet hem daarna.
425func (s *Server) removeBackupServer(ctx context.Context, by string, conn backup.Conn) error {
426 if conn.Connected() {
427 ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
428 _, _, _ = s.backupClient().Call(ctx, conn, http.MethodPost, "/api/v1/admin/disconnect", map[string]any{})
429 cancel()
430 }
431 if err := s.backupMgr.Remove(conn.ID); err != nil {
432 return err
433 }
434 s.backupTree(conn.ID).RemoveSnapshot()
435 s.backupAudit("remove", by, "id", conn.ID, "name", conn.Name)
436 return nil
437}
438
439func (s *Server) adminBackupRemove(w http.ResponseWriter, r *http.Request) {
440 if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) {
441 return
442 }
443 conn, ok := s.backupConnFromPath(w, r)
444 if !ok {
445 return
446 }
447 if err := s.removeBackupServer(r.Context(), s.who(r).User.Username, conn); err != nil {
448 s.redirect(w, r, backupPath(conn.ID), "", s.backupErrText(r, err))
449 return
450 }
451 s.redirect(w, r, "/admin/backup", s.tr(r, "backup.ok.revoked"), "")
452}
453
454// backupAction voert een beheeractie van de backup server uit. BlueGit kent
455// de acties niet vooraf: de backup server noemt ze (GET /api/v1/admin/actions),
456// zodat alles wat zijn eigen webinterface kan, ook hier kan.
457func (s *Server) backupAction(ctx context.Context, by string, conn backup.Conn, name string, in map[string]any) (int, []byte, error) {
458 if !conn.Connected() {
459 return 0, nil, fail(409, i18n.E("backup.err.none"))
460 }
461 ctx, cancel := context.WithTimeout(ctx, 60*time.Second)
462 defer cancel()
463 c := s.backupClient()
464 actions, err := c.Actions(ctx, conn)
465 if err != nil {
466 return 0, nil, fail(502, err)
467 }
468 var act *backup.RemoteAction
469 for i := range actions {
470 if actions[i].Name == name && actions[i].Signed {
471 act = &actions[i]
472 }
473 }
474 if act == nil {
475 return 0, nil, fail(404, i18n.E("backup.err.action"))
476 }
477 str := func(k string) string {
478 v, _ := in[k].(string)
479 return strings.TrimSpace(v)
480 }
481 if name == "rollback" {
482 if str("archive") == "" {
483 return 0, nil, fail(400, i18n.E("backup.err.archive"))
484 }
485 if str("confirm") != str("archive") {
486 return 0, nil, fail(400, i18n.E("backup.err.confirm"))
487 }
488 }
489 if name == "sync" {
490 if _, ok := in["wait"]; !ok {
491 in["wait"] = "false"
492 }
493 }
494 p := act.Path
495 for _, param := range act.Params {
496 v := str(param)
497 if v == "" {
498 return 0, nil, fail(400, i18n.E("backup.err.archive"))
499 }
500 p = strings.ReplaceAll(p, "{"+param+"}", url.PathEscape(v))
501 delete(in, param)
502 }
503 var body any
504 if act.Method != http.MethodGet {
505 body = in
506 }
507 hc := *s.backupHTTP
508 hc.Timeout = 60 * time.Second
509 cl := *c
510 cl.HTTP = &hc
511 code, raw, err := cl.Call(ctx, conn, act.Method, p, body)
512 if err != nil {
513 return 0, nil, fail(502, err)
514 }
515 if act.Method != http.MethodGet {
516 kv := []any{"id", conn.ID, "name", conn.Name, "remote_action", name, "status", code}
517 if a := str("archive"); a != "" {
518 kv = append(kv, "archive", a)
519 }
520 if s.Log != nil && name == "rollback" {
521 s.Log.Warn("backup audit", append([]any{"action", "rollback", "by", by}, kv...)...)
522 } else {
523 s.backupAudit("remote", by, kv...)
524 }
525 }
526 return code, raw, nil
527}
528
529func (s *Server) adminBackupAct(w http.ResponseWriter, r *http.Request) {
530 if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) {
531 return
532 }
533 conn, ok := s.backupConnFromPath(w, r)
534 if !ok {
535 return
536 }
537 back := backupPath(conn.ID)
538 name := r.PathValue("name")
539 if name == "rollback" && r.FormValue("understood") != "1" {
540 s.redirect(w, r, back, "", s.tr(r, "backup.err.understood"))
541 return
542 }
543 in := map[string]any{}
544 _ = r.ParseForm()
545 for k, v := range r.PostForm {
546 if k == "csrf" || k == "understood" || len(v) == 0 {
547 continue
548 }
549 in[k] = v[0]
550 }
551 code, raw, err := s.backupAction(r.Context(), s.who(r).User.Username, conn, name, in)
552 if err != nil {
553 s.redirect(w, r, back, "", s.backupErrText(r, err))
554 return
555 }
556 if code >= 300 {
557 var e struct {
558 Error string `json:"error"`
559 }
560 _ = json.Unmarshal(raw, &e)
561 if e.Error == "" {
562 e.Error = http.StatusText(code)
563 }
564 s.redirect(w, r, back, "", s.tr(r, "backup.err.remote", e.Error))
565 return
566 }
567 msg := s.tr(r, "backup.ok.action")
568 if name == "rollback" {
569 msg = s.tr(r, "backup.ok.rollback", in["archive"])
570 }
571 s.redirect(w, r, back, msg, "")
572}
573
574// ---------- API voor beheerders ----------
575
576func backupConnJSON(c backup.Conn) map[string]any {
577 out := map[string]any{
578 "id": c.ID, "name": c.Name, "key_hint": c.KeyHint, "created_at": rfcTime(c.CreatedAt), "created_by": c.CreatedBy,
579 "connected": c.Connected(), "server_url": c.ServerURL, "server_id": c.ServerID,
580 }
581 if c.Connected() {
582 out["connected_at"] = rfcTime(c.ConnectedAt)
583 out["last_seen"] = rfcTime(c.LastSeen)
584 }
585 return out
586}
587
588func (s *Server) apiBackupAdmin(w http.ResponseWriter, r *http.Request) bool {
589 if !apiUser(r).InstanceAdmin {
590 s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden")))
591 return false
592 }
593 s.backupInit()
594 return true
595}
596
597func (s *Server) apiBackupConn(w http.ResponseWriter, r *http.Request) (backup.Conn, bool) {
598 if !s.apiBackupAdmin(w, r) {
599 return backup.Conn{}, false
600 }
601 c, ok := s.backupMgr.Get(r.PathValue("id"))
602 if !ok {
603 s.writeAPIErr(w, r, fail(404, i18n.E("backup.err.unknown")))
604 }
605 return c, ok
606}
607
608func (s *Server) apiAdminBackup(w http.ResponseWriter, r *http.Request) {
609 if !s.apiBackupAdmin(w, r) {
610 return
611 }
612 bv := s.backupList()
613 servers := make([]map[string]any, 0, len(bv.Servers))
614 for _, c := range bv.Servers {
615 servers = append(servers, backupConnJSON(c))
616 }
617 writeJSON(w, http.StatusOK, map[string]any{"instance_id": bv.InstanceID, "max_servers": bv.Max, "servers": servers})
618}
619
620func (s *Server) apiAdminBackupAdd(w http.ResponseWriter, r *http.Request) {
621 if !s.apiBackupAdmin(w, r) {
622 return
623 }
624 var in struct {
625 Name string `json:"name"`
626 }
627 _ = readJSON(r, &in)
628 by := apiUser(r).Username
629 key, c, err := s.backupMgr.Add(in.Name, by)
630 if errors.Is(err, backup.ErrTooMany) {
631 s.writeAPIErr(w, r, fail(409, err))
632 return
633 }
634 if err != nil {
635 s.writeAPIErr(w, r, fail(500, err))
636 return
637 }
638 s.backupAudit("add", by, "id", c.ID, "name", c.Name)
639 out := backupConnJSON(c)
640 out["key"] = key
641 writeJSON(w, http.StatusCreated, out)
642}
643
644func (s *Server) apiAdminBackupServer(w http.ResponseWriter, r *http.Request) {
645 c, ok := s.apiBackupConn(w, r)
646 if !ok {
647 return
648 }
649 v := s.backupServerView(r.Context(), c)
650 out := backupConnJSON(c)
651 out["archives"] = v.Archives
652 if v.Archives == nil {
653 out["archives"] = []backup.Archive{}
654 }
655 if v.Remote != nil {
656 out["remote"] = v.Remote
657 }
658 if v.Config != nil {
659 out["config"] = v.Config
660 }
661 out["remote_error"] = v.RemoteErr
662 writeJSON(w, http.StatusOK, out)
663}
664
665func (s *Server) apiAdminBackupRename(w http.ResponseWriter, r *http.Request) {
666 c, ok := s.apiBackupConn(w, r)
667 if !ok {
668 return
669 }
670 var in struct {
671 Name string `json:"name"`
672 }
673 if err := readJSON(r, &in); err != nil {
674 s.writeAPIErr(w, r, fail(400, err))
675 return
676 }
677 c, err := s.backupMgr.Rename(c.ID, in.Name)
678 if err != nil {
679 s.writeAPIErr(w, r, fail(400, err))
680 return
681 }
682 writeJSON(w, http.StatusOK, backupConnJSON(c))
683}
684
685func (s *Server) apiAdminBackupKey(w http.ResponseWriter, r *http.Request) {
686 c, ok := s.apiBackupConn(w, r)
687 if !ok {
688 return
689 }
690 by := apiUser(r).Username
691 key, c, err := s.backupMgr.RotateKey(c.ID, by)
692 if err != nil {
693 s.writeAPIErr(w, r, fail(500, err))
694 return
695 }
696 s.backupAudit("new_key", by, "id", c.ID, "name", c.Name)
697 out := backupConnJSON(c)
698 out["key"] = key
699 writeJSON(w, http.StatusCreated, out)
700}
701
702func (s *Server) apiAdminBackupRemove(w http.ResponseWriter, r *http.Request) {
703 c, ok := s.apiBackupConn(w, r)
704 if !ok {
705 return
706 }
707 if err := s.removeBackupServer(r.Context(), apiUser(r).Username, c); err != nil {
708 s.writeAPIErr(w, r, fail(500, err))
709 return
710 }
711 writeJSON(w, http.StatusNoContent, nil)
712}
713
714func (s *Server) apiAdminBackupAction(w http.ResponseWriter, r *http.Request) {
715 c, ok := s.apiBackupConn(w, r)
716 if !ok {
717 return
718 }
719 in := map[string]any{}
720 if r.ContentLength != 0 {
721 if err := readJSON(r, &in); err != nil {
722 s.writeAPIErr(w, r, fail(400, err))
723 return
724 }
725 }
726 code, raw, err := s.backupAction(r.Context(), apiUser(r).Username, c, r.PathValue("name"), in)
727 if err != nil {
728 s.writeAPIErr(w, r, err)
729 return
730 }
731 w.Header().Set("Content-Type", "application/json")
732 w.WriteHeader(code)
733 _, _ = w.Write(raw)
734}
735
736func unwrapFail(err error) error {
737 var oe interface{ Unwrap() error }
738 if errors.As(err, &oe) && oe.Unwrap() != nil {
739 return oe.Unwrap()
740 }
741 return err
742}
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 +419 −0
@@ -0,0 +1,419 @@
1 package server
2
3 import (
4 "context"
5 "encoding/json"
6 "io"
7 "net/http"
8 "net/http/httptest"
9 "net/url"
10 "os"
11 "path/filepath"
12 "strings"
13 "sync"
14 "testing"
15 "time"
16
17 "gitlab.com/Timfa/bluegit/internal/auth"
18 "gitlab.com/Timfa/bluegit/internal/backup"
19 "gitlab.com/Timfa/bluegit/internal/config"
20 "gitlab.com/Timfa/bluegit/internal/store"
21 )
22
23 type backupEnv struct {
24 srv *Server
25 st *store.Store
26 base string
27 tim store.User
28 tok string
29 }
30
31 func newBackupEnv(t *testing.T) *backupEnv {
32 t.Helper()
33 stateDir, storage := t.TempDir(), t.TempDir()
34 st, err := store.Open(filepath.Join(stateDir, "bluegit.db"), bytes32())
35 if err != nil {
36 t.Fatal(err)
37 }
38 t.Cleanup(func() { _ = st.Close() })
39 _ = os.WriteFile(filepath.Join(stateDir, "secret.key"), bytes32(), 0o600)
40 cfg := config.Config{
41 Listen: "127.0.0.1:0", StoragePath: storage, StatePath: stateDir,
42 Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test", BaseURL: "https://auth.timfalken.com"},
43 Git: config.Git{Binary: "git", DefaultBranch: "master"},
44 }
45 srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: "/bin/true", StateDir: stateDir}
46 ts := httptest.NewServer(srv.Handler())
47 t.Cleanup(ts.Close)
48 srv.Cfg.BaseURL = ts.URL
49 tim, err := st.UpsertUser(context.Background(), 1, "tim", "", false)
50 if err != nil {
51 t.Fatal(err)
52 }
53 if !tim.InstanceAdmin {
54 t.Skip("eerste gebruiker is geen beheerder")
55 }
56 _ = os.MkdirAll(filepath.Join(storage, "repos", "tim", "app.git"), 0o755)
57 _ = os.WriteFile(filepath.Join(storage, "repos", "tim", "app.git", "HEAD"), []byte("ref: refs/heads/master\n"), 0o644)
58 srv.backupInit()
59 srv.backupNote.Delay = 20 * time.Millisecond
60 return &backupEnv{srv: srv, st: st, base: ts.URL, tim: tim, tok: issue(t, st, tim.ID, "api")}
61 }
62
63 func keyed(t *testing.T, method, u, key string, body io.Reader) (int, []byte) {
64 t.Helper()
65 req, _ := http.NewRequest(method, u, body)
66 if key != "" {
67 req.Header.Set("Authorization", "Bearer "+key)
68 }
69 res, err := http.DefaultClient.Do(req)
70 if err != nil {
71 t.Fatal(err)
72 }
73 defer res.Body.Close()
74 b, _ := io.ReadAll(res.Body)
75 return res.StatusCode, b
76 }
77
78 // fakeBackup speelt de backup server: hij controleert elke handtekening.
79 type fakeBackup struct {
80 mu sync.Mutex
81 secret string
82 notifies int
83 rollback []string
84 calls []string
85 bodies map[string]string
86 badSig int
87 ts *httptest.Server
88 }
89
90 func newFakeBackup(t *testing.T) *fakeBackup {
91 f := &fakeBackup{}
92 f.ts = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
93 body, _ := io.ReadAll(r.Body)
94 f.mu.Lock()
95 defer f.mu.Unlock()
96 if err := backup.Verify(r, f.secret, body, time.Now()); err != nil {
97 f.badSig++
98 http.Error(w, `{"error":"sig"}`, 401)
99 return
100 }
101 switch r.URL.Path {
102 case "/api/v1/notify":
103 f.notifies++
104 w.WriteHeader(204)
105 case "/api/v1/archives":
106 _ = json.NewEncoder(w).Encode(map[string]any{"archives": []backup.Archive{{Name: "bluegit-20261115-120000.tar.gz", CreatedAt: time.Date(2026, 11, 15, 12, 0, 0, 0, time.UTC), Size: 3 << 20}}})
107 case "/api/v1/status":
108 _, _ = w.Write([]byte(`{"version":"test","archive_interval":"24h0m0s","retention_days":30,"rollback":{"state":"idle"}}`))
109 case "/api/v1/rollback":
110 var in struct{ Archive string }
111 _ = json.Unmarshal(body, &in)
112 f.rollback = append(f.rollback, in.Archive)
113 w.WriteHeader(202)
114 case "/api/v1/admin/actions":
115 _, _ = w.Write([]byte(`{"actions":[
116 {"name":"status","method":"GET","path":"/api/v1/admin/status","bluegit":true},
117 {"name":"config","method":"GET","path":"/api/v1/admin/config","bluegit":true},
118 {"name":"config.update","method":"PUT","path":"/api/v1/admin/config","bluegit":true},
119 {"name":"sync","method":"POST","path":"/api/v1/admin/sync","bluegit":true},
120 {"name":"archive.delete","method":"DELETE","path":"/api/v1/admin/archives/{name}","bluegit":true,"params":["name"]},
121 {"name":"archive.download","method":"GET","path":"/api/v1/admin/archives/{name}/download","params":["name"]},
122 {"name":"rollback","method":"POST","path":"/api/v1/admin/rollback","bluegit":true},
123 {"name":"disconnect","method":"POST","path":"/api/v1/admin/disconnect","bluegit":true}]}`))
124 case "/api/v1/admin/config":
125 if r.Method == "PUT" {
126 f.calls = append(f.calls, "PUT config")
127 if f.bodies == nil {
128 f.bodies = map[string]string{}
129 }
130 f.bodies["config"] = string(body)
131 }
132 _, _ = w.Write([]byte(`{"fields":[{"key":"archive_interval","label":"Archiefinterval","kind":"duration","value":"24h"},{"key":"retention_days","label":"Bewaartermijn","kind":"int","value":"30"}],"data_dir":"/var/lib/bluegit-backup"}`))
133 case "/api/v1/admin/rollback":
134 var in struct{ Archive, Confirm string }
135 _ = json.Unmarshal(body, &in)
136 if in.Confirm != in.Archive {
137 http.Error(w, `{"error":"confirm"}`, 400)
138 return
139 }
140 f.rollback = append(f.rollback, in.Archive)
141 w.WriteHeader(202)
142 default:
143 if r.URL.Path == "/api/v1/admin/sync" || r.URL.Path == "/api/v1/admin/disconnect" || strings.HasPrefix(r.URL.Path, "/api/v1/admin/archives/") {
144 f.calls = append(f.calls, r.Method+" "+r.URL.Path+" "+string(body))
145 _, _ = w.Write([]byte(`{}`))
146 return
147 }
148 http.NotFound(w, r)
149 }
150 }))
151 t.Cleanup(f.ts.Close)
152 return f
153 }
154
155 type addedServer struct {
156 ID string `json:"id"`
157 Key string `json:"key"`
158 }
159
160 func addBackupServer(t *testing.T, e *backupEnv, name string) addedServer {
161 t.Helper()
162 code, b := rapi(t, e.base, e.tok, "POST", "/admin/backup/servers", map[string]any{"name": name})
163 if code != 201 {
164 t.Fatalf("server toevoegen: %d %s", code, b)
165 }
166 var a addedServer
167 _ = json.Unmarshal(b, &a)
168 if !strings.HasPrefix(a.Key, "bgbk_") || a.ID == "" {
169 t.Fatalf("%s", b)
170 }
171 return a
172 }
173
174 func TestBackupKeyAndKeyedAPI(t *testing.T) {
175 e := newBackupEnv(t)
176 // Zonder key: 401. Met een gewoon toegangstoken: ook 401.
177 if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/manifest", "", nil); code != 401 {
178 t.Fatalf("zonder key: %d", code)
179 }
180 if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/manifest", e.tok, nil); code != 401 {
181 t.Fatalf("bg_-token: %d", code)
182 }
183 // Alleen een beheerder maakt een backup server.
184 bob, _ := e.st.UpsertUser(context.Background(), 2, "bob", "", false)
185 if code, _ := rapi(t, e.base, issue(t, e.st, bob.ID, "api"), "POST", "/admin/backup/servers", map[string]any{"name": "x"}); code != 403 {
186 t.Fatalf("bob maakt server: %d", code)
187 }
188 k := addBackupServer(t, e, "nas")
189 code, b := keyed(t, "GET", e.base+"/api/v1/backup/info", k.Key, nil)
190 var info struct {
191 InstanceID string `json:"instance_id"`
192 Name string `json:"name"`
193 }
194 _ = json.Unmarshal(b, &info)
195 if code != 200 || info.InstanceID == "" || info.Name != "nas" {
196 t.Fatalf("info: %d %s", code, b)
197 }
198 code, b = keyed(t, "GET", e.base+"/api/v1/backup/manifest", k.Key, nil)
199 var m backup.Manifest
200 _ = json.Unmarshal(b, &m)
201 if code != 200 || m.Instance != info.InstanceID {
202 t.Fatalf("manifest: %d %.300s", code, b)
203 }
204 have := map[string]bool{}
205 for _, f := range m.Files {
206 have[f.Path] = true
207 }
208 for _, want := range []string{"state/bluegit.db", "state/secret.key", "data/repos/tim/app.git/HEAD"} {
209 if !have[want] {
210 t.Fatalf("manifest mist %s: %v", want, have)
211 }
212 }
213 code, b = keyed(t, "GET", e.base+"/api/v1/backup/file?path="+url.QueryEscape("data/repos/tim/app.git/HEAD"), k.Key, nil)
214 if code != 200 || string(b) != "ref: refs/heads/master\n" {
215 t.Fatalf("file: %d %q", code, b)
216 }
217 code, b = keyed(t, "GET", e.base+"/api/v1/backup/file?path=state/bluegit.db", k.Key, nil)
218 if code != 200 || !strings.HasPrefix(string(b), "SQLite format 3") {
219 t.Fatalf("db-kopie: %d %.20q", code, b)
220 }
221 for _, bad := range []string{"state/backup.json", "state/storage_path", "../../etc/passwd", "data/repos/../../x"} {
222 if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/file?path="+url.QueryEscape(bad), k.Key, nil); code != 404 {
223 t.Fatalf("%s: %d", bad, code)
224 }
225 }
226 // Een tweede server met een eigen key; nieuwe key voor de eerste.
227 k2 := addBackupServer(t, e, "offsite")
228 code, b = rapi(t, e.base, e.tok, "POST", "/admin/backup/servers/"+k.ID+"/key", nil)
229 var rot addedServer
230 _ = json.Unmarshal(b, &rot)
231 if code != 201 || rot.Key == k.Key {
232 t.Fatalf("nieuwe key: %d %s", code, b)
233 }
234 if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/info", k.Key, nil); code != 401 {
235 t.Fatalf("oude key werkt nog: %d", code)
236 }
237 if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/info", rot.Key, nil); code != 200 {
238 t.Fatalf("nieuwe key: %d", code)
239 }
240 if code, b := rapi(t, e.base, e.tok, "PUT", "/admin/backup/servers/"+k2.ID, map[string]any{"name": "Offsite 2"}); code != 200 || !strings.Contains(string(b), "Offsite 2") {
241 t.Fatalf("hernoemen: %d %s", code, b)
242 }
243 // Verwijderen: die key werkt niet meer, de andere wel.
244 if code, _ := rapi(t, e.base, e.tok, "DELETE", "/admin/backup/servers/"+k.ID, nil); code != 204 {
245 t.Fatalf("verwijderen: %d", code)
246 }
247 if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/info", rot.Key, nil); code != 401 {
248 t.Fatalf("na verwijderen: %d", code)
249 }
250 if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/info", k2.Key, nil); code != 200 {
251 t.Fatalf("andere server: %d", code)
252 }
253 if code, _ := rapi(t, e.base, e.tok, "GET", "/admin/backup/servers/onbekend", nil); code != 404 {
254 t.Fatalf("onbekend: %d", code)
255 }
256 }
257
258 func TestBackupMultipleServersAndControl(t *testing.T) {
259 e := newBackupEnv(t)
260 fa, fb := newFakeBackup(t), newFakeBackup(t)
261 ka, kb := addBackupServer(t, e, "nas"), addBackupServer(t, e, "offsite")
262 fa.secret, fb.secret = backup.SigningSecret(ka.Key), backup.SigningSecret(kb.Key)
263 for _, c := range []struct {
264 key, url string
265 }{{ka.Key, fa.ts.URL}, {kb.Key, fb.ts.URL}} {
266 code, b := keyed(t, "POST", e.base+"/api/v1/backup/connect", c.key, strings.NewReader(`{"server_url":"`+c.url+`","server_id":"s"}`))
267 if code != 200 {
268 t.Fatalf("connect: %d %s", code, b)
269 }
270 }
271 if code, _ := keyed(t, "POST", e.base+"/api/v1/backup/connect", ka.Key, strings.NewReader(`{"server_url":"ftp://x"}`)); code != 400 {
272 t.Fatalf("ftp-adres: %d", code)
273 }
274
275 // Een schrijvende actie geeft een ondertekende melding aan beide.
276 if code, b := rapi(t, e.base, e.tok, "POST", "/projects", map[string]any{"name": "Notify"}); code/100 != 2 {
277 t.Fatalf("project: %d %s", code, b)
278 }
279 deadline := time.Now().Add(5 * time.Second)
280 for {
281 fa.mu.Lock()
282 na := fa.notifies
283 fa.mu.Unlock()
284 fb.mu.Lock()
285 nb := fb.notifies
286 fb.mu.Unlock()
287 if na > 0 && nb > 0 {
288 break
289 }
290 if time.Now().After(deadline) {
291 t.Fatalf("meldingen: %d en %d", na, nb)
292 }
293 time.Sleep(20 * time.Millisecond)
294 }
295
296 // Lijst via de API en op de pagina.
297 code, b := rapi(t, e.base, e.tok, "GET", "/admin/backup", nil)
298 if code != 200 || strings.Count(string(b), `"connected":true`) != 2 {
299 t.Fatalf("admin backup: %d %s", code, b)
300 }
301 code, b = rapi(t, e.base, e.tok, "GET", "/admin/backup/servers/"+ka.ID, nil)
302 if code != 200 || !strings.Contains(string(b), "bluegit-20261115-120000.tar.gz") || !strings.Contains(string(b), `"retention_days"`) {
303 t.Fatalf("server: %d %s", code, b)
304 }
305 tc, csrf := sessionClient(t, e.st, e.base, e.tim.ID)
306 res, _ := tc.Get(e.base + "/admin/backup")
307 page := body(t, res)
308 for _, want := range []string{"nas", "offsite", `/admin/backup/s/` + ka.ID, `/admin/backup/s/` + kb.ID, `href="/admin/backup"`} {
309 if !strings.Contains(page, want) {
310 t.Fatalf("lijst mist %s: %.600s", want, page)
311 }
312 }
313 res, _ = tc.Get(e.base + "/admin/backup/s/" + ka.ID)
314 page = body(t, res)
315 for _, want := range []string{"bluegit-20261115-120000.tar.gz", `class="backup-danger"`, `name="understood"`, `name="confirm"`,
316 `act/config.update`, `name="retention_days" value="30"`, `act/sync`, `act/archive.delete`} {
317 if !strings.Contains(page, want) {
318 t.Fatalf("pagina mist %s: %.600s", want, page)
319 }
320 }
321
322 // Instellingen en sync vanuit BlueGit (formulier en API).
323 res, _ = tc.PostForm(e.base+"/admin/backup/s/"+ka.ID+"/act/config.update", url.Values{"csrf": {csrf}, "retention_days": {"9"}})
324 res.Body.Close()
325 if code, b := rapi(t, e.base, e.tok, "POST", "/admin/backup/servers/"+ka.ID+"/actions/sync", nil); code != 200 {
326 t.Fatalf("sync: %d %s", code, b)
327 }
328 if code, _ := rapi(t, e.base, e.tok, "POST", "/admin/backup/servers/"+ka.ID+"/actions/archive.download", map[string]any{"name": "x"}); code != 404 {
329 t.Fatalf("niet-BlueGit-actie: %d", code)
330 }
331 if code, _ := rapi(t, e.base, e.tok, "POST", "/admin/backup/servers/"+ka.ID+"/actions/archive.delete", map[string]any{"name": "bluegit-20261115-120000.tar.gz"}); code != 200 {
332 t.Fatalf("archief verwijderen: %d", code)
333 }
334 fa.mu.Lock()
335 if fa.bodies["config"] != `{"retention_days":"9"}` {
336 t.Fatalf("config %q", fa.bodies["config"])
337 }
338 calls := strings.Join(fa.calls, "|")
339 fa.mu.Unlock()
340 if !strings.Contains(calls, `POST /api/v1/admin/sync {"wait":"false"}`) || !strings.Contains(calls, "DELETE /api/v1/admin/archives/bluegit-20261115-120000.tar.gz") {
341 t.Fatalf("calls %s", calls)
342 }
343
344 // Rollback: zonder vinkje niets, verkeerde bevestiging 400, dan goed.
345 arch := "bluegit-20261115-120000.tar.gz"
346 res, _ = tc.PostForm(e.base+"/admin/backup/s/"+ka.ID+"/act/rollback", url.Values{"csrf": {csrf}, "archive": {arch}, "confirm": {arch}})
347 res.Body.Close()
348 if code, _ := rapi(t, e.base, e.tok, "POST", "/admin/backup/servers/"+ka.ID+"/actions/rollback", map[string]any{"archive": arch, "confirm": "ja"}); code != 400 {
349 t.Fatalf("verkeerde bevestiging: %d", code)
350 }
351 fa.mu.Lock()
352 if len(fa.rollback) != 0 {
353 t.Fatal("rollback zonder vinkje of bevestiging")
354 }
355 fa.mu.Unlock()
356 res, _ = tc.PostForm(e.base+"/admin/backup/s/"+ka.ID+"/act/rollback", url.Values{"csrf": {csrf}, "archive": {arch}, "confirm": {arch}, "understood": {"1"}})
357 res.Body.Close()
358 if code, b := rapi(t, e.base, e.tok, "POST", "/admin/backup/servers/"+ka.ID+"/actions/rollback", map[string]any{"archive": arch, "confirm": arch}); code != 202 {
359 t.Fatalf("rollback api: %d %s", code, b)
360 }
361 // Verwijderen laat de backup server ontkoppelen.
362 if code, _ := rapi(t, e.base, e.tok, "DELETE", "/admin/backup/servers/"+kb.ID, nil); code != 204 {
363 t.Fatalf("verwijderen: %d", code)
364 }
365 fb.mu.Lock()
366 if !strings.Contains(strings.Join(fb.calls, "|"), "POST /api/v1/admin/disconnect") {
367 t.Fatalf("geen disconnect: %v", fb.calls)
368 }
369 fb.mu.Unlock()
370 fa.mu.Lock()
371 defer fa.mu.Unlock()
372 if len(fa.rollback) != 2 || fa.badSig != 0 {
373 t.Fatalf("rollbacks %v, foute handtekeningen %d", fa.rollback, fa.badSig)
374 }
375 }
376
377 func TestBackupRestoreStagesAndRestarts(t *testing.T) {
378 e := newBackupEnv(t)
379 restarted := make(chan struct{}, 1)
380 e.srv.RequestRestart = func() { restarted <- struct{}{} }
381 k := addBackupServer(t, e, "nas")
382 // Ongeldig archief: 400, niets klaargezet.
383 if code, _ := keyed(t, "POST", e.base+"/api/v1/backup/restore", k.Key, strings.NewReader("x")); code != 400 {
384 t.Fatalf("ongeldig: %d", code)
385 }
386 if backup.HasPending(e.srv.StateDir) {
387 t.Fatal("READY na fout")
388 }
389 // Een archief uit het eigen manifest terugsturen.
390 tarball := buildTarFromInstance(t, e, k.Key)
391 code, b := keyed(t, "POST", e.base+"/api/v1/backup/restore", k.Key, strings.NewReader(tarball))
392 if code != 202 {
393 t.Fatalf("restore: %d %s", code, b)
394 }
395 select {
396 case <-restarted:
397 case <-time.After(3 * time.Second):
398 t.Fatal("geen herstart")
399 }
400 if !backup.HasPending(e.srv.StateDir) {
401 t.Fatal("geen READY")
402 }
403 restoreBusy.Store(false)
404 }
405
406 func buildTarFromInstance(t *testing.T, e *backupEnv, key string) string {
407 t.Helper()
408 _, b := keyed(t, "GET", e.base+"/api/v1/backup/manifest", key, nil)
409 var m backup.Manifest
410 _ = json.Unmarshal(b, &m)
411 var sb strings.Builder
412 files := map[string]string{}
413 for _, f := range m.Files {
414 _, data := keyed(t, "GET", e.base+"/api/v1/backup/file?path="+url.QueryEscape(f.Path), key, nil)
415 files[f.Path] = string(data)
416 }
417 writeTarGz(t, &sb, files)
418 return sb.String()
419 }
@@ -0,0 +1,419 @@
1package server
2
3import (
4 "context"
5 "encoding/json"
6 "io"
7 "net/http"
8 "net/http/httptest"
9 "net/url"
10 "os"
11 "path/filepath"
12 "strings"
13 "sync"
14 "testing"
15 "time"
16
17 "gitlab.com/Timfa/bluegit/internal/auth"
18 "gitlab.com/Timfa/bluegit/internal/backup"
19 "gitlab.com/Timfa/bluegit/internal/config"
20 "gitlab.com/Timfa/bluegit/internal/store"
21)
22
23type backupEnv struct {
24 srv *Server
25 st *store.Store
26 base string
27 tim store.User
28 tok string
29}
30
31func newBackupEnv(t *testing.T) *backupEnv {
32 t.Helper()
33 stateDir, storage := t.TempDir(), t.TempDir()
34 st, err := store.Open(filepath.Join(stateDir, "bluegit.db"), bytes32())
35 if err != nil {
36 t.Fatal(err)
37 }
38 t.Cleanup(func() { _ = st.Close() })
39 _ = os.WriteFile(filepath.Join(stateDir, "secret.key"), bytes32(), 0o600)
40 cfg := config.Config{
41 Listen: "127.0.0.1:0", StoragePath: storage, StatePath: stateDir,
42 Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test", BaseURL: "https://auth.timfalken.com"},
43 Git: config.Git{Binary: "git", DefaultBranch: "master"},
44 }
45 srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: "/bin/true", StateDir: stateDir}
46 ts := httptest.NewServer(srv.Handler())
47 t.Cleanup(ts.Close)
48 srv.Cfg.BaseURL = ts.URL
49 tim, err := st.UpsertUser(context.Background(), 1, "tim", "", false)
50 if err != nil {
51 t.Fatal(err)
52 }
53 if !tim.InstanceAdmin {
54 t.Skip("eerste gebruiker is geen beheerder")
55 }
56 _ = os.MkdirAll(filepath.Join(storage, "repos", "tim", "app.git"), 0o755)
57 _ = os.WriteFile(filepath.Join(storage, "repos", "tim", "app.git", "HEAD"), []byte("ref: refs/heads/master\n"), 0o644)
58 srv.backupInit()
59 srv.backupNote.Delay = 20 * time.Millisecond
60 return &backupEnv{srv: srv, st: st, base: ts.URL, tim: tim, tok: issue(t, st, tim.ID, "api")}
61}
62
63func keyed(t *testing.T, method, u, key string, body io.Reader) (int, []byte) {
64 t.Helper()
65 req, _ := http.NewRequest(method, u, body)
66 if key != "" {
67 req.Header.Set("Authorization", "Bearer "+key)
68 }
69 res, err := http.DefaultClient.Do(req)
70 if err != nil {
71 t.Fatal(err)
72 }
73 defer res.Body.Close()
74 b, _ := io.ReadAll(res.Body)
75 return res.StatusCode, b
76}
77
78// fakeBackup speelt de backup server: hij controleert elke handtekening.
79type fakeBackup struct {
80 mu sync.Mutex
81 secret string
82 notifies int
83 rollback []string
84 calls []string
85 bodies map[string]string
86 badSig int
87 ts *httptest.Server
88}
89
90func newFakeBackup(t *testing.T) *fakeBackup {
91 f := &fakeBackup{}
92 f.ts = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
93 body, _ := io.ReadAll(r.Body)
94 f.mu.Lock()
95 defer f.mu.Unlock()
96 if err := backup.Verify(r, f.secret, body, time.Now()); err != nil {
97 f.badSig++
98 http.Error(w, `{"error":"sig"}`, 401)
99 return
100 }
101 switch r.URL.Path {
102 case "/api/v1/notify":
103 f.notifies++
104 w.WriteHeader(204)
105 case "/api/v1/archives":
106 _ = json.NewEncoder(w).Encode(map[string]any{"archives": []backup.Archive{{Name: "bluegit-20261115-120000.tar.gz", CreatedAt: time.Date(2026, 11, 15, 12, 0, 0, 0, time.UTC), Size: 3 << 20}}})
107 case "/api/v1/status":
108 _, _ = w.Write([]byte(`{"version":"test","archive_interval":"24h0m0s","retention_days":30,"rollback":{"state":"idle"}}`))
109 case "/api/v1/rollback":
110 var in struct{ Archive string }
111 _ = json.Unmarshal(body, &in)
112 f.rollback = append(f.rollback, in.Archive)
113 w.WriteHeader(202)
114 case "/api/v1/admin/actions":
115 _, _ = w.Write([]byte(`{"actions":[
116 {"name":"status","method":"GET","path":"/api/v1/admin/status","bluegit":true},
117 {"name":"config","method":"GET","path":"/api/v1/admin/config","bluegit":true},
118 {"name":"config.update","method":"PUT","path":"/api/v1/admin/config","bluegit":true},
119 {"name":"sync","method":"POST","path":"/api/v1/admin/sync","bluegit":true},
120 {"name":"archive.delete","method":"DELETE","path":"/api/v1/admin/archives/{name}","bluegit":true,"params":["name"]},
121 {"name":"archive.download","method":"GET","path":"/api/v1/admin/archives/{name}/download","params":["name"]},
122 {"name":"rollback","method":"POST","path":"/api/v1/admin/rollback","bluegit":true},
123 {"name":"disconnect","method":"POST","path":"/api/v1/admin/disconnect","bluegit":true}]}`))
124 case "/api/v1/admin/config":
125 if r.Method == "PUT" {
126 f.calls = append(f.calls, "PUT config")
127 if f.bodies == nil {
128 f.bodies = map[string]string{}
129 }
130 f.bodies["config"] = string(body)
131 }
132 _, _ = w.Write([]byte(`{"fields":[{"key":"archive_interval","label":"Archiefinterval","kind":"duration","value":"24h"},{"key":"retention_days","label":"Bewaartermijn","kind":"int","value":"30"}],"data_dir":"/var/lib/bluegit-backup"}`))
133 case "/api/v1/admin/rollback":
134 var in struct{ Archive, Confirm string }
135 _ = json.Unmarshal(body, &in)
136 if in.Confirm != in.Archive {
137 http.Error(w, `{"error":"confirm"}`, 400)
138 return
139 }
140 f.rollback = append(f.rollback, in.Archive)
141 w.WriteHeader(202)
142 default:
143 if r.URL.Path == "/api/v1/admin/sync" || r.URL.Path == "/api/v1/admin/disconnect" || strings.HasPrefix(r.URL.Path, "/api/v1/admin/archives/") {
144 f.calls = append(f.calls, r.Method+" "+r.URL.Path+" "+string(body))
145 _, _ = w.Write([]byte(`{}`))
146 return
147 }
148 http.NotFound(w, r)
149 }
150 }))
151 t.Cleanup(f.ts.Close)
152 return f
153}
154
155type addedServer struct {
156 ID string `json:"id"`
157 Key string `json:"key"`
158}
159
160func addBackupServer(t *testing.T, e *backupEnv, name string) addedServer {
161 t.Helper()
162 code, b := rapi(t, e.base, e.tok, "POST", "/admin/backup/servers", map[string]any{"name": name})
163 if code != 201 {
164 t.Fatalf("server toevoegen: %d %s", code, b)
165 }
166 var a addedServer
167 _ = json.Unmarshal(b, &a)
168 if !strings.HasPrefix(a.Key, "bgbk_") || a.ID == "" {
169 t.Fatalf("%s", b)
170 }
171 return a
172}
173
174func TestBackupKeyAndKeyedAPI(t *testing.T) {
175 e := newBackupEnv(t)
176 // Zonder key: 401. Met een gewoon toegangstoken: ook 401.
177 if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/manifest", "", nil); code != 401 {
178 t.Fatalf("zonder key: %d", code)
179 }
180 if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/manifest", e.tok, nil); code != 401 {
181 t.Fatalf("bg_-token: %d", code)
182 }
183 // Alleen een beheerder maakt een backup server.
184 bob, _ := e.st.UpsertUser(context.Background(), 2, "bob", "", false)
185 if code, _ := rapi(t, e.base, issue(t, e.st, bob.ID, "api"), "POST", "/admin/backup/servers", map[string]any{"name": "x"}); code != 403 {
186 t.Fatalf("bob maakt server: %d", code)
187 }
188 k := addBackupServer(t, e, "nas")
189 code, b := keyed(t, "GET", e.base+"/api/v1/backup/info", k.Key, nil)
190 var info struct {
191 InstanceID string `json:"instance_id"`
192 Name string `json:"name"`
193 }
194 _ = json.Unmarshal(b, &info)
195 if code != 200 || info.InstanceID == "" || info.Name != "nas" {
196 t.Fatalf("info: %d %s", code, b)
197 }
198 code, b = keyed(t, "GET", e.base+"/api/v1/backup/manifest", k.Key, nil)
199 var m backup.Manifest
200 _ = json.Unmarshal(b, &m)
201 if code != 200 || m.Instance != info.InstanceID {
202 t.Fatalf("manifest: %d %.300s", code, b)
203 }
204 have := map[string]bool{}
205 for _, f := range m.Files {
206 have[f.Path] = true
207 }
208 for _, want := range []string{"state/bluegit.db", "state/secret.key", "data/repos/tim/app.git/HEAD"} {
209 if !have[want] {
210 t.Fatalf("manifest mist %s: %v", want, have)
211 }
212 }
213 code, b = keyed(t, "GET", e.base+"/api/v1/backup/file?path="+url.QueryEscape("data/repos/tim/app.git/HEAD"), k.Key, nil)
214 if code != 200 || string(b) != "ref: refs/heads/master\n" {
215 t.Fatalf("file: %d %q", code, b)
216 }
217 code, b = keyed(t, "GET", e.base+"/api/v1/backup/file?path=state/bluegit.db", k.Key, nil)
218 if code != 200 || !strings.HasPrefix(string(b), "SQLite format 3") {
219 t.Fatalf("db-kopie: %d %.20q", code, b)
220 }
221 for _, bad := range []string{"state/backup.json", "state/storage_path", "../../etc/passwd", "data/repos/../../x"} {
222 if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/file?path="+url.QueryEscape(bad), k.Key, nil); code != 404 {
223 t.Fatalf("%s: %d", bad, code)
224 }
225 }
226 // Een tweede server met een eigen key; nieuwe key voor de eerste.
227 k2 := addBackupServer(t, e, "offsite")
228 code, b = rapi(t, e.base, e.tok, "POST", "/admin/backup/servers/"+k.ID+"/key", nil)
229 var rot addedServer
230 _ = json.Unmarshal(b, &rot)
231 if code != 201 || rot.Key == k.Key {
232 t.Fatalf("nieuwe key: %d %s", code, b)
233 }
234 if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/info", k.Key, nil); code != 401 {
235 t.Fatalf("oude key werkt nog: %d", code)
236 }
237 if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/info", rot.Key, nil); code != 200 {
238 t.Fatalf("nieuwe key: %d", code)
239 }
240 if code, b := rapi(t, e.base, e.tok, "PUT", "/admin/backup/servers/"+k2.ID, map[string]any{"name": "Offsite 2"}); code != 200 || !strings.Contains(string(b), "Offsite 2") {
241 t.Fatalf("hernoemen: %d %s", code, b)
242 }
243 // Verwijderen: die key werkt niet meer, de andere wel.
244 if code, _ := rapi(t, e.base, e.tok, "DELETE", "/admin/backup/servers/"+k.ID, nil); code != 204 {
245 t.Fatalf("verwijderen: %d", code)
246 }
247 if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/info", rot.Key, nil); code != 401 {
248 t.Fatalf("na verwijderen: %d", code)
249 }
250 if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/info", k2.Key, nil); code != 200 {
251 t.Fatalf("andere server: %d", code)
252 }
253 if code, _ := rapi(t, e.base, e.tok, "GET", "/admin/backup/servers/onbekend", nil); code != 404 {
254 t.Fatalf("onbekend: %d", code)
255 }
256}
257
258func TestBackupMultipleServersAndControl(t *testing.T) {
259 e := newBackupEnv(t)
260 fa, fb := newFakeBackup(t), newFakeBackup(t)
261 ka, kb := addBackupServer(t, e, "nas"), addBackupServer(t, e, "offsite")
262 fa.secret, fb.secret = backup.SigningSecret(ka.Key), backup.SigningSecret(kb.Key)
263 for _, c := range []struct {
264 key, url string
265 }{{ka.Key, fa.ts.URL}, {kb.Key, fb.ts.URL}} {
266 code, b := keyed(t, "POST", e.base+"/api/v1/backup/connect", c.key, strings.NewReader(`{"server_url":"`+c.url+`","server_id":"s"}`))
267 if code != 200 {
268 t.Fatalf("connect: %d %s", code, b)
269 }
270 }
271 if code, _ := keyed(t, "POST", e.base+"/api/v1/backup/connect", ka.Key, strings.NewReader(`{"server_url":"ftp://x"}`)); code != 400 {
272 t.Fatalf("ftp-adres: %d", code)
273 }
274
275 // Een schrijvende actie geeft een ondertekende melding aan beide.
276 if code, b := rapi(t, e.base, e.tok, "POST", "/projects", map[string]any{"name": "Notify"}); code/100 != 2 {
277 t.Fatalf("project: %d %s", code, b)
278 }
279 deadline := time.Now().Add(5 * time.Second)
280 for {
281 fa.mu.Lock()
282 na := fa.notifies
283 fa.mu.Unlock()
284 fb.mu.Lock()
285 nb := fb.notifies
286 fb.mu.Unlock()
287 if na > 0 && nb > 0 {
288 break
289 }
290 if time.Now().After(deadline) {
291 t.Fatalf("meldingen: %d en %d", na, nb)
292 }
293 time.Sleep(20 * time.Millisecond)
294 }
295
296 // Lijst via de API en op de pagina.
297 code, b := rapi(t, e.base, e.tok, "GET", "/admin/backup", nil)
298 if code != 200 || strings.Count(string(b), `"connected":true`) != 2 {
299 t.Fatalf("admin backup: %d %s", code, b)
300 }
301 code, b = rapi(t, e.base, e.tok, "GET", "/admin/backup/servers/"+ka.ID, nil)
302 if code != 200 || !strings.Contains(string(b), "bluegit-20261115-120000.tar.gz") || !strings.Contains(string(b), `"retention_days"`) {
303 t.Fatalf("server: %d %s", code, b)
304 }
305 tc, csrf := sessionClient(t, e.st, e.base, e.tim.ID)
306 res, _ := tc.Get(e.base + "/admin/backup")
307 page := body(t, res)
308 for _, want := range []string{"nas", "offsite", `/admin/backup/s/` + ka.ID, `/admin/backup/s/` + kb.ID, `href="/admin/backup"`} {
309 if !strings.Contains(page, want) {
310 t.Fatalf("lijst mist %s: %.600s", want, page)
311 }
312 }
313 res, _ = tc.Get(e.base + "/admin/backup/s/" + ka.ID)
314 page = body(t, res)
315 for _, want := range []string{"bluegit-20261115-120000.tar.gz", `class="backup-danger"`, `name="understood"`, `name="confirm"`,
316 `act/config.update`, `name="retention_days" value="30"`, `act/sync`, `act/archive.delete`} {
317 if !strings.Contains(page, want) {
318 t.Fatalf("pagina mist %s: %.600s", want, page)
319 }
320 }
321
322 // Instellingen en sync vanuit BlueGit (formulier en API).
323 res, _ = tc.PostForm(e.base+"/admin/backup/s/"+ka.ID+"/act/config.update", url.Values{"csrf": {csrf}, "retention_days": {"9"}})
324 res.Body.Close()
325 if code, b := rapi(t, e.base, e.tok, "POST", "/admin/backup/servers/"+ka.ID+"/actions/sync", nil); code != 200 {
326 t.Fatalf("sync: %d %s", code, b)
327 }
328 if code, _ := rapi(t, e.base, e.tok, "POST", "/admin/backup/servers/"+ka.ID+"/actions/archive.download", map[string]any{"name": "x"}); code != 404 {
329 t.Fatalf("niet-BlueGit-actie: %d", code)
330 }
331 if code, _ := rapi(t, e.base, e.tok, "POST", "/admin/backup/servers/"+ka.ID+"/actions/archive.delete", map[string]any{"name": "bluegit-20261115-120000.tar.gz"}); code != 200 {
332 t.Fatalf("archief verwijderen: %d", code)
333 }
334 fa.mu.Lock()
335 if fa.bodies["config"] != `{"retention_days":"9"}` {
336 t.Fatalf("config %q", fa.bodies["config"])
337 }
338 calls := strings.Join(fa.calls, "|")
339 fa.mu.Unlock()
340 if !strings.Contains(calls, `POST /api/v1/admin/sync {"wait":"false"}`) || !strings.Contains(calls, "DELETE /api/v1/admin/archives/bluegit-20261115-120000.tar.gz") {
341 t.Fatalf("calls %s", calls)
342 }
343
344 // Rollback: zonder vinkje niets, verkeerde bevestiging 400, dan goed.
345 arch := "bluegit-20261115-120000.tar.gz"
346 res, _ = tc.PostForm(e.base+"/admin/backup/s/"+ka.ID+"/act/rollback", url.Values{"csrf": {csrf}, "archive": {arch}, "confirm": {arch}})
347 res.Body.Close()
348 if code, _ := rapi(t, e.base, e.tok, "POST", "/admin/backup/servers/"+ka.ID+"/actions/rollback", map[string]any{"archive": arch, "confirm": "ja"}); code != 400 {
349 t.Fatalf("verkeerde bevestiging: %d", code)
350 }
351 fa.mu.Lock()
352 if len(fa.rollback) != 0 {
353 t.Fatal("rollback zonder vinkje of bevestiging")
354 }
355 fa.mu.Unlock()
356 res, _ = tc.PostForm(e.base+"/admin/backup/s/"+ka.ID+"/act/rollback", url.Values{"csrf": {csrf}, "archive": {arch}, "confirm": {arch}, "understood": {"1"}})
357 res.Body.Close()
358 if code, b := rapi(t, e.base, e.tok, "POST", "/admin/backup/servers/"+ka.ID+"/actions/rollback", map[string]any{"archive": arch, "confirm": arch}); code != 202 {
359 t.Fatalf("rollback api: %d %s", code, b)
360 }
361 // Verwijderen laat de backup server ontkoppelen.
362 if code, _ := rapi(t, e.base, e.tok, "DELETE", "/admin/backup/servers/"+kb.ID, nil); code != 204 {
363 t.Fatalf("verwijderen: %d", code)
364 }
365 fb.mu.Lock()
366 if !strings.Contains(strings.Join(fb.calls, "|"), "POST /api/v1/admin/disconnect") {
367 t.Fatalf("geen disconnect: %v", fb.calls)
368 }
369 fb.mu.Unlock()
370 fa.mu.Lock()
371 defer fa.mu.Unlock()
372 if len(fa.rollback) != 2 || fa.badSig != 0 {
373 t.Fatalf("rollbacks %v, foute handtekeningen %d", fa.rollback, fa.badSig)
374 }
375}
376
377func TestBackupRestoreStagesAndRestarts(t *testing.T) {
378 e := newBackupEnv(t)
379 restarted := make(chan struct{}, 1)
380 e.srv.RequestRestart = func() { restarted <- struct{}{} }
381 k := addBackupServer(t, e, "nas")
382 // Ongeldig archief: 400, niets klaargezet.
383 if code, _ := keyed(t, "POST", e.base+"/api/v1/backup/restore", k.Key, strings.NewReader("x")); code != 400 {
384 t.Fatalf("ongeldig: %d", code)
385 }
386 if backup.HasPending(e.srv.StateDir) {
387 t.Fatal("READY na fout")
388 }
389 // Een archief uit het eigen manifest terugsturen.
390 tarball := buildTarFromInstance(t, e, k.Key)
391 code, b := keyed(t, "POST", e.base+"/api/v1/backup/restore", k.Key, strings.NewReader(tarball))
392 if code != 202 {
393 t.Fatalf("restore: %d %s", code, b)
394 }
395 select {
396 case <-restarted:
397 case <-time.After(3 * time.Second):
398 t.Fatal("geen herstart")
399 }
400 if !backup.HasPending(e.srv.StateDir) {
401 t.Fatal("geen READY")
402 }
403 restoreBusy.Store(false)
404}
405
406func buildTarFromInstance(t *testing.T, e *backupEnv, key string) string {
407 t.Helper()
408 _, b := keyed(t, "GET", e.base+"/api/v1/backup/manifest", key, nil)
409 var m backup.Manifest
410 _ = json.Unmarshal(b, &m)
411 var sb strings.Builder
412 files := map[string]string{}
413 for _, f := range m.Files {
414 _, data := keyed(t, "GET", e.base+"/api/v1/backup/file?path="+url.QueryEscape(f.Path), key, nil)
415 files[f.Path] = string(data)
416 }
417 writeTarGz(t, &sb, files)
418 return sb.String()
419}
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 +16 −0
@@ -1874,3 +1874,19 @@ 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; }
1888 .backup-actions { margin-top: 10px; }
1889 .backup-actions form, .backup-archives td.act form { display: inline-block; margin: 0 4px 4px 0; }
1890 .backup-config { display: grid; gap: 10px; max-width: 46em; }
1891 .backup-config label { display: grid; gap: 2px; }
1892 .backup-status th { width: 14em; }
@@ -1874,3 +1874,19 @@ 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; }
1888.backup-actions { margin-top: 10px; }
1889.backup-actions form, .backup-archives td.act form { display: inline-block; margin: 0 4px 4px 0; }
1890.backup-config { display: grid; gap: 10px; max-width: 46em; }
1891.backup-config label { display: grid; gap: 2px; }
1892.backup-status th { width: 14em; }
internal/server/templates/backup.html added +149 −0
@@ -0,0 +1,149 @@
1 {{define "adminbackup"}}
2 {{template "layout-start" .}}
3 {{with .Backup}}
4 {{if .Current}}{{with .Current}}
5 <p><a href="/admin/backup">← {{t "backup.back"}}</a></p>
6 <h1>{{.Conn.Name}}</h1>
7 {{if $.Backup.NewKey}}
8 <section class="panel" id="backup-newkey">
9 <p><strong>{{t "backup.key.once"}}</strong></p>
10 <p class="code backup-key">{{$.Backup.NewKey}}</p>
11 </section>
12 {{end}}
13
14 <section class="panel" id="backup-server">
15 <h2>{{t "backup.server.title"}}</h2>
16 {{if .Conn.Connected}}
17 <p>{{t "backup.server.connected" .Conn.ServerURL}} <span class="muted">{{t "backup.server.seen"}} {{date .Conn.LastSeen}}</span></p>
18 {{if .RemoteErr}}<p class="backup-danger-text">{{t "backup.server.unreachable" .RemoteErr}}</p>{{end}}
19 {{with .Remote}}
20 <table class="rui-table backup-status">
21 <tr><th>{{t "backup.status.lastSync"}}</th><td>{{if .LastSync.IsZero}}—{{else}}{{date .LastSync}}{{end}}{{if .SyncError}} <span class="backup-danger-text">{{.SyncError}}</span>{{end}}</td></tr>
22 <tr><th>{{t "backup.status.result"}}</th><td>{{t "backup.status.resultText" .LastStats.Files .LastStats.Downloaded .LastStats.Deleted}}</td></tr>
23 <tr><th>{{t "backup.status.counts"}}</th><td>{{.Syncs}} / {{.Notifies}}</td></tr>
24 <tr><th>{{t "backup.status.mirror"}}</th><td>{{printf "%.1f MB" (mb .MirrorBytes)}}</td></tr>
25 <tr><th>{{t "backup.archives.title"}}</th><td>{{.Archives}}{{if not .LastArchive.IsZero}} · {{date .LastArchive}}{{end}}{{if .ArchiveError}} <span class="backup-danger-text">{{.ArchiveError}}</span>{{end}}</td></tr>
26 {{if .Rollback.State}}<tr><th>{{t "backup.status.rollback"}}</th><td>{{.Rollback.State}} {{.Rollback.Archive}}{{if .Rollback.Error}} <span class="backup-danger-text">{{.Rollback.Error}}</span>{{end}}</td></tr>{{end}}
27 <tr><th>{{t "backup.status.version"}}</th><td>{{.Version}}</td></tr>
28 </table>
29 <div class="row backup-actions">
30 <form method="post" action="/admin/backup/s/{{$.Backup.Current.Conn.ID}}/act/sync"><input type="hidden" name="csrf" value="{{$.CSRF}}"><button type="submit">{{t "backup.act.sync"}}</button></form>
31 <form method="post" action="/admin/backup/s/{{$.Backup.Current.Conn.ID}}/act/archive"><input type="hidden" name="csrf" value="{{$.CSRF}}"><button type="submit">{{t "backup.act.archive"}}</button></form>
32 <form method="post" action="/admin/backup/s/{{$.Backup.Current.Conn.ID}}/act/prune"><input type="hidden" name="csrf" value="{{$.CSRF}}"><button type="submit" class="ghost">{{t "backup.act.prune"}}</button></form>
33 </div>
34 {{end}}
35 {{else}}
36 <p class="muted">{{t "backup.server.none"}}</p>
37 {{end}}
38 </section>
39
40 {{with .Config}}
41 <section class="panel" id="backup-config">
42 <h2>{{t "backup.config.title"}}</h2>
43 {{if .Restart}}<p class="muted">{{t "backup.config.restart"}}</p>{{end}}
44 <form method="post" action="/admin/backup/s/{{$.Backup.Current.Conn.ID}}/act/config.update" class="backup-config">
45 <input type="hidden" name="csrf" value="{{$.CSRF}}">
46 {{range .Fields}}
47 <label>{{.Label}} <input type="text" name="{{.Key}}" value="{{.Value}}"> <span class="muted">{{.Help}}</span></label>
48 {{end}}
49 <button type="submit">{{t "backup.config.save"}}</button>
50 </form>
51 </section>
52 {{end}}
53
54 {{if .Conn.Connected}}
55 <section class="panel" id="backup-archives">
56 <h2>{{t "backup.archives.title"}}</h2>
57 {{if .Archives}}
58 <div class="backup-danger" role="alert">
59 <strong>{{t "backup.warn.title"}}</strong>
60 <p>{{t "backup.warn.body"}}</p>
61 </div>
62 <div class="hscroll">
63 <table class="rui-table backup-archives">
64 <thead><tr><th>{{t "backup.col.archive"}}</th><th>{{t "backup.col.created"}}</th><th>{{t "backup.col.size"}}</th><th></th></tr></thead>
65 <tbody>
66 {{range .Archives}}<tr>
67 <td><code>{{.Name}}</code></td>
68 <td>{{date .CreatedAt}}</td>
69 <td>{{printf "%.1f MB" (mb .Size)}}</td>
70 <td class="act">
71 <form method="post" action="/admin/backup/s/{{$.Backup.Current.Conn.ID}}/act/archive.delete" data-confirm="{{t "backup.archive.deleteAsk" .Name}}">
72 <input type="hidden" name="csrf" value="{{$.CSRF}}"><input type="hidden" name="name" value="{{.Name}}">
73 <button type="submit" class="ghost">{{t "backup.archive.delete"}}</button>
74 </form>
75 <details class="backup-rollback">
76 <summary class="danger">{{t "backup.rollback"}}</summary>
77 <form method="post" action="/admin/backup/s/{{$.Backup.Current.Conn.ID}}/act/rollback" data-confirm="{{t "backup.rollbackAsk" .Name}}">
78 <input type="hidden" name="csrf" value="{{$.CSRF}}">
79 <input type="hidden" name="archive" value="{{.Name}}">
80 <p class="backup-danger-text">{{t "backup.warn.body"}}</p>
81 <label><input type="checkbox" name="understood" value="1" required> {{t "backup.understood"}}</label>
82 <label>{{t "backup.typeName"}} <input type="text" name="confirm" required autocomplete="off" placeholder="{{.Name}}"></label>
83 <button type="submit" class="danger">{{t "backup.rollbackNow"}}</button>
84 </form>
85 </details>
86 </td>
87 </tr>{{end}}
88 </tbody>
89 </table>
90 </div>
91 {{else}}<p class="muted">{{t "backup.archives.none"}}</p>{{end}}
92 </section>
93 {{end}}
94
95 <section class="panel" id="backup-key">
96 <h2>{{t "backup.key.title"}}</h2>
97 <p>{{t "backup.key.active" .Conn.KeyHint}} <span class="muted">{{t "backup.key.by" .Conn.CreatedBy}} · {{date .Conn.CreatedAt}}</span></p>
98 <form method="post" action="/admin/backup/s/{{.Conn.ID}}/key" data-confirm="{{t "backup.key.replaceAsk"}}">
99 <input type="hidden" name="csrf" value="{{$.CSRF}}">
100 <button type="submit">{{t "backup.key.replace"}}</button>
101 </form>
102 <form method="post" action="/admin/backup/s/{{.Conn.ID}}/rename" class="row">
103 <input type="hidden" name="csrf" value="{{$.CSRF}}">
104 <label>{{t "backup.servers.name"}} <input type="text" name="name" value="{{.Conn.Name}}" maxlength="60" required></label>
105 <button type="submit" class="ghost">{{t "backup.rename"}}</button>
106 </form>
107 <form method="post" action="/admin/backup/s/{{.Conn.ID}}/remove" data-confirm="{{t "backup.key.revokeAsk"}}">
108 <input type="hidden" name="csrf" value="{{$.CSRF}}">
109 <button type="submit" class="danger">{{t "backup.key.revoke"}}</button>
110 </form>
111 </section>
112 {{end}}
113 {{else}}
114 <h1>{{t "backup.title"}}</h1>
115 <p class="muted">{{t "backup.lead"}}</p>
116 <section class="panel" id="backup-servers">
117 <h2>{{t "backup.servers.title"}}</h2>
118 {{if .Servers}}
119 <div class="hscroll">
120 <table class="rui-table backup-servers">
121 <thead><tr><th>{{t "backup.col.name"}}</th><th>{{t "backup.col.state"}}</th><th>{{t "backup.col.address"}}</th><th>{{t "backup.server.seen"}}</th><th></th></tr></thead>
122 <tbody>
123 {{range .Servers}}<tr>
124 <td><a href="/admin/backup/s/{{.ID}}">{{.Name}}</a></td>
125 <td>{{if .Connected}}{{t "backup.state.connected"}}{{else}}{{t "backup.state.waiting"}}{{end}}</td>
126 <td>{{if .ServerURL}}<code>{{.ServerURL}}</code>{{else}}—{{end}}</td>
127 <td>{{if .LastSeen.IsZero}}—{{else}}{{date .LastSeen}}{{end}}</td>
128 <td><a href="/admin/backup/s/{{.ID}}">{{t "backup.open"}}</a></td>
129 </tr>{{end}}
130 </tbody>
131 </table>
132 </div>
133 {{else}}
134 <p class="muted">{{t "backup.servers.none"}}</p>
135 {{end}}
136 {{if lt (len .Servers) .Max}}
137 <form method="post" action="/admin/backup/servers" class="row">
138 <input type="hidden" name="csrf" value="{{$.CSRF}}">
139 <label>{{t "backup.servers.name"}} <input type="text" name="name" maxlength="60" placeholder="{{t "backup.servers.namePh"}}"></label>
140 <button type="submit">{{t "backup.servers.add"}}</button>
141 </form>
142 {{end}}
143 <p class="muted">{{t "backup.multi"}}</p>
144 <p class="muted">{{t "backup.instance" .InstanceID}}</p>
145 </section>
146 {{end}}
147 {{end}}
148 {{template "layout-end" .}}
149 {{end}}
@@ -0,0 +1,149 @@
1{{define "adminbackup"}}
2{{template "layout-start" .}}
3{{with .Backup}}
4{{if .Current}}{{with .Current}}
5<p><a href="/admin/backup">← {{t "backup.back"}}</a></p>
6<h1>{{.Conn.Name}}</h1>
7{{if $.Backup.NewKey}}
8<section class="panel" id="backup-newkey">
9 <p><strong>{{t "backup.key.once"}}</strong></p>
10 <p class="code backup-key">{{$.Backup.NewKey}}</p>
11</section>
12{{end}}
13
14<section class="panel" id="backup-server">
15 <h2>{{t "backup.server.title"}}</h2>
16 {{if .Conn.Connected}}
17 <p>{{t "backup.server.connected" .Conn.ServerURL}} <span class="muted">{{t "backup.server.seen"}} {{date .Conn.LastSeen}}</span></p>
18 {{if .RemoteErr}}<p class="backup-danger-text">{{t "backup.server.unreachable" .RemoteErr}}</p>{{end}}
19 {{with .Remote}}
20 <table class="rui-table backup-status">
21 <tr><th>{{t "backup.status.lastSync"}}</th><td>{{if .LastSync.IsZero}}—{{else}}{{date .LastSync}}{{end}}{{if .SyncError}} <span class="backup-danger-text">{{.SyncError}}</span>{{end}}</td></tr>
22 <tr><th>{{t "backup.status.result"}}</th><td>{{t "backup.status.resultText" .LastStats.Files .LastStats.Downloaded .LastStats.Deleted}}</td></tr>
23 <tr><th>{{t "backup.status.counts"}}</th><td>{{.Syncs}} / {{.Notifies}}</td></tr>
24 <tr><th>{{t "backup.status.mirror"}}</th><td>{{printf "%.1f MB" (mb .MirrorBytes)}}</td></tr>
25 <tr><th>{{t "backup.archives.title"}}</th><td>{{.Archives}}{{if not .LastArchive.IsZero}} · {{date .LastArchive}}{{end}}{{if .ArchiveError}} <span class="backup-danger-text">{{.ArchiveError}}</span>{{end}}</td></tr>
26 {{if .Rollback.State}}<tr><th>{{t "backup.status.rollback"}}</th><td>{{.Rollback.State}} {{.Rollback.Archive}}{{if .Rollback.Error}} <span class="backup-danger-text">{{.Rollback.Error}}</span>{{end}}</td></tr>{{end}}
27 <tr><th>{{t "backup.status.version"}}</th><td>{{.Version}}</td></tr>
28 </table>
29 <div class="row backup-actions">
30 <form method="post" action="/admin/backup/s/{{$.Backup.Current.Conn.ID}}/act/sync"><input type="hidden" name="csrf" value="{{$.CSRF}}"><button type="submit">{{t "backup.act.sync"}}</button></form>
31 <form method="post" action="/admin/backup/s/{{$.Backup.Current.Conn.ID}}/act/archive"><input type="hidden" name="csrf" value="{{$.CSRF}}"><button type="submit">{{t "backup.act.archive"}}</button></form>
32 <form method="post" action="/admin/backup/s/{{$.Backup.Current.Conn.ID}}/act/prune"><input type="hidden" name="csrf" value="{{$.CSRF}}"><button type="submit" class="ghost">{{t "backup.act.prune"}}</button></form>
33 </div>
34 {{end}}
35 {{else}}
36 <p class="muted">{{t "backup.server.none"}}</p>
37 {{end}}
38</section>
39
40{{with .Config}}
41<section class="panel" id="backup-config">
42 <h2>{{t "backup.config.title"}}</h2>
43 {{if .Restart}}<p class="muted">{{t "backup.config.restart"}}</p>{{end}}
44 <form method="post" action="/admin/backup/s/{{$.Backup.Current.Conn.ID}}/act/config.update" class="backup-config">
45 <input type="hidden" name="csrf" value="{{$.CSRF}}">
46 {{range .Fields}}
47 <label>{{.Label}} <input type="text" name="{{.Key}}" value="{{.Value}}"> <span class="muted">{{.Help}}</span></label>
48 {{end}}
49 <button type="submit">{{t "backup.config.save"}}</button>
50 </form>
51</section>
52{{end}}
53
54{{if .Conn.Connected}}
55<section class="panel" id="backup-archives">
56 <h2>{{t "backup.archives.title"}}</h2>
57 {{if .Archives}}
58 <div class="backup-danger" role="alert">
59 <strong>{{t "backup.warn.title"}}</strong>
60 <p>{{t "backup.warn.body"}}</p>
61 </div>
62 <div class="hscroll">
63 <table class="rui-table backup-archives">
64 <thead><tr><th>{{t "backup.col.archive"}}</th><th>{{t "backup.col.created"}}</th><th>{{t "backup.col.size"}}</th><th></th></tr></thead>
65 <tbody>
66 {{range .Archives}}<tr>
67 <td><code>{{.Name}}</code></td>
68 <td>{{date .CreatedAt}}</td>
69 <td>{{printf "%.1f MB" (mb .Size)}}</td>
70 <td class="act">
71 <form method="post" action="/admin/backup/s/{{$.Backup.Current.Conn.ID}}/act/archive.delete" data-confirm="{{t "backup.archive.deleteAsk" .Name}}">
72 <input type="hidden" name="csrf" value="{{$.CSRF}}"><input type="hidden" name="name" value="{{.Name}}">
73 <button type="submit" class="ghost">{{t "backup.archive.delete"}}</button>
74 </form>
75 <details class="backup-rollback">
76 <summary class="danger">{{t "backup.rollback"}}</summary>
77 <form method="post" action="/admin/backup/s/{{$.Backup.Current.Conn.ID}}/act/rollback" data-confirm="{{t "backup.rollbackAsk" .Name}}">
78 <input type="hidden" name="csrf" value="{{$.CSRF}}">
79 <input type="hidden" name="archive" value="{{.Name}}">
80 <p class="backup-danger-text">{{t "backup.warn.body"}}</p>
81 <label><input type="checkbox" name="understood" value="1" required> {{t "backup.understood"}}</label>
82 <label>{{t "backup.typeName"}} <input type="text" name="confirm" required autocomplete="off" placeholder="{{.Name}}"></label>
83 <button type="submit" class="danger">{{t "backup.rollbackNow"}}</button>
84 </form>
85 </details>
86 </td>
87 </tr>{{end}}
88 </tbody>
89 </table>
90 </div>
91 {{else}}<p class="muted">{{t "backup.archives.none"}}</p>{{end}}
92</section>
93{{end}}
94
95<section class="panel" id="backup-key">
96 <h2>{{t "backup.key.title"}}</h2>
97 <p>{{t "backup.key.active" .Conn.KeyHint}} <span class="muted">{{t "backup.key.by" .Conn.CreatedBy}} · {{date .Conn.CreatedAt}}</span></p>
98 <form method="post" action="/admin/backup/s/{{.Conn.ID}}/key" data-confirm="{{t "backup.key.replaceAsk"}}">
99 <input type="hidden" name="csrf" value="{{$.CSRF}}">
100 <button type="submit">{{t "backup.key.replace"}}</button>
101 </form>
102 <form method="post" action="/admin/backup/s/{{.Conn.ID}}/rename" class="row">
103 <input type="hidden" name="csrf" value="{{$.CSRF}}">
104 <label>{{t "backup.servers.name"}} <input type="text" name="name" value="{{.Conn.Name}}" maxlength="60" required></label>
105 <button type="submit" class="ghost">{{t "backup.rename"}}</button>
106 </form>
107 <form method="post" action="/admin/backup/s/{{.Conn.ID}}/remove" data-confirm="{{t "backup.key.revokeAsk"}}">
108 <input type="hidden" name="csrf" value="{{$.CSRF}}">
109 <button type="submit" class="danger">{{t "backup.key.revoke"}}</button>
110 </form>
111</section>
112{{end}}
113{{else}}
114<h1>{{t "backup.title"}}</h1>
115<p class="muted">{{t "backup.lead"}}</p>
116<section class="panel" id="backup-servers">
117 <h2>{{t "backup.servers.title"}}</h2>
118 {{if .Servers}}
119 <div class="hscroll">
120 <table class="rui-table backup-servers">
121 <thead><tr><th>{{t "backup.col.name"}}</th><th>{{t "backup.col.state"}}</th><th>{{t "backup.col.address"}}</th><th>{{t "backup.server.seen"}}</th><th></th></tr></thead>
122 <tbody>
123 {{range .Servers}}<tr>
124 <td><a href="/admin/backup/s/{{.ID}}">{{.Name}}</a></td>
125 <td>{{if .Connected}}{{t "backup.state.connected"}}{{else}}{{t "backup.state.waiting"}}{{end}}</td>
126 <td>{{if .ServerURL}}<code>{{.ServerURL}}</code>{{else}}—{{end}}</td>
127 <td>{{if .LastSeen.IsZero}}—{{else}}{{date .LastSeen}}{{end}}</td>
128 <td><a href="/admin/backup/s/{{.ID}}">{{t "backup.open"}}</a></td>
129 </tr>{{end}}
130 </tbody>
131 </table>
132 </div>
133 {{else}}
134 <p class="muted">{{t "backup.servers.none"}}</p>
135 {{end}}
136 {{if lt (len .Servers) .Max}}
137 <form method="post" action="/admin/backup/servers" class="row">
138 <input type="hidden" name="csrf" value="{{$.CSRF}}">
139 <label>{{t "backup.servers.name"}} <input type="text" name="name" maxlength="60" placeholder="{{t "backup.servers.namePh"}}"></label>
140 <button type="submit">{{t "backup.servers.add"}}</button>
141 </form>
142 {{end}}
143 <p class="muted">{{t "backup.multi"}}</p>
144 <p class="muted">{{t "backup.instance" .InstanceID}}</p>
145</section>
146{{end}}
147{{end}}
148{{template "layout-end" .}}
149{{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}