Add busy tasks and check busy tasks in debug

alexr00 · alexr00 · commit be89df857d05 · 2019-10-11T11:24:21.000+02:00
to prevent 'stale' prelaunch task results Fixes microsoft#82076
diff --git a/src/vs/workbench/contrib/debug/browser/debugService.ts b/src/vs/workbench/contrib/debug/browser/debugService.ts
@@ -768,9 +768,27 @@ export class DebugService implements IDebugService {
 
 		// If a task is missing the problem matcher the promise will never complete, so we need to have a workaround #35340
 		let taskStarted = false;
-		const promise: Promise<ITaskSummary | null> = this.taskService.getActiveTasks().then(tasks => {
+		const inactivePromise: Promise<ITaskSummary | null> = new Promise((c, e) => once(e => {
+			// When a task isBackground it will go inactive when it is safe to launch.
+			// But when a background task is terminated by the user, it will also fire an inactive event.
+			// This means that we will not get to see the real exit code from running the task (undefined when terminated by the user).
+			// Catch the ProcessEnded event here, which occurs before inactive, and capture the exit code to prevent this.
+			return (e.kind === TaskEventKind.Inactive
+				|| (e.kind === TaskEventKind.ProcessEnded && e.exitCode === undefined))
+				&& e.taskId === task._id;
+		}, this.taskService.onDidStateChange)(e => {
+			taskStarted = true;
+			c(e.kind === TaskEventKind.ProcessEnded ? { exitCode: e.exitCode } : null);
+		}));
+
+		const promise: Promise<ITaskSummary | null> = this.taskService.getActiveTasks().then(async (tasks): Promise<ITaskSummary | null> => {
 			if (tasks.filter(t => t._id === task._id).length) {
-				// task is already running - nothing to do.
+				// Check that the task isn't busy and if it is, wait for it
+				const busyTasks = await this.taskService.getBusyTasks();
+				if (busyTasks.filter(t => t._id === task._id).length) {
+					return inactivePromise;
+				}
+				// task is already running and isn't busy - nothing to do.
 				return Promise.resolve(null);
 			}
 			once(e => ((e.kind === TaskEventKind.Active) || (e.kind === TaskEventKind.DependsOnStarted)) && e.taskId === task._id, this.taskService.onDidStateChange)(() => {
@@ -780,18 +798,7 @@ export class DebugService implements IDebugService {
 			});
 			const taskPromise = this.taskService.run(task);
 			if (task.configurationProperties.isBackground) {
-				return new Promise((c, e) => once(e => {
-					// When a task isBackground it will go inactive when it is safe to launch.
-					// But when a background task is terminated by the user, it will also fire an inactive event.
-					// This means that we will not get to see the real exit code from running the task (undefined when terminated by the user).
-					// Catch the ProcessEnded event here, which occurs before inactive, and capture the exit code to prevent this.
-					return (e.kind === TaskEventKind.Inactive
-						|| (e.kind === TaskEventKind.ProcessEnded && e.exitCode === undefined))
-						&& e.taskId === task._id;
-				}, this.taskService.onDidStateChange)(e => {
-					taskStarted = true;
-					c(e.kind === TaskEventKind.ProcessEnded ? { exitCode: e.exitCode } : null);
-				}));
+				return inactivePromise;
 			}
 
 			return taskPromise;
diff --git a/src/vs/workbench/contrib/tasks/browser/abstractTaskService.ts b/src/vs/workbench/contrib/tasks/browser/abstractTaskService.ts
@@ -569,6 +569,13 @@ export abstract class AbstractTaskService extends Disposable implements ITaskSer
 		return Promise.resolve(this._taskSystem.getActiveTasks());
 	}
 
+	public getBusyTasks(): Promise<Task[]> {
+		if (!this._taskSystem) {
+			return Promise.resolve([]);
+		}
+		return Promise.resolve(this._taskSystem.getBusyTasks());
+	}
+
 	public getRecentlyUsedTasks(): LinkedMap<string, string> {
 		if (this._recentlyUsedTasks) {
 			return this._recentlyUsedTasks;
diff --git a/src/vs/workbench/contrib/tasks/browser/terminalTaskSystem.ts b/src/vs/workbench/contrib/tasks/browser/terminalTaskSystem.ts
@@ -152,6 +152,7 @@ export class TerminalTaskSystem implements ITaskSystem {
 	};
 
 	private activeTasks: IStringDictionary<ActiveTerminalData>;
+	private busyTasks: IStringDictionary<Task>;
 	private terminals: IStringDictionary<TerminalData>;
 	private idleTaskTerminals: LinkedMap<string, string>;
 	private sameTaskTerminals: IStringDictionary<string>;
@@ -180,6 +181,7 @@ export class TerminalTaskSystem implements ITaskSystem {
 	) {
 
 		this.activeTasks = Object.create(null);
+		this.busyTasks = Object.create(null);
 		this.terminals = Object.create(null);
 		this.idleTaskTerminals = new LinkedMap<string, string>();
 		this.sameTaskTerminals = Object.create(null);
@@ -280,6 +282,10 @@ export class TerminalTaskSystem implements ITaskSystem {
 		return Object.keys(this.activeTasks).map(key => this.activeTasks[key].task);
 	}
 
+	public getBusyTasks(): Task[] {
+		return Object.keys(this.busyTasks).map(key => this.busyTasks[key]);
+	}
+
 	public customExecutionComplete(task: Task, result: number): Promise<void> {
 		let activeTerminal = this.activeTasks[task.getMapKey()];
 		if (!activeTerminal) {
@@ -533,12 +539,17 @@ export class TerminalTaskSystem implements ITaskSystem {
 			}
 			const toDispose = new DisposableStore();
 			let eventCounter: number = 0;
+			const mapKey = task.getMapKey();
 			toDispose.add(watchingProblemMatcher.onDidStateChange((event) => {
 				if (event.kind === ProblemCollectorEventKind.BackgroundProcessingBegins) {
 					eventCounter++;
+					this.busyTasks[mapKey] = task;
 					this._onDidStateChange.fire(TaskEvent.create(TaskEventKind.Active, task));
 				} else if (event.kind === ProblemCollectorEventKind.BackgroundProcessingEnds) {
 					eventCounter--;
+					if (this.busyTasks[mapKey]) {
+						delete this.busyTasks[mapKey];
+					}
 					this._onDidStateChange.fire(TaskEvent.create(TaskEventKind.Inactive, task));
 					if (eventCounter === 0) {
 						if ((watchingProblemMatcher.numberOfMatches > 0) && watchingProblemMatcher.maxMarkerSeverity &&
@@ -597,6 +608,9 @@ export class TerminalTaskSystem implements ITaskSystem {
 					onData.dispose();
 					onExit.dispose();
 					let key = task.getMapKey();
+					if (this.busyTasks[mapKey]) {
+						delete this.busyTasks[mapKey];
+					}
 					delete this.activeTasks[key];
 					this._onDidStateChange.fire(TaskEvent.create(TaskEventKind.Changed));
 					if (exitCode !== undefined) {
@@ -656,6 +670,8 @@ export class TerminalTaskSystem implements ITaskSystem {
 				// The process never got ready. Need to think how to handle this.
 			});
 			this._onDidStateChange.fire(TaskEvent.create(TaskEventKind.Start, task, terminal.id));
+			const mapKey = task.getMapKey();
+			this.busyTasks[mapKey] = task;
 			this._onDidStateChange.fire(TaskEvent.create(TaskEventKind.Active, task));
 			let problemMatchers = this.resolveMatchers(resolver, task.configurationProperties.problemMatchers);
 			let startStopProblemMatcher = new StartStopProblemCollector(problemMatchers, this.markerService, this.modelService, ProblemHandlingStrategy.Clean, this.fileService);
@@ -709,6 +725,9 @@ export class TerminalTaskSystem implements ITaskSystem {
 					}
 
 					this._onDidStateChange.fire(TaskEvent.create(TaskEventKind.ProcessEnded, task, exitCode));
+					if (this.busyTasks[mapKey]) {
+						delete this.busyTasks[mapKey];
+					}
 					this._onDidStateChange.fire(TaskEvent.create(TaskEventKind.Inactive, task));
 					this._onDidStateChange.fire(TaskEvent.create(TaskEventKind.End, task));
 					resolve({ exitCode });
@@ -1028,7 +1047,11 @@ export class TerminalTaskSystem implements ITaskSystem {
 				// This can happen if the terminal wasn't shutdown with an "immediate" flag and is expected.
 				// For correct terminal re-use, the task needs to be deleted immediately.
 				// Note that this shouldn't be a problem anymore since user initiated terminal kills are now immediate.
-				delete this.activeTasks[task.getMapKey()];
+				const mapKey = task.getMapKey();
+				delete this.activeTasks[mapKey];
+				if (this.busyTasks[mapKey]) {
+					delete this.busyTasks[mapKey];
+				}
 			}
 		});
 		this.terminals[terminalKey] = { terminal: result, lastTask: taskKey, group };
diff --git a/src/vs/workbench/contrib/tasks/common/taskService.ts b/src/vs/workbench/contrib/tasks/common/taskService.ts
@@ -62,6 +62,7 @@ export interface ITaskService {
 	inTerminal(): boolean;
 	isActive(): Promise<boolean>;
 	getActiveTasks(): Promise<Task[]>;
+	getBusyTasks(): Promise<Task[]>;
 	restart(task: Task): void;
 	terminate(task: Task): Promise<TaskTerminateResponse>;
 	terminateAll(): Promise<TaskTerminateResponse[]>;
diff --git a/src/vs/workbench/contrib/tasks/common/taskSystem.ts b/src/vs/workbench/contrib/tasks/common/taskSystem.ts
@@ -133,6 +133,7 @@ export interface ITaskSystem {
 	isActive(): Promise<boolean>;
 	isActiveSync(): boolean;
 	getActiveTasks(): Task[];
+	getBusyTasks(): Task[];
 	canAutoTerminate(): boolean;
 	terminate(task: Task): Promise<TaskTerminateResponse>;
 	terminateAll(): Promise<TaskTerminateResponse[]>;
diff --git a/src/vs/workbench/contrib/tasks/node/processTaskSystem.ts b/src/vs/workbench/contrib/tasks/node/processTaskSystem.ts
@@ -90,6 +90,10 @@ export class ProcessTaskSystem implements ITaskSystem {
 		return result;
 	}
 
+	public getBusyTasks(): Task[] {
+		return this.getActiveTasks();
+	}
+
 	public run(task: Task): ITaskExecuteResult {
 		if (this.activeTask) {
 			return { kind: TaskExecuteKind.Active, task, active: { same: this.activeTask._id === task._id, background: this.activeTask.configurationProperties.isBackground! }, promise: this.activeTaskPromise! };
