testcontainers 9.6.0 → 9.8.0-beta.1

package/dist/package.json

@@ -1,7 +1,7 @@
 {
     "name": "testcontainers",
     "author": "Cristian Greco",
-    "version": "9.6.0",
+    "version": "9.8.0-beta.1",
     "main": "dist/src/index",
     "types": "dist/src/index",
     "keywords": [
@@ -56,31 +56,31 @@
         "@types/async-lock": "^1.4.0",
         "@types/byline": "^4.2.33",
         "@types/debug": "4.1.7",
-        "@types/jest": "^29.5.0",
-        "@types/node": "^18.15.11",
+        "@types/jest": "^29.5.1",
+        "@types/node": "^18.16.2",
         "@types/node-fetch": "^2.6.3",
         "@types/pg": "^8.6.6",
         "@types/properties-reader": "^2.1.1",
         "@types/tar-fs": "^2.0.1",
-        "@typescript-eslint/eslint-plugin": "^5.57.0",
-        "@typescript-eslint/parser": "^5.57.0",
-        "arangojs": "^8.2.0",
+        "@typescript-eslint/eslint-plugin": "^5.59.1",
+        "@typescript-eslint/parser": "^5.59.1",
+        "arangojs": "^8.2.1",
         "cross-env": "^7.0.3",
-        "eslint": "^8.37.0",
+        "eslint": "^8.39.0",
         "eslint-config-prettier": "^8.8.0",
         "eslint-plugin-prettier": "^4.2.1",
         "husky": "^8.0.3",
         "jest": "^29.5.0",
         "kafkajs": "^2.2.4",
-        "lint-staged": "^13.2.0",
-        "mongoose": "^6.10.4",
+        "lint-staged": "^13.2.2",
+        "mongoose": "^6.10.5",
         "mysql2": "^2.3.3",
         "nats": "^2.13.1",
-        "neo4j-driver": "^5.6.0",
+        "neo4j-driver": "^5.7.0",
         "pg": "^8.10.0",
-        "prettier": "^2.8.7",
+        "prettier": "^2.8.8",
         "rimraf": "^3.0.2",
-        "ts-jest": "^29.0.5",
+        "ts-jest": "^29.1.0",
         "ts-node": "^10.9.1",
         "typescript": "^4.9.5",
         "wait-for-expect": "^3.0.2"

package/dist/src/docker/{docker-client-config.d.ts → client/docker-client-config.d.ts}

@@ -3,6 +3,7 @@
 /// <reference types="node" />
 /// <reference types="node" />
 export type DockerClientConfig = {
+    tcHost?: string;
     dockerHost?: string;
     dockerTlsVerify?: string;
     dockerCertPath?: string;

package/dist/src/docker/client/docker-client-config.js

@@ -0,0 +1,79 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDockerClientConfig = void 0;
+const path_1 = __importDefault(require("path"));
+const logger_1 = require("../../logger");
+const os_1 = require("os");
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const properties_reader_1 = __importDefault(require("properties-reader"));
+const getDockerClientConfig = (env = process.env) => __awaiter(void 0, void 0, void 0, function* () {
+    const dockerClientConfig = Object.assign(Object.assign({}, (yield loadFromFile())), loadFromEnv(env));
+    logDockerClientConfig(dockerClientConfig);
+    return dockerClientConfig;
+});
+exports.getDockerClientConfig = getDockerClientConfig;
+function loadFromFile() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const file = path_1.default.resolve((0, os_1.homedir)(), ".testcontainers.properties");
+        const dockerClientConfig = {};
+        if ((0, fs_1.existsSync)(file)) {
+            logger_1.log.debug(`Loading ".testcontainers.properties" file...`);
+            const string = yield (0, promises_1.readFile)(file, { encoding: "utf-8" });
+            const properties = (0, properties_reader_1.default)("").read(string);
+            const tcHost = properties.get("tc.host");
+            if (tcHost !== null) {
+                dockerClientConfig.tcHost = tcHost;
+            }
+            const dockerHost = properties.get("docker.host");
+            if (dockerHost !== null) {
+                dockerClientConfig.dockerHost = dockerHost;
+            }
+            const dockerTlsVerify = properties.get("docker.tls.verify");
+            if (dockerTlsVerify !== null) {
+                dockerClientConfig.dockerTlsVerify = `${dockerTlsVerify}`;
+            }
+            const dockerCertPath = properties.get("docker.cert.path");
+            if (dockerCertPath !== null) {
+                dockerClientConfig.dockerCertPath = dockerCertPath;
+            }
+        }
+        return dockerClientConfig;
+    });
+}
+function loadFromEnv(env) {
+    const dockerClientConfig = {};
+    if (env["DOCKER_HOST"] !== undefined) {
+        dockerClientConfig.dockerHost = env["DOCKER_HOST"];
+    }
+    if (env["DOCKER_TLS_VERIFY"] !== undefined) {
+        dockerClientConfig.dockerTlsVerify = env["DOCKER_TLS_VERIFY"];
+    }
+    if (env["DOCKER_CERT_PATH"] !== undefined) {
+        dockerClientConfig.dockerCertPath = env["DOCKER_CERT_PATH"];
+    }
+    return dockerClientConfig;
+}
+function logDockerClientConfig(config) {
+    if (!logger_1.log.enabled()) {
+        return;
+    }
+    const configurations = Object.entries(config)
+        .filter(([, value]) => value !== undefined)
+        .map(([key, value]) => `${key}: "${value}"`);
+    if (configurations.length > 0) {
+        logger_1.log.debug(`Loaded Docker client configuration, ${configurations.join(", ")}`);
+    }
+}

