BlueGit

timfa bluegit

Files

bluegit / internal / runner / routing.go

routing.go

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