public static IHostConfiguration EnableLiveMetricsStream(this IHostConfiguration hostConfiguration, TelemetryConfiguration telemetryConfiguration)
{
QuickPulseTelemetryProcessor processor = null;
telemetryConfiguration.TelemetryProcessorChainBuilder
.Use(next =>
{
processor = new QuickPulseTelemetryProcessor(next);
return(processor);
})
.Build();
var quickPulse = new QuickPulseTelemetryModule();
quickPulse.Initialize(telemetryConfiguration);
quickPulse.RegisterTelemetryProcessor(processor);
foreach (var telemetryProcessor in telemetryConfiguration.TelemetryProcessors)
{
if (telemetryProcessor is ITelemetryModule telemetryModule)
{
telemetryModule.Initialize(telemetryConfiguration);
}
}
return(hostConfiguration);
}
public ConsumerContextSupervisor(IClientContextSupervisor clientContextSupervisor, ReceiveSettings receiveSettings,
IHostConfiguration hostConfiguration, IHeadersDeserializer headersDeserializer, Func <ConsumerBuilder <TKey, TValue> > consumerBuilderFactory)
: base(new ConsumerContextFactory <TKey, TValue>(clientContextSupervisor, receiveSettings, hostConfiguration, headersDeserializer,
consumerBuilderFactory))
{
clientContextSupervisor.AddConsumeAgent(this);
}
public PipelineInformation(Type processorInterfaceType, IEventSubscription subscription, IProcessingSettings processingSettings, IHostConfiguration hostConfiguration)
{
ProcessorInterfaceType = processorInterfaceType;
Subscription = subscription;
ProcessingSettings = processingSettings;
HostConfiguration = hostConfiguration;
}
public static void SubscribeToSystemEvents(IHostConfiguration host)
{
if (host == null)
{
throw new ArgumentNullException(nameof(host));
}
}
public KafkaTransportContext(ISendPipe sendPipe, IHostConfiguration hostConfiguration, KafkaTopicAddress topicAddress)
: base(hostConfiguration)
{
SendPipe = sendPipe;
HostAddress = hostConfiguration.HostAddress;
TopicAddress = topicAddress;
}
protected BaseReceiveEndpointContext(IHostConfiguration hostConfiguration, IReceiveEndpointConfiguration configuration)
{
_hostConfiguration = hostConfiguration;
InputAddress = configuration.InputAddress;
HostAddress = configuration.HostAddress;
PublishFaults = configuration.PublishFaults;
PrefetchCount = configuration.PrefetchCount;
ConcurrentMessageLimit = configuration.ConcurrentMessageLimit;
_publishTopology = configuration.Topology.Publish;
ConsumePipeSpecification = configuration.Consume.Specification;
SendObservers = new SendObservable();
PublishObservers = new PublishObservable();
_endpointObservers = configuration.EndpointObservers;
_receiveObservers = configuration.ReceiveObservers;
_transportObservers = configuration.TransportObservers;
Dependencies = configuration.Dependencies;
_sendPipe = new Lazy <ISendPipe>(() => configuration.Send.CreatePipe());
_publishPipe = new Lazy <IPublishPipe>(() => configuration.Publish.CreatePipe());
_receivePipe = new Lazy <IReceivePipe>(configuration.CreateReceivePipe);
_serializer = new Lazy <IMessageSerializer>(() => configuration.Serialization.Serializer);
Reset();
hostConfiguration.ConnectReceiveEndpointContext(this);
}
public EventHubProcessorContext(IHostConfiguration hostConfiguration, ReceiveSettings receiveSettings, BlobContainerClient blobContainerClient,
EventProcessorClient client, Func <PartitionInitializingEventArgs, Task> partitionInitializingHandler,
Func <PartitionClosingEventArgs, Task> partitionClosingHandler, CancellationToken cancellationToken)
: base(cancellationToken)
{
_blobContainerClient = blobContainerClient;
_client = client;
var lockContext = new ProcessorLockContext(hostConfiguration, receiveSettings);
_client.PartitionInitializingAsync += async args =>
{
await lockContext.OnPartitionInitializing(args).ConfigureAwait(false);
if (partitionInitializingHandler != null)
{
await partitionInitializingHandler(args).ConfigureAwait(false);
}
};
_client.PartitionClosingAsync += async args =>
{
if (partitionClosingHandler != null)
{
await partitionClosingHandler(args).ConfigureAwait(false);
}
await lockContext.OnPartitionClosing(args).ConfigureAwait(false);
};
_client.ProcessErrorAsync += OnError;
_client.ProcessEventAsync += OnMessage;
ReceiveSettings = receiveSettings;
_lockContext = lockContext;
}
EventStoreHolder(IHostConfiguration configuration, IBinarySerializer serializer)
{
var ipEndpoint = new IPEndPoint(configuration.EventStoreIp, configuration.EventStorePort);
_connection = EventStoreConnection.Create(ipEndpoint);
_serializer = serializer;
}
public static void RegisterConnector <TConnector>(
this IHostConfiguration hostConfiguration,
IConnectorConfiguration connectorConfiguration = null,
string registrationName = null) where TConnector : IConnector
{
hostConfiguration.RegisterComponent(new SingleConnectorComponent <TConnector>(connectorConfiguration, registrationName));
}
public HostService(
IHostConfiguration config,
IScheduler scheduler)
{
_scheduler = scheduler;
_url = config.Url;
}
public ReceiveEndpointDispatcherFactory(IBusRegistrationContext registration, IBusInstance busInstance)
{
_hostConfiguration = busInstance.HostConfiguration;
_registration = registration;
_dispatchers = new ConcurrentDictionary <string, Lazy <IReceiveEndpointDispatcher> >();
}
public BrokeredMessageReceiverServiceBusEndpointConfiguration(IHostConfiguration hostConfiguration, IEndpointConfiguration configuration,
Uri hostAddress, Uri inputAddress)
: base(hostConfiguration, configuration)
{
HostAddress = hostAddress;
InputAddress = inputAddress;
}
public static IHostConfiguration UseScheduling(this IHostConfiguration configuration)
{
var scheduler = new SchedulingPlugin(configuration);
configuration.AddPlugin(scheduler);
return(configuration);
}
protected BaseHost(IHostConfiguration hostConfiguration, IHostTopology hostTopology)
{
_hostConfiguration = hostConfiguration;
_hostTopology = hostTopology;
_receiveEndpoints = new ReceiveEndpointCollection();
}
protected BaseReceiveEndpointContext(IHostConfiguration hostConfiguration, IReceiveEndpointConfiguration configuration)
{
InputAddress = configuration.InputAddress;
HostAddress = configuration.HostAddress;
_publishTopology = configuration.Topology.Publish;
ConsumePipeSpecification = configuration.Consume.Specification;
_logContext = LogContext.Current.CreateLogContext(LogCategoryName.Transport.Receive);
SendObservers = new SendObservable();
PublishObservers = new PublishObservable();
_endpointObservers = configuration.EndpointObservers;
_receiveObservers = configuration.ReceiveObservers;
_transportObservers = configuration.TransportObservers;
Dependencies = configuration.Dependencies;
_sendPipe = new Lazy <ISendPipe>(() => configuration.Send.CreatePipe());
_publishPipe = new Lazy <IPublishPipe>(() => configuration.Publish.CreatePipe());
_receivePipe = new Lazy <IReceivePipe>(configuration.CreateReceivePipe);
_serializer = new Lazy <IMessageSerializer>(() => configuration.Serialization.Serializer);
_sendEndpointProvider = new Lazy <ISendEndpointProvider>(CreateSendEndpointProvider);
_publishEndpointProvider = new Lazy <IPublishEndpointProvider>(CreatePublishEndpointProvider);
_sendTransportProvider = new Lazy <ISendTransportProvider>(CreateSendTransportProvider);
_publishTransportProvider = new Lazy <IPublishTransportProvider>(CreatePublishTransportProvider);
hostConfiguration.ConnectReceiveContextContext(this);
}
public static IHostConfiguration UseTcpAliveListener(this IHostConfiguration configuration, int port)
{
var listener = new TcpAliveListenerPlugin(configuration, port);
configuration.AddPlugin(listener);
return(configuration);
}
protected BaseHost(IHostConfiguration hostConfiguration)
{
_hostConfiguration = hostConfiguration;
_receiveEndpoints = new ReceiveEndpointCollection();
Add(_receiveEndpoints);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="topShelfConfiguration">Topshelf Configuration</param>
/// <param name="hostConfiguration">Host Configuration</param>
/// <param name="owinStartup">Owin startup class</param>
public OwinHostTopShelfService(ITopShelfConfiguration topShelfConfiguration, IHostConfiguration hostConfiguration, IOwinStartup owinStartup)
{
TopShelfConfiguration = topShelfConfiguration;
HostConfiguration = hostConfiguration;
_logger = Log.Logger.ForContext <OwinHostTopShelfService>();
_owinStartup = owinStartup;
}
public ReceiveTransport(IHostConfiguration hostConfiguration, ReceiveEndpointContext context, Func <ISupervisor <TContext> > supervisorFactory,
IPipe <TContext> transportPipe)
{
_hostConfiguration = hostConfiguration;
_context = context;
_supervisorFactory = supervisorFactory;
_transportPipe = transportPipe;
}
public ConsumerContextFactory(IClientContextSupervisor clientContextSupervisor, ReceiveSettings receiveSettings,
IHostConfiguration hostConfiguration, IHeadersDeserializer headersDeserializer, Func <ConsumerBuilder <TKey, TValue> > consumerBuilderFactory)
{
_clientContextSupervisor = clientContextSupervisor;
_receiveSettings = receiveSettings;
_headersDeserializer = headersDeserializer;
_hostConfiguration = hostConfiguration;
_consumerBuilderFactory = consumerBuilderFactory;
}
public ProducerContextFactory(IClientContextSupervisor clientContextSupervisor, IHostConfiguration hostConfiguration,
IHeadersSerializer headersSerializer,
Func <ProducerBuilder <TKey, TValue> > producerBuilderFactory)
{
_clientContextSupervisor = clientContextSupervisor;
_hostConfiguration = hostConfiguration;
_headersSerializer = headersSerializer;
_producerBuilderFactory = producerBuilderFactory;
}
public TinyIoCBootstrapper(IHostConfiguration hostConfiguration, ILogger logger)
{
_container = TinyIoCContainer.Current;
_container.Register<IHostConfiguration>(hostConfiguration);
_container.Register<ILogger>(logger);
_container.AutoRegister(AutoRegisterAssemblies(), DuplicateImplementationActions.RegisterMultiple, ExcludedTypes);
RegisterNegotiator();
_container.Register<IStyxEngine>(new SecureSocketStyxEngine(Logger, Engine, HostConfiguration));
}
public KafkaTransportContext(ISendPipe sendPipe, IHostConfiguration hostConfiguration, KafkaTopicAddress topicAddress,
IProducerContextSupervisor <TKey, TValue> supervisor)
: base(hostConfiguration)
{
_hostConfiguration = hostConfiguration;
_supervisor = supervisor;
SendPipe = sendPipe;
TopicAddress = topicAddress;
}
public KafkaProducerContext(IProducer <TKey, TValue> producer, IHostConfiguration hostConfiguration, ISendPipeConfiguration sendConfiguration,
SendObservable sendObservers, IHeadersSerializer headersSerializer)
{
_producer = producer;
_hostConfiguration = hostConfiguration;
_sendPipe = sendConfiguration.CreatePipe();
SendObservers = sendObservers;
HeadersSerializer = headersSerializer;
}
public DefaultHandshakeNegotiator(IHostConfiguration hostConfiguration, IProtocolSelector protocolSelector, IQueryParametersBuilder queryParametersBuilder, IRouteParametersBuilder routeParametersBuilder, IRouteResolver routeResolver, ISubProtocolNegotiator subProtocolNegotiator)
{
_hostConfiguration = hostConfiguration;
_protocolSelector = protocolSelector;
_queryParametersBuilder = queryParametersBuilder;
_routeParametersBuilder = routeParametersBuilder;
_routeResolver = routeResolver;
_subProtocolNegotiator = subProtocolNegotiator;
}
public TransportBusInstance(IBusControl busControl, IHost <TEndpointConfigurator> host, IHostConfiguration hostConfiguration, IBusRegistrationContext
busRegistrationContext)
{
_host = host;
_busRegistrationContext = busRegistrationContext;
BusControl = busControl;
HostConfiguration = hostConfiguration;
}
public ProcessorContextSupervisor(IConnectionContextSupervisor supervisor, IHostConfiguration hostConfiguration, ReceiveSettings receiveSettings,
Func <IStorageSettings, BlobContainerClient> blobContainerClientFactory,
Func <IHostSettings, BlobContainerClient, EventProcessorClient> clientFactory, Func <PartitionClosingEventArgs, Task> partitionClosingHandler,
Func <PartitionInitializingEventArgs, Task> partitionInitializingHandler)
: base(new ProcessorContextFactory(supervisor, hostConfiguration, receiveSettings, blobContainerClientFactory, clientFactory,
partitionClosingHandler,
partitionInitializingHandler))
{
supervisor.AddConsumeAgent(this);
}
protected RedisChannelReceiver(IConnectionMultiplexer connectionMultiplexer, string queueName, IProcessingSettings settings, RedisConfiguration redisConfiguration, IHostConfiguration hostConfiguration, IMessageProcessor processor)
{
ConnectionMultiplexer = connectionMultiplexer;
_settings = settings;
_redisConfiguration = redisConfiguration;
_hostConfiguration = hostConfiguration;
_processor = processor;
_queueName = queueName;
_maxConcurrent = new SemaphoreQueue(settings.MaxConcurrentCalls);
}
public ProvisionalContractReaderService(IKernel kernel, IHostConfiguration hostConfig)
{
_log = LogManager.GetLogger(typeof(ProvisionalContractDataService));
_kernel = kernel;
_dshs = _kernel.Get <IDataServiceHostSettings>();
_dataService = _kernel.Get <IProvisionalContractDataService>();
_path = hostConfig.AppSetting("DropLocation");
_filter = hostConfig.AppSetting("Filter");
}
/// <summary>
/// Registers all <see cref="IProcessCommand{T,TSettings}"/> and <see cref="IProcessEvent{TTopic,TTopicSubscription,TSettings}"/> found in the executing assembly
/// </summary>
public static IHostConfiguration RegisterProcessors(this IHostConfiguration configuration, Container container, Assembly assembly)
{
container.Register(typeof(IProcessCommand <,>), new List <Assembly> {
assembly
}, Lifestyle.Scoped);
container.Register(typeof(IProcessEvent <, ,>), new List <Assembly> {
assembly
}, Lifestyle.Scoped);
return(configuration);
}
public bool TryGetHost(Uri address, out IHostConfiguration host)
{
if (TryGetHost(address, out TConfiguration hostConfiguration))
{
host = hostConfiguration;
return(true);
}
host = default;
return(false);
}
public EventHubTransportContext(IEventHubHostConfiguration hostConfiguration, ISendPipe sendPipe,
IHostConfiguration configuration, Uri endpointAddress, IMessageSerializer messageSerializer)
: base(configuration)
{
_configuration = configuration;
SendPipe = sendPipe;
EndpointAddress = new EventHubEndpointAddress(HostAddress, endpointAddress);
_producerContextSupervisor =
new Recycle <IProducerContextSupervisor>(() =>
new ProducerContextSupervisor(hostConfiguration.ConnectionContextSupervisor, EndpointAddress.EventHubName, messageSerializer));
}
public ServiceBusQueueChannelReceiver(IProcessingSettings settings, IServiceBusConfiguration configuration, IHostConfiguration hostConfiguration, IMessageProcessor processor)
{
_configuration = configuration;
_hostConfiguration = hostConfiguration;
_processor = processor;
Settings = settings;
_log = hostConfiguration.Log;
//new client factory per ServiceBusQueueChannelReceiver means a separate communication channel per reader instead of a shared
_clientFactory = new ClientFactory(configuration.ConnectionString);
_managementClient = new ManagementClient(configuration.ConnectionString);
}
public StyxHost(Uri location, IHostConfiguration hostConfiguration = null, ILogger logger = null, IBootstrapper bootstrapper = null)
{
if (location == null)
throw new ArgumentNullException("location");
hostConfiguration = hostConfiguration ?? new HostConfiguration();
hostConfiguration.Port = location.Port;
hostConfiguration.Scheme = location.Scheme;
logger = logger ?? new DebuggerLogger();
bootstrapper = bootstrapper ?? new TinyIoCBootstrapper(hostConfiguration, logger);
_hostConfiguration = bootstrapper.HostConfiguration;
_logger = bootstrapper.Logger;
_engine = bootstrapper.Engine;
_routeRegister = bootstrapper.RouteRegister;
_listenerSocket = bootstrapper.SocketListener;
}
public SecureSocketStyxEngine(ILogger logger, IStyxEngine styxEngine, IHostConfiguration hostConfiguration)
{
_logger = logger;
_styxEngine = styxEngine;
_hostConfiguration = hostConfiguration;
}
public SocketListener(IHostConfiguration hostConfiguration)
: this(new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP))
{
_localEndPoint = new IPEndPoint(hostConfiguration.ClientAddress, hostConfiguration.Port);
}
public ConnectionFactoryInfo(ConnectionFactory connectionFactory, IHostConfiguration hostConfiguration)
{
ConnectionFactory = connectionFactory;
HostConfiguration = hostConfiguration;
}
public HostPasswordProvider(IHostConfiguration configuration)
{
_configuration = new HostPasswordConfiguration();
_configuration.LoadFromFile(configuration.HostPasswordFilePath);
}
public QuotaFactory(NotNullable<IHostConfiguration> hostConfiguration)
{
_hostConfiguration = hostConfiguration.Value;
}
