testcontainers 9.5.0 → 9.7.0

package/dist/src/docker/resolve-host.d.ts

@@ -3,4 +3,5 @@
 /// <reference types="node" />
 /// <reference types="node" />
 import Dockerode from "dockerode";
-export declare const resolveHost: (dockerode: Dockerode, indexServerAddress: string, uri: string, env?: NodeJS.ProcessEnv) => Promise<string>;
+import { Provider } from "./docker-client";
+export declare const resolveHost: (dockerode: Dockerode, provider: Provider, indexServerAddress: string, uri: string, env?: NodeJS.ProcessEnv) => Promise<string>;

package/dist/src/docker/resolve-host.js

@@ -14,7 +14,7 @@ const url_1 = require("url");
 const logger_1 = require("../logger");
 const run_in_container_1 = require("./functions/run-in-container");
 const fs_1 = require("fs");
-const resolveHost = (dockerode, indexServerAddress, uri, env = process.env) => __awaiter(void 0, void 0, void 0, function* () {
+const resolveHost = (dockerode, provider, indexServerAddress, uri, env = process.env) => __awaiter(void 0, void 0, void 0, function* () {
     if (env.TESTCONTAINERS_HOST_OVERRIDE !== undefined) {
         return env.TESTCONTAINERS_HOST_OVERRIDE;
     }
@@ -27,7 +27,8 @@ const resolveHost = (dockerode, indexServerAddress, uri, env = process.env) => _
         case "unix:":
         case "npipe:": {
             if (isInContainer()) {
-                const gateway = yield findGateway(dockerode);
+                const networkName = provider === "podman" ? "podman" : "bridge";
+                const gateway = yield findGateway(dockerode, networkName);
                 if (gateway !== undefined) {
                     return gateway;
                 }
@@ -43,14 +44,14 @@ const resolveHost = (dockerode, indexServerAddress, uri, env = process.env) => _
     }
 });
 exports.resolveHost = resolveHost;
-const findGateway = (dockerode) => __awaiter(void 0, void 0, void 0, function* () {
+const findGateway = (dockerode, networkName) => __awaiter(void 0, void 0, void 0, function* () {
     var _a, _b, _c;
-    logger_1.log.debug(`Checking gateway for Docker host`);
-    const inspectResult = yield dockerode.getNetwork("bridge").inspect();
+    logger_1.log.debug(`Checking gateway for Docker host...`);
+    const inspectResult = yield dockerode.getNetwork(networkName).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, indexServerAddress) => __awaiter(void 0, void 0, void 0, function* () {
-    logger_1.log.debug(`Checking default gateway for Docker host`);
+    logger_1.log.debug(`Checking default gateway for Docker host...`);
     return (0, run_in_container_1.runInContainer)(dockerode, indexServerAddress, "alpine:3.14", [
         "sh",
         "-c",

package/dist/src/docker-compose/default-docker-compose-options.js

@@ -26,17 +26,19 @@ const logger_1 = require("../logger");
 const os_1 = require("os");
 const type_guards_1 = require("../type-guards");
 const defaultDockerComposeOptions = (_a) => __awaiter(void 0, void 0, void 0, function* () {
+    var _b;
     var { environment = {} } = _a, options = __rest(_a, ["environment"]);
     const { composeEnvironment } = yield (0, docker_client_1.dockerClient)();
+    const log = (_b = options.logger) !== null && _b !== void 0 ? _b : logger_1.composeLog;
     return {
         log: false,
-        callback: logger_1.log.enabled()
+        callback: log.enabled()
             ? (chunk) => {
                 chunk
                     .toString()
                     .split(os_1.EOL)
                     .filter(type_guards_1.isNotEmptyString)
-                    .forEach((line) => logger_1.log.trace(line.trim()));
+                    .forEach((line) => log.trace(line.trim()));
             }
             : undefined,
         cwd: options.filePath,

package/dist/src/docker-compose/docker-compose-options.d.ts

@@ -1,4 +1,5 @@
 import { Environment } from "../docker/types";
+import { Logger } from "../logger";
 export type DockerComposeOptions = {
     filePath: string;
     files: string | string[];
@@ -6,4 +7,5 @@ export type DockerComposeOptions = {
     commandOptions?: string[];
     composeOptions?: string[];
     environment?: Environment;
+    logger?: Logger;
 };

package/dist/src/docker-compose/functions/docker-compose-down.js

@@ -14,7 +14,7 @@ const logger_1 = require("../../logger");
 const default_docker_compose_options_1 = require("../default-docker-compose-options");
 const docker_compose_1 = require("docker-compose");
 const dockerComposeDown = (options, downOptions) => __awaiter(void 0, void 0, void 0, function* () {
-    logger_1.log.info(`Downing DockerCompose environment`);
+    logger_1.log.info(`Downing DockerCompose environment...`);
     try {
         yield (0, docker_compose_1.down)(Object.assign(Object.assign({}, (yield (0, default_docker_compose_options_1.defaultDockerComposeOptions)(options))), { commandOptions: commandOptions(downOptions) }));
         logger_1.log.info(`Downed DockerCompose environment`);

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

@@ -16,12 +16,12 @@ const default_docker_compose_options_1 = require("../default-docker-compose-opti
 const dockerComposePull = (options, services) => __awaiter(void 0, void 0, void 0, function* () {
     try {
         if (services) {
-            logger_1.log.info(`Pulling DockerCompose environment images for ${services.join(", ")}`);
-            yield (0, docker_compose_1.pullMany)(services, yield (0, default_docker_compose_options_1.defaultDockerComposeOptions)(options));
+            logger_1.log.info(`Pulling DockerCompose environment images "${services.join('", "')}"...`);
+            yield (0, docker_compose_1.pullMany)(services, yield (0, default_docker_compose_options_1.defaultDockerComposeOptions)(Object.assign(Object.assign({}, options), { logger: logger_1.pullLog })));
         }
         else {
-            logger_1.log.info(`Pulling DockerCompose environment images`);
-            yield (0, docker_compose_1.pullAll)(yield (0, default_docker_compose_options_1.defaultDockerComposeOptions)(options));
+            logger_1.log.info(`Pulling DockerCompose environment images...`);
+            yield (0, docker_compose_1.pullAll)(yield (0, default_docker_compose_options_1.defaultDockerComposeOptions)(Object.assign(Object.assign({}, options), { logger: logger_1.pullLog })));
         }
         logger_1.log.info(`Pulled DockerCompose environment`);
         // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/dist/src/docker-compose/functions/docker-compose-stop.js

@@ -14,7 +14,7 @@ const logger_1 = require("../../logger");
 const docker_compose_1 = require("docker-compose");
 const default_docker_compose_options_1 = require("../default-docker-compose-options");
 const dockerComposeStop = (options) => __awaiter(void 0, void 0, void 0, function* () {
-    logger_1.log.info(`Stopping DockerCompose environment`);
+    logger_1.log.info(`Stopping DockerCompose environment...`);
     try {
         yield (0, docker_compose_1.stop)(yield (0, default_docker_compose_options_1.defaultDockerComposeOptions)(options));
         logger_1.log.info(`Stopped DockerCompose environment`);

package/dist/src/docker-compose/functions/docker-compose-up.js

@@ -15,7 +15,7 @@ const docker_compose_1 = require("docker-compose");
 const default_docker_compose_options_1 = require("../default-docker-compose-options");
 const docker_compose_down_1 = require("./docker-compose-down");
 const dockerComposeUp = (options, services) => __awaiter(void 0, void 0, void 0, function* () {
-    logger_1.log.info(`Upping DockerCompose environment`);
+    logger_1.log.info(`Upping DockerCompose environment...`);
     try {
         if (services) {
             yield (0, docker_compose_1.upMany)(services, yield (0, default_docker_compose_options_1.defaultDockerComposeOptions)(options));

package/dist/src/docker-compose-environment/docker-compose-environment.d.ts

@@ -14,7 +14,7 @@ export declare class DockerComposeEnvironment {
     private environment;
     private pullPolicy;
     private waitStrategy;
-    private startupTimeout;
+    private startupTimeout?;
     constructor(composeFilePath: string, composeFiles: string | string[], uuid?: Uuid);
     withBuild(): this;
     withEnvironment(environment: Environment): this;

package/dist/src/docker-compose-environment/docker-compose-environment.js

@@ -25,9 +25,9 @@ const started_docker_compose_environment_1 = require("./started-docker-compose-e
 const docker_compose_down_1 = require("../docker-compose/functions/docker-compose-down");
 const docker_compose_up_1 = require("../docker-compose/functions/docker-compose-up");
 const wait_for_container_1 = require("../wait-for-container");
-const default_wait_strategy_1 = require("../wait-strategy/default-wait-strategy");
 const pull_policy_1 = require("../pull-policy");
 const docker_compose_pull_1 = require("../docker-compose/functions/docker-compose-pull");
+const wait_1 = require("../wait-strategy/wait");
 class DockerComposeEnvironment {
     constructor(composeFilePath, composeFiles, uuid = new uuid_1.RandomUuid()) {
         this.build = false;
@@ -37,7 +37,6 @@ class DockerComposeEnvironment {
         this.environment = {};
         this.pullPolicy = new pull_policy_1.DefaultPullPolicy();
         this.waitStrategy = {};
-        this.startupTimeout = 60000;
         this.composeFilePath = composeFilePath;
         this.composeFiles = composeFiles;
         this.projectName = `testcontainers-${uuid.nextUuid()}`;
@@ -77,7 +76,7 @@ class DockerComposeEnvironment {
     }
     up(services) {
         return __awaiter(this, void 0, void 0, function* () {
-            logger_1.log.info(`Starting DockerCompose environment: ${this.projectName}`);
+            logger_1.log.info(`Starting DockerCompose environment "${this.projectName}"...`);
             (yield reaper_1.ReaperInstance.getInstance()).addProject(this.projectName);
             const options = {
                 filePath: this.composeFilePath,
@@ -105,26 +104,28 @@ class DockerComposeEnvironment {
                 ...containerNames,
                 startedContainer.Names.join(", "),
             ], []);
-            logger_1.log.info(`Started the following containers: ${startedContainerNames.join(", ")}`);
+            logger_1.log.info(`Started containers "${startedContainerNames.join('", "')}"`);
             const startedGenericContainers = (yield Promise.all(startedContainers.map((startedContainer) => __awaiter(this, void 0, void 0, function* () {
                 const container = yield (0, get_container_1.getContainerById)(startedContainer.Id);
                 const containerName = (0, container_name_resolver_1.resolveContainerName)(this.projectName, startedContainer.Names[0]);
                 const { host, hostIps } = yield (0, docker_client_1.dockerClient)();
                 const inspectResult = yield (0, inspect_container_1.inspectContainer)(container);
                 const boundPorts = bound_ports_1.BoundPorts.fromInspectResult(hostIps, inspectResult);
-                const waitStrategy = (this.waitStrategy[containerName] ? this.waitStrategy[containerName] : (0, default_wait_strategy_1.defaultWaitStrategy)(host, container)).withStartupTimeout(this.startupTimeout);
+                const waitStrategy = this.waitStrategy[containerName]
+                    ? this.waitStrategy[containerName]
+                    : wait_1.Wait.forListeningPorts();
+                if (this.startupTimeout !== undefined) {
+                    waitStrategy.withStartupTimeout(this.startupTimeout);
+                }
                 if (logger_1.containerLog.enabled()) {
                     (yield (0, container_logs_1.containerLogs)(container))
                         .on("data", (data) => logger_1.containerLog.trace(`${containerName}: ${data.trim()}`))
                         .on("err", (data) => logger_1.containerLog.error(`${containerName}: ${data.trim()}`));
                 }
                 try {
-                    logger_1.log.info(`Waiting for container ${containerName} to be ready`);
-                    yield (0, wait_for_container_1.waitForContainer)(container, waitStrategy, host, boundPorts);
-                    logger_1.log.info(`Container ${containerName} is ready`);
+                    yield (0, wait_for_container_1.waitForContainer)(container, waitStrategy, boundPorts);
                 }
                 catch (err) {
-                    logger_1.log.error(`Container ${containerName} failed to be ready: ${err}`);
                     try {
                         yield (0, docker_compose_down_1.dockerComposeDown)(options, { removeVolumes: true, timeout: 0 });
                     }
@@ -138,7 +139,7 @@ class DockerComposeEnvironment {
                 const containerName = startedGenericContainer.getName();
                 return Object.assign(Object.assign({}, map), { [containerName]: startedGenericContainer });
             }, {});
-            logger_1.log.info(`DockerCompose environment started: ${Object.keys(startedGenericContainers).join(", ")}`);
+            logger_1.log.info(`DockerCompose environment started`);
             return new started_docker_compose_environment_1.StartedDockerComposeEnvironment(startedGenericContainers, Object.assign(Object.assign({}, options), { composeOptions, environment: this.environment }));
         });
     }

package/dist/src/generic-container/generic-container-builder.js

@@ -52,7 +52,7 @@ class GenericContainerBuilder {
             const imageName = docker_image_name_1.DockerImageName.fromString(image);
             yield reaper_1.ReaperInstance.getInstance();
             const dockerfile = path_1.default.resolve(this.context, this.dockerfileName);
-            logger_1.log.debug(`Preparing to build Dockerfile: ${dockerfile}`);
+            logger_1.log.debug(`Preparing to build Dockerfile "${dockerfile}" as image "${imageName}"...`);
             const imageNames = yield (0, dockerfile_parser_1.getDockerfileImages)(dockerfile, this.buildArgs);
             const { dockerode, indexServerAddress } = yield (0, docker_client_1.dockerClient)();
             const registryConfig = yield this.getRegistryConfig(indexServerAddress, imageNames);

package/dist/src/generic-container/generic-container.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import archiver from "archiver";
 import { BoundPorts } from "../bound-ports";
 import { PortWithOptionalBinding } from "../port";
@@ -9,16 +10,18 @@ import { CreateContainerOptions } from "../docker/functions/container/create-con
 import { InspectResult } from "../docker/functions/container/inspect-container";
 import { GenericContainerBuilder } from "./generic-container-builder";
 import { StartedNetwork } from "../network";
+import { Readable } from "stream";
 export declare class GenericContainer implements TestContainer {
     readonly image: string;
     static fromDockerfile(context: string, dockerfileName?: string): GenericContainerBuilder;
     protected opts: CreateContainerOptions;
-    protected startupTimeout: number;
-    protected waitStrategy?: WaitStrategy;
+    protected startupTimeout?: number;
+    protected waitStrategy: WaitStrategy;
     protected tarToCopy?: archiver.Archiver;
     protected networkMode?: string;
     protected networkAliases: string[];
     protected pullPolicy: PullPolicy;
+    protected logConsumer?: (stream: Readable) => unknown;
     constructor(image: string);
     /**
      * @deprecated Since version 9.4.0. Will be removed in version 10.0.0. Use `beforeContainerStarted` instead.
@@ -65,4 +68,5 @@ export declare class GenericContainer implements TestContainer {
     protected getTarToCopy(): archiver.Archiver;
     withWorkingDir(workingDir: string): this;
     withResourcesQuota({ memory, cpu }: ResourcesQuota): this;
+    withLogConsumer(logConsumer: (stream: Readable) => unknown): this;
 }

package/dist/src/generic-container/generic-container.js

@@ -36,7 +36,7 @@ const get_container_1 = require("../docker/functions/container/get-container");
 const labels_1 = require("../labels");
 const wait_for_container_1 = require("../wait-for-container");
 const create_container_options_1 = require("./create-container-options");
-const default_wait_strategy_1 = require("../wait-strategy/default-wait-strategy");
+const wait_1 = require("../wait-strategy/wait");
 const reusableContainerCreationLock = new async_lock_1.default();
 class GenericContainer {
     static fromDockerfile(context, dockerfileName = "Dockerfile") {
@@ -44,7 +44,7 @@ class GenericContainer {
     }
     constructor(image) {
         this.image = image;
-        this.startupTimeout = 60000;
+        this.waitStrategy = wait_1.Wait.forListeningPorts();
         this.networkAliases = [];
         this.pullPolicy = new pull_policy_1.DefaultPullPolicy();
         const imageName = docker_image_name_1.DockerImageName.fromString(image);
@@ -79,14 +79,14 @@ class GenericContainer {
             if (this.opts.reusable) {
                 const containerHash = (0, hash_1.hash)(JSON.stringify(this.opts));
                 this.opts.labels = Object.assign(Object.assign({}, this.opts.labels), { [labels_1.LABEL_TESTCONTAINERS_CONTAINER_HASH]: containerHash });
-                logger_1.log.debug(`Container reuse has been enabled, hash: ${containerHash}`);
+                logger_1.log.debug(`Container reuse has been enabled with hash "${containerHash}"`);
                 // We might have several async processes try to create a reusable container
                 // at once, to avoid possibly creating too many of these, use a lock
                 // on the containerHash, this ensures that only single reusable instance is created
                 return reusableContainerCreationLock.acquire(containerHash, () => __awaiter(this, void 0, void 0, function* () {
                     const container = yield (0, get_container_1.getContainerByHash)(containerHash);
                     if (container !== undefined) {
-                        logger_1.log.debug(`Found container to reuse with hash: ${containerHash}`);
+                        logger_1.log.debug(`Found container to reuse with hash "${containerHash}"`, { containerId: container.id });
                         return this.reuseContainer(container);
                     }
                     else {
@@ -101,17 +101,18 @@ class GenericContainer {
         });
     }
     reuseContainer(container) {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             const { host, hostIps } = yield (0, docker_client_1.dockerClient)();
             const inspectResult = yield (0, inspect_container_1.inspectContainer)(container);
             const boundPorts = bound_ports_1.BoundPorts.fromInspectResult(hostIps, inspectResult).filter(this.opts.exposedPorts);
-            const waitStrategy = ((_a = this.waitStrategy) !== null && _a !== void 0 ? _a : (0, default_wait_strategy_1.defaultWaitStrategy)(host, container)).withStartupTimeout(this.startupTimeout);
+            if (this.startupTimeout !== undefined) {
+                this.waitStrategy.withStartupTimeout(this.startupTimeout);
+            }
             if (this.containerStarting) {
                 yield this.containerStarting(inspectResult, true);
             }
-            yield (0, wait_for_container_1.waitForContainer)(container, waitStrategy, host, boundPorts);
-            const startedContainer = new started_generic_container_1.StartedGenericContainer(container, host, inspectResult, boundPorts, inspectResult.name, waitStrategy);
+            yield (0, wait_for_container_1.waitForContainer)(container, this.waitStrategy, boundPorts);
+            const startedContainer = new started_generic_container_1.StartedGenericContainer(container, host, inspectResult, boundPorts, inspectResult.name, this.waitStrategy);
             if (this.containerStarted) {
                 yield this.containerStarted(startedContainer, inspectResult, true);
             }
@@ -122,7 +123,6 @@ class GenericContainer {
         });
     }
     startContainer(createContainerOptions) {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             const container = yield (0, create_container_1.createContainer)(createContainerOptions);
             if (!this.opts.imageName.isHelperContainer() && port_forwarder_1.PortForwarderInstance.isRunning()) {
@@ -148,25 +148,34 @@ class GenericContainer {
                 this.tarToCopy.finalize();
                 yield (0, put_container_archive_1.putContainerArchive)({ container, stream: this.tarToCopy, containerPath: "/" });
             }
-            logger_1.log.info(`Starting container ${this.opts.imageName} with ID: ${container.id}`);
+            logger_1.log.info(`Starting container for image "${this.opts.imageName}"...`, { containerId: container.id });
             if (this.containerCreated) {
                 yield this.containerCreated(container.id);
             }
             yield (0, start_container_1.startContainer)(container);
+            logger_1.log.info(`Started container for image "${this.opts.imageName}"`, { containerId: container.id });
             const { host, hostIps } = yield (0, docker_client_1.dockerClient)();
             const inspectResult = yield (0, inspect_container_1.inspectContainer)(container);
             const boundPorts = bound_ports_1.BoundPorts.fromInspectResult(hostIps, inspectResult).filter(this.opts.exposedPorts);
-            const waitStrategy = ((_a = this.waitStrategy) !== null && _a !== void 0 ? _a : (0, default_wait_strategy_1.defaultWaitStrategy)(host, container)).withStartupTimeout(this.startupTimeout);
-            if (logger_1.containerLog.enabled()) {
-                (yield (0, container_logs_1.containerLogs)(container))
-                    .on("data", (data) => logger_1.containerLog.trace(`${container.id}: ${data.trim()}`))
-                    .on("err", (data) => logger_1.containerLog.error(`${container.id}: ${data.trim()}`));
+            if (this.startupTimeout !== undefined) {
+                this.waitStrategy.withStartupTimeout(this.startupTimeout);
+            }
+            if (logger_1.containerLog.enabled() || this.logConsumer !== undefined) {
+                const logStream = yield (0, container_logs_1.containerLogs)(container);
+                if (this.logConsumer !== undefined) {
+                    this.logConsumer(logStream);
+                }
+                if (logger_1.containerLog.enabled()) {
+                    logStream
+                        .on("data", (data) => logger_1.containerLog.trace(data.trim(), { containerId: container.id }))
+                        .on("err", (data) => logger_1.containerLog.error(data.trim(), { containerId: container.id }));
+                }
             }
             if (this.containerStarting) {
                 yield this.containerStarting(inspectResult, false);
             }
-            yield (0, wait_for_container_1.waitForContainer)(container, waitStrategy, host, boundPorts);
-            const startedContainer = new started_generic_container_1.StartedGenericContainer(container, host, inspectResult, boundPorts, inspectResult.name, waitStrategy);
+            yield (0, wait_for_container_1.waitForContainer)(container, this.waitStrategy, boundPorts);
+            const startedContainer = new started_generic_container_1.StartedGenericContainer(container, host, inspectResult, boundPorts, inspectResult.name, this.waitStrategy);
             if (this.containerStarted) {
                 yield this.containerStarted(startedContainer, inspectResult, false);
             }
@@ -305,5 +314,9 @@ class GenericContainer {
         this.opts.resourcesQuota = { memory: ram, cpu: cpuQuota };
         return this;
     }
+    withLogConsumer(logConsumer) {
+        this.logConsumer = logConsumer;
+        return this;
+    }
 }
 exports.GenericContainer = GenericContainer;

package/dist/src/generic-container/started-generic-container.d.ts

@@ -13,6 +13,8 @@ export declare class StartedGenericContainer implements StartedTestContainer {
     private boundPorts;
     private readonly name;
     private readonly waitStrategy;
+    private stoppedContainer?;
+    private stopContainerLock;
     constructor(container: Dockerode.Container, host: string, inspectResult: InspectResult, boundPorts: BoundPorts, name: string, waitStrategy: WaitStrategy);
     protected containerIsStopping?(): Promise<void>;
     stop(options?: Partial<StopOptions>): Promise<StoppedTestContainer>;

package/dist/src/generic-container/started-generic-container.js

@@ -8,6 +8,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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.StartedGenericContainer = void 0;
 const inspect_container_1 = require("../docker/functions/container/inspect-container");
@@ -21,6 +24,7 @@ const stop_container_1 = require("../docker/functions/container/stop-container")
 const restart_container_1 = require("../docker/functions/container/restart-container");
 const wait_for_container_1 = require("../wait-for-container");
 const docker_client_1 = require("../docker/docker-client");
+const async_lock_1 = __importDefault(require("async-lock"));
 class StartedGenericContainer {
     constructor(container, host, inspectResult, boundPorts, name, waitStrategy) {
         this.container = container;
@@ -29,38 +33,47 @@ class StartedGenericContainer {
         this.boundPorts = boundPorts;
         this.name = name;
         this.waitStrategy = waitStrategy;
+        this.stopContainerLock = new async_lock_1.default();
     }
     stop(options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.stopContainer(options);
+            return this.stopContainerLock.acquire("stop", () => __awaiter(this, void 0, void 0, function* () {
+                if (this.stoppedContainer) {
+                    return this.stoppedContainer;
+                }
+                this.stoppedContainer = yield this.stopContainer(options);
+                return this.stoppedContainer;
+            }));
         });
     }
     restart(options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
             const resolvedOptions = Object.assign({ timeout: 0 }, options);
-            logger_1.log.info(`Restarting container with ID: ${this.container.id}`);
+            logger_1.log.info(`Restarting container...`, { containerId: this.container.id });
             yield (0, restart_container_1.restartContainer)(this.container, resolvedOptions);
             const { hostIps } = yield (0, docker_client_1.dockerClient)();
             this.inspectResult = yield (0, inspect_container_1.inspectContainer)(this.container);
             const startTime = this.inspectResult.state.startedAt;
             if (logger_1.containerLog.enabled()) {
                 (yield (0, container_logs_1.containerLogs)(this.container, { since: startTime }))
-                    .on("data", (data) => logger_1.containerLog.trace(`${this.container.id}: ${data.trim()}`))
-                    .on("err", (data) => logger_1.containerLog.error(`${this.container.id}: ${data.trim()}`));
+                    .on("data", (data) => logger_1.containerLog.trace(data.trim(), { containerId: this.container.id }))
+                    .on("err", (data) => logger_1.containerLog.error(data.trim(), { containerId: this.container.id }));
             }
             this.boundPorts = bound_ports_1.BoundPorts.fromInspectResult(hostIps, this.inspectResult).filter(Array.from(this.boundPorts.iterator()).map((port) => port[0]));
-            yield (0, wait_for_container_1.waitForContainer)(this.container, this.waitStrategy, this.host, this.boundPorts, startTime);
+            yield (0, wait_for_container_1.waitForContainer)(this.container, this.waitStrategy, this.boundPorts, startTime);
+            logger_1.log.info(`Restarted container`, { containerId: this.container.id });
         });
     }
     stopContainer(options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            logger_1.log.info(`Stopping container with ID: ${this.container.id}`);
+            logger_1.log.info(`Stopping container...`, { containerId: this.container.id });
             if (this.containerIsStopping) {
                 yield this.containerIsStopping();
             }
             const resolvedOptions = Object.assign({ timeout: 0, removeVolumes: true }, options);
             yield (0, stop_container_1.stopContainer)(this.container, { timeout: resolvedOptions.timeout });
             yield (0, remove_container_1.removeContainer)(this.container, { removeVolumes: resolvedOptions.removeVolumes });
+            logger_1.log.info(`Stopped container`, { containerId: this.container.id });
             if (this.containerIsStopped) {
                 yield this.containerIsStopped();
             }
@@ -95,7 +108,13 @@ class StartedGenericContainer {
         return this.inspectResult.networkSettings[networkName].ipAddress;
     }
     exec(command) {
-        return (0, exec_container_1.execContainer)(this.container, command);
+        return __awaiter(this, void 0, void 0, function* () {
+            const { dockerode, provider } = yield (0, docker_client_1.dockerClient)();
+            logger_1.log.debug(`Executing command "${command.join(" ")}"...`, { containerId: this.container.id });
+            const output = yield (0, exec_container_1.execContainer)(dockerode, provider, this.container, command);
+            logger_1.log.debug(`Executed command "${command.join(" ")}"...`, { containerId: this.container.id });
+            return output;
+        });
     }
     logs() {
         return (0, container_logs_1.containerLogs)(this.container);

package/dist/src/images.js

@@ -2,5 +2,5 @@
 var _a, _b;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SSHD_IMAGE = exports.REAPER_IMAGE = void 0;
-exports.REAPER_IMAGE = (_a = process.env["RYUK_CONTAINER_IMAGE"]) !== null && _a !== void 0 ? _a : "testcontainers/ryuk:0.3.4";
+exports.REAPER_IMAGE = (_a = process.env["RYUK_CONTAINER_IMAGE"]) !== null && _a !== void 0 ? _a : "testcontainers/ryuk:0.4.0";
 exports.SSHD_IMAGE = (_b = process.env["SSHD_CONTAINER_IMAGE"]) !== null && _b !== void 0 ? _b : "testcontainers/sshd:1.1.0";

package/dist/src/logger.d.ts

@@ -1,36 +1,25 @@
 type Message = string;
-export interface Logger {
-    enabled(): boolean;
-    trace(message: Message): void;
-    debug(message: Message): void;
-    info(message: Message): void;
-    warn(message: Message): void;
-    error(message: Message): void;
-}
-declare class DebugLogger implements Logger {
+type Options = {
+    containerId?: string;
+    imageName?: string;
+};
+export declare class Logger {
+    private readonly showLevel;
     private readonly logger;
-    constructor(namespace: string);
-    enabled(): boolean;
-    trace(message: Message): void;
-    debug(message: Message): void;
-    info(message: Message): void;
-    warn(message: Message): void;
-    error(message: Message): void;
-}
-export declare class FakeLogger implements Logger {
-    readonly traceLogs: Message[];
-    readonly debugLogs: Message[];
-    readonly infoLogs: Message[];
-    readonly warnLogs: Message[];
-    readonly errorLogs: Message[];
+    constructor(namespace: string, showLevel?: boolean);
     enabled(): boolean;
-    trace(message: Message): void;
-    debug(message: Message): void;
-    info(message: Message): void;
-    warn(message: Message): void;
-    error(message: Message): void;
+    trace(message: Message, options?: Options): void;
+    debug(message: Message, options?: Options): void;
+    info(message: Message, options?: Options): void;
+    warn(message: Message, options?: Options): void;
+    error(message: Message, options?: Options): void;
+    private formatMessage;
+    private renderOptions;
 }
-export declare const log: DebugLogger;
-export declare const containerLog: DebugLogger;
-export declare const execLog: DebugLogger;
+export declare const log: Logger;
+export declare const containerLog: Logger;
+export declare const composeLog: Logger;
+export declare const buildLog: Logger;
+export declare const pullLog: Logger;
+export declare const execLog: Logger;
 export {};

package/dist/src/logger.js

@@ -3,59 +3,49 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.execLog = exports.containerLog = exports.log = exports.FakeLogger = void 0;
+exports.execLog = exports.pullLog = exports.buildLog = exports.composeLog = exports.containerLog = exports.log = exports.Logger = void 0;
 const debug_1 = __importDefault(require("debug"));
-class DebugLogger {
-    constructor(namespace) {
+class Logger {
+    constructor(namespace, showLevel = true) {
+        this.showLevel = showLevel;
         this.logger = (0, debug_1.default)(namespace);
     }
     enabled() {
         return this.logger.enabled;
     }
-    trace(message) {
-        this.logger(`TRACE ${message}`);
+    trace(message, options) {
+        this.logger(this.formatMessage(message, "TRACE", options));
     }
-    debug(message) {
-        this.logger(`DEBUG ${message}`);
+    debug(message, options) {
+        this.logger(this.formatMessage(message, "DEBUG", options));
     }
-    info(message) {
-        this.logger(`INFO  ${message}`);
+    info(message, options) {
+        this.logger(this.formatMessage(message, "INFO", options));
     }
-    warn(message) {
-        this.logger(`WARN  ${message}`);
+    warn(message, options) {
+        this.logger(this.formatMessage(message, "WARN", options));
     }
-    error(message) {
-        this.logger(`ERROR ${message}`);
+    error(message, options) {
+        this.logger(this.formatMessage(message, "ERROR", options));
     }
-}
-class FakeLogger {
-    constructor() {
-        this.traceLogs = [];
-        this.debugLogs = [];
-        this.infoLogs = [];
-        this.warnLogs = [];
-        this.errorLogs = [];
-    }
-    enabled() {
-        return true;
-    }
-    trace(message) {
-        this.traceLogs.push(message);
-    }
-    debug(message) {
-        this.debugLogs.push(message);
-    }
-    info(message) {
-        this.infoLogs.push(message);
-    }
-    warn(message) {
-        this.warnLogs.push(message);
+    formatMessage(message, level, options) {
+        return `${this.showLevel ? `[${level}] ` : ""}${this.renderOptions(options)}${message}`;
     }
-    error(message) {
-        this.errorLogs.push(message);
+    renderOptions(options) {
+        let str = "";
+        if (options === null || options === void 0 ? void 0 : options.containerId) {
+            str += `[${options.containerId.substring(0, 12)}] `;
+        }
+        if (options === null || options === void 0 ? void 0 : options.imageName) {
+            str += `[${options.imageName}] `;
+        }
+        return str;
     }
 }
-exports.FakeLogger = FakeLogger;
-exports.log = new DebugLogger("testcontainers");
-exports.containerLog = new DebugLogger("testcontainers:containers");
-exports.execLog = new DebugLogger("testcontainers:exec");
+exports.Logger = Logger;
+exports.log = new Logger("testcontainers");
+exports.containerLog = new Logger("testcontainers:containers", false);
+exports.composeLog = new Logger("testcontainers:compose", false);
+exports.buildLog = new Logger("testcontainers:build", false);
+exports.pullLog = new Logger("testcontainers:pull", false);
+exports.execLog = new Logger("testcontainers:exec", false);