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

package/src/docker.container.js

@@ -1,345 +1,212 @@
-// @flow
 import bytes from 'bytes';
-import throttle from 'lodash/throttle';
-import { buildLog } from './run';
-import { spawn } from './cp';
-import type { SpawnOptions } from './cp';
-import { parseDockerDate } from './docker';
-
-type DockerContainerInspectOutput = {
-  [string]: any,
-};
-
-export type DockerContainer = {|
-  command: string,
-  created: Date,
-  id: string,
-  image: string,
-  labels: string[],
-  mounts: string[],
-  name: string,
-  names: string[],
-  networks: string[],
-  ports: Array<{ iface: string, sourcePort: number, destPort: number }>,
-  runningFor: string,
-  size: string,
-  status: string,
-  exited: boolean,
-  inspect: () => Promise<DockerContainerInspectOutput>,
-  exists: () => Promise<boolean>,
-  isRunning: () => Promise<boolean>,
-  start: () => Promise<void>,
-  stop: (ignoreError?: boolean) => Promise<void>,
-  kill: (ignoreError?: boolean) => Promise<void>,
-  restart: () => Promise<void>,
-  rm: (ignoreError?: boolean) => Promise<void>,
-  teardown: (verbose?: boolean) => Promise<void>,
-|};
-
-type DockerContainerLsOptions = {
-  all?: boolean,
-  filter?: (container: DockerContainer) => boolean,
-};
-
+import { throttle } from 'lodash-es';
+import { spawn } from './cp.js';
+import { parseDockerDate } from './docker.js';
+import { buildLog } from './run.js';
 // calling this function in rapid succession can lead to errors.
 // prefer throttled version
