Пример #1
1
        static void InitializeENodeFramework()
        {
            var setting = new ConfigurationSetting
            {
                SqlDefaultConnectionString = ConfigurationManager.AppSettings["connectionString"],
                EnableGroupCommitEvent = false
            };
            var assemblies = new[]
            {
                Assembly.Load("NoteSample.Domain"),
                Assembly.Load("NoteSample.CommandHandlers"),
                Assembly.Load("NoteSample.Commands"),
                Assembly.GetExecutingAssembly()
            };
            _configuration = ECommonConfiguration
                .Create()
                .UseAutofac()
                .RegisterCommonComponents()
                .UseLog4Net()
                .UseJsonNet()
                .RegisterUnhandledExceptionHandler()
                .CreateENode(setting)
                .RegisterENodeComponents()
                .UseSqlServerEventStore()
                .RegisterBusinessComponents(assemblies)
                .InitializeBusinessAssemblies(assemblies)
                .UseEQueue()
                .StartEQueue();

            _commandService = ObjectContainer.Resolve<ICommandService>();
            _memoryCache = ObjectContainer.Resolve<IMemoryCache>();
        }
Пример #2
0
        static void InitializeENodeFramework()
        {
            var assemblies = new[]
            {
                Assembly.Load("NoteSample.Domain"),
                Assembly.Load("NoteSample.Commands"),
                Assembly.Load("NoteSample.CommandHandlers"),
                Assembly.GetExecutingAssembly()
            };
            _configuration = Configuration
                .Create()
                .UseAutofac()
                .RegisterCommonComponents()
                .UseLog4Net()
                .UseJsonNet()
                .RegisterUnhandledExceptionHandler()
                .CreateENode()
                .RegisterENodeComponents()
                .RegisterBusinessComponents(assemblies)
                .UseEQueue()
                .InitializeBusinessAssemblies(assemblies)
                .StartEQueue();

            Console.WriteLine(string.Empty);

            _logger = ObjectContainer.Resolve<ILoggerFactory>().Create(typeof(Program).Name);
            _logger.Info("ENode started...");
        }
Пример #3
0
        static void InitializeENodeFramework()
        {
            var setting = new ConfigurationSetting
            {
                SqlDefaultConnectionString = ConfigurationManager.AppSettings["connectionString"],
                EnableGroupCommitEvent = true
            };
            var assemblies = new[]
            {
                Assembly.Load("NoteSample.Domain")
            };
            _configuration = ECommonConfiguration
                .Create()
                .UseAutofac()
                .RegisterCommonComponents()
                .UseLog4Net()
                .UseJsonNet()
                .RegisterUnhandledExceptionHandler()
                .CreateENode(setting)
                .RegisterENodeComponents()
                .RegisterAllTypeCodes()
                .UseSqlServerEventStore()
                .RegisterBusinessComponents(assemblies)
                .InitializeBusinessAssemblies(assemblies);

            Console.WriteLine("ENode started...");
        }
        private void InitializeENode()
        {
            var assemblies = new[]
            {
                Assembly.Load("Int.AC"),
                Assembly.Load("Int.AC.CommandHandlers"),
                Assembly.Load("Int.AC.ReadModel"),
                Assembly.Load("Int.UITest")
            };
            string dbConfig = System.Configuration.ConfigurationManager.ConnectionStrings["IntDbConn"].ConnectionString;
            var setting = new ConfigurationSetting { SqlServerDefaultConnectionString = dbConfig };
            _enodeConfiguration = _ecommonConfiguration
                .CreateENode(setting)
                .RegisterENodeComponents()
                .RegisterBusinessComponents(assemblies)
                .UseSqlServerCommandStore()
                .UseSqlServerEventStore()
                .UseEQueue()
                .InitializeBusinessAssemblies(assemblies)
                .StartENode(NodeType.CommandProcessor | NodeType.EventProcessor | NodeType.ExceptionProcessor)
                .StartEQueue();

            RegisterControllers();
            _logger.Info("ENode initialized.");
        }
Пример #5
0
        private void InitializeENode()
        {
            ConfigSettings.Initialize();

            var assemblies = new[]
            {
                Assembly.Load("Registration.Commands"),
                Assembly.Load("Registration.Domain"),
                Assembly.Load("Registration.ReadModel"),
                Assembly.Load("Payments.Commands"),
                Assembly.Load("Payments.ReadModel"),
                Assembly.GetExecutingAssembly()
            };

            _enodeConfiguration = _ecommonConfiguration
                .CreateENode()
                .RegisterENodeComponents()
                .RegisterBusinessComponents(assemblies)
                .UseEQueue()
                .InitializeBusinessAssemblies(assemblies)
                .StartEQueue();

            RegisterControllers();
            _logger.Info("ENode initialized.");
        }
Пример #6
0
        private static void InitializeENode(
            bool useMockCommandStore = false,
            bool useMockEventStore = false,
            bool useMockPublishedVersionStore = false,
            bool useMockDomainEventPublisher = false,
            bool useMockApplicationMessagePublisher = false,
            bool useMockPublishableExceptionPublisher = false)
        {
            var setting = new ConfigurationSetting(ConfigurationManager.AppSettings["connectionString"]);
            var assemblies = new[]
            {
                Assembly.GetExecutingAssembly()
            };

            _enodeConfiguration = ECommonConfiguration
                .Create()
                .UseAutofac()
                .RegisterCommonComponents()
                .UseLog4Net()
                .UseJsonNet()
                .RegisterUnhandledExceptionHandler()
                .CreateENode(setting)
                .RegisterENodeComponents()
                .UseCommandStore(useMockCommandStore)
                .UseEventStore(useMockEventStore)
                .UsePublishedVersionStore(useMockPublishedVersionStore)
                .RegisterBusinessComponents(assemblies)
                .InitializeBusinessAssemblies(assemblies)
                .UseEQueue(useMockDomainEventPublisher, useMockApplicationMessagePublisher, useMockPublishableExceptionPublisher)
                .StartEQueue();

            _commandService = ObjectContainer.Resolve<ICommandService>();
            _memoryCache = ObjectContainer.Resolve<IMemoryCache>();
            _commandStore = ObjectContainer.Resolve<ICommandStore>();
            _eventStore = ObjectContainer.Resolve<IEventStore>();
            _publishedVersionStore = ObjectContainer.Resolve<IPublishedVersionStore>();
            _domainEventPublisher = ObjectContainer.Resolve<IMessagePublisher<DomainEventStreamMessage>>();
            _applicationMessagePublisher = ObjectContainer.Resolve<IMessagePublisher<IApplicationMessage>>();
            _publishableExceptionPublisher = ObjectContainer.Resolve<IMessagePublisher<IPublishableException>>();
            _logger = ObjectContainer.Resolve<ILoggerFactory>().Create(typeof(BaseTest));
            _logger.Info("ENode initialized.");
        }
Пример #7
0
        private void InitializeENode()
        {
            ConfigSettings.Initialize();

            var assemblies = new[]
            {
                Assembly.Load("ConferenceManagement.ReadModel"),
                Assembly.Load("ConferenceManagement.Web")
            };

            _enodeConfiguration = _ecommonConfiguration
                .CreateENode()
                .RegisterENodeComponents()
                .RegisterBusinessComponents(assemblies)
                .RegisterAllTypeCodes()
                .UseEQueue()
                .InitializeBusinessAssemblies(assemblies)
                .StartEQueue();

            RegisterControllers();
            _logger.Info("ENode initialized.");
        }
