CMS fit and finish (#5542)

* cms connections dont save

* added value to enum

* remove refresh and update provider name for cms

* removed ownerUri from saved connection and contributed to array

* removed owneruri

* ownerUri not needed any more

* removed AAD from cms

* initial review

* changed comments

* add back saveProfile option for connectionProfile

* review fixes and other UI improvements

* fixed auth

* added cms integration tests

* added constants

* removed utils from apiwrapper

* changed connection type name

* review comments

* clearer code and addressed reviews
This commit is contained in:
Aditya Bist
2019-05-31 11:14:37 -07:00
committed by GitHub
parent fa52478ffa
commit 1773dede25
27 changed files with 546 additions and 278 deletions

View File

@@ -12,6 +12,8 @@ import * as Utils from './cmsResource/utils';
import { ICmsResourceNodeInfo } from './cmsResource/tree/baseTreeNodes';
const localize = nls.loadMessageBundle();
const cmsProvider: string = 'MSSQL-CMS';
const mssqlProvider: string = 'MSSQL';
/**
* Wrapper class to act as a facade over VSCode and Data APIs and allow us to test / mock callbacks into
@@ -102,11 +104,11 @@ export class ApiWrapper {
* @param resource The optional URI, as a URI object or a string, to use to get resource-scoped configurations
*/
public getConfiguration(): vscode.WorkspaceConfiguration {
return vscode.workspace.getConfiguration('cms');
return vscode.workspace.getConfiguration('centralManagementServers');
}
public async setConfiguration(value: any): Promise<void> {
await vscode.workspace.getConfiguration('cms').update('cmsServers', value, true);
await vscode.workspace.getConfiguration('centralManagementServers').update('servers', value, true);
}
/**
@@ -156,7 +158,7 @@ export class ApiWrapper {
}
public showWarningMessage(message: string, ...items: string[]): Thenable<string | undefined> {
return vscode.window.showWarningMessage(message, ...items);
return vscode.window.showWarningMessage(message, { modal: true }, ...items);
}
public showInformationMessage(message: string, ...items: string[]): Thenable<string | undefined> {
@@ -178,153 +180,4 @@ export class ApiWrapper {
public registerCompletionItemProvider(selector: vscode.DocumentSelector, provider: vscode.CompletionItemProvider, ...triggerCharacters: string[]): vscode.Disposable {
return vscode.languages.registerCompletionItemProvider(selector, provider, ...triggerCharacters);
}
// Connection APIs
public openConnectionDialog(providers: string[], initialConnectionProfile?: azdata.IConnectionProfile, connectionCompletionOptions?: azdata.IConnectionCompletionOptions): Thenable<azdata.connection.Connection> {
return azdata.connection.openConnectionDialog(providers, initialConnectionProfile, connectionCompletionOptions);
}
// CMS APIs
public async getCmsService(): Promise<mssql.CmsService> {
if (!this._cmsService) {
let extensionApi: mssql.MssqlExtensionApi = vscode.extensions.getExtension('Microsoft.mssql').exports;
this._cmsService = await extensionApi.getCmsServiceProvider();
}
return this._cmsService;
}
public async getRegisteredServers(ownerUri: string, relativePath: string): Promise<mssql.ListRegisteredServersResult> {
return this.getCmsService().then((service) => {
return service.getRegisteredServers(ownerUri, relativePath).then((result) => {
if (result && result.registeredServersList && result.registeredServersList) {
return result;
}
});
});
}
public async createCmsServer(connection: azdata.connection.Connection,
name: string, description: string): Promise<mssql.ListRegisteredServersResult> {
let provider = await this.getCmsService();
connection.providerName = connection.providerName === 'MSSQL-CMS' ? 'MSSQL' : connection.providerName;
let ownerUri = await azdata.connection.getUriForConnection(connection.connectionId);
if (!ownerUri) {
// Make a connection if it's not already connected
await azdata.connection.connect(Utils.toConnectionProfile(connection), false, false).then(async (result) => {
ownerUri = await azdata.connection.getUriForConnection(result.connectionId);
});
}
return provider.createCmsServer(name, description, connection, ownerUri).then((result) => {
if (result) {
return result;
}
});
}
public async deleteCmsServer(cmsServer: any) {
let config = this.getConfiguration();
if (config && config.cmsServers) {
let newServers = config.cmsServers.filter((cachedServer) => {
return cachedServer.name !== cmsServer;
});
await this.setConfiguration(newServers);
this._registeredCmsServers = this._registeredCmsServers.filter((cachedServer) => {
return cachedServer.name !== cmsServer;
});
}
}
public cacheRegisteredCmsServer(name: string, description: string, ownerUri: string, connection: azdata.connection.Connection): void {
if (!this._registeredCmsServers) {
this._registeredCmsServers = [];
}
let cmsServerNode: ICmsResourceNodeInfo = {
name: name,
description: description,
ownerUri: ownerUri,
connection: connection
};
this._registeredCmsServers.push(cmsServerNode);
}
public async addRegisteredServer(relativePath: string, ownerUri: string,
parentServerName?: string): Promise<any> {
let provider = await this.getCmsService();
// Initial profile to disallow SQL Login without
// changing provider.
let initialProfile: azdata.IConnectionProfile = {
connectionName: undefined,
serverName: undefined,
databaseName: undefined,
userName: undefined,
password: undefined,
authenticationType: undefined,
savePassword: undefined,
groupFullName: undefined,
groupId: undefined,
providerName: undefined,
saveProfile: undefined,
id: undefined,
options: {
authTypeChanged: true
}
};
return this.openConnectionDialog(['MSSQL-CMS'], initialProfile, undefined).then((connection) => {
if (connection && connection.options) {
if (connection.options.server === parentServerName) {
// error out for same server registration
let errorText = localize('cms.errors.sameServerUnderCms', 'You cannot add a shared registered server with the same name as the Configuration Server');
this.showErrorMessage(errorText);
return;
} else {
return provider.addRegisteredServer(ownerUri, relativePath,
connection.options.registeredServerName, connection.options.registeredServerDescription, connection).then((result) => {
if (result) {
return connection.options.server;
}
});
}
}
});
}
public async removeRegisteredServer(registeredServerName: string, relativePath: string, ownerUri: string): Promise<boolean> {
let provider = await this.getCmsService();
return provider.removeRegisteredServer(ownerUri, relativePath, registeredServerName).then((result) => {
return result;
});
}
public async addServerGroup(groupName: string, groupDescription: string, relativePath: string, ownerUri: string): Promise<boolean> {
let provider = await this.getCmsService();
return provider.addServerGroup(ownerUri, relativePath, groupName, groupDescription).then((result) => {
return result;
});
}
public async removeServerGroup(groupName: string, relativePath: string, ownerUri: string): Promise<boolean> {
let provider = await this.getCmsService();
return provider.removeServerGroup(ownerUri, relativePath, groupName).then((result) => {
return result;
});
}
// Getters
public get registeredCmsServers(): ICmsResourceNodeInfo[] {
return this._registeredCmsServers;
}
public get connection(): Thenable<azdata.connection.Connection> {
return this.openConnectionDialog(['MSSQL-CMS'], undefined, undefined).then((connection) => {
if (connection) {
// remove group ID from connection if a user chose connection
// from the recent connections list
connection.options['groupId'] = null;
connection.providerName = 'MSSQL';
return connection;
}
});
}
}