/// <summary> /// Close the MQTT connection /// </summary> public Task StopAsync() { if (_managedMqttClient == null) { return(Task.CompletedTask); } _managedMqttClient.StopAsync().Wait(); _managedMqttClient.Dispose(); _managedMqttClient = null; return(Task.CompletedTask); }
private async void Disconnect(object sender, RoutedEventArgs e) { try { if (_mqttClient != null) { await _mqttClient.DisconnectAsync(); _mqttClient.Dispose(); _mqttClient = null; } if (_managedMqttClient != null) { await _managedMqttClient.StopAsync(); _managedMqttClient.Dispose(); _managedMqttClient = null; } } catch (Exception exception) { Trace.Text += exception + Environment.NewLine; } }
public void Dispose() { if (managedMqttClient != null) { managedMqttClient.StopAsync(); managedMqttClient.Dispose(); } }
/// <summary> /// Close the MQTT connection. /// </summary> public Task StopAsync() { if (_managedMqttClient == null) { return(Task.CompletedTask); } ConnectionState = ConnectionState.Disconnected; _managedMqttClient.StopAsync().Wait(); _managedMqttClient.Dispose(); _managedMqttClient = null; _messageHandler = null; return(Task.CompletedTask); }
public override async Task StopAsync(CancellationToken cancellationToken) { if (_mqttClient != null) { _mqttClient.Dispose(); } await base.StopAsync(cancellationToken); }
internal override void Dispose() { ParentMeasures.Remove(this); ParentRainmeterApis.Remove(Rainmeter); Debug("Disposing Client Measure " + this.Name + " ...", 1); DisconnectAsync().Wait(); MqttClient.Dispose(); this.ClearBuffer(); }
public Task StopAsync(CancellationToken cancellationToken) { _logger.LogInformation($"Stopping MqttListener for {Descriptor}"); ThrowIfDisposed(); if (_managedMqttClient == null) { throw new InvalidOperationException("The listener has not yet been started or has already been stopped."); } _cancellationTokenSource.Cancel(); _managedMqttClient.StopAsync().Wait(); _managedMqttClient.Dispose(); _managedMqttClient = null; return(Task.FromResult <bool>(true)); }
private bool disposedValue = false; // To detect redundant calls protected virtual void Dispose(bool disposing) { if (!disposedValue) { if (disposing) { _client?.Dispose(); } disposedValue = true; } }
public static void Cerrar() { try { cierreForzado = true; client.Dispose(); } catch (Exception ex) { new Log().Escribir(ex); } }
public void Dispose() { if (_disposed) { return; } _disposed = true; _logger.LogInformation("MQTT disconnecting"); _connectionTask?.Dispose(); _mqttClient?.Dispose(); }
public static void StopMQTT() { Logging.WriteDebugLog("MQTT.StopMQTT()"); _timerMQTT.Dispose(); SendMessage(string.Format("{0}/status", _strClientId.ToLower()), "offline"); _mqtt.StopAsync(); _mqtt.Dispose(); _mqtt = null; }
public Task StopAsync(CancellationToken cancellationToken) { _mqttClient.StopAsync().Wait(); _mqttClient.Dispose(); _allSockets.ForEach(s => { s.Close(); }); _allSockets.Clear(); _server.Dispose(); return(Task.CompletedTask); }
public async Task Stop() { try { if (_mqttClient != null) { await _mqttClient.StopAsync().ConfigureAwait(false); } } finally { _mqttClient?.Dispose(); } }
private async void but_Stop_Click(object sender, EventArgs e) { if (mqttClient != null) { if (mqttClient.IsStarted) { await mqttClient.StopAsync(); } mqttClient.Dispose(); } but_Subscribe.Enabled = false; but_Publish.Enabled = false; but_Stop.Enabled = false; but_Start.Enabled = true; }
public async Task <bool> Open() { if (_client != null) { if (_client.IsConnected) { return(true); } _client.Dispose(); _client = null; } try { _tokenSource?.Cancel(); _tokenSource = new CancellationTokenSource(); _client = _mqttFactory.CreateManagedMqttClient(); _client.ConnectedHandler = new MqttClientConnectedHandlerDelegate(ConnectedHandler); _client.DisconnectedHandler = new MqttClientDisconnectedHandlerDelegate(DisconnectedHandler); _client.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(MessageReceived); var options = new ManagedMqttClientOptionsBuilder() .WithAutoReconnectDelay(TimeSpan.FromSeconds(5)) .WithClientOptions(ClientOptions()) .Build(); await _client.SubscribeAsync(new MqttTopicFilterBuilder().WithTopic($"{_mqttConfig.BaseTopic}/#").Build()); await _client.SubscribeAsync(new MqttTopicFilterBuilder().WithTopic("home-assistant/#").Build()); await _client.StartAsync(options); _keepAliveThread = new Thread(Keepalive); _keepAliveThread.Start(_tokenSource.Token); return(true); } catch (Exception e) { _client?.Dispose(); _client = null; _logger.LogError(e, $"Failed connection to mqtt{(_mqttConfig.UseSsl ? "s" : string.Empty)}://{_mqttConfig.Server}:{_mqttConfig.Port}"); return(false); } }
public void Stop() { Policy .HandleResult <MqttClientPublishResult>(r => r.ReasonCode == MqttClientPublishReasonCode.UnspecifiedError) .WaitAndRetry(5, retryAttempt => TimeSpan.FromSeconds(2), (exception, timespan) => _logger.LogWarning("Error sending offline message. Retrying...")) .Execute(() => { var message = _mqttClient.PublishAsync(_lwtMessage); message.Wait(); return(message.Result); }); _mqttClient.StopAsync().Wait(); _logger.LogDebug("Stopped client"); _mqttClient.Dispose(); }
public void Dispose() { if (_disposed) { return; } _disposed = true; try { _mqttClient?.StopAsync().Wait(); _mqttClient?.Dispose(); } catch (IOException ex) { _logger.LogCritical(ex.ToString()); } }
private async Task Connect() { Disconnect(); _logger.LogInformation("Starting MqttConnectionService..."); await Task.Yield(); var settings = _settings.CurrentSettings; var options = new MqttClientOptionsBuilder() .WithTcpServer(settings.MqttServer, settings.MqttPort) .WithTls(x => { x.UseTls = settings.MqttSecure != TlsMode.False; x.AllowUntrustedCertificates = settings.MqttSecure == TlsMode.Insecure; x.IgnoreCertificateRevocationErrors = true; }) .WithCredentials(settings.MqttUsername, settings.MqttPassword) .Build(); var managedOptions = new ManagedMqttClientOptionsBuilder() .WithClientOptions(options) .WithAutoReconnectDelay(TimeSpan.FromSeconds(10)) .Build(); _client = _mqttFactory.CreateManagedMqttClient(); _client.ConnectedHandler = this; _client.DisconnectedHandler = this; _client.ApplicationMessageReceivedHandler = this; await _client.StartAsync(managedOptions); _connection.Disposable = Disposable.Create(() => { _logger.LogInformation("Disconnection from MQTT server..."); _client.Dispose(); }); _logger.LogInformation("Subscribing to MQTT topics..."); await Subscribe(); }
public async Task Close() { _tokenSource?.Cancel(); if (_client == null || !_client.IsConnected) { return; } try { await UpdateStatus(false, CancellationToken.None); await _client.StopAsync(); } catch (Exception e) { _logger.LogError(e, "Exception while closing connection"); } finally { _client?.Dispose(); _client = null; } }
private bool disposedValue = false; // Dient zur Erkennung redundanter Aufrufe. protected virtual void Dispose(bool disposing) { if (!disposedValue) { if (disposing) { // TODO: verwalteten Zustand (verwaltete Objekte) entsorgen. clientLock.Wait(); try { client.Dispose(); } finally { clientLock.Release(); } } // TODO: nicht verwaltete Ressourcen (nicht verwaltete Objekte) freigeben und Finalizer weiter unten überschreiben. // TODO: große Felder auf Null setzen. disposedValue = true; } }
public void Stop() { _mqttClient?.StopAsync().GetAwaiter().GetResult(); _mqttClient?.Dispose(); }
public void Dispose() { Semaphore?.Dispose(); _client?.Dispose(); }
/// <summary> /// Create a rx mqtt client based on a <see cref="IManagedMqttClient"/>. /// </summary> /// <param name="managedMqttClient">The manged mqtt client.</param> /// <param name="logger">The mqtt net logger.</param> /// <remarks> /// Use the <see cref="MqttFactoryExtensions.CreateRxMqttClient(IMqttFactory)"/> or /// <see cref="MqttFactoryExtensions.CreateRxMqttClient(IMqttFactory, IMqttNetLogger)"/> /// factory methods to crate the client. /// </remarks> /// <exception cref="ArgumentNullException"></exception> public RxMqttClient(IManagedMqttClient managedMqttClient, IMqttNetLogger logger) { InternalClient = managedMqttClient ?? throw new ArgumentNullException(nameof(managedMqttClient)); if (logger == null) { throw new ArgumentNullException(nameof(logger)); } this.logger = logger.WithSource(nameof(RxMqttClient)); topicSubscriptionCache = new Dictionary <string, IObservable <MqttApplicationMessageReceivedEventArgs> >(); var cancelationSubject = new Subject <Unit>(); ConnectedEvent = CrateFromHandler <MqttClientConnectedEventArgs>(observer => { managedMqttClient.UseConnectedHandler(args => observer.OnNext(args)); return(Disposable.Create(() => managedMqttClient.ConnectedHandler = null)); }); DisconnectedEvent = CrateFromHandler <MqttClientDisconnectedEventArgs>(observer => { managedMqttClient.UseDisconnectedHandler(args => observer.OnNext(args)); return(Disposable.Create(() => managedMqttClient.DisconnectedHandler = null)); }); ConnectingFailedEvent = CrateFromHandler <ManagedProcessFailedEventArgs>(observer => { managedMqttClient.ConnectingFailedHandler = new ConnectingFailedHandlerDelegate(args => observer.OnNext(args)); return(Disposable.Create(() => managedMqttClient.ConnectingFailedHandler = null)); }); SynchronizingSubscriptionsFailedEvent = CrateFromHandler <ManagedProcessFailedEventArgs>(observer => { managedMqttClient.SynchronizingSubscriptionsFailedHandler = new SynchronizingSubscriptionsFailedHandlerDelegate(args => observer.OnNext(args)); return(Disposable.Create(() => managedMqttClient.SynchronizingSubscriptionsFailedHandler = null)); }); ApplicationMessageProcessedEvent = CrateFromHandler <ApplicationMessageProcessedEventArgs>(observer => { managedMqttClient.ApplicationMessageProcessedHandler = new ApplicationMessageProcessedHandlerDelegate(args => observer.OnNext(args)); return(Disposable.Create(() => managedMqttClient.ApplicationMessageReceivedHandler = null)); }); ApplicationMessageSkippedEvent = CrateFromHandler <ApplicationMessageSkippedEventArgs>(observer => { managedMqttClient.ApplicationMessageSkippedHandler = new ApplicationMessageSkippedHandlerDelegate(args => observer.OnNext(args)); return(Disposable.Create(() => managedMqttClient.ApplicationMessageReceivedHandler = null)); }); Connected = Observable .Create <bool>(observer => { var connected = ConnectedEvent.Subscribe(_ => observer.OnNext(true)); var disconnected = DisconnectedEvent.Subscribe(_ => observer.OnNext(false)); return(new CompositeDisposable(connected, disconnected)); }) .TakeUntil(cancelationSubject) // complete on dispose .Prepend(IsConnected) // start with current state .Append(false) // finish with false .Replay(1) // replay last state on subscribe .RefCount(); // count subscriptions and dispose source observable when no subscription applicationMessageReceived = CrateFromHandler <MqttApplicationMessageReceivedEventArgs>(observer => { managedMqttClient.UseApplicationMessageReceivedHandler(args => observer.OnNext(args)); return(Disposable.Create(() => managedMqttClient.ApplicationMessageReceivedHandler = null)); }); IObservable <T> CrateFromHandler <T>(Func <IObserver <T>, IDisposable> func) { return(Observable.Create(func) .TakeUntil(cancelationSubject) // complete on dispose .Publish() // publish from on source observable .RefCount()); // count subscriptions and dispose source observable when no subscription } cleanUp = Disposable.Create(() => { cancelationSubject.OnNext(Unit.Default); // complete all observers cancelationSubject.Dispose(); try { managedMqttClient.Dispose(); } catch { } }); }
public void Dispose() { _mqttClient?.Dispose(); }
public void Dispose() { _mqttClient.StopAsync().Wait(); _mqttClient.Dispose(); }
public void Dispose() { _client.Dispose(); }
public void Destroy() { _logger.Debug("Destory Module Called.."); _managedMqttClient.Dispose(); }