hammerkit 2.0.0-next.3 → 2.0.0-next.4

package/dist/kubernetes/ensure-persistent-data.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ensurePersistentData = exports.packSource = exports.restoreLiveFiles = exports.syncLiveFiles = exports.SYNC_FILES = exports.getStateDirsInUse = exports.REMOVE_OTHER_STATES = exports.execInPod = exports.clearClaim = exports.getPodForPersistence = void 0;
+exports.ensurePersistentData = exports.packSource = exports.clearStateFiles = exports.restoreLiveFiles = exports.syncLiveFiles = exports.SYNC_FILES = exports.getStateDirsInUse = exports.REMOVE_OTHER_STATES = exports.execInPod = exports.clearClaim = exports.getPodForPersistence = void 0;
 const volumes_1 = require("./volumes");
 const apply_1 = require("./apply");
 const path_1 = require("path");
@@ -282,6 +282,31 @@ exports.restoreLiveFiles = restoreLiveFiles;
 // Returns whether the upload is needed.
 async function prepareStateFiles(instance, env, work, pod, dir, inUse) {
     const targetPath = `/dev/hammerkit/${work.id()}`;
+    await removeOtherStates(instance, env, pod, targetPath, dir, inUse);
+    if (inUse.has(dir) && !(await execInPod(instance, env, pod, ['test', '-e', `${targetPath}/${dir}/${UPLOADED}`]))) {
+        work.status.write('info', `the files of ${work.name} are there already`);
+        return false;
+    }
+    await clearStateDir(instance, env, pod, `${targetPath}/${dir}`);
+    return true;
+}
+// what a failed upload, restore or task left: tar does not remove files the commit does not have
+async function clearStateDir(instance, env, pod, path) {
+    const cleared = await execInPod(instance, env, pod, ['rm', '-rf', path]);
+    if (cleared) {
+        throw new Error(`unable to clear ${path}: ${cleared}`);
+    }
+}
+// Before a restore of a service run into the folder `dir` of the claim of `work` (in its upload
+// pod `pod`): the folders of the other states go but those of `inUse`, which pods of the run
+// mount, and `dir` is emptied. A claim that took only restores holds one state, as after a Job.
+async function clearStateFiles(instance, env, work, pod, dir, inUse) {
+    const targetPath = `/dev/hammerkit/${work.id()}`;
+    await removeOtherStates(instance, env, pod, targetPath, dir, inUse);
+    await clearStateDir(instance, env, pod, `${targetPath}/${dir}`);
+}
+exports.clearStateFiles = clearStateFiles;
+async function removeOtherStates(instance, env, pod, targetPath, dir, inUse) {
     const removed = await execInPod(instance, env, pod, [
         'sh',
         '-c',
@@ -294,16 +319,6 @@ async function prepareStateFiles(instance, env, work, pod, dir, inUse) {
     if (removed) {
         throw new Error(`unable to remove the files of other commits in ${targetPath}: ${removed}`);
     }
-    if (inUse.has(dir) && !(await execInPod(instance, env, pod, ['test', '-e', `${targetPath}/${dir}/${UPLOADED}`]))) {
-        work.status.write('info', `the files of ${work.name} are there already`);
-        return false;
-    }
-    // what a failed upload or task left: tar does not remove files the commit does not have
-    const cleared = await execInPod(instance, env, pod, ['rm', '-rf', `${targetPath}/${dir}`]);
-    if (cleared) {
-        throw new Error(`unable to clear ${targetPath}/${dir}: ${cleared}`);
-    }
-    return true;
 }
 // The archive that uploads a source into the claim: its file or directory, at its place in
 // the claim (see getClaimSubPath) instead of under its own name

package/dist/kubernetes/kept-claims.js

@@ -99,11 +99,15 @@ async function annotate(instance, namespace, name, annotations) {
     }
 }
 // The state key of the outputs whose folder is whole in the claim of a task of a service run
-// (see getStateFilesDir), null when it names none. The run's namespace is its own, and only
-// the run writes to the claim: it forgets the state before it writes, records it after.
+// (see getStateFilesDir), null when it names none (also while the claim is being removed),
+// undefined when there is no claim. The run's namespace is its own, and only the run writes
+// to the claim: it forgets the state before it writes, records it after.
 async function rememberedClaimState(instance, kubernetes, name) {
     const claim = await readClaim(instance, kubernetes.namespace, name);
-    if (!claim || claim.metadata?.deletionTimestamp) {
+    if (!claim) {
+        return undefined;
+    }
+    if (claim.metadata?.deletionTimestamp) {
         return null;
     }
     return claim.metadata?.annotations?.[exports.STATE_ANNOTATION] ?? null;

package/dist/kubernetes/restore-kubernetes-data.js

@@ -16,7 +16,9 @@ stateDir) {
 exports.getRestoreTarget = getRestoreTarget;
 async function restoreKubernetesData(work, kubernetes, instance, environment, path, 
 // the kept claim of the work holds what an earlier run left, which goes first; on a
-// service run, the outputs go into the folder of `stateKey` (see getStateFilesDir)
+// service run, the outputs go into the folder of `stateKey` (see getStateFilesDir);
+// `otherStates`: the folders of the other states go but these (the ones pods of the run
+// mount), and the folder of `stateKey` is emptied first
 options = {}) {
     const persistence = await (0, volumes_1.getKubernetesPersistence)(work, kubernetes, options.stateKey);
     const stateDir = kubernetes.server?.serviceRun ? (0, volumes_1.getItemFilesDir)(work, options.stateKey) : undefined;
@@ -24,6 +26,9 @@ options = {}) {
         if (options.reset) {
             await (0, ensure_persistent_data_1.clearClaim)(instance, kubernetes, work, name);
         }
+        if (stateDir && options.otherStates) {
+            await (0, ensure_persistent_data_1.clearStateFiles)(instance, kubernetes, work, name, stateDir, options.otherStates);
+        }
         for (const generatedArchive of (0, event_cache_1.getArchivePaths)(work.data, path)) {
             if (!(await environment.file.exists(generatedArchive.filename))) {
                 continue;

package/dist/planner/work-runtime-kubernetes.js

@@ -190,8 +190,13 @@ function kubernetesTaskRuntime(task, kubernetes) {
             }
             if (remembers && !kept) {
                 // the folder of the state is written now: until it is whole, the claim names no state
+                // (a restore without a state key says none, and the next run uploads again)
                 await (0, kept_claims_1.forgetClaimState)(instance, kubernetes, claim);
-                await (0, restore_kubernetes_data_1.restoreKubernetesData)(task, kubernetes, instance, environment, path, { stateKey });
+                await (0, restore_kubernetes_data_1.restoreKubernetesData)(task, kubernetes, instance, environment, path, {
+                    stateKey,
+                    // the folders of other states no pod of the run mounts go, as before a Job
+                    ...(stateKey ? { otherStates: await (0, ensure_persistent_data_1.getStateDirsInUse)(instance, kubernetes.namespace, claim) } : {}),
+                });
                 if (stateKey) {
                     await (0, kept_claims_1.recordClaimState)(instance, kubernetes, claim, stateKey);
                 }
@@ -488,9 +493,11 @@ function kubernetesTaskRuntime(task, kubernetes) {
                 return (0, kept_claims_1.useClaimState)(instance, kubernetes, claim);
             }
             if (remembers) {
-                // a service run that sleeps loses its Jobs but keeps its claims, the claim says
+                // a service run that sleeps loses its Jobs but keeps its claims, the claim says. One
+                // that names no state is being written (or was, and that failed): the folder of the
+                // state of an earlier Job may be gone. Only a task without a claim goes by its Jobs.
                 const remembered = await (0, kept_claims_1.rememberedClaimState)(instance, kubernetes, claim);
-                if (remembered) {
+                if (remembered !== undefined) {
                     return remembered;
                 }
             }

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": "2.0.0-next.3",
+  "version": "2.0.0-next.4",
   "keywords": [
     "build",
     "build-tool",