ckaczor/sqltoolsservice
1
0
Fork 0
mirror of https://github.com/ckaczor/sqltoolsservice.git synced 2026-01-14 01:25:40 -05:00
Code Issues Packages Projects Releases Wiki Activity

Catch Request/Event handler errors at dispatcher level (#1610)

Browse Source 
* Catch Request/Event handler errors at dispatcher level

* Fix tests

* Use Exception overload of SendError

* Fix tests
This commit is contained in:
Charles Gagnon
2022-07-29 17:31:36 -07:00
committed by GitHub
parent 3294a52ad9
commit fd00114a0e
32 changed files with 1326 additions and 1921 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
src/Microsoft.SqlTools.Credentials/Credentials/CredentialService.cs
View File

@@ -1,4 +1,4 @@
//
//
// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
//
@@ -50,7 +50,7 @@ namespace Microsoft.SqlTools.Credentials
/// </summary>
private CredentialService()
: this(null, new StoreConfig()
{ CredentialFolder = DefaultSecretsFolder, CredentialFile = DefaultSecretsFile, IsRelativeToUserHomeDir = true})
{ CredentialFolder = DefaultSecretsFolder, CredentialFile = DefaultSecretsFile, IsRelativeToUserHomeDir = true })
{
}
@@ -67,12 +67,12 @@ namespace Microsoft.SqlTools.Credentials
/// </summary>
internal static ICredentialStore GetStoreForOS(StoreConfig config)
{
if(RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
return new Win32CredentialStore();
}
#if !WINDOWS_ONLY_BUILD
else if(RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
{
return new OSXCredentialStore();
}
@@ -161,16 +161,8 @@ namespace Microsoft.SqlTools.Credentials
private async Task HandleRequest<T>(Func<Task<T>> handler, RequestContext<T> requestContext, string requestType)
{
Logger.Write(TraceEventType.Verbose, requestType);
try
{
T result = await handler();
await requestContext.SendResult(result);
}
catch (Exception ex)
{
await requestContext.SendError(ex.ToString());
}
T result = await handler();
await requestContext.SendResult(result);
}
}

56
src/Microsoft.SqlTools.Hosting/Hosting/Protocol/MessageDispatcher.cs
View File

@@ -131,20 +131,29 @@ namespace Microsoft.SqlTools.Hosting.Protocol
requestMessage,
messageWriter);
TParams typedParams = default(TParams);
if (requestMessage.Contents != null)
try
{
try
TParams typedParams = default(TParams);
if (requestMessage.Contents != null)
{
typedParams = requestMessage.Contents.ToObject<TParams>();
try
{
typedParams = requestMessage.Contents.ToObject<TParams>();
}
catch (Exception ex)
{
throw new Exception($"{requestType.MethodName} : Error parsing message contents {requestMessage.Contents}", ex);
}
}
catch (Exception ex)
{
await requestContext.SendError(ex.Message);
}
}
await requestHandler(typedParams, requestContext);
await requestHandler(typedParams, requestContext);
}
catch (Exception ex)
{
Logger.Error(ex);
await requestContext.SendError(ex);
}
});
});
}
@@ -178,20 +187,27 @@ namespace Microsoft.SqlTools.Hosting.Protocol
{
var eventContext = new EventContext(messageWriter);
TParams typedParams = default(TParams);
if (eventMessage.Contents != null)
try
{
try
TParams typedParams = default(TParams);
if (eventMessage.Contents != null)
{
typedParams = eventMessage.Contents.ToObject<TParams>();
}
catch (Exception ex)
{
Logger.Write(TraceEventType.Verbose, ex.ToString());
try
{
typedParams = eventMessage.Contents.ToObject<TParams>();
}
catch (Exception ex)
{
throw new Exception($"{eventType.MethodName} : Error parsing message contents {eventMessage.Contents}", ex);
}
}
await eventHandler(typedParams, eventContext);
}
catch (Exception ex)
{
// There's nothing on the client side to send an error back to so just log the error and move on
Logger.Error(ex);
}
await eventHandler(typedParams, eventContext);
});
});
}

6
src/Microsoft.SqlTools.Hosting/Utility/Logger.cs
View File

@@ -263,6 +263,12 @@ namespace Microsoft.SqlTools.Utility
/// <param name="logMessage">The message text to be written.</param>
public static void Error(string logMessage) => Write(TraceEventType.Error, logMessage);
/// <summary>
/// Writes an exception to the log file with the Error event level
/// </summary>
/// <param name="exception"></param>
public static void Error(Exception exception) => Write(TraceEventType.Error, exception.ToString());
/// <summary>
/// Writes a message to the log file with the Critical event level
/// </summary>

5
src/Microsoft.SqlTools.ResourceProvider.Core/ResourceProviderService.cs
View File

@@ -135,11 +135,6 @@ namespace Microsoft.SqlTools.ResourceProvider.Core
await requestContext.SendError(ex.Message);
}
}
catch (Exception ex)
{
// Send just the error message back for now as stack trace isn't useful
await requestContext.SendError(ex.Message);
}
}
}
}

108
src/Microsoft.SqlTools.ServiceLayer/Admin/AdminService.cs
View File

@@ -81,24 +81,17 @@ namespace Microsoft.SqlTools.ServiceLayer.Admin
DefaultDatabaseInfoParams optionsParams,
RequestContext<DefaultDatabaseInfoResponse> requestContext)
{
try
{
var response = new DefaultDatabaseInfoResponse();
ConnectionInfo connInfo;
AdminService.ConnectionServiceInstance.TryFindConnection(
optionsParams.OwnerUri,
out connInfo);
var response = new DefaultDatabaseInfoResponse();
ConnectionInfo connInfo;
AdminService.ConnectionServiceInstance.TryFindConnection(
optionsParams.OwnerUri,
out connInfo);
using (var taskHelper = CreateDatabaseTaskHelper(connInfo))
{
response.DefaultDatabaseInfo = DatabaseTaskHelper.DatabasePrototypeToDatabaseInfo(taskHelper.Prototype);
await requestContext.SendResult(response);
}
}
catch (Exception ex)
using (var taskHelper = CreateDatabaseTaskHelper(connInfo))
{
await requestContext.SendError(ex.ToString());
}
response.DefaultDatabaseInfo = DatabaseTaskHelper.DatabasePrototypeToDatabaseInfo(taskHelper.Prototype);
await requestContext.SendResult(response);
}
}
/// <summary>
@@ -108,32 +101,25 @@ namespace Microsoft.SqlTools.ServiceLayer.Admin
CreateDatabaseParams databaseParams,
RequestContext<CreateDatabaseResponse> requestContext)
{
try
{
var response = new DefaultDatabaseInfoResponse();
ConnectionInfo connInfo;
AdminService.ConnectionServiceInstance.TryFindConnection(
databaseParams.OwnerUri,
out connInfo);
var response = new DefaultDatabaseInfoResponse();
ConnectionInfo connInfo;
AdminService.ConnectionServiceInstance.TryFindConnection(
databaseParams.OwnerUri,
out connInfo);
using (var taskHelper = CreateDatabaseTaskHelper(connInfo))
{
DatabasePrototype prototype = taskHelper.Prototype;
DatabaseTaskHelper.ApplyToPrototype(databaseParams.DatabaseInfo, taskHelper.Prototype);
Database db = prototype.ApplyChanges();
await requestContext.SendResult(new CreateDatabaseResponse()
{
Result = true,
TaskId = 0
});
}
}
catch (Exception ex)
using (var taskHelper = CreateDatabaseTaskHelper(connInfo))
{
await requestContext.SendError(ex.ToString());
}
DatabasePrototype prototype = taskHelper.Prototype;
DatabaseTaskHelper.ApplyToPrototype(databaseParams.DatabaseInfo, taskHelper.Prototype);
Database db = prototype.ApplyChanges();
await requestContext.SendResult(new CreateDatabaseResponse()
{
Result = true,
TaskId = 0
});
}
}
/// <summary>
@@ -143,39 +129,31 @@ namespace Microsoft.SqlTools.ServiceLayer.Admin
GetDatabaseInfoParams databaseParams,
RequestContext<GetDatabaseInfoResponse> requestContext)
{
try
Func<Task> requestHandler = async () =>
{
Func<Task> requestHandler = async () =>
ConnectionInfo connInfo;
AdminService.ConnectionServiceInstance.TryFindConnection(
databaseParams.OwnerUri,
out connInfo);
DatabaseInfo info = null;
if (connInfo != null)
{
ConnectionInfo connInfo;
AdminService.ConnectionServiceInstance.TryFindConnection(
databaseParams.OwnerUri,
out connInfo);
DatabaseInfo info = null;
info = GetDatabaseInfo(connInfo);
}
if (connInfo != null)
{
info = GetDatabaseInfo(connInfo);
}
await requestContext.SendResult(new GetDatabaseInfoResponse()
{
DatabaseInfo = info
});
};
Task task = Task.Run(async () => await requestHandler()).ContinueWithOnFaulted(async t =>
await requestContext.SendResult(new GetDatabaseInfoResponse()
{
await requestContext.SendError(t.Exception.ToString());
DatabaseInfo = info
});
};
}
catch (Exception ex)
Task task = Task.Run(async () => await requestHandler()).ContinueWithOnFaulted(async t =>
{
await requestContext.SendError(ex.ToString());
}
await requestContext.SendError(t.Exception.ToString());
});
}
/// <summary>
/// Return database info for a specific database
/// </summary>

184
src/Microsoft.SqlTools.ServiceLayer/Agent/AgentService.cs
View File

@@ -148,38 +148,31 @@ namespace Microsoft.SqlTools.ServiceLayer.Agent
/// </summary>
internal async Task HandleAgentJobsRequest(AgentJobsParams parameters, RequestContext<AgentJobsResult> requestContext)
{
try
{
var result = new AgentJobsResult();
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
var result = new AgentJobsResult();
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
if (connInfo != null)
{
var serverConnection = ConnectionService.OpenServerConnection(connInfo);
var fetcher = new JobFetcher(serverConnection);
var filter = new JobActivityFilter();
var jobs = fetcher.FetchJobs(filter);
var agentJobs = new List<AgentJobInfo>();
if (jobs != null)
{
foreach (var job in jobs.Values)
{
agentJobs.Add(AgentUtilities.ConvertToAgentJobInfo(job));
}
}
result.Success = true;
result.Jobs = agentJobs.ToArray();
serverConnection.SqlConnectionObject.Close();
}
await requestContext.SendResult(result);
}
catch (Exception e)
if (connInfo != null)
{
await requestContext.SendError(e);
var serverConnection = ConnectionService.OpenServerConnection(connInfo);
var fetcher = new JobFetcher(serverConnection);
var filter = new JobActivityFilter();
var jobs = fetcher.FetchJobs(filter);
var agentJobs = new List<AgentJobInfo>();
if (jobs != null)
{
foreach (var job in jobs.Values)
{
agentJobs.Add(AgentUtilities.ConvertToAgentJobInfo(job));
}
}
result.Success = true;
result.Jobs = agentJobs.ToArray();
serverConnection.SqlConnectionObject.Close();
}
await requestContext.SendResult(result);
}
/// <summary>
@@ -187,79 +180,72 @@ namespace Microsoft.SqlTools.ServiceLayer.Agent
/// </summary>
internal async Task HandleJobHistoryRequest(AgentJobHistoryParams parameters, RequestContext<AgentJobHistoryResult> requestContext)
{
try
var result = new AgentJobHistoryResult();
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
if (connInfo != null)
{
var result = new AgentJobHistoryResult();
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
if (connInfo != null)
CDataContainer dataContainer = CDataContainer.CreateDataContainer(connInfo, databaseExists: true);
var jobServer = dataContainer.Server.JobServer;
var jobs = jobServer.Jobs;
Tuple<SqlConnectionInfo, DataTable, ServerConnection> tuple = CreateSqlConnection(connInfo, parameters.JobId);
SqlConnectionInfo sqlConnInfo = tuple.Item1;
DataTable dt = tuple.Item2;
ServerConnection connection = tuple.Item3;
// Send Steps, Alerts and Schedules with job history in background
// Add steps to the job if any
JobStepCollection steps = jobs[parameters.JobName].JobSteps;
var jobSteps = new List<AgentJobStepInfo>();
foreach (JobStep step in steps)
{
CDataContainer dataContainer = CDataContainer.CreateDataContainer(connInfo, databaseExists: true);
var jobServer = dataContainer.Server.JobServer;
var jobs = jobServer.Jobs;
Tuple<SqlConnectionInfo, DataTable, ServerConnection> tuple = CreateSqlConnection(connInfo, parameters.JobId);
SqlConnectionInfo sqlConnInfo = tuple.Item1;
DataTable dt = tuple.Item2;
ServerConnection connection = tuple.Item3;
// Send Steps, Alerts and Schedules with job history in background
// Add steps to the job if any
JobStepCollection steps = jobs[parameters.JobName].JobSteps;
var jobSteps = new List<AgentJobStepInfo>();
foreach (JobStep step in steps)
{
jobSteps.Add(AgentUtilities.ConvertToAgentJobStepInfo(step, parameters.JobId, parameters.JobName));
}
result.Steps = jobSteps.ToArray();
// Add schedules to the job if any
JobScheduleCollection schedules = jobs[parameters.JobName].JobSchedules;
var jobSchedules = new List<AgentScheduleInfo>();
foreach (JobSchedule schedule in schedules)
{
jobSchedules.Add(AgentUtilities.ConvertToAgentScheduleInfo(schedule));
}
result.Schedules = jobSchedules.ToArray();
// Alerts
AlertCollection alerts = jobServer.Alerts;
var jobAlerts = new List<Alert>();
foreach (Alert alert in alerts)
{
if (alert.JobName == parameters.JobName)
{
jobAlerts.Add(alert);
}
}
result.Alerts = AgentUtilities.ConvertToAgentAlertInfo(jobAlerts);
// Add histories
int count = dt.Rows.Count;
List<AgentJobHistoryInfo> jobHistories = new List<AgentJobHistoryInfo>();
if (count > 0)
{
var job = dt.Rows[0];
Guid jobId = (Guid)job[AgentUtilities.UrnJobId];
int runStatus = Convert.ToInt32(job[AgentUtilities.UrnRunStatus], System.Globalization.CultureInfo.InvariantCulture);
var t = new LogSourceJobHistory(parameters.JobName, sqlConnInfo, null, runStatus, jobId, null);
var tlog = t as ILogSource;
tlog.Initialize();
var logEntries = t.LogEntries;
// Finally add the job histories
jobHistories = AgentUtilities.ConvertToAgentJobHistoryInfo(logEntries, job, steps);
result.Histories = jobHistories.ToArray();
result.Success = true;
tlog.CloseReader();
}
await requestContext.SendResult(result);
jobSteps.Add(AgentUtilities.ConvertToAgentJobStepInfo(step, parameters.JobId, parameters.JobName));
}
}
catch (Exception e)
{
await requestContext.SendError(e);
result.Steps = jobSteps.ToArray();
// Add schedules to the job if any
JobScheduleCollection schedules = jobs[parameters.JobName].JobSchedules;
var jobSchedules = new List<AgentScheduleInfo>();
foreach (JobSchedule schedule in schedules)
{
jobSchedules.Add(AgentUtilities.ConvertToAgentScheduleInfo(schedule));
}
result.Schedules = jobSchedules.ToArray();
// Alerts
AlertCollection alerts = jobServer.Alerts;
var jobAlerts = new List<Alert>();
foreach (Alert alert in alerts)
{
if (alert.JobName == parameters.JobName)
{
jobAlerts.Add(alert);
}
}
result.Alerts = AgentUtilities.ConvertToAgentAlertInfo(jobAlerts);
// Add histories
int count = dt.Rows.Count;
List<AgentJobHistoryInfo> jobHistories = new List<AgentJobHistoryInfo>();
if (count > 0)
{
var job = dt.Rows[0];
Guid jobId = (Guid)job[AgentUtilities.UrnJobId];
int runStatus = Convert.ToInt32(job[AgentUtilities.UrnRunStatus], System.Globalization.CultureInfo.InvariantCulture);
var t = new LogSourceJobHistory(parameters.JobName, sqlConnInfo, null, runStatus, jobId, null);
var tlog = t as ILogSource;
tlog.Initialize();
var logEntries = t.LogEntries;
// Finally add the job histories
jobHistories = AgentUtilities.ConvertToAgentJobHistoryInfo(logEntries, job, steps);
result.Histories = jobHistories.ToArray();
result.Success = true;
tlog.CloseReader();
}
await requestContext.SendResult(result);
}
}

55
src/Microsoft.SqlTools.ServiceLayer/AzureBlob/BlobService.cs
View File

@@ -42,39 +42,32 @@ namespace Microsoft.SqlTools.ServiceLayer.AzureBlob
CreateSasParams optionsParams,
RequestContext<CreateSasResponse> requestContext)
{
try
{
ConnectionInfo connInfo;
ConnectionService.Instance.TryFindConnection(
optionsParams.OwnerUri,
out connInfo);
var response = new CreateSasResponse();
ConnectionInfo connInfo;
ConnectionService.Instance.TryFindConnection(
optionsParams.OwnerUri,
out connInfo);
var response = new CreateSasResponse();
if (connInfo == null)
{
await requestContext.SendError(SR.ConnectionServiceListDbErrorNotConnected(optionsParams.OwnerUri));
return;
}
if (connInfo.IsCloud)
{
await requestContext.SendError(SR.NotSupportedCloudCreateSas);
return;
}
using (SqlConnection sqlConn = ConnectionService.OpenSqlConnection(connInfo, "AzureBlob"))
{
// Connection gets disconnected when backup is done
ServerConnection serverConnection = new ServerConnection(sqlConn);
Server sqlServer = new Server(serverConnection);
SharedAccessSignatureCreator sharedAccessSignatureCreator = new SharedAccessSignatureCreator(sqlServer);
string sharedAccessSignature = sharedAccessSignatureCreator.CreateSqlSASCredential(optionsParams.StorageAccountName, optionsParams.BlobContainerKey, optionsParams.BlobContainerUri, optionsParams.ExpirationDate);
response.SharedAccessSignature = sharedAccessSignature;
await requestContext.SendResult(response);
}
}
catch (Exception ex)
if (connInfo == null)
{
await requestContext.SendError(ex);
await requestContext.SendError(SR.ConnectionServiceListDbErrorNotConnected(optionsParams.OwnerUri));
return;
}
if (connInfo.IsCloud)
{
await requestContext.SendError(SR.NotSupportedCloudCreateSas);
return;
}
using (SqlConnection sqlConn = ConnectionService.OpenSqlConnection(connInfo, "AzureBlob"))
{
// Connection gets disconnected when backup is done
ServerConnection serverConnection = new ServerConnection(sqlConn);
Server sqlServer = new Server(serverConnection);
SharedAccessSignatureCreator sharedAccessSignatureCreator = new SharedAccessSignatureCreator(sqlServer);
string sharedAccessSignature = sharedAccessSignatureCreator.CreateSqlSASCredential(optionsParams.StorageAccountName, optionsParams.BlobContainerKey, optionsParams.BlobContainerUri, optionsParams.ExpirationDate);
response.SharedAccessSignature = sharedAccessSignature;
await requestContext.SendResult(response);
}
}
}

28
src/Microsoft.SqlTools.ServiceLayer/AzureFunctions/AzureFunctionsService.cs
View File

