public IBusControl CreateServiceBus(MassTransitOptions options, IReadOnlyList<Action<IReceiveEndpointConfigurator>> commandSubscriptions, IReadOnlyList<Action<IReceiveEndpointConfigurator>> eventSubscriptions)
{
return Bus.Factory.CreateUsingInMemory(cfg =>
{
cfg.UseJsonSerializer();
cfg.UseConcurrencyLimit(options.ConcurrencyLimit);
if (commandSubscriptions.Any())
{
cfg.ReceiveEndpoint(options.CommandQueueNameStrategy.GetQueueName(), endpoint =>
{
endpoint.UseRetry(options.CommandErrorPolicy);
foreach (var subscription in commandSubscriptions)
subscription(endpoint);
});
}
if (eventSubscriptions.Any())
{
cfg.ReceiveEndpoint(options.EventQueueNameStrategy.GetQueueName(), endpoint =>
{
endpoint.UseRetry(options.EventErrorPolicy);
foreach (var subscription in eventSubscriptions)
subscription(endpoint);
});
}
});
}
public MassTransitBusEngine(MassTransitConnectionDescriptor connectionDescriptor, MassTransitOptions options)
{
if (connectionDescriptor == null)
{
throw new ArgumentNullException(nameof(connectionDescriptor));
}
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
_connectionDescriptor = connectionDescriptor;
_options = options;
_logger = _options.LoggerFactory.CreateLogger(nameof(MassTransitBusEngine));
}
public MassTransitBusEngine(IServiceBusFactory serviceBusFactory, MassTransitOptions options)
{
if (serviceBusFactory == null)
{
throw new ArgumentNullException(nameof(serviceBusFactory));
}
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
_serviceBusFactory = serviceBusFactory;
_options = options;
_logger = options.LoggerFactory.CreateLogger(nameof(MassTransitBusEngine));
}
public void Initialize()
{
fixture = new Fixture();
commandQueueName = fixture.Create<string>();
eventQueueName = fixture.Create<string>();
mockLoggerFactory = new Mock<ILoggerFactory>();
mockLogger = new Mock<ILogger>();
mockLoggerFactory.Setup(p => p.CreateLogger(It.IsAny<string>())).Returns(() => mockLogger.Object);
mockContextManager = new Mock<IContextManager>();
mockCommandErrorStrategy = new Mock<IErrorStrategy>();
mockCommandQueueStrategy = new Mock<IQueueStrategy>();
mockCommandServiceBus = new Mock<IServiceBus>();
mockEventErrorStrategy = new Mock<IErrorStrategy>();
mockEventQueueStrategy = new Mock<IQueueStrategy>();
mockEventServiceBus = new Mock<IServiceBus>();
mockServiceBusFactory = new Mock<IServiceBusFactory>();
mockServiceBusFactory.Setup(p => p.CreateServiceBus(It.IsAny<MassTransitConnectionDescriptor>(), mockCommandQueueStrategy.Object, It.IsAny<IReadOnlyList<Action<SubscriptionBusServiceConfigurator>>>())).Returns(mockCommandServiceBus.Object);
mockServiceBusFactory.Setup(p => p.CreateServiceBus(It.IsAny<MassTransitConnectionDescriptor>(), mockEventQueueStrategy.Object, It.IsAny<IReadOnlyList<Action<SubscriptionBusServiceConfigurator>>>())).Returns(mockEventServiceBus.Object);
mockCommandQueueStrategy.Setup(p => p.GetQueueName()).Returns(commandQueueName);
mockEventQueueStrategy.Setup(p => p.GetQueueName()).Returns(eventQueueName);
options = new MassTransitOptions
{
LoggerFactory = mockLoggerFactory.Object,
CommandErrorStrategy = mockCommandErrorStrategy.Object,
CommandQueueStrategy = mockCommandQueueStrategy.Object,
EventErrorStrategy = mockEventErrorStrategy.Object,
EventQueueStrategy = mockEventQueueStrategy.Object,
ServiceBusFactory = mockServiceBusFactory.Object,
ContextManager = mockContextManager.Object
};
var host = fixture.Create<Uri>();
var userName = fixture.Create<string>();
var password = fixture.Create<string>();
connectionDescriptor = new MassTransitConnectionDescriptor(host, userName, password);
}
public IBusControl CreateServiceBus(MassTransitOptions options, IReadOnlyList<Action<IReceiveEndpointConfigurator>> commandSubscriptions, IReadOnlyList<Action<IReceiveEndpointConfigurator>> eventSubscriptions)
{
var bus = Bus.Factory.CreateUsingRabbitMq(cfg =>
{
var host = cfg.Host(_connectionDescriptor.Host, h =>
{
h.Username(_connectionDescriptor.UserName);
h.Password(_connectionDescriptor.Password);
});
cfg.UseJsonSerializer();
cfg.UseConcurrencyLimit(options.ConcurrencyLimit);
if (commandSubscriptions.Any())
{
cfg.ReceiveEndpoint(host, options.CommandQueueNameStrategy.GetQueueName(), endpoint =>
{
endpoint.UseRetry(options.CommandErrorPolicy);
_rabbitMqOptions.CommandQueuePolicy.ApplyPolicy(endpoint);
foreach (var subscription in commandSubscriptions)
subscription(endpoint);
});
}
if (eventSubscriptions.Any())
{
cfg.ReceiveEndpoint(host, options.EventQueueNameStrategy.GetQueueName(), endpoint =>
{
endpoint.UseRetry(options.EventErrorPolicy);
_rabbitMqOptions.EventQueuePolicy.ApplyPolicy(endpoint);
foreach (var subscription in eventSubscriptions)
subscription(endpoint);
});
}
});
return bus;
}
private void ConfigureMassTransitOptions(MassTransitOptions options)
{
options.CommandQueueStrategy = new TemporaryQueueStrategy();
options.EventQueueStrategy = new TemporaryQueueStrategy();
}
