/// <inheritdoc cref="IMqttClientConfigBuilder.WithCredentials(string,string?)" />
public IMqttClientConfigBuilder WithCredentials(string username, string?password = null)
{
Check.NotNull(username, nameof(username));
_builder.WithCredentials(username, password);
return(this);
}
private void SetupMqttClient()
{
var solarEdgeSetting = Resolver.CreateConcreteInstanceWithDependencies <SolarEdgeSetting>();
var lwtMessage = new MqttApplicationMessageBuilder()
.WithRetainFlag(true)
.WithTopic("tele/solaredge/LWT")
.WithPayload("offline")
.Build();
var clientOptions = new MqttClientOptionsBuilder().WithClientId("SolarEdge")
.WithTcpServer(solarEdgeSetting.MqttAddress)
.WithWillMessage(lwtMessage);
if (!string.IsNullOrWhiteSpace(solarEdgeSetting.MqttUsername))
{
clientOptions.WithCredentials(solarEdgeSetting.MqttUsername, solarEdgeSetting.MqttPassword);
}
var options = new ManagedMqttClientOptionsBuilder().WithAutoReconnectDelay(TimeSpan.FromSeconds(5))
.WithClientOptions(clientOptions.Build())
.Build();
var mqttClient = new MqttFactory().CreateManagedMqttClient();
mqttClient.StartAsync(options).Wait();
ConfigurationResolver.AddRegistration(new SingletonRegistration <IManagedMqttClient>(mqttClient));
}
public static async Task <IManagedMqttClient> GetClient(MqttOptions mqttOptions)
{
var clientConnectionOptionsBuilder = new MqttClientOptionsBuilder()
.WithClientId(mqttOptions.ClientId)
.WithTcpServer(mqttOptions.BrokerHostNameOrIp, mqttOptions.Port);
if (!String.IsNullOrEmpty(mqttOptions.UserName) &&
!String.IsNullOrEmpty(mqttOptions.Password))
{
clientConnectionOptionsBuilder = clientConnectionOptionsBuilder
.WithCredentials(mqttOptions.UserName, mqttOptions.Password);
}
if (mqttOptions.EnableTls)
{
clientConnectionOptionsBuilder = clientConnectionOptionsBuilder
.WithTls();
}
var managedClientOptions = new ManagedMqttClientOptionsBuilder()
.WithAutoReconnectDelay(TimeSpan.FromSeconds(5))
.WithClientOptions(clientConnectionOptionsBuilder.Build())
.Build();
var mqttClient = new MqttFactory().CreateManagedMqttClient();
await mqttClient.StartAsync(managedClientOptions);
return(mqttClient);
}
protected async Task Connect(string user, string passwd)
{
var factory = new MqttFactory();
MqttClientOptionsBuilder builder;
this.Client = factory.CreateMqttClient();
builder = new MqttClientOptionsBuilder()
.WithClientId(Guid.NewGuid().ToString())
.WithTcpServer(this._host, this._port)
.WithCleanSession();
if (this._ssl)
{
builder.WithTls(new MqttClientOptionsBuilderTlsParameters {
AllowUntrustedCertificates = true,
UseTls = true
});
}
if (user != null)
{
builder.WithCredentials(user, passwd);
}
this.Client.UseDisconnectedHandler(e => { this.OnDisconnect_HandlerAsync(); });
this.Client.UseConnectedHandler(e => { this.OnConnect_Handler(); });
this.Client.UseApplicationMessageReceivedHandler(this.OnMessage_Handler);
this._client_options = builder.Build();
await this.Client.ConnectAsync(this._client_options).AwaitBackground();
}
private async void ConnectMirror()
{
if (_neonConfig.Mqtt.MirrorConfig.IsEnabled)
{
var mqttMirrorClientOptions = new MqttClientOptionsBuilder()
.WithClientId(Guid.NewGuid().ToString())
.WithTcpServer(_neonConfig.Mqtt.MirrorConfig.ClientConfig.HostName,
_neonConfig.Mqtt.MirrorConfig.ClientConfig.Port).WithCleanSession();
if (_neonConfig.Mqtt.MirrorConfig.ClientConfig.IsAuth)
{
mqttMirrorClientOptions = mqttMirrorClientOptions.WithCredentials(
_neonConfig.Mqtt.MirrorConfig.ClientConfig.Username,
_neonConfig.Mqtt.MirrorConfig.ClientConfig.Password);
}
_mirrorMqttClient = new MqttFactory().CreateMqttClient();
_mirrorMqttClient.UseApplicationMessageReceivedHandler(async args =>
{
if (_neonConfig.Mqtt.MirrorConfig.ReceiveFromMirror)
{
await _mqttClient.PublishAsync(args.ApplicationMessage);
}
});
await _mirrorMqttClient.ConnectAsync(mqttMirrorClientOptions.Build());
_logger.LogInformation($"Mirror MQTT connected");
}
}
private IMqttClientOptions GetMqttOption(string clientId)
{
var builder = new MqttClientOptionsBuilder()
.WithProtocolVersion(MqttProtocolVersion.V311)
.WithClientId(clientId);
/*
* .WithWillMessage(new MqttApplicationMessage()
* {
* Payload = Encoding.UTF8.GetBytes("Hello World!!!"),
* Topic = "/homegenie",
* Retain = true,
* QualityOfServiceLevel = MqttQualityOfServiceLevel.AtLeastOnce
* });
*/
// TODO: ...
//.WithKeepAlivePeriod(TimeSpan.FromSeconds(...))
//.WithCommunicationTimeout(TimeSpan.FromSeconds(...))
// .WithTls()
//.WithCleanSession();
if (usingWebSockets)
{
builder.WithWebSocketServer(endPoint.Address + ":" + endPoint.Port + "/mqtt");
}
else
{
builder.WithTcpServer(endPoint.Address, endPoint.Port);
}
if (networkCredential != null)
{
builder.WithCredentials(networkCredential.UserName, networkCredential.Password);
}
return(builder.Build());
}
/// <summary>
/// Start logic
/// </summary>
/// <returns></returns>
public async Task Start()
{
var clientOptions = new MqttClientOptionsBuilder()
.WithClientId($"BluewalkNukiBridge2Mqtt-{Environment.MachineName}-{Environment.UserName}")
.WithTcpServer(_mqttHost, _mqttPort);
if (!string.IsNullOrEmpty(Configuration.Instance.Config.Mqtt.Username))
{
clientOptions = clientOptions.WithCredentials(Configuration.Instance.Config.Mqtt.Username,
Configuration.Instance.Config.Mqtt.Password);
}
var managedOptions = new ManagedMqttClientOptionsBuilder()
.WithAutoReconnectDelay(TimeSpan.FromSeconds(5))
.WithClientOptions(clientOptions);
Log.Information($"MQTT: Connecting to {_mqttHost}:{_mqttPort}");
await _mqttClient.StartAsync(managedOptions.Build());
Log.Information($"Starting callback listener on {_httpListener.Prefixes.First()}");
_stopHttpListener = false;
HttpListenAsync();
InitializeCallback();
DiscoverLocks();
if (_infoTimer.Interval > 0)
{
_infoTimer.Start();
}
}
public static MqttClientOptionsBuilder WithConnectionUri(this MqttClientOptionsBuilder builder, Uri uri)
{
var port = uri.IsDefaultPort ? null : (int?)uri.Port;
switch (uri.Scheme.ToLower())
{
case "tcp":
case "mqtt":
builder.WithTcpServer(uri.Host, port);
break;
case "mqtts":
builder.WithTcpServer(uri.Host, port).WithTls();
break;
case "ws":
case "wss":
builder.WithWebSocketServer(uri.ToString());
break;
default:
throw new ArgumentException("Unexpected scheme in uri.");
}
if (!string.IsNullOrEmpty(uri.UserInfo))
{
var userInfo = uri.UserInfo.Split(':');
var username = userInfo[0];
var password = userInfo.Length > 1 ? userInfo[1] : "";
builder.WithCredentials(username, password);
}
return(builder);
}
public BrixelOpenDoorClient(string clientId, string server, string topic, int port, bool useSSL = true, string username = null, string password = null)
{
_topic = topic;
var optionsBuilder = new MqttClientOptionsBuilder()
.WithClientId(clientId)
.WithTcpServer(server, port);
if (!string.IsNullOrWhiteSpace(username) || !string.IsNullOrWhiteSpace(password))
{
optionsBuilder.WithCredentials(username, password);
}
if (useSSL)
{
optionsBuilder
.WithTls(new MqttClientOptionsBuilderTlsParameters
{
AllowUntrustedCertificates = true,
SslProtocol = SslProtocols.Tls12,
IgnoreCertificateChainErrors = true,
IgnoreCertificateRevocationErrors = true,
UseTls = true
});
}
_options = optionsBuilder.Build();
}
public MqttSink(MqttSinkOptions options, IManagedMqttClient client) : base(options)
{
MqttClient = client;
Topics = options.Topics.ToList();
Options = options;
var builder = new MqttClientOptionsBuilder()
.WithTcpServer(options.Server, options.Port);
if (options.Password != null && options.Username != null)
{
builder = builder.WithCredentials(options.Username, options.Password);
}
var clientOptions = builder.Build();
MqttClientOptions = new ManagedMqttClientOptionsBuilder()
.WithPendingMessagesOverflowStrategy(MQTTnet.Server.MqttPendingMessagesOverflowStrategy.DropOldestQueuedMessage)
.WithClientOptions(clientOptions)
.WithMaxPendingMessages(1).WithAutoReconnectDelay(TimeSpan.FromSeconds(10)).Build();
MqttClient.UseDisconnectedHandler(HandleDisconnected);
MqttClient.UseConnectedHandler(HandleConnected);
client.StartAsync(MqttClientOptions).Wait();
Next.Subscribe(payload =>
{
Publish(payload).Wait();
});
}
/// <summary>
/// Constructor responsible for obtaining a <see cref="MQTTConnection"/> through DI.
/// </summary>
/// <param name="connectionInfo">Valid connection.</param>
/// <exception cref="ArgumentNullException"><paramref name="connectionInfo"/> is null.</exception>
/// <exception cref="ArgumentNullException"><see cref="MQTTConnection.Host"/> is null or empty.</exception>
public MQTTHandler(MQTTConnection connectionInfo)
{
if (connectionInfo == null)
{
throw new ArgumentNullException(paramName: nameof(connectionInfo), message: "Connection info must not be null.");
}
if (string.IsNullOrWhiteSpace(connectionInfo.Host))
{
throw new ArgumentNullException(paramName: nameof(connectionInfo.Host), message: "Host must not be null.");
}
var factory = new MqttFactory();
Client = factory.CreateMqttClient();
var optsBuilder = new MqttClientOptionsBuilder()
.WithTcpServer(opts =>
{
opts.Server = connectionInfo.Host;
opts.Port = connectionInfo.Port;
opts.TlsOptions = new MqttClientTlsOptions {
UseTls = false
};
});
if (connectionInfo.IsCredentialsAvailable)
{
optsBuilder.WithCredentials(connectionInfo.User, connectionInfo.Password);
}
Options = optsBuilder.Build();
}
public MqttSource(MqttSourceOptions options, IManagedMqttClient mqttClient) : base(options)
{
Value = Subject.AsObservable();
Options = options;
MqttClient = mqttClient;
var builder = new MqttClientOptionsBuilder()
.WithTcpServer(options.Server, options.Port);
if (options.Password != null && options.Username != null)
{
builder = builder.WithCredentials(options.Username, options.Password);
}
var clientOptions = builder.Build();
MqttClientOptions = new ManagedMqttClientOptionsBuilder()
.WithPendingMessagesOverflowStrategy(MQTTnet.Server.MqttPendingMessagesOverflowStrategy.DropOldestQueuedMessage)
.WithClientOptions(clientOptions)
.WithMaxPendingMessages(1).WithAutoReconnectDelay(TimeSpan.FromSeconds(RECONNECT_DELAY)).Build();
Initialize().Wait();
}
/// <summary>
/// Converts the connection options to client options.
/// </summary>
public IMqttClientOptions ToMqttClientOptions()
{
MqttClientOptionsBuilder builder = new MqttClientOptionsBuilder()
.WithTcpServer(Server, Port > 0 ? Port : null);
if (!string.IsNullOrEmpty(ClientID))
{
builder.WithClientId(ClientID);
}
if (!string.IsNullOrEmpty(Username))
{
builder.WithCredentials(Username, Password);
}
if (Timeout > 0)
{
builder.WithCommunicationTimeout(TimeSpan.FromMilliseconds(Timeout));
}
if (ProtocolVersion > MqttProtocolVersion.Unknown)
{
builder.WithProtocolVersion(ProtocolVersion);
}
return(builder.Build());
}
private IMqttClientOptions ReadConfiguration()
{
var json = Helpers.MqttConfigJson;
if (!string.IsNullOrEmpty(json))
{
var config = JsonConvert.DeserializeObject <Config>(json);
var builder = new MqttClientOptionsBuilder()
.WithClientId(config.BridgeUser.ClientId)
.WithTcpServer(config.BridgeUrl, config.BridgePort)
.WithCleanSession();
if (config.BridgeTls)
{
builder = builder.WithTls();
}
if (!string.IsNullOrEmpty(config.BridgeUser.UserName) &&
!string.IsNullOrEmpty(config.BridgeUser.Password))
{
builder = builder
.WithCredentials(config.BridgeUser.UserName, config.BridgeUser.Password);
}
return(builder
.Build());
}
else
{
throw new FileNotFoundException(
$"config.json not found. Assembly location {Helpers.AssemblyDirectory}");
}
}
public void changeClientConfig(ConnectorData MQTTConnectorData)
{
_MQTTHostAndPort = MQTTConnectorData.getHasSE();
_ClientConfiguration = new MqttClientOptionsBuilder();
_ClientConfiguration.WithClientId(String.Format("{0}-{1}_{2}", MQTTConnectorData.Username, DateTime.Now.ToString("ffffmmHHss"), FedNetWorker.getRandomString(10)));
if (MQTTConnectorData.useCreditential)
{
_ClientConfiguration.WithCredentials(MQTTConnectorData.Username, MQTTConnectorData.Password);
}
if (!MQTTConnectorData.useCreditential)
{
_ClientConfiguration.WithCredentials(MQTTConnectorData.Username, "");
}
_ClientConfiguration.WithTcpServer(MQTTConnectorData.Host, MQTTConnectorData.Port);
_logSystem.Info("MQTT Client reinitialized !");
}
public async Task StartAsync(CancellationToken cancellationToken)
{
bool boilerUnit = this.configuration.GetSection("BoilerUnit").GetValue <bool>("UseBoiler");
if (boilerUnit)
{
boilerTimer = new System.Timers.Timer(60000);
boilerTimer.Elapsed += BoilerTimer_Elapsed;
boilerTimer.AutoReset = true;
}
reconnectTimer = new System.Timers.Timer(30000);
reconnectTimer.Elapsed += ReconnectTimer_Elapsed;
reconnectTimer.AutoReset = true;
string mqttServer = configuration.GetSection("MqttClient").GetValue <string>("ServerAddress");
int mqttPort = configuration.GetSection("MqttClient").GetValue <int>("ServerPort");
string mqttClientId = configuration.GetSection("MqttClient").GetValue <string>("ClientId");
string user = configuration.GetSection("MqttClient").GetValue <string>("User");
string password = configuration.GetSection("MqttClient").GetValue <string>("Password");
MqttClientOptionsBuilder mqttClientOptionsBuilder = new MqttClientOptionsBuilder()
.WithClientId(mqttClientId)
.WithTcpServer(mqttServer, mqttPort > 0 ? mqttPort : 1883);
if (!string.IsNullOrEmpty(user))
{
mqttClientOptionsBuilder.WithCredentials(user, password);
}
mqttOptions = mqttClientOptionsBuilder.Build();
//mqttOptions = new MqttClientOptionsBuilder()
// .WithClientId(mqttClientId)
// .WithTcpServer(mqttServer, mqttPort > 0 ? mqttPort : 1883)
// .WithCredentials(user, password)
// .Build();
client = new MqttFactory().CreateMqttClient();
client.UseDisconnectedHandler(e =>
{
if (boilerUnit)
{
boilerTimer.Stop();
}
reconnectTimer.Start();
});
client.UseConnectedHandler(async e =>
{
await SubscribeTopics();
reconnectTimer.Stop();
if (boilerUnit)
{
boilerTimer.Start();
}
});
await client.ConnectAsync(mqttOptions);
}
public FedNetClient(ConnectorData MQTTConnectorData, IFedNetLogger newlogSystem = null)
{
_logSystem = newlogSystem;
if (_logSystem == null)
{
_logSystem = new DefaultLogger();
}
_MQTTHostAndPort = MQTTConnectorData.getHasSE();
_ClientConfiguration = new MqttClientOptionsBuilder();
_ClientConfiguration.WithClientId(String.Format("{0}-{1}_{2}", MQTTConnectorData.Username, DateTime.Now.ToString("ffffmmHHss"), FedNetWorker.getRandomString(10)));
if (MQTTConnectorData.useCreditential)
{
_ClientConfiguration.WithCredentials(MQTTConnectorData.Username, MQTTConnectorData.Password);
}
_ClientConfiguration.WithTcpServer(MQTTConnectorData.Host, MQTTConnectorData.Port);
_theGameClient = new MqttFactory().CreateMqttClient();
_theGameClient.UseDisconnectedHandler(e => {
_logSystem.Info("Disconnected (reason : " + (e.AuthenticateResult != null ? e.AuthenticateResult.ResultCode.ToString() : "unknow") + ")");
if (Disconnected != null)
{
Disconnected.Invoke(this, e);
}
if (reconnectOnDisco)
{
Task.Delay(1000).Wait();
Connect();
}
});
_theGameClient.UseConnectedHandler(e => {
_logSystem.Info("Connected !!");
_theGameClient.SubscribeAsync(FedNetConstante.SERVER_TO_CLIENT + FedNetConstante.DEFAULT_TOPIC_SEPARATOR + ClientId + FedNetConstante.DEFAULT_TOPIC_SEPARATOR + FedNetConstante.DEFAULT_TOPIC_JOKER, (MqttQualityOfServiceLevel)FedNetConstante.PRIORITY_SERVER_TO_CLIENT);
_theGameClient.SubscribeAsync(FedNetConstante.SERVER_BROADCAST + FedNetConstante.DEFAULT_TOPIC_SEPARATOR + FedNetConstante.DEFAULT_TOPIC_JOKER, (MqttQualityOfServiceLevel)FedNetConstante.PRIORITY_SERVER_BROADCAST);
if (Connected != null)
{
Connected.Invoke(this, e);
}
});
_theGameClient.UseApplicationMessageReceivedHandler(e => {
if (e.ClientId == "" || e.ClientId == " " || e.ClientId == null)
{
return;
}
if (MessageReceived != null)
{
MessageReceived.Invoke(this, Message.getMessage(e.ApplicationMessage));
}
});
reconnectOnDisco = true;
_logSystem.Info("Client initialized !");
}
private static BridgeOptions Configure()
{
var opts = ReadJson("config.json");
var primaryPath = opts.Primary.Split(":").First();
var primaryPortText = opts.Primary.Split(":").Last();
var primaryParse = int.TryParse(primaryPortText, out var primaryPort);
var secondaryPath = opts.Secondary.Split(":").First();
var secondaryPortText = opts.Secondary.Split(":").Last();
var secondaryParse = int.TryParse(secondaryPortText, out var secondaryPort);
var primaryOptions = new MqttClientOptionsBuilder()
.WithClientId("Primary")
.WithTcpServer(primaryPath, primaryPort)
.WithCleanSession();
if (opts.PrimaryUsername != null && opts.PrimaryPassword != null)
{
primaryOptions = primaryOptions.WithCredentials(opts.PrimaryUsername, opts.PrimaryPassword);
}
var secondaryOptions = new MqttClientOptionsBuilder()
.WithClientId("Secondary")
.WithTcpServer(secondaryPath, secondaryPort)
.WithCleanSession();
if (opts.SecondaryUsername != null && opts.SecondaryPassword != null)
{
secondaryOptions = secondaryOptions.WithCredentials(opts.SecondaryUsername, opts.SecondaryPassword);
}
var bridgeOptions = new BridgeOptions
{
PrimaryOptions = primaryOptions.Build(),
SecondaryOptions = secondaryOptions.Build(),
SyncMode = opts.Sync
};
if (opts.PrimaryTopicFilters.Any())
{
var primaryFilters = opts.PrimaryTopicFilters
.Select(f => new TopicFilterBuilder().WithTopic(f).Build())
.ToArray();
bridgeOptions.PrimaryFilters = primaryFilters;
}
if (opts.SecondaryTopicFilters.Any())
{
var secondaryFilters = opts.SecondaryTopicFilters
.Select(f => new TopicFilterBuilder().WithTopic(f).Build())
.ToArray();
bridgeOptions.SecondaryFilters = secondaryFilters;
}
return(bridgeOptions);
}
public void Startup()
{
MqttClientOptionsBuilder options = new MqttClientOptionsBuilder()
.WithTcpServer(Global.mqtt_server);
if (!string.IsNullOrEmpty(Global.mqtt_username))
{
options = options
.WithCredentials(Global.mqtt_username, Global.mqtt_password);
}
ManagedMqttClientOptions manoptions = new ManagedMqttClientOptionsBuilder()
.WithAutoReconnectDelay(TimeSpan.FromSeconds(5))
.WithClientOptions(options.Build())
.Build();
MqttClient = new MqttFactory().CreateManagedMqttClient();
MqttClient.Connected += (sender, e) =>
{
log.Debug("Connected");
// For the initial connection wait for the controller connected event to publish config
// For subsequent connections publish config immediately
if (ControllerConnected)
{
PublishConfig();
}
};
MqttClient.ConnectingFailed += (sender, e) => { log.Debug("Error connecting " + e.Exception.Message); };
MqttClient.StartAsync(manoptions);
MqttClient.ApplicationMessageReceived += MqttClient_ApplicationMessageReceived;
MqttClient.SubscribeAsync(new TopicFilterBuilder().WithTopic($"{Global.mqtt_prefix}/+/{Topic.command}").Build());
MqttClient.SubscribeAsync(new TopicFilterBuilder().WithTopic($"{Global.mqtt_prefix}/+/{Topic.brightness_command}").Build());
MqttClient.SubscribeAsync(new TopicFilterBuilder().WithTopic($"{Global.mqtt_prefix}/+/{Topic.temperature_heat_command}").Build());
MqttClient.SubscribeAsync(new TopicFilterBuilder().WithTopic($"{Global.mqtt_prefix}/+/{Topic.temperature_cool_command}").Build());
MqttClient.SubscribeAsync(new TopicFilterBuilder().WithTopic($"{Global.mqtt_prefix}/+/{Topic.humidify_command}").Build());
MqttClient.SubscribeAsync(new TopicFilterBuilder().WithTopic($"{Global.mqtt_prefix}/+/{Topic.dehumidify_command}").Build());
MqttClient.SubscribeAsync(new TopicFilterBuilder().WithTopic($"{Global.mqtt_prefix}/+/{Topic.mode_command}").Build());
MqttClient.SubscribeAsync(new TopicFilterBuilder().WithTopic($"{Global.mqtt_prefix}/+/{Topic.fan_mode_command}").Build());
MqttClient.SubscribeAsync(new TopicFilterBuilder().WithTopic($"{Global.mqtt_prefix}/+/{Topic.hold_command}").Build());
// Wait until shutdown
trigger.WaitOne();
MqttClient.PublishAsync($"{Global.mqtt_prefix}/status", "offline", MqttQualityOfServiceLevel.AtMostOnce, true);
}
public MQTTPublisher(IMqttFactory factory, MQTTOptions options)
{
_mqttClient = factory.CreateMqttClient();
_options = options;
var builder = new MqttClientOptionsBuilder().WithTcpServer(_options.Host, _options.Port);
if (!string.IsNullOrEmpty(_options.Username) ||
!string.IsNullOrEmpty(_options.Password.ToString()))
{
builder.WithCredentials(_options.Username, _options.Password.ToString());
}
_mqttClientOptions = builder.Build();
}
private async Task ConnectAsync()
{
MqttNetConsoleLogger.ForwardToConsole();
var factory = new MqttFactory();
_mqttClient = factory.CreateMqttClient();
var clientOptionsBuilder = new MqttClientOptionsBuilder()
//.WithClientId()
.WithTcpServer(_broker);
if (!string.IsNullOrWhiteSpace(_username) || !string.IsNullOrWhiteSpace(_password))
{
clientOptionsBuilder = clientOptionsBuilder.WithCredentials(_username, _password);
}
var clientOptions = clientOptionsBuilder.Build();
_mqttClient.ConnectedHandler = new MqttClientConnectedHandlerDelegate(async e =>
{
Console.WriteLine("### CONNECTED WITH SERVER ###");
await Task.Delay(0);
});
_mqttClient.DisconnectedHandler = new MqttClientDisconnectedHandlerDelegate(async e =>
{
Console.WriteLine("### DISCONNECTED FROM SERVER ###");
await Task.Delay(TimeSpan.FromSeconds(5));
try
{
}
catch
{
Console.WriteLine("### RECONNECTING FAILED ###");
}
});
try
{
await _mqttClient.ConnectAsync(clientOptions);
}
catch (Exception exception)
{
Console.WriteLine("### CONNECTING FAILED ###" + Environment.NewLine + exception);
}
}
private MqttClientOptionsBuilder ConfigureClientOptions(MqttClientOptionsBuilder builder, MqttOptions options)
{
builder
.WithClientId(options.ClientName)
.WithTcpServer(options.Host, options.Port)
.WithWillMessage(GetLastWill());
if (options.UseTls)
{
builder = builder.WithTls();
}
if (options.HasCredentials)
{
builder = builder.WithCredentials(options.Username, options.Password);
}
return(builder);
}
private IMqttClientOptions GetConnectOptions()
{
var mqttOptionsBuilder = new MqttClientOptionsBuilder()
.WithCleanSession()
.WithClientId(Guid.NewGuid().ToString());
if (!string.IsNullOrWhiteSpace(_mqttConfig.User))
{
mqttOptionsBuilder = mqttOptionsBuilder.WithCredentials(_mqttConfig.User, _mqttConfig.Password);
}
return(mqttOptionsBuilder.WithTcpServer(_mqttConfig.Host, _mqttConfig.Port)
.WithTls(tlsParameters =>
{
tlsParameters.UseTls = _mqttConfig.Tls;
}).Build());
}
public async Task Connect(string username, string server, int port)
{
var clientOptionsBuilder = new MqttClientOptionsBuilder();
clientOptionsBuilder.WithProtocolVersion((MqttProtocolVersion.V310));
if (!string.IsNullOrWhiteSpace(username))
{
MqttClientCredentials credentials = new MqttClientCredentials();
credentials.Username = username;
clientOptionsBuilder.WithCredentials(credentials);
}
clientOptionsBuilder.WithTcpServer(server, port);
await _mqttClient.ConnectAsync(clientOptionsBuilder.Build());
}
// presently this is only configured to connect to MQTT over secure websockets
public async void Initialize(string server, string username = null, string password = null)
{
// configure client
var factory = new MqttFactory();
MQTTClient = factory.CreateMqttClient();
// load server config -- currently exoects MQTT over secure websockets
var options = new MqttClientOptionsBuilder()
.WithWebSocketServer(server)
.WithTls();
// add authentication options if applicable
if (!string.IsNullOrWhiteSpace(username))
{
options = options.WithCredentials(username, password);
}
// setup handlers to add after connecting
MQTTClient.UseConnectedHandler(async e => {
Log.Instance.Debug("Connected to MQTT server");
if (!string.IsNullOrWhiteSpace(UserIdentifier))
{
Log.Instance.Info($"Subscribing to events for user identifier {UserIdentifier}");
await MQTTClient.SubscribeAsync(new TopicFilterBuilder().WithTopic(
string.IsNullOrWhiteSpace(TopicPrefix) ? $"{UserIdentifier}/event" : $"{TopicPrefix}/{UserIdentifier}/event"
).Build());
State = MQTTMessageState.Listening;
}
else
{
Log.Instance.Info($"No user identifier provided; subscribing to pairing events with pairing key {PairingKey}");
await MQTTClient.SubscribeAsync(new TopicFilterBuilder().WithTopic(
string.IsNullOrWhiteSpace(TopicPrefix) ? $"pair/{PairingKey}" : $"{TopicPrefix}/pair/{PairingKey}"
).Build());
State = MQTTMessageState.Pairing;
}
});
// add handler
MQTTClient.UseApplicationMessageReceivedHandler(e => { OnReceiveMessage(e.ApplicationMessage); });
// connect
await MQTTClient.ConnectAsync(options.Build(), CancellationToken.None);
}
public Mqtt(
ILogger <Mqtt> logger,
string clientId,
string serverUri,
int port,
bool cleanSession,
string?brokerUsername,
string?brokerPassword,
MqttChannelConfig?lastWill)
{
this.logger = logger;
this.serverUri = serverUri;
this.clientId = clientId;
var factory = new MqttFactory();
client = factory.CreateMqttClient();
client.DisconnectedHandler = new MqttClientDisconnectedHandlerDelegate(DisconnectedHandler);
client.ConnectedHandler = new MqttClientConnectedHandlerDelegate(ConnectedHandler);
client.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(MessageReceivedHandler);
var clientOptionsBuilder = new MqttClientOptionsBuilder()
.WithTcpServer(serverUri, port)
.WithClientId(clientId)
.WithCleanSession(cleanSession);
if (lastWill is not null)
{
clientOptionsBuilder.WithWillMessage(
new MqttApplicationMessageBuilder()
.WithTopic(lastWill.Topic)
.WithPayload(lastWill.Payload)
.WithRetainFlag(lastWill.Retain)
.WithQualityOfServiceLevel(lastWill.GetQualityOfServiceAsEnum().ToMqttNet())
.Build());
}
if (brokerUsername is not null &&
brokerPassword is not null)
{
clientOptionsBuilder.WithCredentials(brokerUsername, brokerPassword);
}
clientOptions = clientOptionsBuilder.Build();
}
/// <summary>
/// Service Start action. Do not call this directly.
/// </summary>
/// <param name="cancellationToken">Cancelation token.</param>
/// <returns>Awaitable <see cref="Task" />.</returns>
public async Task StartAsync(CancellationToken cancellationToken = default(CancellationToken))
{
_serviceLog.LogInformation("Service start initiated");
_stopping = false;
// MQTT will message
var willMessage = new MqttApplicationMessageBuilder()
.WithTopic($"{TopicRoot}/connected")
.WithPayload(((int)ConnectionStatus.Disconnected).ToString())
.WithAtLeastOnceQoS()
.WithRetainFlag()
.Build();
// MQTT client options
var optionsBuilder = new MqttClientOptionsBuilder()
.WithTcpServer(_brokerSettings.BrokerIp, _brokerSettings.BrokerPort)
.WithClientId(MqttClientId.ToString())
.WithCleanSession()
.WithWillMessage(willMessage);
// MQTT credentials
if (!string.IsNullOrEmpty(_brokerSettings.BrokerUsername) && !string.IsNullOrEmpty(_brokerSettings.BrokerPassword))
{
optionsBuilder.WithCredentials(_brokerSettings.BrokerUsername, _brokerSettings.BrokerPassword);
}
var managedOptions = new ManagedMqttClientOptionsBuilder()
.WithAutoReconnectDelay(TimeSpan.FromSeconds(_brokerSettings.BrokerReconnectDelay))
.WithClientOptions(optionsBuilder.Build())
.Build();
// Subscribe to MQTT messages
await SubscribeAsync(cancellationToken)
.ConfigureAwait(false);
// Connect to MQTT
await MqttClient.StartAsync(managedOptions)
.ConfigureAwait(false);
// Call startup on inheriting service class
await StartServiceAsync(cancellationToken)
.ConfigureAwait(false);
_serviceLog.LogInformation("Service started successfully");
}
private void Connect()
{
var clientOptions = new MqttClientOptionsBuilder()
.WithClientId("DeconzToMqtt2")
.WithTcpServer(_hostname)
.WithWillMessage(new MqttApplicationMessageBuilder()
.WithRetainFlag(true)
.WithTopic("tele/deconztomqtt/LWT")
.WithPayload("offline")
.Build());
if (!string.IsNullOrWhiteSpace(_username))
{
clientOptions.WithCredentials(_username, _password);
}
var managedOptions = new ManagedMqttClientOptionsBuilder()
.WithAutoReconnectDelay(TimeSpan.FromSeconds(5))
.WithClientOptions(clientOptions);
var factory = new MqttFactory(new MqttNetLogger(_logProvider));
_client = factory.CreateManagedMqttClient();
_client.UseDisconnectedHandler(async e =>
{
_logger.Warn("Disconnected from MQTT server. Try reconnect...");
});
_client.UseConnectedHandler(async e =>
{
_logger.Info("Connected to MQTT server");
await _client.PublishAsync(new MqttApplicationMessageBuilder()
.WithRetainFlag(true)
.WithTopic("tele/deconztomqtt/LWT")
.WithPayload("online")
.Build());
});
_logger.Info("Connecting to MQTT server '{0}'", _hostname);
_client.StartAsync(managedOptions.Build()).Wait(_cancelationToken.Token);
}
private static async Task <IManagedMqttClient> InitMqtt(MqttConfig cfg)
{
var optionBuilder = new MqttClientOptionsBuilder()
.WithClientId($"shome.scene.processor-{Guid.NewGuid()}")
.WithTcpServer(cfg.Host, cfg.Port);
if (!string.IsNullOrWhiteSpace(cfg.User))
{
optionBuilder = optionBuilder.WithCredentials(cfg.User, cfg.Password);
}
var options = new ManagedMqttClientOptionsBuilder()
.WithAutoReconnectDelay(TimeSpan.FromSeconds(5))
.WithClientOptions(optionBuilder.Build())
.Build();
var mqttClient = new MqttFactory().CreateManagedMqttClient();
//await mqttClient.SubscribeAsync(new TopicFilterBuilder().WithTopic("#").WithAtLeastOnceQoS().Build());
mqttClient.Connected += (sender, args) =>
{
_logger.LogInformation("mqtt connected");
};
mqttClient.ConnectingFailed += (sender, args) =>
{
_logger.LogError($"mqtt connection fail. Error {args.Exception}");
};
mqttClient.Disconnected += (sender, args) =>
{
_logger.LogWarning($"mqtt disconnected. Error {args.Exception}");
};
mqttClient.SynchronizingSubscriptionsFailed += (sender, args) =>
{
_logger.LogError($"mqtt sync subscriptions fail. Error {args.Exception}");
};
mqttClient.ApplicationMessageReceived += MqttClientOnApplicationMessageReceived;
await mqttClient.StartAsync(options);
return(mqttClient);
}
private IMqttClientOptions GetMqttClientOptions(MqttConnectionString connectionString)
{
var mqttClientOptionsBuilder = new MqttClientOptionsBuilder()
.WithClientId(connectionString.ClientId)
.WithTcpServer(connectionString.Server, connectionString.Port);
if (!string.IsNullOrEmpty(connectionString.Username) || !string.IsNullOrEmpty(connectionString.Password))
{
_logger.LogTrace($"Using authentication, username: '******'");
mqttClientOptionsBuilder = mqttClientOptionsBuilder.WithCredentials(connectionString.Username, connectionString.Password);
}
if (connectionString.Tls)
{
var certificates = new List <byte[]>();
if (connectionString.Certificate != null)
{
using (var cert = new X509Certificate(connectionString.Certificate))
{
var serializedServerCertificate = cert.Export(X509ContentType.Cert);
certificates.Add(serializedServerCertificate);
}
}
mqttClientOptionsBuilder = mqttClientOptionsBuilder.WithTls(new MqttClientOptionsBuilderTlsParameters
{
UseTls = true,
Certificates = certificates,
#if DEBUG
CertificateValidationCallback = (X509Certificate x, X509Chain y, SslPolicyErrors z, IMqttClientOptions o) =>
{
return(true);
},
#endif
AllowUntrustedCertificates = false,
IgnoreCertificateChainErrors = false,
IgnoreCertificateRevocationErrors = false
});
}
return(mqttClientOptionsBuilder.Build());
}