@@ -17,7 +17,7 @@ namespace Microsoft.SqlTools.ServiceLayer.AzureFunctions
class AzureFunctionsService
{
private static readonly Lazy<AzureFunctionsService> instance = new Lazy<AzureFunctionsService>(() => new AzureFunctionsService());
/// <summary>
/// Gets the singleton instance object
/// </summary>
@@ -41,17 +41,10 @@ namespace Microsoft.SqlTools.ServiceLayer.AzureFunctions
/// </summary>
public async Task HandleAddSqlBindingRequest(AddSqlBindingParams parameters, RequestContext<ResultStatus> requestContext)
{
try
{
AddSqlBindingOperation operation = new AddSqlBindingOperation(parameters);
ResultStatus result = operation.AddBinding();
AddSqlBindingOperation operation = new AddSqlBindingOperation(parameters);
ResultStatus result = operation.AddBinding();
await requestContext.SendResult(result);
}
catch (Exception e)
{
await requestContext.SendError(e);
}
await requestContext.SendResult(result);
}
/// <summary>
@@ -59,17 +52,10 @@ namespace Microsoft.SqlTools.ServiceLayer.AzureFunctions
/// </summary>
public async Task HandleGetAzureFunctionsRequest(GetAzureFunctionsParams parameters, RequestContext<GetAzureFunctionsResult> requestContext)
{
try
{
GetAzureFunctionsOperation operation = new GetAzureFunctionsOperation(parameters);
GetAzureFunctionsResult result = operation.GetAzureFunctions();
GetAzureFunctionsOperation operation = new GetAzureFunctionsOperation(parameters);
GetAzureFunctionsResult result = operation.GetAzureFunctions();
await requestContext.SendResult(result);
}
catch (Exception e)
{
await requestContext.SendError(e);
}
await requestContext.SendResult(result);
}
}
}

291
src/Microsoft.SqlTools.ServiceLayer/Cms/CmsService.cs
View File

@@ -54,240 +54,197 @@ namespace Microsoft.SqlTools.ServiceLayer.Cms
public async Task HandleCreateCentralManagementServerRequest(CreateCentralManagementServerParams createCmsParams, RequestContext<ListRegisteredServersResult> requestContext)
{
Logger.Write(TraceEventType.Verbose, "HandleCreateCentralManagementServerRequest");
try
CmsTask = Task.Run(async () =>
{
CmsTask = Task.Run(async () =>
try
{
try
{
//Validate params and connect
ServerConnection conn = await ValidateAndCreateConnection(createCmsParams.ConnectParams);
//Validate params and connect
ServerConnection conn = await ValidateAndCreateConnection(createCmsParams.ConnectParams);
// Get Current Reg Servers on CMS
RegisteredServersStore store = new RegisteredServersStore(conn);
ServerGroup parentGroup = store.DatabaseEngineServerGroup;
ListRegisteredServersResult result = GetChildrenfromParentGroup(parentGroup);
if (result != null)
{
await requestContext.SendResult(result);
return;
}
}
catch (Exception ex)
// Get Current Reg Servers on CMS
RegisteredServersStore store = new RegisteredServersStore(conn);
ServerGroup parentGroup = store.DatabaseEngineServerGroup;
ListRegisteredServersResult result = GetChildrenfromParentGroup(parentGroup);
if (result != null)
{
// Exception related to connection/creation will only be caught here. Note that the outer catch will not catch them
await requestContext.SendError(ex);
await requestContext.SendResult(result);
return;
}
});
}
catch (Exception e)
{
// Exception related to run task will be captured here
await requestContext.SendError(e);
}
}
catch (Exception ex)
{
// Exception related to connection/creation will only be caught here. Note that the outer catch will not catch them
await requestContext.SendError(ex);
}
});
}
public async Task HandleAddRegisteredServerRequest(AddRegisteredServerParams cmsCreateParams, RequestContext<bool> requestContext)
{
Logger.Write(TraceEventType.Verbose, "HandleAddRegisteredServerRequest");
try
CmsTask = Task.Run(async () =>
{
CmsTask = Task.Run(async () =>
try
{
try
ServerConnection serverConn = ValidateAndCreateConnection(cmsCreateParams.ParentOwnerUri);
if (serverConn != null)
{
ServerConnection serverConn = ValidateAndCreateConnection(cmsCreateParams.ParentOwnerUri);
if (serverConn != null)
{
// Get Current Reg Servers
RegisteredServersStore store = new RegisteredServersStore(serverConn);
ServerGroup parentGroup = NavigateToServerGroup(store, cmsCreateParams.RelativePath);
RegisteredServerCollection servers = parentGroup.RegisteredServers;
// Add the new server (intentionally not cheching existence to reuse the exception message)
RegisteredServer registeredServer = new RegisteredServer(parentGroup, cmsCreateParams.RegisteredServerName);
registeredServer.Description = cmsCreateParams.RegisteredServerDescription;
registeredServer.ConnectionString = serverConn.ConnectionString;
registeredServer.ServerName = cmsCreateParams.RegisteredServerConnectionDetails.ServerName;
registeredServer.Create();
await requestContext.SendResult(true);
}
else
{
await requestContext.SendResult(false);
}
// Get Current Reg Servers
RegisteredServersStore store = new RegisteredServersStore(serverConn);
ServerGroup parentGroup = NavigateToServerGroup(store, cmsCreateParams.RelativePath);
RegisteredServerCollection servers = parentGroup.RegisteredServers;
// Add the new server (intentionally not cheching existence to reuse the exception message)
RegisteredServer registeredServer = new RegisteredServer(parentGroup, cmsCreateParams.RegisteredServerName);
registeredServer.Description = cmsCreateParams.RegisteredServerDescription;
registeredServer.ConnectionString = serverConn.ConnectionString;
registeredServer.ServerName = cmsCreateParams.RegisteredServerConnectionDetails.ServerName;
registeredServer.Create();
await requestContext.SendResult(true);
}
catch (Exception e)
else
{
await requestContext.SendError(e);
await requestContext.SendResult(false);
}
});
}
catch (Exception e)
{
await requestContext.SendError(e);
}
}
catch (Exception e)
{
await requestContext.SendError(e);
}
});
}
public async Task HandleListRegisteredServersRequest(ListRegisteredServersParams listServerParams, RequestContext<ListRegisteredServersResult> requestContext)
{
Logger.Write(TraceEventType.Verbose, "HandleListRegisteredServersRequest");
try
CmsTask = Task.Run(async () =>
{
CmsTask = Task.Run(async () =>
try
{
try
{
//Validate and create connection
ServerConnection serverConn = ValidateAndCreateConnection(listServerParams.ParentOwnerUri);
//Validate and create connection
ServerConnection serverConn = ValidateAndCreateConnection(listServerParams.ParentOwnerUri);
if (serverConn != null)
{
// Get registered Servers
RegisteredServersStore store = new RegisteredServersStore(serverConn);
ServerGroup parentGroup = NavigateToServerGroup(store, listServerParams.RelativePath);
ListRegisteredServersResult result = GetChildrenfromParentGroup(parentGroup);
await requestContext.SendResult(result);
}
else
{
await requestContext.SendResult(null);
}
}
catch (Exception e)
if (serverConn != null)
{
await requestContext.SendError(e);
// Get registered Servers
RegisteredServersStore store = new RegisteredServersStore(serverConn);
ServerGroup parentGroup = NavigateToServerGroup(store, listServerParams.RelativePath);
ListRegisteredServersResult result = GetChildrenfromParentGroup(parentGroup);
await requestContext.SendResult(result);
}
});
}
catch (Exception e)
{
await requestContext.SendError(e);
}
else
{
await requestContext.SendResult(null);
}
}
catch (Exception e)
{
await requestContext.SendError(e);
}
});
}
public async Task HandleRemoveRegisteredServerRequest(RemoveRegisteredServerParams removeServerParams, RequestContext<bool> requestContext)
{
Logger.Write(TraceEventType.Verbose, "HandleRemoveServerRequest");
try
CmsTask = Task.Run(async () =>
{
CmsTask = Task.Run(async () =>
try
{
try
// Validate and Connect
ServerConnection serverConn = ValidateAndCreateConnection(removeServerParams.ParentOwnerUri);
if (serverConn != null)
{
// Validate and Connect
ServerConnection serverConn = ValidateAndCreateConnection(removeServerParams.ParentOwnerUri);
if (serverConn != null)
// Get list of registered Servers
RegisteredServersStore store = new RegisteredServersStore(serverConn);
ServerGroup parentGroup = NavigateToServerGroup(store, removeServerParams.RelativePath, false);
if (parentGroup != null)
{
// Get list of registered Servers
RegisteredServersStore store = new RegisteredServersStore(serverConn);
ServerGroup parentGroup = NavigateToServerGroup(store, removeServerParams.RelativePath, false);
if (parentGroup != null)
{
RegisteredServer regServ = parentGroup.RegisteredServers.OfType<RegisteredServer>().FirstOrDefault(r => r.Name == removeServerParams.RegisteredServerName); // since duplicates are not allowed
regServ?.Drop();
await requestContext.SendResult(true);
}
}
else
{
await requestContext.SendResult(false);
RegisteredServer regServ = parentGroup.RegisteredServers.OfType<RegisteredServer>().FirstOrDefault(r => r.Name == removeServerParams.RegisteredServerName); // since duplicates are not allowed
regServ?.Drop();
await requestContext.SendResult(true);
}
}
catch (Exception e)
else
{
await requestContext.SendError(e);
await requestContext.SendResult(false);
}
});
}
catch (Exception e)
{
await requestContext.SendError(e);
}
}
catch (Exception e)
{
await requestContext.SendError(e);
}
});
}
public async Task HandleAddServerGroupRequest(AddServerGroupParams addServerGroupParams, RequestContext<bool> requestContext)
{
Logger.Write(TraceEventType.Verbose, "HandleAddServerGroupRequest");
try
CmsTask = Task.Run(async () =>
{
CmsTask = Task.Run(async () =>
try
{
try
ServerConnection serverConn = ValidateAndCreateConnection(addServerGroupParams.ParentOwnerUri);
if (serverConn != null)
{
ServerConnection serverConn = ValidateAndCreateConnection(addServerGroupParams.ParentOwnerUri);
if (serverConn != null)
ServerGroup parentGroup;
RegisteredServersStore store = new RegisteredServersStore(serverConn);
// It's a CMS server
if (string.IsNullOrEmpty(addServerGroupParams.RelativePath))
{
ServerGroup parentGroup;
RegisteredServersStore store = new RegisteredServersStore(serverConn);
// It's a CMS server
if (string.IsNullOrEmpty(addServerGroupParams.RelativePath))
{
parentGroup = store.DatabaseEngineServerGroup;
}
else
{
parentGroup = NavigateToServerGroup(store, addServerGroupParams.RelativePath);
}
// Add the new group (intentionally not cheching existence to reuse the exception message)
ServerGroup serverGroup = new ServerGroup(parentGroup, addServerGroupParams.GroupName)
{
Description = addServerGroupParams.GroupDescription
};
serverGroup.Create();
await requestContext.SendResult(true);
parentGroup = store.DatabaseEngineServerGroup;
}
else
{
await requestContext.SendResult(false);
parentGroup = NavigateToServerGroup(store, addServerGroupParams.RelativePath);
}
// Add the new group (intentionally not cheching existence to reuse the exception message)
ServerGroup serverGroup = new ServerGroup(parentGroup, addServerGroupParams.GroupName)
{
Description = addServerGroupParams.GroupDescription
};
serverGroup.Create();
await requestContext.SendResult(true);
}
catch (Exception e)
else
{
await requestContext.SendError(e);
await requestContext.SendResult(false);
}
});
}
catch (Exception e)
{
await requestContext.SendError(e);
}
}
catch (Exception e)
{
await requestContext.SendError(e);
}
});
}
public async Task HandleRemoveServerGroupRequest(RemoveServerGroupParams removeServerGroupParams, RequestContext<bool> requestContext)
{
Logger.Write(TraceEventType.Verbose, "HandleRemoveServerGroupRequest");
try
CmsTask = Task.Run(async () =>
{
CmsTask = Task.Run(async () =>
try
{
try
ServerConnection serverConn = ValidateAndCreateConnection(removeServerGroupParams.ParentOwnerUri);
if (serverConn != null)
{
ServerConnection serverConn = ValidateAndCreateConnection(removeServerGroupParams.ParentOwnerUri);
if (serverConn != null)
{
RegisteredServersStore store = new RegisteredServersStore(serverConn);
RegisteredServersStore store = new RegisteredServersStore(serverConn);
ServerGroup parentGroup = NavigateToServerGroup(store, removeServerGroupParams.RelativePath, false);
ServerGroup serverGrouptoRemove = parentGroup.ServerGroups.OfType<ServerGroup>().FirstOrDefault(r => r.Name == removeServerGroupParams.GroupName); // since duplicates are not allowed
serverGrouptoRemove?.Drop();
await requestContext.SendResult(true);
}
else
{
await requestContext.SendResult(false);
}
ServerGroup parentGroup = NavigateToServerGroup(store, removeServerGroupParams.RelativePath, false);
ServerGroup serverGrouptoRemove = parentGroup.ServerGroups.OfType<ServerGroup>().FirstOrDefault(r => r.Name == removeServerGroupParams.GroupName); // since duplicates are not allowed
serverGrouptoRemove?.Drop();
await requestContext.SendResult(true);
}
catch (Exception e)
else
{
await requestContext.SendError(e);
await requestContext.SendResult(false);
}
});
}
catch (Exception e)
{
await requestContext.SendError(e);
}
}
catch (Exception e)
{
await requestContext.SendError(e);
}
});
}
#endregion

65
src/Microsoft.SqlTools.ServiceLayer/Connection/ConnectionService.cs
View File

@@ -1119,16 +1119,8 @@ namespace Microsoft.SqlTools.ServiceLayer.Connection
RequestContext<bool> requestContext)
{
Logger.Write(TraceEventType.Verbose, "HandleCancelConnectRequest");
try
{
bool result = CancelConnect(cancelParams);
await requestContext.SendResult(result);
}
catch (Exception ex)
{
await requestContext.SendError(ex.ToString());
}
bool result = CancelConnect(cancelParams);
await requestContext.SendResult(result);
}
/// <summary>
@@ -1139,16 +1131,8 @@ namespace Microsoft.SqlTools.ServiceLayer.Connection
RequestContext<bool> requestContext)
{
Logger.Write(TraceEventType.Verbose, "HandleDisconnectRequest");
try
{
bool result = Instance.Disconnect(disconnectParams);
await requestContext.SendResult(result);
}
catch (Exception ex)
{
await requestContext.SendError(ex.ToString());
}
bool result = Instance.Disconnect(disconnectParams);
await requestContext.SendResult(result);
}
@@ -1403,34 +1387,27 @@ namespace Microsoft.SqlTools.ServiceLayer.Connection
string connectionString = string.Empty;
ConnectionInfo info;
SqlConnectionStringBuilder connStringBuilder;
try
// set connection string using connection uri if connection details are undefined
if (connStringParams.ConnectionDetails == null)
{
// set connection string using connection uri if connection details are undefined
if (connStringParams.ConnectionDetails == null)
{
TryFindConnection(connStringParams.OwnerUri, out info);
connStringBuilder = CreateConnectionStringBuilder(info.ConnectionDetails);
}
// set connection string using connection details
else
{
connStringBuilder = CreateConnectionStringBuilder(connStringParams.ConnectionDetails as ConnectionDetails);
}
if (!connStringParams.IncludePassword)
{
connStringBuilder.Password = ConnectionService.PasswordPlaceholder;
}
// default connection string application name to always be included unless set to false
if (!connStringParams.IncludeApplicationName.HasValue || connStringParams.IncludeApplicationName.Value == true)
{
connStringBuilder.ApplicationName = "sqlops-connection-string";
}
connectionString = connStringBuilder.ConnectionString;
TryFindConnection(connStringParams.OwnerUri, out info);
connStringBuilder = CreateConnectionStringBuilder(info.ConnectionDetails);
}
catch (Exception e)
// set connection string using connection details
else
{
await requestContext.SendError(e.ToString());
connStringBuilder = CreateConnectionStringBuilder(connStringParams.ConnectionDetails as ConnectionDetails);
}
if (!connStringParams.IncludePassword)
{
connStringBuilder.Password = ConnectionService.PasswordPlaceholder;
}
// default connection string application name to always be included unless set to false
if (!connStringParams.IncludeApplicationName.HasValue || connStringParams.IncludeApplicationName.Value == true)
{
connStringBuilder.ApplicationName = "sqlops-connection-string";
}
connectionString = connStringBuilder.ConnectionString;
await requestContext.SendResult(connectionString);
}

242
src/Microsoft.SqlTools.ServiceLayer/DacFx/DacFxService.cs
View File

