testcontainers 9.6.0 → 9.8.0-beta.1

package/dist/src/uuid.js

@@ -7,7 +7,7 @@ exports.RandomUuid = void 0;
 const crypto_1 = __importDefault(require("crypto"));
 class RandomUuid {
     nextUuid() {
-        return crypto_1.default.randomUUID();
+        return crypto_1.default.createHash("md5").update(crypto_1.default.randomUUID()).digest("hex").substring(0, 12);
     }
 }
 exports.RandomUuid = RandomUuid;

package/dist/src/wait-for-container.js

@@ -14,19 +14,19 @@ const logger_1 = require("./logger");
 const stop_container_1 = require("./docker/functions/container/stop-container");
 const remove_container_1 = require("./docker/functions/container/remove-container");
 const waitForContainer = (container, waitStrategy, boundPorts, startTime) => __awaiter(void 0, void 0, void 0, function* () {
-    logger_1.log.debug(`Waiting for container to be ready: ${container.id}`);
+    logger_1.log.debug(`Waiting for container to be ready...`, { containerId: container.id });
     try {
         yield waitStrategy.waitUntilReady(container, boundPorts, startTime);
-        logger_1.log.info(`Container is ready: ${container.id}`);
+        logger_1.log.info(`Container is ready`, { containerId: container.id });
     }
     catch (err) {
-        logger_1.log.error(`Container failed to be ready: ${container.id}: ${err}`);
+        logger_1.log.error(`Container failed to be ready: ${err}`, { containerId: container.id });
         try {
             yield (0, stop_container_1.stopContainer)(container, { timeout: 0 });
             yield (0, remove_container_1.removeContainer)(container, { removeVolumes: true });
         }
         catch (stopErr) {
-            logger_1.log.error(`Failed to stop container after it failed to be ready: ${container.id}: ${stopErr}`);
+            logger_1.log.error(`Failed to stop container after it failed to be ready: ${stopErr}`, { containerId: container.id });
         }
         throw err;
     }

package/dist/src/wait-strategy/composite-wait-strategy.js

@@ -19,13 +19,13 @@ class CompositeWaitStrategy extends wait_strategy_1.AbstractWaitStrategy {
     }
     waitUntilReady(container, boundPorts, startTime) {
         return __awaiter(this, void 0, void 0, function* () {
-            logger_1.log.debug(`Starting composite wait strategy for ${container.id}`);
+            logger_1.log.debug(`Waiting for composite...`, { containerId: container.id });
             return new Promise((resolve, reject) => {
                 let deadlineTimeout;
                 if (this.deadline !== undefined) {
                     deadlineTimeout = setTimeout(() => {
-                        const message = `Composite wait strategy not successful after ${this.deadline}ms for ${container.id}`;
-                        logger_1.log.error(message);
+                        const message = `Composite wait strategy not successful after ${this.deadline}ms`;
+                        logger_1.log.error(message, { containerId: container.id });
                         reject(new Error(message));
                     }, this.deadline);
                 }
@@ -42,7 +42,7 @@ class CompositeWaitStrategy extends wait_strategy_1.AbstractWaitStrategy {
     }
     withStartupTimeout(startupTimeout) {
         this.waitStrategies
-            .filter((waitStrategy) => waitStrategy.getStartupTimeout() === undefined)
+            .filter((waitStrategy) => !waitStrategy.isStartupTimeoutSet())
             .forEach((waitStrategy) => waitStrategy.withStartupTimeout(startupTimeout));
         return this;
     }

package/dist/src/wait-strategy/health-check-wait-strategy.js

@@ -16,15 +16,18 @@ const inspect_container_1 = require("../docker/functions/container/inspect-conta
 const wait_strategy_1 = require("./wait-strategy");
 class HealthCheckWaitStrategy extends wait_strategy_1.AbstractWaitStrategy {
     waitUntilReady(container) {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            logger_1.log.debug(`Waiting for health check for ${container.id}`);
+            logger_1.log.debug(`Waiting for health check...`, { containerId: container.id });
             const status = yield new retry_strategy_1.IntervalRetryStrategy(100).retryUntil(() => __awaiter(this, void 0, void 0, function* () { return (yield (0, inspect_container_1.inspectContainer)(container)).healthCheckStatus; }), (healthCheckStatus) => healthCheckStatus === "healthy" || healthCheckStatus === "unhealthy", () => {
                 const timeout = this.startupTimeout;
-                throw new Error(`Health check not healthy after ${timeout}ms for ${container.id}`);
-            }, (_a = this.startupTimeout) !== null && _a !== void 0 ? _a : wait_strategy_1.DEFAULT_STARTUP_TIMEOUT);
+                const message = `Health check not healthy after ${timeout}ms`;
+                logger_1.log.error(message, { containerId: container.id });
+                throw new Error(message);
+            }, this.startupTimeout);
             if (status !== "healthy") {
-                throw new Error(`Health check failed: ${status} for ${container.id}`);
+                const message = `Health check failed: ${status}`;
+                logger_1.log.error(message, { containerId: container.id });
+                throw new Error(message);
             }
         });
     }

package/dist/src/wait-strategy/host-port-wait-strategy.js

@@ -14,13 +14,13 @@ const port_check_1 = require("../port-check");
 const logger_1 = require("../logger");
 const retry_strategy_1 = require("../retry-strategy");
 const wait_strategy_1 = require("./wait-strategy");
-const docker_client_1 = require("../docker/docker-client");
+const docker_client_1 = require("../docker/client/docker-client");
 class HostPortWaitStrategy extends wait_strategy_1.AbstractWaitStrategy {
     waitUntilReady(container, boundPorts) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { dockerode, provider, host } = yield (0, docker_client_1.dockerClient)();
+            const { dockerode, containerRuntime, host } = yield (0, docker_client_1.getDockerClient)();
             const hostPortCheck = new port_check_1.HostPortCheck(host);
-            const internalPortCheck = new port_check_1.InternalPortCheck(dockerode, provider, container);
+            const internalPortCheck = new port_check_1.InternalPortCheck(dockerode, containerRuntime, container);
             yield Promise.all([
                 this.waitForHostPorts(hostPortCheck, container, boundPorts),
                 this.waitForInternalPorts(internalPortCheck, container, boundPorts),
@@ -30,28 +30,28 @@ class HostPortWaitStrategy extends wait_strategy_1.AbstractWaitStrategy {
     waitForHostPorts(portCheck, container, boundPorts) {
         return __awaiter(this, void 0, void 0, function* () {
             for (const [, hostPort] of boundPorts.iterator()) {
-                logger_1.log.debug(`Waiting for host port ${hostPort} for ${container.id}`);
+                logger_1.log.debug(`Waiting for host port ${hostPort}...`, { containerId: container.id });
                 yield this.waitForPort(container, hostPort, portCheck);
-                logger_1.log.debug(`Host port ${hostPort} ready for ${container.id}`);
+                logger_1.log.debug(`Host port ${hostPort} ready`, { containerId: container.id });
             }
         });
     }
     waitForInternalPorts(portCheck, container, boundPorts) {
         return __awaiter(this, void 0, void 0, function* () {
             for (const [internalPort] of boundPorts.iterator()) {
-                logger_1.log.debug(`Waiting for internal port ${internalPort} for ${container.id}`);
+                logger_1.log.debug(`Waiting for internal port ${internalPort}...`, { containerId: container.id });
                 yield this.waitForPort(container, internalPort, portCheck);
-                logger_1.log.debug(`Internal port ${internalPort} ready for ${container.id}`);
+                logger_1.log.debug(`Internal port ${internalPort} ready`, { containerId: container.id });
             }
         });
     }
     waitForPort(container, port, portCheck) {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            const startupTimeout = (_a = this.startupTimeout) !== null && _a !== void 0 ? _a : wait_strategy_1.DEFAULT_STARTUP_TIMEOUT;
             yield new retry_strategy_1.IntervalRetryStrategy(100).retryUntil(() => portCheck.isBound(port), (isBound) => isBound, () => {
-                throw new Error(`Port ${port} not bound after ${startupTimeout}ms for ${container.id}`);
-            }, startupTimeout);
+                const message = `Port ${port} not bound after ${this.startupTimeout}ms`;
+                logger_1.log.error(message, { containerId: container.id });
+                throw new Error(message);
+            }, this.startupTimeout);
         });
     }
 }

package/dist/src/wait-strategy/http-wait-strategy.js

@@ -17,7 +17,8 @@ const wait_strategy_1 = require("./wait-strategy");
 const retry_strategy_1 = require("../retry-strategy");
 const node_fetch_1 = __importDefault(require("node-fetch"));
 const https_1 = __importDefault(require("https"));
-const docker_client_1 = require("../docker/docker-client");
+const docker_client_1 = require("../docker/client/docker-client");
+const logger_1 = require("../logger");
 class HttpWaitStrategy extends wait_strategy_1.AbstractWaitStrategy {
     constructor(path, port) {
         super();
@@ -68,10 +69,9 @@ class HttpWaitStrategy extends wait_strategy_1.AbstractWaitStrategy {
         return this;
     }
     waitUntilReady(container, boundPorts) {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            const { host } = yield (0, docker_client_1.dockerClient)();
-            const startupTimeout = (_a = this.startupTimeout) !== null && _a !== void 0 ? _a : wait_strategy_1.DEFAULT_STARTUP_TIMEOUT;
+            logger_1.log.debug(`Waiting for HTTP...`, { containerId: container.id });
+            const { host } = yield (0, docker_client_1.getDockerClient)();
             yield new retry_strategy_1.IntervalRetryStrategy(this.readTimeout).retryUntil(() => __awaiter(this, void 0, void 0, function* () {
                 try {
                     const url = `${this.protocol}://${host}:${boundPorts.getBinding(this.port)}${this.path}`;
@@ -82,7 +82,7 @@ class HttpWaitStrategy extends wait_strategy_1.AbstractWaitStrategy {
                         agent: this.getAgent(),
                     });
                 }
-                catch (_b) {
+                catch (_a) {
                     return undefined;
                 }
             }), (response) => __awaiter(this, void 0, void 0, function* () {
@@ -102,8 +102,10 @@ class HttpWaitStrategy extends wait_strategy_1.AbstractWaitStrategy {
                     return true;
                 }
             }), () => {
-                throw new Error(`URL ${this.path} not accessible after ${startupTimeout}ms for ${container.id}`);
-            }, startupTimeout);
+                const message = `URL ${this.path} not accessible after ${this.startupTimeout}ms`;
+                logger_1.log.error(message, { containerId: container.id });
+                throw new Error(message);
+            }, this.startupTimeout);
         });
     }
     getAgent() {

package/dist/src/wait-strategy/log-wait-strategy.js

@@ -24,17 +24,15 @@ class LogWaitStrategy extends wait_strategy_1.AbstractWaitStrategy {
         this.times = times;
     }
     waitUntilReady(container, boundPorts, startTime) {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            logger_1.log.debug(`Waiting for log message "${this.message}" for ${container.id}`);
-            const startupTimeout = (_a = this.startupTimeout) !== null && _a !== void 0 ? _a : wait_strategy_1.DEFAULT_STARTUP_TIMEOUT;
+            logger_1.log.debug(`Waiting for log message "${this.message}"...`, { containerId: container.id });
             const stream = yield (0, container_logs_1.containerLogs)(container, { since: startTime });
             return new Promise((resolve, reject) => {
                 const timeout = setTimeout(() => {
-                    const message = `Log message "${this.message}" not received after ${startupTimeout}ms for ${container.id}`;
-                    logger_1.log.error(message);
+                    const message = `Log message "${this.message}" not received after ${this.startupTimeout}ms`;
+                    logger_1.log.error(message, { containerId: container.id });
                     reject(new Error(message));
-                }, startupTimeout);
+                }, this.startupTimeout);
                 const comparisonFn = (line) => {
                     if (this.message instanceof RegExp) {
                         return this.message.test(line);
@@ -59,7 +57,9 @@ class LogWaitStrategy extends wait_strategy_1.AbstractWaitStrategy {
                     .on("end", () => {
                     stream.destroy();
                     clearTimeout(timeout);
-                    reject(new Error(`Log stream ended and message "${this.message}" was not received for ${container.id}`));
+                    const message = `Log stream ended and message "${this.message}" was not received`;
+                    logger_1.log.error(message, { containerId: container.id });
+                    reject(new Error(message));
                 });
             });
         });

package/dist/src/wait-strategy/shell-wait-strategy.js

@@ -14,24 +14,24 @@ const logger_1 = require("../logger");
 const wait_strategy_1 = require("./wait-strategy");
 const retry_strategy_1 = require("../retry-strategy");
 const exec_container_1 = require("../docker/functions/container/exec-container");
-const docker_client_1 = require("../docker/docker-client");
+const docker_client_1 = require("../docker/client/docker-client");
 class ShellWaitStrategy extends wait_strategy_1.AbstractWaitStrategy {
     constructor(command) {
         super();
         this.command = command;
     }
     waitUntilReady(container) {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            logger_1.log.debug(`Waiting for successful shell command ${this.command} for ${container.id}`);
-            const { dockerode, provider } = yield (0, docker_client_1.dockerClient)();
-            const startupTimeout = (_a = this.startupTimeout) !== null && _a !== void 0 ? _a : wait_strategy_1.DEFAULT_STARTUP_TIMEOUT;
+            logger_1.log.debug(`Waiting for successful shell command "${this.command}"...`, { containerId: container.id });
+            const { dockerode, containerRuntime } = yield (0, docker_client_1.getDockerClient)();
             yield new retry_strategy_1.IntervalRetryStrategy(100).retryUntil(() => __awaiter(this, void 0, void 0, function* () {
-                const { exitCode } = yield (0, exec_container_1.execContainer)(dockerode, provider, container, ["/bin/sh", "-c", this.command], false);
+                const { exitCode } = yield (0, exec_container_1.execContainer)(dockerode, containerRuntime, container, ["/bin/sh", "-c", this.command], false);
                 return exitCode;
             }), (exitCode) => exitCode === 0, () => {
-                throw new Error(`Shell command "${this.command}" not successful after ${startupTimeout}ms for ${container.id}`);
-            }, startupTimeout);
+                const message = `Shell command "${this.command}" not successful after ${this.startupTimeout}ms`;
+                logger_1.log.error(message, { containerId: container.id });
+                throw new Error(message);
+            }, this.startupTimeout);
         });
     }
 }

