private async void OnStopped() { foreach (var plugin in _plugins) { plugin.QuitAction(); } await _mqttClient.DisconnectAsync(); }
public void Cleanup() { _mqttClient.DisconnectAsync().GetAwaiter().GetResult(); _mqttClient.Dispose(); _host.StopAsync().GetAwaiter().GetResult(); _host.Dispose(); }
public async Task StopAsync(CancellationToken cancellationToken) { // o app ser encerrado if (cancellationToken.IsCancellationRequested) { var disconnectOption = new MqttClientDisconnectOptions { ReasonCode = MqttClientDisconnectReason.NormalDisconnection, ReasonString = "NormalDiconnection" }; await mqttClient.DisconnectAsync(disconnectOption, cancellationToken); } await mqttClient.DisconnectAsync(); _logger.LogInformation("Encerrando..."); }
public void Disconnect() { if (!_mqttClient.IsConnected) { return; } _mqttClient.DisconnectAsync().Wait(); }
/// <summary> /// Connect to MQTT Broker /// </summary> /// <returns></returns> public async Task Connect() { try { // 1. Get Device Credentials from flash disk var mqttCredential = await GetCredentials(); // 1.1. Call Api to get MQTT credentials if no credentials found if (mqttCredential == null) { var device = new DeviceModel { macAddress = MacAddress, uuid = UUID, }; mqttCredential = await PutCredentials(device); if (mqttCredential == null) { throw new Exception("Can not get MQTT credential"); //Debug.WriteLine("Can not get MQTT credential"); } // 1.2. Store credential to flash disk await SetCredentials(mqttCredential); } if (mqttClient == null) { mqttClient = new MqttFactory().CreateMqttClient(); } // clear the old connection try { await mqttClient.DisconnectAsync(); } catch (Exception ex) { Debug.WriteLine("error", ex); } // 2. Connect to MQTT broker var options = new MqttClientOptionsBuilder() .WithTcpServer(mqttCredential.Endpoint, mqttCredential.Port) .WithClientId(mqttCredential.ClientId) .WithCredentials(mqttCredential.Username, mqttCredential.Password) //.WithKeepAlivePeriod(System.TimeSpan.FromSeconds(20)) //.WithCommunicationTimeout(System.TimeSpan.FromSeconds(60)) .WithCleanSession(false) .Build(); await mqttClient.ConnectAsync(options, CancellationToken.None); } catch (Exception ex) { Debug.WriteLine("Connect mqtt ", ex); } }
/// <summary> /// Остановка задачи /// </summary> public async void Stop() { if (_client.IsConnected) { await _client.DisconnectAsync(); Log.Debug(MQTT_TAG, "Disconnected"); } }
private async static void SendCommandToDevice(string ipAddress, string port, string topic, string command) { if (client != null && client.IsConnected) { await client.DisconnectAsync(); } configuration = new MqttConfiguration { Port = Convert.ToInt32(port) }; client = await MqttClient.CreateAsync(ipAddress, configuration); var sessionState = await client.ConnectAsync(new MqttClientCredentials(clientId : "mrpclient")); await client.SubscribeAsync(topic + "_client", MqttQualityOfService.AtLeastOnce); client.MessageStream.Subscribe(msg => OnMessageReceived(msg.Topic, System.Text.Encoding.UTF8.GetString(msg.Payload))); await client.PublishAsync(new MqttApplicationMessage(topic, Encoding.UTF8.GetBytes(command)), MqttQualityOfService.AtLeastOnce); }
/// <summary> /// Disconnect from the Broker /// </summary> public void Disconnect() { if (!_mqttClient.IsConnected) { return; } _mqttClient.DisconnectAsync(); IsActive = false; }
public async Task StopAsync() { if (!_client.IsConnected) { return; } Message?.Invoke("[MQTT server] disconnect"); await _client.DisconnectAsync(); }
public static Task DisconnectAsync(this IMqttClient client, MqttClientDisconnectOptions options) { if (client == null) { throw new ArgumentNullException(nameof(client)); } return(client.DisconnectAsync(options, CancellationToken.None)); }
private async void Disconnect_Click(object sender, EventArgs e) { if (mqttClient == null) { return; } status.Text = "Disconnecting..."; await mqttClient.DisconnectAsync(); }
public async Task when_connecting_client_with_clean_session_false_then_session_is_preserved() { using (IMqttClient client = await GetClientAsync()) { string clientId = MqttTestHelper.GetClientId(); SessionState sessionState1 = await client.ConnectAsync(new MqttClientCredentials( clientId ), cleanSession : false); await client.DisconnectAsync(); SessionState sessionState2 = await client.ConnectAsync(new MqttClientCredentials( clientId ), cleanSession : false); await client.DisconnectAsync(); sessionState1.Should().Be(SessionState.CleanSession); sessionState2.Should().Be(SessionState.SessionPresent); } }
public Object publishMQTT(MqttCon mqtt) { // Inicializar respuesta string result = string.Empty; // Generar un client_id aleatorio para evitar conflictos en mqtt var client_id = Guid.NewGuid().ToString(); // Debug Console.WriteLine(mqtt.topic); Console.WriteLine(mqtt.msg); var clientSettinigs = AppSettingsProvider.ClientSettings; var brokerHostSettings = AppSettingsProvider.BrokerHostSettings; // Parametros para la configuracion del cliente MQTT. var options = new MqttClientOptionsBuilder() .WithCredentials(clientSettinigs.UserName, clientSettinigs.Password) .WithClientId(client_id) .WithTcpServer(brokerHostSettings.Host, brokerHostSettings.Port) .WithCleanSession() .Build(); // Consruye el mensaje MQTT var msg = new MqttApplicationMessageBuilder() .WithTopic(mqtt.topic) .WithPayload(mqtt.msg) .WithExactlyOnceQoS() .WithRetainFlag() .Build(); // Console.WriteLine(msg.ConvertPayloadToString()); // Envia mensaje MQTT try { // Establece conexion con el Broker mqttClient.ConnectAsync(options).Wait(); // Envia el mensaje mqttClient.PublishAsync(msg).Wait(); //Desconecta el cliente mqttClient.DisconnectAsync().Wait(); } catch (Exception e) { System.Console.WriteLine("Error enviando por MQTT : " + e.Message + e.StackTrace); } // Cierra la conexion // // Retorna Json indicando que fue exitoso return(Json(new { success = true })); }
public static Task DisconnectAsync(this IMqttClient client) { if (client == null) { throw new ArgumentNullException(nameof(client)); } return(client.DisconnectAsync(new MqttClientDisconnectOptions())); }
public async void Terminate() { if (_client.IsConnected) { await _client.DisconnectAsync(); _client = null; } }
public void Dispose() { CancellationTokenSource.Cancel(); if (client.IsConnected) { client.DisconnectAsync(); client.Dispose(); } }
public async void OnClickReConectMqtt() { // MqttURL = mqttUrlText.text; //responseTextMqtt.text = "接続中"; await mqttClient.DisconnectAsync(); ConnectMqtt(); }
static void Main(string[] args) { try { Console.WriteLine("Starting Subsriber...."); //create subscriber client var factory = new MqttFactory(); _client = factory.CreateMqttClient(); //configure options _options = new MqttClientOptionsBuilder() .WithClientId("SubscriberId") .WithTcpServer("127.0.0.1", 1884) .WithCredentials("sanjay", "%Welcome@123%") .WithCleanSession() .Build(); //Handlers _client.UseConnectedHandler(e => { Console.WriteLine("Connected successfully with MQTT Brokers."); //Subscribe to topic _client.SubscribeAsync(new TopicFilterBuilder().WithTopic("/ABB/Factory/Office").Build()).Wait(); _client.SubscribeAsync(new TopicFilterBuilder().WithTopic("mqttdotnet/pubtest").Build()).Wait(); }); _client.UseDisconnectedHandler(e => { Console.WriteLine("Disconnected from MQTT Brokers."); }); _client.UseApplicationMessageReceivedHandler(e => { Console.WriteLine("### RECEIVED APPLICATION MESSAGE ###"); Console.WriteLine($"+ Topic = {e.ApplicationMessage.Topic}"); Console.WriteLine($"+ Payload = {Encoding.UTF8.GetString(e.ApplicationMessage.Payload)}"); Console.WriteLine($"+ QoS = {e.ApplicationMessage.QualityOfServiceLevel}"); Console.WriteLine($"+ Retain = {e.ApplicationMessage.Retain}"); Console.WriteLine(); //Task.Run(() => _client.PublishAsync("hello/world")); }); //actually connect _client.ConnectAsync(_options).Wait(); Console.WriteLine("Press key to exit"); Console.ReadLine(); Task.Run(() => Thread.Sleep(Timeout.Infinite)).Wait(); _client.DisconnectAsync().Wait(); } catch (Exception e) { Console.WriteLine(e); throw; } }
private void Disconnect() { #if HAVE_SYNC if (IsSync) Client.Disconnect(); else #endif Client.DisconnectAsync().Wait(); }
private async Task DisconnectAsync() { if (!Connected) { return; } await _mqttClient.DisconnectAsync(); }
/// <summary> /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. /// </summary> public void Dispose() { #if DEBUG // Write all trace messages to the console window. MqttNetGlobalLogger.LogMessagePublished -= OnShowMsg; #endif if (_client != null) { _tcpServer = null; _client.DisconnectedHandler = null; _client.ApplicationMessageReceivedHandler = null; if (_client.IsConnected) { _client.DisconnectAsync().Wait(); } } }
/// <summary> /// Disconnect from the MQTT broker. /// </summary> /// <param name="entities"></param> public async Task Disconnect() { // Do not attempt to reconnect when we disconnect AttemptReconnectOnDisconnect = false; if (MqttClient.IsConnected) { await MqttClient.DisconnectAsync(); } }
public async Task CloseAsync() { await client.UnsubscribeAsync(GetTopicFilters().Select(tp => tp.Topic)); await client.UnsubscribeAsync(nameof(Format)); await client.UnsubscribeAsync(nameof(AudioData)); await client.DisconnectAsync(); }
/// <summary> /// Will cleanup MQTT client /// </summary> public void Cleanup() { Console.WriteLine("MQTTSensor cleaning up"); client.UnsubscribeAsync(Topic); client.DisconnectAsync(); client.Connected -= Client_Connected; client.Disconnected -= Client_Disconnected; client.ApplicationMessageReceived -= Client_ApplicationMessageReceived; client = null; }
private async Task MaintainConnectionAsync(CancellationToken cancellationToken) { try { while (!cancellationToken.IsCancellationRequested) { var connectionState = await ReconnectIfRequiredAsync().ConfigureAwait(false); if (connectionState == ReconnectionResult.NotConnected) { _publishingCancellationToken?.Cancel(false); _publishingCancellationToken = null; await Task.Delay(_options.AutoReconnectDelay, cancellationToken).ConfigureAwait(false); continue; } if (connectionState == ReconnectionResult.Reconnected || _subscriptionsNotPushed) { await PushSubscriptionsAsync(); _publishingCancellationToken = new CancellationTokenSource(); #pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed Task.Factory.StartNew(() => PublishQueuedMessagesAsync(_publishingCancellationToken.Token), _publishingCancellationToken.Token, TaskCreationOptions.LongRunning, TaskScheduler.Default).ConfigureAwait(false); #pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed continue; } if (connectionState == ReconnectionResult.StillConnected) { await Task.Delay(100, _connectionCancellationToken.Token).ConfigureAwait(false); // Consider using the _Disconnected_ event here. (TaskCompletionSource) } } } catch (OperationCanceledException) { } catch (MqttCommunicationException exception) { _logger.LogWarning(new EventId(), exception, "Communication exception while maintaining connection."); } catch (Exception exception) { _logger.LogError(new EventId(), exception, "Unhandled exception while maintaining connection."); } finally { await _mqttClient.DisconnectAsync().ConfigureAwait(false); _logger.LogInformation("Stopped"); } }
public async Task when_publish_with_client_with_session_clared_then_subscriptions_are_not_re_used(int count) { CleanSession = true; string topic = "topic/foo/bar"; using (IMqttClient publisher = await GetClientAsync()) using (IMqttClient subscriber = await GetClientAsync()) { string subscriberId = subscriber.Id; ManualResetEventSlim subscriberDone = new ManualResetEventSlim(); int subscriberReceived = 0; await subscriber .SubscribeAsync(topic, MqttQualityOfService.AtMostOnce); subscriber .MessageStream .Where(m => m.Topic == topic) .Subscribe(m => { Interlocked.Increment(ref subscriberReceived); if (subscriberReceived == count) { subscriberDone.Set(); } }); await subscriber.DisconnectAsync(); SessionState sessionState = await subscriber.ConnectAsync(new MqttClientCredentials( subscriberId ), cleanSession : true); List <Task> tasks = new List <Task>(); for (int i = 1; i <= count; i++) { TestMessage testMessage = GetTestMessage(i); MqttApplicationMessage message = new MqttApplicationMessage(topic, Serializer.Serialize(testMessage)); tasks.Add(publisher.PublishAsync(message, MqttQualityOfService.AtMostOnce)); } await Task.WhenAll(tasks); bool completed = subscriberDone.Wait(TimeSpan.FromSeconds(Configuration.WaitTimeoutSecs)); Assert.False(completed); SessionState.CleanSession.Should().Be(sessionState); 0.Should().Be(subscriberReceived); await subscriber.UnsubscribeAsync(topic); } }
private async Task MaintainConnectionAsync(CancellationToken cancellationToken) { try { while (!cancellationToken.IsCancellationRequested) { var connectionState = await ReconnectIfRequiredAsync().ConfigureAwait(false); if (connectionState == ReconnectionResult.NotConnected) { _publishingCancellationToken?.Cancel(false); _publishingCancellationToken = null; await Task.Delay(_options.AutoReconnectDelay, cancellationToken).ConfigureAwait(false); continue; } if (connectionState == ReconnectionResult.Reconnected || _subscriptionsNotPushed) { await PushSubscriptionsAsync(); _publishingCancellationToken = new CancellationTokenSource(); #pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed Task.Run(async() => await PublishQueuedMessagesAsync(_publishingCancellationToken.Token), _publishingCancellationToken.Token).ConfigureAwait(false); #pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed continue; } if (connectionState == ReconnectionResult.StillConnected) { await Task.Delay(TimeSpan.FromSeconds(1), _connectionCancellationToken.Token).ConfigureAwait(false); } } } catch (OperationCanceledException) { } catch (MqttCommunicationException exception) { _logger.Warning <ManagedMqttClient>(exception, "Communication exception while maintaining connection."); } catch (Exception exception) { _logger.Error <ManagedMqttClient>(exception, "Unhandled exception while maintaining connection."); } finally { await _mqttClient.DisconnectAsync().ConfigureAwait(false); _logger.Info <ManagedMqttClient>("Stopped"); } }
public void SetText(string text) { try { // InvokeRequired required compares the thread ID of the // calling thread to the thread ID of the creating thread. // If these threads are different, it returns true. if (this.rtxtLoginMessage.InvokeRequired) { //SetTextCallback d = new SetTextCallback(SetText); //this.Invoke(d, new object[] { text }); this.rtxtLoginMessage.Invoke((Action)(() => SetText(text))); } else { if (this.rtxtLoginMessage.Lines.Count() > 300) { this.rtxtLoginMessage.Text = ""; } rtxtLoginMessage.Select(0, 0); rtxtLoginMessage.SelectedText = text + Environment.NewLine; string filenminfo = "ServerStatus_Info_" + DateTime.Now.ToString("yyyyMMdd") + ".txt"; string fullpath2 = Path.Combine(TraceFilePath, filenminfo); using (System.IO.StreamWriter file = new System.IO.StreamWriter(fullpath2, true)) { file.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + "-" + text); } } } catch (Exception ex) { if (mqtc.IsConnected) { mqtc.Disconnected -= mqtc_Disconnected; mqtc.ApplicationMessageReceived -= mqtc_MsgEventHandler; mqtc.Connected -= mqtc_Connected; mqtc.DisconnectAsync(); } } }
public void DisconnectServer(IMqttClient mqttClient) { try { mqttClient.DisconnectAsync(); } catch (MqttCommunicationException ee) { throw ee; } }
private static async Task CloseIntern(IMqttClient client) { try { await client.DisconnectAsync(); } catch (Exception) { } try { client.Dispose(); } catch (Exception) { } }