@@ -69,24 +69,18 @@ namespace Microsoft.SqlTools.ServiceLayer.DacFx
/// Handles request to export a bacpac
/// </summary>
/// <returns></returns>
public async Task HandleExportRequest(ExportParams parameters, RequestContext<DacFxResult> requestContext)
public Task HandleExportRequest(ExportParams parameters, RequestContext<DacFxResult> requestContext)
{
try
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
if (connInfo != null)
{
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
if (connInfo != null)
{
ExportOperation operation = new ExportOperation(parameters, connInfo);
ExecuteOperation(operation, parameters, SR.ExportBacpacTaskName, requestContext);
}
}
catch (Exception e)
{
await requestContext.SendError(e);
ExportOperation operation = new ExportOperation(parameters, connInfo);
ExecuteOperation(operation, parameters, SR.ExportBacpacTaskName, requestContext);
}
return Task.CompletedTask;
}
/// <summary>
@@ -95,21 +89,14 @@ namespace Microsoft.SqlTools.ServiceLayer.DacFx
/// <returns></returns>
public async Task HandleImportRequest(ImportParams parameters, RequestContext<DacFxResult> requestContext)
{
try
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
if (connInfo != null)
{
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
if (connInfo != null)
{
ImportOperation operation = new ImportOperation(parameters, connInfo);
ExecuteOperation(operation, parameters, SR.ImportBacpacTaskName, requestContext);
}
}
catch (Exception e)
{
await requestContext.SendError(e);
ImportOperation operation = new ImportOperation(parameters, connInfo);
ExecuteOperation(operation, parameters, SR.ImportBacpacTaskName, requestContext);
}
}
@@ -117,51 +104,39 @@ namespace Microsoft.SqlTools.ServiceLayer.DacFx
/// Handles request to extract a dacpac
/// </summary>
/// <returns></returns>
public async Task HandleExtractRequest(ExtractParams parameters, RequestContext<DacFxResult> requestContext)
public Task HandleExtractRequest(ExtractParams parameters, RequestContext<DacFxResult> requestContext)
{
try
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
if (connInfo != null)
{
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
if (connInfo != null)
{
// Set connection details database name to ensure the connection string gets created correctly for DW(extract doesn't work if connection is to master)
connInfo.ConnectionDetails.DatabaseName = parameters.DatabaseName;
ExtractOperation operation = new ExtractOperation(parameters, connInfo);
string taskName = parameters.ExtractTarget == DacExtractTarget.DacPac ? SR.ExtractDacpacTaskName : SR.ProjectExtractTaskName;
ExecuteOperation(operation, parameters, taskName, requestContext);
}
}
catch (Exception e)
{
await requestContext.SendError(e);
// Set connection details database name to ensure the connection string gets created correctly for DW(extract doesn't work if connection is to master)
connInfo.ConnectionDetails.DatabaseName = parameters.DatabaseName;
ExtractOperation operation = new ExtractOperation(parameters, connInfo);
string taskName = parameters.ExtractTarget == DacExtractTarget.DacPac ? SR.ExtractDacpacTaskName : SR.ProjectExtractTaskName;
ExecuteOperation(operation, parameters, taskName, requestContext);
}
return Task.CompletedTask;
}
/// <summary>
/// Handles request to deploy a dacpac
/// </summary>
/// <returns></returns>
public async Task HandleDeployRequest(DeployParams parameters, RequestContext<DacFxResult> requestContext)
public Task HandleDeployRequest(DeployParams parameters, RequestContext<DacFxResult> requestContext)
{
try
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
if (connInfo != null)
{
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
if (connInfo != null)
{
DeployOperation operation = new DeployOperation(parameters, connInfo);
ExecuteOperation(operation, parameters, SR.DeployDacpacTaskName, requestContext);
}
}
catch (Exception e)
{
await requestContext.SendError(e);
DeployOperation operation = new DeployOperation(parameters, connInfo);
ExecuteOperation(operation, parameters, SR.DeployDacpacTaskName, requestContext);
}
return Task.CompletedTask;
}
/// <summary>
@@ -170,36 +145,29 @@ namespace Microsoft.SqlTools.ServiceLayer.DacFx
/// <returns></returns>
public async Task HandleGenerateDeployScriptRequest(GenerateDeployScriptParams parameters, RequestContext<DacFxResult> requestContext)
{
try
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
if (connInfo != null)
{
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
if (connInfo != null)
GenerateDeployScriptOperation operation = new GenerateDeployScriptOperation(parameters, connInfo);
SqlTask sqlTask = null;
TaskMetadata metadata = new TaskMetadata();
metadata.TaskOperation = operation;
metadata.TaskExecutionMode = parameters.TaskExecutionMode;
metadata.ServerName = connInfo.ConnectionDetails.ServerName;
metadata.DatabaseName = parameters.DatabaseName;
metadata.Name = SR.GenerateScriptTaskName;
sqlTask = SqlTaskManagerInstance.CreateAndRun<SqlTask>(metadata);
await requestContext.SendResult(new DacFxResult()
{
GenerateDeployScriptOperation operation = new GenerateDeployScriptOperation(parameters, connInfo);
SqlTask sqlTask = null;
TaskMetadata metadata = new TaskMetadata();
metadata.TaskOperation = operation;
metadata.TaskExecutionMode = parameters.TaskExecutionMode;
metadata.ServerName = connInfo.ConnectionDetails.ServerName;
metadata.DatabaseName = parameters.DatabaseName;
metadata.Name = SR.GenerateScriptTaskName;
sqlTask = SqlTaskManagerInstance.CreateAndRun<SqlTask>(metadata);
await requestContext.SendResult(new DacFxResult()
{
OperationId = operation.OperationId,
Success = true,
ErrorMessage = string.Empty
});
}
}
catch (Exception e)
{
await requestContext.SendError(e);
OperationId = operation.OperationId,
Success = true,
ErrorMessage = string.Empty
});
}
}
@@ -209,29 +177,22 @@ namespace Microsoft.SqlTools.ServiceLayer.DacFx
/// <returns></returns>
public async Task HandleGenerateDeployPlanRequest(GenerateDeployPlanParams parameters, RequestContext<GenerateDeployPlanRequestResult> requestContext)
{
try
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
if (connInfo != null)
{
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
if (connInfo != null)
{
GenerateDeployPlanOperation operation = new GenerateDeployPlanOperation(parameters, connInfo);
operation.Execute(parameters.TaskExecutionMode);
GenerateDeployPlanOperation operation = new GenerateDeployPlanOperation(parameters, connInfo);
operation.Execute(parameters.TaskExecutionMode);
await requestContext.SendResult(new GenerateDeployPlanRequestResult()
{
OperationId = operation.OperationId,
Success = true,
ErrorMessage = string.Empty,
Report = operation.DeployReport
});
}
}
catch (Exception e)
{
await requestContext.SendError(e);
await requestContext.SendResult(new GenerateDeployPlanRequestResult()
{
OperationId = operation.OperationId,
Success = true,
ErrorMessage = string.Empty,
Report = operation.DeployReport
});
}
}
@@ -241,30 +202,23 @@ namespace Microsoft.SqlTools.ServiceLayer.DacFx
/// <returns></returns>
public async Task HandleGetOptionsFromProfileRequest(GetOptionsFromProfileParams parameters, RequestContext<DacFxOptionsResult> requestContext)
{
try
DeploymentOptions options = null;
if (parameters.ProfilePath != null)
{
DeploymentOptions options = null;
if (parameters.ProfilePath != null)
DacProfile profile = DacProfile.Load(parameters.ProfilePath);
if (profile.DeployOptions != null)
{
DacProfile profile = DacProfile.Load(parameters.ProfilePath);
if (profile.DeployOptions != null)
{
options = DeploymentOptions.GetDefaultPublishOptions();
await options.InitializeFromProfile(profile.DeployOptions, parameters.ProfilePath);
}
options = DeploymentOptions.GetDefaultPublishOptions();
await options.InitializeFromProfile(profile.DeployOptions, parameters.ProfilePath);
}
}
await requestContext.SendResult(new DacFxOptionsResult()
{
DeploymentOptions = options,
Success = true,
ErrorMessage = string.Empty,
});
}
catch (Exception e)
await requestContext.SendResult(new DacFxOptionsResult()
{
await requestContext.SendError(e);
}
DeploymentOptions = options,
Success = true,
ErrorMessage = string.Empty,
});
}
/// <summary>
@@ -273,17 +227,10 @@ namespace Microsoft.SqlTools.ServiceLayer.DacFx
/// <returns></returns>
public async Task HandleValidateStreamingJobRequest(ValidateStreamingJobParams parameters, RequestContext<ValidateStreamingJobResult> requestContext)
{
try
{
ValidateStreamingJobOperation operation = new ValidateStreamingJobOperation(parameters);
ValidateStreamingJobResult result = operation.ValidateQuery();
ValidateStreamingJobOperation operation = new ValidateStreamingJobOperation(parameters);
ValidateStreamingJobResult result = operation.ValidateQuery();
await requestContext.SendResult(result);
}
catch (Exception e)
{
await requestContext.SendError(e);
}
await requestContext.SendResult(result);
}
/// <summary>
@@ -317,18 +264,11 @@ namespace Microsoft.SqlTools.ServiceLayer.DacFx
public async Task HandleParseTSqlScriptRequest(ParseTSqlScriptRequestParams requestParams, RequestContext<ParseTSqlScriptResult> requestContext)
{
try
var script = System.IO.File.ReadAllText(requestParams.FilePath);
await requestContext.SendResult(new ParseTSqlScriptResult()
{
var script = System.IO.File.ReadAllText(requestParams.FilePath);
await requestContext.SendResult(new ParseTSqlScriptResult()
{
ContainsCreateTableStatement = DacTableDesigner.ScriptContainsCreateTableStatements(script, requestParams.DatabaseSchemaProvider)
});
}
catch (Exception e)
{
await requestContext.SendError(e);
}
ContainsCreateTableStatement = DacTableDesigner.ScriptContainsCreateTableStatements(script, requestParams.DatabaseSchemaProvider)
});
}
public async Task HandleGenerateTSqlModelRequest(GenerateTSqlModelParams requestParams, RequestContext<ResultStatus> requestContext)

102
src/Microsoft.SqlTools.ServiceLayer/DisasterRecovery/DisasterRecoveryService.cs
View File

@@ -137,35 +137,28 @@ namespace Microsoft.SqlTools.ServiceLayer.DisasterRecovery
DefaultDatabaseInfoParams optionsParams,
RequestContext<BackupConfigInfoResponse> requestContext)
{
try
{
var response = new BackupConfigInfoResponse();
ConnectionInfo connInfo;
DisasterRecoveryService.ConnectionServiceInstance.TryFindConnection(
optionsParams.OwnerUri,
out connInfo);
var response = new BackupConfigInfoResponse();
ConnectionInfo connInfo;
DisasterRecoveryService.ConnectionServiceInstance.TryFindConnection(
optionsParams.OwnerUri,
out connInfo);
if (connInfo != null)
if (connInfo != null)
{
using (DatabaseTaskHelper helper = AdminService.CreateDatabaseTaskHelper(connInfo, databaseExists: true))
{
using (DatabaseTaskHelper helper = AdminService.CreateDatabaseTaskHelper(connInfo, databaseExists: true))
using (SqlConnection sqlConn = ConnectionService.OpenSqlConnection(connInfo, "Backup"))
{
using (SqlConnection sqlConn = ConnectionService.OpenSqlConnection(connInfo, "Backup"))
if (sqlConn != null && !connInfo.IsCloud)
{
if (sqlConn != null && !connInfo.IsCloud)
{
BackupConfigInfo backupConfigInfo = this.GetBackupConfigInfo(helper.DataContainer, sqlConn, sqlConn.Database);
response.BackupConfigInfo = backupConfigInfo;
}
BackupConfigInfo backupConfigInfo = this.GetBackupConfigInfo(helper.DataContainer, sqlConn, sqlConn.Database);
response.BackupConfigInfo = backupConfigInfo;
}
}
}
}
await requestContext.SendResult(response);
}
catch (Exception ex)
{
await requestContext.SendError(ex.ToString());
}
await requestContext.SendResult(response);
}
/// <summary>
@@ -322,54 +315,47 @@ namespace Microsoft.SqlTools.ServiceLayer.DisasterRecovery
BackupParams backupParams,
RequestContext<BackupResponse> requestContext)
{
try
BackupResponse response = new BackupResponse();
ConnectionInfo connInfo;
bool supported = IsBackupRestoreOperationSupported(backupParams.OwnerUri, out connInfo);
if (supported && connInfo != null)
{
BackupResponse response = new BackupResponse();
ConnectionInfo connInfo;
bool supported = IsBackupRestoreOperationSupported(backupParams.OwnerUri, out connInfo);
if (supported && connInfo != null)
DatabaseTaskHelper helper = AdminService.CreateDatabaseTaskHelper(connInfo, databaseExists: true);
// Open a new connection to use for the backup, which will be closed when the backup task is completed
// (or an error occurs)
SqlConnection sqlConn = ConnectionService.OpenSqlConnection(connInfo, "Backup");
try
{
DatabaseTaskHelper helper = AdminService.CreateDatabaseTaskHelper(connInfo, databaseExists: true);
// Open a new connection to use for the backup, which will be closed when the backup task is completed
// (or an error occurs)
SqlConnection sqlConn = ConnectionService.OpenSqlConnection(connInfo, "Backup");
try
BackupOperation backupOperation = CreateBackupOperation(helper.DataContainer, sqlConn, backupParams.BackupInfo);
// create task metadata
TaskMetadata metadata = TaskMetadata.Create(backupParams, SR.BackupTaskName, backupOperation, ConnectionServiceInstance);
SqlTask sqlTask = SqlTaskManagerInstance.CreateAndRun<SqlTask>(metadata);
sqlTask.StatusChanged += (object sender, TaskEventArgs<SqlTaskStatus> e) =>
{
BackupOperation backupOperation = CreateBackupOperation(helper.DataContainer, sqlConn, backupParams.BackupInfo);
// create task metadata
TaskMetadata metadata = TaskMetadata.Create(backupParams, SR.BackupTaskName, backupOperation, ConnectionServiceInstance);
SqlTask sqlTask = SqlTaskManagerInstance.CreateAndRun<SqlTask>(metadata);
sqlTask.StatusChanged += (object sender, TaskEventArgs<SqlTaskStatus> e) =>
SqlTask sqlTask = e.SqlTask;
if (sqlTask != null && sqlTask.IsCompleted)
{
SqlTask sqlTask = e.SqlTask;
if (sqlTask != null && sqlTask.IsCompleted)
{
sqlConn.Dispose();
}
};
}
catch
{
// Ensure that the connection is closed if any error occurs while starting up the task
sqlConn.Dispose();
throw;
}
sqlConn.Dispose();
}
};
}
else
catch
{
response.Result = false;
// Ensure that the connection is closed if any error occurs while starting up the task
sqlConn.Dispose();
throw;
}
await requestContext.SendResult(response);
}
catch (Exception ex)
else
{
await requestContext.SendError(ex.ToString());
response.Result = false;
}
await requestContext.SendResult(response);
}
private bool IsBackupRestoreOperationSupported(string ownerUri, out ConnectionInfo connectionInfo)

105
src/Microsoft.SqlTools.ServiceLayer/EditData/EditDataService.cs
View File

@@ -91,18 +91,11 @@ namespace Microsoft.SqlTools.ServiceLayer.EditData
internal async Task HandleSessionRequest<TResult>(SessionOperationParams sessionParams,
RequestContext<TResult> requestContext, Func<EditSession, TResult> sessionOperation)
{
try
{
EditSession editSession = GetActiveSessionOrThrow(sessionParams.OwnerUri);
EditSession editSession = GetActiveSessionOrThrow(sessionParams.OwnerUri);
// Get the result from execution of the editSession operation
TResult result = sessionOperation(editSession);
await requestContext.SendResult(result);
}
catch (Exception e)
{
await requestContext.SendError(e.Message);
}
// Get the result from execution of the editSession operation
TResult result = sessionOperation(editSession);
await requestContext.SendResult(result);
}
internal Task HandleCreateRowRequest(EditCreateRowParams createParams,
@@ -125,26 +118,18 @@ namespace Microsoft.SqlTools.ServiceLayer.EditData
internal async Task HandleDisposeRequest(EditDisposeParams disposeParams,
RequestContext<EditDisposeResult> requestContext)
{
try
{
// Sanity check the owner URI
Validate.IsNotNullOrWhitespaceString(nameof(disposeParams.OwnerUri), disposeParams.OwnerUri);
// Sanity check the owner URI
Validate.IsNotNullOrWhitespaceString(nameof(disposeParams.OwnerUri), disposeParams.OwnerUri);
// Attempt to remove the editSession
EditSession editSession;
if (!ActiveSessions.TryRemove(disposeParams.OwnerUri, out editSession))
{
await requestContext.SendError(SR.EditDataSessionNotFound);
return;
}
// Everything was successful, return success
await requestContext.SendResult(new EditDisposeResult());
}
catch (Exception e)
// Attempt to remove the editSession
EditSession editSession;
if (!ActiveSessions.TryRemove(disposeParams.OwnerUri, out editSession))
{
await requestContext.SendError(e.Message);
throw new Exception(SR.EditDataSessionNotFound);
}
// Everything was successful, return success
await requestContext.SendResult(new EditDisposeResult());
}
internal async Task HandleInitializeRequest(EditInitializeParams initParams,
@@ -157,32 +142,25 @@ namespace Microsoft.SqlTools.ServiceLayer.EditData
EditSession.Connector connector = () => connectionService.GetOrOpenConnection(initParams.OwnerUri, ConnectionType.Edit, alwaysPersistSecurity: true);
EditSession.QueryRunner queryRunner = q => SessionInitializeQueryRunner(initParams.OwnerUri, context, q);
try
// Make sure we have info to process this request
Validate.IsNotNullOrWhitespaceString(nameof(initParams.OwnerUri), initParams.OwnerUri);
Validate.IsNotNullOrWhitespaceString(nameof(initParams.ObjectName), initParams.ObjectName);
Validate.IsNotNullOrWhitespaceString(nameof(initParams.ObjectType), initParams.ObjectType);
// Create a session and add it to the session list
EditSession session = new EditSession(metadataFactory);
if (!ActiveSessions.TryAdd(initParams.OwnerUri, session))
{
// Make sure we have info to process this request
Validate.IsNotNullOrWhitespaceString(nameof(initParams.OwnerUri), initParams.OwnerUri);
Validate.IsNotNullOrWhitespaceString(nameof(initParams.ObjectName), initParams.ObjectName);
Validate.IsNotNullOrWhitespaceString(nameof(initParams.ObjectType), initParams.ObjectType);
// Create a session and add it to the session list
EditSession session = new EditSession(metadataFactory);
if (!ActiveSessions.TryAdd(initParams.OwnerUri, session))
{
throw new InvalidOperationException(SR.EditDataSessionAlreadyExists);
}
context.ResultSetHandler = (ResultSetEventParams resultSetEventParams) => { session.UpdateColumnInformationWithMetadata(resultSetEventParams.ResultSetSummary.ColumnInfo); };
// Initialize the session
session.Initialize(initParams, connector, queryRunner, executionSuccessHandler, executionFailureHandler);
// Send the result
await requestContext.SendResult(new EditInitializeResult());
}
catch (Exception e)
{
await requestContext.SendError(e.Message);
throw new InvalidOperationException(SR.EditDataSessionAlreadyExists);
}
context.ResultSetHandler = (ResultSetEventParams resultSetEventParams) => { session.UpdateColumnInformationWithMetadata(resultSetEventParams.ResultSetSummary.ColumnInfo); };
// Initialize the session
session.Initialize(initParams, connector, queryRunner, executionSuccessHandler, executionFailureHandler);
// Send the result
await requestContext.SendResult(new EditInitializeResult());
}
internal Task HandleRevertCellRequest(EditRevertCellParams revertParams,
@@ -205,23 +183,16 @@ namespace Microsoft.SqlTools.ServiceLayer.EditData
internal async Task HandleSubsetRequest(EditSubsetParams subsetParams,
RequestContext<EditSubsetResult> requestContext)
{
try
{
EditSession session = GetActiveSessionOrThrow(subsetParams.OwnerUri);
EditSession session = GetActiveSessionOrThrow(subsetParams.OwnerUri);
EditRow[] rows = await session.GetRows(subsetParams.RowStartIndex, subsetParams.RowCount);
EditSubsetResult result = new EditSubsetResult
{
RowCount = rows.Length,
Subset = rows
};
await requestContext.SendResult(result);
}
catch (Exception e)
EditRow[] rows = await session.GetRows(subsetParams.RowStartIndex, subsetParams.RowCount);
EditSubsetResult result = new EditSubsetResult
{
await requestContext.SendError(e.Message);
}
RowCount = rows.Length,
Subset = rows
};
await requestContext.SendResult(result);
}
internal Task HandleUpdateCellRequest(EditUpdateCellParams updateParams,

70
src/Microsoft.SqlTools.ServiceLayer/ExecutionPlan/ExecutionPlanService.cs
View File

@@ -55,18 +55,11 @@ namespace Microsoft.SqlTools.ServiceLayer.ExecutionPlan
private async Task HandleGetExecutionPlan(GetExecutionPlanParams requestParams, RequestContext<GetExecutionPlanResult> requestContext)
{
try
var plans = ExecutionPlanGraphUtils.CreateShowPlanGraph(requestParams.GraphInfo.GraphFileContent, "");
await requestContext.SendResult(new GetExecutionPlanResult
{
var plans = ExecutionPlanGraphUtils.CreateShowPlanGraph(requestParams.GraphInfo.GraphFileContent, "");
await requestContext.SendResult(new GetExecutionPlanResult
{
Graphs = plans
});
}
catch (Exception e)
{
await requestContext.SendError(e.ToString());
}
Graphs = plans
});
}
/// <summary>
@@ -76,39 +69,32 @@ namespace Microsoft.SqlTools.ServiceLayer.ExecutionPlan
ExecutionPlanComparisonParams requestParams,
RequestContext<ExecutionPlanComparisonResult> requestContext)
{
try
var nodeBuilder = new XmlPlanNodeBuilder(ShowPlanType.Unknown);
var firstPlanXml = nodeBuilder.GetSingleStatementXml(requestParams.FirstExecutionPlanGraphInfo.GraphFileContent, requestParams.FirstExecutionPlanGraphInfo.PlanIndexInFile);
var firstGraphSet = ShowPlanGraph.ParseShowPlanXML(firstPlanXml, ShowPlanType.Unknown);
var firstRootNode = firstGraphSet?[0]?.Root;
var secondPlanXml = nodeBuilder.GetSingleStatementXml(requestParams.SecondExecutionPlanGraphInfo.GraphFileContent, requestParams.SecondExecutionPlanGraphInfo.PlanIndexInFile);
var secondGraphSet = ShowPlanGraph.ParseShowPlanXML(secondPlanXml, ShowPlanType.Unknown);
var secondRootNode = secondGraphSet?[0]?.Root;
var manager = new SkeletonManager();
var firstSkeletonNode = manager.CreateSkeleton(firstRootNode);
var secondSkeletonNode = manager.CreateSkeleton(secondRootNode);
manager.ColorMatchingSections(firstSkeletonNode, secondSkeletonNode, requestParams.IgnoreDatabaseName);
var firstGraphComparisonResultDTO = firstSkeletonNode.ConvertToDTO();
var secondGraphComparisonResultDTO = secondSkeletonNode.ConvertToDTO();
ExecutionPlanGraphUtils.CopyMatchingNodesIntoSkeletonDTO(firstGraphComparisonResultDTO, secondGraphComparisonResultDTO);
ExecutionPlanGraphUtils.CopyMatchingNodesIntoSkeletonDTO(secondGraphComparisonResultDTO, firstGraphComparisonResultDTO);
var result = new ExecutionPlanComparisonResult()
{
var nodeBuilder = new XmlPlanNodeBuilder(ShowPlanType.Unknown);
var firstPlanXml = nodeBuilder.GetSingleStatementXml(requestParams.FirstExecutionPlanGraphInfo.GraphFileContent, requestParams.FirstExecutionPlanGraphInfo.PlanIndexInFile);
var firstGraphSet = ShowPlanGraph.ParseShowPlanXML(firstPlanXml, ShowPlanType.Unknown);
var firstRootNode = firstGraphSet?[0]?.Root;
FirstComparisonResult = firstGraphComparisonResultDTO,
SecondComparisonResult = secondGraphComparisonResultDTO
};
var secondPlanXml = nodeBuilder.GetSingleStatementXml(requestParams.SecondExecutionPlanGraphInfo.GraphFileContent, requestParams.SecondExecutionPlanGraphInfo.PlanIndexInFile);
var secondGraphSet = ShowPlanGraph.ParseShowPlanXML(secondPlanXml, ShowPlanType.Unknown);
var secondRootNode = secondGraphSet?[0]?.Root;
var manager = new SkeletonManager();
var firstSkeletonNode = manager.CreateSkeleton(firstRootNode);
var secondSkeletonNode = manager.CreateSkeleton(secondRootNode);
manager.ColorMatchingSections(firstSkeletonNode, secondSkeletonNode, requestParams.IgnoreDatabaseName);
var firstGraphComparisonResultDTO = firstSkeletonNode.ConvertToDTO();
var secondGraphComparisonResultDTO = secondSkeletonNode.ConvertToDTO();
ExecutionPlanGraphUtils.CopyMatchingNodesIntoSkeletonDTO(firstGraphComparisonResultDTO, secondGraphComparisonResultDTO);
ExecutionPlanGraphUtils.CopyMatchingNodesIntoSkeletonDTO(secondGraphComparisonResultDTO, firstGraphComparisonResultDTO);
var result = new ExecutionPlanComparisonResult()
{
FirstComparisonResult = firstGraphComparisonResultDTO,
SecondComparisonResult = secondGraphComparisonResultDTO
};
await requestContext.SendResult(result);
}
catch (Exception e)
{
await requestContext.SendError(e.ToString());
}
await requestContext.SendResult(result);
}
/// <summary>

