BlueGit

timfa bluegit

Files

bluegit / internal / runner / routing.go

routing.go

routing.go 3.8 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, group, 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, own, nil, nil), nil
89}
90
91func anyOnline(rs []store.Runner, now time.Time) bool {
92 for _, r := range rs {
93 if r.Online(now) {
94 return true
95 }
96 }
97 return false
98}
99
100// Step is de beslissing voor een wachtende job in deze tick.
101type Step struct {
102 Tier int // trede waar de job nu staat
103 Builtin bool // nu ingebouwd starten
104 Moved bool // aanbod is verplaatst; opslaan
105}
106
107// Advance kiest wat er met een wachtende job gebeurt. builtinFree zegt of
108// de ingebouwde runner nu een plek heeft. Elke trede wordt hooguit één
109// keer per tick bekeken.
110func Advance(tiers []Tier, tier int, offerAt, now time.Time, builtinFree bool) Step {
111 n := len(tiers)
112 if n == 0 {
113 return Step{}
114 }
115 if tier < 0 || tier >= n {
116 tier = 0
117 }
118 moved := offerAt.IsZero()
119 if moved {
120 offerAt = now
121 }
122 for i := 0; i < n; i++ {
123 t := tiers[tier]
124 if t.Builtin {
125 if builtinFree {
126 return Step{Tier: tier, Builtin: true, Moved: moved}
127 }
128 } else if anyOnline(t.Runners, now) && (now.Sub(offerAt) < OfferTimeout || i > 0 && moved) {
129 return Step{Tier: tier, Moved: moved}
130 }
131 tier = (tier + 1) % n
132 offerAt = now
133 moved = true
134 }
135 return Step{Tier: tier, Moved: moved}
136}
137
138// RunnerInTier zegt of runner id in de trede staat.
139func RunnerInTier(tiers []Tier, tier int, id int64) bool {
140 if tier < 0 || tier >= len(tiers) {
141 return false
142 }
143 for _, r := range tiers[tier].Runners {
144 if r.ID == id {
145 return true
146 }
147 }
148 return false
149}