public Message(TData payload, DeliveryInfo deliveryInfo, Ack ack, Nack nack)
{
Payload = payload ?? throw new ArgumentNullException(nameof(payload));
DeliveryInfo = deliveryInfo ?? throw new ArgumentNullException(nameof(deliveryInfo));
this.ack = ack ?? throw new ArgumentNullException(nameof(ack));
this.nack = nack ?? throw new ArgumentNullException(nameof(nack));
}
public SerializedPayload NewNack(Guid messageId)
{
var payload = new Nack
{
Id = messageId
};
return(_serializer.Serialize(payload));
}
private void OnMessageNack(Guid clientId, Nack nack)
{
_logger.LogInformation($"Nack received for message with id: {nack.Id} from client: {clientId}");
if (_clientStore.TryGet(clientId, out var client))
{
client.OnPayloadNackReceived(nack.Id);
}
}
public void Serialization_NackMatchResults()
{
var nack = new Nack {
Id = Guid.NewGuid()
};
var b = _serializer.Serialize(nack);
var result = _deserializer.ToNack(b.DataWithoutSize);
Assert.Equal(nack.Id, result.Id);
}
public SerializedPayload Serialize(Nack ack)
{
var binaryWriter = ObjectPool.Shared.Rent <BinaryProtocolWriter>();
try
{
return(binaryWriter
.WriteType(PayloadType.Nack)
.WriteId(ack.Id)
.ToSerializedPayload());
}
finally
{
ObjectPool.Shared.Return(binaryWriter);
}
}
/// <summary>
/// Оповестить брокер о результате обработки.
/// </summary>
/// <param name="acknowledgement">Данные о результате обработки.</param>
/// <param name="channel">Канал.</param>
/// <param name="messageContext">Контекст сообщения.</param>
/// <param name="settings">Настройки очереди.</param>
public Task HandleAsync <TMessage>(
Acknowledgement acknowledgement,
IModel channel,
MessageContext messageContext,
SubscriberSettings settings
) where TMessage : class, IMessage
{
return(acknowledgement switch
{
Ack _ => HandleAck(channel, messageContext, settings),
Reject reject => HandleRejectAsync <TMessage>(reject, channel, messageContext, settings),
Nack nack => HandleNackAsync <TMessage>(nack, channel, messageContext, settings),
Retry retry => HandleRetryAsync <TMessage>(retry, channel, messageContext, settings),
_ => throw new ArgumentOutOfRangeException(
nameof(acknowledgement),
typeof(Acknowledgement),
"Передан неизвестный подтип Acknowledgement."
)
});
public void OnUpdate()
{
if (this.LastUpdateTime < 0)
{
this.Disconnect("timedout");
return;
}
if (this.ACKQueue.Count > 0)
{
Ack pk = new Ack();
List <int> pks = new List <int>();
foreach (KeyValuePair <int, int> kv in this.ACKQueue.ToArray())
{
pks.Add(kv.Value);
}
pks.Sort();
pk.Packets = pks.ToArray();
this.SendPacket(pk);
this.ACKQueue.Clear();
}
if (this.NACKQueue.Count > 0)
{
Nack pk = new Nack();
List <int> pks = new List <int>();
foreach (KeyValuePair <int, int> kv in this.NACKQueue.ToArray())
{
pks.Add(kv.Value);
}
pks.Sort();
pk.Packets = pks.ToArray();
this.SendPacket(pk);
this.NACKQueue.Clear();
}
if (this.ResendQueue.Count > 0)
{
for (int i = 0; i < this.ResendQueue.Count; ++i)
{
DataPacket pk;
this.ResendQueue.TryDequeue(out pk);
pk.SeqNumber = this.LastSendSeqNumber++;
this.SendPacket(pk);
Logger.Debug("%server.network.dataPacket.resend");
}
}
if (this.SendedPacket.Count > 0)
{
foreach (DataPacket pk in this.SendedPacket.Values)
{
if (pk.SendTimedOut < 0)
{
DataPacket remove;
this.ResendQueue.Enqueue(pk);
this.SendedPacket.TryRemove(pk.SeqNumber, out remove);
}
--pk.SendTimedOut;
}
}
if (this.LastPingTime < 0)
{
OnlinePing ping = new OnlinePing();
ping.PingID = DateTime.Now.Ticks;
this.QueueConnectedPacket(ping, RakNetPacketReliability.UNRELIABLE, -1, RakNetProtocol.FlagImmediate);
}
this.SendQueuePacket();
--this.LastPingTime;
--this.LastUpdateTime;
}
internal WithNackElse(Nack nk, Else xE) : base(xE.pk)
{
this.nk = nk;
this.xE = xE;
}
protected virtual void HandleNack(Nack nack, IModel channel, BasicDeliverEventArgs deliveryArgs)
{
channel.BasicNack(deliveryArgs.DeliveryTag, false, nack.Requeue);
}
