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());
}
public MockFabricTransportServiceRemotingListener(
ServiceContext serviceContext,
IServiceRemotingMessageHandler serviceRemotingMessageHandler,
FabricTransportRemotingListenerSettings remotingListenerSettings = null,
IServiceRemotingMessageSerializationProvider serializationProvider = null)
: base(serviceContext, serviceRemotingMessageHandler, remotingListenerSettings, serializationProvider)
{
}
public ServiceHostRemotingCommunicationListenerComponents(
IServiceRemotingMessageHandler messageDispatcher,
IServiceRemotingMessageSerializationProvider messageSerializationProvider,
FabricTransportRemotingListenerSettings listenerSettings)
{
this.MessageHandler = messageDispatcher;
this.ListenerSettings = listenerSettings;
this.MessageSerializationProvider = messageSerializationProvider;
}
/// <summary>
/// Constructs a fabric transport based service remoting listener with default
/// <see cref="FabricTransportRemotingListenerSettings"/>.
/// </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="ServiceRemotingDispatcher"/>
/// for message processing.
/// </param>
public FabricTransportServiceRemotingListener(
ServiceContext serviceContext,
IService serviceImplementation)
: this(
serviceContext,
serviceImplementation,
listenerSettings : FabricTransportRemotingListenerSettings.GetDefault())
{
}
/// <summary>
/// Construct a fabric TCP transport based service remoting listener for the specified actor service.
/// </summary>
/// <param name="actorService">
/// The implementation of the actor service.
/// </param>
/// <param name="listenerSettings">
/// The settings to use for the listener.
/// </param>
public FabricTransportActorServiceRemotingListener(
ActorService actorService,
FabricTransportRemotingListenerSettings listenerSettings = null)
: this(
GetContext(actorService),
new ActorServiceRemotingDispatcher(actorService, new DataContractRemotingMessageFactory()),
SetEndPointResourceName(listenerSettings, actorService))
{
}
private static ActorRemotingSerializationManager InitializeSerializerManager(FabricTransportRemotingListenerSettings listenerSettings,
IServiceRemotingMessageSerializationProvider serializationProvider)
{
listenerSettings = listenerSettings ?? FabricTransportRemotingListenerSettings.GetDefault();
return(new ActorRemotingSerializationManager(serializationProvider,
new ActorRemotingMessageHeaderSerializer(listenerSettings.HeaderBufferSize,
listenerSettings.HeaderMaxBufferCount)));
}
/// <summary>
/// Construct a fabric TCP transport based service remoting listener for the specified actor service.
/// </summary>
/// <param name="actorService">
/// The implementation of the actor service.
/// </param>
/// <param name="listenerSettings">
/// The settings to use for the listener.
/// </param>
public FabricTransportActorServiceRemotingListener(
ActorService actorService,
FabricTransportRemotingListenerSettings listenerSettings = null)
: base(
GetContext(actorService),
new ActorServiceRemotingDispatcher(actorService),
SetEndPointResourceName(listenerSettings, actorService))
{
}
private static FabricTransportRemotingListenerSettings GetDefaultFabricTransportListenerSettings(string sectionName = "TransportSettings")
{
var listenerSettings = (FabricTransportRemotingListenerSettings)null;
if (!FabricTransportRemotingListenerSettings.TryLoadFrom(sectionName, out listenerSettings, (string)null))
{
listenerSettings = new FabricTransportRemotingListenerSettings();
}
return(listenerSettings);
}
/// <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>
public FabricTransportActorServiceRemotingListener(
ServiceContext serviceContext,
IServiceRemotingMessageHandler messageHandler,
FabricTransportRemotingListenerSettings listenerSettings = null)
: base(
serviceContext,
messageHandler,
listenerSettings)
{
}
/// <summary>
/// Constructs a fabric transport based service remoting listener with <see cref="FabricTransportRemotingListenerSettings"/>
/// loaded from configuration section.
/// </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="ServiceRemotingDispatcher"/>
/// for message processing.
/// </param>
/// <param name="listenerSettingsConfigSectionName">
/// The name of the configuration section in the configuration package named
/// "Config" in the service manifest that defines the settings for the listener.
/// </param>
public FabricTransportServiceRemotingListener(
ServiceContext serviceContext,
IService serviceImplementation,
string listenerSettingsConfigSectionName)
: this(
serviceContext,
new ServiceRemotingDispatcher(serviceContext, serviceImplementation),
FabricTransportRemotingListenerSettings.LoadFrom(listenerSettingsConfigSectionName))
{
}
/// <summary>
/// Constructs a fabric transport based service remoting listener with <see cref="FabricTransportRemotingListenerSettings"/>
/// loaded from configuration section.
/// </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="listenerSettingsConfigSectionName">
/// The name of the configuration section in the configuration package named
/// "Config" in the service manifest that defines the settings for the listener.
/// </param>
public FabricTransportServiceRemotingListener(
ServiceContext serviceContext,
IServiceRemotingMessageHandler messageHandler,
string listenerSettingsConfigSectionName)
: this(
serviceContext,
messageHandler,
FabricTransportRemotingListenerSettings.LoadFrom(listenerSettingsConfigSectionName))
{
}
internal static FabricTransportRemotingListenerSettings GetActorListenerSettings(ActorService actorService)
{
FabricTransportRemotingListenerSettings listenerSettings;
if (!FabricTransportRemotingListenerSettings.TryLoadFrom(ActorNameFormat.GetFabricServiceTransportSettingsSectionName(actorService.ActorTypeInformation.ImplementationType), out listenerSettings, (string)null))
{
listenerSettings = GetDefaultFabricTransportListenerSettings("TransportSettings");
}
return(listenerSettings);
}
/// <summary>
/// Creates a V2 service remoting listener for remoting the service interface.
/// </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>
/// <returns>
/// A <see cref="FabricTransportServiceRemotingListener"/>
/// as <see cref="IServiceRemotingListener"/>
/// for the specified service implementation.
/// </returns>
public override IServiceRemotingListener CreateServiceRemotingListenerV2(ServiceContext serviceContext, IService serviceImplementation)
{
var settings = FabricTransportRemotingListenerSettings.GetDefault();
settings.MaxMessageSize = this.GetAndValidateMaxMessageSize(settings.MaxMessageSize);
settings.OperationTimeout = this.GetAndValidateOperationTimeout(settings.OperationTimeout);
settings.KeepAliveTimeout = this.GetKeepAliveTimeout(settings.KeepAliveTimeout);
return(new V2.FabricTransport.Runtime.FabricTransportServiceRemotingListener(serviceContext: serviceContext,
serviceImplementation: serviceImplementation, remotingListenerSettings: settings));
}
/// <summary>
/// Constructs a fabric transport based service remoting listener with the specified
/// <see cref="FabricTransportRemotingListenerSettings"/>.
/// </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="ServiceRemotingDispatcher"/>
/// for message processing.
/// </param>
/// <param name="listenerSettings">
/// The settings for the listener.
/// </param>
public FabricTransportServiceRemotingListener(
ServiceContext serviceContext,
IService serviceImplementation,
FabricTransportRemotingListenerSettings listenerSettings)
: this(
serviceContext,
new ServiceRemotingDispatcher(serviceContext, serviceImplementation),
listenerSettings)
{
}
/// <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>
/// Optional override to create listeners (e.g., HTTP, Service Remoting, WCF, etc.) for this service replica to handle client or user requests.
/// </summary>
/// <remarks>
/// For more information on service communication, see https://aka.ms/servicefabricservicecommunication
/// </remarks>
/// <returns>A collection of listeners.</returns>
protected override IEnumerable <ServiceReplicaListener> CreateServiceReplicaListeners()
{
return(new[]
{
new ServiceReplicaListener((c) =>
{
var settings = new FabricTransportRemotingListenerSettings();
settings.UseWrappedMessage = true;
return new FabricTransportServiceRemotingListener(c, this, settings);
})
});
}
/// <summary>
/// Optional override to create listeners (e.g., HTTP, Service Remoting, WCF, etc.) for this service replica to handle client or user requests.
/// </summary>
/// <remarks>
/// For more information on service communication, see https://aka.ms/servicefabricservicecommunication
/// </remarks>
/// <returns>A collection of listeners.</returns>
protected override IEnumerable <ServiceReplicaListener> CreateServiceReplicaListeners()
{
var settings = new FabricTransportRemotingListenerSettings
{
MaxMessageSize = 325236432,
MaxConcurrentCalls = 100
};
return(new[]
{
new ServiceReplicaListener((c) => new FabricTransportServiceRemotingListener(c, this, settings))
});
}
private FabricTransportListener CreateNativeListener(
FabricTransportRemotingListenerSettings listenerSettings,
IServiceRemotingMessageHandler messageHandler,
ServiceContext serviceContext)
{
var connectionHandler = new FabricTransportServiceRemotingConnectionHandler();
return(new FabricTransportListener(
listenerSettings.GetInternalSettings(),
listenerSettings.GetInternalSettings().GetListenerAddress(serviceContext),
new FabricTransportMessagingHandler(messageHandler),
connectionHandler));
}
/// <summary>
/// Constructs a fabric transport based service remoting listener with the specified
/// <see cref="FabricTransportRemotingListenerSettings"/>.
/// </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">
/// The settings to use for the listener.
/// </param>
public FabricTransportServiceRemotingListener(
ServiceContext serviceContext,
IServiceRemotingMessageHandler messageHandler,
FabricTransportRemotingListenerSettings listenerSettings)
{
this.messageHandler = messageHandler;
this.nativeListener = this.CreateNativeListener(
listenerSettings,
this.messageHandler,
serviceContext);
this.listenAddress = serviceContext.ListenAddress;
this.publishAddress = serviceContext.PublishAddress;
}
private static ServiceInstanceListener CreateListenerFor(Func <IService> service, string endpointName, string listenerName)
{
var settings = new FabricTransportRemotingListenerSettings {
EndpointResourceName = endpointName
};
return(new ServiceInstanceListener(context =>
new FabricTransportServiceRemotingListener(
context,
service.Invoke(),
settings,
new ServiceRemotingJsonSerializationProvider()),
listenerName));
}
/// <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)
{
}
internal static FabricTransportRemotingListenerSettings GetActorListenerSettings(ActorService actorService)
{
var sectionName = ActorNameFormat.GetFabricServiceTransportSettingsSectionName(
actorService.ActorTypeInformation.ImplementationType);
FabricTransportRemotingListenerSettings listenerSettings;
var isSucceded = FabricTransportRemotingListenerSettings.TryLoadFrom(sectionName, out listenerSettings);
if (!isSucceded)
{
listenerSettings = FabricTransportRemotingListenerSettings.GetDefault();
}
return(listenerSettings);
}
public override IServiceRemotingListener CreateServiceRemotingListener(ActorService actorService)
{
FabricTransportRemotingListenerSettings listenerSettings = GetActorListenerSettings(actorService);
listenerSettings.MaxMessageSize = this.GetAndValidateMaxMessageSize(listenerSettings.MaxMessageSize);
listenerSettings.OperationTimeout = this.GetandValidateOperationTimeout(listenerSettings.OperationTimeout);
listenerSettings.KeepAliveTimeout = this.GetandValidateKeepAliveTimeout(listenerSettings.KeepAliveTimeout);
var serviceRemotingDispatcher = ActorServiceRemotingDispatcherAttribute.GetServiceRemotingDispatcher(actorService);
return((IServiceRemotingListener) new FabricTransportActorServiceRemotingListener(
serviceContext: actorService.Context,
messageHandler: serviceRemotingDispatcher,
listenerSettings: listenerSettings));
}
private static FabricTransportRemotingListenerSettings SetEndPointResourceName(
FabricTransportRemotingListenerSettings listenerSettings, ActorService actorService)
{
if (listenerSettings == null)
{
listenerSettings = GetActorListenerSettings(actorService);
}
if (listenerSettings.EndpointResourceName.Equals(FabricTransportRemotingListenerSettings.DefaultEndpointResourceName))
{
listenerSettings.EndpointResourceName = ActorNameFormat.GetFabricServiceEndpointName(
actorService.ActorTypeInformation.ImplementationType);
}
return(listenerSettings);
}
/// <summary>
/// Optional override to create listeners (e.g., HTTP, Service Remoting, WCF, etc.) for this service replica to handle client or user requests.
/// </summary>
/// <remarks>
/// For more information on service communication, see https://aka.ms/servicefabricservicecommunication
/// </remarks>
/// <returns>A collection of listeners.</returns>
protected override IEnumerable <ServiceReplicaListener> CreateServiceReplicaListeners()
{
var listenerSettings = new FabricTransportRemotingListenerSettings
{
MaxMessageSize = 10000000,
SecurityCredentials = RemotingExtensions.GetSecurityCredentials(
RemotingExtensions.Certificates.ServiceThumbprint,
RemotingExtensions.Certificates.WebsiteThumbprint,
RemotingExtensions.Certificates.WebsiteCommonName
)
};
return(new[] {
new ServiceReplicaListener(context => new FabricTransportServiceRemotingListener(context, this, listenerSettings))
});
}
public void AddRemotingListener_UsingFunc_RegisterType()
{
string expectedName = nameof(AddRemotingListener_UsingFunc_RegisterType);
FabricTransportRemotingListenerSettings settings = new FabricTransportRemotingListenerSettings();
HostBuilder builder = new HostBuilder();
ServiceFabricHostBuilder <OmexStatelessService, StatelessServiceContext> sfBuilder =
MockServiceFabricHostBuilder.CreateMockBuilder <OmexStatelessService, StatelessServiceContext>(builder);
sfBuilder.AddRemotingListener(expectedName, (p, s) => new MockService(), settings);
IListenerBuilder <OmexStatelessService> value = builder.Build().Services.GetService <IListenerBuilder <OmexStatelessService> >();
Assert.IsNotNull(value);
Assert.AreEqual(expectedName, value.Name);
Assert.AreEqual(settings, GetSettings(value));
}
public void AddRemotingListener_ToStatefulServiceUsingIServiceType_RegisterType()
{
string expectedName = nameof(AddRemotingListener_ToStatefulServiceUsingIServiceType_RegisterType);
FabricTransportRemotingListenerSettings settings = new FabricTransportRemotingListenerSettings();
HostBuilder builder = new HostBuilder();
ServiceFabricHostBuilder <OmexStatefulService, StatefulServiceContext> sfBuilder =
MockServiceFabricHostBuilder.CreateMockBuilder <OmexStatefulService, StatefulServiceContext>(builder);
sfBuilder.AddRemotingListener <MockService>(expectedName, settings);
IListenerBuilder <OmexStatefulService> value = builder.Build().Services.GetService <IListenerBuilder <OmexStatefulService> >();
Assert.IsInstanceOfType(value, typeof(GenericRemotingListenerBuilder <OmexStatefulService>));
Assert.AreEqual(expectedName, value.Name);
Assert.AreEqual(settings, GetSettings(value));
}
/// <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
)
{
}
public void AddRemotingListener_ToStatelessServiceUsingIServiceTypeThatHasUnregisteredDependency_BuildThrowsInvalidOperationException()
{
string expectedName = nameof(AddRemotingListener_ToStatelessServiceUsingIServiceType_RegisterType);
FabricTransportRemotingListenerSettings settings = new FabricTransportRemotingListenerSettings();
HostBuilder builder = new HostBuilder();
ServiceFabricHostBuilder <OmexStatelessService, StatelessServiceContext> sfBuilder =
MockServiceFabricHostBuilder.CreateMockBuilder <OmexStatelessService, StatelessServiceContext>(builder);
sfBuilder.AddRemotingListener <MockServiceWithDependencies>(expectedName, settings);
IListenerBuilder <OmexStatelessService> value = builder.Build().Services.GetRequiredService <IListenerBuilder <OmexStatelessService> >();
InvalidOperationException exception = Assert.ThrowsException <InvalidOperationException>(() => value.Build(MockServiceFabricServices.MockOmexStatelessService));
StringAssert.Contains(exception.Message, typeof(MockServiceWithDependencies).FullName);
StringAssert.Contains(exception.Message, typeof(IMockServiceDependency).FullName);
}
public void AddRemotingListener_ToStatelessServiceUsingIServiceTypeThatHasNoDependencies_BuildDoesNotThrow()
{
string expectedName = nameof(AddRemotingListener_ToStatelessServiceUsingIServiceType_RegisterType);
FabricTransportRemotingListenerSettings settings = new FabricTransportRemotingListenerSettings();
HostBuilder builder = new HostBuilder();
ServiceFabricHostBuilder <OmexStatelessService, StatelessServiceContext> sfBuilder =
MockServiceFabricHostBuilder.CreateMockBuilder <OmexStatelessService, StatelessServiceContext>(builder);
sfBuilder.AddRemotingListener <MockService>(expectedName, settings);
IListenerBuilder <OmexStatelessService> value = builder.Build().Services.GetRequiredService <IListenerBuilder <OmexStatelessService> >();
ICommunicationListener service = value.Build(MockServiceFabricServices.MockOmexStatelessService);
Assert.IsNotNull(service);
Assert.AreEqual(expectedName, value.Name);
Assert.AreEqual(settings, GetSettings(value));
}