Пример #8
0
        static void InitializeENodeFramework()
        {
            var assemblies = new[]
            {
                Assembly.Load("NoteSample.Domain"),
                Assembly.Load("NoteSample.Commands"),
                Assembly.Load("NoteSample.CommandHandlers"),
                Assembly.Load("NoteSample.Denormalizers"),
                Assembly.GetExecutingAssembly()
            };
            var setting = new ConfigurationSetting
            {
                SqlDefaultConnectionString = ConfigSettings.ConnectionString
            };

            _configuration = Configuration
                .Create()
                .UseAutofac()
                .RegisterCommonComponents()
                .UseLog4Net()
                .UseJsonNet()
                .RegisterUnhandledExceptionHandler()
                .CreateENode(setting)
                .RegisterENodeComponents()
                .RegisterBusinessComponents(assemblies)
                .UseSqlServerCommandStore()
                .UseSqlServerEventStore()
                .UseSqlServerSequenceMessagePublishedVersionStore()
                .UseSqlServerMessageHandleRecordStore()
                .UseEQueue()
                .InitializeBusinessAssemblies(assemblies)
                .StartEQueue();

            Console.WriteLine(string.Empty);

            _logger = ObjectContainer.Resolve<ILoggerFactory>().Create(typeof(Program).Name);
            _logger.Info("ENode started...");
        }
Пример #9
0
        static void InitializeENodeFramework()
        {
            var assemblies = new[]
            {
                Assembly.Load("NoteSample.Domain"),
                Assembly.GetExecutingAssembly()
            };
            _configuration = Configuration
                .Create()
                .UseAutofac()
                .RegisterCommonComponents()
                .UseLog4Net()
                .UseJsonNet()
                .RegisterUnhandledExceptionHandler()
                .CreateENode()
                .RegisterENodeComponents()
                .RegisterBusinessComponents(assemblies)
                .InitializeBusinessAssemblies(assemblies)
                .UseEQueue()
                .StartEQueue();

            Console.WriteLine("ENode started...");
        }
Пример #10
0
        private void InitializeENode()
        {
            ConfigSettings.Initialize();

            var assemblies = new[]
            {
                Assembly.Load("Forum.Commands"),
                Assembly.Load("Forum.QueryServices"),
                Assembly.Load("Forum.QueryServices.Dapper"),
                Assembly.Load("Forum.Web")
            };

            _enodeConfiguration = _ecommonConfiguration
                .CreateENode()
                .RegisterENodeComponents()
                .RegisterBusinessComponents(assemblies)
                .UseEQueue()
                .InitializeBusinessAssemblies(assemblies)
                .StartEQueue();

            RegisterControllers();
            _logger.Info("ENode initialized.");
        }
Пример #11
0
        private static void InitializeENode()
        {
            var assemblies = new[]
            {
                Assembly.Load("Forum.Infrastructure"),
                Assembly.Load("Forum.Commands"),
                Assembly.Load("Forum.Domain"),
                Assembly.Load("Forum.Domain.Dapper"),
                Assembly.Load("Forum.CommandHandlers"),
                Assembly.Load("Forum.Denormalizers.Dapper"),
                Assembly.Load("Forum.ProcessManagers"),
                Assembly.Load("Forum.QueryServices"),
                Assembly.Load("Forum.QueryServices.Dapper"),
                Assembly.Load("Forum.Tests")
            };

            var setting = new ConfigurationSetting(ConfigSettings.ENodeConnectionString);

            _enodeConfiguration = Configuration
                                  .Create()
                                  .UseAutofac()
                                  .RegisterCommonComponents()
                                  .UseLog4Net()
                                  .UseJsonNet()
                                  .RegisterUnhandledExceptionHandler()
                                  .CreateENode(setting)
                                  .RegisterENodeComponents()
                                  .RegisterBusinessComponents(assemblies)
                                  .UseSqlServerLockService()
                                  .UseSqlServerCommandStore()
                                  .UseSqlServerEventStore()
                                  .UseSqlServerPublishedVersionStore()
                                  .UseEQueue()
                                  .InitializeBusinessAssemblies(assemblies)
                                  .StartEQueue();
        }
Пример #12
0
        static void InitializeENodeFramework()
        {
            var assemblies = new[]
            {
                Assembly.Load("NoteSample.Domain"),
                Assembly.GetExecutingAssembly()
            };

            _configuration = Configuration
                             .Create()
                             .UseAutofac()
                             .RegisterCommonComponents()
                             .UseLog4Net()
                             .UseJsonNet()
                             .RegisterUnhandledExceptionHandler()
                             .CreateENode()
                             .RegisterENodeComponents()
                             .RegisterBusinessComponents(assemblies)
                             .InitializeBusinessAssemblies(assemblies)
                             .UseEQueue()
                             .StartEQueue();

            Console.WriteLine("ENode started...");
        }
Пример #13
0
        /// <summary>
        /// 初始化ENode
        /// </summary>
        private static void InitializeENode()
        {
            ConfigSettings.Initialize();

            var assemblies = new[]
            {
                Assembly.Load("Shop.Commands"),
                Assembly.Load("Shop.Domain"),
                Assembly.Load("Shop.ReadModel"),

                Assembly.GetExecutingAssembly()
            };

            var setting = new ConfigurationSetting(ConfigSettings.ENodeConnectionString);

            _enodeConfiguration = _ecommonConfiguration
                                  .CreateENode(setting)
                                  .RegisterENodeComponents()//注册ENode的所有默认实现组件以及给定程序集中的所有标记了Component特性的组件到容器
                                  .RegisterBusinessComponents(assemblies)
                                  .UseEQueue()
                                  .InitializeBusinessAssemblies(assemblies);
            //应该将组件注入到AOC容器
            _logger.Info("ENode initialized.");
        }
Пример #14
0
        public static ENodeConfiguration UseEQueue(this ENodeConfiguration enodeConfiguration)
        {
            var configuration = enodeConfiguration.GetCommonConfiguration();

            configuration.RegisterEQueueComponents();

            _broker = BrokerController.Create();

            _commandResultProcessor = new CommandResultProcessor(new IPEndPoint(SocketUtils.GetLocalIPV4(), 9000));
            _commandService         = new CommandService(_commandResultProcessor);
            _eventPublisher         = new DomainEventPublisher();

            configuration.SetDefault <ICommandService, CommandService>(_commandService);
            configuration.SetDefault <IMessagePublisher <DomainEventStreamMessage>, DomainEventPublisher>(_eventPublisher);

            //注意,这里实例化之前,需要确保各种MessagePublisher要先注入到IOC,因为CommandConsumer, DomainEventConsumer都依赖于IMessagePublisher<T>
            _commandConsumer = new CommandConsumer();
            _eventConsumer   = new DomainEventConsumer();

            _commandConsumer.Subscribe("NoteCommandTopic");
            _eventConsumer.Subscribe("NoteEventTopic");

            return(enodeConfiguration);
        }
