private async Task <HttpResultMessage <object> > RemoteExecuteAsync(HttpMessage httpMessage)
{
HttpResultMessage <object> resultMessage = new HttpResultMessage <object>();
try {
var entity = await _serviceProxyProvider.Invoke <Object>(httpMessage.Parameters, httpMessage.RoutePath, httpMessage.ServiceKey);
if (entity != null)
{
entity = JsonConvert.DeserializeObject(entity.ToString(), typeof(Object));
}
resultMessage.Entity = entity;
resultMessage.IsSucceed = resultMessage.Entity != default;
resultMessage.StatusCode = resultMessage.IsSucceed ? (int)StatusCode.Success : (int)StatusCode.RequestError;
}
catch (Exception ex)
{
if (_logger.IsEnabled(LogLevel.Error))
{
_logger.LogError(ex, "执行远程调用逻辑时候发生了错误。");
}
resultMessage = new HttpResultMessage <object> {
Entity = null, Message = "执行发生了错误。", StatusCode = (int)StatusCode.RequestError
};
}
return(resultMessage);
}
private async Task <HttpResultMessage <object> > RemoteExecuteAsync(HttpRequestMessage httpMessage)
{
var resultMessage = new HttpResultMessage <object>();
try
{
resultMessage.Result = await _serviceProxyProvider.Invoke <object>(httpMessage.Parameters, httpMessage.RoutePath, httpMessage.ServiceKey);
resultMessage.IsSucceed = resultMessage.Result != default;
resultMessage.StatusCode = resultMessage.IsSucceed ? (int)StatusCode.Success : (int)StatusCode.RequestError;
}
catch (Exception exception)
{
if (_logger.IsEnabled(LogLevel.Error))
{
_logger.LogError(exception, $"执行远程调用逻辑时候发生了错误：{exception.Message}");
}
resultMessage.Result = null;
resultMessage.StatusCode = (int)StatusCode.RequestError;
resultMessage.Message = "执行发生了错误。";
resultMessage.Message = ExceptionPrompt.GetPrompt(exception);
}
return(resultMessage);
}
public async Task OnActionExecuting(ActionExecutingContext filterContext)
{
var gatewayAppConfig = AppConfig.Options.ApiGetWay;
if (filterContext.Message.RoutePath == gatewayAppConfig.AuthorizationRoutePath)
{
var token = await _authorizationServerProvider.GenerateTokenCredential(new Dictionary <string, object>(filterContext.Message.Parameters));
if (token != null)
{
filterContext.Result = HttpResultMessage <object> .Create(true, token);
filterContext.Result.StatusCode = StatusCode.Success;
}
else
{
filterContext.Result = new HttpResultMessage <object> {
IsSucceed = false, StatusCode = StatusCode.UnAuthentication, Message = "Invalid authentication credentials"
};
}
}
else if (filterContext.Route.ServiceDescriptor.AuthType() == AuthorizationType.AppSecret.ToString())
{
if (!ValidateAppSecretAuthentication(filterContext, out HttpResultMessage <object> result))
{
filterContext.Result = result;
}
}
}
public async Task InvokeAsync(HttpContext context)
{
try
{
await OnAuthorize(context);
await _next(context);
}
catch (AuthenticationException ex)
{
var noAuthResponseContent = new HttpResultMessage()
{
IsSucceed = false, Message = ex.Message, StatusCode = StatusCode.UnAuthentication
};
await context.Response.WriteAsync(_jsonSerializer.Serialize(noAuthResponseContent, true));
}
catch (CPlatformException ex)
{
var resultMessage = new HttpResultMessage()
{
IsSucceed = false, Message = ex.Message, StatusCode = StatusCode.CPlatformError
};
await context.Response.WriteAsync(_jsonSerializer.Serialize(resultMessage, true));
}
catch (Exception ex)
{
var resultMessage = new HttpResultMessage()
{
IsSucceed = false, Message = ex.StackTrace, StatusCode = StatusCode.RequestError
};
await context.Response.WriteAsync(_jsonSerializer.Serialize(resultMessage, true));
}
}
private async Task <HttpResultMessage <object> > RemoteExecuteAsync(ServiceEntry entry, HttpMessage httpMessage)
{
HttpResultMessage <object> resultMessage = new HttpResultMessage <object>();
var provider = _concurrent.GetValueOrDefault(httpMessage.RoutePath);
var list = new List <object>();
if (provider.Item1 == null)
{
provider.Item2 = ServiceLocator.GetService <IServiceProxyFactory>().CreateProxy(httpMessage.ServiceKey, entry.Type);
provider.Item3 = provider.Item2.GetType().GetTypeInfo().DeclaredMethods.Where(p => p.Name == entry.MethodName).FirstOrDefault();;
provider.Item1 = FastInvoke.GetMethodInvoker(provider.Item3);
_concurrent.GetOrAdd(httpMessage.RoutePath, ValueTuple.Create <FastInvokeHandler, object, MethodInfo>(provider.Item1, provider.Item2, provider.Item3));
}
foreach (var parameterInfo in provider.Item3.GetParameters())
{
var value = httpMessage.Parameters[parameterInfo.Name];
var parameterType = parameterInfo.ParameterType;
var parameter = _typeConvertibleService.Convert(value, parameterType);
list.Add(parameter);
}
try
{
var methodResult = provider.Item1(provider.Item2, list.ToArray());
var task = methodResult as Task;
if (task == null)
{
resultMessage.Data = methodResult;
}
else
{
await task;
var taskType = task.GetType().GetTypeInfo();
if (taskType.IsGenericType)
{
resultMessage.Data = taskType.GetProperty("Result").GetValue(task);
}
}
resultMessage.IsSucceed = resultMessage.Data != null;
resultMessage.StatusCode = resultMessage.IsSucceed ? StatusCode.OK : StatusCode.RequestError; //StatusCode.Success : (int)StatusCode.RequestError;
}
catch (Exception exception)
{
if (_logger.IsEnabled(LogLevel.Error))
{
_logger.LogError(exception, "执行远程调用逻辑时候发生了错误。");
}
if (exception is CPlatformException)
{
resultMessage.StatusCode = ((CPlatformException)exception).ExceptionCode;
}
else
{
resultMessage.StatusCode = StatusCode.UnKnownError;
}
resultMessage.Message = GetExceptionMessage(exception);
resultMessage.IsSucceed = false;
}
return(resultMessage);
}
private bool ValidateAppSecretAuthentication(ActionExecutingContext filterContext, out HttpResultMessage <object> result)
{
bool isSuccess = true;
DateTime time;
result = HttpResultMessage <object> .Create(true, null);
if (!filterContext.Route.ServiceDescriptor.EnableAuthorization())
{
return(isSuccess);
}
var author = filterContext.Context.Request.Headers["Authorization"];
var model = filterContext.Message.Parameters;
var route = filterContext.Route;
if (model.ContainsKey("timeStamp") && author.Count > 0)
{
if (long.TryParse(model["timeStamp"].ToString(), out long timeStamp))
{
time = DateTimeConverter.UnixTimestampToDateTime(timeStamp);
var seconds = (DateTime.Now - time).TotalSeconds;
if (seconds <= 3560 && seconds >= 0)
{
if (GetMD5($"{route.ServiceDescriptor.Token}{time.ToString("yyyy-MM-dd hh:mm:ss") }") != author.ToString())
{
result = new HttpResultMessage <object> {
IsSucceed = false, StatusCode = StatusCode.UnAuthentication, Message = "Invalid authentication credentials"
};
isSuccess = false;
}
}
else
{
result = new HttpResultMessage <object> {
IsSucceed = false, StatusCode = StatusCode.UnAuthentication, Message = "Invalid authentication credentials"
};
isSuccess = false;
}
}
else
{
result = new HttpResultMessage <object> {
IsSucceed = false, StatusCode = StatusCode.UnAuthentication, Message = "Invalid authentication credentials"
};
isSuccess = false;
}
}
else
{
// todo 认证 AppAppSecret
result = new HttpResultMessage <object> {
IsSucceed = false, StatusCode = StatusCode.RequestError, Message = "Request error"
};
isSuccess = false;
}
return(isSuccess);
}
/// <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("服务提供者接收到消息。");
}
if (!message.IsHttpMessage())
{
return;
}
HttpMessage httpMessage;
try
{
httpMessage = message.GetContent <HttpMessage>();
if (httpMessage.Attachments != null)
{
foreach (var attachment in httpMessage.Attachments)
{
RpcContext.GetContext().SetAttachment(attachment.Key, attachment.Value);
}
}
}
catch (Exception exception)
{
_logger.LogError(exception, "将接收到的消息反序列化成 TransportMessage<httpMessage> 时发送了错误。");
return;
}
var entry = _serviceEntryLocate.Locate(httpMessage);
if (entry == null)
{
if (_logger.IsEnabled(LogLevel.Error))
{
_logger.LogError($"根据服务routePath：{httpMessage.RoutePath} - {httpMessage.HttpMethod}，找不到服务条目。");
}
return;
}
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug("准备执行本地逻辑。");
}
HttpResultMessage <object> httpResultMessage = new HttpResultMessage <object>()
{
};
if (_serviceProvider.IsRegisteredWithKey(httpMessage.ServiceKey, entry.Type))
{
//执行本地代码。
httpResultMessage = await LocalExecuteAsync(entry, httpMessage);
}
else
{
httpResultMessage = await RemoteExecuteAsync(entry, httpMessage);
}
await SendRemoteInvokeResult(sender, httpResultMessage);
}
private async Task <HttpResultMessage <object> > LocalExecuteAsync(ServiceEntry entry,
HttpRequestMessage httpMessage)
{
var resultMessage = new HttpResultMessage <object>();
try
{
var result = await entry.Func(httpMessage.ServiceKey, httpMessage.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);
}
}
resultMessage.IsSucceed = resultMessage.Result != null;
resultMessage.StatusCode = resultMessage.IsSucceed ? (int)StatusCode.Success : (int)StatusCode.RequestError;
}
catch (ValidateException validateException)
{
if (_logger.IsEnabled(LogLevel.Error))
{
_logger.LogError(validateException, $"执行本地逻辑时候发生了错误：{validateException.Message}", validateException);
}
resultMessage.Message = validateException.Message;
resultMessage.StatusCode = validateException.HResult;
}
catch (Exception exception)
{
if (_logger.IsEnabled(LogLevel.Error))
{
_logger.LogError(exception, $"执行本地逻辑时候发生了错误：{exception.Message}");
}
resultMessage.StatusCode = exception.HResult;
resultMessage.Message = "执行发生了错误。";
resultMessage.Message = ExceptionPrompt.GetPrompt(exception);
}
return(resultMessage);
}
/// <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("服务提供者接收到消息。");
}
if (!message.IsHttpMessage())
{
return;
}
HttpMessage httpMessage;
try
{
httpMessage = message.GetContent <HttpMessage>();
}
catch (Exception exception)
{
_logger.LogError(exception, "将接收到的消息反序列化成 TransportMessage<httpMessage> 时发送了错误。");
return;
}
var entry = _serviceEntryLocate.Locate(httpMessage);
if (entry == null)
{
if (_logger.IsEnabled(LogLevel.Error))
{
_logger.LogError($"根据服务routePath：{httpMessage.RoutePath}，找不到服务条目。");
}
return;
}
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug("准备执行本地逻辑。");
}
if (_serviceProvider.IsRegisteredWithKey(httpMessage.ServiceKey, entry.Type))
{
HttpResultMessage <object> httpResultMessage = new HttpResultMessage <object>();
//执行本地代码。
await LocalExecuteAsync(entry, httpMessage, httpResultMessage);
//向客户端发送调用结果。
await SendRemoteInvokeResult(sender, httpResultMessage);
}
else
{
HttpResultMessage <object> httpResultMessage = new HttpResultMessage <object>();
await RemoteExecuteAsync(entry, httpMessage, httpResultMessage);
await SendRemoteInvokeResult(sender, httpResultMessage);
}
}
public async Task <RemoteInvokeResultMessage> SendAsync(CancellationToken cancellationToken)
{
var command = _app.Model;
var httpMessage = new HttpResultMessage <Object>();
switch (command.Method.ToLower())
{
case "post":
{
var formData = command.FormData.ToDictionary();
if (formData.ContainsKey("type") && formData["type"] == "application/octet-stream")
{
httpMessage = await _httpClientProvider.UploadFileAsync <HttpResultMessage <Object> >(command.Address, command.FormData.ToDictionary(), command.Header.ToDictionary());
}
else
{
httpMessage = await _httpClientProvider.PostJsonMessageAsync <HttpResultMessage <Object> >(command.Address, command.Data, command.Header.ToDictionary());
}
break;
}
case "get":
{
httpMessage = await _httpClientProvider.GetJsonMessageAsync <HttpResultMessage <Object> >(command.Address, command.Header.ToDictionary());
break;
}
case "put":
{
httpMessage = await _httpClientProvider.PutJsonMessageAsync <HttpResultMessage <Object> >(command.Address, command.Data, command.Header.ToDictionary());
break;
}
case "delete":
{
httpMessage = await _httpClientProvider.DeleteJsonMessageAsync <HttpResultMessage <Object> >(command.Address, command.Data, command.Header.ToDictionary());
break;
}
}
return(new RemoteInvokeResultMessage
{
ExceptionMessage = httpMessage.Message,
Result = httpMessage.Entity,
StatusCode = httpMessage.StatusCode
});
}
/// <summary>
/// execute as an asynchronous operation.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="message">The message.</param>
public async Task ExecuteAsync(IMessageSender sender, TransportMessage message)
{
if (_logger.IsEnabled(LogLevel.Trace))
{
_logger.LogTrace("服务提供者接收到消息。");
}
if (!message.IsHttpMessage())
{
return;
}
HttpRequestMessage httpMessage;
try
{
httpMessage = message.GetContent <HttpRequestMessage>();
}
catch (Exception exception)
{
_logger.LogError(exception, "将接收到的消息反序列化成 TransportMessage<httpMessage> 时发送了错误。");
return;
}
if (httpMessage.Attachments != null)
{
foreach (var attachment in httpMessage.Attachments)
{
RpcContext.GetContext().SetAttachment(attachment.Key, attachment.Value);
}
}
WirteDiagnosticBefore(message);
var entry = _serviceEntryLocate.Locate(httpMessage);
var httpResultMessage = new HttpResultMessage <object>();
if (entry != null && _serviceProvider.IsRegisteredWithKey(httpMessage.ServiceKey, entry.Type))
{
//执行本地代码。
httpResultMessage = await LocalExecuteAsync(entry, httpMessage);
}
else
{
httpResultMessage = await RemoteExecuteAsync(httpMessage);
}
await SendRemoteInvokeResult(sender, message.Id, httpResultMessage);
}
private async Task <HttpResultMessage <object> > LocalExecuteAsync(ServiceEntry entry, HttpMessage httpMessage)
{
HttpResultMessage <object> resultMessage = new HttpResultMessage <object>();
try
{
var result = await entry.Func(httpMessage.ServiceKey, httpMessage.Parameters);
var task = result as Task;
if (task == null)
{
resultMessage.Data = result;
}
else
{
task.Wait();
var taskType = task.GetType().GetTypeInfo();
if (taskType.IsGenericType)
{
resultMessage.Data = taskType.GetProperty("Result").GetValue(task);
}
}
resultMessage.IsSucceed = resultMessage.Data != null;
resultMessage.StatusCode = resultMessage.IsSucceed ? StatusCode.OK : StatusCode.RequestError; //StatusCode.Success : (int)StatusCode.RequestError;
}
catch (Exception exception)
{
if (_logger.IsEnabled(LogLevel.Error))
{
_logger.LogError(exception, "执行本地逻辑时候发生了错误。");
}
//resultMessage.Message = "执行发生了错误。";
//resultMessage.StatusCode = exception.HResult;
//if (exception is CPlatformException)
//{
// resultMessage.StatusCode = ((CPlatformException)exception).ExceptionCode;
//}
//else
//{
// resultMessage.StatusCode = StatusCode.UnKnownError;
//}
resultMessage.StatusCode = GetGetExceptionStatusCode(exception);
resultMessage.Message = GetExceptionMessage(exception);
resultMessage.IsSucceed = false;
}
return(resultMessage);
}
private async Task LocalExecuteAsync(UdpServiceEntry entry, byte [] bytes)
{
HttpResultMessage <object> resultMessage = new HttpResultMessage <object>();
try
{
await entry.Behavior.Dispatch(bytes);
}
catch (Exception exception)
{
if (_logger.IsEnabled(LogLevel.Error))
{
_logger.LogError(exception, "执行本地逻辑时候发生了错误。");
}
}
}
public async Task OnActionExecuting(ActionExecutingContext filterContext)
{
var gatewayAppConfig = AppConfig.Options.ApiGetWay;
if (filterContext.Message.RoutePath == gatewayAppConfig.AuthenticationRoutePath)
{
var terminal = filterContext.Context.Request.Headers["x-terminal"];
if (gatewayAppConfig.IsUsingTerminal)
{
if (!terminal.Any())
{
filterContext.Result = new HttpResultMessage <object> {
IsSucceed = false, StatusCode = StatusCode.RequestError, Message = "请设置请求头x-terminal"
};
}
if (gatewayAppConfig.Terminals.Split(",").Any(p => p == terminal))
{
filterContext.Result = new HttpResultMessage <object> {
IsSucceed = false, StatusCode = StatusCode.RequestError, Message = $"不支持名称为{terminal}的终端,请检查设置的请求头x-terminal"
};
}
//filterContext.Message.Parameters.Add("terminal", terminal);
RpcContext.GetContext().SetAttachment("x-terminal", terminal.ToString());
}
var token = await _authorizationServerProvider.IssueToken(new Dictionary <string, object>(filterContext.Message.Parameters));
if (token != null)
{
filterContext.Result = HttpResultMessage <object> .Create(true, token);
filterContext.Result.StatusCode = StatusCode.Success;
}
else
{
filterContext.Result = new HttpResultMessage <object> {
IsSucceed = false, StatusCode = StatusCode.RequestError, Message = "请求失败,请稍后重试"
};
}
}
else if (filterContext.Route.ServiceDescriptor.AuthType() == AuthorizationType.AppSecret.ToString())
{
if (!ValidateAppSecretAuthentication(filterContext, out HttpResultMessage <object> result))
{
filterContext.Result = result;
}
}
}
private async Task <DnsTransportMessage> LocalExecuteAsync(DnsServiceEntry entry, DnsTransportMessage message)
{
HttpResultMessage <object> resultMessage = new HttpResultMessage <object>();
try
{
var dnsQuestion = message.DnsQuestion;
message.Address = await entry.Behavior.DomainResolve(dnsQuestion.Name);
}
catch (Exception exception)
{
if (_logger.IsEnabled(LogLevel.Error))
{
_logger.LogError(exception, "执行本地逻辑时候发生了错误。");
}
}
return(message);
}
private async Task <HttpResultMessage <object> > RemoteExecuteAsync(HttpMessage httpMessage)
{
HttpResultMessage <object> resultMessage = new HttpResultMessage <object>();
try
{
resultMessage.Entity = await _serviceProxyProvider.Invoke <object>(httpMessage.Parameters, httpMessage.RoutePath, httpMessage.ServiceKey);
resultMessage.IsSucceed = resultMessage.Entity != default;
resultMessage.StatusCode = resultMessage.IsSucceed ? (int)StatusCode.Success : (int)StatusCode.RequestError;
}
catch (Exception ex)
{
resultMessage = new HttpResultMessage <object> {
Entity = null, Message = "执行发生了错误。", StatusCode = (int)StatusCode.RequestError
};
}
return(resultMessage);
}
public async Task ExecuteAsync(IMessageSender sender, TransportMessage message)
{
if (!message.IsHttpMessage())
{
return;
}
HttpMessage httpMessage;
try
{
httpMessage = message.GetContent <HttpMessage>();
}
catch (Exception exception)
{
Console.WriteLine(exception.Message + "将接收到的消息反序列化成 TransportMessage<httpMessage> 时发送了错误。");
return;
}
//if (httpMessage.Attachments != null)
//{
// foreach (var attachment in httpMessage.Attachments)
// RpcContext.GetContext().SetAttachment(attachment.Key, attachment.Value);
//}
WirteDiagnosticBefore(message);
var entry = _serviceEntryLocate.Locate(httpMessage);
HttpResultMessage <object> httpResultMessage = new HttpResultMessage <object>()
{
};
if (entry != null)
{
//执行本地代码。
httpResultMessage = await LocalExecuteAsync(entry, httpMessage);
}
else
{
//httpResultMessage = await RemoteExecuteAsync(httpMessage);
}
await SendRemoteInvokeResult(sender, message.Id, httpResultMessage);
}
private async Task <HttpResultMessage <object> > RemoteExecuteAsync(HttpMessage httpMessage)
{
HttpResultMessage <object> resultMessage = new HttpResultMessage <object>();
try {
resultMessage.Data = await _serviceProxyProvider.Invoke <object>(httpMessage.Parameters, httpMessage.RoutePath, httpMessage.ServiceKey);
resultMessage.IsSucceed = resultMessage.Data != default;
resultMessage.StatusCode = resultMessage.IsSucceed ? (int)StatusCode.Success : (int)StatusCode.RequestError;
}
catch (Exception ex)
{
if (_logger.IsEnabled(LogLevel.Error))
{
_logger.LogError(ex, "执行远程调用逻辑时候发生了错误。");
}
resultMessage = new HttpResultMessage <object> {
Data = null, Message = "执行发生了错误。", StatusCode = (int)StatusCode.RequestError
};
}
return(resultMessage);
}
public async Task OnActionExecuting(ActionExecutingContext filterContext)
{
var gatewayAppConfig = AppConfig.Options.ApiGetWay;
if (filterContext.Message.RoutePath == gatewayAppConfig.AuthorizationRoutePath)
{
var token = await _authorizationServerProvider.GenerateTokenCredential(new Dictionary <string, object>(filterContext.Message.Parameters));
if (token != null)
{
filterContext.Result = HttpResultMessage <object> .Create(true, token);
filterContext.Result.StatusCode = (int)ServiceStatusCode.Success;
}
else
{
filterContext.Result = new HttpResultMessage <object> {
IsSucceed = false, StatusCode = (int)ServiceStatusCode.AuthorizationFailed, Message = "Invalid authentication credentials"
};
}
}
}
public async Task ExecuteAsync(IMessageSender sender, TransportMessage message)
{
if (_logger.IsEnabled(LogLevel.Trace))
{
_logger.LogTrace("服务提供者接收到消息。");
}
if (!message.IsHttpMessage())
{
return;
}
HttpMessage httpMessage;
try
{
httpMessage = message.GetContent <HttpMessage>();
}
catch (Exception exception)
{
_logger.LogError(exception, "将接收到的消息反序列化成 TransportMessage<httpMessage> 时发送了错误。");
return;
}
var entry = _serviceEntryLocate.Locate(httpMessage);
HttpResultMessage <object> httpResultMessage = new HttpResultMessage <object>()
{
};
if (entry != null && _serviceProvider.IsRegisteredWithKey(httpMessage.ServiceKey, entry.Type))
{
//执行本地代码。
httpResultMessage = await LocalExecuteAsync(entry, httpMessage);
}
else
{
httpResultMessage = await RemoteExecuteAsync(httpMessage);
}
await SendRemoteInvokeResult(sender, httpResultMessage);
}
private async Task <HttpResultMessage <object> > RemoteExecuteAsync(HttpMessage httpMessage)
{
HttpResultMessage <object> resultMessage = new HttpResultMessage <object>();
try {
var resultData = await _serviceProxyProvider.Invoke <object>(httpMessage.Parameters, httpMessage.RoutePath, httpMessage.ServiceKey);
resultMessage.Entity = HandleResultData(resultData);
resultMessage.IsSucceed = resultMessage.Entity != default;
resultMessage.StatusCode = resultMessage.IsSucceed ? StatusCode.Success : StatusCode.RequestError;
}
catch (Exception ex)
{
if (_logger.IsEnabled(LogLevel.Error))
{
_logger.LogError(ex, "执行远程调用逻辑时候发生了错误。");
}
resultMessage = new HttpResultMessage <object> {
Entity = null, Message = ex.GetExceptionMessage(), StatusCode = ex.GetGetExceptionStatusCode()
};
}
return(resultMessage);
}
private async Task <HttpResultMessage <object> > LocalExecuteAsync(ServiceEntry entry, HttpMessage httpMessage)
{
HttpResultMessage <object> resultMessage = new HttpResultMessage <object>();
try
{
var result = await entry.Func(httpMessage.ServiceKey, httpMessage.Parameters);
var task = result as Task;
if (task == null)
{
resultMessage.Entity = result;
}
else
{
task.Wait();
var taskType = task.GetType().GetTypeInfo();
if (taskType.IsGenericType)
{
resultMessage.Entity = taskType.GetProperty("Result").GetValue(task);
}
}
resultMessage.IsSucceed = resultMessage.Entity != null;
resultMessage.StatusCode = resultMessage.IsSucceed ? StatusCode.Success : StatusCode.RequestError;
}
catch (Exception exception)
{
if (_logger.IsEnabled(LogLevel.Error))
{
_logger.LogError(exception, "执行本地逻辑时候发生了错误。");
}
resultMessage.Message = exception.GetExceptionMessage();
resultMessage.StatusCode = exception.GetGetExceptionStatusCode();
}
return(resultMessage);
}
private async Task <HttpResultMessage <object> > LocalExecuteAsync(ServiceEntry entry, HttpMessage httpMessage)
{
HttpResultMessage <object> resultMessage = new HttpResultMessage <object>();
try
{
var result = await entry.Func(httpMessage.ServiceKey, httpMessage.Parameters);
var task = result as Task;
if (task == null)
{
resultMessage.Entity = result;
}
else
{
task.Wait();
var taskType = task.GetType().GetTypeInfo();
if (taskType.IsGenericType)
{
resultMessage.Entity = taskType.GetProperty("Result").GetValue(task);
}
}
resultMessage.IsSucceed = resultMessage.Entity != null;
resultMessage.StatusCode =
resultMessage.IsSucceed ? (int)StatusCode.Success : (int)StatusCode.RequestError;
}
catch (Exception ex)
{
Console.WriteLine("执行本地逻辑时候发生了错误。");
resultMessage.Message = ex.Message;
resultMessage.StatusCode = ex.HResult;
}
return(resultMessage);
}
private async Task SendRemoteInvokeResult(IMessageSender sender, HttpResultMessage resultMessage)
{
try
{
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug("准备发送响应消息。");
}
await sender.SendAndFlushAsync(new TransportMessage(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, HttpResultMessage resultMessage)
{
try
{
await sender.SendAndFlushAsync(new TransportMessage(messageId, resultMessage));
}
catch (Exception exception)
{
Console.WriteLine(exception.Message + "发送响应消息时候发生了异常。");
}
}
private async Task RemoteExecuteAsync(ServiceEntry entry, HttpMessage httpMessage, HttpResultMessage <object> resultMessage)
{
var provider = _concurrent.GetValueOrDefault(httpMessage.RoutePath);
var list = new List <object>();
if (provider.Item1 == null)
{
provider.Item2 = ServiceLocator.GetService <IServiceProxyFactory>().CreateProxy(httpMessage.ServiceKey, entry.Type);
provider.Item3 = provider.Item2.GetType().GetTypeInfo().DeclaredMethods.Where(p => p.Name == entry.MethodName).FirstOrDefault();;
provider.Item1 = FastInvoke.GetMethodInvoker(provider.Item3);
_concurrent.GetOrAdd(httpMessage.RoutePath, ValueTuple.Create <FastInvokeHandler, object, MethodInfo>(provider.Item1, provider.Item2, provider.Item3));
}
foreach (var parameterInfo in provider.Item3.GetParameters())
{
var value = httpMessage.Parameters[parameterInfo.Name];
var parameterType = parameterInfo.ParameterType;
var parameter = _typeConvertibleService.Convert(value, parameterType);
list.Add(parameter);
}
var methodResult = provider.Item1(provider.Item2, list.ToArray());
var task = methodResult as Task;
if (task == null)
{
resultMessage.Entity = methodResult;
resultMessage.IsSucceed = resultMessage.Entity != null;
}
else
{
await task;
var taskType = task.GetType().GetTypeInfo();
if (taskType.IsGenericType)
{
resultMessage.Entity = taskType.GetProperty("Result").GetValue(task);
}
resultMessage.IsSucceed = resultMessage.Entity != null;
}
}
