build-strap 3.0.0-dev.42 → 4.0.0-dev.2

package/dockerCleanup.js

@@ -1,152 +1,77 @@
-"use strict";Object.defineProperty(exports, "__esModule", { value: true });exports.dockerImageCleanup = exports.dockerContainerCleanup = exports.dockerCleanup = exports.default = void 0;
-var _uniq = _interopRequireDefault(require("lodash/uniq"));
-var _docker = require("./docker");
-
-
-
-
-
-
-
-var _docker2 = require("./docker.container");
-var _run = require("./run");function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { default: obj };}
-
+import { uniq } from 'lodash-es';
+import moment from 'moment';
+import { dockerContainerLs } from './docker.container.js';
+import { dockerImages, dockerRmi, getDockerRepo, getDockerTags, getUntaggedDockerIds, } from './docker.js';
+import { buildLog } from './run.js';
 // flattens arrays of promises and/or promises for arrays
 // into a single array of (awaited) values
-const flatten = async (input) => {
-  const result = await input;
-  return Array.isArray(result) ?
-  [].concat(...(await Promise.all(result.map(flatten)))) :
-  result;
-};
-
-
-
-
-
-
-
-
-
-
+async function flatten(input) {
+    const result = await input;
+    return Array.isArray(result)
+        ? [].concat(...(await Promise.all(result.map(flatten))))
+        : result;
+}
 /**
  * Purge stopped containers
  */
-const dockerContainerCleanup = async ({
-  dryRun = process.argv.includes('--dry-run') } =
-{}) => {
-  const toClean = await (0, _docker2.dockerContainerLs)({
-    all: true,
-    filter: (c) => c.exited });
-
-  if (dryRun) {
-    (0, _run.buildLog)(
-    `Containers to delete (dry run):\n  ${toClean.
-    map((c) => c.id).
-    join('\n  ')}`);
-
-  } else {
-    await Promise.all(toClean.map(async (c) => c.rm(true)));
-  }
-};exports.dockerContainerCleanup = dockerContainerCleanup;
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+export const dockerContainerCleanup = async ({ dryRun = process.argv.includes('--dry-run'), } = {}) => {
+    const toClean = await dockerContainerLs({
+        all: true,
+        filter: (c) => c.exited,
+    });
+    if (dryRun) {
+        if (toClean) {
+            buildLog(`Containers to delete (dry run):\n  ${toClean
+                .map((c) => c.id)
+                .join('\n  ')}`);
+        }
+        else {
+            buildLog('No containers to delete (dry run)');
+        }
+    }
+    else if (toClean) {
+        await Promise.all(toClean.map(async (c) => c.rm(true)));
+    }
+};
 /**
  * Purge docker images created during build process
  */
