hammerkit 1.5.1 → 1.6.0-alpha.2

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

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLocalWorkRuntime = void 0;
+const tar_1 = require("tar");
+const path_1 = require("path");
+const local_task_1 = require("../executer/local-task");
+const event_cache_1 = require("../executer/event-cache");
+const find_process_1 = __importDefault(require("find-process"));
+function getStateFilename(task) {
+    return (0, path_1.join)(task.data.cwd, '.hammerkit', `${task.id()}`);
+}
+function getPidFilename(task) {
+    return (0, path_1.join)(task.data.cwd, '.hammerkit', `${task.id()}.pid`);
+}
+async function readActivePid(task, environment) {
+    const pidFile = getPidFilename(task);
+    if (!(await environment.file.exists(pidFile))) {
+        return null;
+    }
+    const pid = parseInt((await environment.file.read(pidFile)).trim(), 10);
+    if (!pid || pid === process.pid) {
+        return null;
+    }
+    const processes = await (0, find_process_1.default)('pid', pid);
+    if (processes.length === 0) {
+        await environment.file.remove(pidFile);
+        return null;
+    }
+    return pid;
+}
+function getLocalWorkRuntime(task) {
+    return {
+        async initialize() {
+            // pidfile check happens in execute (initialize has no Environment in scope)
+        },
+        async restore(environment, path) {
+            await restoreLocal(environment, task.data, path);
+        },
+        async archive(environment, path) {
+            await archiveLocal(environment, task, path);
+        },
+        async execute(environment, options) {
+            const activePid = await readActivePid(task, environment);
+            if (activePid !== null) {
+                options.state.set({
+                    type: 'error',
+                    stateKey: options.stateKey,
+                    errorMessage: `task ${task.name} is already running (pid ${activePid})`,
+                });
+                return;
+            }
+            await environment.file.createDirectory((0, path_1.join)(task.data.cwd, '.hammerkit'));
+            const pidFile = getPidFilename(task);
+            await environment.file.writeFile(pidFile, `${process.pid}`);
+            try {
+                await (0, local_task_1.localTask)(task, environment, options);
+                await environment.file.writeFile(getStateFilename(task), options.stateKey);
+            }
+            finally {
+                if (await environment.file.exists(pidFile)) {
+                    await environment.file.remove(pidFile);
+                }
+            }
+        },
+        async stop() {
+            // pidfile is cleaned up by execute()'s finally block; stale entries are
+            // detected by readActivePid() on the next run.
+        },
+        async currentStateKey(environment) {
+            const stateFileName = getStateFilename(task);
+            if (await environment.file.exists(stateFileName)) {
+                return await environment.file.read(stateFileName);
+            }
+            return Promise.resolve(null);
+        },
+        async remove(environment) {
+            for (const generate of task.data.generates) {
+                if (generate.inherited) {
+                    continue;
+                }
+                task.status.write('info', `remove local directory ${generate.path}`);
+                await environment.file.remove(generate.path);
+            }
+        },
+    };
+}
+exports.getLocalWorkRuntime = getLocalWorkRuntime;
+async function archiveLocal(environment, task, path) {
+    for (const generatedArchive of (0, event_cache_1.getArchivePaths)(task.data, path)) {
+        await environment.file.writeStream(generatedArchive.filename, (0, tar_1.create)({
+            cwd: task.data.cwd,
+            gzip: true,
+        }, [(0, path_1.relative)(task.data.cwd, generatedArchive.path)]));
+    }
+}
+async function restoreLocal(environment, task, path) {
+    for (const generate of (0, event_cache_1.getArchivePaths)(task, path)) {
+        if (await environment.file.exists(generate.filename)) {
+            await (0, tar_1.extract)({
+                file: generate.filename,
+                cwd: task.cwd,
+            });
+        }
+    }
+}
+//# sourceMappingURL=work-runtime-local.js.map

