| 1 | package runner |
| 2 | |
| 3 | import ( |
| 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. |
| 13 | type 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. |
| 20 | var 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. |
| 29 | func 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. |
| 64 | func 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 | |
| 79 | func 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. |
| 121 | func 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 | |
| 131 | func 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. |
| 141 | type 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. |
| 150 | func 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. |
| 179 | func 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. |
| 193 | func 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). |
| 203 | func 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 | } |