testcontainers 9.2.0 → 9.3.0

package/dist/src/reaper.js

@@ -0,0 +1,141 @@
+"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.ReaperInstance = void 0;
+const net_1 = require("net");
+const logger_1 = require("./logger");
+const generic_container_1 = require("./generic-container/generic-container");
+const session_id_1 = require("./docker/session-id");
+const images_1 = require("./images");
+const port_1 = require("./port");
+const labels_1 = require("./labels");
+const wait_1 = require("./wait");
+const retry_strategy_1 = require("./retry-strategy");
+const get_remote_docker_unix_socket_path_1 = require("./docker/get-remote-docker-unix-socket-path");
+const docker_client_1 = require("./docker/docker-client");
+class RealReaper {
+    constructor(container, socket) {
+        this.container = container;
+        this.socket = socket;
+    }
+    addProject(projectName) {
+        this.socket.write(`label=com.docker.compose.project=${projectName}\r\n`);
+    }
+    getContainerId() {
+        return this.container.getId();
+    }
+    stop() {
+        this.socket.end();
+    }
+}
+class DisabledReaper {
+    addProject() {
+        // noop
+    }
+    stop() {
+        // noop
+    }
+    getContainerId() {
+        return "";
+    }
+}
+class ReaperInstance {
+    static getInstance() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.instance) {
+                if (this.isEnabled()) {
+                    this.instance = this.createRealInstance();
+                }
+                else {
+                    this.instance = this.createDisabledInstance();
+                }
+            }
+            return this.instance;
+        });
+    }
+    static stopInstance() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.instance) {
+                const reaper = yield this.instance;
+                reaper.stop();
+                this.instance = undefined;
+            }
+        });
+    }
+    static isEnabled() {
+        return process.env.TESTCONTAINERS_RYUK_DISABLED !== "true";
+    }
+    static isPrivileged() {
+        return process.env.TESTCONTAINERS_RYUK_PRIVILEGED === "true";
+    }
+    static createDisabledInstance() {
+        logger_1.log.debug(`Not creating new Reaper for session: ${session_id_1.sessionId}`);
+        return Promise.resolve(new DisabledReaper());
+    }
+    static createRealInstance() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const containerPort = process.env["TESTCONTAINERS_RYUK_PORT"]
+                ? { container: 8080, host: Number(process.env["TESTCONTAINERS_RYUK_PORT"]) }
+                : 8080;
+            logger_1.log.debug(`Creating new Reaper for session: ${session_id_1.sessionId}`);
+            const container = new generic_container_1.GenericContainer(images_1.REAPER_IMAGE)
+                .withName(`testcontainers-ryuk-${session_id_1.sessionId}`)
+                .withExposedPorts(containerPort)
+                .withBindMounts([
+                {
+                    source: (0, get_remote_docker_unix_socket_path_1.getRemoteDockerUnixSocketPath)((yield (0, docker_client_1.dockerClient)()).uri),
+                    target: "/var/run/docker.sock",
+                },
+            ])
+                .withWaitStrategy(wait_1.Wait.forLogMessage(/.+ Started!/));
+            if (this.isPrivileged()) {
+                container.withPrivilegedMode();
+            }
+            const startedContainer = yield container.start();
+            const containerId = startedContainer.getId();
+            const host = startedContainer.getHost();
+            const port = startedContainer.getMappedPort(8080);
+            const retryStrategy = new retry_strategy_1.IntervalRetryStrategy(1000);
+            const retryResult = yield retryStrategy.retryUntil((attempt) => {
+                return new Promise((resolve) => {
+                    logger_1.log.debug(`Connecting to Reaper (attempt ${attempt + 1}) ${containerId} on ${host}:${port}`);
+                    const socket = new net_1.Socket();
+                    socket
+                        .unref()
+                        .on("timeout", () => logger_1.log.error(`Reaper ${containerId} socket timed out`))
+                        .on("error", (err) => logger_1.log.error(`Reaper ${containerId} socket error: ${err}`))
+                        .on("close", (hadError) => {
+                        if (hadError) {
+                            logger_1.log.error(`Connection to Reaper ${containerId} closed with error`);
+                        }
+                        else {
+                            logger_1.log.warn(`Connection to Reaper ${containerId} closed`);
+                        }
+                        resolve(undefined);
+                    })
+                        .connect((0, port_1.getContainerPort)(port), host, () => {
+                        logger_1.log.debug(`Connected to Reaper ${containerId}`);
+                        socket.write(`label=${labels_1.LABEL_TESTCONTAINERS_SESSION_ID}=${session_id_1.sessionId}\r\n`);
+                        const reaper = new RealReaper(startedContainer, socket);
+                        resolve(reaper);
+                    });
+                });
+            }, (result) => result !== undefined, () => new Error(`Failed to connect to Reaper ${containerId}`), 4000);
+            if (retryResult instanceof RealReaper) {
+                return retryResult;
+            }
+            else {
+                throw retryResult;
+            }
+        });
+    }
+}
+exports.ReaperInstance = ReaperInstance;