package/dist/src/docker/client/docker-client.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+import Dockerode from "dockerode";
+import { HostIps } from "../lookup-host-ips";
+import { SystemInfo } from "../../system-info";
+import { ContainerRuntime } from "../types";
+export type DockerClient = DockerClientStrategyResult & {
+    host: string;
+    containerRuntime: ContainerRuntime;
+    hostIps: HostIps;
+    info: SystemInfo;
+};
+export type DockerClientStrategyResult = {
+    uri: string;
+    dockerode: Dockerode;
+    composeEnvironment: NodeJS.ProcessEnv;
+    allowUserOverrides: boolean;
+};
+export declare function getDockerClient(): Promise<DockerClient>;

package/dist/src/docker/client/docker-client.js

@@ -0,0 +1,90 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDockerClient = void 0;
+const logger_1 = require("../../logger");
+const lookup_host_ips_1 = require("../lookup-host-ips");
+const system_info_1 = require("../../system-info");
+const rootless_unix_socket_strategy_1 = require("./strategy/rootless-unix-socket-strategy");
+const stream_utils_1 = require("../../stream-utils");
+const stream_1 = require("stream");
+const resolve_host_1 = require("../resolve-host");
+const configuration_strategy_1 = require("./strategy/configuration-strategy");
+const unix_socket_strategy_1 = require("./strategy/unix-socket-strategy");
+const npipe_socket_strategy_1 = require("./strategy/npipe-socket-strategy");
+const testcontainers_host_strategy_1 = require("./strategy/testcontainers-host-strategy");
+let dockerClient;
+function getDockerClient() {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (dockerClient) {
+            return dockerClient;
+        }
+        const strategies = [
+            new testcontainers_host_strategy_1.TestcontainersHostStrategy(),
+            new configuration_strategy_1.ConfigurationStrategy(),
+            new unix_socket_strategy_1.UnixSocketStrategy(),
+            new rootless_unix_socket_strategy_1.RootlessUnixSocketStrategy(),
+            new npipe_socket_strategy_1.NpipeSocketStrategy(),
+        ];
+        for (const strategy of strategies) {
+            if (strategy.init) {
+                yield strategy.init();
+            }
+            if (strategy.isApplicable()) {
+                logger_1.log.debug(`Found Docker client strategy "${strategy.getName()}"`);
+                const { uri, dockerode, composeEnvironment, allowUserOverrides } = yield strategy.getDockerClient();
+                logger_1.log.debug(`Testing Docker client strategy "${uri}"...`);
+                if (yield isDockerDaemonReachable(dockerode)) {
+                    const info = yield (0, system_info_1.getSystemInfo)(dockerode);
+                    const containerRuntime = uri.includes("podman.sock") ? "podman" : "docker";
+                    const host = yield (0, resolve_host_1.resolveHost)(dockerode, containerRuntime, info.dockerInfo.indexServerAddress, uri, allowUserOverrides);
+                    const hostIps = yield (0, lookup_host_ips_1.lookupHostIps)(host);
+                    dockerClient = {
+                        uri,
+                        containerRuntime,
+                        host,
+                        hostIps,
+                        dockerode,
+                        info,
+                        composeEnvironment,
+                        allowUserOverrides,
+                    };
+                    logDockerClient(strategy.getName(), dockerClient);
+                    return dockerClient;
+                }
+                else {
+                    logger_1.log.warn(`Docker client strategy "${strategy.getName()}" is not working`);
+                }
+            }
+        }
+        throw new Error("No Docker client strategy found");
+    });
+}
+exports.getDockerClient = getDockerClient;
+function isDockerDaemonReachable(dockerode) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const response = yield dockerode.ping();
+            return (yield (0, stream_utils_1.streamToString)(stream_1.Readable.from(response))) === "OK";
+        }
+        catch (err) {
+            logger_1.log.warn(`Docker daemon is not reachable: ${err}`);
+            return false;
+        }
+    });
+}
+function logDockerClient(strategyName, { host, hostIps }) {
+    if (!logger_1.log.enabled()) {
+        return;
+    }
+    const formattedHostIps = hostIps.map((hostIp) => hostIp.address).join(", ");
+    logger_1.log.info(`Using Docker client strategy "${strategyName}", Docker host "${host}" (${formattedHostIps})`);
+}

