private IByteBuffer GetByteBuffer(TransportMsg message)
{
var data = LZ4MessagePackSerializer.FromJson(_serializer.Serialize <string>(message));
IByteBuffer buffer = Unpooled.Buffer(data.Length, data.Length);
return(buffer.WriteBytes(data));
}
/// <summary>
/// 发送请求
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
public async Task <RemoteCallBackData> SendAsync(RemoteCallData data)
{
try
{
data.ServiceId = data.ServiceId.ToLower();
TransportMsg transportMsg = new TransportMsg()
{
Content = data,
ContentType = data.GetType().ToString()
};
Task <RemoteCallBackData> callbackTask = RegisterResultCallbackAsync(transportMsg.Id);
try
{
await _sender.SendAsync(transportMsg);
return(await callbackTask);
}
catch (Exception ex)
{
_logger.Error($"当连接服务端时发生错误, serviceid: {data.ServiceId}", ex);
throw;
}
}
catch (Exception ex)
{
_logger.Error($"传输失败,serviceid: {data.ServiceId}", ex);
throw;
}
}
public RemoteExecutorContext(TransportMsg transportMessage, IServiceEntryContainer serviceEntryContainer,
IResponse response, ISerializer serializer, ILogger logger, IServiceDiscovery serviceDiscovery)
{
Response = response;
TransportMessage = transportMessage;
try
{
RemoteInvokeMessage = transportMessage.GetContent <RemoteCallData>(serializer);
}
catch (Exception ex)
{
logger.Error("failed to convert transportmsg.content to RemoteCallerData.", ex);
return;
}
ServiceEntry = serviceEntryContainer.GetServiceEntry()
.FirstOrDefault(x => x.Descriptor.Id == RemoteInvokeMessage.ServiceId);
ServiceDesc serviceDesc;
if (ServiceEntry == null)
{
logger.Warn($"not found service: {RemoteInvokeMessage.ServiceId}");
List <ServiceRoute> router = serviceDiscovery.GetRoutesAsync().Result;
serviceDesc = router.FirstOrDefault(o => o.ServiceDescriptor.Id == RemoteInvokeMessage.ServiceId).ServiceDescriptor;
}
else
{
serviceDesc = ServiceEntry.Descriptor;
}
RemoteInvokeMessage.Parameters = CheckParameters(RemoteInvokeMessage.Parameters, serviceDesc, serializer);
}
public override void ChannelRead(IChannelHandlerContext context, object message)
{
Task.Run(() =>
{
TransportMsg msg = message as TransportMsg;
_readAction(context, msg);
});
}
public override void ChannelRead(IChannelHandlerContext context, object message)
{
TransportMsg msg = message as TransportMsg;
IClientListener listener = context.Channel.GetAttribute(AttributeKey <IClientListener> .ValueOf(typeof(DefaultTransportClientFactory), nameof(IClientListener))).Get();
IClientSender sender = context.Channel.GetAttribute(AttributeKey <IClientSender> .ValueOf(typeof(DefaultTransportClientFactory), nameof(IClientSender))).Get();
listener.Received(sender, msg);
}
public async Task Received(IClientSender sender, TransportMsg message)
{
if (OnReceived == null)
{
return;
}
await OnReceived(sender, message);
}
private async Task <RemoteCallBackData> RegisterResultCallbackAsync(string id)
{
TaskCompletionSource <TransportMsg> task = new TaskCompletionSource <TransportMsg>();
_resultCallbackDic.TryAdd(id, task);
try
{
TransportMsg result = await task.Task;
return(result.GetContent <RemoteCallBackData>(_serializer));
}
finally
{
_resultCallbackDic.TryRemove(id, out _);
}
}
private Task ListenerOnReceived(IClientSender sender, TransportMsg message)
{
_logger.Debug($"收到消息,消息id: {message.Id}");
if (!_resultCallbackDic.TryGetValue(message.Id, out TaskCompletionSource <TransportMsg> task))
{
return(Task.CompletedTask);
}
if (message.ContentType != typeof(RemoteCallBackData).FullName)
{
return(Task.CompletedTask);
}
task.SetResult(message);
return(Task.CompletedTask);
}
private async Task OnReceived(IChannelHandlerContext channel, TransportMsg message)
{
_logger.Debug($"开始触发服务: {message.Id}");
if (message.ContentType == typeof(RemoteCallData).FullName)
{
IResponse response = new RpcResponse(channel, _serializer, _logger);
RemoteExecutorContext thisContext = new RemoteExecutorContext(message, _serviceEntryContainer, response, _serializer, _logger, _serviceDiscovery);
RequestDel lastInvoke = new RequestDel(async context =>
{
RemoteCallBackData resultMessage = new RemoteCallBackData();
if (context.ServiceEntry == null)
{
resultMessage.ExceptionMessage = $"没有此服务：{context.RemoteInvokeMessage.ServiceId}";
await response.WriteAsync(message.Id, resultMessage);
}
else if (context.ServiceEntry.Descriptor.WaitExecution)
{
await LocalServiceExecuteAsync(context, resultMessage);
await response.WriteAsync(message.Id, resultMessage);
}
else
{
await response.WriteAsync(message.Id, resultMessage);
await Task.Factory.StartNew(async() =>
{
await LocalServiceExecuteAsync(context, resultMessage);
});
}
});
foreach (Func <RequestDel, RequestDel> middleware in _middlewares)
{
lastInvoke = middleware.Invoke(lastInvoke);
}
await lastInvoke.Invoke(thisContext);
}
else
{
_logger.Debug($"msg: {message.Id}, message type is not an RemoteCallData.");
}
}
public async Task WriteAsync(string messageId, RemoteCallBackData resultMessage)
{
try
{
_logger.Debug($"结束处理任务: {messageId}");
TransportMsg transportMsg = new TransportMsg
{
Id = messageId,
Content = resultMessage,
ContentType = resultMessage.GetType().ToString()
};
var data = LZ4MessagePackSerializer.FromJson(_serializer.Serialize <string>(transportMsg));
IByteBuffer buffer = Unpooled.Buffer(data.Length, data.Length);
buffer.WriteBytes(data);
await _channel.WriteAndFlushAsync(buffer);
}
catch (Exception ex)
{
_logger.Error("抛出错误 消息为: " + messageId, ex);
}
}
public async Task SendAsync(TransportMsg message)
{
IByteBuffer buffer = GetByteBuffer(message);
await _channel.WriteAndFlushAsync(buffer);
}
