/// <summary>
/// Creates the worker factory
/// </summary>
public ThreadPoolWorkerFactory(ITransport transport, IRebusLoggerFactory rebusLoggerFactory, IPipeline pipeline, IPipelineInvoker pipelineInvoker, Options options, Func<RebusBus> busGetter, BusLifetimeEvents busLifetimeEvents, ISyncBackoffStrategy backoffStrategy)
{
if (transport == null) throw new ArgumentNullException(nameof(transport));
if (rebusLoggerFactory == null) throw new ArgumentNullException(nameof(rebusLoggerFactory));
if (pipeline == null) throw new ArgumentNullException(nameof(pipeline));
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;
_pipeline = pipeline;
_pipelineInvoker = pipelineInvoker;
_options = options;
_busGetter = busGetter;
_backoffStrategy = backoffStrategy;
_parallelOperationsManager = new ParallelOperationsManager(options.MaxParallelism);
_log = _rebusLoggerFactory.GetCurrentClassLogger();
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;
}
/// <summary>
/// Constructs the bus.
/// </summary>
public RebusBus(IWorkerFactory workerFactory, IRouter router, ITransport transport, IPipeline pipeline, IPipelineInvoker pipelineInvoker, ISubscriptionStorage subscriptionStorage)
{
_workerFactory = workerFactory;
_router = router;
_transport = transport;
_pipeline = pipeline;
_pipelineInvoker = pipelineInvoker;
_subscriptionStorage = subscriptionStorage;
}
/// <summary>
/// Constructs the worker factory
/// </summary>
public ThreadWorkerFactory(ITransport transport, IPipeline pipeline, IPipelineInvoker pipelineInvoker, int maxParallelism)
{
if (transport == null) throw new ArgumentNullException("transport");
if (pipeline == null) throw new ArgumentNullException("pipeline");
if (pipelineInvoker == null) throw new ArgumentNullException("pipelineInvoker");
if (maxParallelism <= 0) throw new ArgumentOutOfRangeException(string.Format("Cannot use value '{0}' as max parallelism!", maxParallelism));
_transport = transport;
_pipeline = pipeline;
_pipelineInvoker = pipelineInvoker;
_parallelOperationsManager = new ParallelOperationsManager(maxParallelism);
}
internal ThreadWorker(ITransport transport, IPipeline pipeline, IPipelineInvoker pipelineInvoker, string workerName, ThreadWorkerSynchronizationContext threadWorkerSynchronizationContext, ParallelOperationsManager parallelOperationsManager)
{
Name = workerName;
_transport = transport;
_pipeline = pipeline;
_pipelineInvoker = pipelineInvoker;
_threadWorkerSynchronizationContext = threadWorkerSynchronizationContext;
_parallelOperationsManager = parallelOperationsManager;
_workerThread = new Thread(ThreadStart)
{
Name = workerName,
IsBackground = true
};
_workerThread.Start();
}
/// <summary>
/// Constructs the worker factory
/// </summary>
public ThreadWorkerFactory(ITransport transport, IPipeline pipeline, IPipelineInvoker pipelineInvoker, IBackoffStrategy backoffStrategy, IRebusLoggerFactory rebusLoggerFactory, Options options, Func <RebusBus> busGetter)
{
if (transport == null)
{
throw new ArgumentNullException(nameof(transport));
}
if (pipeline == null)
{
throw new ArgumentNullException(nameof(pipeline));
}
if (pipelineInvoker == null)
{
throw new ArgumentNullException(nameof(pipelineInvoker));
}
if (backoffStrategy == null)
{
throw new ArgumentNullException(nameof(backoffStrategy));
}
if (rebusLoggerFactory == null)
{
throw new ArgumentNullException(nameof(rebusLoggerFactory));
}
var maxParallelism = options.MaxParallelism;
if (maxParallelism <= 0)
{
throw new ArgumentOutOfRangeException($"Cannot use value '{maxParallelism}' as setting for max parallelism as it must be a positive number");
}
var workerShutdownTimeout = options.WorkerShutdownTimeout;
if (workerShutdownTimeout < TimeSpan.Zero)
{
throw new ArgumentOutOfRangeException($"Cannot use '{workerShutdownTimeout}' as worker shutdown timeout as it");
}
_transport = transport;
_pipeline = pipeline;
_pipelineInvoker = pipelineInvoker;
_backoffStrategy = backoffStrategy;
_rebusLoggerFactory = rebusLoggerFactory;
_busGetter = busGetter;
_parallelOperationsManager = new ParallelOperationsManager(maxParallelism);
_workerShutdownTimeout = workerShutdownTimeout;
}
internal ThreadPoolWorker(string name, ITransport transport, IRebusLoggerFactory rebusLoggerFactory, IPipelineInvoker pipelineInvoker, ParallelOperationsManager parallelOperationsManager, RebusBus owningBus, Options options, ISyncBackoffStrategy backoffStrategy)
{
Name = name;
_log = rebusLoggerFactory.GetLogger <ThreadPoolWorker>();
_transport = transport;
_pipelineInvoker = pipelineInvoker;
_parallelOperationsManager = parallelOperationsManager;
_owningBus = owningBus;
_options = options;
_backoffStrategy = backoffStrategy;
_workerThread = new Thread(Run)
{
Name = name,
IsBackground = true
};
_workerThread.Start();
}
public AsyncTaskWorker(string name, ITransport transport, IPipeline pipeline, IPipelineInvoker pipelineInvoker, int maxParallelismPerWorker, IRebusLoggerFactory rebusLoggerFactory)
{
_transport = transport;
_pipeline = pipeline;
_pipelineInvoker = pipelineInvoker;
_parallelOperationsManager = new ParallelOperationsManager(maxParallelismPerWorker);
_log = rebusLoggerFactory.GetCurrentClassLogger();
Name = name;
_workerTask = new AsyncTask(name, DoWork, new ConsoleLoggerFactory(false), prettyInsignificant: true)
{
Interval = TimeSpan.FromMilliseconds(1)
};
_log.Debug("Starting (task-based) worker {0}", Name);
_workerTask.Start();
}
/// <summary>
/// Constructs the bus.
/// </summary>
public RebusBus(IWorkersCoordinatorFactory workerFactory, IRouter router, ITransport transport, IPipelineInvoker pipelineInvoker, ISubscriptionStorage subscriptionStorage, Options options, IRebusLoggerFactory rebusLoggerFactory, BusLifetimeEvents busLifetimeEvents, ITopicNameConvention topicNameConvention)
{
_workerFactory = workerFactory;
_router = router;
_transport = transport;
_pipelineInvoker = pipelineInvoker;
_subscriptionStorage = subscriptionStorage;
_options = options;
_busLifetimeEvents = busLifetimeEvents;
_log = rebusLoggerFactory.GetLogger <RebusBus>();
_topicNameConvention = topicNameConvention;
var defaultBusName = $"Rebus {Interlocked.Increment(ref _busIdCounter)}";
_busName = options.OptionalBusName ?? defaultBusName;
_workers = new Lazy <IWorkersCoordinator>(() => _workerFactory.CreateWorkersCoordinator("RebusBus WorkersCoordinator", 0), true);
}
/// <summary>
/// Constructs the bus.
/// </summary>
public RebusBus(IWorkerFactory workerFactory, IRouter router, ITransport transport, IPipelineInvoker pipelineInvoker, ISubscriptionStorage subscriptionStorage, Options options, IRebusLoggerFactory rebusLoggerFactory, BusLifetimeEvents busLifetimeEvents, IDataBus dataBus, ITopicNameConvention topicNameConvention)
{
_workerFactory = workerFactory;
_router = router;
_transport = transport;
_pipelineInvoker = pipelineInvoker;
_subscriptionStorage = subscriptionStorage;
_options = options;
_busLifetimeEvents = busLifetimeEvents;
_dataBus = dataBus;
_log = rebusLoggerFactory.GetLogger <RebusBus>();
_topicNameConvention = topicNameConvention;
var defaultBusName = $"Rebus {Interlocked.Increment(ref _busIdCounter)}";
_busName = options.OptionalBusName ?? defaultBusName;
}
internal ThreadPoolWorker(string name, ITransport transport, IRebusLoggerFactory rebusLoggerFactory, IPipeline pipeline, IPipelineInvoker pipelineInvoker, ParallelOperationsManager parallelOperationsManager, RebusBus owningBus, Options options, ISyncBackoffStrategy backoffStrategy)
{
Name = name;
_log = rebusLoggerFactory.GetCurrentClassLogger();
_transport = transport;
_pipeline = pipeline;
_pipelineInvoker = pipelineInvoker;
_parallelOperationsManager = parallelOperationsManager;
_owningBus = owningBus;
_options = options;
_backoffStrategy = backoffStrategy;
_workerThread = new Thread(Run)
{
Name = name,
IsBackground = true
};
_workerThread.Start();
}
internal ThreadWorker(ITransport transport, IPipeline pipeline, IPipelineInvoker pipelineInvoker, string workerName, ThreadWorkerSynchronizationContext threadWorkerSynchronizationContext, ParallelOperationsManager parallelOperationsManager, IBackoffStrategy backoffStrategy, IRebusLoggerFactory rebusLoggerFactory)
{
Name = workerName;
_log = rebusLoggerFactory.GetCurrentClassLogger();
_transport = transport;
_pipeline = pipeline;
_pipelineInvoker = pipelineInvoker;
_threadWorkerSynchronizationContext = threadWorkerSynchronizationContext;
_parallelOperationsManager = parallelOperationsManager;
_backoffStrategy = backoffStrategy;
_workerThread = new Thread(ThreadStart)
{
Name = workerName,
IsBackground = true,
};
_workerThread.Start();
}
internal ThreadWorker(ITransport transport, IPipeline pipeline, IPipelineInvoker pipelineInvoker, string workerName, ThreadWorkerSynchronizationContext threadWorkerSynchronizationContext, ParallelOperationsManager parallelOperationsManager, IBackoffStrategy backoffStrategy, IRebusLoggerFactory rebusLoggerFactory)
{
Name = workerName;
_log = rebusLoggerFactory.GetCurrentClassLogger();
_transport = transport;
_pipeline = pipeline;
_pipelineInvoker = pipelineInvoker;
_threadWorkerSynchronizationContext = threadWorkerSynchronizationContext;
_parallelOperationsManager = parallelOperationsManager;
_backoffStrategy = backoffStrategy;
_workerThread = new Thread(ThreadStart)
{
Name = workerName,
IsBackground = true
};
_workerThread.Start();
}
/// <summary>
/// Constructs the worker factory
/// </summary>
public ThreadWorkerFactory(ITransport transport, IPipeline pipeline, IPipelineInvoker pipelineInvoker, int maxParallelism, IBackoffStrategy backoffStrategy, IRebusLoggerFactory rebusLoggerFactory, TimeSpan workerShutdownTimeout)
{
if (transport == null) throw new ArgumentNullException(nameof(transport));
if (pipeline == null) throw new ArgumentNullException(nameof(pipeline));
if (pipelineInvoker == null) throw new ArgumentNullException(nameof(pipelineInvoker));
if (backoffStrategy == null) throw new ArgumentNullException(nameof(backoffStrategy));
if (rebusLoggerFactory == null) throw new ArgumentNullException(nameof(rebusLoggerFactory));
if (maxParallelism <= 0) throw new ArgumentOutOfRangeException($"Cannot use value '{maxParallelism}' as max parallelism!");
if (workerShutdownTimeout == null) throw new ArgumentNullException(nameof(workerShutdownTimeout));
_transport = transport;
_pipeline = pipeline;
_pipelineInvoker = pipelineInvoker;
_backoffStrategy = backoffStrategy;
_rebusLoggerFactory = rebusLoggerFactory;
_parallelOperationsManager = new ParallelOperationsManager(maxParallelism);
_workerShutdownTimeout = workerShutdownTimeout;
}
public TplWorker(string workerName, RebusBus owningBus, ITransport transport,
IRebusLoggerFactory rebusLoggerFactory, IPipelineInvoker pipelineInvoker,
ParallelOperationsManager parallelOperationsManager, Options options, IBackoffStrategy backoffStrategy,
CancellationToken busDisposalCancellationToken)
{
_owningBus = owningBus;
_transport = transport;
_pipelineInvoker = pipelineInvoker;
_parallelOperationsManager = parallelOperationsManager;
_options = options;
_backoffStrategy = backoffStrategy;
_busDisposalCancellationToken = busDisposalCancellationToken;
Name = workerName;
_cancellationToken = _cancellationTokenSource.Token;
_log = rebusLoggerFactory.GetLogger <TplWorker>();
Task.Run(Run);
}
/// <summary>
/// Constructs the worker factory
/// </summary>
public ThreadWorkerFactory(ITransport transport, IPipeline pipeline, IPipelineInvoker pipelineInvoker, int maxParallelism)
{
if (transport == null)
{
throw new ArgumentNullException("transport");
}
if (pipeline == null)
{
throw new ArgumentNullException("pipeline");
}
if (pipelineInvoker == null)
{
throw new ArgumentNullException("pipelineInvoker");
}
if (maxParallelism <= 0)
{
throw new ArgumentOutOfRangeException(string.Format("Cannot use value '{0}' as max parallelism!", maxParallelism));
}
_transport = transport;
_pipeline = pipeline;
_pipelineInvoker = pipelineInvoker;
_parallelOperationsManager = new ParallelOperationsManager(maxParallelism);
}
public AsyncTaskWorkerFactory(ITransport transport, IPipeline pipeline, IPipelineInvoker pipelineInvoker)
{
_transport = transport;
_pipeline = pipeline;
_pipelineInvoker = pipelineInvoker;
}
public AsyncTaskWorkerFactory(ITransport transport, IPipeline pipeline, IPipelineInvoker pipelineInvoker)
{
_transport = transport;
_pipeline = pipeline;
_pipelineInvoker = pipelineInvoker;
}
public EventBus(IPipelineInvoker pielineInvoker)
{
_pielineInvoker = pielineInvoker;
}
/// <summary>
/// Constructs the bus.
/// </summary>
public RebusBus(IWorkerFactory workerFactory, IRouter router, ITransport transport, IPipeline pipeline, IPipelineInvoker pipelineInvoker, ISubscriptionStorage subscriptionStorage)
{
_workerFactory = workerFactory;
_router = router;
_transport = transport;
_pipeline = pipeline;
_pipelineInvoker = pipelineInvoker;
_subscriptionStorage = subscriptionStorage;
}
public AsyncTaskWorker(string name, ITransport transport, IPipeline pipeline, IPipelineInvoker pipelineInvoker, int maxParallelismPerWorker, IRebusLoggerFactory rebusLoggerFactory)
{
_transport = transport;
_pipeline = pipeline;
_pipelineInvoker = pipelineInvoker;
_parallelOperationsManager = new ParallelOperationsManager(maxParallelismPerWorker);
_log = rebusLoggerFactory.GetCurrentClassLogger();
Name = name;
_workerTask = new AsyncTask(name, DoWork, new ConsoleLoggerFactory(false), prettyInsignificant: true)
{
Interval = TimeSpan.FromMilliseconds(1)
};
_log.Debug("Starting (task-based) worker {0}", Name);
_workerTask.Start();
}
public AsyncTaskWorkerFactory(ITransport transport, IPipeline pipeline, IPipelineInvoker pipelineInvoker, IRebusLoggerFactory rebusLoggerFactory)
{
_transport = transport;
_pipeline = pipeline;
_pipelineInvoker = pipelineInvoker;
_rebusLoggerFactory = rebusLoggerFactory;
}
/// <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>
/// Creates the worker factory
/// </summary>
public ThreadPoolWorkerFactory(ITransport transport, IRebusLoggerFactory rebusLoggerFactory, IPipeline pipeline, IPipelineInvoker pipelineInvoker, Options options, Func <RebusBus> busGetter, BusLifetimeEvents busLifetimeEvents, ISyncBackoffStrategy backoffStrategy)
{
if (transport == null)
{
throw new ArgumentNullException(nameof(transport));
}
if (rebusLoggerFactory == null)
{
throw new ArgumentNullException(nameof(rebusLoggerFactory));
}
if (pipeline == null)
{
throw new ArgumentNullException(nameof(pipeline));
}
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;
_pipeline = pipeline;
_pipelineInvoker = pipelineInvoker;
_options = options;
_busGetter = busGetter;
_backoffStrategy = backoffStrategy;
_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;
}
/// <summary>
/// Constructs the bus.
/// </summary>
public RebusBus(IWorkerFactory workerFactory, IRouter router, ITransport transport, IPipeline pipeline, IPipelineInvoker pipelineInvoker, ISubscriptionStorage subscriptionStorage, Options options, IRebusLoggerFactory rebusLoggerFactory, BusLifetimeEvents busLifetimeEvents, IDataBus dataBus)
{
_workerFactory = workerFactory;
_router = router;
_transport = transport;
_pipeline = pipeline;
_pipelineInvoker = pipelineInvoker;
_subscriptionStorage = subscriptionStorage;
_options = options;
_busLifetimeEvents = busLifetimeEvents;
_dataBus = dataBus;
_log = rebusLoggerFactory.GetCurrentClassLogger();
}
/// <summary>
/// Constructs the TPL worker factory
/// </summary>
public TplWorkerFactory(ITransport transport, IRebusLoggerFactory rebusLoggerFactory, IPipelineInvoker pipelineInvoker, Options options, Func <RebusBus> busGetter, BusLifetimeEvents busLifetimeEvents, IBackoffStrategy backoffStrategy, CancellationToken busDisposalCancellationToken)
{
_transport = transport;
_rebusLoggerFactory = rebusLoggerFactory;
_pipelineInvoker = pipelineInvoker;
_options = options;
_busGetter = busGetter;
_backoffStrategy = backoffStrategy;
_busDisposalCancellationToken = busDisposalCancellationToken;
_parallelOperationsManager = new ParallelOperationsManager(options.MaxParallelism);
_log = _rebusLoggerFactory.GetLogger <TplWorkerFactory>();
busLifetimeEvents.WorkersStopped += WaitForContinuationsToFinish;
}
