public WebCommunicationListener(IVisualObjectsBox visualObjectsBox, string appRoot, string webSocketRoot, ServiceInitializationParameters serviceInitializationParameters) { this.visualObjectsBox = visualObjectsBox; this.appRoot = appRoot; this.webSocketRoot = webSocketRoot; this.serviceInitializationParameters = serviceInitializationParameters; }
public OwinCommunicationListener(ServiceInitializationParameters serviceInitializationParameters, string appRoot, IOwinAppBuilder startup) { this.serviceInitializationParameters = serviceInitializationParameters; this.startup = startup; this.appRoot = appRoot; ServiceConfiguration.InitializeServiceParameters(serviceInitializationParameters); }
public static void InitializeServiceParameters(ServiceInitializationParameters initparams) { serviceInitializationParameters = initparams; var configurationPackage = serviceInitializationParameters.CodePackageActivationContext.GetConfigurationPackageObject("Config"); configurationSection = configurationPackage.Settings.Sections["ConfigurationSettings"]; }
public void InitializeService(ServiceInitializationParameters initializationParameters) { Mode = LoggingMode.Service; if (initializationParameters == null) { ServiceName = "unknown"; PartitionIdentifier = "unknown"; ReplicaIdentifier = "unknown"; ReplicaLabel = "R"; } else if (initializationParameters is StatefulServiceInitializationParameters) { ServiceName = initializationParameters.ServiceName.OriginalString; ReplicaIdentifier = ((StatefulServiceInitializationParameters)initializationParameters).ReplicaId.ToString(); PartitionIdentifier = initializationParameters.PartitionId.ToString(); ReplicaLabel = "R"; } else if (initializationParameters is StatelessServiceInitializationParameters) { ServiceName = initializationParameters.ServiceName.OriginalString; ReplicaIdentifier = ((StatelessServiceInitializationParameters)initializationParameters).InstanceId.ToString(); PartitionIdentifier = initializationParameters.PartitionId.ToString(); ReplicaLabel = "I"; } else { ServiceName = initializationParameters.ServiceName.OriginalString; ReplicaIdentifier = "n/a"; PartitionIdentifier = initializationParameters.PartitionId.ToString(); ReplicaLabel = "R"; } }
public OwinCommunicationListener(string appRoot, IOwinAppBuilder startup, ServiceInitializationParameters serviceInitializationParameters) { this.startup = startup; this.appRoot = appRoot; this.serviceInitializationParameters = serviceInitializationParameters; }
/// <summary> /// Initializes a new instance of the <see cref="EventHubCommunicationListener" /> class. /// </summary> /// <param name="initParams">The initialize parameters.</param> /// <param name="stateManager">The state manager.</param> /// <param name="stateDictionary">The state dictionary.</param> /// <param name="eventDataHandler">The event data handler.</param> /// <exception cref="System.ArgumentNullException">Connection String /// or /// Event Hub name</exception> public EventHubCommunicationListener( ServiceInitializationParameters initParams, IReliableStateManager stateManager, IReliableDictionary <string, string> stateDictionary, IDataHandler eventDataHandler) { var configurationPackage = initParams.CodePackageActivationContext.GetConfigurationPackageObject("Config"); var configSettings = configurationPackage.Settings.Sections["ConfigurationSettings"]; this.stateManager = stateManager; this.stateDictionary = stateDictionary; this.eventHubName = configSettings.Parameters[Constants.EventHubNameStringKey].Value; this.eventHubConnectionString = configSettings.Parameters[Constants.EventHubConnectionStringKey].Value; this.consumerGroup = configSettings.Parameters[Constants.ConsumerGroupNameKey].Value; this.eventDataHandler = eventDataHandler; if (string.IsNullOrWhiteSpace(this.eventHubConnectionString)) { ServiceEventSource.Current.Message("Invalid Connection String"); throw new ArgumentNullException("Connection String"); } if (string.IsNullOrWhiteSpace(this.eventHubName)) { ServiceEventSource.Current.Message("Invalid Event Hub Name"); throw new ArgumentNullException("Event Hub name"); } ServiceEventSource.Current.Message("Initializing Event Hub Listener"); }
public OwinCommunicationListener(string appRoot, IOwinAppBuilder startup, ServiceInitializationParameters serviceInitializationParameters) { this.startup = startup; this.appRoot = appRoot; this.serviceInitializationParameters = serviceInitializationParameters; }
/// <summary> /// Creates a new instance, using the init parameters of a <see cref="StatefulService"/> /// </summary> /// <param name="receiver">(Required) Processes incoming messages.</param> /// <param name="parameters">(Optional) The parameters that were used to init the Reliable Service that uses this listener.</param> /// <param name="serviceBusQueueName">The name of the monitored Service Bus Queue</param> /// <param name="serviceBusSendConnectionString">(Optional) A Service Bus connection string that can be used for Sending messages. /// (Returned as Service Endpoint.) When not supplied, an App.config appSettings value with key 'Microsoft.ServiceBus.ConnectionString.Receive' /// is used.</param> /// <param name="serviceBusReceiveConnectionString">(Optional) A Service Bus connection string that can be used for Receiving messages. /// When not supplied, an App.config appSettings value with key 'Microsoft.ServiceBus.ConnectionString.Receive' /// is used.</param> public ServiceBusQueueCommunicationListener(IServiceBusMessageReceiver receiver, ServiceInitializationParameters parameters, string serviceBusQueueName, string serviceBusSendConnectionString = null, string serviceBusReceiveConnectionString = null) : base(receiver, parameters, serviceBusSendConnectionString, serviceBusReceiveConnectionString) { if (string.IsNullOrWhiteSpace(serviceBusQueueName)) throw new ArgumentOutOfRangeException(nameof(serviceBusQueueName)); ServiceBusQueueName = serviceBusQueueName; }
public WebCommunicationListener(IVisualObjectsBox visualObjectsBox, string appRoot, string webSocketRoot, ServiceInitializationParameters serviceInitializationParameters) { this.visualObjectsBox = visualObjectsBox; this.appRoot = appRoot; this.webSocketRoot = webSocketRoot; this.serviceInitializationParameters = serviceInitializationParameters; }
/// <summary> /// Initializes a new instance of the <see cref="OwinCommunicationListener" /> class. /// </summary> /// <param name="serviceInitializationParameters">The service initialization parameters.</param> /// <param name="startup">The startup.</param> /// <param name="appRoot">The application root.</param> /// <param name="endpointName">The name of the endpoint in the ServiceManifest.xml to use, defaults to "ServiceEndpoint"</param> public OwinCommunicationListener(ServiceInitializationParameters serviceInitializationParameters, IOwinAppBuilder startup, string appRoot = null, string endpointName = "ServiceEndpoint") { _serviceInitializationParameters = serviceInitializationParameters; _startup = startup; _appRoot = appRoot; _endpointName = endpointName; }
/// <summary> /// Initializes a new instance of the <see cref="OwinCommunicationListener" /> class. /// </summary> /// <param name="serviceInitializationParameters">The service initialization parameters.</param> /// <param name="startup">The startup.</param> /// <param name="appRoot">The application root.</param> /// <param name="endpointName">The name of the endpoint in the ServiceManifest.xml to use, defaults to "ServiceEndpoint"</param> public OwinCommunicationListener(ServiceInitializationParameters serviceInitializationParameters, IOwinAppBuilder startup, string appRoot = null, string endpointName = "ServiceEndpoint") { _serviceInitializationParameters = serviceInitializationParameters; _startup = startup; _appRoot = appRoot; _endpointName = endpointName; }
public WebSocketListener( string appRoot, ServiceInitializationParameters serviceInitializationParameters, Func <IWebSocketConnectionHandler> createConnectionHandler) { this.appRoot = appRoot; this.serviceInitializationParameters = serviceInitializationParameters; this.createConnectionHandler = createConnectionHandler; }
public Recaptcha(ServiceInitializationParameters serviceParameters) { serviceParameters.CodePackageActivationContext.ConfigurationPackageModifiedEvent += this.CodePackageActivationContext_ConfigurationPackageModifiedEvent; ConfigurationPackage configPackage = serviceParameters.CodePackageActivationContext.GetConfigurationPackageObject("Config"); this.UpdateConfigSettings(configPackage.Settings); }
public void Initialize(ServiceInitializationParameters serviceInitializationParameters) { Trace.WriteLine("Initialize"); EndpointResourceDescription serviceEndpoint = serviceInitializationParameters.CodePackageActivationContext.GetEndpoint("ServiceEndpoint"); int port = serviceEndpoint.Port; string root = String.IsNullOrWhiteSpace(this.appRoot) ? string.Empty : this.appRoot.TrimEnd('/') + "/"; this.listeningAddress =string.Format( "http://+:{0}/{1}",port,root); }
/// <summary> /// Create correct address for either stateless or stateful /// </summary> /// <param name="initParams"></param> /// <param name="endpointName"></param> /// <param name="address"></param> /// <returns></returns> public static bool TryCreateAddress(ServiceInitializationParameters initParams, string endpointName, out string address) { if (initParams is StatelessServiceInitializationParameters) { return(TryCreateAddress((StatelessServiceInitializationParameters)initParams, endpointName, out address)); } return(TryCreateAddress((StatefulServiceInitializationParameters)initParams, endpointName, out address)); }
public void Initialize(ServiceInitializationParameters serviceInitializationParameters) { Trace.WriteLine("Initialize"); EndpointResourceDescription serviceEndpoint = serviceInitializationParameters.CodePackageActivationContext.GetEndpoint("ServiceEndpoint"); int port = serviceEndpoint.Port; string root = String.IsNullOrWhiteSpace(this.appRoot) ? string.Empty : this.appRoot.TrimEnd('/') + "/"; this.listeningAddress = string.Format("http://+:{0}/{1}", port, root); }
public static void RegisterComponents(HttpConfiguration config, ServiceInitializationParameters serviceParameters) { UnityContainer container = new UnityContainer(); container.RegisterType<ClusterController>( new TransientLifetimeManager(), new InjectionConstructor(new FakeCaptcha())); config.DependencyResolver = new UnityDependencyResolver(container); }
private void ParametersArePassedToServiceFactoryTestHelper( byte[] initializationData, object returnValue, CodePackageActivationContext context, Func <ServiceFactoryBroker, IntPtr, IntPtr, uint, IntPtr, Guid, long, object> factoryFunc, Func <object, ServiceInitializationParameters> initParamGetterFunc, Func <object, long> idGetterFunc) { ParameterSavingStub stub = new ParameterSavingStub { InstanceToReturn = returnValue }; var broker = new ServiceFactoryBroker(stub, context); // the service factory returns byte[0] byte[] initializationDataExpected = initializationData == null ? new byte[0] : initializationData; using (var pin = new PinBlittable(initializationData)) { var instance = factoryFunc( broker, ServiceFactoryBrokerTest.PtrDefaultServiceType, ServiceFactoryBrokerTest.PtrDefaultServiceUri, initializationData == null ? 0 : (uint)initializationData.Length, pin.AddrOfPinnedObject(), ServiceFactoryBrokerTest.DefaultPartitionId, ServiceFactoryBrokerTest.DefaultInstanceId); // the correct values must be passed into the service factory Assert.AreEqual <long>(ServiceFactoryBrokerTest.DefaultInstanceId, stub.InstanceId); Assert.AreEqual(ServiceFactoryBrokerTest.DefaultServiceTypeName, stub.ServiceType); Assert.AreEqual(new Uri(ServiceFactoryBrokerTest.DefaultServiceUri).ToString().ToLower(), stub.ServiceName.ToString().ToLower()); MiscUtility.CompareEnumerables(initializationDataExpected, stub.InitializationData); Assert.AreSame(returnValue, instance); // the values must be set on the initialization parameters (initialize must have been called) ServiceInitializationParameters actualInitParams = initParamGetterFunc(instance); long actualId = idGetterFunc(instance); Assert.AreEqual <long>(ServiceFactoryBrokerTest.DefaultInstanceId, actualId); Assert.AreEqual(ServiceFactoryBrokerTest.DefaultServiceTypeName, actualInitParams.ServiceTypeName); Assert.AreEqual(new Uri(ServiceFactoryBrokerTest.DefaultServiceUri).ToString().ToLower(), actualInitParams.ServiceName.ToString().ToLower()); Assert.AreEqual(ServiceFactoryBrokerTest.DefaultPartitionId, actualInitParams.PartitionId); if (context != null) { Assert.AreSame(context, actualInitParams.CodePackageActivationContext); } MiscUtility.CompareEnumerables(initializationDataExpected, actualInitParams.InitializationData); } }
public void Initialize(ServiceInitializationParameters serviceInitializationParameters) { EndpointResourceDescription serviceEndpoint = serviceInitializationParameters.CodePackageActivationContext.GetEndpoint("ServiceEndpoint"); int port = serviceEndpoint.Port; this.listeningAddress = String.Format( CultureInfo.InvariantCulture, "http://+:{0}/{1}", port, String.IsNullOrWhiteSpace(this.appRoot) ? String.Empty : this.appRoot.TrimEnd('/') + '/'); }
public void Initialize(ServiceInitializationParameters serviceInitializationParameters) { EndpointResourceDescription serviceEndpoint = serviceInitializationParameters.CodePackageActivationContext.GetEndpoint("ServiceEndpoint"); int port = serviceEndpoint.Port; this.listeningAddress = String.Format( CultureInfo.InvariantCulture, "http://+:{0}/{1}", port, String.IsNullOrWhiteSpace(this.appRoot) ? String.Empty : this.appRoot.TrimEnd('/') + '/'); }
public void Initialize(ServiceInitializationParameters serviceInitializationParameters) { ServiceEventSource.Current.Message("Initialize"); EndpointResourceDescription serviceEndpoint = serviceInitializationParameters.CodePackageActivationContext.GetEndpoint("ServiceEndpoint"); int port = serviceEndpoint.Port; listeningAddress = string.Format("http://+:{0}/", port); publishAddress = listeningAddress.Replace("+", FabricRuntime.GetNodeContext().IPAddressOrFQDN); }
/// <summary> /// Creates the communication listener. /// </summary> private ICommunicationListener CreateCommunicationListener(ServiceInitializationParameters serviceInitializationParameters) { try { return(new OwinCommunicationListener(serviceInitializationParameters, _appBuilder, appRoot: _appRoot)); } catch (Exception ex) { ServiceEventSource.Current.ErrorMessage("OwinService - Failed to Create Communication listener", ex); throw; } }
/// <summary> /// Creates the communication listener. /// </summary> private ICommunicationListener CreateCommunicationListener(ServiceInitializationParameters serviceInitializationParameters) { try { return new OwinCommunicationListener(serviceInitializationParameters, _appBuilder, appRoot: _appRoot); } catch(Exception ex) { ServiceEventSource.Current.ErrorMessage("OwinService - Failed to Create Communication listener", ex); throw; } }
/// <summary> /// Initializes the listener. /// </summary> /// <param name="serviceInitializationParameters">The service initialization parameters.</param> /// <exception cref="System.InvalidOperationException"> /// </exception> public void Initialize(ServiceInitializationParameters serviceInitializationParameters) { _serviceInitializationParameters = serviceInitializationParameters; _endpoint = _serviceInitializationParameters.CodePackageActivationContext.GetEndpoint(_endpointName); if (_endpoint == null) { throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Properties.Resources.ArgumentOutOfRange_EndpointDoesNotExist)); } else if (_endpoint.Protocol != EndpointProtocol.Tcp) { throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Properties.Resources.ArgumentOutOfRange_EndpointNotTCP)); } }
public HttpCommunicationListener(ServiceInitializationParameters initParams, Func <HttpListenerContext, CancellationToken, Task> processRequest) { // Service instance's URL is the node's IP & desired port EndpointResourceDescription inputEndpoint = initParams.CodePackageActivationContext.GetEndpoint("WebApiServiceEndpoint"); // This is the public-facing URL that HTTP clients. string uriPrefix = String.Format("{0}://+:{1}/connectedcar/", inputEndpoint.Protocol, inputEndpoint.Port); string uriPublished = uriPrefix.Replace("+", FabricRuntime.GetNodeContext().IPAddressOrFQDN); this.publishUri = uriPublished; this.processRequest = processRequest; this.httpListener = new HttpListener(); this.httpListener.Prefixes.Add(uriPrefix); }
public void Initialize(StatefulServiceInitializationParameters initializationParameters) { this.initParams = initializationParameters; this.partitionId = initializationParameters.PartitionId; this.replicaId = initializationParameters.ReplicaId; // write the information from the code package activation context var context = initializationParameters.CodePackageActivationContext; WriteEventToGlobalFile(string.Format(CultureInfo.InvariantCulture, "ApplicationName = {0}", context.ApplicationName)); WriteEventToGlobalFile(string.Format(CultureInfo.InvariantCulture, "ApplicationTypeName = {0}", context.ApplicationTypeName)); WriteEventToGlobalFile(string.Format(CultureInfo.InvariantCulture, "ServiceManifestName = {0}", context.GetServiceManifestName())); WriteEventToGlobalFile(string.Format(CultureInfo.InvariantCulture, "ServiceManifestVersion = {0}", context.GetServiceManifestVersion())); WriteEventToGlobalFile(string.Format(CultureInfo.InvariantCulture, "CodePackageName = {0}", context.CodePackageName)); WriteEventToGlobalFile(string.Format(CultureInfo.InvariantCulture, "CodePackageVersion = {0}", context.CodePackageVersion)); }
public void Initialize(ServiceInitializationParameters serviceInitializationParameters) { ServiceEventSource.Current.Message("Initialize"); EndpointResourceDescription serviceEndpoint = serviceInitializationParameters.CodePackageActivationContext.GetEndpoint("ServiceEndpoint"); int port = serviceEndpoint.Port; this.listeningAddress = string.Format( CultureInfo.InvariantCulture, "http://+:{0}/{1}", port, string.IsNullOrWhiteSpace(this.appRoot) ? string.Empty : this.appRoot.TrimEnd('/') + '/'); this.publishAddress = this.listeningAddress.Replace("+", FabricRuntime.GetNodeContext().IPAddressOrFQDN); }
public void Initialize(ServiceInitializationParameters serviceInitializationParameters) { ServiceEventSource.Current.Message("Initialize"); EndpointResourceDescription serviceEndpoint = serviceInitializationParameters.CodePackageActivationContext.GetEndpoint("ServiceEndpoint"); int port = serviceEndpoint.Port; this.listeningAddress = string.Format( CultureInfo.InvariantCulture, "http://+:{0}/{1}", port, string.IsNullOrWhiteSpace(this.appRoot) ? string.Empty : this.appRoot.TrimEnd('/') + '/'); this.publishAddress = this.listeningAddress.Replace("+", FabricRuntime.GetNodeContext().IPAddressOrFQDN); }
public static string GetListeningAddress(ServiceInitializationParameters parameters, string endpointName) { var endpoint = parameters.CodePackageActivationContext.GetEndpoint(endpointName); if (parameters is StatefulServiceInitializationParameters) { var statefulInitParams = (StatefulServiceInitializationParameters)parameters; return $"{endpoint.Protocol}://+:{endpoint.Port}/{statefulInitParams.PartitionId}/{statefulInitParams.ReplicaId}/{Guid.NewGuid()}"; } else if (parameters is StatelessServiceInitializationParameters) { return $"{endpoint.Protocol}://+:{endpoint.Port}"; } else { throw new InvalidOperationException(); } }
public static UriBuilder GetDefaultServiceUri(ServiceInitializationParameters sip) { var context = sip.CodePackageActivationContext; var service = sip.ServiceName; try { foreach (var ep in context.GetEndpoints()) { if (ep.Name.Contains("Service")) { var b = new UriBuilder(service); if (ep.Protocol == EndpointProtocol.Tcp) { b.Scheme = Uri.UriSchemeNetTcp; } else { b.Scheme = Enum.GetName(typeof(EndpointProtocol), ep.Protocol); } b.Host = Node; b.Port = ep.Port; log.Info("Found endpoint name {0}, created uri {1}", ep.Name, b); return(b); } } } catch (Exception e) { if (e is AggregateException) { log.Warn("Failed to get host port from endpoints, aggregate exception: {0}", e.InnerException.Message); } else { log.Warn("Failed to get host port from endpoints, exection: {0}", e.Message); } } return(null); }
public EventHubCommunicationListener( ITraceWriter TraceWriter, IReliableStateManager stateManager, IReliableDictionary <string, string> stateDictionary, ServiceInitializationParameters serviceParameters, string eventHubName, string eventHubConnectionString, string eventHubConsumerGroupName, IEventDataHandler handler) : this(TraceWriter, stateManager, stateDictionary, serviceParameters, eventHubName, eventHubConnectionString, eventHubConsumerGroupName, handler, EventHubCommunicationListenerMode.SafeDistribute, string.Empty) { }
public EventHubCommunicationListener( ITraceWriter TraceWriter, IReliableStateManager stateManager, IReliableDictionary<string, string> stateDictionary, ServiceInitializationParameters serviceParameters, string eventHubName, string eventHubConnectionString, string eventHubConsumerGroupName, IEventDataHandler handler) : this(TraceWriter, stateManager, stateDictionary, serviceParameters, eventHubName, eventHubConnectionString, eventHubConsumerGroupName, handler, EventHubCommunicationListenerMode.SafeDistribute, string.Empty) { }
/// <summary> /// Creates a new instance. /// </summary> /// <param name="receiver">(Required) Processes incoming messages.</param> /// <param name="parameters">(Optional) The parameters that were used to init the Reliable Service that uses this listener.</param> /// <param name="serviceBusSendConnectionString">(Optional) A Service Bus connection string that can be used for Sending messages. /// (Returned as Service Endpoint.) When not supplied, an App.config appSettings value with key 'Microsoft.ServiceBus.ConnectionString.Receive' /// is used.</param> /// <param name="serviceBusReceiveConnectionString">(Optional) A Service Bus connection string that can be used for Receiving messages. /// When not supplied, an App.config appSettings value with key 'Microsoft.ServiceBus.ConnectionString.Receive' /// is used.</param> protected ServiceBusCommunicationListener(IServiceBusMessageReceiver receiver , ServiceInitializationParameters parameters , string serviceBusSendConnectionString , string serviceBusReceiveConnectionString) { if (parameters == null) { throw new ArgumentNullException(nameof(parameters)); } if (receiver == null) { throw new ArgumentNullException(nameof(receiver)); } if (string.IsNullOrWhiteSpace(serviceBusSendConnectionString)) { serviceBusSendConnectionString = CloudConfigurationManager.GetSetting(DefaultSendConnectionStringConfigurationKey); } if (string.IsNullOrWhiteSpace(serviceBusReceiveConnectionString)) { serviceBusReceiveConnectionString = CloudConfigurationManager.GetSetting(DefaultReceiveConnectionStringConfigurationKey); } if (string.IsNullOrWhiteSpace(serviceBusSendConnectionString)) { throw new ArgumentOutOfRangeException(nameof(serviceBusSendConnectionString)); } if (string.IsNullOrWhiteSpace(serviceBusReceiveConnectionString)) { throw new ArgumentOutOfRangeException(nameof(serviceBusReceiveConnectionString)); } Parameters = parameters; Receiver = receiver; ServiceBusSendConnectionString = serviceBusSendConnectionString; ServiceBusReceiveConnectionString = serviceBusReceiveConnectionString; _stopProcessingMessageTokenSource = new CancellationTokenSource(); StopProcessingMessageToken = _stopProcessingMessageTokenSource.Token; }
public EventHubCommunicationListener( ITraceWriter TraceWriter, IReliableStateManager stateManager, IReliableDictionary <string, string> stateDictionary, ServiceInitializationParameters serviceParameters, string eventHubName, string eventHubConnectionString, string eventHubConsumerGroupName, IEventDataHandler handler, EventHubCommunicationListenerMode Mode, string eventHubPartitionId) { this.ListenerMode = Mode; if (this.ListenerMode == EventHubCommunicationListenerMode.Single && string.IsNullOrEmpty(eventHubPartitionId)) { throw new InvalidOperationException("Event hub communication listener in single mode requires a partition id"); } this.m_TraceWriter = TraceWriter; this.m_InitParams = serviceParameters; this.EventHubName = eventHubName; this.EventHubConnectionString = eventHubConnectionString; this.Handler = handler; this.EventHubConsumerGroupName = eventHubConsumerGroupName; this.StateManager = stateManager; this.StateDictionary = stateDictionary; this.ListenerMode = Mode; this.m_TraceWriter.TraceMessage( string.Format( "Event Hub Listener created for {0} on {1} group:{2} mode:{3}", this.EventHubName, this.Namespace, this.EventHubConsumerGroupName, this.ListenerMode.ToString())); }
public EventHubCommunicationListener( ITraceWriter TraceWriter, IReliableStateManager stateManager, IReliableDictionary<string, string> stateDictionary, ServiceInitializationParameters serviceParameters, string eventHubName, string eventHubConnectionString, string eventHubConsumerGroupName, IEventDataHandler handler, EventHubCommunicationListenerMode Mode, string eventHubPartitionId) { this.ListenerMode = Mode; if (this.ListenerMode == EventHubCommunicationListenerMode.Single && string.IsNullOrEmpty(eventHubPartitionId)) { throw new InvalidOperationException("Event hub communication listener in single mode requires a partition id"); } this.m_TraceWriter = TraceWriter; this.m_InitParams = serviceParameters; this.EventHubName = eventHubName; this.EventHubConnectionString = eventHubConnectionString; this.Handler = handler; this.EventHubConsumerGroupName = eventHubConsumerGroupName; this.StateManager = stateManager; this.StateDictionary = stateDictionary; this.ListenerMode = Mode; this.m_TraceWriter.TraceMessage( string.Format( "Event Hub Listener created for {0} on {1} group:{2} mode:{3}", this.EventHubName, this.Namespace, this.EventHubConsumerGroupName, this.ListenerMode.ToString())); }
public void Initialize(ServiceInitializationParameters serviceInitializationParameters) { ServiceEventSource.Current.Message("Initialize"); EndpointResourceDescription serviceEndpoint = serviceInitializationParameters.CodePackageActivationContext.GetEndpoint("ServiceEndpoint"); int port = serviceEndpoint.Port; if (serviceInitializationParameters is StatefulServiceInitializationParameters) { StatefulServiceInitializationParameters statefulInitParams = (StatefulServiceInitializationParameters)serviceInitializationParameters; this.listeningAddress = string.Format( CultureInfo.InvariantCulture, "http://+:{0}/{1}/{2}/{3}", port, statefulInitParams.PartitionId, statefulInitParams.ReplicaId, Guid.NewGuid()); } else if (serviceInitializationParameters is StatelessServiceInitializationParameters) { this.listeningAddress = string.Format( CultureInfo.InvariantCulture, "http://+:{0}/{1}", port, string.IsNullOrWhiteSpace(this.appRoot) ? string.Empty : this.appRoot.TrimEnd('/') + '/'); } else { throw new InvalidOperationException(); } this.publishAddress = this.listeningAddress.Replace("+", FabricRuntime.GetNodeContext().IPAddressOrFQDN); }
public void Initialize(ServiceInitializationParameters serviceInitializationParameters) { ServiceEventSource.Current.Message("Initialize"); EndpointResourceDescription serviceEndpoint = serviceInitializationParameters.CodePackageActivationContext.GetEndpoint("ServiceEndpoint"); int port = serviceEndpoint.Port; if (serviceInitializationParameters is StatefulServiceInitializationParameters) { StatefulServiceInitializationParameters statefulInitParams = (StatefulServiceInitializationParameters) serviceInitializationParameters; this.listeningAddress = string.Format( CultureInfo.InvariantCulture, "http://+:{0}/{1}/{2}/{3}", port, statefulInitParams.PartitionId, statefulInitParams.ReplicaId, Guid.NewGuid()); } else if (serviceInitializationParameters is StatelessServiceInitializationParameters) { this.listeningAddress = string.Format( CultureInfo.InvariantCulture, "http://+:{0}/{1}", port, string.IsNullOrWhiteSpace(this.appRoot) ? string.Empty : this.appRoot.TrimEnd('/') + '/'); } else { throw new InvalidOperationException(); } this.publishAddress = this.listeningAddress.Replace("+", FabricRuntime.GetNodeContext().IPAddressOrFQDN); }
/// <summary> /// Creates a new instance. /// </summary> /// <param name="receiver">(Required) Processes incoming messages.</param> /// <param name="parameters">(Optional) The parameters that were used to init the Reliable Service that uses this listener.</param> /// <param name="serviceBusSendConnectionString">(Optional) A Service Bus connection string that can be used for Sending messages. /// (Returned as Service Endpoint.) When not supplied, an App.config appSettings value with key 'Microsoft.ServiceBus.ConnectionString.Receive' /// is used.</param> /// <param name="serviceBusReceiveConnectionString">(Optional) A Service Bus connection string that can be used for Receiving messages. /// When not supplied, an App.config appSettings value with key 'Microsoft.ServiceBus.ConnectionString.Receive' /// is used.</param> protected ServiceBusCommunicationListener(IServiceBusMessageReceiver receiver , ServiceInitializationParameters parameters , string serviceBusSendConnectionString , string serviceBusReceiveConnectionString) { if (parameters == null) throw new ArgumentNullException(nameof(parameters)); if (receiver == null) throw new ArgumentNullException(nameof(receiver)); if (string.IsNullOrWhiteSpace(serviceBusSendConnectionString)) serviceBusSendConnectionString = CloudConfigurationManager.GetSetting(DefaultSendConnectionStringConfigurationKey); if (string.IsNullOrWhiteSpace(serviceBusReceiveConnectionString)) serviceBusReceiveConnectionString = CloudConfigurationManager.GetSetting(DefaultReceiveConnectionStringConfigurationKey); if (string.IsNullOrWhiteSpace(serviceBusSendConnectionString)) throw new ArgumentOutOfRangeException(nameof(serviceBusSendConnectionString)); if (string.IsNullOrWhiteSpace(serviceBusReceiveConnectionString)) throw new ArgumentOutOfRangeException(nameof(serviceBusReceiveConnectionString)); Parameters = parameters; Receiver = receiver; ServiceBusSendConnectionString = serviceBusSendConnectionString; ServiceBusReceiveConnectionString = serviceBusReceiveConnectionString; _stopProcessingMessageTokenSource = new CancellationTokenSource(); StopProcessingMessageToken = _stopProcessingMessageTokenSource.Token; }
/// <summary> /// Creates the communication listener. /// </summary> /// <returns></returns> private ICommunicationListener CreateCommunicationListener(ServiceInitializationParameters serviceInitializationParameters) { return(new ServiceRemotingListener <QueryModelBuilderService>(serviceInitializationParameters, this)); }
public virtual void Initialize(ServiceInitializationParameters init) { // nothing yet }
/// <summary> /// Creates the communication listener. /// </summary> /// <returns></returns> private ICommunicationListener CreateCommunicationListener(ServiceInitializationParameters serviceInitializationParameters) { return new ServiceRemotingListener<EventBusService>(serviceInitializationParameters, this); }
public virtual void Initialize(ServiceInitializationParameters init) { // nothing yet }
public void Initialize(ServiceInitializationParameters serviceInitializationParameters) { verifyDefs(m_listeningDefinitions); m_serviceInitializationParameters = serviceInitializationParameters; EnsureDelegates(); m_listeningAddress = OnCreateListeningAddress(this); m_publishingAddress = OnCreatePublishingAddress(this); }
public void Initialize(ServiceInitializationParameters serviceInitializationParameters) { m_WebSocketSessionsManager = new MultiTypeWebSocketManager(m_ReliableStateManager, serviceInitializationParameters); m_InitializationParameters = serviceInitializationParameters; }
/// <summary> /// Creates the communication listener. /// </summary> /// <returns></returns> private ICommunicationListener CreateCommunicationListener(ServiceInitializationParameters serviceInitializationParameters) { return new ServiceRemotingListener<QueryModelBuilderService>(serviceInitializationParameters, this); }
public static string GetPublishingAddress(ServiceInitializationParameters parameters, string endpointName) { return GetPublishingAddress(GetListeningAddress(parameters, endpointName)); }
//Do not support singleton ctor. public WcfCommunicationListener(ServiceInitializationParameters initParams, Type interfaceType, Type implementationType) { InterfaceType = interfaceType; ImplementationType = implementationType; Binding = BindingHelper.Service.Wcf.ServiceBinding(); }
public void Initialize(StatelessServiceInitializationParameters initializationParameters) { this.initParams = initializationParameters; this.partitionId = initializationParameters.PartitionId; this.instanceId = initializationParameters.InstanceId; }
public OwinCommunicationListener(IOwinAppBuilder startup, ServiceInitializationParameters serviceInitializationParameters) : this(null, startup, serviceInitializationParameters) { }
public void Initialize(StatefulServiceInitializationParameters initializationParameters) { this.initParams = initializationParameters; this.partitionId = initializationParameters.PartitionId; this.replicaId = initializationParameters.ReplicaId; }
public Startup(ServiceInitializationParameters serviceParameters) { this.serviceParameters = serviceParameters; }
public void Initialize(ServiceInitializationParameters serviceInitializationParameters) { m_WebSocketSessionsManager = new MultiTypeWebSocketManager(m_ReliableStateManager, serviceInitializationParameters); m_InitializationParameters = serviceInitializationParameters; }
public OwinCommunicationListener(IOwinListenerSpec pipelineSpec, ServiceInitializationParameters serviceParameters, string publishingAddressHostName) : this(pipelineSpec, serviceParameters) { this.mHostAddress = publishingAddressHostName; }
public OwinCommunicationListener(IOwinListenerSpec pipelineSpec, ServiceInitializationParameters serviceParameters) { this.pipelineSpec = pipelineSpec; this.serviceParameters = serviceParameters; }
public OwinCommunicationListener(IOwinAppBuilder startup, ServiceInitializationParameters serviceInitializationParameters) : this(null, startup, serviceInitializationParameters) { }