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