Пример #15
0
        public static ENodeConfiguration StartEQueue(this ENodeConfiguration enodeConfiguration)
        {
            if (_isEQueueStarted)
            {
                _commandService.InitializeENode();
                _eventPublisher.InitializeENode();
                _applicationMessagePublisher.InitializeENode();
                _domainExceptionPublisher.InitializeENode();

                _commandConsumer.InitializeENode();
                _eventConsumer.InitializeENode();
                _applicationMessageConsumer.InitializeENode();
                _domainExceptionConsumer.InitializeENode();

                return(enodeConfiguration);
            }

            var brokerStorePath = @"d:\equeue-store-enode-ut";
            var brokerSetting   = new BrokerSetting(chunkFileStoreRootPath: brokerStorePath);

            if (Directory.Exists(brokerStorePath))
            {
                Directory.Delete(brokerStorePath, true);
            }

            _nameServerController = new NameServerController();
            _broker = BrokerController.Create(brokerSetting);

            _commandService.InitializeEQueue(new CommandResultProcessor().Initialize(new IPEndPoint(SocketUtils.GetLocalIPV4(), 9001)));
            _eventPublisher.InitializeEQueue();
            _applicationMessagePublisher.InitializeEQueue();
            _domainExceptionPublisher.InitializeEQueue();

            _commandConsumer = new CommandConsumer().InitializeEQueue(setting: new ConsumerSetting {
                ConsumeFromWhere = ConsumeFromWhere.LastOffset
            }).Subscribe("CommandTopic");
            _eventConsumer = new DomainEventConsumer().InitializeEQueue(setting: new ConsumerSetting {
                ConsumeFromWhere = ConsumeFromWhere.LastOffset
            }).Subscribe("EventTopic");
            _applicationMessageConsumer = new ApplicationMessageConsumer().InitializeEQueue(setting: new ConsumerSetting {
                ConsumeFromWhere = ConsumeFromWhere.LastOffset
            }).Subscribe("ApplicationMessageTopic");
            _domainExceptionConsumer = new DomainExceptionConsumer().InitializeEQueue(setting: new ConsumerSetting {
                ConsumeFromWhere = ConsumeFromWhere.LastOffset
            }).Subscribe("DomainExceptionTopic");
            _nameServerSocketRemotingClient = new SocketRemotingClient("NameServerRemotingClient", new IPEndPoint(SocketUtils.GetLocalIPV4(), 9493));

            _nameServerController.Start();
            _broker.Start();
            _eventConsumer.Start();
            _commandConsumer.Start();
            _applicationMessageConsumer.Start();
            _domainExceptionConsumer.Start();
            _applicationMessagePublisher.Start();
            _domainExceptionPublisher.Start();
            _eventPublisher.Start();
            _commandService.Start();
            _nameServerSocketRemotingClient.Start();

            CreateTopic(Constants.CommandTopic);
            CreateTopic(Constants.EventTopic);
            CreateTopic(Constants.ApplicationMessageTopic);
            CreateTopic(Constants.ExceptionTopic);
            WaitAllProducerTopicQueuesAvailable();
            WaitAllConsumerLoadBalanceComplete();

            _isEQueueStarted = true;

            return(enodeConfiguration);
        }
Пример #16
0
        private static void InitializeENode()
        {
            ConfigSettings.Initialize();

            var assemblies = new[]
            {
                Assembly.Load("Conference.Common"),
                Assembly.Load("Payments.Commands"),
                Assembly.Load("Payments.Domain"),
                Assembly.Load("Payments.Messages"),
                Assembly.Load("Payments.CommandHandlers"),
                Assembly.Load("Payments.MessagePublishers"),
                Assembly.Load("Payments.ReadModel"),
                Assembly.GetExecutingAssembly()
            };
            var setting = new ConfigurationSetting
            {
                SqlDefaultConnectionString = ConfigSettings.ConferenceENodeConnectionString
            };

            _enodeConfiguration = _ecommonConfiguration
                .CreateENode(setting)
                .RegisterENodeComponents()
                .RegisterBusinessComponents(assemblies)
                .UseSqlServerLockService()
                .UseSqlServerCommandStore()
                .UseSqlServerEventStore()
                .UseSqlServerSequenceMessagePublishedVersionStore()
                .UseSqlServerMessageHandleRecordStore()
                .UseEQueue()
                .InitializeBusinessAssemblies(assemblies);
            _logger.Info("ENode initialized.");
        }
Пример #17
0
        static void PerformanceTest()
        {
            var assemblies = new[] { Assembly.GetExecutingAssembly() };

            _configuration = Configuration
                .Create()
                .UseAutofac()
                .RegisterCommonComponents()
                .UseLog4Net()
                .UseJsonNet()
                .RegisterUnhandledExceptionHandler()
                .CreateENode()
                .RegisterENodeComponents()
                .RegisterAllTypeCodes()
                .RegisterBusinessComponents(assemblies)
                .UseEQueue()
                .InitializeBusinessAssemblies(assemblies)
                .StartEQueue();

            Console.WriteLine(string.Empty);
            Console.WriteLine("ENode started...");

            var commandService = ObjectContainer.Resolve<ICommandService>();
            var syncHelper = ObjectContainer.Resolve<SyncHelper>();
            var countSyncHelper = ObjectContainer.Resolve<CountSyncHelper>();

            Console.WriteLine(string.Empty);

            var accountList = new List<string>();
            var accountCount = 100;
            var transactionCount = 100;
            var depositAmount = 100000D;
            var transferAmount = 1000D;

            //创建银行账户
            for (var i = 0; i < accountCount; i++)
            {
                var accountId = ObjectId.GenerateNewStringId();
                commandService.ExecuteAsync(new CreateAccountCommand(accountId, "SampleAccount" + i), CommandReturnType.EventHandled).Wait();
                accountList.Add(accountId);
            }

            Console.WriteLine(string.Empty);

            //每个账户都存入初始额度
            foreach (var accountId in accountList)
            {
                commandService.Send(new StartDepositTransactionCommand(ObjectId.GenerateNewStringId(), accountId, depositAmount));
                syncHelper.WaitOne();
            }

            Console.WriteLine(string.Empty);

            countSyncHelper.SetExpectedCount((int)transactionCount);

            var watch = Stopwatch.StartNew();
            for (var i = 0; i < transactionCount; i++)
            {
                var sourceAccountIndex = new Random().Next(accountCount - 1);
                var targetAccountIndex = sourceAccountIndex + 1;
                var sourceAccount = accountList[sourceAccountIndex];
                var targetAccount = accountList[targetAccountIndex];
                commandService.SendAsync(new StartTransferTransactionCommand(ObjectId.GenerateNewStringId(), new TransferTransactionInfo(sourceAccount, targetAccount, transferAmount)));
            }

            countSyncHelper.WaitOne();

            var spentTime = watch.ElapsedMilliseconds;
            Thread.Sleep(500);
            Console.WriteLine(string.Empty);
            Console.WriteLine("All transfer transactions completed, time spent: {0}ms, throughput: {1} transactions per second.", spentTime, transactionCount * 1000 / spentTime);
            Console.WriteLine("Press Enter to exit...");
            Console.ReadLine();
            _configuration.ShutdownEQueue();
        }
Пример #18
0
 /// <summary>
 /// Use the RedisLockService as the ILockService.
 /// </summary>
 /// <returns></returns>
 public static ENodeConfiguration UseRedisLockService(this ENodeConfiguration eNodeConfiguration)
 {
     eNodeConfiguration.GetCommonConfiguration().SetDefault <ILockService, RedisLockService>();
     return(eNodeConfiguration);
 }
