BlueGit

timfa bluegit

bluegit-backup: backup server voor BlueGit

- koppelen met Backupserver-Key, keuze wissen/herstellen bij nieuwe instantie
- gedoseerd synchroniseren (token bucket), melding van BlueGit per wijziging
- archieven tar.gz per interval, opruimen op leeftijd en bij volle schijf
- rollback vanuit BlueGit
- integratietests tegen een echte BlueGit; releases (AUR, self-update,
  tag-binaries) alleen na groene integratietests en met .release-enabled

timfa Grok Bot · pushed by timfa

Authored 2026-11-15 · 2 days ago

Hash
27b370f993799263135356c5a6b7c7c219419b0a
Parent
4862af11
31 files changed +4256 −0
cmd/bluegit-backup/main.go added +237 −0
@@ -0,0 +1,237 @@
1 // bluegit-backup houdt een kopie bij van één BlueGit-instantie.
2 package main
3
4 import (
5 "bufio"
6 "bytes"
7 "context"
8 "encoding/json"
9 "flag"
10 "fmt"
11 "io"
12 "log/slog"
13 "net"
14 "net/http"
15 "os"
16 "os/signal"
17 "strings"
18 "syscall"
19 "time"
20
21 "git.timfalken.com/timfa/bluegit-backup/internal/config"
22 "git.timfalken.com/timfa/bluegit-backup/internal/server"
23 )
24
25 func usage() {
26 fmt.Fprint(os.Stderr, `bluegit-backup
27
28 bluegit-backup serve [--config /etc/bluegit-backup/config.yml]
29 bluegit-backup connect [--config …] --url https://git.example.com [--key bgbk_…] [--on-conflict wipe|restore]
30 bluegit-backup status [--config …]
31 bluegit-backup list [--config …]
32 bluegit-backup archive [--config …] nu een archief maken
33 bluegit-backup sync [--config …] nu synchroniseren
34 bluegit-backup prune [--config …] bewaarregels nu toepassen
35 bluegit-backup example-config
36 bluegit-backup version
37
38 De key kan ook uit BLUEGIT_BACKUP_KEY komen (dan staat hij niet in de proceslijst).
39 `)
40 }
41
42 func main() {
43 if len(os.Args) < 2 {
44 usage()
45 os.Exit(2)
46 }
47 var err error
48 switch os.Args[1] {
49 case "serve":
50 err = serve(os.Args[2:])
51 case "connect":
52 err = connect(os.Args[2:], os.Stdin, os.Stdout)
53 case "status":
54 err = simple(os.Args[2:], http.MethodGet, "/api/v1/admin/status")
55 case "list":
56 err = simple(os.Args[2:], http.MethodGet, "/api/v1/admin/archives")
57 case "archive":
58 err = simple(os.Args[2:], http.MethodPost, "/api/v1/admin/archive")
59 case "sync":
60 err = simple(os.Args[2:], http.MethodPost, "/api/v1/admin/sync")
61 case "prune":
62 err = simple(os.Args[2:], http.MethodPost, "/api/v1/admin/prune")
63 case "example-config":
64 fmt.Print(config.Example())
65 case "version":
66 fmt.Println(server.Version)
67 default:
68 usage()
69 os.Exit(2)
70 }
71 if err != nil {
72 fmt.Fprintln(os.Stderr, "bluegit-backup:", err)
73 os.Exit(1)
74 }
75 }
76
77 func configPath(p string) string {
78 if p != "" {
79 return p
80 }
81 if v := os.Getenv("BLUEGIT_BACKUP_CONFIG"); v != "" {
82 return v
83 }
84 if _, err := os.Stat("bluegit-backup.yml"); err == nil {
85 return "bluegit-backup.yml"
86 }
87 return "/etc/bluegit-backup/config.yml"
88 }
89
90 func serve(args []string) error {
91 fs := flag.NewFlagSet("serve", flag.ExitOnError)
92 cfgPath := fs.String("config", "", "pad naar config.yml")
93 _ = fs.Parse(args)
94 cfg, err := config.Load(configPath(*cfgPath))
95 if err != nil {
96 return err
97 }
98 log := slog.New(slog.NewTextHandler(os.Stdout, nil))
99 srv, err := server.New(cfg, log)
100 if err != nil {
101 return err
102 }
103 ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
104 defer stop()
105 ln, err := net.Listen("tcp", cfg.Listen)
106 if err != nil {
107 return err
108 }
109 hs := &http.Server{Handler: srv.Handler(), ReadHeaderTimeout: 10 * time.Second}
110 go func() {
111 <-ctx.Done()
112 c, cancel := context.WithTimeout(context.Background(), 10*time.Second)
113 defer cancel()
114 _ = hs.Shutdown(c)
115 }()
116 srv.Run(ctx)
117 log.Info("bluegit-backup luistert", "addr", ln.Addr().String(), "public_url", cfg.PublicURL, "version", server.Version)
118 if err := hs.Serve(ln); err != nil && err != http.ErrServerClosed {
119 return err
120 }
121 return nil
122 }
123
124 type client struct {
125 base, token string
126 }
127
128 func newClient(cfgPath string) (*client, error) {
129 cfg, err := config.Load(configPath(cfgPath))
130 if err != nil {
131 return nil, err
132 }
133 tok, err := server.ReadAdminToken(cfg.DataDir)
134 if err != nil {
135 return nil, fmt.Errorf("admin.token lezen (draai als de gebruiker van de dienst of root): %w", err)
136 }
137 host, port, err := net.SplitHostPort(cfg.Listen)
138 if err != nil {
139 return nil, err
140 }
141 if host == "" || host == "0.0.0.0" || host == "::" {
142 host = "127.0.0.1"
143 }
144 return &client{base: "http://" + net.JoinHostPort(host, port), token: tok}, nil
145 }
146
147 func (c *client) do(method, p string, in any) (int, []byte, error) {
148 var body io.Reader
149 if in != nil {
150 b, _ := json.Marshal(in)
151 body = bytes.NewReader(b)
152 }
153 req, _ := http.NewRequest(method, c.base+p, body)
154 req.Header.Set("Authorization", "Bearer "+c.token)
155 req.Header.Set("Content-Type", "application/json")
156 resp, err := (&http.Client{Timeout: 30 * time.Minute}).Do(req)
157 if err != nil {
158 return 0, nil, err
159 }
160 defer resp.Body.Close()
161 b, _ := io.ReadAll(resp.Body)
162 return resp.StatusCode, b, nil
163 }
164
165 func simple(args []string, method, p string) error {
166 fs := flag.NewFlagSet("cmd", flag.ExitOnError)
167 cfgPath := fs.String("config", "", "pad naar config.yml")
168 _ = fs.Parse(args)
169 c, err := newClient(*cfgPath)
170 if err != nil {
171 return err
172 }
173 code, b, err := c.do(method, p, nil)
174 if err != nil {
175 return err
176 }
177 var pretty bytes.Buffer
178 if json.Indent(&pretty, b, "", " ") == nil {
179 b = pretty.Bytes()
180 }
181 fmt.Println(string(b))
182 if code >= 300 {
183 return fmt.Errorf("HTTP %d", code)
184 }
185 return nil
186 }
187
188 func connect(args []string, stdin io.Reader, stdout io.Writer) error {
189 fs := flag.NewFlagSet("connect", flag.ExitOnError)
190 cfgPath := fs.String("config", "", "pad naar config.yml")
191 u := fs.String("url", "", "adres van BlueGit")
192 key := fs.String("key", "", "Backupserver-Key (of BLUEGIT_BACKUP_KEY)")
193 onConflict := fs.String("on-conflict", "", "wipe of restore, zonder te vragen")
194 _ = fs.Parse(args)
195 if *key == "" {
196 *key = os.Getenv("BLUEGIT_BACKUP_KEY")
197 }
198 if *u == "" || *key == "" {
199 return fmt.Errorf("--url en --key (of BLUEGIT_BACKUP_KEY) zijn nodig")
200 }
201 c, err := newClient(*cfgPath)
202 if err != nil {
203 return err
204 }
205 req := server.ConnectRequest{URL: *u, Key: *key, OnConflict: *onConflict}
206 code, b, err := c.do(http.MethodPost, "/api/v1/admin/connect", req)
207 if err != nil {
208 return err
209 }
210 if code == http.StatusConflict {
211 var cf server.ConflictError
212 _ = json.Unmarshal(b, &cf)
213 fmt.Fprintf(stdout, "Deze backup server hoort bij een andere BlueGit (%s, instance %s) en heeft %d archief/archieven.\n", cf.PreviousURL, cf.PreviousInstance, cf.Archives)
214 fmt.Fprintln(stdout, "Een backup server kan maar aan één BlueGit gekoppeld zijn. Kies:")
215 fmt.Fprintln(stdout, " 1) Oude backups verwijderen en met de nieuwe instantie verbinden")
216 fmt.Fprintln(stdout, " 2) De nieuwe instantie terugzetten naar de gegevens in deze backup server (overschrijft alles daar)")
217 fmt.Fprint(stdout, "Keuze [1/2, leeg = afbreken]: ")
218 line, _ := bufio.NewReader(stdin).ReadString('\n')
219 switch strings.TrimSpace(line) {
220 case "1":
221 req.OnConflict = "wipe"
222 case "2":
223 req.OnConflict = "restore"
224 default:
225 return fmt.Errorf("afgebroken; er is niets veranderd")
226 }
227 code, b, err = c.do(http.MethodPost, "/api/v1/admin/connect", req)
228 if err != nil {
229 return err
230 }
231 }
232 fmt.Fprintln(stdout, strings.TrimSpace(string(b)))
233 if code >= 300 {
234 return fmt.Errorf("HTTP %d", code)
235 }
236 return nil
237 }
@@ -0,0 +1,237 @@
1// bluegit-backup houdt een kopie bij van één BlueGit-instantie.
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 "os"
16 "os/signal"
17 "strings"
18 "syscall"
19 "time"
20
21 "git.timfalken.com/timfa/bluegit-backup/internal/config"
22 "git.timfalken.com/timfa/bluegit-backup/internal/server"
23)
24
25func usage() {
26 fmt.Fprint(os.Stderr, `bluegit-backup
27
28 bluegit-backup serve [--config /etc/bluegit-backup/config.yml]
29 bluegit-backup connect [--config …] --url https://git.example.com [--key bgbk_…] [--on-conflict wipe|restore]
30 bluegit-backup status [--config …]
31 bluegit-backup list [--config …]
32 bluegit-backup archive [--config …] nu een archief maken
33 bluegit-backup sync [--config …] nu synchroniseren
34 bluegit-backup prune [--config …] bewaarregels nu toepassen
35 bluegit-backup example-config
36 bluegit-backup version
37
38De key kan ook uit BLUEGIT_BACKUP_KEY komen (dan staat hij niet in de proceslijst).
39`)
40}
41
42func main() {
43 if len(os.Args) < 2 {
44 usage()
45 os.Exit(2)
46 }
47 var err error
48 switch os.Args[1] {
49 case "serve":
50 err = serve(os.Args[2:])
51 case "connect":
52 err = connect(os.Args[2:], os.Stdin, os.Stdout)
53 case "status":
54 err = simple(os.Args[2:], http.MethodGet, "/api/v1/admin/status")
55 case "list":
56 err = simple(os.Args[2:], http.MethodGet, "/api/v1/admin/archives")
57 case "archive":
58 err = simple(os.Args[2:], http.MethodPost, "/api/v1/admin/archive")
59 case "sync":
60 err = simple(os.Args[2:], http.MethodPost, "/api/v1/admin/sync")
61 case "prune":
62 err = simple(os.Args[2:], http.MethodPost, "/api/v1/admin/prune")
63 case "example-config":
64 fmt.Print(config.Example())
65 case "version":
66 fmt.Println(server.Version)
67 default:
68 usage()
69 os.Exit(2)
70 }
71 if err != nil {
72 fmt.Fprintln(os.Stderr, "bluegit-backup:", err)
73 os.Exit(1)
74 }
75}
76
77func configPath(p string) string {
78 if p != "" {
79 return p
80 }
81 if v := os.Getenv("BLUEGIT_BACKUP_CONFIG"); v != "" {
82 return v
83 }
84 if _, err := os.Stat("bluegit-backup.yml"); err == nil {
85 return "bluegit-backup.yml"
86 }
87 return "/etc/bluegit-backup/config.yml"
88}
89
90func serve(args []string) error {
91 fs := flag.NewFlagSet("serve", flag.ExitOnError)
92 cfgPath := fs.String("config", "", "pad naar config.yml")
93 _ = fs.Parse(args)
94 cfg, err := config.Load(configPath(*cfgPath))
95 if err != nil {
96 return err
97 }
98 log := slog.New(slog.NewTextHandler(os.Stdout, nil))
99 srv, err := server.New(cfg, log)
100 if err != nil {
101 return err
102 }
103 ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
104 defer stop()
105 ln, err := net.Listen("tcp", cfg.Listen)
106 if err != nil {
107 return err
108 }
109 hs := &http.Server{Handler: srv.Handler(), ReadHeaderTimeout: 10 * time.Second}
110 go func() {
111 <-ctx.Done()
112 c, cancel := context.WithTimeout(context.Background(), 10*time.Second)
113 defer cancel()
114 _ = hs.Shutdown(c)
115 }()
116 srv.Run(ctx)
117 log.Info("bluegit-backup luistert", "addr", ln.Addr().String(), "public_url", cfg.PublicURL, "version", server.Version)
118 if err := hs.Serve(ln); err != nil && err != http.ErrServerClosed {
119 return err
120 }
121 return nil
122}
123
124type client struct {
125 base, token string
126}
127
128func newClient(cfgPath string) (*client, error) {
129 cfg, err := config.Load(configPath(cfgPath))
130 if err != nil {
131 return nil, err
132 }
133 tok, err := server.ReadAdminToken(cfg.DataDir)
134 if err != nil {
135 return nil, fmt.Errorf("admin.token lezen (draai als de gebruiker van de dienst of root): %w", err)
136 }
137 host, port, err := net.SplitHostPort(cfg.Listen)
138 if err != nil {
139 return nil, err
140 }
141 if host == "" || host == "0.0.0.0" || host == "::" {
142 host = "127.0.0.1"
143 }
144 return &client{base: "http://" + net.JoinHostPort(host, port), token: tok}, nil
145}
146
147func (c *client) do(method, p string, in any) (int, []byte, error) {
148 var body io.Reader
149 if in != nil {
150 b, _ := json.Marshal(in)
151 body = bytes.NewReader(b)
152 }
153 req, _ := http.NewRequest(method, c.base+p, body)
154 req.Header.Set("Authorization", "Bearer "+c.token)
155 req.Header.Set("Content-Type", "application/json")
156 resp, err := (&http.Client{Timeout: 30 * time.Minute}).Do(req)
157 if err != nil {
158 return 0, nil, err
159 }
160 defer resp.Body.Close()
161 b, _ := io.ReadAll(resp.Body)
162 return resp.StatusCode, b, nil
163}
164
165func simple(args []string, method, p string) error {
166 fs := flag.NewFlagSet("cmd", flag.ExitOnError)
167 cfgPath := fs.String("config", "", "pad naar config.yml")
168 _ = fs.Parse(args)
169 c, err := newClient(*cfgPath)
170 if err != nil {
171 return err
172 }
173 code, b, err := c.do(method, p, nil)
174 if err != nil {
175 return err
176 }
177 var pretty bytes.Buffer
178 if json.Indent(&pretty, b, "", " ") == nil {
179 b = pretty.Bytes()
180 }
181 fmt.Println(string(b))
182 if code >= 300 {
183 return fmt.Errorf("HTTP %d", code)
184 }
185 return nil
186}
187
188func connect(args []string, stdin io.Reader, stdout io.Writer) error {
189 fs := flag.NewFlagSet("connect", flag.ExitOnError)
190 cfgPath := fs.String("config", "", "pad naar config.yml")
191 u := fs.String("url", "", "adres van BlueGit")
192 key := fs.String("key", "", "Backupserver-Key (of BLUEGIT_BACKUP_KEY)")
193 onConflict := fs.String("on-conflict", "", "wipe of restore, zonder te vragen")
194 _ = fs.Parse(args)
195 if *key == "" {
196 *key = os.Getenv("BLUEGIT_BACKUP_KEY")
197 }
198 if *u == "" || *key == "" {
199 return fmt.Errorf("--url en --key (of BLUEGIT_BACKUP_KEY) zijn nodig")
200 }
201 c, err := newClient(*cfgPath)
202 if err != nil {
203 return err
204 }
205 req := server.ConnectRequest{URL: *u, Key: *key, OnConflict: *onConflict}
206 code, b, err := c.do(http.MethodPost, "/api/v1/admin/connect", req)
207 if err != nil {
208 return err
209 }
210 if code == http.StatusConflict {
211 var cf server.ConflictError
212 _ = json.Unmarshal(b, &cf)
213 fmt.Fprintf(stdout, "Deze backup server hoort bij een andere BlueGit (%s, instance %s) en heeft %d archief/archieven.\n", cf.PreviousURL, cf.PreviousInstance, cf.Archives)
214 fmt.Fprintln(stdout, "Een backup server kan maar aan één BlueGit gekoppeld zijn. Kies:")
215 fmt.Fprintln(stdout, " 1) Oude backups verwijderen en met de nieuwe instantie verbinden")
216 fmt.Fprintln(stdout, " 2) De nieuwe instantie terugzetten naar de gegevens in deze backup server (overschrijft alles daar)")
217 fmt.Fprint(stdout, "Keuze [1/2, leeg = afbreken]: ")
218 line, _ := bufio.NewReader(stdin).ReadString('\n')
219 switch strings.TrimSpace(line) {
220 case "1":
221 req.OnConflict = "wipe"
222 case "2":
223 req.OnConflict = "restore"
224 default:
225 return fmt.Errorf("afgebroken; er is niets veranderd")
226 }
227 code, b, err = c.do(http.MethodPost, "/api/v1/admin/connect", req)
228 if err != nil {
229 return err
230 }
231 }
232 fmt.Fprintln(stdout, strings.TrimSpace(string(b)))
233 if code >= 300 {
234 return fmt.Errorf("HTTP %d", code)
235 }
236 return nil
237}
docs/ASSUMPTIONS.md added +95 −0
@@ -0,0 +1,95 @@
1 # Aannames
2
3 Deze keuzes heb ik gemaakt waar de opdracht niets vastlegde. Wil je iets anders, dan is het per punt aan te passen.
4
5 ## Opzet
6
7 - **Go**, net als BlueGit. Eén binary zonder CGO. De enige externe dependency is `gopkg.in/yaml.v3`.
8 - **Geen webinterface op de backup server.** Je bedient hem met een configbestand en de CLI. Archieven bekijken en een rollback starten gebeurt in BlueGit, zoals gevraagd.
9 - De CLI praat met de draaiende server via `data_dir/admin.token` (een `bba_…`-token, 0600). Er komt geen tweede inlogsysteem.
10 - Eén backup server hoort bij precies één BlueGit. Dat staat in `data_dir/state.json` (0600). Daar staat ook de key in, want die is nodig om op te halen en om meldingen te controleren.
11
12 ## Key en authenticatie
13
14 - BlueGit maakt de Backupserver-Key (`bgbk_` + 64 hex) onder *Beheer → Backup* en toont hem één keer. BlueGit bewaart alleen `sha256(key)`.
15 - Er is maar één key tegelijk. Een nieuwe key maken maakt de oude ongeldig. Verwijderen ontkoppelt de server.
16 - **Backup server → BlueGit:** `Authorization: Bearer bgbk_…` op `/api/v1/backup/*`. Vijf foute pogingen per minuut per IP-adres geven `429`.
17 - **BlueGit → backup server:** BlueGit kent de key zelf niet meer, alleen de hash. Daarom ondertekent BlueGit met een afgeleid geheim, `sha256("bluegit-backup-sign:" + key)`, dat BlueGit bij het maken van de key bewaart. De handtekening is HMAC-SHA256 over `METHODE\nPAD\nTIJDSTEMPEL\nsha256(body)`, met hoogstens 5 minuten klokverschil. Zo kan iemand die het netwerk ziet geen rollback starten of meldingen vervalsen.
18 - De koppeling in BlueGit (`<state>/backup.json`) zit **niet** in de backup. Een rollback zet de koppeling dus niet terug naar een oude key.
19 - Je koppelt met `bluegit-backup connect --url … ` en de key uit `BLUEGIT_BACKUP_KEY` (of `--key`). De server meldt BlueGit daarna zijn `public_url`, zodat BlueGit weet waar de meldingen heen moeten.
20
21 ## Wat wordt geback-upt
22
23 - Alles wat BlueGit nodig heeft om identiek terug te komen:
24 - de database (`bluegit.db`) als consistente snapshot via `VACUUM INTO`
25 - `secret.key`
26 - de SSH-hostkeys
27 - logo's en avatars
28 - alle repositories
29 - releases en CI-artifacts
30 - **Niet:**
31 - `config.yml`. Dat bestand hoort bij de machine (paden, poorten, OAuth-geheimen) en zet je zelf terug.
32 - `storage_path`, caches, lockbestanden, werkmappen (`data/work`), tijdelijke bestanden, symlinks
33 - de backupkoppeling en het instance-id
34 - "Configuratie" in de opdracht lees ik als: alle instellingen die BlueGit in zijn database en state-map bewaart, plus de sleutels. `config.yml` valt daar niet onder.
35
36 ## Meldingen en synchroniseren
37
38 - BlueGit meldt een wijziging na elk muterend verzoek: elke niet-GET, behalve de backup-API zelf en `git-upload-pack` (clonen en fetchen). Daarnaast meldt BlueGit na elke push (HTTP en SSH) en na elk intern event, zoals CI of releases.
39 - Meldingen worden 2 seconden gebundeld en tot 4 keer opnieuw geprobeerd. Een melding bevat geen data, alleen "er is iets veranderd" (`POST /api/v1/notify`).
40 - Na een melding vraagt de backup server een manifest op: een lijst van paden met grootte en mtime, en voor de database een sha256. Hij haalt alleen nieuwe of gewijzigde bestanden op en verwijdert wat in BlueGit weg is.
41 - Tussen twee syncs na meldingen zit minstens `min_sync_interval` (10s). Meldingen die tijdens een sync binnenkomen, geven precies één vervolgsync.
42 - Mist de server een melding (omdat hij uit stond of het netwerk weg was), dan vangt de volledige controle elk `full_sync_interval` (1u) dat op, en ook een herstart.
43 - Een bestand dat tijdens het downloaden verandert (grootte klopt niet), wordt bij de volgende sync opnieuw opgehaald.
44
45 ## Gedoseerd downloaden
46
47 - Een token bucket begrenst de downloadsnelheid tot `rate_limit_kib` KiB/s (standaard 1024, dus 1 MiB/s), over alle downloads samen.
48 - Er is altijd maar één download tegelijk. BlueGit krijgt dus nooit meer dan één verzoek tegelijk van de backup server.
49 - De database-snapshot kost BlueGit eenmalig een `VACUUM INTO` per manifest. Bij een grote database is dat het zwaarste deel, maar het blokkeert schrijvers in WAL-modus niet.
50
51 ## Archieven
52
53 - Formaat: `tar.gz` (PAX), met de lopende kopie als inhoud (`state/…` en `data/…`). Je kunt een archief dus ook met de hand uitpakken.
54 - Naam: `bluegit-YYYYMMDD-HHMMSS.tar.gz` in UTC, met `-2`, `-3`, … als er in dezelfde seconde meer zijn.
55 - Het eerste archief komt binnen een minuut na de eerste geslaagde sync, daarna elk `archive_interval` (standaard 24u).
56 - Er wordt eerst naar een tijdelijk bestand geschreven en daarna hernoemd. Een half archief komt dus nooit in de lijst.
57 - **Opruimen:**
58 - Archieven ouder dan `retention_days` gaan weg.
59 - Is er minder dan `min_free_mb` vrij op de schijf van `data_dir`, dan gaat het oudste archief weg, net zo lang tot er genoeg vrij is.
60 - Het nieuwste archief blijft altijd staan, ook als het te oud is. Anders zou er geen backup meer zijn.
61 - Is er vóór een nieuw archief niet genoeg ruimte, dan mogen alle oude archieven weg om plaats te maken. Het nieuwe archief wordt dan het enige.
62
63 ## Rollback
64
65 - De beheerder start de rollback in BlueGit onder *Beheer → Backup*. Daar staat een grote rode waarschuwing: "Dit kan niet ongedaan worden gemaakt". Er moet een vinkje gezet worden en de archiefnaam overgetypt. De API vraagt `"confirm": "<archiefnaam>"`.
66 - Het verloop:
67 1. De backup server pakt het archief uit in `mirror.rollback`.
68 2. Hij zet dat op de plaats van zijn lopende kopie.
69 3. Hij stuurt alles als `tar.gz` naar BlueGit (`POST /api/v1/backup/restore`).
70 4. BlueGit zet de data klaar, weigert ondertussen alle wijzigingen (503) en herstart zichzelf (zelfde PID, `exec`).
71 5. Bij het opstarten wisselt BlueGit de bestanden om, nog voordat de database opengaat.
72 - Lukt het versturen niet, dan zet de backup server zijn oude kopie terug. Er gaat dan niets verloren.
73 - Archieven die nieuwer zijn dan het teruggezette archief blijven bewaard. Een rollback naar een te oud archief is zo nog te herstellen met een nieuwere rollback, maar alleen voor wat er in die archieven zat.
74 - Het upload-verkeer naar BlueGit bij een rollback is **niet** gedoseerd. BlueGit staat dan toch al stil, en een snelle terugzet is belangrijker.
75
76 ## Nieuwe instantie
77
78 - Een BlueGit wordt herkend aan zijn `instance_id` (`<state>/instance_id`). Een andere URL met hetzelfde instance-id is dezelfde instantie, bijvoorbeeld na een verhuizing.
79 - Koppel je een andere instantie, dan weigert de server (`409`) en moet je kiezen:
80 - **wissen**: de oude kopie en alle archieven gaan weg, en de nieuwe instantie wordt opnieuw opgehaald.
81 - **herstellen**: de lopende kopie (de stand van de laatste sync, nieuwer dan elk archief) wordt naar de nieuwe BlueGit gestuurd, net als bij een rollback. Daarna hoort de server bij de nieuwe instantie. De oude archieven blijven staan.
82 - `connect` vraagt de keuze in de terminal. Zonder keuze (lege invoer) gebeurt er niets. Zonder terminal gebruik je `--on-conflict wipe|restore`.
83 - De nieuwe BlueGit moet al draaien met een eigen `config.yml` en data-schijf. Het herstel vult alleen de inhoud.
84
85 ## Releases en tests
86
87 - "Dezelfde release-opties als BlueGit" betekent:
88 - een AUR-pakket `bluegit-backup` dat vanaf master wordt bijgewerkt
89 - een self-update van een geïnstalleerde server vanuit de pipeline (via een systemd-unit, net als BlueGit)
90 - binaries bij een tag
91 - Elke release-job hangt af van de job `integration`. Die bouwt een echte BlueGit uit `timfa/bluegit` en draait alle featuretests. Faalt er één, dan komt er geen release.
92 - **Releases vanaf master staan pas aan zodra `.release-enabled` in de repository staat.** Tim beslist wanneer, en zet ook de geheimen (AUR-sleutel, update-token). Tags zet Tim zelf.
93 - De integratietests bouwen BlueGit van de ref in `.bluegit-ref`. Tot de BlueGit-kant gemerged is, is dat `feature/backup-server`. Daarna wordt het `master`.
94 - De integratietests draaien nooit tegen een echte BlueGit-installatie. Elke test start een eigen BlueGit in een tijdelijke map, met de dev-login en zonder SSH of CI-runner.
95 - Het AUR-pakket haalt de broncode van `https://git.timfalken.com/timfa/bluegit-backup/-/archive/<commit>/…`. Daarom is de repository openbaar, net als `timfa/bluegit`.
@@ -0,0 +1,95 @@
1# 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- **Geen webinterface op de backup server.** Je bedient hem met een configbestand en de CLI. Archieven bekijken en een rollback starten gebeurt in BlueGit, zoals gevraagd.
9- De CLI praat met de draaiende server via `data_dir/admin.token` (een `bba_…`-token, 0600). Er komt geen tweede inlogsysteem.
10- Eén backup server hoort bij precies één BlueGit. Dat staat in `data_dir/state.json` (0600). Daar staat ook de key in, want die is nodig om op te halen en om meldingen te controleren.
11
12## Key en authenticatie
13
14- BlueGit maakt de Backupserver-Key (`bgbk_` + 64 hex) onder *Beheer → Backup* en toont hem één keer. BlueGit bewaart alleen `sha256(key)`.
15- Er is maar één key tegelijk. Een nieuwe key maken maakt de oude ongeldig. Verwijderen ontkoppelt de server.
16- **Backup server → BlueGit:** `Authorization: Bearer bgbk_…` op `/api/v1/backup/*`. Vijf foute pogingen per minuut per IP-adres geven `429`.
17- **BlueGit → backup server:** BlueGit kent de key zelf niet meer, alleen de hash. Daarom ondertekent BlueGit met een afgeleid geheim, `sha256("bluegit-backup-sign:" + key)`, dat BlueGit bij het maken van de key bewaart. De handtekening is HMAC-SHA256 over `METHODE\nPAD\nTIJDSTEMPEL\nsha256(body)`, met hoogstens 5 minuten klokverschil. Zo kan iemand die het netwerk ziet geen rollback starten of meldingen vervalsen.
18- De koppeling in BlueGit (`<state>/backup.json`) zit **niet** in de backup. Een rollback zet de koppeling dus niet terug naar een oude key.
19- Je koppelt met `bluegit-backup connect --url … ` en de key uit `BLUEGIT_BACKUP_KEY` (of `--key`). De server meldt BlueGit daarna zijn `public_url`, zodat BlueGit weet waar de meldingen heen moeten.
20
21## Wat wordt geback-upt
22
23- Alles wat BlueGit nodig heeft om identiek terug te komen:
24 - de database (`bluegit.db`) als consistente snapshot via `VACUUM INTO`
25 - `secret.key`
26 - de SSH-hostkeys
27 - logo's en avatars
28 - alle repositories
29 - releases en CI-artifacts
30- **Niet:**
31 - `config.yml`. Dat bestand hoort bij de machine (paden, poorten, OAuth-geheimen) en zet je zelf terug.
32 - `storage_path`, caches, lockbestanden, werkmappen (`data/work`), tijdelijke bestanden, symlinks
33 - de backupkoppeling en het instance-id
34- "Configuratie" in de opdracht lees ik als: alle instellingen die BlueGit in zijn database en state-map bewaart, plus de sleutels. `config.yml` valt daar niet onder.
35
36## Meldingen en synchroniseren
37
38- BlueGit meldt een wijziging na elk muterend verzoek: elke niet-GET, behalve de backup-API zelf en `git-upload-pack` (clonen en fetchen). Daarnaast meldt BlueGit na elke push (HTTP en SSH) en na elk intern event, zoals CI of releases.
39- Meldingen worden 2 seconden gebundeld en tot 4 keer opnieuw geprobeerd. Een melding bevat geen data, alleen "er is iets veranderd" (`POST /api/v1/notify`).
40- Na een melding vraagt de backup server een manifest op: een lijst van paden met grootte en mtime, en voor de database een sha256. Hij haalt alleen nieuwe of gewijzigde bestanden op en verwijdert wat in BlueGit weg is.
41- Tussen twee syncs na meldingen zit minstens `min_sync_interval` (10s). Meldingen die tijdens een sync binnenkomen, geven precies één vervolgsync.
42- Mist de server een melding (omdat hij uit stond of het netwerk weg was), dan vangt de volledige controle elk `full_sync_interval` (1u) dat op, en ook een herstart.
43- Een bestand dat tijdens het downloaden verandert (grootte klopt niet), wordt bij de volgende sync opnieuw opgehaald.
44
45## Gedoseerd downloaden
46
47- Een token bucket begrenst de downloadsnelheid tot `rate_limit_kib` KiB/s (standaard 1024, dus 1 MiB/s), over alle downloads samen.
48- Er is altijd maar één download tegelijk. BlueGit krijgt dus nooit meer dan één verzoek tegelijk van de backup server.
49- De database-snapshot kost BlueGit eenmalig een `VACUUM INTO` per manifest. Bij een grote database is dat het zwaarste deel, maar het blokkeert schrijvers in WAL-modus niet.
50
51## Archieven
52
53- Formaat: `tar.gz` (PAX), met de lopende kopie als inhoud (`state/…` en `data/…`). Je kunt een archief dus ook met de hand uitpakken.
54- Naam: `bluegit-YYYYMMDD-HHMMSS.tar.gz` in UTC, met `-2`, `-3`, … als er in dezelfde seconde meer zijn.
55- Het eerste archief komt binnen een minuut na de eerste geslaagde sync, daarna elk `archive_interval` (standaard 24u).
56- Er wordt eerst naar een tijdelijk bestand geschreven en daarna hernoemd. Een half archief komt dus nooit in de lijst.
57- **Opruimen:**
58 - Archieven ouder dan `retention_days` gaan weg.
59 - Is er minder dan `min_free_mb` vrij op de schijf van `data_dir`, dan gaat het oudste archief weg, net zo lang tot er genoeg vrij is.
60 - Het nieuwste archief blijft altijd staan, ook als het te oud is. Anders zou er geen backup meer zijn.
61 - Is er vóór een nieuw archief niet genoeg ruimte, dan mogen alle oude archieven weg om plaats te maken. Het nieuwe archief wordt dan het enige.
62
63## Rollback
64
65- De beheerder start de rollback in BlueGit onder *Beheer → Backup*. Daar staat een grote rode waarschuwing: "Dit kan niet ongedaan worden gemaakt". Er moet een vinkje gezet worden en de archiefnaam overgetypt. De API vraagt `"confirm": "<archiefnaam>"`.
66- Het verloop:
67 1. De backup server pakt het archief uit in `mirror.rollback`.
68 2. Hij zet dat op de plaats van zijn lopende kopie.
69 3. Hij stuurt alles als `tar.gz` naar BlueGit (`POST /api/v1/backup/restore`).
70 4. BlueGit zet de data klaar, weigert ondertussen alle wijzigingen (503) en herstart zichzelf (zelfde PID, `exec`).
71 5. Bij het opstarten wisselt BlueGit de bestanden om, nog voordat de database opengaat.
72- Lukt het versturen niet, dan zet de backup server zijn oude kopie terug. Er gaat dan niets verloren.
73- Archieven die nieuwer zijn dan het teruggezette archief blijven bewaard. Een rollback naar een te oud archief is zo nog te herstellen met een nieuwere rollback, maar alleen voor wat er in die archieven zat.
74- Het upload-verkeer naar BlueGit bij een rollback is **niet** gedoseerd. BlueGit staat dan toch al stil, en een snelle terugzet is belangrijker.
75
76## Nieuwe instantie
77
78- Een BlueGit wordt herkend aan zijn `instance_id` (`<state>/instance_id`). Een andere URL met hetzelfde instance-id is dezelfde instantie, bijvoorbeeld na een verhuizing.
79- Koppel je een andere instantie, dan weigert de server (`409`) en moet je kiezen:
80 - **wissen**: de oude kopie en alle archieven gaan weg, en de nieuwe instantie wordt opnieuw opgehaald.
81 - **herstellen**: de lopende kopie (de stand van de laatste sync, nieuwer dan elk archief) wordt naar de nieuwe BlueGit gestuurd, net als bij een rollback. Daarna hoort de server bij de nieuwe instantie. De oude archieven blijven staan.
82- `connect` vraagt de keuze in de terminal. Zonder keuze (lege invoer) gebeurt er niets. Zonder terminal gebruik je `--on-conflict wipe|restore`.
83- De nieuwe BlueGit moet al draaien met een eigen `config.yml` en data-schijf. Het herstel vult alleen de inhoud.
84
85## Releases en tests
86
87- "Dezelfde release-opties als BlueGit" betekent:
88 - een AUR-pakket `bluegit-backup` dat vanaf master wordt bijgewerkt
89 - een self-update van een geïnstalleerde server vanuit de pipeline (via een systemd-unit, net als BlueGit)
90 - binaries bij een tag
91- Elke release-job hangt af van de job `integration`. Die bouwt een echte BlueGit uit `timfa/bluegit` en draait alle featuretests. Faalt er één, dan komt er geen release.
92- **Releases vanaf master staan pas aan zodra `.release-enabled` in de repository staat.** Tim beslist wanneer, en zet ook de geheimen (AUR-sleutel, update-token). Tags zet Tim zelf.
93- De integratietests bouwen BlueGit van de ref in `.bluegit-ref`. Tot de BlueGit-kant gemerged is, is dat `feature/backup-server`. Daarna wordt het `master`.
94- De integratietests draaien nooit tegen een echte BlueGit-installatie. Elke test start een eigen BlueGit in een tijdelijke map, met de dev-login en zonder SSH of CI-runner.
95- Het AUR-pakket haalt de broncode van `https://git.timfalken.com/timfa/bluegit-backup/-/archive/<commit>/…`. Daarom is de repository openbaar, net als `timfa/bluegit`.
docs/BACKUP-PROTOCOL.md added +69 −0
@@ -0,0 +1,69 @@
1 # Backup server (bluegit-backup)
2
3 Een losse backup server ([timfa/bluegit-backup](https://git.timfalken.com/timfa/bluegit-backup)) houdt een kopie bij van alle gegevens en configuratie van één BlueGit. Hij haalt ze langzaam op, krijgt na elke wijziging een melding, maakt periodiek een gecomprimeerd archief, en kan BlueGit naar zo'n archief terugzetten.
4
5 ## In BlueGit
6
7 **Beheer > Backup** (`/admin/backup`, alleen installatiebeheerders):
8
9 - **Backupserver-Key** maken (één keer getoond), vervangen of intrekken. Er is altijd hoogstens één key; een nieuwe key maakt de oude ongeldig en vergeet de gekoppelde server.
10 - **Gekoppelde backup server**: adres, laatste contact, archiefinterval en bewaartermijn.
11 - **Backup-archieven** als lijst, met per archief een rollback. Die staat achter een grote rode waarschuwing, een vinkje ("ik begrijp dat dit niet terug te draaien is"), het intypen van de archiefnaam en een bevestigingsdialoog.
12
13 Dezelfde acties via de API (token van een beheerder, scope `api`/`admin`):
14
15 | | |
16 |---|---|
17 | `GET /api/v1/admin/backup` | status, gekoppelde server, archieven |
18 | `POST /api/v1/admin/backup/key` | nieuwe key, `{"key": "bgbk_…"}` (eenmalig) |
19 | `DELETE /api/v1/admin/backup/key` | key intrekken |
20 | `POST /api/v1/admin/backup/rollback` | `{"archive": "naam", "confirm": "naam"}` |
21
22 ## Protocol
23
24 **De backup server praat met BlueGit** met de key als bearer-token (`Authorization: Bearer bgbk_…`):
25
26 | | |
27 |---|---|
28 | `GET /api/v1/backup/info` | `instance_id`, `base_url`, gekoppelde server |
29 | `POST /api/v1/backup/connect` | `{"server_url", "server_id"}`: waar BlueGit meldingen heen stuurt |
30 | `GET /api/v1/backup/manifest` | alle bestanden: pad, grootte, mtime, mode; de database ook met sha256 |
31 | `GET /api/v1/backup/file?path=…` | één bestand |
32 | `POST /api/v1/backup/restore` | tar.gz met logische paden; BlueGit pakt uit en herstart (202) |
33
34 Vijf mislukte key-pogingen per minuut per IP geven daarna `429`.
35
36 **BlueGit praat met de backup server** met een HMAC-handtekening. Het geheim is `sha256("bluegit-backup-sign:" + key)` als hex; beide kanten leiden het af uit de key. Koppen:
37
38 ```text
39 X-BlueGit-Instance: <instance_id>
40 X-BlueGit-Timestamp: <unix-seconden> (hoogstens 5 minuten verschil)
41 X-BlueGit-Signature: hex(HMAC-SHA256(geheim, METHOD "\n" PAD "\n" TS "\n" sha256hex(body)))
42 ```
43
44 | | |
45 |---|---|
46 | `POST /api/v1/notify` | er is iets veranderd |
47 | `GET /api/v1/archives` | `{"archives": [{name, created_at, size}]}` |
48 | `GET /api/v1/status` | interval, bewaartermijn, stand van de laatste rollback |
49 | `POST /api/v1/rollback` | `{"archive": "naam"}` |
50
51 **Meldingen.** Na elk schrijvend HTTP-verzoek (behalve de backup-API zelf en `git-upload-pack`), na elke push (ook SSH) en bij elke CI-gebeurtenis meldt BlueGit een wijziging. Meldingen worden 2 seconden gebundeld en bij een fout tot vier keer opnieuw geprobeerd. De backup server haalt daarnaast periodiek alles op, dus een gemiste melding kost alleen vertraging. Het adres van de backup server mag een privéadres zijn (de beheerder koppelt hem met een eigen key); de SSRF-regels van webhooks gelden hier niet.
52
53 ## Wat er in een backup zit
54
55 ```text
56 state/bluegit.db consistente kopie (VACUUM INTO), niet het live bestand
57 state/secret.key nodig voor de versleutelde geheimen in de database
58 state/ssh/… SSH-hostkey
59 state/logos/…, state/avatars/…
60 data/repos/… bare repositories
61 data/releases/… release-assets (zonder .incoming)
62 data/artifacts/… CI-artifacts
63 ```
64
65 Niet mee: `config.yml`, `storage_path`, `cache.json`, `backup.json` en `instance_id` (horen bij deze installatie), `data/work`, `*.lock` en symlinks. De koppeling staat in `<state>/backup.json` (0600, alleen de hash van de key) en niet in de database, zodat een rollback naar een oud archief de koppeling niet terugdraait.
66
67 ## Terugzetten
68
69 `POST /api/v1/backup/restore` pakt het archief uit in `<state>/.restore` en `<datadisk>/.restore`; de live gegevens blijven tot dan onaangeroerd. Een ongeldig archief (pad buiten de lijst hierboven, `..`, symlink, geen database of `secret.key`) wordt geweigerd en opgeruimd. Daarna weigert BlueGit schrijvende verzoeken (503), sluit af zoals bij een gewone stop en start zichzelf opnieuw met `exec` (zelfde PID, dus systemd ziet geen crash). Bij de start, vóór de database opengaat, worden de mappen omgewisseld: alles uit de lijst hierboven wordt vervangen, ook wat niet in het archief zat. Een BlueGit zonder datadisk kan geen archief met repositories aannemen; kies eerst de datadisk in `/setup`.
@@ -0,0 +1,69 @@
1# Backup server (bluegit-backup)
2
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
5## In BlueGit
6
7**Beheer > Backup** (`/admin/backup`, alleen installatiebeheerders):
8
9- **Backupserver-Key** maken (één keer getoond), vervangen of intrekken. Er is altijd hoogstens één key; een nieuwe key maakt de oude ongeldig en vergeet de gekoppelde server.
10- **Gekoppelde backup server**: adres, laatste contact, archiefinterval en bewaartermijn.
11- **Backup-archieven** als lijst, met per archief een rollback. Die staat achter een grote rode waarschuwing, een vinkje ("ik begrijp dat dit niet terug te draaien is"), het intypen van de archiefnaam en een bevestigingsdialoog.
12
13Dezelfde acties via de API (token van een beheerder, scope `api`/`admin`):
14
15| | |
16|---|---|
17| `GET /api/v1/admin/backup` | status, gekoppelde server, archieven |
18| `POST /api/v1/admin/backup/key` | nieuwe key, `{"key": "bgbk_…"}` (eenmalig) |
19| `DELETE /api/v1/admin/backup/key` | key intrekken |
20| `POST /api/v1/admin/backup/rollback` | `{"archive": "naam", "confirm": "naam"}` |
21
22## Protocol
23
24**De backup server praat met BlueGit** met de key als bearer-token (`Authorization: Bearer bgbk_…`):
25
26| | |
27|---|---|
28| `GET /api/v1/backup/info` | `instance_id`, `base_url`, gekoppelde server |
29| `POST /api/v1/backup/connect` | `{"server_url", "server_id"}`: waar BlueGit meldingen heen stuurt |
30| `GET /api/v1/backup/manifest` | alle bestanden: pad, grootte, mtime, mode; de database ook met sha256 |
31| `GET /api/v1/backup/file?path=…` | één bestand |
32| `POST /api/v1/backup/restore` | tar.gz met logische paden; BlueGit pakt uit en herstart (202) |
33
34Vijf mislukte key-pogingen per minuut per IP geven daarna `429`.
35
36**BlueGit praat met de backup server** met een HMAC-handtekening. Het geheim is `sha256("bluegit-backup-sign:" + key)` als hex; beide kanten leiden het af uit de key. Koppen:
37
38```text
39X-BlueGit-Instance: <instance_id>
40X-BlueGit-Timestamp: <unix-seconden> (hoogstens 5 minuten verschil)
41X-BlueGit-Signature: hex(HMAC-SHA256(geheim, METHOD "\n" PAD "\n" TS "\n" sha256hex(body)))
42```
43
44| | |
45|---|---|
46| `POST /api/v1/notify` | er is iets veranderd |
47| `GET /api/v1/archives` | `{"archives": [{name, created_at, size}]}` |
48| `GET /api/v1/status` | interval, bewaartermijn, stand van de laatste rollback |
49| `POST /api/v1/rollback` | `{"archive": "naam"}` |
50
51**Meldingen.** Na elk schrijvend HTTP-verzoek (behalve de backup-API zelf en `git-upload-pack`), na elke push (ook SSH) en bij elke CI-gebeurtenis meldt BlueGit een wijziging. Meldingen worden 2 seconden gebundeld en bij een fout tot vier keer opnieuw geprobeerd. De backup server haalt daarnaast periodiek alles op, dus een gemiste melding kost alleen vertraging. Het adres van de backup server mag een privéadres zijn (de beheerder koppelt hem met een eigen key); de SSRF-regels van webhooks gelden hier niet.
52
53## Wat er in een backup zit
54
55```text
56state/bluegit.db consistente kopie (VACUUM INTO), niet het live bestand
57state/secret.key nodig voor de versleutelde geheimen in de database
58state/ssh/… SSH-hostkey
59state/logos/…, state/avatars/…
60data/repos/… bare repositories
61data/releases/… release-assets (zonder .incoming)
62data/artifacts/… CI-artifacts
63```
64
65Niet mee: `config.yml`, `storage_path`, `cache.json`, `backup.json` en `instance_id` (horen bij deze installatie), `data/work`, `*.lock` en symlinks. De koppeling staat in `<state>/backup.json` (0600, alleen de hash van de key) en niet in de database, zodat een rollback naar een oud archief de koppeling niet terugdraait.
66
67## Terugzetten
68
69`POST /api/v1/backup/restore` pakt het archief uit in `<state>/.restore` en `<datadisk>/.restore`; de live gegevens blijven tot dan onaangeroerd. Een ongeldig archief (pad buiten de lijst hierboven, `..`, symlink, geen database of `secret.key`) wordt geweigerd en opgeruimd. Daarna weigert BlueGit schrijvende verzoeken (503), sluit af zoals bij een gewone stop en start zichzelf opnieuw met `exec` (zelfde PID, dus systemd ziet geen crash). Bij de start, vóór de database opengaat, worden de mappen omgewisseld: alles uit de lijst hierboven wordt vervangen, ook wat niet in het archief zat. Een BlueGit zonder datadisk kan geen archief met repositories aannemen; kies eerst de datadisk in `/setup`.
docs/BACKUP-SERVER.md added +129 −0
@@ -0,0 +1,129 @@
1 # bluegit-backup
2
3 Een losse backup server voor één [BlueGit](https://git.timfalken.com/timfa/bluegit)-instantie.
4
5 - Koppelt met een **Backupserver-Key** die een BlueGit-beheerder in BlueGit maakt (*Beheer → Backup*).
6 - Haalt alle data en configuratie van BlueGit binnen: database, sleutels, SSH-hostkeys, logo's, avatars, repositories, releases en artifacts. Dat gaat **gedoseerd** (`rate_limit_kib`), zodat BlueGit er geen last van heeft.
7 - BlueGit **meldt elke wijziging**. De backup server haalt dan alleen op wat veranderd is. Daarnaast loopt hij elk `full_sync_interval` alles na.
8 - Elk `archive_interval` (standaard dagelijks) gaat de hele kopie gecomprimeerd in een archief (`tar.gz`).
9 - Archieven ouder dan `retention_days` gaan weg. Is de schijf vol (minder dan `min_free_mb` vrij), dan gaat het oudste archief weg. Het nieuwste archief blijft altijd staan.
10 - In BlueGit ziet de beheerder de archieven en kan hij een **rollback** starten, met een grote waarschuwing dat die niet terug te draaien is. De backup server pakt het archief uit, vervangt zijn kopie en stuurt alles naar BlueGit. BlueGit zet de data terug en herstart.
11 - Eén backup server hoort bij één BlueGit. Koppel je een andere instantie, dan kies je: **oude backups wissen** of **de nieuwe instantie herstellen** met de backupdata.
12
13 Het protocol staat in [docs/PROTOCOL.md](docs/PROTOCOL.md). De aannames staan in [docs/ASSUMPTIONS.md](docs/ASSUMPTIONS.md).
14
15 ## Installeren
16
17 ### Arch Linux (AUR)
18
19 ```sh
20 yay -S bluegit-backup
21 ```
22
23 Het pakket zet de binary in `/usr/bin/bluegit-backup`, de config in `/etc/bluegit-backup/config.yml`, de data in `/var/lib/bluegit-backup` en een systemd-unit `bluegit-backup.service` (gebruiker `bluegit-backup`).
24
25 ### Binary
26
27 Bij een release staan `bluegit-backup-linux-amd64`, `bluegit-backup-linux-arm64` en `SHA256SUMS`. Zelf bouwen:
28
29 ```sh
30 go build -o bluegit-backup ./cmd/bluegit-backup
31 ./bluegit-backup example-config > config.yml
32 ./bluegit-backup serve --config config.yml
33 ```
34
35 ## Koppelen
36
37 1. Zet in `config.yml` `public_url` op het adres waarop BlueGit deze server bereikt.
38 2. Start de server: `systemctl enable --now bluegit-backup`.
39 3. Maak in BlueGit onder *Beheer → Backup* een Backupserver-Key. Die wordt één keer getoond.
40 4. Koppel:
41
42 ```sh
43 BLUEGIT_BACKUP_KEY=bgbk_… bluegit-backup connect --url https://git.example.com
44 ```
45
46 Had deze server al backups van een andere BlueGit, dan vraagt `connect`:
47
48 ```
49 1) oude backups wissen en opnieuw beginnen
50 2) de nieuwe BlueGit herstellen met de laatste backupdata
51 ```
52
53 Zonder terminal kies je met `--on-conflict wipe` of `--on-conflict restore`.
54
55 Daarna haalt de server meteen een volledige kopie op en maakt hij een eerste archief.
56
57 ## Bedienen
58
59 ```sh
60 bluegit-backup status # koppeling, laatste sync, laatste archief
61 bluegit-backup list # archieven
62 bluegit-backup sync # nu synchroniseren
63 bluegit-backup archive # nu een archief maken
64 bluegit-backup prune # bewaarregels nu toepassen
65 ```
66
67 Deze commando's praten met de draaiende server via `data_dir/admin.token` en moeten dus draaien als een gebruiker die dat bestand kan lezen (`sudo -u bluegit-backup …`).
68
69 Een rollback start je in BlueGit, niet hier.
70
71 ## Configuratie
72
73 | Sleutel | Standaard | Betekenis |
74 |---|---|---|
75 | `listen` | `0.0.0.0:8790` | Adres van de HTTP-server |
76 | `public_url` | (leeg) | Adres waarop BlueGit deze server bereikt |
77 | `data_dir` | `/var/lib/bluegit-backup` | Kopie, archieven en koppeling |
78 | `archive_interval` | `24h` | Hoe vaak een archief |
79 | `retention_days` | `30` | Archieven ouder dan dit weg (0 = nooit) |
80 | `min_free_mb` | `1024` | Minder vrij: oudste archief weg |
81 | `rate_limit_kib` | `1024` | Downloadsnelheid in KiB/s (0 = onbeperkt) |
82 | `full_sync_interval` | `1h` | Ook zonder melding alles nalopen |
83 | `min_sync_interval` | `10s` | Minimale tijd tussen syncs na meldingen |
84
85 In `data_dir`:
86
87 - `mirror/` is de lopende kopie.
88 - `archives/` bevat `bluegit-YYYYMMDD-HHMMSS.tar.gz` (UTC).
89 - `state.json` (0600) is de koppeling met de key.
90 - `admin.token` (0600) is voor de CLI.
91
92 ## Releases
93
94 Dezelfde opties als BlueGit: een AUR-pakket (`bluegit-backup`), een self-update van een geïnstalleerde server vanuit de pipeline en binaries bij een tag. Zie `blue-ci-cd.yml`.
95
96 - Elke release-job hangt af van de job `integration`. Die bouwt een echte BlueGit (`scripts/build-bluegit.sh`, ref in `.bluegit-ref`), start hem, configureert hem en test daarmee elke feature. Faalt er één test, dan is er geen release.
97 - Releases vanaf master staan pas aan zodra het bestand `.release-enabled` in de repository staat. De geheimen staan in de kop van `blue-ci-cd.yml`.
98 - Een release bij een tag (`v*`) publiceert de binaries bij een bestaande tag.
99
100 Self-update: zet `BLUEGIT_BACKUP_UPDATE_TOKEN` in `/etc/bluegit-backup/env` op de server. Zet in de pipeline hetzelfde token plus `BLUEGIT_BACKUP_UPDATE_URL`. De server bouwt dan `bluegit-backup` op het commit van master via `bluegit-backup-update.service`.
101
102 ## Tests
103
104 ```sh
105 go test ./... # unit-tests
106 ./scripts/build-bluegit.sh # bouwt .bluegit-bin/bluegit
107 BLUEGIT_BIN=$PWD/.bluegit-bin/bluegit go test -tags integration -v ./integration/
108 ```
109
110 De integratietests starten per test een echte BlueGit in een tijdelijke map (dev-login, geen SSH, geen CI-runner). Ze maken een beheerderstoken en daarmee repositories, issues en een Backupserver-Key. Daarna testen ze tegen die BlueGit:
111
112 | Test | Feature |
113 |---|---|
114 | `TestKeyGenerationAndConnect` | Key maken in BlueGit, koppelen, verkeerde key geweigerd |
115 | `TestFullSyncCopiesAllData` | Alle data en configuratie komt binnen, en de kopie klopt |
116 | `TestNotificationTriggersSync` | Een wijziging in BlueGit geeft een melding en daarna een sync |
117 | `TestDownloadIsThrottled` | Downloaden blijft onder `rate_limit_kib` |
118 | `TestArchiveIntervalAndListInBlueGit` | Archief per interval, lijst zichtbaar in BlueGit |
119 | `TestRetentionAndDiskFull` | Weggooien op leeftijd en bij volle schijf |
120 | `TestRollbackFromBlueGit` | Rollback vanuit BlueGit (met bevestiging), BlueGit staat daarna terug |
121 | `TestNewInstanceWipe` | Nieuwe instantie, keuze wissen |
122 | `TestNewInstanceRestore` | Nieuwe instantie, keuze herstellen |
123 | `TestCLIConnectAsksOnConflict` | `connect` vraagt de keuze |
124
125 De BlueGit-kant (key, meldingen, beheerpagina, rollback) zit in BlueGit op `feature/backup-server`. Zolang die niet gemerged is, bouwt de pipeline BlueGit van die branch (`.bluegit-ref`). Zet `.bluegit-ref` op `master` zodra hij gemerged is.
126
127 ## Licentie
128
129 Zie [LICENSE](LICENSE).
@@ -0,0 +1,129 @@
1# bluegit-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.
12
13Het protocol staat in [docs/PROTOCOL.md](docs/PROTOCOL.md). De aannames staan in [docs/ASSUMPTIONS.md](docs/ASSUMPTIONS.md).
14
15## Installeren
16
17### Arch Linux (AUR)
18
19```sh
20yay -S bluegit-backup
21```
22
23Het pakket zet de binary in `/usr/bin/bluegit-backup`, de config in `/etc/bluegit-backup/config.yml`, de data in `/var/lib/bluegit-backup` en een systemd-unit `bluegit-backup.service` (gebruiker `bluegit-backup`).
24
25### Binary
26
27Bij een release staan `bluegit-backup-linux-amd64`, `bluegit-backup-linux-arm64` en `SHA256SUMS`. Zelf bouwen:
28
29```sh
30go build -o bluegit-backup ./cmd/bluegit-backup
31./bluegit-backup example-config > config.yml
32./bluegit-backup serve --config config.yml
33```
34
35## Koppelen
36
371. Zet in `config.yml` `public_url` op het adres waarop BlueGit deze server bereikt.
382. Start de server: `systemctl enable --now bluegit-backup`.
393. Maak in BlueGit onder *Beheer → Backup* een Backupserver-Key. Die wordt één keer getoond.
404. Koppel:
41
42 ```sh
43 BLUEGIT_BACKUP_KEY=bgbk_… bluegit-backup connect --url https://git.example.com
44 ```
45
46 Had deze server al backups van een andere BlueGit, dan vraagt `connect`:
47
48 ```
49 1) oude backups wissen en opnieuw beginnen
50 2) de nieuwe BlueGit herstellen met de laatste backupdata
51 ```
52
53 Zonder terminal kies je met `--on-conflict wipe` of `--on-conflict restore`.
54
55Daarna haalt de server meteen een volledige kopie op en maakt hij een eerste archief.
56
57## Bedienen
58
59```sh
60bluegit-backup status # koppeling, laatste sync, laatste archief
61bluegit-backup list # archieven
62bluegit-backup sync # nu synchroniseren
63bluegit-backup archive # nu een archief maken
64bluegit-backup prune # bewaarregels nu toepassen
65```
66
67Deze commando's praten met de draaiende server via `data_dir/admin.token` en moeten dus draaien als een gebruiker die dat bestand kan lezen (`sudo -u bluegit-backup …`).
68
69Een rollback start je in BlueGit, niet hier.
70
71## Configuratie
72
73| Sleutel | Standaard | Betekenis |
74|---|---|---|
75| `listen` | `0.0.0.0:8790` | Adres van de HTTP-server |
76| `public_url` | (leeg) | Adres waarop BlueGit deze server bereikt |
77| `data_dir` | `/var/lib/bluegit-backup` | Kopie, archieven en koppeling |
78| `archive_interval` | `24h` | Hoe vaak een archief |
79| `retention_days` | `30` | Archieven ouder dan dit weg (0 = nooit) |
80| `min_free_mb` | `1024` | Minder vrij: oudste archief weg |
81| `rate_limit_kib` | `1024` | Downloadsnelheid in KiB/s (0 = onbeperkt) |
82| `full_sync_interval` | `1h` | Ook zonder melding alles nalopen |
83| `min_sync_interval` | `10s` | Minimale tijd tussen syncs na meldingen |
84
85In `data_dir`:
86
87- `mirror/` is de lopende kopie.
88- `archives/` bevat `bluegit-YYYYMMDD-HHMMSS.tar.gz` (UTC).
89- `state.json` (0600) is de koppeling met de key.
90- `admin.token` (0600) is voor de CLI.
91
92## Releases
93
94Dezelfde opties als BlueGit: een AUR-pakket (`bluegit-backup`), een self-update van een geïnstalleerde server vanuit de pipeline en binaries bij een tag. Zie `blue-ci-cd.yml`.
95
96- Elke release-job hangt af van de job `integration`. Die bouwt een echte BlueGit (`scripts/build-bluegit.sh`, ref in `.bluegit-ref`), start hem, configureert hem en test daarmee elke feature. Faalt er één test, dan is er geen release.
97- Releases vanaf master staan pas aan zodra het bestand `.release-enabled` in de repository staat. De geheimen staan in de kop van `blue-ci-cd.yml`.
98- Een release bij een tag (`v*`) publiceert de binaries bij een bestaande tag.
99
100Self-update: zet `BLUEGIT_BACKUP_UPDATE_TOKEN` in `/etc/bluegit-backup/env` op de server. Zet in de pipeline hetzelfde token plus `BLUEGIT_BACKUP_UPDATE_URL`. De server bouwt dan `bluegit-backup` op het commit van master via `bluegit-backup-update.service`.
101
102## Tests
103
104```sh
105go test ./... # unit-tests
106./scripts/build-bluegit.sh # bouwt .bluegit-bin/bluegit
107BLUEGIT_BIN=$PWD/.bluegit-bin/bluegit go test -tags integration -v ./integration/
108```
109
110De integratietests starten per test een echte BlueGit in een tijdelijke map (dev-login, geen SSH, geen CI-runner). Ze maken een beheerderstoken en daarmee repositories, issues en een Backupserver-Key. Daarna testen ze tegen die BlueGit:
111
112| Test | Feature |
113|---|---|
114| `TestKeyGenerationAndConnect` | Key maken in BlueGit, koppelen, verkeerde key geweigerd |
115| `TestFullSyncCopiesAllData` | Alle data en configuratie komt binnen, en de kopie klopt |
116| `TestNotificationTriggersSync` | Een wijziging in BlueGit geeft een melding en daarna een sync |
117| `TestDownloadIsThrottled` | Downloaden blijft onder `rate_limit_kib` |
118| `TestArchiveIntervalAndListInBlueGit` | Archief per interval, lijst zichtbaar in BlueGit |
119| `TestRetentionAndDiskFull` | Weggooien op leeftijd en bij volle schijf |
120| `TestRollbackFromBlueGit` | Rollback vanuit BlueGit (met bevestiging), BlueGit staat daarna terug |
121| `TestNewInstanceWipe` | Nieuwe instantie, keuze wissen |
122| `TestNewInstanceRestore` | Nieuwe instantie, keuze herstellen |
123| `TestCLIConnectAsksOnConflict` | `connect` vraagt de keuze |
124
125De BlueGit-kant (key, meldingen, beheerpagina, rollback) zit in BlueGit op `feature/backup-server`. Zolang die niet gemerged is, bouwt de pipeline BlueGit van die branch (`.bluegit-ref`). Zet `.bluegit-ref` op `master` zodra hij gemerged is.
126
127## Licentie
128
129Zie [LICENSE](LICENSE).
internal/backupserver/archive/archive.go added +340 −0
@@ -0,0 +1,340 @@
1 // Package archive maakt, bewaart, ruimt op en pakt archieven uit.
2 //
3 // Een archief is een tar.gz (PAX, mtimes in milliseconden) van de kopie met
4 // logische paden (state/…, data/…), precies wat BlueGit bij een restore
5 // aanneemt. Naam: bluegit-YYYYMMDD-HHMMSS.tar.gz in UTC.
6 package archive
7
8 import (
9 "archive/tar"
10 "compress/gzip"
11 "errors"
12 "fmt"
13 "io"
14 "io/fs"
15 "os"
16 "path/filepath"
17 "regexp"
18 "sort"
19 "strings"
20 "time"
21
22 "git.timfalken.com/timfa/bluegit-backup/internal/protocol"
23 )
24
25 var nameRE = regexp.MustCompile(`^bluegit-\d{8}-\d{6}(-\d{1,3})?\.tar\.gz$`)
26
27 // ValidName zegt of name een archiefnaam is (geen pad, geen ..).
28 func ValidName(name string) bool { return nameRE.MatchString(name) }
29
30 // Archive is één archief op schijf.
31 type Archive struct {
32 Name string `json:"name"`
33 CreatedAt time.Time `json:"created_at"`
34 Size int64 `json:"size"`
35 }
36
37 // Store is de map met archieven.
38 type Store struct {
39 Dir string
40 // Free geeft de vrije bytes op het bestandssysteem van Dir. Tests
41 // zetten een nep-versie; nil gebruikt statfs.
42 Free func(dir string) (uint64, error)
43 }
44
45 func (s *Store) free() (uint64, error) {
46 if s.Free != nil {
47 return s.Free(s.Dir)
48 }
49 return FreeBytes(s.Dir)
50 }
51
52 // List geeft de archieven, nieuwste eerst.
53 func (s *Store) List() ([]Archive, error) {
54 ents, err := os.ReadDir(s.Dir)
55 if errors.Is(err, os.ErrNotExist) {
56 return []Archive{}, nil
57 }
58 if err != nil {
59 return nil, err
60 }
61 out := []Archive{}
62 for _, e := range ents {
63 if e.IsDir() || !ValidName(e.Name()) {
64 continue
65 }
66 fi, err := e.Info()
67 if err != nil {
68 continue
69 }
70 out = append(out, Archive{Name: e.Name(), CreatedAt: createdAt(e.Name(), fi), Size: fi.Size()})
71 }
72 sort.Slice(out, func(i, j int) bool {
73 if out[i].CreatedAt.Equal(out[j].CreatedAt) {
74 return out[i].Name > out[j].Name
75 }
76 return out[i].CreatedAt.After(out[j].CreatedAt)
77 })
78 return out, nil
79 }
80
81 // createdAt neemt de mtime: die is gelijk aan de naam, maar tests en een
82 // beheerder kunnen hem verzetten om de bewaartermijn te testen.
83 func createdAt(name string, fi fs.FileInfo) time.Time {
84 return fi.ModTime().UTC()
85 }
86
87 // Path geeft het pad van een bestaand archief.
88 func (s *Store) Path(name string) (string, error) {
89 if !ValidName(name) {
90 return "", errors.New("ongeldige archiefnaam")
91 }
92 p := filepath.Join(s.Dir, name)
93 if _, err := os.Stat(p); err != nil {
94 return "", fmt.Errorf("archief %s bestaat niet", name)
95 }
96 return p, nil
97 }
98
99 // DeleteAll verwijdert alle archieven.
100 func (s *Store) DeleteAll() error {
101 list, err := s.List()
102 if err != nil {
103 return err
104 }
105 for _, a := range list {
106 if err := os.Remove(filepath.Join(s.Dir, a.Name)); err != nil {
107 return err
108 }
109 }
110 return nil
111 }
112
113 // Create schrijft een nieuw archief van mirrorDir. needBytes is een
114 // schatting van de grootte; is er te weinig ruimte, dan gaan eerst oude
115 // archieven weg (het nieuwste blijft).
116 func (s *Store) Create(mirrorDir string, now time.Time, needBytes int64, minFree uint64) (Archive, []string, error) {
117 if err := os.MkdirAll(s.Dir, 0o750); err != nil {
118 return Archive{}, nil, err
119 }
120 var removed []string
121 for {
122 free, err := s.free()
123 if err != nil || free >= uint64(needBytes)+minFree {
124 break
125 }
126 // Het nieuwe archief wordt het nieuwste; daarvoor mag ook het
127 // laatste oude weg. De draaiende kopie blijft altijd staan.
128 name, ok, err := s.removeOldest(0)
129 if err != nil {
130 return Archive{}, removed, err
131 }
132 if !ok {
133 return Archive{}, removed, fmt.Errorf("te weinig schijfruimte voor een archief (%d MB vrij, %d MB nodig)", free>>20, (uint64(needBytes)+minFree)>>20)
134 }
135 removed = append(removed, name)
136 }
137 base := "bluegit-" + now.UTC().Format("20060102-150405")
138 name := base + ".tar.gz"
139 for i := 1; ; i++ {
140 if _, err := os.Stat(filepath.Join(s.Dir, name)); errors.Is(err, os.ErrNotExist) {
141 break
142 }
143 name = fmt.Sprintf("%s-%d.tar.gz", base, i)
144 }
145 tmp := filepath.Join(s.Dir, "."+name+".partial")
146 f, err := os.OpenFile(tmp, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0o640)
147 if err != nil {
148 return Archive{}, removed, err
149 }
150 if err := WriteTarGz(f, mirrorDir); err != nil {
151 f.Close()
152 os.Remove(tmp)
153 return Archive{}, removed, err
154 }
155 if err := f.Sync(); err != nil {
156 f.Close()
157 os.Remove(tmp)
158 return Archive{}, removed, err
159 }
160 if err := f.Close(); err != nil {
161 os.Remove(tmp)
162 return Archive{}, removed, err
163 }
164 final := filepath.Join(s.Dir, name)
165 if err := os.Rename(tmp, final); err != nil {
166 os.Remove(tmp)
167 return Archive{}, removed, err
168 }
169 _ = os.Chtimes(final, now, now)
170 fi, _ := os.Stat(final)
171 return Archive{Name: name, CreatedAt: now.UTC(), Size: fi.Size()}, removed, nil
172 }
173
174 // removeOldest verwijdert het oudste archief zolang er meer dan keep zijn.
175 func (s *Store) removeOldest(keep int) (string, bool, error) {
176 list, err := s.List()
177 if err != nil {
178 return "", false, err
179 }
180 if len(list) <= keep {
181 return "", false, nil
182 }
183 old := list[len(list)-1]
184 if err := os.Remove(filepath.Join(s.Dir, old.Name)); err != nil {
185 return "", false, err
186 }
187 return old.Name, true, nil
188 }
189
190 // Prune verwijdert archieven ouder dan retentionDays (0 = niet op leeftijd)
191 // en daarna de oudste zolang er minder dan minFree bytes vrij is. Het
192 // nieuwste archief blijft altijd staan.
193 func (s *Store) Prune(now time.Time, retentionDays int, minFree uint64) ([]string, error) {
194 var removed []string
195 list, err := s.List()
196 if err != nil {
197 return nil, err
198 }
199 if retentionDays > 0 {
200 cut := now.Add(-time.Duration(retentionDays) * 24 * time.Hour)
201 for i, a := range list {
202 if i == 0 || !a.CreatedAt.Before(cut) {
203 continue
204 }
205 if err := os.Remove(filepath.Join(s.Dir, a.Name)); err != nil {
206 return removed, err
207 }
208 removed = append(removed, a.Name)
209 }
210 }
211 for {
212 free, err := s.free()
213 if err != nil || free >= minFree {
214 break
215 }
216 name, ok, err := s.removeOldest(1)
217 if err != nil {
218 return removed, err
219 }
220 if !ok {
221 break
222 }
223 removed = append(removed, name)
224 }
225 return removed, nil
226 }
227
228 // WriteTarGz schrijft dir als tar.gz met logische paden naar w.
229 func WriteTarGz(w io.Writer, dir string) error {
230 gz, _ := gzip.NewWriterLevel(w, gzip.DefaultCompression)
231 tw := tar.NewWriter(gz)
232 var paths []string
233 err := filepath.WalkDir(dir, func(p string, d fs.DirEntry, err error) error {
234 if err != nil {
235 if errors.Is(err, fs.ErrNotExist) && p == dir {
236 return fs.SkipDir
237 }
238 return err
239 }
240 if d.Type().IsRegular() {
241 paths = append(paths, p)
242 }
243 return nil
244 })
245 if err != nil {
246 return err
247 }
248 sort.Strings(paths)
249 for _, p := range paths {
250 rel, _ := filepath.Rel(dir, p)
251 logical := filepath.ToSlash(rel)
252 if _, ok := protocol.CleanLogical(logical); !ok {
253 continue
254 }
255 if err := addFile(tw, p, logical); err != nil {
256 return err
257 }
258 }
259 if err := tw.Close(); err != nil {
260 return err
261 }
262 return gz.Close()
263 }
264
265 func addFile(tw *tar.Writer, p, logical string) error {
266 f, err := os.Open(p)
267 if err != nil {
268 return err
269 }
270 defer f.Close()
271 fi, err := f.Stat()
272 if err != nil {
273 return err
274 }
275 h := &tar.Header{
276 Name: logical, Mode: int64(fi.Mode().Perm()), Size: fi.Size(), Typeflag: tar.TypeReg,
277 ModTime: fi.ModTime(), Format: tar.FormatPAX,
278 }
279 if err := tw.WriteHeader(h); err != nil {
280 return err
281 }
282 _, err = io.CopyN(tw, f, fi.Size())
283 return err
284 }
285
286 // Extract pakt archief src uit in dst (dat nog niet mag bestaan). Alleen
287 // gewone bestanden met geldige logische paden.
288 func Extract(src, dst string) error {
289 f, err := os.Open(src)
290 if err != nil {
291 return err
292 }
293 defer f.Close()
294 return ExtractReader(f, dst)
295 }
296
297 // ExtractReader is Extract vanaf een stroom.
298 func ExtractReader(r io.Reader, dst string) error {
299 if err := os.MkdirAll(dst, 0o750); err != nil {
300 return err
301 }
302 gz, err := gzip.NewReader(r)
303 if err != nil {
304 return err
305 }
306 tr := tar.NewReader(gz)
307 for {
308 h, err := tr.Next()
309 if err == io.EOF {
310 return nil
311 }
312 if err != nil {
313 return err
314 }
315 if h.Typeflag == tar.TypeDir {
316 continue
317 }
318 logical, ok := protocol.CleanLogical(strings.TrimPrefix(h.Name, "./"))
319 if h.Typeflag != tar.TypeReg || !ok {
320 return fmt.Errorf("ongeldig item in archief: %q", h.Name)
321 }
322 out := filepath.Join(dst, filepath.FromSlash(logical))
323 if err := os.MkdirAll(filepath.Dir(out), 0o750); err != nil {
324 return err
325 }
326 mode := os.FileMode(h.Mode).Perm()&0o755 | 0o600
327 w, err := os.OpenFile(out, os.O_CREATE|os.O_EXCL|os.O_WRONLY, mode)
328 if err != nil {
329 return err
330 }
331 if _, err := io.Copy(w, tr); err != nil {
332 w.Close()
333 return err
334 }
335 if err := w.Close(); err != nil {
336 return err
337 }
338 _ = os.Chtimes(out, h.ModTime, h.ModTime)
339 }
340 }
@@ -0,0 +1,340 @@
1// Package archive maakt, bewaart, ruimt op en pakt archieven uit.
2//
3// Een archief is een tar.gz (PAX, mtimes in milliseconden) van de kopie 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// DeleteAll verwijdert alle archieven.
100func (s *Store) DeleteAll() error {
101 list, err := s.List()
102 if err != nil {
103 return err
104 }
105 for _, a := range list {
106 if err := os.Remove(filepath.Join(s.Dir, a.Name)); err != nil {
107 return err
108 }
109 }
110 return nil
111}
112
113// Create schrijft een nieuw archief van mirrorDir. needBytes is een
114// schatting van de grootte; is er te weinig ruimte, dan gaan eerst oude
115// archieven weg (het nieuwste blijft).
116func (s *Store) Create(mirrorDir string, now time.Time, needBytes int64, minFree uint64) (Archive, []string, error) {
117 if err := os.MkdirAll(s.Dir, 0o750); err != nil {
118 return Archive{}, nil, err
119 }
120 var removed []string
121 for {
122 free, err := s.free()
123 if err != nil || free >= uint64(needBytes)+minFree {
124 break
125 }
126 // Het nieuwe archief wordt het nieuwste; daarvoor mag ook het
127 // laatste oude weg. De draaiende kopie blijft altijd staan.
128 name, ok, err := s.removeOldest(0)
129 if err != nil {
130 return Archive{}, removed, err
131 }
132 if !ok {
133 return Archive{}, removed, fmt.Errorf("te weinig schijfruimte voor een archief (%d MB vrij, %d MB nodig)", free>>20, (uint64(needBytes)+minFree)>>20)
134 }
135 removed = append(removed, name)
136 }
137 base := "bluegit-" + now.UTC().Format("20060102-150405")
138 name := base + ".tar.gz"
139 for i := 1; ; i++ {
140 if _, err := os.Stat(filepath.Join(s.Dir, name)); errors.Is(err, os.ErrNotExist) {
141 break
142 }
143 name = fmt.Sprintf("%s-%d.tar.gz", base, i)
144 }
145 tmp := filepath.Join(s.Dir, "."+name+".partial")
146 f, err := os.OpenFile(tmp, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0o640)
147 if err != nil {
148 return Archive{}, removed, err
149 }
150 if err := WriteTarGz(f, mirrorDir); err != nil {
151 f.Close()
152 os.Remove(tmp)
153 return Archive{}, removed, err
154 }
155 if err := f.Sync(); err != nil {
156 f.Close()
157 os.Remove(tmp)
158 return Archive{}, removed, err
159 }
160 if err := f.Close(); err != nil {
161 os.Remove(tmp)
162 return Archive{}, removed, err
163 }
164 final := filepath.Join(s.Dir, name)
165 if err := os.Rename(tmp, final); err != nil {
166 os.Remove(tmp)
167 return Archive{}, removed, err
168 }
169 _ = os.Chtimes(final, now, now)
170 fi, _ := os.Stat(final)
171 return Archive{Name: name, CreatedAt: now.UTC(), Size: fi.Size()}, removed, nil
172}
173
174// removeOldest verwijdert het oudste archief zolang er meer dan keep zijn.
175func (s *Store) removeOldest(keep int) (string, bool, error) {
176 list, err := s.List()
177 if err != nil {
178 return "", false, err
179 }
180 if len(list) <= keep {
181 return "", false, nil
182 }
183 old := list[len(list)-1]
184 if err := os.Remove(filepath.Join(s.Dir, old.Name)); err != nil {
185 return "", false, err
186 }
187 return old.Name, true, nil
188}
189
190// Prune verwijdert archieven ouder dan retentionDays (0 = niet op leeftijd)
191// en daarna de oudste zolang er minder dan minFree bytes vrij is. Het
192// nieuwste archief blijft altijd staan.
193func (s *Store) Prune(now time.Time, retentionDays int, minFree uint64) ([]string, error) {
194 var removed []string
195 list, err := s.List()
196 if err != nil {
197 return nil, err
198 }
199 if retentionDays > 0 {
200 cut := now.Add(-time.Duration(retentionDays) * 24 * time.Hour)
201 for i, a := range list {
202 if i == 0 || !a.CreatedAt.Before(cut) {
203 continue
204 }
205 if err := os.Remove(filepath.Join(s.Dir, a.Name)); err != nil {
206 return removed, err
207 }
208 removed = append(removed, a.Name)
209 }
210 }
211 for {
212 free, err := s.free()
213 if err != nil || free >= minFree {
214 break
215 }
216 name, ok, err := s.removeOldest(1)
217 if err != nil {
218 return removed, err
219 }
220 if !ok {
221 break
222 }
223 removed = append(removed, name)
224 }
225 return removed, nil
226}
227
228// WriteTarGz schrijft dir als tar.gz met logische paden naar w.
229func WriteTarGz(w io.Writer, dir string) error {
230 gz, _ := gzip.NewWriterLevel(w, gzip.DefaultCompression)
231 tw := tar.NewWriter(gz)
232 var paths []string
233 err := filepath.WalkDir(dir, func(p string, d fs.DirEntry, err error) error {
234 if err != nil {
235 if errors.Is(err, fs.ErrNotExist) && p == dir {
236 return fs.SkipDir
237 }
238 return err
239 }
240 if d.Type().IsRegular() {
241 paths = append(paths, p)
242 }
243 return nil
244 })
245 if err != nil {
246 return err
247 }
248 sort.Strings(paths)
249 for _, p := range paths {
250 rel, _ := filepath.Rel(dir, p)
251 logical := filepath.ToSlash(rel)
252 if _, ok := protocol.CleanLogical(logical); !ok {
253 continue
254 }
255 if err := addFile(tw, p, logical); err != nil {
256 return err
257 }
258 }
259 if err := tw.Close(); err != nil {
260 return err
261 }
262 return gz.Close()
263}
264
265func addFile(tw *tar.Writer, p, logical string) error {
266 f, err := os.Open(p)
267 if err != nil {
268 return err
269 }
270 defer f.Close()
271 fi, err := f.Stat()
272 if err != nil {
273 return err
274 }
275 h := &tar.Header{
276 Name: logical, Mode: int64(fi.Mode().Perm()), Size: fi.Size(), Typeflag: tar.TypeReg,
277 ModTime: fi.ModTime(), Format: tar.FormatPAX,
278 }
279 if err := tw.WriteHeader(h); err != nil {
280 return err
281 }
282 _, err = io.CopyN(tw, f, fi.Size())
283 return err
284}
285
286// Extract pakt archief src uit in dst (dat nog niet mag bestaan). Alleen
287// gewone bestanden met geldige logische paden.
288func Extract(src, dst string) error {
289 f, err := os.Open(src)
290 if err != nil {
291 return err
292 }
293 defer f.Close()
294 return ExtractReader(f, dst)
295}
296
297// ExtractReader is Extract vanaf een stroom.
298func ExtractReader(r io.Reader, dst string) error {
299 if err := os.MkdirAll(dst, 0o750); err != nil {
300 return err
301 }
302 gz, err := gzip.NewReader(r)
303 if err != nil {
304 return err
305 }
306 tr := tar.NewReader(gz)
307 for {
308 h, err := tr.Next()
309 if err == io.EOF {
310 return nil
311 }
312 if err != nil {
313 return err
314 }
315 if h.Typeflag == tar.TypeDir {
316 continue
317 }
318 logical, ok := protocol.CleanLogical(strings.TrimPrefix(h.Name, "./"))
319 if h.Typeflag != tar.TypeReg || !ok {
320 return fmt.Errorf("ongeldig item in archief: %q", h.Name)
321 }
322 out := filepath.Join(dst, filepath.FromSlash(logical))
323 if err := os.MkdirAll(filepath.Dir(out), 0o750); err != nil {
324 return err
325 }
326 mode := os.FileMode(h.Mode).Perm()&0o755 | 0o600
327 w, err := os.OpenFile(out, os.O_CREATE|os.O_EXCL|os.O_WRONLY, mode)
328 if err != nil {
329 return err
330 }
331 if _, err := io.Copy(w, tr); err != nil {
332 w.Close()
333 return err
334 }
335 if err := w.Close(); err != nil {
336 return err
337 }
338 _ = os.Chtimes(out, h.ModTime, h.ModTime)
339 }
340}
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 +151 −0
@@ -0,0 +1,151 @@
1 // Package config leest de configuratie van de backup server.
2 package config
3
4 import (
5 "fmt"
6 "os"
7 "strings"
8 "time"
9
10 "gopkg.in/yaml.v3"
11 )
12
13 // Config is /etc/bluegit-backup/config.yml.
14 type Config struct {
15 // Listen is waar de backup server luistert (plain HTTP; TLS doet een
16 // proxy ervoor als dat nodig is).
17 Listen string `yaml:"listen"`
18 // PublicURL is het adres waarop BlueGit deze server bereikt, voor
19 // meldingen, de archieflijst en rollback.
20 PublicURL string `yaml:"public_url"`
21 // DataDir bevat de draaiende kopie, de archieven en de koppeling.
22 DataDir string `yaml:"data_dir"`
23 // ArchiveInterval: zo vaak wordt de hele kopie gecomprimeerd en
24 // opgeslagen. Standaard 24h (dagelijks).
25 ArchiveInterval Duration `yaml:"archive_interval"`
26 // RetentionDays: archieven ouder dan dit worden verwijderd. 0 = nooit
27 // op leeftijd. Het nieuwste archief blijft altijd staan.
28 RetentionDays int `yaml:"retention_days"`
29 // MinFreeMB: zakt de vrije ruimte op DataDir hieronder, dan gaat het
30 // oudste archief weg (het nieuwste blijft altijd staan).
31 MinFreeMB int64 `yaml:"min_free_mb"`
32 // RateLimitKiB begrenst het downloaden van BlueGit, in KiB/s.
33 // Standaard 1024. 0 = geen limiet.
34 RateLimitKiB int64 `yaml:"rate_limit_kib"`
35 // FullSyncInterval: ook zonder melding wordt zo vaak gesynchroniseerd.
36 FullSyncInterval Duration `yaml:"full_sync_interval"`
37 // MinSyncInterval: na een melding wacht de server minstens zo lang
38 // sinds de vorige sync, zodat een drukke BlueGit niet elke seconde een
39 // databasekopie hoeft te maken.
40 MinSyncInterval Duration `yaml:"min_sync_interval"`
41 }
42
43 // Duration leest "24h", "30m" enzovoort.
44 type Duration struct{ time.Duration }
45
46 // UnmarshalYAML leest een Go-duur of een aantal seconden.
47 func (d *Duration) UnmarshalYAML(n *yaml.Node) error {
48 s := strings.TrimSpace(n.Value)
49 if s == "" {
50 return nil
51 }
52 if strings.HasSuffix(s, "d") {
53 var days int
54 if _, err := fmt.Sscanf(s, "%dd", &days); err == nil {
55 d.Duration = time.Duration(days) * 24 * time.Hour
56 return nil
57 }
58 }
59 v, err := time.ParseDuration(s)
60 if err != nil {
61 return fmt.Errorf("ongeldige duur %q", s)
62 }
63 d.Duration = v
64 return nil
65 }
66
67 // MarshalYAML schrijft de duur terug als tekst.
68 func (d Duration) MarshalYAML() (any, error) { return d.String(), nil }
69
70 // Defaults vult lege velden.
71 func (c *Config) Defaults() {
72 if c.Listen == "" {
73 c.Listen = "0.0.0.0:8790"
74 }
75 if c.DataDir == "" {
76 c.DataDir = "/var/lib/bluegit-backup"
77 }
78 if c.ArchiveInterval.Duration == 0 {
79 c.ArchiveInterval.Duration = 24 * time.Hour
80 }
81 if c.RetentionDays == 0 {
82 c.RetentionDays = 30
83 }
84 if c.RetentionDays < 0 {
85 c.RetentionDays = 0
86 }
87 if c.MinFreeMB == 0 {
88 c.MinFreeMB = 1024
89 }
90 if c.RateLimitKiB == 0 {
91 c.RateLimitKiB = 1024
92 }
93 if c.RateLimitKiB < 0 {
94 c.RateLimitKiB = 0
95 }
96 if c.FullSyncInterval.Duration == 0 {
97 c.FullSyncInterval.Duration = time.Hour
98 }
99 if c.MinSyncInterval.Duration == 0 {
100 c.MinSyncInterval.Duration = 10 * time.Second
101 }
102 }
103
104 // Validate controleert de combinatie.
105 func (c Config) Validate() error {
106 if c.ArchiveInterval.Duration < time.Second {
107 return fmt.Errorf("archive_interval moet minstens 1s zijn")
108 }
109 if c.PublicURL != "" && !strings.HasPrefix(c.PublicURL, "http://") && !strings.HasPrefix(c.PublicURL, "https://") {
110 return fmt.Errorf("public_url moet met http:// of https:// beginnen")
111 }
112 return nil
113 }
114
115 // Load leest path. Een ontbrekend bestand geeft de standaardwaarden.
116 func Load(path string) (Config, error) {
117 var c Config
118 b, err := os.ReadFile(path)
119 if err != nil && !os.IsNotExist(err) {
120 return c, err
121 }
122 if err == nil {
123 if err := yaml.Unmarshal(b, &c); err != nil {
124 return c, fmt.Errorf("%s: %w", path, err)
125 }
126 }
127 c.Defaults()
128 return c, c.Validate()
129 }
130
131 // Example is een voorbeeldconfiguratie.
132 func Example() string {
133 return `# bluegit-backup. Kopieer naar /etc/bluegit-backup/config.yml.
134 listen: 0.0.0.0:8790
135 # Waar BlueGit deze server bereikt (meldingen, archieflijst, rollback).
136 public_url: http://backup.lan:8790
137 data_dir: /var/lib/bluegit-backup
138 # Zo vaak wordt de hele kopie gecomprimeerd opgeslagen. Standaard dagelijks.
139 archive_interval: 24h
140 # Archieven ouder dan dit gaan weg (0 = nooit op leeftijd). Het nieuwste blijft.
141 retention_days: 30
142 # Minder vrije ruimte dan dit: het oudste archief gaat weg.
143 min_free_mb: 1024
144 # Downloadsnelheid van BlueGit in KiB/s, zodat BlueGit er geen last van heeft.
145 rate_limit_kib: 1024
146 # Ook zonder melding zo vaak alles nalopen.
147 full_sync_interval: 1h
148 # Minimale tijd tussen twee syncs na meldingen.
149 min_sync_interval: 10s
150 `
151 }
@@ -0,0 +1,151 @@
1// Package config leest de configuratie van de backup server.
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:8790"
74 }
75 if c.DataDir == "" {
76 c.DataDir = "/var/lib/bluegit-backup"
77 }
78 if c.ArchiveInterval.Duration == 0 {
79 c.ArchiveInterval.Duration = 24 * time.Hour
80 }
81 if c.RetentionDays == 0 {
82 c.RetentionDays = 30
83 }
84 if c.RetentionDays < 0 {
85 c.RetentionDays = 0
86 }
87 if c.MinFreeMB == 0 {
88 c.MinFreeMB = 1024
89 }
90 if c.RateLimitKiB == 0 {
91 c.RateLimitKiB = 1024
92 }
93 if c.RateLimitKiB < 0 {
94 c.RateLimitKiB = 0
95 }
96 if c.FullSyncInterval.Duration == 0 {
97 c.FullSyncInterval.Duration = time.Hour
98 }
99 if c.MinSyncInterval.Duration == 0 {
100 c.MinSyncInterval.Duration = 10 * time.Second
101 }
102}
103
104// Validate controleert de combinatie.
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.PublicURL != "" && !strings.HasPrefix(c.PublicURL, "http://") && !strings.HasPrefix(c.PublicURL, "https://") {
110 return fmt.Errorf("public_url moet met http:// of https:// beginnen")
111 }
112 return nil
113}
114
115// Load leest path. Een ontbrekend bestand geeft de standaardwaarden.
116func Load(path string) (Config, error) {
117 var c Config
118 b, err := os.ReadFile(path)
119 if err != nil && !os.IsNotExist(err) {
120 return c, err
121 }
122 if err == nil {
123 if err := yaml.Unmarshal(b, &c); err != nil {
124 return c, fmt.Errorf("%s: %w", path, err)
125 }
126 }
127 c.Defaults()
128 return c, c.Validate()
129}
130
131// Example is een voorbeeldconfiguratie.
132func Example() string {
133 return `# bluegit-backup. Kopieer naar /etc/bluegit-backup/config.yml.
134listen: 0.0.0.0:8790
135# Waar BlueGit deze server bereikt (meldingen, archieflijst, rollback).
136public_url: http://backup.lan:8790
137data_dir: /var/lib/bluegit-backup
138# Zo vaak wordt de hele kopie gecomprimeerd opgeslagen. Standaard dagelijks.
139archive_interval: 24h
140# Archieven ouder dan dit gaan weg (0 = nooit op leeftijd). Het nieuwste blijft.
141retention_days: 30
142# Minder vrije ruimte dan dit: het oudste archief gaat weg.
143min_free_mb: 1024
144# Downloadsnelheid van BlueGit in KiB/s, zodat BlueGit er geen last van heeft.
145rate_limit_kib: 1024
146# Ook zonder melding zo vaak alles nalopen.
147full_sync_interval: 1h
148# Minimale tijd tussen twee syncs na meldingen.
149min_sync_interval: 10s
150`
151}
internal/backupserver/config/config_test.go added +44 −0
@@ -0,0 +1,44 @@
1 package config
2
3 import (
4 "os"
5 "path/filepath"
6 "testing"
7 "time"
8 )
9
10 func TestDefaults(t *testing.T) {
11 c, err := Load(filepath.Join(t.TempDir(), "geen.yml"))
12 if err != nil {
13 t.Fatal(err)
14 }
15 if c.ArchiveInterval.Duration != 24*time.Hour || c.RetentionDays != 30 || c.RateLimitKiB != 1024 || c.Listen != "0.0.0.0:8790" {
16 t.Fatalf("%+v", c)
17 }
18 }
19
20 func TestLoad(t *testing.T) {
21 p := filepath.Join(t.TempDir(), "c.yml")
22 _ = os.WriteFile(p, []byte("archive_interval: 7d\nretention_days: -1\nrate_limit_kib: -1\npublic_url: http://b:1\n"), 0o600)
23 c, err := Load(p)
24 if err != nil {
25 t.Fatal(err)
26 }
27 if c.ArchiveInterval.Duration != 7*24*time.Hour || c.RetentionDays != 0 || c.RateLimitKiB != 0 {
28 t.Fatalf("%+v", c)
29 }
30 _ = os.WriteFile(p, []byte("public_url: ftp://x\n"), 0o600)
31 if _, err := Load(p); err == nil {
32 t.Fatal("ftp geaccepteerd")
33 }
34 _ = os.WriteFile(p, []byte("archive_interval: soms\n"), 0o600)
35 if _, err := Load(p); err == nil {
36 t.Fatal("ongeldige duur geaccepteerd")
37 }
38 if _, err := os.Stat(p); err != nil {
39 t.Fatal(err)
40 }
41 if Example() == "" {
42 t.Fatal("geen voorbeeld")
43 }
44 }
@@ -0,0 +1,44 @@
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:8790" {
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}
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.NewKey()
53 code, raw = b.Admin("POST", "/sync", nil)
54 if code == 200 {
55 t.Fatalf("sync met ingetrokken key gelukt: %s", raw)
56 }
57 }
58
59 // Feature: alle gegevens en configuratie ophalen.
60 func TestFullSyncCopiesAllData(t *testing.T) {
61 g := startBlueGit(t)
62 g.Project("Alpha", "README.md", "hallo alpha")
63 g.Issue("alpha", "eerste issue")
64 b := startBackup(t, nil)
65 b.Connect(g, g.NewKey())
66 b.Sync()
67
68 for _, p := range []string{"state/bluegit.db", "state/secret.key", "data/repos/tim/alpha.git/HEAD"} {
69 if _, err := os.Stat(b.Mirror(p)); err != nil {
70 t.Fatalf("kopie mist %s: %v", p, err)
71 }
72 }
73 if log := gitLog(t, b.Mirror("data/repos/tim/alpha.git")); !strings.Contains(log, "zet README.md") {
74 t.Fatalf("kopie van de repo is niet bruikbaar: %s", log)
75 }
76 db, _ := os.ReadFile(b.Mirror("state/bluegit.db"))
77 if !strings.HasPrefix(string(db), "SQLite format 3") || !strings.Contains(string(db), "eerste issue") {
78 t.Fatal("databasekopie mist het issue")
79 }
80 key1, _ := os.ReadFile(filepath.Join(g.State, "secret.key"))
81 key2, _ := os.ReadFile(b.Mirror("state/secret.key"))
82 if string(key1) != string(key2) {
83 t.Fatal("secret.key wijkt af")
84 }
85 // Installatiegebonden bestanden gaan niet mee.
86 for _, p := range []string{"state/backup.json", "state/instance_id", "state/storage_path"} {
87 if _, err := os.Stat(b.Mirror(p)); err == nil {
88 t.Fatalf("%s hoort niet in de kopie", p)
89 }
90 }
91 // Een tweede sync zonder wijzigingen haalt (bijna) niets op.
92 code, raw := b.Admin("POST", "/sync", nil)
93 var st struct{ Downloaded int }
94 _ = json.Unmarshal(raw, &st)
95 if code != 200 || st.Downloaded > 1 {
96 t.Fatalf("tweede sync haalde %d bestanden op: %s", st.Downloaded, raw)
97 }
98 }
99
100 // Feature: BlueGit meldt elke wijziging; de backup server haalt hem op.
101 func TestNotificationTriggersSync(t *testing.T) {
102 g := startBlueGit(t)
103 g.Project("Alpha", "README.md", "v1")
104 b := startBackup(t, nil) // full sync pas na een uur: alleen meldingen tellen
105 b.Connect(g, g.NewKey())
106 Eventually(t, 15*time.Second, "eerste sync na koppelen", func() bool {
107 return strings.Contains(gitLog(t, b.Mirror("data/repos/tim/alpha.git")), "zet README.md")
108 })
109 before := b.Status().Notifies
110
111 // Wijziging via de API.
112 g.Commit("alpha", "CHANGELOG.md", "nieuw", "create")
113 Eventually(t, 15*time.Second, "commit via API in de kopie", func() bool {
114 return strings.Contains(gitLog(t, b.Mirror("data/repos/tim/alpha.git")), "zet CHANGELOG.md")
115 })
116 // Wijziging via git push over HTTP.
117 work := t.TempDir()
118 g.Git(work, "clone", "-q", g.RemoteURL("alpha"), "w")
119 repo := filepath.Join(work, "w")
120 _ = os.WriteFile(filepath.Join(repo, "pushed.txt"), []byte("via git"), 0o644)
121 g.Git(repo, "add", ".")
122 g.Git(repo, "commit", "-qm", "gepusht met git")
123 g.Git(repo, "push", "-q", "origin", "master")
124 Eventually(t, 15*time.Second, "git push in de kopie", func() bool {
125 return strings.Contains(gitLog(t, b.Mirror("data/repos/tim/alpha.git")), "gepusht met git")
126 })
127 // Een issue staat alleen in de database.
128 g.Issue("alpha", "issue-na-melding")
129 Eventually(t, 15*time.Second, "issue in de databasekopie", func() bool {
130 db, _ := os.ReadFile(b.Mirror("state/bluegit.db"))
131 return strings.Contains(string(db), "issue-na-melding")
132 })
133 if b.Status().Notifies <= before {
134 t.Fatal("geen meldingen geteld")
135 }
136 }
137
138 // Feature: downloaden op lage snelheid.
139 func TestDownloadIsThrottled(t *testing.T) {
140 g := startBlueGit(t)
141 g.MustAPI("POST", "/projects", map[string]any{"name": "Big", "visibility": "private"})
142 work := t.TempDir()
143 g.Git(work, "init", "-q", "-b", "master", "w")
144 repo := filepath.Join(work, "w")
145 blob := make([]byte, 1536<<10) // 1,5 MiB, niet te comprimeren
146 _, _ = rand.Read(blob)
147 _ = os.WriteFile(filepath.Join(repo, "random.bin"), blob, 0o644)
148 g.Git(repo, "add", ".")
149 g.Git(repo, "commit", "-qm", "groot bestand")
150 g.Git(repo, "push", "-q", g.RemoteURL("big"), "master")
151
152 b := startBackup(t, func(c *config.Config) { c.RateLimitKiB = 512 })
153 start := time.Now()
154 b.Connect(g, g.NewKey())
155 b.Sync()
156 took := time.Since(start)
157 // 1,5 MiB tegen 512 KiB/s is minstens ~2,7 s (min de eerste burst).
158 if took < 2500*time.Millisecond {
159 t.Fatalf("sync duurde %v; de limiet van 512 KiB/s werkt niet", took)
160 }
161 if b.Status().RateLimitKiB != 512 {
162 t.Fatal("limiet niet in de status")
163 }
164 if !strings.Contains(gitLog(t, b.Mirror("data/repos/tim/big.git")), "groot bestand") {
165 t.Fatal("groot bestand niet gekopieerd")
166 }
167 }
168
169 // Feature: op een interval archiveren; archieflijst in BlueGit.
170 func TestArchiveIntervalAndListInBlueGit(t *testing.T) {
171 g := startBlueGit(t)
172 g.Project("Alpha", "README.md", "v1")
173 b := startBackup(t, func(c *config.Config) { c.ArchiveInterval.Duration = 2 * time.Second })
174 if b.Status().Interval != "2s" {
175 t.Fatalf("interval: %s", b.Status().Interval)
176 }
177 b.Connect(g, g.NewKey())
178 Eventually(t, 20*time.Second, "twee archieven door het interval", func() bool { return len(b.Archives()) >= 2 })
179
180 names := b.Archives()
181 st := g.BackupStatus()
182 if len(st.Archives) < 2 || st.Archives[0].Name != names[0] || st.Archives[0].Size == 0 {
183 t.Fatalf("BlueGit toont de archieven niet: %+v vs %v", st.Archives, names)
184 }
185 // De beheerpagina toont de lijst met de grote waarschuwing.
186 res, err := g.Session().Get(g.URL + "/admin/backup")
187 if err != nil {
188 t.Fatal(err)
189 }
190 page, _ := io.ReadAll(res.Body)
191 res.Body.Close()
192 for _, want := range []string{names[0], `class="backup-danger"`, `name="understood"`, `name="confirm"`} {
193 if !strings.Contains(string(page), want) {
194 t.Fatalf("beheerpagina mist %q", want)
195 }
196 }
197 // Het archief is een geldige tar.gz met de logische paden.
198 out, err := exec.Command("tar", "-tzf", filepath.Join(b.Dir, "archives", names[0])).CombinedOutput()
199 if err != nil || !strings.Contains(string(out), "state/bluegit.db") || !strings.Contains(string(out), "data/repos/tim/alpha.git/HEAD") {
200 t.Fatalf("archief: %v %s", err, out)
201 }
202 }
203
204 // Feature: archieven ouder dan x dagen, of de oudste bij een volle schijf, verdwijnen.
205 func TestRetentionAndDiskFull(t *testing.T) {
206 g := startBlueGit(t)
207 g.Project("Alpha", "README.md", "v1")
208 b := startBackup(t, func(c *config.Config) { c.RetentionDays = 7 })
209 b.Connect(g, g.NewKey())
210 b.Sync()
211 var names []string
212 for i := 0; i < 4; i++ {
213 names = append(names, b.Archive())
214 time.Sleep(1100 * time.Millisecond) // namen hebben secondes
215 }
216 // De twee oudste zijn 10 en 8 dagen oud, de derde 6.
217 ages := []int{10, 8, 6}
218 for i, d := range ages {
219 old := time.Now().Add(-time.Duration(d) * 24 * time.Hour)
220 _ = os.Chtimes(filepath.Join(b.Dir, "archives", names[i]), old, old)
221 }
222 code, raw := b.Admin("POST", "/prune", nil)
223 if code != 200 || !strings.Contains(string(raw), names[0]) || !strings.Contains(string(raw), names[1]) || strings.Contains(string(raw), names[2]) {
224 t.Fatalf("prune op leeftijd: %d %s", code, raw)
225 }
226 if got := b.Archives(); len(got) != 2 {
227 t.Fatalf("na leeftijd: %v", got)
228 }
229 // Schijf vol: de oudste gaat weg, het nieuwste blijft altijd.
230 b.Srv.SetFree(func(string) (uint64, error) { return 0, nil })
231 code, raw = b.Admin("POST", "/prune", nil)
232 if code != 200 || !strings.Contains(string(raw), names[2]) {
233 t.Fatalf("prune schijf vol: %d %s", code, raw)
234 }
235 if got := b.Archives(); len(got) != 1 || got[0] != names[3] {
236 t.Fatalf("na schijf vol: %v, wil alleen %s", got, names[3])
237 }
238 // Ook een nieuw archief maakt eerst ruimte: het oude gaat weg, het nieuwe komt.
239 b.Srv.SetFree(func(string) (uint64, error) {
240 if len(b.Archives()) > 0 {
241 return 0, nil
242 }
243 return 10 << 30, nil
244 })
245 time.Sleep(1100 * time.Millisecond)
246 newest := b.Archive()
247 if got := b.Archives(); len(got) != 1 || got[0] != newest {
248 t.Fatalf("na archief bij volle schijf: %v", got)
249 }
250 }
251
252 // Feature: rollback vanuit BlueGit, met bevestiging; kopie en BlueGit gaan terug.
253 func TestRollbackFromBlueGit(t *testing.T) {
254 g := startBlueGit(t)
255 g.Project("Alpha", "README.md", "versie 1")
256 g.Issue("alpha", "voor het archief")
257 b := startBackup(t, nil)
258 b.Connect(g, g.NewKey())
259 b.Sync()
260 archiveName := b.Archive()
261
262 // Na het archief: alles verandert.
263 g.Commit("alpha", "README.md", "versie 2", "update")
264 g.Issue("alpha", "na het archief")
265 g.Project("Beta", "b.txt", "nieuw project")
266 b.Sync()
267 if _, s := g.File("alpha", "README.md"); s != "versie 2" {
268 t.Fatalf("voorbereiding: %q", s)
269 }
270
271 // Zonder juiste bevestiging gebeurt er niets.
272 code, raw := g.API("POST", "/admin/backup/rollback", map[string]any{"archive": archiveName, "confirm": "ja"})
273 if code != 400 {
274 t.Fatalf("rollback zonder bevestiging: %d %s", code, raw)
275 }
276 // Via het formulier zonder vinkje ook niet.
277 if code := postRollbackForm(t, g, archiveName, false); code/100 != 3 {
278 t.Fatalf("formulier zonder vinkje: %d", code)
279 }
280 time.Sleep(300 * time.Millisecond)
281 if b.Status().Rollback.State != "idle" {
282 t.Fatalf("rollback gestart zonder bevestiging: %+v", b.Status().Rollback)
283 }
284
285 // Echte rollback via de UI.
286 if code := postRollbackForm(t, g, archiveName, true); code/100 != 3 {
287 t.Fatalf("formulier: %d", code)
288 }
289 Eventually(t, 60*time.Second, "rollback klaar", func() bool {
290 st := b.Status().Rollback
291 if st.State == "failed" {
292 t.Fatalf("rollback mislukt: %s", st.Error)
293 }
294 return st.State == "done"
295 })
296 g.WaitUp(30 * time.Second)
297
298 if code, s := g.File("alpha", "README.md"); code != 200 || s != "versie 1" {
299 t.Fatalf("README na rollback: %d %q", code, s)
300 }
301 if code := g.ProjectCode("beta"); code != 404 {
302 t.Fatalf("project beta bestaat na rollback nog: %d", code)
303 }
304 titles := strings.Join(g.IssueTitles("alpha"), "|")
305 if !strings.Contains(titles, "voor het archief") || strings.Contains(titles, "na het archief") {
306 t.Fatalf("issues na rollback: %s", titles)
307 }
308 // De koppeling overleeft de rollback: BlueGit ziet de server nog, en
309 // de kopie loopt weer gelijk met BlueGit.
310 if st := g.BackupStatus(); !st.Connected || st.RemoteError != "" {
311 t.Fatalf("koppeling na rollback: %+v", st)
312 }
313 b.Sync()
314 if log := gitLog(t, b.Mirror("data/repos/tim/alpha.git")); strings.Count(log, "zet README.md") != 1 {
315 t.Fatalf("kopie na rollback: %s", log)
316 }
317 if _, err := os.Stat(b.Mirror("data/repos/tim/beta.git/HEAD")); err == nil {
318 t.Fatal("beta staat nog in de kopie")
319 }
320 // Na de rollback werkt BlueGit gewoon verder en blijft melden.
321 g.Commit("alpha", "after.txt", "na rollback", "create")
322 Eventually(t, 15*time.Second, "melding na rollback", func() bool {
323 return strings.Contains(gitLog(t, b.Mirror("data/repos/tim/alpha.git")), "zet after.txt")
324 })
325 }
326
327 func postRollbackForm(t *testing.T, g *BlueGit, archiveName string, understood bool) int {
328 t.Helper()
329 hc := g.Session()
330 hc.CheckRedirect = func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }
331 res, err := hc.Get(g.URL + "/admin/backup")
332 if err != nil {
333 t.Fatal(err)
334 }
335 page, _ := io.ReadAll(res.Body)
336 res.Body.Close()
337 csrf := between(string(page), `name="csrf" value="`, `"`)
338 if csrf == "" {
339 t.Fatal("geen csrf op de beheerpagina")
340 }
341 form := url.Values{"csrf": {csrf}, "archive": {archiveName}, "confirm": {archiveName}}
342 if understood {
343 form.Set("understood", "1")
344 }
345 res, err = hc.PostForm(g.URL+"/admin/backup/rollback", form)
346 if err != nil {
347 t.Fatal(err)
348 }
349 res.Body.Close()
350 return res.StatusCode
351 }
352
353 func between(s, a, b string) string {
354 i := strings.Index(s, a)
355 if i < 0 {
356 return ""
357 }
358 s = s[i+len(a):]
359 j := strings.Index(s, b)
360 if j < 0 {
361 return ""
362 }
363 return s[:j]
364 }
365
366 // Feature: één BlueGit per backup server; keuze "oude backups verwijderen".
367 func TestNewInstanceWipe(t *testing.T) {
368 a := startBlueGit(t)
369 a.Project("Alpha", "a.txt", "van A")
370 b := startBackup(t, nil)
371 b.Connect(a, a.NewKey())
372 b.Sync()
373 b.Archive()
374
375 other := startBlueGit(t)
376 other.Project("Gamma", "g.txt", "van B")
377 keyB := other.NewKey()
378 code, raw := b.Admin("POST", "/connect", server.ConnectRequest{URL: other.URL, Key: keyB})
379 if code != 409 {
380 t.Fatalf("tweede BlueGit zonder keuze: %d %s", code, raw)
381 }
382 var cf server.ConflictError
383 _ = json.Unmarshal(raw, &cf)
384 if !cf.Conflict || cf.PreviousURL != a.URL || cf.Archives != 1 || strings.Join(cf.Choices, ",") != "wipe,restore" {
385 t.Fatalf("conflict: %+v", cf)
386 }
387 // Er is nog niets veranderd.
388 if b.Status().BlueGitURL != a.URL || len(b.Archives()) != 1 {
389 t.Fatal("conflict veranderde de koppeling")
390 }
391 code, raw = b.Admin("POST", "/connect", server.ConnectRequest{URL: other.URL, Key: keyB, OnConflict: "wipe"})
392 if code != 200 {
393 t.Fatalf("wipe: %d %s", code, raw)
394 }
395 if len(b.Archives()) != 0 {
396 t.Fatal("oude archieven staan er nog")
397 }
398 b.Sync()
399 if _, err := os.Stat(b.Mirror("data/repos/tim/alpha.git/HEAD")); err == nil {
400 t.Fatal("A staat nog in de kopie")
401 }
402 if !strings.Contains(gitLog(t, b.Mirror("data/repos/tim/gamma.git")), "zet g.txt") {
403 t.Fatal("B staat niet in de kopie")
404 }
405 if st := other.BackupStatus(); !st.Connected || st.ServerURL != b.URL {
406 t.Fatalf("B ziet de koppeling niet: %+v", st)
407 }
408 // A is los: zijn meldingen worden geweigerd (andere instantie).
409 if b.Status().InstanceID == a.BackupStatus().InstanceID {
410 t.Fatal("backup server hoort nog bij A")
411 }
412 }
413
414 // Feature: keuze "nieuwe instantie terugzetten naar de gegevens in de backup server".
415 func TestNewInstanceRestore(t *testing.T) {
416 a := startBlueGit(t)
417 a.Project("Alpha", "a.txt", "van A")
418 a.Issue("alpha", "issue van A")
419 b := startBackup(t, nil)
420 b.Connect(a, a.NewKey())
421 b.Sync()
422
423 fresh := startBlueGit(t)
424 fresh.Project("Gamma", "g.txt", "van B")
425 keyB := fresh.NewKey()
426 freshID := fresh.BackupStatus().InstanceID
427 code, raw := b.Admin("POST", "/connect", server.ConnectRequest{URL: fresh.URL, Key: keyB, OnConflict: "restore"})
428 if code != 200 || !strings.Contains(string(raw), `"restored":true`) {
429 t.Fatalf("restore: %d %s", code, raw)
430 }
431 fresh.WaitUp(30 * time.Second)
432 // De nieuwe BlueGit heeft nu de database van A, dus ook A's token.
433 fresh.Token = a.Token
434 if code, s := fresh.File("alpha", "a.txt"); code != 200 || s != "van A" {
435 t.Fatalf("A's project op de nieuwe BlueGit: %d %q", code, s)
436 }
437 if code := fresh.ProjectCode("gamma"); code != 404 {
438 t.Fatalf("B's eigen project bestaat nog: %d", code)
439 }
440 if titles := strings.Join(fresh.IssueTitles("alpha"), "|"); !strings.Contains(titles, "issue van A") {
441 t.Fatalf("issues: %s", titles)
442 }
443 // De koppeling hoort bij de installatie, niet bij de gegevens.
444 st := fresh.BackupStatus()
445 if !st.Connected || st.InstanceID != freshID || st.ServerURL != b.URL {
446 t.Fatalf("koppeling na restore: %+v", st)
447 }
448 if b.Status().InstanceID != freshID {
449 t.Fatal("backup server hoort niet bij de nieuwe instantie")
450 }
451 b.Sync()
452 if !strings.Contains(gitLog(t, b.Mirror("data/repos/tim/alpha.git")), "zet a.txt") {
453 t.Fatal("kopie na restore")
454 }
455 }
456
457 // Feature: de CLI vraagt de keuze bij een nieuwe verbinding.
458 func TestCLIConnectAsksOnConflict(t *testing.T) {
459 cli := filepath.Join(t.TempDir(), "bluegit-backup")
460 if out, err := exec.Command("go", "build", "-o", cli, "../cmd/bluegit-backup").CombinedOutput(); err != nil {
461 t.Fatalf("build: %v %s", err, out)
462 }
463 a := startBlueGit(t)
464 a.Project("Alpha", "a.txt", "A")
465 b := startBackup(t, nil)
466 cfgPath := filepath.Join(t.TempDir(), "config.yml")
467 _ = os.WriteFile(cfgPath, []byte("listen: "+b.Cfg.Listen+"\npublic_url: "+b.URL+"\ndata_dir: "+b.Dir+"\n"), 0o600)
468 run := func(stdin string, args ...string) (string, error) {
469 cmd := exec.Command(cli, append([]string{"connect", "--config", cfgPath}, args...)...)
470 cmd.Stdin = strings.NewReader(stdin)
471 out, err := cmd.CombinedOutput()
472 return string(out), err
473 }
474 keyA := a.NewKey()
475 cmd := exec.Command(cli, "connect", "--config", cfgPath, "--url", a.URL)
476 cmd.Env = append(os.Environ(), "BLUEGIT_BACKUP_KEY="+keyA)
477 if out, err := cmd.CombinedOutput(); err != nil {
478 t.Fatalf("eerste connect: %v %s", err, out)
479 }
480 b.Sync()
481
482 other := startBlueGit(t)
483 keyB := other.NewKey()
484 out, err := run("\n", "--url", other.URL, "--key", keyB)
485 if err == nil || !strings.Contains(out, "Oude backups verwijderen") || !strings.Contains(out, "terugzetten") || !strings.Contains(out, "afgebroken") {
486 t.Fatalf("afbreken: %v %s", err, out)
487 }
488 if b.Status().BlueGitURL != a.URL {
489 t.Fatal("afbreken veranderde de koppeling")
490 }
491 out, err = run("1\n", "--url", other.URL, "--key", keyB)
492 if err != nil || b.Status().BlueGitURL != other.URL {
493 t.Fatalf("keuze 1: %v %s", err, out)
494 }
495 if out, err := exec.Command(cli, "status", "--config", cfgPath).CombinedOutput(); err != nil || !strings.Contains(string(out), other.URL) {
496 t.Fatalf("status: %v %s", err, out)
497 }
498 }
@@ -0,0 +1,498 @@
1//go:build 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.NewKey()
53 code, raw = b.Admin("POST", "/sync", nil)
54 if code == 200 {
55 t.Fatalf("sync met ingetrokken key gelukt: %s", raw)
56 }
57}
58
59// Feature: alle gegevens en configuratie ophalen.
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")
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.API("POST", "/admin/backup/rollback", map[string]any{"archive": archiveName, "confirm": "ja"})
273 if code != 400 {
274 t.Fatalf("rollback zonder bevestiging: %d %s", code, raw)
275 }
276 // Via het formulier zonder vinkje ook niet.
277 if code := postRollbackForm(t, g, archiveName, false); code/100 != 3 {
278 t.Fatalf("formulier zonder vinkje: %d", code)
279 }
280 time.Sleep(300 * time.Millisecond)
281 if b.Status().Rollback.State != "idle" {
282 t.Fatalf("rollback gestart zonder bevestiging: %+v", b.Status().Rollback)
283 }
284
285 // Echte rollback via de UI.
286 if code := postRollbackForm(t, g, archiveName, true); code/100 != 3 {
287 t.Fatalf("formulier: %d", code)
288 }
289 Eventually(t, 60*time.Second, "rollback klaar", func() bool {
290 st := b.Status().Rollback
291 if st.State == "failed" {
292 t.Fatalf("rollback mislukt: %s", st.Error)
293 }
294 return st.State == "done"
295 })
296 g.WaitUp(30 * time.Second)
297
298 if code, s := g.File("alpha", "README.md"); code != 200 || s != "versie 1" {
299 t.Fatalf("README na rollback: %d %q", code, s)
300 }
301 if code := g.ProjectCode("beta"); code != 404 {
302 t.Fatalf("project beta bestaat na rollback nog: %d", code)
303 }
304 titles := strings.Join(g.IssueTitles("alpha"), "|")
305 if !strings.Contains(titles, "voor het archief") || strings.Contains(titles, "na het archief") {
306 t.Fatalf("issues na rollback: %s", titles)
307 }
308 // De koppeling overleeft de rollback: BlueGit ziet de server nog, en
309 // de kopie loopt weer gelijk met BlueGit.
310 if st := g.BackupStatus(); !st.Connected || st.RemoteError != "" {
311 t.Fatalf("koppeling na rollback: %+v", st)
312 }
313 b.Sync()
314 if log := gitLog(t, b.Mirror("data/repos/tim/alpha.git")); strings.Count(log, "zet README.md") != 1 {
315 t.Fatalf("kopie na rollback: %s", log)
316 }
317 if _, err := os.Stat(b.Mirror("data/repos/tim/beta.git/HEAD")); err == nil {
318 t.Fatal("beta staat nog in de kopie")
319 }
320 // Na de rollback werkt BlueGit gewoon verder en blijft melden.
321 g.Commit("alpha", "after.txt", "na rollback", "create")
322 Eventually(t, 15*time.Second, "melding na rollback", func() bool {
323 return strings.Contains(gitLog(t, b.Mirror("data/repos/tim/alpha.git")), "zet after.txt")
324 })
325}
326
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")
332 if err != nil {
333 t.Fatal(err)
334 }
335 page, _ := io.ReadAll(res.Body)
336 res.Body.Close()
337 csrf := between(string(page), `name="csrf" value="`, `"`)
338 if csrf == "" {
339 t.Fatal("geen csrf op de beheerpagina")
340 }
341 form := url.Values{"csrf": {csrf}, "archive": {archiveName}, "confirm": {archiveName}}
342 if understood {
343 form.Set("understood", "1")
344 }
345 res, err = hc.PostForm(g.URL+"/admin/backup/rollback", form)
346 if err != nil {
347 t.Fatal(err)
348 }
349 res.Body.Close()
350 return res.StatusCode
351}
352
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/harness_test.go added +484 −0
@@ -0,0 +1,484 @@
1 //go:build integration
2
3 // Integratietests: elke test start een echte BlueGit (BLUEGIT_BIN), maakt
4 // daar een beheerder, token en Backupserver-Key aan, en test de backup
5 // server ertegen. Zonder BLUEGIT_BIN falen ze; ze slaan niet over, zodat de
6 // release-jobs nooit op een overgeslagen test kunnen leunen.
7 package integration
8
9 import (
10 "bytes"
11 "context"
12 "encoding/json"
13 "fmt"
14 "io"
15 "log/slog"
16 "net"
17 "net/http"
18 "net/http/cookiejar"
19 "net/url"
20 "os"
21 "os/exec"
22 "path/filepath"
23 "strings"
24 "sync"
25 "testing"
26 "time"
27
28 "git.timfalken.com/timfa/bluegit-backup/internal/config"
29 "git.timfalken.com/timfa/bluegit-backup/internal/server"
30 )
31
32 func bluegitBin(t *testing.T) string {
33 t.Helper()
34 bin := os.Getenv("BLUEGIT_BIN")
35 if bin == "" {
36 t.Fatal("BLUEGIT_BIN ontbreekt: bouw BlueGit met scripts/build-bluegit.sh")
37 }
38 if _, err := os.Stat(bin); err != nil {
39 t.Fatalf("BLUEGIT_BIN: %v", err)
40 }
41 if _, err := exec.LookPath("git"); err != nil {
42 t.Fatal("git ontbreekt")
43 }
44 return bin
45 }
46
47 func freePort(t *testing.T) int {
48 t.Helper()
49 ln, err := net.Listen("tcp", "127.0.0.1:0")
50 if err != nil {
51 t.Fatal(err)
52 }
53 defer ln.Close()
54 return ln.Addr().(*net.TCPAddr).Port
55 }
56
57 // BlueGit is één lokaal opgespinde BlueGit.
58 type BlueGit struct {
59 t *testing.T
60 Bin string
61 URL string
62 Config string
63 State string
64 Storage string
65 Token string
66 cmd *exec.Cmd
67 log *syncBuf
68 }
69
70 type syncBuf struct {
71 mu sync.Mutex
72 b bytes.Buffer
73 }
74
75 func (s *syncBuf) Write(p []byte) (int, error) {
76 s.mu.Lock()
77 defer s.mu.Unlock()
78 return s.b.Write(p)
79 }
80
81 func (s *syncBuf) String() string {
82 s.mu.Lock()
83 defer s.mu.Unlock()
84 return s.b.String()
85 }
86
87 func startBlueGit(t *testing.T) *BlueGit {
88 t.Helper()
89 bin := bluegitBin(t)
90 dir := t.TempDir()
91 port := freePort(t)
92 g := &BlueGit{t: t, Bin: bin, URL: fmt.Sprintf("http://127.0.0.1:%d", port),
93 State: filepath.Join(dir, "state"), Storage: filepath.Join(dir, "storage"), Config: filepath.Join(dir, "bluegit.yml"), log: &syncBuf{}}
94 _ = os.MkdirAll(g.Storage, 0o750)
95 cfg := fmt.Sprintf(`base_url: %s
96 listen: 127.0.0.1:%d
97 state_path: %s
98 storage_path: %s
99 auth:
100 mode: dev
101 dev_user: tim
102 dev_auth_id: 1
103 user_agent: bluegit-backup-it
104 git:
105 binary: git
106 default_branch: master
107 ssh:
108 enabled: false
109 ci:
110 enabled: false
111 `, g.URL, port, g.State, g.Storage)
112 if err := os.WriteFile(g.Config, []byte(cfg), 0o600); err != nil {
113 t.Fatal(err)
114 }
115 g.cmd = exec.Command(bin, "serve", "--config", g.Config)
116 g.cmd.Stdout, g.cmd.Stderr = g.log, g.log
117 if err := g.cmd.Start(); err != nil {
118 t.Fatal(err)
119 }
120 t.Cleanup(func() {
121 _ = g.cmd.Process.Kill()
122 _, _ = g.cmd.Process.Wait()
123 if t.Failed() {
124 t.Logf("BlueGit-log %s:\n%s", g.URL, tail(g.log.String(), 60))
125 }
126 })
127 g.WaitUp(20 * time.Second)
128 // Aanmelden maakt de eerste gebruiker (beheerder) aan.
129 jar, _ := cookiejar.New(nil)
130 hc := &http.Client{Jar: jar}
131 res, err := hc.Get(g.URL + "/login")
132 if err != nil {
133 t.Fatal(err)
134 }
135 res.Body.Close()
136 out, err := exec.Command(bin, "token", "create", "--config", g.Config, "--user", "tim", "--name", "it").CombinedOutput()
137 if err != nil {
138 t.Fatalf("token: %v %s", err, out)
139 }
140 g.Token = strings.TrimSpace(string(out))
141 return g
142 }
143
144 func tail(s string, n int) string {
145 lines := strings.Split(s, "\n")
146 if len(lines) > n {
147 lines = lines[len(lines)-n:]
148 }
149 return strings.Join(lines, "\n")
150 }
151
152 // WaitUp wacht op /healthz.
153 func (g *BlueGit) WaitUp(d time.Duration) {
154 g.t.Helper()
155 deadline := time.Now().Add(d)
156 for time.Now().Before(deadline) {
157 res, err := http.Get(g.URL + "/healthz")
158 if err == nil {
159 res.Body.Close()
160 if res.StatusCode == 200 {
161 return
162 }
163 }
164 time.Sleep(100 * time.Millisecond)
165 }
166 g.t.Fatalf("BlueGit %s kwam niet op:\n%s", g.URL, tail(g.log.String(), 40))
167 }
168
169 // API doet een verzoek met het token. path begint na /api/v1.
170 func (g *BlueGit) API(method, path string, in any) (int, []byte) {
171 g.t.Helper()
172 return g.APIWith(g.Token, method, path, in)
173 }
174
175 // APIWith gebruikt een ander token.
176 func (g *BlueGit) APIWith(tok, method, path string, in any) (int, []byte) {
177 g.t.Helper()
178 var body io.Reader
179 if in != nil {
180 b, _ := json.Marshal(in)
181 body = bytes.NewReader(b)
182 }
183 req, _ := http.NewRequest(method, g.URL+"/api/v1"+path, body)
184 req.Header.Set("Authorization", "Bearer "+tok)
185 if in != nil {
186 req.Header.Set("Content-Type", "application/json")
187 }
188 res, err := http.DefaultClient.Do(req)
189 if err != nil {
190 g.t.Fatalf("%s %s: %v", method, path, err)
191 }
192 defer res.Body.Close()
193 b, _ := io.ReadAll(res.Body)
194 return res.StatusCode, b
195 }
196
197 // MustAPI faalt bij een fout.
198 func (g *BlueGit) MustAPI(method, path string, in any) []byte {
199 g.t.Helper()
200 code, b := g.API(method, path, in)
201 if code >= 300 {
202 g.t.Fatalf("%s %s: %d %s", method, path, code, b)
203 }
204 return b
205 }
206
207 // NewKey maakt een Backupserver-Key via de beheer-API.
208 func (g *BlueGit) NewKey() string {
209 g.t.Helper()
210 var out struct{ Key string }
211 _ = json.Unmarshal(g.MustAPI("POST", "/admin/backup/key", nil), &out)
212 if !strings.HasPrefix(out.Key, "bgbk_") {
213 g.t.Fatalf("key %q", out.Key)
214 }
215 return out.Key
216 }
217
218 // Project maakt een project met één commit.
219 func (g *BlueGit) Project(name, file, content string) {
220 g.t.Helper()
221 g.MustAPI("POST", "/projects", map[string]any{"name": name, "visibility": "private"})
222 g.Commit(strings.ToLower(name), file, content, "create")
223 }
224
225 // Commit schrijft één bestand op master.
226 func (g *BlueGit) Commit(repo, file, content, action string) {
227 g.t.Helper()
228 g.MustAPI("POST", "/projects/tim/"+repo+"/repository/commits", map[string]any{
229 "branch": "master", "commit_message": "zet " + file,
230 "actions": []map[string]string{{"action": action, "file_path": file, "content": content}},
231 })
232 }
233
234 // File leest een bestand van master, of geeft de HTTP-code.
235 func (g *BlueGit) File(repo, file string) (int, string) {
236 g.t.Helper()
237 req, _ := http.NewRequest("GET", g.URL+"/api/v1/projects/tim/"+repo+"/repository/files/"+file+"?ref=master", nil)
238 req.Header.Set("Authorization", "Bearer "+g.Token)
239 res, err := http.DefaultClient.Do(req)
240 if err != nil {
241 g.t.Fatal(err)
242 }
243 defer res.Body.Close()
244 b, _ := io.ReadAll(res.Body)
245 return res.StatusCode, string(b)
246 }
247
248 // Issue maakt een issue.
249 func (g *BlueGit) Issue(repo, title string) {
250 g.t.Helper()
251 g.MustAPI("POST", "/repos/tim/"+repo+"/issues", map[string]any{"title": title})
252 }
253
254 // IssueTitles geeft alle issuetitels.
255 func (g *BlueGit) IssueTitles(repo string) []string {
256 g.t.Helper()
257 code, b := g.API("GET", "/repos/tim/"+repo+"/issues?state=all", nil)
258 if code != 200 {
259 g.t.Fatalf("issues: %d %s", code, b)
260 }
261 var list struct {
262 Issues []struct{ Title string } `json:"issues"`
263 }
264 _ = json.Unmarshal(b, &list)
265 var out []string
266 for _, i := range list.Issues {
267 out = append(out, i.Title)
268 }
269 return out
270 }
271
272 // ProjectCode is de HTTP-code van GET project.
273 func (g *BlueGit) ProjectCode(repo string) int {
274 g.t.Helper()
275 code, _ := g.API("GET", "/projects/tim/"+repo, nil)
276 return code
277 }
278
279 // BackupStatus is GET /admin/backup in BlueGit.
280 type BackupStatus struct {
281 InstanceID string `json:"instance_id"`
282 HasKey bool `json:"has_key"`
283 Connected bool `json:"connected"`
284 ServerURL string `json:"server_url"`
285 Archives []struct {
286 Name string `json:"name"`
287 Size int64 `json:"size"`
288 } `json:"archives"`
289 RemoteError string `json:"remote_error"`
290 }
291
292 func (g *BlueGit) BackupStatus() BackupStatus {
293 g.t.Helper()
294 var st BackupStatus
295 _ = json.Unmarshal(g.MustAPI("GET", "/admin/backup", nil), &st)
296 return st
297 }
298
299 // Session geeft een HTTP-client met sessiecookie (dev-login).
300 func (g *BlueGit) Session() *http.Client {
301 g.t.Helper()
302 jar, _ := cookiejar.New(nil)
303 hc := &http.Client{Jar: jar}
304 res, err := hc.Get(g.URL + "/login")
305 if err != nil {
306 g.t.Fatal(err)
307 }
308 res.Body.Close()
309 return hc
310 }
311
312 // Git draait git met het token als wachtwoord.
313 func (g *BlueGit) Git(dir string, args ...string) string {
314 g.t.Helper()
315 cmd := exec.Command("git", args...)
316 cmd.Dir = dir
317 cmd.Env = append(os.Environ(), "GIT_TERMINAL_PROMPT=0", "GIT_AUTHOR_NAME=it", "GIT_AUTHOR_EMAIL=it@example.invalid", "GIT_COMMITTER_NAME=it", "GIT_COMMITTER_EMAIL=it@example.invalid")
318 out, err := cmd.CombinedOutput()
319 if err != nil {
320 g.t.Fatalf("git %v: %v\n%s", args, err, out)
321 }
322 return string(out)
323 }
324
325 // RemoteURL is de clone-URL met token.
326 func (g *BlueGit) RemoteURL(repo string) string {
327 u, _ := url.Parse(g.URL)
328 u.User = url.UserPassword("tim", g.Token)
329 u.Path = "/tim/" + repo + ".git"
330 return u.String()
331 }
332
333 // Backup is één backup server in dit proces.
334 type Backup struct {
335 t *testing.T
336 Srv *server.Server
337 URL string
338 Dir string
339 Cfg config.Config
340 }
341
342 func startBackup(t *testing.T, mod func(*config.Config)) *Backup {
343 t.Helper()
344 port := freePort(t)
345 b := &Backup{t: t, URL: fmt.Sprintf("http://127.0.0.1:%d", port), Dir: t.TempDir()}
346 cfg := config.Config{Listen: fmt.Sprintf("127.0.0.1:%d", port), PublicURL: b.URL, DataDir: b.Dir}
347 // Snel genoeg voor tests; de standaardwaarden staan in config.Defaults.
348 cfg.MinSyncInterval.Duration = 50 * time.Millisecond
349 cfg.ArchiveInterval.Duration = time.Hour
350 cfg.FullSyncInterval.Duration = time.Hour
351 cfg.RateLimitKiB = -1
352 cfg.MinFreeMB = 1
353 if mod != nil {
354 mod(&cfg)
355 }
356 cfg.Defaults()
357 b.Cfg = cfg
358 srv, err := server.New(cfg, slog.New(slog.NewTextHandler(&testWriter{t}, &slog.HandlerOptions{Level: slog.LevelWarn})))
359 if err != nil {
360 t.Fatal(err)
361 }
362 b.Srv = srv
363 ln, err := net.Listen("tcp", cfg.Listen)
364 if err != nil {
365 t.Fatal(err)
366 }
367 hs := &http.Server{Handler: srv.Handler()}
368 ctx, cancel := context.WithCancel(context.Background())
369 go func() { _ = hs.Serve(ln) }()
370 srv.Run(ctx)
371 t.Cleanup(func() {
372 cancel()
373 _ = hs.Close()
374 })
375 return b
376 }
377
378 type testWriter struct{ t *testing.T }
379
380 func (w *testWriter) Write(p []byte) (int, error) {
381 w.t.Log(strings.TrimRight(string(p), "\n"))
382 return len(p), nil
383 }
384
385 // Admin doet een verzoek op de lokale beheer-API.
386 func (b *Backup) Admin(method, path string, in any) (int, []byte) {
387 b.t.Helper()
388 var body io.Reader
389 if in != nil {
390 raw, _ := json.Marshal(in)
391 body = bytes.NewReader(raw)
392 }
393 req, _ := http.NewRequest(method, b.URL+"/api/v1/admin"+path, body)
394 req.Header.Set("Authorization", "Bearer "+b.Srv.AdminToken())
395 res, err := http.DefaultClient.Do(req)
396 if err != nil {
397 b.t.Fatal(err)
398 }
399 defer res.Body.Close()
400 raw, _ := io.ReadAll(res.Body)
401 return res.StatusCode, raw
402 }
403
404 // Connect koppelt aan g zonder conflictkeuze; faalt bij een fout.
405 func (b *Backup) Connect(g *BlueGit, key string) {
406 b.t.Helper()
407 code, raw := b.Admin("POST", "/connect", server.ConnectRequest{URL: g.URL, Key: key})
408 if code != 200 {
409 b.t.Fatalf("connect: %d %s", code, raw)
410 }
411 }
412
413 // Sync synchroniseert nu.
414 func (b *Backup) Sync() {
415 b.t.Helper()
416 code, raw := b.Admin("POST", "/sync", nil)
417 if code != 200 {
418 b.t.Fatalf("sync: %d %s", code, raw)
419 }
420 }
421
422 // Archive maakt nu een archief en geeft de naam.
423 func (b *Backup) Archive() string {
424 b.t.Helper()
425 code, raw := b.Admin("POST", "/archive", nil)
426 if code != 201 {
427 b.t.Fatalf("archive: %d %s", code, raw)
428 }
429 var a struct{ Name string }
430 _ = json.Unmarshal(raw, &a)
431 return a.Name
432 }
433
434 // Mirror is het pad van een logisch bestand in de kopie.
435 func (b *Backup) Mirror(logical string) string {
436 return filepath.Join(b.Dir, "mirror", filepath.FromSlash(logical))
437 }
438
439 // Archives geeft de archiefnamen, nieuwste eerst.
440 func (b *Backup) Archives() []string {
441 b.t.Helper()
442 _, raw := b.Admin("GET", "/archives", nil)
443 var out struct {
444 Archives []struct{ Name string }
445 }
446 _ = json.Unmarshal(raw, &out)
447 var names []string
448 for _, a := range out.Archives {
449 names = append(names, a.Name)
450 }
451 return names
452 }
453
454 // Status leest de status.
455 func (b *Backup) Status() server.Status {
456 b.t.Helper()
457 _, raw := b.Admin("GET", "/status", nil)
458 var st server.Status
459 _ = json.Unmarshal(raw, &st)
460 return st
461 }
462
463 // Eventually herhaalt f tot hij true geeft.
464 func Eventually(t *testing.T, d time.Duration, what string, f func() bool) {
465 t.Helper()
466 deadline := time.Now().Add(d)
467 for time.Now().Before(deadline) {
468 if f() {
469 return
470 }
471 time.Sleep(50 * time.Millisecond)
472 }
473 t.Fatalf("na %v nog steeds niet: %s", d, what)
474 }
475
476 // gitLog geeft de onderwerpen van een bare repo in de kopie.
477 func gitLog(t *testing.T, gitDir string) string {
478 t.Helper()
479 out, err := exec.Command("git", "--git-dir", gitDir, "log", "--format=%s", "master").CombinedOutput()
480 if err != nil {
481 return "FOUT: " + string(out)
482 }
483 return string(out)
484 }
@@ -0,0 +1,484 @@
1//go:build 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}
69
70type syncBuf struct {
71 mu sync.Mutex
72 b bytes.Buffer
73}
74
75func (s *syncBuf) Write(p []byte) (int, error) {
76 s.mu.Lock()
77 defer s.mu.Unlock()
78 return s.b.Write(p)
79}
80
81func (s *syncBuf) String() string {
82 s.mu.Lock()
83 defer s.mu.Unlock()
84 return s.b.String()
85}
86
87func startBlueGit(t *testing.T) *BlueGit {
88 t.Helper()
89 bin := bluegitBin(t)
90 dir := t.TempDir()
91 port := freePort(t)
92 g := &BlueGit{t: t, Bin: bin, URL: fmt.Sprintf("http://127.0.0.1:%d", port),
93 State: filepath.Join(dir, "state"), Storage: filepath.Join(dir, "storage"), Config: filepath.Join(dir, "bluegit.yml"), log: &syncBuf{}}
94 _ = os.MkdirAll(g.Storage, 0o750)
95 cfg := fmt.Sprintf(`base_url: %s
96listen: 127.0.0.1:%d
97state_path: %s
98storage_path: %s
99auth:
100 mode: dev
101 dev_user: tim
102 dev_auth_id: 1
103 user_agent: bluegit-backup-it
104git:
105 binary: git
106 default_branch: master
107ssh:
108 enabled: false
109ci:
110 enabled: false
111`, g.URL, port, g.State, g.Storage)
112 if err := os.WriteFile(g.Config, []byte(cfg), 0o600); err != nil {
113 t.Fatal(err)
114 }
115 g.cmd = exec.Command(bin, "serve", "--config", g.Config)
116 g.cmd.Stdout, g.cmd.Stderr = g.log, g.log
117 if err := g.cmd.Start(); err != nil {
118 t.Fatal(err)
119 }
120 t.Cleanup(func() {
121 _ = g.cmd.Process.Kill()
122 _, _ = g.cmd.Process.Wait()
123 if t.Failed() {
124 t.Logf("BlueGit-log %s:\n%s", g.URL, tail(g.log.String(), 60))
125 }
126 })
127 g.WaitUp(20 * time.Second)
128 // Aanmelden maakt de eerste gebruiker (beheerder) aan.
129 jar, _ := cookiejar.New(nil)
130 hc := &http.Client{Jar: jar}
131 res, err := hc.Get(g.URL + "/login")
132 if err != nil {
133 t.Fatal(err)
134 }
135 res.Body.Close()
136 out, err := exec.Command(bin, "token", "create", "--config", g.Config, "--user", "tim", "--name", "it").CombinedOutput()
137 if err != nil {
138 t.Fatalf("token: %v %s", err, out)
139 }
140 g.Token = strings.TrimSpace(string(out))
141 return g
142}
143
144func tail(s string, n int) string {
145 lines := strings.Split(s, "\n")
146 if len(lines) > n {
147 lines = lines[len(lines)-n:]
148 }
149 return strings.Join(lines, "\n")
150}
151
152// WaitUp wacht op /healthz.
153func (g *BlueGit) WaitUp(d time.Duration) {
154 g.t.Helper()
155 deadline := time.Now().Add(d)
156 for time.Now().Before(deadline) {
157 res, err := http.Get(g.URL + "/healthz")
158 if err == nil {
159 res.Body.Close()
160 if res.StatusCode == 200 {
161 return
162 }
163 }
164 time.Sleep(100 * time.Millisecond)
165 }
166 g.t.Fatalf("BlueGit %s kwam niet op:\n%s", g.URL, tail(g.log.String(), 40))
167}
168
169// API doet een verzoek met het token. path begint na /api/v1.
170func (g *BlueGit) API(method, path string, in any) (int, []byte) {
171 g.t.Helper()
172 return g.APIWith(g.Token, method, path, in)
173}
174
175// APIWith gebruikt een ander token.
176func (g *BlueGit) APIWith(tok, method, path string, in any) (int, []byte) {
177 g.t.Helper()
178 var body io.Reader
179 if in != nil {
180 b, _ := json.Marshal(in)
181 body = bytes.NewReader(b)
182 }
183 req, _ := http.NewRequest(method, g.URL+"/api/v1"+path, body)
184 req.Header.Set("Authorization", "Bearer "+tok)
185 if in != nil {
186 req.Header.Set("Content-Type", "application/json")
187 }
188 res, err := http.DefaultClient.Do(req)
189 if err != nil {
190 g.t.Fatalf("%s %s: %v", method, path, err)
191 }
192 defer res.Body.Close()
193 b, _ := io.ReadAll(res.Body)
194 return res.StatusCode, b
195}
196
197// MustAPI faalt bij een fout.
198func (g *BlueGit) MustAPI(method, path string, in any) []byte {
199 g.t.Helper()
200 code, b := g.API(method, path, in)
201 if code >= 300 {
202 g.t.Fatalf("%s %s: %d %s", method, path, code, b)
203 }
204 return b
205}
206
207// NewKey maakt een Backupserver-Key via de beheer-API.
208func (g *BlueGit) NewKey() string {
209 g.t.Helper()
210 var out struct{ Key string }
211 _ = json.Unmarshal(g.MustAPI("POST", "/admin/backup/key", nil), &out)
212 if !strings.HasPrefix(out.Key, "bgbk_") {
213 g.t.Fatalf("key %q", out.Key)
214 }
215 return out.Key
216}
217
218// Project maakt een project met één commit.
219func (g *BlueGit) Project(name, file, content string) {
220 g.t.Helper()
221 g.MustAPI("POST", "/projects", map[string]any{"name": name, "visibility": "private"})
222 g.Commit(strings.ToLower(name), file, content, "create")
223}
224
225// Commit schrijft één bestand op master.
226func (g *BlueGit) Commit(repo, file, content, action string) {
227 g.t.Helper()
228 g.MustAPI("POST", "/projects/tim/"+repo+"/repository/commits", map[string]any{
229 "branch": "master", "commit_message": "zet " + file,
230 "actions": []map[string]string{{"action": action, "file_path": file, "content": content}},
231 })
232}
233
234// File leest een bestand van master, of geeft de HTTP-code.
235func (g *BlueGit) File(repo, file string) (int, string) {
236 g.t.Helper()
237 req, _ := http.NewRequest("GET", g.URL+"/api/v1/projects/tim/"+repo+"/repository/files/"+file+"?ref=master", nil)
238 req.Header.Set("Authorization", "Bearer "+g.Token)
239 res, err := http.DefaultClient.Do(req)
240 if err != nil {
241 g.t.Fatal(err)
242 }
243 defer res.Body.Close()
244 b, _ := io.ReadAll(res.Body)
245 return res.StatusCode, string(b)
246}
247
248// Issue maakt een issue.
249func (g *BlueGit) Issue(repo, title string) {
250 g.t.Helper()
251 g.MustAPI("POST", "/repos/tim/"+repo+"/issues", map[string]any{"title": title})
252}
253
254// IssueTitles geeft alle issuetitels.
255func (g *BlueGit) IssueTitles(repo string) []string {
256 g.t.Helper()
257 code, b := g.API("GET", "/repos/tim/"+repo+"/issues?state=all", nil)
258 if code != 200 {
259 g.t.Fatalf("issues: %d %s", code, b)
260 }
261 var list struct {
262 Issues []struct{ Title string } `json:"issues"`
263 }
264 _ = json.Unmarshal(b, &list)
265 var out []string
266 for _, i := range list.Issues {
267 out = append(out, i.Title)
268 }
269 return out
270}
271
272// ProjectCode is de HTTP-code van GET project.
273func (g *BlueGit) ProjectCode(repo string) int {
274 g.t.Helper()
275 code, _ := g.API("GET", "/projects/tim/"+repo, nil)
276 return code
277}
278
279// BackupStatus is GET /admin/backup in BlueGit.
280type BackupStatus struct {
281 InstanceID string `json:"instance_id"`
282 HasKey bool `json:"has_key"`
283 Connected bool `json:"connected"`
284 ServerURL string `json:"server_url"`
285 Archives []struct {
286 Name string `json:"name"`
287 Size int64 `json:"size"`
288 } `json:"archives"`
289 RemoteError string `json:"remote_error"`
290}
291
292func (g *BlueGit) BackupStatus() BackupStatus {
293 g.t.Helper()
294 var st BackupStatus
295 _ = json.Unmarshal(g.MustAPI("GET", "/admin/backup", nil), &st)
296 return st
297}
298
299// Session geeft een HTTP-client met sessiecookie (dev-login).
300func (g *BlueGit) Session() *http.Client {
301 g.t.Helper()
302 jar, _ := cookiejar.New(nil)
303 hc := &http.Client{Jar: jar}
304 res, err := hc.Get(g.URL + "/login")
305 if err != nil {
306 g.t.Fatal(err)
307 }
308 res.Body.Close()
309 return hc
310}
311
312// Git draait git met het token als wachtwoord.
313func (g *BlueGit) Git(dir string, args ...string) string {
314 g.t.Helper()
315 cmd := exec.Command("git", args...)
316 cmd.Dir = dir
317 cmd.Env = append(os.Environ(), "GIT_TERMINAL_PROMPT=0", "GIT_AUTHOR_NAME=it", "GIT_AUTHOR_EMAIL=it@example.invalid", "GIT_COMMITTER_NAME=it", "GIT_COMMITTER_EMAIL=it@example.invalid")
318 out, err := cmd.CombinedOutput()
319 if err != nil {
320 g.t.Fatalf("git %v: %v\n%s", args, err, out)
321 }
322 return string(out)
323}
324
325// RemoteURL is de clone-URL met token.
326func (g *BlueGit) RemoteURL(repo string) string {
327 u, _ := url.Parse(g.URL)
328 u.User = url.UserPassword("tim", g.Token)
329 u.Path = "/tim/" + repo + ".git"
330 return u.String()
331}
332
333// Backup is één backup server in dit proces.
334type Backup struct {
335 t *testing.T
336 Srv *server.Server
337 URL string
338 Dir string
339 Cfg config.Config
340}
341
342func startBackup(t *testing.T, mod func(*config.Config)) *Backup {
343 t.Helper()
344 port := freePort(t)
345 b := &Backup{t: t, URL: fmt.Sprintf("http://127.0.0.1:%d", port), Dir: t.TempDir()}
346 cfg := config.Config{Listen: fmt.Sprintf("127.0.0.1:%d", port), PublicURL: b.URL, DataDir: b.Dir}
347 // Snel genoeg voor tests; de standaardwaarden staan in config.Defaults.
348 cfg.MinSyncInterval.Duration = 50 * time.Millisecond
349 cfg.ArchiveInterval.Duration = time.Hour
350 cfg.FullSyncInterval.Duration = time.Hour
351 cfg.RateLimitKiB = -1
352 cfg.MinFreeMB = 1
353 if mod != nil {
354 mod(&cfg)
355 }
356 cfg.Defaults()
357 b.Cfg = cfg
358 srv, err := server.New(cfg, slog.New(slog.NewTextHandler(&testWriter{t}, &slog.HandlerOptions{Level: slog.LevelWarn})))
359 if err != nil {
360 t.Fatal(err)
361 }
362 b.Srv = srv
363 ln, err := net.Listen("tcp", cfg.Listen)
364 if err != nil {
365 t.Fatal(err)
366 }
367 hs := &http.Server{Handler: srv.Handler()}
368 ctx, cancel := context.WithCancel(context.Background())
369 go func() { _ = hs.Serve(ln) }()
370 srv.Run(ctx)
371 t.Cleanup(func() {
372 cancel()
373 _ = hs.Close()
374 })
375 return b
376}
377
378type testWriter struct{ t *testing.T }
379
380func (w *testWriter) Write(p []byte) (int, error) {
381 w.t.Log(strings.TrimRight(string(p), "\n"))
382 return len(p), nil
383}
384
385// Admin doet een verzoek op de lokale beheer-API.
386func (b *Backup) Admin(method, path string, in any) (int, []byte) {
387 b.t.Helper()
388 var body io.Reader
389 if in != nil {
390 raw, _ := json.Marshal(in)
391 body = bytes.NewReader(raw)
392 }
393 req, _ := http.NewRequest(method, b.URL+"/api/v1/admin"+path, body)
394 req.Header.Set("Authorization", "Bearer "+b.Srv.AdminToken())
395 res, err := http.DefaultClient.Do(req)
396 if err != nil {
397 b.t.Fatal(err)
398 }
399 defer res.Body.Close()
400 raw, _ := io.ReadAll(res.Body)
401 return res.StatusCode, raw
402}
403
404// Connect koppelt aan g zonder conflictkeuze; faalt bij een fout.
405func (b *Backup) Connect(g *BlueGit, key string) {
406 b.t.Helper()
407 code, raw := b.Admin("POST", "/connect", server.ConnectRequest{URL: g.URL, Key: key})
408 if code != 200 {
409 b.t.Fatalf("connect: %d %s", code, raw)
410 }
411}
412
413// Sync synchroniseert nu.
414func (b *Backup) Sync() {
415 b.t.Helper()
416 code, raw := b.Admin("POST", "/sync", nil)
417 if code != 200 {
418 b.t.Fatalf("sync: %d %s", code, raw)
419 }
420}
421
422// Archive maakt nu een archief en geeft de naam.
423func (b *Backup) Archive() string {
424 b.t.Helper()
425 code, raw := b.Admin("POST", "/archive", nil)
426 if code != 201 {
427 b.t.Fatalf("archive: %d %s", code, raw)
428 }
429 var a struct{ Name string }
430 _ = json.Unmarshal(raw, &a)
431 return a.Name
432}
433
434// Mirror is het pad van een logisch bestand in de kopie.
435func (b *Backup) Mirror(logical string) string {
436 return filepath.Join(b.Dir, "mirror", filepath.FromSlash(logical))
437}
438
439// Archives geeft de archiefnamen, nieuwste eerst.
440func (b *Backup) Archives() []string {
441 b.t.Helper()
442 _, raw := b.Admin("GET", "/archives", nil)
443 var out struct {
444 Archives []struct{ Name string }
445 }
446 _ = json.Unmarshal(raw, &out)
447 var names []string
448 for _, a := range out.Archives {
449 names = append(names, a.Name)
450 }
451 return names
452}
453
454// Status leest de status.
455func (b *Backup) Status() server.Status {
456 b.t.Helper()
457 _, raw := b.Admin("GET", "/status", nil)
458 var st server.Status
459 _ = json.Unmarshal(raw, &st)
460 return st
461}
462
463// Eventually herhaalt f tot hij true geeft.
464func Eventually(t *testing.T, d time.Duration, what string, f func() bool) {
465 t.Helper()
466 deadline := time.Now().Add(d)
467 for time.Now().Before(deadline) {
468 if f() {
469 return
470 }
471 time.Sleep(50 * time.Millisecond)
472 }
473 t.Fatalf("na %v nog steeds niet: %s", d, what)
474}
475
476// gitLog geeft de onderwerpen van een bare repo in de kopie.
477func gitLog(t *testing.T, gitDir string) string {
478 t.Helper()
479 out, err := exec.Command("git", "--git-dir", gitDir, "log", "--format=%s", "master").CombinedOutput()
480 if err != nil {
481 return "FOUT: " + string(out)
482 }
483 return string(out)
484}
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 +153 −0
@@ -0,0 +1,153 @@
1 // Package mirror houdt de draaiende kopie van één BlueGit bij.
2 package mirror
3
4 import (
5 "bytes"
6 "context"
7 "encoding/json"
8 "errors"
9 "fmt"
10 "io"
11 "net/http"
12 "net/url"
13 "strings"
14 "time"
15
16 "git.timfalken.com/timfa/bluegit-backup/internal/protocol"
17 "git.timfalken.com/timfa/bluegit-backup/internal/throttle"
18 )
19
20 // ErrGone betekent dat een bestand tussen manifest en download verdween.
21 var ErrGone = errors.New("bestand verdwenen")
22
23 // Remote is de backup-API van één BlueGit, met de Backupserver-Key.
24 type Remote struct {
25 URL string
26 Key string
27 HTTP *http.Client
28 Limiter *throttle.Limiter
29 }
30
31 func (r *Remote) client() *http.Client {
32 if r.HTTP != nil {
33 return r.HTTP
34 }
35 return &http.Client{Timeout: 0}
36 }
37
38 func (r *Remote) req(ctx context.Context, method, p string, body io.Reader) (*http.Response, error) {
39 req, err := http.NewRequestWithContext(ctx, method, strings.TrimRight(r.URL, "/")+p, body)
40 if err != nil {
41 return nil, err
42 }
43 req.Header.Set("Authorization", "Bearer "+r.Key)
44 req.Header.Set("User-Agent", "bluegit-backup")
45 resp, err := r.client().Do(req)
46 if err != nil {
47 return nil, err
48 }
49 if resp.StatusCode >= 300 {
50 defer resp.Body.Close()
51 raw, _ := io.ReadAll(io.LimitReader(resp.Body, 1<<16))
52 var e struct {
53 Error string `json:"error"`
54 }
55 _ = json.Unmarshal(raw, &e)
56 if e.Error == "" {
57 e.Error = strings.TrimSpace(string(raw))
58 }
59 if resp.StatusCode == http.StatusNotFound && strings.HasPrefix(p, "/api/v1/backup/file") {
60 return nil, ErrGone
61 }
62 return nil, &HTTPError{Status: resp.StatusCode, Msg: e.Error}
63 }
64 return resp, nil
65 }
66
67 // HTTPError is een foutantwoord van BlueGit.
68 type HTTPError struct {
69 Status int
70 Msg string
71 }
72
73 func (e *HTTPError) Error() string { return fmt.Sprintf("BlueGit HTTP %d: %s", e.Status, e.Msg) }
74
75 func (r *Remote) getJSON(ctx context.Context, p string, out any) error {
76 resp, err := r.req(ctx, http.MethodGet, p, nil)
77 if err != nil {
78 return err
79 }
80 defer resp.Body.Close()
81 return json.NewDecoder(resp.Body).Decode(out)
82 }
83
84 // Info vraagt het instance-id op en controleert zo ook de key.
85 func (r *Remote) Info(ctx context.Context) (protocol.Info, error) {
86 var out protocol.Info
87 err := r.getJSON(ctx, "/api/v1/backup/info", &out)
88 return out, err
89 }
90
91 // Connect vertelt BlueGit waar deze server bereikbaar is.
92 func (r *Remote) Connect(ctx context.Context, publicURL, serverID string) error {
93 b, _ := json.Marshal(map[string]string{"server_url": publicURL, "server_id": serverID})
94 resp, err := r.req(ctx, http.MethodPost, "/api/v1/backup/connect", bytes.NewReader(b))
95 if err != nil {
96 return err
97 }
98 resp.Body.Close()
99 return nil
100 }
101
102 // Manifest vraagt de volledige lijst op. BlueGit maakt daarbij een nieuwe
103 // databasekopie.
104 func (r *Remote) Manifest(ctx context.Context) (protocol.Manifest, error) {
105 var out protocol.Manifest
106 err := r.getJSON(ctx, "/api/v1/backup/manifest", &out)
107 return out, err
108 }
109
110 // Fetch opent één bestand, begrensd door de limiter.
111 func (r *Remote) Fetch(ctx context.Context, logical string) (io.ReadCloser, error) {
112 resp, err := r.req(ctx, http.MethodGet, "/api/v1/backup/file?path="+url.QueryEscape(logical), nil)
113 if err != nil {
114 return nil, err
115 }
116 return struct {
117 io.Reader
118 io.Closer
119 }{r.Limiter.Reader(ctx, resp.Body), resp.Body}, nil
120 }
121
122 // Restore stuurt een tar.gz naar BlueGit. BlueGit herstart daarna.
123 func (r *Remote) Restore(ctx context.Context, body io.Reader) error {
124 resp, err := r.req(ctx, http.MethodPost, "/api/v1/backup/restore", body)
125 if err != nil {
126 return err
127 }
128 resp.Body.Close()
129 return nil
130 }
131
132 // WaitUp wacht tot BlueGit na een herstart weer antwoordt.
133 func (r *Remote) WaitUp(ctx context.Context, timeout time.Duration) error {
134 deadline := time.Now().Add(timeout)
135 // Eerst kort wachten: BlueGit herstart pas na zijn 202.
136 time.Sleep(500 * time.Millisecond)
137 for {
138 c, cancel := context.WithTimeout(ctx, 3*time.Second)
139 _, err := r.Info(c)
140 cancel()
141 if err == nil {
142 return nil
143 }
144 if time.Now().After(deadline) {
145 return fmt.Errorf("BlueGit kwam niet terug: %w", err)
146 }
147 select {
148 case <-ctx.Done():
149 return ctx.Err()
150 case <-time.After(300 * time.Millisecond):
151 }
152 }
153 }
@@ -0,0 +1,153 @@
1// Package mirror houdt de draaiende kopie van één BlueGit bij.
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}
30
31func (r *Remote) client() *http.Client {
32 if r.HTTP != nil {
33 return r.HTTP
34 }
35 return &http.Client{Timeout: 0}
36}
37
38func (r *Remote) req(ctx context.Context, method, p string, body io.Reader) (*http.Response, error) {
39 req, err := http.NewRequestWithContext(ctx, method, strings.TrimRight(r.URL, "/")+p, body)
40 if err != nil {
41 return nil, err
42 }
43 req.Header.Set("Authorization", "Bearer "+r.Key)
44 req.Header.Set("User-Agent", "bluegit-backup")
45 resp, err := r.client().Do(req)
46 if err != nil {
47 return nil, err
48 }
49 if resp.StatusCode >= 300 {
50 defer resp.Body.Close()
51 raw, _ := io.ReadAll(io.LimitReader(resp.Body, 1<<16))
52 var e struct {
53 Error string `json:"error"`
54 }
55 _ = json.Unmarshal(raw, &e)
56 if e.Error == "" {
57 e.Error = strings.TrimSpace(string(raw))
58 }
59 if resp.StatusCode == http.StatusNotFound && strings.HasPrefix(p, "/api/v1/backup/file") {
60 return nil, ErrGone
61 }
62 return nil, &HTTPError{Status: resp.StatusCode, Msg: e.Error}
63 }
64 return resp, nil
65}
66
67// HTTPError is een foutantwoord van BlueGit.
68type HTTPError struct {
69 Status int
70 Msg string
71}
72
73func (e *HTTPError) Error() string { return fmt.Sprintf("BlueGit HTTP %d: %s", e.Status, e.Msg) }
74
75func (r *Remote) getJSON(ctx context.Context, p string, out any) error {
76 resp, err := r.req(ctx, http.MethodGet, p, nil)
77 if err != nil {
78 return err
79 }
80 defer resp.Body.Close()
81 return json.NewDecoder(resp.Body).Decode(out)
82}
83
84// Info vraagt het instance-id op en controleert zo ook de key.
85func (r *Remote) Info(ctx context.Context) (protocol.Info, error) {
86 var out protocol.Info
87 err := r.getJSON(ctx, "/api/v1/backup/info", &out)
88 return out, err
89}
90
91// Connect vertelt BlueGit waar deze server bereikbaar is.
92func (r *Remote) Connect(ctx context.Context, publicURL, serverID string) error {
93 b, _ := json.Marshal(map[string]string{"server_url": publicURL, "server_id": serverID})
94 resp, err := r.req(ctx, http.MethodPost, "/api/v1/backup/connect", bytes.NewReader(b))
95 if err != nil {
96 return err
97 }
98 resp.Body.Close()
99 return nil
100}
101
102// Manifest vraagt de volledige lijst op. BlueGit maakt daarbij een nieuwe
103// databasekopie.
104func (r *Remote) Manifest(ctx context.Context) (protocol.Manifest, error) {
105 var out protocol.Manifest
106 err := r.getJSON(ctx, "/api/v1/backup/manifest", &out)
107 return out, err
108}
109
110// Fetch opent één bestand, begrensd door de limiter.
111func (r *Remote) Fetch(ctx context.Context, logical string) (io.ReadCloser, error) {
112 resp, err := r.req(ctx, http.MethodGet, "/api/v1/backup/file?path="+url.QueryEscape(logical), nil)
113 if err != nil {
114 return nil, err
115 }
116 return struct {
117 io.Reader
118 io.Closer
119 }{r.Limiter.Reader(ctx, resp.Body), resp.Body}, nil
120}
121
122// Restore stuurt een tar.gz naar BlueGit. BlueGit herstart daarna.
123func (r *Remote) Restore(ctx context.Context, body io.Reader) error {
124 resp, err := r.req(ctx, http.MethodPost, "/api/v1/backup/restore", body)
125 if err != nil {
126 return err
127 }
128 resp.Body.Close()
129 return nil
130}
131
132// WaitUp wacht tot BlueGit na een herstart weer antwoordt.
133func (r *Remote) WaitUp(ctx context.Context, timeout time.Duration) error {
134 deadline := time.Now().Add(timeout)
135 // Eerst kort wachten: BlueGit herstart pas na zijn 202.
136 time.Sleep(500 * time.Millisecond)
137 for {
138 c, cancel := context.WithTimeout(ctx, 3*time.Second)
139 _, err := r.Info(c)
140 cancel()
141 if err == nil {
142 return nil
143 }
144 if time.Now().After(deadline) {
145 return fmt.Errorf("BlueGit kwam niet terug: %w", err)
146 }
147 select {
148 case <-ctx.Done():
149 return ctx.Err()
150 case <-time.After(300 * time.Millisecond):
151 }
152 }
153}
internal/backupserver/protocol/protocol.go added +150 −0
@@ -0,0 +1,150 @@
1 // Package protocol is het draadformaat tussen BlueGit en bluegit-backup.
2 // Het moet gelijk blijven aan internal/backup in BlueGit (docs/BACKUP.md).
3 package protocol
4
5 import (
6 "crypto/hmac"
7 "crypto/sha256"
8 "encoding/hex"
9 "errors"
10 "net/http"
11 "path"
12 "strconv"
13 "strings"
14 "time"
15 )
16
17 // KeyPrefix staat voor elke Backupserver-Key.
18 const KeyPrefix = "bgbk_"
19
20 // Koppen van een ondertekend verzoek van BlueGit.
21 const (
22 HeaderInstance = "X-BlueGit-Instance"
23 HeaderTimestamp = "X-BlueGit-Timestamp"
24 HeaderSignature = "X-BlueGit-Signature"
25 )
26
27 // MaxSkew is hoe ver de klokken uit elkaar mogen lopen.
28 const MaxSkew = 5 * time.Minute
29
30 // DBPath is het logische pad van de databasekopie.
31 const DBPath = "state/bluegit.db"
32
33 // Entry is één bestand in het manifest van BlueGit.
34 type Entry struct {
35 Path string `json:"path"`
36 Size int64 `json:"size"`
37 MTime int64 `json:"mtime"`
38 Mode uint32 `json:"mode"`
39 SHA256 string `json:"sha256,omitempty"`
40 }
41
42 // Manifest is de volledige lijst op één moment.
43 type Manifest struct {
44 Instance string `json:"instance_id"`
45 CreatedAt time.Time `json:"created_at"`
46 Files []Entry `json:"files"`
47 }
48
49 // Info is GET /api/v1/backup/info.
50 type Info struct {
51 InstanceID string `json:"instance_id"`
52 BaseURL string `json:"base_url"`
53 ServerURL string `json:"server_url"`
54 ServerID string `json:"server_id"`
55 HasStorage bool `json:"has_storage"`
56 }
57
58 // SigningSecret leidt het HMAC-geheim af uit de key.
59 func SigningSecret(key string) string {
60 s := sha256.Sum256([]byte("bluegit-backup-sign:" + key))
61 return hex.EncodeToString(s[:])
62 }
63
64 // Signature is hex(HMAC-SHA256(secret, METHOD \n PATH \n TS \n sha256hex(body))).
65 func Signature(secret, method, p, ts string, body []byte) string {
66 sum := sha256.Sum256(body)
67 mac := hmac.New(sha256.New, []byte(secret))
68 mac.Write([]byte(strings.ToUpper(method) + "\n" + p + "\n" + ts + "\n" + hex.EncodeToString(sum[:])))
69 return hex.EncodeToString(mac.Sum(nil))
70 }
71
72 // Sign zet de koppen op een uitgaand verzoek (gebruikt in tests en door
73 // BlueGit zelf).
74 func Sign(req *http.Request, secret, instance string, body []byte, now time.Time) {
75 ts := strconv.FormatInt(now.Unix(), 10)
76 req.Header.Set(HeaderInstance, instance)
77 req.Header.Set(HeaderTimestamp, ts)
78 req.Header.Set(HeaderSignature, Signature(secret, req.Method, req.URL.Path, ts, body))
79 }
80
81 // Verify controleert een binnenkomend ondertekend verzoek.
82 func Verify(r *http.Request, secret string, body []byte, now time.Time) error {
83 ts := r.Header.Get(HeaderTimestamp)
84 n, err := strconv.ParseInt(ts, 10, 64)
85 if err != nil {
86 return errors.New("timestamp ontbreekt")
87 }
88 d := now.Sub(time.Unix(n, 0))
89 if d < 0 {
90 d = -d
91 }
92 if d > MaxSkew {
93 return errors.New("timestamp te oud of in de toekomst")
94 }
95 want := Signature(secret, r.Method, r.URL.Path, ts, body)
96 if !hmac.Equal([]byte(want), []byte(r.Header.Get(HeaderSignature))) {
97 return errors.New("handtekening klopt niet")
98 }
99 return nil
100 }
101
102 var (
103 stateFiles = []string{"bluegit.db", "secret.key"}
104 stateDirs = []string{"ssh", "logos", "avatars"}
105 dataDirs = []string{"repos", "releases", "artifacts"}
106 )
107
108 // CleanLogical controleert een logisch pad zoals BlueGit dat doet. Een pad
109 // buiten de bekende mappen komt nooit in de kopie.
110 func CleanLogical(p string) (string, bool) {
111 if p == "" || strings.Contains(p, "\\") || strings.ContainsRune(p, 0) || strings.HasPrefix(p, "/") {
112 return "", false
113 }
114 c := path.Clean(p)
115 if c != p || c == "." {
116 return "", false
117 }
118 parts := strings.Split(c, "/")
119 for _, part := range parts {
120 if part == ".." || part == "." || part == "" {
121 return "", false
122 }
123 }
124 if len(parts) < 2 {
125 return "", false
126 }
127 switch parts[0] {
128 case "state":
129 if len(parts) == 2 && has(stateFiles, parts[1]) {
130 return c, true
131 }
132 if len(parts) >= 3 && has(stateDirs, parts[1]) {
133 return c, true
134 }
135 case "data":
136 if len(parts) >= 3 && has(dataDirs, parts[1]) && parts[2] != ".incoming" {
137 return c, true
138 }
139 }
140 return "", false
141 }
142
143 func has(list []string, v string) bool {
144 for _, x := range list {
145 if x == v {
146 return true
147 }
148 }
149 return false
150 }
@@ -0,0 +1,150 @@
1// Package protocol is het draadformaat tussen BlueGit en bluegit-backup.
2// Het moet gelijk blijven aan internal/backup in BlueGit (docs/BACKUP.md).
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}
57
58// SigningSecret leidt het HMAC-geheim af uit de key.
59func SigningSecret(key string) string {
60 s := sha256.Sum256([]byte("bluegit-backup-sign:" + key))
61 return hex.EncodeToString(s[:])
62}
63
64// Signature is hex(HMAC-SHA256(secret, METHOD \n PATH \n TS \n sha256hex(body))).
65func Signature(secret, method, p, ts string, body []byte) string {
66 sum := sha256.Sum256(body)
67 mac := hmac.New(sha256.New, []byte(secret))
68 mac.Write([]byte(strings.ToUpper(method) + "\n" + p + "\n" + ts + "\n" + hex.EncodeToString(sum[:])))
69 return hex.EncodeToString(mac.Sum(nil))
70}
71
72// Sign zet de koppen op een uitgaand verzoek (gebruikt in tests en door
73// BlueGit zelf).
74func Sign(req *http.Request, secret, instance string, body []byte, now time.Time) {
75 ts := strconv.FormatInt(now.Unix(), 10)
76 req.Header.Set(HeaderInstance, instance)
77 req.Header.Set(HeaderTimestamp, ts)
78 req.Header.Set(HeaderSignature, Signature(secret, req.Method, req.URL.Path, ts, body))
79}
80
81// Verify controleert een binnenkomend ondertekend verzoek.
82func Verify(r *http.Request, secret string, body []byte, now time.Time) error {
83 ts := r.Header.Get(HeaderTimestamp)
84 n, err := strconv.ParseInt(ts, 10, 64)
85 if err != nil {
86 return errors.New("timestamp ontbreekt")
87 }
88 d := now.Sub(time.Unix(n, 0))
89 if d < 0 {
90 d = -d
91 }
92 if d > MaxSkew {
93 return errors.New("timestamp te oud of in de toekomst")
94 }
95 want := Signature(secret, r.Method, r.URL.Path, ts, body)
96 if !hmac.Equal([]byte(want), []byte(r.Header.Get(HeaderSignature))) {
97 return errors.New("handtekening klopt niet")
98 }
99 return nil
100}
101
102var (
103 stateFiles = []string{"bluegit.db", "secret.key"}
104 stateDirs = []string{"ssh", "logos", "avatars"}
105 dataDirs = []string{"repos", "releases", "artifacts"}
106)
107
108// CleanLogical controleert een logisch pad zoals BlueGit dat doet. Een pad
109// buiten de bekende mappen komt nooit in de kopie.
110func CleanLogical(p string) (string, bool) {
111 if p == "" || strings.Contains(p, "\\") || strings.ContainsRune(p, 0) || strings.HasPrefix(p, "/") {
112 return "", false
113 }
114 c := path.Clean(p)
115 if c != p || c == "." {
116 return "", false
117 }
118 parts := strings.Split(c, "/")
119 for _, part := range parts {
120 if part == ".." || part == "." || part == "" {
121 return "", false
122 }
123 }
124 if len(parts) < 2 {
125 return "", false
126 }
127 switch parts[0] {
128 case "state":
129 if len(parts) == 2 && has(stateFiles, parts[1]) {
130 return c, true
131 }
132 if len(parts) >= 3 && has(stateDirs, parts[1]) {
133 return c, true
134 }
135 case "data":
136 if len(parts) >= 3 && has(dataDirs, parts[1]) && parts[2] != ".incoming" {
137 return c, true
138 }
139 }
140 return "", false
141}
142
143func has(list []string, v string) bool {
144 for _, x := range list {
145 if x == v {
146 return true
147 }
148 }
149 return false
150}
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/server.go added +741 −0
@@ -0,0 +1,741 @@
1 // Package server is de backup server: sync, archieven, de API voor BlueGit
2 // en de lokale beheer-API.
3 package server
4
5 import (
6 "context"
7 "crypto/subtle"
8 "encoding/json"
9 "errors"
10 "fmt"
11 "io"
12 "log/slog"
13 "net/http"
14 "os"
15 "path/filepath"
16 "strings"
17 "sync"
18 "time"
19
20 "git.timfalken.com/timfa/bluegit-backup/internal/archive"
21 "git.timfalken.com/timfa/bluegit-backup/internal/config"
22 "git.timfalken.com/timfa/bluegit-backup/internal/mirror"
23 "git.timfalken.com/timfa/bluegit-backup/internal/protocol"
24 "git.timfalken.com/timfa/bluegit-backup/internal/throttle"
25 )
26
27 // Version wordt bij het bouwen gezet (-ldflags -X).
28 var Version = "dev"
29
30 // Server is één backup server voor één BlueGit.
31 type Server struct {
32 Cfg config.Config
33 Log *slog.Logger
34 // Now is de klok (tests).
35 Now func() time.Time
36 // HTTP is de client richting BlueGit (tests).
37 HTTP *http.Client
38
39 adminToken string
40 serverID string
41 limiter *throttle.Limiter
42 mirror *mirror.Mirror
43 archives *archive.Store
44
45 // work beschermt de kopie: sync, archiveren, rollback en koppelen
46 // gebeuren nooit tegelijk.
47 work sync.Mutex
48
49 mu sync.Mutex
50 state State
51 lastSync time.Time
52 lastSyncErr string
53 lastStats mirror.Stats
54 syncs int
55 notifies int
56 lastArchive time.Time
57 archiveErr string
58 rollback RollbackStatus
59
60 kick chan struct{}
61 }
62
63 // RollbackStatus is de stand van de laatste rollback of restore.
64 type RollbackStatus struct {
65 State string `json:"state"` // idle | running | done | failed
66 Archive string `json:"archive,omitempty"`
67 Error string `json:"error,omitempty"`
68 At time.Time `json:"at,omitempty"`
69 }
70
71 // New zet de mappen klaar en leest de koppeling.
72 func New(cfg config.Config, log *slog.Logger) (*Server, error) {
73 if log == nil {
74 log = slog.New(slog.NewTextHandler(io.Discard, nil))
75 }
76 if err := os.MkdirAll(cfg.DataDir, 0o750); err != nil {
77 return nil, err
78 }
79 s := &Server{Cfg: cfg, Log: log, Now: time.Now, kick: make(chan struct{}, 1)}
80 var err error
81 if s.adminToken, err = secretFile(cfg.DataDir, "admin.token", "bba_"); err != nil {
82 return nil, err
83 }
84 if s.serverID, err = secretFile(cfg.DataDir, "server_id", ""); err != nil {
85 return nil, err
86 }
87 if s.state, err = loadState(cfg.DataDir); err != nil {
88 return nil, err
89 }
90 s.limiter = throttle.New(cfg.RateLimitKiB << 10)
91 s.mirror = &mirror.Mirror{Dir: filepath.Join(cfg.DataDir, "mirror"), Index: filepath.Join(cfg.DataDir, "mirror.index.json")}
92 s.archives = &archive.Store{Dir: filepath.Join(cfg.DataDir, "archives")}
93 _ = os.RemoveAll(filepath.Join(cfg.DataDir, "tmp"))
94 if list, _ := s.archives.List(); len(list) > 0 {
95 s.lastArchive = list[0].CreatedAt
96 }
97 s.rollback.State = "idle"
98 return s, nil
99 }
100
101 // SetFree vervangt de vrije-ruimtemeting (tests).
102 func (s *Server) SetFree(f func(string) (uint64, error)) { s.archives.Free = f }
103
104 // AdminToken is het lokale beheertoken.
105 func (s *Server) AdminToken() string { return s.adminToken }
106
107 func (s *Server) now() time.Time { return s.Now() }
108
109 func (s *Server) remote(st State) *mirror.Remote {
110 return &mirror.Remote{URL: st.BlueGitURL, Key: st.Key, HTTP: s.HTTP, Limiter: s.limiter}
111 }
112
113 func (s *Server) getState() State {
114 s.mu.Lock()
115 defer s.mu.Unlock()
116 return s.state
117 }
118
119 // Run start de achtergrondtaken tot ctx klaar is.
120 func (s *Server) Run(ctx context.Context) {
121 go s.syncLoop(ctx)
122 go s.archiveLoop(ctx)
123 }
124
125 // Kick vraagt om een sync (na een melding).
126 func (s *Server) Kick() {
127 select {
128 case s.kick <- struct{}{}:
129 default:
130 }
131 }
132
133 func (s *Server) syncLoop(ctx context.Context) {
134 full := time.NewTicker(s.Cfg.FullSyncInterval.Duration)
135 defer full.Stop()
136 s.Kick() // meteen na de start
137 for {
138 select {
139 case <-ctx.Done():
140 return
141 case <-full.C:
142 case <-s.kick:
143 }
144 s.mu.Lock()
145 wait := s.Cfg.MinSyncInterval.Duration - s.now().Sub(s.lastSync)
146 s.mu.Unlock()
147 if wait > 0 {
148 select {
149 case <-ctx.Done():
150 return
151 case <-time.After(wait):
152 }
153 }
154 // Meldingen die in de tussentijd binnenkwamen, zitten in deze sync.
155 select {
156 case <-s.kick:
157 default:
158 }
159 _, _ = s.SyncNow(ctx)
160 }
161 }
162
163 // SyncNow synchroniseert één keer.
164 func (s *Server) SyncNow(ctx context.Context) (mirror.Stats, error) {
165 st := s.getState()
166 if !st.Connected() {
167 return mirror.Stats{}, errors.New("geen BlueGit gekoppeld")
168 }
169 s.work.Lock()
170 defer s.work.Unlock()
171 st = s.getState()
172 if !st.Connected() {
173 return mirror.Stats{}, errors.New("geen BlueGit gekoppeld")
174 }
175 stats, err := s.mirror.Sync(ctx, s.remote(st))
176 s.mu.Lock()
177 s.lastSync = s.now()
178 s.syncs++
179 s.lastStats = stats
180 if err != nil {
181 s.lastSyncErr = err.Error()
182 } else {
183 s.lastSyncErr = ""
184 }
185 s.mu.Unlock()
186 if err != nil {
187 s.Log.Warn("sync mislukt", "err", err)
188 } else if stats.Downloaded > 0 || stats.Deleted > 0 {
189 s.Log.Info("sync", "files", stats.Files, "downloaded", stats.Downloaded, "bytes", stats.Bytes, "deleted", stats.Deleted)
190 }
191 return stats, err
192 }
193
194 func (s *Server) archiveLoop(ctx context.Context) {
195 t := time.NewTicker(s.tick())
196 defer t.Stop()
197 for {
198 select {
199 case <-ctx.Done():
200 return
201 case <-t.C:
202 }
203 s.mu.Lock()
204 due := s.now().Sub(s.lastArchive) >= s.Cfg.ArchiveInterval.Duration
205 synced := !s.lastSync.IsZero() && s.lastSyncErr == ""
206 s.mu.Unlock()
207 if due && synced {
208 if _, err := s.ArchiveNow(); err != nil {
209 s.Log.Warn("archief mislukt", "err", err)
210 }
211 }
212 if _, err := s.Prune(); err != nil {
213 s.Log.Warn("opruimen mislukt", "err", err)
214 }
215 }
216 }
217
218 // tick is hoe vaak de archieflus kijkt: een minuut, of korter bij een kort interval.
219 func (s *Server) tick() time.Duration {
220 d := s.Cfg.ArchiveInterval.Duration / 4
221 if d > time.Minute {
222 d = time.Minute
223 }
224 if d < 100*time.Millisecond {
225 d = 100 * time.Millisecond
226 }
227 return d
228 }
229
230 // ArchiveNow comprimeert de hele kopie tot een nieuw archief.
231 func (s *Server) ArchiveNow() (archive.Archive, error) {
232 s.work.Lock()
233 defer s.work.Unlock()
234 if s.mirror.Empty() {
235 return archive.Archive{}, errors.New("de kopie is nog leeg")
236 }
237 now := s.now()
238 a, removed, err := s.archives.Create(s.mirror.Dir, now, s.mirror.Size(), s.minFree())
239 s.mu.Lock()
240 if err != nil {
241 s.archiveErr = err.Error()
242 } else {
243 s.archiveErr = ""
244 s.lastArchive = now
245 }
246 s.mu.Unlock()
247 for _, r := range removed {
248 s.Log.Info("archief verwijderd: schijf vol", "archive", r)
249 }
250 if err != nil {
251 return a, err
252 }
253 s.Log.Info("archief gemaakt", "archive", a.Name, "bytes", a.Size)
254 if pr, err := s.archives.Prune(now, s.Cfg.RetentionDays, s.minFree()); err == nil {
255 for _, r := range pr {
256 s.Log.Info("archief verwijderd", "archive", r)
257 }
258 }
259 return a, nil
260 }
261
262 func (s *Server) minFree() uint64 { return uint64(s.Cfg.MinFreeMB) << 20 }
263
264 // Prune past de bewaarregels toe.
265 func (s *Server) Prune() ([]string, error) {
266 s.work.Lock()
267 defer s.work.Unlock()
268 removed, err := s.archives.Prune(s.now(), s.Cfg.RetentionDays, s.minFree())
269 for _, r := range removed {
270 s.Log.Info("archief verwijderd", "archive", r)
271 }
272 return removed, err
273 }
274
275 // ---------- HTTP ----------
276
277 // Handler is de HTTP-API.
278 func (s *Server) Handler() http.Handler {
279 mux := http.NewServeMux()
280 mux.HandleFunc("GET /healthz", func(w http.ResponseWriter, r *http.Request) { _, _ = w.Write([]byte("ok\n")) })
281 // Van BlueGit, ondertekend.
282 mux.HandleFunc("POST /api/v1/notify", s.signed(s.apiNotify))
283 mux.HandleFunc("GET /api/v1/archives", s.signed(s.apiArchives))
284 mux.HandleFunc("GET /api/v1/status", s.signed(s.apiStatus))
285 mux.HandleFunc("POST /api/v1/rollback", s.signed(s.apiRollback))
286 // Lokaal beheer, met admin.token.
287 mux.HandleFunc("GET /api/v1/admin/status", s.admin(s.apiStatus))
288 mux.HandleFunc("GET /api/v1/admin/archives", s.admin(s.apiArchives))
289 mux.HandleFunc("POST /api/v1/admin/connect", s.admin(s.apiConnect))
290 mux.HandleFunc("POST /api/v1/admin/sync", s.admin(s.apiSync))
291 mux.HandleFunc("POST /api/v1/admin/archive", s.admin(s.apiArchiveNow))
292 mux.HandleFunc("POST /api/v1/admin/prune", s.admin(s.apiPrune))
293 mux.HandleFunc("POST /api/v1/admin/self-update", s.selfUpdate)
294 return mux
295 }
296
297 func writeJSON(w http.ResponseWriter, code int, v any) {
298 w.Header().Set("Content-Type", "application/json")
299 w.Header().Set("Cache-Control", "no-store")
300 w.WriteHeader(code)
301 if v != nil {
302 _ = json.NewEncoder(w).Encode(v)
303 }
304 }
305
306 func writeErr(w http.ResponseWriter, code int, msg string) {
307 writeJSON(w, code, map[string]string{"error": msg})
308 }
309
310 type ctxBody struct{}
311
312 // signed controleert de HMAC-handtekening van de gekoppelde BlueGit.
313 func (s *Server) signed(h http.HandlerFunc) http.HandlerFunc {
314 return func(w http.ResponseWriter, r *http.Request) {
315 st := s.getState()
316 if !st.Connected() {
317 writeErr(w, http.StatusUnauthorized, "niet gekoppeld")
318 return
319 }
320 body, err := io.ReadAll(io.LimitReader(r.Body, 1<<20))
321 if err != nil {
322 writeErr(w, 400, "body")
323 return
324 }
325 if r.Header.Get(protocol.HeaderInstance) != st.InstanceID {
326 writeErr(w, http.StatusUnauthorized, "andere BlueGit-instantie")
327 return
328 }
329 if err := protocol.Verify(r, protocol.SigningSecret(st.Key), body, s.now()); err != nil {
330 writeErr(w, http.StatusUnauthorized, err.Error())
331 return
332 }
333 r = r.WithContext(context.WithValue(r.Context(), ctxBody{}, body))
334 h(w, r)
335 }
336 }
337
338 func bodyOf(r *http.Request) []byte {
339 if b, ok := r.Context().Value(ctxBody{}).([]byte); ok {
340 return b
341 }
342 b, _ := io.ReadAll(io.LimitReader(r.Body, 1<<20))
343 return b
344 }
345
346 func (s *Server) admin(h http.HandlerFunc) http.HandlerFunc {
347 return func(w http.ResponseWriter, r *http.Request) {
348 tok := strings.TrimSpace(strings.TrimPrefix(r.Header.Get("Authorization"), "Bearer "))
349 if subtle.ConstantTimeCompare([]byte(tok), []byte(s.adminToken)) != 1 {
350 writeErr(w, http.StatusUnauthorized, "admin.token nodig")
351 return
352 }
353 h(w, r)
354 }
355 }
356
357 func (s *Server) apiNotify(w http.ResponseWriter, r *http.Request) {
358 s.mu.Lock()
359 s.notifies++
360 s.mu.Unlock()
361 s.Kick()
362 w.WriteHeader(http.StatusNoContent)
363 }
364
365 func (s *Server) apiArchives(w http.ResponseWriter, r *http.Request) {
366 list, err := s.archives.List()
367 if err != nil {
368 writeErr(w, 500, err.Error())
369 return
370 }
371 writeJSON(w, 200, map[string]any{"archives": list})
372 }
373
374 // Status is wat GET /api/v1/status en de CLI tonen.
375 type Status struct {
376 Version string `json:"version"`
377 ServerID string `json:"server_id"`
378 BlueGitURL string `json:"bluegit_url,omitempty"`
379 InstanceID string `json:"instance_id,omitempty"`
380 Connected bool `json:"connected"`
381 LastSync time.Time `json:"last_sync,omitempty"`
382 SyncError string `json:"sync_error,omitempty"`
383 LastStats mirror.Stats `json:"last_stats"`
384 Syncs int `json:"syncs"`
385 Notifies int `json:"notifies"`
386 MirrorBytes int64 `json:"mirror_bytes"`
387 Archives int `json:"archives"`
388 LastArchive time.Time `json:"last_archive,omitempty"`
389 ArchiveError string `json:"archive_error,omitempty"`
390 Interval string `json:"archive_interval"`
391 RetentionDays int `json:"retention_days"`
392 RateLimitKiB int64 `json:"rate_limit_kib"`
393 Rollback RollbackStatus `json:"rollback"`
394 }
395
396 // Status geeft de huidige stand.
397 func (s *Server) Status() Status {
398 list, _ := s.archives.List()
399 s.mu.Lock()
400 defer s.mu.Unlock()
401 return Status{
402 Version: Version, ServerID: s.serverID, BlueGitURL: s.state.BlueGitURL, InstanceID: s.state.InstanceID,
403 Connected: s.state.Connected(), LastSync: s.lastSync, SyncError: s.lastSyncErr, LastStats: s.lastStats,
404 Syncs: s.syncs, Notifies: s.notifies, MirrorBytes: s.mirror.Size(), Archives: len(list),
405 LastArchive: s.lastArchive, ArchiveError: s.archiveErr, Interval: s.Cfg.ArchiveInterval.String(),
406 RetentionDays: s.Cfg.RetentionDays, RateLimitKiB: s.Cfg.RateLimitKiB, Rollback: s.rollback,
407 }
408 }
409
410 func (s *Server) apiStatus(w http.ResponseWriter, r *http.Request) { writeJSON(w, 200, s.Status()) }
411
412 func (s *Server) apiSync(w http.ResponseWriter, r *http.Request) {
413 stats, err := s.SyncNow(r.Context())
414 if err != nil {
415 writeErr(w, 502, err.Error())
416 return
417 }
418 writeJSON(w, 200, stats)
419 }
420
421 func (s *Server) apiArchiveNow(w http.ResponseWriter, r *http.Request) {
422 a, err := s.ArchiveNow()
423 if err != nil {
424 writeErr(w, 409, err.Error())
425 return
426 }
427 writeJSON(w, 201, a)
428 }
429
430 func (s *Server) apiPrune(w http.ResponseWriter, r *http.Request) {
431 removed, err := s.Prune()
432 if err != nil {
433 writeErr(w, 500, err.Error())
434 return
435 }
436 if removed == nil {
437 removed = []string{}
438 }
439 writeJSON(w, 200, map[string]any{"removed": removed})
440 }
441
442 // ---------- koppelen ----------
443
444 // ConnectRequest is POST /api/v1/admin/connect.
445 type ConnectRequest struct {
446 URL string `json:"url"`
447 Key string `json:"key"`
448 // OnConflict is leeg, "wipe" of "restore". Leeg en een andere BlueGit
449 // dan de vorige: 409 met de keuzes.
450 OnConflict string `json:"on_conflict"`
451 }
452
453 // ConflictError is het 409-antwoord bij een andere BlueGit.
454 type ConflictError struct {
455 Conflict bool `json:"conflict"`
456 Error string `json:"error"`
457 PreviousURL string `json:"previous_url"`
458 PreviousInstance string `json:"previous_instance"`
459 NewInstance string `json:"new_instance"`
460 Archives int `json:"archives"`
461 Choices []string `json:"choices"`
462 }
463
464 func (s *Server) apiConnect(w http.ResponseWriter, r *http.Request) {
465 var in ConnectRequest
466 if err := json.Unmarshal(bodyOf(r), &in); err != nil {
467 writeErr(w, 400, "ongeldige JSON")
468 return
469 }
470 res, conflict, err := s.Connect(r.Context(), in)
471 if conflict != nil {
472 writeJSON(w, http.StatusConflict, conflict)
473 return
474 }
475 if err != nil {
476 var he *mirror.HTTPError
477 code := 502
478 if errors.As(err, &he) && he.Status == 401 {
479 code = 401
480 }
481 if errors.Is(err, errBadRequest) {
482 code = 400
483 }
484 writeErr(w, code, err.Error())
485 return
486 }
487 writeJSON(w, 200, res)
488 }
489
490 var errBadRequest = errors.New("ongeldig verzoek")
491
492 // Connect koppelt deze server aan een BlueGit. Er is er altijd hoogstens één.
493 func (s *Server) Connect(ctx context.Context, in ConnectRequest) (map[string]any, *ConflictError, error) {
494 in.URL = strings.TrimRight(strings.TrimSpace(in.URL), "/")
495 in.Key = strings.TrimSpace(in.Key)
496 if !strings.HasPrefix(in.URL, "http://") && !strings.HasPrefix(in.URL, "https://") {
497 return nil, nil, fmt.Errorf("%w: url moet met http:// of https:// beginnen", errBadRequest)
498 }
499 if !strings.HasPrefix(in.Key, protocol.KeyPrefix) {
500 return nil, nil, fmt.Errorf("%w: de Backupserver-Key begint met %s", errBadRequest, protocol.KeyPrefix)
501 }
502 switch in.OnConflict {
503 case "", "wipe", "restore":
504 default:
505 return nil, nil, fmt.Errorf("%w: on_conflict moet wipe of restore zijn", errBadRequest)
506 }
507 if s.Cfg.PublicURL == "" {
508 return nil, nil, fmt.Errorf("%w: zet public_url in de configuratie; BlueGit moet deze server kunnen bereiken", errBadRequest)
509 }
510 s.work.Lock()
511 defer s.work.Unlock()
512 rem := &mirror.Remote{URL: in.URL, Key: in.Key, HTTP: s.HTTP, Limiter: s.limiter}
513 info, err := rem.Info(ctx)
514 if err != nil {
515 return nil, nil, err
516 }
517 old := s.getState()
518 list, _ := s.archives.List()
519 hasData := !s.mirror.Empty() || len(list) > 0
520 other := old.InstanceID != "" && old.InstanceID != info.InstanceID && hasData
521 mode := ""
522 if other {
523 if in.OnConflict == "" {
524 return nil, &ConflictError{
525 Conflict: true, Error: "deze backup server hoort bij een andere BlueGit",
526 PreviousURL: old.BlueGitURL, PreviousInstance: old.InstanceID, NewInstance: info.InstanceID,
527 Archives: len(list), Choices: []string{"wipe", "restore"},
528 }, nil
529 }
530 mode = in.OnConflict
531 }
532 if mode == "wipe" {
533 if err := s.mirror.Wipe(); err != nil {
534 return nil, nil, err
535 }
536 if err := s.archives.DeleteAll(); err != nil {
537 return nil, nil, err
538 }
539 s.mu.Lock()
540 s.lastArchive = time.Time{}
541 s.mu.Unlock()
542 s.Log.Warn("oude backups verwijderd voor een nieuwe BlueGit", "old", old.InstanceID, "new", info.InstanceID)
543 }
544 if mode == "restore" && s.mirror.Empty() {
545 return nil, nil, fmt.Errorf("%w: de kopie is leeg; er is niets om terug te zetten", errBadRequest)
546 }
547 if err := rem.Connect(ctx, s.Cfg.PublicURL, s.serverID); err != nil {
548 return nil, nil, err
549 }
550 st := State{BlueGitURL: in.URL, Key: in.Key, InstanceID: info.InstanceID, ConnectedAt: s.now().UTC()}
551 if err := saveState(s.Cfg.DataDir, st); err != nil {
552 return nil, nil, err
553 }
554 s.mu.Lock()
555 s.state = st
556 s.mu.Unlock()
557 s.Log.Info("gekoppeld", "bluegit", in.URL, "instance", info.InstanceID, "mode", mode)
558 out := map[string]any{"instance_id": info.InstanceID, "bluegit_url": in.URL, "mode": mode}
559 if mode == "restore" {
560 if err := s.sendMirror(ctx, rem, "restore"); err != nil {
561 return nil, nil, fmt.Errorf("terugzetten naar de nieuwe BlueGit mislukt: %w", err)
562 }
563 out["restored"] = true
564 }
565 s.Kick()
566 return out, nil, nil
567 }
568
569 // sendMirror stuurt de hele kopie als tar.gz naar BlueGit en wacht tot die
570 // herstart is. Aanroepen met s.work vast.
571 func (s *Server) sendMirror(ctx context.Context, rem *mirror.Remote, label string) error {
572 s.setRollback(RollbackStatus{State: "running", Archive: label, At: s.now().UTC()})
573 pr, pw := io.Pipe()
574 go func() { pw.CloseWithError(archive.WriteTarGz(pw, s.mirror.Dir)) }()
575 if err := rem.Restore(ctx, pr); err != nil {
576 pr.CloseWithError(err)
577 s.setRollback(RollbackStatus{State: "failed", Archive: label, Error: err.Error(), At: s.now().UTC()})
578 return err
579 }
580 if err := rem.WaitUp(ctx, 3*time.Minute); err != nil {
581 s.setRollback(RollbackStatus{State: "failed", Archive: label, Error: err.Error(), At: s.now().UTC()})
582 return err
583 }
584 s.setRollback(RollbackStatus{State: "done", Archive: label, At: s.now().UTC()})
585 return nil
586 }
587
588 func (s *Server) setRollback(r RollbackStatus) {
589 s.mu.Lock()
590 s.rollback = r
591 s.mu.Unlock()
592 }
593
594 // ---------- rollback ----------
595
596 func (s *Server) apiRollback(w http.ResponseWriter, r *http.Request) {
597 var in struct {
598 Archive string `json:"archive"`
599 }
600 if err := json.Unmarshal(bodyOf(r), &in); err != nil || !archive.ValidName(in.Archive) {
601 writeErr(w, 400, "ongeldige archiefnaam")
602 return
603 }
604 if _, err := s.archives.Path(in.Archive); err != nil {
605 writeErr(w, 404, err.Error())
606 return
607 }
608 s.mu.Lock()
609 busy := s.rollback.State == "running"
610 if !busy {
611 s.rollback = RollbackStatus{State: "running", Archive: in.Archive, At: s.now().UTC()}
612 }
613 s.mu.Unlock()
614 if busy {
615 writeErr(w, 409, "er loopt al een rollback")
616 return
617 }
618 s.Log.Warn("rollback gestart", "archive", in.Archive)
619 go func() {
620 if err := s.Rollback(context.Background(), in.Archive); err != nil {
621 s.Log.Error("rollback mislukt", "archive", in.Archive, "err", err)
622 }
623 }()
624 writeJSON(w, http.StatusAccepted, map[string]string{"state": "running", "archive": in.Archive})
625 }
626
627 // Rollback pakt een archief uit, vervangt daarmee de draaiende kopie en
628 // stuurt die naar BlueGit. Lukt het sturen niet, dan komt de oude kopie
629 // terug, zodat kopie en BlueGit gelijk blijven.
630 func (s *Server) Rollback(ctx context.Context, name string) error {
631 s.work.Lock()
632 defer s.work.Unlock()
633 fail := func(err error) error {
634 s.setRollback(RollbackStatus{State: "failed", Archive: name, Error: err.Error(), At: s.now().UTC()})
635 return err
636 }
637 st := s.getState()
638 if !st.Connected() {
639 return fail(errors.New("geen BlueGit gekoppeld"))
640 }
641 src, err := s.archives.Path(name)
642 if err != nil {
643 return fail(err)
644 }
645 fresh := filepath.Join(s.Cfg.DataDir, "mirror.rollback")
646 old := filepath.Join(s.Cfg.DataDir, "mirror.old")
647 _ = os.RemoveAll(fresh)
648 _ = os.RemoveAll(old)
649 if err := archive.Extract(src, fresh); err != nil {
650 _ = os.RemoveAll(fresh)
651 return fail(fmt.Errorf("uitpakken: %w", err))
652 }
653 oldIndex, _ := os.ReadFile(s.mirror.Index)
654 if err := os.Rename(s.mirror.Dir, old); err != nil && !errors.Is(err, os.ErrNotExist) {
655 return fail(err)
656 }
657 if err := os.Rename(fresh, s.mirror.Dir); err != nil {
658 _ = os.Rename(old, s.mirror.Dir)
659 return fail(err)
660 }
661 if err := s.mirror.RebuildIndex(); err != nil {
662 return fail(err)
663 }
664 if err := s.sendMirror(ctx, s.remote(st), name); err != nil {
665 // Terug naar de kopie van vóór de rollback.
666 _ = os.RemoveAll(s.mirror.Dir)
667 _ = os.Rename(old, s.mirror.Dir)
668 _ = os.WriteFile(s.mirror.Index, oldIndex, 0o600)
669 s.setRollback(RollbackStatus{State: "failed", Archive: name, Error: err.Error(), At: s.now().UTC()})
670 return err
671 }
672 _ = os.RemoveAll(old)
673 s.Log.Warn("rollback klaar", "archive", name)
674 s.Kick()
675 return nil
676 }
677
678 // ---------- self-update ----------
679
680 // UpdateStarter start de update-unit (tests zetten een stub).
681 var UpdateStarter = func(ctx context.Context, ref string) error {
682 return startUpdateUnit(ctx, ref)
683 }
684
685 var updateHits = struct {
686 sync.Mutex
687 at []time.Time
688 }{}
689
690 func (s *Server) selfUpdate(w http.ResponseWriter, r *http.Request) {
691 tok := os.Getenv("BLUEGIT_BACKUP_UPDATE_TOKEN")
692 if tok == "" {
693 http.NotFound(w, r)
694 return
695 }
696 updateHits.Lock()
697 cut := time.Now().Add(-time.Minute)
698 keep := updateHits.at[:0]
699 for _, t := range updateHits.at {
700 if t.After(cut) {
701 keep = append(keep, t)
702 }
703 }
704 updateHits.at = append(keep, time.Now())
705 n := len(updateHits.at)
706 updateHits.Unlock()
707 if n > 5 {
708 writeErr(w, http.StatusTooManyRequests, "te veel verzoeken")
709 return
710 }
711 got := strings.TrimSpace(strings.TrimPrefix(r.Header.Get("Authorization"), "Bearer "))
712 if subtle.ConstantTimeCompare([]byte(got), []byte(tok)) != 1 {
713 writeErr(w, http.StatusUnauthorized, "unauthorized")
714 return
715 }
716 var in struct {
717 Ref string `json:"ref"`
718 }
719 _ = json.NewDecoder(io.LimitReader(r.Body, 4096)).Decode(&in)
720 if !validRef(in.Ref) {
721 writeErr(w, 400, "ref moet een volledige sha zijn")
722 return
723 }
724 if err := UpdateStarter(r.Context(), in.Ref); err != nil {
725 writeErr(w, 500, err.Error())
726 return
727 }
728 writeJSON(w, http.StatusAccepted, map[string]string{"ref": in.Ref, "state": "started"})
729 }
730
731 func validRef(ref string) bool {
732 if len(ref) != 40 {
733 return false
734 }
735 for _, c := range ref {
736 if !(c >= '0' && c <= '9' || c >= 'a' && c <= 'f') {
737 return false
738 }
739 }
740 return true
741 }
@@ -0,0 +1,741 @@
1// Package server is de backup server: sync, archieven, de API voor BlueGit
2// en de lokale beheer-API.
3package server
4
5import (
6 "context"
7 "crypto/subtle"
8 "encoding/json"
9 "errors"
10 "fmt"
11 "io"
12 "log/slog"
13 "net/http"
14 "os"
15 "path/filepath"
16 "strings"
17 "sync"
18 "time"
19
20 "git.timfalken.com/timfa/bluegit-backup/internal/archive"
21 "git.timfalken.com/timfa/bluegit-backup/internal/config"
22 "git.timfalken.com/timfa/bluegit-backup/internal/mirror"
23 "git.timfalken.com/timfa/bluegit-backup/internal/protocol"
24 "git.timfalken.com/timfa/bluegit-backup/internal/throttle"
25)
26
27// Version wordt bij het bouwen gezet (-ldflags -X).
28var Version = "dev"
29
30// Server is één backup server voor één BlueGit.
31type Server struct {
32 Cfg config.Config
33 Log *slog.Logger
34 // Now is de klok (tests).
35 Now func() time.Time
36 // HTTP is de client richting BlueGit (tests).
37 HTTP *http.Client
38
39 adminToken string
40 serverID string
41 limiter *throttle.Limiter
42 mirror *mirror.Mirror
43 archives *archive.Store
44
45 // work beschermt de kopie: sync, archiveren, rollback en koppelen
46 // gebeuren nooit tegelijk.
47 work sync.Mutex
48
49 mu sync.Mutex
50 state State
51 lastSync time.Time
52 lastSyncErr string
53 lastStats mirror.Stats
54 syncs int
55 notifies int
56 lastArchive time.Time
57 archiveErr string
58 rollback RollbackStatus
59
60 kick chan struct{}
61}
62
63// RollbackStatus is de stand van de laatste rollback of restore.
64type RollbackStatus struct {
65 State string `json:"state"` // idle | running | done | failed
66 Archive string `json:"archive,omitempty"`
67 Error string `json:"error,omitempty"`
68 At time.Time `json:"at,omitempty"`
69}
70
71// New zet de mappen klaar en leest de koppeling.
72func New(cfg config.Config, log *slog.Logger) (*Server, error) {
73 if log == nil {
74 log = slog.New(slog.NewTextHandler(io.Discard, nil))
75 }
76 if err := os.MkdirAll(cfg.DataDir, 0o750); err != nil {
77 return nil, err
78 }
79 s := &Server{Cfg: cfg, Log: log, Now: time.Now, kick: make(chan struct{}, 1)}
80 var err error
81 if s.adminToken, err = secretFile(cfg.DataDir, "admin.token", "bba_"); err != nil {
82 return nil, err
83 }
84 if s.serverID, err = secretFile(cfg.DataDir, "server_id", ""); err != nil {
85 return nil, err
86 }
87 if s.state, err = loadState(cfg.DataDir); err != nil {
88 return nil, err
89 }
90 s.limiter = throttle.New(cfg.RateLimitKiB << 10)
91 s.mirror = &mirror.Mirror{Dir: filepath.Join(cfg.DataDir, "mirror"), Index: filepath.Join(cfg.DataDir, "mirror.index.json")}
92 s.archives = &archive.Store{Dir: filepath.Join(cfg.DataDir, "archives")}
93 _ = os.RemoveAll(filepath.Join(cfg.DataDir, "tmp"))
94 if list, _ := s.archives.List(); len(list) > 0 {
95 s.lastArchive = list[0].CreatedAt
96 }
97 s.rollback.State = "idle"
98 return s, nil
99}
100
101// SetFree vervangt de vrije-ruimtemeting (tests).
102func (s *Server) SetFree(f func(string) (uint64, error)) { s.archives.Free = f }
103
104// AdminToken is het lokale beheertoken.
105func (s *Server) AdminToken() string { return s.adminToken }
106
107func (s *Server) now() time.Time { return s.Now() }
108
109func (s *Server) remote(st State) *mirror.Remote {
110 return &mirror.Remote{URL: st.BlueGitURL, Key: st.Key, HTTP: s.HTTP, Limiter: s.limiter}
111}
112
113func (s *Server) getState() State {
114 s.mu.Lock()
115 defer s.mu.Unlock()
116 return s.state
117}
118
119// Run start de achtergrondtaken tot ctx klaar is.
120func (s *Server) Run(ctx context.Context) {
121 go s.syncLoop(ctx)
122 go s.archiveLoop(ctx)
123}
124
125// Kick vraagt om een sync (na een melding).
126func (s *Server) Kick() {
127 select {
128 case s.kick <- struct{}{}:
129 default:
130 }
131}
132
133func (s *Server) syncLoop(ctx context.Context) {
134 full := time.NewTicker(s.Cfg.FullSyncInterval.Duration)
135 defer full.Stop()
136 s.Kick() // meteen na de start
137 for {
138 select {
139 case <-ctx.Done():
140 return
141 case <-full.C:
142 case <-s.kick:
143 }
144 s.mu.Lock()
145 wait := s.Cfg.MinSyncInterval.Duration - s.now().Sub(s.lastSync)
146 s.mu.Unlock()
147 if wait > 0 {
148 select {
149 case <-ctx.Done():
150 return
151 case <-time.After(wait):
152 }
153 }
154 // Meldingen die in de tussentijd binnenkwamen, zitten in deze sync.
155 select {
156 case <-s.kick:
157 default:
158 }
159 _, _ = s.SyncNow(ctx)
160 }
161}
162
163// SyncNow synchroniseert één keer.
164func (s *Server) SyncNow(ctx context.Context) (mirror.Stats, error) {
165 st := s.getState()
166 if !st.Connected() {
167 return mirror.Stats{}, errors.New("geen BlueGit gekoppeld")
168 }
169 s.work.Lock()
170 defer s.work.Unlock()
171 st = s.getState()
172 if !st.Connected() {
173 return mirror.Stats{}, errors.New("geen BlueGit gekoppeld")
174 }
175 stats, err := s.mirror.Sync(ctx, s.remote(st))
176 s.mu.Lock()
177 s.lastSync = s.now()
178 s.syncs++
179 s.lastStats = stats
180 if err != nil {
181 s.lastSyncErr = err.Error()
182 } else {
183 s.lastSyncErr = ""
184 }
185 s.mu.Unlock()
186 if err != nil {
187 s.Log.Warn("sync mislukt", "err", err)
188 } else if stats.Downloaded > 0 || stats.Deleted > 0 {
189 s.Log.Info("sync", "files", stats.Files, "downloaded", stats.Downloaded, "bytes", stats.Bytes, "deleted", stats.Deleted)
190 }
191 return stats, err
192}
193
194func (s *Server) archiveLoop(ctx context.Context) {
195 t := time.NewTicker(s.tick())
196 defer t.Stop()
197 for {
198 select {
199 case <-ctx.Done():
200 return
201 case <-t.C:
202 }
203 s.mu.Lock()
204 due := s.now().Sub(s.lastArchive) >= s.Cfg.ArchiveInterval.Duration
205 synced := !s.lastSync.IsZero() && s.lastSyncErr == ""
206 s.mu.Unlock()
207 if due && synced {
208 if _, err := s.ArchiveNow(); err != nil {
209 s.Log.Warn("archief mislukt", "err", err)
210 }
211 }
212 if _, err := s.Prune(); err != nil {
213 s.Log.Warn("opruimen mislukt", "err", err)
214 }
215 }
216}
217
218// tick is hoe vaak de archieflus kijkt: een minuut, of korter bij een kort interval.
219func (s *Server) tick() time.Duration {
220 d := s.Cfg.ArchiveInterval.Duration / 4
221 if d > time.Minute {
222 d = time.Minute
223 }
224 if d < 100*time.Millisecond {
225 d = 100 * time.Millisecond
226 }
227 return d
228}
229
230// ArchiveNow comprimeert de hele kopie tot een nieuw archief.
231func (s *Server) ArchiveNow() (archive.Archive, error) {
232 s.work.Lock()
233 defer s.work.Unlock()
234 if s.mirror.Empty() {
235 return archive.Archive{}, errors.New("de kopie is nog leeg")
236 }
237 now := s.now()
238 a, removed, err := s.archives.Create(s.mirror.Dir, now, s.mirror.Size(), s.minFree())
239 s.mu.Lock()
240 if err != nil {
241 s.archiveErr = err.Error()
242 } else {
243 s.archiveErr = ""
244 s.lastArchive = now
245 }
246 s.mu.Unlock()
247 for _, r := range removed {
248 s.Log.Info("archief verwijderd: schijf vol", "archive", r)
249 }
250 if err != nil {
251 return a, err
252 }
253 s.Log.Info("archief gemaakt", "archive", a.Name, "bytes", a.Size)
254 if pr, err := s.archives.Prune(now, s.Cfg.RetentionDays, s.minFree()); err == nil {
255 for _, r := range pr {
256 s.Log.Info("archief verwijderd", "archive", r)
257 }
258 }
259 return a, nil
260}
261
262func (s *Server) minFree() uint64 { return uint64(s.Cfg.MinFreeMB) << 20 }
263
264// Prune past de bewaarregels toe.
265func (s *Server) Prune() ([]string, error) {
266 s.work.Lock()
267 defer s.work.Unlock()
268 removed, err := s.archives.Prune(s.now(), s.Cfg.RetentionDays, s.minFree())
269 for _, r := range removed {
270 s.Log.Info("archief verwijderd", "archive", r)
271 }
272 return removed, err
273}
274
275// ---------- HTTP ----------
276
277// Handler is de HTTP-API.
278func (s *Server) Handler() http.Handler {
279 mux := http.NewServeMux()
280 mux.HandleFunc("GET /healthz", func(w http.ResponseWriter, r *http.Request) { _, _ = w.Write([]byte("ok\n")) })
281 // Van BlueGit, ondertekend.
282 mux.HandleFunc("POST /api/v1/notify", s.signed(s.apiNotify))
283 mux.HandleFunc("GET /api/v1/archives", s.signed(s.apiArchives))
284 mux.HandleFunc("GET /api/v1/status", s.signed(s.apiStatus))
285 mux.HandleFunc("POST /api/v1/rollback", s.signed(s.apiRollback))
286 // Lokaal beheer, met admin.token.
287 mux.HandleFunc("GET /api/v1/admin/status", s.admin(s.apiStatus))
288 mux.HandleFunc("GET /api/v1/admin/archives", s.admin(s.apiArchives))
289 mux.HandleFunc("POST /api/v1/admin/connect", s.admin(s.apiConnect))
290 mux.HandleFunc("POST /api/v1/admin/sync", s.admin(s.apiSync))
291 mux.HandleFunc("POST /api/v1/admin/archive", s.admin(s.apiArchiveNow))
292 mux.HandleFunc("POST /api/v1/admin/prune", s.admin(s.apiPrune))
293 mux.HandleFunc("POST /api/v1/admin/self-update", s.selfUpdate)
294 return mux
295}
296
297func writeJSON(w http.ResponseWriter, code int, v any) {
298 w.Header().Set("Content-Type", "application/json")
299 w.Header().Set("Cache-Control", "no-store")
300 w.WriteHeader(code)
301 if v != nil {
302 _ = json.NewEncoder(w).Encode(v)
303 }
304}
305
306func writeErr(w http.ResponseWriter, code int, msg string) {
307 writeJSON(w, code, map[string]string{"error": msg})
308}
309
310type ctxBody struct{}
311
312// signed controleert de HMAC-handtekening van de gekoppelde BlueGit.
313func (s *Server) signed(h http.HandlerFunc) http.HandlerFunc {
314 return func(w http.ResponseWriter, r *http.Request) {
315 st := s.getState()
316 if !st.Connected() {
317 writeErr(w, http.StatusUnauthorized, "niet gekoppeld")
318 return
319 }
320 body, err := io.ReadAll(io.LimitReader(r.Body, 1<<20))
321 if err != nil {
322 writeErr(w, 400, "body")
323 return
324 }
325 if r.Header.Get(protocol.HeaderInstance) != st.InstanceID {
326 writeErr(w, http.StatusUnauthorized, "andere BlueGit-instantie")
327 return
328 }
329 if err := protocol.Verify(r, protocol.SigningSecret(st.Key), body, s.now()); err != nil {
330 writeErr(w, http.StatusUnauthorized, err.Error())
331 return
332 }
333 r = r.WithContext(context.WithValue(r.Context(), ctxBody{}, body))
334 h(w, r)
335 }
336}
337
338func bodyOf(r *http.Request) []byte {
339 if b, ok := r.Context().Value(ctxBody{}).([]byte); ok {
340 return b
341 }
342 b, _ := io.ReadAll(io.LimitReader(r.Body, 1<<20))
343 return b
344}
345
346func (s *Server) admin(h http.HandlerFunc) http.HandlerFunc {
347 return func(w http.ResponseWriter, r *http.Request) {
348 tok := strings.TrimSpace(strings.TrimPrefix(r.Header.Get("Authorization"), "Bearer "))
349 if subtle.ConstantTimeCompare([]byte(tok), []byte(s.adminToken)) != 1 {
350 writeErr(w, http.StatusUnauthorized, "admin.token nodig")
351 return
352 }
353 h(w, r)
354 }
355}
356
357func (s *Server) apiNotify(w http.ResponseWriter, r *http.Request) {
358 s.mu.Lock()
359 s.notifies++
360 s.mu.Unlock()
361 s.Kick()
362 w.WriteHeader(http.StatusNoContent)
363}
364
365func (s *Server) apiArchives(w http.ResponseWriter, r *http.Request) {
366 list, err := s.archives.List()
367 if err != nil {
368 writeErr(w, 500, err.Error())
369 return
370 }
371 writeJSON(w, 200, map[string]any{"archives": list})
372}
373
374// Status is wat GET /api/v1/status en de CLI tonen.
375type Status struct {
376 Version string `json:"version"`
377 ServerID string `json:"server_id"`
378 BlueGitURL string `json:"bluegit_url,omitempty"`
379 InstanceID string `json:"instance_id,omitempty"`
380 Connected bool `json:"connected"`
381 LastSync time.Time `json:"last_sync,omitempty"`
382 SyncError string `json:"sync_error,omitempty"`
383 LastStats mirror.Stats `json:"last_stats"`
384 Syncs int `json:"syncs"`
385 Notifies int `json:"notifies"`
386 MirrorBytes int64 `json:"mirror_bytes"`
387 Archives int `json:"archives"`
388 LastArchive time.Time `json:"last_archive,omitempty"`
389 ArchiveError string `json:"archive_error,omitempty"`
390 Interval string `json:"archive_interval"`
391 RetentionDays int `json:"retention_days"`
392 RateLimitKiB int64 `json:"rate_limit_kib"`
393 Rollback RollbackStatus `json:"rollback"`
394}
395
396// Status geeft de huidige stand.
397func (s *Server) Status() Status {
398 list, _ := s.archives.List()
399 s.mu.Lock()
400 defer s.mu.Unlock()
401 return Status{
402 Version: Version, ServerID: s.serverID, BlueGitURL: s.state.BlueGitURL, InstanceID: s.state.InstanceID,
403 Connected: s.state.Connected(), LastSync: s.lastSync, SyncError: s.lastSyncErr, LastStats: s.lastStats,
404 Syncs: s.syncs, Notifies: s.notifies, MirrorBytes: s.mirror.Size(), Archives: len(list),
405 LastArchive: s.lastArchive, ArchiveError: s.archiveErr, Interval: s.Cfg.ArchiveInterval.String(),
406 RetentionDays: s.Cfg.RetentionDays, RateLimitKiB: s.Cfg.RateLimitKiB, Rollback: s.rollback,
407 }
408}
409
410func (s *Server) apiStatus(w http.ResponseWriter, r *http.Request) { writeJSON(w, 200, s.Status()) }
411
412func (s *Server) apiSync(w http.ResponseWriter, r *http.Request) {
413 stats, err := s.SyncNow(r.Context())
414 if err != nil {
415 writeErr(w, 502, err.Error())
416 return
417 }
418 writeJSON(w, 200, stats)
419}
420
421func (s *Server) apiArchiveNow(w http.ResponseWriter, r *http.Request) {
422 a, err := s.ArchiveNow()
423 if err != nil {
424 writeErr(w, 409, err.Error())
425 return
426 }
427 writeJSON(w, 201, a)
428}
429
430func (s *Server) apiPrune(w http.ResponseWriter, r *http.Request) {
431 removed, err := s.Prune()
432 if err != nil {
433 writeErr(w, 500, err.Error())
434 return
435 }
436 if removed == nil {
437 removed = []string{}
438 }
439 writeJSON(w, 200, map[string]any{"removed": removed})
440}
441
442// ---------- koppelen ----------
443
444// ConnectRequest is POST /api/v1/admin/connect.
445type ConnectRequest struct {
446 URL string `json:"url"`
447 Key string `json:"key"`
448 // OnConflict is leeg, "wipe" of "restore". Leeg en een andere BlueGit
449 // dan de vorige: 409 met de keuzes.
450 OnConflict string `json:"on_conflict"`
451}
452
453// ConflictError is het 409-antwoord bij een andere BlueGit.
454type ConflictError struct {
455 Conflict bool `json:"conflict"`
456 Error string `json:"error"`
457 PreviousURL string `json:"previous_url"`
458 PreviousInstance string `json:"previous_instance"`
459 NewInstance string `json:"new_instance"`
460 Archives int `json:"archives"`
461 Choices []string `json:"choices"`
462}
463
464func (s *Server) apiConnect(w http.ResponseWriter, r *http.Request) {
465 var in ConnectRequest
466 if err := json.Unmarshal(bodyOf(r), &in); err != nil {
467 writeErr(w, 400, "ongeldige JSON")
468 return
469 }
470 res, conflict, err := s.Connect(r.Context(), in)
471 if conflict != nil {
472 writeJSON(w, http.StatusConflict, conflict)
473 return
474 }
475 if err != nil {
476 var he *mirror.HTTPError
477 code := 502
478 if errors.As(err, &he) && he.Status == 401 {
479 code = 401
480 }
481 if errors.Is(err, errBadRequest) {
482 code = 400
483 }
484 writeErr(w, code, err.Error())
485 return
486 }
487 writeJSON(w, 200, res)
488}
489
490var errBadRequest = errors.New("ongeldig verzoek")
491
492// Connect koppelt deze server aan een BlueGit. Er is er altijd hoogstens één.
493func (s *Server) Connect(ctx context.Context, in ConnectRequest) (map[string]any, *ConflictError, error) {
494 in.URL = strings.TrimRight(strings.TrimSpace(in.URL), "/")
495 in.Key = strings.TrimSpace(in.Key)
496 if !strings.HasPrefix(in.URL, "http://") && !strings.HasPrefix(in.URL, "https://") {
497 return nil, nil, fmt.Errorf("%w: url moet met http:// of https:// beginnen", errBadRequest)
498 }
499 if !strings.HasPrefix(in.Key, protocol.KeyPrefix) {
500 return nil, nil, fmt.Errorf("%w: de Backupserver-Key begint met %s", errBadRequest, protocol.KeyPrefix)
501 }
502 switch in.OnConflict {
503 case "", "wipe", "restore":
504 default:
505 return nil, nil, fmt.Errorf("%w: on_conflict moet wipe of restore zijn", errBadRequest)
506 }
507 if s.Cfg.PublicURL == "" {
508 return nil, nil, fmt.Errorf("%w: zet public_url in de configuratie; BlueGit moet deze server kunnen bereiken", errBadRequest)
509 }
510 s.work.Lock()
511 defer s.work.Unlock()
512 rem := &mirror.Remote{URL: in.URL, Key: in.Key, HTTP: s.HTTP, Limiter: s.limiter}
513 info, err := rem.Info(ctx)
514 if err != nil {
515 return nil, nil, err
516 }
517 old := s.getState()
518 list, _ := s.archives.List()
519 hasData := !s.mirror.Empty() || len(list) > 0
520 other := old.InstanceID != "" && old.InstanceID != info.InstanceID && hasData
521 mode := ""
522 if other {
523 if in.OnConflict == "" {
524 return nil, &ConflictError{
525 Conflict: true, Error: "deze backup server hoort bij een andere BlueGit",
526 PreviousURL: old.BlueGitURL, PreviousInstance: old.InstanceID, NewInstance: info.InstanceID,
527 Archives: len(list), Choices: []string{"wipe", "restore"},
528 }, nil
529 }
530 mode = in.OnConflict
531 }
532 if mode == "wipe" {
533 if err := s.mirror.Wipe(); err != nil {
534 return nil, nil, err
535 }
536 if err := s.archives.DeleteAll(); err != nil {
537 return nil, nil, err
538 }
539 s.mu.Lock()
540 s.lastArchive = time.Time{}
541 s.mu.Unlock()
542 s.Log.Warn("oude backups verwijderd voor een nieuwe BlueGit", "old", old.InstanceID, "new", info.InstanceID)
543 }
544 if mode == "restore" && s.mirror.Empty() {
545 return nil, nil, fmt.Errorf("%w: de kopie is leeg; er is niets om terug te zetten", errBadRequest)
546 }
547 if err := rem.Connect(ctx, s.Cfg.PublicURL, s.serverID); err != nil {
548 return nil, nil, err
549 }
550 st := State{BlueGitURL: in.URL, Key: in.Key, InstanceID: info.InstanceID, ConnectedAt: s.now().UTC()}
551 if err := saveState(s.Cfg.DataDir, st); err != nil {
552 return nil, nil, err
553 }
554 s.mu.Lock()
555 s.state = st
556 s.mu.Unlock()
557 s.Log.Info("gekoppeld", "bluegit", in.URL, "instance", info.InstanceID, "mode", mode)
558 out := map[string]any{"instance_id": info.InstanceID, "bluegit_url": in.URL, "mode": mode}
559 if mode == "restore" {
560 if err := s.sendMirror(ctx, rem, "restore"); err != nil {
561 return nil, nil, fmt.Errorf("terugzetten naar de nieuwe BlueGit mislukt: %w", err)
562 }
563 out["restored"] = true
564 }
565 s.Kick()
566 return out, nil, nil
567}
568
569// sendMirror stuurt de hele kopie als tar.gz naar BlueGit en wacht tot die
570// herstart is. Aanroepen met s.work vast.
571func (s *Server) sendMirror(ctx context.Context, rem *mirror.Remote, label string) error {
572 s.setRollback(RollbackStatus{State: "running", Archive: label, At: s.now().UTC()})
573 pr, pw := io.Pipe()
574 go func() { pw.CloseWithError(archive.WriteTarGz(pw, s.mirror.Dir)) }()
575 if err := rem.Restore(ctx, pr); err != nil {
576 pr.CloseWithError(err)
577 s.setRollback(RollbackStatus{State: "failed", Archive: label, Error: err.Error(), At: s.now().UTC()})
578 return err
579 }
580 if err := rem.WaitUp(ctx, 3*time.Minute); err != nil {
581 s.setRollback(RollbackStatus{State: "failed", Archive: label, Error: err.Error(), At: s.now().UTC()})
582 return err
583 }
584 s.setRollback(RollbackStatus{State: "done", Archive: label, At: s.now().UTC()})
585 return nil
586}
587
588func (s *Server) setRollback(r RollbackStatus) {
589 s.mu.Lock()
590 s.rollback = r
591 s.mu.Unlock()
592}
593
594// ---------- rollback ----------
595
596func (s *Server) apiRollback(w http.ResponseWriter, r *http.Request) {
597 var in struct {
598 Archive string `json:"archive"`
599 }
600 if err := json.Unmarshal(bodyOf(r), &in); err != nil || !archive.ValidName(in.Archive) {
601 writeErr(w, 400, "ongeldige archiefnaam")
602 return
603 }
604 if _, err := s.archives.Path(in.Archive); err != nil {
605 writeErr(w, 404, err.Error())
606 return
607 }
608 s.mu.Lock()
609 busy := s.rollback.State == "running"
610 if !busy {
611 s.rollback = RollbackStatus{State: "running", Archive: in.Archive, At: s.now().UTC()}
612 }
613 s.mu.Unlock()
614 if busy {
615 writeErr(w, 409, "er loopt al een rollback")
616 return
617 }
618 s.Log.Warn("rollback gestart", "archive", in.Archive)
619 go func() {
620 if err := s.Rollback(context.Background(), in.Archive); err != nil {
621 s.Log.Error("rollback mislukt", "archive", in.Archive, "err", err)
622 }
623 }()
624 writeJSON(w, http.StatusAccepted, map[string]string{"state": "running", "archive": in.Archive})
625}
626
627// Rollback pakt een archief uit, vervangt daarmee de draaiende kopie en
628// stuurt die naar BlueGit. Lukt het sturen niet, dan komt de oude kopie
629// terug, zodat kopie en BlueGit gelijk blijven.
630func (s *Server) Rollback(ctx context.Context, name string) error {
631 s.work.Lock()
632 defer s.work.Unlock()
633 fail := func(err error) error {
634 s.setRollback(RollbackStatus{State: "failed", Archive: name, Error: err.Error(), At: s.now().UTC()})
635 return err
636 }
637 st := s.getState()
638 if !st.Connected() {
639 return fail(errors.New("geen BlueGit gekoppeld"))
640 }
641 src, err := s.archives.Path(name)
642 if err != nil {
643 return fail(err)
644 }
645 fresh := filepath.Join(s.Cfg.DataDir, "mirror.rollback")
646 old := filepath.Join(s.Cfg.DataDir, "mirror.old")
647 _ = os.RemoveAll(fresh)
648 _ = os.RemoveAll(old)
649 if err := archive.Extract(src, fresh); err != nil {
650 _ = os.RemoveAll(fresh)
651 return fail(fmt.Errorf("uitpakken: %w", err))
652 }
653 oldIndex, _ := os.ReadFile(s.mirror.Index)
654 if err := os.Rename(s.mirror.Dir, old); err != nil && !errors.Is(err, os.ErrNotExist) {
655 return fail(err)
656 }
657 if err := os.Rename(fresh, s.mirror.Dir); err != nil {
658 _ = os.Rename(old, s.mirror.Dir)
659 return fail(err)
660 }
661 if err := s.mirror.RebuildIndex(); err != nil {
662 return fail(err)
663 }
664 if err := s.sendMirror(ctx, s.remote(st), name); err != nil {
665 // Terug naar de kopie van vóór de rollback.
666 _ = os.RemoveAll(s.mirror.Dir)
667 _ = os.Rename(old, s.mirror.Dir)
668 _ = os.WriteFile(s.mirror.Index, oldIndex, 0o600)
669 s.setRollback(RollbackStatus{State: "failed", Archive: name, Error: err.Error(), At: s.now().UTC()})
670 return err
671 }
672 _ = os.RemoveAll(old)
673 s.Log.Warn("rollback klaar", "archive", name)
674 s.Kick()
675 return nil
676}
677
678// ---------- self-update ----------
679
680// UpdateStarter start de update-unit (tests zetten een stub).
681var UpdateStarter = func(ctx context.Context, ref string) error {
682 return startUpdateUnit(ctx, ref)
683}
684
685var updateHits = struct {
686 sync.Mutex
687 at []time.Time
688}{}
689
690func (s *Server) selfUpdate(w http.ResponseWriter, r *http.Request) {
691 tok := os.Getenv("BLUEGIT_BACKUP_UPDATE_TOKEN")
692 if tok == "" {
693 http.NotFound(w, r)
694 return
695 }
696 updateHits.Lock()
697 cut := time.Now().Add(-time.Minute)
698 keep := updateHits.at[:0]
699 for _, t := range updateHits.at {
700 if t.After(cut) {
701 keep = append(keep, t)
702 }
703 }
704 updateHits.at = append(keep, time.Now())
705 n := len(updateHits.at)
706 updateHits.Unlock()
707 if n > 5 {
708 writeErr(w, http.StatusTooManyRequests, "te veel verzoeken")
709 return
710 }
711 got := strings.TrimSpace(strings.TrimPrefix(r.Header.Get("Authorization"), "Bearer "))
712 if subtle.ConstantTimeCompare([]byte(got), []byte(tok)) != 1 {
713 writeErr(w, http.StatusUnauthorized, "unauthorized")
714 return
715 }
716 var in struct {
717 Ref string `json:"ref"`
718 }
719 _ = json.NewDecoder(io.LimitReader(r.Body, 4096)).Decode(&in)
720 if !validRef(in.Ref) {
721 writeErr(w, 400, "ref moet een volledige sha zijn")
722 return
723 }
724 if err := UpdateStarter(r.Context(), in.Ref); err != nil {
725 writeErr(w, 500, err.Error())
726 return
727 }
728 writeJSON(w, http.StatusAccepted, map[string]string{"ref": in.Ref, "state": "started"})
729}
730
731func validRef(ref string) bool {
732 if len(ref) != 40 {
733 return false
734 }
735 for _, c := range ref {
736 if !(c >= '0' && c <= '9' || c >= 'a' && c <= 'f') {
737 return false
738 }
739 }
740 return true
741}
internal/backupserver/server/server_test.go added +232 −0
@@ -0,0 +1,232 @@
1 package server
2
3 import (
4 "bytes"
5 "context"
6 "crypto/sha256"
7 "encoding/hex"
8 "encoding/json"
9 "io"
10 "net/http"
11 "net/http/httptest"
12 "os"
13 "path/filepath"
14 "strings"
15 "sync"
16 "testing"
17 "time"
18
19 "git.timfalken.com/timfa/bluegit-backup/internal/config"
20 "git.timfalken.com/timfa/bluegit-backup/internal/protocol"
21 )
22
23 // fakeBlueGit is een minimale backup-API met bestanden in het geheugen.
24 type fakeBlueGit struct {
25 mu sync.Mutex
26 key string
27 inst string
28 files map[string]string
29 fetches map[string]int
30 ts *httptest.Server
31 }
32
33 func newFake(t *testing.T) *fakeBlueGit {
34 f := &fakeBlueGit{key: "bgbk_test", inst: "inst-1", fetches: map[string]int{},
35 files: map[string]string{"state/bluegit.db": "db1", "state/secret.key": "k", "data/repos/tim/a.git/HEAD": "ref"}}
36 f.ts = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
37 if r.Header.Get("Authorization") != "Bearer "+f.key {
38 http.Error(w, `{"error":"key"}`, 401)
39 return
40 }
41 f.mu.Lock()
42 defer f.mu.Unlock()
43 switch r.URL.Path {
44 case "/api/v1/backup/info":
45 _ = json.NewEncoder(w).Encode(protocol.Info{InstanceID: f.inst})
46 case "/api/v1/backup/connect":
47 w.WriteHeader(200)
48 case "/api/v1/backup/manifest":
49 m := protocol.Manifest{Instance: f.inst}
50 for p, c := range f.files {
51 e := protocol.Entry{Path: p, Size: int64(len(c)), MTime: int64(len(c)) * 1000, Mode: 0o644}
52 if p == protocol.DBPath {
53 s := sha256.Sum256([]byte(c))
54 e.SHA256 = hex.EncodeToString(s[:])
55 }
56 m.Files = append(m.Files, e)
57 }
58 m.Files = append(m.Files, protocol.Entry{Path: "../../etc/passwd", Size: 1})
59 _ = json.NewEncoder(w).Encode(m)
60 case "/api/v1/backup/file":
61 p := r.URL.Query().Get("path")
62 c, ok := f.files[p]
63 if !ok {
64 http.Error(w, `{"error":"weg"}`, 404)
65 return
66 }
67 f.fetches[p]++
68 _, _ = io.WriteString(w, c)
69 default:
70 http.NotFound(w, r)
71 }
72 }))
73 t.Cleanup(f.ts.Close)
74 return f
75 }
76
77 func newTestServer(t *testing.T) *Server {
78 cfg := config.Config{DataDir: t.TempDir(), PublicURL: "http://backup.test"}
79 cfg.Defaults()
80 cfg.RateLimitKiB = 0
81 s, err := New(cfg, nil)
82 if err != nil {
83 t.Fatal(err)
84 }
85 return s
86 }
87
88 func adminReq(s *Server, method, p, body string) *httptest.ResponseRecorder {
89 r := httptest.NewRequest(method, p, strings.NewReader(body))
90 r.Header.Set("Authorization", "Bearer "+s.AdminToken())
91 w := httptest.NewRecorder()
92 s.Handler().ServeHTTP(w, r)
93 return w
94 }
95
96 func TestSyncIncrementalAndDeletes(t *testing.T) {
97 f := newFake(t)
98 s := newTestServer(t)
99 if w := adminReq(s, "POST", "/api/v1/admin/connect", `{"url":"`+f.ts.URL+`","key":"bgbk_test"}`); w.Code != 200 {
100 t.Fatalf("connect %d %s", w.Code, w.Body)
101 }
102 if _, err := s.SyncNow(context.Background()); err != nil {
103 t.Fatal(err)
104 }
105 if _, err := os.Stat(filepath.Join(s.Cfg.DataDir, "mirror", "data/repos/tim/a.git/HEAD")); err != nil {
106 t.Fatal(err)
107 }
108 if _, err := os.Stat(filepath.Join(s.Cfg.DataDir, "etc", "passwd")); err == nil {
109 t.Fatal("pad buiten de kopie geschreven")
110 }
111 // Ongewijzigd: niets opnieuw. Gewijzigde database: alleen die.
112 st, _ := s.SyncNow(context.Background())
113 if st.Downloaded != 0 {
114 t.Fatalf("tweede sync %+v", st)
115 }
116 f.mu.Lock()
117 f.files["state/bluegit.db"] = "db2"
118 delete(f.files, "data/repos/tim/a.git/HEAD")
119 f.mu.Unlock()
120 st, _ = s.SyncNow(context.Background())
121 if st.Downloaded != 1 || st.Deleted != 1 {
122 t.Fatalf("derde sync %+v", st)
123 }
124 if b, _ := os.ReadFile(filepath.Join(s.Cfg.DataDir, "mirror", "state/bluegit.db")); string(b) != "db2" {
125 t.Fatalf("db %q", b)
126 }
127 if _, err := os.Stat(filepath.Join(s.Cfg.DataDir, "mirror", "data/repos/tim")); err == nil {
128 t.Fatal("lege map blijft staan")
129 }
130 // Bestaat state.json en is het 0600 (er staat een key in).
131 fi, err := os.Stat(filepath.Join(s.Cfg.DataDir, "state.json"))
132 if err != nil || fi.Mode().Perm() != 0o600 {
133 t.Fatalf("state.json %v %v", err, fi)
134 }
135 }
136
137 func TestSignedEndpoints(t *testing.T) {
138 f := newFake(t)
139 s := newTestServer(t)
140 if w := adminReq(s, "POST", "/api/v1/admin/connect", `{"url":"`+f.ts.URL+`","key":"bgbk_test"}`); w.Code != 200 {
141 t.Fatalf("connect %d", w.Code)
142 }
143 h := s.Handler()
144 call := func(method, p, body, secret, inst string) int {
145 r := httptest.NewRequest(method, p, bytes.NewReader([]byte(body)))
146 if secret != "" {
147 protocol.Sign(r, secret, inst, []byte(body), time.Now())
148 }
149 w := httptest.NewRecorder()
150 h.ServeHTTP(w, r)
151 return w.Code
152 }
153 good := protocol.SigningSecret("bgbk_test")
154 if c := call("POST", "/api/v1/notify", "{}", "", ""); c != 401 {
155 t.Fatalf("zonder handtekening %d", c)
156 }
157 if c := call("POST", "/api/v1/notify", "{}", protocol.SigningSecret("bgbk_ander"), "inst-1"); c != 401 {
158 t.Fatalf("verkeerd geheim %d", c)
159 }
160 if c := call("POST", "/api/v1/notify", "{}", good, "inst-2"); c != 401 {
161 t.Fatalf("andere instantie %d", c)
162 }
163 if c := call("POST", "/api/v1/notify", "{}", good, "inst-1"); c != 204 {
164 t.Fatalf("melding %d", c)
165 }
166 if c := call("GET", "/api/v1/archives", "", good, "inst-1"); c != 200 {
167 t.Fatalf("archieven %d", c)
168 }
169 if c := call("POST", "/api/v1/rollback", `{"archive":"../x"}`, good, "inst-1"); c != 400 {
170 t.Fatalf("ongeldige naam %d", c)
171 }
172 if c := call("POST", "/api/v1/rollback", `{"archive":"bluegit-20261115-120000.tar.gz"}`, good, "inst-1"); c != 404 {
173 t.Fatalf("onbekend archief %d", c)
174 }
175 // Beheer-API zonder token.
176 r := httptest.NewRequest("GET", "/api/v1/admin/status", nil)
177 w := httptest.NewRecorder()
178 h.ServeHTTP(w, r)
179 if w.Code != 401 {
180 t.Fatalf("status zonder token %d", w.Code)
181 }
182 }
183
184 func TestConnectValidation(t *testing.T) {
185 f := newFake(t)
186 s := newTestServer(t)
187 for body, want := range map[string]int{
188 `{"url":"ftp://x","key":"bgbk_test"}`: 400,
189 `{"url":"` + f.ts.URL + `","key":"zonder-prefix"}`: 400,
190 `{"url":"` + f.ts.URL + `","key":"bgbk_fout"}`: 401,
191 `{"url":"` + f.ts.URL + `","key":"bgbk_test","on_conflict":"x"}`: 400,
192 } {
193 if w := adminReq(s, "POST", "/api/v1/admin/connect", body); w.Code != want {
194 t.Errorf("%s: %d, wil %d (%s)", body, w.Code, want, w.Body)
195 }
196 }
197 s.Cfg.PublicURL = ""
198 if w := adminReq(s, "POST", "/api/v1/admin/connect", `{"url":"`+f.ts.URL+`","key":"bgbk_test"}`); w.Code != 400 {
199 t.Fatalf("zonder public_url %d", w.Code)
200 }
201 }
202
203 func TestSelfUpdateEndpoint(t *testing.T) {
204 s := newTestServer(t)
205 h := s.Handler()
206 var got string
207 UpdateStarter = func(_ context.Context, ref string) error { got = ref; return nil }
208 call := func(tok, body string) int {
209 r := httptest.NewRequest("POST", "/api/v1/admin/self-update", strings.NewReader(body))
210 if tok != "" {
211 r.Header.Set("Authorization", "Bearer "+tok)
212 }
213 w := httptest.NewRecorder()
214 h.ServeHTTP(w, r)
215 return w.Code
216 }
217 t.Setenv("BLUEGIT_BACKUP_UPDATE_TOKEN", "")
218 if c := call("x", `{}`); c != 404 {
219 t.Fatalf("uit: %d", c)
220 }
221 t.Setenv("BLUEGIT_BACKUP_UPDATE_TOKEN", "geheim")
222 if c := call("fout", `{}`); c != 401 {
223 t.Fatalf("fout token: %d", c)
224 }
225 if c := call("geheim", `{"ref":"master"}`); c != 400 {
226 t.Fatalf("geen sha: %d", c)
227 }
228 sha := strings.Repeat("a", 40)
229 if c := call("geheim", `{"ref":"`+sha+`"}`); c != 202 || got != sha {
230 t.Fatalf("start: %d %q", c, got)
231 }
232 }
@@ -0,0 +1,232 @@
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}
202
203func TestSelfUpdateEndpoint(t *testing.T) {
204 s := newTestServer(t)
205 h := s.Handler()
206 var got string
207 UpdateStarter = func(_ context.Context, ref string) error { got = ref; return nil }
208 call := func(tok, body string) int {
209 r := httptest.NewRequest("POST", "/api/v1/admin/self-update", strings.NewReader(body))
210 if tok != "" {
211 r.Header.Set("Authorization", "Bearer "+tok)
212 }
213 w := httptest.NewRecorder()
214 h.ServeHTTP(w, r)
215 return w.Code
216 }
217 t.Setenv("BLUEGIT_BACKUP_UPDATE_TOKEN", "")
218 if c := call("x", `{}`); c != 404 {
219 t.Fatalf("uit: %d", c)
220 }
221 t.Setenv("BLUEGIT_BACKUP_UPDATE_TOKEN", "geheim")
222 if c := call("fout", `{}`); c != 401 {
223 t.Fatalf("fout token: %d", c)
224 }
225 if c := call("geheim", `{"ref":"master"}`); c != 400 {
226 t.Fatalf("geen sha: %d", c)
227 }
228 sha := strings.Repeat("a", 40)
229 if c := call("geheim", `{"ref":"`+sha+`"}`); c != 202 || got != sha {
230 t.Fatalf("start: %d %q", c, got)
231 }
232}
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/update.go added +27 −0
@@ -0,0 +1,27 @@
1 package server
2
3 import (
4 "context"
5 "fmt"
6 "os"
7 "os/exec"
8 "path/filepath"
9 )
10
11 // startUpdateUnit schrijft de gevraagde commit weg en start
12 // bluegit-backup-update.service. De polkit-regel uit packaging staat de
13 // gebruiker bluegit-backup alleen die ene unit toe.
14 func startUpdateUnit(ctx context.Context, ref string) error {
15 dir := os.Getenv("BLUEGIT_BACKUP_STATE_DIR")
16 if dir == "" {
17 dir = "/var/lib/bluegit-backup"
18 }
19 if err := os.WriteFile(filepath.Join(dir, "update-request"), []byte(ref+"\n"), 0o644); err != nil {
20 return err
21 }
22 out, err := exec.CommandContext(ctx, "systemctl", "start", "--no-block", "bluegit-backup-update.service").CombinedOutput()
23 if err != nil {
24 return fmt.Errorf("systemctl: %v: %s", err, out)
25 }
26 return nil
27 }
@@ -0,0 +1,27 @@
1package server
2
3import (
4 "context"
5 "fmt"
6 "os"
7 "os/exec"
8 "path/filepath"
9)
10
11// startUpdateUnit schrijft de gevraagde commit weg en start
12// bluegit-backup-update.service. De polkit-regel uit packaging staat de
13// gebruiker bluegit-backup alleen die ene unit toe.
14func startUpdateUnit(ctx context.Context, ref string) error {
15 dir := os.Getenv("BLUEGIT_BACKUP_STATE_DIR")
16 if dir == "" {
17 dir = "/var/lib/bluegit-backup"
18 }
19 if err := os.WriteFile(filepath.Join(dir, "update-request"), []byte(ref+"\n"), 0o644); err != nil {
20 return err
21 }
22 out, err := exec.CommandContext(ctx, "systemctl", "start", "--no-block", "bluegit-backup-update.service").CombinedOutput()
23 if err != nil {
24 return fmt.Errorf("systemctl: %v: %s", err, out)
25 }
26 return nil
27}
internal/backupserver/throttle/throttle.go added +104 −0
@@ -0,0 +1,104 @@
1 // Package throttle begrenst de leessnelheid met een token bucket.
2 package throttle
3
4 import (
5 "context"
6 "io"
7 "sync"
8 "time"
9 )
10
11 // Limiter is een token bucket in bytes per seconde, gedeeld door alle
12 // downloads van één server.
13 type Limiter struct {
14 mu sync.Mutex
15 rate float64 // bytes/s; 0 = onbegrensd
16 burst float64
17 tokens float64
18 last time.Time
19 now func() time.Time
20 sleep func(context.Context, time.Duration) error
21 }
22
23 // New maakt een limiter. bytesPerSec 0 = geen limiet. De burst is een
24 // kwart seconde, minstens 16 KiB.
25 func New(bytesPerSec int64) *Limiter {
26 l := &Limiter{rate: float64(bytesPerSec), now: time.Now, sleep: sleepCtx}
27 l.burst = l.rate / 4
28 if l.burst < 16<<10 {
29 l.burst = 16 << 10
30 }
31 l.tokens = l.burst
32 l.last = l.now()
33 return l
34 }
35
36 func sleepCtx(ctx context.Context, d time.Duration) error {
37 t := time.NewTimer(d)
38 defer t.Stop()
39 select {
40 case <-ctx.Done():
41 return ctx.Err()
42 case <-t.C:
43 return nil
44 }
45 }
46
47 // Rate is de ingestelde snelheid in bytes/s.
48 func (l *Limiter) Rate() int64 {
49 if l == nil {
50 return 0
51 }
52 return int64(l.rate)
53 }
54
55 // Wait blokkeert tot n bytes gelezen mogen worden.
56 func (l *Limiter) Wait(ctx context.Context, n int) error {
57 if l == nil || l.rate <= 0 || n <= 0 {
58 return nil
59 }
60 l.mu.Lock()
61 now := l.now()
62 l.tokens += now.Sub(l.last).Seconds() * l.rate
63 if l.tokens > l.burst {
64 l.tokens = l.burst
65 }
66 l.last = now
67 l.tokens -= float64(n)
68 var wait time.Duration
69 if l.tokens < 0 {
70 wait = time.Duration(-l.tokens / l.rate * float64(time.Second))
71 }
72 l.mu.Unlock()
73 if wait > 0 {
74 return l.sleep(ctx, wait)
75 }
76 return nil
77 }
78
79 // Reader begrenst r met l.
80 func (l *Limiter) Reader(ctx context.Context, r io.Reader) io.Reader {
81 if l == nil || l.rate <= 0 {
82 return r
83 }
84 return &reader{ctx: ctx, r: r, l: l}
85 }
86
87 type reader struct {
88 ctx context.Context
89 r io.Reader
90 l *Limiter
91 }
92
93 func (t *reader) Read(p []byte) (int, error) {
94 if max := int(t.l.burst); len(p) > max {
95 p = p[:max]
96 }
97 n, err := t.r.Read(p)
98 if n > 0 {
99 if werr := t.l.Wait(t.ctx, n); werr != nil {
100 return n, werr
101 }
102 }
103 return n, err
104 }
@@ -0,0 +1,104 @@
1// Package throttle begrenst de leessnelheid met een token bucket.
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 return int64(l.rate)
53}
54
55// Wait blokkeert tot n bytes gelezen mogen worden.
56func (l *Limiter) Wait(ctx context.Context, n int) error {
57 if l == nil || l.rate <= 0 || n <= 0 {
58 return nil
59 }
60 l.mu.Lock()
61 now := l.now()
62 l.tokens += now.Sub(l.last).Seconds() * l.rate
63 if l.tokens > l.burst {
64 l.tokens = l.burst
65 }
66 l.last = now
67 l.tokens -= float64(n)
68 var wait time.Duration
69 if l.tokens < 0 {
70 wait = time.Duration(-l.tokens / l.rate * float64(time.Second))
71 }
72 l.mu.Unlock()
73 if wait > 0 {
74 return l.sleep(ctx, wait)
75 }
76 return nil
77}
78
79// Reader begrenst r met l.
80func (l *Limiter) Reader(ctx context.Context, r io.Reader) io.Reader {
81 if l == nil || l.rate <= 0 {
82 return r
83 }
84 return &reader{ctx: ctx, r: r, l: l}
85}
86
87type reader struct {
88 ctx context.Context
89 r io.Reader
90 l *Limiter
91}
92
93func (t *reader) Read(p []byte) (int, error) {
94 if max := int(t.l.burst); len(p) > max {
95 p = p[:max]
96 }
97 n, err := t.r.Read(p)
98 if n > 0 {
99 if werr := t.l.Wait(t.ctx, n); werr != nil {
100 return n, werr
101 }
102 }
103 return n, err
104}
internal/backupserver/throttle/throttle_test.go added +52 −0
@@ -0,0 +1,52 @@
1 package throttle
2
3 import (
4 "bytes"
5 "context"
6 "io"
7 "testing"
8 "time"
9 )
10
11 func TestLimiterAverage(t *testing.T) {
12 now := time.Unix(0, 0)
13 slept := time.Duration(0)
14 l := New(100 << 10) // 100 KiB/s
15 l.now = func() time.Time { return now }
16 l.last = now
17 l.sleep = func(_ context.Context, d time.Duration) error {
18 slept += d
19 now = now.Add(d)
20 return nil
21 }
22 data := bytes.Repeat([]byte("x"), 1<<20) // 1 MiB
23 n, err := io.Copy(io.Discard, l.Reader(context.Background(), bytes.NewReader(data)))
24 if err != nil || n != 1<<20 {
25 t.Fatal(n, err)
26 }
27 // 1 MiB tegen 100 KiB/s is ruim 10 s, min de eerste burst van 25 KiB.
28 if slept < 9500*time.Millisecond || slept > 10500*time.Millisecond {
29 t.Fatalf("geslapen %v, verwacht ~10s", slept)
30 }
31 }
32
33 func TestUnlimited(t *testing.T) {
34 l := New(0)
35 r := bytes.NewReader([]byte("abc"))
36 if l.Reader(context.Background(), r) != r {
37 t.Fatal("onbegrensd hoort de reader niet te wikkelen")
38 }
39 if err := l.Wait(context.Background(), 1<<30); err != nil {
40 t.Fatal(err)
41 }
42 }
43
44 func TestCancel(t *testing.T) {
45 l := New(1024)
46 ctx, cancel := context.WithCancel(context.Background())
47 cancel()
48 _ = l.Wait(ctx, 16<<10)
49 if err := l.Wait(ctx, 16<<10); err == nil {
50 t.Fatal("geen fout na annuleren")
51 }
52 }
@@ -0,0 +1,52 @@
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 l.Reader(context.Background(), r) != r {
37 t.Fatal("onbegrensd hoort de reader niet te wikkelen")
38 }
39 if err := l.Wait(context.Background(), 1<<30); err != nil {
40 t.Fatal(err)
41 }
42}
43
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}
packaging/aur-backup/PKGBUILD added +39 −0
@@ -0,0 +1,39 @@
1 # Maintainer: Tim Falken <tim@timfalken.com>
2 pkgname=bluegit-backup
3 pkgver=20261115000000
4 pkgrel=1
5 pkgdesc='Backup server for a BlueGit instance: incremental copy, archives, rollback'
6 arch=('x86_64' 'aarch64')
7 url='https://git.timfalken.com/timfa/bluegit-backup'
8 license=('MIT')
9 depends=('curl')
10 makedepends=('go')
11 backup=('etc/bluegit-backup/config.yml')
12 options=('!debug')
13 install=bluegit-backup.install
14 _commit=0000000000000000000000000000000000000000
15 source=("bluegit-backup-${_commit}.tar.gz::https://git.timfalken.com/timfa/bluegit-backup/-/archive/${_commit}/bluegit-backup-${_commit}.tar.gz")
16 sha256sums=('SKIP')
17
18 build() {
19 cd "$srcdir/bluegit-backup-${_commit}"
20 export CGO_ENABLED=0
21 export GOTOOLCHAIN=auto
22 export GOFLAGS='-trimpath'
23 export GOCACHE="${BUILDDIR:-$srcdir}/gocache"
24 export GOPATH="${BUILDDIR:-$srcdir}/gopath"
25 go build -ldflags="-s -w -X git.timfalken.com/timfa/bluegit-backup/internal/server.Version=${pkgver}" -o bluegit-backup ./cmd/bluegit-backup
26 }
27
28 package() {
29 cd "$srcdir/bluegit-backup-${_commit}"
30 install -Dm755 bluegit-backup "$pkgdir/usr/bin/bluegit-backup"
31 install -Dm644 packaging/bluegit-backup.service "$pkgdir/usr/lib/systemd/system/bluegit-backup.service"
32 install -Dm644 packaging/config.yml "$pkgdir/etc/bluegit-backup/config.yml"
33 install -Dm644 packaging/sysusers.conf "$pkgdir/usr/lib/sysusers.d/bluegit-backup.conf"
34 install -Dm644 packaging/tmpfiles.conf "$pkgdir/usr/lib/tmpfiles.d/bluegit-backup.conf"
35 install -Dm755 packaging/bluegit-backup-update.sh "$pkgdir/usr/lib/bluegit-backup/update"
36 install -Dm644 packaging/bluegit-backup-update.service "$pkgdir/usr/lib/systemd/system/bluegit-backup-update.service"
37 install -Dm644 packaging/bluegit-backup-update.rules "$pkgdir/usr/share/polkit-1/rules.d/49-bluegit-backup-update.rules"
38 install -Dm644 LICENSE "$pkgdir/usr/share/licenses/$pkgname/LICENSE"
39 }
@@ -0,0 +1,39 @@
1# Maintainer: Tim Falken <tim@timfalken.com>
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')
9depends=('curl')
10makedepends=('go')
11backup=('etc/bluegit-backup/config.yml')
12options=('!debug')
13install=bluegit-backup.install
14_commit=0000000000000000000000000000000000000000
15source=("bluegit-backup-${_commit}.tar.gz::https://git.timfalken.com/timfa/bluegit-backup/-/archive/${_commit}/bluegit-backup-${_commit}.tar.gz")
16sha256sums=('SKIP')
17
18build() {
19 cd "$srcdir/bluegit-backup-${_commit}"
20 export CGO_ENABLED=0
21 export GOTOOLCHAIN=auto
22 export GOFLAGS='-trimpath'
23 export GOCACHE="${BUILDDIR:-$srcdir}/gocache"
24 export GOPATH="${BUILDDIR:-$srcdir}/gopath"
25 go build -ldflags="-s -w -X git.timfalken.com/timfa/bluegit-backup/internal/server.Version=${pkgver}" -o bluegit-backup ./cmd/bluegit-backup
26}
27
28package() {
29 cd "$srcdir/bluegit-backup-${_commit}"
30 install -Dm755 bluegit-backup "$pkgdir/usr/bin/bluegit-backup"
31 install -Dm644 packaging/bluegit-backup.service "$pkgdir/usr/lib/systemd/system/bluegit-backup.service"
32 install -Dm644 packaging/config.yml "$pkgdir/etc/bluegit-backup/config.yml"
33 install -Dm644 packaging/sysusers.conf "$pkgdir/usr/lib/sysusers.d/bluegit-backup.conf"
34 install -Dm644 packaging/tmpfiles.conf "$pkgdir/usr/lib/tmpfiles.d/bluegit-backup.conf"
35 install -Dm755 packaging/bluegit-backup-update.sh "$pkgdir/usr/lib/bluegit-backup/update"
36 install -Dm644 packaging/bluegit-backup-update.service "$pkgdir/usr/lib/systemd/system/bluegit-backup-update.service"
37 install -Dm644 packaging/bluegit-backup-update.rules "$pkgdir/usr/share/polkit-1/rules.d/49-bluegit-backup-update.rules"
38 install -Dm644 LICENSE "$pkgdir/usr/share/licenses/$pkgname/LICENSE"
39}
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. BLUEGIT_BACKUP_UPDATE_TOKEN zet POST /api/v1/admin/self-update aan.
11 EnvironmentFile=-/etc/bluegit-backup/env
12 ExecStart=/usr/bin/bluegit-backup serve --config /etc/bluegit-backup/config.yml
13 Restart=on-failure
14 # Lage prioriteit: archiveren en comprimeren mogen de machine niet ophouden.
15 Nice=10
16 IOSchedulingClass=idle
17 NoNewPrivileges=true
18 ProtectSystem=strict
19 ProtectHome=true
20 StateDirectory=bluegit-backup
21 ReadWritePaths=/var/lib/bluegit-backup
22 PrivateTmp=true
23
24 [Install]
25 WantedBy=multi-user.target
@@ -0,0 +1,25 @@
1[Unit]
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. BLUEGIT_BACKUP_UPDATE_TOKEN zet POST /api/v1/admin/self-update aan.
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:8790
3 # Waar BlueGit deze server bereikt (meldingen, archieflijst, rollback).
4 public_url: http://backup.lan:8790
5 data_dir: /var/lib/bluegit-backup
6 # Zo vaak wordt de hele kopie gecomprimeerd opgeslagen. Standaard dagelijks.
7 archive_interval: 24h
8 # Archieven ouder dan dit gaan weg (0 = nooit op leeftijd). Het nieuwste blijft.
9 retention_days: 30
10 # Minder vrije ruimte dan dit: het oudste archief gaat weg.
11 min_free_mb: 1024
12 # Downloadsnelheid van BlueGit in KiB/s, zodat BlueGit er geen last van heeft.
13 rate_limit_kib: 1024
14 # Ook zonder melding zo vaak alles nalopen.
15 full_sync_interval: 1h
16 # Minimale tijd tussen twee syncs na meldingen.
17 min_sync_interval: 10s
@@ -0,0 +1,17 @@
1# bluegit-backup. Kopieer naar /etc/bluegit-backup/config.yml.
2listen: 0.0.0.0:8790
3# Waar BlueGit deze server bereikt (meldingen, archieflijst, rollback).
4public_url: http://backup.lan:8790
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 +2 −0
@@ -0,0 +1,2 @@
1 u bluegit-backup - "BlueGit backup server" /var/lib/bluegit-backup /usr/sbin/nologin
2 u bluegit-backup-build - "bluegit-backup package build" /var/lib/bluegit-backup-build /usr/bin/nologin
@@ -0,0 +1,2 @@
1u bluegit-backup - "BlueGit backup server" /var/lib/bluegit-backup /usr/sbin/nologin
2u bluegit-backup-build - "bluegit-backup package build" /var/lib/bluegit-backup-build /usr/bin/nologin
packaging/backup/tmpfiles.conf added +2 −0
@@ -0,0 +1,2 @@
1 d /var/lib/bluegit-backup 0750 bluegit-backup bluegit-backup -
2 d /var/lib/bluegit-backup-build 0750 bluegit-backup-build bluegit-backup-build -
@@ -0,0 +1,2 @@
1d /var/lib/bluegit-backup 0750 bluegit-backup bluegit-backup -
2d /var/lib/bluegit-backup-build 0750 bluegit-backup-build bluegit-backup-build -
packaging/bluegit-backup-update.rules added +12 −0
@@ -0,0 +1,12 @@
1 // Alleen gebruiker bluegit-backup mag deze ene unit starten.
2 polkit.addRule(function(action, subject) {
3 if (action.id != "org.freedesktop.systemd1.manage-units") {
4 return;
5 }
6 if (subject.user != "bluegit-backup") {
7 return;
8 }
9 if (action.lookup("verb") == "start" && action.lookup("unit") == "bluegit-backup-update.service") {
10 return polkit.Result.YES;
11 }
12 });
@@ -0,0 +1,12 @@
1// Alleen gebruiker bluegit-backup mag deze ene unit starten.
2polkit.addRule(function(action, subject) {
3 if (action.id != "org.freedesktop.systemd1.manage-units") {
4 return;
5 }
6 if (subject.user != "bluegit-backup") {
7 return;
8 }
9 if (action.lookup("verb") == "start" && action.lookup("unit") == "bluegit-backup-update.service") {
10 return polkit.Result.YES;
11 }
12});
packaging/bluegit-backup-update.service added +16 −0
@@ -0,0 +1,16 @@
1 [Unit]
2 Description=bluegit-backup self-update
3 After=network-online.target
4 Wants=network-online.target
5
6 [Service]
7 Type=oneshot
8 # Root installeert de nieuwe binary. De bluegit-backup-gebruiker mag alleen deze unit starten.
9 User=root
10 Environment=BLUEGIT_BACKUP_STATE_DIR=/var/lib/bluegit-backup
11 Environment=BLUEGIT_BACKUP_BUILD_USER=bluegit-backup-build
12 EnvironmentFile=-/etc/bluegit-backup/env
13 ExecStart=/usr/lib/bluegit-backup/update
14 TimeoutStartSec=1h
15 StandardOutput=journal
16 StandardError=journal
@@ -0,0 +1,16 @@
1[Unit]
2Description=bluegit-backup self-update
3After=network-online.target
4Wants=network-online.target
5
6[Service]
7Type=oneshot
8# Root installeert de nieuwe binary. De bluegit-backup-gebruiker mag alleen deze unit starten.
9User=root
10Environment=BLUEGIT_BACKUP_STATE_DIR=/var/lib/bluegit-backup
11Environment=BLUEGIT_BACKUP_BUILD_USER=bluegit-backup-build
12EnvironmentFile=-/etc/bluegit-backup/env
13ExecStart=/usr/lib/bluegit-backup/update
14TimeoutStartSec=1h
15StandardOutput=journal
16StandardError=journal
packaging/bluegit-backup-update.sh added +51 −0
@@ -0,0 +1,51 @@
1 #!/usr/bin/env bash
2 # Self-update van bluegit-backup. Draait als root via bluegit-backup-update.service.
3 # Leest de commit uit update-request, haalt de bronarchief van die commit op,
4 # bouwt als onbevoegde gebruiker en installeert de binary. Met pacman en
5 # makepkg bouwt hij het AUR-pakket (zelfde PKGBUILD); anders alleen de binary.
6 # Bij een fout blijft de geïnstalleerde versie staan.
7 set -euo pipefail
8
9 : "${BLUEGIT_BACKUP_STATE_DIR:=/var/lib/bluegit-backup}"
10 : "${BLUEGIT_BACKUP_BUILD_USER:=bluegit-backup-build}"
11 : "${BLUEGIT_BACKUP_SOURCE:=https://git.timfalken.com/timfa/bluegit-backup}"
12
13 REQUEST="${BLUEGIT_BACKUP_STATE_DIR}/update-request"
14 STATUS="${BLUEGIT_BACKUP_STATE_DIR}/update-status.json"
15
16 write_status() {
17 local result="$1" sha="$2" err="${3:-}"
18 err="${err//$'\n'/ }"
19 err="${err//\"/}"
20 printf '{"time":"%s","sha":"%s","result":"%s","error":"%s"}\n' "$(date -u +%Y-%m-%dT%H:%M:%SZ)" "$sha" "$result" "$err" > "$STATUS.tmp"
21 chmod 644 "$STATUS.tmp"
22 mv -f "$STATUS.tmp" "$STATUS"
23 }
24
25 sha="$(tr -d '[:space:]' < "$REQUEST" 2>/dev/null || true)"
26 if [[ ! "$sha" =~ ^[0-9a-f]{40}$ ]]; then
27 write_status failed "" "update-request is geen volledige sha"
28 exit 1
29 fi
30 trap 'write_status failed "$sha" "zie journalctl -u bluegit-backup-update"' ERR
31
32 work="$(mktemp -d /var/tmp/bluegit-backup-update.XXXXXX)"
33 trap 'rm -rf "$work"' EXIT
34 chown "$BLUEGIT_BACKUP_BUILD_USER:" "$work"
35 url="${BLUEGIT_BACKUP_SOURCE}/-/archive/${sha}/bluegit-backup-${sha}.tar.gz"
36 echo "Downloaden: $url"
37 runuser -u "$BLUEGIT_BACKUP_BUILD_USER" -- curl -fsSL "$url" -o "$work/src.tar.gz"
38 runuser -u "$BLUEGIT_BACKUP_BUILD_USER" -- tar -xzf "$work/src.tar.gz" -C "$work"
39 src="$work/bluegit-backup-${sha}"
40 [[ -d "$src" ]] || src="$(find "$work" -mindepth 1 -maxdepth 1 -type d | head -n 1)"
41
42 echo "Bouwen als $BLUEGIT_BACKUP_BUILD_USER"
43 runuser -u "$BLUEGIT_BACKUP_BUILD_USER" -- env HOME="$work" GOCACHE="$work/gocache" GOPATH="$work/gopath" \
44 CGO_ENABLED=0 GOTOOLCHAIN=auto GOFLAGS=-trimpath \
45 sh -c "cd '$src' && go build -ldflags='-s -w -X git.timfalken.com/timfa/bluegit-backup/internal/server.Version=${sha:0:12}' -o '$work/bluegit-backup' ./cmd/bluegit-backup"
46
47 install -Dm755 "$work/bluegit-backup" /usr/bin/bluegit-backup.new
48 mv -f /usr/bin/bluegit-backup.new /usr/bin/bluegit-backup
49 systemctl try-restart bluegit-backup.service
50 write_status success "$sha"
51 echo "bluegit-backup bijgewerkt naar $sha"
@@ -0,0 +1,51 @@
1#!/usr/bin/env bash
2# Self-update van bluegit-backup. Draait als root via bluegit-backup-update.service.
3# Leest de commit uit update-request, haalt de bronarchief van die commit op,
4# bouwt als onbevoegde gebruiker en installeert de binary. Met pacman en
5# makepkg bouwt hij het AUR-pakket (zelfde PKGBUILD); anders alleen de binary.
6# Bij een fout blijft de geïnstalleerde versie staan.
7set -euo pipefail
8
9: "${BLUEGIT_BACKUP_STATE_DIR:=/var/lib/bluegit-backup}"
10: "${BLUEGIT_BACKUP_BUILD_USER:=bluegit-backup-build}"
11: "${BLUEGIT_BACKUP_SOURCE:=https://git.timfalken.com/timfa/bluegit-backup}"
12
13REQUEST="${BLUEGIT_BACKUP_STATE_DIR}/update-request"
14STATUS="${BLUEGIT_BACKUP_STATE_DIR}/update-status.json"
15
16write_status() {
17 local result="$1" sha="$2" err="${3:-}"
18 err="${err//$'\n'/ }"
19 err="${err//\"/}"
20 printf '{"time":"%s","sha":"%s","result":"%s","error":"%s"}\n' "$(date -u +%Y-%m-%dT%H:%M:%SZ)" "$sha" "$result" "$err" > "$STATUS.tmp"
21 chmod 644 "$STATUS.tmp"
22 mv -f "$STATUS.tmp" "$STATUS"
23}
24
25sha="$(tr -d '[:space:]' < "$REQUEST" 2>/dev/null || true)"
26if [[ ! "$sha" =~ ^[0-9a-f]{40}$ ]]; then
27 write_status failed "" "update-request is geen volledige sha"
28 exit 1
29fi
30trap 'write_status failed "$sha" "zie journalctl -u bluegit-backup-update"' ERR
31
32work="$(mktemp -d /var/tmp/bluegit-backup-update.XXXXXX)"
33trap 'rm -rf "$work"' EXIT
34chown "$BLUEGIT_BACKUP_BUILD_USER:" "$work"
35url="${BLUEGIT_BACKUP_SOURCE}/-/archive/${sha}/bluegit-backup-${sha}.tar.gz"
36echo "Downloaden: $url"
37runuser -u "$BLUEGIT_BACKUP_BUILD_USER" -- curl -fsSL "$url" -o "$work/src.tar.gz"
38runuser -u "$BLUEGIT_BACKUP_BUILD_USER" -- tar -xzf "$work/src.tar.gz" -C "$work"
39src="$work/bluegit-backup-${sha}"
40[[ -d "$src" ]] || src="$(find "$work" -mindepth 1 -maxdepth 1 -type d | head -n 1)"
41
42echo "Bouwen als $BLUEGIT_BACKUP_BUILD_USER"
43runuser -u "$BLUEGIT_BACKUP_BUILD_USER" -- env HOME="$work" GOCACHE="$work/gocache" GOPATH="$work/gopath" \
44 CGO_ENABLED=0 GOTOOLCHAIN=auto GOFLAGS=-trimpath \
45 sh -c "cd '$src' && go build -ldflags='-s -w -X git.timfalken.com/timfa/bluegit-backup/internal/server.Version=${sha:0:12}' -o '$work/bluegit-backup' ./cmd/bluegit-backup"
46
47install -Dm755 "$work/bluegit-backup" /usr/bin/bluegit-backup.new
48mv -f /usr/bin/bluegit-backup.new /usr/bin/bluegit-backup
49systemctl try-restart bluegit-backup.service
50write_status success "$sha"
51echo "bluegit-backup bijgewerkt naar $sha"