hammerkit 1.4.0-beta.6 → 1.5.0-alpha.0

package/dist/testing/integration/unknown.spec.js

@@ -2,13 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 require("jest-extended");
 const get_test_suite_1 = require("../get-test-suite");
-const validate_1 = require("../../planner/validate");
 describe('unknown', () => {
-    const suite = get_test_suite_1.getTestSuite('unknown', ['build.yaml']);
+    const suite = (0, get_test_suite_1.getTestSuite)('unknown', ['build.yaml']);
+    afterAll(() => suite.close());
     async function validateTask(name, expectedErrors) {
-        const { buildFile, context } = await suite.setup();
+        const { cli } = await suite.setup({ taskName: name });
         let i = 0;
-        for await (const message of validate_1.validate(buildFile, context, name)) {
+        for await (const message of cli.validate()) {
             expect(expectedErrors[i++]).toEqual(message.message);
         }
         expect(i).toEqual(expectedErrors.length);

package/dist/testing/integration/validate.spec.js

@@ -2,17 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 require("jest-extended");
 const get_test_suite_1 = require("../get-test-suite");
-const validate_1 = require("../../planner/validate");
 describe('validate', () => {
-    const suite = get_test_suite_1.getTestSuite('validate', ['build.yaml', 'build-loop.yaml']);
+    const suite = (0, get_test_suite_1.getTestSuite)('validate', ['build.yaml', 'build-loop.yaml']);
     async function validateTask(name, expectedErrors) {
-        const { buildFile, context } = await suite.setup();
+        const { cli } = await suite.setup({ taskName: name });
         let i = 0;
-        for await (const message of validate_1.validate(buildFile, context, name)) {
+        for await (const message of cli.validate()) {
             expect(expectedErrors[i++]).toEqual(message.message);
         }
         expect(i).toEqual(expectedErrors.length);
     }
+    afterAll(() => suite.close());
     it('should validate regular task', async () => {
         await validateTask('regular_task', []);
     });

package/dist/testing/integration/watch.spec.js

@@ -1,44 +1,46 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const plan_work_tree_1 = require("../../planner/utils/plan-work-tree");
 const get_test_suite_1 = require("../get-test-suite");
-const execute_1 = require("../../executer/execute");
 const path_1 = require("path");
 describe('watch', () => {
-    const suite = get_test_suite_1.getTestSuite('watch', ['build.yaml', 'src', 'package.json', 'package-lock.json', 'tsconfig.json']);
+    const suite = (0, get_test_suite_1.getTestSuite)('watch', ['build.yaml', 'src', 'package.json', 'package-lock.json', 'tsconfig.json']);
     afterAll(() => suite.close());
     it('should run watch task and cancel', async () => {
-        const { buildFile, context, executionContext } = await suite.setup();
-        const workTree = plan_work_tree_1.planWorkTree(buildFile, 'api');
-        executionContext.watch = true;
-        executionContext.events.on(({ workTree, nodeId, newState }) => {
-            if (nodeId === workTree.rootNode.id && newState.type === 'running') {
-                context.cancelDefer.resolve();
+        const { cli, environment } = await suite.setup({ taskName: 'api' });
+        const apiNode = cli.node('api');
+        const exec = cli.execWatch({ watch: true });
+        exec.processManager.on((evt) => {
+            if (evt.context.id === apiNode.id && evt.type === 'started') {
+                environment.abortCtrl.abort();
             }
         });
-        const result = await execute_1.execute(workTree, executionContext);
+        const result = await exec.start();
         expect(result.success).toBeFalsy();
-        expect(result.nodes[workTree.rootNode.id].state.type).toEqual('aborted');
-    }, 120000);
+        expect(result.state.node[apiNode.id].type).toEqual('canceled');
+    });
     it('should restart task if dependency updates', async () => {
-        const { buildFile, context, executionContext } = await suite.setup();
-        const workTree = plan_work_tree_1.planWorkTree(buildFile, 'api');
+        const { cli, environment } = await suite.setup({ taskName: 'api' });
+        const apiNode = cli.node('api');
+        const exec = cli.execWatch({ watch: true });
+        let appendedFile = false;
         let restarted = false;
-        executionContext.watch = true;
-        executionContext.events.on(({ nodeId, newState }) => {
-            if (nodeId === workTree.rootNode.id && newState.type === 'running') {
-                if (restarted) {
-                    context.cancelDefer.resolve();
+        exec.processManager.on((evt) => {
+            if (evt.type === 'started' && evt.context.id === apiNode.id) {
+                if (!appendedFile) {
+                    appendedFile = true;
+                    environment.file.appendFile((0, path_1.join)(environment.cwd, 'package.json'), '\n');
                 }
                 else {
-                    context.file.appendFile(path_1.join(buildFile.path, 'package.json'), '\n');
                     restarted = true;
+                    environment.abortCtrl.abort();
                 }
             }
         });
-        const result = await execute_1.execute(workTree, executionContext);
+        const result = await exec.start();
+        expect(appendedFile).toBeTruthy();
+        expect(restarted).toBeTruthy();
         expect(result.success).toBeFalsy();
-        expect(result.nodes[workTree.rootNode.id].state.type).toEqual('aborted');
-    }, 120000);
+        expect(result.state.node[apiNode.id].type).toEqual('canceled');
+    });
 });
 //# sourceMappingURL=watch.spec.js.map

package/dist/testing/lazy.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Lazy = void 0;
+class Lazy {
+    constructor(factory) {
+        this.factory = factory;
+        this.current = null;
+    }
+    resolve() {
+        if (!this.current) {
+            this.current = { result: this.factory() };
+        }
+        return this.current.result;
+    }
+}
+exports.Lazy = Lazy;
+//# sourceMappingURL=lazy.js.map

package/dist/testing/start-watch-processes.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startWatchProcesses = void 0;
+const plan_work_nodes_1 = require("../planner/utils/plan-work-nodes");
+const watch_node_1 = require("../executer/watch-node");
+const work_service_1 = require("../planner/work-service");
+const watch_service_1 = require("../executer/watch-service");
+const work_node_status_1 = require("../planner/work-node-status");
+function startWatchProcesses(state, processManager, environment) {
+    for (const node of (0, plan_work_nodes_1.iterateWorkNodes)(state.current.node)) {
+        if (node.node.src.length > 0) {
+            if (node.node.continuous) {
+                environment.status.task(node.node).write('debug', 'do not start files watches for continuous task');
+                continue;
+            }
+            processManager.background((0, work_node_status_1.logContext)('task', node.node), (0, watch_node_1.watchNode)(node.node, state, environment));
+        }
+    }
+    for (const service of (0, plan_work_nodes_1.iterateWorkServices)(state.current.service)) {
+        if (!(0, work_service_1.isContainerWorkService)(service.service)) {
+            continue;
+        }
+        if (service.service.mounts.length > 0) {
+            processManager.background((0, work_node_status_1.logContext)('service', service.service), (0, watch_service_1.watchService)(service.service, state, environment));
+        }
+    }
+}
+exports.startWatchProcesses = startWatchProcesses;
+//# sourceMappingURL=start-watch-processes.js.map

package/dist/testing/test-suite-setup.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=test-suite-setup.js.map

package/dist/utils/abort-event.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitOnAbort = exports.listenOnAbort = void 0;
+function listenOnAbort(abort, callback) {
+    if (abort.aborted) {
+        callback();
+        return;
+    }
+    const listener = abort;
+    listener.addEventListener('abort', () => {
+        callback();
+    }, { once: true });
+}
+exports.listenOnAbort = listenOnAbort;
+function waitOnAbort(abort) {
+    if (abort.aborted) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+        listenOnAbort(abort, resolve);
+    });
+}
+exports.waitOnAbort = waitOnAbort;
+//# sourceMappingURL=abort-event.js.map

package/dist/utils/abortable-function.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abortableFunction = void 0;
+const abort_event_1 = require("./abort-event");
+const log_1 = require("../log");
+function abortableFunction(console, abortSignal, fn) {
+    return new Promise((resolve, reject) => {
+        const cleanupFunctions = [];
+        let aborted = false;
+        function doAbort(err) {
+            aborted = true;
+            Promise.allSettled(cleanupFunctions.map((fn) => fn())).then((results) => {
+                for (const result of results) {
+                    if (result.status === 'rejected') {
+                        console.error((0, log_1.getErrorMessage)(result.reason));
+                    }
+                }
+                reject(err);
+            });
+        }
+        if (abortSignal instanceof Array) {
+            for (const signal of abortSignal) {
+                (0, abort_event_1.listenOnAbort)(signal, () => {
+                    doAbort(new Error('canceled'));
+                });
+            }
+        }
+        else {
+            (0, abort_event_1.listenOnAbort)(abortSignal, () => {
+                doAbort(new Error('canceled'));
+            });
+        }
+        const isAborted = () => {
+            if (abortSignal instanceof Array) {
+                for (const signal of abortSignal) {
+                    if (signal.aborted) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+            else {
+                return abortSignal.aborted;
+            }
+        };
+        fn({
+            addAbortFunction(cleanupFn) {
+                if (aborted) {
+                    cleanupFn();
+                }
+                else {
+                    cleanupFunctions.push(cleanupFn);
+                }
+            },
+            isAborted,
+            checkForAbort() {
+                if (isAborted()) {
+                    throw new Error('canceled');
+                }
+            },
+        })
+            .then((result) => {
+            resolve(result);
+        })
+            .catch((err) => {
+            doAbort(err);
+        });
+    });
+}
+exports.abortableFunction = abortableFunction;
+//# sourceMappingURL=abortable-function.js.map

package/dist/utils/debouncer.spec.js

@@ -8,7 +8,7 @@ describe('utils/debouncer', () => {
         new debouncer_1.Debouncer(() => {
             called = true;
         }, 10);
-        await sleep_1.sleep(20);
+        await (0, sleep_1.sleep)(20);
         expect(called).toBeFalsy();
     });
     it('should trigger after start', async () => {
@@ -17,7 +17,7 @@ describe('utils/debouncer', () => {
             called = true;
         }, 10);
         debouncer.start();
-        await sleep_1.sleep(20);
+        await (0, sleep_1.sleep)(20);
         expect(called).toBeTruthy();
     });
     it('should delay trigger after bounce', async () => {
@@ -26,11 +26,11 @@ describe('utils/debouncer', () => {
             called = true;
         }, 20);
         debouncer.start();
-        await sleep_1.sleep(10);
+        await (0, sleep_1.sleep)(10);
         debouncer.bounce();
-        await sleep_1.sleep(15);
+        await (0, sleep_1.sleep)(15);
         expect(called).toBeFalsy();
-        await sleep_1.sleep(5);
+        await (0, sleep_1.sleep)(5);
         expect(called).toBeTruthy();
     });
     it('should cancel trigger after clear', async () => {
@@ -39,9 +39,9 @@ describe('utils/debouncer', () => {
             called = true;
         }, 20);
         debouncer.start();
-        await sleep_1.sleep(10);
+        await (0, sleep_1.sleep)(10);
         debouncer.clear();
-        await sleep_1.sleep(15);
+        await (0, sleep_1.sleep)(15);
         expect(called).toBeFalsy();
     });
     it('should trigger on flush', async () => {
@@ -50,7 +50,7 @@ describe('utils/debouncer', () => {
             called = true;
         }, 20);
         debouncer.start();
-        await sleep_1.sleep(5);
+        await (0, sleep_1.sleep)(5);
         debouncer.flush();
         expect(called).toBeTruthy();
     });

package/dist/utils/environment-config.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEnvironmentConfig = void 0;
+function getEnvironmentConfig(name, defaultValue) {
+    if (name in process.env) {
+        return parseInt(`${process.env[name]}`, 0) ?? defaultValue;
+    }
+    else {
+        return defaultValue;
+    }
+}
+exports.getEnvironmentConfig = getEnvironmentConfig;
+//# sourceMappingURL=environment-config.js.map

package/dist/utils/fail-never.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.failNever = void 0;
-function failNever(message) {
+function failNever(value, message) {
     throw new Error(message);
 }
 exports.failNever = failNever;

package/dist/utils/sleep.spec.js

@@ -4,18 +4,18 @@ const sleep_1 = require("./sleep");
 describe('utils/sleep', () => {
     it('should resolve not before timeout', () => {
         let called = false;
-        sleep_1.sleep(10).then(() => {
+        (0, sleep_1.sleep)(10).then(() => {
             called = true;
         });
         expect(called).toBeFalsy();
     });
     it('should resolve after timeout', async () => {
         let called = false;
-        sleep_1.sleep(10).then(() => {
+        (0, sleep_1.sleep)(10).then(() => {
             called = true;
         });
         expect(called).toBeFalsy();
-        await sleep_1.sleep(10);
+        await (0, sleep_1.sleep)(10);
         expect(called).toBeTruthy();
     });
 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hammerkit",
   "description": "build stuff and things",
-  "version": "1.4.0-beta.6",
+  "version": "1.5.0-alpha.0",
   "bin": "dist/index.js",
   "bugs": {
     "url": "https://github.com/no0dles/hammerkit"
@@ -18,30 +18,33 @@
   "scripts": {
     "prepack": "tsc -b tsconfig.json",
     "build": "tsc -b tsconfig.json",
-    "test": "jest"
+    "test": "jest",
+    "format": "prettier -w src/** && eslint . --fix --ext .ts"
   },
   "dependencies": {
-    "commander": "^7.2.0",
-    "dockerode": "^3.2.1",
-    "minimatch": "^3.0.4",
+    "chokidar": "^3.5.3",
+    "tar": "^6.1.11",
     "colors": "^1.4.0",
-    "chokidar": "^3.5.2",
-    "yaml": "^1.10.2"
+    "commander": "^9.4.1",
+    "dockerode": "^3.3.4",
+    "minimatch": "^5.1.0",
+    "yaml": "^2.1.3"
   },
   "devDependencies": {
-    "@types/dockerode": "^3.2.3",
-    "@types/jest": "^26.0.22",
-    "@types/minimatch": "^3.0.4",
-    "@types/node": "^14.14.37",
-    "@typescript-eslint/eslint-plugin": "^4.20.0",
-    "@typescript-eslint/parser": "^4.20.0",
-    "eslint": "^7.23.0",
-    "jest": "^26.6.3",
-    "jest-extended": "^0.11.5",
-    "prettier": "^2.2.1",
-    "ts-jest": "^26.5.4",
-    "ts-node": "^9.1.1",
-    "typescript": "^4.2.3",
-    "pkg": "^5.2.1"
+    "@types/dockerode": "^3.3.11",
+    "@types/jest": "^29.1.2",
+    "@types/minimatch": "^5.1.2",
+    "@types/node": "^16.10.2",
+    "@types/tar": "^6.1.3",
+    "@typescript-eslint/eslint-plugin": "^5.40.0",
+    "@typescript-eslint/parser": "^5.40.0",
+    "eslint": "^8.25.0",
+    "jest": "^29.2.0",
+    "jest-extended": "^3.1.0",
+    "pkg": "^5.8.0",
+    "prettier": "^2.7.1",
+    "ts-jest": "^29.0.3",
+    "ts-node": "^10.9.1",
+    "typescript": "^4.8.4"
   }
 }

package/dist/console/get-console-context-mock.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getConsoleContextMock = void 0;
-function getConsoleContextMock() {
-    const expectedLogs = {};
-    function complete(message) {
-        const obj = expectedLogs[message];
-        if (obj) {
-            obj.fulfilled = true;
-            delete expectedLogs[message];
-        }
-    }
-    return {
-        warn(message) {
-            complete(message);
-        },
-        info(message) {
-            complete(message);
-        },
-        error(message) {
-            complete(message);
-        },
-        debug(message) {
-            complete(message);
-        },
-        expectLog(message) {
-            expectedLogs[message] = { fulfilled: false };
-            return expectedLogs[message];
-        },
-    };
-}
-exports.getConsoleContextMock = getConsoleContextMock;
-//# sourceMappingURL=get-console-context-mock.js.map

package/dist/executer/clean.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.clean = void 0;
-const plan_work_nodes_1 = require("../planner/utils/plan-work-nodes");
-const get_cache_directory_1 = require("../optimizer/get-cache-directory");
-async function clean(workNodes, context) {
-    for (const node of plan_work_nodes_1.iterateWorkNodes(workNodes)) {
-        for (const generate of node.generates) {
-            if (await context.file.exists(generate)) {
-                node.status.console.write('internal', 'info', `remove generate ${generate}`);
-                await context.file.remove(generate);
-            }
-        }
-        const cachePath = get_cache_directory_1.getCacheDirectory(node.id);
-        if (await context.file.exists(cachePath)) {
-            node.status.console.write('internal', 'info', `remove cache ${cachePath}`);
-            await context.file.remove(cachePath);
-        }
-    }
-}
-exports.clean = clean;
-//# sourceMappingURL=clean.js.map

package/dist/executer/execute-local.js

@@ -1,58 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeLocal = void 0;
-const child_process_1 = require("child_process");
-const log_1 = require("../log");
-const template_value_1 = require("../planner/utils/template-value");
-const os_1 = require("os");
-const get_process_env_1 = require("../environment/get-process-env");
-async function executeLocal(node, arg, cancelDefer) {
-    node.status.console.write('internal', 'info', `execute ${node.name} locally`);
-    const envs = get_process_env_1.getProcessEnvs(node.envs, arg.environment);
-    for (const cmd of node.cmds) {
-        if (cancelDefer.isResolved) {
-            return;
-        }
-        const command = template_value_1.templateValue(cmd.cmd, envs);
-        await new Promise((resolve, reject) => {
-            node.status.console.write('internal', 'info', `execute cmd ${command} locally`);
-            const ps = child_process_1.exec(command, {
-                env: envs,
-                cwd: cmd.path,
-                shell: os_1.platform() === 'win32' ? 'powershell.exe' : undefined,
-            });
-            ps.stdout?.on('data', (data) => {
-                for (const log of log_1.getLogs(data)) {
-                    node.status.console.write('process', 'info', log);
-                }
-            });
-            ps.stderr?.on('data', (data) => {
-                for (const log of log_1.getLogs(data)) {
-                    node.status.console.write('process', 'info', log);
-                }
-            });
-            ps.on('error', (err) => {
-                node.status.console.write('process', 'error', err.message);
-            });
-            ps.on('close', (code) => {
-                if (cancelDefer.isResolved) {
-                    reject(new Error('canceled'));
-                    return;
-                }
-                if (code !== 0 && code !== null) {
-                    const message = `failed with code ${code}`;
-                    node.status.console.write('process', 'error', message);
-                    reject(new Error(message));
-                }
-                else {
-                    resolve();
-                }
-            });
-            cancelDefer.promise.then(() => {
-                ps.kill();
-            });
-        });
-    }
-}
-exports.executeLocal = executeLocal;
-//# sourceMappingURL=execute-local.js.map

package/dist/executer/execute.js

@@ -1,95 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.execute = void 0;
-const optimize_1 = require("../optimizer/optimize");
-const get_ready_work_nodes_1 = require("./get-ready-work-nodes");
-const write_work_node_cache_1 = require("../optimizer/write-work-node-cache");
-const path_1 = require("path");
-const plan_work_nodes_1 = require("../planner/utils/plan-work-nodes");
-const states_1 = require("./states");
-const debouncer_1 = require("../utils/debouncer");
-const get_work_node_cache_stats_1 = require("../optimizer/get-work-node-cache-stats");
-async function execute(workTree, context) {
-    context.environment.cancelDefer.promise.then(() => {
-        states_1.cancelNodes(workTree, context);
-    });
-    await optimize_1.optimize(workTree, context);
-    if (context.watch) {
-        await watchNodes(workTree, context);
-    }
-    runPendingNodes(workTree, context);
-    await workTree.rootNode.status.defer.promise;
-    for (const node of plan_work_nodes_1.iterateWorkNodes(workTree.nodes)) {
-        await node.status.defer.promise;
-    }
-    const result = {
-        success: true,
-        nodes: {},
-    };
-    for (const node of plan_work_nodes_1.iterateWorkNodes(workTree.nodes)) {
-        result.nodes[node.id] = node.status;
-        if (node.status.state.type === 'failed' || node.status.state.type === 'aborted') {
-            result.success = false;
-        }
-    }
-    return result;
-}
-exports.execute = execute;
-async function watchNodes(workTree, context) {
-    for (const node of plan_work_nodes_1.iterateWorkNodes(workTree.nodes)) {
-        if (node.src.length === 0) {
-            continue;
-        }
-        let currentState = await get_work_node_cache_stats_1.getWorkNodeCacheStats(node, context.environment);
-        const debouncer = new debouncer_1.Debouncer(async () => {
-            if (context.environment.cancelDefer.isResolved) {
-                return;
-            }
-            const newStats = await get_work_node_cache_stats_1.getWorkNodeCacheStats(node, context.environment);
-            const hasChanged = await get_work_node_cache_stats_1.hasStatsChanged(node, currentState, newStats, context.cacheMethod);
-            if (!hasChanged) {
-                return;
-            }
-            currentState = newStats;
-            states_1.resetNode(workTree, node.id, context);
-            runPendingNodes(workTree, context);
-        }, 100);
-        for (const src of node.src) {
-            const watcher = context.environment.file.watch(src.absolutePath, async (fileName) => {
-                const absoluteFileName = path_1.join(src.absolutePath, fileName);
-                if (src.matcher(absoluteFileName, node.cwd)) {
-                    node.status.console.write('internal', 'debug', `source ${absoluteFileName} change for watched task ${node.name}`);
-                    debouncer.bounce();
-                }
-            });
-            context.environment.cancelDefer.promise.then(() => {
-                watcher.close();
-            });
-        }
-    }
-}
-function runPendingNodes(workTree, arg) {
-    const pendingNodes = get_ready_work_nodes_1.getReadyWorkNodes(workTree);
-    for (const pendingNode of pendingNodes) {
-        if (arg.workers !== 0 && Object.keys(arg.runningNodes).length === arg.workers) {
-            continue;
-        }
-        if (arg.runningNodes[pendingNode.id]) {
-            continue;
-        }
-        continueExecution(workTree, pendingNode, arg);
-    }
-}
-async function continueExecution(workTree, node, context) {
-    const cancelDefer = states_1.runNode(workTree, node.id, context);
-    try {
-        await context.executor.exec(node, context, cancelDefer);
-        await write_work_node_cache_1.writeWorkNodeCache(node, context.environment);
-        states_1.completeNode(workTree, node.id, context, true);
-    }
-    catch (e) {
-        states_1.failNode(workTree, node.id, context, e);
-    }
-    runPendingNodes(workTree, context);
-}
-//# sourceMappingURL=execute.js.map

package/dist/executer/execution-context-event.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=execution-context-event.js.map

package/dist/executer/execution-context-mock.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=execution-context-mock.js.map