package/dist/planner/work-runtime-local.spec.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const os_1 = require("os");
+const fs_1 = require("fs");
+const work_runtime_local_1 = require("./work-runtime-local");
+const environment_mock_1 = require("../executer/environment-mock");
+const state_1 = require("../executer/state");
+const mockFindProcess = vi.hoisted(() => vi.fn());
+vi.mock('find-process', () => ({
+    __esModule: true,
+    default: (...args) => mockFindProcess(...args),
+}));
+vi.mock('../executer/local-task', () => ({
+    localTask: vi.fn().mockResolvedValue(undefined),
+}));
+function makeTask(cwd) {
+    return {
+        id: () => 'task-1',
+        name: 'task-1',
+        status: { write: vi.fn() },
+        data: {
+            type: 'local-task',
+            name: 'task-1',
+            cwd,
+            cmds: [],
+            generates: [],
+            src: [],
+            envs: { variables: {}, processEnvs: {} },
+            labels: {},
+            shell: '/bin/sh',
+            continuous: false,
+            caching: {
+                name: 'none',
+                method: 'none',
+                backend: {
+                    type: 'local',
+                    has: async () => false,
+                    pull: async () => false,
+                    push: async () => { },
+                    clear: async () => { },
+                },
+                implicit: true,
+            },
+            description: null,
+            scope: {},
+        },
+        needs: [],
+        deps: [],
+        requiredBy: [],
+    };
+}
+describe('local task pidfile', () => {
+    let cwd;
+    beforeEach(() => {
+        cwd = (0, fs_1.mkdtempSync)((0, path_1.join)((0, os_1.tmpdir)(), 'hammerkit-pidfile-'));
+        mockFindProcess.mockReset();
+    });
+    afterEach(() => {
+        (0, fs_1.rmSync)(cwd, { recursive: true, force: true });
+    });
+    it('writes pidfile during execute and cleans up after', async () => {
+        const task = makeTask(cwd);
+        const runtime = (0, work_runtime_local_1.getLocalWorkRuntime)(task);
+        const env = (0, environment_mock_1.environmentMock)(cwd);
+        const state = new state_1.State({ type: 'pending', stateKey: null });
+        await runtime.execute(env, {
+            stateKey: 'state-1',
+            abort: new AbortController().signal,
+            state,
+            cache: {
+                cached: false,
+                stateKey: 'state-x',
+                resolved: {
+                    name: 'none',
+                    method: 'none',
+                    backend: {
+                        type: 'local',
+                        has: async () => false,
+                        pull: async () => false,
+                        push: async () => { },
+                        clear: async () => { },
+                    },
+                    implicit: true,
+                },
+            },
+            daemon: false,
+        });
+        expect(await env.file.exists((0, path_1.join)(cwd, '.hammerkit', 'task-1.pid'))).toBe(false);
+        expect(await env.file.exists((0, path_1.join)(cwd, '.hammerkit', 'task-1'))).toBe(true);
+    });
+    it('removes a stale pidfile when the process is not alive', async () => {
+        const task = makeTask(cwd);
+        const runtime = (0, work_runtime_local_1.getLocalWorkRuntime)(task);
+        const env = (0, environment_mock_1.environmentMock)(cwd);
+        const state = new state_1.State({ type: 'pending', stateKey: null });
+        await env.file.createDirectory((0, path_1.join)(cwd, '.hammerkit'));
+        (0, fs_1.writeFileSync)((0, path_1.join)(cwd, '.hammerkit', 'task-1.pid'), '999999');
+        mockFindProcess.mockResolvedValueOnce([]);
+        await runtime.execute(env, {
+            stateKey: 'state-2',
+            abort: new AbortController().signal,
+            state,
+            cache: {
+                cached: false,
+                stateKey: 'state-x',
+                resolved: {
+                    name: 'none',
+                    method: 'none',
+                    backend: {
+                        type: 'local',
+                        has: async () => false,
+                        pull: async () => false,
+                        push: async () => { },
+                        clear: async () => { },
+                    },
+                    implicit: true,
+                },
+            },
+            daemon: false,
+        });
+        expect(state.current.type).not.toBe('error');
+        expect(mockFindProcess).toHaveBeenCalledWith('pid', 999999);
+    });
+    it('refuses to run when the pidfile points at a live process', async () => {
+        const task = makeTask(cwd);
+        const runtime = (0, work_runtime_local_1.getLocalWorkRuntime)(task);
+        const env = (0, environment_mock_1.environmentMock)(cwd);
+        const state = new state_1.State({ type: 'pending', stateKey: null });
+        await env.file.createDirectory((0, path_1.join)(cwd, '.hammerkit'));
+        (0, fs_1.writeFileSync)((0, path_1.join)(cwd, '.hammerkit', 'task-1.pid'), '12345');
+        mockFindProcess.mockResolvedValueOnce([{ pid: 12345, name: 'node' }]);
+        await runtime.execute(env, {
+            stateKey: 'state-3',
+            abort: new AbortController().signal,
+            state,
+            cache: {
+                cached: false,
+                stateKey: 'state-x',
+                resolved: {
+                    name: 'none',
+                    method: 'none',
+                    backend: {
+                        type: 'local',
+                        has: async () => false,
+                        pull: async () => false,
+                        push: async () => { },
+                        clear: async () => { },
+                    },
+                    implicit: true,
+                },
+            },
+            daemon: false,
+        });
+        expect(state.current.type).toBe('error');
+        if (state.current.type === 'error') {
+            expect(state.current.errorMessage).toMatch(/already running.*12345/);
+        }
+    });
+    it('does not block when the pidfile contains our own pid', async () => {
+        const task = makeTask(cwd);
+        const runtime = (0, work_runtime_local_1.getLocalWorkRuntime)(task);
+        const env = (0, environment_mock_1.environmentMock)(cwd);
+        const state = new state_1.State({ type: 'pending', stateKey: null });
+        await env.file.createDirectory((0, path_1.join)(cwd, '.hammerkit'));
+        (0, fs_1.writeFileSync)((0, path_1.join)(cwd, '.hammerkit', 'task-1.pid'), `${process.pid}`);
+        await runtime.execute(env, {
+            stateKey: 'state-4',
+            abort: new AbortController().signal,
+            state,
+            cache: {
+                cached: false,
+                stateKey: 'state-x',
+                resolved: {
+                    name: 'none',
+                    method: 'none',
+                    backend: {
+                        type: 'local',
+                        has: async () => false,
+                        pull: async () => false,
+                        push: async () => { },
+                        clear: async () => { },
+                    },
+                    implicit: true,
+                },
+            },
+            daemon: false,
+        });
+        expect(state.current.type).not.toBe('error');
+        expect(mockFindProcess).not.toHaveBeenCalled();
+    });
+});
+//# sourceMappingURL=work-runtime-local.spec.js.map

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