-const dockerImageCleanup = async ({
-  repos = [(0, _docker.getDockerRepo)()],
-  buildImageIds = [],
-  images = [],
-  purgeAll = process.argv.includes('--purge-all'),
-  purgeOld = !process.argv.includes('--keep-old'),
-  dryRun = process.argv.includes('--dry-run') } =
-{}) => {
-  // only match images without a :latest tag
-  const filterLatest = (m) =>
-  purgeAll || !m.tag.match(/^latest(-\w+)?$/);
-  // only match images more than an hour old, AND without a :latest* tag
-  const filterOld = (m) =>
-  purgeAll || filterLatest(m) && m.created < Date.now() - 1000 * 60 * 60;
-
-  const uniqueList = (0, _uniq.default)([
-  // the things that we know were just built by us
-  // remove all tags from the given repos with a matching `buildImageIds`, except for :latest*
-  ...(await flatten(
-  repos.map((r) =>
-  buildImageIds.map(async (b) => (0, _docker.getDockerTags)(b, r, true, filterLatest))))),
-
-
-
-  // unconditionally delete explicitly passed images/ids
-  ...images,
-
-  // images in the given `repos` without a tag, older than 1hr
-  ...(await flatten(
-  repos.map(async (r) => (0, _docker.getUntaggedDockerIds)(r, filterOld)))),
-
-
-  // images with no repo and no tag
-  ...(
-  await (0, _docker.dockerImages)(
-  null,
-  (m) => m.repository === '<none>' && m.tag === '<none>' && filterOld(m))).
-
-  map((m) => m.id),
-
-  // any leftover tags from prior builds (only if purgeAll or purgeOld)
-  ...(purgeAll || purgeOld ?
-  await flatten(
-  repos.map(async (r) => (0, _docker.getDockerTags)(null, r, true, filterOld))) :
-
-  [])]);
-
-
-  if (dryRun) {
-    (0, _run.buildLog)(`Images to delete (dry run):\n  ${uniqueList.join('\n  ')}`);
-  } else {
-    await (0, _docker.dockerRmi)(uniqueList, true);
-  }
-};exports.dockerImageCleanup = dockerImageCleanup;
-
-
-
-
-
-
+export const dockerImageCleanup = async ({ repos = [getDockerRepo()], buildImageIds = [], images = [], purgeAll = process.argv.includes('--purge-all'), purgeOld = !process.argv.includes('--keep-old'), dryRun = process.argv.includes('--dry-run'), } = {}) => {
+    // only match images without a :latest tag
+    const filterLatest = (m) => purgeAll || !m.tag.match(/^latest(-\w+)?$/);
+    // only match images more than an hour old, AND without a :latest* tag
+    const filterOld = (m) => purgeAll ||
+        (filterLatest(m) && moment().subtract(1, 'h').isAfter(m.created));
+    const uniqueList = uniq([
+        // the things that we know were just built by us
+        // remove all tags from the given repos with a matching `buildImageIds`, except for :latest*
+        ...(await flatten(repos.map((r) => buildImageIds.map(async (b) => getDockerTags(b, r, true, filterLatest))))),
+        // unconditionally delete explicitly passed images/ids
+        ...images,
+        // images in the given `repos` without a tag, older than 1hr
+        ...(await flatten(repos.map(async (r) => getUntaggedDockerIds(r, filterOld)))),
+        // images with no repo and no tag
+        ...(await dockerImages(null, (m) => m.repository === '<none>' && m.tag === '<none>' && filterOld(m))).map((m) => m.id),
+        // any leftover tags from prior builds (only if purgeAll or purgeOld)
+        ...(purgeAll || purgeOld
+            ? await flatten(repos.map(async (r) => getDockerTags(null, r, true, filterOld)))
+            : []),
+    ]);
+    if (dryRun) {
+        buildLog(`Images to delete (dry run):\n  ${uniqueList.join('\n  ')}`);
+    }
+    else {
+        await dockerRmi(uniqueList, true);
+    }
+};
 /**
  * Purge docker images created during build process
  */
