ckaczor/sqltoolsservice
1
0
Fork 0
mirror of https://github.com/ckaczor/sqltoolsservice.git synced 2026-02-16 10:58:30 -05:00
Code Issues Packages Projects Releases Wiki Activity

Added service class for machine learning services operations (#906)

Browse Source 
* Added service class for server configurations and language extension
This commit is contained in:
Leila Lali
2020-01-15 11:21:07 -08:00
committed by GitHub
parent 808e8d1d6f
commit 3626d000fd
14 changed files with 964 additions and 93 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/Microsoft.SqlTools.ServiceLayer/HostLoader.cs
View File

@@ -18,6 +18,8 @@ using Microsoft.SqlTools.ServiceLayer.EditData;
using Microsoft.SqlTools.ServiceLayer.FileBrowser; using Microsoft.SqlTools.ServiceLayer.FileBrowser;
using Microsoft.SqlTools.ServiceLayer.Hosting; using Microsoft.SqlTools.ServiceLayer.Hosting;
using Microsoft.SqlTools.ServiceLayer.LanguageServices; using Microsoft.SqlTools.ServiceLayer.LanguageServices;
using Microsoft.SqlTools.ServiceLayer.ServerConfigurations;
using Microsoft.SqlTools.ServiceLayer.LanguageExtensions;
using Microsoft.SqlTools.ServiceLayer.Metadata; using Microsoft.SqlTools.ServiceLayer.Metadata;
using Microsoft.SqlTools.ServiceLayer.Profiler; using Microsoft.SqlTools.ServiceLayer.Profiler;
using Microsoft.SqlTools.ServiceLayer.QueryExecution; using Microsoft.SqlTools.ServiceLayer.QueryExecution;
@@ -122,6 +124,12 @@ namespace Microsoft.SqlTools.ServiceLayer
SchemaCompare.SchemaCompareService.Instance.InitializeService(serviceHost); SchemaCompare.SchemaCompareService.Instance.InitializeService(serviceHost);
serviceProvider.RegisterSingleService(SchemaCompareService.Instance); serviceProvider.RegisterSingleService(SchemaCompareService.Instance);
ServerConfigService.Instance.InitializeService(serviceHost);
serviceProvider.RegisterSingleService(ServerConfigService.Instance);
LanguageExtensionsService.Instance.InitializeService(serviceHost);
serviceProvider.RegisterSingleService(LanguageExtensionsService.Instance);
InitializeHostedServices(serviceProvider, serviceHost); InitializeHostedServices(serviceProvider, serviceHost);
serviceHost.ServiceProvider = serviceProvider; serviceHost.ServiceProvider = serviceProvider;

43
src/Microsoft.SqlTools.ServiceLayer/LanguageExtensions/Contracts/ExternalLanguageStatusRequest.cs Normal file
View File

@@ -0,0 +1,43 @@
//
// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
//
using Microsoft.SqlTools.Hosting.Protocol.Contracts;
namespace Microsoft.SqlTools.ServiceLayer.LanguageExtensions.Contracts
{
public class ExternalLanguageStatusRequestParams
{
/// <summary>
/// Connection uri
/// </summary>
public string OwnerUri { get; set; }
/// <summary>
/// Language name
/// </summary>
public string LanguageName { get; set; }
}
/// <summary>
/// Response class for external language status
/// </summary>
public class ExternalLanguageStatusResponseParams
{
/// <summary>
/// Language status
/// </summary>
public bool Status { get; set; }
}
/// <summary>
/// Request class for external language status
/// </summary>
public class ExternalLanguageStatusRequest
{
public static readonly
RequestType<ExternalLanguageStatusRequestParams, ExternalLanguageStatusResponseParams> Type =
RequestType<ExternalLanguageStatusRequestParams, ExternalLanguageStatusResponseParams>.Create("languageextension/status");
}
}

51
src/Microsoft.SqlTools.ServiceLayer/LanguageExtensions/LanguageExtensionOperations.cs Normal file
View File

@@ -0,0 +1,51 @@
//
// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
//
using System.Data;
namespace Microsoft.SqlTools.ServiceLayer.LanguageExtensions
{
public class LanguageExtensionOperations
{
private const string LanguageStatusScript = @"SELECT is_installed
FROM sys.dm_db_external_language_stats s, sys.external_languages l
WHERE s.external_language_id = l.external_language_id AND language = @LanguageName";
/// <summary>
/// Returns the status of external languages in a connection
/// </summary>
/// <param name="connection"></param>
/// <param name="languageName"></param>
/// <returns></returns>
public bool GetLanguageStatus(IDbConnection connection, string languageName)
{
bool status = false;
try
{
using (IDbCommand command = connection.CreateCommand())
{
command.CommandText = LanguageStatusScript;
var parameter = command.CreateParameter();
parameter.ParameterName = "@LanguageName";
parameter.Value = languageName;
command.Parameters.Add(parameter);
using (IDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
status = (reader[0].ToString() == "True");
}
}
}
}
catch
{
status = false;
}
return status;
}
}
}

98
src/Microsoft.SqlTools.ServiceLayer/LanguageExtensions/LanguageExtensionsService.cs Normal file
View File