package/dist/src/wait-strategy/startup-check-strategy.js

@@ -12,14 +12,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.StartupCheckStrategy = void 0;
 const wait_strategy_1 = require("./wait-strategy");
 const retry_strategy_1 = require("../retry-strategy");
-const docker_client_1 = require("../docker/docker-client");
+const docker_client_1 = require("../docker/client/docker-client");
+const logger_1 = require("../logger");
 class StartupCheckStrategy extends wait_strategy_1.AbstractWaitStrategy {
     waitUntilReady(container) {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            const { dockerode } = yield (0, docker_client_1.dockerClient)();
-            const startupTimeout = (_a = this.startupTimeout) !== null && _a !== void 0 ? _a : wait_strategy_1.DEFAULT_STARTUP_TIMEOUT;
-            const startupStatus = yield new retry_strategy_1.IntervalRetryStrategy(1000).retryUntil(() => __awaiter(this, void 0, void 0, function* () { return yield this.checkStartupState(dockerode, container.id); }), (startupStatus) => startupStatus === "SUCCESS" || startupStatus === "FAIL", () => new Error(`Container not accessible after ${startupTimeout}ms for ${container.id}`), startupTimeout);
+            const { dockerode } = yield (0, docker_client_1.getDockerClient)();
+            const startupStatus = yield new retry_strategy_1.IntervalRetryStrategy(1000).retryUntil(() => __awaiter(this, void 0, void 0, function* () { return yield this.checkStartupState(dockerode, container.id); }), (startupStatus) => startupStatus === "SUCCESS" || startupStatus === "FAIL", () => {
+                const message = `Container not accessible after ${this.startupTimeout}ms`;
+                logger_1.log.error(message, { containerId: container.id });
+                return new Error(message);
+            }, this.startupTimeout);
             if (startupStatus instanceof Error) {
                 throw startupStatus;
             }

package/dist/src/wait-strategy/wait-strategy.d.ts

@@ -1,14 +1,16 @@
 import { BoundPorts } from "../bound-ports";
 import Dockerode from "dockerode";
-export declare const DEFAULT_STARTUP_TIMEOUT = 60000;
 export interface WaitStrategy {
     waitUntilReady(container: Dockerode.Container, boundPorts: BoundPorts, startTime?: Date): Promise<void>;
     withStartupTimeout(startupTimeout: number): WaitStrategy;
-    getStartupTimeout(): number | undefined;
+    isStartupTimeoutSet(): boolean;
+    getStartupTimeout(): number;
 }
 export declare abstract class AbstractWaitStrategy implements WaitStrategy {
-    protected startupTimeout?: number;
+    protected startupTimeout: number;
+    private startupTimeoutSet;
     abstract waitUntilReady(container: Dockerode.Container, boundPorts: BoundPorts, startTime?: Date): Promise<void>;
     withStartupTimeout(startupTimeout: number): this;
-    getStartupTimeout(): number | undefined;
+    isStartupTimeoutSet(): boolean;
+    getStartupTimeout(): number;
 }

package/dist/src/wait-strategy/wait-strategy.js

@@ -1,12 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractWaitStrategy = exports.DEFAULT_STARTUP_TIMEOUT = void 0;
-exports.DEFAULT_STARTUP_TIMEOUT = 60000;
+exports.AbstractWaitStrategy = void 0;
 class AbstractWaitStrategy {
+    constructor() {
+        this.startupTimeout = 60000;
+        this.startupTimeoutSet = false;
+    }
     withStartupTimeout(startupTimeout) {
         this.startupTimeout = startupTimeout;
+        this.startupTimeoutSet = true;
         return this;
     }
+    isStartupTimeoutSet() {
+        return this.startupTimeoutSet;
+    }
     getStartupTimeout() {
         return this.startupTimeout;
     }

package/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.js

@@ -1,66 +0,0 @@
-"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* () {
-    let dockerHost;
-    let dockerTlsVerify;
-    let dockerCertPath;
-    const file = path_1.default.resolve((0, os_1.homedir)(), ".testcontainers.properties");
-    if ((0, fs_1.existsSync)(file)) {
-        logger_1.log.debug("Found .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) {
-            dockerHost = host;
-        }
-        const tlsVerify = properties.get("docker.tls.verify");
-        if (tlsVerify !== null) {
-            dockerTlsVerify = `${tlsVerify}`;
-        }
-        const certPath = properties.get("docker.cert.path");
-        if (certPath !== null) {
-            dockerCertPath = certPath;
-        }
-    }
-    if (env["DOCKER_HOST"] !== undefined) {
-        dockerHost = env["DOCKER_HOST"];
-    }
-    if (env["DOCKER_TLS_VERIFY"] !== undefined) {
-        dockerTlsVerify = env["DOCKER_TLS_VERIFY"];
-    }
-    if (env["DOCKER_CERT_PATH"] !== undefined) {
-        dockerCertPath = env["DOCKER_CERT_PATH"];
-    }
-    let logStr = "Loaded properties: ";
-    if (dockerHost !== undefined) {
-        logStr += `dockerHost=${dockerHost}, `;
-    }
-    if (dockerTlsVerify !== undefined) {
-        logStr += `dockerTlsVerify=${dockerTlsVerify}, `;
-    }
-    if (dockerCertPath !== undefined) {
-        logStr += `dockerCertPath=${dockerCertPath}`;
-    }
-    logger_1.log.debug(logStr);
-    return { dockerHost, dockerTlsVerify, dockerCertPath };
-});
-exports.getDockerClientConfig = getDockerClientConfig;

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

@@ -1,26 +0,0 @@
-/// <reference types="node" />
-import Dockerode from "dockerode";
-import { HostIps } from "./lookup-host-ips";
-export type Provider = "docker" | "podman";
-type DockerClient = {
-    uri: string;
-    provider: Provider;
-    host: string;
-    hostIps: HostIps;
-    dockerode: Dockerode;
-    indexServerAddress: string;
-    composeEnvironment: NodeJS.ProcessEnv;
-};
-export type DockerClientInit = {
-    uri: string;
-    dockerode: Dockerode;
-    composeEnvironment: NodeJS.ProcessEnv;
-};
-export interface DockerClientStrategy {
-    init?(): Promise<void>;
-    isApplicable(): boolean;
-    getDockerClient(): Promise<DockerClientInit>;
-    getName(): string;
-}
-export declare const dockerClient: () => Promise<DockerClient>;
-export {};

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

@@ -1,156 +0,0 @@
-"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.dockerClient = void 0;
-const dockerode_1 = __importDefault(require("dockerode"));
-const path_1 = __importDefault(require("path"));
-const logger_1 = require("../logger");
-const url_1 = require("url");
-const fs_1 = require("fs");
-const session_id_1 = require("./session-id");
-const lookup_host_ips_1 = require("./lookup-host-ips");
-const system_info_1 = require("../system-info");
-const rootless_unix_socket_strategy_1 = require("./rootless-unix-socket-strategy");
-const stream_utils_1 = require("../stream-utils");
-const stream_1 = require("stream");
-const docker_client_config_1 = require("./docker-client-config");
-const resolve_host_1 = require("./resolve-host");
-const getDockerClient = () => __awaiter(void 0, void 0, void 0, function* () {
-    const strategies = [
-        new ConfigurationStrategy(),
-        new UnixSocketStrategy(),
-        new rootless_unix_socket_strategy_1.RootlessUnixSocketStrategy(),
-        new NpipeSocketStrategy(),
-    ];
-    for (const strategy of strategies) {
-        if (strategy.init) {
-            yield strategy.init();
-        }
-        if (strategy.isApplicable()) {
-            logger_1.log.debug(`Found applicable Docker client strategy: ${strategy.getName()}`);
-            const { uri, dockerode, composeEnvironment } = yield strategy.getDockerClient();
-            logger_1.log.debug(`Testing Docker client strategy URI: ${uri}`);
-            if (yield isDockerDaemonReachable(dockerode)) {
-                const indexServerAddress = (yield (0, system_info_1.getSystemInfo)(dockerode)).dockerInfo.indexServerAddress;
-                const provider = uri.includes("podman.sock") ? "podman" : "docker";
-                const host = yield (0, resolve_host_1.resolveHost)(dockerode, provider, indexServerAddress, uri);
-                const hostIps = yield (0, lookup_host_ips_1.lookupHostIps)(host);
-                logger_1.log.info(`Using Docker client strategy: ${strategy.getName()}, Docker host: ${host} (${hostIps
-                    .map((hostIp) => hostIp.address)
-                    .join(", ")})`);
-                return { uri, provider, host, hostIps, dockerode, indexServerAddress, composeEnvironment };
-            }
-            else {
-                logger_1.log.warn(`Docker client strategy ${strategy.getName()} is not reachable`);
-            }
-        }
-    }
-    throw new Error("No Docker client strategy found");
-});
-const isDockerDaemonReachable = (dockerode) => __awaiter(void 0, 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;
-    }
-});
-class ConfigurationStrategy {
-    init() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.dockerConfig = yield (0, docker_client_config_1.getDockerClientConfig)();
-        });
-    }
-    getDockerClient() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { dockerHost, dockerTlsVerify, dockerCertPath } = this.dockerConfig;
-            const dockerOptions = { headers: { "x-tc-sid": session_id_1.sessionId } };
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            const { pathname, hostname, port } = new url_1.URL(dockerHost);
-            if (hostname !== "") {
-                dockerOptions.host = hostname;
-                dockerOptions.port = port;
-            }
-            else {
-                dockerOptions.socketPath = pathname;
-            }
-            if (dockerTlsVerify === "1" && dockerCertPath !== undefined) {
-                dockerOptions.ca = yield fs_1.promises.readFile(path_1.default.resolve(dockerCertPath, "ca.pem"));
-                dockerOptions.cert = yield fs_1.promises.readFile(path_1.default.resolve(dockerCertPath, "cert.pem"));
-                dockerOptions.key = yield fs_1.promises.readFile(path_1.default.resolve(dockerCertPath, "key.pem"));
-            }
-            return {
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                uri: dockerHost,
-                dockerode: new dockerode_1.default(dockerOptions),
-                composeEnvironment: {
-                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                    DOCKER_HOST: dockerHost,
-                    DOCKER_TLS_VERIFY: dockerTlsVerify,
-                    DOCKER_CERT_PATH: dockerCertPath,
-                },
-            };
-        });
-    }
-    isApplicable() {
-        return this.dockerConfig.dockerHost !== undefined;
-    }
-    getName() {
-        return "ConfigurationStrategy";
-    }
-}
-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: {},
-            };
-        });
-    }
-    isApplicable() {
-        return (process.platform === "linux" || process.platform === "darwin") && (0, fs_1.existsSync)("/var/run/docker.sock");
-    }
-    getName() {
-        return "UnixSocketStrategy";
-    }
-}
-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: {},
-            };
-        });
-    }
-    isApplicable() {
-        return process.platform === "win32";
-    }
-    getName() {
-        return "NpipeSocketStrategy";
-    }
-}
-let _dockerClient;
-const dockerClient = () => {
-    if (!_dockerClient) {
-        _dockerClient = getDockerClient();
-    }
-    return _dockerClient;
-};
-exports.dockerClient = dockerClient;

package/dist/src/docker/get-remote-docker-unix-socket-path.d.ts

@@ -1,5 +0,0 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-export declare const getRemoteDockerUnixSocketPath: (uri: string, platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv) => string;