chore: rename interfaces for cleanup

rosen-vladimirov · rosen-vladimirov · commit 1b8a954c031f · 2019-04-15T09:46:49.000+03:00
Improve interfaces and enums for cleanup services.
diff --git a/lib/common/mobile/mobile-core/android-process-service.ts b/lib/common/mobile/mobile-core/android-process-service.ts
@@ -122,7 +122,7 @@ export class AndroidProcessService implements Mobile.IAndroidProcessService {
 		}
 
 		this._forwardedLocalPorts[portForwardInputData.deviceIdentifier] = localPort;
-		await this.$cleanupService.addCleanupAction({ command: await this.$staticConfig.getAdbFilePath(), args: ["-s", portForwardInputData.deviceIdentifier, "forward", "--remove", `tcp:${localPort}`] });
+		await this.$cleanupService.addCleanupCommand({ command: await this.$staticConfig.getAdbFilePath(), args: ["-s", portForwardInputData.deviceIdentifier, "forward", "--remove", `tcp:${localPort}`] });
 		return localPort && +localPort;
 	}
 
diff --git a/lib/definitions/cleanup-service.d.ts b/lib/definitions/cleanup-service.d.ts
@@ -5,18 +5,18 @@
 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.
+	 * @param {ISpawnCommandInfo} commandInfo The command that should be executed, including command and args.
 	 * @returns {Promise<void>}
 	 */
-	addCleanupAction(action: ICleanupAction): Promise<void>;
+	addCleanupCommand(commandInfo: ISpawnCommandInfo): Promise<void>;
 
 	/**
 	 * Remove action to be executed when CLI process exits.
 	 * NOTE: The action should be added in the action list by calling `addCleanupAction` first.
-	 * @param {ICleanupAction} action The action that should be removed from cleanup execution, including command and args.
+	 * @param {ISpawnCommandInfo} commandInfo The command that should be removed from cleanup execution, including command and args.
 	 * @returns {Promise<void>}
 	 */
-	removeCleanupAction(action: ICleanupAction): Promise<void>
+	removeCleanupCommand(commandInfo: ISpawnCommandInfo): Promise<void>
 
 	/**
 	 * Sets the file in which the cleanup process will write its logs.
diff --git a/lib/detached-processes/cleanup-process-definitions.d.ts b/lib/detached-processes/cleanup-process-definitions.d.ts
@@ -1,4 +1,4 @@
-interface ICleanupAction {
+interface ISpawnCommandInfo {
 	/**
 	 * Executable to be started.
 	 */
@@ -8,27 +8,28 @@ interface ICleanupAction {
 	 * Arguments that will be passed to the child process
 	 */
 	args: string[];
+
 	/**
 	 * Timeout to execute the action.
 	 */
 	timeout?: number;
 }
 
