hammerkit 1.27.0-next.26 → 1.27.0-next.27

package/dist/server/endpoints.js

@@ -288,6 +288,9 @@ class EndpointGateway {
             return page(res, 503, 'Starting', `<p>The services of this endpoint are ${run.wakes ? 'waking up' : 'starting'} (${escape(run.state)}), this page reloads until they are up.</p>`);
         }
         if (run.state === 'asleep') {
+            // it may wake on a later request, once there is a place for it
+            res.setHeader('refresh', '30');
+            res.setHeader('retry-after', '30');
             return page(res, 503, 'Asleep', `<p>The services of this endpoint sleep and can not wake now: ${escape(refused ?? 'try again')}.</p>`);
         }
         const why = run.stoppedBy === 'ttl'

package/dist/server/runs.js

@@ -124,6 +124,11 @@ class RunRegistry {
                     this.expireLater(entry);
                 }
             }
+            else if (run.state === 'asleep') {
+                // its time ran out while the server was down: it ends now, and gives its place back
+                run.stoppedBy ?? (run.stoppedBy = 'ttl');
+                this.finish(entry, 'succeeded');
+            }
             else if (run.state === 'queued' || run.state === 'running') {
                 this.finish(entry, 'failed', `the server stopped while the run was ${run.state}, submit it again`);
             }
@@ -146,7 +151,7 @@ class RunRegistry {
         }
         this.checkLimits(owner, waiting);
         if (spec.up) {
-            this.checkUpLimits(owner);
+            this.checkUpLimits(owner, spec.up.name);
             this.checkHosts(owner, spec.up);
         }
         const run = {
@@ -515,20 +520,59 @@ class RunRegistry {
             throw new QuotaError(`you have ${limits.queued} runs in the queue, wait for one to start or cancel one`);
         }
     }
