@cyc-seattle/platform 1.39.3 → 1.40.0

package/README.md

@@ -31,11 +31,13 @@ app owns. The apps that run on it live in their own repos, such as
   one replica, `spreadAcrossZones` spreads them, and `minAvailable` adds a PodDisruptionBudget.
   `podAnnotations` sets annotations such as `cluster-autoscaler.kubernetes.io/safe-to-evict`. A
   pod with `safe-to-evict: "false"` gets at least 500m CPU and 512Mi from Autopilot, so ask for that
-  much, or every preview shows a change.
+  much, or every preview shows a change. `progressDeadlineSeconds` gives a slow rollout longer than
+  Kubernetes' 600 seconds before the deploy fails.
 - `WebService` is a `Workload` behind the environment's Gateway at `hostname`. Its Service exposes
   `port` as port 80, and its readiness probe must be an HTTP GET, which the load balancer's health
   check reuses unless `healthCheck.path` names a cheaper path. With `paths`, it claims only those path prefixes on `hostname`, and another
-  `WebService` can serve the rest of it.
+  `WebService` can serve the rest of it. A stopping pod keeps serving for 10 seconds, while the load
+  balancer stops sending to it, then has 30 seconds to exit.
 - `ScheduledJob` runs a CronJob on `schedule`, in `America/Los_Angeles` unless `timeZone` says
   otherwise. A run never overlaps the one before it, gets an hour, and doesn't retry, by default.
 - All three run non-root with a read-only root filesystem, no capabilities, and no service account

package/dist/planning/staffing.d.ts