package/dist/src/registry-auth-locator/auths.d.ts

@@ -0,0 +1,8 @@
+import { DockerConfig } from "./types";
+import { RegistryAuthLocator } from "./registry-auth-locator";
+import { AuthConfig } from "../docker/types";
+export declare class Auths implements RegistryAuthLocator {
+    getName(): string;
+    getAuthConfig(registry: string, dockerConfig: DockerConfig): Promise<AuthConfig | undefined>;
+    private findAuthEntry;
+}

package/dist/src/registry-auth-locator/auths.js

@@ -0,0 +1,56 @@
+"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.Auths = void 0;
+const registry_matches_1 = require("./registry-matches");
+class Auths {
+    getName() {
+        return "Auths";
+    }
+    getAuthConfig(registry, dockerConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const auth = this.findAuthEntry(registry, dockerConfig);
+            if (!auth) {
+                return undefined;
+            }
+            const authConfig = { registryAddress: registry };
+            if (auth.email) {
+                authConfig.email = auth.email;
+            }
+            if (auth.auth) {
+                const decodedAuth = Buffer.from(auth.auth, "base64").toString();
+                const [username, password] = decodedAuth.split(":");
+                authConfig.username = username;
+                authConfig.password = password;
+            }
+            else {
+                if (auth.username) {
+                    authConfig.username = auth.username;
+                }
+                if (auth.password) {
+                    authConfig.password = auth.password;
+                }
+            }
+            return authConfig;
+        });
+    }
+    findAuthEntry(registry, dockerConfig) {
+        var _a;
+        const authEntries = (_a = dockerConfig.auths) !== null && _a !== void 0 ? _a : {};
+        for (const key in authEntries) {
+            if ((0, registry_matches_1.registryMatches)(key, registry)) {
+                return authEntries[key];
+            }
+        }
+        return undefined;
+    }
+}
+exports.Auths = Auths;

package/dist/src/registry-auth-locator/cred-helpers.d.ts

@@ -0,0 +1,6 @@
+import { CredentialProvider } from "./credential-provider";
+import { DockerConfig } from "./types";
+export declare class CredHelpers extends CredentialProvider {
+    getName(): string;
+    getCredentialProviderName(registry: string, dockerConfig: DockerConfig): string | undefined;
+}

package/dist/src/registry-auth-locator/cred-helpers.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CredHelpers = void 0;
+const credential_provider_1 = require("./credential-provider");
+class CredHelpers extends credential_provider_1.CredentialProvider {
+    getName() {
+        return "CredHelpers";
+    }
+    getCredentialProviderName(registry, dockerConfig) {
+        if (dockerConfig.credHelpers !== undefined && dockerConfig.credHelpers[registry] !== undefined) {
+            return dockerConfig.credHelpers[registry];
+        }
+    }
+}
+exports.CredHelpers = CredHelpers;

package/dist/src/registry-auth-locator/credential-provider.d.ts

@@ -0,0 +1,10 @@
+import { DockerConfig } from "./types";
+import { RegistryAuthLocator } from "./registry-auth-locator";
+import { AuthConfig } from "../docker/types";
+export declare abstract class CredentialProvider implements RegistryAuthLocator {
+    abstract getName(): string;
+    abstract getCredentialProviderName(registry: string, dockerConfig: DockerConfig): string | undefined;
+    getAuthConfig(registry: string, dockerConfig: DockerConfig): Promise<AuthConfig | undefined>;
+    private listCredentials;
+    private runCredentialProvider;
+}

package/dist/src/registry-auth-locator/credential-provider.js

