feat: improve cleanup service

Currently it is possible just to add new actions to be executed in the cleanup. However, in some cases, we want to add action and remove it after that.
Also, we need to delete some lock files when CLI is not using them anymore. So, introduce new API in the cleanup service that allow all of these actions.

Author: rosen-vladimirov

lib/definitions/cleanup-service.d.ts

@@ -10,11 +10,34 @@ interface ICleanupService extends IShouldDispose, IDisposable {
 	 */
 	addCleanupAction(action: ICleanupAction): 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.
+	 * @returns {Promise<void>}
+	 */
+	removeCleanupAction(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
+	setCleanupLogFile(filePath: string): void;
+
+	/**
+	 * Adds file/dir to be deleted once CLI process exits.
+	 * @param {string} filePath Path to file/directory to be deleted.
+	 * @returns {Promise<void>}
+	 */
+	addCleanupDeleteAction(filePath: string): Promise<void>;
+
+	/**
+	 * Removes file/dir from the list of files to be deleted once CLI process exits.
+	 * NOTE: The file should be first added with `addCleanupDeleteAction`
+	 * @param {string} filePath Path to file/directory to be removed from the list of files to be deleted.
+	 * @returns {Promise<void>}
+	 */
+	removeCleanupDeleteAction(filePath: string): Promise<void>;
 }

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

@@ -19,10 +19,18 @@ interface ICleanupProcessMessage {
 	 * Type of the action
 	 */
 	actionType: CleanupProcessMessageType;
+}
 
+interface ICleanupActionMessage extends ICleanupProcessMessage {
 	/**
 	 * Describes the action that must be executed
 	 */
 	action: ICleanupAction;
 }
 
+interface ICleanupDeleteActionMessage extends ICleanupProcessMessage {
+	/**
+	 * Path to file/directory to be deleted.
+	 */
+	filePath: string;
+}

lib/detached-processes/cleanup-process.ts

@@ -1,6 +1,8 @@
 // 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 * as path from "path";
+import * as shelljs from "shelljs";
 import { FileLogService } from "./file-log-service";
 
 const pathToBootstrap = process.argv[2];
@@ -16,6 +18,7 @@ const fileLogService = $injector.resolve<IFileLogService>(FileLogService, { logF
 fileLogService.logData({ message: "Initializing Cleanup process." });
 
 const actionsToExecute: ICleanupAction[] = [];
+const filesToDelete: string[] = [];
 
 const executeCleanup = async () => {
 	const $childProcess = $injector.resolve<IChildProcess>("childProcess");
@@ -31,16 +34,52 @@ const executeCleanup = async () => {
 		}
 	}
 
+	if (filesToDelete.length) {
+		fileLogService.logData({ message: `Deleting files ${filesToDelete.join(" ")}` });
+		shelljs.rm("-Rf", filesToDelete);
+	}
+
 	fileLogService.logData({ message: `cleanup-process finished` });
 	process.exit();
 };
 
 const addCleanupAction = (newAction: ICleanupAction): void => {
-	if (!_.some(actionsToExecute, currentAction => _.isEqual(currentAction, newAction))) {
+	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)}` });
+	} else {
 		fileLogService.logData({ message: `cleanup-process added action for execution: ${JSON.stringify(newAction)}` });
 		actionsToExecute.push(newAction);
+	}
+};
+
+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)}` });
 	} else {
-		fileLogService.logData({ message: `cleanup-process will not add action for execution as it has been added already: ${JSON.stringify(newAction)}` });
+		fileLogService.logData({ message: `cleanup-process cannot remove action for execution as it has note been added before: ${JSON.stringify(actionToRemove)}` });
+	}
+};
+
+const addDeleteAction = (filePath: string): void => {
+	const fullPath = path.resolve(filePath);
+
+	if (_.some(filesToDelete, f => f === fullPath)) {
+		fileLogService.logData({ message: `cleanup-process will not add ${fullPath} for deletion as it has been added already` });
+	} else {
+		filesToDelete.push(fullPath);
+		fileLogService.logData({ message: `cleanup-process added ${fullPath} for deletion` });
+	}
+};
+
+const removeDeleteAction = (filePath: string): void => {
+	const fullPath = path.resolve(filePath);
+
+	if (_.some(filesToDelete, f => f === fullPath)) {
+		_.remove(filesToDelete, f => f === fullPath);
+		fileLogService.logData({ message: `cleanup-process removed ${fullPath} from the list of files for deletion.` });
+	} else {
+		fileLogService.logData({ message: `cleanup-process cannot remove ${fullPath} for deletion as no such entry is found in the files marked for deletion` });
 	}
 };
 
