hammerkit 1.11.1 → 1.11.3

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

@@ -16,12 +16,18 @@ async function awaitRequirement(svc, abort, options = { untilAllDone: false }) {
     return Promise.race([ready, allDone]);
 }
 exports.awaitRequirement = awaitRequirement;
-// Resolve true once any dependent is `ready` — it missed the cache and is about
-// to run, so it needs this task's outputs — and false once every dependent
-// finished without needing it (all cache hits, or skipped themselves).
+// Resolve true once any dependent needs this task's outputs — a task that is
+// `ready` (it missed the cache and is about to run), a service that is
+// `starting` (a task needing it runs) — and false once every dependent
+// finished without needing it: tasks that were cache hits or skipped, services
+// that never started.
 async function awaitDependentNeed(dependents, abort) {
-    const ready = Promise.race(dependents.map((dependent) => (0, state_resolver_1.awaitState)('await-dependent', dependent.state, (s) => s.type === 'ready', abort))).then(() => true);
-    const allDone = Promise.all(dependents.map((dependent) => (0, state_resolver_1.awaitState)('await-dependent-done', dependent.state, (s) => s.type === 'completed' || s.type === 'error' || s.type === 'crash' || s.type === 'canceled', abort))).then(() => false);
+    const ready = Promise.race(dependents.map((dependent) => (0, work_item_1.isWorkTaskItem)(dependent)
+        ? (0, state_resolver_1.awaitState)('await-dependent', dependent.state, (s) => s.type === 'ready', abort)
+        : (0, state_resolver_1.awaitState)('await-dependent', dependent.state, (s) => s.type === 'starting' || s.type === 'ready' || s.type === 'running', abort))).then(() => true);
+    const allDone = Promise.all(dependents.map((dependent) => (0, work_item_1.isWorkTaskItem)(dependent)
+        ? (0, state_resolver_1.awaitState)('await-dependent-done', dependent.state, (s) => s.type === 'completed' || s.type === 'error' || s.type === 'crash' || s.type === 'canceled', abort)
+        : (0, state_resolver_1.awaitState)('await-dependent-done', dependent.state, (s) => s.type === 'end' || s.type === 'error' || s.type === 'canceled', abort))).then(() => false);
     return Promise.race([ready, allDone]);
 }
 exports.awaitDependentNeed = awaitDependentNeed;

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

@@ -38,14 +38,14 @@ function onlyGroupsCacheHits(work) {
         work.deps.every((dep) => dep.state.current.type === 'completed' && dep.state.current.cached));
 }
 async function executeWorkTask(work, environment, options, 
-// when set, the task was not requested and only runs if one of these tasks
-// depending on it misses the cache (see executeWorkTree)
+// when set, the task was not requested and only runs if one of these items
+// depending on it needs it (see executeWorkTree)
 dependents = null) {
     try {
         if (dependents) {
             const needed = await (0, await_completed_dependencies_1.awaitDependentNeed)(dependents, environment.abortCtrl.signal);
             if (!needed) {
-                work.status.write('debug', `${work.name} skipped, every task depending on it was a cache hit`);
+                work.status.write('debug', `${work.name} skipped, nothing depending on it had to run`);
                 work.state.set({ type: 'completed', cached: false, skipped: true, duration: 0, stateKey: '' });
                 return;
             }

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

@@ -51,26 +51,29 @@ function mirrorServicesToInitViews(work) {
         });
     }
 }
-// For every task that may be skipped when nothing needs it, the tasks in this
-// run that depend on it. Requested tasks always run; so does anything a service
-// depends on, and everything in watch mode or with skipping turned off.
+// For every task that may be skipped when nothing needs it, the tasks and
+// services in this run that depend on it. Requested tasks always run; a
+// service's dependency runs once the service starts. Everything runs in watch
+// mode, under `up` and with skipping turned off.
 function skippableDependents(work, options) {
     const result = new Map();
     if (options.type !== 'execute' || !options.skipDeps || options.watch || !work.requested) {
         return result;
     }
-    const neededByService = new Set();
-    for (const service of (0, plan_work_tasks_1.iterateWorkServices)(work)) {
-        for (const dep of service.deps) {
-            neededByService.add(dep.name);
+    // a dependency of nothing in the run (its service needs no one here) has no
+    // dependents left, and is skipped
+    for (const task of (0, plan_work_tasks_1.iterateWorkTasks)(work)) {
+        if (!work.requested.includes(task.name) && !(0, execute_init_task_1.findInitOf)(task)) {
+            result.set(task.name, []);
         }
     }
-    for (const task of (0, plan_work_tasks_1.iterateWorkTasks)(work)) {
-        for (const dep of task.deps) {
-            if (work.requested.includes(dep.name) || neededByService.has(dep.name)) {
+    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) {
+            if (work.requested.includes(dep.name)) {
                 continue;
             }
-            result.set(dep.name, [...(result.get(dep.name) ?? []), task]);
+            result.set(dep.name, [...(result.get(dep.name) ?? []), item]);
         }
     }
     return result;

package/dist/planner/utils/append-work-service.js

@@ -139,7 +139,8 @@ function appendServiceInit(workTree, service, item, environment, context) {
         task.needs.push({ name: item.name, service: view });
     }
     removeRequirer(item, task.name);
-    task.data.caching = { ...task.data.caching, method: 'none' };
+    // explicit, so neither the default method nor `--cache` turns it back on
+    task.data.caching = { ...task.data.caching, method: 'none', implicit: false };
     if (task.data.timeout === null) {
         task.data.timeout = getInitTimeout(undefined, environment);
     }

package/dist/program.js

@@ -508,7 +508,7 @@ async function getProgram(environment, argv) {
             .addOption(new commander_1.Option('--dry-run', 'print the execution plan with predicted cache hits/misses without running').default(false))
             .addOption(new commander_1.Option('--cache-read-only', `restore from cache backends but never push to them (or set ${read_only_1.CACHE_READ_ONLY_ENV}=1)`).default(false))
             .addOption(new commander_1.Option('--timeout <duration>', 'fail tasks without their own timeout after this long (e.g. 10m)').argParser(units_1.parseDuration))
-            .addOption(new commander_1.Option('--no-skip-deps', 'run dependencies even when every task needing them is a cache hit'))
+            .addOption(new commander_1.Option('--no-skip-deps', 'run dependencies even when nothing needing them has to run'))
             .action(async (task, options) => {
             try {
                 // For machine-readable JSON, suppress the human progress logger (which

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