refactor: avoid loading compose info unless needed

Author: henrinormak

packages/testcontainers/src/container-runtime/clients/client.ts

@@ -17,7 +17,7 @@ import { DockerImageClient } from "./image/docker-image-client";
 import { ImageClient } from "./image/image-client";
 import { DockerNetworkClient } from "./network/docker-network-client";
 import { NetworkClient } from "./network/network-client";
-import { ComposeInfo, ContainerRuntimeInfo, Info, NodeInfo } from "./types";
+import { ContainerRuntimeInfo, Info, NodeInfo } from "./types";
 
 export class ContainerRuntimeClient {
   constructor(
@@ -92,7 +92,7 @@ async function initStrategy(strategy: ContainerRuntimeClientStrategy): Promise<C
   const host = await resolveHost(dockerode, result, indexServerAddress);
 
   log.trace("Fetching Compose info...");
-  const composeClient = await getComposeClient(result.composeEnvironment);
+  const composeClient = getComposeClient(result.composeEnvironment);
 
   const nodeInfo: NodeInfo = {
     version: process.version,
@@ -123,9 +123,7 @@ async function initStrategy(strategy: ContainerRuntimeClientStrategy): Promise<C
     labels: dockerodeInfo.Labels ? dockerodeInfo.Labels : [],
   };
 
-  const composeInfo: ComposeInfo = composeClient.info;
-
-  const info: Info = { node: nodeInfo, containerRuntime: containerRuntimeInfo, compose: composeInfo };
+  const info: Info = { node: nodeInfo, containerRuntime: containerRuntimeInfo };
 
   log.trace(`Container runtime info:\n${JSON.stringify(info, null, 2)}`);
   return new ContainerRuntimeClient(info, composeClient, containerClient, imageClient, networkClient);

packages/testcontainers/src/container-runtime/clients/compose/compose-client.ts

@@ -1,84 +1,78 @@
-import { default as dockerComposeV1, default as v1, v2 as dockerComposeV2, v2 } from "docker-compose";
+import { default as v1, v2 } from "docker-compose";
 import { log, pullLog } from "../../../common";
 import { ComposeInfo } from "../types";
 import { defaultComposeOptions } from "./default-compose-options";
 import { ComposeDownOptions, ComposeOptions } from "./types";
 
 export interface ComposeClient {
-  info: ComposeInfo;
+  getInfo(): Promise<ComposeInfo>;
   up(options: ComposeOptions, services?: Array<string>): Promise<void>;
   pull(options: ComposeOptions, services?: Array<string>): Promise<void>;
   stop(options: ComposeOptions): Promise<void>;
   down(options: ComposeOptions, downOptions: ComposeDownOptions): Promise<void>;
 }
 
-export async function getComposeClient(environment: NodeJS.ProcessEnv): Promise<ComposeClient> {
-  const info = await getComposeInfo();
-
-  switch (info?.compatability) {
-    case undefined:
-      return new MissingComposeClient();
-    case "v1":
-      return new ComposeV1Client(info, environment);
-    case "v2":
-      return new ComposeV2Client(info, environment);
-  }
+export function getComposeClient(environment: NodeJS.ProcessEnv): ComposeClient {
+  return new LazyComposeClient(environment);
 }
 
-async function getComposeInfo(): Promise<ComposeInfo | undefined> {
-  try {
-    return {
-      version: (await dockerComposeV2.version()).data.version,
-      compatability: "v2",
-    };
-  } catch (err) {
+class LazyComposeClient implements ComposeClient {
+  private info: ComposeInfo | undefined = undefined;
+  private client: typeof v1 | typeof v2 | undefined = undefined;
+  constructor(private readonly environment: NodeJS.ProcessEnv) {}
+
+  async getInfo(): Promise<ComposeInfo | undefined> {
+    if (this.info !== undefined) {
+      return this.info;
+    }
+
     try {
-      return {
-        version: (await dockerComposeV1.version()).data.version,
-        compatability: "v1",
+      this.info = {
+        version: (await v2.version()).data.version,
+        compatibility: "v2",
       };
-    } catch {
-      return undefined;
+    } catch (err) {
+      try {
+        this.info = {
+          version: (await v1.version()).data.version,
+          compatibility: "v1",
+        };
+      } catch {
+        return undefined;
+      }
     }
+
+    return this.info;
   }
-}
 
-class ComposeV1Client implements ComposeClient {
-  constructor(
-    public readonly info: ComposeInfo,
-    private readonly environment: NodeJS.ProcessEnv
-  ) {}
+  private async getClient(): Promise<typeof v1 | typeof v2> {
+    if (this.client !== undefined) {
+      return this.client;
+    }
 
-  async up(options: ComposeOptions, services: Array<string> | undefined): Promise<void> {
-    try {
-      if (services) {
-        log.info(`Upping Compose environment services ${services.join(", ")}...`);
-        await v1.upMany(services, await defaultComposeOptions(this.environment, options));
-      } else {
-        log.info(`Upping Compose environment...`);
-        await v1.upAll(await defaultComposeOptions(this.environment, options));
-      }
-      log.info(`Upped Compose environment`);
-    } catch (err) {
-      await handleAndRethrow(err, async (error: Error) => {
-        try {
-          log.error(`Failed to up Compose environment: ${error.message}`);
-          await this.down(options, { removeVolumes: true, timeout: 0 });
-        } catch {
-          log.error(`Failed to down Compose environment after failed up`);
-        }
-      });
+    const info = await this.getInfo();
+    switch (info?.compatibility) {
+      case undefined:
+        throw new Error("Compose is not installed");
+      case "v1":
+        this.client = v1;
+        return v1;
+      case "v2":
+        this.client = v2;
+        return v2;
     }
   }
 
-  async pull(options: ComposeOptions, services: Array<string> | undefined): Promise<void> {
+  async up(options: ComposeOptions, services: Array<string> | undefined): Promise<void> {
+    const client = await this.getClient();
+
     try {
       if (services) {
         log.info(`Pulling Compose environment images "${services.join('", "')}"...`);
-        await v1.pullMany(services, await defaultComposeOptions(this.environment, { ...options, logger: pullLog }));
+        await client.pullMany(services, await defaultComposeOptions(this.environment, { ...options, logger: pullLog }));
       } else {
         log.info(`Pulling Compose environment images...`);
-        await v1.pullAll(await defaultComposeOptions(this.environment, { ...options, logger: pullLog }));
+        await client.pullAll(await defaultComposeOptions(this.environment, { ...options, logger: pullLog }));
       }
       log.info(`Pulled Compose environment`);
     } catch (err) {
@@ -88,70 +82,16 @@ class ComposeV1Client implements ComposeClient {
     }
   }
 
-  async stop(options: ComposeOptions): Promise<void> {
-    try {
-      log.info(`Stopping Compose environment...`);
-      await v1.stop(await defaultComposeOptions(this.environment, options));
-      log.info(`Stopped Compose environment`);
-    } catch (err) {
-      await handleAndRethrow(err, async (error: Error) =>
-        log.error(`Failed to stop Compose environment: ${error.message}`)
-      );
-    }
-  }
-
-  async down(options: ComposeOptions, downOptions: ComposeDownOptions): Promise<void> {
-    try {
-      log.info(`Downing Compose environment...`);
-      await v1.down({
-        ...(await defaultComposeOptions(this.environment, options)),
-        commandOptions: composeDownCommandOptions(downOptions),
-      });
-      log.info(`Downed Compose environment`);
-    } catch (err) {
-      await handleAndRethrow(err, async (error: Error) =>
-        log.error(`Failed to down Compose environment: ${error.message}`)
-      );
-    }
-  }
-}
-
-class ComposeV2Client implements ComposeClient {
-  constructor(
-    public readonly info: ComposeInfo,
-    private readonly environment: NodeJS.ProcessEnv
-  ) {}
-
-  async up(options: ComposeOptions, services: Array<string> | undefined): Promise<void> {
-    try {
-      if (services) {
-        log.info(`Upping Compose environment services ${services.join(", ")}...`);
-        await v2.upMany(services, await defaultComposeOptions(this.environment, options));
-      } else {
-        log.info(`Upping Compose environment...`);
-        await v2.upAll(await defaultComposeOptions(this.environment, options));
-      }
-      log.info(`Upped Compose environment`);
-    } catch (err) {
-      await handleAndRethrow(err, async (error: Error) => {
-        try {
-          log.error(`Failed to up Compose environment: ${error.message}`);
-          await this.down(options, { removeVolumes: true, timeout: 0 });
-        } catch {
-          log.error(`Failed to down Compose environment after failed up`);
-        }
-      });
-    }
-  }
-
   async pull(options: ComposeOptions, services: Array<string> | undefined): Promise<void> {
+    const client = await this.getClient();
+
     try {
       if (services) {
         log.info(`Pulling Compose environment images "${services.join('", "')}"...`);
-        await v2.pullMany(services, await defaultComposeOptions(this.environment, { ...options, logger: pullLog }));
+        await client.pullMany(services, await defaultComposeOptions(this.environment, { ...options, logger: pullLog }));
       } else {
         log.info(`Pulling Compose environment images...`);
-        await v2.pullAll(await defaultComposeOptions(this.environment, { ...options, logger: pullLog }));
+        await client.pullAll(await defaultComposeOptions(this.environment, { ...options, logger: pullLog }));
       }
       log.info(`Pulled Compose environment`);
     } catch (err) {
@@ -162,9 +102,11 @@ class ComposeV2Client implements ComposeClient {
   }
 
   async stop(options: ComposeOptions): Promise<void> {
+    const client = await this.getClient();
+
     try {
       log.info(`Stopping Compose environment...`);
-      await v2.stop(await defaultComposeOptions(this.environment, options));
+      await client.stop(await defaultComposeOptions(this.environment, options));
       log.info(`Stopped Compose environment`);
     } catch (err) {
       await handleAndRethrow(err, async (error: Error) =>
@@ -174,9 +116,10 @@ class ComposeV2Client implements ComposeClient {
   }
 
   async down(options: ComposeOptions, downOptions: ComposeDownOptions): Promise<void> {
+    const client = await this.getClient();
     try {
       log.info(`Downing Compose environment...`);
-      await v2.down({
+      await client.down({
         ...(await defaultComposeOptions(this.environment, options)),
         commandOptions: composeDownCommandOptions(downOptions),
       });
@@ -189,26 +132,6 @@ class ComposeV2Client implements ComposeClient {
   }
 }
 
-class MissingComposeClient implements ComposeClient {
-  public readonly info = undefined;
-
-  up(): Promise<void> {
-    throw new Error("Compose is not installed");
-  }
-
-  pull(): Promise<void> {
-    throw new Error("Compose is not installed");
-  }
-
-  stop(): Promise<void> {
-    throw new Error("Compose is not installed");
-  }
-
-  down(): Promise<void> {
-    throw new Error("Compose is not installed");
-  }
-}
-
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 async function handleAndRethrow(err: any, handle: (error: Error) => Promise<void>): Promise<never> {
   const error = err instanceof Error ? err : new Error(err.err.trim());

packages/testcontainers/src/container-runtime/clients/types.ts

@@ -1,7 +1,6 @@
 export type Info = {
   node: NodeInfo;
   containerRuntime: ContainerRuntimeInfo;
-  compose: ComposeInfo;
 };
 
 export type NodeInfo = {
@@ -28,7 +27,7 @@ export type ContainerRuntimeInfo = {
 export type ComposeInfo =
   | {
       version: string;
-      compatability: "v1" | "v2";
+      compatibility: "v1" | "v2";
     }
   | undefined;
 

packages/testcontainers/src/utils/test-helper.ts

@@ -92,7 +92,8 @@ export const getVolumeNames = async (): Promise<string[]> => {
 
 export const composeContainerName = async (serviceName: string, index = 1): Promise<string> => {
   const client = await getContainerRuntimeClient();
-  return client.info.compose?.version.startsWith("1.") ? `${serviceName}_${index}` : `${serviceName}-${index}`;
+  const info = await client.compose.getInfo();
+  return info?.version.startsWith("1.") ? `${serviceName}_${index}` : `${serviceName}-${index}`;
 };
 
 export const waitForDockerEvent = async (eventStream: Readable, eventName: string, times = 1) => {