public MqttClientSubscribeOptionsBuilder WithTopicFilter(
     string topic,
     MqttQualityOfServiceLevel qualityOfServiceLevel = MqttQualityOfServiceLevel.AtMostOnce,
     bool noLocal                      = false,
     bool retainAsPublished            = false,
     MqttRetainHandling retainHandling = MqttRetainHandling.SendAtSubscribe)
 {
     return(WithTopicFilter(new MqttTopicFilter
     {
         Topic = topic,
         QualityOfServiceLevel = qualityOfServiceLevel,
         NoLocal = noLocal,
         RetainAsPublished = retainAsPublished,
         RetainHandling = retainHandling
     }));
 }
        public MqttSubscription(
            string topic,
            bool noLocal,
            MqttRetainHandling retainHandling,
            bool retainAsPublished,
            MqttQualityOfServiceLevel qualityOfServiceLevel,
            uint identifier)
        {
            Topic                        = topic;
            NoLocal                      = noLocal;
            RetainHandling               = retainHandling;
            RetainAsPublished            = retainAsPublished;
            GrantedQualityOfServiceLevel = qualityOfServiceLevel;
            Identifier                   = identifier;

            CalculateTopicHash(Topic, out var hash, out var hashMask, out var hasWildcard);
            TopicHash        = hash;
            TopicHashMask    = hashMask;
            TopicHasWildcard = hasWildcard;
        }
Exemple #3
0
        async Task ExecuteTest(
            MqttRetainHandling retainHandling,
            int expectedCountAfterSubscribe,
            int expectedCountAfterSecondPublish,
            int expectedCountAfterSecondSubscribe)
        {
            using (var testEnvironment = CreateTestEnvironment(MqttProtocolVersion.V500))
            {
                await testEnvironment.StartServer();

                var client1 = await testEnvironment.ConnectClient();

                await client1.PublishStringAsync("Topic", "Payload", retain : true);

                await LongTestDelay();

                var client2 = await testEnvironment.ConnectClient();

                var applicationMessageHandler = testEnvironment.CreateApplicationMessageHandler(client2);

                var topicFilter = testEnvironment.Factory.CreateTopicFilterBuilder().WithTopic("Topic").WithRetainHandling(retainHandling).Build();
                await client2.SubscribeAsync(topicFilter);
                await LongTestDelay();

                applicationMessageHandler.AssertReceivedCountEquals(expectedCountAfterSubscribe);

                await client1.PublishStringAsync("Topic", "Payload", retain : true);
                await LongTestDelay();

                applicationMessageHandler.AssertReceivedCountEquals(expectedCountAfterSecondPublish);

                await client2.SubscribeAsync(topicFilter);
                await LongTestDelay();

                applicationMessageHandler.AssertReceivedCountEquals(expectedCountAfterSecondSubscribe);
            }
        }
Exemple #4
0
 public MqttTopicFilterBuilder WithRetainHandling(MqttRetainHandling value)
 {
     _retainHandling = value;
     return(this);
 }
Exemple #5
0
 public MqttTopicFilterBuilder WithRetainHandling(MqttRetainHandling?value)
 {
     _retainHandling = value ?? MqttRetainHandling.SendAtSubscribe;
     return(this);
 }