-const dockerCleanup = async ({
-  dryRun,
-  ...rest } =
-{}) => {
-  await dockerContainerCleanup({ dryRun });
-  await dockerImageCleanup({
-    dryRun,
-    ...rest });
-
-};exports.dockerCleanup = dockerCleanup;var _default =
-
-dockerCleanup;exports.default = _default;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/dockerCleanup.js"],"names":["flatten","input","result","Array","isArray","concat","Promise","all","map","dockerContainerCleanup","dryRun","process","argv","includes","toClean","filter","c","exited","id","join","rm","dockerImageCleanup","repos","buildImageIds","images","purgeAll","purgeOld","filterLatest","m","tag","match","filterOld","created","Date","now","uniqueList","r","b","repository","dockerCleanup","rest"],"mappings":"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","sourcesContent":["// @flow\nimport uniq from 'lodash/uniq';\nimport {\n  dockerImages,\n  dockerRmi,\n  getUntaggedDockerIds,\n  getDockerTags,\n  getDockerRepo,\n} from './docker';\nimport type { DockerImage, DockerImageFilter } from './docker';\nimport { dockerContainerLs } from './docker.container';\nimport { buildLog } from './run';\n\n// flattens arrays of promises and/or promises for arrays\n// into a single array of (awaited) values\nconst flatten = async (input) => {\n  const result = await input;\n  return Array.isArray(result)\n    ? [].concat(...(await Promise.all(result.map(flatten))))\n    : result;\n};\n\ntype CommonDockerCleanupOptions = {|\n  /** print matched items to console instead of deleting */\n  dryRun?: boolean,\n|};\n\ntype DockerContainerCleanupOptions = {|\n  ...CommonDockerCleanupOptions,\n|};\n\n/**\n * Purge stopped containers\n */\nexport const dockerContainerCleanup = async ({\n  dryRun = process.argv.includes('--dry-run'),\n}: DockerContainerCleanupOptions = {}) => {\n  const toClean = await dockerContainerLs({\n    all: true,\n    filter: (c) => c.exited,\n  });\n  if (dryRun) {\n    buildLog(\n      `Containers to delete (dry run):\\n  ${toClean\n        .map((c) => c.id)\n        .join('\\n  ')}`,\n    );\n  } else {\n    await Promise.all(toClean.map(async (c) => c.rm(true)));\n  }\n};\n\ntype DockerImageCleanupOptions = {|\n  ...CommonDockerCleanupOptions,\n  /** Image repositories to clean (defaults to the one configured in package.json) */\n  repos?: string[],\n  /** Image ids known to be produced by this build */\n  buildImageIds?: string[],\n  /** Explicit image names/ids to delete unconditionally */\n  images?: string[],\n  /**\n   * ignore default exclusions of :latest* and images < 1hr old\n   * this will delete all images in the given repos\n   */\n  purgeAll?: boolean,\n  /**\n   * looks for other builds of the same repos\n   * this will still exclude :latest* and images < 1hr old\n   * useful to clean up after past builds that failed to clean themselves properly\n   */\n  purgeOld?: boolean,\n|};\n\n/**\n * Purge docker images created during build process\n */\nexport const dockerImageCleanup = async ({\n  repos = [getDockerRepo()],\n  buildImageIds = [],\n  images = [],\n  purgeAll = process.argv.includes('--purge-all'),\n  purgeOld = !process.argv.includes('--keep-old'),\n  dryRun = process.argv.includes('--dry-run'),\n}: DockerImageCleanupOptions = {}) => {\n  // only match images without a :latest tag\n  const filterLatest: DockerImageFilter = (m: DockerImage) =>\n    purgeAll || !m.tag.match(/^latest(-\\w+)?$/);\n  // only match images more than an hour old, AND without a :latest* tag\n  const filterOld: DockerImageFilter = (m: DockerImage) =>\n    purgeAll || (filterLatest(m) && m.created < Date.now() - 1000 * 60 * 60);\n\n  const uniqueList = uniq([\n    // the things that we know were just built by us\n    // remove all tags from the given repos with a matching `buildImageIds`, except for :latest*\n    ...(await flatten(\n      repos.map((r) =>\n        buildImageIds.map(async (b) => getDockerTags(b, r, true, filterLatest)),\n      ),\n    )),\n\n    // unconditionally delete explicitly passed images/ids\n    ...images,\n\n    // images in the given `repos` without a tag, older than 1hr\n    ...(await flatten(\n      repos.map(async (r) => getUntaggedDockerIds(r, filterOld)),\n    )),\n\n    // images with no repo and no tag\n    ...(\n      await dockerImages(\n        null,\n        (m) => m.repository === '<none>' && m.tag === '<none>' && filterOld(m),\n      )\n    ).map((m) => m.id),\n\n    // any leftover tags from prior builds (only if purgeAll or purgeOld)\n    ...(purgeAll || purgeOld\n      ? await flatten(\n          repos.map(async (r) => getDockerTags(null, r, true, filterOld)),\n        )\n      : []),\n  ]);\n\n  if (dryRun) {\n    buildLog(`Images to delete (dry run):\\n  ${uniqueList.join('\\n  ')}`);\n  } else {\n    await dockerRmi(uniqueList, true);\n  }\n};\n\ntype DockerCleanupOptions = {|\n  ...DockerImageCleanupOptions,\n  ...DockerContainerCleanupOptions,\n|};\n\n/**\n * Purge docker images created during build process\n */\nexport const dockerCleanup = async ({\n  dryRun,\n  ...rest\n}: DockerCleanupOptions = {}) => {\n  await dockerContainerCleanup({ dryRun });\n  await dockerImageCleanup({\n    dryRun,\n    ...rest,\n  });\n};\n\nexport default dockerCleanup;\n"]}
+export const dockerCleanup = async ({ dryRun, ...rest } = {}) => {
+    await dockerContainerCleanup({ dryRun });
+    await dockerImageCleanup({
+        dryRun,
+        ...rest,
+    });
+};
+export default dockerCleanup;