@@ -0,0 +1,83 @@
+"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.CredentialProvider = void 0;
+const logger_1 = require("../logger");
+const child_process_1 = require("child_process");
+const registry_matches_1 = require("./registry-matches");
+class CredentialProvider {
+    getAuthConfig(registry, dockerConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const credentialProviderName = this.getCredentialProviderName(registry, dockerConfig);
+            if (!credentialProviderName) {
+                return undefined;
+            }
+            const programName = `docker-credential-${credentialProviderName}`;
+            logger_1.log.debug(`Executing Docker credential provider: ${programName}`);
+            const credentials = yield this.listCredentials(programName);
+            if (!Object.keys(credentials).some((aRegistry) => (0, registry_matches_1.registryMatches)(aRegistry, registry))) {
+                logger_1.log.debug(`No credential found for registry: "${registry}"`);
+                return undefined;
+            }
+            const response = yield this.runCredentialProvider(registry, programName);
+            const authConfig = {
+                username: response.Username,
+                password: response.Secret,
+                registryAddress: response.ServerURL,
+            };
+            logger_1.log.debug(`Docker credential provider found auth config for ${registry}`);
+            return authConfig;
+        });
+    }
+    listCredentials(providerName) {
+        return new Promise((resolve, reject) => {
+            (0, child_process_1.exec)(`${providerName} list`, (err, stdout) => {
+                if (err) {
+                    logger_1.log.error(`An error occurred listing credentials: ${err}`);
+                    return reject(new Error("An error occurred listing credentials"));
+                }
+                try {
+                    const response = JSON.parse(stdout);
+                    return resolve(response);
+                }
+                catch (e) {
+                    logger_1.log.error(`Unexpected response from Docker credential provider LIST command: "${stdout}"`);
+                    return reject(new Error("Unexpected response from Docker credential provider LIST command"));
+                }
+            });
+        });
+    }
+    runCredentialProvider(registry, providerName) {
+        return new Promise((resolve, reject) => {
+            const sink = (0, child_process_1.spawn)(providerName, ["get"]);
+            const chunks = [];
+            sink.stdout.on("data", (chunk) => chunks.push(chunk));
+            sink.on("close", (code) => {
+                if (code !== 0) {
+                    logger_1.log.error(`An error occurred getting a credential: ${code}`);
+                    return reject(new Error("An error occurred getting a credential"));
+                }
+                const response = chunks.join("");
+                try {
+                    const parsedResponse = JSON.parse(response);
+                    return resolve(parsedResponse);
+                }
+                catch (e) {
+                    logger_1.log.error(`Unexpected response from Docker credential provider GET command: "${response}"`);
+                    return reject(new Error("Unexpected response from Docker credential provider GET command"));
+                }
+            });
+            sink.stdin.write(`${registry}\n`);
+            sink.stdin.end();
+        });
+    }
+}
+exports.CredentialProvider = CredentialProvider;

package/dist/src/registry-auth-locator/creds-store.d.ts

@@ -0,0 +1,6 @@
+import { CredentialProvider } from "./credential-provider";
+import { DockerConfig } from "./types";
+export declare class CredsStore extends CredentialProvider {
+    getName(): string;
+    getCredentialProviderName(registry: string, dockerConfig: DockerConfig): string | undefined;
+}

package/dist/src/registry-auth-locator/creds-store.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CredsStore = void 0;
+const credential_provider_1 = require("./credential-provider");
+class CredsStore extends credential_provider_1.CredentialProvider {
+    getName() {
+        return "CredsStore";
+    }
+    getCredentialProviderName(registry, dockerConfig) {
+        if (dockerConfig.credsStore !== undefined && dockerConfig.credsStore.length > 0) {
+            return dockerConfig.credsStore;
+        }
+    }
+}
+exports.CredsStore = CredsStore;

package/dist/src/registry-auth-locator/get-auth-config.d.ts

@@ -0,0 +1,2 @@
+import { AuthConfig } from "../docker/types";
+export declare const getAuthConfig: (registry: string) => Promise<AuthConfig | undefined>;

package/dist/src/registry-auth-locator/get-auth-config.js

