BlueGit

timfa bluegit

Files

bluegit / cmd / bluegit-backup / main.go

main.go

main.go 6.5 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 "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}