BlueGit

timfa bluegit

Files

bluegit / cmd / bluegit-backup / main.go

main.go

main.go 10.1 KiB Download Raw
1// bluegit-backup houdt een kopie bij van één BlueGit-instantie.
2package main
3
4import (
5 "bufio"
6 "bytes"
7 "context"
8 "encoding/json"
9 "flag"
10 "fmt"
11 "io"
12 "log/slog"
13 "net"
14 "net/http"
15 "net/url"
16 "os"
17 "os/signal"
18 "strings"
19 "syscall"
20 "time"
21
22 "gitlab.com/Timfa/bluegit/internal/backupserver/config"
23 "gitlab.com/Timfa/bluegit/internal/backupserver/server"
24)
25
26func usage() {
27 fmt.Fprint(os.Stderr, `bluegit-backup
28
29 bluegit-backup serve [--config /etc/bluegit-backup/config.yml]
30 bluegit-backup connect [--config …] --url https://git.example.com [--key bgbk_…] [--on-conflict wipe|restore]
31 bluegit-backup status [--config …]
32 bluegit-backup list [--config …]
33 bluegit-backup archive [--config …] nu een archief maken
34 bluegit-backup sync [--config …] nu synchroniseren
35 bluegit-backup prune [--config …] bewaarregels nu toepassen
36 bluegit-backup config [--config …] instellingen tonen
37 bluegit-backup set [--config …] sleutel=waarde … instellingen wijzigen
38 bluegit-backup delete [--config …] ARCHIEF
39 bluegit-backup rollback [--config …] ARCHIEF (vraagt om de naam over te typen)
40 bluegit-backup disconnect [--config …]
41 bluegit-backup actions [--config …] alle API-acties
42 bluegit-backup token [--config …] het beheertoken voor de webinterface
43 bluegit-backup example-config
44 bluegit-backup version
45
46De key kan ook uit BLUEGIT_BACKUP_KEY komen (dan staat hij niet in de proceslijst).
47`)
48}
49
50func main() {
51 if len(os.Args) < 2 {
52 usage()
53 os.Exit(2)
54 }
55 var err error
56 switch os.Args[1] {
57 case "serve":
58 err = serve(os.Args[2:])
59 case "connect":
60 err = connect(os.Args[2:], os.Stdin, os.Stdout)
61 case "status":
62 err = simple(os.Args[2:], http.MethodGet, "/api/v1/admin/status")
63 case "list":
64 err = simple(os.Args[2:], http.MethodGet, "/api/v1/admin/archives")
65 case "archive":
66 err = simple(os.Args[2:], http.MethodPost, "/api/v1/admin/archive")
67 case "sync":
68 err = simple(os.Args[2:], http.MethodPost, "/api/v1/admin/sync")
69 case "prune":
70 err = simple(os.Args[2:], http.MethodPost, "/api/v1/admin/prune")
71 case "config":
72 err = simple(os.Args[2:], http.MethodGet, "/api/v1/admin/config")
73 case "set":
74 err = setConfig(os.Args[2:])
75 case "disconnect":
76 err = simple(os.Args[2:], http.MethodPost, "/api/v1/admin/disconnect")
77 case "delete":
78 err = withName(os.Args[2:], func(c *client, name string) (int, []byte, error) {
79 return c.do(http.MethodDelete, "/api/v1/admin/archives/"+url.PathEscape(name), nil)
80 })
81 case "rollback":
82 err = rollback(os.Args[2:], os.Stdin, os.Stdout)
83 case "actions":
84 err = simple(os.Args[2:], http.MethodGet, "/api/v1/admin/actions")
85 case "token":
86 err = printToken(os.Args[2:])
87 case "example-config":
88 fmt.Print(config.Example())
89 case "version", "--version":
90 fmt.Println(server.Version)
91 default:
92 usage()
93 os.Exit(2)
94 }
95 if err != nil {
96 fmt.Fprintln(os.Stderr, "bluegit-backup:", err)
97 os.Exit(1)
98 }
99}
100
101func configPath(p string) string {
102 if p != "" {
103 return p
104 }
105 if v := os.Getenv("BLUEGIT_BACKUP_CONFIG"); v != "" {
106 return v
107 }
108 if _, err := os.Stat("bluegit-backup.yml"); err == nil {
109 return "bluegit-backup.yml"
110 }
111 return "/etc/bluegit-backup/config.yml"
112}
113
114func serve(args []string) error {
115 fs := flag.NewFlagSet("serve", flag.ExitOnError)
116 cfgPath := fs.String("config", "", "pad naar config.yml")
117 _ = fs.Parse(args)
118 cfg, err := config.Load(configPath(*cfgPath))
119 if err != nil {
120 return err
121 }
122 log := slog.New(slog.NewTextHandler(os.Stdout, nil))
123 srv, err := server.New(cfg, log)
124 if err != nil {
125 return err
126 }
127 ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
128 defer stop()
129 cfg = srv.Cfg // met settings.yml
130 ln, err := net.Listen("tcp", cfg.Listen)
131 if err != nil {
132 return err
133 }
134 hs := &http.Server{Handler: srv.Handler(), ReadHeaderTimeout: 10 * time.Second}
135 go func() {
136 <-ctx.Done()
137 c, cancel := context.WithTimeout(context.Background(), 10*time.Second)
138 defer cancel()
139 _ = hs.Shutdown(c)
140 }()
141 srv.Run(ctx)
142 log.Info("bluegit-backup luistert", "addr", ln.Addr().String(), "public_url", cfg.PublicURL, "version", server.Version)
143 if err := hs.Serve(ln); err != nil && err != http.ErrServerClosed {
144 return err
145 }
146 return nil
147}
148
149type client struct {
150 base, token string
151}
152
153func newClient(cfgPath string) (*client, error) {
154 cfg, err := config.Load(configPath(cfgPath))
155 if err != nil {
156 return nil, err
157 }
158 if set, err := config.LoadSettings(cfg.DataDir); err == nil {
159 _ = cfg.Apply(set)
160 }
161 tok, err := server.ReadAdminToken(cfg.DataDir)
162 if err != nil {
163 return nil, fmt.Errorf("admin.token lezen (draai als de gebruiker van de dienst of root): %w", err)
164 }
165 host, port, err := net.SplitHostPort(cfg.Listen)
166 if err != nil {
167 return nil, err
168 }
169 if host == "" || host == "0.0.0.0" || host == "::" {
170 host = "127.0.0.1"
171 }
172 return &client{base: "http://" + net.JoinHostPort(host, port), token: tok}, nil
173}
174
175func (c *client) do(method, p string, in any) (int, []byte, error) {
176 var body io.Reader
177 if in != nil {
178 b, _ := json.Marshal(in)
179 body = bytes.NewReader(b)
180 }
181 req, _ := http.NewRequest(method, c.base+p, body)
182 req.Header.Set("Authorization", "Bearer "+c.token)
183 req.Header.Set("Content-Type", "application/json")
184 resp, err := (&http.Client{Timeout: 30 * time.Minute}).Do(req)
185 if err != nil {
186 return 0, nil, err
187 }
188 defer resp.Body.Close()
189 b, _ := io.ReadAll(resp.Body)
190 return resp.StatusCode, b, nil
191}
192
193func printResult(code int, b []byte) error {
194 var pretty bytes.Buffer
195 if json.Indent(&pretty, b, "", " ") == nil {
196 b = pretty.Bytes()
197 }
198 fmt.Println(strings.TrimSpace(string(b)))
199 if code >= 300 {
200 return fmt.Errorf("HTTP %d", code)
201 }
202 return nil
203}
204
205func setConfig(args []string) error {
206 fs := flag.NewFlagSet("set", flag.ExitOnError)
207 cfgPath := fs.String("config", "", "pad naar config.yml")
208 _ = fs.Parse(args)
209 set := map[string]string{}
210 for _, kv := range fs.Args() {
211 k, v, ok := strings.Cut(kv, "=")
212 if !ok {
213 return fmt.Errorf("verwacht sleutel=waarde, kreeg %q", kv)
214 }
215 set[k] = v
216 }
217 if len(set) == 0 {
218 return fmt.Errorf("geef minstens één sleutel=waarde")
219 }
220 c, err := newClient(*cfgPath)
221 if err != nil {
222 return err
223 }
224 code, b, err := c.do(http.MethodPut, "/api/v1/admin/config", set)
225 if err != nil {
226 return err
227 }
228 return printResult(code, b)
229}
230
231func withName(args []string, f func(c *client, name string) (int, []byte, error)) error {
232 fs := flag.NewFlagSet("cmd", flag.ExitOnError)
233 cfgPath := fs.String("config", "", "pad naar config.yml")
234 _ = fs.Parse(args)
235 if fs.NArg() != 1 {
236 return fmt.Errorf("geef precies één archiefnaam")
237 }
238 c, err := newClient(*cfgPath)
239 if err != nil {
240 return err
241 }
242 code, b, err := f(c, fs.Arg(0))
243 if err != nil {
244 return err
245 }
246 return printResult(code, b)
247}
248
249func rollback(args []string, stdin io.Reader, stdout io.Writer) error {
250 return withName(args, func(c *client, name string) (int, []byte, error) {
251 fmt.Fprintln(stdout, "LET OP: een rollback vervangt alle gegevens van BlueGit door dit archief en kan niet ongedaan worden gemaakt.")
252 fmt.Fprint(stdout, "Typ de archiefnaam over om door te gaan: ")
253 line, _ := bufio.NewReader(stdin).ReadString('\n')
254 if strings.TrimSpace(line) != name {
255 return 0, nil, fmt.Errorf("afgebroken; er is niets veranderd")
256 }
257 return c.do(http.MethodPost, "/api/v1/admin/rollback", map[string]string{"archive": name, "confirm": name})
258 })
259}
260
261func printToken(args []string) error {
262 fs := flag.NewFlagSet("token", flag.ExitOnError)
263 cfgPath := fs.String("config", "", "pad naar config.yml")
264 _ = fs.Parse(args)
265 cfg, err := config.Load(configPath(*cfgPath))
266 if err != nil {
267 return err
268 }
269 tok, err := server.ReadAdminToken(cfg.DataDir)
270 if err != nil {
271 return fmt.Errorf("admin.token niet leesbaar (start de server eerst, en draai als de gebruiker bluegit-backup): %w", err)
272 }
273 fmt.Println(tok)
274 return nil
275}
276
277func simple(args []string, method, p string) error {
278 fs := flag.NewFlagSet("cmd", flag.ExitOnError)
279 cfgPath := fs.String("config", "", "pad naar config.yml")
280 _ = fs.Parse(args)
281 c, err := newClient(*cfgPath)
282 if err != nil {
283 return err
284 }
285 code, b, err := c.do(method, p, nil)
286 if err != nil {
287 return err
288 }
289 var pretty bytes.Buffer
290 if json.Indent(&pretty, b, "", " ") == nil {
291 b = pretty.Bytes()
292 }
293 fmt.Println(string(b))
294 if code >= 300 {
295 return fmt.Errorf("HTTP %d", code)
296 }
297 return nil
298}
299
300func connect(args []string, stdin io.Reader, stdout io.Writer) error {
301 fs := flag.NewFlagSet("connect", flag.ExitOnError)
302 cfgPath := fs.String("config", "", "pad naar config.yml")
303 u := fs.String("url", "", "adres van BlueGit")
304 key := fs.String("key", "", "Backupserver-Key (of BLUEGIT_BACKUP_KEY)")
305 onConflict := fs.String("on-conflict", "", "wipe of restore, zonder te vragen")
306 _ = fs.Parse(args)
307 if *key == "" {
308 *key = os.Getenv("BLUEGIT_BACKUP_KEY")
309 }
310 if *u == "" || *key == "" {
311 return fmt.Errorf("--url en --key (of BLUEGIT_BACKUP_KEY) zijn nodig")
312 }
313 c, err := newClient(*cfgPath)
314 if err != nil {
315 return err
316 }
317 req := server.ConnectRequest{URL: *u, Key: *key, OnConflict: *onConflict}
318 code, b, err := c.do(http.MethodPost, "/api/v1/admin/connect", req)
319 if err != nil {
320 return err
321 }
322 if code == http.StatusConflict {
323 var cf server.ConflictError
324 _ = json.Unmarshal(b, &cf)
325 fmt.Fprintf(stdout, "Deze backup server hoort bij een andere BlueGit (%s, instance %s) en heeft %d archief/archieven.\n", cf.PreviousURL, cf.PreviousInstance, cf.Archives)
326 fmt.Fprintln(stdout, "Een backup server kan maar aan één BlueGit gekoppeld zijn. Kies:")
327 fmt.Fprintln(stdout, " 1) Oude backups verwijderen en met de nieuwe instantie verbinden")
328 fmt.Fprintln(stdout, " 2) De nieuwe instantie terugzetten naar de gegevens in deze backup server (overschrijft alles daar)")
329 fmt.Fprint(stdout, "Keuze [1/2, leeg = afbreken]: ")
330 line, _ := bufio.NewReader(stdin).ReadString('\n')
331 switch strings.TrimSpace(line) {
332 case "1":
333 req.OnConflict = "wipe"
334 case "2":
335 req.OnConflict = "restore"
336 default:
337 return fmt.Errorf("afgebroken; er is niets veranderd")
338 }
339 code, b, err = c.do(http.MethodPost, "/api/v1/admin/connect", req)
340 if err != nil {
341 return err
342 }
343 }
344 fmt.Fprintln(stdout, strings.TrimSpace(string(b)))
345 if code >= 300 {
346 return fmt.Errorf("HTTP %d", code)
347 }
348 return nil
349}