testcontainers 7.23.2 → 8.1.1

package/README.md

@@ -5,6 +5,8 @@
 [![Node.js CI](https://github.com/testcontainers/testcontainers-node/actions/workflows/node.js.yml/badge.svg?branch=master)](https://github.com/testcontainers/testcontainers-node/actions/workflows/node.js.yml)
 [![npm version](https://badge.fury.io/js/testcontainers.svg)](https://www.npmjs.com/package/testcontainers)
 [![npm version](https://img.shields.io/npm/dm/testcontainers.svg)](https://www.npmjs.com/package/testcontainers)
+[![Thundra Foresight](https://thundra-assets-prod.s3.us-west-2.amazonaws.com/images/badges/thundra-foresight-badge-enabled.svg)](https://foresight.thundra.live/testRuns/57175ecb-d5ac-4129-957a-9dd617fd27d0)
+[![Foresight Test Summary](https://foresight.service.thundra.us/public/api/v1/badge/test/57175ecb-d5ac-4129-957a-9dd617fd27d0)](https://foresight.thundra.live/testruns/57175ecb-d5ac-4129-957a-9dd617fd27d0)
 
 ## Install
 
@@ -16,12 +18,18 @@ npm i -D testcontainers
 
 The following environment variables are supported:
 
-- `DEBUG=testcontainers` See output
-- `DEBUG=testcontainers:containers` See container output
-- `DEBUG=testcontainers*` See all output
-- `DOCKER_HOST=tcp://docker:2375` Daemon socket to connect to
+- `DEBUG=testcontainers` See testcontainers logs
+- `DEBUG=testcontainers:containers` See container logs
+- `DEBUG=testcontainers*` See all logs
+- `DOCKER_HOST=tcp://docker:2375` Sets the URL of the docker daemon
+- `DOCKER_TLS_VERIFY=1` When set to anything other than an empty string, enables TLS communication with the docker
+  daemon
+- `DOCKER_CERT_PATH=/some/path` Configures the path to the ca.pem, cert.pem, and key.pem files used for TLS
+  verification. Defaults to ~/.docker
 - `TESTCONTAINERS_HOST_OVERRIDE=docker.svc.local` Docker's host on which ports are exposed
-- `TESTCONTAINERS_DOCKER_SOCKET_OVERRIDE=/var/run/docker.sock` Path to Docker's socket. Used by [ryuk](#ryuk) and other [auxiliary containers](#auxiliary-containers) that need to perform Docker actions
+- `TESTCONTAINERS_DOCKER_SOCKET_OVERRIDE=/var/run/docker.sock` Path to Docker's socket. Used by [ryuk](#ryuk) and
+  other [auxiliary containers](#auxiliary-containers) that need to perform Docker actions
+- `TESTCONTAINERS_RYUK_PRIVILEGED=true` Run [ryuk](#ryuk) as a privileged container
 - `TESTCONTAINERS_RYUK_DISABLED=true` Disable [ryuk](#ryuk)
 - `RYUK_CONTAINER_IMAGE=registry.mycompany.com/mirror/ryuk:0.3.0` Custom image for [ryuk](#ryuk)
 - `SSHD_CONTAINER_IMAGE=registry.mycompany.com/mirror/sshd:1.0.0` Custom image for [SSHd](#SSHd)
@@ -136,7 +144,7 @@ Creating a container with a command:
 const { GenericContainer } = require("testcontainers");
 
 const container = await new GenericContainer("alpine")
-  .withCmd(["top"])
+  .withCmd(["sleep", "infinity"])
   .start();
 ```
 
@@ -146,7 +154,7 @@ Execute commands inside a running container:
 const { GenericContainer } = require("testcontainers");
 
 const container = await new GenericContainer("alpine")
-  .withCmd(["top"])
+  .withCmd(["sleep", "infinity"])
   .start();
 
 const { output, exitCode } = await container.exec(["echo", "hello", "world"]);
@@ -263,12 +271,12 @@ const network = await new Network()
     .start();
 
 const container = await new GenericContainer("alpine")
-  .withCmd(["top"])
+  .withCmd(["sleep", "infinity"])
   .withNetworkMode(network.getName())
   .start();
 
 const fooContainer = await new GenericContainer("alpine")
-  .withCmd(["top"])
+  .withCmd(["sleep", "infinity"])
   .withNetworkMode(network.getName())
   .withNetworkAliases("foo", "bar")
   .start();
@@ -276,6 +284,22 @@ const fooContainer = await new GenericContainer("alpine")
 expect((await container.exec(["nslookup", "foo"])).exitCode).toBe(0);
 ```
 
+Add hostname mappings:
+
+```javascript
+const { GenericContainer } = require("testcontainers");
+
+const container = await new GenericContainer("alpine")
+  .withExtraHosts(
+    { host: "foo", ipAddress: "10.11.12.13" },
+    { host: "bar", ipAddress: "11.12.13.14" }
+  )
+  .start();
+
+expect((await container.exec(["nslookup", "foo"])).exitCode).toBe(0);
+expect((await container.exec(["nslookup", "bar"])).exitCode).toBe(0);
+```
+
 Specifying a pull policy. Note that if omitted will use the `DefaultPullPolicy` which will use a locally cached image 
 if one already exists, this is usually the preferred option. In cases where there is a local image for a given tag 
 but the remote image with the same tag may have changed (for example when using the `latest` tag), you can tell 
@@ -401,7 +425,7 @@ server.listen(8000);
 await TestContainers.exposeHostPorts(8000);
 
 const container = await new GenericContainer("alpine")
-  .withCmd(["top"])
+  .withCmd(["sleep", "infinity"])
   .start();
 
 const { output } = await container.exec(["curl", `http://host.testcontainers.internal:8000`]);
@@ -634,8 +658,9 @@ Once started, this container keeps track of containers/images/networks/volumes c
 automatically clean them up 10s after connectivity with testcontainers is lost. This is useful for example if a test 
 starts a container and then terminates unexpectedly, as it will be automatically removed.
 
-ryuk must be run with privileged mode; in CI environments such as Bit Bucket where this isn't supported, ryuk can be 
-disabled by setting the environment variable `TESTCONTAINERS_RYUK_DISABLED` to `true`.
+ryuk by default does not run privileged, if necessary this can be overridden by setting the environment variable 
+`TESTCONTAINERS_RYUK_PRIVILEGED` to `true`. If necessary, ryuk can be disabled enirely by setting the environment 
+variable `TESTCONTAINERS_RYUK_DISABLED` to `true`.
 
 ### SSHd
 
@@ -665,3 +690,4 @@ depending on file sizes and network constraints. It's unlikely that the default
 timeouts set by test frameworks are sufficient.
 
 - Increase the test timeout via the methods provided by the testing framework.
+

package/dist/bound-ports.d.ts

@@ -1,7 +1,10 @@
 import { Port } from "./port";
+import { InspectResult } from "./docker/functions/container/inspect-container";
 export declare class BoundPorts {
     private readonly ports;
     getBinding(port: Port): Port;
     setBinding(key: Port, value: Port): void;
     iterator(): Iterable<[Port, Port]>;
+    filter(ports: Port[]): BoundPorts;
+    static fromInspectResult(inspectResult: InspectResult): BoundPorts;
 }

package/dist/bound-ports.js

@@ -18,5 +18,19 @@ class BoundPorts {
     iterator() {
         return this.ports;
     }
+    filter(ports) {
+        const boundPorts = new BoundPorts();
+        for (const [internalPort, hostPort] of this.iterator()) {
+            if (ports.includes(internalPort)) {
+                boundPorts.setBinding(internalPort, hostPort);
+            }
+        }
+        return boundPorts;
+    }
+    static fromInspectResult(inspectResult) {
+        const boundPorts = new BoundPorts();
+        Object.entries(inspectResult.ports).forEach(([internalPort, hostPort]) => boundPorts.setBinding(parseInt(internalPort), hostPort));
+        return boundPorts;
+    }
 }
 exports.BoundPorts = BoundPorts;

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

@@ -0,0 +1,9 @@
+import Dockerode from "dockerode";
+import { Host } from "./types";
+import "../testcontainers-properties-file";
+declare type DockerClient = {
+    host: Host;
+    dockerode: Dockerode;
+};
+export declare const dockerClient: Promise<DockerClient>;
+export {};

package/dist/docker/docker-client.js

@@ -0,0 +1,149 @@
+"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 = __importDefault(require("fs"));
+const run_in_container_1 = require("./functions/run-in-container");
+const log_system_diagnostics_1 = require("../log-system-diagnostics");
+require("../testcontainers-properties-file");
+const getDockerClient = () => __awaiter(void 0, void 0, void 0, function* () {
+    const strategies = [
+        new ConfigurationStrategy(),
+        new UnixSocketStrategy(),
+        new NpipeSocketStrategy(),
+    ];
+    for (const strategy of strategies) {
+        if (strategy.isApplicable()) {
+            logger_1.log.debug(`Found applicable Docker client strategy: ${strategy.getName()}`);
+            const dockerConfig = strategy.getDockerConfig();
+            const dockerode = new dockerode_1.default(createDockerodeOptions(dockerConfig));
+            logger_1.log.debug(`Testing Docker client strategy URI: ${dockerConfig.uri}`);
+            if (yield isDockerDaemonReachable(dockerode)) {
+                const host = yield resolveHost(dockerode, dockerConfig.uri);
+                logger_1.log.info(`Using Docker client strategy: ${strategy.getName()}, Docker host: ${host}`);
+                log_system_diagnostics_1.logSystemDiagnostics();
+                return { host, dockerode };
+            }
+            else {
+                logger_1.log.warn(`Docker client strategy ${strategy.getName()} is not reachable`);
+            }
+        }
+    }
+    throw new Error("No Docker client strategy found");
+});
+const createDockerodeOptions = (dockerConfig) => {
+    const dockerOptions = {};
+    if (dockerConfig.socketPath) {
+        dockerOptions.socketPath = dockerConfig.socketPath;
+    }
+    else {
+        dockerOptions.host = dockerConfig.uri;
+    }
+    if (dockerConfig.ssl) {
+        dockerOptions.ca = dockerConfig.ssl.ca;
+        dockerOptions.cert = dockerConfig.ssl.cert;
+        dockerOptions.key = dockerConfig.ssl.key;
+    }
+    return dockerOptions;
+};
+const isDockerDaemonReachable = (dockerode) => __awaiter(void 0, void 0, void 0, function* () { return (yield dockerode.ping()).toString() === "OK"; });
+class ConfigurationStrategy {
+    getDockerConfig() {
+        const { DOCKER_HOST, DOCKER_TLS_VERIFY, DOCKER_CERT_PATH } = process.env;
+        return {
+            uri: DOCKER_HOST,
+            ssl: DOCKER_TLS_VERIFY === "1" && DOCKER_CERT_PATH !== undefined
+                ? {
+                    ca: path_1.default.resolve(DOCKER_CERT_PATH, "ca.pem"),
+                    cert: path_1.default.resolve(DOCKER_CERT_PATH, "cert.pem"),
+                    key: path_1.default.resolve(DOCKER_CERT_PATH, "key.pem"),
+                }
+                : undefined,
+        };
+    }
+    isApplicable() {
+        return process.env.DOCKER_HOST !== undefined;
+    }
+    getName() {
+        return "ConfigurationStrategy";
+    }
+}
+class UnixSocketStrategy {
+    getDockerConfig() {
+        return {
+            uri: "unix:///var/run/docker.sock",
+            socketPath: "/var/run/docker.sock",
+        };
+    }
+    isApplicable() {
+        return process.platform === "linux" || process.platform === "darwin";
+    }
+    getName() {
+        return "UnixSocketStrategy";
+    }
+}
+class NpipeSocketStrategy {
+    getDockerConfig() {
+        return {
+            uri: "npipe:////./pipe/docker_engine",
+            socketPath: "//./pipe/docker_engine",
+        };
+    }
+    isApplicable() {
+        return process.platform === "win32";
+    }
+    getName() {
+        return "NpipeSocketStrategy";
+    }
+}
+const resolveHost = (dockerode, uri) => __awaiter(void 0, void 0, void 0, function* () {
+    if (process.env.TESTCONTAINERS_HOST_OVERRIDE !== undefined) {
+        return process.env.TESTCONTAINERS_HOST_OVERRIDE;
+    }
+    const { protocol, hostname } = new url_1.URL(uri);
+    switch (protocol) {
+        case "http:":
+        case "https:":
+        case "tcp:":
+            return hostname;
+        case "unix:":
+        case "npipe:": {
+            if (isInContainer()) {
+                const gateway = yield findGateway(dockerode);
+                if (gateway !== undefined) {
+                    return gateway;
+                }
+                const defaultGateway = yield findDefaultGateway(dockerode);
+                if (defaultGateway !== undefined) {
+                    return defaultGateway;
+                }
+            }
+            return "localhost";
+        }
+        default:
+            throw new Error(`Unsupported protocol: ${protocol}`);
+    }
+});
+const findGateway = (dockerode) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b, _c;
+    const inspectResult = yield dockerode.getNetwork("bridge").inspect();
+    return (_c = (_b = (_a = inspectResult === null || inspectResult === void 0 ? void 0 : inspectResult.IPAM) === null || _a === void 0 ? void 0 : _a.Config) === null || _b === void 0 ? void 0 : _b.find((config) => config.Gateway !== undefined)) === null || _c === void 0 ? void 0 : _c.Gateway;
+});
+const findDefaultGateway = (dockerode) => __awaiter(void 0, void 0, void 0, function* () { return run_in_container_1.runInContainer(dockerode, "alpine:3.5", ["sh", "-c", "ip route|awk '/default/ { print $3 }'"]); });
+const isInContainer = () => fs_1.default.existsSync("/.dockerenv");
+exports.dockerClient = getDockerClient();

package/dist/docker/functions/container/create-container.d.ts

@@ -1,6 +1,6 @@
 import { DockerImageName } from "../../../docker-image-name";
-import { BoundPorts } from "../../../bound-ports";
 import Dockerode from "dockerode";
+import { Port } from "../../../port";
 import { BindMount, Command, ContainerName, Env, ExtraHost, HealthCheck, NetworkMode, TmpFs } from "../../types";
 export declare type CreateContainerOptions = {
     imageName: DockerImageName;
@@ -8,7 +8,7 @@ export declare type CreateContainerOptions = {
     cmd: Command[];
     bindMounts: BindMount[];
     tmpFs: TmpFs;
-    boundPorts: BoundPorts;
+    exposedPorts: Port[];
     name?: ContainerName;
     networkMode?: NetworkMode;
     healthCheck?: HealthCheck;

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

@@ -11,17 +11,18 @@ 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 dockerode_1 = require("../../dockerode");
+const docker_client_1 = require("../../docker-client");
 const create_labels_1 = require("../create-labels");
 const createContainer = (options) => __awaiter(void 0, void 0, void 0, function* () {
     try {
         logger_1.log.info(`Creating container for image: ${options.imageName}`);
-        return yield dockerode_1.dockerode.createContainer({
+        const { dockerode } = yield docker_client_1.dockerClient;
+        return yield dockerode.createContainer({
             name: options.name,
             User: options.user,
             Image: options.imageName.toString(),
             Env: getEnv(options.env),
-            ExposedPorts: getExposedPorts(options.boundPorts),
+            ExposedPorts: getExposedPorts(options.exposedPorts),
             Cmd: options.cmd,
             Labels: create_labels_1.createLabels(options.imageName),
             // @ts-ignore
@@ -31,7 +32,7 @@ const createContainer = (options) => __awaiter(void 0, void 0, void 0, function*
                 ExtraHosts: getExtraHosts(options.extraHosts),
                 AutoRemove: options.autoRemove,
                 NetworkMode: options.networkMode,
-                PortBindings: getPortBindings(options.boundPorts),
+                PortBindings: getPortBindings(options.exposedPorts),
                 Binds: getBindMounts(options.bindMounts),
                 Tmpfs: options.tmpFs,
                 LogConfig: getLogConfig(options.useDefaultLogDriver),
@@ -46,20 +47,20 @@ const createContainer = (options) => __awaiter(void 0, void 0, void 0, function*
 });
 exports.createContainer = createContainer;
 const getEnv = (env) => Object.entries(env).reduce((dockerodeEnvironment, [key, value]) => [...dockerodeEnvironment, `${key}=${value}`], []);
-const getExposedPorts = (boundPorts) => {
+const getExposedPorts = (exposedPorts) => {
     const dockerodeExposedPorts = {};
-    for (const [internalPort] of boundPorts.iterator()) {
-        dockerodeExposedPorts[internalPort.toString()] = {};
+    for (const exposedPort of exposedPorts) {
+        dockerodeExposedPorts[exposedPort.toString()] = {};
     }
     return dockerodeExposedPorts;
 };
 const getExtraHosts = (extraHosts) => {
     return extraHosts.map((extraHost) => `${extraHost.host}:${extraHost.ipAddress}`);
 };
-const getPortBindings = (boundPorts) => {
+const getPortBindings = (exposedPorts) => {
     const dockerodePortBindings = {};
-    for (const [internalPort, hostPort] of boundPorts.iterator()) {
-        dockerodePortBindings[internalPort.toString()] = [{ HostPort: hostPort.toString() }];
+    for (const exposedPort of exposedPorts) {
+        dockerodePortBindings[exposedPort] = [{ HostPort: "0" }];
     }
     return dockerodePortBindings;
 };

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

@@ -19,18 +19,11 @@ const execContainer = (container, command) => __awaiter(void 0, void 0, void 0,
             AttachStderr: true,
         });
         const stream = yield startExec(exec);
-        return yield new Promise((resolve) => {
-            const chunks = [];
-            stream.on("data", (chunk) => chunks.push(chunk));
-            const interval = setInterval(() => __awaiter(void 0, void 0, void 0, function* () {
-                const { running, exitCode } = yield inspectExec(exec);
-                if (!running) {
-                    clearInterval(interval);
-                    stream.destroy();
-                    resolve({ output: chunks.join(""), exitCode });
-                }
-            }), 100);
-        });
+        const chunks = [];
+        stream.on("data", (chunk) => chunks.push(chunk));
+        const exitCode = yield waitForExec(exec);
+        stream.destroy();
+        return { output: chunks.join(""), exitCode };
     }
     catch (err) {
         logger_1.log.error(`Failed to exec container ${container.id} with command "${command.join(" ")}": ${err}`);
@@ -72,3 +65,14 @@ const inspectExec = (exec) => __awaiter(void 0, void 0, void 0, function* () {
         throw err;
     }
 });
+const waitForExec = (exec) => __awaiter(void 0, void 0, void 0, function* () {
+    return new Promise((resolve) => {
+        const interval = setInterval(() => __awaiter(void 0, void 0, void 0, function* () {
+            const { running, exitCode } = yield inspectExec(exec);
+            if (!running) {
+                clearInterval(interval);
+                resolve(exitCode);
+            }
+        }), 100);
+    });
+});

package/dist/docker/functions/container/get-container.d.ts

@@ -1,3 +1,3 @@
 import Dockerode from "dockerode";
 import { Id } from "../../types";
-export declare const getContainerById: (id: Id) => Dockerode.Container;
+export declare const getContainerById: (id: Id) => Promise<Dockerode.Container>;

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

@@ -1,6 +1,18 @@
 "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.getContainerById = void 0;
-const dockerode_1 = require("../../dockerode");
-const getContainerById = (id) => dockerode_1.dockerode.getContainer(id);
+const docker_client_1 = require("../../docker-client");
+const getContainerById = (id) => __awaiter(void 0, void 0, void 0, function* () {
+    const { dockerode } = yield docker_client_1.dockerClient;
+    return dockerode.getContainer(id);
+});
 exports.getContainerById = getContainerById;

package/dist/docker/functions/container/inspect-container.d.ts

@@ -1,10 +1,9 @@
-import { ContainerName, HealthCheckStatus, NetworkSettings } from "../../types";
-import { Port } from "../../../port";
+import { ContainerName, HealthCheckStatus, NetworkSettings, Ports } from "../../types";
 import Dockerode from "dockerode";
 export declare type InspectResult = {
     name: ContainerName;
-    internalPorts: Port[];
-    hostPorts: Port[];
+    hostname: string;
+    ports: Ports;
     healthCheckStatus: HealthCheckStatus;
     networkSettings: {
         [networkName: string]: NetworkSettings;

package/dist/docker/functions/container/inspect-container.js

@@ -15,9 +15,9 @@ const inspectContainer = (container) => __awaiter(void 0, void 0, void 0, functi
     try {
         const inspectResult = yield container.inspect();
         return {
-            hostPorts: getHostPorts(inspectResult),
-            internalPorts: getInternalPorts(inspectResult),
-            name: getName(inspectResult),
+            name: inspectResult.Name,
+            hostname: inspectResult.Config.Hostname,
+            ports: getPorts(inspectResult),
             healthCheckStatus: getHealthCheckStatus(inspectResult),
             networkSettings: getNetworkSettings(inspectResult),
             state: { status: inspectResult.State.Status, running: inspectResult.State.Running },
@@ -29,11 +29,13 @@ const inspectContainer = (container) => __awaiter(void 0, void 0, void 0, functi
     }
 });
 exports.inspectContainer = inspectContainer;
-const getHostPorts = (inspectInfo) => Object.values(inspectInfo.NetworkSettings.Ports)
-    .filter((portsArray) => portsArray !== null)
-    .map((portsArray) => Number(portsArray[0].HostPort));
-const getInternalPorts = (inspectInfo) => Object.keys(inspectInfo.NetworkSettings.Ports).map((port) => Number(port.split("/")[0]));
-const getName = (inspectInfo) => inspectInfo.Name;
+const getPorts = (inspectInfo) => Object.entries(inspectInfo.NetworkSettings.Ports)
+    .filter(([, hostPorts]) => hostPorts !== null)
+    .map(([internalPort, hostPorts]) => {
+    const hostPort = hostPorts[0].HostPort;
+    return { [parseInt(internalPort.split("/")[0])]: parseInt(hostPort) };
+})
+    .reduce((acc, curr) => (Object.assign(Object.assign({}, acc), curr)), {});
 const getHealthCheckStatus = (inspectResult) => {
     const health = inspectResult.State.Health;
     if (health === undefined) {

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

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

package/dist/docker/functions/demux-stream.d.ts

@@ -1,2 +1,2 @@
 import { Readable } from "stream";
-export declare const demuxStream: (stream: Readable) => Readable;
+export declare const demuxStream: (stream: Readable) => Promise<Readable>;

package/dist/docker/functions/demux-stream.js

@@ -1,13 +1,23 @@
 "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.demuxStream = void 0;
 const stream_1 = require("stream");
 const logger_1 = require("../../logger");
-const dockerode_1 = require("../dockerode");
-const demuxStream = (stream) => {
+const docker_client_1 = require("../docker-client");
+const demuxStream = (stream) => __awaiter(void 0, void 0, void 0, function* () {
     try {
         const demuxedStream = new stream_1.PassThrough({ autoDestroy: true, encoding: "utf-8" });
-        dockerode_1.dockerode.modem.demuxStream(stream, demuxedStream, demuxedStream);
+        const { dockerode } = yield docker_client_1.dockerClient;
+        dockerode.modem.demuxStream(stream, demuxedStream, demuxedStream);
         stream.on("end", () => demuxedStream.end());
         demuxedStream.on("close", () => {
             if (!stream.destroyed) {
@@ -20,5 +30,5 @@ const demuxStream = (stream) => {
         logger_1.log.error(`Failed to demux stream: ${err}`);
         throw err;
     }
-};
+});
 exports.demuxStream = demuxStream;

package/dist/docker/functions/get-info.js

@@ -10,9 +10,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDockerInfo = void 0;
-const dockerode_1 = require("../dockerode");
+const docker_client_1 = require("../docker-client");
 const getDockerInfo = () => __awaiter(void 0, void 0, void 0, function* () {
-    const info = yield dockerode_1.dockerode.info();
+    const { dockerode } = yield docker_client_1.dockerClient;
+    const info = yield dockerode.info();
     return {
         serverVersion: info.ServerVersion,
         operatingSystem: info.OperatingSystem,

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

@@ -18,14 +18,15 @@ const docker_ignore_1 = require("../../../docker-ignore");
 const tar_fs_1 = __importDefault(require("tar-fs"));
 const slash_1 = __importDefault(require("slash"));
 const byline_1 = __importDefault(require("byline"));
-const dockerode_1 = require("../../dockerode");
+const docker_client_1 = require("../../docker-client");
 const create_labels_1 = require("../create-labels");
 const buildImage = (options) => __awaiter(void 0, void 0, void 0, function* () {
     try {
         logger_1.log.info(`Building image '${options.imageName.toString()}' with context '${options.context}'`);
         const dockerIgnoreFiles = yield docker_ignore_1.findDockerIgnoreFiles(options.context, options.dockerfileName);
         const tarStream = tar_fs_1.default.pack(options.context, { ignore: (name) => dockerIgnoreFiles.has(slash_1.default(name)) });
-        return new Promise((resolve) => dockerode_1.dockerode
+        const { dockerode } = yield docker_client_1.dockerClient;
+        return new Promise((resolve) => dockerode
             .buildImage(tarStream, {
             dockerfile: options.dockerfileName,
             buildargs: options.buildArgs,

package/dist/docker/functions/image/list-images.js

@@ -11,11 +11,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.listImages = void 0;
 const docker_image_name_1 = require("../../../docker-image-name");
-const dockerode_1 = require("../../dockerode");
+const docker_client_1 = require("../../docker-client");
 const logger_1 = require("../../../logger");
 const listImages = () => __awaiter(void 0, void 0, void 0, function* () {
     try {
-        const images = yield dockerode_1.dockerode.listImages();
+        const { dockerode } = yield docker_client_1.dockerClient;
+        const images = yield dockerode.listImages();
         return images.reduce((dockerImageNames, image) => {
             if (isDanglingImage(image)) {
                 return dockerImageNames;

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

@@ -12,7 +12,7 @@ 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 dockerode_1 = require("../../dockerode");
+const docker_client_1 = require("../../docker-client");
 const image_exists_1 = require("./image-exists");
 const pullImage = (options) => __awaiter(void 0, void 0, void 0, function* () {
     try {
@@ -21,7 +21,8 @@ const pullImage = (options) => __awaiter(void 0, void 0, void 0, function* () {
             return;
         }
         logger_1.log.info(`Pulling image: ${options.imageName}`);
-        const stream = yield dockerode_1.dockerode.pull(options.imageName.toString(), { authconfig: options.authConfig });
+        const { dockerode } = yield docker_client_1.dockerClient;
+        const stream = yield dockerode.pull(options.imageName.toString(), { authconfig: options.authConfig });
         yield new pull_stream_parser_1.PullStreamParser(options.imageName, logger_1.log).consume(stream);
     }
     catch (err) {

package/dist/docker/functions/network/connect-network.js

@@ -11,11 +11,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.connectNetwork = void 0;
 const logger_1 = require("../../../logger");
-const dockerode_1 = require("../../dockerode");
+const docker_client_1 = require("../../docker-client");
 const connectNetwork = (options) => __awaiter(void 0, void 0, void 0, function* () {
     try {
         logger_1.log.info(`Connecting container ${options.containerId} to network ${options.networkId}`);
-        const network = dockerode_1.dockerode.getNetwork(options.networkId);
+        const { dockerode } = yield docker_client_1.dockerClient;
+        const network = dockerode.getNetwork(options.networkId);
         yield network.connect({ Container: options.containerId, EndpointConfig: { Aliases: options.networkAliases } });
     }
     catch (err) {