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)); }