35
src/Microsoft.SqlTools.ServiceLayer/Formatter/TSqlFormatterService.cs
View File

@@ -78,23 +78,17 @@ namespace Microsoft.SqlTools.ServiceLayer.Formatter
public async Task HandleDocFormatRequest(DocumentFormattingParams docFormatParams, RequestContext<TextEdit[]> requestContext)
{
Func<Task<TextEdit[]>> requestHandler = () =>
{
return FormatAndReturnEdits(docFormatParams);
};
await HandleRequest(requestHandler, requestContext, "HandleDocFormatRequest");
Logger.Verbose("HandleDocFormatRequest");
TextEdit[] result = await FormatAndReturnEdits(docFormatParams);
await requestContext.SendResult(result);
DocumentStatusHelper.SendTelemetryEvent(requestContext, CreateTelemetryProps(isDocFormat: true));
}
public async Task HandleDocRangeFormatRequest(DocumentRangeFormattingParams docRangeFormatParams, RequestContext<TextEdit[]> requestContext)
{
Func<Task<TextEdit[]>> requestHandler = () =>
{
return FormatRangeAndReturnEdits(docRangeFormatParams);
};
await HandleRequest(requestHandler, requestContext, "HandleDocRangeFormatRequest");
Logger.Verbose("HandleDocRangeFormatRequest");
TextEdit[] result = await FormatRangeAndReturnEdits(docRangeFormatParams);
await requestContext.SendResult(result);
DocumentStatusHelper.SendTelemetryEvent(requestContext, CreateTelemetryProps(isDocFormat: false));
}
private static TelemetryProperties CreateTelemetryProps(bool isDocFormat)
@@ -230,23 +224,6 @@ namespace Microsoft.SqlTools.ServiceLayer.Formatter
return edit;
}
private async Task HandleRequest<T>(Func<Task<T>> handler, RequestContext<T> requestContext, string requestType)
{
Logger.Write(TraceEventType.Verbose, requestType);
try
{
T result = await handler();
await requestContext.SendResult(result);
}
catch (Exception ex)
{
await requestContext.SendError(ex.ToString());
}
}
public string Format(TextReader input)
{
string originalSql = input.ReadToEnd();

164
src/Microsoft.SqlTools.ServiceLayer/LanguageExtensibility/ExternalLanguageService.cs
View File

@@ -78,34 +78,26 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageExtensibility
public async Task HandleExternalLanguageDeleteRequest(ExternalLanguageDeleteRequestParams parameters, RequestContext<ExternalLanguageDeleteResponseParams> requestContext)
{
Logger.Write(TraceEventType.Verbose, "HandleExternalLanguageDeleteRequest");
try
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
ExternalLanguageDeleteResponseParams response = new ExternalLanguageDeleteResponseParams
{
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
ExternalLanguageDeleteResponseParams response = new ExternalLanguageDeleteResponseParams
{
};
};
if (connInfo == null)
{
await requestContext.SendError(new Exception(SR.ConnectionServiceDbErrorDefaultNotConnected(parameters.OwnerUri)));
}
else
{
using (IDbConnection dbConnection = ConnectionService.OpenSqlConnection(connInfo))
{
ExternalLanguageOperations.DeleteLanguage(dbConnection, parameters.LanguageName);
}
await requestContext.SendResult(response);
}
}
catch (Exception e)
if (connInfo == null)
{
// Exception related to run task will be captured here
await requestContext.SendError(e);
await requestContext.SendError(new Exception(SR.ConnectionServiceDbErrorDefaultNotConnected(parameters.OwnerUri)));
}
else
{
using (IDbConnection dbConnection = ConnectionService.OpenSqlConnection(connInfo))
{
ExternalLanguageOperations.DeleteLanguage(dbConnection, parameters.LanguageName);
}
await requestContext.SendResult(response);
}
}
@@ -118,34 +110,26 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageExtensibility
public async Task HandleExternalLanguageUpdateRequest(ExternalLanguageUpdateRequestParams parameters, RequestContext<ExternalLanguageUpdateResponseParams> requestContext)
{
Logger.Write(TraceEventType.Verbose, "HandleExternalLanguageUpdateRequest");
try
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
ExternalLanguageUpdateResponseParams response = new ExternalLanguageUpdateResponseParams
{
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
ExternalLanguageUpdateResponseParams response = new ExternalLanguageUpdateResponseParams
{
};
};
if (connInfo == null)
{
await requestContext.SendError(new Exception(SR.ConnectionServiceDbErrorDefaultNotConnected(parameters.OwnerUri)));
}
else
{
using (IDbConnection dbConnection = ConnectionService.OpenSqlConnection(connInfo))
{
ExternalLanguageOperations.UpdateLanguage(dbConnection, parameters.Language);
}
await requestContext.SendResult(response);
}
if (connInfo == null)
{
await requestContext.SendError(new Exception(SR.ConnectionServiceDbErrorDefaultNotConnected(parameters.OwnerUri)));
}
catch (Exception e)
else
{
// Exception related to run task will be captured here
await requestContext.SendError(e);
using (IDbConnection dbConnection = ConnectionService.OpenSqlConnection(connInfo))
{
ExternalLanguageOperations.UpdateLanguage(dbConnection, parameters.Language);
}
await requestContext.SendResult(response);
}
}
@@ -158,35 +142,27 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageExtensibility
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
{
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
ExternalLanguageStatusResponseParams response = new ExternalLanguageStatusResponseParams
{
Status = false,
};
Status = false,
};
if (connInfo == null)
{
await requestContext.SendError(new Exception(SR.ConnectionServiceDbErrorDefaultNotConnected(parameters.OwnerUri)));
}
else
{
using (IDbConnection dbConnection = ConnectionService.OpenSqlConnection(connInfo))
{
response.Status = ExternalLanguageOperations.GetLanguageStatus(dbConnection, parameters.LanguageName);
}
await requestContext.SendResult(response);
}
if (connInfo == null)
{
await requestContext.SendError(new Exception(SR.ConnectionServiceDbErrorDefaultNotConnected(parameters.OwnerUri)));
}
catch (Exception e)
else
{
// Exception related to run task will be captured here
await requestContext.SendError(e);
using (IDbConnection dbConnection = ConnectionService.OpenSqlConnection(connInfo))
{
response.Status = ExternalLanguageOperations.GetLanguageStatus(dbConnection, parameters.LanguageName);
}
await requestContext.SendResult(response);
}
}
@@ -199,34 +175,26 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageExtensibility
public async Task HandleExternalLanguageListRequest(ExternalLanguageListRequestParams parameters, RequestContext<ExternalLanguageListResponseParams> requestContext)
{
Logger.Write(TraceEventType.Verbose, "HandleExternalLanguageListRequest");
try
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
ExternalLanguageListResponseParams response = new ExternalLanguageListResponseParams
{
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
ExternalLanguageListResponseParams response = new ExternalLanguageListResponseParams
{
};
};
if (connInfo == null)
{
await requestContext.SendError(new Exception(SR.ConnectionServiceDbErrorDefaultNotConnected(parameters.OwnerUri)));
}
else
{
using (IDbConnection dbConnection = ConnectionService.OpenSqlConnection(connInfo))
{
response.Languages = ExternalLanguageOperations.GetLanguages(dbConnection);
}
await requestContext.SendResult(response);
}
if (connInfo == null)
{
await requestContext.SendError(new Exception(SR.ConnectionServiceDbErrorDefaultNotConnected(parameters.OwnerUri)));
}
catch (Exception e)
else
{
// Exception related to run task will be captured here
await requestContext.SendError(e);
using (IDbConnection dbConnection = ConnectionService.OpenSqlConnection(connInfo))
{
response.Languages = ExternalLanguageOperations.GetLanguages(dbConnection);
}
await requestContext.SendResult(response);
}
}
}

306
src/Microsoft.SqlTools.ServiceLayer/LanguageServices/LanguageService.cs
View File

