private void AddMessage(InboundMessageDispatch envelope)
{
lock (syncRoot)
{
messages.AddLast(envelope);
}
}
public Task Acknowledge(InboundMessageDispatch envelope, AckType ackType)
{
AmqpSession session = connection.GetSession(envelope.ConsumerInfo.SessionId);
AmqpConsumer consumer = session.GetConsumer(envelope.ConsumerId);
consumer.Acknowledge(envelope, ackType);
return Task.CompletedTask;
}
public void OnInboundMessage(InboundMessageDispatch envelope)
{
if (consumers.TryGetValue(envelope.ConsumerInfo.Id, out NmsMessageConsumer messageConsumer))
{
messageConsumer.OnInboundMessage(envelope);
}
}
private void OnMessage(IReceiverLink receiver, global::Amqp.Message amqpMessage)
{
NmsMessage message;
try
{
message = AmqpCodec.DecodeMessage(this, amqpMessage).AsMessage();
}
catch (Exception e)
{
Tracer.Error($"Error on transform: {e.Message}");
// Mark message as undeliverable
link.Modify(amqpMessage, true, true);
return;
}
// Let the message do any final processing before sending it onto a consumer.
// We could defer this to a later stage such as the NmsConnection or even in
// the NmsMessageConsumer dispatch method if we needed to.
message.OnDispatch();
InboundMessageDispatch inboundMessageDispatch = new InboundMessageDispatch
{
Message = message,
ConsumerId = info.Id,
ConsumerInfo = info,
};
AddMessage(inboundMessageDispatch);
IProviderListener providerListener = session.Connection.Provider.Listener;
providerListener.OnInboundMessage(inboundMessageDispatch);
}
private InboundMessageDispatch CreateEnvelope(MsgPriority priority = MsgPriority.BelowNormal)
{
InboundMessageDispatch envelope = new InboundMessageDispatch();
envelope.Message = CreateMessage(priority);
return(envelope);
}
public void TestEnqueueFirstOverridesPriority()
{
PriorityMessageQueue queue = new PriorityMessageQueue();
// Add a higher priority message
InboundMessageDispatch message1 = CreateEnvelope(MsgPriority.High);
queue.Enqueue(message1);
// Add other lower priority messages 'first'.
InboundMessageDispatch message2 = CreateEnvelope(MsgPriority.BelowNormal);
InboundMessageDispatch message3 = CreateEnvelope(MsgPriority.AboveLow);
InboundMessageDispatch message4 = CreateEnvelope(MsgPriority.Low);
queue.EnqueueFirst(message2);
queue.EnqueueFirst(message3);
queue.EnqueueFirst(message4);
// Verify they dequeue in the reverse of the order
// they were added, and not priority order.
Assert.AreSame(message4, queue.DequeueNoWait());
Assert.AreSame(message3, queue.DequeueNoWait());
Assert.AreSame(message2, queue.DequeueNoWait());
Assert.AreSame(message1, queue.DequeueNoWait());
}
public void Acknowledge(InboundMessageDispatch envelope, AckType ackType)
{
if (envelope.Message.Facade is AmqpNmsMessageFacade facade)
{
global::Amqp.Message message = facade.Message;
switch (ackType)
{
case AckType.DELIVERED:
envelope.IsDelivered = true;
break;
case AckType.ACCEPTED:
HandleAccepted(envelope, message);
break;
case AckType.RELEASED:
receiverLink.Release(message);
RemoveMessage(envelope);
break;
case AckType.MODIFIED_FAILED_UNDELIVERABLE:
receiverLink.Modify(message, true, true);
RemoveMessage(envelope);
break;
default:
Tracer.ErrorFormat("Unsupported Ack Type for message: {0}", envelope);
throw new ArgumentException($"Unsupported Ack Type for message: {envelope}");
}
}
else
{
Tracer.ErrorFormat($"Received Ack for unknown message: {envelope}");
}
}
private void RemoveMessage(InboundMessageDispatch envelope)
{
lock (syncRoot)
{
messages.Remove(envelope);
}
}
public void OnInboundMessage(InboundMessageDispatch envelope)
{
if (closed)
{
return;
}
listener.OnInboundMessage(envelope);
}
public void EnqueueFirst(InboundMessageDispatch envelope)
{
using (syncRoot.Lock())
{
lists[(int)MsgPriority.Highest].AddFirst(envelope);
count++;
syncRoot.Pulse();
}
}
public void TestDequeueZeroWhenQueueIsNotEmpty()
{
PriorityMessageQueue queue = new PriorityMessageQueue();
InboundMessageDispatch message = CreateEnvelope();
queue.EnqueueFirst(message);
Assert.False(queue.IsEmpty);
Assert.AreSame(message, queue.Dequeue(1));
}
public void AcknowledgeIndividual(AckType ackType, InboundMessageDispatch envelope)
{
if (Transacted)
{
throw new IllegalStateException("Message acknowledge called inside a transacted Session");
}
Connection.Acknowledge(envelope, ackType);
}
public void Enqueue(InboundMessageDispatch envelope)
{
lock (syncRoot)
{
GetList(envelope).AddLast(envelope);
this.count++;
Monitor.Pulse(syncRoot);
}
}
public void EnqueueFirst(InboundMessageDispatch envelope)
{
lock (syncRoot)
{
lists[(int)MsgPriority.Highest].AddFirst(envelope);
count++;
Monitor.Pulse(syncRoot);
}
}
public void Enqueue(InboundMessageDispatch envelope)
{
using (syncRoot.Lock())
{
GetList(envelope).AddLast(envelope);
this.count++;
syncRoot.Pulse();
}
}
private void SetAcknowledgeCallback(InboundMessageDispatch envelope)
{
if (acknowledgementMode == AcknowledgementMode.ClientAcknowledge)
{
envelope.Message.NmsAcknowledgeCallback = new NmsAcknowledgeCallback(Session);
}
else if (Session.AcknowledgementMode == AcknowledgementMode.IndividualAcknowledge)
{
envelope.Message.NmsAcknowledgeCallback = new NmsAcknowledgeCallback(Session, envelope);
}
}
private bool IsRedeliveryExceeded(InboundMessageDispatch envelope)
{
Tracer.DebugFormat("Checking envelope with {0} redeliveries", envelope.RedeliveryCount);
IRedeliveryPolicy redeliveryPolicy = Session.Connection.RedeliveryPolicy;
if (redeliveryPolicy != null && redeliveryPolicy.MaximumRedeliveries >= 0)
{
return(envelope.RedeliveryCount > redeliveryPolicy.MaximumRedeliveries);
}
return(false);
}
private void DoDequeueWaitsUntilMessageArrivesTestImpl(int timeout)
{
PriorityMessageQueue queue = new PriorityMessageQueue();
InboundMessageDispatch message = CreateEnvelope();
Task.Run(async() =>
{
await Task.Delay(TimeSpan.FromMilliseconds(100));
queue.Enqueue(message);
});
Assert.AreSame(message, queue.Dequeue(timeout));
}
private void AckFromReceive(InboundMessageDispatch envelope)
{
if (envelope?.Message != null)
{
NmsMessage message = envelope.Message;
if (message.NmsAcknowledgeCallback != null)
{
DoAckDelivered(envelope);
}
else
{
DoAckConsumed(envelope);
}
}
}
public Task Acknowledge(InboundMessageDispatch envelope, AckType ackType)
{
CheckClosed();
FailoverRequest request = new FailoverRequest(this, requestTimeout)
{
DoTask = activeProvider => activeProvider.Acknowledge(envelope, ackType),
FailureWhenOffline = true,
Name = nameof(Acknowledge)
};
request.Run();
return(request.Task);
}
public void TestEnqueueFirst()
{
PriorityMessageQueue queue = new PriorityMessageQueue();
InboundMessageDispatch message1 = CreateEnvelope();
InboundMessageDispatch message2 = CreateEnvelope();
InboundMessageDispatch message3 = CreateEnvelope();
queue.EnqueueFirst(message1);
queue.EnqueueFirst(message2);
queue.EnqueueFirst(message3);
Assert.AreSame(message3, queue.DequeueNoWait());
Assert.AreSame(message2, queue.DequeueNoWait());
Assert.AreSame(message1, queue.DequeueNoWait());
}
public void Acknowledge(InboundMessageDispatch envelope, AckType ackType)
{
if (envelope.Message.Facade is AmqpNmsMessageFacade facade)
{
global::Amqp.Message message = facade.Message;
switch (ackType)
{
case AckType.DELIVERED:
envelope.IsDelivered = true;
break;
case AckType.ACCEPTED:
AmqpTransactionContext transactionalState = session.TransactionContext;
if (transactionalState != null)
{
receiverLink.Complete(message, transactionalState.GetTxnAcceptState());
transactionalState.RegisterTxConsumer(this);
}
else
{
receiverLink.Accept(message);
}
RemoveMessage(envelope);
break;
case AckType.RELEASED:
receiverLink.Release(message);
RemoveMessage(envelope);
break;
case AckType.MODIFIED_FAILED_UNDELIVERABLE:
receiverLink.Modify(message, true, true);
RemoveMessage(envelope);
break;
default:
Tracer.Error($"Unsupported Ack Type for message: {envelope.Message}");
throw new ArgumentException($"Unsupported Ack Type for message: {envelope.Message}");
}
}
else
{
Tracer.ErrorFormat($"Received Ack for unknown message: {envelope}");
}
}
public void OnInboundMessage(InboundMessageDispatch envelope)
{
SetAcknowledgeCallback(envelope);
if (envelope.EnqueueFirst)
{
messageQueue.EnqueueFirst(envelope);
}
else
{
messageQueue.Enqueue(envelope);
}
if (Session.IsStarted && Listener != null)
{
Session.EnqueueForDispatch(deliveryTask);
}
}
public void TestRemoveFirst()
{
PriorityMessageQueue queue = new PriorityMessageQueue();
IEnumerable <InboundMessageDispatch> messages = CreateFullRangePrioritySet();
foreach (InboundMessageDispatch envelope in messages)
{
queue.Enqueue(envelope);
}
for (int i = (int)MsgPriority.Highest; i >= 0; i--)
{
InboundMessageDispatch first = queue.DequeueNoWait();
Assert.AreEqual(i, (int)first.Message.NMSPriority);
}
Assert.True(queue.IsEmpty);
}
private InboundMessageDispatch RemoveFirst()
{
if (count > 0)
{
for (int i = (int)MsgPriority.Highest; i >= 0; i--)
{
LinkedList <InboundMessageDispatch> list = lists[i];
if (list.Count > 0)
{
count--;
InboundMessageDispatch envelope = list.First.Value;
list.RemoveFirst();
return(envelope);
}
}
}
return(null);
}
public void OnInboundMessage(InboundMessageDispatch envelope)
{
if (Tracer.IsDebugEnabled)
{
Tracer.Debug($"Message {envelope.Message.NMSMessageId} passed to consumer {Info.Id}");
}
SetAcknowledgeCallback(envelope);
if (envelope.EnqueueFirst)
{
messageQueue.EnqueueFirst(envelope);
}
else
{
messageQueue.Enqueue(envelope);
}
if (Session.IsStarted && Listener != null)
{
Session.EnqueueForDispatch(deliveryTask);
}
}
public async Task Acknowledge(InboundMessageDispatch envelope, AckType ackType)
{
// Consumed or delivered messages fall into a transaction otherwise just pass it in.
if (ackType == AckType.ACCEPTED || ackType == AckType.DELIVERED)
{
try
{
await this.connection.Acknowledge(envelope, ackType).ConfigureAwait(false);
this.participants.Add(envelope.ConsumerId);
Tracer.Debug($"TX:{this.transactionInfo.Id} has performed an acknowledge.");
}
catch (Exception)
{
Tracer.Debug($"TX:{this.transactionInfo.Id} has failed an acknowledge.");
this.participants.Add(envelope.ConsumerId);
throw;
}
}
else
{
await this.connection.Acknowledge(envelope, ackType).ConfigureAwait(false);
}
}
private void HandleAccepted(InboundMessageDispatch envelope, global::Amqp.Message message)
{
Tracer.DebugFormat("Accepted Ack of message: {0}", envelope);
if (session.IsTransacted)
{
if (!session.IsTransactionFailed)
{
var transactionalState = session.TransactionContext;
receiverLink.Complete(message, transactionalState.GetTxnAcceptState());
transactionalState.RegisterTxConsumer(this);
}
else
{
Tracer.DebugFormat("Skipping ack of message {0} in failed transaction.", envelope);
}
}
else
{
receiverLink.Accept(message);
}
RemoveMessage(envelope);
}
private LinkedList <InboundMessageDispatch> GetList(InboundMessageDispatch envelope)
{
MsgPriority priority = envelope.Message.NMSPriority;
return(lists[(int)priority]);
}
public Task Acknowledge(InboundMessageDispatch envelope, AckType ackType)
{
throw new NotImplementedException();
}
