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