Add azcli extension (#16029)

build/azure-pipelines/sql-product-build.yml

@@ -47,7 +47,7 @@ jobs:
   steps:
   - template: linux/sql-product-build-linux.yml
     parameters:
-      extensionsToUnitTest: ["admin-tool-ext-win", "agent", "azdata", "azurecore", "cms", "dacpac", "import", "schema-compare", "notebook", "resource-deployment", "machine-learning", "sql-database-projects", "data-workspace"]
+      extensionsToUnitTest: ["admin-tool-ext-win", "agent", "azcli", "azdata", "azurecore", "cms", "dacpac", "data-workspace", "import", "machine-learning", "notebook", "resource-deployment", "schema-compare", "sql-database-projects"]
   timeoutInMinutes: 90
 
 - job: Windows

build/lib/extensions.js

@@ -214,8 +214,10 @@ const externalExtensions = [
     'agent',
     'arc',
     'asde-deployment',
+    'azcli',
     'azdata',
     'azurehybridtoolkit',
+    'azuremonitor',
     'cms',
     'dacpac',
     'import',

build/lib/extensions.ts

@@ -249,6 +249,7 @@ const externalExtensions = [
 	'agent',
 	'arc',
 	'asde-deployment',
+	'azcli',
 	'azdata',
 	'azurehybridtoolkit',
 	'azuremonitor',

extensions/azcli/.gitignore

@@ -0,0 +1 @@
+*.vsix

extensions/azcli/.vscodeignore

@@ -0,0 +1,9 @@
+.gitignore
+src/**
+out/**
+extension.webpack.config.js
+tsconfig.json
+yarn.lock
+coverConfig.json
+*.vsix
+coverage

extensions/azcli/README.md

@@ -0,0 +1,25 @@
+# Microsoft Azure Data CLI Extension for Azure Data Studio
+
+Welcome to Microsoft Azure Data CLI Extension for Azure Data Studio!
+
+**This extension is only applicable to customers in the Azure Arc data services public preview. Other usage is not supported at this time.**
+
+## Overview
+
+This extension adds support for the Azure Data CLI (azdata) within Azure Data Studio.
+
+See https://docs.microsoft.com/cli/azure/?view=azure-cli-latest for more information on the tool.
+
+## Code of Conduct
+
+This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.
+
+## Privacy Statement
+
+The [Microsoft Enterprise and Developer Privacy Statement](https://privacy.microsoft.com/privacystatement) describes the privacy statement of this software.
+
+## License
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Licensed under the [Source EULA](https://raw.githubusercontent.com/Microsoft/azuredatastudio/main/LICENSE.txt).

extensions/azcli/coverConfig.json

@@ -0,0 +1,21 @@
+{
+	"enabled": true,
+	"relativeSourcePath": "..",
+	"relativeCoverageDir": "../../coverage",
+	"ignorePatterns": [
+		"**/node_modules/**",
+		"**/test/**",
+		"localizedConstants.js",
+		"extension.js"
+	],
+	"reports": [
+		"cobertura",
+		"lcov",
+		"json"
+	],
+	"verbose": false,
+	"remapOptions": {
+		"basePath": "..",
+		"useAbsolutePaths": true
+	}
+}

extensions/azcli/extension.webpack.config.js

@@ -0,0 +1,17 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+//@ts-check
+
+'use strict';
+
+const withDefaults = require('../shared.webpack.config');
+
+module.exports = withDefaults({
+	context: __dirname,
+	entry: {
+		extension: './src/extension.ts'
+	}
+});

extensions/azcli/package.json

@@ -0,0 +1,159 @@
+{
+  "name": "azdata",
+  "displayName": "%azdata.displayName%",
+  "description": "%azdata.description%",
+  "version": "0.6.6",
+  "publisher": "Microsoft",
+  "preview": true,
+  "license": "https://raw.githubusercontent.com/Microsoft/azuredatastudio/main/LICENSE.txt",
+  "icon": "images/extension.png",
+  "engines": {
+    "vscode": "*",
+    "azdata": ">=1.26.0"
+  },
+  "activationEvents": [
+    "*"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Microsoft/azuredatastudio.git"
+  },
+  "extensionDependencies": [
+    "microsoft.resource-deployment"
+  ],
+  "main": "./out/extension",
+  "contributes": {
+    "configuration": [
+      {
+        "type": "object",
+        "title": "%azdata.config.title%",
+        "properties": {
+          "azdata.logDebugInfo": {
+            "type": "boolean",
+            "default": false,
+            "description": "%azdata.config.debug%"
+          },
+          "azdata.acceptEula": {
+            "type": "string",
+            "default": "prompt",
+            "enum": [
+              "dontPrompt",
+              "prompt"
+            ],
+            "enumDescriptions": [
+              "%azdata.acceptEula.dontPrompt.description%",
+              "%azdata.acceptEula.prompt.description%"
+            ],
+            "description": "%azdata.acceptEula.description%"
+          },
+          "azdata.install": {
+            "type": "string",
+            "default": "prompt",
+            "enum": [
+              "dontPrompt",
+              "prompt"
+            ],
+            "enumDescriptions": [
+              "%azdata.install.dontPrompt.description%",
+              "%azdata.install.prompt.description%"
+            ],
+            "description": "%azdata.install.description%"
+          },
+          "azdata.update": {
+            "type": "string",
+            "default": "prompt",
+            "enum": [
+              "dontPrompt",
+              "prompt"
+            ],
+            "enumDescriptions": [
+              "%azdata.update.dontPrompt.description%",
+              "%azdata.update.prompt.description%"
+            ],
+            "description": "%azdata.update.description%"
+          },
+          "azdata.requiredUpdate": {
+            "type": "string",
+            "default": "prompt",
+            "enum": [
+              "dontPrompt",
+              "prompt"
+            ],
+            "enumDescriptions": [
+              "%azdata.update.dontPrompt.description%",
+              "%azdata.update.prompt.description%"
+            ],
+            "description": "%azdata.requiredUpdate.description%"
+          }
+        }
+      }
+    ],
+    "commands": [
+      {
+        "command": "azdata.acceptEula",
+        "title": "%azdata.acceptEula.command.name%",
+        "category": "%command.category%"
+      },
+      {
+        "command": "azdata.install",
+        "title": "%azdata.install.command.name%",
+        "category": "%command.category%"
+      },
+      {
+        "command": "azdata.update",
+        "title": "%azdata.update.command.name%",
+        "category": "%command.category%"
+      }
+    ],
+    "menus": {
+      "commandPalette": [
+        {
+          "command": "azdata.acceptEula",
+          "when": "!azdata.eulaAccepted"
+        },
+        {
+          "command": "azdata.install",
+          "when": "!azdata.found"
+        },
+        {
+          "command": "azdata.update",
+          "when": "azdata.found"
+        }
+      ]
+    },
+    "resourceDeploymentOptionsSources": [
+      {
+        "id": "arc.controller.config.profiles"
+      }
+    ]
+  },
+  "dependencies": {
+    "request": "^2.88.2",
+    "semver": "^7.3.2",
+    "sudo-prompt": "^9.2.1",
+    "vscode-nls": "^4.1.2",
+    "which": "^2.0.2"
+  },
+  "devDependencies": {
+    "@types/mocha": "^5.2.5",
+    "@types/node": "^12.11.7",
+    "@types/request": "^2.48.5",
+    "@types/semver": "^7.3.1",
+    "@types/sinon": "^9.0.4",
+    "@types/uuid": "^8.0.0",
+    "@types/which": "^1.3.2",
+    "mocha": "^5.2.0",
+    "mocha-junit-reporter": "^1.17.0",
+    "mocha-multi-reporters": "^1.1.7",
+    "nock": "^13.0.2",
+    "should": "^13.2.3",
+    "sinon": "^9.0.2",
+    "typemoq": "^2.1.0",
+    "vscodetestcover": "^1.1.0"
+  },
+  "__metadata": {
+    "id": "73",
+    "publisherDisplayName": "Microsoft",
+    "publisherId": "Microsoft"
+  }
+}

extensions/azcli/package.nls.json

@@ -0,0 +1,25 @@
+{
+	"azdata.displayName": "Azure Data CLI",
+	"azdata.description": "Support for Azure Data CLI.",
+	"azdata.config.title": "Azure Data CLI Configuration",
+	"azdata.config.debug": "Log debug info to the output channel for all executed azdata commands",
+
+	"command.category": "Azure Data CLI",
+	"azdata.acceptEula.command.name": "Accept Eula",
+	"azdata.install.command.name": "Install",
+	"azdata.update.command.name": "Check for Update",
+	"azdata.category": "Azure Data CLI",
+
+	"azdata.acceptEula.description": "Choose how acceptance of EULA for the Azure Data CLI is done",
+	"azdata.acceptEula.prompt.description": "The user will be prompted for acceptance of EULA for the Azure Data CLI",
+	"azdata.acceptEula.dontPrompt.description": "The user will not be prompted for acceptance of EULA for the Azure Data CLI",
+
+	"azdata.install.description": "Choose how install of Azure Data CLI is done",
+	"azdata.install.prompt.description": "The user will be prompted for installation of the Azure Data CLI",
+	"azdata.install.dontPrompt.description": "The user will not be prompted for installation of the Azure Data CLI",
+
+	"azdata.update.description": "Choose whether you will be prompted when an update of the Azure Data CLI is available.",
+	"azdata.requiredUpdate.description": "Choose whether you will be prompted when a required update of the Azure Data CLI is available.",
+	"azdata.update.prompt.description": "The user will be prompted for update of the Azure Data CLI",
+	"azdata.update.dontPrompt.description": "The user will not be prompted for update of the Azure Data CLI"
+}

extensions/azcli/src/api.ts

@@ -0,0 +1,202 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as azdataExt from 'azdata-ext';
+import * as vscode from 'vscode';
+import { IAzdataTool, isEulaAccepted, MIN_AZDATA_VERSION, promptForEula } from './azdata';
+import Logger from './common/logger';
+import { NoAzdataError } from './common/utils';
+import * as constants from './constants';
+import * as loc from './localizedConstants';
+import { AzdataToolService } from './services/azdataToolService';
+
+/**
+ * Validates that :
+ *	- Azdata is installed
+ *	- The Azdata version is >= the minimum required version
+ *	- The Azdata CLI has been accepted
+ * @param azdata The azdata tool to check
+ * @param eulaAccepted Whether the Azdata CLI EULA has been accepted
+ */
+async function validateAzdata(azdata: IAzdataTool | undefined, eulaAccepted: boolean): Promise<void> {
+	throwIfNoAzdataOrEulaNotAccepted(azdata, eulaAccepted);
+	await throwIfRequiredVersionMissing(azdata);
+}
+
+export function throwIfNoAzdataOrEulaNotAccepted(azdata: IAzdataTool | undefined, eulaAccepted: boolean): asserts azdata {
+	throwIfNoAzdata(azdata);
+	if (!eulaAccepted) {
+		Logger.log(loc.eulaNotAccepted);
+		throw new Error(loc.eulaNotAccepted);
+	}
+}
+
+export async function throwIfRequiredVersionMissing(azdata: IAzdataTool): Promise<void> {
+	const currentVersion = await azdata.getSemVersion();
+	if (currentVersion.compare(MIN_AZDATA_VERSION) < 0) {
+		throw new Error(loc.missingRequiredVersion(MIN_AZDATA_VERSION.raw));
+	}
+}
+
+export function throwIfNoAzdata(localAzdata: IAzdataTool | undefined): asserts localAzdata {
+	if (!localAzdata) {
+		Logger.log(loc.noAzdata);
+		throw new NoAzdataError();
+	}
+}
+
+export function getExtensionApi(memento: vscode.Memento, azdataToolService: AzdataToolService, localAzdataDiscovered: Promise<IAzdataTool | undefined>): azdataExt.IExtension {
+	return {
+		isEulaAccepted: async () => {
+			throwIfNoAzdata(await localAzdataDiscovered); // ensure that we have discovered Azdata
+			return !!memento.get<boolean>(constants.eulaAccepted);
+		},
+		promptForEula: async (requireUserAction: boolean = true): Promise<boolean> => {
+			await localAzdataDiscovered;
+			return promptForEula(memento, true /* userRequested */, requireUserAction);
+		},
+		azdata: getAzdataApi(localAzdataDiscovered, azdataToolService, memento)
+	};
+}
+
+export function getAzdataApi(localAzdataDiscovered: Promise<IAzdataTool | undefined>, azdataToolService: AzdataToolService, memento: vscode.Memento): azdataExt.IAzdataApi {
+	return {
+		arc: {
+			dc: {
+				create: async (
+					namespace: string,
+					name: string,
+					connectivityMode: string,
+					resourceGroup: string,
+					location: string,
+					subscription: string,
+					profileName?: string,
+					storageClass?: string,
+					additionalEnvVars?: azdataExt.AdditionalEnvVars,
+					azdataContext?: string) => {
+					await localAzdataDiscovered;
+					await validateAzdata(azdataToolService.localAzdata, isEulaAccepted(memento));
+					return azdataToolService.localAzdata!.arc.dc.create(namespace, name, connectivityMode, resourceGroup, location, subscription, profileName, storageClass, additionalEnvVars, azdataContext);
+				},
+				endpoint: {
+					list: async (additionalEnvVars?: azdataExt.AdditionalEnvVars, azdataContext?: string) => {
+						await localAzdataDiscovered;
+						await validateAzdata(azdataToolService.localAzdata, isEulaAccepted(memento));
+						return azdataToolService.localAzdata!.arc.dc.endpoint.list(additionalEnvVars, azdataContext);
+					}
+				},
+				config: {
+					list: async (additionalEnvVars?: azdataExt.AdditionalEnvVars, azdataContext?: string) => {
+						await localAzdataDiscovered;
+						await validateAzdata(azdataToolService.localAzdata, isEulaAccepted(memento));
+						return azdataToolService.localAzdata!.arc.dc.config.list(additionalEnvVars, azdataContext);
+					},
+					show: async (additionalEnvVars?: azdataExt.AdditionalEnvVars, azdataContext?: string) => {
+						await localAzdataDiscovered;
+						await validateAzdata(azdataToolService.localAzdata, isEulaAccepted(memento));
+						return azdataToolService.localAzdata!.arc.dc.config.show(additionalEnvVars, azdataContext);
+					}
+				}
+			},
+			postgres: {
+				server: {
+					delete: async (name: string, additionalEnvVars?: azdataExt.AdditionalEnvVars, azdataContext?: string) => {
+						await localAzdataDiscovered;
+						await validateAzdata(azdataToolService.localAzdata, isEulaAccepted(memento));
+						return azdataToolService.localAzdata!.arc.postgres.server.delete(name, additionalEnvVars, azdataContext);
+					},
+					list: async (additionalEnvVars?: azdataExt.AdditionalEnvVars, azdataContext?: string) => {
+						await localAzdataDiscovered;
+						await validateAzdata(azdataToolService.localAzdata, isEulaAccepted(memento));
+						return azdataToolService.localAzdata!.arc.postgres.server.list(additionalEnvVars, azdataContext);
+					},
+					show: async (name: string, additionalEnvVars?: azdataExt.AdditionalEnvVars, azdataContext?: string) => {
+						await localAzdataDiscovered;
+						await validateAzdata(azdataToolService.localAzdata, isEulaAccepted(memento));
+						return azdataToolService.localAzdata!.arc.postgres.server.show(name, additionalEnvVars, azdataContext);
+					},
+					edit: async (
+						name: string,
+						args: {
+							adminPassword?: boolean;
+							coresLimit?: string;
+							coresRequest?: string;
+							coordinatorEngineSettings?: string;
+							engineSettings?: string;
+							extensions?: string;
+							memoryLimit?: string;
+							memoryRequest?: string;
+							noWait?: boolean;
+							port?: number;
+							replaceEngineSettings?: boolean;
+							workerEngineSettings?: string;
+							workers?: number;
+						},
+						additionalEnvVars?: azdataExt.AdditionalEnvVars,
+						azdataContext?: string) => {
+						await localAzdataDiscovered;
+						await validateAzdata(azdataToolService.localAzdata, isEulaAccepted(memento));
+						return azdataToolService.localAzdata!.arc.postgres.server.edit(name, args, additionalEnvVars, azdataContext);
+					}
+				}
+			},
+			sql: {
+				mi: {
+					delete: async (name: string, additionalEnvVars?: azdataExt.AdditionalEnvVars, azdataContext?: string) => {
+						await localAzdataDiscovered;
+						await validateAzdata(azdataToolService.localAzdata, isEulaAccepted(memento));
+						return azdataToolService.localAzdata!.arc.sql.mi.delete(name, additionalEnvVars, azdataContext);
+					},
+					list: async (additionalEnvVars?: azdataExt.AdditionalEnvVars, azdataContext?: string) => {
+						await localAzdataDiscovered;
+						await validateAzdata(azdataToolService.localAzdata, isEulaAccepted(memento));
+						return azdataToolService.localAzdata!.arc.sql.mi.list(additionalEnvVars, azdataContext);
+					},
+					show: async (name: string, additionalEnvVars?: azdataExt.AdditionalEnvVars, azdataContext?: string) => {
+						await localAzdataDiscovered;
+						await validateAzdata(azdataToolService.localAzdata, isEulaAccepted(memento));
+						return azdataToolService.localAzdata!.arc.sql.mi.show(name, additionalEnvVars, azdataContext);
+					},
+					edit: async (
+						name: string,
+						args: {
+							coresLimit?: string;
+							coresRequest?: string;
+							memoryLimit?: string;
+							memoryRequest?: string;
+							noWait?: boolean;
+						},
+						additionalEnvVars?: azdataExt.AdditionalEnvVars,
+						azdataContext?: string
+					) => {
+						await localAzdataDiscovered;
+						await validateAzdata(azdataToolService.localAzdata, isEulaAccepted(memento));
+						return azdataToolService.localAzdata!.arc.sql.mi.edit(name, args, additionalEnvVars, azdataContext);
+					}
+				}
+			}
+		},
+		getPath: async () => {
+			await localAzdataDiscovered;
+			throwIfNoAzdata(azdataToolService.localAzdata);
+			return azdataToolService.localAzdata.getPath();
+		},
+		login: async (endpointOrNamespace: azdataExt.EndpointOrNamespace, username: string, password: string, additionalEnvVars?: azdataExt.AdditionalEnvVars, azdataContext?: string) => {
+			await validateAzdata(azdataToolService.localAzdata, isEulaAccepted(memento));
+			return azdataToolService.localAzdata!.login(endpointOrNamespace, username, password, additionalEnvVars, azdataContext);
+		},
+		getSemVersion: async () => {
+			await localAzdataDiscovered;
+			throwIfNoAzdata(azdataToolService.localAzdata);
+			return azdataToolService.localAzdata.getSemVersion();
+		},
+		version: async () => {
+			await localAzdataDiscovered;
+			throwIfNoAzdata(azdataToolService.localAzdata);
+			return azdataToolService.localAzdata.version();
+		}
+	};
+}
+

extensions/azcli/src/azdata.ts

@@ -0,0 +1,712 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as azdataExt from 'azdata-ext';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { SemVer } from 'semver';
+import * as vscode from 'vscode';
+import { getPlatformDownloadLink, getPlatformReleaseVersion } from './azdataReleaseInfo';
+import { executeCommand, executeSudoCommand, ExitCodeError, ProcessOutput } from './common/childProcess';
+import { HttpClient } from './common/httpClient';
+import Logger from './common/logger';
+import { getErrorMessage, NoAzdataError, searchForCmd } from './common/utils';
+import { azdataAcceptEulaKey, azdataConfigSection, azdataFound, azdataInstallKey, azdataUpdateKey, azdatarequiredUpdateKey, debugConfigKey, eulaAccepted, eulaUrl, microsoftPrivacyStatementUrl } from './constants';
+import * as loc from './localizedConstants';
+
+/**
+ * The minimum required azdata CLI version for this extension to function properly
+ */
+export const MIN_AZDATA_VERSION = new SemVer('20.3.4');
+
+export const enum AzdataDeployOption {
+	dontPrompt = 'dontPrompt',
+	prompt = 'prompt'
+}
+
+/**
+ * Interface for an object to interact with the azdata tool installed on the box.
+ */
+export interface IAzdataTool extends azdataExt.IAzdataApi {
+	/**
+	 * 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?: azdataExt.AdditionalEnvVars, azdataContext?: string): Promise<azdataExt.AzdataOutput<R>>
+}
+
+/**
+ * An object to interact with the azdata tool installed on the box.
+ */
+export class AzdataTool implements azdataExt.IAzdataApi {
+
+	private _semVersion: SemVer;
+
+	constructor(private _path: string, version: string) {
+		this._semVersion = new SemVer(version);
+	}
+
+	/**
+	 * The semVersion corresponding to this installation of azdata. version() method should have been run
+	 * before fetching this value to ensure that correct value is returned. This is almost always correct unless
+	 * Azdata has gotten reinstalled in the background after this IAzdataApi object was constructed.
+	 */
+	public async getSemVersion(): Promise<SemVer> {
+		return this._semVersion;
+	}
+
+	/**
+	 * gets the path where azdata tool is installed
+	 */
+	public async getPath(): Promise<string> {
+		return this._path;
+	}
+
+	public arc = {
+		dc: {
+			create: (
+				namespace: string,
+				name: string,
+				connectivityMode: string,
+				resourceGroup: string,
+				location: string,
+				subscription: string,
+				profileName?: string,
+				storageClass?: string,
+				additionalEnvVars?: azdataExt.AdditionalEnvVars,
+				azdataContext?: 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, additionalEnvVars, azdataContext);
+			},
+			endpoint: {
+				list: (additionalEnvVars?: azdataExt.AdditionalEnvVars, azdataContext?: string): Promise<azdataExt.AzdataOutput<azdataExt.DcEndpointListResult[]>> => {
+					return this.executeCommand<azdataExt.DcEndpointListResult[]>(['arc', 'dc', 'endpoint', 'list'], additionalEnvVars, azdataContext);
+				}
+			},
+			config: {
+				list: (additionalEnvVars?: azdataExt.AdditionalEnvVars, azdataContext?: string): Promise<azdataExt.AzdataOutput<azdataExt.DcConfigListResult[]>> => {
+					return this.executeCommand<azdataExt.DcConfigListResult[]>(['arc', 'dc', 'config', 'list'], additionalEnvVars, azdataContext);
+				},
+				show: (additionalEnvVars?: azdataExt.AdditionalEnvVars, azdataContext?: string): Promise<azdataExt.AzdataOutput<azdataExt.DcConfigShowResult>> => {
+					return this.executeCommand<azdataExt.DcConfigShowResult>(['arc', 'dc', 'config', 'show'], additionalEnvVars, azdataContext);
+				}
+			}
+		},
+		postgres: {
+			server: {
+				delete: (name: string, additionalEnvVars?: azdataExt.AdditionalEnvVars, azdataContext?: string): Promise<azdataExt.AzdataOutput<void>> => {
+					return this.executeCommand<void>(['arc', 'postgres', 'server', 'delete', '-n', name, '--force'], additionalEnvVars, azdataContext);
+				},
+				list: (additionalEnvVars?: azdataExt.AdditionalEnvVars, azdataContext?: string): Promise<azdataExt.AzdataOutput<azdataExt.PostgresServerListResult[]>> => {
+					return this.executeCommand<azdataExt.PostgresServerListResult[]>(['arc', 'postgres', 'server', 'list'], additionalEnvVars, azdataContext);
+				},
+				show: (name: string, additionalEnvVars?: azdataExt.AdditionalEnvVars, azdataContext?: string): Promise<azdataExt.AzdataOutput<azdataExt.PostgresServerShowResult>> => {
+					return this.executeCommand<azdataExt.PostgresServerShowResult>(['arc', 'postgres', 'server', 'show', '-n', name], additionalEnvVars, azdataContext);
+				},
+				edit: (
+					name: string,
+					args: {
+						adminPassword?: boolean,
+						coresLimit?: string,
+						coresRequest?: string,
+						coordinatorEngineSettings?: string,
+						engineSettings?: string,
+						extensions?: string,
+						memoryLimit?: string,
+						memoryRequest?: string,
+						noWait?: boolean,
+						port?: number,
+						replaceEngineSettings?: boolean,
+						workerEngineSettings?: string,
+						workers?: number
+					},
+					additionalEnvVars?: azdataExt.AdditionalEnvVars,
+					azdataContext?: string): Promise<azdataExt.AzdataOutput<void>> => {
+					const argsArray = ['arc', 'postgres', 'server', 'edit', '-n', name];
+					if (args.adminPassword) { argsArray.push('--admin-password'); }
+					if (args.coresLimit) { argsArray.push('--cores-limit', args.coresLimit); }
+					if (args.coresRequest) { argsArray.push('--cores-request', args.coresRequest); }
+					if (args.coordinatorEngineSettings) { argsArray.push('--coordinator-engine-settings', args.coordinatorEngineSettings); }
+					if (args.engineSettings) { argsArray.push('--engine-settings', args.engineSettings); }
+					if (args.extensions) { argsArray.push('--extensions', args.extensions); }
+					if (args.memoryLimit) { argsArray.push('--memory-limit', args.memoryLimit); }
+					if (args.memoryRequest) { argsArray.push('--memory-request', args.memoryRequest); }
+					if (args.noWait) { argsArray.push('--no-wait'); }
+					if (args.port) { argsArray.push('--port', args.port.toString()); }
+					if (args.replaceEngineSettings) { argsArray.push('--replace-engine-settings'); }
+					if (args.workerEngineSettings) { argsArray.push('--worker-engine-settings', args.workerEngineSettings); }
+					if (args.workers !== undefined) { argsArray.push('--workers', args.workers.toString()); }
+					return this.executeCommand<void>(argsArray, additionalEnvVars, azdataContext);
+				}
+			}
+		},
+		sql: {
+			mi: {
+				delete: (name: string, additionalEnvVars?: azdataExt.AdditionalEnvVars, azdataContext?: string): Promise<azdataExt.AzdataOutput<void>> => {
+					return this.executeCommand<void>(['arc', 'sql', 'mi', 'delete', '-n', name], additionalEnvVars, azdataContext);
+				},
+				list: (additionalEnvVars?: azdataExt.AdditionalEnvVars, azdataContext?: string): Promise<azdataExt.AzdataOutput<azdataExt.SqlMiListResult[]>> => {
+					return this.executeCommand<azdataExt.SqlMiListResult[]>(['arc', 'sql', 'mi', 'list'], additionalEnvVars, azdataContext);
+				},
+				show: (name: string, additionalEnvVars?: azdataExt.AdditionalEnvVars, azdataContext?: string): Promise<azdataExt.AzdataOutput<azdataExt.SqlMiShowResult>> => {
+					return this.executeCommand<azdataExt.SqlMiShowResult>(['arc', 'sql', 'mi', 'show', '-n', name], additionalEnvVars, azdataContext);
+				},
+				edit: (
+					name: string,
+					args: {
+						coresLimit?: string,
+						coresRequest?: string,
+						memoryLimit?: string,
+						memoryRequest?: string,
+						noWait?: boolean,
+					},
+					additionalEnvVars?: azdataExt.AdditionalEnvVars
+				): Promise<azdataExt.AzdataOutput<void>> => {
+					const argsArray = ['arc', 'sql', 'mi', 'edit', '-n', name];
+					if (args.coresLimit) { argsArray.push('--cores-limit', args.coresLimit); }
+					if (args.coresRequest) { argsArray.push('--cores-request', args.coresRequest); }
+					if (args.memoryLimit) { argsArray.push('--memory-limit', args.memoryLimit); }
+					if (args.memoryRequest) { argsArray.push('--memory-request', args.memoryRequest); }
+					if (args.noWait) { argsArray.push('--no-wait'); }
+					return this.executeCommand<void>(argsArray, additionalEnvVars);
+				}
+			}
+		}
+	};
+
+	public async login(endpointOrNamespace: azdataExt.EndpointOrNamespace, username: string, password: string, additionalEnvVars: azdataExt.AdditionalEnvVars = {}, azdataContext?: string): Promise<azdataExt.AzdataOutput<void>> {
+		const args = ['login', '-u', username];
+		if (endpointOrNamespace.endpoint) {
+			args.push('-e', endpointOrNamespace.endpoint);
+		} else if (endpointOrNamespace.namespace) {
+			args.push('--namespace', endpointOrNamespace.namespace);
+		} else {
+			throw new Error(loc.endpointOrNamespaceRequired);
+		}
+		return this.executeCommand<void>(args, Object.assign({}, additionalEnvVars, { 'AZDATA_PASSWORD': password }), azdataContext);
+	}
+
+	/**
+	 * Gets the output of running '--version' command on the azdata tool.
+	 * It also updates the cachedVersion property based on the return value from the tool.
+	 */
+	public async version(): Promise<azdataExt.AzdataOutput<string>> {
+		const output = await executeAzdataCommand(`"${this._path}"`, ['--version']);
+		this._semVersion = new SemVer(parseVersion(output.stdout));
+		return {
+			logs: [],
+			stdout: output.stdout.split(os.EOL),
+			stderr: output.stderr.split(os.EOL),
+			result: output.stdout
+		};
+	}
+
+	/**
+	 * Executes the specified azdata command.
+	 * @param args The args to pass to azdata
+	 * @param additionalEnvVars Additional environment variables to set for this execution
+	 */
+	public async executeCommand<R>(args: string[], additionalEnvVars?: azdataExt.AdditionalEnvVars, azdataContext?: string): Promise<azdataExt.AzdataOutput<R>> {
+		try {
+			if (azdataContext) {
+				args = args.concat('--controller-context', azdataContext);
+			}
+			const output = JSON.parse((await executeAzdataCommand(`"${this._path}"`, args.concat(['--output', 'json']), additionalEnvVars)).stdout);
+			return {
+				logs: <string[]>output.log,
+				stdout: <string[]>output.stdout,
+				stderr: <string[]>output.stderr,
+				result: <R>output.result
+			};
+		} catch (err) {
+			if (err instanceof ExitCodeError) {
+				try {
+					// For azdata internal errors the output is JSON and so we need to do some extra parsing here
+					// to get the correct stderr out. The actual value we get is something like
+					// ERROR: { stderr: '...' }
+					// so we also need to trim off the start that isn't a valid JSON blob
+					err.stderr = JSON.parse(err.stderr.substring(err.stderr.indexOf('{'), err.stderr.indexOf('}') + 1)).stderr;
+				} catch {
+					// it means this was probably some other generic error (such as command not being found)
+					// check if azdata still exists if it does then rethrow the original error if not then emit a new specific error.
+					try {
+						await fs.promises.access(this._path);
+						//this.path exists
+					} catch (e) {
+						// this.path does not exist
+						await vscode.commands.executeCommand('setContext', azdataFound, false);
+						throw new NoAzdataError();
+					}
+					throw err; // rethrow the original error
+				}
+
+			}
+			throw err;
+		}
+	}
+}
+
+export type AzdataDarwinPackageVersionInfo = {
+	versions: {
+		stable: string,
+		devel: string,
+		head: string,
+		bottle: boolean
+	}
+};
+
+/**
+ * Finds the existing installation of azdata, or throws an error if it couldn't find it
+ * or encountered an unexpected error.
+ * The promise is rejected when Azdata is not found.
+ */
+export async function findAzdata(): Promise<IAzdataTool> {
+	Logger.log(loc.searchingForAzdata);
+	try {
+		const azdata = await findSpecificAzdata();
+		await vscode.commands.executeCommand('setContext', azdataFound, true); // save a context key that azdata was found so that command for installing azdata is no longer available in commandPalette and that for updating it is.
+		Logger.log(loc.foundExistingAzdata(await azdata.getPath(), (await azdata.getSemVersion()).raw));
+		return azdata;
+	} catch (err) {
+		Logger.log(loc.couldNotFindAzdata(err));
+		Logger.log(loc.noAzdata);
+		await vscode.commands.executeCommand('setContext', azdataFound, false);// save a context key that azdata was not found so that command for installing azdata is available in commandPalette and that for updating it is no longer available.
+		throw err;
+	}
+}
+
+/**
+ * runs the commands to install azdata, downloading the installation package if needed
+ */
+export async function installAzdata(): Promise<void> {
+	Logger.show();
+	Logger.log(loc.installingAzdata);
+	await vscode.window.withProgress(
+		{
+			location: vscode.ProgressLocation.Notification,
+			title: loc.installingAzdata,
+			cancellable: false
+		},
+		async (_progress, _token): Promise<void> => {
+			switch (process.platform) {
+				case 'win32':
+					await downloadAndInstallAzdataWin32();
+					break;
+				case 'darwin':
+					await installAzdataDarwin();
+					break;
+				case 'linux':
+					await installAzdataLinux();
+					break;
+				default:
+					throw new Error(loc.platformUnsupported(process.platform));
+			}
+		}
+	);
+}
+
+/**
+ * Updates the azdata using os appropriate method
+ */
+async function updateAzdata(version: string): Promise<boolean> {
+	try {
+		Logger.show();
+		Logger.log(loc.updatingAzdata);
+		await vscode.window.withProgress(
+			{
+				location: vscode.ProgressLocation.Notification,
+				title: loc.updatingAzdata,
+				cancellable: false
+			},
+			async (_progress, _token): Promise<void> => {
+				switch (process.platform) {
+					case 'win32':
+						await downloadAndInstallAzdataWin32();
+						break;
+					case 'darwin':
+						await updateAzdataDarwin();
+						break;
+					case 'linux':
+						await installAzdataLinux();
+						break;
+					default:
+						throw new Error(loc.platformUnsupported(process.platform));
+				}
+			}
+		);
+		vscode.window.showInformationMessage(loc.azdataUpdated(version));
+		Logger.log(loc.azdataUpdated(version));
+		return true;
+	} catch (err) {
+		// Windows: 1602 is User cancelling installation/update - not unexpected so don't display
+		if (!(err instanceof ExitCodeError) || err.code !== 1602) {
+			vscode.window.showWarningMessage(loc.updateError(err));
+			Logger.log(loc.updateError(err));
+		}
+	}
+	return false;
+}
+
+/**
+ * Checks whether azdata is installed - and if it is not then invokes the process of azdata installation.
+ * @param userRequested true means that this operation by was requested by a user by executing an ads command.
+ */
+export async function checkAndInstallAzdata(userRequested: boolean = false): Promise<IAzdataTool | undefined> {
+	try {
+		return await findAzdata(); // find currently installed Azdata
+	} catch (err) {
+		// Calls will be made to handle azdata not being installed if user declines to install on the prompt
+		if (await promptToInstallAzdata(userRequested)) {
+			return await findAzdata();
+		}
+	}
+	return undefined;
+}
+
+/**
+ * Checks whether a newer version of azdata is available - and if it is then invokes the process of azdata update.
+ * @param currentAzdata The current version of azdata to check against
+ * @param userRequested true means that this operation by was requested by a user by executing an ads command.
+ * returns true if update was done and false otherwise.
+ */
+export async function checkAndUpdateAzdata(currentAzdata?: IAzdataTool, userRequested: boolean = false): Promise<boolean> {
+	if (currentAzdata !== undefined) {
+		const newSemVersion = await discoverLatestAvailableAzdataVersion();
+		const currentSemVersion = await currentAzdata.getSemVersion();
+		Logger.log(loc.foundAzdataVersionToUpdateTo(newSemVersion.raw, currentSemVersion.raw));
+		if (MIN_AZDATA_VERSION.compare(currentSemVersion) === 1) {
+			if (newSemVersion.compare(MIN_AZDATA_VERSION) >= 0) {
+				return await promptToUpdateAzdata(newSemVersion.raw, userRequested, true);
+			} else {
+				// This should never happen - it means that the currently available version to download
+				// is < the version we require. If this was to happen it'd imply something is wrong with
+				// the version JSON or the minimum required version.
+				// Regardless, there's nothing we can do and so we just bail out at this point and tell the user
+				// they have to install it manually (hopefully it's available and wasn't a publishing mistake)
+				vscode.window.showInformationMessage(loc.requiredVersionNotAvailable(MIN_AZDATA_VERSION.raw, newSemVersion.raw));
+				Logger.log(loc.requiredVersionNotAvailable(newSemVersion.raw, currentSemVersion.raw));
+			}
+		}
+		else if (newSemVersion.compare(currentSemVersion) === 1) {
+			return await promptToUpdateAzdata(newSemVersion.raw, userRequested);
+		} else {
+			Logger.log(loc.currentlyInstalledVersionIsLatest((await currentAzdata.getSemVersion()).raw));
+		}
+	} else {
+		Logger.log(loc.updateCheckSkipped);
+		Logger.log(loc.noAzdata);
+		await vscode.commands.executeCommand('setContext', azdataFound, false);
+	}
+	return false;
+}
+
+/**
+ * prompt user to install Azdata.
+ * @param userRequested - if true this operation was requested in response to a user issued command, if false it was issued at startup by system
+ * returns true if installation was done and false otherwise.
+ */
+async function promptToInstallAzdata(userRequested: boolean = false): Promise<boolean> {
+	let response: string | undefined = loc.yes;
+	const config = <AzdataDeployOption>getConfig(azdataInstallKey);
+	if (userRequested) {
+		Logger.show();
+		Logger.log(loc.userRequestedInstall);
+	}
+	if (config === AzdataDeployOption.dontPrompt && !userRequested) {
+		Logger.log(loc.skipInstall(config));
+		return false;
+	}
+	const responses = userRequested
+		? [loc.yes, loc.no]
+		: [loc.yes, loc.askLater, loc.doNotAskAgain];
+	if (config === AzdataDeployOption.prompt) {
+		Logger.log(loc.promptForAzdataInstallLog);
+		response = await vscode.window.showErrorMessage(loc.promptForAzdataInstall, ...responses);
+		Logger.log(loc.userResponseToInstallPrompt(response));
+	}
+	if (response === loc.doNotAskAgain) {
+		await setConfig(azdataInstallKey, AzdataDeployOption.dontPrompt);
+	} else if (response === loc.yes) {
+		try {
+			await installAzdata();
+			vscode.window.showInformationMessage(loc.azdataInstalled);
+			Logger.log(loc.azdataInstalled);
+			return true;
+		} catch (err) {
+			// Windows: 1602 is User cancelling installation/update - not unexpected so don't display
+			if (!(err instanceof ExitCodeError) || err.code !== 1602) {
+				vscode.window.showWarningMessage(loc.installError(err));
+				Logger.log(loc.installError(err));
+			}
+		}
+	}
+	return false;
+}
+
+/**
+ * prompt user to update Azdata.
+ * @param newVersion - provides the new version that the user will be prompted to update to
+ * @param userRequested - if true this operation was requested in response to a user issued command, if false it was issued at startup by system
+ * returns true if update was done and false otherwise.
+ * @param required - Whether this update is required. If true then we will always show the prompt and warn the user if they decline it
+ */
+async function promptToUpdateAzdata(newVersion: string, userRequested: boolean = false, required = false): Promise<boolean> {
+	if (required) {
+		let response: string | undefined = loc.yes;
+		const config = <AzdataDeployOption>getConfig(azdatarequiredUpdateKey);
+		if (userRequested) {
+			Logger.show();
+			Logger.log(loc.userRequestedUpdate);
+		}
+		if (config === AzdataDeployOption.dontPrompt && !userRequested) {
+			Logger.log(loc.skipRequiredUpdate(config));
+			return false;
+		}
+		const responses = userRequested
+			? [loc.yes, loc.no]
+			: [loc.yes, loc.askLater, loc.doNotAskAgain];
+		Logger.log(loc.promptForRequiredAzdataUpdateLog(MIN_AZDATA_VERSION.raw, newVersion));
+		response = await vscode.window.showInformationMessage(loc.promptForRequiredAzdataUpdate(MIN_AZDATA_VERSION.raw, newVersion), ...responses);
+		Logger.log(loc.userResponseToUpdatePrompt(response));
+		if (response === loc.doNotAskAgain) {
+			await setConfig(azdatarequiredUpdateKey, AzdataDeployOption.dontPrompt);
+		} else if (response === loc.yes) {
+			return updateAzdata(newVersion);
+		} else {
+			vscode.window.showWarningMessage(loc.missingRequiredVersion(MIN_AZDATA_VERSION.raw));
+		}
+	} else {
+		let response: string | undefined = loc.yes;
+		const config = <AzdataDeployOption>getConfig(azdataUpdateKey);
+		if (userRequested) {
+			Logger.show();
+			Logger.log(loc.userRequestedUpdate);
+		}
+		if (config === AzdataDeployOption.dontPrompt && !userRequested) {
+			Logger.log(loc.skipUpdate(config));
+			return false;
+		}
+		const responses = userRequested
+			? [loc.yes, loc.no]
+			: [loc.yes, loc.askLater, loc.doNotAskAgain];
+		if (config === AzdataDeployOption.prompt) {
+			Logger.log(loc.promptForAzdataUpdateLog(newVersion));
+			response = await vscode.window.showInformationMessage(loc.promptForAzdataUpdate(newVersion), ...responses);
+			Logger.log(loc.userResponseToUpdatePrompt(response));
+		}
+		if (response === loc.doNotAskAgain) {
+			await setConfig(azdataUpdateKey, AzdataDeployOption.dontPrompt);
+		} else if (response === loc.yes) {
+			return updateAzdata(newVersion);
+		}
+	}
+	return false;
+}
+
+/**
+ *	Returns true if Eula has been accepted.
+ *
+ * @param memento The memento that stores the eulaAccepted state
+ */
+export function isEulaAccepted(memento: vscode.Memento): boolean {
+	return !!memento.get<boolean>(eulaAccepted);
+}
+
+/**
+ * Prompts user to accept EULA. Stores and returns the user response to EULA prompt.
+ * @param memento - memento where the user response is stored.
+ * @param userRequested - if true this operation was requested in response to a user issued command, if false it was issued at startup by system
+ * @param requireUserAction - if the prompt is required to be acted upon by the user. This is typically 'true' when this method is called to address an Error when the EULA needs to be accepted to proceed.
+ * pre-requisite, the calling code has to ensure that the eula has not yet been previously accepted by the user.
+ * returns true if the user accepted the EULA.
+ */
+export async function promptForEula(memento: vscode.Memento, userRequested: boolean = false, requireUserAction: boolean = false): Promise<boolean> {
+	let response: string | undefined = loc.no;
+	const config = <AzdataDeployOption>getConfig(azdataAcceptEulaKey);
+	if (userRequested) {
+		Logger.show();
+		Logger.log(loc.userRequestedAcceptEula);
+	}
+	const responses = userRequested
+		? [loc.accept, loc.decline]
+		: [loc.accept, loc.askLater, loc.doNotAskAgain];
+	if (config === AzdataDeployOption.prompt || userRequested) {
+		Logger.show();
+		Logger.log(loc.promptForEulaLog(microsoftPrivacyStatementUrl, eulaUrl));
+		response = requireUserAction
+			? await vscode.window.showErrorMessage(loc.promptForEula(microsoftPrivacyStatementUrl, eulaUrl), ...responses)
+			: await vscode.window.showInformationMessage(loc.promptForEula(microsoftPrivacyStatementUrl, eulaUrl), ...responses);
+		Logger.log(loc.userResponseToEulaPrompt(response));
+	}
+	if (response === loc.doNotAskAgain) {
+		await setConfig(azdataAcceptEulaKey, AzdataDeployOption.dontPrompt);
+	} else if (response === loc.accept) {
+		await memento.update(eulaAccepted, true); // save a memento that eula was accepted
+		await vscode.commands.executeCommand('setContext', eulaAccepted, true); // save a context key that eula was accepted so that command for accepting eula is no longer available in commandPalette
+		return true;
+	}
+	return false;
+}
+
+/**
+ * Downloads the Windows installer and runs it
+ */
+async function downloadAndInstallAzdataWin32(): Promise<void> {
+	const downLoadLink = await getPlatformDownloadLink();
+	const downloadFolder = os.tmpdir();
+	const downloadLogs = path.join(downloadFolder, 'ads_azdata_install_logs.log');
+	const downloadedFile = await HttpClient.downloadFile(downLoadLink, downloadFolder);
+
+	try {
+		await executeSudoCommand(`msiexec /qn /i "${downloadedFile}" /lvx "${downloadLogs}"`);
+	} catch (err) {
+		throw new Error(`${err.message}. See logs at ${downloadLogs} for more details.`);
+	}
+}
+
+/**
+ * Runs commands to install azdata on MacOS
+ */
+async function installAzdataDarwin(): Promise<void> {
+	await executeCommand('brew', ['tap', 'microsoft/azdata-cli-release']);
+	await executeCommand('brew', ['update']);
+	await executeCommand('brew', ['install', 'azdata-cli']);
+}
+
+/**
+ * Runs commands to update azdata on MacOS
+ */
+async function updateAzdataDarwin(): Promise<void> {
+	await executeCommand('brew', ['tap', 'microsoft/azdata-cli-release']);
+	await executeCommand('brew', ['update']);
+	await executeCommand('brew', ['upgrade', 'azdata-cli']);
+}
+
+/**
+ * Runs commands to install azdata on Linux
+ */
+async function installAzdataLinux(): Promise<void> {
+	// https://docs.microsoft.com/en-us/sql/big-data-cluster/deploy-install-azdata-linux-package
+	// Get packages needed for install process
+	await executeSudoCommand('apt-get update');
+	await executeSudoCommand('apt-get install gnupg ca-certificates curl wget software-properties-common apt-transport-https lsb-release -y');
+	// Download and install the signing key
+	await executeSudoCommand('curl -sL https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor | sudo tee /etc/apt/trusted.gpg.d/microsoft.asc.gpg > /dev/null');
+	// Add the azdata repository information
+	const release = (await executeCommand('lsb_release', ['-rs'])).stdout.trim();
+	await executeSudoCommand(`add-apt-repository "$(wget -qO- https://packages.microsoft.com/config/ubuntu/${release}/mssql-server-2019.list)"`);
+	// Update repository information and install azdata
+	await executeSudoCommand('apt-get update');
+	await executeSudoCommand('apt-get install -y azdata-cli');
+}
+
+/**
+ */
+async function findSpecificAzdata(): Promise<IAzdataTool> {
+	const path = await ((process.platform === 'win32') ? searchForCmd('azdata.cmd') : searchForCmd('azdata'));
+	const versionOutput = await executeAzdataCommand(`"${path}"`, ['--version']);
+	return new AzdataTool(path, parseVersion(versionOutput.stdout));
+}
+
+function getConfig(key: string): AzdataDeployOption | undefined {
+	const config = vscode.workspace.getConfiguration(azdataConfigSection);
+	const value = <AzdataDeployOption>config.get<AzdataDeployOption>(key);
+	Logger.log(loc.azdataUserSettingRead(key, value));
+	return value;
+}
+
+async function setConfig(key: string, value: string): Promise<void> {
+	const config = vscode.workspace.getConfiguration(azdataConfigSection);
+	await config.update(key, value, vscode.ConfigurationTarget.Global);
+	Logger.log(loc.azdataUserSettingUpdated(key, value));
+}
+
+/**
+ * Gets the latest azdata version available for a given platform
+ */
+export async function discoverLatestAvailableAzdataVersion(): Promise<SemVer> {
+	Logger.log(loc.checkingLatestAzdataVersion);
+	switch (process.platform) {
+		case 'darwin':
+			return await discoverLatestStableAzdataVersionDarwin();
+		// case 'linux':
+		// ideally we would not to discover linux package availability using the apt/apt-get/apt-cache package manager commands.
+		// However, doing discovery that way required apt update to be performed which requires sudo privileges. At least currently this code path
+		// gets invoked on extension start up and prompt user for sudo privileges is annoying at best. So for now basing linux discovery also on a releaseJson file.
+		default:
+			return await getPlatformReleaseVersion();
+	}
+}
+
+/**
+ * Parses out the azdata version from the raw azdata version output
+ * @param raw The raw version output from azdata --version
+ */
+function parseVersion(raw: string): string {
+	// Currently the version is a multi-line string that contains other version information such
+	// as the Python installation, with the first line being the version of azdata itself.
+	const lines = raw.split(os.EOL);
+	return lines[0].trim();
+}
+
+/**
+ * Gets the latest azdata version for MacOs clients
+ */
+async function discoverLatestStableAzdataVersionDarwin(): Promise<SemVer> {
+	// set brew tap to azdata-cli repository
+	await executeCommand('brew', ['tap', 'microsoft/azdata-cli-release']);
+	await executeCommand('brew', ['update']);
+	let brewInfoAzdataCliJson;
+	// Get the package version 'info' about 'azdata-cli' from 'brew' as a json object
+	const brewInfoOutput = (await executeCommand('brew', ['info', 'azdata-cli', '--json'])).stdout;
+	try {
+		brewInfoAzdataCliJson = JSON.parse(brewInfoOutput);
+	} catch (e) {
+		throw Error(`failed to parse the JSON contents output of: 'brew info azdata-cli --json', text being parsed: '${brewInfoOutput}', error:${getErrorMessage(e)}`);
+	}
+	// Get the 'info' about 'azdata-cli' from 'brew' as a json object
+	const azdataPackageVersionInfo: AzdataDarwinPackageVersionInfo = brewInfoAzdataCliJson.shift();
+	Logger.log(loc.latestAzdataVersionAvailable(azdataPackageVersionInfo.versions.stable));
+	return new SemVer(azdataPackageVersionInfo.versions.stable);
+}
+
+async function executeAzdataCommand(command: string, args: string[], additionalEnvVars: azdataExt.AdditionalEnvVars = {}): Promise<ProcessOutput> {
+	additionalEnvVars = Object.assign(additionalEnvVars, { 'ACCEPT_EULA': 'yes' });
+	const debug = vscode.workspace.getConfiguration(azdataConfigSection).get(debugConfigKey);
+	if (debug) {
+		args.push('--debug');
+	}
+	return executeCommand(command, args, additionalEnvVars);
+}
+
+/**
+ * Gets the latest azdata version for linux clients
+ * This method requires sudo permission so not suitable to be run during startup.
+ */
+// async function discoverLatestStableAzdataVersionLinux(): Promise<SemVer> {
+// 	// Update repository information and install azdata
+// 	await executeSudoCommand('apt-get update');
+// 	const output = (await executeCommand('apt', ['list', 'azdata-cli', '--upgradeable'])).stdout;
+// 	// the packageName (with version) string is the second space delimited token on the 2nd line
+// 	const packageName = output.split('\n')[1].split(' ')[1];
+// 	// the version string is the first part of the package sting before '~'
+// 	const version = packageName.split('~')[0];
+// 	Logger.log(loc.latestAzdataVersionAvailable(version));
+// 	return new SemVer(version);
+// }

extensions/azcli/src/azdataReleaseInfo.ts

@@ -0,0 +1,76 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as os from 'os';
+import * as loc from './localizedConstants';
+import { SemVer } from 'semver';
+import { HttpClient } from './common/httpClient';
+import Logger from './common/logger';
+import { getErrorMessage } from './common/utils';
+import { azdataHostname, azdataReleaseJson } from './constants';
+
+interface PlatformReleaseInfo {
+	version: string; // "20.0.1"
+	link?: string; // "https://aka.ms/azdata-msi"
+}
+
+export interface AzdataReleaseInfo {
+	win32: PlatformReleaseInfo,
+	darwin: PlatformReleaseInfo,
+	linux: PlatformReleaseInfo
+}
+
+function getPlatformAzdataReleaseInfo(releaseInfo: AzdataReleaseInfo): PlatformReleaseInfo {
+	switch (os.platform()) {
+		case 'win32':
+			return releaseInfo.win32;
+		case 'linux':
+			return releaseInfo.linux;
+		case 'darwin':
+			return releaseInfo.darwin;
+		default:
+			Logger.log(loc.platformUnsupported(os.platform()));
+			throw new Error(`Unsupported AzdataReleaseInfo platform '${os.platform()}`);
+	}
+}
+
+/**
+ * Gets the release version for the current platform from the release info - throwing an error if it doesn't exist.
+ * @param releaseInfo The AzdataReleaseInfo object
+ */
+export async function getPlatformReleaseVersion(): Promise<SemVer> {
+	const releaseInfo = await getAzdataReleaseInfo();
+	const platformReleaseInfo = getPlatformAzdataReleaseInfo(releaseInfo);
+	if (!platformReleaseInfo.version) {
+		Logger.log(loc.noReleaseVersion(os.platform(), JSON.stringify(releaseInfo)));
+		throw new Error(`No release version available for platform ${os.platform()}`);
+	}
+	Logger.log(loc.latestAzdataVersionAvailable(platformReleaseInfo.version));
+	return new SemVer(platformReleaseInfo.version);
+}
+
+/**
+ * Gets the download link for the current platform from the release info - throwing an error if it doesn't exist.
+ * @param releaseInfo The AzdataReleaseInfo object
+ */
+export async function getPlatformDownloadLink(): Promise<string> {
+	const releaseInfo = await getAzdataReleaseInfo();
+	const platformReleaseInfo = getPlatformAzdataReleaseInfo(releaseInfo);
+	if (!platformReleaseInfo.link) {
+		Logger.log(loc.noDownloadLink(os.platform(), JSON.stringify(releaseInfo)));
+		throw new Error(`No download link available for platform ${os.platform()}`);
+	}
+	return platformReleaseInfo.link;
+}
+
+async function getAzdataReleaseInfo(): Promise<AzdataReleaseInfo> {
+	const fileContents = await HttpClient.getTextContent(`${azdataHostname}/${azdataReleaseJson}`);
+	try {
+		return JSON.parse(fileContents);
+	} catch (e) {
+		Logger.log(loc.failedToParseReleaseInfo(`${azdataHostname}/${azdataReleaseJson}`, fileContents, e));
+		throw Error(`Failed to parse the JSON of contents at: ${azdataHostname}/${azdataReleaseJson}. Error: ${getErrorMessage(e)}`);
+	}
+}

extensions/azcli/src/common/childProcess.ts

@@ -0,0 +1,107 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { AdditionalEnvVars } from 'azdata-ext';
+import * as cp from 'child_process';
+import * as sudo from 'sudo-prompt';
+import * as loc from '../localizedConstants';
+import Logger from './logger';
+
+/**
+ * Wrapper error for when an unexpected exit code was received
+ */
+export class ExitCodeError extends Error {
+	constructor(private _code: number, private _stderr: string) {
+		super();
+		this.setMessage();
+	}
+
+	public get code(): number {
+		return this._code;
+	}
+
+	public set code(value: number) {
+		this._code = value;
+	}
+
+	public get stderr(): string {
+		return this._stderr;
+	}
+
+	public set stderr(value: string) {
+		this._stderr = value;
+		this.setMessage();
+	}
+
+	private setMessage(): void {
+		this.message = loc.unexpectedExitCode(this._code, this._stderr);
+	}
+}
+
+export type ProcessOutput = { stdout: string, stderr: string };
+
+/**
+ * Executes the specified command. Throws an error for a non-0 exit code or if stderr receives output
+ * @param command The command to execute
+ * @param args Optional args to pass, every arg and arg value must be a separate item in the array
+ * @param additionalEnvVars Additional environment variables to add to the process environment
+ */
+export async function executeCommand(command: string, args: string[], additionalEnvVars?: AdditionalEnvVars): Promise<ProcessOutput> {
+	return new Promise((resolve, reject) => {
+		Logger.log(loc.executingCommand(command, args));
+		const stdoutBuffers: Buffer[] = [];
+		const stderrBuffers: Buffer[] = [];
+		const env = Object.assign({}, process.env, additionalEnvVars);
+		const child = cp.spawn(command, args, { shell: true, env: env });
+		child.stdout.on('data', (b: Buffer) => stdoutBuffers.push(b));
+		child.stderr.on('data', (b: Buffer) => stderrBuffers.push(b));
+		child.on('error', reject);
+		child.on('exit', code => {
+			const stdout = Buffer.concat(stdoutBuffers).toString('utf8').trim();
+			const stderr = Buffer.concat(stderrBuffers).toString('utf8').trim();
+			if (stdout) {
+				Logger.log(loc.stdoutOutput(stdout));
+			}
+			if (stderr) {
+				Logger.log(loc.stderrOutput(stderr));
+			}
+			if (code) {
+				const err = new ExitCodeError(code, stderr);
+				Logger.log(err.message);
+				reject(err);
+			} else {
+				resolve({ stdout: stdout, stderr: stderr });
+			}
+		});
+	});
+}
+
+/**
+ * Executes a command with admin privileges. The user will be prompted to enter credentials for invocation of
+ * this function. The exact prompt is platform-dependent.
+ * @param command The command to execute
+ * @param args The additional args
+ */
+export async function executeSudoCommand(command: string): Promise<ProcessOutput> {
+	return new Promise((resolve, reject) => {
+		Logger.log(loc.executingCommand(`sudo ${command}`, []));
+		sudo.exec(command, { name: 'Azure Data Studio' }, (error, stdout, stderr) => {
+			stdout = stdout?.toString() ?? '';
+			stderr = stderr?.toString() ?? '';
+			if (stdout) {
+				Logger.log(loc.stdoutOutput(stdout));
+			}
+			if (stderr) {
+				Logger.log(loc.stderrOutput(stderr));
+			}
+			if (error) {
+				Logger.log(loc.unexpectedCommandError(error.message));
+				reject(error);
+			} else {
+				resolve({ stdout: stdout, stderr: stderr });
+			}
+		});
+	});
+}

extensions/azcli/src/common/httpClient.ts

@@ -0,0 +1,103 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as fs from 'fs';
+import * as request from 'request';
+import * as path from 'path';
+import * as loc from '../localizedConstants';
+import Logger from './logger';
+
+const DownloadTimeout = 20000;
+
+export namespace HttpClient {
+
+	/**
+	 * Downloads a file from the given URL, resolving to the full path of the downloaded file when complete
+	 * @param downloadUrl The URL to download the file from
+	 * @param targetFolder The folder to download the file to
+	 * @returns a promise to a full path to the downloaded file
+	 */
+	export function downloadFile(downloadUrl: string, targetFolder: string): Promise<string> {
+		return download(downloadUrl, targetFolder);
+	}
+
+	/**
+	 * Downloads the text contents of the document at the given URL, resolving to a string containing the text when complete
+	 * @param url The URL of the document whose contents need to be fetched
+	 * @returns a promise to a string that has the contents of document at the provided url
+	 */
+	export async function getTextContent(url: string): Promise<string> {
+		Logger.log(loc.gettingTextContentsOfUrl(url));
+		return await download(url);
+	}
+
+	/**
+	 * Gets a file/fileContents at the given URL.
+	 * @param downloadUrl The URL to download the file from
+	 * @param targetFolder The folder to download the file to. If not defined then return value is the contents of the downloaded file.
+	 * @returns Full path to the downloaded file or the contents of the file at the given downloadUrl
+	 */
+	function download(downloadUrl: string, targetFolder?: string): Promise<string> {
+		return new Promise((resolve, reject) => {
+			let totalMegaBytes: number | undefined = undefined;
+			let receivedBytes = 0;
+			let printThreshold = 0.1;
+			let strings: string[] = [];
+			let downloadRequest = request.get(downloadUrl, { timeout: DownloadTimeout })
+				.on('error', downloadError => {
+					Logger.log(loc.downloadError);
+					Logger.log(downloadError?.message ?? downloadError);
+					reject(downloadError);
+				})
+				.on('response', (response) => {
+					if (response.statusCode !== 200) {
+						Logger.log(loc.downloadError);
+						Logger.log(response.statusMessage);
+						Logger.log(`response code: ${response.statusCode}`);
+						return reject(response.statusMessage);
+					}
+					if (targetFolder !== undefined) {
+						const filename = path.basename(response.request.path);
+						const targetPath = path.join(targetFolder, filename);
+						Logger.log(loc.downloadingTo(filename, downloadUrl, targetPath));
+						// Wait to create the WriteStream until here so we can use the actual
+						// filename based off of the URI.
+						downloadRequest.pipe(fs.createWriteStream(targetPath))
+							.on('close', async () => {
+								Logger.log(loc.downloadFinished);
+								resolve(targetPath);
+							})
+							.on('error', (downloadError) => {
+								reject(downloadError);
+								downloadRequest.abort();
+							});
+					} else {
+						response.on('end', () => {
+							Logger.log(loc.downloadFinished);
+							resolve(strings.join(''));
+						});
+					}
+					let contentLength = response.headers['content-length'];
+					let totalBytes = parseInt(contentLength || '0');
+					totalMegaBytes = totalBytes / (1024 * 1024);
+					Logger.log(loc.downloadingProgressMb('0', totalMegaBytes.toFixed(2)));
+				})
+				.on('data', (data) => {
+					if (targetFolder === undefined) {
+						strings.push(data.toString('utf-8'));
+					}
+					receivedBytes += data.length;
+					if (totalMegaBytes) {
+						let receivedMegaBytes = receivedBytes / (1024 * 1024);
+						let percentage = receivedMegaBytes / totalMegaBytes;
+						if (percentage >= printThreshold) {
+							Logger.log(loc.downloadingProgressMb(receivedMegaBytes.toFixed(2), totalMegaBytes.toFixed(2)));
+							printThreshold += 0.1;
+						}
+					}
+				});
+		});
+	}
+}

extensions/azcli/src/common/logger.ts

@@ -0,0 +1,25 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as vscode from 'vscode';
+import * as loc from '../localizedConstants';
+
+export class Log {
+	private _output: vscode.OutputChannel;
+
+	constructor() {
+		this._output = vscode.window.createOutputChannel(loc.azdata);
+	}
+
+	log(msg: string): void {
+		this._output.appendLine(`[${new Date().toISOString()}] ${msg}`);
+	}
+
+	show(): void {
+		this._output.show(true);
+	}
+}
+const Logger = new Log();
+export default Logger;

extensions/azcli/src/common/promise.ts

@@ -0,0 +1,25 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+/**
+ * Deferred promise
+ */
+export class Deferred<T = void> {
+	promise: Promise<T>;
+	resolve!: (value: T | PromiseLike<T>) => void;
+	reject!: (reason?: any) => void;
+	constructor() {
+		this.promise = new Promise<T>((resolve, reject) => {
+			this.resolve = resolve;
+			this.reject = reject;
+		});
+	}
+
+	then<TResult>(onfulfilled?: (value: T) => TResult | Thenable<TResult>, onrejected?: (reason: any) => TResult | Thenable<TResult>): Thenable<TResult>;
+	then<TResult>(onfulfilled?: (value: T) => TResult | Thenable<TResult>, onrejected?: (reason: any) => void): Thenable<TResult>;
+	then<TResult>(onfulfilled?: (value: T) => TResult | Thenable<TResult>, onrejected?: (reason: any) => TResult | Thenable<TResult>): Thenable<TResult> {
+		return this.promise.then(onfulfilled, onrejected);
+	}
+}

extensions/azcli/src/common/utils.ts

@@ -0,0 +1,34 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as azdataExt from 'azdata-ext';
+import * as which from 'which';
+import * as loc from '../localizedConstants';
+
+export class NoAzdataError extends Error implements azdataExt.ErrorWithLink {
+	constructor() {
+		super(loc.noAzdata);
+	}
+
+	public get messageWithLink(): string {
+		return loc.noAzdataWithLink;
+	}
+}
+/**
+ * Searches for the first instance of the specified executable in the PATH environment variable
+ * @param exe The executable to search for
+ */
+export function searchForCmd(exe: string): Promise<string> {
+	// Note : This is separated out to allow for easy test stubbing
+	return new Promise<string>((resolve, reject) => which(exe, (err, path) => err ? reject(err) : resolve(<any>path)));
+}
+
+/**
+ * Gets the message to display for a given error object that may be a variety of types.
+ * @param error The error object
+ */
+export function getErrorMessage(error: any): string {
+	return error.message ?? error;
+}

extensions/azcli/src/constants.ts

@@ -0,0 +1,24 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+// config setting keys
+export const azdataConfigSection: string = 'azdata';
+export const azdataAcceptEulaKey: string = 'acceptEula';
+export const azdataInstallKey: string = 'install';
+export const azdataUpdateKey: string = 'update';
+export const azdatarequiredUpdateKey: string = 'requiredUpdate';
+export const debugConfigKey = 'logDebugInfo';
+
+
+// context keys && memento keys
+export const eulaAccepted = 'azdata.eulaAccepted';
+export const azdataFound = 'azdata.found';
+
+// other constants
+export const azdataHostname = 'https://aka.ms';
+export const azdataUri = 'azdata-msi';
+export const azdataReleaseJson = 'azdata/release.json';
+export const microsoftPrivacyStatementUrl = 'https://privacy.microsoft.com/privacystatement';
+export const eulaUrl = 'https://aka.ms/eula-azdata-en';

extensions/azcli/src/extension.ts

@@ -0,0 +1,73 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as azdataExt from 'azdata-ext';
+import * as rd from 'resource-deployment';
+import * as vscode from 'vscode';
+import { getExtensionApi } from './api';
+import { checkAndInstallAzdata, checkAndUpdateAzdata, findAzdata, isEulaAccepted, promptForEula } from './azdata';
+import Logger from './common/logger';
+import * as constants from './constants';
+import * as loc from './localizedConstants';
+import { ArcControllerConfigProfilesOptionsSource } from './providers/arcControllerConfigProfilesOptionsSource';
+import { AzdataToolService } from './services/azdataToolService';
+
+export async function activate(context: vscode.ExtensionContext): Promise<azdataExt.IExtension> {
+	const azdataToolService = new AzdataToolService();
+	let eulaAccepted: boolean = false;
+	vscode.commands.registerCommand('azdata.acceptEula', async () => {
+		await promptForEula(context.globalState, true /* userRequested */);
+	});
+
+	vscode.commands.registerCommand('azdata.install', async () => {
+		azdataToolService.localAzdata = await checkAndInstallAzdata(true /* userRequested */);
+	});
+
+	vscode.commands.registerCommand('azdata.update', async () => {
+		if (await checkAndUpdateAzdata(azdataToolService.localAzdata, true /* userRequested */)) { // if an update was performed
+			azdataToolService.localAzdata = await findAzdata(); // find and save the currently installed azdata
+		}
+	});
+
+	eulaAccepted = isEulaAccepted(context.globalState); // fetch eula acceptance state from memento
+	await vscode.commands.executeCommand('setContext', constants.eulaAccepted, eulaAccepted); // set a context key for current value of eulaAccepted state retrieved from memento so that command for accepting eula is available/unavailable in commandPalette appropriately.
+	Logger.log(loc.eulaAcceptedStateOnStartup(eulaAccepted));
+
+	// Don't block on this since we want the extension to finish activating without needing user input
+	const localAzdataDiscovered = checkAndInstallAzdata() // install if not installed and user wants it.
+		.then(async azdataTool => {
+			if (azdataTool !== undefined) {
+				azdataToolService.localAzdata = azdataTool;
+				if (!eulaAccepted) {
+					// Don't block on this since we want extension to finish activating without requiring user actions.
+					// If EULA has not been accepted then we will check again while executing azdata commands.
+					promptForEula(context.globalState)
+						.then(async (userResponse: boolean) => {
+							eulaAccepted = userResponse;
+						})
+						.catch((err) => console.log(err));
+				}
+				try {
+					//update if available and user wants it.
+					if (await checkAndUpdateAzdata(azdataToolService.localAzdata)) { // if an update was performed
+						azdataToolService.localAzdata = await findAzdata(); // find and save the currently installed azdata
+					}
+				} catch (err) {
+					vscode.window.showWarningMessage(loc.updateError(err));
+				}
+			}
+			return azdataTool;
+		});
+
+	const azdataApi = getExtensionApi(context.globalState, azdataToolService, localAzdataDiscovered);
+
+	// register option source(s)
+	const rdApi = <rd.IExtension>vscode.extensions.getExtension(rd.extension.name)?.exports;
+	context.subscriptions.push(rdApi.registerOptionsSourceProvider(new ArcControllerConfigProfilesOptionsSource(azdataApi)));
+
+	return azdataApi;
+}
+
+export function deactivate(): void { }

extensions/azcli/src/localizedConstants.ts

@@ -0,0 +1,73 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as nls from 'vscode-nls';
+import { getErrorMessage } from './common/utils';
+import { azdataConfigSection, azdataInstallKey, azdataUpdateKey, azdatarequiredUpdateKey } from './constants';
+const localize = nls.loadMessageBundle();
+
+export const azdata = localize('azdata.azdata', "Azure Data CLI");
+export const searchingForAzdata = localize('azdata.searchingForAzdata', "Searching for existing Azure Data CLI installation...");
+export const foundExistingAzdata = (path: string, version: string): string => localize('azdata.foundExistingAzdata', "Found existing Azure Data CLI installation of version (v{0}) at path:{1}", version, path);
+
+export const downloadingProgressMb = (currentMb: string, totalMb: string): string => localize('azdata.downloadingProgressMb', "Downloading ({0} / {1} MB)", currentMb, totalMb);
+export const downloadFinished = localize('azdata.downloadFinished', "Download finished");
+export const installingAzdata = localize('azdata.installingAzdata', "Installing Azure Data CLI...");
+export const updatingAzdata = localize('azdata.updatingAzdata', "Updating Azure Data CLI...");
+export const azdataInstalled = localize('azdata.azdataInstalled', "Azure Data CLI was successfully installed. Restarting Azure Data Studio is required to complete configuration - features will not be activated until this is done.");
+export const azdataUpdated = (version: string) => localize('azdata.azdataUpdated', "Azure Data CLI was successfully updated to version: {0}.", version);
+export const yes = localize('azdata.yes', "Yes");
+export const no = localize('azdata.no', "No");
+export const accept = localize('azdata.accept', "Accept");
+export const decline = localize('azdata.decline', "Decline");
+export const doNotAskAgain = localize('azdata.doNotAskAgain', "Don't Ask Again");
+export const askLater = localize('azdata.askLater', "Ask Later");
+export const downloadingTo = (name: string, url: string, location: string): string => localize('azdata.downloadingTo', "Downloading {0} from {1} to {2}", name, url, location);
+export const executingCommand = (command: string, args: string[]): string => localize('azdata.executingCommand', "Executing command: '{0} {1}'", command, args?.join(' '));
+export const stdoutOutput = (stdout: string): string => localize('azdata.stdoutOutput', "stdout: {0}", stdout);
+export const stderrOutput = (stderr: string): string => localize('azdata.stderrOutput', "stderr: {0}", stderr);
+export const checkingLatestAzdataVersion = localize('azdata.checkingLatestAzdataVersion', "Checking for latest available version of Azure Data CLI");
+export const gettingTextContentsOfUrl = (url: string): string => localize('azdata.gettingTextContentsOfUrl', "Getting text contents of resource at URL {0}", url);
+export const foundAzdataVersionToUpdateTo = (newVersion: string, currentVersion: string): string => localize('azdata.versionForUpdate', "Found version: {0} that Azure Data CLI can be updated to from current version: {1}.", newVersion, currentVersion);
+export const latestAzdataVersionAvailable = (version: string): string => localize('azdata.latestAzdataVersionAvailable', "Latest available Azure Data CLI version: {0}.", version);
+export const couldNotFindAzdata = (err: any): string => localize('azdata.couldNotFindAzdata', "Could not find Azure Data CLI. Error: {0}", err.message ?? err);
+export const currentlyInstalledVersionIsLatest = (currentVersion: string): string => localize('azdata.currentlyInstalledVersionIsLatest', "Currently installed version of Azure Data CLI: {0} is same or newer than any other version available", currentVersion);
+export const promptLog = (logEntry: string) => localize('azdata.promptLog', "Prompting the user to accept the following: {0}", logEntry);
+export const promptForAzdataInstall = localize('azdata.couldNotFindAzdataWithPrompt', "Could not find Azure Data CLI, install it now? If not then some features will not be able to function.");
+export const promptForAzdataInstallLog = promptLog(promptForAzdataInstall);
+export const promptForAzdataUpdate = (version: string): string => localize('azdata.promptForAzdataUpdate', "A new version of Azure Data CLI ( {0} ) is available, do you wish to update to it now?", version);
+export const promptForRequiredAzdataUpdate = (requiredVersion: string, latestVersion: string): string => localize('azdata.promptForRequiredAzdataUpdate', "This extension requires Azure Data CLI >= {0} to be installed, do you wish to update to the latest version ({1}) now? If you do not then some functionality may not work.", requiredVersion, latestVersion);
+export const requiredVersionNotAvailable = (requiredVersion: string, currentVersion: string): string => localize('azdata.requiredVersionNotAvailable', "This extension requires Azure Data CLI >= {0} to be installed, but the current version available is only {1}. Install the correct version manually from [here](https://docs.microsoft.com/sql/azdata/install/deploy-install-azdata) and then restart Azure Data Studio.", requiredVersion, currentVersion);
+export const promptForAzdataUpdateLog = (version: string): string => promptLog(promptForAzdataUpdate(version));
+export const promptForRequiredAzdataUpdateLog = (requiredVersion: string, latestVersion: string): string => promptLog(promptForRequiredAzdataUpdate(requiredVersion, latestVersion));
+export const missingRequiredVersion = (requiredVersion: string): string => localize('azdata.missingRequiredVersion', "Azure Data CLI >= {0} is required for this feature. Run the 'Azure Data CLI: Check for Update' command to install this and then try again.", requiredVersion);
+export const downloadError = localize('azdata.downloadError', "Error while downloading");
+export const installError = (err: any): string => localize('azdata.installError', "Error installing Azure Data CLI: {0}", err.message ?? err);
+export const updateError = (err: any): string => localize('azdata.updateError', "Error updating Azure Data CLI: {0}", err.message ?? err);
+export const platformUnsupported = (platform: string): string => localize('azdata.platformUnsupported', "Platform '{0}' is currently unsupported", platform);
+export const unexpectedCommandError = (errMsg: string): string => localize('azdata.unexpectedCommandError', "Unexpected error executing command: {0}", errMsg);
+export const unexpectedExitCode = (code: number, err: string): string => localize('azdata.unexpectedExitCode', "Unexpected exit code from command: {1} ({0})", code, err);
+export const noAzdata = localize('azdata.noAzdata', "No Azure Data CLI is available, run the command 'Azure Data CLI: Install' to enable the features that require it.");
+export const noAzdataWithLink = localize('azdata.noAzdataWithLink', "No Azure Data CLI is available, [install the Azure Data CLI](command:azdata.install) to enable the features that require it.");
+export const skipInstall = (config: string): string => localize('azdata.skipInstall', "Skipping installation of Azure Data CLI, since the operation was not user requested and config option: {0}.{1} is {2}", azdataConfigSection, azdataInstallKey, config);
+export const skipUpdate = (config: string): string => localize('azdata.skipUpdate', "Skipping update of Azure Data CLI, since the operation was not user requested and config option: {0}.{1} is {2}", azdataConfigSection, azdataUpdateKey, config);
+export const skipRequiredUpdate = (config: string): string => localize('azdata.skipRequiredUpdate', "Skipping required update of Azure Data CLI, since the operation was not user requested and config option: {0}.{1} is {2}", azdataConfigSection, azdatarequiredUpdateKey, config);
+export const noReleaseVersion = (platform: string, releaseInfo: string): string => localize('azdata.noReleaseVersion', "No release version available for platform '{0}'\nRelease info: ${1}", platform, releaseInfo);
+export const noDownloadLink = (platform: string, releaseInfo: string): string => localize('azdata.noDownloadLink', "No download link available for platform '{0}'\nRelease info: ${1}", platform, releaseInfo);
+export const failedToParseReleaseInfo = (url: string, fileContents: string, err: any): string => localize('azdata.failedToParseReleaseInfo', "Failed to parse the JSON of contents at: {0}.\nFile contents:\n{1}\nError: {2}", url, fileContents, getErrorMessage(err));
+export const azdataUserSettingRead = (configName: string, configValue: string): string => localize('azdata.azdataUserSettingReadLog', "Azure Data CLI user setting: {0}.{1} read, value: {2}", azdataConfigSection, configName, configValue);
+export const azdataUserSettingUpdated = (configName: string, configValue: string): string => localize('azdata.azdataUserSettingUpdatedLog', "Azure Data CLI user setting: {0}.{1} updated, newValue: {2}", azdataConfigSection, configName, configValue);
+export const userResponseToInstallPrompt = (response: string | undefined): string => localize('azdata.userResponseInstall', "User Response on prompt to install Azure Data CLI: {0}", response);
+export const userResponseToUpdatePrompt = (response: string | undefined): string => localize('azdata.userResponseUpdate', "User Response on prompt to update Azure Data CLI: {0}", response);
+export const userRequestedInstall = localize('azdata.userRequestedInstall', "User requested to install Azure Data CLI using 'Azure Data CLI: Install' command");
+export const userRequestedUpdate = localize('azdata.userRequestedUpdate', "User requested to update Azure Data CLI using 'Azure Data CLI: Check for Update' command");
+export const userRequestedAcceptEula = localize('azdata.acceptEula', "User requested to be prompted for accepting EULA by invoking 'Azure Data CLI: Accept EULA' command");
+export const updateCheckSkipped = localize('azdata.updateCheckSkipped', "No check for new Azure Data CLI version availability performed as Azure Data CLI was not found to be installed");
+export const eulaNotAccepted = localize('azdata.eulaNotAccepted', "Microsoft Privacy statement and Azure Data CLI license terms have not been accepted. Execute the command: [Azure Data CLI: Accept EULA](command:azdata.acceptEula) to accept EULA to enable the features that requires Azure Data CLI.");
+export const promptForEula = (privacyStatementUrl: string, eulaUrl: string) => localize('azdata.promptForEula', "It is required to accept the [Microsoft Privacy Statement]({0}) and the [Azure Data CLI license terms]({1}) to use this extension. Declining this will result in some features not working.", privacyStatementUrl, eulaUrl);
+export const promptForEulaLog = (privacyStatementUrl: string, eulaUrl: string) => promptLog(promptForEula(privacyStatementUrl, eulaUrl));
+export const userResponseToEulaPrompt = (response: string | undefined) => localize('azdata.promptForEulaResponse', "User response to EULA prompt: {0}", response);
+export const eulaAcceptedStateOnStartup = (eulaAccepted: boolean) => localize('azdata.eulaAcceptedStateOnStartup', "'EULA Accepted' state on startup: {0}", eulaAccepted);
+export const endpointOrNamespaceRequired = localize('azdata.endpointOrNamespaceRequired', "Either an endpoint or a namespace must be specified");

extensions/azcli/src/providers/arcControllerConfigProfilesOptionsSource.ts

@@ -0,0 +1,22 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as rd from 'resource-deployment';
+import * as azdataExt from 'azdata-ext';
+
+/**
+ * Class that provides options sources for an Arc Data Controller
+ */
+export class ArcControllerConfigProfilesOptionsSource implements rd.IOptionsSourceProvider {
+	readonly id = 'arc.controller.config.profiles';
+	constructor(private _azdataExtApi: azdataExt.IExtension) { }
+	async getOptions(): Promise<string[]> {
+		const isEulaAccepted = await this._azdataExtApi.isEulaAccepted();
+		if (!isEulaAccepted) { // if eula has not yet be accepted then give user a chance to accept it
+			await this._azdataExtApi.promptForEula();
+		}
+		return (await this._azdataExtApi.azdata.arc.dc.config.list()).result;
+	}
+}

extensions/azcli/src/services/azdataToolService.ts

@@ -0,0 +1,27 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { IAzdataTool } from '../azdata';
+
+export class AzdataToolService {
+	private _localAzdata: IAzdataTool | undefined;
+	constructor() {
+	}
+
+	/**
+	* Gets the localAzdata that was last saved
+	*/
+	get localAzdata(): IAzdataTool | undefined {
+		return this._localAzdata;
+	}
+
+	/**
+	* Sets the localAzdata object to be used for azdata operations
+	*/
+	set localAzdata(azdata: IAzdataTool | undefined) {
+		this._localAzdata = azdata;
+	}
+}
+

extensions/azcli/src/test/api.test.ts

@@ -0,0 +1,121 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as azdataExt from 'azdata-ext';
+import * as childProcess from '../common/childProcess';
+import * as sinon from 'sinon';
+import * as should from 'should';
+import * as vscode from 'vscode';
+import * as TypeMoq from 'typemoq';
+import { getExtensionApi, throwIfNoAzdataOrEulaNotAccepted } from '../api';
+import { AzdataToolService } from '../services/azdataToolService';
+import { assertRejected } from './testUtils';
+import { AzdataTool, IAzdataTool, AzdataDeployOption } from '../azdata';
+
+describe('api', function (): void {
+	afterEach(function (): void {
+		sinon.restore();
+	});
+	describe('throwIfNoAzdataOrEulaNotAccepted', function (): void {
+		it('throws when no azdata', function (): void {
+			should(() => throwIfNoAzdataOrEulaNotAccepted(undefined, false)).throw();
+		});
+		it('throws when EULA not accepted', function (): void {
+			should(() => throwIfNoAzdataOrEulaNotAccepted(TypeMoq.Mock.ofType<IAzdataTool>().object, false)).throw();
+		});
+		it('passes with AzdataTool and EULA accepted', function (): void {
+			throwIfNoAzdataOrEulaNotAccepted(TypeMoq.Mock.ofType<IAzdataTool>().object, true);
+		});
+	});
+	describe('getExtensionApi', function (): void {
+		it('throws when no azdata', async function (): Promise<void> {
+			const mementoMock = TypeMoq.Mock.ofType<vscode.Memento>();
+			const azdataToolService = new AzdataToolService();
+			const api = getExtensionApi(mementoMock.object, azdataToolService, Promise.resolve(undefined));
+			await assertRejected(api.isEulaAccepted(), 'isEulaAccepted');
+			await assertApiCalls(api, assertRejected);
+		});
+
+		it('throws when EULA not accepted', async function (): Promise<void> {
+			const mementoMock = TypeMoq.Mock.ofType<vscode.Memento>();
+			mementoMock.setup(x => x.get(TypeMoq.It.isAny())).returns(() => false);
+			const azdataToolService = new AzdataToolService();
+			// Not using a mock here because it'll hang when resolving mocked objects
+			const api = getExtensionApi(mementoMock.object, azdataToolService, Promise.resolve(new AzdataTool('', '1.0.0')));
+			should(await api.isEulaAccepted()).be.false('EULA should not be accepted');
+			await assertApiCalls(api, assertRejected);
+		});
+
+		it('succeed when azdata present and EULA accepted', async function (): Promise<void> {
+			const mementoMock = TypeMoq.Mock.ofType<vscode.Memento>();
+			mementoMock.setup(x => x.get(TypeMoq.It.isAny())).returns(() => true);
+			const azdataTool = new AzdataTool('', '99.0.0');
+			const azdataToolService = new AzdataToolService();
+			azdataToolService.localAzdata = azdataTool;
+			// Not using a mock here because it'll hang when resolving mocked objects
+			const api = getExtensionApi(mementoMock.object, azdataToolService, Promise.resolve(azdataTool));
+			should(await api.isEulaAccepted()).be.true('EULA should be accepted');
+			sinon.stub(childProcess, 'executeCommand').callsFake(async (_command, args) => {
+				// Version needs to be valid so it can be parsed correctly
+				if (args[0] === '--version') {
+					return { stdout: `99.0.0`, stderr: '' };
+				}
+				console.log(args[0]);
+				return { stdout: `{ }`, stderr: '' };
+			});
+			await assertApiCalls(api, async (promise, message) => {
+				try {
+					await promise;
+				} catch (err) {
+					throw new Error(`API call to ${message} should have succeeded. ${err}`);
+				}
+			});
+		});
+
+		it('promptForEula', async function (): Promise<void> {
+			const mementoMock = TypeMoq.Mock.ofType<vscode.Memento>();
+			mementoMock.setup(x => x.get(TypeMoq.It.isAny())).returns(() => true);
+			const azdataToolService = new AzdataToolService();
+			// Not using a mock here because it'll hang when resolving mocked objects
+			const api = getExtensionApi(mementoMock.object, azdataToolService, Promise.resolve(new AzdataTool('', '1.0.0')));
+			const configMock = TypeMoq.Mock.ofType<vscode.WorkspaceConfiguration>();
+			configMock.setup(x => x.get(TypeMoq.It.isAny())).returns(() => AzdataDeployOption.dontPrompt);
+			sinon.stub(vscode.workspace, 'getConfiguration').returns(configMock.object);
+			const showErrorMessageStub = sinon.stub(vscode.window, 'showErrorMessage');
+			should(await api.promptForEula()).be.false();
+			should(showErrorMessageStub.called).be.true('User should have been prompted to accept');
+		});
+
+		/**
+		 * Asserts that calls to the Azdata API behave as expected
+		 * @param api The API object to test the calls with
+		 * @param assertCallback The function to assert that the results are as expected
+		 */
+		async function assertApiCalls(api: azdataExt.IExtension, assertCallback: (promise: Promise<any>, message: string) => Promise<void>): Promise<void> {
+			await assertCallback(api.azdata.getPath(), 'getPath');
+			await assertCallback(api.azdata.getSemVersion(), 'getSemVersion');
+			await assertCallback(api.azdata.login({ endpoint: 'https://127.0.0.1' }, '', ''), 'login');
+			await assertCallback(api.azdata.login({ namespace: 'namespace' }, '', ''), 'login');
+			await assertCallback(api.azdata.version(), 'version');
+
+			await assertCallback(api.azdata.arc.dc.create('', '', '', '', '', ''), 'arc dc create');
+
+			await assertCallback(api.azdata.arc.dc.config.list(), 'arc dc config list');
+			await assertCallback(api.azdata.arc.dc.config.show(), 'arc dc config show');
+
+			await assertCallback(api.azdata.arc.dc.endpoint.list(), 'arc dc endpoint list');
+
+			await assertCallback(api.azdata.arc.sql.mi.list(), 'arc sql mi list');
+			await assertCallback(api.azdata.arc.sql.mi.delete(''), 'arc sql mi delete');
+			await assertCallback(api.azdata.arc.sql.mi.show(''), 'arc sql mi show');
+			await assertCallback(api.azdata.arc.sql.mi.edit('', {}), 'arc sql mi edit');
+			await assertCallback(api.azdata.arc.postgres.server.list(), 'arc sql postgres server list');
+			await assertCallback(api.azdata.arc.postgres.server.delete(''), 'arc sql postgres server delete');
+			await assertCallback(api.azdata.arc.postgres.server.show(''), 'arc sql postgres server show');
+			await assertCallback(api.azdata.arc.postgres.server.edit('', {}), 'arc sql postgres server edit');
+		}
+	});
+});
+

extensions/azcli/src/test/azdata.test.ts

@@ -0,0 +1,805 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as should from 'should';
+import * as sinon from 'sinon';
+import * as vscode from 'vscode';
+import * as azdata from '../azdata';
+import * as childProcess from '../common/childProcess';
+import { HttpClient } from '../common/httpClient';
+import * as utils from '../common/utils';
+import * as loc from '../localizedConstants';
+import * as os from 'os';
+import * as fs from 'fs';
+import { AzdataReleaseInfo } from '../azdataReleaseInfo';
+import * as TypeMoq from 'typemoq';
+import { eulaAccepted } from '../constants';
+
+const oldAzdataMock = new azdata.AzdataTool('/path/to/azdata', azdata.MIN_AZDATA_VERSION.raw);
+const currentAzdataMock = new azdata.AzdataTool('/path/to/azdata', '9999.999.999');
+
+/**
+ * This matches the schema of the JSON file used to determine the current version of
+ * azdata - do not modify unless also updating the corresponding JSON file
+ */
+const releaseJson: AzdataReleaseInfo = {
+	win32: {
+		'version': '9999.999.999',
+		'link': 'https://download.com/azdata-20.0.1.msi'
+	},
+	darwin: {
+		'version': '9999.999.999'
+	},
+	linux: {
+		'version': '9999.999.999'
+	}
+};
+let executeSudoCommandStub: sinon.SinonStub;
+
+describe('azdata', function () {
+	afterEach(function (): void {
+		sinon.restore();
+	});
+	describe('azdataTool', function (): void {
+		const azdataTool = new azdata.AzdataTool(os.tmpdir(), '1.0.0');
+		let executeCommandStub: sinon.SinonStub;
+		const namespace = 'myNamespace';
+		const name = 'myName';
+		const connectivityMode = 'myConnectivityMode';
+		const resourceGroup = 'myResourceGroup';
+		const location = 'myLocation';
+		const subscription = 'mySubscription';
+		const profileName = 'myProfileName';
+		const storageClass = 'myStorageClass';
+
+		beforeEach(function (): void {
+			executeCommandStub = sinon.stub(childProcess, 'executeCommand').resolves({ stdout: '{}', stderr: '' });
+		});
+
+		describe('arc', function (): void {
+			describe('dc', function (): void {
+				it('create', async function (): Promise<void> {
+					await azdataTool.arc.dc.create(namespace, name, connectivityMode, resourceGroup, location, subscription, profileName, storageClass);
+					verifyExecuteCommandCalledWithArgs([
+						'arc', 'dc', 'create',
+						namespace,
+						name,
+						connectivityMode,
+						resourceGroup,
+						location,
+						subscription,
+						profileName,
+						storageClass]);
+				});
+				describe('endpoint', async function (): Promise<void> {
+					it('list', async function (): Promise<void> {
+						await azdataTool.arc.dc.endpoint.list();
+						verifyExecuteCommandCalledWithArgs(['arc', 'dc', 'endpoint', 'list']);
+					});
+				});
+				describe('config', async function (): Promise<void> {
+					it('list', async function (): Promise<void> {
+						await azdataTool.arc.dc.config.list();
+						verifyExecuteCommandCalledWithArgs(['arc', 'dc', 'config', 'list']);
+					});
+					it('show', async function (): Promise<void> {
+						await azdataTool.arc.dc.config.show();
+						verifyExecuteCommandCalledWithArgs(['arc', 'dc', 'config', 'show']);
+					});
+				});
+			});
+			describe('postgres', function (): void {
+				describe('server', function (): void {
+					it('delete', async function (): Promise<void> {
+						await azdataTool.arc.postgres.server.delete(name);
+						verifyExecuteCommandCalledWithArgs(['arc', 'postgres', 'server', 'delete', name]);
+					});
+					it('list', async function (): Promise<void> {
+						await azdataTool.arc.postgres.server.list();
+						verifyExecuteCommandCalledWithArgs(['arc', 'postgres', 'server', 'list']);
+					});
+					it('show', async function (): Promise<void> {
+						await azdataTool.arc.postgres.server.show(name);
+						verifyExecuteCommandCalledWithArgs(['arc', 'postgres', 'server', 'show', name]);
+					});
+					it('edit', async function (): Promise<void> {
+						const args = {
+							adminPassword: true,
+							coresLimit: 'myCoresLimit',
+							coresRequest: 'myCoresRequest',
+							engineSettings: 'myEngineSettings',
+							extensions: 'myExtensions',
+							memoryLimit: 'myMemoryLimit',
+							memoryRequest: 'myMemoryRequest',
+							noWait: true,
+							port: 1337,
+							replaceEngineSettings: true,
+							workers: 2
+						};
+						await azdataTool.arc.postgres.server.edit(name, args);
+						verifyExecuteCommandCalledWithArgs([
+							'arc', 'postgres', 'server', 'edit',
+							name,
+							'--admin-password',
+							args.coresLimit,
+							args.coresRequest,
+							args.engineSettings,
+							args.extensions,
+							args.memoryLimit,
+							args.memoryRequest,
+							'--no-wait',
+							args.port.toString(),
+							'--replace-engine-settings',
+							args.workers.toString()]);
+					});
+					it('edit no optional args', async function (): Promise<void> {
+						await azdataTool.arc.postgres.server.edit(name, {});
+						verifyExecuteCommandCalledWithArgs([
+							'arc', 'postgres', 'server', 'edit',
+							name]);
+						verifyExecuteCommandCalledWithoutArgs([
+							'--admin-password',
+							'--cores-limit',
+							'--cores-request',
+							'--engine-settings',
+							'--extensions',
+							'--memory-limit',
+							'--memory-request',
+							'--no-wait',
+							'--port',
+							'--replace-engine-settings',
+							'--workers']);
+					});
+				});
+			});
+			describe('sql', function (): void {
+				describe('mi', function (): void {
+					it('delete', async function (): Promise<void> {
+						await azdataTool.arc.sql.mi.delete(name);
+						verifyExecuteCommandCalledWithArgs(['arc', 'sql', 'mi', 'delete', name]);
+					});
+					it('list', async function (): Promise<void> {
+						await azdataTool.arc.sql.mi.list();
+						verifyExecuteCommandCalledWithArgs(['arc', 'sql', 'mi', 'list']);
+					});
+					it('show', async function (): Promise<void> {
+						await azdataTool.arc.sql.mi.show(name);
+						verifyExecuteCommandCalledWithArgs(['arc', 'sql', 'mi', 'show', name]);
+					});
+				});
+			});
+			it('general error throws', async function (): Promise<void> {
+				const err = new Error();
+				executeCommandStub.throws(err);
+				try {
+					await azdataTool.arc.dc.endpoint.list();
+					throw new Error('command should have failed');
+				} catch (error) {
+					should(error).equal(err);
+				}
+			});
+			it('ExitCodeError handled and parsed correctly', async function (): Promise<void> {
+				const errorInnerText = 'my error text';
+				const err = new childProcess.ExitCodeError(1, `ERROR { "stderr": "${errorInnerText}"}`);
+				executeCommandStub.throws(err);
+				try {
+					await azdataTool.arc.dc.endpoint.list();
+					throw new Error('command should have failed');
+				} catch (error) {
+					should(error).equal(err);
+					should((error as childProcess.ExitCodeError).stderr).equal(errorInnerText);
+				}
+			});
+			it('ExitCodeError general error with azdata tool existing rethrows original error', async function (): Promise<void> {
+				sinon.stub(fs.promises, 'access').resolves();
+				const err = new childProcess.ExitCodeError(1, 'some other error');
+				executeCommandStub.throws(err);
+				try {
+					await azdataTool.arc.dc.endpoint.list();
+					throw new Error('command should have failed');
+				} catch (error) {
+					should(error).equal(err);
+				}
+			});
+			it('ExitCodeError general error with azdata tool not existing throws NoAzdataError', async function (): Promise<void> {
+				sinon.stub(fs.promises, 'access').throws(new Error('not found'));
+				const err = new childProcess.ExitCodeError(1, 'some other error');
+				executeCommandStub.throws(err);
+				try {
+					await azdataTool.arc.dc.endpoint.list();
+					throw new Error('command should have failed');
+				} catch (error) {
+					should(error instanceof utils.NoAzdataError).be.true('error should have been instance of NoAzdataError');
+				}
+			});
+		});
+
+		it('login', async function (): Promise<void> {
+			const endpoint = 'myEndpoint';
+			const username = 'myUsername';
+			const password = 'myPassword';
+			await azdataTool.login({ endpoint: endpoint }, username, password);
+			verifyExecuteCommandCalledWithArgs(['login', endpoint, username]);
+		});
+
+		it('version', async function (): Promise<void> {
+			executeCommandStub.resolves({ stdout: '1.0.0', stderr: '' });
+			await azdataTool.version();
+			verifyExecuteCommandCalledWithArgs(['--version']);
+		});
+
+		/**
+		 * Verifies that the specified args were included in the call to executeCommand
+		 * @param args The args to check were included in the execute command call
+		 */
+		function verifyExecuteCommandCalledWithArgs(args: string[], callIndex = 0): void {
+			const commandArgs = executeCommandStub.args[callIndex][1] as string[];
+			args.forEach(arg => should(commandArgs).containEql(arg));
+		}
+
+		/**
+		 * Verifies that the specified args weren't included in the call to executeCommand
+		 * @param args The args to check weren't included in the execute command call
+		 */
+		function verifyExecuteCommandCalledWithoutArgs(args: string[]): void {
+			const commandArgs = executeCommandStub.args[0][1] as string[];
+			args.forEach(arg => should(commandArgs).not.containEql(arg));
+		}
+	});
+
+	describe('findAzdata', function (): void {
+		it('successful', async function (): Promise<void> {
+			// Mock searchForCmd to return a path to azdata.cmd
+			sinon.stub(utils, 'searchForCmd').returns(Promise.resolve('/path/to/azdata'));
+			// Mock call to --version to simulate azdata being installed
+			sinon.stub(childProcess, 'executeCommand').returns(Promise.resolve({ stdout: '1.0.0', stderr: '' }));
+			await should(azdata.findAzdata()).not.be.rejected();
+		});
+		it('unsuccessful', async function (): Promise<void> {
+			if (process.platform === 'win32') {
+				// Mock searchForCmd to return a failure to find azdata.cmd
+				sinon.stub(utils, 'searchForCmd').returns(Promise.reject(new Error('Could not find azdata')));
+			} else {
+				// Mock call to executeCommand to simulate azdata --version returning error
+				sinon.stub(childProcess, 'executeCommand').returns(Promise.reject({ stdout: '', stderr: 'command not found: azdata' }));
+			}
+			await should(azdata.findAzdata()).be.rejected();
+		});
+	});
+
+	describe('installAzdata', function (): void {
+
+		let errorMessageStub: sinon.SinonStub;
+		beforeEach(function (): void {
+			errorMessageStub = sinon.stub(vscode.window, 'showErrorMessage').returns(Promise.resolve(<any>loc.yes));
+			sinon.stub(utils, 'searchForCmd').returns(Promise.resolve('/path/to/azdata'));
+			executeSudoCommandStub = sinon.stub(childProcess, 'executeSudoCommand').returns(Promise.resolve({ stdout: '', stderr: '' }));
+		});
+
+		it('successful install', async function (): Promise<void> {
+			switch (process.platform) {
+				case 'win32':
+					await testWin32SuccessfulInstall();
+					break;
+				case 'darwin':
+					await testDarwinSuccessfulInstall();
+					break;
+				case 'linux':
+					await testLinuxSuccessfulInstall();
+					break;
+			}
+		});
+
+		it('skipped install - dont prompt config', async function (): Promise<void> {
+			const configMock = TypeMoq.Mock.ofType<vscode.WorkspaceConfiguration>();
+			configMock.setup(x => x.get(TypeMoq.It.isAny())).returns(() => 'dontPrompt');
+			sinon.stub(vscode.workspace, 'getConfiguration').returns(configMock.object);
+			switch (process.platform) {
+				case 'win32':
+					await testWin32SkippedInstall();
+					break;
+				case 'darwin':
+					await testDarwinSkippedInstall();
+					break;
+				case 'linux':
+					await testLinuxSkippedInstall();
+					break;
+			}
+		});
+
+		it('skipped install - user chose not to prompt', async function (): Promise<void> {
+			const configMock = TypeMoq.Mock.ofType<vscode.WorkspaceConfiguration>();
+			configMock.setup(x => x.get(TypeMoq.It.isAny())).returns(() => azdata.AzdataDeployOption.prompt);
+			sinon.stub(vscode.workspace, 'getConfiguration').returns(configMock.object);
+			errorMessageStub.resolves(<any>loc.doNotAskAgain);
+			switch (process.platform) {
+				case 'win32':
+					await testWin32SkippedInstall();
+					break;
+				case 'darwin':
+					await testDarwinSkippedInstall();
+					break;
+				case 'linux':
+					await testLinuxSkippedInstall();
+					break;
+			}
+			configMock.verify(x => x.update(TypeMoq.It.isAny(), azdata.AzdataDeployOption.dontPrompt, TypeMoq.It.isAny()), TypeMoq.Times.once());
+		});
+
+		if (process.platform === 'win32') {
+			it('unsuccessful download - win32', async function (): Promise<void> {
+				sinon.stub(HttpClient, 'downloadFile').rejects();
+				sinon.stub(childProcess, 'executeCommand')
+					.onFirstCall()
+					.rejects(new Error('not Found')) // First call mock the tool not being found
+					.resolves({ stdout: '1.0.0', stderr: '' });
+				const azdataTool = await azdata.checkAndInstallAzdata();
+				should(azdataTool).be.undefined();
+			});
+		}
+
+		it('unsuccessful install', async function (): Promise<void> {
+			switch (process.platform) {
+				case 'win32':
+					await testWin32UnsuccessfulInstall();
+					break;
+				case 'darwin':
+					await testDarwinUnsuccessfulInstall();
+					break;
+				case 'linux':
+					await testLinuxUnsuccessfulInstall();
+					break;
+			}
+		});
+	});
+
+	describe('updateAzdata', function (): void {
+		let showInformationMessageStub: sinon.SinonStub;
+
+		beforeEach(function (): void {
+			showInformationMessageStub = sinon.stub(vscode.window, 'showInformationMessage').returns(Promise.resolve(<any>loc.yes));
+			executeSudoCommandStub = sinon.stub(childProcess, 'executeSudoCommand').returns(Promise.resolve({ stdout: '', stderr: '' }));
+			sinon.stub(HttpClient, 'getTextContent').resolves(JSON.stringify(releaseJson));
+		});
+
+		it('successful update', async function (): Promise<void> {
+			switch (process.platform) {
+				case 'win32':
+					await testWin32SuccessfulUpdate();
+					break;
+				case 'darwin':
+					await testDarwinSuccessfulUpdate();
+					break;
+				case 'linux':
+					await testLinuxSuccessfulUpdate();
+					break;
+			}
+		});
+
+		it('successful update - always prompt if user requested', async function (): Promise<void> {
+			const configMock = TypeMoq.Mock.ofType<vscode.WorkspaceConfiguration>();
+			configMock.setup(x => x.get(TypeMoq.It.isAny())).returns(() => azdata.AzdataDeployOption.dontPrompt);
+			sinon.stub(vscode.workspace, 'getConfiguration').returns(configMock.object);
+			switch (process.platform) {
+				case 'win32':
+					await testWin32SuccessfulUpdate(true);
+					break;
+				case 'darwin':
+					await testDarwinSuccessfulUpdate(true);
+					break;
+				case 'linux':
+					await testLinuxSuccessfulUpdate(true);
+					break;
+			}
+		});
+
+		it('skipped update - config set not to prompt', async function (): Promise<void> {
+			const configMock = TypeMoq.Mock.ofType<vscode.WorkspaceConfiguration>();
+			configMock.setup(x => x.get(TypeMoq.It.isAny())).returns(() => azdata.AzdataDeployOption.dontPrompt);
+			sinon.stub(vscode.workspace, 'getConfiguration').returns(configMock.object);
+			switch (process.platform) {
+				case 'win32':
+					await testWin32SkippedUpdateDontPrompt();
+					break;
+				case 'darwin':
+					await testDarwinSkippedUpdateDontPrompt();
+					break;
+				case 'linux':
+					await testLinuxSkippedUpdateDontPrompt();
+					break;
+			}
+		});
+
+		it('skipped update - user chose to never prompt again', async function (): Promise<void> {
+			const configMock = TypeMoq.Mock.ofType<vscode.WorkspaceConfiguration>();
+			configMock.setup(x => x.get(TypeMoq.It.isAny())).returns(() => azdata.AzdataDeployOption.prompt);
+			sinon.stub(vscode.workspace, 'getConfiguration').returns(configMock.object);
+			showInformationMessageStub.resolves(<any>loc.doNotAskAgain);
+			switch (process.platform) {
+				case 'win32':
+					await testWin32SkippedUpdateDontPrompt();
+					break;
+				case 'darwin':
+					await testDarwinSkippedUpdateDontPrompt();
+					break;
+				case 'linux':
+					await testLinuxSkippedUpdateDontPrompt();
+					break;
+			}
+			// Config should have been updated since user chose never to prompt again
+			configMock.verify(x => x.update(TypeMoq.It.isAny(), azdata.AzdataDeployOption.dontPrompt, TypeMoq.It.isAny()), TypeMoq.Times.once());
+		});
+
+		it('skipped update - no new version', async function (): Promise<void> {
+			switch (process.platform) {
+				case 'win32':
+					await testWin32SkippedUpdate();
+					break;
+				case 'darwin':
+					await testDarwinSkippedUpdate();
+					break;
+				case 'linux':
+					await testLinuxSkippedUpdate();
+					break;
+			}
+		});
+
+		it('skipped update - no azdata', async function (): Promise<void> {
+			const result = await azdata.checkAndUpdateAzdata();
+			should(result).be.false();
+		});
+
+		it('unsuccessful update', async function (): Promise<void> {
+			switch (process.platform) {
+				case 'win32':
+					await testWin32UnsuccessfulUpdate();
+					break;
+				case 'darwin':
+					await testDarwinUnsuccessfulUpdate();
+					break;
+				case 'linux':
+					await testLinuxUnsuccessfulUpdate();
+			}
+		});
+
+		describe('discoverLatestAvailableAzdataVersion', function (): void {
+			it('finds latest available version of azdata successfully', async function (): Promise<void> {
+				await azdata.discoverLatestAvailableAzdataVersion();
+			});
+		});
+	});
+
+	describe('promptForEula', function (): void {
+		it('skipped because of config', async function (): Promise<void> {
+			const configMock = TypeMoq.Mock.ofType<vscode.WorkspaceConfiguration>();
+			configMock.setup(x => x.get(TypeMoq.It.isAny())).returns(() => azdata.AzdataDeployOption.dontPrompt);
+			sinon.stub(vscode.workspace, 'getConfiguration').returns(configMock.object);
+			const mementoMock = TypeMoq.Mock.ofType<vscode.Memento>();
+			const result = await azdata.promptForEula(mementoMock.object);
+			should(result).be.false();
+		});
+
+		it('always prompt if user requested', async function (): Promise<void> {
+			const configMock = TypeMoq.Mock.ofType<vscode.WorkspaceConfiguration>();
+			configMock.setup(x => x.get(TypeMoq.It.isAny())).returns(() => azdata.AzdataDeployOption.dontPrompt);
+			sinon.stub(vscode.workspace, 'getConfiguration').returns(configMock.object);
+			const mementoMock = TypeMoq.Mock.ofType<vscode.Memento>();
+			const showInformationMessage = sinon.stub(vscode.window, 'showInformationMessage');
+			const result = await azdata.promptForEula(mementoMock.object, true);
+			should(result).be.false();
+			should(showInformationMessage.calledOnce).be.true('showInformationMessage should have been called to prompt user');
+		});
+
+		it('prompt if config set to do so', async function (): Promise<void> {
+			const configMock = TypeMoq.Mock.ofType<vscode.WorkspaceConfiguration>();
+			configMock.setup(x => x.get(TypeMoq.It.isAny())).returns(() => azdata.AzdataDeployOption.prompt);
+			sinon.stub(vscode.workspace, 'getConfiguration').returns(configMock.object);
+			const mementoMock = TypeMoq.Mock.ofType<vscode.Memento>();
+			const showInformationMessage = sinon.stub(vscode.window, 'showInformationMessage');
+			const result = await azdata.promptForEula(mementoMock.object);
+			should(result).be.false();
+			should(showInformationMessage.calledOnce).be.true('showInformationMessage should have been called to prompt user');
+		});
+
+		it('update config if user chooses not to prompt', async function (): Promise<void> {
+			const configMock = TypeMoq.Mock.ofType<vscode.WorkspaceConfiguration>();
+			configMock.setup(x => x.get(TypeMoq.It.isAny())).returns(() => azdata.AzdataDeployOption.prompt);
+			sinon.stub(vscode.workspace, 'getConfiguration').returns(configMock.object);
+			const mementoMock = TypeMoq.Mock.ofType<vscode.Memento>();
+			const showInformationMessage = sinon.stub(vscode.window, 'showInformationMessage').resolves(<any>loc.doNotAskAgain);
+			const result = await azdata.promptForEula(mementoMock.object);
+			configMock.verify(x => x.update(TypeMoq.It.isAny(), azdata.AzdataDeployOption.dontPrompt, TypeMoq.It.isAny()), TypeMoq.Times.once());
+			should(result).be.false('EULA should not have been accepted');
+			should(showInformationMessage.calledOnce).be.true('showInformationMessage should have been called to prompt user');
+		});
+
+		it('user accepted EULA', async function (): Promise<void> {
+			const configMock = TypeMoq.Mock.ofType<vscode.WorkspaceConfiguration>();
+			configMock.setup(x => x.get(TypeMoq.It.isAny())).returns(() => azdata.AzdataDeployOption.prompt);
+			sinon.stub(vscode.workspace, 'getConfiguration').returns(configMock.object);
+			const mementoMock = TypeMoq.Mock.ofType<vscode.Memento>();
+			const showInformationMessage = sinon.stub(vscode.window, 'showInformationMessage').resolves(<any>loc.accept);
+			const result = await azdata.promptForEula(mementoMock.object);
+			mementoMock.verify(x => x.update(eulaAccepted, true), TypeMoq.Times.once());
+			should(result).be.true('EULA should have been accepted');
+			should(showInformationMessage.calledOnce).be.true('showInformationMessage should have been called to prompt user');
+		});
+
+		it('user accepted EULA - require user action', async function (): Promise<void> {
+			const configMock = TypeMoq.Mock.ofType<vscode.WorkspaceConfiguration>();
+			configMock.setup(x => x.get(TypeMoq.It.isAny())).returns(() => azdata.AzdataDeployOption.prompt);
+			sinon.stub(vscode.workspace, 'getConfiguration').returns(configMock.object);
+			const mementoMock = TypeMoq.Mock.ofType<vscode.Memento>();
+			const showErrorMessage = sinon.stub(vscode.window, 'showErrorMessage').resolves(<any>loc.accept);
+			const result = await azdata.promptForEula(mementoMock.object, true, true);
+			mementoMock.verify(x => x.update(eulaAccepted, true), TypeMoq.Times.once());
+			should(result).be.true('EULA should have been accepted');
+			should(showErrorMessage.calledOnce).be.true('showErrorMessage should have been called to prompt user');
+		});
+	});
+
+	describe('isEulaAccepted', function (): void {
+		const mementoMock = TypeMoq.Mock.ofType<vscode.Memento>();
+		mementoMock.setup(x => x.get(TypeMoq.It.isAny())).returns(() => true);
+		should(azdata.isEulaAccepted(mementoMock.object)).be.true();
+	});
+});
+
+async function testLinuxUnsuccessfulUpdate() {
+	executeSudoCommandStub.rejects();
+	const updateDone = await azdata.checkAndUpdateAzdata(oldAzdataMock);
+	should(updateDone).be.false();
+	should(executeSudoCommandStub.calledOnce).be.true();
+}
+
+async function testDarwinUnsuccessfulUpdate() {
+	const brewInfoOutput = [{
+		name: 'azdata-cli',
+		full_name: 'microsoft/azdata-cli-release/azdata-cli',
+		versions: {
+			'stable': '9999.999.999',
+			'devel': null,
+			'head': null,
+			'bottle': true
+		}
+	}];
+	const executeCommandStub = sinon.stub(childProcess, 'executeCommand')
+		.onThirdCall() //third call is brew info azdata-cli --json which needs to return json of new available azdata versions.
+		.callsFake(async (_command: string, _args: string[]) => {
+			return Promise.resolve({
+				stderr: '',
+				stdout: JSON.stringify(brewInfoOutput)
+			});
+		})
+		.onCall(5) //6th call is the first one to do actual update, the call number are 0 indexed
+		.callsFake(async (_command: string, _args: string[]) => {
+			return Promise.reject(new Error('not Found'));
+		})
+		.callsFake(async (_command: string, _args: string[]) => { // by default return success
+			return Promise.resolve({ stderr: '', stdout: 'success' });
+		});
+	const updateDone = await azdata.checkAndUpdateAzdata(oldAzdataMock);
+	should(updateDone).be.false();
+	should(executeCommandStub.callCount).equal(6);
+}
+
+async function testWin32UnsuccessfulUpdate() {
+	sinon.stub(HttpClient, 'downloadFile').returns(Promise.resolve(__filename));
+	executeSudoCommandStub.rejects();
+	const updateDone = await azdata.checkAndUpdateAzdata(oldAzdataMock);
+	should(updateDone).be.false('Update should not have been successful');
+	should(executeSudoCommandStub.calledOnce).be.true();
+}
+
+async function testLinuxSuccessfulUpdate(userRequested = false) {
+	const executeCommandStub = sinon.stub(childProcess, 'executeCommand').returns(Promise.resolve({ stdout: '0.0.0', stderr: '' }));
+	executeSudoCommandStub.resolves({ stdout: '0.0.0', stderr: '' });
+	await azdata.checkAndUpdateAzdata(oldAzdataMock, userRequested);
+	should(executeSudoCommandStub.callCount).be.equal(6);
+	should(executeCommandStub.calledOnce).be.true();
+}
+
+async function testDarwinSuccessfulUpdate(userRequested = false) {
+	const brewInfoOutput = [{
+		name: 'azdata-cli',
+		full_name: 'microsoft/azdata-cli-release/azdata-cli',
+		versions: {
+			'stable': '9999.999.999',
+			'devel': null,
+			'head': null,
+			'bottle': true
+		}
+	}];
+	const executeCommandStub = sinon.stub(childProcess, 'executeCommand')
+		.onThirdCall() //third call is brew info azdata-cli --json which needs to return json of new available azdata versions.
+		.resolves({
+			stderr: '',
+			stdout: JSON.stringify(brewInfoOutput)
+		})
+		.resolves({ stdout: '0.0.0', stderr: '' });
+	await azdata.checkAndUpdateAzdata(oldAzdataMock, userRequested);
+	should(executeCommandStub.callCount).be.equal(6);
+	should(executeCommandStub.getCall(2).args[0]).be.equal('brew', '3rd call should have been to brew');
+	should(executeCommandStub.getCall(2).args[1]).deepEqual(['info', 'azdata-cli', '--json'], '3rd call did not have expected arguments');
+}
+
+
+async function testWin32SuccessfulUpdate(userRequested = false) {
+	sinon.stub(HttpClient, 'downloadFile').returns(Promise.resolve(__filename));
+	await azdata.checkAndUpdateAzdata(oldAzdataMock, userRequested);
+	should(executeSudoCommandStub.calledOnce).be.true('executeSudoCommand should have been called once');
+	should(executeSudoCommandStub.getCall(0).args[0]).startWith('msiexec /qn /i');
+}
+
+async function testLinuxSkippedUpdate() {
+	executeSudoCommandStub.resolves({ stdout: '0.0.0', stderr: '' });
+	await azdata.checkAndUpdateAzdata(currentAzdataMock);
+	should(executeSudoCommandStub.callCount).be.equal(0, 'executeSudoCommand was not expected to be called');
+}
+
+async function testDarwinSkippedUpdateDontPrompt() {
+	const brewInfoOutput = [{
+		name: 'azdata-cli',
+		full_name: 'microsoft/azdata-cli-release/azdata-cli',
+		versions: {
+			'stable': '9999.999.999',
+			'devel': null,
+			'head': null,
+			'bottle': true
+		}
+	}];
+	const executeCommandStub = sinon.stub(childProcess, 'executeCommand')
+		.onThirdCall() //third call is brew info azdata-cli --json which needs to return json of new available azdata versions.
+		.resolves({
+			stderr: '',
+			stdout: JSON.stringify(brewInfoOutput)
+		})
+		.resolves({ stdout: '0.0.0', stderr: '' });
+	await azdata.checkAndUpdateAzdata(oldAzdataMock);
+	should(executeCommandStub.callCount).be.equal(6);
+	should(executeCommandStub.notCalledWith(sinon.match.any, sinon.match.array.contains(['upgrade', 'azdata-cli'])));
+}
+
+async function testWin32SkippedUpdateDontPrompt() {
+	sinon.stub(HttpClient, 'downloadFile').returns(Promise.resolve(__filename));
+	await azdata.checkAndUpdateAzdata(oldAzdataMock);
+	should(executeSudoCommandStub.notCalled).be.true(`executeSudoCommand should not have been called ${executeSudoCommandStub.getCalls().join(os.EOL)}`);
+}
+
+async function testLinuxSkippedUpdateDontPrompt() {
+	sinon.stub(childProcess, 'executeCommand').returns(Promise.resolve({ stdout: '0.0.0', stderr: '' }));
+	executeSudoCommandStub.resolves({ stdout: '0.0.0', stderr: '' });
+	await azdata.checkAndUpdateAzdata(oldAzdataMock);
+	should(executeSudoCommandStub.callCount).be.equal(0, 'executeSudoCommand was not expected to be called');
+}
+
+async function testDarwinSkippedUpdate() {
+	const brewInfoOutput = [{
+		name: 'azdata-cli',
+		full_name: 'microsoft/azdata-cli-release/azdata-cli',
+		versions: {
+			'stable': '9999.999.999',
+			'devel': null,
+			'head': null,
+			'bottle': true
+		}
+	}];
+	const executeCommandStub = sinon.stub(childProcess, 'executeCommand')
+		.onThirdCall() //third call is brew info azdata-cli --json which needs to return json of new available azdata versions.
+		.resolves({
+			stderr: '',
+			stdout: JSON.stringify(brewInfoOutput)
+		})
+		.resolves({ stdout: '0.0.0', stderr: '' });
+	await azdata.checkAndUpdateAzdata(currentAzdataMock);
+	should(executeCommandStub.callCount).be.equal(6);
+	should(executeCommandStub.notCalledWith(sinon.match.any, sinon.match.array.contains(['upgrade', 'azdata-cli'])));
+}
+
+async function testWin32SkippedUpdate() {
+	sinon.stub(HttpClient, 'downloadFile').returns(Promise.resolve(__filename));
+	await azdata.checkAndUpdateAzdata(currentAzdataMock);
+	should(executeSudoCommandStub.notCalled).be.true('executeSudoCommand should not have been called');
+}
+
+async function testDarwinSkippedInstall() {
+	const executeCommandStub = sinon.stub(childProcess, 'executeCommand')
+		.onFirstCall()
+		.callsFake(async (_command: string, _args: string[]) => {
+			return Promise.reject(new Error('not Found'));
+		})
+		.callsFake(async (_command: string, _args: string[]) => {
+			return Promise.resolve({ stdout: '0.0.0', stderr: '' });
+		});
+	const result = await azdata.checkAndInstallAzdata();
+	should(result).equal(undefined, 'result should be undefined');
+	should(executeCommandStub.callCount).be.equal(0);
+}
+
+async function testLinuxSkippedInstall() {
+	sinon.stub(childProcess, 'executeCommand')
+		.onFirstCall()
+		.rejects(new Error('not Found'))
+		.resolves({ stdout: '0.0.0', stderr: '' });
+	executeSudoCommandStub
+		.resolves({ stdout: 'success', stderr: '' });
+	const result = await azdata.checkAndInstallAzdata();
+	should(result).equal(undefined, 'result should be undefined');
+	should(executeSudoCommandStub.callCount).be.equal(0);
+}
+
+async function testWin32SkippedInstall() {
+	sinon.stub(HttpClient, 'downloadFile').returns(Promise.resolve(__filename));
+	sinon.stub(childProcess, 'executeCommand')
+		.onFirstCall()
+		.rejects(new Error('not Found')) // First call mock the tool not being found
+		.resolves({ stdout: '1.0.0', stderr: '' });
+	executeSudoCommandStub
+		.returns({ stdout: '', stderr: '' });
+	const result = await azdata.checkAndInstallAzdata();
+	should(result).equal(undefined, 'result should be undefined');
+	should(executeSudoCommandStub.notCalled).be.true('executeSudoCommand should not have been called');
+}
+
+async function testWin32SuccessfulInstall() {
+	sinon.stub(HttpClient, 'downloadFile').returns(Promise.resolve(__filename));
+	const executeCommandStub = sinon.stub(childProcess, 'executeCommand')
+		.onFirstCall()
+		.rejects(new Error('not Found')) // First call mock the tool not being found
+		.resolves({ stdout: '1.0.0', stderr: '' });
+	executeSudoCommandStub
+		.returns({ stdout: '', stderr: '' });
+	await azdata.checkAndInstallAzdata();
+	should(executeCommandStub.calledTwice).be.true(`executeCommand should have been called twice. Actual ${executeCommandStub.getCalls().length}`);
+	should(executeSudoCommandStub.calledOnce).be.true(`executeSudoCommand should have been called once. Actual ${executeSudoCommandStub.getCalls().length}`);
+	should(executeSudoCommandStub.getCall(0).args[0]).startWith('msiexec /qn /i');
+}
+
+async function testDarwinSuccessfulInstall() {
+	const executeCommandStub = sinon.stub(childProcess, 'executeCommand')
+		.onFirstCall()
+		.callsFake(async (_command: string, _args: string[]) => {
+			return Promise.reject(new Error('not Found'));
+		})
+		.callsFake(async (_command: string, _args: string[]) => {
+			return Promise.resolve({ stdout: '0.0.0', stderr: '' });
+		});
+	await azdata.checkAndInstallAzdata();
+	should(executeCommandStub.callCount).be.equal(5);
+}
+
+async function testLinuxSuccessfulInstall() {
+	const executeCommandStub = sinon.stub(childProcess, 'executeCommand')
+		.onFirstCall()
+		.rejects(new Error('not Found'))
+		.resolves({ stdout: '0.0.0', stderr: '' });
+	executeSudoCommandStub
+		.resolves({ stdout: 'success', stderr: '' });
+	await azdata.checkAndInstallAzdata();
+	should(executeSudoCommandStub.callCount).be.equal(6);
+	should(executeCommandStub.calledThrice).be.true();
+}
+
+async function testLinuxUnsuccessfulInstall() {
+	executeSudoCommandStub.rejects();
+	const downloadPromise = azdata.installAzdata();
+	await should(downloadPromise).be.rejected();
+	should(executeSudoCommandStub.calledOnce).be.true();
+}
+
+async function testDarwinUnsuccessfulInstall() {
+	const executeCommandStub = sinon.stub(childProcess, 'executeCommand').rejects();
+	const downloadPromise = azdata.installAzdata();
+	await should(downloadPromise).be.rejected();
+	should(executeCommandStub.calledOnce).be.true();
+}
+
+async function testWin32UnsuccessfulInstall() {
+	executeSudoCommandStub.rejects();
+	sinon.stub(HttpClient, 'downloadFile').returns(Promise.resolve(__filename));
+	const downloadPromise = azdata.installAzdata();
+	await should(downloadPromise).be.rejected();
+	should(executeSudoCommandStub.calledOnce).be.true();
+}

extensions/azcli/src/test/azdataReleaseInfo.test.ts

@@ -0,0 +1,75 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as should from 'should';
+import * as sinon from 'sinon';
+import { HttpClient } from '../common/httpClient';
+import { getPlatformReleaseVersion, getPlatformDownloadLink, AzdataReleaseInfo } from '../azdataReleaseInfo';
+
+const emptyReleaseJson = {
+	win32: {},
+	darwin: {},
+	linux: {}
+};
+
+const releaseVersion = '999.999.999';
+const releaseLink = 'https://microsoft.com';
+
+const validReleaseJson: AzdataReleaseInfo = {
+	win32: {
+		version: releaseVersion,
+		link: releaseLink
+	},
+	darwin: {
+		version: releaseVersion,
+		link: releaseLink
+	},
+	linux: {
+		version: releaseVersion,
+		link: releaseLink
+	}
+};
+
+describe('azdataReleaseInfo', function (): void {
+	afterEach(function (): void {
+		sinon.restore();
+	});
+
+	describe('getPlatformReleaseVersion', function(): void {
+		it('gets version successfully', async function(): Promise<void> {
+			sinon.stub(HttpClient, 'getTextContent').resolves(JSON.stringify(validReleaseJson));
+			const version = await getPlatformReleaseVersion();
+			should(version.format()).equal(releaseVersion);
+		});
+
+		it('throws with invalid JSON', async function (): Promise<void> {
+			sinon.stub(HttpClient, 'getTextContent').resolves('invalid JSON');
+			await should(getPlatformReleaseVersion()).be.rejected();
+		});
+
+		it('throws when no version', async function (): Promise<void> {
+			sinon.stub(HttpClient, 'getTextContent').resolves(JSON.stringify(emptyReleaseJson));
+			await should(getPlatformReleaseVersion()).be.rejected();
+		});
+	});
+
+	describe('getPlatformDownloadLink', function(): void {
+		it('gets link successfully', async function(): Promise<void> {
+			sinon.stub(HttpClient, 'getTextContent').resolves(JSON.stringify(validReleaseJson));
+			const link = await getPlatformDownloadLink();
+			should(link).equal(releaseLink);
+		});
+
+		it('throws with invalid JSON', async function (): Promise<void> {
+			sinon.stub(HttpClient, 'getTextContent').resolves('invalid JSON');
+			await should(getPlatformDownloadLink()).be.rejected();
+		});
+
+		it('throws when no version', async function (): Promise<void> {
+			sinon.stub(HttpClient, 'getTextContent').resolves(JSON.stringify(emptyReleaseJson));
+			await should(getPlatformDownloadLink()).be.rejected();
+		});
+	});
+});

extensions/azcli/src/test/common/childProcess.test.ts

@@ -0,0 +1,68 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as should from 'should';
+import * as sudo from 'sudo-prompt';
+import * as sinon from 'sinon';
+import Logger from '../../common/logger';
+
+import { executeCommand, executeSudoCommand } from '../../common/childProcess';
+
+describe('ChildProcess', function (): void {
+
+	afterEach(function(): void {
+		sinon.restore();
+	});
+
+	describe('executeCommand', function(): void {
+		[[], ['test']].forEach(args => {
+			it(`Output channel is used with ${JSON.stringify(args)} args`, async function (): Promise<void> {
+				const logStub = sinon.stub(Logger, 'log');
+				await executeCommand('echo', args);
+				should(logStub.called).be.true('Log should have been called');
+			});
+		});
+
+		it('Gets expected output', async function (): Promise<void> {
+			const echoOutput = 'test';
+			const output = await executeCommand('echo', [echoOutput]);
+			should(output.stdout).equal(echoOutput);
+		});
+
+		it('Invalid command errors', async function (): Promise<void> {
+			await should(executeCommand('invalid_command', [])).be.rejected();
+		});
+	});
+
+	describe('executeSudoCommand', function(): void {
+		it('Gets expected stdout output', async function (): Promise<void> {
+			const stdout = 'stdout output';
+			sinon.stub(sudo, 'exec').callsFake( (_cmd, _options, callback) => {
+				callback!(undefined, stdout);
+			});
+			const result = await executeSudoCommand('echo');
+			should(result.stdout).equal(stdout);
+			should(result.stderr).equal('');
+		});
+
+		it('Gets expected stderr output', async function (): Promise<void> {
+			const stderr = 'stderr output';
+			sinon.stub(sudo, 'exec').callsFake( (_cmd, _options, callback) => {
+				callback!(undefined, undefined, stderr);
+			});
+			const result = await executeSudoCommand('echo');
+			should(result.stdout).equal('');
+			should(result.stderr).equal(stderr);
+		});
+
+		it('Error rejects', async function (): Promise<void> {
+			sinon.stub(sudo, 'exec').callsFake( (_cmd, _options, callback) => {
+				callback!(new Error('error'));
+			});
+			await should(executeSudoCommand('invalid_command')).be.rejected();
+		});
+	});
+
+});

extensions/azcli/src/test/common/httpClient.test.ts

@@ -0,0 +1,100 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as fs from 'fs';
+import * as nock from 'nock';
+import * as os from 'os';
+import * as should from 'should';
+import * as sinon from 'sinon';
+import { PassThrough } from 'stream';
+import { HttpClient } from '../../common/httpClient';
+import { Deferred } from '../../common/promise';
+
+describe('HttpClient', function (): void {
+
+	afterEach(function (): void {
+		nock.cleanAll();
+		nock.enableNetConnect();
+		sinon.restore();
+	});
+
+	describe('downloadFile', function (): void {
+		it('downloads file successfully', async function (): Promise<void> {
+			nock('https://127.0.0.1')
+				.get('/README.md')
+				.replyWithFile(200, __filename);
+			const downloadFolder = os.tmpdir();
+			const downloadPath = await HttpClient.downloadFile('https://127.0.0.1/README.md', downloadFolder);
+			// Verify file was downloaded correctly
+			await fs.promises.stat(downloadPath);
+		});
+
+		it('errors on response stream error', async function (): Promise<void> {
+			const downloadFolder = os.tmpdir();
+			nock('https://127.0.0.1')
+				.get('/')
+				.replyWithError('Unexpected Error');
+			const downloadPromise = HttpClient.downloadFile('https://127.0.0.1', downloadFolder);
+			await should(downloadPromise).be.rejected();
+		});
+
+		it('rejects on non-OK status code', async function (): Promise<void> {
+			const downloadFolder = os.tmpdir();
+			nock('https://127.0.0.1')
+				.get('/')
+				.reply(404, '');
+			const downloadPromise = HttpClient.downloadFile('https://127.0.0.1', downloadFolder);
+			await should(downloadPromise).be.rejected();
+		});
+
+		it('errors on write stream error', async function (): Promise<void> {
+			const downloadFolder = os.tmpdir();
+			const mockWriteStream = new PassThrough();
+			const deferredPromise = new Deferred();
+			sinon.stub(fs, 'createWriteStream').callsFake(() => {
+				deferredPromise.resolve();
+				return <any>mockWriteStream;
+			});
+			nock('https://127.0.0.1')
+				.get('/')
+				.reply(200, '');
+			const downloadPromise = HttpClient.downloadFile('https://127.0.0.1', downloadFolder);
+			// Wait for the stream to be created before throwing the error or HttpClient will miss the event
+			await deferredPromise;
+			try {
+				// Passthrough streams will throw the error we emit so just no-op and
+				// let the HttpClient handler handle the error
+				mockWriteStream.emit('error', 'Unexpected write error');
+			} catch (err) { }
+			await should(downloadPromise).be.rejected();
+		});
+	});
+
+	describe('getTextContent', function (): void {
+		it('Gets file contents correctly', async function (): Promise<void> {
+			nock('https://127.0.0.1')
+				.get('/arbitraryFile')
+				.replyWithFile(200, __filename);
+			const receivedContents = await HttpClient.getTextContent(`https://127.0.0.1/arbitraryFile`);
+			should(receivedContents).equal((await fs.promises.readFile(__filename)).toString());
+		});
+
+		it('rejects on response error', async function (): Promise<void> {
+			nock('https://127.0.0.1')
+				.get('/')
+				.replyWithError('Unexpected Error');
+			const getFileContentsPromise = HttpClient.getTextContent('https://127.0.0.1/', );
+			await should(getFileContentsPromise).be.rejected();
+		});
+
+		it('rejects on non-OK status code', async function (): Promise<void> {
+			nock('https://127.0.0.1')
+				.get('/')
+				.reply(404, '');
+			const getFileContentsPromise = HttpClient.getTextContent('https://127.0.0.1/', );
+			await should(getFileContentsPromise).be.rejected();
+		});
+	});
+});

extensions/azcli/src/test/common/promise.test.ts

@@ -0,0 +1,30 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as should from 'should';
+import { Deferred } from '../../common/promise';
+
+describe('DeferredPromise', function (): void {
+
+	it('Resolves correctly', async function(): Promise<void> {
+		const deferred = new Deferred();
+		deferred.resolve();
+		await should(deferred.promise).be.resolved();
+	});
+
+	it('Rejects correctly', async function(): Promise<void> {
+		const deferred = new Deferred();
+		deferred.reject();
+		await should(deferred.promise).be.rejected();
+	});
+
+	it('Chains then correctly', function(done): void {
+		const deferred = new Deferred();
+		deferred.then( () => {
+			done();
+		});
+		deferred.resolve();
+	});
+});

extensions/azcli/src/test/common/utils.test.ts

@@ -0,0 +1,26 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import * as should from 'should';
+import { NoAzdataError, searchForCmd as searchForExe } from '../../common/utils';
+
+describe('utils', function () {
+	describe('searchForExe', function (): void {
+		it('finds exe successfully', async function (): Promise<void> {
+			await searchForExe('node');
+		});
+		it('throws for non-existent exe', async function (): Promise<void> {
+			await should(searchForExe('someFakeExe')).be.rejected();
+		});
+	});
+
+	describe('NoAzdataError', function (): void {
+		it('error contains message with and without links', function (): void {
+			const error = new NoAzdataError();
+			should(error.message).not.be.empty();
+			should(error.messageWithLink).not.be.empty();
+			should(error.message).not.equal(error.messageWithLink, 'Messages should not be equal');
+		});
+	});
+});

extensions/azcli/src/test/index.ts

@@ -0,0 +1,48 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as path from 'path';
+const testRunner = require('vscodetestcover');
+
+const suite = 'azdata Extension Tests';
+
+const mochaOptions: any = {
+	ui: 'bdd',
+	useColors: true,
+	timeout: 10000
+};
+
+// set relevant mocha options from the environment
+if (process.env.ADS_TEST_GREP) {
+	mochaOptions.grep = process.env.ADS_TEST_GREP;
+	console.log(`setting options.grep to: ${mochaOptions.grep}`);
+}
+if (process.env.ADS_TEST_INVERT_GREP) {
+	mochaOptions.invert = parseInt(process.env.ADS_TEST_INVERT_GREP);
+	console.log(`setting options.invert to: ${mochaOptions.invert}`);
+}
+if (process.env.ADS_TEST_TIMEOUT) {
+	mochaOptions.timeout = parseInt(process.env.ADS_TEST_TIMEOUT);
+	console.log(`setting options.timeout to: ${mochaOptions.timeout}`);
+}
+if (process.env.ADS_TEST_RETRIES) {
+	mochaOptions.retries = parseInt(process.env.ADS_TEST_RETRIES);
+	console.log(`setting options.retries to: ${mochaOptions.retries}`);
+}
+
+if (process.env.BUILD_ARTIFACTSTAGINGDIRECTORY) {
+	mochaOptions.reporter = 'mocha-multi-reporters';
+	mochaOptions.reporterOptions = {
+		reporterEnabled: 'spec, mocha-junit-reporter',
+		mochaJunitReporterReporterOptions: {
+			testsuitesTitle: `${suite} ${process.platform}`,
+			mochaFile: path.join(process.env.BUILD_ARTIFACTSTAGINGDIRECTORY, `test-results/${process.platform}-${suite.toLowerCase().replace(/[^\w]/g, '-')}-results.xml`)
+		}
+	};
+}
+
+testRunner.configure(mochaOptions, { coverConfig: '../../coverConfig.json' });
+
+export = testRunner;

extensions/azcli/src/test/providers/arcControllerConfigProfilesOptionsSource.test.ts

@@ -0,0 +1,38 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as vscode from 'vscode';
+import * as azdataExt from 'azdata-ext';
+import * as should from 'should';
+import * as sinon from 'sinon';
+import { ArcControllerConfigProfilesOptionsSource } from '../../providers/arcControllerConfigProfilesOptionsSource';
+
+describe('arcControllerConfigProfilesOptionsSource', async function (): Promise<void> {
+	afterEach(function(): void {
+		sinon.restore();
+	});
+
+	it('eula accepted returns list', async function (): Promise<void> {
+		const options = ['option1', 'option2'];
+		const api = vscode.extensions.getExtension(azdataExt.extension.name)?.exports as azdataExt.IExtension;
+		sinon.stub(api, 'isEulaAccepted').resolves(true);
+		sinon.stub(api.azdata.arc.dc.config, 'list').resolves({ stdout: [''], stderr: [''], logs: [''], result: options});
+		const source = new ArcControllerConfigProfilesOptionsSource(api);
+		const result = await source.getOptions();
+		should(result).deepEqual(options);
+	});
+
+	it('eula not accepted prompts for acceptance', async function (): Promise<void> {
+		const options = ['option1', 'option2'];
+		const api = vscode.extensions.getExtension(azdataExt.extension.name)?.exports as azdataExt.IExtension;
+		sinon.stub(api, 'isEulaAccepted').resolves(false);
+		const promptStub = sinon.stub(api, 'promptForEula').resolves(true);
+		sinon.stub(api.azdata.arc.dc.config, 'list').resolves({ stdout: [''], stderr: [''], logs: [''], result: options});
+		const source = new ArcControllerConfigProfilesOptionsSource(api);
+		const result = await source.getOptions();
+		should(result).deepEqual(options);
+		should(promptStub.calledOnce).be.true('promptForEula should have been called');
+	});
+});

extensions/azcli/src/test/services/azdataToolService.test.ts

@@ -0,0 +1,17 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as should from 'should';
+import { AzdataTool } from '../../azdata';
+import { AzdataToolService } from '../../services/azdataToolService';
+
+describe('azdataToolService', function (): void {
+	it('Tool should be set correctly', async function (): Promise<void> {
+		const service = new AzdataToolService();
+		should(service.localAzdata).be.undefined();
+		service.localAzdata = new AzdataTool('my path', '1.0.0');
+		should(service).not.be.undefined();
+	});
+});

extensions/azcli/src/test/testUtils.ts

@@ -0,0 +1,20 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+/**
+ * Asserts that the specified promise was rejected. This is similar to should(..).be.rejected but
+ * allows specifying a message in the thrown Error to add more information to the failure.
+ * @param promise The promise to verify was rejected
+ * @param message The message to include in the error if the promise isn't rejected
+ */
+export async function assertRejected(promise: Promise<any>, message: string): Promise<void> {
+	try {
+		await promise;
+	} catch {
+		return;
+	}
+	throw new Error(message);
+}
+

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

@@ -0,0 +1,361 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+declare module 'azdata-ext' {
+	import { SemVer } from 'semver';
+	import * as vscode from 'vscode';
+
+	/**
+	 * Covers defining what the azdata extension exports to other extensions
+	 *
+	 * IMPORTANT: THIS IS NOT A HARD DEFINITION unlike vscode; therefore no enums or classes should be defined here
+	 * (const enums get evaluated when typescript -> javascript so those are fine)
+	 */
+	export const enum extension {
+		name = 'Microsoft.azdata'
+	}
+
+	export type AdditionalEnvVars = { [key: string]: string };
+
+	export interface ErrorWithLink extends Error {
+		messageWithLink: string;
+	}
+
+	export interface DcEndpointListResult {
+		description: string, // "Management Proxy"
+		endpoint: string, // "https://10.91.86.39:30777"
+		name: string, // "mgmtproxy"
+		protocol: string // "https"
+	}
+
+	export interface SqlMiListResult {
+		name: string, // "arc-miaa"
+		replicas: string, // "1/1"
+		serverEndpoint: string,
+		state: string // "Ready"
+	}
+
+	export interface PostgresServerListResult {
+		name: string, // "arc-pg"
+		state: string, // "Ready"
+		workers: number // 1
+	}
+
+	export type DcConfigListResult = string;
+
+	export interface DcConfigShowResult {
+		apiVersion: string, // "arcdata.microsoft.com/v1alpha1"
+		kind: string, // "DataController"
+		metadata: {
+			creationTimestamp: string, // "2020-08-19T17:05:39Z"
+			generation: number, // /1
+			name: string, // "arc"
+			namespace: string, // "arc"
+			resourceVersion: string, // "200369"
+			selfLink: string, // "/apis/arcdata.microsoft.com/v1alpha1/namespaces/arc/datacontrollers/arc"
+			uid: string// "da72ed34-ee51-4bf0-b5c9-b0753834c5c1"
+		},
+		spec: {
+			credentials: {
+				controllerAdmin: string, // "controller-login-secret"
+				dockerRegistry: string, // "mssql-private-registry"
+				serviceAccount: string, // "sa-mssql-controller"
+			},
+			docker: {
+				imagePullPolicy: string, // "Always"
+				imageTag: string, // "15.0.2000.41811_5"
+				registry: string, // "hlsaris.azurecr.io"
+				repository: string // "aris-p-master-dsmain-standard"
+			},
+			security: {
+				allowDumps: boolean, // true,
+				allowNodeMetricsCollection: boolean // true
+				allowPodMetricsCollection: boolean, // true
+				allowRunAsRoot: boolean // false
+			},
+			services: {
+				name: string, // "controller"
+				port: number, // 30080
+				serviceType: string // "NodePort"
+			}[],
+			settings: {
+				ElasticSearch: {
+					'vm.max_map_count': string // "-1"
+				},
+				azure: {
+					connectionMode: string, // "indirect",
+					location: string, // "eastus2euap",
+					resourceGroup: string, // "my-rg",
+					subscription: string, // "a5082b29-8c6e-4bc5-8ddd-8ef39dfebc39"
+				},
+				controller: {
+					'enableBilling': string, // "True"
+					'logs.rotation.days': string, // "7"
+					'logs.rotation.size': string, // "5000"
+				}
+			},
+			storage: {
+				data: {
+					accessMode: string, // "ReadWriteOnce"
+					className: string, // "local-storage"
+					size: string, // "15Gi"
+				},
+				logs: {
+					accessMode: string, // "ReadWriteOnce"
+					className: string, // "local-storage"
+					size: string, // "10Gi"
+				}
+			}
+		},
+		status: {
+			state: string, // "Ready"
+		}
+	}
+
+	export interface StorageVolume {
+		className?: string, // "local-storage"
+		size: string // "5Gi"
+	}
+
+	export interface SchedulingOptions {
+		memory?: string // "10Gi"
+		cpu?: string // "4"
+	}
+
+	export interface ServiceSpec {
+		type: string, // "NodePort"
+		port?: number // 5432
+	}
+
+	export interface SqlMiShowResult {
+		apiVersion: string, // "sql.arcdata.microsoft.com/v1alpha1"
+		kind: string, // "sqlmanagedinstance"
+		metadata: {
+			creationTimestamp: string, // "2020-08-19T17:35:45Z"
+			generation: number, // 1
+			name: string, // "miaa-instance"
+			namespace: string, // "arc"
+			resourceVersion: string, // "202623"
+			selfLink: string, // "/apis/sql.arcdata.microsoft.com/v1alpha1/namespaces/arc/sqlmanagedinstances/miaa-instance"
+			uid: string // "cea737aa-3f82-4f6a-9bed-2b51c2c33dff"
+		},
+		spec: {
+			scheduling?: {
+				default?: {
+					resources?: {
+						limits?: SchedulingOptions,
+						requests?: SchedulingOptions
+					}
+				}
+			}
+			services: {
+				primary: ServiceSpec
+			}
+			storage: {
+				data: {
+					volumes: StorageVolume[]
+				},
+				logs: {
+					volumes: StorageVolume[]
+				}
+			}
+		},
+		status: {
+			readyReplicas: string, // "1/1"
+			state: string, // "Ready",
+			logSearchDashboard: string, // https://127.0.0.1:30777/kibana/app/kibana#/discover?_a=(query:(language:kuery,query:'custom_resource_name:miaa1'))
+			metricsDashboard: string, // https://127.0.0.1:30777/grafana/d/40q72HnGk/sql-managed-instance-metrics?var-hostname=miaa1-0
+			primaryEndpoint?: string // "10.91.86.39:32718"
+		}
+	}
+
+	export interface PostgresServerShowResult {
+		apiVersion: string, // "arcdata.microsoft.com/v1alpha1"
+		kind: string, // "postgresql"
+		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"
+		},
+		spec: {
+			engine: {
+				extensions: {
+					name: string // "citus"
+				}[],
+				settings: {
+					default: { [key: string]: string }, // { "max_connections": "101", "work_mem": "4MB" }
+					roles: {
+						coordinator: { [key: string]: string },
+						worker: { [key: string]: string }
+					}
+				},
+				version: string // "12"
+			},
+			scale: {
+				shards: number, // 1 (shards was renamed to workers, kept here for backwards compatibility)
+				workers: number // 1
+			},
+			scheduling: { // If no roles are specified, settings will apply to all nodes of the PostgreSQL Hyperscale server group.
+				default: {
+					resources: {
+						requests: SchedulingOptions,
+						limits: SchedulingOptions
+					}
+				},
+				roles: {
+					coordinator: {
+						resources: {
+							requests: SchedulingOptions,
+							limits: SchedulingOptions
+						}
+					},
+					worker: {
+						resources: {
+							requests: SchedulingOptions,
+							limits: SchedulingOptions
+						}
+					}
+				}
+			},
+			services: {
+				primary: ServiceSpec
+			},
+			storage: {
+				data: {
+					volumes: StorageVolume[]
+				},
+				logs: {
+					volumes: StorageVolume[]
+				},
+				backups: {
+					volumes: StorageVolume[]
+				}
+			}
+		},
+		status: {
+			primaryEndpoint: string, // "10.130.12.136:26630"
+			readyPods: string, // "1/1",
+			state: string, // "Ready"
+			logSearchDashboard: string, // https://127.0.0.1:30777/kibana/app/kibana#/discover?_a=(query:(language:kuery,query:'custom_resource_name:pg1'))
+			metricsDashboard: string, // https://127.0.0.1:30777/grafana/d/40q72HnGk/sql-managed-instance-metrics?var-hostname=pg1
+			podsStatus: {
+				conditions: {
+					lastTransitionTime: string, // "2020-08-19T17:05:39Z"
+					message?: string, // "containers with unready status: [fluentbit postgres telegraf]"
+					reason?: string, // "ContainersNotReady"
+					status: string, // "True"
+					type: string // "Ready"
+				}[],
+				name: string, // "pg-instancew-0",
+				role: string // "worker"
+			}[]
+		}
+	}
+
+	export interface AzdataOutput<R> {
+		logs: string[],
+		result: R,
+		stderr: string[],
+		stdout: string[],
+		code?: number
+	}
+
+	export interface EndpointOrNamespace {
+		endpoint?: string,
+		namespace?: string
+	}
+	export interface IAzdataApi {
+		arc: {
+			dc: {
+				create(namespace: string, name: string, connectivityMode: string, resourceGroup: string, location: string, subscription: string, profileName?: string, storageClass?: string, additionalEnvVars?: AdditionalEnvVars, azdataContext?: string): Promise<AzdataOutput<void>>,
+				endpoint: {
+					list(additionalEnvVars?: AdditionalEnvVars, azdataContext?: string): Promise<AzdataOutput<DcEndpointListResult[]>>
+				},
+				config: {
+					list(additionalEnvVars?: AdditionalEnvVars, azdataContext?: string): Promise<AzdataOutput<DcConfigListResult[]>>,
+					show(additionalEnvVars?: AdditionalEnvVars, azdataContext?: string): Promise<AzdataOutput<DcConfigShowResult>>
+				}
+			},
+			postgres: {
+				server: {
+					delete(name: string, additionalEnvVars?: AdditionalEnvVars, azdataContext?: string): Promise<AzdataOutput<void>>,
+					list(additionalEnvVars?: AdditionalEnvVars, azdataContext?: string): Promise<AzdataOutput<PostgresServerListResult[]>>,
+					show(name: string, additionalEnvVars?: AdditionalEnvVars, azdataContext?: string): Promise<AzdataOutput<PostgresServerShowResult>>,
+					edit(
+						name: string,
+						args: {
+							adminPassword?: boolean,
+							coresLimit?: string,
+							coresRequest?: string,
+							coordinatorEngineSettings?: string,
+							engineSettings?: string,
+							extensions?: string,
+							memoryLimit?: string,
+							memoryRequest?: string,
+							noWait?: boolean,
+							port?: number,
+							replaceEngineSettings?: boolean,
+							workerEngineSettings?: string,
+							workers?: number
+						},
+						additionalEnvVars?: AdditionalEnvVars,
+						azdataContext?: string
+					): Promise<AzdataOutput<void>>
+				}
+			},
+			sql: {
+				mi: {
+					delete(name: string, additionalEnvVars?: AdditionalEnvVars, azdataContext?: string): Promise<AzdataOutput<void>>,
+					list(additionalEnvVars?: AdditionalEnvVars, azdataContext?: string): Promise<AzdataOutput<SqlMiListResult[]>>,
+					show(name: string, additionalEnvVars?: AdditionalEnvVars, azdataContext?: string): Promise<AzdataOutput<SqlMiShowResult>>,
+					edit(
+						name: string,
+						args: {
+							coresLimit?: string,
+							coresRequest?: string,
+							memoryLimit?: string,
+							memoryRequest?: string,
+							noWait?: boolean,
+						},
+						additionalEnvVars?: AdditionalEnvVars,
+						azdataContext?: string
+					): Promise<AzdataOutput<void>>
+				}
+			}
+		},
+		getPath(): Promise<string>,
+		login(endpointOrNamespace: EndpointOrNamespace, username: string, password: string, additionalEnvVars?: AdditionalEnvVars, azdataContext?: string): Promise<AzdataOutput<void>>,
+		/**
+		 * The semVersion corresponding to this installation of azdata. version() method should have been run
+		 * before fetching this value to ensure that correct value is returned. This is almost always correct unless
+		 * Azdata has gotten reinstalled in the background after this IAzdataApi object was constructed.
+		 */
+		getSemVersion(): Promise<SemVer>,
+		version(): Promise<AzdataOutput<string>>
+	}
+
+	export interface IExtension {
+		azdata: IAzdataApi;
+
+		/**
+		 * returns true if AZDATA CLI EULA has been previously accepted by the user.
+		 */
+		isEulaAccepted(): Promise<boolean>;
+
+		/**
+		 * Prompts user to accept EULA. Stores and returns the user response to EULA prompt.
+		 * @param requireUserAction - if the prompt is required to be acted upon by the user. This is typically 'true' when this method is called to address an Error when the EULA needs to be accepted to proceed.
+		 *
+		 * pre-requisite, the calling code has to ensure that the EULA has not yet been previously accepted by the user. The code can use @see isEulaAccepted() call to ascertain this.
+		 * returns true if the user accepted the EULA.
+		 */
+		promptForEula(requireUserAction?: boolean): Promise<boolean>;
+
+	}
+}

extensions/azcli/src/typings/refs.d.ts

@@ -0,0 +1,9 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+/// <reference path='../../../../src/sql/azdata.d.ts'/>
+/// <reference path='../../../../src/sql/azdata.proposed.d.ts'/>
+/// <reference path='../../../../src/vs/vscode.d.ts'/>
+/// <reference path='../../../resource-deployment/src/typings/resource-deployment.d.ts'/>

extensions/azcli/tsconfig.json

@@ -0,0 +1,14 @@
+{
+	"extends": "../tsconfig.base.json",
+	"compileOnSave": true,
+	"compilerOptions": {
+		"outDir": "./out",
+		"lib": [
+			"es6",
+			"es2015.promise"
+		]
+	},
+	"include": [
+		"src/**/*"
+	]
+}