package server import ( "context" "crypto/subtle" "encoding/json" "errors" "fmt" "io" "net/http" "sort" "strconv" "strings" "gitlab.com/Timfa/bluegit/internal/backupserver/archive" "gitlab.com/Timfa/bluegit/internal/backupserver/config" "gitlab.com/Timfa/bluegit/internal/backupserver/mirror" "gitlab.com/Timfa/bluegit/internal/backupserver/protocol" ) // Input is de invoer van een actie: JSON-velden, querystring, formulier of // padwaarden, allemaal als tekst. type Input map[string]string // Action is één beheerhandeling. De API, de webinterface en BlueGit lopen // allemaal via deze lijst, zodat ze precies hetzelfde kunnen. type Action struct { // Name is de naam in de webinterface (/ui/act/). Name string `json:"name"` Method string `json:"method"` Path string `json:"path"` // Title is de knoptekst of beschrijving. Title string `json:"title"` // Signed: ook de gekoppelde BlueGit mag dit (ondertekend verzoek). Signed bool `json:"bluegit"` // Params zijn de padwaarden, bijvoorbeeld {name}. Params []string `json:"params,omitempty"` // Fields zijn de invoervelden (documentatie en de lijst in /api/v1/admin/actions). Fields []string `json:"fields,omitempty"` Do func(ctx context.Context, in Input) (int, any) `json:"-"` } // fileResult laat de API een bestand sturen in plaats van JSON. type fileResult struct{ path, name string } func errBody(err error) map[string]string { return map[string]string{"error": err.Error()} } // Actions is de volledige lijst met beheerhandelingen. func (s *Server) Actions() []Action { return []Action{ {Name: "status", Method: "GET", Path: "/api/v1/admin/status", Title: "Status", Signed: true, Do: func(ctx context.Context, in Input) (int, any) { return 200, s.Status() }}, {Name: "actions", Method: "GET", Path: "/api/v1/admin/actions", Title: "Alle acties", Signed: true, Do: func(ctx context.Context, in Input) (int, any) { return 200, map[string]any{"actions": s.Actions()} }}, {Name: "config", Method: "GET", Path: "/api/v1/admin/config", Title: "Instellingen", Signed: true, Do: func(ctx context.Context, in Input) (int, any) { return 200, s.ConfigView() }}, {Name: "config.update", Method: "PUT", Path: "/api/v1/admin/config", Title: "Instellingen opslaan", Signed: true, Fields: fieldKeys(), Do: s.actConfigUpdate}, {Name: "connect", Method: "POST", Path: "/api/v1/admin/connect", Title: "Koppelen", Fields: []string{"url", "key", "on_conflict"}, Do: s.actConnect}, {Name: "disconnect", Method: "POST", Path: "/api/v1/admin/disconnect", Title: "Ontkoppelen", Signed: true, Do: s.actDisconnect}, {Name: "sync", Method: "POST", Path: "/api/v1/admin/sync", Title: "Nu synchroniseren", Signed: true, Fields: []string{"wait"}, Do: s.actSync}, {Name: "archive", Method: "POST", Path: "/api/v1/admin/archive", Title: "Nu archiveren", Signed: true, Do: func(ctx context.Context, in Input) (int, any) { a, err := s.ArchiveNow() if err != nil { return 409, errBody(err) } return 201, a }}, {Name: "prune", Method: "POST", Path: "/api/v1/admin/prune", Title: "Nu opruimen", Signed: true, Do: func(ctx context.Context, in Input) (int, any) { removed, err := s.Prune() if err != nil { return 500, errBody(err) } if removed == nil { removed = []string{} } return 200, map[string]any{"removed": removed} }}, {Name: "archives", Method: "GET", Path: "/api/v1/admin/archives", Title: "Archieven", Signed: true, Do: func(ctx context.Context, in Input) (int, any) { list, err := s.archives.List() if err != nil { return 500, errBody(err) } return 200, map[string]any{"archives": list} }}, {Name: "archive.download", Method: "GET", Path: "/api/v1/admin/archives/{name}/download", Title: "Downloaden", Params: []string{"name"}, Do: func(ctx context.Context, in Input) (int, any) { p, err := s.archives.Path(in["name"]) if err != nil { return 404, errBody(err) } return 200, fileResult{path: p, name: in["name"]} }}, {Name: "archive.delete", Method: "DELETE", Path: "/api/v1/admin/archives/{name}", Title: "Verwijderen", Signed: true, Params: []string{"name"}, Do: s.actArchiveDelete}, {Name: "rollback", Method: "POST", Path: "/api/v1/admin/rollback", Title: "Rollback", Signed: true, Fields: []string{"archive", "confirm"}, Do: s.actRollback}, } } func fieldKeys() []string { out := make([]string, 0, len(config.Fields)) for _, f := range config.Fields { out = append(out, f.Key) } return out } func (s *Server) action(name string) (Action, bool) { for _, a := range s.Actions() { if a.Name == name { return a, true } } return Action{}, false } // ConfigView is GET /api/v1/admin/config. type ConfigView struct { Fields []ConfigField `json:"fields"` DataDir string `json:"data_dir"` // Restart: er staat een wijziging klaar die pas na een herstart geldt. Restart bool `json:"restart_pending"` } // ConfigField is een veld met zijn waarde. type ConfigField struct { config.Field Value string `json:"value"` } // ConfigView geeft alle instellingen met hun huidige waarde. func (s *Server) ConfigView() ConfigView { s.mu.Lock() defer s.mu.Unlock() v := ConfigView{DataDir: s.Cfg.DataDir, Restart: s.restartPending} for _, f := range config.Fields { val := s.Cfg.Get(f.Key) if f.Restart { if p, ok := s.settings[f.Key]; ok { val = p } } v.Fields = append(v.Fields, ConfigField{Field: f, Value: val}) } return v } // UpdateConfig past instellingen toe en bewaart ze in settings.yml. Velden // met Restart gelden pas na een herstart. func (s *Server) UpdateConfig(set map[string]string) (ConfigView, error) { s.mu.Lock() next := s.Cfg if err := next.Apply(set); err != nil { s.mu.Unlock() return ConfigView{}, err } merged := map[string]string{} for k, v := range s.settings { merged[k] = v } for k := range set { merged[k] = next.Get(k) } if err := config.SaveSettings(next.DataDir, merged); err != nil { s.mu.Unlock() return ConfigView{}, err } for _, f := range config.Fields { if f.Restart { if _, ok := set[f.Key]; ok && next.Get(f.Key) != s.Cfg.Get(f.Key) { s.restartPending = true } // De draaiende waarde blijft tot de herstart. _ = next.Set(f.Key, s.Cfg.Get(f.Key)) } } s.settings = merged s.Cfg = next s.mu.Unlock() s.limiter.SetRate(next.RateLimitKiB << 10) keys := make([]string, 0, len(set)) for k := range set { keys = append(keys, k) } sort.Strings(keys) s.Log.Info("instellingen gewijzigd", "keys", strings.Join(keys, ",")) // Kortere intervallen meteen laten gelden. s.Kick() return s.ConfigView(), nil } func (s *Server) actConfigUpdate(ctx context.Context, in Input) (int, any) { set := map[string]string{} for k, v := range in { set[k] = v } if len(set) == 0 { return 400, errBody(errors.New("geen instellingen meegegeven")) } v, err := s.UpdateConfig(set) if err != nil { return 400, errBody(err) } return 200, v } func (s *Server) actConnect(ctx context.Context, in Input) (int, any) { res, conflict, err := s.Connect(ctx, ConnectRequest{URL: in["url"], Key: in["key"], OnConflict: in["on_conflict"]}) if conflict != nil { return http.StatusConflict, conflict } if err != nil { var he *mirror.HTTPError code := 502 if errors.As(err, &he) && he.Status == 401 { code = 401 } if errors.Is(err, errBadRequest) { code = 400 } return code, errBody(err) } return 200, res } // Disconnect vergeet de gekoppelde BlueGit. De kopie en de archieven blijven // staan; een volgende koppeling met een andere BlueGit vraagt dan weer om // wissen of herstellen. func (s *Server) Disconnect() error { s.work.Lock() defer s.work.Unlock() st := s.getState() keep := State{InstanceID: st.InstanceID, BlueGitURL: st.BlueGitURL} if err := saveState(s.Cfg.DataDir, keep); err != nil { return err } s.mu.Lock() s.state = keep s.bluegitKnown = false s.mu.Unlock() s.Log.Warn("ontkoppeld", "bluegit", st.BlueGitURL) return nil } func (s *Server) actDisconnect(ctx context.Context, in Input) (int, any) { if !s.getState().Connected() { return 409, errBody(errors.New("er is geen BlueGit gekoppeld")) } if err := s.Disconnect(); err != nil { return 500, errBody(err) } return 200, map[string]any{"connected": false} } func (s *Server) actSync(ctx context.Context, in Input) (int, any) { if !s.getState().Connected() { return 409, errBody(errors.New("geen BlueGit gekoppeld")) } if in["wait"] == "false" || in["wait"] == "0" { s.Kick() return 202, map[string]string{"state": "started"} } stats, err := s.SyncNow(ctx) if errors.Is(err, ErrIncompatible) { return http.StatusConflict, errBody(err) } if err != nil { return 502, errBody(err) } return 200, stats } func (s *Server) actArchiveDelete(ctx context.Context, in Input) (int, any) { name := in["name"] if !archive.ValidName(name) { return 400, errBody(errors.New("ongeldige archiefnaam")) } s.work.Lock() err := s.archives.Delete(name) s.work.Unlock() if err != nil { return 404, errBody(err) } s.Log.Info("archief verwijderd met de hand", "archive", name) return 200, map[string]string{"deleted": name} } func (s *Server) actRollback(ctx context.Context, in Input) (int, any) { name := in["archive"] if !archive.ValidName(name) { return 400, errBody(errors.New("ongeldige archiefnaam")) } if in["confirm"] != name { return 400, errBody(errors.New("bevestig met de archiefnaam in confirm; een rollback kan niet ongedaan worden gemaakt")) } return s.startRollback(name) } // startRollback start een rollback op de achtergrond. func (s *Server) startRollback(name string) (int, any) { if _, err := s.archives.Path(name); err != nil { return 404, errBody(err) } if !s.getState().Connected() { return 409, errBody(errors.New("geen BlueGit gekoppeld")) } if c, p := s.compat(); c != "" && c != protocol.CompatOK { return 409, errBody(fmt.Errorf("%w: %s", ErrIncompatible, compatMessage(c, p))) } s.mu.Lock() busy := s.rollback.State == "running" if !busy { s.rollback = RollbackStatus{State: "running", Archive: name, At: s.now().UTC()} } s.mu.Unlock() if busy { return 409, errBody(errors.New("er loopt al een rollback")) } s.Log.Warn("rollback gestart", "archive", name) go func() { if err := s.Rollback(context.Background(), name); err != nil { s.Log.Error("rollback mislukt", "archive", name, "err", err) } }() return http.StatusAccepted, map[string]string{"state": "running", "archive": name} } // ---------- HTTP ---------- // Handler is de webinterface en de HTTP-API. func (s *Server) Handler() http.Handler { mux := http.NewServeMux() mux.HandleFunc("GET /healthz", func(w http.ResponseWriter, r *http.Request) { _, _ = w.Write([]byte("ok\n")) }) // Van BlueGit, ondertekend (vaste protocolroutes). mux.HandleFunc("POST /api/v1/notify", s.signed(s.apiNotify)) mux.HandleFunc("GET /api/v1/archives", s.signed(s.apiArchives)) mux.HandleFunc("GET /api/v1/status", s.signed(s.apiStatus)) mux.HandleFunc("POST /api/v1/rollback", s.signed(s.apiRollback)) // Beheer: admin.token, een sessie van de webinterface, of BlueGit. for _, a := range s.Actions() { mux.HandleFunc(a.Method+" "+a.Path, s.apiAction(a)) } s.mountUI(mux) return securityHeaders(mux) } func securityHeaders(h http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { protocol.SetOwnHeaders(w.Header(), Version) w.Header().Set("X-Content-Type-Options", "nosniff") w.Header().Set("Referrer-Policy", "same-origin") h.ServeHTTP(w, r) }) } // apiAction voert een actie uit voor de API. func (s *Server) apiAction(a Action) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { body, err := io.ReadAll(io.LimitReader(r.Body, 1<<20)) if err != nil { writeErr(w, 400, "body") return } if code, msg := s.authorize(r, a, body); code != 0 { writeErr(w, code, msg) return } in, err := parseInput(r, body) if err != nil { writeErr(w, 400, err.Error()) return } for _, p := range a.Params { in[p] = r.PathValue(p) } code, out := a.Do(r.Context(), in) if f, ok := out.(fileResult); ok { w.Header().Set("Content-Type", "application/gzip") w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=%q", f.name)) http.ServeFile(w, r, f.path) return } writeJSON(w, code, out) } } // authorize: 0 is toegestaan, anders de foutcode. func (s *Server) authorize(r *http.Request, a Action, body []byte) (int, string) { if tok, ok := strings.CutPrefix(r.Header.Get("Authorization"), "Bearer "); ok { if subtle.ConstantTimeCompare([]byte(strings.TrimSpace(tok)), []byte(s.adminToken)) == 1 { return 0, "" } return 401, "ongeldig token" } if r.Header.Get(protocol.HeaderSignature) != "" { if !a.Signed { return 403, "BlueGit mag dit niet" } st := s.getState() if !st.Connected() { return 401, "niet gekoppeld" } if r.Header.Get(protocol.HeaderInstance) != st.InstanceID { return 401, "andere BlueGit-instantie" } if err := protocol.Verify(r, protocol.SigningSecret(st.Key), body, s.now()); err != nil { return 401, err.Error() } p, _ := protocol.BlueGitFromHeader(r.Header) s.setBlueGit(p) return 0, "" } if sess, ok := s.session(r); ok { if r.Method != http.MethodGet && r.Method != http.MethodHead { if subtle.ConstantTimeCompare([]byte(r.Header.Get("X-CSRF-Token")), []byte(sess.csrf)) != 1 { return 403, "X-CSRF-Token ontbreekt of klopt niet" } } return 0, "" } return 401, "admin.token, sessie of BlueGit-handtekening nodig" } // parseInput leest de querystring en een JSON-object (waarden als tekst). func parseInput(r *http.Request, body []byte) (Input, error) { in := Input{} for k, v := range r.URL.Query() { if len(v) > 0 { in[k] = v[0] } } if len(strings.TrimSpace(string(body))) == 0 { return in, nil } var raw map[string]any if err := json.Unmarshal(body, &raw); err != nil { return nil, errors.New("ongeldige JSON: verwacht een object") } for k, v := range raw { switch t := v.(type) { case string: in[k] = t case float64: in[k] = strconv.FormatFloat(t, 'f', -1, 64) case bool: in[k] = strconv.FormatBool(t) case nil: in[k] = "" default: return nil, fmt.Errorf("veld %s: verwacht tekst, getal of boolean", k) } } return in, nil }