/// <summary>
/// Default library entry point
/// </summary>
/// <param name="connectionFactory"></param>
/// <param name="consumerContainer"></param>
/// <param name="exchangeResolver"></param>
/// <param name="serializer"></param>
/// <param name="idGenerator"></param>
/// <param name="sequenceGenerator"></param>
/// <param name="options"> </param>
public RogerBus(IConnectionFactory connectionFactory,
IConsumerContainer consumerContainer = null,
IExchangeResolver exchangeResolver = null,
IMessageSerializer serializer = null,
IIdGenerator idGenerator = null,
ISequenceGenerator sequenceGenerator = null,
RogerOptions options = null)
{
aggregator = new Aggregator();
reconnectionTimer = new SystemThreadingTimer();
connection = new ReliableConnection(connectionFactory, reconnectionTimer, aggregator);
consumerContainer = consumerContainer.Or(new EmptyConsumerContainer());
exchangeResolver = exchangeResolver.Or(new AttributeExchangeResolver());
serializer = serializer.Or(new ProtoBufNetSerializer());
idGenerator = idGenerator.Or(new RandomIdGenerator());
sequenceGenerator = sequenceGenerator.Or(new ByMessageHirarchyRootSequenceGenerator());
options = options.Or(new RogerOptions());
publishModules.Add(new BasicReturnModule());
if (options.UsePublisherConfirms)
{
publishModules.AddFirst(new PublisherConfirmsModule(TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(10)));
}
var queueFactory = new DefaultQueueFactory(true,
false,
false,
options.QueueUnusedTimeout,
options.MessageTimeToLiveOnQueue,
options.QueueName);
Filters.Add(new ResequencingDeduplicationFilter());
consumer = new DefaultConsumingProcess(idGenerator,
exchangeResolver,
serializer,
new DefaultMessageTypeResolver(),
consumerContainer,
Filters,
queueFactory,
new AlwaysSuccessConsumerInvoker(),
options,
aggregator);
publisher = new QueueingPublishingProcess(idGenerator,
sequenceGenerator,
exchangeResolver,
serializer,
new DefaultMessageTypeResolver(),
publishModules,
aggregator);
aggregator.Subscribe(this);
}
private void StartOrResumeConsumingFromConnection(IReliableConnection connection)
{
if (consumingTask != null)
{
log.Info("Consuming already running, letting current consuming loop complete and will restart consuming when completed");
consumingTask = consumingTask.ContinueWith(task => StartConsuming(connection), TaskContinuationOptions.AttachedToParent);
return;
}
StartConsuming(connection);
}
public void Setup()
{
connection = Substitute.For <IReliableConnection>();
model = Substitute.For <IModelWithConnection>();
connection.CreateModel().Returns(model);
publishModule = Substitute.For <IPublishModule>();
aggregator = new Aggregator();
sut = new QueueingPublishingProcess(Substitute.For <IIdGenerator>(),
Substitute.For <ISequenceGenerator>(),
Substitute.For <IExchangeResolver>(),
Substitute.For <IMessageSerializer>(),
Substitute.For <IMessageTypeResolver>(),
publishModule, aggregator);
sut.Start();
}
public void Setup()
{
connection = Substitute.For<IReliableConnection>();
model = Substitute.For<IModelWithConnection>();
connection.CreateModel().Returns(model);
publishModule = Substitute.For<IPublishModule>();
aggregator = new Aggregator();
sut = new QueueingPublishingProcess(Substitute.For<IIdGenerator>(),
Substitute.For<ISequenceGenerator>(),
Substitute.For<IExchangeResolver>(),
Substitute.For<IMessageSerializer>(),
Substitute.For<IMessageTypeResolver>(),
publishModule, aggregator);
sut.Start();
}
public void Setup()
{
connection = Substitute.For<IReliableConnection>();
model = Substitute.For<IModelWithConnection>();
connection.CreateModel().Returns(model);
queueFactory = Substitute.For<IQueueFactory>();
aggregator = new Aggregator();
sut = new DefaultConsumingProcess(Substitute.For<IIdGenerator>(),
Substitute.For<IExchangeResolver>(),
Substitute.For<IMessageSerializer>(),
Substitute.For<IMessageTypeResolver>(),
Substitute.For<IConsumerContainer>(),
Substitute.For<IMessageFilter>(),
queueFactory,
Substitute.For<IConsumerInvoker>(),
new RogerOptions(), aggregator);
}
public void Setup()
{
connection = Substitute.For <IReliableConnection>();
model = Substitute.For <IModelWithConnection>();
connection.CreateModel().Returns(model);
queueFactory = Substitute.For <IQueueFactory>();
aggregator = new Aggregator();
sut = new DefaultConsumingProcess(Substitute.For <IIdGenerator>(),
Substitute.For <IExchangeResolver>(),
Substitute.For <IMessageSerializer>(),
Substitute.For <IMessageTypeResolver>(),
Substitute.For <IConsumerContainer>(),
Substitute.For <IMessageFilter>(),
queueFactory,
Substitute.For <IConsumerInvoker>(),
new RogerOptions(), aggregator);
}
private void StartConsuming(IReliableConnection connection)
{
Model = connection.CreateModel();
Model.ModelShutdown += ModelOnModelShutdown;
if (options.PrefetchCount.HasValue)
{
log.InfoFormat("Setting QoS with prefetch count {0} on consuming channel", options.PrefetchCount);
Model.BasicQos(0, options.PrefetchCount.Value, false);
}
Endpoint = new RogerEndpoint(Endpoint.IsEmpty ? queueFactory.Create(Model) : queueFactory.Create(Endpoint.Queue, Model));
CreateBindings(new HashSet <Type>(consumerContainer.GetAllConsumerTypes().SelectMany(supportedMessageTypesResolver.Resolve)));
log.DebugFormat("Declared and eventually bound endpoint {0}", Endpoint);
aggregator.Notify(new ConsumingEnabled(Endpoint, connection));
CreateConsumer();
consumingTask = Task.Factory.StartNew(ConsumeSynchronously, TaskCreationOptions.LongRunning);
}
public ConnectionEstablished(IReliableConnection connection)
{
Connection = connection;
}
public ModelWithConnectionDecorator(IModel model, IReliableConnection connection)
{
Connection = connection;
this.model = model;
}
public ConsumingEnabled(RogerEndpoint endpoint, IReliableConnection connection)
{
Endpoint = endpoint;
Connection = connection;
}
public ModelWithConnectionDecorator(IModel model, IReliableConnection connection)
{
Connection = connection;
this.model = model;
}
public ConnectionEstablished(IReliableConnection connection)
{
Connection = connection;
}
public ConsumingEnabled(RogerEndpoint endpoint, IReliableConnection connection)
{
Endpoint = endpoint;
Connection = connection;
}
