public TransportMessage GetTransportMessage()
{
var message = new TransportMessage
{
ContentType = ContentType,
Id = Id,
Content = null
};
object contentObject;
if (IsInvokeMessage())
{
contentObject =
SerializerUtilitys.Deserialize<ProtoBufferRemoteInvokeMessage>(Content).GetRemoteInvokeMessage();
}
else if (IsInvokeResultMessage())
{
contentObject =
SerializerUtilitys.Deserialize<ProtoBufferRemoteInvokeResultMessage>(Content)
.GetRemoteInvokeResultMessage();
}
else
{
throw new NotSupportedException($"无法支持的消息类型：{ContentType}！");
}
message.Content = contentObject;
return message;
}
protected IByteBuffer GetByteBuffer(TransportMessage message)
{
var data = _transportMessageEncoder.Encode(message);
var buffer = Unpooled.Buffer(data.Length, data.Length);
return buffer.WriteBytes(data);
}
public async Task<TransportMessage> InvokeAsync(RemoteInvokeContext context, CancellationToken cancellationToken)
{
if (context == null)
throw new ArgumentNullException(nameof(context));
if (context.InvokeMessage == null)
throw new ArgumentNullException(nameof(context.InvokeMessage));
if (string.IsNullOrEmpty(context.InvokeMessage.ServiceId))
throw new ArgumentException("服务Id不能为空。", nameof(context.InvokeMessage.ServiceId));
var invokeMessage = context.InvokeMessage;
var address = await _addressResolver.Resolver(invokeMessage.ServiceId);
if (address == null)
throw new RpcException($"无法解析服务Id：{invokeMessage.ServiceId}的地址信息。");
try
{
var client = _transportClientFactory.CreateClient(address.CreateEndPoint());
var message = new TransportMessage<RemoteInvokeMessage>
{
Content = context.InvokeMessage,
Id = Guid.NewGuid().ToString("N")
};
await client.SendAsync(TransportMessage.Convert(message));
var resultMessage = await client.ReceiveAsync(message.Id);
return resultMessage;
}
catch (Exception exception)
{
_logger.Fatal($"发起请求中发生了错误，服务Id：{invokeMessage.ServiceId}。", exception);
throw;
}
}
/// <summary>
/// 发送消息。
/// </summary>
/// <param name="message">消息内容。</param>
/// <returns>一个任务。</returns>
public async Task SendAsync(TransportMessage message)
{
if (_logger.IsEnabled(LogLevel.Information))
_logger.LogInformation("准备发送消息：" + message.Id);
var data = GetByteBuffer(message);
await _session.SendAsync(data, 0, data.Length);
}
public byte[] Encode(TransportMessage message)
{
var transportMessage = new ProtoBufferTransportMessage(message)
{
Id = message.Id,
ContentType = message.ContentType
};
return SerializerUtilitys.Serialize(transportMessage);
}
/// <summary>
/// 执行。
/// </summary>
/// <param name="sender">消息发送者。</param>
/// <param name="message">调用消息。</param>
public async Task ExecuteAsync(IMessageSender sender, TransportMessage message)
{
if (_logger.IsEnabled(LogLevel.Information))
_logger.LogInformation("接收到消息。");
if (!message.IsInvokeMessage())
return;
RemoteInvokeMessage remoteInvokeMessage;
try
{
remoteInvokeMessage = message.GetContent<RemoteInvokeMessage>();
}
catch (Exception exception)
{
_logger.LogError("将接收到的消息反序列化成 TransportMessage<RemoteInvokeMessage> 时发送了错误。", exception);
return;
}
var entry = _serviceEntryLocate.Locate(remoteInvokeMessage);
if (entry == null)
{
if (_logger.IsEnabled(LogLevel.Error))
_logger.LogError($"根据服务Id：{remoteInvokeMessage.ServiceId}，找不到服务条目。");
return;
}
if (_logger.IsEnabled(LogLevel.Debug))
_logger.LogDebug("准备执行本地逻辑。");
var resultMessage = new RemoteInvokeResultMessage();
//是否需要等待执行。
if (entry.Descriptor.WaitExecution())
{
//执行本地代码。
await LocalExecuteAsync(entry, remoteInvokeMessage, resultMessage);
//向客户端发送调用结果。
await SendRemoteInvokeResult(sender, message.Id, resultMessage);
}
else
{
//通知客户端已接收到消息。
await SendRemoteInvokeResult(sender, message.Id, resultMessage);
//确保新起一个线程执行，不堵塞当前线程。
await Task.Factory.StartNew(async () =>
{
//执行本地代码。
await LocalExecuteAsync(entry, remoteInvokeMessage, resultMessage);
}, TaskCreationOptions.LongRunning);
}
}
public ProtoBufferTransportMessage(TransportMessage transportMessage)
{
Id = transportMessage.Id;
ContentType = transportMessage.ContentType;
object contentObject;
if (transportMessage.IsInvokeMessage())
{
contentObject = new ProtoBufferRemoteInvokeMessage(transportMessage.GetContent<RemoteInvokeMessage>());
}
else if (transportMessage.IsInvokeResultMessage())
{
contentObject = new ProtoBufferRemoteInvokeResultMessage(transportMessage.GetContent<RemoteInvokeResultMessage>());
}
else
{
throw new NotSupportedException($"无法支持的消息类型：{ContentType}！");
}
Content = SerializerUtilitys.Serialize(contentObject);
}
/// <summary>
/// 发送消息并清空缓冲区。
/// </summary>
/// <param name="message">消息内容。</param>
/// <returns>一个任务。</returns>
public Task SendAndFlushAsync(TransportMessage message)
{
var buffer = GetByteBuffer(message);
return _context.WriteAndFlushAsync(buffer);
}
/// <summary>
/// 执行。
/// </summary>
/// <param name="sender">消息发送者。</param>
/// <param name="message">调用消息。</param>
public async Task ExecuteAsync(IMessageSender sender, TransportMessage message)
{
if (_logger.IsEnabled(LogLevel.Information))
_logger.LogInformation("接收到消息。");
if (!message.IsInvokeMessage())
return;
RemoteInvokeMessage remoteInvokeMessage;
try
{
remoteInvokeMessage = message.GetContent<RemoteInvokeMessage>();
}
catch (Exception exception)
{
_logger.LogError("将接收到的消息反序列化成 TransportMessage<RemoteInvokeMessage> 时发送了错误。", exception);
return;
}
var entry = _serviceEntryLocate.Locate(remoteInvokeMessage);
if (entry == null)
{
if (_logger.IsEnabled(LogLevel.Error))
_logger.LogError($"根据服务Id：{remoteInvokeMessage.ServiceId}，找不到服务条目。");
return;
}
if (_logger.IsEnabled(LogLevel.Debug))
_logger.LogDebug("准备执行本地逻辑。");
var resultMessage = new RemoteInvokeResultMessage();
try
{
var result = entry.Func(remoteInvokeMessage.Parameters);
var task = result as Task;
if (task == null)
{
resultMessage.Result = result;
}
else
{
task.Wait();
var taskType = task.GetType().GetTypeInfo();
if (taskType.IsGenericType)
resultMessage.Result = taskType.GetProperty("Result").GetValue(task);
}
}
catch (Exception exception)
{
if (_logger.IsEnabled(LogLevel.Error))
_logger.LogError("执行本地逻辑时候发生了错误。", exception);
resultMessage.ExceptionMessage = GetExceptionMessage(exception);
}
try
{
if (_logger.IsEnabled(LogLevel.Debug))
_logger.LogDebug("准备发送响应消息。");
await sender.SendAsync(TransportMessage.CreateInvokeResultMessage(message.Id, resultMessage));
if (_logger.IsEnabled(LogLevel.Debug))
_logger.LogDebug("响应消息发送成功。");
}
catch (Exception exception)
{
if (_logger.IsEnabled(LogLevel.Error))
_logger.LogError("发送响应消息时候发生了异常。", exception);
}
}
/// <summary>
/// 发送消息。
/// </summary>
/// <param name="message">消息内容。</param>
/// <returns>一个任务。</returns>
public Task SendAsync(TransportMessage message)
{
return _messageSender.SendAsync(message);
}
/// <summary>
/// 触发接收到消息事件。
/// </summary>
/// <param name="sender">消息发送者。</param>
/// <param name="message">接收到的消息。</param>
public void OnReceived(IMessageSender sender, TransportMessage message)
{
Received?.Invoke(sender, message);
}
private void MessageListener_Received(IMessageSender sender, TransportMessage message)
{
_serviceExecutor.ExecuteAsync(sender, message);
}
/// <summary>
/// 发送消息并清空缓冲区。
/// </summary>
/// <param name="message">消息内容。</param>
/// <returns>一个任务。</returns>
public async Task SendAndFlushAsync(TransportMessage message)
{
var data = GetByteBuffer(message);
await _client.SendAsync(data, 0, data.Length);
}
protected byte[] GetByteBuffer(TransportMessage message)
{
var data = _transportMessageEncoder.Encode(message);
return data;
}
/// <summary>
/// 发送消息并清空缓冲区。
/// </summary>
/// <param name="message">消息内容。</param>
/// <returns>一个任务。</returns>
public async Task SendAndFlushAsync(TransportMessage message)
{
var buffer = GetByteBuffer(message);
await (await _channel).WriteAndFlushAsync(buffer);
}
private void MessageListener_Received(IMessageSender sender, TransportMessage message)
{
if (_logger.IsEnabled(LogLevel.Information))
_logger.LogInformation("接收到消息。");
TaskCompletionSource<TransportMessage> task;
if (!_resultDictionary.TryGetValue(message.Id, out task))
return;
if (message.IsInvokeResultMessage())
{
var content = (RemoteInvokeResultMessage)message.Content;
if (!string.IsNullOrEmpty(content.ExceptionMessage))
{
task.TrySetException(new RpcRemoteException(content.ExceptionMessage));
}
else
{
task.SetResult(message);
}
}
if (message.IsInvokeMessage())
_serviceExecutor?.ExecuteAsync(sender, message);
}
/// <summary>
/// 触发接收到消息事件。
/// </summary>
/// <param name="sender">消息发送者。</param>
/// <param name="message">接收到的消息。</param>
/// <returns>一个任务。</returns>
public async Task OnReceived(IMessageSender sender, TransportMessage message)
{
if (Received == null)
return;
await Received(sender, message);
}
public byte[] Encode(TransportMessage message)
{
var content = JsonConvert.SerializeObject(message);
return Encoding.UTF8.GetBytes(content);
}
/// <summary>
/// 触发接收到消息事件。
/// </summary>
/// <param name="sender">消息发送者。</param>
/// <param name="message">接收到的消息。</param>
public void OnReceived(IMessageSender sender, TransportMessage message)
{
_messageListener.OnReceived(sender, message);
}
