/// <summary>
/// 发送消息。
/// </summary>
/// <param name="message">远程调用消息模型。</param>
/// <returns>远程调用消息的传输消息。</returns>
public async Task <TransportMessage> SendAsync(RemoteInvokeMessage message)
{
try
{
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.Debug("准备发送消息。");
}
var transportMessage = TransportMessage.CreateInvokeMessage(message);
await _messageSender.SendAndFlushAsync(transportMessage);
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.Debug("消息发送成功。");
}
return(transportMessage);
}
catch (Exception exception)
{
if (_logger.IsEnabled(LogLevel.Fatal))
{
_logger.Fatal("消息发送失败。", exception);
}
throw;
}
}
/// <summary>
/// 发送消息。
/// </summary>
/// <param name="message">远程调用消息模型。</param>
/// <returns>远程调用消息的传输消息。</returns>
public async Task SendAsync(TransportMessage transportMessage)
{
try
{
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug("准备发送消息。");
}
try
{
//发送
await _messageSender.SendAndFlushAsync(transportMessage);
}
catch (Exception exception)
{
throw new Exception("与服务端通讯时发生了异常。", exception);
}
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug("消息发送成功。");
}
}
catch (Exception exception)
{
if (_logger.IsEnabled(LogLevel.Error))
{
_logger.LogError(null, exception, "消息发送失败。");
}
throw;
}
}
/// <summary>
/// 发送消息
/// </summary>
/// <param name="message">远程调用消息模型</param>
/// <returns>远程调用消息的传输消息</returns>
public async Task <RemoteInvokeResultMessage> SendAsync(RemoteInvokeMessage message)
{
try
{
_logger.LogInformation("");
Console.WriteLine("准备发送消息");
var transportMessage = TransportMessage.CreateInvokeMessage(message);
//注册结果回调
var callbackTask = RegisterResultCallbackAsync(transportMessage.Id);
try
{
//发送
await _messageSender.SendAndFlushAsync(transportMessage);
}
catch (Exception exception)
{
throw new RpcCommunicationException("与服务端通讯时发生了异常", exception);
}
Console.WriteLine("消息发送成功");
return(await callbackTask);
}
catch (Exception exception)
{
Console.WriteLine("消息发送失败" + exception);
throw;
}
}
public async Task <RemoteInvokeResultMessage> SendAsync(CancellationToken cancellationToken)
{
try
{
var def = new Dictionary <string, object>();
var command = _app.Model;
var transportMessage = TransportMessage.CreateInvokeMessage(new RemoteInvokeMessage
{
DecodeJOject = true,
Parameters = string.IsNullOrEmpty(command.Data) ? def : JsonConvert.DeserializeObject <IDictionary <string, object> >(command.Data),
ServiceId = command.ServiceId,
ServiceKey = command.ServiceKey,
Attachments = string.IsNullOrEmpty(command.Attachments) ? def : JsonConvert.DeserializeObject <IDictionary <string, object> >(command.Attachments)
});
var callbackTask = RegisterResultCallbackAsync(transportMessage.Id);
try
{
await _messageSender.SendAndFlushAsync(transportMessage);
}
catch (Exception exception)
{
throw;
}
return(await callbackTask);
}
catch
{
throw;
}
}
private async Task SendRemoteInvokeResult(IMessageSender sender, string messageId, HttpResultMessage resultMessage)
{
try
{
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug("准备发送响应消息。");
}
await sender.SendAndFlushAsync(new TransportMessage(messageId, resultMessage));
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug("响应消息发送成功。");
}
}
catch (Exception exception)
{
if (_logger.IsEnabled(LogLevel.Error))
{
_logger.LogError(exception, "发送响应消息时候发生了异常。");
}
}
finally
{
RpcContext.RemoveContext();
}
}
/// <summary>
/// 发送消息。
/// </summary>
/// <param name="message">远程调用消息模型。</param>
/// <returns>一个任务。</returns>
public async Task SendAsync(RemoteInvokeMessage message)
{
try
{
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.Debug("准备发送消息。");
}
await _messageSender.SendAndFlushAsync(message);
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.Debug("消息发送成功。");
}
}
catch (Exception exception)
{
if (_logger.IsEnabled(LogLevel.Fatal))
{
_logger.Fatal("消息发送失败。", exception);
}
throw;
}
}
private async Task SendRemoteInvokeErrorResult(IMessageSender sender, string messageId, int statusCode, string errorMessage)
{
try
{
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug("准备发送响应消息。");
}
await sender.SendAndFlushAsync(TransportMessage.CreateInvokeResultMessage(messageId, new RemoteInvokeResultMessage {
StatusCode = statusCode, ExceptionMessage = errorMessage
}));
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 async Task <RemoteInvokeResultMessage> SendAsync(RemoteInvokeMessage message)
{
try
{
_logger.LogInformation("准备发送消息。");
var transportMessage = TransportMessage.CreateInvokeMessage(message);
//注册结果回调
var callbackTask = RegisterResultCallbackAsync(transportMessage.Id);
try
{
//发送
await _messageSender.SendAndFlushAsync(transportMessage);
}
catch (Exception exception)
{
throw new RpcCommunicationException("与服务端通讯时发生了异常", exception);
}
_logger.LogInformation("消息发送成功。");
return(await callbackTask);
}
catch (Exception exception)
{
if (_logger.IsEnabled(LogLevel.Error))
{
_logger.LogError("消息发送失败。", exception);
}
throw;
}
}
/// <summary>
/// 执行。
/// </summary>
/// <param name="sender">消息发送者。</param>
/// <param name="message">调用消息。</param>
public async Task ExecuteAsync(IMessageSender sender, TransportMessage message)
{
if (_logger.IsEnabled(LogLevel.Trace))
{
_logger.LogTrace($"服务提供者接收到消。");
}
Console.WriteLine($"服务提供者接收到消息，Content:{message.Content}，ID:{ message.Id}");
sender.SendAndFlushAsync(message);
return;
}
private async Task SendRemoteInvokeResult(IMessageSender sender, string messageId, HttpResultMessage resultMessage)
{
try
{
await sender.SendAndFlushAsync(new TransportMessage(messageId, resultMessage));
}
catch (Exception exception)
{
Console.WriteLine(exception.Message + "发送响应消息时候发生了异常。");
}
}
private async Task SendRemoteInvokeResult(IMessageSender sender, string messageId,
RemoteInvokeResultMessage resultMessage)
{
try
{
Console.WriteLine("准备发送响应消息");
await sender.SendAndFlushAsync(TransportMessage.CreateInvokeResultMessage(messageId, resultMessage));
Console.WriteLine("响应消息发送成功");
}
catch (Exception exception)
{
Console.WriteLine("发送响应消息时候发生了异常" + exception);
}
}
public async Task <bool> OnActionExecuting(ActionExecutingContext filterContext, IMessageSender sender, string messageId, IEnumerable <IActionFilter> filters)
{
foreach (var fiter in filters)
{
await fiter.OnActionExecuting(filterContext);
if (filterContext.Result != null)
{
await sender.SendAndFlushAsync(new TransportMessage(messageId, filterContext.Result));
return(false);
}
}
return(true);
}
public async Task Handle(string messageId, IMessageSender sender, RemoteInvokeMessage message)
{
RpcContext.GetContext()
.SetAttachments(message.Attachments);
RemoteResultMessage remoteResultMessage;
try
{
var serviceEntry =
_serviceEntryLocator.GetLocalServiceEntryById(message.ServiceId);
if (serviceEntry == null)
{
throw new LmsException($"通过服务id{message.ServiceId}获取本地服务条目失败", StatusCode.NotFindLocalServiceEntry);
}
var tokenValidator = EngineContext.Current.Resolve <ITokenValidator>();
if (!tokenValidator.Validate())
{
throw new RpcAuthenticationException("rpc token不合法");
}
var currentServiceKey = EngineContext.Current.Resolve <ICurrentServiceKey>();
var result = await serviceEntry.Executor(currentServiceKey.ServiceKey,
message.Parameters);
remoteResultMessage = new RemoteResultMessage()
{
Result = result,
StatusCode = StatusCode.Success
};
}
catch (Exception e)
{
remoteResultMessage = new RemoteResultMessage()
{
ExceptionMessage = e.GetExceptionMessage(),
StatusCode = e.GetExceptionStatusCode(),
ValidateErrors = e.GetValidateErrors()
};
}
var resultTransportMessage = new TransportMessage(remoteResultMessage, messageId);
await sender.SendAndFlushAsync(resultTransportMessage);
}
private async Task SendRemoteInvokeResult(IMessageSender sender, string messageId,
RemoteInvokeResultMessage resultMessage)
{
try
{
_logger.LogInformation("准备发送响应消息");
await sender.SendAndFlushAsync(TransportMessage.CreateInvokeResultMessage(messageId, resultMessage));
_logger.LogInformation("响应消息发送成功");
}
catch (Exception exception)
{
if (_logger.IsEnabled(LogLevel.Error))
{
_logger.LogError("发送响应消息时候发生了异常。", exception);
}
}
}
public async Task <RemoteInvokeResultMessage> SendAsync(RemoteInvokeMessage message,
CancellationToken cancellationToken)
{
try
{
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug("准备发送消息。");
}
var transportMessage = TransportMessage.CreateInvokeMessage(message);
WirteDiagnosticBefore(transportMessage);
// 注册结果回调
var callbackTask = RegisterResultCallbackAsync(transportMessage.Id, cancellationToken);
try
{
// 发送
await _messageSender.SendAndFlushAsync(transportMessage);
}
catch (Exception exception)
{
throw new CommunicationException("与服务端通讯时发生了异常。", exception);
}
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug("消息发送成功。");
}
return(await callbackTask);
}
catch (Exception exception)
{
if (_logger.IsEnabled(LogLevel.Error))
{
_logger.LogError(exception, "消息发送失败。");
}
throw;
}
}
public async Task <bool> OnActionExecuting(HttpContext context, HttpMessage message, IMessageSender sender, IEnumerable <IActionFilter> filters)
{
foreach (var fiter in filters)
{
var filterContext = new ActionExecutingContext()
{
Context = context,
Message = message
};
await fiter.OnActionExecuting(filterContext);
if (filterContext.Result != null)
{
await sender.SendAndFlushAsync(new TransportMessage(filterContext.Result));
return(false);
}
}
return(true);
}
private async Task SendRemoteInvokeResult(IMessageSender sender, long messageId, RemoteInvokeResultMessage resultMessage)
{
try
{
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug("准备发送响应消息。");
}
await sender.SendAndFlushAsync(TransportMessage.CreateInvokeResultMessage(messageId, resultMessage));
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug("响应消息发送成功。");
}
}
catch (Exception exception)
{
if (_logger.IsEnabled(LogLevel.Error))
{
_logger.LogError("发送响应消息时候发生了异常。", exception);
}
}
}
private async Task SendRemoteInvokeResult(IMessageSender sender, string messageId, RemoteInvokeResultMessage resultMessage)
{
try
{
if (_logger.IsEnabled(LogLevel.Debug))
_logger.LogDebug("准备发送响应消息。");
await sender.SendAndFlushAsync(TransportMessage.CreateInvokeResultMessage(messageId, 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 SendAndFlushAsync(TransportMessage message)
{
return(_messageSender.SendAndFlushAsync(message));
}