@@ -0,0 +1,98 @@
//
// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
//
using Microsoft.SqlTools.Hosting.Protocol;
using Microsoft.SqlTools.ServiceLayer.Connection;
using Microsoft.SqlTools.ServiceLayer.Hosting;
using Microsoft.SqlTools.ServiceLayer.LanguageExtensions.Contracts;
using Microsoft.SqlTools.Utility;
using System;
using System.Data;
using System.Diagnostics;
using System.Threading.Tasks;
namespace Microsoft.SqlTools.ServiceLayer.LanguageExtensions
{
public class LanguageExtensionsService
{
private LanguageExtensionOperations serviceOperations = new LanguageExtensionOperations();
private ConnectionService connectionService = null;
private static readonly Lazy<LanguageExtensionsService> instance = new Lazy<LanguageExtensionsService>(() => new LanguageExtensionsService());
/// <summary>
/// Gets the singleton instance object
/// </summary>
public static LanguageExtensionsService Instance
{
get { return instance.Value; }
}
/// <summary>
/// Internal for testing purposes only
/// </summary>
internal ConnectionService ConnectionServiceInstance
{
get
{
if (connectionService == null)
{
connectionService = ConnectionService.Instance;
}
return connectionService;
}
set
{
connectionService = value;
}
}
public void InitializeService(ServiceHost serviceHost)
{
serviceHost.SetRequestHandler(ExternalLanguageStatusRequest.Type, this.HandleExternalLanguageStatusRequest);
}
/// <summary>
/// Handles external language status request
/// </summary>
/// <param name="parameters">Request parameters</param>
/// <param name="requestContext">Request Context</param>
/// <returns></returns>
public async Task HandleExternalLanguageStatusRequest(ExternalLanguageStatusRequestParams parameters, RequestContext<ExternalLanguageStatusResponseParams> requestContext)
{
Logger.Write(TraceEventType.Verbose, "HandleExternalLanguageStatusRequest");
try
{
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
ExternalLanguageStatusResponseParams response = new ExternalLanguageStatusResponseParams
{
Status = false,
};
if (connInfo == null)
{
await requestContext.SendError(new Exception(SR.ProfilerConnectionNotFound));
}
else
{
using (IDbConnection dbConnection = ConnectionService.OpenSqlConnection(connInfo))
{
response.Status = serviceOperations.GetLanguageStatus(dbConnection, parameters.LanguageName);
}
await requestContext.SendResult(response);
}
}
catch (Exception e)
{
// Exception related to run task will be captured here
await requestContext.SendError(e);
}
}
}
}

44
src/Microsoft.SqlTools.ServiceLayer/ServerConfigurations/Contracts/ServerConfigListRequest.cs Normal file
View File

@@ -0,0 +1,44 @@
//
// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
//
using Microsoft.SqlTools.Hosting.Protocol.Contracts;
using System.Collections.Generic;
namespace Microsoft.SqlTools.ServiceLayer.ServerConfigurations.Contracts
{
public class ServerConfigListRequestParams
{
/// <summary>
/// Connection uri
/// </summary>
public string OwnerUri { get; set; }
/// <summary>
/// Config Number
/// </summary>
public int ConfigNumber { get; set; }
}
/// <summary>
/// Response class for config list
/// </summary>
public class ServerConfigListResponseParams
{
/// <summary>
/// Config Property
/// </summary>
public List<ServerConfigProperty> ConfigProperties { get; set; }
}
/// <summary>
/// Request class for config list
/// </summary>
public class ServerConfigListRequest
{
public static readonly
RequestType<ServerConfigListRequestParams, ServerConfigListResponseParams> Type =
RequestType<ServerConfigListRequestParams, ServerConfigListResponseParams>.Create("config/List");
}
}

43
src/Microsoft.SqlTools.ServiceLayer/ServerConfigurations/Contracts/ServerConfigProperty.cs Normal file
View File

@@ -0,0 +1,43 @@
//
// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
//
using Microsoft.SqlServer.Management.Smo;
namespace Microsoft.SqlTools.ServiceLayer.ServerConfigurations.Contracts
{
/// <summary>
/// A wrapper for SMO config property
/// </summary>
public class ServerConfigProperty
{
public int Number { get; set; }
public string DisplayName { get; set; }
public string Description { get; set; }
public int ConfigValue { get; set; }
public int Maximum { get; set; }
public int Minimum { get; set; }
public static ServerConfigProperty ToServerConfigProperty(ConfigProperty configProperty)
{
if (configProperty != null)
{
return new ServerConfigProperty
{
Number = configProperty.Number,
DisplayName = configProperty.DisplayName,
ConfigValue = configProperty.ConfigValue,
Maximum = configProperty.Maximum,
Minimum = configProperty.Minimum
};
}
return null;
}
}
}

48
src/Microsoft.SqlTools.ServiceLayer/ServerConfigurations/Contracts/ServerConfigUpdateRequest.cs Normal file
View File

@@ -0,0 +1,48 @@
//
// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
//
using Microsoft.SqlTools.Hosting.Protocol.Contracts;
namespace Microsoft.SqlTools.ServiceLayer.ServerConfigurations.Contracts
{
public class ServerConfigUpdateRequestParams
{
/// <summary>
/// Connection uri
/// </summary>
public string OwnerUri { get; set; }
/// <summary>
/// Config number
/// </summary>
public int ConfigNumber { get; set; }
/// <summary>
/// Config value
/// </summary>
public int ConfigValue { get; set; }
}
/// <summary>
/// Response class for config update
/// </summary>
public class ServerConfigUpdateResponseParams
{
/// <summary>
/// Config Property
/// </summary>
public ServerConfigProperty ConfigProperty { get; set; }
}
/// <summary>
/// Request class for config update
/// </summary>
public class ServerConfigUpdateRequest
{
public static readonly
RequestType<ServerConfigUpdateRequestParams, ServerConfigUpdateResponseParams> Type =
RequestType<ServerConfigUpdateRequestParams, ServerConfigUpdateResponseParams>.Create("config/update");
}
}

43
src/Microsoft.SqlTools.ServiceLayer/ServerConfigurations/Contracts/ServerConfigViewRequest.cs Normal file
View File

