public Task <IServiceRemotingResponseMessageBody> InvokeAsync(ActorId actorId, int interfaceId, int methodId,
string callContext,
IServiceRemotingRequestMessageBody requestMsgBody,
IServiceRemotingMessageBodyFactory remotingMessageBodyFactory,
CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
this.ThrowIfClosed();
var methodDispatcher = this.actorService.MethodDispatcherMapV2.GetDispatcher(interfaceId, methodId);
var actorMethodName = methodDispatcher.GetMethodName(methodId);
var actorMethodContext = ActorMethodContext.CreateForActor(actorMethodName);
return(this.DispatchToActorAsync <IServiceRemotingResponseMessageBody>(
actorId: actorId,
actorMethodContext: actorMethodContext,
createIfRequired: true,
actorFunc:
(actor, innerCancellationToken) =>
this.ActorMethodDispatch(methodDispatcher, actor, interfaceId, methodId, requestMsgBody,
remotingMessageBodyFactory,
innerCancellationToken),
callContext: callContext,
timerCall: false,
cancellationToken: cancellationToken));
}
private void Initialize(ServiceRemotingMessageSerializersManager serializersManager, Binding clientBinding,
IServiceRemotingCallbackMessageHandler callbackClient, IEnumerable <IExceptionHandler> exceptionHandlers,
IServicePartitionResolver servicePartitionResolver, string traceId, Func <Binding, IEnumerable <IExceptionHandler>, IServicePartitionResolver, string, IServiceRemotingCallbackContract, WcfCommunicationClientFactory <IServiceRemotingContract> > createWcfClientFactory)
{
this.serializersManager = serializersManager;
if (traceId == null)
{
traceId = Guid.NewGuid().ToString();
}
if (createWcfClientFactory == null)
{
this.wcfFactory = new WcfCommunicationClientFactory <IServiceRemotingContract>(
clientBinding,
GetExceptionHandlers(exceptionHandlers, traceId),
servicePartitionResolver,
traceId,
this.GetCallbackImplementation(callbackClient));
}
else
{
this.wcfFactory = createWcfClientFactory(
clientBinding,
GetExceptionHandlers(exceptionHandlers, traceId),
servicePartitionResolver,
traceId,
this.GetCallbackImplementation(callbackClient));
}
this.wcfFactory.ClientConnected += this.OnClientConnected;
this.wcfFactory.ClientDisconnected += this.OnClientDisconnected;
this.remotingMessageBodyFactory = this.serializersManager.GetSerializationProvider().CreateMessageBodyFactory();
}
//V2 Stack Api
internal void Initialize(
Remoting.V2.Client.ActorServicePartitionClient client,
IServiceRemotingMessageBodyFactory serviceRemotingMessageBodyFactory)
{
this.servicePartitionClientV2 = client;
this.InitializeV2(serviceRemotingMessageBodyFactory);
this.remotingClient = RemotingClient.V2Client;
}
/// <summary>
/// Instantiates the ServiceRemotingDispatcher that uses the given service context and
/// dispatches messages to the given service implementation.
/// </summary>
/// <param name="serviceContext">Service context</param>
/// <param name="serviceImplementation">Service implementation that implements interfaces of type <see cref="IService"/></param>
/// <param name="serviceRemotingMessageBodyFactory">This is the factory used by Dispatcher to create Remoting Response object</param>
public ServiceRemotingMessageDispatcher(ServiceContext serviceContext,
IService serviceImplementation,
IServiceRemotingMessageBodyFactory serviceRemotingMessageBodyFactory = null)
{
var serviceTypeInformation = ServiceTypeInformation.Get(serviceImplementation.GetType());
this.Initialize(serviceContext, serviceImplementation, serviceTypeInformation.InterfaceTypes, false, serviceRemotingMessageBodyFactory);
}
public WcfServiceRemotingCallbackClient(
IServiceRemotingCallbackContract callbackChannel,
ServiceRemotingMessageSerializersManager serializersManager)
{
this.callbackChannel = callbackChannel;
this.serializersManager = serializersManager;
this.remotingMessageBodyFactory = serializersManager.GetSerializationProvider().CreateMessageBodyFactory();
}
public FabricTransportServiceRemotingCallbackClient(
FabricTransportCallbackClient fabricTransportCallbackClient,
ServiceRemotingMessageSerializersManager serializersManager)
{
this.fabricTransportCallbackClient = fabricTransportCallbackClient;
this.serializersManager = serializersManager;
this.remotingMessageBodyFactory = this.serializersManager.GetSerializationProvider().CreateMessageBodyFactory();
}
public ActivityServiceRemotingMessageDispatcher(
ServiceContext serviceContext,
IService serviceImplementation,
IServiceRemotingMessageBodyFactory serviceRemotingMessageBodyFactory) : base(
serviceContext,
serviceImplementation,
serviceRemotingMessageBodyFactory)
{
}
//V2 APi
internal void Initialize(
ServiceFabric.Services.Remoting.V2.Builder.ServiceProxyGenerator proxyGenerator,
ServiceFabric.Services.Remoting.V2.Client.ServiceRemotingPartitionClient client,
IServiceRemotingMessageBodyFactory serviceRemotingMessageBodyFactory)
{
this.partitionClientV2 = client;
this.ServiceInterfaceType = proxyGenerator.ProxyInterfaceType;
base.InitializeV2(serviceRemotingMessageBodyFactory);
}
/// <summary>
/// Instantiates the ActorServiceRemotingDispatcher that can dispatch messages to an actor service and
/// to the actors hosted in the service..
/// </summary>
/// <param name="actorService">An actor service instance.</param>
/// <param name="serviceRemotingRequestMessageBodyFactory"></param>
public ActorServiceRemotingDispatcher(ActorService actorService,
IServiceRemotingMessageBodyFactory serviceRemotingRequestMessageBodyFactory)
: base(GetContext(actorService),
actorService,
serviceRemotingRequestMessageBodyFactory)
{
this.actorService = actorService;
this.cancellationHelper = new ServiceRemotingCancellationHelper(actorService.Context.TraceId);
}
public ServiceProxy CreateServiceProxy
(ServiceRemotingPartitionClient remotingPartitionClient,
IServiceRemotingMessageBodyFactory remotingMessageBodyFactory)
{
var serviceProxy = (ServiceProxy)this.proxyActivator.CreateInstance();
serviceProxy.Initialize(this, remotingPartitionClient, remotingMessageBodyFactory);
return(serviceProxy);
}
public MyActorService(StatefulServiceContext context, ActorTypeInformation actorTypeInfo, Func <ActorService, ActorId, ActorBase> actorFactory = null, Func <ActorBase, IActorStateProvider, IActorStateManager> stateManagerFactory = null, IActorStateProvider stateProvider = null, ActorServiceSettings settings = null) : base(context, actorTypeInfo, actorFactory, stateManagerFactory, stateProvider, settings)
{
this.messageBodyFactory = new CustomMessageFactory();
this.serviceContext = context;
var fabricClient = new FabricClient();
var partitionInfo = (Int64RangePartitionInformation)fabricClient.QueryManager.GetPartitionAsync(this.Context.PartitionId).GetAwaiter().GetResult()[0].PartitionInformation;
this.lowKey = partitionInfo.LowKey;
this.highkey = partitionInfo.HighKey;
}
public void GetRemotingMessageBodyFactory_PropagatesCalls()
{
IServiceRemotingMessageBodyFactory expectedResult = new Mock <IServiceRemotingMessageBodyFactory>().Object;
Mock <IServiceRemotingClientFactory> factoryMock = new Mock <IServiceRemotingClientFactory>();
factoryMock.Setup(f => f.GetRemotingMessageBodyFactory()).Returns(expectedResult);
OmexServiceRemotingClientFactory wrapper = new OmexServiceRemotingClientFactory(factoryMock.Object);
IServiceRemotingMessageBodyFactory actualResult = wrapper.GetRemotingMessageBodyFactory();
factoryMock.Verify(f => f.GetRemotingMessageBodyFactory());
Assert.AreEqual(expectedResult, actualResult);
}
public ActorServicePartitionClient(
IServiceRemotingClientFactory remotingClientFactory,
Uri serviceUri,
ActorId actorId,
string listenerName = null,
OperationRetrySettings retrySettings = null)
: base(remotingClientFactory, serviceUri,
new ServicePartitionKey(actorId.GetPartitionKey()),
TargetReplicaSelector.Default,
listenerName,
retrySettings)
{
this.ActorId = actorId;
this.messageBodyFactory = remotingClientFactory.GetRemotingMessageBodyFactory();
}
////Why we pass IServiceRemotingMessageBodyFactory to this function instead of
/// setting at class level?. Since we cache MethodDispatcher for each interface ,
/// we can't set IServiceRemotingMessageBodyFactory at class level .
/// These can be cases where multiple IServiceRemotingMessageBodyFactory implmenetation
/// but single dispatcher class .
/// <summary>
///This method is used to dispatch request to the specified methodId of the
/// interface implemented by the remoted object.
/// </summary>
/// <param name="objectImplementation"></param>
/// <param name="methodId"></param>
/// <param name="requestBody"></param>
/// <param name="remotingMessageBodyFactory"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public Task <IServiceRemotingResponseMessageBody> DispatchAsync(object objectImplementation, int methodId,
IServiceRemotingRequestMessageBody requestBody,
IServiceRemotingMessageBodyFactory remotingMessageBodyFactory,
CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
var dispatchTask = this.OnDispatchAsync(
methodId,
objectImplementation,
requestBody,
remotingMessageBodyFactory,
cancellationToken);
return(dispatchTask);
}
private Task <IServiceRemotingResponseMessageBody> ActorMethodDispatch(
Remoting.V2.Builder.ActorMethodDispatcherBase methodDispatcher, ActorBase actor, int interfaceId,
int methodId,
IServiceRemotingRequestMessageBody requestBody,
IServiceRemotingMessageBodyFactory remotingMessageBodyFactory, CancellationToken innerCancellationToken)
{
var actorInterfaceMethodKey =
DiagnosticsEventManager.GetInterfaceMethodKey((uint)interfaceId, (uint)methodId);
this.DiagnosticsEventManager.ActorMethodStart(actorInterfaceMethodKey, actor, RemotingListener.V2Listener);
Task <IServiceRemotingResponseMessageBody> dispatchTask;
try
{
dispatchTask = methodDispatcher.DispatchAsync(actor, methodId, requestBody, remotingMessageBodyFactory,
innerCancellationToken);
}
catch (Exception e)
{
this.DiagnosticsEventManager.ActorMethodFinish(actorInterfaceMethodKey, actor, e,
RemotingListener.V2Listener);
throw;
}
return(dispatchTask.ContinueWith(
t =>
{
IServiceRemotingResponseMessageBody responseMsgBody = null;
try
{
responseMsgBody = t.GetAwaiter().GetResult();
}
catch (Exception e)
{
this.DiagnosticsEventManager.ActorMethodFinish(actorInterfaceMethodKey, actor, e,
RemotingListener.V2Listener);
throw;
}
this.DiagnosticsEventManager.ActorMethodFinish(actorInterfaceMethodKey, actor, null,
RemotingListener.V2Listener);
return responseMsgBody;
},
TaskContinuationOptions.ExecuteSynchronously));
}
/// <summary>
/// Instantiates the ServiceRemotingDispatcher that uses the given service context and
/// dispatches messages to the given service implementation.
/// This dispatcher can be used to dispatch request to the specified Remoting types.
/// </summary>
/// <param name="remotingTypes">Types to which you can dispatch request to </param>
/// <param name="serviceContext">Service context</param>
/// <param name="serviceImplementation">Service implementation that implements specified remoting interfaces</param>
/// <param name="serviceRemotingMessageBodyFactory"></param>
public ServiceRemotingMessageDispatcher(
IEnumerable <Type> remotingTypes,
ServiceContext serviceContext,
object serviceImplementation,
IServiceRemotingMessageBodyFactory serviceRemotingMessageBodyFactory = null)
{
var allRemotingTypes = new List <Type>();
foreach (var type in remotingTypes)
{
foreach (var baseType in type.GetAllBaseInterfaces())
{
if (!allRemotingTypes.Contains(baseType))
{
allRemotingTypes.Add(baseType);
}
}
}
this.Initialize(serviceContext, serviceImplementation, allRemotingTypes, true, serviceRemotingMessageBodyFactory);
}
private void Initialize(FabricTransportRemotingSettings remotingSettings,
IServiceRemotingCallbackMessageHandler remotingCallbackMessageHandler,
IServicePartitionResolver servicePartitionResolver,
IEnumerable <IExceptionHandler> exceptionHandlers,
string traceId,
IServiceRemotingMessageBodyFactory messageBodyFactory,
ServiceRemotingMessageSerializersManager serializersManager)
{
this.remotingMessageBodyFactory = messageBodyFactory;
this.clientFactoryImpl = new FabricTransportServiceRemotingClientFactoryImpl(
serializersManager,
remotingSettings,
remotingCallbackMessageHandler,
servicePartitionResolver,
exceptionHandlers,
traceId
);
this.clientFactoryImpl.ClientConnected += this.OnClientConnected;
this.clientFactoryImpl.ClientDisconnected += this.OnClientDisconnected;
}
private void Initialize(ServiceContext serviceContext, object serviceImplementation,
IEnumerable <Type> remotedInterfaces, bool nonServiceInterface,
IServiceRemotingMessageBodyFactory serviceRemotingMessageBodyFactory)
{
this.serviceRemotingMessageBodyFactory = serviceRemotingMessageBodyFactory ?? new DataContractRemotingMessageFactory();
this.cancellationHelper = new ServiceRemotingCancellationHelper(serviceContext.TraceId);
this.methodDispatcherMap = new Dictionary <int, MethodDispatcherBase>();
this.serviceImplementation = serviceImplementation;
if (serviceImplementation != null)
{
var interfaceDescriptions = new List <ServiceInterfaceDescription>();
foreach (var interfaceType in remotedInterfaces)
{
MethodDispatcherBase methodDispatcher;
if (nonServiceInterface)
{
methodDispatcher = ServiceCodeBuilder.GetOrCreateMethodDispatcherForNonMarkerInterface(interfaceType);
interfaceDescriptions.Add(ServiceInterfaceDescription.CreateUsingCRCId(interfaceType, false));
}
else
{
methodDispatcher = ServiceCodeBuilder.GetOrCreateMethodDispatcher(interfaceType);
interfaceDescriptions.Add(ServiceInterfaceDescription.CreateUsingCRCId(interfaceType, true));
}
this.methodDispatcherMap.Add(methodDispatcher.InterfaceId, methodDispatcher);
}
this.servicePerformanceCounterProvider =
new ServicePerformanceCounterProvider(serviceContext.PartitionId,
serviceContext.ReplicaOrInstanceId,
interfaceDescriptions,
false);
}
}
/// <inheritdoc/>
public ExtendedActorServiceRemotingDispatcher(ActorService actorService, IServiceRemotingMessageBodyFactory serviceRemotingRequestMessageBodyFactory)
: base(actorService, serviceRemotingRequestMessageBodyFactory)
{
}
public CustomActorMessageHandler(ActorService actorService, IServiceRemotingMessageBodyFactory serviceRemotingRequestMessageBodyFactory)
: base(actorService, serviceRemotingRequestMessageBodyFactory)
{
}
public Task <IServiceRemotingResponseMessageBody> InvokeAsync(ActorId actorId, int interfaceId, int methodId, string callContext,
IServiceRemotingRequestMessageBody requestMsgBody, IServiceRemotingMessageBodyFactory remotingMessageBodyFactory,
CancellationToken cancellationToken)
{
return(TaskDone <IServiceRemotingResponseMessageBody> .Done);
}
/// <summary>
/// Internal - used by Service remoting
/// </summary>
/// <param name="methodName"></param>
/// <param name="remotingMessageBodyFactory"></param>
/// <param name="task">continuation task</param>
/// <param name="interfaceName"></param>
/// <returns>
/// A <see cref="System.Threading.Tasks.Task">Task</see> that represents outstanding operation.
/// </returns>
protected Task <IServiceRemotingResponseMessageBody> ContinueWithResult <TRetVal>(string interfaceName, string methodName,
IServiceRemotingMessageBodyFactory remotingMessageBodyFactory,
Task <TRetVal> task)
{
return(task.ContinueWith(
t => this.CreateResponseMessageBody(interfaceName, methodName, remotingMessageBodyFactory, t.GetAwaiter().GetResult()),
TaskContinuationOptions.ExecuteSynchronously));
}
/// <summary> /// This method is implemented by the generated method dispatcher to dispatch request to the specified methodId of the /// interface implemented by the remoted object. /// </summary> protected abstract Task <IServiceRemotingResponseMessageBody> OnDispatchAsync(int methodId, object remotedObject, IServiceRemotingRequestMessageBody requestBody, IServiceRemotingMessageBodyFactory remotingMessageBodyFactory, CancellationToken cancellationToken);
/// <inheritdoc/>
public ExtendedServiceRemotingMessageDispatcher(ServiceContext serviceContext, IService service, IServiceRemotingMessageBodyFactory serviceRemotingMessageBodyFactory = null)
: base(serviceContext, service, serviceRemotingMessageBodyFactory)
{
}
//V2 Stack Api
internal void InitializeV2(
IServiceRemotingMessageBodyFactory serviceRemotingMessageBodyFactory)
{
this.serviceRemotingMessageBodyFactory = serviceRemotingMessageBodyFactory;
}
/// <inheritdoc/>
public ExtendedServiceRemotingMessageDispatcher(IEnumerable <Type> remotingTypes, ServiceContext serviceContext, object serviceImplementation, IServiceRemotingMessageBodyFactory serviceRemotingMessageBodyFactory = null)
: base(remotingTypes, serviceContext, serviceImplementation, serviceRemotingMessageBodyFactory)
{
}
public PerActorMethodScopedLifestyleMessageHandler(ActorService actorService, IServiceRemotingMessageBodyFactory serviceRemotingRequestMessageBodyFactory)
: base(actorService, serviceRemotingRequestMessageBodyFactory)
{
}
/// <summary>
/// This method is used ti create the remoting response from the specified return value
/// </summary>
/// <param name="interfaceName"></param>
/// <param name="methodName"></param>
/// <param name="remotingMessageBodyFactory"></param>
/// <param name="response"></param>
/// <returns></returns>
protected IServiceRemotingResponseMessageBody CreateResponseMessageBody(string interfaceName, string methodName, IServiceRemotingMessageBodyFactory remotingMessageBodyFactory, object response)
{
var msg = remotingMessageBodyFactory.CreateResponse(interfaceName, methodName);
msg.Set(response);
return(msg);
}
