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