-    // Service runs that are not over, of the caller and of everybody, against what may be:
-    // one that is asleep counts, it wakes without asking for a place.
-    checkUpLimits(owner) {
+    // Service runs that are starting or up, of the caller and of everybody, against what may
+    // be. One that is asleep does not count: it asks for a place when it wakes (visit). The runs
+    // of a caller with one name take one place: the newest replaces the others once it is up,
+    // and an older one that gets up after it goes (markUp), so a new run of a name the caller
+    // has does not need another. Several of one name that are still starting share it too:
+    // what they take while they start is held by runs.limits.running and maxConcurrent.
+    checkUpLimits(owner, name) {
+        // what a caller keeps asleep is held by a limit of its own: a run that sleeps may keep the
+        // volumes of its services. A run of a name the caller has a run of (asleep, up or
+        // starting) replaces it, it is not one more.
+        const asleep = this.options.up?.asleep;
+        if (asleep !== undefined) {
+            const open = [...this.entries.values()].filter((entry) => entry.run.up && !isFinal(entry.run.state) && this.owns(owner, entry));
+            const sleeping = new Set(open.filter((entry) => entry.run.state === 'asleep').map((entry) => entry.run.up?.name));
+            if (!open.some((entry) => entry.run.up?.name === name) && sleeping.size >= asleep) {
+                throw new QuotaError(`you have ${asleep} service runs asleep, stop one or wait for its end`);
+            }
+        }
+        const full = this.upLimitReached(owner, name);
+        if (full === 'caller') {
+            throw new QuotaError(`you have ${this.options.up?.perCaller} service runs starting or up, stop one or wait for its end`);
+        }
+        if (full === 'server') {
+            throw new RunError(`the server has ${this.options.up?.total} service runs starting or up, try again later`);
+        }
+    }
+    // Whose limit a service run of the caller with this name would go over, if any
+    upLimitReached(owner, name) {
         const limits = this.options.up;
         if (!limits) {
-            return;
+            return undefined;
         }
-        const open = [...this.entries.values()].filter((entry) => entry.run.up && !isFinal(entry.run.state));
-        if (open.filter((entry) => this.owns(owner, entry)).length >= limits.perCaller) {
-            throw new QuotaError(`you have ${limits.perCaller} service runs starting, up or asleep, stop one or wait for its end`);
+        const places = new Set();
+        const mine = new Set();
+        for (const entry of this.entries.values()) {
+            if (!entry.run.up || isFinal(entry.run.state) || entry.run.state === 'asleep') {
+                continue;
+            }
+            places.add(JSON.stringify([entry.run.owner.iss, entry.run.owner.sub, entry.run.up.name]));
+            if (this.owns(owner, entry)) {
+                mine.add(entry.run.up.name);
+            }
+        }
+        if (mine.has(name)) {
+            return undefined;
+        }
+        if (mine.size >= limits.perCaller) {
+            return 'caller';
         }
-        if (open.length >= limits.total) {
-            throw new RunError(`the server has ${limits.total} service runs starting, up or asleep, try again later`);
+        if (places.size >= limits.total) {
+            return 'server';
         }
+        return undefined;
     }
     // A host is one run's, or a run's that replaces it (same owner and name) once it is up:
     // two labels that come out the same are refused, they would reach each other's services.
@@ -666,6 +710,18 @@ class RunRegistry {
                 this.stop(other, `replaced by ${entry.run.id}`);
             }
         }
+        // A newer run of the name that is up or asleep already (this one waited for an approval
+        // while it got up) is what the owner started last: this one goes, so the runs of a name,
+        // which take one place of runs.up.limits, never hold more than one set of services.
+        const newer = entries
+            .slice(entries.indexOf(entry) + 1)
+            .find((other) => other.run.up?.name === spec.name &&
+            this.owns(entry.run.owner, other) &&
+            (other.run.state === 'up' || other.run.state === 'asleep'));
+        if (newer) {
+            entry.run.stoppedBy = 'replaced';
+            this.stop(entry, `replaced by ${newer.run.id}`);
+        }
         this.dispatch();
     }
     // Stops a service run at its expiry, and puts one that is up to sleep at its sleepsAt. A
@@ -719,9 +775,9 @@ class RunRegistry {
     }
     /**
      * A request to an endpoint of a service run: one that is up stays up for its sleepTtl from
-     * now, one that is asleep is started again (it holds its place of runs.up.limits while it
-     * sleeps), if `mayWake` finds its owner may still run it: else it ends. Answers why it was
-     * not woken, or undefined.
+     * now, one that is asleep is started again, if `mayWake` finds its owner may still run it
+     * (else it ends) and there is a place of runs.up.limits for it (else it sleeps on, and the
+     * next request asks again). Answers why it was not woken, or undefined.
      */
     visit(id, mayWake) {
         const entry = this.entries.get(id);
@@ -746,6 +802,13 @@ class RunRegistry {
             this.finish(entry, 'failed', refused);
             return refused;
         }
+        const full = this.upLimitReached(entry.run.owner, entry.run.up.name);
+        if (full === 'caller') {
+            return 'its owner has as many service runs starting or up as they may, it wakes once one of them stops or sleeps';
+        }
+        if (full === 'server') {
+            return 'the server has as many service runs starting or up as it may, it wakes once one of them stops or sleeps';
+        }
         this.clearTimer(entry);
         entry.abort = new AbortController();
         entry.released = false;

package/dist/server/server-config.js

@@ -525,6 +525,9 @@ exports.serverConfigSchema = zod_1.z
                 .object({
                 // service runs one caller has starting or up at a time; one more is 429
                 up: zod_1.z.number().int().min(1).default(3),
+                // service runs one caller has asleep, which take no place of `up`; a new run
+                // when there are this many is 429
+                asleep: zod_1.z.number().int().min(1).default(10),
             })
                 .strict()
                 .default({}),

package/dist/server/server.js

@@ -707,6 +707,7 @@ async function startServer(config, environment, options = {}) {
         up: {
             maxTtl: (0, units_1.parseDuration)(config.runs.up.maxTtl),
             perCaller: config.runs.up.limits.up,
+            asleep: config.runs.up.limits.asleep,
             total: config.runs.up.total,
         },
         store: new run_store_1.FileRunStore((0, path_1.join)(storage, 'records')),

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hammerkit",
   "description": "Containerized build tool with incremental caching that runs the same build file locally, in Docker and on Kubernetes.",
-  "version": "1.27.0-next.26",
+  "version": "1.27.0-next.27",
   "keywords": [
     "build",
     "build-tool",