hammerkit 1.4.0 → 1.5.0-alpha.1

package/dist/executer/execute-docker.js

@@ -3,87 +3,25 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.pollStatus = exports.execCommand = exports.executeDocker = exports.checkIfAbort = exports.startContainer = exports.getDocker = exports.getContainerMounts = exports.getContainerVolumes = exports.getVolumeName = exports.generateId = void 0;
+exports.execCommand = exports.convertToPosixPath = exports.startContainer = exports.getContainerCli = void 0;
 const stream_1 = require("../docker/stream");
 const dockerode_1 = __importDefault(require("dockerode"));
-const pull_1 = require("../docker/pull");
 const path_1 = require("path");
 const os_1 = require("os");
-const template_value_1 = require("../planner/utils/template-value");
-const crypto_1 = require("crypto");
-const get_docker_executor_1 = require("./get-docker-executor");
 const abort_event_1 = require("../utils/abort-event");
-function generateId(generate) {
-    return crypto_1.createHash('sha1').update(generate).digest('hex');
-}
-exports.generateId = generateId;
-function getVolumeName(generate) {
-    return `hammerkit-${generateId(generate)}`;
-}
-exports.getVolumeName = getVolumeName;
-async function getContainerVolumes(node) {
-    const volumes = [];
-    for (const generate of node.generates) {
-        const name = getVolumeName(generate.path);
-        volumes.push({
-            name,
-            containerPath: generate.path,
-        });
-    }
-    return volumes;
-}
-exports.getContainerVolumes = getContainerVolumes;
-async function getContainerMounts(node, context) {
-    const result = [];
-    for (const source of node.src) {
-        const exists = await context.file.exists(source.absolutePath);
-        if (exists) {
-            result.push({
-                localPath: source.absolutePath,
-                containerPath: source.absolutePath,
-            });
-        }
-        else {
-            if (path_1.extname(source.absolutePath)) {
-                await context.file.writeFile(source.absolutePath, '');
-            }
-            else {
-                await context.file.createDirectory(source.absolutePath);
-                result.push({
-                    localPath: source.absolutePath,
-                    containerPath: source.absolutePath,
-                });
-            }
-        }
-    }
-    for (const mount of node.mounts) {
-        result.push(mount);
-    }
-    for (const volume of result) {
-        const otherVolumes = result.filter((v) => v.containerPath === volume.containerPath && v.localPath !== volume.localPath);
-        if (otherVolumes.length > 0) {
-            throw new Error(`duplicate container mount with different sources ${[
-                volume.localPath,
-                ...otherVolumes.map((ov) => ov.localPath),
-            ].join(', ')}`);
-        }
-    }
-    return result.filter((v, i) => result.findIndex((iv) => iv.containerPath == v.containerPath) === i);
-}
-exports.getContainerMounts = getContainerMounts;
 let dockerInstance = null;