@@ -315,49 +315,41 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices
/// <returns></returns>
internal async Task HandleCompletionExtLoadRequest(CompletionExtensionParams param, RequestContext<bool> requestContext)
{
try
//register the new assembly
var serviceProvider = (ExtensionServiceProvider)ServiceHostInstance.ServiceProvider;
var assembly = AssemblyLoadContext.Default.LoadFromAssemblyPath(param.AssemblyPath);
var assemblies = new Assembly[] { assembly };
serviceProvider.AddAssembliesToConfiguration(assemblies);
foreach (var ext in serviceProvider.GetServices<ICompletionExtension>())
{
//register the new assembly
var serviceProvider = (ExtensionServiceProvider)ServiceHostInstance.ServiceProvider;
var assembly = AssemblyLoadContext.Default.LoadFromAssemblyPath(param.AssemblyPath);
var assemblies = new Assembly[] { assembly };
serviceProvider.AddAssembliesToConfiguration(assemblies);
foreach (var ext in serviceProvider.GetServices<ICompletionExtension>())
var cancellationTokenSource = new CancellationTokenSource(ExtensionLoadingTimeout);
var cancellationToken = cancellationTokenSource.Token;
string extName = ext.Name;
string extTypeName = ext.GetType().FullName;
if (extTypeName != param.TypeName)
{
var cancellationTokenSource = new CancellationTokenSource(ExtensionLoadingTimeout);
var cancellationToken = cancellationTokenSource.Token;
string extName = ext.Name;
string extTypeName = ext.GetType().FullName;
if (extTypeName != param.TypeName)
{
continue;
}
if (!CheckIfAssemblyShouldBeLoaded(param.AssemblyPath, extTypeName))
{
await requestContext.SendError(string.Format("Skip loading {0} because it's already loaded", param.AssemblyPath));
return;
}
await ext.Initialize(param.Properties, cancellationToken).WithTimeout(ExtensionLoadingTimeout);
cancellationTokenSource.Dispose();
if (!string.IsNullOrEmpty(extName))
{
completionExtensions[extName] = ext;
await requestContext.SendResult(true);
return;
}
else
{
await requestContext.SendError(string.Format("Skip loading an unnamed completion extension from {0}", param.AssemblyPath));
return;
}
continue;
}
if (!CheckIfAssemblyShouldBeLoaded(param.AssemblyPath, extTypeName))
{
await requestContext.SendError(string.Format("Skip loading {0} because it's already loaded", param.AssemblyPath));
return;
}
await ext.Initialize(param.Properties, cancellationToken).WithTimeout(ExtensionLoadingTimeout);
cancellationTokenSource.Dispose();
if (!string.IsNullOrEmpty(extName))
{
completionExtensions[extName] = ext;
await requestContext.SendResult(true);
return;
}
else
{
await requestContext.SendError(string.Format("Skip loading an unnamed completion extension from {0}", param.AssemblyPath));
return;
}
}
catch (Exception ex)
{
await requestContext.SendError(ex.Message);
return;
}
await requestContext.SendError(string.Format("Couldn't discover completion extension with type {0} in {1}", param.TypeName, param.AssemblyPath));
@@ -399,30 +391,23 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices
/// <returns></returns>
internal async Task HandleSyntaxParseRequest(SyntaxParseParams param, RequestContext<SyntaxParseResult> requestContext)
{
try
ParseResult result = Parser.Parse(param.Query);
SyntaxParseResult syntaxResult = new SyntaxParseResult();
if (result != null && !result.Errors.Any())
{
ParseResult result = Parser.Parse(param.Query);
SyntaxParseResult syntaxResult = new SyntaxParseResult();
if (result != null && !result.Errors.Any())
{
syntaxResult.Parseable = true;
}
else
{
syntaxResult.Parseable = false;
string[] errorMessages = new string[result.Errors.Count()];
for (int i = 0; i < result.Errors.Count(); i++)
{
errorMessages[i] = result.Errors.ElementAt(i).Message;
}
syntaxResult.Errors = errorMessages;
}
await requestContext.SendResult(syntaxResult);
syntaxResult.Parseable = true;
}
catch (Exception ex)
else
{
await requestContext.SendError(ex.ToString());
syntaxResult.Parseable = false;
string[] errorMessages = new string[result.Errors.Count()];
for (int i = 0; i < result.Errors.Count(); i++)
{
errorMessages[i] = result.Errors.ElementAt(i).Message;
}
syntaxResult.Errors = errorMessages;
}
await requestContext.SendResult(syntaxResult);
}
/// <summary>
@@ -435,39 +420,32 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices
TextDocumentPosition textDocumentPosition,
RequestContext<CompletionItem[]> requestContext)
{
try
var scriptFile = CurrentWorkspace.GetFile(textDocumentPosition.TextDocument.Uri);
if (scriptFile == null)
{
var scriptFile = CurrentWorkspace.GetFile(textDocumentPosition.TextDocument.Uri);
if (scriptFile == null)
{
await requestContext.SendResult(null);
return;
}
// check if Intellisense suggestions are enabled
if (ShouldSkipIntellisense(scriptFile.ClientUri))
{
await requestContext.SendResult(null);
}
else
{
ConnectionInfo connInfo = null;
// Check if we need to refresh the auth token, and if we do then don't pass in the
// connection so that we only show the default options until the refreshed token is returned
if (!await connectionService.TryRequestRefreshAuthToken(scriptFile.ClientUri))
{
ConnectionServiceInstance.TryFindConnection(
scriptFile.ClientUri,
out connInfo);
}
var completionItems = await GetCompletionItems(
textDocumentPosition, scriptFile, connInfo);
await requestContext.SendResult(completionItems);
}
await requestContext.SendResult(null);
return;
}
catch (Exception ex)
// check if Intellisense suggestions are enabled
if (ShouldSkipIntellisense(scriptFile.ClientUri))
{
await requestContext.SendError(ex.ToString());
await requestContext.SendResult(null);
}
else
{
ConnectionInfo connInfo = null;
// Check if we need to refresh the auth token, and if we do then don't pass in the
// connection so that we only show the default options until the refreshed token is returned
if (!await connectionService.TryRequestRefreshAuthToken(scriptFile.ClientUri))
{
ConnectionServiceInstance.TryFindConnection(
scriptFile.ClientUri,
out connInfo);
}
var completionItems = await GetCompletionItems(
textDocumentPosition, scriptFile, connInfo);
await requestContext.SendResult(completionItems);
}
}
@@ -482,70 +460,56 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices
CompletionItem completionItem,
RequestContext<CompletionItem> requestContext)
{
try
// check if Intellisense suggestions are enabled
// Note: Do not know file, so no need to check for MSSQL flavor
if (!CurrentWorkspaceSettings.IsSuggestionsEnabled)
{
// check if Intellisense suggestions are enabled
// Note: Do not know file, so no need to check for MSSQL flavor
if (!CurrentWorkspaceSettings.IsSuggestionsEnabled)
{
await requestContext.SendResult(completionItem);
}
else
{
completionItem = ResolveCompletionItem(completionItem);
await requestContext.SendResult(completionItem);
}
await requestContext.SendResult(completionItem);
}
catch (Exception ex)
else
{
await requestContext.SendError(ex.ToString());
completionItem = ResolveCompletionItem(completionItem);
await requestContext.SendResult(completionItem);
}
}
internal async Task HandleDefinitionRequest(TextDocumentPosition textDocumentPosition, RequestContext<Location[]> requestContext)
{
try
DocumentStatusHelper.SendStatusChange(requestContext, textDocumentPosition, DocumentStatusHelper.DefinitionRequested);
if (!ShouldSkipIntellisense(textDocumentPosition.TextDocument.Uri))
{
DocumentStatusHelper.SendStatusChange(requestContext, textDocumentPosition, DocumentStatusHelper.DefinitionRequested);
if (!ShouldSkipIntellisense(textDocumentPosition.TextDocument.Uri))
// Retrieve document and connection
ConnectionInfo connInfo;
var scriptFile = CurrentWorkspace.GetFile(textDocumentPosition.TextDocument.Uri);
bool isConnected = false;
bool succeeded = false;
DefinitionResult definitionResult = null;
if (scriptFile != null)
{
// Retrieve document and connection
ConnectionInfo connInfo;
var scriptFile = CurrentWorkspace.GetFile(textDocumentPosition.TextDocument.Uri);
bool isConnected = false;
bool succeeded = false;
DefinitionResult definitionResult = null;
if (scriptFile != null)
{
isConnected = ConnectionServiceInstance.TryFindConnection(scriptFile.ClientUri, out connInfo);
definitionResult = GetDefinition(textDocumentPosition, scriptFile, connInfo);
}
isConnected = ConnectionServiceInstance.TryFindConnection(scriptFile.ClientUri, out connInfo);
definitionResult = GetDefinition(textDocumentPosition, scriptFile, connInfo);
}
if (definitionResult != null && !definitionResult.IsErrorResult)
{
await requestContext.SendResult(definitionResult.Locations);
succeeded = true;
}
else
{
await requestContext.SendResult(Array.Empty<Location>());
}
DocumentStatusHelper.SendTelemetryEvent(requestContext, CreatePeekTelemetryProps(succeeded, isConnected));
if (definitionResult != null && !definitionResult.IsErrorResult)
{
await requestContext.SendResult(definitionResult.Locations);
succeeded = true;
}
else
{
// Send an empty result so that processing does not hang when peek def service called from non-mssql clients
await requestContext.SendResult(Array.Empty<Location>());
}
DocumentStatusHelper.SendStatusChange(requestContext, textDocumentPosition, DocumentStatusHelper.DefinitionRequestCompleted);
DocumentStatusHelper.SendTelemetryEvent(requestContext, CreatePeekTelemetryProps(succeeded, isConnected));
}
catch (Exception ex)
else
{
await requestContext.SendError(ex.ToString());
// Send an empty result so that processing does not hang when peek def service called from non-mssql clients
await requestContext.SendResult(Array.Empty<Location>());
}
DocumentStatusHelper.SendStatusChange(requestContext, textDocumentPosition, DocumentStatusHelper.DefinitionRequestCompleted);
}
private static TelemetryProperties CreatePeekTelemetryProps(bool succeeded, bool connected)
@@ -582,67 +546,53 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices
TextDocumentPosition textDocumentPosition,
RequestContext<SignatureHelp> requestContext)
{
try
// check if Intellisense suggestions are enabled
if (ShouldSkipNonMssqlFile(textDocumentPosition))
{
// check if Intellisense suggestions are enabled
if (ShouldSkipNonMssqlFile(textDocumentPosition))
await requestContext.SendResult(null);
}
else
{
ScriptFile scriptFile = CurrentWorkspace.GetFile(
textDocumentPosition.TextDocument.Uri);
SignatureHelp help = null;
if (scriptFile != null)
{
await requestContext.SendResult(null);
help = GetSignatureHelp(textDocumentPosition, scriptFile);
}
if (help != null)
{
await requestContext.SendResult(help);
}
else
{
ScriptFile scriptFile = CurrentWorkspace.GetFile(
textDocumentPosition.TextDocument.Uri);
SignatureHelp help = null;
if (scriptFile != null)
{
help = GetSignatureHelp(textDocumentPosition, scriptFile);
}
if (help != null)
{
await requestContext.SendResult(help);
}
else
{
await requestContext.SendResult(new SignatureHelp());
}
await requestContext.SendResult(new SignatureHelp());
}
}
catch (Exception ex)
{
await requestContext.SendError(ex.ToString());
}
}
private async Task HandleHoverRequest(
TextDocumentPosition textDocumentPosition,
RequestContext<Hover> requestContext)
{
try
// check if Quick Info hover tooltips are enabled
if (CurrentWorkspaceSettings.IsQuickInfoEnabled
&& !ShouldSkipNonMssqlFile(textDocumentPosition))
{
// check if Quick Info hover tooltips are enabled
if (CurrentWorkspaceSettings.IsQuickInfoEnabled
&& !ShouldSkipNonMssqlFile(textDocumentPosition))
{
var scriptFile = CurrentWorkspace.GetFile(
textDocumentPosition.TextDocument.Uri);
var scriptFile = CurrentWorkspace.GetFile(
textDocumentPosition.TextDocument.Uri);
Hover hover = null;
if (scriptFile != null)
{
hover = GetHoverItem(textDocumentPosition, scriptFile);
}
if (hover != null)
{
await requestContext.SendResult(hover);
}
Hover hover = null;
if (scriptFile != null)
{
hover = GetHoverItem(textDocumentPosition, scriptFile);
}
if (hover != null)
{
await requestContext.SendResult(hover);
}
await requestContext.SendResult(null);
}
catch (Exception ex)
{
await requestContext.SendError(ex.ToString());
}
await requestContext.SendResult(null);
}
#endregion

84
src/Microsoft.SqlTools.ServiceLayer/Metadata/MetadataService.cs
View File

@@ -65,40 +65,33 @@ namespace Microsoft.SqlTools.ServiceLayer.Metadata
MetadataQueryParams metadataParams,
RequestContext<MetadataQueryResult> requestContext)
{
try
Func<Task> requestHandler = async () =>
{
Func<Task> requestHandler = async () =>
{
ConnectionInfo connInfo;
MetadataService.ConnectionServiceInstance.TryFindConnection(
metadataParams.OwnerUri,
out connInfo);
ConnectionInfo connInfo;
MetadataService.ConnectionServiceInstance.TryFindConnection(
metadataParams.OwnerUri,
out connInfo);
var metadata = new List<ObjectMetadata>();
if (connInfo != null)
var metadata = new List<ObjectMetadata>();
if (connInfo != null)
{
using (SqlConnection sqlConn = ConnectionService.OpenSqlConnection(connInfo, "Metadata"))
{
using (SqlConnection sqlConn = ConnectionService.OpenSqlConnection(connInfo, "Metadata"))
{
ReadMetadata(sqlConn, metadata);
}
ReadMetadata(sqlConn, metadata);
}
}
await requestContext.SendResult(new MetadataQueryResult
{
Metadata = metadata.ToArray()
});
};
Task task = Task.Run(async () => await requestHandler()).ContinueWithOnFaulted(async t =>
await requestContext.SendResult(new MetadataQueryResult
{
await requestContext.SendError(t.Exception.ToString());
Metadata = metadata.ToArray()
});
MetadataListTask = task;
}
catch (Exception ex)
};
Task task = Task.Run(async () => await requestHandler()).ContinueWithOnFaulted(async t =>
{
await requestContext.SendError(ex.ToString());
}
await requestContext.SendError(t.Exception.ToString());
});
MetadataListTask = task;
}
internal Task MetadataListTask { get; set; }
@@ -131,34 +124,27 @@ namespace Microsoft.SqlTools.ServiceLayer.Metadata
string objectType,
RequestContext<TableMetadataResult> requestContext)
{
try
{
ConnectionInfo connInfo;
MetadataService.ConnectionServiceInstance.TryFindConnection(
metadataParams.OwnerUri,
out connInfo);
ConnectionInfo connInfo;
MetadataService.ConnectionServiceInstance.TryFindConnection(
metadataParams.OwnerUri,
out connInfo);
ColumnMetadata[] metadata = null;
if (connInfo != null)
ColumnMetadata[] metadata = null;
if (connInfo != null)
{
using (SqlConnection sqlConn = ConnectionService.OpenSqlConnection(connInfo, "Metadata"))
{
using (SqlConnection sqlConn = ConnectionService.OpenSqlConnection(connInfo, "Metadata"))
{
TableMetadata table = new SmoMetadataFactory().GetObjectMetadata(
sqlConn, metadataParams.Schema,
metadataParams.ObjectName, objectType);
metadata = table.Columns;
}
TableMetadata table = new SmoMetadataFactory().GetObjectMetadata(
sqlConn, metadataParams.Schema,
metadataParams.ObjectName, objectType);
metadata = table.Columns;
}
}
await requestContext.SendResult(new TableMetadataResult
{
Columns = metadata
});
}
catch (Exception ex)
await requestContext.SendResult(new TableMetadataResult
{
await requestContext.SendError(ex.ToString());
}
Columns = metadata
});
}
internal static bool IsSystemDatabase(string database)

80
src/Microsoft.SqlTools.ServiceLayer/Migration/MigrationService.cs
View File

@@ -98,10 +98,10 @@ namespace Microsoft.SqlTools.ServiceLayer.Migration
/// <summary>
/// Controller for collecting performance data for SKU recommendation
/// </summary>
internal SqlDataQueryController DataCollectionController
{
get;
set;
internal SqlDataQueryController DataCollectionController
{
get;
set;
}
/// <summary>
@@ -157,10 +157,6 @@ namespace Microsoft.SqlTools.ServiceLayer.Migration
await requestContext.SendResult(results);
}
}
catch (Exception e)
{
await requestContext.SendError(e.ToString());
}
finally
{
ConnectionService.Disconnect(new DisconnectParams { OwnerUri = randomUri, Type = null });
@@ -196,11 +192,11 @@ namespace Microsoft.SqlTools.ServiceLayer.Migration
var connectionString = ConnectionService.BuildConnectionString(connInfo.ConnectionDetails);
this.DataCollectionController = new SqlDataQueryController(
connectionString,
parameters.DataFolder,
connectionString,
parameters.DataFolder,
parameters.PerfQueryIntervalInSec,
parameters.NumberOfIterations,
parameters.StaticQueryIntervalInSec,
parameters.NumberOfIterations,
parameters.StaticQueryIntervalInSec,
null);
this.DataCollectionController.Start();
@@ -208,10 +204,6 @@ namespace Microsoft.SqlTools.ServiceLayer.Migration
// TO-DO: what should be returned?
await requestContext.SendResult(new StartPerfDataCollectionResult() { DateTimeStarted = DateTime.UtcNow });
}
catch (Exception e)
{
await requestContext.SendError(e.ToString());
}
finally
{
ConnectionService.Disconnect(new DisconnectParams { OwnerUri = randomUri, Type = null });
@@ -225,17 +217,10 @@ namespace Microsoft.SqlTools.ServiceLayer.Migration
StopPerfDataCollectionParams parameters,
RequestContext<StopPerfDataCollectionResult> requestContext)
{
try
{
this.DataCollectionController.Dispose();
this.DataCollectionController.Dispose();
// TO-DO: what should be returned?
await requestContext.SendResult(new StopPerfDataCollectionResult() { DateTimeStopped = DateTime.UtcNow });
}
catch (Exception e)
{
await requestContext.SendError(e.ToString());
}
// TO-DO: what should be returned?
await requestContext.SendResult(new StopPerfDataCollectionResult() { DateTimeStopped = DateTime.UtcNow });
}
/// <summary>
@@ -245,26 +230,19 @@ namespace Microsoft.SqlTools.ServiceLayer.Migration
RefreshPerfDataCollectionParams parameters,
RequestContext<RefreshPerfDataCollectionResult> requestContext)
{
try
{
bool isCollecting = !(this.DataCollectionController is null) ? this.DataCollectionController.IsRunning() : false;
List<string> messages = !(this.DataCollectionController is null) ? this.DataCollectionController.FetchLatestMessages(parameters.LastRefreshedTime) : new List<string>();
List<string> errors = !(this.DataCollectionController is null) ? this.DataCollectionController.FetchLatestErrors(parameters.LastRefreshedTime) : new List<string>();
bool isCollecting = !(this.DataCollectionController is null) ? this.DataCollectionController.IsRunning() : false;
List<string> messages = !(this.DataCollectionController is null) ? this.DataCollectionController.FetchLatestMessages(parameters.LastRefreshedTime) : new List<string>();
List<string> errors = !(this.DataCollectionController is null) ? this.DataCollectionController.FetchLatestErrors(parameters.LastRefreshedTime) : new List<string>();
RefreshPerfDataCollectionResult result = new RefreshPerfDataCollectionResult()
{
RefreshTime = DateTime.UtcNow,
IsCollecting = isCollecting,
Messages = messages,
Errors = errors,
};
await requestContext.SendResult(result);
}
catch (Exception e)
RefreshPerfDataCollectionResult result = new RefreshPerfDataCollectionResult()
{
await requestContext.SendError(e.ToString());
}
RefreshTime = DateTime.UtcNow,
IsCollecting = isCollecting,
Messages = messages,
Errors = errors,
};
await requestContext.SendResult(result);
}
/// <summary>
/// Handle request to generate SKU recommendations
@@ -296,10 +274,10 @@ namespace Microsoft.SqlTools.ServiceLayer.Migration
List<SkuRecommendationResult> sqlDbResults = new List<SkuRecommendationResult>();
if (parameters.TargetPlatforms.Contains("AzureSqlDatabase"))
{
var prefs = new AzurePreferences()
{
EligibleSkuCategories = GetEligibleSkuCategories("AzureSqlDatabase", parameters.IncludePreviewSkus),
ScalingFactor = parameters.ScalingFactor / 100.0
var prefs = new AzurePreferences()
{
EligibleSkuCategories = GetEligibleSkuCategories("AzureSqlDatabase", parameters.IncludePreviewSkus),
ScalingFactor = parameters.ScalingFactor / 100.0
};
sqlDbResults = provider.GetSkuRecommendation(prefs, req);
@@ -396,10 +374,6 @@ namespace Microsoft.SqlTools.ServiceLayer.Migration
{
await requestContext.SendError($"Unable to read collected performance data from {parameters.DataFolder}. Please specify another folder or start data collection instead.");
}
catch (Exception e)
{
await requestContext.SendError(e.ToString());
}
}
internal class AssessmentRequest : IAssessmentRequest
@@ -634,7 +608,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Migration
vmCapabilities.AddRange(vmPreviewCapabilities);
}
foreach (VirtualMachineFamily family in AzureVirtualMachineFamilyGroup.FamilyGroups[VirtualMachineFamilyType.GeneralPurpose]
.Concat(AzureVirtualMachineFamilyGroup.FamilyGroups[VirtualMachineFamilyType.MemoryOptimized]))

44
src/Microsoft.SqlTools.ServiceLayer/NotebookConvert/NotebookConvertService.cs
View File

@@ -76,42 +76,28 @@ namespace Microsoft.SqlTools.ServiceLayer.NotebookConvert
internal async Task HandleConvertNotebookToSqlRequest(ConvertNotebookToSqlParams parameters, RequestContext<ConvertNotebookToSqlResult> requestContext)
{
try
{
var notebookDoc = JsonConvert.DeserializeObject<NotebookDocument>(parameters.Content);
var notebookDoc = JsonConvert.DeserializeObject<NotebookDocument>(parameters.Content);
var result = new ConvertNotebookToSqlResult
{
Content = ConvertNotebookDocToSql(notebookDoc)
};
await requestContext.SendResult(result);
}
catch (Exception e)
var result = new ConvertNotebookToSqlResult
{
await requestContext.SendError(e);
}
Content = ConvertNotebookDocToSql(notebookDoc)
};
await requestContext.SendResult(result);
}
internal async Task HandleConvertSqlToNotebookRequest(ConvertSqlToNotebookParams parameters, RequestContext<ConvertSqlToNotebookResult> requestContext)
{
try
// This URI doesn't come in escaped - so if it's a file path with reserved characters (such as %)
// then we'll fail to find it since GetFile expects the URI to be a fully-escaped URI as that's
// what the document events are sent in as.
var escapedClientUri = Uri.EscapeUriString(parameters.ClientUri);
var file = WorkspaceService<SqlToolsSettings>.Instance.Workspace.GetFile(escapedClientUri);
// Temporary notebook that we just fill in with the sql until the parsing logic is added
var result = new ConvertSqlToNotebookResult
{
// This URI doesn't come in escaped - so if it's a file path with reserved characters (such as %)
// then we'll fail to find it since GetFile expects the URI to be a fully-escaped URI as that's
// what the document events are sent in as.
var escapedClientUri = Uri.EscapeUriString(parameters.ClientUri);
var file = WorkspaceService<SqlToolsSettings>.Instance.Workspace.GetFile(escapedClientUri);
// Temporary notebook that we just fill in with the sql until the parsing logic is added
var result = new ConvertSqlToNotebookResult
{
Content = JsonConvert.SerializeObject(ConvertSqlToNotebook(file.Contents))
};
await requestContext.SendResult(result);
}
catch (Exception e)
{
await requestContext.SendError(e);
}
Content = JsonConvert.SerializeObject(ConvertSqlToNotebook(file.Contents))
};
await requestContext.SendResult(result);
}
#endregion // Convert Handlers

92
src/Microsoft.SqlTools.ServiceLayer/ObjectExplorer/ObjectExplorerService.cs
View File