@@ -22,13 +22,10 @@ export interface DoubleBooked {
 export declare function enrollmentOf(offering: PlanOffering): number;
 export declare class Staffing {
     private readonly ctx;
-    private readonly covers;
     private readonly warned;
     constructor(ctx: Context);
     /** Warns once for each row and plan copy, about the first date it's seen on. */
     private warnOnce;
-    /** Whether holding `held` qualifies for `required`, through `qualification_covers`. */
-    qualifies(held: Id[], required: Id): boolean;
     /**
      * Gathers each block's activities, times and allocations. A block's paid time runs from its first
      * activity's start to its last one's end, plus the longest setup and put-away. Its time on the
@@ -39,12 +36,11 @@ export declare class Staffing {
     private checkUnallocated;
     /** Each program's settings, by its product. */
     private programs;
-    /** Whether a staff member holding `held`, at level `levelKey` if any, may coach a program coached at `required`. */
-    private qualifiedFor;
     /**
      * Warns when a block's sailors are more than its staff or its boats can safely take. Each program's
-     * sailors count against its own sailors per coach, and a coach counts if they're at the staff
-     * level of one of the block's programs, or qualified for it. Boats count the ones sailors bring.
+     * sailors count against its own sailors per coach, and need coaches at its own staff level. A
+     * salaried position on the block counts as a coach for any of its programs, since the plan trusts
+     * the planner's allocation (#208). Boats count the ones sailors bring.
      */
     private checkCapacity;
     /**

package/dist/planning/staffing.js

@@ -41,13 +41,9 @@ function groupBy(rows, key) {
 }
 export class Staffing {
     ctx;
-    covers = new Map();
     warned = new Set();
     constructor(ctx) {
         this.ctx = ctx;
-        for (const c of ctx.data.qualification_covers) {
-            this.covers.set(c.qualification_id, new Set([...(this.covers.get(c.qualification_id) ?? []), c.covers_id]));
-        }
     }
     /** Warns once for each row and plan copy, about the first date it's seen on. */
     warnOnce(code, message, key, scope = {}) {
@@ -57,21 +53,6 @@ export class Staffing {
         this.warned.add(id);
         this.ctx.warn(code, message, key, scope);
     }
-    /** Whether holding `held` qualifies for `required`, through `qualification_covers`. */
-    qualifies(held, required) {
-        const seen = new Set();
-        const stack = [...held];
-        while (stack.length > 0) {
-            const q = stack.pop();
-            if (q === required)
-                return true;
-            if (seen.has(q))
-                continue;
-            seen.add(q);
-            stack.push(...(this.covers.get(q) ?? []));
-        }
-        return false;
-    }
     /**
      * Gathers each block's activities, times and allocations. A block's paid time runs from its first
      * activity's start to its last one's end, plus the longest setup and put-away. Its time on the
@@ -147,18 +128,11 @@ export class Staffing {
     programs() {
         return new Map(this.ctx.data.plan_programs.map((p) => [p.product_id, p]));
     }
-    /** Whether a staff member holding `held`, at level `levelKey` if any, may coach a program coached at `required`. */
-    qualifiedFor(held, levelKey, required) {
-        if (levelKey === required)
-            return true;
-        const level = this.ctx.data.plan_staff_levels.find((l) => l.key === required);
-        const needed = level?.qualifications ?? [];
-        return needed.length > 0 && needed.every((q) => this.qualifies(held, q));
-    }
     /**
      * Warns when a block's sailors are more than its staff or its boats can safely take. Each program's
-     * sailors count against its own sailors per coach, and a coach counts if they're at the staff
-     * level of one of the block's programs, or qualified for it. Boats count the ones sailors bring.
+     * sailors count against its own sailors per coach, and need coaches at its own staff level. A
+     * salaried position on the block counts as a coach for any of its programs, since the plan trusts
+     * the planner's allocation (#208). Boats count the ones sailors bring.
      */
     checkCapacity(block, programs) {
         const { ctx } = this;
@@ -171,9 +145,9 @@ export class Staffing {
         const scope = { version_id: block.row.version_id, date: block.row.date };
         // The block's offerings, with the verb that agrees with them: "Guppies Week 2 has".
         const has = `${offeringsOf(block)} ${new Set(block.members.map((a) => a.offering.id)).size > 1 ? "have" : "has"}`;
-        let load = 0;
+        // Coaches each level needs, from the sailors of the programs coached at it.
+        const needed = new Map();
         let counted = 0;
-        const required = [];
         for (const o of offerings) {
             const settings = programs.get(o.product_id);
             if (settings?.staff_level_key == null || settings.sailors_per_coach == null || settings.sailors_per_coach <= 0) {
@@ -181,24 +155,25 @@ export class Staffing {
                 continue;
             }
             const n = ctx.enrollment.get(o.id) ?? 0;
-            load += n / settings.sailors_per_coach;
+            needed.set(settings.staff_level_key, (needed.get(settings.staff_level_key) ?? 0) + n / settings.sailors_per_coach);
             counted += n;
-            required.push(settings.staff_level_key);
         }
         if (counted > 0) {
-            const levels = new Map(ctx.data.plan_staff_levels.map((l) => [l.key, l]));
-            const positions = new Map(ctx.data.plan_salaried_positions.map((p) => [p.key, p]));
-            const qualified = sum(block.staff.map((s) => {
-                const held = s.position_key != null
-                    ? (positions.get(s.position_key)?.qualifications ?? [])
-                    : (levels.get(s.staff_level_key ?? "")?.qualifications ?? []);
-                const level = s.position_key != null ? null : s.staff_level_key;
-                return required.some((r) => this.qualifiedFor(held, level, r)) ? s.count : 0;
-            }));
-            if (load > qualified + 1e-9) {
-                ctx.warn("over_capacity", qualified === 0
+            const load = sum(needed.values());
+            // Each level's staff cover only its own programs; salaried positions cover what's left.
+            let short = 0;
+            let covered = 0;
+            for (const [level, need] of needed) {
+                const have = sum(block.staff.filter((s) => s.position_key == null && s.staff_level_key === level).map((s) => s.count));
+                covered += Math.min(need, have);
+                short += Math.max(0, need - have);
+            }
+            const salaried = sum(block.staff.filter((s) => s.position_key != null).map((s) => s.count));
+            covered += Math.min(short, salaried);
+            if (load > covered + 1e-9) {
+                ctx.warn("over_capacity", covered === 0
                     ? `${has} ${countOf(counted, "sailor")} and no coach`
-                    : `${has} ${countOf(counted, "sailor")}, but enough coaches for only ${Math.floor((qualified * counted) / load + 1e-9)}`, block.row.key, scope);
+                    : `${has} ${countOf(counted, "sailor")}, but enough coaches for only ${Math.floor((covered * counted) / load + 1e-9)}`, block.row.key, scope);
             }
         }
         if (!block.members.some((a) => a.uses_boats))

package/dist/schema/index.d.ts

@@ -68,6 +68,7 @@ export interface Schema {
     registrations: Registrations[];
     resource_kinds: ResourceKinds[];
     schools: Schools[];
+    sync_leases: SyncLeases[];
     sync_runs: SyncRuns[];
     sync_tasks: SyncTasks[];
     version_set_members: VersionSetMembers[];
@@ -1058,6 +1059,14 @@ export interface Schools {
     /** Other ways families write this school on their Clubspot forms. An answer matching the name or one of these, ignoring capitals and punctuation and counting a run of spaces as one, is this school. Anything else is kept as their own words. */
     aliases: string[] | null;
 }
+/** Which syncs are running now. A sync holds its queue while it runs, so a second run waits its turn. Written by the syncs. */
+export interface SyncLeases {
+    id: string;
+    /** Which sync's queue is held. A queue has one lease at a time. */
+    queue: string;
+    /** The running sync renews this every minute. Once it passes, the sync has stopped, and the next run takes the queue. */
+    expires_at: string;
+}
 /** One row each time a sync runs. */
 export interface SyncRuns {
     id: string;

package/dist/workload.d.ts

@@ -65,6 +65,8 @@ export interface WorkloadArgs extends PodArgs {
     spreadAcrossZones?: boolean;
     /** Adds a PodDisruptionBudget that keeps this many pods up through drains. Must be below `replicas`. */
     minAvailable?: number;
+    /** How long a rollout may take before the Deployment, and so the deploy, fails. Defaults to 600. */
+    progressDeadlineSeconds?: number;
 }
 /** The pods' Workload Identity principal, for IAM grants. */
 export declare function workloadMember(platform: pulumi.Output<PlatformOutputs>, serviceAccountName: pulumi.Input<string>): pulumi.Output<string>;

package/dist/workload.js

@@ -79,6 +79,7 @@ export function podSpec(name, args, serviceAccountName, container = {}) {
         ],
     }));
 }
+const preStopSeconds = 10;
 /**
  * The Deployment, ServiceAccount, and Service of a `Workload` or a `WebService`, as children of
  * `parent`. `http` is a `WebService`'s port, which its Service exposes as port 80.
@@ -99,10 +100,16 @@ export function deployment(parent, name, args, http) {
         throw new Error(`${name}: "minAvailable" (${args.minAvailable}) must be below "replicas" (${replicas}).`);
     }
     const ports = [...(http !== undefined ? [{ name: "http", port: http }] : []), ...(args.ports ?? [])];
+    // The load balancer keeps sending to a stopping pod for a few seconds (cyc-seattle/platform#153), so
+    // a WebService's pod keeps serving that long before it gets SIGTERM, then has the default 30s to exit.
+    const drain = http !== undefined && {
+        lifecycle: { preStop: { sleep: { seconds: preStopSeconds } } },
+    };
     new k8s.apps.v1.Deployment(name, {
         metadata,
         spec: {
             replicas,
+            ...(args.progressDeadlineSeconds !== undefined && { progressDeadlineSeconds: args.progressDeadlineSeconds }),
             selector: { matchLabels: labels },
             template: {
                 metadata: { labels, ...(args.podAnnotations && { annotations: args.podAnnotations }) },
@@ -111,8 +118,10 @@ export function deployment(parent, name, args, http) {
                     ...(args.readinessProbe && { readinessProbe: args.readinessProbe }),
                     ...(args.livenessProbe && { livenessProbe: args.livenessProbe }),
                     ...(args.startupProbe && { startupProbe: args.startupProbe }),
+                    ...drain,
                 }).apply((spec) => ({
                     ...spec,
+                    ...(drain && { terminationGracePeriodSeconds: preStopSeconds + 30 }),
                     ...(args.spreadAcrossZones && {
                         topologySpreadConstraints: [
                             {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cyc-seattle/platform",
-  "version": "1.39.3",
+  "version": "1.40.0",
   "description": "Pulumi components for CYC's shared Google Cloud platform: WebService, the platform outputs reader, and the stacks that build the platform",
   "author": "CYC Community Sailing Center",
   "license": "Apache-2.0",