public Task<SendResult> SendAsync(Message message, object arg)
{
var queueIds = GetTopicQueueIds(message.Topic);
var queueId = _queueSelector.SelectQueueId(queueIds, message, arg);
var remotingRequest = BuildSendMessageRequest(message, queueId);
var taskCompletionSource = new TaskCompletionSource<SendResult>();
_remotingClient.InvokeAsync(remotingRequest, Setting.SendMessageTimeoutMilliseconds).ContinueWith((requestTask) =>
{
var remotingResponse = requestTask.Result;
if (remotingResponse != null)
{
var response = _binarySerializer.Deserialize<SendMessageResponse>(remotingResponse.Body);
var result = new SendResult(SendStatus.Success, response.MessageOffset, response.MessageQueue, response.QueueOffset);
taskCompletionSource.SetResult(result);
}
else
{
var errorMessage = "Unknown error occurred when sending message to broker.";
if (!requestTask.IsCompleted)
{
errorMessage = "Send message to broker timeout.";
}
else if (requestTask.IsFaulted)
{
errorMessage = requestTask.Exception.Message;
}
taskCompletionSource.SetResult(new SendResult(SendStatus.Failed, errorMessage));
}
});
return taskCompletionSource.Task;
}
public QueueMessage StoreMessage(int queueId, long queueOffset, Message message)
{
var nextOffset = GetNextOffset();
var queueMessage = new QueueMessage(message.Topic, message.Body, nextOffset, queueId, queueOffset, DateTime.Now);
_messageDict[nextOffset] = queueMessage;
return queueMessage;
}
public async Task<SendResult> SendAsync(Message message, string routingKey, int timeoutMilliseconds = 120000)
{
Ensure.NotNull(message, "message");
var queueId = GetAvailableQueueId(message, routingKey);
if (queueId < 0)
{
throw new Exception(string.Format("No available routing queue for topic [{0}].", message.Topic));
}
var remotingRequest = BuildSendMessageRequest(message, queueId);
try
{
var remotingResponse = await _remotingClient.InvokeAsync(remotingRequest, timeoutMilliseconds).ConfigureAwait(false);
if (remotingResponse == null)
{
return new SendResult(SendStatus.Timeout, null, string.Format("Send message timeout, message: {0}, routingKey: {1}, timeoutMilliseconds: {2}", message, routingKey, timeoutMilliseconds));
}
return ParseSendResult(remotingResponse);
}
catch (Exception ex)
{
return new SendResult(SendStatus.Failed, null, ex.Message);
}
}
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()));
}
static void WriteMessagePerfTest()
{
var threadCount = int.Parse(ConfigurationManager.AppSettings["concurrentThreadCount"]); //并行写消息的线程数
var messageSize = int.Parse(ConfigurationManager.AppSettings["messageSize"]); //消息大小，字节为单位
var messageCount = int.Parse(ConfigurationManager.AppSettings["messageCount"]); //总共要写入的消息数
var payload = new byte[messageSize];
var message = new Message("topic1", 100, payload);
var queue = new Queue(message.Topic, 1);
var count = 0L;
_watch = Stopwatch.StartNew();
StartPrintThroughputTask();
for (var i = 0; i < threadCount; i++)
{
Task.Factory.StartNew(() =>
{
while (true)
{
var current = Interlocked.Increment(ref count);
if (current > messageCount)
{
break;
}
_messageStore.StoreMessageAsync(queue, message, (x, y) =>
{
Interlocked.Increment(ref _currentCount);
}, null);
}
});
}
}
public void SendAsync(CommandExecutedMessage message, string topic)
{
var messageJson = _jsonSerializer.Serialize(message);
var messageBytes = Encoding.UTF8.GetBytes(messageJson);
var equeueMessage = new EQueueMessage(topic, (int)EQueueMessageTypeCode.CommandExecutedMessage, messageBytes);
SendMessageAsync(equeueMessage, messageJson, message.CommandId, 0);
}
public int SelectQueueId(IList<int> availableQueueIds, Message message, string routingKey)
{
if (availableQueueIds.Count == 0)
{
return -1;
}
return availableQueueIds[(int)(Interlocked.Increment(ref _index) % availableQueueIds.Count)];
}
public int SelectQueueId(IList<int> availableQueueIds, Message message, object arg)
{
if (availableQueueIds.Count == 0)
{
throw new Exception(string.Format("No available queue for topic [{0}].", message.Topic));
}
return availableQueueIds[(int)(Interlocked.Increment(ref _index) % availableQueueIds.Count)];
}
public SendResult Send(Message message, object arg)
{
var queueIds = GetTopicQueueIds(message.Topic);
var queueId = _queueSelector.SelectQueueId(queueIds, message, arg);
var remotingRequest = BuildSendMessageRequest(message, queueId);
var remotingResponse = _remotingClient.InvokeSync(remotingRequest, Setting.SendMessageTimeoutMilliseconds);
var response = _binarySerializer.Deserialize<SendMessageResponse>(remotingResponse.Body);
return new SendResult(SendStatus.Success, response.MessageOffset, response.MessageQueue, response.QueueOffset);
}
public SendResult Send(Message message, object routingKey, int timeoutMilliseconds = 30000)
{
var sendResult = SendAsync(message, routingKey, timeoutMilliseconds).WaitResult<SendResult>(timeoutMilliseconds + 1000);
if (sendResult == null)
{
sendResult = new SendResult(SendStatus.Timeout, string.Format("Send message timeout, message: {0}, routingKey: {1}, timeoutMilliseconds: {2}", message, routingKey, timeoutMilliseconds));
}
return sendResult;
}
public int SelectQueueId(int totalQueueCount, Message message, object arg)
{
var value = arg.GetHashCode();
if (value < 0)
{
value = Math.Abs(value);
}
return value % totalQueueCount;
}
private void SendMessageAsync(EQueueMessage message, string messageJson, string routingKey, int retryTimes)
{
_ioHelper.TryAsyncActionRecursively <AsyncTaskResult>("PublishQueueMessageAsync",
() => _sendMessageService.SendMessageAsync(_producer, message, routingKey),
currentRetryTimes => SendMessageAsync(message, messageJson, routingKey, currentRetryTimes),
null,
() => string.Format("[message:{0}]", messageJson),
null,
retryTimes);
}
public MessageReply(string topic, string messageID, object result)
: this()
{
if (result != null)
{
Message = new EQueueProtocols.Message(topic, Encoding.UTF8.GetBytes(this.ToJson()));
}
MessageID = messageID;
Result = result;
}
public MessageReply(string topic, string messageID, object result)
: this()
{
if (result != null)
{
Message = new EQueueProtocols.Message(topic, Encoding.UTF8.GetBytes(this.ToJson()));
}
MessageID = messageID;
Result = result;
}
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 void Send(DomainEventHandledMessage message, string topic)
{
var messageJson = _jsonSerializer.Serialize(message);
var messageBytes = Encoding.UTF8.GetBytes(messageJson);
var equeueMessage = new EQueueMessage(topic, (int)EQueueMessageTypeCode.DomainEventHandledMessage, messageBytes);
_ioHelper.TryIOActionRecursively("DomainEventHandledMessage", () => messageJson, () =>
{
_ioHelper.TryIOAction(() => _producer.SendAsync(equeueMessage, message.CommandId), "DomainEventHandledMessageAsync");
});
}
public MessageLogRecord StoreMessage(int queueId, long queueOffset, Message message)
{
var record = new MessageLogRecord(
message.Topic,
message.Code,
message.Body,
queueId,
queueOffset,
message.CreatedTime,
DateTime.Now,
message.Tag);
_chunkWriter.Write(record);
return record;
}
public SendResult Send(Message message, object arg)
{
var queueCount = GetTopicQueueCount(message.Topic);
if (queueCount == 0)
{
throw new Exception(string.Format("No available queue for topic [{0}], producerId:{1}.", message.Topic, Id));
}
var queueId = _queueSelector.SelectQueueId(queueCount, message, arg);
var remotingRequest = BuildSendMessageRequest(message, queueId);
var remotingResponse = _remotingClient.InvokeSync(remotingRequest, Setting.SendMessageTimeoutMilliseconds);
var response = _binarySerializer.Deserialize<SendMessageResponse>(remotingResponse.Body);
var sendStatus = SendStatus.Success; //TODO, figure from remotingResponse.Code;
return new SendResult(sendStatus, response.MessageOffset, response.MessageQueue, response.QueueOffset);
}
public MessageStoreResult StoreMessage(Message message, int queueId)
{
var queues = GetQueues(message.Topic);
var queueCount = queues.Count;
if (queueId >= queueCount || queueId < 0)
{
throw new InvalidQueueIdException(message.Topic, queueCount, queueId);
}
var queue = queues[queueId];
var queueOffset = queue.IncrementCurrentOffset();
var storeResult = _messageStore.StoreMessage(message, queue.QueueId, queueOffset);
queue.SetMessageOffset(queueOffset, storeResult.MessageOffset);
return storeResult;
}
public SendResult Send(Message message, string routingKey, int timeoutMilliseconds = 30 * 1000)
{
if (!_started)
{
throw new Exception("Producer not started, please start the producer first.");
}
var sendResult = SendAsync(message, routingKey, timeoutMilliseconds).WaitResult(timeoutMilliseconds + 3000);
if (sendResult == null)
{
sendResult = new SendResult(SendStatus.Timeout, null, string.Format("Send message timeout, message: {0}, routingKey: {1}, timeoutMilliseconds: {2}", message, routingKey, timeoutMilliseconds));
}
return sendResult;
}
public MessageStoreResult StoreMessage(Message message, int queueId, string routingKey)
{
var queue = _queueService.GetQueue(message.Topic, queueId);
if (queue == null)
{
throw new Exception(string.Format("Queue not exist, topic: {0}, queueId: {1}", message.Topic, queueId));
}
lock (_syncObj)
{
var messageOffset = _messageStore.GetNextMessageOffset();
var queueOffset = queue.IncrementCurrentOffset();
var queueMessage = _messageStore.StoreMessage(queueId, messageOffset, queueOffset, message, routingKey);
queue.SetQueueIndex(queueMessage.QueueOffset, queueMessage.MessageOffset);
return new MessageStoreResult(queueMessage.MessageId, queueMessage.MessageOffset, queueMessage.QueueId, queueMessage.QueueOffset);
}
}
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));
}
}
public MessageStoreResult StoreMessage(Message message, int queueId)
{
var queues = GetQueues(message.Topic);
if (queues.Count == 0)
{
throw new Exception(string.Format("No available queue for storing message. topic:{0}", message.Topic));
}
var queue = queues.SingleOrDefault(x => x.QueueId == queueId);
if (queue == null)
{
throw new InvalidQueueIdException(message.Topic, queues.Select(x => x.QueueId), queueId);
}
var queueOffset = queue.IncrementCurrentOffset();
var queueMessage = _messageStore.StoreMessage(queueId, queueOffset, message);
queue.SetQueueIndex(queueMessage.QueueOffset, queueMessage.MessageOffset);
return new MessageStoreResult(queueMessage.MessageOffset, queueMessage.QueueId, queueMessage.QueueOffset);
}
public MessageQueue SelectMessageQueue(IList<MessageQueue> availableMessageQueues, Message message, string routingKey)
{
if (availableMessageQueues.Count == 0)
{
return null;
}
unchecked
{
int hash = 23;
foreach (char c in routingKey)
{
hash = (hash << 5) - hash + c;
}
if (hash < 0)
{
hash = Math.Abs(hash);
}
return availableMessageQueues[hash % availableMessageQueues.Count];
}
}
public int SelectQueueId(IList<int> availableQueueIds, Message message, string routingKey)
{
if (availableQueueIds.Count == 0)
{
return -1;
}
unchecked
{
int hash = 23;
foreach (char c in routingKey)
{
hash = (hash << 5) - hash + c;
}
if (hash < 0)
{
hash = Math.Abs(hash);
}
return availableQueueIds[(int)(hash % availableQueueIds.Count)];
}
}
static void WriteMessagePerfTest()
{
var threadCount = int.Parse(ConfigurationManager.AppSettings["concurrentThreadCount"]); //并行写消息的线程数
var messageSize = int.Parse(ConfigurationManager.AppSettings["messageSize"]); //消息大小，字节为单位
var messageCount = int.Parse(ConfigurationManager.AppSettings["messageCount"]); //总共要写入的消息数
var payload = new byte[messageSize];
var message = new Message("topic1", 100, payload);
for (var i = 0; i < threadCount; i++)
{
Task.Factory.StartNew(() =>
{
for (var j = 0; j < messageCount; j++)
{
_messageStore.StoreMessage(1, 1000, message);
Interlocked.Increment(ref _currentCount);
}
});
}
}
public int SelectQueueId(IList<int> availableQueueIds, Message message, object arg)
{
if (availableQueueIds.Count == 0)
{
throw new Exception(string.Format("No available queue for topic [{0}].", message.Topic));
}
unchecked
{
int hash = 23;
foreach (char c in arg.ToString())
{
hash = (hash << 5) - hash + c;
}
if (hash < 0)
{
hash = Math.Abs(hash);
}
return availableQueueIds[(int)(hash % availableQueueIds.Count)];
}
}
public async Task<SendResult> SendAsync(Message message, object routingKey, int timeoutMilliseconds = 30000)
{
Ensure.NotNull(message, "message");
var currentRoutingKey = GetStringRoutingKey(routingKey);
var queueIds = GetTopicQueueIds(message.Topic);
var queueId = _queueSelector.SelectQueueId(queueIds, message, currentRoutingKey);
if (queueId < 0)
{
throw new Exception(string.Format("No available routing queue for topic [{0}].", message.Topic));
}
var remotingRequest = BuildSendMessageRequest(message, queueId, currentRoutingKey);
try
{
var remotingResponse = await _remotingClient.InvokeAsync(remotingRequest, timeoutMilliseconds).ConfigureAwait(false);
if (remotingResponse == null)
{
return new SendResult(SendStatus.Timeout, string.Format("Send message timeout, message: {0}, routingKey: {1}, timeoutMilliseconds: {2}", message, routingKey, timeoutMilliseconds));
}
if (remotingResponse.Code == (int)ResponseCode.Success)
{
var response = Encoding.UTF8.GetString(remotingResponse.Body).Split(':');
return new SendResult(SendStatus.Success, response[2], long.Parse(response[0]), new MessageQueue(message.Topic, queueId), long.Parse(response[1]));
}
else
{
return new SendResult(SendStatus.Failed, Encoding.UTF8.GetString(remotingResponse.Body));
}
}
catch (Exception ex)
{
return new SendResult(SendStatus.Failed, ex.Message);
}
}
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 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);
});
}
private int GetAvailableQueueId(Message message, string routingKey)
{
var queueIds = GetTopicQueueIds(message.Topic);
if (queueIds.IsEmpty())
{
return -1;
}
return _queueSelector.SelectQueueId(queueIds, message, routingKey);
}
public int SelectQueueId(int totalQueueCount, Message message, object arg)
{
return (int)(Interlocked.Increment(ref _index) % totalQueueCount);
}
private RemotingRequest BuildSendMessageRequest(Message message, int queueId, object routingKey)
{
var request = new SendMessageRequest { Message = message, QueueId = queueId, RoutingKey = routingKey.ToString() };
var data = MessageUtils.EncodeSendMessageRequest(request);
return new RemotingRequest((int)RequestCode.SendMessage, data);
}
public QueueMessage StoreMessage(int queueId, long messageOffset, long queueOffset, Message message, string routingKey)
{
var queueMessage = new QueueMessage(
ObjectId.GenerateNewStringId(),
message.Topic,
message.Code,
message.Body,
messageOffset,
queueId,
queueOffset,
message.CreatedTime,
DateTime.Now,
DateTime.Now,
routingKey);
_messageDict[messageOffset] = queueMessage;
return queueMessage;
}
private RemotingRequest BuildSendMessageRequest(Message message, int queueId)
{
var request = new SendMessageRequest { Message = message, QueueId = queueId };
var data = MessageUtils.EncodeSendMessageRequest(request);
return new RemotingRequest((int)RequestCode.SendMessage, data);
}
public Task<SendResult> SendAsync(Message message, object arg)
{
var queueCount = GetTopicQueueCount(message.Topic);
if (queueCount == 0)
{
throw new Exception(string.Format("No available queue for topic [{0}], producerId:{1}.", message.Topic, Id));
}
var queueId = _queueSelector.SelectQueueId(queueCount, message, arg);
var remotingRequest = BuildSendMessageRequest(message, queueId);
var taskCompletionSource = new TaskCompletionSource<SendResult>();
_remotingClient.InvokeAsync(remotingRequest, Setting.SendMessageTimeoutMilliseconds).ContinueWith((requestTask) =>
{
var remotingResponse = requestTask.Result;
if (remotingResponse != null)
{
var response = _binarySerializer.Deserialize<SendMessageResponse>(remotingResponse.Body);
var sendStatus = SendStatus.Success; //TODO, figure from remotingResponse.Code;
var result = new SendResult(sendStatus, response.MessageOffset, response.MessageQueue, response.QueueOffset);
taskCompletionSource.SetResult(result);
}
else
{
var result = new SendResult(SendStatus.Failed, "Send message request failed or wait for response timeout.");
taskCompletionSource.SetResult(result);
}
});
return taskCompletionSource.Task;
}