@@ -108,7 +108,7 @@ namespace Microsoft.SqlTools.ServiceLayer.ObjectExplorer
connectionService.RegisterConnectedQueue(connectionName, bindingQueue);
}
catch(Exception ex)
catch (Exception ex)
{
Logger.Write(TraceEventType.Error, ex.Message);
}
@@ -164,30 +164,23 @@ namespace Microsoft.SqlTools.ServiceLayer.ObjectExplorer
internal async Task HandleCreateSessionRequest(ConnectionDetails connectionDetails, RequestContext<CreateSessionResponse> context)
{
try
Logger.Write(TraceEventType.Verbose, "HandleCreateSessionRequest");
Func<Task<CreateSessionResponse>> doCreateSession = async () =>
{
Logger.Write(TraceEventType.Verbose, "HandleCreateSessionRequest");
Func<Task<CreateSessionResponse>> doCreateSession = async () =>
Validate.IsNotNull(nameof(connectionDetails), connectionDetails);
Validate.IsNotNull(nameof(context), context);
return await Task.Run(() =>
{
Validate.IsNotNull(nameof(connectionDetails), connectionDetails);
Validate.IsNotNull(nameof(context), context);
return await Task.Run(() =>
{
string uri = GenerateUri(connectionDetails);
string uri = GenerateUri(connectionDetails);
return new CreateSessionResponse { SessionId = uri };
});
};
return new CreateSessionResponse { SessionId = uri };
});
};
CreateSessionResponse response = await HandleRequestAsync(doCreateSession, context, "HandleCreateSessionRequest");
if (response != null)
{
RunCreateSessionTask(connectionDetails, response.SessionId);
}
}
catch (Exception ex)
CreateSessionResponse response = await HandleRequestAsync(doCreateSession, context, "HandleCreateSessionRequest");
if (response != null)
{
await context.SendError(ex.ToString());
RunCreateSessionTask(connectionDetails, response.SessionId);
}
}
@@ -225,34 +218,27 @@ namespace Microsoft.SqlTools.ServiceLayer.ObjectExplorer
internal async Task HandleRefreshRequest(RefreshParams refreshParams, RequestContext<bool> context)
{
try
{
Logger.Write(TraceEventType.Verbose, "HandleRefreshRequest");
Validate.IsNotNull(nameof(refreshParams), refreshParams);
Validate.IsNotNull(nameof(context), context);
Logger.Write(TraceEventType.Verbose, "HandleRefreshRequest");
Validate.IsNotNull(nameof(refreshParams), refreshParams);
Validate.IsNotNull(nameof(context), context);
string uri = refreshParams.SessionId;
ObjectExplorerSession session = null;
if (string.IsNullOrEmpty(uri) || !sessionMap.TryGetValue(uri, out session))
{
Logger.Write(TraceEventType.Verbose, $"Cannot expand object explorer node. Couldn't find session for uri. {uri} ");
await serviceHost.SendEvent(ExpandCompleteNotification.Type, new ExpandResponse
{
SessionId = refreshParams.SessionId,
NodePath = refreshParams.NodePath,
ErrorMessage = $"Couldn't find session for session: {uri}"
});
}
else
{
RunExpandTask(session, refreshParams, true);
}
await context.SendResult(true);
}
catch (Exception ex)
string uri = refreshParams.SessionId;
ObjectExplorerSession session = null;
if (string.IsNullOrEmpty(uri) || !sessionMap.TryGetValue(uri, out session))
{
await context.SendError(ex.ToString());
Logger.Write(TraceEventType.Verbose, $"Cannot expand object explorer node. Couldn't find session for uri. {uri} ");
await serviceHost.SendEvent(ExpandCompleteNotification.Type, new ExpandResponse
{
SessionId = refreshParams.SessionId,
NodePath = refreshParams.NodePath,
ErrorMessage = $"Couldn't find session for session: {uri}"
});
}
else
{
RunExpandTask(session, refreshParams, true);
}
await context.SendResult(true);
}
internal async Task HandleCloseSessionRequest(CloseSessionParams closeSessionParams, RequestContext<CloseSessionResponse> context)
@@ -304,7 +290,7 @@ namespace Microsoft.SqlTools.ServiceLayer.ObjectExplorer
if (sessionMap.TryGetValue(uri, out session))
{
// Remove the session from active sessions and disconnect
if(sessionMap.TryRemove(session.Uri, out session))
if (sessionMap.TryRemove(session.Uri, out session))
{
if (session != null && session.ConnectionInfo != null)
{
@@ -442,7 +428,7 @@ namespace Microsoft.SqlTools.ServiceLayer.ObjectExplorer
bindingContext.ServerConnection.SqlConnectionObject.ChangeDatabase(bindingContext.ServerConnection.DatabaseName);
}
}
catch(Exception ex)
catch (Exception ex)
{
Logger.Write(TraceEventType.Warning, $"Failed to change the database in OE connection. error: {ex.Message}");
// We should just try to change the connection. If it fails, there's not much we can do
@@ -515,7 +501,7 @@ namespace Microsoft.SqlTools.ServiceLayer.ObjectExplorer
}
return session;
}
catch(Exception ex)
catch (Exception ex)
{
await SendSessionFailedNotification(uri, ex.Message);
return null;
@@ -529,7 +515,7 @@ namespace Microsoft.SqlTools.ServiceLayer.ObjectExplorer
{
// open connection based on request details
ConnectionCompleteParams result = await connectionService.Connect(connectParams);
connectionErrorMessage = result != null ? $"{result.Messages} error code:{result.ErrorNumber}" : string.Empty;
connectionErrorMessage = result != null ? $"{result.Messages} error code:{result.ErrorNumber}" : string.Empty;
if (result != null && !string.IsNullOrEmpty(result.ConnectionId))
{
return result;
@@ -575,18 +561,18 @@ namespace Microsoft.SqlTools.ServiceLayer.ObjectExplorer
private void RunExpandTask(ObjectExplorerSession session, ExpandParams expandParams, bool forceRefresh = false)
{
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
Task task = ExpandNodeAsync(session, expandParams, cancellationTokenSource.Token, forceRefresh);
Task task = ExpandNodeAsync(session, expandParams, cancellationTokenSource.Token, forceRefresh);
ExpandTask = task;
Task.Run(async () =>
{
ObjectExplorerTaskResult result = await RunTaskWithTimeout(task,
ObjectExplorerTaskResult result = await RunTaskWithTimeout(task,
settings?.ExpandTimeout ?? ObjectExplorerSettings.DefaultExpandTimeout);
if (result != null && !result.IsCompleted)
{
cancellationTokenSource.Cancel();
ExpandResponse response = CreateExpandResponse(session, expandParams);
response.ErrorMessage = result.Exception != null ? result.Exception.Message: $"Failed to expand node: {expandParams.NodePath} in session {session.Uri}";
response.ErrorMessage = result.Exception != null ? result.Exception.Message : $"Failed to expand node: {expandParams.NodePath} in session {session.Uri}";
await serviceHost.SendEvent(ExpandCompleteNotification.Type, response);
}
return result;
@@ -599,7 +585,7 @@ namespace Microsoft.SqlTools.ServiceLayer.ObjectExplorer
TimeSpan timeout = TimeSpan.FromSeconds(timeoutInSec);
await Task.WhenAny(task, Task.Delay(timeout));
result.IsCompleted = task.IsCompleted;
if(task.Exception != null)
if (task.Exception != null)
{
result.Exception = task.Exception;
}

216
src/Microsoft.SqlTools.ServiceLayer/Profiler/ProfilerService.cs
View File

@@ -115,55 +115,48 @@ namespace Microsoft.SqlTools.ServiceLayer.Profiler
/// </summary>
internal async Task HandleCreateXEventSessionRequest(CreateXEventSessionParams parameters, RequestContext<CreateXEventSessionResult> requestContext)
{
try
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
if (connInfo == null)
{
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
if (connInfo == null)
{
throw new Exception(SR.ProfilerConnectionNotFound);
}
else if (parameters.SessionName == null)
{
throw new ArgumentNullException("SessionName");
}
else if (parameters.Template == null)
{
throw new ArgumentNullException("Template");
}
else
{
IXEventSession xeSession = null;
// first check whether the session with the given name already exists.
// if so skip the creation part. An exception will be thrown if no session with given name can be found,
// and it can be ignored.
try
{
xeSession = this.XEventSessionFactory.GetXEventSession(parameters.SessionName, connInfo);
}
catch { }
if (xeSession == null)
{
// create a new XEvent session and Profiler session
xeSession = this.XEventSessionFactory.CreateXEventSession(parameters.Template.CreateStatement, parameters.SessionName, connInfo);
}
// start monitoring the profiler session
monitor.StartMonitoringSession(parameters.OwnerUri, xeSession);
var result = new CreateXEventSessionResult();
await requestContext.SendResult(result);
SessionCreatedNotification(parameters.OwnerUri, parameters.SessionName, parameters.Template.Name);
}
throw new Exception(SR.ProfilerConnectionNotFound);
}
catch (Exception e)
else if (parameters.SessionName == null)
{
await requestContext.SendError(new Exception(SR.CreateSessionFailed(e.Message)));
throw new ArgumentNullException("SessionName");
}
else if (parameters.Template == null)
{
throw new ArgumentNullException("Template");
}
else
{
IXEventSession xeSession = null;
// first check whether the session with the given name already exists.
// if so skip the creation part. An exception will be thrown if no session with given name can be found,
// and it can be ignored.
try
{
xeSession = this.XEventSessionFactory.GetXEventSession(parameters.SessionName, connInfo);
}
catch { }
if (xeSession == null)
{
// create a new XEvent session and Profiler session
xeSession = this.XEventSessionFactory.CreateXEventSession(parameters.Template.CreateStatement, parameters.SessionName, connInfo);
}
// start monitoring the profiler session
monitor.StartMonitoringSession(parameters.OwnerUri, xeSession);
var result = new CreateXEventSessionResult();
await requestContext.SendResult(result);
SessionCreatedNotification(parameters.OwnerUri, parameters.SessionName, parameters.Template.Name);
}
}
@@ -172,30 +165,23 @@ namespace Microsoft.SqlTools.ServiceLayer.Profiler
/// </summary>
internal async Task HandleStartProfilingRequest(StartProfilingParams parameters, RequestContext<StartProfilingResult> requestContext)
{
try
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
if (connInfo != null)
{
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
if (connInfo != null)
{
// create a new XEvent session and Profiler session
var xeSession = this.XEventSessionFactory.GetXEventSession(parameters.SessionName, connInfo);
// start monitoring the profiler session
monitor.StartMonitoringSession(parameters.OwnerUri, xeSession);
// create a new XEvent session and Profiler session
var xeSession = this.XEventSessionFactory.GetXEventSession(parameters.SessionName, connInfo);
// start monitoring the profiler session
monitor.StartMonitoringSession(parameters.OwnerUri, xeSession);
var result = new StartProfilingResult();
await requestContext.SendResult(result);
}
else
{
throw new Exception(SR.ProfilerConnectionNotFound);
}
var result = new StartProfilingResult();
await requestContext.SendResult(result);
}
catch (Exception e)
else
{
await requestContext.SendError(new Exception(SR.StartSessionFailed(e.Message)));
throw new Exception(SR.ProfilerConnectionNotFound);
}
}
@@ -204,43 +190,36 @@ namespace Microsoft.SqlTools.ServiceLayer.Profiler
/// </summary>
internal async Task HandleStopProfilingRequest(StopProfilingParams parameters, RequestContext<StopProfilingResult> requestContext)
{
try
{
ProfilerSession session;
monitor.StopMonitoringSession(parameters.OwnerUri, out session);
ProfilerSession session;
monitor.StopMonitoringSession(parameters.OwnerUri, out session);
if (session != null)
if (session != null)
{
// Occasionally we might see the InvalidOperationException due to a read is
// in progress, add the following retry logic will solve the problem.
int remainingAttempts = 3;
while (true)
{
// Occasionally we might see the InvalidOperationException due to a read is
// in progress, add the following retry logic will solve the problem.
int remainingAttempts = 3;
while (true)
try
{
try
session.XEventSession.Stop();
await requestContext.SendResult(new StopProfilingResult { });
break;
}
catch (InvalidOperationException)
{
remainingAttempts--;
if (remainingAttempts == 0)
{
session.XEventSession.Stop();
await requestContext.SendResult(new StopProfilingResult { });
break;
}
catch (InvalidOperationException)
{
remainingAttempts--;
if (remainingAttempts == 0)
{
throw;
}
Thread.Sleep(500);
throw;
}
Thread.Sleep(500);
}
}
else
{
throw new Exception(SR.SessionNotFound);
}
}
catch (Exception e)
else
{
await requestContext.SendError(new Exception(SR.StopSessionFailed(e.Message)));
throw new Exception(SR.SessionNotFound);
}
}
@@ -249,16 +228,9 @@ namespace Microsoft.SqlTools.ServiceLayer.Profiler
/// </summary>
internal async Task HandlePauseProfilingRequest(PauseProfilingParams parameters, RequestContext<PauseProfilingResult> requestContext)
{
try
{
monitor.PauseViewer(parameters.OwnerUri);
monitor.PauseViewer(parameters.OwnerUri);
await requestContext.SendResult(new PauseProfilingResult { });
}
catch (Exception e)
{
await requestContext.SendError(new Exception(SR.PauseSessionFailed(e.Message)));
}
await requestContext.SendResult(new PauseProfilingResult { });
}
/// <summary>
@@ -266,27 +238,20 @@ namespace Microsoft.SqlTools.ServiceLayer.Profiler
/// </summary>
internal async Task HandleGetXEventSessionsRequest(GetXEventSessionsParams parameters, RequestContext<GetXEventSessionsResult> requestContext)
{
try
var result = new GetXEventSessionsResult();
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
if (connInfo == null)
{
var result = new GetXEventSessionsResult();
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
if (connInfo == null)
{
await requestContext.SendError(new Exception(SR.ProfilerConnectionNotFound));
}
else
{
List<string> sessions = GetXEventSessionList(parameters.OwnerUri, connInfo);
result.Sessions = sessions;
await requestContext.SendResult(result);
}
await requestContext.SendError(new Exception(SR.ProfilerConnectionNotFound));
}
catch (Exception e)
else
{
await requestContext.SendError(e);
List<string> sessions = GetXEventSessionList(parameters.OwnerUri, connInfo);
result.Sessions = sessions;
await requestContext.SendResult(result);
}
}
@@ -295,14 +260,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Profiler
/// </summary>
internal async Task HandleDisconnectSessionRequest(DisconnectSessionParams parameters, RequestContext<DisconnectSessionResult> requestContext)
{
try
{
monitor.StopMonitoringSession(parameters.OwnerUri, out _);
}
catch (Exception e)
{
await requestContext.SendError(e);
}
monitor.StopMonitoringSession(parameters.OwnerUri, out _);
}
/// <summary>

323
src/Microsoft.SqlTools.ServiceLayer/QueryExecution/QueryExecutionService.cs
View File

@@ -201,42 +201,36 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution
/// <summary>
/// Handles request to execute a selection of a document in the workspace service
/// </summary>
internal async Task HandleExecuteRequest(ExecuteRequestParamsBase executeParams,
internal Task HandleExecuteRequest(ExecuteRequestParamsBase executeParams,
RequestContext<ExecuteRequestResult> requestContext)
{
try
// Setup actions to perform upon successful start and on failure to start
Func<Query, Task<bool>> queryCreateSuccessAction = async q =>
{
// Setup actions to perform upon successful start and on failure to start
Func<Query, Task<bool>> queryCreateSuccessAction = async q =>
{
await requestContext.SendResult(new ExecuteRequestResult());
Logger.Write(TraceEventType.Stop, $"Response for Query: '{executeParams.OwnerUri} sent. Query Complete!");
return true;
};
Func<string, Task> queryCreateFailureAction = message =>
{
Logger.Write(TraceEventType.Warning, $"Failed to create Query: '{executeParams.OwnerUri}. Message: '{message}' Complete!");
return requestContext.SendError(message);
};
await requestContext.SendResult(new ExecuteRequestResult());
Logger.Write(TraceEventType.Stop, $"Response for Query: '{executeParams.OwnerUri} sent. Query Complete!");
return true;
};
Func<string, Task> queryCreateFailureAction = message =>
{
Logger.Write(TraceEventType.Warning, $"Failed to create Query: '{executeParams.OwnerUri}. Message: '{message}' Complete!");
return requestContext.SendError(message);
};
// Use the internal handler to launch the query
WorkTask = Task.Run(async () =>
{
await InterServiceExecuteQuery(
executeParams,
null,
requestContext,
queryCreateSuccessAction,
queryCreateFailureAction,
null,
null,
isQueryEditor(executeParams.OwnerUri));
});
}
catch (Exception ex)
// Use the internal handler to launch the query
WorkTask = Task.Run(async () =>
{
await requestContext.SendError(ex.ToString());
}
await InterServiceExecuteQuery(
executeParams,
null,
requestContext,
queryCreateSuccessAction,
queryCreateFailureAction,
null,
null,
isQueryEditor(executeParams.OwnerUri));
});
return Task.CompletedTask;
}
/// <summary>
@@ -245,116 +239,109 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution
internal async Task HandleSimpleExecuteRequest(SimpleExecuteParams executeParams,
RequestContext<SimpleExecuteResult> requestContext)
{
try
string randomUri = Guid.NewGuid().ToString();
ExecuteStringParams executeStringParams = new ExecuteStringParams
{
string randomUri = Guid.NewGuid().ToString();
ExecuteStringParams executeStringParams = new ExecuteStringParams
Query = executeParams.QueryString,
// generate guid as the owner uri to make sure every query is unique
OwnerUri = randomUri
};
// get connection
ConnectionInfo connInfo;
if (!ConnectionService.TryFindConnection(executeParams.OwnerUri, out connInfo))
{
await requestContext.SendError(SR.QueryServiceQueryInvalidOwnerUri);
return;
}
ConnectParams connectParams = new ConnectParams
{
OwnerUri = randomUri,
Connection = connInfo.ConnectionDetails,
Type = ConnectionType.Default
};
Task workTask = Task.Run(async () =>
{
await ConnectionService.Connect(connectParams);
ConnectionInfo newConn;
ConnectionService.TryFindConnection(randomUri, out newConn);
Func<string, Task> queryCreateFailureAction = message => requestContext.SendError(message);
ResultOnlyContext<SimpleExecuteResult> newContext = new ResultOnlyContext<SimpleExecuteResult>(requestContext);
// handle sending event back when the query completes
Query.QueryAsyncEventHandler queryComplete = async query =>
{
Query = executeParams.QueryString,
// generate guid as the owner uri to make sure every query is unique
OwnerUri = randomUri
};
// get connection
ConnectionInfo connInfo;
if (!ConnectionService.TryFindConnection(executeParams.OwnerUri, out connInfo))
{
await requestContext.SendError(SR.QueryServiceQueryInvalidOwnerUri);
return;
}
ConnectParams connectParams = new ConnectParams
{
OwnerUri = randomUri,
Connection = connInfo.ConnectionDetails,
Type = ConnectionType.Default
};
Task workTask = Task.Run(async () =>
{
await ConnectionService.Connect(connectParams);
ConnectionInfo newConn;
ConnectionService.TryFindConnection(randomUri, out newConn);
Func<string, Task> queryCreateFailureAction = message => requestContext.SendError(message);
ResultOnlyContext<SimpleExecuteResult> newContext = new ResultOnlyContext<SimpleExecuteResult>(requestContext);
// handle sending event back when the query completes
Query.QueryAsyncEventHandler queryComplete = async query =>
try
{
try
// check to make sure any results were recieved
if (query.Batches.Length == 0
|| query.Batches[0].ResultSets.Count == 0)
{
// check to make sure any results were recieved
if (query.Batches.Length == 0
|| query.Batches[0].ResultSets.Count == 0)
{
await requestContext.SendError(SR.QueryServiceResultSetHasNoResults);
return;
}
long rowCount = query.Batches[0].ResultSets[0].RowCount;
// check to make sure there is a safe amount of rows to load into memory
if (rowCount > Int32.MaxValue)
{
await requestContext.SendError(SR.QueryServiceResultSetTooLarge);
return;
}
SimpleExecuteResult result = new SimpleExecuteResult
{
RowCount = rowCount,
ColumnInfo = query.Batches[0].ResultSets[0].Columns,
Rows = new DbCellValue[0][]
};
if (rowCount > 0)
{
SubsetParams subsetRequestParams = new SubsetParams
{
OwnerUri = randomUri,
BatchIndex = 0,
ResultSetIndex = 0,
RowsStartIndex = 0,
RowsCount = Convert.ToInt32(rowCount)
};
// get the data to send back
ResultSetSubset subset = await InterServiceResultSubset(subsetRequestParams);
result.Rows = subset.Rows;
}
await requestContext.SendResult(result);
await requestContext.SendError(SR.QueryServiceResultSetHasNoResults);
return;
}
finally
long rowCount = query.Batches[0].ResultSets[0].RowCount;
// check to make sure there is a safe amount of rows to load into memory
if (rowCount > Int32.MaxValue)
{
Query removedQuery;
Task removedTask;
// remove the active query since we are done with it
ActiveQueries.TryRemove(randomUri, out removedQuery);
ActiveSimpleExecuteRequests.TryRemove(randomUri, out removedTask);
ConnectionService.Disconnect(new DisconnectParams()
await requestContext.SendError(SR.QueryServiceResultSetTooLarge);
return;
}
SimpleExecuteResult result = new SimpleExecuteResult
{
RowCount = rowCount,
ColumnInfo = query.Batches[0].ResultSets[0].Columns,
Rows = new DbCellValue[0][]
};
if (rowCount > 0)
{
SubsetParams subsetRequestParams = new SubsetParams
{
OwnerUri = randomUri,
Type = null
});
BatchIndex = 0,
ResultSetIndex = 0,
RowsStartIndex = 0,
RowsCount = Convert.ToInt32(rowCount)
};
// get the data to send back
ResultSetSubset subset = await InterServiceResultSubset(subsetRequestParams);
result.Rows = subset.Rows;
}
};
// handle sending error back when query fails
Query.QueryAsyncErrorEventHandler queryFail = async (q, e) =>
await requestContext.SendResult(result);
}
finally
{
await requestContext.SendError(e);
};
Query removedQuery;
Task removedTask;
// remove the active query since we are done with it
ActiveQueries.TryRemove(randomUri, out removedQuery);
ActiveSimpleExecuteRequests.TryRemove(randomUri, out removedTask);
ConnectionService.Disconnect(new DisconnectParams()
{
OwnerUri = randomUri,
Type = null
});
}
};
await InterServiceExecuteQuery(executeStringParams, newConn, newContext, null, queryCreateFailureAction, queryComplete, queryFail);
});
// handle sending error back when query fails
Query.QueryAsyncErrorEventHandler queryFail = async (q, e) =>
{
await requestContext.SendError(e);
};
ActiveSimpleExecuteRequests.TryAdd(randomUri, workTask);
}
catch (Exception ex)
{
await requestContext.SendError(ex.ToString());
}
await InterServiceExecuteQuery(executeStringParams, newConn, newContext, null, queryCreateFailureAction, queryComplete, queryFail);
});
ActiveSimpleExecuteRequests.TryAdd(randomUri, workTask);
}
@@ -392,21 +379,13 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution
internal async Task HandleResultSubsetRequest(SubsetParams subsetParams,
RequestContext<SubsetResult> requestContext)
{
try
ResultSetSubset subset = await InterServiceResultSubset(subsetParams);
var result = new SubsetResult
{
ResultSetSubset subset = await InterServiceResultSubset(subsetParams);
var result = new SubsetResult
{
ResultSubset = subset
};
await requestContext.SendResult(result);
Logger.Write(TraceEventType.Stop, $"Done Handler for Subset request with for Query:'{subsetParams.OwnerUri}', Batch:'{subsetParams.BatchIndex}', ResultSetIndex:'{subsetParams.ResultSetIndex}', RowsStartIndex'{subsetParams.RowsStartIndex}', Requested RowsCount:'{subsetParams.RowsCount}'\r\n\t\t with subset response of:[ RowCount:'{subset.RowCount}', Rows array of length:'{subset.Rows.Length}']");
}
catch (Exception e)
{
// This was unexpected, so send back as error
await requestContext.SendError(e.Message);
}
ResultSubset = subset
};
await requestContext.SendResult(result);
Logger.Write(TraceEventType.Stop, $"Done Handler for Subset request with for Query:'{subsetParams.OwnerUri}', Batch:'{subsetParams.BatchIndex}', ResultSetIndex:'{subsetParams.ResultSetIndex}', RowsStartIndex'{subsetParams.RowsStartIndex}', Requested RowsCount:'{subsetParams.RowsCount}'\r\n\t\t with subset response of:[ RowCount:'{subset.RowCount}', Rows array of length:'{subset.Rows.Length}']");
}
@@ -416,24 +395,16 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution
internal async Task HandleQueryExecutionOptionsRequest(QueryExecutionOptionsParams queryExecutionOptionsParams,
RequestContext<bool> requestContext)
{
try
string uri = queryExecutionOptionsParams.OwnerUri;
if (ActiveQueryExecutionSettings.ContainsKey(uri))
{
string uri = queryExecutionOptionsParams.OwnerUri;
if (ActiveQueryExecutionSettings.ContainsKey(uri))
{
QueryExecutionSettings settings;
ActiveQueryExecutionSettings.TryRemove(uri, out settings);
}
ActiveQueryExecutionSettings.TryAdd(uri, queryExecutionOptionsParams.Options);
await requestContext.SendResult(true);
}
catch (Exception e)
{
// This was unexpected, so send back as error
await requestContext.SendError(e.Message);
QueryExecutionSettings settings;
ActiveQueryExecutionSettings.TryRemove(uri, out settings);
}
ActiveQueryExecutionSettings.TryAdd(uri, queryExecutionOptionsParams.Options);
await requestContext.SendResult(true);
}
/// <summary>
@@ -442,28 +413,20 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution
internal async Task HandleExecutionPlanRequest(QueryExecutionPlanParams planParams,
RequestContext<QueryExecutionPlanResult> requestContext)
{
try
// Attempt to load the query
Query query;
if (!ActiveQueries.TryGetValue(planParams.OwnerUri, out query))
{
// Attempt to load the query
Query query;
if (!ActiveQueries.TryGetValue(planParams.OwnerUri, out query))
{
await requestContext.SendError(SR.QueryServiceRequestsNoQuery);
return;
}
await requestContext.SendError(SR.QueryServiceRequestsNoQuery);
return;
}
// Retrieve the requested execution plan and return it
var result = new QueryExecutionPlanResult
{
ExecutionPlan = await query.GetExecutionPlan(planParams.BatchIndex, planParams.ResultSetIndex)
};
await requestContext.SendResult(result);
}
catch (Exception e)
// Retrieve the requested execution plan and return it
var result = new QueryExecutionPlanResult
{
// This was unexpected, so send back as error
await requestContext.SendError(e.Message);
}
ExecutionPlan = await query.GetExecutionPlan(planParams.BatchIndex, planParams.ResultSetIndex)
};
await requestContext.SendResult(result);
}
/// <summary>
@@ -511,10 +474,6 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution
Messages = e.Message
});
}
catch (Exception e)
{
await requestContext.SendError(e.Message);
}
}
/// <summary>

