Update dataprotocol client (#418)

* 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

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

@@ -0,0 +1,67 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 { createDecorator } from 'vs/platform/instantiation/common/instantiation';
+import Event from 'vs/base/common/event';
+import data = require('data');
+
+import { DashboardComponentParams } from 'sql/services/bootstrap/bootstrapParams';
+import { IConnectionProfile } from 'sql/parts/connection/common/interfaces';
+
+
+export enum TaskExecutionMode {
+	execute = 0,
+	script = 1,
+	executeAndScript = 2,
+}
+
+export const SERVICE_ID = 'backupService';
+export const UI_SERVICE_ID = 'backupUiService';
+
+export const IBackupUiService = createDecorator<IBackupUiService>(UI_SERVICE_ID);
+
+export interface IBackupUiService {
+	_serviceBrand: any;
+
+	/**
+	 * Show backup wizard
+	 */
+	showBackup(connection: IConnectionProfile): Promise<any>;
+
+	/**
+	 * On show backup event
+	 */
+	onShowBackupEvent: Event<DashboardComponentParams>;
+
+	/**
+	 * Close backup wizard
+	 */
+	closeBackup();
+
+	/**
+	 * After the backup dialog is rendered, run Modal methods to set focusable elements, etc.
+	 */
+	onShowBackupDialog();
+}
+
+export const IBackupService = createDecorator<IBackupService>(SERVICE_ID);
+
+export interface IBackupService {
+	_serviceBrand: any;
+
+	getBackupConfigInfo(connectionUri: string): Thenable<data.BackupConfigInfo>;
+
+	/**
+	 * Backup a data source using the provided connection
+	 */
+	backup(connectionUri: string, backupInfo: { [key: string]: any }, taskExecutionMode: data.TaskExecutionMode): Thenable<data.BackupResponse>;
+
+	/**
+	 * Register a disaster recovery provider
+	 */
+	registerProvider(providerId: string, provider: data.BackupProvider): void;
+}

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

@@ -0,0 +1,187 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 * 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 { ICapabilitiesService } from 'sql/services/capabilities/capabilitiesService';
+import { IConnectionProfile } from 'sql/parts/connection/common/interfaces';
+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';
+
+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;
+	private _optionsMap: { [providerName: string]: data.ServiceOption[] } = {};
+	private _optionValues: { [optionName: string]: any } = {};
+	private _connectionUri: string;
+	private static _connectionUniqueId: number = 0;
+
+	private _onShowBackupEvent: Emitter<DashboardComponentParams>;
+	public get onShowBackupEvent(): Event<DashboardComponentParams> { return this._onShowBackupEvent.event; }
+
+	constructor( @IInstantiationService private _instantiationService: IInstantiationService,
+		@IPartService private _partService: IPartService,
+		@ICapabilitiesService private _capabilitiesService: ICapabilitiesService,
+		@IBackupService private _disasterRecoveryService: IBackupService,
+		@IConnectionManagementService private _connectionManagementService: IConnectionManagementService) {
+		this._onShowBackupEvent = new Emitter<DashboardComponentParams>();
+	}
+
+	public showBackup(connection: IConnectionProfile): Promise<any> {
+		let self = this;
+		return new Promise<void>((resolve, reject) => {
+			self.showBackupDialog(connection).then(() => {
+				resolve();
+			}, error => {
+				reject();
+			});
+		});
+	}
+
+	public showBackupDialog(connection: IConnectionProfile): TPromise<void> {
+		let self = this;
+		self._connectionUri = ConnectionUtils.generateUri(connection);
+		self._currentProvider = connection.providerName;
+		let backupDialog = self._backupDialogs[self._currentProvider];
+		if (!backupDialog) {
+			let capabilitiesList = this._capabilitiesService.getCapabilities();
+			capabilitiesList.forEach(providerCapabilities => {
+				let backupFeature = providerCapabilities.features.find(feature => feature.featureName === 'backup');
+				if (backupFeature && backupFeature.optionsMetadata) {
+					this._optionsMap[providerCapabilities.providerName] = backupFeature.optionsMetadata;
+				}
+			});
+			let backupOptions = self._optionsMap[self._currentProvider];
+			if (backupOptions) {
+				backupDialog = self._instantiationService ? self._instantiationService.createInstance(
+					OptionsDialog, 'Backup database - ' + connection.serverName + ':' + connection.databaseName, 'BackupOptions', undefined) : undefined;
+				backupDialog.onOk(() => this.handleOptionDialogClosed());
+			}
+			else {
+				backupDialog = self._instantiationService ? self._instantiationService.createInstance(BackupDialog) : undefined;
+			}
+			backupDialog.render();
+			self._backupDialogs[self._currentProvider] = backupDialog;
+		}
+
+		let backupOptions = this._optionsMap[self._currentProvider];
+		return new TPromise<void>(() => {
+			if (backupOptions) {
+				(backupDialog as OptionsDialog).open(backupOptions, self._optionValues);
+			} else {
+				let uri = this._connectionManagementService.getConnectionId(connection)
+					+ ProviderConnectionInfo.idSeparator
+					+ ConnectionUtils.ConnectionUriBackupIdAttributeName
+					+ ProviderConnectionInfo.nameValueSeparator
+					+ BackupUiService._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 });
+					});
+				}
+				(backupDialog as BackupDialog).open(connection);
+			}
+		});
+	}
+
+	public onShowBackupDialog() {
+		let backupDialog = this._backupDialogs[this._currentProvider];
+		if (backupDialog) {
+			backupDialog.setFocusableElements();
+		}
+	}
+
+	public closeBackup() {
+		let self = this;
+		let backupDialog = self._backupDialogs[self._currentProvider];
+		if (backupDialog) {
+			backupDialog.close();
+		}
+	}
+
+	private handleOptionDialogClosed() {
+		this._disasterRecoveryService.backup(this._connectionUri, this._optionValues, TaskExecutionMode.executeAndScript);
+	}
+
+}