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