@@ -0,0 +1,43 @@
//
// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
//
using Microsoft.SqlTools.Hosting.Protocol.Contracts;
namespace Microsoft.SqlTools.ServiceLayer.ServerConfigurations.Contracts
{
public class ServerConfigViewRequestParams
{
/// <summary>
/// Connection uri
/// </summary>
public string OwnerUri { get; set; }
/// <summary>
/// Config Number
/// </summary>
public int ConfigNumber { get; set; }
}
/// <summary>
/// Response class for config view
/// </summary>
public class ServerConfigViewResponseParams
{
/// <summary>
/// Config Property
/// </summary>
public ServerConfigProperty ConfigProperty { get; set; }
}
/// <summary>
/// Request class for config view
/// </summary>
public class ServerConfigViewRequest
{
public static readonly
RequestType<ServerConfigViewRequestParams, ServerConfigViewResponseParams> Type =
RequestType<ServerConfigViewRequestParams, ServerConfigViewResponseParams>.Create("config/view");
}
}

27
src/Microsoft.SqlTools.ServiceLayer/ServerConfigurations/ServerConfigException.cs Normal file
View File

@@ -0,0 +1,27 @@
//
// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
//
using System;
namespace Microsoft.SqlTools.ServiceLayer.ServerConfigurations
{
/// <summary>
/// Exception raised from machine learning services operations
/// </summary>
public class ServerConfigException : Exception
{
internal ServerConfigException() : base()
{
}
internal ServerConfigException(string m) : base(m)
{
}
internal ServerConfigException(string m, Exception innerException) : base(m, innerException)
{
}
}
}

244
src/Microsoft.SqlTools.ServiceLayer/ServerConfigurations/ServerConfigService.cs Normal file
View File

@@ -0,0 +1,244 @@
//
// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
//
using Microsoft.SqlServer.Management.Common;
using Microsoft.SqlServer.Management.Smo;
using Microsoft.SqlTools.Hosting.Protocol;
using Microsoft.SqlTools.ServiceLayer.Connection;
using Microsoft.SqlTools.ServiceLayer.Hosting;
using Microsoft.SqlTools.ServiceLayer.ServerConfigurations.Contracts;
using Microsoft.SqlTools.Utility;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Threading.Tasks;
namespace Microsoft.SqlTools.ServiceLayer.ServerConfigurations
{
public class ServerConfigService
{
private ConnectionService connectionService = null;
private static readonly Lazy<ServerConfigService> instance = new Lazy<ServerConfigService>(() => new ServerConfigService());
/// <summary>
/// Gets the singleton instance object
/// </summary>
public static ServerConfigService Instance
{
get { return instance.Value; }
}
/// <summary>
/// Internal for testing purposes only
/// </summary>
internal ConnectionService ConnectionServiceInstance
{
get
{
if (connectionService == null)
{
connectionService = ConnectionService.Instance;
}
return connectionService;
}
set
{
connectionService = value;
}
}
public void InitializeService(ServiceHost serviceHost)
{
serviceHost.SetRequestHandler(ServerConfigViewRequest.Type, this.HandleServerConfigViewRequest);
serviceHost.SetRequestHandler(ServerConfigUpdateRequest.Type, this.HandleServerConfigUpdateRequest);
serviceHost.SetRequestHandler(ServerConfigListRequest.Type, this.HandleServerConfigListRequest);
}
/// <summary>
/// Handles config view request
/// </summary>
/// <param name="parameters">Request parameters</param>
/// <param name="requestContext">Request Context</param>
/// <returns></returns>
public async Task HandleServerConfigViewRequest(ServerConfigViewRequestParams parameters, RequestContext<ServerConfigViewResponseParams> requestContext)
{
Logger.Write(TraceEventType.Verbose, "HandleServerConfigViewRequest");
try
{
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
if (connInfo == null)
{
await requestContext.SendError(new Exception(SR.ProfilerConnectionNotFound));
}
else
{
var serverConnection = ConnectionService.OpenServerConnection(connInfo);
ServerConfigProperty serverConfig = GetConfig(serverConnection, parameters.ConfigNumber);
await requestContext.SendResult(new ServerConfigViewResponseParams
{
ConfigProperty = serverConfig
});
}
}
catch (Exception e)
{
// Exception related to run task will be captured here
await requestContext.SendError(e);
}
}
/// <summary>
/// Handles config update request
/// </summary>
/// <param name="parameters">Request parameters</param>
/// <param name="requestContext">Request Context</param>
/// <returns></returns>
public async Task HandleServerConfigUpdateRequest(ServerConfigUpdateRequestParams parameters, RequestContext<ServerConfigUpdateResponseParams> requestContext)
{
Logger.Write(TraceEventType.Verbose, "HandleServerConfigUpdateRequest");
try
{
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
ServerConfigUpdateResponseParams response = new ServerConfigUpdateResponseParams
{
};
if (connInfo == null)
{
await requestContext.SendError(new Exception(SR.ProfilerConnectionNotFound));
}
else
{
var serverConnection = ConnectionService.OpenServerConnection(connInfo);
UpdateConfig(serverConnection, parameters.ConfigNumber, parameters.ConfigValue);
response.ConfigProperty = GetConfig(serverConnection, parameters.ConfigNumber);
await requestContext.SendResult(response);
}
}
catch (Exception e)
{
// Exception related to run task will be captured here
await requestContext.SendError(e);
}
}
/// <summary>
/// Handles config list request
/// </summary>
/// <param name="parameters">Request parameters</param>
/// <param name="requestContext">Request Context</param>
public async Task HandleServerConfigListRequest(ServerConfigListRequestParams parameters, RequestContext<ServerConfigListResponseParams> requestContext)
{
Logger.Write(TraceEventType.Verbose, "HandleServerConfigListRequest");
try
{
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
ServerConfigListResponseParams response = new ServerConfigListResponseParams
{
};
if (connInfo == null)
{
await requestContext.SendError(new Exception(SR.ProfilerConnectionNotFound));
}
else
{
var serverConnection = ConnectionService.OpenServerConnection(connInfo);
response.ConfigProperties = GetConfigs(serverConnection);
await requestContext.SendResult(response);
}
}
catch (Exception e)
{
// Exception related to run task will be captured here
await requestContext.SendError(e);
}
}
/// <summary>
/// Updates external script in a given server. Throws exception if server doesn't support external script
/// </summary>
/// <param name="serverConnection"></param>
/// <param name="configValue"></param>
public void UpdateConfig(ServerConnection serverConnection, int configNumber, int configValue)
{
Server server = new Server(serverConnection);
ConfigProperty serverConfig = GetSmoConfig(server, configNumber);
if (serverConfig != null)
{
try
{
serverConfig.ConfigValue = configValue;
server.Configuration.Alter(true);
}
catch (FailedOperationException ex)
{
throw new ServerConfigException($"Failed to update config. config number: ${configNumber}", ex);
}
}
else
{
throw new ServerConfigException($"Server doesn't have config. config number: ${configNumber}");
}
}
/// <summary>
/// Returns current value of external script config
/// </summary>
/// <param name="serverConnection"></param>
/// <returns></returns>
private ServerConfigProperty GetConfig(ServerConnection serverConnection, int configNumber)
{
Server server = new Server(serverConnection);
ConfigProperty serverConfig = GetSmoConfig(server, configNumber);
return serverConfig != null ? ServerConfigProperty.ToServerConfigProperty(serverConfig) : null;
}
private List<ServerConfigProperty> GetConfigs(ServerConnection serverConnection)
{
Server server = new Server(serverConnection);
List<ServerConfigProperty> list = new List<ServerConfigProperty>();
foreach (ConfigProperty serverConfig in server.Configuration.Properties)
{
list.Add(serverConfig != null ? ServerConfigProperty.ToServerConfigProperty(serverConfig) : null);
}
return list;
}
private ConfigProperty GetSmoConfig(Server server, int configNumber)
{
try
{
ConfigProperty serverConfig = null;
foreach (ConfigProperty configProperty in server.Configuration.Properties)
{
if (configProperty.Number == configNumber)
{
serverConfig = configProperty;
break;
}
}
return serverConfig;
}
catch (Exception ex)
{
throw new ServerConfigException($"Failed to get config. config number: ${configNumber}", ex);
}
}
}
}

