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

package/cp.js

@@ -1,173 +1,88 @@
-"use strict";Object.defineProperty(exports, "__esModule", { value: true });exports.onKillSignal = exports.exec = void 0;exports.spawn = spawn;exports.spawnAdv = spawnAdv;
-var _child_process = _interopRequireDefault(require("child_process"));
-var _crossSpawn = _interopRequireDefault(require("cross-spawn"));
-var _run = require("./run");function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { default: obj };}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-async function spawnAdv(
-command,
-args,
-opts)
-{
-  const {
-    pipeOutput = false,
-    captureOutput = false,
-    rejectOnErrorCode = false,
-    ...options } =
-  opts || {};
-
-  return new Promise((resolve, reject) => {
-    try {
-      const toStr = () => `${command}${args ? ` ${args.join(' ')}` : ''}`;
-      const p = (0, _crossSpawn.default)(command, args, {
-        ...options,
-        // $FlowFixMe
-        ...(pipeOutput && !captureOutput && !(options && options.stdio) ?
-        { stdio: 'inherit' } :
-        {}) });
-
-
-      let output = '';
-      let stdout = '';
-      let stderr = '';
-      if (captureOutput) {
-        if (p.stdout) {
-          if (pipeOutput) {
-            p.stdout.pipe(process.stdout);
-          }
-          p.stdout.on('data', (d) => {
-            const str = d.toString();
-            stdout += str;
-            output += str;
-          });
-        } else {
-          (0, _run.buildLog)(`Warning: cannot capture stdout for \`${toStr()}\``);
+import cp from 'child_process';
+import crossSpawn from 'cross-spawn';
+import { promisify } from 'util';
+import { buildLog } from './run.js';
+export async function spawn(command, args, opts) {
+    const { captureOutput = false, pipeOutput = false, rejectOnErrorCode = true, ...options } = opts || {};
+    return new Promise((resolve, reject) => {
+        try {
+            const toStr = () => `${command}${args ? ` ${args.join(' ')}` : ''}`;
+            const p = crossSpawn(command, args, {
+                ...(pipeOutput && !captureOutput ? { stdio: 'inherit' } : {}),
+                ...options,
+            });
+            let output = '';
+            let stdout = '';
+            let stderr = '';
+            if (captureOutput) {
+                if (p.stdout) {
+                    if (pipeOutput) {
+                        p.stdout.pipe(process.stdout);
+                    }
+                    p.stdout.on('data', (d) => {
+                        const str = d.toString();
+                        stdout += str;
+                        output += str;
+                    });
+                }
+                else {
+                    buildLog(`Warning: cannot capture stdout for \`${toStr()}\``);
+                }
+                if (p.stderr) {
+                    if (pipeOutput) {
+                        p.stderr.pipe(process.stderr);
+                    }
+                    p.stderr.on('data', (d) => {
+                        const str = d.toString();
+                        stderr += str;
+                        output += str;
+                    });
+                }
+                else {
+                    buildLog(`Warning: cannot capture stderr for \`${toStr()}\``);
+                }
+            }
+            let exitHandled = false;
+            const handleExit = (code, signal) => {
+                if (!exitHandled) {
+                    if (rejectOnErrorCode && code) {
+                        reject(new Error(`${toStr()} => ${code} (error)`));
+                    }
+                    else {
+                        resolve({
+                            code,
+                            output,
+                            signal,
+                            stderr,
+                            stdout,
+                        });
+                    }
+                    exitHandled = true;
+                }
+            };
+            p.on('close', handleExit);
+            p.on('exit', handleExit);
+            // only fires if we failed to spawn
+            p.on('error', (err) => {
+                // Here we have a workaround that reverses a "feature" of cross-spawn on Windows. See:
+                // https://github.com/moxystudio/node-cross-spawn/blob/master/lib/enoent.js#L23
+                // https://github.com/moxystudio/node-cross-spawn/issues/104
+                if (process.platform === 'win32' &&
+                    err.code === 'ENOENT' &&
+                    err.errno === 'ENOENT') {
+                    handleExit(1, 'ENOENT');
+                }
+                else {
+                    reject(err);
+                }
+            });
         }
-        if (p.stderr) {
-          if (pipeOutput) {
-            p.stderr.pipe(process.stderr);
-          }
-          p.stderr.on('data', (d) => {
-            const str = d.toString();
-            stderr += str;
-            output += str;
-          });
-        } else {
-          (0, _run.buildLog)(`Warning: cannot capture stderr for \`${toStr()}\``);
+        catch (err) {
+            reject(err);
         }
-      }
-
-      let exitHandled = false;
-      const handleExit = (code, signal) => {
-        if (!exitHandled) {
-          if (rejectOnErrorCode && code) {
-            reject(new Error(`${toStr()} => ${code} (error)`));
-          } else {
-            resolve({
-              output,
-              stdout,
-              stderr,
-              code,
-              signal });
-
-          }
-          exitHandled = true;
-        }
-      };
-
-      p.on('close', handleExit);
-
-      p.on('exit', handleExit);
-
-      // only fires if we failed to spawn
-      p.on('error', (err) => {
-        // Here we have a workaround that reverses a "feature" of cross-spawn on Windows. See:
-        // https://jira.mmodal.com/browse/BTN-8
-        // https://github.com/moxystudio/node-cross-spawn/blob/master/lib/enoent.js#L23
-        // https://github.com/moxystudio/node-cross-spawn/issues/104
-        if (
-        process.platform === 'win32' &&
-        err.code === 'ENOENT' &&
-        err.errno === 'ENOENT')
-        {
-          handleExit(1, 'ENOENT');
-        } else {
-          reject(err);
-        }
-      });
-    } catch (err) {
-      reject(err);
-    }
-  });
-}
-
-// older, simpler interface that just returns a string
-async function spawn(
-command,
-args,
-opts)
-{
-  return spawnAdv(command, args, { rejectOnErrorCode: true, ...opts }).then(
-  (r) => r.output);
-
+    });
 }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-const exec = async (
-command,
-options) =>
-
-new Promise((resolve, reject) => {
-  _child_process.default.exec(command, options, (err, stdout, stderr) => {
-    if (err) {
-      reject(err);
-      return;
-    }
-
-    resolve({ stdout, stderr });
-  });
-});exports.exec = exec;
-
-const onKillSignal = (cbFn) => {
-  ['SIGINT', 'SIGTERM'].forEach((sig) => process.on(sig, cbFn));
-};exports.onKillSignal = onKillSignal;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/cp.js"],"names":["spawnAdv","command","args","opts","pipeOutput","captureOutput","rejectOnErrorCode","options","Promise","resolve","reject","toStr","join","p","stdio","output","stdout","stderr","pipe","process","on","d","str","toString","exitHandled","handleExit","code","signal","Error","err","platform","errno","spawn","then","r","exec","cp","onKillSignal","cbFn","forEach","sig"],"mappings":"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","sourcesContent":["// @flow\nimport cp from 'child_process';\nimport crossSpawn from 'cross-spawn';\nimport { buildLog } from './run';\n\nexport type NativeSpawnOptions = {|\n  cwd?: string,\n  env?: Object,\n  argv0?: string,\n  stdio?: string | Array<any>,\n  detached?: boolean,\n  uid?: number,\n  gid?: number,\n  shell?: boolean | string,\n  windowsVerbatimArguments?: boolean,\n  windowsHide?: boolean,\n|};\n\nexport type SpawnOptions = {|\n  ...NativeSpawnOptions,\n  pipeOutput?: boolean,\n  captureOutput?: boolean,\n  rejectOnErrorCode?: boolean,\n|};\n\nexport type SpawnResult = {|\n  output: string,\n  stdout: string,\n  stderr: string,\n  code: number,\n  signal: string,\n|};\n\nexport async function spawnAdv(\n  command: string,\n  args?: string[],\n  opts?: ?SpawnOptions,\n): Promise<SpawnResult> {\n  const {\n    pipeOutput = false,\n    captureOutput = false,\n    rejectOnErrorCode = false,\n    ...options\n  } = opts || {};\n\n  return new Promise((resolve, reject) => {\n    try {\n      const toStr = () => `${command}${args ? ` ${args.join(' ')}` : ''}`;\n      const p = crossSpawn(command, args, {\n        ...options,\n        // $FlowFixMe\n        ...(pipeOutput && !captureOutput && !(options && options.stdio)\n          ? { stdio: 'inherit' }\n          : {}),\n      });\n\n      let output = '';\n      let stdout = '';\n      let stderr = '';\n      if (captureOutput) {\n        if (p.stdout) {\n          if (pipeOutput) {\n            p.stdout.pipe(process.stdout);\n          }\n          p.stdout.on('data', (d) => {\n            const str = d.toString();\n            stdout += str;\n            output += str;\n          });\n        } else {\n          buildLog(`Warning: cannot capture stdout for \\`${toStr()}\\``);\n        }\n        if (p.stderr) {\n          if (pipeOutput) {\n            p.stderr.pipe(process.stderr);\n          }\n          p.stderr.on('data', (d) => {\n            const str = d.toString();\n            stderr += str;\n            output += str;\n          });\n        } else {\n          buildLog(`Warning: cannot capture stderr for \\`${toStr()}\\``);\n        }\n      }\n\n      let exitHandled = false;\n      const handleExit = (code, signal) => {\n        if (!exitHandled) {\n          if (rejectOnErrorCode && code) {\n            reject(new Error(`${toStr()} => ${code} (error)`));\n          } else {\n            resolve({\n              output,\n              stdout,\n              stderr,\n              code,\n              signal,\n            });\n          }\n          exitHandled = true;\n        }\n      };\n\n      p.on('close', handleExit);\n\n      p.on('exit', handleExit);\n\n      // only fires if we failed to spawn\n      p.on('error', (err) => {\n        // Here we have a workaround that reverses a \"feature\" of cross-spawn on Windows. See:\n        // https://jira.mmodal.com/browse/BTN-8\n        // https://github.com/moxystudio/node-cross-spawn/blob/master/lib/enoent.js#L23\n        // https://github.com/moxystudio/node-cross-spawn/issues/104\n        if (\n          process.platform === 'win32' &&\n          err.code === 'ENOENT' &&\n          err.errno === 'ENOENT'\n        ) {\n          handleExit(1, 'ENOENT');\n        } else {\n          reject(err);\n        }\n      });\n    } catch (err) {\n      reject(err);\n    }\n  });\n}\n\n// older, simpler interface that just returns a string\nexport async function spawn(\n  command: string,\n  args?: string[],\n  opts?: ?SpawnOptions,\n): Promise<string> {\n  return spawnAdv(command, args, { rejectOnErrorCode: true, ...opts }).then(\n    (r) => r.output,\n  );\n}\n\nexport type ExecOptions = {|\n  cwd?: string,\n  env?: Object,\n  encoding?: string,\n  shell?: string,\n  timeout?: number,\n  maxBuffer?: number,\n  killSignal?: string | number,\n  uid?: number,\n  gid?: number,\n  windowsHide?: boolean,\n|};\n\nexport const exec = async (\n  command: string,\n  options?: ExecOptions,\n): Promise<{ stdout: string | Buffer, stderr: string | Buffer }> =>\n  new Promise((resolve, reject) => {\n    cp.exec(command, options, (err, stdout, stderr) => {\n      if (err) {\n        reject(err);\n        return;\n      }\n\n      resolve({ stdout, stderr });\n    });\n  });\n\nexport const onKillSignal = (cbFn: () => any) => {\n  ['SIGINT', 'SIGTERM'].forEach((sig) => process.on(sig, cbFn));\n};\n"]}
+export const exec = promisify(cp.exec);
+export const onKillSignal = (cbFn) => {
+    ['SIGINT', 'SIGTERM'].forEach((sig) => process.on(sig, cbFn));
+};

package/docker.container.d.ts

@@ -0,0 +1,73 @@
+import { SpawnOptions } from './cp.js';
+interface DockerContainerInspectOutput {
+    State: {
+        Running: boolean;
+    };
+}
+interface Port {
+    dest: number;
+    iface: string;
+    src: number;
+}
+export interface DockerContainer {
+    command: string;
+    created: Date;
+    exists: () => Promise<boolean>;
+    exited: boolean;
+    id: string;
+    image: string;
+    inspect: () => Promise<DockerContainerInspectOutput | undefined>;
+    isRunning: () => Promise<boolean>;
+    kill: (ignoreError?: boolean) => Promise<void>;
+    labels: string[];
+    mounts: string[];
+    name: string;
+    names: string[];
+    networks: string[];
+    ports: Port[];
+    restart: () => Promise<void>;
+    rm: (ignoreError?: boolean) => Promise<void>;
+    runningFor: string;
+    size: number;
+    start: () => Promise<void>;
+    status: string;
+    stop: (ignoreError?: boolean) => Promise<void>;
+    teardown: (verbose?: boolean) => Promise<void>;
+}
+interface DockerContainerLsOptions {
+    all?: boolean;
+    filter?: (container: DockerContainer) => boolean;
+}
+export declare function unthrottledDockerContainerLs({ all, filter, }?: DockerContainerLsOptions): Promise<DockerContainer[]>;
+export declare const dockerContainerLs: (options: DockerContainerLsOptions | undefined) => Promise<DockerContainer[]> | undefined;
+export declare function dockerContainerFind(search: string, options?: DockerContainerLsOptions): Promise<DockerContainer | null>;
+export declare function dockerContainerStop(id: string | string[], ignoreErrors?: boolean): Promise<void>;
+export declare function dockerContainerKill(id: string | string[], ignoreErrors?: boolean): Promise<void>;
+export declare function dockerTryStopContainer(id: string | null, name?: string): Promise<void>;
+export declare function dockerContainerRm(id: string | string[], ignoreErrors?: boolean): Promise<void>;
+export declare function dockerContainerRestart(id: string | string[]): Promise<void>;
+export declare function dockerContainerStart(id: string | string[]): Promise<void>;
+export declare function unthrottledDockerContainerInspect(id: string | string[]): Promise<DockerContainerInspectOutput[]>;
+export declare const dockerContainerInspect: (id: string | string[]) => Promise<DockerContainerInspectOutput[]> | undefined;
+interface DockerContainerRunDaemonArgs {
+    cmd?: string[];
+    image: string;
+    runArgs?: string[];
+    waitAttempts?: number;
+    waitDuration?: number;
+}
+interface DockerContainerRunArgs extends DockerContainerRunDaemonArgs {
+    spawnOptions?: SpawnOptions | null;
+}
+export declare function dockerContainerRun({ image, runArgs, cmd, spawnOptions, }: DockerContainerRunArgs): Promise<string>;
+export declare function dockerContainerRunDaemon({ image, runArgs, cmd, waitAttempts, waitDuration, }: DockerContainerRunDaemonArgs): Promise<DockerContainer>;
+/**
+ * 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.
+ * @param {DockerContainer} container The container to test
+ * @param {Function} testFn A function that validates that the container is ready (e.g. by calling an API on the container)
+ * @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 declare const dockerContainerWaitForStart: (container: DockerContainer, testFn: (container: DockerContainer) => Promise<boolean>, timeoutMs?: number, maxAttempts?: number) => Promise<void>;
+export {};