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

package/src/docker.js

@@ -1,66 +1,35 @@
-// @flow
-import path from 'path';
 import bytes from 'bytes';
 import isReachable from 'is-reachable';
 import moment from 'moment';
-import { buildLog } from './run';
-import { getCfg, getPkgName, getPkgScope } from './pkg';
-import { spawn } from './cp';
-import { getVersion, getDevBranch } from './version';
-import {
-  dockerContainerRunDaemon,
-  dockerContainerKill,
-} from './docker.container';
-import { dockerNetworkConnect } from './docker.network';
-
-export type DockerConfig = {
-  registry?: string,
-  repository?: string,
-  name?: string,
-};
-
-export function getDockerConfig(): DockerConfig {
-  return getCfg().docker || {};
-}
-
-export const parseDockerDate = (date: string): Date =>
-  moment(date, 'YYYY-MM-DD HH:mm:ss ZZ').toDate();
-
-export async function dockerBuild(
-  tags: string[] = ['latest'],
-  buildArgs: string[] = [],
-  target: ?string = null,
-  extraArgs?: ?(string[]) = [],
-  repo: string = getDockerRepo(),
-  dockerFile: string = './Dockerfile',
-  workDir: string = '.',
-): Promise<string> {
-  const args = [
-    'build',
-    ...['-f', path.resolve(dockerFile)],
-    ...(target ? ['--target', target] : []),
-    ...tags.reduce((ar, t) => [...ar, '-t', `${repo}:${t}`], []),
-    ...buildArgs.reduce((ar, a) => [...ar, '--build-arg', a], []),
-    ...(extraArgs || []),
-    path.resolve(workDir),
-  ];
-
-  return spawn('docker', args, { stdio: 'inherit' });
-}
-
-export async function dockerTag(
-  imageId: string,
-  tags: string[] = ['latest'],
-  repo?: string = getDockerRepo(),
-): Promise<void> {
-  await Promise.all(
-    tags.map(async (t) => {
-      await spawn('docker', ['tag', imageId, `${repo}:${t}`]);
-      buildLog(`Tagged image ${imageId} as ${repo}:${t}`);
-    }),
-  );
+import path from 'path';
+import { spawn } from './cp.js';
+import { dockerContainerKill, dockerContainerRunDaemon, } from './docker.container.js';
+import { dockerNetworkConnect } from './docker.network.js';
+import { getCfg, getPkgName, getPkgScope } from './pkg.js';
+import { buildLog } from './run.js';
+import { getDevBranch, getVersion } from './version.js';
+export function getDockerConfig() {
+    return getCfg().docker || {};
+}
+export const parseDockerDate = (date) => moment(date, 'YYYY-MM-DD HH:mm:ss ZZ').toDate();
+export async function dockerBuild(tags = ['latest'], buildArgs = [], target = null, extraArgs = [], repo = getDockerRepo(), dockerFile = './Dockerfile', workDir = '.') {
+    const args = [
+        'build',
+        ...['-f', path.resolve(dockerFile)],
+        ...(target ? ['--target', target] : []),
+        ...tags.reduce((ar, t) => [...ar, '-t', `${repo}:${t}`], []),
+        ...buildArgs.reduce((ar, a) => [...ar, '--build-arg', a], []),
+        ...(extraArgs || []),
+        path.resolve(workDir),
+    ];
+    return (await spawn('docker', args, { stdio: 'inherit' })).output;
+}
+export async function dockerTag(imageId, tags = ['latest'], repo = getDockerRepo()) {
+    await Promise.all(tags.map(async (t) => {
+        await spawn('docker', ['tag', imageId, `${repo}:${t}`]);
+        buildLog(`Tagged image ${imageId} as ${repo}:${t}`);
+    }));
 }
-
 /**
  * Apply the standard convention for tagging the docker image for the project,
  * based on the source control branch being built.
@@ -72,293 +41,148 @@ export async function dockerTag(
  * @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 async function dockerTagVersion(
-  imageId: string,
-  repo?: string = getDockerRepo(),
-) {
-  const { isRelease, major, minor, patch, branch } = await getVersion();
-  // determine what tags to apply
-  if (isRelease) {
-    await dockerTag(
-      imageId,
-      ['latest', `${major}`, `${major}.${minor}`, `${major}.${minor}.${patch}`],
-      repo,
-    );
-  } else if (branch === (await getDevBranch())) {
-    await dockerTag(imageId, ['latest-dev'], repo);
-  } else if (branch.match(/^(release|patch)-/)) {
-    await dockerTag(imageId, ['latest-rc'], repo);
-  } else if (branch.match(/^feature-/)) {
-    await dockerTag(imageId, ['latest-feature'], repo);
-  }
+export async function dockerTagVersion(imageId, repo = getDockerRepo()) {
+    const { branch, isRelease, major, minor, patch } = await getVersion();
+    // determine what tags to apply
+    if (isRelease) {
+        await dockerTag(imageId, ['latest', `${major}`, `${major}.${minor}`, `${major}.${minor}.${patch}`], repo);
+    }
+    else if (branch === (await getDevBranch())) {
+        await dockerTag(imageId, ['latest-dev'], repo);
+    }
+    else if (branch.match(/^(release|patch)-/)) {
+        await dockerTag(imageId, ['latest-rc'], repo);
+    }
+    else if (branch.match(/^feature-/)) {
+        await dockerTag(imageId, ['latest-feature'], repo);
+    }
 }
-
-export type DockerImage = {
-  repository: string,
-  tag: string,
-  id: string,
-  digest: string,
-  created: Date,
-  size: number,
-};
-
-export type DockerImageFilter = (i: DockerImage) => boolean;
-
-export async function dockerImages(
-  repo?: ?string = getDockerRepo(),
-  filter?: ?DockerImageFilter = null,
-): Promise<DockerImage[]> {
-  return (
-    await spawn(
-      'docker',
-      ['images', '--format', `{{json .}}`, ...(repo ? [repo] : [])],
-      { captureOutput: true },
-    )
-  )
-    .split('\n')
-    .filter((line) => !!line.trim())
-    .map((l) => {
-      const {
-        Repository: repository,
-        Tag: tag,
-        ID: id,
-        Digest: digest,
-        CreatedAt,
-        Size,
-      } = JSON.parse(l.trim());
-      return {
-        repository,
-        tag,
-        id,
-        digest,
-        created: parseDockerDate(CreatedAt),
-        size: bytes.parse(Size),
-      };
+export async function dockerImages(repo = getDockerRepo(), filter = null) {
+    return (await spawn('docker', ['images', '--format', `{{json .}}`, ...(repo ? [repo] : [])], { captureOutput: true })).output
+        .split('\n')
+        .filter((line) => !!line.trim())
+        .map((l) => {
+        const { CreatedAt, Digest: digest, ID: id, Repository: repository, Size, Tag: tag, } = JSON.parse(l.trim());
+        return {
+            created: parseDockerDate(CreatedAt),
+            digest,
+            id,
+            repository,
+            size: bytes.parse(Size),
+            tag,
+        };
     })
-    .filter(
-      (m) =>
-        (m && m.id) != null &&
-        (typeof filter === 'function' ? filter(m) : true),
-    );
-}
-
-export async function getDockerId(
-  tag: string = 'latest',
-  repo?: ?string,
-): Promise<string> {
-  return (await dockerImages(repo, (m) => m.tag === tag)).map((m) => m.id)[0];
-}
-
-export async function getUntaggedDockerIds(
-  repo?: ?string,
-  filter?: ?DockerImageFilter = null,
-): Promise<string[]> {
-  return (
-    await dockerImages(
-      repo,
-      (m) =>
-        m.tag === '<none>' && (typeof filter === 'function' ? filter(m) : true),
-    )
-  ).map((m) => m.id);
-}
-
-export async function getDockerTags(
-  id?: ?string,
-  repo?: ?string,
-  fullName: boolean = false,
-  filter?: ?DockerImageFilter = null,
-): Promise<string[]> {
-  return (
-    await dockerImages(
-      repo,
-      (m) =>
-        (!id || m.id === id) &&
-        (typeof filter === 'function' ? filter(m) : true),
-    )
-  ).map((m) => (fullName ? `${m.repository}:${m.tag}` : m.tag));
-}
-
-export async function getDockerDigest(
-  imageId: string,
-  repo?: string,
-): Promise<string> {
-  return (await dockerImages(repo, (m) => m.id === imageId)).map(
-    (m) => m.digest,
-  )[0];
-}
-
-export async function dockerLogin(
-  user: string,
-  password: string,
-  registry: string,
-): Promise<void> {
-  const reg = registry || getDockerConfig().registry;
-  await spawn(
-    'docker',
-    [
-      'login',
-      '-u',
-      user || process.env.ARTIFACTORY_USER || '',
-      '-p',
-      password || process.env.ARTIFACTORY_PASSWORD || '',
-      ...(reg ? [reg] : []),
-    ],
-    { stdio: 'inherit' },
-  );
-}
-
-export async function dockerPush(
-  tags?: string[] = ['latest'],
-  repo?: string = getDockerRepo(),
-) {
-  // do this sequentially, so you don't push the same image simultaneously
-  await tags.reduce(async (prev, tag) => {
-    await prev;
-    await spawn('docker', ['push', `${repo}:${tag}`], { stdio: 'inherit' });
-  }, Promise.resolve());
-}
-
-export type DockerPullOptions = {
-  image: string,
-  offline?: boolean,
-  testUrl?: ?string,
-};
-
-export async function dockerPull({
-  image,
-  offline = process.argv.includes('--offline'),
-  testUrl,
-}: DockerPullOptions) {
-  if (offline || !(await isReachable(testUrl || 'https://hub.docker.com'))) {
-    if (offline === false) {
-      throw new Error('Offline, cannot docker pull');
+        .filter((m) => (m && m.id) != null &&
+        (typeof filter === 'function' ? filter(m) : true));
+}
+export async function getDockerId(tag = 'latest', repo = null) {
+    return (await dockerImages(repo, (m) => m.tag === tag)).map((m) => m.id)[0];
+}
+export async function getUntaggedDockerIds(repo, filter = null) {
+    return (await dockerImages(repo, (m) => m.tag === '<none>' && (typeof filter === 'function' ? filter(m) : true))).map((m) => m.id);
+}
+export async function getDockerTags(id, repo, fullName = false, filter = null) {
+    return (await dockerImages(repo, (m) => (!id || m.id === id) &&
+        (typeof filter === 'function' ? filter(m) : true))).map((m) => (fullName ? `${m.repository}:${m.tag}` : m.tag));
+}
+export async function getDockerDigest(imageId, repo) {
+    return (await dockerImages(repo, (m) => m.id === imageId)).map((m) => m.digest)[0];
+}
+export async function dockerLogin({ password = process.env.DOCKER_PASSWORD, registry = process.env.DOCKER_REGISTRY, user = process.env.DOCKER_PASSWORD, } = {}) {
+    const reg = registry || getDockerConfig().registry;
+    await spawn('docker', ['login', '-u', user || '', '-p', password || '', ...(reg ? [reg] : [])], { stdio: 'inherit' });
+}
+export async function dockerPush(tags = ['latest'], repo = getDockerRepo()) {
+    // do this sequentially, so you don't push the same image simultaneously
+    await tags.reduce(async (prev, tag) => {
+        await prev;
+        await spawn('docker', ['push', `${repo}:${tag}`], { stdio: 'inherit' });
+    }, Promise.resolve());
+}
+export async function dockerPull({ image, offline = process.argv.includes('--offline'), testUrl, }) {
+    if (offline || !(await isReachable(testUrl || 'https://hub.docker.com'))) {
+        if (offline === false) {
+            throw new Error('Offline, cannot docker pull');
+        }
+        buildLog('It looks like you are offline, skipping docker pull');
+    }
+    else {
+        // throws on failure
+        await spawn('docker', ['pull', image], { stdio: 'inherit' });
     }
-    buildLog('It looks like you are offline, skipping docker pull');
-  } else {
-    // throws on failure
-    await spawn('docker', ['pull', image], { stdio: 'inherit' });
-  }
-}
-
-export async function dockerRmi(
-  images: string[] = [],
-  ignoreErrors: boolean = true,
-): Promise<void> {
-  // must do these sequentially, or they will interfere with each other
-  await images.reduce(async (prev, image) => {
-    await prev;
-    await spawn('docker', ['rmi', image], { stdio: 'inherit' }).catch((err) => {
-      if (ignoreErrors) {
-        buildLog(
-          `Warning (ignored Error): Failed to rm image(s): ${err.message}`,
-        );
-      } else {
-        throw err;
-      }
-    });
-  }, Promise.resolve());
 }
-
-export function getDockerRepo(): string {
-  const { registry, repository: dkrRepo, name: dkrName } = getDockerConfig();
-  const repository = dkrRepo || getPkgScope();
-  const name = dkrName || getPkgName(false);
-  if (!repository || !name) {
-    throw new Error(
-      'Docker configuration is missing or incomplete in package.json',
-    );
-  }
-  return `${registry ? `${registry}/` : ''}${repository}/${name}`;
+export async function dockerRmi(images = [], ignoreErrors = true) {
+    // must do these sequentially, or they will interfere with each other
+    await images.reduce(async (prev, image) => {
+        await prev;
+        await spawn('docker', ['rmi', image], { stdio: 'inherit' }).catch((err) => {
+            if (ignoreErrors) {
+                buildLog(`Warning (ignored Error): Failed to rm image(s): ${err.message}`);
+            }
+            else {
+                throw err;
+            }
+        });
+    }, Promise.resolve());
+}
+export function getDockerRepo() {
+    const { name: dkrName, registry, repository: dkrRepo } = getDockerConfig();
+    const repository = dkrRepo || getPkgScope();
+    const name = dkrName || getPkgName(false);
+    if (!repository || !name) {
+        throw new Error('Docker configuration is missing or incomplete in package.json');
+    }
+    return `${registry ? `${registry}/` : ''}${repository}/${name}`;
 }
-
-export type PullAndRunContainerOptions = {
-  ...DockerPullOptions,
-  runArgs?: string[],
-  cmd?: string[],
-  network?: ?string,
-  alias?: ?string,
-};
-
-export async function dockerPullAndRunContainer(
-  image: string,
-  options: PullAndRunContainerOptions = {},
-): Promise<string> {
-  const {
-    runArgs = [],
-    cmd = [],
-    network,
-    alias,
-    offline = process.argv.includes('--offline'),
-    testUrl,
-  } = options;
-
-  try {
-    await dockerPull({ image, offline, testUrl });
-  } catch (err) {
-    buildLog(`docker pull failed (${err.message}), attempting to continue...`);
-  }
-  const { id } = await dockerContainerRunDaemon({ image, runArgs, cmd });
-  if (network) {
-    await dockerNetworkConnect(network, id, alias);
-  }
-  return id;
+export async function dockerPullAndRunContainer(options) {
+    const { image, runArgs = [], cmd = [], network, alias, offline = process.argv.includes('--offline'), testUrl, } = options;
+    try {
+        await dockerPull({ image, offline, testUrl });
+    }
+    catch (err) {
+        buildLog(`docker pull failed (${err.message}), attempting to continue...`);
+    }
+    const { id } = await dockerContainerRunDaemon({ cmd, image, runArgs });
+    if (network) {
+        await dockerNetworkConnect(network, id, alias);
+    }
+    return id;
 }
-
-export type CopyFilePathConfig = {
-  from: string,
-  to: string,
-};
-
-export type CopyFilesFromDockerImageConfig = {
-  imageId: string,
-  filePaths: CopyFilePathConfig[],
-  ignoreErrors?: ?boolean,
-};
-
-export async function copyFilesFromDockerImage({
-  imageId,
-  filePaths,
-  ignoreErrors,
-}: CopyFilesFromDockerImageConfig): Promise<any> {
-  const container = await dockerContainerRunDaemon({
-    image: imageId,
-    runArgs: ['-it', '--rm', '--entrypoint=/bin/bash'],
-    cmd: ['read', '-p', 'pause'],
-  });
-
-  buildLog(`Copying Files from Docker Image - imageId (${imageId})`);
-
-  const spawnOptions = {
-    stdio: 'inherit',
-    pipeOutput: true,
-    captureOutput: false,
-  };
-  const copyErrors = [];
-
-  try {
-    filePaths.forEach(async (fp) => {
-      // Try to copy from the Debug Folder
-      try {
-        await spawn(
-          'docker',
-          ['cp', `${container.id}:${fp.from}`, fp.to],
-          spawnOptions,
-        );
-        buildLog(`Copied ${fp.from} => ${fp.to}`);
-      } catch (error) {
-        copyErrors.push(error);
-        buildLog(`Error copying file ${fp.from}`);
-      }
+export async function copyFilesFromDockerImage({ filePaths, ignoreErrors, imageId, }) {
+    const container = await dockerContainerRunDaemon({
+        cmd: ['read', '-p', 'pause'],
+        image: imageId,
+        runArgs: ['-it', '--rm', '--entrypoint=/bin/bash'],
     });
-  } finally {
+    buildLog(`Copying Files from Docker Image - imageId (${imageId})`);
+    const spawnOptions = {
+        captureOutput: false,
+        pipeOutput: true,
+        stdio: 'inherit',
+    };
+    const copyErrors = [];
     try {
-      await dockerContainerKill(container.id);
-    } catch (error) {
-      copyErrors.push(error);
+        filePaths.forEach(async (fp) => {
+            // Try to copy from the Debug Folder
+            try {
+                await spawn('docker', ['cp', `${container.id}:${fp.from}`, fp.to], spawnOptions);
+                buildLog(`Copied ${fp.from} => ${fp.to}`);
+            }
+            catch (error) {
+                copyErrors.push(error);
+                buildLog(`Error copying file ${fp.from}`);
+            }
+        });
+    }
+    finally {
+        try {
+            await dockerContainerKill(container.id);
+        }
+        catch (error) {
+            copyErrors.push(error);
+        }
+    }
+    if (copyErrors.length > 0 && ignoreErrors !== true) {
+        throw new Error('Some files failed to copy');
     }
-  }
-
-  if (copyErrors.length > 0 && ignoreErrors !== true) {
-    throw new Error('Some files failed to copy');
-  }
 }

package/src/docker.network.d.ts

@@ -0,0 +1,42 @@
+export interface DockerNetwork {
+    IPv6: boolean;
+    created: Date;
+    driver: string;
+    exists: () => Promise<boolean>;
+    id: string;
+    labels: string[];
+    name: string;
+    rm: () => Promise<void>;
+    scope: string;
+}
+interface DockerNetworkLsOptions {
+    filter?: (network: DockerNetwork) => boolean;
+}
+export declare function unthrottledDockerNetworkLs({ filter, }?: DockerNetworkLsOptions): Promise<DockerNetwork[]>;
+export declare const dockerNetworkLs: (options?: DockerNetworkLsOptions) => Promise<DockerNetwork[]> | undefined;
+export declare function dockerNetworkFind(networkName: string, options?: DockerNetworkLsOptions): Promise<DockerNetwork | null>;
+export interface DockerNetworkCreateOptions {
+    auxAddresses?: string[];
+    driver?: string;
+    driverOpts?: Record<string, string>;
+    gateways?: string[];
+    ingress?: boolean;
+    internal?: boolean;
+    ipRange?: string;
+    ipv6?: boolean;
+    labels?: string[];
+    subnets?: string[];
+}
+export declare function dockerNetworkCreate(networkName: string, { driver, driverOpts, ipRange, gateways, subnets, auxAddresses, ingress, internal, ipv6, labels, }?: DockerNetworkCreateOptions): Promise<DockerNetwork | null>;
+/**
+ * Removes a network by id
+ * @param {string} id The id of the network
+ */
+export declare function dockerNetworkRm(id: string): Promise<void>;
+/**
+ * Removes all networks with the given name
+ * @param {string} networkName The name of the network
+ */
+export declare function dockerNetworkDelete(networkName: string): Promise<void>;
+export declare function dockerNetworkConnect(networkName: string, containerId: string, alias?: string | null): Promise<void>;
+export {};