190
test/Microsoft.SqlTools.ServiceLayer.IntegrationTests/DisasterRecovery/BackupServiceTests.cs
View File

@@ -78,23 +78,25 @@ CREATE CERTIFICATE {1} WITH SUBJECT = 'Backup Encryption Certificate'; ";
DisasterRecoveryService service = new DisasterRecoveryService(); DisasterRecoveryService service = new DisasterRecoveryService();
string databaseName = "SqlToolsService_TestBackup_" + new Random().Next(10000000, 99999999); string databaseName = "SqlToolsService_TestBackup_" + new Random().Next(10000000, 99999999);
var liveConnection = LiveConnectionHelper.InitLiveConnectionInfo(databaseName);
using (SqlTestDb testDb = SqlTestDb.CreateNew(TestServerType.OnPrem, false, databaseName)) using (SqlTestDb testDb = SqlTestDb.CreateNew(TestServerType.OnPrem, false, databaseName))
using (DatabaseTaskHelper helper = AdminService.CreateDatabaseTaskHelper(liveConnection.ConnectionInfo, databaseExists: true))
using (SqlConnection sqlConn = ConnectionService.OpenSqlConnection(liveConnection.ConnectionInfo))
{ {
string backupPath = GetDefaultBackupFullPath(service, databaseName, helper.DataContainer, sqlConn); var liveConnection = LiveConnectionHelper.InitLiveConnectionInfo(databaseName);
using (DatabaseTaskHelper helper = AdminService.CreateDatabaseTaskHelper(liveConnection.ConnectionInfo, databaseExists: true))
using (SqlConnection sqlConn = ConnectionService.OpenSqlConnection(liveConnection.ConnectionInfo))
{
string backupPath = GetDefaultBackupFullPath(service, databaseName, helper.DataContainer, sqlConn);
BackupInfo backupInfo = CreateDefaultBackupInfo(databaseName, BackupInfo backupInfo = CreateDefaultBackupInfo(databaseName,
BackupType.Full, BackupType.Full,
new List<string>() { backupPath }, new List<string>() { backupPath },
new Dictionary<string, int>() { { backupPath, (int)DeviceType.File } }); new Dictionary<string, int>() { { backupPath, (int)DeviceType.File } });
BackupOperation backupOperation = CreateBackupOperation(service, liveConnection.ConnectionInfo.OwnerUri, backupInfo, helper.DataContainer, sqlConn); BackupOperation backupOperation = CreateBackupOperation(service, liveConnection.ConnectionInfo.OwnerUri, backupInfo, helper.DataContainer, sqlConn);
// Backup the database // Backup the database
service.PerformBackup(backupOperation); service.PerformBackup(backupOperation);
VerifyAndCleanBackup(sqlConn, backupPath); VerifyAndCleanBackup(sqlConn, backupPath);
}
} }
} }
@@ -104,29 +106,31 @@ CREATE CERTIFICATE {1} WITH SUBJECT = 'Backup Encryption Certificate'; ";
DisasterRecoveryService service = new DisasterRecoveryService(); DisasterRecoveryService service = new DisasterRecoveryService();
string databaseName = "SqlToolsService_TestBackup_" + new Random().Next(10000000, 99999999); string databaseName = "SqlToolsService_TestBackup_" + new Random().Next(10000000, 99999999);
var liveConnection = LiveConnectionHelper.InitLiveConnectionInfo(databaseName);
using (SqlTestDb testDb = SqlTestDb.CreateNew(TestServerType.OnPrem, false, databaseName)) using (SqlTestDb testDb = SqlTestDb.CreateNew(TestServerType.OnPrem, false, databaseName))
using (DatabaseTaskHelper helper = AdminService.CreateDatabaseTaskHelper(liveConnection.ConnectionInfo, databaseExists: true))
using (SqlConnection sqlConn = ConnectionService.OpenSqlConnection(liveConnection.ConnectionInfo))
{ {
string backupPath = GetDefaultBackupFullPath(service, databaseName, helper.DataContainer, sqlConn); var liveConnection = LiveConnectionHelper.InitLiveConnectionInfo(databaseName);
using (DatabaseTaskHelper helper = AdminService.CreateDatabaseTaskHelper(liveConnection.ConnectionInfo, databaseExists: true))
using (SqlConnection sqlConn = ConnectionService.OpenSqlConnection(liveConnection.ConnectionInfo))
{
string backupPath = GetDefaultBackupFullPath(service, databaseName, helper.DataContainer, sqlConn);
BackupInfo backupInfo = CreateDefaultBackupInfo(databaseName, BackupInfo backupInfo = CreateDefaultBackupInfo(databaseName,
BackupType.Full, BackupType.Full,
new List<string>() { backupPath }, new List<string>() { backupPath },
new Dictionary<string, int>() { { backupPath, (int)DeviceType.File } }); new Dictionary<string, int>() { { backupPath, (int)DeviceType.File } });
BackupOperation backupOperation = CreateBackupOperation(service, liveConnection.ConnectionInfo.OwnerUri, backupInfo, helper.DataContainer, sqlConn); BackupOperation backupOperation = CreateBackupOperation(service, liveConnection.ConnectionInfo.OwnerUri, backupInfo, helper.DataContainer, sqlConn);
// Generate script for backup // Generate script for backup
service.ScriptBackup(backupOperation); service.ScriptBackup(backupOperation);
string script = backupOperation.ScriptContent; string script = backupOperation.ScriptContent;
Assert.True(!string.IsNullOrEmpty(script)); Assert.True(!string.IsNullOrEmpty(script));
// Execute the script // Execute the script
testDb.RunQuery(script); testDb.RunQuery(script);
VerifyAndCleanBackup(sqlConn, backupPath); VerifyAndCleanBackup(sqlConn, backupPath);
}
} }
} }
@@ -139,45 +143,47 @@ CREATE CERTIFICATE {1} WITH SUBJECT = 'Backup Encryption Certificate'; ";
DisasterRecoveryService service = new DisasterRecoveryService(); DisasterRecoveryService service = new DisasterRecoveryService();
string databaseName = "SqlToolsService_TestBackup_" + new Random().Next(10000000, 99999999); string databaseName = "SqlToolsService_TestBackup_" + new Random().Next(10000000, 99999999);
var liveConnection = LiveConnectionHelper.InitLiveConnectionInfo(databaseName);
using (SqlTestDb testDb = SqlTestDb.CreateNew(TestServerType.OnPrem, false, databaseName)) using (SqlTestDb testDb = SqlTestDb.CreateNew(TestServerType.OnPrem, false, databaseName))
using (DatabaseTaskHelper helper = AdminService.CreateDatabaseTaskHelper(liveConnection.ConnectionInfo, databaseExists: true))
using (SqlConnection sqlConn = ConnectionService.OpenSqlConnection(liveConnection.ConnectionInfo))
{ {
string backupPath = GetDefaultBackupFullPath(service, databaseName, helper.DataContainer, sqlConn); var liveConnection = LiveConnectionHelper.InitLiveConnectionInfo(databaseName);
using (DatabaseTaskHelper helper = AdminService.CreateDatabaseTaskHelper(liveConnection.ConnectionInfo, databaseExists: true))
using (SqlConnection sqlConn = ConnectionService.OpenSqlConnection(liveConnection.ConnectionInfo))
{
string backupPath = GetDefaultBackupFullPath(service, databaseName, helper.DataContainer, sqlConn);
string certificateName = CreateCertificate(testDb); string certificateName = CreateCertificate(testDb);
string cleanupCertificateQuery = string.Format(CleanupCertificateQueryFormat, certificateName); string cleanupCertificateQuery = string.Format(CleanupCertificateQueryFormat, certificateName);
BackupInfo backupInfo = CreateDefaultBackupInfo(databaseName, BackupInfo backupInfo = CreateDefaultBackupInfo(databaseName,
BackupType.Full, BackupType.Full,
new List<string>() { backupPath }, new List<string>() { backupPath },
new Dictionary<string, int>() { { backupPath, (int)DeviceType.File } }); new Dictionary<string, int>() { { backupPath, (int)DeviceType.File } });
backupInfo.ContinueAfterError = true; backupInfo.ContinueAfterError = true;
backupInfo.FormatMedia = true; backupInfo.FormatMedia = true;
backupInfo.SkipTapeHeader = true; backupInfo.SkipTapeHeader = true;
backupInfo.Initialize = true; backupInfo.Initialize = true;
backupInfo.MediaName = "backup test media"; backupInfo.MediaName = "backup test media";
backupInfo.MediaDescription = "backup test"; backupInfo.MediaDescription = "backup test";
backupInfo.RetainDays = 90; backupInfo.RetainDays = 90;
backupInfo.CompressionOption = (int)BackupCompressionOptions.On; backupInfo.CompressionOption = (int)BackupCompressionOptions.On;
backupInfo.EncryptionAlgorithm = (int)BackupEncryptionAlgorithm.Aes128; backupInfo.EncryptionAlgorithm = (int)BackupEncryptionAlgorithm.Aes128;
backupInfo.EncryptorType = (int)BackupEncryptorType.ServerCertificate; backupInfo.EncryptorType = (int)BackupEncryptorType.ServerCertificate;
backupInfo.EncryptorName = certificateName; backupInfo.EncryptorName = certificateName;
BackupOperation backupOperation = CreateBackupOperation(service, liveConnection.ConnectionInfo.OwnerUri, backupInfo, helper.DataContainer, sqlConn); BackupOperation backupOperation = CreateBackupOperation(service, liveConnection.ConnectionInfo.OwnerUri, backupInfo, helper.DataContainer, sqlConn);
// Backup the database // Backup the database
Console.WriteLine("Perform backup operation.."); Console.WriteLine("Perform backup operation..");
service.PerformBackup(backupOperation); service.PerformBackup(backupOperation);
// Remove the backup file // Remove the backup file
Console.WriteLine("Verify the backup file exists and remove.."); Console.WriteLine("Verify the backup file exists and remove..");
VerifyAndCleanBackup(sqlConn, backupPath); VerifyAndCleanBackup(sqlConn, backupPath);
// Delete certificate and master key // Delete certificate and master key
Console.WriteLine("Remove certificate and master key.."); Console.WriteLine("Remove certificate and master key..");
testDb.RunQuery(cleanupCertificateQuery); testDb.RunQuery(cleanupCertificateQuery);
}
} }
} }
@@ -190,47 +196,49 @@ CREATE CERTIFICATE {1} WITH SUBJECT = 'Backup Encryption Certificate'; ";
DisasterRecoveryService service = new DisasterRecoveryService(); DisasterRecoveryService service = new DisasterRecoveryService();
string databaseName = "SqlToolsService_TestBackup_" + new Random().Next(10000000, 99999999); string databaseName = "SqlToolsService_TestBackup_" + new Random().Next(10000000, 99999999);
var liveConnection = LiveConnectionHelper.InitLiveConnectionInfo(databaseName);
using (SqlTestDb testDb = SqlTestDb.CreateNew(TestServerType.OnPrem, false, databaseName)) using (SqlTestDb testDb = SqlTestDb.CreateNew(TestServerType.OnPrem, false, databaseName))
using (DatabaseTaskHelper helper = AdminService.CreateDatabaseTaskHelper(liveConnection.ConnectionInfo, databaseExists: true))
using (SqlConnection sqlConn = ConnectionService.OpenSqlConnection(liveConnection.ConnectionInfo))
{ {
string backupPath = GetDefaultBackupFullPath(service, databaseName, helper.DataContainer, sqlConn); var liveConnection = LiveConnectionHelper.InitLiveConnectionInfo(databaseName);
using (DatabaseTaskHelper helper = AdminService.CreateDatabaseTaskHelper(liveConnection.ConnectionInfo, databaseExists: true))
using (SqlConnection sqlConn = ConnectionService.OpenSqlConnection(liveConnection.ConnectionInfo))
{
string backupPath = GetDefaultBackupFullPath(service, databaseName, helper.DataContainer, sqlConn);
string certificateName = CreateCertificate(testDb); string certificateName = CreateCertificate(testDb);
string cleanupCertificateQuery = string.Format(CleanupCertificateQueryFormat, certificateName); string cleanupCertificateQuery = string.Format(CleanupCertificateQueryFormat, certificateName);
BackupInfo backupInfo = CreateDefaultBackupInfo(databaseName, BackupInfo backupInfo = CreateDefaultBackupInfo(databaseName,
BackupType.Full, BackupType.Full,
new List<string>() { backupPath }, new List<string>() { backupPath },
new Dictionary<string, int>() { { backupPath, (int)DeviceType.File } }); new Dictionary<string, int>() { { backupPath, (int)DeviceType.File } });
backupInfo.FormatMedia = true; backupInfo.FormatMedia = true;
backupInfo.SkipTapeHeader = true; backupInfo.SkipTapeHeader = true;
backupInfo.Initialize = true; backupInfo.Initialize = true;
backupInfo.MediaName = "backup test media"; backupInfo.MediaName = "backup test media";
backupInfo.MediaDescription = "backup test"; backupInfo.MediaDescription = "backup test";
backupInfo.EncryptionAlgorithm = (int)BackupEncryptionAlgorithm.Aes128; backupInfo.EncryptionAlgorithm = (int)BackupEncryptionAlgorithm.Aes128;
backupInfo.EncryptorType = (int)BackupEncryptorType.ServerCertificate; backupInfo.EncryptorType = (int)BackupEncryptorType.ServerCertificate;
backupInfo.EncryptorName = certificateName; backupInfo.EncryptorName = certificateName;
BackupOperation backupOperation = CreateBackupOperation(service, liveConnection.ConnectionInfo.OwnerUri, backupInfo, helper.DataContainer, sqlConn); BackupOperation backupOperation = CreateBackupOperation(service, liveConnection.ConnectionInfo.OwnerUri, backupInfo, helper.DataContainer, sqlConn);
// Backup the database // Backup the database
Console.WriteLine("Generate script for backup operation.."); Console.WriteLine("Generate script for backup operation..");
service.ScriptBackup(backupOperation); service.ScriptBackup(backupOperation);
string script = backupOperation.ScriptContent; string script = backupOperation.ScriptContent;
// Run the script // Run the script
Console.WriteLine("Execute the script.."); Console.WriteLine("Execute the script..");
testDb.RunQuery(script); testDb.RunQuery(script);
// Remove the backup file // Remove the backup file
Console.WriteLine("Verify the backup file exists and remove.."); Console.WriteLine("Verify the backup file exists and remove..");
VerifyAndCleanBackup(sqlConn, backupPath); VerifyAndCleanBackup(sqlConn, backupPath);
// Delete certificate and master key // Delete certificate and master key
Console.WriteLine("Remove certificate and master key.."); Console.WriteLine("Remove certificate and master key..");
testDb.RunQuery(cleanupCertificateQuery); testDb.RunQuery(cleanupCertificateQuery);
}
} }
} }

