testcontainers 9.10.1 → 9.11.0

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

@@ -1,11 +1,10 @@
 /// <reference types="node" />
-import archiver from "archiver";
 import { BoundPorts } from "../bound-ports";
 import { PortWithOptionalBinding } from "../port";
 import { PullPolicy } from "../pull-policy";
 import { StartedTestContainer, TestContainer } from "../test-container";
 import { WaitStrategy } from "../wait-strategy/wait-strategy";
-import { BindMount, ContentToCopy, Environment, ExtraHost, FileToCopy, HealthCheck, Labels, ResourcesQuota, TmpFs, Ulimits } from "../docker/types";
+import { BindMount, ContentToCopy, DirectoryToCopy, Environment, ExtraHost, FileToCopy, HealthCheck, Labels, ResourcesQuota, TmpFs, Ulimits } from "../docker/types";
 import { CreateContainerOptions } from "../docker/functions/container/create-container";
 import { InspectResult } from "../docker/functions/container/inspect-container";
 import { GenericContainerBuilder } from "./generic-container-builder";
@@ -17,11 +16,13 @@ export declare class GenericContainer implements TestContainer {
     protected opts: CreateContainerOptions;
     protected startupTimeout?: number;
     protected waitStrategy: WaitStrategy;
-    protected tarToCopy?: archiver.Archiver;
     protected networkMode?: string;
     protected networkAliases: string[];
     protected pullPolicy: PullPolicy;
     protected logConsumer?: (stream: Readable) => unknown;
+    protected filesToCopy: FileToCopy[];
+    protected directoriesToCopy: DirectoryToCopy[];
+    protected contentsToCopy: ContentToCopy[];
     constructor(image: string);
     /**
      * @deprecated Since version 9.4.0. Will be removed in version 10.0.0. Use `beforeContainerStarted` instead.
@@ -31,8 +32,11 @@ export declare class GenericContainer implements TestContainer {
     protected containerCreated?(containerId: string): Promise<void>;
     protected containerStarting?(inspectResult: InspectResult, reused: boolean): Promise<void>;
     start(): Promise<StartedTestContainer>;
+    private reuseOrStartContainer;
     private reuseContainer;
     private startContainer;
+    private connectContainerToPortForwarder;
+    private createArchiveToCopyToContainer;
     /**
      * @deprecated Since version 9.4.0. Will be removed in version 10.0.0. Use `containerStarted` instead.
      */
@@ -64,8 +68,8 @@ export declare class GenericContainer implements TestContainer {
     withPullPolicy(pullPolicy: PullPolicy): this;
     withIpcMode(ipcMode: string): this;
     withCopyFilesToContainer(filesToCopy: FileToCopy[]): this;
+    withCopyDirectoriesToContainer(directoriesToCopy: DirectoryToCopy[]): this;
     withCopyContentToContainer(contentsToCopy: ContentToCopy[]): this;
-    protected getTarToCopy(): archiver.Archiver;
     withWorkingDir(workingDir: string): this;
     withResourcesQuota({ memory, cpu }: ResourcesQuota): this;
     withSharedMemorySize(bytes: number): this;

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

@@ -18,7 +18,6 @@ const async_lock_1 = __importDefault(require("async-lock"));
 const bound_ports_1 = require("../bound-ports");
 const logger_1 = require("../logger");
 const pull_policy_1 = require("../pull-policy");
-const reaper_1 = require("../reaper");
 const docker_image_name_1 = require("../docker-image-name");
 const port_forwarder_1 = require("../port-forwarder");
 const pull_image_1 = require("../docker/functions/image/pull-image");
@@ -47,19 +46,19 @@ class GenericContainer {
         this.waitStrategy = wait_1.Wait.forListeningPorts();
         this.networkAliases = [];
         this.pullPolicy = new pull_policy_1.DefaultPullPolicy();
+        this.filesToCopy = [];
+        this.directoriesToCopy = [];
+        this.contentsToCopy = [];
         const imageName = docker_image_name_1.DockerImageName.fromString(image);
         this.opts = (0, create_container_options_1.initCreateContainerOptions)(imageName, imageName.isReaper());
     }
     start() {
         return __awaiter(this, void 0, void 0, function* () {
-            const { dockerode, info } = yield (0, docker_client_1.getDockerClient)();
-            yield (0, pull_image_1.pullImage)(dockerode, info.dockerInfo.indexServerAddress, {
+            const dockerClient = yield (0, docker_client_1.getDockerClient)();
+            yield (0, pull_image_1.pullImage)(dockerClient.dockerode, dockerClient.info.dockerInfo.indexServerAddress, {
                 imageName: this.opts.imageName,
                 force: this.pullPolicy.shouldPull(),
             });
-            if (!this.opts.reusable && !this.opts.imageName.isReaper()) {
-                yield reaper_1.ReaperInstance.getInstance();
-            }
             if (this.beforeContainerStarted) {
                 yield this.beforeContainerStarted();
             }
@@ -70,41 +69,33 @@ class GenericContainer {
                 const portForwarder = yield port_forwarder_1.PortForwarderInstance.getInstance();
                 this.opts.extraHosts.push({ host: "host.testcontainers.internal", ipAddress: portForwarder.getIpAddress() });
             }
-            if (this.networkAliases.length > 0) {
-                this.opts.networkMode = undefined;
-            }
-            else {
-                this.opts.networkMode = this.networkMode;
-            }
+            this.opts.networkMode = this.networkAliases.length > 0 ? undefined : this.networkMode;
             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 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}"`, { containerId: container.id });
-                        return this.reuseContainer(container);
-                    }
-                    else {
-                        logger_1.log.debug("No container found to reuse");
-                        return this.startContainer(this.opts);
-                    }
-                }));
-            }
-            else {
-                return this.startContainer(this.opts);
+                return this.reuseOrStartContainer(dockerClient);
             }
+            return this.startContainer(dockerClient, this.opts);
         });
     }