225
src/Microsoft.SqlTools.ServiceLayer/SchemaCompare/SchemaCompareService.cs
View File

@@ -63,61 +63,55 @@ namespace Microsoft.SqlTools.ServiceLayer.SchemaCompare
/// Handles schema compare request
/// </summary>
/// <returns></returns>
public async Task HandleSchemaCompareRequest(SchemaCompareParams parameters, RequestContext<SchemaCompareResult> requestContext)
public Task HandleSchemaCompareRequest(SchemaCompareParams parameters, RequestContext<SchemaCompareResult> requestContext)
{
try
{
ConnectionInfo sourceConnInfo;
ConnectionInfo targetConnInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.SourceEndpointInfo.OwnerUri,
out sourceConnInfo);
ConnectionServiceInstance.TryFindConnection(
parameters.TargetEndpointInfo.OwnerUri,
out targetConnInfo);
ConnectionInfo sourceConnInfo;
ConnectionInfo targetConnInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.SourceEndpointInfo.OwnerUri,
out sourceConnInfo);
ConnectionServiceInstance.TryFindConnection(
parameters.TargetEndpointInfo.OwnerUri,
out targetConnInfo);
CurrentSchemaCompareTask = Task.Run(async () =>
CurrentSchemaCompareTask = Task.Run(async () =>
{
SchemaCompareOperation operation = null;
try
{
SchemaCompareOperation operation = null;
operation = new SchemaCompareOperation(parameters, sourceConnInfo, targetConnInfo);
currentComparisonCancellationAction.Value[operation.OperationId] = operation.Cancel;
operation.Execute(parameters.TaskExecutionMode);
try
// add result to dictionary of results
schemaCompareResults.Value[operation.OperationId] = operation.ComparisonResult;
await requestContext.SendResult(new SchemaCompareResult()
{
operation = new SchemaCompareOperation(parameters, sourceConnInfo, targetConnInfo);
currentComparisonCancellationAction.Value[operation.OperationId] = operation.Cancel;
operation.Execute(parameters.TaskExecutionMode);
OperationId = operation.OperationId,
Success = operation.ComparisonResult.IsValid,
ErrorMessage = operation.ErrorMessage,
AreEqual = operation.ComparisonResult.IsEqual,
Differences = operation.Differences
});
// add result to dictionary of results
schemaCompareResults.Value[operation.OperationId] = operation.ComparisonResult;
await requestContext.SendResult(new SchemaCompareResult()
{
OperationId = operation.OperationId,
Success = operation.ComparisonResult.IsValid,
ErrorMessage = operation.ErrorMessage,
AreEqual = operation.ComparisonResult.IsEqual,
Differences = operation.Differences
});
// clean up cancellation action now that the operation is complete (using try remove to avoid exception)
Action cancelAction = null;
currentComparisonCancellationAction.Value.TryRemove(operation.OperationId, out cancelAction);
}
catch (Exception e)
// clean up cancellation action now that the operation is complete (using try remove to avoid exception)
Action cancelAction = null;
currentComparisonCancellationAction.Value.TryRemove(operation.OperationId, out cancelAction);
}
catch (Exception e)
{
Logger.Write(TraceEventType.Error, "Failed to compare schema. Error: " + e);
await requestContext.SendResult(new SchemaCompareResult()
{
Logger.Write(TraceEventType.Error, "Failed to compare schema. Error: " + e);
await requestContext.SendResult(new SchemaCompareResult()
{
OperationId = operation != null ? operation.OperationId : null,
Success = false,
ErrorMessage = operation == null ? e.Message : operation.ErrorMessage,
});
}
});
}
catch (Exception e)
{
await requestContext.SendError(e);
}
OperationId = operation != null ? operation.OperationId : null,
Success = false,
ErrorMessage = operation == null ? e.Message : operation.ErrorMessage,
});
}
});
return Task.CompletedTask;
}
/// <summary>
@@ -126,34 +120,26 @@ namespace Microsoft.SqlTools.ServiceLayer.SchemaCompare
/// <returns></returns>
public async Task HandleSchemaCompareCancelRequest(SchemaCompareCancelParams parameters, RequestContext<ResultStatus> requestContext)
{
try
Action cancelAction = null;
if (currentComparisonCancellationAction.Value.TryRemove(parameters.OperationId, out cancelAction))
{
Action cancelAction = null;
if (currentComparisonCancellationAction.Value.TryRemove(parameters.OperationId, out cancelAction))
{
if (cancelAction != null)
{
cancelAction.Invoke();
await requestContext.SendResult(new ResultStatus()
{
Success = true,
ErrorMessage = null
});
}
}
else
if (cancelAction != null)
{
cancelAction.Invoke();
await requestContext.SendResult(new ResultStatus()
{
Success = false,
ErrorMessage = SR.SchemaCompareSessionNotFound
Success = true,
ErrorMessage = null
});
}
}
catch (Exception e)
else
{
await requestContext.SendError(e);
await requestContext.SendResult(new ResultStatus()
{
Success = false,
ErrorMessage = SR.SchemaCompareSessionNotFound
});
}
}
@@ -294,7 +280,7 @@ namespace Microsoft.SqlTools.ServiceLayer.SchemaCompare
operation.Execute(parameters.TaskExecutionMode);
// update the comparison result if the include/exclude was successful
if(operation.Success)
if (operation.Success)
{
schemaCompareResults.Value[parameters.OperationId] = operation.ComparisonResult;
}
@@ -353,79 +339,66 @@ namespace Microsoft.SqlTools.ServiceLayer.SchemaCompare
/// <returns></returns>
public async Task HandleSchemaCompareOpenScmpRequest(SchemaCompareOpenScmpParams parameters, RequestContext<SchemaCompareOpenScmpResult> requestContext)
{
try
CurrentSchemaCompareTask = Task.Run(async () =>
{
CurrentSchemaCompareTask = Task.Run(async () =>
SchemaCompareOpenScmpOperation operation = null;
try
{
SchemaCompareOpenScmpOperation operation = null;
operation = new SchemaCompareOpenScmpOperation(parameters);
operation.Execute(TaskExecutionMode.Execute);
try
await requestContext.SendResult(operation.Result);
}
catch (Exception e)
{
await requestContext.SendResult(new SchemaCompareOpenScmpResult()
{
operation = new SchemaCompareOpenScmpOperation(parameters);
operation.Execute(TaskExecutionMode.Execute);
await requestContext.SendResult(operation.Result);
}
catch (Exception e)
{
await requestContext.SendResult(new SchemaCompareOpenScmpResult()
{
Success = false,
ErrorMessage = operation == null ? e.Message : operation.ErrorMessage,
});
}
});
}
catch (Exception e)
{
await requestContext.SendError(e);
}
Success = false,
ErrorMessage = operation == null ? e.Message : operation.ErrorMessage,
});
}
});
}
/// <summary>
/// Handles schema compare save SCMP request
/// </summary>
/// <returns></returns>
public async Task HandleSchemaCompareSaveScmpRequest(SchemaCompareSaveScmpParams parameters, RequestContext<ResultStatus> requestContext)
public Task HandleSchemaCompareSaveScmpRequest(SchemaCompareSaveScmpParams parameters, RequestContext<ResultStatus> requestContext)
{
try
{
ConnectionInfo sourceConnInfo;
ConnectionInfo targetConnInfo;
ConnectionServiceInstance.TryFindConnection(parameters.SourceEndpointInfo.OwnerUri, out sourceConnInfo);
ConnectionServiceInstance.TryFindConnection(parameters.TargetEndpointInfo.OwnerUri, out targetConnInfo);
ConnectionInfo sourceConnInfo;
ConnectionInfo targetConnInfo;
ConnectionServiceInstance.TryFindConnection(parameters.SourceEndpointInfo.OwnerUri, out sourceConnInfo);
ConnectionServiceInstance.TryFindConnection(parameters.TargetEndpointInfo.OwnerUri, out targetConnInfo);
CurrentSchemaCompareTask = Task.Run(async () =>
CurrentSchemaCompareTask = Task.Run(async () =>
{
SchemaCompareSaveScmpOperation operation = null;
try
{
SchemaCompareSaveScmpOperation operation = null;
operation = new SchemaCompareSaveScmpOperation(parameters, sourceConnInfo, targetConnInfo);
operation.Execute(parameters.TaskExecutionMode);
try
await requestContext.SendResult(new ResultStatus()
{
operation = new SchemaCompareSaveScmpOperation(parameters, sourceConnInfo, targetConnInfo);
operation.Execute(parameters.TaskExecutionMode);
await requestContext.SendResult(new ResultStatus()
{
Success = true,
ErrorMessage = operation.ErrorMessage,
});
}
catch (Exception e)
Success = true,
ErrorMessage = operation.ErrorMessage,
});
}
catch (Exception e)
{
Logger.Write(TraceEventType.Error, "Failed to save scmp file. Error: " + e);
await requestContext.SendResult(new SchemaCompareResult()
{
Logger.Write(TraceEventType.Error, "Failed to save scmp file. Error: " + e);
await requestContext.SendResult(new SchemaCompareResult()
{
OperationId = operation != null ? operation.OperationId : null,
Success = false,
ErrorMessage = operation == null ? e.Message : operation.ErrorMessage,
});
}
});
}
catch (Exception e)
{
await requestContext.SendError(e);
}
OperationId = operation != null ? operation.OperationId : null,
Success = false,
ErrorMessage = operation == null ? e.Message : operation.ErrorMessage,
});
}
});
return Task.CompletedTask;
}
private SqlTaskManager SqlTaskManagerInstance

126
src/Microsoft.SqlTools.ServiceLayer/Scripting/ScriptingService.cs
View File

