hammerkit 1.4.0 → 1.5.0-alpha.0

package/dist/executer/kubernetes-service.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kubernetesService = void 0;
+const child_process_1 = require("child_process");
+const log_1 = require("../log");
+const abort_event_1 = require("../utils/abort-event");
+const sleep_1 = require("../utils/sleep");
+function kubernetesService(service, stateKey, state, env) {
+    return async (abort) => {
+        const status = env.status.service(service);
+        do {
+            await startForward(service, stateKey, state, status, abort);
+            if (!abort.signal.aborted) {
+                await (0, sleep_1.sleep)(1000);
+            }
+        } while (!abort.signal.aborted);
+    };
+}
+exports.kubernetesService = kubernetesService;
+function startForward(service, stateKey, state, status, abort) {
+    const cmd = `kubectl port-forward ${service.selector.type}/${service.selector.name} --kubeconfig ${service.kubeconfig} --context ${service.context} ${service.ports.map((p) => `${p.hostPort}:${p.containerPort}`).join(' ')}`;
+    const ps = (0, child_process_1.exec)(cmd, {});
+    return new Promise((resolve) => {
+        ps.stdout?.on('data', async (data) => {
+            for (const log of (0, log_1.getLogs)(data)) {
+                status.console('stdout', log);
+            }
+            state.patchService({
+                service,
+                type: 'running',
+                dns: { host: 'host-gateway' },
+                stateKey,
+            });
+        });
+        ps.stderr?.on('data', async (data) => {
+            for (const log of (0, log_1.getLogs)(data)) {
+                status.console('stderr', log);
+            }
+        });
+        ps.on('error', (err) => {
+            status.write('error', (0, log_1.getErrorMessage)(err));
+            state.patchService({
+                service,
+                type: 'end',
+                reason: 'crash',
+                stateKey,
+            });
+        });
+        ps.on('close', (code) => {
+            status.write('info', `exit with ${code}`);
+            state.patchService({
+                service,
+                type: 'end',
+                reason: 'crash',
+                stateKey,
+            });
+            resolve();
+        });
+    });
+    (0, abort_event_1.listenOnAbort)(abort.signal, () => {
+        ps.kill();
+    });
+}
+//# sourceMappingURL=kubernetes-service.js.map

