hammerkit 1.21.0 → 1.21.2

package/dist/cache/backends/registry/registry-client.js

@@ -108,20 +108,18 @@ class RegistryClient {
         this.authorization = `Bearer ${token}`;
         return true;
     }
-    // Send a request, performing the auth handshake once on a 401. `body` is a
-    // factory because a streamed body cannot be replayed after the challenge.
+    // Send a request, performing the auth handshake once on a 401. A string,
+    // buffer or blob body is replayable and fetch derives its content-length;
+    // never set that header by hand, the undici that serves `fetch` rejects it
+    // on some Node versions.
     async request(method, urlOrPath, init = {}) {
         const url = urlOrPath.startsWith('http') ? urlOrPath : this.url(urlOrPath);
-        const send = () => {
-            const body = init.body?.();
-            return fetch(url, {
-                method,
-                headers: { ...(init.headers ?? {}), ...(this.authorization ? { authorization: this.authorization } : {}) },
-                body: body instanceof stream_1.Readable ? stream_1.Readable.toWeb(body) : body,
-                redirect: init.redirect ?? 'follow',
-                ...(body instanceof stream_1.Readable ? { duplex: 'half' } : {}),
-            });
-        };
+        const send = () => fetch(url, {
+            method,
+            headers: { ...(init.headers ?? {}), ...(this.authorization ? { authorization: this.authorization } : {}) },
+            body: init.body?.(),
+            redirect: init.redirect ?? 'follow',
+        });
         let response = await send();
         if (response.status === 401 && (await this.authenticate(response.headers.get('www-authenticate')))) {
             await response.body?.cancel();
@@ -223,8 +221,10 @@ class RegistryClient {
         return true;
     }
     // Upload a blob from a buffer or a file (monolithic upload: POST to open the
-    // session, PUT the content with its digest to commit it).
-    async uploadBlob(digest, size, content) {
+    // session, PUT the content with its digest to commit it). A file is sent as a
+    // blob backed by the file, so it is read lazily and fetch sends its size as
+    // the content-length.
+    async uploadBlob(digest, content) {
         if (await this.blobExists(digest)) {
             return;
         }
@@ -238,9 +238,10 @@ class RegistryClient {
         }
         const uploadUrl = new URL(location, this.url(''));
         uploadUrl.searchParams.set('digest', digest);
+        const body = 'buffer' in content ? content.buffer : await (0, fs_1.openAsBlob)(content.file);
         const response = await this.request('PUT', uploadUrl.toString(), {
-            headers: { 'content-type': 'application/octet-stream', 'content-length': `${size}` },
-            body: () => ('buffer' in content ? content.buffer : (0, fs_1.createReadStream)(content.file)),
+            headers: { 'content-type': 'application/octet-stream' },
+            body: () => body,
         });
         if (response.status !== 201) {
             return this.fail(response, `uploading blob ${digest}`);

package/dist/cache/backends/registry-cache-backend.js

@@ -85,8 +85,8 @@ function createRegistryCacheBackend(spec) {
                     config: { Labels: { 'dev.hammerkit.task-id': taskId, 'dev.hammerkit.state-key': stateKey } },
                 }));
                 const configDigest = (0, registry_client_1.digestBuffer)(config);
-                await registry.uploadBlob(layer.digest, layer.size, { file: layerFile });
-                await registry.uploadBlob(configDigest.digest, configDigest.size, { buffer: config });
+                await registry.uploadBlob(layer.digest, { file: layerFile });
+                await registry.uploadBlob(configDigest.digest, { buffer: config });
                 const manifest = {
                     schemaVersion: 2,
                     mediaType: registry_client_1.OCI_MANIFEST,

package/dist/executer/await-completed-dependencies.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.awaitRunningNeeds = exports.awaitRunningNeed = exports.awaitCompleted = exports.awaitCompletedDependencies = exports.awaitNoRequirements = exports.awaitDependentNeed = exports.awaitRequirement = void 0;
+exports.awaitRunningNeeds = exports.awaitRunningNeed = exports.awaitCompleted = exports.awaitCompletedDependencies = exports.transitiveDeps = exports.awaitNoRequirements = exports.awaitDependentNeed = exports.awaitRequirement = void 0;
 const work_item_1 = require("../planner/work-item");
 const state_resolver_1 = require("./state-resolver");
 // Resolve true once any requirer is `ready` (about to run). With
@@ -42,8 +42,26 @@ async function awaitNoRequirements(svc, abort) {
     }));
 }
 exports.awaitNoRequirements = awaitNoRequirements;
+// The dependencies and, recursively, theirs, each once.
+function transitiveDeps(deps) {
+    const seen = new Set();
+    const visit = (items) => {
+        for (const item of items) {
+            if (!seen.has(item)) {
+                seen.add(item);
+                visit(item.deps);
+            }
+        }
+    };
+    visit(deps);
+    return [...seen];
+}
+exports.transitiveDeps = transitiveDeps;
+// Waits for the whole dependency closure, not only the direct dependencies: a
+// cached direct dependency completes at once, while the dependencies it
+// skipped past are still being restored for the item about to run.
 async function awaitCompletedDependencies(work, deps, abort) {
-    for (const dep of deps) {
+    for (const dep of transitiveDeps(deps)) {
         work.status.write('debug', `await completion of ${dep.name} with state ${dep.state.current.type}`);
         await awaitCompleted(work, dep, abort);
     }

package/dist/executer/execute-work-tree.js

@@ -5,6 +5,7 @@ const plan_work_tasks_1 = require("../planner/utils/plan-work-tasks");
 const execute_work_service_1 = require("./execute-work-service");
 const execute_work_task_1 = require("./execute-work-task");
 const execute_init_task_1 = require("./execute-init-task");
+const await_completed_dependencies_1 = require("./await-completed-dependencies");
 async function executeWorkTree(work, environment, options) {
     const itemPromises = [];
     const dependents = skippableDependents(work, options);
@@ -67,9 +68,13 @@ function skippableDependents(work, options) {
             result.set(task.name, []);
         }
     }
+    // A dependent also needs everything its dependencies need: a cached `build`
+    // does not restore the `install` a re-running `test` uses at run time. So a
+    // task is a dependent of its whole dependency closure, requested tasks
+    // included in the walk (they are cached or run on their own).
     const items = [...(0, plan_work_tasks_1.iterateWorkTasks)(work), ...(0, plan_work_tasks_1.iterateWorkServices)(work)];
     for (const item of items) {
-        for (const dep of item.deps) {
+        for (const dep of (0, await_completed_dependencies_1.transitiveDeps)(item.deps)) {
             if (work.requested.includes(dep.name)) {
                 continue;
             }

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.21.0",
+  "version": "1.21.2",
   "keywords": [
     "build",
     "build-tool",