package/dockerCompose.d.ts

@@ -0,0 +1,154 @@
+import { DockerContainer } from './docker.container.js';
+import { DockerNetwork, DockerNetworkCreateOptions } from './docker.network.js';
+import { DockerVolume, DockerVolumeCreateOptions } from './docker.volume.js';
+export declare type DockerComposeResourceTracker = {
+    cleaning: null | Promise<void>;
+    containers: Map<string, DockerContainer>;
+    networks: Map<string, DockerNetwork>;
+    services: Map<string, DockerComposeService>;
+    volumes: Map<string, DockerVolume>;
+};
+export declare const dockerComposeCreateResourceTracker: () => DockerComposeResourceTracker;
+declare type DockerComposeEnvDef = string[] | Record<string, string>;
+declare type DockerComposeULimitDef = number | {
+    hard: number;
+    soft: number;
+};
+declare type DockerComposeULimitsDef = Record<string, DockerComposeULimitDef>;
+interface DockerComposeServiceDef {
+    command?: string[];
+    container_name?: string;
+    environment?: DockerComposeEnvDef;
+    image?: string;
+    links?: string[];
+    networks?: string[];
+    ports?: string[];
+    ulimits?: DockerComposeULimitsDef;
+    volumes?: string[];
+}
+interface DockerComposeVolumeDef extends DockerVolumeCreateOptions {
+    name?: string;
+}
+interface DockerComposeNetworkDef extends DockerNetworkCreateOptions {
+    name?: string;
+}
+interface DockerCompose {
+    networks?: Record<string, DockerComposeNetworkDef>;
+    services?: Record<string, DockerComposeServiceDef>;
+    version: string;
+    volumes?: Record<string, DockerComposeVolumeDef>;
+}
+/**
+ * Parse a docker-compose.yml file into a pojo representation
+ * @param {string} filePath Path to the docker-compose.yml file
+ */
+export declare const dockerComposeParse: (filePath?: string) => Promise<DockerCompose>;
+/**
+ * Get the main docker-compose.yml from the root of the repo
+ * @param {boolean} force Force reload from file
+ */
+export declare const dockerComposeGetMain: (force?: boolean) => Promise<DockerCompose>;
+interface PortMap {
+    docker: number;
+    local: null | number;
+    localDefault: number;
+}
+interface UrlMap {
+    docker: null | string;
+    local: null | string;
+}
+interface ParsedPortInfo {
+    ports: PortMap[];
+    runArgs: string[];
+}
+interface ParsedVolumeInfo {
+    runArgs: string[];
+    volumes: string[];
+}
+interface ParsedNetworkInfo {
+    networks: string[];
+    runArgs: string[];
+}
+export declare const dockerComposeCreateNetworks: (names?: string[] | null | undefined, dockerCompose?: string | DockerCompose | null | undefined, tracker?: DockerComposeResourceTracker) => Promise<void>;
+export declare const dockerComposeCreateVolumes: (names?: string[] | undefined, dockerCompose?: string | DockerCompose | null | undefined, tracker?: DockerComposeResourceTracker) => Promise<void>;
+declare type HealthCheckFn = (result: UpResult) => Promise<void>;
+interface UpOptions {
+    avoidConflicts?: boolean;
+    cmd?: string[];
+    healthCheck?: HealthCheckFn;
+    mapPorts?: boolean;
+    mapVolumes?: boolean;
+    tracker?: DockerComposeResourceTracker;
+}
+interface ServiceNameInfo {
+    aliases: string[];
+    name: string;
+    suffix: string;
+}
+interface UpResult {
+    aliases: string[];
+    container: DockerContainer;
+    containerName: string;
+    ports: PortMap[];
+    service: DockerComposeService;
+    urls: UrlMap[];
+    volumes: string[];
+}
+export declare class DockerComposeService {
+    #private;
+    constructor(name: string, serviceDef: DockerComposeServiceDef, dockerCompose?: null | (DockerCompose | string));
+    get name(): string;
+    get serviceDef(): DockerComposeServiceDef;
+    get image(): null | string;
+    get defaultContainerName(): string;
+    get cmd(): string[];
+    get envArgs(): string[];
+    /**
+     * 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
+     */
+    getNames(avoidConflicts?: boolean, max?: number): Promise<ServiceNameInfo>;
+    getPorts(avoidConflicts?: boolean, mapLocal?: boolean): Promise<ParsedPortInfo>;
+    getDefaultPortInfo(): Promise<ParsedPortInfo>;
+    getDefaultPorts(): Promise<PortMap[]>;
+    getDefaultPortArgs(): Promise<string[]>;
+    getDefaultUrls(): Promise<UrlMap[]>;
+    getDefaultNetworkInfo(): Promise<ParsedNetworkInfo>;
+    getDefaultNetworks(): Promise<string[]>;
+    getDefaultNetworkArgs(): Promise<string[]>;
+    getDefaultVolumeInfo(): Promise<ParsedVolumeInfo>;
+    getDefaultVolumes(): Promise<string[]>;
+    getDefaultVolumeArgs(): Promise<string[]>;
+    pull(): Promise<void>;
+    getBaseRunArgs(): Promise<string[]>;
+    assembleRunArgs(containerName?: string, aliases?: string[], additionalArgs?: null | string[]): Promise<string[]>;
+    getRunArgs(avoidConflicts?: boolean, mapLocalPorts?: boolean): Promise<string[]>;
+    up({ healthCheck, avoidConflicts, mapVolumes, mapPorts, cmd, tracker, }?: UpOptions): Promise<UpResult>;
+    down({ includeDefaults, includeNetworks, includeVolumes, }?: {
+        includeDefaults?: boolean;
+        includeNetworks?: boolean;
+        includeVolumes?: boolean;
+    }): Promise<void>;
+    static parse(name: string, force?: boolean, dockerCompose?: null | (DockerCompose | string)): Promise<null | DockerComposeService>;
+    static getUrls(ports: PortMap[], alias: string): UrlMap[];
+}
+export declare function dockerComposeGetAllServices(dockerCompose?: null | (string | DockerCompose)): Promise<Record<string, null | DockerComposeService>>;
+export declare function dockerComposeTeardown({ includeDefaults, includeVolumes, includeNetworks, dockerCompose, tracker, }?: {
+    dockerCompose?: null | (string | DockerCompose);
+    includeDefaults?: boolean;
+    includeNetworks?: boolean;
+    includeVolumes?: boolean;
+    tracker?: DockerComposeResourceTracker;
+}): Promise<void>;
+export interface DockerContainerInfo extends UpResult {
+    dockerPort?: null | number;
+    dockerUrl?: null | string;
+    id: string;
+    image: string;
+    name?: null | string;
+    port?: null | number;
+    url?: null | string;
+}
+export declare function dockerComposeRunService(key: string, upOptions?: UpOptions, dockerCompose?: null | string | DockerCompose): Promise<DockerContainerInfo>;
+export {};