-export async function _dockerContainerLs({
-  all,
-  filter,
-}: DockerContainerLsOptions = {}): Promise<DockerContainer[]> {
-  return (
-    await spawn(
-      'docker',
-      [
+export async function unthrottledDockerContainerLs({ all, filter, } = {}) {
+    return (await spawn('docker', [
         'container',
         'ls',
         ...(all ? ['--all'] : []),
         '--no-trunc',
         '--format',
         '{{json .}}',
-      ],
-      { captureOutput: true },
-    )
-  )
-    .split('\n')
-    .filter((line) => !!line.trim())
-    .map((line) => {
-      const {
-        Command: command,
-        CreatedAt,
-        ID: id,
-        Image: image,
-        Labels,
-        Mounts,
-        Names,
-        Networks,
-        Ports,
-        RunningFor: runningFor,
-        Size,
-        Status: status,
-      } = JSON.parse(line.trim());
-      const names = Names.split(',').map((n) => n.trim());
-      const [name] = names;
-
-      return {
-        command,
-        id,
-        image,
-        name,
-        names,
-        runningFor,
-        size: bytes.parse(Size),
-        status,
-        created: parseDockerDate(CreatedAt),
-        labels: Labels.split(',').map((l) => l.trim()),
-        mounts: Mounts.split(',').map((m) => m.trim()),
-        networks: Networks.split(',').map((n) => n.trim()),
-        ports: Ports.split(',').map((p) => {
-          const [, iface, src, dest] =
-            p.match(/^([^:]+):(\d+)-\\u003e(\d+)/i) || [];
-          return {
-            iface,
-            src: parseInt(src, 10),
-            dest: parseInt(dest, 10),
-          };
-        }),
-        exited: /^Exited/.test(status),
-        inspect: async () => (await dockerContainerInspect(id))[0],
-        async exists(): Promise<boolean> {
-          try {
-            return !!(await this.inspect());
-          } catch {
-            return false;
-          }
-        },
-        async isRunning(): Promise<boolean> {
-          try {
-            const {
-              State: { Running: running },
-            } = await this.inspect();
-            return running;
-          } catch {
-            return false;
-          }
-        },
-        start: async () => dockerContainerStart(id),
-        stop: async (ignoreError?: boolean = true) =>
-          dockerContainerStop(id, ignoreError),
-        kill: async (ignoreError?: boolean = true) =>
-          dockerContainerKill(id, ignoreError),
-        restart: async () => dockerContainerRestart(id),
-        rm: async (ignoreError?: boolean = true) =>
-          dockerContainerRm(id, ignoreError),
-        async teardown(verbose?: boolean = true) {
-          const log = (msg) => verbose && buildLog(msg);
-          if (await this.isRunning()) {
-            try {
-              log(`Stopping container: <${this.name}>...`);
-              await this.stop(false);
-              log(`<${this.name}> container stopped.`);
-            } catch (e1) {
-              log(`Failed to stop <${this.name}> container: ${e1.message}`);
-              try {
-                log(`Killing container: <${this.name}>...`);
-                await this.kill(false);
-                log(`<${this.name}> container killed.`);
-              } catch (e2) {
-                log(`Failed to kill <${this.name}> container: ${e2.message}`);
-              }
-            }
-          } else {
-            log(`<${this.name}> container not running, skipping stop.`);
-          }
-          if (await this.exists()) {
-            await this.rm(true);
-          } else {
-            log(`<${this.name}> container does not exist, skipping rm.`);
-          }
-        },
-      };
+    ], { captureOutput: true })).output
+        .split('\n')
+        .filter((line) => !!line.trim())
+        .map((line) => {
+        const { Command: command, CreatedAt, ID: id, Image: image, Labels, Mounts, Names, Networks, Ports, RunningFor: runningFor, Size, Status: status, } = JSON.parse(line.trim());
+        const names = Names.split(',').map((n) => n.trim());
+        const [name] = names;
+        return {
+            command,
+            created: parseDockerDate(CreatedAt),
+            async exists() {
+                try {
+                    return !!(await this.inspect());
+                }
+                catch {
+                    return false;
+                }
+            },
+            exited: /^Exited/.test(status),
+            id,
+            image,
+            inspect: async () => (await dockerContainerInspect(id))?.[0],
+            async isRunning() {
+                try {
+                    return (await this.inspect())?.State?.Running || false;
+                }
+                catch {
+                    return false;
+                }
+            },
+            kill: async (ignoreError = true) => dockerContainerKill(id, ignoreError),
+            labels: Labels.split(',').map((l) => l.trim()),
+            mounts: Mounts.split(',').map((m) => m.trim()),
+            name,
+            names,
+            networks: Networks.split(',').map((n) => n.trim()),
+            ports: Ports.split(',').map((p) => {
+                const [, iface, src, dest] = p.match(/^([^:]+):(\d+)-\\u003e(\d+)/i) || [];
+                return {
+                    dest: parseInt(dest, 10),
+                    iface,
+                    src: parseInt(src, 10),
+                };
+            }),
+            restart: async () => dockerContainerRestart(id),
+            rm: async (ignoreError = true) => dockerContainerRm(id, ignoreError),
+            runningFor,
+            size: bytes.parse(Size),
+            start: async () => dockerContainerStart(id),
+            status,
+            stop: async (ignoreError = true) => dockerContainerStop(id, ignoreError),
+            async teardown(verbose = true) {
+                const log = (msg) => verbose && buildLog(msg);
+                if (await this.isRunning()) {
+                    try {
+                        log(`Stopping container: <${this.name}>...`);
+                        await this.stop(false);
+                        log(`<${this.name}> container stopped.`);
+                    }
+                    catch (e1) {
+                        log(`Failed to stop <${this.name}> container: ${e1.message}`);
+                        try {
+                            log(`Killing container: <${this.name}>...`);
+                            await this.kill(false);
+                            log(`<${this.name}> container killed.`);
+                        }
+                        catch (e2) {
+                            log(`Failed to kill <${this.name}> container: ${e2.message}`);
+                        }
+                    }
+                }
+                else {
+                    log(`<${this.name}> container not running, skipping stop.`);
+                }
+                if (await this.exists()) {
+                    await this.rm(true);
+                }
+                else {
+                    log(`<${this.name}> container does not exist, skipping rm.`);
+                }
+            },
+        };
     })
-    .filter((c) => c.id && (typeof filter === 'function' ? filter(c) : true));
+        .filter((c) => c.id && (typeof filter === 'function' ? filter(c) : true));
 }
-
-export const dockerContainerLs: (
-  DockerContainerLsOptions | void,
-) => Promise<DockerContainer[]> = throttle(_dockerContainerLs, 500, {
-  trailing: false,
+export const dockerContainerLs = throttle(unthrottledDockerContainerLs, 500, {
+    trailing: false,
 });
-
-export async function dockerContainerFind(
-  search: string,
-  options?: DockerContainerLsOptions,
-): Promise<?DockerContainer> {
-  return (
-    (await dockerContainerLs(options)).find(
-      (c) =>
-        c.name === search ||
+export async function dockerContainerFind(search, options) {
+    return ((await dockerContainerLs(options))?.find((c) => c.name === search ||
         c.id.startsWith(search) ||
-        c.names.includes(search),
-    ) || null
-  );
+        c.names.includes(search)) || null);
 }
-
-export async function dockerContainerStop(
-  id: string | string[],
-  ignoreErrors: boolean = true,
-) {
-  const ids = Array.isArray(id) ? id : [id];
-  try {
-    await spawn('docker', ['container', 'stop', ...ids]);
-  } catch (e) {
-    if (!ignoreErrors) {
-      throw new Error(`Failed to stop container(s): ${e.message}`);
+export async function dockerContainerStop(id, ignoreErrors = true) {
+    const ids = Array.isArray(id) ? id : [id];
+    try {
+        await spawn('docker', ['container', 'stop', ...ids]);
     }
-  }
-}
-
-export async function dockerContainerKill(
-  id: string | string[],
-  ignoreErrors: boolean = true,
-) {
-  const ids = Array.isArray(id) ? id : [id];
-  try {
-    await spawn('docker', ['container', 'kill', ...ids]);
-  } catch (e) {
-    if (!ignoreErrors) {
-      throw new Error(`Failed to kill container(s): ${e.message}`);
+    catch (e) {
+        if (!ignoreErrors) {
+            throw new Error(`Failed to stop container(s): ${e.message}`);
+        }
     }
-  }
 }
-
-export async function dockerTryStopContainer(id: ?string, name?: string = '') {
-  if (id) {
+export async function dockerContainerKill(id, ignoreErrors = true) {
+    const ids = Array.isArray(id) ? id : [id];
     try {
-      await dockerContainerStop(id, false);
-    } catch (e) {
-      buildLog(`Failed to stop ${name} container: ${e.message}`);
+        await spawn('docker', ['container', 'kill', ...ids]);
+    }
+    catch (e) {
+        if (!ignoreErrors) {
+            throw new Error(`Failed to kill container(s): ${e.message}`);
+        }
     }
-  }
 }
-
-export async function dockerContainerRm(
-  id: string | string[],
-  ignoreErrors: boolean = true,
-) {
-  const ids = Array.isArray(id) ? id : [id];
-  try {
-    await spawn('docker', ['container', 'rm', ...ids]);
-  } catch (e) {
-    if (ignoreErrors) {
-      buildLog(
-        `Warning (ignored Error): Failed to remove container(s): ${e.message}`,
-      );
-    } else {
-      throw new Error(`Failed to remove container(s): ${e.message}`);
+export async function dockerTryStopContainer(id, name = '') {
+    if (id) {
+        try {
+            await dockerContainerStop(id, false);
+        }
+        catch (e) {
+            buildLog(`Failed to stop ${name} container: ${e.message}`);
+        }
     }
-  }
 }
-
-export async function dockerContainerRestart(id: string | string[]) {
-  const ids = Array.isArray(id) ? id : [id];
-  await spawn('docker', ['container', 'restart', ...ids]);
+export async function dockerContainerRm(id, ignoreErrors = true) {
+    const ids = Array.isArray(id) ? id : [id];
+    try {
+        await spawn('docker', ['container', 'rm', ...ids]);
+    }
+    catch (e) {
+        if (ignoreErrors) {
+            buildLog(`Warning (ignored Error): Failed to remove container(s): ${e.message}`);
+        }
+        else {
+            throw new Error(`Failed to remove container(s): ${e.message}`);
+        }
+    }
+}
+export async function dockerContainerRestart(id) {
+    const ids = Array.isArray(id) ? id : [id];
+    await spawn('docker', ['container', 'restart', ...ids]);
 }
-
-export async function dockerContainerStart(id: string | string[]) {
-  const ids = Array.isArray(id) ? id : [id];
-  await spawn('docker', ['container', 'start', ...ids]);
+export async function dockerContainerStart(id) {
+    const ids = Array.isArray(id) ? id : [id];
+    await spawn('docker', ['container', 'start', ...ids]);
 }
-
-export async function _dockerContainerInspect(
-  id: string | string[],
-): Promise<DockerContainerInspectOutput[]> {
-  const ids = Array.isArray(id) ? id : [id];
-  return (
-    (
-      await spawn(
-        'docker',
-        ['container', 'inspect', '--format', '{{json .}}', ...ids],
-        { captureOutput: true },
-      )
-    )
-      .split('\n')
-      .filter((line) => !!line.trim())
-      .map((line) => JSON.parse(line.trim())) || []
-  );
+export async function unthrottledDockerContainerInspect(id) {
+    const ids = Array.isArray(id) ? id : [id];
+    return ((await spawn('docker', ['container', 'inspect', '--format', '{{json .}}', ...ids], { captureOutput: true })).output
+        .split('\n')
+        .filter((line) => !!line.trim())
+        .map((line) => JSON.parse(line.trim())) || []);
 }
-export const dockerContainerInspect: (
-  string | string[],
-) => Promise<DockerContainerInspectOutput[]> = throttle(
-  _dockerContainerInspect,
-  500,
-  {
+export const dockerContainerInspect = throttle(unthrottledDockerContainerInspect, 500, {
     trailing: false,
-  },
-);
-
-type DockerContainerRunDaemonArgs = {|
-  image: string,
-  runArgs?: string[],
-  cmd?: string[],
-  waitAttempts?: number,
-  waitDuration?: number,
-|};
-
-type DockerContainerRunArgs = {|
-  ...DockerContainerRunDaemonArgs,
-  spawnOptions?: ?SpawnOptions,
-|};
-
-export async function dockerContainerRun({
-  image,
-  runArgs = [],
-  cmd = [],
-  spawnOptions,
-}: DockerContainerRunArgs): Promise<string> {
-  return spawn('docker', ['container', 'run', ...runArgs, image, ...cmd], {
-    stdio: 'inherit',
-    pipeOutput: true,
-    ...spawnOptions,
-  });
+});
+export async function dockerContainerRun({ image, runArgs = [], cmd = [], spawnOptions, }) {
+    return (await spawn('docker', ['container', 'run', ...runArgs, image, ...cmd], {
+        pipeOutput: true,
+        stdio: 'inherit',
+        ...spawnOptions,
+    })).output;
 }
-
-export async function dockerContainerRunDaemon({
-  image,
-  runArgs = [],
-  cmd = [],
-  waitAttempts = 10,
-  waitDuration = 501,
-}: DockerContainerRunDaemonArgs): Promise<DockerContainer> {
-  const id = (
-    await dockerContainerRun({
-      image,
-      cmd,
-      runArgs: ['-d', ...runArgs],
-      spawnOptions: {
-        stdio: 'pipe',
-        pipeOutput: false,
-        captureOutput: true,
-      },
-    })
-  ).trim();
-  let container = await dockerContainerFind(id);
-  let attempts = 0;
-
-  // containers don't always show up in the list right away
-  /* eslint-disable no-await-in-loop */
-  while (!container && attempts < waitAttempts) {
-    await new Promise((resolve) => setTimeout(resolve, waitDuration));
-    container = await dockerContainerFind(id);
-    attempts += 1;
-  }
-  /* eslint-enable no-await-in-loop */
-
-  if (!container) {
-    throw new Error(`Failed to find newly created container: ${id}`);
-  }
-  return container;
+export async function dockerContainerRunDaemon({ image, runArgs = [], cmd = [], waitAttempts = 10, waitDuration = 501, }) {
+    const id = (await dockerContainerRun({
+        cmd,
+        image,
+        runArgs: ['-d', ...runArgs],
+        spawnOptions: {
+            captureOutput: true,
+            pipeOutput: false,
+            stdio: 'pipe',
+        },
+    })).trim();
+    let container = await dockerContainerFind(id);
+    let attempts = 0;
+    // containers don't always show up in the list right away
+    /* eslint-disable no-await-in-loop */
+    while (!container && attempts < waitAttempts) {
+        await new Promise((resolve) => {
+            setTimeout(resolve, waitDuration);
+        });
+        container = await dockerContainerFind(id);
+        attempts += 1;
+    }
+    /* eslint-enable no-await-in-loop */
+    if (!container) {
+        throw new Error(`Failed to find newly created container: ${id}`);
+    }
+    return container;
 }
-
 const indicators = ['.', ':', '*', '+', '-', '=', '%', '$', '@', '^', '&'];
 let curIndicator = 0;
-
 /**
  * Waits for the given container to be fully started. Checks that the container is
  * running, and test with the provided testFn every second until it returns true.
@@ -348,42 +215,33 @@ let curIndicator = 0;
  * @param {number} timeoutMs The amount of time to wait between attempts.
  * @param {number} maxAttempts The maximum number of attempts before giving up (rejects promise)
  */
-export const dockerContainerWaitForStart = async (
-  container: DockerContainer,
-  testFn: (DockerContainer) => Promise<boolean>,
-  timeoutMs?: number = 1000,
-  maxAttempts?: number = 1200,
-) => {
-  // claim an indicator
-  const indicator = indicators[curIndicator] || '.';
-  curIndicator = (curIndicator + 1) % indicators.length;
-
-  const { name } = container;
-  buildLog(`Waiting for ${name} to fully start... ${indicator}`);
-  await new Promise((resolve, reject) => {
-    const check = (tries = 0) => {
-      process.stdout.write(indicator);
-      setTimeout(async () => {
-        try {
-          if (!(await container.isRunning())) {
-            return reject(
-              new Error(`The '${name}' container is no longer running.`),
-            );
-          }
-          if (await testFn(container)) {
-            return resolve();
-          }
-        } catch (err) {
-          // ignore
-        }
-        return tries < maxAttempts
-          ? check(tries + 1)
-          : reject(
-              new Error(`Timeout waiting for '${name}' container to start.`),
-            );
-      }, timeoutMs);
-    };
-    check();
-  });
-  process.stdout.write('\n');
+export const dockerContainerWaitForStart = async (container, testFn, timeoutMs = 1000, maxAttempts = 1200) => {
+    // claim an indicator
+    const indicator = indicators[curIndicator] || '.';
+    curIndicator = (curIndicator + 1) % indicators.length;
+    const { name } = container;
+    buildLog(`Waiting for ${name} to fully start... ${indicator}`);
+    await new Promise((resolve, reject) => {
+        const check = (tries = 0) => {
+            process.stdout.write(indicator);
+            setTimeout(async () => {
+                try {
+                    if (!(await container.isRunning())) {
+                        return reject(new Error(`The '${name}' container is no longer running.`));
+                    }
+                    if (await testFn(container)) {
+                        return resolve();
+                    }
+                }
+                catch (err) {
+                    // ignore
+                }
+                return tries < maxAttempts
+                    ? check(tries + 1)
+                    : reject(new Error(`Timeout waiting for '${name}' container to start.`));
+            }, timeoutMs);
+        };
+        check();
+    });
+    process.stdout.write('\n');
 };

package/src/docker.d.ts

@@ -0,0 +1,68 @@
+export interface DockerConfig {
+    name?: string;
+    registry?: string;
+    repository?: string;
+}
+export declare function getDockerConfig(): DockerConfig;
+export declare const parseDockerDate: (date: string) => Date;
+export declare function dockerBuild(tags?: string[], buildArgs?: string[], target?: string | null, extraArgs?: string[], repo?: string, dockerFile?: string, workDir?: string): Promise<string>;
+export declare function dockerTag(imageId: string, tags?: string[], repo?: string): Promise<void>;
+/**
+ * Apply the standard convention for tagging the docker image for the project,
+ * based on the source control branch being built.
+ * For releases, applies `latest`, `M.m.p`, `M.m`, `M`
+ * For release candidates, applies `latest-rc`
+ * For feature branches, applies `latest-feature`
+ * For development branch, applies `latest-dev`
+ * All other branches, no tag is applies
+ * @param {string} imageId id of the docker image to which to apply the tags
+ * @param {string} repo optional override of the docker repo url to use (derived from package.json by default)
+ */
+export declare function dockerTagVersion(imageId: string, repo?: string): Promise<void>;
+export interface DockerImage {
+    created: Date;
+    digest: string;
+    id: string;
+    repository: string;
+    size: number;
+    tag: string;
+}
+export declare type DockerImageFilter = (i: DockerImage) => boolean;
+export declare function dockerImages(repo?: null | string, filter?: null | DockerImageFilter): Promise<DockerImage[]>;
+export declare function getDockerId(tag?: string, repo?: null | string): Promise<string>;
+export declare function getUntaggedDockerIds(repo?: string, filter?: null | DockerImageFilter): Promise<string[]>;
+export declare function getDockerTags(id?: null | string, repo?: null | string, fullName?: boolean, filter?: null | DockerImageFilter): Promise<string[]>;
+export declare function getDockerDigest(imageId: string, repo?: string): Promise<string>;
+interface DockerLoginOptions {
+    password?: string;
+    registry?: string;
+    user?: string;
+}
+export declare function dockerLogin({ password, registry, user, }?: DockerLoginOptions): Promise<void>;
+export declare function dockerPush(tags?: string[], repo?: string): Promise<void>;
+export interface DockerPullOptions {
+    image: string;
+    offline?: boolean;
+    testUrl?: string | null;
+}
+export declare function dockerPull({ image, offline, testUrl, }: DockerPullOptions): Promise<void>;
+export declare function dockerRmi(images?: string[], ignoreErrors?: boolean): Promise<void>;
+export declare function getDockerRepo(): string;
+export interface PullAndRunContainerOptions extends DockerPullOptions {
+    alias?: string | null;
+    cmd?: string[];
+    network?: string | null;
+    runArgs?: string[];
+}
+export declare function dockerPullAndRunContainer(options: PullAndRunContainerOptions): Promise<string>;
+export interface CopyFilePathConfig {
+    from: string;
+    to: string;
+}
+export interface CopyFilesFromDockerImageConfig {
+    filePaths: CopyFilePathConfig[];
+    ignoreErrors?: boolean;
+    imageId: string;
+}
+export declare function copyFilesFromDockerImage({ filePaths, ignoreErrors, imageId, }: CopyFilesFromDockerImageConfig): Promise<any>;
+export {};