From 70bd611ee9c901247663ff09eb87c9a84ba706d0 Mon Sep 17 00:00:00 2001
From: Michael Krens <mkrens@gmail.com>
Date: Wed, 1 Jul 2020 02:39:42 +0200
Subject: [PATCH 1/9] spawn processes in detached mode to make a graceful
 shutdown on SIGINT possible

---
 src/emulator/downloadableEmulators.ts | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/emulator/downloadableEmulators.ts b/src/emulator/downloadableEmulators.ts
index 36f16ed40fa..494d7e6dc04 100644
--- a/src/emulator/downloadableEmulators.ts
+++ b/src/emulator/downloadableEmulators.ts
@@ -213,6 +213,11 @@ async function _runBinary(
     try {
       emulator.instance = childProcess.spawn(command.binary, command.args, {
         env: { ...process.env, ...extraEnv },
+        // `detached` must be true as else a SIGINT (Ctrl-c) will stop the child process before we can handle a
+        // graceful shutdown and call `downloadableEmulators.stop(...)` ourselves.
+        // Note that it seems to be a problem with gRPC processes for which a fix may be found on the Java side
+        // related to this issue: https://github.com/grpc/grpc-java/pull/6512
+        detached: true,
         stdio: ["inherit", "pipe", "pipe"],
       });
     } catch (e) {

From eb9bd3001e9563610c9676c6683e2e59a0d0008d Mon Sep 17 00:00:00 2001
From: Michael Krens <mkrens@gmail.com>
Date: Wed, 1 Jul 2020 04:25:47 +0200
Subject: [PATCH 2/9] Adds --export-on-exit flag to automatically export
 emulator data on exit

---
 src/commands/emulators-exec.ts          |   1 +
 src/commands/emulators-export.ts        |  93 +--------------
 src/commands/emulators-start.ts         |   4 +-
 src/commands/ext-dev-emulators-exec.ts  |   1 +
 src/commands/ext-dev-emulators-start.ts |   4 +-
 src/emulator/commandUtils.ts            |  81 +++++++++++--
 src/emulator/controller.ts              | 147 ++++++++++++++++++++++--
 src/emulator/pubsubEmulator.ts          |   1 +
 src/test/emulators/commandUtils.spec.ts |  52 +++++++++
 9 files changed, 269 insertions(+), 115 deletions(-)
 create mode 100644 src/test/emulators/commandUtils.spec.ts

diff --git a/src/commands/emulators-exec.ts b/src/commands/emulators-exec.ts
index 4b9c9394e23..24509f2cd66 100644
--- a/src/commands/emulators-exec.ts
+++ b/src/commands/emulators-exec.ts
@@ -9,4 +9,5 @@ module.exports = new Command("emulators:exec <script>")
   .option(commandUtils.FLAG_ONLY, commandUtils.DESC_ONLY)
   .option(commandUtils.FLAG_INSPECT_FUNCTIONS, commandUtils.DESC_INSPECT_FUNCTIONS)
   .option(commandUtils.FLAG_IMPORT, commandUtils.DESC_IMPORT)
+  .option(commandUtils.FLAG_EXPORT_ON_EXIT, commandUtils.DESC_EXPORT_ON_EXIT)
   .action(commandUtils.emulatorExec);
diff --git a/src/commands/emulators-export.ts b/src/commands/emulators-export.ts
index 63639e2382c..8bd01ab80f4 100644
--- a/src/commands/emulators-export.ts
+++ b/src/commands/emulators-export.ts
@@ -1,98 +1,9 @@
-import * as clc from "cli-color";
-import * as fs from "fs";
-import * as path from "path";
-import * as rimraf from "rimraf";
-
 import { Command } from "../command";
+import * as controller from "../emulator/controller";
 import * as commandUtils from "../emulator/commandUtils";
-import * as utils from "../utils";
-import { EmulatorHub } from "../emulator/hub";
-import { FirebaseError } from "../error";
-import { HubExport } from "../emulator/hubExport";
-import { promptOnce } from "../prompt";
-import { EmulatorHubClient } from "../emulator/hubClient";
 
 module.exports = new Command("emulators:export <path>")
   .description("export data from running emulators")
   .option(commandUtils.FLAG_ONLY, commandUtils.DESC_ONLY)
   .option("--force", "Overwrite any export data in the target directory.")
-  .action(async (exportPath: string, options: any) => {
-    const projectId = options.project;
-    if (!projectId) {
-      throw new FirebaseError(
-        "Could not determine project ID, make sure you're running in a Firebase project directory or add the --project flag.",
-        { exit: 1 }
-      );
-    }
-
-    const hubClient = new EmulatorHubClient(projectId);
-    if (!hubClient.foundHub()) {
-      throw new FirebaseError(
-        `Did not find any running emulators for project ${clc.bold(projectId)}.`,
-        { exit: 1 }
-      );
-    }
-
-    try {
-      await hubClient.getStatus();
-    } catch (e) {
-      const filePath = EmulatorHub.getLocatorFilePath(projectId);
-      throw new FirebaseError(
-        `The emulator hub for ${projectId} did not respond to a status check. If this error continues try shutting down all running emulators and deleting the file ${filePath}`,
-        { exit: 1 }
-      );
-    }
-
-    utils.logBullet(
-      `Found running emulator hub for project ${clc.bold(projectId)} at ${hubClient.origin}`
-    );
-
-    // If the export target directory does not exist, we should attempt to create it
-    const exportAbsPath = path.resolve(exportPath);
-    if (!fs.existsSync(exportAbsPath)) {
-      utils.logBullet(`Creating export directory ${exportAbsPath}`);
-      fs.mkdirSync(exportAbsPath);
-    }
-
-    // Check if there is already an export there and prompt the user about deleting it
-    const existingMetadata = HubExport.readMetadata(exportAbsPath);
-    if (existingMetadata && !options.force) {
-      if (options.noninteractive) {
-        throw new FirebaseError(
-          "Export already exists in the target directory, re-run with --force to overwrite.",
-          { exit: 1 }
-        );
-      }
-
-      const prompt = await promptOnce({
-        type: "confirm",
-        message: `The directory ${exportAbsPath} already contains export data. Exporting again to the same directory will overwrite all data. Do you want to continue?`,
-        default: false,
-      });
-
-      if (!prompt) {
-        throw new FirebaseError("Command aborted", { exit: 1 });
-      }
-    }
-
-    // Remove all existing data (metadata.json will be overwritten automatically)
-    if (existingMetadata) {
-      if (existingMetadata.firestore) {
-        const firestorePath = path.join(exportAbsPath, existingMetadata.firestore.path);
-        utils.logBullet(`Deleting directory ${firestorePath}`);
-        rimraf.sync(firestorePath);
-      }
-    }
-
-    utils.logBullet(`Exporting data to: ${exportAbsPath}`);
-    try {
-      await hubClient.postExport(exportAbsPath);
-    } catch (e) {
-      throw new FirebaseError("Export request failed, see emulator logs for more information.", {
-        exit: 1,
-        original: e,
-      });
-    }
-
-    utils.logSuccess("Export complete");
-  });
+  .action(controller.exportEmulatorData);
diff --git a/src/commands/emulators-start.ts b/src/commands/emulators-start.ts
index e00adf35edb..a0b1d110530 100644
--- a/src/commands/emulators-start.ts
+++ b/src/commands/emulators-start.ts
@@ -19,8 +19,10 @@ module.exports = new Command("emulators:start")
   .option(commandUtils.FLAG_ONLY, commandUtils.DESC_ONLY)
   .option(commandUtils.FLAG_INSPECT_FUNCTIONS, commandUtils.DESC_INSPECT_FUNCTIONS)
   .option(commandUtils.FLAG_IMPORT, commandUtils.DESC_IMPORT)
+  .option(commandUtils.FLAG_EXPORT_ON_EXIT, commandUtils.DESC_EXPORT_ON_EXIT)
   .action(async (options: any) => {
-    const killSignalPromise = commandUtils.shutdownWhenKilled();
+    options = commandUtils.setExportOnExitOptions(options);
+    const killSignalPromise = commandUtils.shutdownWhenKilled(options);
 
     try {
       await controller.startAll(options);
diff --git a/src/commands/ext-dev-emulators-exec.ts b/src/commands/ext-dev-emulators-exec.ts
index f9cef2cc5b2..2db8f64c55c 100644
--- a/src/commands/ext-dev-emulators-exec.ts
+++ b/src/commands/ext-dev-emulators-exec.ts
@@ -9,6 +9,7 @@ module.exports = new Command("ext:dev:emulators:exec <script>")
   .option(commandUtils.FLAG_TEST_CONFIG, commandUtils.DESC_TEST_CONFIG)
   .option(commandUtils.FLAG_TEST_PARAMS, commandUtils.DESC_TEST_PARAMS)
   .option(commandUtils.FLAG_IMPORT, commandUtils.DESC_IMPORT)
+  .option(commandUtils.FLAG_EXPORT_ON_EXIT, commandUtils.DESC_EXPORT_ON_EXIT)
   .action(async (script: string, options: any) => {
     const emulatorOptions = await optionsHelper.buildOptions(options);
     commandUtils.beforeEmulatorCommand(emulatorOptions);
diff --git a/src/commands/ext-dev-emulators-start.ts b/src/commands/ext-dev-emulators-start.ts
index 62fdf0b6f39..3d25415744d 100644
--- a/src/commands/ext-dev-emulators-start.ts
+++ b/src/commands/ext-dev-emulators-start.ts
@@ -11,8 +11,10 @@ module.exports = new Command("ext:dev:emulators:start")
   .option(commandUtils.FLAG_TEST_CONFIG, commandUtils.DESC_TEST_CONFIG)
   .option(commandUtils.FLAG_TEST_PARAMS, commandUtils.DESC_TEST_PARAMS)
   .option(commandUtils.FLAG_IMPORT, commandUtils.DESC_IMPORT)
+  .option(commandUtils.FLAG_EXPORT_ON_EXIT, commandUtils.DESC_EXPORT_ON_EXIT)
   .action(async (options: any) => {
-    const killSignalPromise = commandUtils.shutdownWhenKilled();
+    options = commandUtils.setExportOnExitOptions(options);
+    const killSignalPromise = commandUtils.shutdownWhenKilled(options);
 
     const emulatorOptions = await optionsHelper.buildOptions(options);
     try {
diff --git a/src/emulator/commandUtils.ts b/src/emulator/commandUtils.ts
index cd9edb49add..224eaf1c0a2 100644
--- a/src/emulator/commandUtils.ts
+++ b/src/emulator/commandUtils.ts
@@ -5,16 +5,19 @@ import * as controller from "../emulator/controller";
 import * as Config from "../config";
 import * as utils from "../utils";
 import * as logger from "../logger";
+import * as path from "path";
 import { Constants } from "./constants";
 import { requireAuth } from "../requireAuth";
 import requireConfig = require("../requireConfig");
-import { Emulators, ALL_SERVICE_EMULATORS } from "../emulator/types";
+import { Emulators, ALL_SERVICE_EMULATORS } from "./types";
 import { FirebaseError } from "../error";
-import { EmulatorRegistry } from "../emulator/registry";
-import { FirestoreEmulator } from "../emulator/firestoreEmulator";
+import { EmulatorRegistry } from "./registry";
+import { FirestoreEmulator } from "./firestoreEmulator";
 import * as getProjectId from "../getProjectId";
 import { prompt } from "../prompt";
 import { EmulatorHub } from "./hub";
+import { onExit } from "./controller";
+import * as fsutils from "../fsutils";
 
 export const FLAG_ONLY = "--only <emulators>";
 export const DESC_ONLY =
@@ -30,6 +33,16 @@ export const DESC_INSPECT_FUNCTIONS =
 export const FLAG_IMPORT = "--import [dir]";
 export const DESC_IMPORT = "import emulator data from a previous export (see emulators:export)";
 
+export const FLAG_EXPORT_ON_EXIT_NAME = "--export-on-exit";
+export const FLAG_EXPORT_ON_EXIT = `${FLAG_EXPORT_ON_EXIT_NAME} [dir]`;
+export const DESC_EXPORT_ON_EXIT =
+  "automatically export emulator data (emulators:export) " +
+  "when the emulators make a clean exit (SIGINT), " +
+  `when no dir is provided the location of ${FLAG_IMPORT} is used`;
+export const EXPORT_ON_EXIT_USAGE_ERROR =
+  `"${FLAG_EXPORT_ON_EXIT_NAME}" must be used with "${FLAG_IMPORT}"` +
+  ` or provide a dir directly to "${FLAG_EXPORT_ON_EXIT}"`;
+
 // Flags for the ext:dev:emulators:* commands
 export const FLAG_TEST_CONFIG = "--test-config <firebase.json file>";
 export const DESC_TEST_CONFIG =
@@ -156,13 +169,59 @@ export function parseInspectionPort(options: any): number {
   return parsed;
 }
 
-export function shutdownWhenKilled(): Promise<void> {
+/**
+ * Sets the correct export options based on --import and --export-on-exit.
+ * Also validates if we have a correct setting we need to export the data on exit.
+ * When used as: `--import ./data --export-on-exit` or `--import ./data --export-on-exit ./data`
+ * we do allow an non-existing --import [dir] and we just export-on-exit. This because else one would always need to
+ * export data the first time they start developing on a clean project.
+ * @param options
+ */
+export function setExportOnExitOptions(options: any): any {
+  if (options.exportOnExit) {
+    if (typeof options.import === "string") {
+      options.exportOnExit =
+        typeof options.exportOnExit === "string" ? options.exportOnExit : options.import;
+
+      const importPath = path.resolve(options.import);
+      if (!fsutils.dirExistsSync(importPath) && options.import === options.exportOnExit) {
+        // --import path does not exist and is tha same as --export-on-exit, let's not import and only --export-on-exit
+        options.exportOnExit = options.import;
+        delete options.import;
+      }
+    }
+
+    if (typeof options.exportOnExit === "string") {
+      return options;
+    }
+    throw new FirebaseError(EXPORT_ON_EXIT_USAGE_ERROR);
+  }
+  return options;
+}
+
+export function shutdownWhenKilled(options: any): Promise<void> {
   return new Promise((res, rej) => {
-    process.on("SIGINT", () => {
-      controller
-        .cleanShutdown()
-        .then(res)
-        .catch(rej);
+    let receivedSIGINTS = 0;
+    process.on("SIGINT", async () => {
+      try {
+        receivedSIGINTS = receivedSIGINTS + 1;
+        utils.logLabeledWarning("emulators", `Received SIGINT ${receivedSIGINTS}`);
+        if (receivedSIGINTS < 2) {
+          // in case of a double 'Ctrl-c' we do not want to cleanly exit with onExit
+          await onExit(options);
+        } else {
+          logger.debug(`Skipping clean onExit()`);
+        }
+        if (receivedSIGINTS < 3) {
+          // in case of a triple 'Ctrl-c' we do not want to wait for cleanShutdown when things go wrong
+          await controller.cleanShutdown();
+        } else {
+          logger.debug(`Skipping cleanShutdown()`);
+        }
+        res();
+      } catch (e) {
+        rej();
+      }
     });
   })
     .then(() => {
@@ -251,10 +310,11 @@ async function runScript(script: string, extraEnv: Record<string, string>): Prom
 /** The action function for emulators:exec and ext:dev:emulators:exec.
  *  Starts the appropriate emulators, executes the provided script,
  *  and then exits.
- *  @param script: A script to run after starting the emualtors.
+ *  @param script: A script to run after starting the emulators.
  *  @param options: A Commander options object.
  */
 export async function emulatorExec(script: string, options: any) {
+  options = setExportOnExitOptions(options);
   const projectId = getProjectId(options, true);
   const extraEnv: Record<string, string> = {};
   if (projectId) {
@@ -264,6 +324,7 @@ export async function emulatorExec(script: string, options: any) {
   try {
     await controller.startAll(options, /* noUi = */ true);
     exitCode = await runScript(script, extraEnv);
+    await onExit(options);
   } finally {
     await controller.cleanShutdown();
   }
diff --git a/src/emulator/controller.ts b/src/emulator/controller.ts
index 6cbd7b40c5a..7f217bbfaf8 100644
--- a/src/emulator/controller.ts
+++ b/src/emulator/controller.ts
@@ -6,19 +6,19 @@ import * as path from "path";
 import * as logger from "../logger";
 import * as track from "../track";
 import * as utils from "../utils";
-import { EmulatorRegistry } from "../emulator/registry";
+import { EmulatorRegistry } from "./registry";
 import {
   Address,
   ALL_SERVICE_EMULATORS,
   EmulatorInstance,
   Emulators,
   EMULATORS_SUPPORTED_BY_UI,
-} from "../emulator/types";
-import { Constants, FIND_AVAILBLE_PORT_BY_DEFAULT } from "../emulator/constants";
-import { FunctionsEmulator } from "../emulator/functionsEmulator";
-import { DatabaseEmulator, DatabaseEmulatorArgs } from "../emulator/databaseEmulator";
-import { FirestoreEmulator, FirestoreEmulatorArgs } from "../emulator/firestoreEmulator";
-import { HostingEmulator } from "../emulator/hostingEmulator";
+} from "./types";
+import { Constants, FIND_AVAILBLE_PORT_BY_DEFAULT } from "./constants";
+import { FunctionsEmulator } from "./functionsEmulator";
+import { DatabaseEmulator, DatabaseEmulatorArgs } from "./databaseEmulator";
+import { FirestoreEmulator, FirestoreEmulatorArgs } from "./firestoreEmulator";
+import { HostingEmulator } from "./hostingEmulator";
 import { FirebaseError } from "../error";
 import * as getProjectId from "../getProjectId";
 import { PubsubEmulator } from "./pubsubEmulator";
@@ -30,6 +30,10 @@ import { LoggingEmulator } from "./loggingEmulator";
 import * as dbRulesConfig from "../database/rulesConfig";
 import { EmulatorLogger } from "./emulatorLogger";
 import * as portUtils from "./portUtils";
+import { EmulatorHubClient } from "./hubClient";
+import { promptOnce } from "../prompt";
+import * as rimraf from "rimraf";
+import { FLAG_EXPORT_ON_EXIT_NAME } from "./commandUtils";
 
 async function getAndCheckAddress(emulator: Emulators, options: any): Promise<Address> {
   const host = Constants.normalizeHost(
@@ -46,13 +50,13 @@ async function getAndCheckAddress(emulator: Emulators, options: any): Promise<Ad
     findAvailablePort = FIND_AVAILBLE_PORT_BY_DEFAULT[emulator];
   }
 
-  const logger = EmulatorLogger.forEmulator(emulator);
+  const loggerForEmulator = EmulatorLogger.forEmulator(emulator);
   const portOpen = await portUtils.checkPortOpen(port, host);
   if (!portOpen) {
     if (findAvailablePort) {
       const newPort = await portUtils.findAvailablePort(host, port);
       if (newPort != port) {
-        logger.logLabeled(
+        loggerForEmulator.logLabeled(
           "WARN",
           emulator,
           `${Constants.description(
@@ -64,12 +68,12 @@ async function getAndCheckAddress(emulator: Emulators, options: any): Promise<Ad
     } else {
       await cleanShutdown();
       const description = Constants.description(emulator);
-      logger.logLabeled(
+      loggerForEmulator.logLabeled(
         "WARN",
         emulator,
         `Port ${port} is not open on ${host}, could not start ${description}.`
       );
-      logger.logLabeled(
+      loggerForEmulator.logLabeled(
         "WARN",
         emulator,
         `To select a different host/port, specify that host/port in a firebase.json config file:
@@ -89,7 +93,7 @@ async function getAndCheckAddress(emulator: Emulators, options: any): Promise<Ad
 
   if (portUtils.isRestricted(port)) {
     const suggested = portUtils.suggestUnrestricted(port);
-    logger.logLabeled(
+    loggerForEmulator.logLabeled(
       "WARN",
       emulator,
       `Port ${port} is restricted by some web browsers, including Chrome. You may want to choose a different port such as ${suggested}.`
@@ -108,6 +112,39 @@ export async function startEmulator(instance: EmulatorInstance): Promise<void> {
   await EmulatorRegistry.start(instance);
 }
 
+/**
+ * Exports emulator data on clean exit (SIGINT or process end)
+ * @param options
+ */
+export async function exportOnExit(options: any) {
+  const exportOnExitDir = options.exportOnExit;
+  if (exportOnExitDir) {
+    try {
+      options.force = true;
+      options.noninteractive = true;
+      utils.logBullet(
+        `Automatically exporting data using ${FLAG_EXPORT_ON_EXIT_NAME} "${exportOnExitDir}" ` +
+          "please wait for the export to finish..."
+      );
+      await exportEmulatorData(exportOnExitDir, options);
+    } catch (e) {
+      utils.logWarning(e);
+      utils.logWarning(`Automatic export to "${exportOnExitDir}" failed, going to exit now...`);
+    }
+  }
+}
+
+/**
+ * Hook to do things when we're exiting cleanly (this does not include errors). Will be skipped on a second SIGINT
+ * @param options
+ */
+export async function onExit(options: any) {
+  await exportOnExit(options);
+}
+
+/**
+ * Hook to clean up on shutdown (includes errors). Will be skipped on a third SIGINT
+ */
 export async function cleanShutdown(): Promise<void> {
   EmulatorLogger.forEmulator(Emulators.HUB).logLabeled(
     "BULLET",
@@ -430,3 +467,89 @@ export async function startAll(options: any, noUi: boolean = false): Promise<voi
     }
   }
 }
+
+/**
+ * Exports data from emulators that support data export. Used with `emulators:export` and with the --export-on-exit flag.
+ * @param exportPath
+ * @param options
+ */
+export async function exportEmulatorData(exportPath: string, options: any) {
+  const projectId = options.project;
+  if (!projectId) {
+    throw new FirebaseError(
+      "Could not determine project ID, make sure you're running in a Firebase project directory or add the --project flag.",
+      { exit: 1 }
+    );
+  }
+
+  const hubClient = new EmulatorHubClient(projectId);
+  if (!hubClient.foundHub()) {
+    throw new FirebaseError(
+      `Did not find any running emulators for project ${clc.bold(projectId)}.`,
+      { exit: 1 }
+    );
+  }
+
+  try {
+    await hubClient.getStatus();
+  } catch (e) {
+    const filePath = EmulatorHub.getLocatorFilePath(projectId);
+    throw new FirebaseError(
+      `The emulator hub for ${projectId} did not respond to a status check. If this error continues try shutting down all running emulators and deleting the file ${filePath}`,
+      { exit: 1 }
+    );
+  }
+
+  utils.logBullet(
+    `Found running emulator hub for project ${clc.bold(projectId)} at ${hubClient.origin}`
+  );
+
+  // If the export target directory does not exist, we should attempt to create it
+  const exportAbsPath = path.resolve(exportPath);
+  if (!fs.existsSync(exportAbsPath)) {
+    utils.logBullet(`Creating export directory ${exportAbsPath}`);
+    fs.mkdirSync(exportAbsPath);
+  }
+
+  // Check if there is already an export there and prompt the user about deleting it
+  const existingMetadata = HubExport.readMetadata(exportAbsPath);
+  if (existingMetadata && !options.force) {
+    if (options.noninteractive) {
+      throw new FirebaseError(
+        "Export already exists in the target directory, re-run with --force to overwrite.",
+        { exit: 1 }
+      );
+    }
+
+    const prompt = await promptOnce({
+      type: "confirm",
+      message: `The directory ${exportAbsPath} already contains export data. Exporting again to the same directory will overwrite all data. Do you want to continue?`,
+      default: false,
+    });
+
+    if (!prompt) {
+      throw new FirebaseError("Command aborted", { exit: 1 });
+    }
+  }
+
+  // Remove all existing data (metadata.json will be overwritten automatically)
+  if (existingMetadata) {
+    if (existingMetadata.firestore) {
+      const firestorePath = path.join(exportAbsPath, existingMetadata.firestore.path);
+      utils.logBullet(`Deleting directory ${firestorePath}`);
+      rimraf.sync(firestorePath);
+    }
+  }
+
+  utils.logBullet(`Exporting data to: ${exportAbsPath}`);
+  try {
+    await hubClient.postExport(exportAbsPath);
+  } catch (e) {
+    throw new FirebaseError("Export request failed, see emulator logs for more information.", {
+      exit: 1,
+      original: e,
+    });
+  }
+
+  utils.logSuccess("Export complete");
+}
diff --git a/src/emulator/pubsubEmulator.ts b/src/emulator/pubsubEmulator.ts
index 2a46d3441ae..29477c828c7 100644
--- a/src/emulator/pubsubEmulator.ts
+++ b/src/emulator/pubsubEmulator.ts
@@ -47,6 +47,7 @@ export class PubsubEmulator implements EmulatorInstance {
   }
 
   async stop(): Promise<void> {
+    console.log("CALLED STROP");
     await downloadableEmulators.stop(Emulators.PUBSUB);
   }
 
diff --git a/src/test/emulators/commandUtils.spec.ts b/src/test/emulators/commandUtils.spec.ts
new file mode 100644
index 00000000000..fd2c4be1411
--- /dev/null
+++ b/src/test/emulators/commandUtils.spec.ts
@@ -0,0 +1,52 @@
+import * as commandUtils from "../../emulator/commandUtils";
+import { expect } from "chai";
+import { FirebaseError } from "../../error";
+import { EXPORT_ON_EXIT_USAGE_ERROR } from "../../emulator/commandUtils";
+
+describe("commandUtils", () => {
+  it("should validate --export-on-exit options", () => {
+    expect(commandUtils.setExportOnExitOptions({ import: "./data" }).exportOnExit).to.be.undefined;
+    expect(
+      commandUtils.setExportOnExitOptions({ import: "./data", exportOnExit: "./data" }).exportOnExit
+    ).to.eql("./data");
+    expect(
+      commandUtils.setExportOnExitOptions({ import: "./data", exportOnExit: "./dataExport" })
+        .exportOnExit
+    ).to.eql("./dataExport");
+    expect(
+      commandUtils.setExportOnExitOptions({ import: "./data", exportOnExit: true }).exportOnExit
+    ).to.eql("./data");
+    expect(() => commandUtils.setExportOnExitOptions({ exportOnExit: true })).to.throw(
+      FirebaseError,
+      EXPORT_ON_EXIT_USAGE_ERROR
+    );
+  });
+  it("should delete the --import option when the dir does not exist together with --export-on-exit", () => {
+    expect(
+      commandUtils.setExportOnExitOptions({
+        import: "./dataDirThatDoesNotExist",
+        exportOnExit: "./dataDirThatDoesNotExist",
+      }).import
+    ).to.be.undefined;
+    let options = commandUtils.setExportOnExitOptions({
+      import: "./dataDirThatDoesNotExist",
+      exportOnExit: true,
+    });
+    expect(options.import).to.be.undefined;
+    expect(options.exportOnExit).to.eql("./dataDirThatDoesNotExist");
+  });
+  it("should not touch the --import option when the dir does not exist but --export-on-exit is not set", () => {
+    expect(
+      commandUtils.setExportOnExitOptions({
+        import: "./dataDirThatDoesNotExist",
+      }).import
+    ).to.eql("./dataDirThatDoesNotExist");
+  });
+  it("should keep other unrelated options when using setExportOnExitOptions", () => {
+    expect(
+      commandUtils.setExportOnExitOptions({
+        someUnrelatedOption: "isHere",
+      }).someUnrelatedOption
+    ).to.eql("isHere");
+  });
+});

From 18bf246620800dc450cb63af2d702abc786fa8e5 Mon Sep 17 00:00:00 2001
From: Michael Krens <mkrens@gmail.com>
Date: Wed, 1 Jul 2020 04:31:17 +0200
Subject: [PATCH 3/9] remove console.log

---
 src/emulator/pubsubEmulator.ts | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/emulator/pubsubEmulator.ts b/src/emulator/pubsubEmulator.ts
index 29477c828c7..2a46d3441ae 100644
--- a/src/emulator/pubsubEmulator.ts
+++ b/src/emulator/pubsubEmulator.ts
@@ -47,7 +47,6 @@ export class PubsubEmulator implements EmulatorInstance {
   }
 
   async stop(): Promise<void> {
-    console.log("CALLED STROP");
     await downloadableEmulators.stop(Emulators.PUBSUB);
   }
 

From 2a2736bf347bd2bf6e463538685ce8d06f9dda46 Mon Sep 17 00:00:00 2001
From: Michael Krens <mkrens@gmail.com>
Date: Wed, 1 Jul 2020 16:16:01 +0200
Subject: [PATCH 4/9] mutate --export-on-exit options in Command.before

---
 src/commands/emulators-exec.ts          |  1 +
 src/commands/emulators-start.ts         |  2 +-
 src/commands/ext-dev-emulators-exec.ts  |  1 +
 src/commands/ext-dev-emulators-start.ts |  3 +--
 src/emulator/commandUtils.ts            |  9 ++++-----
 src/test/emulators/commandUtils.spec.ts | 22 +++++++++++++---------
 6 files changed, 21 insertions(+), 17 deletions(-)

diff --git a/src/commands/emulators-exec.ts b/src/commands/emulators-exec.ts
index 24509f2cd66..8c07f0ddb49 100644
--- a/src/commands/emulators-exec.ts
+++ b/src/commands/emulators-exec.ts
@@ -2,6 +2,7 @@ import { Command } from "../command";
 import * as commandUtils from "../emulator/commandUtils";
 
 module.exports = new Command("emulators:exec <script>")
+  .before(commandUtils.setExportOnExitOptions)
   .before(commandUtils.beforeEmulatorCommand)
   .description(
     "start the local Firebase emulators, " + "run a test script, then shut down the emulators"
diff --git a/src/commands/emulators-start.ts b/src/commands/emulators-start.ts
index a0b1d110530..815c535dabc 100644
--- a/src/commands/emulators-start.ts
+++ b/src/commands/emulators-start.ts
@@ -14,6 +14,7 @@ function stylizeLink(url: String) {
 }
 
 module.exports = new Command("emulators:start")
+  .before(commandUtils.setExportOnExitOptions)
   .before(commandUtils.beforeEmulatorCommand)
   .description("start the local Firebase emulators")
   .option(commandUtils.FLAG_ONLY, commandUtils.DESC_ONLY)
@@ -21,7 +22,6 @@ module.exports = new Command("emulators:start")
   .option(commandUtils.FLAG_IMPORT, commandUtils.DESC_IMPORT)
   .option(commandUtils.FLAG_EXPORT_ON_EXIT, commandUtils.DESC_EXPORT_ON_EXIT)
   .action(async (options: any) => {
-    options = commandUtils.setExportOnExitOptions(options);
     const killSignalPromise = commandUtils.shutdownWhenKilled(options);
 
     try {
diff --git a/src/commands/ext-dev-emulators-exec.ts b/src/commands/ext-dev-emulators-exec.ts
index 2db8f64c55c..1c49225c635 100644
--- a/src/commands/ext-dev-emulators-exec.ts
+++ b/src/commands/ext-dev-emulators-exec.ts
@@ -5,6 +5,7 @@ import * as optionsHelper from "../extensions/emulator/optionsHelper";
 
 module.exports = new Command("ext:dev:emulators:exec <script>")
   .description("emulate an extension, run a test script, then shut down the emulators")
+  .before(commandUtils.setExportOnExitOptions)
   .option(commandUtils.FLAG_INSPECT_FUNCTIONS, commandUtils.DESC_INSPECT_FUNCTIONS)
   .option(commandUtils.FLAG_TEST_CONFIG, commandUtils.DESC_TEST_CONFIG)
   .option(commandUtils.FLAG_TEST_PARAMS, commandUtils.DESC_TEST_PARAMS)
diff --git a/src/commands/ext-dev-emulators-start.ts b/src/commands/ext-dev-emulators-start.ts
index 3d25415744d..0fc7f5f8ea2 100644
--- a/src/commands/ext-dev-emulators-start.ts
+++ b/src/commands/ext-dev-emulators-start.ts
@@ -7,15 +7,14 @@ import { FirebaseError } from "../error";
 
 module.exports = new Command("ext:dev:emulators:start")
   .description("start the local Firebase extension emulator")
+  .before(commandUtils.setExportOnExitOptions)
   .option(commandUtils.FLAG_INSPECT_FUNCTIONS, commandUtils.DESC_INSPECT_FUNCTIONS)
   .option(commandUtils.FLAG_TEST_CONFIG, commandUtils.DESC_TEST_CONFIG)
   .option(commandUtils.FLAG_TEST_PARAMS, commandUtils.DESC_TEST_PARAMS)
   .option(commandUtils.FLAG_IMPORT, commandUtils.DESC_IMPORT)
   .option(commandUtils.FLAG_EXPORT_ON_EXIT, commandUtils.DESC_EXPORT_ON_EXIT)
   .action(async (options: any) => {
-    options = commandUtils.setExportOnExitOptions(options);
     const killSignalPromise = commandUtils.shutdownWhenKilled(options);
-
     const emulatorOptions = await optionsHelper.buildOptions(options);
     try {
       commandUtils.beforeEmulatorCommand(emulatorOptions);
diff --git a/src/emulator/commandUtils.ts b/src/emulator/commandUtils.ts
index 224eaf1c0a2..f0fbe80dd25 100644
--- a/src/emulator/commandUtils.ts
+++ b/src/emulator/commandUtils.ts
@@ -170,14 +170,14 @@ export function parseInspectionPort(options: any): number {
 }
 
 /**
- * Sets the correct export options based on --import and --export-on-exit.
+ * Sets the correct export options based on --import and --export-on-exit. Mutates the options object.
  * Also validates if we have a correct setting we need to export the data on exit.
  * When used as: `--import ./data --export-on-exit` or `--import ./data --export-on-exit ./data`
  * we do allow an non-existing --import [dir] and we just export-on-exit. This because else one would always need to
  * export data the first time they start developing on a clean project.
  * @param options
  */
-export function setExportOnExitOptions(options: any): any {
+export function setExportOnExitOptions(options: any) {
   if (options.exportOnExit) {
     if (typeof options.import === "string") {
       options.exportOnExit =
@@ -192,11 +192,11 @@ export function setExportOnExitOptions(options: any): any {
     }
 
     if (typeof options.exportOnExit === "string") {
-      return options;
+      return;
     }
     throw new FirebaseError(EXPORT_ON_EXIT_USAGE_ERROR);
   }
-  return options;
+  return;
 }
 
 export function shutdownWhenKilled(options: any): Promise<void> {
@@ -314,7 +314,6 @@ async function runScript(script: string, extraEnv: Record<string, string>): Prom
  *  @param options: A Commander options object.
  */
 export async function emulatorExec(script: string, options: any) {
-  options = setExportOnExitOptions(options);
   const projectId = getProjectId(options, true);
   const extraEnv: Record<string, string> = {};
   if (projectId) {
diff --git a/src/test/emulators/commandUtils.spec.ts b/src/test/emulators/commandUtils.spec.ts
index fd2c4be1411..97e9193d47b 100644
--- a/src/test/emulators/commandUtils.spec.ts
+++ b/src/test/emulators/commandUtils.spec.ts
@@ -4,17 +4,21 @@ import { FirebaseError } from "../../error";
 import { EXPORT_ON_EXIT_USAGE_ERROR } from "../../emulator/commandUtils";
 
 describe("commandUtils", () => {
+  const testSetExportOnExitOptions = (options: any): any => {
+    commandUtils.setExportOnExitOptions(options);
+    return options;
+  };
+
   it("should validate --export-on-exit options", () => {
-    expect(commandUtils.setExportOnExitOptions({ import: "./data" }).exportOnExit).to.be.undefined;
+    expect(testSetExportOnExitOptions({ import: "./data" }).exportOnExit).to.be.undefined;
     expect(
-      commandUtils.setExportOnExitOptions({ import: "./data", exportOnExit: "./data" }).exportOnExit
+      testSetExportOnExitOptions({ import: "./data", exportOnExit: "./data" }).exportOnExit
     ).to.eql("./data");
     expect(
-      commandUtils.setExportOnExitOptions({ import: "./data", exportOnExit: "./dataExport" })
-        .exportOnExit
+      testSetExportOnExitOptions({ import: "./data", exportOnExit: "./dataExport" }).exportOnExit
     ).to.eql("./dataExport");
     expect(
-      commandUtils.setExportOnExitOptions({ import: "./data", exportOnExit: true }).exportOnExit
+      testSetExportOnExitOptions({ import: "./data", exportOnExit: true }).exportOnExit
     ).to.eql("./data");
     expect(() => commandUtils.setExportOnExitOptions({ exportOnExit: true })).to.throw(
       FirebaseError,
@@ -23,12 +27,12 @@ describe("commandUtils", () => {
   });
   it("should delete the --import option when the dir does not exist together with --export-on-exit", () => {
     expect(
-      commandUtils.setExportOnExitOptions({
+      testSetExportOnExitOptions({
         import: "./dataDirThatDoesNotExist",
         exportOnExit: "./dataDirThatDoesNotExist",
       }).import
     ).to.be.undefined;
-    let options = commandUtils.setExportOnExitOptions({
+    let options = testSetExportOnExitOptions({
       import: "./dataDirThatDoesNotExist",
       exportOnExit: true,
     });
@@ -37,14 +41,14 @@ describe("commandUtils", () => {
   });
   it("should not touch the --import option when the dir does not exist but --export-on-exit is not set", () => {
     expect(
-      commandUtils.setExportOnExitOptions({
+      testSetExportOnExitOptions({
         import: "./dataDirThatDoesNotExist",
       }).import
     ).to.eql("./dataDirThatDoesNotExist");
   });
   it("should keep other unrelated options when using setExportOnExitOptions", () => {
     expect(
-      commandUtils.setExportOnExitOptions({
+      testSetExportOnExitOptions({
         someUnrelatedOption: "isHere",
       }).someUnrelatedOption
     ).to.eql("isHere");

From 1d307a4b82e7400fbc2d6114458f68cc9f8bf59d Mon Sep 17 00:00:00 2001
From: Michael Krens <mkrens@gmail.com>
Date: Wed, 1 Jul 2020 16:28:22 +0200
Subject: [PATCH 5/9] add --export-on-exit flag to CHANGELOG.md

---
 CHANGELOG.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index bba9b20e224..6c4dc53b789 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,4 @@
 - Adds support for regular expression-based custom headers and rewrites for Firebase Hosting. (#2391)
 - Fixes a bug with RTDB Rules hot reloading in the RTDB emulator. (#2371)
 - Changes default functions runtime to Node.js 10 for `firebase init`.
+- Adds a the `--export-on-exit` flag to `emulators:start` and `emulators:exec` to automatically export emulator data on command exit (#2224)

From 7df2b0487d03f2dca0fc570ee3bc8d0db0c07bd8 Mon Sep 17 00:00:00 2001
From: Michael Krens <mkrens@gmail.com>
Date: Wed, 1 Jul 2020 17:08:45 +0200
Subject: [PATCH 6/9] check for options.exportOnExit instead of overriding
 options.force

---
 src/emulator/controller.ts | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/emulator/controller.ts b/src/emulator/controller.ts
index 7f217bbfaf8..72c287ecbf1 100644
--- a/src/emulator/controller.ts
+++ b/src/emulator/controller.ts
@@ -120,8 +120,6 @@ export async function exportOnExit(options: any) {
   const exportOnExitDir = options.exportOnExit;
   if (exportOnExitDir) {
     try {
-      options.force = true;
-      options.noninteractive = true;
       utils.logBullet(
         `Automatically exporting data using ${FLAG_EXPORT_ON_EXIT_NAME} "${exportOnExitDir}" ` +
           "please wait for the export to finish..."
@@ -513,7 +511,7 @@ export async function exportEmulatorData(exportPath: string, options: any) {
 
   // Check if there is already an export there and prompt the user about deleting it
   const existingMetadata = HubExport.readMetadata(exportAbsPath);
-  if (existingMetadata && !options.force) {
+  if (existingMetadata && !(options.force || options.exportOnExit)) {
     if (options.noninteractive) {
       throw new FirebaseError(
         "Export already exists in the target directory, re-run with --force to overwrite.",

From d8b832beecb445346a262f39f6c6b64a17f4e414 Mon Sep 17 00:00:00 2001
From: Michael Krens <mkrens@gmail.com>
Date: Wed, 1 Jul 2020 17:31:28 +0200
Subject: [PATCH 7/9] more test cases and note about that options.exportOnExit
 being be a string or a bool

---
 src/emulator/commandUtils.ts            | 16 ++++++++++------
 src/test/emulators/commandUtils.spec.ts | 12 +++++++++++-
 2 files changed, 21 insertions(+), 7 deletions(-)

diff --git a/src/emulator/commandUtils.ts b/src/emulator/commandUtils.ts
index f0fbe80dd25..8f60f603987 100644
--- a/src/emulator/commandUtils.ts
+++ b/src/emulator/commandUtils.ts
@@ -178,23 +178,27 @@ export function parseInspectionPort(options: any): number {
  * @param options
  */
 export function setExportOnExitOptions(options: any) {
-  if (options.exportOnExit) {
-    if (typeof options.import === "string") {
+  if (options.exportOnExit || typeof options.exportOnExit === "string") {
+    // note that options.exportOnExit may be a bool when used as a flag without a [dir] argument:
+    // --import ./data --export-on-exit
+    if (options.import) {
       options.exportOnExit =
         typeof options.exportOnExit === "string" ? options.exportOnExit : options.import;
 
       const importPath = path.resolve(options.import);
       if (!fsutils.dirExistsSync(importPath) && options.import === options.exportOnExit) {
-        // --import path does not exist and is tha same as --export-on-exit, let's not import and only --export-on-exit
+        // --import path does not exist and is the same as --export-on-exit, let's not import and only --export-on-exit
         options.exportOnExit = options.import;
         delete options.import;
       }
     }
 
-    if (typeof options.exportOnExit === "string") {
-      return;
+    if (options.exportOnExit === true || !options.exportOnExit) {
+      // might be true when only used as a flag without --import [dir]
+      // options.exportOnExit might be an empty string when used as:
+      // firebase emulators:start --debug --import '' --export-on-exit ''
+      throw new FirebaseError(EXPORT_ON_EXIT_USAGE_ERROR);
     }
-    throw new FirebaseError(EXPORT_ON_EXIT_USAGE_ERROR);
   }
   return;
 }
diff --git a/src/test/emulators/commandUtils.spec.ts b/src/test/emulators/commandUtils.spec.ts
index 97e9193d47b..e4964ac9235 100644
--- a/src/test/emulators/commandUtils.spec.ts
+++ b/src/test/emulators/commandUtils.spec.ts
@@ -5,7 +5,9 @@ import { EXPORT_ON_EXIT_USAGE_ERROR } from "../../emulator/commandUtils";
 
 describe("commandUtils", () => {
   const testSetExportOnExitOptions = (options: any): any => {
+    console.log(options);
     commandUtils.setExportOnExitOptions(options);
+    console.log(options);
     return options;
   };
 
@@ -20,7 +22,15 @@ describe("commandUtils", () => {
     expect(
       testSetExportOnExitOptions({ import: "./data", exportOnExit: true }).exportOnExit
     ).to.eql("./data");
-    expect(() => commandUtils.setExportOnExitOptions({ exportOnExit: true })).to.throw(
+    expect(() => testSetExportOnExitOptions({ exportOnExit: true })).to.throw(
+      FirebaseError,
+      EXPORT_ON_EXIT_USAGE_ERROR
+    );
+    expect(() => testSetExportOnExitOptions({ import: "", exportOnExit: true })).to.throw(
+      FirebaseError,
+      EXPORT_ON_EXIT_USAGE_ERROR
+    );
+    expect(() => testSetExportOnExitOptions({ import: "", exportOnExit: "" })).to.throw(
       FirebaseError,
       EXPORT_ON_EXIT_USAGE_ERROR
     );

From 3423dc3925da143241563395c5c2c0ba9d31efb5 Mon Sep 17 00:00:00 2001
From: Michael Krens <mkrens@gmail.com>
Date: Fri, 10 Jul 2020 19:44:01 +0200
Subject: [PATCH 8/9] More robust starting and stopping of emulators: - Listen
 for more stop signals - Stop running on fatal start of emulator - Stop
 emulators on exit that are 'starting' - Faster shutdown (parallel emulator
 stops)

---
 src/emulator/commandUtils.ts            | 94 ++++++++++++++++++++-----
 src/emulator/controller.ts              | 54 +++++++++-----
 src/emulator/databaseEmulator.ts        |  2 +
 src/emulator/downloadableEmulators.ts   | 42 ++++++++---
 src/emulator/firestoreEmulator.ts       |  2 +
 src/emulator/functionsEmulator.ts       |  1 +
 src/emulator/hostingEmulator.ts         |  1 +
 src/emulator/hub.ts                     |  1 +
 src/emulator/loggingEmulator.ts         |  1 +
 src/emulator/pubsubEmulator.ts          |  2 +
 src/emulator/registry.ts                | 32 +++++++--
 src/emulator/types.ts                   |  2 +
 src/emulator/ui.ts                      |  2 +
 src/test/emulators/commandUtils.spec.ts |  2 -
 src/test/emulators/fakeEmulator.ts      |  1 +
 15 files changed, 185 insertions(+), 54 deletions(-)

diff --git a/src/emulator/commandUtils.ts b/src/emulator/commandUtils.ts
index 8f60f603987..300ce570e59 100644
--- a/src/emulator/commandUtils.ts
+++ b/src/emulator/commandUtils.ts
@@ -18,6 +18,9 @@ import { prompt } from "../prompt";
 import { EmulatorHub } from "./hub";
 import { onExit } from "./controller";
 import * as fsutils from "../fsutils";
+import Signals = NodeJS.Signals;
+import SignalsListener = NodeJS.SignalsListener;
+import Table = require("cli-table");
 
 export const FLAG_ONLY = "--only <emulators>";
 export const DESC_ONLY =
@@ -203,29 +206,82 @@ export function setExportOnExitOptions(options: any) {
   return;
 }
 
-export function shutdownWhenKilled(options: any): Promise<void> {
-  return new Promise((res, rej) => {
-    let receivedSIGINTS = 0;
-    process.on("SIGINT", async () => {
-      try {
-        receivedSIGINTS = receivedSIGINTS + 1;
-        utils.logLabeledWarning("emulators", `Received SIGINT ${receivedSIGINTS}`);
-        if (receivedSIGINTS < 2) {
-          // in case of a double 'Ctrl-c' we do not want to cleanly exit with onExit
-          await onExit(options);
-        } else {
-          logger.debug(`Skipping clean onExit()`);
+function processKillSignal(
+  signal: Signals,
+  res: (value?: unknown) => void,
+  rej: (value?: unknown) => void,
+  options: any
+): SignalsListener {
+  let signalCount = 0;
+  return async () => {
+    try {
+      signalCount = signalCount + 1;
+      const signalDisplay = signal === "SIGINT" ? `SIGINT (Ctrl-C)` : signal;
+      logger.debug(`Received signal ${signalDisplay} ${signalCount}`);
+      logger.info(" "); // to not indent the log with the possible Ctrl-C char
+      if (signalCount === 1) {
+        utils.logLabeledBullet(
+          "emulators",
+          `Received ${signalDisplay} for the first time. Starting a clean shutdown.`
+        );
+        utils.logLabeledBullet(
+          "emulators",
+          `Please wait for a clean shutdown or send the ${signalDisplay} signal again to stop right now.`
+        );
+        // in case of a double 'Ctrl-C' we do not want to cleanly exit with onExit/cleanShutdown
+        await onExit(options);
+        await controller.cleanShutdown();
+      } else {
+        logger.debug(`Skipping clean onExit() and cleanShutdown()`);
+        const runningEmulatorsInfosWithPid = EmulatorRegistry.listRunningWithInfo().filter((i) =>
+          Boolean(i.pid)
+        );
+
+        utils.logLabeledWarning(
+          "emulators",
+          `Received ${signalDisplay} ${signalCount} times. You have forced the Emulator Suite to exit without waiting for ${
+            runningEmulatorsInfosWithPid.length
+          } subprocess${
+            runningEmulatorsInfosWithPid.length > 1 ? "es" : ""
+          } to finish. These processes ${clc.bold("may")} still be running on your machine: `
+        );
+
+        const pids: number[] = [];
+
+        const emulatorsTable = new Table({
+          head: ["Emulator", "Host:Port", "PID"],
+          style: {
+            head: ["yellow"],
+          },
+        });
+
+        for (const emulatorInfo of runningEmulatorsInfosWithPid) {
+          pids.push(emulatorInfo.pid as number);
+          emulatorsTable.push([
+            Constants.description(emulatorInfo.name),
+            `${emulatorInfo.host}:${emulatorInfo.port}`,
+            emulatorInfo.pid,
+          ]);
         }
-        if (receivedSIGINTS < 3) {
-          // in case of a triple 'Ctrl-c' we do not want to wait for cleanShutdown when things go wrong
-          await controller.cleanShutdown();
+        logger.info(`\n${emulatorsTable}\n\nTo force them to exit run:\n`);
+        if (process.platform === "win32") {
+          logger.info(clc.bold(`TASKKILL ${pids.map((pid) => "/PID " + pid).join(" ")} /T\n`));
         } else {
-          logger.debug(`Skipping cleanShutdown()`);
+          logger.info(clc.bold(`kill ${pids.join(" ")}\n`));
         }
-        res();
-      } catch (e) {
-        rej();
       }
+      res();
+    } catch (e) {
+      logger.debug(e);
+      rej();
+    }
+  };
+}
+
+export function shutdownWhenKilled(options: any): Promise<void> {
+  return new Promise((res, rej) => {
+    ["SIGINT", "SIGTERM", "SIGHUP", "SIGQUIT"].forEach((signal: string) => {
+      process.on(signal as Signals, processKillSignal(signal as Signals, res, rej, options));
     });
   })
     .then(() => {
diff --git a/src/emulator/controller.ts b/src/emulator/controller.ts
index 405447acd59..39176e4d25e 100644
--- a/src/emulator/controller.ts
+++ b/src/emulator/controller.ts
@@ -15,6 +15,7 @@ import {
   EmulatorInstance,
   Emulators,
   EMULATORS_SUPPORTED_BY_UI,
+  isEmulator,
 } from "./types";
 import { Constants, FIND_AVAILBLE_PORT_BY_DEFAULT } from "./constants";
 import { FunctionsEmulator } from "./functionsEmulator";
@@ -36,6 +37,7 @@ import { EmulatorHubClient } from "./hubClient";
 import { promptOnce } from "../prompt";
 import * as rimraf from "rimraf";
 import { FLAG_EXPORT_ON_EXIT_NAME } from "./commandUtils";
+import { fileExistsSync } from "../fsutils";
 
 async function getAndCheckAddress(emulator: Emulators, options: any): Promise<Address> {
   const host = Constants.normalizeHost(
@@ -144,6 +146,7 @@ export async function onExit(options: any) {
 
 /**
  * Hook to clean up on shutdown (includes errors). Will be skipped on a third SIGINT
+ * Stops all running emulators in parallel.
  */
 export async function cleanShutdown(): Promise<void> {
   EmulatorLogger.forEmulator(Emulators.HUB).logLabeled(
@@ -151,14 +154,7 @@ export async function cleanShutdown(): Promise<void> {
     "emulators",
     "Shutting down emulators."
   );
-  for (const name of EmulatorRegistry.listRunning()) {
-    EmulatorLogger.forEmulator(name).logLabeled(
-      "BULLET",
-      name,
-      `Stopping ${Constants.description(name)}`
-    );
-    await EmulatorRegistry.stop(name);
-  }
+  await EmulatorRegistry.stopAll();
 }
 
 export function filterEmulatorTargets(options: any): Emulators[] {
@@ -252,13 +248,24 @@ export async function startAll(options: any, noUi: boolean = false): Promise<voi
     const ignored = _.difference(requested, targets);
 
     for (const name of ignored) {
-      EmulatorLogger.forEmulator(name as Emulators).logLabeled(
-        "WARN",
-        name,
-        `Not starting the ${clc.bold(name)} emulator, make sure you have run ${clc.bold(
-          "firebase init"
-        )}.`
-      );
+      if (isEmulator(name)) {
+        EmulatorLogger.forEmulator(name as Emulators).logLabeled(
+          "WARN",
+          name,
+          `Not starting the ${clc.bold(name)} emulator, make sure you have run ${clc.bold(
+            "firebase init"
+          )}.`
+        );
+      } else {
+        // this should not work:
+        // firebase emulators:start --only doesnotexit
+        throw new FirebaseError(
+          `${name} is not a valid emulator name, valid options are: ${JSON.stringify(
+            ALL_SERVICE_EMULATORS
+          )}`,
+          { exit: 1 }
+        );
+      }
     }
   }
 
@@ -273,10 +280,19 @@ export async function startAll(options: any, noUi: boolean = false): Promise<voi
     version: "unknown",
   };
   if (options.import) {
-    const importDir = path.resolve(options.import);
-    exportMetadata = JSON.parse(
-      fs.readFileSync(path.join(importDir, HubExport.METADATA_FILE_NAME), "utf8").toString()
-    ) as ExportMetadata;
+    const importFilePath = path.join(path.resolve(options.import), HubExport.METADATA_FILE_NAME);
+    if (fileExistsSync(importFilePath)) {
+      exportMetadata = JSON.parse(
+        fs
+          .readFileSync(
+            path.join(path.resolve(options.import), HubExport.METADATA_FILE_NAME),
+            "utf8"
+          )
+          .toString()
+      ) as ExportMetadata;
+    } else {
+      // could happen when an export was interrupted...
+    }
   }
 
   if (shouldStart(options, Emulators.FUNCTIONS)) {
diff --git a/src/emulator/databaseEmulator.ts b/src/emulator/databaseEmulator.ts
index 2e66bf23bbb..b7c7aac2e57 100644
--- a/src/emulator/databaseEmulator.ts
+++ b/src/emulator/databaseEmulator.ts
@@ -85,8 +85,10 @@ export class DatabaseEmulator implements EmulatorInstance {
     const port = this.args.port || Constants.getDefaultPort(Emulators.DATABASE);
 
     return {
+      name: this.getName(),
       host,
       port,
+      pid: downloadableEmulators.getPID(Emulators.DATABASE),
     };
   }
 
diff --git a/src/emulator/downloadableEmulators.ts b/src/emulator/downloadableEmulators.ts
index 494d7e6dc04..048b5847f77 100644
--- a/src/emulator/downloadableEmulators.ts
+++ b/src/emulator/downloadableEmulators.ts
@@ -16,6 +16,7 @@ import * as clc from "cli-color";
 import * as fs from "fs-extra";
 import * as path from "path";
 import * as os from "os";
+import { EmulatorRegistry } from "./registry";
 
 // tslint:disable-next-line
 const downloadEmulator = require("../emulator/download");
@@ -198,8 +199,21 @@ function _getCommand(
   };
 }
 
-function _fatal(emulator: DownloadableEmulatorDetails, errorMsg: string): void {
-  throw new FirebaseError(emulator.name + ": " + errorMsg, { exit: 1 });
+async function _fatal(emulator: DownloadableEmulatorDetails, errorMsg: string): Promise<void> {
+  // if we do not issue a stopAll here and _fatal is called during startup, we could leave emulators running
+  // that did start already
+  // for example: JAVA_HOME=/does/not/exist firebase emulators:start
+  try {
+    const logger = EmulatorLogger.forEmulator(emulator.name);
+    logger.logLabeled(
+      "WARN",
+      emulator.name,
+      `Fatal error occurred: \n   ${errorMsg}, \n   stopping all running emulators`
+    );
+    await EmulatorRegistry.stopAll();
+  } finally {
+    process.exit(1);
+  }
 }
 
 async function _runBinary(
@@ -230,7 +244,6 @@ async function _runBinary(
           `Could not spawn child process for emulator, check that java is installed and on your $PATH.`
         );
       }
-
       _fatal(emulator, e);
     }
 
@@ -264,21 +277,21 @@ async function _runBinary(
       }
     });
 
-    emulator.instance.on("error", (err: any) => {
+    emulator.instance.on("error", async (err: any) => {
       if (err.path === "java" && err.code === "ENOENT") {
-        _fatal(
+        await _fatal(
           emulator,
           `${description} has exited because java is not installed, you can install it from https://openjdk.java.net/install/`
         );
       } else {
-        _fatal(emulator, `${description} has exited: ${err}`);
+        await _fatal(emulator, `${description} has exited: ${err}`);
       }
     });
-    emulator.instance.once("exit", (code, signal) => {
+    emulator.instance.once("exit", async (code, signal) => {
       if (signal) {
         utils.logWarning(`${description} has exited upon receiving signal: ${signal}`);
       } else if (code && code !== 0 && code !== /* SIGINT */ 130) {
-        _fatal(emulator, `${description} has exited with code: ${code}`);
+        await _fatal(emulator, `${description} has exited with code: ${code}`);
       }
     });
     resolve();
@@ -299,11 +312,20 @@ export function get(emulator: DownloadableEmulators): DownloadableEmulatorDetail
   return EmulatorDetails[emulator];
 }
 
+/**
+ * Returns the PID of the emulator process
+ * @param emulator
+ */
+export function getPID(emulator: DownloadableEmulators): number {
+  const emulatorInstance = get(emulator).instance;
+  return emulatorInstance && emulatorInstance.pid ? emulatorInstance.pid : 0;
+}
+
 /**
  * @param targetName
  */
 export async function stop(targetName: DownloadableEmulators): Promise<void> {
-  const emulator = EmulatorDetails[targetName];
+  const emulator = get(targetName);
   return new Promise((resolve, reject) => {
     const logger = EmulatorLogger.forEmulator(emulator.name);
     if (emulator.instance) {
@@ -350,7 +372,7 @@ export async function start(
   extraEnv: NodeJS.ProcessEnv = {}
 ): Promise<void> {
   const downloadDetails = DownloadDetails[targetName];
-  const emulator = EmulatorDetails[targetName];
+  const emulator = get(targetName);
   const hasEmulator = fs.existsSync(getExecPath(targetName));
   const logger = EmulatorLogger.forEmulator(targetName);
   if (!hasEmulator || downloadDetails.opts.skipCache) {
diff --git a/src/emulator/firestoreEmulator.ts b/src/emulator/firestoreEmulator.ts
index 8186f1d7e26..542e2f2286b 100644
--- a/src/emulator/firestoreEmulator.ts
+++ b/src/emulator/firestoreEmulator.ts
@@ -79,8 +79,10 @@ export class FirestoreEmulator implements EmulatorInstance {
     const port = this.args.port || Constants.getDefaultPort(Emulators.FIRESTORE);
 
     return {
+      name: this.getName(),
       host,
       port,
+      pid: downloadableEmulators.getPID(Emulators.FIRESTORE),
     };
   }
 
diff --git a/src/emulator/functionsEmulator.ts b/src/emulator/functionsEmulator.ts
index fe53bd4ef39..c086ecc9f85 100644
--- a/src/emulator/functionsEmulator.ts
+++ b/src/emulator/functionsEmulator.ts
@@ -505,6 +505,7 @@ export class FunctionsEmulator implements EmulatorInstance {
     const port = this.args.port || Constants.getDefaultPort(Emulators.FUNCTIONS);
 
     return {
+      name: this.getName(),
       host,
       port,
     };
diff --git a/src/emulator/hostingEmulator.ts b/src/emulator/hostingEmulator.ts
index 244928c8a45..5c8deb031ff 100644
--- a/src/emulator/hostingEmulator.ts
+++ b/src/emulator/hostingEmulator.ts
@@ -31,6 +31,7 @@ export class HostingEmulator implements EmulatorInstance {
     const port = this.args.port || Constants.getDefaultPort(Emulators.HOSTING);
 
     return {
+      name: this.getName(),
       host,
       port,
     };
diff --git a/src/emulator/hub.ts b/src/emulator/hub.ts
index d297ac88735..287567ecc57 100644
--- a/src/emulator/hub.ts
+++ b/src/emulator/hub.ts
@@ -126,6 +126,7 @@ export class EmulatorHub implements EmulatorInstance {
     const port = this.args.port || Constants.getDefaultPort(Emulators.HUB);
 
     return {
+      name: this.getName(),
       host,
       port,
     };
diff --git a/src/emulator/loggingEmulator.ts b/src/emulator/loggingEmulator.ts
index 067bebed476..4ffc31747fe 100644
--- a/src/emulator/loggingEmulator.ts
+++ b/src/emulator/loggingEmulator.ts
@@ -56,6 +56,7 @@ export class LoggingEmulator implements EmulatorInstance {
     const port = this.args.port || Constants.getDefaultPort(Emulators.LOGGING);
 
     return {
+      name: this.getName(),
       host,
       port,
     };
diff --git a/src/emulator/pubsubEmulator.ts b/src/emulator/pubsubEmulator.ts
index 2a46d3441ae..8ca5ab76cb5 100644
--- a/src/emulator/pubsubEmulator.ts
+++ b/src/emulator/pubsubEmulator.ts
@@ -55,8 +55,10 @@ export class PubsubEmulator implements EmulatorInstance {
     const port = this.args.port || Constants.getDefaultPort(Emulators.PUBSUB);
 
     return {
+      name: this.getName(),
       host,
       port,
+      pid: downloadableEmulators.getPID(Emulators.PUBSUB),
     };
   }
 
diff --git a/src/emulator/registry.ts b/src/emulator/registry.ts
index 2a8d4cc5799..1f8ff8134f4 100644
--- a/src/emulator/registry.ts
+++ b/src/emulator/registry.ts
@@ -2,6 +2,7 @@ import { ALL_EMULATORS, EmulatorInstance, Emulators, EmulatorInfo } from "./type
 import { FirebaseError } from "../error";
 import * as portUtils from "./portUtils";
 import { Constants } from "./constants";
+import { EmulatorLogger } from "./emulatorLogger";
 
 /**
  * Static registry for running emulators to discover each other.
@@ -16,15 +17,22 @@ export class EmulatorRegistry {
       throw new FirebaseError(`${description} is already running!`, {});
     }
 
+    // must be before we start as else on a quick 'Ctrl-C' after starting we could skip this emulator in cleanShutdown
+    this.set(instance.getName(), instance);
+
     // Start the emulator and wait for it to grab its assigned port.
     await instance.start();
 
     const info = instance.getInfo();
     await portUtils.waitForPortClosed(info.port, info.host);
-    this.set(instance.getName(), instance);
   }
 
   static async stop(name: Emulators): Promise<void> {
+    EmulatorLogger.forEmulator(name).logLabeled(
+      "BULLET",
+      name,
+      `Stopping ${Constants.description(name)}`
+    );
     const instance = this.get(name);
     if (!instance) {
       return;
@@ -35,9 +43,19 @@ export class EmulatorRegistry {
   }
 
   static async stopAll(): Promise<void> {
-    for (const name of this.listRunning()) {
-      await this.stop(name);
-    }
+    await Promise.all(
+      this.listRunning().map(async (name) => {
+        try {
+          await this.stop(name);
+        } catch (e) {
+          EmulatorLogger.forEmulator(name).logLabeled(
+            "WARN",
+            name,
+            `Error stopping ${Constants.description(name)}`
+          );
+        }
+      })
+    );
   }
 
   static isRunning(emulator: Emulators): boolean {
@@ -49,6 +67,12 @@ export class EmulatorRegistry {
     return ALL_EMULATORS.filter((name) => this.isRunning(name));
   }
 
+  static listRunningWithInfo(): EmulatorInfo[] {
+    return this.listRunning()
+      .map((emulator) => this.getInfo(emulator) as EmulatorInfo)
+      .filter((info) => typeof info !== "undefined");
+  }
+
   static get(emulator: Emulators): EmulatorInstance | undefined {
     return this.INSTANCES.get(emulator);
   }
diff --git a/src/emulator/types.ts b/src/emulator/types.ts
index 1d35391dc05..0a5000eefa8 100644
--- a/src/emulator/types.ts
+++ b/src/emulator/types.ts
@@ -96,8 +96,10 @@ export interface EmulatorInstance {
 }
 
 export interface EmulatorInfo {
+  name: Emulators;
   host: string;
   port: number;
+  pid?: number;
 }
 
 export interface DownloadableEmulatorCommand {
diff --git a/src/emulator/ui.ts b/src/emulator/ui.ts
index e765662f406..e3bd495db37 100644
--- a/src/emulator/ui.ts
+++ b/src/emulator/ui.ts
@@ -45,8 +45,10 @@ export class EmulatorUI implements EmulatorInstance {
 
   getInfo(): EmulatorInfo {
     return {
+      name: this.getName(),
       host: this.args.host,
       port: this.args.port,
+      pid: downloadableEmulators.getPID(Emulators.FIRESTORE),
     };
   }
 
diff --git a/src/test/emulators/commandUtils.spec.ts b/src/test/emulators/commandUtils.spec.ts
index e4964ac9235..2b1b2253325 100644
--- a/src/test/emulators/commandUtils.spec.ts
+++ b/src/test/emulators/commandUtils.spec.ts
@@ -5,9 +5,7 @@ import { EXPORT_ON_EXIT_USAGE_ERROR } from "../../emulator/commandUtils";
 
 describe("commandUtils", () => {
   const testSetExportOnExitOptions = (options: any): any => {
-    console.log(options);
     commandUtils.setExportOnExitOptions(options);
-    console.log(options);
     return options;
   };
 
diff --git a/src/test/emulators/fakeEmulator.ts b/src/test/emulators/fakeEmulator.ts
index da68cc092bc..5321d375a57 100644
--- a/src/test/emulators/fakeEmulator.ts
+++ b/src/test/emulators/fakeEmulator.ts
@@ -26,6 +26,7 @@ export class FakeEmulator implements EmulatorInstance {
   }
   getInfo(): EmulatorInfo {
     return {
+      name: this.getName(),
       host: this.host,
       port: this.port,
     };

From 4a9cea2b6301663c4453d968e0defe6e8a362952 Mon Sep 17 00:00:00 2001
From: Michael Krens <mkrens@gmail.com>
Date: Sat, 11 Jul 2020 14:51:45 +0200
Subject: [PATCH 9/9] add warning when we can't find the import metadata file
 (due to interrupted auto export)

---
 src/emulator/controller.ts | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/src/emulator/controller.ts b/src/emulator/controller.ts
index 39176e4d25e..aa82a0c1c8d 100644
--- a/src/emulator/controller.ts
+++ b/src/emulator/controller.ts
@@ -291,7 +291,14 @@ export async function startAll(options: any, noUi: boolean = false): Promise<voi
           .toString()
       ) as ExportMetadata;
     } else {
-      // could happen when an export was interrupted...
+      // could happen when an export was interrupted mid-export...
+      EmulatorLogger.forEmulator(Emulators.HUB).logLabeled(
+        "WARN",
+        "emulators",
+        `Import/Export metadata file does not exist. ${clc.bold(
+          "Skipping data import!"
+        )} Metadata file location: ${importFilePath}`
+      );
     }
   }