public void HandleOneWay(FabricTransportRequestContext requestContext, byte[] headers, byte[] requestBody)
{
var messageHeaders = ServiceRemotingMessageHeaders.Deserialize(this.serializer, headers);
var context = new FabricTransportServiceRemotingRequestContext(requestContext);
this.messageHandler.HandleOneWay(context, messageHeaders, requestBody);
}
public static void AddHeaders(this ServiceRemotingMessageHeaders messageHeaders, IEnumerable <ServiceRequestHeader> headers)
{
foreach (var header in headers)
{
messageHeaders.AddHeader(header);
}
}
public async Task<byte[]> RequestResponseAsync(ServiceRemotingMessageHeaders headers, byte[] requestBody)
{
byte[] result;
var method = _serviceDescription?[headers.InterfaceId]?[headers.MethodId];
try
{
if (method != null) LogMethodStart(method.Name);
SetServiceContext(headers);
result = await _messageHandler.RequestResponseAsync(_requestContext, headers, requestBody)
.ConfigureAwait(false);
if (method != null) LogMethodStop(method.Name);
}
catch (Exception exception)
{
if (method != null) LogMethodFailed(method.Name, exception);
throw new FaultException<RemoteExceptionInformation>(
RemoteExceptionInformation.FromException(exception));
}
finally
{
ServiceContext.SetCurrent(null);
}
return result;
}
private async Task <byte[]> HandleAndTrackRequestAsync(ServiceRemotingMessageHeaders messageHeaders, Func <Task <byte[]> > doHandleRequest)
{
// set service context
ServiceFabricServiceContext.Set(serviceContext);
// create logger per operation
ILogger logger = LoggingContext.CreateLogger <CorrelatingRemotingMessageHandler>();
// Do our best effort in setting the request name.
string methodName = methodNameProvider.GetMethodName(messageHeaders.InterfaceId, messageHeaders.MethodId);
// Weird case, we couldn't find the method in the map. Just use the numerical id as the method name
if (string.IsNullOrEmpty(methodName))
{
methodName = messageHeaders.MethodId.ToString();
}
// get service & operation names
Uri operationUri = ServiceFabricHelper.MakeOperationUri(serviceContext.ServiceName, methodName);
string operationName = ServiceFabricHelper.MakeOperationName(serviceContext.ServiceName, methodName);
string serviceName = ServiceFabricHelper.GetServiceName(serviceContext.ServiceName);
// create request activity
Activity activity = new Activity(operationName);
if (messageHeaders.TryGetHeaderValue(ServiceRemotingStrings.ParentIdHeaderName, out string parentId))
{
activity.SetParentId(parentId);
}
// get parent operation source
messageHeaders.TryGetHeaderValue(ServiceRemotingStrings.SourceHeaderName, out string source);
// set activity baggage
if (messageHeaders.TryGetHeaderValue(ServiceRemotingStrings.CorrelationContextHeaderName, out byte[] correlationBytes))
public async Task <FabricTransportReplyMessage> RequestResponseAsync(
FabricTransportRequestContext requestContext, byte[] headers, byte[] requestBody)
{
// We have Cancellation Token for Remoting layer , hence timeout is not used here.
ServiceRemotingMessageHeaders messageHeaders = null;
try
{
messageHeaders = ServiceRemotingMessageHeaders.Deserialize(this.serializer, headers);
}
catch (Exception e)
{
//This can only happen if there is issue in our product code like Message Corruption or changing headers format.
ReleaseAssert.Failfast("DeSerialization failed for RemotingMessageHeaders with reason {0} for the headers with length {1}", e, headers.Length);
}
var context = new FabricTransportServiceRemotingRequestContext(requestContext);
byte[] replybody;
try
{
replybody = await this.messageHandler.RequestResponseAsync(context, messageHeaders, requestBody);
return(new FabricTransportReplyMessage(false, replybody));
}
catch (Exception e)
{
ServiceTrace.Source.WriteInfo("FabricTransportCommunicationHandler", "Exception While dispatching {0}",
e);
var remoteExceptionInformation = RemoteExceptionInformation.FromException(e);
replybody = remoteExceptionInformation.Data;
return(new FabricTransportReplyMessage(true, replybody));
}
}
Task <byte[]> IServiceRemotingClient.RequestResponseAsync(ServiceRemotingMessageHeaders messageHeaders,
byte[] requestBody)
{
var header = ServiceRemotingMessageHeaders.Serialize(this.serializer, messageHeaders);
return(this.nativeClient.RequestResponseAsync(header, requestBody,
this.settings.OperationTimeout).ContinueWith(t =>
{
var retval = t.GetAwaiter().GetResult();
if (retval.IsException)
{
Exception e;
var isDeserialzied =
RemoteExceptionInformation.ToException(new RemoteExceptionInformation(retval.GetBody()),
out e);
if (isDeserialzied)
{
throw new AggregateException(e);
}
else
{
throw new ArgumentException(@"failed to deserialize and get remote exception",
"remoteExceptionInformation");
}
}
return retval.GetBody();
}));
}
Task <byte[]> IServiceRemotingClient.RequestResponseAsync(ServiceRemotingMessageHeaders messageHeaders,
byte[] requestBody)
{
var header = ServiceRemotingMessageHeaders.Serialize(this.serializer, messageHeaders);
return(this.nativeClient.RequestResponseAsync(header, requestBody,
this.settings.OperationTimeout).ContinueWith(t =>
{
var retval = t.GetAwaiter().GetResult();
if (retval.IsException)
{
Exception e;
var isDeserialzied =
RemoteExceptionInformation.ToException(new RemoteExceptionInformation(retval.GetBody()),
out e);
if (isDeserialzied)
{
throw new AggregateException(e);
}
else
{
throw new ServiceException(e.GetType().FullName, string.Format(
CultureInfo.InvariantCulture,
Remoting.SR.ErrorDeserializationFailure,
e.ToString()));
}
}
return retval.GetBody();
}));
}
public Task <byte[]> RequestResponseAsync(
ServiceRemotingMessageHeaders messageHeaders,
byte[] requestBody)
{
// no op
return(Task.FromResult <byte[]>(null));
}
public void Receiving(ServiceRemotingMessageHeaders headers)
{
if (Manager.CanCopyHeaders())
{
Manager.CopyCommonHeadersFrom(headers);
}
}
public Task <byte[]> RequestResponseAsync(ServiceRemotingMessageHeaders messageHeaders, byte[] requestBody)
{
// add custom header
messageHeaders.AddHeader("TestHeader", Encoding.UTF8.GetBytes("TestHeaderValue"));
return(_inner.RequestResponseAsync(messageHeaders, requestBody));
}
#pragma warning restore 0649
public ServiceRemotingMessageHeaders ToServiceMessageHeaders()
{
var remotingMessageHeaders = new ServiceRemotingMessageHeaders();
remotingMessageHeaders.AddHeader(ActorMessageHeaderName, this.Serialize());
return(remotingMessageHeaders);
}
public virtual async Task <byte[]> RequestResponseAsync(ServiceRemotingMessageHeaders messageHeaders, byte[] requestBody)
{
var args = new ServiceRemotingMessageEventArgs(messageHeaders, requestBody);
await Task.Run(() => ResponseRequested?.Invoke(this, args));
return(args.RequestBody);
}
public void SendOneWay(ServiceRemotingMessageHeaders messageHeaders, byte[] requestBody)
{
// add custom header
messageHeaders.AddHeader("TestHeader", Encoding.UTF8.GetBytes("TestHeaderValue"));
_inner.SendOneWay(messageHeaders, requestBody);
}
private string GetServiceMethodName(ServiceRemotingMessageHeaders messageHeaders)
{
if (messageHeaders == null)
{
return(null);
}
try
{
var methodName = "-";
var lookup = HashUtil.Combine(messageHeaders.InterfaceId, messageHeaders.MethodId);
if (ServiceMethodMap.ContainsKey(lookup))
{
methodName = ServiceMethodMap[lookup];
return(methodName);
}
methodName = _serviceMethodDispatcher.GetMethodDispatcherMapName(
messageHeaders.InterfaceId, messageHeaders.MethodId);
ServiceMethodMap[lookup] = methodName;
return(methodName);
}
catch (Exception ex)
{
// ignored
//_logger?.FailedToGetActorMethodName(actorMessageHeaders, ex);
}
return(null);
}
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);
}
public static Dictionary <string, string> ParseHeaders(
ServiceRemotingMessageHeaders messageHeaders,
out string operationId)
{
var result = new Dictionary <string, string>();
if (messageHeaders.TryGetHeaderValue(HeaderListHeaderName, out string listString))
{
string[] list = listString.Split(';');
foreach (string name in list)
{
if (messageHeaders.TryGetHeaderValue(CorrelationHeader.MakeHeader(name), out string value))
{
result[name] = value;
}
}
}
if (result.TryGetValue(KnownProperty.OperationId, out string operationIdString))
{
operationId = operationIdString;
result.Remove(KnownProperty.OperationId);
}
else
{
operationId = Guid.NewGuid().ToString();
}
return(result);
}
async public Task <byte[]> RequestResponseAsync(ServiceRemotingMessageHeaders headers, byte[] requestBody)
{
try
{
return(await this.wcfClient.Channel.RequestResponseAsync(headers, requestBody).ContinueWith(
t => t.GetAwaiter().GetResult(),
TaskScheduler.Default));
// the code above (TaskScheduler.Default) for dispatches the responses on different thread
// so that if the user code blocks, we do not stop the response receive pump in WCF
}
catch (FaultException <RemoteExceptionInformation> faultException)
{
Exception remoteException;
if (RemoteExceptionInformation.ToException(faultException.Detail, out remoteException))
{
throw new AggregateException(remoteException);
}
throw new ServiceException(remoteException.GetType().FullName, string.Format(
CultureInfo.InvariantCulture,
Microsoft.ServiceFabric.Services.Wcf.SR.ErrorDeserializationFailure,
remoteException.ToString()));
}
}
private static void AddHeaders(ServiceRemotingMessageHeaders headers)
{
byte[] value;
if (!headers.TryGetHeaderValue(ServiceRemotingHeaders.Identity, out value))
{
headers.AddHeader(ServiceRemotingHeaders.Identity, SerializationHelper.SerializeToBytes(ClaimsPrincipal.Current));
}
}
internal static void Add(MessageHeaders messageHeaders)
{
ServiceRemotingMessageHeaders remotingHeaders = Header <OriginationContext> .Get(messageHeaders);
Header <OriginationContext> .Add(Create(), remotingHeaders);
Header <OriginationContext> .Replace(remotingHeaders, messageHeaders);
}
/// <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 static Dictionary <string, byte[]> Headers(this ServiceRemotingMessageHeaders instance)
{
Dictionary <string, byte[]> headers = null;
headers = instance.GetType().InvokeMember("headers",
BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.GetField,
null, instance, new object[0]) as Dictionary <string, byte[]>;
return(headers);
}
private static ActorMessageHeaders GetActorMessageHeaders(ServiceRemotingMessageHeaders messageHeaders)
{
ActorMessageHeaders actorMessageHeaders = null;
if (ActorMessageHeaders.TryFromServiceMessageHeaders(messageHeaders, out actorMessageHeaders))
{
}
return(actorMessageHeaders);
}
private static void SetServiceContext(ServiceRemotingMessageHeaders headers)
{
byte[] bytes;
if (headers.TryGetHeaderValue(ServiceRemotingHeaders.Identity, out bytes))
{
ServiceContext.SetCurrent(new ServiceContext(
SerializationHelper.DeserializeFromBytes<ClaimsPrincipal>(bytes)));
}
}
internal override void OnSending(Uri serviceAddress, MessageHeaders messageHeaders)
{
foreach (IProxyHeaderInterceptor interceptor in Interceptors)
{
ServiceRemotingMessageHeaders headers = Header <ServiceRemotingMessageHeaders> .Get(messageHeaders);
interceptor.Sending(headers);
Header <ServiceRemotingMessageHeaders> .Replace(headers, messageHeaders);
}
}
private CustomServiceRequestHeader UpdateAndGetMessageHeaders(ServiceRemotingMessageHeaders messageHeaders)
{
var customHeader = ServiceRequestContext.Current?.GetCustomHeader();
if (customHeader != null)
{
messageHeaders.AddHeader(customHeader);
}
return(customHeader);
}
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 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));
}
protected override Task <byte[]> SendServiceOneWay(ServiceRemotingMessageHeaders messageHeaders, CustomServiceRequestHeader customServiceRequestHeader, byte[] requestBody)
{
var actorMessageHeaders = GetActorMessageHeaders(messageHeaders);
if (actorMessageHeaders != null)
{
return(SendActorOneWay(messageHeaders, actorMessageHeaders, customServiceRequestHeader, requestBody));
}
return(base.SendServiceOneWay(messageHeaders, customServiceRequestHeader, requestBody));
}
public static void UpdateCurrentActivityId(ServiceRemotingMessageHeaders headers)
{
byte[] headerValue;
if (!headers.TryGetHeaderValue(_activityIdKeyName, out headerValue))
{
return;
}
UpdateCurrentActivityId(Encoding.UTF8.GetString(headerValue));
}
internal bool IsCancellationRequest(ServiceRemotingMessageHeaders messageHeaders)
{
byte[] headerValue;
if (messageHeaders.InvocationId != null &&
messageHeaders.TryGetHeaderValue(ServiceRemotingMessageHeaders.CancellationHeaderName, out headerValue))
{
return(true);
}
return(false);
}
public void Sending(ServiceRemotingMessageHeaders headers)
{
if (OperationContext.Current == null)
{
Manager.AddCommonHeaders(headers);
}
else
{
Manager.CopyCommonHeadersTo(headers);
}
}
public static bool TryFromServiceMessageHeaders(ServiceRemotingMessageHeaders headers, out CustomServiceRequestHeader customServiceRequestHeader)
{
customServiceRequestHeader = (CustomServiceRequestHeader)null;
byte[] headerValue;
if (!headers.TryGetHeaderValue(CustomServiceRequestHeaderName, out headerValue))
{
return(false);
}
customServiceRequestHeader = new CustomServiceRequestHeader(headerValue);
return(true);
}
public static bool TryFromServiceMessageHeaders(ServiceRemotingMessageHeaders headers, out ActorMessageHeaders actorHeaders)
{
actorHeaders = (ActorMessageHeaders)null;
byte[] headerValue;
if (!headers.TryGetHeaderValue(ActorMessageHeaderName, out headerValue))
{
return(false);
}
actorHeaders = ActorMessageHeaders.Deserialize(headerValue);
return(true);
}
public void OneWayMessage(ServiceRemotingMessageHeaders messageHeaders, byte[] requestBody)
{
var method = _serviceDescription?[messageHeaders.InterfaceId]?[messageHeaders.MethodId];
try
{
if (method != null) LogMethodStart(method.Name);
SetServiceContext(messageHeaders);
_messageHandler.HandleOneWay(_requestContext, messageHeaders, requestBody);
if (method != null) LogMethodStop(method.Name);
}
catch (Exception exception)
{
if (method != null) LogMethodFailed(method.Name, exception);
throw;
}
finally
{
SetServiceContext(null);
}
}
public Task<byte[]> RequestResponseAsync(ServiceRemotingMessageHeaders headers, byte[] requestBody)
{
AddHeaders(headers);
return Channel.RequestResponseAsync(headers, requestBody).ContinueWith(t => t.GetAwaiter().GetResult(), TaskScheduler.Default);
}
public void SendOneWay(ServiceRemotingMessageHeaders messageHeaders, byte[] requestBody)
{
AddHeaders(messageHeaders);
Channel.OneWayMessage(messageHeaders, requestBody);
}
public Task<byte[]> RequestResponseAsync(ServiceRemotingMessageHeaders messageHeaders, byte[] requestBody)
{
return _callbackHandler.RequestResponseAsync(messageHeaders, requestBody);
}
public async Task<byte[]> RequestResponseAsync(ServiceRemotingMessageHeaders messageHeaders, byte[] requestBody)
{
var response = await _callbackChannel.RequestResponseAsync(messageHeaders, requestBody).ConfigureAwait(false);
return response;
}
public void OneWayMessage(ServiceRemotingMessageHeaders messageHeaders, byte[] requestBody)
{
_callbackChannel.SendOneWay(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)
{
}
public void SendOneWay(ServiceRemotingMessageHeaders headers, byte[] msgBody)
{
Task.Run(() => _callbackHandler.OneWayMessage(headers, msgBody));
}
