public static IBusControl AddLogContext(this IBusControl busControl) { var observer = new LogContextObserver(); busControl.ConnectReceiveObserver(observer); return(busControl); }
/// <summary> /// Configures and starts the bus. /// </summary> /// <returns></returns> private async static Task ConfigureAndStartBusAsync() { if (_transportComponent == null) { throw new Exception("An active transport component is required for Rock to run correctly"); } _bus = _transportComponent.GetBusControl(RockConsumer.ConfigureRockConsumers); _bus.ConnectConsumeObserver(_statObserver); _bus.ConnectReceiveObserver(_receiveFaultObserver); // Allow the bus to try to connect for some seconds at most var cancelToken = new CancellationTokenSource(); var task = _bus.StartAsync(cancelToken.Token); const int delaySeconds = 45; var delay = Task.Delay(TimeSpan.FromSeconds(delaySeconds)); if (await Task.WhenAny(task, delay) == task) { // Task completed within timeout. // Consider that the task may have faulted or been canceled. // We re-await the task so that any exceptions/cancellation is rethrown. // https://stackoverflow.com/a/11191070/13215483 await task; } else { // The bus did not connect after some seconds cancelToken.Cancel(); throw new Exception($"The bus failed to connect using {_transportComponent.GetType().Name} within {delaySeconds} seconds"); } _isBusStarted = true; }
public Task StartAsync(CancellationToken cancellationToken) { _logger.LogInformation("starting bus"); _busControl.ConnectReceiveObserver(new LoggingReceiveObserver(_messageReceiveLogger)); _busControl.ConnectPublishObserver(new LoggingPublishObserver(_publishingObserverLogger)); return(_busControl.StartAsync(cancellationToken)); }
public static void ConnectMetrics(this IBusControl busControl, Action <PrometheusMetricsOptions> configureMetrics = null, string serviceName = "") { ConfigureMetrics(serviceName, configureMetrics); busControl.ConnectReceiveObserver(new PrometheusMetricsObservers()); }
public static void ConnectMetrics(this IBusControl busControl, string serviceName = "") { PrometheusMetrics.TryConfigure( string.IsNullOrWhiteSpace(serviceName) ? Path.GetFileNameWithoutExtension(Process.GetCurrentProcess().MainModule.FileName) : serviceName); busControl.ConnectReceiveObserver(new PrometheusMetricsObservers(serviceName)); }
public async Task StartAsync(CancellationToken cancellationToken) { //_actorSystem = _serviceProvider.GetService.; var observer = new ReceiveObserver(_actorSystem); _busControl.ConnectReceiveObserver(observer); await _busControl.StartAsync(cancellationToken); //HostActorRef.ActorRef.Tell(Construct()); //HostActorRef.ActorIsReady = true; //HostActorRef.ProcessCached(); }
private void Initialize() { _busControl = _workMode == WorkMode.RabbitMq ? InitializeUsingRabbit() : InitializeUsingInMemory(); var receiveObserver = new ReceiveObserver(); var consumeObserver = new ConsumeObserver(); _receiveHandle = _busControl.ConnectReceiveObserver(receiveObserver); _consumeHandle = _busControl.ConnectConsumeObserver(consumeObserver); }
//private ModelContext _modelContext; //private BusHandle _busHandle; public bool Start(HostControl hostControl) { _logger.Info("Creating bus..."); ConfigureContainer(); var observer = _kernel.Get <ScopeObserver>(); _busControl.ConnectReceiveObserver(observer); _logger.Info("Starting bus..."); TaskUtil.Await(() => _busControl.StartAsync()); ConfigureDb(); return(true); }
/// <summary> /// Observe received messages immediately after they are delivered by the transport /// </summary> /// <param name="receiveObserver"></param> public void AddLog(IReceiveObserver receiveObserver) { _busControl.ConnectReceiveObserver(receiveObserver); }
// Override and inject if you need a more custom startup configuration public virtual Task StartAsync(Type[] listenerNoQueueTypes = null) { if (_options.UseInMemoryBus) { throw new NotSupportedException("InMemory bus is not currently supported"); // _busControl = Bus.Factory.CreateUsingInMemory(sbc => // { // if (_options.BusObserver != null) // { // sbc.AddBusFactorySpecification(_options.BusObserver); // } // sbc.UseRetry(Retry.Immediate(5)); // foreach (var handler in handlers) // { // sbc.ReceiveEndpoint(handler.MessageType.Name, c => // { // c.LoadFrom(_services); // }); // } // }); } else { _busControl = Bus.Factory.CreateUsingRabbitMq(sbc => { var host = sbc.Host(new Uri(_options.RabbitMQUri), h => { h.Username(_options.RabbitMQUsername); h.Password(_options.RabbitMQPassword); }); if (_options.BusObserver != null) { sbc.AddBusFactorySpecification(_options.BusObserver); } if (_options.RetryPolicy != null) { sbc.UseRetry(_options.RetryPolicy); } var allHandlers = _manager.GetAllHandlers().ToList(); foreach (var msgTypes in allHandlers .Where(h => h.GenericType == typeof(IDistributedEventListener <>)) .GroupBy(h => h.ImplementationType)) { sbc.ReceiveEndpoint(host, c => { foreach (var handler in msgTypes) { ConsumerConfiguratorCache.Configure(handler, c, _services); } }); } foreach (var msgTypes in allHandlers .Where(h => h.GenericType == typeof(IEventListener <>) || h.GenericType == typeof(IFaultHandler <>)) .GroupBy(h => h.ImplementationType)) { sbc.ReceiveEndpoint(host, msgTypes.Key.Name, c => { foreach (var handler in msgTypes) { ConsumerConfiguratorCache.Configure(handler, c, _services); } }); } foreach (var msgTypes in allHandlers .Where(h => h.GenericType == typeof(ICommandHandler <,>) || h.GenericType == typeof(ICommandHandler <>)) .GroupBy(h => h.MessageType)) { sbc.ReceiveEndpoint(host, msgTypes.Key.Name, c => { foreach (var handler in msgTypes) { ConsumerConfiguratorCache.Configure(handler, c, _services); } }); } }); } if (_options.ReceiveObserver != null) { _busControl.ConnectReceiveObserver(_options.ReceiveObserver); } if (_options.SendObserver != null) { _busControl.ConnectSendObserver(_options.SendObserver); } if (_options.ConsumeObserver != null) { _busControl.ConnectConsumeObserver(_options.ConsumeObserver); } if (_options.PublishObserver != null) { _busControl.ConnectPublishObserver(_options.PublishObserver); } return(_busControl.StartAsync()); }
public ConnectHandle ConnectReceiveObserver(IReceiveObserver observer) { return(_busControl.ConnectReceiveObserver(observer)); }
private static void RunTransitReceiver() { // IoC - Register Repository var container = new Container(conf => { conf.For <ICustomerRepository>().Use <CustomerRepository>(); }); // Create service bus controller // This will listen for commands on the queue called 'mycompany.domains.queues' IBusControl control = Bus.Factory.CreateUsingRabbitMq( rbt => { IRabbitMqHost host = rbt.Host( ConnectionProperties.HostUri, settings => { settings.Username(ConnectionProperties.UserName); settings.Password(ConnectionProperties.Password); } ); // Register the consumer service - 'RegisterCustomerService' with the Service Bus rbt.ReceiveEndpoint( host, ConnectionProperties.EndPoint, cfgr => { cfgr.Consumer <RegisterCustomerService>(container); // Inject repository cfgr.Consumer <RegisterDomainService>(); /******* THE FOLLOWING RETRY POLICIES ARE BASED ON THE OCCURANCE OF EXCEPTIONS ******/ //cfgr.UseRetry(Retry.Immediate(5)); // Retry 5 times in the event of any exception, before sending to 'error' queue //cfgr.UseRetry(Retry.Except(typeof(ArgumentException)).Immediate(5)); // Retry 5 times Except in the event of an 'ArgumentException' //cfgr.UseRetry(Retry.Selected(typeof(ArgumentException)).Immediate(5)); // Retry 5 times Only in the event of an 'ArgumentException' //cfgr.UseRetry(Retry.All().Immediate(5)); // Retry 5 times in the event of any exception /* * cfgr.UseRetry(Retry.Filter<Exception>( // Retry 5 times in the event of any exception, and set the error message * e => e.Message.IndexOf("Set the error message here") > -1 * ).Immediate(5)); */ /******* INTERVAL RETRY POLICIES ******/ //cfgr.UseRetry(Retry.Exponential(5, TimeSpan.FromSeconds(2), TimeSpan.FromSeconds(30), TimeSpan.FromSeconds(5))); //cfgr.UseRetry(Retry.Incremental(5, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(3))); //cfgr.UseRetry(Retry.Interval(5, TimeSpan.FromSeconds(5))); //cfgr.UseRetry(Retry.Intervals(TimeSpan.FromSeconds(3), TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(4))); } ); } ); // Start listening control.Start(); // Register a message receiver observer control.ConnectReceiveObserver(new MessageReceiveObserver()); // Register a message consumer observer control.ConnectConsumeObserver(new MessageConsumeObserver()); // Wait for commands Console.ReadKey(); // Stop Listening control.Stop(); }