@@ -2,11 +2,21 @@
 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,
-    });
+const work_service_1 = require("./work-service");
+function getWorkServiceId(service) {
+    const jsonData = JSON.stringify((0, work_service_1.isContainerWorkService)(service)
+        ? {
+            cwd: service.cwd ?? undefined,
+            image: service.image,
+            volumes: service.volumes.map((v) => `${v.name}:${v.containerPath}`).sort(),
+            src: service.src.map((s) => s.absolutePath).sort(),
+            mounts: service.mounts.map((m) => m.mount).sort(),
+        }
+        : {
+            context: service.context,
+            selector: service.selector,
+            kubeconfig: service.kubeconfig,
+        });
     return (0, crypto_1.createHash)('sha1').update(jsonData).digest('hex');
 }
 exports.getWorkServiceId = getWorkServiceId;

package/dist/planner/work-source.js

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

package/dist/planner/work-task.js

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

package/dist/program-commands.spec.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const test_case_1 = require("./testing/test-case");
+// Fast unit-suite coverage for program.ts: every command that does not actually
+// run a container (ls, validate, clean --cache, init, --file, unknown task).
+// The slow container-running cases (run, package, up/down) live in
+// `program.spec.ts` and run in the integration suite.
+//
+// shell() forwards args to commander via `[env.cwd, ...args]`, and commander's
+// default `from: 'node'` consumes the first two slots as node+script. So args
+// must start with a script-name placeholder (matching how production receives
+// process.argv); the real command starts at index 1.
+const HK = 'hammerkit';
+describe('program commands (fast)', () => {
+    it('ls lists tasks and services without running them', async () => {
+        const t = (0, test_case_1.createTestCase)('cmd-ls', {
+            '.hammerkit.yaml': {
+                services: { api: { image: 'nginx', ports: [] } },
+                tasks: {
+                    build: { cmds: ['true'], description: 'build it', labels: { tier: 'backend' } },
+                },
+            },
+        });
+        await t.shell([HK, 'ls']);
+    });
+    it('ls --filter narrows by label', async () => {
+        const t = (0, test_case_1.createTestCase)('cmd-ls-filter', {
+            '.hammerkit.yaml': {
+                tasks: {
+                    build: { cmds: ['true'], labels: { app: 'web' } },
+                    lint: { cmds: ['true'], labels: { app: 'tool' } },
+                },
+            },
+        });
+        await t.shell([HK, 'ls', '--filter', 'app=web']);
+    });
+    it('validate returns cleanly for a healthy build file', async () => {
+        const t = (0, test_case_1.createTestCase)('cmd-validate-ok', {
+            '.hammerkit.yaml': {
+                tasks: { build: { description: 'build it', cmds: ['true'] } },
+            },
+        });
+        await t.shell([HK, 'validate']);
+    });
+    it('validate exits non-zero when a cycle is detected', async () => {
+        const t = (0, test_case_1.createTestCase)('cmd-validate-cycle', {
+            '.hammerkit.yaml': {
+                tasks: {
+                    a: { description: 'a', cmds: ['true'], deps: ['b'] },
+                    b: { description: 'b', cmds: ['true'], deps: ['a'] },
+                },
+            },
+        });
+        await expect(t.shell([HK, 'validate'])).rejects.toThrow('Detected errors');
+    });
+    it('clean --cache clears the backend cache (no container ops)', async () => {
+        const t = (0, test_case_1.createTestCase)('cmd-clean-cache', {
+            '.hammerkit.yaml': {
+                tasks: { build: { cmds: ['true'] } },
+            },
+        });
+        await t.shell([HK, 'clean', '--cache']);
+    });
+    it('init writes a default .hammerkit.yaml when none exists', async () => {
+        // empty fixture so getBuildFilename finds nothing; only the `init` command is registered then
+        const t = (0, test_case_1.createTestCase)('cmd-init', {});
+        await t.shell([HK, 'init']);
+    });
+    it('errors when the requested task does not exist', async () => {
+        const t = (0, test_case_1.createTestCase)('cmd-unknown-task', {
+            '.hammerkit.yaml': { tasks: { example: { cmds: ['true'] } } },
+        });
+        await expect(t.shell([HK, 'run', 'no-such-task'])).rejects.toThrow('No tasks found');
+    });
+    it('--file selects a non-default build file', async () => {
+        const t = (0, test_case_1.createTestCase)('cmd-file-arg', {
+            'custom.yaml': {
+                tasks: { only: { description: 'only', cmds: ['true'] } },
+            },
+        });
+        await t.shell([HK, '--file', 'custom.yaml', 'ls']);
+    });
+});
+//# sourceMappingURL=program-commands.spec.js.map