Пример #19
0
        public static ENodeConfiguration StartRabbitMQ(this ENodeConfiguration enodeConfiguration)
        {
            var amqpUri    = new Uri("amqp://*****:*****@localhost/test");
            var clientName = "BankTransferSample";

            _commandService.InitializeRabbitMQ(new ProducerSettings
            {
                AmqpUri    = amqpUri,
                ClientName = clientName
            },
                                               new string[] { Constants.CommandTopic },
                                               new CommandResultProcessor().Initialize(new IPEndPoint(SocketUtils.GetLocalIPV4(), 9000)));
            _applicationMessagePublisher.InitializeRabbitMQ(new ProducerSettings
            {
                AmqpUri    = amqpUri,
                ClientName = clientName
            },
                                                            new string[] { Constants.ApplicationMessageTopic });
            _domainEventPublisher.InitializeRabbitMQ(new ProducerSettings
            {
                AmqpUri    = amqpUri,
                ClientName = clientName
            },
                                                     new string[] { Constants.EventTopic });
            _exceptionPublisher.InitializeRabbitMQ(new ProducerSettings
            {
                AmqpUri    = amqpUri,
                ClientName = clientName
            },
                                                   new string[] { Constants.ExceptionTopic });

            _commandConsumer = new CommandConsumer().InitializeRabbitMQ(new ConsumerSettings
            {
                AmqpUri       = amqpUri,
                ClientName    = clientName,
                Mode          = ConsumeMode.Pull,
                PrefetchCount = (ushort)ENode.Configurations.ENodeConfiguration.Instance.Setting.EventMailBoxPersistenceMaxBatchSize
            }).Subscribe(Constants.CommandTopic);
            _applicationMessageConsumer = new ApplicationMessageConsumer().InitializeRabbitMQ(new ConsumerSettings
            {
                AmqpUri       = amqpUri,
                ClientName    = clientName,
                Mode          = ConsumeMode.Pull,
                PrefetchCount = (ushort)ENode.Configurations.ENodeConfiguration.Instance.Setting.EventMailBoxPersistenceMaxBatchSize
            }).Subscribe(Constants.ApplicationMessageTopic);
            _eventConsumer = new DomainEventConsumer().InitializeRabbitMQ(new ConsumerSettings
            {
                AmqpUri       = amqpUri,
                ClientName    = clientName,
                Mode          = ConsumeMode.Pull,
                PrefetchCount = (ushort)ENode.Configurations.ENodeConfiguration.Instance.Setting.EventMailBoxPersistenceMaxBatchSize
            }).Subscribe(Constants.EventTopic);
            _exceptionConsumer = new DomainExceptionConsumer().InitializeRabbitMQ(new ConsumerSettings
            {
                AmqpUri       = amqpUri,
                ClientName    = clientName,
                Mode          = ConsumeMode.Pull,
                PrefetchCount = (ushort)ENode.Configurations.ENodeConfiguration.Instance.Setting.EventMailBoxPersistenceMaxBatchSize
            }).Subscribe(Constants.ExceptionTopic);

            _exceptionConsumer.Start();
            _eventConsumer.Start();
            _applicationMessageConsumer.Start();
            _commandConsumer.Start();
            _applicationMessagePublisher.Start();
            _domainEventPublisher.Start();
            _exceptionPublisher.Start();
            _commandService.Start();

            return(enodeConfiguration);
        }
Пример #20
0
 /// <summary>Use the SqlServerEventStore as the IEventStore.
 /// </summary>
 /// <returns></returns>
 public static ENodeConfiguration UseSqlServerEventStore(this ENodeConfiguration eNodeConfiguration)
 {
     eNodeConfiguration.GetCommonConfiguration().SetDefault <IEventStore, SqlServerEventStore>();
     return(eNodeConfiguration);
 }
Пример #21
0
 public static ENodeConfiguration StartEQueue(this ENodeConfiguration enodeConfiguration)
 {
     _broker.Start();
     _eventPublisher.Start();
     return(enodeConfiguration);
 }
Пример #22
0
        private void InitializeENode()
        {
            string dbConfig = System.Configuration.ConfigurationManager.ConnectionStrings["IntDbConn"].ConnectionString;

            var assemblies = new[]
            {
                Assembly.Load("Int.AC"),
                Assembly.Load("Int.AC.CommandHandlers"),
                Assembly.Load("Int.PM"),
                Assembly.Load("Int.PM.CommandHandlers")
            };
            var setting = new ConfigurationSetting
            {
                SqlServerDefaultConnectionString = dbConfig
            };

            _enodeConfiguration = _baseConfiguration
                .CreateENode(setting)
                .RegisterENodeComponents()
                .RegisterBusinessComponents(assemblies)
                .SetProviders()
                .UseSqlServerLockService()
                .UseSqlServerCommandStore()
                .UseSqlServerEventStore()
                .UseSqlServerEventPublishInfoStore()
                .UseSqlServerEventHandleInfoStore()
                .UseEQueue()
                .InitializeBusinessAssemblies(assemblies);
        }
Пример #23
0
        public static ENodeConfiguration StartKafka(this ENodeConfiguration enodeConfiguration)
        {
            var kafkaConfig = ObjectContainer.Resolve <Jane.ENode.IKafkaConfiguration>();

            var producerSetting = new ProducerSetting
            {
                BrokerEndPoints = kafkaConfig.BrokerEndPoints
            };
            var commandConsumerSetting = new ConsumerSetting
            {
                BrokerEndPoints = kafkaConfig.BrokerEndPoints,
                GroupName       = "BoundedContextCommandConsumerGroup"
            };
            var eventConsumerSetting = new ConsumerSetting
            {
                BrokerEndPoints = kafkaConfig.BrokerEndPoints,
                GroupName       = "BoundedContextDomainEventConsumerGroup"
            };
            var applicationMessageConsumerSetting = new ConsumerSetting
            {
                BrokerEndPoints = kafkaConfig.BrokerEndPoints,
                GroupName       = "BoundedContextApplicationMessageConsumerGroup"
            };
            var domainExceptionConsumerSetting = new ConsumerSetting
            {
                BrokerEndPoints = kafkaConfig.BrokerEndPoints,
                GroupName       = "BoundedContextDomainExceptionConsumerGroup"
            };

            _commandConsumer = new CommandConsumer()
                               .InitializeKafka(commandConsumerSetting)
                               .Subscribe(new List <string>()
            {
                BoundedContextTopics.BoundedContextDomainCommandTopic
            });
            _eventConsumer = new DomainEventConsumer()
                             .InitializeKafka(eventConsumerSetting)
                             .Subscribe(new List <string>()
            {
                BoundedContextTopics.BoundedContextDomainDomainEventTopic
            });
            _applicationMessageConsumer = new ApplicationMessageConsumer()
                                          .InitializeKafka(applicationMessageConsumerSetting)
                                          .Subscribe(new List <string>()
            {
                BoundedContextTopics.BoundedContextDomainApplicationMessageTopic
            });
            _domainExceptionConsumer = new DomainExceptionConsumer()
                                       .InitializeKafka(domainExceptionConsumerSetting)
                                       .Subscribe(new List <string>()
            {
                BoundedContextTopics.BoundedContextDomainExceptionTopic
            });

            _commandResultProcessor = new CommandResultProcessor()
                                      .Initialize(new IPEndPoint(SocketUtils.GetLocalIPV4(), 9003));
            _commandService.InitializeKafka(producerSetting, _commandResultProcessor);
            _eventPublisher.InitializeKafka(producerSetting);
            _applicationMessagePublisher.InitializeKafka(producerSetting);
            _domainExceptionPublisher.InitializeKafka(producerSetting);

            _commandConsumer.Start();
            _eventConsumer.Start();
            _applicationMessageConsumer.Start();
            _domainExceptionConsumer.Start();

            _commandResultProcessor.Start();
            _commandService.Start();
            _eventPublisher.Start();
            _applicationMessagePublisher.Start();
            _domainExceptionPublisher.Start();

            return(enodeConfiguration);
        }
 /// <summary>Use the MySqlEventStore as the IEventStore.
 /// </summary>
 /// <returns></returns>
 public static ENodeConfiguration UseMySqlEventStore(this ENodeConfiguration configuration, OptionSetting optionSetting = null)
 {
     Configuration.SetDefault <IEventStore, MySqlEventStore>(new MySqlEventStore(optionSetting));
     return(configuration);
 }
 /// <summary>Use the MySqlLockService as the ILockService.
 /// </summary>
 /// <returns></returns>
 public static ENodeConfiguration UseMySqlLockService(this ENodeConfiguration configuration,
                                                      OptionSetting optionSetting = null)
 {
     Configuration.SetDefault <ILockService, MySqlLockService>(new MySqlLockService(optionSetting));
     return(configuration);
 }
