public WcfServiceRemotingClient(
WcfCommunicationClient <IServiceRemotingContract> wcfClient,
ServiceRemotingMessageSerializersManager serializersManager)
{
this.serializersManager = serializersManager;
this.WcfClient = wcfClient;
}
/// <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 FabricTransportServiceRemotingListener(
ServiceContext serviceContext,
IServiceRemotingMessageHandler serviceRemotingMessageHandler,
ServiceRemotingMessageSerializersManager serializersManager,
FabricTransportRemotingListenerSettings remotingListenerSettings = null
)
{
Requires.ThrowIfNull(serviceContext, "serviceContext");
this.listenAddress = serviceContext.ListenAddress;
this.publishAddress = serviceContext.PublishAddress;
var remotingSettings = remotingListenerSettings != null
? remotingListenerSettings
: FabricTransportRemotingListenerSettings.GetDefault();
if (remotingSettings.EndpointResourceName.Equals(FabricTransportRemotingListenerSettings
.DefaultEndpointResourceName))
{
remotingSettings.EndpointResourceName = DefaultV2ListenerEndpointResourceName;
}
this.transportMessageHandler = new FabricTransportMessageHandler(serviceRemotingMessageHandler,
serializersManager,
serviceContext.PartitionId,
serviceContext.ReplicaOrInstanceId);
this.fabricTransportlistener = new FabricTransportListener(remotingSettings.GetInternalSettings(),
remotingSettings.GetInternalSettings().GetListenerAddress(serviceContext),
this.transportMessageHandler,
new FabricTransportRemotingConnectionHandler());
}
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);
}
public WcfRemotingService(IServiceRemotingMessageHandler messageHandler,
ServiceRemotingMessageSerializersManager serializersManager)
{
this.messageHandler = messageHandler;
this.serializersManager = serializersManager;
this.requestContext = new WcfServiceRemotingRequestContext(this.serializersManager);
}
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();
}
public FabricTransportServiceRemotingRequestContext(FabricTransportRequestContext requestContext,
ServiceRemotingMessageSerializersManager serializersManager)
{
this.requestContext = requestContext;
this.serializersManager = serializersManager;
this.id = requestContext.ClientId;
}
// we need to pass a cache of the serializers here rather than the known types,
// the serializer cache should be maintained by the factor
internal FabricTransportServiceRemotingClient(
ServiceRemotingMessageSerializersManager serializersManager,
FabricTransportClient fabricTransportClient)
{
this.fabricTransportClient = fabricTransportClient;
this.serializersManager = serializersManager;
this.IsValid = true;
}
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();
}
internal WcfServiceRemotingListener(
ServiceContext serviceContext,
IServiceRemotingMessageHandler messageHandler,
ServiceRemotingMessageSerializersManager serializerManager,
Binding listenerBinding = null,
string endpointResourceName = "ServiceEndpointV2")
{
this.Initialize(serviceContext, messageHandler, listenerBinding, endpointResourceName, serializerManager);
}
private void Initialize(ServiceContext serviceContext, IServiceRemotingMessageHandler messageHandler,
Binding listenerBinding, string endpointResourceName,
ServiceRemotingMessageSerializersManager serializerManager)
{
this.messageHandler = messageHandler;
this.wcfListener = new WcfCommunicationListener <IServiceRemotingContract>(
serviceContext,
new WcfRemotingService(this.messageHandler, serializerManager),
listenerBinding,
endpointResourceName);
}
internal WcfServiceRemotingListener(
ServiceContext serviceContext,
IServiceRemotingMessageHandler messageHandler,
ServiceRemotingMessageSerializersManager serializersManager,
Binding listenerBinding = null,
EndpointAddress address = null)
{
this.Initialize(serviceContext,
listenerBinding,
address,
serializersManager,
messageHandler);
}
public FabricTransportMessageHandler(
IServiceRemotingMessageHandler remotingMessageHandler,
ServiceRemotingMessageSerializersManager serializersManager,
Guid partitionId,
long replicaOrInstanceId)
{
this.remotingMessageHandler = remotingMessageHandler;
this.serializersManager = serializersManager;
this.partitionId = partitionId;
this.replicaOrInstanceId = replicaOrInstanceId;
this.serviceRemotingPerformanceCounterProvider = new ServiceRemotingPerformanceCounterProvider(this.partitionId,
this.replicaOrInstanceId);
this.headerSerializer = this.serializersManager.GetHeaderSerializer();
}
/// <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);
}
internal FabricTransportServiceRemotingClientFactory(
ServiceRemotingMessageSerializersManager serializersManager,
FabricTransportRemotingSettings remotingSettings = null,
IServiceRemotingCallbackMessageHandler remotingCallbackMessageHandler = null,
IServicePartitionResolver servicePartitionResolver = null,
IEnumerable <IExceptionHandler> exceptionHandlers = null,
string traceId = null)
{
this.Initialize(remotingSettings,
remotingCallbackMessageHandler,
servicePartitionResolver,
exceptionHandlers,
traceId,
serializersManager.GetSerializationProvider().CreateMessageBodyFactory(),
serializersManager);
}
/// <summary>
///
/// </summary>
/// <param name="remotingSettings"></param>
/// <param name="remotingCallbackMessageHandler"></param>
/// <param name="servicePartitionResolver"></param>
/// <param name="exceptionHandlers"></param>
/// <param name="traceId"></param>
/// <param name="serializersManager"></param>
public FabricTransportServiceRemotingClientFactoryImpl(
ServiceRemotingMessageSerializersManager serializersManager,
FabricTransportRemotingSettings remotingSettings,
IServiceRemotingCallbackMessageHandler remotingCallbackMessageHandler = null,
IServicePartitionResolver servicePartitionResolver = null,
IEnumerable <IExceptionHandler> exceptionHandlers = null,
string traceId = null)
: base(
servicePartitionResolver,
GetExceptionHandlers(exceptionHandlers),
traceId)
{
this.settings = remotingSettings ?? FabricTransportRemotingSettings.GetDefault();
this.serializersManager = serializersManager;
this.disposer = new NativeFabricTransportMessageDisposer();
this.fabricTransportRemotingCallbackMessageHandler = new FabricTransportRemotingCallbackMessageHandler(remotingCallbackMessageHandler, this.serializersManager);
}
internal WcfServiceRemotingClientFactory(
ServiceRemotingMessageSerializersManager serializersManager,
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
)
{
this.Initialize(serializersManager, clientBinding, callbackClient, exceptionHandlers, servicePartitionResolver, traceId, createWcfClientFactory);
}
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;
}
/// <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);
}
private void Initialize(ServiceContext serviceContext, Binding listenerBinding, EndpointAddress address,
ServiceRemotingMessageSerializersManager serializerManager,
IServiceRemotingMessageHandler messageHandler)
{
this.messageHandler = messageHandler;
if (address != null)
{
this.wcfListener = new WcfCommunicationListener <IServiceRemotingContract>(
serviceContext,
new WcfRemotingService(this.messageHandler,
serializerManager),
listenerBinding,
address);
}
else
{
this.wcfListener = new WcfCommunicationListener <IServiceRemotingContract>(
serviceContext,
new WcfRemotingService(this.messageHandler,
serializerManager),
listenerBinding,
"ServiceEndpointV2");
}
}
public FabricTransportRemotingCallbackMessageHandler(IServiceRemotingCallbackMessageHandler remotingCallbackClient,
ServiceRemotingMessageSerializersManager manager)
{
this.remotingCallbackClient = remotingCallbackClient;
this.manager = manager;
}
public DummyFabricTransportRemotingClient(ServiceRemotingMessageSerializersManager serializersManager, FabricTransportClient fabricTransportClient) : base(serializersManager, fabricTransportClient)
{
}
public WcfServiceRemotingRequestContext(ServiceRemotingMessageSerializersManager serializerManager)
{
this.serializerManager = serializerManager;
}
public CallbackReceiver(IServiceRemotingCallbackMessageHandler callbackHandler,
ServiceRemotingMessageSerializersManager serializersManager)
{
this.callbackHandler = callbackHandler;
this.serializersManager = serializersManager;
}
