private T Receive(bool acceptance)
{
var msg = _consumer.Receive();
try
{
// Variable to save the body of the message.
string body = string.Empty;
// Get the body
var rawBody = msg.GetBody <object>();
// 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);
if (acceptance)
{
// Accept the messsage.
_consumer.Accept(msg);
}
else
{
_consumer.Reject(msg);
}
}
catch (Exception ex)
{
_consumer.Reject(msg);
Console.WriteLine(ex);
}
return(null);
}
public async Task Start()
{
Running = true;
Connection = new Connection(new Address(ConnectionString));
ReceiverSession = new Session(Connection);
var receiverLink = new ReceiverLink(ReceiverSession, $"{ClientName}-rc", Queue);
while (Running)
{
var message = await receiverLink.ReceiveAsync(TimeSpan.FromMilliseconds(500));
if (message == null)
{
continue;
}
Console.WriteLine("Received Message");
if (string.IsNullOrEmpty(message.Properties?.Subject) ||
string.IsNullOrEmpty(message.Properties.ReplyTo))
{
receiverLink.Reject(message);
continue;
}
receiverLink.Accept(message);
await ProcessMessage(message);
}
}
protected override void Renew(Session session)
{
oldReceiver = receiver;
receiver = new ReceiverLink(session, "receiver", Environment.GetEnvironmentVariable("SERVICE_BUS_NAME"));
receiver.Start(20, (receiver, message) =>
{
Console.WriteLine($"[{DateTime.UtcNow.ToString("dd/MM/yyyy HH:mm:ss")}] -> received message");
try
{
var queueMessage = JsonConvert.DeserializeObject <QueueMessage>(message.GetBody <string>());
OnMessage(queueMessage);
receiver.Accept(message);
}
catch (Exception e)
{
Console.WriteLine($"[{DateTime.UtcNow.ToString("dd/MM/yyyy HH:mm:ss")}] -> message threw an exception: {e.Message}");
receiver.Reject(message);
}
});
if (oldReceiver != null)
{
oldReceiver.Close();
oldReceiver = null;
}
}
public void ContainerHostMessageSourceTest()
{
string name = "ContainerHostMessageSourceTest";
int count = 100;
Queue <Message> messages = new Queue <Message>();
for (int i = 0; i < count; i++)
{
messages.Enqueue(new Message("test")
{
Properties = new Properties()
{
MessageId = name + i
}
});
}
var source = new TestMessageSource(messages);
this.host.RegisterMessageSource(name, source);
var connection = new Connection(Address);
var session = new Session(connection);
var receiver = new ReceiverLink(session, "receiver0", name);
int released = 0;
int rejected = 0;
int ignored = 0;
for (int i = 1; i <= count; i++)
{
Message message = receiver.Receive();
if (i % 5 == 0)
{
receiver.Reject(message);
rejected++;
}
else if (i % 17 == 0)
{
receiver.Release(message);
released++;
}
else if (i % 36 == 0)
{
ignored++;
}
else
{
receiver.Accept(message);
}
}
receiver.Close();
session.Close();
connection.Close();
Thread.Sleep(500);
Assert.AreEqual(released + ignored, messages.Count, string.Join(",", messages.Select(m => m.Properties.MessageId)));
Assert.AreEqual(rejected, source.DeadletterMessage.Count, string.Join(",", source.DeadletterMessage.Select(m => m.Properties.MessageId)));
}
public void ContainerHostSourceLinkEndpointTest()
{
string name = "ContainerHostSourceLinkEndpointTest";
int count = 100;
Queue <Message> messages = new Queue <Message>();
for (int i = 0; i < count; i++)
{
messages.Enqueue(new Message("test")
{
Properties = new Properties()
{
MessageId = name + i
}
});
}
var source = new TestMessageSource(messages);
this.linkProcessor = new TestLinkProcessor(link => new SourceLinkEndpoint(source, link));
this.host.RegisterLinkProcessor(this.linkProcessor);
var connection = new Connection(Address);
var session = new Session(connection);
var receiver = new ReceiverLink(session, "receiver0", name);
int released = 0;
int rejected = 0;
for (int i = 1; i <= count; i++)
{
Message message = receiver.Receive();
if (i % 5 == 0)
{
receiver.Reject(message);
rejected++;
}
else if (i % 17 == 0)
{
receiver.Release(message);
released++;
}
else
{
receiver.Accept(message);
}
}
receiver.Close();
session.Close();
connection.Close();
Thread.Sleep(200);
Assert.AreEqual(released, messages.Count);
Assert.AreEqual(rejected, source.DeadletterMessage.Count);
}
private void onMessage(ReceiverLink receiver, Message message)
{
try
{
// Variable to save the body of the message.
string body = string.Empty;
// Get the body
var rawBody = message.GetBody <object>();
// 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);
if (_handler != null)
{
_handler.ReceiveMessage(body);
}
}
catch (Exception ex)
{
receiver.Reject(message);
Console.WriteLine(ex);
}
}
/// <summary>
/// Callback method that will be called every time a message is received.
/// </summary>
/// <param name="receiver">The AMQP receiver</param>
/// <param name="message">The message you just received</param>
static void OnMessageCallback(ReceiverLink receiver, 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.GetBody <object>();
// If the body is byte[] asume it was sent as a BrokeredMessage
// adn 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_MessageDeliveryReject()
{
string testName = "MessageDeliveryReject";
Connection connection = new Connection(testTarget.Address);
Session session = new Session(connection);
SenderLink sender = new SenderLink(session, "sender-" + testName, testTarget.Path);
Message message = new Message("msg reject");
sender.Send(message, null, null);
ReceiverLink receiver = new ReceiverLink(session, "receiver-" + testName, testTarget.Path);
message = receiver.Receive();
MessageDelivery messageDelivery = message.GetDelivery();
message.Dispose();
receiver.Reject(messageDelivery);
connection.Close();
}
private void HandleMessages()
{
try
{
_logger.LogInformation($"[{DateTime.UtcNow:u}] Connecting to the ServiceBus...");
_log.WriteInfoAsync("EmailSenderBridge", "HandleMessages()", null, "Connecting to the ServiceBus...").Wait();
_connection = Connection.Factory.CreateAsync(new Address(_connectionString)).GetAwaiter().GetResult();
_session = new Session(_connection);
_receiver = new ReceiverLink(_session, "receiver-link", _settings.ServiceBus.QueueName);
while (_isRunning)
{
Message message = _receiver.Receive();
if (message == null)
{
continue;
}
try
{
_logger.LogInformation($"[{DateTime.UtcNow:u}] Processing message...");
MimeMessage emailMessage = PrepareEmailMessage(message);
SendEmailMessage(emailMessage);
_receiver.Accept(message);
}
catch (Exception ex)
{
_receiver.Reject(message);
_log.WriteErrorAsync("EmailSernderBridge", "HandleMessages()", null, ex).Wait();
_logger.LogError($"[{DateTime.UtcNow:u}] {ex}");
}
}
}
catch (Exception ex)
{
_log.WriteErrorAsync("EmailSernderBridge", "HandleMessages()", "Connection issue", ex).Wait();
_logger.LogError($"[{DateTime.UtcNow:u}] {ex}");
}
}
public static void Main(string[] args)
{
Trace.TraceLevel = TraceLevel.Frame;
Trace.TraceListener = (f, a) =>
{
var t = DateTime.Now.ToString("[hh:ss.fff]") + " " + string.Format(f, a);
Console.WriteLine(t);
};
connection = new Connection(amqpAddress, null, new Open()
{
ContainerId = Guid.NewGuid().ToString(),
ChannelMax = 64,
MaxFrameSize = 200,
}, null);
connection.Closed = OnClosed;
session = new Session(connection);
session.Closed = OnClosed;
var linkName = Guid.NewGuid().ToString();
senderLink = new SenderLink(session, linkName, new Attach()
{
Target = new Target()
{
Address = "TestQueue1",
},
//RcvSettleMode = ReceiverSettleMode.Second,
//SndSettleMode = SenderSettleMode.Settled,
}, null);
senderLink.Closed = OnClosed;
for (int i = 0; i < 10; i++)
{
senderLink.Send(CreateMessage(), 5000);
}
senderLink.Close();
linkName = Guid.NewGuid().ToString();
receiverLink = new ReceiverLink(session, linkName, "TestQueue1");
receiverLink.Closed = OnClosed;
receiverLink.SetCredit(1);
var message = receiverLink.Receive(20000);
int receiveCount = 0;
while (message != null)
{
receiveCount++;
//Console.WriteLine(message.Body.GetType());
Console.WriteLine(message.BodySection.GetType());
Console.WriteLine("Receive #{0}. Message = \"{1}\"", receiveCount.ToString(), Encoding.UTF8.GetString(message.GetBody <byte[]>()));
if (receiveCount % 7 == 0)
{
receiverLink.Release(message);
}
else if (receiveCount % 4 == 0)
{
receiverLink.Reject(message);
}
else
{
receiverLink.Accept(message);
}
Thread.Sleep(10000);
message = receiverLink.Receive(20000);
}
receiverLink.Close();
session.Close();
connection.Close();
}
private void TryHandleMessage(ReceiverLink receiverLink, Message amqpMessage)
{
// NOTE this method _should not_ throw an exception!
var threadName = receiverLink.Name;
var messageID = amqpMessage.Properties?.MessageId ?? "?";
try
{
logger.Debug("{0}: Received Message with MessageId={1}", threadName, messageID);
var headers = new Dictionary <string, string>();
if (amqpMessage.ApplicationProperties != null)
{
foreach (var key in amqpMessage.ApplicationProperties.Map.Keys)
{
headers[key.ToString()] = amqpMessage.ApplicationProperties.Map[key].ToString();
}
}
object message = null;
try
{
message = DecodeMessage(amqpMessage);
}
catch (Exception e)
{
logger.Error(e, "{0}: Cannot Decode Message. Will not re-enqueue.", threadName);
OnPoisonMessageDetected(new PoisonMessageDetectedEventArgs()
{
QueueName = ReceiverLinkAddress,
Retries = MaxRetries,
Exception = e,
MessageId = messageID,
ErrorCode = "DecodeException",
});
}
if (message != null)
{
var transportMessage = new IncomingTransportMessage(messageID, headers, message);
Exception lastException = null;
if (faultManager.HasMaxRetriesExceeded(transportMessage, out lastException))
{
logger.Error(lastException, "{0}: MaxRetriesExceeded for MessageId={1}. Will not re-enqueue.", threadName, messageID.ToString());
OnPoisonMessageDetected(new PoisonMessageDetectedEventArgs()
{
QueueName = ReceiverLinkAddress,
Retries = MaxRetries,
Exception = lastException,
MessageId = messageID,
ErrorCode = "MaxRetriesExceeded",
});
}
else
{
logger.Debug("{0}: Notifying observers of new TransportMessage for MessageId={1}.", threadName, messageID.ToString());
OnMessageAvailable(transportMessage);
faultManager.ClearFailuresForMessage(messageID);
}
}
receiverLink.Accept(amqpMessage);
logger.Debug("{0}: Accepting MessageId={1}", threadName, messageID.ToString());
}
catch (Exception e)
{
faultManager.IncrementFailuresForMessage(messageID.ToString(), e);
receiverLink.Reject(amqpMessage);
logger.Error(e, "{0}: Exception caught handling MessageId={1}. Rejecting.", threadName, messageID.ToString());
Thread.Sleep(1000); // TODO possibly implement a backoff with the fault manager based on number of retries?
}
}
public async Task ReadQueue(CancellationToken token, Func <T, Task <MessageAction> > callback)
{
if (receiver != null)
{
throw new Exception("Someone already reading, create a new instance");
}
await Connect();
receiver = new ReceiverLink(session, receiverName, $"{queue}");
token.Register(Close);
while (receiver != null && !token.IsCancellationRequested)
{
try
{
var message = await receiver.ReceiveAsync();
if (message != null)
{
try
{
var cardInfo = JsonConvert.DeserializeObject <T>(message.Body.ToString());
var action = await callback(cardInfo);
switch (action)
{
case MessageAction.ACCEPT:
receiver.Accept(message);
break;
case MessageAction.RELEASE:
receiver.Reject(message);
break;
default:
receiver.Reject(message);
break;
}
}
catch (JsonReaderException)
{
receiver.Reject(message);
}
catch (JsonSerializationException)
{
receiver.Reject(message);
}
}
}
catch
{
if (receiver != null && !token.IsCancellationRequested)
{
Close();
await Connect();
receiver = new ReceiverLink(session, receiverName, $"{queue}");
}
}
}
Close();
}