64
test/Microsoft.SqlTools.ServiceLayer.IntegrationTests/LanguageExtensions/LanguageExtensionsTests.cs Normal file
View File

@@ -0,0 +1,64 @@
//
// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
//
using Microsoft.SqlTools.ServiceLayer.Connection.Contracts;
using Microsoft.SqlTools.ServiceLayer.IntegrationTests.Utility;
using Microsoft.SqlTools.ServiceLayer.LanguageExtensions;
using Microsoft.SqlTools.ServiceLayer.LanguageExtensions.Contracts;
using Microsoft.SqlTools.ServiceLayer.Test.Common;
using Microsoft.SqlTools.ServiceLayer.Test.Common.RequestContextMocking;
using Moq;
using System;
using Xunit;
namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.LanguageExtensions
{
public class LanguageExtensionsTests
{
[Fact]
public async void VerifyExternalLanguageStatusRequest()
{
using (SelfCleaningTempFile queryTempFile = new SelfCleaningTempFile())
{
var connectionResult = await LiveConnectionHelper.InitLiveConnectionInfoAsync("master", queryTempFile.FilePath);
ExternalLanguageStatusResponseParams result = null;
var requestContext = RequestContextMocks.Create<ExternalLanguageStatusResponseParams>(r => result = r).AddErrorHandling(null);
ExternalLanguageStatusRequestParams requestParams = new ExternalLanguageStatusRequestParams
{
OwnerUri = connectionResult.ConnectionInfo.OwnerUri,
LanguageName = "Python"
};
await LanguageExtensionsService.Instance.HandleExternalLanguageStatusRequest(requestParams, requestContext.Object);
Assert.NotNull(result);
LanguageExtensionsService.Instance.ConnectionServiceInstance.Disconnect(new DisconnectParams
{
OwnerUri = queryTempFile.FilePath,
Type = ServiceLayer.Connection.ConnectionType.Default
});
}
}
[Fact]
public async void VerifyExternalLanguageStatusRequestSendErrorGivenInvalidConnection()
{
ExternalLanguageStatusResponseParams result = null;
var requestContext = RequestContextMocks.Create<ExternalLanguageStatusResponseParams>(r => result = r).AddErrorHandling(null);
requestContext.Setup(x => x.SendError(It.IsAny<Exception>())).Returns(System.Threading.Tasks.Task.FromResult(true));
ExternalLanguageStatusRequestParams requestParams = new ExternalLanguageStatusRequestParams
{
OwnerUri = "invalid uri",
LanguageName = "Python"
};
await LanguageExtensionsService.Instance.HandleExternalLanguageStatusRequest(requestParams, requestContext.Object);
requestContext.Verify(x => x.SendError(It.IsAny<Exception>()));
}
}
}

