feat: introduce cleanup child process

In case CLI uses non-Nodejs resources, there's nowhere to clean them as CLI does not handle the SIGINT (Ctrl+C) signal. For example, when we debug on Android, we setup port forward with `adb` command.
Once CLI process is about to stop, the adb forward should be removed, but currently there's nowhere to do it.
So, to handle this, introduce a new cleanup child process. It is detached and unrefed. As we have IPC communication with it, when CLI exits gracefully (i.e. when we are not in a long living command which usually exits with Ctrl+C), we should manually disconnect the process. Whenever some external resources must be cleaned, the actual cleanup commands that should be executed are sent to the new process. It caches them and once the CLI finishes its work, the cleanup process will receive `disconnect` event.
At this point the cleanup process will execute all cleanup actions and after that it will exit.
The idea of the process is very similar to the process used for analytics tracking, so several interfaces were reused. They are just renamed to have a better meaning for the new used cases.
Introduce `--cleanupLogFile` option, which allows the user to specify path to file, where information about all actions will be logged. Also expose a method in CLI's public API that allows setting this file when using CLI as a library.

Author: rosen-vladimirov

lib/bootstrap.ts

@@ -192,3 +192,4 @@ $injector.require("qrCodeTerminalService", "./services/qr-code-terminal-service"
 $injector.require("testInitializationService", "./services/test-initialization-service");
 
 $injector.require("networkConnectivityValidator", "./helpers/network-connectivity-validator");
+$injector.requirePublic("cleanupService", "./services/cleanup-service");

lib/common/services/commands-service.ts

@@ -28,7 +28,8 @@ export class CommandsService implements ICommandsService {
 		private $helpService: IHelpService,
 		private $extensibilityService: IExtensibilityService,
 		private $optionsTracker: IOptionsTracker,
-		private $projectDataService: IProjectDataService) {
+		private $projectDataService: IProjectDataService,
+		private $cleanupService: ICleanupService) {
 			let projectData = null;
 			try {
 				projectData = this.$projectDataService.getProjectData();
@@ -37,6 +38,7 @@ export class CommandsService implements ICommandsService {
 			}
 
 			this.$options.setupOptions(projectData);
+			this.$cleanupService.setShouldDispose(this.$options.justlaunch || !this.$options.watch);
 	}
 
 	public allCommands(opts: { includeDevCommands: boolean }): string[] {

lib/declarations.d.ts

@@ -570,6 +570,7 @@ interface IOptions extends IRelease, IDeviceIdentifier, IJustLaunch, IAvd, IAvai
 	analyticsLogFile: string;
 	performance: Object;
 	setupOptions(projectData: IProjectData): void;
+	cleanupLogFile: string;
 }
 
 interface IEnvOptions {

lib/definitions/cleanup-service.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Descibes the cleanup service which allows scheduling cleanup actions
+ * The actions will be executed once CLI process exits.
+ */
+interface ICleanupService extends IShouldDispose, IDisposable {
+	/**
+	 * Add new action to be executed when CLI process exits.
+	 * @param {ICleanupAction} action The action that should be executed, including command and args.
+	 * @returns {Promise<void>}
+	 */
+	addCleanupAction(action: ICleanupAction): Promise<void>;
+
+	/**
+	 * Sets the file in which the cleanup process will write its logs.
+	 * This method must be called before starting the cleanup process, i.e. when CLI is initialized.
+	 * @param {string} filePath Path to file where the logs will be written. The logs are appended to the passed file.
+	 * @returns {void}
+	 */
+	setCleanupLogFile(filePath: string): void
+}

lib/definitions/file-log-service.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Describes message that needs to be logged in the analytics logging file.
+ */
+interface IFileLogMessage {
+	message: string;
+	type?: FileLogMessageType;
+}
+
+/**
+ * Describes methods to get local logs from analytics tracking.
+ */
+interface IFileLogService {
+	/**
+	 * Logs specified message to the previously specified file.
+	 * @param {IFileLogMessage} fileLogMessage The message that has to be written to the logs file.
+	 * @returns {void}
+	 */
+	logData(fileLogMessage: IFileLogMessage): void;
+}

lib/detached-processes/cleanup-process-definitions.d.ts

@@ -0,0 +1,28 @@
+interface ICleanupAction {
+	/**
+	 * Executable to be started.
+	 */
+	command: string;
+
+	/**
+	 * Arguments that will be passed to the child process
+	 */
+	args: string[];
+	/**
+	 * Timeout to execute the action.
+	 */
+	timeout?: number;
+}
+
+interface ICleanupProcessMessage {
+	/**
+	 * Type of the action
+	 */
+	actionType: CleanupProcessMessageType;
+
+	/**
+	 * Describes the action that must be executed
+	 */
+	action: ICleanupAction;
+}
+

lib/detached-processes/cleanup-process.ts

@@ -0,0 +1,68 @@
+// NOTE: This file is used to clean up resources used by CLI, when the CLI is killed.
+// The instances here are not shared with the ones in main CLI process.
+import * as fs from "fs";
+import { FileLogService } from "./file-log-service";
+
+const pathToBootstrap = process.argv[2];
+if (!pathToBootstrap || !fs.existsSync(pathToBootstrap)) {
+	throw new Error("Invalid path to bootstrap.");
+}
+
+const logFile = process.argv[3];
+// After requiring the bootstrap we can use $injector
+require(pathToBootstrap);
+
+const fileLogService = $injector.resolve<IFileLogService>(FileLogService, { logFile });
+fileLogService.logData({ message: "Initializing Cleanup process." });
+
+const actionsToExecute: ICleanupAction[] = [];
+
+const executeCleanup = async () => {
+	const $childProcess = $injector.resolve<IChildProcess>("childProcess");
+	for (const action of actionsToExecute) {
+		try {
+			fileLogService.logData({ message: `Start executing action: ${JSON.stringify(action)}` });
+
+			// TODO: Add timeout for each action here
+			await $childProcess.trySpawnFromCloseEvent(action.command, action.args);
+			fileLogService.logData({ message: `Successfully executed action: ${JSON.stringify(action)}` });
+		} catch (err) {
+			fileLogService.logData({ message: `Unable to execute action: ${JSON.stringify(action)}`, type: FileLogMessageType.Error });
+		}
+	}
+
+	fileLogService.logData({ message: `cleanup-process finished` });
+	process.exit();
+};
+
+const addCleanupAction = (newAction: ICleanupAction): void => {
+	if (!_.some(actionsToExecute, currentAction => _.isEqual(currentAction, newAction))) {
+		fileLogService.logData({ message: `cleanup-process added action for execution: ${JSON.stringify(newAction)}` });
+		actionsToExecute.push(newAction);
+	} else {
+		fileLogService.logData({ message: `cleanup-process will not add action for execution as it has been added already: ${JSON.stringify(newAction)}` });
+	}
+};
+
+process.on("message", async (cleanupProcessMessage: ICleanupProcessMessage) => {
+	fileLogService.logData({ message: `cleanup-process received message of type: ${JSON.stringify(cleanupProcessMessage)}` });
+
+	switch (cleanupProcessMessage.actionType) {
+		case CleanupProcessMessageType.AddCleanAction:
+			addCleanupAction(cleanupProcessMessage.action);
+			break;
+		default:
+			fileLogService.logData({ message: `Unable to handle message of type ${cleanupProcessMessage.actionType}. Full message is ${JSON.stringify(cleanupProcessMessage)}`, type: FileLogMessageType.Error });
+			break;
+	}
+
+});
+
+process.on("disconnect", async () => {
+	fileLogService.logData({ message: "cleanup-process received process.disconnect event" });
+	await executeCleanup();
+});
+
+fileLogService.logData({ message: `cleanup-process will send ${DetachedProcessMessages.ProcessReadyToReceive} message` });
+
+process.send(DetachedProcessMessages.ProcessReadyToReceive);

lib/detached-processes/detached-process-enums.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Defines messages used in communication between CLI's process and analytics subprocesses.
+ */
+declare const enum DetachedProcessMessages {
+	/**
+	 * The detached process is initialized and is ready to receive information for tracking.
+	 */
+	ProcessReadyToReceive = "ProcessReadyToReceive"
+}
+
+/**
+ * Defines the type of the messages that should be written in the local analyitcs log file (in case such is specified).
+ */
+declare const enum FileLogMessageType {
+	/**
+	 * Information message. This is the default value in case type is not specified.
+	 */
+	Info = "Info",
+
+	/**
+	 * Error message - used to indicate that some action did not succeed.
+	 */
+	Error = "Error"
+}
+
+declare const enum CleanupProcessMessageType {
+	AddCleanAction = "AddCleanAction",
+}

lib/detached-processes/file-log-service.ts

@@ -0,0 +1,15 @@
+import { EOL } from "os";
+import { getFixedLengthDateString } from "../common/helpers";
+
+export class FileLogService implements IFileLogService {
+	constructor(private $fs: IFileSystem,
+		private logFile: string) { }
+
+	public logData(fileLoggingMessage: IFileLogMessage): void {
+		if (this.logFile && fileLoggingMessage && fileLoggingMessage.message) {
+			fileLoggingMessage.type = fileLoggingMessage.type || FileLogMessageType.Info;
+			const formattedDate = getFixedLengthDateString();
+			this.$fs.appendFile(this.logFile, `[${formattedDate}] [${fileLoggingMessage.type}] ${fileLoggingMessage.message}${EOL}`);
+		}
+	}
+}

lib/options.ts

@@ -147,6 +147,7 @@ export class Options {
 			default: { type: OptionType.Boolean, hasSensitiveValue: false },
 			count: { type: OptionType.Number, hasSensitiveValue: false },
 			analyticsLogFile: { type: OptionType.String, hasSensitiveValue: true },
+			cleanupLogFile: { type: OptionType.String, hasSensitiveValue: true },
 			hooks: { type: OptionType.Boolean, default: true, hasSensitiveValue: false },
 			link: { type: OptionType.Boolean, default: false, hasSensitiveValue: false },
 			aab: { type: OptionType.Boolean, hasSensitiveValue: false },