BlueGit

timfa bluegit

Files

bluegit / internal / runner / routing.go

routing.go

routing.go 4.3 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.
58func Tiers(ctx context.Context, st *store.Store, repo store.Repo) ([]Tier, error) {
59 if repo.OwnerKind == "group" {
60 group, err := st.ListRunners(ctx, "group", repo.OwnerID)
61 if err != nil {
62 return nil, err
63 }
64 users, err := st.RunnerOptIns(ctx, repo.OwnerID)
65 if err != nil {
66 return nil, err
67 }
68 var opted []store.Runner
69 for _, u := range users {
70 // Toestemming geldt alleen zolang de gebruiker lid van de groep is.
71 role, err := st.GroupRole(ctx, repo.OwnerID, u)
72 if err != nil || !role.CanRead() {
73 continue
74 }
75 // En alleen als de eigenaar van de runner deze repo zelf mag
76 // lezen. Elke toewijzing kijkt opnieuw, dus ingetrokken rechten
77 // gelden meteen.
78 if r, err := st.EffectiveRole(ctx, u, repo.ID); err != nil || !r.CanRead() {
79 continue
80 }
81 rs, err := st.ListRunners(ctx, "user", u)
82 if err != nil {
83 return nil, err
84 }
85 opted = append(opted, rs...)
86 }
87 return Order("group", "", st.GroupBuiltinFirst(ctx, repo.OwnerID), nil, active(group), active(opted)), nil
88 }
89 own, err := st.ListRunners(ctx, "user", repo.OwnerID)
90 if err != nil {
91 return nil, err
92 }
93 return Order("user", st.UserRunnerPref(ctx, repo.OwnerID), false, active(own), nil, nil), nil
94}
95
96// active laat gepauzeerde (ook lokaal gepauzeerde) runners weg uit de volgorde.
97func active(rs []store.Runner) []store.Runner {
98 var out []store.Runner
99 for _, r := range rs {
100 if !r.Paused && !r.Draining {
101 out = append(out, r)
102 }
103 }
104 return out
105}
106
107func anyOnline(rs []store.Runner, now time.Time) bool {
108 for _, r := range rs {
109 if r.Online(now) {
110 return true
111 }
112 }
113 return false
114}
115
116// Step is de beslissing voor een wachtende job in deze tick.
117type Step struct {
118 Tier int // trede waar de job nu staat
119 Builtin bool // nu ingebouwd starten
120 Moved bool // aanbod is verplaatst; opslaan
121}
122
123// Advance kiest wat er met een wachtende job gebeurt. builtinFree zegt of
124// de ingebouwde runner nu een plek heeft. Elke trede wordt hooguit één
125// keer per tick bekeken.
126func Advance(tiers []Tier, tier int, offerAt, now time.Time, builtinFree bool) Step {
127 n := len(tiers)
128 if n == 0 {
129 return Step{}
130 }
131 if tier < 0 || tier >= n {
132 tier = 0
133 }
134 moved := offerAt.IsZero()
135 if moved {
136 offerAt = now
137 }
138 for i := 0; i < n; i++ {
139 t := tiers[tier]
140 if t.Builtin {
141 if builtinFree {
142 return Step{Tier: tier, Builtin: true, Moved: moved}
143 }
144 } else if anyOnline(t.Runners, now) && (now.Sub(offerAt) < OfferTimeout || i > 0 && moved) {
145 return Step{Tier: tier, Moved: moved}
146 }
147 tier = (tier + 1) % n
148 offerAt = now
149 moved = true
150 }
151 return Step{Tier: tier, Moved: moved}
152}
153
154// RunnerInTier zegt of runner id in de trede staat.
155func RunnerInTier(tiers []Tier, tier int, id int64) bool {
156 if tier < 0 || tier >= len(tiers) {
157 return false
158 }
159 for _, r := range tiers[tier].Runners {
160 if r.ID == id {
161 return true
162 }
163 }
164 return false
165}