@kapeta/local-cluster-service 0.0.0-96f91ef

package/dist/esm/src/containerManager.js

@@ -0,0 +1,958 @@
+"use strict";
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.containerManager = exports.toLocalBindVolume = exports.getExtraHosts = exports.ContainerInfo = exports.HEALTH_CHECK_TIMEOUT = exports.COMPOSE_LABEL_SERVICE = exports.COMPOSE_LABEL_PROJECT = exports.CONTAINER_LABEL_PORT_PREFIX = void 0;
+const path_1 = __importDefault(require("path"));
+const storageService_1 = require("./storageService");
+const os_1 = __importDefault(require("os"));
+const lodash_1 = __importDefault(require("lodash"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const dockerode_1 = __importDefault(require("dockerode"));
+const nodejs_utils_1 = require("@kapeta/nodejs-utils");
+const local_cluster_config_1 = __importDefault(require("@kapeta/local-cluster-config"));
+const node_uuid_1 = __importDefault(require("node-uuid"));
+const md5_1 = __importDefault(require("md5"));
+const utils_1 = require("./utils/utils");
+const types_1 = require("./types");
+const nodejs_api_client_1 = require("@kapeta/nodejs-api-client");
+const taskManager_1 = require("./taskManager");
+const node_events_1 = require("node:events");
+const StreamValues_1 = __importDefault(require("stream-json/streamers/StreamValues"));
+exports.CONTAINER_LABEL_PORT_PREFIX = 'kapeta_port-';
+const NANO_SECOND = 1000000;
+const HEALTH_CHECK_INTERVAL = 3000;
+const HEALTH_CHECK_MAX = 100;
+const LATEST_PULL_TIMEOUT = 1000 * 60 * 15; // 15 minutes
+exports.COMPOSE_LABEL_PROJECT = 'com.docker.compose.project';
+exports.COMPOSE_LABEL_SERVICE = 'com.docker.compose.service';
+exports.HEALTH_CHECK_TIMEOUT = HEALTH_CHECK_INTERVAL * HEALTH_CHECK_MAX * 2;
+var DockerPullEventTypes;
+(function (DockerPullEventTypes) {
+    DockerPullEventTypes["PreparingPhase"] = "Preparing";
+    DockerPullEventTypes["WaitingPhase"] = "Waiting";
+    DockerPullEventTypes["PullingFsPhase"] = "Pulling fs layer";
+    DockerPullEventTypes["DownloadingPhase"] = "Downloading";
+    DockerPullEventTypes["DownloadCompletePhase"] = "Download complete";
+    DockerPullEventTypes["ExtractingPhase"] = "Extracting";
+    DockerPullEventTypes["VerifyingChecksumPhase"] = "Verifying Checksum";
+    DockerPullEventTypes["AlreadyExistsPhase"] = "Already exists";
+    DockerPullEventTypes["PullCompletePhase"] = "Pull complete";
+})(DockerPullEventTypes || (DockerPullEventTypes = {}));
+const processJsonStream = (purpose, stream, handler) => new Promise((resolve, reject) => {
+    const jsonStream = StreamValues_1.default.withParser();
+    jsonStream.on('data', (data) => {
+        try {
+            handler(data.value);
+        }
+        catch (e) {
+            console.error('Failed while processing data for stream: %s', purpose, e);
+        }
+    });
+    jsonStream.on('end', () => {
+        console.log('Docker stream ended: %s', purpose);
+        resolve();
+    });
+    jsonStream.on('error', (err) => {
+        console.error('Docker stream failed: %s', purpose, err);
+        reject(err);
+    });
+    stream.pipe(jsonStream);
+});
+class ContainerManager {
+    _docker;
+    _alive;
+    _mountDir;
+    _version;
+    _lastDockerAccessCheck = 0;
+    logStreams = {};
+    _latestImagePulls = {};
+    constructor() {
+        this._docker = null;
+        this._alive = false;
+        this._version = '';
+        this._mountDir = path_1.default.join(storageService_1.storageService.getKapetaBasedir(), 'mounts');
+        this._latestImagePulls = {};
+        fs_extra_1.default.mkdirpSync(this._mountDir);
+    }
+    async initialize() {
+        // Use the value from cluster-service.yml if configured
+        const dockerConfig = local_cluster_config_1.default.getDockerConfig();
+        const connectOptions = Object.keys(dockerConfig).length > 0
+            ? [dockerConfig]
+            : [
+                // use defaults: DOCKER_HOST etc from env, if available
+                undefined,
+                // default linux
+                { socketPath: '/var/run/docker.sock' },
+                // default macOS
+                {
+                    socketPath: path_1.default.join(os_1.default.homedir(), '.docker/run/docker.sock'),
+                },
+                // Default http
+                { protocol: 'http', host: 'localhost', port: 2375 },
+                { protocol: 'https', host: 'localhost', port: 2376 },
+                { protocol: 'http', host: '127.0.0.1', port: 2375 },
+                { protocol: 'https', host: '127.0.0.1', port: 2376 },
+            ];
+        for (const opts of connectOptions) {
+            try {
+                const testClient = new dockerode_1.default({
+                    ...opts,
+                    timeout: 1000, // 1 secs should be enough for a ping
+                });
+                await testClient.ping();
+                // If we get here - we have a working connection
+                // Now create a client with a longer timeout for all other operations
+                const client = new dockerode_1.default({
+                    ...opts,
+                    timeout: 15 * 60 * 1000, //15 minutes should be enough for any operation
+                });
+                this._docker = client;
+                const versionInfo = await client.version();
+                this._version = versionInfo.Server?.Version ?? versionInfo.Version;
+                if (!this._version) {
+                    console.warn('Failed to determine version from response', versionInfo);
+                    this._version = '0.0.0';
+                }
+                this._alive = true;
+                console.log('Connected to docker daemon with version: %s', this._version);
+                return;
+            }
+            catch (err) {
+                // silently ignore bad configs
+            }
+        }
+        throw new Error('Could not connect to docker daemon. Please make sure docker is running and working.');
+    }
+    async checkAlive() {
+        if (!this._docker) {
+            try {
+                await this.initialize();
+            }
+            catch (e) {
+                this._alive = false;
+            }
+            return this._alive;
+        }
+        try {
+            await this._docker.ping();
+            this._alive = true;
+        }
+        catch (e) {
+            this._alive = false;
+        }
+        return this._alive;
+    }
+    isAlive() {
+        return this._alive;
+    }
+    getMountPoint(systemId, ref, mountName) {
+        const kindUri = (0, nodejs_utils_1.parseKapetaUri)(ref);
+        const systemUri = (0, nodejs_utils_1.parseKapetaUri)(systemId);
+        return path_1.default.join(this._mountDir, systemUri.handle, systemUri.name, systemUri.version, kindUri.handle, kindUri.name, kindUri.version, mountName);
+    }
+    async createMounts(systemId, kind, mountOpts) {
+        const mounts = {};
+        if (mountOpts) {
+            const mountOptList = Object.entries(mountOpts);
+            for (const [mountName, containerPath] of mountOptList) {
+                const hostPath = this.getMountPoint(systemId, kind, mountName);
+                await fs_extra_1.default.mkdirp(hostPath);
+                mounts[containerPath] = hostPath;
+            }
+        }
+        return mounts;
+    }
+    async createVolumes(systemId, serviceId, mountOpts) {
+        const Mounts = [];
+        if (mountOpts) {
+            const mountOptList = Object.entries(mountOpts);
+            for (const [mountName, containerPath] of mountOptList) {
+                const volumeName = `${systemId}_${serviceId}_${mountName}`.replace(/[^a-z0-9]/gi, '_');
+                Mounts.push({
+                    Target: containerPath,
+                    Source: volumeName,
+                    Type: 'volume',
+                    ReadOnly: false,
+                    Consistency: 'consistent',
+                    Labels: {
+                        [exports.COMPOSE_LABEL_PROJECT]: systemId.replace(/[^a-z0-9]/gi, '_'),
+                        [exports.COMPOSE_LABEL_SERVICE]: serviceId.replace(/[^a-z0-9]/gi, '_'),
+                    },
+                });
+            }
+        }
+        return Mounts;
+    }
+    async ping() {
+        try {
+            const pingResult = await this.docker().ping();
+            if (pingResult !== 'OK') {
+                throw new Error(`Ping failed: ${pingResult}`);
+            }
+        }
+        catch (e) {
+            throw new Error(`Docker not running. Please start the docker daemon before running this command. Error: ${e.message}`);
+        }
+    }
+    docker() {
+        if (!this._docker) {
+            throw new Error(`Docker not running`);
+        }
+        return this._docker;
+    }
+    async getContainerByName(containerName) {
+        // The container can be fetched by name or by id using the same API call
+        return this.get(containerName);
+    }
+    async pull(image) {
+        let [imageName, tag] = image.split(/:/);
+        if (!tag) {
+            tag = 'latest';
+        }
+        const imageTagList = (await this.docker().listImages({}))
+            .filter((imageData) => !!imageData.RepoTags)
+            .map((imageData) => imageData.RepoTags);
+        const imageExists = imageTagList.some((imageTags) => imageTags.includes(image));
+        if (tag === 'latest') {
+            if (imageExists && this._latestImagePulls[imageName]) {
+                const lastPull = this._latestImagePulls[imageName];
+                const timeSinceLastPull = Date.now() - lastPull;
+                if (timeSinceLastPull < LATEST_PULL_TIMEOUT) {
+                    console.log('Image found and was pulled %s seconds ago: %s', Math.round(timeSinceLastPull / 1000), image);
+                    // Last pull was less than the timeout - don't pull again
+                    return false;
+                }
+            }
+            this._latestImagePulls[imageName] = Date.now();
+        }
+        else if (imageExists) {
+            console.log('Image found: %s', image);
+            return false;
+        }
+        let friendlyImageName = image;
+        const imageParts = imageName.split('/');
+        if (imageParts.length > 2) {
+            //Strip the registry to make the name shorter
+            friendlyImageName = `${imageParts.slice(1).join('/')}:${tag}`;
+        }
+        const taskName = `Pulling image ${friendlyImageName}`;
+        const processor = async (task) => {
+            const timeStarted = Date.now();
+            const api = new nodejs_api_client_1.KapetaAPI();
+            const accessToken = api.hasToken() ? await api.getAccessToken() : null;
+            const auth = accessToken && image.startsWith('docker.kapeta.com/')
+                ? {
+                    username: 'kapeta',
+                    password: accessToken,
+                    serveraddress: 'docker.kapeta.com',
+                }
+                : {};
+            const stream = await this.docker().pull(image, {
+                authconfig: auth,
+            });
+            const chunks = {};
+            let lastEmitted = Date.now();
+            await processJsonStream(`image:pull:${image}`, stream, (data) => {
+                if (!chunks[data.id]) {
+                    chunks[data.id] = {
+                        downloading: {
+                            total: 0,
+                            current: 0,
+                        },
+                        extracting: {
+                            total: 0,
+                            current: 0,
+                        },
+                        done: false,
+                    };
+                }
+                const chunk = chunks[data.id];
+                if (data.stream) {
+                    // Emit raw output to the task log
+                    task.addLog(data.stream);
+                }
+                switch (data.status) {
+                    case DockerPullEventTypes.PreparingPhase:
+                    case DockerPullEventTypes.WaitingPhase:
+                    case DockerPullEventTypes.PullingFsPhase:
+                        //Do nothing
+                        break;
+                    case DockerPullEventTypes.DownloadingPhase:
+                    case DockerPullEventTypes.VerifyingChecksumPhase:
+                        chunk.downloading = {
+                            total: data.progressDetail?.total ?? 0,
+                            current: data.progressDetail?.current ?? 0,
+                        };
+                        break;
+                    case DockerPullEventTypes.ExtractingPhase:
+                        chunk.extracting = {
+                            total: data.progressDetail?.total ?? 0,
+                            current: data.progressDetail?.current ?? 0,
+                        };
+                        break;
+                    case DockerPullEventTypes.DownloadCompletePhase:
+                        chunk.downloading.current = chunks[data.id].downloading.total;
+                        break;
+                    case DockerPullEventTypes.PullCompletePhase:
+                        chunk.extracting.current = chunks[data.id].extracting.total;
+                        chunk.done = true;
+                        break;
+                }
+                if (data.status === DockerPullEventTypes.AlreadyExistsPhase ||
+                    data.status.includes('Image is up to date') ||
+                    data.status.includes('Downloaded newer image')) {
+                    chunk.downloading.current = 1;
+                    chunk.downloading.total = 1;
+                    chunk.extracting.current = 1;
+                    chunk.extracting.total = 1;
+                    chunk.done = true;
+                }
+                const chunkList = Object.values(chunks);
+                let totals = {
+                    downloading: {
+                        total: 0,
+                        current: 0,
+                    },
+                    extracting: {
+                        total: 0,
+                        current: 0,
+                    },
+                    percent: 0,
+                    total: chunkList.length,
+                    done: 0,
+                };
+                chunkList.forEach((chunk) => {
+                    if (chunk.downloading.current > 0) {
+                        totals.downloading.current += chunk.downloading.current;
+                    }
+                    if (chunk.downloading.total > 0) {
+                        totals.downloading.total += chunk.downloading.total;
+                    }
+                    if (chunk.extracting.current > 0) {
+                        totals.extracting.current += chunk.extracting.current;
+                    }
+                    if (chunk.extracting.total > 0) {
+                        totals.extracting.total += chunk.extracting.total;
+                    }
+                    if (chunk.done) {
+                        totals.done++;
+                    }
+                });
+                totals.percent = totals.total > 0 ? (totals.done / totals.total) * 100 : 0;
+                task.metadata = {
+                    ...task.metadata,
+                    image,
+                    progress: totals.percent,
+                    status: totals,
+                    timeTaken: Date.now() - timeStarted,
+                };
+                if (Date.now() - lastEmitted < 1000) {
+                    return;
+                }
+                task.emitUpdate();
+                lastEmitted = Date.now();
+                //console.log('Pulling image %s: %s % [done: %s, total: %s]', image, Math.round(percent), totals.done, totals.total);
+            });
+            task.metadata = {
+                ...task.metadata,
+                image,
+                progress: 100,
+                timeTaken: Date.now() - timeStarted,
+            };
+            task.emitUpdate();
+        };
+        const task = taskManager_1.taskManager.add(`docker:image:pull:${image}`, processor, {
+            name: taskName,
+            image,
+            progress: -1,
+            group: 'docker:pull', //It's faster to pull images one at a time
+        });
+        await task.wait();
+        return true;
+    }
+    toDockerMounts(mounts) {
+        const Mounts = [];
+        lodash_1.default.forEach(mounts, (Source, Target) => {
+            Mounts.push({
+                Target,
+                Source: toLocalBindVolume(Source),
+                Type: 'bind',
+                ReadOnly: false,
+                Consistency: 'consistent',
+            });
+        });
+        return Mounts;
+    }
+    toDockerHealth(health) {
+        return {
+            Test: ['CMD-SHELL', health.cmd],
+            Interval: health.interval ? health.interval * NANO_SECOND : 5000 * NANO_SECOND,
+            Timeout: health.timeout ? health.timeout * NANO_SECOND : 15000 * NANO_SECOND,
+            Retries: health.retries || 10,
+        };
+    }
+    applyHash(dockerOpts) {
+        if (dockerOpts?.Labels?.HASH) {
+            delete dockerOpts.Labels.HASH;
+        }
+        const hash = (0, md5_1.default)(JSON.stringify(dockerOpts));
+        if (!dockerOpts.Labels) {
+            dockerOpts.Labels = {};
+        }
+        dockerOpts.Labels.HASH = hash;
+    }
+    async ensureContainer(opts) {
+        return await this.createOrUpdateContainer(opts);
+    }
+    async createOrUpdateContainer(opts) {
+        let imagePulled = await this.pull(opts.Image);
+        this.applyHash(opts);
+        if (!opts.name) {
+            console.log('Starting unnamed container: %s', opts.Image);
+            return this.startContainer(opts);
+        }
+        const container = await this.getContainerByName(opts.name);
+        if (imagePulled) {
+            // If image was pulled always recreate
+            console.log('New version of image was pulled: %s', opts.Image);
+        }
+        else {
+            if (!container) {
+                console.log('Starting new container: %s', opts.name);
+                return this.startContainer(opts);
+            }
+            const containerData = await container.inspect();
+            if (containerData?.Config.Labels?.HASH === opts.Labels.HASH) {
+                if (!(await container.isRunning())) {
+                    console.log('Starting previously created container: %s', opts.name);
+                    await container.start();
+                }
+                else {
+                    console.log('Previously created container already running: %s', opts.name);
+                }
+                return container.native;
+            }
+        }
+        if (container) {
+            // Remove the container and start a new one
+            console.log('Replacing previously created container: %s', opts.name);
+            await container.remove({ force: true });
+        }
+        console.log('Starting new container: %s', opts.name);
+        return this.startContainer(opts);
+    }
+    async startContainer(opts) {
+        const extraHosts = getExtraHosts(this._version);
+        if (extraHosts && extraHosts.length > 0) {
+            if (!opts.HostConfig) {
+                opts.HostConfig = {};
+            }
+            if (!opts.HostConfig.ExtraHosts) {
+                opts.HostConfig.ExtraHosts = [];
+            }
+            opts.HostConfig.ExtraHosts = opts.HostConfig.ExtraHosts.concat(extraHosts);
+        }
+        const dockerContainer = await this.docker().createContainer(opts);
+        await dockerContainer.start();
+        return dockerContainer;
+    }
+    async waitForReady(container, attempt = 0) {
+        if (!attempt) {
+            attempt = 0;
+        }
+        if (attempt >= HEALTH_CHECK_MAX) {
+            throw new Error('Container did not become ready within the timeout');
+        }
+        if (await this._isReady(container)) {
+            return;
+        }
+        return new Promise((resolve, reject) => {
+            setTimeout(async () => {
+                try {
+                    await this.waitForReady(container, attempt + 1);
+                    resolve();
+                }
+                catch (err) {
+                    reject(err);
+                }
+            }, HEALTH_CHECK_INTERVAL);
+        });
+    }
+    async _isReady(container) {
+        let info;
+        try {
+            info = await container.inspect();
+        }
+        catch (err) {
+            return false;
+        }
+        const state = info.State;
+        if (state.Status === 'exited' || state?.Status === 'removing' || state?.Status === 'dead') {
+            throw new Error('Container exited unexpectedly');
+        }
+        if (state.Health) {
+            // If container has health info - wait for it to become healthy
+            return state.Health.Status === 'healthy';
+        }
+        else {
+            return state.Running ?? false;
+        }
+    }
+    async remove(container, opts) {
+        const newName = 'deleting-' + node_uuid_1.default.v4();
+        // Rename the container first to avoid name conflicts if people start the same container
+        await container.rename({ name: newName });
+        const newContainer = this.docker().getContainer(newName);
+        await newContainer.remove({ force: !!opts?.force });
+    }
+    /**
+     *
+     * @param name
+     * @return {Promise<ContainerInfo>}
+     */
+    async get(name) {
+        let dockerContainer = null;
+        try {
+            dockerContainer = this.docker().getContainer(name);
+            await dockerContainer.stats();
+        }
+        catch (err) {
+            //Ignore
+            dockerContainer = null;
+        }
+        if (!dockerContainer) {
+            return undefined;
+        }
+        return new ContainerInfo(dockerContainer);
+    }
+    async getLogs(instance) {
+        const containerName = await (0, utils_1.getBlockInstanceContainerName)(instance.systemId, instance.instanceId);
+        const containerInfo = await this.getContainerByName(containerName);
+        if (!containerInfo) {
+            return [
+                {
+                    source: 'stdout',
+                    level: 'ERROR',
+                    time: Date.now(),
+                    message: 'Container not found',
+                },
+            ];
+        }
+        return await containerInfo.getLogs();
+    }
+    async stopLogListening(systemId, instanceId) {
+        const containerName = await (0, utils_1.getBlockInstanceContainerName)(systemId, instanceId);
+        if (this.logStreams[containerName]) {
+            if (this.logStreams[containerName]?.timer) {
+                clearTimeout(this.logStreams[containerName].timer);
+            }
+            try {
+                const stream = this.logStreams[containerName].stream;
+                if (stream) {
+                    await stream.close();
+                }
+            }
+            catch (err) {
+                // Ignore
+            }
+            delete this.logStreams[containerName];
+        }
+    }
+    async ensureLogListening(systemId, instanceId, handler) {
+        const containerName = await (0, utils_1.getBlockInstanceContainerName)(systemId, instanceId);
+        try {
+            if (this.logStreams[containerName]?.stream) {
+                // Already listening - will shut itself down
+                return;
+            }
+            if (this.logStreams[containerName]?.timer) {
+                clearTimeout(this.logStreams[containerName].timer);
+            }
+            const tryLater = () => {
+                this.logStreams[containerName] = {
+                    timer: setTimeout(() => {
+                        // Keep trying until user decides to not listen anymore
+                        this.ensureLogListening(systemId, instanceId, handler);
+                    }, 5000),
+                };
+            };
+            const containerInfo = await this.getContainerByName(containerName);
+            if (!containerInfo || !(await containerInfo.isRunning())) {
+                // Container not currently running - try again in 5 seconds
+                tryLater();
+                return;
+            }
+            const stream = await containerInfo.getLogStream();
+            stream.onLog((log) => {
+                try {
+                    handler(log);
+                }
+                catch (err) {
+                    console.warn('Error handling log', err);
+                }
+            });
+            stream.onEnd(() => {
+                // We get here if the container is stopped
+                delete this.logStreams[containerName];
+                tryLater();
+            });
+            stream.onError((err) => {
+                // We get here if the container crashes
+                delete this.logStreams[containerName];
+                tryLater();
+            });
+            this.logStreams[containerName] = {
+                stream,
+            };
+        }
+        catch (err) {
+            // Ignore
+        }
+    }
+    buildDockerImage(dockerFile, imageName) {
+        const taskName = `Building docker image: ${imageName}`;
+        const processor = async (task) => {
+            const timeStarted = Date.now();
+            const stream = await this.docker().buildImage({
+                context: path_1.default.dirname(dockerFile),
+                src: [path_1.default.basename(dockerFile)],
+            }, {
+                t: imageName,
+                dockerfile: path_1.default.basename(dockerFile),
+            });
+            await processJsonStream(`image:build:${imageName}`, stream, (data) => {
+                if (data.stream) {
+                    // Emit raw output to the task log
+                    task.addLog(data.stream);
+                }
+            });
+        };
+        return taskManager_1.taskManager.add(`docker:image:build:${imageName}`, processor, {
+            name: taskName,
+        });
+    }
+}
+function readLogBuffer(logBuffer) {
+    const out = [];
+    let offset = 0;
+    while (offset < logBuffer.length) {
+        try {
+            // Read the docker log format - explained here:
+            // https://docs.docker.com/engine/api/v1.41/#operation/ContainerAttach
+            // or here : https://ahmet.im/blog/docker-logs-api-binary-format-explained/
+            // First byte is stream type
+            const streamTypeInt = logBuffer.readInt8(offset);
+            const streamType = streamTypeInt === 1 ? 'stdout' : 'stderr';
+            if (streamTypeInt !== 1 && streamTypeInt !== 2) {
+                console.error('Unknown stream type: %s', streamTypeInt, out[out.length - 1]);
+                break;
+            }
+            // Bytes 4-8 is frame size
+            const messageLength = logBuffer.readInt32BE(offset + 4);
+            // After that is the message - with the message length
+            const dataWithoutStreamType = logBuffer.subarray(offset + 8, offset + 8 + messageLength);
+            const raw = dataWithoutStreamType.toString();
+            // Split the message into date and message
+            const firstSpaceIx = raw.indexOf(' ');
+            const dateString = raw.substring(0, firstSpaceIx);
+            const line = raw.substring(firstSpaceIx + 1);
+            offset = offset + messageLength + 8;
+            if (!dateString) {
+                break;
+            }
+            out.push({
+                time: new Date(dateString).getTime(),
+                message: line,
+                level: 'INFO',
+                source: streamType,
+            });
+        }
+        catch (err) {
+            console.error('Error parsing log entry', err);
+            offset = logBuffer.length;
+            break;
+        }
+    }
+    return out;
+}
+class ClosableLogStream {
+    stream;
+    eventEmitter;
+    constructor(stream) {
+        this.stream = stream;
+        this.eventEmitter = new node_events_1.EventEmitter();
+        stream.on('data', (data) => {
+            const logs = readLogBuffer(data);
+            logs.forEach((log) => {
+                this.eventEmitter.emit('log', log);
+            });
+        });
+        stream.on('end', () => {
+            this.eventEmitter.emit('end');
+        });
+        stream.on('error', (error) => {
+            this.eventEmitter.emit('error', error);
+        });
+        stream.on('close', () => {
+            this.eventEmitter.emit('end');
+        });
+    }
+    onLog(listener) {
+        this.eventEmitter.on('log', listener);
+        return () => {
+            this.eventEmitter.removeListener('log', listener);
+        };
+    }
+    onEnd(listener) {
+        this.eventEmitter.on('end', listener);
+        return () => {
+            this.eventEmitter.removeListener('end', listener);
+        };
+    }
+    onError(listener) {
+        this.eventEmitter.on('error', listener);
+        return () => {
+            this.eventEmitter.removeListener('error', listener);
+        };
+    }
+    close() {
+        return new Promise((resolve, reject) => {
+            try {
+                this.stream.close((err) => {
+                    if (err) {
+                        console.warn('Error closing log stream', err);
+                    }
+                    resolve();
+                });
+            }
+            catch (err) {
+                // Ignore
+            }
+        });
+    }
+}
+class ContainerInfo {
+    _container;
+    /**
+     *
+     * @param {Docker.Container} dockerContainer
+     */
+    constructor(dockerContainer) {
+        /**
+         *
+         * @type {Docker.Container}
+         * @private
+         */
+        this._container = dockerContainer;
+    }
+    get native() {
+        return this._container;
+    }
+    async isRunning() {
+        const inspectResult = await this.inspect();
+        if (!inspectResult || !inspectResult.State) {
+            return false;
+        }
+        return inspectResult.State.Running || inspectResult.State.Restarting;
+    }
+    async start() {
+        if (await this.isRunning()) {
+            return;
+        }
+        await this._container.start();
+    }
+    async restart() {
+        if (!(await this.isRunning())) {
+            return this.start();
+        }
+        await this._container.restart();
+    }
+    async stop() {
+        if (!(await this.isRunning())) {
+            return;
+        }
+        await this._container.stop();
+    }
+    async remove(opts) {
+        await exports.containerManager.remove(this._container, opts);
+    }
+    async getPort(type) {
+        const ports = await this.getPorts();
+        if (ports && ports[type]) {
+            return ports[type];
+        }
+        return null;
+    }
+    async inspect() {
+        try {
+            return await this._container.inspect();
+        }
+        catch (err) {
+            return undefined;
+        }
+    }
+    async status() {
+        const result = await this.inspect();
+        return result?.State;
+    }
+    async getPorts() {
+        const inspectResult = await this.inspect();
+        if (!inspectResult || !inspectResult.Config || !inspectResult.Config.Labels) {
+            return false;
+        }
+        const portTypes = {};
+        const ports = {};
+        lodash_1.default.forEach(inspectResult.Config.Labels, (portType, name) => {
+            if (!name.startsWith(exports.CONTAINER_LABEL_PORT_PREFIX)) {
+                return;
+            }
+            const hostPort = name.substring(exports.CONTAINER_LABEL_PORT_PREFIX.length);
+            portTypes[hostPort] = portType;
+        });
+        lodash_1.default.forEach(inspectResult.HostConfig.PortBindings, (portBindings, containerPortSpec) => {
+            let [containerPort, protocol] = containerPortSpec.split(/\//);
+            const hostPort = portBindings[0].HostPort;
+            const portType = portTypes[hostPort];
+            ports[portType] = {
+                containerPort,
+                protocol,
+                hostPort,
+            };
+        });
+        return ports;
+    }
+    async getLogStream() {
+        try {
+            const logStream = (await this.native.logs({
+                stdout: true,
+                stderr: true,
+                follow: true,
+                tail: 0,
+                timestamps: true,
+            }));
+            return new ClosableLogStream(logStream);
+        }
+        catch (err) {
+            console.log('Error getting log stream', err);
+            throw err;
+        }
+    }
+    async getLogs() {
+        const logs = await this.native.logs({
+            stdout: true,
+            stderr: true,
+            follow: false,
+            timestamps: true,
+        });
+        const out = readLogBuffer(logs);
+        if (out.length > 0) {
+            return out;
+        }
+        const status = await this.status();
+        const healthLogs = status?.Health?.Log
+            ? status?.Health?.Log.map((log) => {
+                return {
+                    source: 'stdout',
+                    level: log.ExitCode === 0 ? 'INFO' : 'ERROR',
+                    time: Date.now(),
+                    message: 'Health check: ' + log.Output,
+                };
+            })
+            : [];
+        if (status?.Running) {
+            return [
+                {
+                    source: 'stdout',
+                    level: 'INFO',
+                    time: Date.now(),
+                    message: 'Container is starting...',
+                },
+                ...healthLogs,
+            ];
+        }
+        if (status?.Restarting) {
+            return [
+                {
+                    source: 'stdout',
+                    level: 'INFO',
+                    time: Date.now(),
+                    message: 'Container is restarting...',
+                },
+                ...healthLogs,
+            ];
+        }
+        if (status?.Paused) {
+            return [
+                {
+                    source: 'stdout',
+                    level: 'INFO',
+                    time: Date.now(),
+                    message: 'Container is paused...',
+                },
+                ...healthLogs,
+            ];
+        }
+        if (status?.Error) {
+            return [
+                {
+                    source: 'stderr',
+                    level: 'ERROR',
+                    time: Date.now(),
+                    message: 'Container failed to start:\n' + status.Error,
+                },
+                ...healthLogs,
+            ];
+        }
+        return [
+            {
+                source: 'stdout',
+                level: 'INFO',
+                time: Date.now(),
+                message: 'Container not running',
+                ...healthLogs,
+            },
+        ];
+    }
+}
+exports.ContainerInfo = ContainerInfo;
+function getExtraHosts(dockerVersion) {
+    if (process.platform !== 'darwin' && process.platform !== 'win32') {
+        const [major, minor] = dockerVersion.split('.');
+        if (parseInt(major) >= 20 && parseInt(minor) >= 10) {
+            // Docker 20.10+ on Linux supports adding host.docker.internal to point to host-gateway
+            return [`${types_1.DOCKER_HOST_INTERNAL}:host-gateway`];
+        }
+        // Docker versions lower than 20.10 needs an actual IP address. We use the default network bridge which
+        // is always 172.17.0.1
+        return [`${types_1.DOCKER_HOST_INTERNAL}:172.17.0.1`];
+    }
+    return undefined;
+}
+exports.getExtraHosts = getExtraHosts;
+/**
+ * Ensure that the volume is in the correct format for the docker daemon on the host
+ *
+ * Windows: c:\path\to\volume -> /c/path/to/volume
+ * Linux: /path/to/volume -> /path/to/volume
+ * Mac: /path/to/volume -> /path/to/volume
+ */
+function toLocalBindVolume(volume) {
+    if (process.platform === 'win32') {
+        //On Windows we need to convert c:\ to /c/
+        return volume
+            .replace(/^([a-z]):\\/i, (match, drive) => {
+            return '/' + drive.toLowerCase() + '/';
+        })
+            .replace(/\\(\S)/g, '/$1');
+    }
+    return volume;
+}
+exports.toLocalBindVolume = toLocalBindVolume;
+exports.containerManager = new ContainerManager();