static void Main(string[] args)
{
InitializeEQueue();
var messageHandler = new MessageHandler();
var consumerSetting = new ConsumerSetting { HeartbeatBrokerInterval = 1000, UpdateTopicQueueCountInterval = 1000, RebalanceInterval = 1000 };
var consumer1 = new Consumer("Consumer1", "group1", consumerSetting).Subscribe("SampleTopic").Start(messageHandler);
var consumer2 = new Consumer("Consumer2", "group1", consumerSetting).Subscribe("SampleTopic").Start(messageHandler);
_logger.Info("Start consumer load balance, please wait for a moment.");
var scheduleService = ObjectContainer.Resolve<IScheduleService>();
var waitHandle = new ManualResetEvent(false);
var taskId = scheduleService.ScheduleTask(() =>
{
var c1AllocatedQueueIds = consumer1.GetCurrentQueues().Select(x => x.QueueId);
var c2AllocatedQueueIds = consumer2.GetCurrentQueues().Select(x => x.QueueId);
if (c1AllocatedQueueIds.Count() == 2 && c2AllocatedQueueIds.Count() == 2)
{
_logger.Info(string.Format("Consumer load balance finished. Queue allocation result: c1:{0}, c2:{1}",
string.Join(",", c1AllocatedQueueIds),
string.Join(",", c2AllocatedQueueIds)));
waitHandle.Set();
}
}, 1000, 1000);
waitHandle.WaitOne();
scheduleService.ShutdownTask(taskId);
Console.ReadLine();
}
public ClientService(ClientSetting setting, Producer producer, Consumer consumer)
{
Ensure.NotNull(setting, "setting");
if (producer == null && consumer == null)
{
throw new ArgumentException("producer or consumer must set at least one of them.");
}
else if (producer != null && consumer != null)
{
throw new ArgumentException("producer or consumer cannot set both of them.");
}
Interlocked.Increment(ref _instanceNumber);
_producer = producer;
_consumer = consumer;
_setting = setting;
_clientId = BuildClientId(setting.ClientName);
_brokerConnectionDict = new ConcurrentDictionary<string, BrokerConnection>();
_topicMessageQueueDict = new ConcurrentDictionary<string, IList<MessageQueue>>();
_binarySerializer = ObjectContainer.Resolve<IBinarySerializer>();
_jsonSerializer = ObjectContainer.Resolve<IJsonSerializer>();
_scheduleService = ObjectContainer.Resolve<IScheduleService>();
_logger = ObjectContainer.Resolve<ILoggerFactory>().Create(GetType().FullName);
_nameServerRemotingClientList = RemotingClientUtils.CreateRemotingClientList(_setting.NameServerList, _setting.SocketSetting).ToList();
}
static void StartConsumers()
{
var messageHandler = new MessageHandler();
//Start four consumers.
var consumerSetting = new ConsumerSetting { HeartbeatBrokerInterval = 1000, UpdateTopicQueueCountInterval = 1000, RebalanceInterval = 1000 };
var consumer1 = new Consumer("Consumer1", "group1", consumerSetting).Subscribe("SampleTopic").SetMessageHandler(messageHandler).Start();
var consumer2 = new Consumer("Consumer2", "group1", consumerSetting).Subscribe("SampleTopic").SetMessageHandler(messageHandler).Start();
var consumer3 = new Consumer("Consumer3", "group1", consumerSetting).Subscribe("SampleTopic").SetMessageHandler(messageHandler).Start();
var consumer4 = new Consumer("Consumer4", "group1", consumerSetting).Subscribe("SampleTopic").SetMessageHandler(messageHandler).Start();
//Below to wait for consumer balance.
_logger.Info("Start consumer load balance, please wait for a moment.");
var scheduleService = ObjectContainer.Resolve<IScheduleService>();
var waitHandle = new ManualResetEvent(false);
var taskId = scheduleService.ScheduleTask("WaitQueueAllocationComplete", () =>
{
var c1AllocatedQueueIds = consumer1.GetCurrentQueues().Select(x => x.QueueId);
var c2AllocatedQueueIds = consumer2.GetCurrentQueues().Select(x => x.QueueId);
var c3AllocatedQueueIds = consumer3.GetCurrentQueues().Select(x => x.QueueId);
var c4AllocatedQueueIds = consumer4.GetCurrentQueues().Select(x => x.QueueId);
if (c1AllocatedQueueIds.Count() == 1 && c2AllocatedQueueIds.Count() == 1 && c3AllocatedQueueIds.Count() == 1 && c4AllocatedQueueIds.Count() == 1)
{
_logger.Info(string.Format("Consumer load balance finished. Queue allocation result: c1:{0}, c2:{1}, c3:{2}, c4:{3}",
string.Join(",", c1AllocatedQueueIds),
string.Join(",", c2AllocatedQueueIds),
string.Join(",", c3AllocatedQueueIds),
string.Join(",", c4AllocatedQueueIds)));
waitHandle.Set();
}
}, 1000, 1000);
waitHandle.WaitOne();
scheduleService.ShutdownTask(taskId);
}
static void Main(string[] args)
{
InitializeEQueue();
var messageHandler = new MessageHandler();
var consumer1 = new Consumer("Consumer1", "group1").Subscribe("SampleTopic").Start(messageHandler);
var consumer2 = new Consumer("Consumer2", "group1").Subscribe("SampleTopic").Start(messageHandler);
var consumer3 = new Consumer("Consumer3", "group1").Subscribe("SampleTopic").Start(messageHandler);
var consumer4 = new Consumer("Consumer4", "group1").Subscribe("SampleTopic").Start(messageHandler);
Console.WriteLine("Start consumer load balance, please wait for a moment.");
var scheduleService = ObjectContainer.Resolve<IScheduleService>();
var waitHandle = new ManualResetEvent(false);
var taskId = scheduleService.ScheduleTask(() =>
{
var c1AllocatedQueueIds = consumer1.GetCurrentQueues().Select(x => x.QueueId);
var c2AllocatedQueueIds = consumer2.GetCurrentQueues().Select(x => x.QueueId);
var c3AllocatedQueueIds = consumer3.GetCurrentQueues().Select(x => x.QueueId);
var c4AllocatedQueueIds = consumer4.GetCurrentQueues().Select(x => x.QueueId);
if (c1AllocatedQueueIds.Count() == 1 && c2AllocatedQueueIds.Count() == 1 && c3AllocatedQueueIds.Count() == 1 && c4AllocatedQueueIds.Count() == 1)
{
Console.WriteLine(string.Format("Consumer load balance finished. Queue allocation result: c1:{0}, c2:{1}, c3:{2}, c4:{3}",
string.Join(",", c1AllocatedQueueIds),
string.Join(",", c2AllocatedQueueIds),
string.Join(",", c3AllocatedQueueIds),
string.Join(",", c4AllocatedQueueIds)));
waitHandle.Set();
}
}, 1000, 1000);
waitHandle.WaitOne();
scheduleService.ShutdownTask(taskId);
Console.ReadLine();
}
static void Main(string[] args)
{
InitializeEQueue();
var messageHandler = new MessageHandler();
var consumerSetting = new ConsumerSetting
{
HeartbeatBrokerInterval = 1000,
UpdateTopicQueueCountInterval = 1000,
RebalanceInterval = 1000
};
var consumer = new Consumer("Consumer1", "Group1", consumerSetting).Subscribe("SampleTopic").SetMessageHandler(messageHandler).Start();
_logger.Info("Start consumer load balance, please wait for a moment.");
var scheduleService = ObjectContainer.Resolve<IScheduleService>();
var waitHandle = new ManualResetEvent(false);
var taskId = scheduleService.ScheduleTask("WaitQueueAllocationComplete", () =>
{
var allocatedQueueIds = consumer.GetCurrentQueues().Select(x => x.QueueId);
if (allocatedQueueIds.Count() == 4)
{
_logger.InfoFormat("Consumer load balance completed, allocated queueIds:{0}", string.Join(",", allocatedQueueIds));
waitHandle.Set();
}
}, 1000, 1000);
waitHandle.WaitOne();
scheduleService.ShutdownTask(taskId);
Console.ReadLine();
}
public static ENodeConfiguration UseEQueue(this ENodeConfiguration enodeConfiguration)
{
var configuration = enodeConfiguration.GetCommonConfiguration();
configuration.RegisterEQueueComponents();
var consumerSetting = new ConsumerSetting
{
HeartbeatBrokerInterval = 1000,
UpdateTopicQueueCountInterval = 1000,
RebalanceInterval = 1000
};
var commandExecutedMessageConsumer = new Consumer(consumerSetting, "CommandExecutedMessageConsumer", "CommandExecutedMessageConsumerGroup_" + ObjectId.GenerateNewId().ToString());
var domainEventHandledMessageConsumer = new Consumer(consumerSetting, "DomainEventHandledMessageConsumer", "DomainEventHandledMessageConsumerGroup_" + ObjectId.GenerateNewId().ToString());
_commandResultProcessor = new CommandResultProcessor(commandExecutedMessageConsumer, domainEventHandledMessageConsumer);
_commandService = new CommandService(_commandResultProcessor);
configuration.SetDefault<ICommandService, CommandService>(_commandService);
_commandResultProcessor.SetExecutedCommandMessageTopic("ExecutedCommandMessageTopic");
_commandResultProcessor.SetDomainEventHandledMessageTopic("DomainEventHandledMessageTopic");
return enodeConfiguration;
}
public EventConsumer(string id, ConsumerSetting setting, string groupName, DomainEventHandledMessageSender domainEventHandledMessageSender)
{
_consumer = new Consumer(id, setting, string.IsNullOrEmpty(groupName) ? typeof(EventConsumer).Name + "Group" : groupName);
_binarySerializer = ObjectContainer.Resolve<IBinarySerializer>();
_eventTypeCodeProvider = ObjectContainer.Resolve<IEventTypeCodeProvider>();
_eventProcessor = ObjectContainer.Resolve<IEventProcessor>();
_messageContextDict = new ConcurrentDictionary<string, IMessageContext>();
_domainEventHandledMessageSender = domainEventHandledMessageSender;
}
public CommitConsumeOffsetService(Consumer consumer, ClientService clientService)
{
_consumeOffsetInfoDict = new ConcurrentDictionary<string, ConsumeOffsetInfo>();
_consumer = consumer;
_clientService = clientService;
_clientId = clientService.GetClientId();
_binarySerializer = ObjectContainer.Resolve<IBinarySerializer>();
_scheduleService = ObjectContainer.Resolve<IScheduleService>();
_logger = ObjectContainer.Resolve<ILoggerFactory>().Create(GetType().FullName);
}
public PublishableExceptionConsumer(string id = null, string groupName = null, ConsumerSetting setting = null)
{
_consumer = new Consumer(groupName ?? DefaultExceptionConsumerGroup, setting ?? new ConsumerSetting
{
MessageHandleMode = MessageHandleMode.Sequential
});
_jsonSerializer = ObjectContainer.Resolve<IJsonSerializer>();
_publishableExceptionProcessor = ObjectContainer.Resolve<IMessageProcessor<ProcessingPublishableExceptionMessage, IPublishableException, bool>>();
_publishableExceptionTypeCodeProvider = ObjectContainer.Resolve<ITypeCodeProvider>();
}
public ApplicationMessageConsumer(string groupName = null, ConsumerSetting setting = null)
{
_consumer = new Consumer(groupName ?? DefaultMessageConsumerGroup, setting ?? new ConsumerSetting
{
MessageHandleMode = MessageHandleMode.Sequential
});
_jsonSerializer = ObjectContainer.Resolve<IJsonSerializer>();
_processor = ObjectContainer.Resolve<IMessageProcessor<ProcessingApplicationMessage, IApplicationMessage, bool>>();
_typeNameProvider = ObjectContainer.Resolve<ITypeNameProvider>();
}
public CommandResultProcessor(Consumer commandExecutedMessageConsumer, Consumer domainEventHandledMessageConsumer)
{
_commandExecutedMessageConsumer = commandExecutedMessageConsumer;
_domainEventHandledMessageConsumer = domainEventHandledMessageConsumer;
_commandTaskDict = new ConcurrentDictionary<string, CommandTaskCompletionSource>();
_processTaskDict = new ConcurrentDictionary<string, TaskCompletionSource<ProcessResult>>();
_commandExecutedMessageLocalQueue = new BlockingCollection<CommandExecutedMessage>(new ConcurrentQueue<CommandExecutedMessage>());
_domainEventHandledMessageLocalQueue = new BlockingCollection<DomainEventHandledMessage>(new ConcurrentQueue<DomainEventHandledMessage>());
_commandExecutedMessageWorker = new Worker(() => ProcessExecutedCommandMessage(_commandExecutedMessageLocalQueue.Take()));
_domainEventHandledMessageWorker = new Worker(() => ProcessDomainEventHandledMessage(_domainEventHandledMessageLocalQueue.Take()));
_binarySerializer = ObjectContainer.Resolve<IBinarySerializer>();
}
public RebalanceService(Consumer consumer, ClientService clientService, PullMessageService pullMessageService, CommitConsumeOffsetService commitConsumeOffsetService)
{
_consumer = consumer;
_clientService = clientService;
_clientId = clientService.GetClientId();
_pullRequestDict = new ConcurrentDictionary<string, PullRequest>();
_allocateMessageQueueStragegy = ObjectContainer.Resolve<IAllocateMessageQueueStrategy>();
_pullMessageService = pullMessageService;
_commitConsumeOffsetService = commitConsumeOffsetService;
_binarySerializer = ObjectContainer.Resolve<IBinarySerializer>();
_scheduleService = ObjectContainer.Resolve<IScheduleService>();
_logger = ObjectContainer.Resolve<ILoggerFactory>().Create(GetType().FullName);
}
public DomainEventConsumer(string groupName = null, ConsumerSetting setting = null, bool sendEventHandledMessage = true)
{
_consumer = new Consumer(groupName ?? DefaultEventConsumerGroup, setting ?? new ConsumerSetting
{
MessageHandleMode = MessageHandleMode.Sequential
});
_sendReplyService = new SendReplyService();
_jsonSerializer = ObjectContainer.Resolve<IJsonSerializer>();
_eventSerializer = ObjectContainer.Resolve<IEventSerializer>();
_processor = ObjectContainer.Resolve<IMessageProcessor<ProcessingDomainEventStreamMessage, DomainEventStreamMessage, bool>>();
_logger = ObjectContainer.Resolve<ILoggerFactory>().Create(GetType().FullName);
_sendEventHandledMessage = sendEventHandledMessage;
}
public void Start()
{
var setting = new EQueueConsumers.ConsumerSetting
{
AutoPull = false,
ConsumeFromWhere = EQueueMessages.ConsumeFromWhere.FirstOffset,
BrokerAddress = new IPEndPoint(IPAddress.Parse(BrokerAddress), ConsumerPort),
BrokerAdminAddress = new IPEndPoint(IPAddress.Parse(BrokerAddress), AdminPort)
};
Consumer = new EQueueConsumers.Consumer(GroupId, setting)
.Subscribe(Topic)
.Start();
}
public override void Start()
{
var setting = new EQueueConsumers.ConsumerSetting
{
AutoPull = false,
ConsumeFromWhere = ConsumerConfig.AutoOffsetReset == AutoOffsetReset.Smallest || ConsumerConfig.AutoOffsetReset == AutoOffsetReset.Earliest ? EQueueMessages.ConsumeFromWhere.FirstOffset : EQueueMessages.ConsumeFromWhere.LastOffset,
ClusterName = ClusterName,
NameServerList = NameServerList
};
Consumer = new EQueueConsumers.Consumer(GroupId, setting, ConsumerId);
Topics.ForEach(topic => Consumer.Subscribe(topic));
Consumer.Start();
base.Start();
}
static void Main(string[] args)
{
InitializeEQueue();
var messageHandler = new MessageHandler();
var consumerSetting = new ConsumerSetting
{
HeartbeatBrokerInterval = 1000,
UpdateTopicQueueCountInterval = 1000,
RebalanceInterval = 1000,
ConsumeFromWhere = ConsumeFromWhere.FirstOffset
};
var consumer = new Consumer("SampleConsumer@" + ObjectId.GenerateNewStringId(), "SampleGroup", consumerSetting).Subscribe("SampleTopic").SetMessageHandler(messageHandler).Start();
Console.ReadLine();
}
public static ENodeConfiguration UseEQueue(this ENodeConfiguration enodeConfiguration)
{
var configuration = enodeConfiguration.GetCommonConfiguration();
configuration.RegisterEQueueComponents();
configuration.SetDefault<ICommandTopicProvider, CommandTopicManager>();
configuration.SetDefault<IEventTopicProvider, EventTopicManager>();
configuration.SetDefault<ICommandTypeCodeProvider, CommandTypeCodeManager>();
var consumerSetting = new ConsumerSetting
{
HeartbeatBrokerInterval = 1000,
UpdateTopicQueueCountInterval = 1000,
RebalanceInterval = 1000
};
var eventConsumerSetting = new ConsumerSetting
{
HeartbeatBrokerInterval = 1000,
UpdateTopicQueueCountInterval = 1000,
RebalanceInterval = 1000,
MessageHandleMode = MessageHandleMode.Sequential
};
_broker = new BrokerController().Initialize();
var commandExecutedMessageConsumer = new Consumer(consumerSetting, "CommandExecutedMessageConsumer", "CommandExecutedMessageConsumerGroup_" + ObjectId.GenerateNewId().ToString());
var domainEventHandledMessageConsumer = new Consumer(consumerSetting, "DomainEventHandledMessageConsumer", "DomainEventHandledMessageConsumerGroup_" + ObjectId.GenerateNewId().ToString());
_commandResultProcessor = new CommandResultProcessor(commandExecutedMessageConsumer, domainEventHandledMessageConsumer);
_commandService = new CommandService(_commandResultProcessor);
_commandExecutedMessageSender = new CommandExecutedMessageSender();
_domainEventHandledMessageSender = new DomainEventHandledMessageSender();
_eventPublisher = new EventPublisher();
configuration.SetDefault<ICommandService, CommandService>(_commandService);
configuration.SetDefault<IEventPublisher, EventPublisher>(_eventPublisher);
_commandConsumer = new CommandConsumer(consumerSetting, _commandExecutedMessageSender);
_eventConsumer = new EventConsumer(eventConsumerSetting, _domainEventHandledMessageSender);
_commandConsumer.Subscribe("NoteCommandTopic");
_eventConsumer.Subscribe("NoteEventTopic");
_commandResultProcessor.SetExecutedCommandMessageTopic("ExecutedCommandMessageTopic");
_commandResultProcessor.SetDomainEventHandledMessageTopic("DomainEventHandledMessageTopic");
return enodeConfiguration;
}
public void Start()
{
var setting = new EQueueConsumers.ConsumerSetting
{
AutoPull = false,
ConsumeFromWhere = (_consumerConfig.AutoOffsetReset == AutoOffsetReset.Smallest || _consumerConfig.AutoOffsetReset == AutoOffsetReset.Earliest) ?
EQueueMessages.ConsumeFromWhere.FirstOffset : EQueueMessages.ConsumeFromWhere.LastOffset,
ClusterName = ClusterName,
NameServerList = NameServerList
};
Consumer = new EQueueConsumers.Consumer(GroupId, setting)
.Subscribe(Topic)
.Start();
_cancellationTokenSource = new CancellationTokenSource();
_consumerTask = Task.Factory.StartNew(cs => ReceiveMessages(cs as CancellationTokenSource,
_onMessageReceived),
_cancellationTokenSource,
_cancellationTokenSource.Token,
TaskCreationOptions.LongRunning,
TaskScheduler.Default);
}
static void Main(string[] args)
{
InitializeEQueue();
var messageHandler = new MessageHandler();
var consumer1 = new Consumer("Consumer1", "group1").Subscribe("SampleTopic").Start(messageHandler);
var consumer2 = new Consumer("Consumer2", "group1").Subscribe("SampleTopic").Start(messageHandler);
var consumer3 = new Consumer("Consumer3", "group1").Subscribe("SampleTopic").Start(messageHandler);
var consumer4 = new Consumer("Consumer4", "group1").Subscribe("SampleTopic").Start(messageHandler);
var scheduleService = ObjectContainer.Resolve<IScheduleService>();
scheduleService.ScheduleTask(() =>
{
Console.WriteLine(string.Format("Consumer message queue allocation. c1:{0}, c2:{1}, c3:{2}, c4:{3}",
string.Join(",", consumer1.GetCurrentQueues().Select(x => x.QueueId)),
string.Join(",", consumer2.GetCurrentQueues().Select(x => x.QueueId)),
string.Join(",", consumer3.GetCurrentQueues().Select(x => x.QueueId)),
string.Join(",", consumer4.GetCurrentQueues().Select(x => x.QueueId))));
}, 5000, 5000);
Console.ReadLine();
}
public PullMessageService(Consumer consumer, ClientService clientService)
{
_consumer = consumer;
_clientService = clientService;
_clientId = clientService.GetClientId();
_binarySerializer = ObjectContainer.Resolve<IBinarySerializer>();
_scheduleService = ObjectContainer.Resolve<IScheduleService>();
_logger = ObjectContainer.Resolve<ILoggerFactory>().Create(GetType().FullName);
if (consumer.Setting.AutoPull)
{
if (consumer.Setting.MessageHandleMode == MessageHandleMode.Sequential)
{
_consumingMessageQueue = new BlockingCollection<ConsumingMessage>();
_consumeMessageWorker = new Worker("ConsumeMessage", () => HandleMessage(_consumingMessageQueue.Take()));
}
_messageRetryQueue = new BlockingCollection<ConsumingMessage>();
}
else
{
_pulledMessageQueue = new BlockingCollection<QueueMessage>();
}
}
public ConnectionEventListener(Consumer consumer)
{
_consumer = consumer;
}
public ConnectionEventListener(Consumer consumer)
{
_consumer = consumer;
}