BlueGit

timfa bluegit

Files

bluegit / internal / runner / routing.go

routing.go

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