@@ -0,0 +1,65 @@
+"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.getAuthConfig = void 0;
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const cred_helpers_1 = require("./cred-helpers");
+const creds_store_1 = require("./creds-store");
+const auths_1 = require("./auths");
+const logger_1 = require("../logger");
+const dockerConfigLocation = process.env.DOCKER_CONFIG || `${os_1.default.homedir()}/.docker`;
+const dockerConfigFile = path_1.default.resolve(dockerConfigLocation, "config.json");
+const readDockerConfig = () => __awaiter(void 0, void 0, void 0, function* () {
+    if (process.env.DOCKER_AUTH_CONFIG) {
+        return parseDockerConfig(process.env.DOCKER_AUTH_CONFIG);
+    }
+    else if ((0, fs_1.existsSync)(dockerConfigFile)) {
+        return parseDockerConfig((yield (0, promises_1.readFile)(dockerConfigFile)).toString());
+    }
+    else {
+        return Promise.resolve({});
+    }
+});
+function parseDockerConfig(dockerConfig) {
+    const object = JSON.parse(dockerConfig);
+    return {
+        credsStore: object.credsStore,
+        credHelpers: object.credHelpers,
+        auths: object.auths,
+    };
+}
+const dockerConfig = readDockerConfig();
+const registryAuthLocators = [new cred_helpers_1.CredHelpers(), new creds_store_1.CredsStore(), new auths_1.Auths()];
+const authsCache = new Map();
+const getAuthConfig = (registry) => __awaiter(void 0, void 0, void 0, function* () {
+    if (authsCache.has(registry)) {
+        logger_1.log.debug(`Re-using cached auth for registry ${registry}`);
+        return authsCache.get(registry);
+    }
+    for (const registryAuthLocator of registryAuthLocators) {
+        const authConfig = yield registryAuthLocator.getAuthConfig(registry, yield dockerConfig);
+        if (authConfig) {
+            logger_1.log.debug(`Found applicable registry auth locator for registry "${registry}": ${registryAuthLocator.getName()}`);
+            authsCache.set(registry, authConfig);
+            return authConfig;
+        }
+    }
+    logger_1.log.debug(`No registry auth locator found for registry: "${registry}"`);
+    authsCache.set(registry, undefined);
+    return undefined;
+});
+exports.getAuthConfig = getAuthConfig;

package/dist/src/registry-auth-locator/registry-auth-locator.d.ts

@@ -0,0 +1,6 @@
+import { DockerConfig } from "./types";
+import { AuthConfig } from "../docker/types";
+export interface RegistryAuthLocator {
+    getName(): string;
+    getAuthConfig(registry: string, dockerConfig: DockerConfig): Promise<AuthConfig | undefined>;
+}

package/dist/src/registry-auth-locator/registry-auth-locator.js

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

package/dist/src/registry-auth-locator/registry-matches.d.ts

@@ -0,0 +1 @@
+export declare const registryMatches: (authConfigRegistry: string, requestedRegistry: string) => boolean;

package/dist/src/registry-auth-locator/registry-matches.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registryMatches = void 0;
+const registryMatches = (authConfigRegistry, requestedRegistry) => authConfigRegistry == requestedRegistry || authConfigRegistry.endsWith("://" + requestedRegistry);
+exports.registryMatches = registryMatches;

package/dist/src/registry-auth-locator/types.d.ts

@@ -0,0 +1,23 @@
+export type CredentialProviderGetResponse = {
+    ServerURL: string;
+    Username: string;
+    Secret: string;
+};
+export type CredentialProviderListResponse = {
+    [registry: string]: string;
+};
+export type Auth = {
+    auth?: string;
+    email?: string;
+    username?: string;
+    password?: string;
+};
+export type DockerConfig = {
+    credHelpers?: {
+        [registry: string]: string;
+    };
+    credsStore?: string;
+    auths?: {
+        [registry: string]: Auth;
+    };
+};

package/dist/src/registry-auth-locator/types.js

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

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

@@ -0,0 +1,17 @@
+import { Clock, Time } from "./clock";
+export interface RetryStrategy<T, U> {
+    retryUntil(fn: () => Promise<T>, predicate: (result: T) => boolean | Promise<boolean>, onTimeout: () => U, timeout: number): Promise<T | U>;
+}
+declare abstract class AbstractRetryStrategy<T, U> implements RetryStrategy<T, U> {
+    protected readonly clock: Clock;
+    protected constructor(clock?: Clock);
+    abstract retryUntil(fn: () => Promise<T>, predicate: (result: T) => boolean | Promise<boolean>, onTimeout: () => U, timeout: number): Promise<T | U>;
+    protected hasTimedOut(timeout: number, startTime: Time): boolean;
+    protected wait(duration: number): Promise<void>;
+}
+export declare class IntervalRetryStrategy<T, U> extends AbstractRetryStrategy<T, U> {
+    private readonly interval;
+    constructor(interval: number);
+    retryUntil(fn: (attempt: number) => Promise<T>, predicate: (result: T) => boolean | Promise<boolean>, onTimeout: () => U, timeout: number): Promise<T | U>;
+}
+export {};

