BlueGit

timfa bluegit

Files

bluegit / internal / backupserver / server / server.go

server.go

server.go 19.0 KiB Download Raw
1// Package server is de backup server: sync, archieven, de API voor BlueGit
2// en de lokale beheer-API.
3package server
4
5import (
6 "context"
7 "crypto/subtle"
8 "encoding/json"
9 "errors"
10 "fmt"
11 "io"
12 "log/slog"
13 "net/http"
14 "os"
15 "path/filepath"
16 "strings"
17 "sync"
18 "time"
19
20 "git.timfalken.com/timfa/bluegit-backup/internal/archive"
21 "git.timfalken.com/timfa/bluegit-backup/internal/config"
22 "git.timfalken.com/timfa/bluegit-backup/internal/mirror"
23 "git.timfalken.com/timfa/bluegit-backup/internal/protocol"
24 "git.timfalken.com/timfa/bluegit-backup/internal/throttle"
25)
26
27// Version wordt bij het bouwen gezet (-ldflags -X).
28var Version = "dev"
29
30// Server is één backup server voor één BlueGit.
31type Server struct {
32 Cfg config.Config
33 Log *slog.Logger
34 // Now is de klok (tests).
35 Now func() time.Time
36 // HTTP is de client richting BlueGit (tests).
37 HTTP *http.Client
38
39 adminToken string
40 serverID string
41 limiter *throttle.Limiter
42 mirror *mirror.Mirror
43 archives *archive.Store
44
45 // work beschermt de kopie: sync, archiveren, rollback en koppelen
46 // gebeuren nooit tegelijk.
47 work sync.Mutex
48
49 mu sync.Mutex
50 state State
51 lastSync time.Time
52 lastSyncErr string
53 lastStats mirror.Stats
54 syncs int
55 notifies int
56 lastArchive time.Time
57 archiveErr string
58 rollback RollbackStatus
59
60 kick chan struct{}
61
62 // settings is wat via webinterface, API of BlueGit is ingesteld.
63 settings map[string]string
64 restartPending bool
65 sessions map[string]session
66 loginFails map[string][]time.Time
67}
68
69// cfg is de huidige configuratie (instellingen kunnen tijdens het draaien
70// veranderen).
71func (s *Server) cfg() config.Config {
72 s.mu.Lock()
73 defer s.mu.Unlock()
74 return s.Cfg
75}
76
77// RollbackStatus is de stand van de laatste rollback of restore.
78type RollbackStatus struct {
79 State string `json:"state"` // idle | running | done | failed
80 Archive string `json:"archive,omitempty"`
81 Error string `json:"error,omitempty"`
82 At time.Time `json:"at,omitempty"`
83}
84
85// New zet de mappen klaar en leest de koppeling.
86func New(cfg config.Config, log *slog.Logger) (*Server, error) {
87 if log == nil {
88 log = slog.New(slog.NewTextHandler(io.Discard, nil))
89 }
90 if err := os.MkdirAll(cfg.DataDir, 0o750); err != nil {
91 return nil, err
92 }
93 set, err := config.LoadSettings(cfg.DataDir)
94 if err != nil {
95 return nil, err
96 }
97 if err := cfg.Apply(set); err != nil {
98 return nil, fmt.Errorf("%s: %w", config.SettingsFile, err)
99 }
100 s := &Server{Cfg: cfg, Log: log, Now: time.Now, kick: make(chan struct{}, 1), settings: set, sessions: map[string]session{}}
101 if s.adminToken, err = secretFile(cfg.DataDir, "admin.token", "bba_"); err != nil {
102 return nil, err
103 }
104 if s.serverID, err = secretFile(cfg.DataDir, "server_id", ""); err != nil {
105 return nil, err
106 }
107 if s.state, err = loadState(cfg.DataDir); err != nil {
108 return nil, err
109 }
110 s.limiter = throttle.New(cfg.RateLimitKiB << 10)
111 s.mirror = &mirror.Mirror{Dir: filepath.Join(cfg.DataDir, "mirror"), Index: filepath.Join(cfg.DataDir, "mirror.index.json")}
112 s.archives = &archive.Store{Dir: filepath.Join(cfg.DataDir, "archives")}
113 _ = os.RemoveAll(filepath.Join(cfg.DataDir, "tmp"))
114 if list, _ := s.archives.List(); len(list) > 0 {
115 s.lastArchive = list[0].CreatedAt
116 }
117 s.rollback.State = "idle"
118 return s, nil
119}
120
121// SetFree vervangt de vrije-ruimtemeting (tests).
122func (s *Server) SetFree(f func(string) (uint64, error)) { s.archives.Free = f }
123
124// AdminToken is het lokale beheertoken.
125func (s *Server) AdminToken() string { return s.adminToken }
126
127func (s *Server) now() time.Time { return s.Now() }
128
129func (s *Server) remote(st State) *mirror.Remote {
130 return &mirror.Remote{URL: st.BlueGitURL, Key: st.Key, HTTP: s.HTTP, Limiter: s.limiter}
131}
132
133func (s *Server) getState() State {
134 s.mu.Lock()
135 defer s.mu.Unlock()
136 return s.state
137}
138
139// Run start de achtergrondtaken tot ctx klaar is.
140func (s *Server) Run(ctx context.Context) {
141 go s.syncLoop(ctx)
142 go s.archiveLoop(ctx)
143}
144
145// Kick vraagt om een sync (na een melding).
146func (s *Server) Kick() {
147 select {
148 case s.kick <- struct{}{}:
149 default:
150 }
151}
152
153func (s *Server) syncLoop(ctx context.Context) {
154 s.Kick() // meteen na de start
155 for {
156 s.mu.Lock()
157 next := s.Cfg.FullSyncInterval.Duration - s.now().Sub(s.lastSync)
158 s.mu.Unlock()
159 if next < 0 {
160 next = 0
161 }
162 full := time.NewTimer(next)
163 select {
164 case <-ctx.Done():
165 full.Stop()
166 return
167 case <-full.C:
168 case <-s.kick:
169 full.Stop()
170 }
171 s.mu.Lock()
172 wait := s.Cfg.MinSyncInterval.Duration - s.now().Sub(s.lastSync)
173 s.mu.Unlock()
174 if wait > 0 {
175 select {
176 case <-ctx.Done():
177 return
178 case <-time.After(wait):
179 }
180 }
181 // Meldingen die in de tussentijd binnenkwamen, zitten in deze sync.
182 select {
183 case <-s.kick:
184 default:
185 }
186 _, _ = s.SyncNow(ctx)
187 }
188}
189
190// SyncNow synchroniseert één keer.
191func (s *Server) SyncNow(ctx context.Context) (mirror.Stats, error) {
192 st := s.getState()
193 if !st.Connected() {
194 return mirror.Stats{}, errors.New("geen BlueGit gekoppeld")
195 }
196 s.work.Lock()
197 defer s.work.Unlock()
198 st = s.getState()
199 if !st.Connected() {
200 return mirror.Stats{}, errors.New("geen BlueGit gekoppeld")
201 }
202 stats, err := s.mirror.Sync(ctx, s.remote(st))
203 s.mu.Lock()
204 s.lastSync = s.now()
205 s.syncs++
206 s.lastStats = stats
207 if err != nil {
208 s.lastSyncErr = err.Error()
209 } else {
210 s.lastSyncErr = ""
211 }
212 s.mu.Unlock()
213 if err != nil {
214 s.Log.Warn("sync mislukt", "err", err)
215 } else if stats.Downloaded > 0 || stats.Deleted > 0 {
216 s.Log.Info("sync", "files", stats.Files, "downloaded", stats.Downloaded, "bytes", stats.Bytes, "deleted", stats.Deleted)
217 }
218 return stats, err
219}
220
221func (s *Server) archiveLoop(ctx context.Context) {
222 for {
223 select {
224 case <-ctx.Done():
225 return
226 case <-time.After(s.tick()):
227 }
228 s.mu.Lock()
229 due := s.now().Sub(s.lastArchive) >= s.Cfg.ArchiveInterval.Duration
230 synced := !s.lastSync.IsZero() && s.lastSyncErr == ""
231 s.mu.Unlock()
232 if due && synced {
233 if _, err := s.ArchiveNow(); err != nil {
234 s.Log.Warn("archief mislukt", "err", err)
235 }
236 }
237 if _, err := s.Prune(); err != nil {
238 s.Log.Warn("opruimen mislukt", "err", err)
239 }
240 }
241}
242
243// tick is hoe vaak de archieflus kijkt: een minuut, of korter bij een kort interval.
244func (s *Server) tick() time.Duration {
245 d := s.cfg().ArchiveInterval.Duration / 4
246 if d > time.Minute {
247 d = time.Minute
248 }
249 if d < 100*time.Millisecond {
250 d = 100 * time.Millisecond
251 }
252 return d
253}
254
255// ArchiveNow comprimeert de hele kopie tot een nieuw archief.
256func (s *Server) ArchiveNow() (archive.Archive, error) {
257 s.work.Lock()
258 defer s.work.Unlock()
259 if s.mirror.Empty() {
260 return archive.Archive{}, errors.New("de kopie is nog leeg")
261 }
262 now := s.now()
263 a, removed, err := s.archives.Create(s.mirror.Dir, now, s.mirror.Size(), s.minFree())
264 s.mu.Lock()
265 if err != nil {
266 s.archiveErr = err.Error()
267 } else {
268 s.archiveErr = ""
269 s.lastArchive = now
270 }
271 s.mu.Unlock()
272 for _, r := range removed {
273 s.Log.Info("archief verwijderd: schijf vol", "archive", r)
274 }
275 if err != nil {
276 return a, err
277 }
278 s.Log.Info("archief gemaakt", "archive", a.Name, "bytes", a.Size)
279 if pr, err := s.archives.Prune(now, s.cfg().RetentionDays, s.minFree()); err == nil {
280 for _, r := range pr {
281 s.Log.Info("archief verwijderd", "archive", r)
282 }
283 }
284 return a, nil
285}
286
287func (s *Server) minFree() uint64 { return uint64(s.cfg().MinFreeMB) << 20 }
288
289// Prune past de bewaarregels toe.
290func (s *Server) Prune() ([]string, error) {
291 s.work.Lock()
292 defer s.work.Unlock()
293 removed, err := s.archives.Prune(s.now(), s.cfg().RetentionDays, s.minFree())
294 for _, r := range removed {
295 s.Log.Info("archief verwijderd", "archive", r)
296 }
297 return removed, err
298}
299
300func writeJSON(w http.ResponseWriter, code int, v any) {
301 w.Header().Set("Content-Type", "application/json")
302 w.Header().Set("Cache-Control", "no-store")
303 w.WriteHeader(code)
304 if v != nil {
305 _ = json.NewEncoder(w).Encode(v)
306 }
307}
308
309func writeErr(w http.ResponseWriter, code int, msg string) {
310 writeJSON(w, code, map[string]string{"error": msg})
311}
312
313type ctxBody struct{}
314
315// signed controleert de HMAC-handtekening van de gekoppelde BlueGit.
316func (s *Server) signed(h http.HandlerFunc) http.HandlerFunc {
317 return func(w http.ResponseWriter, r *http.Request) {
318 st := s.getState()
319 if !st.Connected() {
320 writeErr(w, http.StatusUnauthorized, "niet gekoppeld")
321 return
322 }
323 body, err := io.ReadAll(io.LimitReader(r.Body, 1<<20))
324 if err != nil {
325 writeErr(w, 400, "body")
326 return
327 }
328 if r.Header.Get(protocol.HeaderInstance) != st.InstanceID {
329 writeErr(w, http.StatusUnauthorized, "andere BlueGit-instantie")
330 return
331 }
332 if err := protocol.Verify(r, protocol.SigningSecret(st.Key), body, s.now()); err != nil {
333 writeErr(w, http.StatusUnauthorized, err.Error())
334 return
335 }
336 r = r.WithContext(context.WithValue(r.Context(), ctxBody{}, body))
337 h(w, r)
338 }
339}
340
341func bodyOf(r *http.Request) []byte {
342 if b, ok := r.Context().Value(ctxBody{}).([]byte); ok {
343 return b
344 }
345 b, _ := io.ReadAll(io.LimitReader(r.Body, 1<<20))
346 return b
347}
348
349func (s *Server) apiNotify(w http.ResponseWriter, r *http.Request) {
350 s.mu.Lock()
351 s.notifies++
352 s.mu.Unlock()
353 s.Kick()
354 w.WriteHeader(http.StatusNoContent)
355}
356
357func (s *Server) apiArchives(w http.ResponseWriter, r *http.Request) {
358 list, err := s.archives.List()
359 if err != nil {
360 writeErr(w, 500, err.Error())
361 return
362 }
363 writeJSON(w, 200, map[string]any{"archives": list})
364}
365
366// Status is wat GET /api/v1/status en de CLI tonen.
367type Status struct {
368 Version string `json:"version"`
369 ServerID string `json:"server_id"`
370 BlueGitURL string `json:"bluegit_url,omitempty"`
371 InstanceID string `json:"instance_id,omitempty"`
372 Connected bool `json:"connected"`
373 LastSync time.Time `json:"last_sync,omitempty"`
374 SyncError string `json:"sync_error,omitempty"`
375 LastStats mirror.Stats `json:"last_stats"`
376 Syncs int `json:"syncs"`
377 Notifies int `json:"notifies"`
378 MirrorBytes int64 `json:"mirror_bytes"`
379 Archives int `json:"archives"`
380 LastArchive time.Time `json:"last_archive,omitempty"`
381 ArchiveError string `json:"archive_error,omitempty"`
382 Interval string `json:"archive_interval"`
383 RetentionDays int `json:"retention_days"`
384 RateLimitKiB int64 `json:"rate_limit_kib"`
385 Rollback RollbackStatus `json:"rollback"`
386}
387
388// Status geeft de huidige stand.
389func (s *Server) Status() Status {
390 list, _ := s.archives.List()
391 s.mu.Lock()
392 defer s.mu.Unlock()
393 return Status{
394 Version: Version, ServerID: s.serverID, BlueGitURL: s.state.BlueGitURL, InstanceID: s.state.InstanceID,
395 Connected: s.state.Connected(), LastSync: s.lastSync, SyncError: s.lastSyncErr, LastStats: s.lastStats,
396 Syncs: s.syncs, Notifies: s.notifies, MirrorBytes: s.mirror.Size(), Archives: len(list),
397 LastArchive: s.lastArchive, ArchiveError: s.archiveErr, Interval: s.Cfg.ArchiveInterval.String(),
398 RetentionDays: s.Cfg.RetentionDays, RateLimitKiB: s.Cfg.RateLimitKiB, Rollback: s.rollback,
399 }
400}
401
402func (s *Server) apiStatus(w http.ResponseWriter, r *http.Request) { writeJSON(w, 200, s.Status()) }
403
404// ---------- koppelen ----------
405
406// ConnectRequest is POST /api/v1/admin/connect.
407type ConnectRequest struct {
408 URL string `json:"url"`
409 Key string `json:"key"`
410 // OnConflict is leeg, "wipe" of "restore". Leeg en een andere BlueGit
411 // dan de vorige: 409 met de keuzes.
412 OnConflict string `json:"on_conflict"`
413}
414
415// ConflictError is het 409-antwoord bij een andere BlueGit.
416type ConflictError struct {
417 Conflict bool `json:"conflict"`
418 Error string `json:"error"`
419 PreviousURL string `json:"previous_url"`
420 PreviousInstance string `json:"previous_instance"`
421 NewInstance string `json:"new_instance"`
422 Archives int `json:"archives"`
423 Choices []string `json:"choices"`
424}
425
426var errBadRequest = errors.New("ongeldig verzoek")
427
428// Connect koppelt deze server aan een BlueGit. Er is er altijd hoogstens één.
429func (s *Server) Connect(ctx context.Context, in ConnectRequest) (map[string]any, *ConflictError, error) {
430 in.URL = strings.TrimRight(strings.TrimSpace(in.URL), "/")
431 in.Key = strings.TrimSpace(in.Key)
432 if !strings.HasPrefix(in.URL, "http://") && !strings.HasPrefix(in.URL, "https://") {
433 return nil, nil, fmt.Errorf("%w: url moet met http:// of https:// beginnen", errBadRequest)
434 }
435 if !strings.HasPrefix(in.Key, protocol.KeyPrefix) {
436 return nil, nil, fmt.Errorf("%w: de Backupserver-Key begint met %s", errBadRequest, protocol.KeyPrefix)
437 }
438 switch in.OnConflict {
439 case "", "wipe", "restore":
440 default:
441 return nil, nil, fmt.Errorf("%w: on_conflict moet wipe of restore zijn", errBadRequest)
442 }
443 pub := s.cfg().PublicURL
444 if pub == "" {
445 return nil, nil, fmt.Errorf("%w: zet public_url in de configuratie; BlueGit moet deze server kunnen bereiken", errBadRequest)
446 }
447 s.work.Lock()
448 defer s.work.Unlock()
449 rem := &mirror.Remote{URL: in.URL, Key: in.Key, HTTP: s.HTTP, Limiter: s.limiter}
450 info, err := rem.Info(ctx)
451 if err != nil {
452 return nil, nil, err
453 }
454 old := s.getState()
455 list, _ := s.archives.List()
456 hasData := !s.mirror.Empty() || len(list) > 0
457 other := old.InstanceID != "" && old.InstanceID != info.InstanceID && hasData
458 mode := ""
459 if other {
460 if in.OnConflict == "" {
461 return nil, &ConflictError{
462 Conflict: true, Error: "deze backup server hoort bij een andere BlueGit",
463 PreviousURL: old.BlueGitURL, PreviousInstance: old.InstanceID, NewInstance: info.InstanceID,
464 Archives: len(list), Choices: []string{"wipe", "restore"},
465 }, nil
466 }
467 mode = in.OnConflict
468 }
469 if mode == "wipe" {
470 if err := s.mirror.Wipe(); err != nil {
471 return nil, nil, err
472 }
473 if err := s.archives.DeleteAll(); err != nil {
474 return nil, nil, err
475 }
476 s.mu.Lock()
477 s.lastArchive = time.Time{}
478 s.mu.Unlock()
479 s.Log.Warn("oude backups verwijderd voor een nieuwe BlueGit", "old", old.InstanceID, "new", info.InstanceID)
480 }
481 if mode == "restore" && s.mirror.Empty() {
482 return nil, nil, fmt.Errorf("%w: de kopie is leeg; er is niets om terug te zetten", errBadRequest)
483 }
484 if err := rem.Connect(ctx, pub, s.serverID); err != nil {
485 return nil, nil, err
486 }
487 st := State{BlueGitURL: in.URL, Key: in.Key, InstanceID: info.InstanceID, ConnectedAt: s.now().UTC()}
488 if err := saveState(s.Cfg.DataDir, st); err != nil {
489 return nil, nil, err
490 }
491 s.mu.Lock()
492 s.state = st
493 s.mu.Unlock()
494 s.Log.Info("gekoppeld", "bluegit", in.URL, "instance", info.InstanceID, "mode", mode)
495 out := map[string]any{"instance_id": info.InstanceID, "bluegit_url": in.URL, "mode": mode}
496 if mode == "restore" {
497 if err := s.sendMirror(ctx, rem, "restore"); err != nil {
498 return nil, nil, fmt.Errorf("terugzetten naar de nieuwe BlueGit mislukt: %w", err)
499 }
500 out["restored"] = true
501 }
502 s.Kick()
503 return out, nil, nil
504}
505
506// sendMirror stuurt de hele kopie als tar.gz naar BlueGit en wacht tot die
507// herstart is. Aanroepen met s.work vast.
508func (s *Server) sendMirror(ctx context.Context, rem *mirror.Remote, label string) error {
509 s.setRollback(RollbackStatus{State: "running", Archive: label, At: s.now().UTC()})
510 pr, pw := io.Pipe()
511 go func() { pw.CloseWithError(archive.WriteTarGz(pw, s.mirror.Dir)) }()
512 if err := rem.Restore(ctx, pr); err != nil {
513 pr.CloseWithError(err)
514 s.setRollback(RollbackStatus{State: "failed", Archive: label, Error: err.Error(), At: s.now().UTC()})
515 return err
516 }
517 if err := rem.WaitUp(ctx, 3*time.Minute); err != nil {
518 s.setRollback(RollbackStatus{State: "failed", Archive: label, Error: err.Error(), At: s.now().UTC()})
519 return err
520 }
521 s.setRollback(RollbackStatus{State: "done", Archive: label, At: s.now().UTC()})
522 return nil
523}
524
525func (s *Server) setRollback(r RollbackStatus) {
526 s.mu.Lock()
527 s.rollback = r
528 s.mu.Unlock()
529}
530
531// ---------- rollback ----------
532
533func (s *Server) apiRollback(w http.ResponseWriter, r *http.Request) {
534 var in struct {
535 Archive string `json:"archive"`
536 }
537 if err := json.Unmarshal(bodyOf(r), &in); err != nil || !archive.ValidName(in.Archive) {
538 writeErr(w, 400, "ongeldige archiefnaam")
539 return
540 }
541 code, out := s.startRollback(in.Archive)
542 writeJSON(w, code, out)
543}
544
545// Rollback pakt een archief uit, vervangt daarmee de draaiende kopie en
546// stuurt die naar BlueGit. Lukt het sturen niet, dan komt de oude kopie
547// terug, zodat kopie en BlueGit gelijk blijven.
548func (s *Server) Rollback(ctx context.Context, name string) error {
549 s.work.Lock()
550 defer s.work.Unlock()
551 fail := func(err error) error {
552 s.setRollback(RollbackStatus{State: "failed", Archive: name, Error: err.Error(), At: s.now().UTC()})
553 return err
554 }
555 st := s.getState()
556 if !st.Connected() {
557 return fail(errors.New("geen BlueGit gekoppeld"))
558 }
559 src, err := s.archives.Path(name)
560 if err != nil {
561 return fail(err)
562 }
563 fresh := filepath.Join(s.Cfg.DataDir, "mirror.rollback")
564 old := filepath.Join(s.Cfg.DataDir, "mirror.old")
565 _ = os.RemoveAll(fresh)
566 _ = os.RemoveAll(old)
567 if err := archive.Extract(src, fresh); err != nil {
568 _ = os.RemoveAll(fresh)
569 return fail(fmt.Errorf("uitpakken: %w", err))
570 }
571 oldIndex, _ := os.ReadFile(s.mirror.Index)
572 if err := os.Rename(s.mirror.Dir, old); err != nil && !errors.Is(err, os.ErrNotExist) {
573 return fail(err)
574 }
575 if err := os.Rename(fresh, s.mirror.Dir); err != nil {
576 _ = os.Rename(old, s.mirror.Dir)
577 return fail(err)
578 }
579 if err := s.mirror.RebuildIndex(); err != nil {
580 return fail(err)
581 }
582 if err := s.sendMirror(ctx, s.remote(st), name); err != nil {
583 // Terug naar de kopie van vóór de rollback.
584 _ = os.RemoveAll(s.mirror.Dir)
585 _ = os.Rename(old, s.mirror.Dir)
586 _ = os.WriteFile(s.mirror.Index, oldIndex, 0o600)
587 s.setRollback(RollbackStatus{State: "failed", Archive: name, Error: err.Error(), At: s.now().UTC()})
588 return err
589 }
590 _ = os.RemoveAll(old)
591 s.Log.Warn("rollback klaar", "archive", name)
592 s.Kick()
593 return nil
594}
595
596// ---------- self-update ----------
597
598// UpdateStarter start de update-unit (tests zetten een stub).
599var UpdateStarter = func(ctx context.Context, ref string) error {
600 return startUpdateUnit(ctx, ref)
601}
602
603var updateHits = struct {
604 sync.Mutex
605 at []time.Time
606}{}
607
608func (s *Server) selfUpdate(w http.ResponseWriter, r *http.Request) {
609 tok := os.Getenv("BLUEGIT_BACKUP_UPDATE_TOKEN")
610 if tok == "" {
611 http.NotFound(w, r)
612 return
613 }
614 updateHits.Lock()
615 cut := time.Now().Add(-time.Minute)
616 keep := updateHits.at[:0]
617 for _, t := range updateHits.at {
618 if t.After(cut) {
619 keep = append(keep, t)
620 }
621 }
622 updateHits.at = append(keep, time.Now())
623 n := len(updateHits.at)
624 updateHits.Unlock()
625 if n > 5 {
626 writeErr(w, http.StatusTooManyRequests, "te veel verzoeken")
627 return
628 }
629 got := strings.TrimSpace(strings.TrimPrefix(r.Header.Get("Authorization"), "Bearer "))
630 if subtle.ConstantTimeCompare([]byte(got), []byte(tok)) != 1 {
631 writeErr(w, http.StatusUnauthorized, "unauthorized")
632 return
633 }
634 var in struct {
635 Ref string `json:"ref"`
636 }
637 _ = json.NewDecoder(io.LimitReader(r.Body, 4096)).Decode(&in)
638 if !validRef(in.Ref) {
639 writeErr(w, 400, "ref moet een volledige sha zijn")
640 return
641 }
642 if err := UpdateStarter(r.Context(), in.Ref); err != nil {
643 writeErr(w, 500, err.Error())
644 return
645 }
646 writeJSON(w, http.StatusAccepted, map[string]string{"ref": in.Ref, "state": "started"})
647}
648
649func validRef(ref string) bool {
650 if len(ref) != 40 {
651 return false
652 }
653 for _, c := range ref {
654 if !(c >= '0' && c <= '9' || c >= 'a' && c <= 'f') {
655 return false
656 }
657 }
658 return true
659}