Update arc api (#11932)

extensions/arc/src/models/controllerModel.ts

@@ -80,7 +80,7 @@ export class ControllerModel {
 			}
 		}
 
-		await this._azdataApi.login(this.info.url, this.info.username, this._password);
+		await this._azdataApi.azdata.login(this.info.url, this.info.username, this._password);
 	}
 
 	/**
@@ -98,7 +98,7 @@ export class ControllerModel {
 		await this.azdataLogin(promptReconnect);
 		this._registrations = [];
 		await Promise.all([
-			this._azdataApi.dc.config.show().then(result => {
+			this._azdataApi.azdata.arc.dc.config.show().then(result => {
 				this._controllerConfig = result.result;
 				this.configLastUpdated = new Date();
 				this._onConfigUpdated.fire(this._controllerConfig);
@@ -112,7 +112,7 @@ export class ControllerModel {
 				this._onConfigUpdated.fire(this._controllerConfig);
 				throw err;
 			}),
-			this._azdataApi.dc.endpoint.list().then(result => {
+			this._azdataApi.azdata.arc.dc.endpoint.list().then(result => {
 				this._endpoints = result.result;
 				this.endpointsLastUpdated = new Date();
 				this._onEndpointsUpdated.fire(this._endpoints);
@@ -127,7 +127,7 @@ export class ControllerModel {
 				throw err;
 			}),
 			Promise.all([
-				this._azdataApi.postgres.server.list().then(result => {
+				this._azdataApi.azdata.arc.postgres.server.list().then(result => {
 					this._registrations.push(...result.result.map(r => {
 						return {
 							instanceName: r.name,
@@ -136,7 +136,7 @@ export class ControllerModel {
 						};
 					}));
 				}),
-				this._azdataApi.sql.mi.list().then(result => {
+				this._azdataApi.azdata.arc.sql.mi.list().then(result => {
 					this._registrations.push(...result.result.map(r => {
 						return {
 							instanceName: r.name,

extensions/arc/src/models/miaaModel.ts

@@ -74,7 +74,7 @@ export class MiaaModel extends ResourceModel {
 		this._refreshPromise = new Deferred();
 		try {
 			await this._controllerModel.azdataLogin();
-			const instanceRefresh = this._azdataApi.sql.mi.show(this.info.name).then(result => {
+			const instanceRefresh = this._azdataApi.azdata.arc.sql.mi.show(this.info.name).then(result => {
 				this._config = result.result;
 				this.configLastUpdated = new Date();
 				this._onConfigUpdated.fire(this._config);

extensions/arc/src/ui/dashboards/miaa/miaaDashboardOverviewPage.ts

@@ -188,7 +188,7 @@ export class MiaaDashboardOverviewPage extends DashboardPage {
 				deleteButton.enabled = false;
 				try {
 					if (await promptForResourceDeletion(this._miaaModel.info.name)) {
-						await this._azdataApi.sql.mi.delete(this._miaaModel.info.name);
+						await this._azdataApi.azdata.arc.sql.mi.delete(this._miaaModel.info.name);
 						await this._controllerModel.refreshTreeNode();
 						vscode.window.showInformationMessage(loc.resourceDeleted(this._miaaModel.info.name));
 					}

extensions/azdata/src/azdata.ts

@@ -3,32 +3,99 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { AzdataOutput } from 'azdata-ext';
 import * as os from 'os';
 import * as vscode from 'vscode';
 import { HttpClient } from './common/httpClient';
 import * as loc from './localizedConstants';
 import { executeCommand, executeSudoCommand, ExitCodeError } from './common/childProcess';
 import { searchForCmd } from './common/utils';
+import * as azdataExt from 'azdata-ext';
 
 export const azdataHostname = 'https://aka.ms';
 export const azdataUri = 'azdata-msi';
 
-export interface IAzdataTool {
+export interface IAzdataTool extends azdataExt.IAzdataApi {
 	path: string,
-	version: string,
+	toolVersion: string,
 	/**
 	 * Executes azdata with the specified arguments (e.g. --version) and returns the result
 	 * @param args The args to pass to azdata
 	 * @param parseResult A function used to parse out the raw result into the desired shape
 	 */
