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

Re-enable parallel message processing (#1741)

Browse Source 
* add flag to handler

* cleanup

* concurrency control

* add flag for handler setters

* update service flags

* fix event handlers

* more handlers

* make sure behavior is unchanged if flag is off

* cleanup

* add test case for parallel processing

* comments

* stop dispatcher in test

* add log for request lifespan

* cleanup and add comments

* correctly release semaphore

* remove deleted file from merge

* use await for semaphore release

* move handler invocation to await and adjust test

* cleanup exception handling and wrapper

* space

* loose assertion condition to make test stable
This commit is contained in:
Hai Cao
2022-12-11 00:05:33 -08:00
committed by GitHub
parent c304f54ca2
commit f86ebae9b8
37 changed files with 350 additions and 245 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/Microsoft.SqlTools.Hosting/Hosting/Protocol/Channel/ChannelBase.cs
View File

@@ -23,7 +23,7 @@ namespace Microsoft.SqlTools.Hosting.Protocol.Channel
/// <summary>
/// Gets the MessageReader for reading messages from the channel.
/// </summary>
public MessageReader MessageReader { get; protected set; }
public virtual MessageReader MessageReader { get; protected set; } // mark as virtual for mocking ChannelBase in UT
/// <summary>
/// Gets the MessageWriter for writing messages to the channel.

38
src/Microsoft.SqlTools.Hosting/Hosting/Protocol/IProtocolEndpoint.cs
View File

@@ -16,17 +16,43 @@ namespace Microsoft.SqlTools.Hosting.Protocol
/// </summary>
public interface IProtocolEndpoint : IEventSender, IRequestSender
{
/// <summary>
/// Set a request handler
/// </summary>
/// <typeparam name="TParams">type of parameter</typeparam>
/// <typeparam name="TResult">type of result</typeparam>
/// <param name="requestType">request type</param>
/// <param name="requestHandler">request handler</param>
/// <param name="isParallelProcessingSupported">whether this handler supports parallel processing</param>
void SetRequestHandler<TParams, TResult>(
RequestType<TParams, TResult> requestType,
Func<TParams, RequestContext<TResult>, Task> requestHandler);
void SetEventHandler<TParams>(
EventType<TParams> eventType,
Func<TParams, EventContext, Task> eventHandler);
Func<TParams, RequestContext<TResult>, Task> requestHandler,
bool isParallelProcessingSupported = false);
/// <summary>
/// Set an request handler
/// </summary>
/// <typeparam name="TParams">type of parameter</typeparam>
/// <param name="eventType">type of event</param>
/// <param name="eventHandler">event handler</param>
/// <param name="isParallelProcessingSupported">whether this handler supports parallel processing</param>
void SetEventHandler<TParams>(
EventType<TParams> eventType,
Func<TParams, EventContext, Task> eventHandler,
bool overrideExisting);
bool isParallelProcessingSupported = false);
/// <summary>
/// Set an request handler
/// </summary>
/// <typeparam name="TParams">type of parameter</typeparam>
/// <param name="eventType">type of event</param>
/// <param name="eventHandler">event handler</param>
/// <param name="overrideExisting">whether to override the existing handler for the same event type</param>
/// <param name="isParallelProcessingSupported">whether this handler supports parallel processing</param>
void SetEventHandler<TParams>(
EventType<TParams> eventType,
Func<TParams, EventContext, Task> eventHandler,
bool overrideExisting,
bool isParallelProcessingSupported = false);
}
}

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