package/dist/src/docker/client/strategy/configuration-strategy.d.ts

@@ -0,0 +1,11 @@
+import { DockerClientStrategyResult } from "../docker-client";
+import { DockerClientStrategy } from "./docker-client-strategy";
+export declare class ConfigurationStrategy implements DockerClientStrategy {
+    private dockerHost;
+    private dockerTlsVerify;
+    private dockerCertPath;
+    init(): Promise<void>;
+    getDockerClient(): Promise<DockerClientStrategyResult>;
+    isApplicable(): boolean;
+    getName(): string;
+}

package/dist/src/docker/client/strategy/configuration-strategy.js

@@ -0,0 +1,68 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigurationStrategy = void 0;
+const docker_client_config_1 = require("../docker-client-config");
+const dockerode_1 = __importDefault(require("dockerode"));
+const session_id_1 = require("../../session-id");
+const url_1 = require("url");
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+class ConfigurationStrategy {
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { dockerHost, dockerTlsVerify, dockerCertPath } = yield (0, docker_client_config_1.getDockerClientConfig)();
+            if (dockerHost) {
+                this.dockerHost = dockerHost;
+            }
+            this.dockerTlsVerify = dockerTlsVerify;
+            this.dockerCertPath = dockerCertPath;
+        });
+    }
+    getDockerClient() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dockerOptions = { headers: { "x-tc-sid": session_id_1.sessionId } };
+            const { pathname, hostname, port } = new url_1.URL(this.dockerHost);
+            if (hostname !== "") {
+                dockerOptions.host = hostname;
+                dockerOptions.port = port;
+            }
+            else {
+                dockerOptions.socketPath = pathname;
+            }
+            if (this.dockerTlsVerify === "1" && this.dockerCertPath !== undefined) {
+                dockerOptions.ca = yield fs_1.promises.readFile(path_1.default.resolve(this.dockerCertPath, "ca.pem"));
+                dockerOptions.cert = yield fs_1.promises.readFile(path_1.default.resolve(this.dockerCertPath, "cert.pem"));
+                dockerOptions.key = yield fs_1.promises.readFile(path_1.default.resolve(this.dockerCertPath, "key.pem"));
+            }
+            return {
+                uri: this.dockerHost,
+                dockerode: new dockerode_1.default(dockerOptions),
+                composeEnvironment: {
+                    DOCKER_HOST: this.dockerHost,
+                    DOCKER_TLS_VERIFY: this.dockerTlsVerify,
+                    DOCKER_CERT_PATH: this.dockerCertPath,
+                },
+                allowUserOverrides: true,
+            };
+        });
+    }
+    isApplicable() {
+        return this.dockerHost !== undefined;
+    }
+    getName() {
+        return "ConfigurationStrategy";
+    }
+}
+exports.ConfigurationStrategy = ConfigurationStrategy;