Пример #26
0
 /// <summary>Use the PostgresPublishedVersionStore as the IPublishedVersionStore.
 /// </summary>
 /// <returns></returns>
 public static ENodeConfiguration UsePostgresPublishedVersionStore(this ENodeConfiguration eNodeConfiguration)
 {
     eNodeConfiguration.GetCommonConfiguration().SetDefault <IPublishedVersionStore, PostgresPublishedVersionStore>();
     return(eNodeConfiguration);
 }
Пример #27
0
 /// <summary>Use the PostgresEventStore as the IEventStore.
 /// </summary>
 /// <returns></returns>
 public static ENodeConfiguration UsePostgresEventStore(this ENodeConfiguration eNodeConfiguration)
 {
     eNodeConfiguration.GetCommonConfiguration().SetDefault <IEventStore, PostgresEventStore>();
     return(eNodeConfiguration);
 }
Пример #28
0
        private static void InitializeENode()
        {
            ConfigSettings.Initialize();

            var assemblies = new[]
            {
                Assembly.Load("Conference.Common"),
                Assembly.Load("ConferenceManagement.Domain"),
                Assembly.Load("ConferenceManagement.Commands"),
                Assembly.Load("ConferenceManagement.CommandHandlers"),
                Assembly.Load("ConferenceManagement.MessagePublishers"),
                Assembly.Load("ConferenceManagement.ReadModel"),
                Assembly.Load("ConferenceManagement.Repositories.Dapper"),
                Assembly.Load("ConferenceManagement.Messages"),
                Assembly.GetExecutingAssembly()
            };
            var setting = new ConfigurationSetting
            {
                SqlDefaultConnectionString = ConfigSettings.ConferenceENodeConnectionString
            };

            _enodeConfiguration = _ecommonConfiguration
                .CreateENode(setting)
                .RegisterENodeComponents()
                .RegisterBusinessComponents(assemblies)
                .UseSqlServerLockService()
                .UseSqlServerCommandStore()
                .UseSqlServerEventStore()
                .UseSqlServerSequenceMessagePublishedVersionStore()
                .UseSqlServerMessageHandleRecordStore()
                .UseEQueue()
                .InitializeBusinessAssemblies(assemblies);
            ObjectContainer.Resolve<ILockService>().AddLockKey(typeof(ConferenceSlugIndex).Name);
            _logger.Info("ENode initialized.");
        }
Пример #29
0
        public static ENodeConfiguration StartEQueue(this ENodeConfiguration enodeConfiguration)
        {
            if (_isEQueueStarted)
            {
                _commandService.InitializeENode();
                _eventPublisher.InitializeENode();
                _applicationMessagePublisher.InitializeENode();
                _domainExceptionPublisher.InitializeENode();

                _commandConsumer.InitializeENode();
                _eventConsumer.InitializeENode();
                _applicationMessageConsumer.InitializeENode();
                _domainExceptionConsumer.InitializeENode();

                return(enodeConfiguration);
            }

            var localIp           = SocketUtils.GetLocalIPV4();
            var nameserverPoint   = 9493;
            var nameserverSetting = new NameServerSetting {
                BindingAddress = new IPEndPoint(localIp, nameserverPoint)
            };
            var brokerStorePath = @"d:\equeue-store-enode-ut";
            var brokerSetting   = new BrokerSetting(chunkFileStoreRootPath: brokerStorePath)
            {
                NameServerList = new List <IPEndPoint> {
                    new IPEndPoint(localIp, nameserverPoint)
                }
            };

            brokerSetting.BrokerInfo.ProducerAddress = new IPEndPoint(localIp, 5000).ToAddress();
            brokerSetting.BrokerInfo.ConsumerAddress = new IPEndPoint(localIp, 5001).ToAddress();
            brokerSetting.BrokerInfo.AdminAddress    = new IPEndPoint(localIp, 5002).ToAddress();

            var producerSetting = new ProducerSetting
            {
                NameServerList = new List <IPEndPoint> {
                    new IPEndPoint(localIp, nameserverPoint)
                }
            };
            var consumerSetting = new ConsumerSetting
            {
                NameServerList = new List <IPEndPoint> {
                    new IPEndPoint(localIp, nameserverPoint)
                },
                ConsumeFromWhere = ConsumeFromWhere.LastOffset
            };

            if (Directory.Exists(brokerStorePath))
            {
                Directory.Delete(brokerStorePath, true);
            }

            _nameServerController = new NameServerController(nameserverSetting);
            _broker = BrokerController.Create(brokerSetting);

            var commandResultProcessor = new CommandResultProcessor().Initialize(new IPEndPoint(localIp, 9001));

            _commandService.InitializeEQueue(commandResultProcessor, producerSetting);
            _eventPublisher.InitializeEQueue(producerSetting);
            _applicationMessagePublisher.InitializeEQueue(producerSetting);
            _domainExceptionPublisher.InitializeEQueue(producerSetting);

            _commandConsumer                = new CommandConsumer().InitializeEQueue(setting: consumerSetting).Subscribe("CommandTopic");
            _eventConsumer                  = new DomainEventConsumer().InitializeEQueue(setting: consumerSetting).Subscribe("EventTopic");
            _applicationMessageConsumer     = new ApplicationMessageConsumer().InitializeEQueue(setting: consumerSetting).Subscribe("ApplicationMessageTopic");
            _domainExceptionConsumer        = new DomainExceptionConsumer().InitializeEQueue(setting: consumerSetting).Subscribe("DomainExceptionTopic");
            _nameServerSocketRemotingClient = new SocketRemotingClient("NameServerRemotingClient", new IPEndPoint(localIp, nameserverPoint));

            _nameServerController.Start();
            _broker.Start();
            _eventConsumer.Start();
            _commandConsumer.Start();
            _applicationMessageConsumer.Start();
            _domainExceptionConsumer.Start();
            _applicationMessagePublisher.Start();
            _domainExceptionPublisher.Start();
            _eventPublisher.Start();
            _commandService.Start();
            _nameServerSocketRemotingClient.Start();

            CreateTopic(Constants.CommandTopic);
            CreateTopic(Constants.EventTopic);
            CreateTopic(Constants.ApplicationMessageTopic);
            CreateTopic(Constants.ExceptionTopic);
            WaitAllProducerTopicQueuesAvailable();
            WaitAllConsumerLoadBalanceComplete();

            _isEQueueStarted = true;

            return(enodeConfiguration);
        }
Пример #30
0
 public static ENodeConfiguration ShutdownEQueue(this ENodeConfiguration enodeConfiguration)
 {
     _commandConsumer.Shutdown();
     _eventPublisher.Shutdown();
     return(enodeConfiguration);
 }
Пример #31
0
 public static ENodeConfiguration ShutdownEQueue(this ENodeConfiguration enodeConfiguration)
 {
     _eventPublisher.Shutdown();
     _broker.Shutdown();
     return(enodeConfiguration);
 }
Пример #32
0
 /// <summary>Initialize the SqlServerPublishedVersionStore with option setting.
 /// </summary>
 /// <param name="optionSetting"></param>
 /// <returns></returns>
 public static ENodeConfiguration InitializeSqlServerPublishedVersionStore(this ENodeConfiguration eNodeConfiguration, OptionSetting optionSetting = null)
 {
     ((SqlServerPublishedVersionStore)ObjectContainer.Resolve <IPublishedVersionStore>()).Initialize(optionSetting);
     return(eNodeConfiguration);
 }
