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

package/dist/planner/work-node-id.spec.js

@@ -2,24 +2,27 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const work_node_id_1 = require("./work-node-id");
 const create_build_file_1 = require("../testing/create-build-file");
-const get_environment_mock_1 = require("../executer/get-environment-mock");
 const plan_work_node_1 = require("./utils/plan-work-node");
+const work_context_1 = require("./work-context");
+const environment_mock_1 = require("../executer/environment-mock");
 async function compareTasks(firstTask, secondTask, expectEqual) {
-    const environmentMock = get_environment_mock_1.getEnvironmentMock();
-    const firstBuildFile = await create_build_file_1.createBuildFile(environmentMock, {
+    const environment = (0, environment_mock_1.environmentMock)(process.cwd());
+    const firstBuildFile = await (0, create_build_file_1.createBuildFile)(environment, {
         tasks: {
             test: firstTask,
         },
     });
-    const secondBuildFile = await create_build_file_1.createBuildFile(environmentMock, {
+    const secondBuildFile = await (0, create_build_file_1.createBuildFile)(environment, {
         tasks: {
             test: secondTask,
         },
     });
-    const firstMerged = plan_work_node_1.getMergedBuildTask(firstBuildFile, firstBuildFile.tasks['test']);
-    const secondMerged = plan_work_node_1.getMergedBuildTask(secondBuildFile, secondBuildFile.tasks['test']);
-    const firstNodeId = work_node_id_1.getWorkNodeId(firstBuildFile.path, firstMerged.task, firstMerged.deps);
-    const secondNodeId = work_node_id_1.getWorkNodeId(secondBuildFile.path, secondMerged.task, secondMerged.deps);
+    const firstContext = (0, work_context_1.createWorkContext)(firstBuildFile);
+    const firstMerged = (0, plan_work_node_1.planTask)(firstContext, (0, plan_work_node_1.findBuildTask)(firstContext, { taskName: 'test' }));
+    const secondContext = (0, work_context_1.createWorkContext)(secondBuildFile);
+    const secondMerged = (0, plan_work_node_1.planTask)(secondContext, (0, plan_work_node_1.findBuildTask)(secondContext, { taskName: 'test' }));
+    const firstNodeId = (0, work_node_id_1.getWorkNodeId)(firstMerged);
+    const secondNodeId = (0, work_node_id_1.getWorkNodeId)(secondMerged);
     if (expectEqual) {
         expect(firstNodeId).toEqual(secondNodeId);
     }

package/dist/planner/work-node-path.js

@@ -1,3 +1,2 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=work-node-path.js.map

package/dist/planner/work-node-status.js

@@ -1,31 +1,134 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.nodeConsole = void 0;
-const log_1 = require("../log");
+exports.statusConsole = exports.logContext = void 0;
 const emitter_1 = require("../utils/emitter");
-function nodeConsole() {
-    let current = null;
-    const logs = [];
-    const emit = emitter_1.emitter();
+const work_node_1 = require("./work-node");
+const environment_config_1 = require("../utils/environment-config");
+const log_1 = require("../log");
+const StatusBufferMax = (0, environment_config_1.getEnvironmentConfig)('STATUS_BUFFER_LIMIT', 300);
+const ConsoleBufferMax = (0, environment_config_1.getEnvironmentConfig)('CONSOLE_BUFFER_LIMIT', 30);
+function logContext(type, node) {
+    return {
+        type,
+        name: node.name,
+        id: node.id,
+    };
+}
+exports.logContext = logContext;
+class BufferContext {
+    constructor(limit) {
+        this.limit = limit;
+        this.scopedBuffer = {};
+        this.buffer = [];
+    }
+    add(id, data) {
+        this.buffer.push(data);
+        if (id in this.scopedBuffer) {
+            const scopedBuffer = this.scopedBuffer[id];
+            scopedBuffer.push(data);
+            if (scopedBuffer.length > this.limit) {
+                const removedBuffer = this.buffer.splice(0, 1)[0];
+                const bufferIndex = this.buffer.indexOf(removedBuffer);
+                if (bufferIndex >= 0) {
+                    this.buffer.splice(bufferIndex, 1);
+                }
+            }
+        }
+        else {
+            this.scopedBuffer[id] = [data];
+        }
+    }
+    current(id) {
+        if (!(id in this.scopedBuffer)) {
+            return null;
+        }
+        const value = this.scopedBuffer[id];
+        return value[value.length - 1];
+    }
+    get(id) {
+        if (id) {
+            return this.scopedBuffer[id] ?? [];
+        }
+        else {
+            return this.buffer;
+        }
+    }
+}
+function statusConsole() {
+    const statusBuffer = new BufferContext(StatusBufferMax);
+    const consoleBuffer = new BufferContext(ConsoleBufferMax);
+    const emit = (0, emitter_1.emitter)();
+    function addMessage(context, message) {
+        emit.emit(message);
+        if (message.type === 'console') {
+            consoleBuffer.add(context.id, message);
+        }
+        else if (log_1.isVerbose || message.level !== 'debug') {
+            statusBuffer.add(context.id, message);
+        }
+    }
     return {
-        read() {
-            return Promise.resolve(logs);
+        task(task) {
+            return this.context(logContext('task', task));
+        },
+        service(service) {
+            return this.context(logContext('service', service));
+        },
+        from(node) {
+            if ((0, work_node_1.isWorkNode)(node)) {
+                return this.task(node);
+            }
+            else {
+                return this.service(node);
+            }
+        },
+        context(context) {
+            return {
+                currentLog() {
+                    return consoleBuffer.current(context.id);
+                },
+                current() {
+                    return statusBuffer.current(context.id);
+                },
+                *logs() {
+                    for (const log of consoleBuffer.get(context.id)) {
+                        yield log;
+                    }
+                },
+                *read() {
+                    for (const log of statusBuffer.get(context.id)) {
+                        yield log;
+                    }
+                },
+                console(type, message) {
+                    addMessage(context, {
+                        type: 'console',
+                        console: type,
+                        message,
+                        date: new Date(),
+                        context,
+                    });
+                },
+                write(level, message) {
+                    addMessage(context, {
+                        type: 'status',
+                        message,
+                        context,
+                        level,
+                        date: new Date(),
+                    });
+                },
+            };
         },
         on(listener) {
             return emit.on(listener);
         },
-        write(type, level, message) {
-            const log = { level, type, message, date: new Date() };
-            if (log_1.isVerbose || level !== 'debug') {
-                current = log;
+        *read() {
+            for (const message of statusBuffer.get()) {
+                yield message;
             }
-            emit.emit(log);
-            logs.push(log);
-        },
-        get current() {
-            return current;
         },
     };
 }
-exports.nodeConsole = nodeConsole;
+exports.statusConsole = statusConsole;
 //# sourceMappingURL=work-node-status.js.map

package/dist/planner/work-node.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isLocalWorkNode = exports.isContainerWorkNode = void 0;
+exports.isWorkNode = exports.isContainerWorkNode = void 0;
 const isContainerWorkNode = (val) => val.type === 'container';
 exports.isContainerWorkNode = isContainerWorkNode;
-const isLocalWorkNode = (val) => val.type === 'local';
-exports.isLocalWorkNode = isLocalWorkNode;
+const isWorkNode = (val) => val.type === 'container' || val.type === 'local';
+exports.isWorkNode = isWorkNode;
 //# sourceMappingURL=work-node.js.map

package/dist/planner/work-service-id.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWorkServiceId = void 0;
+const crypto_1 = require("crypto");
+function getWorkServiceId(buildFile, service) {
+    const jsonData = JSON.stringify({
+        path: buildFile.path,
+        image: service.image,
+    });
+    return (0, crypto_1.createHash)('sha1').update(jsonData).digest('hex');
+}
+exports.getWorkServiceId = getWorkServiceId;
+//# sourceMappingURL=work-service-id.js.map

package/dist/planner/work-service-volume.js

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

package/dist/planner/work-service.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isContainerWorkService = void 0;
+const isContainerWorkService = (svc) => 'image' in svc && svc.type === 'container-service';
+exports.isContainerWorkService = isContainerWorkService;
+//# sourceMappingURL=work-service.js.map

package/dist/planner/work-services.js

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

package/dist/planner/work-volume.js

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

package/dist/program.js

@@ -1,75 +1,146 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getProgram = void 0;
+exports.getProgram = exports.createCli = void 0;
 const commander_1 = require("commander");
 const path_1 = require("path");
-const get_build_file_1 = require("./parser/get-build-file");
-const plan_work_nodes_1 = require("./planner/utils/plan-work-nodes");
-const execute_1 = require("./executer/execute");
-const plan_work_tree_1 = require("./planner/utils/plan-work-tree");
-const restore_1 = require("./executer/restore");
-const store_1 = require("./executer/store");
-const clean_1 = require("./executer/clean");
-const validate_1 = require("./planner/validate");
-const get_local_executor_1 = require("./executer/get-local-executor");
-const get_docker_executor_1 = require("./executer/get-docker-executor");
-const get_logger_1 = require("./logging/get-logger");
 const ci_1 = require("./utils/ci");
-const emitter_1 = require("./utils/emitter");
+const parse_label_arguments_1 = require("./parser/parse-label-arguments");
+const cli_1 = require("./cli");
+const get_build_file_1 = require("./parser/get-build-file");
+const work_scope_1 = require("./executer/work-scope");
+const get_work_context_1 = require("./get-work-context");
+const log_1 = require("./log");
+const label_values_1 = require("./executer/label-values");
+async function createCli(fileName, environment, workScope) {
+    const buildFile = await (0, get_build_file_1.getBuildFile)(fileName, environment);
+    const workTree = (0, get_work_context_1.getWorkScope)(buildFile, workScope, environment);
+    return (0, cli_1.getCli)(workTree, environment);
+}
+exports.createCli = createCli;
+function parseWorkScope(options) {
+    const scope = (0, work_scope_1.emptyWorkLabelScope)();
+    if (typeof options !== 'object') {
+        return scope;
+    }
+    if (options === undefined || options === null) {
+        return scope;
+    }
+    for (const [key, value] of Object.entries(options)) {
+        if (key === 'filter' && value instanceof Array) {
+            scope.filterLabels = (0, parse_label_arguments_1.parseLabelArguments)(value);
+        }
+        else if (key === 'exclude' && value instanceof Array) {
+            scope.excludeLabels = (0, parse_label_arguments_1.parseLabelArguments)(value);
+        }
+    }
+    return scope;
+}
 async function getProgram(environment, argv) {
     const program = new commander_1.Command();
     const args = [...argv];
     const fileIndex = args.indexOf('--file');
-    const fileName = path_1.join(environment.cwd, fileIndex >= 0 ? args[fileIndex + 1] : 'build.yaml');
+    const fileName = (0, path_1.join)(environment.cwd, fileIndex >= 0 ? args[fileIndex + 1] : 'build.yaml');
     if (fileIndex >= 0) {
         args.splice(fileIndex, 2);
     }
     if (await environment.file.exists(fileName)) {
-        const buildFile = await get_build_file_1.getBuildFile(fileName, environment);
-        const workNodes = plan_work_nodes_1.planWorkNodes(buildFile);
-        const reservedCommands = ['clean', 'store', 'restore', 'validate'];
         program
-            .command('clean')
-            .description('clear task cache')
-            .action(async () => {
-            try {
-                await clean_1.clean(workNodes, environment);
+            .command('ls')
+            .description('list all tasks')
+            .addOption(new commander_1.Option('-f, --filter <labels...>', 'filter task and services with labels'))
+            .addOption(new commander_1.Option('-e, --exclude <labels...>', 'exclude task and services with labels'))
+            .action(async (options) => {
+            const cli = await createCli(fileName, environment, parseWorkScope(options));
+            const items = cli.ls();
+            const tasks = items.filter(cli_1.isCliTask);
+            const services = items.filter(cli_1.isCliService);
+            if (services.length > 0) {
+                (0, log_1.printTitle)('Services');
+                for (const node of services) {
+                    (0, log_1.printItem)(node.item);
+                    (0, log_1.printProperty)('ports', node.item.ports.map((p) => `127.0.0.1:${p.hostPort} -> ${p.containerPort}`).join(', '));
+                    if (node.item.type === 'kubernetes-service') {
+                        (0, log_1.printProperty)('context', node.item.context);
+                        (0, log_1.printProperty)('selector', `${node.item.selector.type}/${node.item.selector.name}`);
+                    }
+                    else {
+                        (0, log_1.printProperty)('image', node.item.image);
+                    }
+                }
             }
-            catch (e) {
-                environment.console.error(e);
-                process.exit(1);
+            if (tasks.length > 0 && services.length > 0) {
+                process.stdout.write('\n');
             }
+            if (tasks.length > 0) {
+                (0, log_1.printTitle)('Tasks');
+                for (const node of tasks) {
+                    (0, log_1.printItem)(node.item);
+                    if (node.item.needs.length > 0) {
+                        (0, log_1.printProperty)('needs', node.item.needs.map((d) => d.name).join(', '));
+                    }
+                    if (node.item.deps.length > 0) {
+                        (0, log_1.printProperty)('deps', node.item.deps.map((d) => d.name).join(', '));
+                    }
+                    if (node.item.type === 'container') {
+                        (0, log_1.printProperty)('image', node.item.image);
+                    }
+                    if (node.item.caching) {
+                        (0, log_1.printProperty)('caching', node.item.caching);
+                    }
+                    if ((0, label_values_1.hasLabels)(node.item.labels)) {
+                        (0, log_1.printProperty)('labels', `${Object.keys(node.item.labels)
+                            .map((key) => `${key}=${node.item.labels[key].join(',')}`)
+                            .join(' ')}`);
+                    }
+                    if (node.item.src.length > 0) {
+                        (0, log_1.printProperty)('src', node.item.src.map((d) => (0, path_1.relative)(node.item.cwd, d.absolutePath)).join(' '));
+                    }
+                    if (node.item.generates.length > 0) {
+                        (0, log_1.printProperty)('generates', node.item.generates.map((d) => (0, path_1.relative)(node.item.cwd, d.path)).join(' '));
+                    }
+                }
+            }
+            process.stdout.write('\n');
+        });
+        program
+            .command('clean')
+            .description('clear task cache')
+            .addOption(new commander_1.Option('--service', 'clean data volumes of services'))
+            .addOption(new commander_1.Option('-f, --filter <labels...>', 'filter task and services with labels'))
+            .addOption(new commander_1.Option('-e, --exclude <labels...>', 'exclude task and services with labels'))
+            .action(async (options) => {
+            const cli = await createCli(fileName, environment, parseWorkScope(options));
+            await cli.clean({
+                service: options.service,
+            });
         });
         program
             .command('store <path>')
             .description('save task outputs into <path>')
-            .action(async (path) => {
-            try {
-                await store_1.store(workNodes, path, environment);
-            }
-            catch (e) {
-                environment.console.error(e);
-                process.exit(1);
-            }
+            .addOption(new commander_1.Option('-f, --filter <labels...>', 'filter task and services with labels'))
+            .addOption(new commander_1.Option('-e, --exclude <labels...>', 'exclude task and services with labels'))
+            .action(async (path, options) => {
+            const cli = await createCli(fileName, environment, parseWorkScope(options));
+            await cli.store((0, path_1.resolve)(path));
         });
         program
             .command('restore <path>')
             .description('restore task outputs from <path>')
-            .action(async (path) => {
-            try {
-                await restore_1.restore(workNodes, path, environment);
-            }
-            catch (e) {
-                environment.console.error(e);
-                process.exit(1);
-            }
+            .addOption(new commander_1.Option('-f, --filter <labels...>', 'filter task and services with labels'))
+            .addOption(new commander_1.Option('-e, --exclude <labels...>', 'exclude task and services with labels'))
+            .action(async (path, options) => {
+            const cli = await createCli(fileName, environment, parseWorkScope(options));
+            await cli.restore((0, path_1.resolve)(path));
         });
         program
             .command('validate')
             .description('validate build.yaml')
-            .action(async () => {
+            .addOption(new commander_1.Option('-f, --filter <labels...>', 'filter task and services with labels'))
+            .addOption(new commander_1.Option('-e, --exclude <labels...>', 'exclude task and services with labels'))
+            .action(async (options) => {
             let errors = 0;
-            for await (const validation of validate_1.validate(buildFile, environment)) {
+            const cli = await createCli(fileName, environment, parseWorkScope(options));
+            for await (const validation of cli.validate()) {
                 if (validation.type === 'error') {
                     errors++;
                     environment.console.error(validation.message);
@@ -78,56 +149,46 @@ async function getProgram(environment, argv) {
                     environment.console.warn(validation.message);
                 }
             }
-            if (errors === 0) {
-                process.exit(0);
-            }
-            else {
-                process.exit(1);
+            if (errors !== 0) {
+                program.error('Detected errors in your build.yaml', { exitCode: 1 });
             }
         });
-        for (const node of plan_work_nodes_1.iterateWorkNodes(workNodes)) {
-            if (reservedCommands.indexOf(node.name) >= 0) {
-                environment.console.warn(`${node.name} is reserved, please use another name`);
-                continue;
-            }
-            program
-                .command(node.name)
-                .description(node.description || '')
-                .option('-c, --concurrency <number>', 'parallel worker count', parseInt, 4)
-                .addOption(new commander_1.Option('-w, --watch', 'watch tasks').default(false))
-                .addOption(new commander_1.Option('-l, --log <mode>', 'log mode')
-                .default(ci_1.isCI ? 'live' : 'interactive')
-                .choices(['interactive', 'live', 'grouped']))
-                .addOption(new commander_1.Option('--cache <method>', 'caching method to compare')
-                .default(ci_1.isCI ? 'checksum' : 'modify-date')
-                .choices(['checksum', 'modify-date', 'none']))
-                .addOption(new commander_1.Option('--no-container', 'run every task locally without containers').default(false))
-                .action(async (options) => {
-                const executionContext = {
-                    workers: options.concurrency,
-                    cacheMethod: options.cache,
-                    watch: options.watch,
-                    events: emitter_1.emitter(),
-                    executor: options.container ? get_docker_executor_1.getDockerExecutor() : get_local_executor_1.getLocalExecutor(),
-                    environment: environment,
-                    runningNodes: {},
-                };
-                const logger = get_logger_1.getLogger(options.log);
-                try {
-                    const workTree = plan_work_tree_1.planWorkTree(buildFile, node.name);
-                    logger.start(executionContext, workTree);
-                    const result = await execute_1.execute(workTree, executionContext);
-                    await logger.finish(workTree, result);
-                    if (!result.success) {
-                        process.exit(1);
-                    }
-                }
-                catch (e) {
-                    logger.abort(e);
-                    process.exit(1);
-                }
+        program
+            .command('shutdown')
+            .description('end all container tasks/services')
+            .arguments('[task]')
+            .addOption(new commander_1.Option('-f, --filter <labels...>', 'filter task and services with labels'))
+            .addOption(new commander_1.Option('-e, --exclude <labels...>', 'exclude task and services with labels'))
+            .action(async (task, options) => {
+            const cli = await createCli(fileName, environment, task ? { taskName: task } : parseWorkScope(options));
+            cli.shutdown();
+        });
+        program
+            .command('exec', { isDefault: true })
+            .description('execute task(s)')
+            .arguments('[task]')
+            .addOption(new commander_1.Option('-f, --filter <labels...>', 'filter task and services with labels'))
+            .addOption(new commander_1.Option('-e, --exclude <labels...>', 'exclude task and services with labels'))
+            .addOption(new commander_1.Option('-c, --concurrency <number>', 'parallel worker count').argParser(parseInt).default(4))
+            .addOption(new commander_1.Option('-w, --watch', 'watch tasks').default(false))
+            .addOption(new commander_1.Option('-l, --log <mode>', 'log mode')
+            .default(ci_1.isCI ? 'live' : 'interactive')
+            .choices(['interactive', 'live', 'grouped']))
+            .addOption(new commander_1.Option('--cache <method>', 'caching method to compare')
+            .default(ci_1.isCI ? 'checksum' : 'modify-date')
+            .choices(['checksum', 'modify-date', 'none']))
+            .action(async (task, options) => {
+            const cli = await createCli(fileName, environment, task ? { taskName: task } : parseWorkScope(options));
+            const result = await cli.exec({
+                cacheDefault: options.cache,
+                watch: options.watch,
+                workers: options.concurrency,
+                logMode: options.log,
             });
-        }
+            if (!result.success) {
+                program.error('Execution was not successful', { exitCode: 1 });
+            }
+        });
     }
     else {
         if (fileIndex >= 0) {
@@ -153,7 +214,10 @@ tasks:
     program.version(require('../package.json').version);
     program.option('--verbose', 'log debugging information', false);
     program.option('--file', 'set build file', 'build.yaml');
-    program.name('hammerkit');
+    program.configureOutput({
+        writeOut: (str) => environment.console.info(str),
+        writeErr: (str) => environment.console.error(str),
+    });
     return { program, args };
 }
 exports.getProgram = getProgram;

package/dist/program.spec.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const program_1 = require("./program");
+const environment_mock_1 = require("./executer/environment-mock");
+describe('program', () => {
+    async function testCommand(commandArgs) {
+        const fileName = (0, path_1.join)(__dirname, '../examples/program');
+        const context = (0, environment_mock_1.environmentMock)(fileName);
+        const { program, args } = await (0, program_1.getProgram)(context, [process.argv[0], fileName, ...commandArgs]);
+        return program.exitOverride().parseAsync(args);
+    }
+    it('should run when cache is up to date and --no-cache arg is passed', async () => {
+        await testCommand(['example', '--cache', 'none']);
+    }, 120000);
+    it('should warn about invalid task name', async () => {
+        await expect(testCommand(['example2'])).rejects.toThrow();
+    });
+});
+//# sourceMappingURL=program.spec.js.map

package/dist/start-watch-processes.js

@@ -0,0 +1,28 @@
+"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");
+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({ type: 'task', id: node.node.id + '-watch', name: node.node.name }, (0, watch_node_1.watchNode)(node.node, state, processManager, 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({ type: 'service', id: service.service.id + '-watch', name: service.service.name }, (0, watch_service_1.watchService)(service.service, state, processManager, environment));
+        }
+    }
+}
+exports.startWatchProcesses = startWatchProcesses;
+//# sourceMappingURL=start-watch-processes.js.map