/// <summary>
/// Enqueue the message for relaying.
/// </summary>
/// <param name="msg">Message to enqueue.</param>
public static bool Enqueue(MtaQueuedMessage msg)
{
RabbitMqManager.RabbitMqQueue queue = RabbitMqManager.RabbitMqQueue.OutboundWaiting;
int secondsUntilNextAttempt = (int)Math.Ceiling((msg.AttemptSendAfterUtc - DateTime.UtcNow).TotalSeconds);
if (secondsUntilNextAttempt > 0)
{
if (secondsUntilNextAttempt < 10)
{
queue = RabbitMqManager.RabbitMqQueue.OutboundWait1;
}
else if (secondsUntilNextAttempt < 60)
{
queue = RabbitMqManager.RabbitMqQueue.OutboundWait10;
}
else if (secondsUntilNextAttempt < 300)
{
queue = RabbitMqManager.RabbitMqQueue.OutboundWait60;
}
else
{
queue = RabbitMqManager.RabbitMqQueue.OutboundWait300;
}
}
if (!RabbitMqManager.Publish(msg, queue))
{
return(false);
}
msg.IsHandled = true;
return(true);
}
private static void HandleDequeue()
{
if (_StartedThreads >= STAGING_DEQUEUE_THREADS)
{
return;
}
_StartedThreads++;
while (true)
{
BasicDeliverEventArgs ea = RabbitMq.RabbitMqManager.Dequeue(RabbitMqManager.RabbitMqQueue.InboundStaging, 1, 100).FirstOrDefault();
if (ea == null)
{
Thread.Sleep(1000);
continue;
}
MtaQueuedMessage qmsg = Serialisation.Deserialise <MtaQueuedMessage>(ea.Body);
MtaMessage msg = new MtaMessage(qmsg.ID, qmsg.VirtualMTAGroupID, qmsg.InternalSendID, qmsg.MailFrom, qmsg.RcptTo, string.Empty);
RabbitMqManager.Publish(msg, RabbitMqManager.RabbitMqQueue.Inbound, true);
RabbitMqManager.Publish(qmsg, RabbitMqManager.RabbitMqQueue.OutboundWaiting, true);
RabbitMqManager.Ack(RabbitMqManager.RabbitMqQueue.InboundStaging, ea.DeliveryTag, false);
}
}
/// <summary>
/// Enqueue the messages in the collection for relaying.
/// </summary>
/// <param name="inboundMessages">Messages to enqueue.</param>
public static void Enqueue(MtaMessageCollection inboundMessages)
{
Parallel.ForEach(inboundMessages, message => {
Enqueue(MtaQueuedMessage.CreateNew(message));
});
RabbitMqManager.Ack(RabbitMqManager.RabbitMqQueue.Inbound, inboundMessages.Max(m => m.RabbitMqDeliveryTag), true);
}
/// <summary>
/// Enqueues the Email that we are going to relay in RabbitMQ.
/// </summary>
/// <param name="messageID">ID of the Message being Queued.</param>
/// <param name="ipGroupID">ID of the Virtual MTA Group to send the Message through.</param>
/// <param name="internalSendID">ID of the Send the Message is apart of.</param>
/// <param name="mailFrom">The envelope mailfrom, should be return-path in most instances.</param>
/// <param name="rcptTo">The envelope rcpt to.</param>
/// <param name="message">The Email.</param>
/// <returns>True if the Email has been enqueued in RabbitMQ.</returns>
public static bool Enqueue(Guid messageID, int ipGroupID, int internalSendID, string mailFrom, string[] rcptTo, string message)
{
// Create the thing we are going to queue in RabbitMQ.
MtaMessage recordToSave = new MtaMessage(messageID,
ipGroupID,
internalSendID,
mailFrom,
rcptTo,
message);
return(RabbitMqManager.Publish(MtaQueuedMessage.CreateNew(recordToSave), RabbitMqManager.RabbitMqQueue.InboundStaging, true));
}
/// <summary>
/// Dequeue a message from RabbitMQ.
/// </summary>
/// <returns>A dequeued message or null if there weren't any.</returns>
public static MtaQueuedMessage Dequeue()
{
BasicDeliverEventArgs ea = RabbitMqManager.Dequeue(RabbitMqManager.RabbitMqQueue.OutboundWaiting, 1, 100).FirstOrDefault();
if (ea == null)
{
return(null);
}
MtaQueuedMessage qmsg = Serialisation.Deserialise <MtaQueuedMessage>(ea.Body);
qmsg.RabbitMqDeliveryTag = ea.DeliveryTag;
qmsg.IsHandled = false;
return(qmsg);
}
/// <summary>
/// Dequeues a collection of inbound messages from RabbitMQ.
/// </summary>
/// <param name="maxItems">The maximum amount of messages to dequeue.</param>
/// <returns>The dequeue messages.</returns>
public static MtaMessageCollection Dequeue(int maxItems)
{
List <BasicDeliverEventArgs> items = RabbitMqManager.Dequeue(RabbitMqManager.RabbitMqQueue.Inbound, maxItems, 1 * 1000);
MtaMessageCollection messages = new MtaMessageCollection();
if (items.Count == 0)
{
return(messages);
}
foreach (BasicDeliverEventArgs ea in items)
{
MtaMessage msg = Serialisation.Deserialise <MtaMessage>(ea.Body);
msg.RabbitMqDeliveryTag = ea.DeliveryTag;
messages.Add(msg);
}
return(messages);
}
/// <summary>
/// Acknowledge the message as handled.
/// </summary>
/// <param name="msg">The message to acknowledge.</param>
internal static void Ack(MtaQueuedMessage msg)
{
RabbitMqManager.Ack(RabbitMqManager.RabbitMqQueue.OutboundWaiting, msg.RabbitMqDeliveryTag, false);
}
