bluegit-backup samengevoegd in BlueGit (met history uit timfa/bluegit-backup)
@@ -0,0 +1,349 @@
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
"net/url"
16
"os"
17
"os/signal"
18
"strings"
19
"syscall"
20
"time"
21
22
"git.timfalken.com/timfa/bluegit-backup/internal/config"
23
"git.timfalken.com/timfa/bluegit-backup/internal/server"
24
)
25
26
func usage() {
27
fmt.Fprint(os.Stderr, `bluegit-backup
28
29
bluegit-backup serve [--config /etc/bluegit-backup/config.yml]
30
bluegit-backup connect [--config …] --url https://git.example.com [--key bgbk_…] [--on-conflict wipe|restore]
31
bluegit-backup status [--config …]
32
bluegit-backup list [--config …]
33
bluegit-backup archive [--config …] nu een archief maken
34
bluegit-backup sync [--config …] nu synchroniseren
35
bluegit-backup prune [--config …] bewaarregels nu toepassen
36
bluegit-backup config [--config …] instellingen tonen
37
bluegit-backup set [--config …] sleutel=waarde … instellingen wijzigen
38
bluegit-backup delete [--config …] ARCHIEF
39
bluegit-backup rollback [--config …] ARCHIEF (vraagt om de naam over te typen)
40
bluegit-backup disconnect [--config …]
41
bluegit-backup actions [--config …] alle API-acties
42
bluegit-backup token [--config …] het beheertoken voor de webinterface
43
bluegit-backup example-config
44
bluegit-backup version
45
46
De key kan ook uit BLUEGIT_BACKUP_KEY komen (dan staat hij niet in de proceslijst).
47
`)
48
}
49
50
func main() {
51
if len(os.Args) < 2 {
52
usage()
53
os.Exit(2)
54
}
55
var err error
56
switch os.Args[1] {
57
case "serve":
58
err = serve(os.Args[2:])
59
case "connect":
60
err = connect(os.Args[2:], os.Stdin, os.Stdout)
61
case "status":
62
err = simple(os.Args[2:], http.MethodGet, "/api/v1/admin/status")
63
case "list":
64
err = simple(os.Args[2:], http.MethodGet, "/api/v1/admin/archives")
65
case "archive":
66
err = simple(os.Args[2:], http.MethodPost, "/api/v1/admin/archive")
67
case "sync":
68
err = simple(os.Args[2:], http.MethodPost, "/api/v1/admin/sync")
69
case "prune":
70
err = simple(os.Args[2:], http.MethodPost, "/api/v1/admin/prune")
71
case "config":
72
err = simple(os.Args[2:], http.MethodGet, "/api/v1/admin/config")
73
case "set":
74
err = setConfig(os.Args[2:])
75
case "disconnect":
76
err = simple(os.Args[2:], http.MethodPost, "/api/v1/admin/disconnect")
77
case "delete":
78
err = withName(os.Args[2:], func(c *client, name string) (int, []byte, error) {
79
return c.do(http.MethodDelete, "/api/v1/admin/archives/"+url.PathEscape(name), nil)
80
})
81
case "rollback":
82
err = rollback(os.Args[2:], os.Stdin, os.Stdout)
83
case "actions":
84
err = simple(os.Args[2:], http.MethodGet, "/api/v1/admin/actions")
85
case "token":
86
err = printToken(os.Args[2:])
87
case "example-config":
88
fmt.Print(config.Example())
89
case "version":
90
fmt.Println(server.Version)
91
default:
92
usage()
93
os.Exit(2)
94
}
95
if err != nil {
96
fmt.Fprintln(os.Stderr, "bluegit-backup:", err)
97
os.Exit(1)
98
}
99
}
100
101
func configPath(p string) string {
102
if p != "" {
103
return p
104
}
105
if v := os.Getenv("BLUEGIT_BACKUP_CONFIG"); v != "" {
106
return v
107
}
108
if _, err := os.Stat("bluegit-backup.yml"); err == nil {
109
return "bluegit-backup.yml"
110
}
111
return "/etc/bluegit-backup/config.yml"
112
}
113
114
func serve(args []string) error {
115
fs := flag.NewFlagSet("serve", flag.ExitOnError)
116
cfgPath := fs.String("config", "", "pad naar config.yml")
117
_ = fs.Parse(args)
118
cfg, err := config.Load(configPath(*cfgPath))
119
if err != nil {
120
return err
121
}
122
log := slog.New(slog.NewTextHandler(os.Stdout, nil))
123
srv, err := server.New(cfg, log)
124
if err != nil {
125
return err
126
}
127
ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
128
defer stop()
129
cfg = srv.Cfg // met settings.yml
130
ln, err := net.Listen("tcp", cfg.Listen)
131
if err != nil {
132
return err
133
}
134
hs := &http.Server{Handler: srv.Handler(), ReadHeaderTimeout: 10 * time.Second}
135
go func() {
136
<-ctx.Done()
137
c, cancel := context.WithTimeout(context.Background(), 10*time.Second)
138
defer cancel()
139
_ = hs.Shutdown(c)
140
}()
141
srv.Run(ctx)
142
log.Info("bluegit-backup luistert", "addr", ln.Addr().String(), "public_url", cfg.PublicURL, "version", server.Version)
143
if err := hs.Serve(ln); err != nil && err != http.ErrServerClosed {
144
return err
145
}
146
return nil
147
}
148
149
type client struct {
150
base, token string
151
}
152
153
func newClient(cfgPath string) (*client, error) {
154
cfg, err := config.Load(configPath(cfgPath))
155
if err != nil {
156
return nil, err
157
}
158
if set, err := config.LoadSettings(cfg.DataDir); err == nil {
159
_ = cfg.Apply(set)
160
}
161
tok, err := server.ReadAdminToken(cfg.DataDir)
162
if err != nil {
163
return nil, fmt.Errorf("admin.token lezen (draai als de gebruiker van de dienst of root): %w", err)
164
}
165
host, port, err := net.SplitHostPort(cfg.Listen)
166
if err != nil {
167
return nil, err
168
}
169
if host == "" || host == "0.0.0.0" || host == "::" {
170
host = "127.0.0.1"
171
}
172
return &client{base: "http://" + net.JoinHostPort(host, port), token: tok}, nil
173
}
174
175
func (c *client) do(method, p string, in any) (int, []byte, error) {
176
var body io.Reader
177
if in != nil {
178
b, _ := json.Marshal(in)
179
body = bytes.NewReader(b)
180
}
181
req, _ := http.NewRequest(method, c.base+p, body)
182
req.Header.Set("Authorization", "Bearer "+c.token)
183
req.Header.Set("Content-Type", "application/json")
184
resp, err := (&http.Client{Timeout: 30 * time.Minute}).Do(req)
185
if err != nil {
186
return 0, nil, err
187
}
188
defer resp.Body.Close()
189
b, _ := io.ReadAll(resp.Body)
190
return resp.StatusCode, b, nil
191
}
192
193
func printResult(code int, b []byte) error {
194
var pretty bytes.Buffer
195
if json.Indent(&pretty, b, "", " ") == nil {
196
b = pretty.Bytes()
197
}
198
fmt.Println(strings.TrimSpace(string(b)))
199
if code >= 300 {
200
return fmt.Errorf("HTTP %d", code)
201
}
202
return nil
203
}
204
205
func setConfig(args []string) error {
206
fs := flag.NewFlagSet("set", flag.ExitOnError)
207
cfgPath := fs.String("config", "", "pad naar config.yml")
208
_ = fs.Parse(args)
209
set := map[string]string{}
210
for _, kv := range fs.Args() {
211
k, v, ok := strings.Cut(kv, "=")
212
if !ok {
213
return fmt.Errorf("verwacht sleutel=waarde, kreeg %q", kv)
214
}
215
set[k] = v
216
}
217
if len(set) == 0 {
218
return fmt.Errorf("geef minstens één sleutel=waarde")
219
}
220
c, err := newClient(*cfgPath)
221
if err != nil {
222
return err
223
}
224
code, b, err := c.do(http.MethodPut, "/api/v1/admin/config", set)
225
if err != nil {
226
return err
227
}
228
return printResult(code, b)
229
}
230
231
func withName(args []string, f func(c *client, name string) (int, []byte, error)) error {
232
fs := flag.NewFlagSet("cmd", flag.ExitOnError)
233
cfgPath := fs.String("config", "", "pad naar config.yml")
234
_ = fs.Parse(args)
235
if fs.NArg() != 1 {
236
return fmt.Errorf("geef precies één archiefnaam")
237
}
238
c, err := newClient(*cfgPath)
239
if err != nil {
240
return err
241
}
242
code, b, err := f(c, fs.Arg(0))
243
if err != nil {
244
return err
245
}
246
return printResult(code, b)
247
}
248
249
func rollback(args []string, stdin io.Reader, stdout io.Writer) error {
250
return withName(args, func(c *client, name string) (int, []byte, error) {
251
fmt.Fprintln(stdout, "LET OP: een rollback vervangt alle gegevens van BlueGit door dit archief en kan niet ongedaan worden gemaakt.")
252
fmt.Fprint(stdout, "Typ de archiefnaam over om door te gaan: ")
253
line, _ := bufio.NewReader(stdin).ReadString('\n')
254
if strings.TrimSpace(line) != name {
255
return 0, nil, fmt.Errorf("afgebroken; er is niets veranderd")
256
}
257
return c.do(http.MethodPost, "/api/v1/admin/rollback", map[string]string{"archive": name, "confirm": name})
258
})
259
}
260
261
func printToken(args []string) error {
262
fs := flag.NewFlagSet("token", flag.ExitOnError)
263
cfgPath := fs.String("config", "", "pad naar config.yml")
264
_ = fs.Parse(args)
265
cfg, err := config.Load(configPath(*cfgPath))
266
if err != nil {
267
return err
268
}
269
tok, err := server.ReadAdminToken(cfg.DataDir)
270
if err != nil {
271
return fmt.Errorf("admin.token niet leesbaar (start de server eerst, en draai als de gebruiker bluegit-backup): %w", err)
272
}
273
fmt.Println(tok)
274
return nil
275
}
276
277
func simple(args []string, method, p string) error {
278
fs := flag.NewFlagSet("cmd", flag.ExitOnError)
279
cfgPath := fs.String("config", "", "pad naar config.yml")
280
_ = fs.Parse(args)
281
c, err := newClient(*cfgPath)
282
if err != nil {
283
return err
284
}
285
code, b, err := c.do(method, p, nil)
286
if err != nil {
287
return err
288
}
289
var pretty bytes.Buffer
290
if json.Indent(&pretty, b, "", " ") == nil {
291
b = pretty.Bytes()
292
}
293
fmt.Println(string(b))
294
if code >= 300 {
295
return fmt.Errorf("HTTP %d", code)
296
}
297
return nil
298
}
299
300
func connect(args []string, stdin io.Reader, stdout io.Writer) error {
301
fs := flag.NewFlagSet("connect", flag.ExitOnError)
302
cfgPath := fs.String("config", "", "pad naar config.yml")
303
u := fs.String("url", "", "adres van BlueGit")
304
key := fs.String("key", "", "Backupserver-Key (of BLUEGIT_BACKUP_KEY)")
305
onConflict := fs.String("on-conflict", "", "wipe of restore, zonder te vragen")
306
_ = fs.Parse(args)
307
if *key == "" {
308
*key = os.Getenv("BLUEGIT_BACKUP_KEY")
309
}
310
if *u == "" || *key == "" {
311
return fmt.Errorf("--url en --key (of BLUEGIT_BACKUP_KEY) zijn nodig")
312
}
313
c, err := newClient(*cfgPath)
314
if err != nil {
315
return err
316
}
317
req := server.ConnectRequest{URL: *u, Key: *key, OnConflict: *onConflict}
318
code, b, err := c.do(http.MethodPost, "/api/v1/admin/connect", req)
319
if err != nil {
320
return err
321
}
322
if code == http.StatusConflict {
323
var cf server.ConflictError
324
_ = json.Unmarshal(b, &cf)
325
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)
326
fmt.Fprintln(stdout, "Een backup server kan maar aan één BlueGit gekoppeld zijn. Kies:")
327
fmt.Fprintln(stdout, " 1) Oude backups verwijderen en met de nieuwe instantie verbinden")
328
fmt.Fprintln(stdout, " 2) De nieuwe instantie terugzetten naar de gegevens in deze backup server (overschrijft alles daar)")
329
fmt.Fprint(stdout, "Keuze [1/2, leeg = afbreken]: ")
330
line, _ := bufio.NewReader(stdin).ReadString('\n')
331
switch strings.TrimSpace(line) {
332
case "1":
333
req.OnConflict = "wipe"
334
case "2":
335
req.OnConflict = "restore"
336
default:
337
return fmt.Errorf("afgebroken; er is niets veranderd")
338
}
339
code, b, err = c.do(http.MethodPost, "/api/v1/admin/connect", req)
340
if err != nil {
341
return err
342
}
343
}
344
fmt.Fprintln(stdout, strings.TrimSpace(string(b)))
345
if code >= 300 {
346
return fmt.Errorf("HTTP %d", code)
347
}
348
return nil
349
}
@@ -0,0 +1,349 @@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
"net/url"16
"os"17
"os/signal"18
"strings"19
"syscall"20
"time"21
22
"git.timfalken.com/timfa/bluegit-backup/internal/config"23
"git.timfalken.com/timfa/bluegit-backup/internal/server"24
)25
26
func usage() {27
fmt.Fprint(os.Stderr, `bluegit-backup28
29
bluegit-backup serve [--config /etc/bluegit-backup/config.yml]30
bluegit-backup connect [--config …] --url https://git.example.com [--key bgbk_…] [--on-conflict wipe|restore]31
bluegit-backup status [--config …]32
bluegit-backup list [--config …]33
bluegit-backup archive [--config …] nu een archief maken34
bluegit-backup sync [--config …] nu synchroniseren35
bluegit-backup prune [--config …] bewaarregels nu toepassen36
bluegit-backup config [--config …] instellingen tonen37
bluegit-backup set [--config …] sleutel=waarde … instellingen wijzigen38
bluegit-backup delete [--config …] ARCHIEF39
bluegit-backup rollback [--config …] ARCHIEF (vraagt om de naam over te typen)40
bluegit-backup disconnect [--config …]41
bluegit-backup actions [--config …] alle API-acties42
bluegit-backup token [--config …] het beheertoken voor de webinterface43
bluegit-backup example-config44
bluegit-backup version45
46
De key kan ook uit BLUEGIT_BACKUP_KEY komen (dan staat hij niet in de proceslijst).47
`)48
}49
50
func main() {51
if len(os.Args) < 2 {52
usage()53
os.Exit(2)54
}55
var err error56
switch os.Args[1] {57
case "serve":58
err = serve(os.Args[2:])59
case "connect":60
err = connect(os.Args[2:], os.Stdin, os.Stdout)61
case "status":62
err = simple(os.Args[2:], http.MethodGet, "/api/v1/admin/status")63
case "list":64
err = simple(os.Args[2:], http.MethodGet, "/api/v1/admin/archives")65
case "archive":66
err = simple(os.Args[2:], http.MethodPost, "/api/v1/admin/archive")67
case "sync":68
err = simple(os.Args[2:], http.MethodPost, "/api/v1/admin/sync")69
case "prune":70
err = simple(os.Args[2:], http.MethodPost, "/api/v1/admin/prune")71
case "config":72
err = simple(os.Args[2:], http.MethodGet, "/api/v1/admin/config")73
case "set":74
err = setConfig(os.Args[2:])75
case "disconnect":76
err = simple(os.Args[2:], http.MethodPost, "/api/v1/admin/disconnect")77
case "delete":78
err = withName(os.Args[2:], func(c *client, name string) (int, []byte, error) {79
return c.do(http.MethodDelete, "/api/v1/admin/archives/"+url.PathEscape(name), nil)80
})81
case "rollback":82
err = rollback(os.Args[2:], os.Stdin, os.Stdout)83
case "actions":84
err = simple(os.Args[2:], http.MethodGet, "/api/v1/admin/actions")85
case "token":86
err = printToken(os.Args[2:])87
case "example-config":88
fmt.Print(config.Example())89
case "version":90
fmt.Println(server.Version)91
default:92
usage()93
os.Exit(2)94
}95
if err != nil {96
fmt.Fprintln(os.Stderr, "bluegit-backup:", err)97
os.Exit(1)98
}99
}100
101
func configPath(p string) string {102
if p != "" {103
return p104
}105
if v := os.Getenv("BLUEGIT_BACKUP_CONFIG"); v != "" {106
return v107
}108
if _, err := os.Stat("bluegit-backup.yml"); err == nil {109
return "bluegit-backup.yml"110
}111
return "/etc/bluegit-backup/config.yml"112
}113
114
func serve(args []string) error {115
fs := flag.NewFlagSet("serve", flag.ExitOnError)116
cfgPath := fs.String("config", "", "pad naar config.yml")117
_ = fs.Parse(args)118
cfg, err := config.Load(configPath(*cfgPath))119
if err != nil {120
return err121
}122
log := slog.New(slog.NewTextHandler(os.Stdout, nil))123
srv, err := server.New(cfg, log)124
if err != nil {125
return err126
}127
ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)128
defer stop()129
cfg = srv.Cfg // met settings.yml130
ln, err := net.Listen("tcp", cfg.Listen)131
if err != nil {132
return err133
}134
hs := &http.Server{Handler: srv.Handler(), ReadHeaderTimeout: 10 * time.Second}135
go func() {136
<-ctx.Done()137
c, cancel := context.WithTimeout(context.Background(), 10*time.Second)138
defer cancel()139
_ = hs.Shutdown(c)140
}()141
srv.Run(ctx)142
log.Info("bluegit-backup luistert", "addr", ln.Addr().String(), "public_url", cfg.PublicURL, "version", server.Version)143
if err := hs.Serve(ln); err != nil && err != http.ErrServerClosed {144
return err145
}146
return nil147
}148
149
type client struct {150
base, token string151
}152
153
func newClient(cfgPath string) (*client, error) {154
cfg, err := config.Load(configPath(cfgPath))155
if err != nil {156
return nil, err157
}158
if set, err := config.LoadSettings(cfg.DataDir); err == nil {159
_ = cfg.Apply(set)160
}161
tok, err := server.ReadAdminToken(cfg.DataDir)162
if err != nil {163
return nil, fmt.Errorf("admin.token lezen (draai als de gebruiker van de dienst of root): %w", err)164
}165
host, port, err := net.SplitHostPort(cfg.Listen)166
if err != nil {167
return nil, err168
}169
if host == "" || host == "0.0.0.0" || host == "::" {170
host = "127.0.0.1"171
}172
return &client{base: "http://" + net.JoinHostPort(host, port), token: tok}, nil173
}174
175
func (c *client) do(method, p string, in any) (int, []byte, error) {176
var body io.Reader177
if in != nil {178
b, _ := json.Marshal(in)179
body = bytes.NewReader(b)180
}181
req, _ := http.NewRequest(method, c.base+p, body)182
req.Header.Set("Authorization", "Bearer "+c.token)183
req.Header.Set("Content-Type", "application/json")184
resp, err := (&http.Client{Timeout: 30 * time.Minute}).Do(req)185
if err != nil {186
return 0, nil, err187
}188
defer resp.Body.Close()189
b, _ := io.ReadAll(resp.Body)190
return resp.StatusCode, b, nil191
}192
193
func printResult(code int, b []byte) error {194
var pretty bytes.Buffer195
if json.Indent(&pretty, b, "", " ") == nil {196
b = pretty.Bytes()197
}198
fmt.Println(strings.TrimSpace(string(b)))199
if code >= 300 {200
return fmt.Errorf("HTTP %d", code)201
}202
return nil203
}204
205
func setConfig(args []string) error {206
fs := flag.NewFlagSet("set", flag.ExitOnError)207
cfgPath := fs.String("config", "", "pad naar config.yml")208
_ = fs.Parse(args)209
set := map[string]string{}210
for _, kv := range fs.Args() {211
k, v, ok := strings.Cut(kv, "=")212
if !ok {213
return fmt.Errorf("verwacht sleutel=waarde, kreeg %q", kv)214
}215
set[k] = v216
}217
if len(set) == 0 {218
return fmt.Errorf("geef minstens één sleutel=waarde")219
}220
c, err := newClient(*cfgPath)221
if err != nil {222
return err223
}224
code, b, err := c.do(http.MethodPut, "/api/v1/admin/config", set)225
if err != nil {226
return err227
}228
return printResult(code, b)229
}230
231
func withName(args []string, f func(c *client, name string) (int, []byte, error)) error {232
fs := flag.NewFlagSet("cmd", flag.ExitOnError)233
cfgPath := fs.String("config", "", "pad naar config.yml")234
_ = fs.Parse(args)235
if fs.NArg() != 1 {236
return fmt.Errorf("geef precies één archiefnaam")237
}238
c, err := newClient(*cfgPath)239
if err != nil {240
return err241
}242
code, b, err := f(c, fs.Arg(0))243
if err != nil {244
return err245
}246
return printResult(code, b)247
}248
249
func rollback(args []string, stdin io.Reader, stdout io.Writer) error {250
return withName(args, func(c *client, name string) (int, []byte, error) {251
fmt.Fprintln(stdout, "LET OP: een rollback vervangt alle gegevens van BlueGit door dit archief en kan niet ongedaan worden gemaakt.")252
fmt.Fprint(stdout, "Typ de archiefnaam over om door te gaan: ")253
line, _ := bufio.NewReader(stdin).ReadString('\n')254
if strings.TrimSpace(line) != name {255
return 0, nil, fmt.Errorf("afgebroken; er is niets veranderd")256
}257
return c.do(http.MethodPost, "/api/v1/admin/rollback", map[string]string{"archive": name, "confirm": name})258
})259
}260
261
func printToken(args []string) error {262
fs := flag.NewFlagSet("token", flag.ExitOnError)263
cfgPath := fs.String("config", "", "pad naar config.yml")264
_ = fs.Parse(args)265
cfg, err := config.Load(configPath(*cfgPath))266
if err != nil {267
return err268
}269
tok, err := server.ReadAdminToken(cfg.DataDir)270
if err != nil {271
return fmt.Errorf("admin.token niet leesbaar (start de server eerst, en draai als de gebruiker bluegit-backup): %w", err)272
}273
fmt.Println(tok)274
return nil275
}276
277
func simple(args []string, method, p string) error {278
fs := flag.NewFlagSet("cmd", flag.ExitOnError)279
cfgPath := fs.String("config", "", "pad naar config.yml")280
_ = fs.Parse(args)281
c, err := newClient(*cfgPath)282
if err != nil {283
return err284
}285
code, b, err := c.do(method, p, nil)286
if err != nil {287
return err288
}289
var pretty bytes.Buffer290
if json.Indent(&pretty, b, "", " ") == nil {291
b = pretty.Bytes()292
}293
fmt.Println(string(b))294
if code >= 300 {295
return fmt.Errorf("HTTP %d", code)296
}297
return nil298
}299
300
func connect(args []string, stdin io.Reader, stdout io.Writer) error {301
fs := flag.NewFlagSet("connect", flag.ExitOnError)302
cfgPath := fs.String("config", "", "pad naar config.yml")303
u := fs.String("url", "", "adres van BlueGit")304
key := fs.String("key", "", "Backupserver-Key (of BLUEGIT_BACKUP_KEY)")305
onConflict := fs.String("on-conflict", "", "wipe of restore, zonder te vragen")306
_ = fs.Parse(args)307
if *key == "" {308
*key = os.Getenv("BLUEGIT_BACKUP_KEY")309
}310
if *u == "" || *key == "" {311
return fmt.Errorf("--url en --key (of BLUEGIT_BACKUP_KEY) zijn nodig")312
}313
c, err := newClient(*cfgPath)314
if err != nil {315
return err316
}317
req := server.ConnectRequest{URL: *u, Key: *key, OnConflict: *onConflict}318
code, b, err := c.do(http.MethodPost, "/api/v1/admin/connect", req)319
if err != nil {320
return err321
}322
if code == http.StatusConflict {323
var cf server.ConflictError324
_ = json.Unmarshal(b, &cf)325
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)326
fmt.Fprintln(stdout, "Een backup server kan maar aan één BlueGit gekoppeld zijn. Kies:")327
fmt.Fprintln(stdout, " 1) Oude backups verwijderen en met de nieuwe instantie verbinden")328
fmt.Fprintln(stdout, " 2) De nieuwe instantie terugzetten naar de gegevens in deze backup server (overschrijft alles daar)")329
fmt.Fprint(stdout, "Keuze [1/2, leeg = afbreken]: ")330
line, _ := bufio.NewReader(stdin).ReadString('\n')331
switch strings.TrimSpace(line) {332
case "1":333
req.OnConflict = "wipe"334
case "2":335
req.OnConflict = "restore"336
default:337
return fmt.Errorf("afgebroken; er is niets veranderd")338
}339
code, b, err = c.do(http.MethodPost, "/api/v1/admin/connect", req)340
if err != nil {341
return err342
}343
}344
fmt.Fprintln(stdout, strings.TrimSpace(string(b)))345
if code >= 300 {346
return fmt.Errorf("HTTP %d", code)347
}348
return nil349
}@@ -0,0 +1,138 @@
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
- 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.
9
10
## Webinterface en API
11
12
- De webinterface draait op hetzelfde adres als de API, standaard `0.0.0.0:8080`. Er komt geen aparte poort voor BlueGit: BlueGit praat met dezelfde server (ondertekend).
13
- **Inloggen gaat met het beheertoken** uit `data_dir/admin.token` (`bba_…`, 0600). Dat token gebruiken ook de API en de CLI. Er komt geen apart gebruikersbeheer: de backup server heeft één beheerder. `bluegit-backup token` toont het token.
14
- Sessies staan alleen in het geheugen. Een herstart logt iedereen uit.
15
- Elke handeling staat in één lijst (`Actions`). De API-routes en de formulieren van de webinterface komen allebei uit die lijst, en een formulier roept dezelfde code aan als de API. Daardoor kan de API alles wat de webinterface kan, en andersom. Een unit-test controleert dat elke wijzigende actie een formulier heeft en elk formulier een actie. De integratietests falen als er een actie bij komt die niet getest wordt.
16
- "Alles instellen" betekent: alle velden uit `config.yml` behalve `data_dir`. In die map staan de instellingen zelf, dus die blijft in `config.yml`. Wat via de webinterface, API of BlueGit is ingesteld, gaat naar `data_dir/settings.yml`. Dat bestand gaat boven `config.yml`, zodat `config.yml` van root kan blijven. `listen` geldt pas na een herstart, de rest meteen (ook de downloadsnelheid tijdens een lopende sync).
17
- In de webinterface kun je ook een rollback starten en een archief downloaden of verwijderen. De rollback heeft dezelfde waarschuwing en bevestiging als in BlueGit.
18
- De webinterface is gewone HTML zonder JavaScript, in het Nederlands. Hij weigert framing (`X-Frame-Options: DENY`). Daarom bedient BlueGit de backup server via de API en niet met een iframe.
19
20
## Bediening vanuit BlueGit
21
22
- Tim gaf de keuze tussen een iframe of een API-koppeling met een vergelijkbare interface. Ik koos de **API-koppeling**:
23
- Een iframe zou een tweede login vragen.
24
- Het werkt niet als de backup server alleen voor BlueGit bereikbaar is en niet voor de browser.
25
- Het opent de deur voor clickjacking.
26
- BlueGit vraagt de lijst met acties op (`GET /api/v1/admin/actions`) en stuurt een gekozen actie ondertekend door. Een nieuwe actie in de backup server werkt daardoor in BlueGit zonder BlueGit aan te passen, zolang hij voor BlueGit is opengezet.
27
- **Niet** vanuit BlueGit:
28
- **koppelen**: dat vraagt de key op de backup server zelf.
29
- **een archief downloaden**: een archief van gigabytes hoort niet door BlueGit heen te lopen.
30
- De instellingen in BlueGit tonen de labels en uitleg van de backup server, dus in het Nederlands. Wat BlueGit er zelf omheen zet, is vertaald (en, nl, de, fr).
31
- Verwijdert een beheerder een backup server in BlueGit, dan vraagt BlueGit de backup server eerst om te ontkoppelen. De kopie en de archieven blijven op de backup server staan.
32
33
## Meerdere backup servers
34
35
- Eén BlueGit kan tot **16** backup servers hebben, elk met een eigen naam en key. Dat zijn er genoeg voor een paar plekken (bijvoorbeeld thuis en offsite), en het begrenst het aantal meldingen per wijziging.
36
- Elke backup server krijgt elke melding, parallel. Een server die niet reageert, houdt de andere niet op.
37
- Een rollback kan vanaf elke gekoppelde backup server. De andere servers zien de teruggezette stand bij hun volgende sync.
38
- Koppelt een tweede backup server met dezelfde key, dan gaat de koppeling (het adres voor meldingen) naar die server. Een key hoort bij één server. Geef een nieuwe server een eigen key.
39
- `backup.json` bevat nu een lijst met servers. De oude vorm met één koppeling wordt bij het lezen omgezet.
40
41
## Key en authenticatie
42
43
- BlueGit maakt per backup server een Backupserver-Key (`bgbk_` + 64 hex) onder *Beheer → Backup* en toont hem één keer. BlueGit bewaart alleen `sha256(key)`.
44
- Een nieuwe key voor een server maakt zijn oude key ongeldig. Verwijderen ontkoppelt die server.
45
- **Backup server → BlueGit:** `Authorization: Bearer bgbk_…` op `/api/v1/backup/*`. Vijf foute pogingen per minuut per IP-adres geven `429`.
46
- **BlueGit → backup server** (meldingen, archieflijst, status, rollback en de beheeracties): 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. Binnen die 5 minuten kan een afgeluisterd verzoek wel opnieuw worden gestuurd. Gebruik TLS als het netwerk tussen BlueGit en de backup server niet te vertrouwen is.
47
- De koppeling in BlueGit (`<state>/backup.json`) zit **niet** in de backup. Een rollback zet de koppeling dus niet terug naar een oude key.
48
- Je koppelt in de webinterface, met de API, of 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.
49
50
## Wat wordt geback-upt
51
52
- Alles wat BlueGit nodig heeft om identiek terug te komen:
53
- de database (`bluegit.db`) als consistente snapshot via `VACUUM INTO`
54
- `secret.key`
55
- de SSH-hostkeys
56
- logo's en avatars
57
- alle repositories
58
- releases en CI-artifacts
59
- **Niet:**
60
- `config.yml`. Dat bestand hoort bij de machine (paden, poorten, OAuth-geheimen) en zet je zelf terug.
61
- `storage_path`, caches, lockbestanden, werkmappen (`data/work`), tijdelijke bestanden, symlinks
62
- de backupkoppeling en het instance-id
63
- "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.
64
65
## Meldingen en synchroniseren
66
67
- 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.
68
- 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`).
69
- 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.
70
- Tussen twee syncs na meldingen zit minstens `min_sync_interval` (10s). Meldingen die tijdens een sync binnenkomen, geven precies één vervolgsync.
71
- 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.
72
- Een bestand dat tijdens het downloaden verandert (grootte klopt niet), wordt bij de volgende sync opnieuw opgehaald.
73
74
## Gedoseerd downloaden
75
76
- Een token bucket begrenst de downloadsnelheid tot `rate_limit_kib` KiB/s (standaard 1024, dus 1 MiB/s), over alle downloads samen.
77
- Er is altijd maar één download tegelijk. BlueGit krijgt dus nooit meer dan één verzoek tegelijk van de backup server.
78
- 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.
79
80
## Archieven
81
82
- Formaat: `tar.gz` (PAX), met de lopende kopie als inhoud (`state/…` en `data/…`). Je kunt een archief dus ook met de hand uitpakken.
83
- Naam: `bluegit-YYYYMMDD-HHMMSS.tar.gz` in UTC, met `-2`, `-3`, … als er in dezelfde seconde meer zijn.
84
- Het eerste archief komt binnen een minuut na de eerste geslaagde sync, daarna elk `archive_interval` (standaard 24u).
85
- Er wordt eerst naar een tijdelijk bestand geschreven en daarna hernoemd. Een half archief komt dus nooit in de lijst.
86
- **Opruimen:**
87
- Archieven ouder dan `retention_days` gaan weg.
88
- 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.
89
- Het nieuwste archief blijft altijd staan, ook als het te oud is. Anders zou er geen backup meer zijn.
90
- 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.
91
92
## Rollback
93
94
- 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>"`.
95
- Het verloop:
96
1. De backup server pakt het archief uit in `mirror.rollback`.
97
2. Hij zet dat op de plaats van zijn lopende kopie.
98
3. Hij stuurt alles als `tar.gz` naar BlueGit (`POST /api/v1/backup/restore`).
99
4. BlueGit zet de data klaar, weigert ondertussen alle wijzigingen (503) en herstart zichzelf (zelfde PID, `exec`).
100
5. Bij het opstarten wisselt BlueGit de bestanden om, nog voordat de database opengaat.
101
- Lukt het versturen niet, dan zet de backup server zijn oude kopie terug. Er gaat dan niets verloren.
102
- 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.
103
- Het upload-verkeer naar BlueGit bij een rollback is **niet** gedoseerd. BlueGit staat dan toch al stil, en een snelle terugzet is belangrijker.
104
105
## Nieuwe instantie
106
107
- 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.
108
- Koppel je een andere instantie, dan weigert de server (`409`) en moet je kiezen:
109
- **wissen**: de oude kopie en alle archieven gaan weg, en de nieuwe instantie wordt opnieuw opgehaald.
110
- **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.
111
- `connect` vraagt de keuze in de terminal. Zonder keuze (lege invoer) gebeurt er niets. Zonder terminal gebruik je `--on-conflict wipe|restore`.
112
- De nieuwe BlueGit moet al draaien met een eigen `config.yml` en data-schijf. Het herstel vult alleen de inhoud.
113
114
## Compatibiliteit (t1209u)
115
116
- Elke kant heeft een **protocolversie** (een geheel getal, wat hij spreekt) en een **minimumversie** (de oudste versie van de andere kant die hij nog ondersteunt). Geen min/max: een nieuwere kant geeft zelf aan tot hoe ver terug hij de ander nog ondersteunt; dat dekt beide richtingen.
117
- Ze passen als de backup server minstens het minimum van BlueGit spreekt en BlueGit minstens het minimum van de backup server. Anders: `backup_too_old` (BlueGit vraagt meer) of `bluegit_too_old` (de backup server vraagt meer). Vraagt allebei meer, dan meldt BlueGit `backup_too_old`.
118
- Nu: BlueGit protocol 1 (minimum 1), bluegit-backup protocol 1 (minimum 1). Wat tot nu toe bestond (BlueGit tot en met de backup-merge, bluegit-backup v0.1.0) stuurt geen protocol en geldt als protocol 1; die blijven dus samenwerken met deze versie.
119
- Het protocol gaat de **volgende keer omhoog** als een wijziging oude tegenpartijen breekt. Het minimum gaat pas omhoog als die oude versie echt niet meer werkt.
120
- **Uitwisseling**: koppen op elk verzoek en antwoord tussen de twee (`X-BlueGit-Protocol`/`-Min-Protocol`/`-Version` van BlueGit, `X-Backup-Protocol`/`-Min-Protocol`/`-Version` van de backup server), en `protocol`/`min_protocol`/`version` in `GET /api/v1/backup/info`. Zo hoort de backup server het bij info, sync en elke melding, en BlueGit bij elk verzoek met de key en elk antwoord op een melding of beheeractie.
121
- BlueGit bewaart het laatst gemelde protocol per backup server in `backup.json`. De banner leest alleen dat bestand (geen netwerkverkeer bij elke pagina). Een nieuwe key wist het, tot de server zich opnieuw meldt.
122
- **Banner**: alleen voor instance-beheerders, bovenaan elke HTML-pagina (onder de kopbalk), per niet-passende backup server één regel: de naam, of BlueGit of de backup server geüpdatet moet worden, beide protocolnummers, en een link naar Beheer → Backup. In het Engels, Nederlands, Duits en Frans (en spijkerschrift via het Engels).
123
- **Weigeren**: BlueGit geeft `426 Upgrade Required` op `manifest`, `file` en `restore`. `info` en `connect` blijven werken, zodat een niet-passende server toch kan koppelen en de beheerder de banner ziet. De backup server vraagt vóór elke sync, rollback en restore `info` op en weigert zelf (`409`); een rollback vanuit BlueGit weigert hij als het laatst gemelde protocol niet past. Archieven bekijken, downloaden, verwijderen en instellingen blijven werken.
124
- De backup server toont het in zijn webinterface (banner bovenaan, regel *Protocol* in het overzicht) en in `GET /api/v1/admin/status` (`protocol`, `min_protocol`, `bluegit_protocol`, `bluegit_min_protocol`, `bluegit_version`, `compat`, `compat_message`).
125
- **Versie**: de backup server meldt `Version` (bij het bouwen gezet). BlueGit heeft geen versienummer en meldt de commit uit de build-info (12 tekens), of `dev`.
126
- **Tests**: "backup te oud" bootsen we na met een test-build van BlueGit met `-ldflags -X …/internal/backup.protocolVersion=99 -X ….minBackupProtocol=99` (`scripts/build-bluegit.sh` bouwt die naast de gewone). "BlueGit te oud" bootsen we na door in de test het protocol van de backup server (die in het testproces draait) op 2 met minimum 2 te zetten. Een gebruiker die geen beheerder is, maken we door dezelfde BlueGit te herstarten met een andere dev-gebruiker.
127
128
## Releases en tests
129
130
- "Dezelfde release-opties als BlueGit" betekent:
131
- een AUR-pakket `bluegit-backup` dat vanaf master wordt bijgewerkt
132
- binaries bij een tag
133
- Geen self-update (Tim, 2026-11-15, t1209u): gebruikers updaten de backup server zelf (AUR-helper of een nieuwe binary). Er is geen update-endpoint, geen update-unit en geen pipeline-job die een server bijwerkt.
134
- 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.
135
- Releases vanaf master staan aan zodra `.release-enabled` in de repository staat. Zonder dat bestand doen de release-scripts niets.
136
- De integratietests bouwen BlueGit van de ref in `.bluegit-ref` (`master`; tijdens de compatibiliteitswijziging tijdelijk `feature/backup-compat`, tot die in BlueGit gemerged is).
137
- 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.
138
- 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,138 @@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
- 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.9
10
## Webinterface en API11
12
- De webinterface draait op hetzelfde adres als de API, standaard `0.0.0.0:8080`. Er komt geen aparte poort voor BlueGit: BlueGit praat met dezelfde server (ondertekend).13
- **Inloggen gaat met het beheertoken** uit `data_dir/admin.token` (`bba_…`, 0600). Dat token gebruiken ook de API en de CLI. Er komt geen apart gebruikersbeheer: de backup server heeft één beheerder. `bluegit-backup token` toont het token.14
- Sessies staan alleen in het geheugen. Een herstart logt iedereen uit.15
- Elke handeling staat in één lijst (`Actions`). De API-routes en de formulieren van de webinterface komen allebei uit die lijst, en een formulier roept dezelfde code aan als de API. Daardoor kan de API alles wat de webinterface kan, en andersom. Een unit-test controleert dat elke wijzigende actie een formulier heeft en elk formulier een actie. De integratietests falen als er een actie bij komt die niet getest wordt.16
- "Alles instellen" betekent: alle velden uit `config.yml` behalve `data_dir`. In die map staan de instellingen zelf, dus die blijft in `config.yml`. Wat via de webinterface, API of BlueGit is ingesteld, gaat naar `data_dir/settings.yml`. Dat bestand gaat boven `config.yml`, zodat `config.yml` van root kan blijven. `listen` geldt pas na een herstart, de rest meteen (ook de downloadsnelheid tijdens een lopende sync).17
- In de webinterface kun je ook een rollback starten en een archief downloaden of verwijderen. De rollback heeft dezelfde waarschuwing en bevestiging als in BlueGit.18
- De webinterface is gewone HTML zonder JavaScript, in het Nederlands. Hij weigert framing (`X-Frame-Options: DENY`). Daarom bedient BlueGit de backup server via de API en niet met een iframe.19
20
## Bediening vanuit BlueGit21
22
- Tim gaf de keuze tussen een iframe of een API-koppeling met een vergelijkbare interface. Ik koos de **API-koppeling**:23
- Een iframe zou een tweede login vragen.24
- Het werkt niet als de backup server alleen voor BlueGit bereikbaar is en niet voor de browser.25
- Het opent de deur voor clickjacking.26
- BlueGit vraagt de lijst met acties op (`GET /api/v1/admin/actions`) en stuurt een gekozen actie ondertekend door. Een nieuwe actie in de backup server werkt daardoor in BlueGit zonder BlueGit aan te passen, zolang hij voor BlueGit is opengezet.27
- **Niet** vanuit BlueGit:28
- **koppelen**: dat vraagt de key op de backup server zelf.29
- **een archief downloaden**: een archief van gigabytes hoort niet door BlueGit heen te lopen.30
- De instellingen in BlueGit tonen de labels en uitleg van de backup server, dus in het Nederlands. Wat BlueGit er zelf omheen zet, is vertaald (en, nl, de, fr).31
- Verwijdert een beheerder een backup server in BlueGit, dan vraagt BlueGit de backup server eerst om te ontkoppelen. De kopie en de archieven blijven op de backup server staan.32
33
## Meerdere backup servers34
35
- Eén BlueGit kan tot **16** backup servers hebben, elk met een eigen naam en key. Dat zijn er genoeg voor een paar plekken (bijvoorbeeld thuis en offsite), en het begrenst het aantal meldingen per wijziging.36
- Elke backup server krijgt elke melding, parallel. Een server die niet reageert, houdt de andere niet op.37
- Een rollback kan vanaf elke gekoppelde backup server. De andere servers zien de teruggezette stand bij hun volgende sync.38
- Koppelt een tweede backup server met dezelfde key, dan gaat de koppeling (het adres voor meldingen) naar die server. Een key hoort bij één server. Geef een nieuwe server een eigen key.39
- `backup.json` bevat nu een lijst met servers. De oude vorm met één koppeling wordt bij het lezen omgezet.40
41
## Key en authenticatie42
43
- BlueGit maakt per backup server een Backupserver-Key (`bgbk_` + 64 hex) onder *Beheer → Backup* en toont hem één keer. BlueGit bewaart alleen `sha256(key)`.44
- Een nieuwe key voor een server maakt zijn oude key ongeldig. Verwijderen ontkoppelt die server.45
- **Backup server → BlueGit:** `Authorization: Bearer bgbk_…` op `/api/v1/backup/*`. Vijf foute pogingen per minuut per IP-adres geven `429`.46
- **BlueGit → backup server** (meldingen, archieflijst, status, rollback en de beheeracties): 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. Binnen die 5 minuten kan een afgeluisterd verzoek wel opnieuw worden gestuurd. Gebruik TLS als het netwerk tussen BlueGit en de backup server niet te vertrouwen is.47
- De koppeling in BlueGit (`<state>/backup.json`) zit **niet** in de backup. Een rollback zet de koppeling dus niet terug naar een oude key.48
- Je koppelt in de webinterface, met de API, of 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.49
50
## Wat wordt geback-upt51
52
- Alles wat BlueGit nodig heeft om identiek terug te komen:53
- de database (`bluegit.db`) als consistente snapshot via `VACUUM INTO`54
- `secret.key`55
- de SSH-hostkeys56
- logo's en avatars57
- alle repositories58
- releases en CI-artifacts59
- **Niet:**60
- `config.yml`. Dat bestand hoort bij de machine (paden, poorten, OAuth-geheimen) en zet je zelf terug.61
- `storage_path`, caches, lockbestanden, werkmappen (`data/work`), tijdelijke bestanden, symlinks62
- de backupkoppeling en het instance-id63
- "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.64
65
## Meldingen en synchroniseren66
67
- 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.68
- 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`).69
- 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.70
- Tussen twee syncs na meldingen zit minstens `min_sync_interval` (10s). Meldingen die tijdens een sync binnenkomen, geven precies één vervolgsync.71
- 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.72
- Een bestand dat tijdens het downloaden verandert (grootte klopt niet), wordt bij de volgende sync opnieuw opgehaald.73
74
## Gedoseerd downloaden75
76
- Een token bucket begrenst de downloadsnelheid tot `rate_limit_kib` KiB/s (standaard 1024, dus 1 MiB/s), over alle downloads samen.77
- Er is altijd maar één download tegelijk. BlueGit krijgt dus nooit meer dan één verzoek tegelijk van de backup server.78
- 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.79
80
## Archieven81
82
- Formaat: `tar.gz` (PAX), met de lopende kopie als inhoud (`state/…` en `data/…`). Je kunt een archief dus ook met de hand uitpakken.83
- Naam: `bluegit-YYYYMMDD-HHMMSS.tar.gz` in UTC, met `-2`, `-3`, … als er in dezelfde seconde meer zijn.84
- Het eerste archief komt binnen een minuut na de eerste geslaagde sync, daarna elk `archive_interval` (standaard 24u).85
- Er wordt eerst naar een tijdelijk bestand geschreven en daarna hernoemd. Een half archief komt dus nooit in de lijst.86
- **Opruimen:**87
- Archieven ouder dan `retention_days` gaan weg.88
- 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.89
- Het nieuwste archief blijft altijd staan, ook als het te oud is. Anders zou er geen backup meer zijn.90
- 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.91
92
## Rollback93
94
- 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>"`.95
- Het verloop:96
1. De backup server pakt het archief uit in `mirror.rollback`.97
2. Hij zet dat op de plaats van zijn lopende kopie.98
3. Hij stuurt alles als `tar.gz` naar BlueGit (`POST /api/v1/backup/restore`).99
4. BlueGit zet de data klaar, weigert ondertussen alle wijzigingen (503) en herstart zichzelf (zelfde PID, `exec`).100
5. Bij het opstarten wisselt BlueGit de bestanden om, nog voordat de database opengaat.101
- Lukt het versturen niet, dan zet de backup server zijn oude kopie terug. Er gaat dan niets verloren.102
- 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.103
- Het upload-verkeer naar BlueGit bij een rollback is **niet** gedoseerd. BlueGit staat dan toch al stil, en een snelle terugzet is belangrijker.104
105
## Nieuwe instantie106
107
- 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.108
- Koppel je een andere instantie, dan weigert de server (`409`) en moet je kiezen:109
- **wissen**: de oude kopie en alle archieven gaan weg, en de nieuwe instantie wordt opnieuw opgehaald.110
- **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.111
- `connect` vraagt de keuze in de terminal. Zonder keuze (lege invoer) gebeurt er niets. Zonder terminal gebruik je `--on-conflict wipe|restore`.112
- De nieuwe BlueGit moet al draaien met een eigen `config.yml` en data-schijf. Het herstel vult alleen de inhoud.113
114
## Compatibiliteit (t1209u)115
116
- Elke kant heeft een **protocolversie** (een geheel getal, wat hij spreekt) en een **minimumversie** (de oudste versie van de andere kant die hij nog ondersteunt). Geen min/max: een nieuwere kant geeft zelf aan tot hoe ver terug hij de ander nog ondersteunt; dat dekt beide richtingen.117
- Ze passen als de backup server minstens het minimum van BlueGit spreekt en BlueGit minstens het minimum van de backup server. Anders: `backup_too_old` (BlueGit vraagt meer) of `bluegit_too_old` (de backup server vraagt meer). Vraagt allebei meer, dan meldt BlueGit `backup_too_old`.118
- Nu: BlueGit protocol 1 (minimum 1), bluegit-backup protocol 1 (minimum 1). Wat tot nu toe bestond (BlueGit tot en met de backup-merge, bluegit-backup v0.1.0) stuurt geen protocol en geldt als protocol 1; die blijven dus samenwerken met deze versie.119
- Het protocol gaat de **volgende keer omhoog** als een wijziging oude tegenpartijen breekt. Het minimum gaat pas omhoog als die oude versie echt niet meer werkt.120
- **Uitwisseling**: koppen op elk verzoek en antwoord tussen de twee (`X-BlueGit-Protocol`/`-Min-Protocol`/`-Version` van BlueGit, `X-Backup-Protocol`/`-Min-Protocol`/`-Version` van de backup server), en `protocol`/`min_protocol`/`version` in `GET /api/v1/backup/info`. Zo hoort de backup server het bij info, sync en elke melding, en BlueGit bij elk verzoek met de key en elk antwoord op een melding of beheeractie.121
- BlueGit bewaart het laatst gemelde protocol per backup server in `backup.json`. De banner leest alleen dat bestand (geen netwerkverkeer bij elke pagina). Een nieuwe key wist het, tot de server zich opnieuw meldt.122
- **Banner**: alleen voor instance-beheerders, bovenaan elke HTML-pagina (onder de kopbalk), per niet-passende backup server één regel: de naam, of BlueGit of de backup server geüpdatet moet worden, beide protocolnummers, en een link naar Beheer → Backup. In het Engels, Nederlands, Duits en Frans (en spijkerschrift via het Engels).123
- **Weigeren**: BlueGit geeft `426 Upgrade Required` op `manifest`, `file` en `restore`. `info` en `connect` blijven werken, zodat een niet-passende server toch kan koppelen en de beheerder de banner ziet. De backup server vraagt vóór elke sync, rollback en restore `info` op en weigert zelf (`409`); een rollback vanuit BlueGit weigert hij als het laatst gemelde protocol niet past. Archieven bekijken, downloaden, verwijderen en instellingen blijven werken.124
- De backup server toont het in zijn webinterface (banner bovenaan, regel *Protocol* in het overzicht) en in `GET /api/v1/admin/status` (`protocol`, `min_protocol`, `bluegit_protocol`, `bluegit_min_protocol`, `bluegit_version`, `compat`, `compat_message`).125
- **Versie**: de backup server meldt `Version` (bij het bouwen gezet). BlueGit heeft geen versienummer en meldt de commit uit de build-info (12 tekens), of `dev`.126
- **Tests**: "backup te oud" bootsen we na met een test-build van BlueGit met `-ldflags -X …/internal/backup.protocolVersion=99 -X ….minBackupProtocol=99` (`scripts/build-bluegit.sh` bouwt die naast de gewone). "BlueGit te oud" bootsen we na door in de test het protocol van de backup server (die in het testproces draait) op 2 met minimum 2 te zetten. Een gebruiker die geen beheerder is, maken we door dezelfde BlueGit te herstarten met een andere dev-gebruiker.127
128
## Releases en tests129
130
- "Dezelfde release-opties als BlueGit" betekent:131
- een AUR-pakket `bluegit-backup` dat vanaf master wordt bijgewerkt132
- binaries bij een tag133
- Geen self-update (Tim, 2026-11-15, t1209u): gebruikers updaten de backup server zelf (AUR-helper of een nieuwe binary). Er is geen update-endpoint, geen update-unit en geen pipeline-job die een server bijwerkt.134
- 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.135
- Releases vanaf master staan aan zodra `.release-enabled` in de repository staat. Zonder dat bestand doen de release-scripts niets.136
- De integratietests bouwen BlueGit van de ref in `.bluegit-ref` (`master`; tijdens de compatibiliteitswijziging tijdelijk `feature/backup-compat`, tot die in BlueGit gemerged is).137
- 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.138
- 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,100 @@
1
# Backup servers (bluegit-backup)
2
3
Een losse backup server ([timfa/bluegit-backup](https://git.timfalken.com/timfa/bluegit-backup)) houdt een kopie bij van alle gegevens en configuratie van één BlueGit. Hij haalt ze langzaam op, krijgt na elke wijziging een melding, maakt periodiek een gecomprimeerd archief, en kan BlueGit naar zo'n archief terugzetten.
4
5
Eén BlueGit kan meerdere backup servers hebben (hoogstens 16), elk met een eigen Backupserver-Key. Een backup server hoort bij één BlueGit.
6
7
## In BlueGit
8
9
**Beheer > Backup** (`/admin/backup`, alleen installatiebeheerders) toont de lijst met backup servers: naam, gekoppeld of wachtend op de key, adres en laatste contact. **Backup server toevoegen** maakt een nieuwe server met een eigen key, die één keer wordt getoond.
10
11
Per backup server (`/admin/backup/s/<id>`) staat dezelfde bediening als in de webinterface van de backup server zelf:
12
13
- **Status**: laatste sync en het resultaat ervan, aantal syncs en meldingen, grootte van de kopie, archieven, de laatste rollback en de versie. Met de knoppen *Nu synchroniseren*, *Nu archiveren* en *Nu opruimen*.
14
- **Instellingen** van de backup server: archiefinterval, bewaartermijn, minimale vrije ruimte, downloadsnelheid, syncintervallen, publiek adres en luisteradres. BlueGit krijgt de velden van de backup server en toont ze zoals ze daar staan.
15
- **Backup-archieven** met *Verwijderen* en *Rollback*. Een rollback staat achter een grote rode waarschuwing, een vinkje ("ik begrijp dat dit niet terug te draaien is"), het intypen van de archiefnaam en een bevestigingsdialoog.
16
- **Backupserver-Key** vervangen (de oude key werkt meteen niet meer; de server moet opnieuw koppelen), de server hernoemen, of key intrekken en de server verwijderen. Bij verwijderen vraagt BlueGit de backup server eerst om te ontkoppelen. De archieven blijven op de backup server staan.
17
18
BlueGit kent de acties niet vooraf. Het vraagt ze op bij de backup server (`GET /api/v1/admin/actions`) en stuurt ze ondertekend door. Alles wat de backup server voor BlueGit openzet, kan dus ook hier. Koppelen en een archief downloaden kan alleen op de backup server zelf.
19
20
Dezelfde acties via de API (token van een beheerder, scope `api`/`admin`):
21
22
| | |
23
|---|---|
24
| `GET /api/v1/admin/backup` | `instance_id` en de lijst met backup servers |
25
| `POST /api/v1/admin/backup/servers` | `{"name"}`: nieuwe backup server; het antwoord bevat eenmalig `key` |
26
| `GET /api/v1/admin/backup/servers/{id}` | server met `remote` (status), `archives` en `config`, zoals de backup server ze meldt |
27
| `PUT /api/v1/admin/backup/servers/{id}` | `{"name"}`: hernoemen |
28
| `POST /api/v1/admin/backup/servers/{id}/key` | nieuwe key (eenmalig in het antwoord) |
29
| `DELETE /api/v1/admin/backup/servers/{id}` | ontkoppelen en vergeten |
30
| `POST /api/v1/admin/backup/servers/{id}/actions/{name}` | actie van de backup server, bijvoorbeeld `config.update` met `{"retention_days": "14"}`, `sync`, `archive`, `prune`, `archive.delete` met `{"name"}`, of `rollback` met `{"archive": "naam", "confirm": "naam"}` |
31
32
Het antwoord van een actie is het antwoord van de backup server, met dezelfde statuscode.
33
34
## Protocol
35
36
**De backup server praat met BlueGit** met de key als bearer-token (`Authorization: Bearer bgbk_…`):
37
38
| | |
39
|---|---|
40
| `GET /api/v1/backup/info` | `instance_id`, `base_url`, naam en adres van de server bij deze key |
41
| `POST /api/v1/backup/connect` | `{"server_url", "server_id"}`: waar BlueGit meldingen heen stuurt |
42
| `GET /api/v1/backup/manifest` | alle bestanden: pad, grootte, mtime, mode; de database ook met sha256 |
43
| `GET /api/v1/backup/file?path=…` | één bestand |
44
| `POST /api/v1/backup/restore` | tar.gz met logische paden; BlueGit pakt uit en herstart (202) |
45
46
Vijf mislukte key-pogingen per minuut per IP geven daarna `429`.
47
48
**BlueGit praat met de backup server** met een HMAC-handtekening. Het geheim is `sha256("bluegit-backup-sign:" + key)` als hex; beide kanten leiden het af uit de key. Koppen:
49
50
```text
51
X-BlueGit-Instance: <instance_id>
52
X-BlueGit-Timestamp: <unix-seconden> (hoogstens 5 minuten verschil)
53
X-BlueGit-Signature: hex(HMAC-SHA256(geheim, METHOD "\n" PAD "\n" TS "\n" sha256hex(body)))
54
```
55
56
| | |
57
|---|---|
58
| `POST /api/v1/notify` | er is iets veranderd |
59
| `GET /api/v1/archives` | `{"archives": [{name, created_at, size}]}` |
60
| `GET /api/v1/status` | interval, bewaartermijn, stand van de laatste rollback |
61
| `POST /api/v1/rollback` | `{"archive": "naam"}` |
62
| `* /api/v1/admin/…` | de beheeracties van de backup server (lijst: `GET /api/v1/admin/actions`, veld `bluegit: true`) |
63
64
**Meldingen.** Elke gekoppelde backup server krijgt ze, ondertekend met zijn eigen key. Na elk schrijvend HTTP-verzoek (behalve de backup-API zelf en `git-upload-pack`), na elke push (ook SSH) en bij elke CI-gebeurtenis meldt BlueGit een wijziging. Meldingen worden 2 seconden gebundeld en bij een fout tot vier keer opnieuw geprobeerd. De backup server haalt daarnaast periodiek alles op, dus een gemiste melding kost alleen vertraging. Het adres van de backup server mag een privéadres zijn (de beheerder koppelt hem met een eigen key); de SSRF-regels van webhooks gelden hier niet.
65
66
### Compatibiliteit (protocolversie)
67
68
Elke kant heeft een **protocolversie** (wat hij spreekt) en een **minimumversie** (de oudste versie van de andere kant die hij nog ondersteunt). Nu is dat aan beide kanten protocol 1, minimum 1.
69
70
- BlueGit stuurt `X-BlueGit-Protocol`, `X-BlueGit-Min-Protocol` en `X-BlueGit-Version` mee op elk verzoek aan de backup server (meldingen, status, beheeracties, rollback) en op elk antwoord van de backup-API; `GET /api/v1/backup/info` geeft ook `protocol`, `min_protocol`, `version` en `compat`.
71
- De backup server stuurt `X-Backup-Protocol`, `X-Backup-Min-Protocol` en `X-Backup-Version` mee op elk verzoek aan BlueGit en op elk antwoord.
72
- Ontbreken de koppen, dan is het protocol 1 (BlueGit vóór deze versie en bluegit-backup v0.1.0).
73
- Ze passen als de backup server minstens het minimum van BlueGit spreekt en BlueGit minstens het minimum van de backup server. Anders is het `backup_too_old` (update de backup server) of `bluegit_too_old` (update BlueGit).
74
75
Wat er gebeurt als ze niet passen:
76
77
- BlueGit onthoudt per backup server het laatst gemelde protocol in `backup.json` en toont **beheerders bovenaan elke pagina een banner** met de naam van de backup server, wie er geüpdatet moet worden en een link naar Beheer → Backup. Andere gebruikers zien niets. De lijst en de pagina van de server tonen het ook, en de API (`GET /api/v1/admin/backup`) geeft per server `compat` en `protocol`.
78
- BlueGit weigert `manifest`, `file` en `restore` met `426 Upgrade Required` (`{"error", "compat", "protocol", "min_protocol"}`); `info` en `connect` blijven werken, zodat beide kanten het kunnen melden.
79
- De backup server vraagt vóór elke sync, rollback of restore `info` op en weigert zelf als het niet past; zijn webinterface toont een banner en `GET /api/v1/admin/status` geeft `compat` en `compat_message`.
80
- Na een update van de verouderde kant herstelt alles vanzelf bij het volgende contact.
81
82
Een test-build met een ander protocol: `go build -ldflags "-X gitlab.com/Timfa/bluegit/internal/backup.protocolVersion=99 -X gitlab.com/Timfa/bluegit/internal/backup.minBackupProtocol=99" ./cmd/bluegit` (de integratietests van bluegit-backup doen dat).
83
84
## Wat er in een backup zit
85
86
```text
87
state/bluegit.db consistente kopie (VACUUM INTO), niet het live bestand
88
state/secret.key nodig voor de versleutelde geheimen in de database
89
state/ssh/… SSH-hostkey
90
state/logos/…, state/avatars/…
91
data/repos/… bare repositories
92
data/releases/… release-assets (zonder .incoming)
93
data/artifacts/… CI-artifacts
94
```
95
96
Niet mee: `config.yml`, `storage_path`, `cache.json`, `backup.json` en `instance_id` (horen bij deze installatie), `data/work`, `*.lock` en symlinks. Elke backup server krijgt bij `GET /api/v1/backup/manifest` een eigen databasekopie (`<state>/.backup/snapshot-<id>.db`); kopieën worden één voor één gemaakt, zodat twee servers die tegelijk synchroniseren elkaars kopie niet vervangen. Verwijderen van een server ruimt zijn kopie op. De koppelingen staan in `<state>/backup.json` (0600, per server alleen de hash van de key) en niet in de database, zodat een rollback naar een oud archief de koppeling niet terugdraait.
97
98
## Terugzetten
99
100
`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,100 @@1
# Backup servers (bluegit-backup)2
3
Een losse backup server ([timfa/bluegit-backup](https://git.timfalken.com/timfa/bluegit-backup)) houdt een kopie bij van alle gegevens en configuratie van één BlueGit. Hij haalt ze langzaam op, krijgt na elke wijziging een melding, maakt periodiek een gecomprimeerd archief, en kan BlueGit naar zo'n archief terugzetten.4
5
Eén BlueGit kan meerdere backup servers hebben (hoogstens 16), elk met een eigen Backupserver-Key. Een backup server hoort bij één BlueGit.6
7
## In BlueGit8
9
**Beheer > Backup** (`/admin/backup`, alleen installatiebeheerders) toont de lijst met backup servers: naam, gekoppeld of wachtend op de key, adres en laatste contact. **Backup server toevoegen** maakt een nieuwe server met een eigen key, die één keer wordt getoond.10
11
Per backup server (`/admin/backup/s/<id>`) staat dezelfde bediening als in de webinterface van de backup server zelf:12
13
- **Status**: laatste sync en het resultaat ervan, aantal syncs en meldingen, grootte van de kopie, archieven, de laatste rollback en de versie. Met de knoppen *Nu synchroniseren*, *Nu archiveren* en *Nu opruimen*.14
- **Instellingen** van de backup server: archiefinterval, bewaartermijn, minimale vrije ruimte, downloadsnelheid, syncintervallen, publiek adres en luisteradres. BlueGit krijgt de velden van de backup server en toont ze zoals ze daar staan.15
- **Backup-archieven** met *Verwijderen* en *Rollback*. Een rollback staat achter een grote rode waarschuwing, een vinkje ("ik begrijp dat dit niet terug te draaien is"), het intypen van de archiefnaam en een bevestigingsdialoog.16
- **Backupserver-Key** vervangen (de oude key werkt meteen niet meer; de server moet opnieuw koppelen), de server hernoemen, of key intrekken en de server verwijderen. Bij verwijderen vraagt BlueGit de backup server eerst om te ontkoppelen. De archieven blijven op de backup server staan.17
18
BlueGit kent de acties niet vooraf. Het vraagt ze op bij de backup server (`GET /api/v1/admin/actions`) en stuurt ze ondertekend door. Alles wat de backup server voor BlueGit openzet, kan dus ook hier. Koppelen en een archief downloaden kan alleen op de backup server zelf.19
20
Dezelfde acties via de API (token van een beheerder, scope `api`/`admin`):21
22
| | |23
|---|---|24
| `GET /api/v1/admin/backup` | `instance_id` en de lijst met backup servers |25
| `POST /api/v1/admin/backup/servers` | `{"name"}`: nieuwe backup server; het antwoord bevat eenmalig `key` |26
| `GET /api/v1/admin/backup/servers/{id}` | server met `remote` (status), `archives` en `config`, zoals de backup server ze meldt |27
| `PUT /api/v1/admin/backup/servers/{id}` | `{"name"}`: hernoemen |28
| `POST /api/v1/admin/backup/servers/{id}/key` | nieuwe key (eenmalig in het antwoord) |29
| `DELETE /api/v1/admin/backup/servers/{id}` | ontkoppelen en vergeten |30
| `POST /api/v1/admin/backup/servers/{id}/actions/{name}` | actie van de backup server, bijvoorbeeld `config.update` met `{"retention_days": "14"}`, `sync`, `archive`, `prune`, `archive.delete` met `{"name"}`, of `rollback` met `{"archive": "naam", "confirm": "naam"}` |31
32
Het antwoord van een actie is het antwoord van de backup server, met dezelfde statuscode.33
34
## Protocol35
36
**De backup server praat met BlueGit** met de key als bearer-token (`Authorization: Bearer bgbk_…`):37
38
| | |39
|---|---|40
| `GET /api/v1/backup/info` | `instance_id`, `base_url`, naam en adres van de server bij deze key |41
| `POST /api/v1/backup/connect` | `{"server_url", "server_id"}`: waar BlueGit meldingen heen stuurt |42
| `GET /api/v1/backup/manifest` | alle bestanden: pad, grootte, mtime, mode; de database ook met sha256 |43
| `GET /api/v1/backup/file?path=…` | één bestand |44
| `POST /api/v1/backup/restore` | tar.gz met logische paden; BlueGit pakt uit en herstart (202) |45
46
Vijf mislukte key-pogingen per minuut per IP geven daarna `429`.47
48
**BlueGit praat met de backup server** met een HMAC-handtekening. Het geheim is `sha256("bluegit-backup-sign:" + key)` als hex; beide kanten leiden het af uit de key. Koppen:49
50
```text51
X-BlueGit-Instance: <instance_id>52
X-BlueGit-Timestamp: <unix-seconden> (hoogstens 5 minuten verschil)53
X-BlueGit-Signature: hex(HMAC-SHA256(geheim, METHOD "\n" PAD "\n" TS "\n" sha256hex(body)))54
```55
56
| | |57
|---|---|58
| `POST /api/v1/notify` | er is iets veranderd |59
| `GET /api/v1/archives` | `{"archives": [{name, created_at, size}]}` |60
| `GET /api/v1/status` | interval, bewaartermijn, stand van de laatste rollback |61
| `POST /api/v1/rollback` | `{"archive": "naam"}` |62
| `* /api/v1/admin/…` | de beheeracties van de backup server (lijst: `GET /api/v1/admin/actions`, veld `bluegit: true`) |63
64
**Meldingen.** Elke gekoppelde backup server krijgt ze, ondertekend met zijn eigen key. Na elk schrijvend HTTP-verzoek (behalve de backup-API zelf en `git-upload-pack`), na elke push (ook SSH) en bij elke CI-gebeurtenis meldt BlueGit een wijziging. Meldingen worden 2 seconden gebundeld en bij een fout tot vier keer opnieuw geprobeerd. De backup server haalt daarnaast periodiek alles op, dus een gemiste melding kost alleen vertraging. Het adres van de backup server mag een privéadres zijn (de beheerder koppelt hem met een eigen key); de SSRF-regels van webhooks gelden hier niet.65
66
### Compatibiliteit (protocolversie)67
68
Elke kant heeft een **protocolversie** (wat hij spreekt) en een **minimumversie** (de oudste versie van de andere kant die hij nog ondersteunt). Nu is dat aan beide kanten protocol 1, minimum 1.69
70
- BlueGit stuurt `X-BlueGit-Protocol`, `X-BlueGit-Min-Protocol` en `X-BlueGit-Version` mee op elk verzoek aan de backup server (meldingen, status, beheeracties, rollback) en op elk antwoord van de backup-API; `GET /api/v1/backup/info` geeft ook `protocol`, `min_protocol`, `version` en `compat`.71
- De backup server stuurt `X-Backup-Protocol`, `X-Backup-Min-Protocol` en `X-Backup-Version` mee op elk verzoek aan BlueGit en op elk antwoord.72
- Ontbreken de koppen, dan is het protocol 1 (BlueGit vóór deze versie en bluegit-backup v0.1.0).73
- Ze passen als de backup server minstens het minimum van BlueGit spreekt en BlueGit minstens het minimum van de backup server. Anders is het `backup_too_old` (update de backup server) of `bluegit_too_old` (update BlueGit).74
75
Wat er gebeurt als ze niet passen:76
77
- BlueGit onthoudt per backup server het laatst gemelde protocol in `backup.json` en toont **beheerders bovenaan elke pagina een banner** met de naam van de backup server, wie er geüpdatet moet worden en een link naar Beheer → Backup. Andere gebruikers zien niets. De lijst en de pagina van de server tonen het ook, en de API (`GET /api/v1/admin/backup`) geeft per server `compat` en `protocol`.78
- BlueGit weigert `manifest`, `file` en `restore` met `426 Upgrade Required` (`{"error", "compat", "protocol", "min_protocol"}`); `info` en `connect` blijven werken, zodat beide kanten het kunnen melden.79
- De backup server vraagt vóór elke sync, rollback of restore `info` op en weigert zelf als het niet past; zijn webinterface toont een banner en `GET /api/v1/admin/status` geeft `compat` en `compat_message`.80
- Na een update van de verouderde kant herstelt alles vanzelf bij het volgende contact.81
82
Een test-build met een ander protocol: `go build -ldflags "-X gitlab.com/Timfa/bluegit/internal/backup.protocolVersion=99 -X gitlab.com/Timfa/bluegit/internal/backup.minBackupProtocol=99" ./cmd/bluegit` (de integratietests van bluegit-backup doen dat).83
84
## Wat er in een backup zit85
86
```text87
state/bluegit.db consistente kopie (VACUUM INTO), niet het live bestand88
state/secret.key nodig voor de versleutelde geheimen in de database89
state/ssh/… SSH-hostkey90
state/logos/…, state/avatars/…91
data/repos/… bare repositories92
data/releases/… release-assets (zonder .incoming)93
data/artifacts/… CI-artifacts94
```95
96
Niet mee: `config.yml`, `storage_path`, `cache.json`, `backup.json` en `instance_id` (horen bij deze installatie), `data/work`, `*.lock` en symlinks. Elke backup server krijgt bij `GET /api/v1/backup/manifest` een eigen databasekopie (`<state>/.backup/snapshot-<id>.db`); kopieën worden één voor één gemaakt, zodat twee servers die tegelijk synchroniseren elkaars kopie niet vervangen. Verwijderen van een server ruimt zijn kopie op. De koppelingen staan in `<state>/backup.json` (0600, per server alleen de hash van de key) en niet in de database, zodat een rollback naar een oud archief de koppeling niet terugdraait.97
98
## Terugzetten99
100
`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,194 @@
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. Eén BlueGit kan wel meerdere backup servers hebben, elk met een eigen key.
12
- Een **webinterface** (standaard op poort 8080) waarin alles in te stellen en te bedienen is, en een **API** die precies hetzelfde kan. Beide lopen via één lijst met acties (`GET /api/v1/admin/actions`).
13
- Vanuit **BlueGit** (*Beheer → Backup → server*) is de backup server ook te bedienen: status, instellingen, sync, archiveren, opruimen, archieven verwijderen en rollback. BlueGit vraagt de acties op bij de backup server en stuurt ze ondertekend door.
14
15
Het protocol staat in [docs/PROTOCOL.md](docs/PROTOCOL.md). De aannames staan in [docs/ASSUMPTIONS.md](docs/ASSUMPTIONS.md).
16
17
## Installeren
18
19
### Arch Linux (AUR)
20
21
```sh
22
yay -S bluegit-backup
23
```
24
25
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`).
26
27
### Binary
28
29
Bij een release staan `bluegit-backup-linux-amd64`, `bluegit-backup-linux-arm64` en `SHA256SUMS`. Zelf bouwen:
30
31
```sh
32
go build -o bluegit-backup ./cmd/bluegit-backup
33
./bluegit-backup example-config > config.yml
34
./bluegit-backup serve --config config.yml
35
```
36
37
## Koppelen
38
39
1. Zet in `config.yml` `public_url` op het adres waarop BlueGit deze server bereikt.
40
2. Start de server: `systemctl enable --now bluegit-backup`.
41
3. Voeg in BlueGit onder *Beheer → Backup* een backup server toe. De Backupserver-Key wordt één keer getoond.
42
4. Koppel in de webinterface (`http://<server>:8080`, sectie *Koppeling*), of met de CLI:
43
44
```sh
45
BLUEGIT_BACKUP_KEY=bgbk_… bluegit-backup connect --url https://git.example.com
46
```
47
48
Had deze server al backups van een andere BlueGit, dan vraagt `connect`:
49
50
```
51
1) oude backups wissen en opnieuw beginnen
52
2) de nieuwe BlueGit herstellen met de laatste backupdata
53
```
54
55
Zonder terminal kies je met `--on-conflict wipe` of `--on-conflict restore`.
56
57
Daarna haalt de server meteen een volledige kopie op en maakt hij een eerste archief.
58
59
## Webinterface
60
61
Open `http://<server>:8080` en log in met het beheertoken uit `data_dir/admin.token`:
62
63
```sh
64
sudo -u bluegit-backup bluegit-backup token
65
```
66
67
Daar staan:
68
69
- **Overzicht**: koppeling, laatste sync, kopie, archieven en de laatste rollback, met *Nu synchroniseren*, *Nu archiveren* en *Nu opruimen*.
70
- **Koppeling**: koppelen (met de keuze wissen of herstellen bij een andere BlueGit) en ontkoppelen.
71
- **Instellingen**: elk veld uit de tabel hieronder. Ze gaan naar `data_dir/settings.yml`, dat boven `config.yml` gaat. `listen` geldt pas na een herstart, de rest meteen.
72
- **Archieven**: downloaden, verwijderen en een rollback (met waarschuwing, vinkje en de archiefnaam overtypen).
73
- **API**: de lijst met alle acties.
74
75
Passen BlueGit en deze backup server niet bij elkaar (een van de twee is verouderd), dan staat er bovenaan een waarschuwing die zegt wie er geüpdatet moet worden. De server synchroniseert en zet dan niets terug tot dat gebeurd is. Zie [Compatibiliteit](#compatibiliteit).
76
77
De sessie is een HttpOnly-cookie (SameSite=Strict, 12 uur), elk formulier heeft een CSRF-token, en vijf foute logins per minuut per IP-adres geven `429`. De interface mag niet in een frame van een andere site. Gebruik een TLS-proxy als de server buiten je eigen netwerk bereikbaar is.
78
79
## API
80
81
Elke actie uit de webinterface is ook een API-aanroep, met `Authorization: Bearer <admin.token>`:
82
83
| Methode | Pad | Actie | BlueGit |
84
|---|---|---|---|
85
| GET | `/api/v1/admin/status` | Status | ✓ |
86
| GET | `/api/v1/admin/actions` | Alle acties | ✓ |
87
| GET | `/api/v1/admin/config` | Instellingen met uitleg | ✓ |
88
| PUT | `/api/v1/admin/config` | Instellingen wijzigen, bv. `{"retention_days": 14}` | ✓ |
89
| POST | `/api/v1/admin/connect` | `{"url", "key", "on_conflict": ""\|"wipe"\|"restore"}` | |
90
| POST | `/api/v1/admin/disconnect` | Ontkoppelen (kopie en archieven blijven) | ✓ |
91
| POST | `/api/v1/admin/sync` | Nu synchroniseren (`{"wait": false}`: op de achtergrond) | ✓ |
92
| POST | `/api/v1/admin/archive` | Nu archiveren | ✓ |
93
| POST | `/api/v1/admin/prune` | Bewaarregels nu toepassen | ✓ |
94
| GET | `/api/v1/admin/archives` | Archieven | ✓ |
95
| GET | `/api/v1/admin/archives/{name}/download` | Archief downloaden | |
96
| DELETE | `/api/v1/admin/archives/{name}` | Archief verwijderen | ✓ |
97
| POST | `/api/v1/admin/rollback` | `{"archive", "confirm": archiefnaam}`; niet terug te draaien | ✓ |
98
99
✓ betekent dat de gekoppelde BlueGit dit ook mag, met een ondertekend verzoek. Een sessie van de webinterface mag de API ook gebruiken, met het CSRF-token in `X-CSRF-Token`.
100
101
## Compatibiliteit
102
103
BlueGit en de backup server melden elkaar hun protocolversie en de oudste versie van de andere kant die ze nog ondersteunen (koppen `X-Backup-Protocol`/`X-Backup-Min-Protocol` en `X-BlueGit-Protocol`/`X-BlueGit-Min-Protocol`, plus `info`). Deze versie spreekt protocol 1 en ondersteunt BlueGit vanaf protocol 1. Een BlueGit die geen protocol meldt, spreekt protocol 1.
104
105
Past het niet:
106
107
- weigert de backup server te synchroniseren en terug te zetten (`409`), en geven `GET /api/v1/admin/status` en de webinterface `compat` (`bluegit_too_old` of `backup_too_old`) en een uitleg;
108
- zien beheerders in BlueGit bovenaan elke pagina een banner met de naam van de backup server en wie er geüpdatet moet worden, met een link naar Beheer → Backup;
109
- weigert BlueGit de gegevens (`426`).
110
111
Updaten doe je zelf (zie [Releases](#releases)); bij het volgende contact is alles weer normaal. Het protocol staat in [docs/PROTOCOL.md](docs/PROTOCOL.md).
112
113
## CLI
114
115
```sh
116
bluegit-backup status | list | config | actions
117
bluegit-backup sync | archive | prune | disconnect
118
bluegit-backup set retention_days=14 archive_interval=12h
119
bluegit-backup delete bluegit-20261115-030000.tar.gz
120
bluegit-backup rollback bluegit-20261115-030000.tar.gz # vraagt om de naam over te typen
121
bluegit-backup token # beheertoken voor de webinterface
122
```
123
124
Deze commando's praten met de draaiende server via `data_dir/admin.token`. Draai ze dus als een gebruiker die dat bestand kan lezen (`sudo -u bluegit-backup …`).
125
126
## Configuratie
127
128
| Sleutel | Standaard | Betekenis |
129
|---|---|---|
130
| `listen` | `0.0.0.0:8080` | Adres van de webinterface en API (na herstart) |
131
| `public_url` | (leeg) | Adres waarop BlueGit deze server bereikt |
132
| `data_dir` | `/var/lib/bluegit-backup` | Kopie, archieven en koppeling (alleen in `config.yml`) |
133
| `archive_interval` | `24h` | Hoe vaak een archief |
134
| `retention_days` | `30` | Archieven ouder dan dit weg (0 = nooit) |
135
| `min_free_mb` | `1024` | Minder vrij: oudste archief weg |
136
| `rate_limit_kib` | `1024` | Downloadsnelheid in KiB/s (0 = onbeperkt) |
137
| `full_sync_interval` | `1h` | Ook zonder melding alles nalopen |
138
| `min_sync_interval` | `10s` | Minimale tijd tussen syncs na meldingen |
139
140
In `data_dir`:
141
142
- `mirror/` is de lopende kopie.
143
- `archives/` bevat `bluegit-YYYYMMDD-HHMMSS.tar.gz` (UTC).
144
- `state.json` (0600) is de koppeling met de key.
145
- `admin.token` (0600) is voor de webinterface, de API en de CLI.
146
- `settings.yml` (0600) bevat wat via de webinterface, API of BlueGit is ingesteld.
147
148
## Releases
149
150
Een AUR-pakket (`bluegit-backup`, bijgewerkt vanaf master) en binaries bij een tag. Zie `blue-ci-cd.yml`.
151
152
- 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.
153
- 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`.
154
- Een release bij een tag (`v*`) publiceert de binaries bij een bestaande tag.
155
- Eerste release: [v0.1.0](https://git.timfalken.com/timfa/bluegit-backup/-/releases) (linux amd64/arm64 en `SHA256SUMS`).
156
157
Updaten doe je zelf: met je AUR-helper (bijvoorbeeld `yay -Syu bluegit-backup`) of met een nieuwe binary van de releasepagina. Er is geen self-update.
158
159
## Tests
160
161
```sh
162
go test ./... # unit-tests
163
./scripts/build-bluegit.sh # bouwt .bluegit-bin/bluegit
164
BLUEGIT_BIN=$PWD/.bluegit-bin/bluegit go test -tags integration -v ./integration/
165
```
166
167
Daarnaast controleren unit-tests dat elke wijzigende actie een formulier in de webinterface heeft, en elk formulier een API-actie.
168
169
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:
170
171
| Test | Feature |
172
|---|---|
173
| `TestKeyGenerationAndConnect` | Key maken in BlueGit, koppelen, verkeerde key geweigerd |
174
| `TestFullSyncCopiesAllData` | Alle data en configuratie komt binnen, en de kopie klopt |
175
| `TestNotificationTriggersSync` | Een wijziging in BlueGit geeft een melding en daarna een sync |
176
| `TestDownloadIsThrottled` | Downloaden blijft onder `rate_limit_kib` |
177
| `TestArchiveIntervalAndListInBlueGit` | Archief per interval, lijst zichtbaar in BlueGit |
178
| `TestRetentionAndDiskFull` | Weggooien op leeftijd en bij volle schijf |
179
| `TestRollbackFromBlueGit` | Rollback vanuit BlueGit (met bevestiging), BlueGit staat daarna terug |
180
| `TestNewInstanceWipe` | Nieuwe instantie, keuze wissen |
181
| `TestNewInstanceRestore` | Nieuwe instantie, keuze herstellen |
182
| `TestCLIConnectAsksOnConflict` | `connect` vraagt de keuze |
183
| `TestWebUIConfiguresAndOperatesEverything` | Webinterface: inloggen, alle instellingen, koppelen, sync, archief, download, opruimen, rollback, verwijderen, ontkoppelen |
184
| `TestAPIDoesEverythingTheUICan` | Elke actie via de API; de test faalt als er een actie bij komt zonder test |
185
| `TestBlueGitControlsBackupServer` | Instellingen, archief, sync en verwijderen vanuit BlueGit (API en webinterface) |
186
| `TestMultipleBackupServers` | Twee backup servers aan één BlueGit; meldingen naar beide; verwijderen ontkoppelt alleen die ene |
187
| `TestCompatBlueGitTooOld` | Backup server vraagt een nieuwer protocol: hij weigert sync en rollback, waarschuwt in UI en API; BlueGit toont beheerders de banner op elke pagina; na de update is alles weer normaal |
188
| `TestCompatBackupTooOld` | Test-build van BlueGit met protocol 99 (`-ldflags -X`): koppelen lukt, BlueGit geeft `426`, de backup server weigert, beheerders zien de banner en een gewone gebruiker niet |
189
190
De pipeline bouwt BlueGit van de ref in `.bluegit-ref`, plus een test-build met protocol 99 (`.bluegit-bin/bluegit-future`) voor `TestCompatBackupTooOld`.
191
192
## Licentie
193
194
Zie [LICENSE](LICENSE).
@@ -0,0 +1,194 @@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. Eén BlueGit kan wel meerdere backup servers hebben, elk met een eigen key.12
- Een **webinterface** (standaard op poort 8080) waarin alles in te stellen en te bedienen is, en een **API** die precies hetzelfde kan. Beide lopen via één lijst met acties (`GET /api/v1/admin/actions`).13
- Vanuit **BlueGit** (*Beheer → Backup → server*) is de backup server ook te bedienen: status, instellingen, sync, archiveren, opruimen, archieven verwijderen en rollback. BlueGit vraagt de acties op bij de backup server en stuurt ze ondertekend door.14
15
Het protocol staat in [docs/PROTOCOL.md](docs/PROTOCOL.md). De aannames staan in [docs/ASSUMPTIONS.md](docs/ASSUMPTIONS.md).16
17
## Installeren18
19
### Arch Linux (AUR)20
21
```sh22
yay -S bluegit-backup23
```24
25
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`).26
27
### Binary28
29
Bij een release staan `bluegit-backup-linux-amd64`, `bluegit-backup-linux-arm64` en `SHA256SUMS`. Zelf bouwen:30
31
```sh32
go build -o bluegit-backup ./cmd/bluegit-backup33
./bluegit-backup example-config > config.yml34
./bluegit-backup serve --config config.yml35
```36
37
## Koppelen38
39
1. Zet in `config.yml` `public_url` op het adres waarop BlueGit deze server bereikt.40
2. Start de server: `systemctl enable --now bluegit-backup`.41
3. Voeg in BlueGit onder *Beheer → Backup* een backup server toe. De Backupserver-Key wordt één keer getoond.42
4. Koppel in de webinterface (`http://<server>:8080`, sectie *Koppeling*), of met de CLI:43
44
```sh45
BLUEGIT_BACKUP_KEY=bgbk_… bluegit-backup connect --url https://git.example.com46
```47
48
Had deze server al backups van een andere BlueGit, dan vraagt `connect`:49
50
```51
1) oude backups wissen en opnieuw beginnen52
2) de nieuwe BlueGit herstellen met de laatste backupdata53
```54
55
Zonder terminal kies je met `--on-conflict wipe` of `--on-conflict restore`.56
57
Daarna haalt de server meteen een volledige kopie op en maakt hij een eerste archief.58
59
## Webinterface60
61
Open `http://<server>:8080` en log in met het beheertoken uit `data_dir/admin.token`:62
63
```sh64
sudo -u bluegit-backup bluegit-backup token65
```66
67
Daar staan:68
69
- **Overzicht**: koppeling, laatste sync, kopie, archieven en de laatste rollback, met *Nu synchroniseren*, *Nu archiveren* en *Nu opruimen*.70
- **Koppeling**: koppelen (met de keuze wissen of herstellen bij een andere BlueGit) en ontkoppelen.71
- **Instellingen**: elk veld uit de tabel hieronder. Ze gaan naar `data_dir/settings.yml`, dat boven `config.yml` gaat. `listen` geldt pas na een herstart, de rest meteen.72
- **Archieven**: downloaden, verwijderen en een rollback (met waarschuwing, vinkje en de archiefnaam overtypen).73
- **API**: de lijst met alle acties.74
75
Passen BlueGit en deze backup server niet bij elkaar (een van de twee is verouderd), dan staat er bovenaan een waarschuwing die zegt wie er geüpdatet moet worden. De server synchroniseert en zet dan niets terug tot dat gebeurd is. Zie [Compatibiliteit](#compatibiliteit).76
77
De sessie is een HttpOnly-cookie (SameSite=Strict, 12 uur), elk formulier heeft een CSRF-token, en vijf foute logins per minuut per IP-adres geven `429`. De interface mag niet in een frame van een andere site. Gebruik een TLS-proxy als de server buiten je eigen netwerk bereikbaar is.78
79
## API80
81
Elke actie uit de webinterface is ook een API-aanroep, met `Authorization: Bearer <admin.token>`:82
83
| Methode | Pad | Actie | BlueGit |84
|---|---|---|---|85
| GET | `/api/v1/admin/status` | Status | ✓ |86
| GET | `/api/v1/admin/actions` | Alle acties | ✓ |87
| GET | `/api/v1/admin/config` | Instellingen met uitleg | ✓ |88
| PUT | `/api/v1/admin/config` | Instellingen wijzigen, bv. `{"retention_days": 14}` | ✓ |89
| POST | `/api/v1/admin/connect` | `{"url", "key", "on_conflict": ""\|"wipe"\|"restore"}` | |90
| POST | `/api/v1/admin/disconnect` | Ontkoppelen (kopie en archieven blijven) | ✓ |91
| POST | `/api/v1/admin/sync` | Nu synchroniseren (`{"wait": false}`: op de achtergrond) | ✓ |92
| POST | `/api/v1/admin/archive` | Nu archiveren | ✓ |93
| POST | `/api/v1/admin/prune` | Bewaarregels nu toepassen | ✓ |94
| GET | `/api/v1/admin/archives` | Archieven | ✓ |95
| GET | `/api/v1/admin/archives/{name}/download` | Archief downloaden | |96
| DELETE | `/api/v1/admin/archives/{name}` | Archief verwijderen | ✓ |97
| POST | `/api/v1/admin/rollback` | `{"archive", "confirm": archiefnaam}`; niet terug te draaien | ✓ |98
99
✓ betekent dat de gekoppelde BlueGit dit ook mag, met een ondertekend verzoek. Een sessie van de webinterface mag de API ook gebruiken, met het CSRF-token in `X-CSRF-Token`.100
101
## Compatibiliteit102
103
BlueGit en de backup server melden elkaar hun protocolversie en de oudste versie van de andere kant die ze nog ondersteunen (koppen `X-Backup-Protocol`/`X-Backup-Min-Protocol` en `X-BlueGit-Protocol`/`X-BlueGit-Min-Protocol`, plus `info`). Deze versie spreekt protocol 1 en ondersteunt BlueGit vanaf protocol 1. Een BlueGit die geen protocol meldt, spreekt protocol 1.104
105
Past het niet:106
107
- weigert de backup server te synchroniseren en terug te zetten (`409`), en geven `GET /api/v1/admin/status` en de webinterface `compat` (`bluegit_too_old` of `backup_too_old`) en een uitleg;108
- zien beheerders in BlueGit bovenaan elke pagina een banner met de naam van de backup server en wie er geüpdatet moet worden, met een link naar Beheer → Backup;109
- weigert BlueGit de gegevens (`426`).110
111
Updaten doe je zelf (zie [Releases](#releases)); bij het volgende contact is alles weer normaal. Het protocol staat in [docs/PROTOCOL.md](docs/PROTOCOL.md).112
113
## CLI114
115
```sh116
bluegit-backup status | list | config | actions117
bluegit-backup sync | archive | prune | disconnect118
bluegit-backup set retention_days=14 archive_interval=12h119
bluegit-backup delete bluegit-20261115-030000.tar.gz120
bluegit-backup rollback bluegit-20261115-030000.tar.gz # vraagt om de naam over te typen121
bluegit-backup token # beheertoken voor de webinterface122
```123
124
Deze commando's praten met de draaiende server via `data_dir/admin.token`. Draai ze dus als een gebruiker die dat bestand kan lezen (`sudo -u bluegit-backup …`).125
126
## Configuratie127
128
| Sleutel | Standaard | Betekenis |129
|---|---|---|130
| `listen` | `0.0.0.0:8080` | Adres van de webinterface en API (na herstart) |131
| `public_url` | (leeg) | Adres waarop BlueGit deze server bereikt |132
| `data_dir` | `/var/lib/bluegit-backup` | Kopie, archieven en koppeling (alleen in `config.yml`) |133
| `archive_interval` | `24h` | Hoe vaak een archief |134
| `retention_days` | `30` | Archieven ouder dan dit weg (0 = nooit) |135
| `min_free_mb` | `1024` | Minder vrij: oudste archief weg |136
| `rate_limit_kib` | `1024` | Downloadsnelheid in KiB/s (0 = onbeperkt) |137
| `full_sync_interval` | `1h` | Ook zonder melding alles nalopen |138
| `min_sync_interval` | `10s` | Minimale tijd tussen syncs na meldingen |139
140
In `data_dir`:141
142
- `mirror/` is de lopende kopie.143
- `archives/` bevat `bluegit-YYYYMMDD-HHMMSS.tar.gz` (UTC).144
- `state.json` (0600) is de koppeling met de key.145
- `admin.token` (0600) is voor de webinterface, de API en de CLI.146
- `settings.yml` (0600) bevat wat via de webinterface, API of BlueGit is ingesteld.147
148
## Releases149
150
Een AUR-pakket (`bluegit-backup`, bijgewerkt vanaf master) en binaries bij een tag. Zie `blue-ci-cd.yml`.151
152
- 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.153
- 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`.154
- Een release bij een tag (`v*`) publiceert de binaries bij een bestaande tag.155
- Eerste release: [v0.1.0](https://git.timfalken.com/timfa/bluegit-backup/-/releases) (linux amd64/arm64 en `SHA256SUMS`).156
157
Updaten doe je zelf: met je AUR-helper (bijvoorbeeld `yay -Syu bluegit-backup`) of met een nieuwe binary van de releasepagina. Er is geen self-update.158
159
## Tests160
161
```sh162
go test ./... # unit-tests163
./scripts/build-bluegit.sh # bouwt .bluegit-bin/bluegit164
BLUEGIT_BIN=$PWD/.bluegit-bin/bluegit go test -tags integration -v ./integration/165
```166
167
Daarnaast controleren unit-tests dat elke wijzigende actie een formulier in de webinterface heeft, en elk formulier een API-actie.168
169
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:170
171
| Test | Feature |172
|---|---|173
| `TestKeyGenerationAndConnect` | Key maken in BlueGit, koppelen, verkeerde key geweigerd |174
| `TestFullSyncCopiesAllData` | Alle data en configuratie komt binnen, en de kopie klopt |175
| `TestNotificationTriggersSync` | Een wijziging in BlueGit geeft een melding en daarna een sync |176
| `TestDownloadIsThrottled` | Downloaden blijft onder `rate_limit_kib` |177
| `TestArchiveIntervalAndListInBlueGit` | Archief per interval, lijst zichtbaar in BlueGit |178
| `TestRetentionAndDiskFull` | Weggooien op leeftijd en bij volle schijf |179
| `TestRollbackFromBlueGit` | Rollback vanuit BlueGit (met bevestiging), BlueGit staat daarna terug |180
| `TestNewInstanceWipe` | Nieuwe instantie, keuze wissen |181
| `TestNewInstanceRestore` | Nieuwe instantie, keuze herstellen |182
| `TestCLIConnectAsksOnConflict` | `connect` vraagt de keuze |183
| `TestWebUIConfiguresAndOperatesEverything` | Webinterface: inloggen, alle instellingen, koppelen, sync, archief, download, opruimen, rollback, verwijderen, ontkoppelen |184
| `TestAPIDoesEverythingTheUICan` | Elke actie via de API; de test faalt als er een actie bij komt zonder test |185
| `TestBlueGitControlsBackupServer` | Instellingen, archief, sync en verwijderen vanuit BlueGit (API en webinterface) |186
| `TestMultipleBackupServers` | Twee backup servers aan één BlueGit; meldingen naar beide; verwijderen ontkoppelt alleen die ene |187
| `TestCompatBlueGitTooOld` | Backup server vraagt een nieuwer protocol: hij weigert sync en rollback, waarschuwt in UI en API; BlueGit toont beheerders de banner op elke pagina; na de update is alles weer normaal |188
| `TestCompatBackupTooOld` | Test-build van BlueGit met protocol 99 (`-ldflags -X`): koppelen lukt, BlueGit geeft `426`, de backup server weigert, beheerders zien de banner en een gewone gebruiker niet |189
190
De pipeline bouwt BlueGit van de ref in `.bluegit-ref`, plus een test-build met protocol 99 (`.bluegit-bin/bluegit-future`) voor `TestCompatBackupTooOld`.191
192
## Licentie193
194
Zie [LICENSE](LICENSE).@@ -0,0 +1,349 @@
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
// Delete verwijdert één archief.
100
func (s *Store) Delete(name string) error {
101
p, err := s.Path(name)
102
if err != nil {
103
return err
104
}
105
return os.Remove(p)
106
}
107
108
// DeleteAll verwijdert alle archieven.
109
func (s *Store) DeleteAll() error {
110
list, err := s.List()
111
if err != nil {
112
return err
113
}
114
for _, a := range list {
115
if err := os.Remove(filepath.Join(s.Dir, a.Name)); err != nil {
116
return err
117
}
118
}
119
return nil
120
}
121
122
// Create schrijft een nieuw archief van mirrorDir. needBytes is een
123
// schatting van de grootte; is er te weinig ruimte, dan gaan eerst oude
124
// archieven weg (het nieuwste blijft).
125
func (s *Store) Create(mirrorDir string, now time.Time, needBytes int64, minFree uint64) (Archive, []string, error) {
126
if err := os.MkdirAll(s.Dir, 0o750); err != nil {
127
return Archive{}, nil, err
128
}
129
var removed []string
130
for {
131
free, err := s.free()
132
if err != nil || free >= uint64(needBytes)+minFree {
133
break
134
}
135
// Het nieuwe archief wordt het nieuwste; daarvoor mag ook het
136
// laatste oude weg. De draaiende kopie blijft altijd staan.
137
name, ok, err := s.removeOldest(0)
138
if err != nil {
139
return Archive{}, removed, err
140
}
141
if !ok {
142
return Archive{}, removed, fmt.Errorf("te weinig schijfruimte voor een archief (%d MB vrij, %d MB nodig)", free>>20, (uint64(needBytes)+minFree)>>20)
143
}
144
removed = append(removed, name)
145
}
146
base := "bluegit-" + now.UTC().Format("20060102-150405")
147
name := base + ".tar.gz"
148
for i := 1; ; i++ {
149
if _, err := os.Stat(filepath.Join(s.Dir, name)); errors.Is(err, os.ErrNotExist) {
150
break
151
}
152
name = fmt.Sprintf("%s-%d.tar.gz", base, i)
153
}
154
tmp := filepath.Join(s.Dir, "."+name+".partial")
155
f, err := os.OpenFile(tmp, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0o640)
156
if err != nil {
157
return Archive{}, removed, err
158
}
159
if err := WriteTarGz(f, mirrorDir); err != nil {
160
f.Close()
161
os.Remove(tmp)
162
return Archive{}, removed, err
163
}
164
if err := f.Sync(); err != nil {
165
f.Close()
166
os.Remove(tmp)
167
return Archive{}, removed, err
168
}
169
if err := f.Close(); err != nil {
170
os.Remove(tmp)
171
return Archive{}, removed, err
172
}
173
final := filepath.Join(s.Dir, name)
174
if err := os.Rename(tmp, final); err != nil {
175
os.Remove(tmp)
176
return Archive{}, removed, err
177
}
178
_ = os.Chtimes(final, now, now)
179
fi, _ := os.Stat(final)
180
return Archive{Name: name, CreatedAt: now.UTC(), Size: fi.Size()}, removed, nil
181
}
182
183
// removeOldest verwijdert het oudste archief zolang er meer dan keep zijn.
184
func (s *Store) removeOldest(keep int) (string, bool, error) {
185
list, err := s.List()
186
if err != nil {
187
return "", false, err
188
}
189
if len(list) <= keep {
190
return "", false, nil
191
}
192
old := list[len(list)-1]
193
if err := os.Remove(filepath.Join(s.Dir, old.Name)); err != nil {
194
return "", false, err
195
}
196
return old.Name, true, nil
197
}
198
199
// Prune verwijdert archieven ouder dan retentionDays (0 = niet op leeftijd)
200
// en daarna de oudste zolang er minder dan minFree bytes vrij is. Het
201
// nieuwste archief blijft altijd staan.
202
func (s *Store) Prune(now time.Time, retentionDays int, minFree uint64) ([]string, error) {
203
var removed []string
204
list, err := s.List()
205
if err != nil {
206
return nil, err
207
}
208
if retentionDays > 0 {
209
cut := now.Add(-time.Duration(retentionDays) * 24 * time.Hour)
210
for i, a := range list {
211
if i == 0 || !a.CreatedAt.Before(cut) {
212
continue
213
}
214
if err := os.Remove(filepath.Join(s.Dir, a.Name)); err != nil {
215
return removed, err
216
}
217
removed = append(removed, a.Name)
218
}
219
}
220
for {
221
free, err := s.free()
222
if err != nil || free >= minFree {
223
break
224
}
225
name, ok, err := s.removeOldest(1)
226
if err != nil {
227
return removed, err
228
}
229
if !ok {
230
break
231
}
232
removed = append(removed, name)
233
}
234
return removed, nil
235
}
236
237
// WriteTarGz schrijft dir als tar.gz met logische paden naar w.
238
func WriteTarGz(w io.Writer, dir string) error {
239
gz, _ := gzip.NewWriterLevel(w, gzip.DefaultCompression)
240
tw := tar.NewWriter(gz)
241
var paths []string
242
err := filepath.WalkDir(dir, func(p string, d fs.DirEntry, err error) error {
243
if err != nil {
244
if errors.Is(err, fs.ErrNotExist) && p == dir {
245
return fs.SkipDir
246
}
247
return err
248
}
249
if d.Type().IsRegular() {
250
paths = append(paths, p)
251
}
252
return nil
253
})
254
if err != nil {
255
return err
256
}
257
sort.Strings(paths)
258
for _, p := range paths {
259
rel, _ := filepath.Rel(dir, p)
260
logical := filepath.ToSlash(rel)
261
if _, ok := protocol.CleanLogical(logical); !ok {
262
continue
263
}
264
if err := addFile(tw, p, logical); err != nil {
265
return err
266
}
267
}
268
if err := tw.Close(); err != nil {
269
return err
270
}
271
return gz.Close()
272
}
273
274
func addFile(tw *tar.Writer, p, logical string) error {
275
f, err := os.Open(p)
276
if err != nil {
277
return err
278
}
279
defer f.Close()
280
fi, err := f.Stat()
281
if err != nil {
282
return err
283
}
284
h := &tar.Header{
285
Name: logical, Mode: int64(fi.Mode().Perm()), Size: fi.Size(), Typeflag: tar.TypeReg,
286
ModTime: fi.ModTime(), Format: tar.FormatPAX,
287
}
288
if err := tw.WriteHeader(h); err != nil {
289
return err
290
}
291
_, err = io.CopyN(tw, f, fi.Size())
292
return err
293
}
294
295
// Extract pakt archief src uit in dst (dat nog niet mag bestaan). Alleen
296
// gewone bestanden met geldige logische paden.
297
func Extract(src, dst string) error {
298
f, err := os.Open(src)
299
if err != nil {
300
return err
301
}
302
defer f.Close()
303
return ExtractReader(f, dst)
304
}
305
306
// ExtractReader is Extract vanaf een stroom.
307
func ExtractReader(r io.Reader, dst string) error {
308
if err := os.MkdirAll(dst, 0o750); err != nil {
309
return err
310
}
311
gz, err := gzip.NewReader(r)
312
if err != nil {
313
return err
314
}
315
tr := tar.NewReader(gz)
316
for {
317
h, err := tr.Next()
318
if err == io.EOF {
319
return nil
320
}
321
if err != nil {
322
return err
323
}
324
if h.Typeflag == tar.TypeDir {
325
continue
326
}
327
logical, ok := protocol.CleanLogical(strings.TrimPrefix(h.Name, "./"))
328
if h.Typeflag != tar.TypeReg || !ok {
329
return fmt.Errorf("ongeldig item in archief: %q", h.Name)
330
}
331
out := filepath.Join(dst, filepath.FromSlash(logical))
332
if err := os.MkdirAll(filepath.Dir(out), 0o750); err != nil {
333
return err
334
}
335
mode := os.FileMode(h.Mode).Perm()&0o755 | 0o600
336
w, err := os.OpenFile(out, os.O_CREATE|os.O_EXCL|os.O_WRONLY, mode)
337
if err != nil {
338
return err
339
}
340
if _, err := io.Copy(w, tr); err != nil {
341
w.Close()
342
return err
343
}
344
if err := w.Close(); err != nil {
345
return err
346
}
347
_ = os.Chtimes(out, h.ModTime, h.ModTime)
348
}
349
}
@@ -0,0 +1,349 @@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
// Delete verwijdert één archief.100
func (s *Store) Delete(name string) error {101
p, err := s.Path(name)102
if err != nil {103
return err104
}105
return os.Remove(p)106
}107
108
// DeleteAll verwijdert alle archieven.109
func (s *Store) DeleteAll() error {110
list, err := s.List()111
if err != nil {112
return err113
}114
for _, a := range list {115
if err := os.Remove(filepath.Join(s.Dir, a.Name)); err != nil {116
return err117
}118
}119
return nil120
}121
122
// Create schrijft een nieuw archief van mirrorDir. needBytes is een123
// schatting van de grootte; is er te weinig ruimte, dan gaan eerst oude124
// archieven weg (het nieuwste blijft).125
func (s *Store) Create(mirrorDir string, now time.Time, needBytes int64, minFree uint64) (Archive, []string, error) {126
if err := os.MkdirAll(s.Dir, 0o750); err != nil {127
return Archive{}, nil, err128
}129
var removed []string130
for {131
free, err := s.free()132
if err != nil || free >= uint64(needBytes)+minFree {133
break134
}135
// Het nieuwe archief wordt het nieuwste; daarvoor mag ook het136
// laatste oude weg. De draaiende kopie blijft altijd staan.137
name, ok, err := s.removeOldest(0)138
if err != nil {139
return Archive{}, removed, err140
}141
if !ok {142
return Archive{}, removed, fmt.Errorf("te weinig schijfruimte voor een archief (%d MB vrij, %d MB nodig)", free>>20, (uint64(needBytes)+minFree)>>20)143
}144
removed = append(removed, name)145
}146
base := "bluegit-" + now.UTC().Format("20060102-150405")147
name := base + ".tar.gz"148
for i := 1; ; i++ {149
if _, err := os.Stat(filepath.Join(s.Dir, name)); errors.Is(err, os.ErrNotExist) {150
break151
}152
name = fmt.Sprintf("%s-%d.tar.gz", base, i)153
}154
tmp := filepath.Join(s.Dir, "."+name+".partial")155
f, err := os.OpenFile(tmp, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0o640)156
if err != nil {157
return Archive{}, removed, err158
}159
if err := WriteTarGz(f, mirrorDir); err != nil {160
f.Close()161
os.Remove(tmp)162
return Archive{}, removed, err163
}164
if err := f.Sync(); err != nil {165
f.Close()166
os.Remove(tmp)167
return Archive{}, removed, err168
}169
if err := f.Close(); err != nil {170
os.Remove(tmp)171
return Archive{}, removed, err172
}173
final := filepath.Join(s.Dir, name)174
if err := os.Rename(tmp, final); err != nil {175
os.Remove(tmp)176
return Archive{}, removed, err177
}178
_ = os.Chtimes(final, now, now)179
fi, _ := os.Stat(final)180
return Archive{Name: name, CreatedAt: now.UTC(), Size: fi.Size()}, removed, nil181
}182
183
// removeOldest verwijdert het oudste archief zolang er meer dan keep zijn.184
func (s *Store) removeOldest(keep int) (string, bool, error) {185
list, err := s.List()186
if err != nil {187
return "", false, err188
}189
if len(list) <= keep {190
return "", false, nil191
}192
old := list[len(list)-1]193
if err := os.Remove(filepath.Join(s.Dir, old.Name)); err != nil {194
return "", false, err195
}196
return old.Name, true, nil197
}198
199
// Prune verwijdert archieven ouder dan retentionDays (0 = niet op leeftijd)200
// en daarna de oudste zolang er minder dan minFree bytes vrij is. Het201
// nieuwste archief blijft altijd staan.202
func (s *Store) Prune(now time.Time, retentionDays int, minFree uint64) ([]string, error) {203
var removed []string204
list, err := s.List()205
if err != nil {206
return nil, err207
}208
if retentionDays > 0 {209
cut := now.Add(-time.Duration(retentionDays) * 24 * time.Hour)210
for i, a := range list {211
if i == 0 || !a.CreatedAt.Before(cut) {212
continue213
}214
if err := os.Remove(filepath.Join(s.Dir, a.Name)); err != nil {215
return removed, err216
}217
removed = append(removed, a.Name)218
}219
}220
for {221
free, err := s.free()222
if err != nil || free >= minFree {223
break224
}225
name, ok, err := s.removeOldest(1)226
if err != nil {227
return removed, err228
}229
if !ok {230
break231
}232
removed = append(removed, name)233
}234
return removed, nil235
}236
237
// WriteTarGz schrijft dir als tar.gz met logische paden naar w.238
func WriteTarGz(w io.Writer, dir string) error {239
gz, _ := gzip.NewWriterLevel(w, gzip.DefaultCompression)240
tw := tar.NewWriter(gz)241
var paths []string242
err := filepath.WalkDir(dir, func(p string, d fs.DirEntry, err error) error {243
if err != nil {244
if errors.Is(err, fs.ErrNotExist) && p == dir {245
return fs.SkipDir246
}247
return err248
}249
if d.Type().IsRegular() {250
paths = append(paths, p)251
}252
return nil253
})254
if err != nil {255
return err256
}257
sort.Strings(paths)258
for _, p := range paths {259
rel, _ := filepath.Rel(dir, p)260
logical := filepath.ToSlash(rel)261
if _, ok := protocol.CleanLogical(logical); !ok {262
continue263
}264
if err := addFile(tw, p, logical); err != nil {265
return err266
}267
}268
if err := tw.Close(); err != nil {269
return err270
}271
return gz.Close()272
}273
274
func addFile(tw *tar.Writer, p, logical string) error {275
f, err := os.Open(p)276
if err != nil {277
return err278
}279
defer f.Close()280
fi, err := f.Stat()281
if err != nil {282
return err283
}284
h := &tar.Header{285
Name: logical, Mode: int64(fi.Mode().Perm()), Size: fi.Size(), Typeflag: tar.TypeReg,286
ModTime: fi.ModTime(), Format: tar.FormatPAX,287
}288
if err := tw.WriteHeader(h); err != nil {289
return err290
}291
_, err = io.CopyN(tw, f, fi.Size())292
return err293
}294
295
// Extract pakt archief src uit in dst (dat nog niet mag bestaan). Alleen296
// gewone bestanden met geldige logische paden.297
func Extract(src, dst string) error {298
f, err := os.Open(src)299
if err != nil {300
return err301
}302
defer f.Close()303
return ExtractReader(f, dst)304
}305
306
// ExtractReader is Extract vanaf een stroom.307
func ExtractReader(r io.Reader, dst string) error {308
if err := os.MkdirAll(dst, 0o750); err != nil {309
return err310
}311
gz, err := gzip.NewReader(r)312
if err != nil {313
return err314
}315
tr := tar.NewReader(gz)316
for {317
h, err := tr.Next()318
if err == io.EOF {319
return nil320
}321
if err != nil {322
return err323
}324
if h.Typeflag == tar.TypeDir {325
continue326
}327
logical, ok := protocol.CleanLogical(strings.TrimPrefix(h.Name, "./"))328
if h.Typeflag != tar.TypeReg || !ok {329
return fmt.Errorf("ongeldig item in archief: %q", h.Name)330
}331
out := filepath.Join(dst, filepath.FromSlash(logical))332
if err := os.MkdirAll(filepath.Dir(out), 0o750); err != nil {333
return err334
}335
mode := os.FileMode(h.Mode).Perm()&0o755 | 0o600336
w, err := os.OpenFile(out, os.O_CREATE|os.O_EXCL|os.O_WRONLY, mode)337
if err != nil {338
return err339
}340
if _, err := io.Copy(w, tr); err != nil {341
w.Close()342
return err343
}344
if err := w.Close(); err != nil {345
return err346
}347
_ = os.Chtimes(out, h.ModTime, h.ModTime)348
}349
}@@ -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,154 @@
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:8080"
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.FullSyncInterval.Duration < time.Second || c.MinSyncInterval.Duration < 0 {
110
return fmt.Errorf("full_sync_interval moet minstens 1s zijn")
111
}
112
if c.PublicURL != "" && !strings.HasPrefix(c.PublicURL, "http://") && !strings.HasPrefix(c.PublicURL, "https://") {
113
return fmt.Errorf("public_url moet met http:// of https:// beginnen")
114
}
115
return nil
116
}
117
118
// Load leest path. Een ontbrekend bestand geeft de standaardwaarden.
119
func Load(path string) (Config, error) {
120
var c Config
121
b, err := os.ReadFile(path)
122
if err != nil && !os.IsNotExist(err) {
123
return c, err
124
}
125
if err == nil {
126
if err := yaml.Unmarshal(b, &c); err != nil {
127
return c, fmt.Errorf("%s: %w", path, err)
128
}
129
}
130
c.Defaults()
131
return c, c.Validate()
132
}
133
134
// Example is een voorbeeldconfiguratie.
135
func Example() string {
136
return `# bluegit-backup. Kopieer naar /etc/bluegit-backup/config.yml.
137
listen: 0.0.0.0:8080
138
# Waar BlueGit deze server bereikt (meldingen, archieflijst, rollback).
139
public_url: http://backup.lan:8080
140
data_dir: /var/lib/bluegit-backup
141
# Zo vaak wordt de hele kopie gecomprimeerd opgeslagen. Standaard dagelijks.
142
archive_interval: 24h
143
# Archieven ouder dan dit gaan weg (0 = nooit op leeftijd). Het nieuwste blijft.
144
retention_days: 30
145
# Minder vrije ruimte dan dit: het oudste archief gaat weg.
146
min_free_mb: 1024
147
# Downloadsnelheid van BlueGit in KiB/s, zodat BlueGit er geen last van heeft.
148
rate_limit_kib: 1024
149
# Ook zonder melding zo vaak alles nalopen.
150
full_sync_interval: 1h
151
# Minimale tijd tussen twee syncs na meldingen.
152
min_sync_interval: 10s
153
`
154
}
@@ -0,0 +1,154 @@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:8080"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.FullSyncInterval.Duration < time.Second || c.MinSyncInterval.Duration < 0 {110
return fmt.Errorf("full_sync_interval moet minstens 1s zijn")111
}112
if c.PublicURL != "" && !strings.HasPrefix(c.PublicURL, "http://") && !strings.HasPrefix(c.PublicURL, "https://") {113
return fmt.Errorf("public_url moet met http:// of https:// beginnen")114
}115
return nil116
}117
118
// Load leest path. Een ontbrekend bestand geeft de standaardwaarden.119
func Load(path string) (Config, error) {120
var c Config121
b, err := os.ReadFile(path)122
if err != nil && !os.IsNotExist(err) {123
return c, err124
}125
if err == nil {126
if err := yaml.Unmarshal(b, &c); err != nil {127
return c, fmt.Errorf("%s: %w", path, err)128
}129
}130
c.Defaults()131
return c, c.Validate()132
}133
134
// Example is een voorbeeldconfiguratie.135
func Example() string {136
return `# bluegit-backup. Kopieer naar /etc/bluegit-backup/config.yml.137
listen: 0.0.0.0:8080138
# Waar BlueGit deze server bereikt (meldingen, archieflijst, rollback).139
public_url: http://backup.lan:8080140
data_dir: /var/lib/bluegit-backup141
# Zo vaak wordt de hele kopie gecomprimeerd opgeslagen. Standaard dagelijks.142
archive_interval: 24h143
# Archieven ouder dan dit gaan weg (0 = nooit op leeftijd). Het nieuwste blijft.144
retention_days: 30145
# Minder vrije ruimte dan dit: het oudste archief gaat weg.146
min_free_mb: 1024147
# Downloadsnelheid van BlueGit in KiB/s, zodat BlueGit er geen last van heeft.148
rate_limit_kib: 1024149
# Ook zonder melding zo vaak alles nalopen.150
full_sync_interval: 1h151
# Minimale tijd tussen twee syncs na meldingen.152
min_sync_interval: 10s153
`154
}@@ -0,0 +1,95 @@
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:8080" {
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
}
45
46
func TestFieldsRoundTrip(t *testing.T) {
47
var c Config
48
c.Defaults()
49
for _, f := range Fields {
50
v := c.Get(f.Key)
51
if f.Key != "public_url" && v == "" {
52
t.Errorf("%s: leeg", f.Key)
53
}
54
if err := c.Set(f.Key, v); err != nil && f.Key != "public_url" {
55
t.Errorf("%s=%q: %v", f.Key, v, err)
56
}
57
if got := c.Get(f.Key); got != v {
58
t.Errorf("%s: %q != %q", f.Key, got, v)
59
}
60
}
61
if c.Listen != "0.0.0.0:8080" {
62
t.Fatalf("standaardpoort %s", c.Listen)
63
}
64
}
65
66
func TestApplyIsAtomic(t *testing.T) {
67
var c Config
68
c.Defaults()
69
if err := c.Apply(map[string]string{"retention_days": "7", "archive_interval": "nee"}); err == nil {
70
t.Fatal("fout verwacht")
71
}
72
if c.RetentionDays != 30 {
73
t.Fatal("half toegepast")
74
}
75
if err := c.Apply(map[string]string{"retention_days": "7", "archive_interval": "7d", "public_url": "http://b:8080/"}); err != nil {
76
t.Fatal(err)
77
}
78
if c.RetentionDays != 7 || c.ArchiveInterval.Duration != 7*24*time.Hour || c.PublicURL != "http://b:8080" {
79
t.Fatalf("%+v", c)
80
}
81
if err := c.Apply(map[string]string{"data_dir": "/tmp"}); err == nil {
82
t.Fatal("data_dir mag niet")
83
}
84
}
85
86
func TestSettingsFile(t *testing.T) {
87
d := t.TempDir()
88
if err := SaveSettings(d, map[string]string{"retention_days": "3"}); err != nil {
89
t.Fatal(err)
90
}
91
m, err := LoadSettings(d)
92
if err != nil || m["retention_days"] != "3" {
93
t.Fatal(m, err)
94
}
95
}
@@ -0,0 +1,95 @@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:8080" {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
}45
46
func TestFieldsRoundTrip(t *testing.T) {47
var c Config48
c.Defaults()49
for _, f := range Fields {50
v := c.Get(f.Key)51
if f.Key != "public_url" && v == "" {52
t.Errorf("%s: leeg", f.Key)53
}54
if err := c.Set(f.Key, v); err != nil && f.Key != "public_url" {55
t.Errorf("%s=%q: %v", f.Key, v, err)56
}57
if got := c.Get(f.Key); got != v {58
t.Errorf("%s: %q != %q", f.Key, got, v)59
}60
}61
if c.Listen != "0.0.0.0:8080" {62
t.Fatalf("standaardpoort %s", c.Listen)63
}64
}65
66
func TestApplyIsAtomic(t *testing.T) {67
var c Config68
c.Defaults()69
if err := c.Apply(map[string]string{"retention_days": "7", "archive_interval": "nee"}); err == nil {70
t.Fatal("fout verwacht")71
}72
if c.RetentionDays != 30 {73
t.Fatal("half toegepast")74
}75
if err := c.Apply(map[string]string{"retention_days": "7", "archive_interval": "7d", "public_url": "http://b:8080/"}); err != nil {76
t.Fatal(err)77
}78
if c.RetentionDays != 7 || c.ArchiveInterval.Duration != 7*24*time.Hour || c.PublicURL != "http://b:8080" {79
t.Fatalf("%+v", c)80
}81
if err := c.Apply(map[string]string{"data_dir": "/tmp"}); err == nil {82
t.Fatal("data_dir mag niet")83
}84
}85
86
func TestSettingsFile(t *testing.T) {87
d := t.TempDir()88
if err := SaveSettings(d, map[string]string{"retention_days": "3"}); err != nil {89
t.Fatal(err)90
}91
m, err := LoadSettings(d)92
if err != nil || m["retention_days"] != "3" {93
t.Fatal(m, err)94
}95
}@@ -0,0 +1,211 @@
1
package config
2
3
import (
4
"errors"
5
"fmt"
6
"net"
7
"os"
8
"path/filepath"
9
"sort"
10
"strconv"
11
"strings"
12
"time"
13
14
"gopkg.in/yaml.v3"
15
)
16
17
// Field beschrijft één instelling die de webinterface, de API en BlueGit
18
// kunnen lezen en wijzigen. Alles wat in Fields staat, is overal hetzelfde
19
// instelbaar.
20
type Field struct {
21
Key string `json:"key"`
22
Label string `json:"label"`
23
Help string `json:"help"`
24
// Kind is duration, int of text.
25
Kind string `json:"kind"`
26
// Restart: pas na een herstart van kracht.
27
Restart bool `json:"restart,omitempty"`
28
}
29
30
// Fields zijn de instelbare velden, in de volgorde van de webinterface.
31
var Fields = []Field{
32
{Key: "public_url", Label: "Publiek adres", Help: "Waar BlueGit deze server bereikt, bijvoorbeeld http://backup.lan:8080.", Kind: "text"},
33
{Key: "archive_interval", Label: "Archiefinterval", Help: "Zo vaak wordt de hele kopie gecomprimeerd opgeslagen (bijvoorbeeld 24h, 12h, 7d).", Kind: "duration"},
34
{Key: "retention_days", Label: "Bewaartermijn (dagen)", Help: "Archieven ouder dan dit gaan weg. 0 = nooit op leeftijd. Het nieuwste blijft altijd staan.", Kind: "int"},
35
{Key: "min_free_mb", Label: "Minimaal vrij (MB)", Help: "Minder vrije schijfruimte dan dit: het oudste archief gaat weg.", Kind: "int"},
36
{Key: "rate_limit_kib", Label: "Downloadsnelheid (KiB/s)", Help: "Zo snel wordt BlueGit hoogstens gelezen. 0 = onbeperkt.", Kind: "int"},
37
{Key: "full_sync_interval", Label: "Volledige controle", Help: "Ook zonder melding zo vaak alles nalopen.", Kind: "duration"},
38
{Key: "min_sync_interval", Label: "Minimale tijd tussen syncs", Help: "Na een melding wacht de server minstens zo lang sinds de vorige sync.", Kind: "duration"},
39
{Key: "listen", Label: "Luisteradres", Help: "Adres en poort van de webinterface en API. Geldt na een herstart.", Kind: "text", Restart: true},
40
}
41
42
// FieldByKey zoekt een veld.
43
func FieldByKey(key string) (Field, bool) {
44
for _, f := range Fields {
45
if f.Key == key {
46
return f, true
47
}
48
}
49
return Field{}, false
50
}
51
52
// Get geeft de waarde van key als tekst.
53
func (c Config) Get(key string) string {
54
switch key {
55
case "listen":
56
return c.Listen
57
case "public_url":
58
return c.PublicURL
59
case "data_dir":
60
return c.DataDir
61
case "archive_interval":
62
return FormatDuration(c.ArchiveInterval.Duration)
63
case "retention_days":
64
return strconv.Itoa(c.RetentionDays)
65
case "min_free_mb":
66
return strconv.FormatInt(c.MinFreeMB, 10)
67
case "rate_limit_kib":
68
return strconv.FormatInt(c.RateLimitKiB, 10)
69
case "full_sync_interval":
70
return FormatDuration(c.FullSyncInterval.Duration)
71
case "min_sync_interval":
72
return FormatDuration(c.MinSyncInterval.Duration)
73
}
74
return ""
75
}
76
77
// FormatDuration schrijft 24h als "24h" en 30m als "30m".
78
func FormatDuration(d time.Duration) string {
79
if d%(24*time.Hour) == 0 && d >= 48*time.Hour {
80
return fmt.Sprintf("%dd", d/(24*time.Hour))
81
}
82
switch {
83
case d == 0:
84
return "0s"
85
case d%time.Hour == 0:
86
return fmt.Sprintf("%dh", d/time.Hour)
87
case d%time.Minute == 0:
88
return fmt.Sprintf("%dm", d/time.Minute)
89
case d%time.Second == 0:
90
return fmt.Sprintf("%ds", d/time.Second)
91
}
92
return d.String()
93
}
94
95
// ParseDuration leest een Go-duur of een aantal dagen ("7d").
96
func ParseDuration(s string) (time.Duration, error) {
97
s = strings.TrimSpace(s)
98
if strings.HasSuffix(s, "d") {
99
n, err := strconv.Atoi(strings.TrimSuffix(s, "d"))
100
if err == nil && n >= 0 {
101
return time.Duration(n) * 24 * time.Hour, nil
102
}
103
}
104
d, err := time.ParseDuration(s)
105
if err != nil {
106
return 0, fmt.Errorf("ongeldige duur %q", s)
107
}
108
return d, nil
109
}
110
111
// Set zet key op val. Alleen velden uit Fields.
112
func (c *Config) Set(key, val string) error {
113
f, ok := FieldByKey(key)
114
if !ok {
115
return fmt.Errorf("onbekende instelling %q", key)
116
}
117
val = strings.TrimSpace(val)
118
switch f.Kind {
119
case "duration":
120
d, err := ParseDuration(val)
121
if err != nil {
122
return fmt.Errorf("%s: %w", key, err)
123
}
124
switch key {
125
case "archive_interval":
126
c.ArchiveInterval.Duration = d
127
case "full_sync_interval":
128
c.FullSyncInterval.Duration = d
129
case "min_sync_interval":
130
c.MinSyncInterval.Duration = d
131
}
132
case "int":
133
n, err := strconv.ParseInt(val, 10, 64)
134
if err != nil || n < 0 {
135
return fmt.Errorf("%s: geef een geheel getal van 0 of meer", key)
136
}
137
switch key {
138
case "retention_days":
139
c.RetentionDays = int(n)
140
case "min_free_mb":
141
c.MinFreeMB = n
142
case "rate_limit_kib":
143
c.RateLimitKiB = n
144
}
145
default:
146
switch key {
147
case "public_url":
148
c.PublicURL = strings.TrimRight(val, "/")
149
case "listen":
150
if _, _, err := net.SplitHostPort(val); err != nil {
151
return fmt.Errorf("listen: verwacht host:poort, bijvoorbeeld 0.0.0.0:8080")
152
}
153
c.Listen = val
154
}
155
}
156
return nil
157
}
158
159
// Apply zet een reeks instellingen in één keer. Bij een fout verandert er niets.
160
func (c *Config) Apply(set map[string]string) error {
161
next := *c
162
keys := make([]string, 0, len(set))
163
for k := range set {
164
keys = append(keys, k)
165
}
166
sort.Strings(keys)
167
for _, k := range keys {
168
if err := next.Set(k, set[k]); err != nil {
169
return err
170
}
171
}
172
if err := next.Validate(); err != nil {
173
return err
174
}
175
*c = next
176
return nil
177
}
178
179
// SettingsFile bewaart wat via de webinterface, API of BlueGit is ingesteld.
180
// Het gaat boven config.yml, zodat config.yml van root mag blijven.
181
const SettingsFile = "settings.yml"
182
183
// LoadSettings leest data_dir/settings.yml (ontbreekt: leeg).
184
func LoadSettings(dataDir string) (map[string]string, error) {
185
out := map[string]string{}
186
b, err := os.ReadFile(filepath.Join(dataDir, SettingsFile))
187
if errors.Is(err, os.ErrNotExist) {
188
return out, nil
189
}
190
if err != nil {
191
return nil, err
192
}
193
if err := yaml.Unmarshal(b, &out); err != nil {
194
return nil, fmt.Errorf("%s: %w", SettingsFile, err)
195
}
196
return out, nil
197
}
198
199
// SaveSettings schrijft data_dir/settings.yml.
200
func SaveSettings(dataDir string, set map[string]string) error {
201
b, err := yaml.Marshal(set)
202
if err != nil {
203
return err
204
}
205
b = append([]byte("# Door de webinterface, API of BlueGit ingesteld. Gaat boven config.yml.\n"), b...)
206
tmp := filepath.Join(dataDir, SettingsFile+".tmp")
207
if err := os.WriteFile(tmp, b, 0o600); err != nil {
208
return err
209
}
210
return os.Rename(tmp, filepath.Join(dataDir, SettingsFile))
211
}
@@ -0,0 +1,211 @@1
package config2
3
import (4
"errors"5
"fmt"6
"net"7
"os"8
"path/filepath"9
"sort"10
"strconv"11
"strings"12
"time"13
14
"gopkg.in/yaml.v3"15
)16
17
// Field beschrijft één instelling die de webinterface, de API en BlueGit18
// kunnen lezen en wijzigen. Alles wat in Fields staat, is overal hetzelfde19
// instelbaar.20
type Field struct {21
Key string `json:"key"`22
Label string `json:"label"`23
Help string `json:"help"`24
// Kind is duration, int of text.25
Kind string `json:"kind"`26
// Restart: pas na een herstart van kracht.27
Restart bool `json:"restart,omitempty"`28
}29
30
// Fields zijn de instelbare velden, in de volgorde van de webinterface.31
var Fields = []Field{32
{Key: "public_url", Label: "Publiek adres", Help: "Waar BlueGit deze server bereikt, bijvoorbeeld http://backup.lan:8080.", Kind: "text"},33
{Key: "archive_interval", Label: "Archiefinterval", Help: "Zo vaak wordt de hele kopie gecomprimeerd opgeslagen (bijvoorbeeld 24h, 12h, 7d).", Kind: "duration"},34
{Key: "retention_days", Label: "Bewaartermijn (dagen)", Help: "Archieven ouder dan dit gaan weg. 0 = nooit op leeftijd. Het nieuwste blijft altijd staan.", Kind: "int"},35
{Key: "min_free_mb", Label: "Minimaal vrij (MB)", Help: "Minder vrije schijfruimte dan dit: het oudste archief gaat weg.", Kind: "int"},36
{Key: "rate_limit_kib", Label: "Downloadsnelheid (KiB/s)", Help: "Zo snel wordt BlueGit hoogstens gelezen. 0 = onbeperkt.", Kind: "int"},37
{Key: "full_sync_interval", Label: "Volledige controle", Help: "Ook zonder melding zo vaak alles nalopen.", Kind: "duration"},38
{Key: "min_sync_interval", Label: "Minimale tijd tussen syncs", Help: "Na een melding wacht de server minstens zo lang sinds de vorige sync.", Kind: "duration"},39
{Key: "listen", Label: "Luisteradres", Help: "Adres en poort van de webinterface en API. Geldt na een herstart.", Kind: "text", Restart: true},40
}41
42
// FieldByKey zoekt een veld.43
func FieldByKey(key string) (Field, bool) {44
for _, f := range Fields {45
if f.Key == key {46
return f, true47
}48
}49
return Field{}, false50
}51
52
// Get geeft de waarde van key als tekst.53
func (c Config) Get(key string) string {54
switch key {55
case "listen":56
return c.Listen57
case "public_url":58
return c.PublicURL59
case "data_dir":60
return c.DataDir61
case "archive_interval":62
return FormatDuration(c.ArchiveInterval.Duration)63
case "retention_days":64
return strconv.Itoa(c.RetentionDays)65
case "min_free_mb":66
return strconv.FormatInt(c.MinFreeMB, 10)67
case "rate_limit_kib":68
return strconv.FormatInt(c.RateLimitKiB, 10)69
case "full_sync_interval":70
return FormatDuration(c.FullSyncInterval.Duration)71
case "min_sync_interval":72
return FormatDuration(c.MinSyncInterval.Duration)73
}74
return ""75
}76
77
// FormatDuration schrijft 24h als "24h" en 30m als "30m".78
func FormatDuration(d time.Duration) string {79
if d%(24*time.Hour) == 0 && d >= 48*time.Hour {80
return fmt.Sprintf("%dd", d/(24*time.Hour))81
}82
switch {83
case d == 0:84
return "0s"85
case d%time.Hour == 0:86
return fmt.Sprintf("%dh", d/time.Hour)87
case d%time.Minute == 0:88
return fmt.Sprintf("%dm", d/time.Minute)89
case d%time.Second == 0:90
return fmt.Sprintf("%ds", d/time.Second)91
}92
return d.String()93
}94
95
// ParseDuration leest een Go-duur of een aantal dagen ("7d").96
func ParseDuration(s string) (time.Duration, error) {97
s = strings.TrimSpace(s)98
if strings.HasSuffix(s, "d") {99
n, err := strconv.Atoi(strings.TrimSuffix(s, "d"))100
if err == nil && n >= 0 {101
return time.Duration(n) * 24 * time.Hour, nil102
}103
}104
d, err := time.ParseDuration(s)105
if err != nil {106
return 0, fmt.Errorf("ongeldige duur %q", s)107
}108
return d, nil109
}110
111
// Set zet key op val. Alleen velden uit Fields.112
func (c *Config) Set(key, val string) error {113
f, ok := FieldByKey(key)114
if !ok {115
return fmt.Errorf("onbekende instelling %q", key)116
}117
val = strings.TrimSpace(val)118
switch f.Kind {119
case "duration":120
d, err := ParseDuration(val)121
if err != nil {122
return fmt.Errorf("%s: %w", key, err)123
}124
switch key {125
case "archive_interval":126
c.ArchiveInterval.Duration = d127
case "full_sync_interval":128
c.FullSyncInterval.Duration = d129
case "min_sync_interval":130
c.MinSyncInterval.Duration = d131
}132
case "int":133
n, err := strconv.ParseInt(val, 10, 64)134
if err != nil || n < 0 {135
return fmt.Errorf("%s: geef een geheel getal van 0 of meer", key)136
}137
switch key {138
case "retention_days":139
c.RetentionDays = int(n)140
case "min_free_mb":141
c.MinFreeMB = n142
case "rate_limit_kib":143
c.RateLimitKiB = n144
}145
default:146
switch key {147
case "public_url":148
c.PublicURL = strings.TrimRight(val, "/")149
case "listen":150
if _, _, err := net.SplitHostPort(val); err != nil {151
return fmt.Errorf("listen: verwacht host:poort, bijvoorbeeld 0.0.0.0:8080")152
}153
c.Listen = val154
}155
}156
return nil157
}158
159
// Apply zet een reeks instellingen in één keer. Bij een fout verandert er niets.160
func (c *Config) Apply(set map[string]string) error {161
next := *c162
keys := make([]string, 0, len(set))163
for k := range set {164
keys = append(keys, k)165
}166
sort.Strings(keys)167
for _, k := range keys {168
if err := next.Set(k, set[k]); err != nil {169
return err170
}171
}172
if err := next.Validate(); err != nil {173
return err174
}175
*c = next176
return nil177
}178
179
// SettingsFile bewaart wat via de webinterface, API of BlueGit is ingesteld.180
// Het gaat boven config.yml, zodat config.yml van root mag blijven.181
const SettingsFile = "settings.yml"182
183
// LoadSettings leest data_dir/settings.yml (ontbreekt: leeg).184
func LoadSettings(dataDir string) (map[string]string, error) {185
out := map[string]string{}186
b, err := os.ReadFile(filepath.Join(dataDir, SettingsFile))187
if errors.Is(err, os.ErrNotExist) {188
return out, nil189
}190
if err != nil {191
return nil, err192
}193
if err := yaml.Unmarshal(b, &out); err != nil {194
return nil, fmt.Errorf("%s: %w", SettingsFile, err)195
}196
return out, nil197
}198
199
// SaveSettings schrijft data_dir/settings.yml.200
func SaveSettings(dataDir string, set map[string]string) error {201
b, err := yaml.Marshal(set)202
if err != nil {203
return err204
}205
b = append([]byte("# Door de webinterface, API of BlueGit ingesteld. Gaat boven config.yml.\n"), b...)206
tmp := filepath.Join(dataDir, SettingsFile+".tmp")207
if err := os.WriteFile(tmp, b, 0o600); err != nil {208
return err209
}210
return os.Rename(tmp, filepath.Join(dataDir, SettingsFile))211
}@@ -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.RotateKey()
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/s/" + g.Server)
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.Action(g.Server, "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/s/" + g.Server)
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/s/"+g.Server+"/act/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.RotateKey()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/s/" + g.Server)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.Action(g.Server, "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/s/" + g.Server)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/s/"+g.Server+"/act/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,147 @@
1
//go:build integration
2
3
package integration
4
5
import (
6
"net/http"
7
"strings"
8
"testing"
9
"time"
10
11
"git.timfalken.com/timfa/bluegit-backup/internal/protocol"
12
"git.timfalken.com/timfa/bluegit-backup/internal/server"
13
)
14
15
// setBackupProtocol bootst een andere versie van de backup server na (die
16
// draait in dit testproces). Terugzetten gebeurt aan het eind van de test.
17
func setBackupProtocol(t *testing.T, proto, min string) (restore func()) {
18
oldP, oldM := protocol.ProtocolVersion, protocol.MinBlueGitProtocol
19
protocol.ProtocolVersion, protocol.MinBlueGitProtocol = proto, min
20
restore = func() { protocol.ProtocolVersion, protocol.MinBlueGitProtocol = oldP, oldM }
21
t.Cleanup(restore)
22
return restore
23
}
24
25
// bannerPages zijn pagina's van verschillende soorten; de banner hoort op elk.
26
var bannerPages = []string{"/", "/users/tim", "/tim/alpha", "/admin", "/admin/backup", "/-/info", "/help"}
27
28
func requireBanner(t *testing.T, g *BlueGit, hc *http.Client, name string, want ...string) {
29
t.Helper()
30
for _, p := range bannerPages {
31
html := g.Page(hc, p)
32
if !strings.Contains(html, `class="compat-banner"`) || !strings.Contains(html, name) || !strings.Contains(html, `href="/admin/backup"`) {
33
t.Fatalf("%s: geen banner voor %q:\n%s", p, name, tail(html, 30))
34
}
35
for _, w := range want {
36
if !strings.Contains(html, w) {
37
t.Fatalf("%s: banner mist %q", p, w)
38
}
39
}
40
}
41
}
42
43
// Feature: een backup server die een nieuwer protocol vraagt dan BlueGit
44
// spreekt ("BlueGit te oud"). De backup server weigert te synchroniseren en
45
// terug te zetten en meldt het in zijn UI en API; BlueGit toont beheerders op
46
// elke pagina een banner. Na de update (hier: terug naar protocol 1) is
47
// alles weer normaal.
48
func TestCompatBlueGitTooOld(t *testing.T) {
49
g := startBlueGit(t)
50
g.Project("Alpha", "README.md", "v1")
51
b := startBackup(t, nil)
52
id, key := g.AddServer("nas")
53
b.Connect(g, key)
54
b.Sync()
55
arch := b.Archive()
56
if st := g.ServerStatus(id); st.Compat != "ok" || st.Protocol.Backup != 1 || st.Protocol.BlueGit != 1 {
57
t.Fatalf("begin: %+v", st)
58
}
59
60
// De backup server wordt "geüpdatet" naar protocol 2 en vraagt BlueGit ≥ 2.
61
restore := setBackupProtocol(t, "2", "2")
62
code, raw := b.Admin("POST", "/sync", nil)
63
if code != http.StatusConflict || !strings.Contains(string(raw), "BlueGit is verouderd") {
64
t.Fatalf("sync bij te oude BlueGit: %d %s", code, raw)
65
}
66
st := b.Status()
67
if st.Compat != "bluegit_too_old" || st.BlueGitProtocol != 1 || !strings.Contains(st.CompatMessage, "Update BlueGit") {
68
t.Fatalf("status: %+v", st)
69
}
70
if html := openUI(t, b).Page(); !strings.Contains(html, `class="compat-banner"`) || !strings.Contains(html, "Update BlueGit") {
71
t.Fatalf("backup-UI zonder waarschuwing:\n%s", tail(html, 40))
72
}
73
// BlueGit hoort het protocol in het antwoord van de backup server.
74
if st := g.ServerStatus(id); st.Compat != "bluegit_too_old" || st.Protocol.Backup != 2 || st.Protocol.BackupMin != 2 {
75
t.Fatalf("BlueGit: %+v", st)
76
}
77
// Terugzetten weigert de backup server; BlueGit blijft ongemoeid.
78
g.Commit("alpha", "na.txt", "x", "create")
79
if code, raw := g.Action(id, "rollback", map[string]any{"archive": arch, "confirm": arch}); code < 400 || !strings.Contains(string(raw), "verouderd") {
80
t.Fatalf("rollback bij te oude BlueGit: %d %s", code, raw)
81
}
82
if code, _ := g.File("alpha", "na.txt"); code != 200 {
83
t.Fatal("BlueGit is toch teruggezet")
84
}
85
requireBanner(t, g, g.Session(), "nas", "BlueGit is out of date", "Update BlueGit")
86
87
// "BlueGit geüpdatet" (hier: de backup server weer op protocol 1).
88
restore()
89
b.Sync()
90
if st := b.Status(); st.Compat != "ok" || st.CompatMessage != "" {
91
t.Fatalf("na update: %+v", st)
92
}
93
Eventually(t, 10*time.Second, "BlueGit ziet weer protocol 1", func() bool { return g.ServerStatus(id).Compat == "ok" })
94
if strings.Contains(g.Page(g.Session(), "/"), "compat-banner") {
95
t.Fatal("banner blijft na de update")
96
}
97
}
98
99
// Feature: BlueGit vraagt een nieuwer protocol dan de backup server spreekt
100
// ("backup te oud"). Nagebootst met een test-build van BlueGit met protocol
101
// 99 (-ldflags -X, scripts/build-bluegit.sh). Koppelen lukt, zodat het
102
// zichtbaar wordt; BlueGit weigert gegevens (426), de backup server weigert
103
// te synchroniseren, beheerders zien de banner en andere gebruikers niet.
104
func TestCompatBackupTooOld(t *testing.T) {
105
g := startBlueGitBin(t, bluegitFutureBin(t))
106
g.Project("Alpha", "README.md", "v1")
107
b := startBackup(t, nil)
108
id, key := g.AddServer("offsite")
109
code, raw := b.Admin("POST", "/connect", server.ConnectRequest{URL: g.URL, Key: key})
110
if code != 200 || !strings.Contains(string(raw), "backup_too_old") || !strings.Contains(string(raw), "Update de backup server") {
111
t.Fatalf("koppelen: %d %s", code, raw)
112
}
113
code, raw = b.Admin("POST", "/sync", nil)
114
if code != http.StatusConflict || !strings.Contains(string(raw), "backup server is verouderd") {
115
t.Fatalf("sync: %d %s", code, raw)
116
}
117
if st := b.Status(); st.Compat != "backup_too_old" || st.BlueGitProtocol != FutureProtocol || st.BlueGitMinProtocol != FutureProtocol {
118
t.Fatalf("status: %+v", st)
119
}
120
// Een oude backup server zonder protocolkoppen krijgt van BlueGit 426.
121
req, _ := http.NewRequest("GET", g.URL+"/api/v1/backup/manifest", nil)
122
req.Header.Set("Authorization", "Bearer "+key)
123
res, err := http.DefaultClient.Do(req)
124
if err != nil {
125
t.Fatal(err)
126
}
127
res.Body.Close()
128
if res.StatusCode != http.StatusUpgradeRequired {
129
t.Fatalf("manifest zonder koppen: %d", res.StatusCode)
130
}
131
if st := g.ServerStatus(id); st.Compat != "backup_too_old" || st.Protocol.BlueGit != FutureProtocol {
132
t.Fatalf("BlueGit: %+v", st)
133
}
134
requireBanner(t, g, g.Session(), "offsite", "The backup server is out of date", "Update the backup server")
135
136
// Een gebruiker die geen beheerder is, ziet de banner niet.
137
g.RestartAs("bob", 2)
138
bob := g.Session()
139
for _, p := range []string{"/", "/users/bob", "/-/info", "/help"} {
140
if html := g.Page(bob, p); strings.Contains(html, "compat-banner") || strings.Contains(html, "offsite") {
141
t.Fatalf("%s: niet-beheerder ziet de banner", p)
142
}
143
}
144
if html := g.Page(bob, "/"); !strings.Contains(html, "bob") {
145
t.Fatalf("niet als bob aangemeld:\n%s", tail(html, 20))
146
}
147
}
@@ -0,0 +1,147 @@1
//go:build integration2
3
package integration4
5
import (6
"net/http"7
"strings"8
"testing"9
"time"10
11
"git.timfalken.com/timfa/bluegit-backup/internal/protocol"12
"git.timfalken.com/timfa/bluegit-backup/internal/server"13
)14
15
// setBackupProtocol bootst een andere versie van de backup server na (die16
// draait in dit testproces). Terugzetten gebeurt aan het eind van de test.17
func setBackupProtocol(t *testing.T, proto, min string) (restore func()) {18
oldP, oldM := protocol.ProtocolVersion, protocol.MinBlueGitProtocol19
protocol.ProtocolVersion, protocol.MinBlueGitProtocol = proto, min20
restore = func() { protocol.ProtocolVersion, protocol.MinBlueGitProtocol = oldP, oldM }21
t.Cleanup(restore)22
return restore23
}24
25
// bannerPages zijn pagina's van verschillende soorten; de banner hoort op elk.26
var bannerPages = []string{"/", "/users/tim", "/tim/alpha", "/admin", "/admin/backup", "/-/info", "/help"}27
28
func requireBanner(t *testing.T, g *BlueGit, hc *http.Client, name string, want ...string) {29
t.Helper()30
for _, p := range bannerPages {31
html := g.Page(hc, p)32
if !strings.Contains(html, `class="compat-banner"`) || !strings.Contains(html, name) || !strings.Contains(html, `href="/admin/backup"`) {33
t.Fatalf("%s: geen banner voor %q:\n%s", p, name, tail(html, 30))34
}35
for _, w := range want {36
if !strings.Contains(html, w) {37
t.Fatalf("%s: banner mist %q", p, w)38
}39
}40
}41
}42
43
// Feature: een backup server die een nieuwer protocol vraagt dan BlueGit44
// spreekt ("BlueGit te oud"). De backup server weigert te synchroniseren en45
// terug te zetten en meldt het in zijn UI en API; BlueGit toont beheerders op46
// elke pagina een banner. Na de update (hier: terug naar protocol 1) is47
// alles weer normaal.48
func TestCompatBlueGitTooOld(t *testing.T) {49
g := startBlueGit(t)50
g.Project("Alpha", "README.md", "v1")51
b := startBackup(t, nil)52
id, key := g.AddServer("nas")53
b.Connect(g, key)54
b.Sync()55
arch := b.Archive()56
if st := g.ServerStatus(id); st.Compat != "ok" || st.Protocol.Backup != 1 || st.Protocol.BlueGit != 1 {57
t.Fatalf("begin: %+v", st)58
}59
60
// De backup server wordt "geüpdatet" naar protocol 2 en vraagt BlueGit ≥ 2.61
restore := setBackupProtocol(t, "2", "2")62
code, raw := b.Admin("POST", "/sync", nil)63
if code != http.StatusConflict || !strings.Contains(string(raw), "BlueGit is verouderd") {64
t.Fatalf("sync bij te oude BlueGit: %d %s", code, raw)65
}66
st := b.Status()67
if st.Compat != "bluegit_too_old" || st.BlueGitProtocol != 1 || !strings.Contains(st.CompatMessage, "Update BlueGit") {68
t.Fatalf("status: %+v", st)69
}70
if html := openUI(t, b).Page(); !strings.Contains(html, `class="compat-banner"`) || !strings.Contains(html, "Update BlueGit") {71
t.Fatalf("backup-UI zonder waarschuwing:\n%s", tail(html, 40))72
}73
// BlueGit hoort het protocol in het antwoord van de backup server.74
if st := g.ServerStatus(id); st.Compat != "bluegit_too_old" || st.Protocol.Backup != 2 || st.Protocol.BackupMin != 2 {75
t.Fatalf("BlueGit: %+v", st)76
}77
// Terugzetten weigert de backup server; BlueGit blijft ongemoeid.78
g.Commit("alpha", "na.txt", "x", "create")79
if code, raw := g.Action(id, "rollback", map[string]any{"archive": arch, "confirm": arch}); code < 400 || !strings.Contains(string(raw), "verouderd") {80
t.Fatalf("rollback bij te oude BlueGit: %d %s", code, raw)81
}82
if code, _ := g.File("alpha", "na.txt"); code != 200 {83
t.Fatal("BlueGit is toch teruggezet")84
}85
requireBanner(t, g, g.Session(), "nas", "BlueGit is out of date", "Update BlueGit")86
87
// "BlueGit geüpdatet" (hier: de backup server weer op protocol 1).88
restore()89
b.Sync()90
if st := b.Status(); st.Compat != "ok" || st.CompatMessage != "" {91
t.Fatalf("na update: %+v", st)92
}93
Eventually(t, 10*time.Second, "BlueGit ziet weer protocol 1", func() bool { return g.ServerStatus(id).Compat == "ok" })94
if strings.Contains(g.Page(g.Session(), "/"), "compat-banner") {95
t.Fatal("banner blijft na de update")96
}97
}98
99
// Feature: BlueGit vraagt een nieuwer protocol dan de backup server spreekt100
// ("backup te oud"). Nagebootst met een test-build van BlueGit met protocol101
// 99 (-ldflags -X, scripts/build-bluegit.sh). Koppelen lukt, zodat het102
// zichtbaar wordt; BlueGit weigert gegevens (426), de backup server weigert103
// te synchroniseren, beheerders zien de banner en andere gebruikers niet.104
func TestCompatBackupTooOld(t *testing.T) {105
g := startBlueGitBin(t, bluegitFutureBin(t))106
g.Project("Alpha", "README.md", "v1")107
b := startBackup(t, nil)108
id, key := g.AddServer("offsite")109
code, raw := b.Admin("POST", "/connect", server.ConnectRequest{URL: g.URL, Key: key})110
if code != 200 || !strings.Contains(string(raw), "backup_too_old") || !strings.Contains(string(raw), "Update de backup server") {111
t.Fatalf("koppelen: %d %s", code, raw)112
}113
code, raw = b.Admin("POST", "/sync", nil)114
if code != http.StatusConflict || !strings.Contains(string(raw), "backup server is verouderd") {115
t.Fatalf("sync: %d %s", code, raw)116
}117
if st := b.Status(); st.Compat != "backup_too_old" || st.BlueGitProtocol != FutureProtocol || st.BlueGitMinProtocol != FutureProtocol {118
t.Fatalf("status: %+v", st)119
}120
// Een oude backup server zonder protocolkoppen krijgt van BlueGit 426.121
req, _ := http.NewRequest("GET", g.URL+"/api/v1/backup/manifest", nil)122
req.Header.Set("Authorization", "Bearer "+key)123
res, err := http.DefaultClient.Do(req)124
if err != nil {125
t.Fatal(err)126
}127
res.Body.Close()128
if res.StatusCode != http.StatusUpgradeRequired {129
t.Fatalf("manifest zonder koppen: %d", res.StatusCode)130
}131
if st := g.ServerStatus(id); st.Compat != "backup_too_old" || st.Protocol.BlueGit != FutureProtocol {132
t.Fatalf("BlueGit: %+v", st)133
}134
requireBanner(t, g, g.Session(), "offsite", "The backup server is out of date", "Update the backup server")135
136
// Een gebruiker die geen beheerder is, ziet de banner niet.137
g.RestartAs("bob", 2)138
bob := g.Session()139
for _, p := range []string{"/", "/users/bob", "/-/info", "/help"} {140
if html := g.Page(bob, p); strings.Contains(html, "compat-banner") || strings.Contains(html, "offsite") {141
t.Fatalf("%s: niet-beheerder ziet de banner", p)142
}143
}144
if html := g.Page(bob, "/"); !strings.Contains(html, "bob") {145
t.Fatalf("niet als bob aangemeld:\n%s", tail(html, 20))146
}147
}@@ -0,0 +1,613 @@
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
// Server is het id van de laatst toegevoegde backup server in BlueGit.
69
Server string
70
}
71
72
type syncBuf struct {
73
mu sync.Mutex
74
b bytes.Buffer
75
}
76
77
func (s *syncBuf) Write(p []byte) (int, error) {
78
s.mu.Lock()
79
defer s.mu.Unlock()
80
return s.b.Write(p)
81
}
82
83
func (s *syncBuf) String() string {
84
s.mu.Lock()
85
defer s.mu.Unlock()
86
return s.b.String()
87
}
88
89
func startBlueGit(t *testing.T) *BlueGit {
90
t.Helper()
91
return startBlueGitBin(t, bluegitBin(t))
92
}
93
94
// bluegitFutureBin is een test-build van dezelfde BlueGit met een hoger
95
// protocol (scripts/build-bluegit.sh bouwt hem naast BLUEGIT_BIN met
96
// -ldflags -X): protocol FutureProtocol, en hij ondersteunt alleen backup
97
// servers vanaf FutureProtocol.
98
func bluegitFutureBin(t *testing.T) string {
99
t.Helper()
100
bin := os.Getenv("BLUEGIT_FUTURE_BIN")
101
if bin == "" {
102
bin = filepath.Join(filepath.Dir(bluegitBin(t)), "bluegit-future")
103
}
104
if _, err := os.Stat(bin); err != nil {
105
t.Fatalf("test-build met hoger protocol ontbreekt (scripts/build-bluegit.sh): %v", err)
106
}
107
return bin
108
}
109
110
// FutureProtocol staat ook in scripts/build-bluegit.sh.
111
const FutureProtocol = 99
112
113
func startBlueGitBin(t *testing.T, bin string) *BlueGit {
114
t.Helper()
115
dir := t.TempDir()
116
port := freePort(t)
117
g := &BlueGit{t: t, Bin: bin, URL: fmt.Sprintf("http://127.0.0.1:%d", port),
118
State: filepath.Join(dir, "state"), Storage: filepath.Join(dir, "storage"), Config: filepath.Join(dir, "bluegit.yml"), log: &syncBuf{}}
119
_ = os.MkdirAll(g.Storage, 0o750)
120
cfg := fmt.Sprintf(`base_url: %s
121
listen: 127.0.0.1:%d
122
state_path: %s
123
storage_path: %s
124
auth:
125
mode: dev
126
dev_user: tim
127
dev_auth_id: 1
128
user_agent: bluegit-backup-it
129
git:
130
binary: git
131
default_branch: master
132
ssh:
133
enabled: false
134
ci:
135
enabled: false
136
`, g.URL, port, g.State, g.Storage)
137
if err := os.WriteFile(g.Config, []byte(cfg), 0o600); err != nil {
138
t.Fatal(err)
139
}
140
g.cmd = exec.Command(bin, "serve", "--config", g.Config)
141
g.cmd.Stdout, g.cmd.Stderr = g.log, g.log
142
if err := g.cmd.Start(); err != nil {
143
t.Fatal(err)
144
}
145
t.Cleanup(func() {
146
_ = g.cmd.Process.Kill()
147
_, _ = g.cmd.Process.Wait()
148
if t.Failed() {
149
t.Logf("BlueGit-log %s:\n%s", g.URL, tail(g.log.String(), 60))
150
}
151
})
152
g.WaitUp(20 * time.Second)
153
// Aanmelden maakt de eerste gebruiker (beheerder) aan.
154
jar, _ := cookiejar.New(nil)
155
hc := &http.Client{Jar: jar}
156
res, err := hc.Get(g.URL + "/login")
157
if err != nil {
158
t.Fatal(err)
159
}
160
res.Body.Close()
161
out, err := exec.Command(bin, "token", "create", "--config", g.Config, "--user", "tim", "--name", "it").CombinedOutput()
162
if err != nil {
163
t.Fatalf("token: %v %s", err, out)
164
}
165
g.Token = strings.TrimSpace(string(out))
166
return g
167
}
168
169
func tail(s string, n int) string {
170
lines := strings.Split(s, "\n")
171
if len(lines) > n {
172
lines = lines[len(lines)-n:]
173
}
174
return strings.Join(lines, "\n")
175
}
176
177
// RestartAs herstart dezelfde BlueGit (zelfde gegevens) met een andere
178
// dev-gebruiker. Zo is er een tweede gebruiker die geen beheerder is.
179
func (g *BlueGit) RestartAs(user string, authID int) {
180
g.t.Helper()
181
_ = g.cmd.Process.Kill()
182
_, _ = g.cmd.Process.Wait()
183
b, err := os.ReadFile(g.Config)
184
if err != nil {
185
g.t.Fatal(err)
186
}
187
var out []string
188
for _, l := range strings.Split(string(b), "\n") {
189
switch {
190
case strings.HasPrefix(l, " dev_user:"):
191
l = " dev_user: " + user
192
case strings.HasPrefix(l, " dev_auth_id:"):
193
l = fmt.Sprintf(" dev_auth_id: %d", authID)
194
}
195
out = append(out, l)
196
}
197
if err := os.WriteFile(g.Config, []byte(strings.Join(out, "\n")), 0o600); err != nil {
198
g.t.Fatal(err)
199
}
200
g.cmd = exec.Command(g.Bin, "serve", "--config", g.Config)
201
g.cmd.Stdout, g.cmd.Stderr = g.log, g.log
202
if err := g.cmd.Start(); err != nil {
203
g.t.Fatal(err)
204
}
205
g.WaitUp(20 * time.Second)
206
}
207
208
// Page haalt een HTML-pagina op met een sessie (dev-login van de huidige
209
// dev-gebruiker).
210
func (g *BlueGit) Page(hc *http.Client, p string) string {
211
g.t.Helper()
212
res, err := hc.Get(g.URL + p)
213
if err != nil {
214
g.t.Fatal(err)
215
}
216
defer res.Body.Close()
217
b, _ := io.ReadAll(res.Body)
218
return string(b)
219
}
220
221
// WaitUp wacht op /healthz.
222
func (g *BlueGit) WaitUp(d time.Duration) {
223
g.t.Helper()
224
deadline := time.Now().Add(d)
225
for time.Now().Before(deadline) {
226
res, err := http.Get(g.URL + "/healthz")
227
if err == nil {
228
res.Body.Close()
229
if res.StatusCode == 200 {
230
return
231
}
232
}
233
time.Sleep(100 * time.Millisecond)
234
}
235
g.t.Fatalf("BlueGit %s kwam niet op:\n%s", g.URL, tail(g.log.String(), 40))
236
}
237
238
// API doet een verzoek met het token. path begint na /api/v1.
239
func (g *BlueGit) API(method, path string, in any) (int, []byte) {
240
g.t.Helper()
241
return g.APIWith(g.Token, method, path, in)
242
}
243
244
// APIWith gebruikt een ander token.
245
func (g *BlueGit) APIWith(tok, method, path string, in any) (int, []byte) {
246
g.t.Helper()
247
var body io.Reader
248
if in != nil {
249
b, _ := json.Marshal(in)
250
body = bytes.NewReader(b)
251
}
252
req, _ := http.NewRequest(method, g.URL+"/api/v1"+path, body)
253
req.Header.Set("Authorization", "Bearer "+tok)
254
if in != nil {
255
req.Header.Set("Content-Type", "application/json")
256
}
257
res, err := http.DefaultClient.Do(req)
258
if err != nil {
259
g.t.Fatalf("%s %s: %v", method, path, err)
260
}
261
defer res.Body.Close()
262
b, _ := io.ReadAll(res.Body)
263
return res.StatusCode, b
264
}
265
266
// MustAPI faalt bij een fout.
267
func (g *BlueGit) MustAPI(method, path string, in any) []byte {
268
g.t.Helper()
269
code, b := g.API(method, path, in)
270
if code >= 300 {
271
g.t.Fatalf("%s %s: %d %s", method, path, code, b)
272
}
273
return b
274
}
275
276
// AddServer voegt een backup server toe in BlueGit en geeft id en key.
277
func (g *BlueGit) AddServer(name string) (string, string) {
278
g.t.Helper()
279
var out struct{ ID, Key string }
280
_ = json.Unmarshal(g.MustAPI("POST", "/admin/backup/servers", map[string]any{"name": name}), &out)
281
if !strings.HasPrefix(out.Key, "bgbk_") || out.ID == "" {
282
g.t.Fatalf("server %+v", out)
283
}
284
return out.ID, out.Key
285
}
286
287
// NewKey voegt een backup server toe en geeft zijn Backupserver-Key.
288
func (g *BlueGit) NewKey() string {
289
g.t.Helper()
290
id, key := g.AddServer("test")
291
g.Server = id
292
return key
293
}
294
295
// RotateKey geeft de laatst toegevoegde backup server een nieuwe key.
296
func (g *BlueGit) RotateKey() string {
297
g.t.Helper()
298
var out struct{ Key string }
299
_ = json.Unmarshal(g.MustAPI("POST", "/admin/backup/servers/"+g.Server+"/key", nil), &out)
300
return out.Key
301
}
302
303
// Action voert een actie van backup server id uit via BlueGit.
304
func (g *BlueGit) Action(id, name string, in any) (int, []byte) {
305
g.t.Helper()
306
return g.API("POST", "/admin/backup/servers/"+id+"/actions/"+name, in)
307
}
308
309
// Project maakt een project met één commit.
310
func (g *BlueGit) Project(name, file, content string) {
311
g.t.Helper()
312
g.MustAPI("POST", "/projects", map[string]any{"name": name, "visibility": "private"})
313
g.Commit(strings.ToLower(name), file, content, "create")
314
}
315
316
// Commit schrijft één bestand op master.
317
func (g *BlueGit) Commit(repo, file, content, action string) {
318
g.t.Helper()
319
g.MustAPI("POST", "/projects/tim/"+repo+"/repository/commits", map[string]any{
320
"branch": "master", "commit_message": "zet " + file,
321
"actions": []map[string]string{{"action": action, "file_path": file, "content": content}},
322
})
323
}
324
325
// File leest een bestand van master, of geeft de HTTP-code.
326
func (g *BlueGit) File(repo, file string) (int, string) {
327
g.t.Helper()
328
req, _ := http.NewRequest("GET", g.URL+"/api/v1/projects/tim/"+repo+"/repository/files/"+file+"?ref=master", nil)
329
req.Header.Set("Authorization", "Bearer "+g.Token)
330
res, err := http.DefaultClient.Do(req)
331
if err != nil {
332
g.t.Fatal(err)
333
}
334
defer res.Body.Close()
335
b, _ := io.ReadAll(res.Body)
336
return res.StatusCode, string(b)
337
}
338
339
// Issue maakt een issue.
340
func (g *BlueGit) Issue(repo, title string) {
341
g.t.Helper()
342
g.MustAPI("POST", "/repos/tim/"+repo+"/issues", map[string]any{"title": title})
343
}
344
345
// IssueTitles geeft alle issuetitels.
346
func (g *BlueGit) IssueTitles(repo string) []string {
347
g.t.Helper()
348
code, b := g.API("GET", "/repos/tim/"+repo+"/issues?state=all", nil)
349
if code != 200 {
350
g.t.Fatalf("issues: %d %s", code, b)
351
}
352
var list struct {
353
Issues []struct{ Title string } `json:"issues"`
354
}
355
_ = json.Unmarshal(b, &list)
356
var out []string
357
for _, i := range list.Issues {
358
out = append(out, i.Title)
359
}
360
return out
361
}
362
363
// ProjectCode is de HTTP-code van GET project.
364
func (g *BlueGit) ProjectCode(repo string) int {
365
g.t.Helper()
366
code, _ := g.API("GET", "/projects/tim/"+repo, nil)
367
return code
368
}
369
370
// BackupStatus is wat BlueGit over een backup server weet.
371
type BackupStatus struct {
372
InstanceID string `json:"instance_id"`
373
HasKey bool `json:"-"`
374
Name string `json:"name"`
375
Connected bool `json:"connected"`
376
ServerURL string `json:"server_url"`
377
Archives []struct {
378
Name string `json:"name"`
379
Size int64 `json:"size"`
380
} `json:"archives"`
381
Config struct {
382
Fields []struct {
383
Key string `json:"key"`
384
Value string `json:"value"`
385
} `json:"fields"`
386
} `json:"config"`
387
RemoteError string `json:"remote_error"`
388
// Compat: "" (onbekend), ok, bluegit_too_old of backup_too_old.
389
Compat string `json:"compat"`
390
Protocol struct {
391
BlueGit int `json:"bluegit"`
392
BlueGitMin int `json:"bluegit_min"`
393
Backup int `json:"backup"`
394
BackupMin int `json:"backup_min"`
395
} `json:"protocol"`
396
}
397
398
// BackupStatus geeft de stand van de laatst toegevoegde backup server.
399
func (g *BlueGit) BackupStatus() BackupStatus { return g.ServerStatus(g.Server) }
400
401
// ServerStatus geeft de stand van backup server id ("" = de eerste).
402
func (g *BlueGit) ServerStatus(id string) BackupStatus {
403
g.t.Helper()
404
var list struct {
405
InstanceID string `json:"instance_id"`
406
Servers []struct {
407
ID string `json:"id"`
408
} `json:"servers"`
409
}
410
_ = json.Unmarshal(g.MustAPI("GET", "/admin/backup", nil), &list)
411
st := BackupStatus{InstanceID: list.InstanceID}
412
if id == "" && len(list.Servers) > 0 {
413
id = list.Servers[0].ID
414
}
415
found := false
416
for _, s := range list.Servers {
417
found = found || s.ID == id
418
}
419
if !found {
420
return st
421
}
422
_ = json.Unmarshal(g.MustAPI("GET", "/admin/backup/servers/"+id, nil), &st)
423
st.HasKey = true
424
st.InstanceID = list.InstanceID
425
return st
426
}
427
428
// Session geeft een HTTP-client met sessiecookie (dev-login).
429
func (g *BlueGit) Session() *http.Client {
430
g.t.Helper()
431
jar, _ := cookiejar.New(nil)
432
hc := &http.Client{Jar: jar}
433
res, err := hc.Get(g.URL + "/login")
434
if err != nil {
435
g.t.Fatal(err)
436
}
437
res.Body.Close()
438
return hc
439
}
440
441
// Git draait git met het token als wachtwoord.
442
func (g *BlueGit) Git(dir string, args ...string) string {
443
g.t.Helper()
444
cmd := exec.Command("git", args...)
445
cmd.Dir = dir
446
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")
447
out, err := cmd.CombinedOutput()
448
if err != nil {
449
g.t.Fatalf("git %v: %v\n%s", args, err, out)
450
}
451
return string(out)
452
}
453
454
// RemoteURL is de clone-URL met token.
455
func (g *BlueGit) RemoteURL(repo string) string {
456
u, _ := url.Parse(g.URL)
457
u.User = url.UserPassword("tim", g.Token)
458
u.Path = "/tim/" + repo + ".git"
459
return u.String()
460
}
461
462
// Backup is één backup server in dit proces.
463
type Backup struct {
464
t *testing.T
465
Srv *server.Server
466
URL string
467
Dir string
468
Cfg config.Config
469
}
470
471
func startBackup(t *testing.T, mod func(*config.Config)) *Backup {
472
t.Helper()
473
port := freePort(t)
474
b := &Backup{t: t, URL: fmt.Sprintf("http://127.0.0.1:%d", port), Dir: t.TempDir()}
475
cfg := config.Config{Listen: fmt.Sprintf("127.0.0.1:%d", port), PublicURL: b.URL, DataDir: b.Dir}
476
// Snel genoeg voor tests; de standaardwaarden staan in config.Defaults.
477
cfg.MinSyncInterval.Duration = 50 * time.Millisecond
478
cfg.ArchiveInterval.Duration = time.Hour
479
cfg.FullSyncInterval.Duration = time.Hour
480
cfg.RateLimitKiB = -1
481
cfg.MinFreeMB = 1
482
if mod != nil {
483
mod(&cfg)
484
}
485
cfg.Defaults()
486
b.Cfg = cfg
487
srv, err := server.New(cfg, slog.New(slog.NewTextHandler(&testWriter{t}, &slog.HandlerOptions{Level: slog.LevelWarn})))
488
if err != nil {
489
t.Fatal(err)
490
}
491
b.Srv = srv
492
ln, err := net.Listen("tcp", cfg.Listen)
493
if err != nil {
494
t.Fatal(err)
495
}
496
hs := &http.Server{Handler: srv.Handler()}
497
ctx, cancel := context.WithCancel(context.Background())
498
go func() { _ = hs.Serve(ln) }()
499
srv.Run(ctx)
500
t.Cleanup(func() {
501
cancel()
502
_ = hs.Close()
503
})
504
return b
505
}
506
507
type testWriter struct{ t *testing.T }
508
509
func (w *testWriter) Write(p []byte) (int, error) {
510
w.t.Log(strings.TrimRight(string(p), "\n"))
511
return len(p), nil
512
}
513
514
// Admin doet een verzoek op de lokale beheer-API.
515
func (b *Backup) Admin(method, path string, in any) (int, []byte) {
516
b.t.Helper()
517
var body io.Reader
518
if in != nil {
519
raw, _ := json.Marshal(in)
520
body = bytes.NewReader(raw)
521
}
522
req, _ := http.NewRequest(method, b.URL+"/api/v1/admin"+path, body)
523
req.Header.Set("Authorization", "Bearer "+b.Srv.AdminToken())
524
res, err := http.DefaultClient.Do(req)
525
if err != nil {
526
b.t.Fatal(err)
527
}
528
defer res.Body.Close()
529
raw, _ := io.ReadAll(res.Body)
530
return res.StatusCode, raw
531
}
532
533
// Connect koppelt aan g zonder conflictkeuze; faalt bij een fout.
534
func (b *Backup) Connect(g *BlueGit, key string) {
535
b.t.Helper()
536
code, raw := b.Admin("POST", "/connect", server.ConnectRequest{URL: g.URL, Key: key})
537
if code != 200 {
538
b.t.Fatalf("connect: %d %s", code, raw)
539
}
540
}
541
542
// Sync synchroniseert nu.
543
func (b *Backup) Sync() {
544
b.t.Helper()
545
code, raw := b.Admin("POST", "/sync", nil)
546
if code != 200 {
547
b.t.Fatalf("sync: %d %s", code, raw)
548
}
549
}
550
551
// Archive maakt nu een archief en geeft de naam.
552
func (b *Backup) Archive() string {
553
b.t.Helper()
554
code, raw := b.Admin("POST", "/archive", nil)
555
if code != 201 {
556
b.t.Fatalf("archive: %d %s", code, raw)
557
}
558
var a struct{ Name string }
559
_ = json.Unmarshal(raw, &a)
560
return a.Name
561
}
562
563
// Mirror is het pad van een logisch bestand in de kopie.
564
func (b *Backup) Mirror(logical string) string {
565
return filepath.Join(b.Dir, "mirror", filepath.FromSlash(logical))
566
}
567
568
// Archives geeft de archiefnamen, nieuwste eerst.
569
func (b *Backup) Archives() []string {
570
b.t.Helper()
571
_, raw := b.Admin("GET", "/archives", nil)
572
var out struct {
573
Archives []struct{ Name string }
574
}
575
_ = json.Unmarshal(raw, &out)
576
var names []string
577
for _, a := range out.Archives {
578
names = append(names, a.Name)
579
}
580
return names
581
}
582
583
// Status leest de status.
584
func (b *Backup) Status() server.Status {
585
b.t.Helper()
586
_, raw := b.Admin("GET", "/status", nil)
587
var st server.Status
588
_ = json.Unmarshal(raw, &st)
589
return st
590
}
591
592
// Eventually herhaalt f tot hij true geeft.
593
func Eventually(t *testing.T, d time.Duration, what string, f func() bool) {
594
t.Helper()
595
deadline := time.Now().Add(d)
596
for time.Now().Before(deadline) {
597
if f() {
598
return
599
}
600
time.Sleep(50 * time.Millisecond)
601
}
602
t.Fatalf("na %v nog steeds niet: %s", d, what)
603
}
604
605
// gitLog geeft de onderwerpen van een bare repo in de kopie.
606
func gitLog(t *testing.T, gitDir string) string {
607
t.Helper()
608
out, err := exec.Command("git", "--git-dir", gitDir, "log", "--format=%s", "master").CombinedOutput()
609
if err != nil {
610
return "FOUT: " + string(out)
611
}
612
return string(out)
613
}
@@ -0,0 +1,613 @@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
// Server is het id van de laatst toegevoegde backup server in BlueGit.69
Server string70
}71
72
type syncBuf struct {73
mu sync.Mutex74
b bytes.Buffer75
}76
77
func (s *syncBuf) Write(p []byte) (int, error) {78
s.mu.Lock()79
defer s.mu.Unlock()80
return s.b.Write(p)81
}82
83
func (s *syncBuf) String() string {84
s.mu.Lock()85
defer s.mu.Unlock()86
return s.b.String()87
}88
89
func startBlueGit(t *testing.T) *BlueGit {90
t.Helper()91
return startBlueGitBin(t, bluegitBin(t))92
}93
94
// bluegitFutureBin is een test-build van dezelfde BlueGit met een hoger95
// protocol (scripts/build-bluegit.sh bouwt hem naast BLUEGIT_BIN met96
// -ldflags -X): protocol FutureProtocol, en hij ondersteunt alleen backup97
// servers vanaf FutureProtocol.98
func bluegitFutureBin(t *testing.T) string {99
t.Helper()100
bin := os.Getenv("BLUEGIT_FUTURE_BIN")101
if bin == "" {102
bin = filepath.Join(filepath.Dir(bluegitBin(t)), "bluegit-future")103
}104
if _, err := os.Stat(bin); err != nil {105
t.Fatalf("test-build met hoger protocol ontbreekt (scripts/build-bluegit.sh): %v", err)106
}107
return bin108
}109
110
// FutureProtocol staat ook in scripts/build-bluegit.sh.111
const FutureProtocol = 99112
113
func startBlueGitBin(t *testing.T, bin string) *BlueGit {114
t.Helper()115
dir := t.TempDir()116
port := freePort(t)117
g := &BlueGit{t: t, Bin: bin, URL: fmt.Sprintf("http://127.0.0.1:%d", port),118
State: filepath.Join(dir, "state"), Storage: filepath.Join(dir, "storage"), Config: filepath.Join(dir, "bluegit.yml"), log: &syncBuf{}}119
_ = os.MkdirAll(g.Storage, 0o750)120
cfg := fmt.Sprintf(`base_url: %s121
listen: 127.0.0.1:%d122
state_path: %s123
storage_path: %s124
auth:125
mode: dev126
dev_user: tim127
dev_auth_id: 1128
user_agent: bluegit-backup-it129
git:130
binary: git131
default_branch: master132
ssh:133
enabled: false134
ci:135
enabled: false136
`, g.URL, port, g.State, g.Storage)137
if err := os.WriteFile(g.Config, []byte(cfg), 0o600); err != nil {138
t.Fatal(err)139
}140
g.cmd = exec.Command(bin, "serve", "--config", g.Config)141
g.cmd.Stdout, g.cmd.Stderr = g.log, g.log142
if err := g.cmd.Start(); err != nil {143
t.Fatal(err)144
}145
t.Cleanup(func() {146
_ = g.cmd.Process.Kill()147
_, _ = g.cmd.Process.Wait()148
if t.Failed() {149
t.Logf("BlueGit-log %s:\n%s", g.URL, tail(g.log.String(), 60))150
}151
})152
g.WaitUp(20 * time.Second)153
// Aanmelden maakt de eerste gebruiker (beheerder) aan.154
jar, _ := cookiejar.New(nil)155
hc := &http.Client{Jar: jar}156
res, err := hc.Get(g.URL + "/login")157
if err != nil {158
t.Fatal(err)159
}160
res.Body.Close()161
out, err := exec.Command(bin, "token", "create", "--config", g.Config, "--user", "tim", "--name", "it").CombinedOutput()162
if err != nil {163
t.Fatalf("token: %v %s", err, out)164
}165
g.Token = strings.TrimSpace(string(out))166
return g167
}168
169
func tail(s string, n int) string {170
lines := strings.Split(s, "\n")171
if len(lines) > n {172
lines = lines[len(lines)-n:]173
}174
return strings.Join(lines, "\n")175
}176
177
// RestartAs herstart dezelfde BlueGit (zelfde gegevens) met een andere178
// dev-gebruiker. Zo is er een tweede gebruiker die geen beheerder is.179
func (g *BlueGit) RestartAs(user string, authID int) {180
g.t.Helper()181
_ = g.cmd.Process.Kill()182
_, _ = g.cmd.Process.Wait()183
b, err := os.ReadFile(g.Config)184
if err != nil {185
g.t.Fatal(err)186
}187
var out []string188
for _, l := range strings.Split(string(b), "\n") {189
switch {190
case strings.HasPrefix(l, " dev_user:"):191
l = " dev_user: " + user192
case strings.HasPrefix(l, " dev_auth_id:"):193
l = fmt.Sprintf(" dev_auth_id: %d", authID)194
}195
out = append(out, l)196
}197
if err := os.WriteFile(g.Config, []byte(strings.Join(out, "\n")), 0o600); err != nil {198
g.t.Fatal(err)199
}200
g.cmd = exec.Command(g.Bin, "serve", "--config", g.Config)201
g.cmd.Stdout, g.cmd.Stderr = g.log, g.log202
if err := g.cmd.Start(); err != nil {203
g.t.Fatal(err)204
}205
g.WaitUp(20 * time.Second)206
}207
208
// Page haalt een HTML-pagina op met een sessie (dev-login van de huidige209
// dev-gebruiker).210
func (g *BlueGit) Page(hc *http.Client, p string) string {211
g.t.Helper()212
res, err := hc.Get(g.URL + p)213
if err != nil {214
g.t.Fatal(err)215
}216
defer res.Body.Close()217
b, _ := io.ReadAll(res.Body)218
return string(b)219
}220
221
// WaitUp wacht op /healthz.222
func (g *BlueGit) WaitUp(d time.Duration) {223
g.t.Helper()224
deadline := time.Now().Add(d)225
for time.Now().Before(deadline) {226
res, err := http.Get(g.URL + "/healthz")227
if err == nil {228
res.Body.Close()229
if res.StatusCode == 200 {230
return231
}232
}233
time.Sleep(100 * time.Millisecond)234
}235
g.t.Fatalf("BlueGit %s kwam niet op:\n%s", g.URL, tail(g.log.String(), 40))236
}237
238
// API doet een verzoek met het token. path begint na /api/v1.239
func (g *BlueGit) API(method, path string, in any) (int, []byte) {240
g.t.Helper()241
return g.APIWith(g.Token, method, path, in)242
}243
244
// APIWith gebruikt een ander token.245
func (g *BlueGit) APIWith(tok, method, path string, in any) (int, []byte) {246
g.t.Helper()247
var body io.Reader248
if in != nil {249
b, _ := json.Marshal(in)250
body = bytes.NewReader(b)251
}252
req, _ := http.NewRequest(method, g.URL+"/api/v1"+path, body)253
req.Header.Set("Authorization", "Bearer "+tok)254
if in != nil {255
req.Header.Set("Content-Type", "application/json")256
}257
res, err := http.DefaultClient.Do(req)258
if err != nil {259
g.t.Fatalf("%s %s: %v", method, path, err)260
}261
defer res.Body.Close()262
b, _ := io.ReadAll(res.Body)263
return res.StatusCode, b264
}265
266
// MustAPI faalt bij een fout.267
func (g *BlueGit) MustAPI(method, path string, in any) []byte {268
g.t.Helper()269
code, b := g.API(method, path, in)270
if code >= 300 {271
g.t.Fatalf("%s %s: %d %s", method, path, code, b)272
}273
return b274
}275
276
// AddServer voegt een backup server toe in BlueGit en geeft id en key.277
func (g *BlueGit) AddServer(name string) (string, string) {278
g.t.Helper()279
var out struct{ ID, Key string }280
_ = json.Unmarshal(g.MustAPI("POST", "/admin/backup/servers", map[string]any{"name": name}), &out)281
if !strings.HasPrefix(out.Key, "bgbk_") || out.ID == "" {282
g.t.Fatalf("server %+v", out)283
}284
return out.ID, out.Key285
}286
287
// NewKey voegt een backup server toe en geeft zijn Backupserver-Key.288
func (g *BlueGit) NewKey() string {289
g.t.Helper()290
id, key := g.AddServer("test")291
g.Server = id292
return key293
}294
295
// RotateKey geeft de laatst toegevoegde backup server een nieuwe key.296
func (g *BlueGit) RotateKey() string {297
g.t.Helper()298
var out struct{ Key string }299
_ = json.Unmarshal(g.MustAPI("POST", "/admin/backup/servers/"+g.Server+"/key", nil), &out)300
return out.Key301
}302
303
// Action voert een actie van backup server id uit via BlueGit.304
func (g *BlueGit) Action(id, name string, in any) (int, []byte) {305
g.t.Helper()306
return g.API("POST", "/admin/backup/servers/"+id+"/actions/"+name, in)307
}308
309
// Project maakt een project met één commit.310
func (g *BlueGit) Project(name, file, content string) {311
g.t.Helper()312
g.MustAPI("POST", "/projects", map[string]any{"name": name, "visibility": "private"})313
g.Commit(strings.ToLower(name), file, content, "create")314
}315
316
// Commit schrijft één bestand op master.317
func (g *BlueGit) Commit(repo, file, content, action string) {318
g.t.Helper()319
g.MustAPI("POST", "/projects/tim/"+repo+"/repository/commits", map[string]any{320
"branch": "master", "commit_message": "zet " + file,321
"actions": []map[string]string{{"action": action, "file_path": file, "content": content}},322
})323
}324
325
// File leest een bestand van master, of geeft de HTTP-code.326
func (g *BlueGit) File(repo, file string) (int, string) {327
g.t.Helper()328
req, _ := http.NewRequest("GET", g.URL+"/api/v1/projects/tim/"+repo+"/repository/files/"+file+"?ref=master", nil)329
req.Header.Set("Authorization", "Bearer "+g.Token)330
res, err := http.DefaultClient.Do(req)331
if err != nil {332
g.t.Fatal(err)333
}334
defer res.Body.Close()335
b, _ := io.ReadAll(res.Body)336
return res.StatusCode, string(b)337
}338
339
// Issue maakt een issue.340
func (g *BlueGit) Issue(repo, title string) {341
g.t.Helper()342
g.MustAPI("POST", "/repos/tim/"+repo+"/issues", map[string]any{"title": title})343
}344
345
// IssueTitles geeft alle issuetitels.346
func (g *BlueGit) IssueTitles(repo string) []string {347
g.t.Helper()348
code, b := g.API("GET", "/repos/tim/"+repo+"/issues?state=all", nil)349
if code != 200 {350
g.t.Fatalf("issues: %d %s", code, b)351
}352
var list struct {353
Issues []struct{ Title string } `json:"issues"`354
}355
_ = json.Unmarshal(b, &list)356
var out []string357
for _, i := range list.Issues {358
out = append(out, i.Title)359
}360
return out361
}362
363
// ProjectCode is de HTTP-code van GET project.364
func (g *BlueGit) ProjectCode(repo string) int {365
g.t.Helper()366
code, _ := g.API("GET", "/projects/tim/"+repo, nil)367
return code368
}369
370
// BackupStatus is wat BlueGit over een backup server weet.371
type BackupStatus struct {372
InstanceID string `json:"instance_id"`373
HasKey bool `json:"-"`374
Name string `json:"name"`375
Connected bool `json:"connected"`376
ServerURL string `json:"server_url"`377
Archives []struct {378
Name string `json:"name"`379
Size int64 `json:"size"`380
} `json:"archives"`381
Config struct {382
Fields []struct {383
Key string `json:"key"`384
Value string `json:"value"`385
} `json:"fields"`386
} `json:"config"`387
RemoteError string `json:"remote_error"`388
// Compat: "" (onbekend), ok, bluegit_too_old of backup_too_old.389
Compat string `json:"compat"`390
Protocol struct {391
BlueGit int `json:"bluegit"`392
BlueGitMin int `json:"bluegit_min"`393
Backup int `json:"backup"`394
BackupMin int `json:"backup_min"`395
} `json:"protocol"`396
}397
398
// BackupStatus geeft de stand van de laatst toegevoegde backup server.399
func (g *BlueGit) BackupStatus() BackupStatus { return g.ServerStatus(g.Server) }400
401
// ServerStatus geeft de stand van backup server id ("" = de eerste).402
func (g *BlueGit) ServerStatus(id string) BackupStatus {403
g.t.Helper()404
var list struct {405
InstanceID string `json:"instance_id"`406
Servers []struct {407
ID string `json:"id"`408
} `json:"servers"`409
}410
_ = json.Unmarshal(g.MustAPI("GET", "/admin/backup", nil), &list)411
st := BackupStatus{InstanceID: list.InstanceID}412
if id == "" && len(list.Servers) > 0 {413
id = list.Servers[0].ID414
}415
found := false416
for _, s := range list.Servers {417
found = found || s.ID == id418
}419
if !found {420
return st421
}422
_ = json.Unmarshal(g.MustAPI("GET", "/admin/backup/servers/"+id, nil), &st)423
st.HasKey = true424
st.InstanceID = list.InstanceID425
return st426
}427
428
// Session geeft een HTTP-client met sessiecookie (dev-login).429
func (g *BlueGit) Session() *http.Client {430
g.t.Helper()431
jar, _ := cookiejar.New(nil)432
hc := &http.Client{Jar: jar}433
res, err := hc.Get(g.URL + "/login")434
if err != nil {435
g.t.Fatal(err)436
}437
res.Body.Close()438
return hc439
}440
441
// Git draait git met het token als wachtwoord.442
func (g *BlueGit) Git(dir string, args ...string) string {443
g.t.Helper()444
cmd := exec.Command("git", args...)445
cmd.Dir = dir446
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")447
out, err := cmd.CombinedOutput()448
if err != nil {449
g.t.Fatalf("git %v: %v\n%s", args, err, out)450
}451
return string(out)452
}453
454
// RemoteURL is de clone-URL met token.455
func (g *BlueGit) RemoteURL(repo string) string {456
u, _ := url.Parse(g.URL)457
u.User = url.UserPassword("tim", g.Token)458
u.Path = "/tim/" + repo + ".git"459
return u.String()460
}461
462
// Backup is één backup server in dit proces.463
type Backup struct {464
t *testing.T465
Srv *server.Server466
URL string467
Dir string468
Cfg config.Config469
}470
471
func startBackup(t *testing.T, mod func(*config.Config)) *Backup {472
t.Helper()473
port := freePort(t)474
b := &Backup{t: t, URL: fmt.Sprintf("http://127.0.0.1:%d", port), Dir: t.TempDir()}475
cfg := config.Config{Listen: fmt.Sprintf("127.0.0.1:%d", port), PublicURL: b.URL, DataDir: b.Dir}476
// Snel genoeg voor tests; de standaardwaarden staan in config.Defaults.477
cfg.MinSyncInterval.Duration = 50 * time.Millisecond478
cfg.ArchiveInterval.Duration = time.Hour479
cfg.FullSyncInterval.Duration = time.Hour480
cfg.RateLimitKiB = -1481
cfg.MinFreeMB = 1482
if mod != nil {483
mod(&cfg)484
}485
cfg.Defaults()486
b.Cfg = cfg487
srv, err := server.New(cfg, slog.New(slog.NewTextHandler(&testWriter{t}, &slog.HandlerOptions{Level: slog.LevelWarn})))488
if err != nil {489
t.Fatal(err)490
}491
b.Srv = srv492
ln, err := net.Listen("tcp", cfg.Listen)493
if err != nil {494
t.Fatal(err)495
}496
hs := &http.Server{Handler: srv.Handler()}497
ctx, cancel := context.WithCancel(context.Background())498
go func() { _ = hs.Serve(ln) }()499
srv.Run(ctx)500
t.Cleanup(func() {501
cancel()502
_ = hs.Close()503
})504
return b505
}506
507
type testWriter struct{ t *testing.T }508
509
func (w *testWriter) Write(p []byte) (int, error) {510
w.t.Log(strings.TrimRight(string(p), "\n"))511
return len(p), nil512
}513
514
// Admin doet een verzoek op de lokale beheer-API.515
func (b *Backup) Admin(method, path string, in any) (int, []byte) {516
b.t.Helper()517
var body io.Reader518
if in != nil {519
raw, _ := json.Marshal(in)520
body = bytes.NewReader(raw)521
}522
req, _ := http.NewRequest(method, b.URL+"/api/v1/admin"+path, body)523
req.Header.Set("Authorization", "Bearer "+b.Srv.AdminToken())524
res, err := http.DefaultClient.Do(req)525
if err != nil {526
b.t.Fatal(err)527
}528
defer res.Body.Close()529
raw, _ := io.ReadAll(res.Body)530
return res.StatusCode, raw531
}532
533
// Connect koppelt aan g zonder conflictkeuze; faalt bij een fout.534
func (b *Backup) Connect(g *BlueGit, key string) {535
b.t.Helper()536
code, raw := b.Admin("POST", "/connect", server.ConnectRequest{URL: g.URL, Key: key})537
if code != 200 {538
b.t.Fatalf("connect: %d %s", code, raw)539
}540
}541
542
// Sync synchroniseert nu.543
func (b *Backup) Sync() {544
b.t.Helper()545
code, raw := b.Admin("POST", "/sync", nil)546
if code != 200 {547
b.t.Fatalf("sync: %d %s", code, raw)548
}549
}550
551
// Archive maakt nu een archief en geeft de naam.552
func (b *Backup) Archive() string {553
b.t.Helper()554
code, raw := b.Admin("POST", "/archive", nil)555
if code != 201 {556
b.t.Fatalf("archive: %d %s", code, raw)557
}558
var a struct{ Name string }559
_ = json.Unmarshal(raw, &a)560
return a.Name561
}562
563
// Mirror is het pad van een logisch bestand in de kopie.564
func (b *Backup) Mirror(logical string) string {565
return filepath.Join(b.Dir, "mirror", filepath.FromSlash(logical))566
}567
568
// Archives geeft de archiefnamen, nieuwste eerst.569
func (b *Backup) Archives() []string {570
b.t.Helper()571
_, raw := b.Admin("GET", "/archives", nil)572
var out struct {573
Archives []struct{ Name string }574
}575
_ = json.Unmarshal(raw, &out)576
var names []string577
for _, a := range out.Archives {578
names = append(names, a.Name)579
}580
return names581
}582
583
// Status leest de status.584
func (b *Backup) Status() server.Status {585
b.t.Helper()586
_, raw := b.Admin("GET", "/status", nil)587
var st server.Status588
_ = json.Unmarshal(raw, &st)589
return st590
}591
592
// Eventually herhaalt f tot hij true geeft.593
func Eventually(t *testing.T, d time.Duration, what string, f func() bool) {594
t.Helper()595
deadline := time.Now().Add(d)596
for time.Now().Before(deadline) {597
if f() {598
return599
}600
time.Sleep(50 * time.Millisecond)601
}602
t.Fatalf("na %v nog steeds niet: %s", d, what)603
}604
605
// gitLog geeft de onderwerpen van een bare repo in de kopie.606
func gitLog(t *testing.T, gitDir string) string {607
t.Helper()608
out, err := exec.Command("git", "--git-dir", gitDir, "log", "--format=%s", "master").CombinedOutput()609
if err != nil {610
return "FOUT: " + string(out)611
}612
return string(out)613
}@@ -0,0 +1,399 @@
1
//go:build integration
2
3
package integration
4
5
import (
6
"encoding/json"
7
"io"
8
"net/http"
9
"net/http/cookiejar"
10
"net/url"
11
"os"
12
"path/filepath"
13
"sort"
14
"strings"
15
"testing"
16
"time"
17
)
18
19
// webUI is een browser op de webinterface van de backup server.
20
type webUI struct {
21
t *testing.T
22
b *Backup
23
hc *http.Client
24
csrf string
25
}
26
27
func openUI(t *testing.T, b *Backup) *webUI {
28
t.Helper()
29
jar, _ := cookiejar.New(nil)
30
u := &webUI{t: t, b: b, hc: &http.Client{Jar: jar, CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }}}
31
res, err := u.hc.Get(b.URL + "/")
32
if err != nil {
33
t.Fatal(err)
34
}
35
res.Body.Close()
36
if res.StatusCode != 303 || res.Header.Get("Location") != "/login" {
37
t.Fatalf("zonder login: %d %s", res.StatusCode, res.Header.Get("Location"))
38
}
39
res, _ = u.hc.PostForm(b.URL+"/login", url.Values{"token": {"bba_fout"}})
40
res.Body.Close()
41
if res.Header.Get("Location") != "/login?fout=1" {
42
t.Fatal("fout token geaccepteerd")
43
}
44
res, _ = u.hc.PostForm(b.URL+"/login", url.Values{"token": {b.Srv.AdminToken()}})
45
res.Body.Close()
46
if res.StatusCode != 303 || res.Header.Get("Location") != "/" {
47
t.Fatalf("login: %d", res.StatusCode)
48
}
49
u.Page()
50
return u
51
}
52
53
// Page haalt de hoofdpagina op en onthoudt het CSRF-token.
54
func (u *webUI) Page() string {
55
u.t.Helper()
56
res, err := u.hc.Get(u.b.URL + "/")
57
if err != nil {
58
u.t.Fatal(err)
59
}
60
b, _ := io.ReadAll(res.Body)
61
res.Body.Close()
62
if res.StatusCode != 200 {
63
u.t.Fatalf("pagina: %d", res.StatusCode)
64
}
65
u.csrf = between(string(b), `name="csrf" value="`, `"`)
66
return string(b)
67
}
68
69
// Act verstuurt het formulier van een actie en geeft de melding erna.
70
func (u *webUI) Act(name string, form url.Values) string {
71
u.t.Helper()
72
if form == nil {
73
form = url.Values{}
74
}
75
form.Set("csrf", u.csrf)
76
res, err := u.hc.PostForm(u.b.URL+"/ui/act/"+name, form)
77
if err != nil {
78
u.t.Fatal(err)
79
}
80
res.Body.Close()
81
if res.StatusCode != 303 {
82
u.t.Fatalf("%s: %d", name, res.StatusCode)
83
}
84
return between(u.Page(), `role="status">`, `</div>`)
85
}
86
87
func actionNames(t *testing.T, b *Backup, withGet bool) []string {
88
t.Helper()
89
code, raw := b.Admin("GET", "/actions", nil)
90
if code != 200 {
91
t.Fatalf("actions: %d", code)
92
}
93
var out struct {
94
Actions []struct{ Name, Method string }
95
}
96
_ = json.Unmarshal(raw, &out)
97
var names []string
98
for _, a := range out.Actions {
99
if withGet || a.Method != "GET" {
100
names = append(names, a.Name)
101
}
102
}
103
sort.Strings(names)
104
return names
105
}
106
107
func requireAll(t *testing.T, what string, want []string, done map[string]bool) {
108
t.Helper()
109
for _, n := range want {
110
if !done[n] {
111
t.Errorf("%s: actie %s niet getest", what, n)
112
}
113
}
114
}
115
116
// Feature: alles is in te stellen en te bedienen via de webinterface (poort 8080 standaard).
117
func TestWebUIConfiguresAndOperatesEverything(t *testing.T) {
118
g := startBlueGit(t)
119
g.Project("Alpha", "README.md", "v1")
120
b := startBackup(t, nil)
121
u := openUI(t, b)
122
done := map[string]bool{}
123
124
// Instellingen.
125
msg := u.Act("config.update", url.Values{"archive_interval": {"3h"}, "retention_days": {"5"}, "rate_limit_kib": {"2048"}, "min_free_mb": {"2"}, "full_sync_interval": {"2h"}, "min_sync_interval": {"1s"}, "public_url": {b.URL}, "listen": {b.Cfg.Listen}})
126
if !strings.Contains(msg, "opgeslagen") {
127
t.Fatalf("instellingen: %q", msg)
128
}
129
done["config.update"] = true
130
st := b.Status()
131
if st.Interval != "3h0m0s" || st.RetentionDays != 5 || st.RateLimitKiB != 2048 {
132
t.Fatalf("niet toegepast: %+v", st)
133
}
134
if msg := u.Act("config.update", url.Values{"archive_interval": {"nooit"}}); !strings.Contains(msg, "mislukt") {
135
t.Fatalf("ongeldige waarde: %q", msg)
136
}
137
u.Act("config.update", url.Values{"rate_limit_kib": {"0"}})
138
139
// Koppelen met een key uit BlueGit.
140
if msg := u.Act("connect", url.Values{"url": {g.URL}, "key": {"bgbk_fout"}, "on_conflict": {""}}); !strings.Contains(msg, "mislukt") {
141
t.Fatalf("verkeerde key: %q", msg)
142
}
143
if msg := u.Act("connect", url.Values{"url": {g.URL}, "key": {g.NewKey()}, "on_conflict": {""}}); !strings.Contains(msg, "gelukt") {
144
t.Fatalf("koppelen: %q", msg)
145
}
146
done["connect"] = true
147
if st := g.BackupStatus(); !st.Connected || st.ServerURL != b.URL {
148
t.Fatalf("BlueGit ziet de koppeling niet: %+v", st)
149
}
150
151
// Sync, archief, opruimen.
152
if msg := u.Act("sync", nil); !strings.Contains(msg, "gestart") {
153
t.Fatalf("sync: %q", msg)
154
}
155
done["sync"] = true
156
Eventually(t, 15*time.Second, "kopie na sync uit de webinterface", func() bool {
157
_, err := os.Stat(b.Mirror("data/repos/tim/alpha.git/HEAD"))
158
return err == nil
159
})
160
b.Sync()
161
if msg := u.Act("archive", nil); !strings.Contains(msg, "Archief gemaakt") {
162
t.Fatalf("archief: %q", msg)
163
}
164
done["archive"] = true
165
name := b.Archives()[0]
166
page := u.Page()
167
if !strings.Contains(page, name) || !strings.Contains(page, "gekoppeld") {
168
t.Fatal("pagina toont het archief of de koppeling niet")
169
}
170
// Download vanuit de pagina.
171
res, err := u.hc.Get(b.URL + "/api/v1/admin/archives/" + name + "/download")
172
if err != nil {
173
t.Fatal(err)
174
}
175
got, _ := io.ReadAll(res.Body)
176
res.Body.Close()
177
want, _ := os.ReadFile(filepath.Join(b.Dir, "archives", name))
178
if res.StatusCode != 200 || len(got) == 0 || string(got) != string(want) {
179
t.Fatalf("download: %d %d bytes", res.StatusCode, len(got))
180
}
181
if msg := u.Act("prune", nil); !strings.Contains(msg, "Opgeruimd") {
182
t.Fatalf("opruimen: %q", msg)
183
}
184
done["prune"] = true
185
186
// Rollback vanuit de webinterface: zonder vinkje niets, daarna echt.
187
g.Commit("alpha", "README.md", "v2", "update")
188
b.Sync()
189
if msg := u.Act("rollback", url.Values{"archive": {name}, "confirm": {name}}); !strings.Contains(msg, "Vink aan") {
190
t.Fatalf("zonder vinkje: %q", msg)
191
}
192
if msg := u.Act("rollback", url.Values{"archive": {name}, "confirm": {"verkeerd"}, "understood": {"1"}}); !strings.Contains(msg, "mislukt") {
193
t.Fatalf("verkeerde bevestiging: %q", msg)
194
}
195
if msg := u.Act("rollback", url.Values{"archive": {name}, "confirm": {name}, "understood": {"1"}}); !strings.Contains(msg, "Rollback gestart") {
196
t.Fatalf("rollback: %q", msg)
197
}
198
done["rollback"] = true
199
Eventually(t, 60*time.Second, "rollback klaar", func() bool {
200
st := b.Status().Rollback
201
if st.State == "failed" {
202
t.Fatalf("rollback mislukt: %s", st.Error)
203
}
204
return st.State == "done"
205
})
206
g.WaitUp(30 * time.Second)
207
if _, s := g.File("alpha", "README.md"); s != "v1" {
208
t.Fatalf("README na rollback: %q", s)
209
}
210
211
// Archief verwijderen en ontkoppelen.
212
if msg := u.Act("archive.delete", url.Values{"name": {name}}); !strings.Contains(msg, "gelukt") {
213
t.Fatalf("verwijderen: %q", msg)
214
}
215
done["archive.delete"] = true
216
if len(b.Archives()) != 0 {
217
t.Fatal("archief staat er nog")
218
}
219
if msg := u.Act("disconnect", nil); !strings.Contains(msg, "gelukt") {
220
t.Fatalf("ontkoppelen: %q", msg)
221
}
222
done["disconnect"] = true
223
if b.Status().Connected {
224
t.Fatal("nog gekoppeld")
225
}
226
requireAll(t, "webinterface", actionNames(t, b, false), done)
227
}
228
229
// Feature: de API kan alles wat de webinterface kan, en andersom.
230
func TestAPIDoesEverythingTheUICan(t *testing.T) {
231
g := startBlueGit(t)
232
g.Project("Alpha", "README.md", "v1")
233
b := startBackup(t, nil)
234
done := map[string]bool{}
235
call := func(name, method, path string, in any, want int) []byte {
236
t.Helper()
237
code, raw := b.Admin(method, path, in)
238
if code != want {
239
t.Fatalf("%s %s: %d %s", method, path, code, raw)
240
}
241
done[name] = true
242
return raw
243
}
244
call("status", "GET", "/status", nil, 200)
245
call("actions", "GET", "/actions", nil, 200)
246
raw := call("config", "GET", "/config", nil, 200)
247
if !strings.Contains(string(raw), `"key":"listen"`) {
248
t.Fatalf("config: %s", raw)
249
}
250
call("config.update", "PUT", "/config", map[string]any{"retention_days": 7, "archive_interval": "6h"}, 200)
251
if b.Status().RetentionDays != 7 {
252
t.Fatal("config niet toegepast")
253
}
254
call("connect", "POST", "/connect", map[string]any{"url": g.URL, "key": g.NewKey()}, 200)
255
call("sync", "POST", "/sync", nil, 200)
256
raw = call("archive", "POST", "/archive", nil, 201)
257
var a struct{ Name string }
258
_ = json.Unmarshal(raw, &a)
259
raw = call("archives", "GET", "/archives", nil, 200)
260
if !strings.Contains(string(raw), a.Name) {
261
t.Fatalf("archives: %s", raw)
262
}
263
raw = call("archive.download", "GET", "/archives/"+a.Name+"/download", nil, 200)
264
if len(raw) < 100 || raw[0] != 0x1f || raw[1] != 0x8b {
265
t.Fatal("download is geen gzip")
266
}
267
call("prune", "POST", "/prune", nil, 200)
268
call("rollback", "POST", "/rollback", map[string]any{"archive": a.Name}, 400) // bevestiging ontbreekt
269
call("rollback", "POST", "/rollback", map[string]any{"archive": a.Name, "confirm": a.Name}, 202)
270
Eventually(t, 60*time.Second, "rollback klaar", func() bool { return b.Status().Rollback.State == "done" })
271
g.WaitUp(30 * time.Second)
272
call("archive.delete", "DELETE", "/archives/"+a.Name, nil, 200)
273
call("disconnect", "POST", "/disconnect", nil, 200)
274
requireAll(t, "API", actionNames(t, b, true), done)
275
}
276
277
// Feature: vanuit BlueGit is de backup server te bedienen zoals in zijn eigen webinterface.
278
func TestBlueGitControlsBackupServer(t *testing.T) {
279
g := startBlueGit(t)
280
g.Project("Alpha", "README.md", "v1")
281
b := startBackup(t, nil)
282
b.Connect(g, g.NewKey())
283
b.Sync()
284
285
// Instellingen lezen en wijzigen via de BlueGit-API.
286
st := g.BackupStatus()
287
if len(st.Config.Fields) == 0 {
288
t.Fatalf("BlueGit ziet geen instellingen: %+v", st)
289
}
290
if code, raw := g.Action(g.Server, "config.update", map[string]any{"retention_days": "11", "archive_interval": "5h"}); code != 200 {
291
t.Fatalf("config via BlueGit: %d %s", code, raw)
292
}
293
if s := b.Status(); s.RetentionDays != 11 || s.Interval != "5h0m0s" {
294
t.Fatalf("niet toegepast: %+v", s)
295
}
296
// Archief maken, synchroniseren en verwijderen via BlueGit.
297
if code, raw := g.Action(g.Server, "archive", nil); code != 201 {
298
t.Fatalf("archief via BlueGit: %d %s", code, raw)
299
}
300
name := b.Archives()[0]
301
g.Commit("alpha", "x.txt", "x", "create")
302
before := b.Status().Syncs
303
if code, raw := g.Action(g.Server, "sync", nil); code != 202 {
304
t.Fatalf("sync via BlueGit: %d %s", code, raw)
305
}
306
Eventually(t, 15*time.Second, "sync gestart door BlueGit", func() bool { return b.Status().Syncs > before })
307
if code, raw := g.Action(g.Server, "archive.delete", map[string]any{"name": name}); code != 200 {
308
t.Fatalf("verwijderen via BlueGit: %d %s", code, raw)
309
}
310
if len(b.Archives()) != 0 {
311
t.Fatal("archief niet verwijderd")
312
}
313
// Koppelen kan BlueGit niet namens de backup server (alleen lokaal).
314
if code, _ := g.Action(g.Server, "connect", map[string]any{"url": g.URL, "key": "bgbk_x"}); code != 404 {
315
t.Fatalf("connect via BlueGit: %d", code)
316
}
317
318
// Dezelfde bediening in de BlueGit-webinterface.
319
hc := g.Session()
320
hc.CheckRedirect = func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }
321
res, err := hc.Get(g.URL + "/admin/backup/s/" + g.Server)
322
if err != nil {
323
t.Fatal(err)
324
}
325
page, _ := io.ReadAll(res.Body)
326
res.Body.Close()
327
for _, want := range []string{`name="retention_days" value="11"`, "/act/sync", "/act/archive", "/act/prune", "/act/config.update"} {
328
if !strings.Contains(string(page), want) {
329
t.Fatalf("BlueGit-pagina mist %q", want)
330
}
331
}
332
csrf := between(string(page), `name="csrf" value="`, `"`)
333
res, err = hc.PostForm(g.URL+"/admin/backup/s/"+g.Server+"/act/config.update", url.Values{"csrf": {csrf}, "retention_days": {"12"}})
334
if err != nil {
335
t.Fatal(err)
336
}
337
res.Body.Close()
338
if b.Status().RetentionDays != 12 {
339
t.Fatalf("formulier in BlueGit: %d", b.Status().RetentionDays)
340
}
341
res, _ = hc.PostForm(g.URL+"/admin/backup/s/"+g.Server+"/act/archive", url.Values{"csrf": {csrf}})
342
res.Body.Close()
343
if len(b.Archives()) != 1 {
344
t.Fatal("archief via het BlueGit-formulier ontbreekt")
345
}
346
}
347
348
// Feature: één BlueGit kan meerdere backup servers hebben; elke backup server hoort bij één BlueGit.
349
func TestMultipleBackupServers(t *testing.T) {
350
g := startBlueGit(t)
351
g.Project("Alpha", "README.md", "v1")
352
b1, b2 := startBackup(t, nil), startBackup(t, nil)
353
id1, key1 := g.AddServer("nas")
354
id2, key2 := g.AddServer("offsite")
355
b1.Connect(g, key1)
356
b2.Connect(g, key2)
357
for _, id := range []string{id1, id2} {
358
if st := g.ServerStatus(id); !st.Connected || st.RemoteError != "" {
359
t.Fatalf("%s: %+v", id, st)
360
}
361
}
362
if g.ServerStatus(id1).ServerURL != b1.URL || g.ServerStatus(id2).ServerURL != b2.URL {
363
t.Fatal("adressen verwisseld")
364
}
365
// Elke wijziging komt bij beide aan.
366
g.Commit("alpha", "beide.txt", "x", "create")
367
for _, b := range []*Backup{b1, b2} {
368
Eventually(t, 15*time.Second, "melding bij "+b.URL, func() bool {
369
return strings.Contains(gitLog(t, b.Mirror("data/repos/tim/alpha.git")), "zet beide.txt")
370
})
371
}
372
// Een key hoort bij één server: key1 werkt niet voor de tweede server.
373
b3 := startBackup(t, nil)
374
b3.Connect(g, key1) // dezelfde key: BlueGit verplaatst de koppeling van nas naar b3
375
if st := g.ServerStatus(id1); st.ServerURL != b3.URL {
376
t.Fatalf("koppeling niet verplaatst: %+v", st)
377
}
378
// Verwijderen in BlueGit ontkoppelt alleen die server.
379
if code, raw := g.API("DELETE", "/admin/backup/servers/"+id2, nil); code != 204 {
380
t.Fatalf("verwijderen: %d %s", code, raw)
381
}
382
if b2.Status().Connected {
383
t.Fatal("verwijderde backup server is nog gekoppeld")
384
}
385
g.Commit("alpha", "daarna.txt", "x", "create")
386
Eventually(t, 15*time.Second, "overgebleven server krijgt meldingen", func() bool {
387
return strings.Contains(gitLog(t, b3.Mirror("data/repos/tim/alpha.git")), "zet daarna.txt")
388
})
389
time.Sleep(time.Second)
390
if strings.Contains(gitLog(t, b2.Mirror("data/repos/tim/alpha.git")), "zet daarna.txt") {
391
t.Fatal("verwijderde server synchroniseert nog")
392
}
393
// Een backup server hoort bij één BlueGit: koppelen aan een andere vraagt om een keuze.
394
other := startBlueGit(t)
395
code, raw := b3.Admin("POST", "/connect", map[string]any{"url": other.URL, "key": other.NewKey()})
396
if code != 409 || !strings.Contains(string(raw), `"choices":["wipe","restore"]`) {
397
t.Fatalf("tweede BlueGit: %d %s", code, raw)
398
}
399
}
@@ -0,0 +1,399 @@1
//go:build integration2
3
package integration4
5
import (6
"encoding/json"7
"io"8
"net/http"9
"net/http/cookiejar"10
"net/url"11
"os"12
"path/filepath"13
"sort"14
"strings"15
"testing"16
"time"17
)18
19
// webUI is een browser op de webinterface van de backup server.20
type webUI struct {21
t *testing.T22
b *Backup23
hc *http.Client24
csrf string25
}26
27
func openUI(t *testing.T, b *Backup) *webUI {28
t.Helper()29
jar, _ := cookiejar.New(nil)30
u := &webUI{t: t, b: b, hc: &http.Client{Jar: jar, CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }}}31
res, err := u.hc.Get(b.URL + "/")32
if err != nil {33
t.Fatal(err)34
}35
res.Body.Close()36
if res.StatusCode != 303 || res.Header.Get("Location") != "/login" {37
t.Fatalf("zonder login: %d %s", res.StatusCode, res.Header.Get("Location"))38
}39
res, _ = u.hc.PostForm(b.URL+"/login", url.Values{"token": {"bba_fout"}})40
res.Body.Close()41
if res.Header.Get("Location") != "/login?fout=1" {42
t.Fatal("fout token geaccepteerd")43
}44
res, _ = u.hc.PostForm(b.URL+"/login", url.Values{"token": {b.Srv.AdminToken()}})45
res.Body.Close()46
if res.StatusCode != 303 || res.Header.Get("Location") != "/" {47
t.Fatalf("login: %d", res.StatusCode)48
}49
u.Page()50
return u51
}52
53
// Page haalt de hoofdpagina op en onthoudt het CSRF-token.54
func (u *webUI) Page() string {55
u.t.Helper()56
res, err := u.hc.Get(u.b.URL + "/")57
if err != nil {58
u.t.Fatal(err)59
}60
b, _ := io.ReadAll(res.Body)61
res.Body.Close()62
if res.StatusCode != 200 {63
u.t.Fatalf("pagina: %d", res.StatusCode)64
}65
u.csrf = between(string(b), `name="csrf" value="`, `"`)66
return string(b)67
}68
69
// Act verstuurt het formulier van een actie en geeft de melding erna.70
func (u *webUI) Act(name string, form url.Values) string {71
u.t.Helper()72
if form == nil {73
form = url.Values{}74
}75
form.Set("csrf", u.csrf)76
res, err := u.hc.PostForm(u.b.URL+"/ui/act/"+name, form)77
if err != nil {78
u.t.Fatal(err)79
}80
res.Body.Close()81
if res.StatusCode != 303 {82
u.t.Fatalf("%s: %d", name, res.StatusCode)83
}84
return between(u.Page(), `role="status">`, `</div>`)85
}86
87
func actionNames(t *testing.T, b *Backup, withGet bool) []string {88
t.Helper()89
code, raw := b.Admin("GET", "/actions", nil)90
if code != 200 {91
t.Fatalf("actions: %d", code)92
}93
var out struct {94
Actions []struct{ Name, Method string }95
}96
_ = json.Unmarshal(raw, &out)97
var names []string98
for _, a := range out.Actions {99
if withGet || a.Method != "GET" {100
names = append(names, a.Name)101
}102
}103
sort.Strings(names)104
return names105
}106
107
func requireAll(t *testing.T, what string, want []string, done map[string]bool) {108
t.Helper()109
for _, n := range want {110
if !done[n] {111
t.Errorf("%s: actie %s niet getest", what, n)112
}113
}114
}115
116
// Feature: alles is in te stellen en te bedienen via de webinterface (poort 8080 standaard).117
func TestWebUIConfiguresAndOperatesEverything(t *testing.T) {118
g := startBlueGit(t)119
g.Project("Alpha", "README.md", "v1")120
b := startBackup(t, nil)121
u := openUI(t, b)122
done := map[string]bool{}123
124
// Instellingen.125
msg := u.Act("config.update", url.Values{"archive_interval": {"3h"}, "retention_days": {"5"}, "rate_limit_kib": {"2048"}, "min_free_mb": {"2"}, "full_sync_interval": {"2h"}, "min_sync_interval": {"1s"}, "public_url": {b.URL}, "listen": {b.Cfg.Listen}})126
if !strings.Contains(msg, "opgeslagen") {127
t.Fatalf("instellingen: %q", msg)128
}129
done["config.update"] = true130
st := b.Status()131
if st.Interval != "3h0m0s" || st.RetentionDays != 5 || st.RateLimitKiB != 2048 {132
t.Fatalf("niet toegepast: %+v", st)133
}134
if msg := u.Act("config.update", url.Values{"archive_interval": {"nooit"}}); !strings.Contains(msg, "mislukt") {135
t.Fatalf("ongeldige waarde: %q", msg)136
}137
u.Act("config.update", url.Values{"rate_limit_kib": {"0"}})138
139
// Koppelen met een key uit BlueGit.140
if msg := u.Act("connect", url.Values{"url": {g.URL}, "key": {"bgbk_fout"}, "on_conflict": {""}}); !strings.Contains(msg, "mislukt") {141
t.Fatalf("verkeerde key: %q", msg)142
}143
if msg := u.Act("connect", url.Values{"url": {g.URL}, "key": {g.NewKey()}, "on_conflict": {""}}); !strings.Contains(msg, "gelukt") {144
t.Fatalf("koppelen: %q", msg)145
}146
done["connect"] = true147
if st := g.BackupStatus(); !st.Connected || st.ServerURL != b.URL {148
t.Fatalf("BlueGit ziet de koppeling niet: %+v", st)149
}150
151
// Sync, archief, opruimen.152
if msg := u.Act("sync", nil); !strings.Contains(msg, "gestart") {153
t.Fatalf("sync: %q", msg)154
}155
done["sync"] = true156
Eventually(t, 15*time.Second, "kopie na sync uit de webinterface", func() bool {157
_, err := os.Stat(b.Mirror("data/repos/tim/alpha.git/HEAD"))158
return err == nil159
})160
b.Sync()161
if msg := u.Act("archive", nil); !strings.Contains(msg, "Archief gemaakt") {162
t.Fatalf("archief: %q", msg)163
}164
done["archive"] = true165
name := b.Archives()[0]166
page := u.Page()167
if !strings.Contains(page, name) || !strings.Contains(page, "gekoppeld") {168
t.Fatal("pagina toont het archief of de koppeling niet")169
}170
// Download vanuit de pagina.171
res, err := u.hc.Get(b.URL + "/api/v1/admin/archives/" + name + "/download")172
if err != nil {173
t.Fatal(err)174
}175
got, _ := io.ReadAll(res.Body)176
res.Body.Close()177
want, _ := os.ReadFile(filepath.Join(b.Dir, "archives", name))178
if res.StatusCode != 200 || len(got) == 0 || string(got) != string(want) {179
t.Fatalf("download: %d %d bytes", res.StatusCode, len(got))180
}181
if msg := u.Act("prune", nil); !strings.Contains(msg, "Opgeruimd") {182
t.Fatalf("opruimen: %q", msg)183
}184
done["prune"] = true185
186
// Rollback vanuit de webinterface: zonder vinkje niets, daarna echt.187
g.Commit("alpha", "README.md", "v2", "update")188
b.Sync()189
if msg := u.Act("rollback", url.Values{"archive": {name}, "confirm": {name}}); !strings.Contains(msg, "Vink aan") {190
t.Fatalf("zonder vinkje: %q", msg)191
}192
if msg := u.Act("rollback", url.Values{"archive": {name}, "confirm": {"verkeerd"}, "understood": {"1"}}); !strings.Contains(msg, "mislukt") {193
t.Fatalf("verkeerde bevestiging: %q", msg)194
}195
if msg := u.Act("rollback", url.Values{"archive": {name}, "confirm": {name}, "understood": {"1"}}); !strings.Contains(msg, "Rollback gestart") {196
t.Fatalf("rollback: %q", msg)197
}198
done["rollback"] = true199
Eventually(t, 60*time.Second, "rollback klaar", func() bool {200
st := b.Status().Rollback201
if st.State == "failed" {202
t.Fatalf("rollback mislukt: %s", st.Error)203
}204
return st.State == "done"205
})206
g.WaitUp(30 * time.Second)207
if _, s := g.File("alpha", "README.md"); s != "v1" {208
t.Fatalf("README na rollback: %q", s)209
}210
211
// Archief verwijderen en ontkoppelen.212
if msg := u.Act("archive.delete", url.Values{"name": {name}}); !strings.Contains(msg, "gelukt") {213
t.Fatalf("verwijderen: %q", msg)214
}215
done["archive.delete"] = true216
if len(b.Archives()) != 0 {217
t.Fatal("archief staat er nog")218
}219
if msg := u.Act("disconnect", nil); !strings.Contains(msg, "gelukt") {220
t.Fatalf("ontkoppelen: %q", msg)221
}222
done["disconnect"] = true223
if b.Status().Connected {224
t.Fatal("nog gekoppeld")225
}226
requireAll(t, "webinterface", actionNames(t, b, false), done)227
}228
229
// Feature: de API kan alles wat de webinterface kan, en andersom.230
func TestAPIDoesEverythingTheUICan(t *testing.T) {231
g := startBlueGit(t)232
g.Project("Alpha", "README.md", "v1")233
b := startBackup(t, nil)234
done := map[string]bool{}235
call := func(name, method, path string, in any, want int) []byte {236
t.Helper()237
code, raw := b.Admin(method, path, in)238
if code != want {239
t.Fatalf("%s %s: %d %s", method, path, code, raw)240
}241
done[name] = true242
return raw243
}244
call("status", "GET", "/status", nil, 200)245
call("actions", "GET", "/actions", nil, 200)246
raw := call("config", "GET", "/config", nil, 200)247
if !strings.Contains(string(raw), `"key":"listen"`) {248
t.Fatalf("config: %s", raw)249
}250
call("config.update", "PUT", "/config", map[string]any{"retention_days": 7, "archive_interval": "6h"}, 200)251
if b.Status().RetentionDays != 7 {252
t.Fatal("config niet toegepast")253
}254
call("connect", "POST", "/connect", map[string]any{"url": g.URL, "key": g.NewKey()}, 200)255
call("sync", "POST", "/sync", nil, 200)256
raw = call("archive", "POST", "/archive", nil, 201)257
var a struct{ Name string }258
_ = json.Unmarshal(raw, &a)259
raw = call("archives", "GET", "/archives", nil, 200)260
if !strings.Contains(string(raw), a.Name) {261
t.Fatalf("archives: %s", raw)262
}263
raw = call("archive.download", "GET", "/archives/"+a.Name+"/download", nil, 200)264
if len(raw) < 100 || raw[0] != 0x1f || raw[1] != 0x8b {265
t.Fatal("download is geen gzip")266
}267
call("prune", "POST", "/prune", nil, 200)268
call("rollback", "POST", "/rollback", map[string]any{"archive": a.Name}, 400) // bevestiging ontbreekt269
call("rollback", "POST", "/rollback", map[string]any{"archive": a.Name, "confirm": a.Name}, 202)270
Eventually(t, 60*time.Second, "rollback klaar", func() bool { return b.Status().Rollback.State == "done" })271
g.WaitUp(30 * time.Second)272
call("archive.delete", "DELETE", "/archives/"+a.Name, nil, 200)273
call("disconnect", "POST", "/disconnect", nil, 200)274
requireAll(t, "API", actionNames(t, b, true), done)275
}276
277
// Feature: vanuit BlueGit is de backup server te bedienen zoals in zijn eigen webinterface.278
func TestBlueGitControlsBackupServer(t *testing.T) {279
g := startBlueGit(t)280
g.Project("Alpha", "README.md", "v1")281
b := startBackup(t, nil)282
b.Connect(g, g.NewKey())283
b.Sync()284
285
// Instellingen lezen en wijzigen via de BlueGit-API.286
st := g.BackupStatus()287
if len(st.Config.Fields) == 0 {288
t.Fatalf("BlueGit ziet geen instellingen: %+v", st)289
}290
if code, raw := g.Action(g.Server, "config.update", map[string]any{"retention_days": "11", "archive_interval": "5h"}); code != 200 {291
t.Fatalf("config via BlueGit: %d %s", code, raw)292
}293
if s := b.Status(); s.RetentionDays != 11 || s.Interval != "5h0m0s" {294
t.Fatalf("niet toegepast: %+v", s)295
}296
// Archief maken, synchroniseren en verwijderen via BlueGit.297
if code, raw := g.Action(g.Server, "archive", nil); code != 201 {298
t.Fatalf("archief via BlueGit: %d %s", code, raw)299
}300
name := b.Archives()[0]301
g.Commit("alpha", "x.txt", "x", "create")302
before := b.Status().Syncs303
if code, raw := g.Action(g.Server, "sync", nil); code != 202 {304
t.Fatalf("sync via BlueGit: %d %s", code, raw)305
}306
Eventually(t, 15*time.Second, "sync gestart door BlueGit", func() bool { return b.Status().Syncs > before })307
if code, raw := g.Action(g.Server, "archive.delete", map[string]any{"name": name}); code != 200 {308
t.Fatalf("verwijderen via BlueGit: %d %s", code, raw)309
}310
if len(b.Archives()) != 0 {311
t.Fatal("archief niet verwijderd")312
}313
// Koppelen kan BlueGit niet namens de backup server (alleen lokaal).314
if code, _ := g.Action(g.Server, "connect", map[string]any{"url": g.URL, "key": "bgbk_x"}); code != 404 {315
t.Fatalf("connect via BlueGit: %d", code)316
}317
318
// Dezelfde bediening in de BlueGit-webinterface.319
hc := g.Session()320
hc.CheckRedirect = func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }321
res, err := hc.Get(g.URL + "/admin/backup/s/" + g.Server)322
if err != nil {323
t.Fatal(err)324
}325
page, _ := io.ReadAll(res.Body)326
res.Body.Close()327
for _, want := range []string{`name="retention_days" value="11"`, "/act/sync", "/act/archive", "/act/prune", "/act/config.update"} {328
if !strings.Contains(string(page), want) {329
t.Fatalf("BlueGit-pagina mist %q", want)330
}331
}332
csrf := between(string(page), `name="csrf" value="`, `"`)333
res, err = hc.PostForm(g.URL+"/admin/backup/s/"+g.Server+"/act/config.update", url.Values{"csrf": {csrf}, "retention_days": {"12"}})334
if err != nil {335
t.Fatal(err)336
}337
res.Body.Close()338
if b.Status().RetentionDays != 12 {339
t.Fatalf("formulier in BlueGit: %d", b.Status().RetentionDays)340
}341
res, _ = hc.PostForm(g.URL+"/admin/backup/s/"+g.Server+"/act/archive", url.Values{"csrf": {csrf}})342
res.Body.Close()343
if len(b.Archives()) != 1 {344
t.Fatal("archief via het BlueGit-formulier ontbreekt")345
}346
}347
348
// Feature: één BlueGit kan meerdere backup servers hebben; elke backup server hoort bij één BlueGit.349
func TestMultipleBackupServers(t *testing.T) {350
g := startBlueGit(t)351
g.Project("Alpha", "README.md", "v1")352
b1, b2 := startBackup(t, nil), startBackup(t, nil)353
id1, key1 := g.AddServer("nas")354
id2, key2 := g.AddServer("offsite")355
b1.Connect(g, key1)356
b2.Connect(g, key2)357
for _, id := range []string{id1, id2} {358
if st := g.ServerStatus(id); !st.Connected || st.RemoteError != "" {359
t.Fatalf("%s: %+v", id, st)360
}361
}362
if g.ServerStatus(id1).ServerURL != b1.URL || g.ServerStatus(id2).ServerURL != b2.URL {363
t.Fatal("adressen verwisseld")364
}365
// Elke wijziging komt bij beide aan.366
g.Commit("alpha", "beide.txt", "x", "create")367
for _, b := range []*Backup{b1, b2} {368
Eventually(t, 15*time.Second, "melding bij "+b.URL, func() bool {369
return strings.Contains(gitLog(t, b.Mirror("data/repos/tim/alpha.git")), "zet beide.txt")370
})371
}372
// Een key hoort bij één server: key1 werkt niet voor de tweede server.373
b3 := startBackup(t, nil)374
b3.Connect(g, key1) // dezelfde key: BlueGit verplaatst de koppeling van nas naar b3375
if st := g.ServerStatus(id1); st.ServerURL != b3.URL {376
t.Fatalf("koppeling niet verplaatst: %+v", st)377
}378
// Verwijderen in BlueGit ontkoppelt alleen die server.379
if code, raw := g.API("DELETE", "/admin/backup/servers/"+id2, nil); code != 204 {380
t.Fatalf("verwijderen: %d %s", code, raw)381
}382
if b2.Status().Connected {383
t.Fatal("verwijderde backup server is nog gekoppeld")384
}385
g.Commit("alpha", "daarna.txt", "x", "create")386
Eventually(t, 15*time.Second, "overgebleven server krijgt meldingen", func() bool {387
return strings.Contains(gitLog(t, b3.Mirror("data/repos/tim/alpha.git")), "zet daarna.txt")388
})389
time.Sleep(time.Second)390
if strings.Contains(gitLog(t, b2.Mirror("data/repos/tim/alpha.git")), "zet daarna.txt") {391
t.Fatal("verwijderde server synchroniseert nog")392
}393
// Een backup server hoort bij één BlueGit: koppelen aan een andere vraagt om een keuze.394
other := startBlueGit(t)395
code, raw := b3.Admin("POST", "/connect", map[string]any{"url": other.URL, "key": other.NewKey()})396
if code != 409 || !strings.Contains(string(raw), `"choices":["wipe","restore"]`) {397
t.Fatalf("tweede BlueGit: %d %s", code, raw)398
}399
}@@ -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,161 @@
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
// Version gaat mee in de X-Backup-koppen.
30
Version string
31
// OnPeer krijgt het protocol van BlueGit uit elk antwoord dat het meldt.
32
OnPeer func(protocol.Peer)
33
}
34
35
func (r *Remote) client() *http.Client {
36
if r.HTTP != nil {
37
return r.HTTP
38
}
39
return &http.Client{Timeout: 0}
40
}
41
42
func (r *Remote) req(ctx context.Context, method, p string, body io.Reader) (*http.Response, error) {
43
req, err := http.NewRequestWithContext(ctx, method, strings.TrimRight(r.URL, "/")+p, body)
44
if err != nil {
45
return nil, err
46
}
47
req.Header.Set("Authorization", "Bearer "+r.Key)
48
req.Header.Set("User-Agent", "bluegit-backup")
49
protocol.SetOwnHeaders(req.Header, r.Version)
50
resp, err := r.client().Do(req)
51
if err != nil {
52
return nil, err
53
}
54
if p, ok := protocol.BlueGitFromHeader(resp.Header); ok && r.OnPeer != nil {
55
r.OnPeer(p)
56
}
57
if resp.StatusCode >= 300 {
58
defer resp.Body.Close()
59
raw, _ := io.ReadAll(io.LimitReader(resp.Body, 1<<16))
60
var e struct {
61
Error string `json:"error"`
62
}
63
_ = json.Unmarshal(raw, &e)
64
if e.Error == "" {
65
e.Error = strings.TrimSpace(string(raw))
66
}
67
if resp.StatusCode == http.StatusNotFound && strings.HasPrefix(p, "/api/v1/backup/file") {
68
return nil, ErrGone
69
}
70
return nil, &HTTPError{Status: resp.StatusCode, Msg: e.Error}
71
}
72
return resp, nil
73
}
74
75
// HTTPError is een foutantwoord van BlueGit.
76
type HTTPError struct {
77
Status int
78
Msg string
79
}
80
81
func (e *HTTPError) Error() string { return fmt.Sprintf("BlueGit HTTP %d: %s", e.Status, e.Msg) }
82
83
func (r *Remote) getJSON(ctx context.Context, p string, out any) error {
84
resp, err := r.req(ctx, http.MethodGet, p, nil)
85
if err != nil {
86
return err
87
}
88
defer resp.Body.Close()
89
return json.NewDecoder(resp.Body).Decode(out)
90
}
91
92
// Info vraagt het instance-id op en controleert zo ook de key.
93
func (r *Remote) Info(ctx context.Context) (protocol.Info, error) {
94
var out protocol.Info
95
err := r.getJSON(ctx, "/api/v1/backup/info", &out)
96
return out, err
97
}
98
99
// Connect vertelt BlueGit waar deze server bereikbaar is.
100
func (r *Remote) Connect(ctx context.Context, publicURL, serverID string) error {
101
b, _ := json.Marshal(map[string]string{"server_url": publicURL, "server_id": serverID})
102
resp, err := r.req(ctx, http.MethodPost, "/api/v1/backup/connect", bytes.NewReader(b))
103
if err != nil {
104
return err
105
}
106
resp.Body.Close()
107
return nil
108
}
109
110
// Manifest vraagt de volledige lijst op. BlueGit maakt daarbij een nieuwe
111
// databasekopie.
112
func (r *Remote) Manifest(ctx context.Context) (protocol.Manifest, error) {
113
var out protocol.Manifest
114
err := r.getJSON(ctx, "/api/v1/backup/manifest", &out)
115
return out, err
116
}
117
118
// Fetch opent één bestand, begrensd door de limiter.
119
func (r *Remote) Fetch(ctx context.Context, logical string) (io.ReadCloser, error) {
120
resp, err := r.req(ctx, http.MethodGet, "/api/v1/backup/file?path="+url.QueryEscape(logical), nil)
121
if err != nil {
122
return nil, err
123
}
124
return struct {
125
io.Reader
126
io.Closer
127
}{r.Limiter.Reader(ctx, resp.Body), resp.Body}, nil
128
}
129
130
// Restore stuurt een tar.gz naar BlueGit. BlueGit herstart daarna.
131
func (r *Remote) Restore(ctx context.Context, body io.Reader) error {
132
resp, err := r.req(ctx, http.MethodPost, "/api/v1/backup/restore", body)
133
if err != nil {
134
return err
135
}
136
resp.Body.Close()
137
return nil
138
}
139
140
// WaitUp wacht tot BlueGit na een herstart weer antwoordt.
141
func (r *Remote) WaitUp(ctx context.Context, timeout time.Duration) error {
142
deadline := time.Now().Add(timeout)
143
// Eerst kort wachten: BlueGit herstart pas na zijn 202.
144
time.Sleep(500 * time.Millisecond)
145
for {
146
c, cancel := context.WithTimeout(ctx, 3*time.Second)
147
_, err := r.Info(c)
148
cancel()
149
if err == nil {
150
return nil
151
}
152
if time.Now().After(deadline) {
153
return fmt.Errorf("BlueGit kwam niet terug: %w", err)
154
}
155
select {
156
case <-ctx.Done():
157
return ctx.Err()
158
case <-time.After(300 * time.Millisecond):
159
}
160
}
161
}
@@ -0,0 +1,161 @@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
// Version gaat mee in de X-Backup-koppen.30
Version string31
// OnPeer krijgt het protocol van BlueGit uit elk antwoord dat het meldt.32
OnPeer func(protocol.Peer)33
}34
35
func (r *Remote) client() *http.Client {36
if r.HTTP != nil {37
return r.HTTP38
}39
return &http.Client{Timeout: 0}40
}41
42
func (r *Remote) req(ctx context.Context, method, p string, body io.Reader) (*http.Response, error) {43
req, err := http.NewRequestWithContext(ctx, method, strings.TrimRight(r.URL, "/")+p, body)44
if err != nil {45
return nil, err46
}47
req.Header.Set("Authorization", "Bearer "+r.Key)48
req.Header.Set("User-Agent", "bluegit-backup")49
protocol.SetOwnHeaders(req.Header, r.Version)50
resp, err := r.client().Do(req)51
if err != nil {52
return nil, err53
}54
if p, ok := protocol.BlueGitFromHeader(resp.Header); ok && r.OnPeer != nil {55
r.OnPeer(p)56
}57
if resp.StatusCode >= 300 {58
defer resp.Body.Close()59
raw, _ := io.ReadAll(io.LimitReader(resp.Body, 1<<16))60
var e struct {61
Error string `json:"error"`62
}63
_ = json.Unmarshal(raw, &e)64
if e.Error == "" {65
e.Error = strings.TrimSpace(string(raw))66
}67
if resp.StatusCode == http.StatusNotFound && strings.HasPrefix(p, "/api/v1/backup/file") {68
return nil, ErrGone69
}70
return nil, &HTTPError{Status: resp.StatusCode, Msg: e.Error}71
}72
return resp, nil73
}74
75
// HTTPError is een foutantwoord van BlueGit.76
type HTTPError struct {77
Status int78
Msg string79
}80
81
func (e *HTTPError) Error() string { return fmt.Sprintf("BlueGit HTTP %d: %s", e.Status, e.Msg) }82
83
func (r *Remote) getJSON(ctx context.Context, p string, out any) error {84
resp, err := r.req(ctx, http.MethodGet, p, nil)85
if err != nil {86
return err87
}88
defer resp.Body.Close()89
return json.NewDecoder(resp.Body).Decode(out)90
}91
92
// Info vraagt het instance-id op en controleert zo ook de key.93
func (r *Remote) Info(ctx context.Context) (protocol.Info, error) {94
var out protocol.Info95
err := r.getJSON(ctx, "/api/v1/backup/info", &out)96
return out, err97
}98
99
// Connect vertelt BlueGit waar deze server bereikbaar is.100
func (r *Remote) Connect(ctx context.Context, publicURL, serverID string) error {101
b, _ := json.Marshal(map[string]string{"server_url": publicURL, "server_id": serverID})102
resp, err := r.req(ctx, http.MethodPost, "/api/v1/backup/connect", bytes.NewReader(b))103
if err != nil {104
return err105
}106
resp.Body.Close()107
return nil108
}109
110
// Manifest vraagt de volledige lijst op. BlueGit maakt daarbij een nieuwe111
// databasekopie.112
func (r *Remote) Manifest(ctx context.Context) (protocol.Manifest, error) {113
var out protocol.Manifest114
err := r.getJSON(ctx, "/api/v1/backup/manifest", &out)115
return out, err116
}117
118
// Fetch opent één bestand, begrensd door de limiter.119
func (r *Remote) Fetch(ctx context.Context, logical string) (io.ReadCloser, error) {120
resp, err := r.req(ctx, http.MethodGet, "/api/v1/backup/file?path="+url.QueryEscape(logical), nil)121
if err != nil {122
return nil, err123
}124
return struct {125
io.Reader126
io.Closer127
}{r.Limiter.Reader(ctx, resp.Body), resp.Body}, nil128
}129
130
// Restore stuurt een tar.gz naar BlueGit. BlueGit herstart daarna.131
func (r *Remote) Restore(ctx context.Context, body io.Reader) error {132
resp, err := r.req(ctx, http.MethodPost, "/api/v1/backup/restore", body)133
if err != nil {134
return err135
}136
resp.Body.Close()137
return nil138
}139
140
// WaitUp wacht tot BlueGit na een herstart weer antwoordt.141
func (r *Remote) WaitUp(ctx context.Context, timeout time.Duration) error {142
deadline := time.Now().Add(timeout)143
// Eerst kort wachten: BlueGit herstart pas na zijn 202.144
time.Sleep(500 * time.Millisecond)145
for {146
c, cancel := context.WithTimeout(ctx, 3*time.Second)147
_, err := r.Info(c)148
cancel()149
if err == nil {150
return nil151
}152
if time.Now().After(deadline) {153
return fmt.Errorf("BlueGit kwam niet terug: %w", err)154
}155
select {156
case <-ctx.Done():157
return ctx.Err()158
case <-time.After(300 * time.Millisecond):159
}160
}161
}@@ -0,0 +1,121 @@
1
package protocol
2
3
import (
4
"net/http"
5
"strconv"
6
"strings"
7
)
8
9
// Compatibiliteit tussen BlueGit en bluegit-backup (gelijk aan
10
// internal/backup/compat.go in BlueGit).
11
//
12
// Elke kant heeft een protocolversie (wat hij zelf spreekt) en een
13
// minimumversie (de oudste versie van de andere kant die hij nog
14
// ondersteunt). Ze passen als elk de minimumversie van de ander haalt. Een
15
// kant die geen protocol meldt, spreekt protocol 1 (BlueGit vóór de
16
// protocolversie en bluegit-backup v0.1.0).
17
//
18
// Strings, zodat een test-build ze met -ldflags -X kan overschrijven; de
19
// integratietests zetten ze direct (de backup server draait in het
20
// testproces).
21
var (
22
ProtocolVersion = "1"
23
MinBlueGitProtocol = "1"
24
)
25
26
// Koppen met de protocolversie.
27
const (
28
HeaderBlueGitProtocol = "X-BlueGit-Protocol"
29
HeaderBlueGitMinProtocol = "X-BlueGit-Min-Protocol"
30
HeaderBlueGitVersion = "X-BlueGit-Version"
31
HeaderBackupProtocol = "X-Backup-Protocol"
32
HeaderBackupMinProtocol = "X-Backup-Min-Protocol"
33
HeaderBackupVersion = "X-Backup-Version"
34
)
35
36
// Uitkomsten van Compat.
37
const (
38
CompatOK = "ok"
39
CompatBlueGitTooOld = "bluegit_too_old"
40
CompatBackupTooOld = "backup_too_old"
41
)
42
43
func atoiMin1(s string) int {
44
n, err := strconv.Atoi(strings.TrimSpace(s))
45
if err != nil || n < 1 {
46
return 1
47
}
48
return n
49
}
50
51
// Protocol is de protocolversie van deze backup server.
52
func Protocol() int { return atoiMin1(ProtocolVersion) }
53
54
// MinProtocol is de oudste protocolversie van BlueGit die deze backup
55
// server ondersteunt.
56
func MinProtocol() int {
57
if m := atoiMin1(MinBlueGitProtocol); m <= Protocol() {
58
return m
59
}
60
return Protocol()
61
}
62
63
// Compat vergelijkt BlueGit (protocol, minimum voor de backup server) met
64
// een backup server (protocol, minimum voor BlueGit).
65
func Compat(bluegit, bluegitMin, backup, backupMin int) string {
66
switch {
67
case backup < bluegitMin:
68
return CompatBackupTooOld
69
case bluegit < backupMin:
70
return CompatBlueGitTooOld
71
}
72
return CompatOK
73
}
74
75
// Peer is wat BlueGit over zijn protocol zegt.
76
type Peer struct {
77
Protocol int `json:"protocol"`
78
MinProtocol int `json:"min_protocol"`
79
Version string `json:"version,omitempty"`
80
}
81
82
// Compat beoordeelt deze backup server tegen BlueGit p.
83
func (p Peer) Compat() string {
84
return Compat(atoiMin1(strconv.Itoa(p.Protocol)), atoiMin1(strconv.Itoa(p.MinProtocol)), Protocol(), MinProtocol())
85
}
86
87
// BlueGitFromHeader leest de X-BlueGit-koppen. ok is false zonder
88
// protocolkop; p is dan protocol 1.
89
func BlueGitFromHeader(h http.Header) (Peer, bool) {
90
p := Peer{Protocol: 1, MinProtocol: 1}
91
raw := h.Get(HeaderBlueGitProtocol)
92
if raw == "" {
93
return p, false
94
}
95
p.Protocol = atoiMin1(raw)
96
if m := h.Get(HeaderBlueGitMinProtocol); m != "" {
97
p.MinProtocol = atoiMin1(m)
98
}
99
p.Version = cleanVersion(h.Get(HeaderBlueGitVersion))
100
return p, true
101
}
102
103
func cleanVersion(v string) string {
104
out := make([]rune, 0, len(v))
105
for _, r := range strings.TrimSpace(v) {
106
if r > ' ' && r < 0x7f && r != '<' && r != '>' && r != '"' {
107
out = append(out, r)
108
}
109
if len(out) == 40 {
110
break
111
}
112
}
113
return string(out)
114
}
115
116
// SetOwnHeaders zet de X-Backup-koppen.
117
func SetOwnHeaders(h http.Header, version string) {
118
h.Set(HeaderBackupProtocol, strconv.Itoa(Protocol()))
119
h.Set(HeaderBackupMinProtocol, strconv.Itoa(MinProtocol()))
120
h.Set(HeaderBackupVersion, version)
121
}
@@ -0,0 +1,121 @@1
package protocol2
3
import (4
"net/http"5
"strconv"6
"strings"7
)8
9
// Compatibiliteit tussen BlueGit en bluegit-backup (gelijk aan10
// internal/backup/compat.go in BlueGit).11
//12
// Elke kant heeft een protocolversie (wat hij zelf spreekt) en een13
// minimumversie (de oudste versie van de andere kant die hij nog14
// ondersteunt). Ze passen als elk de minimumversie van de ander haalt. Een15
// kant die geen protocol meldt, spreekt protocol 1 (BlueGit vóór de16
// protocolversie en bluegit-backup v0.1.0).17
//18
// Strings, zodat een test-build ze met -ldflags -X kan overschrijven; de19
// integratietests zetten ze direct (de backup server draait in het20
// testproces).21
var (22
ProtocolVersion = "1"23
MinBlueGitProtocol = "1"24
)25
26
// Koppen met de protocolversie.27
const (28
HeaderBlueGitProtocol = "X-BlueGit-Protocol"29
HeaderBlueGitMinProtocol = "X-BlueGit-Min-Protocol"30
HeaderBlueGitVersion = "X-BlueGit-Version"31
HeaderBackupProtocol = "X-Backup-Protocol"32
HeaderBackupMinProtocol = "X-Backup-Min-Protocol"33
HeaderBackupVersion = "X-Backup-Version"34
)35
36
// Uitkomsten van Compat.37
const (38
CompatOK = "ok"39
CompatBlueGitTooOld = "bluegit_too_old"40
CompatBackupTooOld = "backup_too_old"41
)42
43
func atoiMin1(s string) int {44
n, err := strconv.Atoi(strings.TrimSpace(s))45
if err != nil || n < 1 {46
return 147
}48
return n49
}50
51
// Protocol is de protocolversie van deze backup server.52
func Protocol() int { return atoiMin1(ProtocolVersion) }53
54
// MinProtocol is de oudste protocolversie van BlueGit die deze backup55
// server ondersteunt.56
func MinProtocol() int {57
if m := atoiMin1(MinBlueGitProtocol); m <= Protocol() {58
return m59
}60
return Protocol()61
}62
63
// Compat vergelijkt BlueGit (protocol, minimum voor de backup server) met64
// een backup server (protocol, minimum voor BlueGit).65
func Compat(bluegit, bluegitMin, backup, backupMin int) string {66
switch {67
case backup < bluegitMin:68
return CompatBackupTooOld69
case bluegit < backupMin:70
return CompatBlueGitTooOld71
}72
return CompatOK73
}74
75
// Peer is wat BlueGit over zijn protocol zegt.76
type Peer struct {77
Protocol int `json:"protocol"`78
MinProtocol int `json:"min_protocol"`79
Version string `json:"version,omitempty"`80
}81
82
// Compat beoordeelt deze backup server tegen BlueGit p.83
func (p Peer) Compat() string {84
return Compat(atoiMin1(strconv.Itoa(p.Protocol)), atoiMin1(strconv.Itoa(p.MinProtocol)), Protocol(), MinProtocol())85
}86
87
// BlueGitFromHeader leest de X-BlueGit-koppen. ok is false zonder88
// protocolkop; p is dan protocol 1.89
func BlueGitFromHeader(h http.Header) (Peer, bool) {90
p := Peer{Protocol: 1, MinProtocol: 1}91
raw := h.Get(HeaderBlueGitProtocol)92
if raw == "" {93
return p, false94
}95
p.Protocol = atoiMin1(raw)96
if m := h.Get(HeaderBlueGitMinProtocol); m != "" {97
p.MinProtocol = atoiMin1(m)98
}99
p.Version = cleanVersion(h.Get(HeaderBlueGitVersion))100
return p, true101
}102
103
func cleanVersion(v string) string {104
out := make([]rune, 0, len(v))105
for _, r := range strings.TrimSpace(v) {106
if r > ' ' && r < 0x7f && r != '<' && r != '>' && r != '"' {107
out = append(out, r)108
}109
if len(out) == 40 {110
break111
}112
}113
return string(out)114
}115
116
// SetOwnHeaders zet de X-Backup-koppen.117
func SetOwnHeaders(h http.Header, version string) {118
h.Set(HeaderBackupProtocol, strconv.Itoa(Protocol()))119
h.Set(HeaderBackupMinProtocol, strconv.Itoa(MinProtocol()))120
h.Set(HeaderBackupVersion, version)121
}@@ -0,0 +1,41 @@
1
package protocol
2
3
import (
4
"net/http"
5
"testing"
6
)
7
8
func TestCompat(t *testing.T) {
9
cases := []struct {
10
bg, bgMin, bk, bkMin int
11
want string
12
}{
13
{1, 1, 1, 1, CompatOK},
14
{2, 1, 1, 1, CompatOK},
15
{1, 1, 2, 1, CompatOK},
16
{3, 2, 1, 1, CompatBackupTooOld},
17
{1, 1, 3, 2, CompatBlueGitTooOld},
18
}
19
for _, c := range cases {
20
if got := Compat(c.bg, c.bgMin, c.bk, c.bkMin); got != c.want {
21
t.Errorf("Compat(%d,%d,%d,%d) = %s, wil %s", c.bg, c.bgMin, c.bk, c.bkMin, got, c.want)
22
}
23
}
24
}
25
26
func TestBlueGitFromHeader(t *testing.T) {
27
if p, ok := BlueGitFromHeader(http.Header{}); ok || p.Protocol != 1 || p.MinProtocol != 1 {
28
t.Fatalf("zonder koppen: %+v", p)
29
}
30
h := http.Header{}
31
h.Set(HeaderBlueGitProtocol, "4")
32
h.Set(HeaderBlueGitMinProtocol, "3")
33
h.Set(HeaderBlueGitVersion, "abc<def")
34
p, ok := BlueGitFromHeader(h)
35
if !ok || p.Protocol != 4 || p.MinProtocol != 3 || p.Version != "abcdef" {
36
t.Fatalf("%+v", p)
37
}
38
if p.Compat() != CompatBackupTooOld {
39
t.Fatalf("BlueGit 4 vraagt 3, wij spreken 1: %s", p.Compat())
40
}
41
}
@@ -0,0 +1,41 @@1
package protocol2
3
import (4
"net/http"5
"testing"6
)7
8
func TestCompat(t *testing.T) {9
cases := []struct {10
bg, bgMin, bk, bkMin int11
want string12
}{13
{1, 1, 1, 1, CompatOK},14
{2, 1, 1, 1, CompatOK},15
{1, 1, 2, 1, CompatOK},16
{3, 2, 1, 1, CompatBackupTooOld},17
{1, 1, 3, 2, CompatBlueGitTooOld},18
}19
for _, c := range cases {20
if got := Compat(c.bg, c.bgMin, c.bk, c.bkMin); got != c.want {21
t.Errorf("Compat(%d,%d,%d,%d) = %s, wil %s", c.bg, c.bgMin, c.bk, c.bkMin, got, c.want)22
}23
}24
}25
26
func TestBlueGitFromHeader(t *testing.T) {27
if p, ok := BlueGitFromHeader(http.Header{}); ok || p.Protocol != 1 || p.MinProtocol != 1 {28
t.Fatalf("zonder koppen: %+v", p)29
}30
h := http.Header{}31
h.Set(HeaderBlueGitProtocol, "4")32
h.Set(HeaderBlueGitMinProtocol, "3")33
h.Set(HeaderBlueGitVersion, "abc<def")34
p, ok := BlueGitFromHeader(h)35
if !ok || p.Protocol != 4 || p.MinProtocol != 3 || p.Version != "abcdef" {36
t.Fatalf("%+v", p)37
}38
if p.Compat() != CompatBackupTooOld {39
t.Fatalf("BlueGit 4 vraagt 3, wij spreken 1: %s", p.Compat())40
}41
}@@ -0,0 +1,167 @@
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
// Protocol en MinProtocol zijn 0 bij een BlueGit van vóór de
57
// protocolversie (dat is protocol 1).
58
Protocol int `json:"protocol"`
59
MinProtocol int `json:"min_protocol"`
60
Version string `json:"version"`
61
}
62
63
// Peer geeft het protocol van BlueGit uit info.
64
func (i Info) Peer() Peer {
65
p := Peer{Protocol: i.Protocol, MinProtocol: i.MinProtocol, Version: cleanVersion(i.Version)}
66
if p.Protocol < 1 {
67
p.Protocol = 1
68
}
69
if p.MinProtocol < 1 {
70
p.MinProtocol = 1
71
}
72
return p
73
}
74
75
// SigningSecret leidt het HMAC-geheim af uit de key.
76
func SigningSecret(key string) string {
77
s := sha256.Sum256([]byte("bluegit-backup-sign:" + key))
78
return hex.EncodeToString(s[:])
79
}
80
81
// Signature is hex(HMAC-SHA256(secret, METHOD \n PATH \n TS \n sha256hex(body))).
82
func Signature(secret, method, p, ts string, body []byte) string {
83
sum := sha256.Sum256(body)
84
mac := hmac.New(sha256.New, []byte(secret))
85
mac.Write([]byte(strings.ToUpper(method) + "\n" + p + "\n" + ts + "\n" + hex.EncodeToString(sum[:])))
86
return hex.EncodeToString(mac.Sum(nil))
87
}
88
89
// Sign zet de koppen op een uitgaand verzoek (gebruikt in tests en door
90
// BlueGit zelf).
91
func Sign(req *http.Request, secret, instance string, body []byte, now time.Time) {
92
ts := strconv.FormatInt(now.Unix(), 10)
93
req.Header.Set(HeaderInstance, instance)
94
req.Header.Set(HeaderTimestamp, ts)
95
req.Header.Set(HeaderSignature, Signature(secret, req.Method, req.URL.Path, ts, body))
96
}
97
98
// Verify controleert een binnenkomend ondertekend verzoek.
99
func Verify(r *http.Request, secret string, body []byte, now time.Time) error {
100
ts := r.Header.Get(HeaderTimestamp)
101
n, err := strconv.ParseInt(ts, 10, 64)
102
if err != nil {
103
return errors.New("timestamp ontbreekt")
104
}
105
d := now.Sub(time.Unix(n, 0))
106
if d < 0 {
107
d = -d
108
}
109
if d > MaxSkew {
110
return errors.New("timestamp te oud of in de toekomst")
111
}
112
want := Signature(secret, r.Method, r.URL.Path, ts, body)
113
if !hmac.Equal([]byte(want), []byte(r.Header.Get(HeaderSignature))) {
114
return errors.New("handtekening klopt niet")
115
}
116
return nil
117
}
118
119
var (
120
stateFiles = []string{"bluegit.db", "secret.key"}
121
stateDirs = []string{"ssh", "logos", "avatars"}
122
dataDirs = []string{"repos", "releases", "artifacts"}
123
)
124
125
// CleanLogical controleert een logisch pad zoals BlueGit dat doet. Een pad
126
// buiten de bekende mappen komt nooit in de kopie.
127
func CleanLogical(p string) (string, bool) {
128
if p == "" || strings.Contains(p, "\\") || strings.ContainsRune(p, 0) || strings.HasPrefix(p, "/") {
129
return "", false
130
}
131
c := path.Clean(p)
132
if c != p || c == "." {
133
return "", false
134
}
135
parts := strings.Split(c, "/")
136
for _, part := range parts {
137
if part == ".." || part == "." || part == "" {
138
return "", false
139
}
140
}
141
if len(parts) < 2 {
142
return "", false
143
}
144
switch parts[0] {
145
case "state":
146
if len(parts) == 2 && has(stateFiles, parts[1]) {
147
return c, true
148
}
149
if len(parts) >= 3 && has(stateDirs, parts[1]) {
150
return c, true
151
}
152
case "data":
153
if len(parts) >= 3 && has(dataDirs, parts[1]) && parts[2] != ".incoming" {
154
return c, true
155
}
156
}
157
return "", false
158
}
159
160
func has(list []string, v string) bool {
161
for _, x := range list {
162
if x == v {
163
return true
164
}
165
}
166
return false
167
}
@@ -0,0 +1,167 @@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
// Protocol en MinProtocol zijn 0 bij een BlueGit van vóór de57
// protocolversie (dat is protocol 1).58
Protocol int `json:"protocol"`59
MinProtocol int `json:"min_protocol"`60
Version string `json:"version"`61
}62
63
// Peer geeft het protocol van BlueGit uit info.64
func (i Info) Peer() Peer {65
p := Peer{Protocol: i.Protocol, MinProtocol: i.MinProtocol, Version: cleanVersion(i.Version)}66
if p.Protocol < 1 {67
p.Protocol = 168
}69
if p.MinProtocol < 1 {70
p.MinProtocol = 171
}72
return p73
}74
75
// SigningSecret leidt het HMAC-geheim af uit de key.76
func SigningSecret(key string) string {77
s := sha256.Sum256([]byte("bluegit-backup-sign:" + key))78
return hex.EncodeToString(s[:])79
}80
81
// Signature is hex(HMAC-SHA256(secret, METHOD \n PATH \n TS \n sha256hex(body))).82
func Signature(secret, method, p, ts string, body []byte) string {83
sum := sha256.Sum256(body)84
mac := hmac.New(sha256.New, []byte(secret))85
mac.Write([]byte(strings.ToUpper(method) + "\n" + p + "\n" + ts + "\n" + hex.EncodeToString(sum[:])))86
return hex.EncodeToString(mac.Sum(nil))87
}88
89
// Sign zet de koppen op een uitgaand verzoek (gebruikt in tests en door90
// BlueGit zelf).91
func Sign(req *http.Request, secret, instance string, body []byte, now time.Time) {92
ts := strconv.FormatInt(now.Unix(), 10)93
req.Header.Set(HeaderInstance, instance)94
req.Header.Set(HeaderTimestamp, ts)95
req.Header.Set(HeaderSignature, Signature(secret, req.Method, req.URL.Path, ts, body))96
}97
98
// Verify controleert een binnenkomend ondertekend verzoek.99
func Verify(r *http.Request, secret string, body []byte, now time.Time) error {100
ts := r.Header.Get(HeaderTimestamp)101
n, err := strconv.ParseInt(ts, 10, 64)102
if err != nil {103
return errors.New("timestamp ontbreekt")104
}105
d := now.Sub(time.Unix(n, 0))106
if d < 0 {107
d = -d108
}109
if d > MaxSkew {110
return errors.New("timestamp te oud of in de toekomst")111
}112
want := Signature(secret, r.Method, r.URL.Path, ts, body)113
if !hmac.Equal([]byte(want), []byte(r.Header.Get(HeaderSignature))) {114
return errors.New("handtekening klopt niet")115
}116
return nil117
}118
119
var (120
stateFiles = []string{"bluegit.db", "secret.key"}121
stateDirs = []string{"ssh", "logos", "avatars"}122
dataDirs = []string{"repos", "releases", "artifacts"}123
)124
125
// CleanLogical controleert een logisch pad zoals BlueGit dat doet. Een pad126
// buiten de bekende mappen komt nooit in de kopie.127
func CleanLogical(p string) (string, bool) {128
if p == "" || strings.Contains(p, "\\") || strings.ContainsRune(p, 0) || strings.HasPrefix(p, "/") {129
return "", false130
}131
c := path.Clean(p)132
if c != p || c == "." {133
return "", false134
}135
parts := strings.Split(c, "/")136
for _, part := range parts {137
if part == ".." || part == "." || part == "" {138
return "", false139
}140
}141
if len(parts) < 2 {142
return "", false143
}144
switch parts[0] {145
case "state":146
if len(parts) == 2 && has(stateFiles, parts[1]) {147
return c, true148
}149
if len(parts) >= 3 && has(stateDirs, parts[1]) {150
return c, true151
}152
case "data":153
if len(parts) >= 3 && has(dataDirs, parts[1]) && parts[2] != ".incoming" {154
return c, true155
}156
}157
return "", false158
}159
160
func has(list []string, v string) bool {161
for _, x := range list {162
if x == v {163
return true164
}165
}166
return false167
}@@ -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,461 @@
1
package server
2
3
import (
4
"context"
5
"crypto/subtle"
6
"encoding/json"
7
"errors"
8
"fmt"
9
"io"
10
"net/http"
11
"sort"
12
"strconv"
13
"strings"
14
15
"git.timfalken.com/timfa/bluegit-backup/internal/archive"
16
"git.timfalken.com/timfa/bluegit-backup/internal/config"
17
"git.timfalken.com/timfa/bluegit-backup/internal/mirror"
18
"git.timfalken.com/timfa/bluegit-backup/internal/protocol"
19
)
20
21
// Input is de invoer van een actie: JSON-velden, querystring, formulier of
22
// padwaarden, allemaal als tekst.
23
type Input map[string]string
24
25
// Action is één beheerhandeling. De API, de webinterface en BlueGit lopen
26
// allemaal via deze lijst, zodat ze precies hetzelfde kunnen.
27
type Action struct {
28
// Name is de naam in de webinterface (/ui/act/<name>).
29
Name string `json:"name"`
30
Method string `json:"method"`
31
Path string `json:"path"`
32
// Title is de knoptekst of beschrijving.
33
Title string `json:"title"`
34
// Signed: ook de gekoppelde BlueGit mag dit (ondertekend verzoek).
35
Signed bool `json:"bluegit"`
36
// Params zijn de padwaarden, bijvoorbeeld {name}.
37
Params []string `json:"params,omitempty"`
38
// Fields zijn de invoervelden (documentatie en de lijst in /api/v1/admin/actions).
39
Fields []string `json:"fields,omitempty"`
40
Do func(ctx context.Context, in Input) (int, any) `json:"-"`
41
}
42
43
// fileResult laat de API een bestand sturen in plaats van JSON.
44
type fileResult struct{ path, name string }
45
46
func errBody(err error) map[string]string { return map[string]string{"error": err.Error()} }
47
48
// Actions is de volledige lijst met beheerhandelingen.
49
func (s *Server) Actions() []Action {
50
return []Action{
51
{Name: "status", Method: "GET", Path: "/api/v1/admin/status", Title: "Status", Signed: true,
52
Do: func(ctx context.Context, in Input) (int, any) { return 200, s.Status() }},
53
{Name: "actions", Method: "GET", Path: "/api/v1/admin/actions", Title: "Alle acties", Signed: true,
54
Do: func(ctx context.Context, in Input) (int, any) { return 200, map[string]any{"actions": s.Actions()} }},
55
{Name: "config", Method: "GET", Path: "/api/v1/admin/config", Title: "Instellingen", Signed: true,
56
Do: func(ctx context.Context, in Input) (int, any) { return 200, s.ConfigView() }},
57
{Name: "config.update", Method: "PUT", Path: "/api/v1/admin/config", Title: "Instellingen opslaan", Signed: true,
58
Fields: fieldKeys(), Do: s.actConfigUpdate},
59
{Name: "connect", Method: "POST", Path: "/api/v1/admin/connect", Title: "Koppelen",
60
Fields: []string{"url", "key", "on_conflict"}, Do: s.actConnect},
61
{Name: "disconnect", Method: "POST", Path: "/api/v1/admin/disconnect", Title: "Ontkoppelen", Signed: true,
62
Do: s.actDisconnect},
63
{Name: "sync", Method: "POST", Path: "/api/v1/admin/sync", Title: "Nu synchroniseren", Signed: true,
64
Fields: []string{"wait"}, Do: s.actSync},
65
{Name: "archive", Method: "POST", Path: "/api/v1/admin/archive", Title: "Nu archiveren", Signed: true,
66
Do: func(ctx context.Context, in Input) (int, any) {
67
a, err := s.ArchiveNow()
68
if err != nil {
69
return 409, errBody(err)
70
}
71
return 201, a
72
}},
73
{Name: "prune", Method: "POST", Path: "/api/v1/admin/prune", Title: "Nu opruimen", Signed: true,
74
Do: func(ctx context.Context, in Input) (int, any) {
75
removed, err := s.Prune()
76
if err != nil {
77
return 500, errBody(err)
78
}
79
if removed == nil {
80
removed = []string{}
81
}
82
return 200, map[string]any{"removed": removed}
83
}},
84
{Name: "archives", Method: "GET", Path: "/api/v1/admin/archives", Title: "Archieven", Signed: true,
85
Do: func(ctx context.Context, in Input) (int, any) {
86
list, err := s.archives.List()
87
if err != nil {
88
return 500, errBody(err)
89
}
90
return 200, map[string]any{"archives": list}
91
}},
92
{Name: "archive.download", Method: "GET", Path: "/api/v1/admin/archives/{name}/download", Title: "Downloaden",
93
Params: []string{"name"}, Do: func(ctx context.Context, in Input) (int, any) {
94
p, err := s.archives.Path(in["name"])
95
if err != nil {
96
return 404, errBody(err)
97
}
98
return 200, fileResult{path: p, name: in["name"]}
99
}},
100
{Name: "archive.delete", Method: "DELETE", Path: "/api/v1/admin/archives/{name}", Title: "Verwijderen", Signed: true,
101
Params: []string{"name"}, Do: s.actArchiveDelete},
102
{Name: "rollback", Method: "POST", Path: "/api/v1/admin/rollback", Title: "Rollback", Signed: true,
103
Fields: []string{"archive", "confirm"}, Do: s.actRollback},
104
}
105
}
106
107
func fieldKeys() []string {
108
out := make([]string, 0, len(config.Fields))
109
for _, f := range config.Fields {
110
out = append(out, f.Key)
111
}
112
return out
113
}
114
115
func (s *Server) action(name string) (Action, bool) {
116
for _, a := range s.Actions() {
117
if a.Name == name {
118
return a, true
119
}
120
}
121
return Action{}, false
122
}
123
124
// ConfigView is GET /api/v1/admin/config.
125
type ConfigView struct {
126
Fields []ConfigField `json:"fields"`
127
DataDir string `json:"data_dir"`
128
// Restart: er staat een wijziging klaar die pas na een herstart geldt.
129
Restart bool `json:"restart_pending"`
130
}
131
132
// ConfigField is een veld met zijn waarde.
133
type ConfigField struct {
134
config.Field
135
Value string `json:"value"`
136
}
137
138
// ConfigView geeft alle instellingen met hun huidige waarde.
139
func (s *Server) ConfigView() ConfigView {
140
s.mu.Lock()
141
defer s.mu.Unlock()
142
v := ConfigView{DataDir: s.Cfg.DataDir, Restart: s.restartPending}
143
for _, f := range config.Fields {
144
val := s.Cfg.Get(f.Key)
145
if f.Restart {
146
if p, ok := s.settings[f.Key]; ok {
147
val = p
148
}
149
}
150
v.Fields = append(v.Fields, ConfigField{Field: f, Value: val})
151
}
152
return v
153
}
154
155
// UpdateConfig past instellingen toe en bewaart ze in settings.yml. Velden
156
// met Restart gelden pas na een herstart.
157
func (s *Server) UpdateConfig(set map[string]string) (ConfigView, error) {
158
s.mu.Lock()
159
next := s.Cfg
160
if err := next.Apply(set); err != nil {
161
s.mu.Unlock()
162
return ConfigView{}, err
163
}
164
merged := map[string]string{}
165
for k, v := range s.settings {
166
merged[k] = v
167
}
168
for k := range set {
169
merged[k] = next.Get(k)
170
}
171
if err := config.SaveSettings(next.DataDir, merged); err != nil {
172
s.mu.Unlock()
173
return ConfigView{}, err
174
}
175
for _, f := range config.Fields {
176
if f.Restart {
177
if _, ok := set[f.Key]; ok && next.Get(f.Key) != s.Cfg.Get(f.Key) {
178
s.restartPending = true
179
}
180
// De draaiende waarde blijft tot de herstart.
181
_ = next.Set(f.Key, s.Cfg.Get(f.Key))
182
}
183
}
184
s.settings = merged
185
s.Cfg = next
186
s.mu.Unlock()
187
s.limiter.SetRate(next.RateLimitKiB << 10)
188
keys := make([]string, 0, len(set))
189
for k := range set {
190
keys = append(keys, k)
191
}
192
sort.Strings(keys)
193
s.Log.Info("instellingen gewijzigd", "keys", strings.Join(keys, ","))
194
// Kortere intervallen meteen laten gelden.
195
s.Kick()
196
return s.ConfigView(), nil
197
}
198
199
func (s *Server) actConfigUpdate(ctx context.Context, in Input) (int, any) {
200
set := map[string]string{}
201
for k, v := range in {
202
set[k] = v
203
}
204
if len(set) == 0 {
205
return 400, errBody(errors.New("geen instellingen meegegeven"))
206
}
207
v, err := s.UpdateConfig(set)
208
if err != nil {
209
return 400, errBody(err)
210
}
211
return 200, v
212
}
213
214
func (s *Server) actConnect(ctx context.Context, in Input) (int, any) {
215
res, conflict, err := s.Connect(ctx, ConnectRequest{URL: in["url"], Key: in["key"], OnConflict: in["on_conflict"]})
216
if conflict != nil {
217
return http.StatusConflict, conflict
218
}
219
if err != nil {
220
var he *mirror.HTTPError
221
code := 502
222
if errors.As(err, &he) && he.Status == 401 {
223
code = 401
224
}
225
if errors.Is(err, errBadRequest) {
226
code = 400
227
}
228
return code, errBody(err)
229
}
230
return 200, res
231
}
232
233
// Disconnect vergeet de gekoppelde BlueGit. De kopie en de archieven blijven
234
// staan; een volgende koppeling met een andere BlueGit vraagt dan weer om
235
// wissen of herstellen.
236
func (s *Server) Disconnect() error {
237
s.work.Lock()
238
defer s.work.Unlock()
239
st := s.getState()
240
keep := State{InstanceID: st.InstanceID, BlueGitURL: st.BlueGitURL}
241
if err := saveState(s.Cfg.DataDir, keep); err != nil {
242
return err
243
}
244
s.mu.Lock()
245
s.state = keep
246
s.bluegitKnown = false
247
s.mu.Unlock()
248
s.Log.Warn("ontkoppeld", "bluegit", st.BlueGitURL)
249
return nil
250
}
251
252
func (s *Server) actDisconnect(ctx context.Context, in Input) (int, any) {
253
if !s.getState().Connected() {
254
return 409, errBody(errors.New("er is geen BlueGit gekoppeld"))
255
}
256
if err := s.Disconnect(); err != nil {
257
return 500, errBody(err)
258
}
259
return 200, map[string]any{"connected": false}
260
}
261
262
func (s *Server) actSync(ctx context.Context, in Input) (int, any) {
263
if !s.getState().Connected() {
264
return 409, errBody(errors.New("geen BlueGit gekoppeld"))
265
}
266
if in["wait"] == "false" || in["wait"] == "0" {
267
s.Kick()
268
return 202, map[string]string{"state": "started"}
269
}
270
stats, err := s.SyncNow(ctx)
271
if errors.Is(err, ErrIncompatible) {
272
return http.StatusConflict, errBody(err)
273
}
274
if err != nil {
275
return 502, errBody(err)
276
}
277
return 200, stats
278
}
279
280
func (s *Server) actArchiveDelete(ctx context.Context, in Input) (int, any) {
281
name := in["name"]
282
if !archive.ValidName(name) {
283
return 400, errBody(errors.New("ongeldige archiefnaam"))
284
}
285
s.work.Lock()
286
err := s.archives.Delete(name)
287
s.work.Unlock()
288
if err != nil {
289
return 404, errBody(err)
290
}
291
s.Log.Info("archief verwijderd met de hand", "archive", name)
292
return 200, map[string]string{"deleted": name}
293
}
294
295
func (s *Server) actRollback(ctx context.Context, in Input) (int, any) {
296
name := in["archive"]
297
if !archive.ValidName(name) {
298
return 400, errBody(errors.New("ongeldige archiefnaam"))
299
}
300
if in["confirm"] != name {
301
return 400, errBody(errors.New("bevestig met de archiefnaam in confirm; een rollback kan niet ongedaan worden gemaakt"))
302
}
303
return s.startRollback(name)
304
}
305
306
// startRollback start een rollback op de achtergrond.
307
func (s *Server) startRollback(name string) (int, any) {
308
if _, err := s.archives.Path(name); err != nil {
309
return 404, errBody(err)
310
}
311
if !s.getState().Connected() {
312
return 409, errBody(errors.New("geen BlueGit gekoppeld"))
313
}
314
if c, p := s.compat(); c != "" && c != protocol.CompatOK {
315
return 409, errBody(fmt.Errorf("%w: %s", ErrIncompatible, compatMessage(c, p)))
316
}
317
s.mu.Lock()
318
busy := s.rollback.State == "running"
319
if !busy {
320
s.rollback = RollbackStatus{State: "running", Archive: name, At: s.now().UTC()}
321
}
322
s.mu.Unlock()
323
if busy {
324
return 409, errBody(errors.New("er loopt al een rollback"))
325
}
326
s.Log.Warn("rollback gestart", "archive", name)
327
go func() {
328
if err := s.Rollback(context.Background(), name); err != nil {
329
s.Log.Error("rollback mislukt", "archive", name, "err", err)
330
}
331
}()
332
return http.StatusAccepted, map[string]string{"state": "running", "archive": name}
333
}
334
335
// ---------- HTTP ----------
336
337
// Handler is de webinterface en de HTTP-API.
338
func (s *Server) Handler() http.Handler {
339
mux := http.NewServeMux()
340
mux.HandleFunc("GET /healthz", func(w http.ResponseWriter, r *http.Request) { _, _ = w.Write([]byte("ok\n")) })
341
// Van BlueGit, ondertekend (vaste protocolroutes).
342
mux.HandleFunc("POST /api/v1/notify", s.signed(s.apiNotify))
343
mux.HandleFunc("GET /api/v1/archives", s.signed(s.apiArchives))
344
mux.HandleFunc("GET /api/v1/status", s.signed(s.apiStatus))
345
mux.HandleFunc("POST /api/v1/rollback", s.signed(s.apiRollback))
346
// Beheer: admin.token, een sessie van de webinterface, of BlueGit.
347
for _, a := range s.Actions() {
348
mux.HandleFunc(a.Method+" "+a.Path, s.apiAction(a))
349
}
350
s.mountUI(mux)
351
return securityHeaders(mux)
352
}
353
354
func securityHeaders(h http.Handler) http.Handler {
355
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
356
protocol.SetOwnHeaders(w.Header(), Version)
357
w.Header().Set("X-Content-Type-Options", "nosniff")
358
w.Header().Set("Referrer-Policy", "same-origin")
359
h.ServeHTTP(w, r)
360
})
361
}
362
363
// apiAction voert een actie uit voor de API.
364
func (s *Server) apiAction(a Action) http.HandlerFunc {
365
return func(w http.ResponseWriter, r *http.Request) {
366
body, err := io.ReadAll(io.LimitReader(r.Body, 1<<20))
367
if err != nil {
368
writeErr(w, 400, "body")
369
return
370
}
371
if code, msg := s.authorize(r, a, body); code != 0 {
372
writeErr(w, code, msg)
373
return
374
}
375
in, err := parseInput(r, body)
376
if err != nil {
377
writeErr(w, 400, err.Error())
378
return
379
}
380
for _, p := range a.Params {
381
in[p] = r.PathValue(p)
382
}
383
code, out := a.Do(r.Context(), in)
384
if f, ok := out.(fileResult); ok {
385
w.Header().Set("Content-Type", "application/gzip")
386
w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=%q", f.name))
387
http.ServeFile(w, r, f.path)
388
return
389
}
390
writeJSON(w, code, out)
391
}
392
}
393
394
// authorize: 0 is toegestaan, anders de foutcode.
395
func (s *Server) authorize(r *http.Request, a Action, body []byte) (int, string) {
396
if tok, ok := strings.CutPrefix(r.Header.Get("Authorization"), "Bearer "); ok {
397
if subtle.ConstantTimeCompare([]byte(strings.TrimSpace(tok)), []byte(s.adminToken)) == 1 {
398
return 0, ""
399
}
400
return 401, "ongeldig token"
401
}
402
if r.Header.Get(protocol.HeaderSignature) != "" {
403
if !a.Signed {
404
return 403, "BlueGit mag dit niet"
405
}
406
st := s.getState()
407
if !st.Connected() {
408
return 401, "niet gekoppeld"
409
}
410
if r.Header.Get(protocol.HeaderInstance) != st.InstanceID {
411
return 401, "andere BlueGit-instantie"
412
}
413
if err := protocol.Verify(r, protocol.SigningSecret(st.Key), body, s.now()); err != nil {
414
return 401, err.Error()
415
}
416
p, _ := protocol.BlueGitFromHeader(r.Header)
417
s.setBlueGit(p)
418
return 0, ""
419
}
420
if sess, ok := s.session(r); ok {
421
if r.Method != http.MethodGet && r.Method != http.MethodHead {
422
if subtle.ConstantTimeCompare([]byte(r.Header.Get("X-CSRF-Token")), []byte(sess.csrf)) != 1 {
423
return 403, "X-CSRF-Token ontbreekt of klopt niet"
424
}
425
}
426
return 0, ""
427
}
428
return 401, "admin.token, sessie of BlueGit-handtekening nodig"
429
}
430
431
// parseInput leest de querystring en een JSON-object (waarden als tekst).
432
func parseInput(r *http.Request, body []byte) (Input, error) {
433
in := Input{}
434
for k, v := range r.URL.Query() {
435
if len(v) > 0 {
436
in[k] = v[0]
437
}
438
}
439
if len(strings.TrimSpace(string(body))) == 0 {
440
return in, nil
441
}
442
var raw map[string]any
443
if err := json.Unmarshal(body, &raw); err != nil {
444
return nil, errors.New("ongeldige JSON: verwacht een object")
445
}
446
for k, v := range raw {
447
switch t := v.(type) {
448
case string:
449
in[k] = t
450
case float64:
451
in[k] = strconv.FormatFloat(t, 'f', -1, 64)
452
case bool:
453
in[k] = strconv.FormatBool(t)
454
case nil:
455
in[k] = ""
456
default:
457
return nil, fmt.Errorf("veld %s: verwacht tekst, getal of boolean", k)
458
}
459
}
460
return in, nil
461
}
@@ -0,0 +1,461 @@1
package server2
3
import (4
"context"5
"crypto/subtle"6
"encoding/json"7
"errors"8
"fmt"9
"io"10
"net/http"11
"sort"12
"strconv"13
"strings"14
15
"git.timfalken.com/timfa/bluegit-backup/internal/archive"16
"git.timfalken.com/timfa/bluegit-backup/internal/config"17
"git.timfalken.com/timfa/bluegit-backup/internal/mirror"18
"git.timfalken.com/timfa/bluegit-backup/internal/protocol"19
)20
21
// Input is de invoer van een actie: JSON-velden, querystring, formulier of22
// padwaarden, allemaal als tekst.23
type Input map[string]string24
25
// Action is één beheerhandeling. De API, de webinterface en BlueGit lopen26
// allemaal via deze lijst, zodat ze precies hetzelfde kunnen.27
type Action struct {28
// Name is de naam in de webinterface (/ui/act/<name>).29
Name string `json:"name"`30
Method string `json:"method"`31
Path string `json:"path"`32
// Title is de knoptekst of beschrijving.33
Title string `json:"title"`34
// Signed: ook de gekoppelde BlueGit mag dit (ondertekend verzoek).35
Signed bool `json:"bluegit"`36
// Params zijn de padwaarden, bijvoorbeeld {name}.37
Params []string `json:"params,omitempty"`38
// Fields zijn de invoervelden (documentatie en de lijst in /api/v1/admin/actions).39
Fields []string `json:"fields,omitempty"`40
Do func(ctx context.Context, in Input) (int, any) `json:"-"`41
}42
43
// fileResult laat de API een bestand sturen in plaats van JSON.44
type fileResult struct{ path, name string }45
46
func errBody(err error) map[string]string { return map[string]string{"error": err.Error()} }47
48
// Actions is de volledige lijst met beheerhandelingen.49
func (s *Server) Actions() []Action {50
return []Action{51
{Name: "status", Method: "GET", Path: "/api/v1/admin/status", Title: "Status", Signed: true,52
Do: func(ctx context.Context, in Input) (int, any) { return 200, s.Status() }},53
{Name: "actions", Method: "GET", Path: "/api/v1/admin/actions", Title: "Alle acties", Signed: true,54
Do: func(ctx context.Context, in Input) (int, any) { return 200, map[string]any{"actions": s.Actions()} }},55
{Name: "config", Method: "GET", Path: "/api/v1/admin/config", Title: "Instellingen", Signed: true,56
Do: func(ctx context.Context, in Input) (int, any) { return 200, s.ConfigView() }},57
{Name: "config.update", Method: "PUT", Path: "/api/v1/admin/config", Title: "Instellingen opslaan", Signed: true,58
Fields: fieldKeys(), Do: s.actConfigUpdate},59
{Name: "connect", Method: "POST", Path: "/api/v1/admin/connect", Title: "Koppelen",60
Fields: []string{"url", "key", "on_conflict"}, Do: s.actConnect},61
{Name: "disconnect", Method: "POST", Path: "/api/v1/admin/disconnect", Title: "Ontkoppelen", Signed: true,62
Do: s.actDisconnect},63
{Name: "sync", Method: "POST", Path: "/api/v1/admin/sync", Title: "Nu synchroniseren", Signed: true,64
Fields: []string{"wait"}, Do: s.actSync},65
{Name: "archive", Method: "POST", Path: "/api/v1/admin/archive", Title: "Nu archiveren", Signed: true,66
Do: func(ctx context.Context, in Input) (int, any) {67
a, err := s.ArchiveNow()68
if err != nil {69
return 409, errBody(err)70
}71
return 201, a72
}},73
{Name: "prune", Method: "POST", Path: "/api/v1/admin/prune", Title: "Nu opruimen", Signed: true,74
Do: func(ctx context.Context, in Input) (int, any) {75
removed, err := s.Prune()76
if err != nil {77
return 500, errBody(err)78
}79
if removed == nil {80
removed = []string{}81
}82
return 200, map[string]any{"removed": removed}83
}},84
{Name: "archives", Method: "GET", Path: "/api/v1/admin/archives", Title: "Archieven", Signed: true,85
Do: func(ctx context.Context, in Input) (int, any) {86
list, err := s.archives.List()87
if err != nil {88
return 500, errBody(err)89
}90
return 200, map[string]any{"archives": list}91
}},92
{Name: "archive.download", Method: "GET", Path: "/api/v1/admin/archives/{name}/download", Title: "Downloaden",93
Params: []string{"name"}, Do: func(ctx context.Context, in Input) (int, any) {94
p, err := s.archives.Path(in["name"])95
if err != nil {96
return 404, errBody(err)97
}98
return 200, fileResult{path: p, name: in["name"]}99
}},100
{Name: "archive.delete", Method: "DELETE", Path: "/api/v1/admin/archives/{name}", Title: "Verwijderen", Signed: true,101
Params: []string{"name"}, Do: s.actArchiveDelete},102
{Name: "rollback", Method: "POST", Path: "/api/v1/admin/rollback", Title: "Rollback", Signed: true,103
Fields: []string{"archive", "confirm"}, Do: s.actRollback},104
}105
}106
107
func fieldKeys() []string {108
out := make([]string, 0, len(config.Fields))109
for _, f := range config.Fields {110
out = append(out, f.Key)111
}112
return out113
}114
115
func (s *Server) action(name string) (Action, bool) {116
for _, a := range s.Actions() {117
if a.Name == name {118
return a, true119
}120
}121
return Action{}, false122
}123
124
// ConfigView is GET /api/v1/admin/config.125
type ConfigView struct {126
Fields []ConfigField `json:"fields"`127
DataDir string `json:"data_dir"`128
// Restart: er staat een wijziging klaar die pas na een herstart geldt.129
Restart bool `json:"restart_pending"`130
}131
132
// ConfigField is een veld met zijn waarde.133
type ConfigField struct {134
config.Field135
Value string `json:"value"`136
}137
138
// ConfigView geeft alle instellingen met hun huidige waarde.139
func (s *Server) ConfigView() ConfigView {140
s.mu.Lock()141
defer s.mu.Unlock()142
v := ConfigView{DataDir: s.Cfg.DataDir, Restart: s.restartPending}143
for _, f := range config.Fields {144
val := s.Cfg.Get(f.Key)145
if f.Restart {146
if p, ok := s.settings[f.Key]; ok {147
val = p148
}149
}150
v.Fields = append(v.Fields, ConfigField{Field: f, Value: val})151
}152
return v153
}154
155
// UpdateConfig past instellingen toe en bewaart ze in settings.yml. Velden156
// met Restart gelden pas na een herstart.157
func (s *Server) UpdateConfig(set map[string]string) (ConfigView, error) {158
s.mu.Lock()159
next := s.Cfg160
if err := next.Apply(set); err != nil {161
s.mu.Unlock()162
return ConfigView{}, err163
}164
merged := map[string]string{}165
for k, v := range s.settings {166
merged[k] = v167
}168
for k := range set {169
merged[k] = next.Get(k)170
}171
if err := config.SaveSettings(next.DataDir, merged); err != nil {172
s.mu.Unlock()173
return ConfigView{}, err174
}175
for _, f := range config.Fields {176
if f.Restart {177
if _, ok := set[f.Key]; ok && next.Get(f.Key) != s.Cfg.Get(f.Key) {178
s.restartPending = true179
}180
// De draaiende waarde blijft tot de herstart.181
_ = next.Set(f.Key, s.Cfg.Get(f.Key))182
}183
}184
s.settings = merged185
s.Cfg = next186
s.mu.Unlock()187
s.limiter.SetRate(next.RateLimitKiB << 10)188
keys := make([]string, 0, len(set))189
for k := range set {190
keys = append(keys, k)191
}192
sort.Strings(keys)193
s.Log.Info("instellingen gewijzigd", "keys", strings.Join(keys, ","))194
// Kortere intervallen meteen laten gelden.195
s.Kick()196
return s.ConfigView(), nil197
}198
199
func (s *Server) actConfigUpdate(ctx context.Context, in Input) (int, any) {200
set := map[string]string{}201
for k, v := range in {202
set[k] = v203
}204
if len(set) == 0 {205
return 400, errBody(errors.New("geen instellingen meegegeven"))206
}207
v, err := s.UpdateConfig(set)208
if err != nil {209
return 400, errBody(err)210
}211
return 200, v212
}213
214
func (s *Server) actConnect(ctx context.Context, in Input) (int, any) {215
res, conflict, err := s.Connect(ctx, ConnectRequest{URL: in["url"], Key: in["key"], OnConflict: in["on_conflict"]})216
if conflict != nil {217
return http.StatusConflict, conflict218
}219
if err != nil {220
var he *mirror.HTTPError221
code := 502222
if errors.As(err, &he) && he.Status == 401 {223
code = 401224
}225
if errors.Is(err, errBadRequest) {226
code = 400227
}228
return code, errBody(err)229
}230
return 200, res231
}232
233
// Disconnect vergeet de gekoppelde BlueGit. De kopie en de archieven blijven234
// staan; een volgende koppeling met een andere BlueGit vraagt dan weer om235
// wissen of herstellen.236
func (s *Server) Disconnect() error {237
s.work.Lock()238
defer s.work.Unlock()239
st := s.getState()240
keep := State{InstanceID: st.InstanceID, BlueGitURL: st.BlueGitURL}241
if err := saveState(s.Cfg.DataDir, keep); err != nil {242
return err243
}244
s.mu.Lock()245
s.state = keep246
s.bluegitKnown = false247
s.mu.Unlock()248
s.Log.Warn("ontkoppeld", "bluegit", st.BlueGitURL)249
return nil250
}251
252
func (s *Server) actDisconnect(ctx context.Context, in Input) (int, any) {253
if !s.getState().Connected() {254
return 409, errBody(errors.New("er is geen BlueGit gekoppeld"))255
}256
if err := s.Disconnect(); err != nil {257
return 500, errBody(err)258
}259
return 200, map[string]any{"connected": false}260
}261
262
func (s *Server) actSync(ctx context.Context, in Input) (int, any) {263
if !s.getState().Connected() {264
return 409, errBody(errors.New("geen BlueGit gekoppeld"))265
}266
if in["wait"] == "false" || in["wait"] == "0" {267
s.Kick()268
return 202, map[string]string{"state": "started"}269
}270
stats, err := s.SyncNow(ctx)271
if errors.Is(err, ErrIncompatible) {272
return http.StatusConflict, errBody(err)273
}274
if err != nil {275
return 502, errBody(err)276
}277
return 200, stats278
}279
280
func (s *Server) actArchiveDelete(ctx context.Context, in Input) (int, any) {281
name := in["name"]282
if !archive.ValidName(name) {283
return 400, errBody(errors.New("ongeldige archiefnaam"))284
}285
s.work.Lock()286
err := s.archives.Delete(name)287
s.work.Unlock()288
if err != nil {289
return 404, errBody(err)290
}291
s.Log.Info("archief verwijderd met de hand", "archive", name)292
return 200, map[string]string{"deleted": name}293
}294
295
func (s *Server) actRollback(ctx context.Context, in Input) (int, any) {296
name := in["archive"]297
if !archive.ValidName(name) {298
return 400, errBody(errors.New("ongeldige archiefnaam"))299
}300
if in["confirm"] != name {301
return 400, errBody(errors.New("bevestig met de archiefnaam in confirm; een rollback kan niet ongedaan worden gemaakt"))302
}303
return s.startRollback(name)304
}305
306
// startRollback start een rollback op de achtergrond.307
func (s *Server) startRollback(name string) (int, any) {308
if _, err := s.archives.Path(name); err != nil {309
return 404, errBody(err)310
}311
if !s.getState().Connected() {312
return 409, errBody(errors.New("geen BlueGit gekoppeld"))313
}314
if c, p := s.compat(); c != "" && c != protocol.CompatOK {315
return 409, errBody(fmt.Errorf("%w: %s", ErrIncompatible, compatMessage(c, p)))316
}317
s.mu.Lock()318
busy := s.rollback.State == "running"319
if !busy {320
s.rollback = RollbackStatus{State: "running", Archive: name, At: s.now().UTC()}321
}322
s.mu.Unlock()323
if busy {324
return 409, errBody(errors.New("er loopt al een rollback"))325
}326
s.Log.Warn("rollback gestart", "archive", name)327
go func() {328
if err := s.Rollback(context.Background(), name); err != nil {329
s.Log.Error("rollback mislukt", "archive", name, "err", err)330
}331
}()332
return http.StatusAccepted, map[string]string{"state": "running", "archive": name}333
}334
335
// ---------- HTTP ----------336
337
// Handler is de webinterface en de HTTP-API.338
func (s *Server) Handler() http.Handler {339
mux := http.NewServeMux()340
mux.HandleFunc("GET /healthz", func(w http.ResponseWriter, r *http.Request) { _, _ = w.Write([]byte("ok\n")) })341
// Van BlueGit, ondertekend (vaste protocolroutes).342
mux.HandleFunc("POST /api/v1/notify", s.signed(s.apiNotify))343
mux.HandleFunc("GET /api/v1/archives", s.signed(s.apiArchives))344
mux.HandleFunc("GET /api/v1/status", s.signed(s.apiStatus))345
mux.HandleFunc("POST /api/v1/rollback", s.signed(s.apiRollback))346
// Beheer: admin.token, een sessie van de webinterface, of BlueGit.347
for _, a := range s.Actions() {348
mux.HandleFunc(a.Method+" "+a.Path, s.apiAction(a))349
}350
s.mountUI(mux)351
return securityHeaders(mux)352
}353
354
func securityHeaders(h http.Handler) http.Handler {355
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {356
protocol.SetOwnHeaders(w.Header(), Version)357
w.Header().Set("X-Content-Type-Options", "nosniff")358
w.Header().Set("Referrer-Policy", "same-origin")359
h.ServeHTTP(w, r)360
})361
}362
363
// apiAction voert een actie uit voor de API.364
func (s *Server) apiAction(a Action) http.HandlerFunc {365
return func(w http.ResponseWriter, r *http.Request) {366
body, err := io.ReadAll(io.LimitReader(r.Body, 1<<20))367
if err != nil {368
writeErr(w, 400, "body")369
return370
}371
if code, msg := s.authorize(r, a, body); code != 0 {372
writeErr(w, code, msg)373
return374
}375
in, err := parseInput(r, body)376
if err != nil {377
writeErr(w, 400, err.Error())378
return379
}380
for _, p := range a.Params {381
in[p] = r.PathValue(p)382
}383
code, out := a.Do(r.Context(), in)384
if f, ok := out.(fileResult); ok {385
w.Header().Set("Content-Type", "application/gzip")386
w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=%q", f.name))387
http.ServeFile(w, r, f.path)388
return389
}390
writeJSON(w, code, out)391
}392
}393
394
// authorize: 0 is toegestaan, anders de foutcode.395
func (s *Server) authorize(r *http.Request, a Action, body []byte) (int, string) {396
if tok, ok := strings.CutPrefix(r.Header.Get("Authorization"), "Bearer "); ok {397
if subtle.ConstantTimeCompare([]byte(strings.TrimSpace(tok)), []byte(s.adminToken)) == 1 {398
return 0, ""399
}400
return 401, "ongeldig token"401
}402
if r.Header.Get(protocol.HeaderSignature) != "" {403
if !a.Signed {404
return 403, "BlueGit mag dit niet"405
}406
st := s.getState()407
if !st.Connected() {408
return 401, "niet gekoppeld"409
}410
if r.Header.Get(protocol.HeaderInstance) != st.InstanceID {411
return 401, "andere BlueGit-instantie"412
}413
if err := protocol.Verify(r, protocol.SigningSecret(st.Key), body, s.now()); err != nil {414
return 401, err.Error()415
}416
p, _ := protocol.BlueGitFromHeader(r.Header)417
s.setBlueGit(p)418
return 0, ""419
}420
if sess, ok := s.session(r); ok {421
if r.Method != http.MethodGet && r.Method != http.MethodHead {422
if subtle.ConstantTimeCompare([]byte(r.Header.Get("X-CSRF-Token")), []byte(sess.csrf)) != 1 {423
return 403, "X-CSRF-Token ontbreekt of klopt niet"424
}425
}426
return 0, ""427
}428
return 401, "admin.token, sessie of BlueGit-handtekening nodig"429
}430
431
// parseInput leest de querystring en een JSON-object (waarden als tekst).432
func parseInput(r *http.Request, body []byte) (Input, error) {433
in := Input{}434
for k, v := range r.URL.Query() {435
if len(v) > 0 {436
in[k] = v[0]437
}438
}439
if len(strings.TrimSpace(string(body))) == 0 {440
return in, nil441
}442
var raw map[string]any443
if err := json.Unmarshal(body, &raw); err != nil {444
return nil, errors.New("ongeldige JSON: verwacht een object")445
}446
for k, v := range raw {447
switch t := v.(type) {448
case string:449
in[k] = t450
case float64:451
in[k] = strconv.FormatFloat(t, 'f', -1, 64)452
case bool:453
in[k] = strconv.FormatBool(t)454
case nil:455
in[k] = ""456
default:457
return nil, fmt.Errorf("veld %s: verwacht tekst, getal of boolean", k)458
}459
}460
return in, nil461
}@@ -0,0 +1,682 @@
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
"encoding/json"
8
"errors"
9
"fmt"
10
"io"
11
"log/slog"
12
"net/http"
13
"os"
14
"path/filepath"
15
"strings"
16
"sync"
17
"time"
18
19
"git.timfalken.com/timfa/bluegit-backup/internal/archive"
20
"git.timfalken.com/timfa/bluegit-backup/internal/config"
21
"git.timfalken.com/timfa/bluegit-backup/internal/mirror"
22
"git.timfalken.com/timfa/bluegit-backup/internal/protocol"
23
"git.timfalken.com/timfa/bluegit-backup/internal/throttle"
24
)
25
26
// Version wordt bij het bouwen gezet (-ldflags -X).
27
var Version = "dev"
28
29
// Server is één backup server voor één BlueGit.
30
type Server struct {
31
Cfg config.Config
32
Log *slog.Logger
33
// Now is de klok (tests).
34
Now func() time.Time
35
// HTTP is de client richting BlueGit (tests).
36
HTTP *http.Client
37
38
adminToken string
39
serverID string
40
limiter *throttle.Limiter
41
mirror *mirror.Mirror
42
archives *archive.Store
43
44
// work beschermt de kopie: sync, archiveren, rollback en koppelen
45
// gebeuren nooit tegelijk.
46
work sync.Mutex
47
48
mu sync.Mutex
49
state State
50
lastSync time.Time
51
lastSyncErr string
52
lastStats mirror.Stats
53
syncs int
54
notifies int
55
lastArchive time.Time
56
archiveErr string
57
rollback RollbackStatus
58
// bluegit is het protocol dat de gekoppelde BlueGit het laatst meldde.
59
bluegit protocol.Peer
60
bluegitKnown bool
61
62
kick chan struct{}
63
64
// settings is wat via webinterface, API of BlueGit is ingesteld.
65
settings map[string]string
66
restartPending bool
67
sessions map[string]session
68
loginFails map[string][]time.Time
69
}
70
71
// cfg is de huidige configuratie (instellingen kunnen tijdens het draaien
72
// veranderen).
73
func (s *Server) cfg() config.Config {
74
s.mu.Lock()
75
defer s.mu.Unlock()
76
return s.Cfg
77
}
78
79
// RollbackStatus is de stand van de laatste rollback of restore.
80
type RollbackStatus struct {
81
State string `json:"state"` // idle | running | done | failed
82
Archive string `json:"archive,omitempty"`
83
Error string `json:"error,omitempty"`
84
At time.Time `json:"at,omitempty"`
85
}
86
87
// New zet de mappen klaar en leest de koppeling.
88
func New(cfg config.Config, log *slog.Logger) (*Server, error) {
89
if log == nil {
90
log = slog.New(slog.NewTextHandler(io.Discard, nil))
91
}
92
if err := os.MkdirAll(cfg.DataDir, 0o750); err != nil {
93
return nil, err
94
}
95
set, err := config.LoadSettings(cfg.DataDir)
96
if err != nil {
97
return nil, err
98
}
99
if err := cfg.Apply(set); err != nil {
100
return nil, fmt.Errorf("%s: %w", config.SettingsFile, err)
101
}
102
s := &Server{Cfg: cfg, Log: log, Now: time.Now, kick: make(chan struct{}, 1), settings: set, sessions: map[string]session{}}
103
if s.adminToken, err = secretFile(cfg.DataDir, "admin.token", "bba_"); err != nil {
104
return nil, err
105
}
106
if s.serverID, err = secretFile(cfg.DataDir, "server_id", ""); err != nil {
107
return nil, err
108
}
109
if s.state, err = loadState(cfg.DataDir); err != nil {
110
return nil, err
111
}
112
s.limiter = throttle.New(cfg.RateLimitKiB << 10)
113
s.mirror = &mirror.Mirror{Dir: filepath.Join(cfg.DataDir, "mirror"), Index: filepath.Join(cfg.DataDir, "mirror.index.json")}
114
s.archives = &archive.Store{Dir: filepath.Join(cfg.DataDir, "archives")}
115
_ = os.RemoveAll(filepath.Join(cfg.DataDir, "tmp"))
116
if list, _ := s.archives.List(); len(list) > 0 {
117
s.lastArchive = list[0].CreatedAt
118
}
119
s.rollback.State = "idle"
120
return s, nil
121
}
122
123
// SetFree vervangt de vrije-ruimtemeting (tests).
124
func (s *Server) SetFree(f func(string) (uint64, error)) { s.archives.Free = f }
125
126
// AdminToken is het lokale beheertoken.
127
func (s *Server) AdminToken() string { return s.adminToken }
128
129
func (s *Server) now() time.Time { return s.Now() }
130
131
func (s *Server) remote(st State) *mirror.Remote {
132
return &mirror.Remote{URL: st.BlueGitURL, Key: st.Key, HTTP: s.HTTP, Limiter: s.limiter, Version: Version, OnPeer: s.setBlueGit}
133
}
134
135
// setBlueGit legt het protocol van BlueGit vast.
136
func (s *Server) setBlueGit(p protocol.Peer) {
137
s.mu.Lock()
138
changed := !s.bluegitKnown || s.bluegit != p
139
s.bluegit, s.bluegitKnown = p, true
140
s.mu.Unlock()
141
if changed && p.Compat() != protocol.CompatOK {
142
s.Log.Warn("niet compatibel met BlueGit", "compat", p.Compat(), "bluegit_protocol", p.Protocol, "bluegit_min", p.MinProtocol,
143
"protocol", protocol.Protocol(), "min", protocol.MinProtocol())
144
}
145
}
146
147
// compat is "" (nog onbekend), ok, bluegit_too_old of backup_too_old.
148
func (s *Server) compat() (string, protocol.Peer) {
149
s.mu.Lock()
150
defer s.mu.Unlock()
151
if !s.bluegitKnown {
152
return "", s.bluegit
153
}
154
return s.bluegit.Compat(), s.bluegit
155
}
156
157
// compatMessage zegt wie er geüpdatet moet worden (leeg als alles past).
158
func compatMessage(c string, p protocol.Peer) string {
159
switch c {
160
case protocol.CompatBlueGitTooOld:
161
return fmt.Sprintf("BlueGit is verouderd (protocol %d; deze backup server vraagt minstens %d). Update BlueGit; tot dan wordt er niets gesynchroniseerd of teruggezet.", p.Protocol, protocol.MinProtocol())
162
case protocol.CompatBackupTooOld:
163
return fmt.Sprintf("Deze backup server is verouderd (protocol %d; BlueGit vraagt minstens %d). Update de backup server; tot dan wordt er niets gesynchroniseerd of teruggezet.", protocol.Protocol(), p.MinProtocol)
164
}
165
return ""
166
}
167
168
// ErrIncompatible: BlueGit en deze backup server passen niet bij elkaar.
169
var ErrIncompatible = errors.New("niet compatibel")
170
171
// checkCompat vraagt info op bij BlueGit en weigert als de protocollen niet
172
// passen. Aanroepen vóór elke sync, rollback of restore.
173
func (s *Server) checkCompat(ctx context.Context, rem *mirror.Remote) error {
174
info, err := rem.Info(ctx)
175
if err != nil {
176
return err
177
}
178
s.setBlueGit(info.Peer())
179
if c, p := s.compat(); c != protocol.CompatOK {
180
return fmt.Errorf("%w: %s", ErrIncompatible, compatMessage(c, p))
181
}
182
return nil
183
}
184
185
func (s *Server) getState() State {
186
s.mu.Lock()
187
defer s.mu.Unlock()
188
return s.state
189
}
190
191
// Run start de achtergrondtaken tot ctx klaar is.
192
func (s *Server) Run(ctx context.Context) {
193
go s.syncLoop(ctx)
194
go s.archiveLoop(ctx)
195
}
196
197
// Kick vraagt om een sync (na een melding).
198
func (s *Server) Kick() {
199
select {
200
case s.kick <- struct{}{}:
201
default:
202
}
203
}
204
205
func (s *Server) syncLoop(ctx context.Context) {
206
s.Kick() // meteen na de start
207
for {
208
s.mu.Lock()
209
next := s.Cfg.FullSyncInterval.Duration - s.now().Sub(s.lastSync)
210
s.mu.Unlock()
211
if next < 0 {
212
next = 0
213
}
214
full := time.NewTimer(next)
215
select {
216
case <-ctx.Done():
217
full.Stop()
218
return
219
case <-full.C:
220
case <-s.kick:
221
full.Stop()
222
}
223
s.mu.Lock()
224
wait := s.Cfg.MinSyncInterval.Duration - s.now().Sub(s.lastSync)
225
s.mu.Unlock()
226
if wait > 0 {
227
select {
228
case <-ctx.Done():
229
return
230
case <-time.After(wait):
231
}
232
}
233
// Meldingen die in de tussentijd binnenkwamen, zitten in deze sync.
234
select {
235
case <-s.kick:
236
default:
237
}
238
_, _ = s.SyncNow(ctx)
239
}
240
}
241
242
// SyncNow synchroniseert één keer.
243
func (s *Server) SyncNow(ctx context.Context) (mirror.Stats, error) {
244
st := s.getState()
245
if !st.Connected() {
246
return mirror.Stats{}, errors.New("geen BlueGit gekoppeld")
247
}
248
s.work.Lock()
249
defer s.work.Unlock()
250
st = s.getState()
251
if !st.Connected() {
252
return mirror.Stats{}, errors.New("geen BlueGit gekoppeld")
253
}
254
rem := s.remote(st)
255
var stats mirror.Stats
256
err := s.checkCompat(ctx, rem)
257
if err == nil {
258
stats, err = s.mirror.Sync(ctx, rem)
259
}
260
s.mu.Lock()
261
s.lastSync = s.now()
262
s.syncs++
263
s.lastStats = stats
264
if err != nil {
265
s.lastSyncErr = err.Error()
266
} else {
267
s.lastSyncErr = ""
268
}
269
s.mu.Unlock()
270
if err != nil {
271
s.Log.Warn("sync mislukt", "err", err)
272
} else if stats.Downloaded > 0 || stats.Deleted > 0 {
273
s.Log.Info("sync", "files", stats.Files, "downloaded", stats.Downloaded, "bytes", stats.Bytes, "deleted", stats.Deleted)
274
}
275
return stats, err
276
}
277
278
func (s *Server) archiveLoop(ctx context.Context) {
279
for {
280
select {
281
case <-ctx.Done():
282
return
283
case <-time.After(s.tick()):
284
}
285
s.mu.Lock()
286
due := s.now().Sub(s.lastArchive) >= s.Cfg.ArchiveInterval.Duration
287
synced := !s.lastSync.IsZero() && s.lastSyncErr == ""
288
s.mu.Unlock()
289
if due && synced {
290
if _, err := s.ArchiveNow(); err != nil {
291
s.Log.Warn("archief mislukt", "err", err)
292
}
293
}
294
if _, err := s.Prune(); err != nil {
295
s.Log.Warn("opruimen mislukt", "err", err)
296
}
297
}
298
}
299
300
// tick is hoe vaak de archieflus kijkt: een minuut, of korter bij een kort interval.
301
func (s *Server) tick() time.Duration {
302
d := s.cfg().ArchiveInterval.Duration / 4
303
if d > time.Minute {
304
d = time.Minute
305
}
306
if d < 100*time.Millisecond {
307
d = 100 * time.Millisecond
308
}
309
return d
310
}
311
312
// ArchiveNow comprimeert de hele kopie tot een nieuw archief.
313
func (s *Server) ArchiveNow() (archive.Archive, error) {
314
s.work.Lock()
315
defer s.work.Unlock()
316
if s.mirror.Empty() {
317
return archive.Archive{}, errors.New("de kopie is nog leeg")
318
}
319
now := s.now()
320
a, removed, err := s.archives.Create(s.mirror.Dir, now, s.mirror.Size(), s.minFree())
321
s.mu.Lock()
322
if err != nil {
323
s.archiveErr = err.Error()
324
} else {
325
s.archiveErr = ""
326
s.lastArchive = now
327
}
328
s.mu.Unlock()
329
for _, r := range removed {
330
s.Log.Info("archief verwijderd: schijf vol", "archive", r)
331
}
332
if err != nil {
333
return a, err
334
}
335
s.Log.Info("archief gemaakt", "archive", a.Name, "bytes", a.Size)
336
if pr, err := s.archives.Prune(now, s.cfg().RetentionDays, s.minFree()); err == nil {
337
for _, r := range pr {
338
s.Log.Info("archief verwijderd", "archive", r)
339
}
340
}
341
return a, nil
342
}
343
344
func (s *Server) minFree() uint64 { return uint64(s.cfg().MinFreeMB) << 20 }
345
346
// Prune past de bewaarregels toe.
347
func (s *Server) Prune() ([]string, error) {
348
s.work.Lock()
349
defer s.work.Unlock()
350
removed, err := s.archives.Prune(s.now(), s.cfg().RetentionDays, s.minFree())
351
for _, r := range removed {
352
s.Log.Info("archief verwijderd", "archive", r)
353
}
354
return removed, err
355
}
356
357
func writeJSON(w http.ResponseWriter, code int, v any) {
358
w.Header().Set("Content-Type", "application/json")
359
w.Header().Set("Cache-Control", "no-store")
360
w.WriteHeader(code)
361
if v != nil {
362
_ = json.NewEncoder(w).Encode(v)
363
}
364
}
365
366
func writeErr(w http.ResponseWriter, code int, msg string) {
367
writeJSON(w, code, map[string]string{"error": msg})
368
}
369
370
type ctxBody struct{}
371
372
// signed controleert de HMAC-handtekening van de gekoppelde BlueGit.
373
func (s *Server) signed(h http.HandlerFunc) http.HandlerFunc {
374
return func(w http.ResponseWriter, r *http.Request) {
375
st := s.getState()
376
if !st.Connected() {
377
writeErr(w, http.StatusUnauthorized, "niet gekoppeld")
378
return
379
}
380
body, err := io.ReadAll(io.LimitReader(r.Body, 1<<20))
381
if err != nil {
382
writeErr(w, 400, "body")
383
return
384
}
385
if r.Header.Get(protocol.HeaderInstance) != st.InstanceID {
386
writeErr(w, http.StatusUnauthorized, "andere BlueGit-instantie")
387
return
388
}
389
if err := protocol.Verify(r, protocol.SigningSecret(st.Key), body, s.now()); err != nil {
390
writeErr(w, http.StatusUnauthorized, err.Error())
391
return
392
}
393
// Zonder koppen is het een BlueGit van vóór de protocolversie.
394
p, _ := protocol.BlueGitFromHeader(r.Header)
395
s.setBlueGit(p)
396
r = r.WithContext(context.WithValue(r.Context(), ctxBody{}, body))
397
h(w, r)
398
}
399
}
400
401
func bodyOf(r *http.Request) []byte {
402
if b, ok := r.Context().Value(ctxBody{}).([]byte); ok {
403
return b
404
}
405
b, _ := io.ReadAll(io.LimitReader(r.Body, 1<<20))
406
return b
407
}
408
409
func (s *Server) apiNotify(w http.ResponseWriter, r *http.Request) {
410
s.mu.Lock()
411
s.notifies++
412
s.mu.Unlock()
413
s.Kick()
414
w.WriteHeader(http.StatusNoContent)
415
}
416
417
func (s *Server) apiArchives(w http.ResponseWriter, r *http.Request) {
418
list, err := s.archives.List()
419
if err != nil {
420
writeErr(w, 500, err.Error())
421
return
422
}
423
writeJSON(w, 200, map[string]any{"archives": list})
424
}
425
426
// Status is wat GET /api/v1/status en de CLI tonen.
427
type Status struct {
428
Version string `json:"version"`
429
ServerID string `json:"server_id"`
430
BlueGitURL string `json:"bluegit_url,omitempty"`
431
InstanceID string `json:"instance_id,omitempty"`
432
Connected bool `json:"connected"`
433
LastSync time.Time `json:"last_sync,omitempty"`
434
SyncError string `json:"sync_error,omitempty"`
435
LastStats mirror.Stats `json:"last_stats"`
436
Syncs int `json:"syncs"`
437
Notifies int `json:"notifies"`
438
MirrorBytes int64 `json:"mirror_bytes"`
439
Archives int `json:"archives"`
440
LastArchive time.Time `json:"last_archive,omitempty"`
441
ArchiveError string `json:"archive_error,omitempty"`
442
Interval string `json:"archive_interval"`
443
RetentionDays int `json:"retention_days"`
444
RateLimitKiB int64 `json:"rate_limit_kib"`
445
Rollback RollbackStatus `json:"rollback"`
446
// Protocol van deze server en van BlueGit; Compat is "" (nog
447
// onbekend), ok, bluegit_too_old of backup_too_old.
448
Protocol int `json:"protocol"`
449
MinProtocol int `json:"min_protocol"`
450
BlueGitProtocol int `json:"bluegit_protocol,omitempty"`
451
BlueGitMinProtocol int `json:"bluegit_min_protocol,omitempty"`
452
BlueGitVersion string `json:"bluegit_version,omitempty"`
453
Compat string `json:"compat"`
454
CompatMessage string `json:"compat_message,omitempty"`
455
}
456
457
// Status geeft de huidige stand.
458
func (s *Server) Status() Status {
459
list, _ := s.archives.List()
460
compat, peer := s.compat()
461
s.mu.Lock()
462
defer s.mu.Unlock()
463
st := Status{
464
Version: Version, ServerID: s.serverID, BlueGitURL: s.state.BlueGitURL, InstanceID: s.state.InstanceID,
465
Connected: s.state.Connected(), LastSync: s.lastSync, SyncError: s.lastSyncErr, LastStats: s.lastStats,
466
Syncs: s.syncs, Notifies: s.notifies, MirrorBytes: s.mirror.Size(), Archives: len(list),
467
LastArchive: s.lastArchive, ArchiveError: s.archiveErr, Interval: s.Cfg.ArchiveInterval.String(),
468
RetentionDays: s.Cfg.RetentionDays, RateLimitKiB: s.Cfg.RateLimitKiB, Rollback: s.rollback,
469
Protocol: protocol.Protocol(), MinProtocol: protocol.MinProtocol(), Compat: compat, CompatMessage: compatMessage(compat, peer),
470
}
471
if s.bluegitKnown {
472
st.BlueGitProtocol, st.BlueGitMinProtocol, st.BlueGitVersion = peer.Protocol, peer.MinProtocol, peer.Version
473
}
474
return st
475
}
476
477
func (s *Server) apiStatus(w http.ResponseWriter, r *http.Request) { writeJSON(w, 200, s.Status()) }
478
479
// ---------- koppelen ----------
480
481
// ConnectRequest is POST /api/v1/admin/connect.
482
type ConnectRequest struct {
483
URL string `json:"url"`
484
Key string `json:"key"`
485
// OnConflict is leeg, "wipe" of "restore". Leeg en een andere BlueGit
486
// dan de vorige: 409 met de keuzes.
487
OnConflict string `json:"on_conflict"`
488
}
489
490
// ConflictError is het 409-antwoord bij een andere BlueGit.
491
type ConflictError struct {
492
Conflict bool `json:"conflict"`
493
Error string `json:"error"`
494
PreviousURL string `json:"previous_url"`
495
PreviousInstance string `json:"previous_instance"`
496
NewInstance string `json:"new_instance"`
497
Archives int `json:"archives"`
498
Choices []string `json:"choices"`
499
}
500
501
var errBadRequest = errors.New("ongeldig verzoek")
502
503
// Connect koppelt deze server aan een BlueGit. Er is er altijd hoogstens één.
504
func (s *Server) Connect(ctx context.Context, in ConnectRequest) (map[string]any, *ConflictError, error) {
505
in.URL = strings.TrimRight(strings.TrimSpace(in.URL), "/")
506
in.Key = strings.TrimSpace(in.Key)
507
if !strings.HasPrefix(in.URL, "http://") && !strings.HasPrefix(in.URL, "https://") {
508
return nil, nil, fmt.Errorf("%w: url moet met http:// of https:// beginnen", errBadRequest)
509
}
510
if !strings.HasPrefix(in.Key, protocol.KeyPrefix) {
511
return nil, nil, fmt.Errorf("%w: de Backupserver-Key begint met %s", errBadRequest, protocol.KeyPrefix)
512
}
513
switch in.OnConflict {
514
case "", "wipe", "restore":
515
default:
516
return nil, nil, fmt.Errorf("%w: on_conflict moet wipe of restore zijn", errBadRequest)
517
}
518
pub := s.cfg().PublicURL
519
if pub == "" {
520
return nil, nil, fmt.Errorf("%w: zet public_url in de configuratie; BlueGit moet deze server kunnen bereiken", errBadRequest)
521
}
522
s.work.Lock()
523
defer s.work.Unlock()
524
rem := &mirror.Remote{URL: in.URL, Key: in.Key, HTTP: s.HTTP, Limiter: s.limiter, Version: Version, OnPeer: s.setBlueGit}
525
info, err := rem.Info(ctx)
526
if err != nil {
527
return nil, nil, err
528
}
529
// Ook bij een niet-passende BlueGit koppelen we, zodat BlueGit het zijn
530
// beheerders kan laten zien; synchroniseren en terugzetten gebeurt dan niet.
531
s.setBlueGit(info.Peer())
532
compat := info.Peer().Compat()
533
old := s.getState()
534
list, _ := s.archives.List()
535
hasData := !s.mirror.Empty() || len(list) > 0
536
other := old.InstanceID != "" && old.InstanceID != info.InstanceID && hasData
537
mode := ""
538
if other {
539
if in.OnConflict == "" {
540
return nil, &ConflictError{
541
Conflict: true, Error: "deze backup server hoort bij een andere BlueGit",
542
PreviousURL: old.BlueGitURL, PreviousInstance: old.InstanceID, NewInstance: info.InstanceID,
543
Archives: len(list), Choices: []string{"wipe", "restore"},
544
}, nil
545
}
546
mode = in.OnConflict
547
}
548
if mode == "wipe" {
549
if err := s.mirror.Wipe(); err != nil {
550
return nil, nil, err
551
}
552
if err := s.archives.DeleteAll(); err != nil {
553
return nil, nil, err
554
}
555
s.mu.Lock()
556
s.lastArchive = time.Time{}
557
s.mu.Unlock()
558
s.Log.Warn("oude backups verwijderd voor een nieuwe BlueGit", "old", old.InstanceID, "new", info.InstanceID)
559
}
560
if mode == "restore" && compat != protocol.CompatOK {
561
return nil, nil, fmt.Errorf("%w: %s", ErrIncompatible, compatMessage(compat, info.Peer()))
562
}
563
if mode == "restore" && s.mirror.Empty() {
564
return nil, nil, fmt.Errorf("%w: de kopie is leeg; er is niets om terug te zetten", errBadRequest)
565
}
566
if err := rem.Connect(ctx, pub, s.serverID); err != nil {
567
return nil, nil, err
568
}
569
st := State{BlueGitURL: in.URL, Key: in.Key, InstanceID: info.InstanceID, ConnectedAt: s.now().UTC()}
570
if err := saveState(s.Cfg.DataDir, st); err != nil {
571
return nil, nil, err
572
}
573
s.mu.Lock()
574
s.state = st
575
s.mu.Unlock()
576
s.Log.Info("gekoppeld", "bluegit", in.URL, "instance", info.InstanceID, "mode", mode)
577
out := map[string]any{"instance_id": info.InstanceID, "bluegit_url": in.URL, "mode": mode, "compat": compat}
578
if msg := compatMessage(compat, info.Peer()); msg != "" {
579
out["warning"] = msg
580
}
581
if mode == "restore" {
582
if err := s.sendMirror(ctx, rem, "restore"); err != nil {
583
return nil, nil, fmt.Errorf("terugzetten naar de nieuwe BlueGit mislukt: %w", err)
584
}
585
out["restored"] = true
586
}
587
s.Kick()
588
return out, nil, nil
589
}
590
591
// sendMirror stuurt de hele kopie als tar.gz naar BlueGit en wacht tot die
592
// herstart is. Aanroepen met s.work vast.
593
func (s *Server) sendMirror(ctx context.Context, rem *mirror.Remote, label string) error {
594
s.setRollback(RollbackStatus{State: "running", Archive: label, At: s.now().UTC()})
595
pr, pw := io.Pipe()
596
go func() { pw.CloseWithError(archive.WriteTarGz(pw, s.mirror.Dir)) }()
597
if err := rem.Restore(ctx, pr); err != nil {
598
pr.CloseWithError(err)
599
s.setRollback(RollbackStatus{State: "failed", Archive: label, Error: err.Error(), At: s.now().UTC()})
600
return err
601
}
602
if err := rem.WaitUp(ctx, 3*time.Minute); err != nil {
603
s.setRollback(RollbackStatus{State: "failed", Archive: label, Error: err.Error(), At: s.now().UTC()})
604
return err
605
}
606
s.setRollback(RollbackStatus{State: "done", Archive: label, At: s.now().UTC()})
607
return nil
608
}
609
610
func (s *Server) setRollback(r RollbackStatus) {
611
s.mu.Lock()
612
s.rollback = r
613
s.mu.Unlock()
614
}
615
616
// ---------- rollback ----------
617
618
func (s *Server) apiRollback(w http.ResponseWriter, r *http.Request) {
619
var in struct {
620
Archive string `json:"archive"`
621
}
622
if err := json.Unmarshal(bodyOf(r), &in); err != nil || !archive.ValidName(in.Archive) {
623
writeErr(w, 400, "ongeldige archiefnaam")
624
return
625
}
626
code, out := s.startRollback(in.Archive)
627
writeJSON(w, code, out)
628
}
629
630
// Rollback pakt een archief uit, vervangt daarmee de draaiende kopie en
631
// stuurt die naar BlueGit. Lukt het sturen niet, dan komt de oude kopie
632
// terug, zodat kopie en BlueGit gelijk blijven.
633
func (s *Server) Rollback(ctx context.Context, name string) error {
634
s.work.Lock()
635
defer s.work.Unlock()
636
fail := func(err error) error {
637
s.setRollback(RollbackStatus{State: "failed", Archive: name, Error: err.Error(), At: s.now().UTC()})
638
return err
639
}
640
st := s.getState()
641
if !st.Connected() {
642
return fail(errors.New("geen BlueGit gekoppeld"))
643
}
644
if err := s.checkCompat(ctx, s.remote(st)); err != nil {
645
return fail(err)
646
}
647
src, err := s.archives.Path(name)
648
if err != nil {
649
return fail(err)
650
}
651
fresh := filepath.Join(s.Cfg.DataDir, "mirror.rollback")
652
old := filepath.Join(s.Cfg.DataDir, "mirror.old")
653
_ = os.RemoveAll(fresh)
654
_ = os.RemoveAll(old)
655
if err := archive.Extract(src, fresh); err != nil {
656
_ = os.RemoveAll(fresh)
657
return fail(fmt.Errorf("uitpakken: %w", err))
658
}
659
oldIndex, _ := os.ReadFile(s.mirror.Index)
660
if err := os.Rename(s.mirror.Dir, old); err != nil && !errors.Is(err, os.ErrNotExist) {
661
return fail(err)
662
}
663
if err := os.Rename(fresh, s.mirror.Dir); err != nil {
664
_ = os.Rename(old, s.mirror.Dir)
665
return fail(err)
666
}
667
if err := s.mirror.RebuildIndex(); err != nil {
668
return fail(err)
669
}
670
if err := s.sendMirror(ctx, s.remote(st), name); err != nil {
671
// Terug naar de kopie van vóór de rollback.
672
_ = os.RemoveAll(s.mirror.Dir)
673
_ = os.Rename(old, s.mirror.Dir)
674
_ = os.WriteFile(s.mirror.Index, oldIndex, 0o600)
675
s.setRollback(RollbackStatus{State: "failed", Archive: name, Error: err.Error(), At: s.now().UTC()})
676
return err
677
}
678
_ = os.RemoveAll(old)
679
s.Log.Warn("rollback klaar", "archive", name)
680
s.Kick()
681
return nil
682
}
@@ -0,0 +1,682 @@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
"encoding/json"8
"errors"9
"fmt"10
"io"11
"log/slog"12
"net/http"13
"os"14
"path/filepath"15
"strings"16
"sync"17
"time"18
19
"git.timfalken.com/timfa/bluegit-backup/internal/archive"20
"git.timfalken.com/timfa/bluegit-backup/internal/config"21
"git.timfalken.com/timfa/bluegit-backup/internal/mirror"22
"git.timfalken.com/timfa/bluegit-backup/internal/protocol"23
"git.timfalken.com/timfa/bluegit-backup/internal/throttle"24
)25
26
// Version wordt bij het bouwen gezet (-ldflags -X).27
var Version = "dev"28
29
// Server is één backup server voor één BlueGit.30
type Server struct {31
Cfg config.Config32
Log *slog.Logger33
// Now is de klok (tests).34
Now func() time.Time35
// HTTP is de client richting BlueGit (tests).36
HTTP *http.Client37
38
adminToken string39
serverID string40
limiter *throttle.Limiter41
mirror *mirror.Mirror42
archives *archive.Store43
44
// work beschermt de kopie: sync, archiveren, rollback en koppelen45
// gebeuren nooit tegelijk.46
work sync.Mutex47
48
mu sync.Mutex49
state State50
lastSync time.Time51
lastSyncErr string52
lastStats mirror.Stats53
syncs int54
notifies int55
lastArchive time.Time56
archiveErr string57
rollback RollbackStatus58
// bluegit is het protocol dat de gekoppelde BlueGit het laatst meldde.59
bluegit protocol.Peer60
bluegitKnown bool61
62
kick chan struct{}63
64
// settings is wat via webinterface, API of BlueGit is ingesteld.65
settings map[string]string66
restartPending bool67
sessions map[string]session68
loginFails map[string][]time.Time69
}70
71
// cfg is de huidige configuratie (instellingen kunnen tijdens het draaien72
// veranderen).73
func (s *Server) cfg() config.Config {74
s.mu.Lock()75
defer s.mu.Unlock()76
return s.Cfg77
}78
79
// RollbackStatus is de stand van de laatste rollback of restore.80
type RollbackStatus struct {81
State string `json:"state"` // idle | running | done | failed82
Archive string `json:"archive,omitempty"`83
Error string `json:"error,omitempty"`84
At time.Time `json:"at,omitempty"`85
}86
87
// New zet de mappen klaar en leest de koppeling.88
func New(cfg config.Config, log *slog.Logger) (*Server, error) {89
if log == nil {90
log = slog.New(slog.NewTextHandler(io.Discard, nil))91
}92
if err := os.MkdirAll(cfg.DataDir, 0o750); err != nil {93
return nil, err94
}95
set, err := config.LoadSettings(cfg.DataDir)96
if err != nil {97
return nil, err98
}99
if err := cfg.Apply(set); err != nil {100
return nil, fmt.Errorf("%s: %w", config.SettingsFile, err)101
}102
s := &Server{Cfg: cfg, Log: log, Now: time.Now, kick: make(chan struct{}, 1), settings: set, sessions: map[string]session{}}103
if s.adminToken, err = secretFile(cfg.DataDir, "admin.token", "bba_"); err != nil {104
return nil, err105
}106
if s.serverID, err = secretFile(cfg.DataDir, "server_id", ""); err != nil {107
return nil, err108
}109
if s.state, err = loadState(cfg.DataDir); err != nil {110
return nil, err111
}112
s.limiter = throttle.New(cfg.RateLimitKiB << 10)113
s.mirror = &mirror.Mirror{Dir: filepath.Join(cfg.DataDir, "mirror"), Index: filepath.Join(cfg.DataDir, "mirror.index.json")}114
s.archives = &archive.Store{Dir: filepath.Join(cfg.DataDir, "archives")}115
_ = os.RemoveAll(filepath.Join(cfg.DataDir, "tmp"))116
if list, _ := s.archives.List(); len(list) > 0 {117
s.lastArchive = list[0].CreatedAt118
}119
s.rollback.State = "idle"120
return s, nil121
}122
123
// SetFree vervangt de vrije-ruimtemeting (tests).124
func (s *Server) SetFree(f func(string) (uint64, error)) { s.archives.Free = f }125
126
// AdminToken is het lokale beheertoken.127
func (s *Server) AdminToken() string { return s.adminToken }128
129
func (s *Server) now() time.Time { return s.Now() }130
131
func (s *Server) remote(st State) *mirror.Remote {132
return &mirror.Remote{URL: st.BlueGitURL, Key: st.Key, HTTP: s.HTTP, Limiter: s.limiter, Version: Version, OnPeer: s.setBlueGit}133
}134
135
// setBlueGit legt het protocol van BlueGit vast.136
func (s *Server) setBlueGit(p protocol.Peer) {137
s.mu.Lock()138
changed := !s.bluegitKnown || s.bluegit != p139
s.bluegit, s.bluegitKnown = p, true140
s.mu.Unlock()141
if changed && p.Compat() != protocol.CompatOK {142
s.Log.Warn("niet compatibel met BlueGit", "compat", p.Compat(), "bluegit_protocol", p.Protocol, "bluegit_min", p.MinProtocol,143
"protocol", protocol.Protocol(), "min", protocol.MinProtocol())144
}145
}146
147
// compat is "" (nog onbekend), ok, bluegit_too_old of backup_too_old.148
func (s *Server) compat() (string, protocol.Peer) {149
s.mu.Lock()150
defer s.mu.Unlock()151
if !s.bluegitKnown {152
return "", s.bluegit153
}154
return s.bluegit.Compat(), s.bluegit155
}156
157
// compatMessage zegt wie er geüpdatet moet worden (leeg als alles past).158
func compatMessage(c string, p protocol.Peer) string {159
switch c {160
case protocol.CompatBlueGitTooOld:161
return fmt.Sprintf("BlueGit is verouderd (protocol %d; deze backup server vraagt minstens %d). Update BlueGit; tot dan wordt er niets gesynchroniseerd of teruggezet.", p.Protocol, protocol.MinProtocol())162
case protocol.CompatBackupTooOld:163
return fmt.Sprintf("Deze backup server is verouderd (protocol %d; BlueGit vraagt minstens %d). Update de backup server; tot dan wordt er niets gesynchroniseerd of teruggezet.", protocol.Protocol(), p.MinProtocol)164
}165
return ""166
}167
168
// ErrIncompatible: BlueGit en deze backup server passen niet bij elkaar.169
var ErrIncompatible = errors.New("niet compatibel")170
171
// checkCompat vraagt info op bij BlueGit en weigert als de protocollen niet172
// passen. Aanroepen vóór elke sync, rollback of restore.173
func (s *Server) checkCompat(ctx context.Context, rem *mirror.Remote) error {174
info, err := rem.Info(ctx)175
if err != nil {176
return err177
}178
s.setBlueGit(info.Peer())179
if c, p := s.compat(); c != protocol.CompatOK {180
return fmt.Errorf("%w: %s", ErrIncompatible, compatMessage(c, p))181
}182
return nil183
}184
185
func (s *Server) getState() State {186
s.mu.Lock()187
defer s.mu.Unlock()188
return s.state189
}190
191
// Run start de achtergrondtaken tot ctx klaar is.192
func (s *Server) Run(ctx context.Context) {193
go s.syncLoop(ctx)194
go s.archiveLoop(ctx)195
}196
197
// Kick vraagt om een sync (na een melding).198
func (s *Server) Kick() {199
select {200
case s.kick <- struct{}{}:201
default:202
}203
}204
205
func (s *Server) syncLoop(ctx context.Context) {206
s.Kick() // meteen na de start207
for {208
s.mu.Lock()209
next := s.Cfg.FullSyncInterval.Duration - s.now().Sub(s.lastSync)210
s.mu.Unlock()211
if next < 0 {212
next = 0213
}214
full := time.NewTimer(next)215
select {216
case <-ctx.Done():217
full.Stop()218
return219
case <-full.C:220
case <-s.kick:221
full.Stop()222
}223
s.mu.Lock()224
wait := s.Cfg.MinSyncInterval.Duration - s.now().Sub(s.lastSync)225
s.mu.Unlock()226
if wait > 0 {227
select {228
case <-ctx.Done():229
return230
case <-time.After(wait):231
}232
}233
// Meldingen die in de tussentijd binnenkwamen, zitten in deze sync.234
select {235
case <-s.kick:236
default:237
}238
_, _ = s.SyncNow(ctx)239
}240
}241
242
// SyncNow synchroniseert één keer.243
func (s *Server) SyncNow(ctx context.Context) (mirror.Stats, error) {244
st := s.getState()245
if !st.Connected() {246
return mirror.Stats{}, errors.New("geen BlueGit gekoppeld")247
}248
s.work.Lock()249
defer s.work.Unlock()250
st = s.getState()251
if !st.Connected() {252
return mirror.Stats{}, errors.New("geen BlueGit gekoppeld")253
}254
rem := s.remote(st)255
var stats mirror.Stats256
err := s.checkCompat(ctx, rem)257
if err == nil {258
stats, err = s.mirror.Sync(ctx, rem)259
}260
s.mu.Lock()261
s.lastSync = s.now()262
s.syncs++263
s.lastStats = stats264
if err != nil {265
s.lastSyncErr = err.Error()266
} else {267
s.lastSyncErr = ""268
}269
s.mu.Unlock()270
if err != nil {271
s.Log.Warn("sync mislukt", "err", err)272
} else if stats.Downloaded > 0 || stats.Deleted > 0 {273
s.Log.Info("sync", "files", stats.Files, "downloaded", stats.Downloaded, "bytes", stats.Bytes, "deleted", stats.Deleted)274
}275
return stats, err276
}277
278
func (s *Server) archiveLoop(ctx context.Context) {279
for {280
select {281
case <-ctx.Done():282
return283
case <-time.After(s.tick()):284
}285
s.mu.Lock()286
due := s.now().Sub(s.lastArchive) >= s.Cfg.ArchiveInterval.Duration287
synced := !s.lastSync.IsZero() && s.lastSyncErr == ""288
s.mu.Unlock()289
if due && synced {290
if _, err := s.ArchiveNow(); err != nil {291
s.Log.Warn("archief mislukt", "err", err)292
}293
}294
if _, err := s.Prune(); err != nil {295
s.Log.Warn("opruimen mislukt", "err", err)296
}297
}298
}299
300
// tick is hoe vaak de archieflus kijkt: een minuut, of korter bij een kort interval.301
func (s *Server) tick() time.Duration {302
d := s.cfg().ArchiveInterval.Duration / 4303
if d > time.Minute {304
d = time.Minute305
}306
if d < 100*time.Millisecond {307
d = 100 * time.Millisecond308
}309
return d310
}311
312
// ArchiveNow comprimeert de hele kopie tot een nieuw archief.313
func (s *Server) ArchiveNow() (archive.Archive, error) {314
s.work.Lock()315
defer s.work.Unlock()316
if s.mirror.Empty() {317
return archive.Archive{}, errors.New("de kopie is nog leeg")318
}319
now := s.now()320
a, removed, err := s.archives.Create(s.mirror.Dir, now, s.mirror.Size(), s.minFree())321
s.mu.Lock()322
if err != nil {323
s.archiveErr = err.Error()324
} else {325
s.archiveErr = ""326
s.lastArchive = now327
}328
s.mu.Unlock()329
for _, r := range removed {330
s.Log.Info("archief verwijderd: schijf vol", "archive", r)331
}332
if err != nil {333
return a, err334
}335
s.Log.Info("archief gemaakt", "archive", a.Name, "bytes", a.Size)336
if pr, err := s.archives.Prune(now, s.cfg().RetentionDays, s.minFree()); err == nil {337
for _, r := range pr {338
s.Log.Info("archief verwijderd", "archive", r)339
}340
}341
return a, nil342
}343
344
func (s *Server) minFree() uint64 { return uint64(s.cfg().MinFreeMB) << 20 }345
346
// Prune past de bewaarregels toe.347
func (s *Server) Prune() ([]string, error) {348
s.work.Lock()349
defer s.work.Unlock()350
removed, err := s.archives.Prune(s.now(), s.cfg().RetentionDays, s.minFree())351
for _, r := range removed {352
s.Log.Info("archief verwijderd", "archive", r)353
}354
return removed, err355
}356
357
func writeJSON(w http.ResponseWriter, code int, v any) {358
w.Header().Set("Content-Type", "application/json")359
w.Header().Set("Cache-Control", "no-store")360
w.WriteHeader(code)361
if v != nil {362
_ = json.NewEncoder(w).Encode(v)363
}364
}365
366
func writeErr(w http.ResponseWriter, code int, msg string) {367
writeJSON(w, code, map[string]string{"error": msg})368
}369
370
type ctxBody struct{}371
372
// signed controleert de HMAC-handtekening van de gekoppelde BlueGit.373
func (s *Server) signed(h http.HandlerFunc) http.HandlerFunc {374
return func(w http.ResponseWriter, r *http.Request) {375
st := s.getState()376
if !st.Connected() {377
writeErr(w, http.StatusUnauthorized, "niet gekoppeld")378
return379
}380
body, err := io.ReadAll(io.LimitReader(r.Body, 1<<20))381
if err != nil {382
writeErr(w, 400, "body")383
return384
}385
if r.Header.Get(protocol.HeaderInstance) != st.InstanceID {386
writeErr(w, http.StatusUnauthorized, "andere BlueGit-instantie")387
return388
}389
if err := protocol.Verify(r, protocol.SigningSecret(st.Key), body, s.now()); err != nil {390
writeErr(w, http.StatusUnauthorized, err.Error())391
return392
}393
// Zonder koppen is het een BlueGit van vóór de protocolversie.394
p, _ := protocol.BlueGitFromHeader(r.Header)395
s.setBlueGit(p)396
r = r.WithContext(context.WithValue(r.Context(), ctxBody{}, body))397
h(w, r)398
}399
}400
401
func bodyOf(r *http.Request) []byte {402
if b, ok := r.Context().Value(ctxBody{}).([]byte); ok {403
return b404
}405
b, _ := io.ReadAll(io.LimitReader(r.Body, 1<<20))406
return b407
}408
409
func (s *Server) apiNotify(w http.ResponseWriter, r *http.Request) {410
s.mu.Lock()411
s.notifies++412
s.mu.Unlock()413
s.Kick()414
w.WriteHeader(http.StatusNoContent)415
}416
417
func (s *Server) apiArchives(w http.ResponseWriter, r *http.Request) {418
list, err := s.archives.List()419
if err != nil {420
writeErr(w, 500, err.Error())421
return422
}423
writeJSON(w, 200, map[string]any{"archives": list})424
}425
426
// Status is wat GET /api/v1/status en de CLI tonen.427
type Status struct {428
Version string `json:"version"`429
ServerID string `json:"server_id"`430
BlueGitURL string `json:"bluegit_url,omitempty"`431
InstanceID string `json:"instance_id,omitempty"`432
Connected bool `json:"connected"`433
LastSync time.Time `json:"last_sync,omitempty"`434
SyncError string `json:"sync_error,omitempty"`435
LastStats mirror.Stats `json:"last_stats"`436
Syncs int `json:"syncs"`437
Notifies int `json:"notifies"`438
MirrorBytes int64 `json:"mirror_bytes"`439
Archives int `json:"archives"`440
LastArchive time.Time `json:"last_archive,omitempty"`441
ArchiveError string `json:"archive_error,omitempty"`442
Interval string `json:"archive_interval"`443
RetentionDays int `json:"retention_days"`444
RateLimitKiB int64 `json:"rate_limit_kib"`445
Rollback RollbackStatus `json:"rollback"`446
// Protocol van deze server en van BlueGit; Compat is "" (nog447
// onbekend), ok, bluegit_too_old of backup_too_old.448
Protocol int `json:"protocol"`449
MinProtocol int `json:"min_protocol"`450
BlueGitProtocol int `json:"bluegit_protocol,omitempty"`451
BlueGitMinProtocol int `json:"bluegit_min_protocol,omitempty"`452
BlueGitVersion string `json:"bluegit_version,omitempty"`453
Compat string `json:"compat"`454
CompatMessage string `json:"compat_message,omitempty"`455
}456
457
// Status geeft de huidige stand.458
func (s *Server) Status() Status {459
list, _ := s.archives.List()460
compat, peer := s.compat()461
s.mu.Lock()462
defer s.mu.Unlock()463
st := Status{464
Version: Version, ServerID: s.serverID, BlueGitURL: s.state.BlueGitURL, InstanceID: s.state.InstanceID,465
Connected: s.state.Connected(), LastSync: s.lastSync, SyncError: s.lastSyncErr, LastStats: s.lastStats,466
Syncs: s.syncs, Notifies: s.notifies, MirrorBytes: s.mirror.Size(), Archives: len(list),467
LastArchive: s.lastArchive, ArchiveError: s.archiveErr, Interval: s.Cfg.ArchiveInterval.String(),468
RetentionDays: s.Cfg.RetentionDays, RateLimitKiB: s.Cfg.RateLimitKiB, Rollback: s.rollback,469
Protocol: protocol.Protocol(), MinProtocol: protocol.MinProtocol(), Compat: compat, CompatMessage: compatMessage(compat, peer),470
}471
if s.bluegitKnown {472
st.BlueGitProtocol, st.BlueGitMinProtocol, st.BlueGitVersion = peer.Protocol, peer.MinProtocol, peer.Version473
}474
return st475
}476
477
func (s *Server) apiStatus(w http.ResponseWriter, r *http.Request) { writeJSON(w, 200, s.Status()) }478
479
// ---------- koppelen ----------480
481
// ConnectRequest is POST /api/v1/admin/connect.482
type ConnectRequest struct {483
URL string `json:"url"`484
Key string `json:"key"`485
// OnConflict is leeg, "wipe" of "restore". Leeg en een andere BlueGit486
// dan de vorige: 409 met de keuzes.487
OnConflict string `json:"on_conflict"`488
}489
490
// ConflictError is het 409-antwoord bij een andere BlueGit.491
type ConflictError struct {492
Conflict bool `json:"conflict"`493
Error string `json:"error"`494
PreviousURL string `json:"previous_url"`495
PreviousInstance string `json:"previous_instance"`496
NewInstance string `json:"new_instance"`497
Archives int `json:"archives"`498
Choices []string `json:"choices"`499
}500
501
var errBadRequest = errors.New("ongeldig verzoek")502
503
// Connect koppelt deze server aan een BlueGit. Er is er altijd hoogstens één.504
func (s *Server) Connect(ctx context.Context, in ConnectRequest) (map[string]any, *ConflictError, error) {505
in.URL = strings.TrimRight(strings.TrimSpace(in.URL), "/")506
in.Key = strings.TrimSpace(in.Key)507
if !strings.HasPrefix(in.URL, "http://") && !strings.HasPrefix(in.URL, "https://") {508
return nil, nil, fmt.Errorf("%w: url moet met http:// of https:// beginnen", errBadRequest)509
}510
if !strings.HasPrefix(in.Key, protocol.KeyPrefix) {511
return nil, nil, fmt.Errorf("%w: de Backupserver-Key begint met %s", errBadRequest, protocol.KeyPrefix)512
}513
switch in.OnConflict {514
case "", "wipe", "restore":515
default:516
return nil, nil, fmt.Errorf("%w: on_conflict moet wipe of restore zijn", errBadRequest)517
}518
pub := s.cfg().PublicURL519
if pub == "" {520
return nil, nil, fmt.Errorf("%w: zet public_url in de configuratie; BlueGit moet deze server kunnen bereiken", errBadRequest)521
}522
s.work.Lock()523
defer s.work.Unlock()524
rem := &mirror.Remote{URL: in.URL, Key: in.Key, HTTP: s.HTTP, Limiter: s.limiter, Version: Version, OnPeer: s.setBlueGit}525
info, err := rem.Info(ctx)526
if err != nil {527
return nil, nil, err528
}529
// Ook bij een niet-passende BlueGit koppelen we, zodat BlueGit het zijn530
// beheerders kan laten zien; synchroniseren en terugzetten gebeurt dan niet.531
s.setBlueGit(info.Peer())532
compat := info.Peer().Compat()533
old := s.getState()534
list, _ := s.archives.List()535
hasData := !s.mirror.Empty() || len(list) > 0536
other := old.InstanceID != "" && old.InstanceID != info.InstanceID && hasData537
mode := ""538
if other {539
if in.OnConflict == "" {540
return nil, &ConflictError{541
Conflict: true, Error: "deze backup server hoort bij een andere BlueGit",542
PreviousURL: old.BlueGitURL, PreviousInstance: old.InstanceID, NewInstance: info.InstanceID,543
Archives: len(list), Choices: []string{"wipe", "restore"},544
}, nil545
}546
mode = in.OnConflict547
}548
if mode == "wipe" {549
if err := s.mirror.Wipe(); err != nil {550
return nil, nil, err551
}552
if err := s.archives.DeleteAll(); err != nil {553
return nil, nil, err554
}555
s.mu.Lock()556
s.lastArchive = time.Time{}557
s.mu.Unlock()558
s.Log.Warn("oude backups verwijderd voor een nieuwe BlueGit", "old", old.InstanceID, "new", info.InstanceID)559
}560
if mode == "restore" && compat != protocol.CompatOK {561
return nil, nil, fmt.Errorf("%w: %s", ErrIncompatible, compatMessage(compat, info.Peer()))562
}563
if mode == "restore" && s.mirror.Empty() {564
return nil, nil, fmt.Errorf("%w: de kopie is leeg; er is niets om terug te zetten", errBadRequest)565
}566
if err := rem.Connect(ctx, pub, s.serverID); err != nil {567
return nil, nil, err568
}569
st := State{BlueGitURL: in.URL, Key: in.Key, InstanceID: info.InstanceID, ConnectedAt: s.now().UTC()}570
if err := saveState(s.Cfg.DataDir, st); err != nil {571
return nil, nil, err572
}573
s.mu.Lock()574
s.state = st575
s.mu.Unlock()576
s.Log.Info("gekoppeld", "bluegit", in.URL, "instance", info.InstanceID, "mode", mode)577
out := map[string]any{"instance_id": info.InstanceID, "bluegit_url": in.URL, "mode": mode, "compat": compat}578
if msg := compatMessage(compat, info.Peer()); msg != "" {579
out["warning"] = msg580
}581
if mode == "restore" {582
if err := s.sendMirror(ctx, rem, "restore"); err != nil {583
return nil, nil, fmt.Errorf("terugzetten naar de nieuwe BlueGit mislukt: %w", err)584
}585
out["restored"] = true586
}587
s.Kick()588
return out, nil, nil589
}590
591
// sendMirror stuurt de hele kopie als tar.gz naar BlueGit en wacht tot die592
// herstart is. Aanroepen met s.work vast.593
func (s *Server) sendMirror(ctx context.Context, rem *mirror.Remote, label string) error {594
s.setRollback(RollbackStatus{State: "running", Archive: label, At: s.now().UTC()})595
pr, pw := io.Pipe()596
go func() { pw.CloseWithError(archive.WriteTarGz(pw, s.mirror.Dir)) }()597
if err := rem.Restore(ctx, pr); err != nil {598
pr.CloseWithError(err)599
s.setRollback(RollbackStatus{State: "failed", Archive: label, Error: err.Error(), At: s.now().UTC()})600
return err601
}602
if err := rem.WaitUp(ctx, 3*time.Minute); err != nil {603
s.setRollback(RollbackStatus{State: "failed", Archive: label, Error: err.Error(), At: s.now().UTC()})604
return err605
}606
s.setRollback(RollbackStatus{State: "done", Archive: label, At: s.now().UTC()})607
return nil608
}609
610
func (s *Server) setRollback(r RollbackStatus) {611
s.mu.Lock()612
s.rollback = r613
s.mu.Unlock()614
}615
616
// ---------- rollback ----------617
618
func (s *Server) apiRollback(w http.ResponseWriter, r *http.Request) {619
var in struct {620
Archive string `json:"archive"`621
}622
if err := json.Unmarshal(bodyOf(r), &in); err != nil || !archive.ValidName(in.Archive) {623
writeErr(w, 400, "ongeldige archiefnaam")624
return625
}626
code, out := s.startRollback(in.Archive)627
writeJSON(w, code, out)628
}629
630
// Rollback pakt een archief uit, vervangt daarmee de draaiende kopie en631
// stuurt die naar BlueGit. Lukt het sturen niet, dan komt de oude kopie632
// terug, zodat kopie en BlueGit gelijk blijven.633
func (s *Server) Rollback(ctx context.Context, name string) error {634
s.work.Lock()635
defer s.work.Unlock()636
fail := func(err error) error {637
s.setRollback(RollbackStatus{State: "failed", Archive: name, Error: err.Error(), At: s.now().UTC()})638
return err639
}640
st := s.getState()641
if !st.Connected() {642
return fail(errors.New("geen BlueGit gekoppeld"))643
}644
if err := s.checkCompat(ctx, s.remote(st)); err != nil {645
return fail(err)646
}647
src, err := s.archives.Path(name)648
if err != nil {649
return fail(err)650
}651
fresh := filepath.Join(s.Cfg.DataDir, "mirror.rollback")652
old := filepath.Join(s.Cfg.DataDir, "mirror.old")653
_ = os.RemoveAll(fresh)654
_ = os.RemoveAll(old)655
if err := archive.Extract(src, fresh); err != nil {656
_ = os.RemoveAll(fresh)657
return fail(fmt.Errorf("uitpakken: %w", err))658
}659
oldIndex, _ := os.ReadFile(s.mirror.Index)660
if err := os.Rename(s.mirror.Dir, old); err != nil && !errors.Is(err, os.ErrNotExist) {661
return fail(err)662
}663
if err := os.Rename(fresh, s.mirror.Dir); err != nil {664
_ = os.Rename(old, s.mirror.Dir)665
return fail(err)666
}667
if err := s.mirror.RebuildIndex(); err != nil {668
return fail(err)669
}670
if err := s.sendMirror(ctx, s.remote(st), name); err != nil {671
// Terug naar de kopie van vóór de rollback.672
_ = os.RemoveAll(s.mirror.Dir)673
_ = os.Rename(old, s.mirror.Dir)674
_ = os.WriteFile(s.mirror.Index, oldIndex, 0o600)675
s.setRollback(RollbackStatus{State: "failed", Archive: name, Error: err.Error(), At: s.now().UTC()})676
return err677
}678
_ = os.RemoveAll(old)679
s.Log.Warn("rollback klaar", "archive", name)680
s.Kick()681
return nil682
}@@ -0,0 +1,201 @@
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
}
@@ -0,0 +1,201 @@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
}@@ -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,303 @@
1
package server
2
3
import (
4
"crypto/rand"
5
"crypto/subtle"
6
"embed"
7
"encoding/hex"
8
"encoding/json"
9
"fmt"
10
"html/template"
11
"net"
12
"net/http"
13
"net/url"
14
"strings"
15
"time"
16
17
"git.timfalken.com/timfa/bluegit-backup/internal/archive"
18
)
19
20
//go:embed web/*
21
var webFS embed.FS
22
23
var uiTmpl = template.Must(template.New("").Funcs(template.FuncMap{
24
"bytes": humanBytes,
25
"when": func(t time.Time) string {
26
if t.IsZero() {
27
return "nog niet"
28
}
29
return t.Local().Format("2006-01-02 15:04:05")
30
},
31
"json": func(v any) string { b, _ := json.MarshalIndent(v, "", " "); return string(b) },
32
}).ParseFS(webFS, "web/*.html"))
33
34
const (
35
sessionCookie = "bbsession"
36
sessionTTL = 12 * time.Hour
37
)
38
39
type session struct {
40
csrf string
41
expires time.Time
42
flash string
43
isErr bool
44
}
45
46
func randHex(n int) string {
47
b := make([]byte, n)
48
_, _ = rand.Read(b)
49
return hex.EncodeToString(b)
50
}
51
52
func humanBytes(n int64) string {
53
const unit = 1024
54
if n < unit {
55
return fmt.Sprintf("%d B", n)
56
}
57
div, exp := int64(unit), 0
58
for m := n / unit; m >= unit; m /= unit {
59
div *= unit
60
exp++
61
}
62
return fmt.Sprintf("%.1f %ciB", float64(n)/float64(div), "KMGTPE"[exp])
63
}
64
65
func (s *Server) session(r *http.Request) (session, bool) {
66
c, err := r.Cookie(sessionCookie)
67
if err != nil || c.Value == "" {
68
return session{}, false
69
}
70
s.mu.Lock()
71
defer s.mu.Unlock()
72
sess, ok := s.sessions[c.Value]
73
if !ok || s.now().After(sess.expires) {
74
delete(s.sessions, c.Value)
75
return session{}, false
76
}
77
return sess, true
78
}
79
80
func (s *Server) setFlash(r *http.Request, msg string, isErr bool) {
81
c, err := r.Cookie(sessionCookie)
82
if err != nil {
83
return
84
}
85
s.mu.Lock()
86
defer s.mu.Unlock()
87
if sess, ok := s.sessions[c.Value]; ok {
88
sess.flash, sess.isErr = msg, isErr
89
s.sessions[c.Value] = sess
90
}
91
}
92
93
func (s *Server) takeFlash(r *http.Request) (string, bool) {
94
c, err := r.Cookie(sessionCookie)
95
if err != nil {
96
return "", false
97
}
98
s.mu.Lock()
99
defer s.mu.Unlock()
100
sess, ok := s.sessions[c.Value]
101
if !ok {
102
return "", false
103
}
104
msg, isErr := sess.flash, sess.isErr
105
sess.flash, sess.isErr = "", false
106
s.sessions[c.Value] = sess
107
return msg, isErr
108
}
109
110
func clientIP(r *http.Request) string {
111
h, _, err := net.SplitHostPort(r.RemoteAddr)
112
if err != nil {
113
return r.RemoteAddr
114
}
115
return h
116
}
117
118
// loginAllowed: hoogstens 5 foute pogingen per minuut per IP-adres.
119
func (s *Server) loginAllowed(ip string, failed bool) bool {
120
s.mu.Lock()
121
defer s.mu.Unlock()
122
if s.loginFails == nil {
123
s.loginFails = map[string][]time.Time{}
124
}
125
cut := s.now().Add(-time.Minute)
126
keep := s.loginFails[ip][:0]
127
for _, t := range s.loginFails[ip] {
128
if t.After(cut) {
129
keep = append(keep, t)
130
}
131
}
132
if failed {
133
keep = append(keep, s.now())
134
}
135
s.loginFails[ip] = keep
136
return len(keep) < 5
137
}
138
139
func (s *Server) mountUI(mux *http.ServeMux) {
140
mux.HandleFunc("GET /{$}", s.uiIndex)
141
mux.HandleFunc("GET /login", s.uiLoginPage)
142
mux.HandleFunc("POST /login", s.uiLogin)
143
mux.HandleFunc("POST /logout", s.uiLogout)
144
mux.HandleFunc("POST /ui/act/{name}", s.uiAct)
145
}
146
147
func (s *Server) render(w http.ResponseWriter, name string, data any) {
148
w.Header().Set("Content-Type", "text/html; charset=utf-8")
149
w.Header().Set("Cache-Control", "no-store")
150
w.Header().Set("Content-Security-Policy", "default-src 'self'; style-src 'self' 'unsafe-inline'; script-src 'none'; frame-ancestors 'none'; form-action 'self'")
151
w.Header().Set("X-Frame-Options", "DENY")
152
if err := uiTmpl.ExecuteTemplate(w, name, data); err != nil {
153
s.Log.Error("template", "name", name, "err", err)
154
}
155
}
156
157
func (s *Server) uiLoginPage(w http.ResponseWriter, r *http.Request) {
158
if _, ok := s.session(r); ok {
159
http.Redirect(w, r, "/", http.StatusSeeOther)
160
return
161
}
162
s.render(w, "login.html", map[string]any{"Error": r.URL.Query().Get("fout") != "", "Version": Version})
163
}
164
165
func (s *Server) uiLogin(w http.ResponseWriter, r *http.Request) {
166
ip := clientIP(r)
167
if !s.loginAllowed(ip, false) {
168
http.Error(w, "te veel pogingen, wacht een minuut", http.StatusTooManyRequests)
169
return
170
}
171
tok := strings.TrimSpace(r.PostFormValue("token"))
172
if subtle.ConstantTimeCompare([]byte(tok), []byte(s.adminToken)) != 1 {
173
s.loginAllowed(ip, true)
174
http.Redirect(w, r, "/login?fout=1", http.StatusSeeOther)
175
return
176
}
177
id := randHex(32)
178
s.mu.Lock()
179
for k, v := range s.sessions {
180
if s.now().After(v.expires) {
181
delete(s.sessions, k)
182
}
183
}
184
s.sessions[id] = session{csrf: randHex(16), expires: s.now().Add(sessionTTL)}
185
s.mu.Unlock()
186
http.SetCookie(w, &http.Cookie{Name: sessionCookie, Value: id, Path: "/", HttpOnly: true,
187
SameSite: http.SameSiteStrictMode, Secure: r.TLS != nil || r.Header.Get("X-Forwarded-Proto") == "https",
188
MaxAge: int(sessionTTL / time.Second)})
189
http.Redirect(w, r, "/", http.StatusSeeOther)
190
}
191
192
func (s *Server) uiLogout(w http.ResponseWriter, r *http.Request) {
193
if sess, ok := s.session(r); ok && r.PostFormValue("csrf") == sess.csrf {
194
c, _ := r.Cookie(sessionCookie)
195
s.mu.Lock()
196
delete(s.sessions, c.Value)
197
s.mu.Unlock()
198
}
199
http.SetCookie(w, &http.Cookie{Name: sessionCookie, Value: "", Path: "/", MaxAge: -1, HttpOnly: true})
200
http.Redirect(w, r, "/login", http.StatusSeeOther)
201
}
202
203
// pageData is wat de webinterface toont: precies de uitkomst van de
204
// GET-acties uit Actions.
205
type pageData struct {
206
CSRF string
207
Flash string
208
FlashErr bool
209
Status Status
210
Config ConfigView
211
Archives []archive.Archive
212
Actions []Action
213
Version string
214
}
215
216
func (s *Server) uiIndex(w http.ResponseWriter, r *http.Request) {
217
sess, ok := s.session(r)
218
if !ok {
219
http.Redirect(w, r, "/login", http.StatusSeeOther)
220
return
221
}
222
d := pageData{CSRF: sess.csrf, Status: s.Status(), Config: s.ConfigView(), Actions: s.Actions(), Version: Version}
223
d.Archives, _ = s.archives.List()
224
d.Flash, d.FlashErr = s.takeFlash(r)
225
s.render(w, "index.html", d)
226
}
227
228
// uiAct voert een actie uit vanuit een formulier, via dezelfde code als de API.
229
func (s *Server) uiAct(w http.ResponseWriter, r *http.Request) {
230
sess, ok := s.session(r)
231
if !ok {
232
http.Redirect(w, r, "/login", http.StatusSeeOther)
233
return
234
}
235
if err := r.ParseForm(); err != nil {
236
http.Error(w, "formulier", 400)
237
return
238
}
239
if subtle.ConstantTimeCompare([]byte(r.PostFormValue("csrf")), []byte(sess.csrf)) != 1 {
240
http.Error(w, "CSRF-token klopt niet; laad de pagina opnieuw", http.StatusForbidden)
241
return
242
}
243
a, ok := s.action(r.PathValue("name"))
244
if !ok || a.Method == http.MethodGet {
245
http.NotFound(w, r)
246
return
247
}
248
in := Input{}
249
for k, v := range r.PostForm {
250
if k == "csrf" || k == "understood" || len(v) == 0 {
251
continue
252
}
253
in[k] = v[0]
254
}
255
anchor := "#" + strings.SplitN(a.Name, ".", 2)[0]
256
if a.Name == "rollback" && r.PostFormValue("understood") == "" {
257
s.setFlash(r, "Vink aan dat je begrijpt dat een rollback niet ongedaan kan worden gemaakt.", true)
258
http.Redirect(w, r, "/#archives", http.StatusSeeOther)
259
return
260
}
261
if a.Name == "sync" {
262
in["wait"] = "false"
263
}
264
code, out := a.Do(r.Context(), in)
265
msg, isErr := describe(a, code, out)
266
s.setFlash(r, msg, isErr)
267
http.Redirect(w, r, "/"+anchor, http.StatusSeeOther)
268
}
269
270
func describe(a Action, code int, out any) (string, bool) {
271
if code >= 400 {
272
switch v := out.(type) {
273
case *ConflictError:
274
return fmt.Sprintf("%s (vorige: %s, %d archieven). Kies hieronder ‘oude backups wissen’ of ‘nieuwe BlueGit herstellen’ en koppel opnieuw.", v.Error, v.PreviousURL, v.Archives), true
275
case map[string]string:
276
return a.Title + " mislukt: " + v["error"], true
277
}
278
return fmt.Sprintf("%s mislukt (HTTP %d)", a.Title, code), true
279
}
280
switch a.Name {
281
case "sync":
282
return "Synchronisatie gestart.", false
283
case "archive":
284
if v, ok := out.(archive.Archive); ok {
285
return "Archief gemaakt: " + v.Name, false
286
}
287
case "prune":
288
if v, ok := out.(map[string]any); ok {
289
return fmt.Sprintf("Opgeruimd: %d archieven.", len(v["removed"].([]string))), false
290
}
291
case "rollback":
292
return "Rollback gestart. BlueGit herstart zodra de data er staat.", false
293
case "config.update":
294
if v, ok := out.(ConfigView); ok && v.Restart {
295
return "Instellingen opgeslagen. Een deel geldt pas na een herstart.", false
296
}
297
return "Instellingen opgeslagen.", false
298
}
299
return a.Title + ": gelukt.", false
300
}
301
302
// UIPath is het formulieradres van een actie in de webinterface.
303
func UIPath(a Action) string { return "/ui/act/" + url.PathEscape(a.Name) }
@@ -0,0 +1,303 @@1
package server2
3
import (4
"crypto/rand"5
"crypto/subtle"6
"embed"7
"encoding/hex"8
"encoding/json"9
"fmt"10
"html/template"11
"net"12
"net/http"13
"net/url"14
"strings"15
"time"16
17
"git.timfalken.com/timfa/bluegit-backup/internal/archive"18
)19
20
//go:embed web/*21
var webFS embed.FS22
23
var uiTmpl = template.Must(template.New("").Funcs(template.FuncMap{24
"bytes": humanBytes,25
"when": func(t time.Time) string {26
if t.IsZero() {27
return "nog niet"28
}29
return t.Local().Format("2006-01-02 15:04:05")30
},31
"json": func(v any) string { b, _ := json.MarshalIndent(v, "", " "); return string(b) },32
}).ParseFS(webFS, "web/*.html"))33
34
const (35
sessionCookie = "bbsession"36
sessionTTL = 12 * time.Hour37
)38
39
type session struct {40
csrf string41
expires time.Time42
flash string43
isErr bool44
}45
46
func randHex(n int) string {47
b := make([]byte, n)48
_, _ = rand.Read(b)49
return hex.EncodeToString(b)50
}51
52
func humanBytes(n int64) string {53
const unit = 102454
if n < unit {55
return fmt.Sprintf("%d B", n)56
}57
div, exp := int64(unit), 058
for m := n / unit; m >= unit; m /= unit {59
div *= unit60
exp++61
}62
return fmt.Sprintf("%.1f %ciB", float64(n)/float64(div), "KMGTPE"[exp])63
}64
65
func (s *Server) session(r *http.Request) (session, bool) {66
c, err := r.Cookie(sessionCookie)67
if err != nil || c.Value == "" {68
return session{}, false69
}70
s.mu.Lock()71
defer s.mu.Unlock()72
sess, ok := s.sessions[c.Value]73
if !ok || s.now().After(sess.expires) {74
delete(s.sessions, c.Value)75
return session{}, false76
}77
return sess, true78
}79
80
func (s *Server) setFlash(r *http.Request, msg string, isErr bool) {81
c, err := r.Cookie(sessionCookie)82
if err != nil {83
return84
}85
s.mu.Lock()86
defer s.mu.Unlock()87
if sess, ok := s.sessions[c.Value]; ok {88
sess.flash, sess.isErr = msg, isErr89
s.sessions[c.Value] = sess90
}91
}92
93
func (s *Server) takeFlash(r *http.Request) (string, bool) {94
c, err := r.Cookie(sessionCookie)95
if err != nil {96
return "", false97
}98
s.mu.Lock()99
defer s.mu.Unlock()100
sess, ok := s.sessions[c.Value]101
if !ok {102
return "", false103
}104
msg, isErr := sess.flash, sess.isErr105
sess.flash, sess.isErr = "", false106
s.sessions[c.Value] = sess107
return msg, isErr108
}109
110
func clientIP(r *http.Request) string {111
h, _, err := net.SplitHostPort(r.RemoteAddr)112
if err != nil {113
return r.RemoteAddr114
}115
return h116
}117
118
// loginAllowed: hoogstens 5 foute pogingen per minuut per IP-adres.119
func (s *Server) loginAllowed(ip string, failed bool) bool {120
s.mu.Lock()121
defer s.mu.Unlock()122
if s.loginFails == nil {123
s.loginFails = map[string][]time.Time{}124
}125
cut := s.now().Add(-time.Minute)126
keep := s.loginFails[ip][:0]127
for _, t := range s.loginFails[ip] {128
if t.After(cut) {129
keep = append(keep, t)130
}131
}132
if failed {133
keep = append(keep, s.now())134
}135
s.loginFails[ip] = keep136
return len(keep) < 5137
}138
139
func (s *Server) mountUI(mux *http.ServeMux) {140
mux.HandleFunc("GET /{$}", s.uiIndex)141
mux.HandleFunc("GET /login", s.uiLoginPage)142
mux.HandleFunc("POST /login", s.uiLogin)143
mux.HandleFunc("POST /logout", s.uiLogout)144
mux.HandleFunc("POST /ui/act/{name}", s.uiAct)145
}146
147
func (s *Server) render(w http.ResponseWriter, name string, data any) {148
w.Header().Set("Content-Type", "text/html; charset=utf-8")149
w.Header().Set("Cache-Control", "no-store")150
w.Header().Set("Content-Security-Policy", "default-src 'self'; style-src 'self' 'unsafe-inline'; script-src 'none'; frame-ancestors 'none'; form-action 'self'")151
w.Header().Set("X-Frame-Options", "DENY")152
if err := uiTmpl.ExecuteTemplate(w, name, data); err != nil {153
s.Log.Error("template", "name", name, "err", err)154
}155
}156
157
func (s *Server) uiLoginPage(w http.ResponseWriter, r *http.Request) {158
if _, ok := s.session(r); ok {159
http.Redirect(w, r, "/", http.StatusSeeOther)160
return161
}162
s.render(w, "login.html", map[string]any{"Error": r.URL.Query().Get("fout") != "", "Version": Version})163
}164
165
func (s *Server) uiLogin(w http.ResponseWriter, r *http.Request) {166
ip := clientIP(r)167
if !s.loginAllowed(ip, false) {168
http.Error(w, "te veel pogingen, wacht een minuut", http.StatusTooManyRequests)169
return170
}171
tok := strings.TrimSpace(r.PostFormValue("token"))172
if subtle.ConstantTimeCompare([]byte(tok), []byte(s.adminToken)) != 1 {173
s.loginAllowed(ip, true)174
http.Redirect(w, r, "/login?fout=1", http.StatusSeeOther)175
return176
}177
id := randHex(32)178
s.mu.Lock()179
for k, v := range s.sessions {180
if s.now().After(v.expires) {181
delete(s.sessions, k)182
}183
}184
s.sessions[id] = session{csrf: randHex(16), expires: s.now().Add(sessionTTL)}185
s.mu.Unlock()186
http.SetCookie(w, &http.Cookie{Name: sessionCookie, Value: id, Path: "/", HttpOnly: true,187
SameSite: http.SameSiteStrictMode, Secure: r.TLS != nil || r.Header.Get("X-Forwarded-Proto") == "https",188
MaxAge: int(sessionTTL / time.Second)})189
http.Redirect(w, r, "/", http.StatusSeeOther)190
}191
192
func (s *Server) uiLogout(w http.ResponseWriter, r *http.Request) {193
if sess, ok := s.session(r); ok && r.PostFormValue("csrf") == sess.csrf {194
c, _ := r.Cookie(sessionCookie)195
s.mu.Lock()196
delete(s.sessions, c.Value)197
s.mu.Unlock()198
}199
http.SetCookie(w, &http.Cookie{Name: sessionCookie, Value: "", Path: "/", MaxAge: -1, HttpOnly: true})200
http.Redirect(w, r, "/login", http.StatusSeeOther)201
}202
203
// pageData is wat de webinterface toont: precies de uitkomst van de204
// GET-acties uit Actions.205
type pageData struct {206
CSRF string207
Flash string208
FlashErr bool209
Status Status210
Config ConfigView211
Archives []archive.Archive212
Actions []Action213
Version string214
}215
216
func (s *Server) uiIndex(w http.ResponseWriter, r *http.Request) {217
sess, ok := s.session(r)218
if !ok {219
http.Redirect(w, r, "/login", http.StatusSeeOther)220
return221
}222
d := pageData{CSRF: sess.csrf, Status: s.Status(), Config: s.ConfigView(), Actions: s.Actions(), Version: Version}223
d.Archives, _ = s.archives.List()224
d.Flash, d.FlashErr = s.takeFlash(r)225
s.render(w, "index.html", d)226
}227
228
// uiAct voert een actie uit vanuit een formulier, via dezelfde code als de API.229
func (s *Server) uiAct(w http.ResponseWriter, r *http.Request) {230
sess, ok := s.session(r)231
if !ok {232
http.Redirect(w, r, "/login", http.StatusSeeOther)233
return234
}235
if err := r.ParseForm(); err != nil {236
http.Error(w, "formulier", 400)237
return238
}239
if subtle.ConstantTimeCompare([]byte(r.PostFormValue("csrf")), []byte(sess.csrf)) != 1 {240
http.Error(w, "CSRF-token klopt niet; laad de pagina opnieuw", http.StatusForbidden)241
return242
}243
a, ok := s.action(r.PathValue("name"))244
if !ok || a.Method == http.MethodGet {245
http.NotFound(w, r)246
return247
}248
in := Input{}249
for k, v := range r.PostForm {250
if k == "csrf" || k == "understood" || len(v) == 0 {251
continue252
}253
in[k] = v[0]254
}255
anchor := "#" + strings.SplitN(a.Name, ".", 2)[0]256
if a.Name == "rollback" && r.PostFormValue("understood") == "" {257
s.setFlash(r, "Vink aan dat je begrijpt dat een rollback niet ongedaan kan worden gemaakt.", true)258
http.Redirect(w, r, "/#archives", http.StatusSeeOther)259
return260
}261
if a.Name == "sync" {262
in["wait"] = "false"263
}264
code, out := a.Do(r.Context(), in)265
msg, isErr := describe(a, code, out)266
s.setFlash(r, msg, isErr)267
http.Redirect(w, r, "/"+anchor, http.StatusSeeOther)268
}269
270
func describe(a Action, code int, out any) (string, bool) {271
if code >= 400 {272
switch v := out.(type) {273
case *ConflictError:274
return fmt.Sprintf("%s (vorige: %s, %d archieven). Kies hieronder ‘oude backups wissen’ of ‘nieuwe BlueGit herstellen’ en koppel opnieuw.", v.Error, v.PreviousURL, v.Archives), true275
case map[string]string:276
return a.Title + " mislukt: " + v["error"], true277
}278
return fmt.Sprintf("%s mislukt (HTTP %d)", a.Title, code), true279
}280
switch a.Name {281
case "sync":282
return "Synchronisatie gestart.", false283
case "archive":284
if v, ok := out.(archive.Archive); ok {285
return "Archief gemaakt: " + v.Name, false286
}287
case "prune":288
if v, ok := out.(map[string]any); ok {289
return fmt.Sprintf("Opgeruimd: %d archieven.", len(v["removed"].([]string))), false290
}291
case "rollback":292
return "Rollback gestart. BlueGit herstart zodra de data er staat.", false293
case "config.update":294
if v, ok := out.(ConfigView); ok && v.Restart {295
return "Instellingen opgeslagen. Een deel geldt pas na een herstart.", false296
}297
return "Instellingen opgeslagen.", false298
}299
return a.Title + ": gelukt.", false300
}301
302
// UIPath is het formulieradres van een actie in de webinterface.303
func UIPath(a Action) string { return "/ui/act/" + url.PathEscape(a.Name) }@@ -0,0 +1,285 @@
1
package server
2
3
import (
4
"bytes"
5
"encoding/json"
6
"net/http"
7
"net/http/httptest"
8
"net/url"
9
"os"
10
"path/filepath"
11
"regexp"
12
"strings"
13
"testing"
14
"time"
15
16
"git.timfalken.com/timfa/bluegit-backup/internal/config"
17
"git.timfalken.com/timfa/bluegit-backup/internal/protocol"
18
)
19
20
// uiClient is een browser met een cookie.
21
type uiClient struct {
22
t *testing.T
23
h http.Handler
24
cookie *http.Cookie
25
}
26
27
func (c *uiClient) do(method, p string, form url.Values) *httptest.ResponseRecorder {
28
var body *strings.Reader
29
if form != nil {
30
body = strings.NewReader(form.Encode())
31
} else {
32
body = strings.NewReader("")
33
}
34
r := httptest.NewRequest(method, p, body)
35
if form != nil {
36
r.Header.Set("Content-Type", "application/x-www-form-urlencoded")
37
}
38
if c.cookie != nil {
39
r.AddCookie(c.cookie)
40
}
41
w := httptest.NewRecorder()
42
c.h.ServeHTTP(w, r)
43
for _, ck := range w.Result().Cookies() {
44
if ck.Name == sessionCookie {
45
c.cookie = ck
46
}
47
}
48
return w
49
}
50
51
var csrfRE = regexp.MustCompile(`name="csrf" value="([0-9a-f]+)"`)
52
53
func login(t *testing.T, s *Server) (*uiClient, string) {
54
c := &uiClient{t: t, h: s.Handler()}
55
if w := c.do("GET", "/", nil); w.Code != 303 || w.Header().Get("Location") != "/login" {
56
t.Fatalf("zonder sessie: %d %s", w.Code, w.Header().Get("Location"))
57
}
58
if w := c.do("POST", "/login", url.Values{"token": {"fout"}}); w.Header().Get("Location") != "/login?fout=1" {
59
t.Fatalf("fout token: %s", w.Header().Get("Location"))
60
}
61
if w := c.do("POST", "/login", url.Values{"token": {s.AdminToken()}}); w.Code != 303 || c.cookie == nil {
62
t.Fatalf("login %d", w.Code)
63
}
64
if !c.cookie.HttpOnly || c.cookie.SameSite != http.SameSiteStrictMode {
65
t.Fatalf("cookie %+v", c.cookie)
66
}
67
w := c.do("GET", "/", nil)
68
if w.Code != 200 {
69
t.Fatalf("index %d", w.Code)
70
}
71
m := csrfRE.FindStringSubmatch(w.Body.String())
72
if m == nil {
73
t.Fatal("geen csrf")
74
}
75
return c, m[1]
76
}
77
78
// Elke wijzigende actie heeft een formulier in de webinterface, elke
79
// beheerroute zit in Actions, en elk formulier hoort bij een actie.
80
func TestUIAndAPIParity(t *testing.T) {
81
f := newFake(t)
82
s := newTestServer(t)
83
if w := adminReq(s, "POST", "/api/v1/admin/connect", `{"url":"`+f.ts.URL+`","key":"bgbk_test"}`); w.Code != 200 {
84
t.Fatal(w.Body)
85
}
86
if _, err := s.SyncNow(t.Context()); err != nil {
87
t.Fatal(err)
88
}
89
if _, err := s.ArchiveNow(); err != nil {
90
t.Fatal(err)
91
}
92
c, _ := login(t, s)
93
page := c.do("GET", "/", nil).Body.String()
94
// Het koppelformulier staat in een uitklapper zodra er gekoppeld is; het
95
// moet er nog steeds zijn.
96
forms := map[string]bool{}
97
for _, m := range regexp.MustCompile(`action="/ui/act/([a-z.]+)"`).FindAllStringSubmatch(page, -1) {
98
forms[m[1]] = true
99
}
100
for _, a := range s.Actions() {
101
switch a.Method {
102
case "GET":
103
// Getoond op de pagina; download als link.
104
if a.Name == "archive.download" && !strings.Contains(page, "/download\">Downloaden") {
105
t.Errorf("geen downloadlink")
106
}
107
default:
108
if !forms[a.Name] {
109
t.Errorf("actie %s (%s %s) heeft geen formulier in de webinterface", a.Name, a.Method, a.Path)
110
}
111
delete(forms, a.Name)
112
}
113
}
114
for f := range forms {
115
t.Errorf("formulier %s hoort bij geen API-actie", f)
116
}
117
// Alle GET-acties geven hun gegevens ook op de pagina.
118
for _, want := range []string{"Overzicht", "cfg-archive_interval", "cfg-listen", "bluegit-", "/api/v1/admin/config"} {
119
if !strings.Contains(page, want) {
120
t.Errorf("pagina mist %q", want)
121
}
122
}
123
// De API geeft dezelfde actielijst.
124
w := adminReq(s, "GET", "/api/v1/admin/actions", "")
125
var al struct {
126
Actions []Action `json:"actions"`
127
}
128
_ = json.Unmarshal(w.Body.Bytes(), &al)
129
if len(al.Actions) != len(s.Actions()) {
130
t.Fatalf("actions %d", len(al.Actions))
131
}
132
}
133
134
func TestUISettingsAndCSRF(t *testing.T) {
135
s := newTestServer(t)
136
c, csrf := login(t, s)
137
form := url.Values{"csrf": {csrf}, "retention_days": {"9"}, "archive_interval": {"12h"}, "rate_limit_kib": {"300"}, "listen": {"127.0.0.1:9999"}}
138
if w := c.do("POST", "/ui/act/config.update", form); w.Code != 303 {
139
t.Fatalf("opslaan %d %s", w.Code, w.Body)
140
}
141
page := c.do("GET", "/", nil).Body.String()
142
if !strings.Contains(page, "Instellingen opgeslagen") || !strings.Contains(page, "herstart") {
143
t.Fatalf("melding ontbreekt")
144
}
145
cv := s.ConfigView()
146
get := func(k string) string {
147
for _, f := range cv.Fields {
148
if f.Key == k {
149
return f.Value
150
}
151
}
152
return ""
153
}
154
if get("retention_days") != "9" || get("archive_interval") != "12h" || get("listen") != "127.0.0.1:9999" || !cv.Restart {
155
t.Fatalf("%+v", cv)
156
}
157
if s.limiter.Rate() != 300<<10 {
158
t.Fatalf("rate %d", s.limiter.Rate())
159
}
160
if s.cfg().Listen == "127.0.0.1:9999" {
161
t.Fatal("listen hoort pas na herstart te gelden")
162
}
163
// Bewaard: een nieuwe server leest het.
164
s2, err := New(s.Cfg, nil)
165
if err != nil {
166
t.Fatal(err)
167
}
168
if s2.cfg().RetentionDays != 9 || s2.cfg().Listen != "127.0.0.1:9999" {
169
t.Fatalf("na herstart %+v", s2.cfg())
170
}
171
// Zonder of met fout CSRF-token: geweigerd.
172
if w := c.do("POST", "/ui/act/config.update", url.Values{"retention_days": {"1"}}); w.Code != 403 {
173
t.Fatalf("zonder csrf %d", w.Code)
174
}
175
// Ongeldige waarde: foutmelding, niets veranderd.
176
c.do("POST", "/ui/act/config.update", url.Values{"csrf": {csrf}, "retention_days": {"-1"}})
177
if !strings.Contains(c.do("GET", "/", nil).Body.String(), "mislukt") || s.cfg().RetentionDays != 9 {
178
t.Fatal("ongeldige waarde")
179
}
180
// API met sessiecookie vraagt X-CSRF-Token.
181
r := httptest.NewRequest("PUT", "/api/v1/admin/config", strings.NewReader(`{"retention_days":3}`))
182
r.AddCookie(c.cookie)
183
w := httptest.NewRecorder()
184
s.Handler().ServeHTTP(w, r)
185
if w.Code != 403 {
186
t.Fatalf("cookie zonder csrf-header %d", w.Code)
187
}
188
r = httptest.NewRequest("PUT", "/api/v1/admin/config", strings.NewReader(`{"retention_days":3}`))
189
r.AddCookie(c.cookie)
190
r.Header.Set("X-CSRF-Token", csrf)
191
w = httptest.NewRecorder()
192
s.Handler().ServeHTTP(w, r)
193
if w.Code != 200 || s.cfg().RetentionDays != 3 {
194
t.Fatalf("cookie met csrf-header %d %s", w.Code, w.Body)
195
}
196
// Uitloggen.
197
c.do("POST", "/logout", url.Values{"csrf": {csrf}})
198
if w := c.do("GET", "/", nil); w.Code != 303 {
199
t.Fatalf("na uitloggen %d", w.Code)
200
}
201
// Webinterface mag niet in een iframe van een ander.
202
if h := c.do("GET", "/login", nil).Header(); h.Get("X-Frame-Options") != "DENY" {
203
t.Fatal("frame")
204
}
205
}
206
207
func TestLoginRateLimit(t *testing.T) {
208
s := newTestServer(t)
209
c := &uiClient{t: t, h: s.Handler()}
210
for i := 0; i < 5; i++ {
211
c.do("POST", "/login", url.Values{"token": {"fout"}})
212
}
213
if w := c.do("POST", "/login", url.Values{"token": {s.AdminToken()}}); w.Code != 429 {
214
t.Fatalf("na 5 fouten %d", w.Code)
215
}
216
}
217
218
func TestAPIConfig(t *testing.T) {
219
s := newTestServer(t)
220
w := adminReq(s, "PUT", "/api/v1/admin/config", `{"min_free_mb":2048,"full_sync_interval":"30m"}`)
221
if w.Code != 200 {
222
t.Fatalf("%d %s", w.Code, w.Body)
223
}
224
if s.cfg().MinFreeMB != 2048 || s.cfg().FullSyncInterval.Duration != 30*time.Minute {
225
t.Fatalf("%+v", s.cfg())
226
}
227
if _, err := os.Stat(filepath.Join(s.Cfg.DataDir, config.SettingsFile)); err != nil {
228
t.Fatal(err)
229
}
230
for _, body := range []string{`{"data_dir":"/tmp"}`, `{"onbekend":1}`, `{"archive_interval":"0s"}`, `{}`, `[1]`} {
231
if w := adminReq(s, "PUT", "/api/v1/admin/config", body); w.Code != 400 {
232
t.Errorf("%s: %d", body, w.Code)
233
}
234
}
235
w = adminReq(s, "GET", "/api/v1/admin/config", "")
236
var cv ConfigView
237
_ = json.Unmarshal(w.Body.Bytes(), &cv)
238
if len(cv.Fields) != len(config.Fields) {
239
t.Fatalf("%s", w.Body)
240
}
241
}
242
243
func TestSignedAdminActions(t *testing.T) {
244
f := newFake(t)
245
s := newTestServer(t)
246
if w := adminReq(s, "POST", "/api/v1/admin/connect", `{"url":"`+f.ts.URL+`","key":"bgbk_test"}`); w.Code != 200 {
247
t.Fatal(w.Body)
248
}
249
good := protocol.SigningSecret("bgbk_test")
250
call := func(method, p, body string) *httptest.ResponseRecorder {
251
r := httptest.NewRequest(method, p, bytes.NewReader([]byte(body)))
252
protocol.Sign(r, good, "inst-1", []byte(body), time.Now())
253
w := httptest.NewRecorder()
254
s.Handler().ServeHTTP(w, r)
255
return w
256
}
257
if w := call("PUT", "/api/v1/admin/config", `{"retention_days":"4"}`); w.Code != 200 || s.cfg().RetentionDays != 4 {
258
t.Fatalf("config via BlueGit %d %s", w.Code, w.Body)
259
}
260
if w := call("GET", "/api/v1/admin/config", ""); w.Code != 200 {
261
t.Fatalf("config lezen %d", w.Code)
262
}
263
if w := call("POST", "/api/v1/admin/connect", `{}`); w.Code != 403 {
264
t.Fatalf("connect via BlueGit %d", w.Code)
265
}
266
if w := call("POST", "/api/v1/admin/rollback", `{"archive":"bluegit-20261115-120000.tar.gz"}`); w.Code != 400 {
267
t.Fatalf("rollback zonder confirm %d", w.Code)
268
}
269
// Handtekening over een ander pad: geweigerd.
270
r := httptest.NewRequest("POST", "/api/v1/admin/sync", nil)
271
protocol.Sign(r, good, "inst-1", nil, time.Now())
272
r.URL.Path = "/api/v1/admin/disconnect"
273
w := httptest.NewRecorder()
274
s.Handler().ServeHTTP(w, r)
275
if w.Code != 401 {
276
t.Fatalf("ander pad %d", w.Code)
277
}
278
if w := call("POST", "/api/v1/admin/disconnect", ``); w.Code != 200 || s.getState().Connected() {
279
t.Fatalf("disconnect %d", w.Code)
280
}
281
// Ontkoppeld: BlueGit kan niets meer.
282
if w := call("GET", "/api/v1/admin/status", ""); w.Code != 401 {
283
t.Fatalf("na ontkoppelen %d", w.Code)
284
}
285
}
@@ -0,0 +1,285 @@1
package server2
3
import (4
"bytes"5
"encoding/json"6
"net/http"7
"net/http/httptest"8
"net/url"9
"os"10
"path/filepath"11
"regexp"12
"strings"13
"testing"14
"time"15
16
"git.timfalken.com/timfa/bluegit-backup/internal/config"17
"git.timfalken.com/timfa/bluegit-backup/internal/protocol"18
)19
20
// uiClient is een browser met een cookie.21
type uiClient struct {22
t *testing.T23
h http.Handler24
cookie *http.Cookie25
}26
27
func (c *uiClient) do(method, p string, form url.Values) *httptest.ResponseRecorder {28
var body *strings.Reader29
if form != nil {30
body = strings.NewReader(form.Encode())31
} else {32
body = strings.NewReader("")33
}34
r := httptest.NewRequest(method, p, body)35
if form != nil {36
r.Header.Set("Content-Type", "application/x-www-form-urlencoded")37
}38
if c.cookie != nil {39
r.AddCookie(c.cookie)40
}41
w := httptest.NewRecorder()42
c.h.ServeHTTP(w, r)43
for _, ck := range w.Result().Cookies() {44
if ck.Name == sessionCookie {45
c.cookie = ck46
}47
}48
return w49
}50
51
var csrfRE = regexp.MustCompile(`name="csrf" value="([0-9a-f]+)"`)52
53
func login(t *testing.T, s *Server) (*uiClient, string) {54
c := &uiClient{t: t, h: s.Handler()}55
if w := c.do("GET", "/", nil); w.Code != 303 || w.Header().Get("Location") != "/login" {56
t.Fatalf("zonder sessie: %d %s", w.Code, w.Header().Get("Location"))57
}58
if w := c.do("POST", "/login", url.Values{"token": {"fout"}}); w.Header().Get("Location") != "/login?fout=1" {59
t.Fatalf("fout token: %s", w.Header().Get("Location"))60
}61
if w := c.do("POST", "/login", url.Values{"token": {s.AdminToken()}}); w.Code != 303 || c.cookie == nil {62
t.Fatalf("login %d", w.Code)63
}64
if !c.cookie.HttpOnly || c.cookie.SameSite != http.SameSiteStrictMode {65
t.Fatalf("cookie %+v", c.cookie)66
}67
w := c.do("GET", "/", nil)68
if w.Code != 200 {69
t.Fatalf("index %d", w.Code)70
}71
m := csrfRE.FindStringSubmatch(w.Body.String())72
if m == nil {73
t.Fatal("geen csrf")74
}75
return c, m[1]76
}77
78
// Elke wijzigende actie heeft een formulier in de webinterface, elke79
// beheerroute zit in Actions, en elk formulier hoort bij een actie.80
func TestUIAndAPIParity(t *testing.T) {81
f := newFake(t)82
s := newTestServer(t)83
if w := adminReq(s, "POST", "/api/v1/admin/connect", `{"url":"`+f.ts.URL+`","key":"bgbk_test"}`); w.Code != 200 {84
t.Fatal(w.Body)85
}86
if _, err := s.SyncNow(t.Context()); err != nil {87
t.Fatal(err)88
}89
if _, err := s.ArchiveNow(); err != nil {90
t.Fatal(err)91
}92
c, _ := login(t, s)93
page := c.do("GET", "/", nil).Body.String()94
// Het koppelformulier staat in een uitklapper zodra er gekoppeld is; het95
// moet er nog steeds zijn.96
forms := map[string]bool{}97
for _, m := range regexp.MustCompile(`action="/ui/act/([a-z.]+)"`).FindAllStringSubmatch(page, -1) {98
forms[m[1]] = true99
}100
for _, a := range s.Actions() {101
switch a.Method {102
case "GET":103
// Getoond op de pagina; download als link.104
if a.Name == "archive.download" && !strings.Contains(page, "/download\">Downloaden") {105
t.Errorf("geen downloadlink")106
}107
default:108
if !forms[a.Name] {109
t.Errorf("actie %s (%s %s) heeft geen formulier in de webinterface", a.Name, a.Method, a.Path)110
}111
delete(forms, a.Name)112
}113
}114
for f := range forms {115
t.Errorf("formulier %s hoort bij geen API-actie", f)116
}117
// Alle GET-acties geven hun gegevens ook op de pagina.118
for _, want := range []string{"Overzicht", "cfg-archive_interval", "cfg-listen", "bluegit-", "/api/v1/admin/config"} {119
if !strings.Contains(page, want) {120
t.Errorf("pagina mist %q", want)121
}122
}123
// De API geeft dezelfde actielijst.124
w := adminReq(s, "GET", "/api/v1/admin/actions", "")125
var al struct {126
Actions []Action `json:"actions"`127
}128
_ = json.Unmarshal(w.Body.Bytes(), &al)129
if len(al.Actions) != len(s.Actions()) {130
t.Fatalf("actions %d", len(al.Actions))131
}132
}133
134
func TestUISettingsAndCSRF(t *testing.T) {135
s := newTestServer(t)136
c, csrf := login(t, s)137
form := url.Values{"csrf": {csrf}, "retention_days": {"9"}, "archive_interval": {"12h"}, "rate_limit_kib": {"300"}, "listen": {"127.0.0.1:9999"}}138
if w := c.do("POST", "/ui/act/config.update", form); w.Code != 303 {139
t.Fatalf("opslaan %d %s", w.Code, w.Body)140
}141
page := c.do("GET", "/", nil).Body.String()142
if !strings.Contains(page, "Instellingen opgeslagen") || !strings.Contains(page, "herstart") {143
t.Fatalf("melding ontbreekt")144
}145
cv := s.ConfigView()146
get := func(k string) string {147
for _, f := range cv.Fields {148
if f.Key == k {149
return f.Value150
}151
}152
return ""153
}154
if get("retention_days") != "9" || get("archive_interval") != "12h" || get("listen") != "127.0.0.1:9999" || !cv.Restart {155
t.Fatalf("%+v", cv)156
}157
if s.limiter.Rate() != 300<<10 {158
t.Fatalf("rate %d", s.limiter.Rate())159
}160
if s.cfg().Listen == "127.0.0.1:9999" {161
t.Fatal("listen hoort pas na herstart te gelden")162
}163
// Bewaard: een nieuwe server leest het.164
s2, err := New(s.Cfg, nil)165
if err != nil {166
t.Fatal(err)167
}168
if s2.cfg().RetentionDays != 9 || s2.cfg().Listen != "127.0.0.1:9999" {169
t.Fatalf("na herstart %+v", s2.cfg())170
}171
// Zonder of met fout CSRF-token: geweigerd.172
if w := c.do("POST", "/ui/act/config.update", url.Values{"retention_days": {"1"}}); w.Code != 403 {173
t.Fatalf("zonder csrf %d", w.Code)174
}175
// Ongeldige waarde: foutmelding, niets veranderd.176
c.do("POST", "/ui/act/config.update", url.Values{"csrf": {csrf}, "retention_days": {"-1"}})177
if !strings.Contains(c.do("GET", "/", nil).Body.String(), "mislukt") || s.cfg().RetentionDays != 9 {178
t.Fatal("ongeldige waarde")179
}180
// API met sessiecookie vraagt X-CSRF-Token.181
r := httptest.NewRequest("PUT", "/api/v1/admin/config", strings.NewReader(`{"retention_days":3}`))182
r.AddCookie(c.cookie)183
w := httptest.NewRecorder()184
s.Handler().ServeHTTP(w, r)185
if w.Code != 403 {186
t.Fatalf("cookie zonder csrf-header %d", w.Code)187
}188
r = httptest.NewRequest("PUT", "/api/v1/admin/config", strings.NewReader(`{"retention_days":3}`))189
r.AddCookie(c.cookie)190
r.Header.Set("X-CSRF-Token", csrf)191
w = httptest.NewRecorder()192
s.Handler().ServeHTTP(w, r)193
if w.Code != 200 || s.cfg().RetentionDays != 3 {194
t.Fatalf("cookie met csrf-header %d %s", w.Code, w.Body)195
}196
// Uitloggen.197
c.do("POST", "/logout", url.Values{"csrf": {csrf}})198
if w := c.do("GET", "/", nil); w.Code != 303 {199
t.Fatalf("na uitloggen %d", w.Code)200
}201
// Webinterface mag niet in een iframe van een ander.202
if h := c.do("GET", "/login", nil).Header(); h.Get("X-Frame-Options") != "DENY" {203
t.Fatal("frame")204
}205
}206
207
func TestLoginRateLimit(t *testing.T) {208
s := newTestServer(t)209
c := &uiClient{t: t, h: s.Handler()}210
for i := 0; i < 5; i++ {211
c.do("POST", "/login", url.Values{"token": {"fout"}})212
}213
if w := c.do("POST", "/login", url.Values{"token": {s.AdminToken()}}); w.Code != 429 {214
t.Fatalf("na 5 fouten %d", w.Code)215
}216
}217
218
func TestAPIConfig(t *testing.T) {219
s := newTestServer(t)220
w := adminReq(s, "PUT", "/api/v1/admin/config", `{"min_free_mb":2048,"full_sync_interval":"30m"}`)221
if w.Code != 200 {222
t.Fatalf("%d %s", w.Code, w.Body)223
}224
if s.cfg().MinFreeMB != 2048 || s.cfg().FullSyncInterval.Duration != 30*time.Minute {225
t.Fatalf("%+v", s.cfg())226
}227
if _, err := os.Stat(filepath.Join(s.Cfg.DataDir, config.SettingsFile)); err != nil {228
t.Fatal(err)229
}230
for _, body := range []string{`{"data_dir":"/tmp"}`, `{"onbekend":1}`, `{"archive_interval":"0s"}`, `{}`, `[1]`} {231
if w := adminReq(s, "PUT", "/api/v1/admin/config", body); w.Code != 400 {232
t.Errorf("%s: %d", body, w.Code)233
}234
}235
w = adminReq(s, "GET", "/api/v1/admin/config", "")236
var cv ConfigView237
_ = json.Unmarshal(w.Body.Bytes(), &cv)238
if len(cv.Fields) != len(config.Fields) {239
t.Fatalf("%s", w.Body)240
}241
}242
243
func TestSignedAdminActions(t *testing.T) {244
f := newFake(t)245
s := newTestServer(t)246
if w := adminReq(s, "POST", "/api/v1/admin/connect", `{"url":"`+f.ts.URL+`","key":"bgbk_test"}`); w.Code != 200 {247
t.Fatal(w.Body)248
}249
good := protocol.SigningSecret("bgbk_test")250
call := func(method, p, body string) *httptest.ResponseRecorder {251
r := httptest.NewRequest(method, p, bytes.NewReader([]byte(body)))252
protocol.Sign(r, good, "inst-1", []byte(body), time.Now())253
w := httptest.NewRecorder()254
s.Handler().ServeHTTP(w, r)255
return w256
}257
if w := call("PUT", "/api/v1/admin/config", `{"retention_days":"4"}`); w.Code != 200 || s.cfg().RetentionDays != 4 {258
t.Fatalf("config via BlueGit %d %s", w.Code, w.Body)259
}260
if w := call("GET", "/api/v1/admin/config", ""); w.Code != 200 {261
t.Fatalf("config lezen %d", w.Code)262
}263
if w := call("POST", "/api/v1/admin/connect", `{}`); w.Code != 403 {264
t.Fatalf("connect via BlueGit %d", w.Code)265
}266
if w := call("POST", "/api/v1/admin/rollback", `{"archive":"bluegit-20261115-120000.tar.gz"}`); w.Code != 400 {267
t.Fatalf("rollback zonder confirm %d", w.Code)268
}269
// Handtekening over een ander pad: geweigerd.270
r := httptest.NewRequest("POST", "/api/v1/admin/sync", nil)271
protocol.Sign(r, good, "inst-1", nil, time.Now())272
r.URL.Path = "/api/v1/admin/disconnect"273
w := httptest.NewRecorder()274
s.Handler().ServeHTTP(w, r)275
if w.Code != 401 {276
t.Fatalf("ander pad %d", w.Code)277
}278
if w := call("POST", "/api/v1/admin/disconnect", ``); w.Code != 200 || s.getState().Connected() {279
t.Fatalf("disconnect %d", w.Code)280
}281
// Ontkoppeld: BlueGit kan niets meer.282
if w := call("GET", "/api/v1/admin/status", ""); w.Code != 401 {283
t.Fatalf("na ontkoppelen %d", w.Code)284
}285
}@@ -0,0 +1,104 @@
1
<!doctype html><html lang="nl"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
2
<title>bluegit-backup</title>{{template "style"}}</head><body>
3
<header><h1>bluegit-backup</h1>
4
<span class="badge{{if not .Status.Connected}} off{{end}}">{{if .Status.Connected}}gekoppeld{{else}}niet gekoppeld{{end}}</span>
5
<form method="post" action="/logout"><input type="hidden" name="csrf" value="{{.CSRF}}"><button class="secondary" type="submit">Uitloggen</button></form>
6
</header>
7
{{if .Status.CompatMessage}}<div class="compat-banner" role="alert" id="compat"><strong>BlueGit en deze backup server passen niet bij elkaar:</strong> {{.Status.CompatMessage}}</div>{{end}}
8
<main>
9
{{if .Flash}}<div class="flash{{if .FlashErr}} err{{end}}" role="status">{{.Flash}}</div>{{end}}
10
11
<section id="status">
12
<h2>Overzicht</h2>
13
<dl>
14
<dt>BlueGit</dt><dd>{{if .Status.BlueGitURL}}{{.Status.BlueGitURL}}{{else}}—{{end}}{{if .Status.InstanceID}} <small>instantie {{.Status.InstanceID}}</small>{{end}}</dd>
15
<dt>Laatste sync</dt><dd>{{when .Status.LastSync}}{{if .Status.SyncError}} <span class="badge off">{{.Status.SyncError}}</span>{{end}}</dd>
16
<dt>Laatste sync-resultaat</dt><dd>{{.Status.LastStats.Files}} bestanden, {{.Status.LastStats.Downloaded}} opgehaald ({{bytes .Status.LastStats.Bytes}}), {{.Status.LastStats.Deleted}} verwijderd</dd>
17
<dt>Syncs / meldingen</dt><dd>{{.Status.Syncs}} / {{.Status.Notifies}}</dd>
18
<dt>Kopie</dt><dd>{{bytes .Status.MirrorBytes}}</dd>
19
<dt>Archieven</dt><dd>{{.Status.Archives}}, laatste {{when .Status.LastArchive}}{{if .Status.ArchiveError}} <span class="badge off">{{.Status.ArchiveError}}</span>{{end}}</dd>
20
<dt>Rollback</dt><dd>{{.Status.Rollback.State}}{{if .Status.Rollback.Archive}} ({{.Status.Rollback.Archive}}){{end}}{{if .Status.Rollback.Error}} <span class="badge off">{{.Status.Rollback.Error}}</span>{{end}}</dd>
21
<dt>Versie</dt><dd>{{.Status.Version}} <small>server-id {{.Status.ServerID}}</small></dd>
22
<dt>Protocol</dt><dd>{{.Status.Protocol}} <small>(ondersteunt BlueGit ≥ {{.Status.MinProtocol}})</small>{{if .Status.BlueGitProtocol}} · BlueGit {{.Status.BlueGitProtocol}} <small>(ondersteunt backup server ≥ {{.Status.BlueGitMinProtocol}}{{if .Status.BlueGitVersion}}, versie {{.Status.BlueGitVersion}}{{end}})</small>{{end}}{{if eq .Status.Compat "ok"}} <span class="badge">compatibel</span>{{else if .Status.Compat}} <span class="badge off">niet compatibel</span>{{end}}</dd>
23
</dl>
24
<div class="row" style="margin-top:.8rem">
25
<form method="post" action="/ui/act/sync"><input type="hidden" name="csrf" value="{{.CSRF}}"><button type="submit">Nu synchroniseren</button></form>
26
<form method="post" action="/ui/act/archive"><input type="hidden" name="csrf" value="{{.CSRF}}"><button type="submit">Nu archiveren</button></form>
27
<form method="post" action="/ui/act/prune"><input type="hidden" name="csrf" value="{{.CSRF}}"><button class="secondary" type="submit">Nu opruimen</button></form>
28
</div>
29
</section>
30
31
<section id="connect">
32
<h2>Koppeling</h2>
33
{{if .Status.Connected}}
34
<p>Gekoppeld met <strong>{{.Status.BlueGitURL}}</strong>. Een backup server hoort bij één BlueGit.</p>
35
<form method="post" action="/ui/act/disconnect"><input type="hidden" name="csrf" value="{{.CSRF}}"><button class="secondary" type="submit">Ontkoppelen</button> <small>De kopie en de archieven blijven staan.</small></form>
36
<details><summary>Opnieuw koppelen (nieuwe key of andere BlueGit)</summary>{{template "connectform" .}}</details>
37
{{else}}
38
<p>Maak in BlueGit onder <em>Beheer → Backup</em> een Backupserver-Key en vul die hier in.</p>
39
{{template "connectform" .}}
40
{{end}}
41
</section>
42
43
<section id="config">
44
<h2>Instellingen</h2>
45
{{if .Config.Restart}}<div class="flash">Er staat een wijziging klaar die pas na een herstart geldt.</div>{{end}}
46
<form method="post" action="/ui/act/config.update">
47
<input type="hidden" name="csrf" value="{{.CSRF}}">
48
{{range .Config.Fields}}
49
<label for="cfg-{{.Key}}">{{.Label}} <small>{{.Help}}{{if .Restart}} (na herstart){{end}}</small></label>
50
<input id="cfg-{{.Key}}" type="text" name="{{.Key}}" value="{{.Value}}">
51
{{end}}
52
<p><small>Gegevensmap: <code>{{.Config.DataDir}}</code> (alleen in config.yml)</small></p>
53
<p><button type="submit">Opslaan</button></p>
54
</form>
55
</section>
56
57
<section id="archives">
58
<h2>Archieven</h2>
59
{{if .Archives}}
60
<table><thead><tr><th>Archief</th><th>Gemaakt</th><th>Grootte</th><th></th></tr></thead><tbody>
61
{{range .Archives}}<tr>
62
<td><code>{{.Name}}</code></td><td>{{when .CreatedAt}}</td><td>{{bytes .Size}}</td>
63
<td class="row"><a href="/api/v1/admin/archives/{{.Name}}/download">Downloaden</a>
64
<form method="post" action="/ui/act/archive.delete"><input type="hidden" name="csrf" value="{{$.CSRF}}"><input type="hidden" name="name" value="{{.Name}}"><button class="secondary" type="submit">Verwijderen</button></form></td>
65
</tr>{{end}}
66
</tbody></table>
67
<details>
68
<summary>Rollback naar een archief</summary>
69
<div class="backup-danger"><strong>Dit kan niet ongedaan worden gemaakt.</strong>
70
Alle gegevens van BlueGit worden vervangen door de inhoud van het archief. Alles wat daarna is veranderd, is weg. BlueGit herstart.</div>
71
<form method="post" action="/ui/act/rollback">
72
<input type="hidden" name="csrf" value="{{.CSRF}}">
73
<label for="rb-archive">Archief</label>
74
<select id="rb-archive" name="archive">{{range .Archives}}<option value="{{.Name}}">{{.Name}}</option>{{end}}</select>
75
<label for="rb-confirm">Typ de archiefnaam over</label>
76
<input id="rb-confirm" type="text" name="confirm" autocomplete="off" required>
77
<label><input type="checkbox" name="understood" value="1" required> Ik begrijp dat dit niet ongedaan kan worden gemaakt</label>
78
<p><button class="danger" type="submit">Rollback starten</button></p>
79
</form>
80
</details>
81
{{else}}<p>Nog geen archieven.</p>{{end}}
82
</section>
83
84
<section id="api">
85
<h2>API</h2>
86
<p><small>Alles hierboven kan ook via de API, met <code>Authorization: Bearer <admin.token></code>. Acties met ✓ kan ook de gekoppelde BlueGit uitvoeren.</small></p>
87
<table><thead><tr><th>Methode</th><th>Pad</th><th>Actie</th><th>BlueGit</th></tr></thead><tbody>
88
{{range .Actions}}<tr><td><code>{{.Method}}</code></td><td><code>{{.Path}}</code></td><td>{{.Title}}</td><td>{{if .Signed}}✓{{end}}</td></tr>{{end}}
89
</tbody></table>
90
</section>
91
<p><small>bluegit-backup {{.Version}}</small></p>
92
</main></body></html>
93
{{define "connectform"}}
94
<form method="post" action="/ui/act/connect">
95
<input type="hidden" name="csrf" value="{{.CSRF}}">
96
<label for="c-url">BlueGit-adres</label><input id="c-url" type="url" name="url" placeholder="https://git.example.com" value="{{.Status.BlueGitURL}}" required>
97
<label for="c-key">Backupserver-Key</label><input id="c-key" type="password" name="key" placeholder="bgbk_…" autocomplete="off" required>
98
<label>Hoorde deze server eerder bij een andere BlueGit?</label>
99
<label><input type="radio" name="on_conflict" value="" checked> Nee, of vraag het eerst</label>
100
<label><input type="radio" name="on_conflict" value="wipe"> Oude backups wissen en opnieuw beginnen</label>
101
<label><input type="radio" name="on_conflict" value="restore"> De nieuwe BlueGit herstellen met de backupdata</label>
102
<p><button type="submit">Koppelen</button></p>
103
</form>
104
{{end}}
@@ -0,0 +1,104 @@1
<!doctype html><html lang="nl"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">2
<title>bluegit-backup</title>{{template "style"}}</head><body>3
<header><h1>bluegit-backup</h1>4
<span class="badge{{if not .Status.Connected}} off{{end}}">{{if .Status.Connected}}gekoppeld{{else}}niet gekoppeld{{end}}</span>5
<form method="post" action="/logout"><input type="hidden" name="csrf" value="{{.CSRF}}"><button class="secondary" type="submit">Uitloggen</button></form>6
</header>7
{{if .Status.CompatMessage}}<div class="compat-banner" role="alert" id="compat"><strong>BlueGit en deze backup server passen niet bij elkaar:</strong> {{.Status.CompatMessage}}</div>{{end}}8
<main>9
{{if .Flash}}<div class="flash{{if .FlashErr}} err{{end}}" role="status">{{.Flash}}</div>{{end}}10
11
<section id="status">12
<h2>Overzicht</h2>13
<dl>14
<dt>BlueGit</dt><dd>{{if .Status.BlueGitURL}}{{.Status.BlueGitURL}}{{else}}—{{end}}{{if .Status.InstanceID}} <small>instantie {{.Status.InstanceID}}</small>{{end}}</dd>15
<dt>Laatste sync</dt><dd>{{when .Status.LastSync}}{{if .Status.SyncError}} <span class="badge off">{{.Status.SyncError}}</span>{{end}}</dd>16
<dt>Laatste sync-resultaat</dt><dd>{{.Status.LastStats.Files}} bestanden, {{.Status.LastStats.Downloaded}} opgehaald ({{bytes .Status.LastStats.Bytes}}), {{.Status.LastStats.Deleted}} verwijderd</dd>17
<dt>Syncs / meldingen</dt><dd>{{.Status.Syncs}} / {{.Status.Notifies}}</dd>18
<dt>Kopie</dt><dd>{{bytes .Status.MirrorBytes}}</dd>19
<dt>Archieven</dt><dd>{{.Status.Archives}}, laatste {{when .Status.LastArchive}}{{if .Status.ArchiveError}} <span class="badge off">{{.Status.ArchiveError}}</span>{{end}}</dd>20
<dt>Rollback</dt><dd>{{.Status.Rollback.State}}{{if .Status.Rollback.Archive}} ({{.Status.Rollback.Archive}}){{end}}{{if .Status.Rollback.Error}} <span class="badge off">{{.Status.Rollback.Error}}</span>{{end}}</dd>21
<dt>Versie</dt><dd>{{.Status.Version}} <small>server-id {{.Status.ServerID}}</small></dd>22
<dt>Protocol</dt><dd>{{.Status.Protocol}} <small>(ondersteunt BlueGit ≥ {{.Status.MinProtocol}})</small>{{if .Status.BlueGitProtocol}} · BlueGit {{.Status.BlueGitProtocol}} <small>(ondersteunt backup server ≥ {{.Status.BlueGitMinProtocol}}{{if .Status.BlueGitVersion}}, versie {{.Status.BlueGitVersion}}{{end}})</small>{{end}}{{if eq .Status.Compat "ok"}} <span class="badge">compatibel</span>{{else if .Status.Compat}} <span class="badge off">niet compatibel</span>{{end}}</dd>23
</dl>24
<div class="row" style="margin-top:.8rem">25
<form method="post" action="/ui/act/sync"><input type="hidden" name="csrf" value="{{.CSRF}}"><button type="submit">Nu synchroniseren</button></form>26
<form method="post" action="/ui/act/archive"><input type="hidden" name="csrf" value="{{.CSRF}}"><button type="submit">Nu archiveren</button></form>27
<form method="post" action="/ui/act/prune"><input type="hidden" name="csrf" value="{{.CSRF}}"><button class="secondary" type="submit">Nu opruimen</button></form>28
</div>29
</section>30
31
<section id="connect">32
<h2>Koppeling</h2>33
{{if .Status.Connected}}34
<p>Gekoppeld met <strong>{{.Status.BlueGitURL}}</strong>. Een backup server hoort bij één BlueGit.</p>35
<form method="post" action="/ui/act/disconnect"><input type="hidden" name="csrf" value="{{.CSRF}}"><button class="secondary" type="submit">Ontkoppelen</button> <small>De kopie en de archieven blijven staan.</small></form>36
<details><summary>Opnieuw koppelen (nieuwe key of andere BlueGit)</summary>{{template "connectform" .}}</details>37
{{else}}38
<p>Maak in BlueGit onder <em>Beheer → Backup</em> een Backupserver-Key en vul die hier in.</p>39
{{template "connectform" .}}40
{{end}}41
</section>42
43
<section id="config">44
<h2>Instellingen</h2>45
{{if .Config.Restart}}<div class="flash">Er staat een wijziging klaar die pas na een herstart geldt.</div>{{end}}46
<form method="post" action="/ui/act/config.update">47
<input type="hidden" name="csrf" value="{{.CSRF}}">48
{{range .Config.Fields}}49
<label for="cfg-{{.Key}}">{{.Label}} <small>{{.Help}}{{if .Restart}} (na herstart){{end}}</small></label>50
<input id="cfg-{{.Key}}" type="text" name="{{.Key}}" value="{{.Value}}">51
{{end}}52
<p><small>Gegevensmap: <code>{{.Config.DataDir}}</code> (alleen in config.yml)</small></p>53
<p><button type="submit">Opslaan</button></p>54
</form>55
</section>56
57
<section id="archives">58
<h2>Archieven</h2>59
{{if .Archives}}60
<table><thead><tr><th>Archief</th><th>Gemaakt</th><th>Grootte</th><th></th></tr></thead><tbody>61
{{range .Archives}}<tr>62
<td><code>{{.Name}}</code></td><td>{{when .CreatedAt}}</td><td>{{bytes .Size}}</td>63
<td class="row"><a href="/api/v1/admin/archives/{{.Name}}/download">Downloaden</a>64
<form method="post" action="/ui/act/archive.delete"><input type="hidden" name="csrf" value="{{$.CSRF}}"><input type="hidden" name="name" value="{{.Name}}"><button class="secondary" type="submit">Verwijderen</button></form></td>65
</tr>{{end}}66
</tbody></table>67
<details>68
<summary>Rollback naar een archief</summary>69
<div class="backup-danger"><strong>Dit kan niet ongedaan worden gemaakt.</strong>70
Alle gegevens van BlueGit worden vervangen door de inhoud van het archief. Alles wat daarna is veranderd, is weg. BlueGit herstart.</div>71
<form method="post" action="/ui/act/rollback">72
<input type="hidden" name="csrf" value="{{.CSRF}}">73
<label for="rb-archive">Archief</label>74
<select id="rb-archive" name="archive">{{range .Archives}}<option value="{{.Name}}">{{.Name}}</option>{{end}}</select>75
<label for="rb-confirm">Typ de archiefnaam over</label>76
<input id="rb-confirm" type="text" name="confirm" autocomplete="off" required>77
<label><input type="checkbox" name="understood" value="1" required> Ik begrijp dat dit niet ongedaan kan worden gemaakt</label>78
<p><button class="danger" type="submit">Rollback starten</button></p>79
</form>80
</details>81
{{else}}<p>Nog geen archieven.</p>{{end}}82
</section>83
84
<section id="api">85
<h2>API</h2>86
<p><small>Alles hierboven kan ook via de API, met <code>Authorization: Bearer <admin.token></code>. Acties met ✓ kan ook de gekoppelde BlueGit uitvoeren.</small></p>87
<table><thead><tr><th>Methode</th><th>Pad</th><th>Actie</th><th>BlueGit</th></tr></thead><tbody>88
{{range .Actions}}<tr><td><code>{{.Method}}</code></td><td><code>{{.Path}}</code></td><td>{{.Title}}</td><td>{{if .Signed}}✓{{end}}</td></tr>{{end}}89
</tbody></table>90
</section>91
<p><small>bluegit-backup {{.Version}}</small></p>92
</main></body></html>93
{{define "connectform"}}94
<form method="post" action="/ui/act/connect">95
<input type="hidden" name="csrf" value="{{.CSRF}}">96
<label for="c-url">BlueGit-adres</label><input id="c-url" type="url" name="url" placeholder="https://git.example.com" value="{{.Status.BlueGitURL}}" required>97
<label for="c-key">Backupserver-Key</label><input id="c-key" type="password" name="key" placeholder="bgbk_…" autocomplete="off" required>98
<label>Hoorde deze server eerder bij een andere BlueGit?</label>99
<label><input type="radio" name="on_conflict" value="" checked> Nee, of vraag het eerst</label>100
<label><input type="radio" name="on_conflict" value="wipe"> Oude backups wissen en opnieuw beginnen</label>101
<label><input type="radio" name="on_conflict" value="restore"> De nieuwe BlueGit herstellen met de backupdata</label>102
<p><button type="submit">Koppelen</button></p>103
</form>104
{{end}}@@ -0,0 +1,12 @@
1
<!doctype html><html lang="nl"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
2
<title>Inloggen · bluegit-backup</title>{{template "style"}}</head><body>
3
<header><h1>bluegit-backup</h1></header>
4
<main class="login"><section>
5
<h2>Inloggen</h2>
6
{{if .Error}}<div class="flash err">Dat token klopt niet.</div>{{end}}
7
<form method="post" action="/login">
8
<label for="token">Beheertoken <small>Staat in <code>data_dir/admin.token</code>. Toon het met <code>sudo -u bluegit-backup bluegit-backup token</code>.</small></label>
9
<input id="token" name="token" type="password" autocomplete="current-password" required autofocus>
10
<p><button type="submit">Inloggen</button></p>
11
</form>
12
</section><p><small>versie {{.Version}}</small></p></main></body></html>
@@ -0,0 +1,12 @@1
<!doctype html><html lang="nl"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">2
<title>Inloggen · bluegit-backup</title>{{template "style"}}</head><body>3
<header><h1>bluegit-backup</h1></header>4
<main class="login"><section>5
<h2>Inloggen</h2>6
{{if .Error}}<div class="flash err">Dat token klopt niet.</div>{{end}}7
<form method="post" action="/login">8
<label for="token">Beheertoken <small>Staat in <code>data_dir/admin.token</code>. Toon het met <code>sudo -u bluegit-backup bluegit-backup token</code>.</small></label>9
<input id="token" name="token" type="password" autocomplete="current-password" required autofocus>10
<p><button type="submit">Inloggen</button></p>11
</form>12
</section><p><small>versie {{.Version}}</small></p></main></body></html>@@ -0,0 +1,25 @@
1
{{define "style"}}<style>
2
:root{--blue:#1f6feb;--bg:#f6f8fa;--fg:#1f2328;--muted:#656d76;--border:#d0d7de;--danger:#cf222e;--ok:#1a7f37}
3
*{box-sizing:border-box}body{margin:0;font:15px/1.5 system-ui,-apple-system,"Segoe UI",sans-serif;background:var(--bg);color:var(--fg)}
4
header{background:#0d1b3e;color:#fff;padding:.8rem 1.5rem;display:flex;align-items:center;gap:1rem}
5
header h1{font-size:1.15rem;margin:0;flex:1}header form{margin:0}
6
main{max-width:1000px;margin:1.5rem auto;padding:0 1rem}
7
section{background:#fff;border:1px solid var(--border);border-radius:8px;padding:1rem 1.25rem;margin-bottom:1.25rem}
8
section h2{margin:.1rem 0 .8rem;font-size:1.1rem}
9
dl{display:grid;grid-template-columns:max-content 1fr;gap:.25rem 1rem;margin:0}dt{color:var(--muted)}dd{margin:0}
10
label{display:block;font-weight:600;margin:.6rem 0 .2rem}small{color:var(--muted);font-weight:400;display:block}
11
input[type=text],input[type=password],input[type=url]{width:100%;padding:.45rem .6rem;border:1px solid var(--border);border-radius:6px;font:inherit}
12
button{background:var(--blue);color:#fff;border:0;border-radius:6px;padding:.45rem .9rem;font:inherit;cursor:pointer}
13
button.secondary{background:#fff;color:var(--fg);border:1px solid var(--border)}button.danger{background:var(--danger)}
14
.row{display:flex;gap:.5rem;flex-wrap:wrap;align-items:center}.row form{margin:0}
15
table{width:100%;border-collapse:collapse}th,td{text-align:left;padding:.4rem .5rem;border-bottom:1px solid var(--border)}
16
.flash{padding:.7rem 1rem;border-radius:6px;margin-bottom:1rem;background:#dafbe1;border:1px solid var(--ok)}
17
.flash.err{background:#ffebe9;border-color:var(--danger)}
18
.badge{display:inline-block;padding:0 .5rem;border-radius:1rem;font-size:.85rem;background:#ddf4ff}
19
.badge.off{background:#ffebe9}
20
.compat-banner{background:#fff4d6;color:#6b4a00;border-bottom:1px solid #e8c766;padding:.7rem 1.2rem}
21
.backup-danger{border:2px solid var(--danger);background:#ffebe9;border-radius:8px;padding:.8rem 1rem;margin:.8rem 0}
22
.backup-danger strong{color:var(--danger);font-size:1.1rem;display:block}
23
details{margin-top:.5rem}code{background:var(--bg);padding:0 .3rem;border-radius:4px}
24
.login{max-width:420px;margin:4rem auto}
25
</style>{{end}}
@@ -0,0 +1,25 @@1
{{define "style"}}<style>2
:root{--blue:#1f6feb;--bg:#f6f8fa;--fg:#1f2328;--muted:#656d76;--border:#d0d7de;--danger:#cf222e;--ok:#1a7f37}3
*{box-sizing:border-box}body{margin:0;font:15px/1.5 system-ui,-apple-system,"Segoe UI",sans-serif;background:var(--bg);color:var(--fg)}4
header{background:#0d1b3e;color:#fff;padding:.8rem 1.5rem;display:flex;align-items:center;gap:1rem}5
header h1{font-size:1.15rem;margin:0;flex:1}header form{margin:0}6
main{max-width:1000px;margin:1.5rem auto;padding:0 1rem}7
section{background:#fff;border:1px solid var(--border);border-radius:8px;padding:1rem 1.25rem;margin-bottom:1.25rem}8
section h2{margin:.1rem 0 .8rem;font-size:1.1rem}9
dl{display:grid;grid-template-columns:max-content 1fr;gap:.25rem 1rem;margin:0}dt{color:var(--muted)}dd{margin:0}10
label{display:block;font-weight:600;margin:.6rem 0 .2rem}small{color:var(--muted);font-weight:400;display:block}11
input[type=text],input[type=password],input[type=url]{width:100%;padding:.45rem .6rem;border:1px solid var(--border);border-radius:6px;font:inherit}12
button{background:var(--blue);color:#fff;border:0;border-radius:6px;padding:.45rem .9rem;font:inherit;cursor:pointer}13
button.secondary{background:#fff;color:var(--fg);border:1px solid var(--border)}button.danger{background:var(--danger)}14
.row{display:flex;gap:.5rem;flex-wrap:wrap;align-items:center}.row form{margin:0}15
table{width:100%;border-collapse:collapse}th,td{text-align:left;padding:.4rem .5rem;border-bottom:1px solid var(--border)}16
.flash{padding:.7rem 1rem;border-radius:6px;margin-bottom:1rem;background:#dafbe1;border:1px solid var(--ok)}17
.flash.err{background:#ffebe9;border-color:var(--danger)}18
.badge{display:inline-block;padding:0 .5rem;border-radius:1rem;font-size:.85rem;background:#ddf4ff}19
.badge.off{background:#ffebe9}20
.compat-banner{background:#fff4d6;color:#6b4a00;border-bottom:1px solid #e8c766;padding:.7rem 1.2rem}21
.backup-danger{border:2px solid var(--danger);background:#ffebe9;border-radius:8px;padding:.8rem 1rem;margin:.8rem 0}22
.backup-danger strong{color:var(--danger);font-size:1.1rem;display:block}23
details{margin-top:.5rem}code{background:var(--bg);padding:0 .3rem;border-radius:4px}24
.login{max-width:420px;margin:4rem auto}25
</style>{{end}}@@ -0,0 +1,130 @@
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
l.mu.Lock()
53
defer l.mu.Unlock()
54
return int64(l.rate)
55
}
56
57
// Wait blokkeert tot n bytes gelezen mogen worden.
58
func (l *Limiter) Wait(ctx context.Context, n int) error {
59
if l == nil || n <= 0 {
60
return nil
61
}
62
l.mu.Lock()
63
if l.rate <= 0 {
64
l.mu.Unlock()
65
return nil
66
}
67
now := l.now()
68
l.tokens += now.Sub(l.last).Seconds() * l.rate
69
if l.tokens > l.burst {
70
l.tokens = l.burst
71
}
72
l.last = now
73
l.tokens -= float64(n)
74
var wait time.Duration
75
if l.tokens < 0 {
76
wait = time.Duration(-l.tokens / l.rate * float64(time.Second))
77
}
78
l.mu.Unlock()
79
if wait > 0 {
80
return l.sleep(ctx, wait)
81
}
82
return nil
83
}
84
85
// Reader begrenst r met l.
86
func (l *Limiter) Reader(ctx context.Context, r io.Reader) io.Reader {
87
if l == nil {
88
return r
89
}
90
return &reader{ctx: ctx, r: r, l: l}
91
}
92
93
type reader struct {
94
ctx context.Context
95
r io.Reader
96
l *Limiter
97
}
98
99
func (t *reader) Read(p []byte) (int, error) {
100
t.l.mu.Lock()
101
max := int(t.l.burst)
102
t.l.mu.Unlock()
103
if len(p) > max {
104
p = p[:max]
105
}
106
n, err := t.r.Read(p)
107
if n > 0 {
108
if werr := t.l.Wait(t.ctx, n); werr != nil {
109
return n, werr
110
}
111
}
112
return n, err
113
}
114
115
// SetRate past de snelheid aan zonder lopende downloads te onderbreken.
116
func (l *Limiter) SetRate(bytesPerSec int64) {
117
if l == nil {
118
return
119
}
120
l.mu.Lock()
121
defer l.mu.Unlock()
122
l.rate = float64(bytesPerSec)
123
l.burst = l.rate / 4
124
if l.burst < 16<<10 {
125
l.burst = 16 << 10
126
}
127
if l.tokens > l.burst {
128
l.tokens = l.burst
129
}
130
}
@@ -0,0 +1,130 @@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
l.mu.Lock()53
defer l.mu.Unlock()54
return int64(l.rate)55
}56
57
// Wait blokkeert tot n bytes gelezen mogen worden.58
func (l *Limiter) Wait(ctx context.Context, n int) error {59
if l == nil || n <= 0 {60
return nil61
}62
l.mu.Lock()63
if l.rate <= 0 {64
l.mu.Unlock()65
return nil66
}67
now := l.now()68
l.tokens += now.Sub(l.last).Seconds() * l.rate69
if l.tokens > l.burst {70
l.tokens = l.burst71
}72
l.last = now73
l.tokens -= float64(n)74
var wait time.Duration75
if l.tokens < 0 {76
wait = time.Duration(-l.tokens / l.rate * float64(time.Second))77
}78
l.mu.Unlock()79
if wait > 0 {80
return l.sleep(ctx, wait)81
}82
return nil83
}84
85
// Reader begrenst r met l.86
func (l *Limiter) Reader(ctx context.Context, r io.Reader) io.Reader {87
if l == nil {88
return r89
}90
return &reader{ctx: ctx, r: r, l: l}91
}92
93
type reader struct {94
ctx context.Context95
r io.Reader96
l *Limiter97
}98
99
func (t *reader) Read(p []byte) (int, error) {100
t.l.mu.Lock()101
max := int(t.l.burst)102
t.l.mu.Unlock()103
if len(p) > max {104
p = p[:max]105
}106
n, err := t.r.Read(p)107
if n > 0 {108
if werr := t.l.Wait(t.ctx, n); werr != nil {109
return n, werr110
}111
}112
return n, err113
}114
115
// SetRate past de snelheid aan zonder lopende downloads te onderbreken.116
func (l *Limiter) SetRate(bytesPerSec int64) {117
if l == nil {118
return119
}120
l.mu.Lock()121
defer l.mu.Unlock()122
l.rate = float64(bytesPerSec)123
l.burst = l.rate / 4124
if l.burst < 16<<10 {125
l.burst = 16 << 10126
}127
if l.tokens > l.burst {128
l.tokens = l.burst129
}130
}@@ -0,0 +1,70 @@
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 b, _ := io.ReadAll(l.Reader(context.Background(), r)); string(b) != "abc" {
37
t.Fatal(string(b))
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
}
53
54
func TestSetRate(t *testing.T) {
55
l := New(0)
56
l.SetRate(2048)
57
if l.Rate() != 2048 {
58
t.Fatal(l.Rate())
59
}
60
var slept time.Duration
61
l.sleep = func(_ context.Context, d time.Duration) error { slept += d; return nil }
62
now := time.Unix(0, 0)
63
l.now = func() time.Time { return now }
64
l.last = now
65
l.tokens = 0
66
_ = l.Wait(context.Background(), 4096)
67
if slept != 2*time.Second {
68
t.Fatal(slept)
69
}
70
}
@@ -0,0 +1,70 @@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 b, _ := io.ReadAll(l.Reader(context.Background(), r)); string(b) != "abc" {37
t.Fatal(string(b))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
}53
54
func TestSetRate(t *testing.T) {55
l := New(0)56
l.SetRate(2048)57
if l.Rate() != 2048 {58
t.Fatal(l.Rate())59
}60
var slept time.Duration61
l.sleep = func(_ context.Context, d time.Duration) error { slept += d; return nil }62
now := time.Unix(0, 0)63
l.now = func() time.Time { return now }64
l.last = now65
l.tokens = 066
_ = l.Wait(context.Background(), 4096)67
if slept != 2*time.Second {68
t.Fatal(slept)69
}70
}@@ -0,0 +1,35 @@
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
makedepends=('go')
10
backup=('etc/bluegit-backup/config.yml')
11
options=('!debug')
12
install=bluegit-backup.install
13
_commit=0000000000000000000000000000000000000000
14
source=("bluegit-backup-${_commit}.tar.gz::https://git.timfalken.com/timfa/bluegit-backup/-/archive/${_commit}/bluegit-backup-${_commit}.tar.gz")
15
sha256sums=('SKIP')
16
17
build() {
18
cd "$srcdir/bluegit-backup-${_commit}"
19
export CGO_ENABLED=0
20
export GOTOOLCHAIN=auto
21
export GOFLAGS='-trimpath'
22
export GOCACHE="${BUILDDIR:-$srcdir}/gocache"
23
export GOPATH="${BUILDDIR:-$srcdir}/gopath"
24
go build -ldflags="-s -w -X git.timfalken.com/timfa/bluegit-backup/internal/server.Version=${pkgver}" -o bluegit-backup ./cmd/bluegit-backup
25
}
26
27
package() {
28
cd "$srcdir/bluegit-backup-${_commit}"
29
install -Dm755 bluegit-backup "$pkgdir/usr/bin/bluegit-backup"
30
install -Dm644 packaging/bluegit-backup.service "$pkgdir/usr/lib/systemd/system/bluegit-backup.service"
31
install -Dm644 packaging/config.yml "$pkgdir/etc/bluegit-backup/config.yml"
32
install -Dm644 packaging/sysusers.conf "$pkgdir/usr/lib/sysusers.d/bluegit-backup.conf"
33
install -Dm644 packaging/tmpfiles.conf "$pkgdir/usr/lib/tmpfiles.d/bluegit-backup.conf"
34
install -Dm644 LICENSE "$pkgdir/usr/share/licenses/$pkgname/LICENSE"
35
}
@@ -0,0 +1,35 @@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
makedepends=('go')10
backup=('etc/bluegit-backup/config.yml')11
options=('!debug')12
install=bluegit-backup.install13
_commit=000000000000000000000000000000000000000014
source=("bluegit-backup-${_commit}.tar.gz::https://git.timfalken.com/timfa/bluegit-backup/-/archive/${_commit}/bluegit-backup-${_commit}.tar.gz")15
sha256sums=('SKIP')16
17
build() {18
cd "$srcdir/bluegit-backup-${_commit}"19
export CGO_ENABLED=020
export GOTOOLCHAIN=auto21
export GOFLAGS='-trimpath'22
export GOCACHE="${BUILDDIR:-$srcdir}/gocache"23
export GOPATH="${BUILDDIR:-$srcdir}/gopath"24
go build -ldflags="-s -w -X git.timfalken.com/timfa/bluegit-backup/internal/server.Version=${pkgver}" -o bluegit-backup ./cmd/bluegit-backup25
}26
27
package() {28
cd "$srcdir/bluegit-backup-${_commit}"29
install -Dm755 bluegit-backup "$pkgdir/usr/bin/bluegit-backup"30
install -Dm644 packaging/bluegit-backup.service "$pkgdir/usr/lib/systemd/system/bluegit-backup.service"31
install -Dm644 packaging/config.yml "$pkgdir/etc/bluegit-backup/config.yml"32
install -Dm644 packaging/sysusers.conf "$pkgdir/usr/lib/sysusers.d/bluegit-backup.conf"33
install -Dm644 packaging/tmpfiles.conf "$pkgdir/usr/lib/tmpfiles.d/bluegit-backup.conf"34
install -Dm644 LICENSE "$pkgdir/usr/share/licenses/$pkgname/LICENSE"35
}@@ -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, bijvoorbeeld BLUEGIT_BACKUP_KEY voor `connect`.
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, bijvoorbeeld BLUEGIT_BACKUP_KEY voor `connect`.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:8080
3
# Waar BlueGit deze server bereikt (meldingen, archieflijst, rollback).
4
public_url: http://backup.lan:8080
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:80803
# Waar BlueGit deze server bereikt (meldingen, archieflijst, rollback).4
public_url: http://backup.lan:80805
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 @@
1
u bluegit-backup - "BlueGit backup server" /var/lib/bluegit-backup /usr/sbin/nologin
@@ -0,0 +1 @@1
u bluegit-backup - "BlueGit backup server" /var/lib/bluegit-backup /usr/sbin/nologin@@ -0,0 +1 @@
1
d /var/lib/bluegit-backup 0750 bluegit-backup bluegit-backup -
@@ -0,0 +1 @@1
d /var/lib/bluegit-backup 0750 bluegit-backup bluegit-backup -