package/dist/src/retry-strategy.js

@@ -0,0 +1,46 @@
+"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.IntervalRetryStrategy = void 0;
+const clock_1 = require("./clock");
+class AbstractRetryStrategy {
+    constructor(clock = new clock_1.SystemClock()) {
+        this.clock = clock;
+    }
+    hasTimedOut(timeout, startTime) {
+        return this.clock.getTime() - startTime > timeout;
+    }
+    wait(duration) {
+        return new Promise((resolve) => setTimeout(resolve, duration));
+    }
+}
+class IntervalRetryStrategy extends AbstractRetryStrategy {
+    constructor(interval) {
+        super();
+        this.interval = interval;
+    }
+    retryUntil(fn, predicate, onTimeout, timeout) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const startTime = this.clock.getTime();
+            let attemptNumber = 0;
+            let result = yield fn(attemptNumber++);
+            while (!(yield predicate(result))) {
+                if (this.hasTimedOut(timeout, startTime)) {
+                    return onTimeout();
+                }
+                yield this.wait(this.interval);
+                result = yield fn(attemptNumber++);
+            }
+            return result;
+        });
+    }
+}
+exports.IntervalRetryStrategy = IntervalRetryStrategy;

package/dist/src/startup-check-strategy.d.ts

@@ -0,0 +1,7 @@
+import { AbstractWaitStrategy } from "./wait-strategy";
+import Dockerode from "dockerode";
+export type StartupStatus = "PENDING" | "SUCCESS" | "FAIL";
+export declare abstract class StartupCheckStrategy extends AbstractWaitStrategy {
+    abstract checkStartupState(dockerClient: Dockerode, containerId: string): Promise<StartupStatus>;
+    waitUntilReady(container: Dockerode.Container): Promise<void>;
+}

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

@@ -0,0 +1,30 @@
+"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.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");
+class StartupCheckStrategy extends wait_strategy_1.AbstractWaitStrategy {
+    waitUntilReady(container) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { dockerode } = yield (0, docker_client_1.dockerClient)();
+            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 ${this.startupTimeout}ms for ${container.id}`), this.startupTimeout);
+            if (startupStatus instanceof Error) {
+                throw startupStatus;
+            }
+            else if (startupStatus === "FAIL") {
+                throw new Error(`Container failed to start for ${container.id}`);
+            }
+        });
+    }
+}
+exports.StartupCheckStrategy = StartupCheckStrategy;

package/dist/src/stream-utils.d.ts

@@ -0,0 +1,6 @@
+import { Readable } from "stream";
+type Options = {
+    trim: boolean;
+};
+export declare const streamToString: (stream: Readable, options?: Options) => Promise<string>;
+export {};

package/dist/src/stream-utils.js

@@ -0,0 +1,46 @@
+"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 __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.streamToString = void 0;
+const streamToString = (stream, options = { trim: false }) => { var _a, stream_1, stream_1_1; return __awaiter(void 0, void 0, void 0, function* () {
+    var _b, e_1, _c, _d;
+    const chunks = [];
+    try {
+        for (_a = true, stream_1 = __asyncValues(stream); stream_1_1 = yield stream_1.next(), _b = stream_1_1.done, !_b;) {
+            _d = stream_1_1.value;
+            _a = false;
+            try {
+                const chunk = _d;
+                chunks.push(Buffer.from(chunk));
+            }
+            finally {
+                _a = true;
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (!_a && !_b && (_c = stream_1.return)) yield _c.call(stream_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    const str = Buffer.concat(chunks).toString("utf-8");
+    return options.trim ? str.trim() : str;
+}); };
+exports.streamToString = streamToString;

package/dist/src/system-info.d.ts

@@ -0,0 +1,17 @@
+import { DockerInfo } from "./docker/functions/get-info";
+import Dockerode from "dockerode";
+export type SystemInfo = {
+    nodeInfo: NodeInfo;
+    dockerInfo: DockerInfo;
+    dockerComposeInfo?: DockerComposeInfo;
+};
+export declare const getSystemInfo: (dockerode: Dockerode) => Promise<SystemInfo>;
+type NodeInfo = {
+    version: string;
+    architecture: string;
+    platform: string;
+};
+export type DockerComposeInfo = {
+    version: string;
+};
+export {};