-interface ICleanupProcessMessage {
+interface ICleanupMessageBase {
 	/**
-	 * Type of the action
+	 * Type of the message
 	 */
-	actionType: CleanupProcessMessageType;
+	messageType: CleanupProcessMessage;
 }
 
-interface ICleanupActionMessage extends ICleanupProcessMessage {
+interface ISpawnCommandCleanupMessage extends ICleanupMessageBase {
 	/**
-	 * Describes the action that must be executed
+	 * Describes the command that must be executed
 	 */
-	action: ICleanupAction;
+	commandInfo: ISpawnCommandInfo;
 }
 
-interface ICleanupDeleteActionMessage extends ICleanupProcessMessage {
+interface IDeleteFileCleanupMessage extends ICleanupMessageBase {
 	/**
 	 * Path to file/directory to be deleted.
 	 */
diff --git a/lib/detached-processes/cleanup-process.ts b/lib/detached-processes/cleanup-process.ts
@@ -17,19 +17,19 @@ require(pathToBootstrap);
 const fileLogService = $injector.resolve<IFileLogService>(FileLogService, { logFile });
 fileLogService.logData({ message: "Initializing Cleanup process." });
 
-const actionsToExecute: ICleanupAction[] = [];
+const commandsInfos: ISpawnCommandInfo[] = [];
 const filesToDelete: string[] = [];
 
 const executeCleanup = async () => {
 	const $childProcess = $injector.resolve<IChildProcess>("childProcess");
-	for (const action of actionsToExecute) {
+	for (const commandInfo of commandsInfos) {
 		try {
-			fileLogService.logData({ message: `Start executing action: ${JSON.stringify(action)}` });
+			fileLogService.logData({ message: `Start executing command: ${JSON.stringify(commandInfo)}` });
 
-			await $childProcess.trySpawnFromCloseEvent(action.command, action.args, {}, { throwError: true, timeout: action.timeout || 3000 });
-			fileLogService.logData({ message: `Successfully executed action: ${JSON.stringify(action)}` });
+			await $childProcess.trySpawnFromCloseEvent(commandInfo.command, commandInfo.args, {}, { throwError: true, timeout: commandInfo.timeout || 3000 });
+			fileLogService.logData({ message: `Successfully executed command: ${JSON.stringify(commandInfo)}` });
 		} catch (err) {
-			fileLogService.logData({ message: `Unable to execute action: ${JSON.stringify(action)}`, type: FileLogMessageType.Error });
+			fileLogService.logData({ message: `Unable to execute command: ${JSON.stringify(commandInfo)}`, type: FileLogMessageType.Error });
 		}
 	}
 
@@ -42,21 +42,21 @@ const executeCleanup = async () => {
 	process.exit();
 };
 
-const addCleanupAction = (newAction: ICleanupAction): void => {
-	if (_.some(actionsToExecute, currentAction => _.isEqual(currentAction, newAction))) {
-		fileLogService.logData({ message: `cleanup-process will not add action for execution as it has been added already: ${JSON.stringify(newAction)}` });
+const addCleanupAction = (commandInfo: ISpawnCommandInfo): void => {
+	if (_.some(commandsInfos, currentCommandInfo => _.isEqual(currentCommandInfo, commandInfo))) {
+		fileLogService.logData({ message: `cleanup-process will not add command for execution as it has been added already: ${JSON.stringify(commandInfo)}` });
 	} else {
-		fileLogService.logData({ message: `cleanup-process added action for execution: ${JSON.stringify(newAction)}` });
-		actionsToExecute.push(newAction);
+		fileLogService.logData({ message: `cleanup-process added command for execution: ${JSON.stringify(commandInfo)}` });
+		commandsInfos.push(commandInfo);
 	}
 };
 
-const removeCleanupAction = (actionToRemove: ICleanupAction): void => {
-	if (_.some(actionsToExecute, currentAction => _.isEqual(currentAction, actionToRemove))) {
-		_.remove(actionsToExecute, currentAction => _.isEqual(currentAction, actionToRemove));
-		fileLogService.logData({ message: `cleanup-process removed action for execution: ${JSON.stringify(actionToRemove)}` });
+const removeCleanupAction = (commandInfo: ISpawnCommandInfo): void => {
+	if (_.some(commandsInfos, currentCommandInfo => _.isEqual(currentCommandInfo, commandInfo))) {
+		_.remove(commandsInfos, currentCommandInfo => _.isEqual(currentCommandInfo, commandInfo));
+		fileLogService.logData({ message: `cleanup-process removed command for execution: ${JSON.stringify(commandInfo)}` });
 	} else {
-		fileLogService.logData({ message: `cleanup-process cannot remove action for execution as it has note been added before: ${JSON.stringify(actionToRemove)}` });
+		fileLogService.logData({ message: `cleanup-process cannot remove command for execution as it has note been added before: ${JSON.stringify(commandInfo)}` });
 	}
 };
 
@@ -82,24 +82,24 @@ const removeDeleteAction = (filePath: string): void => {
 	}
 };
 
-process.on("message", async (cleanupProcessMessage: ICleanupProcessMessage) => {
+process.on("message", async (cleanupProcessMessage: ICleanupMessageBase) => {
 	fileLogService.logData({ message: `cleanup-process received message of type: ${JSON.stringify(cleanupProcessMessage)}` });
 
-	switch (cleanupProcessMessage.actionType) {
-		case CleanupProcessMessageType.AddCleanAction:
-			addCleanupAction((<ICleanupActionMessage>cleanupProcessMessage).action);
+	switch (cleanupProcessMessage.messageType) {
+		case CleanupProcessMessage.AddCleanCommand:
+			addCleanupAction((<ISpawnCommandCleanupMessage>cleanupProcessMessage).commandInfo);
 			break;
-		case CleanupProcessMessageType.RemoveCleanAction:
-			removeCleanupAction((<ICleanupActionMessage>cleanupProcessMessage).action);
+		case CleanupProcessMessage.RemoveCleanCommand:
+			removeCleanupAction((<ISpawnCommandCleanupMessage>cleanupProcessMessage).commandInfo);
 			break;
-		case CleanupProcessMessageType.AddDeleteAction:
-			addDeleteAction((<ICleanupDeleteActionMessage>cleanupProcessMessage).filePath);
+		case CleanupProcessMessage.AddDeleteFileAction:
+			addDeleteAction((<IDeleteFileCleanupMessage>cleanupProcessMessage).filePath);
 			break;
-		case CleanupProcessMessageType.RemoveDeleteAction:
-			removeDeleteAction((<ICleanupDeleteActionMessage>cleanupProcessMessage).filePath);
+		case CleanupProcessMessage.RemoveDeleteFileAction:
+			removeDeleteAction((<IDeleteFileCleanupMessage>cleanupProcessMessage).filePath);
 			break;
 		default:
-			fileLogService.logData({ message: `Unable to handle message of type ${cleanupProcessMessage.actionType}. Full message is ${JSON.stringify(cleanupProcessMessage)}`, type: FileLogMessageType.Error });
+			fileLogService.logData({ message: `Unable to handle message of type ${cleanupProcessMessage.messageType}. Full message is ${JSON.stringify(cleanupProcessMessage)}`, type: FileLogMessageType.Error });
 			break;
 	}
 
diff --git a/lib/detached-processes/detached-process-enums.d.ts b/lib/detached-processes/detached-process-enums.d.ts
@@ -23,25 +23,25 @@ declare const enum FileLogMessageType {
 	Error = "Error"
 }
 
-declare const enum CleanupProcessMessageType {
+declare const enum CleanupProcessMessage {
 	/**
-	 * This type of action defines that cleanup procedure should execute specific action.
+	 * This type of message defines that cleanup procedure should execute specific command.
 	 */
-	AddCleanAction = "AddCleanAction",
+	AddCleanCommand = "AddCleanCommand",
 
 	/**
-	 * This type of action defines that cleanup procedure should not execute previously defined cleanup action.
+	 * This type of message defines that cleanup procedure should not execute previously defined cleanup command.
 	 */
-	RemoveCleanAction = "RemoveCleanAction",
+	RemoveCleanCommand = "RemoveCleanCommand",
 
 	/**
-	 * This type of action defines that cleanup procedure should delete specified files.
+	 * This type of message defines that cleanup procedure should delete specified files.
 	 */
-	AddDeleteAction = "AddDeleteAction",
+	AddDeleteFileAction = "AddDeleteFileAction",
 
 	/**
-	 * This type of action defines the cleanup procedure should not delete previously specified file.
+	 * This type of message defines the cleanup procedure should not delete previously specified file.
 	 */
-	RemoveDeleteAction = "RemoveDeleteAction",
+	RemoveDeleteFileAction = "RemoveDeleteFileAction",
 
 }
diff --git a/lib/services/android-device-debug-service.ts b/lib/services/android-device-debug-service.ts
@@ -71,7 +71,7 @@ export class AndroidDeviceDebugService extends DebugServiceBase implements IDevi
 			await this.unixSocketForward(port, `${unixSocketName}`);
 		}
 
-		await this.$cleanupService.addCleanupAction({ command: await this.$staticConfig.getAdbFilePath(), args: ["-s", deviceId, "forward", "--remove", `tcp:${port}`] });
+		await this.$cleanupService.addCleanupCommand({ command: await this.$staticConfig.getAdbFilePath(), args: ["-s", deviceId, "forward", "--remove", `tcp:${port}`] });
 
 		return port;
 	}
diff --git a/lib/services/cleanup-service.ts b/lib/services/cleanup-service.ts
@@ -15,24 +15,24 @@ export class CleanupService implements ICleanupService {
 
 	public shouldDispose = false;
 
-	public async addCleanupAction(action: ICleanupAction): Promise<void> {
+	public async addCleanupCommand(commandInfo: ISpawnCommandInfo): Promise<void> {
 		const cleanupProcess = await this.getCleanupProcess();
-		cleanupProcess.send(<ICleanupProcessMessage>{ actionType: CleanupProcessMessageType.AddCleanAction, action });
+		cleanupProcess.send(<ISpawnCommandCleanupMessage>{ messageType: CleanupProcessMessage.AddCleanCommand, commandInfo });
 	}
 
-	public async removeCleanupAction(action: ICleanupAction): Promise<void> {
+	public async removeCleanupCommand(commandInfo: ISpawnCommandInfo): Promise<void> {
 		const cleanupProcess = await this.getCleanupProcess();
-		cleanupProcess.send(<ICleanupProcessMessage>{ actionType: CleanupProcessMessageType.RemoveCleanAction, action });
+		cleanupProcess.send(<ISpawnCommandCleanupMessage>{ messageType: CleanupProcessMessage.RemoveCleanCommand, commandInfo });
 	}
 
 	public async addCleanupDeleteAction(filePath: string): Promise<void> {
 		const cleanupProcess = await this.getCleanupProcess();
-		cleanupProcess.send(<ICleanupDeleteActionMessage>{ actionType: CleanupProcessMessageType.AddDeleteAction, filePath });
+		cleanupProcess.send(<IDeleteFileCleanupMessage>{ messageType: CleanupProcessMessage.AddDeleteFileAction, filePath });
 	}
 
 	public async removeCleanupDeleteAction(filePath: string): Promise<void> {
 		const cleanupProcess = await this.getCleanupProcess();
-		cleanupProcess.send(<ICleanupDeleteActionMessage>{ actionType: CleanupProcessMessageType.RemoveDeleteAction, filePath });
+		cleanupProcess.send(<IDeleteFileCleanupMessage>{ messageType: CleanupProcessMessage.RemoveDeleteFileAction, filePath });
 	}
 
 	@exported("cleanupService")
diff --git a/lib/services/livesync/android-device-livesync-sockets-service.ts b/lib/services/livesync/android-device-livesync-sockets-service.ts
@@ -59,7 +59,7 @@ export class AndroidDeviceSocketsLiveSyncService extends AndroidDeviceLiveSyncSe
 		}
 	}
 
-	private async getCleanupAction(appIdentifier: string): Promise<ICleanupAction> {
+	private async getCleanupCommand(appIdentifier: string): Promise<ISpawnCommandInfo> {
 		return {
 			command: await this.$staticConfig.getAdbFilePath(), args: [
 				"-s",
@@ -86,14 +86,14 @@ export class AndroidDeviceSocketsLiveSyncService extends AndroidDeviceLiveSyncSe
 				}
 			}, AndroidDeviceSocketsLiveSyncService.STATUS_UPDATE_INTERVAL);
 
-			const cleanupAction = await this.getCleanupAction(liveSyncInfo.deviceAppData.appIdentifier);
+			const cleanupCommand = await this.getCleanupCommand(liveSyncInfo.deviceAppData.appIdentifier);
 			const actionOnEnd = async () => {
 				clearInterval(syncInterval);
 				await this.device.fileSystem.deleteFile(this.getPathToLiveSyncFileOnDevice(liveSyncInfo.deviceAppData.appIdentifier), liveSyncInfo.deviceAppData.appIdentifier);
-				await this.$cleanupService.removeCleanupAction(cleanupAction);
+				await this.$cleanupService.removeCleanupCommand(cleanupCommand);
 			};
 
-			await this.$cleanupService.addCleanupAction(cleanupAction);
+			await this.$cleanupService.addCleanupCommand(cleanupCommand);
 			// We need to clear resources when the action fails
 			// But we also need the real result of the action.
 			await doSyncPromise.then(actionOnEnd.bind(this), actionOnEnd.bind(this));

Original file line number	Diff line number	Diff line change
`@@ -122,7 +122,7 @@ export class AndroidProcessService implements Mobile.IAndroidProcessService {`
`122`	`122`	`}`
`123`	`123`
`124`	`124`	`this._forwardedLocalPorts[portForwardInputData.deviceIdentifier] = localPort;`
`125`		- await this.$cleanupService.addCleanupAction({ command: await this.$staticConfig.getAdbFilePath(), args: ["-s", portForwardInputData.deviceIdentifier, "forward", "--remove", `tcp:${localPort}`] });
	`125`	+ await this.$cleanupService.addCleanupCommand({ command: await this.$staticConfig.getAdbFilePath(), args: ["-s", portForwardInputData.deviceIdentifier, "forward", "--remove", `tcp:${localPort}`] });
`126`	`126`	`return localPort && +localPort;`
`127`	`127`	`}`
`128`	`128`
Original file line number	Diff line number	Diff line change
`@@ -71,7 +71,7 @@ export class AndroidDeviceDebugService extends DebugServiceBase implements IDevi`
`71`	`71`	await this.unixSocketForward(port, `${unixSocketName}`);
`72`	`72`	`}`
`73`	`73`
`74`		- await this.$cleanupService.addCleanupAction({ command: await this.$staticConfig.getAdbFilePath(), args: ["-s", deviceId, "forward", "--remove", `tcp:${port}`] });
	`74`	+ await this.$cleanupService.addCleanupCommand({ command: await this.$staticConfig.getAdbFilePath(), args: ["-s", deviceId, "forward", "--remove", `tcp:${port}`] });
`75`	`75`
`76`	`76`	`return port;`
`77`	`77`	`}`