public static IDisposable StartTimer(this IBusBase messageBus, string topic, int delayMs = 5000, int intervalMs = 10000)
{
Assert.ArgumentNotNull(messageBus, nameof(messageBus));
var module = GetModule(messageBus);
return(module.AddNewTimer(topic, delayMs, intervalMs));
}
/// <summary>
/// Schedule the provided event source with the system. It will be polled periodically for new events.
/// </summary>
/// <param name="messageBus"></param>
/// <param name="source"></param>
/// <returns></returns>
public static IDisposable RunEventSource(this IBusBase messageBus, IEventSource source)
{
Assert.ArgumentNotNull(messageBus, nameof(messageBus));
var module = GetModuleOrThrow(messageBus);
return(module.RunEventSource(source));
}
/// <summary>
/// Get a direct reference to the OutboxMonitor, which holds the outboxes and periodically flushes them
/// </summary>
/// <param name="messageBus"></param>
/// <returns></returns>
public static IOutboxMonitor GetOutboxMonitor(this IBusBase messageBus)
{
Assert.ArgumentNotNull(messageBus, nameof(messageBus));
var module = GetOutboxModuleOrThrow(messageBus);
return(module.Monitor);
}
public OutboxModule(IBusBase messageBus, int pollDelayMs)
{
Assert.ArgumentNotNull(messageBus, nameof(messageBus));
Assert.IsInRange(pollDelayMs, nameof(pollDelayMs), 1000, int.MaxValue);
_messageBus = messageBus;
Monitor = new OutboxMonitor(messageBus.Logger, messageBus.WorkerPool, pollDelayMs);
}
/// <summary>
/// Add the outbox to be monitored by the OutboxModule, if the module has been initialized.
/// Otherwise do nothing
/// </summary>
/// <param name="messageBus"></param>
/// <param name="outbox"></param>
/// <returns></returns>
public static IDisposable TryAddOutboxToBeMonitored(this IBusBase messageBus, IOutboxSender outbox)
{
Assert.ArgumentNotNull(messageBus, nameof(messageBus));
Assert.ArgumentNotNull(outbox, nameof(outbox));
var module = messageBus.Modules.Get <OutboxModule>();
return(module?.AddOutboxToBeMonitored(outbox) ?? new DoNothingDisposable());
}
/// <summary>
/// Add the outbox to be monitored by the OutboxModule
/// </summary>
/// <param name="messageBus"></param>
/// <param name="outbox"></param>
/// <returns></returns>
public static IDisposable AddOutboxToBeMonitored(this IBusBase messageBus, IOutboxSender outbox)
{
Assert.ArgumentNotNull(messageBus, nameof(messageBus));
Assert.ArgumentNotNull(outbox, nameof(outbox));
var module = GetOutboxModuleOrThrow(messageBus);
return(module.AddOutboxToBeMonitored(outbox));
}
/// <summary>
/// Add the outbox to be monitored by the OutboxModule
/// </summary>
/// <typeparam name="TMessage"></typeparam>
/// <param name="messageBus"></param>
/// <param name="outbox"></param>
/// <param name="send"></param>
/// <returns></returns>
public static IDisposable AddOutboxToBeMonitored <TMessage>(this IBusBase messageBus, IOutbox <TMessage> outbox, Action <Envelope <TMessage> > send)
{
Assert.ArgumentNotNull(messageBus, nameof(messageBus));
Assert.ArgumentNotNull(outbox, nameof(outbox));
Assert.ArgumentNotNull(send, nameof(send));
var module = GetOutboxModuleOrThrow(messageBus);
return(module.AddOutboxToBeMonitored(outbox, send));
}
private static RabbitModule GetRabbitModuleOrThrow(IBusBase messageBus)
{
var module = messageBus.Modules.Get <RabbitModule>();
if (module == null)
{
throw new Exception($"RabbitMQ is not initialized. Call .{nameof(InitializeRabbitMq)}() first.");
}
return(module);
}
private static TestingModule GetTestingModule(IBusBase messageBus)
{
var module = messageBus.Modules.Get <TestingModule>();
if (module == null)
{
throw new Exception($"Testing module is not initialized. Call .{nameof(InitializeTesting)}() first");
}
return(module);
}
public static IDisposable PullRabbitMqToLocal <TPayload>(this IBusBase messageBus, Action <IRabbitConsumerBuilderRemoteTopic <TPayload> > setup)
where TPayload : class
{
var module = GetRabbitModuleOrThrow(messageBus);
var builder = module.CreateSubscriberBuilder <TPayload>();
setup(builder);
var receiver = builder.Build();
return(module.ManageConsumer(receiver));
}
public OutboxSubscription(IBusBase messageBus, ISubscription <TPayload> inner, IOutbox <TPayload> outbox)
{
Assert.ArgumentNotNull(messageBus, nameof(messageBus));
Assert.ArgumentNotNull(inner, nameof(inner));
Assert.ArgumentNotNull(outbox, nameof(outbox));
_inner = inner;
var sender = new OutboxSender <TPayload>(messageBus.Logger, outbox, PublishInternal);
var outboxToken = messageBus.TryAddOutboxToBeMonitored(sender);
_outbox = new SendingOutbox <TPayload>(outbox, sender, outboxToken);
}
public ForwardToRabbitSubscription(IBusBase messageBus, IBus rabbitBus, string queueName, IOutbox <TPayload> outbox)
{
Assert.ArgumentNotNull(messageBus, nameof(messageBus));
Assert.ArgumentNotNull(rabbitBus, nameof(rabbitBus));
Assert.ArgumentNotNull(outbox, nameof(outbox));
_rabbitBus = rabbitBus;
_queueName = queueName;
var sender = new OutboxSender <TPayload>(messageBus.Logger, outbox, PublishInternal);
var outboxToken = messageBus.AddOutboxToBeMonitored(sender);
_outbox = new SendingOutbox <TPayload>(outbox, sender, outboxToken);
}
private static EventSourceModule GetModuleOrThrow(IBusBase messageBus)
{
return(messageBus.Modules.Get <EventSourceModule>() ?? throw new Exception($"EventSource module is not enabled. Call .{nameof(InitializeEventSources)}() first"));
}
private static OutboxModule GetOutboxModuleOrThrow(IBusBase messageBus)
{
var module = messageBus.Modules.Get <OutboxModule>();
return(module ?? throw new Exception($"Outbox module has not been initialized. Call .{nameof(InitializeOutboxModule)} first."));
}
/// <summary>
/// Schedule the given action to run as an event source. The system will invoke it periodically.
/// </summary>
/// <param name="messageBus"></param>
/// <param name="action"></param>
/// <returns></returns>
public static IDisposable RunEventSource(this IBusBase messageBus, Action <IEventSourceContext> action)
{
return(RunEventSource(messageBus, new DelegateEventSource(action)));
}
public static PublishExpectation <TPayload> ExpectPublish <TPayload>(this IBusBase messageBus, string topic, Func <TPayload, bool> filter = null, string description = null)
{
return(GetTestingModule(messageBus).ExpectPublish(topic, filter, description));
}
public static ScatterExpectation <TRequest, TResponse> ExpectScatter <TRequest, TResponse>(this IBusBase messageBus, string topic, Func <TRequest, bool> filter = null, string description = null)
{
return(GetTestingModule(messageBus).ExpectScatter <TRequest, TResponse>(topic, filter, description));
}
private static MessageTimerModule GetModule(IBusBase messageBus)
{
return(messageBus.Modules.Get <MessageTimerModule>() ?? throw new Exception($"Message Timer module is not initialized. Call .{nameof(InitializeMessageTimer)}() first"));
}
/// <summary>
/// Initialize the OutboxModule, for automatic monitoring of outboxes in the system
/// This method must be called before any other outbox-related methods
/// </summary>
/// <param name="messageBus"></param>
/// <param name="pollDelayMs"></param>
/// <returns></returns>
public static IDisposable InitializeOutboxModule(this IBusBase messageBus, int pollDelayMs = 5000)
{
Assert.ArgumentNotNull(messageBus, nameof(messageBus));
return(messageBus.Modules.Add(new OutboxModule(messageBus, pollDelayMs)));
}
public static ISubscription <TPayload> WrapSubscription(IBusBase messageBus, ISubscription <TPayload> inner, IOutbox <TPayload> outbox)
{
return(outbox == null ? inner : new OutboxSubscription <TPayload>(messageBus, inner, outbox));
}
public static ISubscriberReference <TPayload> CreateRabbitMqForwardingSubscription <TPayload>(this IBusBase messageBus, Action <IRabbitSenderBuilder <TPayload> > setup)
{
Assert.ArgumentNotNull(messageBus, nameof(messageBus));
Assert.ArgumentNotNull(setup, nameof(setup));
var module = GetRabbitModuleOrThrow(messageBus);
var builder = module.CreatePublisherBuilder <TPayload>();
setup(builder);
return(builder.Build());
}
/// <summary>
/// Factory method for a new InMemoryOutbox which will automatically be monitored by the OutboxModule
/// </summary>
/// <typeparam name="TMessage"></typeparam>
/// <param name="messageBus"></param>
/// <param name="send"></param>
/// <param name="maxMessages"></param>
/// <returns></returns>
public static OutboxAndToken <TMessage> GetMonitoredInMemoryOutbox <TMessage>(this IBusBase messageBus, Action <Envelope <TMessage> > send, int maxMessages = 100)
{
Assert.ArgumentNotNull(messageBus, nameof(messageBus));
Assert.ArgumentNotNull(send, nameof(send));
var module = GetOutboxModuleOrThrow(messageBus);
var outbox = new InMemoryOutbox <TMessage>(maxMessages);
var token = module.AddOutboxToBeMonitored(outbox, send);
return(new OutboxAndToken <TMessage>(outbox, token));
}
public ReadOnlyModules(IBusBase messageBus)
{
_messageBus = messageBus;
}
public static bool IsMessageTimerInitialized(this IBusBase messageBus)
{
var module = messageBus.Modules.Get <MessageTimerModule>();
return(module != null);
}
