package server import ( "context" "errors" "net/http" "os" "path/filepath" "time" "gitlab.com/Timfa/bluegit/internal/i18n" "gitlab.com/Timfa/bluegit/internal/store" "gitlab.com/Timfa/bluegit/internal/update" ) // De update-poort: zodra een self-update klaarstaat, starten er geen jobs // meer van pipelines die daarna zijn aangemaakt. Lopende pipelines mogen // afmaken; de updater wacht tot er niets meer draait (running == 0). // De release-pipeline zelf blokkeert niets: self_update is de laatste job // en stopt direct na de POST. // // Veiligheidskleppen: na MaxWait gaat de poort vanzelf open (de updater // geeft dan ook op), en een beheerder kan forceren (update-force), dan // installeert de updater zonder te wachten. const forceFile = "update-force" // DefaultUpdateMaxWait is de standaard maximale wachttijd. const DefaultUpdateMaxWait = 30 * time.Minute func (s *Server) updateMaxWait() time.Duration { if m := s.Cfg.CI.UpdateMaxWaitMin; m > 0 { return time.Duration(m) * time.Minute } return DefaultUpdateMaxWait } // UpdateGate zegt of er een update in afwachting is, en sinds wanneer. func (s *Server) UpdateGate() (bool, time.Time) { if s.StateDir == "" { return false, time.Time{} } st, err := update.ReadStatus(s.StateDir) if err != nil || (st.Result != update.ResultWaiting && st.Result != "running") { return false, time.Time{} } since, err := time.Parse(time.RFC3339, st.Time) if err != nil { return false, time.Time{} } // wachten + bouwen; daarna is de update mislukt of de dienst herstart if time.Since(since) > s.updateMaxWait()+updateRunning { return false, time.Time{} } return true, since } // HoldPipeline is de runnerhaak: true = deze pipeline wacht op de update. func (s *Server) HoldPipeline(p store.Pipeline) bool { on, since := s.UpdateGate() return on && !p.CreatedAt.Before(since) } // pipeStatusFor geeft de status voor UI, API en scripts: een wachtende // pipeline heet waiting_for_update. func (s *Server) pipeStatusFor(p store.Pipeline) string { if (p.Status == "queued" || p.Status == "created") && s.HoldPipeline(p) { return "waiting_for_update" } return p.Status } func (s *Server) updateForced() bool { _, err := os.Stat(filepath.Join(s.StateDir, forceFile)) return err == nil } func (s *Server) setUpdateForce(on bool) error { p := filepath.Join(s.StateDir, forceFile) if !on { if err := os.Remove(p); err != nil && !errors.Is(err, os.ErrNotExist) { return err } return nil } return os.WriteFile(p, []byte(time.Now().UTC().Format(time.RFC3339)+"\n"), 0o640) } func (s *Server) countHeld(ctx context.Context) int { on, _ := s.UpdateGate() if !on || s.Store == nil { return 0 } pipes, err := s.Store.ActivePipelines(ctx) if err != nil { return 0 } n := 0 for _, p := range pipes { if s.HoldPipeline(p) { n++ } } return n } // apiForceUpdate laat een beheerder de wachtende update nu installeren. func (s *Server) apiForceUpdate(w http.ResponseWriter, r *http.Request) { if !apiUser(r).InstanceAdmin { s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden"))) return } if on, _ := s.UpdateGate(); !on { s.writeAPIErr(w, r, fail(409, i18n.E("err.noUpdatePending"))) return } if err := s.setUpdateForce(true); err != nil { s.writeAPIErr(w, r, fail(500, err)) return } writeJSON(w, http.StatusOK, map[string]any{"forced": true}) }