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)); }