150
test/Microsoft.SqlTools.ServiceLayer.IntegrationTests/ServerConfigurations/ServerConfigurationsServiceTests.cs Normal file
View File

@@ -0,0 +1,150 @@
//
// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
//
using Microsoft.SqlTools.ServiceLayer.Connection.Contracts;
using Microsoft.SqlTools.ServiceLayer.IntegrationTests.Utility;
using Microsoft.SqlTools.ServiceLayer.ServerConfigurations;
using Microsoft.SqlTools.ServiceLayer.ServerConfigurations.Contracts;
using Microsoft.SqlTools.ServiceLayer.Test.Common;
using Microsoft.SqlTools.ServiceLayer.Test.Common.RequestContextMocking;
using Moq;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Xunit;
namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.MachineLearningServices
{
public class ServerConfigurationsServiceTests
{
[Fact]
public async void VerifyListingConfigs()
{
List<ServerConfigProperty> configs = await GetAllConfigs();
Assert.NotNull(configs);
Assert.True(configs.Count > 0);
}
[Fact]
public async void VerifyUpdatingConfigs()
{
using (SelfCleaningTempFile queryTempFile = new SelfCleaningTempFile())
{
var connectionResult = await LiveConnectionHelper.InitLiveConnectionInfoAsync("master", queryTempFile.FilePath);
List<ServerConfigProperty> configs = await GetAllConfigs();
Assert.NotNull(configs);
Assert.True(configs.Count > 0);
ServerConfigProperty sampleConfig = configs[0];
ServerConfigViewResponseParams result = null;
ServerConfigUpdateResponseParams updateResult = null;
int newValue = sampleConfig.ConfigValue == sampleConfig.Minimum ? sampleConfig.Maximum : sampleConfig.Minimum;
var requestContext = RequestContextMocks.Create<ServerConfigViewResponseParams>(r => result = r).AddErrorHandling(null);
var updateRequestContext = RequestContextMocks.Create<ServerConfigUpdateResponseParams>(r => updateResult = r).AddErrorHandling(null);
ServerConfigViewRequestParams requestParams = new ServerConfigViewRequestParams
{
OwnerUri = connectionResult.ConnectionInfo.OwnerUri,
ConfigNumber = sampleConfig.Number
};
ServerConfigUpdateRequestParams updateRequestParams = new ServerConfigUpdateRequestParams
{
OwnerUri = connectionResult.ConnectionInfo.OwnerUri,
ConfigNumber = sampleConfig.Number,
ConfigValue = newValue
};
await ServerConfigService.Instance.HandleServerConfigViewRequest(requestParams, requestContext.Object);
Assert.NotNull(result);
Assert.Equal(result.ConfigProperty.ConfigValue, sampleConfig.ConfigValue);
await ServerConfigService.Instance.HandleServerConfigUpdateRequest(updateRequestParams, updateRequestContext.Object);
Assert.NotNull(updateResult);
Assert.Equal(updateResult.ConfigProperty.ConfigValue, newValue);
updateRequestParams.ConfigValue = sampleConfig.ConfigValue;
await ServerConfigService.Instance.HandleServerConfigUpdateRequest(updateRequestParams, updateRequestContext.Object);
Assert.NotNull(updateResult);
Assert.Equal(updateResult.ConfigProperty.ConfigValue, sampleConfig.ConfigValue);
ServerConfigService.Instance.ConnectionServiceInstance.Disconnect(new DisconnectParams
{
OwnerUri = queryTempFile.FilePath,
Type = ServiceLayer.Connection.ConnectionType.Default
});
}
}
public async Task<List<ServerConfigProperty>> GetAllConfigs()
{
using (SelfCleaningTempFile queryTempFile = new SelfCleaningTempFile())
{
var connectionResult = await LiveConnectionHelper.InitLiveConnectionInfoAsync("master", queryTempFile.FilePath);
ServerConfigListResponseParams result = null;
var requestContext = RequestContextMocks.Create<ServerConfigListResponseParams>(r => result = r).AddErrorHandling(null);
ServerConfigListRequestParams requestParams = new ServerConfigListRequestParams
{
OwnerUri = connectionResult.ConnectionInfo.OwnerUri
};
await ServerConfigService.Instance.HandleServerConfigListRequest(requestParams, requestContext.Object);
Assert.NotNull(result);
return result.ConfigProperties;
}
}
[Fact]
public async void VerifyConfigViewRequestSendErrorGivenInvalidConnection()
{
ServerConfigViewResponseParams result = null;
var requestContext = RequestContextMocks.Create<ServerConfigViewResponseParams>(r => result = r).AddErrorHandling(null);
requestContext.Setup(x => x.SendError(It.IsAny<Exception>())).Returns(System.Threading.Tasks.Task.FromResult(true));
ServerConfigViewRequestParams requestParams = new ServerConfigViewRequestParams
{
OwnerUri = "invalid uri"
};
await ServerConfigService.Instance.HandleServerConfigViewRequest(requestParams, requestContext.Object);
requestContext.Verify(x => x.SendError(It.IsAny<Exception>()));
}
[Fact]
public async void VerifyConfigUpdateRequestSendErrorGivenInvalidConnection()
{
ServerConfigUpdateResponseParams result = null;
var requestContext = RequestContextMocks.Create<ServerConfigUpdateResponseParams>(r => result = r).AddErrorHandling(null);
requestContext.Setup(x => x.SendError(It.IsAny<Exception>())).Returns(System.Threading.Tasks.Task.FromResult(true));
ServerConfigUpdateRequestParams requestParams = new ServerConfigUpdateRequestParams
{
OwnerUri = "invalid uri",
ConfigValue = 1
};
await ServerConfigService.Instance.HandleServerConfigUpdateRequest(requestParams, requestContext.Object);
requestContext.Verify(x => x.SendError(It.IsAny<Exception>()));
}
[Fact]
public async void VerifyConfigListRequestSendErrorGivenInvalidConnection()
{
ServerConfigListResponseParams result = null;
var requestContext = RequestContextMocks.Create<ServerConfigListResponseParams>(r => result = r).AddErrorHandling(null);
requestContext.Setup(x => x.SendError(It.IsAny<Exception>())).Returns(System.Threading.Tasks.Task.FromResult(true));
ServerConfigListRequestParams requestParams = new ServerConfigListRequestParams
{
OwnerUri = "invalid uri",
};
await ServerConfigService.Instance.HandleServerConfigListRequest(requestParams, requestContext.Object);
requestContext.Verify(x => x.SendError(It.IsAny<Exception>()));
}
}
}

