private static byte EncodePubRecPacket(MqttPubRecPacket packet, IMqttPacketWriter packetWriter) { ThrowIfPacketIdentifierIsInvalid(packet); if (!packet.ReasonCode.HasValue) { ThrowReasonCodeNotSetException(); } var propertiesWriter = new MqttV500PropertiesWriter(); if (packet.Properties != null) { propertiesWriter.WriteReasonString(packet.Properties.ReasonString); propertiesWriter.WriteUserProperties(packet.Properties.UserProperties); } packetWriter.Write(packet.PacketIdentifier.Value); if (packetWriter.Length > 0 || packet.ReasonCode.Value != MqttPubRecReasonCode.Success) { packetWriter.Write((byte)packet.ReasonCode.Value); propertiesWriter.WriteTo(packetWriter); } return(MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.PubRec)); }
public void DeserializeV311_MqttPubRecPacket() { var p = new MqttPubRecPacket { PacketIdentifier = 123 }; DeserializeAndCompare(p, "UAIAew=="); }
async Task ProcessReceivedPublishPackets(CancellationToken cancellationToken) { while (!cancellationToken.IsCancellationRequested) { try { var publishPacketDequeueResult = await _publishPacketReceiverQueue.TryDequeueAsync(cancellationToken).ConfigureAwait(false); if (!publishPacketDequeueResult.IsSuccess) { return; } var publishPacket = publishPacketDequeueResult.Item; if (publishPacket.QualityOfServiceLevel == MqttQualityOfServiceLevel.AtMostOnce) { await HandleReceivedApplicationMessageAsync(publishPacket).ConfigureAwait(false); } else if (publishPacket.QualityOfServiceLevel == MqttQualityOfServiceLevel.AtLeastOnce) { if (await HandleReceivedApplicationMessageAsync(publishPacket).ConfigureAwait(false)) { await SendAsync(new MqttPubAckPacket { PacketIdentifier = publishPacket.PacketIdentifier, ReasonCode = MqttPubAckReasonCode.Success }, cancellationToken).ConfigureAwait(false); } } else if (publishPacket.QualityOfServiceLevel == MqttQualityOfServiceLevel.ExactlyOnce) { if (await HandleReceivedApplicationMessageAsync(publishPacket).ConfigureAwait(false)) { var pubRecPacket = new MqttPubRecPacket { PacketIdentifier = publishPacket.PacketIdentifier, ReasonCode = MqttPubRecReasonCode.Success }; await SendAsync(pubRecPacket, cancellationToken).ConfigureAwait(false); } } else { throw new MqttProtocolViolationException("Received a not supported QoS level."); } } catch (OperationCanceledException) { } catch (Exception exception) { _logger.Error(exception, "Error while handling application message."); } } }
private Task SerializeAsync(MqttPubRecPacket packet, IMqttCommunicationChannel destination) { using (var output = new MqttPacketWriter()) { output.Write(packet.PacketIdentifier); output.InjectFixedHeader(MqttControlPacketType.PubRec); return(output.WriteToAsync(destination)); } }
static MqttPubRecPacket Create(MqttPublishPacket publishPacket, MqttApplicationMessageReceivedReasonCode applicationMessageReceivedReasonCode) { var pubRecPacket = new MqttPubRecPacket { PacketIdentifier = publishPacket.PacketIdentifier, ReasonCode = (MqttPubRecReasonCode)(int)applicationMessageReceivedReasonCode }; return(pubRecPacket); }
private async Task HandleIncomingPublishPacketWithQoS2(IMqttChannelAdapter adapter, MqttApplicationMessage applicationMessage, MqttPublishPacket publishPacket, CancellationToken cancellationToken) { // QoS 2 is implement as method "B" [4.3.3 QoS 2: Exactly once delivery] await _sessionsManager.DispatchApplicationMessageAsync(this, applicationMessage).ConfigureAwait(false); var response = new MqttPubRecPacket { PacketIdentifier = publishPacket.PacketIdentifier }; await adapter.SendPacketsAsync(_options.DefaultCommunicationTimeout, cancellationToken, response).ConfigureAwait(false); }
static byte EncodePubRecPacket(MqttPubRecPacket packet, MqttBufferWriter bufferWriter) { if (packet.PacketIdentifier == 0) { throw new MqttProtocolViolationException("PubRec packet has no packet identifier."); } bufferWriter.WriteTwoByteInteger(packet.PacketIdentifier); return(MqttBufferWriter.BuildFixedHeader(MqttControlPacketType.PubRec)); }
static byte EncodePubRecPacket(MqttPubRecPacket packet, IMqttPacketWriter packetWriter) { if (!packet.PacketIdentifier.HasValue) { throw new MqttProtocolViolationException("PubRec packet has no packet identifier."); } packetWriter.Write(packet.PacketIdentifier.Value); return(MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.PubRec)); }
public MqttPubRelPacket CreatePubRelPacket(MqttPubRecPacket pubRecPacket, MqttApplicationMessageReceivedReasonCode reasonCode) { if (pubRecPacket == null) { throw new ArgumentNullException(nameof(pubRecPacket)); } return(new MqttPubRelPacket { PacketIdentifier = pubRecPacket.PacketIdentifier }); }
Task ProcessReceivedPubRecPacket(MqttPubRecPacket pubRecPacket, CancellationToken cancellationToken) { if (!_packetDispatcher.TryDispatch(pubRecPacket)) { // The packet is unknown. Probably due to a restart of the client. // So wen send this to the server to trigger a full resend of the message. var pubRelPacket = _adapter.PacketFormatterAdapter.DataConverter.CreatePubRelPacket(pubRecPacket, MqttApplicationMessageReceivedReasonCode.PacketIdentifierNotFound); return(SendAsync(pubRelPacket, cancellationToken)); } return(PlatformAbstractionLayer.CompletedTask); }
async Task HandleIncomingPubRecPacket(MqttPubRecPacket pubRecPacket) { var acknowledgedPublishPacket = Session.PeekAcknowledgePublishPacket(pubRecPacket.PacketIdentifier); if (acknowledgedPublishPacket != null) { await ClientAcknowledgedPublishPacket(acknowledgedPublishPacket, pubRecPacket).ConfigureAwait(false); } var pubRelPacket = _packetFactories.PubRel.Create(pubRecPacket, MqttApplicationMessageReceivedReasonCode.Success); Session.EnqueueControlPacket(new MqttPacketBusItem(pubRelPacket)); }
private Task HandleIncomingPublishPacketWithQoS2Async(MqttPublishPacket publishPacket) { var applicationMessage = _dataConverter.CreateApplicationMessage(publishPacket); _sessionsManager.DispatchApplicationMessage(applicationMessage, this); var pubRecPacket = new MqttPubRecPacket { PacketIdentifier = publishPacket.PacketIdentifier, ReasonCode = MqttPubRecReasonCode.Success }; return(SendAsync(pubRecPacket)); }
private void HandleIncomingPublishPacketWithQoS2( IMqttChannelAdapter adapter, MqttPublishPacket publishPacket, CancellationToken cancellationToken) { // QoS 2 is implement as method "B" (4.3.3 QoS 2: Exactly once delivery) _sessionsManager.EnqueueApplicationMessage(this, publishPacket); var response = new MqttPubRecPacket { PacketIdentifier = publishPacket.PacketIdentifier }; adapter.SendPacketAsync(response, cancellationToken).GetAwaiter().GetResult(); }
Task ProcessReceivedPubRecPacket(MqttPubRecPacket pubRecPacket, CancellationToken cancellationToken) { if (!_packetDispatcher.TryDispatch(pubRecPacket)) { // The packet is unknown. Probably due to a restart of the client. // So wen send this to the server to trigger a full resend of the message. return(SendAsync(new MqttPubRelPacket { PacketIdentifier = pubRecPacket.PacketIdentifier, ReasonCode = MqttPubRelReasonCode.PacketIdentifierNotFound }, cancellationToken)); } return(PlatformAbstractionLayer.CompletedTask); }
public MqttClientPublishResult CreatePublishResult(MqttPubRecPacket pubRecPacket, MqttPubCompPacket pubCompPacket) { if (pubRecPacket == null || pubCompPacket == null) { return(new MqttClientPublishResult { ReasonCode = MqttClientPublishReasonCode.UnspecifiedError }); } return(new MqttClientPublishResult { PacketIdentifier = pubCompPacket.PacketIdentifier, ReasonCode = MqttClientPublishReasonCode.Success }); }
private static MqttBasePacket DecodePubRecPacket(IMqttPacketBodyReader body) { ThrowIfBodyIsEmpty(body); var packet = new MqttPubRecPacket { PacketIdentifier = body.ReadTwoByteInteger() }; if (body.EndOfStream) { packet.ReasonCode = MqttPubRecReasonCode.Success; return(packet); } packet.ReasonCode = (MqttPubRecReasonCode)body.ReadByte(); var propertiesReader = new MqttV500PropertiesReader(body); while (propertiesReader.MoveNext()) { if (packet.Properties == null) { packet.Properties = new MqttPubRecPacketProperties(); } if (propertiesReader.CurrentPropertyId == MqttPropertyId.ReasonString) { packet.Properties.ReasonString = propertiesReader.ReadReasonString(); } else if (propertiesReader.CurrentPropertyId == MqttPropertyId.UserProperty) { if (packet.Properties.UserProperties == null) { packet.Properties.UserProperties = new List <MqttUserProperty>(); } propertiesReader.AddUserPropertyTo(packet.Properties.UserProperties); } else { propertiesReader.ThrowInvalidPropertyIdException(typeof(MqttPubRecPacket)); } } return(packet); }
byte EncodePubRecPacket(MqttPubRecPacket packet) { ThrowIfPacketIdentifierIsInvalid(packet.PacketIdentifier, packet); _propertiesWriter.WriteReasonString(packet.ReasonString); _propertiesWriter.WriteUserProperties(packet.UserProperties); _bufferWriter.WriteTwoByteInteger(packet.PacketIdentifier); if (_bufferWriter.Length > 0 || packet.ReasonCode != MqttPubRecReasonCode.Success) { _bufferWriter.WriteByte((byte)packet.ReasonCode); _propertiesWriter.WriteTo(_bufferWriter); _propertiesWriter.Reset(); } return(MqttBufferWriter.BuildFixedHeader(MqttControlPacketType.PubRec)); }
public MqttClientPublishResult Create(MqttPubRecPacket pubRecPacket, MqttPubCompPacket pubCompPacket) { if (pubRecPacket == null || pubCompPacket == null) { return(new MqttClientPublishResult { ReasonCode = MqttClientPublishReasonCode.UnspecifiedError }); } MqttClientPublishResult result; // The PUBCOMP is the last packet in QoS 2. So we use the results from that instead of PUBREC. if (pubCompPacket.ReasonCode == MqttPubCompReasonCode.PacketIdentifierNotFound) { result = new MqttClientPublishResult { PacketIdentifier = pubCompPacket.PacketIdentifier, ReasonCode = MqttClientPublishReasonCode.UnspecifiedError, ReasonString = pubCompPacket.ReasonString, UserProperties = pubCompPacket.UserProperties ?? EmptyUserProperties }; return(result); } result = new MqttClientPublishResult { PacketIdentifier = pubCompPacket.PacketIdentifier, ReasonCode = MqttClientPublishReasonCode.Success, ReasonString = pubCompPacket.ReasonString, UserProperties = pubCompPacket.UserProperties ?? EmptyUserProperties }; if (pubRecPacket.ReasonCode != MqttPubRecReasonCode.Success) { // Both enums share the same values. result.ReasonCode = (MqttClientPublishReasonCode)pubRecPacket.ReasonCode; } return(result); }
private async Task TryProcessReceivedPublishPacketAsync(MqttPublishPacket publishPacket, CancellationToken cancellationToken) { try { if (publishPacket.QualityOfServiceLevel == MqttQualityOfServiceLevel.AtMostOnce) { await HandleReceivedApplicationMessageAsync(publishPacket).ConfigureAwait(false); } else if (publishPacket.QualityOfServiceLevel == MqttQualityOfServiceLevel.AtLeastOnce) { if (await HandleReceivedApplicationMessageAsync(publishPacket).ConfigureAwait(false)) { await SendAsync(new MqttPubAckPacket { PacketIdentifier = publishPacket.PacketIdentifier, ReasonCode = MqttPubAckReasonCode.Success }, cancellationToken).ConfigureAwait(false); } } else if (publishPacket.QualityOfServiceLevel == MqttQualityOfServiceLevel.ExactlyOnce) { if (await HandleReceivedApplicationMessageAsync(publishPacket).ConfigureAwait(false)) { var pubRecPacket = new MqttPubRecPacket { PacketIdentifier = publishPacket.PacketIdentifier, ReasonCode = MqttPubRecReasonCode.Success }; await SendAsync(pubRecPacket, cancellationToken).ConfigureAwait(false); } } else { throw new MqttProtocolViolationException("Received a not supported QoS level."); } } catch (Exception exception) { _logger.Error(exception, "Error while handling application message."); } }
public void Serialize_Full_MqttPubRecPacket_V500() { var pubRecPacket = new MqttPubRecPacket { PacketIdentifier = 123, ReasonCode = MqttPubRecReasonCode.UnspecifiedError, ReasonString = "ReasonString", UserProperties = new List <MqttUserProperty> { new MqttUserProperty("Foo", "Bar") } }; var deserialized = MqttPacketSerializationHelper.EncodeAndDecodePacket(pubRecPacket, MqttProtocolVersion.V500); Assert.AreEqual(pubRecPacket.PacketIdentifier, deserialized.PacketIdentifier); Assert.AreEqual(pubRecPacket.ReasonCode, deserialized.ReasonCode); Assert.AreEqual(pubRecPacket.ReasonString, deserialized.ReasonString); CollectionAssert.AreEqual(pubRecPacket.UserProperties, deserialized.UserProperties); }
public void Serialize_Full_MqttPubRecPacket_V311() { var pubRecPacket = new MqttPubRecPacket { PacketIdentifier = 123, ReasonCode = MqttPubRecReasonCode.UnspecifiedError, ReasonString = "ReasonString", UserProperties = new List <MqttUserProperty> { new MqttUserProperty("Foo", "Bar") } }; var deserialized = MqttPacketSerializationHelper.EncodeAndDecodePacket(pubRecPacket, MqttProtocolVersion.V311); Assert.AreEqual(pubRecPacket.PacketIdentifier, deserialized.PacketIdentifier); // ReasonCode not available in MQTTv3. // ReasonString not available in MQTTv3. // UserProperties not available in MQTTv3. Assert.IsNull(deserialized.UserProperties); }
public MqttPacket Create(MqttPublishPacket publishPacket, InterceptingPublishEventArgs interceptingPublishEventArgs) { if (publishPacket == null) { throw new ArgumentNullException(nameof(publishPacket)); } var pubRecPacket = new MqttPubRecPacket { PacketIdentifier = publishPacket.PacketIdentifier, ReasonCode = MqttPubRecReasonCode.Success }; if (interceptingPublishEventArgs != null) { pubRecPacket.ReasonCode = (MqttPubRecReasonCode)(int)interceptingPublishEventArgs.Response.ReasonCode; pubRecPacket.ReasonString = interceptingPublishEventArgs.Response.ReasonString; pubRecPacket.UserProperties = interceptingPublishEventArgs.Response.UserProperties; } return(pubRecPacket); }
MqttPacket DecodePubRecPacket(ArraySegment <byte> body) { ThrowIfBodyIsEmpty(body); _bufferReader.SetBuffer(body.Array, body.Offset, body.Count); var packet = new MqttPubRecPacket { PacketIdentifier = _bufferReader.ReadTwoByteInteger() }; if (_bufferReader.EndOfStream) { packet.ReasonCode = MqttPubRecReasonCode.Success; return(packet); } packet.ReasonCode = (MqttPubRecReasonCode)_bufferReader.ReadByte(); var propertiesReader = new MqttV5PropertiesReader(_bufferReader); while (propertiesReader.MoveNext()) { if (propertiesReader.CurrentPropertyId == MqttPropertyId.ReasonString) { packet.ReasonString = propertiesReader.ReadReasonString(); } else { propertiesReader.ThrowInvalidPropertyIdException(typeof(MqttPubRecPacket)); } } packet.UserProperties = propertiesReader.CollectedUserProperties; return(packet); }
void HandleIncomingPubRecPacket(MqttPubRecPacket pubRecPacket) { var pubRelPacket = _packetFactories.PubRel.Create(pubRecPacket, MqttApplicationMessageReceivedReasonCode.Success); Session.EnqueueControlPacket(new MqttPacketBusItem(pubRelPacket)); }
private static byte Serialize(MqttPubRecPacket packet, MqttPacketWriter writer) { writer.Write(packet.PacketIdentifier); return(MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.PubRec)); }