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

package/src/cp.js

@@ -1,172 +1,88 @@
-// @flow
 import cp from 'child_process';
 import crossSpawn from 'cross-spawn';
-import { buildLog } from './run';
-
-export type NativeSpawnOptions = {|
-  cwd?: string,
-  env?: Object,
-  argv0?: string,
-  stdio?: string | Array<any>,
-  detached?: boolean,
-  uid?: number,
-  gid?: number,
-  shell?: boolean | string,
-  windowsVerbatimArguments?: boolean,
-  windowsHide?: boolean,
-|};
-
-export type SpawnOptions = {|
-  ...NativeSpawnOptions,
-  pipeOutput?: boolean,
-  captureOutput?: boolean,
-  rejectOnErrorCode?: boolean,
-|};
-
-export type SpawnResult = {|
-  output: string,
-  stdout: string,
-  stderr: string,
-  code: number,
-  signal: string,
-|};
-
-export async function spawnAdv(
-  command: string,
-  args?: string[],
-  opts?: ?SpawnOptions,
-): Promise<SpawnResult> {
-  const {
-    pipeOutput = false,
-    captureOutput = false,
-    rejectOnErrorCode = false,
-    ...options
-  } = opts || {};
-
-  return new Promise((resolve, reject) => {
-    try {
-      const toStr = () => `${command}${args ? ` ${args.join(' ')}` : ''}`;
-      const p = crossSpawn(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 {
-          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({
-              output,
-              stdout,
-              stderr,
-              code,
-              signal,
+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);
+                }
             });
-          }
-          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);
         }
-      });
-    } catch (err) {
-      reject(err);
-    }
-  });
-}
-
-// older, simpler interface that just returns a string
-export async function spawn(
-  command: string,
-  args?: string[],
-  opts?: ?SpawnOptions,
-): Promise<string> {
-  return spawnAdv(command, args, { rejectOnErrorCode: true, ...opts }).then(
-    (r) => r.output,
-  );
-}
-
-export type ExecOptions = {|
-  cwd?: string,
-  env?: Object,
-  encoding?: string,
-  shell?: string,
-  timeout?: number,
-  maxBuffer?: number,
-  killSignal?: string | number,
-  uid?: number,
-  gid?: number,
-  windowsHide?: boolean,
-|};
-
-export const exec = async (
-  command: string,
-  options?: ExecOptions,
-): Promise<{ stdout: string | Buffer, stderr: string | Buffer }> =>
-  new Promise((resolve, reject) => {
-    cp.exec(command, options, (err, stdout, stderr) => {
-      if (err) {
-        reject(err);
-        return;
-      }
-
-      resolve({ stdout, stderr });
     });
-  });
-
-export const onKillSignal = (cbFn: () => any) => {
-  ['SIGINT', 'SIGTERM'].forEach((sig) => process.on(sig, cbFn));
+}
+export const exec = promisify(cp.exec);
+export const onKillSignal = (cbFn) => {
+    ['SIGINT', 'SIGTERM'].forEach((sig) => process.on(sig, cbFn));
 };

package/src/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 {};