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

package/src/docker.network.js

@@ -1,159 +1,85 @@
-// @flow
-import throttle from 'lodash/throttle';
-import { spawn } from './cp';
-import { parseDockerDate } from './docker';
-
-export type DockerNetwork = {|
-  id: string,
-  name: string,
-  driver: string,
-  scope: string,
-  created: Date,
-  IPv6: boolean,
-  labels: string[],
-  exists: () => Promise<boolean>,
-  rm: () => Promise<void>,
-|};
-
-type DockerNetworkLsOptions = {
-  filter?: (network: DockerNetwork) => boolean,
-};
-
+import { throttle } from 'lodash-es';
+import { spawn } from './cp.js';
+import { parseDockerDate } from './docker.js';
 // calling this function in rapid succession can lead to errors.
 // prefer throttled version
-export async function _dockerNetworkLs({
-  filter,
-}: DockerNetworkLsOptions = {}): Promise<DockerNetwork[]> {
-  return (
-    await spawn('docker', ['network', 'ls', '--format', '{{json .}}'], {
-      captureOutput: true,
+export async function unthrottledDockerNetworkLs({ filter, } = {}) {
+    return (await spawn('docker', ['network', 'ls', '--format', '{{json .}}'], {
+        captureOutput: true,
+    })).output
+        .split('\n')
+        .filter((line) => !!line.trim())
+        .map((line) => {
+        const { CreatedAt, Driver: driver, ID: id, IPv6, Labels, Name: name, Scope: scope, } = JSON.parse(line.trim());
+        return {
+            IPv6: IPv6 === 'true',
+            created: parseDockerDate(CreatedAt),
+            driver,
+            exists: async () => !!(await dockerNetworkFind(id)),
+            id,
+            labels: Labels.split(',').map((l) => l.trim()),
+            name,
+            rm: async () => dockerNetworkRm(id),
+            scope,
+        };
     })
-  )
-    .split('\n')
-    .filter((line) => !!line.trim())
-    .map((line) => {
-      const {
-        ID: id,
-        Name: name,
-        Driver: driver,
-        Scope: scope,
-        CreatedAt,
-        IPv6,
-        Labels,
-      } = JSON.parse(line.trim());
-      return {
-        id,
-        name,
-        driver,
-        scope,
-        created: parseDockerDate(CreatedAt),
-        IPv6: IPv6 === 'true',
-        labels: Labels.split(',').map((l) => l.trim()),
-        exists: async () => !!(await dockerNetworkFind(id)),
-        rm: async () => dockerNetworkRm(id),
-      };
-    })
-    .filter((n) => n.id && (typeof filter === 'function' ? filter(n) : true));
+        .filter((n) => n.id && (typeof filter === 'function' ? filter(n) : true));
 }
-export const dockerNetworkLs: (
-  DockerNetworkLsOptions | void,
-) => Promise<DockerNetwork[]> = throttle(_dockerNetworkLs, 500, {
-  trailing: false,
+export const dockerNetworkLs = throttle(unthrottledDockerNetworkLs, 500, {
+    trailing: false,
 });
-
-export async function dockerNetworkFind(
-  networkName: string,
-  options?: DockerNetworkLsOptions,
-): Promise<?DockerNetwork> {
-  return (await dockerNetworkLs(options)).find(
-    (n) => n.name === networkName || n.id === networkName,
-  );
+export async function dockerNetworkFind(networkName, options) {
+    return ((await dockerNetworkLs(options))?.find((n) => n.name === networkName || n.id === networkName) || null);
 }
-
-export type DockerNetworkCreateOptions = {|
-  driver?: string,
-  driverOpts?: { [string]: string },
-  ipRange?: string,
-  gateways?: string[],
-  subnets?: string[],
-  auxAddresses?: string[],
-  ingress?: boolean,
-  internal?: boolean,
-  ipv6?: boolean,
-  labels?: string[],
-|};
-
-export async function dockerNetworkCreate(
-  networkName: string,
-  {
-    driver,
-    driverOpts = {},
-    ipRange,
-    gateways = [],
-    subnets = [],
-    auxAddresses = [],
-    ingress,
-    internal,
-    ipv6,
-    labels = [],
-  }: DockerNetworkCreateOptions = {},
-): Promise<?DockerNetwork> {
-  const existing = await dockerNetworkFind(networkName);
-  if (existing) return existing;
-  await spawn('docker', [
-    'network',
-    'create',
-    ...labels.flatMap((l) => ['--label', l]),
-    ...gateways.flatMap((g) => ['--gateway', g]),
-    ...subnets.flatMap((s) => ['--subnet', s]),
-    ...auxAddresses.flatMap((a) => ['--aux-address', a]),
-    ...(ipRange ? ['--ip-range', ipRange] : []),
-    ...(ingress ? ['--ingress'] : []),
-    ...(internal ? ['--internal'] : []),
-    ...(ipv6 ? ['--ipv6'] : []),
-    ...(driver ? ['-d', driver] : []),
-    ...Object.entries(driverOpts).flatMap(([k, v]) => [
-      '-o',
-      `${k}=${(v: any)}`,
-    ]),
-    networkName,
-  ]);
-  return dockerNetworkFind(networkName);
+export async function dockerNetworkCreate(networkName, { driver, driverOpts = {}, ipRange, gateways = [], subnets = [], auxAddresses = [], ingress, internal, ipv6, labels = [], } = {}) {
+    const existing = await dockerNetworkFind(networkName);
+    if (existing)
+        return existing;
+    await spawn('docker', [
+        'network',
+        'create',
+        ...labels.flatMap((l) => ['--label', l]),
+        ...gateways.flatMap((g) => ['--gateway', g]),
+        ...subnets.flatMap((s) => ['--subnet', s]),
+        ...auxAddresses.flatMap((a) => ['--aux-address', a]),
+        ...(ipRange ? ['--ip-range', ipRange] : []),
+        ...(ingress ? ['--ingress'] : []),
+        ...(internal ? ['--internal'] : []),
+        ...(ipv6 ? ['--ipv6'] : []),
+        ...(driver ? ['-d', driver] : []),
+        ...Object.entries(driverOpts).flatMap(([k, v]) => ['-o', `${k}=${v}`]),
+        networkName,
+    ]);
+    return dockerNetworkFind(networkName);
 }
-
 /**
  * Removes a network by id
  * @param {string} id The id of the network
  */
-export async function dockerNetworkRm(id: string) {
-  await spawn('docker', ['network', 'rm', id]);
+export async function dockerNetworkRm(id) {
+    await spawn('docker', ['network', 'rm', id]);
 }
-
 /**
  * Removes all networks with the given name
  * @param {string} networkName The name of the network
  */
-export async function dockerNetworkDelete(networkName: string) {
-  let existing;
-  // eslint-disable-next-line no-cond-assign, no-await-in-loop
-  while ((existing = await dockerNetworkFind(networkName))) {
-    // eslint-disable-next-line no-await-in-loop
-    await existing.rm();
-  }
+export async function dockerNetworkDelete(networkName) {
+    let existing;
+    // eslint-disable-next-line no-cond-assign, no-await-in-loop
+    while ((existing = await dockerNetworkFind(networkName))) {
+        // eslint-disable-next-line no-await-in-loop
+        await existing.rm();
+    }
 }
-
-export async function dockerNetworkConnect(
-  networkName: string,
-  containerId: string,
-  alias?: ?string,
-) {
-  const net = await dockerNetworkCreate(networkName);
-  if (!net) throw new Error('Failed to create docker network');
-  await spawn('docker', [
-    'network',
-    'connect',
-    ...(alias ? ['--alias', alias] : []),
-    net.id,
-    containerId,
-  ]);
+export async function dockerNetworkConnect(networkName, containerId, alias) {
+    const net = await dockerNetworkCreate(networkName);
+    if (!net)
+        throw new Error('Failed to create docker network');
+    await spawn('docker', [
+        'network',
+        'connect',
+        ...(alias ? ['--alias', alias] : []),
+        net.id,
+        containerId,
+    ]);
 }

package/src/docker.volume.d.ts

@@ -0,0 +1,26 @@
+declare type DockerVolumeInspectOutput = Record<string, any>;
+export interface DockerVolume {
+    driver: string;
+    inspect: () => Promise<null | DockerVolumeInspectOutput>;
+    labels: string[];
+    mountPoint: string;
+    name: string;
+    rm: () => Promise<void>;
+    scope: string;
+}
+interface DockerVolumeLsOptions {
+    filter?: (vol: DockerVolume) => boolean;
+}
+export declare function unthrottledDockerVolumeLs({ filter, }?: DockerVolumeLsOptions): Promise<DockerVolume[]>;
+export declare const dockerVolumeLs: (options?: DockerVolumeLsOptions) => undefined | Promise<DockerVolume[]>;
+export declare function dockerVolumeFind(search: string, options?: DockerVolumeLsOptions): Promise<null | DockerVolume>;
+export interface DockerVolumeCreateOptions {
+    driver?: string;
+    driverOpts?: Record<string, string>;
+    labels?: string[];
+}
+export declare function dockerVolumeCreate(name: string, { labels, driver, driverOpts }?: DockerVolumeCreateOptions): Promise<null | DockerVolume>;
+export declare function dockerVolumeRm(id: string | string[], ignoreErrors?: boolean): Promise<void>;
+export declare function unthrottledDockerVolumeInspect(id: string | string[]): Promise<DockerVolumeInspectOutput[]>;
+export declare const dockerVolumeInspect: (id: string | string[]) => undefined | Promise<DockerVolumeInspectOutput[]>;
+export {};

package/src/docker.volume.js

@@ -1,136 +1,62 @@
-// @flow
-import throttle from 'lodash/throttle';
-import { spawn } from './cp';
-
-type DockerVolumeInspectOutput = {
-  [string]: any,
-};
-
-export type DockerVolume = {|
-  name: string,
-  driver: string,
-  scope: string,
-  labels: string[],
-  mountPoint: string,
-  inspect: () => Promise<DockerVolumeInspectOutput>,
-  rm: () => Promise<void>,
-|};
-
-type DockerVolumeLsOptions = {
-  filter?: (vol: DockerVolume) => boolean,
-};
-
+import { throttle } from 'lodash-es';
+import { spawn } from './cp.js';
 // calling this function in rapid succession can lead to errors.
 // prefer throttled version
-export async function _dockerVolumeLs({
-  filter,
-}: DockerVolumeLsOptions = {}): Promise<DockerVolume[]> {
-  return (
-    await spawn('docker', ['volume', 'ls', '--format', '{{json .}}'], {
-      captureOutput: true,
+export async function unthrottledDockerVolumeLs({ filter, } = {}) {
+    return (await spawn('docker', ['volume', 'ls', '--format', '{{json .}}'], {
+        captureOutput: true,
+    })).output
+        .split('\n')
+        .filter((line) => !!line.trim())
+        .map((line) => {
+        const { Driver: driver, Labels, Mountpoint: mountPoint, Name: name, Scope: scope, } = JSON.parse(line.trim());
+        return {
+            driver,
+            inspect: async () => (await dockerVolumeInspect(name))?.[0] || null,
+            labels: Labels.split(',').map((l) => l.trim()),
+            mountPoint,
+            name,
+            rm: async () => dockerVolumeRm(name),
+            scope,
+        };
     })
-  )
-    .split('\n')
-    .filter((line) => !!line.trim())
-    .map((line) => {
-      const {
-        Name: name,
-        Driver: driver,
-        Scope: scope,
-        Labels,
-        Mountpoint: mountPoint,
-      } = JSON.parse(line.trim());
-
-      return {
-        name,
-        driver,
-        scope,
-        labels: Labels.split(',').map((l) => l.trim()),
-        mountPoint,
-        inspect: async () => (await dockerVolumeInspect(name))[0],
-        rm: async () => dockerVolumeRm(name),
-      };
-    })
-    .filter((v) => v.name && (typeof filter === 'function' ? filter(v) : true));
+        .filter((v) => v.name && (typeof filter === 'function' ? filter(v) : true));
 }
-
-export const dockerVolumeLs: (
-  DockerVolumeLsOptions | void,
-) => Promise<DockerVolume[]> = throttle(_dockerVolumeLs, 500, {
-  trailing: false,
+export const dockerVolumeLs = throttle(unthrottledDockerVolumeLs, 500, {
+    trailing: false,
 });
-
-export async function dockerVolumeFind(
-  search: string,
-  options?: DockerVolumeLsOptions,
-): Promise<?DockerVolume> {
-  return (await dockerVolumeLs(options)).find(
-    (v) => v.name === search || v.name.startsWith(search),
-  );
+export async function dockerVolumeFind(search, options) {
+    return ((await dockerVolumeLs(options))?.find((v) => v.name === search || v.name.startsWith(search)) ?? null);
 }
-
-export type DockerVolumeCreateOptions = {|
-  labels?: string[],
-  driver?: string,
-  driverOpts?: { [string]: string },
-|};
-export async function dockerVolumeCreate(
-  name: string,
-  { labels = [], driver, driverOpts = {} }: DockerVolumeCreateOptions = {},
-): Promise<?DockerVolume> {
-  const existing = await dockerVolumeFind(name);
-  if (existing) return existing;
-  await spawn('docker', [
-    'volume',
-    'create',
-    ...labels.flatMap((l) => ['--label', l]),
-    ...(driver ? ['-d', driver] : []),
-    ...Object.entries(driverOpts).flatMap(([k, v]) => [
-      '-o',
-      `${k}=${(v: any)}`,
-    ]),
-    name,
-  ]);
-  return dockerVolumeFind(name);
+export async function dockerVolumeCreate(name, { labels = [], driver, driverOpts = {} } = {}) {
+    const existing = await dockerVolumeFind(name);
+    if (existing)
+        return existing;
+    await spawn('docker', [
+        'volume',
+        'create',
+        ...labels.flatMap((l) => ['--label', l]),
+        ...(driver ? ['-d', driver] : []),
+        ...Object.entries(driverOpts).flatMap(([k, v]) => ['-o', `${k}=${v}`]),
+        name,
+    ]);
+    return dockerVolumeFind(name);
 }
-
-export async function dockerVolumeRm(
-  id: string | string[],
-  ignoreErrors: boolean = true,
-) {
-  const ids = Array.isArray(id) ? id : [id];
-  try {
-    await spawn('docker', ['volume', 'rm', ...ids]);
-  } catch (e) {
-    if (!ignoreErrors) {
-      throw new Error(`Failed to remove volume(s): ${e.message}`);
+export async function dockerVolumeRm(id, ignoreErrors = true) {
+    const ids = Array.isArray(id) ? id : [id];
+    try {
+        await spawn('docker', ['volume', 'rm', ...ids]);
+    }
+    catch (e) {
+        if (!ignoreErrors) {
+            throw new Error(`Failed to remove volume(s): ${e.message}`);
+        }
     }
-  }
 }
-
 // calling this function in rapid succession can lead to errors.
 // prefer throttled version
-export async function _dockerVolumeInspect(
-  id: string | string[],
-): Promise<DockerVolumeInspectOutput[]> {
-  const ids = Array.isArray(id) ? id : [id];
-  return (
-    JSON.parse(
-      (
-        await spawn(
-          'docker',
-          ['volume', 'inspect', '--format', '{{json .}}', ...ids],
-          { captureOutput: true },
-        )
-      ).trim(),
-    ) || []
-  );
+export async function unthrottledDockerVolumeInspect(id) {
+    const ids = Array.isArray(id) ? id : [id];
+    return (JSON.parse((await spawn('docker', ['volume', 'inspect', '--format', '{{json .}}', ...ids], { captureOutput: true })).output.trim()) || []);
 }
-
-export const dockerVolumeInspect: (
-  string | string[],
-) => Promise<DockerVolumeInspectOutput[]> = throttle(
-  _dockerVolumeInspect,
-  500,
-  { trailing: true },
-);
+export const dockerVolumeInspect = throttle(unthrottledDockerVolumeInspect, 500, { trailing: true });

package/src/dockerCleanup.d.ts

@@ -0,0 +1,38 @@
+interface CommonDockerCleanupOptions {
+    /** print matched items to console instead of deleting */
+    dryRun?: boolean;
+}
+/**
+ * Purge stopped containers
+ */
+export declare const dockerContainerCleanup: ({ dryRun, }?: CommonDockerCleanupOptions) => Promise<void>;
+interface DockerImageCleanupOptions extends CommonDockerCleanupOptions {
+    /** Image ids known to be produced by this build */
+    buildImageIds?: string[];
+    /** Explicit image names/ids to delete unconditionally */
+    images?: string[];
+    /**
+     * ignore default exclusions of :latest* and images < 1hr old
+     * this will delete all images in the given repos
+     */
+    purgeAll?: boolean;
+    /**
+     * looks for other builds of the same repos
+     * this will still exclude :latest* and images < 1hr old
+     * useful to clean up after past builds that failed to clean themselves properly
+     */
+    purgeOld?: boolean;
+    /** Image repositories to clean (defaults to the one configured in package.json) */
+    repos?: string[];
+}
+/**
+ * Purge docker images created during build process
+ */
+export declare const dockerImageCleanup: ({ repos, buildImageIds, images, purgeAll, purgeOld, dryRun, }?: DockerImageCleanupOptions) => Promise<void>;
+interface DockerCleanupOptions extends DockerImageCleanupOptions, CommonDockerCleanupOptions {
+}
+/**
+ * Purge docker images created during build process
+ */
+export declare const dockerCleanup: ({ dryRun, ...rest }?: DockerCleanupOptions) => Promise<void>;
+export default dockerCleanup;