package/dist/src/docker/client/strategy/docker-client-strategy.d.ts

@@ -0,0 +1,7 @@
+import { DockerClientStrategyResult } from "../docker-client";
+export interface DockerClientStrategy {
+    init?(): Promise<void>;
+    isApplicable(): boolean;
+    getDockerClient(): Promise<DockerClientStrategyResult>;
+    getName(): string;
+}

package/dist/src/docker/client/strategy/docker-client-strategy.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/docker/client/strategy/npipe-socket-strategy.d.ts

@@ -0,0 +1,7 @@
+import { DockerClientStrategyResult } from "../docker-client";
+import { DockerClientStrategy } from "./docker-client-strategy";
+export declare class NpipeSocketStrategy implements DockerClientStrategy {
+    getDockerClient(): Promise<DockerClientStrategyResult>;
+    isApplicable(): boolean;
+    getName(): string;
+}

package/dist/src/docker/client/strategy/npipe-socket-strategy.js

@@ -0,0 +1,35 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NpipeSocketStrategy = void 0;
+const dockerode_1 = __importDefault(require("dockerode"));
+class NpipeSocketStrategy {
+    getDockerClient() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return {
+                uri: "npipe:////./pipe/docker_engine",
+                dockerode: new dockerode_1.default({ socketPath: "//./pipe/docker_engine" }),
+                composeEnvironment: {},
+                allowUserOverrides: true,
+            };
+        });
+    }
+    isApplicable() {
+        return process.platform === "win32";
+    }
+    getName() {
+        return "NpipeSocketStrategy";
+    }
+}
+exports.NpipeSocketStrategy = NpipeSocketStrategy;

package/dist/src/docker/{rootless-unix-socket-strategy.d.ts → client/strategy/rootless-unix-socket-strategy.d.ts}

@@ -1,5 +1,6 @@
 /// <reference types="node" />
-import { DockerClientInit, DockerClientStrategy } from "./docker-client";
+import { DockerClientStrategyResult } from "../docker-client";
+import { DockerClientStrategy } from "./docker-client-strategy";
 export declare class RootlessUnixSocketStrategy implements DockerClientStrategy {
     private readonly platform;
     private readonly env;
@@ -11,7 +12,7 @@ export declare class RootlessUnixSocketStrategy implements DockerClientStrategy
     private getSocketPathFromHomeRunDir;
     private getSocketPathFromHomeDesktopDir;
     private getSocketPathFromRunDir;
-    getDockerClient(): Promise<DockerClientInit>;
+    getDockerClient(): Promise<DockerClientStrategyResult>;
     isApplicable(): boolean;
     getName(): string;
 }

package/dist/src/docker/{rootless-unix-socket-strategy.js → client/strategy/rootless-unix-socket-strategy.js}

