public void ListenSameCommandOnDifferentEndpointsTest() { var commandHandler = new CommandsHandler(); using (var messagingEngine = new MessagingEngine( _logFactory, new TransportResolver(new Dictionary <string, TransportInfo> { { "InMemory", new TransportInfo("none", "none", "none", null, "InMemory") } }))) { 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.StartPublishers(); engine.StartSubscribers(); 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(7000); Assert.That(commandHandler.HandledCommands, Is.EquivalentTo(new[] { "test1", "test2" })); } } }
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); }
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(); }
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") .ListeningCommands(typeof(string)).On("commandsRoute") //same as .PublishingCommands(typeof(string)).To("bc").With("selfCommandsRoute") .WithLoopback("selfCommandsRoute") .PublishingEvents(typeof(int)).With("eventsRoute") //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()) .WithCommandsHandler(typeof(CommandsHandler)) .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.StartPublishers(); engine.StartSubscribers(); } } }
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(); }
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(); }
public void PrioritizedCommandsProcessingTest() { var endpointProvider = new Mock <IEndpointProvider>(); endpointProvider.Setup(r => r.Get("exchange1")).Returns(new Endpoint("InMemory", "bc.exchange1", true, SerializationFormat.Json)); endpointProvider.Setup(r => r.Get("exchange2")).Returns(new Endpoint("InMemory", "bc.exchange2", true, SerializationFormat.Json)); var commandHandler = new CommandsHandler(false, 100); using (var messagingEngine = new MessagingEngine( _logFactory, new TransportResolver(new Dictionary <string, TransportInfo> { { "InMemory", new TransportInfo("none", "none", "none", null, "InMemory") } }))) { using (var engine = new CqrsEngine( _logFactory, messagingEngine, endpointProvider.Object, Register.DefaultEndpointResolver(new InMemoryEndpointResolver()), Register.BoundedContext("bc") .PublishingEvents(typeof(int)).With("eventExchange")//.WithLoopback("eventQueue") .ListeningCommands(typeof(string)).On("commandsRoute") .Prioritized(lowestPriority: 1) .WithEndpoint("exchange1").For(key => key.Priority == 1) .WithEndpoint("exchange2").For(key => key.Priority == 2) .ProcessingOptions("commandsRoute").MultiThreaded(2) .WithCommandsHandler(commandHandler))) { engine.StartPublishers(); engine.StartSubscribers(); messagingEngine.Send("low1", new Endpoint("InMemory", "bc.exchange2", serializationFormat: SerializationFormat.Json)); messagingEngine.Send("low2", new Endpoint("InMemory", "bc.exchange2", serializationFormat: SerializationFormat.Json)); messagingEngine.Send("low3", new Endpoint("InMemory", "bc.exchange2", serializationFormat: SerializationFormat.Json)); messagingEngine.Send("low4", new Endpoint("InMemory", "bc.exchange2", serializationFormat: SerializationFormat.Json)); messagingEngine.Send("low5", new Endpoint("InMemory", "bc.exchange2", serializationFormat: SerializationFormat.Json)); messagingEngine.Send("low6", new Endpoint("InMemory", "bc.exchange2", serializationFormat: SerializationFormat.Json)); messagingEngine.Send("low7", new Endpoint("InMemory", "bc.exchange2", serializationFormat: SerializationFormat.Json)); messagingEngine.Send("low8", new Endpoint("InMemory", "bc.exchange2", serializationFormat: SerializationFormat.Json)); messagingEngine.Send("low9", new Endpoint("InMemory", "bc.exchange2", serializationFormat: SerializationFormat.Json)); messagingEngine.Send("low10", new Endpoint("InMemory", "bc.exchange2", serializationFormat: SerializationFormat.Json)); messagingEngine.Send("high", new Endpoint("InMemory", "bc.exchange1", serializationFormat: SerializationFormat.Json)); Thread.Sleep(2000); Assert.True(commandHandler.HandledCommands.Take(2).Any(c => (string)c == "high")); } } }
public void SagaTest() { var commandHandler = new CustomCommandsHandler(); using (var messagingEngine = new MessagingEngine( _logFactory, new TransportResolver(new Dictionary <string, TransportInfo> { { "rmq", new TransportInfo("amqp://localhost/LKK", "guest", "guest", "None", "RabbitMq") } }), new RabbitMqTransportFactory(_logFactory))) { using (var engine = new CqrsEngine( _logFactory, messagingEngine, Register.DefaultEndpointResolver( new RabbitMqConventionEndpointResolver("rmq", SerializationFormat.Json, environment: "dev")), Register.BoundedContext("operations") .PublishingCommands(typeof(CreateCashOutCommand)).To("lykke-wallet").With("operations-commands") .ListeningEvents(typeof(CashOutCreatedEvent)).From("lykke-wallet").On("lykke-wallet-events"), Register.BoundedContext("lykke-wallet") .FailedCommandRetryDelay((long)TimeSpan.FromSeconds(2).TotalMilliseconds) .ListeningCommands(typeof(CreateCashOutCommand)).On("operations-commands") .PublishingEvents(typeof(CashOutCreatedEvent)).With("lykke-wallet-events") .WithCommandsHandler(commandHandler), Register.Saga <TestSaga>("swift-cashout") .ListeningEvents(typeof(CashOutCreatedEvent)).From("lykke-wallet").On("lykke-wallet-events"), Register.DefaultRouting.PublishingCommands(typeof(CreateCashOutCommand)).To("lykke-wallet") .With("operations-commands")) ) { engine.StartPublishers(); engine.StartSubscribers(); engine.SendCommand(new CreateCashOutCommand { Payload = "test data" }, null, "lykke-wallet"); Assert.True(TestSaga.Complete.WaitOne(2000), "Saga has not got events or failed to send command"); } } }
private CqrsEngine CreateEngine(IComponentContext ctx) { var rabbitMqSettings = new ConnectionFactory { Uri = _cqrsSettings.RabbitConnectionString }; var messagingEngine = new MessagingEngine ( ctx.Resolve <ILogFactory>(), new TransportResolver(new Dictionary <string, TransportInfo> { { "RabbitMq", new TransportInfo ( broker: rabbitMqSettings.Endpoint.ToString(), login: rabbitMqSettings.UserName, password: rabbitMqSettings.Password, jailStrategyName: "None", messaging: "RabbitMq" ) } }), new RabbitMqTransportFactory(ctx.Resolve <ILogFactory>()) ); var engine = new CqrsEngine ( logFactory: ctx.Resolve <ILogFactory>(), dependencyResolver: ctx.Resolve <IDependencyResolver>(), messagingEngine: messagingEngine, endpointProvider: new DefaultEndpointProvider(), createMissingEndpoints: true, registrations: ConfigureCqrsEngine() ); engine.StartPublishers(); return(engine); }
public void ContextUsesDefaultRouteForCommandPublishingIfItDoesNotHaveItsOwnTest() { var bcCommands = new Endpoint("InMemory", "bcCommands", serializationFormat: SerializationFormat.Json); var defaultCommands = new Endpoint("InMemory", "defaultCommands", serializationFormat: SerializationFormat.Json); using (var messagingEngine = new MessagingEngine( _logFactory, new TransportResolver(new Dictionary <string, TransportInfo> { { "InMemory", new TransportInfo("none", "none", "none", null, "InMemory") } }))) { using (var engine = new CqrsEngine( _logFactory, messagingEngine, Register.DefaultEndpointResolver(new InMemoryEndpointResolver()), Register.BoundedContext("bc2") .PublishingCommands(typeof(int)).To("bc1").With("bcCommands"), Register.DefaultRouting .PublishingCommands(typeof(string)).To("bc1").With("defaultCommands") .PublishingCommands(typeof(int)).To("bc1").With("defaultCommands"))) { engine.StartPublishers(); var received = new AutoResetEvent(false); using (messagingEngine.Subscribe(defaultCommands, o => received.Set(), s => { }, typeof(string))) { engine.SendCommand("test", "bc2", "bc1"); Assert.That(received.WaitOne(2000), Is.True, "not defined for context command was not routed with default route map"); } using (messagingEngine.Subscribe(bcCommands, o => received.Set(), s => { }, typeof(int))) { engine.SendCommand(1, "bc2", "bc1"); Assert.That(received.WaitOne(2000), Is.True, "defined for context command was not routed with context route map"); } } } }
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(), RegisterContext(), Register.CommandInterceptors(new DefaultCommandLoggingInterceptor(_log)), Register.EventInterceptors(new DefaultEventLoggingInterceptor(_log))); engine.StartPublishers(); return(engine); }
private CqrsEngine CreateEngine( IComponentContext ctx, IMessagingEngine messagingEngine, ILogFactory logFactory) { const string defaultPipeline = "commands"; const string defaultRoute = "self"; var sagasMessagePackEndpointResolver = new RabbitMqConventionEndpointResolver( "RabbitMq", SerializationFormat.MessagePack, environment: "lykke"); var sagasProtobufEndpointResolver = new RabbitMqConventionEndpointResolver( "RabbitMq", SerializationFormat.ProtoBuf, environment: "lykke"); var engine = new CqrsEngine( logFactory, ctx.Resolve <IDependencyResolver>(), messagingEngine, new DefaultEndpointProvider(), true, Register.DefaultEndpointResolver(sagasMessagePackEndpointResolver), Register.EventInterceptors(new DefaultEventLoggingInterceptor(ctx.Resolve <ILogFactory>())), Register.CommandInterceptors(new DefaultCommandLoggingInterceptor(ctx.Resolve <ILogFactory>())), Register.BoundedContext(BoundedContext.ForwardWithdrawal) .ListeningCommands( typeof(ProcessPaymentCommand), typeof(RemoveEntryCommand), typeof(RemoveEntryFromHistoryJobCommand), typeof(RemoveEntryFromHistoryServiceCommand)) .On(defaultRoute) .PublishingEvents( typeof(PaymentEntryRemovedEvent), typeof(CashInRemovedFromHistoryJobEvent), typeof(CashInRemovedFromHistoryServiceEvent), typeof(CashInProcesedEvent)) .With(defaultPipeline) .WithCommandsHandler(typeof(CommandsHandler)), Register.Saga <PaymentSaga>("payment-saga") .ListeningEvents( typeof(PaymentEntryRemovedEvent), typeof(CashInRemovedFromHistoryJobEvent), typeof(CashInRemovedFromHistoryServiceEvent), typeof(CashInProcesedEvent)) .From(BoundedContext.ForwardWithdrawal).On(defaultRoute) .PublishingCommands( typeof(ProcessPaymentCommand), typeof(RemoveEntryCommand), typeof(RemoveEntryFromHistoryJobCommand), typeof(RemoveEntryFromHistoryServiceCommand)) .To(BoundedContext.ForwardWithdrawal).With(defaultPipeline) .PublishingCommands( typeof(DeleteForwardCashinCommand)) .To(HistoryBoundedContext.Name) .With(defaultPipeline) .WithEndpointResolver(sagasProtobufEndpointResolver), Register.Saga <CashoutsSaga>("cashouts-saga") .ListeningEvents(typeof(CashOutProcessedEvent)) .From(PostProcessingBoundedContext.Name) .On(defaultRoute) .WithEndpointResolver(sagasProtobufEndpointResolver) .PublishingCommands( typeof(CreateForwardCashinCommand)) .To(HistoryBoundedContext.Name) .With(defaultPipeline) .WithEndpointResolver(sagasProtobufEndpointResolver), Register.DefaultRouting .PublishingCommands(typeof(RemoveEntryCommand)) .To(BoundedContext.ForwardWithdrawal) .With(defaultPipeline)); engine.StartPublishers(); return(engine); }
protected override void Load(ContainerBuilder builder) { if (_settings.TransactionHandlerJob.ChaosKitty != null) { ChaosKitty.StateOfChaos = _settings.TransactionHandlerJob.ChaosKitty.StateOfChaos; } MessagePackSerializerFactory.Defaults.FormatterResolver = MessagePack.Resolvers.ContractlessStandardResolver.Instance; builder.Register(context => new AutofacDependencyResolver(context)).As <IDependencyResolver>().SingleInstance(); var rabbitMqSettings = new RabbitMQ.Client.ConnectionFactory { Uri = _settings.TransactionHandlerJob.SagasRabbitMqConnStr }; builder.Register(ctx => { var logFactory = ctx.Resolve <ILogFactory>(); return(new MessagingEngine( logFactory, new TransportResolver(new Dictionary <string, TransportInfo> { { "RabbitMq", new TransportInfo( rabbitMqSettings.Endpoint.ToString(), rabbitMqSettings.UserName, rabbitMqSettings.Password, "None", "RabbitMq") } }), new RabbitMqTransportFactory(logFactory))); }); var defaultRetryDelay = _settings.TransactionHandlerJob.RetryDelayInMilliseconds; var longRetryDelay = defaultRetryDelay * 60; builder.RegisterType <CashInOutMessageProcessor>(); builder.RegisterType <ForwardWithdawalSaga>(); builder.RegisterType <HistorySaga>(); builder.RegisterType <TradeSaga>(); builder.RegisterType <TransferSaga>(); builder.RegisterType <EthereumCoreSaga>(); builder.RegisterType <ForwardWithdrawalCommandHandler>(); builder.RegisterType <BitcoinCommandHandler>() .WithParameter(TypedParameter.From(TimeSpan.FromMilliseconds(longRetryDelay))).SingleInstance(); builder.RegisterType <EthereumCommandHandler>() .WithParameter(TypedParameter.From(_settings.Ethereum)) .WithParameter(TypedParameter.From(TimeSpan.FromMilliseconds(longRetryDelay))); builder.RegisterType <OffchainCommandHandler>(); builder.RegisterType <OperationsCommandHandler>() .WithParameter(TypedParameter.From(TimeSpan.FromMilliseconds(longRetryDelay))); builder.RegisterType <TradeCommandHandler>(); builder.RegisterType <HistoryCommandHandler>(); builder.RegisterType <LimitOrderCommandHandler>(); builder.RegisterType <EthereumCoreCommandHandler>(); builder.RegisterType <OperationHistoryProjection>(); builder.RegisterType <OrdersProjection>(); builder.RegisterType <ContextFactory>().As <IContextFactory>().SingleInstance(); builder.RegisterType <ClientTradesFactory>().As <IClientTradesFactory>().SingleInstance(); builder.Register(ctx => { const string commandsRoute = "commands"; const string eventsRoute = "events"; const string defaultRoute = "self"; var engine = new CqrsEngine( ctx.Resolve <ILogFactory>(), ctx.Resolve <IDependencyResolver>(), ctx.Resolve <MessagingEngine>(), new DefaultEndpointProvider(), true, Register.DefaultEndpointResolver(new RabbitMqConventionEndpointResolver( "RabbitMq", SerializationFormat.MessagePack, environment: "lykke", exclusiveQueuePostfix: _settings.TransactionHandlerJob.QueuePostfix)), Register.BoundedContext(BoundedContexts.Trades) .FailedCommandRetryDelay(defaultRetryDelay) .ListeningCommands(typeof(CreateTradeCommand), typeof(CreateTransactionCommand)) .On(defaultRoute) .PublishingEvents(typeof(TradeCreatedEvent)) .With(eventsRoute) .WithCommandsHandler <TradeCommandHandler>(), Register.BoundedContext(BoundedContexts.Orders) .ListeningEvents(typeof(TradeCreatedEvent)) .From(BoundedContexts.Trades).On(defaultRoute) .WithProjection(typeof(OrdersProjection), BoundedContexts.Trades), Register.Saga <TradeSaga>($"{BoundedContexts.TxHandler}.trade-saga") .ListeningEvents(typeof(TradeCreatedEvent)) .From(BoundedContexts.Trades).On(defaultRoute) .PublishingCommands(typeof(CreateTransactionCommand)) .To(BoundedContexts.Trades).With(commandsRoute), Register.BoundedContext(BoundedContexts.TxHandler) .FailedCommandRetryDelay(defaultRetryDelay) .ListeningCommands(typeof(ProcessLimitOrderCommand)) .On(commandsRoute) .WithLoopback() .PublishingEvents(typeof(LimitOrderExecutedEvent)) .With(eventsRoute) .WithCommandsHandler <LimitOrderCommandHandler>(), Register.BoundedContext(BoundedContexts.ForwardWithdrawal) .FailedCommandRetryDelay(defaultRetryDelay) .ListeningCommands(typeof(SetLinkedCashInOperationCommand)) .On(defaultRoute) .PublishingEvents(typeof(ForwardWithdawalLinkedEvent)) .With(eventsRoute) .WithCommandsHandler <ForwardWithdrawalCommandHandler>(), Register.BoundedContext(BoundedContexts.Bitcoin) .FailedCommandRetryDelay(defaultRetryDelay) .ListeningCommands(typeof(SegwitTransferCommand)) .On(defaultRoute) .WithCommandsHandler <BitcoinCommandHandler>(), Register.BoundedContext(BoundedContexts.Ethereum) .FailedCommandRetryDelay(defaultRetryDelay) .ListeningCommands(typeof(TransferEthereumCommand)) .On(defaultRoute) .PublishingEvents(typeof(EthereumTransferSentEvent)) .With(eventsRoute) .WithCommandsHandler <EthereumCommandHandler>(), Register.BoundedContext(BoundedContexts.EthereumCommands) .FailedCommandRetryDelay(defaultRetryDelay) .ListeningCommands(typeof(ProcessEthCoinEventCommand), typeof(ProcessHotWalletErc20EventCommand)) .On(defaultRoute) .WithLoopback(defaultRoute) .ListeningCommands(typeof(EnrollEthCashinToMatchingEngineCommand), typeof(SaveEthInHistoryCommand)) .On(defaultRoute) .PublishingEvents(typeof(CashinDetectedEvent), typeof(EthCashinEnrolledToMatchingEngineEvent), typeof(EthCashinSavedInHistoryEvent)) .With(eventsRoute) .WithCommandsHandler <EthereumCoreCommandHandler>() .ProcessingOptions(defaultRoute).MultiThreaded(4).QueueCapacity(1024), Register.BoundedContext(BoundedContexts.Offchain) .FailedCommandRetryDelay(defaultRetryDelay) .ListeningCommands(typeof(CreateOffchainCashoutRequestCommand)) .On(defaultRoute) .WithCommandsHandler <OffchainCommandHandler>(), Register.BoundedContext(BoundedContexts.Operations) .FailedCommandRetryDelay(defaultRetryDelay) .ListeningCommands( typeof(SaveTransferOperationStateCommand), typeof(SaveManualOperationStateCommand), typeof(SaveCashoutOperationStateCommand), typeof(SaveIssueOperationStateCommand), typeof(CompleteOperationCommand)) .On(defaultRoute) .PublishingEvents( typeof(TransferOperationStateSavedEvent), typeof(ManualTransactionStateSavedEvent), typeof(IssueTransactionStateSavedEvent), typeof(CashoutTransactionStateSavedEvent)) .With(eventsRoute) .WithCommandsHandler <OperationsCommandHandler>(), Register.BoundedContext(BoundedContexts.OperationsHistory) .FailedCommandRetryDelay(defaultRetryDelay) .ListeningEvents( typeof(TransferOperationStateSavedEvent), typeof(ManualTransactionStateSavedEvent), typeof(IssueTransactionStateSavedEvent), typeof(CashoutTransactionStateSavedEvent)) .From(BoundedContexts.Operations).On(defaultRoute) .WithProjection(typeof(OperationHistoryProjection), BoundedContexts.Operations) .ListeningEvents(typeof(ForwardWithdawalLinkedEvent)) .From(BoundedContexts.ForwardWithdrawal).On(defaultRoute) .WithProjection(typeof(OperationHistoryProjection), BoundedContexts.ForwardWithdrawal) .ListeningEvents(typeof(TradeCreatedEvent)) .From(BoundedContexts.Trades).On(defaultRoute) .WithProjection(typeof(OperationHistoryProjection), BoundedContexts.Trades) .ListeningEvents(typeof(LimitOrderExecutedEvent)) .From(BoundedContexts.TxHandler).On(defaultRoute) .WithProjection(typeof(OperationHistoryProjection), BoundedContexts.TxHandler) .ProcessingOptions(defaultRoute).MultiThreaded(4).QueueCapacity(1024) .ListeningCommands(typeof(UpdateLimitOrdersCountCommand)) .On(commandsRoute) .WithCommandsHandler <HistoryCommandHandler>(), Register.Saga <ForwardWithdawalSaga>($"{BoundedContexts.TxHandler}.forward-withdrawal-saga") .ListeningEvents(typeof(CashoutTransactionStateSavedEvent)) .From(BoundedContexts.Operations).On(defaultRoute) .PublishingCommands(typeof(SetLinkedCashInOperationCommand)) .To(BoundedContexts.ForwardWithdrawal).With(commandsRoute), Register.Saga <HistorySaga>("history-saga") .ListeningEvents(typeof(LimitOrderExecutedEvent)) .From(BoundedContexts.TxHandler).On("events") .PublishingCommands(typeof(UpdateLimitOrdersCountCommand)) .To(BoundedContexts.OperationsHistory).With(commandsRoute), Register.Saga <TransferSaga>("transfers-saga") .ListeningEvents(typeof(TransferOperationStateSavedEvent)) .From(BoundedContexts.Operations).On(defaultRoute) .ListeningEvents(typeof(EthereumTransferSentEvent)) .From(BoundedContexts.Ethereum).On(defaultRoute) .PublishingCommands(typeof(TransferEthereumCommand)) .To(BoundedContexts.Ethereum).With(commandsRoute) .PublishingCommands(typeof(CompleteOperationCommand)) .To(BoundedContexts.Operations).With(commandsRoute), Register.Saga <EthereumCoreSaga>("ethereum-core-saga") .ListeningEvents(typeof(CashinDetectedEvent), typeof(EthCashinEnrolledToMatchingEngineEvent), typeof(EthCashinSavedInHistoryEvent)) .From(BoundedContexts.EthereumCommands).On(defaultRoute) .PublishingCommands(typeof(EnrollEthCashinToMatchingEngineCommand), typeof(SaveEthInHistoryCommand)) .To(BoundedContexts.EthereumCommands).With(commandsRoute) .ProcessingOptions(defaultRoute).MultiThreaded(4).QueueCapacity(1024), Register.DefaultRouting .PublishingCommands(typeof(CreateOffchainCashoutRequestCommand)) .To(BoundedContexts.Offchain).With(commandsRoute) .PublishingCommands(typeof(SegwitTransferCommand)) .To(BoundedContexts.Bitcoin).With(commandsRoute) .PublishingCommands(typeof(SaveManualOperationStateCommand), typeof(SaveIssueOperationStateCommand), typeof(SaveCashoutOperationStateCommand)) .To(BoundedContexts.Operations).With(commandsRoute) .PublishingCommands(typeof(CreateTradeCommand)) .To(BoundedContexts.Trades).With(commandsRoute) .PublishingCommands(typeof(SaveTransferOperationStateCommand)) .To(BoundedContexts.Operations).With(commandsRoute) ); engine.StartPublishers(); return(engine); }) .As <ICqrsEngine>() .AutoActivate() .SingleInstance(); }
protected override void Load(ContainerBuilder builder) { if (_settings.ChaosKitty != null) { builder .RegisterType <ChaosKitty>() .WithParameter(TypedParameter.From(_settings.ChaosKitty.StateOfChaos)) .As <IChaosKitty>() .SingleInstance(); } else { builder .RegisterType <SilentChaosKitty>() .As <IChaosKitty>() .SingleInstance(); } builder.Register(context => new AutofacDependencyResolver(context)).As <IDependencyResolver>().SingleInstance(); var rabbitMqSettings = new RabbitMQ.Client.ConnectionFactory { Uri = _settings.RabbitConnectionString }; 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.RegisterType <BalancesUpdateProjection>(); builder.RegisterType <TotalBalanceCommandHandler>(); builder.Register(ctx => { const string defaultRoute = "self"; const string defaultPipeline = "commands"; var engine = new CqrsEngine(ctx.Resolve <ILogFactory>(), ctx.Resolve <IDependencyResolver>(), ctx.Resolve <IMessagingEngine>(), new DefaultEndpointProvider(), true, Register.DefaultEndpointResolver(new RabbitMqConventionEndpointResolver( "RabbitMq", Messaging.Serialization.SerializationFormat.ProtoBuf, environment: "lykke", exclusiveQueuePostfix: "k8s")), Register.BoundedContext(BoundedContext.Name) .ListeningCommands(typeof(UpdateTotalBalanceCommand)) .On(defaultPipeline) .WithCommandsHandler <TotalBalanceCommandHandler>() .PublishingEvents(typeof(BalanceUpdatedEvent)) .With(defaultRoute) .ListeningEvents(typeof(BalanceUpdatedEvent)) .From(BoundedContext.Name).On(defaultRoute) .WithProjection(typeof(BalancesUpdateProjection), BoundedContext.Name), Register.DefaultRouting .PublishingCommands(typeof(UpdateTotalBalanceCommand)) .To(BoundedContext.Name).With(defaultPipeline) ); engine.StartPublishers(); return(engine); }) .As <ICqrsEngine>() .SingleInstance() .AutoActivate(); }
protected override void Load(ContainerBuilder builder) { if (_settings.ChaosKitty != null) { builder .RegisterType <ChaosKitty>() .WithParameter(TypedParameter.From(_settings.ChaosKitty.StateOfChaos)) .As <IChaosKitty>() .SingleInstance(); } else { builder .RegisterType <SilentChaosKitty>() .As <IChaosKitty>() .SingleInstance(); } MessagePackSerializerFactory.Defaults.FormatterResolver = MessagePack.Resolvers.ContractlessStandardResolver.Instance; builder .Register(context => new AutofacDependencyResolver(context)) .As <IDependencyResolver>() .SingleInstance(); var rabbitMqSettings = new RabbitMQ.Client.ConnectionFactory { Uri = new Uri(_settings.SagasRabbitMqConnStr) }; builder.RegisterType <ApiKeyHandler>() .PropertiesAutowired(PropertyWiringOptions.AllowCircularDependencies); 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 defaultRetryDelay = (long)_settings.RetryDelay.TotalMilliseconds; const string defaultPipeline = "commands"; const string defaultRoute = "self"; var engine = new CqrsEngine(logFactory, ctx.Resolve <IDependencyResolver>(), messagingEngine, new DefaultEndpointProvider(), true, Register.DefaultEndpointResolver(new RabbitMqConventionEndpointResolver( "RabbitMq", SerializationFormat.MessagePack, environment: "lykke", exclusiveQueuePostfix: _settings.QueuePostfix)), Register.EventInterceptors(new DefaultEventLoggingInterceptor(ctx.Resolve <ILogFactory>())), Register.BoundedContext("api-key") .FailedCommandRetryDelay(defaultRetryDelay) .ListeningCommands( typeof(CreateApiKeyCommand), typeof(DisableApiKeyCommand), typeof(SetTokensCommand) ) .On(defaultRoute) .PublishingEvents( typeof(ApiKeyUpdatedEvent)) .With(defaultPipeline) .WithCommandsHandler <ApiKeyHandler>(), Register.DefaultRouting .PublishingCommands( typeof(CreateApiKeyCommand), typeof(DisableApiKeyCommand), typeof(SetTokensCommand) ) .To("api-key").With(defaultPipeline) ); engine.StartPublishers(); return(engine); }) .As <ICqrsEngine>() .AutoActivate() .SingleInstance(); }
private CqrsEngine CreateEngine(IComponentContext ctx) { var logFactory = ctx.Resolve <ILogFactory>(); var messagingEngine = RegisterMessagingEngine(ctx); var defaultRetryDelay = (long)_settings.RetryDelay.TotalMilliseconds; const string defaultPipeline = "commands"; const string defaultRoute = "self"; const string eventsRoute = "evets"; var registration = new List <IRegistration>() { Register.DefaultEndpointResolver(GetDefaultEndpointResolver()), Register.BoundedContext(Self) .FailedCommandRetryDelay(defaultRetryDelay) .ListeningCommands(typeof(LockDepositWalletCommand)) .On(defaultRoute) .WithLoopback() //When it is sent not from saga .WithCommandsHandler <LockDepositWalletCommandsHandler>() .PublishingEvents(typeof(DepositWalletLockedEvent)) .With(defaultPipeline) .ListeningCommands(typeof(RetrieveClientCommand)) .On(defaultRoute) .WithCommandsHandler <RetrieveClientCommandHandler>() .PublishingEvents(typeof(ClientRetrievedEvent)) .With(defaultPipeline) .ListeningCommands(typeof(EnrollToMatchingEngineCommand)) .On(defaultRoute) .WithCommandsHandler <EnrollToMatchingEngineCommandsHandler>() .PublishingEvents(typeof(CashinEnrolledToMatchingEngineEvent)) .With(defaultPipeline) .ListeningCommands(typeof(SetEnrolledBalanceCommand)) .On(defaultRoute) .WithCommandsHandler <SetEnrolledBalanceCommandHandler>() .PublishingEvents(typeof(EnrolledBalanceSetEvent)) .With(defaultPipeline) .ListeningCommands(typeof(ResetEnrolledBalanceCommand)) .On(defaultRoute) .WithCommandsHandler <ResetEnrolledBalanceCommandHandler>() .PublishingEvents(typeof(EnrolledBalanceResetEvent)) .With(defaultPipeline) .ListeningCommands(typeof(ReleaseDepositWalletLockCommand)) .On(defaultRoute) .WithCommandsHandler <ReleaseDepositWalletLockCommandHandler>() .PublishingEvents(typeof(DepositWalletLockReleasedEvent)) .With(defaultPipeline) .ListeningCommands(typeof(NotifyCashinCompletedCommand)) .On(defaultRoute) .WithCommandsHandler <NotifyCashinCompletedCommandsHandler>() .PublishingEvents(typeof(CashinCompletedEvent)) .With(eventsRoute) .ListeningCommands(typeof(NotifyCashinFailedCommand)) .On(defaultRoute) .WithCommandsHandler <NotifyCashinFailedCommandsHandler>() .PublishingEvents(typeof(CashinFailedEvent)) .With(eventsRoute) .ListeningEvents(typeof(EnrolledBalanceSetEvent)) .From(Self) .On(eventsRoute) .WithProjection(typeof(MatchingEngineCallDeduplicationsProjection), Self) .ListeningEvents(typeof(BlockchainOperationsExecutor.Contract.Events.OperationExecutionCompletedEvent)) .From(BlockchainOperationsExecutorBoundedContext.Name) .On(eventsRoute) .WithProjection(typeof(MatchingEngineCallDeduplicationsProjection), BlockchainOperationsExecutorBoundedContext.Name) .ListeningEvents(typeof(BlockchainOperationsExecutor.Contract.Events.OperationExecutionFailedEvent)) .From(BlockchainOperationsExecutorBoundedContext.Name) .On(eventsRoute) .WithProjection(typeof(MatchingEngineCallDeduplicationsProjection), BlockchainOperationsExecutorBoundedContext.Name) .ProcessingOptions(defaultRoute).MultiThreaded(8).QueueCapacity(1024) .ProcessingOptions(eventsRoute).MultiThreaded(8).QueueCapacity(1024), Register.Saga <CashinSaga>($"{Self}.saga") .ListeningEvents(typeof(DepositWalletLockedEvent)) .From(Self) .On(defaultRoute) .PublishingCommands( typeof(RetrieveClientCommand), typeof(ReleaseDepositWalletLockCommand)) .To(Self) .With(defaultPipeline) .ListeningEvents(typeof(ClientRetrievedEvent)) .From(Self) .On(defaultRoute) .PublishingCommands(typeof(BlockchainRiskControl.Contract.Commands.ValidateOperationCommand)) .To(BlockchainRiskControl.Contract.BlockchainRiskControlBoundedContext.Name) .With(defaultPipeline) .ListeningEvents(typeof(BlockchainRiskControl.Contract.Events.OperationAcceptedEvent)) .From(BlockchainRiskControl.Contract.BlockchainRiskControlBoundedContext.Name) .On(defaultRoute) .PublishingCommands(typeof(EnrollToMatchingEngineCommand)) .To(Self) .With(defaultPipeline) .ListeningEvents(typeof(BlockchainRiskControl.Contract.Events.OperationRejectedEvent)) .From(BlockchainRiskControl.Contract.BlockchainRiskControlBoundedContext.Name) .On(defaultRoute) .PublishingCommands(typeof(ReleaseDepositWalletLockCommand)) .To(Self) .With(defaultPipeline) .ListeningEvents(typeof(CashinEnrolledToMatchingEngineEvent)) .From(Self) .On(defaultRoute) .PublishingCommands(typeof(SetEnrolledBalanceCommand)) .To(Self) .With(defaultPipeline) .ListeningEvents(typeof(EnrolledBalanceSetEvent)) .From(Self) .On(defaultRoute) .PublishingCommands(typeof(BlockchainOperationsExecutor.Contract.Commands.StartOperationExecutionCommand)) .To(BlockchainOperationsExecutorBoundedContext.Name) .With(defaultPipeline) .ListeningEvents(typeof(BlockchainOperationsExecutor.Contract.Events.OperationExecutionCompletedEvent)) .From(BlockchainOperationsExecutorBoundedContext.Name) .On(defaultRoute) .PublishingCommands(typeof(ResetEnrolledBalanceCommand)) .To(Self) .With(defaultPipeline) .ListeningEvents(typeof(EnrolledBalanceResetEvent)) .From(Self) .On(defaultRoute) .PublishingCommands(typeof(ReleaseDepositWalletLockCommand)) .To(Self) .With(defaultPipeline) .ListeningEvents(typeof(BlockchainOperationsExecutor.Contract.Events.OperationExecutionFailedEvent)) .From(BlockchainOperationsExecutorBoundedContext.Name) .On(defaultRoute) .ListeningEvents(typeof(DepositWalletLockReleasedEvent)) .From(Self) .On(defaultRoute) .PublishingCommands( typeof(NotifyCashinFailedCommand), typeof(NotifyCashinCompletedCommand)) .To(Self) .With(defaultPipeline) .ProcessingOptions(defaultRoute).MultiThreaded(8).QueueCapacity(1024), Register.BoundedContext(BlockchainRiskControl.Contract.BlockchainRiskControlBoundedContext.Name) .FailedCommandRetryDelay(defaultRetryDelay) .PublishingEvents(typeof(BlockchainRiskControl.Contract.Events.OperationRejectedEvent)) .With(eventsRoute) }; var interceptors = GetInterceptors(); if (interceptors != null) { registration.AddRange(interceptors); } var cqrsEngine = new CqrsEngine( logFactory, ctx.Resolve <IDependencyResolver>(), messagingEngine, new DefaultEndpointProvider(), true, registration.ToArray()); cqrsEngine.StartPublishers(); return(cqrsEngine); }
protected override void Load(ContainerBuilder builder) { string selfRoute = "self"; string commandsRoute = "commands"; string eventsRoute = "events"; MessagePackSerializerFactory.Defaults.FormatterResolver = MessagePack.Resolvers.ContractlessStandardResolver.Instance; var rabbitMqSagasSettings = new RabbitMQ.Client.ConnectionFactory { Uri = _sagasRabbitMq.CurrentValue.RabbitConnectionString }; builder.Register(context => new AutofacDependencyResolver(context)).As <IDependencyResolver>(); builder .RegisterType <ValidationCommandHandler>() .SingleInstance(); builder.Register(ctx => { var logFactory = ctx.Resolve <ILogFactory>(); return(new MessagingEngine( logFactory, new TransportResolver(new Dictionary <string, TransportInfo> { { "RabbitMq", new TransportInfo(rabbitMqSagasSettings.Endpoint.ToString(), rabbitMqSagasSettings.UserName, rabbitMqSagasSettings.Password, "None", "RabbitMq") } }), new RabbitMqTransportFactory(logFactory))); }) .As <IMessagingEngine>() .SingleInstance(); builder.Register(ctx => { var logFactory = ctx.Resolve <ILogFactory>(); var engine = new CqrsEngine(logFactory, ctx.Resolve <IDependencyResolver>(), ctx.Resolve <IMessagingEngine>(), new DefaultEndpointProvider(), true, Register.DefaultEndpointResolver(new RabbitMqConventionEndpointResolver( "RabbitMq", SerializationFormat.MessagePack, environment: "lykke", exclusiveQueuePostfix: "k8s")), Register.BoundedContext(ConfirmationCodesBoundedContext.Name) .ListeningCommands(typeof(ValidateConfirmationCommand)) .On(commandsRoute) .WithCommandsHandler <ValidationCommandHandler>() .PublishingEvents( typeof(ConfirmationValidationPassedEvent), typeof(ConfirmationValidationFailedEvent)) .With(eventsRoute) ); engine.StartPublishers(); return(engine); }) .As <ICqrsEngine>() .SingleInstance() .AutoActivate(); }
protected override void Load(ContainerBuilder builder) { MessagePackSerializerFactory.Defaults.FormatterResolver = MessagePack.Resolvers.ContractlessStandardResolver.Instance; var rabbitMqSettings = new RabbitMQ.Client.ConnectionFactory { Uri = _settings.CurrentValue.TierService.Cqrs.RabbitConnectionString }; builder.Register(context => new AutofacDependencyResolver(context)).As <IDependencyResolver>(); builder.Register(ctx => new MessagingEngine(ctx.Resolve <ILogFactory>(), new TransportResolver(new Dictionary <string, TransportInfo> { { "Transports", new TransportInfo(rabbitMqSettings.Endpoint.ToString(), rabbitMqSettings.UserName, rabbitMqSettings.Password, "None", "RabbitMq") } }), new RabbitMqTransportFactory(ctx.Resolve <ILogFactory>()))).As <IMessagingEngine>().SingleInstance(); builder.RegisterType <ClientDepositsSaga>(); builder.RegisterType <TierUpgradeRequestSaga>(); builder.RegisterType <KycStatusChangedProjection>(); builder.RegisterType <DepositOperationRemovedProjection>(); const string environment = "lykke"; const string queuePostfix = "k8s"; const string commandsRoute = "commands"; const string eventsRoute = "events"; const string selfRoute = "self"; builder.Register(ctx => { var engine = new CqrsEngine(ctx.Resolve <ILogFactory>(), ctx.Resolve <IDependencyResolver>(), ctx.Resolve <IMessagingEngine>(), new DefaultEndpointProvider(), true, Register.DefaultEndpointResolver(new RabbitMqConventionEndpointResolver( "Transports", SerializationFormat.MessagePack, environment: environment, exclusiveQueuePostfix: queuePostfix)), Register.EventInterceptors(new DefaultEventLoggingInterceptor(ctx.Resolve <ILogFactory>())), Register.BoundedContext(TierBoundedContext.Name) .PublishingEvents( typeof(TierUpgradeRequestChangedEvent), typeof(ClientDepositedEvent) ) .With(selfRoute) .ListeningEvents(typeof(KycStatusChangedEvent)) .From(KycBoundedContext.Name).On(eventsRoute) .WithProjection(typeof(KycStatusChangedProjection), KycBoundedContext.Name) .ListeningEvents(typeof(ClientOperationRemovedEvent)) .From(LimitationsBoundedContext.Name).On(eventsRoute) .WithProjection(typeof(DepositOperationRemovedProjection), LimitationsBoundedContext.Name), Register.Saga <TierUpgradeRequestSaga>("upgrade-request-saga") .ListeningEvents(typeof(TierUpgradeRequestChangedEvent)) .From(TierBoundedContext.Name).On(selfRoute) .PublishingCommands(typeof(TextNotificationCommand)).To(PushNotificationsBoundedContext.Name) .With(commandsRoute) .ProcessingOptions(commandsRoute).MultiThreaded(2).QueueCapacity(256), Register.Saga <ClientDepositsSaga>("client-deposits-saga") .ListeningEvents(typeof(ClientDepositedEvent)) .From(TierBoundedContext.Name).On(selfRoute) .PublishingCommands(typeof(TextNotificationCommand)).To(PushNotificationsBoundedContext.Name) .With(commandsRoute) .ProcessingOptions(commandsRoute).MultiThreaded(2).QueueCapacity(256) ); engine.StartPublishers(); return(engine); }) .As <ICqrsEngine>() .SingleInstance() .AutoActivate(); }
protected override void Load(ContainerBuilder builder) { builder.Register(context => new AutofacDependencyResolver(context)).As <IDependencyResolver>().SingleInstance(); var rabbitMqSettings = new RabbitMQ.Client.ConnectionFactory { Uri = new Uri(_settings.RabbitConnString) }; var rabbitMqEndpoint = rabbitMqSettings.Endpoint.ToString(); builder.Register(ctx => { var logFactory = ctx.Resolve <ILogFactory>(); return(new MessagingEngine( logFactory, new TransportResolver(new Dictionary <string, TransportInfo> { { "RabbitMq", new TransportInfo( rabbitMqEndpoint, rabbitMqSettings.UserName, rabbitMqSettings.Password, "None", "RabbitMq") } }), new RabbitMqTransportFactory(logFactory))); }); builder.Register(ctx => { const string defaultRoute = "self"; var logFactory = ctx.Resolve <ILogFactory>(); var cqrsEngine = new CqrsEngine( logFactory, ctx.Resolve <IDependencyResolver>(), ctx.Resolve <MessagingEngine>(), new DefaultEndpointProvider(), true, Register.DefaultEndpointResolver(new RabbitMqConventionEndpointResolver( "RabbitMq", Messaging.Serialization.SerializationFormat.ProtoBuf, environment: "lykke")), Register.CommandInterceptors(new DefaultCommandLoggingInterceptor(logFactory)), Register.EventInterceptors(new DefaultEventLoggingInterceptor(logFactory)), Register.BoundedContext(BoundedContext.Name) .PublishingEvents( typeof(FeeChargedEvent), typeof(CashInProcessedEvent), typeof(CashOutProcessedEvent), typeof(CashTransferProcessedEvent), typeof(ExecutionProcessedEvent), typeof(ManualOrderTradeProcessedEvent), typeof(OrderPlacedEvent), typeof(OrderCancelledEvent)) .With(defaultRoute), Register.DefaultRouting); cqrsEngine.StartPublishers(); return(cqrsEngine); }) .As <ICqrsEngine>() .AutoActivate() .SingleInstance(); }
protected override void Load(ContainerBuilder builder) { if (_settings.ChaosKitty != null) { builder .RegisterType <ChaosKitty>() .WithParameter(TypedParameter.From(_settings.ChaosKitty.StateOfChaos)) .As <IChaosKitty>() .SingleInstance(); } else { builder .RegisterType <SilentChaosKitty>() .As <IChaosKitty>() .SingleInstance(); } MessagePackSerializerFactory.Defaults.FormatterResolver = MessagePack.Resolvers.ContractlessStandardResolver.Instance; builder.Register(context => new AutofacDependencyResolver(context)).As <IDependencyResolver>().SingleInstance(); var rabbitMqSettings = new RabbitMQ.Client.ConnectionFactory { Uri = _settings.CqrsRabbitConnString }; builder.RegisterType <ApiKeyProjection>() .WithParameter( new ResolvedParameter( (pi, ctx) => pi.ParameterType == typeof(IDistributedCache), (pi, ctx) => ctx.ResolveKeyed <IDistributedCache>(_settings.Cache.ApiKeyCacheInstance))); 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)); const string defaultRoute = "self"; var cqrsEngine = new CqrsEngine(logFactory, ctx.Resolve <IDependencyResolver>(), messagingEngine, new DefaultEndpointProvider(), true, Register.DefaultEndpointResolver(new RabbitMqConventionEndpointResolver( "RabbitMq", SerializationFormat.MessagePack, environment: "lykke", exclusiveQueuePostfix: _settings.QueuePostfix)), Register.EventInterceptors(new DefaultEventLoggingInterceptor(ctx.Resolve <ILogFactory>())), Register.BoundedContext("hft-api") .ListeningEvents( typeof(ApiKeyUpdatedEvent)) .From("api-key").On(defaultRoute) .WithProjection(typeof(ApiKeyProjection), "api-key") .WithAssetsReadModel(route: System.Environment.MachineName) ); cqrsEngine.StartPublishers(); return(cqrsEngine); }) .As <ICqrsEngine>() .AutoActivate() .SingleInstance(); }
protected override void Load(ContainerBuilder builder) { Messaging.Serialization.MessagePackSerializerFactory.Defaults.FormatterResolver = MessagePack.Resolvers.ContractlessStandardResolver.Instance; var rabbitMqSettings = new RabbitMQ.Client.ConnectionFactory { Uri = _settings.CurrentValue.SagasRabbitMqSettings.ConnectionString }; builder.Register(context => new AutofacDependencyResolver(context)).As <IDependencyResolver>().SingleInstance(); builder.Register(c => new MessagingEngine(_log, new TransportResolver(new Dictionary <string, TransportInfo> { { "RabbitMq", new TransportInfo(rabbitMqSettings.Endpoint.ToString(), rabbitMqSettings.UserName, rabbitMqSettings.Password, "None", "RabbitMq") } }), new RabbitMqTransportFactory())) .As <IMessagingEngine>(); builder.RegisterType <ConfirmationCommandHandler>(); builder.RegisterType <AssetsProjection>(); builder.RegisterType <HistoryExportProjection>(); builder.RegisterType <OperationsProjection>(); builder.RegisterType <MarketDataProjection>() .WithParameter(TypedParameter.From(_settings.CurrentValue.CacheSettings.MarketDataCacheInterval)); var protobufEndpointResolver = new RabbitMqConventionEndpointResolver( "RabbitMq", SerializationFormat.ProtoBuf, environment: "lykke", exclusiveQueuePostfix: _env); builder.Register(ctx => { const string defaultRoute = "self"; var engine = new CqrsEngine( _log, ctx.Resolve <IDependencyResolver>(), ctx.Resolve <IMessagingEngine>(), new DefaultEndpointProvider(), true, Register.DefaultEndpointResolver(new RabbitMqConventionEndpointResolver( "RabbitMq", SerializationFormat.MessagePack, environment: "lykke", exclusiveQueuePostfix: _env)), Register.BoundedContext(WampHostBoundedContext.Name) .ListeningEvents( typeof(AssetCreatedEvent), typeof(AssetUpdatedEvent), typeof(AssetPairCreatedEvent), typeof(AssetPairUpdatedEvent)) .From(BoundedContexts.Assets).On(defaultRoute) .WithProjection(typeof(AssetsProjection), BoundedContexts.Assets) .ListeningEvents( typeof(ClientHistoryExportedEvent)) .From(HistoryExportBuilderBoundedContext.Name).On(defaultRoute) .WithProjection(typeof(HistoryExportProjection), HistoryExportBuilderBoundedContext.Name) .ListeningEvents(typeof(OperationFailedEvent), typeof(OperationConfirmedEvent), typeof(OperationCompletedEvent), typeof(OperationCorruptedEvent)) .From(OperationsBoundedContext.Name).On(defaultRoute) .WithProjection(typeof(OperationsProjection), OperationsBoundedContext.Name) .ListeningEvents(typeof(MarketDataChangedEvent)) .From(MarketDataBoundedContext.Name).On(defaultRoute) .WithProjection(typeof(MarketDataProjection), MarketDataBoundedContext.Name) .ListeningCommands(typeof(RequestConfirmationCommand)).On("commands") .WithEndpointResolver(protobufEndpointResolver) .WithCommandsHandler <ConfirmationCommandHandler>() ); engine.StartPublishers(); return(engine); }) .As <ICqrsEngine>() .SingleInstance() .AutoActivate(); }