More layering and compile strictness (#8973)

* add more folders to strictire compile, add more strict compile options

* update ci

* wip

* add more layering and fix issues

* add more strictness

* remove unnecessary assertion

* add missing checks

* fix indentation

* remove jsdoc

src/sql/workbench/services/tasks/browser/tasksRegistry.ts

@@ -0,0 +1,119 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { MenuRegistry, ICommandAction } from 'vs/platform/actions/common/actions';
+import { IDisposable } from 'vs/base/common/lifecycle';
+import { ITaskRegistry, ITaskHandler, ITask, ITaskHandlerDescription, ITaskOptions } from 'sql/workbench/services/tasks/common/tasks';
+import * as types from 'vs/base/common/types';
+import { Event, Emitter } from 'vs/base/common/event';
+import { URI } from 'vs/base/common/uri';
+import { CommandsRegistry } from 'vs/platform/commands/common/commands';
+import { createCSSRule, asCSSUrl } from 'vs/base/browser/dom';
+import { ServicesAccessor } from 'vs/platform/instantiation/common/instantiation';
+import { IConnectionProfile } from 'sql/platform/connection/common/interfaces';
+import { IdGenerator } from 'vs/base/common/idGenerator';
+import { ThemeIcon } from 'vs/platform/theme/common/themeService';
+
+const ids = new IdGenerator('task-icon-');
+
+export const TaskRegistry: ITaskRegistry = new class implements ITaskRegistry {
+
+	private _tasks = new Array<string>();
+	private _onTaskRegistered = new Emitter<string>();
+	public readonly onTaskRegistered: Event<string> = this._onTaskRegistered.event;
+	private taskIdToIconClassNameMap: Map<string /* task id */, string /* CSS rule */> = new Map<string, string>();
+
+	registerTask(idOrTask: string | ITask, handler?: ITaskHandler): IDisposable {
+		let disposable: IDisposable;
+		let id: string;
+		if (types.isString(idOrTask)) {
+			disposable = CommandsRegistry.registerCommand(idOrTask, handler!);
+			id = idOrTask;
+		} else {
+			if (idOrTask.iconClass) {
+				this.taskIdToIconClassNameMap.set(idOrTask.id, idOrTask.iconClass);
+			}
+			disposable = CommandsRegistry.registerCommand(idOrTask);
+			id = idOrTask.id;
+		}
+
+		this._tasks.push(id);
+		this._onTaskRegistered.fire(id);
+
+		return {
+			dispose: () => {
+				let index = this._tasks.indexOf(id);
+				if (index >= 0) {
+					this._tasks = this._tasks.splice(index, 1);
+				}
+				disposable.dispose();
+			}
+		};
+	}
+
+	getOrCreateTaskIconClassName(item: ICommandAction): string | undefined {
+		let iconClass: string | undefined;
+		if (this.taskIdToIconClassNameMap.has(item.id)) {
+			iconClass = this.taskIdToIconClassNameMap.get(item.id);
+		} else if (ThemeIcon.isThemeIcon(item.icon)) {
+			// TODO
+		} else if (item.icon?.dark) { // at the very least we need a dark icon
+			iconClass = ids.nextId();
+			createCSSRule(`.codicon.${iconClass}`, `background-image: ${asCSSUrl(item.icon.light || item.icon.dark)}`);
+			createCSSRule(`.vs-dark .codicon.${iconClass}, .hc-black .codicon.${iconClass}`, `background-image: ${asCSSUrl(item.icon.dark)}`);
+			this.taskIdToIconClassNameMap.set(item.id, iconClass);
+		}
+		return iconClass;
+	}
+
+	getTasks(): string[] {
+		return this._tasks.slice(0);
+	}
+};
+
+export abstract class Task {
+	public readonly id: string;
+	public readonly title: string;
+	public readonly iconPath?: { dark: URI; light?: URI; };
+	private readonly _iconClass?: string;
+	private readonly _description?: ITaskHandlerDescription;
+
+	constructor(opts: ITaskOptions) {
+		this.id = opts.id;
+		this.title = opts.title;
+		if (opts.iconPath) {
+			this.iconPath = {
+				dark: URI.parse(opts.iconPath.dark),
+				light: opts.iconPath.light ? URI.parse(opts.iconPath.light) : undefined,
+			};
+		}
+		this._iconClass = opts.iconClass;
+		this._description = opts.description;
+	}
+
+	private toITask(): ITask {
+		return {
+			id: this.id,
+			handler: (accessor, profile, args) => this.runTask(accessor, profile, args),
+			description: this._description,
+			iconClass: this._iconClass
+		};
+	}
+
+	private toCommandAction(): ICommandAction {
+		return {
+			icon: this.iconPath,
+			id: this.id,
+			title: this.title
+		};
+	}
+
+	public registerTask(): IDisposable {
+		MenuRegistry.addCommand(this.toCommandAction());
+		return TaskRegistry.registerTask(this.toITask());
+	}
+
+	public abstract runTask(accessor: ServicesAccessor, profile: IConnectionProfile, args: any): void | Promise<void>;
+}

src/sql/workbench/services/tasks/common/tasks.ts

@@ -0,0 +1,59 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { IConnectionProfile } from 'sql/platform/connection/common/interfaces';
+
+import * as types from 'vs/base/common/types';
+import { ILocalizedString, ICommandAction } from 'vs/platform/actions/common/actions';
+import { Event } from 'vs/base/common/event';
+import { IDisposable } from 'vs/base/common/lifecycle';
+import { ContextKeyExpr } from 'vs/platform/contextkey/common/contextkey';
+import { ServicesAccessor } from 'vs/platform/instantiation/common/instantiation';
+
+export interface ITaskOptions {
+	id: string;
+	title: string;
+	iconPath: { dark: string; light?: string; };
+	description?: ITaskHandlerDescription;
+	iconClass?: string;
+}
+
+export interface ITaskHandlerDescription {
+	description: string;
+	args: { name: string; description?: string; constraint?: types.TypeConstraint; }[];
+	returns?: string;
+}
+
+export interface ITaskEvent {
+	taskId: string;
+}
+
+export interface ITaskAction {
+	id: string;
+	title: string | ILocalizedString;
+	category?: string | ILocalizedString;
+	iconClass?: string;
+	iconPath?: string;
+}
+
+export interface ITaskHandler {
+	(accessor: ServicesAccessor, profile: IConnectionProfile, ...args: any[]): void;
+}
+
+export interface ITask {
+	id: string;
+	handler: ITaskHandler;
+	precondition?: ContextKeyExpr;
+	description?: ITaskHandlerDescription;
+	iconClass?: string;
+}
+
+export interface ITaskRegistry {
+	registerTask(id: string, command: ITaskHandler): IDisposable;
+	registerTask(command: ITask): IDisposable;
+	getTasks(): string[];
+	getOrCreateTaskIconClassName(item: ICommandAction): string | undefined;
+	onTaskRegistered: Event<string>;
+}

src/sql/workbench/services/tasks/common/tasksNode.ts

@@ -0,0 +1,115 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { StopWatch } from 'vs/base/common/stopwatch';
+import { generateUuid } from 'vs/base/common/uuid';
+
+export enum TaskStatus {
+	NotStarted = 0,
+	InProgress = 1,
+	Succeeded = 2,
+	SucceededWithWarning = 3,
+	Failed = 4,
+	Canceled = 5,
+	Canceling = 6
+}
+
+export enum TaskExecutionMode {
+	execute = 0,
+	script = 1,
+	executeAndScript = 2,
+}
+
+export class TaskNode {
+	/**
+	 * id for TaskNode
+	 */
+	public id: string;
+
+	/**
+	 * string defining the type of the task - for example Backup, Restore
+	 */
+	public taskName: string;
+
+	/**
+	 * sever name
+	 */
+	public serverName?: string;
+
+	/**
+	 * Database Name
+	 */
+	public databaseName?: string;
+
+	/**
+	 * Provider Name
+	 */
+	public providerName?: string;
+
+
+	/**
+	 * The start time of the task
+	 */
+	public startTime: string;
+
+	/**
+	 * The end time of the task
+	 */
+	public endTime?: string;
+
+	/**
+	 * The timer for the task
+	 */
+	public timer: StopWatch;
+
+	/**
+	 * Does this node have children
+	 */
+	public hasChildren: boolean;
+
+	/**
+	 * Children of this node
+	 */
+	public children?: TaskNode[];
+
+	/**
+	 * Task's message
+	 */
+	public message?: string;
+
+	/**
+	 * Status of the task
+	 */
+	public status: TaskStatus;
+
+	/**
+	 * Execution mode of task
+	 */
+	public taskExecutionMode: TaskExecutionMode;
+
+	/**
+	 * Indicates if the task can be canceled
+	 */
+	public isCancelable: boolean;
+
+	/**
+	 * Script of task operation
+	 */
+	public script?: string;
+
+	constructor(taskName: string, serverName?: string, databaseName?: string, taskId: string | undefined = undefined, taskExecutionMode: TaskExecutionMode = TaskExecutionMode.execute, isCancelable: boolean = true) {
+		this.id = taskId || generateUuid();
+
+		this.taskName = taskName;
+		this.serverName = serverName;
+		this.databaseName = databaseName;
+		this.timer = StopWatch.create();
+		this.startTime = new Date().toLocaleTimeString();
+		this.status = TaskStatus.InProgress;
+		this.hasChildren = false;
+		this.taskExecutionMode = taskExecutionMode;
+		this.isCancelable = isCancelable;
+	}
+}

src/sql/workbench/services/tasks/common/tasksService.ts

@@ -0,0 +1,254 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as azdata from 'azdata';
+import { TaskNode, TaskStatus, TaskExecutionMode } from 'sql/workbench/services/tasks/common/tasksNode';
+import { IQueryEditorService } from 'sql/workbench/services/queryEditor/common/queryEditorService';
+import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
+import { Event, Emitter } from 'vs/base/common/event';
+import { ILifecycleService } from 'vs/platform/lifecycle/common/lifecycle';
+import { localize } from 'vs/nls';
+import Severity from 'vs/base/common/severity';
+import { IDialogService } from 'vs/platform/dialogs/common/dialogs';
+import { IConnectionManagementService } from 'sql/platform/connection/common/connectionManagement';
+import { find } from 'vs/base/common/arrays';
+
+export const SERVICE_ID = 'taskHistoryService';
+export const ITaskService = createDecorator<ITaskService>(SERVICE_ID);
+
+export interface ITaskService {
+	_serviceBrand: undefined;
+	onTaskComplete: Event<TaskNode>;
+	onAddNewTask: Event<TaskNode>;
+	handleNewTask(task: TaskNode): void;
+	handleTaskComplete(eventArgs: TaskStatusChangeArgs): void;
+	getAllTasks(): TaskNode;
+	getNumberOfInProgressTasks(): number;
+	onNewTaskCreated(handle: number, taskInfo: azdata.TaskInfo): void;
+	createNewTask(taskInfo: azdata.TaskInfo): void;
+	updateTask(taskProgressInfo: azdata.TaskProgressInfo): void;
+	onTaskStatusChanged(handle: number, taskProgressInfo: azdata.TaskProgressInfo): void;
+	cancelTask(providerId: string, taskId: string): Promise<boolean | undefined>;
+	/**
+	 * Register a ObjectExplorer provider
+	 */
+	registerProvider(providerId: string, provider: azdata.TaskServicesProvider): void;
+}
+
+export interface TaskStatusChangeArgs {
+	taskId: string;
+	status: azdata.TaskStatus;
+	message?: string;
+	script?: string;
+}
+
+export class TaskService implements ITaskService {
+	public _serviceBrand: undefined;
+	private _taskQueue: TaskNode;
+	private _onTaskComplete = new Emitter<TaskNode>();
+	private _onAddNewTask = new Emitter<TaskNode>();
+	private _providers: { [handle: string]: azdata.TaskServicesProvider; } = Object.create(null);
+
+	constructor(
+		@ILifecycleService lifecycleService: ILifecycleService,
+		@IDialogService private dialogService: IDialogService,
+		@IQueryEditorService private queryEditorService: IQueryEditorService,
+		@IConnectionManagementService private connectionManagementService: IConnectionManagementService
+	) {
+		this._taskQueue = new TaskNode('Root');
+		this._onTaskComplete = new Emitter<TaskNode>();
+		this._onAddNewTask = new Emitter<TaskNode>();
+
+		lifecycleService.onBeforeShutdown(event => event.veto(this.beforeShutdown()));
+
+	}
+
+	/**
+	 * Register a ObjectExplorer provider
+	 */
+	public registerProvider(providerId: string, provider: azdata.TaskServicesProvider): void {
+		this._providers[providerId] = provider;
+	}
+
+	public onNewTaskCreated(handle: number, taskInfo: azdata.TaskInfo) {
+		this.createNewTask(taskInfo);
+	}
+
+	public createNewTask(taskInfo: azdata.TaskInfo) {
+		let databaseName: string = taskInfo.databaseName;
+		let serverName: string = taskInfo.serverName;
+		if (taskInfo && taskInfo.connection) {
+			let connectionProfile = this.connectionManagementService.getConnectionProfile(taskInfo.connection.connectionId);
+			if (connectionProfile && !!databaseName) {
+				databaseName = connectionProfile.databaseName;
+			}
+			if (connectionProfile && !!serverName) {
+				serverName = connectionProfile.serverName;
+			}
+		}
+		let node: TaskNode = new TaskNode(taskInfo.name, serverName, databaseName, taskInfo.taskId, taskInfo.taskExecutionMode, taskInfo.isCancelable);
+		node.providerName = taskInfo.providerName;
+		this.handleNewTask(node);
+	}
+
+	public updateTask(taskProgressInfo: azdata.TaskProgressInfo) {
+		this.handleTaskComplete({
+			taskId: taskProgressInfo.taskId,
+			status: taskProgressInfo.status,
+			message: taskProgressInfo.message,
+			script: taskProgressInfo.script
+		});
+	}
+
+	public onTaskStatusChanged(handle: number, taskProgressInfo: azdata.TaskProgressInfo) {
+		this.updateTask(taskProgressInfo);
+	}
+
+	public cancelTask(providerId: string, taskId: string): Promise<boolean | undefined> {
+		let task = this.getTaskInQueue(taskId);
+		if (task) {
+			task.status = TaskStatus.Canceling;
+			this._onTaskComplete.fire(task);
+			if (providerId) {
+				let provider = this._providers[providerId];
+				if (provider && provider.cancelTask) {
+					return Promise.resolve(provider.cancelTask({
+						taskId: taskId
+					}));
+				}
+			} else {
+				return Promise.resolve(true);
+			}
+		}
+		return Promise.resolve(undefined);
+	}
+
+	private cancelAllTasks(): Thenable<void> {
+		return new Promise<void>((resolve, reject) => {
+			let promises = this._taskQueue.children!.map(task => {
+				if (task.status === TaskStatus.InProgress || task.status === TaskStatus.NotStarted) {
+					return this.cancelTask(task.providerName!, task.id);
+				}
+				return Promise.resolve(true);
+			});
+
+			Promise.all(promises).then(result => {
+				resolve(undefined);
+			}).catch(error => {
+				reject(error);
+			});
+		});
+	}
+
+	public handleNewTask(task: TaskNode): void {
+		if (this._taskQueue.hasChildren) {
+			this._taskQueue.children!.unshift(task);
+		} else {
+			this._taskQueue.hasChildren = true;
+			this._taskQueue.children = [task];
+		}
+		this._onAddNewTask.fire(task);
+	}
+
+	public beforeShutdown(): Promise<boolean> {
+		const message = localize('InProgressWarning', "1 or more tasks are in progress. Are you sure you want to quit?");
+		const options = [
+			localize('taskService.yes', "Yes"),
+			localize('taskService.no', "No")
+		];
+
+		return new Promise<boolean>((resolve, reject) => {
+			let numOfInprogressTasks = this.getNumberOfInProgressTasks();
+			if (numOfInprogressTasks > 0) {
+				this.dialogService.show(Severity.Warning, message, options).then(choice => {
+					switch (choice.choice) {
+						case 0:
+							let timeout: any;
+							let isTimeout = false;
+							this.cancelAllTasks().then(() => {
+								clearTimeout(timeout);
+								if (!isTimeout) {
+									resolve(false);
+								}
+							}, error => {
+								clearTimeout(timeout);
+								if (!isTimeout) {
+									resolve(false);
+								}
+							});
+							timeout = setTimeout(function () {
+								isTimeout = true;
+								resolve(false);
+							}, 2000);
+							break;
+						case 1:
+							resolve(true);
+					}
+				});
+			} else {
+				resolve(false);
+			}
+		});
+	}
+
+	public handleTaskComplete(eventArgs: TaskStatusChangeArgs): void {
+		let task = this.getTaskInQueue(eventArgs.taskId);
+		if (task) {
+			task.status = eventArgs.status;
+			if (eventArgs.message) {
+				task.message = eventArgs.message;
+			}
+			switch (task.status) {
+				case TaskStatus.Canceled:
+				case TaskStatus.Succeeded:
+				case TaskStatus.SucceededWithWarning:
+				case TaskStatus.Failed:
+					task.endTime = new Date().toLocaleTimeString();
+					task.timer.stop();
+					this._onTaskComplete.fire(task);
+					break;
+				default:
+					break;
+			}
+
+			if ((task.status === TaskStatus.Succeeded || task.status === TaskStatus.SucceededWithWarning)
+				&& eventArgs.script && eventArgs.script !== '') {
+				if (task.taskExecutionMode === TaskExecutionMode.script) {
+					this.queryEditorService.newSqlEditor(eventArgs.script);
+				} else if (task.taskExecutionMode === TaskExecutionMode.executeAndScript) {
+					task.script = eventArgs.script;
+				}
+			}
+		}
+
+	}
+
+	private getTaskInQueue(taskId: string): TaskNode | undefined {
+		if (this._taskQueue.hasChildren) {
+			return find(this._taskQueue.children!, x => x.id === taskId);
+		}
+		return undefined;
+	}
+
+	public get onTaskComplete(): Event<TaskNode> {
+		return this._onTaskComplete.event;
+	}
+
+	public get onAddNewTask(): Event<TaskNode> {
+		return this._onAddNewTask.event;
+	}
+
+	public getNumberOfInProgressTasks(): number {
+		if (this._taskQueue.hasChildren) {
+			let inProgressTasks = this._taskQueue.children!.filter(x => x.status === TaskStatus.InProgress);
+			return inProgressTasks ? inProgressTasks.length : 0;
+		}
+		return 0;
+	}
+
+	public getAllTasks(): TaskNode {
+		return this._taskQueue;
+	}
+}