public void DeserializeV311_MqttPublishPacket_DupFalse()
{
var p = new MqttPublishPacket
{
Dup = false,
};
var p2 = Roundtrip(p);
Assert.AreEqual(p.Dup, p2.Dup);
}
void EnqueueReceivedPublishPacket(MqttPublishPacket publishPacket)
{
try
{
_publishPacketReceiverQueue.Enqueue(publishPacket);
}
catch (Exception exception)
{
_logger.Error(exception, "Error while queueing application message.");
}
}
private static void ValidatePublishPacket(MqttPublishPacket packet)
{
if (packet == null)
{
throw new ArgumentNullException(nameof(packet));
}
if (packet.QualityOfServiceLevel == 0 && packet.Dup)
{
throw new MqttProtocolViolationException("Dup flag must be false for QoS 0 packets [MQTT-3.3.1-2].");
}
}
public void DeserializeV311_MqttPublishPacket_Qos1()
{
var p = new MqttPublishPacket
{
QualityOfServiceLevel = MqttQualityOfServiceLevel.AtMostOnce,
};
var p2 = Roundtrip(p);
Assert.AreEqual(p.QualityOfServiceLevel, p2.QualityOfServiceLevel);
Assert.AreEqual(p.Dup, p2.Dup);
}
async Task <MqttClientPublishResult> PublishExactlyOnceAsync(MqttPublishPacket publishPacket, CancellationToken cancellationToken)
{
publishPacket.PacketIdentifier = _packetIdentifierProvider.GetNextPacketIdentifier();
var pubRecPacket = await SendAndReceiveAsync <MqttPubRecPacket>(publishPacket, cancellationToken).ConfigureAwait(false);
var pubRelPacket = _adapter.PacketFormatterAdapter.DataConverter.CreatePubRelPacket(pubRecPacket, MqttApplicationMessageReceivedReasonCode.Success);
var pubCompPacket = await SendAndReceiveAsync <MqttPubCompPacket>(pubRelPacket, cancellationToken).ConfigureAwait(false);
return(_adapter.PacketFormatterAdapter.DataConverter.CreateClientPublishResult(pubRecPacket, pubCompPacket));
}
private void FireApplicationMessageReceivedEvent(MqttPublishPacket publishPacket)
{
try
{
var applicationMessage = publishPacket.ToApplicationMessage();
ApplicationMessageReceived?.Invoke(this, new MqttMessageReceivedEventArgs(Options.ClientId, applicationMessage));
}
catch (Exception exception)
{
_logger.Error(exception, "Unhandled exception while handling application message.");
}
}
private void FireApplicationMessageReceivedEvent(MqttPublishPacket publishPacket)
{
try
{
var applicationMessage = publishPacket.ToApplicationMessage();
ApplicationMessageReceived?.Invoke(this, new MqttApplicationMessageReceivedEventArgs(applicationMessage));
}
catch (Exception exception)
{
MqttTrace.Error(nameof(MqttClient), exception, "Unhandled exception while handling application message.");
}
}
public MqttApplicationMessageReceivedEventArgs(
string clientId,
MqttApplicationMessage applicationMessage,
MqttPublishPacket publishPacket,
Func <MqttApplicationMessageReceivedEventArgs, CancellationToken, Task> acknowledgeHandler)
{
ClientId = clientId;
ApplicationMessage = applicationMessage ?? throw new ArgumentNullException(nameof(applicationMessage));
PublishPacket = publishPacket;
PacketIdentifier = publishPacket.PacketIdentifier;
_acknowledgeHandler = acknowledgeHandler;
}
public MqttPublishPacket Clone(MqttPublishPacket publishPacket)
{
return(new MqttPublishPacket
{
Topic = publishPacket.Topic,
Payload = publishPacket.Payload,
Retain = publishPacket.Retain,
QualityOfServiceLevel = publishPacket.QualityOfServiceLevel,
Dup = publishPacket.Dup,
PacketIdentifier = publishPacket.PacketIdentifier
});
}
public MqttPubRecPacket CreatePubRecPacket(MqttPublishPacket publishPacket, MqttApplicationMessageReceivedReasonCode reasonCode)
{
if (publishPacket == null)
{
throw new ArgumentNullException(nameof(publishPacket));
}
return(new MqttPubRecPacket
{
PacketIdentifier = publishPacket.PacketIdentifier
});
}
public void DeserializeV311_MqttPublishPacket_Qos3()
{
var p = new MqttPublishPacket
{
QualityOfServiceLevel = MqttQualityOfServiceLevel.ExactlyOnce,
PacketIdentifier = 1
};
var p2 = Roundtrip(p);
Assert.AreEqual(p.QualityOfServiceLevel, p2.QualityOfServiceLevel);
Assert.AreEqual(p.Dup, p2.Dup);
}
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);
}
public void Enqueue(MqttPublishPacket publishPacket)
{
if (publishPacket == null)
{
throw new ArgumentNullException(nameof(publishPacket));
}
lock (_pendingPublishPackets)
{
_pendingPublishPackets.Add(new MqttClientPublishPacketContext(publishPacket));
_gate.Set();
}
}
private void HandleIncomingPublishPacketWithQoS1(
IMqttChannelAdapter adapter,
MqttPublishPacket publishPacket,
CancellationToken cancellationToken)
{
_sessionsManager.EnqueueApplicationMessage(this, publishPacket);
var response = new MqttPubAckPacket
{
PacketIdentifier = publishPacket.PacketIdentifier
};
adapter.SendPacketAsync(response, cancellationToken).GetAwaiter().GetResult();
}
public void DeserializeV311_MqttPublishPacket()
{
var p = new MqttPublishPacket
{
PacketIdentifier = 123,
Dup = true,
Retain = true,
Payload = Encoding.ASCII.GetBytes("HELLO"),
QualityOfServiceLevel = MqttQualityOfServiceLevel.AtLeastOnce,
Topic = "A/B/C"
};
DeserializeAndCompare(p, "Ow4ABUEvQi9DAHtIRUxMTw==");
}
public void EnqueuePublishPacket(MqttPublishPacket publishPacket)
{
if (publishPacket == null)
{
throw new ArgumentNullException(nameof(publishPacket));
}
if (!_subscriptionsManager.IsSubscribed(publishPacket))
{
return;
}
_pendingMessagesQueue.Enqueue(publishPacket);
}
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));
}
public void EnqueueApplicationMessage(MqttClientSession senderClientSession, MqttPublishPacket publishPacket)
{
if (publishPacket == null)
{
throw new ArgumentNullException(nameof(publishPacket));
}
var checkSubscriptionsResult = _subscriptionsManager.CheckSubscriptions(publishPacket.Topic, publishPacket.QualityOfServiceLevel);
if (!checkSubscriptionsResult.IsSubscribed)
{
return;
}
publishPacket = new MqttPublishPacket
{
Topic = publishPacket.Topic,
Payload = publishPacket.Payload,
QualityOfServiceLevel = checkSubscriptionsResult.QualityOfServiceLevel,
Retain = publishPacket.Retain,
Dup = false
};
if (publishPacket.QualityOfServiceLevel > 0)
{
publishPacket.PacketIdentifier = _packetIdentifierProvider.GetNewPacketIdentifier();
}
if (_options.ClientMessageQueueInterceptor != null)
{
var context = new MqttClientMessageQueueInterceptorContext(
senderClientSession?.ClientId,
ClientId,
publishPacket.ToApplicationMessage());
_options.ClientMessageQueueInterceptor?.Invoke(context);
if (!context.AcceptEnqueue || context.ApplicationMessage == null)
{
return;
}
publishPacket.Topic = context.ApplicationMessage.Topic;
publishPacket.Payload = context.ApplicationMessage.Payload;
publishPacket.QualityOfServiceLevel = context.ApplicationMessage.QualityOfServiceLevel;
}
_pendingPacketsQueue.Enqueue(publishPacket);
}
public void Serialize_LargePacket()
{
var serializer = new MqttV311PacketFormatter(WriterFactory());
const int payloadLength = 80000;
var payload = new byte[payloadLength];
var value = 0;
for (var i = 0; i < payloadLength; i++)
{
if (value > 255)
{
value = 0;
}
payload[i] = (byte)value;
}
var publishPacket = new MqttPublishPacket
{
Topic = "abcdefghijklmnopqrstuvwxyz0123456789",
Payload = payload
};
var publishPacketCopy = Roundtrip(publishPacket);
//var buffer = serializer.Encode(publishPacket);
//var testChannel = new TestMqttChannel(new MemoryStream(buffer.Array, buffer.Offset, buffer.Count));
//var header = new MqttPacketReader(testChannel).ReadFixedHeaderAsync(
// new byte[2],
// CancellationToken.None).GetAwaiter().GetResult().FixedHeader;
//var eof = buffer.Offset + buffer.Count;
//var receivedPacket = new ReceivedMqttPacket(
// header.Flags,
// new MqttPacketBodyReader(buffer.Array, eof - header.RemainingLength, buffer.Count + buffer.Offset),
// 0);
//var packet = (MqttPublishPacket)serializer.Decode(receivedPacket);
Assert.AreEqual(publishPacket.Topic, publishPacketCopy.Topic);
Assert.IsTrue(publishPacket.Payload.SequenceEqual(publishPacketCopy.Payload));
}
public void EnqueuePublishPacket(MqttPublishPacket publishPacket)
{
if (publishPacket == null)
{
throw new ArgumentNullException(nameof(publishPacket));
}
if (!_subscriptionsManager.IsSubscribed(publishPacket))
{
return;
}
_messageQueue.Enqueue(publishPacket);
MqttTrace.Verbose(nameof(MqttClientSession), "Client '{0}': Enqueued pending publish packet.", _identifier);
}
public MqttApplicationMessage CreateApplicationMessage(MqttPublishPacket publishPacket)
{
if (publishPacket == null)
{
throw new ArgumentNullException(nameof(publishPacket));
}
return(new MqttApplicationMessage
{
Topic = publishPacket.Topic,
Payload = publishPacket.Payload,
QualityOfServiceLevel = publishPacket.QualityOfServiceLevel,
Retain = publishPacket.Retain
});
}
static MqttPubAckPacket Create(MqttPublishPacket publishPacket, MqttApplicationMessageReceivedReasonCode applicationMessageReceivedReasonCode)
{
if (publishPacket == null)
{
throw new ArgumentNullException(nameof(publishPacket));
}
var pubAckPacket = new MqttPubAckPacket
{
PacketIdentifier = publishPacket.PacketIdentifier,
ReasonCode = (MqttPubAckReasonCode)(int)applicationMessageReceivedReasonCode
};
return(pubAckPacket);
}
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();
}
public void Serialize_LargePacket()
{
var serializer = new MqttPacketSerializer {
ProtocolVersion = MqttProtocolVersion.V311
};
const int payloadLength = 80000;
var payload = new byte[payloadLength];
var value = 0;
for (var i = 0; i < payloadLength; i++)
{
if (value > 255)
{
value = 0;
}
payload[i] = (byte)value;
}
var publishPacket = new MqttPublishPacket
{
Topic = "abcdefghijklmnopqrstuvwxyz0123456789",
Payload = payload
};
var buffer = serializer.Serialize(publishPacket);
var testChannel = new TestMqttChannel(new MemoryStream(buffer.Array, buffer.Offset, buffer.Count));
var header = MqttPacketReader.ReadFixedHeaderAsync(
testChannel,
new byte[2],
new byte[1],
CancellationToken.None).GetAwaiter().GetResult();
var eof = buffer.Offset + buffer.Count;
var receivedPacket = new ReceivedMqttPacket(
header.Flags,
new MqttPacketBodyReader(buffer.Array, eof - header.RemainingLength, buffer.Count + buffer.Offset));
var packet = (MqttPublishPacket)serializer.Deserialize(receivedPacket);
Assert.AreEqual(publishPacket.Topic, packet.Topic);
Assert.IsTrue(publishPacket.Payload.SequenceEqual(packet.Payload));
}
private void FireApplicationMessageReceivedEvent(MqttPublishPacket publishPacket)
{
if (publishPacket.QualityOfServiceLevel != MqttQualityOfServiceLevel.AtMostOnce)
{
_processedPublishPackets.Add(publishPacket.PacketIdentifier);
}
var applicationMessage = new MqttApplicationMessage(
publishPacket.Topic,
publishPacket.Payload,
publishPacket.QualityOfServiceLevel,
publishPacket.Retain
);
ApplicationMessageReceived?.Invoke(this, new MqttApplicationMessageReceivedEventArgs(applicationMessage));
}
async Task <bool> HandleReceivedApplicationMessageAsync(MqttPublishPacket publishPacket)
{
var applicationMessage = _adapter.PacketFormatterAdapter.DataConverter.CreateApplicationMessage(publishPacket);
var handler = ApplicationMessageReceivedHandler;
if (handler != null)
{
var eventArgs = new MqttApplicationMessageReceivedEventArgs(Options.ClientId, applicationMessage);
await handler.HandleApplicationMessageReceivedAsync(eventArgs).ConfigureAwait(false);
return(!eventArgs.ProcessingFailed);
}
return(true);
}
public void EnqueuePublishPacket(MqttPublishPacket publishPacket)
{
if (publishPacket == null)
{
throw new ArgumentNullException(nameof(publishPacket));
}
var result = _subscriptionsManager.CheckSubscriptions(publishPacket);
if (!result.IsSubscribed)
{
return;
}
publishPacket.QualityOfServiceLevel = result.QualityOfServiceLevel;
_pendingMessagesQueue.Enqueue(publishPacket);
}
Task ClientAcknowledgedPublishPacket(MqttPublishPacket publishPacket, MqttPacketWithIdentifier acknowledgePacket)
{
if (_eventContainer.ClientAcknowledgedPublishPacketEvent.HasHandlers)
{
var eventArgs = new ClientAcknowledgedPublishPacketEventArgs
{
PublishPacket = publishPacket,
AcknowledgePacket = acknowledgePacket,
ClientId = Id,
SessionItems = Session.Items
};
return(_eventContainer.ClientAcknowledgedPublishPacketEvent.TryInvokeAsync(eventArgs, _logger));
}
return(PlatformAbstractionLayer.CompletedTask);
}
public MqttApplicationMessage CreateApplicationMessage(MqttPublishPacket publishPacket)
{
return(new MqttApplicationMessage
{
Topic = publishPacket.Topic,
Payload = publishPacket.Payload,
QualityOfServiceLevel = publishPacket.QualityOfServiceLevel,
Retain = publishPacket.Retain,
ResponseTopic = publishPacket.Properties?.ResponseTopic,
ContentType = publishPacket.Properties?.ContentType,
CorrelationData = publishPacket.Properties?.CorrelationData,
MessageExpiryInterval = publishPacket.Properties?.MessageExpiryInterval,
SubscriptionIdentifiers = publishPacket.Properties?.SubscriptionIdentifiers,
TopicAlias = publishPacket.Properties?.TopicAlias,
PayloadFormatIndicator = publishPacket.Properties?.PayloadFormatIndicator,
UserProperties = publishPacket.Properties?.UserProperties ?? new List <MqttUserProperty>()
});
}
public void MqttSubscriptionsManager_SubscribeSingleNoSuccess()
{
var sm = new MqttClientSubscriptionsManager(new OptionsWrapper <MqttServerOptions>(new MqttServerOptions()));
var sp = new MqttSubscribePacket();
sp.TopicFilters.Add(new TopicFilter("A/B/C", MqttQualityOfServiceLevel.AtMostOnce));
sm.Subscribe(sp, "");
var pp = new MqttPublishPacket
{
Topic = "A/B/X",
QualityOfServiceLevel = MqttQualityOfServiceLevel.AtMostOnce
};
Assert.IsFalse(sm.IsSubscribed(pp));
}
