public async Task <IApiResult <string> > Hello()
{
var(res, state) = await MessagePoster.CallApiAsync <string>("test2", "test");
FlowTracer.MonitorInfomation("hello");
return(ApiResultHelper.Helper.Succees($"hello1:{res.ResultData}"));
}
/// <summary>
/// 检查接口是否可执行
/// </summary>
/// <param name="action"></param>
/// <param name="message"></param>
/// <returns></returns>
public bool Check(IApiAction action, IInlineMessage message)
{
var user = GlobalContext.User;
//1 确定调用方法及对应权限
if (ZeroAppOption.Instance.IsOpenAccess || action.Option.HasFlag(ApiOption.Anymouse))
{
return(true);
}
if (!int.TryParse(user[ZeroTeamJwtClaim.Exp], out int last) || DateTime.Now.ToTimestamp() > last)
{
FlowTracer.MonitorInfomation(() => $"令牌已过期 => {new DateTime(1970, 1, 1).AddSeconds(last)}");
message.State = MessageState.Deny;
message.Result = ApiResultHelper.TokenTimeOutJson;
return(false);
}
//1 确定调用方法及对应权限
if (UserInfo.IsLoginUser(user))
{
return(true);
}
FlowTracer.MonitorInfomation("错误: 需要用户登录信息");
var status = DependencyHelper.GetService <IOperatorStatus>();
status.Code = OperatorStatusCode.BusinessException;
status.Message = "拒绝访问";
message.RealState = MessageState.Deny;
message.ResultData = status;
return(false);
}
/// <summary>
/// 数据发送结束
/// </summary>
async Task OnEnd()
{
using var _ = FlowTracer.DebugStepScope("[OnEnd]");
FlowTracer.MonitorInfomation($"[State] {Message.State} [Result] {Message.Result}");
Message.TraceInfo.End = DateTime.Now;
var array = middlewares.Where(p => p.Scope.HasFlag(MessageHandleScope.End)).ToArray();
if (array.Length == 0)
{
return;
}
foreach (var middleware in array.OrderByDescending(p => p.Level))
{
using var __ = FlowTracer.TraceStepScope(() => $"[{middleware.GetTypeName()}.OnEnd]");
try
{
await middleware.OnEnd(Message);
}
catch (Exception ex)
{
FlowTracer.MonitorError(() => $"[{middleware.GetTypeName()}.OnEnd] 发生异常.{ ex.Message}.");
logger.Exception(ex);
}
}
}
/// <summary>
/// 准备
/// </summary>
/// <param name="service">当前服务</param>
/// <param name="message">当前消息</param>
/// <param name="tag">扩展信息</param>
/// <param name="next">下一个处理方法</param>
/// <returns></returns>
async Task IMessageMiddleware.Handle(IService service, IInlineMessage message, object tag, Func <Task> next)
{
var serviceName = message.Service;
if (ToolsOption.Instance.ReverseProxyMap == null || !ToolsOption.Instance.ReverseProxyMap.TryGetValue(message.Service, out serviceName))
{
if (string.Equals(service.ServiceName, message.Service, StringComparison.OrdinalIgnoreCase))
{
message.State = MessageState.Unhandled;
message.ResultCreater = ApiResultHelper.State;
await next();
return;
}
}
FlowTracer.BeginStepMonitor($"[反向代理] {serviceName}/{message.Method}");
message.Service = serviceName;
try
{
message.ResultCreater ??= ApiResultHelper.State;
await MessagePoster.Post(message, true);
}
finally
{
FlowTracer.EndStepMonitor();
}
}
/// <summary>
/// 准备
/// </summary>
/// <param name="service">当前服务</param>
/// <param name="message">当前消息</param>
/// <param name="tag">扩展信息</param>
/// <returns></returns>
Task <bool> IMessageMiddleware.Prepare(IService service, IInlineMessage message, object tag)
{
if (!string.Equals(service.ServiceName, message.Service, StringComparison.OrdinalIgnoreCase))
{
return(Task.FromResult(true));
}
Service = service;
Message = message;
Tag = tag;
action = Service.GetApiAction(Message.Method);
//1 查找调用方法
if (action == null)
{
FlowTracer.MonitorDetails(() => $"错误: 接口({Message.Method})不存在");
Message.State = MessageState.Unhandled;
Message.ResultCreater = ApiResultHelper.State;
scope = MessageHandleScope.None;
}
else
{
FlowTracer.MonitorTrace($"[Action] {action.Info.ControllerName}.{action.Info.Name}");
}
return(Task.FromResult(true));
}
/// <summary>
/// 错误发生时处理
/// </summary>
/// <remarks>
/// 默认实现为保证OnCallEnd可控制且不再抛出异常,无特殊需要不应再次实现
/// </remarks>
private async Task OnMessageError(Exception ex)
{
logger.Exception(ex);
using var _ = FlowTracer.DebugStepScope("[OnMessageError]");
FlowTracer.MonitorError(() => $"发生未处理异常.[{Message.State}]{Message.Result}");
Message.RealState = MessageState.FrameworkError;
var array = middlewares.Where(p => p.Scope.HasFlag(MessageHandleScope.Exception)).ToArray();
if (array.Length == 0)
{
return;
}
foreach (var middleware in array)
{
using var __ = FlowTracer.TraceStepScope(() => $"[{middleware.GetTypeName()}.OnGlobalException]");
try
{
await middleware.OnGlobalException(Service, Message, ex, Original);
}
catch (Exception e)
{
FlowTracer.MonitorError(() => $"[{middleware.GetTypeName()}.OnGlobalException] 发生异常.{ ex.Message}.");
logger.Exception(e);
}
}
}
/// <summary>
/// 访问外部
/// </summary>
/// <param name="service">服务名称，用于查找HttpClient，不会与api拼接</param>
/// <param name="api">完整的接口名称</param>
/// <param name="forms">Form内容</param>
/// <returns></returns>
public static async Task <(MessageState state, string res)> OutFormPost(string service, string api, Dictionary <string, string> forms)
{
using var _ = FlowTracer.DebugStepScope("[HttpPoster.OutFormPost]");
try
{
var client = HttpClientOption.HttpClientFactory.CreateClient(service);
FlowTracer.MonitorDetails(() => $"URL : {client.BaseAddress}{api}");
using var form = new FormUrlEncodedContent(forms);
using var response = await client.PostAsync(api, form);
var json = await response.Content.ReadAsStringAsync();
MessageState state = HttpCodeToMessageState(response.StatusCode);
FlowTracer.MonitorDetails(() => $"HttpStatus : {response.StatusCode} MessageState : {state} Result : {json}");
return(state, json);
}
catch (HttpRequestException ex)
{
FlowTracer.MonitorError(() => $"发生异常.{ex.Message}");
return(MessageState.Unsend, null);
}
catch (Exception ex)
{
FlowTracer.MonitorError(() => $"发生异常.{ex.Message}");
return(MessageState.NetworkError, null);
}
}
async Task IHostedService.StartAsync(CancellationToken cancellationToken)
{
while (!cancellationToken.IsCancellationRequested)
{
FlowTracer.BeginMonitor("OrderEvent");
await MessagePoster.PublishAsync("OrderEvent", "offline/v1/new", new UnionOrder
{
Items = new List <UnionOrderItem>
{
new UnionOrderItem
{
ItemType = SkuType.GeneralProduct,
SkuName = "女鞋E思Q",
SalePrice = 50,
Number = 3,
Amount = 500,
Pay = 100,
BaseSkuSid = 878465627947009L
}
},
Amount = 500,
Pay = 500
});
_logger.TraceMonitor(FlowTracer.EndMonitor());
await Task.Delay(1000);
}
}
/// <summary>
/// 结果处理
/// </summary>
/// <param name="message">当前消息</param>
/// <returns></returns>
async Task IMessageMiddleware.OnEnd(IInlineMessage message)
{
var root = FlowTracer.EndMonitor();
if (root != null)
{
ScopeRuner.ScopeLogger.TraceMonitor(root);
}
if (ToolsOption.Instance.EnableMarkPoint && (message.Service != ToolsOption.Instance.MarkPointName || message.Method != "post"))
{
await MessagePoster.PublishAsync(ToolsOption.Instance.MarkPointName, "post", new TraceLinkMessage
{
Monitor = root,
Trace = GlobalContext.CurrentNoLazy?.TraceInfo,
Message = new MessageItem
{
ID = message.ID,
State = message.State,
Service = message.Service,
Method = message.Method,
Argument = message.Argument,
Result = message.Result,
User = GlobalContext.User?.ToDictionary(),
Context = GlobalContext.CurrentNoLazy?.ToDictionary()
}
});
}
}
/// <summary>
/// 处理
/// </summary>
/// <returns></returns>
async Task Handle()
{
Message.RealState = MessageState.Processing;
//参数处理
if (!ArgumentPrepare(action))
{
return;
}
Message.ResultSerializer = action.ResultSerializer;
Message.ResultCreater = action.ResultCreater;
//扩展检查
var checkers = DependencyHelper.GetServices <IApiActionChecker>();
foreach (var checker in checkers)
{
if (!checker.Check(action, Message))
{
return;
}
}
GlobalContext.Current.RequestTask = new ActionTask();
GlobalContext.Current.ActionTask = new TaskCompletionSource <bool>();
try
{
action.Execute(Message, Service.Serialize);
var(state, result) = await GlobalContext.Current.RequestTask.Task;
Message.State = state;
Message.ResultData = result;
}
//catch (TaskCanceledException)
//{
// Message.State = MessageState.Cancel;
// var status = DependencyHelper.GetService<IOperatorStatus>();
// status.Code = OperatorStatusCode.TimeOut;
// status.Message = "操作被取消";
// Message.ResultData = status;
//}
catch (FormatException fe)
{
FlowTracer.MonitorError(() => $"参数转换出错误, 请检查调用参数是否合适:{fe.Message}");
Message.RealState = MessageState.FormalError;
var status = DependencyHelper.GetService <IOperatorStatus>();
status.Code = OperatorStatusCode.ArgumentError;
status.Message = "参数转换出错误, 请检查调用参数是否合适";
Message.ResultData = status;
}
catch (MessageArgumentNullException b)
{
var msg = $"参数{b.ParamName}不能为空";
FlowTracer.MonitorDetails(msg);
Message.RealState = MessageState.FormalError;
var status = DependencyHelper.GetService <IOperatorStatus>();
status.Code = OperatorStatusCode.ArgumentError;
status.Message = msg;
Message.ResultData = status;
}
}
/// <summary>
/// 准备处理
/// </summary>
/// <returns>是否需要正式处理</returns>
private async Task <bool> Prepare()
{
try
{
Message.CheckRequestTraceInfo();
Message.ResetToRequest();
GlobalContext.Reset(Message);
if (IsOffline)
{
Message.DataState = MessageDataState.ArgumentOffline;
}
}
catch (Exception ex)
{
await OnMessageError(ex);
return(false);
}
using var _ = FlowTracer.DebugStepScope("[Prepare]");
FlowTracer.MonitorTrace(() => $"[Context] {Message.Context?.ToInnerString()}");
FlowTracer.MonitorTrace(() => $"[User] {Message.User?.ToInnerString()}");
FlowTracer.MonitorTrace(() => $"[TraceInfo] {Message.TraceInfo?.ToInnerString()}");
FlowTracer.MonitorInfomation(() => $"[Argument] {Message.Argument ?? Message.ArgumentData?.ToInnerString()}");
var array = middlewares.Where(p => p.Scope.HasFlag(MessageHandleScope.Prepare)).ToArray();
foreach (var middleware in array)
{
FlowTracer.BeginTraceStepMonitor(middleware.GetTypeName());
try
{
FlowTracer.MonitorTrace(() => $"[Prepare>{middleware.GetTypeName()}.Prepare]");
if (!await middleware.Prepare(Service, Message, Original))
{
return(false);
}
}
catch (Exception ex)
{
FlowTracer.MonitorError(() => $"[Prepare>{middleware.GetTypeName()}.Prepare] 发生异常.{ ex.Message}.");
await OnMessageError(ex);
return(false);
}
finally
{
FlowTracer.EndDebugStepMonitor();
}
}
if (GlobalContext.CurrentNoLazy == null)
{
GlobalContext.Current.Message = Message;
}
return(true);
}
/// <summary>
/// 异常处理
/// </summary>
/// <param name="service">当前服务</param>
/// <param name="message">当前消息</param>
/// <param name="exception"></param>
/// <param name="tag">扩展信息</param>
/// <returns></returns>
Task IMessageMiddleware.OnGlobalException(IService service, IInlineMessage message, Exception exception, object tag)
{
DependencyScope.Logger.Exception(exception);
FlowTracer.MonitorInfomation(() => $"发生未处理异常.{exception.Message}");
CheckException(message, exception);
return(Task.CompletedTask);
}
/// <summary>
/// 中间件链式处理
/// </summary>
/// <returns></returns>
private async Task DoHandle()
{
using var _ = FlowTracer.DebugStepScope("[DoHandle]");
try
{
await Handle();
}
catch (Exception ex)
{
FlowTracer.MonitorError(() => $"[DoHandle] 发生异常.{ ex.Message}.");
await OnMessageError(ex);
}
}
private async Task Process()
{
await Task.Yield();
var name = $"{Message.Service}/{Message.Method}({Message.ID})";
logger = DependencyHelper.LoggerFactory.CreateLogger(name);
FlowTracer.BeginMonitor(name);
middlewares = DependencyHelper.ServiceProvider.GetServices <IMessageMiddleware>().Where(p => p.Scope > MessageHandleScope.None).OrderBy(p => p.Level).ToArray();
try
{
//BUG:Prepare处理需要检查
if (await Prepare() && Message.State <= MessageState.Processing)
{
index = 0;
await DoHandle();
}
}
catch (Exception ex)
{
logger.Exception(ex);
}
await Write();
try
{
WaitTask?.TrySetResult(true);
}
catch (Exception ex)
{
logger.Error($"[WaitTask:\n{ex}");
}
try
{
var actionTask = GlobalContext.Current?.ActionTask;
if (actionTask != null)
{
await actionTask.Task;
}
}
catch (Exception ex)
{
logger.Error($"[ActionTask]:\n{ex}");
}
await OnEnd();
ZeroAppOption.Instance.EndRequest();
}
/// <summary>
/// 中间件链式处理
/// </summary>
/// <returns></returns>
private async Task Handle()
{
while (index < middlewares.Length)
{
var next = middlewares[index++];
if (!next.Scope.HasFlag(MessageHandleScope.Handle))
{
continue;
}
using var _ = FlowTracer.TraceStepScope(next.GetTypeName());
await next.Handle(Service, Message, Original, Handle);
return;
}
}
/// <summary>
/// 准备
/// </summary>
/// <param name="service">当前服务</param>
/// <param name="message">当前消息</param>
/// <param name="tag">扩展信息</param>
/// <returns></returns>
Task <bool> IMessageMiddleware.Prepare(IService service, IInlineMessage message, object tag)
{
try
{
if (!CheckToken(message, GlobalContext.Current))
{
return(Task.FromResult(false));
}
}
catch (Exception ex)
{
FlowTracer.MonitorInfomation(() => $"令牌还原失败 => {message.TraceInfo.Token}\n{ex}");
return(Task.FromResult(false));
}
FlowTracer.MonitorDetails(() => $"User => {GlobalContext.User?.ToJson()}");
return(Task.FromResult(true));
}
/// <summary>
/// 生产消息
/// </summary>
/// <param name="message">消息</param>
/// <returns></returns>
async Task <IMessageResult> IMessagePoster.Post(IInlineMessage message)
{
if (!ZeroAppOption.Instance.IsAlive)
{
message.State = MessageState.Cancel;
return(null);
}
message.Offline();
message.RealState = MessageState.AsyncQueue;
if (AsyncPost)
{
var item = new TQueueItem
{
ID = message.ID,
Topic = message.Service,
Time = DateTime.Now,
Message = message
};
queues.Enqueue(item);
semaphore.Release();
FlowTracer.MonitorDetails(() => $"[异步消息投递] {item.ID} 消息已投入发送队列,将在后台静默发送直到成功");
return(new MessageResult
{
ID = message.ID,
State = MessageState.AsyncQueue
});
}
try
{
return(await PostMessage(new TQueueItem
{
ID = message.ID,
Topic = message.Service,
Time = DateTime.Now,
Message = message
}));
}
finally
{
ZeroAppOption.Instance.EndRequest();
}
}
/// <summary>
/// 参数校验
/// </summary>
/// <param name="action"></param>
/// <returns></returns>
private bool ArgumentPrepare(IApiAction action)
{
try
{
action.RestoreArgument(Message);
}
catch (Exception ex)
{
var msg = $"错误 : 还原参数异常{ex.Message}";
FlowTracer.MonitorInfomation(msg);
var status = DependencyHelper.GetService <IOperatorStatus>();
status.Code = OperatorStatusCode.BusinessException;
status.Message = msg;
Message.ResultData = status;
Message.RealState = MessageState.FormalError;
return(false);
}
try
{
if (action.ValidateArgument(Message, out var status))
{
return(true);
}
var msg = $"参数校验失败 : {status.Message}";
FlowTracer.MonitorInfomation(msg);
Message.ResultData = status;
Message.Result = SmartSerializer.ToInnerString(status);
Message.RealState = MessageState.FormalError;
return(false);
}
catch (Exception ex)
{
var msg = $"错误 : 参数校验异常{ex.Message}";
FlowTracer.MonitorInfomation(msg);
var status = DependencyHelper.GetService <IOperatorStatus>();
status.Code = OperatorStatusCode.ArgumentError;
status.Message = msg;
Message.ResultData = status;
Message.RealState = MessageState.FormalError;
return(false);
}
}
/// <summary>
/// 结果推到调用处
/// </summary>
private async Task Write()
{
if (Original == null || Message.State == MessageState.NoUs)
{
return;
}
using var _ = FlowTracer.DebugStepScope("[Write]");
//Message.Trace ??= GlobalContext.CurrentNoLazy?.Trace;
if (Message.TraceInfo != null)
{
Message.TraceInfo.End = DateTime.Now;
}
try
{
Message.OfflineResult();
}
catch (Exception ex)
{
await OnMessageError(ex);
}
try
{
if (Original is IMessageWriter writer)
{
FlowTracer.MonitorDetails(() => $"[Write>{writer}.OnResult] 写入返回值");
await writer.OnResult(Message, null);
}
else
{
FlowTracer.MonitorDetails(() => $"[Write>{Service.Receiver.GetTypeName()}.OnResult] 写入返回值");
await Service.Receiver.OnResult(Message, Original);
}
}
catch (Exception ex)
{
FlowTracer.MonitorError(() => $"[Write>{Service.Receiver.GetTypeName()}.OnResult] 发生异常.{ ex.Message}.");
logger.Exception(ex);
}
}
private static bool CheckToken(IInlineMessage message, IZeroContext context)
{
if (message.TraceInfo.Token.IsBlank() || !message.IsOutAccess)
{
return(true);
}
var resolver = DependencyHelper.GetService <ITokenResolver>();
if (resolver == null)
{
return(true);
}
context.User = resolver.TokenToUser(message.TraceInfo.Token);
if (context.User[ZeroTeamJwtClaim.Iss] != ToolsOption.Instance.JwtIssue)
{
FlowTracer.MonitorInfomation(() => $"非法令牌颁发机构 => {context.User[ZeroTeamJwtClaim.Iss]}");
message.State = MessageState.Deny;
message.Result = ApiResultHelper.DenyAccessJson;
return(false);
}
return(true);
}
/// <summary>
/// 访问外部
/// </summary>
/// <param name="service">服务名称，用于查找HttpClient，不会与api拼接</param>
/// <param name="api">完整的接口名称</param>
/// <param name="argument">内容</param>
/// <returns></returns>
public static async Task <(MessageState state, string res)> OutPost(string service, string api, string argument)
{
using var _ = FlowTracer.DebugStepScope("[HttpPoster.CallOut]");
HttpStatusCode httpStatusCode;
StringContent content = null;
try
{
var client = HttpClientOption.HttpClientFactory.CreateClient(service);
FlowTracer.MonitorDetails(() => $"URL : {client.BaseAddress}{api}");
string json;
content = new StringContent(argument ?? "");
using var response = await client.PostAsync(api, content);
httpStatusCode = response.StatusCode;
json = await response.Content.ReadAsStringAsync();
var state = HttpCodeToMessageState(httpStatusCode);
FlowTracer.MonitorDetails(() => $"HttpStatus : {httpStatusCode} MessageState : {state} Result : {json}");
return(state, json);
}
catch (HttpRequestException ex)
{
FlowTracer.MonitorError(() => $"发生异常.{ex.Message}");
return(MessageState.Unsend, null);
}
catch (Exception ex)
{
FlowTracer.MonitorError(() => $"发生异常.{ex.Message}");
return(MessageState.NetworkError, null);
}
finally
{
content?.Dispose();
}
}
/// <summary>
/// 标明调用结束
/// </summary>
/// <returns>是否发送成功</returns>
internal Task <bool> WriteResult(IInlineMessage message)
{
if (Session == null || Session.IsDisposed)
{
return(Task.FromResult(true));
}
if (!TcpOption.Instance.IsType(message.Service))
{
return(Task.FromResult(true));
}
try
{
Session.Server.UpdateSession(Session); //防止超时
var pipeStream = Session.Stream.ToPipeStream();
var json = SmartSerializer.ToInnerString(message.ToMessageResult(true));
var len = pipeStream.WriteLine(json);
Session.Stream.Flush();
}
catch (Exception ex)
{
FlowTracer.MonitorError(() => ex.ToString());
}
return(Task.FromResult(true));
}
/// <summary>
/// 生产消息
/// </summary>
/// <param name="message">消息</param>
/// <returns></returns>
async Task <IMessageResult> IMessagePoster.Post(IInlineMessage message)
{
if (!HttpClientOption.ServiceMap.TryGetValue(message.Service, out var name))
{
name = HttpClientOption.DefaultName;
}
using var _ = FlowTracer.DebugStepScope("[HttpPoster.Post]");
StringContent content = null;
try
{
ZeroAppOption.Instance.BeginRequest();
message.ArgumentOffline();
var client = HttpClientOption.HttpClientFactory.CreateClient(name);
if (client.BaseAddress == null)
{
client.BaseAddress = new Uri(HttpClientOption.Instance.DefaultUrl);
client.Timeout = TimeSpan.FromSeconds(HttpClientOption.Instance.DefaultTimeOut);
FlowTracer.MonitorError(() => $"[{message.Service}/{message.Method}]服务未注册,使用默认地址：{HttpClientOption.Instance.DefaultUrl}");
//message.State = MessageState.Unhandled;
//return null;//直接使用状态
}
var uri = new Uri($"{client.BaseAddress }{message.Service}/{message.Method}");
FlowTracer.MonitorDetails(() =>
{
return($"URL : {uri.OriginalString}");
});
using var requestMessage = new HttpRequestMessage
{
RequestUri = uri,
Method = HttpMethod.Post
};
if (message.Argument.IsNotBlank())
{
requestMessage.Content = content = new StringContent(message.Argument);
}
requestMessage.Headers.Add("x-zmvc-ver", "v2");
requestMessage.Headers.Add("x-zmvc-id", message.ID);
if (message.TraceInfo != null)
{
requestMessage.Headers.Add("x-zmvc-trace", message.TraceInfo.ToInnerString());
}
if (message.User != null)
{
requestMessage.Headers.Add("x-zmvc-user", message.User.ToInnerString());
}
if (message.Context != null)
{
requestMessage.Headers.Add("x-zmvc-ctx", message.Context.ToInnerString());
}
using var response = await client.SendAsync(requestMessage);
if (response.Headers.TryGetValues("x-zmvc-state", out var state))
{
message.State = Enum.Parse <MessageState>(state.First());
}
else
{
message.State = MessageState.NetworkError;
}
message.Result = await response.Content.ReadAsStringAsync();
if (response.StatusCode == HttpStatusCode.NotFound ||
response.StatusCode == HttpStatusCode.ServiceUnavailable ||
response.StatusCode == HttpStatusCode.BadGateway)
{
message.State = HttpCodeToMessageState(response.StatusCode);
message.Result = null;
}
if (string.IsNullOrEmpty(message.Result))
{
message.OfflineResult();
}
message.DataState |= MessageDataState.ResultOffline;
FlowTracer.MonitorDetails(() => $"StatusCode : {response.StatusCode} | State : {message.State} | Result : {message.Result}");
}
catch (HttpRequestException ex)
{
FlowTracer.MonitorError(() => $"发生异常.{ex.Message}");
message.State = MessageState.Unsend;
}
catch (Exception ex)
{
FlowTracer.MonitorError(() => $"发生异常.{ex.Message}");
message.State = MessageState.NetworkError;
}
finally
{
ZeroAppOption.Instance.EndRequest();
content?.Dispose();
}
return(null);//直接使用状态
}
/// <summary>
/// 投递消息
/// </summary>
/// <param name="message">消息</param>
/// <param name="defPoster">服务未注册时，是否使用缺省投递器</param>
/// <param name="autoOffline">是否自动离线</param>
/// <returns>返回值,如果未进行离线交换message返回为空,此时请检查state</returns>
public static async Task <IInlineMessage> Post(IMessageItem message, bool autoOffline = true, bool defPoster = true)
{
if (message == null || string.IsNullOrEmpty(message.Service) || string.IsNullOrEmpty(message.Method))
{
FlowTracer.MonitorError($"参数错误：Service:{message?.Service} Method:{message?.Method}");
throw new ArgumentException("参数[message]不能为空且[message.Topic]与[message.Title]必须为有效值");
}
using var scope = FlowTracer.DebugStepScope(() => $"[MessagePoster] {message.Service}/{message.Method}");
if (!ZeroAppOption.Instance.CanRun)
{
FlowTracer.MonitorError($"系统未运行,当前状态为：{ZeroAppOption.Instance.ApplicationState}");
if (message is IInlineMessage inlineMessage)
{
message.State = MessageState.Cancel;
return(inlineMessage);
}
else
{
return(new InlineMessage
{
ID = message.ID,
State = MessageState.Cancel,
Service = message.Service,
Method = message.Method,
Result = message.Result,
Argument = message.Argument,
TraceInfo = message.TraceInfo
});
}
}
var producer = MessagePostOption.Instance.GetService(message.Service, defPoster);
if (producer == null)
{
FlowTracer.MonitorError($"服务({message.Service})不存在");
if (message is IInlineMessage inlineMessage)
{
message.State = MessageState.Unhandled;
return(inlineMessage);
}
else
{
return(new InlineMessage
{
ID = message.ID,
State = MessageState.Unhandled,
Service = message.Service,
Method = message.Method,
Result = message.Result,
Argument = message.Argument,
TraceInfo = message.TraceInfo
});
}
}
FlowTracer.MonitorDetails(() => $"[Poster] {producer.GetTypeName()}");
var inline = CheckMessage(producer, message);
try
{
FlowTracer.MonitorTrace(() => $"[Context] {message.Context?.ToInnerString()}");
FlowTracer.MonitorTrace(() => $"[User] {message.User?.ToInnerString()}");
FlowTracer.MonitorTrace(() => $"[TraceInfo] {message.TraceInfo?.ToInnerString()}");
FlowTracer.MonitorDetails(() => $"[Argument] {inline.Argument ?? inline.ArgumentData?.ToInnerString()}");
var msg = await producer.Post(inline);
if (msg != null)
{
inline.CopyResult(msg);
}
if (autoOffline)
{
inline.OfflineResult();
}
FlowTracer.MonitorDetails(() => $"[State] {inline.State} [Result] {inline.Result ?? inline.ResultData?.ToJson() ?? "无返回值"}");
return(inline);
}
catch (MessagePostException ex)
{
logger.Exception(ex);
inline.State = MessageState.NetworkError;
return(inline);
}
catch (Exception ex)
{
logger.Exception(ex);
inline.State = MessageState.FrameworkError;
return(inline);
}
finally
{
}
}
/// <summary>
/// 调用检查
/// </summary>
/// <param name="context"></param>
public async Task <(bool success, IInlineMessage message)> CheckRequest(HttpContext context)
{
HttpContext = context;
var request = context.Request;
//ITokenResolver
if (!TryGetHeader(request, "x-zmvc-ver", out var ver))
{
Message = new HttpMessage
{
IsOutAccess = true,
HttpContext = context,
Uri = request.Path.Value,
HttpMethod = request.Method.ToUpper(),
ID = Guid.NewGuid().ToString("N").ToUpper()
};
if (!CheckApiRoute())
{
return(false, null);
}
CheckTrace();
await Prepare();
return(true, Message);
}
var content = await ReadContent();
FlowTracer.MonitorDebug(content);
if (ver != "v2")
{
var message = SmartSerializer.FromInnerString <InlineMessage>(content);
message.DataState = MessageDataState.ArgumentOffline;
return(true, message);
}
Message = new HttpMessage
{
ID = GetHeader(context.Request, "x-zmvc-id"),
HttpContext = context,
Uri = request.Path.Value,
HttpMethod = request.Method.ToUpper(),
Argument = content,
HttpContent = content,
ExtensionDictionary = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase),
DataState = MessageDataState.ArgumentOffline
};
if (!CheckApiRoute())
{
return(false, null);
}
if (TryGetHeader(context.Request, "x-zmvc-trace", out var trace))
{
Message.TraceInfo = SmartSerializer.ToObject <TraceInfo>(trace);
}
if (TryGetHeader(context.Request, "x-zmvc-user", out var user))
{
Message.User = SmartSerializer.ToObject <Dictionary <string, string> >(user);
}
if (TryGetHeader(context.Request, "x-zmvc-ctx", out var ctx))
{
Message.Context = SmartSerializer.ToObject <Dictionary <string, string> >(ctx);
}
return(true, Message);
}
