public virtual async Task Start() { _sent = new TestSendObserver(TestTimeout); _consumed = new BusTestConsumeObserver(TestTimeout); _published = new BusTestPublishObserver(TestTimeout); PreCreateBus?.Invoke(this); _bus = CreateBus(); ConnectObservers(_bus); _busHandle = await _bus.StartAsync().ConfigureAwait(false); BusSendEndpoint = await GetSendEndpoint(_bus.Address).ConfigureAwait(false); InputQueueSendEndpoint = await GetSendEndpoint(InputQueueAddress).ConfigureAwait(false); _inputQueueSendObserver = InputQueueSendEndpoint.ConnectSendObserver(_sent); _busConsumeObserver = _bus.ConnectConsumeObserver(_consumed); _busPublishObserver = _bus.ConnectPublishObserver(_published); _busSendObserver = _bus.ConnectSendObserver(_sent); }
/// <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 BusTestScenario(TimeSpan timeout, IBusControl busControl) { _timeout = timeout; _busControl = busControl; Received = new ReceivedMessageList(timeout); _skipped = new ReceivedMessageList(timeout); _published = new PublishedMessageList(timeout); _tokenSource = new CancellationTokenSource(timeout); CancellationToken = _tokenSource.Token; var testSendObserver = new TestSendObserver(timeout); Sent = testSendObserver.Messages; _subjectSendEndpoint = GetSendEndpoint(testSendObserver); var consumeObserver = new TestConsumeObserver(timeout); Received = consumeObserver.Messages; busControl.ConnectConsumeObserver(consumeObserver); _busHandle = _busControl.Start(); }
public Task StartAsync(CancellationToken cancellationToken) { foreach (var observer in observers) { busControl.ConnectConsumeObserver(observer); } return(busControl.StartAsync(cancellationToken)); }
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); }
public bool Start(HostControl hostControl) { _bus.ConnectConsumeObserver(new ConsumeObserver()); _bus.ConnectSendObserver(new SendObserver()); _bus.Start(); _bus.Publish(new TestCommand { JobId = 1 }); return(true); }
public async Task StartAsync(CancellationToken cancellationToken) { _logger.LogInformation("Bus host is being started..."); await _busControl.StartAsync(cancellationToken); if (_config.EnableMessagesAudit) { _busControl.ConnectConsumeObserver(_consumingAuditObserver); _busControl.ConnectPublishObserver(_publishingAuditObserver); _busControl.ConnectSendObserver(_sendingAuditObserver); } _logger.LogInformation("Bus host has been started"); }
public BusTestScenario(TimeSpan timeout, IBusControl busControl) { _timeout = timeout; _busControl = busControl; Received = new ReceivedMessageList(timeout); _skipped = new ReceivedMessageList(timeout); _published = new PublishedMessageList(timeout); _tokenSource = new CancellationTokenSource(timeout); CancellationToken = _tokenSource.Token; var testSendObserver = new TestSendObserver(timeout); Sent = testSendObserver.Messages; _subjectSendEndpoint = GetSendEndpoint(testSendObserver); var consumeObserver = new TestConsumeObserver(timeout); Received = consumeObserver.Messages; busControl.ConnectConsumeObserver(consumeObserver); _busHandle = _busControl.StartAsync(); }
private static void RunMassTransitReceiverWithRabbit() { var container = new Container(conf => { conf.For <ICustomerRepository>().Use <CustomerRepository>(); }); string whatDoIHave = container.WhatDoIHave(); IBusControl rabbitBusControl = Bus.Factory.CreateUsingRabbitMq(rabbit => { rabbit.Host(new Uri("rabbitmq://localhost:5672/accounting"), settings => { settings.Password("guest"); settings.Username("guest"); }); rabbit.ReceiveEndpoint("mycompany.domains.queues", conf => { conf.Consumer <RegisterCustomerConsumer>(container); conf.Consumer <RegisterCustomerConsumer>(container); conf.Consumer <RegisterDomainConsumer>(); }); rabbit.ReceiveEndpoint("mycompany.queues.errors.newcustomers", conf => { conf.Consumer <RegisterCustomerFaultConsumer>(); }); }); // rabbitBusControl.ConnectSendObserver(new SendObjectObserver()); rabbitBusControl.Start(); //rabbitBusControl.ConnectReceiveObserver(new MessageReceiveObserver()); rabbitBusControl.ConnectConsumeObserver(new MessageConsumeObserver()); Console.ReadKey(); rabbitBusControl.Stop(); }
public BusTestScenario(TimeSpan timeout, IBusControl busControl) { _timeout = timeout; _busControl = busControl; Received = new ReceivedMessageList(timeout); _skipped = new ReceivedMessageList(timeout); _published = new PublishedMessageList(timeout); _tokenSource = new CancellationTokenSource(timeout); CancellationToken = _tokenSource.Token; _subjectSendEndpoint = _busControl.GetSendEndpoint(new Uri("loopback://localhost/input_queue")).Result; var testSendObserver = new TestSendObserver(timeout); Sent = testSendObserver.Messages; _subjectSendEndpoint.ConnectSendObserver(testSendObserver); var consumeObserver = new TestConsumeObserver(timeout); Received = consumeObserver.Messages; busControl.ConnectConsumeObserver(consumeObserver); _busHandle = _busControl.Start(); }
/// <summary> /// Observe consumed messages /// </summary> /// <param name="consumeObserver"></param> public void AddLog(IConsumeObserver consumeObserver) { _busControl.ConnectConsumeObserver(consumeObserver); }
public bool Start(HostControl hostControl) { var saga = new OrderStateMachine(); var repo = new InMemorySagaRepository <Order>(); _busObserver = new BusObserver(); _busControl = BusConfigurator.ConfigureBus((cfg, host) => { cfg.AddBusFactorySpecification(new BusObserverSpecification(() => _busObserver)); cfg.ReceiveEndpoint(host, RabbitMqConstants.SagaQueue, e => { cfg.UseNLog(new LogFactory()); cfg.EnablePerformanceCounters(); e.UseRetry(Retry.Interval(5, TimeSpan.FromSeconds(5))); e.UseCircuitBreaker(cb => { cb.TripThreshold = 15; cb.ResetInterval(TimeSpan.FromMinutes(5)); cb.TrackingPeriod = TimeSpan.FromMinutes(1); cb.ActiveThreshold = 10; }); //e.UseRetry(Retry.Except(typeof(ArgumentException), // typeof(NotAcceptedStateMachineException)).Interval(10, TimeSpan.FromSeconds(5))); //TODO: Create a custom filter policy for inner exceptions on Sagas: http://stackoverflow.com/questions/37041293/how-to-use-masstransits-retry-policy-with-sagas e.StateMachineSaga(saga, repo); }); }); var consumeObserver = new LogConsumeObserver(); _busControl.ConnectConsumeObserver(consumeObserver); //TODO: See how to do versioning of messages (best practices) //http://masstransit.readthedocs.io/en/master/overview/versioning.html try { _busHandle = _busControl.Start(); Console.WriteLine("Saga active.. Press enter to exit"); GlobalConfiguration.Configuration.UseMongoStorage("mongodb://localhost:27017", "hangfire-masstransit"); hangfireServer = new BackgroundJobServer(); Console.WriteLine("Hangfire Server started. Press any key to exit..."); WebApp.Start <Startup>("http://localhost:1235"); } catch { hangfireServer.Dispose(); _busControl.Stop(); throw; } return(true); }
// 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 ConnectConsumeObserver(IConsumeObserver observer) { return(_busControl.ConnectConsumeObserver(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(); }
public bool Start(HostControl hostControl) { Log.Information($"Service {Name} v.{Version} starting..."); Log.Information($"Name: {Name}"); Log.Information($"Title: {Title}"); Log.Information($"Description: {Description}"); Log.Information($"Version: {Version}"); var builder = new ContainerBuilder(); builder.Register(c => new GridFsStorage( Environment.ExpandEnvironmentVariables(ConfigurationManager.AppSettings["OsdrConnectionSettings:ConnectionString"]), ConfigurationManager.AppSettings["OsdrConnectionSettings:DatabaseName"] )).As <IBlobStorage>(); builder.RegisterModule <Sds.Cvsp.Compounds.Autofac.PropertiesCalculationModule>(); builder.RegisterConsumers(Assembly.GetExecutingAssembly()); builder.Register(context => { var busControl = Bus.Factory.CreateUsingRabbitMq(cfg => { var mtSettings = ConfigurationManager.AppSettings.MassTransitSettings(); var host = cfg.Host(new Uri(Environment.ExpandEnvironmentVariables(mtSettings.ConnectionString)), h => { }); cfg.RegisterConsumer <ChemicalPropertiesCommandHandler>(host, context, e => { e.PrefetchCount = mtSettings.PrefetchCount; }); cfg.UseConcurrencyLimit(mtSettings.ConcurrencyLimit); }); return(busControl); }) .SingleInstance() .As <IBusControl>() .As <IBus>(); var container = builder.Build(); ServiceLocator.SetLocatorProvider(() => new AutofacServiceLocator(container)); BusControl = container.Resolve <IBusControl>(); BusControl.ConnectPublishObserver(new PublishObserver()); BusControl.ConnectConsumeObserver(new ConsumeObserver()); BusControl.Start(); if (int.TryParse(ConfigurationManager.AppSettings["HeartBeat:TcpPort"], out int port)) { Heartbeat.TcpPortListener.Start(port); } Log.Information($"Service {Name} v.{Version} started"); return(true); }