public void FailedPublish(IModel channel, BasicNackEventArgs args)
{
if (args == null)
{
throw new ArgumentNullException("args");
}
ProcessArgsAndRun(args.Multiple, args.DeliveryTag, x => x.Failure());
}
public void Should_mark_failure()
{
const int sequenceNumber = 34456;
channel.Stub(x => x.NextPublishSeqNo).Return(sequenceNumber);
var success = false;
var failure = false;
Action successCallback = () => success = true;
Action failureCallback = () => failure = true;
publisherConfirms.RegisterCallbacks(channel, successCallback, failureCallback);
var args = new BasicNackEventArgs
{
DeliveryTag = sequenceNumber,
Multiple = false
};
publisherConfirms.FailedPublish(channel, args);
success.ShouldBeFalse();
failure.ShouldBeTrue();
}
protected override void OnBrokerRejectedMessage(IModel model, BasicNackEventArgs args)
{
OnBrokerRejectedMessageIsCall = true;
}
private void PublishModelOnBasicNacks(IModel model, BasicNackEventArgs args)
{
if (args.Multiple)
log.WarnFormat("Broker nacked all deliveries up to and including #{0}", args.DeliveryTag);
else
log.WarnFormat("Broker nacked delivery #{0}", args.DeliveryTag);
}
public void Should_mark_success_up_to_sequence_number_when_multiple_is_true()
{
const string expectedOutput = "Success0 Success1 Success2 Success3 Success4 Success5 --multiple ack of 5 complete --Failure6 Failure7 Failure8 ";
var writer = new StringWriter();
//var writer = Console.Out;
Action<ulong> registerCallback = sequenceNumber =>
{
var model = MockRepository.GenerateStub<IModel>();
model.Stub(x => x.NextPublishSeqNo).Return(sequenceNumber);
publisherConfirms.RegisterCallbacks(model,
() => writer.Write("Success{0} ", sequenceNumber),
() => writer.Write("Failure{0} ", sequenceNumber));
};
for (ulong i = 0; i < 10; i++)
{
registerCallback(i);
}
var args = new BasicAckEventArgs
{
DeliveryTag = 5, // should callback success up to and including seq no 5
Multiple = true
};
publisherConfirms.SuccessfulPublish(channel, args);
writer.Write("--multiple ack of 5 complete --");
var args2 = new BasicNackEventArgs
{
DeliveryTag = 8, // should callback failure for 6, 7, 8
Multiple = true
};
publisherConfirms.FailedPublish(channel, args2);
writer.ToString().ShouldEqual(expectedOutput);
}
private void OnChannelNack(
IModel channel,
BasicNackEventArgs args)
{
TaskCompletionSource<string> _taskCompletionSource;
var _confirmedDeliveryTags = this.c_unconfirmedMessages.Keys.Where(deliveryTag => deliveryTag <= args.DeliveryTag);
foreach (var _confirmedDeliveryTag in _confirmedDeliveryTags)
{
if (!this.c_unconfirmedMessages.TryRemove(_confirmedDeliveryTag, out _taskCompletionSource))
{
throw new ApplicationException("Could not remove delivery tag entry");
}
_taskCompletionSource.SetResult((string)_taskCompletionSource.Task.AsyncState);
}
}
public void HandleBasicNack(ulong deliveryTag,
bool multiple,
bool requeue)
{
BasicNackEventArgs e = new BasicNackEventArgs();
e.DeliveryTag = deliveryTag;
e.Multiple = multiple;
e.Requeue = requeue;
OnBasicNack(e);
}
void OnBasicNacks(object model, BasicNackEventArgs args)
{
if (args.Multiple)
{
ulong[] ids = _published.Keys.Where(x => x <= args.DeliveryTag).ToArray();
foreach (var id in ids)
{
PendingPublish value;
if (_published.TryRemove(id, out value))
value.Nack();
}
}
else
{
PendingPublish value;
if (_published.TryRemove(args.DeliveryTag, out value))
value.Nack();
}
}
public virtual void OnBasicNack(BasicNackEventArgs args)
{
EventHandler<BasicNackEventArgs> handler;
lock (m_eventLock)
{
handler = m_basicNack;
}
if (handler != null)
{
foreach (EventHandler<BasicNackEventArgs> h in handler.GetInvocationList())
{
try
{
h(this, args);
}
catch (Exception e)
{
OnCallbackException(CallbackExceptionEventArgs.Build(e, "OnBasicNack"));
}
}
}
handleAckNack(args.DeliveryTag, args.Multiple, true);
}
protected override void OnModelBasicNacks(Object sender, BasicNackEventArgs args)
{
base.OnModelBasicNacks(sender, args);
_log.Info($"consumer-model basic.nack received (delivery-tag: {args.DeliveryTag}, multiple: {args.Multiple})");
}
private void ModelOnBasicNacks(IModel model, BasicNackEventArgs args)
{
MarkAsConfirmed(args.DeliveryTag, args.Multiple);
}
private void ModelOnBasicNacks(object sender, BasicNackEventArgs e)
{
_logger.Debug($"Nack, tag: {e.DeliveryTag}, multiple: {e.Multiple}");
Nack?.Invoke(this, e);
}
private void OnNack(object sender, BasicNackEventArgs args)
{
eventBus.Publish(MessageConfirmationEvent.Nack((IModel)sender, args.DeliveryTag, args.Multiple));
}
protected override void OnBrokerRejectedMessage(object sender, BasicNackEventArgs args)
{
OnBrokerRejectedMessageIsCall = true;
}
private void ModelOnBasicNacks(object model, BasicNackEventArgs e)
{
HandleConfirm(e.DeliveryTag, e.Multiple, x => x.OnNack());
}
private void ModelOnBasicNacks(IModel model, BasicNackEventArgs args)
{
HandleConfirm(args.DeliveryTag, args.Multiple, x => x.OnNack());
}
public void FailedPublish(IModel channel, BasicNackEventArgs args)
{
Preconditions.CheckNotNull(args, "args");
ProcessArgsAndRun(args.Multiple, args.DeliveryTag, x => x.Failure());
}
protected virtual void OnModelBasicNacks(Object sender, BasicNackEventArgs args) { }
public virtual void OnBasicNack(BasicNackEventArgs args)
{
m_delegate.OnBasicNack(args);
}
private void BasicNackEventHandler(object sender, BasicNackEventArgs e)
{
this.BasicNacks?.Invoke(sender, e);
}
public virtual void OnBasicNack(BasicNackEventArgs args)
{
BasicNackEventHandler handler;
lock (m_eventLock)
{
handler = m_basicNack;
}
if (handler != null)
{
foreach (BasicNackEventHandler h in handler.GetInvocationList()) {
try {
h(this, args);
} catch (Exception e) {
CallbackExceptionEventArgs exnArgs = new CallbackExceptionEventArgs(e);
exnArgs.Detail["context"] = "OnBasicNack";
OnCallbackException(exnArgs);
}
}
}
handleAckNack(args.DeliveryTag, args.Multiple, true);
}
private void OnChannelNack(
IModel channel,
BasicNackEventArgs args)
{
// Todo
}
/// <summary>
/// CONFIRM mode - sent when
/// used to nack publisher confirm
/// </summary>
/// <param name="model"></param>
/// <param name="args"></param>
protected virtual void Channel_BasicNacks( IModel model, BasicNackEventArgs args )
{
this.Tracer.TraceEvent ( System.Diagnostics.TraceEventType.Error, 0, "[{0}] bus nack error, delivery tag {1}, multiple {2}, requeue {3} ", this, args.DeliveryTag, args.Multiple, args.Requeue );
//SUPPORT multi confirm mode
TaskCompletionSource<int> tcs;
if (this.ConfirmTaskCompletions.TryRemove ( args.DeliveryTag, out tcs ))
{
//standarize on error codes what does it mean to return -1???
tcs.SetResult ( -1 );
//react depending on the reason: reconnect or discharge all pending RPC requests
}
}
private void OnChannelNacked(
IModel channel,
BasicNackEventArgs args)
{
this.c_logger.DebugFormat("OnChannelNacked Starting, is multiple = {0} and delivery tag = {1}", args.Multiple, args.DeliveryTag);
this.ProcessDeliveryTags(
args.Multiple,
args.DeliveryTag,
publication => publication.SetResult(PublicationResultStatus.Nacked));
this.c_logger.DebugFormat("OnChannelNacked Completed, is multiple = {0} and delivery tag = {1}", args.Multiple, args.DeliveryTag);
}