Пример #33
0
        private static void InitializeENode()
        {
            ConfigSettings.Initialize();

            var assemblies = new[]
            {
                Assembly.Load("Forum.Infrastructure"),
                Assembly.Load("Forum.Commands"),
                Assembly.Load("Forum.Domain"),
                Assembly.Load("Forum.Denormalizers.Dapper"),
                Assembly.Load("Forum.ProcessManagers"),
                Assembly.Load("Forum.EventService")
            };
            var setting = new ConfigurationSetting
            {
                SqlDefaultConnectionString = ConfigSettings.ConnectionString
            };

            _enodeConfiguration = _ecommonConfiguration
                .CreateENode(setting)
                .RegisterENodeComponents()
                .RegisterBusinessComponents(assemblies)
                .UseSqlServerSequenceMessagePublishedVersionStore()
                .UseSqlServerMessageHandleRecordStore()
                .UseEQueue()
                .InitializeBusinessAssemblies(assemblies);
            _logger.Info("ENode initialized.");
        }
Пример #34
0
 public static ENodeConfiguration BuildContainer(this ENodeConfiguration enodeConfiguration)
 {
     enodeConfiguration.GetCommonConfiguration().BuildContainer();
     return(enodeConfiguration);
 }
Пример #35
0
        public static ENodeConfiguration RegisterAllTypeCodes(this ENodeConfiguration enodeConfiguration)
        {
            var provider = ObjectContainer.Resolve <ITypeCodeProvider>() as DefaultTypeCodeProvider;

            //aggregates
            provider.RegisterType <BankAccount>(100);
            provider.RegisterType <DepositTransaction>(101);
            provider.RegisterType <TransferTransaction>(102);

            //commands
            provider.RegisterType <CreateAccountCommand>(200);
            provider.RegisterType <ValidateAccountCommand>(201);
            provider.RegisterType <AddTransactionPreparationCommand>(202);
            provider.RegisterType <CommitTransactionPreparationCommand>(203);

            provider.RegisterType <StartDepositTransactionCommand>(204);
            provider.RegisterType <ConfirmDepositPreparationCommand>(205);
            provider.RegisterType <ConfirmDepositCommand>(206);

            provider.RegisterType <StartTransferTransactionCommand>(207);
            provider.RegisterType <ConfirmAccountValidatePassedCommand>(208);
            provider.RegisterType <ConfirmTransferOutPreparationCommand>(209);
            provider.RegisterType <ConfirmTransferInPreparationCommand>(210);
            provider.RegisterType <ConfirmTransferOutCommand>(211);
            provider.RegisterType <ConfirmTransferInCommand>(212);
            provider.RegisterType <CancelTransferTransactionCommand>(213);

            //application messages
            provider.RegisterType <AccountValidatePassedMessage>(300);
            provider.RegisterType <AccountValidateFailedMessage>(301);

            //domain events
            provider.RegisterType <AccountCreatedEvent>(400);
            provider.RegisterType <TransactionPreparationAddedEvent>(401);
            provider.RegisterType <TransactionPreparationCommittedEvent>(402);
            provider.RegisterType <TransactionPreparationCanceledEvent>(403);

            provider.RegisterType <DepositTransactionStartedEvent>(404);
            provider.RegisterType <DepositTransactionPreparationCompletedEvent>(405);
            provider.RegisterType <DepositTransactionCompletedEvent>(406);

            provider.RegisterType <TransferTransactionStartedEvent>(407);
            provider.RegisterType <SourceAccountValidatePassedConfirmedEvent>(408);
            provider.RegisterType <TargetAccountValidatePassedConfirmedEvent>(409);
            provider.RegisterType <AccountValidatePassedConfirmCompletedEvent>(410);
            provider.RegisterType <TransferOutPreparationConfirmedEvent>(411);
            provider.RegisterType <TransferInPreparationConfirmedEvent>(412);
            provider.RegisterType <TransferOutConfirmedEvent>(413);
            provider.RegisterType <TransferInConfirmedEvent>(414);
            provider.RegisterType <TransferTransactionCompletedEvent>(415);
            provider.RegisterType <TransferTransactionCanceledEvent>(416);

            //publishable exceptions
            provider.RegisterType <InsufficientBalanceException>(500);

            //application message and domain event handlers
            provider.RegisterType <DepositTransactionProcessManager>(600);
            provider.RegisterType <TransferTransactionProcessManager>(601);
            provider.RegisterType <ConsoleLogger>(602);
            provider.RegisterType <SyncHelper>(603);
            provider.RegisterType <CountSyncHelper>(604);

            return(enodeConfiguration);
        }
Пример #36
0
 public static ENodeConfiguration InitEmailSeting(this ENodeConfiguration enodeConfiguration)
 {
     EmailSettingConfigs.InitEmailSetting();
     return(enodeConfiguration);
 }
Пример #37
0
        private static void InitializeENode()
        {
            ConfigSettings.Initialize();

            var assemblies = new[]
            {
                Assembly.Load("Forum.Infrastructure"),
                Assembly.Load("Forum.Domain"),
                Assembly.Load("Forum.Domain.Dapper"),
                Assembly.Load("Forum.CommandHandlers"),
                Assembly.Load("Forum.CommandService")
            };
            var setting = new ConfigurationSetting
            {
                SqlServerDefaultConnectionString = ConfigSettings.ConnectionString
            };

            _enodeConfiguration = _ecommonConfiguration
                .CreateENode(setting)
                .RegisterENodeComponents()
                .RegisterBusinessComponents(assemblies)
                .RegisterAllTypeCodes()
                .UseSqlServerLockService()
                .UseSqlServerCommandStore()
                .UseSqlServerEventStore()
                .UseEQueue()
                .InitializeBusinessAssemblies(assemblies);
            _logger.Info("ENode initialized.");
        }
Пример #38
0
 public static ENodeConfiguration InitLotteryEngine(this ENodeConfiguration enodeConfiguration)
 {
     EngineContext.Initialize();
     return(enodeConfiguration);
 }
Пример #39
0
        static void NormalTest()
        {
            var assemblies = new[] { Assembly.GetExecutingAssembly() };

            _configuration = Configuration
                .Create()
                .UseAutofac()
                .RegisterCommonComponents()
                .UseLog4Net()
                .UseJsonNet()
                .CreateENode()
                .RegisterENodeComponents()
                .RegisterAllTypeCodes()
                .RegisterBusinessComponents(assemblies)
                .UseEQueue()
                .InitializeBusinessAssemblies(assemblies)
                .StartEQueue();

            Console.WriteLine(string.Empty);
            Console.WriteLine("ENode started...");

            var commandService = ObjectContainer.Resolve<ICommandService>();
            var syncHelper = ObjectContainer.Resolve<SyncHelper>();
            var account1 = ObjectId.GenerateNewStringId();
            var account2 = ObjectId.GenerateNewStringId();
            var account3 = "INVALID-" + ObjectId.GenerateNewStringId();
            Console.WriteLine(string.Empty);

            //创建两个银行账户
            commandService.ExecuteAsync(new CreateAccountCommand(account1, "雪华"), CommandReturnType.EventHandled).Wait();
            commandService.ExecuteAsync(new CreateAccountCommand(account2, "凯锋"), CommandReturnType.EventHandled).Wait();

            Console.WriteLine(string.Empty);

            //每个账户都存入1000元
            commandService.Send(new StartDepositTransactionCommand(ObjectId.GenerateNewStringId(), account1, 1000));
            syncHelper.WaitOne();
            commandService.Send(new StartDepositTransactionCommand(ObjectId.GenerateNewStringId(), account2, 1000));
            syncHelper.WaitOne();

            Console.WriteLine(string.Empty);

            //账户1向账户3转账300元,交易会失败,因为账户3不存在
            commandService.Send(new StartTransferTransactionCommand(ObjectId.GenerateNewStringId(), new TransferTransactionInfo(account1, account3, 300D)));
            syncHelper.WaitOne();
            Console.WriteLine(string.Empty);

            //账户1向账户2转账1200元,交易会失败,因为余额不足
            commandService.Send(new StartTransferTransactionCommand(ObjectId.GenerateNewStringId(), new TransferTransactionInfo(account1, account2, 1200D)));
            syncHelper.WaitOne();
            Console.WriteLine(string.Empty);

            //账户2向账户1转账500元,交易成功
            commandService.Send(new StartTransferTransactionCommand(ObjectId.GenerateNewStringId(), new TransferTransactionInfo(account2, account1, 500D)));
            syncHelper.WaitOne();

            Thread.Sleep(500);
            Console.WriteLine(string.Empty);
            Console.WriteLine("Press Enter to exit...");
            Console.ReadLine();
            _configuration.ShutdownEQueue();
        }
