public async Task StartAsyncSubscribesToTopics() { // Arrange var mockMqttConnection = new Mock <IMqttConnection>(); var mockTriggeredFunctionExecutor = new Mock <ITriggeredFunctionExecutor>(); mockMqttConnection .Setup(x => x.SubscribeAsync(It.IsAny <MqttTopicFilter[]>())) .Returns(Task.CompletedTask); mockTriggeredFunctionExecutor .Setup(x => x.TryExecuteAsync(It.IsAny <TriggeredFunctionData>(), It.IsAny <CancellationToken>())); var topicFilter = new MqttTopicFilter[] { new MqttTopicFilter() { Topic = "test/topic", QualityOfServiceLevel = MQTTnet.Protocol.MqttQualityOfServiceLevel.AtLeastOnce } }; var mqttListener = new MqttListener(mockMqttConnection.Object, topicFilter, mockTriggeredFunctionExecutor.Object, _mockLogger.Object); // Act await mqttListener.StartAsync(_cancellationToken).ConfigureAwait(false); await mqttListener.OnMessage(new MqttMessageReceivedEventArgs(DefaultMessage)); // Shouldnt we be able to raise the IMqttConnection.OnMessageEventHandler?? // Assert mockMqttConnection.VerifyAll(); mockTriggeredFunctionExecutor.VerifyAll(); }
private async void Subscribe(object sender, RoutedEventArgs e) { try { var qos = MqttQualityOfServiceLevel.AtMostOnce; if (SubscribeQoS1.IsChecked == true) { qos = MqttQualityOfServiceLevel.AtLeastOnce; } if (SubscribeQoS2.IsChecked == true) { qos = MqttQualityOfServiceLevel.ExactlyOnce; } var topicFilter = new MqttTopicFilter { Topic = SubscribeTopic.Text, QualityOfServiceLevel = qos }; if (_mqttClient != null) { await _mqttClient.SubscribeAsync(topicFilter); } if (_managedMqttClient != null) { await _managedMqttClient.SubscribeAsync(topicFilter); } } catch (Exception exception) { Trace.Text += exception + Environment.NewLine; } }
public async Task StopAsyncUnsubscribesToTopics() { // Arrange var mockMqttConnection = new Mock <IMqttConnection>(); var mockTriggeredFunctionExecutor = new Mock <ITriggeredFunctionExecutor>(); mockMqttConnection .Setup(x => x.SubscribeAsync(It.IsAny <MqttTopicFilter[]>())) .Returns(Task.CompletedTask); mockMqttConnection .Setup(x => x.UnubscribeAsync(It.IsAny <string[]>())) .Returns(Task.CompletedTask); var topicFilter = new MqttTopicFilter[] { new MqttTopicFilter() { Topic = "test/topic", QualityOfServiceLevel = MQTTnet.Protocol.MqttQualityOfServiceLevel.AtLeastOnce } }; var mqttListener = new MqttListener(mockMqttConnection.Object, topicFilter, mockTriggeredFunctionExecutor.Object, _mockLogger.Object); // Act await mqttListener.StartAsync(_cancellationToken).ConfigureAwait(false); await mqttListener.StopAsync(_cancellationToken).ConfigureAwait(false); // Assert mockMqttConnection.VerifyAll(); }
async Task <InterceptingSubscriptionEventArgs> InterceptSubscribe(MqttTopicFilter topicFilter, CancellationToken cancellationToken) { var eventArgs = new InterceptingSubscriptionEventArgs { ClientId = _session.Id, TopicFilter = topicFilter, SessionItems = _session.Items, Session = new MqttSessionStatus(_session), CancellationToken = cancellationToken }; if (topicFilter.QualityOfServiceLevel == MqttQualityOfServiceLevel.AtMostOnce) { eventArgs.Response.ReasonCode = MqttSubscribeReasonCode.GrantedQoS0; } else if (topicFilter.QualityOfServiceLevel == MqttQualityOfServiceLevel.AtLeastOnce) { eventArgs.Response.ReasonCode = MqttSubscribeReasonCode.GrantedQoS1; } else if (topicFilter.QualityOfServiceLevel == MqttQualityOfServiceLevel.ExactlyOnce) { eventArgs.Response.ReasonCode = MqttSubscribeReasonCode.GrantedQoS2; } if (topicFilter.Topic.StartsWith("$share/")) { eventArgs.Response.ReasonCode = MqttSubscribeReasonCode.SharedSubscriptionsNotSupported; } else { await _eventContainer.InterceptingSubscriptionEvent.InvokeAsync(eventArgs).ConfigureAwait(false); } return(eventArgs); }
private MqttTopicFilter CreateTopicFilter( string topic, MqttQualityOfServiceLevel?qualityOfServiceLevel = null, bool?noLocal = null, bool?retainAsPublished = null, MqttRetainHandling?retainHandling = null) { var result = new MqttTopicFilter { Topic = TopicFilterSanitizer.SanitizeTopic(topic) }; if (qualityOfServiceLevel.HasValue) { result.QualityOfServiceLevel = qualityOfServiceLevel.Value; } if (noLocal.HasValue) { result.NoLocal = noLocal.Value; } if (retainAsPublished.HasValue) { result.RetainAsPublished = retainAsPublished.Value; } if (retainHandling.HasValue) { result.RetainHandling = retainHandling.Value; } return(result); }
public async Task MessageForOtherTopicThanSubscribedToIsProcessed() { // Arrange var mockMqttConnection = new Mock <IMqttConnection>(); var mockTriggeredFunctionExecutor = new Mock <ITriggeredFunctionExecutor>(); mockMqttConnection .Setup(x => x.SubscribeAsync(It.IsAny <MqttTopicFilter[]>())) .Returns(Task.CompletedTask); mockTriggeredFunctionExecutor .Setup(x => x.TryExecuteAsync(It.IsAny <TriggeredFunctionData>(), It.IsAny <CancellationToken>())); var topicFilter = new MqttTopicFilter[] { new MqttTopicFilter() { Topic = "test/topic", QualityOfServiceLevel = MQTTnet.Protocol.MqttQualityOfServiceLevel.AtLeastOnce } }; var mqttListener = new MqttListener(mockMqttConnection.Object, topicFilter, mockTriggeredFunctionExecutor.Object, _mockLogger.Object); // Act await mqttListener.StartAsync(_cancellationToken).ConfigureAwait(false); var message = new MqttMessage("weird", new byte[] { }, MqttQualityOfServiceLevel.AtLeastOnce, true); await mqttListener.OnMessage(new MqttMessageReceivedEventArgs(message)); // Assert mockMqttConnection.VerifyAll(); mockTriggeredFunctionExecutor.VerifyAll(); }
static async Task Main(string[] args) { var mqttFactory = new MqttFactory(); var tlsOptions = new MqttClientTlsOptions { UseTls = false, IgnoreCertificateChainErrors = true, IgnoreCertificateRevocationErrors = true, AllowUntrustedCertificates = true }; var options = new MqttClientOptions { ClientId = "Note", ProtocolVersion = MqttProtocolVersion.V311, ChannelOptions = new MqttClientTcpOptions { Server = "xx.xx.xx.xx", Port = 1883, TlsOptions = tlsOptions } }; if (options.ChannelOptions == null) { throw new InvalidOperationException(); } options.Credentials = new MqttClientCredentials { Username = "******", Password = Encoding.UTF8.GetBytes("123456") }; var topicFilter = new MqttTopicFilter { Topic = "esp32/dht/temperature" }; options.CleanSession = true; options.KeepAlivePeriod = TimeSpan.FromSeconds(5); managedMqttClientSubscriber = mqttFactory.CreateManagedMqttClient(); managedMqttClientSubscriber.ConnectedHandler = new MqttClientConnectedHandlerDelegate(OnSubscriberConnected); managedMqttClientSubscriber.DisconnectedHandler = new MqttClientDisconnectedHandlerDelegate(OnSubscriberDisconnected); managedMqttClientSubscriber.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(OnSubscriberMessageReceived); await managedMqttClientSubscriber.SubscribeAsync(topicFilter); await managedMqttClientSubscriber.StartAsync( new ManagedMqttClientOptions { ClientOptions = options }); while (true) { } }
Subscription CreateSubscription(MqttTopicFilter topicFilter, MqttSubscribePacket subscribePacket) { var subscription = new Subscription { Topic = topicFilter.Topic, NoLocal = topicFilter.NoLocal, RetainHandling = topicFilter.RetainHandling, RetainAsPublished = topicFilter.RetainAsPublished, QualityOfServiceLevel = topicFilter.QualityOfServiceLevel, Identifier = subscribePacket.Properties?.SubscriptionIdentifier ?? 0 }; _subscriptionsLock.EnterWriteLock(); try { subscription.IsNewSubscription = !_subscriptions.ContainsKey(topicFilter.Topic); _subscriptions[topicFilter.Topic] = subscription; } finally { _subscriptionsLock.ExitWriteLock(); } return(subscription); }
public MqttClientUnsubscribeOptionsBuilder WithTopicFilter(MqttTopicFilter topicFilter) { if (topicFilter is null) { throw new ArgumentNullException(nameof(topicFilter)); } return(WithTopicFilter(topicFilter.Topic)); }
public MyMqttClient(string clientId, string host, int port, string topic) : this(clientId, host, port) { if (!string.IsNullOrWhiteSpace(topic)) { _topics = new MqttTopicFilterBuilder() .WithTopic(topic) .Build(); } }
/// <summary> /// The method that handles the button click to subscribe to a certain topic. /// </summary> /// <param name="sender">The sender.</param> /// <param name="e">The event args.</param> private async void ButtonSubscribeClick(object sender, EventArgs e) { var topicFilter = new MqttTopicFilter { Topic = this.TextBoxTopicSubscribed.Text.Trim() }; await this.managedMqttClientSubscriber.SubscribeAsync(topicFilter); MessageBox.Show("Topic " + this.TextBoxTopicSubscribed.Text.Trim() + " is subscribed", "Notice", MessageBoxButtons.OK, MessageBoxIcon.Information); }
public async Task TestValidateSubscription() { // Add users to users dictionary to simulate that the connection was established successfully: var users = new Dictionary <string, User> { { "Test", new User { Id = User1Id, UserName = "******", ValidateClientId = false } } }; // Test user var mqttTopicFilter = new MqttTopicFilter { Topic = "d/e", QualityOfServiceLevel = MqttQualityOfServiceLevel.AtLeastOnce }; var mqttConnectionValidatorContext = new MqttSubscriptionInterceptorContext("Test", mqttTopicFilter, new Dictionary <object, object>()); var blacklist = await this.userRepository.GetBlacklistItemsForUser(User1Id, BlacklistWhitelistType.Subscribe); var whitelist = await this.userRepository.GetWhitelistItemsForUser(User1Id, BlacklistWhitelistType.Subscribe); var result = this.mqttValidator.ValidateSubscription( mqttConnectionValidatorContext, blacklist, whitelist, users["Test"], ClientIdPrefixes); Assert.IsTrue(result); mqttTopicFilter = new MqttTopicFilter { Topic = "e", QualityOfServiceLevel = MqttQualityOfServiceLevel.AtLeastOnce }; mqttConnectionValidatorContext = new MqttSubscriptionInterceptorContext("Test", mqttTopicFilter, new Dictionary <object, object>()); result = this.mqttValidator.ValidateSubscription( mqttConnectionValidatorContext, blacklist, whitelist, users["Test"], ClientIdPrefixes); Assert.IsTrue(result); }
async Task <MqttSubscriptionInterceptorContext> InterceptSubscribeAsync(MqttTopicFilter topicFilter) { var context = new MqttSubscriptionInterceptorContext(_clientSession.ClientId, topicFilter, _clientSession.Items); if (_options.SubscriptionInterceptor != null) { await _options.SubscriptionInterceptor.InterceptSubscriptionAsync(context).ConfigureAwait(false); } return(context); }
private async void btn_subscribe_Click(object sender, EventArgs e) { string SubscribeTopic = txt_subscribe_topic.Text.Trim(); int level = box_level_subscribe.SelectedIndex; var topicFilter = new MqttTopicFilter { Topic = SubscribeTopic, QualityOfServiceLevel = (MqttQualityOfServiceLevel)level }; await client.SubscribeAsync(topicFilter); MessageBox.Show("主题:" + SubscribeTopic + " 订阅成功", title, MessageBoxButtons.OK, MessageBoxIcon.Information); }
public MqttClientService(IMqttClient mqttClient, IMqttClientOptions options, string[] topics) { _mqttClient = mqttClient; _options = options; MqttTopicFilterBuilder topicFilterBuilder = new MqttTopicFilterBuilder(); for (int i = 0; i < topics.Length; i++) { topicFilterBuilder.WithTopic(topics[i]); } _topicFilter = topicFilterBuilder.Build(); }
public MainPage() { this.InitializeComponent(); GetLamps(); var factory = new MqttFactory(); mqttClient = factory.CreateMqttClient(); var options = new MqttClientOptionsBuilder() .WithTcpServer(DomoticzUrl, 1883) .Build(); System.Threading.CancellationToken cancellationToken; mqttClient.ConnectAsync(options, cancellationToken); mqttClient.UseConnectedHandler(async e => { MqttTopicFilter topicFilter = new MqttTopicFilter(); topicFilter.Topic = "domoticz/out"; await mqttClient.SubscribeAsync(topicFilter); }); mqttClient.UseApplicationMessageReceivedHandler(async e => { dynamic json = JsonConvert.DeserializeObject(Encoding.UTF8.GetString(e.ApplicationMessage.Payload)); Lamp lamp = LampCollection.FirstOrDefault(lc => lc.IDX == (uint)json.idx); if (lamp != null) { Debug.WriteLine($"{lamp.Name} has updated! NValue: {json.nvalue}, SValue: {json.svalue1}"); await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { if (lamp.Dimmable) { if (lamp.ColorLamp) { lamp.SetStatus((uint)json.nvalue, (uint)json.svalue1, (byte)json.Color.r, (byte)json.Color.g, (byte)json.Color.b); } else { lamp.SetStatus((uint)json.nvalue, (uint)json.svalue1); } } else { lamp.SetStatus((uint)json.nvalue); } }); } }); }
public MqttClientSubscribeOptionsBuilder WithTopicFilter(MqttTopicFilter topicFilter) { if (topicFilter == null) { throw new ArgumentNullException(nameof(topicFilter)); } if (_subscribeOptions.TopicFilters == null) { _subscribeOptions.TopicFilters = new List <MqttTopicFilter>(); } _subscribeOptions.TopicFilters.Add(topicFilter); return(this); }
public void Test() { var sub = new string[] { "/test/#", "/test/+/test/test", "/test/+/#" }; var pub = "/test/test/test/test"; foreach (var item in sub) { Assert.True(MqttTopicFilter.Matches(pub, item)); } var sub1 = new string[] { "test/#", "/test/sss/test/test", "/test//#" }; foreach (var item in sub1) { Assert.False(MqttTopicFilter.Matches(pub, item)); } }
protected override async Task ExecuteAsync(CancellationToken stoppingToken) { logger.LogInformation("executing task"); if (mqttClient.IsConnected == false) { logger.LogWarning("publishing failed, trying to connect ..."); await Connect(); if (!mqttClient.IsConnected) { logger.LogError("unable to connect to broker"); return; } } string[] strTopics = { "sensor/0/temperature", "sensor/0/humidity" }; MqttClientSubscribeOptions objSubOptions = new MqttClientSubscribeOptions(); List <MqttTopicFilter> objTopics = new List <MqttTopicFilter>(); foreach (string strTopic in strTopics) { MqttTopicFilter objAdd = new MqttTopicFilter { Topic = strTopic }; objTopics.Add(objAdd); } objSubOptions.TopicFilters = objTopics; await mqttClient.SubscribeAsync(objSubOptions).ConfigureAwait(false); //!!!!subscribe goes here!!!! var message = new MqttApplicationMessageBuilder() //here it does send the message .WithTopic("hc") .WithPayload("I'm ok") .WithExactlyOnceQoS() .WithRetainFlag() .Build(); await mqttClient.PublishAsync(message); return; }
static void Test1() { var sub = new string[] { "/test/#", "/test/+/test/test", "/test/+/#" }; var pub = "/test/test/test/test"; foreach (var item in sub) { XTrace.WriteLine(MqttTopicFilter.Matches(pub, item) + ""); } var sub1 = new string[] { "test/#", "/test/sss/test/test", "/test//#" }; foreach (var item in sub1) { XTrace.WriteLine(MqttTopicFilter.Matches(pub, item) + ""); } }
public async Task SafeNotifyClientSubscribedTopicAsync(string clientId, MqttTopicFilter topicFilter) { try { var handler = ClientSubscribedTopicHandler; if (handler == null) { return; } await handler.HandleClientSubscribedTopicAsync(new MqttServerClientSubscribedTopicEventArgs(clientId, topicFilter)).ConfigureAwait(false); } catch (Exception exception) { _logger.Error(exception, "Error while handling custom 'ClientSubscribedTopic' event."); } }
async Task <MqttSubscriptionInterceptorContext> InterceptSubscribe(MqttTopicFilter topicFilter) { var interceptor = _options.SubscriptionInterceptor; if (interceptor == null) { return(null); } var context = new MqttSubscriptionInterceptorContext { ClientId = _clientSession.ClientId, TopicFilter = topicFilter, SessionItems = _clientSession.Items }; await interceptor.InterceptSubscriptionAsync(context).ConfigureAwait(false); return(context); }
public async Task ConnectAsync() { var mqttClient = new MqttFactory().CreateMqttClient(); mqttClient.UseApplicationMessageReceivedHandler(e => { HandleMessage(e.ApplicationMessage); }); mqttClient.UseDisconnectedHandler(e => { HandleDisconnect(e.AuthenticateResult); }); var topicFilter = new MqttTopicFilter { Topic = _mqttTopic }; var options = new MqttClientOptionsBuilder() .WithClientId(_clientId) .WithTcpServer(_mqttServer, 1883) .WithCredentials(_mqttUser, _mqttPassword) .WithCleanSession() .Build(); mqttClient.ConnectAsync(options, CancellationToken.None).Wait(); await mqttClient.SubscribeAsync(topicFilter); }
public async void Subscribe(string topic) { if (_mqttClient == null || !_mqttClient.IsConnected) { return; } if (!string.IsNullOrWhiteSpace(topic)) { MqttTopicFilter builder = new MqttTopicFilter(); builder.Topic = topic; builder.QualityOfServiceLevel = MQTTnet.Protocol.MqttQualityOfServiceLevel.AtLeastOnce; try { await _mqttClient.SubscribeAsync(builder); } catch (Exception) { throw new TimeoutException(); } } }
static MqttBasePacket DecodeSubscribePacket(IMqttPacketBodyReader body) { ThrowIfBodyIsEmpty(body); var packet = new MqttSubscribePacket { PacketIdentifier = body.ReadTwoByteInteger() }; while (!body.EndOfStream) { var topicFilter = new MqttTopicFilter { Topic = body.ReadStringWithLengthPrefix(), QualityOfServiceLevel = (MqttQualityOfServiceLevel)body.ReadByte() }; packet.TopicFilters.Add(topicFilter); } return(packet); }
private static List <MqttTopicFilter> GetTopicsToSubscribe(string topicBase, int bucktesCount) { var res = new List <MqttTopicFilter>(bucktesCount + 1); var topicInfo = new MqttTopicFilter() { QualityOfServiceLevel = MqttQualityOfServiceLevel.AtLeastOnce, Topic = $"{topicBase}/info" }; res.Add(topicInfo); for (int i = 1; i <= bucktesCount; ++i) { var topicBucket = new MqttTopicFilter() { QualityOfServiceLevel = MqttQualityOfServiceLevel.AtLeastOnce, Topic = $"{topicBase}/data{i - 1}" }; res.Add(topicBucket); } return(res); }
MqttPacket DecodeSubscribePacket(ArraySegment <byte> body) { ThrowIfBodyIsEmpty(body); _bufferReader.SetBuffer(body.Array, body.Offset, body.Count); var packet = new MqttSubscribePacket { PacketIdentifier = _bufferReader.ReadTwoByteInteger() }; while (!_bufferReader.EndOfStream) { var topicFilter = new MqttTopicFilter { Topic = _bufferReader.ReadString(), QualityOfServiceLevel = (MqttQualityOfServiceLevel)_bufferReader.ReadByte() }; packet.TopicFilters.Add(topicFilter); } return(packet); }
private static MqttClientSubscribeResultItem MapSubscribeResultItem(MqttTopicFilter topicFilter) { MqttClientSubscribeResultCode resultCode; switch (topicFilter.QualityOfServiceLevel) { case MqttQualityOfServiceLevel.AtMostOnce: resultCode = MqttClientSubscribeResultCode.GrantedQoS0; break; case MqttQualityOfServiceLevel.AtLeastOnce: resultCode = MqttClientSubscribeResultCode.GrantedQoS1; break; case MqttQualityOfServiceLevel.ExactlyOnce: resultCode = MqttClientSubscribeResultCode.GrantedQoS2; break; default: throw new InvalidOperationException("Invalid QualityOfServiceLevel."); } return(new MqttClientSubscribeResultItem(topicFilter, resultCode)); }
public MqttServerClientSubscribedTopicEventArgs(string clientId, MqttTopicFilter topicFilter) { ClientId = clientId ?? throw new ArgumentNullException(nameof(clientId)); TopicFilter = topicFilter ?? throw new ArgumentNullException(nameof(topicFilter)); }
public MqttSubscriptionInterceptorContext(string clientId, MqttTopicFilter topicFilter, IDictionary <object, object> sessionItems) { ClientId = clientId; TopicFilter = topicFilter; SessionItems = sessionItems; }