private void Initialize(FabricTransportRemotingSettings remotingSettings,
IServiceRemotingCallbackMessageHandler remotingCallbackMessageHandler,
IServicePartitionResolver servicePartitionResolver,
IEnumerable <IExceptionHandler> exceptionHandlers,
string traceId,
IServiceRemotingMessageSerializationProvider serializationProvider,
IServiceRemotingMessageHeaderSerializer headerSerializer = null)
{
remotingSettings = remotingSettings ?? FabricTransportRemotingSettings.GetDefault();
if (headerSerializer == null)
{
headerSerializer = new ServiceRemotingMessageHeaderSerializer(new BufferPoolManager(remotingSettings.HeaderBufferSize, remotingSettings.HeaderMaxBufferCount));
}
var serializersManager = new ServiceRemotingMessageSerializersManager(serializationProvider,
headerSerializer);
this.Initialize(remotingSettings,
remotingCallbackMessageHandler,
servicePartitionResolver,
exceptionHandlers,
traceId,
serializersManager.GetSerializationProvider().CreateMessageBodyFactory(),
serializersManager);
}
/// <summary>
/// Constructs a WCF based service remoting client factory.
/// </summary>
/// <param name="clientBinding">
/// WCF binding to use for the client. If the client binding is not specified or null,
/// a default client binding is created using
/// <see cref="Microsoft.ServiceFabric.Services.Communication.Wcf.WcfUtility.CreateTcpClientBinding"/> method
/// which creates a <see cref="System.ServiceModel.NetTcpBinding"/> with no security.
/// </param>
/// <param name="callbackClient">
/// The callback client that receives the callbacks from the service.
/// </param>
/// <param name="exceptionHandlers">
/// Exception handlers to handle the exceptions encountered in communicating with the service.
/// </param>
/// <param name="servicePartitionResolver">
/// Service partition resolver to resolve the service endpoints. If not specified, a default
/// service partition resolver returned by <see cref="ServicePartitionResolver.GetDefault"/> is used.
/// </param>
/// <param name="traceId">
/// Id to use in diagnostics traces from this component.
/// </param>
/// <param name="createWcfClientFactory">
/// Delegate function that creates <see cref="Microsoft.ServiceFabric.Services.Communication.Wcf.Client.WcfCommunicationClientFactory{TServiceContract}"/> using the
/// <see cref="Microsoft.ServiceFabric.Services.Remoting.V2.Wcf.IServiceRemotingContract"/>.
/// </param>
/// <param name="serializationProvider"></param>
/// <remarks>
/// This factory uses <see cref="WcfExceptionHandler"/> and <see cref="ServiceRemotingExceptionHandler"/> in addition to the
/// exception handlers supplied to the constructor.
/// </remarks>
public WcfServiceRemotingClientFactory(
Binding clientBinding = null,
IServiceRemotingCallbackMessageHandler callbackClient = null,
IEnumerable <IExceptionHandler> exceptionHandlers = null,
IServicePartitionResolver servicePartitionResolver = null,
string traceId = null,
Func <
Binding,
IEnumerable <IExceptionHandler>,
IServicePartitionResolver,
string,
IServiceRemotingCallbackContract,
WcfCommunicationClientFactory <IServiceRemotingContract> > createWcfClientFactory = null,
IServiceRemotingMessageSerializationProvider serializationProvider = null)
{
if (serializationProvider == null)
{
serializationProvider = new BasicDataContractSerializationProvider();
}
var serializersManager = new ServiceRemotingMessageSerializersManager(serializationProvider,
new BasicDataContractHeaderSerializer());
this.Initialize(serializersManager,
clientBinding,
callbackClient,
exceptionHandlers,
servicePartitionResolver,
traceId,
createWcfClientFactory);
}
internal CorrelatingFabricTransportServiceRemotingClientFactory(
FabricTransportRemotingSettings remotingSettings = null,
IServiceRemotingCallbackMessageHandler remotingCallbackMessageHandler = null,
IServicePartitionResolver servicePartitionResolver = null,
IEnumerable <IExceptionHandler> exceptionHandlers = null,
string traceId = null,
IServiceRemotingMessageSerializationProvider serializationProvider = null,
IServiceRemotingClientFactory inner = null,
Action <CallSummary> raiseSummary = null,
string remoteServiceName = null)
{
if (inner == null)
{
inner = new FabricTransportServiceRemotingClientFactory(
remotingSettings,
remotingCallbackMessageHandler,
servicePartitionResolver,
exceptionHandlers,
traceId,
serializationProvider);
}
_inner = inner;
_raiseSummary = raiseSummary;
_remoteServiceName = remoteServiceName ?? "unknown";
}
public MockFabricTransportServiceRemotingListener(
ServiceContext serviceContext,
IServiceRemotingMessageHandler serviceRemotingMessageHandler,
FabricTransportRemotingListenerSettings remotingListenerSettings = null,
IServiceRemotingMessageSerializationProvider serializationProvider = null)
: base(serviceContext, serviceRemotingMessageHandler, remotingListenerSettings, serializationProvider)
{
}
private static ActorRemotingSerializationManager InitializeSerializerManager(FabricTransportRemotingListenerSettings listenerSettings,
IServiceRemotingMessageSerializationProvider serializationProvider)
{
listenerSettings = listenerSettings ?? FabricTransportRemotingListenerSettings.GetDefault();
return(new ActorRemotingSerializationManager(serializationProvider,
new ActorRemotingMessageHeaderSerializer(listenerSettings.HeaderBufferSize,
listenerSettings.HeaderMaxBufferCount)));
}
public ServiceHostRemotingCommunicationListenerComponents(
IServiceRemotingMessageHandler messageDispatcher,
IServiceRemotingMessageSerializationProvider messageSerializationProvider,
FabricTransportRemotingListenerSettings listenerSettings)
{
this.MessageHandler = messageDispatcher;
this.ListenerSettings = listenerSettings;
this.MessageSerializationProvider = messageSerializationProvider;
}
public CorrelatingFabricTransportServiceRemotingClientFactory(
FabricTransportRemotingSettings remotingSettings = null,
IServiceRemotingCallbackMessageHandler remotingCallbackMessageHandler = null,
IServicePartitionResolver servicePartitionResolver = null,
IEnumerable <IExceptionHandler> exceptionHandlers = null,
string traceId = null,
IServiceRemotingMessageSerializationProvider serializationProvider = null) :
this(remotingSettings, remotingCallbackMessageHandler, servicePartitionResolver, exceptionHandlers, traceId, serializationProvider, null)
{
}
/// <summary>
/// Constructs a fabric transport based service remoting listener.
/// </summary>
/// <param name="serviceContext">
/// The context of the service for which the remoting listener is being constructed.
/// </param>
/// <param name="serviceRemotingMessageHandler">
/// The handler for processing remoting messages. As the messages are received,
/// the listener delivers them to this handler.
/// </param>
/// <param name="serializationProvider">It is used to serialize deserialize request and response body </param>
/// <param name="remotingListenerSettings">The settings for the listener</param>
public FabricTransportServiceRemotingListener(
ServiceContext serviceContext,
IServiceRemotingMessageHandler serviceRemotingMessageHandler,
FabricTransportRemotingListenerSettings remotingListenerSettings = null,
IServiceRemotingMessageSerializationProvider serializationProvider = null
) : this(serviceContext,
serviceRemotingMessageHandler,
InitializeSerializersManager(serializationProvider, remotingListenerSettings),
remotingListenerSettings)
{
}
/// <summary>
/// Construct a fabric TCP transport based service remoting listener for the specified actor service.
/// </summary>
/// <param name="serviceContext">
/// The context of the service for which the remoting listener is being constructed.
/// </param>
/// <param name="messageHandler">
/// The handler for processing remoting messages. As the messages are received,
/// the listener delivers them to this handler.
/// </param>
/// <param name="listenerSettings"></param>
/// <param name="serializationProvider"></param>
public FabricTransportActorServiceRemotingListener(
ServiceContext serviceContext,
IServiceRemotingMessageHandler messageHandler,
FabricTransportRemotingListenerSettings listenerSettings = null,
IServiceRemotingMessageSerializationProvider serializationProvider = null
)
: base(
serviceContext,
messageHandler,
InitializeSerializerManager(listenerSettings,
serializationProvider),
listenerSettings)
{
}
/// <summary>
/// Constructs a WCF based service remoting listener.
/// </summary>
/// <param name="serviceContext">The context of the service for which the remoting listener is being constructed.</param>
/// <param name="serviceRemotingMessageHandler">The handler for receiving and processing remoting messages. As the messages are received
/// the listener delivers the messages to the handler.
/// </param>
/// <param name="serializationProvider"></param>
/// <param name="listenerBinding">WCF binding to use for the listener. If the listener binding is not specified or null,
/// a default listener binding is created using <see cref="Microsoft.ServiceFabric.Services.Communication.Wcf.WcfUtility.CreateTcpListenerBinding"/> method.
/// </param>
/// <param name="address">The endpoint address to use for the WCF listener. If not specified or null, the endpoint
/// address is created using the default endpoint resource named "ServiceEndpoint" defined in the service manifest.
/// </param>
public WcfActorServiceRemotingListener(
ServiceContext serviceContext,
IServiceRemotingMessageHandler serviceRemotingMessageHandler,
IServiceRemotingMessageSerializationProvider serializationProvider,
Binding listenerBinding = null,
EndpointAddress address = null)
: base(
serviceContext,
serviceRemotingMessageHandler,
new ActorRemotingSerializationManager(serializationProvider ?? new BasicDataContractSerializationProvider(),
new BasicDataContractActorHeaderSerializer()),
listenerBinding,
address)
{
}
public ServiceRemotingMessageSerializersManager(
IServiceRemotingMessageSerializationProvider serializationProvider,
IServiceRemotingMessageHeaderSerializer headerSerializer)
{
if (headerSerializer == null)
{
headerSerializer = new ServiceRemotingMessageHeaderSerializer(new BufferPoolManager());
}
if (serializationProvider == null)
{
serializationProvider = new ServiceRemotingDataContractSerializationProvider();
}
this.serializationProvider = serializationProvider;
this.cachedBodySerializers = new ConcurrentDictionary <int, CacheEntry>();
this.headerSerializer = headerSerializer;
}
/// <summary>
/// Constructs a fabric transport based actor remoting client factory.
/// </summary>
/// <param name="fabricTransportRemotingSettings">
/// The settings for the fabric transport. If the settings are not provided or null, default settings
/// with no security.
/// </param>
/// <param name="callbackMessageHandler">
/// The callback client that receives the callbacks from the service.
/// </param>
/// <param name="servicePartitionResolver">
/// Service partition resolver to resolve the service endpoints. If not specified, a default
/// service partition resolver returned by <see cref="ServicePartitionResolver.GetDefault"/> is used.
/// </param>
/// <param name="exceptionHandlers">
/// Exception handlers to handle the exceptions encountered in communicating with the actor.
/// </param>
/// <param name="traceId">
/// Id to use in diagnostics traces from this component.
/// </param>
/// <param name="serializationProvider"></param>
public FabricTransportActorRemotingClientFactory(
FabricTransportRemotingSettings fabricTransportRemotingSettings,
IServiceRemotingCallbackMessageHandler callbackMessageHandler,
IServicePartitionResolver servicePartitionResolver = null,
IEnumerable <IExceptionHandler> exceptionHandlers = null,
string traceId = null,
IServiceRemotingMessageSerializationProvider serializationProvider = null) :
base(IntializeSerializationManager(serializationProvider, fabricTransportRemotingSettings),
fabricTransportRemotingSettings,
callbackMessageHandler,
servicePartitionResolver,
GetExceptionHandlers(exceptionHandlers),
traceId)
{
}
/// <summary>
/// Constructs a WCF based service remoting listener.
/// </summary>
/// <param name="serviceContext">The context of the service for which the remoting listener is being constructed.</param>
/// <param name="messageHandler">The handler for receiving and processing remoting messages. As the messages are received
/// the listener delivers the messages to the handler.
/// </param>
/// <param name="serializationProvider"></param>
/// <param name="listenerBinding">WCF binding to use for the listener. If the listener binding is not specified or null,
/// a default listener binding is created using <see cref="WcfUtility.CreateTcpListenerBinding"/> method which creates
/// a <see cref="System.ServiceModel.NetTcpBinding"/> with no security.
/// </param>
/// <param name="endpointResourceName">The name of the endpoint resource defined in the service manifest that
/// should be used to create the address for the listener. If the endpointResourceName is not specified or it is null,
/// the default value "ServiceEndpointV2" is used.
/// </param>
public WcfServiceRemotingListener(
ServiceContext serviceContext,
IServiceRemotingMessageHandler messageHandler,
IServiceRemotingMessageSerializationProvider serializationProvider = null,
Binding listenerBinding = null,
string endpointResourceName = "ServiceEndpointV2")
{
if (serializationProvider == null)
{
serializationProvider = new BasicDataContractSerializationProvider();
}
var serializerManager = new ServiceRemotingMessageSerializersManager(serializationProvider,
new BasicDataContractHeaderSerializer());
this.Initialize(serviceContext, messageHandler, listenerBinding, endpointResourceName, serializerManager);
}
/// <summary>
/// Constructs a WCF based service remoting listener.
/// </summary>
/// <param name="serviceContext">The context of the service for which the remoting listener is being constructed.</param>
/// <param name="messageHandler">The handler for receiving and processing remoting messages. As the messages are received
/// the listener delivers the messages to the handler.
/// </param>
/// <param name="serializationProvider"></param>
/// <param name="listenerBinding">WCF binding to use for the listener. If the listener binding is not specified or null,
/// a default listener binding is created using <see cref="WcfUtility.CreateTcpListenerBinding"/> method.
/// </param>
/// <param name="address">The endpoint address to use for the WCF listener. If not specified or null, the endpoint
/// address is created using the default endpoint resource named "ServiceEndpointV2" defined in the service manifest.
/// </param>
public WcfServiceRemotingListener(
ServiceContext serviceContext,
IServiceRemotingMessageHandler messageHandler,
IServiceRemotingMessageSerializationProvider serializationProvider = null,
Binding listenerBinding = null,
EndpointAddress address = null)
{
if (serializationProvider == null)
{
serializationProvider = new BasicDataContractSerializationProvider();
}
var serializerManager = new ServiceRemotingMessageSerializersManager(serializationProvider,
new BasicDataContractHeaderSerializer());
this.Initialize(serviceContext, listenerBinding, address, serializerManager, messageHandler);
}
/// <summary>
/// Constructs a WCF based actor remoting factory.
/// </summary>
/// <param name="clientBinding">
/// WCF binding to use for the client. If the client binding is null,
/// a default client binding is created using
/// <see cref="Microsoft.ServiceFabric.Services.Communication.Wcf.WcfUtility.CreateTcpClientBinding"/> method
/// which creates a <see cref="System.ServiceModel.NetTcpBinding"/> with no security.
/// </param>
/// <param name="callbackClient">
/// The callback client that receives the callbacks from the service.
/// </param>
/// <param name="exceptionHandlers">
/// Exception handlers to handle the exceptions encountered in communicating with the service.
/// </param>
/// <param name="servicePartitionResolver">
/// Service partition resolver to resolve the service endpoints. If not specified, a default
/// service partition resolver returned by <see cref="ServicePartitionResolver.GetDefault"/> is used.
/// </param>
/// <param name="traceId">
/// Id to use in diagnostics traces from this component.
/// </param>
/// <param name="serializationProvider"></param>
/// <remarks>
/// This factory uses <see cref="Microsoft.ServiceFabric.Services.Communication.Wcf.Client.WcfExceptionHandler"/>,
/// <see cref="Microsoft.ServiceFabric.Actors.Remoting.Client.ActorRemotingExceptionHandler"/>, in addition to the
/// exception handlers supplied to the constructor.
/// </remarks>
public WcfActorRemotingClientFactory(
Binding clientBinding,
IServiceRemotingCallbackMessageHandler callbackClient,
IEnumerable <IExceptionHandler> exceptionHandlers = null,
IServicePartitionResolver servicePartitionResolver = null,
string traceId = null,
IServiceRemotingMessageSerializationProvider serializationProvider = null) :
base(
new ActorRemotingSerializationManager(serializationProvider ?? new BasicDataContractSerializationProvider(),
new BasicDataContractActorHeaderSerializer()),
clientBinding,
callbackClient,
GetExceptionHandlers(exceptionHandlers),
servicePartitionResolver,
traceId)
{
}
/// <summary>
/// Constructs a fabric transport based service remoting listener .
/// </summary>
/// <param name="serviceContext">
/// The context of the service for which the remoting listener is being constructed.
/// </param>
/// <param name="serviceImplementation">
/// The service implementation object used to construct <see cref="ServiceRemotingMessageDispatcher"/>
/// for message processing.
/// </param>
/// <param name="serializationProvider">It is used to serialize deserialize request and response body </param>
/// <param name="remotingListenerSettings">The settings for the listener</param>
public FabricTransportServiceRemotingListener(
ServiceContext serviceContext,
IService serviceImplementation,
FabricTransportRemotingListenerSettings remotingListenerSettings = null,
IServiceRemotingMessageSerializationProvider serializationProvider = null
)
: this(serviceContext,
new ServiceRemotingMessageDispatcher(
serviceContext,
serviceImplementation,
serializationProvider != null?serializationProvider.CreateMessageBodyFactory():
new DataContractRemotingMessageFactory()),
remotingListenerSettings,
serializationProvider
)
{
}
internal CorrelatingFabricTransportServiceRemotingClientFactory(
FabricTransportRemotingSettings remotingSettings = null,
IServiceRemotingCallbackMessageHandler remotingCallbackMessageHandler = null,
IServicePartitionResolver servicePartitionResolver = null,
IEnumerable <IExceptionHandler> exceptionHandlers = null,
string traceId = null,
IServiceRemotingMessageSerializationProvider serializationProvider = null,
IServiceRemotingClientFactory inner = null)
{
if (inner == null)
{
inner = new FabricTransportServiceRemotingClientFactory(
remotingSettings,
remotingCallbackMessageHandler,
servicePartitionResolver,
exceptionHandlers,
traceId,
serializationProvider);
}
_inner = inner;
}
/// <summary>
/// Constructs a WCF based service remoting listener.
/// </summary>
/// <param name="serviceContext">The context of the service for which the remoting listener is being constructed.</param>
/// <param name="serviceImplementation">The service implementation object.</param>
/// <param name="listenerBinding">WCF binding to use for the listener. If the listener binding is not specified or null,
/// a default listener binding is created using <see cref="WcfUtility.CreateTcpListenerBinding"/> method which creates
/// a <see cref="System.ServiceModel.NetTcpBinding"/> with no security.
/// </param>
/// <param name="serializationProvider"></param>
/// <param name="endpointResourceName">The name of the endpoint resource defined in the service manifest that
/// should be used to create the address for the listener. If the endpointResourceName is not specified or null,
/// the default value "ServiceEndpointV2" is used.
/// </param>
public WcfServiceRemotingListener(
ServiceContext serviceContext,
IService serviceImplementation,
Binding listenerBinding = null,
IServiceRemotingMessageSerializationProvider serializationProvider = null,
string endpointResourceName = "ServiceEndpointV2")
{
if (serializationProvider == null)
{
serializationProvider = new BasicDataContractSerializationProvider();
}
var serializerManager = new ServiceRemotingMessageSerializersManager(serializationProvider,
new BasicDataContractHeaderSerializer());
this.messageHandler = new ServiceRemotingMessageDispatcher(serviceContext, serviceImplementation,
serializerManager.GetSerializationProvider().CreateMessageBodyFactory());
this.wcfListener = new WcfCommunicationListener <IServiceRemotingContract>(
serviceContext,
new WcfRemotingService(
this.messageHandler,
serializerManager),
listenerBinding,
endpointResourceName);
}
public ActorRemotingSerializationManager(IServiceRemotingMessageSerializationProvider serializationProvider,
IServiceRemotingMessageHeaderSerializer headerSerializer) : base(serializationProvider, headerSerializer)
{
}
private static ActorRemotingSerializationManager IntializeSerializationManager(IServiceRemotingMessageSerializationProvider serializationProvider, FabricTransportRemotingSettings settings)
{
settings = settings ?? FabricTransportRemotingSettings.GetDefault();
return(new ActorRemotingSerializationManager(serializationProvider,
new ActorRemotingMessageHeaderSerializer(settings.HeaderBufferSize, settings.HeaderMaxBufferCount)));
}
