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