Refact/idea lastknown (#501)

* close

* connection is working

* formatting

* adds all

* formatting

* removed unneeded logging

* readd npm shrinkwrap

* addressed comments

* fix capabilities cacheing

* updated shrinkwrap

* fixed tests

* remove dead code

* vbump sqltools

src/sql/parts/connection/common/connectionManagement.ts

@@ -136,7 +136,7 @@ export interface IConnectionManagementService {
 
 	clearRecentConnectionsList(): void;
 
-	clearRecentConnection(connectionProfile: IConnectionProfile) : void;
+	clearRecentConnection(connectionProfile: IConnectionProfile): void;
 
 	getActiveConnections(): ConnectionProfile[];
 
@@ -278,24 +278,6 @@ export interface IErrorMessageService {
 	showDialog(severity: Severity, headerTitle: string, message: string, messageDetails?: string, actions?: IAction[]): void;
 }
 
-export enum ServiceOptionType {
-	string = 0,
-	multistring = 1,
-	password = 2,
-	number = 3,
-	category = 4,
-	boolean = 5
-}
-
-export enum ConnectionOptionSpecialType {
-	serverName = 0,
-	databaseName = 1,
-	authType = 2,
-	userName = 3,
-	password = 4,
-	appName = 5
-}
-
 export enum RunQueryOnConnectionMode {
 	none = 0,
 	executeQuery = 1,

src/sql/parts/connection/common/connectionStore.ts

@@ -52,6 +52,11 @@ export class ConnectionStore {
 			this._connectionConfig = new ConnectionConfig(this._configurationEditService,
 				this._workspaceConfigurationService, this._capabilitiesService, cachedServerCapabilities);
 		}
+		if (_capabilitiesService) {
+			_capabilitiesService.onProviderRegisteredEvent(e => {
+				this.saveCachedServerCapabilities();
+			});
+		}
 	}
 
 	public static get CRED_PREFIX(): string { return 'Microsoft.SqlTools'; }

src/sql/parts/connection/common/providerConnectionInfo.ts

@@ -7,7 +7,7 @@
 
 import data = require('data');
 import * as interfaces from 'sql/parts/connection/common/interfaces';
-import { ConnectionOptionSpecialType, ServiceOptionType } from 'sql/parts/connection/common/connectionManagement';
+import { ConnectionOptionSpecialType, ServiceOptionType } from 'sql/workbench/api/common/sqlExtHostTypes';
 import * as Constants from 'sql/parts/connection/common/constants';
 
 export class ProviderConnectionInfo implements data.ConnectionInfo {
@@ -114,7 +114,7 @@ export class ProviderConnectionInfo implements data.ConnectionInfo {
 		return isPasswordRequired;
 	}
 
-	private getSpecialTypeOptionValue(type: number): string {
+	private getSpecialTypeOptionValue(type: string): string {
 		let name = this.getSpecialTypeOptionName(type);
 		if (name) {
 			return this.options[name];
@@ -172,7 +172,7 @@ export class ProviderConnectionInfo implements data.ConnectionInfo {
 		return providerId;
 	}
 
-	public getSpecialTypeOptionName(type: number): string {
+	public getSpecialTypeOptionName(type: string): string {
 		if (this._serverCapabilities) {
 			let optionMetadata = this._serverCapabilities.connectionProvider.options.find(o => o.specialValueType === type);
 			return !!optionMetadata ? optionMetadata.name : undefined;
@@ -181,7 +181,7 @@ export class ProviderConnectionInfo implements data.ConnectionInfo {
 		}
 	}
 
-	public setSpecialTypeOptionName(type: number, value: string): void {
+	public setSpecialTypeOptionName(type: string, value: string): void {
 		let name = this.getSpecialTypeOptionName(type);
 		if (!!name) {
 			this.options[name] = value;
@@ -238,4 +238,3 @@ export class ProviderConnectionInfo implements data.ConnectionInfo {
 		return parts;
 	}
 }
-

src/sql/parts/connection/connectionDialog/connectionController.ts

@@ -5,7 +5,7 @@
 
 'use strict';
 
-import { IConnectionManagementService, ConnectionOptionSpecialType } from 'sql/parts/connection/common/connectionManagement';
+import { IConnectionManagementService } from 'sql/parts/connection/common/connectionManagement';
 import { IConnectionComponentCallbacks, IConnectionComponentController, IConnectionValidateResult } from 'sql/parts/connection/connectionDialog/connectionDialogService';
 import { ConnectionWidget } from 'sql/parts/connection/connectionDialog/connectionWidget';
 import { AdvancedPropertiesController } from 'sql/parts/connection/connectionDialog/advancedPropertiesController';
@@ -15,6 +15,7 @@ import * as Constants from 'sql/parts/connection/common/constants';
 import data = require('data');
 import * as Utils from 'sql/parts/connection/common/utils';
 import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
+import { ConnectionOptionSpecialType } from 'sql/workbench/api/common/sqlExtHostTypes';
 
 export class ConnectionController implements IConnectionComponentController {
 	private _container: HTMLElement;

src/sql/parts/connection/connectionDialog/connectionDialogWidget.ts

@@ -291,8 +291,7 @@ export class ConnectionDialogWidget extends Modal {
 							this.onConnectionClick({ payload: { origin: origin, originalEvent: eventish } }, element);
 						}
 					};
-					let actionProvider = this._instantiationService.createInstance(RecentConnectionActionsProvider, this._instantiationService, this._connectionManagementService,
-						this._messageService);
+					let actionProvider = this._instantiationService.createInstance(RecentConnectionActionsProvider);
 					let controller = new RecentConnectionTreeController(leftClick, actionProvider, this._connectionManagementService, this._contextMenuService);
 					actionProvider.onRecentConnectionRemoved(() => {
 						this.open(this._connectionManagementService.getRecentConnections().length > 0);

src/sql/parts/connection/connectionDialog/connectionWidget.ts

@@ -16,7 +16,7 @@ import * as DialogHelper from 'sql/base/browser/ui/modal/dialogHelper';
 import { IConnectionComponentCallbacks } from 'sql/parts/connection/connectionDialog/connectionDialogService';
 import * as lifecycle from 'vs/base/common/lifecycle';
 import { IConnectionProfile } from 'sql/parts/connection/common/interfaces';
-import { ConnectionOptionSpecialType } from 'sql/parts/connection/common/connectionManagement';
+import { ConnectionOptionSpecialType } from 'sql/workbench/api/common/sqlExtHostTypes';
 import * as Constants from 'sql/parts/connection/common/constants';
 import { ConnectionProfileGroup, IConnectionProfileGroup } from 'sql/parts/connection/common/connectionProfileGroup';
 import { IThemeService } from 'vs/platform/theme/common/themeService';
@@ -87,7 +87,7 @@ export class ConnectionWidget {
 		}
 
 		var authTypeOption = this._optionsMaps[ConnectionOptionSpecialType.authType];
-		if(authTypeOption) {
+		if (authTypeOption) {
 			if (OS === OperatingSystem.Windows) {
 				authTypeOption.defaultValue = this.getAuthTypeDisplayName(Constants.integrated);
 			} else {
@@ -250,11 +250,11 @@ export class ConnectionWidget {
 		}
 	}
 
-	private setConnectButton() : void {
+	private setConnectButton(): void {
 		let authDisplayName: string = this.getAuthTypeDisplayName(this.authenticationType);
 		let authType: AuthenticationType = this.getMatchingAuthType(authDisplayName);
 		let showUsernameAndPassword: boolean = true;
-		if(authType) {
+		if (authType) {
 			showUsernameAndPassword = authType.showUsernameAndPassword;
 		}
 		showUsernameAndPassword ? this._callbacks.onSetConnectButton(!!this.serverName && !!this.userName) :
@@ -366,7 +366,7 @@ export class ConnectionWidget {
 		var displayName: string;
 		var authTypeOption = this._optionsMaps[ConnectionOptionSpecialType.authType];
 
-		if(authTypeOption) {
+		if (authTypeOption) {
 			authTypeOption.categoryValues.forEach(c => {
 				if (c.name === authTypeName) {
 					displayName = c.displayName;

src/sql/parts/disasterRecovery/backup/backup.component.ts

@@ -17,7 +17,7 @@ import { SplitView } from 'sql/base/browser/ui/splitview/splitview';
 import { attachButtonStyler, attachListBoxStyler, attachInputBoxStyler, attachSelectBoxStyler } from 'sql/common/theme/styler';
 import { IConnectionProfile } from 'sql/parts/connection/common/interfaces';
 import * as BackupConstants from 'sql/parts/disasterRecovery/backup/constants';
-import { IDisasterRecoveryService, IDisasterRecoveryUiService, TaskExecutionMode } from 'sql/parts/disasterRecovery/common/interfaces';
+import { IBackupService, IBackupUiService, TaskExecutionMode } from 'sql/parts/disasterRecovery/backup/common/backupService';
 import FileValidationConstants = require('sql/parts/fileBrowser/common/fileValidationServiceConstants');
 import { DashboardComponentParams } from 'sql/services/bootstrap/bootstrapParams';
 import { IBootstrapService, BOOTSTRAP_SERVICE_ID } from 'sql/services/bootstrap/bootstrapService';
@@ -140,8 +140,8 @@ export class BackupComponent {
 
 	// tslint:enable:no-unused-variable
 
-	private _disasterRecoveryService: IDisasterRecoveryService;
-	private _disasterRecoveryUiService: IDisasterRecoveryUiService;
+	private _backupService: IBackupService;
+	private _backupUiService: IBackupUiService;
 	private _uri: string;
 	private _toDispose: lifecycle.IDisposable[] = [];
 	private _advancedHeaderSize = 32;
@@ -198,9 +198,9 @@ export class BackupComponent {
 		@Inject(forwardRef(() => ChangeDetectorRef)) private _changeDetectorRef: ChangeDetectorRef,
 		@Inject(BOOTSTRAP_SERVICE_ID) private _bootstrapService: IBootstrapService,
 	) {
-		this._disasterRecoveryService = _bootstrapService.disasterRecoveryService;
-		this._disasterRecoveryUiService = _bootstrapService.disasterRecoveryUiService;
-		this._disasterRecoveryUiService.onShowBackupEvent((param) => this.onGetBackupConfigInfo(param));
+		this._backupService = _bootstrapService.backupService;
+		this._backupUiService = _bootstrapService.backupUiService;
+		this._backupUiService.onShowBackupEvent((param) => this.onGetBackupConfigInfo(param));
 	}
 
 	ngOnInit() {
@@ -315,12 +315,12 @@ export class BackupComponent {
 	ngAfterViewInit() {
 		// Set category view for advanced options. This should be defined in ngAfterViewInit so that it correctly calculates the text height after data binding.
 		var splitview = new SplitView(this.advancedOptionElement.nativeElement);
-		var advancedBodySize =  DOM.getTotalHeight(this.advancedOptionBodyElement.nativeElement);
+		var advancedBodySize = DOM.getTotalHeight(this.advancedOptionBodyElement.nativeElement);
 		var categoryView = new CategoryView(this.advancedConfigurationLabel, this.advancedOptionBodyElement.nativeElement, true, advancedBodySize, this._advancedHeaderSize);
 		splitview.addView(categoryView);
 		splitview.layout(advancedBodySize + this._advancedHeaderSize);
 
-		this._disasterRecoveryUiService.onShowBackupDialog();
+		this._backupUiService.onShowBackupDialog();
 	}
 
 	private onGetBackupConfigInfo(param: DashboardComponentParams) {
@@ -336,7 +336,7 @@ export class BackupComponent {
 		this._uri = param.ownerUri;
 
 		// Get backup configuration info
-		this._disasterRecoveryService.getBackupConfigInfo(this._uri).then(configInfo => {
+		this._backupService.getBackupConfigInfo(this._uri).then(configInfo => {
 			if (configInfo) {
 				this.defaultNewBackupFolder = configInfo.defaultBackupFolder;
 				this.recoveryModel = configInfo.recoveryModel;
@@ -546,12 +546,12 @@ export class BackupComponent {
 	* UI event handlers
 	*/
 	private onScript(): void {
-		this._disasterRecoveryService.backup(this._uri, this.createBackupInfo(), TaskExecutionMode.script);
+		this._backupService.backup(this._uri, this.createBackupInfo(), TaskExecutionMode.script);
 		this.close();
 	}
 
 	private onOk(): void {
-		this._disasterRecoveryService.backup(this._uri, this.createBackupInfo(), TaskExecutionMode.executeAndScript);
+		this._backupService.backup(this._uri, this.createBackupInfo(), TaskExecutionMode.executeAndScript);
 		this.close();
 	}
 
@@ -561,7 +561,7 @@ export class BackupComponent {
 	}
 
 	private close(): void {
-		this._disasterRecoveryUiService.closeBackup();
+		this._backupUiService.closeBackup();
 		this.resetDialog();
 	}
 

src/sql/parts/disasterRecovery/backup/common/backupService.ts

@@ -5,7 +5,6 @@
 
 'use strict';
 
-import { TPromise } from 'vs/base/common/winjs.base';
 import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
 import Event from 'vs/base/common/event';
 import data = require('data');
@@ -20,12 +19,12 @@ export enum TaskExecutionMode {
 	executeAndScript = 2,
 }
 
-export const SERVICE_ID = 'disasterRecoveryService';
-export const UI_SERVICE_ID = 'disasterRecoveryUiService';
+export const SERVICE_ID = 'backupService';
+export const UI_SERVICE_ID = 'backupUiService';
 
-export const IDisasterRecoveryUiService = createDecorator<IDisasterRecoveryUiService>(UI_SERVICE_ID);
+export const IBackupUiService = createDecorator<IBackupUiService>(UI_SERVICE_ID);
 
-export interface IDisasterRecoveryUiService {
+export interface IBackupUiService {
 	_serviceBrand: any;
 
 	/**
@@ -49,9 +48,9 @@ export interface IDisasterRecoveryUiService {
 	onShowBackupDialog();
 }
 
-export const IDisasterRecoveryService = createDecorator<IDisasterRecoveryService>(SERVICE_ID);
+export const IBackupService = createDecorator<IBackupService>(SERVICE_ID);
 
-export interface IDisasterRecoveryService {
+export interface IBackupService {
 	_serviceBrand: any;
 
 	getBackupConfigInfo(connectionUri: string): Thenable<data.BackupConfigInfo>;
@@ -64,31 +63,5 @@ export interface IDisasterRecoveryService {
 	/**
 	 * Register a disaster recovery provider
 	 */
-	registerProvider(providerId: string, provider: data.DisasterRecoveryProvider): void;
-
-	/**
-	 * Restore a data source using a backup file or database
-	 */
-	restore(connectionUri: string, restoreInfo: data.RestoreInfo): Thenable<data.RestoreResponse>;
-
-	/**
-	 * Gets restore plan to do the restore operation on a database
-	 */
-	getRestorePlan(connectionUri: string, restoreInfo: data.RestoreInfo): Thenable<data.RestorePlanResponse>;
-
-	/**
-	 * Gets restore config Info
-	 */
-	getRestoreConfigInfo(connectionUri: string): Thenable<data.RestoreConfigInfo>;
-
-	/**
-	 * Cancel restore plan
-	 */
-	cancelRestorePlan(connectionUri: string, restoreInfo: data.RestoreInfo): Thenable<boolean>;
+	registerProvider(providerId: string, provider: data.BackupProvider): void;
 }
-
-export const IRestoreDialogController = createDecorator<IRestoreDialogController>('restoreDialogService');
-export interface IRestoreDialogController {
-	_serviceBrand: any;
-	showDialog(connection: IConnectionProfile): TPromise<void>;
-}

src/sql/parts/disasterRecovery/backup/common/backupServiceImp.ts

@@ -4,25 +4,87 @@
  *--------------------------------------------------------------------------------------------*/
 
 'use strict';
-
-import { TPromise } from 'vs/base/common/winjs.base';
+import { IConnectionManagementService } from 'sql/parts/connection/common/connectionManagement';
+import * as data from 'data';
+import * as Constants from 'sql/common/constants';
+import * as TelemetryKeys from 'sql/common/telemetryKeys';
+import * as TelemetryUtils from 'sql/common/telemetryUtilities';
+import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
+import { IBackupService, TaskExecutionMode, IBackupUiService } from 'sql/parts/disasterRecovery/backup/common/backupService';
+import { BackupDialog } from 'sql/parts/disasterRecovery/backup/backupDialog';
+import { OptionsDialog } from 'sql/base/browser/ui/modal/optionsDialog';
 import Event, { Emitter } from 'vs/base/common/event';
+import { DashboardComponentParams } from 'sql/services/bootstrap/bootstrapParams';
 import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
 import { IPartService } from 'vs/workbench/services/part/common/partService';
-import * as data from 'data';
-
 import { ICapabilitiesService } from 'sql/services/capabilities/capabilitiesService';
 import { IConnectionProfile } from 'sql/parts/connection/common/interfaces';
-import { OptionsDialog } from 'sql/base/browser/ui/modal/optionsDialog';
-import { BackupDialog } from 'sql/parts/disasterRecovery/backup/backupDialog';
-import { IDisasterRecoveryService, IDisasterRecoveryUiService, TaskExecutionMode } from 'sql/parts/disasterRecovery/common/interfaces';
-import { IConnectionManagementService } from 'sql/parts/connection/common/connectionManagement';
-import ConnectionUtils = require('sql/parts/connection/common/utils');
+import { TPromise } from 'vs/base/common/winjs.base';
+import * as ConnectionUtils from 'sql/parts/connection/common/utils';
 import { ProviderConnectionInfo } from 'sql/parts/connection/common/providerConnectionInfo';
-import { DashboardComponentParams } from 'sql/services/bootstrap/bootstrapParams';
-import * as Utils from 'sql/parts/connection/common/utils';
 
-export class DisasterRecoveryUiService implements IDisasterRecoveryUiService {
+export class BackupService implements IBackupService {
+
+	public _serviceBrand: any;
+	private _providers: { [handle: string]: data.BackupProvider; } = Object.create(null);
+
+	constructor(
+		@IConnectionManagementService private _connectionService: IConnectionManagementService,
+		@ITelemetryService private _telemetryService: ITelemetryService
+	) {
+	}
+
+	/**
+	 * Get database metadata needed to populate backup UI
+	 */
+	public getBackupConfigInfo(connectionUri: string): Thenable<data.BackupConfigInfo> {
+		let providerId: string = this._connectionService.getProviderIdFromUri(connectionUri);
+		if (providerId) {
+			let provider = this._providers[providerId];
+			if (provider) {
+				return provider.getBackupConfigInfo(connectionUri);
+			}
+		}
+		return Promise.resolve(undefined);
+	}
+
+	/**
+	 * Backup a data source using the provided connection
+	 */
+	public backup(connectionUri: string, backupInfo: { [key: string]: any }, taskExecutionMode: TaskExecutionMode): Thenable<data.BackupResponse> {
+		return new Promise<data.BackupResponse>((resolve, reject) => {
+			let providerResult = this.getProvider(connectionUri);
+			if (providerResult) {
+				TelemetryUtils.addTelemetry(this._telemetryService, TelemetryKeys.BackupCreated, { provider: providerResult.providerName });
+				providerResult.provider.backup(connectionUri, backupInfo, taskExecutionMode).then(result => {
+					resolve(result);
+				}, error => {
+					reject(error);
+				});
+			} else {
+				reject(Constants.InvalidProvider);
+			}
+		});
+	}
+
+	private getProvider(connectionUri: string): { provider: data.BackupProvider, providerName: string } {
+		let providerId: string = this._connectionService.getProviderIdFromUri(connectionUri);
+		if (providerId) {
+			return { provider: this._providers[providerId], providerName: providerId };
+		} else {
+			return undefined;
+		}
+	}
+
+	/**
+	 * Register a disaster recovery provider
+	 */
+	public registerProvider(providerId: string, provider: data.BackupProvider): void {
+		this._providers[providerId] = provider;
+	}
+}
+
+export class BackupUiService implements IBackupUiService {
 	public _serviceBrand: any;
 	private _backupDialogs: { [providerName: string]: BackupDialog | OptionsDialog } = {};
 	private _currentProvider: string;
@@ -37,10 +99,10 @@ export class DisasterRecoveryUiService implements IDisasterRecoveryUiService {
 	constructor( @IInstantiationService private _instantiationService: IInstantiationService,
 		@IPartService private _partService: IPartService,
 		@ICapabilitiesService private _capabilitiesService: ICapabilitiesService,
-		@IDisasterRecoveryService private _disasterRecoveryService: IDisasterRecoveryService,
+		@IBackupService private _disasterRecoveryService: IBackupService,
 		@IConnectionManagementService private _connectionManagementService: IConnectionManagementService) {
-			this._onShowBackupEvent = new Emitter<DashboardComponentParams>();
-		}
+		this._onShowBackupEvent = new Emitter<DashboardComponentParams>();
+	}
 
 	public showBackup(connection: IConnectionProfile): Promise<any> {
 		let self = this;
@@ -86,16 +148,16 @@ export class DisasterRecoveryUiService implements IDisasterRecoveryUiService {
 			} else {
 				let uri = this._connectionManagementService.getConnectionId(connection)
 					+ ProviderConnectionInfo.idSeparator
-					+ Utils.ConnectionUriBackupIdAttributeName
+					+ ConnectionUtils.ConnectionUriBackupIdAttributeName
 					+ ProviderConnectionInfo.nameValueSeparator
-					+ DisasterRecoveryUiService._connectionUniqueId;
+					+ BackupUiService._connectionUniqueId;
 
-				DisasterRecoveryUiService._connectionUniqueId++;
+				BackupUiService._connectionUniqueId++;
 
 				// Create connection if needed
 				if (!this._connectionManagementService.isConnected(uri)) {
 					this._connectionManagementService.connect(connection, uri).then(() => {
-						this._onShowBackupEvent.fire({connection: connection, ownerUri: uri});
+						this._onShowBackupEvent.fire({ connection: connection, ownerUri: uri });
 					});
 				}
 				(backupDialog as BackupDialog).open(connection);

src/sql/parts/disasterRecovery/common/disasterRecoveryService.ts

@@ -1,149 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the Source EULA. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-'use strict';
-import { IConnectionManagementService } from 'sql/parts/connection/common/connectionManagement';
-import data = require('data');
-import { IDisasterRecoveryService, TaskExecutionMode } from 'sql/parts/disasterRecovery/common/interfaces';
-import * as Constants from 'sql/common/constants';
-import * as TelemetryKeys from 'sql/common/telemetryKeys';
-import * as TelemetryUtils from 'sql/common/telemetryUtilities';
-import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
-
-export class DisasterRecoveryService implements IDisasterRecoveryService {
-
-	public _serviceBrand: any;
-	private _providers: { [handle: string]: data.DisasterRecoveryProvider; } = Object.create(null);
-
-	constructor(
-		@IConnectionManagementService private _connectionService: IConnectionManagementService,
-		@ITelemetryService private _telemetryService: ITelemetryService
-	) {
-	}
-
-	/**
-	 * Get database metadata needed to populate backup UI
-	 */
-	public getBackupConfigInfo(connectionUri: string): Thenable<data.BackupConfigInfo> {
-		let providerId: string = this._connectionService.getProviderIdFromUri(connectionUri);
-		if (providerId) {
-			let provider = this._providers[providerId];
-			if (provider) {
-				return provider.getBackupConfigInfo(connectionUri);
-			}
-		}
-		return Promise.resolve(undefined);
-	}
-
-	/**
-	 * Backup a data source using the provided connection
-	 */
-	public backup(connectionUri: string, backupInfo: { [key: string]: any }, taskExecutionMode: TaskExecutionMode): Thenable<data.BackupResponse> {
-		return new Promise<data.BackupResponse>((resolve, reject) => {
-			let providerResult = this.getProvider(connectionUri);
-			if (providerResult) {
-				TelemetryUtils.addTelemetry(this._telemetryService, TelemetryKeys.BackupCreated, { provider: providerResult.providerName });
-				providerResult.provider.backup(connectionUri, backupInfo, taskExecutionMode).then(result => {
-					resolve(result);
-				}, error => {
-					reject(error);
-				});
-			} else {
-				reject(Constants.InvalidProvider);
-			}
-		});
-	}
-
-	/**
-	 * Gets restore config Info
-	 */
-	getRestoreConfigInfo(connectionUri: string): Thenable<data.RestoreConfigInfo> {
-		return new Promise<data.RestoreConfigInfo>((resolve, reject) => {
-			let providerResult = this.getProvider(connectionUri);
-			if (providerResult) {
-				providerResult.provider.getRestoreConfigInfo(connectionUri).then(result => {
-					resolve(result);
-				}, error => {
-					reject(error);
-				});
-			} else {
-				reject(Constants.InvalidProvider);
-			}
-		});
-	}
-
-	/**
-	 * Restore a data source using a backup file or database
-	 */
-	restore(connectionUri: string, restoreInfo: data.RestoreInfo): Thenable<data.RestoreResponse> {
-		return new Promise<data.RestoreResponse>((resolve, reject) => {
-			let providerResult = this.getProvider(connectionUri);
-			if (providerResult) {
-				TelemetryUtils.addTelemetry(this._telemetryService, TelemetryKeys.RestoreRequested, { provider: providerResult.providerName });
-				providerResult.provider.restore(connectionUri, restoreInfo).then(result => {
-					resolve(result);
-				}, error => {
-					reject(error);
-				});
-			} else {
-				reject(Constants.InvalidProvider);
-			}
-		});
-	}
-
-	private getProvider(connectionUri: string): { provider: data.DisasterRecoveryProvider, providerName: string } {
-		let providerId: string = this._connectionService.getProviderIdFromUri(connectionUri);
-		if (providerId) {
-			return { provider: this._providers[providerId], providerName: providerId };
-		} else {
-			return undefined;
-		}
-	}
-
-	/**
-	 * Gets restore plan to do the restore operation on a database
-	 */
-	getRestorePlan(connectionUri: string, restoreInfo: data.RestoreInfo): Thenable<data.RestorePlanResponse> {
-		return new Promise<data.RestorePlanResponse>((resolve, reject) => {
-			let providerResult = this.getProvider(connectionUri);
-			if (providerResult) {
-				providerResult.provider.getRestorePlan(connectionUri, restoreInfo).then(result => {
-					resolve(result);
-				}, error => {
-					reject(error);
-				});
-			} else {
-				reject(Constants.InvalidProvider);
-
-			}
-		});
-	}
-
-	/**
-	 * Cancels a restore plan
-	 */
-	cancelRestorePlan(connectionUri: string, restoreInfo: data.RestoreInfo): Thenable<boolean> {
-		return new Promise<boolean>((resolve, reject) => {
-			let providerResult = this.getProvider(connectionUri);
-			if (providerResult) {
-				providerResult.provider.cancelRestorePlan(connectionUri, restoreInfo).then(result => {
-					resolve(result);
-				}, error => {
-					reject(error);
-				});
-			} else {
-				reject(Constants.InvalidProvider);
-
-			}
-		});
-	}
-
-	/**
-	 * Register a disaster recovery provider
-	 */
-	public registerProvider(providerId: string, provider: data.DisasterRecoveryProvider): void {
-		this._providers[providerId] = provider;
-	}
-}

src/sql/parts/disasterRecovery/restore/common/restoreService.ts

@@ -0,0 +1,51 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import { TPromise } from 'vs/base/common/winjs.base';
+import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
+import * as data from 'data';
+
+import { IConnectionProfile } from 'sql/parts/connection/common/interfaces';
+
+export const SERVICE_ID = 'restoreService';
+export const IRestoreService = createDecorator<IRestoreService>(SERVICE_ID);
+export { TaskExecutionMode } from 'sql/parts/disasterRecovery/backup/common/backupService';
+
+export interface IRestoreService {
+	_serviceBrand: any;
+
+	/**
+	 * Register a disaster recovery provider
+	 */
+	registerProvider(providerId: string, provider: data.RestoreProvider): void;
+
+	/**
+	 * Restore a data source using a backup file or database
+	 */
+	restore(connectionUri: string, restoreInfo: data.RestoreInfo): Thenable<data.RestoreResponse>;
+
+	/**
+	 * Gets restore plan to do the restore operation on a database
+	 */
+	getRestorePlan(connectionUri: string, restoreInfo: data.RestoreInfo): Thenable<data.RestorePlanResponse>;
+
+	/**
+	 * Gets restore config Info
+	 */
+	getRestoreConfigInfo(connectionUri: string): Thenable<data.RestoreConfigInfo>;
+
+	/**
+	 * Cancel restore plan
+	 */
+	cancelRestorePlan(connectionUri: string, restoreInfo: data.RestoreInfo): Thenable<boolean>;
+}
+
+export const IRestoreDialogController = createDecorator<IRestoreDialogController>('restoreDialogService');
+export interface IRestoreDialogController {
+	_serviceBrand: any;
+	showDialog(connection: IConnectionProfile): TPromise<void>;
+}

src/sql/parts/disasterRecovery/restore/common/restoreServiceImpl.ts

@@ -4,21 +4,128 @@
  *--------------------------------------------------------------------------------------------*/
 
 'use strict';
+import { IConnectionManagementService } from 'sql/parts/connection/common/connectionManagement';
+import * as data from 'data';
 import { TPromise } from 'vs/base/common/winjs.base';
+import * as Constants from 'sql/common/constants';
+import * as TelemetryKeys from 'sql/common/telemetryKeys';
+import * as TelemetryUtils from 'sql/common/telemetryUtilities';
+import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
 import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
 import * as types from 'vs/base/common/types';
-
-import { OptionsDialog } from 'sql/base/browser/ui/modal/optionsDialog';
-import { IConnectionProfile } from 'sql/parts/connection/common/interfaces';
-import { IConnectionManagementService } from 'sql/parts/connection/common/connectionManagement';
-import * as ConnectionConstants from 'sql/parts/connection/common/constants';
-import { ProviderConnectionInfo } from 'sql/parts/connection/common/providerConnectionInfo';
-import { IDisasterRecoveryService, IRestoreDialogController, TaskExecutionMode } from 'sql/parts/disasterRecovery/common/interfaces';
-import { MssqlRestoreInfo } from 'sql/parts/disasterRecovery/restore/mssqlRestoreInfo';
-import { RestoreDialog } from 'sql/parts/disasterRecovery/restore/restoreDialog';
 import { ICapabilitiesService } from 'sql/services/capabilities/capabilitiesService';
+import { IRestoreService, IRestoreDialogController, TaskExecutionMode } from 'sql/parts/disasterRecovery/restore/common/restoreService';
+import { OptionsDialog } from 'sql/base/browser/ui/modal/optionsDialog';
+import { RestoreDialog } from 'sql/parts/disasterRecovery/restore/restoreDialog';
+import * as ConnectionConstants from 'sql/parts/connection/common/constants';
+import { MssqlRestoreInfo } from 'sql/parts/disasterRecovery/restore/mssqlRestoreInfo';
+import { IConnectionProfile } from 'sql/parts/connection/common/interfaces';
+import { ProviderConnectionInfo } from 'sql/parts/connection/common/providerConnectionInfo';
 import * as Utils from 'sql/parts/connection/common/utils';
-import * as data from 'data';
+
+export class RestoreService implements IRestoreService {
+
+	public _serviceBrand: any;
+	private _providers: { [handle: string]: data.RestoreProvider; } = Object.create(null);
+
+	constructor(
+		@IConnectionManagementService private _connectionService: IConnectionManagementService,
+		@ITelemetryService private _telemetryService: ITelemetryService
+	) {
+	}
+
+	/**
+	 * Gets restore config Info
+	 */
+	getRestoreConfigInfo(connectionUri: string): Thenable<data.RestoreConfigInfo> {
+		return new Promise<data.RestoreConfigInfo>((resolve, reject) => {
+			let providerResult = this.getProvider(connectionUri);
+			if (providerResult) {
+				providerResult.provider.getRestoreConfigInfo(connectionUri).then(result => {
+					resolve(result);
+				}, error => {
+					reject(error);
+				});
+			} else {
+				reject(Constants.InvalidProvider);
+			}
+		});
+	}
+
+	/**
+	 * Restore a data source using a backup file or database
+	 */
+	restore(connectionUri: string, restoreInfo: data.RestoreInfo): Thenable<data.RestoreResponse> {
+		return new Promise<data.RestoreResponse>((resolve, reject) => {
+			let providerResult = this.getProvider(connectionUri);
+			if (providerResult) {
+				TelemetryUtils.addTelemetry(this._telemetryService, TelemetryKeys.RestoreRequested, { provider: providerResult.providerName });
+				providerResult.provider.restore(connectionUri, restoreInfo).then(result => {
+					resolve(result);
+				}, error => {
+					reject(error);
+				});
+			} else {
+				reject(Constants.InvalidProvider);
+			}
+		});
+	}
+
+	private getProvider(connectionUri: string): { provider: data.RestoreProvider, providerName: string } {
+		let providerId: string = this._connectionService.getProviderIdFromUri(connectionUri);
+		if (providerId) {
+			return { provider: this._providers[providerId], providerName: providerId };
+		} else {
+			return undefined;
+		}
+	}
+
+	/**
+	 * Gets restore plan to do the restore operation on a database
+	 */
+	getRestorePlan(connectionUri: string, restoreInfo: data.RestoreInfo): Thenable<data.RestorePlanResponse> {
+		return new Promise<data.RestorePlanResponse>((resolve, reject) => {
+			let providerResult = this.getProvider(connectionUri);
+			if (providerResult) {
+				providerResult.provider.getRestorePlan(connectionUri, restoreInfo).then(result => {
+					resolve(result);
+				}, error => {
+					reject(error);
+				});
+			} else {
+				reject(Constants.InvalidProvider);
+
+			}
+		});
+	}
+
+	/**
+	 * Cancels a restore plan
+	 */
+	cancelRestorePlan(connectionUri: string, restoreInfo: data.RestoreInfo): Thenable<boolean> {
+		return new Promise<boolean>((resolve, reject) => {
+			let providerResult = this.getProvider(connectionUri);
+			if (providerResult) {
+				providerResult.provider.cancelRestorePlan(connectionUri, restoreInfo).then(result => {
+					resolve(result);
+				}, error => {
+					reject(error);
+				});
+			} else {
+				reject(Constants.InvalidProvider);
+
+			}
+		});
+	}
+
+	/**
+	 * Register a disaster recovery provider
+	 */
+	public registerProvider(providerId: string, provider: data.RestoreProvider): void {
+		this._providers[providerId] = provider;
+	}
+}
+
 
 export class RestoreDialogController implements IRestoreDialogController {
 	_serviceBrand: any;
@@ -32,7 +139,7 @@ export class RestoreDialogController implements IRestoreDialogController {
 
 	constructor(
 		@IInstantiationService private _instantiationService: IInstantiationService,
-		@IDisasterRecoveryService private _disasterRecoveryService: IDisasterRecoveryService,
+		@IRestoreService private _restoreService: IRestoreService,
 		@IConnectionManagementService private _connectionService: IConnectionManagementService,
 		@ICapabilitiesService private _capabilitiesService: ICapabilitiesService
 	) {
@@ -46,14 +153,14 @@ export class RestoreDialogController implements IRestoreDialogController {
 			restoreOption.taskExecutionMode = TaskExecutionMode.executeAndScript;
 		}
 
-		this._disasterRecoveryService.restore(this._ownerUri, restoreOption);
+		this._restoreService.restore(this._ownerUri, restoreOption);
 		let restoreDialog = this._restoreDialogs[this._currentProvider];
 		restoreDialog.close();
 	}
 
 	private handleMssqlOnValidateFile(overwriteTargetDatabase: boolean = false): void {
 		let restoreDialog = this._restoreDialogs[this._currentProvider] as RestoreDialog;
-		this._disasterRecoveryService.getRestorePlan(this._ownerUri, this.setRestoreOption(overwriteTargetDatabase)).then(restorePlanResponse => {
+		this._restoreService.getRestorePlan(this._ownerUri, this.setRestoreOption(overwriteTargetDatabase)).then(restorePlanResponse => {
 			this._sessionId = restorePlanResponse.sessionId;
 
 			if (restorePlanResponse.errorMessage) {
@@ -88,7 +195,7 @@ export class RestoreDialogController implements IRestoreDialogController {
 	private getMssqlRestoreConfigInfo(): Promise<void> {
 		return new Promise<void>((resolve, reject) => {
 			let restoreDialog = this._restoreDialogs[this._currentProvider] as RestoreDialog;
-			this._disasterRecoveryService.getRestoreConfigInfo(this._ownerUri).then(restoreConfigInfo => {
+			this._restoreService.getRestoreConfigInfo(this._ownerUri).then(restoreConfigInfo => {
 				restoreDialog.viewModel.updateOptionWithConfigInfo(restoreConfigInfo.configInfo);
 				resolve();
 			}, error => {
@@ -150,7 +257,7 @@ export class RestoreDialogController implements IRestoreDialogController {
 	private handleOnCancel(): void {
 		let restoreInfo = new MssqlRestoreInfo();
 		restoreInfo.sessionId = this._sessionId;
-		this._disasterRecoveryService.cancelRestorePlan(this._ownerUri, restoreInfo).then(() => {
+		this._restoreService.cancelRestorePlan(this._ownerUri, restoreInfo).then(() => {
 			this._connectionService.disconnect(this._ownerUri);
 		});
 	}

src/sql/parts/disasterRecovery/restore/restoreDialog.ts

@@ -30,7 +30,6 @@ import * as DialogHelper from 'sql/base/browser/ui/modal/dialogHelper';
 import { Modal } from 'sql/base/browser/ui/modal/modal';
 import { attachButtonStyler, attachModalDialogStyler, attachTableStyler, attachInputBoxStyler, attachSelectBoxStyler, attachEditableDropdownStyler } from 'sql/common/theme/styler';
 import * as TelemetryKeys from 'sql/common/telemetryKeys';
-import { ServiceOptionType } from 'sql/parts/connection/common/connectionManagement';
 import * as BackupConstants from 'sql/parts/disasterRecovery/backup/constants';
 import { RestoreViewModel, RestoreOptionParam, SouceDatabaseNamesParam } from 'sql/parts/disasterRecovery/restore/restoreViewModel';
 import * as FileValidationConstants from 'sql/parts/fileBrowser/common/fileValidationServiceConstants';
@@ -40,6 +39,7 @@ import { TabbedPanel, PanelTabIdentifier } from 'sql/base/browser/ui/panel/panel
 import * as DOM from 'vs/base/browser/dom';
 import * as data from 'data';
 import * as strings from 'vs/base/common/strings';
+import { ServiceOptionType } from 'sql/workbench/api/common/sqlExtHostTypes';
 
 interface FileListElement {
 	logicalFileName: string;

src/sql/parts/disasterRecovery/restore/restoreViewModel.ts

@@ -5,11 +5,11 @@
 
 'use strict';
 import * as data from 'data';
-import { ServiceOptionType } from 'sql/parts/connection/common/connectionManagement';
 import * as DialogHelper from 'sql/base/browser/ui/modal/dialogHelper';
 import * as types from 'vs/base/common/types';
 
 import Event, { Emitter } from 'vs/base/common/event';
+import { ServiceOptionType } from 'sql/workbench/api/common/sqlExtHostTypes';
 
 export interface RestoreOptionsElement {
 	optionMetadata: data.ServiceOption;

src/sql/parts/profiler/service/profilerTestBackend.ts

@@ -31,6 +31,7 @@ const columns = [
 ];
 
 export class ProfilerTestBackend implements data.ProfilerProvider {
+	public readonly providerId = 'MSSQL';
 	private index = 0;
 	private timeOutMap = new Map<string, number>();
 	private testData: Array<Array<string>> = new Array<Array<string>>();