fix

Signed-off-by: Roman Nikitenko <rnikiten@redhat.com>

Author: RomanNikitenko

code/extensions/che-commands/src/taskProvider.ts

@@ -129,23 +129,28 @@ export class DevfileTaskProvider implements vscode.TaskProvider {
 		};
 
 		const writeEmitter = new vscode.EventEmitter<string>();
-		const closeEmitter = new vscode.EventEmitter<void>();
+		const closeEmitter = new vscode.EventEmitter<number | void>();
 		const activeExecutions: vscode.TaskExecution[] = [];
 
 		const execution = new vscode.CustomExecution(async (): Promise<vscode.Pseudoterminal> => {
 			const pty: vscode.Pseudoterminal = {
 				onDidWrite: writeEmitter.event,
 				onDidClose: closeEmitter.event,
 				open: async () => {
+					let exitCode = 0;
 					writeEmitter.fire(`Running composite task: ${name}\r\n`);
 					try {
-						await this.runComposite(commandIds, parallel, writeEmitter, activeExecutions);
+						const result = await this.runComposite(commandIds, parallel, writeEmitter, activeExecutions);
+						if (result.failed) {
+							exitCode = 1;
+						}
 						writeEmitter.fire(`Composite task finished: ${name}\r\n`);
 					} catch (error) {
+						exitCode = 1;
 						writeEmitter.fire(`Composite task failed: ${name}\r\n`);
 						writeEmitter.fire(`${String(error)}\r\n`);
 					} finally {
-						closeEmitter.fire();
+						closeEmitter.fire(exitCode);
 					}
 				},
 				close: () => {
@@ -165,13 +170,13 @@ export class DevfileTaskProvider implements vscode.TaskProvider {
 		parallel: boolean,
 		writeEmitter: vscode.EventEmitter<string>,
 		activeExecutions: vscode.TaskExecution[]
-	): Promise<void> {
+	): Promise<{ failed: boolean }> {
 		const tasks = await vscode.tasks.fetchTasks({ type: 'devfile' });
 		const taskMap = new Map<string, vscode.Task>();
 
 		for (const task of tasks) {
 			const def = task.definition as DevfileTaskDefinition;
-			if (def?.commandId) {
+			if (def?.commandId && !def.command.startsWith('composite:')) {
 				taskMap.set(def.commandId, task);
 			}
 			taskMap.set(task.name, task);
@@ -187,33 +192,48 @@ export class DevfileTaskProvider implements vscode.TaskProvider {
 		}
 		if (!targetTasks.length) {
 			writeEmitter.fire('No tasks to run.\r\n');
-			return;
+			return { failed: true };
 		}
 
 		if (parallel) {
 			targetTasks.forEach(task => writeEmitter.fire(`Starting ${task.name}\r\n`));
 			const executions = await Promise.all(targetTasks.map(task => vscode.tasks.executeTask(task)));
 			activeExecutions.push(...executions);
-			await Promise.all(executions.map((execution, index) => this.waitForTaskEnd(execution, targetTasks[index].name, writeEmitter)));
-			return;
+			const results = await Promise.all(executions.map((execution, index) => this.waitForTaskEnd(execution, targetTasks[index].name, writeEmitter)));
+			return { failed: results.some(result => result.failed) };
 		}
 
+		let failed = false;
 		for (const task of targetTasks) {
 			writeEmitter.fire(`Starting ${task.name}\r\n`);
 			const execution = await vscode.tasks.executeTask(task);
 			activeExecutions.push(execution);
-			await this.waitForTaskEnd(execution, task.name, writeEmitter);
+			const result = await this.waitForTaskEnd(execution, task.name, writeEmitter);
+			if (result.failed) {
+				failed = true;
+			}
 		}
+		return { failed };
 	}
 
 	private waitForTaskEnd(
 		execution: vscode.TaskExecution,
 		taskName: string,
 		writeEmitter: vscode.EventEmitter<string>
-	): Promise<void> {
+	): Promise<{ failed: boolean }> {
 		return new Promise(resolve => {
 			let processEnded = false;
 			let exitCode: number | undefined;
+			let processStarted = false;
+			let processId: number | undefined;
+
+			const startDisposable = vscode.tasks.onDidStartTaskProcess(event => {
+				if (event.execution === execution) {
+					processStarted = true;
+					processId = event.processId;
+					writeEmitter.fire(`Process started for ${taskName} (pid ${processId})\r\n`);
+				}
+			});
 
 			const processDisposable = vscode.tasks.onDidEndTaskProcess(event => {
 				if (event.execution === execution) {
@@ -224,18 +244,25 @@ export class DevfileTaskProvider implements vscode.TaskProvider {
 
 			const disposable = vscode.tasks.onDidEndTask(event => {
 				if (event.execution === execution) {
+					startDisposable.dispose();
 					processDisposable.dispose();
 					disposable.dispose();
+					let failed = false;
 					if (processEnded) {
 						if (exitCode === 0) {
 							writeEmitter.fire(`Completed ${taskName} (exit code 0)\r\n`);
 						} else {
 							writeEmitter.fire(`Completed ${taskName} (exit code ${exitCode})\r\n`);
+							failed = true;
 						}
+					} else if (processStarted) {
+						writeEmitter.fire(`Terminated ${taskName} (pid ${processId})\r\n`);
+						failed = true;
 					} else {
 						writeEmitter.fire(`Terminated ${taskName}\r\n`);
+						failed = true;
 					}
-					resolve();
+					resolve({ failed });
 				}
 			});
 		});