public void TwoSimpleEventInterceptorsTest()
{
var simpleEventInterceptorOne = new EventSimpleInterceptor();
var simpleEventInterceptorTwo = new EventSimpleInterceptor();
using (var messagingEngine = new MessagingEngine(
_logFactory,
new TransportResolver(new Dictionary <string, TransportInfo>
{
{ "InMemory", new TransportInfo("none", "none", "none", null) }
})))
{
using (var engine = new CqrsEngine(
_logFactory,
messagingEngine,
Register.DefaultEndpointResolver(new InMemoryEndpointResolver()),
Register.EventInterceptors(simpleEventInterceptorOne),
Register.EventInterceptors(simpleEventInterceptorTwo),
Register.Saga <TestSaga>("test2")
.ListeningEvents(typeof(string)).From("lykke-wallet").On("lykke-wallet-events")))
{
engine.StartSubscribers();
messagingEngine.Send("2", new Endpoint("InMemory", "lykke-wallet-events", serializationFormat: SerializationFormat.Json));
Thread.Sleep(1000);
Assert.True(simpleEventInterceptorOne.Intercepted);
Assert.True(simpleEventInterceptorTwo.Intercepted);
Assert.NotNull(simpleEventInterceptorOne.InterceptionTimestamp);
Assert.NotNull(simpleEventInterceptorTwo.InterceptionTimestamp);
Assert.True(simpleEventInterceptorOne.InterceptionTimestamp < simpleEventInterceptorTwo.InterceptionTimestamp);
Assert.True(TestSaga.Messages.Contains("2"));
}
}
}
protected override void Load(ContainerBuilder builder)
{
MessagePackSerializerFactory.Defaults.FormatterResolver = MessagePack.Resolvers.ContractlessStandardResolver.Instance;
var rabbitMqSettings = new RabbitMQ.Client.ConnectionFactory {
Uri = new Uri(_settings.CurrentValue.SiriusCashoutProcessorJob.Cqrs.RabbitConnectionString)
};
builder.Register(context => new AutofacDependencyResolver(context)).As <IDependencyResolver>();
builder.RegisterType <CashoutCommandHandler>()
.WithParameter(TypedParameter.From(_settings.CurrentValue.SiriusApiServiceClient.BrokerAccountId))
.WithParameter(TypedParameter.From(_settings.CurrentValue.SiriusCashoutProcessorJob.RetrySettings.NotEnoughBalanceRetryDelayInSeconds))
.SingleInstance();
builder.Register(ctx => new MessagingEngine(ctx.Resolve <ILogFactory>(),
new TransportResolver(new Dictionary <string, TransportInfo>
{
{
"RabbitMq",
new TransportInfo(rabbitMqSettings.Endpoint.ToString(), rabbitMqSettings.UserName,
rabbitMqSettings.Password, "None", "RabbitMq")
}
}),
new RabbitMqTransportFactory(ctx.Resolve <ILogFactory>()))).As <IMessagingEngine>().SingleInstance();
const string environment = "lykke";
builder.Register(ctx =>
{
var engine = new CqrsEngine(ctx.Resolve <ILogFactory>(),
ctx.Resolve <IDependencyResolver>(),
ctx.Resolve <IMessagingEngine>(),
new DefaultEndpointProvider(),
true,
Register.DefaultEndpointResolver(new RabbitMqConventionEndpointResolver(
"RabbitMq",
SerializationFormat.MessagePack,
environment: environment)),
Register.EventInterceptors(new DefaultEventLoggingInterceptor(ctx.Resolve <ILogFactory>())),
Register.CommandInterceptors(new DefaultCommandLoggingInterceptor(ctx.Resolve <ILogFactory>())),
Register.BoundedContext(SiriusCashoutProcessorBoundedContext.Name)
.ListeningCommands(typeof(StartCashoutCommand))
.On("commands")
.WithCommandsHandler <CashoutCommandHandler>()
.PublishingEvents(
typeof(CashoutCompletedEvent),
typeof(CashoutFailedEvent)
)
.With("events")
);
engine.StartPublishers();
return(engine);
})
.As <ICqrsEngine>()
.SingleInstance()
.AutoActivate();
}
public void EventLoggingInterceptorDoesNotBreakProcessingChain()
{
var eventLoggingInterceptor = new DefaultEventLoggingInterceptor(_logFactory);
var simpleEventInterceptor = new EventSimpleInterceptor();
using (var messagingEngine = new MessagingEngine(
_logFactory,
new TransportResolver(new Dictionary <string, TransportInfo>
{
{ "InMemory", new TransportInfo("none", "none", "none", null) }
})))
{
using (var engine = new CqrsEngine(
_logFactory,
messagingEngine,
Register.DefaultEndpointResolver(new InMemoryEndpointResolver()),
Register.EventInterceptors(eventLoggingInterceptor, simpleEventInterceptor),
Register.Saga <TestSaga>("test1")
.ListeningEvents(typeof(string)).From("lykke-wallet").On("lykke-wallet-events")))
{
engine.StartSubscribers();
messagingEngine.Send("1", new Endpoint("InMemory", "lykke-wallet-events", serializationFormat: SerializationFormat.Json));
Thread.Sleep(1000);
Assert.True(simpleEventInterceptor.Intercepted);
}
}
}
public void CommandLoggingInterceptorDoesNotBreakProcessingChain()
{
var commandLoggingInterceptor = new DefaultCommandLoggingInterceptor(_logFactory);
var commandSimpleInterceptor = new CommandSimpleInterceptor();
var commandsHandler = new CommandsHandler();
using (var messagingEngine = new MessagingEngine(
_logFactory,
new TransportResolver(new Dictionary <string, TransportInfo>
{
{ "InMemory", new TransportInfo("none", "none", "none", null) }
})))
{
using (var engine = new CqrsEngine(
_logFactory,
messagingEngine,
Register.DefaultEndpointResolver(new InMemoryEndpointResolver()),
Register.CommandInterceptors(commandLoggingInterceptor, commandSimpleInterceptor),
Register.BoundedContext("test1")
.ListeningCommands(typeof(int)).On("lykke-wallet-events")
.WithCommandsHandler(commandsHandler)))
{
engine.StartSubscribers();
messagingEngine.Send(1, new Endpoint("InMemory", "lykke-wallet-events", serializationFormat: SerializationFormat.Json));
Thread.Sleep(1000);
Assert.True(commandSimpleInterceptor.Intercepted);
}
}
}
public void EventLoggingInterceptorTest()
{
int eventLoggedCount = 0;
var eventLoggingInterceptor = new CustomEventLoggingInterceptor(
_logFactory,
new Dictionary <Type, EventLoggingDelegate>
{
{ typeof(string), (l, h, e) => ++ eventLoggedCount }
});
using (var messagingEngine = new MessagingEngine(
_logFactory,
new TransportResolver(new Dictionary <string, TransportInfo>
{
{ "InMemory", new TransportInfo("none", "none", "none", null) }
})))
{
using (var engine = new CqrsEngine(
_logFactory,
messagingEngine,
Register.DefaultEndpointResolver(new InMemoryEndpointResolver()),
Register.EventInterceptors(eventLoggingInterceptor),
Register.Saga <TestSaga>("test1")
.ListeningEvents(typeof(string)).From("lykke-wallet").On("lykke-wallet-events")))
{
engine.StartSubscribers();
messagingEngine.Send("1", new Endpoint("InMemory", "lykke-wallet-events", serializationFormat: SerializationFormat.Json));
Thread.Sleep(1000);
Assert.True(eventLoggedCount > 0, "Event was not logged");
Assert.True(eventLoggedCount == 1, "Event was logged more than once");
}
}
}
public void EventLoggingInterceptorTestForDefaultLogging()
{
var eventLoggingInterceptor = new DefaultEventLoggingInterceptor(_logFactory);
using (var messagingEngine = new MessagingEngine(
_logFactory,
new TransportResolver(new Dictionary <string, TransportInfo>
{
{ "InMemory", new TransportInfo("none", "none", "none", null) }
})))
{
using (var engine = new CqrsEngine(
_logFactory,
messagingEngine,
Register.DefaultEndpointResolver(new InMemoryEndpointResolver()),
Register.EventInterceptors(eventLoggingInterceptor),
Register.Saga <TestSaga>("test1")
.ListeningEvents(typeof(string)).From("lykke-wallet").On("lykke-wallet-events")))
{
engine.StartSubscribers();
using (var writer = new StringWriter())
{
var prevOut = Console.Out;
Console.SetOut(writer);
messagingEngine.Send("1", new Endpoint("InMemory", "lykke-wallet-events", serializationFormat: SerializationFormat.Json));
Thread.Sleep(1000);
Console.SetOut(prevOut);
var output = writer.ToString();
Assert.IsFalse(output.IsNullOrEmpty(), "Event was not logged");
}
}
}
}
private CqrsEngine CreateEngine(IComponentContext ctx, IMessagingEngine messagingEngine)
{
var rabbitMqConventionEndpointResolver =
new RabbitMqConventionEndpointResolver("RabbitMq", SerializationFormat.MessagePack,
environment: _settings.EnvironmentName);
var registrations = new List <IRegistration>
{
Register.DefaultEndpointResolver(rabbitMqConventionEndpointResolver),
RegisterDefaultRouting(),
RegisterSpecialLiquidationSaga(),
RegisterLiquidationSaga(),
RegisterContext(),
Register.CommandInterceptors(new DefaultCommandLoggingInterceptor(_log)),
Register.EventInterceptors(new DefaultEventLoggingInterceptor(_log))
};
var fakeGavel = RegisterGavelContextIfNeeded();
if (fakeGavel != null)
{
registrations.Add(fakeGavel);
}
var correlationManager = ctx.Resolve <CqrsCorrelationManager>();
var engine = new CqrsEngine(_log, ctx.Resolve <IDependencyResolver>(), messagingEngine,
new DefaultEndpointProvider(), true, registrations.ToArray());
engine.SetReadHeadersAction(correlationManager.FetchCorrelationIfExists);
engine.SetWriteHeadersFunc(correlationManager.BuildCorrelationHeadersIfExists);
engine.StartPublishers();
return(engine);
}
void IRegistration.Process(CqrsEngine cqrsEngine)
{
foreach (var descriptor in m_Descriptors)
{
descriptor.Process(m_Subject, cqrsEngine);
}
}
public override void Process(Context context, CqrsEngine cqrsEngine)
{
foreach (var handler in ResolvedDependencies)
{
context.CommandDispatcher.Wire(handler, new OptionalParameter <IEventPublisher>(context.EventsPublisher));
}
}
public void ListenSameCommandOnDifferentEndpointsTest()
{
using (var messagingEngine = new MessagingEngine(
_logFactory,
new TransportResolver(new Dictionary <string, TransportInfo>
{
{ "InMemory", new TransportInfo("none", "none", "none", null, "InMemory") }
})))
{
var commandHandler = new CommandHandler();
using (var engine = new CqrsEngine(
_logFactory,
messagingEngine,
Register.DefaultEndpointResolver(new InMemoryEndpointResolver()),
Register.BoundedContext("bc")
.PublishingEvents(typeof(int)).With("eventExchange")
.ListeningCommands(typeof(string)).On("exchange1")
.ListeningCommands(typeof(string)).On("exchange2")
.WithCommandsHandler(commandHandler)))
{
engine.Start();
messagingEngine.Send("test1", new Endpoint("InMemory", "exchange1", serializationFormat: SerializationFormat.Json));
messagingEngine.Send("test2", new Endpoint("InMemory", "exchange2", serializationFormat: SerializationFormat.Json));
messagingEngine.Send("test3", new Endpoint("InMemory", "exchange3", serializationFormat: SerializationFormat.Json));
Thread.Sleep(6000);
Assert.That(commandHandler.AcceptedCommands, Is.EquivalentTo(new[] { "test1", "test2" }));
}
}
}
public override void Process(Context context, CqrsEngine cqrsEngine)
{
foreach (var process in ResolvedDependencies)
{
context.Processes.Add(((IProcess)process));
}
}
public void AllThreadsAreStoppedAfterCqrsDisposeTest()
{
var initialThreadCount = Process.GetCurrentProcess().Threads.Count;
Console.WriteLine(initialThreadCount);
using (
var messagingEngine =
new MessagingEngine(
new TransportResolver(new Dictionary <string, TransportInfo>
{
{ "InMemory", new TransportInfo("none", "none", "none", null, "InMemory") }
})))
{
using (var engine = new CqrsEngine(messagingEngine,
new InMemoryEndpointResolver(),
LocalBoundedContext.Named("bc").ConcurrencyLevel(1)
.PublishingEvents(typeof(int))
.To("eventExchange")
.RoutedTo("eventQueue")
.ListeningCommands(typeof(string))
.On("exchange1", CommandPriority.Low)
.On("exchange2", CommandPriority.High)
.RoutedFrom("commandQueue")
.WithCommandsHandler(new CommandHandler(100)))
)
{
Console.WriteLine(Process.GetCurrentProcess().Threads.Count);
}
}
Assert.That(Process.GetCurrentProcess().Threads.Count, Is.EqualTo(initialThreadCount),
"Some threads were not stopped");
}
public void ListenSameCommandOnDifferentEndpointsTest()
{
using (
var messagingEngine =
new MessagingEngine(
new TransportResolver(new Dictionary <string, TransportInfo>
{
{ "InMemory", new TransportInfo("none", "none", "none", null, "InMemory") }
})))
{
var commandHandler = new CommandHandler();
using (var engine = new CqrsEngine(messagingEngine,
new InMemoryEndpointResolver(),
LocalBoundedContext.Named("bc")
.PublishingEvents(typeof(int)).To("eventExchange").RoutedTo("eventQueue")
.ListeningCommands(typeof(string)).On("exchange1").On("exchange2").RoutedFrom("commandQueue")
.WithCommandsHandler(commandHandler))
)
{
messagingEngine.Send("test1", new Endpoint("InMemory", "bc.exchange1", serializationFormat: "json"));
messagingEngine.Send("test2", new Endpoint("InMemory", "bc.exchange2", serializationFormat: "json"));
messagingEngine.Send("test3", new Endpoint("InMemory", "bc.exchange3", serializationFormat: "json"));
Thread.Sleep(2000);
Assert.That(commandHandler.AcceptedCommands, Is.EquivalentTo(new[] { "test1", "test2" }));
}
}
}
protected sealed override Context GetSubject(CqrsEngine cqrsEngine)
{
var context = CreateContext(cqrsEngine);
cqrsEngine.Contexts.Add(context);
return(context);
}
public void TwoSimpleCommandInterceptorsTest()
{
var commandSimpleInterceptorOne = new CommandSimpleInterceptor();
var commandSimpleInterceptorTwo = new CommandSimpleInterceptor();
var commandsHandler = new CommandsHandler();
using (var messagingEngine = new MessagingEngine(
_logFactory,
new TransportResolver(new Dictionary <string, TransportInfo>
{
{ "InMemory", new TransportInfo("none", "none", "none", null) }
})))
{
using (var engine = new CqrsEngine(
_logFactory,
messagingEngine,
Register.DefaultEndpointResolver(new InMemoryEndpointResolver()),
Register.CommandInterceptors(commandSimpleInterceptorOne, commandSimpleInterceptorTwo),
Register.BoundedContext("swift-cashout")
.ListeningCommands(typeof(int)).On("lykke-wallet-events")
.WithCommandsHandler(commandsHandler)))
{
engine.StartSubscribers();
messagingEngine.Send(1, new Endpoint("InMemory", "lykke-wallet-events", serializationFormat: SerializationFormat.Json));
Thread.Sleep(1000);
Assert.True(commandSimpleInterceptorOne.Intercepted);
Assert.True(commandSimpleInterceptorTwo.Intercepted);
Assert.NotNull(commandSimpleInterceptorOne.InterceptionTimestamp);
Assert.NotNull(commandSimpleInterceptorTwo.InterceptionTimestamp);
Assert.True(commandSimpleInterceptorOne.InterceptionTimestamp < commandSimpleInterceptorTwo.InterceptionTimestamp);
Assert.True(commandsHandler.HandledCommands.Count > 0);
}
}
}
private CqrsEngine CreateEngine(IComponentContext ctx, IMessagingEngine messagingEngine)
{
var rabbitMqConventionEndpointResolver = new RabbitMqConventionEndpointResolver(
"RabbitMq",
SerializationFormat.MessagePack,
environment: _settings.EnvironmentName);
var engine = new CqrsEngine(
_log,
ctx.Resolve <IDependencyResolver>(),
messagingEngine,
new DefaultEndpointProvider(),
true,
Register.DefaultEndpointResolver(rabbitMqConventionEndpointResolver),
RegisterDefaultRouting(),
RegisterWithdrawalSaga(),
RegisterDepositSaga(),
RegisterClosePositionSaga(),
RegisterNegativeProtectionSaga(),
RegisterGiveTemporaryCapitalSaga(),
RegisterRevokeTemporaryCapitalSaga(),
RegisterDeleteAccountsSaga(),
RegisterContext(),
Register.CommandInterceptors(new DefaultCommandLoggingInterceptor(_log)),
Register.EventInterceptors(new DefaultEventLoggingInterceptor(_log)));
var correlationManager = ctx.Resolve <CqrsCorrelationManager>();
engine.SetReadHeadersAction(correlationManager.FetchCorrelationIfExists);
engine.SetWriteHeadersFunc(correlationManager.BuildCorrelationHeadersIfExists);
engine.StartAll();
return(engine);
}
void IRegistration.Create(CqrsEngine cqrsEngine)
{
m_Subject = GetSubject(cqrsEngine);
foreach (var descriptor in m_Descriptors)
{
descriptor.Create(m_Subject, cqrsEngine.DependencyResolver);
}
}
public void Process(CqrsEngine cqrsEngine)
{
foreach (var boundContext in m_BoundContexts)
{
var context = cqrsEngine.BoundedContexts.FirstOrDefault(bc => bc.Name == boundContext);
context.EventDispatcher.Wire(m_Saga, new OptionalParameter <ICommandSender>(cqrsEngine));
}
}
protected override void Load(ContainerBuilder builder)
{
MessagePackSerializerFactory.Defaults.FormatterResolver = MessagePack.Resolvers.ContractlessStandardResolver.Instance;
var rabbitMqSettings = new RabbitMQ.Client.ConnectionFactory
{
Uri = new Uri(_settings.SagasRabbitMq.RabbitConnectionString)
};
builder.Register(context => new AutofacDependencyResolver(context)).As <IDependencyResolver>().SingleInstance();
builder.RegisterType <HistoryExportProjection>().SingleInstance();
var messagingEngine = new MessagingEngine(_log,
new TransportResolver(new Dictionary <string, TransportInfo>
{
{ "RabbitMq", new TransportInfo(rabbitMqSettings.Endpoint.ToString(), rabbitMqSettings.UserName, rabbitMqSettings.Password, "None", "RabbitMq") }
}),
new RabbitMqTransportFactory());
builder
.Register(ctx =>
{
const string defaultPipeline = "commands";
const string defaultRoute = "self";
var engine = new CqrsEngine(_log,
ctx.Resolve <IDependencyResolver>(),
messagingEngine,
new DefaultEndpointProvider(),
true,
Register.DefaultEndpointResolver(new RabbitMqConventionEndpointResolver(
"RabbitMq",
SerializationFormat.MessagePack,
environment: "lykke",
exclusiveQueuePostfix: "k8s")),
Register.BoundedContext("apiv2")
.PublishingCommands(typeof(CreateCashoutCommand), typeof(CreateSwiftCashoutCommand))
.To(OperationsBoundedContext.Name).With(defaultPipeline)
.ListeningEvents(
typeof(ClientHistoryExpiredEvent),
typeof(ClientHistoryExportedEvent))
.From(HistoryExportBuilderBoundedContext.Name).On(defaultRoute)
.WithProjection(typeof(HistoryExportProjection), HistoryExportBuilderBoundedContext.Name)
.PublishingCommands(typeof(ConfirmCommand))
.To(OperationsBoundedContext.Name).With(defaultPipeline),
Register.DefaultRouting
.PublishingCommands(typeof(ExportClientHistoryCommand))
.To(HistoryExportBuilderBoundedContext.Name).With(defaultPipeline)
);
engine.StartPublishers();
return(engine);
})
.As <ICqrsEngine>()
.SingleInstance()
.AutoActivate();
}
public void FluentApiTest()
{
var endpointProvider = new Mock <IEndpointProvider>();
endpointProvider.Setup(r => r.Get("high")).Returns(new Endpoint("InMemory", "high", true, SerializationFormat.Json));
endpointProvider.Setup(r => r.Get("low")).Returns(new Endpoint("InMemory", "low", true, SerializationFormat.Json));
endpointProvider.Setup(r => r.Get("medium")).Returns(new Endpoint("InMemory", "medium", true, SerializationFormat.Json));
using (var messagingEngine = new MessagingEngine(
_logFactory,
new TransportResolver(new Dictionary <string, TransportInfo>
{
{ "InMemory", new TransportInfo("none", "none", "none", null, "InMemory") },
{ "rmq", new TransportInfo("none", "none", "none", null, "InMemory") }
})))
{
using (var engine = new CqrsEngine(
_logFactory,
messagingEngine,
endpointProvider.Object,
Register.BoundedContext("bc")
.PublishingCommands(typeof(string)).To("operations").With("operationsCommandsRoute")
.ListeningEvents(typeof(int)).From("operations").On("operationEventsRoute")
.ListeningCommands(typeof(string)).On("commandsRoute")
//same as .PublishingCommands(typeof(string)).To("bc").With("selfCommandsRoute")
.WithLoopback("selfCommandsRoute")
.PublishingEvents(typeof(int)).With("eventsRoute")
//same as.ListeningEvents(typeof(int)).From("bc").On("selfEventsRoute")
.WithLoopback("selfEventsRoute")
//explicit prioritization
.ListeningCommands(typeof(string)).On("explicitlyPrioritizedCommandsRoute")
.Prioritized(lowestPriority: 2)
.WithEndpoint("high").For(key => key.Priority == 0)
.WithEndpoint("medium").For(key => key.Priority == 1)
.WithEndpoint("low").For(key => key.Priority == 2)
//resolver based prioritization
.ListeningCommands(typeof(string)).On("prioritizedCommandsRoute")
.Prioritized(lowestPriority: 2)
.WithEndpointResolver(new InMemoryEndpointResolver())
.ProcessingOptions("explicitlyPrioritizedCommandsRoute").MultiThreaded(10)
.ProcessingOptions("prioritizedCommandsRoute").MultiThreaded(10).QueueCapacity(1024),
Register.Saga <TestSaga>("saga")
.PublishingCommands(typeof(string)).To("operations").With("operationsCommandsRoute")
.ListeningEvents(typeof(int)).From("operations").On("operationEventsRoute"),
Register.DefaultRouting
.PublishingCommands(typeof(string)).To("operations").With("defaultCommandsRoute")
.PublishingCommands(typeof(int)).To("operations").With("defaultCommandsRoute"),
Register.DefaultEndpointResolver(
new RabbitMqConventionEndpointResolver("rmq", SerializationFormat.Json))
))
{
engine.Start();
}
}
}
void IRegistration.Process(CqrsEngine cqrsEngine)
{
var boundedContext = cqrsEngine.BoundedContexts.FirstOrDefault(bc => bc.Name == Name);
foreach (var descriptor in m_Configurators)
{
descriptor.Process(boundedContext, cqrsEngine);
}
}
/// <inheritdoc cref="IRegistration"/>
public void Create(CqrsEngine cqrsEngine)
{
if (m_Resolver == null)
{
m_Resolver = cqrsEngine.DependencyResolver.GetService(Dependencies.First()) as IEndpointResolver;
}
cqrsEngine.EndpointResolver = m_Resolver;
}
protected override void Load(ContainerBuilder builder)
{
var rabbitMqSettings = new RabbitMQ.Client.ConnectionFactory {
Uri = _appSettings.CurrentValue.SagasRabbitMq.RabbitConnectionString
};
builder.Register(context => new AutofacDependencyResolver(context)).As <IDependencyResolver>().SingleInstance();
MessagePackSerializerFactory.Defaults.FormatterResolver = MessagePack.Resolvers.ContractlessStandardResolver.Instance;
builder.RegisterType <AssetsProjection>();
builder.Register(ctx => new MessagingEngine(ctx.Resolve <ILogFactory>(),
new TransportResolver(new Dictionary <string, TransportInfo>
{
{ "RabbitMq", new TransportInfo(rabbitMqSettings.Endpoint.ToString(), rabbitMqSettings.UserName, rabbitMqSettings.Password, "None", "RabbitMq") }
}),
new RabbitMqTransportFactory(ctx.Resolve <ILogFactory>()))).As <IMessagingEngine>().SingleInstance();
builder.Register(ctx =>
{
var msgPackResolver = new RabbitMqConventionEndpointResolver(
"RabbitMq",
SerializationFormat.MessagePack,
environment: "lykke",
exclusiveQueuePostfix: "k8s");
var engine = new CqrsEngine(
ctx.Resolve <ILogFactory>(),
ctx.Resolve <IDependencyResolver>(),
ctx.Resolve <IMessagingEngine>(),
new DefaultEndpointProvider(),
true,
Register.EventInterceptors(new DefaultEventLoggingInterceptor(ctx.Resolve <ILogFactory>())),
Register.DefaultEndpointResolver(msgPackResolver),
Register.BoundedContext(LimitationsBoundedContext.Name)
.ListeningEvents(typeof(AssetCreatedEvent), typeof(AssetUpdatedEvent))
.From(Assets.BoundedContext.Name).On("events")
.WithProjection(typeof(AssetsProjection), Assets.BoundedContext.Name)
.PublishingEvents(
typeof(ClientDepositEvent),
typeof(ClientWithdrawEvent)
).With("events")
.WithEndpointResolver(msgPackResolver)
);
engine.StartPublishers();
return(engine);
})
.As <ICqrsEngine>()
.AutoActivate()
.SingleInstance();
}
public void CqrsEngineTest()
{
var serializationManager = new SerializationManager();
serializationManager.RegisterSerializerFactory(new JsonSerializerFactory());
var transportResolver =
new TransportResolver(new Dictionary <string, TransportInfo>
{
{ "test", new TransportInfo("localhost", "guest", "guest", null, "RabbitMq") }
});
var messagingEngine = new MessagingEngine(transportResolver, new RabbitMqTransportFactory());
using (messagingEngine)
{
var cqrsEngine = new CqrsEngine(messagingEngine, new FakeEndpointResolver(),
LocalBoundedContext.Named("integration")
.PublishingEvents(typeof(int)).To("eventExchange").RoutedTo("eventQueue")
.ListeningCommands(typeof(string)).On("commandExchange").RoutedFrom("commandQueue")
.WithCommandsHandler <CommandsHandler>(),
LocalBoundedContext.Named("bc").WithProjection <EventListener>("integration")
);
/* var cqrsEngine = new CqrsEngine(messagingEngine, new RabbitMqConventionEndpointResolver("test","json",new EndpointResolver(new Dictionary<string, Endpoint>())),
* LocalBoundedContext.Named("integration")
* .PublishingEvents(typeof (int)).To("events").RoutedToSameEndpoint()
* .ListeningCommands(typeof (string)).On("commands").RoutedFromSameEndpoint()
* .WithCommandsHandler<CommandsHandler>(),
* LocalBoundedContext.Named("bc").WithProjection<EventListener>("integration")
* );*/
/* var c=new commandSender(messagingEngine, RemoteBoundedContext.Named("integration")
* .ListeningCommands(typeof(TestCommand)).On(new Endpoint())
* .PublishingEvents(typeof(TransferCreatedEvent)).To(new Endpoint()),
* LocalBoundedContext.Named("testBC")
* .ListeningCommands(typeof(TestCommand)).On(new Endpoint("test", "unistream.u1.commands", true))
* .ListeningCommands(typeof(int)).On(new Endpoint("test", "unistream.u1.commands", true))
* .PublishingEvents(typeof (int)).To(new Endpoint()).RoutedTo(new Endpoint())
* .PublishingEvents(typeof (string)).To(new Endpoint())
* .WithEventStore(dispatchCommits => Wireup.Init()
* .LogToOutputWindow()
* .UsingInMemoryPersistence()
* .InitializeStorageEngine()
* .UsingJsonSerialization()
* .UsingSynchronousDispatchScheduler()
* .DispatchTo(dispatchCommits))
* ); */
// messagingEngine.Send("test", new Endpoint("test", "unistream.u1.commands", true,"json"));
cqrsEngine.SendCommand("test", "integration");
Thread.Sleep(3000);
}
}
public override void Process(BoundedContext boundedContext, CqrsEngine cqrsEngine)
{
foreach (var handler in ResolvedDependencies)
{
IRepository repository = boundedContext.EventStore == null?null:boundedContext.EventStore.Repository;
boundedContext.CommandDispatcher.Wire(handler,
new OptionalParameter <IEventPublisher>(boundedContext.EventsPublisher),
new OptionalParameter <IRepository>(repository)
);
}
}
void IRegistration.Create(CqrsEngine cqrsEngine)
{
var boundedContext = new BoundedContext(cqrsEngine, Name, ThreadCount, FailedCommandRetryDelayInternal, m_IsLocal, m_LocalBoundedContext);
foreach (var descriptor in m_Configurators)
{
descriptor.Create(boundedContext, cqrsEngine.DependencyResolver);
}
cqrsEngine.BoundedContexts.Add(boundedContext);
}
internal BoundedContext(CqrsEngine cqrsEngine, string name, int threadCount, long failedCommandRetryDelay, bool isLocal, string localBoundedContext)
{
ThreadCount = threadCount;
FailedCommandRetryDelay = failedCommandRetryDelay;
IsLocal = isLocal;
LocalBoundedContext = localBoundedContext;
Name = name;
EventsPublisher = new EventsPublisher(cqrsEngine, this);
CommandDispatcher = new CommandDispatcher(Name, threadCount, failedCommandRetryDelay);
EventDispatcher = new EventDispatcher(Name);
Processes = new List <IProcess>();
}
public override void Process(Context context, CqrsEngine cqrsEngine)
{
EndpointResolver.SetFallbackResolver(cqrsEngine.EndpointResolver);
var notHandledEventTypes = context.EventDispatcher.GetUnhandledEventTypes(m_BoundedContext, m_Types);
if (notHandledEventTypes.Count > 0)
{
throw new InvalidOperationException(
$"Event types ({string.Join(", ", notHandledEventTypes.Select(t => t.Name))}) that are listened from context '{m_BoundedContext}' on route '{Route}' have no handler");
}
}
protected override void Load(ContainerBuilder builder)
{
MessagePackSerializerFactory.Defaults.FormatterResolver = MessagePack.Resolvers.ContractlessStandardResolver.Instance;
var rabbitMqSettings = new RabbitMQ.Client.ConnectionFactory
{
Uri = new Uri(_settings.RabbitConnectionString)
};
builder.Register(context => new AutofacDependencyResolver(context)).As <IDependencyResolver>().SingleInstance();
builder
.Register(ctx =>
{
var logFactory = ctx.Resolve <ILogFactory>();
var messagingEngine = new MessagingEngine(
logFactory,
new TransportResolver(new Dictionary <string, TransportInfo>
{
{
"RabbitMq",
new TransportInfo(rabbitMqSettings.Endpoint.ToString(),
rabbitMqSettings.UserName,
rabbitMqSettings.Password,
"None",
"RabbitMq")
}
}),
new RabbitMqTransportFactory(logFactory));
const string defaultPipeline = "commands";
var engine = new CqrsEngine(logFactory,
ctx.Resolve <IDependencyResolver>(),
messagingEngine,
new DefaultEndpointProvider(),
true,
Register.DefaultEndpointResolver(new RabbitMqConventionEndpointResolver(
"RabbitMq",
SerializationFormat.MessagePack,
environment: "lykke",
exclusiveQueuePostfix: "k8s")),
Register.BoundedContext("hft-api")
.PublishingCommands(typeof(CreateCashoutCommand))
.To(OperationsBoundedContext.Name).With(defaultPipeline));
engine.StartPublishers();
return(engine);
})
.As <ICqrsEngine>()
.SingleInstance()
.AutoActivate();
}
protected override void Load(ContainerBuilder builder)
{
MessagePackSerializerFactory.Defaults.FormatterResolver = MessagePack.Resolvers.ContractlessStandardResolver.Instance;
builder.Register(context => new AutofacDependencyResolver(context)).As <IDependencyResolver>().SingleInstance();
var rabbitMqSettings = new RabbitMQ.Client.ConnectionFactory {
Uri = _settings.CurrentValue.MarketDataService.Cqrs.ConnectionString
};
builder.Register(ctx =>
{
var logFactory = ctx.Resolve <ILogFactory>();
var broker = rabbitMqSettings.Endpoint.ToString();
var messagingEngine = new MessagingEngine(logFactory,
new TransportResolver(new Dictionary <string, TransportInfo>
{
{ "RabbitMq", new TransportInfo(broker, rabbitMqSettings.UserName, rabbitMqSettings.Password, "None", "RabbitMq") }
}),
new RabbitMqTransportFactory(logFactory));
var engine = new CqrsEngine(logFactory,
ctx.Resolve <IDependencyResolver>(),
messagingEngine,
new DefaultEndpointProvider(),
true,
Register.DefaultEndpointResolver(new RabbitMqConventionEndpointResolver(
"RabbitMq",
SerializationFormat.MessagePack,
environment: "lykke",
exclusiveQueuePostfix: "marketdata")),
Register.CommandInterceptors(new DefaultCommandLoggingInterceptor(logFactory)),
Register.EventInterceptors(new DefaultEventLoggingInterceptor(logFactory)),
Register.BoundedContext(MarketDataBoundedContext.Name)
.WithAssetsReadModel(route: System.Environment.MachineName)
.PublishingEvents(
typeof(MarketDataChangedEvent)
)
.With("events")
);
engine.StartPublishers();
return(engine);
})
.As <ICqrsEngine>()
.AutoActivate()
.SingleInstance();
}