testcontainers 9.10.0 → 9.11.0

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;

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

@@ -4,7 +4,7 @@ import { PortWithOptionalBinding } from "./port";
 import { PullPolicy } from "./pull-policy";
 import { WaitStrategy } from "./wait-strategy/wait-strategy";
 import { Readable } from "stream";
-import { BindMount, ContentToCopy, Environment, ExecResult, ExtraHost, FileToCopy, Labels, ResourcesQuota, TmpFs, Ulimits } from "./docker/types";
+import { BindMount, ContentToCopy, DirectoryToCopy, Environment, ExecResult, ExtraHost, FileToCopy, Labels, ResourcesQuota, TmpFs, Ulimits } from "./docker/types";
 import { StartedNetwork } from "./network";
 export interface TestContainer {
     start(): Promise<StartedTestContainer>;
@@ -28,6 +28,7 @@ export interface TestContainer {
     withPullPolicy(pullPolicy: PullPolicy): this;
     withReuse(): this;
     withCopyFilesToContainer(filesToCopy: FileToCopy[]): this;
+    withCopyDirectoriesToContainer(directoriesToCopy: DirectoryToCopy[]): this;
     withCopyContentToContainer(contentsToCopy: ContentToCopy[]): this;
     withWorkingDir(workingDir: string): this;
     withResourcesQuota(resourcesQuota: ResourcesQuota): this;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "testcontainers",
   "author": "Cristian Greco",
-  "version": "9.10.0",
+  "version": "9.11.0",
   "main": "dist/src/index",
   "types": "dist/src/index",
   "keywords": [
@@ -46,46 +46,48 @@
     "docker-compose": "^0.24.1",
     "dockerode": "^3.3.5",
     "get-port": "^5.1.1",
-    "node-fetch": "^2.6.11",
+    "node-fetch": "^2.6.12",
+    "proper-lockfile": "^4.1.2",
     "properties-reader": "^2.2.0",
     "ssh-remote-port-forward": "^1.0.4",
     "tar-fs": "^2.1.1",
     "tmp": "^0.2.1"
   },
   "devDependencies": {
-    "@elastic/elasticsearch": "^7.17.0",
+    "@elastic/elasticsearch": "^7.17.11",
     "@types/async-lock": "^1.4.0",
     "@types/byline": "^4.2.33",
     "@types/debug": "4.1.8",
-    "@types/jest": "^29.5.2",
-    "@types/node": "^18.16.18",
+    "@types/jest": "^29.5.3",
+    "@types/node": "^18.16.19",
     "@types/node-fetch": "^2.6.4",
     "@types/pg": "^8.10.2",
+    "@types/proper-lockfile": "^4.1.2",
     "@types/properties-reader": "^2.1.1",
     "@types/selenium-webdriver": "^4.1.15",
     "@types/tar-fs": "^2.0.1",
     "@types/tmp": "^0.2.3",
-    "@typescript-eslint/eslint-plugin": "^5.59.11",
-    "@typescript-eslint/parser": "^5.59.11",
-    "arangojs": "^8.3.0",
+    "@typescript-eslint/eslint-plugin": "^5.62.0",
+    "@typescript-eslint/parser": "^5.62.0",
+    "arangojs": "^8.4.0",
     "cross-env": "^7.0.3",
-    "eslint": "^8.42.0",
+    "eslint": "^8.44.0",
     "eslint-config-prettier": "^8.8.0",
     "eslint-plugin-prettier": "^4.2.1",
     "husky": "^8.0.3",
-    "jest": "^29.5.0",
+    "jest": "^29.6.1",
     "kafkajs": "^2.2.4",
-    "lint-staged": "^13.2.2",
-    "mongoose": "^6.11.2",
+    "lint-staged": "^13.2.3",
+    "mongoose": "^6.11.3",
     "mqtt": "^4.3.7",
     "mysql2": "^2.3.3",
-    "nats": "^2.14.0",
-    "neo4j-driver": "^5.9.1",
-    "pg": "^8.11.0",
+    "nats": "^2.15.1",
+    "neo4j-driver": "^5.10.0",
+    "pg": "^8.11.1",
     "prettier": "^2.8.8",
     "rimraf": "^3.0.2",
     "selenium-webdriver": "^4.10.0",
-    "ts-jest": "^29.1.0",
+    "ts-jest": "^29.1.1",
     "ts-node": "^10.9.1",
     "typescript": "^4.9.5",
     "wait-for-expect": "^3.0.2"

package/dist/src/docker/session-id.d.ts

@@ -1 +0,0 @@
-export declare const sessionId: string;

package/dist/src/docker/session-id.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sessionId = void 0;
-const uuid_1 = require("../uuid");
-exports.sessionId = new uuid_1.RandomUuid().nextUuid();