@@ -49,7 +88,16 @@ process.on("message", async (cleanupProcessMessage: ICleanupProcessMessage) => {
 
 	switch (cleanupProcessMessage.actionType) {
 		case CleanupProcessMessageType.AddCleanAction:
-			addCleanupAction(cleanupProcessMessage.action);
+			addCleanupAction((<ICleanupActionMessage>cleanupProcessMessage).action);
+			break;
+		case CleanupProcessMessageType.RemoveCleanAction:
+			removeCleanupAction((<ICleanupActionMessage>cleanupProcessMessage).action);
+			break;
+		case CleanupProcessMessageType.AddDeleteAction:
+			addDeleteAction((<ICleanupDeleteActionMessage>cleanupProcessMessage).filePath);
+			break;
+		case CleanupProcessMessageType.RemoveDeleteAction:
+			removeDeleteAction((<ICleanupDeleteActionMessage>cleanupProcessMessage).filePath);
 			break;
 		default:
 			fileLogService.logData({ message: `Unable to handle message of type ${cleanupProcessMessage.actionType}. Full message is ${JSON.stringify(cleanupProcessMessage)}`, type: FileLogMessageType.Error });

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

@@ -24,5 +24,24 @@ declare const enum FileLogMessageType {
 }
 
 declare const enum CleanupProcessMessageType {
+	/**
+	 * This type of action defines that cleanup procedure should execute specific action.
+	 */
 	AddCleanAction = "AddCleanAction",
+
+	/**
+	 * This type of action defines that cleanup procedure should not execute previously defined cleanup action.
+	 */
+	RemoveCleanAction = "RemoveCleanAction",
+
+	/**
+	 * This type of action defines that cleanup procedure should delete specified files.
+	 */
+	AddDeleteAction = "AddDeleteAction",
+
+	/**
+	 * This type of action defines the cleanup procedure should not delete previously specified file.
+	 */
+	RemoveDeleteAction = "RemoveDeleteAction",
+
 }

lib/services/cleanup-service.ts

@@ -20,6 +20,21 @@ export class CleanupService implements ICleanupService {
 		cleanupProcess.send(<ICleanupProcessMessage>{ actionType: CleanupProcessMessageType.AddCleanAction, action });
 	}
 
+	public async removeCleanupAction(action: ICleanupAction): Promise<void> {
+		const cleanupProcess = await this.getCleanupProcess();
+		cleanupProcess.send(<ICleanupProcessMessage>{ actionType: CleanupProcessMessageType.RemoveCleanAction, action });
+	}
+
+	public async addCleanupDeleteAction(filePath: string): Promise<void> {
+		const cleanupProcess = await this.getCleanupProcess();
+		cleanupProcess.send(<ICleanupDeleteActionMessage>{ actionType: CleanupProcessMessageType.AddDeleteAction, filePath });
+	}
+
+	public async removeCleanupDeleteAction(filePath: string): Promise<void> {
+		const cleanupProcess = await this.getCleanupProcess();
+		cleanupProcess.send(<ICleanupDeleteActionMessage>{ actionType: CleanupProcessMessageType.RemoveDeleteAction, filePath });
+	}
+
 	@exported("cleanupService")
 	public setCleanupLogFile(filePath: string): void {
 		this.pathToCleanupLogFile = filePath;