CMS Extension - 2 (#4908)

* first set of changes to experiment the registration of cms related apis

* Adding cms service entry to workbench

* Adding basic functionality for add remove reg servers and group

* Returning relative path as part of RegServerResult as string

* initial extension

* cleaned building with connecting to server

* get list of registered servers

* progress with registered servers tree

* cms base node with server selection

* removed unused services

* replaced azure stuff with cms

* removed cmsResourceService

* list servers progress

* Removing the cms apis from core. Having mssql extension expose them for cms extension

* create server working fine

* initial expansion and nodes

* Propogating the backend name changes to apis

* initial cms extension working

* cached connection needs change in api

* connect without dashboard in proposed

* Fixing some missing sqlops references

* add registered server bug found

* added refresh context menu option

* added payload

* server description not disabled after reject connection

* added more context actions and action icons

* added empty resource and error when same name server is added

* fixed connection issues with cms and normal connections

* added initial tests

* added cms icons

* removed azure readme

* test script revert

* fix build tests

* added more cms tests

* fixed test script

* fixed silent error when expanding servers

* added more cms tests

* removed cmsdialog from api

* cms dialog without object

* fixed theming issues

* initial connection dialog done

* can make connections

* PM asks for strings and icons

* removed search

* removed unused code and fixed 1 test

* fix connection management tests

* changed icons

* format file

* fixed hygiene

* initial cr comments

* refactored cms connection dialog

* fixed bug when switching dialogs

* localized connection provider options

* fixed cms provider name

* code review comments

* localized options in cms and mssql

* localized more options
This commit is contained in:
Aditya Bist
2019-04-29 15:16:59 -07:00
committed by GitHub
parent cbf3ca726f
commit 39772c2dbe
60 changed files with 4595 additions and 156 deletions

View File

@@ -0,0 +1,185 @@
/*---------------------------------------------------------------------------------------------
* 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 * as nls from 'vscode-nls';
import * as azdata from 'azdata';
import { AppContext } from '../appContext';
import { TreeNode } from './treeNode';
import { CmsResourceTreeProvider } from './tree/treeProvider';
import { CmsResourceEmptyTreeNode } from './tree/cmsResourceEmptyTreeNode';
import { RegisteredServerTreeNode } from './tree/registeredServerTreeNode';
import { ServerGroupTreeNode } from './tree/serverGroupTreeNode';
import { CmsResourceTreeNode } from './tree/cmsResourceTreeNode';
const localize = nls.loadMessageBundle();
export function registerCmsServerCommand(appContext: AppContext, tree: CmsResourceTreeProvider): void {
// Create a CMS Server
appContext.apiWrapper.registerCommand('cms.resource.registerCmsServer', async (node?: TreeNode) => {
if (node && !(node instanceof CmsResourceEmptyTreeNode)) {
return;
}
await appContext.apiWrapper.connection.then(async (connection) => {
if (connection && connection.options) {
let registeredCmsServerName = connection.options.registeredServerName ?
connection.options.registeredServerName : connection.options.server;
// check if a CMS with the same name is registered or not
let cachedServers = appContext.apiWrapper.registeredCmsServers;
let serverExists: boolean = false;
if (cachedServers) {
serverExists = cachedServers.some((server) => {
return server.name === registeredCmsServerName;
});
}
if (!serverExists) {
// remove any group ID if user selects a connection from
// recent connection list
connection.options.groupId = null;
let registeredCmsServerDescription = connection.options.registeredServerDescription;
// remove server description from connection uri
connection.options.registeredCmsServerDescription = null;
let ownerUri = await azdata.connection.getUriForConnection(connection.connectionId);
appContext.apiWrapper.cacheRegisteredCmsServer(registeredCmsServerName, registeredCmsServerDescription, ownerUri, connection);
tree.notifyNodeChanged(undefined);
} else {
// error out for same server name
let errorText = localize('cms.errors.sameCmsServerName', 'Central Management Server Group already has a Registered Server with the name {0}', registeredCmsServerName);
appContext.apiWrapper.showErrorMessage(errorText);
return;
}
}
});
});
}
export function deleteCmsServerCommand(appContext: AppContext, tree: CmsResourceTreeProvider): void {
// Delete a CMS Server
appContext.apiWrapper.registerCommand('cms.resource.deleteCmsServer', async (node?: TreeNode) => {
if (!(node instanceof CmsResourceTreeNode)) {
return;
}
await appContext.apiWrapper.deleteCmsServer(node.name);
tree.isSystemInitialized = false;
tree.notifyNodeChanged(undefined);
});
}
export function addRegisteredServerCommand(appContext: AppContext, tree: CmsResourceTreeProvider): void {
// Add a registered server
appContext.apiWrapper.registerCommand('cms.resource.addRegisteredServer', async (node?: TreeNode) => {
if (!(node instanceof CmsResourceTreeNode || node instanceof ServerGroupTreeNode)) {
return;
}
let relativePath = node instanceof CmsResourceTreeNode ? '' : node.relativePath;
let serverName = node instanceof CmsResourceTreeNode ? node.connection.options.server : null;
await appContext.apiWrapper.addRegisteredServer(relativePath, node.ownerUri, serverName).then((result) => {
if (result) {
tree.notifyNodeChanged(undefined);
}
});
});
}
export function deleteRegisteredServerCommand(appContext: AppContext, tree: CmsResourceTreeProvider): void {
// Delete a registered server
appContext.apiWrapper.registerCommand('cms.resource.deleteRegisteredServer', async (node?: TreeNode) => {
if (!(node instanceof RegisteredServerTreeNode)) {
return;
}
appContext.apiWrapper.removeRegisteredServer(node.name, node.relativePath, node.ownerUri).then((result) => {
if (result) {
tree.notifyNodeChanged(undefined);
}
});
});
}
export function addServerGroupCommand(appContext: AppContext, tree: CmsResourceTreeProvider): void {
// Add a registered server group
appContext.apiWrapper.registerCommand('cms.resource.addServerGroup', async (node?: TreeNode) => {
if (!(node instanceof ServerGroupTreeNode || node instanceof CmsResourceTreeNode)) {
return;
}
// add a dialog for adding a group
let title = localize('cms.AddServerGroup', 'Add Server Group');
let dialog = azdata.window.createModelViewDialog(title, 'cms.addServerGroup');
dialog.okButton.label = localize('cms.OK', 'OK');
dialog.cancelButton.label = localize('cms.Cancel', 'Cancel');
let mainTab = azdata.window.createTab(title);
let serverGroupName: string = null;
let serverDescription: string = null;
mainTab.registerContent(async view => {
let nameTextBox = view.modelBuilder.inputBox().component();
nameTextBox.required = true;
nameTextBox.onTextChanged((e) => {
serverGroupName = e;
});
if (nameTextBox.value && nameTextBox.value.length > 0) {
dialog.message = null;
}
let descriptionTextBox = view.modelBuilder.inputBox().component();
descriptionTextBox.required = false;
descriptionTextBox.onTextChanged((e) => {
serverDescription = e;
});
let formModel = view.modelBuilder.formContainer()
.withFormItems([{
component: nameTextBox,
title: localize('cms.ServerGroupName', 'Server Group Name')
}, {
component: descriptionTextBox,
title: localize('cms.ServerGroupDescription', 'Server Group Description')
}]).withLayout({ width: '100%' }).component();
await view.initializeModel(formModel);
});
dialog.content = [mainTab];
azdata.window.openDialog(dialog);
let groupExists = false;
dialog.okButton.onClick(() => {
let path = node instanceof ServerGroupTreeNode ? node.relativePath : '';
if (node.serverGroupNodes.some(node => node.name === serverGroupName)) {
groupExists = true;
}
if (!groupExists) {
appContext.apiWrapper.addServerGroup(serverGroupName, serverDescription, path, node.ownerUri).then((result) => {
if (result) {
tree.notifyNodeChanged(undefined);
}
});
} else {
// error out for same server group
let errorText = localize('cms.errors.sameServerGroupName', '{0} already has a Server Group with the name {1}', node.name, serverGroupName);
appContext.apiWrapper.showErrorMessage(errorText);
return;
}
});
});
}
export function deleteServerGroupCommand(appContext: AppContext, tree: CmsResourceTreeProvider): void {
// Remove a registered server group
appContext.apiWrapper.registerCommand('cms.resource.deleteServerGroup', async (node?: TreeNode) => {
if (!(node instanceof ServerGroupTreeNode)) {
return;
}
appContext.apiWrapper.removeServerGroup(node.name, node.relativePath, node.ownerUri).then((result) => {
if (result) {
tree.notifyNodeChanged(undefined);
}
});
});
}
export function refreshCommand(appContext: AppContext, tree: CmsResourceTreeProvider): void {
// Refresh the cms resource
appContext.apiWrapper.registerCommand('cms.resource.refresh', async (node?: TreeNode) => {
if (!node) {
return;
}
tree.notifyNodeChanged(undefined);
});
}