public RemotingResponse HandleRequest(IRequestHandlerContext context, RemotingRequest remotingRequest)
{
if (BrokerController.Instance.IsCleaning)
{
throw new BrokerCleanningException();
}
var request = _binarySerializer.Deserialize <QueryTopicQueueInfoRequest>(remotingRequest.Body);
var topicQueueInfoList = new List <TopicQueueInfo>();
var queues = _queueStore.QueryQueues(request.Topic).ToList().OrderBy(x => x.Topic).ThenBy(x => x.QueueId);
foreach (var queue in queues)
{
var topicQueueInfo = new TopicQueueInfo();
topicQueueInfo.Topic = queue.Topic;
topicQueueInfo.QueueId = queue.QueueId;
topicQueueInfo.QueueCurrentOffset = queue.NextOffset - 1;
topicQueueInfo.QueueMinOffset = queue.GetMinQueueOffset();
topicQueueInfo.QueueMinConsumedOffset = _offsetStore.GetMinConsumedOffset(queue.Topic, queue.QueueId);
topicQueueInfo.ProducerVisible = queue.Setting.ProducerVisible;
topicQueueInfo.ConsumerVisible = queue.Setting.ConsumerVisible;
topicQueueInfoList.Add(topicQueueInfo);
}
return(RemotingResponseFactory.CreateResponse(remotingRequest, _binarySerializer.Serialize(topicQueueInfoList)));
}
public RemotingResponse HandleRequest(IRequestHandlerContext context, RemotingRequest remotingRequest)
{
var request = MessageUtils.DecodeSendMessageRequest(remotingRequest.Body);
var message = request.Message;
var queueId = request.QueueId;
var queue = _queueStore.GetQueue(message.Topic, queueId);
if (queue == null)
{
throw new QueueNotExistException(message.Topic, queueId);
}
//消息写文件需要加锁，确保顺序写文件
MessageStoreResult result = null;
lock (_syncObj)
{
var queueOffset = queue.NextOffset;
var messageRecord = _messageStore.StoreMessage(queueId, queueOffset, message);
queue.AddMessage(messageRecord.LogPosition);
queue.IncrementNextOffset();
result = new MessageStoreResult(messageRecord.MessageId, message.Code, message.Topic, queueId, queueOffset);
}
//如果需要立即通知所有消费者有新消息，则立即通知
if (BrokerController.Instance.Setting.NotifyWhenMessageArrived)
{
_suspendedPullRequestManager.NotifyNewMessage(request.Message.Topic, result.QueueId, result.QueueOffset);
}
var data = MessageUtils.EncodeMessageStoreResult(result);
return(RemotingResponseFactory.CreateResponse(remotingRequest, data));
}
public RemotingResponse HandleRequest(IRequestHandlerContext context, RemotingRequest remotingRequest)
{
var request = _binarySerializer.Deserialize <RemoveQueueOffsetInfoRequest>(remotingRequest.Body);
_offsetManager.DeleteQueueOffset(request.ConsumerGroup, request.Topic, request.QueueId);
return(RemotingResponseFactory.CreateResponse(remotingRequest));
}
public RemotingResponse HandleRequest(IRequestHandlerContext context, RemotingRequest remotingRequest)
{
var request = _binarySerializer.Deserialize <QueryTopicQueueInfoRequest>(remotingRequest.Body);
var topicQueueInfoList = new List <TopicQueueInfo>();
var topicList = !string.IsNullOrEmpty(request.Topic) ? new List <string> {
request.Topic
} : _queueService.GetAllTopics().ToList();
foreach (var topic in topicList)
{
var queues = _queueService.QueryQueues(topic).ToList();
foreach (var queue in queues)
{
var topicQueueInfo = new TopicQueueInfo();
topicQueueInfo.Topic = queue.Topic;
topicQueueInfo.QueueId = queue.QueueId;
topicQueueInfo.QueueCurrentOffset = queue.CurrentOffset;
topicQueueInfo.QueueMinOffset = queue.GetMinQueueOffset();
topicQueueInfo.QueueMessageCount = queue.GetMessageRealCount();
topicQueueInfo.QueueMaxConsumedOffset = _offsetManager.GetMinOffset(queue.Topic, queue.QueueId);
topicQueueInfo.Status = queue.Status;
topicQueueInfoList.Add(topicQueueInfo);
}
}
return(RemotingResponseFactory.CreateResponse(remotingRequest, _binarySerializer.Serialize(topicQueueInfoList)));
}
public RemotingResponse HandleRequest(IRequestHandlerContext context, RemotingRequest remotingRequest)
{
var disableQueueRequest = _binarySerializer.Deserialize <DisableQueueRequest>(remotingRequest.Body);
_queueService.DisableQueue(disableQueueRequest.Topic, disableQueueRequest.QueueId);
return(RemotingResponseFactory.CreateResponse(remotingRequest));
}
public void OnComplete()
{
if (Success)
{
var recordCount = BatchMessageLogRecord.Records.Count();
var messageResults = new List <BatchMessageItemResult>();
foreach (var record in BatchMessageLogRecord.Records)
{
messageResults.Add(new BatchMessageItemResult(record.MessageId, record.Code, record.QueueOffset, record.CreatedTime, record.StoredTime, record.Tag));
}
var result = new BatchMessageStoreResult(Queue.Topic, Queue.QueueId, messageResults);
var data = BatchMessageUtils.EncodeMessageStoreResult(result);
var response = RemotingResponseFactory.CreateResponse(RemotingRequest, data);
RequestHandlerContext.SendRemotingResponse(response);
if (BatchSendMessageRequestHandler._notifyWhenMessageArrived && recordCount > 0)
{
BatchSendMessageRequestHandler._suspendedPullRequestManager.NotifyNewMessage(Queue.Topic, Queue.QueueId, BatchMessageLogRecord.Records.First().QueueOffset);
}
if (recordCount > 0)
{
var lastRecord = BatchMessageLogRecord.Records.Last();
BatchSendMessageRequestHandler._brokerController.AddLatestMessage(lastRecord.MessageId, lastRecord.CreatedTime, lastRecord.StoredTime);
}
}
else
{
var response = RemotingResponseFactory.CreateResponse(RemotingRequest, ResponseCode.Failed, Encoding.UTF8.GetBytes(SendMessageFailedText));
RequestHandlerContext.SendRemotingResponse(response);
}
}
public RemotingResponse HandleRequest(IRequestHandlerContext context, RemotingRequest remotingRequest)
{
var request = _binarySerializer.Deserialize <QueryConsumerInfoRequest>(remotingRequest.Body);
var consumerInfoList = new List <ConsumerInfo>();
if (!string.IsNullOrEmpty(request.GroupName))
{
var consumerGroups = _consumerManager.QueryConsumerGroup(request.GroupName);
foreach (var consumerGroup in consumerGroups)
{
foreach (var topicConsumeInfo in GetConsumerInfoForGroup(consumerGroup, request.Topic))
{
consumerInfoList.Add(topicConsumeInfo);
}
}
}
else
{
var consumerGroups = _consumerManager.GetAllConsumerGroups();
foreach (var consumerGroup in consumerGroups)
{
foreach (var topicConsumeInfo in GetConsumerInfoForGroup(consumerGroup, request.Topic))
{
consumerInfoList.Add(topicConsumeInfo);
}
}
}
return(RemotingResponseFactory.CreateResponse(remotingRequest, _binarySerializer.Serialize(consumerInfoList)));
}
public RemotingResponse HandleRequest(IRequestHandlerContext context, RemotingRequest remotingRequest)
{
var addQueueRequest = _binarySerializer.Deserialize <AddQueueRequest>(remotingRequest.Body);
_queueStore.AddQueue(addQueueRequest.Topic);
return(RemotingResponseFactory.CreateResponse(remotingRequest));
}
public RemotingResponse HandleRequest(IRequestHandlerContext context, RemotingRequest remotingRequest)
{
var request = _binarySerializer.Deserialize <CreateTopicRequest>(remotingRequest.Body);
_queueStore.CreateTopic(request.Topic, request.InitialQueueCount);
return(RemotingResponseFactory.CreateResponse(remotingRequest));
}
public RemotingResponse HandleRequest(IRequestHandlerContext context, RemotingRequest remotingRequest)
{
var request = _binarySerializer.Deserialize <SetQueueProducerVisibleRequest>(remotingRequest.Body);
_queueStore.SetProducerVisible(request.Topic, request.QueueId, request.Visible);
return(RemotingResponseFactory.CreateResponse(remotingRequest));
}
public void OnComplete()
{
if (Success)
{
var result = new MessageStoreResult(
MessageLogRecord.MessageId,
MessageLogRecord.Code,
MessageLogRecord.Topic,
MessageLogRecord.QueueId,
MessageLogRecord.QueueOffset,
MessageLogRecord.CreatedTime,
MessageLogRecord.StoredTime,
MessageLogRecord.Tag);
var data = MessageUtils.EncodeMessageStoreResult(result);
var response = RemotingResponseFactory.CreateResponse(RemotingRequest, data);
RequestHandlerContext.SendRemotingResponse(response);
if (SendMessageRequestHandler._notifyWhenMessageArrived)
{
SendMessageRequestHandler._suspendedPullRequestManager.NotifyNewMessage(MessageLogRecord.Topic, result.QueueId, result.QueueOffset);
}
SendMessageRequestHandler._brokerController.AddLatestMessage(result.MessageId, result.CreatedTime, result.StoredTime);
}
else
{
var response = RemotingResponseFactory.CreateResponse(RemotingRequest, ResponseCode.Failed, Encoding.UTF8.GetBytes(SendMessageFailedText));
RequestHandlerContext.SendRemotingResponse(response);
}
}
public RemotingResponse HandleRequest(IRequestHandlerContext context, RemotingRequest remotingRequest)
{
var clusterList = _clusterManager.GetAllClusters();
var data = _binarySerializer.Serialize(clusterList);
return(RemotingResponseFactory.CreateResponse(remotingRequest, data));
}
public RemotingResponse HandleRequest(IRequestHandlerContext context, RemotingRequest remotingRequest)
{
var request = _binarySerializer.Deserialize <BrokerRegistrationRequest>(remotingRequest.Body);
_clusterManager.RegisterBroker(context.Connection, request);
return(RemotingResponseFactory.CreateResponse(remotingRequest));
}
public RemotingResponse HandleRequest(IRequestHandlerContext context, RemotingRequest remotingRequest)
{
var topic = Encoding.UTF8.GetString(remotingRequest.Body);
var queueIds = _queueStore.GetQueues(topic, BrokerController.Instance.Setting.AutoCreateTopic).Where(x => x.Setting.ProducerVisible).Select(x => x.QueueId).ToList();
var data = Encoding.UTF8.GetBytes(string.Join(",", queueIds));
return(RemotingResponseFactory.CreateResponse(remotingRequest, data));
}
public RemotingResponse HandleRequest(IRequestHandlerContext context, RemotingRequest remotingRequest)
{
var topic = Encoding.UTF8.GetString(remotingRequest.Body);
var queueIds = _queueService.GetOrCreateQueues(topic).Select(x => x.QueueId).ToList();
var data = Encoding.UTF8.GetBytes(string.Join(",", queueIds));
return(RemotingResponseFactory.CreateResponse(remotingRequest, data));
}
public RemotingResponse HandleRequest(IRequestHandlerContext context, RemotingRequest remotingRequest)
{
var request = _binarySerializer.Deserialize <GetClusterBrokersRequest>(remotingRequest.Body);
var brokerInfoList = _clusterManager.GetClusterBrokerStatusInfos(request);
var data = _binarySerializer.Serialize(brokerInfoList);
return(RemotingResponseFactory.CreateResponse(remotingRequest, data));
}
public RemotingResponse HandleRequest(IRequestHandlerContext context, RemotingRequest remotingRequest)
{
var request = _binarySerializer.Deserialize <GetTopicQueueInfoRequest>(remotingRequest.Body);
var topicQueueInfoList = _clusterManager.GetTopicQueueInfo(request);
var data = _binarySerializer.Serialize(topicQueueInfoList);
return(RemotingResponseFactory.CreateResponse(remotingRequest, data));
}
public RemotingResponse HandleRequest(IRequestHandlerContext context, RemotingRequest remotingRequest)
{
var request = _binarySerializer.Deserialize <GetProducerListRequest>(remotingRequest.Body);
var producerList = _clusterManager.GetProducerList(request);
var data = _binarySerializer.Serialize(producerList);
return(RemotingResponseFactory.CreateResponse(remotingRequest, data));
}
public RemotingResponse HandleRequest(IRequestHandlerContext context, RemotingRequest remotingRequest)
{
var request = _binarySerializer.Deserialize <QueryMessageRequest>(remotingRequest.Body);
var total = 0;
var messages = _messageStore.QueryMessages(request.Topic, request.QueueId, request.Code, request.RoutingKey, request.PageIndex, request.PageSize, out total).ToList();
return(RemotingResponseFactory.CreateResponse(remotingRequest, _binarySerializer.Serialize(new QueryMessageResponse(total, messages))));
}
public RemotingResponse HandleRequest(IRequestHandlerContext context, RemotingRequest remotingRequest)
{
if (BrokerController.Instance.IsCleaning)
{
throw new BrokerCleanningException();
}
var latestSendMessageIds = BrokerController.Instance.GetLatestSendMessageIds();
return(RemotingResponseFactory.CreateResponse(remotingRequest, Encoding.UTF8.GetBytes(latestSendMessageIds)));
}
public RemotingResponse HandleRequest(IRequestHandlerContext context, RemotingRequest remotingRequest)
{
if (BrokerController.Instance.IsCleaning)
{
throw new BrokerCleanningException();
}
var statisticInfo = BrokerController.Instance.GetBrokerStatisticInfo();
return(RemotingResponseFactory.CreateResponse(remotingRequest, _binarySerializer.Serialize(statisticInfo)));
}
public RemotingResponse HandleRequest(IRequestHandlerContext context, RemotingRequest remotingRequest)
{
if (BrokerController.Instance.IsCleaning)
{
throw new BrokerCleanningException();
}
var producerIdList = _producerManager.GetAllProducers();
var data = Encoding.UTF8.GetBytes(string.Join(",", producerIdList));
return(RemotingResponseFactory.CreateResponse(remotingRequest, data));
}
public RemotingResponse HandleRequest(IRequestHandlerContext context, RemotingRequest remotingRequest)
{
if (BrokerController.Instance.IsCleaning)
{
throw new BrokerCleanningException();
}
var request = _binarySerializer.Deserialize <DeleteTopicRequest>(remotingRequest.Body);
_queueStore.DeleteTopic(request.Topic);
return(RemotingResponseFactory.CreateResponse(remotingRequest));
}
public RemotingResponse HandleRequest(IRequestHandlerContext context, RemotingRequest remotingRequest)
{
if (BrokerController.Instance.IsCleaning)
{
throw new BrokerCleanningException();
}
var request = _binarySerializer.Deserialize <SetQueueProducerVisibleRequest>(remotingRequest.Body);
_queueStore.SetProducerVisible(request.Topic, request.QueueId, request.Visible);
return(RemotingResponseFactory.CreateResponse(remotingRequest));
}
public RemotingResponse HandleRequest(IRequestHandlerContext context, RemotingRequest remotingRequest)
{
if (BrokerController.Instance.IsCleaning)
{
throw new BrokerCleanningException();
}
var request = _binarySerializer.Deserialize <GetTopicConsumeInfoRequest>(remotingRequest.Body);
var topicConsumeInfoList = _getTopicConsumeInfoListService.GetTopicConsumeInfoList(request.GroupName, request.Topic);
return(RemotingResponseFactory.CreateResponse(remotingRequest, _binarySerializer.Serialize(topicConsumeInfoList)));
}
public RemotingResponse HandleRequest(IRequestHandlerContext context, RemotingRequest remotingRequest)
{
if (BrokerController.Instance.IsCleaning)
{
throw new BrokerCleanningException();
}
var request = _binarySerializer.Deserialize <CreateTopicRequest>(remotingRequest.Body);
IEnumerable <int> queueIds = _queueStore.CreateTopic(request.Topic, request.InitialQueueCount);
var data = _binarySerializer.Serialize(queueIds);
return(RemotingResponseFactory.CreateResponse(remotingRequest, data));
}
public RemotingResponse HandleRequest(IRequestHandlerContext context, RemotingRequest remotingRequest)
{
var request = _binarySerializer.Deserialize <GetMessageDetailRequest>(remotingRequest.Body);
var message = _messageStore.FindMessage(request.MessageOffset, request.MessageId);
var messages = new List <QueueMessage>();
if (message != null)
{
messages.Add(message);
}
return(RemotingResponseFactory.CreateResponse(remotingRequest, _binarySerializer.Serialize(messages)));
}
public RemotingResponse HandleRequest(IRequestHandlerContext context, RemotingRequest remotingRequest)
{
var request = _binarySerializer.Deserialize <QueryConsumerRequest>(remotingRequest.Body);
var consumerGroup = _consumerManager.GetConsumerGroup(request.GroupName);
var consumerIdList = new List <string>();
if (consumerGroup != null)
{
consumerIdList = consumerGroup.GetConsumerIdsForTopic(request.Topic).ToList();
consumerIdList.Sort();
}
return(RemotingResponseFactory.CreateResponse(remotingRequest, Encoding.UTF8.GetBytes(string.Join(",", consumerIdList))));
}
public RemotingResponse HandleRequest(IRequestHandlerContext context, RemotingRequest remotingRequest)
{
var request = _binarySerializer.Deserialize <GetTopicRouteInfoRequest>(remotingRequest.Body);
_clusterManager.GetTopicRouteInfo(request).ContinueWith(t =>
{
var routeInfoList = t.Result;
var data = _binarySerializer.Serialize(routeInfoList);
var response = RemotingResponseFactory.CreateResponse(remotingRequest, data);
context.SendRemotingResponse(response);
});
return(null);
}
public RemotingResponse HandleRequest(IRequestHandlerContext context, RemotingRequest remotingRequest)
{
var request = _binarySerializer.Deserialize <DeleteTopicForClusterRequest>(remotingRequest.Body);
var requestService = new BrokerRequestService(_nameServerController);
requestService.ExecuteActionToAllClusterBrokers(request.ClusterName, async remotingClient =>
{
var requestData = _binarySerializer.Serialize(new DeleteTopicRequest(request.Topic));
var remotingResponse = await remotingClient.InvokeAsync(new RemotingRequest((int)BrokerRequestCode.DeleteTopic, requestData), 30000);
context.SendRemotingResponse(remotingResponse);
});
return(RemotingResponseFactory.CreateResponse(remotingRequest));
}
