Merge branch 'feature/backup-server' into stage
@@ -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
28
Een repository hoort bij een gebruiker of bij een groep. De hoogste rol telt.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.git116
- [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
@@ -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 err76
return err75
}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 err87
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.Bool106
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 = m125
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 err192
return err177
}193
}194
if restart.Load() {195
// Zelfde PID, dus systemd en een testharnas merken alleen een korte196
// onderbreking. De nieuwe start zet de klaarstaande backup neer.197
log.Warn("herstart na terugzetten van een backup")198
<-shutDone199
_ = st.Close()200
self, err := os.Executable()201
if err != nil {202
return err203
}204
return syscall.Exec(self, os.Args, os.Environ())205
}178
return nil206
return nil179
}207
}180
208
@@ -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
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 BlueGit8
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
## Protocol35
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
```text51
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 zit67
68
```text69
state/bluegit.db consistente kopie (VACUUM INTO), niet het live bestand70
state/secret.key nodig voor de versleutelde geheimen in de database71
state/ssh/… SSH-hostkey72
state/logos/…, state/avatars/…73
data/repos/… bare repositories74
data/releases/… release-assets (zonder .incoming)75
data/artifacts/… CI-artifacts76
```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
## Terugzetten81
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`.@@ -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 sub61
## Releases publiek bij een privé repo61
## Releases publiek bij een privé repo62
62
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).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
## Backup66
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).@@ -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 @@1
package backup2
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 []string192
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 string219
typ byte220
}221
222
func tgz(t *testing.T, files []tf) []byte {223
var buf bytes.Buffer224
gz := gzip.NewWriter(&buf)225
tw := tar.NewWriter(gz)226
for _, f := range files {227
typ := f.typ228
if typ == 0 {229
typ = tar.TypeReg230
}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
return276
}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 hun335
// 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.Mutex339
busy := 0340
n := 0341
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 err357
}358
a, b := base, base359
a.Conn, b.Conn = "aaa", "bbb"360
var wg sync.WaitGroup361
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 <- err369
}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,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 @@1
package backup2
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 *Manager53
HTTP *http.Client54
Now func() time.Time55
}56
57
// RemoteError is een foutantwoord van de backup server.58
type RemoteError struct {59
Status int60
Msg string61
}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 het66
// 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, err74
}75
var body []byte76
if in != nil {77
if body, err = json.Marshal(in); err != nil {78
return 0, nil, err79
}80
}81
req, err := http.NewRequestWithContext(ctx, method, conn.ServerURL+p, bytes.NewReader(body))82
if err != nil {83
return 0, nil, err84
}85
if in != nil {86
req.Header.Set("Content-Type", "application/json")87
}88
now := time.Now89
if c.Now != nil {90
now = c.Now91
}92
Sign(req, conn.SignSecret, inst, body, now())93
hc := c.HTTP94
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, err100
}101
defer resp.Body.Close()102
raw, _ := io.ReadAll(io.LimitReader(resp.Body, 4<<20))103
return resp.StatusCode, raw, nil104
}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 err110
}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 nil125
}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, err134
}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 RemoteStatus139
err := c.do(ctx, conn, http.MethodGet, "/api/v1/status", nil, &out)140
return out, err141
}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 RemoteConfig163
err := c.do(ctx, conn, http.MethodGet, "/api/v1/admin/config", nil, &out)164
return out, err165
}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, err185
}186
187
// Rollback vraagt de backup server om archive terug te zetten. De server188
// 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 elke199
// gekoppelde backup server, met een paar nieuwe pogingen bij een fout. De200
// backup servers halen daarnaast periodiek alles op, dus een gemiste201
// melding kost alleen vertraging.202
type Notifier struct {203
Client *Client204
Delay time.Duration205
once sync.Once206
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
return213
}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.Delay226
if delay <= 0 {227
delay = 2 * time.Second228
}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
continue239
}240
var wg sync.WaitGroup241
for _, conn := range list {242
if !conn.Connected() {243
continue244
}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
return254
}255
time.Sleep(time.Duration(1<<try) * 2 * time.Second)256
}257
}(conn)258
}259
wg.Wait()260
}261
}@@ -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, het3
// 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 in6
// <state>/instance_id. Die twee bestanden horen bij deze installatie en gaan7
// niet mee in een backup, zodat een rollback de koppeling niet terugdraait.8
package backup9
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 = 1655
56
// file is backup.json. Eén BlueGit kan meerdere backup servers hebben; een57
// 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 string65
mu sync.Mutex66
}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 doet75
// 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, err87
}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{}, false94
}95
for _, c := range list {96
if c.ID == id {97
return c, true98
}99
}100
return Conn{}, false101
}102
103
func (m *Manager) load() (file, error) {104
var f file105
b, err := os.ReadFile(filepath.Join(m.Dir, connFile))106
if errors.Is(err, os.ErrNotExist) {107
return f, nil108
}109
if err != nil {110
return f, err111
}112
if err := json.Unmarshal(b, &f); err != nil {113
return f, err114
}115
if f.Servers == nil {116
// Oude vorm met één koppeling.117
var one Conn118
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, err129
}130
}131
}132
return f, nil133
}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 err145
}146
tmp := filepath.Join(m.Dir, connFile+".tmp")147
if err := os.WriteFile(tmp, b, 0o600); err != nil {148
return err149
}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{}, err159
}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{}, err164
}165
return f.Servers[i], m.save(f)166
}167
}168
return Conn{}, ErrUnknown169
}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 "", err184
}185
return KeyPrefix + hex.EncodeToString(raw), nil186
}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 name195
}196
197
// Add maakt een nieuwe backup server met een eigen key. De key wordt198
// 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{}, err207
}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{}, err217
}218
if len(f.Servers) >= MaxServers {219
return "", Conn{}, ErrTooMany220
}221
f.Servers = append(f.Servers, c)222
if err := m.save(f); err != nil {223
return "", Conn{}, err224
}225
return key, c, nil226
}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 zijn232
// 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{}, err237
}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(), by241
c.ServerURL, c.ServerID, c.ConnectedAt = "", "", time.Time{}242
return nil243
})244
if err != nil {245
return "", Conn{}, err246
}247
return key, c, nil248
}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 err266
}267
out := f.Servers[:0]268
found := false269
for _, c := range f.Servers {270
if c.ID == id {271
found = true272
continue273
}274
out = append(out, c)275
}276
if !found {277
return ErrUnknown278
}279
f.Servers = out280
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{}, false288
}289
list, err := m.List()290
if err != nil {291
return Conn{}, false292
}293
h := HashKey(key)294
for _, c := range list {295
if c.HasKey() && subtle.ConstantTimeCompare([]byte(h), []byte(c.KeyHash)) == 1 {296
return c, true297
}298
}299
return Conn{}, false300
}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 = serverID307
c.ConnectedAt = time.Now().UTC()308
c.LastSeen = c.ConnectedAt309
return nil310
})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
return318
}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 keer323
// 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, nil331
}332
}333
raw := make([]byte, 16)334
if _, err := rand.Read(raw); err != nil {335
return "", err336
}337
id := hex.EncodeToString(raw)338
if err := os.MkdirAll(m.Dir, 0o750); err != nil {339
return "", err340
}341
return id, os.WriteFile(p, []byte(id+"\n"), 0o600)342
}@@ -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 @@1
package backup2
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.Minute23
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 = -d50
}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 nil59
}@@ -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 @@1
package backup2
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 bestand25
// state/secret.key nodig om de geheimen in de database te lezen26
// state/ssh/… SSH-hostkey27
// state/logos/… project- en groepslogo's28
// state/avatars/… geüploade avatars29
// data/repos/… bare repositories30
// data/releases/… gepubliceerde release-assets (zonder .incoming)31
// data/artifacts/… CI-artifacts32
//33
// Niet mee: storage_path, cache.json, backup.json en instance_id (horen bij34
// de installatie), data/work (tijdelijke werkmappen), lock-bestanden en35
// 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-milliseconden50
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 string64
DataDir string // leeg als er geen datadisk is65
// Snapshot schrijft een consistente kopie van de database naar pad.66
Snapshot func(dst string) error67
// Conn is de koppeling waarvoor de kopie is. Elke backup server krijgt68
// een eigen databasekopie, zodat twee servers die tegelijk een69
// manifest ophalen elkaars kopie niet vervangen.70
Conn string71
}72
73
// snapshotMu zorgt dat er maar één databasekopie tegelijk gemaakt wordt.74
var snapshotMu sync.Mutex75
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.Builder89
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, err104
}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, err117
}118
e, err := entryOf(DBPath, snap, true)119
if err != nil {120
return m, err121
}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, err133
}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, err139
}140
}141
}142
sort.Slice(m.Files, func(i, j int) bool { return m.Files[i].Path < m.Files[j].Path })143
return m, nil144
}145
146
func entryOf(logical, real string, hash bool) (Entry, error) {147
fi, err := os.Lstat(real)148
if err != nil {149
return Entry{}, err150
}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, err159
}160
defer f.Close()161
h := sha256.New()162
if _, err := io.Copy(h, f); err != nil {163
return e, err164
}165
e.SHA256 = hex.EncodeToString(h.Sum(nil))166
}167
return e, nil168
}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 nil179
}180
// Een map die tijdens het lopen verdwijnt (git gc) slaan we over.181
if d != nil && d.IsDir() {182
return fs.SkipDir183
}184
return nil185
}186
if p != root && skipName(d.Name()) {187
if d.IsDir() {188
return fs.SkipDir189
}190
return nil191
}192
if d.IsDir() || d.Type()&fs.ModeSymlink != 0 || !d.Type().IsRegular() {193
return nil194
}195
rel, err := filepath.Rel(root, p)196
if err != nil {197
return nil198
}199
if e, err := entryOf(logical+"/"+filepath.ToSlash(rel), p, false); err == nil {200
m.Files = append(m.Files, e)201
}202
return nil203
})204
if errors.Is(err, fs.ErrNotExist) {205
return nil206
}207
return err208
}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 "", false214
}215
c := path.Clean(p)216
if c != p || c == "." || strings.HasPrefix(c, "../") || strings.Contains(c, "/../") {217
return "", false218
}219
parts := strings.Split(c, "/")220
for _, part := range parts {221
if part == ".." || part == "." || part == "" {222
return "", false223
}224
}225
if len(parts) < 2 {226
return "", false227
}228
switch parts[0] {229
case "state":230
if len(parts) == 2 && contains(stateFiles, parts[1]) {231
return c, true232
}233
if len(parts) >= 3 && contains(stateDirs, parts[1]) {234
return c, true235
}236
case "data":237
if len(parts) >= 3 && contains(dataDirs, parts[1]) && parts[2] != ".incoming" {238
return c, true239
}240
}241
return "", false242
}243
244
func contains(list []string, v string) bool {245
for _, x := range list {246
if x == v {247
return true248
}249
}250
return false251
}252
253
// Resolve geeft het echte bestand bij een logisch pad. De database komt254
// 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 string261
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 "", err275
}276
if !fi.Mode().IsRegular() {277
return "", errors.New("geen gewoon bestand")278
}279
return real, nil280
}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. Er293
// verandert nog niets aan de live gegevens; dat doet ApplyPending bij de294
// 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 string299
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, err309
}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 := 0316
seenDB, seenKey := false, false317
for {318
h, err := tr.Next()319
if err == io.EOF {320
break321
}322
if err != nil {323
return fail(err)324
}325
if h.Typeflag == tar.TypeDir {326
continue327
}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 string336
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 == DBPath345
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() & 0o755350
if mode == 0 {351
mode = 0o640352
}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, nil375
}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 == nil381
}382
383
// ApplyPending zet een klaarstaande backup op zijn plek. Aanroepen bij de384
// 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, nil390
}391
if err != nil {392
return false, err393
}394
var p pending395
if err := json.Unmarshal(b, &p); err != nil {396
return false, err397
}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, err404
}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, err411
}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 err426
}427
}428
if _, err := os.Lstat(staged); err == nil {429
if err := os.Rename(staged, live); err != nil {430
return err431
}432
}433
return os.RemoveAll(old)434
}@@ -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 @@1
package i18n2
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
}@@ -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 tabs35
return tabs35
}36
}36
37
37
func isAdminPage(page string) bool {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
func (s *Server) mountAdmin(mux *http.ServeMux) {42
func (s *Server) mountAdmin(mux *http.ServeMux) {@@ -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
}@@ -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 @@1
package server2
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 een22
// melding bij elke wijziging, en kunnen een archief terugsturen (rollback).23
// Vanuit BlueGit is elke backup server ook te bedienen: BlueGit stuurt24
// ondertekende verzoeken naar de beheer-API van de backup server. Het25
// protocol staat in docs/BACKUP.md.26
27
// maxRestoreBytes begrenst een terug te zetten archief (64 GiB).28
const maxRestoreBytes = 64 << 3029
30
var (31
restoreBusy atomic.Bool32
backupFails updateLimiter33
)34
35
// BackupView is de stand op Beheer > Backup.36
type BackupView struct {37
InstanceID string38
Servers []backup.Conn39
Max int40
// Current is de geopende backup server (detailpagina).41
Current *BackupServerView42
NewKey string43
}44
45
// BackupServerView is één backup server met wat hij zelf meldt.46
type BackupServerView struct {47
Conn backup.Conn48
Remote *backup.RemoteStatus49
Archives []backup.Archive50
Config *backup.RemoteConfig51
RemoteErr string52
}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.backupMgr70
}71
72
// BackupChanged meldt een wijziging aan de gekoppelde backup server.73
func (s *Server) BackupChanged() {74
if s.StateDir == "" {75
return76
}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 backup104
// server haalt daarna alleen op wat veranderd is; een melding te veel kost105
// 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
return112
}113
if restoreBusy.Load() {114
http.Error(w, "backup wordt teruggezet; BlueGit herstart zo\n", http.StatusServiceUnavailable)115
return116
}117
next.ServeHTTP(w, r)118
if strings.HasPrefix(r.URL.Path, "/api/v1/backup/") || strings.HasSuffix(r.URL.Path, "/git-upload-pack") {119
return120
}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
return136
}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
return144
}145
backupErr(w, http.StatusUnauthorized, "ongeldige Backupserver-Key")146
return147
}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 c158
}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
return165
}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
return181
}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
return186
}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
return191
}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
return204
}205
m, err := s.backupTree(backupConnOf(r).ID).Build(id)206
if err != nil {207
backupErr(w, 500, err.Error())208
return209
}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
return218
}219
f, err := os.Open(real)220
if err != nil {221
backupErr(w, http.StatusNotFound, "bestand niet gevonden")222
return223
}224
defer f.Close()225
fi, err := f.Stat()226
if err != nil {227
backupErr(w, 500, err.Error())228
return229
}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 uit237
// 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
return242
}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
return253
}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 bv277
}278
279
// backupServerView vraagt status, archieven en instellingen op bij de280
// 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 v285
}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 v293
}294
v.Remote = &st295
if arch, err := c.Archives(ctx, conn); err == nil {296
v.Archives = arch297
} else {298
v.RemoteErr = err.Error()299
}300
if cfg, err := c.Config(ctx, conn); err == nil {301
v.Config = &cfg302
} else if v.RemoteErr == "" {303
v.RemoteErr = err.Error()304
}305
return v306
}307
308
func (s *Server) adminBackup(w http.ResponseWriter, r *http.Request) {309
if ok, _ := s.adminOnly(w, r); !ok {310
return311
}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, ok325
}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
return332
}333
conn, ok := s.backupConnFromPath(w, r)334
if !ok {335
return336
}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.Value343
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 de349
// 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
return366
}367
s.backupInit()368
by := s.who(r).User.Username369
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
return373
}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
return392
}393
conn, ok := s.backupConnFromPath(w, r)394
if !ok {395
return396
}397
by := s.who(r).User.Username398
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
return402
}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
return411
}412
conn, ok := s.backupConnFromPath(w, r)413
if !ok {414
return415
}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
return419
}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 bereikbaar424
// 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 err433
}434
s.backupTree(conn.ID).RemoveSnapshot()435
s.backupAudit("remove", by, "id", conn.ID, "name", conn.Name)436
return nil437
}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
return442
}443
conn, ok := s.backupConnFromPath(w, r)444
if !ok {445
return446
}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
return450
}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 kent455
// 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.RemoteAction469
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.Path495
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 any504
if act.Method != http.MethodGet {505
body = in506
}507
hc := *s.backupHTTP508
hc.Timeout = 60 * time.Second509
cl := *c510
cl.HTTP = &hc511
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, nil527
}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
return532
}533
conn, ok := s.backupConnFromPath(w, r)534
if !ok {535
return536
}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
return542
}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
continue548
}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
return555
}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
return566
}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 out586
}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 false592
}593
s.backupInit()594
return true595
}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{}, false600
}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, ok606
}607
608
func (s *Server) apiAdminBackup(w http.ResponseWriter, r *http.Request) {609
if !s.apiBackupAdmin(w, r) {610
return611
}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
return623
}624
var in struct {625
Name string `json:"name"`626
}627
_ = readJSON(r, &in)628
by := apiUser(r).Username629
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
return633
}634
if err != nil {635
s.writeAPIErr(w, r, fail(500, err))636
return637
}638
s.backupAudit("add", by, "id", c.ID, "name", c.Name)639
out := backupConnJSON(c)640
out["key"] = key641
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
return648
}649
v := s.backupServerView(r.Context(), c)650
out := backupConnJSON(c)651
out["archives"] = v.Archives652
if v.Archives == nil {653
out["archives"] = []backup.Archive{}654
}655
if v.Remote != nil {656
out["remote"] = v.Remote657
}658
if v.Config != nil {659
out["config"] = v.Config660
}661
out["remote_error"] = v.RemoteErr662
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
return669
}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
return676
}677
c, err := s.backupMgr.Rename(c.ID, in.Name)678
if err != nil {679
s.writeAPIErr(w, r, fail(400, err))680
return681
}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
return689
}690
by := apiUser(r).Username691
key, c, err := s.backupMgr.RotateKey(c.ID, by)692
if err != nil {693
s.writeAPIErr(w, r, fail(500, err))694
return695
}696
s.backupAudit("new_key", by, "id", c.ID, "name", c.Name)697
out := backupConnJSON(c)698
out["key"] = key699
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
return706
}707
if err := s.removeBackupServer(r.Context(), apiUser(r).Username, c); err != nil {708
s.writeAPIErr(w, r, fail(500, err))709
return710
}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
return718
}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
return724
}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
return730
}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 err742
}@@ -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 @@1
package server2
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,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 @@1
package server2
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 *Server25
st *store.Store26
base string27
tim store.User28
tok string29
}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.URL49
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.Millisecond60
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, b76
}77
78
// fakeBackup speelt de backup server: hij controleert elke handtekening.79
type fakeBackup struct {80
mu sync.Mutex81
secret string82
notifies int83
rollback []string84
calls []string85
bodies map[string]string86
badSig int87
ts *httptest.Server88
}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
return100
}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
return139
}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
return147
}148
http.NotFound(w, r)149
}150
}))151
t.Cleanup(f.ts.Close)152
return f153
}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 addedServer167
_ = json.Unmarshal(b, &a)168
if !strings.HasPrefix(a.Key, "bgbk_") || a.ID == "" {169
t.Fatalf("%s", b)170
}171
return a172
}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.Manifest200
_ = 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] = true207
}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 addedServer230
_ = 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 string265
}{{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.notifies283
fa.mu.Unlock()284
fb.mu.Lock()285
nb := fb.notifies286
fb.mu.Unlock()287
if na > 0 && nb > 0 {288
break289
}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.Manifest410
_ = json.Unmarshal(b, &m)411
var sb strings.Builder412
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
}@@ -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.Us45
// git http, SSH en postReceive zijn de enige aanroepers.45
// git http, SSH en postReceive zijn de enige aanroepers.46
func (s *Server) AfterPush(repo store.Repo, user store.User, before, after map[string]string) {46
func (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 []st234
}235
}235
236
236
func (s *Server) Dispatch(repoID int64, ev webhook.Event) {237
func (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 {@@ -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.Cache78
graphCache *gitgraph.Cache78
79
79
gitMaint gitMaintState80
gitMaint gitMaintState81
82
// RequestRestart herstart het proces (main: opnieuw exec'en). Nodig na83
// het uitpakken van een backup. Nil: alleen bij de volgende start.84
RequestRestart func()85
backupOnce sync.Once86
backupMgr *backup.Manager87
backupNote *backup.Notifier88
backupHTTP *http.Client89
restoring sync.Mutex80
}90
}81
91
82
type principal struct {92
type 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
275
func (s *Server) realIP(next http.Handler) http.Handler {286
func (s *Server) realIP(next http.Handler) http.Handler {@@ -333,6 +344,7 @@ func (s *Server) mustTemplates() {333
return label344
return label334
},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.603
type View struct {615
type View struct {616
Backup *BackupView604
RunnerList []RunnerView617
RunnerList []RunnerView605
RunnerPref string618
RunnerPref string606
NewRunnerToken string619
NewRunnerToken string@@ -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
}1875
span.starbtn.btn { border: 1px solid var(--line); border-radius: var(--radius); color: var(--ink); }1875
span.starbtn.btn { border: 1px solid var(--line); border-radius: var(--radius); color: var(--ink); }1876
span.starbtn.starred { color: #9a6700; }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; }@@ -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}}@@ -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) {1063
func (s *Store) decrypt(nonce, ct []byte) (string, error) {1063
func (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 dst1068
// (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 err1072
}