// 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/apppaths" "gitlab.com/Timfa/bluegit/internal/backupserver/config" "gitlab.com/Timfa/bluegit/internal/backupserver/server" ) func usage() { fmt.Fprint(os.Stderr, `bluegit-backup Koppelen en instellingen regel je in de webinterface: open http://:8080, log in met het beheertoken (`+"`bluegit-backup token`"+`) en gebruik Instellingen en Koppeling. De CLI is een alternatief. bluegit-backup serve [--data-dir /var/lib/bluegit-backup] bluegit-backup connect [--data-dir …] --url https://git.example.com [--key bgbk_…] [--on-conflict wipe|restore] bluegit-backup status [--data-dir …] bluegit-backup list [--data-dir …] bluegit-backup archive [--data-dir …] nu een archief maken bluegit-backup sync [--data-dir …] nu synchroniseren bluegit-backup prune [--data-dir …] bewaarregels nu toepassen bluegit-backup config [--data-dir …] instellingen tonen bluegit-backup set [--data-dir …] sleutel=waarde … instellingen wijzigen bluegit-backup delete [--data-dir …] ARCHIEF bluegit-backup rollback [--data-dir …] ARCHIEF (vraagt om de naam over te typen) bluegit-backup disconnect [--data-dir …] bluegit-backup actions [--data-dir …] alle API-acties bluegit-backup token [--data-dir …] het beheertoken voor de webinterface bluegit-backup example-config oude config.yml (alleen voor eenmalige import) bluegit-backup version --data-dir mag ook BLUEGIT_BACKUP_DATA_DIR zijn (standaard /var/lib/bluegit-backup). Een oude --config / config.yml wordt één keer overgenomen in settings.yml. 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 { return apppaths.ConfigFile(p, "BLUEGIT_BACKUP_CONFIG", "bluegit-backup.yml", "/etc/bluegit-backup/config.yml", "BlueGit-backup") } type startFlags struct { fs *flag.FlagSet config *string dataDir *string } func newStartFlags(name string) *startFlags { fs := flag.NewFlagSet(name, flag.ExitOnError) s := &startFlags{fs: fs} s.config = fs.String("config", "", "pad naar een oude config.yml (wordt eenmaal overgenomen)") s.dataDir = fs.String("data-dir", "", "gegevensmap (standaard "+config.DefaultDataDir()+")") return s } func (s *startFlags) load(log *slog.Logger) (config.Config, error) { return config.LoadRuntime(config.Startup{ ConfigPath: configPath(*s.config), DataDir: *s.dataDir, DataDirEnv: os.Getenv("BLUEGIT_BACKUP_DATA_DIR"), }, log) } func serve(args []string) error { sf := newStartFlags("serve") _ = sf.fs.Parse(args) log := slog.New(slog.NewTextHandler(os.Stdout, nil)) cfg, err := sf.load(log) if err != nil { return err } srv, err := server.New(cfg, log) if err != nil { return err } ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM) defer stop() srv.Run(ctx) return srv.ListenAndServe(ctx) } type client struct { base, token string } func newClientFrom(sf *startFlags) (*client, error) { cfg, err := sf.load(nil) if err != nil { return nil, err } 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 { sf := newStartFlags("set") _ = sf.fs.Parse(args) set := map[string]string{} for _, kv := range sf.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 := newClientFrom(sf) 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 { sf := newStartFlags("cmd") _ = sf.fs.Parse(args) if sf.fs.NArg() != 1 { return fmt.Errorf("geef precies één archiefnaam") } c, err := newClientFrom(sf) if err != nil { return err } code, b, err := f(c, sf.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 { sf := newStartFlags("token") _ = sf.fs.Parse(args) cfg, err := sf.load(nil) 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 { sf := newStartFlags("cmd") _ = sf.fs.Parse(args) c, err := newClientFrom(sf) 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 { sf := newStartFlags("connect") u := sf.fs.String("url", "", "adres van BlueGit") key := sf.fs.String("key", "", "Backupserver-Key (of BLUEGIT_BACKUP_KEY)") onConflict := sf.fs.String("on-conflict", "", "wipe of restore, zonder te vragen") _ = sf.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 := newClientFrom(sf) 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 }