private async Task <ConsumeEventResult> ConsumeMessageEvent(byte[] message, string type, IDictionary <string, object> headers)
{
var result = new ConsumeEventResult
{
Success = true
};
var context = new ConsumeContext
{
Bus = this,
Headers = headers,
};
Type typeObject = null;
#if NETSTANDARD1_6
typeObject = Type.GetType(type);
if (typeObject == null)
{
var assemblies = Microsoft.Extensions.DependencyModel.DependencyContext.Default.RuntimeLibraries;
foreach (var assembly in assemblies)
{
try
{
var asm = Assembly.Load(new AssemblyName(assembly.Name));
typeObject = asm.GetTypes().FirstOrDefault(t => t.FullName == type || t.AssemblyQualifiedName == type);
if (null != typeObject)
{
break;
}
}
catch (Exception)
{}
}
}
#else
typeObject = Type.GetType(type) ?? AppDomain.CurrentDomain.GetAssemblies().Select(a => a.GetType(type)).FirstOrDefault(t => t != null);
#endif
if (typeObject == null)
{
Logger.Warn(string.Format("Could not find type {0} when consuming message.", type));
return(result);
}
try
{
var envelope = new Envelope
{
Headers = headers,
Body = message
};
bool stop = ProcessFilters(Configuration.BeforeConsumingFilters, envelope);
if (stop)
{
return(result);
}
var tasks = new List <Task>();
if (headers.ContainsKey("MessageType") && Encoding.UTF8.GetString((byte[])headers["MessageType"]) == "ByteStream")
{
ProcessStream(envelope.Body, typeObject, headers);
}
else
{
tasks.Add(ProcessMessageHandlers(envelope.Body, typeObject, context));
tasks.Add(ProcessProcessManagerHandlers(envelope.Body, typeObject, context));
ProcessAggregatorHandlers(envelope.Body, typeObject);
ProcessRequestReplyConfigurations(envelope.Body, type, context);
}
await Task.WhenAll(tasks);
ProcessFilters(Configuration.AfterConsumingFilters, envelope);
if (headers.ContainsKey("RoutingSlip"))
{
ProcessRoutingSlip(envelope.Body, typeObject, headers);
}
}
catch (Exception ex)
{
if (Configuration.ExceptionHandler != null)
{
Configuration.ExceptionHandler(ex);
}
result.Success = false;
result.Exception = ex;
}
return(result);
}
private void ProcessMessage(BasicDeliverEventArgs args)
{
ConsumeEventResult result;
IDictionary <string, object> headers = args.BasicProperties.Headers;
try
{
SetHeader(args.BasicProperties.Headers, "TimeReceived", DateTime.UtcNow.ToString("O"));
SetHeader(args.BasicProperties.Headers, "DestinationMachine", Environment.MachineName);
SetHeader(args.BasicProperties.Headers, "DestinationAddress", _transportSettings.QueueName);
var typeName = Encoding.UTF8.GetString((byte[])(headers.ContainsKey("FullTypeName") ? headers["FullTypeName"] : headers["TypeName"]));
result = _consumerEventHandler(args.Body, typeName, headers);
SetHeader(args.BasicProperties.Headers, "TimeProcessed", DateTime.UtcNow.ToString("O"));
}
catch (Exception ex)
{
result = new ConsumeEventResult
{
Exception = ex,
Success = false
};
}
if (!result.Success)
{
int retryCount = 0;
if (args.BasicProperties.Headers.ContainsKey("RetryCount"))
{
retryCount = (int)args.BasicProperties.Headers["RetryCount"];
}
if (retryCount < _maxRetries)
{
retryCount++;
SetHeader(args.BasicProperties.Headers, "RetryCount", retryCount);
_model.BasicPublish(string.Empty, _retryQueueName, args.BasicProperties, args.Body);
}
else
{
if (result.Exception != null)
{
string jsonException = string.Empty;
try
{
jsonException = JsonConvert.SerializeObject(result.Exception);
}
catch (Exception ex)
{
Logger.Warn("Error serializing exception", ex);
}
SetHeader(args.BasicProperties.Headers, "Exception", JsonConvert.SerializeObject(new
{
TimeStamp = DateTime.Now,
ExceptionType = result.Exception.GetType().FullName,
Message = GetErrorMessage(result.Exception),
result.Exception.StackTrace,
result.Exception.Source,
Exception = jsonException
}));
}
Logger.ErrorFormat("Max number of retries exceeded. MessageId: {0}", args.BasicProperties.MessageId);
_model.BasicPublish(_errorExchange, string.Empty, args.BasicProperties, args.Body);
}
}
else if (!_errorsDisabled)
{
string messageType = null;
if (headers.ContainsKey("MessageType"))
{
messageType = Encoding.UTF8.GetString((byte[])headers["MessageType"]);
}
if (_transportSettings.AuditingEnabled && messageType != "ByteStream")
{
_model.BasicPublish(_auditExchange, string.Empty, args.BasicProperties, args.Body);
}
}
}
