deployment extensibility (#7394)

* rename button and update dialog button width

* make deployment resource type contributable

* conflicts

* fix card width hight issue

* comments

extensions/resource-deployment/src/interfaces.ts

@@ -35,24 +35,85 @@ export interface ResourceTypeOptionValue {
 	displayName: string;
 }
 
-export interface DeploymentProvider {
-	title: string;
+export interface DialogDeploymentProvider extends DeploymentProviderBase {
 	dialog: DialogInfo;
-	notebook: string | NotebookInfo;
-	downloadUrl: string;
-	webPageUrl: string;
+}
+
+export interface WizardDeploymentProvider extends DeploymentProviderBase {
 	wizard: WizardInfo;
+}
+
+export interface NotebookDeploymentProvider extends DeploymentProviderBase {
+	notebook: string | NotebookInfo;
+}
+
+export interface WebPageDeploymentProvider extends DeploymentProviderBase {
+	webPageUrl: string;
+}
+
+export interface DownloadDeploymentProvider extends DeploymentProviderBase {
+	downloadUrl: string;
+}
+
+export interface CommandDeploymentProvider extends DeploymentProviderBase {
+	command: string;
+}
+
+export function instanceOfDialogDeploymentProvider(obj: any): obj is DialogDeploymentProvider {
+	return obj && 'dialog' in obj;
+}
+
+export function instanceOfWizardDeploymentProvider(obj: any): obj is WizardDeploymentProvider {
+	return obj && 'wizard' in obj;
+}
+
+export function instanceOfNotebookDeploymentProvider(obj: any): obj is NotebookDeploymentProvider {
+	return obj && 'notebook' in obj;
+}
+
+export function instanceOfWebPageDeploymentProvider(obj: any): obj is WebPageDeploymentProvider {
+	return obj && 'webPageUrl' in obj;
+}
+
+export function instanceOfDownloadDeploymentProvider(obj: any): obj is DownloadDeploymentProvider {
+	return obj && 'downloadUrl' in obj;
+}
+
+export function instanceOfCommandDeploymentProvider(obj: any): obj is CommandDeploymentProvider {
+	return obj && 'command' in obj;
+}
+
+export interface DeploymentProviderBase {
 	requiredTools: ToolRequirementInfo[];
 	when: string;
 }
 
+export type DeploymentProvider = DialogDeploymentProvider | WizardDeploymentProvider | NotebookDeploymentProvider | WebPageDeploymentProvider | DownloadDeploymentProvider | CommandDeploymentProvider;
+
 export interface WizardInfo {
 	notebook: string | NotebookInfo;
 	type: BdcDeploymentType;
 }
 
-export interface DialogInfo {
+export interface NotebookBasedDialogInfo extends DialogInfoBase {
 	notebook: string | NotebookInfo;
+}
+
+export interface CommandBasedDialogInfo extends DialogInfoBase {
+	command: string;
+}
+
+export type DialogInfo = NotebookBasedDialogInfo | CommandBasedDialogInfo;
+
+export function instanceOfNotebookBasedDialogInfo(obj: any): obj is NotebookBasedDialogInfo {
+	return obj && 'notebook' in obj;
+}
+
+export function instanceOfCommandBasedDialogInfo(obj: any): obj is CommandBasedDialogInfo {
+	return obj && 'command' in obj;
+}
+
+export interface DialogInfoBase {
 	title: string;
 	name: string;
 	tabs: DialogTabInfo[];

extensions/resource-deployment/src/main.ts

@@ -5,12 +5,12 @@
 
 import * as vscode from 'vscode';
 import * as nls from 'vscode-nls';
-import { DialogInfo } from './interfaces';
+import { NotebookBasedDialogInfo } from './interfaces';
 import { NotebookService } from './services/notebookService';
 import { PlatformService } from './services/platformService';
 import { ResourceTypeService } from './services/resourceTypeService';
 import { ToolsService } from './services/toolsService';
-import { NotebookInputDialog } from './ui/notebookInputDialog';
+import { DeploymentInputDialog } from './ui/deploymentInputDialog';
 import { ResourceTypePickerDialog } from './ui/resourceTypePickerDialog';
 
 const localize = nls.loadMessageBundle();
@@ -33,7 +33,7 @@ export function activate(context: vscode.ExtensionContext) {
 		if (filtered.length !== 1) {
 			vscode.window.showErrorMessage(localize('resourceDeployment.UnknownResourceType', 'The resource type: {0} is not defined', resourceTypeName));
 		} else {
-			const dialog = new ResourceTypePickerDialog(context, toolsService, resourceTypeService, filtered[0]);
+			const dialog = new ResourceTypePickerDialog(toolsService, resourceTypeService, filtered[0]);
 			dialog.open();
 		}
 	};
@@ -44,11 +44,11 @@ export function activate(context: vscode.ExtensionContext) {
 	vscode.commands.registerCommand('azdata.resource.sql-bdc.deploy', () => {
 		openDialog('sql-bdc');
 	});
-	vscode.commands.registerCommand('azdata.resource.deploy', () => {
-		openDialog('sql-bdc');
+	vscode.commands.registerCommand('azdata.resource.deploy', (resourceType: string = 'sql-image') => {
+		openDialog(resourceType);
 	});
-	vscode.commands.registerCommand('azdata.openNotebookInputDialog', (dialogInfo: DialogInfo) => {
-		const dialog = new NotebookInputDialog(notebookService, dialogInfo);
+	vscode.commands.registerCommand('azdata.openNotebookInputDialog', (dialogInfo: NotebookBasedDialogInfo) => {
+		const dialog = new DeploymentInputDialog(notebookService, dialogInfo);
 		dialog.open();
 	});
 }

extensions/resource-deployment/src/services/resourceTypeService.ts

@@ -14,9 +14,9 @@ import * as nls from 'vscode-nls';
 import { INotebookService } from './notebookService';
 import { IPlatformService } from './platformService';
 import { IToolsService } from './toolsService';
-import { ResourceType, ResourceTypeOption, DeploymentProvider } from '../interfaces';
+import { ResourceType, ResourceTypeOption, NotebookInfo, DeploymentProvider, instanceOfWizardDeploymentProvider, instanceOfDialogDeploymentProvider, instanceOfNotebookDeploymentProvider, instanceOfDownloadDeploymentProvider, instanceOfWebPageDeploymentProvider, instanceOfCommandDeploymentProvider, instanceOfNotebookBasedDialogInfo } from '../interfaces';
 import { DeployClusterWizard } from '../ui/deployClusterWizard/deployClusterWizard';
-import { NotebookInputDialog } from '../ui/notebookInputDialog';
+import { DeploymentInputDialog } from '../ui/deploymentInputDialog';
 import { KubeService } from './kubeService';
 import { AzdataService } from './azdataService';
 const localize = nls.loadMessageBundle();
@@ -38,20 +38,15 @@ export class ResourceTypeService implements IResourceTypeService {
 	 */
 	getResourceTypes(filterByPlatform: boolean = true): ResourceType[] {
 		if (this._resourceTypes.length === 0) {
-			const pkgJson = require('../../package.json');
-			let extensionFullName: string;
-			if (pkgJson && pkgJson.name && pkgJson.publisher) {
-				extensionFullName = `${pkgJson.publisher}.${pkgJson.name}`;
-			} else {
-				const errorMessage = localize('resourceDeployment.extensionFullNameError', 'Could not find package.json or the name/publisher is not set');
-				this.platformService.showErrorMessage(errorMessage);
-				throw new Error(errorMessage);
-			}
-
-			// If we load package.json directly using require(path) the contents won't be localized
-			this._resourceTypes = vscode.extensions.getExtension(extensionFullName)!.packageJSON.resourceTypes as ResourceType[];
-			this._resourceTypes.forEach(resourceType => {
-				resourceType.getProvider = (selectedOptions) => { return this.getProvider(resourceType, selectedOptions); };
+			vscode.extensions.all.forEach((extension) => {
+				const extensionResourceTypes = extension.packageJSON.contributes && extension.packageJSON.contributes.resourceDeploymentTypes as ResourceType[];
+				if (extensionResourceTypes) {
+					extensionResourceTypes.forEach((resourceType) => {
+						this.updatePathProperties(resourceType, extension.extensionPath);
+						resourceType.getProvider = (selectedOptions) => { return this.getProvider(resourceType, selectedOptions); };
+						this._resourceTypes.push(resourceType);
+					});
+				}
 			});
 		}
 
@@ -63,6 +58,39 @@ export class ResourceTypeService implements IResourceTypeService {
 		return resourceTypes;
 	}
 
+	private updatePathProperties(resourceType: ResourceType, extensionPath: string): void {
+		resourceType.icon.dark = path.join(extensionPath, resourceType.icon.dark);
+		resourceType.icon.light = path.join(extensionPath, resourceType.icon.light);
+		resourceType.providers.forEach((provider) => {
+			if (instanceOfNotebookDeploymentProvider(provider)) {
+				this.updateNotebookPath(provider, extensionPath);
+			} else if (instanceOfDialogDeploymentProvider(provider) && instanceOfNotebookBasedDialogInfo(provider.dialog)) {
+				this.updateNotebookPath(provider.dialog, extensionPath);
+			}
+			else if ('wizard' in provider) {
+				this.updateNotebookPath(provider.wizard, extensionPath);
+			}
+		});
+	}
+
+	private updateNotebookPath(objWithNotebookProperty: { notebook: string | NotebookInfo } | undefined, extensionPath: string): void {
+		if (objWithNotebookProperty && objWithNotebookProperty.notebook) {
+			if (typeof objWithNotebookProperty.notebook === 'string') {
+				objWithNotebookProperty.notebook = path.join(extensionPath, objWithNotebookProperty.notebook);
+			} else {
+				if (objWithNotebookProperty.notebook.darwin) {
+					objWithNotebookProperty.notebook.darwin = path.join(extensionPath, objWithNotebookProperty.notebook.darwin);
+				}
+				if (objWithNotebookProperty.notebook.win32) {
+					objWithNotebookProperty.notebook.darwin = path.join(extensionPath, objWithNotebookProperty.notebook.win32);
+				}
+				if (objWithNotebookProperty.notebook.linux) {
+					objWithNotebookProperty.notebook = path.join(extensionPath, objWithNotebookProperty.notebook.linux);
+				}
+			}
+		}
+	}
+
 	/**
 	 * Validate the resource types and returns validation error messages if any.
 	 * @param resourceTypes resource types to be validated
@@ -140,7 +168,12 @@ export class ResourceTypeService implements IResourceTypeService {
 			let providerIndex = 1;
 			resourceType.providers.forEach(provider => {
 				const providerPositionInfo = `${positionInfo}, provider index: ${providerIndex} `;
-				if (!provider.wizard && !provider.dialog && !provider.notebook && !provider.downloadUrl && !provider.webPageUrl) {
+				if (!instanceOfWizardDeploymentProvider(provider)
+					&& !instanceOfDialogDeploymentProvider(provider)
+					&& !instanceOfNotebookDeploymentProvider(provider)
+					&& !instanceOfDownloadDeploymentProvider(provider)
+					&& !instanceOfWebPageDeploymentProvider(provider)
+					&& !instanceOfCommandDeploymentProvider(provider)) {
 					errorMessages.push(`No deployment method defined for the provider, ${providerPositionInfo}`);
 				}
 
@@ -197,15 +230,15 @@ export class ResourceTypeService implements IResourceTypeService {
 
 	public startDeployment(provider: DeploymentProvider): void {
 		const self = this;
-		if (provider.wizard) {
+		if (instanceOfWizardDeploymentProvider(provider)) {
 			const wizard = new DeployClusterWizard(provider.wizard, new KubeService(), new AzdataService(this.platformService), this.notebookService);
 			wizard.open();
-		} else if (provider.dialog) {
-			const dialog = new NotebookInputDialog(this.notebookService, provider.dialog);
+		} else if (instanceOfDialogDeploymentProvider(provider)) {
+			const dialog = new DeploymentInputDialog(this.notebookService, provider.dialog);
 			dialog.open();
-		} else if (provider.notebook) {
+		} else if (instanceOfNotebookDeploymentProvider(provider)) {
 			this.notebookService.launchNotebook(provider.notebook);
-		} else if (provider.downloadUrl) {
+		} else if (instanceOfDownloadDeploymentProvider(provider)) {
 			const taskName = localize('resourceDeployment.DownloadAndLaunchTaskName', "Download and launch installer, URL: {0}", provider.downloadUrl);
 			azdata.tasks.startBackgroundOperation({
 				displayName: taskName,
@@ -223,8 +256,10 @@ export class ResourceTypeService implements IResourceTypeService {
 					});
 				}
 			});
-		} else if (provider.webPageUrl) {
+		} else if (instanceOfWebPageDeploymentProvider(provider)) {
 			vscode.commands.executeCommand('vscode.open', vscode.Uri.parse(provider.webPageUrl));
+		} else if (instanceOfCommandDeploymentProvider(provider)) {
+			vscode.commands.executeCommand(provider.command);
 		}
 	}
 

extensions/resource-deployment/src/ui/deploymentInputDialog.ts

@@ -8,14 +8,14 @@ import * as vscode from 'vscode';
 import * as nls from 'vscode-nls';
 import { DialogBase } from './dialogBase';
 import { INotebookService } from '../services/notebookService';
-import { DialogInfo } from '../interfaces';
+import { DialogInfo, instanceOfNotebookBasedDialogInfo } from '../interfaces';
 import { Validator, initializeDialog, InputComponents, setModelValues } from './modelViewUtils';
 import { Model } from './model';
 import { EOL } from 'os';
 
 const localize = nls.loadMessageBundle();
 
-export class NotebookInputDialog extends DialogBase {
+export class DeploymentInputDialog extends DialogBase {
 
 	private inputComponents: InputComponents = {};
 
@@ -62,10 +62,14 @@ export class NotebookInputDialog extends DialogBase {
 	private onComplete(): void {
 		const model: Model = new Model();
 		setModelValues(this.inputComponents, model);
-		model.setEnvironmentVariables();
-		this.notebookService.launchNotebook(this.dialogInfo.notebook).then(() => { }, (error) => {
-			vscode.window.showErrorMessage(error);
-		});
+		if (instanceOfNotebookBasedDialogInfo(this.dialogInfo)) {
+			model.setEnvironmentVariables();
+			this.notebookService.launchNotebook(this.dialogInfo.notebook).then(() => { }, (error) => {
+				vscode.window.showErrorMessage(error);
+			});
+		} else {
+			vscode.commands.executeCommand(this.dialogInfo.command, model);
+		}
 		this.dispose();
 	}
 }

extensions/resource-deployment/src/ui/modelViewUtils.ts

@@ -6,7 +6,7 @@
 import * as azdata from 'azdata';
 import * as vscode from 'vscode';
 import * as nls from 'vscode-nls';
-import { DialogInfo, FieldType, FieldInfo, SectionInfo, LabelPosition } from '../interfaces';
+import { DialogInfoBase, FieldType, FieldInfo, SectionInfo, LabelPosition } from '../interfaces';
 import { Model } from './model';
 
 const localize = nls.loadMessageBundle();
@@ -30,7 +30,7 @@ export const DefaultInputComponentWidth = '400px';
 export const DefaultLabelComponentWidth = '200px';
 
 export interface DialogContext extends CreateContext {
-	dialogInfo: DialogInfo;
+	dialogInfo: DialogInfoBase;
 	container: azdata.window.Dialog;
 }
 

extensions/resource-deployment/src/ui/resourceTypePickerDialog.ts

@@ -4,10 +4,9 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as azdata from 'azdata';
-import * as vscode from 'vscode';
 import * as nls from 'vscode-nls';
 import { DialogBase } from './dialogBase';
-import { ResourceType, DeploymentProvider, AgreementInfo } from '../interfaces';
+import { ResourceType, AgreementInfo, DeploymentProvider } from '../interfaces';
 import { IResourceTypeService } from '../services/resourceTypeService';
 import { IToolsService } from '../services/toolsService';
 import { EOL } from 'os';
@@ -29,7 +28,7 @@ export class ResourceTypePickerDialog extends DialogBase {
 	private _agreementContainer!: azdata.DivContainer;
 	private _agreementCheckboxChecked: boolean = false;
 
-	constructor(private extensionContext: vscode.ExtensionContext,
+	constructor(
 		private toolsService: IToolsService,
 		private resourceTypeService: IResourceTypeService,
 		resourceType: ResourceType) {
@@ -125,13 +124,16 @@ export class ResourceTypePickerDialog extends DialogBase {
 		const card = this._view.modelBuilder.card().withProperties<azdata.CardProperties>({
 			cardType: azdata.CardType.VerticalButton,
 			iconPath: {
-				dark: this.extensionContext.asAbsolutePath(resourceType.icon.dark),
-				light: this.extensionContext.asAbsolutePath(resourceType.icon.light)
+				dark: resourceType.icon.dark,
+				light: resourceType.icon.light
 			},
 			label: resourceType.displayName,
-			selected: (this._selectedResourceType && this._selectedResourceType.name === resourceType.name)
+			selected: (this._selectedResourceType && this._selectedResourceType.name === resourceType.name),
+			width: '220px',
+			height: '180px',
+			iconWidth: '50px',
+			iconHeight: '50px'
 		}).component();
-
 		this._resourceTypeCards.push(card);
 		this._cardResourceTypeMap.set(resourceType.name, card);
 		this._toDispose.push(card.onCardSelectedChanged(() => this.selectResourceType(resourceType)));