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