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 SendMessageTest()
{
_mode = ConfigurationManager.AppSettings["Mode"];
var address = ConfigurationManager.AppSettings["BrokerAddress"];
var brokerAddress = string.IsNullOrEmpty(address) ? SocketUtils.GetLocalIPV4() : IPAddress.Parse(address);
var clientCount = int.Parse(ConfigurationManager.AppSettings["ClientCount"]);
var messageSize = int.Parse(ConfigurationManager.AppSettings["MessageSize"]);
var messageCount = int.Parse(ConfigurationManager.AppSettings["MessageCount"]);
var actions = new List<Action>();
var payload = new byte[messageSize];
var topic = ConfigurationManager.AppSettings["Topic"];
var message = new Message(topic, 100, payload);
for (var i = 0; i < clientCount; i++)
{
var setting = new ProducerSetting
{
BrokerAddress = new IPEndPoint(brokerAddress, 5000),
BrokerAdminAddress = new IPEndPoint(brokerAddress, 5002)
};
var producer = new Producer(setting).Start();
actions.Add(() => SendMessages(producer, _mode, messageCount, message));
}
Task.Factory.StartNew(() => Parallel.Invoke(actions.ToArray()));
}
public EventPublisher(ProducerSetting setting, string id)
{
_producer = new Producer(setting, id);
_binarySerializer = ObjectContainer.Resolve<IBinarySerializer>();
_eventTopicProvider = ObjectContainer.Resolve<IEventTopicProvider>();
_eventTypeCodeProvider = ObjectContainer.Resolve<IEventTypeCodeProvider>();
_logger = ObjectContainer.Resolve<ILoggerFactory>().Create(GetType().Name);
}
public EventPublisher(string id, string topic, EQueueClientsProducers.ProducerSetting producerSetting)
{
Topic = topic;
Id = id;
_Logger = IoCFactory.Resolve<ILoggerFactory>().Create(this.GetType());
MessageQueue = new BlockingCollection<EQueueProtocols.Message>();
Producer = new EQueueClientsProducers.Producer(Id, producerSetting);
}
public EventPublisher(string id, string topic, EQueueClientsProducers.ProducerSetting producerSetting)
{
Topic = topic;
Id = id;
_Logger = IoCFactory.Resolve <ILoggerFactory>().Create(this.GetType());
MessageQueue = new BlockingCollection <EQueueProtocols.Message>();
Producer = new EQueueClientsProducers.Producer(Id, producerSetting);
}
public CommandService(CommandResultProcessor commandResultProcessor, ProducerSetting setting, string id)
{
_commandResultProcessor = commandResultProcessor;
_producer = new Producer(setting, id);
_binarySerializer = ObjectContainer.Resolve<IBinarySerializer>();
_commandTopicProvider = ObjectContainer.Resolve<ICommandTopicProvider>();
_commandTypeCodeProvider = ObjectContainer.Resolve<ICommandTypeCodeProvider>();
_logger = ObjectContainer.Resolve<ILoggerFactory>().Create(GetType().Name);
}
public void SendMessage(Producer producer, EQueueMessage message, object routingKey)
{
_ioHelper.TryIOAction(() =>
{
var result = producer.Send(message, routingKey);
if (result.SendStatus != SendStatus.Success)
{
throw new IOException(result.ErrorMessage);
}
}, "SendQueueMessage");
}
public CommandService(CommandResultProcessor commandResultProcessor = null, string id = null, ProducerSetting setting = null)
{
_commandResultProcessor = commandResultProcessor;
_producer = new Producer(id ?? DefaultCommandServiceProcuderId, setting ?? new ProducerSetting());
_jsonSerializer = ObjectContainer.Resolve<IJsonSerializer>();
_commandTopicProvider = ObjectContainer.Resolve<ITopicProvider<ICommand>>();
_commandTypeCodeProvider = ObjectContainer.Resolve<ITypeCodeProvider>();
_commandRouteKeyProvider = ObjectContainer.Resolve<ICommandRoutingKeyProvider>();
_sendMessageService = new SendQueueMessageService();
_logger = ObjectContainer.Resolve<ILoggerFactory>().Create(GetType().FullName);
_ioHelper = ObjectContainer.Resolve<IOHelper>();
}
public CommandConsumer(string name, EQueueClientsConsumers.ConsumerSetting consumerSetting, string groupName,
string subscribeTopic, string brokerAddress, int producerBrokerPort,
IHandlerProvider handlerProvider)
: base(name, consumerSetting, groupName, subscribeTopic)
{
HandlerProvider = handlerProvider;
var producerSetting = new EQueueClientsProducers.ProducerSetting();
producerSetting.BrokerAddress = brokerAddress;
producerSetting.BrokerPort = producerBrokerPort;
Producer = new EQueueClientsProducers.Producer(string.Format("{0}-Reply-Producer", name), producerSetting);
CommandConsumers.Add(this);
}
public async Task<AsyncTaskResult> SendMessageAsync(Producer producer, EQueueMessage message, object routingKey)
{
try
{
var result = await producer.SendAsync(message, routingKey);
if (result.SendStatus != SendStatus.Success)
{
return new AsyncTaskResult(AsyncTaskStatus.IOException, result.ErrorMessage);
}
return AsyncTaskResult.Success;
}
catch (Exception ex)
{
return new AsyncTaskResult(AsyncTaskStatus.IOException, ex.Message);
}
}
static void SendMessage(Producer producer, IndexEntry indexEntry)
{
var message = "message" + Interlocked.Increment(ref messageIndex);
producer.SendAsync(new Message("SampleTopic", Encoding.UTF8.GetBytes(message)), indexEntry.Index.ToString()).ContinueWith(sendTask =>
{
var finishedCount = Interlocked.Increment(ref finished);
if (finishedCount % 1000 == 0)
{
_logger.InfoFormat("Sent {0} messages, time spent:{1}", finishedCount, watch.ElapsedMilliseconds);
}
if (indexEntry.Index < indexEntry.Total)
{
indexEntry.Index++;
SendMessage(producer, indexEntry);
}
});
}
public override void Start()
{
#region init sending commands Worker
#region Init Command Queue client
Producer = new EQueueClientsProducers.Producer(string.Format("{0}-Reply-Producer", ProducerName), ProducerSetting);
Producer.Start();
#endregion
SendCommandWorkTask = Task.Factory.StartNew(() =>
{
try
{
using (var messageStore = IoCFactory.Resolve <IMessageStore>())
{
messageStore.GetAllUnSentCommands()
.ForEach(commandContext => ToBeSentCommandQueue.Add(commandContext as MessageContext));
}
}
catch (Exception ex)
{
_Logger.Error("Get all unsent commands failed", ex);
}
while (!_exit)
{
try
{
var commandContext = ToBeSentCommandQueue.Take();
SendCommand(commandContext);
}
catch (Exception ex)
{
_Logger.Debug("send command quit", ex);
}
}
}, TaskCreationOptions.LongRunning);
#endregion
#region init process command reply worker
base.Start();
#endregion
}
public async Task<AsyncTaskResult> SendMessageAsync(Producer producer, EQueueMessage message, string routingKey)
{
try
{
var result = await producer.SendAsync(message, routingKey);
if (result.SendStatus != SendStatus.Success)
{
_logger.ErrorFormat("EQueue message async send failed, sendResult: {0}, routingKey: {1}", result, routingKey);
return new AsyncTaskResult(AsyncTaskStatus.IOException, result.ErrorMessage);
}
_logger.InfoFormat("EQueue message async send success, sendResult: {0}, routingKey: {1}", result, routingKey);
return AsyncTaskResult.Success;
}
catch (Exception ex)
{
_logger.Error(string.Format("EQueue message async send has exception, message: {0}, routingKey: {1}", message, routingKey), ex);
return new AsyncTaskResult(AsyncTaskStatus.IOException, ex.Message);
}
}
static void Main(string[] args)
{
InitializeEQueue();
var brokerIP = ConfigurationManager.AppSettings["BrokerIP"];
var brokerEndPoint = string.IsNullOrEmpty(brokerIP) ? new IPEndPoint(SocketUtils.GetLocalIPV4(), 5000) : new IPEndPoint(IPAddress.Parse(brokerIP), 5000);
var producer = new Producer("Producer1", new ProducerSetting { BrokerProducerIPEndPoint = brokerEndPoint }).Start();
var messageSize = int.Parse(ConfigurationManager.AppSettings["MessageSize"]);
var messageCount = int.Parse(ConfigurationManager.AppSettings["MessageCount"]);
var message = new byte[messageSize];
var sendCallback = new Action<Task<SendResult>>(sendTask =>
{
if (sendTask.Exception != null)
{
_logger.ErrorFormat("Sent message failed, errorMessage: {0}", sendTask.Exception.GetBaseException().Message);
return;
}
if (sendTask.Result.SendStatus == SendStatus.Success)
{
var finishedCount = Interlocked.Increment(ref finished);
if (finishedCount == 1)
{
watch = Stopwatch.StartNew();
}
if (finishedCount % 10000 == 0)
{
_logger.InfoFormat("Sent {0} messages, time spent:{1}", finishedCount, watch.ElapsedMilliseconds);
}
}
else
{
_logger.ErrorFormat("Sent message failed, errorMessage: {0}", sendTask.Result.ErrorMessage);
}
});
for (var index = 1; index <= messageCount; index++)
{
producer.SendAsync(new Message("SampleTopic", 100, message), Interlocked.Increment(ref messageIndex)).ContinueWith(sendCallback);
}
Console.ReadLine();
}
public void SendMessage(Producer producer, EQueueMessage message, string routingKey)
{
try
{
_ioHelper.TryIOAction(() =>
{
var result = producer.Send(message, routingKey);
if (result.SendStatus != SendStatus.Success)
{
_logger.ErrorFormat("EQueue message sync send failed, sendResult: {0}, routingKey: {1}", result, routingKey);
throw new IOException(result.ErrorMessage);
}
_logger.InfoFormat("EQueue message sync send success, sendResult: {0}, routingKey: {1}", result, routingKey);
}, "SendQueueMessage");
}
catch (Exception ex)
{
_logger.Error(string.Format("EQueue message synch send has exception, message: {0}, routingKey: {1}", message, routingKey), ex);
throw;
}
}
static void Main(string[] args)
{
InitializeEQueue();
var scheduleService = ObjectContainer.Resolve<IScheduleService>();
var producer = new Producer().Start();
var total = 1000;
var parallelCount = 10;
var finished = 0;
var messageIndex = 0;
var watch = Stopwatch.StartNew();
var action = new Action(() =>
{
for (var index = 1; index <= total; index++)
{
var message = "message" + Interlocked.Increment(ref messageIndex);
producer.SendAsync(new Message("SampleTopic", Encoding.UTF8.GetBytes(message)), index.ToString()).ContinueWith(sendTask =>
{
var finishedCount = Interlocked.Increment(ref finished);
if (finishedCount % 1000 == 0)
{
Console.WriteLine(string.Format("Sent {0} messages, time spent:{1}", finishedCount, watch.ElapsedMilliseconds));
}
});
}
});
var actions = new List<Action>();
for (var index = 0; index < parallelCount; index++)
{
actions.Add(action);
}
Parallel.Invoke(actions.ToArray());
Console.ReadLine();
}
static void SendMessages(Producer producer, string mode, int count, int sleepMilliseconds, int batchSize, Message message)
{
_logger.InfoFormat("----Send message starting, producerId:{0}----", producer.Id);
if (mode == "Oneway")
{
for (var i = 1; i <= count; i++)
{
TryAction(() => producer.SendOneway(message, message.Key));
var current = Interlocked.Increment(ref _sendingCount);
if (current % 10000 == 0)
{
_logger.InfoFormat("Sening {0} messages, timeSpent: {1}ms, throughput: {2}/s", current, _watch.ElapsedMilliseconds, current * 1000 / _watch.ElapsedMilliseconds);
}
WaitIfNecessory(current, batchSize, sleepMilliseconds);
}
}
else if (mode == "Async")
{
for (var i = 1; i <= count; i++)
{
TryAction(() => producer.SendAsync(message, message.Key, 100000).ContinueWith(SendCallback));
var current = Interlocked.Increment(ref _sendingCount);
WaitIfNecessory(current, batchSize, sleepMilliseconds);
}
}
else if (mode == "Callback")
{
producer.RegisterResponseHandler(new ResponseHandler());
for (var i = 1; i <= count; i++)
{
TryAction(() => producer.SendWithCallback(message, message.Key));
var current = Interlocked.Increment(ref _sendingCount);
WaitIfNecessory(current, batchSize, sleepMilliseconds);
}
}
}
static void Main(string[] args)
{
InitializeEQueue();
var scheduleService = ObjectContainer.Resolve<IScheduleService>();
var producer = new Producer("Producer1").Start();
var total = 10000;
var parallelCount = 10;
var action = new Action(() =>
{
SendMessage(producer, new IndexEntry { Index = 1, Total = total });
});
var actions = new List<Action>();
for (var index = 0; index < parallelCount; index++)
{
actions.Add(action);
}
Parallel.Invoke(actions.ToArray());
Console.ReadLine();
}
static Task SendMessageAsync(Producer producer, Message message, string routingKey)
{
return producer.SendAsync(message, routingKey).ContinueWith(t =>
{
if (t.Exception != null)
{
_logger.ErrorFormat("Send message has exception, errorMessage: {0}", t.Exception.GetBaseException().Message);
return;
}
if (t.Result == null)
{
_logger.Error("Send message timeout.");
return;
}
if (t.Result.SendStatus != SendStatus.Success)
{
_logger.ErrorFormat("Send message failed, errorMessage: {0}", t.Result.ErrorMessage);
return;
}
_sendResultLogger.InfoFormat("Message send success, routingKey: {0}, sendResult: {1}", routingKey, t.Result);
Interlocked.Increment(ref _sentCount);
});
}
public ConnectionEventListener(Producer producer)
{
_producer = producer;
}
public CommandExecutedMessageSender(ProducerSetting setting, string id)
{
_producer = new Producer(setting, id);
_binarySerializer = ObjectContainer.Resolve<IBinarySerializer>();
}
static void SendMessageTest()
{
var serverAddress = ConfigurationManager.AppSettings["ServerAddress"];
var mode = ConfigurationManager.AppSettings["Mode"];
var brokerAddress = string.IsNullOrEmpty(serverAddress) ? SocketUtils.GetLocalIPV4() : IPAddress.Parse(serverAddress);
var clientCount = int.Parse(ConfigurationManager.AppSettings["ClientCount"]);
var messageSize = int.Parse(ConfigurationManager.AppSettings["MessageSize"]);
var messageCount = int.Parse(ConfigurationManager.AppSettings["MessageCount"]);
var sleepMilliseconds = int.Parse(ConfigurationManager.AppSettings["SleepMilliseconds"]);
var batchSize = int.Parse(ConfigurationManager.AppSettings["BatchSize"]);
var actions = new List<Action>();
var payload = new byte[messageSize];
var message = new Message("SampleTopic", 100, ObjectId.GenerateNewStringId(), payload);
for (var i = 1; i <= clientCount; i++)
{
var producer = new Producer("Producer@" + i.ToString(), new ProducerSetting { BrokerAddress = new IPEndPoint(brokerAddress, 5000) }).Start();
actions.Add(() => SendMessages(producer, mode, messageCount, sleepMilliseconds, batchSize, message));
}
_watch.Start();
Task.Factory.StartNew(() => Parallel.Invoke(actions.ToArray()));
}
static void SendMessages(Producer producer, string mode, int messageCount, Message message)
{
_logger.Info("----Send message starting----");
var sendAction = default(Action<int>);
if (_mode == "Oneway")
{
sendAction = index =>
{
producer.SendOneway(message, index.ToString());
Interlocked.Increment(ref _sentCount);
};
}
else if (_mode == "Sync")
{
sendAction = index =>
{
var result = producer.Send(message, index.ToString());
if (result.SendStatus != SendStatus.Success)
{
throw new Exception(result.ErrorMessage);
}
Interlocked.Increment(ref _sentCount);
};
}
else if (_mode == "Async")
{
sendAction = index => producer.SendAsync(message, index.ToString()).ContinueWith(t =>
{
if (t.Exception != null)
{
_hasError = true;
_logger.ErrorFormat("Send message has exception, errorMessage: {0}", t.Exception.GetBaseException().Message);
return;
}
if (t.Result == null)
{
_hasError = true;
_logger.Error("Send message timeout.");
return;
}
if (t.Result.SendStatus != SendStatus.Success)
{
_hasError = true;
_logger.ErrorFormat("Send message failed, errorMessage: {0}", t.Result.ErrorMessage);
return;
}
Interlocked.Increment(ref _sentCount);
});
}
else if (_mode == "Callback")
{
producer.RegisterResponseHandler(new ResponseHandler());
sendAction = index => producer.SendWithCallback(message, index.ToString());
}
Task.Factory.StartNew(() =>
{
for (var i = 0; i < messageCount; i++)
{
try
{
sendAction(i);
}
catch (Exception ex)
{
_hasError = true;
_logger.ErrorFormat("Send message failed, errorMsg:{0}", ex.Message);
}
if (_hasError)
{
Thread.Sleep(3000);
_hasError = false;
}
}
});
}
static void SendMessage()
{
var brokerIP = ConfigurationManager.AppSettings["BrokerAddress"];
var brokerEndPoint = string.IsNullOrEmpty(brokerIP) ? new IPEndPoint(SocketUtils.GetLocalIPV4(), 5000) : new IPEndPoint(IPAddress.Parse(brokerIP), 5000);
var messageSize = int.Parse(ConfigurationManager.AppSettings["MessageSize"]);
var connectionCount = int.Parse(ConfigurationManager.AppSettings["ConnectionCount"]);
var flowControlCount = int.Parse(ConfigurationManager.AppSettings["FlowControlCount"]);
var maxMessageCount = int.Parse(ConfigurationManager.AppSettings["MaxMessageCount"]);
var payload = new byte[messageSize];
var message = new Message("SampleTopic", 100, payload);
var messageIndex = 0L;
var sendingCount = 0L;
var finishedCount = 0L;
var previousFinishedCount = 0L;
var previousElapsedMilliseconds = 0L;
var flowControlledCount = 0;
var watch = Stopwatch.StartNew();
for (var i = 0; i < connectionCount; i++)
{
Task.Factory.StartNew(() =>
{
var producer = new Producer("Producer@" + ObjectId.GenerateNewStringId(), new ProducerSetting { BrokerProducerIPEndPoint = brokerEndPoint }).Start();
while (true)
{
var waitingCount = sendingCount - finishedCount;
if (waitingCount > flowControlCount)
{
Thread.Sleep(1);
var current = Interlocked.Increment(ref flowControlledCount);
if (current % 1000 == 0)
{
_logger.InfoFormat("Start to flow control, pending messages: {0}, flow count: {1}", waitingCount, current);
}
continue;
}
producer.SendAsync(message, Interlocked.Increment(ref messageIndex), 300000).ContinueWith(sendTask =>
{
if (sendTask.Exception != null)
{
_logger.ErrorFormat("Sent message failed, errorMessage: {0}", sendTask.Exception.GetBaseException().Message);
return;
}
if (sendTask.Result.SendStatus == SendStatus.Success)
{
var currentFinishedCount = Interlocked.Increment(ref finishedCount);
if (currentFinishedCount % 10000 == 0)
{
var currentElapsedMilliseconds = watch.ElapsedMilliseconds;
_logger.InfoFormat("Sent {0} messages, time elapsed: {1}ms, current throughput: {2}, average throughput: {3}",
currentFinishedCount,
currentElapsedMilliseconds,
(currentFinishedCount - previousFinishedCount) * 1000 / (currentElapsedMilliseconds - previousElapsedMilliseconds),
currentFinishedCount * 1000 / currentElapsedMilliseconds);
Interlocked.Exchange(ref previousFinishedCount, currentFinishedCount);
Interlocked.Exchange(ref previousElapsedMilliseconds, currentElapsedMilliseconds);
}
}
else
{
_logger.ErrorFormat("Sent message failed, errorMessage: {0}", sendTask.Result.ErrorMessage);
}
});
var count = Interlocked.Increment(ref sendingCount);
if (count >= maxMessageCount)
{
break;
}
}
});
}
}
static void StartProducer()
{
var producer = new Producer("Producer1").Start();
var total = 1000;
var parallelCount = 10;
var finished = 0;
var messageIndex = 0;
var watch = Stopwatch.StartNew();
var action = new Action(() =>
{
for (var index = 1; index <= total; index++)
{
var message = "message" + Interlocked.Increment(ref messageIndex);
producer.SendAsync(new Message("SampleTopic", Encoding.UTF8.GetBytes(message)), index).ContinueWith(sendTask =>
{
var finishedCount = Interlocked.Increment(ref finished);
if (finishedCount % 1000 == 0)
{
_logger.InfoFormat("Sent {0} messages, time spent:{1}", finishedCount, watch.ElapsedMilliseconds);
}
});
}
});
var actions = new List<Action>();
for (var index = 0; index < parallelCount; index++)
{
actions.Add(action);
}
Parallel.Invoke(actions.ToArray());
}
public ConnectionEventListener(Producer producer)
{
_producer = producer;
}
public DomainEventHandledMessageSender(ProducerSetting setting, string id)
{
_producer = new Producer(setting, id);
_binarySerializer = ObjectContainer.Resolve<IBinarySerializer>();
}
static void SendMessages()
{
var setting = new ProducerSetting
{
BrokerAddress = new IPEndPoint(SocketUtils.GetLocalIPV4(), 5000),
BrokerAdminAddress = new IPEndPoint(SocketUtils.GetLocalIPV4(), 5002)
};
var producer = new Producer(setting).Start();
var index = 0L;
while (true)
{
var payload = Encoding.UTF8.GetBytes(index.ToString());
var message = new Message("topic1", 100, payload);
SendMessageAsync(producer, message, index.ToString());
index++;
Thread.Sleep(10);
}
}