package/dist/executer/label-values.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchesAnyLabel = exports.hasDependencyWithMatch = exports.hasNeedsWithMatch = exports.matchesAllLabels = exports.hasLabels = void 0;
+function hasLabels(labels) {
+    return Object.keys(labels).length > 0;
+}
+exports.hasLabels = hasLabels;
+function matchesAllLabels(filterLabels, node, nodes) {
+    for (const [labelKey, filterValues] of Object.entries(filterLabels)) {
+        const nodeValues = node.labels[labelKey];
+        if (nodeValues === null || nodeValues === undefined || nodeValues.length === 0) {
+            if (!hasNeedsWithMatch(node, nodes, (depNode) => matchesAllLabels(filterLabels, depNode, nodes))) {
+                return false;
+            }
+        }
+        for (const nodeValue of nodeValues || []) {
+            if (filterValues.indexOf(nodeValue) === -1) {
+                if (!hasNeedsWithMatch(node, nodes, (depNode) => matchesAllLabels(filterLabels, depNode, nodes))) {
+                    return false;
+                }
+            }
+        }
+    }
+    return true;
+}
+exports.matchesAllLabels = matchesAllLabels;
+function hasNeedsWithMatch(root, nodes, matcher) {
+    for (const node of Object.values(nodes)) {
+        if (node.deps.some((d) => d.id === root.id)) {
+            if (matcher(node)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+exports.hasNeedsWithMatch = hasNeedsWithMatch;
+function hasDependencyWithMatch(root, matcher) {
+    for (const dep of root.deps) {
+        if (matcher(dep)) {
+            return true;
+        }
+    }
+    return false;
+}
+exports.hasDependencyWithMatch = hasDependencyWithMatch;
+function matchesAnyLabel(filterLabels, node) {
+    if (!hasLabels(filterLabels)) {
+        return false;
+    }
+    for (const [labelKey, filterValues] of Object.entries(filterLabels)) {
+        const nodeValues = node.labels[labelKey];
+        if (nodeValues === null || nodeValues === undefined || nodeValues.length === 0) {
+            continue;
+        }
+        for (const nodeValue of nodeValues) {
+            if (filterValues.indexOf(nodeValue) >= 0) {
+                return true;
+            }
+        }
+    }
+    return hasDependencyWithMatch(node, (depNode) => matchesAnyLabel(filterLabels, depNode));
+}
+exports.matchesAnyLabel = matchesAnyLabel;
+//# sourceMappingURL=label-values.js.map

package/dist/executer/local-node.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.localNode = void 0;
+const abort_1 = require("./abort");
+const execute_command_1 = require("./execute-command");
+const write_work_node_cache_1 = require("../optimizer/write-work-node-cache");
+const log_1 = require("../log");
+const states_1 = require("./states");
+function localNode(node, stateKey, state, environment) {
+    return async (abort, started) => {
+        const status = environment.status.task(node);
+        status.write('info', `execute ${node.name} locally`);
+        try {
+            for (const cmd of node.cmds) {
+                (0, abort_1.checkForAbort)(abort.signal);
+                status.write('info', `execute cmd "${cmd.cmd}" locally`);
+                const exitCode = await (0, execute_command_1.executeCommand)(status, abort.signal, cmd.path, cmd.cmd, node.envs);
+                if (exitCode !== 0) {
+                    state.patchNode({
+                        type: 'crash',
+                        node,
+                        exitCode,
+                        stateKey,
+                    }, stateKey);
+                    return;
+                }
+            }
+            await (0, write_work_node_cache_1.writeWorkNodeCache)(node, environment);
+            state.patchNode({
+                type: 'completed',
+                node: node,
+                cached: false,
+                stateKey,
+                duration: (0, states_1.getDuration)(started),
+            }, stateKey);
+        }
+        catch (e) {
+            if (e instanceof abort_1.AbortError) {
+                state.patchNode({
+                    type: 'canceled',
+                    node,
+                    stateKey,
+                }, stateKey);
+            }
+            else {
+                state.patchNode({
+                    type: 'error',
+                    node,
+                    stateKey,
+                    errorMessage: (0, log_1.getErrorMessage)(e),
+                }, stateKey);
+            }
+        }
+    };
+}
+exports.localNode = localNode;
+//# sourceMappingURL=local-node.js.map

package/dist/executer/print-container-options.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printContainerOptions = void 0;
+function printContainerOptions(status, containerOptions) {
+    status.write('debug', `create container with image ${containerOptions.Image} with ${containerOptions.Entrypoint}`);
+    for (const mount of containerOptions.HostConfig?.Binds || []) {
+        status.write('debug', `bind ${mount}`);
+    }
+    for (const mount of containerOptions.HostConfig?.Binds || []) {
+        status.write('debug', `bind ${mount}`);
+    }
+    for (const link of containerOptions.HostConfig?.Links || []) {
+        status.write('debug', `link ${link}`);
+    }
+}
+exports.printContainerOptions = printContainerOptions;
+//# sourceMappingURL=print-container-options.js.map

package/dist/{logging/log-strategy.js → executer/process-item.js}

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

package/dist/executer/process-listener.js

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

package/dist/executer/process-manager.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcessManager = void 0;
+const abort_event_1 = require("../utils/abort-event");
+const log_1 = require("../log");
+class ProcessManager {
+    constructor(env, workerLimit) {
+        this.env = env;
+        this.workerLimit = workerLimit;
+        this.processes = [];
+        this.pendingProcesses = [];
+        this.listeners = [];
+    }
+    on(listener) {
+        this.listeners.push(listener);
+    }
+    onComplete() {
+        if (this.processes.length === 0 && this.pendingProcesses.length === 0) {
+            return Promise.resolve();
+        }
+        return new Promise((resolve) => {
+            this.listeners.push((evt, processes, pending) => {
+                if (processes.length === 0 && pending.length === 0) {
+                    resolve();
+                }
+            });
+        });
+    }
+    abort(context) {
+        this.pendingProcesses = this.pendingProcesses.filter((p) => p.context.id !== context.id);
+        const processes = this.processes.filter((p) => p.context.id === context.id);
+        for (const process of processes) {
+            process.abortController.abort();
+        }
+    }
+    background(context, process) {
+        const abortController = new AbortController();
+        (0, abort_event_1.listenOnAbort)(this.env.abortCtrl.signal, () => {
+            abortController.abort();
+        });
+        this.startProcess({ process, context, abortController });
+        return abortController;
+    }
+    task(context, process) {
+        const abortController = new AbortController();
+        (0, abort_event_1.listenOnAbort)(this.env.abortCtrl.signal, () => {
+            abortController.abort();
+        });
+        const hasFreeWorker = this.workerLimit === 0 || this.workerLimit > this.processes.length;
+        if (hasFreeWorker) {
+            const hasBlockingProcess = this.processes.some((p) => p.context.id === context.id);
+            if (hasBlockingProcess) {
+                this.abort(context);
+                this.pendingProcesses.push({ context, process, abortController });
+            }
+            else {
+                this.startProcess({ process, context, abortController });
+            }
+        }
+        else {
+            this.pendingProcesses.push({ context, process, abortController });
+        }
+        return abortController;
+    }
+    enqueuePendingProcesses() {
+        const nextProcess = this.pendingProcesses[0];
+        if (nextProcess) {
+            const hasBlockingProcess = this.processes.some((p) => p.context.id === nextProcess.context.id);
+            if (hasBlockingProcess) {
+                return;
+            }
+        }
+        const pendingProcess = this.pendingProcesses.shift();
+        if (pendingProcess) {
+            this.startProcess(pendingProcess);
+        }
+    }
+    startProcess(pendingProcess) {
+        const started = new Date();
+        const item = {
+            context: pendingProcess.context,
+            started,
+            abortController: pendingProcess.abortController,
+            promise: pendingProcess
+                .process(pendingProcess.abortController, started)
+                .catch((err) => {
+                this.env.status.context(pendingProcess.context).write('error', (0, log_1.getErrorMessage)(err));
+            })
+                .finally(() => {
+                const index = this.processes.indexOf(item);
+                this.processes.splice(index, 1);
+                this.notifyListeners({ context: item.context, type: 'ended' });
+                this.enqueuePendingProcesses();
+            }),
+        };
+        this.processes.push(item);
+        this.notifyListeners({ context: item.context, type: 'started' });
+    }
+    notifyListeners(evt) {
+        for (const listener of this.listeners) {
+            try {
+                listener(evt, this.processes, this.pendingProcesses.map((p) => ({ context: p.context })));
+            }
+            catch (e) {
+                this.env.status.context(evt.context).write('error', (0, log_1.getErrorMessage)(e));
+            }
+        }
+    }
+}
+exports.ProcessManager = ProcessManager;
+//# sourceMappingURL=process-manager.js.map

package/dist/executer/process-manager.spec.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const process_manager_1 = require("./process-manager");
+const environment_mock_1 = require("./environment-mock");
+const abort_event_1 = require("../utils/abort-event");
+describe('process-manager', () => {
+    it('should complete on success', async () => {
+        const manager = new process_manager_1.ProcessManager((0, environment_mock_1.environmentMock)(process.cwd()), 0);
+        let currentIndex = 0;
+        const expectedEvents = ['started', 'ended'];
+        manager.on((evt) => {
+            expect(evt.type).toBe(expectedEvents[currentIndex++]);
+        });
+        manager.task({ type: 'task', name: 'test-success', id: 'a' }, () => new Promise((resolve) => setTimeout(() => resolve(), 100)));
+        await manager.onComplete();
+        expect(currentIndex).toBe(2);
+    });
+    it('should complete on error', async () => {
+        const manager = new process_manager_1.ProcessManager((0, environment_mock_1.environmentMock)(process.cwd()), 0);
+        let currentIndex = 0;
+        const expectedEvents = ['started', 'ended'];
+        manager.on((evt) => {
+            expect(evt.type).toBe(expectedEvents[currentIndex++]);
+        });
+        manager.task({ type: 'task', name: 'test-error', id: 'a' }, () => new Promise((resolve, reject) => setTimeout(() => reject(new Error('3')), 100)));
+        await manager.onComplete();
+        expect(currentIndex).toBe(2);
+    });
+    it('should not start more than worker count', async () => {
+        const manager = new process_manager_1.ProcessManager((0, environment_mock_1.environmentMock)(process.cwd()), 1);
+        const processes = [];
+        let concurrencyCount = 0;
+        let hasOversteppedLimits = false;
+        manager.on((evt) => {
+            if (evt.type === 'started') {
+                concurrencyCount++;
+            }
+            else if (evt.type === 'ended') {
+                concurrencyCount--;
+                processes.push(evt.context.id);
+            }
+            if (concurrencyCount > 1) {
+                hasOversteppedLimits = true;
+            }
+        });
+        manager.task({ type: 'task', name: 'test-success', id: 'a' }, () => new Promise((resolve) => setTimeout(() => resolve(), 100)));
+        manager.task({ type: 'task', name: 'test-success', id: 'b' }, () => new Promise((resolve) => setTimeout(() => resolve(), 100)));
+        manager.task({ type: 'task', name: 'test-success', id: 'c' }, () => new Promise((resolve) => setTimeout(() => resolve(), 100)));
+        await manager.onComplete();
+        expect(processes).toEqual(['a', 'b', 'c']);
+        expect(hasOversteppedLimits).toBeFalsy();
+        expect(concurrencyCount).toBe(0);
+    });
+    it('should terminate on abort', async () => {
+        const env = (0, environment_mock_1.environmentMock)(process.cwd());
+        const manager = new process_manager_1.ProcessManager(env, 0);
+        manager.task({ type: 'task', name: 'test-success', id: 'a' }, (abort) => new Promise((resolve) => {
+            (0, abort_event_1.listenOnAbort)(abort.signal, resolve);
+        }));
+        setTimeout(() => {
+            env.abortCtrl.abort();
+        }, 200);
+        await manager.onComplete();
+    });
+    it('should abort if task with same id is already started', async () => {
+        const manager = new process_manager_1.ProcessManager((0, environment_mock_1.environmentMock)(process.cwd()), 0);
+        const processes = [];
+        let concurrencyCount = 0;
+        let hasOversteppedLimits = false;
+        manager.on((evt) => {
+            if (evt.type === 'started') {
+                concurrencyCount++;
+            }
+            else if (evt.type === 'ended') {
+                concurrencyCount--;
+                processes.push(evt.context.id);
+            }
+            if (concurrencyCount > 1) {
+                hasOversteppedLimits = true;
+            }
+        });
+        const abortController = manager.task({ type: 'task', name: 'test-success', id: 'a' }, () => new Promise((resolve) => setTimeout(() => resolve(), 200)));
+        manager.task({ type: 'task', name: 'test-success', id: 'a' }, () => new Promise((resolve) => setTimeout(() => resolve(), 100)));
+        expect(abortController.signal.aborted).toBeTruthy();
+        await manager.onComplete();
+        expect(processes).toEqual(['a', 'a']);
+        expect(hasOversteppedLimits).toBeFalsy();
+        expect(concurrencyCount).toBe(0);
+    });
+});
+//# sourceMappingURL=process-manager.spec.js.map

package/dist/executer/{executor.js → process.js}

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

package/dist/executer/{execute-result.js → readonly-state.js}

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

package/dist/executer/schedule.js

@@ -0,0 +1,139 @@
+"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");
+const start_watch_processes_1 = require("../start-watch-processes");
+const start_node_1 = require("./start-node");
+async function schedule(processManager, state, environment) {
+    if (state.current.watch) {
+        (0, start_watch_processes_1.startWatchProcesses)(state, processManager, environment);
+    }
+    state.on((currentState) => {
+        for (const [, nodeState] of Object.entries(currentState.node)) {
+            if (nodeState.type === 'pending') {
+                const hasOpenDeps = nodeState.node.deps.some((dep) => currentState.node[dep.id].type !== 'completed');
+                if (hasOpenDeps) {
+                    continue;
+                }
+                state.patchNode({
+                    type: 'starting',
+                    node: nodeState.node,
+                    started: new Date(),
+                    stateKey: null,
+                }, nodeState.stateKey);
+                processManager.background({
+                    type: 'task',
+                    name: nodeState.node.name,
+                    id: nodeState.node.id + '-cache',
+                }, async () => {
+                    // TODO abort improvement
+                    await (0, start_node_1.startNode)(nodeState, state, environment);
+                });
+            }
+            else if (nodeState.type === 'ready') {
+                const endedNeeds = nodeState.node.needs
+                    .map((need) => currentState.service[need.id])
+                    .filter((service) => service.type === 'end' || service.type === 'canceled');
+                if (endedNeeds.length > 0) {
+                    state.patchNode({
+                        type: 'error',
+                        node: nodeState.node,
+                        stateKey: nodeState.stateKey,
+                        errorMessage: endedNeeds
+                            .map((n) => `service ${n.service.name} ${n.type === 'end' ? 'has ended ' + n.reason : 'was canceled'}`)
+                            .join(', '),
+                    }, nodeState.stateKey);
+                    continue;
+                }
+                const pendingNeeds = nodeState.node.needs
+                    .map((need) => currentState.service[need.id])
+                    .filter((service) => service.type === 'pending');
+                if (pendingNeeds.length > 0) {
+                    for (const pendingNeed of pendingNeeds) {
+                        state.patchService({
+                            type: 'starting',
+                            service: pendingNeed.service,
+                            stateKey: null,
+                        });
+                        processManager.background({
+                            type: 'service',
+                            name: pendingNeed.service.name,
+                            id: pendingNeed.service.id + '-cache',
+                        }, async () => {
+                            // TODO abort improvement
+                            await (0, start_node_1.startService)(pendingNeed.service, state, environment);
+                        });
+                    }
+                    continue;
+                }
+                const hasNotReadyNeeds = nodeState.node.needs.some((need) => currentState.service[need.id].type !== 'running');
+                if (hasNotReadyNeeds) {
+                    continue;
+                }
+                const serviceContainers = {};
+                for (const need of nodeState.node.needs) {
+                    const serviceState = currentState.service[need.id];
+                    if (serviceState.type === 'running') {
+                        serviceContainers[need.id] = serviceState.dns;
+                    }
+                }
+                state.patchNode({
+                    type: 'running',
+                    node: nodeState.node,
+                    stateKey: nodeState.stateKey,
+                    started: nodeState.started,
+                }, nodeState.stateKey);
+                const ctx = (0, work_node_status_1.logContext)('task', nodeState.node);
+                if ((0, work_node_1.isContainerWorkNode)(nodeState.node)) {
+                    processManager.task(ctx, (0, docker_node_1.dockerNode)(nodeState.node, nodeState.stateKey, serviceContainers, state, environment));
+                }
+                else {
+                    processManager.task(ctx, (0, local_node_1.localNode)(nodeState.node, nodeState.stateKey, state, environment));
+                }
+            }
+        }
+        for (const [serviceId, serviceState] of Object.entries(currentState.service)) {
+            if (serviceState.type === 'ready') {
+                const ctx = (0, work_node_status_1.logContext)('service', serviceState.service);
+                state.patchService({
+                    type: 'starting',
+                    service: serviceState.service,
+                    stateKey: serviceState.stateKey,
+                });
+                processManager.background(ctx, (0, work_service_1.isContainerWorkService)(serviceState.service)
+                    ? (0, docker_service_1.dockerService)(serviceState.service, serviceState.stateKey, state, environment)
+                    : (0, kubernetes_service_1.kubernetesService)(serviceState.service, serviceState.stateKey, state, environment));
+            }
+            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) {
+                const ctx = (0, work_node_status_1.logContext)('service', serviceState.service);
+                environment.status.service(serviceState.service).write('info', 'stop unused service');
+                processManager.abort(ctx);
+            }
+        }
+    });
+    await processManager.onComplete();
+    const success = !Object.values(state.current.node).some((n) => n.type !== 'completed');
+    return {
+        state: state.current,
+        success,
+    };
+}
+exports.schedule = schedule;
+//# sourceMappingURL=schedule.js.map

package/dist/executer/scheduler/check-for-loop.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkForLoop = void 0;
+const plan_work_nodes_1 = require("../../planner/utils/plan-work-nodes");
+const validate_1 = require("../../planner/validate");
+function checkForLoop(state) {
+    for (const nodeState of (0, plan_work_nodes_1.iterateWorkNodes)(state.node)) {
+        const cyclePath = (0, validate_1.hasCycle)(nodeState.node, []);
+        if (cyclePath && cyclePath.length > 0) {
+            const errorMessage = `task cycle detected ${cyclePath.map((n) => n.name).join(' -> ')}`;
+            state.node[nodeState.node.id] = {
+                type: 'error',
+                node: nodeState.node,
+                stateKey: null,
+                errorMessage,
+            };
+        }
+    }
+}
+exports.checkForLoop = checkForLoop;
+//# sourceMappingURL=check-for-loop.js.map

package/dist/executer/scheduler/enqueue-next.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkCacheState = void 0;
+const read_work_node_cache_1 = require("../../optimizer/read-work-node-cache");
+const get_work_node_cache_stats_1 = require("../../optimizer/get-work-node-cache-stats");
+async function checkCacheState(node, defaultCacheMethod, environment) {
+    const status = environment.status.task(node);
+    const caching = node.caching ?? defaultCacheMethod;
+    const currentStats = await (0, get_work_node_cache_stats_1.getWorkNodeCacheStats)(node, environment);
+    const stateKey = (0, get_work_node_cache_stats_1.getStateKey)(currentStats, caching);
+    if (caching === 'none') {
+        status.write('debug', `${node.name} is skipping cache check, because caching is disabled`);
+        return { cached: false, stateKey };
+    }
+    const cache = await (0, read_work_node_cache_1.readCache)(node, environment);
+    if (cache === null) {
+        status.write('debug', `${node.name} is skipping cache check, because there was none found`);
+        return { cached: false, stateKey };
+    }
+    const cacheKey = (0, get_work_node_cache_stats_1.getStateKey)(cache, caching);
+    return {
+        cached: cacheKey === stateKey,
+        stateKey,
+    };
+}
+exports.checkCacheState = checkCacheState;
+//# sourceMappingURL=enqueue-next.js.map

package/dist/{testing/test-context.js → executer/scheduler/node-state.js}

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

package/dist/executer/scheduler/scheduler-result.js

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

package/dist/executer/scheduler/scheduler-state.js

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

package/dist/executer/scheduler/service-state.js

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

package/dist/executer/service-dns.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isHostServiceDns = void 0;
+const isHostServiceDns = (val) => 'host' in val;
+exports.isHostServiceDns = isHostServiceDns;
+//# sourceMappingURL=service-dns.js.map

package/dist/executer/set-user-permission.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setUserPermission = void 0;
+const execute_docker_1 = require("./execute-docker");
+async function setUserPermission(directory, status, environment, container, user) {
+    status.write('debug', `set permission on ${directory}`);
+    const result = await (0, execute_docker_1.execCommand)(status, environment, container, '/', ['chown', user, directory], null, undefined, undefined);
+    if (result.type === 'canceled') {
+        return;
+    }
+    if (result.type === 'timeout' || result.result.ExitCode !== 0) {
+        status.write('warn', `unable to set permissions for ${directory}`);
+    }
+}
+exports.setUserPermission = setUserPermission;
+//# sourceMappingURL=set-user-permission.js.map