-	executeCommand<R>(args: string[], additionalEnvVars?: { [key: string]: string }): Promise<AzdataOutput<R>>
+	executeCommand<R>(args: string[], additionalEnvVars?: { [key: string]: string }): Promise<azdataExt.AzdataOutput<R>>
 }
 
 class AzdataTool implements IAzdataTool {
-	constructor(public path: string, public version: string, private _outputChannel: vscode.OutputChannel) { }
+	constructor(public path: string, public toolVersion: string, private _outputChannel: vscode.OutputChannel) { }
 
-	public async executeCommand<R>(args: string[], additionalEnvVars?: { [key: string]: string }): Promise<AzdataOutput<R>> {
+	public arc = {
+		dc: {
+			create: async (namespace: string, name: string, connectivityMode: string, resourceGroup: string, location: string, subscription: string, profileName?: string, storageClass?: string): Promise<azdataExt.AzdataOutput<void>> => {
+				const args = ['arc', 'dc', 'create',
+					'--namespace', namespace,
+					'--name', name,
+					'--connectivity-mode', connectivityMode,
+					'--resource-group', resourceGroup,
+					'--location', location,
+					'--subscription', subscription];
+				if (profileName) {
+					args.push('--profile-name', profileName);
+				}
+				if (storageClass) {
+					args.push('--storage-class', storageClass);
+				}
+				return this.executeCommand<void>(args);
+			},
+			endpoint: {
+				list: async () => {
+					return this.executeCommand<azdataExt.DcEndpointListResult[]>(['arc', 'dc', 'endpoint', 'list']);
+				}
+			},
+			config: {
+				list: async () => {
+					return this.executeCommand<azdataExt.DcConfigListResult[]>(['arc', 'dc', 'config', 'list']);
+				},
+				show: async () => {
+					return this.executeCommand<azdataExt.DcConfigShowResult>(['arc', 'dc', 'config', 'show']);
+				}
+			}
+		},
+		postgres: {
+			server: {
+				list: async () => {
+					return this.executeCommand<azdataExt.PostgresServerListResult[]>(['arc', 'postgres', 'server', 'list']);
+				},
+				show: async (name: string) => {
+					return this.executeCommand<azdataExt.PostgresServerShowResult>(['arc', 'postgres', 'server', 'show', '-n', name]);
+				}
+			}
+		},
+		sql: {
+			mi: {
+				delete: async (name: string) => {
+					return this.executeCommand<void>(['arc', 'sql', 'mi', 'delete', '-n', name]);
+				},
+				list: async () => {
+					return this.executeCommand<azdataExt.SqlMiListResult[]>(['arc', 'sql', 'mi', 'list']);
+				},
+				show: async (name: string) => {
+					return this.executeCommand<azdataExt.SqlMiShowResult>(['arc', 'sql', 'mi', 'show', '-n', name]);
+				}
+			}
+		}
+	};
+
+	public async login(endpoint: string, username: string, password: string): Promise<azdataExt.AzdataOutput<void>> {
+		return this.executeCommand<void>(['login', '-e', endpoint, '-u', username], { 'AZDATA_PASSWORD': password });
+	}
+
+	public async version(): Promise<azdataExt.AzdataOutput<string>> {
+		const output = await this.executeCommand<string>(['--version']);
+		this.toolVersion = parseVersion(output.stdout[0]);
+		return output;
+	}
+
+	public async executeCommand<R>(args: string[], additionalEnvVars?: { [key: string]: string }): Promise<azdataExt.AzdataOutput<R>> {
 		try {
 			const output = JSON.parse((await executeCommand(`"${this.path}"`, args.concat(['--output', 'json']), this._outputChannel, additionalEnvVars)).stdout);
 			return {
@@ -65,7 +132,7 @@ export async function findAzdata(outputChannel: vscode.OutputChannel): Promise<I
 			default:
 				azdata = await findSpecificAzdata('azdata', outputChannel);
 		}
-		outputChannel.appendLine(loc.foundExistingAzdata(azdata.path, azdata.version));
+		outputChannel.appendLine(loc.foundExistingAzdata(azdata.path, azdata.toolVersion));
 		return azdata;
 	} catch (err) {
 		outputChannel.appendLine(loc.couldNotFindAzdata(err));

extensions/azdata/src/extension.ts

@@ -6,6 +6,7 @@
 import * as azdataExt from 'azdata-ext';
 import * as vscode from 'vscode';
 import { findAzdata, IAzdataTool } from './azdata';
+import * as loc from './localizedConstants';
 
 let localAzdata: IAzdataTool | undefined = undefined;
 
@@ -13,52 +14,75 @@ export async function activate(): Promise<azdataExt.IExtension> {
 	const outputChannel = vscode.window.createOutputChannel('azdata');
 	localAzdata = await checkForAzdata(outputChannel);
 	return {
+		azdata: {
+			arc: {
 				dc: {
+					create: async (namespace: string, name: string, connectivityMode: string, resourceGroup: string, location: string, subscription: string, profileName?: string, storageClass?: string) => {
+						throwIfNoAzdata();
+						return localAzdata!.arc.dc.create(namespace, name, connectivityMode, resourceGroup, location, subscription, profileName, storageClass);
+					},
 					endpoint: {
 						list: async () => {
-					return executeLocalAzdataCommand(['arc', 'dc', 'endpoint', 'list']);
+							throwIfNoAzdata();
+							return localAzdata!.arc.dc.endpoint.list();
 						}
 					},
 					config: {
-				show: async () => {
+						list: async () => {
-					return executeLocalAzdataCommand(['arc', 'dc', 'config', 'show']);
+							throwIfNoAzdata();
-				}
+							return localAzdata!.arc.dc.config.list();
-			}
 						},
-		login: async (endpoint: string, username: string, password: string) => {
+						show: async () => {
-			return executeLocalAzdataCommand(['login', '-e', endpoint, '-u', username], { 'AZDATA_PASSWORD': password });
+							throwIfNoAzdata();
+							return localAzdata!.arc.dc.config.show();
+						}
+					}
 				},
 				postgres: {
 					server: {
 						list: async () => {
-					return executeLocalAzdataCommand(['arc', 'postgres', 'server', 'list']);
+							throwIfNoAzdata();
+							return localAzdata!.arc.postgres.server.list();
 						},
 						show: async (name: string) => {
-					return executeLocalAzdataCommand(['arc', 'postgres', 'server', 'show', '-n', name]);
+							throwIfNoAzdata();
+							return localAzdata!.arc.postgres.server.show(name);
 						}
 					}
 				},
 				sql: {
 					mi: {
 						delete: async (name: string) => {
-					return executeLocalAzdataCommand(['arc', 'sql', 'mi', 'delete', '-n', name]);
+							throwIfNoAzdata();
+							return localAzdata!.arc.sql.mi.delete(name);
 						},
 						list: async () => {
-					return executeLocalAzdataCommand(['arc', 'sql', 'mi', 'list']);
+							throwIfNoAzdata();
+							return localAzdata!.arc.sql.mi.list();
 						},
 						show: async (name: string) => {
-					return executeLocalAzdataCommand(['arc', 'sql', 'mi', 'show', '-n', name]);
+							throwIfNoAzdata();
+							return localAzdata!.arc.sql.mi.show(name);
 						}
 					}
 				}
+			},
+			login: async (endpoint: string, username: string, password: string) => {
+				throwIfNoAzdata();
+				return localAzdata!.login(endpoint, username, password);
+			},
+			version: async () => {
+				throwIfNoAzdata();
+				return localAzdata!.version();
+			}
+		}
 	};
 }
 
-async function executeLocalAzdataCommand<R>(args: string[], additionalEnvVars?: { [key: string]: string }): Promise<azdataExt.AzdataOutput<R>> {
+function throwIfNoAzdata(): void {
 	if (!localAzdata) {
-		throw new Error('No azdata');
+		throw new Error(loc.noAzdata);
 	}
-	return localAzdata.executeCommand(args, additionalEnvVars);
 }
 
 async function checkForAzdata(outputChannel: vscode.OutputChannel): Promise<IAzdataTool | undefined> {

extensions/azdata/src/localizedConstants.ts

@@ -28,3 +28,4 @@ export function installError(err: any): string { return localize('azdata.install
 export function platformUnsupported(platform: string): string { return localize('azdata.platformUnsupported', "Platform '{0}' is currently unsupported", platform); }
 export function unexpectedCommandError(errMsg: string): string { return localize('azdata.unexpectedCommandError', "Unexpected error executing command : {0}", errMsg); }
 export function unexpectedExitCode(code: number, err: string): string { return localize('azdata.unexpectedExitCode', "Unexpected exit code from command : {1} ({0})", code, err); }
+export const noAzdata = localize('azdata.NoAzdata', "No azdata available");

extensions/azdata/src/typings/azdata-ext.d.ts

@@ -34,6 +34,8 @@ declare module 'azdata-ext' {
 		workers: number // 1
 	}
 
+	export type DcConfigListResult = string;
+
 	export interface DcConfigShowResult {
 		apiVersion: string, // "arcdata.microsoft.com/v1alpha1"
 		kind: string, // "DataController"
@@ -127,6 +129,20 @@ declare module 'azdata-ext' {
 		}
 	}
 
+	export interface PostgresServerShowResult {
+		apiVersion: string, // "arcdata.microsoft.com/v1alpha1"
+		kind: string, // "postgresql-12"
+		metadata: {
+			creationTimestamp: string, // "2020-08-19T20:25:11Z"
+			generation: number, // 1
+			name: string, // "chgagnon-pg"
+			namespace: string, // "arc",
+			resourceVersion: string, // "214944",
+			selfLink: string, // "/apis/arcdata.microsoft.com/v1alpha1/namespaces/arc/postgresql-12s/chgagnon-pg",
+			uid: string, // "26d0f5bb-0c0b-4225-a6b5-5be2bf6feac0"
+		}
+	}
+
 	export interface PostgresServerShowResult {
 		apiVersion: string, // "arcdata.microsoft.com/v1alpha1"
 		kind: string, // "postgresql-12"
@@ -155,34 +171,12 @@ declare module 'azdata-ext' {
 					}
 				]
 			},
-			scale: {
-				shards: number // 1
-			},
-			scheduling: {
-				default: {
-					resources: {
-						requests: {
-							memory: string, // "256Mi"
-						}
-					}
-				}
-			},
-			storage: {
-				data: {
-					className: string, // "local-storage",
-					size: string // "5Gi"
-				},
-				logs: {
-					className: string, // "local-storage",
-					size: string // "5Gi"
-				}
-			}
-		},
 			status: {
 				readyPods: string, // "1/1",
 				state: string // "Ready"
 			}
 		}
+	}
 
 	export interface AzdataOutput<R> {
 		logs: string[],
@@ -192,16 +186,18 @@ declare module 'azdata-ext' {
 		code?: number
 	}
 
-	export interface IExtension {
+	export interface IAzdataApi {
+		arc: {
 			dc: {
+				create(namespace: string, name: string, connectivityMode: string, resourceGroup: string, location: string, subscription: string, profileName?: string, storageClass?: string): Promise<AzdataOutput<void>>,
 				endpoint: {
 					list(): Promise<AzdataOutput<DcEndpointListResult[]>>
 				},
 				config: {
+					list(): Promise<AzdataOutput<DcConfigListResult[]>>,
 					show(): Promise<AzdataOutput<DcConfigShowResult>>
 				}
 			},
-		login(endpoint: string, username: string, password: string): Promise<AzdataOutput<void>>,
 			postgres: {
 				server: {
 					list(): Promise<AzdataOutput<PostgresServerListResult[]>>,
@@ -216,5 +212,11 @@ declare module 'azdata-ext' {
 				}
 			}
 		}
-}
+		login(endpoint: string, username: string, password: string): Promise<AzdataOutput<any>>,
+		version(): Promise<AzdataOutput<string>>
+	}
 
+	export interface IExtension {
+		azdata: IAzdataApi;
+	}
+}