private FabricTransportMessage CreateFabricTransportMessage(IServiceRemotingResponseMessage retval, int interfaceId, Stopwatch stopwatch)
{
if (retval == null)
{
return(new FabricTransportMessage(null, null));
}
var responseHeader = this.headerSerializer.SerializeResponseHeader(retval.GetHeader());
var fabricTransportRequestHeader = responseHeader != null
? new FabricTransportRequestHeader(responseHeader.GetSendBuffer(),
responseHeader.Dispose)
: new FabricTransportRequestHeader(new ArraySegment <byte>(), null);
var responseSerializer =
this.serializersManager.GetResponseBodySerializer(interfaceId);
stopwatch.Restart();
var responseMsgBody = responseSerializer.Serialize(retval.GetBody());
if (this.serviceRemotingPerformanceCounterProvider.serviceResponseSerializationTimeCounterWriter != null)
{
this.serviceRemotingPerformanceCounterProvider.serviceResponseSerializationTimeCounterWriter
.UpdateCounterValue(stopwatch.ElapsedMilliseconds);
}
var fabricTransportRequestBody = responseMsgBody != null
? new FabricTransportRequestBody(responseMsgBody.GetSendBuffers(),
responseMsgBody.Dispose)
: new FabricTransportRequestBody(new List <ArraySegment <byte> >(), null);
var message = new FabricTransportMessage(
fabricTransportRequestHeader,
fabricTransportRequestBody);
return(message);
}
public async Task <IServiceRemotingResponseMessage> RequestResponseAsync(IServiceRemotingRequestMessage requestMessage)
{
IServiceRemotingResponseMessage responseMessage =
await _InnerClient.RequestResponseAsync(TrackingHelper.ProcessRequest(requestMessage)).ConfigureAwait(false);
return(TrackingHelper.ProcessResponse(responseMessage));
}
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));
}
internal static void Execute(IServiceRemotingResponseMessage response)
{
var pipelineHandlers = responseHandlers.Values;
foreach (var pipelineHandler in pipelineHandlers)
{
pipelineHandler.Handler.Process(response);
}
}
public async Task <IServiceRemotingResponseMessage> RequestResponseAsync(IServiceRemotingRequestMessage requestMessage)
{
MessagePipeline.Execute(requestMessage);
IServiceRemotingResponseMessage result = await this.InnerClient.RequestResponseAsync(requestMessage);
MessagePipeline.Execute(result);
return(result);
}
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);
}
internal ServiceResponseInfo(
IServiceRemotingResponseMessage responseMessage,
string method,
Uri service,
object state,
Exception exception)
{
ResponseMessage = responseMessage;
Method = method;
Service = service;
State = state;
Exception = exception;
}
private async Task <IServiceRemotingResponseMessageBody> HandleRequestResponseAsync(
IServiceRemotingRequestMessageHeader remotingRequestMessageHeader,
IServiceRemotingRequestMessageBody requestMessageBody,
CancellationToken cancellationToken)
{
IServiceRemotingResponseMessage retval = await this.OnDispatch(remotingRequestMessageHeader, requestMessageBody,
cancellationToken);
if (retval != null)
{
return(retval.GetBody());
}
return(null);
}
public async Task Constructor_RequestResponseAsync_PropagateCalls()
{
IServiceRemotingResponseMessage expectedResponce = new Mock <IServiceRemotingResponseMessage>().Object;
IServiceRemotingRequestMessage messsageMock = CreateMessage();
Mock <IServiceRemotingClient> clientMock = new Mock <IServiceRemotingClient>();
clientMock.Setup(c => c.RequestResponseAsync(messsageMock)).Returns(Task.FromResult(expectedResponce));
ServiceRemotingClientWrapper wrapper = new ServiceRemotingClientWrapper(clientMock.Object);
IServiceRemotingResponseMessage responce = await wrapper.RequestResponseAsync(messsageMock);
clientMock.Verify(c => c.RequestResponseAsync(messsageMock), Times.Once);
Assert.AreEqual(expectedResponce, responce);
}
internal ActorResponseInfo(
IServiceRemotingResponseMessage responseMessage,
ActorId actorId,
string method,
Uri service,
object state,
Exception exception)
{
ResponseMessage = responseMessage;
ActorId = actorId;
Method = method;
ActorService = service;
State = state;
Exception = exception;
}
/// <inheritdoc/>
public override async Task <IServiceRemotingResponseMessage> HandleRequestResponseAsync(IServiceRemotingRequestContext requestContext,
IServiceRemotingRequestMessage requestMessage)
{
var handleExtended = false;
Uri serviceUri = null;
object state = null;
Exception exception = null;
var header = requestMessage.GetHeader() as IActorRemotingMessageHeaders;
//check to see if message headers are assignable
if (header != null)
{
handleExtended = true;
serviceUri = (Uri)header.GetCustomHeaders()[CustomHeaders.ReservedHeaderServiceUri];
RemotingContext.FromRemotingMessageHeader(header);
}
if (BeforeHandleRequestResponseAsync != null && handleExtended)
{
state = await BeforeHandleRequestResponseAsync.Invoke(new ActorRequestInfo(requestMessage, header.ActorId, header.MethodName, serviceUri));
}
IServiceRemotingResponseMessage responseMessage = null;
try
{
responseMessage = await base.HandleRequestResponseAsync(requestContext, requestMessage);
}
catch (Exception ex)
{
exception = ex;
throw;
}
finally
{
if (AfterHandleRequestResponseAsync != null && handleExtended)
{
await AfterHandleRequestResponseAsync.Invoke(new ActorResponseInfo(responseMessage, header.ActorId, header.MethodName, serviceUri, state, exception));
}
}
return(responseMessage);
}
/// <inheritdoc/>
public override async Task <IServiceRemotingResponseMessage> HandleRequestResponseAsync(IServiceRemotingRequestContext requestContext,
IServiceRemotingRequestMessage requestMessage)
{
var header = requestMessage.GetHeader();
var serviceUri = (Uri)header.GetCustomHeaders()[CustomHeaders.ReservedHeaderServiceUri];
RemotingContext.FromRemotingMessageHeader(header);
object state = null;
Exception exception = null;
if (BeforeHandleRequestResponseAsync != null)
{
state = await BeforeHandleRequestResponseAsync.Invoke(new ServiceRequestInfo(requestMessage, header.MethodName, serviceUri));
}
IServiceRemotingResponseMessage responseMessage = null;
try
{
responseMessage = await base.HandleRequestResponseAsync(requestContext, requestMessage);
}
catch (Exception ex)
{
exception = ex;
throw;
}
finally
{
if (AfterHandleRequestResponseAsync != null)
{
await AfterHandleRequestResponseAsync.Invoke(new ServiceResponseInfo(responseMessage, header.MethodName, serviceUri, state, exception));
}
}
return(responseMessage);
}