hammerkit 1.5.1 → 1.6.0-alpha.2

package/dist/executer/docker-service.js

@@ -9,105 +9,129 @@ const log_1 = require("../log");
 const remove_container_1 = require("../docker/remove-container");
 const check_readiness_1 = require("./check-readiness");
 const execution_steps_1 = require("./execution-steps");
-function dockerService(service, stateKey, state, environment) {
-    return async (abort) => {
-        const status = environment.status.service(service);
-        let container = null;
-        await (0, execution_steps_1.prepareMounts)(service, environment);
-        (0, abort_1.checkForAbort)(abort.signal);
-        await (0, execution_steps_1.pullImage)(service, environment);
-        (0, abort_1.checkForAbort)(abort.signal);
-        await (0, execution_steps_1.prepareVolume)(service, environment);
-        (0, abort_1.checkForAbort)(abort.signal);
-        try {
-            (0, abort_1.checkForAbort)(abort.signal);
-            status.write('debug', `create container with image ${service.image}`);
-            container = await environment.docker.createContainer({
-                Image: service.image,
-                Env: Object.keys(service.envs).map((k) => `${k}=${service.envs[k]}`),
-                Labels: { app: 'hammerkit', 'hammerkit-id': service.id, 'hammerkit-type': 'service' },
-                ExposedPorts: service.ports.reduce((map, port) => {
-                    map[`${port.containerPort}/tcp`] = {};
+const docker_task_1 = require("./docker-task");
+const replace_env_variables_1 = require("../environment/replace-env-variables");
+const get_service_containers_1 = require("./get-service-containers");
+async function dockerService(docker, item, options, environment) {
+    let container = null;
+    try {
+        await (0, execution_steps_1.prepareMounts)(item, environment);
+        (0, abort_1.checkForAbort)(options.abort);
+        await (0, execution_steps_1.pullImage)(item, docker);
+        (0, abort_1.checkForAbort)(options.abort);
+        await (0, execution_steps_1.prepareVolume)(item, docker);
+        (0, abort_1.checkForAbort)(options.abort);
+        const serviceContainers = (0, get_service_containers_1.getServiceContainers)(item.needs);
+        const network = (0, docker_task_1.getNeedsNetwork)(serviceContainers, item.needs);
+        item.status.write('debug', `create container with image ${item.data.image}`);
+        const envs = (0, replace_env_variables_1.getEnvironmentVariables)(item.data.envs);
+        container = await docker.createContainer({
+            Image: item.data.image,
+            Env: Object.keys(envs).map((k) => `${k}=${envs[k]}`),
+            Labels: {
+                app: 'hammerkit',
+                'hammerkit-id': item.id(),
+                'hammerkit-pid': process.pid.toString(),
+                'hammerkit-type': 'service',
+                'hammerkit-state': options.stateKey,
+            },
+            ExposedPorts: item.data.ports.reduce((map, port) => {
+                map[`${port.containerPort}/tcp`] = {};
+                return map;
+            }, {}),
+            Cmd: item.data.cmd ? [item.data.cmd.parsed.command, ...item.data.cmd.parsed.args] : undefined,
+            WorkingDir: item.data.cwd ? (0, execute_docker_1.convertToPosixPath)(item.data.cwd) : undefined,
+            HostConfig: {
+                ExtraHosts: network.hosts,
+                Links: network.links,
+                Binds: [
+                    ...item.data.src.map((s) => `${s.absolutePath}:${s.absolutePath}`),
+                    ...item.data.mounts.map((v) => `${v.localPath}:${(0, execute_docker_1.convertToPosixPath)(v.containerPath)}`),
+                    ...item.data.volumes.map((v) => `${v.name}:${(0, execute_docker_1.convertToPosixPath)(v.containerPath)}`),
+                ],
+                PortBindings: item.data.ports
+                    .filter((p) => !!p.hostPort)
+                    .reduce((map, port) => {
+                    map[`${port.containerPort}/tcp`] = [{ HostPort: `${port.hostPort}` }];
                     return map;
                 }, {}),
-                Cmd: service.cmd ? service.cmd.split(' ') : undefined,
-                HostConfig: {
-                    Binds: [
-                        ...service.mounts.map((v) => `${v.localPath}:${(0, execute_docker_1.convertToPosixPath)(v.containerPath)}`),
-                        ...service.volumes.map((v) => `${v.name}:${(0, execute_docker_1.convertToPosixPath)(v.containerPath)}`),
-                    ],
-                    PortBindings: service.ports.reduce((map, port) => {
-                        map[`${port.containerPort}/tcp`] = [{ HostPort: `${port.hostPort}` }];
-                        return map;
-                    }, {}),
-                },
+            },
+        });
+        const stream = await container.attach({ stream: true, stdout: true, stderr: true });
+        (0, stream_1.logStream)(item.status, stream);
+        await container.start();
+        if (!item.data.healthcheck) {
+            options.state.set({
+                type: 'running',
+                dns: { containerId: container.id },
+                stateKey: options.stateKey,
+                remote: null,
             });
-            const stream = await container.attach({ stream: true, stdout: true, stderr: true });
-            (0, stream_1.logStream)(status, stream);
-            await container.start();
-            //await setUserPermissions(service, container, environment)
-            if (!service.healthcheck) {
-                state.patchService({
+        }
+        else {
+            let ready = false;
+            do {
+                ready = await (0, check_readiness_1.checkReadiness)(item.status, item.data.healthcheck, environment, container, options.abort);
+                if (!ready) {
+                    await new Promise((resolve) => setTimeout(() => resolve(), 1000));
+                }
+            } while (!ready && !options.abort.aborted);
+            if (ready) {
+                options.state.set({
                     type: 'running',
-                    service,
                     dns: { containerId: container.id },
-                    stateKey,
+                    stateKey: options.stateKey,
+                    remote: null,
                 });
             }
-            else {
-                let ready = false;
-                do {
-                    ready = await (0, check_readiness_1.checkReadiness)(status, service.healthcheck, environment, container, abort.signal);
-                    if (!ready) {
-                        await new Promise((resolve) => setTimeout(() => resolve(), 1000));
-                    }
-                } while (!ready && !abort.signal.aborted);
-                if (ready) {
-                    state.patchService({
-                        type: 'running',
-                        service,
-                        dns: { containerId: container.id },
-                        stateKey,
-                    });
-                }
-            }
-            await (0, abort_event_1.waitOnAbort)(abort.signal);
-            state.patchService({
+        }
+        if (!options.daemon) {
+            const reason = await new Promise((resolve) => {
+                const abortHandle = (0, abort_event_1.listenOnAbort)(options.abort, () => resolve('terminated'));
+                container
+                    .wait()
+                    .then(() => {
+                    abortHandle.close();
+                    resolve('crash');
+                })
+                    .catch(() => {
+                    abortHandle.close();
+                    resolve('crash');
+                });
+            });
+            options.state.set({
                 type: 'end',
-                service,
-                stateKey,
-                reason: 'terminated',
+                stateKey: options.stateKey,
+                reason,
             });
         }
-        catch (e) {
-            if (e instanceof abort_1.AbortError) {
-                state.patchService({
-                    type: 'canceled',
-                    service,
-                    stateKey,
-                });
-            }
-            else {
-                status.write('error', (0, log_1.getErrorMessage)(e));
-                state.patchService({
-                    type: 'end',
-                    service,
-                    reason: 'crash',
-                    stateKey,
-                });
-            }
+    }
+    catch (e) {
+        if (e instanceof abort_1.AbortError) {
+            options.state.set({
+                type: 'canceled',
+                stateKey: options.stateKey,
+            });
         }
-        finally {
-            if (container) {
-                try {
-                    await (0, remove_container_1.removeContainer)(container);
-                }
-                catch (e) {
-                    status.write('error', `remove of container failed ${(0, log_1.getErrorMessage)(e)}`);
-                }
+        else {
+            item.status.write('error', (0, log_1.getErrorMessage)(e));
+            options.state.set({
+                type: 'end',
+                reason: 'crash',
+                stateKey: options.stateKey,
+            });
+        }
+    }
+    finally {
+        if (container && !options.daemon) {
+            try {
+                await (0, remove_container_1.removeContainer)(container);
+            }
+            catch (e) {
+                item.status.write('error', `remove of container failed ${(0, log_1.getErrorMessage)(e)}`);
             }
         }
-    };
+    }
 }
 exports.dockerService = dockerService;
 //# sourceMappingURL=docker-service.js.map

package/dist/executer/docker-task.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dockerTask = exports.getNeedsNetwork = void 0;
+const service_dns_1 = require("./service-dns");
+const execute_docker_1 = require("./execute-docker");
+const abort_1 = require("./abort");
+const log_1 = require("../log");
+const execution_steps_1 = require("./execution-steps");
+const using_container_1 = require("../docker/using-container");
+const print_container_options_1 = require("./print-container-options");
+const tar_1 = require("tar");
+const replace_env_variables_1 = require("../environment/replace-env-variables");
+const get_container_binds_1 = require("./get-container-binds");
+const get_service_containers_1 = require("./get-service-containers");
+function getNeedsNetwork(serviceContainers, needs) {
+    const links = [];
+    const hosts = [];
+    for (const need of needs) {
+        const dns = serviceContainers[need.name];
+        if ((0, service_dns_1.isHostServiceDns)(dns)) {
+            hosts.push(`${need.name}:${dns.host}`);
+        }
+        else {
+            if (!dns.containerId) {
+                throw new Error(`service ${need.name} is not running`);
+            }
+            links.push(`${dns.containerId}:${need.name}`);
+        }
+    }
+    return { links, hosts };
+}
+exports.getNeedsNetwork = getNeedsNetwork;
+function buildCreateOptions(item, stateKey, serviceContainers, environment) {
+    const network = getNeedsNetwork(serviceContainers, item.needs);
+    const binds = (0, get_container_binds_1.getContainerBinds)(item);
+    const envs = (0, replace_env_variables_1.getEnvironmentVariables)(item.data.envs);
+    return {
+        abortSignal: environment.abortCtrl.signal,
+        Image: item.data.image,
+        Tty: true,
+        Entrypoint: [item.data.shell],
+        Cmd: ['-c', 'sleep 3600'],
+        Env: Object.entries(envs).map(([key, value]) => `${key}=${value}`),
+        WorkingDir: (0, execute_docker_1.convertToPosixPath)(item.data.cwd),
+        Labels: {
+            app: 'hammerkit',
+            'hammerkit-id': item.id(),
+            'hammerkit-pid': process.pid.toString(),
+            'hammerkit-type': 'task',
+            'hammerkit-state': stateKey,
+        },
+        HostConfig: {
+            Binds: binds.map((b) => `${b.localPath}:${(0, execute_docker_1.convertToPosixPath)(b.containerPath)}`),
+            ExtraHosts: network.hosts,
+            Links: network.links,
+            AutoRemove: true,
+        },
+    };
+}
+async function dockerTask(docker, item, environment, options) {
+    item.status.write('info', `execute ${item.name} in container`);
+    try {
+        await (0, execution_steps_1.prepareMounts)(item, environment);
+        (0, abort_1.checkForAbort)(options.abort);
+        await (0, execution_steps_1.pullImage)(item, docker);
+        (0, abort_1.checkForAbort)(options.abort);
+        await (0, execution_steps_1.prepareVolume)(item, docker);
+        (0, abort_1.checkForAbort)(options.abort);
+        const serviceContainers = (0, get_service_containers_1.getServiceContainers)(item.needs);
+        const containerOptions = buildCreateOptions(item, options.stateKey, serviceContainers, environment);
+        (0, print_container_options_1.printContainerOptions)(item.status, containerOptions);
+        await (0, using_container_1.usingContainer)(docker, item, containerOptions, options.stateKey, async (container) => {
+            await (0, execution_steps_1.setUserPermissions)(item, container, environment);
+            for (const cmd of item.data.cmds) {
+                (0, abort_1.checkForAbort)(options.abort);
+                item.status.write('info', `execute cmd "${cmd.cmd}" in container`);
+                const result = await (0, execute_docker_1.execCommand)(item.status, environment, container, (0, execute_docker_1.convertToPosixPath)(cmd.cwd), [item.data.shell, '-c', cmd.cmd], item.data.user, undefined, options.abort);
+                if (result.type === 'timeout') {
+                    throw new Error(`command ${cmd.cmd} timed out`);
+                }
+                if (result.type === 'canceled') {
+                    throw new abort_1.AbortError();
+                }
+                if (result.result.ExitCode !== 0) {
+                    options.state.set({
+                        stateKey: options.stateKey,
+                        type: 'crash',
+                        exitCode: result.result.ExitCode ?? 1,
+                    });
+                    return false;
+                }
+            }
+            for (const generate of item.data.generates) {
+                if (!generate.export || generate.inherited || generate.isFile) {
+                    continue;
+                }
+                const readable = await container.getArchive({
+                    path: generate.path,
+                });
+                await environment.file.createDirectory(generate.path);
+                await new Promise((resolve, reject) => {
+                    readable
+                        .pipe((0, tar_1.extract)({
+                        cwd: generate.path,
+                        newer: true,
+                        stripComponents: 1,
+                    }))
+                        .on('close', () => resolve())
+                        .on('error', (err) => reject(err));
+                });
+            }
+            return true;
+        });
+    }
+    catch (e) {
+        if (e instanceof abort_1.AbortError) {
+            options.state.set({
+                stateKey: options.stateKey,
+                type: 'canceled',
+            });
+        }
+        else {
+            options.state.set({
+                stateKey: options.stateKey,
+                type: 'error',
+                errorMessage: (0, log_1.getErrorMessage)(e),
+            });
+        }
+    }
+}
+exports.dockerTask = dockerTask;
+//# sourceMappingURL=docker-task.js.map

package/dist/executer/environment-mock.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.environmentMock = void 0;
-const work_node_status_1 = require("../planner/work-node-status");
+const work_item_status_1 = require("../planner/work-item-status");
 const get_file_context_1 = require("../file/get-file-context");
-const execute_docker_1 = require("./execute-docker");
 const log_1 = require("../log");
 const empty_writable_1 = require("../utils/empty-writable");
 function environmentMock(cwd) {
@@ -13,9 +12,9 @@ function environmentMock(cwd) {
         console: (0, log_1.consoleContext)((0, empty_writable_1.emptyWritable)()),
         abortCtrl: new AbortController(),
         processEnvs: {},
-        status: (0, work_node_status_1.statusConsole)((0, empty_writable_1.emptyWritable)()),
-        docker: (0, execute_docker_1.getContainerCli)(),
+        status: (0, work_item_status_1.statusConsole)((0, empty_writable_1.emptyWritable)()),
         stdout: (0, empty_writable_1.emptyWritable)(),
+        stderr: (0, empty_writable_1.emptyWritable)(),
         stdoutColumns: 80,
     };
 }

package/dist/executer/environment-mock.spec.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const environment_mock_1 = require("./environment-mock");
+describe('environmentMock', () => {
+    it('returns an Environment with the given cwd and silent streams', () => {
+        const env = (0, environment_mock_1.environmentMock)('/tmp/x');
+        expect(env.cwd).toBe('/tmp/x');
+        expect(env.file).toBeDefined();
+        expect(env.console).toBeDefined();
+        expect(env.status).toBeDefined();
+        expect(env.stdout).toBeDefined();
+        expect(env.stderr).toBeDefined();
+        expect(env.abortCtrl).toBeInstanceOf(AbortController);
+        expect(env.processEnvs).toEqual({});
+        expect(env.stdoutColumns).toBe(80);
+        // writing to silent streams must not throw
+        env.stdout.write('hello\n');
+        env.stderr.write('world\n');
+        env.console.info('info');
+    });
+});
+//# sourceMappingURL=environment-mock.spec.js.map

package/dist/executer/event-cache.js

@@ -1,159 +1,92 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.cleanCache = exports.storeCache = exports.restoreCache = void 0;
-const plan_work_nodes_1 = require("../planner/utils/plan-work-nodes");
+exports.cleanCache = exports.storeCache = exports.getArchivePaths = exports.restoreCache = void 0;
+const plan_work_tasks_1 = require("../planner/utils/plan-work-tasks");
 const get_cache_directory_1 = require("../optimizer/get-cache-directory");
 const path_1 = require("path");
 const move_files_1 = require("../file/move-files");
-const execute_docker_1 = require("./execute-docker");
-const get_docker_executor_1 = require("./get-docker-executor");
-const tar_1 = require("tar");
-const work_node_1 = require("../planner/work-node");
-const using_container_1 = require("../docker/using-container");
-const work_service_1 = require("../planner/work-service");
-const plan_work_volume_1 = require("../planner/utils/plan-work-volume");
-async function restoreCache(path, workTree, environment) {
-    for (const node of (0, plan_work_nodes_1.iterateWorkNodes)(workTree.nodes)) {
-        const cachePath = (0, get_cache_directory_1.getCacheDirectory)(node.id);
-        const sourceCacheDir = (0, path_1.join)(path, node.id);
-        await (0, move_files_1.moveFiles)(node, environment, function* () {
+async function restoreCache(environment, path, workTree) {
+    for (const task of (0, plan_work_tasks_1.iterateWorkTasks)(workTree)) {
+        const cachePath = (0, get_cache_directory_1.getCacheDirectory)(task.id());
+        const sourceCacheDir = (0, path_1.join)(path, task.id());
+        // TODO move into local runtime
+        await (0, move_files_1.moveFiles)(task, environment, function* () {
             yield { from: (0, path_1.join)(sourceCacheDir, 'stats.json'), to: (0, path_1.join)(cachePath, 'stats.json') };
             yield { from: (0, path_1.join)(sourceCacheDir, 'description.json'), to: (0, path_1.join)(cachePath, 'description.json') };
         });
-        if ((0, work_node_1.isContainerWorkNode)(node)) {
-            await restoreContainer(environment, node, sourceCacheDir);
-        }
-        else {
-            await restoreLocal(environment, node, sourceCacheDir);
-        }
+        await task.runtime.restore(environment, sourceCacheDir);
+    }
+    for (const service of (0, plan_work_tasks_1.iterateWorkServices)(workTree)) {
+        const cachePath = (0, get_cache_directory_1.getCacheDirectory)(service.id());
+        const sourceCacheDir = (0, path_1.join)(path, service.id());
+        // TODO move into local runtime
+        await (0, move_files_1.moveFiles)(service, environment, function* () {
+            yield { from: (0, path_1.join)(sourceCacheDir, 'stats.json'), to: (0, path_1.join)(cachePath, 'stats.json') };
+            yield { from: (0, path_1.join)(sourceCacheDir, 'description.json'), to: (0, path_1.join)(cachePath, 'description.json') };
+        });
+        await service.runtime.restore(environment, sourceCacheDir);
     }
 }
 exports.restoreCache = restoreCache;
-async function restoreLocal(environment, node, path) {
-    for (const generate of getGenerates(node, path)) {
-        if (await environment.file.exists(generate.filename)) {
-            await (0, tar_1.extract)({
-                file: generate.filename,
-                cwd: node.cwd,
-            });
+function* getArchivePaths(task, path) {
+    if (task.type === 'container-service') {
+        for (const volume of task.volumes.filter((v) => !v.inherited)) {
+            yield {
+                filename: (0, path_1.join)(path, volume.name + '-volume.tgz'),
+                path: volume.containerPath,
+            };
         }
     }
-}
-async function restoreContainer(environment, node, path) {
-    await (0, using_container_1.usingContainer)(environment, node, {
-        Image: node.image,
-        Tty: true,
-        Entrypoint: 'sh',
-        Cmd: ['-c', 'sleep 3600'],
-        WorkingDir: (0, execute_docker_1.convertToPosixPath)(node.cwd),
-        Labels: { app: 'hammerkit', 'hammerkit-id': node.id, 'hammerkit-type': 'task' },
-        HostConfig: {
-            AutoRemove: true,
-            Binds: [...node.volumes.map((v) => `${v.name}:${(0, execute_docker_1.convertToPosixPath)(v.containerPath)}`)],
-        },
-    }, async (container) => {
-        for (const generate of getGenerates(node, path)) {
-            if (await environment.file.exists(generate.filename)) {
-                await container.putArchive(environment.file.readStream(generate.filename), {
-                    path: (0, path_1.dirname)(generate.path),
-                });
-            }
+    else {
+        for (const generate of task.generates.filter((g) => !g.inherited)) {
+            const generateId = (0, path_1.relative)(task.cwd, generate.path).split(path_1.sep).join('-');
+            yield {
+                filename: (0, path_1.join)(path, generateId + '-generates.tgz'),
+                path: generate.path,
+            };
         }
-    });
-}
-function* getGenerates(node, path) {
-    const generates = node.generates.filter((g) => !g.inherited);
-    for (const generate of generates) {
-        const generateId = (0, path_1.relative)(node.cwd, generate.path).split(path_1.sep).join('-');
-        yield {
-            filename: (0, path_1.join)(path, generateId + '-generates.tgz'),
-            path: generate.path,
-        };
     }
 }
-async function archiveContainer(environment, node, path) {
-    await (0, using_container_1.usingContainer)(environment, node, {
-        Image: node.image,
-        Tty: true,
-        Entrypoint: 'sh',
-        Cmd: ['-c', 'sleep 3600'],
-        WorkingDir: (0, execute_docker_1.convertToPosixPath)(node.cwd),
-        Labels: { app: 'hammerkit', 'hammerkit-id': node.id, 'hammerkit-type': 'task' },
-        HostConfig: {
-            AutoRemove: true,
-            Binds: [...node.volumes.map((v) => `${v.name}:${(0, execute_docker_1.convertToPosixPath)(v.containerPath)}`)],
-        },
-    }, async (container) => {
-        for (const generatedArchive of getGenerates(node, path)) {
-            const readable = await container.getArchive({
-                path: generatedArchive.path,
-            });
-            await environment.file.writeStream(generatedArchive.filename, readable);
-        }
-    });
-}
-async function archiveLocal(environment, node, path) {
-    for (const generatedArchive of getGenerates(node, path)) {
-        await environment.file.writeStream(generatedArchive.filename, (0, tar_1.create)({
-            cwd: node.cwd,
-            gzip: true,
-        }, [(0, path_1.relative)(node.cwd, generatedArchive.path)]));
+exports.getArchivePaths = getArchivePaths;
+async function storeCache(environment, path, workTree) {
+    for (const task of (0, plan_work_tasks_1.iterateWorkTasks)(workTree)) {
+        const cachePath = (0, get_cache_directory_1.getCacheDirectory)(task.id());
+        const sourceCacheDir = (0, path_1.join)(path, task.id());
+        await (0, move_files_1.moveFiles)(task, environment, function* () {
+            yield { from: (0, path_1.join)(cachePath, 'stats.json'), to: (0, path_1.join)(sourceCacheDir, 'stats.json') };
+            yield { from: (0, path_1.join)(cachePath, 'description.json'), to: (0, path_1.join)(sourceCacheDir, 'description.json') };
+        });
+        await environment.file.createDirectory(sourceCacheDir);
+        await task.runtime.archive(environment, sourceCacheDir);
     }
-}
-async function storeCache(path, workTree, environment) {
-    for (const node of (0, plan_work_nodes_1.iterateWorkNodes)(workTree.nodes)) {
-        const cachePath = (0, get_cache_directory_1.getCacheDirectory)(node.id);
-        const sourceCacheDir = (0, path_1.join)(path, node.id);
-        await (0, move_files_1.moveFiles)(node, environment, function* () {
+    for (const service of (0, plan_work_tasks_1.iterateWorkServices)(workTree)) {
+        const cachePath = (0, get_cache_directory_1.getCacheDirectory)(service.id());
+        const sourceCacheDir = (0, path_1.join)(path, service.id());
+        await (0, move_files_1.moveFiles)(service, environment, function* () {
             yield { from: (0, path_1.join)(cachePath, 'stats.json'), to: (0, path_1.join)(sourceCacheDir, 'stats.json') };
             yield { from: (0, path_1.join)(cachePath, 'description.json'), to: (0, path_1.join)(sourceCacheDir, 'description.json') };
         });
-        if ((0, work_node_1.isContainerWorkNode)(node)) {
-            await archiveContainer(environment, node, sourceCacheDir);
-        }
-        else {
-            await archiveLocal(environment, node, sourceCacheDir);
-        }
+        await environment.file.createDirectory(sourceCacheDir);
+        await service.runtime.archive(environment, sourceCacheDir);
     }
 }
 exports.storeCache = storeCache;
 async function cleanCache(workTree, environment, options) {
-    for (const node of (0, plan_work_nodes_1.iterateWorkNodes)(workTree.nodes)) {
-        const nodeStatus = environment.status.task(node);
-        for (const generate of node.generates) {
-            if (generate.inherited) {
-                continue;
-            }
-            const volumeName = (0, plan_work_volume_1.getVolumeName)(generate.path);
-            const volumeExists = await (0, get_docker_executor_1.existsVolume)(environment, volumeName);
-            if (volumeExists) {
-                await (0, get_docker_executor_1.removeVolume)(environment, nodeStatus, volumeName);
-            }
-            else {
-                nodeStatus.write('info', `generate ${generate} has no volume ${volumeName}`);
-            }
-            nodeStatus.write('info', `remove local directory ${generate.path}`);
-            await environment.file.remove(generate.path);
+    for (const task of (0, plan_work_tasks_1.iterateWorkTasks)(workTree)) {
+        await task.runtime.remove(environment);
+        if (options?.cache) {
+            await task.data.caching.backend.clear(task.id(), environment);
         }
-        const cachePath = (0, get_cache_directory_1.getCacheDirectory)(node.id);
+        const cachePath = (0, get_cache_directory_1.getCacheDirectory)(task.id());
         if (await environment.file.exists(cachePath)) {
-            nodeStatus.write('info', `remove cache ${cachePath}`);
+            task.status.write('info', `remove cache ${cachePath}`);
             await environment.file.remove(cachePath);
         }
     }
-    if (options.service) {
-        for (const service of (0, plan_work_nodes_1.iterateWorkServices)(workTree.services)) {
-            if (!(0, work_service_1.isContainerWorkService)(service)) {
-                continue;
-            }
-            const nodeStatus = environment.status.service(service);
-            for (const volume of service.volumes) {
-                const volumeExists = await (0, get_docker_executor_1.existsVolume)(environment, volume.name);
-                if (!volumeExists) {
-                    continue;
-                }
-                await (0, get_docker_executor_1.removeVolume)(environment, nodeStatus, volume.name);
-            }
+    for (const service of (0, plan_work_tasks_1.iterateWorkServices)(workTree)) {
+        await service.runtime.remove(environment);
+        if (options?.cache) {
+            await service.data.caching.backend.clear(service.id(), environment);
         }
     }
 }

package/dist/executer/execute-command.js

@@ -6,10 +6,10 @@ const os_1 = require("os");
 const log_1 = require("../log");
 const abort_1 = require("./abort");
 const abort_event_1 = require("../utils/abort-event");
-async function executeCommand(status, abortSignal, cwd, command, envs) {
+async function executeCommand(status, abortSignal, cwd, command, envs, environment) {
     return new Promise((resolve, reject) => {
         const ps = (0, child_process_1.exec)(command, {
-            env: envs,
+            env: { ...envs, PATH: environment.processEnvs['PATH'] },
             cwd,
             shell: (0, os_1.platform)() === 'win32' ? 'powershell.exe' : undefined,
         });
@@ -27,13 +27,14 @@ async function executeCommand(status, abortSignal, cwd, command, envs) {
             reject(err);
         });
         ps.on('close', (code) => {
+            abortListener.close();
             if (abortSignal.aborted) {
                 reject(new abort_1.AbortError());
                 return;
             }
             resolve(code ?? 0);
         });
-        (0, abort_event_1.listenOnAbort)(abortSignal, () => {
+        const abortListener = (0, abort_event_1.listenOnAbort)(abortSignal, () => {
             ps.kill();
         });
     });