bluegit-backup: backup server voor BlueGit
- koppelen met Backupserver-Key, keuze wissen/herstellen bij nieuwe instantie - gedoseerd synchroniseren (token bucket), melding van BlueGit per wijziging - archieven tar.gz per interval, opruimen op leeftijd en bij volle schijf - rollback vanuit BlueGit - integratietests tegen een echte BlueGit; releases (AUR, self-update, tag-binaries) alleen na groene integratietests en met .release-enabled
@@ -0,0 +1,237 @@
1
// bluegit-backup houdt een kopie bij van één BlueGit-instantie.
2
package main
3
4
import (
5
"bufio"
6
"bytes"
7
"context"
8
"encoding/json"
9
"flag"
10
"fmt"
11
"io"
12
"log/slog"
13
"net"
14
"net/http"
15
"os"
16
"os/signal"
17
"strings"
18
"syscall"
19
"time"
20
21
"git.timfalken.com/timfa/bluegit-backup/internal/config"
22
"git.timfalken.com/timfa/bluegit-backup/internal/server"
23
)
24
25
func usage() {
26
fmt.Fprint(os.Stderr, `bluegit-backup
27
28
bluegit-backup serve [--config /etc/bluegit-backup/config.yml]
29
bluegit-backup connect [--config …] --url https://git.example.com [--key bgbk_…] [--on-conflict wipe|restore]
30
bluegit-backup status [--config …]
31
bluegit-backup list [--config …]
32
bluegit-backup archive [--config …] nu een archief maken
33
bluegit-backup sync [--config …] nu synchroniseren
34
bluegit-backup prune [--config …] bewaarregels nu toepassen
35
bluegit-backup example-config
36
bluegit-backup version
37
38
De key kan ook uit BLUEGIT_BACKUP_KEY komen (dan staat hij niet in de proceslijst).
39
`)
40
}
41
42
func main() {
43
if len(os.Args) < 2 {
44
usage()
45
os.Exit(2)
46
}
47
var err error
48
switch os.Args[1] {
49
case "serve":
50
err = serve(os.Args[2:])
51
case "connect":
52
err = connect(os.Args[2:], os.Stdin, os.Stdout)
53
case "status":
54
err = simple(os.Args[2:], http.MethodGet, "/api/v1/admin/status")
55
case "list":
56
err = simple(os.Args[2:], http.MethodGet, "/api/v1/admin/archives")
57
case "archive":
58
err = simple(os.Args[2:], http.MethodPost, "/api/v1/admin/archive")
59
case "sync":
60
err = simple(os.Args[2:], http.MethodPost, "/api/v1/admin/sync")
61
case "prune":
62
err = simple(os.Args[2:], http.MethodPost, "/api/v1/admin/prune")
63
case "example-config":
64
fmt.Print(config.Example())
65
case "version":
66
fmt.Println(server.Version)
67
default:
68
usage()
69
os.Exit(2)
70
}
71
if err != nil {
72
fmt.Fprintln(os.Stderr, "bluegit-backup:", err)
73
os.Exit(1)
74
}
75
}
76
77
func configPath(p string) string {
78
if p != "" {
79
return p
80
}
81
if v := os.Getenv("BLUEGIT_BACKUP_CONFIG"); v != "" {
82
return v
83
}
84
if _, err := os.Stat("bluegit-backup.yml"); err == nil {
85
return "bluegit-backup.yml"
86
}
87
return "/etc/bluegit-backup/config.yml"
88
}
89
90
func serve(args []string) error {
91
fs := flag.NewFlagSet("serve", flag.ExitOnError)
92
cfgPath := fs.String("config", "", "pad naar config.yml")
93
_ = fs.Parse(args)
94
cfg, err := config.Load(configPath(*cfgPath))
95
if err != nil {
96
return err
97
}
98
log := slog.New(slog.NewTextHandler(os.Stdout, nil))
99
srv, err := server.New(cfg, log)
100
if err != nil {
101
return err
102
}
103
ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
104
defer stop()
105
ln, err := net.Listen("tcp", cfg.Listen)
106
if err != nil {
107
return err
108
}
109
hs := &http.Server{Handler: srv.Handler(), ReadHeaderTimeout: 10 * time.Second}
110
go func() {
111
<-ctx.Done()
112
c, cancel := context.WithTimeout(context.Background(), 10*time.Second)
113
defer cancel()
114
_ = hs.Shutdown(c)
115
}()
116
srv.Run(ctx)
117
log.Info("bluegit-backup luistert", "addr", ln.Addr().String(), "public_url", cfg.PublicURL, "version", server.Version)
118
if err := hs.Serve(ln); err != nil && err != http.ErrServerClosed {
119
return err
120
}
121
return nil
122
}
123
124
type client struct {
125
base, token string
126
}
127
128
func newClient(cfgPath string) (*client, error) {
129
cfg, err := config.Load(configPath(cfgPath))
130
if err != nil {
131
return nil, err
132
}
133
tok, err := server.ReadAdminToken(cfg.DataDir)
134
if err != nil {
135
return nil, fmt.Errorf("admin.token lezen (draai als de gebruiker van de dienst of root): %w", err)
136
}
137
host, port, err := net.SplitHostPort(cfg.Listen)
138
if err != nil {
139
return nil, err
140
}
141
if host == "" || host == "0.0.0.0" || host == "::" {
142
host = "127.0.0.1"
143
}
144
return &client{base: "http://" + net.JoinHostPort(host, port), token: tok}, nil
145
}
146
147
func (c *client) do(method, p string, in any) (int, []byte, error) {
148
var body io.Reader
149
if in != nil {
150
b, _ := json.Marshal(in)
151
body = bytes.NewReader(b)
152
}
153
req, _ := http.NewRequest(method, c.base+p, body)
154
req.Header.Set("Authorization", "Bearer "+c.token)
155
req.Header.Set("Content-Type", "application/json")
156
resp, err := (&http.Client{Timeout: 30 * time.Minute}).Do(req)
157
if err != nil {
158
return 0, nil, err
159
}
160
defer resp.Body.Close()
161
b, _ := io.ReadAll(resp.Body)
162
return resp.StatusCode, b, nil
163
}
164
165
func simple(args []string, method, p string) error {
166
fs := flag.NewFlagSet("cmd", flag.ExitOnError)
167
cfgPath := fs.String("config", "", "pad naar config.yml")
168
_ = fs.Parse(args)
169
c, err := newClient(*cfgPath)
170
if err != nil {
171
return err
172
}
173
code, b, err := c.do(method, p, nil)
174
if err != nil {
175
return err
176
}
177
var pretty bytes.Buffer
178
if json.Indent(&pretty, b, "", " ") == nil {
179
b = pretty.Bytes()
180
}
181
fmt.Println(string(b))
182
if code >= 300 {
183
return fmt.Errorf("HTTP %d", code)
184
}
185
return nil
186
}
187
188
func connect(args []string, stdin io.Reader, stdout io.Writer) error {
189
fs := flag.NewFlagSet("connect", flag.ExitOnError)
190
cfgPath := fs.String("config", "", "pad naar config.yml")
191
u := fs.String("url", "", "adres van BlueGit")
192
key := fs.String("key", "", "Backupserver-Key (of BLUEGIT_BACKUP_KEY)")
193
onConflict := fs.String("on-conflict", "", "wipe of restore, zonder te vragen")
194
_ = fs.Parse(args)
195
if *key == "" {
196
*key = os.Getenv("BLUEGIT_BACKUP_KEY")
197
}
198
if *u == "" || *key == "" {
199
return fmt.Errorf("--url en --key (of BLUEGIT_BACKUP_KEY) zijn nodig")
200
}
201
c, err := newClient(*cfgPath)
202
if err != nil {
203
return err
204
}
205
req := server.ConnectRequest{URL: *u, Key: *key, OnConflict: *onConflict}
206
code, b, err := c.do(http.MethodPost, "/api/v1/admin/connect", req)
207
if err != nil {
208
return err
209
}
210
if code == http.StatusConflict {
211
var cf server.ConflictError
212
_ = json.Unmarshal(b, &cf)
213
fmt.Fprintf(stdout, "Deze backup server hoort bij een andere BlueGit (%s, instance %s) en heeft %d archief/archieven.\n", cf.PreviousURL, cf.PreviousInstance, cf.Archives)
214
fmt.Fprintln(stdout, "Een backup server kan maar aan één BlueGit gekoppeld zijn. Kies:")
215
fmt.Fprintln(stdout, " 1) Oude backups verwijderen en met de nieuwe instantie verbinden")
216
fmt.Fprintln(stdout, " 2) De nieuwe instantie terugzetten naar de gegevens in deze backup server (overschrijft alles daar)")
217
fmt.Fprint(stdout, "Keuze [1/2, leeg = afbreken]: ")
218
line, _ := bufio.NewReader(stdin).ReadString('\n')
219
switch strings.TrimSpace(line) {
220
case "1":
221
req.OnConflict = "wipe"
222
case "2":
223
req.OnConflict = "restore"
224
default:
225
return fmt.Errorf("afgebroken; er is niets veranderd")
226
}
227
code, b, err = c.do(http.MethodPost, "/api/v1/admin/connect", req)
228
if err != nil {
229
return err
230
}
231
}
232
fmt.Fprintln(stdout, strings.TrimSpace(string(b)))
233
if code >= 300 {
234
return fmt.Errorf("HTTP %d", code)
235
}
236
return nil
237
}
@@ -0,0 +1,237 @@1
// bluegit-backup houdt een kopie bij van één BlueGit-instantie.2
package main3
4
import (5
"bufio"6
"bytes"7
"context"8
"encoding/json"9
"flag"10
"fmt"11
"io"12
"log/slog"13
"net"14
"net/http"15
"os"16
"os/signal"17
"strings"18
"syscall"19
"time"20
21
"git.timfalken.com/timfa/bluegit-backup/internal/config"22
"git.timfalken.com/timfa/bluegit-backup/internal/server"23
)24
25
func usage() {26
fmt.Fprint(os.Stderr, `bluegit-backup27
28
bluegit-backup serve [--config /etc/bluegit-backup/config.yml]29
bluegit-backup connect [--config …] --url https://git.example.com [--key bgbk_…] [--on-conflict wipe|restore]30
bluegit-backup status [--config …]31
bluegit-backup list [--config …]32
bluegit-backup archive [--config …] nu een archief maken33
bluegit-backup sync [--config …] nu synchroniseren34
bluegit-backup prune [--config …] bewaarregels nu toepassen35
bluegit-backup example-config36
bluegit-backup version37
38
De key kan ook uit BLUEGIT_BACKUP_KEY komen (dan staat hij niet in de proceslijst).39
`)40
}41
42
func main() {43
if len(os.Args) < 2 {44
usage()45
os.Exit(2)46
}47
var err error48
switch os.Args[1] {49
case "serve":50
err = serve(os.Args[2:])51
case "connect":52
err = connect(os.Args[2:], os.Stdin, os.Stdout)53
case "status":54
err = simple(os.Args[2:], http.MethodGet, "/api/v1/admin/status")55
case "list":56
err = simple(os.Args[2:], http.MethodGet, "/api/v1/admin/archives")57
case "archive":58
err = simple(os.Args[2:], http.MethodPost, "/api/v1/admin/archive")59
case "sync":60
err = simple(os.Args[2:], http.MethodPost, "/api/v1/admin/sync")61
case "prune":62
err = simple(os.Args[2:], http.MethodPost, "/api/v1/admin/prune")63
case "example-config":64
fmt.Print(config.Example())65
case "version":66
fmt.Println(server.Version)67
default:68
usage()69
os.Exit(2)70
}71
if err != nil {72
fmt.Fprintln(os.Stderr, "bluegit-backup:", err)73
os.Exit(1)74
}75
}76
77
func configPath(p string) string {78
if p != "" {79
return p80
}81
if v := os.Getenv("BLUEGIT_BACKUP_CONFIG"); v != "" {82
return v83
}84
if _, err := os.Stat("bluegit-backup.yml"); err == nil {85
return "bluegit-backup.yml"86
}87
return "/etc/bluegit-backup/config.yml"88
}89
90
func serve(args []string) error {91
fs := flag.NewFlagSet("serve", flag.ExitOnError)92
cfgPath := fs.String("config", "", "pad naar config.yml")93
_ = fs.Parse(args)94
cfg, err := config.Load(configPath(*cfgPath))95
if err != nil {96
return err97
}98
log := slog.New(slog.NewTextHandler(os.Stdout, nil))99
srv, err := server.New(cfg, log)100
if err != nil {101
return err102
}103
ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)104
defer stop()105
ln, err := net.Listen("tcp", cfg.Listen)106
if err != nil {107
return err108
}109
hs := &http.Server{Handler: srv.Handler(), ReadHeaderTimeout: 10 * time.Second}110
go func() {111
<-ctx.Done()112
c, cancel := context.WithTimeout(context.Background(), 10*time.Second)113
defer cancel()114
_ = hs.Shutdown(c)115
}()116
srv.Run(ctx)117
log.Info("bluegit-backup luistert", "addr", ln.Addr().String(), "public_url", cfg.PublicURL, "version", server.Version)118
if err := hs.Serve(ln); err != nil && err != http.ErrServerClosed {119
return err120
}121
return nil122
}123
124
type client struct {125
base, token string126
}127
128
func newClient(cfgPath string) (*client, error) {129
cfg, err := config.Load(configPath(cfgPath))130
if err != nil {131
return nil, err132
}133
tok, err := server.ReadAdminToken(cfg.DataDir)134
if err != nil {135
return nil, fmt.Errorf("admin.token lezen (draai als de gebruiker van de dienst of root): %w", err)136
}137
host, port, err := net.SplitHostPort(cfg.Listen)138
if err != nil {139
return nil, err140
}141
if host == "" || host == "0.0.0.0" || host == "::" {142
host = "127.0.0.1"143
}144
return &client{base: "http://" + net.JoinHostPort(host, port), token: tok}, nil145
}146
147
func (c *client) do(method, p string, in any) (int, []byte, error) {148
var body io.Reader149
if in != nil {150
b, _ := json.Marshal(in)151
body = bytes.NewReader(b)152
}153
req, _ := http.NewRequest(method, c.base+p, body)154
req.Header.Set("Authorization", "Bearer "+c.token)155
req.Header.Set("Content-Type", "application/json")156
resp, err := (&http.Client{Timeout: 30 * time.Minute}).Do(req)157
if err != nil {158
return 0, nil, err159
}160
defer resp.Body.Close()161
b, _ := io.ReadAll(resp.Body)162
return resp.StatusCode, b, nil163
}164
165
func simple(args []string, method, p string) error {166
fs := flag.NewFlagSet("cmd", flag.ExitOnError)167
cfgPath := fs.String("config", "", "pad naar config.yml")168
_ = fs.Parse(args)169
c, err := newClient(*cfgPath)170
if err != nil {171
return err172
}173
code, b, err := c.do(method, p, nil)174
if err != nil {175
return err176
}177
var pretty bytes.Buffer178
if json.Indent(&pretty, b, "", " ") == nil {179
b = pretty.Bytes()180
}181
fmt.Println(string(b))182
if code >= 300 {183
return fmt.Errorf("HTTP %d", code)184
}185
return nil186
}187
188
func connect(args []string, stdin io.Reader, stdout io.Writer) error {189
fs := flag.NewFlagSet("connect", flag.ExitOnError)190
cfgPath := fs.String("config", "", "pad naar config.yml")191
u := fs.String("url", "", "adres van BlueGit")192
key := fs.String("key", "", "Backupserver-Key (of BLUEGIT_BACKUP_KEY)")193
onConflict := fs.String("on-conflict", "", "wipe of restore, zonder te vragen")194
_ = fs.Parse(args)195
if *key == "" {196
*key = os.Getenv("BLUEGIT_BACKUP_KEY")197
}198
if *u == "" || *key == "" {199
return fmt.Errorf("--url en --key (of BLUEGIT_BACKUP_KEY) zijn nodig")200
}201
c, err := newClient(*cfgPath)202
if err != nil {203
return err204
}205
req := server.ConnectRequest{URL: *u, Key: *key, OnConflict: *onConflict}206
code, b, err := c.do(http.MethodPost, "/api/v1/admin/connect", req)207
if err != nil {208
return err209
}210
if code == http.StatusConflict {211
var cf server.ConflictError212
_ = json.Unmarshal(b, &cf)213
fmt.Fprintf(stdout, "Deze backup server hoort bij een andere BlueGit (%s, instance %s) en heeft %d archief/archieven.\n", cf.PreviousURL, cf.PreviousInstance, cf.Archives)214
fmt.Fprintln(stdout, "Een backup server kan maar aan één BlueGit gekoppeld zijn. Kies:")215
fmt.Fprintln(stdout, " 1) Oude backups verwijderen en met de nieuwe instantie verbinden")216
fmt.Fprintln(stdout, " 2) De nieuwe instantie terugzetten naar de gegevens in deze backup server (overschrijft alles daar)")217
fmt.Fprint(stdout, "Keuze [1/2, leeg = afbreken]: ")218
line, _ := bufio.NewReader(stdin).ReadString('\n')219
switch strings.TrimSpace(line) {220
case "1":221
req.OnConflict = "wipe"222
case "2":223
req.OnConflict = "restore"224
default:225
return fmt.Errorf("afgebroken; er is niets veranderd")226
}227
code, b, err = c.do(http.MethodPost, "/api/v1/admin/connect", req)228
if err != nil {229
return err230
}231
}232
fmt.Fprintln(stdout, strings.TrimSpace(string(b)))233
if code >= 300 {234
return fmt.Errorf("HTTP %d", code)235
}236
return nil237
}@@ -0,0 +1,95 @@
1
# Aannames
2
3
Deze keuzes heb ik gemaakt waar de opdracht niets vastlegde. Wil je iets anders, dan is het per punt aan te passen.
4
5
## Opzet
6
7
- **Go**, net als BlueGit. Eén binary zonder CGO. De enige externe dependency is `gopkg.in/yaml.v3`.
8
- **Geen webinterface op de backup server.** Je bedient hem met een configbestand en de CLI. Archieven bekijken en een rollback starten gebeurt in BlueGit, zoals gevraagd.
9
- De CLI praat met de draaiende server via `data_dir/admin.token` (een `bba_…`-token, 0600). Er komt geen tweede inlogsysteem.
10
- Eén backup server hoort bij precies één BlueGit. Dat staat in `data_dir/state.json` (0600). Daar staat ook de key in, want die is nodig om op te halen en om meldingen te controleren.
11
12
## Key en authenticatie
13
14
- BlueGit maakt de Backupserver-Key (`bgbk_` + 64 hex) onder *Beheer → Backup* en toont hem één keer. BlueGit bewaart alleen `sha256(key)`.
15
- Er is maar één key tegelijk. Een nieuwe key maken maakt de oude ongeldig. Verwijderen ontkoppelt de server.
16
- **Backup server → BlueGit:** `Authorization: Bearer bgbk_…` op `/api/v1/backup/*`. Vijf foute pogingen per minuut per IP-adres geven `429`.
17
- **BlueGit → backup server:** BlueGit kent de key zelf niet meer, alleen de hash. Daarom ondertekent BlueGit met een afgeleid geheim, `sha256("bluegit-backup-sign:" + key)`, dat BlueGit bij het maken van de key bewaart. De handtekening is HMAC-SHA256 over `METHODE\nPAD\nTIJDSTEMPEL\nsha256(body)`, met hoogstens 5 minuten klokverschil. Zo kan iemand die het netwerk ziet geen rollback starten of meldingen vervalsen.
18
- De koppeling in BlueGit (`<state>/backup.json`) zit **niet** in de backup. Een rollback zet de koppeling dus niet terug naar een oude key.
19
- Je koppelt met `bluegit-backup connect --url … ` en de key uit `BLUEGIT_BACKUP_KEY` (of `--key`). De server meldt BlueGit daarna zijn `public_url`, zodat BlueGit weet waar de meldingen heen moeten.
20
21
## Wat wordt geback-upt
22
23
- Alles wat BlueGit nodig heeft om identiek terug te komen:
24
- de database (`bluegit.db`) als consistente snapshot via `VACUUM INTO`
25
- `secret.key`
26
- de SSH-hostkeys
27
- logo's en avatars
28
- alle repositories
29
- releases en CI-artifacts
30
- **Niet:**
31
- `config.yml`. Dat bestand hoort bij de machine (paden, poorten, OAuth-geheimen) en zet je zelf terug.
32
- `storage_path`, caches, lockbestanden, werkmappen (`data/work`), tijdelijke bestanden, symlinks
33
- de backupkoppeling en het instance-id
34
- "Configuratie" in de opdracht lees ik als: alle instellingen die BlueGit in zijn database en state-map bewaart, plus de sleutels. `config.yml` valt daar niet onder.
35
36
## Meldingen en synchroniseren
37
38
- BlueGit meldt een wijziging na elk muterend verzoek: elke niet-GET, behalve de backup-API zelf en `git-upload-pack` (clonen en fetchen). Daarnaast meldt BlueGit na elke push (HTTP en SSH) en na elk intern event, zoals CI of releases.
39
- Meldingen worden 2 seconden gebundeld en tot 4 keer opnieuw geprobeerd. Een melding bevat geen data, alleen "er is iets veranderd" (`POST /api/v1/notify`).
40
- Na een melding vraagt de backup server een manifest op: een lijst van paden met grootte en mtime, en voor de database een sha256. Hij haalt alleen nieuwe of gewijzigde bestanden op en verwijdert wat in BlueGit weg is.
41
- Tussen twee syncs na meldingen zit minstens `min_sync_interval` (10s). Meldingen die tijdens een sync binnenkomen, geven precies één vervolgsync.
42
- Mist de server een melding (omdat hij uit stond of het netwerk weg was), dan vangt de volledige controle elk `full_sync_interval` (1u) dat op, en ook een herstart.
43
- Een bestand dat tijdens het downloaden verandert (grootte klopt niet), wordt bij de volgende sync opnieuw opgehaald.
44
45
## Gedoseerd downloaden
46
47
- Een token bucket begrenst de downloadsnelheid tot `rate_limit_kib` KiB/s (standaard 1024, dus 1 MiB/s), over alle downloads samen.
48
- Er is altijd maar één download tegelijk. BlueGit krijgt dus nooit meer dan één verzoek tegelijk van de backup server.
49
- De database-snapshot kost BlueGit eenmalig een `VACUUM INTO` per manifest. Bij een grote database is dat het zwaarste deel, maar het blokkeert schrijvers in WAL-modus niet.
50
51
## Archieven
52
53
- Formaat: `tar.gz` (PAX), met de lopende kopie als inhoud (`state/…` en `data/…`). Je kunt een archief dus ook met de hand uitpakken.
54
- Naam: `bluegit-YYYYMMDD-HHMMSS.tar.gz` in UTC, met `-2`, `-3`, … als er in dezelfde seconde meer zijn.
55
- Het eerste archief komt binnen een minuut na de eerste geslaagde sync, daarna elk `archive_interval` (standaard 24u).
56
- Er wordt eerst naar een tijdelijk bestand geschreven en daarna hernoemd. Een half archief komt dus nooit in de lijst.
57
- **Opruimen:**
58
- Archieven ouder dan `retention_days` gaan weg.
59
- Is er minder dan `min_free_mb` vrij op de schijf van `data_dir`, dan gaat het oudste archief weg, net zo lang tot er genoeg vrij is.
60
- Het nieuwste archief blijft altijd staan, ook als het te oud is. Anders zou er geen backup meer zijn.
61
- Is er vóór een nieuw archief niet genoeg ruimte, dan mogen alle oude archieven weg om plaats te maken. Het nieuwe archief wordt dan het enige.
62
63
## Rollback
64
65
- De beheerder start de rollback in BlueGit onder *Beheer → Backup*. Daar staat een grote rode waarschuwing: "Dit kan niet ongedaan worden gemaakt". Er moet een vinkje gezet worden en de archiefnaam overgetypt. De API vraagt `"confirm": "<archiefnaam>"`.
66
- Het verloop:
67
1. De backup server pakt het archief uit in `mirror.rollback`.
68
2. Hij zet dat op de plaats van zijn lopende kopie.
69
3. Hij stuurt alles als `tar.gz` naar BlueGit (`POST /api/v1/backup/restore`).
70
4. BlueGit zet de data klaar, weigert ondertussen alle wijzigingen (503) en herstart zichzelf (zelfde PID, `exec`).
71
5. Bij het opstarten wisselt BlueGit de bestanden om, nog voordat de database opengaat.
72
- Lukt het versturen niet, dan zet de backup server zijn oude kopie terug. Er gaat dan niets verloren.
73
- Archieven die nieuwer zijn dan het teruggezette archief blijven bewaard. Een rollback naar een te oud archief is zo nog te herstellen met een nieuwere rollback, maar alleen voor wat er in die archieven zat.
74
- Het upload-verkeer naar BlueGit bij een rollback is **niet** gedoseerd. BlueGit staat dan toch al stil, en een snelle terugzet is belangrijker.
75
76
## Nieuwe instantie
77
78
- Een BlueGit wordt herkend aan zijn `instance_id` (`<state>/instance_id`). Een andere URL met hetzelfde instance-id is dezelfde instantie, bijvoorbeeld na een verhuizing.
79
- Koppel je een andere instantie, dan weigert de server (`409`) en moet je kiezen:
80
- **wissen**: de oude kopie en alle archieven gaan weg, en de nieuwe instantie wordt opnieuw opgehaald.
81
- **herstellen**: de lopende kopie (de stand van de laatste sync, nieuwer dan elk archief) wordt naar de nieuwe BlueGit gestuurd, net als bij een rollback. Daarna hoort de server bij de nieuwe instantie. De oude archieven blijven staan.
82
- `connect` vraagt de keuze in de terminal. Zonder keuze (lege invoer) gebeurt er niets. Zonder terminal gebruik je `--on-conflict wipe|restore`.
83
- De nieuwe BlueGit moet al draaien met een eigen `config.yml` en data-schijf. Het herstel vult alleen de inhoud.
84
85
## Releases en tests
86
87
- "Dezelfde release-opties als BlueGit" betekent:
88
- een AUR-pakket `bluegit-backup` dat vanaf master wordt bijgewerkt
89
- een self-update van een geïnstalleerde server vanuit de pipeline (via een systemd-unit, net als BlueGit)
90
- binaries bij een tag
91
- Elke release-job hangt af van de job `integration`. Die bouwt een echte BlueGit uit `timfa/bluegit` en draait alle featuretests. Faalt er één, dan komt er geen release.
92
- **Releases vanaf master staan pas aan zodra `.release-enabled` in de repository staat.** Tim beslist wanneer, en zet ook de geheimen (AUR-sleutel, update-token). Tags zet Tim zelf.
93
- De integratietests bouwen BlueGit van de ref in `.bluegit-ref`. Tot de BlueGit-kant gemerged is, is dat `feature/backup-server`. Daarna wordt het `master`.
94
- De integratietests draaien nooit tegen een echte BlueGit-installatie. Elke test start een eigen BlueGit in een tijdelijke map, met de dev-login en zonder SSH of CI-runner.
95
- Het AUR-pakket haalt de broncode van `https://git.timfalken.com/timfa/bluegit-backup/-/archive/<commit>/…`. Daarom is de repository openbaar, net als `timfa/bluegit`.
@@ -0,0 +1,95 @@1
# Aannames2
3
Deze keuzes heb ik gemaakt waar de opdracht niets vastlegde. Wil je iets anders, dan is het per punt aan te passen.4
5
## Opzet6
7
- **Go**, net als BlueGit. Eén binary zonder CGO. De enige externe dependency is `gopkg.in/yaml.v3`.8
- **Geen webinterface op de backup server.** Je bedient hem met een configbestand en de CLI. Archieven bekijken en een rollback starten gebeurt in BlueGit, zoals gevraagd.9
- De CLI praat met de draaiende server via `data_dir/admin.token` (een `bba_…`-token, 0600). Er komt geen tweede inlogsysteem.10
- Eén backup server hoort bij precies één BlueGit. Dat staat in `data_dir/state.json` (0600). Daar staat ook de key in, want die is nodig om op te halen en om meldingen te controleren.11
12
## Key en authenticatie13
14
- BlueGit maakt de Backupserver-Key (`bgbk_` + 64 hex) onder *Beheer → Backup* en toont hem één keer. BlueGit bewaart alleen `sha256(key)`.15
- Er is maar één key tegelijk. Een nieuwe key maken maakt de oude ongeldig. Verwijderen ontkoppelt de server.16
- **Backup server → BlueGit:** `Authorization: Bearer bgbk_…` op `/api/v1/backup/*`. Vijf foute pogingen per minuut per IP-adres geven `429`.17
- **BlueGit → backup server:** BlueGit kent de key zelf niet meer, alleen de hash. Daarom ondertekent BlueGit met een afgeleid geheim, `sha256("bluegit-backup-sign:" + key)`, dat BlueGit bij het maken van de key bewaart. De handtekening is HMAC-SHA256 over `METHODE\nPAD\nTIJDSTEMPEL\nsha256(body)`, met hoogstens 5 minuten klokverschil. Zo kan iemand die het netwerk ziet geen rollback starten of meldingen vervalsen.18
- De koppeling in BlueGit (`<state>/backup.json`) zit **niet** in de backup. Een rollback zet de koppeling dus niet terug naar een oude key.19
- Je koppelt met `bluegit-backup connect --url … ` en de key uit `BLUEGIT_BACKUP_KEY` (of `--key`). De server meldt BlueGit daarna zijn `public_url`, zodat BlueGit weet waar de meldingen heen moeten.20
21
## Wat wordt geback-upt22
23
- Alles wat BlueGit nodig heeft om identiek terug te komen:24
- de database (`bluegit.db`) als consistente snapshot via `VACUUM INTO`25
- `secret.key`26
- de SSH-hostkeys27
- logo's en avatars28
- alle repositories29
- releases en CI-artifacts30
- **Niet:**31
- `config.yml`. Dat bestand hoort bij de machine (paden, poorten, OAuth-geheimen) en zet je zelf terug.32
- `storage_path`, caches, lockbestanden, werkmappen (`data/work`), tijdelijke bestanden, symlinks33
- de backupkoppeling en het instance-id34
- "Configuratie" in de opdracht lees ik als: alle instellingen die BlueGit in zijn database en state-map bewaart, plus de sleutels. `config.yml` valt daar niet onder.35
36
## Meldingen en synchroniseren37
38
- BlueGit meldt een wijziging na elk muterend verzoek: elke niet-GET, behalve de backup-API zelf en `git-upload-pack` (clonen en fetchen). Daarnaast meldt BlueGit na elke push (HTTP en SSH) en na elk intern event, zoals CI of releases.39
- Meldingen worden 2 seconden gebundeld en tot 4 keer opnieuw geprobeerd. Een melding bevat geen data, alleen "er is iets veranderd" (`POST /api/v1/notify`).40
- Na een melding vraagt de backup server een manifest op: een lijst van paden met grootte en mtime, en voor de database een sha256. Hij haalt alleen nieuwe of gewijzigde bestanden op en verwijdert wat in BlueGit weg is.41
- Tussen twee syncs na meldingen zit minstens `min_sync_interval` (10s). Meldingen die tijdens een sync binnenkomen, geven precies één vervolgsync.42
- Mist de server een melding (omdat hij uit stond of het netwerk weg was), dan vangt de volledige controle elk `full_sync_interval` (1u) dat op, en ook een herstart.43
- Een bestand dat tijdens het downloaden verandert (grootte klopt niet), wordt bij de volgende sync opnieuw opgehaald.44
45
## Gedoseerd downloaden46
47
- Een token bucket begrenst de downloadsnelheid tot `rate_limit_kib` KiB/s (standaard 1024, dus 1 MiB/s), over alle downloads samen.48
- Er is altijd maar één download tegelijk. BlueGit krijgt dus nooit meer dan één verzoek tegelijk van de backup server.49
- De database-snapshot kost BlueGit eenmalig een `VACUUM INTO` per manifest. Bij een grote database is dat het zwaarste deel, maar het blokkeert schrijvers in WAL-modus niet.50
51
## Archieven52
53
- Formaat: `tar.gz` (PAX), met de lopende kopie als inhoud (`state/…` en `data/…`). Je kunt een archief dus ook met de hand uitpakken.54
- Naam: `bluegit-YYYYMMDD-HHMMSS.tar.gz` in UTC, met `-2`, `-3`, … als er in dezelfde seconde meer zijn.55
- Het eerste archief komt binnen een minuut na de eerste geslaagde sync, daarna elk `archive_interval` (standaard 24u).56
- Er wordt eerst naar een tijdelijk bestand geschreven en daarna hernoemd. Een half archief komt dus nooit in de lijst.57
- **Opruimen:**58
- Archieven ouder dan `retention_days` gaan weg.59
- Is er minder dan `min_free_mb` vrij op de schijf van `data_dir`, dan gaat het oudste archief weg, net zo lang tot er genoeg vrij is.60
- Het nieuwste archief blijft altijd staan, ook als het te oud is. Anders zou er geen backup meer zijn.61
- Is er vóór een nieuw archief niet genoeg ruimte, dan mogen alle oude archieven weg om plaats te maken. Het nieuwe archief wordt dan het enige.62
63
## Rollback64
65
- De beheerder start de rollback in BlueGit onder *Beheer → Backup*. Daar staat een grote rode waarschuwing: "Dit kan niet ongedaan worden gemaakt". Er moet een vinkje gezet worden en de archiefnaam overgetypt. De API vraagt `"confirm": "<archiefnaam>"`.66
- Het verloop:67
1. De backup server pakt het archief uit in `mirror.rollback`.68
2. Hij zet dat op de plaats van zijn lopende kopie.69
3. Hij stuurt alles als `tar.gz` naar BlueGit (`POST /api/v1/backup/restore`).70
4. BlueGit zet de data klaar, weigert ondertussen alle wijzigingen (503) en herstart zichzelf (zelfde PID, `exec`).71
5. Bij het opstarten wisselt BlueGit de bestanden om, nog voordat de database opengaat.72
- Lukt het versturen niet, dan zet de backup server zijn oude kopie terug. Er gaat dan niets verloren.73
- Archieven die nieuwer zijn dan het teruggezette archief blijven bewaard. Een rollback naar een te oud archief is zo nog te herstellen met een nieuwere rollback, maar alleen voor wat er in die archieven zat.74
- Het upload-verkeer naar BlueGit bij een rollback is **niet** gedoseerd. BlueGit staat dan toch al stil, en een snelle terugzet is belangrijker.75
76
## Nieuwe instantie77
78
- Een BlueGit wordt herkend aan zijn `instance_id` (`<state>/instance_id`). Een andere URL met hetzelfde instance-id is dezelfde instantie, bijvoorbeeld na een verhuizing.79
- Koppel je een andere instantie, dan weigert de server (`409`) en moet je kiezen:80
- **wissen**: de oude kopie en alle archieven gaan weg, en de nieuwe instantie wordt opnieuw opgehaald.81
- **herstellen**: de lopende kopie (de stand van de laatste sync, nieuwer dan elk archief) wordt naar de nieuwe BlueGit gestuurd, net als bij een rollback. Daarna hoort de server bij de nieuwe instantie. De oude archieven blijven staan.82
- `connect` vraagt de keuze in de terminal. Zonder keuze (lege invoer) gebeurt er niets. Zonder terminal gebruik je `--on-conflict wipe|restore`.83
- De nieuwe BlueGit moet al draaien met een eigen `config.yml` en data-schijf. Het herstel vult alleen de inhoud.84
85
## Releases en tests86
87
- "Dezelfde release-opties als BlueGit" betekent:88
- een AUR-pakket `bluegit-backup` dat vanaf master wordt bijgewerkt89
- een self-update van een geïnstalleerde server vanuit de pipeline (via een systemd-unit, net als BlueGit)90
- binaries bij een tag91
- Elke release-job hangt af van de job `integration`. Die bouwt een echte BlueGit uit `timfa/bluegit` en draait alle featuretests. Faalt er één, dan komt er geen release.92
- **Releases vanaf master staan pas aan zodra `.release-enabled` in de repository staat.** Tim beslist wanneer, en zet ook de geheimen (AUR-sleutel, update-token). Tags zet Tim zelf.93
- De integratietests bouwen BlueGit van de ref in `.bluegit-ref`. Tot de BlueGit-kant gemerged is, is dat `feature/backup-server`. Daarna wordt het `master`.94
- De integratietests draaien nooit tegen een echte BlueGit-installatie. Elke test start een eigen BlueGit in een tijdelijke map, met de dev-login en zonder SSH of CI-runner.95
- Het AUR-pakket haalt de broncode van `https://git.timfalken.com/timfa/bluegit-backup/-/archive/<commit>/…`. Daarom is de repository openbaar, net als `timfa/bluegit`.@@ -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`.@@ -0,0 +1,129 @@
1
# bluegit-backup
2
3
Een losse backup server voor één [BlueGit](https://git.timfalken.com/timfa/bluegit)-instantie.
4
5
- Koppelt met een **Backupserver-Key** die een BlueGit-beheerder in BlueGit maakt (*Beheer → Backup*).
6
- Haalt alle data en configuratie van BlueGit binnen: database, sleutels, SSH-hostkeys, logo's, avatars, repositories, releases en artifacts. Dat gaat **gedoseerd** (`rate_limit_kib`), zodat BlueGit er geen last van heeft.
7
- BlueGit **meldt elke wijziging**. De backup server haalt dan alleen op wat veranderd is. Daarnaast loopt hij elk `full_sync_interval` alles na.
8
- Elk `archive_interval` (standaard dagelijks) gaat de hele kopie gecomprimeerd in een archief (`tar.gz`).
9
- Archieven ouder dan `retention_days` gaan weg. Is de schijf vol (minder dan `min_free_mb` vrij), dan gaat het oudste archief weg. Het nieuwste archief blijft altijd staan.
10
- In BlueGit ziet de beheerder de archieven en kan hij een **rollback** starten, met een grote waarschuwing dat die niet terug te draaien is. De backup server pakt het archief uit, vervangt zijn kopie en stuurt alles naar BlueGit. BlueGit zet de data terug en herstart.
11
- Eén backup server hoort bij één BlueGit. Koppel je een andere instantie, dan kies je: **oude backups wissen** of **de nieuwe instantie herstellen** met de backupdata.
12
13
Het protocol staat in [docs/PROTOCOL.md](docs/PROTOCOL.md). De aannames staan in [docs/ASSUMPTIONS.md](docs/ASSUMPTIONS.md).
14
15
## Installeren
16
17
### Arch Linux (AUR)
18
19
```sh
20
yay -S bluegit-backup
21
```
22
23
Het pakket zet de binary in `/usr/bin/bluegit-backup`, de config in `/etc/bluegit-backup/config.yml`, de data in `/var/lib/bluegit-backup` en een systemd-unit `bluegit-backup.service` (gebruiker `bluegit-backup`).
24
25
### Binary
26
27
Bij een release staan `bluegit-backup-linux-amd64`, `bluegit-backup-linux-arm64` en `SHA256SUMS`. Zelf bouwen:
28
29
```sh
30
go build -o bluegit-backup ./cmd/bluegit-backup
31
./bluegit-backup example-config > config.yml
32
./bluegit-backup serve --config config.yml
33
```
34
35
## Koppelen
36
37
1. Zet in `config.yml` `public_url` op het adres waarop BlueGit deze server bereikt.
38
2. Start de server: `systemctl enable --now bluegit-backup`.
39
3. Maak in BlueGit onder *Beheer → Backup* een Backupserver-Key. Die wordt één keer getoond.
40
4. Koppel:
41
42
```sh
43
BLUEGIT_BACKUP_KEY=bgbk_… bluegit-backup connect --url https://git.example.com
44
```
45
46
Had deze server al backups van een andere BlueGit, dan vraagt `connect`:
47
48
```
49
1) oude backups wissen en opnieuw beginnen
50
2) de nieuwe BlueGit herstellen met de laatste backupdata
51
```
52
53
Zonder terminal kies je met `--on-conflict wipe` of `--on-conflict restore`.
54
55
Daarna haalt de server meteen een volledige kopie op en maakt hij een eerste archief.
56
57
## Bedienen
58
59
```sh
60
bluegit-backup status # koppeling, laatste sync, laatste archief
61
bluegit-backup list # archieven
62
bluegit-backup sync # nu synchroniseren
63
bluegit-backup archive # nu een archief maken
64
bluegit-backup prune # bewaarregels nu toepassen
65
```
66
67
Deze commando's praten met de draaiende server via `data_dir/admin.token` en moeten dus draaien als een gebruiker die dat bestand kan lezen (`sudo -u bluegit-backup …`).
68
69
Een rollback start je in BlueGit, niet hier.
70
71
## Configuratie
72
73
| Sleutel | Standaard | Betekenis |
74
|---|---|---|
75
| `listen` | `0.0.0.0:8790` | Adres van de HTTP-server |
76
| `public_url` | (leeg) | Adres waarop BlueGit deze server bereikt |
77
| `data_dir` | `/var/lib/bluegit-backup` | Kopie, archieven en koppeling |
78
| `archive_interval` | `24h` | Hoe vaak een archief |
79
| `retention_days` | `30` | Archieven ouder dan dit weg (0 = nooit) |
80
| `min_free_mb` | `1024` | Minder vrij: oudste archief weg |
81
| `rate_limit_kib` | `1024` | Downloadsnelheid in KiB/s (0 = onbeperkt) |
82
| `full_sync_interval` | `1h` | Ook zonder melding alles nalopen |
83
| `min_sync_interval` | `10s` | Minimale tijd tussen syncs na meldingen |
84
85
In `data_dir`:
86
87
- `mirror/` is de lopende kopie.
88
- `archives/` bevat `bluegit-YYYYMMDD-HHMMSS.tar.gz` (UTC).
89
- `state.json` (0600) is de koppeling met de key.
90
- `admin.token` (0600) is voor de CLI.
91
92
## Releases
93
94
Dezelfde opties als BlueGit: een AUR-pakket (`bluegit-backup`), een self-update van een geïnstalleerde server vanuit de pipeline en binaries bij een tag. Zie `blue-ci-cd.yml`.
95
96
- Elke release-job hangt af van de job `integration`. Die bouwt een echte BlueGit (`scripts/build-bluegit.sh`, ref in `.bluegit-ref`), start hem, configureert hem en test daarmee elke feature. Faalt er één test, dan is er geen release.
97
- Releases vanaf master staan pas aan zodra het bestand `.release-enabled` in de repository staat. De geheimen staan in de kop van `blue-ci-cd.yml`.
98
- Een release bij een tag (`v*`) publiceert de binaries bij een bestaande tag.
99
100
Self-update: zet `BLUEGIT_BACKUP_UPDATE_TOKEN` in `/etc/bluegit-backup/env` op de server. Zet in de pipeline hetzelfde token plus `BLUEGIT_BACKUP_UPDATE_URL`. De server bouwt dan `bluegit-backup` op het commit van master via `bluegit-backup-update.service`.
101
102
## Tests
103
104
```sh
105
go test ./... # unit-tests
106
./scripts/build-bluegit.sh # bouwt .bluegit-bin/bluegit
107
BLUEGIT_BIN=$PWD/.bluegit-bin/bluegit go test -tags integration -v ./integration/
108
```
109
110
De integratietests starten per test een echte BlueGit in een tijdelijke map (dev-login, geen SSH, geen CI-runner). Ze maken een beheerderstoken en daarmee repositories, issues en een Backupserver-Key. Daarna testen ze tegen die BlueGit:
111
112
| Test | Feature |
113
|---|---|
114
| `TestKeyGenerationAndConnect` | Key maken in BlueGit, koppelen, verkeerde key geweigerd |
115
| `TestFullSyncCopiesAllData` | Alle data en configuratie komt binnen, en de kopie klopt |
116
| `TestNotificationTriggersSync` | Een wijziging in BlueGit geeft een melding en daarna een sync |
117
| `TestDownloadIsThrottled` | Downloaden blijft onder `rate_limit_kib` |
118
| `TestArchiveIntervalAndListInBlueGit` | Archief per interval, lijst zichtbaar in BlueGit |
119
| `TestRetentionAndDiskFull` | Weggooien op leeftijd en bij volle schijf |
120
| `TestRollbackFromBlueGit` | Rollback vanuit BlueGit (met bevestiging), BlueGit staat daarna terug |
121
| `TestNewInstanceWipe` | Nieuwe instantie, keuze wissen |
122
| `TestNewInstanceRestore` | Nieuwe instantie, keuze herstellen |
123
| `TestCLIConnectAsksOnConflict` | `connect` vraagt de keuze |
124
125
De BlueGit-kant (key, meldingen, beheerpagina, rollback) zit in BlueGit op `feature/backup-server`. Zolang die niet gemerged is, bouwt de pipeline BlueGit van die branch (`.bluegit-ref`). Zet `.bluegit-ref` op `master` zodra hij gemerged is.
126
127
## Licentie
128
129
Zie [LICENSE](LICENSE).
@@ -0,0 +1,129 @@1
# bluegit-backup2
3
Een losse backup server voor één [BlueGit](https://git.timfalken.com/timfa/bluegit)-instantie.4
5
- Koppelt met een **Backupserver-Key** die een BlueGit-beheerder in BlueGit maakt (*Beheer → Backup*).6
- Haalt alle data en configuratie van BlueGit binnen: database, sleutels, SSH-hostkeys, logo's, avatars, repositories, releases en artifacts. Dat gaat **gedoseerd** (`rate_limit_kib`), zodat BlueGit er geen last van heeft.7
- BlueGit **meldt elke wijziging**. De backup server haalt dan alleen op wat veranderd is. Daarnaast loopt hij elk `full_sync_interval` alles na.8
- Elk `archive_interval` (standaard dagelijks) gaat de hele kopie gecomprimeerd in een archief (`tar.gz`).9
- Archieven ouder dan `retention_days` gaan weg. Is de schijf vol (minder dan `min_free_mb` vrij), dan gaat het oudste archief weg. Het nieuwste archief blijft altijd staan.10
- In BlueGit ziet de beheerder de archieven en kan hij een **rollback** starten, met een grote waarschuwing dat die niet terug te draaien is. De backup server pakt het archief uit, vervangt zijn kopie en stuurt alles naar BlueGit. BlueGit zet de data terug en herstart.11
- Eén backup server hoort bij één BlueGit. Koppel je een andere instantie, dan kies je: **oude backups wissen** of **de nieuwe instantie herstellen** met de backupdata.12
13
Het protocol staat in [docs/PROTOCOL.md](docs/PROTOCOL.md). De aannames staan in [docs/ASSUMPTIONS.md](docs/ASSUMPTIONS.md).14
15
## Installeren16
17
### Arch Linux (AUR)18
19
```sh20
yay -S bluegit-backup21
```22
23
Het pakket zet de binary in `/usr/bin/bluegit-backup`, de config in `/etc/bluegit-backup/config.yml`, de data in `/var/lib/bluegit-backup` en een systemd-unit `bluegit-backup.service` (gebruiker `bluegit-backup`).24
25
### Binary26
27
Bij een release staan `bluegit-backup-linux-amd64`, `bluegit-backup-linux-arm64` en `SHA256SUMS`. Zelf bouwen:28
29
```sh30
go build -o bluegit-backup ./cmd/bluegit-backup31
./bluegit-backup example-config > config.yml32
./bluegit-backup serve --config config.yml33
```34
35
## Koppelen36
37
1. Zet in `config.yml` `public_url` op het adres waarop BlueGit deze server bereikt.38
2. Start de server: `systemctl enable --now bluegit-backup`.39
3. Maak in BlueGit onder *Beheer → Backup* een Backupserver-Key. Die wordt één keer getoond.40
4. Koppel:41
42
```sh43
BLUEGIT_BACKUP_KEY=bgbk_… bluegit-backup connect --url https://git.example.com44
```45
46
Had deze server al backups van een andere BlueGit, dan vraagt `connect`:47
48
```49
1) oude backups wissen en opnieuw beginnen50
2) de nieuwe BlueGit herstellen met de laatste backupdata51
```52
53
Zonder terminal kies je met `--on-conflict wipe` of `--on-conflict restore`.54
55
Daarna haalt de server meteen een volledige kopie op en maakt hij een eerste archief.56
57
## Bedienen58
59
```sh60
bluegit-backup status # koppeling, laatste sync, laatste archief61
bluegit-backup list # archieven62
bluegit-backup sync # nu synchroniseren63
bluegit-backup archive # nu een archief maken64
bluegit-backup prune # bewaarregels nu toepassen65
```66
67
Deze commando's praten met de draaiende server via `data_dir/admin.token` en moeten dus draaien als een gebruiker die dat bestand kan lezen (`sudo -u bluegit-backup …`).68
69
Een rollback start je in BlueGit, niet hier.70
71
## Configuratie72
73
| Sleutel | Standaard | Betekenis |74
|---|---|---|75
| `listen` | `0.0.0.0:8790` | Adres van de HTTP-server |76
| `public_url` | (leeg) | Adres waarop BlueGit deze server bereikt |77
| `data_dir` | `/var/lib/bluegit-backup` | Kopie, archieven en koppeling |78
| `archive_interval` | `24h` | Hoe vaak een archief |79
| `retention_days` | `30` | Archieven ouder dan dit weg (0 = nooit) |80
| `min_free_mb` | `1024` | Minder vrij: oudste archief weg |81
| `rate_limit_kib` | `1024` | Downloadsnelheid in KiB/s (0 = onbeperkt) |82
| `full_sync_interval` | `1h` | Ook zonder melding alles nalopen |83
| `min_sync_interval` | `10s` | Minimale tijd tussen syncs na meldingen |84
85
In `data_dir`:86
87
- `mirror/` is de lopende kopie.88
- `archives/` bevat `bluegit-YYYYMMDD-HHMMSS.tar.gz` (UTC).89
- `state.json` (0600) is de koppeling met de key.90
- `admin.token` (0600) is voor de CLI.91
92
## Releases93
94
Dezelfde opties als BlueGit: een AUR-pakket (`bluegit-backup`), een self-update van een geïnstalleerde server vanuit de pipeline en binaries bij een tag. Zie `blue-ci-cd.yml`.95
96
- Elke release-job hangt af van de job `integration`. Die bouwt een echte BlueGit (`scripts/build-bluegit.sh`, ref in `.bluegit-ref`), start hem, configureert hem en test daarmee elke feature. Faalt er één test, dan is er geen release.97
- Releases vanaf master staan pas aan zodra het bestand `.release-enabled` in de repository staat. De geheimen staan in de kop van `blue-ci-cd.yml`.98
- Een release bij een tag (`v*`) publiceert de binaries bij een bestaande tag.99
100
Self-update: zet `BLUEGIT_BACKUP_UPDATE_TOKEN` in `/etc/bluegit-backup/env` op de server. Zet in de pipeline hetzelfde token plus `BLUEGIT_BACKUP_UPDATE_URL`. De server bouwt dan `bluegit-backup` op het commit van master via `bluegit-backup-update.service`.101
102
## Tests103
104
```sh105
go test ./... # unit-tests106
./scripts/build-bluegit.sh # bouwt .bluegit-bin/bluegit107
BLUEGIT_BIN=$PWD/.bluegit-bin/bluegit go test -tags integration -v ./integration/108
```109
110
De integratietests starten per test een echte BlueGit in een tijdelijke map (dev-login, geen SSH, geen CI-runner). Ze maken een beheerderstoken en daarmee repositories, issues en een Backupserver-Key. Daarna testen ze tegen die BlueGit:111
112
| Test | Feature |113
|---|---|114
| `TestKeyGenerationAndConnect` | Key maken in BlueGit, koppelen, verkeerde key geweigerd |115
| `TestFullSyncCopiesAllData` | Alle data en configuratie komt binnen, en de kopie klopt |116
| `TestNotificationTriggersSync` | Een wijziging in BlueGit geeft een melding en daarna een sync |117
| `TestDownloadIsThrottled` | Downloaden blijft onder `rate_limit_kib` |118
| `TestArchiveIntervalAndListInBlueGit` | Archief per interval, lijst zichtbaar in BlueGit |119
| `TestRetentionAndDiskFull` | Weggooien op leeftijd en bij volle schijf |120
| `TestRollbackFromBlueGit` | Rollback vanuit BlueGit (met bevestiging), BlueGit staat daarna terug |121
| `TestNewInstanceWipe` | Nieuwe instantie, keuze wissen |122
| `TestNewInstanceRestore` | Nieuwe instantie, keuze herstellen |123
| `TestCLIConnectAsksOnConflict` | `connect` vraagt de keuze |124
125
De BlueGit-kant (key, meldingen, beheerpagina, rollback) zit in BlueGit op `feature/backup-server`. Zolang die niet gemerged is, bouwt de pipeline BlueGit van die branch (`.bluegit-ref`). Zet `.bluegit-ref` op `master` zodra hij gemerged is.126
127
## Licentie128
129
Zie [LICENSE](LICENSE).@@ -0,0 +1,340 @@
1
// Package archive maakt, bewaart, ruimt op en pakt archieven uit.
2
//
3
// Een archief is een tar.gz (PAX, mtimes in milliseconden) van de kopie met
4
// logische paden (state/…, data/…), precies wat BlueGit bij een restore
5
// aanneemt. Naam: bluegit-YYYYMMDD-HHMMSS.tar.gz in UTC.
6
package archive
7
8
import (
9
"archive/tar"
10
"compress/gzip"
11
"errors"
12
"fmt"
13
"io"
14
"io/fs"
15
"os"
16
"path/filepath"
17
"regexp"
18
"sort"
19
"strings"
20
"time"
21
22
"git.timfalken.com/timfa/bluegit-backup/internal/protocol"
23
)
24
25
var nameRE = regexp.MustCompile(`^bluegit-\d{8}-\d{6}(-\d{1,3})?\.tar\.gz$`)
26
27
// ValidName zegt of name een archiefnaam is (geen pad, geen ..).
28
func ValidName(name string) bool { return nameRE.MatchString(name) }
29
30
// Archive is één archief op schijf.
31
type Archive struct {
32
Name string `json:"name"`
33
CreatedAt time.Time `json:"created_at"`
34
Size int64 `json:"size"`
35
}
36
37
// Store is de map met archieven.
38
type Store struct {
39
Dir string
40
// Free geeft de vrije bytes op het bestandssysteem van Dir. Tests
41
// zetten een nep-versie; nil gebruikt statfs.
42
Free func(dir string) (uint64, error)
43
}
44
45
func (s *Store) free() (uint64, error) {
46
if s.Free != nil {
47
return s.Free(s.Dir)
48
}
49
return FreeBytes(s.Dir)
50
}
51
52
// List geeft de archieven, nieuwste eerst.
53
func (s *Store) List() ([]Archive, error) {
54
ents, err := os.ReadDir(s.Dir)
55
if errors.Is(err, os.ErrNotExist) {
56
return []Archive{}, nil
57
}
58
if err != nil {
59
return nil, err
60
}
61
out := []Archive{}
62
for _, e := range ents {
63
if e.IsDir() || !ValidName(e.Name()) {
64
continue
65
}
66
fi, err := e.Info()
67
if err != nil {
68
continue
69
}
70
out = append(out, Archive{Name: e.Name(), CreatedAt: createdAt(e.Name(), fi), Size: fi.Size()})
71
}
72
sort.Slice(out, func(i, j int) bool {
73
if out[i].CreatedAt.Equal(out[j].CreatedAt) {
74
return out[i].Name > out[j].Name
75
}
76
return out[i].CreatedAt.After(out[j].CreatedAt)
77
})
78
return out, nil
79
}
80
81
// createdAt neemt de mtime: die is gelijk aan de naam, maar tests en een
82
// beheerder kunnen hem verzetten om de bewaartermijn te testen.
83
func createdAt(name string, fi fs.FileInfo) time.Time {
84
return fi.ModTime().UTC()
85
}
86
87
// Path geeft het pad van een bestaand archief.
88
func (s *Store) Path(name string) (string, error) {
89
if !ValidName(name) {
90
return "", errors.New("ongeldige archiefnaam")
91
}
92
p := filepath.Join(s.Dir, name)
93
if _, err := os.Stat(p); err != nil {
94
return "", fmt.Errorf("archief %s bestaat niet", name)
95
}
96
return p, nil
97
}
98
99
// DeleteAll verwijdert alle archieven.
100
func (s *Store) DeleteAll() error {
101
list, err := s.List()
102
if err != nil {
103
return err
104
}
105
for _, a := range list {
106
if err := os.Remove(filepath.Join(s.Dir, a.Name)); err != nil {
107
return err
108
}
109
}
110
return nil
111
}
112
113
// Create schrijft een nieuw archief van mirrorDir. needBytes is een
114
// schatting van de grootte; is er te weinig ruimte, dan gaan eerst oude
115
// archieven weg (het nieuwste blijft).
116
func (s *Store) Create(mirrorDir string, now time.Time, needBytes int64, minFree uint64) (Archive, []string, error) {
117
if err := os.MkdirAll(s.Dir, 0o750); err != nil {
118
return Archive{}, nil, err
119
}
120
var removed []string
121
for {
122
free, err := s.free()
123
if err != nil || free >= uint64(needBytes)+minFree {
124
break
125
}
126
// Het nieuwe archief wordt het nieuwste; daarvoor mag ook het
127
// laatste oude weg. De draaiende kopie blijft altijd staan.
128
name, ok, err := s.removeOldest(0)
129
if err != nil {
130
return Archive{}, removed, err
131
}
132
if !ok {
133
return Archive{}, removed, fmt.Errorf("te weinig schijfruimte voor een archief (%d MB vrij, %d MB nodig)", free>>20, (uint64(needBytes)+minFree)>>20)
134
}
135
removed = append(removed, name)
136
}
137
base := "bluegit-" + now.UTC().Format("20060102-150405")
138
name := base + ".tar.gz"
139
for i := 1; ; i++ {
140
if _, err := os.Stat(filepath.Join(s.Dir, name)); errors.Is(err, os.ErrNotExist) {
141
break
142
}
143
name = fmt.Sprintf("%s-%d.tar.gz", base, i)
144
}
145
tmp := filepath.Join(s.Dir, "."+name+".partial")
146
f, err := os.OpenFile(tmp, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0o640)
147
if err != nil {
148
return Archive{}, removed, err
149
}
150
if err := WriteTarGz(f, mirrorDir); err != nil {
151
f.Close()
152
os.Remove(tmp)
153
return Archive{}, removed, err
154
}
155
if err := f.Sync(); err != nil {
156
f.Close()
157
os.Remove(tmp)
158
return Archive{}, removed, err
159
}
160
if err := f.Close(); err != nil {
161
os.Remove(tmp)
162
return Archive{}, removed, err
163
}
164
final := filepath.Join(s.Dir, name)
165
if err := os.Rename(tmp, final); err != nil {
166
os.Remove(tmp)
167
return Archive{}, removed, err
168
}
169
_ = os.Chtimes(final, now, now)
170
fi, _ := os.Stat(final)
171
return Archive{Name: name, CreatedAt: now.UTC(), Size: fi.Size()}, removed, nil
172
}
173
174
// removeOldest verwijdert het oudste archief zolang er meer dan keep zijn.
175
func (s *Store) removeOldest(keep int) (string, bool, error) {
176
list, err := s.List()
177
if err != nil {
178
return "", false, err
179
}
180
if len(list) <= keep {
181
return "", false, nil
182
}
183
old := list[len(list)-1]
184
if err := os.Remove(filepath.Join(s.Dir, old.Name)); err != nil {
185
return "", false, err
186
}
187
return old.Name, true, nil
188
}
189
190
// Prune verwijdert archieven ouder dan retentionDays (0 = niet op leeftijd)
191
// en daarna de oudste zolang er minder dan minFree bytes vrij is. Het
192
// nieuwste archief blijft altijd staan.
193
func (s *Store) Prune(now time.Time, retentionDays int, minFree uint64) ([]string, error) {
194
var removed []string
195
list, err := s.List()
196
if err != nil {
197
return nil, err
198
}
199
if retentionDays > 0 {
200
cut := now.Add(-time.Duration(retentionDays) * 24 * time.Hour)
201
for i, a := range list {
202
if i == 0 || !a.CreatedAt.Before(cut) {
203
continue
204
}
205
if err := os.Remove(filepath.Join(s.Dir, a.Name)); err != nil {
206
return removed, err
207
}
208
removed = append(removed, a.Name)
209
}
210
}
211
for {
212
free, err := s.free()
213
if err != nil || free >= minFree {
214
break
215
}
216
name, ok, err := s.removeOldest(1)
217
if err != nil {
218
return removed, err
219
}
220
if !ok {
221
break
222
}
223
removed = append(removed, name)
224
}
225
return removed, nil
226
}
227
228
// WriteTarGz schrijft dir als tar.gz met logische paden naar w.
229
func WriteTarGz(w io.Writer, dir string) error {
230
gz, _ := gzip.NewWriterLevel(w, gzip.DefaultCompression)
231
tw := tar.NewWriter(gz)
232
var paths []string
233
err := filepath.WalkDir(dir, func(p string, d fs.DirEntry, err error) error {
234
if err != nil {
235
if errors.Is(err, fs.ErrNotExist) && p == dir {
236
return fs.SkipDir
237
}
238
return err
239
}
240
if d.Type().IsRegular() {
241
paths = append(paths, p)
242
}
243
return nil
244
})
245
if err != nil {
246
return err
247
}
248
sort.Strings(paths)
249
for _, p := range paths {
250
rel, _ := filepath.Rel(dir, p)
251
logical := filepath.ToSlash(rel)
252
if _, ok := protocol.CleanLogical(logical); !ok {
253
continue
254
}
255
if err := addFile(tw, p, logical); err != nil {
256
return err
257
}
258
}
259
if err := tw.Close(); err != nil {
260
return err
261
}
262
return gz.Close()
263
}
264
265
func addFile(tw *tar.Writer, p, logical string) error {
266
f, err := os.Open(p)
267
if err != nil {
268
return err
269
}
270
defer f.Close()
271
fi, err := f.Stat()
272
if err != nil {
273
return err
274
}
275
h := &tar.Header{
276
Name: logical, Mode: int64(fi.Mode().Perm()), Size: fi.Size(), Typeflag: tar.TypeReg,
277
ModTime: fi.ModTime(), Format: tar.FormatPAX,
278
}
279
if err := tw.WriteHeader(h); err != nil {
280
return err
281
}
282
_, err = io.CopyN(tw, f, fi.Size())
283
return err
284
}
285
286
// Extract pakt archief src uit in dst (dat nog niet mag bestaan). Alleen
287
// gewone bestanden met geldige logische paden.
288
func Extract(src, dst string) error {
289
f, err := os.Open(src)
290
if err != nil {
291
return err
292
}
293
defer f.Close()
294
return ExtractReader(f, dst)
295
}
296
297
// ExtractReader is Extract vanaf een stroom.
298
func ExtractReader(r io.Reader, dst string) error {
299
if err := os.MkdirAll(dst, 0o750); err != nil {
300
return err
301
}
302
gz, err := gzip.NewReader(r)
303
if err != nil {
304
return err
305
}
306
tr := tar.NewReader(gz)
307
for {
308
h, err := tr.Next()
309
if err == io.EOF {
310
return nil
311
}
312
if err != nil {
313
return err
314
}
315
if h.Typeflag == tar.TypeDir {
316
continue
317
}
318
logical, ok := protocol.CleanLogical(strings.TrimPrefix(h.Name, "./"))
319
if h.Typeflag != tar.TypeReg || !ok {
320
return fmt.Errorf("ongeldig item in archief: %q", h.Name)
321
}
322
out := filepath.Join(dst, filepath.FromSlash(logical))
323
if err := os.MkdirAll(filepath.Dir(out), 0o750); err != nil {
324
return err
325
}
326
mode := os.FileMode(h.Mode).Perm()&0o755 | 0o600
327
w, err := os.OpenFile(out, os.O_CREATE|os.O_EXCL|os.O_WRONLY, mode)
328
if err != nil {
329
return err
330
}
331
if _, err := io.Copy(w, tr); err != nil {
332
w.Close()
333
return err
334
}
335
if err := w.Close(); err != nil {
336
return err
337
}
338
_ = os.Chtimes(out, h.ModTime, h.ModTime)
339
}
340
}
@@ -0,0 +1,340 @@1
// Package archive maakt, bewaart, ruimt op en pakt archieven uit.2
//3
// Een archief is een tar.gz (PAX, mtimes in milliseconden) van de kopie met4
// logische paden (state/…, data/…), precies wat BlueGit bij een restore5
// aanneemt. Naam: bluegit-YYYYMMDD-HHMMSS.tar.gz in UTC.6
package archive7
8
import (9
"archive/tar"10
"compress/gzip"11
"errors"12
"fmt"13
"io"14
"io/fs"15
"os"16
"path/filepath"17
"regexp"18
"sort"19
"strings"20
"time"21
22
"git.timfalken.com/timfa/bluegit-backup/internal/protocol"23
)24
25
var nameRE = regexp.MustCompile(`^bluegit-\d{8}-\d{6}(-\d{1,3})?\.tar\.gz$`)26
27
// ValidName zegt of name een archiefnaam is (geen pad, geen ..).28
func ValidName(name string) bool { return nameRE.MatchString(name) }29
30
// Archive is één archief op schijf.31
type Archive struct {32
Name string `json:"name"`33
CreatedAt time.Time `json:"created_at"`34
Size int64 `json:"size"`35
}36
37
// Store is de map met archieven.38
type Store struct {39
Dir string40
// Free geeft de vrije bytes op het bestandssysteem van Dir. Tests41
// zetten een nep-versie; nil gebruikt statfs.42
Free func(dir string) (uint64, error)43
}44
45
func (s *Store) free() (uint64, error) {46
if s.Free != nil {47
return s.Free(s.Dir)48
}49
return FreeBytes(s.Dir)50
}51
52
// List geeft de archieven, nieuwste eerst.53
func (s *Store) List() ([]Archive, error) {54
ents, err := os.ReadDir(s.Dir)55
if errors.Is(err, os.ErrNotExist) {56
return []Archive{}, nil57
}58
if err != nil {59
return nil, err60
}61
out := []Archive{}62
for _, e := range ents {63
if e.IsDir() || !ValidName(e.Name()) {64
continue65
}66
fi, err := e.Info()67
if err != nil {68
continue69
}70
out = append(out, Archive{Name: e.Name(), CreatedAt: createdAt(e.Name(), fi), Size: fi.Size()})71
}72
sort.Slice(out, func(i, j int) bool {73
if out[i].CreatedAt.Equal(out[j].CreatedAt) {74
return out[i].Name > out[j].Name75
}76
return out[i].CreatedAt.After(out[j].CreatedAt)77
})78
return out, nil79
}80
81
// createdAt neemt de mtime: die is gelijk aan de naam, maar tests en een82
// beheerder kunnen hem verzetten om de bewaartermijn te testen.83
func createdAt(name string, fi fs.FileInfo) time.Time {84
return fi.ModTime().UTC()85
}86
87
// Path geeft het pad van een bestaand archief.88
func (s *Store) Path(name string) (string, error) {89
if !ValidName(name) {90
return "", errors.New("ongeldige archiefnaam")91
}92
p := filepath.Join(s.Dir, name)93
if _, err := os.Stat(p); err != nil {94
return "", fmt.Errorf("archief %s bestaat niet", name)95
}96
return p, nil97
}98
99
// DeleteAll verwijdert alle archieven.100
func (s *Store) DeleteAll() error {101
list, err := s.List()102
if err != nil {103
return err104
}105
for _, a := range list {106
if err := os.Remove(filepath.Join(s.Dir, a.Name)); err != nil {107
return err108
}109
}110
return nil111
}112
113
// Create schrijft een nieuw archief van mirrorDir. needBytes is een114
// schatting van de grootte; is er te weinig ruimte, dan gaan eerst oude115
// archieven weg (het nieuwste blijft).116
func (s *Store) Create(mirrorDir string, now time.Time, needBytes int64, minFree uint64) (Archive, []string, error) {117
if err := os.MkdirAll(s.Dir, 0o750); err != nil {118
return Archive{}, nil, err119
}120
var removed []string121
for {122
free, err := s.free()123
if err != nil || free >= uint64(needBytes)+minFree {124
break125
}126
// Het nieuwe archief wordt het nieuwste; daarvoor mag ook het127
// laatste oude weg. De draaiende kopie blijft altijd staan.128
name, ok, err := s.removeOldest(0)129
if err != nil {130
return Archive{}, removed, err131
}132
if !ok {133
return Archive{}, removed, fmt.Errorf("te weinig schijfruimte voor een archief (%d MB vrij, %d MB nodig)", free>>20, (uint64(needBytes)+minFree)>>20)134
}135
removed = append(removed, name)136
}137
base := "bluegit-" + now.UTC().Format("20060102-150405")138
name := base + ".tar.gz"139
for i := 1; ; i++ {140
if _, err := os.Stat(filepath.Join(s.Dir, name)); errors.Is(err, os.ErrNotExist) {141
break142
}143
name = fmt.Sprintf("%s-%d.tar.gz", base, i)144
}145
tmp := filepath.Join(s.Dir, "."+name+".partial")146
f, err := os.OpenFile(tmp, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0o640)147
if err != nil {148
return Archive{}, removed, err149
}150
if err := WriteTarGz(f, mirrorDir); err != nil {151
f.Close()152
os.Remove(tmp)153
return Archive{}, removed, err154
}155
if err := f.Sync(); err != nil {156
f.Close()157
os.Remove(tmp)158
return Archive{}, removed, err159
}160
if err := f.Close(); err != nil {161
os.Remove(tmp)162
return Archive{}, removed, err163
}164
final := filepath.Join(s.Dir, name)165
if err := os.Rename(tmp, final); err != nil {166
os.Remove(tmp)167
return Archive{}, removed, err168
}169
_ = os.Chtimes(final, now, now)170
fi, _ := os.Stat(final)171
return Archive{Name: name, CreatedAt: now.UTC(), Size: fi.Size()}, removed, nil172
}173
174
// removeOldest verwijdert het oudste archief zolang er meer dan keep zijn.175
func (s *Store) removeOldest(keep int) (string, bool, error) {176
list, err := s.List()177
if err != nil {178
return "", false, err179
}180
if len(list) <= keep {181
return "", false, nil182
}183
old := list[len(list)-1]184
if err := os.Remove(filepath.Join(s.Dir, old.Name)); err != nil {185
return "", false, err186
}187
return old.Name, true, nil188
}189
190
// Prune verwijdert archieven ouder dan retentionDays (0 = niet op leeftijd)191
// en daarna de oudste zolang er minder dan minFree bytes vrij is. Het192
// nieuwste archief blijft altijd staan.193
func (s *Store) Prune(now time.Time, retentionDays int, minFree uint64) ([]string, error) {194
var removed []string195
list, err := s.List()196
if err != nil {197
return nil, err198
}199
if retentionDays > 0 {200
cut := now.Add(-time.Duration(retentionDays) * 24 * time.Hour)201
for i, a := range list {202
if i == 0 || !a.CreatedAt.Before(cut) {203
continue204
}205
if err := os.Remove(filepath.Join(s.Dir, a.Name)); err != nil {206
return removed, err207
}208
removed = append(removed, a.Name)209
}210
}211
for {212
free, err := s.free()213
if err != nil || free >= minFree {214
break215
}216
name, ok, err := s.removeOldest(1)217
if err != nil {218
return removed, err219
}220
if !ok {221
break222
}223
removed = append(removed, name)224
}225
return removed, nil226
}227
228
// WriteTarGz schrijft dir als tar.gz met logische paden naar w.229
func WriteTarGz(w io.Writer, dir string) error {230
gz, _ := gzip.NewWriterLevel(w, gzip.DefaultCompression)231
tw := tar.NewWriter(gz)232
var paths []string233
err := filepath.WalkDir(dir, func(p string, d fs.DirEntry, err error) error {234
if err != nil {235
if errors.Is(err, fs.ErrNotExist) && p == dir {236
return fs.SkipDir237
}238
return err239
}240
if d.Type().IsRegular() {241
paths = append(paths, p)242
}243
return nil244
})245
if err != nil {246
return err247
}248
sort.Strings(paths)249
for _, p := range paths {250
rel, _ := filepath.Rel(dir, p)251
logical := filepath.ToSlash(rel)252
if _, ok := protocol.CleanLogical(logical); !ok {253
continue254
}255
if err := addFile(tw, p, logical); err != nil {256
return err257
}258
}259
if err := tw.Close(); err != nil {260
return err261
}262
return gz.Close()263
}264
265
func addFile(tw *tar.Writer, p, logical string) error {266
f, err := os.Open(p)267
if err != nil {268
return err269
}270
defer f.Close()271
fi, err := f.Stat()272
if err != nil {273
return err274
}275
h := &tar.Header{276
Name: logical, Mode: int64(fi.Mode().Perm()), Size: fi.Size(), Typeflag: tar.TypeReg,277
ModTime: fi.ModTime(), Format: tar.FormatPAX,278
}279
if err := tw.WriteHeader(h); err != nil {280
return err281
}282
_, err = io.CopyN(tw, f, fi.Size())283
return err284
}285
286
// Extract pakt archief src uit in dst (dat nog niet mag bestaan). Alleen287
// gewone bestanden met geldige logische paden.288
func Extract(src, dst string) error {289
f, err := os.Open(src)290
if err != nil {291
return err292
}293
defer f.Close()294
return ExtractReader(f, dst)295
}296
297
// ExtractReader is Extract vanaf een stroom.298
func ExtractReader(r io.Reader, dst string) error {299
if err := os.MkdirAll(dst, 0o750); err != nil {300
return err301
}302
gz, err := gzip.NewReader(r)303
if err != nil {304
return err305
}306
tr := tar.NewReader(gz)307
for {308
h, err := tr.Next()309
if err == io.EOF {310
return nil311
}312
if err != nil {313
return err314
}315
if h.Typeflag == tar.TypeDir {316
continue317
}318
logical, ok := protocol.CleanLogical(strings.TrimPrefix(h.Name, "./"))319
if h.Typeflag != tar.TypeReg || !ok {320
return fmt.Errorf("ongeldig item in archief: %q", h.Name)321
}322
out := filepath.Join(dst, filepath.FromSlash(logical))323
if err := os.MkdirAll(filepath.Dir(out), 0o750); err != nil {324
return err325
}326
mode := os.FileMode(h.Mode).Perm()&0o755 | 0o600327
w, err := os.OpenFile(out, os.O_CREATE|os.O_EXCL|os.O_WRONLY, mode)328
if err != nil {329
return err330
}331
if _, err := io.Copy(w, tr); err != nil {332
w.Close()333
return err334
}335
if err := w.Close(); err != nil {336
return err337
}338
_ = os.Chtimes(out, h.ModTime, h.ModTime)339
}340
}@@ -0,0 +1,124 @@
1
package archive
2
3
import (
4
"archive/tar"
5
"bytes"
6
"compress/gzip"
7
"os"
8
"path/filepath"
9
"testing"
10
"time"
11
)
12
13
func mkMirror(t *testing.T) string {
14
d := t.TempDir()
15
files := map[string]string{"state/bluegit.db": "db", "state/secret.key": "k", "data/repos/tim/a.git/HEAD": "ref", "stray.txt": "nee"}
16
for p, c := range files {
17
full := filepath.Join(d, filepath.FromSlash(p))
18
_ = os.MkdirAll(filepath.Dir(full), 0o755)
19
_ = os.WriteFile(full, []byte(c), 0o644)
20
}
21
mt := time.UnixMilli(1_700_000_000_123)
22
_ = os.Chtimes(filepath.Join(d, "data/repos/tim/a.git/HEAD"), mt, mt)
23
return d
24
}
25
26
func TestCreateListExtractRoundtrip(t *testing.T) {
27
s := &Store{Dir: t.TempDir(), Free: func(string) (uint64, error) { return 1 << 40, nil }}
28
now := time.Date(2026, 11, 15, 12, 0, 0, 0, time.UTC)
29
a, removed, err := s.Create(mkMirror(t), now, 10, 0)
30
if err != nil || len(removed) != 0 || a.Name != "bluegit-20261115-120000.tar.gz" {
31
t.Fatal(a, removed, err)
32
}
33
b, _, _ := s.Create(mkMirror(t), now, 10, 0)
34
if b.Name != "bluegit-20261115-120000-1.tar.gz" {
35
t.Fatalf("dubbele naam: %s", b.Name)
36
}
37
list, _ := s.List()
38
if len(list) != 2 {
39
t.Fatal(list)
40
}
41
dst := filepath.Join(t.TempDir(), "x")
42
p, _ := s.Path(a.Name)
43
if err := Extract(p, dst); err != nil {
44
t.Fatal(err)
45
}
46
fi, err := os.Stat(filepath.Join(dst, "data/repos/tim/a.git/HEAD"))
47
if err != nil || fi.ModTime().UnixMilli() != 1_700_000_000_123 {
48
t.Fatalf("mtime in milliseconden niet bewaard: %v %v", err, fi)
49
}
50
if _, err := os.Stat(filepath.Join(dst, "stray.txt")); err == nil {
51
t.Fatal("onbekend pad in archief")
52
}
53
if _, err := s.Path("../etc/passwd"); err == nil {
54
t.Fatal("pad buiten de map")
55
}
56
}
57
58
func TestPruneRules(t *testing.T) {
59
free := uint64(1 << 40)
60
s := &Store{Dir: t.TempDir(), Free: func(string) (uint64, error) { return free, nil }}
61
now := time.Date(2026, 11, 15, 12, 0, 0, 0, time.UTC)
62
var names []string
63
for i := 0; i < 4; i++ {
64
a, _, err := s.Create(mkMirror(t), now.Add(time.Duration(i)*time.Second), 1, 0)
65
if err != nil {
66
t.Fatal(err)
67
}
68
names = append(names, a.Name)
69
}
70
// Leeftijd: 40, 31 en 29 dagen; nieuwste vandaag.
71
for i, d := range []int{40, 31, 29} {
72
old := now.Add(-time.Duration(d) * 24 * time.Hour)
73
_ = os.Chtimes(filepath.Join(s.Dir, names[i]), old, old)
74
}
75
removed, err := s.Prune(now, 30, 0)
76
if err != nil || len(removed) != 2 {
77
t.Fatal(removed, err)
78
}
79
// 0 dagen = niet op leeftijd.
80
if r, _ := s.Prune(now.Add(1000*24*time.Hour), 0, 0); len(r) != 0 {
81
t.Fatal(r)
82
}
83
// Alles te oud: het nieuwste blijft.
84
if r, _ := s.Prune(now.Add(1000*24*time.Hour), 1, 0); len(r) != 1 {
85
t.Fatal(r)
86
}
87
if l, _ := s.List(); len(l) != 1 || l[0].Name != names[3] {
88
t.Fatal(l)
89
}
90
// Schijf vol: nieuwste blijft.
91
free = 0
92
if r, _ := s.Prune(now, 0, 1<<20); len(r) != 0 {
93
t.Fatal(r)
94
}
95
// Nieuw archief bij volle schijf: oude weg, dan pas schrijven; lukt
96
// dat niet, dan een fout.
97
if _, _, err := s.Create(mkMirror(t), now.Add(time.Hour), 1, 1<<20); err == nil {
98
t.Fatal("archief zonder ruimte")
99
}
100
if l, _ := s.List(); len(l) != 0 {
101
t.Fatalf("het oude archief had weg gemoeten voor ruimte: %v", l)
102
}
103
}
104
105
func TestExtractRejects(t *testing.T) {
106
for name, hdr := range map[string]*tar.Header{
107
"traversal": {Name: "data/repos/../../x", Typeflag: tar.TypeReg, Mode: 0o644},
108
"symlink": {Name: "data/repos/a/l", Typeflag: tar.TypeSymlink, Linkname: "/etc/passwd"},
109
"absoluut": {Name: "/etc/passwd", Typeflag: tar.TypeReg, Mode: 0o644},
110
} {
111
var buf bytes.Buffer
112
gz := gzip.NewWriter(&buf)
113
tw := tar.NewWriter(gz)
114
_ = tw.WriteHeader(hdr)
115
_ = tw.Close()
116
_ = gz.Close()
117
if err := ExtractReader(&buf, filepath.Join(t.TempDir(), "x")); err == nil {
118
t.Errorf("%s geaccepteerd", name)
119
}
120
}
121
if ValidName("bluegit-x.tar.gz") || !ValidName("bluegit-20261115-120000.tar.gz") || ValidName("../bluegit-20261115-120000.tar.gz") {
122
t.Fatal("ValidName")
123
}
124
}
@@ -0,0 +1,124 @@1
package archive2
3
import (4
"archive/tar"5
"bytes"6
"compress/gzip"7
"os"8
"path/filepath"9
"testing"10
"time"11
)12
13
func mkMirror(t *testing.T) string {14
d := t.TempDir()15
files := map[string]string{"state/bluegit.db": "db", "state/secret.key": "k", "data/repos/tim/a.git/HEAD": "ref", "stray.txt": "nee"}16
for p, c := range files {17
full := filepath.Join(d, filepath.FromSlash(p))18
_ = os.MkdirAll(filepath.Dir(full), 0o755)19
_ = os.WriteFile(full, []byte(c), 0o644)20
}21
mt := time.UnixMilli(1_700_000_000_123)22
_ = os.Chtimes(filepath.Join(d, "data/repos/tim/a.git/HEAD"), mt, mt)23
return d24
}25
26
func TestCreateListExtractRoundtrip(t *testing.T) {27
s := &Store{Dir: t.TempDir(), Free: func(string) (uint64, error) { return 1 << 40, nil }}28
now := time.Date(2026, 11, 15, 12, 0, 0, 0, time.UTC)29
a, removed, err := s.Create(mkMirror(t), now, 10, 0)30
if err != nil || len(removed) != 0 || a.Name != "bluegit-20261115-120000.tar.gz" {31
t.Fatal(a, removed, err)32
}33
b, _, _ := s.Create(mkMirror(t), now, 10, 0)34
if b.Name != "bluegit-20261115-120000-1.tar.gz" {35
t.Fatalf("dubbele naam: %s", b.Name)36
}37
list, _ := s.List()38
if len(list) != 2 {39
t.Fatal(list)40
}41
dst := filepath.Join(t.TempDir(), "x")42
p, _ := s.Path(a.Name)43
if err := Extract(p, dst); err != nil {44
t.Fatal(err)45
}46
fi, err := os.Stat(filepath.Join(dst, "data/repos/tim/a.git/HEAD"))47
if err != nil || fi.ModTime().UnixMilli() != 1_700_000_000_123 {48
t.Fatalf("mtime in milliseconden niet bewaard: %v %v", err, fi)49
}50
if _, err := os.Stat(filepath.Join(dst, "stray.txt")); err == nil {51
t.Fatal("onbekend pad in archief")52
}53
if _, err := s.Path("../etc/passwd"); err == nil {54
t.Fatal("pad buiten de map")55
}56
}57
58
func TestPruneRules(t *testing.T) {59
free := uint64(1 << 40)60
s := &Store{Dir: t.TempDir(), Free: func(string) (uint64, error) { return free, nil }}61
now := time.Date(2026, 11, 15, 12, 0, 0, 0, time.UTC)62
var names []string63
for i := 0; i < 4; i++ {64
a, _, err := s.Create(mkMirror(t), now.Add(time.Duration(i)*time.Second), 1, 0)65
if err != nil {66
t.Fatal(err)67
}68
names = append(names, a.Name)69
}70
// Leeftijd: 40, 31 en 29 dagen; nieuwste vandaag.71
for i, d := range []int{40, 31, 29} {72
old := now.Add(-time.Duration(d) * 24 * time.Hour)73
_ = os.Chtimes(filepath.Join(s.Dir, names[i]), old, old)74
}75
removed, err := s.Prune(now, 30, 0)76
if err != nil || len(removed) != 2 {77
t.Fatal(removed, err)78
}79
// 0 dagen = niet op leeftijd.80
if r, _ := s.Prune(now.Add(1000*24*time.Hour), 0, 0); len(r) != 0 {81
t.Fatal(r)82
}83
// Alles te oud: het nieuwste blijft.84
if r, _ := s.Prune(now.Add(1000*24*time.Hour), 1, 0); len(r) != 1 {85
t.Fatal(r)86
}87
if l, _ := s.List(); len(l) != 1 || l[0].Name != names[3] {88
t.Fatal(l)89
}90
// Schijf vol: nieuwste blijft.91
free = 092
if r, _ := s.Prune(now, 0, 1<<20); len(r) != 0 {93
t.Fatal(r)94
}95
// Nieuw archief bij volle schijf: oude weg, dan pas schrijven; lukt96
// dat niet, dan een fout.97
if _, _, err := s.Create(mkMirror(t), now.Add(time.Hour), 1, 1<<20); err == nil {98
t.Fatal("archief zonder ruimte")99
}100
if l, _ := s.List(); len(l) != 0 {101
t.Fatalf("het oude archief had weg gemoeten voor ruimte: %v", l)102
}103
}104
105
func TestExtractRejects(t *testing.T) {106
for name, hdr := range map[string]*tar.Header{107
"traversal": {Name: "data/repos/../../x", Typeflag: tar.TypeReg, Mode: 0o644},108
"symlink": {Name: "data/repos/a/l", Typeflag: tar.TypeSymlink, Linkname: "/etc/passwd"},109
"absoluut": {Name: "/etc/passwd", Typeflag: tar.TypeReg, Mode: 0o644},110
} {111
var buf bytes.Buffer112
gz := gzip.NewWriter(&buf)113
tw := tar.NewWriter(gz)114
_ = tw.WriteHeader(hdr)115
_ = tw.Close()116
_ = gz.Close()117
if err := ExtractReader(&buf, filepath.Join(t.TempDir(), "x")); err == nil {118
t.Errorf("%s geaccepteerd", name)119
}120
}121
if ValidName("bluegit-x.tar.gz") || !ValidName("bluegit-20261115-120000.tar.gz") || ValidName("../bluegit-20261115-120000.tar.gz") {122
t.Fatal("ValidName")123
}124
}@@ -0,0 +1,14 @@
1
//go:build linux || darwin || freebsd
2
3
package archive
4
5
import "syscall"
6
7
// FreeBytes geeft de vrije ruimte voor een gewone gebruiker op dir.
8
func FreeBytes(dir string) (uint64, error) {
9
var st syscall.Statfs_t
10
if err := syscall.Statfs(dir, &st); err != nil {
11
return 0, err
12
}
13
return uint64(st.Bavail) * uint64(st.Bsize), nil
14
}
@@ -0,0 +1,14 @@1
//go:build linux || darwin || freebsd2
3
package archive4
5
import "syscall"6
7
// FreeBytes geeft de vrije ruimte voor een gewone gebruiker op dir.8
func FreeBytes(dir string) (uint64, error) {9
var st syscall.Statfs_t10
if err := syscall.Statfs(dir, &st); err != nil {11
return 0, err12
}13
return uint64(st.Bavail) * uint64(st.Bsize), nil14
}@@ -0,0 +1,8 @@
1
//go:build !(linux || darwin || freebsd)
2
3
package archive
4
5
import "errors"
6
7
// FreeBytes is niet beschikbaar op dit platform; de schijf-vol-regel doet dan niets.
8
func FreeBytes(dir string) (uint64, error) { return 0, errors.New("statfs niet beschikbaar") }
@@ -0,0 +1,8 @@1
//go:build !(linux || darwin || freebsd)2
3
package archive4
5
import "errors"6
7
// FreeBytes is niet beschikbaar op dit platform; de schijf-vol-regel doet dan niets.8
func FreeBytes(dir string) (uint64, error) { return 0, errors.New("statfs niet beschikbaar") }@@ -0,0 +1,151 @@
1
// Package config leest de configuratie van de backup server.
2
package config
3
4
import (
5
"fmt"
6
"os"
7
"strings"
8
"time"
9
10
"gopkg.in/yaml.v3"
11
)
12
13
// Config is /etc/bluegit-backup/config.yml.
14
type Config struct {
15
// Listen is waar de backup server luistert (plain HTTP; TLS doet een
16
// proxy ervoor als dat nodig is).
17
Listen string `yaml:"listen"`
18
// PublicURL is het adres waarop BlueGit deze server bereikt, voor
19
// meldingen, de archieflijst en rollback.
20
PublicURL string `yaml:"public_url"`
21
// DataDir bevat de draaiende kopie, de archieven en de koppeling.
22
DataDir string `yaml:"data_dir"`
23
// ArchiveInterval: zo vaak wordt de hele kopie gecomprimeerd en
24
// opgeslagen. Standaard 24h (dagelijks).
25
ArchiveInterval Duration `yaml:"archive_interval"`
26
// RetentionDays: archieven ouder dan dit worden verwijderd. 0 = nooit
27
// op leeftijd. Het nieuwste archief blijft altijd staan.
28
RetentionDays int `yaml:"retention_days"`
29
// MinFreeMB: zakt de vrije ruimte op DataDir hieronder, dan gaat het
30
// oudste archief weg (het nieuwste blijft altijd staan).
31
MinFreeMB int64 `yaml:"min_free_mb"`
32
// RateLimitKiB begrenst het downloaden van BlueGit, in KiB/s.
33
// Standaard 1024. 0 = geen limiet.
34
RateLimitKiB int64 `yaml:"rate_limit_kib"`
35
// FullSyncInterval: ook zonder melding wordt zo vaak gesynchroniseerd.
36
FullSyncInterval Duration `yaml:"full_sync_interval"`
37
// MinSyncInterval: na een melding wacht de server minstens zo lang
38
// sinds de vorige sync, zodat een drukke BlueGit niet elke seconde een
39
// databasekopie hoeft te maken.
40
MinSyncInterval Duration `yaml:"min_sync_interval"`
41
}
42
43
// Duration leest "24h", "30m" enzovoort.
44
type Duration struct{ time.Duration }
45
46
// UnmarshalYAML leest een Go-duur of een aantal seconden.
47
func (d *Duration) UnmarshalYAML(n *yaml.Node) error {
48
s := strings.TrimSpace(n.Value)
49
if s == "" {
50
return nil
51
}
52
if strings.HasSuffix(s, "d") {
53
var days int
54
if _, err := fmt.Sscanf(s, "%dd", &days); err == nil {
55
d.Duration = time.Duration(days) * 24 * time.Hour
56
return nil
57
}
58
}
59
v, err := time.ParseDuration(s)
60
if err != nil {
61
return fmt.Errorf("ongeldige duur %q", s)
62
}
63
d.Duration = v
64
return nil
65
}
66
67
// MarshalYAML schrijft de duur terug als tekst.
68
func (d Duration) MarshalYAML() (any, error) { return d.String(), nil }
69
70
// Defaults vult lege velden.
71
func (c *Config) Defaults() {
72
if c.Listen == "" {
73
c.Listen = "0.0.0.0:8790"
74
}
75
if c.DataDir == "" {
76
c.DataDir = "/var/lib/bluegit-backup"
77
}
78
if c.ArchiveInterval.Duration == 0 {
79
c.ArchiveInterval.Duration = 24 * time.Hour
80
}
81
if c.RetentionDays == 0 {
82
c.RetentionDays = 30
83
}
84
if c.RetentionDays < 0 {
85
c.RetentionDays = 0
86
}
87
if c.MinFreeMB == 0 {
88
c.MinFreeMB = 1024
89
}
90
if c.RateLimitKiB == 0 {
91
c.RateLimitKiB = 1024
92
}
93
if c.RateLimitKiB < 0 {
94
c.RateLimitKiB = 0
95
}
96
if c.FullSyncInterval.Duration == 0 {
97
c.FullSyncInterval.Duration = time.Hour
98
}
99
if c.MinSyncInterval.Duration == 0 {
100
c.MinSyncInterval.Duration = 10 * time.Second
101
}
102
}
103
104
// Validate controleert de combinatie.
105
func (c Config) Validate() error {
106
if c.ArchiveInterval.Duration < time.Second {
107
return fmt.Errorf("archive_interval moet minstens 1s zijn")
108
}
109
if c.PublicURL != "" && !strings.HasPrefix(c.PublicURL, "http://") && !strings.HasPrefix(c.PublicURL, "https://") {
110
return fmt.Errorf("public_url moet met http:// of https:// beginnen")
111
}
112
return nil
113
}
114
115
// Load leest path. Een ontbrekend bestand geeft de standaardwaarden.
116
func Load(path string) (Config, error) {
117
var c Config
118
b, err := os.ReadFile(path)
119
if err != nil && !os.IsNotExist(err) {
120
return c, err
121
}
122
if err == nil {
123
if err := yaml.Unmarshal(b, &c); err != nil {
124
return c, fmt.Errorf("%s: %w", path, err)
125
}
126
}
127
c.Defaults()
128
return c, c.Validate()
129
}
130
131
// Example is een voorbeeldconfiguratie.
132
func Example() string {
133
return `# bluegit-backup. Kopieer naar /etc/bluegit-backup/config.yml.
134
listen: 0.0.0.0:8790
135
# Waar BlueGit deze server bereikt (meldingen, archieflijst, rollback).
136
public_url: http://backup.lan:8790
137
data_dir: /var/lib/bluegit-backup
138
# Zo vaak wordt de hele kopie gecomprimeerd opgeslagen. Standaard dagelijks.
139
archive_interval: 24h
140
# Archieven ouder dan dit gaan weg (0 = nooit op leeftijd). Het nieuwste blijft.
141
retention_days: 30
142
# Minder vrije ruimte dan dit: het oudste archief gaat weg.
143
min_free_mb: 1024
144
# Downloadsnelheid van BlueGit in KiB/s, zodat BlueGit er geen last van heeft.
145
rate_limit_kib: 1024
146
# Ook zonder melding zo vaak alles nalopen.
147
full_sync_interval: 1h
148
# Minimale tijd tussen twee syncs na meldingen.
149
min_sync_interval: 10s
150
`
151
}
@@ -0,0 +1,151 @@1
// Package config leest de configuratie van de backup server.2
package config3
4
import (5
"fmt"6
"os"7
"strings"8
"time"9
10
"gopkg.in/yaml.v3"11
)12
13
// Config is /etc/bluegit-backup/config.yml.14
type Config struct {15
// Listen is waar de backup server luistert (plain HTTP; TLS doet een16
// proxy ervoor als dat nodig is).17
Listen string `yaml:"listen"`18
// PublicURL is het adres waarop BlueGit deze server bereikt, voor19
// meldingen, de archieflijst en rollback.20
PublicURL string `yaml:"public_url"`21
// DataDir bevat de draaiende kopie, de archieven en de koppeling.22
DataDir string `yaml:"data_dir"`23
// ArchiveInterval: zo vaak wordt de hele kopie gecomprimeerd en24
// opgeslagen. Standaard 24h (dagelijks).25
ArchiveInterval Duration `yaml:"archive_interval"`26
// RetentionDays: archieven ouder dan dit worden verwijderd. 0 = nooit27
// op leeftijd. Het nieuwste archief blijft altijd staan.28
RetentionDays int `yaml:"retention_days"`29
// MinFreeMB: zakt de vrije ruimte op DataDir hieronder, dan gaat het30
// oudste archief weg (het nieuwste blijft altijd staan).31
MinFreeMB int64 `yaml:"min_free_mb"`32
// RateLimitKiB begrenst het downloaden van BlueGit, in KiB/s.33
// Standaard 1024. 0 = geen limiet.34
RateLimitKiB int64 `yaml:"rate_limit_kib"`35
// FullSyncInterval: ook zonder melding wordt zo vaak gesynchroniseerd.36
FullSyncInterval Duration `yaml:"full_sync_interval"`37
// MinSyncInterval: na een melding wacht de server minstens zo lang38
// sinds de vorige sync, zodat een drukke BlueGit niet elke seconde een39
// databasekopie hoeft te maken.40
MinSyncInterval Duration `yaml:"min_sync_interval"`41
}42
43
// Duration leest "24h", "30m" enzovoort.44
type Duration struct{ time.Duration }45
46
// UnmarshalYAML leest een Go-duur of een aantal seconden.47
func (d *Duration) UnmarshalYAML(n *yaml.Node) error {48
s := strings.TrimSpace(n.Value)49
if s == "" {50
return nil51
}52
if strings.HasSuffix(s, "d") {53
var days int54
if _, err := fmt.Sscanf(s, "%dd", &days); err == nil {55
d.Duration = time.Duration(days) * 24 * time.Hour56
return nil57
}58
}59
v, err := time.ParseDuration(s)60
if err != nil {61
return fmt.Errorf("ongeldige duur %q", s)62
}63
d.Duration = v64
return nil65
}66
67
// MarshalYAML schrijft de duur terug als tekst.68
func (d Duration) MarshalYAML() (any, error) { return d.String(), nil }69
70
// Defaults vult lege velden.71
func (c *Config) Defaults() {72
if c.Listen == "" {73
c.Listen = "0.0.0.0:8790"74
}75
if c.DataDir == "" {76
c.DataDir = "/var/lib/bluegit-backup"77
}78
if c.ArchiveInterval.Duration == 0 {79
c.ArchiveInterval.Duration = 24 * time.Hour80
}81
if c.RetentionDays == 0 {82
c.RetentionDays = 3083
}84
if c.RetentionDays < 0 {85
c.RetentionDays = 086
}87
if c.MinFreeMB == 0 {88
c.MinFreeMB = 102489
}90
if c.RateLimitKiB == 0 {91
c.RateLimitKiB = 102492
}93
if c.RateLimitKiB < 0 {94
c.RateLimitKiB = 095
}96
if c.FullSyncInterval.Duration == 0 {97
c.FullSyncInterval.Duration = time.Hour98
}99
if c.MinSyncInterval.Duration == 0 {100
c.MinSyncInterval.Duration = 10 * time.Second101
}102
}103
104
// Validate controleert de combinatie.105
func (c Config) Validate() error {106
if c.ArchiveInterval.Duration < time.Second {107
return fmt.Errorf("archive_interval moet minstens 1s zijn")108
}109
if c.PublicURL != "" && !strings.HasPrefix(c.PublicURL, "http://") && !strings.HasPrefix(c.PublicURL, "https://") {110
return fmt.Errorf("public_url moet met http:// of https:// beginnen")111
}112
return nil113
}114
115
// Load leest path. Een ontbrekend bestand geeft de standaardwaarden.116
func Load(path string) (Config, error) {117
var c Config118
b, err := os.ReadFile(path)119
if err != nil && !os.IsNotExist(err) {120
return c, err121
}122
if err == nil {123
if err := yaml.Unmarshal(b, &c); err != nil {124
return c, fmt.Errorf("%s: %w", path, err)125
}126
}127
c.Defaults()128
return c, c.Validate()129
}130
131
// Example is een voorbeeldconfiguratie.132
func Example() string {133
return `# bluegit-backup. Kopieer naar /etc/bluegit-backup/config.yml.134
listen: 0.0.0.0:8790135
# Waar BlueGit deze server bereikt (meldingen, archieflijst, rollback).136
public_url: http://backup.lan:8790137
data_dir: /var/lib/bluegit-backup138
# Zo vaak wordt de hele kopie gecomprimeerd opgeslagen. Standaard dagelijks.139
archive_interval: 24h140
# Archieven ouder dan dit gaan weg (0 = nooit op leeftijd). Het nieuwste blijft.141
retention_days: 30142
# Minder vrije ruimte dan dit: het oudste archief gaat weg.143
min_free_mb: 1024144
# Downloadsnelheid van BlueGit in KiB/s, zodat BlueGit er geen last van heeft.145
rate_limit_kib: 1024146
# Ook zonder melding zo vaak alles nalopen.147
full_sync_interval: 1h148
# Minimale tijd tussen twee syncs na meldingen.149
min_sync_interval: 10s150
`151
}@@ -0,0 +1,44 @@
1
package config
2
3
import (
4
"os"
5
"path/filepath"
6
"testing"
7
"time"
8
)
9
10
func TestDefaults(t *testing.T) {
11
c, err := Load(filepath.Join(t.TempDir(), "geen.yml"))
12
if err != nil {
13
t.Fatal(err)
14
}
15
if c.ArchiveInterval.Duration != 24*time.Hour || c.RetentionDays != 30 || c.RateLimitKiB != 1024 || c.Listen != "0.0.0.0:8790" {
16
t.Fatalf("%+v", c)
17
}
18
}
19
20
func TestLoad(t *testing.T) {
21
p := filepath.Join(t.TempDir(), "c.yml")
22
_ = os.WriteFile(p, []byte("archive_interval: 7d\nretention_days: -1\nrate_limit_kib: -1\npublic_url: http://b:1\n"), 0o600)
23
c, err := Load(p)
24
if err != nil {
25
t.Fatal(err)
26
}
27
if c.ArchiveInterval.Duration != 7*24*time.Hour || c.RetentionDays != 0 || c.RateLimitKiB != 0 {
28
t.Fatalf("%+v", c)
29
}
30
_ = os.WriteFile(p, []byte("public_url: ftp://x\n"), 0o600)
31
if _, err := Load(p); err == nil {
32
t.Fatal("ftp geaccepteerd")
33
}
34
_ = os.WriteFile(p, []byte("archive_interval: soms\n"), 0o600)
35
if _, err := Load(p); err == nil {
36
t.Fatal("ongeldige duur geaccepteerd")
37
}
38
if _, err := os.Stat(p); err != nil {
39
t.Fatal(err)
40
}
41
if Example() == "" {
42
t.Fatal("geen voorbeeld")
43
}
44
}
@@ -0,0 +1,44 @@1
package config2
3
import (4
"os"5
"path/filepath"6
"testing"7
"time"8
)9
10
func TestDefaults(t *testing.T) {11
c, err := Load(filepath.Join(t.TempDir(), "geen.yml"))12
if err != nil {13
t.Fatal(err)14
}15
if c.ArchiveInterval.Duration != 24*time.Hour || c.RetentionDays != 30 || c.RateLimitKiB != 1024 || c.Listen != "0.0.0.0:8790" {16
t.Fatalf("%+v", c)17
}18
}19
20
func TestLoad(t *testing.T) {21
p := filepath.Join(t.TempDir(), "c.yml")22
_ = os.WriteFile(p, []byte("archive_interval: 7d\nretention_days: -1\nrate_limit_kib: -1\npublic_url: http://b:1\n"), 0o600)23
c, err := Load(p)24
if err != nil {25
t.Fatal(err)26
}27
if c.ArchiveInterval.Duration != 7*24*time.Hour || c.RetentionDays != 0 || c.RateLimitKiB != 0 {28
t.Fatalf("%+v", c)29
}30
_ = os.WriteFile(p, []byte("public_url: ftp://x\n"), 0o600)31
if _, err := Load(p); err == nil {32
t.Fatal("ftp geaccepteerd")33
}34
_ = os.WriteFile(p, []byte("archive_interval: soms\n"), 0o600)35
if _, err := Load(p); err == nil {36
t.Fatal("ongeldige duur geaccepteerd")37
}38
if _, err := os.Stat(p); err != nil {39
t.Fatal(err)40
}41
if Example() == "" {42
t.Fatal("geen voorbeeld")43
}44
}@@ -0,0 +1,498 @@
1
//go:build integration
2
3
package integration
4
5
import (
6
"crypto/rand"
7
"encoding/json"
8
"io"
9
"net/http"
10
"net/url"
11
"os"
12
"os/exec"
13
"path/filepath"
14
"strings"
15
"testing"
16
"time"
17
18
"git.timfalken.com/timfa/bluegit-backup/internal/config"
19
"git.timfalken.com/timfa/bluegit-backup/internal/server"
20
)
21
22
// Feature: Backupserver-Key in BlueGit genereren en de backup server koppelen.
23
func TestKeyGenerationAndConnect(t *testing.T) {
24
g := startBlueGit(t)
25
b := startBackup(t, nil)
26
27
// Zonder key niets; een verkeerde key wordt geweigerd.
28
if st := g.BackupStatus(); st.HasKey || st.Connected {
29
t.Fatalf("vers BlueGit heeft al een key: %+v", st)
30
}
31
code, raw := b.Admin("POST", "/connect", server.ConnectRequest{URL: g.URL, Key: "bgbk_verkeerd"})
32
if code != 401 {
33
t.Fatalf("verkeerde key: %d %s", code, raw)
34
}
35
key := g.NewKey()
36
b.Connect(g, key)
37
38
st := g.BackupStatus()
39
if !st.HasKey || !st.Connected || st.ServerURL != b.URL || st.RemoteError != "" {
40
t.Fatalf("BlueGit ziet de koppeling niet: %+v", st)
41
}
42
bs := b.Status()
43
if !bs.Connected || bs.InstanceID != st.InstanceID || bs.BlueGitURL != g.URL {
44
t.Fatalf("backup status: %+v", bs)
45
}
46
// De key staat niet leesbaar in BlueGit.
47
raw2, _ := os.ReadFile(filepath.Join(g.State, "backup.json"))
48
if strings.Contains(string(raw2), key) {
49
t.Fatal("BlueGit bewaart de key leesbaar")
50
}
51
// Een nieuwe key maakt de oude ongeldig: de backup server kan niet meer syncen.
52
g.NewKey()
53
code, raw = b.Admin("POST", "/sync", nil)
54
if code == 200 {
55
t.Fatalf("sync met ingetrokken key gelukt: %s", raw)
56
}
57
}
58
59
// Feature: alle gegevens en configuratie ophalen.
60
func TestFullSyncCopiesAllData(t *testing.T) {
61
g := startBlueGit(t)
62
g.Project("Alpha", "README.md", "hallo alpha")
63
g.Issue("alpha", "eerste issue")
64
b := startBackup(t, nil)
65
b.Connect(g, g.NewKey())
66
b.Sync()
67
68
for _, p := range []string{"state/bluegit.db", "state/secret.key", "data/repos/tim/alpha.git/HEAD"} {
69
if _, err := os.Stat(b.Mirror(p)); err != nil {
70
t.Fatalf("kopie mist %s: %v", p, err)
71
}
72
}
73
if log := gitLog(t, b.Mirror("data/repos/tim/alpha.git")); !strings.Contains(log, "zet README.md") {
74
t.Fatalf("kopie van de repo is niet bruikbaar: %s", log)
75
}
76
db, _ := os.ReadFile(b.Mirror("state/bluegit.db"))
77
if !strings.HasPrefix(string(db), "SQLite format 3") || !strings.Contains(string(db), "eerste issue") {
78
t.Fatal("databasekopie mist het issue")
79
}
80
key1, _ := os.ReadFile(filepath.Join(g.State, "secret.key"))
81
key2, _ := os.ReadFile(b.Mirror("state/secret.key"))
82
if string(key1) != string(key2) {
83
t.Fatal("secret.key wijkt af")
84
}
85
// Installatiegebonden bestanden gaan niet mee.
86
for _, p := range []string{"state/backup.json", "state/instance_id", "state/storage_path"} {
87
if _, err := os.Stat(b.Mirror(p)); err == nil {
88
t.Fatalf("%s hoort niet in de kopie", p)
89
}
90
}
91
// Een tweede sync zonder wijzigingen haalt (bijna) niets op.
92
code, raw := b.Admin("POST", "/sync", nil)
93
var st struct{ Downloaded int }
94
_ = json.Unmarshal(raw, &st)
95
if code != 200 || st.Downloaded > 1 {
96
t.Fatalf("tweede sync haalde %d bestanden op: %s", st.Downloaded, raw)
97
}
98
}
99
100
// Feature: BlueGit meldt elke wijziging; de backup server haalt hem op.
101
func TestNotificationTriggersSync(t *testing.T) {
102
g := startBlueGit(t)
103
g.Project("Alpha", "README.md", "v1")
104
b := startBackup(t, nil) // full sync pas na een uur: alleen meldingen tellen
105
b.Connect(g, g.NewKey())
106
Eventually(t, 15*time.Second, "eerste sync na koppelen", func() bool {
107
return strings.Contains(gitLog(t, b.Mirror("data/repos/tim/alpha.git")), "zet README.md")
108
})
109
before := b.Status().Notifies
110
111
// Wijziging via de API.
112
g.Commit("alpha", "CHANGELOG.md", "nieuw", "create")
113
Eventually(t, 15*time.Second, "commit via API in de kopie", func() bool {
114
return strings.Contains(gitLog(t, b.Mirror("data/repos/tim/alpha.git")), "zet CHANGELOG.md")
115
})
116
// Wijziging via git push over HTTP.
117
work := t.TempDir()
118
g.Git(work, "clone", "-q", g.RemoteURL("alpha"), "w")
119
repo := filepath.Join(work, "w")
120
_ = os.WriteFile(filepath.Join(repo, "pushed.txt"), []byte("via git"), 0o644)
121
g.Git(repo, "add", ".")
122
g.Git(repo, "commit", "-qm", "gepusht met git")
123
g.Git(repo, "push", "-q", "origin", "master")
124
Eventually(t, 15*time.Second, "git push in de kopie", func() bool {
125
return strings.Contains(gitLog(t, b.Mirror("data/repos/tim/alpha.git")), "gepusht met git")
126
})
127
// Een issue staat alleen in de database.
128
g.Issue("alpha", "issue-na-melding")
129
Eventually(t, 15*time.Second, "issue in de databasekopie", func() bool {
130
db, _ := os.ReadFile(b.Mirror("state/bluegit.db"))
131
return strings.Contains(string(db), "issue-na-melding")
132
})
133
if b.Status().Notifies <= before {
134
t.Fatal("geen meldingen geteld")
135
}
136
}
137
138
// Feature: downloaden op lage snelheid.
139
func TestDownloadIsThrottled(t *testing.T) {
140
g := startBlueGit(t)
141
g.MustAPI("POST", "/projects", map[string]any{"name": "Big", "visibility": "private"})
142
work := t.TempDir()
143
g.Git(work, "init", "-q", "-b", "master", "w")
144
repo := filepath.Join(work, "w")
145
blob := make([]byte, 1536<<10) // 1,5 MiB, niet te comprimeren
146
_, _ = rand.Read(blob)
147
_ = os.WriteFile(filepath.Join(repo, "random.bin"), blob, 0o644)
148
g.Git(repo, "add", ".")
149
g.Git(repo, "commit", "-qm", "groot bestand")
150
g.Git(repo, "push", "-q", g.RemoteURL("big"), "master")
151
152
b := startBackup(t, func(c *config.Config) { c.RateLimitKiB = 512 })
153
start := time.Now()
154
b.Connect(g, g.NewKey())
155
b.Sync()
156
took := time.Since(start)
157
// 1,5 MiB tegen 512 KiB/s is minstens ~2,7 s (min de eerste burst).
158
if took < 2500*time.Millisecond {
159
t.Fatalf("sync duurde %v; de limiet van 512 KiB/s werkt niet", took)
160
}
161
if b.Status().RateLimitKiB != 512 {
162
t.Fatal("limiet niet in de status")
163
}
164
if !strings.Contains(gitLog(t, b.Mirror("data/repos/tim/big.git")), "groot bestand") {
165
t.Fatal("groot bestand niet gekopieerd")
166
}
167
}
168
169
// Feature: op een interval archiveren; archieflijst in BlueGit.
170
func TestArchiveIntervalAndListInBlueGit(t *testing.T) {
171
g := startBlueGit(t)
172
g.Project("Alpha", "README.md", "v1")
173
b := startBackup(t, func(c *config.Config) { c.ArchiveInterval.Duration = 2 * time.Second })
174
if b.Status().Interval != "2s" {
175
t.Fatalf("interval: %s", b.Status().Interval)
176
}
177
b.Connect(g, g.NewKey())
178
Eventually(t, 20*time.Second, "twee archieven door het interval", func() bool { return len(b.Archives()) >= 2 })
179
180
names := b.Archives()
181
st := g.BackupStatus()
182
if len(st.Archives) < 2 || st.Archives[0].Name != names[0] || st.Archives[0].Size == 0 {
183
t.Fatalf("BlueGit toont de archieven niet: %+v vs %v", st.Archives, names)
184
}
185
// De beheerpagina toont de lijst met de grote waarschuwing.
186
res, err := g.Session().Get(g.URL + "/admin/backup")
187
if err != nil {
188
t.Fatal(err)
189
}
190
page, _ := io.ReadAll(res.Body)
191
res.Body.Close()
192
for _, want := range []string{names[0], `class="backup-danger"`, `name="understood"`, `name="confirm"`} {
193
if !strings.Contains(string(page), want) {
194
t.Fatalf("beheerpagina mist %q", want)
195
}
196
}
197
// Het archief is een geldige tar.gz met de logische paden.
198
out, err := exec.Command("tar", "-tzf", filepath.Join(b.Dir, "archives", names[0])).CombinedOutput()
199
if err != nil || !strings.Contains(string(out), "state/bluegit.db") || !strings.Contains(string(out), "data/repos/tim/alpha.git/HEAD") {
200
t.Fatalf("archief: %v %s", err, out)
201
}
202
}
203
204
// Feature: archieven ouder dan x dagen, of de oudste bij een volle schijf, verdwijnen.
205
func TestRetentionAndDiskFull(t *testing.T) {
206
g := startBlueGit(t)
207
g.Project("Alpha", "README.md", "v1")
208
b := startBackup(t, func(c *config.Config) { c.RetentionDays = 7 })
209
b.Connect(g, g.NewKey())
210
b.Sync()
211
var names []string
212
for i := 0; i < 4; i++ {
213
names = append(names, b.Archive())
214
time.Sleep(1100 * time.Millisecond) // namen hebben secondes
215
}
216
// De twee oudste zijn 10 en 8 dagen oud, de derde 6.
217
ages := []int{10, 8, 6}
218
for i, d := range ages {
219
old := time.Now().Add(-time.Duration(d) * 24 * time.Hour)
220
_ = os.Chtimes(filepath.Join(b.Dir, "archives", names[i]), old, old)
221
}
222
code, raw := b.Admin("POST", "/prune", nil)
223
if code != 200 || !strings.Contains(string(raw), names[0]) || !strings.Contains(string(raw), names[1]) || strings.Contains(string(raw), names[2]) {
224
t.Fatalf("prune op leeftijd: %d %s", code, raw)
225
}
226
if got := b.Archives(); len(got) != 2 {
227
t.Fatalf("na leeftijd: %v", got)
228
}
229
// Schijf vol: de oudste gaat weg, het nieuwste blijft altijd.
230
b.Srv.SetFree(func(string) (uint64, error) { return 0, nil })
231
code, raw = b.Admin("POST", "/prune", nil)
232
if code != 200 || !strings.Contains(string(raw), names[2]) {
233
t.Fatalf("prune schijf vol: %d %s", code, raw)
234
}
235
if got := b.Archives(); len(got) != 1 || got[0] != names[3] {
236
t.Fatalf("na schijf vol: %v, wil alleen %s", got, names[3])
237
}
238
// Ook een nieuw archief maakt eerst ruimte: het oude gaat weg, het nieuwe komt.
239
b.Srv.SetFree(func(string) (uint64, error) {
240
if len(b.Archives()) > 0 {
241
return 0, nil
242
}
243
return 10 << 30, nil
244
})
245
time.Sleep(1100 * time.Millisecond)
246
newest := b.Archive()
247
if got := b.Archives(); len(got) != 1 || got[0] != newest {
248
t.Fatalf("na archief bij volle schijf: %v", got)
249
}
250
}
251
252
// Feature: rollback vanuit BlueGit, met bevestiging; kopie en BlueGit gaan terug.
253
func TestRollbackFromBlueGit(t *testing.T) {
254
g := startBlueGit(t)
255
g.Project("Alpha", "README.md", "versie 1")
256
g.Issue("alpha", "voor het archief")
257
b := startBackup(t, nil)
258
b.Connect(g, g.NewKey())
259
b.Sync()
260
archiveName := b.Archive()
261
262
// Na het archief: alles verandert.
263
g.Commit("alpha", "README.md", "versie 2", "update")
264
g.Issue("alpha", "na het archief")
265
g.Project("Beta", "b.txt", "nieuw project")
266
b.Sync()
267
if _, s := g.File("alpha", "README.md"); s != "versie 2" {
268
t.Fatalf("voorbereiding: %q", s)
269
}
270
271
// Zonder juiste bevestiging gebeurt er niets.
272
code, raw := g.API("POST", "/admin/backup/rollback", map[string]any{"archive": archiveName, "confirm": "ja"})
273
if code != 400 {
274
t.Fatalf("rollback zonder bevestiging: %d %s", code, raw)
275
}
276
// Via het formulier zonder vinkje ook niet.
277
if code := postRollbackForm(t, g, archiveName, false); code/100 != 3 {
278
t.Fatalf("formulier zonder vinkje: %d", code)
279
}
280
time.Sleep(300 * time.Millisecond)
281
if b.Status().Rollback.State != "idle" {
282
t.Fatalf("rollback gestart zonder bevestiging: %+v", b.Status().Rollback)
283
}
284
285
// Echte rollback via de UI.
286
if code := postRollbackForm(t, g, archiveName, true); code/100 != 3 {
287
t.Fatalf("formulier: %d", code)
288
}
289
Eventually(t, 60*time.Second, "rollback klaar", func() bool {
290
st := b.Status().Rollback
291
if st.State == "failed" {
292
t.Fatalf("rollback mislukt: %s", st.Error)
293
}
294
return st.State == "done"
295
})
296
g.WaitUp(30 * time.Second)
297
298
if code, s := g.File("alpha", "README.md"); code != 200 || s != "versie 1" {
299
t.Fatalf("README na rollback: %d %q", code, s)
300
}
301
if code := g.ProjectCode("beta"); code != 404 {
302
t.Fatalf("project beta bestaat na rollback nog: %d", code)
303
}
304
titles := strings.Join(g.IssueTitles("alpha"), "|")
305
if !strings.Contains(titles, "voor het archief") || strings.Contains(titles, "na het archief") {
306
t.Fatalf("issues na rollback: %s", titles)
307
}
308
// De koppeling overleeft de rollback: BlueGit ziet de server nog, en
309
// de kopie loopt weer gelijk met BlueGit.
310
if st := g.BackupStatus(); !st.Connected || st.RemoteError != "" {
311
t.Fatalf("koppeling na rollback: %+v", st)
312
}
313
b.Sync()
314
if log := gitLog(t, b.Mirror("data/repos/tim/alpha.git")); strings.Count(log, "zet README.md") != 1 {
315
t.Fatalf("kopie na rollback: %s", log)
316
}
317
if _, err := os.Stat(b.Mirror("data/repos/tim/beta.git/HEAD")); err == nil {
318
t.Fatal("beta staat nog in de kopie")
319
}
320
// Na de rollback werkt BlueGit gewoon verder en blijft melden.
321
g.Commit("alpha", "after.txt", "na rollback", "create")
322
Eventually(t, 15*time.Second, "melding na rollback", func() bool {
323
return strings.Contains(gitLog(t, b.Mirror("data/repos/tim/alpha.git")), "zet after.txt")
324
})
325
}
326
327
func postRollbackForm(t *testing.T, g *BlueGit, archiveName string, understood bool) int {
328
t.Helper()
329
hc := g.Session()
330
hc.CheckRedirect = func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }
331
res, err := hc.Get(g.URL + "/admin/backup")
332
if err != nil {
333
t.Fatal(err)
334
}
335
page, _ := io.ReadAll(res.Body)
336
res.Body.Close()
337
csrf := between(string(page), `name="csrf" value="`, `"`)
338
if csrf == "" {
339
t.Fatal("geen csrf op de beheerpagina")
340
}
341
form := url.Values{"csrf": {csrf}, "archive": {archiveName}, "confirm": {archiveName}}
342
if understood {
343
form.Set("understood", "1")
344
}
345
res, err = hc.PostForm(g.URL+"/admin/backup/rollback", form)
346
if err != nil {
347
t.Fatal(err)
348
}
349
res.Body.Close()
350
return res.StatusCode
351
}
352
353
func between(s, a, b string) string {
354
i := strings.Index(s, a)
355
if i < 0 {
356
return ""
357
}
358
s = s[i+len(a):]
359
j := strings.Index(s, b)
360
if j < 0 {
361
return ""
362
}
363
return s[:j]
364
}
365
366
// Feature: één BlueGit per backup server; keuze "oude backups verwijderen".
367
func TestNewInstanceWipe(t *testing.T) {
368
a := startBlueGit(t)
369
a.Project("Alpha", "a.txt", "van A")
370
b := startBackup(t, nil)
371
b.Connect(a, a.NewKey())
372
b.Sync()
373
b.Archive()
374
375
other := startBlueGit(t)
376
other.Project("Gamma", "g.txt", "van B")
377
keyB := other.NewKey()
378
code, raw := b.Admin("POST", "/connect", server.ConnectRequest{URL: other.URL, Key: keyB})
379
if code != 409 {
380
t.Fatalf("tweede BlueGit zonder keuze: %d %s", code, raw)
381
}
382
var cf server.ConflictError
383
_ = json.Unmarshal(raw, &cf)
384
if !cf.Conflict || cf.PreviousURL != a.URL || cf.Archives != 1 || strings.Join(cf.Choices, ",") != "wipe,restore" {
385
t.Fatalf("conflict: %+v", cf)
386
}
387
// Er is nog niets veranderd.
388
if b.Status().BlueGitURL != a.URL || len(b.Archives()) != 1 {
389
t.Fatal("conflict veranderde de koppeling")
390
}
391
code, raw = b.Admin("POST", "/connect", server.ConnectRequest{URL: other.URL, Key: keyB, OnConflict: "wipe"})
392
if code != 200 {
393
t.Fatalf("wipe: %d %s", code, raw)
394
}
395
if len(b.Archives()) != 0 {
396
t.Fatal("oude archieven staan er nog")
397
}
398
b.Sync()
399
if _, err := os.Stat(b.Mirror("data/repos/tim/alpha.git/HEAD")); err == nil {
400
t.Fatal("A staat nog in de kopie")
401
}
402
if !strings.Contains(gitLog(t, b.Mirror("data/repos/tim/gamma.git")), "zet g.txt") {
403
t.Fatal("B staat niet in de kopie")
404
}
405
if st := other.BackupStatus(); !st.Connected || st.ServerURL != b.URL {
406
t.Fatalf("B ziet de koppeling niet: %+v", st)
407
}
408
// A is los: zijn meldingen worden geweigerd (andere instantie).
409
if b.Status().InstanceID == a.BackupStatus().InstanceID {
410
t.Fatal("backup server hoort nog bij A")
411
}
412
}
413
414
// Feature: keuze "nieuwe instantie terugzetten naar de gegevens in de backup server".
415
func TestNewInstanceRestore(t *testing.T) {
416
a := startBlueGit(t)
417
a.Project("Alpha", "a.txt", "van A")
418
a.Issue("alpha", "issue van A")
419
b := startBackup(t, nil)
420
b.Connect(a, a.NewKey())
421
b.Sync()
422
423
fresh := startBlueGit(t)
424
fresh.Project("Gamma", "g.txt", "van B")
425
keyB := fresh.NewKey()
426
freshID := fresh.BackupStatus().InstanceID
427
code, raw := b.Admin("POST", "/connect", server.ConnectRequest{URL: fresh.URL, Key: keyB, OnConflict: "restore"})
428
if code != 200 || !strings.Contains(string(raw), `"restored":true`) {
429
t.Fatalf("restore: %d %s", code, raw)
430
}
431
fresh.WaitUp(30 * time.Second)
432
// De nieuwe BlueGit heeft nu de database van A, dus ook A's token.
433
fresh.Token = a.Token
434
if code, s := fresh.File("alpha", "a.txt"); code != 200 || s != "van A" {
435
t.Fatalf("A's project op de nieuwe BlueGit: %d %q", code, s)
436
}
437
if code := fresh.ProjectCode("gamma"); code != 404 {
438
t.Fatalf("B's eigen project bestaat nog: %d", code)
439
}
440
if titles := strings.Join(fresh.IssueTitles("alpha"), "|"); !strings.Contains(titles, "issue van A") {
441
t.Fatalf("issues: %s", titles)
442
}
443
// De koppeling hoort bij de installatie, niet bij de gegevens.
444
st := fresh.BackupStatus()
445
if !st.Connected || st.InstanceID != freshID || st.ServerURL != b.URL {
446
t.Fatalf("koppeling na restore: %+v", st)
447
}
448
if b.Status().InstanceID != freshID {
449
t.Fatal("backup server hoort niet bij de nieuwe instantie")
450
}
451
b.Sync()
452
if !strings.Contains(gitLog(t, b.Mirror("data/repos/tim/alpha.git")), "zet a.txt") {
453
t.Fatal("kopie na restore")
454
}
455
}
456
457
// Feature: de CLI vraagt de keuze bij een nieuwe verbinding.
458
func TestCLIConnectAsksOnConflict(t *testing.T) {
459
cli := filepath.Join(t.TempDir(), "bluegit-backup")
460
if out, err := exec.Command("go", "build", "-o", cli, "../cmd/bluegit-backup").CombinedOutput(); err != nil {
461
t.Fatalf("build: %v %s", err, out)
462
}
463
a := startBlueGit(t)
464
a.Project("Alpha", "a.txt", "A")
465
b := startBackup(t, nil)
466
cfgPath := filepath.Join(t.TempDir(), "config.yml")
467
_ = os.WriteFile(cfgPath, []byte("listen: "+b.Cfg.Listen+"\npublic_url: "+b.URL+"\ndata_dir: "+b.Dir+"\n"), 0o600)
468
run := func(stdin string, args ...string) (string, error) {
469
cmd := exec.Command(cli, append([]string{"connect", "--config", cfgPath}, args...)...)
470
cmd.Stdin = strings.NewReader(stdin)
471
out, err := cmd.CombinedOutput()
472
return string(out), err
473
}
474
keyA := a.NewKey()
475
cmd := exec.Command(cli, "connect", "--config", cfgPath, "--url", a.URL)
476
cmd.Env = append(os.Environ(), "BLUEGIT_BACKUP_KEY="+keyA)
477
if out, err := cmd.CombinedOutput(); err != nil {
478
t.Fatalf("eerste connect: %v %s", err, out)
479
}
480
b.Sync()
481
482
other := startBlueGit(t)
483
keyB := other.NewKey()
484
out, err := run("\n", "--url", other.URL, "--key", keyB)
485
if err == nil || !strings.Contains(out, "Oude backups verwijderen") || !strings.Contains(out, "terugzetten") || !strings.Contains(out, "afgebroken") {
486
t.Fatalf("afbreken: %v %s", err, out)
487
}
488
if b.Status().BlueGitURL != a.URL {
489
t.Fatal("afbreken veranderde de koppeling")
490
}
491
out, err = run("1\n", "--url", other.URL, "--key", keyB)
492
if err != nil || b.Status().BlueGitURL != other.URL {
493
t.Fatalf("keuze 1: %v %s", err, out)
494
}
495
if out, err := exec.Command(cli, "status", "--config", cfgPath).CombinedOutput(); err != nil || !strings.Contains(string(out), other.URL) {
496
t.Fatalf("status: %v %s", err, out)
497
}
498
}
@@ -0,0 +1,498 @@1
//go:build integration2
3
package integration4
5
import (6
"crypto/rand"7
"encoding/json"8
"io"9
"net/http"10
"net/url"11
"os"12
"os/exec"13
"path/filepath"14
"strings"15
"testing"16
"time"17
18
"git.timfalken.com/timfa/bluegit-backup/internal/config"19
"git.timfalken.com/timfa/bluegit-backup/internal/server"20
)21
22
// Feature: Backupserver-Key in BlueGit genereren en de backup server koppelen.23
func TestKeyGenerationAndConnect(t *testing.T) {24
g := startBlueGit(t)25
b := startBackup(t, nil)26
27
// Zonder key niets; een verkeerde key wordt geweigerd.28
if st := g.BackupStatus(); st.HasKey || st.Connected {29
t.Fatalf("vers BlueGit heeft al een key: %+v", st)30
}31
code, raw := b.Admin("POST", "/connect", server.ConnectRequest{URL: g.URL, Key: "bgbk_verkeerd"})32
if code != 401 {33
t.Fatalf("verkeerde key: %d %s", code, raw)34
}35
key := g.NewKey()36
b.Connect(g, key)37
38
st := g.BackupStatus()39
if !st.HasKey || !st.Connected || st.ServerURL != b.URL || st.RemoteError != "" {40
t.Fatalf("BlueGit ziet de koppeling niet: %+v", st)41
}42
bs := b.Status()43
if !bs.Connected || bs.InstanceID != st.InstanceID || bs.BlueGitURL != g.URL {44
t.Fatalf("backup status: %+v", bs)45
}46
// De key staat niet leesbaar in BlueGit.47
raw2, _ := os.ReadFile(filepath.Join(g.State, "backup.json"))48
if strings.Contains(string(raw2), key) {49
t.Fatal("BlueGit bewaart de key leesbaar")50
}51
// Een nieuwe key maakt de oude ongeldig: de backup server kan niet meer syncen.52
g.NewKey()53
code, raw = b.Admin("POST", "/sync", nil)54
if code == 200 {55
t.Fatalf("sync met ingetrokken key gelukt: %s", raw)56
}57
}58
59
// Feature: alle gegevens en configuratie ophalen.60
func TestFullSyncCopiesAllData(t *testing.T) {61
g := startBlueGit(t)62
g.Project("Alpha", "README.md", "hallo alpha")63
g.Issue("alpha", "eerste issue")64
b := startBackup(t, nil)65
b.Connect(g, g.NewKey())66
b.Sync()67
68
for _, p := range []string{"state/bluegit.db", "state/secret.key", "data/repos/tim/alpha.git/HEAD"} {69
if _, err := os.Stat(b.Mirror(p)); err != nil {70
t.Fatalf("kopie mist %s: %v", p, err)71
}72
}73
if log := gitLog(t, b.Mirror("data/repos/tim/alpha.git")); !strings.Contains(log, "zet README.md") {74
t.Fatalf("kopie van de repo is niet bruikbaar: %s", log)75
}76
db, _ := os.ReadFile(b.Mirror("state/bluegit.db"))77
if !strings.HasPrefix(string(db), "SQLite format 3") || !strings.Contains(string(db), "eerste issue") {78
t.Fatal("databasekopie mist het issue")79
}80
key1, _ := os.ReadFile(filepath.Join(g.State, "secret.key"))81
key2, _ := os.ReadFile(b.Mirror("state/secret.key"))82
if string(key1) != string(key2) {83
t.Fatal("secret.key wijkt af")84
}85
// Installatiegebonden bestanden gaan niet mee.86
for _, p := range []string{"state/backup.json", "state/instance_id", "state/storage_path"} {87
if _, err := os.Stat(b.Mirror(p)); err == nil {88
t.Fatalf("%s hoort niet in de kopie", p)89
}90
}91
// Een tweede sync zonder wijzigingen haalt (bijna) niets op.92
code, raw := b.Admin("POST", "/sync", nil)93
var st struct{ Downloaded int }94
_ = json.Unmarshal(raw, &st)95
if code != 200 || st.Downloaded > 1 {96
t.Fatalf("tweede sync haalde %d bestanden op: %s", st.Downloaded, raw)97
}98
}99
100
// Feature: BlueGit meldt elke wijziging; de backup server haalt hem op.101
func TestNotificationTriggersSync(t *testing.T) {102
g := startBlueGit(t)103
g.Project("Alpha", "README.md", "v1")104
b := startBackup(t, nil) // full sync pas na een uur: alleen meldingen tellen105
b.Connect(g, g.NewKey())106
Eventually(t, 15*time.Second, "eerste sync na koppelen", func() bool {107
return strings.Contains(gitLog(t, b.Mirror("data/repos/tim/alpha.git")), "zet README.md")108
})109
before := b.Status().Notifies110
111
// Wijziging via de API.112
g.Commit("alpha", "CHANGELOG.md", "nieuw", "create")113
Eventually(t, 15*time.Second, "commit via API in de kopie", func() bool {114
return strings.Contains(gitLog(t, b.Mirror("data/repos/tim/alpha.git")), "zet CHANGELOG.md")115
})116
// Wijziging via git push over HTTP.117
work := t.TempDir()118
g.Git(work, "clone", "-q", g.RemoteURL("alpha"), "w")119
repo := filepath.Join(work, "w")120
_ = os.WriteFile(filepath.Join(repo, "pushed.txt"), []byte("via git"), 0o644)121
g.Git(repo, "add", ".")122
g.Git(repo, "commit", "-qm", "gepusht met git")123
g.Git(repo, "push", "-q", "origin", "master")124
Eventually(t, 15*time.Second, "git push in de kopie", func() bool {125
return strings.Contains(gitLog(t, b.Mirror("data/repos/tim/alpha.git")), "gepusht met git")126
})127
// Een issue staat alleen in de database.128
g.Issue("alpha", "issue-na-melding")129
Eventually(t, 15*time.Second, "issue in de databasekopie", func() bool {130
db, _ := os.ReadFile(b.Mirror("state/bluegit.db"))131
return strings.Contains(string(db), "issue-na-melding")132
})133
if b.Status().Notifies <= before {134
t.Fatal("geen meldingen geteld")135
}136
}137
138
// Feature: downloaden op lage snelheid.139
func TestDownloadIsThrottled(t *testing.T) {140
g := startBlueGit(t)141
g.MustAPI("POST", "/projects", map[string]any{"name": "Big", "visibility": "private"})142
work := t.TempDir()143
g.Git(work, "init", "-q", "-b", "master", "w")144
repo := filepath.Join(work, "w")145
blob := make([]byte, 1536<<10) // 1,5 MiB, niet te comprimeren146
_, _ = rand.Read(blob)147
_ = os.WriteFile(filepath.Join(repo, "random.bin"), blob, 0o644)148
g.Git(repo, "add", ".")149
g.Git(repo, "commit", "-qm", "groot bestand")150
g.Git(repo, "push", "-q", g.RemoteURL("big"), "master")151
152
b := startBackup(t, func(c *config.Config) { c.RateLimitKiB = 512 })153
start := time.Now()154
b.Connect(g, g.NewKey())155
b.Sync()156
took := time.Since(start)157
// 1,5 MiB tegen 512 KiB/s is minstens ~2,7 s (min de eerste burst).158
if took < 2500*time.Millisecond {159
t.Fatalf("sync duurde %v; de limiet van 512 KiB/s werkt niet", took)160
}161
if b.Status().RateLimitKiB != 512 {162
t.Fatal("limiet niet in de status")163
}164
if !strings.Contains(gitLog(t, b.Mirror("data/repos/tim/big.git")), "groot bestand") {165
t.Fatal("groot bestand niet gekopieerd")166
}167
}168
169
// Feature: op een interval archiveren; archieflijst in BlueGit.170
func TestArchiveIntervalAndListInBlueGit(t *testing.T) {171
g := startBlueGit(t)172
g.Project("Alpha", "README.md", "v1")173
b := startBackup(t, func(c *config.Config) { c.ArchiveInterval.Duration = 2 * time.Second })174
if b.Status().Interval != "2s" {175
t.Fatalf("interval: %s", b.Status().Interval)176
}177
b.Connect(g, g.NewKey())178
Eventually(t, 20*time.Second, "twee archieven door het interval", func() bool { return len(b.Archives()) >= 2 })179
180
names := b.Archives()181
st := g.BackupStatus()182
if len(st.Archives) < 2 || st.Archives[0].Name != names[0] || st.Archives[0].Size == 0 {183
t.Fatalf("BlueGit toont de archieven niet: %+v vs %v", st.Archives, names)184
}185
// De beheerpagina toont de lijst met de grote waarschuwing.186
res, err := g.Session().Get(g.URL + "/admin/backup")187
if err != nil {188
t.Fatal(err)189
}190
page, _ := io.ReadAll(res.Body)191
res.Body.Close()192
for _, want := range []string{names[0], `class="backup-danger"`, `name="understood"`, `name="confirm"`} {193
if !strings.Contains(string(page), want) {194
t.Fatalf("beheerpagina mist %q", want)195
}196
}197
// Het archief is een geldige tar.gz met de logische paden.198
out, err := exec.Command("tar", "-tzf", filepath.Join(b.Dir, "archives", names[0])).CombinedOutput()199
if err != nil || !strings.Contains(string(out), "state/bluegit.db") || !strings.Contains(string(out), "data/repos/tim/alpha.git/HEAD") {200
t.Fatalf("archief: %v %s", err, out)201
}202
}203
204
// Feature: archieven ouder dan x dagen, of de oudste bij een volle schijf, verdwijnen.205
func TestRetentionAndDiskFull(t *testing.T) {206
g := startBlueGit(t)207
g.Project("Alpha", "README.md", "v1")208
b := startBackup(t, func(c *config.Config) { c.RetentionDays = 7 })209
b.Connect(g, g.NewKey())210
b.Sync()211
var names []string212
for i := 0; i < 4; i++ {213
names = append(names, b.Archive())214
time.Sleep(1100 * time.Millisecond) // namen hebben secondes215
}216
// De twee oudste zijn 10 en 8 dagen oud, de derde 6.217
ages := []int{10, 8, 6}218
for i, d := range ages {219
old := time.Now().Add(-time.Duration(d) * 24 * time.Hour)220
_ = os.Chtimes(filepath.Join(b.Dir, "archives", names[i]), old, old)221
}222
code, raw := b.Admin("POST", "/prune", nil)223
if code != 200 || !strings.Contains(string(raw), names[0]) || !strings.Contains(string(raw), names[1]) || strings.Contains(string(raw), names[2]) {224
t.Fatalf("prune op leeftijd: %d %s", code, raw)225
}226
if got := b.Archives(); len(got) != 2 {227
t.Fatalf("na leeftijd: %v", got)228
}229
// Schijf vol: de oudste gaat weg, het nieuwste blijft altijd.230
b.Srv.SetFree(func(string) (uint64, error) { return 0, nil })231
code, raw = b.Admin("POST", "/prune", nil)232
if code != 200 || !strings.Contains(string(raw), names[2]) {233
t.Fatalf("prune schijf vol: %d %s", code, raw)234
}235
if got := b.Archives(); len(got) != 1 || got[0] != names[3] {236
t.Fatalf("na schijf vol: %v, wil alleen %s", got, names[3])237
}238
// Ook een nieuw archief maakt eerst ruimte: het oude gaat weg, het nieuwe komt.239
b.Srv.SetFree(func(string) (uint64, error) {240
if len(b.Archives()) > 0 {241
return 0, nil242
}243
return 10 << 30, nil244
})245
time.Sleep(1100 * time.Millisecond)246
newest := b.Archive()247
if got := b.Archives(); len(got) != 1 || got[0] != newest {248
t.Fatalf("na archief bij volle schijf: %v", got)249
}250
}251
252
// Feature: rollback vanuit BlueGit, met bevestiging; kopie en BlueGit gaan terug.253
func TestRollbackFromBlueGit(t *testing.T) {254
g := startBlueGit(t)255
g.Project("Alpha", "README.md", "versie 1")256
g.Issue("alpha", "voor het archief")257
b := startBackup(t, nil)258
b.Connect(g, g.NewKey())259
b.Sync()260
archiveName := b.Archive()261
262
// Na het archief: alles verandert.263
g.Commit("alpha", "README.md", "versie 2", "update")264
g.Issue("alpha", "na het archief")265
g.Project("Beta", "b.txt", "nieuw project")266
b.Sync()267
if _, s := g.File("alpha", "README.md"); s != "versie 2" {268
t.Fatalf("voorbereiding: %q", s)269
}270
271
// Zonder juiste bevestiging gebeurt er niets.272
code, raw := g.API("POST", "/admin/backup/rollback", map[string]any{"archive": archiveName, "confirm": "ja"})273
if code != 400 {274
t.Fatalf("rollback zonder bevestiging: %d %s", code, raw)275
}276
// Via het formulier zonder vinkje ook niet.277
if code := postRollbackForm(t, g, archiveName, false); code/100 != 3 {278
t.Fatalf("formulier zonder vinkje: %d", code)279
}280
time.Sleep(300 * time.Millisecond)281
if b.Status().Rollback.State != "idle" {282
t.Fatalf("rollback gestart zonder bevestiging: %+v", b.Status().Rollback)283
}284
285
// Echte rollback via de UI.286
if code := postRollbackForm(t, g, archiveName, true); code/100 != 3 {287
t.Fatalf("formulier: %d", code)288
}289
Eventually(t, 60*time.Second, "rollback klaar", func() bool {290
st := b.Status().Rollback291
if st.State == "failed" {292
t.Fatalf("rollback mislukt: %s", st.Error)293
}294
return st.State == "done"295
})296
g.WaitUp(30 * time.Second)297
298
if code, s := g.File("alpha", "README.md"); code != 200 || s != "versie 1" {299
t.Fatalf("README na rollback: %d %q", code, s)300
}301
if code := g.ProjectCode("beta"); code != 404 {302
t.Fatalf("project beta bestaat na rollback nog: %d", code)303
}304
titles := strings.Join(g.IssueTitles("alpha"), "|")305
if !strings.Contains(titles, "voor het archief") || strings.Contains(titles, "na het archief") {306
t.Fatalf("issues na rollback: %s", titles)307
}308
// De koppeling overleeft de rollback: BlueGit ziet de server nog, en309
// de kopie loopt weer gelijk met BlueGit.310
if st := g.BackupStatus(); !st.Connected || st.RemoteError != "" {311
t.Fatalf("koppeling na rollback: %+v", st)312
}313
b.Sync()314
if log := gitLog(t, b.Mirror("data/repos/tim/alpha.git")); strings.Count(log, "zet README.md") != 1 {315
t.Fatalf("kopie na rollback: %s", log)316
}317
if _, err := os.Stat(b.Mirror("data/repos/tim/beta.git/HEAD")); err == nil {318
t.Fatal("beta staat nog in de kopie")319
}320
// Na de rollback werkt BlueGit gewoon verder en blijft melden.321
g.Commit("alpha", "after.txt", "na rollback", "create")322
Eventually(t, 15*time.Second, "melding na rollback", func() bool {323
return strings.Contains(gitLog(t, b.Mirror("data/repos/tim/alpha.git")), "zet after.txt")324
})325
}326
327
func postRollbackForm(t *testing.T, g *BlueGit, archiveName string, understood bool) int {328
t.Helper()329
hc := g.Session()330
hc.CheckRedirect = func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }331
res, err := hc.Get(g.URL + "/admin/backup")332
if err != nil {333
t.Fatal(err)334
}335
page, _ := io.ReadAll(res.Body)336
res.Body.Close()337
csrf := between(string(page), `name="csrf" value="`, `"`)338
if csrf == "" {339
t.Fatal("geen csrf op de beheerpagina")340
}341
form := url.Values{"csrf": {csrf}, "archive": {archiveName}, "confirm": {archiveName}}342
if understood {343
form.Set("understood", "1")344
}345
res, err = hc.PostForm(g.URL+"/admin/backup/rollback", form)346
if err != nil {347
t.Fatal(err)348
}349
res.Body.Close()350
return res.StatusCode351
}352
353
func between(s, a, b string) string {354
i := strings.Index(s, a)355
if i < 0 {356
return ""357
}358
s = s[i+len(a):]359
j := strings.Index(s, b)360
if j < 0 {361
return ""362
}363
return s[:j]364
}365
366
// Feature: één BlueGit per backup server; keuze "oude backups verwijderen".367
func TestNewInstanceWipe(t *testing.T) {368
a := startBlueGit(t)369
a.Project("Alpha", "a.txt", "van A")370
b := startBackup(t, nil)371
b.Connect(a, a.NewKey())372
b.Sync()373
b.Archive()374
375
other := startBlueGit(t)376
other.Project("Gamma", "g.txt", "van B")377
keyB := other.NewKey()378
code, raw := b.Admin("POST", "/connect", server.ConnectRequest{URL: other.URL, Key: keyB})379
if code != 409 {380
t.Fatalf("tweede BlueGit zonder keuze: %d %s", code, raw)381
}382
var cf server.ConflictError383
_ = json.Unmarshal(raw, &cf)384
if !cf.Conflict || cf.PreviousURL != a.URL || cf.Archives != 1 || strings.Join(cf.Choices, ",") != "wipe,restore" {385
t.Fatalf("conflict: %+v", cf)386
}387
// Er is nog niets veranderd.388
if b.Status().BlueGitURL != a.URL || len(b.Archives()) != 1 {389
t.Fatal("conflict veranderde de koppeling")390
}391
code, raw = b.Admin("POST", "/connect", server.ConnectRequest{URL: other.URL, Key: keyB, OnConflict: "wipe"})392
if code != 200 {393
t.Fatalf("wipe: %d %s", code, raw)394
}395
if len(b.Archives()) != 0 {396
t.Fatal("oude archieven staan er nog")397
}398
b.Sync()399
if _, err := os.Stat(b.Mirror("data/repos/tim/alpha.git/HEAD")); err == nil {400
t.Fatal("A staat nog in de kopie")401
}402
if !strings.Contains(gitLog(t, b.Mirror("data/repos/tim/gamma.git")), "zet g.txt") {403
t.Fatal("B staat niet in de kopie")404
}405
if st := other.BackupStatus(); !st.Connected || st.ServerURL != b.URL {406
t.Fatalf("B ziet de koppeling niet: %+v", st)407
}408
// A is los: zijn meldingen worden geweigerd (andere instantie).409
if b.Status().InstanceID == a.BackupStatus().InstanceID {410
t.Fatal("backup server hoort nog bij A")411
}412
}413
414
// Feature: keuze "nieuwe instantie terugzetten naar de gegevens in de backup server".415
func TestNewInstanceRestore(t *testing.T) {416
a := startBlueGit(t)417
a.Project("Alpha", "a.txt", "van A")418
a.Issue("alpha", "issue van A")419
b := startBackup(t, nil)420
b.Connect(a, a.NewKey())421
b.Sync()422
423
fresh := startBlueGit(t)424
fresh.Project("Gamma", "g.txt", "van B")425
keyB := fresh.NewKey()426
freshID := fresh.BackupStatus().InstanceID427
code, raw := b.Admin("POST", "/connect", server.ConnectRequest{URL: fresh.URL, Key: keyB, OnConflict: "restore"})428
if code != 200 || !strings.Contains(string(raw), `"restored":true`) {429
t.Fatalf("restore: %d %s", code, raw)430
}431
fresh.WaitUp(30 * time.Second)432
// De nieuwe BlueGit heeft nu de database van A, dus ook A's token.433
fresh.Token = a.Token434
if code, s := fresh.File("alpha", "a.txt"); code != 200 || s != "van A" {435
t.Fatalf("A's project op de nieuwe BlueGit: %d %q", code, s)436
}437
if code := fresh.ProjectCode("gamma"); code != 404 {438
t.Fatalf("B's eigen project bestaat nog: %d", code)439
}440
if titles := strings.Join(fresh.IssueTitles("alpha"), "|"); !strings.Contains(titles, "issue van A") {441
t.Fatalf("issues: %s", titles)442
}443
// De koppeling hoort bij de installatie, niet bij de gegevens.444
st := fresh.BackupStatus()445
if !st.Connected || st.InstanceID != freshID || st.ServerURL != b.URL {446
t.Fatalf("koppeling na restore: %+v", st)447
}448
if b.Status().InstanceID != freshID {449
t.Fatal("backup server hoort niet bij de nieuwe instantie")450
}451
b.Sync()452
if !strings.Contains(gitLog(t, b.Mirror("data/repos/tim/alpha.git")), "zet a.txt") {453
t.Fatal("kopie na restore")454
}455
}456
457
// Feature: de CLI vraagt de keuze bij een nieuwe verbinding.458
func TestCLIConnectAsksOnConflict(t *testing.T) {459
cli := filepath.Join(t.TempDir(), "bluegit-backup")460
if out, err := exec.Command("go", "build", "-o", cli, "../cmd/bluegit-backup").CombinedOutput(); err != nil {461
t.Fatalf("build: %v %s", err, out)462
}463
a := startBlueGit(t)464
a.Project("Alpha", "a.txt", "A")465
b := startBackup(t, nil)466
cfgPath := filepath.Join(t.TempDir(), "config.yml")467
_ = os.WriteFile(cfgPath, []byte("listen: "+b.Cfg.Listen+"\npublic_url: "+b.URL+"\ndata_dir: "+b.Dir+"\n"), 0o600)468
run := func(stdin string, args ...string) (string, error) {469
cmd := exec.Command(cli, append([]string{"connect", "--config", cfgPath}, args...)...)470
cmd.Stdin = strings.NewReader(stdin)471
out, err := cmd.CombinedOutput()472
return string(out), err473
}474
keyA := a.NewKey()475
cmd := exec.Command(cli, "connect", "--config", cfgPath, "--url", a.URL)476
cmd.Env = append(os.Environ(), "BLUEGIT_BACKUP_KEY="+keyA)477
if out, err := cmd.CombinedOutput(); err != nil {478
t.Fatalf("eerste connect: %v %s", err, out)479
}480
b.Sync()481
482
other := startBlueGit(t)483
keyB := other.NewKey()484
out, err := run("\n", "--url", other.URL, "--key", keyB)485
if err == nil || !strings.Contains(out, "Oude backups verwijderen") || !strings.Contains(out, "terugzetten") || !strings.Contains(out, "afgebroken") {486
t.Fatalf("afbreken: %v %s", err, out)487
}488
if b.Status().BlueGitURL != a.URL {489
t.Fatal("afbreken veranderde de koppeling")490
}491
out, err = run("1\n", "--url", other.URL, "--key", keyB)492
if err != nil || b.Status().BlueGitURL != other.URL {493
t.Fatalf("keuze 1: %v %s", err, out)494
}495
if out, err := exec.Command(cli, "status", "--config", cfgPath).CombinedOutput(); err != nil || !strings.Contains(string(out), other.URL) {496
t.Fatalf("status: %v %s", err, out)497
}498
}@@ -0,0 +1,484 @@
1
//go:build integration
2
3
// Integratietests: elke test start een echte BlueGit (BLUEGIT_BIN), maakt
4
// daar een beheerder, token en Backupserver-Key aan, en test de backup
5
// server ertegen. Zonder BLUEGIT_BIN falen ze; ze slaan niet over, zodat de
6
// release-jobs nooit op een overgeslagen test kunnen leunen.
7
package integration
8
9
import (
10
"bytes"
11
"context"
12
"encoding/json"
13
"fmt"
14
"io"
15
"log/slog"
16
"net"
17
"net/http"
18
"net/http/cookiejar"
19
"net/url"
20
"os"
21
"os/exec"
22
"path/filepath"
23
"strings"
24
"sync"
25
"testing"
26
"time"
27
28
"git.timfalken.com/timfa/bluegit-backup/internal/config"
29
"git.timfalken.com/timfa/bluegit-backup/internal/server"
30
)
31
32
func bluegitBin(t *testing.T) string {
33
t.Helper()
34
bin := os.Getenv("BLUEGIT_BIN")
35
if bin == "" {
36
t.Fatal("BLUEGIT_BIN ontbreekt: bouw BlueGit met scripts/build-bluegit.sh")
37
}
38
if _, err := os.Stat(bin); err != nil {
39
t.Fatalf("BLUEGIT_BIN: %v", err)
40
}
41
if _, err := exec.LookPath("git"); err != nil {
42
t.Fatal("git ontbreekt")
43
}
44
return bin
45
}
46
47
func freePort(t *testing.T) int {
48
t.Helper()
49
ln, err := net.Listen("tcp", "127.0.0.1:0")
50
if err != nil {
51
t.Fatal(err)
52
}
53
defer ln.Close()
54
return ln.Addr().(*net.TCPAddr).Port
55
}
56
57
// BlueGit is één lokaal opgespinde BlueGit.
58
type BlueGit struct {
59
t *testing.T
60
Bin string
61
URL string
62
Config string
63
State string
64
Storage string
65
Token string
66
cmd *exec.Cmd
67
log *syncBuf
68
}
69
70
type syncBuf struct {
71
mu sync.Mutex
72
b bytes.Buffer
73
}
74
75
func (s *syncBuf) Write(p []byte) (int, error) {
76
s.mu.Lock()
77
defer s.mu.Unlock()
78
return s.b.Write(p)
79
}
80
81
func (s *syncBuf) String() string {
82
s.mu.Lock()
83
defer s.mu.Unlock()
84
return s.b.String()
85
}
86
87
func startBlueGit(t *testing.T) *BlueGit {
88
t.Helper()
89
bin := bluegitBin(t)
90
dir := t.TempDir()
91
port := freePort(t)
92
g := &BlueGit{t: t, Bin: bin, URL: fmt.Sprintf("http://127.0.0.1:%d", port),
93
State: filepath.Join(dir, "state"), Storage: filepath.Join(dir, "storage"), Config: filepath.Join(dir, "bluegit.yml"), log: &syncBuf{}}
94
_ = os.MkdirAll(g.Storage, 0o750)
95
cfg := fmt.Sprintf(`base_url: %s
96
listen: 127.0.0.1:%d
97
state_path: %s
98
storage_path: %s
99
auth:
100
mode: dev
101
dev_user: tim
102
dev_auth_id: 1
103
user_agent: bluegit-backup-it
104
git:
105
binary: git
106
default_branch: master
107
ssh:
108
enabled: false
109
ci:
110
enabled: false
111
`, g.URL, port, g.State, g.Storage)
112
if err := os.WriteFile(g.Config, []byte(cfg), 0o600); err != nil {
113
t.Fatal(err)
114
}
115
g.cmd = exec.Command(bin, "serve", "--config", g.Config)
116
g.cmd.Stdout, g.cmd.Stderr = g.log, g.log
117
if err := g.cmd.Start(); err != nil {
118
t.Fatal(err)
119
}
120
t.Cleanup(func() {
121
_ = g.cmd.Process.Kill()
122
_, _ = g.cmd.Process.Wait()
123
if t.Failed() {
124
t.Logf("BlueGit-log %s:\n%s", g.URL, tail(g.log.String(), 60))
125
}
126
})
127
g.WaitUp(20 * time.Second)
128
// Aanmelden maakt de eerste gebruiker (beheerder) aan.
129
jar, _ := cookiejar.New(nil)
130
hc := &http.Client{Jar: jar}
131
res, err := hc.Get(g.URL + "/login")
132
if err != nil {
133
t.Fatal(err)
134
}
135
res.Body.Close()
136
out, err := exec.Command(bin, "token", "create", "--config", g.Config, "--user", "tim", "--name", "it").CombinedOutput()
137
if err != nil {
138
t.Fatalf("token: %v %s", err, out)
139
}
140
g.Token = strings.TrimSpace(string(out))
141
return g
142
}
143
144
func tail(s string, n int) string {
145
lines := strings.Split(s, "\n")
146
if len(lines) > n {
147
lines = lines[len(lines)-n:]
148
}
149
return strings.Join(lines, "\n")
150
}
151
152
// WaitUp wacht op /healthz.
153
func (g *BlueGit) WaitUp(d time.Duration) {
154
g.t.Helper()
155
deadline := time.Now().Add(d)
156
for time.Now().Before(deadline) {
157
res, err := http.Get(g.URL + "/healthz")
158
if err == nil {
159
res.Body.Close()
160
if res.StatusCode == 200 {
161
return
162
}
163
}
164
time.Sleep(100 * time.Millisecond)
165
}
166
g.t.Fatalf("BlueGit %s kwam niet op:\n%s", g.URL, tail(g.log.String(), 40))
167
}
168
169
// API doet een verzoek met het token. path begint na /api/v1.
170
func (g *BlueGit) API(method, path string, in any) (int, []byte) {
171
g.t.Helper()
172
return g.APIWith(g.Token, method, path, in)
173
}
174
175
// APIWith gebruikt een ander token.
176
func (g *BlueGit) APIWith(tok, method, path string, in any) (int, []byte) {
177
g.t.Helper()
178
var body io.Reader
179
if in != nil {
180
b, _ := json.Marshal(in)
181
body = bytes.NewReader(b)
182
}
183
req, _ := http.NewRequest(method, g.URL+"/api/v1"+path, body)
184
req.Header.Set("Authorization", "Bearer "+tok)
185
if in != nil {
186
req.Header.Set("Content-Type", "application/json")
187
}
188
res, err := http.DefaultClient.Do(req)
189
if err != nil {
190
g.t.Fatalf("%s %s: %v", method, path, err)
191
}
192
defer res.Body.Close()
193
b, _ := io.ReadAll(res.Body)
194
return res.StatusCode, b
195
}
196
197
// MustAPI faalt bij een fout.
198
func (g *BlueGit) MustAPI(method, path string, in any) []byte {
199
g.t.Helper()
200
code, b := g.API(method, path, in)
201
if code >= 300 {
202
g.t.Fatalf("%s %s: %d %s", method, path, code, b)
203
}
204
return b
205
}
206
207
// NewKey maakt een Backupserver-Key via de beheer-API.
208
func (g *BlueGit) NewKey() string {
209
g.t.Helper()
210
var out struct{ Key string }
211
_ = json.Unmarshal(g.MustAPI("POST", "/admin/backup/key", nil), &out)
212
if !strings.HasPrefix(out.Key, "bgbk_") {
213
g.t.Fatalf("key %q", out.Key)
214
}
215
return out.Key
216
}
217
218
// Project maakt een project met één commit.
219
func (g *BlueGit) Project(name, file, content string) {
220
g.t.Helper()
221
g.MustAPI("POST", "/projects", map[string]any{"name": name, "visibility": "private"})
222
g.Commit(strings.ToLower(name), file, content, "create")
223
}
224
225
// Commit schrijft één bestand op master.
226
func (g *BlueGit) Commit(repo, file, content, action string) {
227
g.t.Helper()
228
g.MustAPI("POST", "/projects/tim/"+repo+"/repository/commits", map[string]any{
229
"branch": "master", "commit_message": "zet " + file,
230
"actions": []map[string]string{{"action": action, "file_path": file, "content": content}},
231
})
232
}
233
234
// File leest een bestand van master, of geeft de HTTP-code.
235
func (g *BlueGit) File(repo, file string) (int, string) {
236
g.t.Helper()
237
req, _ := http.NewRequest("GET", g.URL+"/api/v1/projects/tim/"+repo+"/repository/files/"+file+"?ref=master", nil)
238
req.Header.Set("Authorization", "Bearer "+g.Token)
239
res, err := http.DefaultClient.Do(req)
240
if err != nil {
241
g.t.Fatal(err)
242
}
243
defer res.Body.Close()
244
b, _ := io.ReadAll(res.Body)
245
return res.StatusCode, string(b)
246
}
247
248
// Issue maakt een issue.
249
func (g *BlueGit) Issue(repo, title string) {
250
g.t.Helper()
251
g.MustAPI("POST", "/repos/tim/"+repo+"/issues", map[string]any{"title": title})
252
}
253
254
// IssueTitles geeft alle issuetitels.
255
func (g *BlueGit) IssueTitles(repo string) []string {
256
g.t.Helper()
257
code, b := g.API("GET", "/repos/tim/"+repo+"/issues?state=all", nil)
258
if code != 200 {
259
g.t.Fatalf("issues: %d %s", code, b)
260
}
261
var list struct {
262
Issues []struct{ Title string } `json:"issues"`
263
}
264
_ = json.Unmarshal(b, &list)
265
var out []string
266
for _, i := range list.Issues {
267
out = append(out, i.Title)
268
}
269
return out
270
}
271
272
// ProjectCode is de HTTP-code van GET project.
273
func (g *BlueGit) ProjectCode(repo string) int {
274
g.t.Helper()
275
code, _ := g.API("GET", "/projects/tim/"+repo, nil)
276
return code
277
}
278
279
// BackupStatus is GET /admin/backup in BlueGit.
280
type BackupStatus struct {
281
InstanceID string `json:"instance_id"`
282
HasKey bool `json:"has_key"`
283
Connected bool `json:"connected"`
284
ServerURL string `json:"server_url"`
285
Archives []struct {
286
Name string `json:"name"`
287
Size int64 `json:"size"`
288
} `json:"archives"`
289
RemoteError string `json:"remote_error"`
290
}
291
292
func (g *BlueGit) BackupStatus() BackupStatus {
293
g.t.Helper()
294
var st BackupStatus
295
_ = json.Unmarshal(g.MustAPI("GET", "/admin/backup", nil), &st)
296
return st
297
}
298
299
// Session geeft een HTTP-client met sessiecookie (dev-login).
300
func (g *BlueGit) Session() *http.Client {
301
g.t.Helper()
302
jar, _ := cookiejar.New(nil)
303
hc := &http.Client{Jar: jar}
304
res, err := hc.Get(g.URL + "/login")
305
if err != nil {
306
g.t.Fatal(err)
307
}
308
res.Body.Close()
309
return hc
310
}
311
312
// Git draait git met het token als wachtwoord.
313
func (g *BlueGit) Git(dir string, args ...string) string {
314
g.t.Helper()
315
cmd := exec.Command("git", args...)
316
cmd.Dir = dir
317
cmd.Env = append(os.Environ(), "GIT_TERMINAL_PROMPT=0", "GIT_AUTHOR_NAME=it", "GIT_AUTHOR_EMAIL=it@example.invalid", "GIT_COMMITTER_NAME=it", "GIT_COMMITTER_EMAIL=it@example.invalid")
318
out, err := cmd.CombinedOutput()
319
if err != nil {
320
g.t.Fatalf("git %v: %v\n%s", args, err, out)
321
}
322
return string(out)
323
}
324
325
// RemoteURL is de clone-URL met token.
326
func (g *BlueGit) RemoteURL(repo string) string {
327
u, _ := url.Parse(g.URL)
328
u.User = url.UserPassword("tim", g.Token)
329
u.Path = "/tim/" + repo + ".git"
330
return u.String()
331
}
332
333
// Backup is één backup server in dit proces.
334
type Backup struct {
335
t *testing.T
336
Srv *server.Server
337
URL string
338
Dir string
339
Cfg config.Config
340
}
341
342
func startBackup(t *testing.T, mod func(*config.Config)) *Backup {
343
t.Helper()
344
port := freePort(t)
345
b := &Backup{t: t, URL: fmt.Sprintf("http://127.0.0.1:%d", port), Dir: t.TempDir()}
346
cfg := config.Config{Listen: fmt.Sprintf("127.0.0.1:%d", port), PublicURL: b.URL, DataDir: b.Dir}
347
// Snel genoeg voor tests; de standaardwaarden staan in config.Defaults.
348
cfg.MinSyncInterval.Duration = 50 * time.Millisecond
349
cfg.ArchiveInterval.Duration = time.Hour
350
cfg.FullSyncInterval.Duration = time.Hour
351
cfg.RateLimitKiB = -1
352
cfg.MinFreeMB = 1
353
if mod != nil {
354
mod(&cfg)
355
}
356
cfg.Defaults()
357
b.Cfg = cfg
358
srv, err := server.New(cfg, slog.New(slog.NewTextHandler(&testWriter{t}, &slog.HandlerOptions{Level: slog.LevelWarn})))
359
if err != nil {
360
t.Fatal(err)
361
}
362
b.Srv = srv
363
ln, err := net.Listen("tcp", cfg.Listen)
364
if err != nil {
365
t.Fatal(err)
366
}
367
hs := &http.Server{Handler: srv.Handler()}
368
ctx, cancel := context.WithCancel(context.Background())
369
go func() { _ = hs.Serve(ln) }()
370
srv.Run(ctx)
371
t.Cleanup(func() {
372
cancel()
373
_ = hs.Close()
374
})
375
return b
376
}
377
378
type testWriter struct{ t *testing.T }
379
380
func (w *testWriter) Write(p []byte) (int, error) {
381
w.t.Log(strings.TrimRight(string(p), "\n"))
382
return len(p), nil
383
}
384
385
// Admin doet een verzoek op de lokale beheer-API.
386
func (b *Backup) Admin(method, path string, in any) (int, []byte) {
387
b.t.Helper()
388
var body io.Reader
389
if in != nil {
390
raw, _ := json.Marshal(in)
391
body = bytes.NewReader(raw)
392
}
393
req, _ := http.NewRequest(method, b.URL+"/api/v1/admin"+path, body)
394
req.Header.Set("Authorization", "Bearer "+b.Srv.AdminToken())
395
res, err := http.DefaultClient.Do(req)
396
if err != nil {
397
b.t.Fatal(err)
398
}
399
defer res.Body.Close()
400
raw, _ := io.ReadAll(res.Body)
401
return res.StatusCode, raw
402
}
403
404
// Connect koppelt aan g zonder conflictkeuze; faalt bij een fout.
405
func (b *Backup) Connect(g *BlueGit, key string) {
406
b.t.Helper()
407
code, raw := b.Admin("POST", "/connect", server.ConnectRequest{URL: g.URL, Key: key})
408
if code != 200 {
409
b.t.Fatalf("connect: %d %s", code, raw)
410
}
411
}
412
413
// Sync synchroniseert nu.
414
func (b *Backup) Sync() {
415
b.t.Helper()
416
code, raw := b.Admin("POST", "/sync", nil)
417
if code != 200 {
418
b.t.Fatalf("sync: %d %s", code, raw)
419
}
420
}
421
422
// Archive maakt nu een archief en geeft de naam.
423
func (b *Backup) Archive() string {
424
b.t.Helper()
425
code, raw := b.Admin("POST", "/archive", nil)
426
if code != 201 {
427
b.t.Fatalf("archive: %d %s", code, raw)
428
}
429
var a struct{ Name string }
430
_ = json.Unmarshal(raw, &a)
431
return a.Name
432
}
433
434
// Mirror is het pad van een logisch bestand in de kopie.
435
func (b *Backup) Mirror(logical string) string {
436
return filepath.Join(b.Dir, "mirror", filepath.FromSlash(logical))
437
}
438
439
// Archives geeft de archiefnamen, nieuwste eerst.
440
func (b *Backup) Archives() []string {
441
b.t.Helper()
442
_, raw := b.Admin("GET", "/archives", nil)
443
var out struct {
444
Archives []struct{ Name string }
445
}
446
_ = json.Unmarshal(raw, &out)
447
var names []string
448
for _, a := range out.Archives {
449
names = append(names, a.Name)
450
}
451
return names
452
}
453
454
// Status leest de status.
455
func (b *Backup) Status() server.Status {
456
b.t.Helper()
457
_, raw := b.Admin("GET", "/status", nil)
458
var st server.Status
459
_ = json.Unmarshal(raw, &st)
460
return st
461
}
462
463
// Eventually herhaalt f tot hij true geeft.
464
func Eventually(t *testing.T, d time.Duration, what string, f func() bool) {
465
t.Helper()
466
deadline := time.Now().Add(d)
467
for time.Now().Before(deadline) {
468
if f() {
469
return
470
}
471
time.Sleep(50 * time.Millisecond)
472
}
473
t.Fatalf("na %v nog steeds niet: %s", d, what)
474
}
475
476
// gitLog geeft de onderwerpen van een bare repo in de kopie.
477
func gitLog(t *testing.T, gitDir string) string {
478
t.Helper()
479
out, err := exec.Command("git", "--git-dir", gitDir, "log", "--format=%s", "master").CombinedOutput()
480
if err != nil {
481
return "FOUT: " + string(out)
482
}
483
return string(out)
484
}
@@ -0,0 +1,484 @@1
//go:build integration2
3
// Integratietests: elke test start een echte BlueGit (BLUEGIT_BIN), maakt4
// daar een beheerder, token en Backupserver-Key aan, en test de backup5
// server ertegen. Zonder BLUEGIT_BIN falen ze; ze slaan niet over, zodat de6
// release-jobs nooit op een overgeslagen test kunnen leunen.7
package integration8
9
import (10
"bytes"11
"context"12
"encoding/json"13
"fmt"14
"io"15
"log/slog"16
"net"17
"net/http"18
"net/http/cookiejar"19
"net/url"20
"os"21
"os/exec"22
"path/filepath"23
"strings"24
"sync"25
"testing"26
"time"27
28
"git.timfalken.com/timfa/bluegit-backup/internal/config"29
"git.timfalken.com/timfa/bluegit-backup/internal/server"30
)31
32
func bluegitBin(t *testing.T) string {33
t.Helper()34
bin := os.Getenv("BLUEGIT_BIN")35
if bin == "" {36
t.Fatal("BLUEGIT_BIN ontbreekt: bouw BlueGit met scripts/build-bluegit.sh")37
}38
if _, err := os.Stat(bin); err != nil {39
t.Fatalf("BLUEGIT_BIN: %v", err)40
}41
if _, err := exec.LookPath("git"); err != nil {42
t.Fatal("git ontbreekt")43
}44
return bin45
}46
47
func freePort(t *testing.T) int {48
t.Helper()49
ln, err := net.Listen("tcp", "127.0.0.1:0")50
if err != nil {51
t.Fatal(err)52
}53
defer ln.Close()54
return ln.Addr().(*net.TCPAddr).Port55
}56
57
// BlueGit is één lokaal opgespinde BlueGit.58
type BlueGit struct {59
t *testing.T60
Bin string61
URL string62
Config string63
State string64
Storage string65
Token string66
cmd *exec.Cmd67
log *syncBuf68
}69
70
type syncBuf struct {71
mu sync.Mutex72
b bytes.Buffer73
}74
75
func (s *syncBuf) Write(p []byte) (int, error) {76
s.mu.Lock()77
defer s.mu.Unlock()78
return s.b.Write(p)79
}80
81
func (s *syncBuf) String() string {82
s.mu.Lock()83
defer s.mu.Unlock()84
return s.b.String()85
}86
87
func startBlueGit(t *testing.T) *BlueGit {88
t.Helper()89
bin := bluegitBin(t)90
dir := t.TempDir()91
port := freePort(t)92
g := &BlueGit{t: t, Bin: bin, URL: fmt.Sprintf("http://127.0.0.1:%d", port),93
State: filepath.Join(dir, "state"), Storage: filepath.Join(dir, "storage"), Config: filepath.Join(dir, "bluegit.yml"), log: &syncBuf{}}94
_ = os.MkdirAll(g.Storage, 0o750)95
cfg := fmt.Sprintf(`base_url: %s96
listen: 127.0.0.1:%d97
state_path: %s98
storage_path: %s99
auth:100
mode: dev101
dev_user: tim102
dev_auth_id: 1103
user_agent: bluegit-backup-it104
git:105
binary: git106
default_branch: master107
ssh:108
enabled: false109
ci:110
enabled: false111
`, g.URL, port, g.State, g.Storage)112
if err := os.WriteFile(g.Config, []byte(cfg), 0o600); err != nil {113
t.Fatal(err)114
}115
g.cmd = exec.Command(bin, "serve", "--config", g.Config)116
g.cmd.Stdout, g.cmd.Stderr = g.log, g.log117
if err := g.cmd.Start(); err != nil {118
t.Fatal(err)119
}120
t.Cleanup(func() {121
_ = g.cmd.Process.Kill()122
_, _ = g.cmd.Process.Wait()123
if t.Failed() {124
t.Logf("BlueGit-log %s:\n%s", g.URL, tail(g.log.String(), 60))125
}126
})127
g.WaitUp(20 * time.Second)128
// Aanmelden maakt de eerste gebruiker (beheerder) aan.129
jar, _ := cookiejar.New(nil)130
hc := &http.Client{Jar: jar}131
res, err := hc.Get(g.URL + "/login")132
if err != nil {133
t.Fatal(err)134
}135
res.Body.Close()136
out, err := exec.Command(bin, "token", "create", "--config", g.Config, "--user", "tim", "--name", "it").CombinedOutput()137
if err != nil {138
t.Fatalf("token: %v %s", err, out)139
}140
g.Token = strings.TrimSpace(string(out))141
return g142
}143
144
func tail(s string, n int) string {145
lines := strings.Split(s, "\n")146
if len(lines) > n {147
lines = lines[len(lines)-n:]148
}149
return strings.Join(lines, "\n")150
}151
152
// WaitUp wacht op /healthz.153
func (g *BlueGit) WaitUp(d time.Duration) {154
g.t.Helper()155
deadline := time.Now().Add(d)156
for time.Now().Before(deadline) {157
res, err := http.Get(g.URL + "/healthz")158
if err == nil {159
res.Body.Close()160
if res.StatusCode == 200 {161
return162
}163
}164
time.Sleep(100 * time.Millisecond)165
}166
g.t.Fatalf("BlueGit %s kwam niet op:\n%s", g.URL, tail(g.log.String(), 40))167
}168
169
// API doet een verzoek met het token. path begint na /api/v1.170
func (g *BlueGit) API(method, path string, in any) (int, []byte) {171
g.t.Helper()172
return g.APIWith(g.Token, method, path, in)173
}174
175
// APIWith gebruikt een ander token.176
func (g *BlueGit) APIWith(tok, method, path string, in any) (int, []byte) {177
g.t.Helper()178
var body io.Reader179
if in != nil {180
b, _ := json.Marshal(in)181
body = bytes.NewReader(b)182
}183
req, _ := http.NewRequest(method, g.URL+"/api/v1"+path, body)184
req.Header.Set("Authorization", "Bearer "+tok)185
if in != nil {186
req.Header.Set("Content-Type", "application/json")187
}188
res, err := http.DefaultClient.Do(req)189
if err != nil {190
g.t.Fatalf("%s %s: %v", method, path, err)191
}192
defer res.Body.Close()193
b, _ := io.ReadAll(res.Body)194
return res.StatusCode, b195
}196
197
// MustAPI faalt bij een fout.198
func (g *BlueGit) MustAPI(method, path string, in any) []byte {199
g.t.Helper()200
code, b := g.API(method, path, in)201
if code >= 300 {202
g.t.Fatalf("%s %s: %d %s", method, path, code, b)203
}204
return b205
}206
207
// NewKey maakt een Backupserver-Key via de beheer-API.208
func (g *BlueGit) NewKey() string {209
g.t.Helper()210
var out struct{ Key string }211
_ = json.Unmarshal(g.MustAPI("POST", "/admin/backup/key", nil), &out)212
if !strings.HasPrefix(out.Key, "bgbk_") {213
g.t.Fatalf("key %q", out.Key)214
}215
return out.Key216
}217
218
// Project maakt een project met één commit.219
func (g *BlueGit) Project(name, file, content string) {220
g.t.Helper()221
g.MustAPI("POST", "/projects", map[string]any{"name": name, "visibility": "private"})222
g.Commit(strings.ToLower(name), file, content, "create")223
}224
225
// Commit schrijft één bestand op master.226
func (g *BlueGit) Commit(repo, file, content, action string) {227
g.t.Helper()228
g.MustAPI("POST", "/projects/tim/"+repo+"/repository/commits", map[string]any{229
"branch": "master", "commit_message": "zet " + file,230
"actions": []map[string]string{{"action": action, "file_path": file, "content": content}},231
})232
}233
234
// File leest een bestand van master, of geeft de HTTP-code.235
func (g *BlueGit) File(repo, file string) (int, string) {236
g.t.Helper()237
req, _ := http.NewRequest("GET", g.URL+"/api/v1/projects/tim/"+repo+"/repository/files/"+file+"?ref=master", nil)238
req.Header.Set("Authorization", "Bearer "+g.Token)239
res, err := http.DefaultClient.Do(req)240
if err != nil {241
g.t.Fatal(err)242
}243
defer res.Body.Close()244
b, _ := io.ReadAll(res.Body)245
return res.StatusCode, string(b)246
}247
248
// Issue maakt een issue.249
func (g *BlueGit) Issue(repo, title string) {250
g.t.Helper()251
g.MustAPI("POST", "/repos/tim/"+repo+"/issues", map[string]any{"title": title})252
}253
254
// IssueTitles geeft alle issuetitels.255
func (g *BlueGit) IssueTitles(repo string) []string {256
g.t.Helper()257
code, b := g.API("GET", "/repos/tim/"+repo+"/issues?state=all", nil)258
if code != 200 {259
g.t.Fatalf("issues: %d %s", code, b)260
}261
var list struct {262
Issues []struct{ Title string } `json:"issues"`263
}264
_ = json.Unmarshal(b, &list)265
var out []string266
for _, i := range list.Issues {267
out = append(out, i.Title)268
}269
return out270
}271
272
// ProjectCode is de HTTP-code van GET project.273
func (g *BlueGit) ProjectCode(repo string) int {274
g.t.Helper()275
code, _ := g.API("GET", "/projects/tim/"+repo, nil)276
return code277
}278
279
// BackupStatus is GET /admin/backup in BlueGit.280
type BackupStatus struct {281
InstanceID string `json:"instance_id"`282
HasKey bool `json:"has_key"`283
Connected bool `json:"connected"`284
ServerURL string `json:"server_url"`285
Archives []struct {286
Name string `json:"name"`287
Size int64 `json:"size"`288
} `json:"archives"`289
RemoteError string `json:"remote_error"`290
}291
292
func (g *BlueGit) BackupStatus() BackupStatus {293
g.t.Helper()294
var st BackupStatus295
_ = json.Unmarshal(g.MustAPI("GET", "/admin/backup", nil), &st)296
return st297
}298
299
// Session geeft een HTTP-client met sessiecookie (dev-login).300
func (g *BlueGit) Session() *http.Client {301
g.t.Helper()302
jar, _ := cookiejar.New(nil)303
hc := &http.Client{Jar: jar}304
res, err := hc.Get(g.URL + "/login")305
if err != nil {306
g.t.Fatal(err)307
}308
res.Body.Close()309
return hc310
}311
312
// Git draait git met het token als wachtwoord.313
func (g *BlueGit) Git(dir string, args ...string) string {314
g.t.Helper()315
cmd := exec.Command("git", args...)316
cmd.Dir = dir317
cmd.Env = append(os.Environ(), "GIT_TERMINAL_PROMPT=0", "GIT_AUTHOR_NAME=it", "GIT_AUTHOR_EMAIL=it@example.invalid", "GIT_COMMITTER_NAME=it", "GIT_COMMITTER_EMAIL=it@example.invalid")318
out, err := cmd.CombinedOutput()319
if err != nil {320
g.t.Fatalf("git %v: %v\n%s", args, err, out)321
}322
return string(out)323
}324
325
// RemoteURL is de clone-URL met token.326
func (g *BlueGit) RemoteURL(repo string) string {327
u, _ := url.Parse(g.URL)328
u.User = url.UserPassword("tim", g.Token)329
u.Path = "/tim/" + repo + ".git"330
return u.String()331
}332
333
// Backup is één backup server in dit proces.334
type Backup struct {335
t *testing.T336
Srv *server.Server337
URL string338
Dir string339
Cfg config.Config340
}341
342
func startBackup(t *testing.T, mod func(*config.Config)) *Backup {343
t.Helper()344
port := freePort(t)345
b := &Backup{t: t, URL: fmt.Sprintf("http://127.0.0.1:%d", port), Dir: t.TempDir()}346
cfg := config.Config{Listen: fmt.Sprintf("127.0.0.1:%d", port), PublicURL: b.URL, DataDir: b.Dir}347
// Snel genoeg voor tests; de standaardwaarden staan in config.Defaults.348
cfg.MinSyncInterval.Duration = 50 * time.Millisecond349
cfg.ArchiveInterval.Duration = time.Hour350
cfg.FullSyncInterval.Duration = time.Hour351
cfg.RateLimitKiB = -1352
cfg.MinFreeMB = 1353
if mod != nil {354
mod(&cfg)355
}356
cfg.Defaults()357
b.Cfg = cfg358
srv, err := server.New(cfg, slog.New(slog.NewTextHandler(&testWriter{t}, &slog.HandlerOptions{Level: slog.LevelWarn})))359
if err != nil {360
t.Fatal(err)361
}362
b.Srv = srv363
ln, err := net.Listen("tcp", cfg.Listen)364
if err != nil {365
t.Fatal(err)366
}367
hs := &http.Server{Handler: srv.Handler()}368
ctx, cancel := context.WithCancel(context.Background())369
go func() { _ = hs.Serve(ln) }()370
srv.Run(ctx)371
t.Cleanup(func() {372
cancel()373
_ = hs.Close()374
})375
return b376
}377
378
type testWriter struct{ t *testing.T }379
380
func (w *testWriter) Write(p []byte) (int, error) {381
w.t.Log(strings.TrimRight(string(p), "\n"))382
return len(p), nil383
}384
385
// Admin doet een verzoek op de lokale beheer-API.386
func (b *Backup) Admin(method, path string, in any) (int, []byte) {387
b.t.Helper()388
var body io.Reader389
if in != nil {390
raw, _ := json.Marshal(in)391
body = bytes.NewReader(raw)392
}393
req, _ := http.NewRequest(method, b.URL+"/api/v1/admin"+path, body)394
req.Header.Set("Authorization", "Bearer "+b.Srv.AdminToken())395
res, err := http.DefaultClient.Do(req)396
if err != nil {397
b.t.Fatal(err)398
}399
defer res.Body.Close()400
raw, _ := io.ReadAll(res.Body)401
return res.StatusCode, raw402
}403
404
// Connect koppelt aan g zonder conflictkeuze; faalt bij een fout.405
func (b *Backup) Connect(g *BlueGit, key string) {406
b.t.Helper()407
code, raw := b.Admin("POST", "/connect", server.ConnectRequest{URL: g.URL, Key: key})408
if code != 200 {409
b.t.Fatalf("connect: %d %s", code, raw)410
}411
}412
413
// Sync synchroniseert nu.414
func (b *Backup) Sync() {415
b.t.Helper()416
code, raw := b.Admin("POST", "/sync", nil)417
if code != 200 {418
b.t.Fatalf("sync: %d %s", code, raw)419
}420
}421
422
// Archive maakt nu een archief en geeft de naam.423
func (b *Backup) Archive() string {424
b.t.Helper()425
code, raw := b.Admin("POST", "/archive", nil)426
if code != 201 {427
b.t.Fatalf("archive: %d %s", code, raw)428
}429
var a struct{ Name string }430
_ = json.Unmarshal(raw, &a)431
return a.Name432
}433
434
// Mirror is het pad van een logisch bestand in de kopie.435
func (b *Backup) Mirror(logical string) string {436
return filepath.Join(b.Dir, "mirror", filepath.FromSlash(logical))437
}438
439
// Archives geeft de archiefnamen, nieuwste eerst.440
func (b *Backup) Archives() []string {441
b.t.Helper()442
_, raw := b.Admin("GET", "/archives", nil)443
var out struct {444
Archives []struct{ Name string }445
}446
_ = json.Unmarshal(raw, &out)447
var names []string448
for _, a := range out.Archives {449
names = append(names, a.Name)450
}451
return names452
}453
454
// Status leest de status.455
func (b *Backup) Status() server.Status {456
b.t.Helper()457
_, raw := b.Admin("GET", "/status", nil)458
var st server.Status459
_ = json.Unmarshal(raw, &st)460
return st461
}462
463
// Eventually herhaalt f tot hij true geeft.464
func Eventually(t *testing.T, d time.Duration, what string, f func() bool) {465
t.Helper()466
deadline := time.Now().Add(d)467
for time.Now().Before(deadline) {468
if f() {469
return470
}471
time.Sleep(50 * time.Millisecond)472
}473
t.Fatalf("na %v nog steeds niet: %s", d, what)474
}475
476
// gitLog geeft de onderwerpen van een bare repo in de kopie.477
func gitLog(t *testing.T, gitDir string) string {478
t.Helper()479
out, err := exec.Command("git", "--git-dir", gitDir, "log", "--format=%s", "master").CombinedOutput()480
if err != nil {481
return "FOUT: " + string(out)482
}483
return string(out)484
}@@ -0,0 +1,283 @@
1
package mirror
2
3
import (
4
"context"
5
"crypto/sha256"
6
"encoding/hex"
7
"encoding/json"
8
"errors"
9
"fmt"
10
"io"
11
"io/fs"
12
"os"
13
"path/filepath"
14
"sort"
15
"strings"
16
"time"
17
18
"git.timfalken.com/timfa/bluegit-backup/internal/protocol"
19
)
20
21
// Mirror is de draaiende kopie: Dir bevat de logische paden (state/…,
22
// data/…). Index onthoudt per bestand grootte en mtime zoals BlueGit ze
23
// meldde, zodat een volgende sync alleen wijzigingen ophaalt.
24
type Mirror struct {
25
Dir string
26
Index string
27
}
28
29
// Stats zegt wat een sync deed.
30
type Stats struct {
31
Files int `json:"files"`
32
Downloaded int `json:"downloaded"`
33
Bytes int64 `json:"bytes"`
34
Deleted int `json:"deleted"`
35
Skipped int `json:"skipped"`
36
}
37
38
// LoadIndex leest de index. Geen bestand: leeg.
39
func (m *Mirror) LoadIndex() (map[string]protocol.Entry, error) {
40
idx := map[string]protocol.Entry{}
41
b, err := os.ReadFile(m.Index)
42
if errors.Is(err, os.ErrNotExist) {
43
return idx, nil
44
}
45
if err != nil {
46
return idx, err
47
}
48
return idx, json.Unmarshal(b, &idx)
49
}
50
51
func (m *Mirror) saveIndex(idx map[string]protocol.Entry) error {
52
b, err := json.Marshal(idx)
53
if err != nil {
54
return err
55
}
56
tmp := m.Index + ".tmp"
57
if err := os.WriteFile(tmp, b, 0o600); err != nil {
58
return err
59
}
60
return os.Rename(tmp, m.Index)
61
}
62
63
// Empty zegt of de kopie nog niets bevat.
64
func (m *Mirror) Empty() bool {
65
idx, err := m.LoadIndex()
66
return err != nil || len(idx) == 0
67
}
68
69
// Size is de totale grootte volgens de index.
70
func (m *Mirror) Size() int64 {
71
idx, _ := m.LoadIndex()
72
var n int64
73
for _, e := range idx {
74
n += e.Size
75
}
76
return n
77
}
78
79
// Wipe verwijdert de kopie en de index.
80
func (m *Mirror) Wipe() error {
81
if err := os.RemoveAll(m.Dir); err != nil {
82
return err
83
}
84
err := os.Remove(m.Index)
85
if errors.Is(err, os.ErrNotExist) {
86
return nil
87
}
88
return err
89
}
90
91
func (m *Mirror) real(logical string) string {
92
return filepath.Join(m.Dir, filepath.FromSlash(logical))
93
}
94
95
func same(a, b protocol.Entry) bool {
96
if a.Path == protocol.DBPath || b.Path == protocol.DBPath {
97
return a.SHA256 != "" && a.SHA256 == b.SHA256 && a.Size == b.Size
98
}
99
return a.Size == b.Size && a.MTime == b.MTime
100
}
101
102
// Sync haalt het manifest op en brengt de kopie gelijk: nieuwe en
103
// gewijzigde bestanden downloaden (begrensd), verdwenen bestanden weg.
104
func (m *Mirror) Sync(ctx context.Context, r *Remote) (Stats, error) {
105
var st Stats
106
man, err := r.Manifest(ctx)
107
if err != nil {
108
return st, err
109
}
110
idx, err := m.LoadIndex()
111
if err != nil {
112
idx = map[string]protocol.Entry{}
113
}
114
if err := os.MkdirAll(m.Dir, 0o750); err != nil {
115
return st, err
116
}
117
tmpDir := filepath.Join(filepath.Dir(m.Dir), "tmp")
118
if err := os.MkdirAll(tmpDir, 0o750); err != nil {
119
return st, err
120
}
121
want := map[string]bool{}
122
dirty := 0
123
for _, e := range man.Files {
124
logical, ok := protocol.CleanLogical(e.Path)
125
if !ok {
126
continue
127
}
128
want[logical] = true
129
st.Files++
130
if old, ok := idx[logical]; ok && same(old, e) {
131
if _, err := os.Stat(m.real(logical)); err == nil {
132
continue
133
}
134
}
135
n, err := m.download(ctx, r, tmpDir, e)
136
if errors.Is(err, ErrGone) {
137
st.Skipped++
138
want[logical] = false
139
continue
140
}
141
if err != nil {
142
_ = m.saveIndex(idx)
143
return st, fmt.Errorf("%s: %w", logical, err)
144
}
145
idx[logical] = e
146
st.Downloaded++
147
st.Bytes += n
148
dirty++
149
if dirty >= 200 {
150
_ = m.saveIndex(idx)
151
dirty = 0
152
}
153
}
154
for p := range idx {
155
if !want[p] {
156
_ = os.Remove(m.real(p))
157
delete(idx, p)
158
st.Deleted++
159
}
160
}
161
// Ook bestanden die niet in de index stonden (een afgebroken download).
162
_ = filepath.WalkDir(m.Dir, func(p string, d fs.DirEntry, err error) error {
163
if err != nil || d.IsDir() {
164
return nil
165
}
166
rel, _ := filepath.Rel(m.Dir, p)
167
if _, ok := idx[filepath.ToSlash(rel)]; !ok {
168
_ = os.Remove(p)
169
}
170
return nil
171
})
172
removeEmptyDirs(m.Dir)
173
return st, m.saveIndex(idx)
174
}
175
176
func (m *Mirror) download(ctx context.Context, r *Remote, tmpDir string, e protocol.Entry) (int64, error) {
177
rc, err := r.Fetch(ctx, e.Path)
178
if err != nil {
179
return 0, err
180
}
181
defer rc.Close()
182
f, err := os.CreateTemp(tmpDir, "dl-*")
183
if err != nil {
184
return 0, err
185
}
186
tmp := f.Name()
187
defer os.Remove(tmp)
188
h := sha256.New()
189
n, err := io.Copy(io.MultiWriter(f, h), rc)
190
if cerr := f.Close(); err == nil {
191
err = cerr
192
}
193
if err != nil {
194
return n, err
195
}
196
if e.SHA256 != "" && hex.EncodeToString(h.Sum(nil)) != e.SHA256 {
197
return n, errors.New("sha256 klopt niet")
198
}
199
mode := os.FileMode(e.Mode).Perm()
200
if mode == 0 {
201
mode = 0o640
202
}
203
_ = os.Chmod(tmp, mode|0o600)
204
dst := m.real(e.Path)
205
if err := os.MkdirAll(filepath.Dir(dst), 0o750); err != nil {
206
return n, err
207
}
208
if err := os.Rename(tmp, dst); err != nil {
209
return n, err
210
}
211
mt := time.UnixMilli(e.MTime)
212
_ = os.Chtimes(dst, mt, mt)
213
return n, nil
214
}
215
216
func removeEmptyDirs(root string) {
217
var dirs []string
218
_ = filepath.WalkDir(root, func(p string, d fs.DirEntry, err error) error {
219
if err == nil && d.IsDir() && p != root {
220
dirs = append(dirs, p)
221
}
222
return nil
223
})
224
sort.Slice(dirs, func(i, j int) bool { return len(dirs[i]) > len(dirs[j]) })
225
for _, d := range dirs {
226
_ = os.Remove(d) // faalt als hij niet leeg is
227
}
228
}
229
230
// RebuildIndex maakt de index opnieuw uit de bestanden zelf, na het
231
// uitpakken van een archief. De mtimes komen uit het archief en zijn
232
// dezelfde die BlueGit na het terugzetten heeft.
233
func (m *Mirror) RebuildIndex() error {
234
idx := map[string]protocol.Entry{}
235
err := filepath.WalkDir(m.Dir, func(p string, d fs.DirEntry, err error) error {
236
if err != nil {
237
return err
238
}
239
if d.IsDir() || !d.Type().IsRegular() {
240
return nil
241
}
242
rel, _ := filepath.Rel(m.Dir, p)
243
logical := filepath.ToSlash(rel)
244
if _, ok := protocol.CleanLogical(logical); !ok {
245
return nil
246
}
247
fi, err := d.Info()
248
if err != nil {
249
return err
250
}
251
e := protocol.Entry{Path: logical, Size: fi.Size(), MTime: fi.ModTime().UnixMilli(), Mode: uint32(fi.Mode().Perm())}
252
if logical == protocol.DBPath {
253
f, err := os.Open(p)
254
if err != nil {
255
return err
256
}
257
h := sha256.New()
258
_, err = io.Copy(h, f)
259
f.Close()
260
if err != nil {
261
return err
262
}
263
e.SHA256 = hex.EncodeToString(h.Sum(nil))
264
}
265
idx[logical] = e
266
return nil
267
})
268
if err != nil && !errors.Is(err, fs.ErrNotExist) {
269
return err
270
}
271
return m.saveIndex(idx)
272
}
273
274
// HasPath zegt of een logisch pad in de kopie staat (voor tests en status).
275
func (m *Mirror) HasPath(prefix string) bool {
276
idx, _ := m.LoadIndex()
277
for p := range idx {
278
if strings.HasPrefix(p, prefix) {
279
return true
280
}
281
}
282
return false
283
}
@@ -0,0 +1,283 @@1
package mirror2
3
import (4
"context"5
"crypto/sha256"6
"encoding/hex"7
"encoding/json"8
"errors"9
"fmt"10
"io"11
"io/fs"12
"os"13
"path/filepath"14
"sort"15
"strings"16
"time"17
18
"git.timfalken.com/timfa/bluegit-backup/internal/protocol"19
)20
21
// Mirror is de draaiende kopie: Dir bevat de logische paden (state/…,22
// data/…). Index onthoudt per bestand grootte en mtime zoals BlueGit ze23
// meldde, zodat een volgende sync alleen wijzigingen ophaalt.24
type Mirror struct {25
Dir string26
Index string27
}28
29
// Stats zegt wat een sync deed.30
type Stats struct {31
Files int `json:"files"`32
Downloaded int `json:"downloaded"`33
Bytes int64 `json:"bytes"`34
Deleted int `json:"deleted"`35
Skipped int `json:"skipped"`36
}37
38
// LoadIndex leest de index. Geen bestand: leeg.39
func (m *Mirror) LoadIndex() (map[string]protocol.Entry, error) {40
idx := map[string]protocol.Entry{}41
b, err := os.ReadFile(m.Index)42
if errors.Is(err, os.ErrNotExist) {43
return idx, nil44
}45
if err != nil {46
return idx, err47
}48
return idx, json.Unmarshal(b, &idx)49
}50
51
func (m *Mirror) saveIndex(idx map[string]protocol.Entry) error {52
b, err := json.Marshal(idx)53
if err != nil {54
return err55
}56
tmp := m.Index + ".tmp"57
if err := os.WriteFile(tmp, b, 0o600); err != nil {58
return err59
}60
return os.Rename(tmp, m.Index)61
}62
63
// Empty zegt of de kopie nog niets bevat.64
func (m *Mirror) Empty() bool {65
idx, err := m.LoadIndex()66
return err != nil || len(idx) == 067
}68
69
// Size is de totale grootte volgens de index.70
func (m *Mirror) Size() int64 {71
idx, _ := m.LoadIndex()72
var n int6473
for _, e := range idx {74
n += e.Size75
}76
return n77
}78
79
// Wipe verwijdert de kopie en de index.80
func (m *Mirror) Wipe() error {81
if err := os.RemoveAll(m.Dir); err != nil {82
return err83
}84
err := os.Remove(m.Index)85
if errors.Is(err, os.ErrNotExist) {86
return nil87
}88
return err89
}90
91
func (m *Mirror) real(logical string) string {92
return filepath.Join(m.Dir, filepath.FromSlash(logical))93
}94
95
func same(a, b protocol.Entry) bool {96
if a.Path == protocol.DBPath || b.Path == protocol.DBPath {97
return a.SHA256 != "" && a.SHA256 == b.SHA256 && a.Size == b.Size98
}99
return a.Size == b.Size && a.MTime == b.MTime100
}101
102
// Sync haalt het manifest op en brengt de kopie gelijk: nieuwe en103
// gewijzigde bestanden downloaden (begrensd), verdwenen bestanden weg.104
func (m *Mirror) Sync(ctx context.Context, r *Remote) (Stats, error) {105
var st Stats106
man, err := r.Manifest(ctx)107
if err != nil {108
return st, err109
}110
idx, err := m.LoadIndex()111
if err != nil {112
idx = map[string]protocol.Entry{}113
}114
if err := os.MkdirAll(m.Dir, 0o750); err != nil {115
return st, err116
}117
tmpDir := filepath.Join(filepath.Dir(m.Dir), "tmp")118
if err := os.MkdirAll(tmpDir, 0o750); err != nil {119
return st, err120
}121
want := map[string]bool{}122
dirty := 0123
for _, e := range man.Files {124
logical, ok := protocol.CleanLogical(e.Path)125
if !ok {126
continue127
}128
want[logical] = true129
st.Files++130
if old, ok := idx[logical]; ok && same(old, e) {131
if _, err := os.Stat(m.real(logical)); err == nil {132
continue133
}134
}135
n, err := m.download(ctx, r, tmpDir, e)136
if errors.Is(err, ErrGone) {137
st.Skipped++138
want[logical] = false139
continue140
}141
if err != nil {142
_ = m.saveIndex(idx)143
return st, fmt.Errorf("%s: %w", logical, err)144
}145
idx[logical] = e146
st.Downloaded++147
st.Bytes += n148
dirty++149
if dirty >= 200 {150
_ = m.saveIndex(idx)151
dirty = 0152
}153
}154
for p := range idx {155
if !want[p] {156
_ = os.Remove(m.real(p))157
delete(idx, p)158
st.Deleted++159
}160
}161
// Ook bestanden die niet in de index stonden (een afgebroken download).162
_ = filepath.WalkDir(m.Dir, func(p string, d fs.DirEntry, err error) error {163
if err != nil || d.IsDir() {164
return nil165
}166
rel, _ := filepath.Rel(m.Dir, p)167
if _, ok := idx[filepath.ToSlash(rel)]; !ok {168
_ = os.Remove(p)169
}170
return nil171
})172
removeEmptyDirs(m.Dir)173
return st, m.saveIndex(idx)174
}175
176
func (m *Mirror) download(ctx context.Context, r *Remote, tmpDir string, e protocol.Entry) (int64, error) {177
rc, err := r.Fetch(ctx, e.Path)178
if err != nil {179
return 0, err180
}181
defer rc.Close()182
f, err := os.CreateTemp(tmpDir, "dl-*")183
if err != nil {184
return 0, err185
}186
tmp := f.Name()187
defer os.Remove(tmp)188
h := sha256.New()189
n, err := io.Copy(io.MultiWriter(f, h), rc)190
if cerr := f.Close(); err == nil {191
err = cerr192
}193
if err != nil {194
return n, err195
}196
if e.SHA256 != "" && hex.EncodeToString(h.Sum(nil)) != e.SHA256 {197
return n, errors.New("sha256 klopt niet")198
}199
mode := os.FileMode(e.Mode).Perm()200
if mode == 0 {201
mode = 0o640202
}203
_ = os.Chmod(tmp, mode|0o600)204
dst := m.real(e.Path)205
if err := os.MkdirAll(filepath.Dir(dst), 0o750); err != nil {206
return n, err207
}208
if err := os.Rename(tmp, dst); err != nil {209
return n, err210
}211
mt := time.UnixMilli(e.MTime)212
_ = os.Chtimes(dst, mt, mt)213
return n, nil214
}215
216
func removeEmptyDirs(root string) {217
var dirs []string218
_ = filepath.WalkDir(root, func(p string, d fs.DirEntry, err error) error {219
if err == nil && d.IsDir() && p != root {220
dirs = append(dirs, p)221
}222
return nil223
})224
sort.Slice(dirs, func(i, j int) bool { return len(dirs[i]) > len(dirs[j]) })225
for _, d := range dirs {226
_ = os.Remove(d) // faalt als hij niet leeg is227
}228
}229
230
// RebuildIndex maakt de index opnieuw uit de bestanden zelf, na het231
// uitpakken van een archief. De mtimes komen uit het archief en zijn232
// dezelfde die BlueGit na het terugzetten heeft.233
func (m *Mirror) RebuildIndex() error {234
idx := map[string]protocol.Entry{}235
err := filepath.WalkDir(m.Dir, func(p string, d fs.DirEntry, err error) error {236
if err != nil {237
return err238
}239
if d.IsDir() || !d.Type().IsRegular() {240
return nil241
}242
rel, _ := filepath.Rel(m.Dir, p)243
logical := filepath.ToSlash(rel)244
if _, ok := protocol.CleanLogical(logical); !ok {245
return nil246
}247
fi, err := d.Info()248
if err != nil {249
return err250
}251
e := protocol.Entry{Path: logical, Size: fi.Size(), MTime: fi.ModTime().UnixMilli(), Mode: uint32(fi.Mode().Perm())}252
if logical == protocol.DBPath {253
f, err := os.Open(p)254
if err != nil {255
return err256
}257
h := sha256.New()258
_, err = io.Copy(h, f)259
f.Close()260
if err != nil {261
return err262
}263
e.SHA256 = hex.EncodeToString(h.Sum(nil))264
}265
idx[logical] = e266
return nil267
})268
if err != nil && !errors.Is(err, fs.ErrNotExist) {269
return err270
}271
return m.saveIndex(idx)272
}273
274
// HasPath zegt of een logisch pad in de kopie staat (voor tests en status).275
func (m *Mirror) HasPath(prefix string) bool {276
idx, _ := m.LoadIndex()277
for p := range idx {278
if strings.HasPrefix(p, prefix) {279
return true280
}281
}282
return false283
}@@ -0,0 +1,153 @@
1
// Package mirror houdt de draaiende kopie van één BlueGit bij.
2
package mirror
3
4
import (
5
"bytes"
6
"context"
7
"encoding/json"
8
"errors"
9
"fmt"
10
"io"
11
"net/http"
12
"net/url"
13
"strings"
14
"time"
15
16
"git.timfalken.com/timfa/bluegit-backup/internal/protocol"
17
"git.timfalken.com/timfa/bluegit-backup/internal/throttle"
18
)
19
20
// ErrGone betekent dat een bestand tussen manifest en download verdween.
21
var ErrGone = errors.New("bestand verdwenen")
22
23
// Remote is de backup-API van één BlueGit, met de Backupserver-Key.
24
type Remote struct {
25
URL string
26
Key string
27
HTTP *http.Client
28
Limiter *throttle.Limiter
29
}
30
31
func (r *Remote) client() *http.Client {
32
if r.HTTP != nil {
33
return r.HTTP
34
}
35
return &http.Client{Timeout: 0}
36
}
37
38
func (r *Remote) req(ctx context.Context, method, p string, body io.Reader) (*http.Response, error) {
39
req, err := http.NewRequestWithContext(ctx, method, strings.TrimRight(r.URL, "/")+p, body)
40
if err != nil {
41
return nil, err
42
}
43
req.Header.Set("Authorization", "Bearer "+r.Key)
44
req.Header.Set("User-Agent", "bluegit-backup")
45
resp, err := r.client().Do(req)
46
if err != nil {
47
return nil, err
48
}
49
if resp.StatusCode >= 300 {
50
defer resp.Body.Close()
51
raw, _ := io.ReadAll(io.LimitReader(resp.Body, 1<<16))
52
var e struct {
53
Error string `json:"error"`
54
}
55
_ = json.Unmarshal(raw, &e)
56
if e.Error == "" {
57
e.Error = strings.TrimSpace(string(raw))
58
}
59
if resp.StatusCode == http.StatusNotFound && strings.HasPrefix(p, "/api/v1/backup/file") {
60
return nil, ErrGone
61
}
62
return nil, &HTTPError{Status: resp.StatusCode, Msg: e.Error}
63
}
64
return resp, nil
65
}
66
67
// HTTPError is een foutantwoord van BlueGit.
68
type HTTPError struct {
69
Status int
70
Msg string
71
}
72
73
func (e *HTTPError) Error() string { return fmt.Sprintf("BlueGit HTTP %d: %s", e.Status, e.Msg) }
74
75
func (r *Remote) getJSON(ctx context.Context, p string, out any) error {
76
resp, err := r.req(ctx, http.MethodGet, p, nil)
77
if err != nil {
78
return err
79
}
80
defer resp.Body.Close()
81
return json.NewDecoder(resp.Body).Decode(out)
82
}
83
84
// Info vraagt het instance-id op en controleert zo ook de key.
85
func (r *Remote) Info(ctx context.Context) (protocol.Info, error) {
86
var out protocol.Info
87
err := r.getJSON(ctx, "/api/v1/backup/info", &out)
88
return out, err
89
}
90
91
// Connect vertelt BlueGit waar deze server bereikbaar is.
92
func (r *Remote) Connect(ctx context.Context, publicURL, serverID string) error {
93
b, _ := json.Marshal(map[string]string{"server_url": publicURL, "server_id": serverID})
94
resp, err := r.req(ctx, http.MethodPost, "/api/v1/backup/connect", bytes.NewReader(b))
95
if err != nil {
96
return err
97
}
98
resp.Body.Close()
99
return nil
100
}
101
102
// Manifest vraagt de volledige lijst op. BlueGit maakt daarbij een nieuwe
103
// databasekopie.
104
func (r *Remote) Manifest(ctx context.Context) (protocol.Manifest, error) {
105
var out protocol.Manifest
106
err := r.getJSON(ctx, "/api/v1/backup/manifest", &out)
107
return out, err
108
}
109
110
// Fetch opent één bestand, begrensd door de limiter.
111
func (r *Remote) Fetch(ctx context.Context, logical string) (io.ReadCloser, error) {
112
resp, err := r.req(ctx, http.MethodGet, "/api/v1/backup/file?path="+url.QueryEscape(logical), nil)
113
if err != nil {
114
return nil, err
115
}
116
return struct {
117
io.Reader
118
io.Closer
119
}{r.Limiter.Reader(ctx, resp.Body), resp.Body}, nil
120
}
121
122
// Restore stuurt een tar.gz naar BlueGit. BlueGit herstart daarna.
123
func (r *Remote) Restore(ctx context.Context, body io.Reader) error {
124
resp, err := r.req(ctx, http.MethodPost, "/api/v1/backup/restore", body)
125
if err != nil {
126
return err
127
}
128
resp.Body.Close()
129
return nil
130
}
131
132
// WaitUp wacht tot BlueGit na een herstart weer antwoordt.
133
func (r *Remote) WaitUp(ctx context.Context, timeout time.Duration) error {
134
deadline := time.Now().Add(timeout)
135
// Eerst kort wachten: BlueGit herstart pas na zijn 202.
136
time.Sleep(500 * time.Millisecond)
137
for {
138
c, cancel := context.WithTimeout(ctx, 3*time.Second)
139
_, err := r.Info(c)
140
cancel()
141
if err == nil {
142
return nil
143
}
144
if time.Now().After(deadline) {
145
return fmt.Errorf("BlueGit kwam niet terug: %w", err)
146
}
147
select {
148
case <-ctx.Done():
149
return ctx.Err()
150
case <-time.After(300 * time.Millisecond):
151
}
152
}
153
}
@@ -0,0 +1,153 @@1
// Package mirror houdt de draaiende kopie van één BlueGit bij.2
package mirror3
4
import (5
"bytes"6
"context"7
"encoding/json"8
"errors"9
"fmt"10
"io"11
"net/http"12
"net/url"13
"strings"14
"time"15
16
"git.timfalken.com/timfa/bluegit-backup/internal/protocol"17
"git.timfalken.com/timfa/bluegit-backup/internal/throttle"18
)19
20
// ErrGone betekent dat een bestand tussen manifest en download verdween.21
var ErrGone = errors.New("bestand verdwenen")22
23
// Remote is de backup-API van één BlueGit, met de Backupserver-Key.24
type Remote struct {25
URL string26
Key string27
HTTP *http.Client28
Limiter *throttle.Limiter29
}30
31
func (r *Remote) client() *http.Client {32
if r.HTTP != nil {33
return r.HTTP34
}35
return &http.Client{Timeout: 0}36
}37
38
func (r *Remote) req(ctx context.Context, method, p string, body io.Reader) (*http.Response, error) {39
req, err := http.NewRequestWithContext(ctx, method, strings.TrimRight(r.URL, "/")+p, body)40
if err != nil {41
return nil, err42
}43
req.Header.Set("Authorization", "Bearer "+r.Key)44
req.Header.Set("User-Agent", "bluegit-backup")45
resp, err := r.client().Do(req)46
if err != nil {47
return nil, err48
}49
if resp.StatusCode >= 300 {50
defer resp.Body.Close()51
raw, _ := io.ReadAll(io.LimitReader(resp.Body, 1<<16))52
var e struct {53
Error string `json:"error"`54
}55
_ = json.Unmarshal(raw, &e)56
if e.Error == "" {57
e.Error = strings.TrimSpace(string(raw))58
}59
if resp.StatusCode == http.StatusNotFound && strings.HasPrefix(p, "/api/v1/backup/file") {60
return nil, ErrGone61
}62
return nil, &HTTPError{Status: resp.StatusCode, Msg: e.Error}63
}64
return resp, nil65
}66
67
// HTTPError is een foutantwoord van BlueGit.68
type HTTPError struct {69
Status int70
Msg string71
}72
73
func (e *HTTPError) Error() string { return fmt.Sprintf("BlueGit HTTP %d: %s", e.Status, e.Msg) }74
75
func (r *Remote) getJSON(ctx context.Context, p string, out any) error {76
resp, err := r.req(ctx, http.MethodGet, p, nil)77
if err != nil {78
return err79
}80
defer resp.Body.Close()81
return json.NewDecoder(resp.Body).Decode(out)82
}83
84
// Info vraagt het instance-id op en controleert zo ook de key.85
func (r *Remote) Info(ctx context.Context) (protocol.Info, error) {86
var out protocol.Info87
err := r.getJSON(ctx, "/api/v1/backup/info", &out)88
return out, err89
}90
91
// Connect vertelt BlueGit waar deze server bereikbaar is.92
func (r *Remote) Connect(ctx context.Context, publicURL, serverID string) error {93
b, _ := json.Marshal(map[string]string{"server_url": publicURL, "server_id": serverID})94
resp, err := r.req(ctx, http.MethodPost, "/api/v1/backup/connect", bytes.NewReader(b))95
if err != nil {96
return err97
}98
resp.Body.Close()99
return nil100
}101
102
// Manifest vraagt de volledige lijst op. BlueGit maakt daarbij een nieuwe103
// databasekopie.104
func (r *Remote) Manifest(ctx context.Context) (protocol.Manifest, error) {105
var out protocol.Manifest106
err := r.getJSON(ctx, "/api/v1/backup/manifest", &out)107
return out, err108
}109
110
// Fetch opent één bestand, begrensd door de limiter.111
func (r *Remote) Fetch(ctx context.Context, logical string) (io.ReadCloser, error) {112
resp, err := r.req(ctx, http.MethodGet, "/api/v1/backup/file?path="+url.QueryEscape(logical), nil)113
if err != nil {114
return nil, err115
}116
return struct {117
io.Reader118
io.Closer119
}{r.Limiter.Reader(ctx, resp.Body), resp.Body}, nil120
}121
122
// Restore stuurt een tar.gz naar BlueGit. BlueGit herstart daarna.123
func (r *Remote) Restore(ctx context.Context, body io.Reader) error {124
resp, err := r.req(ctx, http.MethodPost, "/api/v1/backup/restore", body)125
if err != nil {126
return err127
}128
resp.Body.Close()129
return nil130
}131
132
// WaitUp wacht tot BlueGit na een herstart weer antwoordt.133
func (r *Remote) WaitUp(ctx context.Context, timeout time.Duration) error {134
deadline := time.Now().Add(timeout)135
// Eerst kort wachten: BlueGit herstart pas na zijn 202.136
time.Sleep(500 * time.Millisecond)137
for {138
c, cancel := context.WithTimeout(ctx, 3*time.Second)139
_, err := r.Info(c)140
cancel()141
if err == nil {142
return nil143
}144
if time.Now().After(deadline) {145
return fmt.Errorf("BlueGit kwam niet terug: %w", err)146
}147
select {148
case <-ctx.Done():149
return ctx.Err()150
case <-time.After(300 * time.Millisecond):151
}152
}153
}@@ -0,0 +1,150 @@
1
// Package protocol is het draadformaat tussen BlueGit en bluegit-backup.
2
// Het moet gelijk blijven aan internal/backup in BlueGit (docs/BACKUP.md).
3
package protocol
4
5
import (
6
"crypto/hmac"
7
"crypto/sha256"
8
"encoding/hex"
9
"errors"
10
"net/http"
11
"path"
12
"strconv"
13
"strings"
14
"time"
15
)
16
17
// KeyPrefix staat voor elke Backupserver-Key.
18
const KeyPrefix = "bgbk_"
19
20
// Koppen van een ondertekend verzoek van BlueGit.
21
const (
22
HeaderInstance = "X-BlueGit-Instance"
23
HeaderTimestamp = "X-BlueGit-Timestamp"
24
HeaderSignature = "X-BlueGit-Signature"
25
)
26
27
// MaxSkew is hoe ver de klokken uit elkaar mogen lopen.
28
const MaxSkew = 5 * time.Minute
29
30
// DBPath is het logische pad van de databasekopie.
31
const DBPath = "state/bluegit.db"
32
33
// Entry is één bestand in het manifest van BlueGit.
34
type Entry struct {
35
Path string `json:"path"`
36
Size int64 `json:"size"`
37
MTime int64 `json:"mtime"`
38
Mode uint32 `json:"mode"`
39
SHA256 string `json:"sha256,omitempty"`
40
}
41
42
// Manifest is de volledige lijst op één moment.
43
type Manifest struct {
44
Instance string `json:"instance_id"`
45
CreatedAt time.Time `json:"created_at"`
46
Files []Entry `json:"files"`
47
}
48
49
// Info is GET /api/v1/backup/info.
50
type Info struct {
51
InstanceID string `json:"instance_id"`
52
BaseURL string `json:"base_url"`
53
ServerURL string `json:"server_url"`
54
ServerID string `json:"server_id"`
55
HasStorage bool `json:"has_storage"`
56
}
57
58
// SigningSecret leidt het HMAC-geheim af uit de key.
59
func SigningSecret(key string) string {
60
s := sha256.Sum256([]byte("bluegit-backup-sign:" + key))
61
return hex.EncodeToString(s[:])
62
}
63
64
// Signature is hex(HMAC-SHA256(secret, METHOD \n PATH \n TS \n sha256hex(body))).
65
func Signature(secret, method, p, ts string, body []byte) string {
66
sum := sha256.Sum256(body)
67
mac := hmac.New(sha256.New, []byte(secret))
68
mac.Write([]byte(strings.ToUpper(method) + "\n" + p + "\n" + ts + "\n" + hex.EncodeToString(sum[:])))
69
return hex.EncodeToString(mac.Sum(nil))
70
}
71
72
// Sign zet de koppen op een uitgaand verzoek (gebruikt in tests en door
73
// BlueGit zelf).
74
func Sign(req *http.Request, secret, instance string, body []byte, now time.Time) {
75
ts := strconv.FormatInt(now.Unix(), 10)
76
req.Header.Set(HeaderInstance, instance)
77
req.Header.Set(HeaderTimestamp, ts)
78
req.Header.Set(HeaderSignature, Signature(secret, req.Method, req.URL.Path, ts, body))
79
}
80
81
// Verify controleert een binnenkomend ondertekend verzoek.
82
func Verify(r *http.Request, secret string, body []byte, now time.Time) error {
83
ts := r.Header.Get(HeaderTimestamp)
84
n, err := strconv.ParseInt(ts, 10, 64)
85
if err != nil {
86
return errors.New("timestamp ontbreekt")
87
}
88
d := now.Sub(time.Unix(n, 0))
89
if d < 0 {
90
d = -d
91
}
92
if d > MaxSkew {
93
return errors.New("timestamp te oud of in de toekomst")
94
}
95
want := Signature(secret, r.Method, r.URL.Path, ts, body)
96
if !hmac.Equal([]byte(want), []byte(r.Header.Get(HeaderSignature))) {
97
return errors.New("handtekening klopt niet")
98
}
99
return nil
100
}
101
102
var (
103
stateFiles = []string{"bluegit.db", "secret.key"}
104
stateDirs = []string{"ssh", "logos", "avatars"}
105
dataDirs = []string{"repos", "releases", "artifacts"}
106
)
107
108
// CleanLogical controleert een logisch pad zoals BlueGit dat doet. Een pad
109
// buiten de bekende mappen komt nooit in de kopie.
110
func CleanLogical(p string) (string, bool) {
111
if p == "" || strings.Contains(p, "\\") || strings.ContainsRune(p, 0) || strings.HasPrefix(p, "/") {
112
return "", false
113
}
114
c := path.Clean(p)
115
if c != p || c == "." {
116
return "", false
117
}
118
parts := strings.Split(c, "/")
119
for _, part := range parts {
120
if part == ".." || part == "." || part == "" {
121
return "", false
122
}
123
}
124
if len(parts) < 2 {
125
return "", false
126
}
127
switch parts[0] {
128
case "state":
129
if len(parts) == 2 && has(stateFiles, parts[1]) {
130
return c, true
131
}
132
if len(parts) >= 3 && has(stateDirs, parts[1]) {
133
return c, true
134
}
135
case "data":
136
if len(parts) >= 3 && has(dataDirs, parts[1]) && parts[2] != ".incoming" {
137
return c, true
138
}
139
}
140
return "", false
141
}
142
143
func has(list []string, v string) bool {
144
for _, x := range list {
145
if x == v {
146
return true
147
}
148
}
149
return false
150
}
@@ -0,0 +1,150 @@1
// Package protocol is het draadformaat tussen BlueGit en bluegit-backup.2
// Het moet gelijk blijven aan internal/backup in BlueGit (docs/BACKUP.md).3
package protocol4
5
import (6
"crypto/hmac"7
"crypto/sha256"8
"encoding/hex"9
"errors"10
"net/http"11
"path"12
"strconv"13
"strings"14
"time"15
)16
17
// KeyPrefix staat voor elke Backupserver-Key.18
const KeyPrefix = "bgbk_"19
20
// Koppen van een ondertekend verzoek van BlueGit.21
const (22
HeaderInstance = "X-BlueGit-Instance"23
HeaderTimestamp = "X-BlueGit-Timestamp"24
HeaderSignature = "X-BlueGit-Signature"25
)26
27
// MaxSkew is hoe ver de klokken uit elkaar mogen lopen.28
const MaxSkew = 5 * time.Minute29
30
// DBPath is het logische pad van de databasekopie.31
const DBPath = "state/bluegit.db"32
33
// Entry is één bestand in het manifest van BlueGit.34
type Entry struct {35
Path string `json:"path"`36
Size int64 `json:"size"`37
MTime int64 `json:"mtime"`38
Mode uint32 `json:"mode"`39
SHA256 string `json:"sha256,omitempty"`40
}41
42
// Manifest is de volledige lijst op één moment.43
type Manifest struct {44
Instance string `json:"instance_id"`45
CreatedAt time.Time `json:"created_at"`46
Files []Entry `json:"files"`47
}48
49
// Info is GET /api/v1/backup/info.50
type Info struct {51
InstanceID string `json:"instance_id"`52
BaseURL string `json:"base_url"`53
ServerURL string `json:"server_url"`54
ServerID string `json:"server_id"`55
HasStorage bool `json:"has_storage"`56
}57
58
// SigningSecret leidt het HMAC-geheim af uit de key.59
func SigningSecret(key string) string {60
s := sha256.Sum256([]byte("bluegit-backup-sign:" + key))61
return hex.EncodeToString(s[:])62
}63
64
// Signature is hex(HMAC-SHA256(secret, METHOD \n PATH \n TS \n sha256hex(body))).65
func Signature(secret, method, p, ts string, body []byte) string {66
sum := sha256.Sum256(body)67
mac := hmac.New(sha256.New, []byte(secret))68
mac.Write([]byte(strings.ToUpper(method) + "\n" + p + "\n" + ts + "\n" + hex.EncodeToString(sum[:])))69
return hex.EncodeToString(mac.Sum(nil))70
}71
72
// Sign zet de koppen op een uitgaand verzoek (gebruikt in tests en door73
// BlueGit zelf).74
func Sign(req *http.Request, secret, instance string, body []byte, now time.Time) {75
ts := strconv.FormatInt(now.Unix(), 10)76
req.Header.Set(HeaderInstance, instance)77
req.Header.Set(HeaderTimestamp, ts)78
req.Header.Set(HeaderSignature, Signature(secret, req.Method, req.URL.Path, ts, body))79
}80
81
// Verify controleert een binnenkomend ondertekend verzoek.82
func Verify(r *http.Request, secret string, body []byte, now time.Time) error {83
ts := r.Header.Get(HeaderTimestamp)84
n, err := strconv.ParseInt(ts, 10, 64)85
if err != nil {86
return errors.New("timestamp ontbreekt")87
}88
d := now.Sub(time.Unix(n, 0))89
if d < 0 {90
d = -d91
}92
if d > MaxSkew {93
return errors.New("timestamp te oud of in de toekomst")94
}95
want := Signature(secret, r.Method, r.URL.Path, ts, body)96
if !hmac.Equal([]byte(want), []byte(r.Header.Get(HeaderSignature))) {97
return errors.New("handtekening klopt niet")98
}99
return nil100
}101
102
var (103
stateFiles = []string{"bluegit.db", "secret.key"}104
stateDirs = []string{"ssh", "logos", "avatars"}105
dataDirs = []string{"repos", "releases", "artifacts"}106
)107
108
// CleanLogical controleert een logisch pad zoals BlueGit dat doet. Een pad109
// buiten de bekende mappen komt nooit in de kopie.110
func CleanLogical(p string) (string, bool) {111
if p == "" || strings.Contains(p, "\\") || strings.ContainsRune(p, 0) || strings.HasPrefix(p, "/") {112
return "", false113
}114
c := path.Clean(p)115
if c != p || c == "." {116
return "", false117
}118
parts := strings.Split(c, "/")119
for _, part := range parts {120
if part == ".." || part == "." || part == "" {121
return "", false122
}123
}124
if len(parts) < 2 {125
return "", false126
}127
switch parts[0] {128
case "state":129
if len(parts) == 2 && has(stateFiles, parts[1]) {130
return c, true131
}132
if len(parts) >= 3 && has(stateDirs, parts[1]) {133
return c, true134
}135
case "data":136
if len(parts) >= 3 && has(dataDirs, parts[1]) && parts[2] != ".incoming" {137
return c, true138
}139
}140
return "", false141
}142
143
func has(list []string, v string) bool {144
for _, x := range list {145
if x == v {146
return true147
}148
}149
return false150
}@@ -0,0 +1,46 @@
1
package protocol
2
3
import (
4
"bytes"
5
"net/http"
6
"testing"
7
"time"
8
)
9
10
// Vaste vector: moet gelijk blijven aan internal/backup in BlueGit.
11
func TestSignatureVector(t *testing.T) {
12
sec := SigningSecret("bgbk_test")
13
if sec != "c04d0bdbac2260c010f61c9b063b28026eed1d2292c928708708821449e72c2a" {
14
t.Fatalf("geheim %s", sec)
15
}
16
if got := Signature(sec, "post", "/api/v1/notify", "1800000000", []byte("{}")); got != "51c5ec72528304632383637b99dfda1e14b68194bbec2d4faa36c9d5ef892548" {
17
t.Fatalf("handtekening %s", got)
18
}
19
}
20
21
func TestVerify(t *testing.T) {
22
sec := SigningSecret("bgbk_x")
23
now := time.Unix(1_800_000_000, 0)
24
body := []byte(`{"archive":"a"}`)
25
req, _ := http.NewRequest("POST", "http://b/api/v1/rollback", bytes.NewReader(body))
26
Sign(req, sec, "i", body, now)
27
if err := Verify(req, sec, body, now); err != nil {
28
t.Fatal(err)
29
}
30
if Verify(req, sec, []byte("{}"), now) == nil || Verify(req, sec, body, now.Add(6*time.Minute)) == nil || Verify(req, "x", body, now) == nil {
31
t.Fatal("vervalsing geaccepteerd")
32
}
33
}
34
35
func TestCleanLogical(t *testing.T) {
36
for _, p := range []string{"state/bluegit.db", "data/repos/a/b.git/HEAD", "state/ssh/k"} {
37
if _, ok := CleanLogical(p); !ok {
38
t.Error(p)
39
}
40
}
41
for _, p := range []string{"state/backup.json", "../x", "data/work/x", "data/releases/.incoming/a", "/x", "state/./bluegit.db"} {
42
if _, ok := CleanLogical(p); ok {
43
t.Error(p)
44
}
45
}
46
}
@@ -0,0 +1,46 @@1
package protocol2
3
import (4
"bytes"5
"net/http"6
"testing"7
"time"8
)9
10
// Vaste vector: moet gelijk blijven aan internal/backup in BlueGit.11
func TestSignatureVector(t *testing.T) {12
sec := SigningSecret("bgbk_test")13
if sec != "c04d0bdbac2260c010f61c9b063b28026eed1d2292c928708708821449e72c2a" {14
t.Fatalf("geheim %s", sec)15
}16
if got := Signature(sec, "post", "/api/v1/notify", "1800000000", []byte("{}")); got != "51c5ec72528304632383637b99dfda1e14b68194bbec2d4faa36c9d5ef892548" {17
t.Fatalf("handtekening %s", got)18
}19
}20
21
func TestVerify(t *testing.T) {22
sec := SigningSecret("bgbk_x")23
now := time.Unix(1_800_000_000, 0)24
body := []byte(`{"archive":"a"}`)25
req, _ := http.NewRequest("POST", "http://b/api/v1/rollback", bytes.NewReader(body))26
Sign(req, sec, "i", body, now)27
if err := Verify(req, sec, body, now); err != nil {28
t.Fatal(err)29
}30
if Verify(req, sec, []byte("{}"), now) == nil || Verify(req, sec, body, now.Add(6*time.Minute)) == nil || Verify(req, "x", body, now) == nil {31
t.Fatal("vervalsing geaccepteerd")32
}33
}34
35
func TestCleanLogical(t *testing.T) {36
for _, p := range []string{"state/bluegit.db", "data/repos/a/b.git/HEAD", "state/ssh/k"} {37
if _, ok := CleanLogical(p); !ok {38
t.Error(p)39
}40
}41
for _, p := range []string{"state/backup.json", "../x", "data/work/x", "data/releases/.incoming/a", "/x", "state/./bluegit.db"} {42
if _, ok := CleanLogical(p); ok {43
t.Error(p)44
}45
}46
}@@ -0,0 +1,741 @@
1
// Package server is de backup server: sync, archieven, de API voor BlueGit
2
// en de lokale beheer-API.
3
package server
4
5
import (
6
"context"
7
"crypto/subtle"
8
"encoding/json"
9
"errors"
10
"fmt"
11
"io"
12
"log/slog"
13
"net/http"
14
"os"
15
"path/filepath"
16
"strings"
17
"sync"
18
"time"
19
20
"git.timfalken.com/timfa/bluegit-backup/internal/archive"
21
"git.timfalken.com/timfa/bluegit-backup/internal/config"
22
"git.timfalken.com/timfa/bluegit-backup/internal/mirror"
23
"git.timfalken.com/timfa/bluegit-backup/internal/protocol"
24
"git.timfalken.com/timfa/bluegit-backup/internal/throttle"
25
)
26
27
// Version wordt bij het bouwen gezet (-ldflags -X).
28
var Version = "dev"
29
30
// Server is één backup server voor één BlueGit.
31
type Server struct {
32
Cfg config.Config
33
Log *slog.Logger
34
// Now is de klok (tests).
35
Now func() time.Time
36
// HTTP is de client richting BlueGit (tests).
37
HTTP *http.Client
38
39
adminToken string
40
serverID string
41
limiter *throttle.Limiter
42
mirror *mirror.Mirror
43
archives *archive.Store
44
45
// work beschermt de kopie: sync, archiveren, rollback en koppelen
46
// gebeuren nooit tegelijk.
47
work sync.Mutex
48
49
mu sync.Mutex
50
state State
51
lastSync time.Time
52
lastSyncErr string
53
lastStats mirror.Stats
54
syncs int
55
notifies int
56
lastArchive time.Time
57
archiveErr string
58
rollback RollbackStatus
59
60
kick chan struct{}
61
}
62
63
// RollbackStatus is de stand van de laatste rollback of restore.
64
type RollbackStatus struct {
65
State string `json:"state"` // idle | running | done | failed
66
Archive string `json:"archive,omitempty"`
67
Error string `json:"error,omitempty"`
68
At time.Time `json:"at,omitempty"`
69
}
70
71
// New zet de mappen klaar en leest de koppeling.
72
func New(cfg config.Config, log *slog.Logger) (*Server, error) {
73
if log == nil {
74
log = slog.New(slog.NewTextHandler(io.Discard, nil))
75
}
76
if err := os.MkdirAll(cfg.DataDir, 0o750); err != nil {
77
return nil, err
78
}
79
s := &Server{Cfg: cfg, Log: log, Now: time.Now, kick: make(chan struct{}, 1)}
80
var err error
81
if s.adminToken, err = secretFile(cfg.DataDir, "admin.token", "bba_"); err != nil {
82
return nil, err
83
}
84
if s.serverID, err = secretFile(cfg.DataDir, "server_id", ""); err != nil {
85
return nil, err
86
}
87
if s.state, err = loadState(cfg.DataDir); err != nil {
88
return nil, err
89
}
90
s.limiter = throttle.New(cfg.RateLimitKiB << 10)
91
s.mirror = &mirror.Mirror{Dir: filepath.Join(cfg.DataDir, "mirror"), Index: filepath.Join(cfg.DataDir, "mirror.index.json")}
92
s.archives = &archive.Store{Dir: filepath.Join(cfg.DataDir, "archives")}
93
_ = os.RemoveAll(filepath.Join(cfg.DataDir, "tmp"))
94
if list, _ := s.archives.List(); len(list) > 0 {
95
s.lastArchive = list[0].CreatedAt
96
}
97
s.rollback.State = "idle"
98
return s, nil
99
}
100
101
// SetFree vervangt de vrije-ruimtemeting (tests).
102
func (s *Server) SetFree(f func(string) (uint64, error)) { s.archives.Free = f }
103
104
// AdminToken is het lokale beheertoken.
105
func (s *Server) AdminToken() string { return s.adminToken }
106
107
func (s *Server) now() time.Time { return s.Now() }
108
109
func (s *Server) remote(st State) *mirror.Remote {
110
return &mirror.Remote{URL: st.BlueGitURL, Key: st.Key, HTTP: s.HTTP, Limiter: s.limiter}
111
}
112
113
func (s *Server) getState() State {
114
s.mu.Lock()
115
defer s.mu.Unlock()
116
return s.state
117
}
118
119
// Run start de achtergrondtaken tot ctx klaar is.
120
func (s *Server) Run(ctx context.Context) {
121
go s.syncLoop(ctx)
122
go s.archiveLoop(ctx)
123
}
124
125
// Kick vraagt om een sync (na een melding).
126
func (s *Server) Kick() {
127
select {
128
case s.kick <- struct{}{}:
129
default:
130
}
131
}
132
133
func (s *Server) syncLoop(ctx context.Context) {
134
full := time.NewTicker(s.Cfg.FullSyncInterval.Duration)
135
defer full.Stop()
136
s.Kick() // meteen na de start
137
for {
138
select {
139
case <-ctx.Done():
140
return
141
case <-full.C:
142
case <-s.kick:
143
}
144
s.mu.Lock()
145
wait := s.Cfg.MinSyncInterval.Duration - s.now().Sub(s.lastSync)
146
s.mu.Unlock()
147
if wait > 0 {
148
select {
149
case <-ctx.Done():
150
return
151
case <-time.After(wait):
152
}
153
}
154
// Meldingen die in de tussentijd binnenkwamen, zitten in deze sync.
155
select {
156
case <-s.kick:
157
default:
158
}
159
_, _ = s.SyncNow(ctx)
160
}
161
}
162
163
// SyncNow synchroniseert één keer.
164
func (s *Server) SyncNow(ctx context.Context) (mirror.Stats, error) {
165
st := s.getState()
166
if !st.Connected() {
167
return mirror.Stats{}, errors.New("geen BlueGit gekoppeld")
168
}
169
s.work.Lock()
170
defer s.work.Unlock()
171
st = s.getState()
172
if !st.Connected() {
173
return mirror.Stats{}, errors.New("geen BlueGit gekoppeld")
174
}
175
stats, err := s.mirror.Sync(ctx, s.remote(st))
176
s.mu.Lock()
177
s.lastSync = s.now()
178
s.syncs++
179
s.lastStats = stats
180
if err != nil {
181
s.lastSyncErr = err.Error()
182
} else {
183
s.lastSyncErr = ""
184
}
185
s.mu.Unlock()
186
if err != nil {
187
s.Log.Warn("sync mislukt", "err", err)
188
} else if stats.Downloaded > 0 || stats.Deleted > 0 {
189
s.Log.Info("sync", "files", stats.Files, "downloaded", stats.Downloaded, "bytes", stats.Bytes, "deleted", stats.Deleted)
190
}
191
return stats, err
192
}
193
194
func (s *Server) archiveLoop(ctx context.Context) {
195
t := time.NewTicker(s.tick())
196
defer t.Stop()
197
for {
198
select {
199
case <-ctx.Done():
200
return
201
case <-t.C:
202
}
203
s.mu.Lock()
204
due := s.now().Sub(s.lastArchive) >= s.Cfg.ArchiveInterval.Duration
205
synced := !s.lastSync.IsZero() && s.lastSyncErr == ""
206
s.mu.Unlock()
207
if due && synced {
208
if _, err := s.ArchiveNow(); err != nil {
209
s.Log.Warn("archief mislukt", "err", err)
210
}
211
}
212
if _, err := s.Prune(); err != nil {
213
s.Log.Warn("opruimen mislukt", "err", err)
214
}
215
}
216
}
217
218
// tick is hoe vaak de archieflus kijkt: een minuut, of korter bij een kort interval.
219
func (s *Server) tick() time.Duration {
220
d := s.Cfg.ArchiveInterval.Duration / 4
221
if d > time.Minute {
222
d = time.Minute
223
}
224
if d < 100*time.Millisecond {
225
d = 100 * time.Millisecond
226
}
227
return d
228
}
229
230
// ArchiveNow comprimeert de hele kopie tot een nieuw archief.
231
func (s *Server) ArchiveNow() (archive.Archive, error) {
232
s.work.Lock()
233
defer s.work.Unlock()
234
if s.mirror.Empty() {
235
return archive.Archive{}, errors.New("de kopie is nog leeg")
236
}
237
now := s.now()
238
a, removed, err := s.archives.Create(s.mirror.Dir, now, s.mirror.Size(), s.minFree())
239
s.mu.Lock()
240
if err != nil {
241
s.archiveErr = err.Error()
242
} else {
243
s.archiveErr = ""
244
s.lastArchive = now
245
}
246
s.mu.Unlock()
247
for _, r := range removed {
248
s.Log.Info("archief verwijderd: schijf vol", "archive", r)
249
}
250
if err != nil {
251
return a, err
252
}
253
s.Log.Info("archief gemaakt", "archive", a.Name, "bytes", a.Size)
254
if pr, err := s.archives.Prune(now, s.Cfg.RetentionDays, s.minFree()); err == nil {
255
for _, r := range pr {
256
s.Log.Info("archief verwijderd", "archive", r)
257
}
258
}
259
return a, nil
260
}
261
262
func (s *Server) minFree() uint64 { return uint64(s.Cfg.MinFreeMB) << 20 }
263
264
// Prune past de bewaarregels toe.
265
func (s *Server) Prune() ([]string, error) {
266
s.work.Lock()
267
defer s.work.Unlock()
268
removed, err := s.archives.Prune(s.now(), s.Cfg.RetentionDays, s.minFree())
269
for _, r := range removed {
270
s.Log.Info("archief verwijderd", "archive", r)
271
}
272
return removed, err
273
}
274
275
// ---------- HTTP ----------
276
277
// Handler is de HTTP-API.
278
func (s *Server) Handler() http.Handler {
279
mux := http.NewServeMux()
280
mux.HandleFunc("GET /healthz", func(w http.ResponseWriter, r *http.Request) { _, _ = w.Write([]byte("ok\n")) })
281
// Van BlueGit, ondertekend.
282
mux.HandleFunc("POST /api/v1/notify", s.signed(s.apiNotify))
283
mux.HandleFunc("GET /api/v1/archives", s.signed(s.apiArchives))
284
mux.HandleFunc("GET /api/v1/status", s.signed(s.apiStatus))
285
mux.HandleFunc("POST /api/v1/rollback", s.signed(s.apiRollback))
286
// Lokaal beheer, met admin.token.
287
mux.HandleFunc("GET /api/v1/admin/status", s.admin(s.apiStatus))
288
mux.HandleFunc("GET /api/v1/admin/archives", s.admin(s.apiArchives))
289
mux.HandleFunc("POST /api/v1/admin/connect", s.admin(s.apiConnect))
290
mux.HandleFunc("POST /api/v1/admin/sync", s.admin(s.apiSync))
291
mux.HandleFunc("POST /api/v1/admin/archive", s.admin(s.apiArchiveNow))
292
mux.HandleFunc("POST /api/v1/admin/prune", s.admin(s.apiPrune))
293
mux.HandleFunc("POST /api/v1/admin/self-update", s.selfUpdate)
294
return mux
295
}
296
297
func writeJSON(w http.ResponseWriter, code int, v any) {
298
w.Header().Set("Content-Type", "application/json")
299
w.Header().Set("Cache-Control", "no-store")
300
w.WriteHeader(code)
301
if v != nil {
302
_ = json.NewEncoder(w).Encode(v)
303
}
304
}
305
306
func writeErr(w http.ResponseWriter, code int, msg string) {
307
writeJSON(w, code, map[string]string{"error": msg})
308
}
309
310
type ctxBody struct{}
311
312
// signed controleert de HMAC-handtekening van de gekoppelde BlueGit.
313
func (s *Server) signed(h http.HandlerFunc) http.HandlerFunc {
314
return func(w http.ResponseWriter, r *http.Request) {
315
st := s.getState()
316
if !st.Connected() {
317
writeErr(w, http.StatusUnauthorized, "niet gekoppeld")
318
return
319
}
320
body, err := io.ReadAll(io.LimitReader(r.Body, 1<<20))
321
if err != nil {
322
writeErr(w, 400, "body")
323
return
324
}
325
if r.Header.Get(protocol.HeaderInstance) != st.InstanceID {
326
writeErr(w, http.StatusUnauthorized, "andere BlueGit-instantie")
327
return
328
}
329
if err := protocol.Verify(r, protocol.SigningSecret(st.Key), body, s.now()); err != nil {
330
writeErr(w, http.StatusUnauthorized, err.Error())
331
return
332
}
333
r = r.WithContext(context.WithValue(r.Context(), ctxBody{}, body))
334
h(w, r)
335
}
336
}
337
338
func bodyOf(r *http.Request) []byte {
339
if b, ok := r.Context().Value(ctxBody{}).([]byte); ok {
340
return b
341
}
342
b, _ := io.ReadAll(io.LimitReader(r.Body, 1<<20))
343
return b
344
}
345
346
func (s *Server) admin(h http.HandlerFunc) http.HandlerFunc {
347
return func(w http.ResponseWriter, r *http.Request) {
348
tok := strings.TrimSpace(strings.TrimPrefix(r.Header.Get("Authorization"), "Bearer "))
349
if subtle.ConstantTimeCompare([]byte(tok), []byte(s.adminToken)) != 1 {
350
writeErr(w, http.StatusUnauthorized, "admin.token nodig")
351
return
352
}
353
h(w, r)
354
}
355
}
356
357
func (s *Server) apiNotify(w http.ResponseWriter, r *http.Request) {
358
s.mu.Lock()
359
s.notifies++
360
s.mu.Unlock()
361
s.Kick()
362
w.WriteHeader(http.StatusNoContent)
363
}
364
365
func (s *Server) apiArchives(w http.ResponseWriter, r *http.Request) {
366
list, err := s.archives.List()
367
if err != nil {
368
writeErr(w, 500, err.Error())
369
return
370
}
371
writeJSON(w, 200, map[string]any{"archives": list})
372
}
373
374
// Status is wat GET /api/v1/status en de CLI tonen.
375
type Status struct {
376
Version string `json:"version"`
377
ServerID string `json:"server_id"`
378
BlueGitURL string `json:"bluegit_url,omitempty"`
379
InstanceID string `json:"instance_id,omitempty"`
380
Connected bool `json:"connected"`
381
LastSync time.Time `json:"last_sync,omitempty"`
382
SyncError string `json:"sync_error,omitempty"`
383
LastStats mirror.Stats `json:"last_stats"`
384
Syncs int `json:"syncs"`
385
Notifies int `json:"notifies"`
386
MirrorBytes int64 `json:"mirror_bytes"`
387
Archives int `json:"archives"`
388
LastArchive time.Time `json:"last_archive,omitempty"`
389
ArchiveError string `json:"archive_error,omitempty"`
390
Interval string `json:"archive_interval"`
391
RetentionDays int `json:"retention_days"`
392
RateLimitKiB int64 `json:"rate_limit_kib"`
393
Rollback RollbackStatus `json:"rollback"`
394
}
395
396
// Status geeft de huidige stand.
397
func (s *Server) Status() Status {
398
list, _ := s.archives.List()
399
s.mu.Lock()
400
defer s.mu.Unlock()
401
return Status{
402
Version: Version, ServerID: s.serverID, BlueGitURL: s.state.BlueGitURL, InstanceID: s.state.InstanceID,
403
Connected: s.state.Connected(), LastSync: s.lastSync, SyncError: s.lastSyncErr, LastStats: s.lastStats,
404
Syncs: s.syncs, Notifies: s.notifies, MirrorBytes: s.mirror.Size(), Archives: len(list),
405
LastArchive: s.lastArchive, ArchiveError: s.archiveErr, Interval: s.Cfg.ArchiveInterval.String(),
406
RetentionDays: s.Cfg.RetentionDays, RateLimitKiB: s.Cfg.RateLimitKiB, Rollback: s.rollback,
407
}
408
}
409
410
func (s *Server) apiStatus(w http.ResponseWriter, r *http.Request) { writeJSON(w, 200, s.Status()) }
411
412
func (s *Server) apiSync(w http.ResponseWriter, r *http.Request) {
413
stats, err := s.SyncNow(r.Context())
414
if err != nil {
415
writeErr(w, 502, err.Error())
416
return
417
}
418
writeJSON(w, 200, stats)
419
}
420
421
func (s *Server) apiArchiveNow(w http.ResponseWriter, r *http.Request) {
422
a, err := s.ArchiveNow()
423
if err != nil {
424
writeErr(w, 409, err.Error())
425
return
426
}
427
writeJSON(w, 201, a)
428
}
429
430
func (s *Server) apiPrune(w http.ResponseWriter, r *http.Request) {
431
removed, err := s.Prune()
432
if err != nil {
433
writeErr(w, 500, err.Error())
434
return
435
}
436
if removed == nil {
437
removed = []string{}
438
}
439
writeJSON(w, 200, map[string]any{"removed": removed})
440
}
441
442
// ---------- koppelen ----------
443
444
// ConnectRequest is POST /api/v1/admin/connect.
445
type ConnectRequest struct {
446
URL string `json:"url"`
447
Key string `json:"key"`
448
// OnConflict is leeg, "wipe" of "restore". Leeg en een andere BlueGit
449
// dan de vorige: 409 met de keuzes.
450
OnConflict string `json:"on_conflict"`
451
}
452
453
// ConflictError is het 409-antwoord bij een andere BlueGit.
454
type ConflictError struct {
455
Conflict bool `json:"conflict"`
456
Error string `json:"error"`
457
PreviousURL string `json:"previous_url"`
458
PreviousInstance string `json:"previous_instance"`
459
NewInstance string `json:"new_instance"`
460
Archives int `json:"archives"`
461
Choices []string `json:"choices"`
462
}
463
464
func (s *Server) apiConnect(w http.ResponseWriter, r *http.Request) {
465
var in ConnectRequest
466
if err := json.Unmarshal(bodyOf(r), &in); err != nil {
467
writeErr(w, 400, "ongeldige JSON")
468
return
469
}
470
res, conflict, err := s.Connect(r.Context(), in)
471
if conflict != nil {
472
writeJSON(w, http.StatusConflict, conflict)
473
return
474
}
475
if err != nil {
476
var he *mirror.HTTPError
477
code := 502
478
if errors.As(err, &he) && he.Status == 401 {
479
code = 401
480
}
481
if errors.Is(err, errBadRequest) {
482
code = 400
483
}
484
writeErr(w, code, err.Error())
485
return
486
}
487
writeJSON(w, 200, res)
488
}
489
490
var errBadRequest = errors.New("ongeldig verzoek")
491
492
// Connect koppelt deze server aan een BlueGit. Er is er altijd hoogstens één.
493
func (s *Server) Connect(ctx context.Context, in ConnectRequest) (map[string]any, *ConflictError, error) {
494
in.URL = strings.TrimRight(strings.TrimSpace(in.URL), "/")
495
in.Key = strings.TrimSpace(in.Key)
496
if !strings.HasPrefix(in.URL, "http://") && !strings.HasPrefix(in.URL, "https://") {
497
return nil, nil, fmt.Errorf("%w: url moet met http:// of https:// beginnen", errBadRequest)
498
}
499
if !strings.HasPrefix(in.Key, protocol.KeyPrefix) {
500
return nil, nil, fmt.Errorf("%w: de Backupserver-Key begint met %s", errBadRequest, protocol.KeyPrefix)
501
}
502
switch in.OnConflict {
503
case "", "wipe", "restore":
504
default:
505
return nil, nil, fmt.Errorf("%w: on_conflict moet wipe of restore zijn", errBadRequest)
506
}
507
if s.Cfg.PublicURL == "" {
508
return nil, nil, fmt.Errorf("%w: zet public_url in de configuratie; BlueGit moet deze server kunnen bereiken", errBadRequest)
509
}
510
s.work.Lock()
511
defer s.work.Unlock()
512
rem := &mirror.Remote{URL: in.URL, Key: in.Key, HTTP: s.HTTP, Limiter: s.limiter}
513
info, err := rem.Info(ctx)
514
if err != nil {
515
return nil, nil, err
516
}
517
old := s.getState()
518
list, _ := s.archives.List()
519
hasData := !s.mirror.Empty() || len(list) > 0
520
other := old.InstanceID != "" && old.InstanceID != info.InstanceID && hasData
521
mode := ""
522
if other {
523
if in.OnConflict == "" {
524
return nil, &ConflictError{
525
Conflict: true, Error: "deze backup server hoort bij een andere BlueGit",
526
PreviousURL: old.BlueGitURL, PreviousInstance: old.InstanceID, NewInstance: info.InstanceID,
527
Archives: len(list), Choices: []string{"wipe", "restore"},
528
}, nil
529
}
530
mode = in.OnConflict
531
}
532
if mode == "wipe" {
533
if err := s.mirror.Wipe(); err != nil {
534
return nil, nil, err
535
}
536
if err := s.archives.DeleteAll(); err != nil {
537
return nil, nil, err
538
}
539
s.mu.Lock()
540
s.lastArchive = time.Time{}
541
s.mu.Unlock()
542
s.Log.Warn("oude backups verwijderd voor een nieuwe BlueGit", "old", old.InstanceID, "new", info.InstanceID)
543
}
544
if mode == "restore" && s.mirror.Empty() {
545
return nil, nil, fmt.Errorf("%w: de kopie is leeg; er is niets om terug te zetten", errBadRequest)
546
}
547
if err := rem.Connect(ctx, s.Cfg.PublicURL, s.serverID); err != nil {
548
return nil, nil, err
549
}
550
st := State{BlueGitURL: in.URL, Key: in.Key, InstanceID: info.InstanceID, ConnectedAt: s.now().UTC()}
551
if err := saveState(s.Cfg.DataDir, st); err != nil {
552
return nil, nil, err
553
}
554
s.mu.Lock()
555
s.state = st
556
s.mu.Unlock()
557
s.Log.Info("gekoppeld", "bluegit", in.URL, "instance", info.InstanceID, "mode", mode)
558
out := map[string]any{"instance_id": info.InstanceID, "bluegit_url": in.URL, "mode": mode}
559
if mode == "restore" {
560
if err := s.sendMirror(ctx, rem, "restore"); err != nil {
561
return nil, nil, fmt.Errorf("terugzetten naar de nieuwe BlueGit mislukt: %w", err)
562
}
563
out["restored"] = true
564
}
565
s.Kick()
566
return out, nil, nil
567
}
568
569
// sendMirror stuurt de hele kopie als tar.gz naar BlueGit en wacht tot die
570
// herstart is. Aanroepen met s.work vast.
571
func (s *Server) sendMirror(ctx context.Context, rem *mirror.Remote, label string) error {
572
s.setRollback(RollbackStatus{State: "running", Archive: label, At: s.now().UTC()})
573
pr, pw := io.Pipe()
574
go func() { pw.CloseWithError(archive.WriteTarGz(pw, s.mirror.Dir)) }()
575
if err := rem.Restore(ctx, pr); err != nil {
576
pr.CloseWithError(err)
577
s.setRollback(RollbackStatus{State: "failed", Archive: label, Error: err.Error(), At: s.now().UTC()})
578
return err
579
}
580
if err := rem.WaitUp(ctx, 3*time.Minute); err != nil {
581
s.setRollback(RollbackStatus{State: "failed", Archive: label, Error: err.Error(), At: s.now().UTC()})
582
return err
583
}
584
s.setRollback(RollbackStatus{State: "done", Archive: label, At: s.now().UTC()})
585
return nil
586
}
587
588
func (s *Server) setRollback(r RollbackStatus) {
589
s.mu.Lock()
590
s.rollback = r
591
s.mu.Unlock()
592
}
593
594
// ---------- rollback ----------
595
596
func (s *Server) apiRollback(w http.ResponseWriter, r *http.Request) {
597
var in struct {
598
Archive string `json:"archive"`
599
}
600
if err := json.Unmarshal(bodyOf(r), &in); err != nil || !archive.ValidName(in.Archive) {
601
writeErr(w, 400, "ongeldige archiefnaam")
602
return
603
}
604
if _, err := s.archives.Path(in.Archive); err != nil {
605
writeErr(w, 404, err.Error())
606
return
607
}
608
s.mu.Lock()
609
busy := s.rollback.State == "running"
610
if !busy {
611
s.rollback = RollbackStatus{State: "running", Archive: in.Archive, At: s.now().UTC()}
612
}
613
s.mu.Unlock()
614
if busy {
615
writeErr(w, 409, "er loopt al een rollback")
616
return
617
}
618
s.Log.Warn("rollback gestart", "archive", in.Archive)
619
go func() {
620
if err := s.Rollback(context.Background(), in.Archive); err != nil {
621
s.Log.Error("rollback mislukt", "archive", in.Archive, "err", err)
622
}
623
}()
624
writeJSON(w, http.StatusAccepted, map[string]string{"state": "running", "archive": in.Archive})
625
}
626
627
// Rollback pakt een archief uit, vervangt daarmee de draaiende kopie en
628
// stuurt die naar BlueGit. Lukt het sturen niet, dan komt de oude kopie
629
// terug, zodat kopie en BlueGit gelijk blijven.
630
func (s *Server) Rollback(ctx context.Context, name string) error {
631
s.work.Lock()
632
defer s.work.Unlock()
633
fail := func(err error) error {
634
s.setRollback(RollbackStatus{State: "failed", Archive: name, Error: err.Error(), At: s.now().UTC()})
635
return err
636
}
637
st := s.getState()
638
if !st.Connected() {
639
return fail(errors.New("geen BlueGit gekoppeld"))
640
}
641
src, err := s.archives.Path(name)
642
if err != nil {
643
return fail(err)
644
}
645
fresh := filepath.Join(s.Cfg.DataDir, "mirror.rollback")
646
old := filepath.Join(s.Cfg.DataDir, "mirror.old")
647
_ = os.RemoveAll(fresh)
648
_ = os.RemoveAll(old)
649
if err := archive.Extract(src, fresh); err != nil {
650
_ = os.RemoveAll(fresh)
651
return fail(fmt.Errorf("uitpakken: %w", err))
652
}
653
oldIndex, _ := os.ReadFile(s.mirror.Index)
654
if err := os.Rename(s.mirror.Dir, old); err != nil && !errors.Is(err, os.ErrNotExist) {
655
return fail(err)
656
}
657
if err := os.Rename(fresh, s.mirror.Dir); err != nil {
658
_ = os.Rename(old, s.mirror.Dir)
659
return fail(err)
660
}
661
if err := s.mirror.RebuildIndex(); err != nil {
662
return fail(err)
663
}
664
if err := s.sendMirror(ctx, s.remote(st), name); err != nil {
665
// Terug naar de kopie van vóór de rollback.
666
_ = os.RemoveAll(s.mirror.Dir)
667
_ = os.Rename(old, s.mirror.Dir)
668
_ = os.WriteFile(s.mirror.Index, oldIndex, 0o600)
669
s.setRollback(RollbackStatus{State: "failed", Archive: name, Error: err.Error(), At: s.now().UTC()})
670
return err
671
}
672
_ = os.RemoveAll(old)
673
s.Log.Warn("rollback klaar", "archive", name)
674
s.Kick()
675
return nil
676
}
677
678
// ---------- self-update ----------
679
680
// UpdateStarter start de update-unit (tests zetten een stub).
681
var UpdateStarter = func(ctx context.Context, ref string) error {
682
return startUpdateUnit(ctx, ref)
683
}
684
685
var updateHits = struct {
686
sync.Mutex
687
at []time.Time
688
}{}
689
690
func (s *Server) selfUpdate(w http.ResponseWriter, r *http.Request) {
691
tok := os.Getenv("BLUEGIT_BACKUP_UPDATE_TOKEN")
692
if tok == "" {
693
http.NotFound(w, r)
694
return
695
}
696
updateHits.Lock()
697
cut := time.Now().Add(-time.Minute)
698
keep := updateHits.at[:0]
699
for _, t := range updateHits.at {
700
if t.After(cut) {
701
keep = append(keep, t)
702
}
703
}
704
updateHits.at = append(keep, time.Now())
705
n := len(updateHits.at)
706
updateHits.Unlock()
707
if n > 5 {
708
writeErr(w, http.StatusTooManyRequests, "te veel verzoeken")
709
return
710
}
711
got := strings.TrimSpace(strings.TrimPrefix(r.Header.Get("Authorization"), "Bearer "))
712
if subtle.ConstantTimeCompare([]byte(got), []byte(tok)) != 1 {
713
writeErr(w, http.StatusUnauthorized, "unauthorized")
714
return
715
}
716
var in struct {
717
Ref string `json:"ref"`
718
}
719
_ = json.NewDecoder(io.LimitReader(r.Body, 4096)).Decode(&in)
720
if !validRef(in.Ref) {
721
writeErr(w, 400, "ref moet een volledige sha zijn")
722
return
723
}
724
if err := UpdateStarter(r.Context(), in.Ref); err != nil {
725
writeErr(w, 500, err.Error())
726
return
727
}
728
writeJSON(w, http.StatusAccepted, map[string]string{"ref": in.Ref, "state": "started"})
729
}
730
731
func validRef(ref string) bool {
732
if len(ref) != 40 {
733
return false
734
}
735
for _, c := range ref {
736
if !(c >= '0' && c <= '9' || c >= 'a' && c <= 'f') {
737
return false
738
}
739
}
740
return true
741
}
@@ -0,0 +1,741 @@1
// Package server is de backup server: sync, archieven, de API voor BlueGit2
// en de lokale beheer-API.3
package server4
5
import (6
"context"7
"crypto/subtle"8
"encoding/json"9
"errors"10
"fmt"11
"io"12
"log/slog"13
"net/http"14
"os"15
"path/filepath"16
"strings"17
"sync"18
"time"19
20
"git.timfalken.com/timfa/bluegit-backup/internal/archive"21
"git.timfalken.com/timfa/bluegit-backup/internal/config"22
"git.timfalken.com/timfa/bluegit-backup/internal/mirror"23
"git.timfalken.com/timfa/bluegit-backup/internal/protocol"24
"git.timfalken.com/timfa/bluegit-backup/internal/throttle"25
)26
27
// Version wordt bij het bouwen gezet (-ldflags -X).28
var Version = "dev"29
30
// Server is één backup server voor één BlueGit.31
type Server struct {32
Cfg config.Config33
Log *slog.Logger34
// Now is de klok (tests).35
Now func() time.Time36
// HTTP is de client richting BlueGit (tests).37
HTTP *http.Client38
39
adminToken string40
serverID string41
limiter *throttle.Limiter42
mirror *mirror.Mirror43
archives *archive.Store44
45
// work beschermt de kopie: sync, archiveren, rollback en koppelen46
// gebeuren nooit tegelijk.47
work sync.Mutex48
49
mu sync.Mutex50
state State51
lastSync time.Time52
lastSyncErr string53
lastStats mirror.Stats54
syncs int55
notifies int56
lastArchive time.Time57
archiveErr string58
rollback RollbackStatus59
60
kick chan struct{}61
}62
63
// RollbackStatus is de stand van de laatste rollback of restore.64
type RollbackStatus struct {65
State string `json:"state"` // idle | running | done | failed66
Archive string `json:"archive,omitempty"`67
Error string `json:"error,omitempty"`68
At time.Time `json:"at,omitempty"`69
}70
71
// New zet de mappen klaar en leest de koppeling.72
func New(cfg config.Config, log *slog.Logger) (*Server, error) {73
if log == nil {74
log = slog.New(slog.NewTextHandler(io.Discard, nil))75
}76
if err := os.MkdirAll(cfg.DataDir, 0o750); err != nil {77
return nil, err78
}79
s := &Server{Cfg: cfg, Log: log, Now: time.Now, kick: make(chan struct{}, 1)}80
var err error81
if s.adminToken, err = secretFile(cfg.DataDir, "admin.token", "bba_"); err != nil {82
return nil, err83
}84
if s.serverID, err = secretFile(cfg.DataDir, "server_id", ""); err != nil {85
return nil, err86
}87
if s.state, err = loadState(cfg.DataDir); err != nil {88
return nil, err89
}90
s.limiter = throttle.New(cfg.RateLimitKiB << 10)91
s.mirror = &mirror.Mirror{Dir: filepath.Join(cfg.DataDir, "mirror"), Index: filepath.Join(cfg.DataDir, "mirror.index.json")}92
s.archives = &archive.Store{Dir: filepath.Join(cfg.DataDir, "archives")}93
_ = os.RemoveAll(filepath.Join(cfg.DataDir, "tmp"))94
if list, _ := s.archives.List(); len(list) > 0 {95
s.lastArchive = list[0].CreatedAt96
}97
s.rollback.State = "idle"98
return s, nil99
}100
101
// SetFree vervangt de vrije-ruimtemeting (tests).102
func (s *Server) SetFree(f func(string) (uint64, error)) { s.archives.Free = f }103
104
// AdminToken is het lokale beheertoken.105
func (s *Server) AdminToken() string { return s.adminToken }106
107
func (s *Server) now() time.Time { return s.Now() }108
109
func (s *Server) remote(st State) *mirror.Remote {110
return &mirror.Remote{URL: st.BlueGitURL, Key: st.Key, HTTP: s.HTTP, Limiter: s.limiter}111
}112
113
func (s *Server) getState() State {114
s.mu.Lock()115
defer s.mu.Unlock()116
return s.state117
}118
119
// Run start de achtergrondtaken tot ctx klaar is.120
func (s *Server) Run(ctx context.Context) {121
go s.syncLoop(ctx)122
go s.archiveLoop(ctx)123
}124
125
// Kick vraagt om een sync (na een melding).126
func (s *Server) Kick() {127
select {128
case s.kick <- struct{}{}:129
default:130
}131
}132
133
func (s *Server) syncLoop(ctx context.Context) {134
full := time.NewTicker(s.Cfg.FullSyncInterval.Duration)135
defer full.Stop()136
s.Kick() // meteen na de start137
for {138
select {139
case <-ctx.Done():140
return141
case <-full.C:142
case <-s.kick:143
}144
s.mu.Lock()145
wait := s.Cfg.MinSyncInterval.Duration - s.now().Sub(s.lastSync)146
s.mu.Unlock()147
if wait > 0 {148
select {149
case <-ctx.Done():150
return151
case <-time.After(wait):152
}153
}154
// Meldingen die in de tussentijd binnenkwamen, zitten in deze sync.155
select {156
case <-s.kick:157
default:158
}159
_, _ = s.SyncNow(ctx)160
}161
}162
163
// SyncNow synchroniseert één keer.164
func (s *Server) SyncNow(ctx context.Context) (mirror.Stats, error) {165
st := s.getState()166
if !st.Connected() {167
return mirror.Stats{}, errors.New("geen BlueGit gekoppeld")168
}169
s.work.Lock()170
defer s.work.Unlock()171
st = s.getState()172
if !st.Connected() {173
return mirror.Stats{}, errors.New("geen BlueGit gekoppeld")174
}175
stats, err := s.mirror.Sync(ctx, s.remote(st))176
s.mu.Lock()177
s.lastSync = s.now()178
s.syncs++179
s.lastStats = stats180
if err != nil {181
s.lastSyncErr = err.Error()182
} else {183
s.lastSyncErr = ""184
}185
s.mu.Unlock()186
if err != nil {187
s.Log.Warn("sync mislukt", "err", err)188
} else if stats.Downloaded > 0 || stats.Deleted > 0 {189
s.Log.Info("sync", "files", stats.Files, "downloaded", stats.Downloaded, "bytes", stats.Bytes, "deleted", stats.Deleted)190
}191
return stats, err192
}193
194
func (s *Server) archiveLoop(ctx context.Context) {195
t := time.NewTicker(s.tick())196
defer t.Stop()197
for {198
select {199
case <-ctx.Done():200
return201
case <-t.C:202
}203
s.mu.Lock()204
due := s.now().Sub(s.lastArchive) >= s.Cfg.ArchiveInterval.Duration205
synced := !s.lastSync.IsZero() && s.lastSyncErr == ""206
s.mu.Unlock()207
if due && synced {208
if _, err := s.ArchiveNow(); err != nil {209
s.Log.Warn("archief mislukt", "err", err)210
}211
}212
if _, err := s.Prune(); err != nil {213
s.Log.Warn("opruimen mislukt", "err", err)214
}215
}216
}217
218
// tick is hoe vaak de archieflus kijkt: een minuut, of korter bij een kort interval.219
func (s *Server) tick() time.Duration {220
d := s.Cfg.ArchiveInterval.Duration / 4221
if d > time.Minute {222
d = time.Minute223
}224
if d < 100*time.Millisecond {225
d = 100 * time.Millisecond226
}227
return d228
}229
230
// ArchiveNow comprimeert de hele kopie tot een nieuw archief.231
func (s *Server) ArchiveNow() (archive.Archive, error) {232
s.work.Lock()233
defer s.work.Unlock()234
if s.mirror.Empty() {235
return archive.Archive{}, errors.New("de kopie is nog leeg")236
}237
now := s.now()238
a, removed, err := s.archives.Create(s.mirror.Dir, now, s.mirror.Size(), s.minFree())239
s.mu.Lock()240
if err != nil {241
s.archiveErr = err.Error()242
} else {243
s.archiveErr = ""244
s.lastArchive = now245
}246
s.mu.Unlock()247
for _, r := range removed {248
s.Log.Info("archief verwijderd: schijf vol", "archive", r)249
}250
if err != nil {251
return a, err252
}253
s.Log.Info("archief gemaakt", "archive", a.Name, "bytes", a.Size)254
if pr, err := s.archives.Prune(now, s.Cfg.RetentionDays, s.minFree()); err == nil {255
for _, r := range pr {256
s.Log.Info("archief verwijderd", "archive", r)257
}258
}259
return a, nil260
}261
262
func (s *Server) minFree() uint64 { return uint64(s.Cfg.MinFreeMB) << 20 }263
264
// Prune past de bewaarregels toe.265
func (s *Server) Prune() ([]string, error) {266
s.work.Lock()267
defer s.work.Unlock()268
removed, err := s.archives.Prune(s.now(), s.Cfg.RetentionDays, s.minFree())269
for _, r := range removed {270
s.Log.Info("archief verwijderd", "archive", r)271
}272
return removed, err273
}274
275
// ---------- HTTP ----------276
277
// Handler is de HTTP-API.278
func (s *Server) Handler() http.Handler {279
mux := http.NewServeMux()280
mux.HandleFunc("GET /healthz", func(w http.ResponseWriter, r *http.Request) { _, _ = w.Write([]byte("ok\n")) })281
// Van BlueGit, ondertekend.282
mux.HandleFunc("POST /api/v1/notify", s.signed(s.apiNotify))283
mux.HandleFunc("GET /api/v1/archives", s.signed(s.apiArchives))284
mux.HandleFunc("GET /api/v1/status", s.signed(s.apiStatus))285
mux.HandleFunc("POST /api/v1/rollback", s.signed(s.apiRollback))286
// Lokaal beheer, met admin.token.287
mux.HandleFunc("GET /api/v1/admin/status", s.admin(s.apiStatus))288
mux.HandleFunc("GET /api/v1/admin/archives", s.admin(s.apiArchives))289
mux.HandleFunc("POST /api/v1/admin/connect", s.admin(s.apiConnect))290
mux.HandleFunc("POST /api/v1/admin/sync", s.admin(s.apiSync))291
mux.HandleFunc("POST /api/v1/admin/archive", s.admin(s.apiArchiveNow))292
mux.HandleFunc("POST /api/v1/admin/prune", s.admin(s.apiPrune))293
mux.HandleFunc("POST /api/v1/admin/self-update", s.selfUpdate)294
return mux295
}296
297
func writeJSON(w http.ResponseWriter, code int, v any) {298
w.Header().Set("Content-Type", "application/json")299
w.Header().Set("Cache-Control", "no-store")300
w.WriteHeader(code)301
if v != nil {302
_ = json.NewEncoder(w).Encode(v)303
}304
}305
306
func writeErr(w http.ResponseWriter, code int, msg string) {307
writeJSON(w, code, map[string]string{"error": msg})308
}309
310
type ctxBody struct{}311
312
// signed controleert de HMAC-handtekening van de gekoppelde BlueGit.313
func (s *Server) signed(h http.HandlerFunc) http.HandlerFunc {314
return func(w http.ResponseWriter, r *http.Request) {315
st := s.getState()316
if !st.Connected() {317
writeErr(w, http.StatusUnauthorized, "niet gekoppeld")318
return319
}320
body, err := io.ReadAll(io.LimitReader(r.Body, 1<<20))321
if err != nil {322
writeErr(w, 400, "body")323
return324
}325
if r.Header.Get(protocol.HeaderInstance) != st.InstanceID {326
writeErr(w, http.StatusUnauthorized, "andere BlueGit-instantie")327
return328
}329
if err := protocol.Verify(r, protocol.SigningSecret(st.Key), body, s.now()); err != nil {330
writeErr(w, http.StatusUnauthorized, err.Error())331
return332
}333
r = r.WithContext(context.WithValue(r.Context(), ctxBody{}, body))334
h(w, r)335
}336
}337
338
func bodyOf(r *http.Request) []byte {339
if b, ok := r.Context().Value(ctxBody{}).([]byte); ok {340
return b341
}342
b, _ := io.ReadAll(io.LimitReader(r.Body, 1<<20))343
return b344
}345
346
func (s *Server) admin(h http.HandlerFunc) http.HandlerFunc {347
return func(w http.ResponseWriter, r *http.Request) {348
tok := strings.TrimSpace(strings.TrimPrefix(r.Header.Get("Authorization"), "Bearer "))349
if subtle.ConstantTimeCompare([]byte(tok), []byte(s.adminToken)) != 1 {350
writeErr(w, http.StatusUnauthorized, "admin.token nodig")351
return352
}353
h(w, r)354
}355
}356
357
func (s *Server) apiNotify(w http.ResponseWriter, r *http.Request) {358
s.mu.Lock()359
s.notifies++360
s.mu.Unlock()361
s.Kick()362
w.WriteHeader(http.StatusNoContent)363
}364
365
func (s *Server) apiArchives(w http.ResponseWriter, r *http.Request) {366
list, err := s.archives.List()367
if err != nil {368
writeErr(w, 500, err.Error())369
return370
}371
writeJSON(w, 200, map[string]any{"archives": list})372
}373
374
// Status is wat GET /api/v1/status en de CLI tonen.375
type Status struct {376
Version string `json:"version"`377
ServerID string `json:"server_id"`378
BlueGitURL string `json:"bluegit_url,omitempty"`379
InstanceID string `json:"instance_id,omitempty"`380
Connected bool `json:"connected"`381
LastSync time.Time `json:"last_sync,omitempty"`382
SyncError string `json:"sync_error,omitempty"`383
LastStats mirror.Stats `json:"last_stats"`384
Syncs int `json:"syncs"`385
Notifies int `json:"notifies"`386
MirrorBytes int64 `json:"mirror_bytes"`387
Archives int `json:"archives"`388
LastArchive time.Time `json:"last_archive,omitempty"`389
ArchiveError string `json:"archive_error,omitempty"`390
Interval string `json:"archive_interval"`391
RetentionDays int `json:"retention_days"`392
RateLimitKiB int64 `json:"rate_limit_kib"`393
Rollback RollbackStatus `json:"rollback"`394
}395
396
// Status geeft de huidige stand.397
func (s *Server) Status() Status {398
list, _ := s.archives.List()399
s.mu.Lock()400
defer s.mu.Unlock()401
return Status{402
Version: Version, ServerID: s.serverID, BlueGitURL: s.state.BlueGitURL, InstanceID: s.state.InstanceID,403
Connected: s.state.Connected(), LastSync: s.lastSync, SyncError: s.lastSyncErr, LastStats: s.lastStats,404
Syncs: s.syncs, Notifies: s.notifies, MirrorBytes: s.mirror.Size(), Archives: len(list),405
LastArchive: s.lastArchive, ArchiveError: s.archiveErr, Interval: s.Cfg.ArchiveInterval.String(),406
RetentionDays: s.Cfg.RetentionDays, RateLimitKiB: s.Cfg.RateLimitKiB, Rollback: s.rollback,407
}408
}409
410
func (s *Server) apiStatus(w http.ResponseWriter, r *http.Request) { writeJSON(w, 200, s.Status()) }411
412
func (s *Server) apiSync(w http.ResponseWriter, r *http.Request) {413
stats, err := s.SyncNow(r.Context())414
if err != nil {415
writeErr(w, 502, err.Error())416
return417
}418
writeJSON(w, 200, stats)419
}420
421
func (s *Server) apiArchiveNow(w http.ResponseWriter, r *http.Request) {422
a, err := s.ArchiveNow()423
if err != nil {424
writeErr(w, 409, err.Error())425
return426
}427
writeJSON(w, 201, a)428
}429
430
func (s *Server) apiPrune(w http.ResponseWriter, r *http.Request) {431
removed, err := s.Prune()432
if err != nil {433
writeErr(w, 500, err.Error())434
return435
}436
if removed == nil {437
removed = []string{}438
}439
writeJSON(w, 200, map[string]any{"removed": removed})440
}441
442
// ---------- koppelen ----------443
444
// ConnectRequest is POST /api/v1/admin/connect.445
type ConnectRequest struct {446
URL string `json:"url"`447
Key string `json:"key"`448
// OnConflict is leeg, "wipe" of "restore". Leeg en een andere BlueGit449
// dan de vorige: 409 met de keuzes.450
OnConflict string `json:"on_conflict"`451
}452
453
// ConflictError is het 409-antwoord bij een andere BlueGit.454
type ConflictError struct {455
Conflict bool `json:"conflict"`456
Error string `json:"error"`457
PreviousURL string `json:"previous_url"`458
PreviousInstance string `json:"previous_instance"`459
NewInstance string `json:"new_instance"`460
Archives int `json:"archives"`461
Choices []string `json:"choices"`462
}463
464
func (s *Server) apiConnect(w http.ResponseWriter, r *http.Request) {465
var in ConnectRequest466
if err := json.Unmarshal(bodyOf(r), &in); err != nil {467
writeErr(w, 400, "ongeldige JSON")468
return469
}470
res, conflict, err := s.Connect(r.Context(), in)471
if conflict != nil {472
writeJSON(w, http.StatusConflict, conflict)473
return474
}475
if err != nil {476
var he *mirror.HTTPError477
code := 502478
if errors.As(err, &he) && he.Status == 401 {479
code = 401480
}481
if errors.Is(err, errBadRequest) {482
code = 400483
}484
writeErr(w, code, err.Error())485
return486
}487
writeJSON(w, 200, res)488
}489
490
var errBadRequest = errors.New("ongeldig verzoek")491
492
// Connect koppelt deze server aan een BlueGit. Er is er altijd hoogstens één.493
func (s *Server) Connect(ctx context.Context, in ConnectRequest) (map[string]any, *ConflictError, error) {494
in.URL = strings.TrimRight(strings.TrimSpace(in.URL), "/")495
in.Key = strings.TrimSpace(in.Key)496
if !strings.HasPrefix(in.URL, "http://") && !strings.HasPrefix(in.URL, "https://") {497
return nil, nil, fmt.Errorf("%w: url moet met http:// of https:// beginnen", errBadRequest)498
}499
if !strings.HasPrefix(in.Key, protocol.KeyPrefix) {500
return nil, nil, fmt.Errorf("%w: de Backupserver-Key begint met %s", errBadRequest, protocol.KeyPrefix)501
}502
switch in.OnConflict {503
case "", "wipe", "restore":504
default:505
return nil, nil, fmt.Errorf("%w: on_conflict moet wipe of restore zijn", errBadRequest)506
}507
if s.Cfg.PublicURL == "" {508
return nil, nil, fmt.Errorf("%w: zet public_url in de configuratie; BlueGit moet deze server kunnen bereiken", errBadRequest)509
}510
s.work.Lock()511
defer s.work.Unlock()512
rem := &mirror.Remote{URL: in.URL, Key: in.Key, HTTP: s.HTTP, Limiter: s.limiter}513
info, err := rem.Info(ctx)514
if err != nil {515
return nil, nil, err516
}517
old := s.getState()518
list, _ := s.archives.List()519
hasData := !s.mirror.Empty() || len(list) > 0520
other := old.InstanceID != "" && old.InstanceID != info.InstanceID && hasData521
mode := ""522
if other {523
if in.OnConflict == "" {524
return nil, &ConflictError{525
Conflict: true, Error: "deze backup server hoort bij een andere BlueGit",526
PreviousURL: old.BlueGitURL, PreviousInstance: old.InstanceID, NewInstance: info.InstanceID,527
Archives: len(list), Choices: []string{"wipe", "restore"},528
}, nil529
}530
mode = in.OnConflict531
}532
if mode == "wipe" {533
if err := s.mirror.Wipe(); err != nil {534
return nil, nil, err535
}536
if err := s.archives.DeleteAll(); err != nil {537
return nil, nil, err538
}539
s.mu.Lock()540
s.lastArchive = time.Time{}541
s.mu.Unlock()542
s.Log.Warn("oude backups verwijderd voor een nieuwe BlueGit", "old", old.InstanceID, "new", info.InstanceID)543
}544
if mode == "restore" && s.mirror.Empty() {545
return nil, nil, fmt.Errorf("%w: de kopie is leeg; er is niets om terug te zetten", errBadRequest)546
}547
if err := rem.Connect(ctx, s.Cfg.PublicURL, s.serverID); err != nil {548
return nil, nil, err549
}550
st := State{BlueGitURL: in.URL, Key: in.Key, InstanceID: info.InstanceID, ConnectedAt: s.now().UTC()}551
if err := saveState(s.Cfg.DataDir, st); err != nil {552
return nil, nil, err553
}554
s.mu.Lock()555
s.state = st556
s.mu.Unlock()557
s.Log.Info("gekoppeld", "bluegit", in.URL, "instance", info.InstanceID, "mode", mode)558
out := map[string]any{"instance_id": info.InstanceID, "bluegit_url": in.URL, "mode": mode}559
if mode == "restore" {560
if err := s.sendMirror(ctx, rem, "restore"); err != nil {561
return nil, nil, fmt.Errorf("terugzetten naar de nieuwe BlueGit mislukt: %w", err)562
}563
out["restored"] = true564
}565
s.Kick()566
return out, nil, nil567
}568
569
// sendMirror stuurt de hele kopie als tar.gz naar BlueGit en wacht tot die570
// herstart is. Aanroepen met s.work vast.571
func (s *Server) sendMirror(ctx context.Context, rem *mirror.Remote, label string) error {572
s.setRollback(RollbackStatus{State: "running", Archive: label, At: s.now().UTC()})573
pr, pw := io.Pipe()574
go func() { pw.CloseWithError(archive.WriteTarGz(pw, s.mirror.Dir)) }()575
if err := rem.Restore(ctx, pr); err != nil {576
pr.CloseWithError(err)577
s.setRollback(RollbackStatus{State: "failed", Archive: label, Error: err.Error(), At: s.now().UTC()})578
return err579
}580
if err := rem.WaitUp(ctx, 3*time.Minute); err != nil {581
s.setRollback(RollbackStatus{State: "failed", Archive: label, Error: err.Error(), At: s.now().UTC()})582
return err583
}584
s.setRollback(RollbackStatus{State: "done", Archive: label, At: s.now().UTC()})585
return nil586
}587
588
func (s *Server) setRollback(r RollbackStatus) {589
s.mu.Lock()590
s.rollback = r591
s.mu.Unlock()592
}593
594
// ---------- rollback ----------595
596
func (s *Server) apiRollback(w http.ResponseWriter, r *http.Request) {597
var in struct {598
Archive string `json:"archive"`599
}600
if err := json.Unmarshal(bodyOf(r), &in); err != nil || !archive.ValidName(in.Archive) {601
writeErr(w, 400, "ongeldige archiefnaam")602
return603
}604
if _, err := s.archives.Path(in.Archive); err != nil {605
writeErr(w, 404, err.Error())606
return607
}608
s.mu.Lock()609
busy := s.rollback.State == "running"610
if !busy {611
s.rollback = RollbackStatus{State: "running", Archive: in.Archive, At: s.now().UTC()}612
}613
s.mu.Unlock()614
if busy {615
writeErr(w, 409, "er loopt al een rollback")616
return617
}618
s.Log.Warn("rollback gestart", "archive", in.Archive)619
go func() {620
if err := s.Rollback(context.Background(), in.Archive); err != nil {621
s.Log.Error("rollback mislukt", "archive", in.Archive, "err", err)622
}623
}()624
writeJSON(w, http.StatusAccepted, map[string]string{"state": "running", "archive": in.Archive})625
}626
627
// Rollback pakt een archief uit, vervangt daarmee de draaiende kopie en628
// stuurt die naar BlueGit. Lukt het sturen niet, dan komt de oude kopie629
// terug, zodat kopie en BlueGit gelijk blijven.630
func (s *Server) Rollback(ctx context.Context, name string) error {631
s.work.Lock()632
defer s.work.Unlock()633
fail := func(err error) error {634
s.setRollback(RollbackStatus{State: "failed", Archive: name, Error: err.Error(), At: s.now().UTC()})635
return err636
}637
st := s.getState()638
if !st.Connected() {639
return fail(errors.New("geen BlueGit gekoppeld"))640
}641
src, err := s.archives.Path(name)642
if err != nil {643
return fail(err)644
}645
fresh := filepath.Join(s.Cfg.DataDir, "mirror.rollback")646
old := filepath.Join(s.Cfg.DataDir, "mirror.old")647
_ = os.RemoveAll(fresh)648
_ = os.RemoveAll(old)649
if err := archive.Extract(src, fresh); err != nil {650
_ = os.RemoveAll(fresh)651
return fail(fmt.Errorf("uitpakken: %w", err))652
}653
oldIndex, _ := os.ReadFile(s.mirror.Index)654
if err := os.Rename(s.mirror.Dir, old); err != nil && !errors.Is(err, os.ErrNotExist) {655
return fail(err)656
}657
if err := os.Rename(fresh, s.mirror.Dir); err != nil {658
_ = os.Rename(old, s.mirror.Dir)659
return fail(err)660
}661
if err := s.mirror.RebuildIndex(); err != nil {662
return fail(err)663
}664
if err := s.sendMirror(ctx, s.remote(st), name); err != nil {665
// Terug naar de kopie van vóór de rollback.666
_ = os.RemoveAll(s.mirror.Dir)667
_ = os.Rename(old, s.mirror.Dir)668
_ = os.WriteFile(s.mirror.Index, oldIndex, 0o600)669
s.setRollback(RollbackStatus{State: "failed", Archive: name, Error: err.Error(), At: s.now().UTC()})670
return err671
}672
_ = os.RemoveAll(old)673
s.Log.Warn("rollback klaar", "archive", name)674
s.Kick()675
return nil676
}677
678
// ---------- self-update ----------679
680
// UpdateStarter start de update-unit (tests zetten een stub).681
var UpdateStarter = func(ctx context.Context, ref string) error {682
return startUpdateUnit(ctx, ref)683
}684
685
var updateHits = struct {686
sync.Mutex687
at []time.Time688
}{}689
690
func (s *Server) selfUpdate(w http.ResponseWriter, r *http.Request) {691
tok := os.Getenv("BLUEGIT_BACKUP_UPDATE_TOKEN")692
if tok == "" {693
http.NotFound(w, r)694
return695
}696
updateHits.Lock()697
cut := time.Now().Add(-time.Minute)698
keep := updateHits.at[:0]699
for _, t := range updateHits.at {700
if t.After(cut) {701
keep = append(keep, t)702
}703
}704
updateHits.at = append(keep, time.Now())705
n := len(updateHits.at)706
updateHits.Unlock()707
if n > 5 {708
writeErr(w, http.StatusTooManyRequests, "te veel verzoeken")709
return710
}711
got := strings.TrimSpace(strings.TrimPrefix(r.Header.Get("Authorization"), "Bearer "))712
if subtle.ConstantTimeCompare([]byte(got), []byte(tok)) != 1 {713
writeErr(w, http.StatusUnauthorized, "unauthorized")714
return715
}716
var in struct {717
Ref string `json:"ref"`718
}719
_ = json.NewDecoder(io.LimitReader(r.Body, 4096)).Decode(&in)720
if !validRef(in.Ref) {721
writeErr(w, 400, "ref moet een volledige sha zijn")722
return723
}724
if err := UpdateStarter(r.Context(), in.Ref); err != nil {725
writeErr(w, 500, err.Error())726
return727
}728
writeJSON(w, http.StatusAccepted, map[string]string{"ref": in.Ref, "state": "started"})729
}730
731
func validRef(ref string) bool {732
if len(ref) != 40 {733
return false734
}735
for _, c := range ref {736
if !(c >= '0' && c <= '9' || c >= 'a' && c <= 'f') {737
return false738
}739
}740
return true741
}@@ -0,0 +1,232 @@
1
package server
2
3
import (
4
"bytes"
5
"context"
6
"crypto/sha256"
7
"encoding/hex"
8
"encoding/json"
9
"io"
10
"net/http"
11
"net/http/httptest"
12
"os"
13
"path/filepath"
14
"strings"
15
"sync"
16
"testing"
17
"time"
18
19
"git.timfalken.com/timfa/bluegit-backup/internal/config"
20
"git.timfalken.com/timfa/bluegit-backup/internal/protocol"
21
)
22
23
// fakeBlueGit is een minimale backup-API met bestanden in het geheugen.
24
type fakeBlueGit struct {
25
mu sync.Mutex
26
key string
27
inst string
28
files map[string]string
29
fetches map[string]int
30
ts *httptest.Server
31
}
32
33
func newFake(t *testing.T) *fakeBlueGit {
34
f := &fakeBlueGit{key: "bgbk_test", inst: "inst-1", fetches: map[string]int{},
35
files: map[string]string{"state/bluegit.db": "db1", "state/secret.key": "k", "data/repos/tim/a.git/HEAD": "ref"}}
36
f.ts = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
37
if r.Header.Get("Authorization") != "Bearer "+f.key {
38
http.Error(w, `{"error":"key"}`, 401)
39
return
40
}
41
f.mu.Lock()
42
defer f.mu.Unlock()
43
switch r.URL.Path {
44
case "/api/v1/backup/info":
45
_ = json.NewEncoder(w).Encode(protocol.Info{InstanceID: f.inst})
46
case "/api/v1/backup/connect":
47
w.WriteHeader(200)
48
case "/api/v1/backup/manifest":
49
m := protocol.Manifest{Instance: f.inst}
50
for p, c := range f.files {
51
e := protocol.Entry{Path: p, Size: int64(len(c)), MTime: int64(len(c)) * 1000, Mode: 0o644}
52
if p == protocol.DBPath {
53
s := sha256.Sum256([]byte(c))
54
e.SHA256 = hex.EncodeToString(s[:])
55
}
56
m.Files = append(m.Files, e)
57
}
58
m.Files = append(m.Files, protocol.Entry{Path: "../../etc/passwd", Size: 1})
59
_ = json.NewEncoder(w).Encode(m)
60
case "/api/v1/backup/file":
61
p := r.URL.Query().Get("path")
62
c, ok := f.files[p]
63
if !ok {
64
http.Error(w, `{"error":"weg"}`, 404)
65
return
66
}
67
f.fetches[p]++
68
_, _ = io.WriteString(w, c)
69
default:
70
http.NotFound(w, r)
71
}
72
}))
73
t.Cleanup(f.ts.Close)
74
return f
75
}
76
77
func newTestServer(t *testing.T) *Server {
78
cfg := config.Config{DataDir: t.TempDir(), PublicURL: "http://backup.test"}
79
cfg.Defaults()
80
cfg.RateLimitKiB = 0
81
s, err := New(cfg, nil)
82
if err != nil {
83
t.Fatal(err)
84
}
85
return s
86
}
87
88
func adminReq(s *Server, method, p, body string) *httptest.ResponseRecorder {
89
r := httptest.NewRequest(method, p, strings.NewReader(body))
90
r.Header.Set("Authorization", "Bearer "+s.AdminToken())
91
w := httptest.NewRecorder()
92
s.Handler().ServeHTTP(w, r)
93
return w
94
}
95
96
func TestSyncIncrementalAndDeletes(t *testing.T) {
97
f := newFake(t)
98
s := newTestServer(t)
99
if w := adminReq(s, "POST", "/api/v1/admin/connect", `{"url":"`+f.ts.URL+`","key":"bgbk_test"}`); w.Code != 200 {
100
t.Fatalf("connect %d %s", w.Code, w.Body)
101
}
102
if _, err := s.SyncNow(context.Background()); err != nil {
103
t.Fatal(err)
104
}
105
if _, err := os.Stat(filepath.Join(s.Cfg.DataDir, "mirror", "data/repos/tim/a.git/HEAD")); err != nil {
106
t.Fatal(err)
107
}
108
if _, err := os.Stat(filepath.Join(s.Cfg.DataDir, "etc", "passwd")); err == nil {
109
t.Fatal("pad buiten de kopie geschreven")
110
}
111
// Ongewijzigd: niets opnieuw. Gewijzigde database: alleen die.
112
st, _ := s.SyncNow(context.Background())
113
if st.Downloaded != 0 {
114
t.Fatalf("tweede sync %+v", st)
115
}
116
f.mu.Lock()
117
f.files["state/bluegit.db"] = "db2"
118
delete(f.files, "data/repos/tim/a.git/HEAD")
119
f.mu.Unlock()
120
st, _ = s.SyncNow(context.Background())
121
if st.Downloaded != 1 || st.Deleted != 1 {
122
t.Fatalf("derde sync %+v", st)
123
}
124
if b, _ := os.ReadFile(filepath.Join(s.Cfg.DataDir, "mirror", "state/bluegit.db")); string(b) != "db2" {
125
t.Fatalf("db %q", b)
126
}
127
if _, err := os.Stat(filepath.Join(s.Cfg.DataDir, "mirror", "data/repos/tim")); err == nil {
128
t.Fatal("lege map blijft staan")
129
}
130
// Bestaat state.json en is het 0600 (er staat een key in).
131
fi, err := os.Stat(filepath.Join(s.Cfg.DataDir, "state.json"))
132
if err != nil || fi.Mode().Perm() != 0o600 {
133
t.Fatalf("state.json %v %v", err, fi)
134
}
135
}
136
137
func TestSignedEndpoints(t *testing.T) {
138
f := newFake(t)
139
s := newTestServer(t)
140
if w := adminReq(s, "POST", "/api/v1/admin/connect", `{"url":"`+f.ts.URL+`","key":"bgbk_test"}`); w.Code != 200 {
141
t.Fatalf("connect %d", w.Code)
142
}
143
h := s.Handler()
144
call := func(method, p, body, secret, inst string) int {
145
r := httptest.NewRequest(method, p, bytes.NewReader([]byte(body)))
146
if secret != "" {
147
protocol.Sign(r, secret, inst, []byte(body), time.Now())
148
}
149
w := httptest.NewRecorder()
150
h.ServeHTTP(w, r)
151
return w.Code
152
}
153
good := protocol.SigningSecret("bgbk_test")
154
if c := call("POST", "/api/v1/notify", "{}", "", ""); c != 401 {
155
t.Fatalf("zonder handtekening %d", c)
156
}
157
if c := call("POST", "/api/v1/notify", "{}", protocol.SigningSecret("bgbk_ander"), "inst-1"); c != 401 {
158
t.Fatalf("verkeerd geheim %d", c)
159
}
160
if c := call("POST", "/api/v1/notify", "{}", good, "inst-2"); c != 401 {
161
t.Fatalf("andere instantie %d", c)
162
}
163
if c := call("POST", "/api/v1/notify", "{}", good, "inst-1"); c != 204 {
164
t.Fatalf("melding %d", c)
165
}
166
if c := call("GET", "/api/v1/archives", "", good, "inst-1"); c != 200 {
167
t.Fatalf("archieven %d", c)
168
}
169
if c := call("POST", "/api/v1/rollback", `{"archive":"../x"}`, good, "inst-1"); c != 400 {
170
t.Fatalf("ongeldige naam %d", c)
171
}
172
if c := call("POST", "/api/v1/rollback", `{"archive":"bluegit-20261115-120000.tar.gz"}`, good, "inst-1"); c != 404 {
173
t.Fatalf("onbekend archief %d", c)
174
}
175
// Beheer-API zonder token.
176
r := httptest.NewRequest("GET", "/api/v1/admin/status", nil)
177
w := httptest.NewRecorder()
178
h.ServeHTTP(w, r)
179
if w.Code != 401 {
180
t.Fatalf("status zonder token %d", w.Code)
181
}
182
}
183
184
func TestConnectValidation(t *testing.T) {
185
f := newFake(t)
186
s := newTestServer(t)
187
for body, want := range map[string]int{
188
`{"url":"ftp://x","key":"bgbk_test"}`: 400,
189
`{"url":"` + f.ts.URL + `","key":"zonder-prefix"}`: 400,
190
`{"url":"` + f.ts.URL + `","key":"bgbk_fout"}`: 401,
191
`{"url":"` + f.ts.URL + `","key":"bgbk_test","on_conflict":"x"}`: 400,
192
} {
193
if w := adminReq(s, "POST", "/api/v1/admin/connect", body); w.Code != want {
194
t.Errorf("%s: %d, wil %d (%s)", body, w.Code, want, w.Body)
195
}
196
}
197
s.Cfg.PublicURL = ""
198
if w := adminReq(s, "POST", "/api/v1/admin/connect", `{"url":"`+f.ts.URL+`","key":"bgbk_test"}`); w.Code != 400 {
199
t.Fatalf("zonder public_url %d", w.Code)
200
}
201
}
202
203
func TestSelfUpdateEndpoint(t *testing.T) {
204
s := newTestServer(t)
205
h := s.Handler()
206
var got string
207
UpdateStarter = func(_ context.Context, ref string) error { got = ref; return nil }
208
call := func(tok, body string) int {
209
r := httptest.NewRequest("POST", "/api/v1/admin/self-update", strings.NewReader(body))
210
if tok != "" {
211
r.Header.Set("Authorization", "Bearer "+tok)
212
}
213
w := httptest.NewRecorder()
214
h.ServeHTTP(w, r)
215
return w.Code
216
}
217
t.Setenv("BLUEGIT_BACKUP_UPDATE_TOKEN", "")
218
if c := call("x", `{}`); c != 404 {
219
t.Fatalf("uit: %d", c)
220
}
221
t.Setenv("BLUEGIT_BACKUP_UPDATE_TOKEN", "geheim")
222
if c := call("fout", `{}`); c != 401 {
223
t.Fatalf("fout token: %d", c)
224
}
225
if c := call("geheim", `{"ref":"master"}`); c != 400 {
226
t.Fatalf("geen sha: %d", c)
227
}
228
sha := strings.Repeat("a", 40)
229
if c := call("geheim", `{"ref":"`+sha+`"}`); c != 202 || got != sha {
230
t.Fatalf("start: %d %q", c, got)
231
}
232
}
@@ -0,0 +1,232 @@1
package server2
3
import (4
"bytes"5
"context"6
"crypto/sha256"7
"encoding/hex"8
"encoding/json"9
"io"10
"net/http"11
"net/http/httptest"12
"os"13
"path/filepath"14
"strings"15
"sync"16
"testing"17
"time"18
19
"git.timfalken.com/timfa/bluegit-backup/internal/config"20
"git.timfalken.com/timfa/bluegit-backup/internal/protocol"21
)22
23
// fakeBlueGit is een minimale backup-API met bestanden in het geheugen.24
type fakeBlueGit struct {25
mu sync.Mutex26
key string27
inst string28
files map[string]string29
fetches map[string]int30
ts *httptest.Server31
}32
33
func newFake(t *testing.T) *fakeBlueGit {34
f := &fakeBlueGit{key: "bgbk_test", inst: "inst-1", fetches: map[string]int{},35
files: map[string]string{"state/bluegit.db": "db1", "state/secret.key": "k", "data/repos/tim/a.git/HEAD": "ref"}}36
f.ts = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {37
if r.Header.Get("Authorization") != "Bearer "+f.key {38
http.Error(w, `{"error":"key"}`, 401)39
return40
}41
f.mu.Lock()42
defer f.mu.Unlock()43
switch r.URL.Path {44
case "/api/v1/backup/info":45
_ = json.NewEncoder(w).Encode(protocol.Info{InstanceID: f.inst})46
case "/api/v1/backup/connect":47
w.WriteHeader(200)48
case "/api/v1/backup/manifest":49
m := protocol.Manifest{Instance: f.inst}50
for p, c := range f.files {51
e := protocol.Entry{Path: p, Size: int64(len(c)), MTime: int64(len(c)) * 1000, Mode: 0o644}52
if p == protocol.DBPath {53
s := sha256.Sum256([]byte(c))54
e.SHA256 = hex.EncodeToString(s[:])55
}56
m.Files = append(m.Files, e)57
}58
m.Files = append(m.Files, protocol.Entry{Path: "../../etc/passwd", Size: 1})59
_ = json.NewEncoder(w).Encode(m)60
case "/api/v1/backup/file":61
p := r.URL.Query().Get("path")62
c, ok := f.files[p]63
if !ok {64
http.Error(w, `{"error":"weg"}`, 404)65
return66
}67
f.fetches[p]++68
_, _ = io.WriteString(w, c)69
default:70
http.NotFound(w, r)71
}72
}))73
t.Cleanup(f.ts.Close)74
return f75
}76
77
func newTestServer(t *testing.T) *Server {78
cfg := config.Config{DataDir: t.TempDir(), PublicURL: "http://backup.test"}79
cfg.Defaults()80
cfg.RateLimitKiB = 081
s, err := New(cfg, nil)82
if err != nil {83
t.Fatal(err)84
}85
return s86
}87
88
func adminReq(s *Server, method, p, body string) *httptest.ResponseRecorder {89
r := httptest.NewRequest(method, p, strings.NewReader(body))90
r.Header.Set("Authorization", "Bearer "+s.AdminToken())91
w := httptest.NewRecorder()92
s.Handler().ServeHTTP(w, r)93
return w94
}95
96
func TestSyncIncrementalAndDeletes(t *testing.T) {97
f := newFake(t)98
s := newTestServer(t)99
if w := adminReq(s, "POST", "/api/v1/admin/connect", `{"url":"`+f.ts.URL+`","key":"bgbk_test"}`); w.Code != 200 {100
t.Fatalf("connect %d %s", w.Code, w.Body)101
}102
if _, err := s.SyncNow(context.Background()); err != nil {103
t.Fatal(err)104
}105
if _, err := os.Stat(filepath.Join(s.Cfg.DataDir, "mirror", "data/repos/tim/a.git/HEAD")); err != nil {106
t.Fatal(err)107
}108
if _, err := os.Stat(filepath.Join(s.Cfg.DataDir, "etc", "passwd")); err == nil {109
t.Fatal("pad buiten de kopie geschreven")110
}111
// Ongewijzigd: niets opnieuw. Gewijzigde database: alleen die.112
st, _ := s.SyncNow(context.Background())113
if st.Downloaded != 0 {114
t.Fatalf("tweede sync %+v", st)115
}116
f.mu.Lock()117
f.files["state/bluegit.db"] = "db2"118
delete(f.files, "data/repos/tim/a.git/HEAD")119
f.mu.Unlock()120
st, _ = s.SyncNow(context.Background())121
if st.Downloaded != 1 || st.Deleted != 1 {122
t.Fatalf("derde sync %+v", st)123
}124
if b, _ := os.ReadFile(filepath.Join(s.Cfg.DataDir, "mirror", "state/bluegit.db")); string(b) != "db2" {125
t.Fatalf("db %q", b)126
}127
if _, err := os.Stat(filepath.Join(s.Cfg.DataDir, "mirror", "data/repos/tim")); err == nil {128
t.Fatal("lege map blijft staan")129
}130
// Bestaat state.json en is het 0600 (er staat een key in).131
fi, err := os.Stat(filepath.Join(s.Cfg.DataDir, "state.json"))132
if err != nil || fi.Mode().Perm() != 0o600 {133
t.Fatalf("state.json %v %v", err, fi)134
}135
}136
137
func TestSignedEndpoints(t *testing.T) {138
f := newFake(t)139
s := newTestServer(t)140
if w := adminReq(s, "POST", "/api/v1/admin/connect", `{"url":"`+f.ts.URL+`","key":"bgbk_test"}`); w.Code != 200 {141
t.Fatalf("connect %d", w.Code)142
}143
h := s.Handler()144
call := func(method, p, body, secret, inst string) int {145
r := httptest.NewRequest(method, p, bytes.NewReader([]byte(body)))146
if secret != "" {147
protocol.Sign(r, secret, inst, []byte(body), time.Now())148
}149
w := httptest.NewRecorder()150
h.ServeHTTP(w, r)151
return w.Code152
}153
good := protocol.SigningSecret("bgbk_test")154
if c := call("POST", "/api/v1/notify", "{}", "", ""); c != 401 {155
t.Fatalf("zonder handtekening %d", c)156
}157
if c := call("POST", "/api/v1/notify", "{}", protocol.SigningSecret("bgbk_ander"), "inst-1"); c != 401 {158
t.Fatalf("verkeerd geheim %d", c)159
}160
if c := call("POST", "/api/v1/notify", "{}", good, "inst-2"); c != 401 {161
t.Fatalf("andere instantie %d", c)162
}163
if c := call("POST", "/api/v1/notify", "{}", good, "inst-1"); c != 204 {164
t.Fatalf("melding %d", c)165
}166
if c := call("GET", "/api/v1/archives", "", good, "inst-1"); c != 200 {167
t.Fatalf("archieven %d", c)168
}169
if c := call("POST", "/api/v1/rollback", `{"archive":"../x"}`, good, "inst-1"); c != 400 {170
t.Fatalf("ongeldige naam %d", c)171
}172
if c := call("POST", "/api/v1/rollback", `{"archive":"bluegit-20261115-120000.tar.gz"}`, good, "inst-1"); c != 404 {173
t.Fatalf("onbekend archief %d", c)174
}175
// Beheer-API zonder token.176
r := httptest.NewRequest("GET", "/api/v1/admin/status", nil)177
w := httptest.NewRecorder()178
h.ServeHTTP(w, r)179
if w.Code != 401 {180
t.Fatalf("status zonder token %d", w.Code)181
}182
}183
184
func TestConnectValidation(t *testing.T) {185
f := newFake(t)186
s := newTestServer(t)187
for body, want := range map[string]int{188
`{"url":"ftp://x","key":"bgbk_test"}`: 400,189
`{"url":"` + f.ts.URL + `","key":"zonder-prefix"}`: 400,190
`{"url":"` + f.ts.URL + `","key":"bgbk_fout"}`: 401,191
`{"url":"` + f.ts.URL + `","key":"bgbk_test","on_conflict":"x"}`: 400,192
} {193
if w := adminReq(s, "POST", "/api/v1/admin/connect", body); w.Code != want {194
t.Errorf("%s: %d, wil %d (%s)", body, w.Code, want, w.Body)195
}196
}197
s.Cfg.PublicURL = ""198
if w := adminReq(s, "POST", "/api/v1/admin/connect", `{"url":"`+f.ts.URL+`","key":"bgbk_test"}`); w.Code != 400 {199
t.Fatalf("zonder public_url %d", w.Code)200
}201
}202
203
func TestSelfUpdateEndpoint(t *testing.T) {204
s := newTestServer(t)205
h := s.Handler()206
var got string207
UpdateStarter = func(_ context.Context, ref string) error { got = ref; return nil }208
call := func(tok, body string) int {209
r := httptest.NewRequest("POST", "/api/v1/admin/self-update", strings.NewReader(body))210
if tok != "" {211
r.Header.Set("Authorization", "Bearer "+tok)212
}213
w := httptest.NewRecorder()214
h.ServeHTTP(w, r)215
return w.Code216
}217
t.Setenv("BLUEGIT_BACKUP_UPDATE_TOKEN", "")218
if c := call("x", `{}`); c != 404 {219
t.Fatalf("uit: %d", c)220
}221
t.Setenv("BLUEGIT_BACKUP_UPDATE_TOKEN", "geheim")222
if c := call("fout", `{}`); c != 401 {223
t.Fatalf("fout token: %d", c)224
}225
if c := call("geheim", `{"ref":"master"}`); c != 400 {226
t.Fatalf("geen sha: %d", c)227
}228
sha := strings.Repeat("a", 40)229
if c := call("geheim", `{"ref":"`+sha+`"}`); c != 202 || got != sha {230
t.Fatalf("start: %d %q", c, got)231
}232
}@@ -0,0 +1,72 @@
1
package server
2
3
import (
4
"crypto/rand"
5
"encoding/hex"
6
"encoding/json"
7
"errors"
8
"os"
9
"path/filepath"
10
"strings"
11
"time"
12
)
13
14
// State is de koppeling met de ene BlueGit. Bevat de key, dus 0600.
15
type State struct {
16
BlueGitURL string `json:"bluegit_url,omitempty"`
17
Key string `json:"key,omitempty"`
18
InstanceID string `json:"instance_id,omitempty"`
19
ConnectedAt time.Time `json:"connected_at,omitempty"`
20
}
21
22
// Connected zegt of er een BlueGit gekoppeld is.
23
func (s State) Connected() bool { return s.BlueGitURL != "" && s.Key != "" && s.InstanceID != "" }
24
25
func loadState(dir string) (State, error) {
26
var s State
27
b, err := os.ReadFile(filepath.Join(dir, "state.json"))
28
if errors.Is(err, os.ErrNotExist) {
29
return s, nil
30
}
31
if err != nil {
32
return s, err
33
}
34
return s, json.Unmarshal(b, &s)
35
}
36
37
func saveState(dir string, s State) error {
38
b, err := json.MarshalIndent(s, "", " ")
39
if err != nil {
40
return err
41
}
42
tmp := filepath.Join(dir, "state.json.tmp")
43
if err := os.WriteFile(tmp, b, 0o600); err != nil {
44
return err
45
}
46
return os.Rename(tmp, filepath.Join(dir, "state.json"))
47
}
48
49
// secretFile leest een willekeurig geheim uit dir/name of maakt het aan.
50
func secretFile(dir, name, prefix string) (string, error) {
51
p := filepath.Join(dir, name)
52
if b, err := os.ReadFile(p); err == nil {
53
if v := strings.TrimSpace(string(b)); v != "" {
54
return v, nil
55
}
56
}
57
raw := make([]byte, 24)
58
if _, err := rand.Read(raw); err != nil {
59
return "", err
60
}
61
v := prefix + hex.EncodeToString(raw)
62
return v, os.WriteFile(p, []byte(v+"\n"), 0o600)
63
}
64
65
// ReadAdminToken leest het lokale beheertoken (voor de CLI).
66
func ReadAdminToken(dataDir string) (string, error) {
67
b, err := os.ReadFile(filepath.Join(dataDir, "admin.token"))
68
if err != nil {
69
return "", err
70
}
71
return strings.TrimSpace(string(b)), nil
72
}
@@ -0,0 +1,72 @@1
package server2
3
import (4
"crypto/rand"5
"encoding/hex"6
"encoding/json"7
"errors"8
"os"9
"path/filepath"10
"strings"11
"time"12
)13
14
// State is de koppeling met de ene BlueGit. Bevat de key, dus 0600.15
type State struct {16
BlueGitURL string `json:"bluegit_url,omitempty"`17
Key string `json:"key,omitempty"`18
InstanceID string `json:"instance_id,omitempty"`19
ConnectedAt time.Time `json:"connected_at,omitempty"`20
}21
22
// Connected zegt of er een BlueGit gekoppeld is.23
func (s State) Connected() bool { return s.BlueGitURL != "" && s.Key != "" && s.InstanceID != "" }24
25
func loadState(dir string) (State, error) {26
var s State27
b, err := os.ReadFile(filepath.Join(dir, "state.json"))28
if errors.Is(err, os.ErrNotExist) {29
return s, nil30
}31
if err != nil {32
return s, err33
}34
return s, json.Unmarshal(b, &s)35
}36
37
func saveState(dir string, s State) error {38
b, err := json.MarshalIndent(s, "", " ")39
if err != nil {40
return err41
}42
tmp := filepath.Join(dir, "state.json.tmp")43
if err := os.WriteFile(tmp, b, 0o600); err != nil {44
return err45
}46
return os.Rename(tmp, filepath.Join(dir, "state.json"))47
}48
49
// secretFile leest een willekeurig geheim uit dir/name of maakt het aan.50
func secretFile(dir, name, prefix string) (string, error) {51
p := filepath.Join(dir, name)52
if b, err := os.ReadFile(p); err == nil {53
if v := strings.TrimSpace(string(b)); v != "" {54
return v, nil55
}56
}57
raw := make([]byte, 24)58
if _, err := rand.Read(raw); err != nil {59
return "", err60
}61
v := prefix + hex.EncodeToString(raw)62
return v, os.WriteFile(p, []byte(v+"\n"), 0o600)63
}64
65
// ReadAdminToken leest het lokale beheertoken (voor de CLI).66
func ReadAdminToken(dataDir string) (string, error) {67
b, err := os.ReadFile(filepath.Join(dataDir, "admin.token"))68
if err != nil {69
return "", err70
}71
return strings.TrimSpace(string(b)), nil72
}@@ -0,0 +1,27 @@
1
package server
2
3
import (
4
"context"
5
"fmt"
6
"os"
7
"os/exec"
8
"path/filepath"
9
)
10
11
// startUpdateUnit schrijft de gevraagde commit weg en start
12
// bluegit-backup-update.service. De polkit-regel uit packaging staat de
13
// gebruiker bluegit-backup alleen die ene unit toe.
14
func startUpdateUnit(ctx context.Context, ref string) error {
15
dir := os.Getenv("BLUEGIT_BACKUP_STATE_DIR")
16
if dir == "" {
17
dir = "/var/lib/bluegit-backup"
18
}
19
if err := os.WriteFile(filepath.Join(dir, "update-request"), []byte(ref+"\n"), 0o644); err != nil {
20
return err
21
}
22
out, err := exec.CommandContext(ctx, "systemctl", "start", "--no-block", "bluegit-backup-update.service").CombinedOutput()
23
if err != nil {
24
return fmt.Errorf("systemctl: %v: %s", err, out)
25
}
26
return nil
27
}
@@ -0,0 +1,27 @@1
package server2
3
import (4
"context"5
"fmt"6
"os"7
"os/exec"8
"path/filepath"9
)10
11
// startUpdateUnit schrijft de gevraagde commit weg en start12
// bluegit-backup-update.service. De polkit-regel uit packaging staat de13
// gebruiker bluegit-backup alleen die ene unit toe.14
func startUpdateUnit(ctx context.Context, ref string) error {15
dir := os.Getenv("BLUEGIT_BACKUP_STATE_DIR")16
if dir == "" {17
dir = "/var/lib/bluegit-backup"18
}19
if err := os.WriteFile(filepath.Join(dir, "update-request"), []byte(ref+"\n"), 0o644); err != nil {20
return err21
}22
out, err := exec.CommandContext(ctx, "systemctl", "start", "--no-block", "bluegit-backup-update.service").CombinedOutput()23
if err != nil {24
return fmt.Errorf("systemctl: %v: %s", err, out)25
}26
return nil27
}@@ -0,0 +1,104 @@
1
// Package throttle begrenst de leessnelheid met een token bucket.
2
package throttle
3
4
import (
5
"context"
6
"io"
7
"sync"
8
"time"
9
)
10
11
// Limiter is een token bucket in bytes per seconde, gedeeld door alle
12
// downloads van één server.
13
type Limiter struct {
14
mu sync.Mutex
15
rate float64 // bytes/s; 0 = onbegrensd
16
burst float64
17
tokens float64
18
last time.Time
19
now func() time.Time
20
sleep func(context.Context, time.Duration) error
21
}
22
23
// New maakt een limiter. bytesPerSec 0 = geen limiet. De burst is een
24
// kwart seconde, minstens 16 KiB.
25
func New(bytesPerSec int64) *Limiter {
26
l := &Limiter{rate: float64(bytesPerSec), now: time.Now, sleep: sleepCtx}
27
l.burst = l.rate / 4
28
if l.burst < 16<<10 {
29
l.burst = 16 << 10
30
}
31
l.tokens = l.burst
32
l.last = l.now()
33
return l
34
}
35
36
func sleepCtx(ctx context.Context, d time.Duration) error {
37
t := time.NewTimer(d)
38
defer t.Stop()
39
select {
40
case <-ctx.Done():
41
return ctx.Err()
42
case <-t.C:
43
return nil
44
}
45
}
46
47
// Rate is de ingestelde snelheid in bytes/s.
48
func (l *Limiter) Rate() int64 {
49
if l == nil {
50
return 0
51
}
52
return int64(l.rate)
53
}
54
55
// Wait blokkeert tot n bytes gelezen mogen worden.
56
func (l *Limiter) Wait(ctx context.Context, n int) error {
57
if l == nil || l.rate <= 0 || n <= 0 {
58
return nil
59
}
60
l.mu.Lock()
61
now := l.now()
62
l.tokens += now.Sub(l.last).Seconds() * l.rate
63
if l.tokens > l.burst {
64
l.tokens = l.burst
65
}
66
l.last = now
67
l.tokens -= float64(n)
68
var wait time.Duration
69
if l.tokens < 0 {
70
wait = time.Duration(-l.tokens / l.rate * float64(time.Second))
71
}
72
l.mu.Unlock()
73
if wait > 0 {
74
return l.sleep(ctx, wait)
75
}
76
return nil
77
}
78
79
// Reader begrenst r met l.
80
func (l *Limiter) Reader(ctx context.Context, r io.Reader) io.Reader {
81
if l == nil || l.rate <= 0 {
82
return r
83
}
84
return &reader{ctx: ctx, r: r, l: l}
85
}
86
87
type reader struct {
88
ctx context.Context
89
r io.Reader
90
l *Limiter
91
}
92
93
func (t *reader) Read(p []byte) (int, error) {
94
if max := int(t.l.burst); len(p) > max {
95
p = p[:max]
96
}
97
n, err := t.r.Read(p)
98
if n > 0 {
99
if werr := t.l.Wait(t.ctx, n); werr != nil {
100
return n, werr
101
}
102
}
103
return n, err
104
}
@@ -0,0 +1,104 @@1
// Package throttle begrenst de leessnelheid met een token bucket.2
package throttle3
4
import (5
"context"6
"io"7
"sync"8
"time"9
)10
11
// Limiter is een token bucket in bytes per seconde, gedeeld door alle12
// downloads van één server.13
type Limiter struct {14
mu sync.Mutex15
rate float64 // bytes/s; 0 = onbegrensd16
burst float6417
tokens float6418
last time.Time19
now func() time.Time20
sleep func(context.Context, time.Duration) error21
}22
23
// New maakt een limiter. bytesPerSec 0 = geen limiet. De burst is een24
// kwart seconde, minstens 16 KiB.25
func New(bytesPerSec int64) *Limiter {26
l := &Limiter{rate: float64(bytesPerSec), now: time.Now, sleep: sleepCtx}27
l.burst = l.rate / 428
if l.burst < 16<<10 {29
l.burst = 16 << 1030
}31
l.tokens = l.burst32
l.last = l.now()33
return l34
}35
36
func sleepCtx(ctx context.Context, d time.Duration) error {37
t := time.NewTimer(d)38
defer t.Stop()39
select {40
case <-ctx.Done():41
return ctx.Err()42
case <-t.C:43
return nil44
}45
}46
47
// Rate is de ingestelde snelheid in bytes/s.48
func (l *Limiter) Rate() int64 {49
if l == nil {50
return 051
}52
return int64(l.rate)53
}54
55
// Wait blokkeert tot n bytes gelezen mogen worden.56
func (l *Limiter) Wait(ctx context.Context, n int) error {57
if l == nil || l.rate <= 0 || n <= 0 {58
return nil59
}60
l.mu.Lock()61
now := l.now()62
l.tokens += now.Sub(l.last).Seconds() * l.rate63
if l.tokens > l.burst {64
l.tokens = l.burst65
}66
l.last = now67
l.tokens -= float64(n)68
var wait time.Duration69
if l.tokens < 0 {70
wait = time.Duration(-l.tokens / l.rate * float64(time.Second))71
}72
l.mu.Unlock()73
if wait > 0 {74
return l.sleep(ctx, wait)75
}76
return nil77
}78
79
// Reader begrenst r met l.80
func (l *Limiter) Reader(ctx context.Context, r io.Reader) io.Reader {81
if l == nil || l.rate <= 0 {82
return r83
}84
return &reader{ctx: ctx, r: r, l: l}85
}86
87
type reader struct {88
ctx context.Context89
r io.Reader90
l *Limiter91
}92
93
func (t *reader) Read(p []byte) (int, error) {94
if max := int(t.l.burst); len(p) > max {95
p = p[:max]96
}97
n, err := t.r.Read(p)98
if n > 0 {99
if werr := t.l.Wait(t.ctx, n); werr != nil {100
return n, werr101
}102
}103
return n, err104
}@@ -0,0 +1,52 @@
1
package throttle
2
3
import (
4
"bytes"
5
"context"
6
"io"
7
"testing"
8
"time"
9
)
10
11
func TestLimiterAverage(t *testing.T) {
12
now := time.Unix(0, 0)
13
slept := time.Duration(0)
14
l := New(100 << 10) // 100 KiB/s
15
l.now = func() time.Time { return now }
16
l.last = now
17
l.sleep = func(_ context.Context, d time.Duration) error {
18
slept += d
19
now = now.Add(d)
20
return nil
21
}
22
data := bytes.Repeat([]byte("x"), 1<<20) // 1 MiB
23
n, err := io.Copy(io.Discard, l.Reader(context.Background(), bytes.NewReader(data)))
24
if err != nil || n != 1<<20 {
25
t.Fatal(n, err)
26
}
27
// 1 MiB tegen 100 KiB/s is ruim 10 s, min de eerste burst van 25 KiB.
28
if slept < 9500*time.Millisecond || slept > 10500*time.Millisecond {
29
t.Fatalf("geslapen %v, verwacht ~10s", slept)
30
}
31
}
32
33
func TestUnlimited(t *testing.T) {
34
l := New(0)
35
r := bytes.NewReader([]byte("abc"))
36
if l.Reader(context.Background(), r) != r {
37
t.Fatal("onbegrensd hoort de reader niet te wikkelen")
38
}
39
if err := l.Wait(context.Background(), 1<<30); err != nil {
40
t.Fatal(err)
41
}
42
}
43
44
func TestCancel(t *testing.T) {
45
l := New(1024)
46
ctx, cancel := context.WithCancel(context.Background())
47
cancel()
48
_ = l.Wait(ctx, 16<<10)
49
if err := l.Wait(ctx, 16<<10); err == nil {
50
t.Fatal("geen fout na annuleren")
51
}
52
}
@@ -0,0 +1,52 @@1
package throttle2
3
import (4
"bytes"5
"context"6
"io"7
"testing"8
"time"9
)10
11
func TestLimiterAverage(t *testing.T) {12
now := time.Unix(0, 0)13
slept := time.Duration(0)14
l := New(100 << 10) // 100 KiB/s15
l.now = func() time.Time { return now }16
l.last = now17
l.sleep = func(_ context.Context, d time.Duration) error {18
slept += d19
now = now.Add(d)20
return nil21
}22
data := bytes.Repeat([]byte("x"), 1<<20) // 1 MiB23
n, err := io.Copy(io.Discard, l.Reader(context.Background(), bytes.NewReader(data)))24
if err != nil || n != 1<<20 {25
t.Fatal(n, err)26
}27
// 1 MiB tegen 100 KiB/s is ruim 10 s, min de eerste burst van 25 KiB.28
if slept < 9500*time.Millisecond || slept > 10500*time.Millisecond {29
t.Fatalf("geslapen %v, verwacht ~10s", slept)30
}31
}32
33
func TestUnlimited(t *testing.T) {34
l := New(0)35
r := bytes.NewReader([]byte("abc"))36
if l.Reader(context.Background(), r) != r {37
t.Fatal("onbegrensd hoort de reader niet te wikkelen")38
}39
if err := l.Wait(context.Background(), 1<<30); err != nil {40
t.Fatal(err)41
}42
}43
44
func TestCancel(t *testing.T) {45
l := New(1024)46
ctx, cancel := context.WithCancel(context.Background())47
cancel()48
_ = l.Wait(ctx, 16<<10)49
if err := l.Wait(ctx, 16<<10); err == nil {50
t.Fatal("geen fout na annuleren")51
}52
}@@ -0,0 +1,39 @@
1
# Maintainer: Tim Falken <tim@timfalken.com>
2
pkgname=bluegit-backup
3
pkgver=20261115000000
4
pkgrel=1
5
pkgdesc='Backup server for a BlueGit instance: incremental copy, archives, rollback'
6
arch=('x86_64' 'aarch64')
7
url='https://git.timfalken.com/timfa/bluegit-backup'
8
license=('MIT')
9
depends=('curl')
10
makedepends=('go')
11
backup=('etc/bluegit-backup/config.yml')
12
options=('!debug')
13
install=bluegit-backup.install
14
_commit=0000000000000000000000000000000000000000
15
source=("bluegit-backup-${_commit}.tar.gz::https://git.timfalken.com/timfa/bluegit-backup/-/archive/${_commit}/bluegit-backup-${_commit}.tar.gz")
16
sha256sums=('SKIP')
17
18
build() {
19
cd "$srcdir/bluegit-backup-${_commit}"
20
export CGO_ENABLED=0
21
export GOTOOLCHAIN=auto
22
export GOFLAGS='-trimpath'
23
export GOCACHE="${BUILDDIR:-$srcdir}/gocache"
24
export GOPATH="${BUILDDIR:-$srcdir}/gopath"
25
go build -ldflags="-s -w -X git.timfalken.com/timfa/bluegit-backup/internal/server.Version=${pkgver}" -o bluegit-backup ./cmd/bluegit-backup
26
}
27
28
package() {
29
cd "$srcdir/bluegit-backup-${_commit}"
30
install -Dm755 bluegit-backup "$pkgdir/usr/bin/bluegit-backup"
31
install -Dm644 packaging/bluegit-backup.service "$pkgdir/usr/lib/systemd/system/bluegit-backup.service"
32
install -Dm644 packaging/config.yml "$pkgdir/etc/bluegit-backup/config.yml"
33
install -Dm644 packaging/sysusers.conf "$pkgdir/usr/lib/sysusers.d/bluegit-backup.conf"
34
install -Dm644 packaging/tmpfiles.conf "$pkgdir/usr/lib/tmpfiles.d/bluegit-backup.conf"
35
install -Dm755 packaging/bluegit-backup-update.sh "$pkgdir/usr/lib/bluegit-backup/update"
36
install -Dm644 packaging/bluegit-backup-update.service "$pkgdir/usr/lib/systemd/system/bluegit-backup-update.service"
37
install -Dm644 packaging/bluegit-backup-update.rules "$pkgdir/usr/share/polkit-1/rules.d/49-bluegit-backup-update.rules"
38
install -Dm644 LICENSE "$pkgdir/usr/share/licenses/$pkgname/LICENSE"
39
}
@@ -0,0 +1,39 @@1
# Maintainer: Tim Falken <tim@timfalken.com>2
pkgname=bluegit-backup3
pkgver=202611150000004
pkgrel=15
pkgdesc='Backup server for a BlueGit instance: incremental copy, archives, rollback'6
arch=('x86_64' 'aarch64')7
url='https://git.timfalken.com/timfa/bluegit-backup'8
license=('MIT')9
depends=('curl')10
makedepends=('go')11
backup=('etc/bluegit-backup/config.yml')12
options=('!debug')13
install=bluegit-backup.install14
_commit=000000000000000000000000000000000000000015
source=("bluegit-backup-${_commit}.tar.gz::https://git.timfalken.com/timfa/bluegit-backup/-/archive/${_commit}/bluegit-backup-${_commit}.tar.gz")16
sha256sums=('SKIP')17
18
build() {19
cd "$srcdir/bluegit-backup-${_commit}"20
export CGO_ENABLED=021
export GOTOOLCHAIN=auto22
export GOFLAGS='-trimpath'23
export GOCACHE="${BUILDDIR:-$srcdir}/gocache"24
export GOPATH="${BUILDDIR:-$srcdir}/gopath"25
go build -ldflags="-s -w -X git.timfalken.com/timfa/bluegit-backup/internal/server.Version=${pkgver}" -o bluegit-backup ./cmd/bluegit-backup26
}27
28
package() {29
cd "$srcdir/bluegit-backup-${_commit}"30
install -Dm755 bluegit-backup "$pkgdir/usr/bin/bluegit-backup"31
install -Dm644 packaging/bluegit-backup.service "$pkgdir/usr/lib/systemd/system/bluegit-backup.service"32
install -Dm644 packaging/config.yml "$pkgdir/etc/bluegit-backup/config.yml"33
install -Dm644 packaging/sysusers.conf "$pkgdir/usr/lib/sysusers.d/bluegit-backup.conf"34
install -Dm644 packaging/tmpfiles.conf "$pkgdir/usr/lib/tmpfiles.d/bluegit-backup.conf"35
install -Dm755 packaging/bluegit-backup-update.sh "$pkgdir/usr/lib/bluegit-backup/update"36
install -Dm644 packaging/bluegit-backup-update.service "$pkgdir/usr/lib/systemd/system/bluegit-backup-update.service"37
install -Dm644 packaging/bluegit-backup-update.rules "$pkgdir/usr/share/polkit-1/rules.d/49-bluegit-backup-update.rules"38
install -Dm644 LICENSE "$pkgdir/usr/share/licenses/$pkgname/LICENSE"39
}@@ -0,0 +1,39 @@
1
# System-unit met User=bluegit-backup, config in /etc/bluegit-backup/config.yml
2
# en gegevens in /var/lib/bluegit-backup. post_upgrade herstart de dienst.
3
# backup= in de PKGBUILD laat een bestaande config.yml staan.
4
5
_bb_run() {
6
if ! command -v systemctl >/dev/null 2>&1 || [[ ! -d /run/systemd/system ]]; then
7
echo "bluegit-backup: systemd draait niet (chroot of container). De service is niet aangepast."
8
return 0
9
fi
10
systemctl "$@" || true
11
}
12
13
post_install() {
14
systemd-sysusers bluegit-backup.conf || true
15
systemd-tmpfiles --create bluegit-backup.conf || true
16
_bb_run daemon-reload
17
cat <<'MSG'
18
bluegit-backup: zet public_url in /etc/bluegit-backup/config.yml (het adres waarop
19
BlueGit deze server bereikt) en start de dienst:
20
systemctl enable --now bluegit-backup.service
21
Maak daarna in BlueGit onder Beheer > Backup een Backupserver-Key en koppel:
22
sudo -u bluegit-backup BLUEGIT_BACKUP_KEY=bgbk_… bluegit-backup connect --url https://git.example.com
23
MSG
24
}
25
26
post_upgrade() {
27
systemd-sysusers bluegit-backup.conf || true
28
systemd-tmpfiles --create bluegit-backup.conf || true
29
_bb_run daemon-reload
30
_bb_run try-restart bluegit-backup.service
31
}
32
33
pre_remove() {
34
_bb_run disable --now bluegit-backup.service
35
}
36
37
post_remove() {
38
_bb_run daemon-reload
39
}
@@ -0,0 +1,39 @@1
# System-unit met User=bluegit-backup, config in /etc/bluegit-backup/config.yml2
# en gegevens in /var/lib/bluegit-backup. post_upgrade herstart de dienst.3
# backup= in de PKGBUILD laat een bestaande config.yml staan.4
5
_bb_run() {6
if ! command -v systemctl >/dev/null 2>&1 || [[ ! -d /run/systemd/system ]]; then7
echo "bluegit-backup: systemd draait niet (chroot of container). De service is niet aangepast."8
return 09
fi10
systemctl "$@" || true11
}12
13
post_install() {14
systemd-sysusers bluegit-backup.conf || true15
systemd-tmpfiles --create bluegit-backup.conf || true16
_bb_run daemon-reload17
cat <<'MSG'18
bluegit-backup: zet public_url in /etc/bluegit-backup/config.yml (het adres waarop19
BlueGit deze server bereikt) en start de dienst:20
systemctl enable --now bluegit-backup.service21
Maak daarna in BlueGit onder Beheer > Backup een Backupserver-Key en koppel:22
sudo -u bluegit-backup BLUEGIT_BACKUP_KEY=bgbk_… bluegit-backup connect --url https://git.example.com23
MSG24
}25
26
post_upgrade() {27
systemd-sysusers bluegit-backup.conf || true28
systemd-tmpfiles --create bluegit-backup.conf || true29
_bb_run daemon-reload30
_bb_run try-restart bluegit-backup.service31
}32
33
pre_remove() {34
_bb_run disable --now bluegit-backup.service35
}36
37
post_remove() {38
_bb_run daemon-reload39
}@@ -0,0 +1,25 @@
1
[Unit]
2
Description=BlueGit backup server
3
After=network-online.target
4
Wants=network-online.target
5
6
[Service]
7
Type=simple
8
User=bluegit-backup
9
Group=bluegit-backup
10
# Optioneel. BLUEGIT_BACKUP_UPDATE_TOKEN zet POST /api/v1/admin/self-update aan.
11
EnvironmentFile=-/etc/bluegit-backup/env
12
ExecStart=/usr/bin/bluegit-backup serve --config /etc/bluegit-backup/config.yml
13
Restart=on-failure
14
# Lage prioriteit: archiveren en comprimeren mogen de machine niet ophouden.
15
Nice=10
16
IOSchedulingClass=idle
17
NoNewPrivileges=true
18
ProtectSystem=strict
19
ProtectHome=true
20
StateDirectory=bluegit-backup
21
ReadWritePaths=/var/lib/bluegit-backup
22
PrivateTmp=true
23
24
[Install]
25
WantedBy=multi-user.target
@@ -0,0 +1,25 @@1
[Unit]2
Description=BlueGit backup server3
After=network-online.target4
Wants=network-online.target5
6
[Service]7
Type=simple8
User=bluegit-backup9
Group=bluegit-backup10
# Optioneel. BLUEGIT_BACKUP_UPDATE_TOKEN zet POST /api/v1/admin/self-update aan.11
EnvironmentFile=-/etc/bluegit-backup/env12
ExecStart=/usr/bin/bluegit-backup serve --config /etc/bluegit-backup/config.yml13
Restart=on-failure14
# Lage prioriteit: archiveren en comprimeren mogen de machine niet ophouden.15
Nice=1016
IOSchedulingClass=idle17
NoNewPrivileges=true18
ProtectSystem=strict19
ProtectHome=true20
StateDirectory=bluegit-backup21
ReadWritePaths=/var/lib/bluegit-backup22
PrivateTmp=true23
24
[Install]25
WantedBy=multi-user.target@@ -0,0 +1,17 @@
1
# bluegit-backup. Kopieer naar /etc/bluegit-backup/config.yml.
2
listen: 0.0.0.0:8790
3
# Waar BlueGit deze server bereikt (meldingen, archieflijst, rollback).
4
public_url: http://backup.lan:8790
5
data_dir: /var/lib/bluegit-backup
6
# Zo vaak wordt de hele kopie gecomprimeerd opgeslagen. Standaard dagelijks.
7
archive_interval: 24h
8
# Archieven ouder dan dit gaan weg (0 = nooit op leeftijd). Het nieuwste blijft.
9
retention_days: 30
10
# Minder vrije ruimte dan dit: het oudste archief gaat weg.
11
min_free_mb: 1024
12
# Downloadsnelheid van BlueGit in KiB/s, zodat BlueGit er geen last van heeft.
13
rate_limit_kib: 1024
14
# Ook zonder melding zo vaak alles nalopen.
15
full_sync_interval: 1h
16
# Minimale tijd tussen twee syncs na meldingen.
17
min_sync_interval: 10s
@@ -0,0 +1,17 @@1
# bluegit-backup. Kopieer naar /etc/bluegit-backup/config.yml.2
listen: 0.0.0.0:87903
# Waar BlueGit deze server bereikt (meldingen, archieflijst, rollback).4
public_url: http://backup.lan:87905
data_dir: /var/lib/bluegit-backup6
# Zo vaak wordt de hele kopie gecomprimeerd opgeslagen. Standaard dagelijks.7
archive_interval: 24h8
# Archieven ouder dan dit gaan weg (0 = nooit op leeftijd). Het nieuwste blijft.9
retention_days: 3010
# Minder vrije ruimte dan dit: het oudste archief gaat weg.11
min_free_mb: 102412
# Downloadsnelheid van BlueGit in KiB/s, zodat BlueGit er geen last van heeft.13
rate_limit_kib: 102414
# Ook zonder melding zo vaak alles nalopen.15
full_sync_interval: 1h16
# Minimale tijd tussen twee syncs na meldingen.17
min_sync_interval: 10s@@ -0,0 +1,2 @@
1
u bluegit-backup - "BlueGit backup server" /var/lib/bluegit-backup /usr/sbin/nologin
2
u bluegit-backup-build - "bluegit-backup package build" /var/lib/bluegit-backup-build /usr/bin/nologin
@@ -0,0 +1,2 @@1
u bluegit-backup - "BlueGit backup server" /var/lib/bluegit-backup /usr/sbin/nologin2
u bluegit-backup-build - "bluegit-backup package build" /var/lib/bluegit-backup-build /usr/bin/nologin@@ -0,0 +1,2 @@
1
d /var/lib/bluegit-backup 0750 bluegit-backup bluegit-backup -
2
d /var/lib/bluegit-backup-build 0750 bluegit-backup-build bluegit-backup-build -
@@ -0,0 +1,2 @@1
d /var/lib/bluegit-backup 0750 bluegit-backup bluegit-backup -2
d /var/lib/bluegit-backup-build 0750 bluegit-backup-build bluegit-backup-build -@@ -0,0 +1,12 @@
1
// Alleen gebruiker bluegit-backup mag deze ene unit starten.
2
polkit.addRule(function(action, subject) {
3
if (action.id != "org.freedesktop.systemd1.manage-units") {
4
return;
5
}
6
if (subject.user != "bluegit-backup") {
7
return;
8
}
9
if (action.lookup("verb") == "start" && action.lookup("unit") == "bluegit-backup-update.service") {
10
return polkit.Result.YES;
11
}
12
});
@@ -0,0 +1,12 @@1
// Alleen gebruiker bluegit-backup mag deze ene unit starten.2
polkit.addRule(function(action, subject) {3
if (action.id != "org.freedesktop.systemd1.manage-units") {4
return;5
}6
if (subject.user != "bluegit-backup") {7
return;8
}9
if (action.lookup("verb") == "start" && action.lookup("unit") == "bluegit-backup-update.service") {10
return polkit.Result.YES;11
}12
});@@ -0,0 +1,16 @@
1
[Unit]
2
Description=bluegit-backup self-update
3
After=network-online.target
4
Wants=network-online.target
5
6
[Service]
7
Type=oneshot
8
# Root installeert de nieuwe binary. De bluegit-backup-gebruiker mag alleen deze unit starten.
9
User=root
10
Environment=BLUEGIT_BACKUP_STATE_DIR=/var/lib/bluegit-backup
11
Environment=BLUEGIT_BACKUP_BUILD_USER=bluegit-backup-build
12
EnvironmentFile=-/etc/bluegit-backup/env
13
ExecStart=/usr/lib/bluegit-backup/update
14
TimeoutStartSec=1h
15
StandardOutput=journal
16
StandardError=journal
@@ -0,0 +1,16 @@1
[Unit]2
Description=bluegit-backup self-update3
After=network-online.target4
Wants=network-online.target5
6
[Service]7
Type=oneshot8
# Root installeert de nieuwe binary. De bluegit-backup-gebruiker mag alleen deze unit starten.9
User=root10
Environment=BLUEGIT_BACKUP_STATE_DIR=/var/lib/bluegit-backup11
Environment=BLUEGIT_BACKUP_BUILD_USER=bluegit-backup-build12
EnvironmentFile=-/etc/bluegit-backup/env13
ExecStart=/usr/lib/bluegit-backup/update14
TimeoutStartSec=1h15
StandardOutput=journal16
StandardError=journal@@ -0,0 +1,51 @@
1
#!/usr/bin/env bash
2
# Self-update van bluegit-backup. Draait als root via bluegit-backup-update.service.
3
# Leest de commit uit update-request, haalt de bronarchief van die commit op,
4
# bouwt als onbevoegde gebruiker en installeert de binary. Met pacman en
5
# makepkg bouwt hij het AUR-pakket (zelfde PKGBUILD); anders alleen de binary.
6
# Bij een fout blijft de geïnstalleerde versie staan.
7
set -euo pipefail
8
9
: "${BLUEGIT_BACKUP_STATE_DIR:=/var/lib/bluegit-backup}"
10
: "${BLUEGIT_BACKUP_BUILD_USER:=bluegit-backup-build}"
11
: "${BLUEGIT_BACKUP_SOURCE:=https://git.timfalken.com/timfa/bluegit-backup}"
12
13
REQUEST="${BLUEGIT_BACKUP_STATE_DIR}/update-request"
14
STATUS="${BLUEGIT_BACKUP_STATE_DIR}/update-status.json"
15
16
write_status() {
17
local result="$1" sha="$2" err="${3:-}"
18
err="${err//$'\n'/ }"
19
err="${err//\"/}"
20
printf '{"time":"%s","sha":"%s","result":"%s","error":"%s"}\n' "$(date -u +%Y-%m-%dT%H:%M:%SZ)" "$sha" "$result" "$err" > "$STATUS.tmp"
21
chmod 644 "$STATUS.tmp"
22
mv -f "$STATUS.tmp" "$STATUS"
23
}
24
25
sha="$(tr -d '[:space:]' < "$REQUEST" 2>/dev/null || true)"
26
if [[ ! "$sha" =~ ^[0-9a-f]{40}$ ]]; then
27
write_status failed "" "update-request is geen volledige sha"
28
exit 1
29
fi
30
trap 'write_status failed "$sha" "zie journalctl -u bluegit-backup-update"' ERR
31
32
work="$(mktemp -d /var/tmp/bluegit-backup-update.XXXXXX)"
33
trap 'rm -rf "$work"' EXIT
34
chown "$BLUEGIT_BACKUP_BUILD_USER:" "$work"
35
url="${BLUEGIT_BACKUP_SOURCE}/-/archive/${sha}/bluegit-backup-${sha}.tar.gz"
36
echo "Downloaden: $url"
37
runuser -u "$BLUEGIT_BACKUP_BUILD_USER" -- curl -fsSL "$url" -o "$work/src.tar.gz"
38
runuser -u "$BLUEGIT_BACKUP_BUILD_USER" -- tar -xzf "$work/src.tar.gz" -C "$work"
39
src="$work/bluegit-backup-${sha}"
40
[[ -d "$src" ]] || src="$(find "$work" -mindepth 1 -maxdepth 1 -type d | head -n 1)"
41
42
echo "Bouwen als $BLUEGIT_BACKUP_BUILD_USER"
43
runuser -u "$BLUEGIT_BACKUP_BUILD_USER" -- env HOME="$work" GOCACHE="$work/gocache" GOPATH="$work/gopath" \
44
CGO_ENABLED=0 GOTOOLCHAIN=auto GOFLAGS=-trimpath \
45
sh -c "cd '$src' && go build -ldflags='-s -w -X git.timfalken.com/timfa/bluegit-backup/internal/server.Version=${sha:0:12}' -o '$work/bluegit-backup' ./cmd/bluegit-backup"
46
47
install -Dm755 "$work/bluegit-backup" /usr/bin/bluegit-backup.new
48
mv -f /usr/bin/bluegit-backup.new /usr/bin/bluegit-backup
49
systemctl try-restart bluegit-backup.service
50
write_status success "$sha"
51
echo "bluegit-backup bijgewerkt naar $sha"
@@ -0,0 +1,51 @@1
#!/usr/bin/env bash2
# Self-update van bluegit-backup. Draait als root via bluegit-backup-update.service.3
# Leest de commit uit update-request, haalt de bronarchief van die commit op,4
# bouwt als onbevoegde gebruiker en installeert de binary. Met pacman en5
# makepkg bouwt hij het AUR-pakket (zelfde PKGBUILD); anders alleen de binary.6
# Bij een fout blijft de geïnstalleerde versie staan.7
set -euo pipefail8
9
: "${BLUEGIT_BACKUP_STATE_DIR:=/var/lib/bluegit-backup}"10
: "${BLUEGIT_BACKUP_BUILD_USER:=bluegit-backup-build}"11
: "${BLUEGIT_BACKUP_SOURCE:=https://git.timfalken.com/timfa/bluegit-backup}"12
13
REQUEST="${BLUEGIT_BACKUP_STATE_DIR}/update-request"14
STATUS="${BLUEGIT_BACKUP_STATE_DIR}/update-status.json"15
16
write_status() {17
local result="$1" sha="$2" err="${3:-}"18
err="${err//$'\n'/ }"19
err="${err//\"/}"20
printf '{"time":"%s","sha":"%s","result":"%s","error":"%s"}\n' "$(date -u +%Y-%m-%dT%H:%M:%SZ)" "$sha" "$result" "$err" > "$STATUS.tmp"21
chmod 644 "$STATUS.tmp"22
mv -f "$STATUS.tmp" "$STATUS"23
}24
25
sha="$(tr -d '[:space:]' < "$REQUEST" 2>/dev/null || true)"26
if [[ ! "$sha" =~ ^[0-9a-f]{40}$ ]]; then27
write_status failed "" "update-request is geen volledige sha"28
exit 129
fi30
trap 'write_status failed "$sha" "zie journalctl -u bluegit-backup-update"' ERR31
32
work="$(mktemp -d /var/tmp/bluegit-backup-update.XXXXXX)"33
trap 'rm -rf "$work"' EXIT34
chown "$BLUEGIT_BACKUP_BUILD_USER:" "$work"35
url="${BLUEGIT_BACKUP_SOURCE}/-/archive/${sha}/bluegit-backup-${sha}.tar.gz"36
echo "Downloaden: $url"37
runuser -u "$BLUEGIT_BACKUP_BUILD_USER" -- curl -fsSL "$url" -o "$work/src.tar.gz"38
runuser -u "$BLUEGIT_BACKUP_BUILD_USER" -- tar -xzf "$work/src.tar.gz" -C "$work"39
src="$work/bluegit-backup-${sha}"40
[[ -d "$src" ]] || src="$(find "$work" -mindepth 1 -maxdepth 1 -type d | head -n 1)"41
42
echo "Bouwen als $BLUEGIT_BACKUP_BUILD_USER"43
runuser -u "$BLUEGIT_BACKUP_BUILD_USER" -- env HOME="$work" GOCACHE="$work/gocache" GOPATH="$work/gopath" \44
CGO_ENABLED=0 GOTOOLCHAIN=auto GOFLAGS=-trimpath \45
sh -c "cd '$src' && go build -ldflags='-s -w -X git.timfalken.com/timfa/bluegit-backup/internal/server.Version=${sha:0:12}' -o '$work/bluegit-backup' ./cmd/bluegit-backup"46
47
install -Dm755 "$work/bluegit-backup" /usr/bin/bluegit-backup.new48
mv -f /usr/bin/bluegit-backup.new /usr/bin/bluegit-backup49
systemctl try-restart bluegit-backup.service50
write_status success "$sha"51
echo "bluegit-backup bijgewerkt naar $sha"