public Worker(IErrorTracker errorTracker,
IReceiveMessages receiveMessages,
IActivateHandlers activateHandlers,
IStoreSubscriptions storeSubscriptions,
ISerializeMessages serializeMessages,
IStoreSagaData storeSagaData,
IInspectHandlerPipeline inspectHandlerPipeline,
string workerThreadName,
IHandleDeferredMessage handleDeferredMessage,
IMutateIncomingMessages mutateIncomingMessages,
IStoreTimeouts storeTimeouts,
IEnumerable <IUnitOfWorkManager> unitOfWorkManagers,
ConfigureAdditionalBehavior configureAdditionalBehavior,
MessageLogger messageLogger)
{
this.receiveMessages = receiveMessages;
this.serializeMessages = serializeMessages;
this.mutateIncomingMessages = mutateIncomingMessages;
this.unitOfWorkManagers = unitOfWorkManagers;
this.configureAdditionalBehavior = configureAdditionalBehavior;
this.messageLogger = messageLogger;
this.errorTracker = errorTracker;
dispatcher = new Dispatcher(storeSagaData, activateHandlers, storeSubscriptions, inspectHandlerPipeline, handleDeferredMessage, storeTimeouts);
dispatcher.UncorrelatedMessage += RaiseUncorrelatedMessage;
nullMessageReceivedBackoffHelper = CreateBackoffHelper(configureAdditionalBehavior.BackoffBehavior);
workerThread = new Thread(MainLoop)
{
Name = workerThreadName
};
workerThread.Start();
log.Info("Worker {0} created and inner thread started", WorkerThreadName);
}
protected override void DoSetUp()
{
activateHandlers = Mock <IActivateHandlers>();
receiveMessages = new MessageReceiverForTesting(new JsonMessageSerializer());
worker = CreateWorker(receiveMessages, activateHandlers);
}
protected RebusBus CreateBus(string inputQueueName, IActivateHandlers activateHandlers)
{
return(CreateBus(inputQueueName, activateHandlers,
new InMemorySubscriptionStorage(),
new SagaDataPersisterForTesting(),
ErrorQueueName));
}
public Worker(IErrorTracker errorTracker,
IReceiveMessages receiveMessages,
IActivateHandlers activateHandlers,
IStoreSubscriptions storeSubscriptions,
ISerializeMessages serializeMessages,
IStoreSagaData storeSagaData,
IInspectHandlerPipeline inspectHandlerPipeline,
string workerThreadName,
IHandleDeferredMessage handleDeferredMessage,
IMutateIncomingMessages mutateIncomingMessages)
{
this.receiveMessages = receiveMessages;
this.serializeMessages = serializeMessages;
this.mutateIncomingMessages = mutateIncomingMessages;
this.errorTracker = errorTracker;
dispatcher = new Dispatcher(storeSagaData, activateHandlers, storeSubscriptions, inspectHandlerPipeline, handleDeferredMessage);
dispatcher.UncorrelatedMessage += RaiseUncorrelatedMessage;
workerThread = new Thread(MainLoop)
{
Name = workerThreadName
};
workerThread.Start();
log.Info("Worker {0} created and inner thread started", WorkerThreadName);
}
protected RebusBus CreateBus(string inputQueueName, IActivateHandlers activateHandlers)
{
return CreateBus(inputQueueName, activateHandlers,
new InMemorySubscriptionStorage(),
new SagaDataPersisterForTesting(),
"error");
}
public void Lesson(IActivateHandlers activateHandlers)
{
var handlers = activateHandlers.GetHandlerInstancesFor<RebusHierarchyLesson>();
IHandleMessages<RebusHierarchyLesson> firstHandler = handlers.First();
firstHandler.Handle(new RebusHierarchyLesson());
}
public void Lesson(IActivateHandlers activateHandlers)
{
var handlers = activateHandlers.GetHandlerInstancesFor <RebusHierarchyLesson>();
IHandleMessages <RebusHierarchyLesson> firstHandler = handlers.First();
firstHandler.Handle(new RebusHierarchyLesson());
}
public CorrelationHandlerInjector(IActivateHandlers innerActivator)
{
this.innerActivator = innerActivator;
cleanupTimer.Elapsed += (o, ea) => DoCleanup();
cleanupTimer.Interval = TimeSpan.FromSeconds(1).TotalMilliseconds;
cleanupTimer.Start();
}
protected RebusBus CreateBus(string inputQueueName, IActivateHandlers activateHandlers)
{
var messageQueue = new MsmqMessageQueue(inputQueueName).PurgeInputQueue();
serializer = new JsonMessageSerializer();
var bus = new RebusBus(activateHandlers, messageQueue, messageQueue,
new InMemorySubscriptionStorage(), this,
serializer, new SagaDataPersisterForTesting(),
new TrivialPipelineInspector());
buses.Add(bus);
return bus;
}
/// <summary>
/// Constructs the dispatcher with the specified instances to store and retrieve saga data,
/// create message handlers, store and retrieve subscriptions, and to inspect and
/// possibly rearrange the handler pipeline.
/// </summary>
public Dispatcher(IStoreSagaData storeSagaData,
IActivateHandlers activateHandlers,
IStoreSubscriptions storeSubscriptions,
IInspectHandlerPipeline inspectHandlerPipeline,
IHandleDeferredMessage handleDeferredMessage)
{
this.storeSagaData = storeSagaData;
this.activateHandlers = activateHandlers;
this.storeSubscriptions = storeSubscriptions;
this.inspectHandlerPipeline = inspectHandlerPipeline;
this.handleDeferredMessage = handleDeferredMessage;
}
public IAdvancedBus CreateBus(string inputQueueName, IActivateHandlers handlerActivator)
{
var transport = CreateTransport(inputQueueName);
var bus = new RebusBus(handlerActivator, transport, transport, new InMemorySubscriptionStorage(),
new InMemorySagaPersister(), new ThrowingEndpointMapper(),
new JsonMessageSerializer(),
new TrivialPipelineInspector(), new ErrorTracker("error"));
startables.Add(bus);
return bus;
}
public IAdvancedBus CreateBus(string inputQueueName, IActivateHandlers handlerActivator)
{
var transport = CreateTransport(inputQueueName);
var bus = new RebusBus(handlerActivator, transport, transport, new InMemorySubscriptionStorage(),
new InMemorySagaPersister(), new ThrowingEndpointMapper(),
new JsonMessageSerializer(),
new TrivialPipelineInspector(), new ErrorTracker("error"));
startables.Add(bus);
return(bus);
}
protected RebusBus CreateBus(string inputQueueName, IActivateHandlers handlerActivator)
{
var rabbitMqMessageQueue = new RabbitMqMessageQueue(ConnectionString, inputQueueName, inputQueueName + ".error").PurgeInputQueue();
var bus = new RebusBus(handlerActivator, rabbitMqMessageQueue, rabbitMqMessageQueue,
new InMemorySubscriptionStorage(), new InMemorySagaPersister(), this,
new JsonMessageSerializer(), new TrivialPipelineInspector());
toDispose.Add(bus);
toDispose.Add(rabbitMqMessageQueue);
return bus;
}
protected override void DoSetUp()
{
activateHandlers = Mock <IActivateHandlers>();
receiveMessages = new MessageReceiverForTesting(new JsonMessageSerializer());
worker = new Worker(new ErrorTracker("error"),
receiveMessages,
activateHandlers,
new InMemorySubscriptionStorage(),
new JsonMessageSerializer(),
new InMemorySagaPersister(),
new TrivialPipelineInspector(), "Just some test worker",
new DeferredMessageHandlerForTesting());
}
protected RebusBus CreateBus(string inputQueueName, IActivateHandlers handlerActivator)
{
var rabbitMqMessageQueue = new RabbitMqMessageQueue(ConnectionString, inputQueueName, inputQueueName + ".error").PurgeInputQueue();
var bus = new RebusBus(handlerActivator, rabbitMqMessageQueue, rabbitMqMessageQueue,
new InMemorySubscriptionStorage(), new InMemorySagaPersister(), this,
new JsonMessageSerializer(), new TrivialPipelineInspector(),
new ErrorTracker(inputQueueName + ".error"));
toDispose.Add(bus);
toDispose.Add(rabbitMqMessageQueue);
return(bus);
}
/// <summary>
/// Constructs the bus with the specified ways of achieving its goals.
/// </summary>
/// <param name="activateHandlers">The bus will use this to construct handlers for received messages.</param>
/// <param name="sendMessages">Will be used to send transport messages when you send, publish, and reply.</param>
/// <param name="receiveMessages">Will be used to receive transport messages. If the bus is configured to run with multiple threads, this one should be reentrant.</param>
/// <param name="storeSubscriptions">Will be used to store subscription information. Is only relevant if the bus is a publisher, i.e. it publishes messages and other services assume they can subscribe to its messages.</param>
/// <param name="storeSagaData">Will be used to store saga data. Is only relevant if one or more handlers are derived from <see cref="Saga"/>.</param>
/// <param name="determineDestination">Will be used to resolve a destination in cases where the message destination is not explicitly specified as part of a send/subscribe operation.</param>
/// <param name="serializeMessages">Will be used to serialize and deserialize transport messages.</param>
/// <param name="inspectHandlerPipeline">Will be called to inspect the pipeline of handlers constructed to handle an incoming message.</param>
public RebusBus(IActivateHandlers activateHandlers, ISendMessages sendMessages, IReceiveMessages receiveMessages, IStoreSubscriptions storeSubscriptions, IStoreSagaData storeSagaData, IDetermineDestination determineDestination, ISerializeMessages serializeMessages, IInspectHandlerPipeline inspectHandlerPipeline)
{
this.activateHandlers = activateHandlers;
this.sendMessages = sendMessages;
this.receiveMessages = receiveMessages;
this.storeSubscriptions = storeSubscriptions;
this.determineDestination = determineDestination;
this.serializeMessages = serializeMessages;
this.storeSagaData = storeSagaData;
this.inspectHandlerPipeline = inspectHandlerPipeline;
rebusId = Interlocked.Increment(ref rebusIdCounter);
log.Info("Rebus bus created");
}
/// <summary>
/// Constructs the dispatcher with the specified instances to store and retrieve saga data,
/// create message handlers, store and retrieve subscriptions, and to inspect and
/// possibly rearrange the handler pipeline.
/// </summary>
public Dispatcher(IStoreSagaData storeSagaData,
IActivateHandlers activateHandlers,
IStoreSubscriptions storeSubscriptions,
IInspectHandlerPipeline inspectHandlerPipeline,
IHandleDeferredMessage handleDeferredMessage,
IStoreTimeouts storeTimeouts)
{
this.storeSagaData = storeSagaData;
this.activateHandlers = activateHandlers;
this.storeSubscriptions = storeSubscriptions;
this.inspectHandlerPipeline = inspectHandlerPipeline;
this.handleDeferredMessage = handleDeferredMessage;
this.storeTimeouts = storeTimeouts;
sagaDataIdPropertyName = Reflect.Path <ISagaData>(s => s.Id);
sagaDataPropertyName = Reflect.Path <Saga <ISagaData> >(s => s.Data);
}
protected RebusBus CreateBus(string inputQueueName, IActivateHandlers activateHandlers, IStoreSubscriptions storeSubscriptions, IStoreSagaData storeSagaData, string errorQueueName)
{
var messageQueue = new MsmqMessageQueue(inputQueueName).PurgeInputQueue();
MsmqUtil.PurgeQueue(errorQueueName);
serializer = new JsonMessageSerializer();
var bus = new RebusBus(activateHandlers, messageQueue, messageQueue,
storeSubscriptions, storeSagaData,
this, serializer, pipelineInspector,
new ErrorTracker(errorQueueName));
EnsureProperDisposal(bus);
EnsureProperDisposal(messageQueue);
return(bus);
}
protected RebusBus CreateBus(string inputQueueName, IActivateHandlers handlerActivator)
{
queuesToDelete.Add(inputQueueName);
queuesToDelete.Add(inputQueueName + ".error");
var bus = Configure.With(new FakeContainerAdapter(handlerActivator))
.Transport(x => x.UseRabbitMq(ConnectionString, inputQueueName, inputQueueName + ".error"))
.CreateBus() as RebusBus;
var rabbitMqMessageQueue = new RabbitMqMessageQueue(ConnectionString, inputQueueName).PurgeInputQueue();
DisposableTracker.TrackDisposable(rabbitMqMessageQueue);
DisposableTracker.TrackDisposable(bus);
return(bus);
}
protected RebusBus CreateBus(string inputQueueName, IActivateHandlers activateHandlers, IStoreSubscriptions storeSubscriptions, IStoreSagaData storeSagaData, string errorQueueName)
{
var messageQueue = new MsmqMessageQueue(inputQueueName).PurgeInputQueue();
MsmqUtil.PurgeQueue(errorQueueName);
serializer = new JsonMessageSerializer();
var bus = new RebusBus(activateHandlers, messageQueue, messageQueue,
storeSubscriptions, storeSagaData,
this, serializer, pipelineInspector,
new ErrorTracker(errorQueueName),
null,
new ConfigureAdditionalBehavior());
EnsureProperDisposal(bus);
EnsureProperDisposal(messageQueue);
return bus;
}
public IBus CreateBus(string inputQueueName, IActivateHandlers handlerActivator, IStoreTimeouts storeTimeouts)
{
var transport = CreateTransport(inputQueueName);
var bus = new RebusBus(handlerActivator, transport, transport,
new InMemorySubscriptionStorage(),
new InMemorySagaPersister(),
new ThrowingEndpointMapper(),
new JsonMessageSerializer(),
new TrivialPipelineInspector(),
new ErrorTracker(ErrorQueueName),
storeTimeouts, new ConfigureAdditionalBehavior());
startables.Add(bus);
disposables.Add(bus);
return bus;
}
public IBus CreateBus(string inputQueueName, IActivateHandlers handlerActivator, IStoreTimeouts storeTimeouts)
{
var transport = CreateTransport(inputQueueName);
var bus = new RebusBus(handlerActivator, transport, transport,
new InMemorySubscriptionStorage(),
new InMemorySagaPersister(),
new ThrowingEndpointMapper(),
new JsonMessageSerializer(),
new TrivialPipelineInspector(),
new ErrorTracker(ErrorQueueName),
storeTimeouts, new ConfigureAdditionalBehavior());
startables.Add(bus);
disposables.Add(bus);
return(bus);
}
protected Worker CreateWorker(IReceiveMessages receiveMessages, IActivateHandlers activateHandlers,
IInspectHandlerPipeline inspectHandlerPipeline = null,
IEnumerable <IUnitOfWorkManager> unitOfWorkManagers = null,
IErrorTracker errorTracker = null)
{
return(new Worker(errorTracker ?? new ErrorTracker("error"),
receiveMessages,
activateHandlers,
new InMemorySubscriptionStorage(),
new JsonMessageSerializer(),
new SagaDataPersisterForTesting(),
inspectHandlerPipeline ?? new TrivialPipelineInspector(),
"Just some test worker",
new DeferredMessageHandlerForTesting(),
new IncomingMessageMutatorPipelineForTesting(),
null,
unitOfWorkManagers ?? new IUnitOfWorkManager[0],
new ConfigureAdditionalBehavior()));
}
protected Worker CreateWorker(IReceiveMessages receiveMessages, IActivateHandlers activateHandlers,
IInspectHandlerPipeline inspectHandlerPipeline = null,
IEnumerable<IUnitOfWorkManager> unitOfWorkManagers = null,
IErrorTracker errorTracker = null)
{
return new Worker(errorTracker ?? new ErrorTracker("error"),
receiveMessages,
activateHandlers,
new InMemorySubscriptionStorage(),
new JsonMessageSerializer(),
new SagaDataPersisterForTesting(),
inspectHandlerPipeline ?? new TrivialPipelineInspector(),
"Just some test worker",
new DeferredMessageHandlerForTesting(),
new IncomingMessageMutatorPipelineForTesting(),
null,
unitOfWorkManagers ?? new IUnitOfWorkManager[0],
new ConfigureAdditionalBehavior());
}
/// <summary>
/// Constructs the bus with the specified ways of achieving its goals.
/// </summary>
/// <param name="activateHandlers">The bus will use this to construct handlers for received messages.</param>
/// <param name="sendMessages">Will be used to send transport messages when you send, publish, and reply.</param>
/// <param name="receiveMessages">Will be used to receive transport messages. If the bus is configured to run with multiple threads, this one should be reentrant.</param>
/// <param name="storeSubscriptions">Will be used to store subscription information. Is only relevant if the bus is a publisher, i.e. it publishes messages and other services assume they can subscribe to its messages.</param>
/// <param name="storeSagaData">Will be used to store saga data. Is only relevant if one or more handlers are derived from <see cref="Saga"/>.</param>
/// <param name="determineDestination">Will be used to resolve a destination in cases where the message destination is not explicitly specified as part of a send/subscribe operation.</param>
/// <param name="serializeMessages">Will be used to serialize and deserialize transport messages.</param>
/// <param name="inspectHandlerPipeline">Will be called to inspect the pipeline of handlers constructed to handle an incoming message.</param>
/// <param name="errorTracker">Will be used to track failed delivery attempts.</param>
public RebusBus(IActivateHandlers activateHandlers, ISendMessages sendMessages, IReceiveMessages receiveMessages, IStoreSubscriptions storeSubscriptions, IStoreSagaData storeSagaData, IDetermineDestination determineDestination, ISerializeMessages serializeMessages, IInspectHandlerPipeline inspectHandlerPipeline, IErrorTracker errorTracker)
{
this.activateHandlers = activateHandlers;
this.sendMessages = sendMessages;
this.receiveMessages = receiveMessages;
this.storeSubscriptions = storeSubscriptions;
this.determineDestination = determineDestination;
this.serializeMessages = serializeMessages;
this.storeSagaData = storeSagaData;
this.inspectHandlerPipeline = inspectHandlerPipeline;
this.errorTracker = errorTracker;
batch = new RebusBatchOperations(determineDestination, storeSubscriptions, this);
routing = new RebusRouting(this);
rebusId = Interlocked.Increment(ref rebusIdCounter);
log.Info("Rebus bus created");
}
/// <summary>
/// Constructs the bus with the specified ways of achieving its goals.
/// </summary>
/// <param name="activateHandlers">The bus will use this to construct handlers for received messages.</param>
/// <param name="sendMessages">Will be used to send transport messages when you send, publish, and reply.</param>
/// <param name="receiveMessages">Will be used to receive transport messages. If the bus is configured to run with multiple threads, this one should be reentrant.</param>
/// <param name="storeSubscriptions">Will be used to store subscription information. Is only relevant if the bus is a publisher, i.e. it publishes messages and other services assume they can subscribe to its messages.</param>
/// <param name="storeSagaData">Will be used to store saga data. Is only relevant if one or more handlers are derived from <see cref="Saga"/>.</param>
/// <param name="determineMessageOwnership">Will be used to resolve a destination in cases where the message destination is not explicitly specified as part of a send/subscribe operation.</param>
/// <param name="serializeMessages">Will be used to serialize and deserialize transport messages.</param>
/// <param name="inspectHandlerPipeline">Will be called to inspect the pipeline of handlers constructed to handle an incoming message.</param>
/// <param name="errorTracker">Will be used to track failed delivery attempts.</param>
/// <param name="storeTimeouts">Optionally provides an internal timeout manager to be used instead of sending timeout requests to an external timeout manager</param>
/// <param name="configureAdditionalBehavior"></param>
public RebusBus(
IActivateHandlers activateHandlers, ISendMessages sendMessages, IReceiveMessages receiveMessages, IStoreSubscriptions storeSubscriptions, IStoreSagaData storeSagaData,
IDetermineMessageOwnership determineMessageOwnership, ISerializeMessages serializeMessages, IInspectHandlerPipeline inspectHandlerPipeline, IErrorTracker errorTracker,
IStoreTimeouts storeTimeouts, ConfigureAdditionalBehavior configureAdditionalBehavior)
{
this.activateHandlers = activateHandlers;
this.sendMessages = sendMessages;
this.receiveMessages = receiveMessages;
this.storeSubscriptions = storeSubscriptions;
this.determineMessageOwnership = determineMessageOwnership;
this.serializeMessages = serializeMessages;
this.storeSagaData = storeSagaData;
this.inspectHandlerPipeline = inspectHandlerPipeline;
this.errorTracker = errorTracker;
this.storeTimeouts = storeTimeouts;
this.configureAdditionalBehavior = configureAdditionalBehavior;
batch = new RebusBatchOperations(determineMessageOwnership, storeSubscriptions, this);
routing = new RebusRouting(this);
rebusId = Interlocked.Increment(ref rebusIdCounter);
continuations = new RebusSynchronizationContext();
log.Info("Rebus bus {0} created", rebusId);
if (storeTimeouts == null)
{
var timeoutManagerEndpointAddress = RebusConfigurationSection
.GetConfigurationValueOrDefault(s => s.TimeoutManagerAddress, "rebus.timeout");
log.Info("Using external timeout manager with input queue '{0}'", timeoutManagerEndpointAddress);
timeoutManagerAddress = timeoutManagerEndpointAddress;
}
else
{
log.Info("Using internal timeout manager");
timeoutManagerAddress = this.receiveMessages.InputQueueAddress;
dueTimeoutScheduler = new DueTimeoutScheduler(storeTimeouts, new DeferredMessageReDispatcher(this));
}
}
public IBus CreateBus(string inputQueueName, IActivateHandlers handlerActivator)
{
return CreateBus(inputQueueName, handlerActivator, null);
}
protected RebusBus CreateBus(string inputQueueName, IActivateHandlers activateHandlers, IStoreSubscriptions storeSubscriptions, IStoreSagaData storeSagaData, string errorQueueName)
{
var messageQueue = new MsmqMessageQueue(inputQueueName, errorQueueName).PurgeInputQueue();
MsmqUtil.PurgeQueue(errorQueueName);
serializer = new JsonMessageSerializer();
var bus = new RebusBus(activateHandlers, messageQueue, messageQueue,
storeSubscriptions, storeSagaData,
this, serializer, pipelineInspector);
toDispose.Add(bus);
toDispose.Add(messageQueue);
return bus;
}
public Worker(
IErrorTracker errorTracker,
IReceiveMessages receiveMessages,
IActivateHandlers activateHandlers,
IStoreSubscriptions storeSubscriptions,
ISerializeMessages serializeMessages,
IStoreSagaData storeSagaData,
IInspectHandlerPipeline inspectHandlerPipeline,
string workerThreadName,
IHandleDeferredMessage handleDeferredMessage,
IMutateIncomingMessages mutateIncomingMessages,
IStoreTimeouts storeTimeouts,
IEnumerable<IUnitOfWorkManager> unitOfWorkManagers,
ConfigureAdditionalBehavior configureAdditionalBehavior,
MessageLogger messageLogger,
RebusSynchronizationContext continuations)
{
this.receiveMessages = receiveMessages;
this.serializeMessages = serializeMessages;
this.mutateIncomingMessages = mutateIncomingMessages;
this.unitOfWorkManagers = unitOfWorkManagers;
this.configureAdditionalBehavior = configureAdditionalBehavior;
this.messageLogger = messageLogger;
this.continuations = continuations;
this.errorTracker = errorTracker;
dispatcher = new Dispatcher(storeSagaData, activateHandlers, storeSubscriptions, inspectHandlerPipeline, handleDeferredMessage, storeTimeouts);
dispatcher.UncorrelatedMessage += RaiseUncorrelatedMessage;
nullMessageReceivedBackoffHelper = CreateBackoffHelper(configureAdditionalBehavior.BackoffBehavior);
workerThread = new Thread(MainLoop) { Name = workerThreadName };
workerThread.Start();
log.Info("Worker {0} created and inner thread started", WorkerThreadName);
}
public IBus CreateBus(string inputQueue, IActivateHandlers handlerActivator)
{
return busFactory.CreateBus(inputQueue, handlerActivator);
}
public IBus CreateBus(string inputQueue, IActivateHandlers handlerActivator)
{
return busFactory.CreateBus(inputQueue, handlerActivator, new InMemoryTimeoutStorage());
}
private static IWindsorContainer GetContainer(IActivateHandlers activator)
{
var adapter = (activator as WindsorContainerAdapter).ThrowIfNull("Rebus backbone is not using a Castle Container?!");
return(adapter.Container);
}
public IBus CreateBus(string inputQueue, IActivateHandlers handlerActivator)
{
return(busFactory.CreateBus(inputQueue, handlerActivator, new InMemoryTimeoutStorage()));
}
public IBus CreateBus(string inputQueueName, IActivateHandlers handlerActivator)
{
return(CreateBus(inputQueueName, handlerActivator, null));
}
public IBus CreateBus(string inputQueue, IActivateHandlers handlerActivator)
{
return(busFactory.CreateBus(inputQueue, handlerActivator));
}
public FakeContainerAdapter(IActivateHandlers handlerActivator)
{
this.handlerActivator = handlerActivator;
}
