BlueGit

timfa bluegit

Files

bluegit / internal / server / stale_manual.go

stale_manual.go

stale_manual.go 4.2 KiB Download Raw
1package server
2
3import (
4 "context"
5 "net/http"
6 "strconv"
7 "strings"
8 "time"
9
10 "gitlab.com/Timfa/bluegit/internal/i18n"
11 "gitlab.com/Timfa/bluegit/internal/store"
12)
13
14// Verlopen handmatige jobs: zie store/stale_manual.go voor de regels.
15
16// expiredManualJob is true voor een handmatige job die verlopen is; die kan
17// niet meer gestart of opnieuw gestart worden.
18func expiredManualJob(j store.Job) bool {
19 if j.Status != "canceled" {
20 return false
21 }
22 return j.Reason == store.ReasonStaleManual || (j.Reason == store.ReasonSuperseded && j.When == "manual")
23}
24
25// expireSuperseded laat handmatige jobs van oudere pipelines op dezelfde ref
26// verlopen zodra een nieuwe pipeline gemaakt is.
27func (s *Server) expireSuperseded(ctx context.Context, repoID int64, ref string, keep int64) {
28 out, err := s.Store.ExpireSupersededManual(ctx, repoID, ref, keep)
29 if err != nil && s.Log != nil {
30 s.Log.Error("stale manual", "err", err)
31 }
32 s.logExpired(ctx, out)
33}
34
35func (s *Server) logExpired(ctx context.Context, out []store.ExpiredManual) {
36 if s.Log == nil {
37 return
38 }
39 for _, e := range out {
40 path := strconv.FormatInt(e.RepoID, 10)
41 if r, err := s.Store.RepoByID(ctx, e.RepoID); err == nil {
42 path = r.FullPath()
43 }
44 s.Log.Info("stale manual expired", "repo", path, "pipeline", e.PipelineID, "ref", e.Ref, "jobs", e.Jobs, "reason", e.Reason)
45 }
46}
47
48// StaleManualSweeper ruimt kort na de start en daarna elk uur verlopen
49// handmatige jobs op.
50func (s *Server) StaleManualSweeper(ctx context.Context) {
51 first := time.NewTimer(time.Minute)
52 defer first.Stop()
53 t := time.NewTicker(time.Hour)
54 defer t.Stop()
55 for {
56 select {
57 case <-ctx.Done():
58 return
59 case <-first.C:
60 case <-t.C:
61 }
62 out, err := s.Store.SweepStaleManual(ctx, time.Now())
63 if err != nil && s.Log != nil {
64 s.Log.Error("stale manual sweep", "err", err)
65 }
66 s.logExpired(ctx, out)
67 }
68}
69
70func (s *Server) adminPipelines(w http.ResponseWriter, r *http.Request) {
71 if ok, _ := s.adminOnly(w, r); !ok {
72 return
73 }
74 v := s.view(w, r, "title.admin")
75 v.Page = "adminpipelines"
76 v.StaleDays, _ = s.Store.StaleManualDays(r.Context())
77 v.StaleDaysDefault = store.DefaultStaleManualDays
78 s.render(w, "adminpipelines", v)
79}
80
81func (s *Server) adminPipelinesSave(w http.ResponseWriter, r *http.Request) {
82 if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) {
83 return
84 }
85 n, err := strconv.Atoi(strings.TrimSpace(r.FormValue("stale_manual_days")))
86 if err != nil || s.Store.SetStaleManualDays(r.Context(), n) != nil {
87 s.redirect(w, r, "/admin/pipelines", "", s.tr(r, "stale.err.days"))
88 return
89 }
90 if s.Log != nil {
91 s.Log.Info("admin audit", "by", s.who(r).User.Username, "stale_manual_days", n)
92 }
93 s.redirect(w, r, "/admin/pipelines", s.tr(r, "flash.saved"), "")
94}
95
96func (s *Server) apiAdminPipelineSettings(w http.ResponseWriter, r *http.Request) {
97 if !apiUser(r).InstanceAdmin {
98 s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden")))
99 return
100 }
101 if r.Method == http.MethodPut {
102 var in struct {
103 Days *int `json:"stale_manual_days"`
104 }
105 if err := readJSON(r, &in); err != nil || in.Days == nil {
106 s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
107 return
108 }
109 if err := s.Store.SetStaleManualDays(r.Context(), *in.Days); err != nil {
110 s.writeAPIErr(w, r, fail(400, i18n.E("stale.err.days")))
111 return
112 }
113 if s.Log != nil {
114 s.Log.Info("admin audit", "by", apiUser(r).Username, "stale_manual_days", *in.Days)
115 }
116 }
117 n, err := s.Store.StaleManualDays(r.Context())
118 if err != nil {
119 s.writeAPIErr(w, r, err)
120 return
121 }
122 writeJSON(w, http.StatusOK, map[string]any{"stale_manual_days": n, "default": store.DefaultStaleManualDays})
123}
124
125func (s *Server) apiAdminExpireStale(w http.ResponseWriter, r *http.Request) {
126 if !apiUser(r).InstanceAdmin {
127 s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden")))
128 return
129 }
130 out, err := s.Store.SweepStaleManual(r.Context(), time.Now())
131 s.logExpired(r.Context(), out)
132 if err != nil {
133 s.writeAPIErr(w, r, err)
134 return
135 }
136 list := []map[string]any{}
137 for _, e := range out {
138 path := ""
139 if rp, err := s.Store.RepoByID(r.Context(), e.RepoID); err == nil {
140 path = rp.FullPath()
141 }
142 list = append(list, map[string]any{"project": path, "pipeline_id": e.PipelineID, "ref": e.Ref, "jobs": e.Jobs, "reason": e.Reason})
143 }
144 writeJSON(w, http.StatusOK, list)
145}