public IEnumerable <string> GetAllClusters()
{
var remotingClient = GetAvailableNameServerRemotingClient();
var remotingRequest = new RemotingRequest((int)NameServerRequestCode.GetAllClusters, EmptyBytes);
var remotingResponse = remotingClient.InvokeSync(remotingRequest, 30000);
if (remotingResponse.ResponseCode == ResponseCode.Success)
{
return(_binarySerializer.Deserialize <IEnumerable <string> >(remotingResponse.ResponseBody));
}
else
{
throw new Exception(string.Format("GetAllClusters failed, errorMessage: {0}", Encoding.UTF8.GetString(remotingResponse.ResponseBody)));
}
}
private IEnumerable <int> GetTopicQueueIdsFromServer(string topic)
{
var remotingRequest = new RemotingRequest((int)RequestCode.GetTopicQueueIdsForProducer, Encoding.UTF8.GetBytes(topic));
var remotingResponse = _remotingClient.InvokeSync(remotingRequest, 30000);
if (remotingResponse.Code == (int)ResponseCode.Success)
{
var queueIds = Encoding.UTF8.GetString(remotingResponse.Body);
return(queueIds.Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries).Select(x => int.Parse(x)));
}
else
{
throw new Exception(string.Format("GetTopicQueueIds has exception, producerId:{0}, topic:{1}, remoting response code:{2}", Id, topic, remotingResponse.Code));
}
}
public QueueMessage GetMessageDetail(string messageId)
{
var requestData = _binarySerializer.Serialize(new GetMessageDetailRequest(messageId));
var remotingRequest = new RemotingRequest((int)RequestCode.GetMessageDetail, requestData);
var remotingResponse = _remotingClient.InvokeSync(remotingRequest, 30000);
if (remotingResponse.Code == (int)ResponseCode.Success)
{
return(_binarySerializer.Deserialize <IEnumerable <QueueMessage> >(remotingResponse.Body).SingleOrDefault());
}
else
{
throw new Exception(string.Format("GetMessageDetail failed, errorMessage: {0}", Encoding.UTF8.GetString(remotingResponse.Body)));
}
}
public BrokerStatisticInfo QueryBrokerStatisticInfo(string clusterName, string brokerName)
{
var remotingClient = GetBrokerByName(clusterName, brokerName);
var remotingRequest = new RemotingRequest((int)BrokerRequestCode.GetBrokerStatisticInfo, new byte[0]);
var remotingResponse = remotingClient.InvokeSync(remotingRequest, 30000);
if (remotingResponse.ResponseCode == ResponseCode.Success)
{
return(_binarySerializer.Deserialize <BrokerStatisticInfo>(remotingResponse.ResponseBody));
}
else
{
throw new Exception(string.Format("QueryBrokerStatisticInfo failed, errorMessage: {0}", Encoding.UTF8.GetString(remotingResponse.ResponseBody)));
}
}
private async Task <IEnumerable <int> > CreateTopicOnBroker(string topic, Broker broker)
{
var brokerAdminEndpoint = broker.BrokerInfo.AdminAddress.ToEndPoint();
var adminRemotingClient = new SocketRemotingClient(_nameServerController.Setting.Name, brokerAdminEndpoint, _nameServerController.Setting.SocketSetting).Start();
var requestData = _binarySerializer.Serialize(new CreateTopicRequest(topic));
var remotingRequest = new RemotingRequest((int)BrokerRequestCode.CreateTopic, requestData);
var remotingResponse = await adminRemotingClient.InvokeAsync(remotingRequest, 30000);
if (remotingResponse.ResponseCode != ResponseCode.Success)
{
throw new Exception(string.Format("AutoCreateTopicOnBroker failed, errorMessage: {0}", Encoding.UTF8.GetString(remotingResponse.ResponseBody)));
}
adminRemotingClient.Shutdown();
return(_binarySerializer.Deserialize <IEnumerable <int> >(remotingResponse.ResponseBody));
}
public IEnumerable <TopicQueueInfo> GetTopicQueueInfo(string topic)
{
var requestData = _binarySerializer.Serialize(new QueryTopicQueueInfoRequest(topic));
var remotingRequest = new RemotingRequest((int)RequestCode.QueryTopicQueueInfo, requestData);
var remotingResponse = _remotingClient.InvokeSync(remotingRequest, 30000);
if (remotingResponse.Code == (int)ResponseCode.Success)
{
return(_binarySerializer.Deserialize <IEnumerable <TopicQueueInfo> >(remotingResponse.Body));
}
else
{
throw new Exception(string.Format("QueryTopicQueueInfo failed, errorMessage: {0}", Encoding.UTF8.GetString(remotingResponse.Body)));
}
}
private IEnumerable <int> GetTopicQueueIdsFromServer(string topic)
{
var remotingRequest = new RemotingRequest((int)RequestCode.GetTopicQueueIdsForConsumer, Encoding.UTF8.GetBytes(topic));
var remotingResponse = _adminRemotingClient.InvokeSync(remotingRequest, Setting.DefaultTimeoutMilliseconds);
if (remotingResponse.Code == (int)ResponseCode.Success)
{
var queueIds = Encoding.UTF8.GetString(remotingResponse.Body);
return(queueIds.Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries).Select(x => int.Parse(x)));
}
else
{
throw new Exception(string.Format("GetTopicQueueIds has exception, group: {0}, topic: {1}, remoting response code: {2}", GroupName, topic, remotingResponse.Code));
}
}
public IEnumerable <string> GetProducerInfo()
{
var remotingRequest = new RemotingRequest((int)RequestCode.QueryProducerInfo, EmptyBytes);
var remotingResponse = _remotingClient.InvokeSync(remotingRequest, 10000);
if (remotingResponse.Code == (int)ResponseCode.Success)
{
var producerIds = Encoding.UTF8.GetString(remotingResponse.Body);
return(producerIds.Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries));
}
else
{
throw new Exception(string.Format("GetProducerInfo failed, errorMessage: {0}", Encoding.UTF8.GetString(remotingResponse.Body)));
}
}
public void DeleteConsumerGroup(string consumerGroup)
{
if (string.IsNullOrEmpty(consumerGroup))
{
throw new ArgumentException("consumerGroup cannot be null or empty.");
}
var requestData = _binarySerializer.Serialize(new DeleteConsumerGroupRequest(consumerGroup));
var remotingRequest = new RemotingRequest((int)RequestCode.DeleteConsumerGroup, requestData);
var remotingResponse = _remotingClient.InvokeSync(remotingRequest, 30000);
if (remotingResponse.Code != (int)ResponseCode.Success)
{
throw new Exception(string.Format("DeleteConsumerGroup failed, errorMessage: {0}", Encoding.UTF8.GetString(remotingResponse.Body)));
}
}
public void SetQueueNextConsumeOffset(string consumerGroup, string topic, int queueId, long nextOffset)
{
if (nextOffset < 0)
{
throw new ArgumentException("nextOffset cannot be small than zero.");
}
var requestData = _binarySerializer.Serialize(new SetQueueNextConsumeOffsetRequest(consumerGroup, topic, queueId, nextOffset));
var remotingRequest = new RemotingRequest((int)RequestCode.SetQueueNextConsumeOffset, requestData);
var remotingResponse = _remotingClient.InvokeSync(remotingRequest, 30000);
if (remotingResponse.Code != (int)ResponseCode.Success)
{
throw new Exception(string.Format("SetQueueNextConsumeOffset failed, errorMessage: {0}", Encoding.UTF8.GetString(remotingResponse.Body)));
}
}
public RemotingResponse HandleRequest(IRequestHandlerContext context, RemotingRequest remotingRequest)
{
if (remotingRequest.Body.Length > _brokerController.Setting.MessageMaxSize)
{
throw new Exception("Message size cannot exceed max message size:" + _brokerController.Setting.MessageMaxSize);
}
if (BrokerController.Instance.IsCleaning)
{
throw new BrokerCleanningException();
}
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);
}
_messageStore.StoreMessageAsync(queue, message, (record, parameter) =>
{
var storeContext = parameter as StoreContext;
if (record.LogPosition >= 0 && !string.IsNullOrEmpty(record.MessageId))
{
storeContext.Queue.AddMessage(record.LogPosition, record.Tag);
storeContext.MessageLogRecord = record;
storeContext.Success = true;
}
else
{
storeContext.Success = false;
}
_bufferQueue.EnqueueMessage(storeContext);
}, new StoreContext
{
RequestHandlerContext = context,
RemotingRequest = remotingRequest,
Queue = queue,
SendMessageRequestHandler = this
}, request.ProducerAddress);
_tpsStatisticService.AddTopicSendCount(message.Topic, queueId);
return(null);
}
public void CommitConsumeOffset(MessageQueue messageQueue, long consumeOffset, bool throwIfException = false)
{
Ensure.NotNull(messageQueue, "messageQueue");
Ensure.Nonnegative(consumeOffset, "consumeOffset");
var brokerConnection = _clientService.GetBrokerConnection(messageQueue.BrokerName);
if (brokerConnection == null)
{
_logger.ErrorFormat("CommitConsumeOffset failed as the target broker connection not found, messageQueue:{0}", messageQueue);
return;
}
var remotingClient = brokerConnection.AdminRemotingClient;
var request = new UpdateQueueOffsetRequest(_consumer.GroupName, messageQueue, consumeOffset);
var remotingRequest = new RemotingRequest((int)BrokerRequestCode.UpdateQueueConsumeOffsetRequest, _binarySerializer.Serialize(request));
var brokerAddress = remotingClient.ServerEndPoint.ToAddress();
try
{
remotingClient.InvokeOneway(remotingRequest);
if (_logger.IsDebugEnabled)
{
_logger.DebugFormat("CommitConsumeOffset success, consumerGroup:{0}, consumerId:{1}, messageQueue:{2}, consumeOffset:{3}, brokerAddress:{4}",
_consumer.GroupName,
_clientId,
messageQueue,
consumeOffset,
brokerAddress);
}
}
catch (Exception ex)
{
if (remotingClient.IsConnected)
{
_logger.Error(string.Format("CommitConsumeOffset has exception, consumerGroup:{0}, consumerId:{1}, messageQueue:{2}, consumeOffset:{3}, brokerAddress:{4}",
_consumer.GroupName,
_clientId,
messageQueue,
consumeOffset,
brokerAddress), ex);
}
if (throwIfException)
{
throw;
}
}
}
public RemotingResponse HandleRequest(IRequestHandlerContext context, RemotingRequest request)
{
var queryConsumerRequest = _binarySerializer.Deserialize <QueryConsumerRequest>(request.Body);
var consumerGroup = _brokerController.ConsumerManager.GetConsumerGroup(queryConsumerRequest.GroupName);
var consumerIdList = new List <string>();
if (consumerGroup != null)
{
consumerIdList = consumerGroup.GetConsumerIdsForTopic(queryConsumerRequest.Topic).ToList();
consumerIdList.Sort();
}
var consumerIds = string.Join(",", consumerIdList);
var data = Encoding.UTF8.GetBytes(consumerIds);
return(new RemotingResponse((int)ResponseCode.Success, request.Sequence, data));
}
public void AddQueue(string clusterName, string topic)
{
var remotingClient = GetAvailableNameServerRemotingClient();
var requestData = _binarySerializer.Serialize(new AddQueueForClusterRequest
{
ClusterName = clusterName,
Topic = topic
});
var remotingRequest = new RemotingRequest((int)NameServerRequestCode.AddQueue, requestData);
var remotingResponse = remotingClient.InvokeSync(remotingRequest, 30000);
if (remotingResponse.ResponseCode != ResponseCode.Success)
{
throw new Exception(string.Format("AddQueue failed, errorMessage: {0}", Encoding.UTF8.GetString(remotingResponse.ResponseBody)));
}
}
public RemotingResponse HandleRequest(IRequestHandlerContext context, RemotingRequest remotingRequest)
{
if (BrokerController.Instance.IsCleaning)
{
return(null);
}
var request = _binarySerializer.Deserialize <byte[], UpdateQueueOffsetRequest>(remotingRequest.Body);
_offsetStore.UpdateConsumeOffset(
request.MessageQueue.Topic,
request.MessageQueue.QueueId,
request.QueueOffset,
request.ConsumerGroup);
return(null);
}
public async Task <IEnumerable <string> > GetProducerInfoList(string clusterName, string brokerName)
{
var remotingClient = GetBrokerByName(clusterName, brokerName);
var remotingRequest = new RemotingRequest((int)BrokerRequestCode.GetProducerList, EmptyBytes);
var remotingResponse = await remotingClient.InvokeAsync(remotingRequest, 30000);
if (remotingResponse.ResponseCode == ResponseCode.Success)
{
var producerIds = Encoding.UTF8.GetString(remotingResponse.ResponseBody);
return(producerIds.Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries));
}
else
{
throw new Exception(string.Format("GetProducerInfo failed, errorMessage: {0}", Encoding.UTF8.GetString(remotingResponse.ResponseBody)));
}
}
public IEnumerable <string> GetLatestSendMessagesList(string clusterName, string brokerName)
{
var remotingClient = GetBrokerByName(clusterName, brokerName);
var remotingRequest = new RemotingRequest((int)BrokerRequestCode.GetLastestMessages, EmptyBytes);
var remotingResponse = remotingClient.InvokeSync(remotingRequest, 30000);
if (remotingResponse.ResponseCode == ResponseCode.Success)
{
var messageIds = Encoding.UTF8.GetString(remotingResponse.ResponseBody);
return(messageIds.Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries));
}
else
{
throw new Exception(string.Format("GetLatestSendMessagesList failed, errorMessage: {0}", Encoding.UTF8.GetString(remotingResponse.ResponseBody)));
}
}
public IEnumerable <ConsumerInfo> GetConsumerInfoList(string clusterName, string brokerName, string group, string topic)
{
var remotingClient = GetBrokerByName(clusterName, brokerName);
var requestData = _binarySerializer.Serialize(new Protocols.Brokers.Requests.GetConsumerListRequest(group, topic));
var remotingRequest = new RemotingRequest((int)BrokerRequestCode.GetConsumerList, requestData);
var remotingResponse = remotingClient.InvokeSync(remotingRequest, 30000);
if (remotingResponse.ResponseCode == ResponseCode.Success)
{
return(_binarySerializer.Deserialize <IEnumerable <ConsumerInfo> >(remotingResponse.ResponseBody));
}
else
{
throw new Exception(string.Format("GetConsumerInfo failed, errorMessage: {0}", Encoding.UTF8.GetString(remotingResponse.ResponseBody)));
}
}
public QueryMessageResponse QueryMessages(string topic, int?queueId, int?code, string routingKey, int pageIndex, int pageSize)
{
var request = new QueryMessageRequest(topic, queueId, code, routingKey, pageIndex, pageSize);
var requestData = _binarySerializer.Serialize(request);
var remotingRequest = new RemotingRequest((int)RequestCode.QueryMessage, requestData);
var remotingResponse = _remotingClient.InvokeSync(remotingRequest, 30000);
if (remotingResponse.Code == (int)ResponseCode.Success)
{
return(_binarySerializer.Deserialize <QueryMessageResponse>(remotingResponse.Body));
}
else
{
throw new Exception(string.Format("QueryMessages failed, errorMessage: {0}", Encoding.UTF8.GetString(remotingResponse.Body)));
}
}
private IEnumerable <string> QueryGroupConsumers(string topic)
{
var queryConsumerRequest = _binarySerializer.Serialize(new QueryConsumerRequest(GroupName, topic));
var remotingRequest = new RemotingRequest((int)RequestCode.QueryGroupConsumer, queryConsumerRequest);
var remotingResponse = _remotingClient.InvokeSync(remotingRequest, Setting.DefaultTimeoutMilliseconds);
if (remotingResponse.Code == (int)ResponseCode.Success)
{
var consumerIds = Encoding.UTF8.GetString(remotingResponse.Body);
return(consumerIds.Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries));
}
else
{
throw new Exception(string.Format("QueryGroupConsumers has exception, consumerId:{0}, group:{1}, topic:{2}, remoting response code:{3}", Id, GroupName, topic, remotingResponse.Code));
}
}
private static void CreateTopic(string topic)
{
var binarySerializer = ObjectContainer.Resolve<IBinarySerializer>();
var requestData = binarySerializer.Serialize(new CreateTopicForClusterRequest
{
ClusterName = "DefaultCluster",
Topic = topic
});
var remotingRequest = new RemotingRequest((int)NameServerRequestCode.CreateTopic, requestData);
var task = _nameServerSocketRemotingClient.InvokeAsync(remotingRequest, 30000);
task.Wait();
if (task.Result.ResponseCode != ResponseCode.Success)
{
throw new Exception(string.Format("CreateTopic failed, errorMessage: {0}", Encoding.UTF8.GetString(task.Result.ResponseBody)));
}
}
public RemotingResponse HandleRequest(IRequestHandlerContext context, RemotingRequest remotingRequest)
{
var currentTime = DateTime.Now;
_performanceService.IncrementKeyCount(_performanceKey, (currentTime - remotingRequest.CreatedTime).TotalMilliseconds);
return(new RemotingResponse(
remotingRequest.Type,
remotingRequest.Code,
remotingRequest.Sequence,
remotingRequest.CreatedTime,
10,
response,
currentTime,
remotingRequest.Header,
null));
}
public async Task DeleteTopic(string clusterName, string topic)
{
var remotingClient = GetAvailableNameServerRemotingClient();
var requestData = _binarySerializer.Serialize(new DeleteTopicForClusterRequest
{
ClusterName = clusterName,
Topic = topic
});
var remotingRequest = new RemotingRequest((int)NameServerRequestCode.DeleteTopic, requestData);
var remotingResponse = await remotingClient.InvokeAsync(remotingRequest, 30000);
if (remotingResponse.ResponseCode != ResponseCode.Success)
{
throw new Exception(string.Format("DeleteTopic failed, errorMessage: {0}", Encoding.UTF8.GetString(remotingResponse.ResponseBody)));
}
}
public void OnMessage(IReader reader)
{
try
{
if (closed)
{
logger.Debug($"Got message when closed. Ignoring...");
return;
}
MessageType messageType = (MessageType)reader.ReadByte();
ReadFormatterInfo readFormatterInfo = new ReadFormatterInfo(reader, rpcSerializer);
switch (messageType)
{
case MessageType.RpcRequest:
RemotingRequest remotingRequest = new RemotingRequest();
remotingRequest.MergeFrom(readFormatterInfo);
LogMessageReceived(remotingRequest);
EnqueueRequest(remotingRequest);
break;
case MessageType.RpcResponse:
RemotingResponse remotingResponse = new RemotingResponse();
remotingResponse.MergeFrom(readFormatterInfo);
LogMessageReceived(remotingResponse);
ExecuteResponse(remotingResponse);
break;
case MessageType.RpcResponseError:
RemotingResponseError remotingResponseError = new RemotingResponseError();
remotingResponseError.MergeFrom(readFormatterInfo);
LogMessageReceived(remotingResponseError);
ExecuteResponseError(remotingResponseError);
break;
default:
OnExtraMessage(messageType, readFormatterInfo);
break;
}
}
catch (Exception outerException)
{
logger.Error($"Unhandled exception on {this.GetType().Name}.{nameof(OnMessage)}(): {outerException}");
Connection.Close();
}
}
public RemotingResponse HandleRequest(IRequestHandlerContext context, RemotingRequest request)
{
var sendMessageRequest = MessageUtils.DecodeSendMessageRequest(request.Body);
var storeResult = _messageService.StoreMessage(sendMessageRequest.Message, sendMessageRequest.QueueId);
if (_brokerController.Setting.NotifyWhenMessageArrived)
{
_brokerController.SuspendedPullRequestManager.NotifyMessageArrived(sendMessageRequest.Message.Topic, storeResult.QueueId, storeResult.QueueOffset);
}
var sendMessageResponse = new SendMessageResponse(
storeResult.MessageOffset,
new MessageQueue(sendMessageRequest.Message.Topic, storeResult.QueueId),
storeResult.QueueOffset);
var responseData = _binarySerializer.Serialize(sendMessageResponse);
return(new RemotingResponse((int)ResponseCode.Success, request.Sequence, responseData));
}
public RemotingResponse HandleRequest(IRequestHandlerContext context, RemotingRequest remotingRequest)
{
var request = _binarySerializer.Deserialize <SetQueueProducerVisibleForClusterRequest>(remotingRequest.Body);
var requestService = new BrokerRequestService(_nameServerController);
requestService.ExecuteActionToAllClusterBrokers(request.ClusterName, remotingClient =>
{
var requestData = _binarySerializer.Serialize(new SetQueueProducerVisibleRequest(request.Topic, request.QueueId, request.Visible));
var remotingResponse = remotingClient.InvokeSync(new RemotingRequest((int)BrokerRequestCode.SetQueueProducerVisible, requestData), 30000);
if (remotingResponse.ResponseCode != ResponseCode.Success)
{
throw new Exception(string.Format("SetQueueProducerVisible failed, errorMessage: {0}", Encoding.UTF8.GetString(remotingResponse.ResponseBody)));
}
});
return(RemotingResponseFactory.CreateResponse(remotingRequest));
}
public RemotingResponse HandleRequest(IRequestHandlerContext context, RemotingRequest remotingRequest)
{
if (BrokerController.Instance.IsCleaning)
{
throw new BrokerCleanningException();
}
var request = _binarySerializer.Deserialize <GetMessageDetailRequest>(remotingRequest.Body);
var messageInfo = MessageIdUtil.ParseMessageId(request.MessageId);
var message = _messageStore.GetMessage(messageInfo.MessagePosition);
var messages = new List <QueueMessage>();
if (message != null)
{
messages.Add(message);
}
return(RemotingResponseFactory.CreateResponse(remotingRequest, _binarySerializer.Serialize(messages)));
}
public Task <RemotingResponse> InvokeAsync(RemotingRequest request, int timeoutMillis)
{
EnsureClientStatus();
request.Type = RemotingRequestType.Async;
var taskCompletionSource = new TaskCompletionSource <RemotingResponse>();
var responseFuture = new ResponseFuture(request, timeoutMillis, taskCompletionSource);
if (!_responseFutureDict.TryAdd(request.Sequence, responseFuture))
{
throw new ResponseFutureAddFailedException(request.Sequence);
}
_clientSocket.QueueMessage(RemotingUtils.BuildRequestMessage(request));
return(taskCompletionSource.Task);
}
public async Task DeleteConsumerGroup(string clusterName, string brokerName, string consumerGroup)
{
var remotingClient = await GetBrokerByName(clusterName, brokerName);
if (string.IsNullOrEmpty(consumerGroup))
{
throw new ArgumentException("consumerGroup cannot be null or empty.");
}
var requestData = _binarySerializer.Serialize(new DeleteConsumerGroupRequest(consumerGroup));
var remotingRequest = new RemotingRequest((int)BrokerRequestCode.DeleteConsumerGroup, requestData);
var remotingResponse = await remotingClient.InvokeAsync(remotingRequest, 30000);
if (remotingResponse.ResponseCode != ResponseCode.Success)
{
throw new Exception(string.Format("DeleteConsumerGroup failed, errorMessage: {0}", Encoding.UTF8.GetString(remotingResponse.ResponseBody)));
}
}
public async Task SetQueueNextConsumeOffset(string clusterName, string brokerName, string consumerGroup, string topic, int queueId, long nextOffset)
{
var remotingClient = await GetBrokerByName(clusterName, brokerName);
if (nextOffset < 0)
{
throw new ArgumentException("nextOffset cannot be small than zero.");
}
var requestData = _binarySerializer.Serialize(new SetQueueNextConsumeOffsetRequest(consumerGroup, topic, queueId, nextOffset));
var remotingRequest = new RemotingRequest((int)BrokerRequestCode.SetQueueNextConsumeOffset, requestData);
var remotingResponse = await remotingClient.InvokeAsync(remotingRequest, 30000);
if (remotingResponse.ResponseCode != ResponseCode.Success)
{
throw new Exception(string.Format("SetQueueNextConsumeOffset failed, errorMessage: {0}", Encoding.UTF8.GetString(remotingResponse.ResponseBody)));
}
}
public RemotingRequestToken(RemotingRequest request, DeferredObject deferred, Type returnType)
{
_request = request;
_deferred = deferred;
_returnType = returnType;
}
public object Invoke(object proxyObject, MethodInfo method, object[] arguments)
{
foreach (ParameterInfo parameter in method.GetParameters())
{
if (parameter.ParameterType.IsByRef)
{
throw new InvalidOperationException("Remoting interfaces can not include methods that " +
"have \"out\" or \"ref\" parameters.");
}
}
Type returnType = method.ReturnType;
if (!Deferred.IsTypedDeferred(returnType))
{
throw new InvalidOperationException("Remoting interface methods must return a deferred.");
}
RemotingRequest request = new RemotingRequest(_protocol.GetNextCompletionCookieAndAdvance(),
_stubId, _interfaceName, method.Name, arguments);
DeferredObject deferred = Activator.CreateInstance(returnType) as DeferredObject;
RemotingRequestToken token = new RemotingRequestToken(request, deferred, returnType);
_protocol.SendRequest(token);
return deferred;
}
public RemotingTimeoutException(string address, RemotingRequest request, int timeoutMillis)
: base(string.Format("Wait response on the channel <{0}> timeout, request:{1}, timeoutMillis:{2}ms", address, request, timeoutMillis))
{
}
public RemotingTimeoutException(EndPoint serverEndPoint, RemotingRequest request, long timeoutMillis)
: base(string.Format("Wait response from server[{0}] timeout, request:{1}, timeoutMillis:{2}ms", serverEndPoint, request, timeoutMillis))
{
}
public RemotingSendRequestException(string address, RemotingRequest request, Exception exception)
: base(string.Format("Send request {0} to <{1}> failed.", request, address), exception)
{
}
public RemotingRequestException(IPEndPoint serverEndPoint, RemotingRequest request, Exception exception)
: base(string.Format("Send request {0} to server [{1}] failed.", request, serverEndPoint), exception)
{
}
public RemotingRequestException(IPEndPoint serverEndPoint, RemotingRequest request, string errorMessage)
: base(string.Format("Send request {0} to server [{1}] failed, errorMessage:{2}", request, serverEndPoint, errorMessage))
{
}