@@ -13,7 +13,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RootlessUnixSocketStrategy = void 0;
-const type_guards_1 = require("../type-guards");
+const type_guards_1 = require("../../../type-guards");
 const fs_1 = require("fs");
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
@@ -64,6 +64,7 @@ class RootlessUnixSocketStrategy {
                 uri: `unix://${this.socketPath}`,
                 dockerode: new dockerode_1.default({ socketPath: this.socketPath }),
                 composeEnvironment: {},
+                allowUserOverrides: true,
             };
         });
     }

package/dist/src/docker/client/strategy/testcontainers-host-strategy.d.ts

@@ -0,0 +1,9 @@
+import { DockerClientStrategyResult } from "../docker-client";
+import { DockerClientStrategy } from "./docker-client-strategy";
+export declare class TestcontainersHostStrategy implements DockerClientStrategy {
+    private host;
+    init(): Promise<void>;
+    getDockerClient(): Promise<DockerClientStrategyResult>;
+    isApplicable(): boolean;
+    getName(): string;
+}

package/dist/src/docker/client/strategy/testcontainers-host-strategy.js

@@ -0,0 +1,52 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestcontainersHostStrategy = void 0;
+const docker_client_config_1 = require("../docker-client-config");
+const dockerode_1 = __importDefault(require("dockerode"));
+const session_id_1 = require("../../session-id");
+const url_1 = require("url");
+class TestcontainersHostStrategy {
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { tcHost } = yield (0, docker_client_config_1.getDockerClientConfig)();
+            if (tcHost) {
+                this.host = tcHost;
+            }
+        });
+    }
+    getDockerClient() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dockerOptions = { headers: { "x-tc-sid": session_id_1.sessionId } };
+            const { hostname, port } = new url_1.URL(this.host);
+            dockerOptions.host = hostname;
+            dockerOptions.port = port;
+            return {
+                uri: this.host,
+                dockerode: new dockerode_1.default(dockerOptions),
+                composeEnvironment: {
+                    DOCKER_HOST: this.host,
+                },
+                allowUserOverrides: false,
+            };
+        });
+    }
+    isApplicable() {
+        return this.host !== undefined;
+    }
+    getName() {
+        return "TestcontainersHostStrategy";
+    }
+}
+exports.TestcontainersHostStrategy = TestcontainersHostStrategy;

package/dist/src/docker/client/strategy/unix-socket-strategy.d.ts

@@ -0,0 +1,7 @@
+import { DockerClientStrategyResult } from "../docker-client";
+import { DockerClientStrategy } from "./docker-client-strategy";
+export declare class UnixSocketStrategy implements DockerClientStrategy {
+    getDockerClient(): Promise<DockerClientStrategyResult>;
+    isApplicable(): boolean;
+    getName(): string;
+}

package/dist/src/docker/client/strategy/unix-socket-strategy.js

@@ -0,0 +1,36 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnixSocketStrategy = void 0;
+const dockerode_1 = __importDefault(require("dockerode"));
+const fs_1 = require("fs");
+class UnixSocketStrategy {
+    getDockerClient() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return {
+                uri: "unix:///var/run/docker.sock",
+                dockerode: new dockerode_1.default({ socketPath: "/var/run/docker.sock" }),
+                composeEnvironment: {},
+                allowUserOverrides: true,
+            };
+        });
+    }
+    isApplicable() {
+        return (process.platform === "linux" || process.platform === "darwin") && (0, fs_1.existsSync)("/var/run/docker.sock");
+    }
+    getName() {
+        return "UnixSocketStrategy";
+    }
+}
+exports.UnixSocketStrategy = UnixSocketStrategy;

package/dist/src/docker/functions/container/attach-container.js

