BlueGit

timfa bluegit

Files

bluegit / internal / server / update_gate.go

update_gate.go

update_gate.go 3.3 KiB Download Raw
1package server
2
3import (
4 "context"
5 "errors"
6 "net/http"
7 "os"
8 "path/filepath"
9 "time"
10
11 "gitlab.com/Timfa/bluegit/internal/i18n"
12 "gitlab.com/Timfa/bluegit/internal/store"
13 "gitlab.com/Timfa/bluegit/internal/update"
14)
15
16// De update-poort: zodra een self-update klaarstaat, starten er geen jobs
17// meer van pipelines die daarna zijn aangemaakt. Lopende pipelines mogen
18// afmaken; de updater wacht tot er niets meer draait (running == 0).
19// De release-pipeline zelf blokkeert niets: self_update is de laatste job
20// en stopt direct na de POST.
21//
22// Veiligheidskleppen: na MaxWait gaat de poort vanzelf open (de updater
23// geeft dan ook op), en een beheerder kan forceren (update-force), dan
24// installeert de updater zonder te wachten.
25
26const forceFile = "update-force"
27
28// DefaultUpdateMaxWait is de standaard maximale wachttijd.
29const DefaultUpdateMaxWait = 30 * time.Minute
30
31func (s *Server) updateMaxWait() time.Duration {
32 if m := s.Cfg.CI.UpdateMaxWaitMin; m > 0 {
33 return time.Duration(m) * time.Minute
34 }
35 return DefaultUpdateMaxWait
36}
37
38// UpdateGate zegt of er een update in afwachting is, en sinds wanneer.
39func (s *Server) UpdateGate() (bool, time.Time) {
40 if s.StateDir == "" {
41 return false, time.Time{}
42 }
43 st, err := update.ReadStatus(s.StateDir)
44 if err != nil || (st.Result != update.ResultWaiting && st.Result != "running") {
45 return false, time.Time{}
46 }
47 since, err := time.Parse(time.RFC3339, st.Time)
48 if err != nil {
49 return false, time.Time{}
50 }
51 // wachten + bouwen; daarna is de update mislukt of de dienst herstart
52 if time.Since(since) > s.updateMaxWait()+updateRunning {
53 return false, time.Time{}
54 }
55 return true, since
56}
57
58// HoldPipeline is de runnerhaak: true = deze pipeline wacht op de update.
59func (s *Server) HoldPipeline(p store.Pipeline) bool {
60 on, since := s.UpdateGate()
61 return on && !p.CreatedAt.Before(since)
62}
63
64// pipeStatusFor geeft de status voor UI, API en scripts: een wachtende
65// pipeline heet waiting_for_update.
66func (s *Server) pipeStatusFor(p store.Pipeline) string {
67 if (p.Status == "queued" || p.Status == "created") && s.HoldPipeline(p) {
68 return "waiting_for_update"
69 }
70 return p.Status
71}
72
73func (s *Server) updateForced() bool {
74 _, err := os.Stat(filepath.Join(s.StateDir, forceFile))
75 return err == nil
76}
77
78func (s *Server) setUpdateForce(on bool) error {
79 p := filepath.Join(s.StateDir, forceFile)
80 if !on {
81 if err := os.Remove(p); err != nil && !errors.Is(err, os.ErrNotExist) {
82 return err
83 }
84 return nil
85 }
86 return os.WriteFile(p, []byte(time.Now().UTC().Format(time.RFC3339)+"\n"), 0o640)
87}
88
89func (s *Server) countHeld(ctx context.Context) int {
90 on, _ := s.UpdateGate()
91 if !on || s.Store == nil {
92 return 0
93 }
94 pipes, err := s.Store.ActivePipelines(ctx)
95 if err != nil {
96 return 0
97 }
98 n := 0
99 for _, p := range pipes {
100 if s.HoldPipeline(p) {
101 n++
102 }
103 }
104 return n
105}
106
107// apiForceUpdate laat een beheerder de wachtende update nu installeren.
108func (s *Server) apiForceUpdate(w http.ResponseWriter, r *http.Request) {
109 if !apiUser(r).InstanceAdmin {
110 s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden")))
111 return
112 }
113 if on, _ := s.UpdateGate(); !on {
114 s.writeAPIErr(w, r, fail(409, i18n.E("err.noUpdatePending")))
115 return
116 }
117 if err := s.setUpdateForce(true); err != nil {
118 s.writeAPIErr(w, r, fail(500, err))
119 return
120 }
121 writeJSON(w, http.StatusOK, map[string]any{"forced": true})
122}