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