@@ -22,7 +22,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Scripting
/// Main class for Scripting Service functionality
/// </summary>
public sealed class ScriptingService : IDisposable
{
{
private const int ScriptingOperationTimeout = 60000;
private static readonly Lazy<ScriptingService> LazyInstance = new Lazy<ScriptingService>(() => new ScriptingService());
@@ -84,75 +84,60 @@ namespace Microsoft.SqlTools.ServiceLayer.Scripting
/// </summary>
private async Task HandleListObjectsRequest(ScriptingListObjectsParams parameters, RequestContext<ScriptingListObjectsResult> requestContext)
{
try
{
ScriptingListObjectsOperation operation = new ScriptingListObjectsOperation(parameters);
operation.CompleteNotification += (sender, e) => requestContext.SendEvent(ScriptingListObjectsCompleteEvent.Type, e);
ScriptingListObjectsOperation operation = new ScriptingListObjectsOperation(parameters);
operation.CompleteNotification += (sender, e) => requestContext.SendEvent(ScriptingListObjectsCompleteEvent.Type, e);
RunTask(requestContext, operation);
RunTask(requestContext, operation);
await requestContext.SendResult(new ScriptingListObjectsResult { OperationId = operation.OperationId });
}
catch (Exception e)
{
await requestContext.SendError(e);
}
await requestContext.SendResult(new ScriptingListObjectsResult { OperationId = operation.OperationId });
}
/// <summary>
/// Handles request to start the scripting operation
/// </summary>
public async Task HandleScriptExecuteRequest(ScriptingParams parameters, RequestContext<ScriptingResult> requestContext)
public Task HandleScriptExecuteRequest(ScriptingParams parameters, RequestContext<ScriptingResult> requestContext)
{
SmoScriptingOperation operation = null;
try
// if a connection string wasn't provided as a parameter then
// use the owner uri property to lookup its associated ConnectionInfo
// and then build a connection string out of that
ConnectionInfo connInfo = null;
string accessToken = null;
if (parameters.ConnectionString == null)
{
// if a connection string wasn't provided as a parameter then
// use the owner uri property to lookup its associated ConnectionInfo
// and then build a connection string out of that
ConnectionInfo connInfo = null;
string accessToken = null;
if (parameters.ConnectionString == null)
ScriptingService.ConnectionServiceInstance.TryFindConnection(parameters.OwnerUri, out connInfo);
if (connInfo != null)
{
ScriptingService.ConnectionServiceInstance.TryFindConnection(parameters.OwnerUri, out connInfo);
if (connInfo != null)
{
parameters.ConnectionString = ConnectionService.BuildConnectionString(connInfo.ConnectionDetails);
accessToken = connInfo.ConnectionDetails.AzureAccountToken;
}
else
{
throw new Exception("Could not find ConnectionInfo");
}
}
if (parameters.FilePath == null)
{
// Create a temporary and random path to handle this operation
parameters.FilePath = Path.GetTempFileName();
}
if (!ShouldCreateScriptAsOperation(parameters))
{
operation = new ScriptingScriptOperation(parameters, accessToken);
parameters.ConnectionString = ConnectionService.BuildConnectionString(connInfo.ConnectionDetails);
accessToken = connInfo.ConnectionDetails.AzureAccountToken;
}
else
{
operation = new ScriptAsScriptingOperation(parameters, accessToken);
throw new Exception("Could not find ConnectionInfo");
}
operation.PlanNotification += (sender, e) => requestContext.SendEvent(ScriptingPlanNotificationEvent.Type, e).Wait();
operation.ProgressNotification += (sender, e) => requestContext.SendEvent(ScriptingProgressNotificationEvent.Type, e).Wait();
operation.CompleteNotification += (sender, e) => this.SendScriptingCompleteEvent(requestContext, ScriptingCompleteEvent.Type, e, operation, parameters.ScriptDestination);
RunTask(requestContext, operation);
}
catch (Exception e)
if (parameters.FilePath == null)
{
await requestContext.SendError(e);
// Create a temporary and random path to handle this operation
parameters.FilePath = Path.GetTempFileName();
}
if (!ShouldCreateScriptAsOperation(parameters))
{
operation = new ScriptingScriptOperation(parameters, accessToken);
}
else
{
operation = new ScriptAsScriptingOperation(parameters, accessToken);
}
operation.PlanNotification += (sender, e) => requestContext.SendEvent(ScriptingPlanNotificationEvent.Type, e).Wait();
operation.ProgressNotification += (sender, e) => requestContext.SendEvent(ScriptingProgressNotificationEvent.Type, e).Wait();
operation.CompleteNotification += (sender, e) => this.SendScriptingCompleteEvent(requestContext, ScriptingCompleteEvent.Type, e, operation, parameters.ScriptDestination);
RunTask(requestContext, operation);
return Task.CompletedTask;
}
private bool ShouldCreateScriptAsOperation(ScriptingParams parameters)
@@ -160,10 +145,10 @@ namespace Microsoft.SqlTools.ServiceLayer.Scripting
// Scripting as operation should be used to script one object.
// Scripting data and scripting to file is not supported by scripting as operation
// To script Select, alter and execute use scripting as operation. The other operation doesn't support those types
if( (parameters.ScriptingObjects != null && parameters.ScriptingObjects.Count == 1 && parameters.ScriptOptions != null
&& parameters.ScriptOptions.TypeOfDataToScript == "SchemaOnly" && parameters.ScriptDestination == "ToEditor") ||
parameters.Operation == ScriptingOperationType.Select || parameters.Operation == ScriptingOperationType.Execute ||
parameters.Operation == ScriptingOperationType.Alter)
if ((parameters.ScriptingObjects != null && parameters.ScriptingObjects.Count == 1 && parameters.ScriptOptions != null
&& parameters.ScriptOptions.TypeOfDataToScript == "SchemaOnly" && parameters.ScriptDestination == "ToEditor") ||
parameters.Operation == ScriptingOperationType.Select || parameters.Operation == ScriptingOperationType.Execute ||
parameters.Operation == ScriptingOperationType.Alter)
{
return true;
}
@@ -178,27 +163,20 @@ namespace Microsoft.SqlTools.ServiceLayer.Scripting
/// </summary>
public async Task HandleScriptCancelRequest(ScriptingCancelParams parameters, RequestContext<ScriptingCancelResult> requestContext)
{
try
ScriptingOperation operation = null;
if (this.ActiveOperations.TryRemove(parameters.OperationId, out operation))
{
ScriptingOperation operation = null;
if (this.ActiveOperations.TryRemove(parameters.OperationId, out operation))
{
operation.Cancel();
}
else
{
Logger.Write(TraceEventType.Information, string.Format("Operation {0} was not found", operation.OperationId));
}
operation.Cancel();
}
else
{
Logger.Write(TraceEventType.Information, string.Format("Operation {0} was not found", operation.OperationId));
}
await requestContext.SendResult(new ScriptingCancelResult());
}
catch (Exception e)
{
await requestContext.SendError(e);
}
await requestContext.SendResult(new ScriptingCancelResult());
}
private async void SendScriptingCompleteEvent<TParams>(RequestContext<ScriptingResult> requestContext, EventType<TParams> eventType, TParams parameters,
private async void SendScriptingCompleteEvent<TParams>(RequestContext<ScriptingResult> requestContext, EventType<TParams> eventType, TParams parameters,
SmoScriptingOperation operation, string scriptDestination)
{
await requestContext.SendEvent(eventType, parameters);
@@ -250,7 +228,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Scripting
if (!disposed)
{
disposed = true;
foreach (ScriptingScriptOperation operation in this.ActiveOperations.Values)
{
operation.Dispose();

1
test/Microsoft.SqlTools.ServiceLayer.IntegrationTests/Agent/AgentServiceTests.cs
View File

@@ -44,6 +44,7 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.Agent
/// Verify that a job history request returns the job history
/// </summary>
[Test]
[Ignore("Skipping test since it doesn't work - there's no jobs so it just immediately throws.")]
public async Task TestHandleJobHistoryRequests()
{
using (SelfCleaningTempFile queryTempFile = new SelfCleaningTempFile())

64
test/Microsoft.SqlTools.ServiceLayer.IntegrationTests/LanguageExtensibility/ExternalLanguageServiceTests.cs
View File

@@ -93,17 +93,17 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.LanguageExtensibility
{
ExternalLanguageOperations = operations.Object
};
await VerifyError<ExternalLanguageDeleteResponseParams>(
test: async (requestContext, connectionUrl) =>
{
ExternalLanguageDeleteRequestParams requestParams = new ExternalLanguageDeleteRequestParams
{
OwnerUri = connectionUrl,
LanguageName = language.Name
};
await service.HandleExternalLanguageDeleteRequest(requestParams, requestContext);
return null;
});
using (SelfCleaningTempFile queryTempFile = new SelfCleaningTempFile())
{
var connectionResult = await LiveConnectionHelper.InitLiveConnectionInfoAsync("master", queryTempFile.FilePath);
var requestContext = RequestContextMocks.Create<ExternalLanguageDeleteResponseParams>(r => { });
ExternalLanguageDeleteRequestParams requestParams = new ExternalLanguageDeleteRequestParams
{
OwnerUri = queryTempFile.FilePath,
LanguageName = language.Name
};
Assert.That(() => service.HandleExternalLanguageDeleteRequest(requestParams, requestContext.Object), Throws.Exception);
}
}
[Test]
@@ -174,17 +174,17 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.LanguageExtensibility
{
ExternalLanguageOperations = operations.Object
};
await VerifyError<ExternalLanguageUpdateResponseParams>(
test: async (requestContext, connectionUrl) =>
{
ExternalLanguageUpdateRequestParams requestParams = new ExternalLanguageUpdateRequestParams
{
OwnerUri = connectionUrl,
Language = language
};
await service.HandleExternalLanguageUpdateRequest(requestParams, requestContext);
return null;
});
using (SelfCleaningTempFile queryTempFile = new SelfCleaningTempFile())
{
var connectionResult = await LiveConnectionHelper.InitLiveConnectionInfoAsync("master", queryTempFile.FilePath);
var requestContext = RequestContextMocks.Create<ExternalLanguageUpdateResponseParams>(r => { });
ExternalLanguageUpdateRequestParams requestParams = new ExternalLanguageUpdateRequestParams
{
OwnerUri = queryTempFile.FilePath,
Language = language
};
Assert.That(() => service.HandleExternalLanguageUpdateRequest(requestParams, requestContext.Object), Throws.Exception);
}
}
[Test]
@@ -254,16 +254,16 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.LanguageExtensibility
{
ExternalLanguageOperations = operations.Object
};
await VerifyError<ExternalLanguageListResponseParams>(
test: async (requestContext, connectionUrl) =>
{
ExternalLanguageListRequestParams requestParams = new ExternalLanguageListRequestParams
{
OwnerUri = connectionUrl
};
await service.HandleExternalLanguageListRequest(requestParams, requestContext);
return null;
});
using (SelfCleaningTempFile queryTempFile = new SelfCleaningTempFile())
{
var connectionResult = await LiveConnectionHelper.InitLiveConnectionInfoAsync("master", queryTempFile.FilePath);
var requestContext = RequestContextMocks.Create<ExternalLanguageListResponseParams>(r => { });
var requestParams = new ExternalLanguageListRequestParams
{
OwnerUri = queryTempFile.FilePath
};
Assert.That(() => service.HandleExternalLanguageListRequest(requestParams, requestContext.Object), Throws.Exception);
}
}
[Test]

2
test/Microsoft.SqlTools.ServiceLayer.IntegrationTests/Scripting/ScriptingServiceTests.cs
View File

@@ -58,7 +58,7 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.Scripting
var scriptingParams = new ScriptingParams
{
OwnerUri = ConnectionService.BuildConnectionString(result.ConnectionInfo.ConnectionDetails)
OwnerUri = result.ScriptFile.ClientUri
};
if (isSelectScript)
{

54
test/Microsoft.SqlTools.ServiceLayer.UnitTests/Credentials/CredentialServiceTests.cs
View File

@@ -75,25 +75,19 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Credentials
}
[Test]
public async Task SaveCredentialThrowsIfCredentialIdMissing()
public void SaveCredentialThrowsIfCredentialIdMissing()
{
string errorResponse = null;
var contextMock = RequestContextMocks.Create<bool>(null).AddErrorHandling((msg, code, data) => errorResponse = msg);
await service.HandleSaveCredentialRequest(new Credential(null), contextMock.Object);
TestUtils.VerifyErrorSent(contextMock);
Assert.That(errorResponse, Does.Contain("ArgumentException"));
var contextMock = RequestContextMocks.Create<bool>(null);
// Verify throws with no ID
Assert.That(() => service.HandleSaveCredentialRequest(new Credential(null), contextMock.Object), Throws.ArgumentException);
}
[Test]
public async Task SaveCredentialThrowsIfPasswordMissing()
public void SaveCredentialThrowsIfPasswordMissing()
{
string errorResponse = null;
var contextMock = RequestContextMocks.Create<bool>(null).AddErrorHandling((msg, code, data) => errorResponse = msg);
await service.HandleSaveCredentialRequest(new Credential(CredentialId), contextMock.Object);
TestUtils.VerifyErrorSent(contextMock);
Assert.True(errorResponse.Contains("ArgumentException") || errorResponse.Contains("ArgumentNullException"));
var contextMock = RequestContextMocks.Create<bool>(null);
// Verify throws with no ID
Assert.That(() => service.HandleSaveCredentialRequest(new Credential(CredentialId), contextMock.Object), Throws.ArgumentNullException);
}
[Test]
@@ -193,27 +187,11 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Credentials
}
[Test]
public async Task ReadCredentialThrowsIfCredentialIsNull()
public void ReadCredentialThrowsIfCredentialIsNull()
{
string errorResponse = null;
var contextMock = RequestContextMocks.Create<Credential>(null).AddErrorHandling((msg, code, data) => errorResponse = msg);
// Verify throws on null, and this is sent as an error
await service.HandleReadCredentialRequest(null, contextMock.Object);
TestUtils.VerifyErrorSent(contextMock);
Assert.That(errorResponse, Does.Contain("ArgumentNullException"));
}
[Test]
public async Task ReadCredentialThrowsIfIdMissing()
{
string errorResponse = null;
var contextMock = RequestContextMocks.Create<Credential>(null).AddErrorHandling((msg, code, data) => errorResponse = msg);
var contextMock = RequestContextMocks.Create<Credential>(null);
// Verify throws with no ID
await service.HandleReadCredentialRequest(new Credential(), contextMock.Object);
TestUtils.VerifyErrorSent(contextMock);
Assert.That(errorResponse, Does.Contain("ArgumentException"));
Assert.That(() => service.HandleReadCredentialRequest(new Credential(), contextMock.Object), Throws.ArgumentException);
}
[Test]
@@ -235,15 +213,11 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Credentials
}
[Test]
public async Task DeleteCredentialThrowsIfIdMissing()
public void DeleteCredentialThrowsIfIdMissing()
{
object errorResponse = null;
var contextMock = RequestContextMocks.Create<bool>(null).AddErrorHandling((msg, code, data) => errorResponse = msg);
var contextMock = RequestContextMocks.Create<bool>(null);
// Verify throws with no ID
await service.HandleDeleteCredentialRequest(new Credential(), contextMock.Object);
TestUtils.VerifyErrorSent(contextMock);
Assert.True(((string)errorResponse).Contains("ArgumentException"));
Assert.That(() => service.HandleDeleteCredentialRequest(new Credential(), contextMock.Object), Throws.ArgumentException);
}
[Test]

59
test/Microsoft.SqlTools.ServiceLayer.UnitTests/EditData/ServiceIntegrationTests.cs
View File

@@ -26,7 +26,7 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.EditData
#region EditSession Operation Helper Tests
[Test]
public async Task NullOrMissingSessionId([Values(null, "", " \t\n\r", "Does not exist")] string sessionId)
public void NullOrMissingSessionId([Values(null, "", " \t\n\r", "Does not exist")] string sessionId)
{
// Setup:
// ... Create a edit data service
@@ -34,14 +34,10 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.EditData
// ... Create a session params that returns the provided session ID
var mockParams = new EditCreateRowParams {OwnerUri = sessionId};
var contextMock = RequestContextMocks.Create<EditDisposeResult>(null);
// If: I ask to perform an action that requires a session
// Then: I should get an error from it
var efv = new EventFlowValidator<EditDisposeResult>()
.AddStandardErrorValidation()
.Complete();
await eds.HandleSessionRequest(mockParams, efv.Object, session => null);
efv.Validate();
Assert.That(() => eds.HandleSessionRequest(mockParams, contextMock.Object, session => null), Throws.Exception);
}
[Test]
@@ -54,14 +50,10 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.EditData
// ... Create a session param that returns the common owner uri
var mockParams = new EditCreateRowParams { OwnerUri = Common.OwnerUri };
var contextMock = RequestContextMocks.Create<EditDisposeResult>(null);
// If: I ask to perform an action that requires a session
// Then: I should get an error from it
var efv = new EventFlowValidator<EditDisposeResult>()
.AddStandardErrorValidation()
.Complete();
await eds.HandleSessionRequest(mockParams, efv.Object, s => { throw new Exception(); });
efv.Validate();
Assert.That(() => eds.HandleSessionRequest(mockParams, contextMock.Object, s => { throw new Exception(); }), Throws.Exception);
}
@@ -71,18 +63,15 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.EditData
#region Dispose Tests
[Test]
public async Task DisposeNullOrMissingSessionId([Values(null, "", " \t\n\r", "Does not exist")] string sessionId)
public void DisposeNullOrMissingSessionId([Values(null, "", " \t\n\r", "Does not exist")] string sessionId)
{
// Setup: Create a edit data service
var eds = new EditDataService(null, null, null);
// If: I ask to perform an action that requires a session
// Then: I should get an error from it
var efv = new EventFlowValidator<EditDisposeResult>()
.AddStandardErrorValidation()
.Complete();
await eds.HandleDisposeRequest(new EditDisposeParams {OwnerUri = sessionId}, efv.Object);
efv.Validate();
var contextMock = RequestContextMocks.Create<EditDisposeResult>(null);
Assert.That(() => eds.HandleDisposeRequest(new EditDisposeParams { OwnerUri = sessionId }, contextMock.Object), Throws.Exception);
}
[Test]
@@ -293,16 +282,11 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.EditData
OwnerUri = ownerUri,
ObjectType = objType
};
// ... And I initialize an edit session with that
var efv = new EventFlowValidator<EditInitializeResult>()
.AddStandardErrorValidation()
.Complete();
await eds.HandleInitializeRequest(initParams, efv.Object);
// Then:
// ... An error event should have been raised
efv.Validate();
var contextMock = RequestContextMocks.Create<EditInitializeResult>(null);
// ... And I initialize an edit session with that
// Then:
// ... An error event should have been sent
Assert.That(() => eds.HandleInitializeRequest(initParams, contextMock.Object), Throws.ArgumentException);
// ... There should not be a session
Assert.That(eds.ActiveSessions, Is.Empty);
@@ -324,16 +308,13 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.EditData
ObjectType = "Table",
Filters = new EditInitializeFiltering()
};
var efv = new EventFlowValidator<EditInitializeResult>()
.AddStandardErrorValidation()
.Complete();
await eds.HandleInitializeRequest(initParams, efv.Object);
// Then:
// ... An error event should have been sent
efv.Validate();
// ... The original session should still be there
var contextMock = RequestContextMocks.Create<EditInitializeResult>(null);
// Then:
// ... An error event should have been sent
Assert.That(() => eds.HandleInitializeRequest(initParams, contextMock.Object), Throws.ArgumentNullException);
// ... The original session should still be there
Assert.AreEqual(1, eds.ActiveSessions.Count);
Assert.AreEqual(session, eds.ActiveSessions[Constants.OwnerUri]);
}

14
test/Microsoft.SqlTools.ServiceLayer.UnitTests/QueryExecution/ExecutionPlanTests.cs
View File

@@ -198,11 +198,8 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.QueryExecution
// ... And I then ask for a valid execution plan from it
var executionPlanParams = new QueryExecutionPlanParams { OwnerUri = Constants.OwnerUri, ResultSetIndex = 0, BatchIndex = 0 };
var executionPlanRequest = new EventFlowValidator<QueryExecutionPlanResult>()
.AddStandardErrorValidation()
.Complete();
await queryService.HandleExecutionPlanRequest(executionPlanParams, executionPlanRequest.Object);
executionPlanRequest.Validate();
var contextMock = RequestContextMocks.Create<QueryExecutionPlanResult>(null);
Assert.That(() => queryService.HandleExecutionPlanRequest(executionPlanParams, contextMock.Object), Throws.InvalidOperationException);
}
[Test]
@@ -229,11 +226,8 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.QueryExecution
// ... And I then ask for an execution plan from a result set
var executionPlanParams = new QueryExecutionPlanParams { OwnerUri = Constants.OwnerUri, ResultSetIndex = 0, BatchIndex = 0 };
var executionPlanRequest = new EventFlowValidator<QueryExecutionPlanResult>()
.AddStandardErrorValidation()
.Complete();
await queryService.HandleExecutionPlanRequest(executionPlanParams, executionPlanRequest.Object);
executionPlanRequest.Validate();
var contextMock = RequestContextMocks.Create<QueryExecutionPlanResult>(null);
Assert.ThrowsAsync<ArgumentOutOfRangeException>(() => queryService.HandleExecutionPlanRequest(executionPlanParams, contextMock.Object));
}
#endregion

21
test/Microsoft.SqlTools.ServiceLayer.UnitTests/QueryExecution/SubsetTests.cs
View File

@@ -163,11 +163,8 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.QueryExecution
var workspaceService = Common.GetPrimedWorkspaceService(Constants.StandardQuery);
var queryService = Common.GetPrimedExecutionService(null, true, false, false, workspaceService);
var subsetParams = new SubsetParams { OwnerUri = Constants.OwnerUri, RowsCount = 1, ResultSetIndex = 0, RowsStartIndex = 0 };
var subsetRequest = new EventFlowValidator<SubsetResult>()
.AddStandardErrorValidation()
.Complete();
await queryService.HandleResultSubsetRequest(subsetParams, subsetRequest.Object);
subsetRequest.Validate();
var contextMock = RequestContextMocks.Create<SubsetResult>(null);
Assert.ThrowsAsync<ArgumentOutOfRangeException>(() => queryService.HandleResultSubsetRequest(subsetParams, contextMock.Object));
}
[Test]
@@ -186,11 +183,8 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.QueryExecution
// ... And I then ask for a valid set of results from it
var subsetParams = new SubsetParams { OwnerUri = Constants.OwnerUri, RowsCount = 1, ResultSetIndex = 0, RowsStartIndex = 0 };
var subsetRequest = new EventFlowValidator<SubsetResult>()
.AddStandardErrorValidation()
.Complete();
await queryService.HandleResultSubsetRequest(subsetParams, subsetRequest.Object);
subsetRequest.Validate();
var contextMock = RequestContextMocks.Create<SubsetResult>(null);
Assert.That(() => queryService.HandleResultSubsetRequest(subsetParams, contextMock.Object), Throws.InvalidOperationException);
}
[Test]
@@ -208,11 +202,8 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.QueryExecution
// ... And I then ask for a set of results from it
var subsetParams = new SubsetParams { OwnerUri = Constants.OwnerUri, RowsCount = 1, ResultSetIndex = 0, RowsStartIndex = 0 };
var subsetRequest = new EventFlowValidator<SubsetResult>()
.AddStandardErrorValidation()
.Complete();
await queryService.HandleResultSubsetRequest(subsetParams, subsetRequest.Object);
subsetRequest.Validate();
var contextMock = RequestContextMocks.Create<SubsetResult>(null);
Assert.ThrowsAsync<ArgumentOutOfRangeException>(() => queryService.HandleResultSubsetRequest(subsetParams, contextMock.Object));
}
#endregion