// bluegit-backup houdt een kopie bij van één BlueGit-instantie. package main import ( "bufio" "bytes" "context" "encoding/json" "flag" "fmt" "io" "log/slog" "net" "net/http" "net/url" "os" "os/signal" "strings" "syscall" "time" "gitlab.com/Timfa/bluegit/internal/backupserver/config" "gitlab.com/Timfa/bluegit/internal/backupserver/server" ) func usage() { fmt.Fprint(os.Stderr, `bluegit-backup bluegit-backup serve [--config /etc/bluegit-backup/config.yml] bluegit-backup connect [--config …] --url https://git.example.com [--key bgbk_…] [--on-conflict wipe|restore] bluegit-backup status [--config …] bluegit-backup list [--config …] bluegit-backup archive [--config …] nu een archief maken bluegit-backup sync [--config …] nu synchroniseren bluegit-backup prune [--config …] bewaarregels nu toepassen bluegit-backup config [--config …] instellingen tonen bluegit-backup set [--config …] sleutel=waarde … instellingen wijzigen bluegit-backup delete [--config …] ARCHIEF bluegit-backup rollback [--config …] ARCHIEF (vraagt om de naam over te typen) bluegit-backup disconnect [--config …] bluegit-backup actions [--config …] alle API-acties bluegit-backup token [--config …] het beheertoken voor de webinterface bluegit-backup example-config bluegit-backup version De key kan ook uit BLUEGIT_BACKUP_KEY komen (dan staat hij niet in de proceslijst). `) } func main() { if len(os.Args) < 2 { usage() os.Exit(2) } var err error switch os.Args[1] { case "serve": err = serve(os.Args[2:]) case "connect": err = connect(os.Args[2:], os.Stdin, os.Stdout) case "status": err = simple(os.Args[2:], http.MethodGet, "/api/v1/admin/status") case "list": err = simple(os.Args[2:], http.MethodGet, "/api/v1/admin/archives") case "archive": err = simple(os.Args[2:], http.MethodPost, "/api/v1/admin/archive") case "sync": err = simple(os.Args[2:], http.MethodPost, "/api/v1/admin/sync") case "prune": err = simple(os.Args[2:], http.MethodPost, "/api/v1/admin/prune") case "config": err = simple(os.Args[2:], http.MethodGet, "/api/v1/admin/config") case "set": err = setConfig(os.Args[2:]) case "disconnect": err = simple(os.Args[2:], http.MethodPost, "/api/v1/admin/disconnect") case "delete": err = withName(os.Args[2:], func(c *client, name string) (int, []byte, error) { return c.do(http.MethodDelete, "/api/v1/admin/archives/"+url.PathEscape(name), nil) }) case "rollback": err = rollback(os.Args[2:], os.Stdin, os.Stdout) case "actions": err = simple(os.Args[2:], http.MethodGet, "/api/v1/admin/actions") case "token": err = printToken(os.Args[2:]) case "example-config": fmt.Print(config.Example()) case "version", "--version": fmt.Println(server.Version) default: usage() os.Exit(2) } if err != nil { fmt.Fprintln(os.Stderr, "bluegit-backup:", err) os.Exit(1) } } func configPath(p string) string { if p != "" { return p } if v := os.Getenv("BLUEGIT_BACKUP_CONFIG"); v != "" { return v } if _, err := os.Stat("bluegit-backup.yml"); err == nil { return "bluegit-backup.yml" } return "/etc/bluegit-backup/config.yml" } func serve(args []string) error { fs := flag.NewFlagSet("serve", flag.ExitOnError) cfgPath := fs.String("config", "", "pad naar config.yml") _ = fs.Parse(args) cfg, err := config.Load(configPath(*cfgPath)) if err != nil { return err } log := slog.New(slog.NewTextHandler(os.Stdout, nil)) srv, err := server.New(cfg, log) if err != nil { return err } ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM) defer stop() cfg = srv.Cfg // met settings.yml ln, err := net.Listen("tcp", cfg.Listen) if err != nil { return err } hs := &http.Server{Handler: srv.Handler(), ReadHeaderTimeout: 10 * time.Second} go func() { <-ctx.Done() c, cancel := context.WithTimeout(context.Background(), 10*time.Second) defer cancel() _ = hs.Shutdown(c) }() srv.Run(ctx) log.Info("bluegit-backup luistert", "addr", ln.Addr().String(), "public_url", cfg.PublicURL, "version", server.Version) if err := hs.Serve(ln); err != nil && err != http.ErrServerClosed { return err } return nil } type client struct { base, token string } func newClient(cfgPath string) (*client, error) { cfg, err := config.Load(configPath(cfgPath)) if err != nil { return nil, err } if set, err := config.LoadSettings(cfg.DataDir); err == nil { _ = cfg.Apply(set) } tok, err := server.ReadAdminToken(cfg.DataDir) if err != nil { return nil, fmt.Errorf("admin.token lezen (draai als de gebruiker van de dienst of root): %w", err) } host, port, err := net.SplitHostPort(cfg.Listen) if err != nil { return nil, err } if host == "" || host == "0.0.0.0" || host == "::" { host = "127.0.0.1" } return &client{base: "http://" + net.JoinHostPort(host, port), token: tok}, nil } func (c *client) do(method, p string, in any) (int, []byte, error) { var body io.Reader if in != nil { b, _ := json.Marshal(in) body = bytes.NewReader(b) } req, _ := http.NewRequest(method, c.base+p, body) req.Header.Set("Authorization", "Bearer "+c.token) req.Header.Set("Content-Type", "application/json") resp, err := (&http.Client{Timeout: 30 * time.Minute}).Do(req) if err != nil { return 0, nil, err } defer resp.Body.Close() b, _ := io.ReadAll(resp.Body) return resp.StatusCode, b, nil } func printResult(code int, b []byte) error { var pretty bytes.Buffer if json.Indent(&pretty, b, "", " ") == nil { b = pretty.Bytes() } fmt.Println(strings.TrimSpace(string(b))) if code >= 300 { return fmt.Errorf("HTTP %d", code) } return nil } func setConfig(args []string) error { fs := flag.NewFlagSet("set", flag.ExitOnError) cfgPath := fs.String("config", "", "pad naar config.yml") _ = fs.Parse(args) set := map[string]string{} for _, kv := range fs.Args() { k, v, ok := strings.Cut(kv, "=") if !ok { return fmt.Errorf("verwacht sleutel=waarde, kreeg %q", kv) } set[k] = v } if len(set) == 0 { return fmt.Errorf("geef minstens één sleutel=waarde") } c, err := newClient(*cfgPath) if err != nil { return err } code, b, err := c.do(http.MethodPut, "/api/v1/admin/config", set) if err != nil { return err } return printResult(code, b) } func withName(args []string, f func(c *client, name string) (int, []byte, error)) error { fs := flag.NewFlagSet("cmd", flag.ExitOnError) cfgPath := fs.String("config", "", "pad naar config.yml") _ = fs.Parse(args) if fs.NArg() != 1 { return fmt.Errorf("geef precies één archiefnaam") } c, err := newClient(*cfgPath) if err != nil { return err } code, b, err := f(c, fs.Arg(0)) if err != nil { return err } return printResult(code, b) } func rollback(args []string, stdin io.Reader, stdout io.Writer) error { return withName(args, func(c *client, name string) (int, []byte, error) { fmt.Fprintln(stdout, "LET OP: een rollback vervangt alle gegevens van BlueGit door dit archief en kan niet ongedaan worden gemaakt.") fmt.Fprint(stdout, "Typ de archiefnaam over om door te gaan: ") line, _ := bufio.NewReader(stdin).ReadString('\n') if strings.TrimSpace(line) != name { return 0, nil, fmt.Errorf("afgebroken; er is niets veranderd") } return c.do(http.MethodPost, "/api/v1/admin/rollback", map[string]string{"archive": name, "confirm": name}) }) } func printToken(args []string) error { fs := flag.NewFlagSet("token", flag.ExitOnError) cfgPath := fs.String("config", "", "pad naar config.yml") _ = fs.Parse(args) cfg, err := config.Load(configPath(*cfgPath)) if err != nil { return err } tok, err := server.ReadAdminToken(cfg.DataDir) if err != nil { return fmt.Errorf("admin.token niet leesbaar (start de server eerst, en draai als de gebruiker bluegit-backup): %w", err) } fmt.Println(tok) return nil } func simple(args []string, method, p string) error { fs := flag.NewFlagSet("cmd", flag.ExitOnError) cfgPath := fs.String("config", "", "pad naar config.yml") _ = fs.Parse(args) c, err := newClient(*cfgPath) if err != nil { return err } code, b, err := c.do(method, p, nil) if err != nil { return err } var pretty bytes.Buffer if json.Indent(&pretty, b, "", " ") == nil { b = pretty.Bytes() } fmt.Println(string(b)) if code >= 300 { return fmt.Errorf("HTTP %d", code) } return nil } func connect(args []string, stdin io.Reader, stdout io.Writer) error { fs := flag.NewFlagSet("connect", flag.ExitOnError) cfgPath := fs.String("config", "", "pad naar config.yml") u := fs.String("url", "", "adres van BlueGit") key := fs.String("key", "", "Backupserver-Key (of BLUEGIT_BACKUP_KEY)") onConflict := fs.String("on-conflict", "", "wipe of restore, zonder te vragen") _ = fs.Parse(args) if *key == "" { *key = os.Getenv("BLUEGIT_BACKUP_KEY") } if *u == "" || *key == "" { return fmt.Errorf("--url en --key (of BLUEGIT_BACKUP_KEY) zijn nodig") } c, err := newClient(*cfgPath) if err != nil { return err } req := server.ConnectRequest{URL: *u, Key: *key, OnConflict: *onConflict} code, b, err := c.do(http.MethodPost, "/api/v1/admin/connect", req) if err != nil { return err } if code == http.StatusConflict { var cf server.ConflictError _ = json.Unmarshal(b, &cf) 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) fmt.Fprintln(stdout, "Een backup server kan maar aan één BlueGit gekoppeld zijn. Kies:") fmt.Fprintln(stdout, " 1) Oude backups verwijderen en met de nieuwe instantie verbinden") fmt.Fprintln(stdout, " 2) De nieuwe instantie terugzetten naar de gegevens in deze backup server (overschrijft alles daar)") fmt.Fprint(stdout, "Keuze [1/2, leeg = afbreken]: ") line, _ := bufio.NewReader(stdin).ReadString('\n') switch strings.TrimSpace(line) { case "1": req.OnConflict = "wipe" case "2": req.OnConflict = "restore" default: return fmt.Errorf("afgebroken; er is niets veranderd") } code, b, err = c.do(http.MethodPost, "/api/v1/admin/connect", req) if err != nil { return err } } fmt.Fprintln(stdout, strings.TrimSpace(string(b))) if code >= 300 { return fmt.Errorf("HTTP %d", code) } return nil }