public IActionResult ManaualProcess(Guid messageId, string topic)
{
var message = MessageSvc.LoadMessage(messageId, topic);
var msg = new TextMessage()
{
MessageText = message.MessageText
};
msg.putHeaders(BuiltinKeys.TraceId, messageId.ToString());
msg.putHeaders(BuiltinKeys.Topic, topic);
Stopwatch stopwatch = new Stopwatch();
IMonitor monitor = new SqlMonitor();
try
{
var processor = new RestApiProcessor();
stopwatch.Restart();
var result = (processor.Process(msg)).Result;
stopwatch.Stop();
MessageSuccessEventArgs args = new MessageSuccessEventArgs(msg, stopwatch.ElapsedMilliseconds);
monitor.onEvent(args);
return(Json(new { Success = true, Message = "处理成功！" }));
}
catch (Exception ex)
{
stopwatch.Stop();
MessageExceptionEventArgs args = new MessageExceptionEventArgs(msg, ex, stopwatch.ElapsedMilliseconds);
monitor.onEvent(args);
}
return(Json(new { Success = true, Message = "处理失败！" }));
}
private static string GetMessageExceptionInfo(MessageExceptionEventArgs e)
{
var errorInfo = string.Format(" Message: {0}\n Exception: {1}\n {2}",
e.Message, e.Exception.GetType().FullName, e.Exception.Message);
return(errorInfo);
}
private void Consumer_Received(object sender, BasicDeliverEventArgs e)
{
var body = e.Body;
var msgStr = Encoding.UTF8.GetString(body);
IMessage message = JsonConvert.DeserializeObject <TextMessage>(msgStr);
if (processor == null)
{
throw new MessageTransitException("Processor can not be null!");
}
try
{
stopwatch.Restart();
bool result = (processor.Process(message)).Result;
stopwatch.Stop();
if (result)
{
channel.BasicAck(e.DeliveryTag, false);
if (monitors != null && monitors.Count > 0)
{
MessageSuccessEventArgs args = new MessageSuccessEventArgs(message, stopwatch.ElapsedMilliseconds);
monitors.ForEach(m => m.onEvent(args));
}
}
else
{
channel.BasicReject(e.DeliveryTag, false);
if (monitors != null && monitors.Count > 0)
{
MessageExceptionEventArgs args = new MessageExceptionEventArgs(message, new Exception("Proccess Failed!"), stopwatch.ElapsedMilliseconds);
monitors.ForEach(m => m.onEvent(args));
}
}
}
catch (Exception ex)
{
stopwatch.Stop();
channel.BasicReject(e.DeliveryTag, false);
if (monitors != null && monitors.Count > 0)
{
MessageExceptionEventArgs args = new MessageExceptionEventArgs(message, ex, stopwatch.ElapsedMilliseconds);
monitors.ForEach(m => m.onEvent(args));
}
}
}
bool DoExecute(MessageResult ctx, IObserverHandler <IMessage> handler, AtomicInteger barrier)
{
var e = new MessageReceivingEventArgs(ctx, handler.Target);
try
{
ListnerManager.OnReceiving(e);
if (!e.Ignored)
{
ctx.results.Add(DelegateInvoker.Invoke <IMessage>(handler, ctx.Request.Sender, ctx.Request.ToMessage()));
}
return(true);
}
catch (Exception ex)
{
var re = new MessageExceptionEventArgs(ctx, ex);
ListnerManager.OnReceivingException(re);
ctx.InnerExceptions.Add(ex);
return(!re.Canceled);
}
finally
{
barrier--;
if (barrier == 0)
{
ListnerManager.OnReceived(new MessageEventArgs(ctx));
ListnerManager.OnSent(e);
OnCompleted(ctx);
}
else
{
ListnerManager.OnReceived(new MessageEventArgs(ctx));
}
e = null;
}
}
public void onEvent(MessageEventArgs e)
{
if (e is MessageSuccessEventArgs)
{
MessageSuccessEventArgs args = e as MessageSuccessEventArgs;
MessageSvc.UpdateMessageStatusToSuccess(Guid.Parse(args.message.Headers[BuiltinKeys.TraceId]), args.message.Headers[BuiltinKeys.Topic], args.milliseconds);
}
else if (e is MessageExceptionEventArgs)
{
MessageExceptionEventArgs args = e as MessageExceptionEventArgs;
MessageSvc.UpdateMessageStatusToFail(new ProcessFailRecord()
{
MessageId = Guid.Parse(args.message.Headers[BuiltinKeys.TraceId]),
Topic = args.message.Headers[BuiltinKeys.Topic],
FailRecord = args.ex.Message,
TimePeriod = args.milliseconds
});
#region 邮件通知
#endregion
}
}
private static void computationalNode_MessageHandlingException(object sender, MessageExceptionEventArgs e)
{
_logger.Warn("Message handling exception:\n" + GetMessageExceptionInfo(e));
}
private static void computationalNode_MessageSendingException(object sender, MessageExceptionEventArgs e)
{
_logger.Error("Message sending exception:\n" + GetMessageExceptionInfo(e));
}
static void computationalClient_MessageHandlingException(object sender, MessageExceptionEventArgs e)
{
Logger.Warn(e.Message + "\n" + e.Exception);
}
public void OnReceivingException(MessageExceptionEventArgs e)
{
ForEach(item => item.OnReceivingException(e));
}
bool DoExecute(MessageResult ctx, IObserverHandler<IMessage> handler, AtomicInteger barrier)
{
var e = new MessageReceivingEventArgs (ctx, handler.Target);
try
{
ListnerManager.OnReceiving(e);
if (!e.Ignored)
ctx.results.Add(DelegateInvoker.Invoke<IMessage>(handler, ctx.Request.Sender, ctx.Request.ToMessage()));
return true;
}
catch (Exception ex)
{
var re = new MessageExceptionEventArgs (ctx,ex);
ListnerManager.OnReceivingException(re);
ctx.InnerExceptions.Add(ex);
return !re.Canceled;
}
finally
{
barrier--;
if (barrier == 0)
{
ListnerManager.OnReceived(new MessageEventArgs(ctx));
ListnerManager.OnSent(e);
OnCompleted(ctx);
}
else
ListnerManager.OnReceived(new MessageEventArgs(ctx));
e = null;
}
}
public override void OnReceivingException(MessageExceptionEventArgs e)
{
}