/// <summary>
/// Dispatches the messages received from the client to the actor service methods or the actor methods.
/// This can be used by user where they know interfaceId and MethodId for the method to dispatch to .
/// </summary>
/// <param name="requestContext">Request context that allows getting the callback channel if required.</param>
/// <param name="requestMessage">Remoting message.</param>
/// <returns></returns>
public override Task <IServiceRemotingResponseMessage> HandleRequestResponseAsync(
IServiceRemotingRequestContext requestContext,
IServiceRemotingRequestMessage requestMessage)
{
Requires.ThrowIfNull(requestMessage, "requestMessage");
Requires.ThrowIfNull(requestMessage.GetHeader(), "RequestMessageHeader");
var messageHeaders = requestMessage.GetHeader();
var actorHeaders = requestMessage.GetHeader() as IActorRemotingMessageHeaders;
if (actorHeaders != null)
{
if (messageHeaders.InterfaceId == Runtime.ActorEventSubscription.InterfaceId)
{
return(this.HandleSubscriptionRequestsAsync(
requestContext,
messageHeaders,
requestMessage.GetBody()));
}
return(this.HandleActorMethodDispatchAsync(actorHeaders, requestMessage.GetBody()));
}
return(base.HandleRequestResponseAsync(requestContext, requestMessage));
}
public override async Task <IServiceRemotingResponseMessage> HandleRequestResponseAsync(
IServiceRemotingRequestContext requestContext,
IServiceRemotingRequestMessage requestMessage)
{
IServiceRemotingRequestMessageHeader headers = requestMessage.GetHeader();
if (headers.TryGetHeaderValue(ActivityServiceRemoting.OperationIdHeaderName, out byte[] operationIdBytes))
public override Task <IServiceRemotingResponseMessage> HandleRequestResponseAsync(
IServiceRemotingRequestContext requestContext,
IServiceRemotingRequestMessage requestMessage)
{
ExtractAndSetAllCorrelationHeaderValues(requestMessage.GetHeader());
return(base.HandleRequestResponseAsync(requestContext, requestMessage));
}
private async Task <byte[]> RequestResponseServiceMessageAsync(
IServiceRemotingRequestContext requestContext,
ServiceRemotingMessageHeaders messageHeaders,
byte[] requestBody,
CustomServiceRequestHeader customHeader)
{
var methodName = GetServiceMethodName(messageHeaders.InterfaceId, messageHeaders.MethodId);
byte[] result = null;
using (new ServiceRequestContextWrapper(customHeader))
{
using (_logger?.RecieveServiceMessage(_service.GetServiceContext().ServiceName, methodName, messageHeaders, customHeader))
{
try
{
result = await _innerMessageHandler.RequestResponseAsync(requestContext, messageHeaders, requestBody);
}
catch (Exception ex)
{
_logger?.RecieveServiceMessageFailed(_service.GetServiceContext().ServiceName, methodName, messageHeaders, customHeader, ex);
throw;
}
}
}
return(result);
}
/// <inheritdoc />
public override async Task <IServiceRemotingResponseMessage> HandleRequestResponseAsync(
IServiceRemotingRequestContext requestContext,
IServiceRemotingRequestMessage requestMessage)
{
Activity?activity = null;
IServiceRemotingResponseMessage?responseMessage = null;
try
{
activity = requestMessage.StartActivityFromIncomingRequest(m_diagnosticListener, RequestActivityName);
responseMessage = await base.HandleRequestResponseAsync(requestContext, requestMessage).ConfigureAwait(false);
activity?.SetResult(ActivityResult.Success);
}
catch (Exception ex)
{
m_diagnosticListener.ReportException(ex);
throw;
}
finally
{
m_diagnosticListener.StopActivityIfExist(activity);
}
return(responseMessage);
}
/// <summary>
/// Handles a message from the client that requires a response from the service.
/// </summary>
/// <param name="requestContext">Request context - contains additional information about the request</param>
/// <param name="requestMessage">Request message</param>
public virtual async Task <IServiceRemotingResponseMessage> HandleRequestResponseAsync(
IServiceRemotingRequestContext requestContext,
IServiceRemotingRequestMessage requestMessage)
{
if (this.IsCancellationRequest(requestMessage.GetHeader()))
{
await
this.cancellationHelper.CancelRequestAsync(requestMessage.GetHeader().InterfaceId,
requestMessage.GetHeader().MethodId,
requestMessage.GetHeader().InvocationId);
return(null);
}
else
{
var messageHeaders = requestMessage.GetHeader();
var retval = await this.cancellationHelper.DispatchRequest <IServiceRemotingResponseMessage>(
messageHeaders.InterfaceId,
messageHeaders.MethodId,
messageHeaders.InvocationId,
cancellationToken => this.OnDispatch(messageHeaders, requestMessage.GetBody(),
cancellationToken));
return(retval);
}
}
public override async Task <byte[]> RequestResponseAsync(IServiceRemotingRequestContext requestContext, ServiceRemotingMessageHeaders messageHeaders, byte[] requestBodyBytes)
{
var actorMessageHeaders = messageHeaders.GetActorMessageHeaders(CommunicationLogger);
var methodName = GetActorMethodName(actorMessageHeaders);
var customHeader = messageHeaders.GetCustomServiceRequestHeader(CommunicationLogger) ?? new CustomServiceRequestHeader();
CommunicationLogger?.StartActorMessageRecieved(methodName, customHeader);
byte[] result = null;
try
{
result = await this.RunInRequestContext(
async() => await base.RequestResponseAsync(
requestContext,
messageHeaders,
requestBodyBytes),
customHeader);
CommunicationLogger?.ActorMessageDispatched(methodName, customHeader);
}
catch (Exception ex)
{
CommunicationLogger?.ActorMessageFailed(methodName, customHeader, ex);
throw;
}
finally
{
CommunicationLogger?.StopActorMessageRecieved(methodName, customHeader);
}
return(result);
}
public Task <IServiceRemotingResponseMessage> HandleRequestResponseAsync(IServiceRemotingRequestContext requestContext, IServiceRemotingRequestMessage requestMessage)
{
// Information from Headers can be extracted here from request.
ThreadCultureInfo.AddCultureInfoToCallContext(requestMessage);
var response = this.innerHandler.HandleRequestResponseAsync(requestContext, requestMessage);
return(response);
}
/// <summary>
/// Handles a one way message from the client. It consumes the correlation id and context from the message headers, if any.
/// </summary>
/// <param name="requestContext">Request context - contains additional information about the request.</param>
/// <param name="messageHeaders">Request message headers.</param>
/// <param name="requestBody">Request message body.</param>
public void HandleOneWay(IServiceRemotingRequestContext requestContext, ServiceRemotingMessageHeaders messageHeaders, byte[] requestBody)
{
HandleAndTrackRequestAsync(messageHeaders, () =>
{
_innerHandler.HandleOneWay(requestContext, messageHeaders, requestBody);
return(Task.FromResult <byte[]>(null));
}).Forget();
}
public async override Task <IServiceRemotingResponseMessage> HandleRequestResponseAsync(
IServiceRemotingRequestContext requestContext,
IServiceRemotingRequestMessage requestMessage)
{
IServiceRemotingResponseMessage responseMessage =
await base.HandleRequestResponseAsync(requestContext, TrackingHelper.ProcessRequest(requestMessage)).ConfigureAwait(false);
return(TrackingHelper.ProcessResponse(responseMessage));
}
public async override Task <IServiceRemotingResponseMessage> HandleRequestResponseAsync(
IServiceRemotingRequestContext requestContext,
IServiceRemotingRequestMessage requestMessage)
{
MessagePipeline.Execute(requestMessage);
IServiceRemotingResponseMessage responseMessage = await base.HandleRequestResponseAsync(requestContext, requestMessage);
MessagePipeline.Execute(responseMessage);
return(responseMessage);
}
public override Task <byte[]> RequestResponseAsync(IServiceRemotingRequestContext requestContext,
ServiceRemotingMessageHeaders messageHeaders, byte[] requestBody)
{
messageHeaders.TryGetHeaderValue(HeaderIdentifiers.TraceId, out byte[] col);
if (col != null && col.Any())
{
CallContext.LogicalSetData(HeaderIdentifiers.TraceId, Encoding.ASCII.GetString(col));
}
return(base.RequestResponseAsync(requestContext, messageHeaders, requestBody));
}
public override void HandleOneWay(IServiceRemotingRequestContext requestContext,
ServiceRemotingMessageHeaders messageHeaders, byte[] requestBody)
{
messageHeaders.TryGetHeaderValue(HeaderIdentifiers.TraceId, out byte[] col);
if (col != null && col.Any())
{
CallContext.LogicalSetData(HeaderIdentifiers.TraceId, Encoding.ASCII.GetString(col));
}
base.HandleOneWay(requestContext, messageHeaders, requestBody);
}
public Task <IServiceRemotingResponseMessage> HandleRequestResponseAsync(
IServiceRemotingRequestContext requestContext,
IServiceRemotingRequestMessage requestMessage)
{
var state = new ServiceHostRemotingListenerLoggerMessageState(requestMessage);
using (this.logger.BeginScope(state))
{
return(this.handler.HandleRequestResponseAsync(requestContext, requestMessage));
}
}
public override Task <byte[]> RequestResponseAsync(IServiceRemotingRequestContext requestContext, ServiceRemotingMessageHeaders messageHeaders, byte[] requestBody)
{
var contextDto = messageHeaders.GetContextDto();
CustomServiceContext.SetContext(contextDto);
return(ServiceRequestContext.RunInRequestContext(async() =>
await base.RequestResponseAsync(
requestContext,
messageHeaders,
requestBody),
contextDto));
}
public Task <IServiceRemotingResponseMessage> HandleRequestResponseAsync(IServiceRemotingRequestContext requestContext, IServiceRemotingRequestMessage requestMessage)
{
// Custom events can be hooked here.
// Information from Headers can be extracted here.
var messageHeaders = requestMessage.GetHeader();
var interfaceId = messageHeaders.InterfaceId;
var methodId = messageHeaders.MethodId;
CustomRemotingEvents.RaiseReceiveRequest(string.Empty);
var response = this.innerHandler.HandleRequestResponseAsync(requestContext, requestMessage);
CustomRemotingEvents.RaiseSendResponse(string.Empty);
return(response);
}
public async Task <byte[]> RequestResponseAsync(
IServiceRemotingRequestContext requestContext, ServiceRemotingMessageHeaders messageHeaders, byte[] requestBody)
{
try
{
CorrelationDetails.UpdateCurrentActivityId(messageHeaders);
return(await _serviceRemotingMessageHandler.RequestResponseAsync(requestContext, messageHeaders, requestBody));
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public Task <byte[]> RequestResponseAsync(IServiceRemotingRequestContext requestContext, ServiceRemotingMessageHeaders messageHeaders, byte[] requestBody)
{
var customHeader = messageHeaders.GetCustomServiceRequestHeader(_logger) ?? new CustomServiceRequestHeader();
var actorMessageHeaders = messageHeaders.GetActorMessageHeaders(_logger);
if (actorMessageHeaders == null)
{
return(RequestResponseServiceMessageAsync(requestContext, messageHeaders, requestBody, customHeader));
}
else
{
return(RequestResponseActorMessageAsync(requestContext, messageHeaders, requestBody, actorMessageHeaders, customHeader));
}
}
public override async Task <byte[]> RequestResponseAsync(IServiceRemotingRequestContext requestContext, ServiceRemotingMessageHeaders messageHeaders, byte[] requestBody)
{
byte[] headerValueBytes;
string headerValueString;
bool gotCustomHeader = messageHeaders.TryGetHeaderValue("TestHeader", out headerValueBytes);
if (gotCustomHeader)
{
headerValueString = Encoding.UTF8.GetString(headerValueBytes);
Thread.CurrentPrincipal = new ClaimsPrincipal(new ClaimsIdentity(new Claim[] { new Claim("TestHeader", headerValueString) }));
}
return(await base.RequestResponseAsync(requestContext, messageHeaders, requestBody));
}
/// <summary>
/// Handles a message from the client that requires a response from the service.
/// </summary>
/// <param name="requestContext">Request context - contains additional information about the request</param>
/// <param name="messageHeaders">Request message headers</param>
/// <param name="requestBody">Request message body</param>
/// <returns>Response body</returns>
public virtual async Task <byte[]> RequestResponseAsync(
IServiceRemotingRequestContext requestContext,
ServiceRemotingMessageHeaders messageHeaders,
byte[] requestBody)
{
if (this.IsCancellationRequest(messageHeaders))
{
await
this.cancellationHelper.CancelRequestAsync(messageHeaders.InterfaceId, messageHeaders.MethodId,
messageHeaders.InvocationId);
return(null);
}
else
{
if (null != this.servicePerformanceCounterProvider.serviceOutstandingRequestsCounterWriter)
{
this.servicePerformanceCounterProvider.serviceOutstandingRequestsCounterWriter.UpdateCounterValue(1);
}
var requestStopWatch = Stopwatch.StartNew();
byte[] retval = null;
try
{
retval = await this.cancellationHelper.DispatchRequest <byte[]>(
messageHeaders.InterfaceId,
messageHeaders.MethodId,
messageHeaders.InvocationId,
cancellationToken => this.OnDispatch(messageHeaders, requestBody, cancellationToken));
}
finally
{
if (null != this.servicePerformanceCounterProvider.serviceOutstandingRequestsCounterWriter)
{
this.servicePerformanceCounterProvider.serviceOutstandingRequestsCounterWriter
.UpdateCounterValue(-1);
}
if (null != this.servicePerformanceCounterProvider.serviceRequestProcessingTimeCounterWriter)
{
this.servicePerformanceCounterProvider.serviceRequestProcessingTimeCounterWriter
.UpdateCounterValue(
requestStopWatch.ElapsedMilliseconds);
}
}
return(retval);
}
}
/// <summary>
/// Dispatches the messages received from the client to the actor service methods or the actor methods.
/// </summary>
/// <param name="requestContext">Request context that allows getting the callback channel if required.</param>
/// <param name="messageHeaders">Service remoting message headers</param>
/// <param name="requestBodyBytes">serialized request body of the remoting message.</param>
/// <returns>
/// A <see cref="System.Threading.Tasks.Task">Task</see> that represents outstanding operation.
/// The result of the Task is the serialized response body.
/// </returns>
public override Task <byte[]> RequestResponseAsync(
IServiceRemotingRequestContext requestContext,
ServiceRemotingMessageHeaders messageHeaders,
byte[] requestBodyBytes)
{
if (messageHeaders.InterfaceId == ActorMessageDispatch.InterfaceId)
{
return(this.HandleActorMethodDispatchAsync(messageHeaders, requestBodyBytes));
}
if (messageHeaders.InterfaceId == ActorEventSubscription.InterfaceId)
{
return(this.HandleSubscriptionRequestsAsync(requestContext, messageHeaders, requestBodyBytes));
}
return(base.RequestResponseAsync(requestContext, messageHeaders, requestBodyBytes));
}
public override async Task <byte[]> RequestResponseAsync(IServiceRemotingRequestContext requestContext, ServiceRemotingMessageHeaders messageHeaders,
byte[] requestBodyBytes)
{
try
{
LogServiceMethodStart(...);
result = await base.RequestResponseAsync(requestContext, messageHeaders, requestBodyBytes).ConfigureAwait(false);
LogServiceMethodStop(...);
return(result);
}
catch (Exception exception)
{
LogServiceMethodException(...);
throw;
}
}
/// <summary>
/// Handles a message from the client that requires a response from the service.
/// </summary>
/// <param name="requestContext">Request context - contains additional information about the request</param>
/// <param name="messageHeaders">Request message headers</param>
/// <param name="requestBody">Request message body</param>
/// <returns>Response body</returns>
public virtual Task <byte[]> RequestResponseAsync(
IServiceRemotingRequestContext requestContext,
ServiceRemotingMessageHeaders messageHeaders,
byte[] requestBody)
{
if (this.cancellationHelper.IsCancellationRequest(messageHeaders))
{
return(this.cancellationHelper.CancelRequestAsync(messageHeaders.InterfaceId, messageHeaders.MethodId, messageHeaders.InvocationId));
}
else
{
return(this.cancellationHelper.DispatchRequest(
messageHeaders.InterfaceId,
messageHeaders.MethodId,
messageHeaders.InvocationId,
cancellationToken => this.OnDispatch(messageHeaders, requestBody, cancellationToken)));
}
}
public async Task <IServiceRemotingResponseMessage> HandleRequestResponseAsync(
IServiceRemotingRequestContext requestContext,
IServiceRemotingRequestMessage requestMessage)
{
Dictionary <string, string> context = ExtractContextProperties(requestMessage);
if (context == null)
{
return(await _innerHandler.HandleRequestResponseAsync(requestContext, requestMessage));
}
else
{
using (L.Context(context))
{
return(await _innerHandler.HandleRequestResponseAsync(requestContext, requestMessage));
}
}
}
private async Task <byte[]> HandleSubscriptionRequestsAsync(
IServiceRemotingRequestContext requestContext,
ServiceRemotingMessageHeaders messageHeaders,
byte[] requestMsgBodyBytes)
{
ActorMessageHeaders actorMessageHeaders;
if (!ActorMessageHeaders.TryFromServiceMessageHeaders(messageHeaders, out actorMessageHeaders))
{
//This can only happen if there is issue in our product code like Message Corruption or changing headers format.
ReleaseAssert.Failfast("ActorMessageHeaders Deserialization failed");
}
if (actorMessageHeaders.MethodId == ActorEventSubscription.SubscribeMethodId)
{
var requestMsgBody = (ActorMessageBody)SerializationUtility.Deserialize(ActorEventSubscription.Serializer, requestMsgBodyBytes);
var castedRequestMsgBody = (EventSubscriptionRequestBody)requestMsgBody.Value;
await this.actorService.ActorManager.SubscribeAsync(
actorMessageHeaders.ActorId,
castedRequestMsgBody.eventInterfaceId,
new ActorEventSubscriberProxy(
castedRequestMsgBody.subscriptionId,
requestContext.GetCallbackClient()));
return(null);
}
if (actorMessageHeaders.MethodId == ActorEventSubscription.UnSubscribeMethodId)
{
var requestMsgBody = (ActorMessageBody)SerializationUtility.Deserialize(ActorEventSubscription.Serializer, requestMsgBodyBytes);
var castedRequestMsgBody = (EventSubscriptionRequestBody)requestMsgBody.Value;
await this.actorService.ActorManager.UnsubscribeAsync(
actorMessageHeaders.ActorId,
castedRequestMsgBody.eventInterfaceId,
castedRequestMsgBody.subscriptionId);
return(null);
}
throw new MissingMethodException(string.Format(CultureInfo.CurrentCulture, Actors.SR.ErrorInvalidMethodId, actorMessageHeaders.MethodId));
}
private async Task <byte[]> HandleSubscriptionRequests(
IServiceRemotingRequestContext requestContext,
ServiceRemotingMessageHeaders messageHeaders,
byte[] requestMsgBodyBytes)
{
ActorMessageHeaders actorMessageHeaders;
if (!ActorMessageHeaders.TryFromServiceMessageHeaders(messageHeaders, out actorMessageHeaders))
{
throw new SerializationException(Actors.SR.ErrorActorMessageHeadersDeserializationFailed);
}
if (actorMessageHeaders.MethodId == ActorEventSubscription.SubscribeMethodId)
{
var requestMsgBody = (ActorMessageBody)SerializationUtility.Deserialize(ActorEventSubscription.Serializer, requestMsgBodyBytes);
var castedRequestMsgBody = (EventSubscriptionRequestBody)requestMsgBody.Value;
await this.actorService.ActorManager.SubscribeAsync(
actorMessageHeaders.ActorId,
castedRequestMsgBody.eventInterfaceId,
new ActorEventSubscriberProxy(
castedRequestMsgBody.subscriptionId,
requestContext.GetCallbackClient()));
return(null);
}
if (actorMessageHeaders.MethodId == ActorEventSubscription.UnSubscribeMethodId)
{
var requestMsgBody = (ActorMessageBody)SerializationUtility.Deserialize(ActorEventSubscription.Serializer, requestMsgBodyBytes);
var castedRequestMsgBody = (EventSubscriptionRequestBody)requestMsgBody.Value;
await this.actorService.ActorManager.UnsubscribeAsync(
actorMessageHeaders.ActorId,
castedRequestMsgBody.eventInterfaceId,
castedRequestMsgBody.subscriptionId);
return(null);
}
throw new MissingMethodException(string.Format(CultureInfo.CurrentCulture, Actors.SR.ErrorInvalidMethodId, actorMessageHeaders.MethodId));
}
private async Task <IServiceRemotingResponseMessage> HandleSubscriptionRequestsAsync(
IServiceRemotingRequestContext requestContext,
IServiceRemotingRequestMessageHeader messageHeaders,
IServiceRemotingRequestMessageBody requestMsgBody)
{
var actorHeaders = (IActorRemotingMessageHeaders)messageHeaders;
if (actorHeaders.MethodId == Runtime.ActorEventSubscription.SubscribeMethodId)
{
var castedRequestMsgBody =
(EventSubscriptionRequestBody)requestMsgBody.GetParameter(0, "Value",
typeof(EventSubscriptionRequestBody));
await this.actorService.ActorManager
.SubscribeAsync(
actorHeaders.ActorId,
castedRequestMsgBody.eventInterfaceId,
new ActorEventSubscriberProxy(
castedRequestMsgBody.subscriptionId,
requestContext.GetCallBackClient()));
return(null);
}
if (messageHeaders.MethodId == Runtime.ActorEventSubscription.UnSubscribeMethodId)
{
var castedRequestMsgBody =
(Actors.Remoting.EventSubscriptionRequestBody)requestMsgBody.GetParameter(0, "Value",
typeof(Actors.Remoting.EventSubscriptionRequestBody));
await this.actorService.ActorManager
.UnsubscribeAsync(
actorHeaders.ActorId,
castedRequestMsgBody.eventInterfaceId,
castedRequestMsgBody.subscriptionId);
return(null);
}
throw new MissingMethodException(string.Format(CultureInfo.CurrentCulture, SR.ErrorInvalidMethodId,
messageHeaders.MethodId));
}
public override Task <byte[]> RequestResponseAsync(
IServiceRemotingRequestContext requestContext,
ServiceRemotingMessageHeaders messageHeaders,
byte[] requestBody)
{
var user = messageHeaders.GetUser();
var correlationId = messageHeaders.GetCorrelationId();
var headersInternal = messageHeaders.GetPrivateField <ServiceRemotingMessageHeaders, Dictionary <string, byte[]> >("headers");
var headerNames = headersInternal.Keys;
return(ServiceRequestContext.RunInRequestContext(
async() => await base.RequestResponseAsync(
requestContext,
messageHeaders,
requestBody),
correlationId, user));
}
public async Task <IServiceRemotingResponseMessage> HandleRequestResponseAsync(
IServiceRemotingRequestContext requestContext,
IServiceRemotingRequestMessage requestMessage)
{
Dictionary <string, string> context = ExtractContextProperties(requestMessage);
string methodName = MethodResolver.GetMethodName(requestMessage);
Exception gex = null;
using (L.Context(context))
{
using (var time = new TimeMeasure())
{
try
{
return(await _innerHandler.HandleRequestResponseAsync(requestContext, requestMessage));
}
catch (Exception ex)
{
gex = ex;
throw;
}
finally
{
if (_raiseSummary != null)
{
var summary = new CallSummary(methodName, gex, time.ElapsedTicks);
_raiseSummary(summary);
}
_log.Request(methodName, time.ElapsedTicks, gex,
context.ToDictionary(k => k.Key, v => (object)(v.Value)));
}
}
}
}
public Task <byte[]> RequestResponseAsync(
IServiceRemotingRequestContext requestContext, ServiceRemotingMessageHeaders messageHeaders, byte[] requestBody)
{
ActivityId.UpdateCurrentActivityId(messageHeaders);
return(this.innerRemotingMessageHandler.RequestResponseAsync(requestContext, messageHeaders, requestBody));
}
public Task<byte[]> RequestResponseAsync(IServiceRemotingRequestContext requestContext, ServiceRemotingMessageHeaders messageHeaders,
byte[] requestBody)
{
return Task.FromResult(new byte[0]);
}
public void HandleOneWay(IServiceRemotingRequestContext requestContext, ServiceRemotingMessageHeaders messageHeaders,
byte[] requestBody)
{
}