Пример #40
0
 public static ENodeConfiguration UseAutoMapper(this ENodeConfiguration enodeConfiguration,
                                                params string[] assemblyNames)
 {
     MapperConfig.InitAutoMapperConfig(assemblyNames);
     return(enodeConfiguration);
 }
Пример #41
0
        static void NormalTest()
        {
            var assemblies    = new[] { Assembly.GetExecutingAssembly() };
            var loggerFactory = new SerilogLoggerFactory()
                                .AddFileLogger("ECommon", Path.Combine("logs", "ecommon"))
                                .AddFileLogger("ENode", Path.Combine("logs", "enode"))
                                .AddFileLogger("ENode.RabbitMQ", Path.Combine("logs", "enode.rabbitmq"));

            _configuration = ECommon.Configurations.Configuration
                             .Create()
                             .UseAutofac()
                             .RegisterCommonComponents()
                             .UseSerilog(loggerFactory)
                             .UseJsonNet()
                             .CreateENode()
                             .RegisterENodeComponents()
                             .RegisterBusinessComponents(assemblies)
                             .UseRabbitMQ()
                             .BuildContainer()
                             .InitializeBusinessAssemblies(assemblies)
                             .StartRabbitMQ()
                             .Start();

            Console.WriteLine(string.Empty);
            Console.WriteLine("ENode started...");

            var commandService = ObjectContainer.Resolve <ICommandService>();
            var syncHelper     = ObjectContainer.Resolve <SyncHelper>();
            var account1       = ObjectId.GenerateNewStringId();
            var account2       = ObjectId.GenerateNewStringId();
            var account3       = "INVALID-" + ObjectId.GenerateNewStringId();

            Console.WriteLine(string.Empty);

            //创建两个银行账户
            commandService.ExecuteAsync(new CreateAccountCommand(account1, "雪华"), CommandReturnType.EventHandled).Wait();
            commandService.ExecuteAsync(new CreateAccountCommand(account2, "凯锋"), CommandReturnType.EventHandled).Wait();

            Console.WriteLine(string.Empty);

            //每个账户都存入1000元
            commandService.SendAsync(new StartDepositTransactionCommand(ObjectId.GenerateNewStringId(), account1, 1000)).Wait();
            syncHelper.WaitOne();
            commandService.SendAsync(new StartDepositTransactionCommand(ObjectId.GenerateNewStringId(), account2, 1000)).Wait();
            syncHelper.WaitOne();

            Console.WriteLine(string.Empty);

            //账户1向账户3转账300元,交易会失败,因为账户3不存在
            commandService.SendAsync(new StartTransferTransactionCommand(ObjectId.GenerateNewStringId(), new TransferTransactionInfo(account1, account3, 300D))
            {
                Items = new Dictionary <string, string>
                {
                    { "ProcessId", "10000" }
                }
            }).Wait();
            syncHelper.WaitOne();
            Console.WriteLine(string.Empty);

            //账户1向账户2转账1200元,交易会失败,因为余额不足
            commandService.SendAsync(new StartTransferTransactionCommand(ObjectId.GenerateNewStringId(), new TransferTransactionInfo(account1, account2, 1200D))
            {
                Items = new Dictionary <string, string>
                {
                    { "ProcessId", "10001" }
                }
            }).Wait();
            syncHelper.WaitOne();
            Console.WriteLine(string.Empty);

            //账户2向账户1转账500元,交易成功
            commandService.SendAsync(new StartTransferTransactionCommand(ObjectId.GenerateNewStringId(), new TransferTransactionInfo(account2, account1, 500D))
            {
                Items = new Dictionary <string, string>
                {
                    { "ProcessId", "10002" }
                }
            }).Wait();
            syncHelper.WaitOne();

            Thread.Sleep(10000);
            _configuration.ShutdownRabbitMQ().Stop();
            Console.WriteLine("Simple test complete.");
        }
Пример #42
0
        public static ENodeConfiguration StartEQueue(this ENodeConfiguration enodeConfiguration)
        {
            if (_isEQueueStarted)
            {
                _commandService.InitializeENode();
                _eventPublisher.InitializeENode();

                _commandConsumer.InitializeENode();
                _eventConsumer.InitializeENode();

                return(enodeConfiguration);
            }

            var nameServerEndpoint  = new IPEndPoint(IPAddress.Loopback, ConfigSettings.NameServerPort);
            var nameServerEndpoints = new List <IPEndPoint> {
                nameServerEndpoint
            };
            var nameServerSetting = new NameServerSetting()
            {
                BindingAddress = nameServerEndpoint
            };

            _nameServerController = new NameServerController(nameServerSetting);

            var brokerStorePath = @"d:\forum-equeue-store-test";

            if (Directory.Exists(brokerStorePath))
            {
                Directory.Delete(brokerStorePath, true);
            }

            var brokerSetting = new BrokerSetting(false, brokerStorePath)
            {
                NameServerList = nameServerEndpoints
            };

            brokerSetting.BrokerInfo.ProducerAddress = new IPEndPoint(IPAddress.Loopback, ConfigSettings.BrokerProducerPort).ToAddress();
            brokerSetting.BrokerInfo.ConsumerAddress = new IPEndPoint(IPAddress.Loopback, ConfigSettings.BrokerConsumerPort).ToAddress();
            brokerSetting.BrokerInfo.AdminAddress    = new IPEndPoint(IPAddress.Loopback, ConfigSettings.BrokerAdminPort).ToAddress();
            _broker = BrokerController.Create(brokerSetting);

            _commandService.InitializeEQueue(new CommandResultProcessor().Initialize(new IPEndPoint(IPAddress.Loopback, 9000)), new ProducerSetting
            {
                NameServerList = nameServerEndpoints
            });
            _eventPublisher.InitializeEQueue(new ProducerSetting
            {
                NameServerList = nameServerEndpoints
            });
            _commandConsumer = new CommandConsumer().InitializeEQueue(setting: new ConsumerSetting
            {
                NameServerList = nameServerEndpoints
            });
            _eventConsumer = new DomainEventConsumer().InitializeEQueue(setting: new ConsumerSetting
            {
                NameServerList = nameServerEndpoints
            });

            _commandConsumer
            .Subscribe("AccountCommandTopic")
            .Subscribe("SectionCommandTopic")
            .Subscribe("PostCommandTopic")
            .Subscribe("ReplyCommandTopic");
            _eventConsumer
            .Subscribe("AccountEventTopic")
            .Subscribe("SectionEventTopic")
            .Subscribe("PostEventTopic")
            .Subscribe("ReplyEventTopic");

            _nameServerController.Start();
            _broker.Start();
            _eventConsumer.Start();
            _commandConsumer.Start();
            _eventPublisher.Start();
            _commandService.Start();

            WaitAllConsumerLoadBalanceComplete();

            _isEQueueStarted = true;

            return(enodeConfiguration);
        }
Пример #43
0
 public static ENodeConfiguration ShutdownEQueue(this ENodeConfiguration enodeConfiguration)
 {
     _commandService.Shutdown();
     return(enodeConfiguration);
 }