@@ -27,14 +27,22 @@ namespace Microsoft.SqlTools.Hosting.Protocol
internal Dictionary<string, Func<Message, MessageWriter, Task>> requestHandlers =
new Dictionary<string, Func<Message, MessageWriter, Task>>();
internal Dictionary<string, bool> requestHandlerParallelismMap =
new Dictionary<string, bool>();
internal Dictionary<string, Func<Message, MessageWriter, Task>> eventHandlers =
new Dictionary<string, Func<Message, MessageWriter, Task>>();
internal Dictionary<string, bool> eventHandlerParallelismMap =
new Dictionary<string, bool>();
private Action<Message> responseHandler;
private CancellationTokenSource messageLoopCancellationToken =
new CancellationTokenSource();
private SemaphoreSlim semaphore = new SemaphoreSlim(10); // Limit to 10 threads to begin with, ideally there shouldn't be any limitation
#endregion
#region Properties
@@ -112,7 +120,8 @@ namespace Microsoft.SqlTools.Hosting.Protocol
public void SetRequestHandler<TParams, TResult>(
RequestType<TParams, TResult> requestType,
Func<TParams, RequestContext<TResult>, Task> requestHandler,
bool overrideExisting)
bool overrideExisting,
bool isParallelProcessingSupported = false)
{
if (overrideExisting)
{
@@ -120,16 +129,18 @@ namespace Microsoft.SqlTools.Hosting.Protocol
this.requestHandlers.Remove(requestType.MethodName);
}
this.requestHandlerParallelismMap.Add(requestType.MethodName, isParallelProcessingSupported);
this.requestHandlers.Add(
requestType.MethodName,
async (requestMessage, messageWriter) =>
{
Logger.Write(TraceEventType.Verbose, $"Processing message with id[{requestMessage.Id}], of type[{requestMessage.MessageType}] and method[{requestMessage.Method}]");
var requestContext =
new RequestContext<TResult>(
requestMessage,
messageWriter);
try
{
{
TParams typedParams = default(TParams);
if (requestMessage.Contents != null)
{
@@ -144,6 +155,7 @@ namespace Microsoft.SqlTools.Hosting.Protocol
}
await requestHandler(typedParams, requestContext);
Logger.Write(TraceEventType.Verbose, $"Finished processing message with id[{requestMessage.Id}], of type[{requestMessage.MessageType}] and method[{requestMessage.Method}]");
}
catch (Exception ex)
{
@@ -166,7 +178,8 @@ namespace Microsoft.SqlTools.Hosting.Protocol
public void SetEventHandler<TParams>(
EventType<TParams> eventType,
Func<TParams, EventContext, Task> eventHandler,
bool overrideExisting)
bool overrideExisting,
bool isParallelProcessingSupported = false)
{
if (overrideExisting)
{
@@ -174,14 +187,16 @@ namespace Microsoft.SqlTools.Hosting.Protocol
this.eventHandlers.Remove(eventType.MethodName);
}
this.eventHandlerParallelismMap.Add(eventType.MethodName, isParallelProcessingSupported);
this.eventHandlers.Add(
eventType.MethodName,
async (eventMessage, messageWriter) =>
{
Logger.Write(TraceEventType.Verbose, $"Processing message with id[{eventMessage.Id}], of type[{eventMessage.MessageType}] and method[{eventMessage.Method}]");
var eventContext = new EventContext(messageWriter);
TParams typedParams = default(TParams);
try
{
{
if (eventMessage.Contents != null)
{
try
@@ -194,6 +209,7 @@ namespace Microsoft.SqlTools.Hosting.Protocol
}
}
await eventHandler(typedParams, eventContext);
Logger.Write(TraceEventType.Verbose, $"Finished processing message with id[{eventMessage.Id}], of type[{eventMessage.MessageType}] and method[{eventMessage.Method}]");
}
catch (Exception ex)
{
@@ -284,19 +300,13 @@ namespace Microsoft.SqlTools.Hosting.Protocol
Message messageToDispatch,
MessageWriter messageWriter)
{
Task handlerToAwait = null;
Func<Message, MessageWriter, Task> handlerToAwait = null;
bool isParallelProcessingSupported = false;
if (messageToDispatch.MessageType == MessageType.Request)
{
Func<Message, MessageWriter, Task> requestHandler = null;
if (this.requestHandlers.TryGetValue(messageToDispatch.Method, out requestHandler))
{
handlerToAwait = requestHandler(messageToDispatch, messageWriter);
}
// else
// {
// // TODO: Message not supported error
// }
this.requestHandlers.TryGetValue(messageToDispatch.Method, out handlerToAwait);
this.requestHandlerParallelismMap.TryGetValue(messageToDispatch.Method, out isParallelProcessingSupported);
}
else if (messageToDispatch.MessageType == MessageType.Response)
{
@@ -307,15 +317,8 @@ namespace Microsoft.SqlTools.Hosting.Protocol
}
else if (messageToDispatch.MessageType == MessageType.Event)
{
Func<Message, MessageWriter, Task> eventHandler = null;
if (this.eventHandlers.TryGetValue(messageToDispatch.Method, out eventHandler))
{
handlerToAwait = eventHandler(messageToDispatch, messageWriter);
}
else
{
// TODO: Message not supported error
}
this.eventHandlers.TryGetValue(messageToDispatch.Method, out handlerToAwait);
this.eventHandlerParallelismMap.TryGetValue(messageToDispatch.Method, out isParallelProcessingSupported);
}
// else
// {
@@ -324,39 +327,37 @@ namespace Microsoft.SqlTools.Hosting.Protocol
if (handlerToAwait != null)
{
if (this.ParallelMessageProcessing)
try
{
// Run the task in a separate thread so that the main
// thread is not blocked.
_ = Task.Run(() =>
if (this.ParallelMessageProcessing && isParallelProcessingSupported)
{
_ = RunTask(handlerToAwait);
});
// Run the task in a separate thread so that the main
// thread is not blocked. Use semaphore to limit the degree of parallelism.
await semaphore.WaitAsync();
_ = Task.Run(async () =>
{
await handlerToAwait(messageToDispatch, messageWriter);
semaphore.Release();
});
}
else
{
await handlerToAwait(messageToDispatch, messageWriter);
}
}
else
catch (TaskCanceledException e)
{
await RunTask(handlerToAwait);
// Some tasks may be cancelled due to legitimate
// timeouts so don't let those exceptions go higher.
Logger.Write(TraceEventType.Verbose, string.Format("A TaskCanceledException occurred in the request handler: {0}", e.ToString()));
}
}
}
private async Task RunTask(Task task)
{
try
{
await task;
}
catch (TaskCanceledException)
{
// Some tasks may be cancelled due to legitimate
// timeouts so don't let those exceptions go higher.
}
catch (Exception e)
{
if (!(e is AggregateException && ((AggregateException)e).InnerExceptions[0] is TaskCanceledException))
catch (Exception e)
{
// Log the error but don't rethrow it to prevent any errors in the handler from crashing the service
Logger.Write(TraceEventType.Error, string.Format("An unexpected error occured in the request handler: {0}", e.ToString()));
if (!(e is AggregateException && ((AggregateException)e).InnerExceptions[0] is TaskCanceledException))
{
// Log the error but don't rethrow it to prevent any errors in the handler from crashing the service
Logger.Write(TraceEventType.Error, string.Format("An unexpected error occurred in the request handler: {0}", e.ToString()));
}
}
}
}

3
src/Microsoft.SqlTools.Hosting/Hosting/Protocol/MessageReader.cs
View File

@@ -49,6 +49,7 @@ namespace Microsoft.SqlTools.Hosting.Protocol
#endregion
#region Constructors
public MessageReader() {} // added for mocking MessageReader in UT
public MessageReader(
Stream inputStream,
@@ -74,7 +75,7 @@ namespace Microsoft.SqlTools.Hosting.Protocol
#region Public Methods
public async Task<Message> ReadMessage()
public virtual async Task<Message> ReadMessage() // mark as virtual for mocking MessageReader in UT
{
string messageContent = null;

35
src/Microsoft.SqlTools.Hosting/Hosting/Protocol/ProtocolEndpoint.cs
View File

@@ -272,32 +272,39 @@ namespace Microsoft.SqlTools.Hosting.Protocol
public void SetRequestHandler<TParams, TResult>(
RequestType<TParams, TResult> requestType,
Func<TParams, RequestContext<TResult>, Task> requestHandler)
Func<TParams, RequestContext<TResult>, Task> requestHandler,
bool isParallelProcessingSupported = false)
{
this.MessageDispatcher.SetRequestHandler(
requestType,
requestHandler);
}
public void SetEventHandler<TParams>(
EventType<TParams> eventType,
Func<TParams, EventContext, Task> eventHandler)
{
this.MessageDispatcher.SetEventHandler(
eventType,
eventHandler,
false);
requestHandler,
false,
isParallelProcessingSupported);
}
public void SetEventHandler<TParams>(
EventType<TParams> eventType,
Func<TParams, EventContext, Task> eventHandler,
bool overrideExisting)
bool isParallelProcessingSupported = false)
{
this.MessageDispatcher.SetEventHandler(
eventType,
eventHandler,
overrideExisting);
false,
isParallelProcessingSupported);
}
public void SetEventHandler<TParams>(
EventType<TParams> eventType,
Func<TParams, EventContext, Task> eventHandler,
bool overrideExisting,
bool isParallelProcessingSupported = false)
{
this.MessageDispatcher.SetEventHandler(
eventType,
eventHandler,
overrideExisting,
isParallelProcessingSupported);
}
private void HandleResponse(Message responseMessage)

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

@@ -65,10 +65,10 @@ namespace Microsoft.SqlTools.ServiceLayer.Admin
/// </summary>
public void InitializeService(ServiceHost serviceHost)
{
serviceHost.SetRequestHandler(CreateDatabaseRequest.Type, HandleCreateDatabaseRequest);
serviceHost.SetRequestHandler(CreateLoginRequest.Type, HandleCreateLoginRequest);
serviceHost.SetRequestHandler(DefaultDatabaseInfoRequest.Type, HandleDefaultDatabaseInfoRequest);
serviceHost.SetRequestHandler(GetDatabaseInfoRequest.Type, HandleGetDatabaseInfoRequest);
serviceHost.SetRequestHandler(CreateDatabaseRequest.Type, HandleCreateDatabaseRequest, true);
serviceHost.SetRequestHandler(CreateLoginRequest.Type, HandleCreateLoginRequest, true);
serviceHost.SetRequestHandler(DefaultDatabaseInfoRequest.Type, HandleDefaultDatabaseInfoRequest, true);
serviceHost.SetRequestHandler(GetDatabaseInfoRequest.Type, HandleGetDatabaseInfoRequest, true);
}
/// <summary>

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

@@ -79,56 +79,56 @@ namespace Microsoft.SqlTools.ServiceLayer.Agent
this.ServiceHost = serviceHost;
// Jobs request handlers
this.ServiceHost.SetRequestHandler(AgentJobsRequest.Type, HandleAgentJobsRequest);
this.ServiceHost.SetRequestHandler(AgentJobHistoryRequest.Type, HandleJobHistoryRequest);
this.ServiceHost.SetRequestHandler(AgentJobActionRequest.Type, HandleJobActionRequest);
this.ServiceHost.SetRequestHandler(AgentJobsRequest.Type, HandleAgentJobsRequest, true);
this.ServiceHost.SetRequestHandler(AgentJobHistoryRequest.Type, HandleJobHistoryRequest, true);
this.ServiceHost.SetRequestHandler(AgentJobActionRequest.Type, HandleJobActionRequest, true);
this.ServiceHost.SetRequestHandler(CreateAgentJobRequest.Type, HandleCreateAgentJobRequest);
this.ServiceHost.SetRequestHandler(UpdateAgentJobRequest.Type, HandleUpdateAgentJobRequest);
this.ServiceHost.SetRequestHandler(DeleteAgentJobRequest.Type, HandleDeleteAgentJobRequest);
this.ServiceHost.SetRequestHandler(CreateAgentJobRequest.Type, HandleCreateAgentJobRequest, true);
this.ServiceHost.SetRequestHandler(UpdateAgentJobRequest.Type, HandleUpdateAgentJobRequest, true);
this.ServiceHost.SetRequestHandler(DeleteAgentJobRequest.Type, HandleDeleteAgentJobRequest, true);
this.ServiceHost.SetRequestHandler(AgentJobDefaultsRequest.Type, HandleAgentJobDefaultsRequest);
this.ServiceHost.SetRequestHandler(AgentJobDefaultsRequest.Type, HandleAgentJobDefaultsRequest, true);
// Job Steps request handlers
this.ServiceHost.SetRequestHandler(CreateAgentJobStepRequest.Type, HandleCreateAgentJobStepRequest);
this.ServiceHost.SetRequestHandler(UpdateAgentJobStepRequest.Type, HandleUpdateAgentJobStepRequest);
this.ServiceHost.SetRequestHandler(DeleteAgentJobStepRequest.Type, HandleDeleteAgentJobStepRequest);
this.ServiceHost.SetRequestHandler(CreateAgentJobStepRequest.Type, HandleCreateAgentJobStepRequest, true);
this.ServiceHost.SetRequestHandler(UpdateAgentJobStepRequest.Type, HandleUpdateAgentJobStepRequest, true);
this.ServiceHost.SetRequestHandler(DeleteAgentJobStepRequest.Type, HandleDeleteAgentJobStepRequest, true);
// Alerts request handlers
this.ServiceHost.SetRequestHandler(AgentAlertsRequest.Type, HandleAgentAlertsRequest);
this.ServiceHost.SetRequestHandler(CreateAgentAlertRequest.Type, HandleCreateAgentAlertRequest);
this.ServiceHost.SetRequestHandler(UpdateAgentAlertRequest.Type, HandleUpdateAgentAlertRequest);
this.ServiceHost.SetRequestHandler(DeleteAgentAlertRequest.Type, HandleDeleteAgentAlertRequest);
this.ServiceHost.SetRequestHandler(AgentAlertsRequest.Type, HandleAgentAlertsRequest, true);
this.ServiceHost.SetRequestHandler(CreateAgentAlertRequest.Type, HandleCreateAgentAlertRequest, true);
this.ServiceHost.SetRequestHandler(UpdateAgentAlertRequest.Type, HandleUpdateAgentAlertRequest, true);
this.ServiceHost.SetRequestHandler(DeleteAgentAlertRequest.Type, HandleDeleteAgentAlertRequest, true);
// Operators request handlers
this.ServiceHost.SetRequestHandler(AgentOperatorsRequest.Type, HandleAgentOperatorsRequest);
this.ServiceHost.SetRequestHandler(CreateAgentOperatorRequest.Type, HandleCreateAgentOperatorRequest);
this.ServiceHost.SetRequestHandler(UpdateAgentOperatorRequest.Type, HandleUpdateAgentOperatorRequest);
this.ServiceHost.SetRequestHandler(DeleteAgentOperatorRequest.Type, HandleDeleteAgentOperatorRequest);
this.ServiceHost.SetRequestHandler(AgentOperatorsRequest.Type, HandleAgentOperatorsRequest, true);
this.ServiceHost.SetRequestHandler(CreateAgentOperatorRequest.Type, HandleCreateAgentOperatorRequest, true);
this.ServiceHost.SetRequestHandler(UpdateAgentOperatorRequest.Type, HandleUpdateAgentOperatorRequest, true);
this.ServiceHost.SetRequestHandler(DeleteAgentOperatorRequest.Type, HandleDeleteAgentOperatorRequest, true);
// Proxy Accounts request handlers
this.ServiceHost.SetRequestHandler(AgentProxiesRequest.Type, HandleAgentProxiesRequest);
this.ServiceHost.SetRequestHandler(CreateAgentProxyRequest.Type, HandleCreateAgentProxyRequest);
this.ServiceHost.SetRequestHandler(UpdateAgentProxyRequest.Type, HandleUpdateAgentProxyRequest);
this.ServiceHost.SetRequestHandler(DeleteAgentProxyRequest.Type, HandleDeleteAgentProxyRequest);
this.ServiceHost.SetRequestHandler(AgentProxiesRequest.Type, HandleAgentProxiesRequest, true);
this.ServiceHost.SetRequestHandler(CreateAgentProxyRequest.Type, HandleCreateAgentProxyRequest, true);
this.ServiceHost.SetRequestHandler(UpdateAgentProxyRequest.Type, HandleUpdateAgentProxyRequest, true);
this.ServiceHost.SetRequestHandler(DeleteAgentProxyRequest.Type, HandleDeleteAgentProxyRequest, true);
// Schedule request handlers
this.ServiceHost.SetRequestHandler(AgentSchedulesRequest.Type, HandleAgentSchedulesRequest);
this.ServiceHost.SetRequestHandler(CreateAgentScheduleRequest.Type, HandleCreateAgentScheduleRequest);
this.ServiceHost.SetRequestHandler(UpdateAgentScheduleRequest.Type, HandleUpdateAgentScheduleRequest);
this.ServiceHost.SetRequestHandler(DeleteAgentScheduleRequest.Type, HandleDeleteAgentScheduleRequest);
this.ServiceHost.SetRequestHandler(AgentSchedulesRequest.Type, HandleAgentSchedulesRequest, true);
this.ServiceHost.SetRequestHandler(CreateAgentScheduleRequest.Type, HandleCreateAgentScheduleRequest, true);
this.ServiceHost.SetRequestHandler(UpdateAgentScheduleRequest.Type, HandleUpdateAgentScheduleRequest, true);
this.ServiceHost.SetRequestHandler(DeleteAgentScheduleRequest.Type, HandleDeleteAgentScheduleRequest, true);
// Notebook request handlers
this.ServiceHost.SetRequestHandler(AgentNotebooksRequest.Type, HandleAgentNotebooksRequest);
this.ServiceHost.SetRequestHandler(AgentNotebookHistoryRequest.Type, HandleAgentNotebookHistoryRequest);
this.ServiceHost.SetRequestHandler(AgentNotebookMaterializedRequest.Type, HandleAgentNotebookMaterializedRequest);
this.ServiceHost.SetRequestHandler(AgentNotebookTemplateRequest.Type, HandleAgentNotebookTemplateRequest);
this.ServiceHost.SetRequestHandler(CreateAgentNotebookRequest.Type, HandleCreateAgentNotebookRequest);
this.ServiceHost.SetRequestHandler(DeleteAgentNotebookRequest.Type, HandleDeleteAgentNotebooksRequest);
this.ServiceHost.SetRequestHandler(UpdateAgentNotebookRequest.Type, HandleUpdateAgentNotebookRequest);
this.ServiceHost.SetRequestHandler(UpdateAgentNotebookRunPinRequest.Type, HandleUpdateAgentNotebookRunPinRequest);
this.ServiceHost.SetRequestHandler(UpdateAgentNotebookRunNameRequest.Type, HandleUpdateAgentNotebookRunNameRequest);
this.ServiceHost.SetRequestHandler(DeleteNotebookMaterializedRequest.Type, HandleDeleteNotebookMaterializedRequest);
this.ServiceHost.SetRequestHandler(AgentNotebooksRequest.Type, HandleAgentNotebooksRequest, true);
this.ServiceHost.SetRequestHandler(AgentNotebookHistoryRequest.Type, HandleAgentNotebookHistoryRequest, true);
this.ServiceHost.SetRequestHandler(AgentNotebookMaterializedRequest.Type, HandleAgentNotebookMaterializedRequest, true);
this.ServiceHost.SetRequestHandler(AgentNotebookTemplateRequest.Type, HandleAgentNotebookTemplateRequest, true);
this.ServiceHost.SetRequestHandler(CreateAgentNotebookRequest.Type, HandleCreateAgentNotebookRequest, true);
this.ServiceHost.SetRequestHandler(DeleteAgentNotebookRequest.Type, HandleDeleteAgentNotebooksRequest, true);
this.ServiceHost.SetRequestHandler(UpdateAgentNotebookRequest.Type, HandleUpdateAgentNotebookRequest, true);
this.ServiceHost.SetRequestHandler(UpdateAgentNotebookRunPinRequest.Type, HandleUpdateAgentNotebookRunPinRequest, true);
this.ServiceHost.SetRequestHandler(UpdateAgentNotebookRunNameRequest.Type, HandleUpdateAgentNotebookRunNameRequest, true);
this.ServiceHost.SetRequestHandler(DeleteNotebookMaterializedRequest.Type, HandleDeleteNotebookMaterializedRequest, true);
serviceHost.RegisterShutdownTask((_, _) =>
{
@@ -1194,7 +1194,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Agent
parameters.OwnerUri,
out connInfo);
result.Success = true;
result.Notebooks = AgentNotebookHelper.GetAgentNotebooks(connInfo).Result;
result.Notebooks = await AgentNotebookHelper.GetAgentNotebooks(connInfo);
}
catch (Exception e)
{
@@ -1243,7 +1243,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Agent
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
result.NotebookMaterialized = AgentNotebookHelper.GetMaterializedNotebook(connInfo, parameters.NotebookMaterializedId, parameters.TargetDatabase).Result;
result.NotebookMaterialized = await AgentNotebookHelper.GetMaterializedNotebook(connInfo, parameters.NotebookMaterializedId, parameters.TargetDatabase);
result.Success = true;
}
catch (Exception e)

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

@@ -35,7 +35,7 @@ namespace Microsoft.SqlTools.ServiceLayer.AzureBlob
public void InitializeService(IProtocolEndpoint serviceHost)
{
serviceHost.SetRequestHandler(CreateSasRequest.Type, HandleCreateSasRequest);
serviceHost.SetRequestHandler(CreateSasRequest.Type, HandleCreateSasRequest, true);
}
internal async Task HandleCreateSasRequest(

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

@@ -32,8 +32,8 @@ namespace Microsoft.SqlTools.ServiceLayer.AzureFunctions
/// <param name="serviceHost"></param>
public void InitializeService(ServiceHost serviceHost)
{
serviceHost.SetRequestHandler(AddSqlBindingRequest.Type, this.HandleAddSqlBindingRequest);
serviceHost.SetRequestHandler(GetAzureFunctionsRequest.Type, this.HandleGetAzureFunctionsRequest);
serviceHost.SetRequestHandler(AddSqlBindingRequest.Type, this.HandleAddSqlBindingRequest, true);
serviceHost.SetRequestHandler(GetAzureFunctionsRequest.Type, this.HandleGetAzureFunctionsRequest, true);
}
/// <summary>

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

@@ -43,12 +43,12 @@ namespace Microsoft.SqlTools.ServiceLayer.Cms
/// <param name="serviceHost"></param>
public void InitializeService(ServiceHost serviceHost)
{
serviceHost.SetRequestHandler(CreateCentralManagementServerRequest.Type, this.HandleCreateCentralManagementServerRequest);
serviceHost.SetRequestHandler(ListRegisteredServersRequest.Type, this.HandleListRegisteredServersRequest);
serviceHost.SetRequestHandler(AddRegisteredServerRequest.Type, this.HandleAddRegisteredServerRequest);
serviceHost.SetRequestHandler(RemoveRegisteredServerRequest.Type, this.HandleRemoveRegisteredServerRequest);
serviceHost.SetRequestHandler(AddServerGroupRequest.Type, this.HandleAddServerGroupRequest);
serviceHost.SetRequestHandler(RemoveServerGroupRequest.Type, this.HandleRemoveServerGroupRequest);
serviceHost.SetRequestHandler(CreateCentralManagementServerRequest.Type, this.HandleCreateCentralManagementServerRequest, true);
serviceHost.SetRequestHandler(ListRegisteredServersRequest.Type, this.HandleListRegisteredServersRequest, true);
serviceHost.SetRequestHandler(AddRegisteredServerRequest.Type, this.HandleAddRegisteredServerRequest, true);
serviceHost.SetRequestHandler(RemoveRegisteredServerRequest.Type, this.HandleRemoveRegisteredServerRequest, true);
serviceHost.SetRequestHandler(AddServerGroupRequest.Type, this.HandleAddServerGroupRequest, true);
serviceHost.SetRequestHandler(RemoveServerGroupRequest.Type, this.HandleRemoveServerGroupRequest, true);
}
public async Task HandleCreateCentralManagementServerRequest(CreateCentralManagementServerParams createCmsParams, RequestContext<ListRegisteredServersResult> requestContext)

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

@@ -1059,14 +1059,14 @@ namespace Microsoft.SqlTools.ServiceLayer.Connection
this.ServiceHost = serviceHost;
// Register request and event handlers with the Service Host
serviceHost.SetRequestHandler(ConnectionRequest.Type, HandleConnectRequest);
serviceHost.SetRequestHandler(CancelConnectRequest.Type, HandleCancelConnectRequest);
serviceHost.SetRequestHandler(ChangePasswordRequest.Type, HandleChangePasswordRequest);
serviceHost.SetRequestHandler(DisconnectRequest.Type, HandleDisconnectRequest);
serviceHost.SetRequestHandler(ListDatabasesRequest.Type, HandleListDatabasesRequest);
serviceHost.SetRequestHandler(ChangeDatabaseRequest.Type, HandleChangeDatabaseRequest);
serviceHost.SetRequestHandler(GetConnectionStringRequest.Type, HandleGetConnectionStringRequest);
serviceHost.SetRequestHandler(BuildConnectionInfoRequest.Type, HandleBuildConnectionInfoRequest);
serviceHost.SetRequestHandler(ConnectionRequest.Type, HandleConnectRequest, true);
serviceHost.SetRequestHandler(CancelConnectRequest.Type, HandleCancelConnectRequest, true);
serviceHost.SetRequestHandler(ChangePasswordRequest.Type, HandleChangePasswordRequest, true);
serviceHost.SetRequestHandler(DisconnectRequest.Type, HandleDisconnectRequest, true);
serviceHost.SetRequestHandler(ListDatabasesRequest.Type, HandleListDatabasesRequest, true);
serviceHost.SetRequestHandler(ChangeDatabaseRequest.Type, HandleChangeDatabaseRequest, true);
serviceHost.SetRequestHandler(GetConnectionStringRequest.Type, HandleGetConnectionStringRequest, true);
serviceHost.SetRequestHandler(BuildConnectionInfoRequest.Type, HandleBuildConnectionInfoRequest, true);
}
/// <summary>

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

@@ -46,18 +46,18 @@ namespace Microsoft.SqlTools.ServiceLayer.DacFx
/// <param name="serviceHost"></param>
public void InitializeService(ServiceHost serviceHost)
{
serviceHost.SetRequestHandler(ExportRequest.Type, this.HandleExportRequest);
serviceHost.SetRequestHandler(ImportRequest.Type, this.HandleImportRequest);
serviceHost.SetRequestHandler(ExtractRequest.Type, this.HandleExtractRequest);
serviceHost.SetRequestHandler(DeployRequest.Type, this.HandleDeployRequest);
serviceHost.SetRequestHandler(GenerateDeployScriptRequest.Type, this.HandleGenerateDeployScriptRequest);
serviceHost.SetRequestHandler(GenerateDeployPlanRequest.Type, this.HandleGenerateDeployPlanRequest);
serviceHost.SetRequestHandler(GetOptionsFromProfileRequest.Type, this.HandleGetOptionsFromProfileRequest);
serviceHost.SetRequestHandler(ValidateStreamingJobRequest.Type, this.HandleValidateStreamingJobRequest);
serviceHost.SetRequestHandler(GetDefaultPublishOptionsRequest.Type, this.HandleGetDefaultPublishOptionsRequest);
serviceHost.SetRequestHandler(ParseTSqlScriptRequest.Type, this.HandleParseTSqlScriptRequest);
serviceHost.SetRequestHandler(GenerateTSqlModelRequest.Type, this.HandleGenerateTSqlModelRequest);
serviceHost.SetRequestHandler(GetObjectsFromTSqlModelRequest.Type, this.HandleGetObjectsFromTSqlModelRequest);
serviceHost.SetRequestHandler(ExportRequest.Type, this.HandleExportRequest, true);
serviceHost.SetRequestHandler(ImportRequest.Type, this.HandleImportRequest, true);
serviceHost.SetRequestHandler(ExtractRequest.Type, this.HandleExtractRequest, true);
serviceHost.SetRequestHandler(DeployRequest.Type, this.HandleDeployRequest, true);
serviceHost.SetRequestHandler(GenerateDeployScriptRequest.Type, this.HandleGenerateDeployScriptRequest, true);
serviceHost.SetRequestHandler(GenerateDeployPlanRequest.Type, this.HandleGenerateDeployPlanRequest, true);
serviceHost.SetRequestHandler(GetOptionsFromProfileRequest.Type, this.HandleGetOptionsFromProfileRequest, true);
serviceHost.SetRequestHandler(ValidateStreamingJobRequest.Type, this.HandleValidateStreamingJobRequest, true);
serviceHost.SetRequestHandler(GetDefaultPublishOptionsRequest.Type, this.HandleGetDefaultPublishOptionsRequest, true);
serviceHost.SetRequestHandler(ParseTSqlScriptRequest.Type, this.HandleParseTSqlScriptRequest, true);
serviceHost.SetRequestHandler(GenerateTSqlModelRequest.Type, this.HandleGenerateTSqlModelRequest, true);
serviceHost.SetRequestHandler(GetObjectsFromTSqlModelRequest.Type, this.HandleGetObjectsFromTSqlModelRequest, true);
}
/// <summary>

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

@@ -96,22 +96,22 @@ namespace Microsoft.SqlTools.ServiceLayer.DisasterRecovery
public void InitializeService(IProtocolEndpoint serviceHost)
{
// Get database info
serviceHost.SetRequestHandler(BackupConfigInfoRequest.Type, HandleBackupConfigInfoRequest);
serviceHost.SetRequestHandler(BackupConfigInfoRequest.Type, HandleBackupConfigInfoRequest, true);
// Create backup
serviceHost.SetRequestHandler(BackupRequest.Type, HandleBackupRequest);
serviceHost.SetRequestHandler(BackupRequest.Type, HandleBackupRequest, true);
// Create restore task
serviceHost.SetRequestHandler(RestoreRequest.Type, HandleRestoreRequest);
serviceHost.SetRequestHandler(RestoreRequest.Type, HandleRestoreRequest, true);
// Create restore plan
serviceHost.SetRequestHandler(RestorePlanRequest.Type, HandleRestorePlanRequest);
serviceHost.SetRequestHandler(RestorePlanRequest.Type, HandleRestorePlanRequest, true);
// Cancel restore plan
serviceHost.SetRequestHandler(CancelRestorePlanRequest.Type, HandleCancelRestorePlanRequest);
serviceHost.SetRequestHandler(CancelRestorePlanRequest.Type, HandleCancelRestorePlanRequest, true);
// Create restore config
serviceHost.SetRequestHandler(RestoreConfigInfoRequest.Type, HandleRestoreConfigInfoRequest);
serviceHost.SetRequestHandler(RestoreConfigInfoRequest.Type, HandleRestoreConfigInfoRequest, true);
// Register file path validation callbacks
FileBrowserServiceInstance.RegisterValidatePathsCallback(FileValidationServiceConstants.Backup, DisasterRecoveryFileValidator.ValidatePaths);

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

@@ -75,15 +75,15 @@ namespace Microsoft.SqlTools.ServiceLayer.EditData
public void InitializeService(ServiceHost serviceHost)
{
// Register handlers for requests
serviceHost.SetRequestHandler(EditCreateRowRequest.Type, HandleCreateRowRequest);
serviceHost.SetRequestHandler(EditDeleteRowRequest.Type, HandleDeleteRowRequest);
serviceHost.SetRequestHandler(EditDisposeRequest.Type, HandleDisposeRequest);
serviceHost.SetRequestHandler(EditInitializeRequest.Type, HandleInitializeRequest);
serviceHost.SetRequestHandler(EditRevertCellRequest.Type, HandleRevertCellRequest);
serviceHost.SetRequestHandler(EditRevertRowRequest.Type, HandleRevertRowRequest);
serviceHost.SetRequestHandler(EditSubsetRequest.Type, HandleSubsetRequest);
serviceHost.SetRequestHandler(EditUpdateCellRequest.Type, HandleUpdateCellRequest);
serviceHost.SetRequestHandler(EditCommitRequest.Type, HandleCommitRequest);
serviceHost.SetRequestHandler(EditCreateRowRequest.Type, HandleCreateRowRequest, true);
serviceHost.SetRequestHandler(EditDeleteRowRequest.Type, HandleDeleteRowRequest, true);
serviceHost.SetRequestHandler(EditDisposeRequest.Type, HandleDisposeRequest, true);
serviceHost.SetRequestHandler(EditInitializeRequest.Type, HandleInitializeRequest, true);
serviceHost.SetRequestHandler(EditRevertCellRequest.Type, HandleRevertCellRequest, true);
serviceHost.SetRequestHandler(EditRevertRowRequest.Type, HandleRevertRowRequest, true);
serviceHost.SetRequestHandler(EditSubsetRequest.Type, HandleSubsetRequest, true);
serviceHost.SetRequestHandler(EditUpdateCellRequest.Type, HandleUpdateCellRequest, true);
serviceHost.SetRequestHandler(EditCommitRequest.Type, HandleCommitRequest, true);
}
#region Request Handlers

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

@@ -49,8 +49,8 @@ namespace Microsoft.SqlTools.ServiceLayer.ExecutionPlan
public void InitializeService(ServiceHost serviceHost)
{
ServiceHost = serviceHost;
ServiceHost.SetRequestHandler(GetExecutionPlanRequest.Type, HandleGetExecutionPlan);
ServiceHost.SetRequestHandler(ExecutionPlanComparisonRequest.Type, HandleExecutionPlanComparisonRequest);
ServiceHost.SetRequestHandler(GetExecutionPlanRequest.Type, HandleGetExecutionPlan, true);
ServiceHost.SetRequestHandler(ExecutionPlanComparisonRequest.Type, HandleExecutionPlanComparisonRequest, true);
}
private async Task HandleGetExecutionPlan(GetExecutionPlanParams requestParams, RequestContext<GetExecutionPlanResult> requestContext)

8
src/Microsoft.SqlTools.ServiceLayer/FileBrowser/FileBrowserService.cs
View File

@@ -73,16 +73,16 @@ namespace Microsoft.SqlTools.ServiceLayer.FileBrowser
public void InitializeService(ServiceHost serviceHost)
{
// Open a file browser
serviceHost.SetRequestHandler(FileBrowserOpenRequest.Type, HandleFileBrowserOpenRequest);
serviceHost.SetRequestHandler(FileBrowserOpenRequest.Type, HandleFileBrowserOpenRequest, true);
// Expand a folder node
serviceHost.SetRequestHandler(FileBrowserExpandRequest.Type, HandleFileBrowserExpandRequest);
serviceHost.SetRequestHandler(FileBrowserExpandRequest.Type, HandleFileBrowserExpandRequest, true);
// Validate the selected files
serviceHost.SetRequestHandler(FileBrowserValidateRequest.Type, HandleFileBrowserValidateRequest);
serviceHost.SetRequestHandler(FileBrowserValidateRequest.Type, HandleFileBrowserValidateRequest, true);
// Close the file browser
serviceHost.SetRequestHandler(FileBrowserCloseRequest.Type, HandleFileBrowserCloseRequest);
serviceHost.SetRequestHandler(FileBrowserCloseRequest.Type, HandleFileBrowserCloseRequest, true);
}
#region request handlers

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

@@ -42,8 +42,8 @@ namespace Microsoft.SqlTools.ServiceLayer.Formatter
public override void InitializeService(IProtocolEndpoint serviceHost)
{
Logger.Write(TraceEventType.Verbose, "TSqlFormatter initialized");
serviceHost.SetRequestHandler(DocumentFormattingRequest.Type, HandleDocFormatRequest);
serviceHost.SetRequestHandler(DocumentRangeFormattingRequest.Type, HandleDocRangeFormatRequest);
serviceHost.SetRequestHandler(DocumentFormattingRequest.Type, HandleDocFormatRequest, true);
serviceHost.SetRequestHandler(DocumentRangeFormattingRequest.Type, HandleDocRangeFormatRequest, true);
WorkspaceService?.RegisterConfigChangeCallback(HandleDidChangeConfigurationNotification);
}

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

@@ -60,10 +60,10 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageExtensibility
public void InitializeService(ServiceHost serviceHost)
{
serviceHost.SetRequestHandler(ExternalLanguageStatusRequest.Type, this.HandleExternalLanguageStatusRequest);
serviceHost.SetRequestHandler(ExternalLanguageListRequest.Type, this.HandleExternalLanguageListRequest);
serviceHost.SetRequestHandler(ExternalLanguageDeleteRequest.Type, this.HandleExternalLanguageDeleteRequest);
serviceHost.SetRequestHandler(ExternalLanguageUpdateRequest.Type, this.HandleExternalLanguageUpdateRequest);
serviceHost.SetRequestHandler(ExternalLanguageStatusRequest.Type, this.HandleExternalLanguageStatusRequest, true);
serviceHost.SetRequestHandler(ExternalLanguageListRequest.Type, this.HandleExternalLanguageListRequest, true);
serviceHost.SetRequestHandler(ExternalLanguageDeleteRequest.Type, this.HandleExternalLanguageDeleteRequest, true);
serviceHost.SetRequestHandler(ExternalLanguageUpdateRequest.Type, this.HandleExternalLanguageUpdateRequest, true);
}
/// <summary>

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

@@ -252,6 +252,7 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices
// serviceHost.SetRequestHandler(ReferencesRequest.Type, HandleReferencesRequest);
// serviceHost.SetRequestHandler(DocumentHighlightRequest.Type, HandleDocumentHighlightRequest);
// Not enabling parallel processing for LanguageService as message order might matter.
serviceHost.SetRequestHandler(SignatureHelpRequest.Type, HandleSignatureHelpRequest);
serviceHost.SetRequestHandler(CompletionResolveRequest.Type, HandleCompletionResolveRequest);
serviceHost.SetRequestHandler(HoverRequest.Type, HandleHoverRequest);

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

@@ -50,9 +50,9 @@ namespace Microsoft.SqlTools.ServiceLayer.Metadata
/// <param name="context"></param>
public void InitializeService(ServiceHost serviceHost)
{
serviceHost.SetRequestHandler(MetadataListRequest.Type, HandleMetadataListRequest);
serviceHost.SetRequestHandler(TableMetadataRequest.Type, HandleGetTableRequest);
serviceHost.SetRequestHandler(ViewMetadataRequest.Type, HandleGetViewRequest);
serviceHost.SetRequestHandler(MetadataListRequest.Type, HandleMetadataListRequest, true);
serviceHost.SetRequestHandler(TableMetadataRequest.Type, HandleGetTableRequest, true);
serviceHost.SetRequestHandler(ViewMetadataRequest.Type, HandleGetViewRequest, true);
}
/// <summary>

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

@@ -121,16 +121,16 @@ namespace Microsoft.SqlTools.ServiceLayer.Migration
public void InitializeService(ServiceHost serviceHost)
{
this.ServiceHost = serviceHost;
this.ServiceHost.SetRequestHandler(MigrationAssessmentsRequest.Type, HandleMigrationAssessmentsRequest);
this.ServiceHost.SetRequestHandler(StartPerfDataCollectionRequest.Type, HandleStartPerfDataCollectionRequest);
this.ServiceHost.SetRequestHandler(StopPerfDataCollectionRequest.Type, HandleStopPerfDataCollectionRequest);
this.ServiceHost.SetRequestHandler(RefreshPerfDataCollectionRequest.Type, HandleRefreshPerfDataCollectionRequest);
this.ServiceHost.SetRequestHandler(GetSkuRecommendationsRequest.Type, HandleGetSkuRecommendationsRequest);
this.ServiceHost.SetRequestHandler(StartLoginMigrationRequest.Type, HandleStartLoginMigration);
this.ServiceHost.SetRequestHandler(ValidateLoginMigrationRequest.Type, HandleValidateLoginMigration);
this.ServiceHost.SetRequestHandler(MigrateLoginsRequest.Type, HandleMigrateLogins);
this.ServiceHost.SetRequestHandler(EstablishUserMappingRequest.Type, HandleEstablishUserMapping);
this.ServiceHost.SetRequestHandler(MigrateServerRolesAndSetPermissionsRequest.Type, HandleMigrateServerRolesAndSetPermissions);
this.ServiceHost.SetRequestHandler(MigrationAssessmentsRequest.Type, HandleMigrationAssessmentsRequest, true);
this.ServiceHost.SetRequestHandler(StartPerfDataCollectionRequest.Type, HandleStartPerfDataCollectionRequest, true);
this.ServiceHost.SetRequestHandler(StopPerfDataCollectionRequest.Type, HandleStopPerfDataCollectionRequest, true);
this.ServiceHost.SetRequestHandler(RefreshPerfDataCollectionRequest.Type, HandleRefreshPerfDataCollectionRequest, true);
this.ServiceHost.SetRequestHandler(GetSkuRecommendationsRequest.Type, HandleGetSkuRecommendationsRequest, true);
this.ServiceHost.SetRequestHandler(StartLoginMigrationRequest.Type, HandleStartLoginMigration, true);
this.ServiceHost.SetRequestHandler(ValidateLoginMigrationRequest.Type, HandleValidateLoginMigration, true);
this.ServiceHost.SetRequestHandler(MigrateLoginsRequest.Type, HandleMigrateLogins, true);
this.ServiceHost.SetRequestHandler(EstablishUserMappingRequest.Type, HandleEstablishUserMapping, true);
this.ServiceHost.SetRequestHandler(MigrateServerRolesAndSetPermissionsRequest.Type, HandleMigrateServerRolesAndSetPermissions, true);
}
/// <summary>

14
src/Microsoft.SqlTools.ServiceLayer/ModelManagement/ModelManagementService.cs
View File

@@ -62,13 +62,13 @@ namespace Microsoft.SqlTools.ServiceLayer.ModelManagement
public void InitializeService(ServiceHost serviceHost)
{
serviceHost.SetRequestHandler(ImportModelRequest.Type, this.HandleModelImportRequest);
serviceHost.SetRequestHandler(ConfigureModelTableRequest.Type, this.HandleConfigureModelTableRequest);
serviceHost.SetRequestHandler(DeleteModelRequest.Type, this.HandleDeleteModelRequest);
serviceHost.SetRequestHandler(DownloadModelRequest.Type, this.HandleDownloadModelRequest);
serviceHost.SetRequestHandler(GetModelsRequest.Type, this.HandleGetModelsRequest);
serviceHost.SetRequestHandler(UpdateModelRequest.Type, this.HandleUpdateModelRequest);
serviceHost.SetRequestHandler(VerifyModelTableRequest.Type, this.HandleVerifyModelTableRequest);
serviceHost.SetRequestHandler(ImportModelRequest.Type, this.HandleModelImportRequest, true);
serviceHost.SetRequestHandler(ConfigureModelTableRequest.Type, this.HandleConfigureModelTableRequest, true);
serviceHost.SetRequestHandler(DeleteModelRequest.Type, this.HandleDeleteModelRequest, true);
serviceHost.SetRequestHandler(DownloadModelRequest.Type, this.HandleDownloadModelRequest, true);
serviceHost.SetRequestHandler(GetModelsRequest.Type, this.HandleGetModelsRequest, true);
serviceHost.SetRequestHandler(UpdateModelRequest.Type, this.HandleUpdateModelRequest, true);
serviceHost.SetRequestHandler(VerifyModelTableRequest.Type, this.HandleVerifyModelTableRequest, true);
}
/// <summary>

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

@@ -66,8 +66,8 @@ namespace Microsoft.SqlTools.ServiceLayer.NotebookConvert
{
this.ServiceHost = serviceHost;
this.ServiceHost.SetRequestHandler(ConvertNotebookToSqlRequest.Type, HandleConvertNotebookToSqlRequest);
this.ServiceHost.SetRequestHandler(ConvertSqlToNotebookRequest.Type, HandleConvertSqlToNotebookRequest);
this.ServiceHost.SetRequestHandler(ConvertNotebookToSqlRequest.Type, HandleConvertNotebookToSqlRequest, true);
this.ServiceHost.SetRequestHandler(ConvertSqlToNotebookRequest.Type, HandleConvertSqlToNotebookRequest, true);
}

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

@@ -128,6 +128,7 @@ namespace Microsoft.SqlTools.ServiceLayer.ObjectExplorer
this.ConnectedBindingQueue.OnUnhandledException += OnUnhandledException;
// Not enabling parallel processing for OEService as it might cause OE to hang.
// Register handlers for requests
serviceHost.SetRequestHandler(CreateSessionRequest.Type, HandleCreateSessionRequest);
serviceHost.SetRequestHandler(ExpandRequest.Type, HandleExpandRequest);

2
src/Microsoft.SqlTools.ServiceLayer/ObjectManagement/ObjectManagementService.cs
View File

@@ -46,7 +46,7 @@ namespace Microsoft.SqlTools.ServiceLayer.ObjectManagement
public void InitializeService(IProtocolEndpoint serviceHost)
{
this.serviceHost = serviceHost;
this.serviceHost.SetRequestHandler(RenameRequest.Type, HandleRenameRequest);
this.serviceHost.SetRequestHandler(RenameRequest.Type, HandleRenameRequest, true);
}
/// <summary>

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

@@ -97,12 +97,12 @@ namespace Microsoft.SqlTools.ServiceLayer.Profiler
public void InitializeService(ServiceHost serviceHost)
{
this.ServiceHost = serviceHost;
this.ServiceHost.SetRequestHandler(CreateXEventSessionRequest.Type, HandleCreateXEventSessionRequest);
this.ServiceHost.SetRequestHandler(StartProfilingRequest.Type, HandleStartProfilingRequest);
this.ServiceHost.SetRequestHandler(StopProfilingRequest.Type, HandleStopProfilingRequest);
this.ServiceHost.SetRequestHandler(PauseProfilingRequest.Type, HandlePauseProfilingRequest);
this.ServiceHost.SetRequestHandler(GetXEventSessionsRequest.Type, HandleGetXEventSessionsRequest);
this.ServiceHost.SetRequestHandler(DisconnectSessionRequest.Type, HandleDisconnectSessionRequest);
this.ServiceHost.SetRequestHandler(CreateXEventSessionRequest.Type, HandleCreateXEventSessionRequest, true);
this.ServiceHost.SetRequestHandler(StartProfilingRequest.Type, HandleStartProfilingRequest, true);
this.ServiceHost.SetRequestHandler(StopProfilingRequest.Type, HandleStopProfilingRequest, true);
this.ServiceHost.SetRequestHandler(PauseProfilingRequest.Type, HandlePauseProfilingRequest, true);
this.ServiceHost.SetRequestHandler(GetXEventSessionsRequest.Type, HandleGetXEventSessionsRequest, true);
this.ServiceHost.SetRequestHandler(DisconnectSessionRequest.Type, HandleDisconnectSessionRequest, true);
this.SessionMonitor.AddSessionListener(this);
}

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

@@ -170,21 +170,21 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution
public void InitializeService(ServiceHost serviceHost)
{
// Register handlers for requests
serviceHost.SetRequestHandler(ExecuteDocumentSelectionRequest.Type, HandleExecuteRequest);
serviceHost.SetRequestHandler(ExecuteDocumentStatementRequest.Type, HandleExecuteRequest);
serviceHost.SetRequestHandler(ExecuteStringRequest.Type, HandleExecuteRequest);
serviceHost.SetRequestHandler(SubsetRequest.Type, HandleResultSubsetRequest);
serviceHost.SetRequestHandler(QueryDisposeRequest.Type, HandleDisposeRequest);
serviceHost.SetRequestHandler(QueryCancelRequest.Type, HandleCancelRequest);
serviceHost.SetRequestHandler(ExecuteDocumentSelectionRequest.Type, HandleExecuteRequest, true);
serviceHost.SetRequestHandler(ExecuteDocumentStatementRequest.Type, HandleExecuteRequest, true);
serviceHost.SetRequestHandler(ExecuteStringRequest.Type, HandleExecuteRequest, true);
serviceHost.SetRequestHandler(SubsetRequest.Type, HandleResultSubsetRequest, true);
serviceHost.SetRequestHandler(QueryDisposeRequest.Type, HandleDisposeRequest, true);
serviceHost.SetRequestHandler(QueryCancelRequest.Type, HandleCancelRequest, true);
serviceHost.SetEventHandler(ConnectionUriChangedNotification.Type, HandleConnectionUriChangedNotification);
serviceHost.SetRequestHandler(SaveResultsAsCsvRequest.Type, HandleSaveResultsAsCsvRequest);
serviceHost.SetRequestHandler(SaveResultsAsExcelRequest.Type, HandleSaveResultsAsExcelRequest);
serviceHost.SetRequestHandler(SaveResultsAsJsonRequest.Type, HandleSaveResultsAsJsonRequest);
serviceHost.SetRequestHandler(SaveResultsAsMarkdownRequest.Type, this.HandleSaveResultsAsMarkdownRequest);
serviceHost.SetRequestHandler(SaveResultsAsXmlRequest.Type, HandleSaveResultsAsXmlRequest);
serviceHost.SetRequestHandler(QueryExecutionPlanRequest.Type, HandleExecutionPlanRequest);
serviceHost.SetRequestHandler(SimpleExecuteRequest.Type, HandleSimpleExecuteRequest);
serviceHost.SetRequestHandler(QueryExecutionOptionsRequest.Type, HandleQueryExecutionOptionsRequest);
serviceHost.SetRequestHandler(SaveResultsAsCsvRequest.Type, HandleSaveResultsAsCsvRequest, true);
serviceHost.SetRequestHandler(SaveResultsAsExcelRequest.Type, HandleSaveResultsAsExcelRequest, true);
serviceHost.SetRequestHandler(SaveResultsAsJsonRequest.Type, HandleSaveResultsAsJsonRequest, true);
serviceHost.SetRequestHandler(SaveResultsAsMarkdownRequest.Type, this.HandleSaveResultsAsMarkdownRequest, true);
serviceHost.SetRequestHandler(SaveResultsAsXmlRequest.Type, HandleSaveResultsAsXmlRequest, true);
serviceHost.SetRequestHandler(QueryExecutionPlanRequest.Type, HandleExecutionPlanRequest, true);
serviceHost.SetRequestHandler(SimpleExecuteRequest.Type, HandleSimpleExecuteRequest, true);
serviceHost.SetRequestHandler(QueryExecutionOptionsRequest.Type, HandleQueryExecutionOptionsRequest, true);
// Register the file open update handler
WorkspaceService<SqlToolsSettings>.Instance.RegisterTextDocCloseCallback(HandleDidCloseTextDocumentNotification);

4
src/Microsoft.SqlTools.ServiceLayer/QueryExecution/SerializationService.cs
View File

@@ -34,8 +34,8 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution
public override void InitializeService(IProtocolEndpoint serviceHost)
{
Logger.Write(TraceEventType.Verbose, "SerializationService initialized");
serviceHost.SetRequestHandler(SerializeStartRequest.Type, HandleSerializeStartRequest);
serviceHost.SetRequestHandler(SerializeContinueRequest.Type, HandleSerializeContinueRequest);
serviceHost.SetRequestHandler(SerializeStartRequest.Type, HandleSerializeStartRequest, true);
serviceHost.SetRequestHandler(SerializeContinueRequest.Type, HandleSerializeContinueRequest, true);
}
/// <summary>

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

@@ -48,15 +48,15 @@ namespace Microsoft.SqlTools.ServiceLayer.SchemaCompare
/// <param name="serviceHost"></param>
public void InitializeService(ServiceHost serviceHost)
{
serviceHost.SetRequestHandler(SchemaCompareRequest.Type, this.HandleSchemaCompareRequest);
serviceHost.SetRequestHandler(SchemaCompareCancellationRequest.Type, this.HandleSchemaCompareCancelRequest);
serviceHost.SetRequestHandler(SchemaCompareGenerateScriptRequest.Type, this.HandleSchemaCompareGenerateScriptRequest);
serviceHost.SetRequestHandler(SchemaComparePublishDatabaseChangesRequest.Type, this.HandleSchemaComparePublishDatabaseChangesRequest);
serviceHost.SetRequestHandler(SchemaComparePublishProjectChangesRequest.Type, this.HandleSchemaComparePublishProjectChangesRequest);
serviceHost.SetRequestHandler(SchemaCompareIncludeExcludeNodeRequest.Type, this.HandleSchemaCompareIncludeExcludeNodeRequest);
serviceHost.SetRequestHandler(SchemaCompareGetDefaultOptionsRequest.Type, this.HandleSchemaCompareGetDefaultOptionsRequest);
serviceHost.SetRequestHandler(SchemaCompareOpenScmpRequest.Type, this.HandleSchemaCompareOpenScmpRequest);
serviceHost.SetRequestHandler(SchemaCompareSaveScmpRequest.Type, this.HandleSchemaCompareSaveScmpRequest);
serviceHost.SetRequestHandler(SchemaCompareRequest.Type, this.HandleSchemaCompareRequest, true);
serviceHost.SetRequestHandler(SchemaCompareCancellationRequest.Type, this.HandleSchemaCompareCancelRequest, true);
serviceHost.SetRequestHandler(SchemaCompareGenerateScriptRequest.Type, this.HandleSchemaCompareGenerateScriptRequest, true);
serviceHost.SetRequestHandler(SchemaComparePublishDatabaseChangesRequest.Type, this.HandleSchemaComparePublishDatabaseChangesRequest, true);
serviceHost.SetRequestHandler(SchemaComparePublishProjectChangesRequest.Type, this.HandleSchemaComparePublishProjectChangesRequest, true);
serviceHost.SetRequestHandler(SchemaCompareIncludeExcludeNodeRequest.Type, this.HandleSchemaCompareIncludeExcludeNodeRequest, true);
serviceHost.SetRequestHandler(SchemaCompareGetDefaultOptionsRequest.Type, this.HandleSchemaCompareGetDefaultOptionsRequest, true);
serviceHost.SetRequestHandler(SchemaCompareOpenScmpRequest.Type, this.HandleSchemaCompareOpenScmpRequest, true);
serviceHost.SetRequestHandler(SchemaCompareSaveScmpRequest.Type, this.HandleSchemaCompareSaveScmpRequest, true);
}
/// <summary>

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

@@ -65,9 +65,9 @@ namespace Microsoft.SqlTools.ServiceLayer.Scripting
/// <param name="context"></param>
public void InitializeService(ServiceHost serviceHost)
{
serviceHost.SetRequestHandler(ScriptingRequest.Type, this.HandleScriptExecuteRequest);
serviceHost.SetRequestHandler(ScriptingCancelRequest.Type, this.HandleScriptCancelRequest);
serviceHost.SetRequestHandler(ScriptingListObjectsRequest.Type, this.HandleListObjectsRequest);
serviceHost.SetRequestHandler(ScriptingRequest.Type, this.HandleScriptExecuteRequest, true);
serviceHost.SetRequestHandler(ScriptingCancelRequest.Type, this.HandleScriptCancelRequest, true);
serviceHost.SetRequestHandler(ScriptingListObjectsRequest.Type, this.HandleListObjectsRequest, true);
// Register handler for shutdown event
serviceHost.RegisterShutdownTask((shutdownParams, requestContext) =>

8
src/Microsoft.SqlTools.ServiceLayer/Security/SecurityService.cs
View File

@@ -75,10 +75,10 @@ namespace Microsoft.SqlTools.ServiceLayer.Security
this.ServiceHost = serviceHost;
// Credential request handlers
this.ServiceHost.SetRequestHandler(CreateCredentialRequest.Type, HandleCreateCredentialRequest);
this.ServiceHost.SetRequestHandler(UpdateCredentialRequest.Type, HandleUpdateCredentialRequest);
this.ServiceHost.SetRequestHandler(DeleteCredentialRequest.Type, HandleDeleteCredentialRequest);
this.ServiceHost.SetRequestHandler(GetCredentialsRequest.Type, HandleGetCredentialsRequest);
this.ServiceHost.SetRequestHandler(CreateCredentialRequest.Type, HandleCreateCredentialRequest, true);
this.ServiceHost.SetRequestHandler(UpdateCredentialRequest.Type, HandleUpdateCredentialRequest, true);
this.ServiceHost.SetRequestHandler(DeleteCredentialRequest.Type, HandleDeleteCredentialRequest, true);
this.ServiceHost.SetRequestHandler(GetCredentialsRequest.Type, HandleGetCredentialsRequest, true);
}
/// <summary>

6
src/Microsoft.SqlTools.ServiceLayer/ServerConfigurations/ServerConfigService.cs
View File

@@ -49,9 +49,9 @@ namespace Microsoft.SqlTools.ServiceLayer.ServerConfigurations
public void InitializeService(ServiceHost serviceHost)
{
serviceHost.SetRequestHandler(ServerConfigViewRequest.Type, this.HandleServerConfigViewRequest);
serviceHost.SetRequestHandler(ServerConfigUpdateRequest.Type, this.HandleServerConfigUpdateRequest);
serviceHost.SetRequestHandler(ServerConfigListRequest.Type, this.HandleServerConfigListRequest);
serviceHost.SetRequestHandler(ServerConfigViewRequest.Type, this.HandleServerConfigViewRequest, true);
serviceHost.SetRequestHandler(ServerConfigUpdateRequest.Type, this.HandleServerConfigUpdateRequest, true);
serviceHost.SetRequestHandler(ServerConfigListRequest.Type, this.HandleServerConfigListRequest, true);
}
/// <summary>

6
src/Microsoft.SqlTools.ServiceLayer/SqlAssessment/SqlAssessmentService.cs
View File

@@ -102,9 +102,9 @@ namespace Microsoft.SqlTools.ServiceLayer.SqlAssessment
public void InitializeService(ServiceHost serviceHost)
{
// Register handlers for requests
serviceHost.SetRequestHandler(InvokeRequest.Type, HandleInvokeRequest);
serviceHost.SetRequestHandler(GetAssessmentItemsRequest.Type, HandleGetAssessmentItemsRequest);
serviceHost.SetRequestHandler(GenerateScriptRequest.Type, HandleGenerateScriptRequest);
serviceHost.SetRequestHandler(InvokeRequest.Type, HandleInvokeRequest, true);
serviceHost.SetRequestHandler(GetAssessmentItemsRequest.Type, HandleGetAssessmentItemsRequest, true);
serviceHost.SetRequestHandler(GenerateScriptRequest.Type, HandleGenerateScriptRequest, true);
// Register handler for shutdown event
serviceHost.RegisterShutdownTask((shutdownParams, requestContext) =>

12
src/Microsoft.SqlTools.ServiceLayer/TableDesigner/TableDesignerService.cs
View File

@@ -58,12 +58,12 @@ namespace Microsoft.SqlTools.ServiceLayer.TableDesigner
public void InitializeService(ServiceHost serviceHost)
{
this.ServiceHost = serviceHost;
this.ServiceHost.SetRequestHandler(InitializeTableDesignerRequest.Type, HandleInitializeTableDesignerRequest);
this.ServiceHost.SetRequestHandler(ProcessTableDesignerEditRequest.Type, HandleProcessTableDesignerEditRequest);
this.ServiceHost.SetRequestHandler(PublishTableChangesRequest.Type, HandlePublishTableChangesRequest);
this.ServiceHost.SetRequestHandler(GenerateScriptRequest.Type, HandleGenerateScriptRequest);
this.ServiceHost.SetRequestHandler(GeneratePreviewReportRequest.Type, HandleGeneratePreviewReportRequest);
this.ServiceHost.SetRequestHandler(DisposeTableDesignerRequest.Type, HandleDisposeTableDesignerRequest);
this.ServiceHost.SetRequestHandler(InitializeTableDesignerRequest.Type, HandleInitializeTableDesignerRequest, true);
this.ServiceHost.SetRequestHandler(ProcessTableDesignerEditRequest.Type, HandleProcessTableDesignerEditRequest, true);
this.ServiceHost.SetRequestHandler(PublishTableChangesRequest.Type, HandlePublishTableChangesRequest, true);
this.ServiceHost.SetRequestHandler(GenerateScriptRequest.Type, HandleGenerateScriptRequest, true);
this.ServiceHost.SetRequestHandler(GeneratePreviewReportRequest.Type, HandleGeneratePreviewReportRequest, true);
this.ServiceHost.SetRequestHandler(DisposeTableDesignerRequest.Type, HandleDisposeTableDesignerRequest, true);
Workspace.WorkspaceService<SqlToolsSettings>.Instance.RegisterConfigChangeCallback(UpdateSettings);
}

4
src/Microsoft.SqlTools.ServiceLayer/TaskServices/TaskService.cs
View File

@@ -52,8 +52,8 @@ namespace Microsoft.SqlTools.ServiceLayer.TaskServices
{
this.serviceHost = serviceHost;
Logger.Write(TraceEventType.Verbose, "TaskService initialized");
serviceHost.SetRequestHandler(ListTasksRequest.Type, HandleListTasksRequest);
serviceHost.SetRequestHandler(CancelTaskRequest.Type, HandleCancelTaskRequest);
serviceHost.SetRequestHandler(ListTasksRequest.Type, HandleListTasksRequest, true);
serviceHost.SetRequestHandler(CancelTaskRequest.Type, HandleCancelTaskRequest, true);
TaskManager.TaskAdded += OnTaskAdded;
}

1
src/Microsoft.SqlTools.ServiceLayer/Workspace/WorkspaceService.cs
View File

@@ -127,6 +127,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Workspace
// Create a workspace that will handle state for the session
Workspace = new Workspace();
// Not enabling parallel processing for WorkspaceService as it might cause doc out of sync.
// Register the handlers for when changes to the workspae occur
serviceHost.SetEventHandler(DidChangeTextDocumentNotification.Type, HandleDidChangeTextDocumentNotification);
serviceHost.SetEventHandler(DidOpenTextDocumentNotification.Type, HandleDidOpenTextDocumentNotification);

67
test/Microsoft.SqlTools.ServiceLayer.UnitTests/Messaging/MessageDispatcherTests.cs
View File

@@ -4,6 +4,8 @@
//
using System;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.SqlTools.Hosting.Protocol;
using Microsoft.SqlTools.Hosting.Protocol.Channel;
@@ -84,5 +86,70 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Messaging
Assert.True(handlerCalled);
}
}
[Test]
public void ParallelMessageProcessingTest()
{
int numOfRequests = 10;
int msForEachRequest = 1000;
// Without parallel processing, this should take around numOfRequests * msForEachRequest ms to finish.
// With parallel process, this should take around 1 * msForEachRequest ms to finish.
// The diff should be around (numOfRequests - 1) * msForEachRequest ms.
// In order to make this test stable, we loose the assertion by checking the diff against
// (numOfRequests / 2) * msForEachRequest ms, which should for sure pass.
Assert.IsTrue(GetTimeToHandleRequests(false, numOfRequests, msForEachRequest) - GetTimeToHandleRequests(true, numOfRequests, msForEachRequest) > msForEachRequest * (numOfRequests / 2));
}
/// <summary>
/// Gets the time to handle certain amount of requests in ms
/// </summary>
/// <param name="parallelMessageProcessing">Wheater to enable parallel processing</param>
/// <param name="numOfRequests">num of requests to handle</param>
/// <param name="msForEachRequest">rough time taken to finish each reqeust in ms</param>
/// <returns></returns>
private long GetTimeToHandleRequests(bool parallelMessageProcessing, int numOfRequests, int msForEachRequest)
{
RequestType<int, int> requestType = RequestType<int, int>.Create("test/requestType");
var mockChannel = new Mock<ChannelBase>();
SemaphoreSlim unfinishedRequestCount = new SemaphoreSlim(numOfRequests);
bool okayToEnd = false;
mockChannel.Setup(c => c.MessageReader.ReadMessage())
.Returns(Task.FromResult(Message.Request("1", "test/requestType", null)));
var dispatcher = new MessageDispatcher(mockChannel.Object);
dispatcher.ParallelMessageProcessing = parallelMessageProcessing;
Stopwatch stopwatch = Stopwatch.StartNew();
var handler = async (int _, RequestContext<int> _) =>
{
// simulate a slow sync call
Thread.Sleep(msForEachRequest / 2);
// simulate a delay async call
await Task.Delay(msForEachRequest / 2);
await unfinishedRequestCount.WaitAsync();
if (unfinishedRequestCount.CurrentCount == 0)
{
// cut off when we reach numOfRequests
stopwatch.Stop();
okayToEnd = true;
}
await Task.CompletedTask;
};
dispatcher.SetRequestHandler(requestType, handler, false, true);
dispatcher.Start();
while (true)
{
if (okayToEnd)
{
// wait until we finish handling the required amount of requests
break;
}
Thread.Sleep(1000);
}
dispatcher.Stop();
return stopwatch.ElapsedMilliseconds;
}
}
}