@@ -18,7 +18,7 @@ const attachContainer = (dockerode, container) => __awaiter(void 0, void 0, void
         return (0, demux_stream_1.demuxStream)(dockerode, stream);
     }
     catch (err) {
-        logger_1.log.error(`Failed to attach to container ${container.id}: ${err}`);
+        logger_1.log.error(`Failed to attach to container: ${err}`, { containerId: container.id });
         throw err;
     }
 });

package/dist/src/docker/functions/container/container-logs.js

@@ -12,7 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.containerLogs = void 0;
 const logger_1 = require("../../../logger");
 const demux_stream_1 = require("../demux-stream");
-const docker_client_1 = require("../../docker-client");
+const docker_client_1 = require("../../client/docker-client");
 const containerLogs = (container, options = {}) => __awaiter(void 0, void 0, void 0, function* () {
     try {
         const stream = (yield container.logs({
@@ -22,7 +22,7 @@ const containerLogs = (container, options = {}) => __awaiter(void 0, void 0, voi
             since: options.since ? options.since.getTime() / 1000 : 0,
         }));
         stream.socket.unref();
-        return (0, demux_stream_1.demuxStream)((yield (0, docker_client_1.dockerClient)()).dockerode, stream);
+        return (0, demux_stream_1.demuxStream)((yield (0, docker_client_1.getDockerClient)()).dockerode, stream);
     }
     catch (err) {
         logger_1.log.error(`Failed to get container logs: ${err}`);

package/dist/src/docker/functions/container/create-container.js

@@ -11,15 +11,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createContainer = void 0;
 const logger_1 = require("../../../logger");
-const docker_client_1 = require("../../docker-client");
+const docker_client_1 = require("../../client/docker-client");
 const port_1 = require("../../../port");
 const create_labels_1 = require("../create-labels");
 const createContainer = (options) => __awaiter(void 0, void 0, void 0, function* () {
     var _a, _b;
     try {
-        logger_1.log.info(`Creating container for image: ${options.imageName}`);
-        const { dockerode } = yield (0, docker_client_1.dockerClient)();
-        return yield dockerode.createContainer({
+        logger_1.log.info(`Creating container for image "${options.imageName}"...`);
+        const { dockerode } = yield (0, docker_client_1.getDockerClient)();
+        const container = yield dockerode.createContainer({
             name: options.name,
             User: options.user,
             Image: options.imageName.toString(),
@@ -47,9 +47,11 @@ const createContainer = (options) => __awaiter(void 0, void 0, void 0, function*
                 NanoCpus: (_b = options.resourcesQuota) === null || _b === void 0 ? void 0 : _b.cpu,
             },
         });
+        logger_1.log.info(`Created container for image "${options.imageName}"`, { containerId: container.id });
+        return container;
     }
     catch (err) {
-        logger_1.log.error(`Failed to create container for image ${options.imageName}: ${err}`);
+        logger_1.log.error(`Failed to create container for image "${options.imageName}": ${err}`);
         throw err;
     }
 });
@@ -72,7 +74,7 @@ const getPortBindings = (exposedPorts) => {
             dockerodePortBindings[exposedPort.container] = [{ HostPort: exposedPort.host.toString() }];
         }
         else {
-            dockerodePortBindings[exposedPort] = [{ HostPort: "0" }];
+            dockerodePortBindings[exposedPort] = [{ HostPort: "" }];
         }
     }
     return dockerodePortBindings;

package/dist/src/docker/functions/container/exec-container.d.ts

@@ -1,4 +1,3 @@
-import { ExecResult } from "../../types";
+import { ContainerRuntime, ExecResult } from "../../types";
 import Dockerode from "dockerode";
-import { Provider } from "../../docker-client";
-export declare const execContainer: (dockerode: Dockerode, provider: Provider, container: Dockerode.Container, command: string[], shouldLog?: boolean) => Promise<ExecResult>;
+export declare const execContainer: (dockerode: Dockerode, containerRuntime: ContainerRuntime, container: Dockerode.Container, command: string[], shouldLog?: boolean) => Promise<ExecResult>;