public void exception_is_thrown()
{
RebusUnitOfWork.Initialize(unitOfWorkFactory: null);
var fakeMessageContext = new FakeMessageContext();
var ex = Should.Throw <InvalidOperationException>(() => RebusUnitOfWork.Create(fakeMessageContext));
ex.Message.ShouldBe("RebusUnitOfWork has not been initialized! Please call RebusUnitOfWork.Initialize(...) before using it.");
}
public void Context()
{
var domainEventHandlerFactory = new FakeDomainEventHandlerFactory(domainEvent => _raisedDomainEvent = (TestDomainEvent)domainEvent);
DomainEvents.Initialize(domainEventHandlerFactory);
DomainEvents.ResetDelayedEventsStorage();
var unitOfWorkFactory = IoC.Resolve <IUnitOfWorkFactory>();
RebusUnitOfWork.Initialize(
unitOfWorkFactory: unitOfWorkFactory,
isolationLevel: IsolationLevel.ReadCommitted
);
_fakeMessageContext = new FakeMessageContext();
_unitOfWork = RebusUnitOfWork.Create(_fakeMessageContext);
_simulateApplicationTransaction();
RebusUnitOfWork.Commit(_fakeMessageContext, _unitOfWork);
RebusUnitOfWork.Cleanup(_fakeMessageContext, _unitOfWork);
}
static void Main(string[] args)
{
using (var windsorContainer = new WindsorContainer())
{
CoreDddNhibernateInstaller.SetUnitOfWorkLifeStyle(x => x.PerRebusMessage());
windsorContainer.Install(
FromAssembly.Containing <CoreDddInstaller>(),
FromAssembly.Containing <CoreDddNhibernateInstaller>()
);
windsorContainer.Register(
Component.For <INhibernateConfigurator>()
.ImplementedBy <CoreDddSharedNhibernateConfigurator>()
.LifeStyle.Singleton
);
windsorContainer.Register(
Component.For <IInternationalMaritimeOrganizationVerifier>()
.ImplementedBy <InternationalMaritimeOrganizationVerifier>()
.LifeStyle.Transient
);
// register command handlers
windsorContainer.Register(
Classes
.FromAssemblyContaining <CreateNewShipCommandHandler>()
.BasedOn(typeof(ICommandHandler <>))
.WithService.FirstInterface()
.Configure(x => x.LifestyleTransient()));
// register domain event handlers
windsorContainer.Register(
Classes
.FromAssemblyContaining <ShipCreatedDomainEventHandler>()
.BasedOn(typeof(IDomainEventHandler <>))
.WithService.FirstInterface()
.Configure(x => x.LifestyleTransient()));
windsorContainer.AutoRegisterHandlersFromAssemblyOf <VerifyImoNumberShipCreatedDomainEventMessageHandler>();
DomainEvents.Initialize(windsorContainer.Resolve <IDomainEventHandlerFactory>());
RebusUnitOfWork.Initialize(
unitOfWorkFactory: windsorContainer.Resolve <IUnitOfWorkFactory>(),
isolationLevel: System.Data.IsolationLevel.ReadCommitted
);
var rebusConfigurer = Configure.With(new CastleWindsorContainerAdapter(windsorContainer))
.Transport(x => x.UseRabbitMq("amqp://*****:*****@localhost", "ServiceApp"))
.Options(o =>
{
o.EnableUnitOfWork(
RebusUnitOfWork.Create,
RebusUnitOfWork.Commit,
RebusUnitOfWork.Rollback,
RebusUnitOfWork.Cleanup
);
});
using (var bus = rebusConfigurer.Start())
{
bus.Subscribe <ShipCreatedDomainEventMessage>().Wait();
Console.WriteLine("Press enter to quit");
Console.ReadLine();
}
}
}
private static IBus _ConfigureAndStartRebus(IHandlerActivator handlerActivator)
{
var rebusConfigurer = Configure.With(handlerActivator);
var rebusInputQueue = _configuration["Rebus:InputQueueName"];
var rebusTransport = _configuration["Rebus:Transport"];
switch (rebusTransport)
{
#if NETFRAMEWORK
case "MSMQ":
rebusConfigurer
.Transport(x => x.UseMsmq(rebusInputQueue))
.Subscriptions(x => x.UseJsonFile($"{Path.GetTempPath()}\\emailmaker_msmq_subscriptions.json"))
;
break;
#endif
case "RabbitMQ":
rebusConfigurer.Transport(x => x.UseRabbitMq(_configuration["Rebus:RabbitMQ:ConnectionString"], rebusInputQueue));
break;
default:
throw new Exception($"Unknown rebus transport: {rebusTransport}");
}
var rebusUnitOfWorkMode = _configuration["Rebus:UnitOfWorkMode"];
switch (rebusUnitOfWorkMode)
{
case "TransactionScopeUnitOfWork":
RebusTransactionScopeUnitOfWork.Initialize(
unitOfWorkFactory: IoC.Resolve <IUnitOfWorkFactory>(),
isolationLevel: System.Transactions.IsolationLevel.ReadCommitted,
transactionScopeEnlistmentAction: null
);
rebusConfigurer
.Options(o =>
{
o.EnableUnitOfWork(
RebusTransactionScopeUnitOfWork.Create,
RebusTransactionScopeUnitOfWork.Commit,
RebusTransactionScopeUnitOfWork.Rollback,
RebusTransactionScopeUnitOfWork.Cleanup
);
})
;
break;
case "UnitOfWork":
RebusUnitOfWork.Initialize(
unitOfWorkFactory: IoC.Resolve <IUnitOfWorkFactory>(),
isolationLevel: System.Data.IsolationLevel.ReadCommitted
);
rebusConfigurer
.Options(o =>
{
o.EnableUnitOfWork(
RebusUnitOfWork.Create,
RebusUnitOfWork.Commit,
RebusUnitOfWork.Rollback,
RebusUnitOfWork.Cleanup
);
})
; break;
default:
throw new Exception($"Unknown rebus unit of work mode: {rebusUnitOfWorkMode}");
}
var bus = rebusConfigurer.Start();
bus.Subscribe <EmailEnqueuedToBeSentEventMessage>().Wait();
return(bus);
}
