fix: replace processService with cleanupService

Replace processService with cleanupService where appropriate. The cleanupService allows execution of code after CLI has died. `processService` was used to handle some events, but it caused more issues than benefits. So remove it from the codebase.

Author: rosen-vladimirov

lib/common/bootstrap.ts

@@ -85,7 +85,6 @@ $injector.require("iOSEmulatorServices", "./mobile/ios/simulator/ios-emulator-se
 $injector.require("wp8EmulatorServices", "./mobile/wp8/wp8-emulator-services");
 
 $injector.require("autoCompletionService", "./services/auto-completion-service");
-$injector.require("processService", "./services/process-service");
 $injector.requirePublic("settingsService", "./services/settings-service");
 $injector.require("opener", "./opener");
 $injector.require("microTemplateService", "./services/micro-templating-service");

lib/common/declarations.d.ts

@@ -1466,11 +1466,6 @@ interface INet {
 	waitForPortToListen(waitForPortListenData: IWaitForPortListenData): Promise<boolean>;
 }
 
-interface IProcessService {
-	listenersCount: number;
-	attachToProcessExitSignals(context: any, callback: () => void): void;
-}
-
 interface IDependencyInformation {
 	name: string;
 	version?: string;

lib/common/http-client.ts

@@ -19,15 +19,9 @@ export class HttpClient implements Server.IHttpClient {
 	private cleanupData: ICleanupRequestData[];
 
 	constructor(private $logger: ILogger,
-		private $processService: IProcessService,
 		private $proxyService: IProxyService,
 		private $staticConfig: Config.IStaticConfig) {
 		this.cleanupData = [];
-		this.$processService.attachToProcessExitSignals(this, () => {
-			this.cleanupData.forEach(d => {
-				this.cleanupAfterRequest(d);
-			});
-		});
 	}
 
 	public async httpRequest(options: any, proxySettings?: IProxySettings): Promise<Server.IResponse> {

lib/common/mobile/android/logcat-helper.ts

@@ -16,7 +16,6 @@ export class LogcatHelper implements Mobile.ILogcatHelper {
 		private $devicePlatformsConstants: Mobile.IDevicePlatformsConstants,
 		private $logger: ILogger,
 		private $injector: IInjector,
-		private $processService: IProcessService,
 		private $devicesService: Mobile.IDevicesService) {
 		this.mapDevicesLoggingData = Object.create(null);
 	}
@@ -53,8 +52,6 @@ export class LogcatHelper implements Mobile.ILogcatHelper {
 				const lineText = line.toString();
 				this.$deviceLogProvider.logData(lineText, this.$devicePlatformsConstants.Android, deviceIdentifier);
 			});
-
-			this.$processService.attachToProcessExitSignals(this, logcatStream.kill);
 		}
 	}
 
@@ -72,8 +69,6 @@ export class LogcatHelper implements Mobile.ILogcatHelper {
 			logcatDumpStream.removeAllListeners();
 			lineStream.removeAllListeners();
 		});
