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);
}
private void ConnectObservers()
{
_publishObserver = new LoggingPublishObserver(LogObserver);
_sendObserver = new LoggingSendObserver(LogObserver);
_azureBus.ConnectPublishObserver(_publishObserver);
_azureBus.ConnectSendObserver(_sendObserver);
}
/// <summary>
/// Connects the given ticket to all requests sent through the bus.
/// </summary>
/// <param name="busControl">The bus control.</param>
/// <param name="ticket">The ticket.</param>
public static void ConnectTicket(this IBusControl busControl, string ticket)
{
var propagator = new EncryptedTicketPropagator(ticket);
busControl.ConnectSendObserver(propagator);
busControl.ConnectPublishObserver(propagator);
}
/// <summary>
/// Connects the thread principal to all requests sent through the bus.
/// </summary>
/// <param name="busControl">The bus control.</param>
public static void ConnectThreadPrincipal(this IBusControl busControl)
{
var propagator = new PrincipalTicketPropagator();
busControl.ConnectSendObserver(propagator);
busControl.ConnectPublishObserver(propagator);
}
public Task StartAsync(CancellationToken cancellationToken)
{
_logger.LogInformation("starting bus");
_busControl.ConnectReceiveObserver(new LoggingReceiveObserver(_messageReceiveLogger));
_busControl.ConnectPublishObserver(new LoggingPublishObserver(_publishingObserverLogger));
return(_busControl.StartAsync(cancellationToken));
}
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");
}
/// <summary>
/// Observing published messages
/// </summary>
/// <param name="publishObserver"></param>
public void AddLog(IPublishObserver publishObserver)
{
_busControl.ConnectPublishObserver(publishObserver);
}
// 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 ConnectPublishObserver(IPublishObserver observer)
{
return(_busControl.ConnectPublishObserver(observer));
}
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);
}
