test

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

Author: RomanNikitenko

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

@@ -17,6 +17,7 @@ interface DevfileTaskDefinition extends vscode.TaskDefinition {
 	command: string;
 	workdir?: string;
 	component?: string;
+	commandId?: string;
 }
 
 export class DevfileTaskProvider implements vscode.TaskProvider {
@@ -35,15 +36,34 @@ export class DevfileTaskProvider implements vscode.TaskProvider {
 	private async computeTasks(): Promise<vscode.Task[]> {
 		const devfileCommands = await this.fetchDevfileCommands();
 
-		const cheTasks: vscode.Task[] = devfileCommands!
-			.filter(command => command.exec?.commandLine)
+		const localCommands = devfileCommands!
 			.filter(command => {
 				const importedByAttribute = (command.attributes as any)?.['controller.devfile.io/imported-by'];
 				return !command.attributes || importedByAttribute === undefined || importedByAttribute === 'parent';
 			})
-			.filter(command => !/^init-ssh-agent-command-\d+$/.test(command.id))
-			.map(command => this.createCheTask(command.exec?.label || command.id, command.exec?.commandLine!, command.exec?.workingDir || '${PROJECT_SOURCE}', command.exec?.component!, command.exec?.env));
-		return cheTasks;
+			.filter(command => !/^init-ssh-agent-command-\d+$/.test(command.id));
+
+		const execTasks: vscode.Task[] = localCommands
+			.filter(command => command.exec?.commandLine)
+			.map(command => this.createCheTask(
+				command.exec?.label || command.id,
+				command.exec?.commandLine!,
+				command.exec?.workingDir || '${PROJECT_SOURCE}',
+				command.exec?.component!,
+				command.exec?.env,
+				command.id
+			));
+
+		const compositeTasks: vscode.Task[] = localCommands
+			.filter(command => (command as any).composite?.commands?.length)
+			.map(command => this.createCompositeTask(
+				(command as any).composite?.label || command.id,
+				(command as any).composite?.commands || [],
+				Boolean((command as any).composite?.parallel),
+				command.id
+			));
+
+		return [...execTasks, ...compositeTasks];
 	}
 
 	private async fetchDevfileCommands(): Promise<V1alpha2DevWorkspaceSpecTemplateCommands[]> {
@@ -56,7 +76,14 @@ export class DevfileTaskProvider implements vscode.TaskProvider {
 		return [];
 	}
 
-	private createCheTask(name: string, command: string, workdir: string, component: string, env?: Array<V1alpha2DevWorkspaceSpecTemplateCommandsItemsExecEnv>): vscode.Task {
+	private createCheTask(
+		name: string,
+		command: string,
+		workdir: string,
+		component: string,
+		env?: Array<V1alpha2DevWorkspaceSpecTemplateCommandsItemsExecEnv>,
+		commandId?: string
+	): vscode.Task {
 		function expandEnvVariables(line: string): string {
 			const regex = /\${[a-zA-Z_][a-zA-Z0-9_]*}/g;
 			const envArray = line.match(regex);
@@ -75,7 +102,8 @@ export class DevfileTaskProvider implements vscode.TaskProvider {
 			type: 'devfile',
 			command,
 			workdir,
-			component
+			component,
+			commandId
 		};
 
 		const execution = new vscode.CustomExecution(async (): Promise<vscode.Pseudoterminal> => {
@@ -92,4 +120,99 @@ export class DevfileTaskProvider implements vscode.TaskProvider {
 		const task = new vscode.Task(kind, vscode.TaskScope.Workspace, name, 'devfile', execution, []);
 		return task;
 	}
+
+	private createCompositeTask(name: string, commandIds: string[], parallel: boolean, commandId: string): vscode.Task {
+		const kind: DevfileTaskDefinition = {
+			type: 'devfile',
+			command: `composite:${commandId}`,
+			commandId
+		};
+
+		const writeEmitter = new vscode.EventEmitter<string>();
+		const closeEmitter = new vscode.EventEmitter<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 () => {
+					writeEmitter.fire(`Running composite task: ${name}\r\n`);
+					try {
+						await this.runComposite(commandIds, parallel, writeEmitter, activeExecutions);
+						writeEmitter.fire(`Composite task finished: ${name}\r\n`);
+					} catch (error) {
+						writeEmitter.fire(`Composite task failed: ${name}\r\n`);
+						writeEmitter.fire(`${String(error)}\r\n`);
+					} finally {
+						closeEmitter.fire();
+					}
+				},
+				close: () => {
+					for (const execution of activeExecutions) {
+						execution.terminate();
+					}
+				}
+			};
+			return pty;
+		});
+
+		return new vscode.Task(kind, vscode.TaskScope.Workspace, name, 'devfile', execution, []);
+	}
+
+	private async runComposite(
+		commandIds: string[],
+		parallel: boolean,
+		writeEmitter: vscode.EventEmitter<string>,
+		activeExecutions: vscode.TaskExecution[]
+	): Promise<void> {
+		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) {
+				taskMap.set(def.commandId, task);
+			}
+			taskMap.set(task.name, task);
+		}
+
+		const targetTasks = commandIds
+			.map(id => taskMap.get(id))
+			.filter((task): task is vscode.Task => Boolean(task));
+
+		const missing = commandIds.filter(id => !taskMap.has(id));
+		if (missing.length) {
+			writeEmitter.fire(`Missing tasks: ${missing.join(', ')}\r\n`);
+		}
+		if (!targetTasks.length) {
+			writeEmitter.fire('No tasks to run.\r\n');
+			return;
+		}
+
+		if (parallel) {
+			const executions = await Promise.all(targetTasks.map(task => vscode.tasks.executeTask(task)));
+			activeExecutions.push(...executions);
+			await Promise.all(executions.map(execution => this.waitForTaskEnd(execution)));
+			return;
+		}
+
+		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);
+		}
+	}
+
+	private waitForTaskEnd(execution: vscode.TaskExecution): Promise<void> {
+		return new Promise(resolve => {
+			const disposable = vscode.tasks.onDidEndTask(event => {
+				if (event.execution === execution) {
+					disposable.dispose();
+					resolve();
+				}
+			});
+		});
+	}
 }