BlueGit

timfa bluegit

bluegit-backup samengevoegd in BlueGit (met history uit timfa/bluegit-backup)

timfa Grok Bot · pushed by timfa

Authored 2026-11-16 · 1 day ago

Hash
9adc516eca5a2a003de66ac2365a55776cef18c6
38 files changed +6675 −0
cmd/bluegit-backup/main.go added +349 −0
@@ -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.
2package main
3
4import (
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
26func 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
46De key kan ook uit BLUEGIT_BACKUP_KEY komen (dan staat hij niet in de proceslijst).
47`)
48}
49
50func 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
101func 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
114func 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
149type client struct {
150 base, token string
151}
152
153func 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
175func (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
193func 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
205func 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
231func 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
249func 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
261func 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
277func 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
300func 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}
docs/ASSUMPTIONS.md added +138 −0
@@ -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# Aannames
2
3Deze 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`.
docs/BACKUP-PROTOCOL.md added +100 −0
@@ -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
3Een losse backup server ([timfa/bluegit-backup](https://git.timfalken.com/timfa/bluegit-backup)) houdt een kopie bij van alle gegevens en configuratie van één BlueGit. Hij haalt ze langzaam op, krijgt na elke wijziging een melding, maakt periodiek een gecomprimeerd archief, en kan BlueGit naar zo'n archief terugzetten.
4
5Eén BlueGit kan meerdere backup servers hebben (hoogstens 16), elk met een eigen Backupserver-Key. Een backup server hoort bij één BlueGit.
6
7## In BlueGit
8
9**Beheer > Backup** (`/admin/backup`, alleen installatiebeheerders) toont de lijst met backup servers: naam, gekoppeld of wachtend op de key, adres en laatste contact. **Backup server toevoegen** maakt een nieuwe server met een eigen key, die één keer wordt getoond.
10
11Per backup server (`/admin/backup/s/<id>`) staat dezelfde bediening als in de webinterface van de backup server zelf:
12
13- **Status**: laatste sync en het resultaat ervan, aantal syncs en meldingen, grootte van de kopie, archieven, de laatste rollback en de versie. Met de knoppen *Nu synchroniseren*, *Nu archiveren* en *Nu opruimen*.
14- **Instellingen** van de backup server: archiefinterval, bewaartermijn, minimale vrije ruimte, downloadsnelheid, syncintervallen, publiek adres en luisteradres. BlueGit krijgt de velden van de backup server en toont ze zoals ze daar staan.
15- **Backup-archieven** met *Verwijderen* en *Rollback*. Een rollback staat achter een grote rode waarschuwing, een vinkje ("ik begrijp dat dit niet terug te draaien is"), het intypen van de archiefnaam en een bevestigingsdialoog.
16- **Backupserver-Key** vervangen (de oude key werkt meteen niet meer; de server moet opnieuw koppelen), de server hernoemen, of key intrekken en de server verwijderen. Bij verwijderen vraagt BlueGit de backup server eerst om te ontkoppelen. De archieven blijven op de backup server staan.
17
18BlueGit kent de acties niet vooraf. Het vraagt ze op bij de backup server (`GET /api/v1/admin/actions`) en stuurt ze ondertekend door. Alles wat de backup server voor BlueGit openzet, kan dus ook hier. Koppelen en een archief downloaden kan alleen op de backup server zelf.
19
20Dezelfde acties via de API (token van een beheerder, scope `api`/`admin`):
21
22| | |
23|---|---|
24| `GET /api/v1/admin/backup` | `instance_id` en de lijst met backup servers |
25| `POST /api/v1/admin/backup/servers` | `{"name"}`: nieuwe backup server; het antwoord bevat eenmalig `key` |
26| `GET /api/v1/admin/backup/servers/{id}` | server met `remote` (status), `archives` en `config`, zoals de backup server ze meldt |
27| `PUT /api/v1/admin/backup/servers/{id}` | `{"name"}`: hernoemen |
28| `POST /api/v1/admin/backup/servers/{id}/key` | nieuwe key (eenmalig in het antwoord) |
29| `DELETE /api/v1/admin/backup/servers/{id}` | ontkoppelen en vergeten |
30| `POST /api/v1/admin/backup/servers/{id}/actions/{name}` | actie van de backup server, bijvoorbeeld `config.update` met `{"retention_days": "14"}`, `sync`, `archive`, `prune`, `archive.delete` met `{"name"}`, of `rollback` met `{"archive": "naam", "confirm": "naam"}` |
31
32Het antwoord van een actie is het antwoord van de backup server, met dezelfde statuscode.
33
34## Protocol
35
36**De backup server praat met BlueGit** met de key als bearer-token (`Authorization: Bearer bgbk_…`):
37
38| | |
39|---|---|
40| `GET /api/v1/backup/info` | `instance_id`, `base_url`, naam en adres van de server bij deze key |
41| `POST /api/v1/backup/connect` | `{"server_url", "server_id"}`: waar BlueGit meldingen heen stuurt |
42| `GET /api/v1/backup/manifest` | alle bestanden: pad, grootte, mtime, mode; de database ook met sha256 |
43| `GET /api/v1/backup/file?path=…` | één bestand |
44| `POST /api/v1/backup/restore` | tar.gz met logische paden; BlueGit pakt uit en herstart (202) |
45
46Vijf mislukte key-pogingen per minuut per IP geven daarna `429`.
47
48**BlueGit praat met de backup server** met een HMAC-handtekening. Het geheim is `sha256("bluegit-backup-sign:" + key)` als hex; beide kanten leiden het af uit de key. Koppen:
49
50```text
51X-BlueGit-Instance: <instance_id>
52X-BlueGit-Timestamp: <unix-seconden> (hoogstens 5 minuten verschil)
53X-BlueGit-Signature: hex(HMAC-SHA256(geheim, METHOD "\n" PAD "\n" TS "\n" sha256hex(body)))
54```
55
56| | |
57|---|---|
58| `POST /api/v1/notify` | er is iets veranderd |
59| `GET /api/v1/archives` | `{"archives": [{name, created_at, size}]}` |
60| `GET /api/v1/status` | interval, bewaartermijn, stand van de laatste rollback |
61| `POST /api/v1/rollback` | `{"archive": "naam"}` |
62| `* /api/v1/admin/…` | de beheeracties van de backup server (lijst: `GET /api/v1/admin/actions`, veld `bluegit: true`) |
63
64**Meldingen.** Elke gekoppelde backup server krijgt ze, ondertekend met zijn eigen key. Na elk schrijvend HTTP-verzoek (behalve de backup-API zelf en `git-upload-pack`), na elke push (ook SSH) en bij elke CI-gebeurtenis meldt BlueGit een wijziging. Meldingen worden 2 seconden gebundeld en bij een fout tot vier keer opnieuw geprobeerd. De backup server haalt daarnaast periodiek alles op, dus een gemiste melding kost alleen vertraging. Het adres van de backup server mag een privéadres zijn (de beheerder koppelt hem met een eigen key); de SSRF-regels van webhooks gelden hier niet.
65
66### Compatibiliteit (protocolversie)
67
68Elke 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
75Wat 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
82Een 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
87state/bluegit.db consistente kopie (VACUUM INTO), niet het live bestand
88state/secret.key nodig voor de versleutelde geheimen in de database
89state/ssh/… SSH-hostkey
90state/logos/…, state/avatars/…
91data/repos/… bare repositories
92data/releases/… release-assets (zonder .incoming)
93data/artifacts/… CI-artifacts
94```
95
96Niet 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`.
docs/BACKUP-SERVER.md added +194 −0
@@ -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-backup
2
3Een 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
15Het 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
22yay -S bluegit-backup
23```
24
25Het 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
29Bij een release staan `bluegit-backup-linux-amd64`, `bluegit-backup-linux-arm64` en `SHA256SUMS`. Zelf bouwen:
30
31```sh
32go 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
391. Zet in `config.yml` `public_url` op het adres waarop BlueGit deze server bereikt.
402. Start de server: `systemctl enable --now bluegit-backup`.
413. Voeg in BlueGit onder *Beheer → Backup* een backup server toe. De Backupserver-Key wordt één keer getoond.
424. 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
57Daarna haalt de server meteen een volledige kopie op en maakt hij een eerste archief.
58
59## Webinterface
60
61Open `http://<server>:8080` en log in met het beheertoken uit `data_dir/admin.token`:
62
63```sh
64sudo -u bluegit-backup bluegit-backup token
65```
66
67Daar 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
75Passen 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
77De 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
81Elke 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
103BlueGit 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
105Past 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
111Updaten 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
116bluegit-backup status | list | config | actions
117bluegit-backup sync | archive | prune | disconnect
118bluegit-backup set retention_days=14 archive_interval=12h
119bluegit-backup delete bluegit-20261115-030000.tar.gz
120bluegit-backup rollback bluegit-20261115-030000.tar.gz # vraagt om de naam over te typen
121bluegit-backup token # beheertoken voor de webinterface
122```
123
124Deze 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
140In `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
150Een 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
157Updaten 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
162go test ./... # unit-tests
163./scripts/build-bluegit.sh # bouwt .bluegit-bin/bluegit
164BLUEGIT_BIN=$PWD/.bluegit-bin/bluegit go test -tags integration -v ./integration/
165```
166
167Daarnaast controleren unit-tests dat elke wijzigende actie een formulier in de webinterface heeft, en elk formulier een API-actie.
168
169De 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
190De 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
194Zie [LICENSE](LICENSE).
internal/backupserver/archive/archive.go added +349 −0
@@ -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 met
4// logische paden (state/…, data/…), precies wat BlueGit bij een restore
5// aanneemt. Naam: bluegit-YYYYMMDD-HHMMSS.tar.gz in UTC.
6package archive
7
8import (
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
25var 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 ..).
28func ValidName(name string) bool { return nameRE.MatchString(name) }
29
30// Archive is één archief op schijf.
31type 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.
38type 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
45func (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.
53func (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.
83func createdAt(name string, fi fs.FileInfo) time.Time {
84 return fi.ModTime().UTC()
85}
86
87// Path geeft het pad van een bestaand archief.
88func (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.
100func (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.
109func (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).
125func (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.
184func (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.
202func (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.
238func 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
274func 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.
297func 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.
307func 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}
internal/backupserver/archive/archive_test.go added +124 −0
@@ -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 @@
1package archive
2
3import (
4 "archive/tar"
5 "bytes"
6 "compress/gzip"
7 "os"
8 "path/filepath"
9 "testing"
10 "time"
11)
12
13func 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
26func 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
58func 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
105func 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}
internal/backupserver/archive/free_linux.go added +14 −0
@@ -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 || freebsd
2
3package archive
4
5import "syscall"
6
7// FreeBytes geeft de vrije ruimte voor een gewone gebruiker op dir.
8func 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}
internal/backupserver/archive/free_other.go added +8 −0
@@ -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
3package archive
4
5import "errors"
6
7// FreeBytes is niet beschikbaar op dit platform; de schijf-vol-regel doet dan niets.
8func FreeBytes(dir string) (uint64, error) { return 0, errors.New("statfs niet beschikbaar") }
internal/backupserver/config/config.go added +154 −0
@@ -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.
2package config
3
4import (
5 "fmt"
6 "os"
7 "strings"
8 "time"
9
10 "gopkg.in/yaml.v3"
11)
12
13// Config is /etc/bluegit-backup/config.yml.
14type 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.
44type Duration struct{ time.Duration }
45
46// UnmarshalYAML leest een Go-duur of een aantal seconden.
47func (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.
68func (d Duration) MarshalYAML() (any, error) { return d.String(), nil }
69
70// Defaults vult lege velden.
71func (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.
105func (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.
119func 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.
135func Example() string {
136 return `# bluegit-backup. Kopieer naar /etc/bluegit-backup/config.yml.
137listen: 0.0.0.0:8080
138# Waar BlueGit deze server bereikt (meldingen, archieflijst, rollback).
139public_url: http://backup.lan:8080
140data_dir: /var/lib/bluegit-backup
141# Zo vaak wordt de hele kopie gecomprimeerd opgeslagen. Standaard dagelijks.
142archive_interval: 24h
143# Archieven ouder dan dit gaan weg (0 = nooit op leeftijd). Het nieuwste blijft.
144retention_days: 30
145# Minder vrije ruimte dan dit: het oudste archief gaat weg.
146min_free_mb: 1024
147# Downloadsnelheid van BlueGit in KiB/s, zodat BlueGit er geen last van heeft.
148rate_limit_kib: 1024
149# Ook zonder melding zo vaak alles nalopen.
150full_sync_interval: 1h
151# Minimale tijd tussen twee syncs na meldingen.
152min_sync_interval: 10s
153`
154}
internal/backupserver/config/config_test.go added +95 −0
@@ -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 @@
1package config
2
3import (
4 "os"
5 "path/filepath"
6 "testing"
7 "time"
8)
9
10func 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
20func 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
46func 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
66func 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
86func 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}
internal/backupserver/config/fields.go added +211 −0
@@ -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 @@
1package config
2
3import (
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.
20type 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.
31var 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.
43func 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.
53func (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".
78func 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").
96func 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.
112func (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.
160func (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.
181const SettingsFile = "settings.yml"
182
183// LoadSettings leest data_dir/settings.yml (ontbreekt: leeg).
184func 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.
200func 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}
internal/backupserver/integration/backup_test.go added +498 −0
@@ -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 integration
2
3package integration
4
5import (
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.
23func 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.
60func 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.
101func 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.
139func 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.
170func 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.
205func 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.
253func 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
327func 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
353func 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".
367func 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".
415func 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.
458func 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}
internal/backupserver/integration/compat_test.go added +147 −0
@@ -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 integration
2
3package integration
4
5import (
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.
17func 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.
26var bannerPages = []string{"/", "/users/tim", "/tim/alpha", "/admin", "/admin/backup", "/-/info", "/help"}
27
28func 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.
48func 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.
104func 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}
internal/backupserver/integration/harness_test.go added +613 −0
@@ -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 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.
7package integration
8
9import (
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
32func 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
47func 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.
58type 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
72type syncBuf struct {
73 mu sync.Mutex
74 b bytes.Buffer
75}
76
77func (s *syncBuf) Write(p []byte) (int, error) {
78 s.mu.Lock()
79 defer s.mu.Unlock()
80 return s.b.Write(p)
81}
82
83func (s *syncBuf) String() string {
84 s.mu.Lock()
85 defer s.mu.Unlock()
86 return s.b.String()
87}
88
89func 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.
98func 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.
111const FutureProtocol = 99
112
113func 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
121listen: 127.0.0.1:%d
122state_path: %s
123storage_path: %s
124auth:
125 mode: dev
126 dev_user: tim
127 dev_auth_id: 1
128 user_agent: bluegit-backup-it
129git:
130 binary: git
131 default_branch: master
132ssh:
133 enabled: false
134ci:
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
169func 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.
179func (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).
210func (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.
222func (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.
239func (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.
245func (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.
267func (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.
277func (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.
288func (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.
296func (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.
304func (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.
310func (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.
317func (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.
326func (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.
340func (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.
346func (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.
364func (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.
371type 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.
399func (g *BlueGit) BackupStatus() BackupStatus { return g.ServerStatus(g.Server) }
400
401// ServerStatus geeft de stand van backup server id ("" = de eerste).
402func (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).
429func (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.
442func (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.
455func (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.
463type Backup struct {
464 t *testing.T
465 Srv *server.Server
466 URL string
467 Dir string
468 Cfg config.Config
469}
470
471func 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
507type testWriter struct{ t *testing.T }
508
509func (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.
515func (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.
534func (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.
543func (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.
552func (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.
564func (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.
569func (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.
584func (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.
593func 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.
606func 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}
internal/backupserver/integration/ui_test.go added +399 −0
@@ -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 integration
2
3package integration
4
5import (
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.
20type webUI struct {
21 t *testing.T
22 b *Backup
23 hc *http.Client
24 csrf string
25}
26
27func 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.
54func (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.
70func (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
87func 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
107func 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).
117func 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.
230func 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.
278func 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.
349func 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}
internal/backupserver/mirror/mirror.go added +283 −0
@@ -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 @@
1package mirror
2
3import (
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.
24type Mirror struct {
25 Dir string
26 Index string
27}
28
29// Stats zegt wat een sync deed.
30type 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.
39func (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
51func (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.
64func (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.
70func (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.
80func (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
91func (m *Mirror) real(logical string) string {
92 return filepath.Join(m.Dir, filepath.FromSlash(logical))
93}
94
95func 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.
104func (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
176func (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
216func 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.
233func (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).
275func (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}
internal/backupserver/mirror/remote.go added +161 −0
@@ -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.
2package mirror
3
4import (
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.
21var ErrGone = errors.New("bestand verdwenen")
22
23// Remote is de backup-API van één BlueGit, met de Backupserver-Key.
24type 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
35func (r *Remote) client() *http.Client {
36 if r.HTTP != nil {
37 return r.HTTP
38 }
39 return &http.Client{Timeout: 0}
40}
41
42func (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.
76type HTTPError struct {
77 Status int
78 Msg string
79}
80
81func (e *HTTPError) Error() string { return fmt.Sprintf("BlueGit HTTP %d: %s", e.Status, e.Msg) }
82
83func (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.
93func (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.
100func (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.
112func (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.
119func (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.
131func (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.
141func (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}
internal/backupserver/protocol/compat.go added +121 −0
@@ -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 @@
1package protocol
2
3import (
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).
21var (
22 ProtocolVersion = "1"
23 MinBlueGitProtocol = "1"
24)
25
26// Koppen met de protocolversie.
27const (
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.
37const (
38 CompatOK = "ok"
39 CompatBlueGitTooOld = "bluegit_too_old"
40 CompatBackupTooOld = "backup_too_old"
41)
42
43func 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.
52func Protocol() int { return atoiMin1(ProtocolVersion) }
53
54// MinProtocol is de oudste protocolversie van BlueGit die deze backup
55// server ondersteunt.
56func 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).
65func 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.
76type 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.
83func (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.
89func 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
103func 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.
117func 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}
internal/backupserver/protocol/compat_test.go added +41 −0
@@ -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 @@
1package protocol
2
3import (
4 "net/http"
5 "testing"
6)
7
8func 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
26func 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}
internal/backupserver/protocol/protocol.go added +167 −0
@@ -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).
3package protocol
4
5import (
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.
18const KeyPrefix = "bgbk_"
19
20// Koppen van een ondertekend verzoek van BlueGit.
21const (
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.
28const MaxSkew = 5 * time.Minute
29
30// DBPath is het logische pad van de databasekopie.
31const DBPath = "state/bluegit.db"
32
33// Entry is één bestand in het manifest van BlueGit.
34type 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.
43type 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.
50type 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.
64func (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.
76func 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))).
82func 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).
91func 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.
99func 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
119var (
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.
127func 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
160func has(list []string, v string) bool {
161 for _, x := range list {
162 if x == v {
163 return true
164 }
165 }
166 return false
167}
internal/backupserver/protocol/protocol_test.go added +46 −0
@@ -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 @@
1package protocol
2
3import (
4 "bytes"
5 "net/http"
6 "testing"
7 "time"
8)
9
10// Vaste vector: moet gelijk blijven aan internal/backup in BlueGit.
11func 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
21func 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
35func 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}
internal/backupserver/server/actions.go added +461 −0
@@ -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 @@
1package server
2
3import (
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.
23type 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.
27type 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.
44type fileResult struct{ path, name string }
45
46func errBody(err error) map[string]string { return map[string]string{"error": err.Error()} }
47
48// Actions is de volledige lijst met beheerhandelingen.
49func (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
107func 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
115func (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.
125type 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.
133type ConfigField struct {
134 config.Field
135 Value string `json:"value"`
136}
137
138// ConfigView geeft alle instellingen met hun huidige waarde.
139func (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.
157func (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
199func (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
214func (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.
236func (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
252func (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
262func (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
280func (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
295func (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.
307func (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.
338func (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
354func 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.
364func (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.
395func (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).
432func 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}
internal/backupserver/server/server.go added +682 −0
@@ -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 BlueGit
2// en de lokale beheer-API.
3package server
4
5import (
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).
27var Version = "dev"
28
29// Server is één backup server voor één BlueGit.
30type 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).
73func (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.
80type 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.
88func 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).
124func (s *Server) SetFree(f func(string) (uint64, error)) { s.archives.Free = f }
125
126// AdminToken is het lokale beheertoken.
127func (s *Server) AdminToken() string { return s.adminToken }
128
129func (s *Server) now() time.Time { return s.Now() }
130
131func (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.
136func (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.
148func (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).
158func 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.
169var 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.
173func (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
185func (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.
192func (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).
198func (s *Server) Kick() {
199 select {
200 case s.kick <- struct{}{}:
201 default:
202 }
203}
204
205func (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.
243func (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
278func (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.
301func (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.
313func (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
344func (s *Server) minFree() uint64 { return uint64(s.cfg().MinFreeMB) << 20 }
345
346// Prune past de bewaarregels toe.
347func (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
357func 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
366func writeErr(w http.ResponseWriter, code int, msg string) {
367 writeJSON(w, code, map[string]string{"error": msg})
368}
369
370type ctxBody struct{}
371
372// signed controleert de HMAC-handtekening van de gekoppelde BlueGit.
373func (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
401func 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
409func (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
417func (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.
427type 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.
458func (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
477func (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.
482type 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.
491type 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
501var errBadRequest = errors.New("ongeldig verzoek")
502
503// Connect koppelt deze server aan een BlueGit. Er is er altijd hoogstens één.
504func (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.
593func (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
610func (s *Server) setRollback(r RollbackStatus) {
611 s.mu.Lock()
612 s.rollback = r
613 s.mu.Unlock()
614}
615
616// ---------- rollback ----------
617
618func (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.
633func (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}
internal/backupserver/server/server_test.go added +201 −0
@@ -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 @@
1package server
2
3import (
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.
24type 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
33func 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
77func 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
88func 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
96func 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
137func 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
184func 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}
internal/backupserver/server/state.go added +72 −0
@@ -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 @@
1package server
2
3import (
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.
15type 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.
23func (s State) Connected() bool { return s.BlueGitURL != "" && s.Key != "" && s.InstanceID != "" }
24
25func 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
37func 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.
50func 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).
66func 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}
internal/backupserver/server/ui.go added +303 −0
@@ -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 @@
1package server
2
3import (
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/*
21var webFS embed.FS
22
23var 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
34const (
35 sessionCookie = "bbsession"
36 sessionTTL = 12 * time.Hour
37)
38
39type session struct {
40 csrf string
41 expires time.Time
42 flash string
43 isErr bool
44}
45
46func randHex(n int) string {
47 b := make([]byte, n)
48 _, _ = rand.Read(b)
49 return hex.EncodeToString(b)
50}
51
52func 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
65func (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
80func (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
93func (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
110func 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.
119func (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
139func (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
147func (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
157func (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
165func (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
192func (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.
205type 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
216func (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.
229func (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
270func 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.
303func UIPath(a Action) string { return "/ui/act/" + url.PathEscape(a.Name) }
internal/backupserver/server/ui_test.go added +285 −0
@@ -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 @@
1package server
2
3import (
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.
21type uiClient struct {
22 t *testing.T
23 h http.Handler
24 cookie *http.Cookie
25}
26
27func (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
51var csrfRE = regexp.MustCompile(`name="csrf" value="([0-9a-f]+)"`)
52
53func 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.
80func 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
134func 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
207func 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
218func 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
243func 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}
internal/backupserver/server/web/index.html added +104 −0
@@ -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 &lt;admin.token&gt;</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>
70Alle 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 &lt;admin.token&gt;</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}}
internal/backupserver/server/web/login.html added +12 −0
@@ -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>
internal/backupserver/server/web/style.html added +25 −0
@@ -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)}
4header{background:#0d1b3e;color:#fff;padding:.8rem 1.5rem;display:flex;align-items:center;gap:1rem}
5header h1{font-size:1.15rem;margin:0;flex:1}header form{margin:0}
6main{max-width:1000px;margin:1.5rem auto;padding:0 1rem}
7section{background:#fff;border:1px solid var(--border);border-radius:8px;padding:1rem 1.25rem;margin-bottom:1.25rem}
8section h2{margin:.1rem 0 .8rem;font-size:1.1rem}
9dl{display:grid;grid-template-columns:max-content 1fr;gap:.25rem 1rem;margin:0}dt{color:var(--muted)}dd{margin:0}
10label{display:block;font-weight:600;margin:.6rem 0 .2rem}small{color:var(--muted);font-weight:400;display:block}
11input[type=text],input[type=password],input[type=url]{width:100%;padding:.45rem .6rem;border:1px solid var(--border);border-radius:6px;font:inherit}
12button{background:var(--blue);color:#fff;border:0;border-radius:6px;padding:.45rem .9rem;font:inherit;cursor:pointer}
13button.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}
15table{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}
23details{margin-top:.5rem}code{background:var(--bg);padding:0 .3rem;border-radius:4px}
24.login{max-width:420px;margin:4rem auto}
25</style>{{end}}
internal/backupserver/throttle/throttle.go added +130 −0
@@ -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.
2package throttle
3
4import (
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.
13type 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.
25func 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
36func 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.
48func (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.
58func (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.
86func (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
93type reader struct {
94 ctx context.Context
95 r io.Reader
96 l *Limiter
97}
98
99func (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.
116func (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}
internal/backupserver/throttle/throttle_test.go added +70 −0
@@ -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 @@
1package throttle
2
3import (
4 "bytes"
5 "context"
6 "io"
7 "testing"
8 "time"
9)
10
11func 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
33func 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
44func 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
54func 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}
packaging/aur-backup/PKGBUILD added +35 −0
@@ -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>
2pkgname=bluegit-backup
3pkgver=20261115000000
4pkgrel=1
5pkgdesc='Backup server for a BlueGit instance: incremental copy, archives, rollback'
6arch=('x86_64' 'aarch64')
7url='https://git.timfalken.com/timfa/bluegit-backup'
8license=('MIT')
9makedepends=('go')
10backup=('etc/bluegit-backup/config.yml')
11options=('!debug')
12install=bluegit-backup.install
13_commit=0000000000000000000000000000000000000000
14source=("bluegit-backup-${_commit}.tar.gz::https://git.timfalken.com/timfa/bluegit-backup/-/archive/${_commit}/bluegit-backup-${_commit}.tar.gz")
15sha256sums=('SKIP')
16
17build() {
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
27package() {
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}
packaging/aur-backup/bluegit-backup.install added +39 −0
@@ -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.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
13post_install() {
14 systemd-sysusers bluegit-backup.conf || true
15 systemd-tmpfiles --create bluegit-backup.conf || true
16 _bb_run daemon-reload
17 cat <<'MSG'
18bluegit-backup: zet public_url in /etc/bluegit-backup/config.yml (het adres waarop
19BlueGit deze server bereikt) en start de dienst:
20 systemctl enable --now bluegit-backup.service
21Maak 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
23MSG
24}
25
26post_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
33pre_remove() {
34 _bb_run disable --now bluegit-backup.service
35}
36
37post_remove() {
38 _bb_run daemon-reload
39}
packaging/backup/bluegit-backup.service added +25 −0
@@ -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]
2Description=BlueGit backup server
3After=network-online.target
4Wants=network-online.target
5
6[Service]
7Type=simple
8User=bluegit-backup
9Group=bluegit-backup
10# Optioneel, bijvoorbeeld BLUEGIT_BACKUP_KEY voor `connect`.
11EnvironmentFile=-/etc/bluegit-backup/env
12ExecStart=/usr/bin/bluegit-backup serve --config /etc/bluegit-backup/config.yml
13Restart=on-failure
14# Lage prioriteit: archiveren en comprimeren mogen de machine niet ophouden.
15Nice=10
16IOSchedulingClass=idle
17NoNewPrivileges=true
18ProtectSystem=strict
19ProtectHome=true
20StateDirectory=bluegit-backup
21ReadWritePaths=/var/lib/bluegit-backup
22PrivateTmp=true
23
24[Install]
25WantedBy=multi-user.target
packaging/backup/config.yml added +17 −0
@@ -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.
2listen: 0.0.0.0:8080
3# Waar BlueGit deze server bereikt (meldingen, archieflijst, rollback).
4public_url: http://backup.lan:8080
5data_dir: /var/lib/bluegit-backup
6# Zo vaak wordt de hele kopie gecomprimeerd opgeslagen. Standaard dagelijks.
7archive_interval: 24h
8# Archieven ouder dan dit gaan weg (0 = nooit op leeftijd). Het nieuwste blijft.
9retention_days: 30
10# Minder vrije ruimte dan dit: het oudste archief gaat weg.
11min_free_mb: 1024
12# Downloadsnelheid van BlueGit in KiB/s, zodat BlueGit er geen last van heeft.
13rate_limit_kib: 1024
14# Ook zonder melding zo vaak alles nalopen.
15full_sync_interval: 1h
16# Minimale tijd tussen twee syncs na meldingen.
17min_sync_interval: 10s
packaging/backup/sysusers.conf added +1 −0
@@ -0,0 +1 @@
1 u bluegit-backup - "BlueGit backup server" /var/lib/bluegit-backup /usr/sbin/nologin
@@ -0,0 +1 @@
1u bluegit-backup - "BlueGit backup server" /var/lib/bluegit-backup /usr/sbin/nologin
packaging/backup/tmpfiles.conf added +1 −0
@@ -0,0 +1 @@
1 d /var/lib/bluegit-backup 0750 bluegit-backup bluegit-backup -
@@ -0,0 +1 @@
1d /var/lib/bluegit-backup 0750 bluegit-backup bluegit-backup -