4
test/Microsoft.SqlTools.ServiceLayer.IntegrationTests/Utility/LiveConnectionHelper.cs
View File

@@ -63,7 +63,7 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.Utility
} }
public static async Task<TestConnectionResult> InitLiveConnectionInfoAsync(string databaseName = null, string ownerUri = null, public static async Task<TestConnectionResult> InitLiveConnectionInfoAsync(string databaseName = null, string ownerUri = null,
string connectionType = ServiceLayer.Connection.ConnectionType.Default) string connectionType = ServiceLayer.Connection.ConnectionType.Default, TestServerType serverType = TestServerType.OnPrem)
{ {
ScriptFile scriptFile = null; ScriptFile scriptFile = null;
if (string.IsNullOrEmpty(ownerUri)) if (string.IsNullOrEmpty(ownerUri))
@@ -72,7 +72,7 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.Utility
scriptFile = TestServiceProvider.Instance.WorkspaceService.Workspace.GetFile(ownerUri); scriptFile = TestServiceProvider.Instance.WorkspaceService.Workspace.GetFile(ownerUri);
ownerUri = scriptFile.ClientUri; ownerUri = scriptFile.ClientUri;
} }
ConnectParams connectParams = TestServiceProvider.Instance.ConnectionProfileService.GetConnectionParameters(TestServerType.OnPrem, databaseName); ConnectParams connectParams = TestServiceProvider.Instance.ConnectionProfileService.GetConnectionParameters(serverType, databaseName);
var connectionService = GetLiveTestConnectionService(); var connectionService = GetLiveTestConnectionService();
var connectionResult = var connectionResult =