static void TheCallback(IReceiverLink link, Message message)
{
//Interlocked.Increment(ref ReceivedMessages);
//Console.WriteLine((Point)message.Body);
link.Accept(message);
}
static void TheCallback(IReceiverLink link, Message message)
{
Interlocked.Increment(ref ReceivedMessages);
try
{
var settings = new JsonSerializerSettings();
settings.TypeNameHandling = TypeNameHandling.Auto;
settings.MetadataPropertyHandling = MetadataPropertyHandling.Ignore;
settings.DateParseHandling = DateParseHandling.None;
var point = JsonConvert.DeserializeObject <Point>(message.Body.ToString(), settings);
if (point.X > 99900)
{
sw1.Stop();
Console.WriteLine(sw1.Elapsed);
}
}
catch (Exception err)
{
Console.WriteLine(err.Message);
}
Console.WriteLine(message.Body.ToString());
link.Accept(message);
}
private void OnMessageReceived(IReceiverLink receiver, Message message)
{
List <CFXEnvelope> envelopes = null;
try
{
envelopes = AmqpUtilities.EnvelopesFromMessage(message);
}
catch (Exception ex)
{
envelopes = null;
AppLog.Error(ex);
}
if (envelopes != null && OnCFXMessageReceived != null)
{
try
{
receiver.Accept(message);
envelopes.ForEach(env => OnCFXMessageReceived(new AmqpChannelAddress()
{
Uri = NetworkUri, Address = receiver.Name
}, env));
}
catch (Exception ex)
{
AppLog.Error(ex);
}
}
}
protected virtual async void OnMessageCallback(IReceiverLink receiver, Message message)
{
try {
// Get the body
var rawBody = message.Body as string;
var typeString = message.ApplicationProperties[MESSAGE_TYPE_KEY] as string;
var dataType = EventTypeLookup[typeString];
var handlerType = typeof(IDomainEventHandler <>).MakeGenericType(dataType);
var data = JsonConvert.DeserializeObject(rawBody, dataType);
var handler = Provider.GetService(handlerType);
if (handler != null)
{
//TODO: Update the way "Handle" is retrieved in a type safe way.
var method = handlerType.GetTypeInfo().GetDeclaredMethod("Handle");
await(Task) method.Invoke(handler, new object[] { data });
receiver.Accept(message);
}
else
{
var desc = $"Handler not found for {typeString}";
Logger.LogWarning(desc);
receiver.Reject(message);
}
} catch (Exception ex) {
Logger.LogError(101, ex, ex.Message);
receiver.Reject(message);
}
}
public void TestMethod_InterfaceSendReceive()
{
string testName = "InterfaceSendReceive";
const int nMsgs = 200;
IConnection connection = new Connection(testTarget.Address);
ISession session = connection.CreateSession();
ISenderLink sender = session.CreateSender("sender-" + testName, testTarget.Path);
for (int i = 0; i < nMsgs; ++i)
{
Message message = new Message("msg" + i);
message.Properties = new Properties()
{
GroupId = "abcdefg"
};
message.ApplicationProperties = new ApplicationProperties();
message.ApplicationProperties["sn"] = i;
sender.Send(message, null, null);
}
IReceiverLink receiver = session.CreateReceiver("receiver-" + testName, testTarget.Path);
for (int i = 0; i < nMsgs; ++i)
{
Message message = receiver.Receive();
Trace.WriteLine(TraceLevel.Verbose, "receive: {0}", message.ApplicationProperties["sn"]);
receiver.Accept(message);
}
connection.Close();
}
private static void OnMessageReceived(IReceiverLink receiver, Message message)
{
// Ack that we got the message.
receiver.Accept(message);
// Ignore messages that don't have a body
if (message.Body == null)
{
return;
}
// Ignore messages that are not a serialized FiniteDto
var dtoName = JsonDtoSerializer.GetDtoName(message.Body.ToString());
if (string.IsNullOrWhiteSpace(dtoName))
{
return;
}
// TODO: recode this to not be a switch (instead a map)
switch (dtoName)
{
case "DescriptiveTextDto":
var dto = JsonDtoSerializer.DeserializeAs <DescriptiveTextDto>(message.Body.ToString());
Windows.WriteMainWindowDescriptiveText($"\r\n{dto.Text}");
break;
}
}
private static void ProcessMessage(IReceiverLink receiver, Message message)
{
var msg = Encoding.UTF8.GetString((byte[])message.Body);
_receivedMessages.Add(msg);
receiver.Accept(message);
}
private void OnMessage(IReceiverLink receiverLink, Message message)
{
try
{
var ret = false;
try
{
ret = _MessageReceiver(message);
}
catch (Exception e)
{
Logger.Error("Exception in onMessageReceived!", e);
}
if (ret)
{
Logger.Debug("Message has been accepted.");
receiverLink?.Accept(message);
}
}
catch (Exception ex)
{
Logger.Error(ex.Message);
}
}
private void OnMessageReceived(IReceiverLink receiver, Message message)
{
List <CFXEnvelope> envelopes = null;
try
{
envelopes = AmqpUtilities.EnvelopesFromMessage(message);
}
catch (Exception ex)
{
envelopes = null;
AppLog.Error(ex);
}
if (envelopes == null || (envelopes != null && envelopes.Count < 1))
{
try
{
receiver.Accept(message);
AppLog.Error(string.Format("Malformed Message Received: {0}", AmqpUtilities.MessagePreview(message)));
Endpoint?.Channel_OnMalformedMessageReceived(new AmqpChannelAddress()
{
Uri = NetworkUri, Address = receiver.Name
}, AmqpUtilities.StringFromEnvelopes(message));
}
catch (Exception ex)
{
AppLog.Error(ex);
}
}
else if (envelopes != null && OnCFXMessageReceived != null)
{
try
{
receiver.Accept(message);
envelopes.ForEach(env => OnCFXMessageReceived(new AmqpChannelAddress()
{
Uri = NetworkUri, Address = receiver.Name
}, env));
}
catch (Exception ex)
{
AppLog.Error(ex);
}
}
}
// Método que será chamado toda vez que uma mensagem for recebida.
private static void OnMessageCallback(IReceiverLink receiver, Message message)
{
try
{
/*
* var serializer = new AmqpSerializer(new ContractResolver()
* {
* PrefixList = new[] { "Receiver" }
* });
*
* Cliente cliente = message.GetBody<Cliente>(serializer);
* Console.WriteLine("Received {0}", cliente);
* receiver.Accept(message);
*/
// Lendo a propriedade customizada
var messageType = message.ApplicationProperties["Message.Type.FullName"];
// Variável para salvar o corpo da mensagem
string body = string.Empty;
// Pega o corpo
var rawBody = message.Body;
// Se o corpo é byte [] assume que foi enviado como uma BrokeredMessage
// desserialize-o usando um XmlDictionaryReader
if (rawBody is byte[])
{
using (var reader = XmlDictionaryReader.CreateBinaryReader(
new MemoryStream(rawBody as byte[]),
null,
XmlDictionaryReaderQuotas.Max))
{
var doc = new XmlDocument();
doc.Load(reader);
body = doc.InnerText;
}
}
else // Se o corpo for uma string
{
body = rawBody.ToString();
}
// Escrevendo o corpo no console
Console.WriteLine(body);
// Aceitando a mensagem
receiver.Accept(message);
}
catch (Exception ex)
{
receiver.Reject(message);
Console.WriteLine(ex);
}
}
public void OnMessage(IReceiverLink link, Message message)
{
ConnectionManager.WriteLine($"Called, and using the message: {message.Body}");
ConnectionManager.WriteLine($"Accepting message number ..please wait");
var content = message.Body;
var bytes = (byte[])content;
File.WriteAllBytes($@"C:\Temp\ELNOutput\{message.ApplicationProperties["CamelFileName"]}", bytes);
link.Accept(message);
}
private void OnMessageCallback(IReceiverLink receiver, Message message)
{
try
{
//var messageType = message.ApplicationProperties["Message.Type.FullName"];
this.cliente = message.GetBody <Cliente>(serializer);
Console.WriteLine("Received {0}", this.cliente);
receiver.Accept(message);
}
catch (Exception ex)
{
receiver.Reject(message);
Console.WriteLine(ex);
}
}
static private void OnMessage(IReceiverLink receiveLink, Message message)
{
Data data = (Data)message.BodySection;
Console.WriteLine(UTF8Encoding.UTF8.GetString(data.Binary));
if (message.ApplicationProperties != null)
{
foreach (var property in message.ApplicationProperties.Map)
{
Console.WriteLine($" Key:{property.Key} Value:{property.Value}");
}
}
receiveLink.Accept(message);
}
public void EurexMessageCallback(IReceiverLink receiver, Message message)
{
Log.DebugFormat("EurexMessageCallback");
if (message == null)
{
Log.WarnFormat("receiver.Receive(600000) is timeout.");
return;
}
Amqp.Framing.Data payload = (Amqp.Framing.Data)message.BodySection;
String payloadText = Encoding.UTF8.GetString(payload.Binary);
Log.DebugFormat("Received message: {0}", payloadText);
receiver.Accept(message);
}
private void processResponse(IReceiverLink receiver, Message message)
{
receiver.Accept(message);
if (!this._pendingRequests.TryRemove(message.Properties.CorrelationId, out var tcs))
{
Console.WriteLine($"No pending response for {message.Properties.CorrelationId}");
}
if (!this._isTimedout)
{
var response = message.GetBody <AmqpRpcResponse>();
if (tcs != null)
{
tcs.SetResult(response);
}
}
}
/// <summary>
/// Method that will be called every time a message is received.
/// </summary>
static void OnMessageCallback(IReceiverLink receiver, Amqp.Message message)
{
try
{
// You can read the custom property
var messageType = message.ApplicationProperties["Message.Type.FullName"];
// Variable to save the body of the message.
string body = string.Empty;
// Get the body
var rawBody = message.Body;
// If the body is byte[] assume it was sent as a BrokeredMessage
// and deserialize it using a XmlDictionaryReader
if (rawBody is byte[])
{
using (var reader = XmlDictionaryReader.CreateBinaryReader(
new MemoryStream(rawBody as byte[]),
null,
XmlDictionaryReaderQuotas.Max))
{
var doc = new XmlDocument();
doc.Load(reader);
body = doc.InnerText;
}
}
else // Asume the body is a string
{
body = rawBody.ToString();
}
// Write the body to the Console.
Console.WriteLine(body);
// Accept the messsage.
receiver.Accept(message);
}
catch (Exception ex)
{
receiver.Reject(message);
Console.WriteLine(ex);
}
}
public void TestMethod_InterfaceSendReceiveOnAttach()
{
string testName = "InterfaceSendReceiveOnAttach";
const int nMsgs = 200;
int nAttaches = 0;
OnAttached onAttached = (link, attach) => {
nAttaches++;
};
IConnection connection = new Connection(testTarget.Address);
ISession session = connection.CreateSession();
ISenderLink sender = session.CreateSender("sender-" + testName, new Target()
{
Address = testTarget.Path
}, onAttached);
for (int i = 0; i < nMsgs; ++i)
{
Message message = new Message("msg" + i);
message.Properties = new Properties()
{
GroupId = "abcdefg"
};
message.ApplicationProperties = new ApplicationProperties();
message.ApplicationProperties["sn"] = i;
sender.Send(message, null, null);
}
IReceiverLink receiver = session.CreateReceiver("receiver-" + testName, new Source()
{
Address = testTarget.Path
}, onAttached);
for (int i = 0; i < nMsgs; ++i)
{
Message message = receiver.Receive();
Trace.WriteLine(TraceLevel.Verbose, "receive: {0}", message.ApplicationProperties["sn"]);
receiver.Accept(message);
}
Assert.AreEqual(2, nAttaches);
connection.Close();
}
private void InvokeHandler(
IReceiverLink receiverLink,
Message amqpMessage,
IMessage message,
HostItemSubscriber subscriber)
{
try
{
DispatchModule.InvokeDispatcherInNewLifetimeScopeAsync(
subscriber.DispatchInfo,
message).GetAwaiter().GetResult();
receiverLink.Accept(amqpMessage);
}
catch (Exception ex)
{
LogMessageReceiveEx(ex, message, subscriber.DispatchInfo);
receiverLink.Reject(amqpMessage);
}
}
public async Task InterfaceSendReceiveAsync()
{
string testName = "BasicSendReceiveAsync";
int nMsgs = 100;
IConnectionFactory factory = new ConnectionFactory();
IConnection connection = await factory.CreateAsync(this.testTarget.Address);
ISession session = connection.CreateSession();
ISenderLink sender = session.CreateSender("sender-" + testName, testTarget.Path);
for (int i = 0; i < nMsgs; ++i)
{
Message message = new Message();
message.Properties = new Properties()
{
MessageId = "msg" + i, GroupId = testName
};
message.ApplicationProperties = new ApplicationProperties();
message.ApplicationProperties["sn"] = i;
await sender.SendAsync(message);
}
IReceiverLink receiver = session.CreateReceiver("receiver-" + testName, testTarget.Path);
for (int i = 0; i < nMsgs; ++i)
{
Message message = await receiver.ReceiveAsync(Timeout.InfiniteTimeSpan);
Trace.WriteLine(TraceLevel.Information, "receive: {0}", message.ApplicationProperties["sn"]);
receiver.Accept(message);
}
await sender.CloseAsync();
await receiver.CloseAsync();
await session.CloseAsync();
await connection.CloseAsync();
}
public void OnMessage(IReceiverLink link, Message message)
{
WriteLine($"Received a message with the content: {message.Body}");
//if (1 == 1) throw new Exception("Something wrong");
//WriteLine("Testing sleep " + (++x));
//Thread.Sleep(100 * 1000);
WriteLine($"Accepted message number {_x++}");
link.Accept(message);
//Console.WriteLine($"Received message {message.Body}");
//Debug.WriteLine($"Received message {message.Body}");
//WriteLine($"started a long running job at {DateTime.Now}");
//for (int i = 0; i < 150; i++)
//{
// Console.Write(i + " ");
// //user = container.UserService.GetUserProfile();
// var fileContent = File.ReadAllText(@"C:\temp\test.txt");
//}
//WriteLine($"finished a long running job at {DateTime.Now}");
}
protected virtual async void OnMessageCallback(IReceiverLink receiver, Message message)
{
var messageType = message.ApplicationProperties[MESSAGE_TYPE_KEY] as string;
using (Logger.BeginScope(new Dictionary <string, object> {
["CorrelationId"] = message.Properties.CorrelationId,
["MessageId"] = message.Properties.MessageId,
["MessageType"] = messageType
})) {
Logger.LogInformation($"Received message {message.Properties.MessageId}");
try {
string rawBody = null;
// Get the body
if (message.Body is string)
{
rawBody = message.Body as string;
}
else if (message.Body is byte[])
{
using (var reader = XmlDictionaryReader.CreateBinaryReader(
new MemoryStream(message.Body as byte[]),
null,
XmlDictionaryReaderQuotas.Max)) {
var doc = new XmlDocument();
doc.Load(reader);
rawBody = doc.InnerText;
}
}
else
{
throw new ArgumentException($"Message {message.Properties.MessageId} has body with an invalid type {message.Body.GetType().ToString()}");
}
Logger.LogTrace($"Received message {message.Properties.MessageId} with body: {rawBody}");
Logger.LogDebug($"Event type key: {messageType}");
var dataType = EventTypeLookup[messageType];
Logger.LogDebug($"Event type: {dataType}");
var handlerType = typeof(IDomainEventHandler <>).MakeGenericType(dataType);
Logger.LogDebug($"Event type handler interface: {handlerType}");
var handler = Provider.GetService(handlerType);
if (handler != null)
{
Logger.LogDebug($"Event type handler: {handler.GetType()}");
var data = JsonConvert.DeserializeObject(rawBody, dataType);
Logger.LogDebug($"Successfully deserialized body to {dataType}");
//TODO: Update the way "Handle" is retrieved in a type safe way.
var eventType = typeof(DomainEventMessage <>).MakeGenericType(dataType);
var method1 = handlerType.GetTypeInfo().GetMethod("Handle", new Type[] { eventType });
var method2 = handlerType.GetTypeInfo().GetMethod("Handle", new Type[] { dataType });
if (method1 != null)
{
dynamic domainEvent = Activator.CreateInstance(eventType);
domainEvent.MessageId = message.Properties.MessageId;
domainEvent.CorrelationId = message.Properties.CorrelationId;
domainEvent.Data = (dynamic)data;
await(Task) method1.Invoke(handler, new object[] { domainEvent });
}
else
{
await(Task) method2.Invoke(handler, new object[] { data });
}
receiver.Accept(message);
Logger.LogInformation($"Message {message.Properties.MessageId} accepted");
}
else
{
receiver.Reject(message);
Logger.LogError($"Message {message.Properties.MessageId} rejected because handler was not found for type {messageType}");
}
} catch (Exception ex) {
receiver.Reject(message);
Logger.LogError(ex, $"Message {message.Properties.MessageId} rejected because of unhandled exception {ex.Message}");
}
}
}
private async void ProcessIncomingRpcRequestAsync(IReceiverLink receiver, Message message)
{
//Accept the message since we would be replying using sender, hence disposition does not make sense
await Task.Run(async() =>
{
receiver.Accept(message);
//Deserialize the body
AmqpRpcRequest _rpcRequest = message.GetBody <AmqpRpcRequest>();
string _replyTo = message.Properties.ReplyTo;
string _correlationId = message.Properties.CorrelationId;
if (!_rpMethodTypes.Contains(_rpcRequest.Type))
{
Log.Error($"Invalid request type received: {_rpcRequest.Type}");
await this.SendResponseAsync(replyTo: _replyTo, correlationId: _correlationId, requestType: _rpcRequest.Type, response: null, ex: new AmqpRpcInvalidRpcTypeException(_rpcRequest.Type));
return;
}
if (string.IsNullOrEmpty(_rpcRequest.Method))
{
Log.Error("Missing RPC function call name: {@_rpcRequest}", _rpcRequest);
await this.SendResponseAsync(replyTo: _replyTo, correlationId: _correlationId, requestType: _rpcRequest.Type, response: null, ex: new AmqpRpcMissingFunctionNameException(JsonConvert.SerializeObject(_rpcRequest)));
return;
}
if (!this._serverFunctions.ContainsKey(_rpcRequest.Method))
{
Log.Error($"Unknown RPC method request received: {_rpcRequest.Method}");
await this.SendResponseAsync(replyTo: _replyTo, correlationId: _correlationId, requestType: _rpcRequest.Type, response: null, ex: new AmqpRpcUnknownFunctionException($"{_rpcRequest.Method} is not bound to remote server"));
return;
}
var _requestObjectType = this._serverFunctions.SingleOrDefault(x => x.Key.Equals(_rpcRequest.Method));
if (_requestObjectType.Value == null)
{
Log.Error($"Unknown RPC method request received: {_rpcRequest.Method}");
await this.SendResponseAsync(replyTo: _replyTo, correlationId: _correlationId, requestType: _rpcRequest.Type, response: null, ex: new AmqpRpcUnknownFunctionException($"{_rpcRequest.Method} is not bound to remote server"));
return;
}
var _methodParameter = this._utility.PeeloutAmqpWrapper(deserializationType: _requestObjectType.Value.RequestParameterType, parameters: _rpcRequest.Parameters);
var _classInstance = Activator.CreateInstance(_requestObjectType.Value.FunctionWrapperType);
MethodInfo _method = _requestObjectType.Value.FunctionWrapperType.GetMethod(_requestObjectType.Key);
var _asyncAttribute = _method.GetCustomAttribute <AsyncStateMachineAttribute>();
var _isAsync = (_asyncAttribute != null) || (_method.ReturnType.BaseType.Equals(typeof(Task)));
try
{
if (!(_methodParameter is null) && _method.GetParameters().Length > 0)
{
//TODO: check for missing properties from rpc calls
//await this.SendResponse(replyTo: _replyTo, correlationId: _correlationId, _rpcRequest.type, null, new AmqpRpcUnknowParameterException($"{_rpcRequest.method} invokation failed, mismatch in parameter"));
object _rtnVal = null;
try
{
if (_isAsync)
{
_rtnVal = await(dynamic) _method.Invoke(_classInstance, new[] { _methodParameter });
}
else
{
_rtnVal = _method.Invoke(_classInstance, new[] { _methodParameter });
}
await this.SendResponseAsync(replyTo: _replyTo, correlationId: _correlationId, requestType: _rpcRequest.Type, response: _rtnVal, ex: null);
}
catch (Exception ex)
{
await this.SendResponseAsync(replyTo: _replyTo, correlationId: _correlationId, requestType: _rpcRequest.Type, response: null, ex: ex);
return;
}
}
else if (_methodParameter is null && _method.GetParameters().Length.Equals(0))
{
object _rtnVal = null;
try
{
if (_isAsync)
{
_rtnVal = await(dynamic) _method.Invoke(_classInstance, null);
}
else
{
_rtnVal = _method.Invoke(_classInstance, null);
}
await this.SendResponseAsync(replyTo: _replyTo, correlationId: _correlationId, requestType: _rpcRequest.Type, response: _rtnVal, ex: null);
}
catch (Exception ex)
{
await this.SendResponseAsync(replyTo: _replyTo, correlationId: _correlationId, requestType: _rpcRequest.Type, response: null, ex: ex);
return;
}
}
public void Accept()
{
link.Accept(message);
}
protected async Task OnMessageCallbackAsync(IReceiverLink receiver, Message message)
{
var messageTypeName = message.ApplicationProperties[Constants.MESSAGE_TYPE_KEY] as string;
var properties = new Dictionary <string, object> {
["CorrelationId"] = message.Properties.CorrelationId,
["MessageId"] = message.Properties.MessageId,
["MessageType"] = messageTypeName
};
// if message has correlationId, set it so that handling can be found by initial correlation
if (!string.IsNullOrWhiteSpace(message.Properties.CorrelationId))
{
CorrelationContext.SetCorrelationId(message.Properties.CorrelationId);
}
var timer = new Stopwatch();
timer.Start();
using (Logger.BeginScope(properties)) {
Logger.LogInformation($"Received message {message.Properties.MessageId}");
try {
string body = DomainEventMessage.GetBody(message);
Logger.LogTrace("Received message {MessageId} with body: {MessageBody}", message.Properties.MessageId, body);
Logger.LogDebug($"Event type key: {messageTypeName}");
if (!EventTypeLookup.ContainsKey(messageTypeName))
{
Logger.LogError($"Message {message.Properties.MessageId} rejected because message type was not registered for type {messageTypeName}");
receiver.Reject(message);
return;
}
var dataType = EventTypeLookup[messageTypeName];
Logger.LogDebug($"Event type: {dataType}");
var handlerType = typeof(IDomainEventHandler <>).MakeGenericType(dataType);
Logger.LogDebug($"Event type handler interface: {handlerType}");
var handler = Provider.GetService(handlerType);
if (handler == null)
{
Logger.LogError($"Message {message.Properties.MessageId} rejected because handler was not found for type {messageTypeName}");
receiver.Reject(message);
return;
}
Logger.LogDebug($"Event type handler: {handler.GetType()}");
dynamic domainEvent;
try {
domainEvent = DomainEventMessage.CreateGenericInstance(dataType, message);
Logger.LogDebug($"Successfully deserialized body to {dataType}");
} catch (Exception ex) {
Logger.LogError(ex, ex.Message);
receiver.Reject(message);
return;
}
HandlerResult result;
dynamic dhandler = handler;
try {
result = await dhandler.HandleAsync(domainEvent).ConfigureAwait(false);
} catch (Exception ex) {
Logger.LogError(ex, $"Message {message.Properties.MessageId} caught unhandled exception {ex.Message}");
result = HandlerResult.Failed;
}
timer.Stop();
var duration = timer.ElapsedMilliseconds;
var dp = new Dictionary <string, object> {
["duration"] = duration
};
using (Logger.BeginScope(dp)) {
Logger.LogInformation($"Handler executed for message {message.Properties.MessageId} and returned result of {result}");
switch (result)
{
case HandlerResult.Success:
receiver.Accept(message);
Logger.LogInformation($"Message {message.Properties.MessageId} accepted");
break;
case HandlerResult.Retry:
var deliveryCount = message.Header.DeliveryCount;
var delay = 10 * deliveryCount;
var scheduleTime = DateTime.UtcNow.AddSeconds(delay);
using (var ts = new TransactionScope()) {
var sender = new SenderLink(Link.Session, Settings.AppName + "-retry", Settings.Queue);
// create a new message to be queued with scheduled delivery time
var retry = new Message(body)
{
Header = message.Header,
Footer = message.Footer,
Properties = message.Properties,
ApplicationProperties = message.ApplicationProperties
};
retry.ApplicationProperties[Constants.SCHEDULED_ENQUEUE_TIME_UTC] = scheduleTime;
sender.Send(retry);
receiver.Accept(message);
}
Logger.LogInformation($"Message {message.Properties.MessageId} requeued with delay of {delay} seconds for {scheduleTime}");
break;
case HandlerResult.Failed:
receiver.Reject(message);
break;
case HandlerResult.Release:
receiver.Release(message);
break;
default:
throw new NotImplementedException($"Unknown HandlerResult value of {result}");
}
}
} catch (Exception ex) {
timer.Stop();
var duration = timer.ElapsedMilliseconds;
var dp = new Dictionary <string, object> {
["duration"] = duration
};
using (Logger.BeginScope(dp)) {
Logger.LogError(ex, $"Message {message.Properties.MessageId} rejected because of unhandled exception {ex.Message}");
receiver.Reject(message);
}
}
}
}
void OnMessage(IReceiverLink link, Message message)
{
link.Accept(message);
this.Success(1);
}
protected virtual async void OnMessageCallback(IReceiverLink receiver, Message message)
{
var messageType = message.ApplicationProperties[MESSAGE_TYPE_KEY] as string;
using (Logger.BeginScope(new Dictionary <string, object> {
["CorrelationId"] = message.Properties.CorrelationId,
["MessageId"] = message.Properties.MessageId,
["MessageType"] = messageType
})) {
Logger.LogInformation($"Received message {message.Properties.MessageId}");
try {
string rawBody = null;
// Get the body
if (message.Body is string)
{
rawBody = message.Body as string;
}
else if (message.Body is byte[])
{
using (var reader = XmlDictionaryReader.CreateBinaryReader(
new MemoryStream(message.Body as byte[]),
null,
XmlDictionaryReaderQuotas.Max)) {
var doc = new XmlDocument();
doc.Load(reader);
rawBody = doc.InnerText;
}
}
else
{
throw new ArgumentException($"Message {message.Properties.MessageId} has body with an invalid type {message.Body.GetType()}");
}
Logger.LogTrace($"Received message {message.Properties.MessageId} with body: {rawBody}");
Logger.LogDebug($"Event type key: {messageType}");
if (!EventTypeLookup.ContainsKey(messageType))
{
Logger.LogError($"Message {message.Properties.MessageId} rejected because message type was not registered for type {messageType}");
receiver.Reject(message);
}
var dataType = EventTypeLookup[messageType];
Logger.LogDebug($"Event type: {dataType}");
var handlerType = typeof(IDomainEventHandler <>).MakeGenericType(dataType);
Logger.LogDebug($"Event type handler interface: {handlerType}");
var handler = Provider.GetService(handlerType);
if (handler != null)
{
Logger.LogDebug($"Event type handler: {handler.GetType()}");
List <string> errors = new List <string>();
var data = JsonConvert.DeserializeObject(rawBody, dataType,
new JsonSerializerSettings {
Error = (object sender, Newtonsoft.Json.Serialization.ErrorEventArgs args) => {
errors.Add(args.ErrorContext.Error.Message);
args.ErrorContext.Handled = true;
}
});
if (errors.Any())
{
Logger.LogError($"Message {message.Properties.MessageId} rejected because of errors deserializing messsage body: {string.Join(", ", errors)}");
receiver.Reject(message);
return;
}
Logger.LogDebug($"Successfully deserialized body to {dataType}");
var eventType = typeof(DomainEventMessage <>).MakeGenericType(dataType);
var method = handlerType.GetTypeInfo().GetMethod("Handle", new Type[] { eventType });
if (method != null)
{
dynamic domainEvent = Activator.CreateInstance(eventType);
domainEvent.MessageId = message.Properties.MessageId;
domainEvent.CorrelationId = message.Properties.CorrelationId;
domainEvent.Data = (dynamic)data;
await(Task) method.Invoke(handler, new object[] { domainEvent });
}
Logger.LogInformation($"Message {message.Properties.MessageId} accepted");
receiver.Accept(message);
}
else
{
Logger.LogError($"Message {message.Properties.MessageId} rejected because handler was not found for type {messageType}");
receiver.Reject(message);
}
} catch (Exception ex) {
Logger.LogError(ex, $"Message {message.Properties.MessageId} rejected because of unhandled exception {ex.Message}");
receiver.Reject(message);
}
}
}