-
-		this.$processService.attachToProcessExitSignals(this, logcatDumpStream.kill);
 	}
 
 	/**

lib/common/mobile/ios/device/ios-device-operations.ts

@@ -9,16 +9,11 @@ export class IOSDeviceOperations extends EventEmitter implements IIOSDeviceOpera
 	public shouldDispose: boolean;
 	private deviceLib: IOSDeviceLib.IOSDeviceLib;
 
-	constructor(private $logger: ILogger,
-		private $processService: IProcessService) {
+	constructor(private $logger: ILogger) {
 		super();
 
 		this.isInitialized = false;
 		this.shouldDispose = true;
-		this.$processService.attachToProcessExitSignals(this, () => {
-			this.setShouldDispose(true);
-			this.dispose();
-		});
 	}
 
 	public async install(ipaPath: string, deviceIdentifiers: string[], errorHandler: DeviceOperationErrorHandler): Promise<IOSDeviceResponse> {

lib/common/mobile/ios/device/ios-device.ts

@@ -20,7 +20,6 @@ export class IOSDevice extends IOSDeviceBase {
 		protected $deviceLogProvider: Mobile.IDeviceLogProvider,
 		protected $lockService: ILockService,
 		private $iOSSocketRequestExecutor: IiOSSocketRequestExecutor,
-		protected $processService: IProcessService,
 		private $devicePlatformsConstants: Mobile.IDevicePlatformsConstants,
 		private $iOSDeviceProductNameMapper: Mobile.IiOSDeviceProductNameMapper,
 		private $iosDeviceOperations: IIOSDeviceOperations,

lib/common/mobile/ios/ios-device-base.ts

@@ -6,7 +6,6 @@ export abstract class IOSDeviceBase implements Mobile.IiOSDevice {
 	protected abstract $errors: IErrors;
 	protected abstract $deviceLogProvider: Mobile.IDeviceLogProvider;
 	protected abstract $iOSDebuggerPortService: IIOSDebuggerPortService;
-	protected abstract $processService: IProcessService;
 	protected abstract $lockService: ILockService;
 	abstract deviceInfo: Mobile.IDeviceInfo;
 	abstract applicationManager: Mobile.IDeviceApplicationManager;
@@ -33,8 +32,6 @@ export abstract class IOSDeviceBase implements Mobile.IiOSDevice {
 					this.cachedSockets[appId].on("close", async () => {
 						await this.destroyDebugSocket(appId);
 					});
-
-					this.$processService.attachToProcessExitSignals(this, () => this.destroyDebugSocket(appId));
 				}
 
 				return this.cachedSockets[appId];

lib/common/mobile/ios/simulator/ios-simulator-application-manager.ts

@@ -15,18 +15,10 @@ export class IOSSimulatorApplicationManager extends ApplicationManagerBase {
 		private device: Mobile.IiOSDevice,
 		private $options: IOptions,
 		private $fs: IFileSystem,
-		private $processService: IProcessService,
 		private $deviceLogProvider: Mobile.IDeviceLogProvider,
 		$logger: ILogger,
 		$hooksService: IHooksService) {
 		super($logger, $hooksService);
-		this.$processService.attachToProcessExitSignals(this, () => {
-			for (const appId in this._lldbProcesses) {
-				/* tslint:disable:no-floating-promises */
-				this.detachNativeDebugger(appId);
-				/* tslint:enable:no-floating-promises */
-			}
-		});
 	}
 
 	public async getInstalledApplications(): Promise<string[]> {

lib/common/mobile/ios/simulator/ios-simulator-device.ts

@@ -22,8 +22,7 @@ export class IOSSimulator extends IOSDeviceBase implements Mobile.IiOSDevice {
 		private $iOSEmulatorServices: Mobile.IiOSSimulatorService,
 		private $iOSNotification: IiOSNotification,
 		private $iOSSimulatorLogProvider: Mobile.IiOSSimulatorLogProvider,
-		private $logger: ILogger,
-		protected $processService: IProcessService) {
+		private $logger: ILogger) {
 		super();
 		this.applicationManager = this.$injector.resolve(applicationManagerPath.IOSSimulatorApplicationManager, { iosSim: this.$iOSSimResolver.iOSSim, device: this });
 		this.fileSystem = this.$injector.resolve(fileSystemPath.IOSSimulatorFileSystem, { iosSim: this.$iOSSimResolver.iOSSim });

lib/common/mobile/ios/simulator/ios-simulator-log-provider.ts

@@ -8,7 +8,6 @@ export class IOSSimulatorLogProvider extends EventEmitter implements Mobile.IiOS
 
 	constructor(private $iOSSimResolver: Mobile.IiOSSimResolver,
 		private $logger: ILogger,
-		private $processService: IProcessService,
 		private $devicePlatformsConstants: Mobile.IDevicePlatformsConstants,
 		private $deviceLogProvider: Mobile.IDeviceLogProvider) {
 			super();
@@ -47,8 +46,6 @@ export class IOSSimulatorLogProvider extends EventEmitter implements Mobile.IiOS
 				deviceLogChildProcess.stderr.on("data", action.bind(this));
 			}
 
-			this.$processService.attachToProcessExitSignals(this, deviceLogChildProcess.kill);
-
 			this.simulatorsLoggingEnabled[deviceId] = true;
 			this.simulatorsLogProcess[deviceId] = deviceLogChildProcess;
 		}

lib/common/mobile/mobile-core/android-process-service.ts

@@ -1,8 +1,7 @@
 import { EOL } from "os";
-import * as shelljs from "shelljs";
 import { DeviceAndroidDebugBridge } from "../android/device-android-debug-bridge";
 import { TARGET_FRAMEWORK_IDENTIFIERS } from "../../constants";
-import { exported, cache } from "../../decorators";
+import { exported } from "../../decorators";
 
 export class AndroidProcessService implements Mobile.IAndroidProcessService {
 	private _devicesAdbs: IDictionary<Mobile.IDeviceAndroidDebugBridge>;
@@ -11,7 +10,8 @@ export class AndroidProcessService implements Mobile.IAndroidProcessService {
 	constructor(private $errors: IErrors,
 		private $injector: IInjector,
 		private $net: INet,
-		private $processService: IProcessService) {
+		private $cleanupService: ICleanupService,
+		private $staticConfig: IStaticConfig) {
 		this._devicesAdbs = {};
 		this._forwardedLocalPorts = {};
 	}
@@ -22,8 +22,6 @@ export class AndroidProcessService implements Mobile.IAndroidProcessService {
 	}
 
 	public async mapAbstractToTcpPort(deviceIdentifier: string, appIdentifier: string, framework: string): Promise<string> {
-		this.tryAttachToProcessExitSignals();
-
 		const adb = await this.setupForPortForwarding({ deviceIdentifier, appIdentifier });
 
 		const processId = (await this.getProcessIds(adb, [appIdentifier]))[appIdentifier];
@@ -120,16 +118,16 @@ export class AndroidProcessService implements Mobile.IAndroidProcessService {
 
 		if (!localPort) {
 			localPort = await this.$net.getFreePort();
-			await adb.executeCommand(["forward", `tcp:${localPort}`, portForwardInputData.abstractPort], {deviceIdentifier: portForwardInputData.deviceIdentifier});
+			await adb.executeCommand(["forward", `tcp:${localPort}`, portForwardInputData.abstractPort], { deviceIdentifier: portForwardInputData.deviceIdentifier });
 		}
 
 		this._forwardedLocalPorts[portForwardInputData.deviceIdentifier] = localPort;
+		// TODO: use correct path to adb
+		await this.$cleanupService.addCleanupAction({ command: await this.$staticConfig.getAdbFilePath(), args: ["-s", portForwardInputData.deviceIdentifier, "forward", "--remove", `tcp:${localPort}`] });
 		return localPort && +localPort;
 	}
 
 	private async setupForPortForwarding(portForwardInputData?: Mobile.IPortForwardDataBase): Promise<Mobile.IDeviceAndroidDebugBridge> {
-		this.tryAttachToProcessExitSignals();
-
 		const adb = this.getAdb(portForwardInputData.deviceIdentifier);
 
 		return adb;
@@ -279,18 +277,6 @@ export class AndroidProcessService implements Mobile.IAndroidProcessService {
 
 		return result;
 	}
-
-	@cache()
-	private tryAttachToProcessExitSignals(): void {
-		this.$processService.attachToProcessExitSignals(this, () => {
-			_.each(this._forwardedLocalPorts, (port: number, deviceIdentifier: string) => {
-				// We need to use shelljs here instead of $adb because listener functions of exit, SIGINT and SIGTERM must only perform synchronous operations.
-				// The Node.js process will exit immediately after calling the 'exit' event listeners causing any additional work still queued in the event loop to be abandoned.
-				// See the official documentation for more information and examples - https://nodejs.org/dist/latest-v6.x/docs/api/process.html#process_event_exit.
-				shelljs.exec(`adb -s ${deviceIdentifier} forward --remove tcp:${port}`);
-			});
-		});
-	}
 }
 
 $injector.register("androidProcessService", AndroidProcessService);

lib/common/services/lock-service.ts

@@ -4,7 +4,6 @@ import { cache } from "../decorators";
 import { getHash } from "../helpers";
 
 export class LockService implements ILockService {
-	private currentlyLockedFiles: string[] = [];
 
 	@cache()
 	private get defaultLockFilePath(): string {
@@ -28,14 +27,7 @@ export class LockService implements ILockService {
 
 	constructor(private $fs: IFileSystem,
 		private $settingsService: ISettingsService,
-		private $processService: IProcessService) {
-		this.$processService.attachToProcessExitSignals(this, () => {
-			const locksToRemove = _.clone(this.currentlyLockedFiles);
-			for (const lockToRemove of locksToRemove) {
-				lockfile.unlockSync(lockToRemove);
-				this.cleanLock(lockToRemove);
-			}
-		});
+		private $cleanupService: ICleanupService) {
 	}
 
 	public async executeActionWithLock<T>(action: () => Promise<T>, lockFilePath?: string, lockOpts?: ILockOptions): Promise<T> {
@@ -51,29 +43,29 @@ export class LockService implements ILockService {
 
 	public async lock(lockFilePath?: string, lockOpts?: ILockOptions): Promise<() => void> {
 		const { filePath, fileOpts } = this.getLockFileSettings(lockFilePath, lockOpts);
-		this.currentlyLockedFiles.push(filePath);
+		await this.$cleanupService.addCleanupDeleteAction(filePath);
 		this.$fs.writeFile(filePath, "");
 
 		try {
 			const releaseFunc = await lockfile.lock(filePath, fileOpts);
 			return async () => {
 				await releaseFunc();
-				this.cleanLock(filePath);
+				await this.cleanLock(filePath);
 			};
 		} catch (err) {
 			throw new Error(`Timeout while waiting for lock "${filePath}"`);
 		}
 	}
 
-	public unlock(lockFilePath?: string): void {
+	public async unlock(lockFilePath?: string): Promise<void> {
 		const { filePath } = this.getLockFileSettings(lockFilePath);
 		lockfile.unlockSync(filePath);
-		this.cleanLock(filePath);
+		await this.cleanLock(filePath);
 	}
 
-	private cleanLock(lockPath: string): void {
-		_.remove(this.currentlyLockedFiles, e => e === lockPath);
+	private async cleanLock(lockPath: string): Promise<void> {
 		this.$fs.deleteFile(lockPath);
+		await this.$cleanupService.removeCleanupDeleteAction(lockPath);
 	}
 
 	private getLockFileSettings(filePath?: string, fileOpts?: ILockOptions): { filePath: string, fileOpts: ILockOptions } {

lib/common/services/process-service.ts

@@ -89,10 +89,6 @@ function createTestInjector(testScenario: ITestScenario): IInjector {
 		return testScenario.isInteractive;
 	};
 
-	testInjector.register("processService", {
-		attachToProcessExitSignals: (context: any, callback: () => void): void => (undefined)
-	});
-
 	testInjector.register("childProcess", {});
 	testInjector.register("projectDataService", {});
 	testInjector.register("mobileHelper", {});

lib/common/test/unit-tests/analytics-service.ts

@@ -60,11 +60,6 @@ function createTestInjector(): IInjector {
 		}
 	});
 	injector.register("devicePlatformsConstants", { Android: "Android" });
-	injector.register("processService", {
-		attachToProcessExitSignals(context: any, callback: () => void): void {
-			//left blank intentionally because of lint
-		},
-	});
 	injector.register("deviceLogProvider", {
 		logData(line: string, platform: string, deviceIdentifier: string): void {
 			//left blank intentionally because of lint

lib/common/test/unit-tests/mobile/android/logcat-helper.ts

@@ -160,9 +160,6 @@ function createTestInjector(): IInjector {
 	testInjector.register("iOSEmulatorServices", IOSEmulatorServices);
 	testInjector.register("messages", Messages);
 	testInjector.register("prompter", {});
-	testInjector.register("processService", {
-		attachToProcessExitSignals: (context: any, callback: () => Promise<any>) => { /* no implementation required */ }
-	});
 
 	testInjector.register("mobileHelper", {
 		platformNames: ["ios", "android"],

lib/common/test/unit-tests/mobile/devices-service.ts

@@ -5,7 +5,7 @@ import { assert } from "chai";
 import { DeviceDiscoveryEventNames, CONNECTED_STATUS } from "../../../constants";
 import { DevicePlatformsConstants } from "../../../mobile/device-platforms-constants";
 import { ErrorsStub, CommonLoggerStub, HooksServiceStub, LockServiceStub } from "../stubs";
-import { FileSystemStub, ChildProcessStub, ProcessServiceStub } from "../../../../../test/stubs";
+import { FileSystemStub, ChildProcessStub } from "../../../../../test/stubs";
 
 let currentlyRunningSimulators: Mobile.IiSimDevice[];
 
@@ -41,7 +41,6 @@ function createTestInjector(): IInjector {
 	injector.register("deviceLogProvider", {});
 	injector.register("iOSEmulatorServices", {});
 	injector.register("iOSNotification", {});
-	injector.register("processService", ProcessServiceStub);
 	injector.register("options", {});
 	injector.register("hooksService", HooksServiceStub);
 	injector.register("logger", CommonLoggerStub);