/// <summary>
/// Called when [action executing].
/// </summary>
/// <param name="filterContext">The filter context.</param>
public async Task OnActionExecuting(ActionExecutingContext filterContext)
{
var serviceEntry = _serviceEntryLocate.Locate(filterContext.Message);
if (serviceEntry != null)
{
var httpMethods = serviceEntry.Methods;
if (httpMethods.Count() > 0 &&
!httpMethods.Any(p => string.Compare(p, filterContext.Context.Request.Method, true) == 0))
{
filterContext.Result = new HttpResultMessage <object>
{
IsSucceed = false,
StatusCode = Http405EndpointStatusCode,
Message = Http405EndpointDisplayName
};
}
}
else
{
var serviceRoute = await _serviceRouteProvider.GetRouteByPath(filterContext.Message.RoutePath);
var httpMethods = serviceRoute.ServiceDescriptor.HttpMethod();
if (!string.IsNullOrEmpty(httpMethods) && !httpMethods.Contains(filterContext.Context.Request.Method))
{
filterContext.Result = new HttpResultMessage <object>
{
IsSucceed = false,
StatusCode = Http405EndpointStatusCode,
Message = Http405EndpointDisplayName
};
}
}
}
/// <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);
}
/// <summary>
/// 执行消息转换后的服务
/// </summary>
/// <param name="sender">消息发送者</param>
/// <param name="message">调用消息</param>
public async Task ExecuteAsync(IMessageSender sender, TransportMessage message)
{
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;
}
_logger.LogInformation("准备执行本地逻辑");
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);
}
}
/// <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 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;
}
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 && _serviceProvider.IsRegisteredWithKey(httpMessage.ServiceKey, entry.Type))
{
//执行本地代码。
httpResultMessage = await LocalExecuteAsync(entry, httpMessage);
}
else
{
httpResultMessage = await RemoteExecuteAsync(httpMessage);
}
await SendRemoteInvokeResult(sender, message.Id, httpResultMessage);
}
public async Task OnActionExecuting(ActionExecutingContext filterContext)
{
filterContext.Context.Response.OnStarting(async() =>
{
var options = AppConfig.Options;
var transferContract = filterContext.Route.ServiceDescriptor.GetTransferContract();
if (transferContract != null)
{
var option = options.Where(p => p.Name == transferContract.Name).FirstOrDefault();
if (option != null)
{
var routePath = string.IsNullOrEmpty(option.RoutePath) ? transferContract.RoutePath : option.RoutePath;
var address = new StringBuilder(option.Endpoint);
address = address.Append(routePath);
var serviceEntry = _serviceEntryLocate.Locate(filterContext.Message);
if (serviceEntry != null)
{
var parameters = new Dictionary <string, object>();
foreach (var parameterInfo in serviceEntry.Parameters)
{
var value = filterContext.Message.Parameters[parameterInfo.Name];
var parameterType = parameterInfo.ParameterType;
var parameter = _typeConvertibleService.Convert(value, parameterType);
parameters.Add(parameterInfo.Name, _typeConvertibleService.Convert(value, parameterType));
}
try
{
var result = await ServiceLocator.GetService <ITransportClient>(transferContract.Type.ToString()).SendAsync(address.ToString(),
parameters, filterContext.Context);
await new MessageSender(_serializer, filterContext.Context).SendAndFlushAsync(result, GetContentType(transferContract.Type));
}
catch (Exception ex)
{
var i = 0;
}
}
}
}
});
}
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);
}
public async Task OnActionExecuting(ActionExecutingContext filterContext)
{
var serviceEntry= _serviceEntryLocate.Locate(filterContext.Message);
if (serviceEntry != null)
{
var httpMethods = serviceEntry.Methods;
if (httpMethods.Count()>0 && !httpMethods.Any(p => String.Compare(p, filterContext.Context.Request.Method, true) == 0))
{
filterContext.Result = new HttpResultMessage<object>
{
IsSucceed = false,
StatusCode = Http405EndpointStatusCode,
Message = Http405EndpointDisplayName
};
}
}
else
{
var path = HttpUtility.UrlDecode(GetRoutePath(filterContext.Context.Request.Path.ToString()));
path = AppConfig.MapRoutePathOptions.GetRoutePath(path, filterContext.Message.HttpMethod);
var serviceRoute = await _serviceRouteProvider.GetRouteByPathOrRegexPath(path, filterContext.Message.HttpMethod);
if (serviceRoute == null)
{
throw new CPlatformException($"未能找到路径为{path}-{filterContext.Message.HttpMethod}的路由信息", StatusCode.Http404EndpointStatusCode);
}
var httpMethods = serviceRoute.ServiceDescriptor.HttpMethod();
if (httpMethods != null && !httpMethods.Contains(filterContext.Context.Request.Method))
{
filterContext.Result = new HttpResultMessage<object>
{
IsSucceed = false,
StatusCode = Http405EndpointStatusCode,
Message = Http405EndpointDisplayName
};
}
}
}
/// <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(exception, "将接收到的消息反序列化成 TransportMessage<RemoteInvokeMessage> 时发送了错误。");
return;
}
var entry = _serviceEntryLocate.Locate(remoteInvokeMessage);
if (entry == null)
{
if (_logger.IsEnabled(LogLevel.Error))
{
_logger.LogError($"根据服务Id：{remoteInvokeMessage.ServiceId}，找不到服务条目。");
}
return;
}
if (remoteInvokeMessage.Attachments != null)
{
foreach (var attachment in remoteInvokeMessage.Attachments)
{
RpcContext.GetContext().SetAttachment(attachment.Key, attachment.Value);
}
}
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);
}
}
/// <summary>
/// 执行。
/// </summary>
/// <param name="sender">消息发送者。</param>
/// <param name="message">调用消息。</param>
public async Task ExecuteAsync(IMessageSender sender, TransportMessage message)
{
if (_logger.IsEnabled(LogLevel.Information))
{
_logger.Information("接收到消息。");
}
if (!message.IsInvokeMessage())
{
return;
}
RemoteInvokeMessage remoteInvokeMessage;
try
{
remoteInvokeMessage = _objecSerializer.Deserialize <object, RemoteInvokeMessage>(message.Content);
}
catch (Exception exception)
{
_logger.Error($"将接收到的消息反序列化成 TransportMessage<RemoteInvokeMessage> 时发送了错误。", exception);
return;
}
var entry = _serviceEntryLocate.Locate(remoteInvokeMessage);
if (entry == null)
{
if (_logger.IsEnabled(LogLevel.Error))
{
_logger.Error($"根据服务Id：{remoteInvokeMessage.ServiceId}，找不到服务条目。");
}
return;
}
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.Debug("准备执行本地逻辑。");
}
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();
if (taskType.IsGenericType)
{
resultMessage.Result = taskType.GetProperty("Result").GetValue(task);
}
}
}
catch (Exception exception)
{
if (_logger.IsEnabled(LogLevel.Error))
{
_logger.Error("执行本地逻辑时候发生了错误。", exception);
}
resultMessage.ExceptionMessage = GetExceptionMessage(exception);
}
try
{
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.Debug("准备发送响应消息。");
}
await sender.SendAsync(TransportMessage.CreateInvokeResultMessage(message.Id, resultMessage));
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.Debug("响应消息发送成功。");
}
}
catch (Exception exception)
{
if (_logger.IsEnabled(LogLevel.Error))
{
_logger.Error("发送响应消息时候发生了异常。", exception);
}
}
}
