testcontainers 9.7.0 → 9.8.0

package/dist/package.json

@@ -1,7 +1,7 @@
 {
     "name": "testcontainers",
     "author": "Cristian Greco",
-    "version": "9.7.0",
+    "version": "9.8.0",
     "main": "dist/src/index",
     "types": "dist/src/index",
     "keywords": [

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/{docker-client-config.js → client/docker-client-config.js}

@@ -14,7 +14,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDockerClientConfig = void 0;
 const path_1 = __importDefault(require("path"));
-const logger_1 = require("../logger");
+const logger_1 = require("../../logger");
 const os_1 = require("os");
 const fs_1 = require("fs");
 const promises_1 = require("fs/promises");
@@ -30,20 +30,24 @@ function loadFromFile() {
         const file = path_1.default.resolve((0, os_1.homedir)(), ".testcontainers.properties");
         const dockerClientConfig = {};
         if ((0, fs_1.existsSync)(file)) {
-            logger_1.log.debug(`Found ".testcontainers.properties" 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 host = properties.get("docker.host");
-            if (host !== null) {
-                dockerClientConfig.dockerHost = host;
+            const tcHost = properties.get("tc.host");
+            if (tcHost !== null) {
+                dockerClientConfig.tcHost = tcHost;
             }
-            const tlsVerify = properties.get("docker.tls.verify");
-            if (tlsVerify !== null) {
-                dockerClientConfig.dockerTlsVerify = `${tlsVerify}`;
+            const dockerHost = properties.get("docker.host");
+            if (dockerHost !== null) {
+                dockerClientConfig.dockerHost = dockerHost;
             }
-            const certPath = properties.get("docker.cert.path");
-            if (certPath !== null) {
-                dockerClientConfig.dockerCertPath = certPath;
+            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;
@@ -63,6 +67,9 @@ function loadFromEnv(env) {
     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}"`);

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/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,14 +11,14 @@ 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)();
+        const { dockerode } = yield (0, docker_client_1.getDockerClient)();
         const container = yield dockerode.createContainer({
             name: options.name,
             User: options.user,
@@ -74,7 +74,7 @@ const getPortBindings = (exposedPorts) => {
             dockerodePortBindings[exposedPort.container] = [{ HostPort: exposedPort.host.toString() }];
         }
         else {
-            dockerodePortBindings[exposedPort] = [{ HostPort: "" }];
+            dockerodePortBindings[exposedPort] = [{ HostPort: "0" }];
         }
     }
     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>;

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

@@ -16,7 +16,7 @@ exports.execContainer = void 0;
 const logger_1 = require("../../../logger");
 const byline_1 = __importDefault(require("byline"));
 const demux_stream_1 = require("../demux-stream");
-const execContainer = (dockerode, provider, container, command, shouldLog = true) => __awaiter(void 0, void 0, void 0, function* () {
+const execContainer = (dockerode, containerRuntime, container, command, shouldLog = true) => __awaiter(void 0, void 0, void 0, function* () {
     const chunks = [];
     try {
         const exec = yield container.exec({
@@ -24,7 +24,7 @@ const execContainer = (dockerode, provider, container, command, shouldLog = true
             AttachStdout: true,
             AttachStderr: true,
         });
-        const stream = yield startExec(dockerode, provider, exec, container);
+        const stream = yield startExec(dockerode, containerRuntime, exec, container);
         stream.on("data", (chunk) => chunks.push(chunk));
         if (shouldLog && logger_1.execLog.enabled()) {
             (0, byline_1.default)(stream).on("data", (line) => logger_1.execLog.trace(line, { containerId: container.id }));
@@ -41,10 +41,10 @@ const execContainer = (dockerode, provider, container, command, shouldLog = true
     }
 });
 exports.execContainer = execContainer;
-const startExec = (dockerode, provider, exec, container) => __awaiter(void 0, void 0, void 0, function* () {
+const startExec = (dockerode, containerRuntime, exec, container) => __awaiter(void 0, void 0, void 0, function* () {
     try {
         const stream = yield exec.start({ stdin: true, Detach: false, Tty: true });
-        if (provider === "podman") {
+        if (containerRuntime === "podman") {
             return (0, demux_stream_1.demuxStream)(dockerode, stream);
         }
         else {

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

@@ -10,12 +10,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getContainerByHash = exports.getContainerById = void 0;
-const docker_client_1 = require("../../docker-client");
+const docker_client_1 = require("../../client/docker-client");
 const logger_1 = require("../../../logger");
 const labels_1 = require("../../../labels");
 const getContainerById = (id) => __awaiter(void 0, void 0, void 0, function* () {
     try {
-        const { dockerode } = yield (0, docker_client_1.dockerClient)();
+        const { dockerode } = yield (0, docker_client_1.getDockerClient)();
         return dockerode.getContainer(id);
     }
     catch (err) {
@@ -26,7 +26,7 @@ const getContainerById = (id) => __awaiter(void 0, void 0, void 0, function* ()
 exports.getContainerById = getContainerById;
 const getContainerByHash = (hash) => __awaiter(void 0, void 0, void 0, function* () {
     try {
-        const { dockerode } = yield (0, docker_client_1.dockerClient)();
+        const { dockerode } = yield (0, docker_client_1.getDockerClient)();
         const containers = yield dockerode.listContainers({
             limit: 1,
             filters: {

package/dist/src/docker/functions/container/list-containers.js

@@ -10,11 +10,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.listContainers = void 0;
-const docker_client_1 = require("../../docker-client");
+const docker_client_1 = require("../../client/docker-client");
 const logger_1 = require("../../../logger");
 const listContainers = () => __awaiter(void 0, void 0, void 0, function* () {
     try {
-        const { dockerode } = yield (0, docker_client_1.dockerClient)();
+        const { dockerode } = yield (0, docker_client_1.getDockerClient)();
         return yield dockerode.listContainers();
     }
     catch (err) {

package/dist/src/docker/functions/image/build-image.js

@@ -16,7 +16,7 @@ exports.buildImage = void 0;
 const logger_1 = require("../../../logger");
 const tar_fs_1 = __importDefault(require("tar-fs"));
 const byline_1 = __importDefault(require("byline"));
-const docker_client_1 = require("../../docker-client");
+const docker_client_1 = require("../../client/docker-client");
 const create_labels_1 = require("../create-labels");
 const path_1 = __importDefault(require("path"));
 const fs_1 = require("fs");
@@ -36,7 +36,7 @@ const buildImage = (options) => __awaiter(void 0, void 0, void 0, function* () {
                 }
             },
         });
-        const { dockerode } = yield (0, docker_client_1.dockerClient)();
+        const { dockerode } = yield (0, docker_client_1.getDockerClient)();
         const buildImageOptions = {
             dockerfile: options.dockerfileName,
             nocache: !options.cache,

package/dist/src/docker/functions/image/pull-image.js

@@ -14,10 +14,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pullImage = void 0;
 const logger_1 = require("../../../logger");
-const pull_stream_parser_1 = require("../../pull-stream-parser");
 const image_exists_1 = require("./image-exists");
 const get_auth_config_1 = require("../../../registry-auth-locator/get-auth-config");
 const async_lock_1 = __importDefault(require("async-lock"));
+const byline_1 = __importDefault(require("byline"));
 const imagePullLock = new async_lock_1.default();
 const pullImage = (dockerode, indexServerAddress, options) => __awaiter(void 0, void 0, void 0, function* () {
     try {
@@ -30,7 +30,14 @@ const pullImage = (dockerode, indexServerAddress, options) => __awaiter(void 0,
             logger_1.log.info(`Pulling image "${options.imageName}"...`);
             const authconfig = yield (0, get_auth_config_1.getAuthConfig)((_a = options.imageName.registry) !== null && _a !== void 0 ? _a : indexServerAddress);
             const stream = yield dockerode.pull(options.imageName.toString(), { authconfig });
-            yield new pull_stream_parser_1.PullStreamParser(options.imageName, logger_1.pullLog).consume(stream);
+            return new Promise((resolve) => {
+                (0, byline_1.default)(stream).on("data", (line) => {
+                    if (logger_1.pullLog.enabled()) {
+                        logger_1.pullLog.trace(line, { imageName: options.imageName.toString() });
+                    }
+                });
+                stream.on("end", resolve);
+            });
         }));
     }
     catch (err) {