build-strap 4.0.0-dev.46 → 4.0.0-dev.54

package/src/dockerCompose.js

@@ -1,765 +1,439 @@
-// @flow
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _DockerComposeService_name, _DockerComposeService_svcDef, _DockerComposeService_dockerCompose, _DockerComposeService_tracker, _DockerComposeService_parsedPorts, _DockerComposeService_parsedNetworks, _DockerComposeService_parsedVolumes, _DockerComposeService_baseRunArgs;
 import fs from 'fs-extra';
+import getPort from 'get-port';
 import yaml from 'js-yaml';
 import path from 'path';
-import getPort from 'get-port';
-import { keys, entries, mapValuesAsync, type MapObj } from './maps';
-
-import { buildLog } from './run';
-import { dockerPull } from './docker';
-import {
-  dockerContainerFind,
-  dockerContainerRunDaemon,
-  type DockerContainer,
-} from './docker.container';
-import {
-  dockerNetworkDelete,
-  dockerNetworkCreate,
-  type DockerNetworkCreateOptions,
-  type DockerNetwork,
-} from './docker.network';
-import {
-  dockerVolumeCreate,
-  dockerVolumeRm,
-  type DockerVolume,
-} from './docker.volume';
-
-export type DockerComposeResourceTracker = {
-  services: Map<string, DockerComposeService>,
-  networks: Map<string, DockerNetwork>,
-  containers: Map<string, DockerContainer>,
-  volumes: Map<string, DockerVolume>,
-  cleaning: ?Promise<void>,
-};
-
-export const dockerComposeCreateResourceTracker = (): DockerComposeResourceTracker => ({
-  networks: new Map(),
-  services: new Map(),
-  containers: new Map(),
-  volumes: new Map(),
-  cleaning: null,
+import { dockerContainerFind, dockerContainerRunDaemon, } from './docker.container.js';
+import { dockerPull } from './docker.js';
+import { dockerNetworkCreate, dockerNetworkDelete, } from './docker.network.js';
+import { dockerVolumeCreate, dockerVolumeRm, } from './docker.volume.js';
+import { mapValuesAsync } from './maps.js';
+import { buildLog } from './run.js';
+export const dockerComposeCreateResourceTracker = () => ({
+    cleaning: null,
+    containers: new Map(),
+    networks: new Map(),
+    services: new Map(),
+    volumes: new Map(),
 });
-
 const defaultTracker = dockerComposeCreateResourceTracker();
-
-type DockerComposeEnvDef = string[] | { [string]: string };
-
-type DockerComposeULimitDef = number | { soft: number, hard: number };
-
-type DockerComposeULimitsDef = {
-  [string]: DockerComposeULimitDef,
-};
-
-type DockerComposeServiceDef = {
-  container_name?: string,
-  image?: string,
-  ports?: string[],
-  volumes?: string[],
-  command?: string[],
-  networks?: string[],
-  environment?: DockerComposeEnvDef,
-  links?: string[],
-  ulimits?: DockerComposeULimitsDef,
-};
-
-type DockerComposeVolumeDef = {
-  name?: string,
-};
-
-type DockerComposeNetworkDef = {
-  ...DockerNetworkCreateOptions,
-  name?: string,
-};
-
-type DockerCompose = {
-  version: string,
-  services?: {
-    [string]: DockerComposeServiceDef,
-  },
-  volumes?: {
-    [string]: DockerComposeVolumeDef,
-  },
-  networks?: {
-    [string]: DockerComposeNetworkDef,
-  },
-};
-
 /**
  * Parse a docker-compose.yml file into a pojo representation
  * @param {string} filePath Path to the docker-compose.yml file
  */
-export const dockerComposeParse = async (
-  filePath?: string = './docker-compose.yml',
-): Promise<DockerCompose> => (yaml.load(await fs.readFile(filePath)): any);
-
-let dc: ?DockerCompose = null;
-
+export const dockerComposeParse = async (filePath = './docker-compose.yml') => yaml.load(await fs.readFile(filePath, 'utf8'));
+let dc = null;
 /**
  * Get the main docker-compose.yml from the root of the repo
  * @param {boolean} force Force reload from file
  */
-export const dockerComposeGetMain = async (
-  force?: boolean = false,
-): Promise<DockerCompose> => {
-  if (force || !dc) {
-    dc = await dockerComposeParse();
-  }
-  return dc;
+export const dockerComposeGetMain = async (force = false) => {
+    if (force || !dc) {
+        dc = await dockerComposeParse();
+    }
+    return dc;
 };
-
 // Function that handles passed dockerCompose as either a file path or `DockerCompose` object.
 // If not passed, defaults to the main docker-compose.yml from the root of the repo
-const dockerComposeResolve = async (
-  dockerCompose?: ?(string | DockerCompose),
-  force?: boolean,
-): Promise<DockerCompose> =>
-  typeof dockerCompose === 'string'
+const dockerComposeResolve = async (dockerCompose, force) => typeof dockerCompose === 'string'
     ? dockerComposeParse(dockerCompose)
     : dockerCompose || dockerComposeGetMain(force);
-
 // Determines an unnamed resource's name from the dirname combined with the key
-const prefixName = (name: string) => `${path.basename(__dirname)}_${name}`;
-
-const getServiceDef = async (
-  name: string,
-  force?: boolean,
-  dockerCompose?: ?(string | DockerCompose),
-): Promise<?DockerComposeServiceDef> =>
-  (await dockerComposeResolve(dockerCompose, force)).services?.[name] || null;
-
-type PortMap = {
-  local: ?number,
-  localDefault: number,
-  docker: number,
-};
-
-type UrlMap = {
-  local: ?string,
-  docker: ?string,
+const prefixName = (name) => `${path.basename(__dirname)}_${name}`;
+const getServiceDef = async (name, force, dockerCompose) => (await dockerComposeResolve(dockerCompose, force)).services?.[name] || null;
+const parsePorts = async (portsCfg = [], avoidConflicts = true, mapLocal = true, host = '0.0.0.0') => {
+    const ports = [];
+    const runArgs = await portsCfg.reduce(async (args, portStr) => {
+        const [lp, dp] = portStr.split(':');
+        const localDefault = parseInt(lp, 10);
+        const docker = parseInt(dp, 10);
+        const local = mapLocal
+            ? avoidConflicts
+                ? await getPort({ host, port: localDefault })
+                : localDefault
+            : null;
+        ports.push({ docker, local, localDefault });
+        return local ? [...(await args), '-p', `${local}:${docker}`] : args;
+    }, Promise.resolve([]));
+    return { ports, runArgs };
 };
-
-type ParsedPortInfo = {
-  runArgs: string[],
-  ports: PortMap[],
-};
-
-const parsePorts = async (
-  portsCfg?: string[] = [],
-  avoidConflicts?: boolean = true,
-  mapLocal?: boolean = true,
-  host?: string = '0.0.0.0',
-): Promise<ParsedPortInfo> => {
-  const ports: PortMap[] = [];
-  const runArgs = await portsCfg.reduce(async (args, portStr) => {
-    const [lp, dp] = portStr.split(':');
-    const localDefault = parseInt(lp, 10);
-    const docker = parseInt(dp, 10);
-    const local = mapLocal
-      ? avoidConflicts
-        ? await getPort({ port: localDefault, host })
-        : localDefault
-      : null;
-    ports.push({ local, localDefault, docker });
-    return local ? [...(await args), '-p', `${local}:${docker}`] : args;
-  }, []);
-  return { runArgs, ports };
-};
-
-const parseEnv = (env?: DockerComposeEnvDef = []): string[] =>
-  Array.isArray(env)
+const parseEnv = (env = []) => Array.isArray(env)
     ? env.flatMap((e) => ['-e', e])
-    : entries(env).flatMap(([k, v]) => ['-e', `${k}=${v}`]);
-
-const parseULimits = (ul?: DockerComposeULimitsDef = {}): string[] =>
-  entries(ul).flatMap(([k, v]) => [
+    : Object.entries(env).flatMap(([k, v]) => ['-e', `${k}=${v}`]);
+const parseULimits = (ul = {}) => Object.entries(ul).flatMap(([k, v]) => [
     '--ulimit',
-    `${k}=${
-      typeof v === 'number' ? v : `${v.soft}${v.hard ? `:${v.hard}` : ''}`
-    }`,
-  ]);
-
-type ParsedVolumeInfo = {
-  runArgs: string[],
-  volumes: string[],
-};
-
-const parseVolumes = async (
-  volCfg?: string[] = [],
-  nameSuffix?: string = '',
-  dockerCompose?: ?(string | DockerCompose),
-): Promise<ParsedVolumeInfo> => {
-  const { volumes: volMap } = await dockerComposeResolve(dockerCompose);
-  const volumes = [];
-  const runArgs: string[] = volCfg
-    .map((v) => {
-      const [src, ...rest] = v.split(':');
-      const name = volMap?.[src]
-        ? `${volMap[src].name || prefixName(src)}${nameSuffix}`
-        : null;
-      if (name) {
-        volumes.push(name);
-      }
-      const realSrc = name || path.resolve(src);
-      return [realSrc, ...rest].join(':');
+    `${k}=${typeof v === 'number' ? v : `${v.soft}${v.hard ? `:${v.hard}` : ''}`}`,
+]);
+const parseVolumes = async (volCfg = [], nameSuffix = '', dockerCompose = null) => {
+    const { volumes: volMap } = await dockerComposeResolve(dockerCompose);
+    const volumes = [];
+    const runArgs = volCfg
+        .map((v) => {
+        const [src, ...rest] = v.split(':');
+        const name = volMap?.[src]
+            ? `${volMap[src].name || prefixName(src)}${nameSuffix}`
+            : null;
+        if (name) {
+            volumes.push(name);
+        }
+        const realSrc = name || path.resolve(src);
+        return [realSrc, ...rest].join(':');
     })
-    .flatMap((v) => ['-v', v]);
-  return { runArgs, volumes };
-};
-
-type ParsedNetworkInfo = {
-  runArgs: string[],
-  networks: string[],
+        .flatMap((v) => ['-v', v]);
+    return { runArgs, volumes };
 };
-
-const parseNetworks = async (
-  netCfg?: string[] = [],
-  dockerCompose?: ?(string | DockerCompose),
-): Promise<ParsedNetworkInfo> => {
-  const { networks: netMap } = await dockerComposeResolve(dockerCompose);
-  const networks = netCfg.map((n) => netMap?.[n].name || prefixName(n));
-  return {
-    networks,
-    runArgs: (networks.flatMap((n) => ['--network', n]): string[]),
-  };
+const parseNetworks = async (netCfg = [], dockerCompose = null) => {
+    const { networks: netMap } = await dockerComposeResolve(dockerCompose);
+    const networks = netCfg.map((n) => netMap?.[n].name || prefixName(n));
+    return {
+        networks,
+        runArgs: networks.flatMap((n) => ['--network', n]),
+    };
 };
-
-export const dockerComposeCreateNetworks = async (
-  names?: ?(string[]),
-  dockerCompose?: ?(string | DockerCompose),
-  tracker?: DockerComposeResourceTracker = defaultTracker,
-) => {
-  const { networks = {} } = await dockerComposeResolve(dockerCompose);
-  await Promise.all(
-    entries(networks).map(async ([key, val]) => {
-      const name = val?.name || prefixName(key);
-      if (!names || names.includes(name)) {
-        const network = await dockerNetworkCreate(name, (val || {}: any));
-        if (network) {
-          tracker.networks.set(name, network);
+export const dockerComposeCreateNetworks = async (names, dockerCompose, tracker = defaultTracker) => {
+    const { networks = {} } = await dockerComposeResolve(dockerCompose);
+    await Promise.all(Object.entries(networks).map(async ([key, val]) => {
+        const name = val?.name || prefixName(key);
+        if (names?.includes(name)) {
+            const network = await dockerNetworkCreate(name, val);
+            if (network) {
+                tracker.networks.set(name, network);
+            }
         }
-      }
-    }),
-  );
+    }));
 };
-
-export const dockerComposeCreateVolumes = async (
-  names?: string[],
-  dockerCompose?: ?(string | DockerCompose),
-  tracker?: DockerComposeResourceTracker = defaultTracker,
-) => {
-  const { volumes = {} } = await dockerComposeResolve(dockerCompose);
-  await Promise.all(
-    entries(volumes).map(async ([key, val]) => {
-      const name = val?.name || prefixName(key);
-      if (!names || names.includes(name)) {
-        const volume = await dockerVolumeCreate(name, (val || {}: any));
-        if (volume) {
-          tracker.volumes.set(name, volume);
+export const dockerComposeCreateVolumes = async (names, dockerCompose, tracker = defaultTracker) => {
+    const { volumes = {} } = await dockerComposeResolve(dockerCompose);
+    await Promise.all(Object.entries(volumes).map(async ([key, val]) => {
+        const name = val?.name || prefixName(key);
+        if (!names || names.includes(name)) {
+            const volume = await dockerVolumeCreate(name, val);
+            if (volume) {
+                tracker.volumes.set(name, volume);
+            }
         }
-      }
-    }),
-  );
-};
-
-type HealthCheckFn = (UpResult) => Promise<void>;
-
-type UpOptions = {
-  healthCheck?: HealthCheckFn,
-  avoidConflicts?: boolean,
-  mapVolumes?: boolean,
-  mapPorts?: boolean,
-  cmd?: string[],
-  tracker?: DockerComposeResourceTracker,
-};
-
-type ServiceNameInfo = {
-  name: string,
-  aliases: string[],
-  suffix: string,
+    }));
 };
-
-type UpResult = {|
-  service: DockerComposeService,
-  container: DockerContainer,
-  containerName: string,
-  aliases: string[],
-  ports: PortMap[],
-  urls: UrlMap[],
-  volumes: string[],
-|};
-
 export class DockerComposeService {
-  #name: string;
-  #svcDef: DockerComposeServiceDef;
-  #dockerCompose: ?(DockerCompose | string);
-  #tracker: DockerComposeResourceTracker = dockerComposeCreateResourceTracker();
-
-  // lazily computed
-  #parsedPorts: ?ParsedPortInfo = null;
-  #parsedNetworks: ?ParsedNetworkInfo = null;
-  #parsedVolumes: ?ParsedVolumeInfo = null;
-  #baseRunArgs: ?(string[]) = null;
-
-  constructor(
-    name: string,
-    serviceDef: DockerComposeServiceDef,
-    dockerCompose?: ?(DockerCompose | string),
-  ) {
-    this.#name = name;
-    this.#svcDef = serviceDef;
-    this.#dockerCompose = dockerCompose || null;
-  }
-
-  get name(): string {
-    return this.#name;
-  }
-
-  get serviceDef(): DockerComposeServiceDef {
-    return this.#svcDef;
-  }
-
-  get image(): ?string {
-    return this.#svcDef.image || null;
-  }
-
-  get defaultContainerName(): string {
-    return this.#svcDef.container_name || this.#name;
-  }
-
-  get cmd(): string[] {
-    return this.#svcDef.command || [];
-  }
-
-  get envArgs(): string[] {
-    return parseEnv(this.#svcDef.environment);
-  }
-
-  /**
-   * Find (available) container name and alias(es)
-   * @param {boolean} avoidConflicts if `true`, find a container name that is unused
-   * @param {number} max maximum number of names to try
-   */
-  async getNames(
-    avoidConflicts?: boolean = false,
-    max?: number = 100,
-  ): Promise<ServiceNameInfo> {
-    /* eslint-disable no-await-in-loop */
-    for (let i = 0; i < max; i += 1) {
-      const suffix = i ? `-${i}` : '';
-      const testName = `${this.defaultContainerName}${suffix}`;
-      const container = await dockerContainerFind(testName, { all: true });
-      if (!avoidConflicts || !container) {
-        return {
-          name: testName,
-          aliases: [`${this.name}${suffix}`],
-          suffix,
-        };
-      }
+    constructor(name, serviceDef, dockerCompose) {
+        _DockerComposeService_name.set(this, void 0);
+        _DockerComposeService_svcDef.set(this, void 0);
+        _DockerComposeService_dockerCompose.set(this, void 0);
+        _DockerComposeService_tracker.set(this, dockerComposeCreateResourceTracker());
+        // lazily computed
+        _DockerComposeService_parsedPorts.set(this, null);
+        _DockerComposeService_parsedNetworks.set(this, null);
+        _DockerComposeService_parsedVolumes.set(this, null);
+        _DockerComposeService_baseRunArgs.set(this, null);
+        __classPrivateFieldSet(this, _DockerComposeService_name, name, "f");
+        __classPrivateFieldSet(this, _DockerComposeService_svcDef, serviceDef, "f");
+        __classPrivateFieldSet(this, _DockerComposeService_dockerCompose, dockerCompose || null, "f");
     }
-    /* eslint-enable no-await-in-loop */
-    throw new Error(
-      `Failed to find available container name for ${this.defaultContainerName}`,
-    );
-  }
-
-  // Get (available) port mappings
-  async getPorts(
-    avoidConflicts?: boolean = false,
-    mapLocal?: boolean = true,
-  ): Promise<ParsedPortInfo> {
-    return parsePorts(this.#svcDef.ports, avoidConflicts, mapLocal);
-  }
-
-  async getDefaultPortInfo(): Promise<ParsedPortInfo> {
-    if (!this.#parsedPorts) {
-      this.#parsedPorts = await this.getPorts();
+    get name() {
+        return __classPrivateFieldGet(this, _DockerComposeService_name, "f");
     }
-    return this.#parsedPorts;
-  }
-
-  async getDefaultPorts(): Promise<PortMap[]> {
-    const { ports } = await this.getDefaultPortInfo();
-    return ports;
-  }
-
-  async getDefaultPortArgs(): Promise<string[]> {
-    const { runArgs } = await this.getDefaultPortInfo();
-    return runArgs;
-  }
-
-  async getDefaultUrls(): Promise<UrlMap[]> {
-    return this.constructor.getUrls(
-      await this.getDefaultPorts(),
-      this.defaultContainerName,
-    );
-  }
-
-  async getDefaultNetworkInfo(): Promise<ParsedNetworkInfo> {
-    if (!this.#parsedNetworks) {
-      this.#parsedNetworks = await parseNetworks(this.#svcDef.networks);
+    get serviceDef() {
+        return __classPrivateFieldGet(this, _DockerComposeService_svcDef, "f");
     }
-    return this.#parsedNetworks;
-  }
-
-  async getDefaultNetworks(): Promise<string[]> {
-    const { networks } = await this.getDefaultNetworkInfo();
-    return networks;
-  }
-
-  async getDefaultNetworkArgs(): Promise<string[]> {
-    const { runArgs } = await this.getDefaultNetworkInfo();
-    return runArgs;
-  }
-
-  async getDefaultVolumeInfo(): Promise<ParsedVolumeInfo> {
-    if (!this.#parsedVolumes) {
-      this.#parsedVolumes = await parseVolumes(this.#svcDef.networks);
+    get image() {
+        return __classPrivateFieldGet(this, _DockerComposeService_svcDef, "f").image || null;
     }
-    return this.#parsedVolumes;
-  }
-
-  async getDefaultVolumes(): Promise<string[]> {
-    const { volumes } = await this.getDefaultVolumeInfo();
-    return volumes;
-  }
-
-  async getDefaultVolumeArgs(): Promise<string[]> {
-    const { runArgs } = await this.getDefaultVolumeInfo();
-    return runArgs;
-  }
-
-  async pull() {
-    if (!this.image) {
-      throw new Error(`Cannot pull '${this.name}', no image configured.`);
+    get defaultContainerName() {
+        return __classPrivateFieldGet(this, _DockerComposeService_svcDef, "f").container_name || __classPrivateFieldGet(this, _DockerComposeService_name, "f");
     }
-    await dockerPull({ image: this.image });
-  }
-
-  async getBaseRunArgs(): Promise<string[]> {
-    if (!this.#baseRunArgs) {
-      const envArgs = parseEnv(this.#svcDef.environment);
-      const ulArgs = parseULimits(this.#svcDef.ulimits);
-      const netArgs = await this.getDefaultNetworkArgs();
-
-      this.#baseRunArgs = ['--rm', ...envArgs, ...netArgs, ...ulArgs];
+    get cmd() {
+        return __classPrivateFieldGet(this, _DockerComposeService_svcDef, "f").command || [];
     }
-    return this.#baseRunArgs;
-  }
-
-  async assembleRunArgs(
-    containerName?: string = this.defaultContainerName,
-    aliases?: string[] = [this.name],
-    additionalArgs?: string[],
-  ): Promise<string[]> {
-    const additional = additionalArgs || [
-      ...(await this.getDefaultPortArgs()),
-      ...(await this.getDefaultVolumeArgs()),
-    ];
-    return [
-      ...(await this.getBaseRunArgs()),
-      ...(containerName ? ['--name', containerName] : []),
-      ...aliases.flatMap((a) => (a ? ['--network-alias', a] : [])),
-      ...additional,
-    ];
-  }
-
-  async getRunArgs(
-    avoidConflicts?: boolean = false,
-    mapLocalPorts?: boolean = true,
-  ): Promise<string[]> {
-    const { name: cName, aliases, suffix } = await this.getNames(
-      avoidConflicts,
-    );
-    const { runArgs: pArgs } = await this.getPorts(
-      avoidConflicts,
-      mapLocalPorts,
-    );
-    const { runArgs: vArgs } = await parseVolumes(this.#svcDef.volumes, suffix);
-    return this.assembleRunArgs(cName, aliases, [...pArgs, ...vArgs]);
-  }
-
-  async up({
-    healthCheck,
-    avoidConflicts = false,
-    mapVolumes = true,
-    mapPorts = true,
-    cmd = this.cmd,
-    tracker = defaultTracker,
-  }: UpOptions = {}): Promise<UpResult> {
-    const { image } = this;
-    if (!image) {
-      throw new Error(
-        `Cannot bring up service '${this.name}', no image defined.`,
-      );
+    get envArgs() {
+        return parseEnv(__classPrivateFieldGet(this, _DockerComposeService_svcDef, "f").environment);
     }
-    if (this.#tracker.containers.size) {
-      buildLog(
-        `Warning: up called on service '${this.name}' with already running container`,
-      );
+    /**
+     * Find (available) container name and alias(es)
+     * @param {boolean} avoidConflicts if `true`, find a container name that is unused
+     * @param {number} max maximum number of names to try
+     */
+    async getNames(avoidConflicts = false, max = 100) {
+        /* eslint-disable no-await-in-loop */
+        for (let i = 0; i < max; i += 1) {
+            const suffix = i ? `-${i}` : '';
+            const testName = `${this.defaultContainerName}${suffix}`;
+            const container = await dockerContainerFind(testName, { all: true });
+            if (!avoidConflicts || !container) {
+                return {
+                    aliases: [`${this.name}${suffix}`],
+                    name: testName,
+                    suffix,
+                };
+            }
+        }
+        /* eslint-enable no-await-in-loop */
+        throw new Error(`Failed to find available container name for ${this.defaultContainerName}`);
     }
-    const { name: containerName, aliases, suffix } = await this.getNames(
-      avoidConflicts,
-    );
-    const { runArgs: pArgs, ports } = await this.getPorts(
-      avoidConflicts,
-      mapPorts,
-    );
-    const { runArgs: vArgs, volumes } = mapVolumes
-      ? await parseVolumes(this.#svcDef.volumes, suffix)
-      : { runArgs: [], volumes: [] };
-
-    let container = await dockerContainerFind(containerName, { all: true });
-    if (container && !(await container.isRunning())) {
-      await container.start();
+    // Get (available) port mappings
+    async getPorts(avoidConflicts = false, mapLocal = true) {
+        return parsePorts(__classPrivateFieldGet(this, _DockerComposeService_svcDef, "f").ports, avoidConflicts, mapLocal);
     }
-    if (!container) {
-      await this.pull();
-      await dockerComposeCreateNetworks(
-        await this.getDefaultNetworks(),
-        this.#dockerCompose,
-        this.#tracker,
-      );
-      await dockerComposeCreateVolumes(
-        volumes,
-        this.#dockerCompose,
-        this.#tracker,
-      );
-      const runArgs = await this.assembleRunArgs(containerName, aliases, [
-        ...pArgs,
-        ...vArgs,
-      ]);
-      container = await dockerContainerRunDaemon({
-        image,
-        runArgs,
-        cmd,
-      });
-    } else {
-      buildLog(`Reusing existing container for '${this.name}' service.`);
+    async getDefaultPortInfo() {
+        if (!__classPrivateFieldGet(this, _DockerComposeService_parsedPorts, "f")) {
+            __classPrivateFieldSet(this, _DockerComposeService_parsedPorts, await this.getPorts(), "f");
+        }
+        return __classPrivateFieldGet(this, _DockerComposeService_parsedPorts, "f");
     }
-    // This service tracks the things it created
-    this.#tracker.containers.set(containerName, container);
-    // The passed tracker needs to track this service
-    tracker.services.set(this.name, this);
-
-    const idAlias = container.id.slice(0, 12);
-    aliases.push(idAlias);
-    const urls = this.constructor.getUrls(ports, idAlias);
-
-    const info: UpResult = {
-      service: this,
-      container,
-      containerName,
-      aliases,
-      ports,
-      volumes,
-      urls,
-    };
-    await healthCheck?.(info);
-    return info;
-  }
-
-  async down({
-    includeDefaults = false,
-    includeVolumes = false,
-    includeNetworks = false,
-  }: {
-    includeDefaults?: boolean,
-    includeVolumes?: boolean,
-    includeNetworks?: boolean,
-  } = {}) {
-    buildLog(`Bringing down <${this.name}> service...`);
-    await dockerComposeTeardown({
-      tracker: this.#tracker,
-      includeVolumes,
-      includeNetworks,
-    });
-    if (includeDefaults) {
-      const container = await dockerContainerFind(this.defaultContainerName);
-      if (container) {
-        await container.teardown(true);
-      }
+    async getDefaultPorts() {
+        const { ports } = await this.getDefaultPortInfo();
+        return ports;
     }
-  }
-
-  static async parse(
-    name: string,
-    force?: boolean = true,
-    dockerCompose?: ?(DockerCompose | string),
-  ): Promise<?DockerComposeService> {
-    const svcDef = await getServiceDef(name, force, dockerCompose);
-    return svcDef ? new this(name, svcDef, dockerCompose) : null;
-  }
-
-  static getUrls(ports: PortMap[], alias: string): UrlMap[] {
-    return ports.map(({ local, docker }) => ({
-      local: local ? `http://localhost:${local}` : null,
-      docker: docker ? `http://${alias}:${docker}` : null,
-    }));
-  }
-}
-
-export async function dockerComposeGetAllServices(
-  dockerCompose?: ?(string | DockerCompose),
-): Promise<MapObj<string, DockerComposeService>> {
-  const { services } = await dockerComposeResolve(dockerCompose);
-  return mapValuesAsync(services, (s, name) =>
-    DockerComposeService.parse(name),
-  );
-}
-
-export async function dockerComposeTeardown({
-  includeDefaults = false,
-  includeVolumes = false,
-  includeNetworks = false,
-  dockerCompose,
-  tracker = defaultTracker,
-}: {
-  includeDefaults?: boolean,
-  includeVolumes?: boolean,
-  includeNetworks?: boolean,
-  dockerCompose?: ?(string | DockerCompose),
-  tracker?: DockerComposeResourceTracker,
-} = {}): Promise<void> {
-  if (!tracker.cleaning) {
-    // eslint-disable-next-line no-param-reassign
-    tracker.cleaning = (async () => {
-      if (tracker.services.size) {
-        buildLog('Bringing down started docker services...');
-        const promises = Promise.all(
-          Array.from(tracker.services.values()).map(async (s) =>
-            s.down({ includeVolumes, includeNetworks }),
-          ),
-        );
-        tracker.services.clear();
-        await promises;
-      }
-      if (includeDefaults) {
-        const { services } = await dockerComposeResolve(dockerCompose);
-        const svcNames = keys(services);
-        if (svcNames.length) {
-          buildLog('Bringing down default docker services...');
-          await Promise.all(
-            svcNames.map(async (s) =>
-              (await DockerComposeService.parse(s))?.down({
-                includeDefaults,
-                includeVolumes,
-                includeNetworks,
-              }),
-            ),
-          );
+    async getDefaultPortArgs() {
+        const { runArgs } = await this.getDefaultPortInfo();
+        return runArgs;
+    }
+    async getDefaultUrls() {
+        return DockerComposeService.getUrls(await this.getDefaultPorts(), this.defaultContainerName);
+    }
+    async getDefaultNetworkInfo() {
+        if (!__classPrivateFieldGet(this, _DockerComposeService_parsedNetworks, "f")) {
+            __classPrivateFieldSet(this, _DockerComposeService_parsedNetworks, await parseNetworks(__classPrivateFieldGet(this, _DockerComposeService_svcDef, "f").networks), "f");
         }
-      }
-
-      if (tracker.containers.size) {
-        buildLog('Stopping created docker containers...');
-        const promises = Promise.all(
-          Array.from(tracker.containers.values()).map(async (c) =>
-            c.teardown(true),
-          ),
-        );
-        tracker.containers.clear();
-        await promises;
-      }
-
-      if (includeVolumes) {
-        if (tracker.volumes.size) {
-          buildLog('Removing created docker volumes...');
-          const promises = Promise.all(
-            Array.from(tracker.volumes.values()).map(async (v) => v.rm()),
-          );
-          tracker.volumes.clear();
-          await promises;
+        return __classPrivateFieldGet(this, _DockerComposeService_parsedNetworks, "f");
+    }
+    async getDefaultNetworks() {
+        const { networks } = await this.getDefaultNetworkInfo();
+        return networks;
+    }
+    async getDefaultNetworkArgs() {
+        const { runArgs } = await this.getDefaultNetworkInfo();
+        return runArgs;
+    }
+    async getDefaultVolumeInfo() {
+        if (!__classPrivateFieldGet(this, _DockerComposeService_parsedVolumes, "f")) {
+            __classPrivateFieldSet(this, _DockerComposeService_parsedVolumes, await parseVolumes(__classPrivateFieldGet(this, _DockerComposeService_svcDef, "f").networks), "f");
         }
-        if (includeDefaults) {
-          buildLog('Removing default docker volumes...');
-          const { volumes } = await dockerComposeResolve(dockerCompose);
-          await Promise.all(
-            entries(volumes).map(async ([key, val]) => {
-              const name = val?.name || prefixName(key);
-              await dockerVolumeRm(name, true);
-            }),
-          );
+        return __classPrivateFieldGet(this, _DockerComposeService_parsedVolumes, "f");
+    }
+    async getDefaultVolumes() {
+        const { volumes } = await this.getDefaultVolumeInfo();
+        return volumes;
+    }
+    async getDefaultVolumeArgs() {
+        const { runArgs } = await this.getDefaultVolumeInfo();
+        return runArgs;
+    }
+    async pull() {
+        if (!this.image) {
+            throw new Error(`Cannot pull '${this.name}', no image configured.`);
+        }
+        await dockerPull({ image: this.image });
+    }
+    async getBaseRunArgs() {
+        if (!__classPrivateFieldGet(this, _DockerComposeService_baseRunArgs, "f")) {
+            const envArgs = parseEnv(__classPrivateFieldGet(this, _DockerComposeService_svcDef, "f").environment);
+            const ulArgs = parseULimits(__classPrivateFieldGet(this, _DockerComposeService_svcDef, "f").ulimits);
+            const netArgs = await this.getDefaultNetworkArgs();
+            __classPrivateFieldSet(this, _DockerComposeService_baseRunArgs, ['--rm', ...envArgs, ...netArgs, ...ulArgs], "f");
+        }
+        return __classPrivateFieldGet(this, _DockerComposeService_baseRunArgs, "f");
+    }
+    async assembleRunArgs(containerName = this.defaultContainerName, aliases = [this.name], additionalArgs = null) {
+        const additional = additionalArgs || [
+            ...(await this.getDefaultPortArgs()),
+            ...(await this.getDefaultVolumeArgs()),
+        ];
+        return [
+            ...(await this.getBaseRunArgs()),
+            ...(containerName ? ['--name', containerName] : []),
+            ...aliases.flatMap((a) => (a ? ['--network-alias', a] : [])),
+            ...additional,
+        ];
+    }
+    async getRunArgs(avoidConflicts = false, mapLocalPorts = true) {
+        const { aliases, name: cName, suffix, } = await this.getNames(avoidConflicts);
+        const { runArgs: pArgs } = await this.getPorts(avoidConflicts, mapLocalPorts);
+        const { runArgs: vArgs } = await parseVolumes(__classPrivateFieldGet(this, _DockerComposeService_svcDef, "f").volumes, suffix);
+        return this.assembleRunArgs(cName, aliases, [...pArgs, ...vArgs]);
+    }
+    async up({ healthCheck, avoidConflicts = false, mapVolumes = true, mapPorts = true, cmd = this.cmd, tracker = defaultTracker, } = {}) {
+        const { image } = this;
+        if (!image) {
+            throw new Error(`Cannot bring up service '${this.name}', no image defined.`);
         }
-      }
-
-      if (includeNetworks) {
-        if (tracker.networks.size) {
-          buildLog('Removing created docker networks...');
-          const promises = Promise.all(
-            Array.from(tracker.networks.values()).map(async (n) => n.rm()),
-          );
-          tracker.networks.clear();
-          await promises;
+        if (__classPrivateFieldGet(this, _DockerComposeService_tracker, "f").containers.size) {
+            buildLog(`Warning: up called on service '${this.name}' with already running container`);
         }
+        const { aliases, name: containerName, suffix, } = await this.getNames(avoidConflicts);
+        const { ports, runArgs: pArgs } = await this.getPorts(avoidConflicts, mapPorts);
+        const { runArgs: vArgs, volumes } = mapVolumes
+            ? await parseVolumes(__classPrivateFieldGet(this, _DockerComposeService_svcDef, "f").volumes, suffix)
+            : { runArgs: [], volumes: [] };
+        let container = await dockerContainerFind(containerName, { all: true });
+        if (container && !(await container.isRunning())) {
+            await container.start();
+        }
+        if (!container) {
+            await this.pull();
+            await dockerComposeCreateNetworks(await this.getDefaultNetworks(), __classPrivateFieldGet(this, _DockerComposeService_dockerCompose, "f"), __classPrivateFieldGet(this, _DockerComposeService_tracker, "f"));
+            await dockerComposeCreateVolumes(volumes, __classPrivateFieldGet(this, _DockerComposeService_dockerCompose, "f"), __classPrivateFieldGet(this, _DockerComposeService_tracker, "f"));
+            const runArgs = await this.assembleRunArgs(containerName, aliases, [
+                ...pArgs,
+                ...vArgs,
+            ]);
+            container = await dockerContainerRunDaemon({
+                cmd,
+                image,
+                runArgs,
+            });
+        }
+        else {
+            buildLog(`Reusing existing container for '${this.name}' service.`);
+        }
+        // This service tracks the things it created
+        __classPrivateFieldGet(this, _DockerComposeService_tracker, "f").containers.set(containerName, container);
+        // The passed tracker needs to track this service
+        tracker.services.set(this.name, this);
+        const idAlias = container.id.slice(0, 12);
+        aliases.push(idAlias);
+        const urls = DockerComposeService.getUrls(ports, idAlias);
+        const info = {
+            aliases,
+            container,
+            containerName,
+            ports,
+            service: this,
+            urls,
+            volumes,
+        };
+        await healthCheck?.(info);
+        return info;
+    }
+    async down({ includeDefaults = false, includeNetworks = false, includeVolumes = false, } = {}) {
+        buildLog(`Bringing down <${this.name}> service...`);
+        await dockerComposeTeardown({
+            includeNetworks,
+            includeVolumes,
+            tracker: __classPrivateFieldGet(this, _DockerComposeService_tracker, "f"),
+        });
         if (includeDefaults) {
-          buildLog('Removing default docker networks...');
-          const { networks } = await dockerComposeResolve(dockerCompose);
-          await Promise.all(
-            entries(networks).map(async ([key, val]) => {
-              const name = val?.name || prefixName(key);
-              try {
-                await dockerNetworkDelete(name);
-              } catch (err) {
-                buildLog(`Error deleting network '${name}': ${err.message}`);
-              }
-            }),
-          );
+            const container = await dockerContainerFind(this.defaultContainerName);
+            if (container) {
+                await container.teardown(true);
+            }
         }
-      }
-      // eslint-disable-next-line no-param-reassign
-      tracker.cleaning = null;
-    })();
-  }
-  return tracker.cleaning;
+    }
+    static async parse(name, force = true, dockerCompose = null) {
+        const svcDef = await getServiceDef(name, force, dockerCompose);
+        return svcDef ? new this(name, svcDef, dockerCompose) : null;
+    }
+    static getUrls(ports, alias) {
+        return ports.map(({ docker, local }) => ({
+            docker: docker ? `http://${alias}:${docker}` : null,
+            local: local ? `http://localhost:${local}` : null,
+        }));
+    }
+}
+_DockerComposeService_name = new WeakMap(), _DockerComposeService_svcDef = new WeakMap(), _DockerComposeService_dockerCompose = new WeakMap(), _DockerComposeService_tracker = new WeakMap(), _DockerComposeService_parsedPorts = new WeakMap(), _DockerComposeService_parsedNetworks = new WeakMap(), _DockerComposeService_parsedVolumes = new WeakMap(), _DockerComposeService_baseRunArgs = new WeakMap();
+export async function dockerComposeGetAllServices(dockerCompose) {
+    const { services } = await dockerComposeResolve(dockerCompose);
+    return mapValuesAsync(services, (s, name) => DockerComposeService.parse(name));
+}
+export async function dockerComposeTeardown({ includeDefaults = false, includeVolumes = false, includeNetworks = false, dockerCompose, tracker = defaultTracker, } = {}) {
+    if (!tracker.cleaning) {
+        // eslint-disable-next-line no-param-reassign
+        tracker.cleaning = (async () => {
+            if (tracker.services.size) {
+                buildLog('Bringing down started docker services...');
+                const promises = Promise.all(Array.from(tracker.services.values()).map(async (s) => s.down({ includeNetworks, includeVolumes })));
+                tracker.services.clear();
+                await promises;
+            }
+            if (includeDefaults) {
+                const { services } = await dockerComposeResolve(dockerCompose);
+                const svcNames = Object.keys(services ?? {});
+                if (svcNames.length) {
+                    buildLog('Bringing down default docker services...');
+                    await Promise.all(svcNames.map(async (s) => (await DockerComposeService.parse(s))?.down({
+                        includeDefaults,
+                        includeNetworks,
+                        includeVolumes,
+                    })));
+                }
+            }
+            if (tracker.containers.size) {
+                buildLog('Stopping created docker containers...');
+                const promises = Promise.all(Array.from(tracker.containers.values()).map(async (c) => c.teardown(true)));
+                tracker.containers.clear();
+                await promises;
+            }
+            if (includeVolumes) {
+                if (tracker.volumes.size) {
+                    buildLog('Removing created docker volumes...');
+                    const promises = Promise.all(Array.from(tracker.volumes.values()).map(async (v) => v.rm()));
+                    tracker.volumes.clear();
+                    await promises;
+                }
+                if (includeDefaults) {
+                    buildLog('Removing default docker volumes...');
+                    const { volumes } = await dockerComposeResolve(dockerCompose);
+                    await Promise.all(Object.entries(volumes ?? {}).map(async ([key, val]) => {
+                        const name = val?.name || prefixName(key);
+                        await dockerVolumeRm(name, true);
+                    }));
+                }
+            }
+            if (includeNetworks) {
+                if (tracker.networks.size) {
+                    buildLog('Removing created docker networks...');
+                    const promises = Promise.all(Array.from(tracker.networks.values()).map(async (n) => n.rm()));
+                    tracker.networks.clear();
+                    await promises;
+                }
+                if (includeDefaults) {
+                    buildLog('Removing default docker networks...');
+                    const { networks } = await dockerComposeResolve(dockerCompose);
+                    await Promise.all(Object.entries(networks ?? {}).map(async ([key, val]) => {
+                        const name = val?.name || prefixName(key);
+                        try {
+                            await dockerNetworkDelete(name);
+                        }
+                        catch (err) {
+                            buildLog(`Error deleting network '${name}': ${err.message}`);
+                        }
+                    }));
+                }
+            }
+            // eslint-disable-next-line no-param-reassign
+            tracker.cleaning = null;
+        })();
+    }
+    return tracker.cleaning;
 }
-
-export type DockerContainerInfo = {|
-  ...UpResult,
-  id: string,
-  image: string,
-  name?: ?string,
-
-  // for convenience, the first port mapping info
-  port?: ?number,
-  dockerPort?: ?number,
-  url?: ?string,
-  dockerUrl?: ?string,
-|};
-
-export async function dockerComposeRunService(
-  key: string,
-  upOptions?: UpOptions = {},
-  dockerCompose?: ?(string | DockerCompose),
-): Promise<DockerContainerInfo> {
-  const service: ?DockerComposeService = await DockerComposeService.parse(
-    key,
-    false,
-    dockerCompose,
-  );
-  if (!service) {
-    throw new Error(`Failed to find service '${key}'`);
-  }
-  buildLog(`Starting <${service.name}> service...`);
-  const upResult: UpResult = await service.up(upOptions);
-  const {
-    container,
-    urls,
-    urls: [{ local: url, docker: dockerUrl }],
-    ports: [{ local: port, docker: dockerPort }],
-  } = upResult;
-  const { id, name, image } = container;
-  urls.forEach(
-    ({ local }) =>
-      local && buildLog(`<${service.name}> accessible at ${local}`),
-  );
-  return {
-    ...upResult,
-    id,
-    image,
-    name,
-    port,
-    dockerPort,
-    url,
-    dockerUrl,
-  };
+export async function dockerComposeRunService(key, upOptions = {}, dockerCompose = null) {
+    const service = await DockerComposeService.parse(key, false, dockerCompose);
+    if (!service) {
+        throw new Error(`Failed to find service '${key}'`);
+    }
+    buildLog(`Starting <${service.name}> service...`);
+    const upResult = await service.up(upOptions);
+    const { container, urls, urls: [{ docker: dockerUrl, local: url }], ports: [{ docker: dockerPort, local: port }], } = upResult;
+    const { id, image, name } = container;
+    urls.forEach(({ local }) => local && buildLog(`<${service.name}> accessible at ${local}`));
+    return {
+        ...upResult,
+        dockerPort,
+        dockerUrl,
+        id,
+        image,
+        name,
+        port,
+        url,
+    };
 }