Пример #44
0
 /// <summary>Initialize the SqlServerLockService with option setting.
 /// </summary>
 /// <param name="optionSetting"></param>
 /// <returns></returns>
 public static ENodeConfiguration InitializeSqlServerLockService(this ENodeConfiguration eNodeConfiguration, OptionSetting optionSetting = null)
 {
     ((SqlServerLockService)ObjectContainer.Resolve <ILockService>()).Initialize(optionSetting);
     return(eNodeConfiguration);
 }
Пример #45
0
        public static ENodeConfiguration UseEQueue(this ENodeConfiguration enodeConfiguration)
        {
            var configuration   = enodeConfiguration.GetCommonConfiguration();
            var brokerStorePath = @"c:\forum-equeue-store-test";

            if (Directory.Exists(brokerStorePath))
            {
                Directory.Delete(brokerStorePath, true);
            }

            configuration.RegisterEQueueComponents();

            var nameServerEndpoint  = new IPEndPoint(IPAddress.Loopback, ConfigSettings.NameServerPort);
            var nameServerEndpoints = new List <IPEndPoint> {
                nameServerEndpoint
            };
            var nameServerSetting = new NameServerSetting()
            {
                BindingAddress = nameServerEndpoint
            };

            _nameServer = new NameServerController(nameServerSetting);

            var brokerSetting = new BrokerSetting(false, brokerStorePath);

            brokerSetting.NameServerList             = nameServerEndpoints;
            brokerSetting.BrokerInfo.ProducerAddress = new IPEndPoint(IPAddress.Loopback, ConfigSettings.BrokerProducerPort).ToAddress();
            brokerSetting.BrokerInfo.ConsumerAddress = new IPEndPoint(IPAddress.Loopback, ConfigSettings.BrokerConsumerPort).ToAddress();
            brokerSetting.BrokerInfo.AdminAddress    = new IPEndPoint(IPAddress.Loopback, ConfigSettings.BrokerAdminPort).ToAddress();
            _broker = BrokerController.Create(brokerSetting);

            _commandResultProcessor = new CommandResultProcessor(new IPEndPoint(IPAddress.Loopback, 9000));
            _commandService         = new CommandService(_commandResultProcessor, new ProducerSetting
            {
                NameServerList = nameServerEndpoints
            });
            _eventPublisher = new DomainEventPublisher(new ProducerSetting
            {
                NameServerList = nameServerEndpoints
            });

            configuration.SetDefault <ICommandService, CommandService>(_commandService);
            configuration.SetDefault <IMessagePublisher <DomainEventStreamMessage>, DomainEventPublisher>(_eventPublisher);

            _commandConsumer = new CommandConsumer(setting: new ConsumerSetting
            {
                NameServerList = nameServerEndpoints
            });
            _eventConsumer = new DomainEventConsumer(setting: new ConsumerSetting
            {
                NameServerList = nameServerEndpoints
            });

            _commandConsumer
            .Subscribe("AccountCommandTopic")
            .Subscribe("SectionCommandTopic")
            .Subscribe("PostCommandTopic")
            .Subscribe("ReplyCommandTopic");
            _eventConsumer
            .Subscribe("AccountEventTopic")
            .Subscribe("SectionEventTopic")
            .Subscribe("PostEventTopic")
            .Subscribe("ReplyEventTopic");

            return(enodeConfiguration);
        }
Пример #46
0
        public static ENodeConfiguration UseEQueue(this ENodeConfiguration enodeConfiguration,
                                                   bool useMockDomainEventPublisher          = false,
                                                   bool useMockApplicationMessagePublisher   = false,
                                                   bool useMockPublishableExceptionPublisher = false)
        {
            var configuration   = enodeConfiguration.GetCommonConfiguration();
            var brokerStorePath = @"c:\equeue-store";
            var brokerSetting   = new BrokerSetting(brokerStorePath);

            if (Directory.Exists(brokerStorePath))
            {
                Directory.Delete(brokerStorePath, true);
            }

            configuration.RegisterEQueueComponents();
            _broker         = BrokerController.Create(brokerSetting);
            _commandService = new CommandService(new CommandResultProcessor(new IPEndPoint(SocketUtils.GetLocalIPV4(), 9001)));
            _eventPublisher = new DomainEventPublisher();
            _applicationMessagePublisher   = new ApplicationMessagePublisher();
            _publishableExceptionPublisher = new PublishableExceptionPublisher();

            if (useMockDomainEventPublisher)
            {
                configuration.SetDefault <IMessagePublisher <DomainEventStreamMessage>, MockDomainEventPublisher>();
            }
            else
            {
                configuration.SetDefault <IMessagePublisher <DomainEventStreamMessage>, DomainEventPublisher>(_eventPublisher);
            }

            if (useMockApplicationMessagePublisher)
            {
                configuration.SetDefault <IMessagePublisher <IApplicationMessage>, MockApplicationMessagePublisher>();
            }
            else
            {
                configuration.SetDefault <IMessagePublisher <IApplicationMessage>, ApplicationMessagePublisher>(_applicationMessagePublisher);
            }

            if (useMockPublishableExceptionPublisher)
            {
                configuration.SetDefault <IMessagePublisher <IPublishableException>, MockPublishableExceptionPublisher>();
            }
            else
            {
                configuration.SetDefault <IMessagePublisher <IPublishableException>, PublishableExceptionPublisher>(_publishableExceptionPublisher);
            }

            configuration.SetDefault <ICommandService, CommandService>(_commandService);

            _commandConsumer = new CommandConsumer(setting: new ConsumerSetting {
                ConsumeFromWhere = ConsumeFromWhere.FirstOffset
            }).Subscribe("CommandTopic");
            _eventConsumer = new DomainEventConsumer(setting: new ConsumerSetting {
                ConsumeFromWhere = ConsumeFromWhere.FirstOffset
            }).Subscribe("EventTopic");
            _applicationMessageConsumer = new ApplicationMessageConsumer(setting: new ConsumerSetting {
                ConsumeFromWhere = ConsumeFromWhere.FirstOffset
            }).Subscribe("ApplicationMessageTopic");
            _publishableExceptionConsumer = new PublishableExceptionConsumer(setting: new ConsumerSetting {
                ConsumeFromWhere = ConsumeFromWhere.FirstOffset
            }).Subscribe("PublishableExceptionTopic");

            return(enodeConfiguration);
        }
Пример #47
0
 public static ENodeConfiguration StartEQueue(this ENodeConfiguration enodeConfiguration)
 {
     _commandService.Start();
     return(enodeConfiguration);
 }
Пример #48
0
        private static void InitializeEnode()
        {
            var assemblies = new[]
            {
                Assembly.Load("BEnode.Config"),
                Assembly.Load("Account.Domain"),
                Assembly.Load("Account.Commands"),
                Assembly.Load("Account.CommandHandlers"),
                Assembly.Load("Account.Denormalizers.Dapper"),
                Assembly.GetExecutingAssembly()
            };
            var setting = new ConfigurationSetting
            {
                SqlDefaultConnectionString = DbConfiguration.ENodeConnectionString
            };

            _enodeConfiguration = _ecommonConfiguration
                .CreateENode(setting)
                .RegisterENodeComponents()
                .RegisterBusinessComponents(assemblies)
                .UseSqlServerLockService()
                .UseSqlServerCommandStore()
                .UseSqlServerEventStore()
                .UseSqlServerSequenceMessagePublishedVersionStore()
                .UseSqlServerMessageHandleRecordStore()
                .UseEQueue()
                .InitializeBusinessAssemblies(assemblies);

            //ObjectContainer.Resolve<ILockService>().AddLockKey(typeof(UserInfo).Name);
            _logger.Info("ENode initialized.");
        }