/// <summary>
/// Creates the worker factory
/// </summary>
public ThreadPoolWorkerFactory(ITransport transport, IRebusLoggerFactory rebusLoggerFactory,
IPipelineInvoker pipelineInvoker, Options options, Func <RebusBus> busGetter,
BusLifetimeEvents busLifetimeEvents, IBackoffStrategy backoffStrategy, CancellationToken busDisposalCancellationToken)
{
if (busLifetimeEvents == null)
{
throw new ArgumentNullException(nameof(busLifetimeEvents));
}
_transport = transport ?? throw new ArgumentNullException(nameof(transport));
_rebusLoggerFactory = rebusLoggerFactory ?? throw new ArgumentNullException(nameof(rebusLoggerFactory));
_pipelineInvoker = pipelineInvoker ?? throw new ArgumentNullException(nameof(pipelineInvoker));
_options = options ?? throw new ArgumentNullException(nameof(options));
_busGetter = busGetter ?? throw new ArgumentNullException(nameof(busGetter));
_backoffStrategy = backoffStrategy ?? throw new ArgumentNullException(nameof(backoffStrategy));
_busDisposalCancellationToken = busDisposalCancellationToken;
_parallelOperationsManager = new ParallelOperationsManager(options.MaxParallelism);
_log = _rebusLoggerFactory.GetLogger <ThreadPoolWorkerFactory>();
if (_options.MaxParallelism < 1)
{
throw new ArgumentException($"Max parallelism is {_options.MaxParallelism} which is an invalid value");
}
if (options.WorkerShutdownTimeout < TimeSpan.Zero)
{
throw new ArgumentOutOfRangeException($"Cannot use '{options.WorkerShutdownTimeout}' as worker shutdown timeout as it");
}
busLifetimeEvents.WorkersStopped += WaitForContinuationsToFinish;
}
public static void RaiseBusStartedBackdoor(this BusLifetimeEvents busLifetimeEvents)
{
var methodInfo = busLifetimeEvents.GetType()
.GetMethod("RaiseBusStarting", BindingFlags.NonPublic | BindingFlags.Instance)
?? throw new ArgumentException("Could not find the method");
methodInfo.Invoke(busLifetimeEvents, new object[0]);
}
static void PurgeQueue(string queueName)
{
var consoleLoggerFactory = new ConsoleLoggerFactory(false);
var asyncTaskFactory = new TplAsyncTaskFactory(consoleLoggerFactory);
var connectionString = StandardAzureServiceBusTransportFactory.ConnectionString;
var busLifetimeEvents = new BusLifetimeEvents();
new AzureServiceBusTransport(connectionString, queueName, consoleLoggerFactory, asyncTaskFactory)
.PurgeInputQueue();
}
/// <summary>
/// Constructs the TPL worker factory
/// </summary>
public TplWorkerFactory(ITransport transport, IRebusLoggerFactory rebusLoggerFactory, IPipelineInvoker pipelineInvoker, Options options, Func <RebusBus> busGetter, BusLifetimeEvents busLifetimeEvents, IBackoffStrategy backoffStrategy)
{
_transport = transport;
_rebusLoggerFactory = rebusLoggerFactory;
_pipelineInvoker = pipelineInvoker;
_options = options;
_busGetter = busGetter;
_busLifetimeEvents = busLifetimeEvents;
_backoffStrategy = backoffStrategy;
_parallelOperationsManager = new ParallelOperationsManager(options.MaxParallelism);
_log = _rebusLoggerFactory.GetLogger <TplWorkerFactory>();
busLifetimeEvents.WorkersStopped += WaitForContinuationsToFinish;
}
protected override void SetUp()
{
var connectionString = StandardAzureServiceBusTransportFactory.ConnectionString;
var consoleLoggerFactory = new ConsoleLoggerFactory(false);
var asyncTaskFactory = new TplAsyncTaskFactory(consoleLoggerFactory);
var busLifetimeEvents = new BusLifetimeEvents();
new AzureServiceBusTransport(connectionString, QueueName, consoleLoggerFactory, asyncTaskFactory).PurgeInputQueue();
_activator = new BuiltinHandlerActivator();
_bus = Configure.With(_activator)
.Transport(t => t.UseAzureServiceBus(connectionString, QueueName))
.Options(o =>
{
o.LogPipeline();
})
.Start();
Using(_bus);
}
ITransport GetTransport()
{
var consoleLoggerFactory = new ConsoleLoggerFactory(false);
var asyncTaskFactory = new TplAsyncTaskFactory(consoleLoggerFactory);
var connectionString = StandardAzureServiceBusTransportFactory.ConnectionString;
var busLifetimeEvents = new BusLifetimeEvents();
if (_mode == AzureServiceBusMode.Basic)
{
var basicTransport = new BasicAzureServiceBusTransport(connectionString, _queueName, consoleLoggerFactory, asyncTaskFactory);
Using(basicTransport);
basicTransport.Initialize();
basicTransport.PurgeInputQueue();
return(basicTransport);
}
var transport = new AzureServiceBusTransport(connectionString, _queueName, consoleLoggerFactory, asyncTaskFactory);
Using(transport);
transport.Initialize();
transport.PurgeInputQueue();
return(transport);
}
/// <summary>
/// Creates the worker factory
/// </summary>
public WorkersCoordinatorFactory(ITransport transport, IRebusLoggerFactory rebusLoggerFactory, IPipelineInvoker pipelineInvoker, Options options, Func <RebusBus> busGetter, BusLifetimeEvents busLifetimeEvents, IBackoffStrategy backoffStrategy)
{
if (transport == null)
{
throw new ArgumentNullException(nameof(transport));
}
if (rebusLoggerFactory == null)
{
throw new ArgumentNullException(nameof(rebusLoggerFactory));
}
if (pipelineInvoker == null)
{
throw new ArgumentNullException(nameof(pipelineInvoker));
}
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (busGetter == null)
{
throw new ArgumentNullException(nameof(busGetter));
}
if (busLifetimeEvents == null)
{
throw new ArgumentNullException(nameof(busLifetimeEvents));
}
if (backoffStrategy == null)
{
throw new ArgumentNullException(nameof(backoffStrategy));
}
_transport = transport;
_rebusLoggerFactory = rebusLoggerFactory;
_pipelineInvoker = pipelineInvoker;
_options = options;
_busGetter = busGetter;
_backoffStrategy = backoffStrategy;
_log = _rebusLoggerFactory.GetLogger <WorkersCoordinatorFactory>();
if (_options.MaxReadParallelism < 1)
{
throw new ArgumentException($"Max read parallelism is {_options.MaxReadParallelism} which is an invalid value");
}
if (options.WorkerShutdownTimeout < TimeSpan.Zero)
{
throw new ArgumentOutOfRangeException($"Cannot use '{options.WorkerShutdownTimeout}' as worker shutdown timeout as it");
}
}
/// <summary>
/// Registers and/or modifies Rebus configuration for the current service collection.
/// </summary>
/// <param name="services">The current message service builder.</param>
/// <param name="configure">The optional configuration actions for Rebus.</param>
public static IServiceCollection AddRebus(this IServiceCollection services, Func <RebusConfigurer, IServiceProvider, RebusConfigurer> configure)
{
if (services == null)
{
throw new ArgumentNullException(nameof(services));
}
if (configure == null)
{
throw new ArgumentNullException(nameof(configure));
}
var busAlreadyRegistered = services.Any(descriptor => descriptor.ServiceType == typeof(IBus));
if (busAlreadyRegistered)
{
throw new InvalidOperationException(@"Sorry, but it seems like Rebus has already been configured in this service collection.
It is advised to use one container instance per bus instance, because this way it can be treated as an autonomous component with the container as the root.");
}
services.AddTransient(s => MessageContext.Current ?? throw new InvalidOperationException("Attempted to resolve IMessageContext outside of a Rebus handler, which is not possible. If you get this error, it's probably a sign that your service provider is being used outside of Rebus, where it's simply not possible to resolve a Rebus message context. Rebus' message context is only available to code executing inside a Rebus handler."));
services.AddTransient(s => s.GetRequiredService <IBus>().Advanced.SyncBus);
BusLifetimeEvents busLifetimeEvents = null;
// Register the Rebus Bus instance, to be created when it is first requested.
services.AddSingleton(provider => new DependencyInjectionHandlerActivator(provider));
services.AddSingleton(provider =>
{
var activator = provider.GetRequiredService <DependencyInjectionHandlerActivator>();
var configurer = Configure.With(activator);
configure(configurer, provider);
var starter = configurer
// little hack: we snatch the lifetime events here...
.Options(o => o.Decorate(c => busLifetimeEvents = c.Get <BusLifetimeEvents>()))
.Options(o => o.Decorate <IPipeline>(c =>
{
var pipeline = c.Get <IPipeline>();
var step = new ServiceProviderProviderStep(provider);
return(new PipelineStepConcatenator(pipeline)
.OnReceive(step, PipelineAbsolutePosition.Front)
.OnSend(step, PipelineAbsolutePosition.Front));
}))
.Create();
return(starter);
});
// ...so we can install a resolver for it here:
services.AddSingleton(provider =>
{
// first, ensure that the busLifetimeEventsInstance has been set
provider.GetRequiredService <IBus>();
// then return the instance
return(busLifetimeEvents);
});
services.AddSingleton(provider => provider.GetRequiredService <IBusStarter>().Bus);
services.AddSingleton(provider => new ServiceCollectionBusDisposalFacility(provider.GetRequiredService <IBus>()));
return(services);
}
