internal async Task HandleDisposeRequest(EditDisposeParams disposeParams,
RequestContext <EditDisposeResult> requestContext)
{
try
{
// 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)
{
await requestContext.SendError(e.Message);
}
}
/// <summary>
/// Handles config view request
/// </summary>
/// <param name="parameters">Request parameters</param>
/// <param name="requestContext">Request Context</param>
/// <returns></returns>
public async Task HandleServerConfigViewRequest(ServerConfigViewRequestParams parameters, RequestContext <ServerConfigViewResponseParams> requestContext)
{
Logger.Write(TraceEventType.Verbose, "HandleServerConfigViewRequest");
try
{
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
if (connInfo == null)
{
await requestContext.SendError(new Exception(SR.ProfilerConnectionNotFound));
}
else
{
var serverConnection = ConnectionService.OpenServerConnection(connInfo);
ServerConfigProperty serverConfig = GetConfig(serverConnection, parameters.ConfigNumber);
await requestContext.SendResult(new ServerConfigViewResponseParams
{
ConfigProperty = serverConfig
});
}
}
catch (Exception e)
{
// Exception related to run task will be captured here
await requestContext.SendError(e);
}
}
public async Task HandleCreateCentralManagementServerRequest(CreateCentralManagementServerParams createCmsParams, RequestContext <ListRegisteredServersResult> requestContext)
{
Logger.Write(TraceEventType.Verbose, "HandleCreateCentralManagementServerRequest");
try
{
CmsTask = Task.Run(async() =>
{
try
{
//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)
{
// Exception related to connection/creation will only be caught here. Note that the outer catch will not catch them
await requestContext.SendError(ex);
}
});
}
catch (Exception e)
{
// Exception related to run task will be captured here
await requestContext.SendError(e);
}
}
/// <summary>
/// Handle get database info request
/// </summary>
internal static async Task HandleGetDatabaseInfoRequest(
GetDatabaseInfoParams databaseParams,
RequestContext <GetDatabaseInfoResponse> requestContext)
{
try
{
Func <Task> requestHandler = async() =>
{
ConnectionInfo connInfo;
AdminService.ConnectionServiceInstance.TryFindConnection(
databaseParams.OwnerUri,
out connInfo);
DatabaseInfo info = null;
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.SendError(t.Exception.ToString());
});
}
catch (Exception ex)
{
await requestContext.SendError(ex.ToString());
}
}
/// <summary>
/// Handles external language delete request
/// </summary>
/// <param name="parameters">Request parameters</param>
/// <param name="requestContext">Request Context</param>
/// <returns></returns>
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
{
};
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)
{
// Exception related to run task will be captured here
await requestContext.SendError(e);
}
}
/// <summary>
/// Handle request to pause a profiling session
/// </summary>
internal async Task HandleGetXEventSessionsRequest(GetXEventSessionsParams parameters, RequestContext <GetXEventSessionsResult> requestContext)
{
await Task.Run(async() =>
{
try
{
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);
}
}
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() =>
{
try
{
ServerConnection serverConn = ValidateAndCreateConnection(removeServerGroupParams.ParentOwnerUri);
if (serverConn != null)
{
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);
}
}
catch (Exception e)
{
await requestContext.SendError(e);
}
});
}
catch (Exception e)
{
await requestContext.SendError(e);
}
}
private async Task SaveResultsHelper(SaveResultsRequestParams saveParams,
RequestContext <SaveResultRequestResult> requestContext, IFileStreamFactory fileFactory)
{
// retrieve query for OwnerUri
Query query;
if (!ActiveQueries.TryGetValue(saveParams.OwnerUri, out query))
{
await requestContext.SendError(SR.QueryServiceQueryInvalidOwnerUri);
return;
}
//Setup the callback for completion of the save task
ResultSet.SaveAsAsyncEventHandler successHandler = async parameters =>
{
await requestContext.SendResult(new SaveResultRequestResult());
};
ResultSet.SaveAsFailureAsyncEventHandler errorHandler = async(parameters, reason) =>
{
string message = SR.QueryServiceSaveAsFail(Path.GetFileName(parameters.FilePath), reason);
await requestContext.SendError(message);
};
try
{
// Launch the task
query.SaveAs(saveParams, fileFactory, successHandler, errorHandler);
}
catch (Exception e)
{
await errorHandler(saveParams, e.Message);
}
}
/// <summary>
/// Handles request to execute a selection of a document in the workspace service
/// </summary>
internal async 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 =>
{
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);
});
}
catch (Exception ex)
{
await requestContext.SendError(ex.ToString());
}
}
private async Task HandleRequest <T>(Func <Task <T> > handler, Func <ExpiredTokenException, T> expiredTokenHandler, RequestContext <T> requestContext, string requestType)
{
Logger.Write(LogLevel.Verbose, requestType);
try
{
T result = await handler();
await requestContext.SendResult(result);
}
catch (ExpiredTokenException ex)
{
if (expiredTokenHandler != null)
{
// This is a special exception indicating the token(s) used to request resources had expired.
// Any Azure resource should have handling for this such as an error path that clearly indicates that a refresh is needed
T result = expiredTokenHandler(ex);
await requestContext.SendResult(result);
}
else
{
// No handling for expired tokens defined / expected
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);
}
}
/// <summary>
/// Handles a request to get an execution plan
/// </summary>
internal async Task HandleExecutionPlanRequest(QueryExecutionPlanParams planParams,
RequestContext <QueryExecutionPlanResult> requestContext)
{
try
{
// Attempt to load the query
Query query;
if (!ActiveQueries.TryGetValue(planParams.OwnerUri, out query))
{
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)
{
// This was unexpected, so send back as error
await requestContext.SendError(e.Message);
}
}
protected async Task HandleSetVariablesRequest(
SetVariableRequestArguments setVariableParams,
RequestContext <SetVariableResponseBody> requestContext)
{
try
{
string updatedValue =
await _editorSession.DebugService.SetVariable(
setVariableParams.VariablesReference,
setVariableParams.Name,
setVariableParams.Value);
var setVariableResponse = new SetVariableResponseBody
{
Value = updatedValue
};
await requestContext.SendResult(setVariableResponse);
}
catch (Exception ex) when(ex is ArgumentTransformationMetadataException ||
ex is InvalidPowerShellExpressionException ||
ex is SessionStateUnauthorizedAccessException)
{
// Catch common, innocuous errors caused by the user supplying a value that can't be converted or the variable is not settable.
Logger.Write(LogLevel.Verbose, $"Failed to set variable: {ex.Message}");
await requestContext.SendError(ex.Message);
}
catch (Exception ex)
{
Logger.Write(LogLevel.Error, $"Unexpected error setting variable: {ex.Message}");
string msg =
$"Unexpected error: {ex.GetType().Name} - {ex.Message} Please report this error to the PowerShellEditorServices project on GitHub.";
await requestContext.SendError(msg);
}
}
private async Task HandleAssessmentRequest <TResult>(
RequestContext <AssessmentResult <TResult> > requestContext,
AssessmentParams requestParams,
Func <SqlObjectLocator, Task <List <TResult> > > assessmentFunction)
where TResult : AssessmentItemInfo
{
try
{
string randomUri = Guid.NewGuid().ToString();
// get connection
if (!ConnectionService.TryFindConnection(requestParams.OwnerUri, out var connInfo))
{
await requestContext.SendError(SR.SqlAssessmentQueryInvalidOwnerUri);
return;
}
ConnectParams connectParams = new ConnectParams
{
OwnerUri = randomUri,
Connection = connInfo.ConnectionDetails,
Type = ConnectionType.Default
};
if (!connInfo.TryGetConnection(ConnectionType.Default, out var connection))
{
await requestContext.SendError(SR.SqlAssessmentConnectingError);
}
var workTask = CallAssessmentEngine <TResult>(
requestParams,
connectParams,
randomUri,
assessmentFunction)
.ContinueWith(async tsk =>
{
await requestContext.SendResult(tsk.Result);
});
ActiveRequests.TryAdd(randomUri, workTask);
}
catch (Exception ex)
{
if (ex is StackOverflowException || ex is OutOfMemoryException)
{
throw;
}
await requestContext.SendError(ex.ToString());
}
}
/// <summary>
/// Handle request to get backup configuration info
/// </summary>
/// <param name="optionsParams"></param>
/// <param name="requestContext"></param>
/// <returns></returns>
public static async Task HandleBackupConfigInfoRequest(
DefaultDatabaseInfoParams optionsParams,
RequestContext <BackupConfigInfoResponse> requestContext)
{
try
{
var response = new BackupConfigInfoResponse();
ConnectionInfo connInfo;
DisasterRecoveryService.ConnectionServiceInstance.TryFindConnection(
optionsParams.OwnerUri,
out connInfo);
if (connInfo != null)
{
DatabaseTaskHelper helper = AdminService.CreateDatabaseTaskHelper(connInfo, databaseExists: true);
SqlConnection sqlConn = GetSqlConnection(connInfo);
if ((sqlConn != null) && !connInfo.IsSqlDW && !connInfo.IsAzure)
{
BackupConfigInfo backupConfigInfo = DisasterRecoveryService.Instance.GetBackupConfigInfo(helper.DataContainer, sqlConn, sqlConn.Database);
backupConfigInfo.DatabaseInfo = AdminService.GetDatabaseInfo(connInfo);
response.BackupConfigInfo = backupConfigInfo;
}
}
await requestContext.SendResult(response);
}
catch (Exception ex)
{
await requestContext.SendError(ex.ToString());
}
}
/// <summary>
/// Handle request to start a profiling session
/// </summary>
internal async Task HandleStartProfilingRequest(StartProfilingParams parameters, RequestContext <StartProfilingResult> requestContext)
{
try
{
var result = new StartProfilingResult();
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
if (connInfo != null)
{
ProfilerSession session = StartSession(parameters.OwnerUri, connInfo);
result.SessionId = session.SessionId;
result.Succeeded = true;
}
else
{
result.Succeeded = false;
result.ErrorMessage = SR.ProfilerConnectionNotFound;
}
await requestContext.SendResult(result);
}
catch (Exception e)
{
await requestContext.SendError(e);
}
}
/// <summary>
/// Handle request to get backup configuration info
/// </summary>
/// <param name="optionsParams"></param>
/// <param name="requestContext"></param>
/// <returns></returns>
internal async Task HandleBackupConfigInfoRequest(
DefaultDatabaseInfoParams optionsParams,
RequestContext <BackupConfigInfoResponse> requestContext)
{
try
{
var response = new BackupConfigInfoResponse();
ConnectionInfo connInfo;
DisasterRecoveryService.ConnectionServiceInstance.TryFindConnection(
optionsParams.OwnerUri,
out connInfo);
if (connInfo != null)
{
using (DatabaseTaskHelper helper = AdminService.CreateDatabaseTaskHelper(connInfo, databaseExists: true))
{
using (SqlConnection sqlConn = ConnectionService.OpenSqlConnection(connInfo, "Backup"))
{
if (sqlConn != null && !connInfo.IsCloud)
{
BackupConfigInfo backupConfigInfo = this.GetBackupConfigInfo(helper.DataContainer, sqlConn, sqlConn.Database);
response.BackupConfigInfo = backupConfigInfo;
}
}
}
}
await requestContext.SendResult(response);
}
catch (Exception ex)
{
await requestContext.SendError(ex.ToString());
}
}
/// <summary>
/// Handles a create database request
/// </summary>
internal static async Task HandleCreateDatabaseRequest(
CreateDatabaseParams databaseParams,
RequestContext <CreateDatabaseResponse> requestContext)
{
try
{
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)
{
await requestContext.SendError(ex.ToString());
}
}
/// <summary>
/// Handles request to generate deploy script
/// </summary>
/// <returns></returns>
public async Task HandleGenerateDeployScriptRequest(GenerateDeployScriptParams parameters, RequestContext <DacFxResult> requestContext)
{
try
{
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()
{
OperationId = operation.OperationId,
Success = true,
ErrorMessage = string.Empty
});
}
}
catch (Exception e)
{
await requestContext.SendError(e);
}
}
/// <summary>
/// Handle a table pr view metadata query request
/// </summary>
private static async Task HandleGetTableOrViewRequest(
TableMetadataParams metadataParams,
string objectType,
RequestContext <TableMetadataResult> requestContext)
{
try
{
ConnectionInfo connInfo;
MetadataService.ConnectionServiceInstance.TryFindConnection(
metadataParams.OwnerUri,
out connInfo);
ColumnMetadata[] metadata = null;
if (connInfo != null)
{
using (SqlConnection sqlConn = ConnectionService.OpenSqlConnection(connInfo, "Metadata"))
{
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.SendError(ex.ToString());
}
}
/// <summary>
/// Handle a metadata query request
/// </summary>
internal static async Task HandleMetadataListRequest(
MetadataQueryParams metadataParams,
RequestContext <MetadataQueryResult> requestContext)
{
try
{
ConnectionInfo connInfo;
MetadataService.ConnectionServiceInstance.TryFindConnection(
metadataParams.OwnerUri,
out connInfo);
var metadata = new List <ObjectMetadata>();
if (connInfo != null)
{
using (SqlConnection sqlConn = OpenMetadataConnection(connInfo))
{
ReadMetadata(sqlConn, metadata);
}
}
await requestContext.SendResult(new MetadataQueryResult
{
Metadata = metadata.ToArray()
});
}
catch (Exception ex)
{
await requestContext.SendError(ex.ToString());
}
}
public async Task HandleDisposeRequest(QueryDisposeParams disposeParams,
RequestContext <QueryDisposeResult> requestContext)
{
try
{
// Attempt to remove the query for the owner uri
Query result;
if (!ActiveQueries.TryRemove(disposeParams.OwnerUri, out result))
{
await requestContext.SendResult(new QueryDisposeResult
{
Messages = SR.QueryServiceRequestsNoQuery
});
return;
}
// Cleanup the query
result.Dispose();
// Success
await requestContext.SendResult(new QueryDisposeResult
{
Messages = null
});
}
catch (Exception e)
{
await requestContext.SendError(e.Message);
}
}
/// <summary>
/// Handles a request to cancel this query if it is in progress
/// </summary>
internal async Task HandleCancelRequest(QueryCancelParams cancelParams,
RequestContext <QueryCancelResult> requestContext)
{
try
{
// Attempt to find the query for the owner uri
Query result;
if (!ActiveQueries.TryGetValue(cancelParams.OwnerUri, out result))
{
await requestContext.SendResult(new QueryCancelResult
{
Messages = SR.QueryServiceRequestsNoQuery
});
return;
}
// Cancel the query and send a success message
result.Cancel();
await requestContext.SendResult(new QueryCancelResult());
}
catch (InvalidOperationException e)
{
// If this exception occurred, we most likely were trying to cancel a completed query
await requestContext.SendResult(new QueryCancelResult
{
Messages = e.Message
});
}
catch (Exception e)
{
await requestContext.SendError(e.Message);
}
}
/// <summary>
/// Handles request to generate deploy plan
/// </summary>
/// <returns></returns>
public async Task HandleGenerateDeployPlanRequest(GenerateDeployPlanParams parameters, RequestContext <GenerateDeployPlanRequestResult> requestContext)
{
try
{
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
if (connInfo != null)
{
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);
}
}
/// <summary>
/// Handle request to start a profiling session
/// </summary>
internal async Task HandleStartProfilingRequest(StartProfilingParams parameters, RequestContext <StartProfilingResult> requestContext)
{
await Task.Run(async() =>
{
try
{
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);
var result = new StartProfilingResult();
await requestContext.SendResult(result);
}
else
{
throw new Exception(SR.ProfilerConnectionNotFound);
}
}
catch (Exception e)
{
await requestContext.SendError(new Exception(SR.StartSessionFailed(e.Message)));
}
});
}
/// <summary>
/// Handles script as request messages
/// </summary>
/// <param name="scriptingParams"></param>
/// <param name="requestContext"></param>
internal static async Task HandleScriptingScriptAsRequest(
ScriptingScriptAsParams scriptingParams,
RequestContext <ScriptingScriptAsResult> requestContext)
{
try
{
ConnectionInfo connInfo;
ScriptingService.ConnectionServiceInstance.TryFindConnection(
scriptingParams.OwnerUri,
out connInfo);
ObjectMetadata metadata = scriptingParams.Metadata;
string script = string.Empty;
if (connInfo != null)
{
script = QueueScriptOperation(scriptingParams.Operation, connInfo, metadata);
}
await requestContext.SendResult(new ScriptingScriptAsResult
{
OwnerUri = scriptingParams.OwnerUri,
Script = script
});
}
catch (Exception ex)
{
await requestContext.SendError(ex.ToString());
}
}
public void SendException()
{
// Setup: Create a blocking collection to collect the output
var bc = new BlockingCollection <Message>(new ConcurrentQueue <Message>());
// If: I write an error as an exception with the request context
const string errorMessage = "error";
var e = new Exception(errorMessage);
var rc = new RequestContext <CommonObjects.TestMessageContents>(CommonObjects.RequestMessage, bc);
rc.SendError(e);
// Then:
// ... The message writer should have sent an error
Assert.Single(bc);
var firstMessage = bc.First();
Assert.Equal(MessageType.ResponseError, firstMessage.MessageType);
// ... The error object it built should have the reuired fields set
var contents = firstMessage.GetTypedContents <Error>();
Assert.Equal(e.HResult, contents.Code);
Assert.Equal(errorMessage, contents.Message);
}
internal async Task HandleRefreshRequest(RefreshParams refreshParams, RequestContext <bool> context)
{
try
{
Logger.Write(LogLevel.Verbose, "HandleRefreshRequest");
Validate.IsNotNull(nameof(refreshParams), refreshParams);
Validate.IsNotNull(nameof(context), context);
string uri = refreshParams.SessionId;
ObjectExplorerSession session = null;
if (!sessionMap.TryGetValue(uri, out session))
{
Logger.Write(LogLevel.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)
{
await context.SendError(ex.ToString());
}
}
internal async Task HandleCreateSessionRequest(ConnectionDetails connectionDetails, RequestContext <CreateSessionResponse> context)
{
try
{
Logger.Write(LogLevel.Verbose, "HandleCreateSessionRequest");
Func <Task <CreateSessionResponse> > doCreateSession = async() =>
{
Validate.IsNotNull(nameof(connectionDetails), connectionDetails);
Validate.IsNotNull(nameof(context), context);
return(await Task.Factory.StartNew(() =>
{
string uri = GenerateUri(connectionDetails);
return new CreateSessionResponse {
SessionId = uri
};
}));
};
CreateSessionResponse response = await HandleRequestAsync(doCreateSession, context, "HandleCreateSessionRequest");
if (response != null)
{
RunCreateSessionTask(connectionDetails, response.SessionId);
}
}
catch (Exception ex)
{
await context.SendError(ex.ToString());
}
}
/// <summary>
/// Handles schema compare open SCMP request
/// </summary>
/// <returns></returns>
public async Task HandleSchemaCompareOpenScmpRequest(SchemaCompareOpenScmpParams parameters, RequestContext <SchemaCompareOpenScmpResult> requestContext)
{
try
{
CurrentSchemaCompareTask = Task.Run(async() =>
{
SchemaCompareOpenScmpOperation operation = null;
try
{
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);
}
}
/// <summary>
/// Handles schema compare cancel request
/// </summary>
/// <returns></returns>
public async Task HandleSchemaCompareCancelRequest(SchemaCompareCancelParams parameters, RequestContext <ResultStatus> requestContext)
{
try
{
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
{
await requestContext.SendResult(new ResultStatus()
{
Success = false,
ErrorMessage = SR.SchemaCompareSessionNotFound
});
}
}
catch (Exception e)
{
await requestContext.SendError(e);
}
}
/// <summary>
/// Adds a procedure that can be called by remote peer to the scene.
/// </summary>
/// <param name="route"></param>
/// <param name="handler"></param>
/// <param name="ordered">True if the message should be alwayse receive in order, false otherwise.</param>
/// <remarks>
/// The procedure is added to the scene to which this service is attached.
/// </remarks>
public void AddProcedure(string route, Func<RequestContext<IScenePeer>, Task> handler, bool ordered)
{
this._scene.AddRoute(route, p =>
{
var buffer = new byte[2];
p.Stream.Read(buffer, 0, 2);
var id = BitConverter.ToUInt16(buffer, 0);
var cts = new CancellationTokenSource();
var ctx = new RequestContext<IScenePeer>(p.Connection, _scene, id, ordered, new SubStream(p.Stream, false), cts.Token);
var identifier = System.Tuple.Create(p.Connection.Id, id);
if (_runningRequests.TryAdd(identifier, cts))
{
handler.InvokeWrapping(ctx).ContinueWith(t =>
{
_runningRequests.TryRemove(identifier, out cts);
if (t.Status == TaskStatus.RanToCompletion)
{
ctx.SendCompleted();
}
else if (t.Status == TaskStatus.Faulted)
{
var errorSent = false;
var ex = t.Exception.InnerExceptions.OfType<ClientException>();
if (ex.Any())
{
ctx.SendError(string.Join("|", ex.Select(e => e.Message).ToArray()));
errorSent = true;
}
if (t.Exception.InnerExceptions.Any(e => !(e is ClientException)))
{
string errorMessage = string.Format("An error occured while executing procedure '{0}'.", route);
if (!errorSent)
{
var errorId = Guid.NewGuid().ToString("N");
ctx.SendError(string.Format("An exception occurred on the remote peer. Error {0}.", errorId));
errorMessage = string.Format("Error {0}. ", errorId) + errorMessage;
}
_scene.DependencyResolver.Resolve<ILogger>().Log(LogLevel.Error, "rpc.server", errorMessage, t.Exception);
}
}
});
}
}, new Dictionary<string, string> { { RpcClientPlugin.PluginName, RpcClientPlugin.Version } });
}
/// <summary>
/// Adds a procedure that can be called by remote peer to the scene.
/// </summary>
/// <param name="route"></param>
/// <param name="handler"></param>
/// <param name="ordered">True if the message should be alwayse receive in order, false otherwise.</param>
/// <remarks>
/// The procedure is added to the scene to which this service is attached.
/// </remarks>
public void AddProcedure(string route, Func<RequestContext<IScenePeer>, Task> handler, bool ordered)
{
this._scene.AddRoute(route, p =>
{
var buffer = new byte[2];
p.Stream.Read(buffer, 0, 2);
var id = BitConverter.ToUInt16(buffer, 0);
var cts = new CancellationTokenSource();
var ctx = new RequestContext<IScenePeer>(p.Connection, _scene, id, ordered,cts.Token);
if (_runningRequests.TryAdd(id, cts))
{
handler(ctx).ContinueWith(t =>
{
_runningRequests.TryRemove(id, out cts);
if (t.IsCompleted)
{
ctx.SendCompleted();
}
else
{
_scene.resolver.GetComponent<ILogger>().Log(Stormancer.Diagnostics.LogLevel.Error, _scene.Id, "failed to create procedure");
var ex = t.Exception.InnerExceptions.OfType<ClientException>();
if (ex.Any())
{
ctx.SendError(string.Join("|", ex.Select(e => e.Message).ToArray()));
}
}
});
}
}, new Dictionary<string, string> { { "stormancer.plugins.rpc", "1.0.0" } });
_scene.resolver.GetComponent<ILogger>().Log(Stormancer.Diagnostics.LogLevel.Trace, _scene.Id, "Procedure succesfully created");
}
