package runner import ( "context" "gitlab.com/Timfa/bluegit/internal/access" "time" "gitlab.com/Timfa/bluegit/internal/store" ) // Tier is één trede in de runnervolgorde van een job: de ingebouwde // BlueGit-runner of een set aparte runners. type Tier struct { Builtin bool Runners []store.Runner } // OfferTimeout: zo lang krijgen online aparte runners in een trede om een // job op te pakken voordat de volgende trede aan de beurt is. var OfferTimeout = 20 * time.Second // Order berekent de volgorde puur uit de gegevens; zie Tiers. // // Accountrepo: eigen runners eerst (own_first) of de BlueGit-runner eerst // en eigen runners alleen als die niet meteen vrij is (builtin_first). // Groepsrepo: groepsrunners → account-runners van groepsleden die // toestemming gaven → BlueGit-runner; met builtinFirst staat de // BlueGit-runner vooraan. Lege treden vallen weg. func Order(ownerKind, userPref string, builtinFirst bool, own, group, optedIn []store.Runner) []Tier { var tiers []Tier add := func(t Tier) { if t.Builtin || len(t.Runners) > 0 { tiers = append(tiers, t) } } builtin := Tier{Builtin: true} if ownerKind == "group" { if builtinFirst { add(builtin) } add(Tier{Runners: group}) add(Tier{Runners: optedIn}) if !builtinFirst { add(builtin) } return tiers } if userPref == store.RunnerPrefOwnFirst { add(Tier{Runners: own}) add(builtin) } else { add(builtin) add(Tier{Runners: own}) } return tiers } // Tiers geeft de runnervolgorde voor een repo. Globale runners (van de // beheerders) staan altijd vooraan, daarna de volgorde van Order. // // protected: de job draait op een beschermde ref (en krijgt beschermde // geheimen). Dan doen account-runners van opt-in-leden alleen mee als hun // eigenaar maintainer (of hoger, of instance-admin) op de repo is. func Tiers(ctx context.Context, st *store.Store, repo store.Repo, protected bool) ([]Tier, error) { global, err := st.ListRunners(ctx, store.RunnerGlobal, 0) if err != nil { return nil, err } rest, err := repoTiers(ctx, st, repo, protected) if err != nil { return nil, err } if g := active(global); len(g) > 0 { return append([]Tier{{Runners: g}}, rest...), nil } return rest, nil } func repoTiers(ctx context.Context, st *store.Store, repo store.Repo, protected bool) ([]Tier, error) { if repo.OwnerKind == "group" { group, err := st.ListRunners(ctx, "group", repo.OwnerID) if err != nil { return nil, err } users, err := st.RunnerOptIns(ctx, repo.OwnerID) if err != nil { return nil, err } var opted []store.Runner for _, u := range users { // Toestemming geldt alleen zolang de gebruiker lid van de groep is. role, err := st.GroupRole(ctx, repo.OwnerID, u) if err != nil || !role.CanRead() { continue } // En alleen als de eigenaar van de runner deze repo zelf mag // lezen. Elke toewijzing kijkt opnieuw, dus ingetrokken rechten // gelden meteen. if r, err := st.EffectiveRole(ctx, u, repo.ID); err != nil || !r.CanRead() { continue } if protected && !MaintainerOrAdmin(ctx, st, u, repo.ID) { continue } rs, err := st.ListRunners(ctx, "user", u) if err != nil { return nil, err } opted = append(opted, rs...) } return Order("group", "", st.GroupBuiltinFirst(ctx, repo.OwnerID), nil, active(group), active(opted)), nil } own, err := st.ListRunners(ctx, "user", repo.OwnerID) if err != nil { return nil, err } return Order("user", st.UserRunnerPref(ctx, repo.OwnerID), false, active(own), nil, nil), nil } // active laat gepauzeerde (ook lokaal gepauzeerde) runners weg uit de volgorde. func active(rs []store.Runner) []store.Runner { var out []store.Runner for _, r := range rs { if !r.Paused && !r.Draining { out = append(out, r) } } return out } func anyOnline(rs []store.Runner, now time.Time) bool { for _, r := range rs { if r.Online(now) { return true } } return false } // Step is de beslissing voor een wachtende job in deze tick. type Step struct { Tier int // trede waar de job nu staat Builtin bool // nu ingebouwd starten Moved bool // aanbod is verplaatst; opslaan } // Advance kiest wat er met een wachtende job gebeurt. builtinFree zegt of // de ingebouwde runner nu een plek heeft. Elke trede wordt hooguit één // keer per tick bekeken. func Advance(tiers []Tier, tier int, offerAt, now time.Time, builtinFree bool) Step { n := len(tiers) if n == 0 { return Step{} } if tier < 0 || tier >= n { tier = 0 } moved := offerAt.IsZero() if moved { offerAt = now } for i := 0; i < n; i++ { t := tiers[tier] if t.Builtin { if builtinFree { return Step{Tier: tier, Builtin: true, Moved: moved} } } else if anyOnline(t.Runners, now) && (now.Sub(offerAt) < OfferTimeout || i > 0 && moved) { return Step{Tier: tier, Moved: moved} } tier = (tier + 1) % n offerAt = now moved = true } return Step{Tier: tier, Moved: moved} } // RunnerInTier zegt of runner id in de trede staat. func RunnerInTier(tiers []Tier, tier int, id int64) bool { if tier < 0 || tier >= len(tiers) { return false } for _, r := range tiers[tier].Runners { if r.ID == id { return true } } return false } // MaintainerOrAdmin: de gebruiker is maintainer (of eigenaar) van de repo, // of instance-admin. func MaintainerOrAdmin(ctx context.Context, st *store.Store, userID, repoID int64) bool { if u, err := st.UserByID(ctx, userID); err == nil && u.InstanceAdmin { return true } r, err := st.EffectiveRole(ctx, userID, repoID) return err == nil && r.AtLeast(access.RoleMaintainer) } // ExcludedForProtected geeft de namen van opt-in account-runners die voor // een job op een beschermde ref niet mogen (eigenaar geen maintainer). func ExcludedForProtected(ctx context.Context, st *store.Store, repo store.Repo) []string { if repo.OwnerKind != "group" { return nil } users, _ := st.RunnerOptIns(ctx, repo.OwnerID) var out []string for _, u := range users { if role, err := st.GroupRole(ctx, repo.OwnerID, u); err != nil || !role.CanRead() { continue } if MaintainerOrAdmin(ctx, st, u, repo.ID) { continue } rs, _ := st.ListRunners(ctx, "user", u) for _, rn := range active(rs) { out = append(out, rn.Name) } } return out }