public static PubCompPacket InResponseTo(PubRelPacket publishPacket)
{
return(new PubCompPacket
{
PacketId = publishPacket.PacketId
});
}
IEnumerable <TestScenarioStep> GetPart2SpecificSteps(Func <object> currentMessageFunc)
{
yield return(TestScenarioStep.ReadMore());
var packets = new Packet[2];
for (int i = packets.Length - 1; i >= 0; i--)
{
packets[i] = Assert.IsAssignableFrom <Packet>(currentMessageFunc());
if (i > 0)
{
yield return(TestScenarioStep.ReadMore());
}
}
PublishPacket qos1Packet = Assert.Single(packets.OfType <PublishPacket>());
Assert.Equal(QualityOfService.AtLeastOnce, qos1Packet.QualityOfService);
this.AssertPacketCoreValue(qos1Packet, Encoding.ASCII.GetString(qos1Packet.Payload.ToArray()));
PubRelPacket pubRelQos2Packet = Assert.Single(packets.OfType <PubRelPacket>());
yield return(TestScenarioStep.Write(
false,
PubAckPacket.InResponseTo(qos1Packet),
PubCompPacket.InResponseTo(pubRelQos2Packet),
DisconnectPacket.Instance));
}
public static PubCompPacket InResponseTo(PubRelPacket publishPacket)
{
return new PubCompPacket
{
PacketId = publishPacket.PacketId
};
}
/// <summary>
/// Sends the pub relative.
/// </summary>
/// <param name="channel">The channel.</param>
/// <param name="messageId">The message identifier.</param>
public async Task SendPubRel(IChannel channel, int messageId)
{
var mqttPubAckMessage = new PubRelPacket
{
PacketId = messageId
};
await channel.WriteAndFlushAsync(mqttPubAckMessage);
}
public async Task PubRel(IChannelHandlerContext context, PubRelPacket packet)
{
int messageId = packet.PacketId;
var mqttChannel = _channelService.GetMqttChannel(await _channelService.GetDeviceId(context.Channel));
var message = mqttChannel.GetMqttMessage(messageId);
message.ConfirmStatus = ConfirmStatus.PUBREL;
await _channelService.Pubrec(mqttChannel, messageId);
}
Task PublishReleaseToClientAsync(IChannelHandlerContext context, int packetId, MessageFeedbackChannel feedbackChannel,
IQos2MessageDeliveryState messageState, PreciseTimeSpan startTimestamp)
{
var pubRelPacket = new PubRelPacket();
pubRelPacket.PacketId = packetId;
return(this.pubRelPubCompProcessor.SendRequestAsync(context, pubRelPacket,
new CompletionPendingMessageState(packetId, messageState, startTimestamp, feedbackChannel)));
}
protected void PubRelAck(SendMqttMessage mqttMessage)
{
PubRelPacket mqttPubAckMessage = new PubRelPacket()
{
PacketId = mqttMessage.MessageId,
};
mqttMessage.Channel.WriteAndFlushAsync(mqttPubAckMessage);
}
bool TryDecodePacket(IChannelHandlerContext context, IByteBuffer buffer, out Packet packet)
{
if (!buffer.IsReadable(2))
{
packet = null;
return(false);
}
byte signature = buffer.ReadByte();
if (!TryDecodeRemainingLength(buffer, out int remainingLength) || !buffer.IsReadable(remainingLength))
{
packet = null;
return(false);
}
var fixedHeader = new FixedHeader(signature, remainingLength);
switch (fixedHeader.PacketType)
{
case PacketType.CONNECT: packet = new ConnectPacket(); break;
case PacketType.CONNACK: packet = new ConnAckPacket(); break;
case PacketType.DISCONNECT: packet = new DisconnectPacket(); break;
case PacketType.PINGREQ: packet = new PingReqPacket(); break;
case PacketType.PINGRESP: packet = new PingRespPacket(); break;
case PacketType.PUBACK: packet = new PubAckPacket(); break;
case PacketType.PUBCOMP: packet = new PubCompPacket(); break;
case PacketType.PUBLISH: packet = new PublishPacket(); break;
case PacketType.PUBREC: packet = new PubRecPacket(); break;
case PacketType.PUBREL: packet = new PubRelPacket(); break;
case PacketType.SUBSCRIBE: packet = new SubscribePacket(); break;
case PacketType.SUBACK: packet = new SubAckPacket(); break;
case PacketType.UNSUBSCRIBE: packet = new UnsubscribePacket(); break;
case PacketType.UNSUBACK: packet = new UnsubscribePacket(); break;
default:
throw new DecoderException("Unsupported Message Type");
}
packet.FixedHeader = fixedHeader;
packet.Decode(buffer);
return(true);
}
Task PublishReleaseToClientAsync(IChannelHandlerContext context, int packetId, string lockToken,
IQos2MessageDeliveryState messageState, PreciseTimeSpan startTimestamp)
{
var pubRelPacket = new PubRelPacket
{
PacketId = packetId
};
return(this.pubRelPubCompProcessor.SendRequestAsync(context, pubRelPacket,
new CompletionPendingMessageState(packetId, lockToken, messageState, startTimestamp)));
}
public void OnPubRel(IChannelHandlerContext context, PubRelPacket packet)
{
if (pendingIncomingQoS2Publishes.ContainsKey(packet.PacketId))
{
var qos2Publish = pendingIncomingQoS2Publishes[packet.PacketId];
publishCallback(qos2Publish.PublishPacket);
qos2Publish.OnPubRelReceived();
pendingIncomingQoS2Publishes.TryRemove(packet.PacketId, out _);
}
context.WriteAndFlushAsync(PubCompPacket.InResponseTo(packet));
}
async void RetransmitNextPublishRelease(IChannelHandlerContext context, CompletionPendingMessageState messageInfo)
{
try
{
var packet = new PubRelPacket
{
PacketId = messageInfo.PacketId
};
await this.pubRelPubCompProcessor.RetransmitAsync(context, packet, messageInfo);
}
catch (Exception ex)
{
ShutdownOnError(context, "<- PUBREL (retransmission)", ex);
}
}
public void OnPubRec(IChannelHandlerContext context, PubRecPacket packet)
{
pendingPublishes.TryGetValue(packet.PacketId, out PendingPublish pendingPublish);
if (pendingPublish == null)
{
return;
}
pendingPublish.OnPubAckReceived();
var pubRelPacket = PubRelPacket.InResponseTo(packet);
context.WriteAndFlushAsync(pubRelPacket);
pendingPublish.SetPubRelPacket(pubRelPacket);
pendingPublish.RetransmitPubRel(eventLoopGroup.GetNext(), sendAndFlushAsync);
}
Packet DecodePacketInternal(IByteBuffer buffer, byte packetSignature, ref int remainingLength)
{
Packet packet;
var fixedHeader = new FixedHeader(packetSignature, remainingLength);
switch (fixedHeader.PacketType)
{
case PacketType.CONNECT: packet = new ConnectPacket(); break;
case PacketType.CONNACK: packet = new ConnAckPacket(); break;
case PacketType.DISCONNECT: packet = new DisconnectPacket(); break;
case PacketType.PINGREQ: packet = new PingReqPacket(); break;
case PacketType.PINGRESP: packet = new PingRespPacket(); break;
case PacketType.PUBACK: packet = new PubAckPacket(); break;
case PacketType.PUBCOMP: packet = new PubCompPacket(); break;
case PacketType.PUBLISH: packet = new PublishPacket(); break;
case PacketType.PUBREC: packet = new PubRecPacket(); break;
case PacketType.PUBREL: packet = new PubRelPacket(); break;
case PacketType.SUBSCRIBE: packet = new SubscribePacket(); break;
case PacketType.SUBACK: packet = new SubAckPacket(); break;
case PacketType.UNSUBSCRIBE: packet = new UnsubscribePacket(); break;
case PacketType.UNSUBACK: packet = new UnsubscribePacket(); break;
default:
throw new DecoderException("Unsupported Message Type");
}
packet.FixedHeader = fixedHeader;
packet.Decode(buffer);
remainingLength = packet.RemaingLength;
return(packet);
}
async Task GetPart2SpecificSteps(IChannel channel, ReadListeningHandler readHandler)
{
var packets = new Packet[2];
for (int i = packets.Length - 1; i >= 0; i--)
{
packets[i] = Assert.IsAssignableFrom<Packet>(await readHandler.ReceiveAsync());
}
PublishPacket qos1Packet = Assert.Single(packets.OfType<PublishPacket>());
Assert.Equal(QualityOfService.AtLeastOnce, qos1Packet.QualityOfService);
this.AssertPacketCoreValue(qos1Packet, Encoding.ASCII.GetString(qos1Packet.Payload.ToArray()));
PubRelPacket pubRelQos2Packet = Assert.Single(packets.OfType<PubRelPacket>());
await channel.WriteAndFlushManyAsync(
PubAckPacket.InResponseTo(qos1Packet),
PubCompPacket.InResponseTo(pubRelQos2Packet),
DisconnectPacket.Instance);
}
private void ProcessMessage(IChannel channel, PubRecPacket message)
{
var packet = new PubRelPacket(message.VariableHeader.PacketIdentifier);
channel.WriteAndFlushAsync(packet);
}
public void SetPubRelPacket(PubRelPacket pubRelPacket)
{
pubRelRetransmissionAction.OriginalPacket = pubRelPacket;
}
Packet DecodePacketInternal(IByteBuffer buffer, int packetSignature, ref int remainingLength, IChannelHandlerContext context)
{
if (Signatures.IsPublish(packetSignature))
{
var qualityOfService = (QualityOfService)((packetSignature >> 1) & 0x3); // take bits #1 and #2 ONLY and convert them into QoS value
if (qualityOfService == QualityOfService.Reserved)
{
throw new DecoderException($"Unexpected QoS value of {(int)qualityOfService} for {PacketType.PUBLISH} packet.");
}
bool duplicate = (packetSignature & 0x8) == 0x8; // test bit#3
bool retain = (packetSignature & 0x1) != 0; // test bit#0
var packet = new PublishPacket(qualityOfService, duplicate, retain);
DecodePublishPacket(buffer, packet, ref remainingLength);
return(packet);
}
switch (packetSignature) // strict match checks for valid message type + correct values in flags part
{
case Signatures.PubAck:
var pubAckPacket = new PubAckPacket();
DecodePacketIdVariableHeader(buffer, pubAckPacket, ref remainingLength);
return(pubAckPacket);
case Signatures.PubRec:
var pubRecPacket = new PubRecPacket();
DecodePacketIdVariableHeader(buffer, pubRecPacket, ref remainingLength);
return(pubRecPacket);
case Signatures.PubRel:
var pubRelPacket = new PubRelPacket();
DecodePacketIdVariableHeader(buffer, pubRelPacket, ref remainingLength);
return(pubRelPacket);
case Signatures.PubComp:
var pubCompPacket = new PubCompPacket();
DecodePacketIdVariableHeader(buffer, pubCompPacket, ref remainingLength);
return(pubCompPacket);
case Signatures.PingReq:
this.ValidateServerPacketExpected(packetSignature);
return(PingReqPacket.Instance);
case Signatures.Subscribe:
this.ValidateServerPacketExpected(packetSignature);
var subscribePacket = new SubscribePacket();
DecodePacketIdVariableHeader(buffer, subscribePacket, ref remainingLength);
DecodeSubscribePayload(buffer, subscribePacket, ref remainingLength);
return(subscribePacket);
case Signatures.Unsubscribe:
this.ValidateServerPacketExpected(packetSignature);
var unsubscribePacket = new UnsubscribePacket();
DecodePacketIdVariableHeader(buffer, unsubscribePacket, ref remainingLength);
DecodeUnsubscribePayload(buffer, unsubscribePacket, ref remainingLength);
return(unsubscribePacket);
case Signatures.Connect:
this.ValidateServerPacketExpected(packetSignature);
var connectPacket = new ConnectPacket();
DecodeConnectPacket(buffer, connectPacket, ref remainingLength, context);
return(connectPacket);
case Signatures.Disconnect:
this.ValidateServerPacketExpected(packetSignature);
return(DisconnectPacket.Instance);
case Signatures.ConnAck:
this.ValidateClientPacketExpected(packetSignature);
var connAckPacket = new ConnAckPacket();
DecodeConnAckPacket(buffer, connAckPacket, ref remainingLength);
return(connAckPacket);
case Signatures.SubAck:
this.ValidateClientPacketExpected(packetSignature);
var subAckPacket = new SubAckPacket();
DecodePacketIdVariableHeader(buffer, subAckPacket, ref remainingLength);
DecodeSubAckPayload(buffer, subAckPacket, ref remainingLength);
return(subAckPacket);
case Signatures.UnsubAck:
this.ValidateClientPacketExpected(packetSignature);
var unsubAckPacket = new UnsubAckPacket();
DecodePacketIdVariableHeader(buffer, unsubAckPacket, ref remainingLength);
return(unsubAckPacket);
case Signatures.PingResp:
this.ValidateClientPacketExpected(packetSignature);
return(PingRespPacket.Instance);
default:
throw new DecoderException($"First packet byte value of `{packetSignature}` is invalid.");
}
}
public abstract void PubRel(IChannelHandlerContext context, PubRelPacket packet);
private void ProcessMessage(IChannel channel, PubRelPacket message)
{
}
Packet DecodePacketInternal(IByteBuffer buffer, int packetSignature, ref int remainingLength, IChannelHandlerContext context)
{
if (Signatures.IsPublish(packetSignature))
{
var qualityOfService = (QualityOfService)((packetSignature >> 1) & 0x3); // take bits #1 and #2 ONLY and convert them into QoS value
if (qualityOfService == QualityOfService.Reserved)
{
ThrowHelper.ThrowDecoderException_UnexpectedQoSValueForPublish(qualityOfService);
}
bool duplicate = (packetSignature & 0x8) == 0x8; // test bit#3
bool retain = (packetSignature & 0x1) != 0; // test bit#0
var packet = new PublishPacket(qualityOfService, duplicate, retain);
DecodePublishPacket(buffer, packet, ref remainingLength);
return(packet);
}
switch (packetSignature) // strict match checks for valid message type + correct values in flags part
{
case Signatures.PubAck:
var pubAckPacket = new PubAckPacket();
DecodePacketIdVariableHeader(buffer, pubAckPacket, ref remainingLength);
return(pubAckPacket);
case Signatures.PubRec:
var pubRecPacket = new PubRecPacket();
DecodePacketIdVariableHeader(buffer, pubRecPacket, ref remainingLength);
return(pubRecPacket);
case Signatures.PubRel:
var pubRelPacket = new PubRelPacket();
DecodePacketIdVariableHeader(buffer, pubRelPacket, ref remainingLength);
return(pubRelPacket);
case Signatures.PubComp:
var pubCompPacket = new PubCompPacket();
DecodePacketIdVariableHeader(buffer, pubCompPacket, ref remainingLength);
return(pubCompPacket);
case Signatures.PingReq:
if (!_isServer)
{
ValidateServerPacketExpected(packetSignature);
}
return(PingReqPacket.Instance);
case Signatures.Subscribe:
if (!_isServer)
{
ValidateServerPacketExpected(packetSignature);
}
var subscribePacket = new SubscribePacket();
DecodePacketIdVariableHeader(buffer, subscribePacket, ref remainingLength);
DecodeSubscribePayload(buffer, subscribePacket, ref remainingLength);
return(subscribePacket);
case Signatures.Unsubscribe:
if (!_isServer)
{
ValidateServerPacketExpected(packetSignature);
}
var unsubscribePacket = new UnsubscribePacket();
DecodePacketIdVariableHeader(buffer, unsubscribePacket, ref remainingLength);
DecodeUnsubscribePayload(buffer, unsubscribePacket, ref remainingLength);
return(unsubscribePacket);
case Signatures.Connect:
if (!_isServer)
{
ValidateServerPacketExpected(packetSignature);
}
var connectPacket = new ConnectPacket();
DecodeConnectPacket(buffer, connectPacket, ref remainingLength, context);
return(connectPacket);
case Signatures.Disconnect:
if (!_isServer)
{
ValidateServerPacketExpected(packetSignature);
}
return(DisconnectPacket.Instance);
case Signatures.ConnAck:
if (_isServer)
{
ValidateClientPacketExpected(packetSignature);
}
var connAckPacket = new ConnAckPacket();
DecodeConnAckPacket(buffer, connAckPacket, ref remainingLength);
return(connAckPacket);
case Signatures.SubAck:
if (_isServer)
{
ValidateClientPacketExpected(packetSignature);
}
var subAckPacket = new SubAckPacket();
DecodePacketIdVariableHeader(buffer, subAckPacket, ref remainingLength);
DecodeSubAckPayload(buffer, subAckPacket, ref remainingLength);
return(subAckPacket);
case Signatures.UnsubAck:
if (_isServer)
{
ValidateClientPacketExpected(packetSignature);
}
var unsubAckPacket = new UnsubAckPacket();
DecodePacketIdVariableHeader(buffer, unsubAckPacket, ref remainingLength);
return(unsubAckPacket);
case Signatures.PingResp:
if (_isServer)
{
ValidateClientPacketExpected(packetSignature);
}
return(PingRespPacket.Instance);
default:
return(ThrowHelper.FromDecoderException_FirstPacketByteValueIsInvalid(packetSignature));
}
}
