BlueGit

timfa bluegit

Files

bluegit / internal / runner / routing.go

routing.go

routing.go 6.1 KiB Download Raw
1package runner
2
3import (
4 "context"
5 "gitlab.com/Timfa/bluegit/internal/access"
6 "time"
7
8 "gitlab.com/Timfa/bluegit/internal/store"
9)
10
11// Tier is één trede in de runnervolgorde van een job: de ingebouwde
12// BlueGit-runner of een set aparte runners.
13type Tier struct {
14 Builtin bool
15 Runners []store.Runner
16}
17
18// OfferTimeout: zo lang krijgen online aparte runners in een trede om een
19// job op te pakken voordat de volgende trede aan de beurt is.
20var OfferTimeout = 20 * time.Second
21
22// Order berekent de volgorde puur uit de gegevens; zie Tiers.
23//
24// Accountrepo: eigen runners eerst (own_first) of de BlueGit-runner eerst
25// en eigen runners alleen als die niet meteen vrij is (builtin_first).
26// Groepsrepo: groepsrunners → account-runners van groepsleden die
27// toestemming gaven → BlueGit-runner; met builtinFirst staat de
28// BlueGit-runner vooraan. Lege treden vallen weg.
29func Order(ownerKind, userPref string, builtinFirst bool, own, group, optedIn []store.Runner) []Tier {
30 var tiers []Tier
31 add := func(t Tier) {
32 if t.Builtin || len(t.Runners) > 0 {
33 tiers = append(tiers, t)
34 }
35 }
36 builtin := Tier{Builtin: true}
37 if ownerKind == "group" {
38 if builtinFirst {
39 add(builtin)
40 }
41 add(Tier{Runners: group})
42 add(Tier{Runners: optedIn})
43 if !builtinFirst {
44 add(builtin)
45 }
46 return tiers
47 }
48 if userPref == store.RunnerPrefOwnFirst {
49 add(Tier{Runners: own})
50 add(builtin)
51 } else {
52 add(builtin)
53 add(Tier{Runners: own})
54 }
55 return tiers
56}
57
58// Tiers geeft de runnervolgorde voor een repo. Globale runners (van de
59// beheerders) staan altijd vooraan, daarna de volgorde van Order.
60//
61// protected: de job draait op een beschermde ref (en krijgt beschermde
62// geheimen). Dan doen account-runners van opt-in-leden alleen mee als hun
63// eigenaar maintainer (of hoger, of instance-admin) op de repo is.
64func Tiers(ctx context.Context, st *store.Store, repo store.Repo, protected bool) ([]Tier, error) {
65 global, err := st.ListRunners(ctx, store.RunnerGlobal, 0)
66 if err != nil {
67 return nil, err
68 }
69 rest, err := repoTiers(ctx, st, repo, protected)
70 if err != nil {
71 return nil, err
72 }
73 if g := active(global); len(g) > 0 {
74 return append([]Tier{{Runners: g}}, rest...), nil
75 }
76 return rest, nil
77}
78
79func repoTiers(ctx context.Context, st *store.Store, repo store.Repo, protected bool) ([]Tier, error) {
80 if repo.OwnerKind == "group" {
81 group, err := st.ListRunners(ctx, "group", repo.OwnerID)
82 if err != nil {
83 return nil, err
84 }
85 users, err := st.RunnerOptIns(ctx, repo.OwnerID)
86 if err != nil {
87 return nil, err
88 }
89 var opted []store.Runner
90 for _, u := range users {
91 // Toestemming geldt alleen zolang de gebruiker lid van de groep is.
92 role, err := st.GroupRole(ctx, repo.OwnerID, u)
93 if err != nil || !role.CanRead() {
94 continue
95 }
96 // En alleen als de eigenaar van de runner deze repo zelf mag
97 // lezen. Elke toewijzing kijkt opnieuw, dus ingetrokken rechten
98 // gelden meteen.
99 if r, err := st.EffectiveRole(ctx, u, repo.ID); err != nil || !r.CanRead() {
100 continue
101 }
102 if protected && !MaintainerOrAdmin(ctx, st, u, repo.ID) {
103 continue
104 }
105 rs, err := st.ListRunners(ctx, "user", u)
106 if err != nil {
107 return nil, err
108 }
109 opted = append(opted, rs...)
110 }
111 return Order("group", "", st.GroupBuiltinFirst(ctx, repo.OwnerID), nil, active(group), active(opted)), nil
112 }
113 own, err := st.ListRunners(ctx, "user", repo.OwnerID)
114 if err != nil {
115 return nil, err
116 }
117 return Order("user", st.UserRunnerPref(ctx, repo.OwnerID), false, active(own), nil, nil), nil
118}
119
120// active laat gepauzeerde (ook lokaal gepauzeerde) runners weg uit de volgorde.
121func active(rs []store.Runner) []store.Runner {
122 var out []store.Runner
123 for _, r := range rs {
124 if !r.Paused && !r.Draining {
125 out = append(out, r)
126 }
127 }
128 return out
129}
130
131func anyOnline(rs []store.Runner, now time.Time) bool {
132 for _, r := range rs {
133 if r.Online(now) {
134 return true
135 }
136 }
137 return false
138}
139
140// Step is de beslissing voor een wachtende job in deze tick.
141type Step struct {
142 Tier int // trede waar de job nu staat
143 Builtin bool // nu ingebouwd starten
144 Moved bool // aanbod is verplaatst; opslaan
145}
146
147// Advance kiest wat er met een wachtende job gebeurt. builtinFree zegt of
148// de ingebouwde runner nu een plek heeft. Elke trede wordt hooguit één
149// keer per tick bekeken.
150func Advance(tiers []Tier, tier int, offerAt, now time.Time, builtinFree bool) Step {
151 n := len(tiers)
152 if n == 0 {
153 return Step{}
154 }
155 if tier < 0 || tier >= n {
156 tier = 0
157 }
158 moved := offerAt.IsZero()
159 if moved {
160 offerAt = now
161 }
162 for i := 0; i < n; i++ {
163 t := tiers[tier]
164 if t.Builtin {
165 if builtinFree {
166 return Step{Tier: tier, Builtin: true, Moved: moved}
167 }
168 } else if anyOnline(t.Runners, now) && (now.Sub(offerAt) < OfferTimeout || i > 0 && moved) {
169 return Step{Tier: tier, Moved: moved}
170 }
171 tier = (tier + 1) % n
172 offerAt = now
173 moved = true
174 }
175 return Step{Tier: tier, Moved: moved}
176}
177
178// RunnerInTier zegt of runner id in de trede staat.
179func RunnerInTier(tiers []Tier, tier int, id int64) bool {
180 if tier < 0 || tier >= len(tiers) {
181 return false
182 }
183 for _, r := range tiers[tier].Runners {
184 if r.ID == id {
185 return true
186 }
187 }
188 return false
189}
190
191// MaintainerOrAdmin: de gebruiker is maintainer (of eigenaar) van de repo,
192// of instance-admin.
193func MaintainerOrAdmin(ctx context.Context, st *store.Store, userID, repoID int64) bool {
194 if u, err := st.UserByID(ctx, userID); err == nil && u.InstanceAdmin {
195 return true
196 }
197 r, err := st.EffectiveRole(ctx, userID, repoID)
198 return err == nil && r.AtLeast(access.RoleMaintainer)
199}
200
201// ExcludedForProtected geeft de namen van opt-in account-runners die voor
202// een job op een beschermde ref niet mogen (eigenaar geen maintainer).
203func ExcludedForProtected(ctx context.Context, st *store.Store, repo store.Repo) []string {
204 if repo.OwnerKind != "group" {
205 return nil
206 }
207 users, _ := st.RunnerOptIns(ctx, repo.OwnerID)
208 var out []string
209 for _, u := range users {
210 if role, err := st.GroupRole(ctx, repo.OwnerID, u); err != nil || !role.CanRead() {
211 continue
212 }
213 if MaintainerOrAdmin(ctx, st, u, repo.ID) {
214 continue
215 }
216 rs, _ := st.ListRunners(ctx, "user", u)
217 for _, rn := range active(rs) {
218 out = append(out, rn.Name)
219 }
220 }
221 return out
222}