-    reuseContainer(container) {
+    reuseOrStartContainer(dockerClient) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 with hash "${containerHash}"`);
+            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}"`, { containerId: container.id });
+                    return this.reuseContainer(dockerClient, container);
+                }
+                logger_1.log.debug("No container found to reuse");
+                return this.startContainer(dockerClient, this.opts);
+            }));
+        });
+    }
+    reuseContainer(dockerClient, container) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { host, hostIps } = yield (0, docker_client_1.getDockerClient)();
             const inspectResult = yield (0, inspect_container_1.inspectContainer)(container);
-            const boundPorts = bound_ports_1.BoundPorts.fromInspectResult(hostIps, inspectResult).filter(this.opts.exposedPorts);
+            const boundPorts = bound_ports_1.BoundPorts.fromInspectResult(dockerClient.hostIps, inspectResult).filter(this.opts.exposedPorts);
             if (this.startupTimeout !== undefined) {
                 this.waitStrategy.withStartupTimeout(this.startupTimeout);
             }
@@ -112,7 +103,7 @@ class GenericContainer {
                 yield this.containerStarting(inspectResult, true);
             }
             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);
+            const startedContainer = new started_generic_container_1.StartedGenericContainer(container, dockerClient.host, inspectResult, boundPorts, inspectResult.name, this.waitStrategy);
             if (this.containerStarted) {
                 yield this.containerStarted(startedContainer, inspectResult, true);
             }
@@ -122,20 +113,11 @@ class GenericContainer {
             return startedContainer;
         });
     }
