private Task HandleIncomingPubRelPacketAsync(IMqttChannelAdapter adapter, MqttPubRelPacket pubRelPacket, CancellationToken cancellationToken)
{
var response = new MqttPubCompPacket {
PacketIdentifier = pubRelPacket.PacketIdentifier
};
return(adapter.SendPacketsAsync(_options.DefaultCommunicationTimeout, cancellationToken, new[] { response }));
}
Task ProcessReceivedPubRelPacket(MqttPubRelPacket pubRelPacket, CancellationToken cancellationToken)
{
return(SendAsync(new MqttPubCompPacket
{
PacketIdentifier = pubRelPacket.PacketIdentifier,
ReasonCode = MqttPubCompReasonCode.Success
}, cancellationToken));
}
private Task ProcessReceivedPubRelPacket(MqttPubRelPacket pubRelPacket)
{
var response = new MqttPubCompPacket
{
PacketIdentifier = pubRelPacket.PacketIdentifier
};
return(SendAsync(response));
}
private async Task ProcessReceivedPubRelPacket(MqttPubRelPacket pubRelPacket)
{
lock (_unacknowledgedPublishPackets)
{
_unacknowledgedPublishPackets.Remove(pubRelPacket.PacketIdentifier);
}
await SendAsync(pubRelPacket.CreateResponse <MqttPubCompPacket>());
}
public void DeserializeV311_MqttPubRelPacket()
{
var p = new MqttPubRelPacket
{
PacketIdentifier = 123
};
DeserializeAndCompare(p, "YgIAew==");
}
private Task ProcessReceivedPubRelPacket(MqttPubRelPacket pubRelPacket, CancellationToken cancellationToken)
{
var response = new MqttPubCompPacket
{
PacketIdentifier = pubRelPacket.PacketIdentifier
};
return(SendAsync(response, cancellationToken));
}
private Task ProcessReceivedPacketAsync(IMqttChannelAdapter adapter, MqttBasePacket packet, CancellationToken cancellationToken)
{
if (packet is MqttPublishPacket publishPacket)
{
return(HandleIncomingPublishPacketAsync(adapter, publishPacket, cancellationToken));
}
if (packet is MqttPingReqPacket)
{
return(adapter.SendPacketsAsync(_options.DefaultCommunicationTimeout, cancellationToken, new[] { new MqttPingRespPacket() }));
}
if (packet is MqttPubRelPacket pubRelPacket)
{
return(HandleIncomingPubRelPacketAsync(adapter, pubRelPacket, cancellationToken));
}
if (packet is MqttPubRecPacket pubRecPacket)
{
var responsePacket = new MqttPubRelPacket
{
PacketIdentifier = pubRecPacket.PacketIdentifier
};
return(adapter.SendPacketsAsync(_options.DefaultCommunicationTimeout, cancellationToken, new[] { responsePacket }));
}
if (packet is MqttPubAckPacket || packet is MqttPubCompPacket)
{
// Discard message.
return(Task.FromResult(0));
}
if (packet is MqttSubscribePacket subscribePacket)
{
return(HandleIncomingSubscribePacketAsync(adapter, subscribePacket, cancellationToken));
}
if (packet is MqttUnsubscribePacket unsubscribePacket)
{
return(HandleIncomingUnsubscribePacketAsync(adapter, unsubscribePacket, cancellationToken));
}
if (packet is MqttDisconnectPacket)
{
return(StopAsync(true));
}
if (packet is MqttConnectPacket)
{
return(StopAsync());
}
_logger.Warning <MqttClientSession>("Client '{0}': Received not supported packet ({1}). Closing connection.", ClientId, packet);
return(StopAsync());
}
public async Task PublishAsync(IEnumerable <MqttApplicationMessage> applicationMessages)
{
ThrowIfNotConnected();
var publishPackets = applicationMessages.Select(m => m.ToPublishPacket());
var packetGroups = publishPackets.GroupBy(p => p.QualityOfServiceLevel).OrderBy(g => g.Key);
foreach (var qosGroup in packetGroups)
{
switch (qosGroup.Key)
{
case MqttQualityOfServiceLevel.AtMostOnce:
{
// No packet identifier is used for QoS 0 [3.3.2.2 Packet Identifier]
await SendAsync(qosGroup.Cast <MqttBasePacket>().ToArray()).ConfigureAwait(false);
break;
}
case MqttQualityOfServiceLevel.AtLeastOnce:
{
foreach (var publishPacket in qosGroup)
{
publishPacket.PacketIdentifier = _packetIdentifierProvider.GetNewPacketIdentifier();
await SendAndReceiveAsync <MqttPubAckPacket>(publishPacket).ConfigureAwait(false);
}
break;
}
case MqttQualityOfServiceLevel.ExactlyOnce:
{
foreach (var publishPacket in qosGroup)
{
publishPacket.PacketIdentifier = _packetIdentifierProvider.GetNewPacketIdentifier();
var pubRecPacket = await SendAndReceiveAsync <MqttPubRecPacket>(publishPacket).ConfigureAwait(false);
var pubRelPacket = new MqttPubRelPacket
{
PacketIdentifier = pubRecPacket.PacketIdentifier
};
await SendAndReceiveAsync <MqttPubCompPacket>(pubRelPacket).ConfigureAwait(false);
}
break;
}
default:
{
throw new InvalidOperationException();
}
}
}
}
Task HandleIncomingPubRelPacketAsync(MqttPubRelPacket pubRelPacket, CancellationToken cancellationToken)
{
var pubCompPacket = new MqttPubCompPacket
{
PacketIdentifier = pubRelPacket.PacketIdentifier,
ReasonCode = MqttPubCompReasonCode.Success
};
return(SendAsync(pubCompPacket, cancellationToken));
}
private async Task SerializeAsync(MqttPubRelPacket packet, IMqttCommunicationChannel destination)
{
using (var output = new MqttPacketWriter())
{
output.Write(packet.PacketIdentifier);
output.InjectFixedHeader(MqttControlPacketType.PubRel, 0x02);
await output.WriteToAsync(destination);
}
}
static byte EncodePubRelPacket(MqttPubRelPacket packet, MqttBufferWriter bufferWriter)
{
if (packet.PacketIdentifier == 0)
{
throw new MqttProtocolViolationException("PubRel packet has no packet identifier.");
}
bufferWriter.WriteTwoByteInteger(packet.PacketIdentifier);
return(MqttBufferWriter.BuildFixedHeader(MqttControlPacketType.PubRel, 0x02));
}
private Task HandleIncomingPubRelPacketAsync(MqttPubRelPacket pubRelPacket)
{
lock (_unacknowledgedPublishPackets)
{
_unacknowledgedPublishPackets.Remove(pubRelPacket.PacketIdentifier);
}
return(Adapter.SendPacketsAsync(_options.DefaultCommunicationTimeout, _cancellationTokenSource.Token, new MqttPubCompPacket {
PacketIdentifier = pubRelPacket.PacketIdentifier
}));
}
static byte EncodePubRelPacket(MqttPubRelPacket packet, IMqttPacketWriter packetWriter)
{
if (!packet.PacketIdentifier.HasValue)
{
throw new MqttProtocolViolationException("PubRel packet has no packet identifier.");
}
packetWriter.Write(packet.PacketIdentifier.Value);
return(MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.PubRel, 0x02));
}
private Task HandleIncomingPubRelPacketAsync(MqttPubRelPacket pubRelPacket)
{
lock (_unacknowledgedPublishPackets)
{
_unacknowledgedPublishPackets.Remove(pubRelPacket.PacketIdentifier);
}
return(_adapter.SendPacketAsync(new MqttPubCompPacket {
PacketIdentifier = pubRelPacket.PacketIdentifier
}, _options.DefaultCommunicationTimeout));
}
public MqttPubCompPacket CreatePubCompPacket(MqttPubRelPacket pubRelPacket, MqttApplicationMessageReceivedReasonCode reasonCode)
{
if (pubRelPacket == null)
{
throw new ArgumentNullException(nameof(pubRelPacket));
}
return(new MqttPubCompPacket
{
PacketIdentifier = pubRelPacket.PacketIdentifier
});
}
private async Task PublishExactlyOnce(MqttPublishPacket publishPacket, CancellationToken cancellationToken)
{
publishPacket.PacketIdentifier = _packetIdentifierProvider.GetNewPacketIdentifier();
var pubRecPacket = await SendAndReceiveAsync <MqttPubRecPacket>(publishPacket, cancellationToken).ConfigureAwait(false);
var pubRelPacket = new MqttPubRelPacket
{
PacketIdentifier = pubRecPacket.PacketIdentifier
};
await SendAndReceiveAsync <MqttPubCompPacket>(pubRelPacket, cancellationToken).ConfigureAwait(false);
}
private async Task ProcessReceivedPubRelPacket(MqttPubRelPacket pubRelPacket)
{
MqttPublishPacket originalPublishPacket;
if (!_pendingExactlyOncePublishPackets.TryRemove(pubRelPacket.PacketIdentifier, out originalPublishPacket))
{
throw new MqttCommunicationException();
}
await SendAsync(originalPublishPacket.CreateResponse <MqttPubCompPacket>());
FireApplicationMessageReceivedEvent(originalPublishPacket);
}
private async Task HandleIncomingPubRelPacketAsync(MqttPubRelPacket pubRelPacket)
{
MqttPublishPacket publishPacket;
if (!_pendingIncomingPublications.TryRemove(pubRelPacket.PacketIdentifier, out publishPacket))
{
return;
}
await _adapter.SendPacketAsync(new MqttPubCompPacket { PacketIdentifier = publishPacket.PacketIdentifier }, _options.DefaultCommunicationTimeout);
_publishPacketReceivedCallback(this, publishPacket);
}
async Task <MqttClientPublishResult> PublishExactlyOnceAsync(MqttPublishPacket publishPacket, CancellationToken cancellationToken)
{
publishPacket.PacketIdentifier = _packetIdentifierProvider.GetNextPacketIdentifier();
var pubRecPacket = await SendAndReceiveAsync <MqttPubRecPacket>(publishPacket, cancellationToken).ConfigureAwait(false);
var pubRelPacket = new MqttPubRelPacket
{
PacketIdentifier = publishPacket.PacketIdentifier,
ReasonCode = MqttPubRelReasonCode.Success
};
var pubCompPacket = await SendAndReceiveAsync <MqttPubCompPacket>(pubRelPacket, cancellationToken).ConfigureAwait(false);
return(_adapter.PacketFormatterAdapter.DataConverter.CreatePublishResult(pubRecPacket, pubCompPacket));
}
private static MqttBasePacket DecodePubRelPacket(IMqttPacketBodyReader body)
{
ThrowIfBodyIsEmpty(body);
var packet = new MqttPubRelPacket
{
PacketIdentifier = body.ReadTwoByteInteger()
};
if (body.EndOfStream)
{
packet.ReasonCode = MqttPubRelReasonCode.Success;
return(packet);
}
packet.ReasonCode = (MqttPubRelReasonCode)body.ReadByte();
var propertiesReader = new MqttV500PropertiesReader(body);
while (propertiesReader.MoveNext())
{
if (packet.Properties == null)
{
packet.Properties = new MqttPubRelPacketProperties();
}
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(MqttPubRelPacket));
}
}
return(packet);
}
byte EncodePubRelPacket(MqttPubRelPacket packet)
{
ThrowIfPacketIdentifierIsInvalid(packet.PacketIdentifier, packet);
_propertiesWriter.WriteReasonString(packet.ReasonString);
_propertiesWriter.WriteUserProperties(packet.UserProperties);
_bufferWriter.WriteTwoByteInteger(packet.PacketIdentifier);
if (_propertiesWriter.Length > 0 || packet.ReasonCode != MqttPubRelReasonCode.Success)
{
_bufferWriter.WriteByte((byte)packet.ReasonCode);
_propertiesWriter.WriteTo(_bufferWriter);
_propertiesWriter.Reset();
}
return(MqttBufferWriter.BuildFixedHeader(MqttControlPacketType.PubRel, 0x02));
}
public void Serialize_Full_MqttPubRelPacket_V500()
{
var pubRelPacket = new MqttPubRelPacket
{
PacketIdentifier = 123,
ReasonCode = MqttPubRelReasonCode.PacketIdentifierNotFound,
ReasonString = "ReasonString",
UserProperties = new List <MqttUserProperty>
{
new MqttUserProperty("Foo", "Bar")
}
};
var deserialized = MqttPacketSerializationHelper.EncodeAndDecodePacket(pubRelPacket, MqttProtocolVersion.V500);
Assert.AreEqual(pubRelPacket.PacketIdentifier, deserialized.PacketIdentifier);
Assert.AreEqual(pubRelPacket.ReasonCode, deserialized.ReasonCode);
Assert.AreEqual(pubRelPacket.ReasonString, deserialized.ReasonString);
CollectionAssert.AreEqual(pubRelPacket.UserProperties, deserialized.UserProperties);
}
public void Serialize_Full_MqttPubRelPacket_V311()
{
var pubRelPacket = new MqttPubRelPacket
{
PacketIdentifier = 123,
ReasonCode = MqttPubRelReasonCode.PacketIdentifierNotFound,
ReasonString = "ReasonString",
UserProperties = new List <MqttUserProperty>
{
new MqttUserProperty("Foo", "Bar")
}
};
var deserialized = MqttPacketSerializationHelper.EncodeAndDecodePacket(pubRelPacket, MqttProtocolVersion.V311);
Assert.AreEqual(pubRelPacket.PacketIdentifier, deserialized.PacketIdentifier);
// ReasonCode not available in MQTTv3.
// ReasonString not available in MQTTv3.
// UserProperties not available in MQTTv3.
Assert.IsNull(deserialized.UserProperties);
}
MqttPacket DecodePubRelPacket(ArraySegment <byte> body)
{
ThrowIfBodyIsEmpty(body);
_bufferReader.SetBuffer(body.Array, body.Offset, body.Count);
var packet = new MqttPubRelPacket
{
PacketIdentifier = _bufferReader.ReadTwoByteInteger()
};
if (_bufferReader.EndOfStream)
{
packet.ReasonCode = MqttPubRelReasonCode.Success;
return(packet);
}
packet.ReasonCode = (MqttPubRelReasonCode)_bufferReader.ReadByte();
var propertiesReader = new MqttV5PropertiesReader(_bufferReader);
while (propertiesReader.MoveNext())
{
if (propertiesReader.CurrentPropertyId == MqttPropertyId.ReasonString)
{
packet.ReasonString = propertiesReader.ReadReasonString();
}
else
{
propertiesReader.ThrowInvalidPropertyIdException(typeof(MqttPubRelPacket));
}
}
packet.UserProperties = propertiesReader.CollectedUserProperties;
return(packet);
}
Task HandleIncomingPubRelPacket(MqttPubRelPacket pubRelPacket, CancellationToken cancellationToken)
{
var pubCompPacket = _channelAdapter.PacketFormatterAdapter.DataConverter.CreatePubCompPacket(pubRelPacket, MqttApplicationMessageReceivedReasonCode.Success);
return(SendPacketAsync(pubCompPacket, cancellationToken));
}
void HandleIncomingPubRelPacket(MqttPubRelPacket pubRelPacket)
{
var pubCompPacket = _packetFactories.PubComp.Create(pubRelPacket, MqttApplicationMessageReceivedReasonCode.Success);
Session.EnqueueControlPacket(new MqttPacketBusItem(pubCompPacket));
}
private Task ProcessReceivedPubRelPacket(MqttPubRelPacket pubRelPacket)
{
return(SendAsync(pubRelPacket.CreateResponse <MqttPubCompPacket>()));
}
private static byte Serialize(MqttPubRelPacket packet, MqttPacketWriter writer)
{
writer.Write(packet.PacketIdentifier);
return(MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.PubRel, 0x02));
}
private void ProcessReceivedPacket(IMqttChannelAdapter adapter, MqttBasePacket packet, CancellationToken cancellationToken)
{
if (packet is MqttPublishPacket publishPacket)
{
HandleIncomingPublishPacket(adapter, publishPacket, cancellationToken);
return;
}
if (packet is MqttPingReqPacket)
{
adapter.SendPacketAsync(new MqttPingRespPacket(), cancellationToken).GetAwaiter().GetResult();
return;
}
if (packet is MqttPubRelPacket pubRelPacket)
{
var responsePacket = new MqttPubCompPacket
{
PacketIdentifier = pubRelPacket.PacketIdentifier
};
adapter.SendPacketAsync(responsePacket, cancellationToken).GetAwaiter().GetResult();
return;
}
if (packet is MqttPubRecPacket pubRecPacket)
{
var responsePacket = new MqttPubRelPacket
{
PacketIdentifier = pubRecPacket.PacketIdentifier
};
adapter.SendPacketAsync(responsePacket, cancellationToken).GetAwaiter().GetResult();
return;
}
if (packet is MqttPubAckPacket || packet is MqttPubCompPacket)
{
return;
}
if (packet is MqttSubscribePacket subscribePacket)
{
HandleIncomingSubscribePacket(adapter, subscribePacket, cancellationToken);
return;
}
if (packet is MqttUnsubscribePacket unsubscribePacket)
{
HandleIncomingUnsubscribePacket(adapter, unsubscribePacket, cancellationToken);
return;
}
if (packet is MqttDisconnectPacket)
{
Stop(MqttClientDisconnectType.Clean, true);
return;
}
if (packet is MqttConnectPacket)
{
Stop(MqttClientDisconnectType.NotClean, true);
return;
}
_logger.Warning(null, "Client '{0}': Received not supported packet ({1}). Closing connection.", ClientId, packet);
Stop(MqttClientDisconnectType.NotClean, true);
}
Task ProcessReceivedPubRelPacket(MqttPubRelPacket pubRelPacket, CancellationToken cancellationToken)
{
var pubCompPacket = _adapter.PacketFormatterAdapter.DataConverter.CreatePubCompPacket(pubRelPacket, MqttApplicationMessageReceivedReasonCode.Success);
return(SendAsync(pubCompPacket, cancellationToken));
}
