private void OnPublishSucceeded(object sender, BasicAckEventArgs e)
{
if (_pendingConfirmations.TryGetValue(e.DeliveryTag, out Guid messageId))
{
OnMessagePublished?.Invoke(true, messageId);
_pendingConfirmations.TryRemove(e.DeliveryTag, out Guid msgId);
s_logger.LogInformation("Published message: {MessageId}", messageId);
}
}
private void BasicAcks(object sender, BasicAckEventArgs args)
{
foreach (var seqNo in _pending.Keys)
{
if (IsMatch(args.DeliveryTag, args.Multiple, seqNo) && _pending.TryRemove(seqNo, out var tcs))
{
tcs.TrySetResult(null);
}
}
}
private void BasicAcks(IModel model, BasicAckEventArgs args)
{
foreach (ulong seqNo in GetSeqNos(args.DeliveryTag, args.Multiple))
{
TaskCompletionSource <object> tcs;
if (_pending.TryRemove(seqNo, out tcs))
{
tcs.TrySetResult(null);
}
}
}
public void Handler(object sender, BasicAckEventArgs e, IPublishedMessageStore publishedMessageStore)
{
using (var tx = publishedMessageStore.BeginTransaction())
{
RmqPublishMessage targetMessage = publishedMessageStore.GetByDeliveryTag(e.DeliveryTag);
targetMessage.Status = MessageStatusConstants.Success;
publishedMessageStore.Commit(tx);
}
}
private void AckCallback <T>(BasicAckEventArgs ea, MessageTracker <T> messageTracker)
{
if (ea.Multiple)
{
messageTracker.SetMultipleStatus(ea.DeliveryTag, SendStatus.Success);
}
else
{
messageTracker.SetStatus(ea.DeliveryTag, SendStatus.Success);
}
}
private void OnChannelAcked(
BasicAckEventArgs args)
{
this.c_logger.DebugFormat("OnChannelAcked Starting, is multiple = {0} and delivery tag = {1}", args.Multiple, args.DeliveryTag);
this.ProcessDeliveryTags(
args.Multiple,
args.DeliveryTag,
publication => publication.SetResult(PublicationResultStatus.Acked));
this.c_logger.DebugFormat("OnChannelAcked Completed, is multiple = {0} and delivery tag = {1}", args.Multiple, args.DeliveryTag);
}
private void BasicAcksHandler(object sender, BasicAckEventArgs args)
{
//if (!(sender is IModel channel)) return;
//foreach (ProducerChannel producer in ProducerChannels)
//{
// if (producer.Channel.ChannelNumber == channel.ChannelNumber)
// {
// producer.CurrentDeliveryTag = args.DeliveryTag;
// break;
// }
//}
}
private void OnChannelAck(
IModel channel,
BasicAckEventArgs args)
{
var _removedMessage = string.Empty;
var _confirmedDeliveryTags = this.c_unconfirmedMessages.Keys.Where(deliveryTag => deliveryTag <= args.DeliveryTag);
foreach (var _confirmedDeliveryTag in _confirmedDeliveryTags)
{
if (!this.c_unconfirmedMessages.TryRemove(_confirmedDeliveryTag, out _removedMessage))
{
throw new ApplicationException("Could not remove delivery tag entry");
}
}
}
void HandleAck(IModel model, BasicAckEventArgs args)
{
#if NET40
IEnumerable <ulong> ids = Enumerable.Repeat(args.DeliveryTag, 1);
if (args.Multiple)
{
ids = _confirms.GetAllKeys().Where(x => x <= args.DeliveryTag);
}
foreach (ulong id in ids)
{
_confirms[id].TrySetResult(true);
_confirms.Remove(id);
}
#endif
}
private void OnChannelAck(
IModel channel,
BasicAckEventArgs args)
{
this.c_writeLog(string.Format("On channel ack : Is multiple {0}, delivery tag {1}", args.Multiple, args.DeliveryTag));
var _confirmedDeliveryTags = this.c_unconfirmedMessages.Keys.Where(deliveryTag => deliveryTag <= args.DeliveryTag); // Linq perf here ?
var _removedMessage = string.Empty;
foreach (var _confirmedDeliveryTag in _confirmedDeliveryTags)
{
if (!this.c_unconfirmedMessages.TryRemove(_confirmedDeliveryTag, out _removedMessage))
{
throw new ApplicationException("Could not remove delivery tag entry");
}
}
}
private void OnChannelAck(
IModel channel,
BasicAckEventArgs 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);
}
}
void Channel_BasicAcks(object sender, BasicAckEventArgs e)
{
if (!e.Multiple)
{
SetResult(e.DeliveryTag);
}
else
{
foreach (var message in messages)
{
if (message.Key <= e.DeliveryTag)
{
SetResult(message.Key);
}
}
}
}
private void HandleAck(IModel model, BasicAckEventArgs args)
{
var confirmIds = GetConfirmIds(args.DeliveryTag, args.Multiple);
if (confirmIds.Count > 0)
{
if (InTestNackMode)
{
_testNackCount += confirmIds.Count;
_publisherConfirmSettings.Nacktion(confirmIds);
}
else
{
_publisherConfirmSettings.Acktion(confirmIds);
}
}
}
// 说明：broker正常接受到消息，会触发该ack事件
private void Channel_BasicAcks(object sender, BasicAckEventArgs e)
{
/*
* the broker may also set the multiple field in basic.ack to indicate
* that all messages up to and including the one with the sequence number
* have been handled.
*/
// 说明：如这里的备注信息，因此我们需要区别处理e.Multiple的两种情况；
// 另外，在手动等待confirm的模式中我们可以直接调用waitForConfirms(timeout)，
// 放到这里基于事件回调的方式下timeout还是有一定意义的，可以考虑自己实现
if (e.Multiple)
{
_tracker.SetMultipleStatus(e.DeliveryTag, MessageState.Confirmed);
}
else
{
_tracker.SetStatus(e.DeliveryTag, MessageState.Confirmed);
}
}
private void BasicAcksHandler(object sender, BasicAckEventArgs args)
{
if (!(sender is IModel channel))
{
return;
}
foreach (JobInfo job in LIST_OF_JOBS)
{
if (job.Channel.ChannelNumber == channel.ChannelNumber)
{
if (channel.NextPublishSeqNo == args.DeliveryTag + 1)
{
// Send signal to ExecuteJobInBackground procedure
job.ConfirmEvent.Set();
}
break;
}
}
}
void OnBasicAcks(object model, BasicAckEventArgs args)
{
if (args.Multiple)
{
ulong[] ids = _published.Keys.Where(x => x <= args.DeliveryTag).ToArray();
foreach (var id in ids)
{
if (_published.TryRemove(id, out var value))
{
value.Ack();
}
}
}
else
{
if (_published.TryRemove(args.DeliveryTag, out var value))
{
value.Ack();
}
}
}
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);
}
// broker正常接受到消息，会触发该ack事件
private void Channel_BasicAcks(object sender, BasicAckEventArgs e)
{
// 数据更新该条消息的状态信息
long msgHash = 0;
if (_unconfirm.TryGetValue(e.DeliveryTag, out msgHash))
{
var ok = _message_queue_helper.Update(
msgHash,
fromStatus1: MsgStatus.Created, // 之前的状态只能是1 Created 或者2 Retry
fromStatus2: MsgStatus.Retrying,
toStatus: MsgStatus.ArrivedBroker);
if (ok)
{
_unconfirm.Remove(e.DeliveryTag);
}
else
{
throw new Exception("数据库update出现异常");
}
}
}
private void PublishModelOnBasicAcks(IModel model, BasicAckEventArgs args)
{
IUnconfirmedDeliveryFactory _;
if (args.Multiple)
{
log.DebugFormat("Broker confirmed all deliveries up to and including #{0}", args.DeliveryTag);
var toRemove = unconfirmedCommands.Keys.Where(tag => tag <= args.DeliveryTag).ToArray();
foreach (var tag in toRemove)
{
unconfirmedCommands.TryRemove(tag, out _);
}
}
else
{
log.DebugFormat("Broker confirmed delivery #{0}", args.DeliveryTag);
unconfirmedCommands.TryRemove(args.DeliveryTag, out _);
}
log.DebugFormat("Left to be confirmed: {0}", unconfirmedCommands.Count);
}
private void ConfirmChannel_BasicAcks(object sender, BasicAckEventArgs args)
{
string fileName;
lock (_ConfirmMessagesWaitingAck)
{
if (args.Multiple)
{
for (ulong index = args.DeliveryTag; index > 0; index--)
{
if (_ConfirmMessagesWaitingAck.TryGetValue(index, out fileName))
{
_ConfirmMessagesWaitingAck.Remove(index);
DeleteMessageFile(fileName);
}
else
{
break;
}
}
_LastConfirmSeqNo = args.DeliveryTag + 1;
}
else
{
if (_ConfirmMessagesWaitingAck.TryGetValue(args.DeliveryTag, out fileName))
{
_ConfirmMessagesWaitingAck.Remove(args.DeliveryTag);
DeleteMessageFile(fileName);
}
if (_LastConfirmSeqNo == args.DeliveryTag)
{
_LastConfirmSeqNo = args.DeliveryTag + 1;
}
}
}
}
public void SuccessfulPublish(IModel channel, BasicAckEventArgs args)
{
Preconditions.CheckNotNull(args, "args");
ProcessArgsAndRun(args.Multiple, args.DeliveryTag, x => x.Success());
}
internal void CallOnModelBasicAcks(BasicAckEventArgs args)
{
OnModelBasicAcks(null, args);
}
/// <summary>
/// Handles the BasicAcks event of the Channel control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="BasicAckEventArgs"/> instance containing the event data.</param>
private void Channel_BasicAcks(object sender, BasicAckEventArgs e)
{
}
public virtual void OnBasicAck(BasicAckEventArgs args)
{
m_delegate.OnBasicAck(args);
}
protected virtual void OnModelBasicAcks(Object sender, BasicAckEventArgs args)
{
}
protected override void OnModelBasicAcks(Object sender, BasicAckEventArgs args)
{
base.OnModelBasicAcks(sender, args);
_log.Info($"consumer-model basic.ack received (delivery-tag: {args.DeliveryTag}, multiple: {args.Multiple})");
}
public void OnBasicAck(BasicAckEventArgs args)
{
_delegate.OnBasicAck(args);
}
private static void ReceiveDeliveryTagFromRabbitMq(object sender, BasicAckEventArgs e)
{
m_deliveryTagReceived = (int)e.DeliveryTag;
}
public void Acknowledge(object sender, BasicAckEventArgs e)
{
this.logger.LogInformation($"Message acknowledged. Sequence number: {e.DeliveryTag}, multiple: {e.Multiple}");
this.CleanOutstandingConfirms(e.DeliveryTag, e.Multiple);
}
public void MessageAck(BasicAckEventArgs info)
{
_ackQueue.Ack(info.DeliveryTag, info.Multiple);
}