-function getDocker() {
+function getContainerCli() {
     if (!dockerInstance) {
         dockerInstance = new dockerode_1.default();
     }
     return dockerInstance;
 }
-exports.getDocker = getDocker;
-async function startContainer(node, container) {
+exports.getContainerCli = getContainerCli;
+async function startContainer(status, container) {
     return new Promise((resolve, reject) => {
         const handle = setTimeout(() => {
-            node.status.console.write('internal', 'warn', 'start of container is potentially stuck on start');
-        }, 1000);
+            status.write('warn', 'start of container is potentially stuck on start');
+        }, 3000);
         container
             .start()
             .then(() => {
@@ -92,13 +30,28 @@ async function startContainer(node, container) {
         })
             .catch((e) => {
             clearTimeout(handle);
-            reject(e);
+            if ('json' in e && 'message' in e.json) {
+                const errorMessage = e.json.message;
+                const portBlocked = /Bind for .*:\d+ failed: port is already allocated/.exec(errorMessage);
+                if (portBlocked) {
+                    reject(new Error(portBlocked[0]));
+                }
+                else {
+                    reject(new Error(errorMessage));
+                }
+            }
+            else if ('json' in e && e.json instanceof Buffer) {
+                reject(new Error(e.json.toString()));
+            }
+            else {
+                reject(e);
+            }
         });
     });
 }
 exports.startContainer = startContainer;
 function convertToPosixPath(path) {
-    if (os_1.platform() === 'win32') {
+    if ((0, os_1.platform)() === 'win32') {
         return path
             .split(path_1.sep)
             .map((value, index) => (index === 0 && value.endsWith(':') ? '/' + value.substr(0, value.length - 1) : value))
@@ -106,111 +59,8 @@ function convertToPosixPath(path) {
     }
     return path;
 }
-function checkIfAbort(cancelDefer) {
-    if (cancelDefer.signal.aborted) {
-        throw new Error('canceled');
-    }
-}
-exports.checkIfAbort = checkIfAbort;
-async function executeDocker(node, context, cancelDefer) {
-    node.status.console.write('internal', 'debug', `execute ${node.name} as docker task`);
-    const docker = getDocker();
-    const volumes = await getContainerVolumes(node);
-    const mounts = await getContainerMounts(node, context.environment);
-    checkIfAbort(cancelDefer);
-    await pull_1.pull(node, docker, node.image);
-    checkIfAbort(cancelDefer);
-    for (const volume of volumes) {
-        await get_docker_executor_1.ensureVolumeExists(docker, volume.name);
-    }
-    checkIfAbort(cancelDefer);
-    node.status.console.write('internal', 'debug', `create container with image ${node.image} with ${node.shell}`);
-    const container = await docker.createContainer({
-        Image: node.image,
-        Tty: true,
-        Entrypoint: node.shell,
-        Env: Object.keys(node.envs).map((k) => `${k}=${node.envs[k]}`),
-        WorkingDir: convertToPosixPath(node.cwd),
-        Labels: { app: 'hammerkit' },
-        HostConfig: {
-            Binds: [
-                ...mounts.map((v) => `${v.localPath}:${convertToPosixPath(v.containerPath)}`),
-                ...volumes.map((v) => `${v.name}:${convertToPosixPath(v.containerPath)}`),
-            ],
-            PortBindings: node.ports.reduce((map, port) => {
-                map[`${port.containerPort}/tcp`] = [{ HostPort: `${port.hostPort}` }];
-                return map;
-            }, {}),
-            AutoRemove: true,
-        },
-        ExposedPorts: node.ports.reduce((map, port) => {
-            map[`${port.containerPort}/tcp`] = {};
-            return map;
-        }, {}),
-    });
-    abort_event_1.listenOnAbort(cancelDefer.signal, () => {
-        container.remove({ force: true }).catch((e) => {
-            if (e.statusCode !== 404) {
-                node.status.console.write('internal', 'debug', `remove of container failed ${e.message}`);
-            }
-        });
-    });
-    const user = os_1.platform() === 'linux' || os_1.platform() === 'freebsd' || os_1.platform() === 'openbsd' || os_1.platform() === 'sunos'
-        ? `${process.getuid()}:${process.getgid()}`
-        : undefined;
-    try {
-        for (const mount of mounts) {
-            node.status.console.write('internal', 'debug', `bind mount ${mount.localPath}:${mount.containerPath}`);
-        }
-        for (const volume of volumes) {
-            node.status.console.write('internal', 'debug', `volume mount ${volume.name}:${volume.containerPath}`);
-        }
-        node.status.console.write('internal', 'info', `starting container with image ${node.image}`);
-        await startContainer(node, container);
-        if (user) {
-            const setUserPermission = async (directory) => {
-                node.status.console.write('internal', 'debug', 'set permission on ' + directory);
-                const result = await execCommand(node, docker, container, '/', ['chown', user, directory], undefined);
-                if (!result || result.ExitCode !== 0) {
-                    node.status.console.write('internal', 'warn', `unable to set permissions for ${directory}`);
-                }
-            };
-            await setUserPermission(node.cwd);
-            for (const volume of volumes) {
-                await setUserPermission(volume.containerPath);
-            }
-            for (const mount of mounts) {
-                await setUserPermission(mount.containerPath);
-            }
-        }
-        for (const cmd of node.cmds) {
-            checkIfAbort(cancelDefer);
-            const command = template_value_1.templateValue(cmd.cmd, node.envs);
-            node.status.console.write('internal', 'info', `execute cmd ${command} in container`);
-            const result = await execCommand(node, docker, container, convertToPosixPath(cmd.path), [node.shell, '-c', command], user);
-            if (!result) {
-                return;
-            }
-            if (result.ExitCode !== 0) {
-                node.status.console.write('internal', 'error', `command ${command} failed with ${result.ExitCode}`);
-                throw new Error(`command ${command} failed with ${result.ExitCode}`);
-            }
-        }
-    }
-    finally {
-        try {
-            node.status.console.write('internal', 'debug', `remove container`);
-            await container.remove({ force: true });
-        }
-        catch (e) {
-            if (e.statusCode !== 404) {
-                node.status.console.write('internal', 'debug', `remove of container failed ${e.message}`);
-            }
-        }
-    }
-}
-exports.executeDocker = executeDocker;
-async function execCommand(node, docker, container, cwd, cmd, user) {
+exports.convertToPosixPath = convertToPosixPath;
+async function execCommand(status, environment, container, cwd, cmd, user, timeout, abort) {
     const exec = await container.exec({
         Cmd: cmd,
         WorkingDir: cwd,
@@ -218,31 +68,45 @@ async function execCommand(node, docker, container, cwd, cmd, user) {
         AttachStdout: true,
         AttachStdin: true,
         AttachStderr: true,
-        User: user,
+        User: user ?? undefined,
     });
-    node.status.console.write('internal', 'debug', `received exec id ${exec.id}`);
+    status.write('debug', `received exec id ${exec.id}`);
     const stream = await exec.start({ stdin: true, hijack: true, Detach: false, Tty: false });
     return new Promise((resolve, reject) => {
-        stream_1.awaitStream(node, docker, stream)
-            .then(() => exec.inspect())
-            .then(resolve)
+        let resolved = false;
+        if (abort) {
+            (0, abort_event_1.listenOnAbort)(abort, () => {
+                if (resolved) {
+                    return;
+                }
+                resolved = true;
+                resolve({ type: 'canceled' });
+            });
+        }
+        (0, stream_1.awaitStream)(status, stream)
+            .then(() => {
+            if (resolved) {
+                return;
+            }
+            return exec.inspect().then((result) => {
+                if (resolved) {
+                    return;
+                }
+                resolve({ type: 'result', result });
+                resolved = true;
+            });
+        })
             .catch(reject);
-        pollStatus(exec, resolve, reject);
+        if (timeout) {
+            setTimeout(() => {
+                if (resolved) {
+                    return;
+                }
+                resolve({ type: 'timeout' });
+                resolved = true;
+            }, timeout);
+        }
     });
 }
 exports.execCommand = execCommand;
-function pollStatus(exec, resolve, reject) {
-    exec
-        .inspect()
-        .then((result) => {
-        if (!result.Running) {
-            resolve(result);
-        }
-        else {
-            setTimeout(() => pollStatus(exec, resolve, reject), 50);
-        }
-    })
-        .catch(reject);
-}
-exports.pollStatus = pollStatus;
 //# sourceMappingURL=execute-docker.js.map

package/dist/executer/execute.spec.js

@@ -1,46 +1,46 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const create_work_tree_1 = require("../testing/create-work-tree");
-const execute_1 = require("./execute");
-const get_execution_context_mock_1 = require("./get-execution-context-mock");
+const get_test_suite_1 = require("../testing/get-test-suite");
+const expect_1 = require("../testing/expect");
 describe('execute', () => {
-    let ctx;
-    let workTree;
-    let nodeId;
-    beforeEach(async () => {
-        ctx = get_execution_context_mock_1.getExecutionContextMock();
-        ctx.watch = true;
-        workTree = await create_work_tree_1.createWorkTree(ctx.environment, {
-            tasks: {
-                api: {
-                    cmds: ['node index.js'],
-                    src: ['index.js', 'package.json'],
-                },
-            },
-        }, 'api');
-        nodeId = workTree.rootNode.id;
-        await ctx.environment.file.createDirectory(ctx.environment.cwd);
-        await ctx.environment.file.writeFile(`${ctx.environment.cwd}/index.js`, "console.log('hello')");
-        await ctx.environment.file.writeFile(`${ctx.environment.cwd}/package.json`, '{}');
-    });
+    const suite = (0, get_test_suite_1.getTestSuite)('hello-world-node', ['build.yaml', 'package.json', 'index.js']);
+    afterAll(() => suite.close());
     it('should restart watching task if once completed', async () => {
-        const resultPromise = execute_1.execute(workTree, ctx);
-        const runningApi = await ctx.executor.waitForExecution(nodeId);
-        runningApi.end();
-        await ctx.environment.file.appendFile(`${ctx.environment.cwd}/index.js`, '\n');
-        await ctx.executor.waitForExecution(nodeId);
-        await ctx.environment.abortCtrl.abort();
-        const result = await resultPromise;
-        expect(result.success).toBeFalsy();
+        const { cli, environment } = await suite.setup({ taskName: 'api' });
+        const node = cli.node('api');
+        const exec = cli.execWatch({ watch: true });
+        let count = 0;
+        exec.state.on((state) => {
+            if (state.node[node.id].type === 'completed') {
+                count++;
+                if (count === 1) {
+                    environment.file.appendFile(`${environment.cwd}/index.js`, '\n');
+                }
+                else if (count === 2) {
+                    environment.abortCtrl.abort();
+                }
+            }
+        });
+        const result = await exec.start();
+        await (0, expect_1.expectSuccessfulResult)(result, environment);
     });
     it('should restart watching task if once failed', async () => {
-        const resultPromise = execute_1.execute(workTree, ctx);
-        const runningApi = await ctx.executor.waitForExecution(nodeId);
-        runningApi.fail(new Error('runtime error'));
-        await ctx.environment.file.appendFile(`${ctx.environment.cwd}/index.js`, '\n');
-        await ctx.executor.waitForExecution(nodeId);
-        await ctx.environment.abortCtrl.abort();
-        const result = await resultPromise;
+        const { cli, environment } = await suite.setup({ taskName: 'api_crashing' });
+        const node = cli.node('api_crashing');
+        const exec = cli.execWatch({ watch: true });
+        let count = 0;
+        exec.state.on((state) => {
+            if (state.node[node.id].type === 'crash') {
+                count++;
+                if (count === 1) {
+                    environment.file.appendFile(`${environment.cwd}/index.js`, '\n');
+                }
+                else if (count === 2) {
+                    environment.abortCtrl.abort();
+                }
+            }
+        });
+        const result = await exec.start();
         expect(result.success).toBeFalsy();
     });
 });

package/dist/executer/execution-steps.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setUserPermissions = exports.prepareMounts = exports.prepareVolume = exports.pullImage = void 0;
+const work_node_1 = require("../planner/work-node");
+const pull_1 = require("../docker/pull");
+const get_docker_executor_1 = require("./get-docker-executor");
+const work_service_1 = require("../planner/work-service");
+const path_1 = require("path");
+const set_user_permission_1 = require("./set-user-permission");
+async function pullImage(node, environment) {
+    if ((0, work_node_1.isContainerWorkNode)(node)) {
+        await (0, pull_1.pull)(environment.status.task(node), environment, node.image);
+    }
+    else if ((0, work_service_1.isContainerWorkService)(node)) {
+        await (0, pull_1.pull)(environment.status.service(node), environment, node.image);
+    }
+}
+exports.pullImage = pullImage;
+async function prepareVolume(node, environment) {
+    if ((0, work_node_1.isContainerWorkNode)(node) || (0, work_service_1.isContainerWorkService)(node)) {
+        for (const volume of node.volumes) {
+            await (0, get_docker_executor_1.ensureVolumeExists)(environment, volume.name);
+        }
+    }
+}
+exports.prepareVolume = prepareVolume;
+async function prepareMounts(node, environment) {
+    for (const mount of node.mounts) {
+        const exists = await environment.file.exists(mount.localPath);
+        if (exists) {
+            continue;
+        }
+        if ((0, path_1.extname)(mount.localPath)) {
+            await environment.file.writeFile(mount.localPath, '');
+        }
+        else {
+            await environment.file.createDirectory(mount.localPath);
+        }
+    }
+}
+exports.prepareMounts = prepareMounts;
+async function setUserPermissions(node, container, environment) {
+    const status = environment.status.from(node);
+    if (node.user) {
+        if ((0, work_node_1.isContainerWorkNode)(node)) {
+            await (0, set_user_permission_1.setUserPermission)(node.cwd, status, environment, container, node.user);
+        }
+        for (const volume of node.volumes) {
+            await (0, set_user_permission_1.setUserPermission)(volume.containerPath, status, environment, container, node.user);
+        }
+        for (const mount of node.mounts) {
+            await (0, set_user_permission_1.setUserPermission)(mount.containerPath, status, environment, container, node.user);
+        }
+    }
+}
+exports.setUserPermissions = setUserPermissions;
+//# sourceMappingURL=execution-steps.js.map

package/dist/executer/get-docker-executor.js

@@ -1,14 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDockerExecutor = exports.ensureVolumeExists = exports.existsVolume = void 0;
-const work_node_1 = require("../planner/work-node");
-const execute_docker_1 = require("./execute-docker");
-const get_local_executor_1 = require("./get-local-executor");
-const replace_env_variables_1 = require("../environment/replace-env-variables");
-const path_1 = require("path");
-async function existsVolume(docker, volumeName) {
+exports.ensureVolumeExists = exports.existsVolume = void 0;
+async function existsVolume(environment, volumeName) {
     try {
-        const volume = await docker.getVolume(volumeName);
+        const volume = await environment.docker.getVolume(volumeName);
         return await volume.inspect();
     }
     catch (e) {
@@ -16,10 +11,10 @@ async function existsVolume(docker, volumeName) {
     }
 }
 exports.existsVolume = existsVolume;
-async function ensureVolumeExists(docker, volumeName) {
-    const volumeExists = await existsVolume(docker, volumeName);
+async function ensureVolumeExists(environment, volumeName) {
+    const volumeExists = await existsVolume(environment, volumeName);
     if (!volumeExists) {
-        await docker.createVolume({
+        await environment.docker.createVolume({
             Name: volumeName,
             Driver: 'local',
             Labels: { app: 'hammerkit' },
@@ -27,93 +22,4 @@ async function ensureVolumeExists(docker, volumeName) {
     }
 }
 exports.ensureVolumeExists = ensureVolumeExists;
-function getDockerExecutor() {
-    const localExec = get_local_executor_1.getLocalExecutor();
-    return {
-        async restore(node, environment, path) {
-            const docker = execute_docker_1.getDocker();
-            for (const generate of node.generates) {
-                if (generate.inherited) {
-                    continue;
-                }
-                const id = execute_docker_1.generateId(generate.path);
-                const volumeName = execute_docker_1.getVolumeName(generate.path);
-                const sourcePath = path_1.join(path, 'generates', `${id}.tar`);
-                if (!(await environment.file.exists(sourcePath))) {
-                    continue;
-                }
-                await ensureVolumeExists(docker, volumeName);
-                node.status.console.write('internal', 'info', `import data into volume ${volumeName}`);
-                const res = await docker.run('ubuntu', ['bash', '-c', `cd /data && tar xvf /import/${id}.tar --strip 1`], [], {
-                    HostConfig: {
-                        Binds: [`${volumeName}:/data`, `${sourcePath}:/import/${id}.tar`],
-                        AutoRemove: true,
-                    },
-                });
-                if (res[0].StatusCode !== 0) {
-                    throw new Error(res[0].Error);
-                }
-            }
-        },
-        async store(node, environment, path) {
-            const docker = execute_docker_1.getDocker();
-            for (const generate of node.generates) {
-                if (generate.inherited) {
-                    continue;
-                }
-                const id = execute_docker_1.generateId(generate.path);
-                const volumeName = execute_docker_1.getVolumeName(generate.path);
-                const volumeExists = await existsVolume(docker, volumeName);
-                if (!volumeExists) {
-                    node.status.console.write('internal', 'info', `generate ${generate} has no volume ${volumeName}`);
-                    continue;
-                }
-                const targetPath = path_1.join(path, 'generates');
-                await environment.file.createDirectory(targetPath);
-                node.status.console.write('internal', 'info', `export data from volume ${volumeName}`);
-                const res = await docker.run('ubuntu', ['tar', 'cvf', `/export/${id}.tar`, '/data'], [], {
-                    HostConfig: {
-                        Binds: [`${volumeName}:/data`, `${targetPath}:/export`],
-                        AutoRemove: true,
-                    },
-                });
-                if (res[0].StatusCode !== 0) {
-                    throw new Error(res[0].Error);
-                }
-            }
-        },
-        async clean(node, environment) {
-            if (!work_node_1.isContainerWorkNode(node)) {
-                return localExec.clean(node, environment);
-            }
-            const docker = execute_docker_1.getDocker();
-            for (const generate of node.generates) {
-                if (generate.inherited) {
-                    continue;
-                }
-                const volumeName = execute_docker_1.getVolumeName(generate.path);
-                const volumeExists = await existsVolume(docker, volumeName);
-                if (volumeExists) {
-                    node.status.console.write('internal', 'info', `remove volume ${volumeName}`);
-                    const volume = await docker.getVolume(volumeName);
-                    await volume.remove();
-                }
-                else {
-                    node.status.console.write('internal', 'info', `generate ${generate} has no volume ${volumeName}`);
-                }
-            }
-        },
-        async exec(node, context, cancelDefer) {
-            if (!work_node_1.isContainerWorkNode(node)) {
-                return localExec.exec(node, context, cancelDefer);
-            }
-            const envs = replace_env_variables_1.replaceEnvVariables(node, context.environment.processEnvs);
-            await execute_docker_1.executeDocker({
-                ...node,
-                envs,
-            }, context, cancelDefer);
-        },
-    };
-}
-exports.getDockerExecutor = getDockerExecutor;
 //# sourceMappingURL=get-docker-executor.js.map

package/dist/executer/hierarchy-scheduler.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schedule = void 0;
+const work_service_1 = require("../planner/work-service");
+const docker_service_1 = require("./docker-service");
+const kubernetes_service_1 = require("./kubernetes-service");
+const work_node_1 = require("../planner/work-node");
+const docker_node_1 = require("./docker-node");
+const local_node_1 = require("./local-node");
+const work_node_status_1 = require("../planner/work-node-status");
+async function schedule(processManager, state, environment) {
+    state.on((currentState) => {
+        for (const [, nodeState] of Object.entries(currentState.node)) {
+            if (nodeState.type === 'pending') {
+                const endedNeeds = nodeState.node.needs
+                    .map((need) => currentState.service[need.id])
+                    .filter((service) => service.type === 'end');
+                if (endedNeeds.length > 0) {
+                    state.patchNode({
+                        type: 'canceled',
+                        node: nodeState.node,
+                    });
+                    continue;
+                }
+                const pendingNeeds = nodeState.node.needs
+                    .map((need) => currentState.service[need.id])
+                    .filter((service) => service.type === 'pending');
+                const hasOpenDeps = nodeState.node.deps.some((dep) => currentState.node[dep.id].type !== 'completed');
+                if (hasOpenDeps) {
+                    continue;
+                }
+                if (pendingNeeds.length > 0) {
+                    // TODO do not start, if needs are cached
+                    for (const pendingNeed of pendingNeeds) {
+                        const ctx = (0, work_node_status_1.logContext)('service', pendingNeed.service);
+                        state.patchService({
+                            type: 'running',
+                            service: pendingNeed.service,
+                            abortController: processManager.background(ctx, (0, work_service_1.isContainerWorkService)(pendingNeed.service)
+                                ? (0, docker_service_1.dockerService)(pendingNeed.service, state, environment)
+                                : (0, kubernetes_service_1.kubernetesService)(pendingNeed.service, state, environment)),
+                        });
+                    }
+                    continue;
+                }
+                const hasNotReadyNeeds = nodeState.node.needs.some((need) => currentState.service[need.id].type !== 'ready');
+                if (hasNotReadyNeeds) {
+                    continue;
+                }
+                const serviceContainers = {};
+                for (const need of nodeState.node.needs) {
+                    const serviceState = currentState.service[need.id];
+                    if (serviceState.type === 'ready') {
+                        serviceContainers[need.id] = serviceState.dns;
+                    }
+                }
+                const ctx = (0, work_node_status_1.logContext)('task', nodeState.node);
+                state.patchNode({
+                    type: 'starting',
+                    node: nodeState.node,
+                    started: new Date(),
+                    abortController: (0, work_node_1.isContainerWorkNode)(nodeState.node)
+                        ? processManager.task(ctx, (0, docker_node_1.dockerNode)(nodeState.node, serviceContainers, state, environment))
+                        : processManager.task(ctx, (0, local_node_1.localNode)(nodeState.node, state, environment)),
+                });
+            }
+        }
+        for (const [serviceId, serviceState] of Object.entries(currentState.service)) {
+            if (serviceState.type !== 'ready' && serviceState.type !== 'running') {
+                continue;
+            }
+            let hasNeed = false;
+            for (const nodeState of Object.values(currentState.node)) {
+                if (nodeState.type === 'running' || nodeState.type === 'starting' || nodeState.type === 'pending') {
+                    if (nodeState.node.needs.some((n) => n.id === serviceId)) {
+                        hasNeed = true;
+                    }
+                }
+            }
+            if (!hasNeed) {
+                environment.status.service(serviceState.service).write('info', 'stop unused service');
+                serviceState.abortController.abort();
+            }
+        }
+    });
+    await processManager.onComplete();
+    const success = !Object.values(state.current.node).some((n) => n.type !== 'completed');
+    return {
+        state: state.current,
+        success,
+    };
+}
+exports.schedule = schedule;
+//# sourceMappingURL=hierarchy-scheduler.js.map