-    startContainer(createContainerOptions) {
+    startContainer(dockerClient, createContainerOptions) {
         return __awaiter(this, void 0, void 0, function* () {
-            const container = yield (0, create_container_1.createContainer)(createContainerOptions);
+            const container = yield (0, create_container_1.createContainer)(dockerClient.sessionId, createContainerOptions);
             if (!this.opts.imageName.isHelperContainer() && port_forwarder_1.PortForwarderInstance.isRunning()) {
-                const portForwarder = yield port_forwarder_1.PortForwarderInstance.getInstance();
-                const portForwarderNetworkId = portForwarder.getNetworkId();
-                const excludedNetworks = [portForwarderNetworkId, "none", "host"];
-                if (!this.networkMode || !excludedNetworks.includes(this.networkMode)) {
-                    yield (0, connect_network_1.connectNetwork)({
-                        containerId: container.id,
-                        networkId: portForwarderNetworkId,
-                        networkAliases: [],
-                    });
-                }
+                yield this.connectContainerToPortForwarder(container);
             }
             if (this.networkMode && this.networkAliases.length > 0) {
                 yield (0, connect_network_1.connectNetwork)({
@@ -144,9 +126,10 @@ class GenericContainer {
                     networkAliases: this.networkAliases,
                 });
             }
-            if (this.tarToCopy) {
-                this.tarToCopy.finalize();
-                yield (0, put_container_archive_1.putContainerArchive)({ container, stream: this.tarToCopy, containerPath: "/" });
+            if (this.filesToCopy.length > 0 || this.directoriesToCopy.length > 0 || this.contentsToCopy.length > 0) {
+                const archive = this.createArchiveToCopyToContainer();
+                archive.finalize();
+                yield (0, put_container_archive_1.putContainerArchive)({ container, stream: archive, containerPath: "/" });
             }
             logger_1.log.info(`Starting container for image "${this.opts.imageName}"...`, { containerId: container.id });
             if (this.containerCreated) {
@@ -154,19 +137,17 @@ class GenericContainer {
             }
             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.getDockerClient)();
             const inspectResult = yield (0, inspect_container_1.inspectContainer)(container);
-            const boundPorts = bound_ports_1.BoundPorts.fromInspectResult(hostIps, inspectResult).filter(this.opts.exposedPorts);
+            const boundPorts = bound_ports_1.BoundPorts.fromInspectResult(dockerClient.hostIps, inspectResult).filter(this.opts.exposedPorts);
             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);
+                    this.logConsumer(yield (0, container_logs_1.containerLogs)(container));
                 }
                 if (logger_1.containerLog.enabled()) {
-                    logStream
+                    (yield (0, container_logs_1.containerLogs)(container))
                         .on("data", (data) => logger_1.containerLog.trace(data.trim(), { containerId: container.id }))
                         .on("err", (data) => logger_1.containerLog.error(data.trim(), { containerId: container.id }));
                 }
@@ -175,7 +156,7 @@ class GenericContainer {
                 yield this.containerStarting(inspectResult, false);
             }
             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);
+            const startedContainer = new started_generic_container_1.StartedGenericContainer(container, dockerClient.host, inspectResult, boundPorts, inspectResult.name, this.waitStrategy);
             if (this.containerStarted) {
                 yield this.containerStarted(startedContainer, inspectResult, false);
             }
@@ -185,6 +166,33 @@ class GenericContainer {
             return startedContainer;
         });
     }
+    connectContainerToPortForwarder(container) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const portForwarder = yield port_forwarder_1.PortForwarderInstance.getInstance();
+            const portForwarderNetworkId = portForwarder.getNetworkId();
+            const excludedNetworks = [portForwarderNetworkId, "none", "host"];
+            if (!this.networkMode || !excludedNetworks.includes(this.networkMode)) {
+                yield (0, connect_network_1.connectNetwork)({
+                    containerId: container.id,
+                    networkId: portForwarderNetworkId,
+                    networkAliases: [],
+                });
+            }
+        });
+    }
+    createArchiveToCopyToContainer() {
+        const tar = (0, archiver_1.default)("tar");
+        for (const { source, target, mode } of this.filesToCopy) {
+            tar.file(source, { name: target, mode });
+        }
+        for (const { source, target, mode } of this.directoriesToCopy) {
+            tar.directory(source, target, { mode });
+        }
+        for (const { content, target, mode } of this.contentsToCopy) {
+            tar.append(content, { name: target, mode });
+        }
+        return tar;
+    }
     get hasExposedPorts() {
         return this.opts.exposedPorts.length !== 0;
     }
@@ -287,31 +295,26 @@ class GenericContainer {
         return this;
     }
     withCopyFilesToContainer(filesToCopy) {
-        const tar = this.getTarToCopy();
-        filesToCopy.forEach(({ source, target }) => tar.file(source, { name: target }));
+        this.filesToCopy = [...this.filesToCopy, ...filesToCopy];
         return this;
     }
