BlueGit

timfa bluegit

Files

bluegit / internal / backupserver / mirror / remote.go

remote.go

remote.go 4.1 KiB Download Raw
1// Package mirror houdt de draaiende kopie van één BlueGit bij.
2package mirror
3
4import (
5 "bytes"
6 "context"
7 "encoding/json"
8 "errors"
9 "fmt"
10 "io"
11 "net/http"
12 "net/url"
13 "strings"
14 "time"
15
16 "git.timfalken.com/timfa/bluegit-backup/internal/protocol"
17 "git.timfalken.com/timfa/bluegit-backup/internal/throttle"
18)
19
20// ErrGone betekent dat een bestand tussen manifest en download verdween.
21var ErrGone = errors.New("bestand verdwenen")
22
23// Remote is de backup-API van één BlueGit, met de Backupserver-Key.
24type Remote struct {
25 URL string
26 Key string
27 HTTP *http.Client
28 Limiter *throttle.Limiter
29}
30
31func (r *Remote) client() *http.Client {
32 if r.HTTP != nil {
33 return r.HTTP
34 }
35 return &http.Client{Timeout: 0}
36}
37
38func (r *Remote) req(ctx context.Context, method, p string, body io.Reader) (*http.Response, error) {
39 req, err := http.NewRequestWithContext(ctx, method, strings.TrimRight(r.URL, "/")+p, body)
40 if err != nil {
41 return nil, err
42 }
43 req.Header.Set("Authorization", "Bearer "+r.Key)
44 req.Header.Set("User-Agent", "bluegit-backup")
45 resp, err := r.client().Do(req)
46 if err != nil {
47 return nil, err
48 }
49 if resp.StatusCode >= 300 {
50 defer resp.Body.Close()
51 raw, _ := io.ReadAll(io.LimitReader(resp.Body, 1<<16))
52 var e struct {
53 Error string `json:"error"`
54 }
55 _ = json.Unmarshal(raw, &e)
56 if e.Error == "" {
57 e.Error = strings.TrimSpace(string(raw))
58 }
59 if resp.StatusCode == http.StatusNotFound && strings.HasPrefix(p, "/api/v1/backup/file") {
60 return nil, ErrGone
61 }
62 return nil, &HTTPError{Status: resp.StatusCode, Msg: e.Error}
63 }
64 return resp, nil
65}
66
67// HTTPError is een foutantwoord van BlueGit.
68type HTTPError struct {
69 Status int
70 Msg string
71}
72
73func (e *HTTPError) Error() string { return fmt.Sprintf("BlueGit HTTP %d: %s", e.Status, e.Msg) }
74
75func (r *Remote) getJSON(ctx context.Context, p string, out any) error {
76 resp, err := r.req(ctx, http.MethodGet, p, nil)
77 if err != nil {
78 return err
79 }
80 defer resp.Body.Close()
81 return json.NewDecoder(resp.Body).Decode(out)
82}
83
84// Info vraagt het instance-id op en controleert zo ook de key.
85func (r *Remote) Info(ctx context.Context) (protocol.Info, error) {
86 var out protocol.Info
87 err := r.getJSON(ctx, "/api/v1/backup/info", &out)
88 return out, err
89}
90
91// Connect vertelt BlueGit waar deze server bereikbaar is.
92func (r *Remote) Connect(ctx context.Context, publicURL, serverID string) error {
93 b, _ := json.Marshal(map[string]string{"server_url": publicURL, "server_id": serverID})
94 resp, err := r.req(ctx, http.MethodPost, "/api/v1/backup/connect", bytes.NewReader(b))
95 if err != nil {
96 return err
97 }
98 resp.Body.Close()
99 return nil
100}
101
102// Manifest vraagt de volledige lijst op. BlueGit maakt daarbij een nieuwe
103// databasekopie.
104func (r *Remote) Manifest(ctx context.Context) (protocol.Manifest, error) {
105 var out protocol.Manifest
106 err := r.getJSON(ctx, "/api/v1/backup/manifest", &out)
107 return out, err
108}
109
110// Fetch opent één bestand, begrensd door de limiter.
111func (r *Remote) Fetch(ctx context.Context, logical string) (io.ReadCloser, error) {
112 resp, err := r.req(ctx, http.MethodGet, "/api/v1/backup/file?path="+url.QueryEscape(logical), nil)
113 if err != nil {
114 return nil, err
115 }
116 return struct {
117 io.Reader
118 io.Closer
119 }{r.Limiter.Reader(ctx, resp.Body), resp.Body}, nil
120}
121
122// Restore stuurt een tar.gz naar BlueGit. BlueGit herstart daarna.
123func (r *Remote) Restore(ctx context.Context, body io.Reader) error {
124 resp, err := r.req(ctx, http.MethodPost, "/api/v1/backup/restore", body)
125 if err != nil {
126 return err
127 }
128 resp.Body.Close()
129 return nil
130}
131
132// WaitUp wacht tot BlueGit na een herstart weer antwoordt.
133func (r *Remote) WaitUp(ctx context.Context, timeout time.Duration) error {
134 deadline := time.Now().Add(timeout)
135 // Eerst kort wachten: BlueGit herstart pas na zijn 202.
136 time.Sleep(500 * time.Millisecond)
137 for {
138 c, cancel := context.WithTimeout(ctx, 3*time.Second)
139 _, err := r.Info(c)
140 cancel()
141 if err == nil {
142 return nil
143 }
144 if time.Now().After(deadline) {
145 return fmt.Errorf("BlueGit kwam niet terug: %w", err)
146 }
147 select {
148 case <-ctx.Done():
149 return ctx.Err()
150 case <-time.After(300 * time.Millisecond):
151 }
152 }
153}