public static IManagedMqttClient UseDisconnectedHandler(this IManagedMqttClient client, Action <MqttClientDisconnectedEventArgs> handler)
{
if (client == null)
{
throw new ArgumentNullException(nameof(client));
}
if (handler == null)
{
return(client.UseDisconnectedHandler((IMqttClientDisconnectedHandler)null));
}
return(client.UseDisconnectedHandler(new MqttClientDisconnectedHandlerDelegate(handler)));
}
public MqttService(
IOptions <MqttOptions> mqttOptions,
ILogger <MqttService> logger,
DeviceState deviceState,
IServiceScopeFactory serviceScopeFactory)
{
_mqttOptions = mqttOptions.Value;
_logger = logger;
_deviceState = deviceState;
_serviceScopeFactory = serviceScopeFactory;
_client = new MqttFactory().CreateManagedMqttClient();
_client.UseApplicationMessageReceivedHandler(e =>
{
HandleMqttMessage(e);
});
_client.UseConnectedHandler(e =>
{
HandleMqttConnected(e);
});
_client.UseDisconnectedHandler(e =>
{
HandleMqttDisconnected(e);
});
}
public bool TryConnect()
{
lock (_syncRoot)
{
if (IsConnected)
{
// prevent duplicated concurrent re-connection
return(true);
}
if (!_mqttClient.IsStarted)
{
_logger.LogInformation("Mqtt Client is trying to connect");
_mqttClient.StartAsync(_clientOptions).Wait();
_mqttClient.UseConnectedHandler(e => { _logger.LogInformation("MQTT Server connected!"); });
_mqttClient.UseDisconnectedHandler((e) =>
{
_logger.LogError("MQTT Server disconnected: " + e?.Exception?.Message);
});
}
return(_mqttClient.IsConnected);
}
}
private async void OnStarted()
{
var brokerSettings = _configuration.GetSection("BrokerSettings").Get <BrokerSettings>();
var options = new ManagedMqttClientOptionsBuilder()
.WithAutoReconnectDelay(TimeSpan.FromSeconds(5))
.WithClientOptions(new MqttClientOptionsBuilder()
.WithClientId(_serviceSettings.NodeId)
.WithTcpServer(brokerSettings.Host, brokerSettings.Port)
.WithCredentials(brokerSettings.Username, brokerSettings.Password)
.WithCleanSession(false)
.Build())
.Build();
_client.UseConnectedHandler(handler =>
{
_logger.LogInformation("Connected successfully with MQTT Brokers.");
});
_client.UseDisconnectedHandler(handler =>
{
_logger.LogWarning("Disconnected from MQTT Brokers.");
});
await _client.StartAsync(options);
_timer = new Timer(HandleTimerCallback, null, TimeSpan.Zero,
TimeSpan.FromMilliseconds(_serviceSettings.TimeSpan));
}
public static async Task ConnectAsync()
{
var clientId = Guid.NewGuid().ToString();
var mqttURI = "localhost";
var mqttUser = "******";
var mqttPassword = "******";
var mqttPort = 1883;
var messageBuilder = new MqttClientOptionsBuilder()
.WithClientId(clientId)
.WithCredentials(mqttUser, mqttPassword)
.WithTcpServer(mqttURI, mqttPort)
.WithCleanSession();
var options = messageBuilder
.Build();
var managedOptions = new ManagedMqttClientOptionsBuilder()
.WithAutoReconnectDelay(TimeSpan.FromSeconds(5))
.WithClientOptions(options)
.Build();
await client.StartAsync(managedOptions);
client.UseConnectedHandler(e => { Console.WriteLine("Connected successfully with MQTT Brokers."); });
client.UseDisconnectedHandler(e => { Console.WriteLine("Disconnected from MQTT Brokers."); });
}
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();
});
}
private static async Task ConnectAsync()
{
string mqttUri = configuration["mqttServerIp"];
//const string mqttUri = "localhost";
var mqttUser = configuration["mqttUser"];
var mqttPassword = configuration["mqttPassword"];
var mqttPort = Convert.ToInt32(configuration["mqttPort"]);
Console.WriteLine($"MQTT Server:{mqttUri} Username:{mqttUser} ClientID:{clientId}");
var messageBuilder = new MqttClientOptionsBuilder()
.WithClientId(clientId)
.WithCredentials(mqttUser, mqttPassword)
.WithTcpServer(mqttUri, mqttPort)
.WithKeepAlivePeriod(new TimeSpan(0, 0, 30))
.WithCleanSession();
var options = messageBuilder
.Build();
var managedOptions = new ManagedMqttClientOptionsBuilder()
.WithAutoReconnectDelay(TimeSpan.FromSeconds(2))
.WithClientOptions(options)
.Build();
await client.StartAsync(managedOptions);
client.UseConnectedHandler(e => { Console.WriteLine("Connected successfully with MQTT Brokers."); });
client.UseDisconnectedHandler(e =>
{
new MqttClientDisconnectedHandlerDelegate(e => MqttClient_Disconnected(e));
Console.WriteLine("Disconnected from MQTT Brokers.Client Was Connected " + e.ClientWasConnected);
});
client.UseApplicationMessageReceivedHandler(e =>
{
try
{
var topic = e.ApplicationMessage.Topic;
if (!string.IsNullOrWhiteSpace(topic))
{
var payload = HelperFunctions.GetPayload(e.ApplicationMessage.Payload);
Console.WriteLine($"Topic: {topic}. Message Received: {JsonConvert.SerializeObject(payload, Formatting.Indented)}");
var platoonId = topic.Replace("platooning/" + clientId + "/", "").Split("/").Last();
if (payload.Maneuver == 2)
{
_ = SubscribeAsync($@"platooning/broadcast/{platoonId}/#");
Console.WriteLine("Client SubscribeAsync as " + "platooning/broadcast/" + platoonId + "/#");
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message, ex);
}
});
}
static void Main(string[] args)
{
WebClient webclient = new WebClient();
Console.WriteLine("Started mqtt influx exporter");
Task.Run(async() =>
{
await ConnectAsync();
client.UseConnectedHandler(e =>
{
Console.WriteLine("Connected successfully with MQTT Brokers.");
});
client.UseDisconnectedHandler(e =>
{
Console.WriteLine("Disconnected from MQTT Brokers.");
});
client.UseApplicationMessageReceivedHandler(e =>
{
try
{
string topic = e.ApplicationMessage.Topic;
if (string.IsNullOrWhiteSpace(topic) == false)
{
string payload = Encoding.UTF8.GetString(e.ApplicationMessage.Payload);
if (Environment.GetEnvironmentVariable("LOG_MQTT").ToLower() == "true")
{
Console.WriteLine($"Topic: {topic}. Message Received: {payload}");
}
string[] topicParts = topic.Split("/");
// "temperature, type="weather", device="mcu12390u0adaksnjl", value=25.23, timestamp (optional, nanosecond unix time)
string influxPayload = topicParts[2] + ",type=" + topicParts[1] + ",device=" + topicParts[3] + " value=" + payload;
string url = Environment.GetEnvironmentVariable("INFLUXDB_URL");
if (string.IsNullOrEmpty(url))
{
url = "http://192.168.10.31:8086/write?db=iot";
}
var response = webclient.UploadString(url, influxPayload);
//Console.WriteLine(response);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message, ex);
}
});
// Subscribe to channels
_ = SubscribeAsync("iot/weather/+/+", 1);
});
// Prevent immediate exit
_quitEvent.WaitOne();
}
/// <summary>
/// Starts the MQTT Client.
/// </summary>
/// <returns></returns>
public async Task Start()
{
if (managedMqttClient != null)
{
return;
}
managedMqttClient = new MqttFactory().CreateManagedMqttClient();
IMqttClientOptions mqttClientOptions = new MqttClientOptionsBuilder()
.WithTcpServer(host, tcpPort)
.WithCredentials(user, pass)
.Build();
ManagedMqttClientOptions managedMqttClientOptions = new ManagedMqttClientOptionsBuilder()
.WithClientOptions(mqttClientOptions)
.Build();
managedMqttClient.UseApplicationMessageReceivedHandler(e =>
{
IngestMessage(e.ApplicationMessage);
return(Task.CompletedTask);
});
managedMqttClient.UseConnectedHandler(e =>
{
OnStatusUpdate(this, "MQTT connected.");
});
managedMqttClient.UseDisconnectedHandler(e =>
{
if (e.ClientWasConnected)
{
OnStatusUpdate(this, "MQTT disconnected.");
}
else
{
OnStatusUpdate(this, "MQTT failed to connect.");
}
});
managedMqttClient.ConnectingFailedHandler = new ConnectingFailedHandlerDelegate(e =>
{
OnError(this, "MQTT connection failed: " + e.Exception.FlattenMessages());
});
await managedMqttClient.StartAsync(managedMqttClientOptions);
string topic = "rtl_433/+/devices/#";
OnStatusUpdate(this, "Will subscribe to topic \"" + topic + "\"");
await managedMqttClient.SubscribeAsync(topic);
}
public async Task StartAsync(CancellationToken cancellationToken)
{
_logger.LogInformation("MQTT background Service is starting ");
await this.ConnectAsync();
if (_client.IsStarted)
{
_logger.LogInformation("client is started");
}
_client.UseConnectedHandler(ConnectHandler);
_client.UseDisconnectedHandler(DisconnectHandler);
_client.UseApplicationMessageReceivedHandler(MessageRecievedHandler);
await _client.SubscribeAsync("ESP/TOLLCOLLECTION");
}
public void Setup()
{
client.UseApplicationMessageReceivedHandler(e =>
{
Console.WriteLine("");
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"));
if (e.ApplicationMessage.Topic == "master/start")
{
if (!recording)
{
recording = true;
publish("\nStart Signal received", "master/response");
_recorder.record();
}
}
else if (e.ApplicationMessage.Topic == "master/stop")
{
if (recording)
{
recording = false;
publish("\nStop Signal received", "master/response");
_recorder.stop();
}
}
});
client.UseDisconnectedHandler(e => {
Console.WriteLine("Attempting to Connect to " + MasterIP);
Console.WriteLine("\nDisconnected from MQTT Broker!");
connected = false;
});
client.UseConnectedHandler(c => {
Console.WriteLine("\nConnected to MQTT Broker @ " + MasterIP + ":" + MasterPort + "!");
connected = true;
});
}
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 IManagedMqttClient SetupConnectionHandler(this IManagedMqttClient mqttClient, ManagedMqttClientOptions options)
{
// Handle disconnection
mqttClient.UseDisconnectedHandler(async e =>
{
Console.WriteLine("### DISCONNECTED FROM SERVER ###");
await Task.Delay(TimeSpan.FromSeconds(5));
try
{
await mqttClient.StartAsync(options);
}
catch
{
Console.WriteLine("### RECONNECTING FAILED ###");
}
});
return(mqttClient);
}
public void Create(ConnectionOptions options, Credentials credentials, string topic)
{
//configure options
var mqttClientOptions = new MqttClientOptionsBuilder()
.WithClientId(credentials.UserName)
.WithTcpServer(options.IpAddress, options.Port)
.WithCredentials(credentials.Login, credentials.Password)
.WithCleanSession()
.Build();
var mqttManagedMqttClientOptions = _options = new ManagedMqttClientOptionsBuilder()
.WithAutoReconnectDelay(TimeSpan.FromSeconds(5))
.WithClientOptions(mqttClientOptions)
.Build();
// Create a new MQTT client.
_client = new MqttFactory().CreateManagedMqttClient();
//handlers
_client.UseConnectedHandler(e =>
{
OnConnected?.Invoke(e);
//subscribing to a topic
if (!string.IsNullOrEmpty(topic))
{
_topic = topic;
_client.SubscribeAsync(new TopicFilterBuilder().WithTopic(topic).Build()).Wait();
}
});
_client.UseDisconnectedHandler(e =>
{
OnDisconnected?.Invoke(e);
});
_client.UseApplicationMessageReceivedHandler(e =>
{
OnMessageReceived?.Invoke(e);
});
}
public static IManagedMqttClient ConfigureMqttEvents(this IManagedMqttClient mqttClient, IServiceProvider serviceProvider, CancellationToken cancellationToken)
{
MqttEvents mqttEvents = serviceProvider.GetService <MqttEvents>();
if (mqttEvents == null)
{
throw new InvalidOperationException($"Unable to find {nameof(MqttEvents)} service. Did you forget to call {nameof(ServiceCollectionExtensions.AddMqttEvents)}()?");
}
mqttClient.UseDisconnectedHandler(async args =>
{
await mqttEvents.InvokeDisconnectHandler(args, cancellationToken);
});
mqttClient.UseConnectedHandler(async args =>
{
await mqttEvents.InvokeConnectHandler(args, cancellationToken);
});
return(mqttClient);
}
/// <summary>
/// Constructor
/// </summary>
public Logic(ILogger <Logic> logger, IOptions <Config> config, IHostEnvironment hostEnvironment)
{
_logger = logger;
_config = config.Value;
_hostEnvironment = hostEnvironment;
_mqttClient = new MqttFactory().CreateManagedMqttClient();
_mqttClient.UseApplicationMessageReceivedHandler(MqttClientOnApplicationMessageReceived);
_mqttClient.UseConnectedHandler(async e =>
{
_logger.LogInformation("Connected to MQTT server");
await _mqttClient.SubscribeAsync(new TopicFilterBuilder().WithTopic(_config.Mqtt.ShutdownTopic)
.Build());
});
_mqttClient.UseDisconnectedHandler(e =>
{
if (e.Exception != null && !e.ClientWasConnected)
{
_logger.LogError(e.Exception, "Unable to connect to MQTT server");
}
if (e.Exception != null && e.ClientWasConnected)
{
_logger.LogError("Disconnected from connect to MQTT server with error", e.Exception);
}
if (e.Exception == null && e.ClientWasConnected)
{
_logger.LogInformation("Disconnected from MQTT server");
}
});
_timeoutTimer = new Timer(_config.TimeoutSeconds * 1000);
_timeoutTimer.Elapsed += async(sender, args) =>
{
_timeoutTimer.Stop();
InitiateShutdown();
};
}
public async Task ConnectAsync()
{
try
{
_mqttClient.UseConnectedHandler(e => { _logger.LogInformation("Connected to Mqtt Broker"); });
_mqttClient.UseDisconnectedHandler(e =>
{
if (e.Exception != null)
{
_logger.LogWarning("Disconnected from Mqtt Broker", e.Exception);
}
});
_mqttClient.UseApplicationMessageReceivedHandler(async e =>
{
try
{
var topic = e.ApplicationMessage.Topic;
if (!string.IsNullOrWhiteSpace(topic))
{
var payload = Encoding.UTF8.GetString(e.ApplicationMessage.Payload);
_logger.LogInformation($"Topic: {topic}. Message Received: {payload}");
await OnReceived(topic, payload);
}
}
catch (Exception ex)
{
_logger.LogError(ex.Message, ex);
}
});
await _mqttClient.StartAsync(_managedOptions);
}
catch (Exception e)
{
_logger.LogError("Failed to start Mqtt Client", e);
throw;
}
}
public MqttService(IHubContext <DevicesHub> hubContext)
{
_hubContext = hubContext;
var messageBuilder = new MqttClientOptionsBuilder().WithClientId(clientId) /*.WithCredentials(mqttUser, mqttPassword)*/.WithTcpServer(mqttURI, mqttPort).WithCleanSession();
var options = mqttSecure
? messageBuilder
.WithTls()
.Build()
: messageBuilder
.Build();
var managedOptions = new ManagedMqttClientOptionsBuilder().WithAutoReconnectDelay(TimeSpan.FromSeconds(5))
.WithClientOptions(options)
.Build();
client = new MqttFactory().CreateManagedMqttClient();
client.StartAsync(managedOptions);
client.UseConnectedHandler(ClientConnectedHandler);
client.UseDisconnectedHandler(ClientDisconnectedHandler);
client.UseApplicationMessageReceivedHandler(ClientMessageReceivedHandler);
}
public MqttListenerService(IManagedMqttClient client, IManagedMqttClientOptions options, IConfiguration configuration, IServiceId serviceId,
ILogger <MqttListenerService> logger, IPointsOfSaleService posService, IServiceProvider serviceProvider, IPosTopicClassifier posTopicClassifier)
{
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
if (serviceId == null)
{
throw new ArgumentNullException(nameof(serviceId));
}
_client = client ?? throw new ArgumentNullException(nameof(client));
_options = options ?? throw new ArgumentNullException(nameof(options));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_posService = posService ?? throw new ArgumentNullException(nameof(posService));
_posTopicClassifier = posTopicClassifier ?? throw new ArgumentNullException(nameof(posTopicClassifier));
_client.UseApplicationMessageReceivedHandler(OnMqttMessageReceived);
_client.UseConnectedHandler(args => OnConnectedHandler(args));
_client.UseDisconnectedHandler(args => OnDisconnectedHandler(args));
_messageHandlers = serviceProvider.GetServices <IMqttMessageHandler>().ToArray();
}
public Logic(ILogger <Logic> logger, IHostEnvironment hostEnvironment)
{
_logger = logger;
_hostEnvironment = hostEnvironment;
var fileName = Path.Combine(_hostEnvironment.ContentRootPath, "config.yml");
Directory.CreateDirectory(Path.Combine(_hostEnvironment.ContentRootPath, "tokens"));
if (!File.Exists(fileName))
{
throw new FileNotFoundException("Config file not found", fileName);
}
var yaml = File.ReadAllText(fileName);
using (var input = new StringReader(yaml))
{
var deserializer = new DeserializerBuilder()
.WithNamingConvention(CamelCaseNamingConvention.Instance)
.IgnoreUnmatchedProperties()
.Build();
_config = deserializer.Deserialize <Config>(input);
}
_mqttSubscriptions = new List <MqttSubscription>();
_mqttClient = new MqttFactory().CreateManagedMqttClient();
_mqttClient.UseApplicationMessageReceivedHandler(MqttClientOnApplicationMessageReceived);
_mqttClient.UseConnectedHandler(e => { _logger.LogInformation("Connected to MQTT server"); });
_mqttClient.UseDisconnectedHandler(e =>
{
if (e.Exception != null && !e.ClientWasConnected)
{
_logger.LogError(e.Exception, "Unable to connect to MQTT server");
}
if (e.Exception != null && e.ClientWasConnected)
{
_logger.LogError("Disconnected from connect to MQTT server with error", e.Exception);
}
if (e.Exception == null && e.ClientWasConnected)
{
_logger.LogInformation("Disconnected from MQTT server");
}
});
_requestPolicy = Policy
.Handle <FlurlHttpException>(r => r.Call.HttpStatus == HttpStatusCode.Unauthorized)
.RetryAsync(1, async(exception, i) =>
{
var call = (exception as FlurlHttpException)?.Call;
if (!(call?.FlurlRequest is FlurlApiRequest req))
{
return;
}
_logger.LogError("Access forbidden", exception);
_logger.LogInformation($"Authenticating for api {req.Api.Name}");
await ExecuteAuthentication(req.Api);
});
}
private async void but_start_ClickAsync(object sender, EventArgs even)
{
but_Stop_Click(null, null);
var factory = new MqttFactory();
mqttClient = factory.CreateManagedMqttClient();
var mqttClientOptions = new MqttClientOptionsBuilder()
.WithClientId(txt_ClientID.Text?.Trim())
.WithTcpServer(txt_Address.Text?.Trim(), int.Parse(txt_Port.Text?.Trim()))
.WithCredentials(txt_UserName.Text, txt_Password.Text);
if (checkBox1.Checked)
{
if (!File.Exists(txt_ca_file.Text))
{
MessageBox.Show($"没有找到文件:{txt_ca_file.Text}");
return;
}
if (!File.Exists(txt_pfx_file.Text))
{
MessageBox.Show($"没有找到文件:{txt_pfx_file.Text}");
return;
}
var caCert = X509Certificate.CreateFromCertFile(txt_ca_file.Text);
var clientCert = new X509Certificate2(txt_pfx_file.Text);
mqttClientOptions = mqttClientOptions.WithTls(new MqttClientOptionsBuilderTlsParameters()
{
UseTls = true,
SslProtocol = System.Security.Authentication.SslProtocols.Tls12,
CertificateValidationHandler = (o) =>
{
return(true);
},
Certificates = new List <X509Certificate>()
{
caCert, clientCert
}
});
}
var options = new ManagedMqttClientOptionsBuilder()
.WithAutoReconnectDelay(TimeSpan.FromSeconds(5))
.WithClientOptions(mqttClientOptions.Build())
.Build();
await mqttClient.StartAsync(options);
mqttClient.UseDisconnectedHandler(e =>
{
WriteLine_1("### 服务器断开连接 ###");
});
mqttClient.UseApplicationMessageReceivedHandler(e =>
{
WriteLine_1("### 收到消息 ###");
WriteLine_1($"+ Topic = {e.ApplicationMessage.Topic}");
try
{
WriteLine_1($"+ Payload = {Encoding.UTF8.GetString(e.ApplicationMessage.Payload)}");
}
catch { }
WriteLine_1($"+ QoS = {e.ApplicationMessage.QualityOfServiceLevel}");
WriteLine_1($"+ Retain = {e.ApplicationMessage.Retain}");
WriteLine_1();
});
mqttClient.UseConnectedHandler(e =>
{
WriteLine_1("### 连接到服务 ###");
but_Start.Enabled = false;
but_Subscribe.Enabled = true;
but_Publish.Enabled = true;
but_Stop.Enabled = true;
});
}
/// <summary>
/// Initialize
/// </summary>
/// <param name="mqttHost"></param>
/// <param name="mqttPort"></param>
/// <param name="mqttRootTopic"></param>
/// <param name="callbackAddress"></param>
/// <param name="callbackPort"></param>
/// <param name="bridgeUrl"></param>
/// <param name="token"></param>
/// <param name="hashToken"></param>
/// <param name="infoInterval"></param>
private void Initialize(string mqttHost, int?mqttPort, string mqttRootTopic, string callbackAddress,
int?callbackPort, string bridgeUrl, string token, bool hashToken, int?infoInterval)
{
_mqttRootTopic = !string.IsNullOrEmpty(mqttRootTopic) ? mqttRootTopic : "nukibridge";
_mqttHost = !string.IsNullOrEmpty(mqttHost) ? mqttHost : "localhost";
_mqttPort = mqttPort ?? 1883;
_bridgeUrl = !string.IsNullOrEmpty(bridgeUrl) ? bridgeUrl : NukiBridgeClient.DiscoverBridge();
_bridgeToken = token;
if (string.IsNullOrEmpty(_bridgeUrl) ||
string.IsNullOrEmpty(_bridgeToken))
{
throw new Exception("No Bridge_URL and/or Bridge_Token defined");
}
_hashToken = hashToken;
// Setup MQTT
_mqttClient = new MqttFactory().CreateManagedMqttClient();
_mqttClient.UseApplicationMessageReceivedHandler(e => MqttClientOnApplicationMessageReceived(e));
_mqttClient.UseConnectedHandler(e =>
{
Log.Information("MQTT: Connected");
SubscribeTopic("discover");
SubscribeTopic("reset");
SubscribeTopic("reboot");
SubscribeTopic("fw-upgrade");
});
_mqttClient.UseDisconnectedHandler(e =>
{
if (e.ClientWasConnected)
{
Log.Warning($"MQTT: Disconnected ({e.Exception?.Message ?? "clean"})");
}
else
{
Log.Error($"MQTT: Unable to connect ({e.Exception?.Message ?? "clean"})");
}
});
_nukiBridgeClient = new NukiBridgeClient(_bridgeUrl, _bridgeToken, _hashToken);
// Setup callback
_callbackAddress = callbackAddress ?? LocalIpAddress().ToString();
_callbackPort = callbackPort ?? 8080;
_httpListener = new HttpListener
{
Prefixes = { $"http://+:{_callbackPort}/" }
};
_devices = new List <Device>();
// Prevent info interval being set to 0
if ((infoInterval ?? 0) == 0)
{
infoInterval = 300;
}
// Setup info interval
_infoTimer = new Timer((infoInterval ?? 300) * 1000);
_infoTimer.Elapsed += async(sender, args) =>
{
_infoTimer.Stop();
await PublishBridgeInfo();
_infoTimer.Start();
};
}
public static async Task ConnectAsync()
{
string clientId = Guid.NewGuid().ToString();
string mqttURI = "127.0.0.1";
string mqttUser = "******";
string mqttPassword = "******";
int mqttPort = 1883;
bool mqttSecure = false;
var messageBuilder = new MqttClientOptionsBuilder()
.WithClientId(clientId)
.WithCredentials(mqttUser, mqttPassword)
.WithTcpServer(mqttURI, mqttPort)
.WithProtocolVersion(MqttProtocolVersion.V500)
//.WithTls()
.WithCleanSession();
var options = mqttSecure ? messageBuilder.WithTls().Build() : messageBuilder.Build();
var managedOptions = new ManagedMqttClientOptionsBuilder()
.WithAutoReconnectDelay(TimeSpan.FromSeconds(5))
.WithClientOptions(options)
.Build();
client = new MqttFactory().CreateManagedMqttClient();
await client.StartAsync(managedOptions);
client.UseConnectedHandler(e =>
{
Console.WriteLine("Connected successfully with MQTT Brokers.");
});
await SubscribeAsync("+/+/+/+");
//await SubscribeAsync("let/me/in/pep");
Console.WriteLine(client.IsStarted + " " + client.IsConnected);
client.UseDisconnectedHandler(e =>
{
Console.WriteLine("Disconnected from MQTT Brokers." + e.ClientWasConnected + " " + e?.AuthenticateResult?.ReasonString);
});
client.UseApplicationMessageReceivedHandler(e =>
{
try
{
string topic = e.ApplicationMessage.Topic;
if (string.IsNullOrWhiteSpace(topic) == false)
{
string payload = Encoding.UTF8.GetString(e.ApplicationMessage.Payload);
Console.WriteLine($"Topic: {topic}. Message Received: {payload}");
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message, ex);
}
});
}
/// <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 { }
});
}
private static async Task ConnectAsync()
{
const string mqttUri = "localhost";
var mqttUser = "******";
var mqttPassword = "******";
var mqttPort = 1883;
Console.WriteLine($"MQTT Server:{mqttUri} Username:{mqttUser} ClientID:{leadvehicle}");
var messageBuilder = new MqttClientOptionsBuilder()
.WithClientId(leadvehicle)
.WithCredentials(mqttUser, mqttPassword)
.WithTcpServer(mqttUri, mqttPort)
.WithKeepAlivePeriod(new TimeSpan(0, 0, 30))
.WithCleanSession();
var options = messageBuilder
.Build();
var managedOptions = new ManagedMqttClientOptionsBuilder()
.WithAutoReconnectDelay(TimeSpan.FromSeconds(5))
.WithClientOptions(options)
.Build();
await client.StartAsync(managedOptions);
client.UseConnectedHandler(e => { Console.WriteLine("Connected successfully with MQTT Brokers."); });
client.UseApplicationMessageReceivedHandler(e =>
{
Console.WriteLine("Connected UseApplicationMessageReceivedHandler with MQTT Brokers." + e.ApplicationMessage);
});
client.UseDisconnectedHandler(e =>
{
new MqttClientDisconnectedHandlerDelegate(e => MqttClient_Disconnected(e));
Console.WriteLine("Disconnected from MQTT Brokers.Client Was Connected " + e.ClientWasConnected);
});
client.UseApplicationMessageReceivedHandler(e =>
{
try
{
var topic = e.ApplicationMessage.Topic;
if (!string.IsNullOrWhiteSpace(topic))
{
var stringpayload = Encoding.UTF8.GetString(e.ApplicationMessage.Payload);
var bitArray = new BitArray(e.ApplicationMessage.Payload);
var payload = HelperFunctions.GetPayload(e.ApplicationMessage.Payload);
var py = HelperFunctions.ToBitString(new BitArray(e.ApplicationMessage.Payload), 0, 61);
Console.WriteLine($"Topic: {topic}. Message Received: {py}");
var followingVehicle = topic.Replace("platooning/" + leadvehicle + "/", "");
if (payload.Maneuver == 1 && !string.IsNullOrWhiteSpace(followingVehicle))
{
payload.Maneuver = 2;
var message = new BitArray(61);
message.Set(0, false);
message.Set(1, true);
message.Set(2, false);
_ = PublishAsync("platooning/" + followingVehicle + "/" + leadvehicle + "/" + platoonId, Encoding.ASCII.GetString(HelperFunctions.BitArrayToByteArray(message)));
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message, ex);
}
});
}
internal MqttClientMeasure(Rainmeter.API api)
{
ParentMeasures.Add(this);
ParentRainmeterApis.Add(api);
this.Rainmeter = api;
this.Name = api.GetMeasureName();
Skin = api.GetSkin();
DebugLevel = (ushort)api.ReadInt("DebugLevel", 0);
Server = api.ReadString("Server", "localhost");
Port = (ushort)api.ReadInt("Port", 1883);
RetryInterval = (ushort)api.ReadDouble("RetryInterval", 5.0);
ClientId = api.ReadString("ClientId", Guid.NewGuid().ToString());
Username = api.ReadString("Username", "");
Password = new SecureString();
foreach (char ch in api.ReadString("Password", ""))
{
Password.AppendChar(ch);
}
/* Mqtt Server Bangs */
OnConnectBangs = SplitBangs(api.ReadString("OnConnect", ""));
OnDisconnectBangs = SplitBangs(api.ReadString("OnConnect", ""));
OnReloadBangs = SplitBangs(api.ReadString("OnReload", ""));
OnMessageBangs = SplitBangs(api.ReadString("OnMessage", ""));
MqttClient = Factory.CreateManagedMqttClient();
/* Setup Event Handlers */
MqttClient.UseConnectedHandler(e =>
{
if (!MqttClientMeasure.ParentRainmeterApis.Contains(Rainmeter))
{
return;
}
Log(API.LogType.Notice, "Connected to " + Server + " : " + Port);
if (OnConnectBangs.Length > 0)
{
Log(API.LogType.Notice, "Executing OnConnect Bangs");
ExecuteBangs(OnConnectBangs);
}
});
MqttClient.UseApplicationMessageReceivedHandler(e =>
{
if (!MqttClientMeasure.ParentRainmeterApis.Contains(Rainmeter))
{
return;
}
e.GetType();
String topic = e.ApplicationMessage.Topic;
String payload = Encoding.UTF8.GetString(e.ApplicationMessage.Payload);
try
{
Debug("### RECEIVED APPLICATION MESSAGE ###", 3);
Debug($" >> Topic = {e.ApplicationMessage.Topic}", 4);
Debug($" >> Payload = {Encoding.UTF8.GetString(e.ApplicationMessage.Payload)}", 4);
Debug($" >> QoS = {e.ApplicationMessage.QualityOfServiceLevel}", 5);
Debug($" >> Retain = {e.ApplicationMessage.Retain}", 5);
if (Topics.Contains(topic))
{
Topics[topic] = payload;
Log(API.LogType.Notice, "Received update for " + topic);
}
else
{
Topics.Add(topic, payload);
Log(API.LogType.Warning, "Received payload for unknown topic " + topic);
}
if (OnMessageBangs.Length > 0)
{
Log(API.LogType.Notice, "Executing OnMessage Bangs");
ExecuteBangs(OnMessageBangs);
}
}
catch
{
// Error Application
}
});
MqttClient.UseDisconnectedHandler(e =>
{
if (!MqttClientMeasure.ParentRainmeterApis.Contains(Rainmeter))
{
return;
}
Log(API.LogType.Error, e.Exception?.Message);
Log(API.LogType.Error, e.AuthenticateResult?.ReasonString);
Log(API.LogType.Error, e.ClientWasConnected.ToString());
if (!MqttClient.IsConnected)
{
Log(API.LogType.Warning, "Lost previous connection to " + Server + " : " + Port);
}
if (OnDisconnectBangs.Length > 0)
{
Log(API.LogType.Notice, "Executing OnDisconnect Bangs");
ExecuteBangs(OnDisconnectBangs);
}
});
try
{
Log(API.LogType.Warning, "Connecting to " + Server + " : " + Port + "...");
ConnectAsync(Server, Port, Username, Password, ClientId).Wait();
}
catch (Exception ex)
{
Log(API.LogType.Error, "Exception trying to connect: " + ex);
return;
}
}
private static async Task ConnectAsync()
{
//const string mqttUri = "mqttbroker.westeurope.azurecontainer.io";
string mqttUri = configuration["mqttServerIp"];
var mqttUser = configuration["mqttUser"];;
var mqttPassword = configuration["mqttPassword"];;
var mqttPort = Convert.ToInt32(configuration["mqttPort"]);
Console.WriteLine($"MQTT Server:{mqttUri} Username:{mqttUser} ClientID:{leadvehicle}");
var messageBuilder = new MqttClientOptionsBuilder()
.WithClientId(leadvehicle)
.WithCredentials(mqttUser, mqttPassword)
.WithTcpServer(mqttUri, mqttPort)
.WithKeepAlivePeriod(new TimeSpan(0, 0, 30))
.WithCleanSession();
var options = messageBuilder
.Build();
var managedOptions = new ManagedMqttClientOptionsBuilder()
.WithAutoReconnectDelay(TimeSpan.FromSeconds(2))
.WithClientOptions(options)
.Build();
await client.StartAsync(managedOptions);
client.UseConnectedHandler(e => { Console.WriteLine("Connected successfully with MQTT Brokers."); });
client.UseApplicationMessageReceivedHandler(e =>
{
Console.WriteLine("Connected UseApplicationMessageReceivedHandler with MQTT Brokers." + e.ApplicationMessage);
});
client.UseDisconnectedHandler(e =>
{
new MqttClientDisconnectedHandlerDelegate(e => MqttClient_Disconnected(e));
Console.WriteLine("Disconnected from MQTT Brokers.Client Was Connected " + e.ClientWasConnected);
});
client.UseApplicationMessageReceivedHandler(e =>
{
try
{
var topic = e.ApplicationMessage.Topic;
if (!string.IsNullOrWhiteSpace(topic))
{
var stringpayload = Encoding.UTF8.GetString(e.ApplicationMessage.Payload);
var bitArray = new BitArray(e.ApplicationMessage.Payload);
var payload = HelperFunctions.GetPayload(e.ApplicationMessage.Payload);
var py = HelperFunctions.ToBitString(new BitArray(e.ApplicationMessage.Payload), 0, bitcount);
Console.WriteLine($"Topic: {topic}. Message Received: {py}");
var followingVehicle = topic.Split('/');
var key = ConsoleKey.A;
if (key == ConsoleKey.A)
{
if (payload.Maneuver == 1 && !string.IsNullOrWhiteSpace(followingVehicle[2]))
{
payload.Maneuver = 2;
var message = new BitArray(bitcount);
message.Set(0, false);
message.Set(1, true);
message.Set(2, false);
var pubtopic = "platooning/" + followingVehicle[2] + "/" + leadvehicle + "/" +
platoonId;
_ = PublishAsync(
pubtopic,
Encoding.ASCII.GetString(HelperFunctions.BitArrayToByteArray(message)));
Console.WriteLine($"Publish Topic: {pubtopic}. Message Received: {Encoding.ASCII.GetString(HelperFunctions.BitArrayToByteArray(message))}");
}
}
else if (key == ConsoleKey.R)
{
if (payload.Maneuver == 1 && !string.IsNullOrWhiteSpace(followingVehicle[2]))
{
payload.Maneuver = 3;
var message = new BitArray(bitcount);
message.Set(0, false);
message.Set(1, true);
message.Set(2, true);
_ = PublishAsync(
"platooning/" + followingVehicle[2] + "/" + leadvehicle + "/" + platoonId,
Encoding.ASCII.GetString(HelperFunctions.BitArrayToByteArray(message)));
}
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message, ex);
}
});
}