-    withCopyContentToContainer(contentsToCopy) {
-        const tar = this.getTarToCopy();
-        contentsToCopy.forEach(({ content, target }) => tar.append(content, { name: target }));
+    withCopyDirectoriesToContainer(directoriesToCopy) {
+        this.directoriesToCopy = [...this.directoriesToCopy, ...directoriesToCopy];
         return this;
     }
-    getTarToCopy() {
-        if (!this.tarToCopy) {
-            this.tarToCopy = (0, archiver_1.default)("tar");
-        }
-        return this.tarToCopy;
+    withCopyContentToContainer(contentsToCopy) {
+        this.contentsToCopy = [...this.contentsToCopy, ...contentsToCopy];
+        return this;
     }
     withWorkingDir(workingDir) {
         this.opts.workingDir = workingDir;
         return this;
     }
     withResourcesQuota({ memory, cpu }) {
-        // Memory and CPU units from here: https://docs.docker.com/engine/api/v1.42/#tag/Container/operation/ContainerCreate
-        // see Memory, NanoCpus parameters
-        const ram = memory !== undefined ? memory * Math.pow(1024, 3) : undefined;
-        const cpuQuota = cpu !== undefined ? cpu * Math.pow(10, 9) : undefined;
-        this.opts.resourcesQuota = { memory: ram, cpu: cpuQuota };
+        this.opts.resourcesQuota = {
+            memory: memory !== undefined ? memory * Math.pow(1024, 3) : undefined,
+            cpu: cpu !== undefined ? cpu * Math.pow(10, 9) : undefined,
+        };
         return this;
     }
     withSharedMemorySize(bytes) {

package/dist/src/index.d.ts

@@ -1,6 +1,6 @@
 export { TestContainer, StartedTestContainer, StoppedTestContainer } from "./test-container";
 export { GenericContainer } from "./generic-container/generic-container";
-export { GenericContainerBuilder } from "./generic-container/generic-container-builder";
+export { GenericContainerBuilder, BuildOptions } from "./generic-container/generic-container-builder";
 export { TestContainers } from "./test-containers";
 export { DockerComposeEnvironment } from "./docker-compose-environment/docker-compose-environment";
 export { StartedDockerComposeEnvironment } from "./docker-compose-environment/started-docker-compose-environment";

package/dist/src/modules/selenium/selenium-container.js

@@ -35,14 +35,17 @@ class SeleniumContainer extends generic_container_1.GenericContainer {
         return __awaiter(this, void 0, void 0, function* () {
             this.withExposedPorts(SELENIUM_PORT, VNC_PORT)
                 .withSharedMemorySize(2 * 1024 * 1024 * 1024)
-                .withWaitStrategy(wait_1.Wait.forHttp("/wd/hub/status", SELENIUM_PORT).forResponsePredicate((response) => {
-                try {
-                    return JSON.parse(response).value.ready;
-                }
-                catch (_a) {
-                    return false;
-                }
-            }));
+                .withWaitStrategy(wait_1.Wait.forAll([
+                wait_1.Wait.forListeningPorts(),
+                wait_1.Wait.forHttp("/wd/hub/status", SELENIUM_PORT).forResponsePredicate((response) => {
+                    try {
+                        return JSON.parse(response).value.ready;
+                    }
+                    catch (_a) {
+                        return false;
+                    }
+                }),
+            ]));
         });
     }
     withRecording() {

package/dist/src/network.js

@@ -12,9 +12,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.StoppedNetwork = exports.StartedNetwork = exports.Network = void 0;
 const uuid_1 = require("./uuid");
 const logger_1 = require("./logger");
-const reaper_1 = require("./reaper");
 const create_network_1 = require("./docker/functions/network/create-network");
 const remove_network_1 = require("./docker/functions/network/remove-network");
+const docker_client_1 = require("./docker/client/docker-client");
 class Network {
     constructor(createNetworkOptions = {}, uuid = new uuid_1.RandomUuid()) {
         this.createNetworkOptions = createNetworkOptions;
@@ -25,9 +25,9 @@ class Network {
         return __awaiter(this, void 0, void 0, function* () {
             const name = this.uuid.nextUuid();
             const options = Object.assign({ name, driver: "bridge", checkDuplicate: true, internal: false, attachable: false, ingress: false, enableIPv6: false }, this.createNetworkOptions);
-            yield reaper_1.ReaperInstance.getInstance();
             logger_1.log.info(`Starting network "${name}"...`);
-            const id = yield (0, create_network_1.createNetwork)(options);
+            const { sessionId } = yield (0, docker_client_1.getDockerClient)();
+            const id = yield (0, create_network_1.createNetwork)(sessionId, options);
             logger_1.log.info(`Started network "${name}" with ID "${id}"`);
             return new StartedNetwork(id, options);
         });

package/dist/src/port-forwarder.js

@@ -14,7 +14,6 @@ const ssh_remote_port_forward_1 = require("ssh-remote-port-forward");
 const logger_1 = require("./logger");
 const generic_container_1 = require("./generic-container/generic-container");
 const uuid_1 = require("./uuid");
-const session_id_1 = require("./docker/session-id");
 const docker_client_1 = require("./docker/client/docker-client");
 const images_1 = require("./images");
 class PortForwarder {
@@ -60,8 +59,9 @@ class PortForwarderInstance {
             const containerPort = process.env["TESTCONTAINERS_SSHD_PORT"]
                 ? { container: 22, host: Number(process.env["TESTCONTAINERS_SSHD_PORT"]) }
                 : 22;
+            const { sessionId } = yield (0, docker_client_1.getDockerClient)();
             const container = yield new generic_container_1.GenericContainer(images_1.SSHD_IMAGE)
-                .withName(`testcontainers-port-forwarder-${session_id_1.sessionId}`)
+                .withName(`testcontainers-port-forwarder-${sessionId}`)
                 .withExposedPorts(containerPort)
                 .withEnvironment({ PASSWORD: password })
                 .withCommand([

package/dist/src/reaper.d.ts

@@ -1,14 +1,5 @@
-export interface Reaper {
-    addProject(projectName: string): void;
-    getContainerId(): string;
-    stop(): void;
-}
-export declare class ReaperInstance {
-    private static instance?;
-    static getInstance(): Promise<Reaper>;
-    static stopInstance(): Promise<void>;
-    private static isEnabled;
-    private static isPrivileged;
-    private static createDisabledInstance;
-    private static createRealInstance;
-}
+import { PartialDockerClient } from "./docker/client/docker-client-types";
+import Dockerode from "dockerode";
+export declare function registerSessionIdForCleanup(sessionId: string): Promise<void>;
+export declare function registerComposeProjectForCleanup(project: string): Promise<void>;
+export declare function startReaper(dockerClient: PartialDockerClient, sessionId: string, existingReaperContainer?: Dockerode.ContainerInfo): Promise<void>;

package/dist/src/reaper.js

@@ -9,139 +9,149 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReaperInstance = void 0;
+exports.startReaper = exports.registerComposeProjectForCleanup = exports.registerSessionIdForCleanup = 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-strategy/wait");
 const retry_strategy_1 = require("./retry-strategy");
 const remote_docker_unix_socket_path_1 = require("./docker/remote-docker-unix-socket-path");
 const docker_client_1 = require("./docker/client/docker-client");
+const isReaperEnabled = process.env.TESTCONTAINERS_RYUK_DISABLED !== "true";
+let reaper;
+function registerSessionIdForCleanup(sessionId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!reaper) {
+            yield (0, docker_client_1.getDockerClient)();
+        }
+        (yield reaper).addSession(sessionId);
+    });
+}
+exports.registerSessionIdForCleanup = registerSessionIdForCleanup;
+function registerComposeProjectForCleanup(project) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!reaper) {
+            yield (0, docker_client_1.getDockerClient)();
+        }
+        (yield reaper).addProject(project);
+    });
+}
+exports.registerComposeProjectForCleanup = registerComposeProjectForCleanup;
+function startReaper(dockerClient, sessionId, existingReaperContainer) {
+    return __awaiter(this, void 0, void 0, function* () {
+        reaper = !isReaperEnabled
+            ? yield createDisabledReaper()
+            : existingReaperContainer
+                ? yield useExistingReaper(dockerClient, sessionId, existingReaperContainer)
+                : yield createNewReaper(dockerClient, sessionId);
+    });
+}
+exports.startReaper = startReaper;
+function createDisabledReaper() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new DisabledReaper();
+    });
+}
+function useExistingReaper(dockerClient, sessionId, reaperContainer) {
+    return __awaiter(this, void 0, void 0, function* () {
+        logger_1.log.debug(`Reusing existing Reaper for session "${sessionId}"...`);
+        const reaperPort = getReaperPublicPort(reaperContainer);
+        const socket = yield connectToReaperSocket(dockerClient.host, reaperPort, sessionId, reaperContainer.Id);
+        return new RealReaper(sessionId, socket);
+    });
+}
+function getReaperPublicPort(reaperContainer) {
+    var _a;
+    const port = (_a = reaperContainer.Ports.find((port) => port.PrivatePort == 8080)) === null || _a === void 0 ? void 0 : _a.PublicPort;
+    if (!port) {
+        throw new Error("Expected Reaper to map exposed port 8080");
+    }
+    return port;
+}
+function createNewReaper(dockerClient, sessionId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const remoteDockerUnixSocketPath = (0, remote_docker_unix_socket_path_1.getRemoteDockerUnixSocketPath)(dockerClient);
+        logger_1.log.debug(`Creating new Reaper for session "${sessionId}" with socket path "${remoteDockerUnixSocketPath}"...`);
+        const startedContainer = yield createAndStartReaperContainer(sessionId, remoteDockerUnixSocketPath);
+        const containerId = startedContainer.getId();
+        const host = startedContainer.getHost();
+        const port = startedContainer.getMappedPort(8080);
+        const socket = yield connectToReaperSocket(host, port, sessionId, containerId);
+        return new RealReaper(sessionId, socket);
+    });
+}
+function createAndStartReaperContainer(sessionId, socketPath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const exposedPort = process.env["TESTCONTAINERS_RYUK_PORT"]
+            ? { container: 8080, host: Number(process.env["TESTCONTAINERS_RYUK_PORT"]) }
+            : 8080;
+        const container = new generic_container_1.GenericContainer(images_1.REAPER_IMAGE)
+            .withName(`testcontainers-ryuk-${sessionId}`)
+            .withExposedPorts(exposedPort)
+            .withBindMounts([{ source: socketPath, target: "/var/run/docker.sock" }])
+            .withWaitStrategy(wait_1.Wait.forLogMessage(/.+ Started!/));
+        if (process.env.TESTCONTAINERS_RYUK_PRIVILEGED === "true") {
+            container.withPrivilegedMode();
+        }
+        return yield container.start();
+    });
+}
+function connectToReaperSocket(host, port, sessionId, containerId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const retryResult = yield new retry_strategy_1.IntervalRetryStrategy(1000).retryUntil((attempt) => {
+            return new Promise((resolve) => {
+                logger_1.log.debug(`Connecting to Reaper (attempt ${attempt + 1}) on "${host}:${port}"...`, { containerId });
+                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 closed with error`, { containerId });
+                    }
+                    else {
+                        logger_1.log.warn(`Connection to Reaper closed`, { containerId });
+                    }
+                    resolve(undefined);
+                })
+                    .connect(port, host, () => {
+                    logger_1.log.debug(`Connected to Reaper`, { containerId });
+                    resolve(socket);
+                });
+            });
+        }, (result) => result !== undefined, () => {
+            const message = `Failed to connect to Reaper`;
+            logger_1.log.error(message, { containerId });
+            return new Error(message);
+        }, 4000);
+        if (retryResult instanceof net_1.Socket) {
+            return retryResult;
+        }
+        else {
+            throw retryResult;
+        }
+    });
+}
 class RealReaper {
-    constructor(container, socket) {
-        this.container = container;
+    constructor(sessionId, socket) {
+        this.sessionId = sessionId;
         this.socket = socket;
     }
+    addSession(sessionId) {
+        this.socket.write(`label=${labels_1.LABEL_TESTCONTAINERS_SESSION_ID}=${sessionId}\r\n`);
+    }
     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() {
+    addSession() {
         // noop
     }
-    stop() {
+    addProject() {
         // 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;
-            const dockerClient = yield (0, docker_client_1.getDockerClient)();
-            const remoteDockerUnixSocketPath = (0, remote_docker_unix_socket_path_1.getRemoteDockerUnixSocketPath)(dockerClient);
-            logger_1.log.debug(`Creating new Reaper for session "${session_id_1.sessionId}" with socket path "${remoteDockerUnixSocketPath}"...`);
-            const container = new generic_container_1.GenericContainer(images_1.REAPER_IMAGE)
-                .withName(`testcontainers-ryuk-${session_id_1.sessionId}`)
-                .withExposedPorts(containerPort)
-                .withBindMounts([
-                {
-                    source: remoteDockerUnixSocketPath,
-                    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}) on "${host}:${port}"...`, { containerId });
-                    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 closed with error`, { containerId });
-                        }
-                        else {
-                            logger_1.log.warn(`Connection to Reaper closed`, { containerId });
-                        }
-                        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, () => {
-                const message = `Failed to connect to Reaper`;
-                logger_1.log.error(message, { containerId });
-                return new Error(message);
-            }, 4000);
-            if (retryResult instanceof RealReaper) {
-                return retryResult;
-            }
-            else {
-                throw retryResult;
-            }
-        });
-    }
 }
-exports.ReaperInstance = ReaperInstance;