Example #1
0
 void ValidatePublishResult(MqttClientPublishResult publishResult)
 {
     if (publishResult.ReasonCode != MqttClientPublishReasonCode.Success)
     {
         throw new MqttException(isTemporary: IsTemporaryFailure(publishResult.ReasonCode), message: $"Publish failed: [code={publishResult.ReasonCode}, message={publishResult.ReasonString}].");
     }
 }
Example #2
0
        public void SendMQTTMessageToMultipleInstances(string tenantId, List <string> toInstanceIds, MQTTMessage message)
        {
            Task task = Task.Factory.StartNew(async() =>
            {
                MqttClientPublishResult res = null;

                var myMqttClient = _mqttClients.SingleOrDefault(c => (c.TenantId + "-" + c.TenantType).CompareTo(tenantId) == 0);

                message.ToInstancesIds = toInstanceIds;

                string jsonMessage = JsonConvert.SerializeObject(message);

                if (myMqttClient != null && myMqttClient.mqttClient.IsConnected)
                {
                    res = await myMqttClient.mqttClient.PublishAsync(myMqttClient.mqttTopic, jsonMessage, MyMQTTClient.MQTTQualityOfService);
                    InstanceHealthService.Health.MQTTMessagesSent += 1;
                }
                else
                {
                    if (MQTTSendQueue.CheckIfMQTTIsConfigured())
                    {
                        MQTTSendQueue.MessagesToSend.Add(new MQTTQueueMessage()
                        {
                            Topic         = myMqttClient.mqttTopic,
                            QueuedMessage = jsonMessage,
                            QoS           = MyMQTTClient.MQTTQualityOfService
                        });
                    }
                }

                return(res);
            });
        }
Example #3
0
        public override bool Send(string val, List <Variable> vars)
        {
            MqttApplicationMessage msg = new MqttApplicationMessageBuilder()
                                         .WithTopic(topic)
                                         .WithPayload(val)
                                         .WithExactlyOnceQoS()
                                         .WithRetainFlag()
                                         .Build();

            //"broker.hivemq.com", 1883)
            if (serverType == "tcp")
            {
                options = new MqttClientOptionsBuilder().WithTcpServer(mqttServer, mqttServerPort).Build();
            }

            //"broker.hivemq.com:8000/mqtt"
            if (serverType == "ws")
            {
                options = new MqttClientOptionsBuilder().WithWebSocketServer(mqttServerURL).Build();
            }
            if (!mqttClient.IsConnected)
            {
                mqttClient.ConnectAsync(options).Wait();
            }

            MqttClientPublishResult result = mqttClient.PublishAsync(msg, CancellationToken.None).Result;

            if (result.ReasonCode != MqttClientPublishReasonCode.Success)
            {
                Console.WriteLine($"MQTT Send Failure {result.ReasonString}");
                return(false);
            }

            return(true);
        }
        private async void btTest_ClickAsync(object sender, EventArgs e)
        {
            btTest.Enabled    = false;
            btnSave.Enabled   = false;
            btnCancel.Enabled = false;

            try
            {
                AppSettings.Settings.mqtt_serverandport = tb_ServerPort.Text.Trim();
                AppSettings.Settings.mqtt_password      = tb_Password.Text.Trim();
                AppSettings.Settings.mqtt_username      = tb_Username.Text.Trim();
                AppSettings.Settings.mqtt_UseTLS        = cb_UseTLS.Checked;

                using (Global_GUI.CursorWait cw = new Global_GUI.CursorWait())
                {
                    Global.Log("------ TESTING MQTT --------");


                    string topic   = AITOOL.ReplaceParams(this.cam, null, tb_Topic.Text.Trim());
                    string payload = AITOOL.ReplaceParams(this.cam, null, tb_Payload.Text.Trim());

                    List <string> topics   = Global.Split(topic, ";|");
                    List <string> payloads = Global.Split(payload, ";|");

                    MQTTClient mq = new MQTTClient();
                    MqttClientPublishResult pr = null;

                    for (int i = 0; i < topics.Count; i++)
                    {
                        pr = await mq.PublishAsync(topics[i], payloads[i], cam.Action_mqtt_retain_message);
                    }

                    Global.Log("------ DONE TESTING MQTT --------");

                    if (pr != null && (pr.ReasonCode == MqttClientPublishReasonCode.Success))
                    {
                        MessageBox.Show("Success! See Log for details.");
                    }
                    else if (pr != null)
                    {
                        MessageBox.Show($"Failed. See log for details. Reason={pr.ReasonCode}", "", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    }
                    else
                    {
                        MessageBox.Show($"Failed. See log for details.", "", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    }
                }
            }
            catch
            {
            }
            finally
            {
                btTest.Enabled    = true;
                btnSave.Enabled   = true;
                btnCancel.Enabled = true;
            }
        }
 private static void EnsureResultSuccessful(MqttClientPublishResult result)
 {
     if (result.ReasonCode != MqttClientPublishReasonCode.Success)
     {
         throw new IOException("Failed to publish message!")
               {
                   Data = { { "Result", result } }
               };
     }
 }
Example #6
0
        /// <summary>
        /// Publishes the device slice.
        /// </summary>
        private bool PublishDeviceSlice(DeviceSlice deviceSlice)
        {
            try
            {
                if (topicByDevice.TryGetValue(deviceSlice.DeviceNum, out DeviceTopics deviceTopics))
                {
                    int dataIndex = 0;

                    foreach (DeviceTag deviceTag in deviceSlice.DeviceTags)
                    {
                        if (!string.IsNullOrEmpty(deviceTag.Code) &&
                            deviceTopics.TryGetValue(deviceTag.Code, out string topic))
                        {
                            string payloadStr = BuildPayload(deviceTag, deviceSlice.CnlData, dataIndex);
                            MqttApplicationMessage message = new()
                            {
                                Topic   = topic,
                                Payload = Encoding.UTF8.GetBytes(payloadStr),
                                QualityOfServiceLevel = (MqttQualityOfServiceLevel)dsOptions.PublishOptions.QosLevel,
                                Retain = dsOptions.PublishOptions.Retain
                            };

                            if (dsOptions.PublishOptions.DetailedLog)
                            {
                                dsLog.WriteAction("{0} {1} = {2}", CommPhrases.SendNotation, topic, payloadStr);
                            }

                            MqttClientPublishResult result = mqttClientHelper.Publish(message);

                            if (result.ReasonCode != MqttClientPublishReasonCode.Success)
                            {
                                dsLog.WriteError(CommPhrases.ErrorPrefix + result.ReasonCode);
                                return(false);
                            }
                        }

                        dataIndex += deviceTag.DataLength;
                    }
                }

                return(true);
            }
            catch (Exception ex)
            {
                dsLog.WriteError(ex, Locale.IsRussian ?
                                 "Ошибка при публикации данных" :
                                 "Error publishing data");
                return(false);
            }
        }
    public void SetResponseCode(MqttClientPublishReasonCode code)
    {
        var publishResult = new MqttClientPublishResult()
        {
            ReasonCode = code
        };

        // Ensure that when the MQTT Client is called, it's published message is saved and that it returns
        // the specified response code
        MqttClient.Setup(m => m.PublishAsync(It.IsAny <MqttApplicationMessage>(), It.IsAny <CancellationToken>()))
        .Callback <MqttApplicationMessage, CancellationToken>((message, token) =>
        {
            LastPublishedMessage = message;
        })
        .ReturnsAsync(publishResult);
    }
Example #8
0
    private async Task <MQTTnet.Client.Publishing.MqttClientPublishResult> PublishAsync(string topic, string message)
    {
        if (_client != null && _client.IsConnected)
        {
            var mqttmsg = new MqttApplicationMessageBuilder()
                          .WithTopic(topic)
                          .WithPayload(message)
                          .Build();

            MqttClientPublishResult result = await _client.PublishAsync(mqttmsg);

            return(result);
        }
        else
        {
            return(null);
        }
    }
Example #9
0
        public override async Task <ExchangeMessage> SendToOutputAsync(ExchangeMessage message)
        {
            // Create a new MQTT client.

            var msg = new MqttApplicationMessageBuilder()
                      .WithTopic(topic)
                      .WithPayload(message.payload)
                      .WithExactlyOnceQoS()
                      .WithRetainFlag()
                      .Build();

            //"broker.hivemq.com", 1883)
            if (serverType == "tcp")
            {
                options = new MqttClientOptionsBuilder().WithTcpServer(mqttServer, mqttServerPort).Build();
            }

            //"broker.hivemq.com:8000/mqtt"
            if (serverType == "ws")
            {
                options = new MqttClientOptionsBuilder().WithWebSocketServer(mqttServerURL).Build();
            }
            if (!mqttClient.IsConnected)
            {
                mqttClient.ConnectAsync(options).Wait();
            }

            MqttClientPublishResult result = await mqttClient.PublishAsync(msg, CancellationToken.None);

            if (result.ReasonCode == MqttClientPublishReasonCode.Success)
            {
                message.sent   = true;
                message.status = $"Sent to MQTT topic {queueName}";
                return(message);
            }
            else
            {
                message.sent   = true;
                message.status = $"MQTT Send Failure {result.ReasonString}";
                logger.Error($"MQTT Send Failure {result.ReasonString}");
                return(message);
            }
        }
Example #10
0
        public MqttClientPublishResult CreatePublishResult(MqttPubAckPacket pubAckPacket)
        {
            var result = new MqttClientPublishResult
            {
                ReasonCode     = MqttClientPublishReasonCode.Success,
                ReasonString   = pubAckPacket?.Properties?.ReasonString,
                UserProperties = pubAckPacket?.Properties?.UserProperties
            };

            if (pubAckPacket != null)
            {
                // QoS 0 has no response. So we treat it as a success always.
                // Both enums have the same values. So it can be easily converted.
                result.ReasonCode = (MqttClientPublishReasonCode)pubAckPacket.ReasonCode;

                result.PacketIdentifier = pubAckPacket.PacketIdentifier;
            }

            return(result);
        }
Example #11
0
        public MqttClientPublishResult CreatePublishResult(MqttPubRecPacket pubRecPacket, MqttPubCompPacket pubCompPacket)
        {
            if (pubRecPacket == null || pubCompPacket == null)
            {
                return(new MqttClientPublishResult
                {
                    ReasonCode = MqttClientPublishReasonCode.UnspecifiedError
                });
            }

            // The PUBCOMP is the last packet in QoS 2. So we use the results from that instead of PUBREC.
            if (pubCompPacket.ReasonCode == MqttPubCompReasonCode.PacketIdentifierNotFound)
            {
                return(new MqttClientPublishResult
                {
                    PacketIdentifier = pubCompPacket.PacketIdentifier,
                    ReasonCode = MqttClientPublishReasonCode.UnspecifiedError,
                    ReasonString = pubCompPacket.Properties?.ReasonString,
                    UserProperties = pubCompPacket.Properties?.UserProperties
                });
            }

            var result = new MqttClientPublishResult
            {
                PacketIdentifier = pubCompPacket.PacketIdentifier,
                ReasonCode       = MqttClientPublishReasonCode.Success,
                ReasonString     = pubCompPacket.Properties?.ReasonString,
                UserProperties   = pubCompPacket.Properties?.UserProperties
            };

            if (pubRecPacket.ReasonCode.HasValue)
            {
                // Both enums share the same values.
                result.ReasonCode = (MqttClientPublishReasonCode)pubRecPacket.ReasonCode.Value;
            }

            return(result);
        }
        private async void btTest_ClickAsync(object sender, EventArgs e)
        {
            AppSettings.Settings.mqtt_serverandport = tb_ServerPort.Text.Trim();
            AppSettings.Settings.mqtt_password      = tb_Password.Text.Trim();
            AppSettings.Settings.mqtt_username      = tb_Username.Text.Trim();
            AppSettings.Settings.mqtt_UseTLS        = cb_UseTLS.Checked;

            MQTTClient mq = new MQTTClient();

            MqttClientPublishResult pr = await mq.PublishAsync(tb_Topic.Text.Trim(), tb_Payload.Text.Trim());

            if (pr != null && (pr.ReasonCode == MqttClientPublishReasonCode.Success))
            {
                MessageBox.Show("Success.");
            }
            else if (pr != null)
            {
                MessageBox.Show($"Failed. See log. Reason={pr.ReasonCode}", "", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
            else
            {
                MessageBox.Show($"Failed. See log.", "", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }
 public EventPublishedResult(EventType publishedEvent, MqttClientPublishResult publishResult)
 {
     PublishedEvent = publishedEvent;
     PublishResult  = publishResult;
 }
Example #14
0
 /// <summary>
 ///     Initializes a new instance of the <see cref="MqttProduceException" /> class with the
 ///     specified message.
 /// </summary>
 /// <param name="message">
 ///     The exception message.
 /// </param>
 /// <param name="result">
 ///     The <see cref="MqttClientPublishResult" />.
 /// </param>
 public MqttProduceException(string message, MqttClientPublishResult result)
     : base(message)
 {
     Result = result;
 }
Example #15
0
        public async Task <MqttClientPublishResult> PublishAsync(string topic, string payload, bool retain, ClsImageQueueItem CurImg)
        {
            using var Trace = new Trace();  //This c# 8.0 using feature will auto dispose when the function is done.

            MqttClientPublishResult res = null;
            Stopwatch sw = Stopwatch.StartNew();

            await Task.Run(async() =>
            {
                MqttFactory factory = new MqttFactory();

                IMqttClient mqttClient = null;
                bool subscribed        = false;
                bool IsConnected       = false;

                using (mqttClient = factory.CreateMqttClient())
                {
                    try
                    {
                        string server = Global.GetWordBetween(AppSettings.Settings.mqtt_serverandport, "", ":");
                        string port   = Global.GetWordBetween(AppSettings.Settings.mqtt_serverandport, ":", "/");
                        int portint   = 0;
                        if (!string.IsNullOrEmpty(port))
                        {
                            portint = Convert.ToInt32(port);
                        }
                        if (portint == 0 && AppSettings.Settings.mqtt_UseTLS)
                        {
                            portint = 8883;
                        }
                        else if (portint == 0)
                        {
                            portint = 1883;
                        }

                        bool IsWebSocket = (AppSettings.Settings.mqtt_serverandport.IndexOf("ws://", StringComparison.OrdinalIgnoreCase) >= 0 ||
                                            AppSettings.Settings.mqtt_serverandport.IndexOf("/mqtt", StringComparison.OrdinalIgnoreCase) >= 0 ||
                                            AppSettings.Settings.mqtt_serverandport.IndexOf("wss://", StringComparison.OrdinalIgnoreCase) >= 0);

                        bool UseTLS = (AppSettings.Settings.mqtt_UseTLS || portint == 8883 || AppSettings.Settings.mqtt_serverandport.ToLower().Contains("wss://"));

                        bool UseCreds = (!string.IsNullOrWhiteSpace(AppSettings.Settings.mqtt_username));

                        IMqttClientOptions options;


                        //=====================================================================
                        //Seems like there should be a better way here with this Options builder...
                        //I dont see an obvious way to directly modify options without the builder
                        //and I cant seem to put IF statements around each part of the option builder
                        //parameters.
                        //=====================================================================



                        if (UseTLS)
                        {
                            if (UseCreds)
                            {
                                if (IsWebSocket)
                                {
                                    options = new MqttClientOptionsBuilder()
                                              .WithClientId(AppSettings.Settings.mqtt_clientid)
                                              .WithWebSocketServer(AppSettings.Settings.mqtt_serverandport)
                                              .WithCredentials(AppSettings.Settings.mqtt_username, AppSettings.Settings.mqtt_password)
                                              .WithTls()
                                              .WithCleanSession()
                                              .Build();
                                }
                                else
                                {
                                    options = new MqttClientOptionsBuilder()
                                              .WithClientId(AppSettings.Settings.mqtt_clientid)
                                              .WithTcpServer(server, portint)
                                              .WithCredentials(AppSettings.Settings.mqtt_username, AppSettings.Settings.mqtt_password)
                                              .WithTls()
                                              .WithCleanSession()
                                              .Build();
                                }
                            }
                            else
                            {
                                if (IsWebSocket)
                                {
                                    options = new MqttClientOptionsBuilder()
                                              .WithClientId(AppSettings.Settings.mqtt_clientid)
                                              .WithWebSocketServer(AppSettings.Settings.mqtt_serverandport)
                                              .WithTls()
                                              .WithCleanSession()
                                              .Build();
                                }
                                else
                                {
                                    options = new MqttClientOptionsBuilder()
                                              .WithClientId(AppSettings.Settings.mqtt_clientid)
                                              .WithTcpServer(server, portint)
                                              .WithTls()
                                              .WithCleanSession()
                                              .Build();
                                }
                            }
                        }
                        else
                        {
                            if (UseCreds)
                            {
                                if (IsWebSocket)
                                {
                                    options = new MqttClientOptionsBuilder()
                                              .WithClientId(AppSettings.Settings.mqtt_clientid)
                                              .WithWebSocketServer(AppSettings.Settings.mqtt_serverandport)
                                              .WithCredentials(AppSettings.Settings.mqtt_username, AppSettings.Settings.mqtt_password)
                                              .WithCleanSession()
                                              .Build();
                                }
                                else
                                {
                                    options = new MqttClientOptionsBuilder()
                                              .WithClientId(AppSettings.Settings.mqtt_clientid)
                                              .WithTcpServer(server, portint)
                                              .WithCredentials(AppSettings.Settings.mqtt_username, AppSettings.Settings.mqtt_password)
                                              .WithCleanSession()
                                              .Build();
                                }
                            }
                            else
                            {
                                if (IsWebSocket)
                                {
                                    options = new MqttClientOptionsBuilder()
                                              .WithClientId(AppSettings.Settings.mqtt_clientid)
                                              .WithTcpServer(server, portint)
                                              .WithCleanSession()
                                              .Build();
                                }
                                else
                                {
                                    options = new MqttClientOptionsBuilder()
                                              .WithClientId(AppSettings.Settings.mqtt_clientid)
                                              .WithWebSocketServer(AppSettings.Settings.mqtt_serverandport)
                                              .WithCleanSession()
                                              .Build();
                                }
                            }
                        }

                        if (string.IsNullOrWhiteSpace(topic))
                        {
                            topic = Guid.NewGuid().ToString();
                        }

                        mqttClient.UseDisconnectedHandler(async e =>
                        {
                            IsConnected = false;
                            string excp = "";
                            if (e.Exception != null)
                            {
                                excp = e.Exception.Message;
                            }
                            Log($"Debug: MQTT: ### DISCONNECTED FROM SERVER ### - Reason: {e.ReasonCode}, ClientWasDisconnected: {e.ClientWasConnected}, {excp}");

                            //reconnect here if needed?
                        });


                        mqttClient.UseApplicationMessageReceivedHandler(async e =>
                        {
                            Log($"Debug: MQTT: ### RECEIVED APPLICATION MESSAGE ###");
                            Log($"Debug: MQTT: + Topic = {e.ApplicationMessage.Topic}");
                            if (e.ApplicationMessage.Payload.Length < 64)
                            {
                                Log($"Debug: MQTT: + Payload = {Encoding.UTF8.GetString(e.ApplicationMessage.Payload)}");
                            }
                            Log($"Debug: MQTT: + QoS = {e.ApplicationMessage.QualityOfServiceLevel}");
                            Log($"Debug: MQTT: + Retain = {e.ApplicationMessage.Retain}");
                            Log("");
                        });


                        mqttClient.UseConnectedHandler(async e =>
                        {
                            IsConnected = true;
                            Log($"Debug: MQTT: ### CONNECTED WITH SERVER '{AppSettings.Settings.mqtt_serverandport}' ### - Result: {e.AuthenticateResult.ResultCode}, '{e.AuthenticateResult.ReasonString}'");

                            // Subscribe to the topic
                            await mqttClient.SubscribeAsync(topic, MQTTnet.Protocol.MqttQualityOfServiceLevel.AtLeastOnce);

                            subscribed = true;

                            Log($"Debug: MQTT: ### SUBSCRIBED to topic '{topic}'");
                        });


                        Log($"Debug: MQTT: Sending topic '{topic}' with payload '{payload}' to server '{server}:{portint}'...");


                        MqttClientAuthenticateResult cres = await mqttClient.ConnectAsync(options, CancellationToken.None);

                        if (cres != null && mqttClient.IsConnected && cres.ResultCode == MqttClientConnectResultCode.Success)
                        {
                            IsConnected = true;

                            MqttApplicationMessage ma;

                            if (CurImg != null)
                            {
                                using FileStream image_data = System.IO.File.OpenRead(CurImg.image_path);

                                ma = new MqttApplicationMessageBuilder()
                                     .WithTopic(topic)
                                     .WithPayload(image_data)
                                     .WithAtLeastOnceQoS()
                                     .WithRetainFlag(retain)
                                     .Build();

                                res = await mqttClient.PublishAsync(ma, CancellationToken.None);


                                if (res.ReasonCode == MqttClientPublishReasonCode.Success)
                                {
                                    Log($"Debug: MQTT: ...Sent image in {sw.ElapsedMilliseconds}ms, Reason: '{res.ReasonCode}' ({Convert.ToInt32(res.ReasonCode)} - '{res.ReasonString}')");
                                }
                                else
                                {
                                    Log($"Error: MQTT: sending image: ({sw.ElapsedMilliseconds}ms) Reason: '{res.ReasonCode}' ({Convert.ToInt32(res.ReasonCode)} - '{res.ReasonString}')");
                                }
                            }
                            else
                            {
                                ma = new MqttApplicationMessageBuilder()
                                     .WithTopic(topic)
                                     .WithPayload(payload)
                                     .WithAtLeastOnceQoS()
                                     .WithRetainFlag(retain)
                                     .Build();

                                res = await mqttClient.PublishAsync(ma, CancellationToken.None);

                                //Success = 0,
                                //        NoMatchingSubscribers = 0x10,
                                //        UnspecifiedError = 0x80,
                                //        ImplementationSpecificError = 0x83,
                                //        NotAuthorized = 0x87,
                                //        TopicNameInvalid = 0x90,
                                //        PacketIdentifierInUse = 0x91,
                                //        QuotaExceeded = 0x97,
                                //        PayloadFormatInvalid = 0x99

                                if (res.ReasonCode == MqttClientPublishReasonCode.Success)
                                {
                                    Log($"Debug: MQTT: ...Sent in {sw.ElapsedMilliseconds}ms, Reason: '{res.ReasonCode}' ({Convert.ToInt32(res.ReasonCode)} - '{res.ReasonString}')");
                                }
                                else
                                {
                                    Log($"Error: MQTT: sending: ({sw.ElapsedMilliseconds}ms) Reason: '{res.ReasonCode}' ({Convert.ToInt32(res.ReasonCode)} - '{res.ReasonString}')");
                                }
                            }
                        }
                        else if (cres != null)
                        {
                            IsConnected = false;
                            Log($"Error: MQTT: connecting: ({sw.ElapsedMilliseconds}ms) Result: '{cres.ResultCode}' - '{cres.ReasonString}'");
                        }
                        else
                        {
                            IsConnected = false;
                            Log($"Error: MQTT: Error connecting: ({sw.ElapsedMilliseconds}ms) cres=null");
                        }

                        if (mqttClient != null && mqttClient.IsConnected && IsConnected)
                        {
                            if (subscribed)
                            {
                                Log($"Debug: MQTT: Unsubscribing from topic '{topic}'");
                                await mqttClient.UnsubscribeAsync(topic);
                            }

                            if (mqttClient.IsConnected && IsConnected)
                            {
                                Log($"Debug: MQTT: Disconnecting from server.");
                                try
                                {
                                    await mqttClient.DisconnectAsync();
                                }
                                catch (Exception ex)
                                {
                                    //dont throw ERROR in the log if fail to disconnect
                                    Log($"Debug: MQTT: Could not disconnect from server, got: {Global.ExMsg(ex)}");
                                }
                            }
                            else
                            {
                                Log($"Debug: MQTT: Already disconnected from server, no need to disconnect.");
                            }


                            IsConnected = false;
                        }
                    }
                    catch (Exception ex)
                    {
                        Log($"Error: MQTT: Unexpected Problem: Topic '{topic}' Payload '{payload}': " + Global.ExMsg(ex));
                    }
                    finally
                    {
                        if (mqttClient != null && mqttClient.IsConnected)
                        {
                            if (subscribed)
                            {
                                Log($"Debug: MQTT: Un-Subscribing from topic '{topic}'");
                                await mqttClient.UnsubscribeAsync(topic);
                            }
                            Log($"Debug: MQTT: Disconnecting from server.");
                            await mqttClient.DisconnectAsync();
                            mqttClient.Dispose();                  //using should dispose anyway
                        }
                    }
                }
            });


            return(res);
        }
Example #16
0
        private async void btTest_ClickAsync(object sender, EventArgs e)
        {
            this.btTest.Enabled    = false;
            this.btnSave.Enabled   = false;
            this.btnCancel.Enabled = false;

            try
            {
                AppSettings.Settings.mqtt_serverandport = this.tb_ServerPort.Text.Trim();
                AppSettings.Settings.mqtt_password      = this.tb_Password.Text.Trim();
                AppSettings.Settings.mqtt_username      = this.tb_Username.Text.Trim();
                AppSettings.Settings.mqtt_UseTLS        = this.cb_UseTLS.Checked;

                using (Global_GUI.CursorWait cw = new Global_GUI.CursorWait())
                {
                    Log("------ TESTING MQTT --------");


                    string topic   = AITOOL.ReplaceParams(this.cam, null, null, this.tb_Topic.Text.Trim());
                    string payload = AITOOL.ReplaceParams(this.cam, null, null, this.tb_Payload.Text.Trim());

                    List <string> topics   = Global.Split(topic, ";|");
                    List <string> payloads = Global.Split(payload, ";|");

                    MQTTClient mq = new MQTTClient();
                    MqttClientPublishResult pr     = null;
                    ClsImageQueueItem       CurImg = null;


                    for (int i = 0; i < topics.Count; i++)
                    {
                        if (this.cam.Action_mqtt_send_image)
                        {
                            if (topics[i].IndexOf("/image", StringComparison.OrdinalIgnoreCase) >= 0)
                            {
                                if (!string.IsNullOrEmpty(this.cam.last_image_file_with_detections) && File.Exists(this.cam.last_image_file_with_detections))
                                {
                                    CurImg = new ClsImageQueueItem(this.cam.last_image_file_with_detections, 0);
                                }
                                else if (!string.IsNullOrEmpty(this.cam.last_image_file) && File.Exists(this.cam.last_image_file))
                                {
                                    CurImg = new ClsImageQueueItem(this.cam.last_image_file, 0);
                                }
                                else
                                {
                                    CurImg = null;
                                }
                            }
                            else
                            {
                                CurImg = null;
                            }
                        }

                        pr = await mq.PublishAsync(topics[i], payloads[i], this.cam.Action_mqtt_retain_message, CurImg);
                    }

                    Log("------ DONE TESTING MQTT --------");

                    if (pr != null && (pr.ReasonCode == MqttClientPublishReasonCode.Success))
                    {
                        MessageBox.Show("Success! See Log for details.");
                    }
                    else if (pr != null)
                    {
                        MessageBox.Show($"Failed. See log for details. Reason={pr.ReasonCode}", "", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    }
                    else
                    {
                        MessageBox.Show($"Failed. See log for details.", "", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    }
                }
            }
            catch
            {
            }
            finally
            {
                this.btTest.Enabled    = true;
                this.btnSave.Enabled   = true;
                this.btnCancel.Enabled = true;
            }
        }
Example #17
0
        public async Task <MqttClientPublishResult> PublishAsync(string topic, string payload)
        {
            MqttClientPublishResult res = null;
            Stopwatch sw = Stopwatch.StartNew();

            await Task.Run(async() =>
            {
                MqttFactory factory = new MqttFactory();

                IMqttClient mqttClient = null;
                bool subscribed        = false;

                using (mqttClient = factory.CreateMqttClient())
                {
                    try
                    {
                        string server = Global.GetWordBetween(AppSettings.Settings.mqtt_serverandport, "", ":");
                        string port   = Global.GetWordBetween(AppSettings.Settings.mqtt_serverandport, ":", "/");
                        int portint   = 0;
                        if (!string.IsNullOrEmpty(port))
                        {
                            portint = Convert.ToInt32(port);
                        }
                        if (portint == 0 && AppSettings.Settings.mqtt_UseTLS)
                        {
                            portint = 8883;
                        }
                        else if (portint == 0)
                        {
                            portint = 1883;
                        }

                        bool IsWebSocket = (AppSettings.Settings.mqtt_serverandport.ToLower().Contains("ws://") ||
                                            AppSettings.Settings.mqtt_serverandport.ToLower().Contains("/mqtt") ||
                                            AppSettings.Settings.mqtt_serverandport.ToLower().Contains("wss://"));

                        bool UseTLS = (AppSettings.Settings.mqtt_UseTLS || portint == 8883 || AppSettings.Settings.mqtt_serverandport.ToLower().Contains("wss://"));

                        bool UseCreds = (!string.IsNullOrWhiteSpace(AppSettings.Settings.mqtt_username));

                        IMqttClientOptions options;

                        //=====================================================================
                        //Seems like there should be a better way here with this Options builder...
                        //=====================================================================

                        if (UseTLS)
                        {
                            if (UseCreds)
                            {
                                if (IsWebSocket)
                                {
                                    options = new MqttClientOptionsBuilder()
                                              .WithClientId(AppSettings.Settings.mqtt_clientid)
                                              .WithWebSocketServer(AppSettings.Settings.mqtt_serverandport)
                                              .WithCredentials(AppSettings.Settings.mqtt_username, AppSettings.Settings.mqtt_password)
                                              .WithTls()
                                              .WithCleanSession()
                                              .Build();
                                }
                                else
                                {
                                    options = new MqttClientOptionsBuilder()
                                              .WithClientId(AppSettings.Settings.mqtt_clientid)
                                              .WithTcpServer(server, portint)
                                              .WithCredentials(AppSettings.Settings.mqtt_username, AppSettings.Settings.mqtt_password)
                                              .WithTls()
                                              .WithCleanSession()
                                              .Build();
                                }
                            }
                            else
                            {
                                if (IsWebSocket)
                                {
                                    options = new MqttClientOptionsBuilder()
                                              .WithClientId(AppSettings.Settings.mqtt_clientid)
                                              .WithWebSocketServer(AppSettings.Settings.mqtt_serverandport)
                                              .WithTls()
                                              .WithCleanSession()
                                              .Build();
                                }
                                else
                                {
                                    options = new MqttClientOptionsBuilder()
                                              .WithClientId(AppSettings.Settings.mqtt_clientid)
                                              .WithTcpServer(server, portint)
                                              .WithTls()
                                              .WithCleanSession()
                                              .Build();
                                }
                            }
                        }
                        else
                        {
                            if (UseCreds)
                            {
                                if (IsWebSocket)
                                {
                                    options = new MqttClientOptionsBuilder()
                                              .WithClientId(AppSettings.Settings.mqtt_clientid)
                                              .WithWebSocketServer(AppSettings.Settings.mqtt_serverandport)
                                              .WithCredentials(AppSettings.Settings.mqtt_username, AppSettings.Settings.mqtt_password)
                                              .WithCleanSession()
                                              .Build();
                                }
                                else
                                {
                                    options = new MqttClientOptionsBuilder()
                                              .WithClientId(AppSettings.Settings.mqtt_clientid)
                                              .WithTcpServer(server, portint)
                                              .WithCredentials(AppSettings.Settings.mqtt_username, AppSettings.Settings.mqtt_password)
                                              .WithCleanSession()
                                              .Build();
                                }
                            }
                            else
                            {
                                if (IsWebSocket)
                                {
                                    options = new MqttClientOptionsBuilder()
                                              .WithClientId(AppSettings.Settings.mqtt_clientid)
                                              .WithTcpServer(server, portint)
                                              .WithCleanSession()
                                              .Build();
                                }
                                else
                                {
                                    options = new MqttClientOptionsBuilder()
                                              .WithClientId(AppSettings.Settings.mqtt_clientid)
                                              .WithWebSocketServer(AppSettings.Settings.mqtt_serverandport)
                                              .WithCleanSession()
                                              .Build();
                                }
                            }
                        }

                        if (string.IsNullOrWhiteSpace(topic))
                        {
                            topic = Guid.NewGuid().ToString();
                        }

                        mqttClient.UseDisconnectedHandler(async e =>
                        {
                            string excp = "";
                            if (e.Exception != null)
                            {
                                excp = e.Exception.Message;
                            }
                            Global.Log($"MQTT: ### DISCONNECTED FROM SERVER ### - Reason: {e.ReasonCode}, ClientWasDisconnected: {e.ClientWasConnected}, {excp}");

                            //reconnect here if needed?
                        });


                        mqttClient.UseApplicationMessageReceivedHandler(async e =>
                        {
                            Global.Log($"MQTT: ### RECEIVED APPLICATION MESSAGE ###");
                            Global.Log($"MQTT: + Topic = {e.ApplicationMessage.Topic}");
                            Global.Log($"MQTT: + Payload = {Encoding.UTF8.GetString(e.ApplicationMessage.Payload)}");
                            Global.Log($"MQTT: + QoS = {e.ApplicationMessage.QualityOfServiceLevel}");
                            Global.Log($"MQTT: + Retain = {e.ApplicationMessage.Retain}");
                            Global.Log("");
                        });


                        mqttClient.UseConnectedHandler(async e =>
                        {
                            Global.Log($"MQTT: ### CONNECTED WITH SERVER '{AppSettings.Settings.mqtt_serverandport}' ### - Result: {e.AuthenticateResult.ResultCode}, '{e.AuthenticateResult.ReasonString}'");

                            // Subscribe to the topic
                            await mqttClient.SubscribeAsync(topic, MQTTnet.Protocol.MqttQualityOfServiceLevel.AtLeastOnce);

                            subscribed = true;

                            Global.Log($"MQTT: ### SUBSCRIBED to topic '{topic}'");
                        });


                        Global.Log($"MQTT: Sending topic '{topic}' with payload '{payload}' to server '{server}:{portint}'...");

                        MqttClientAuthenticateResult cres = await mqttClient.ConnectAsync(options, CancellationToken.None);

                        if (cres != null && cres.ResultCode == MqttClientConnectResultCode.Success)
                        {
                            MqttApplicationMessage ma = new MqttApplicationMessageBuilder()
                                                        .WithTopic(topic)
                                                        .WithPayload(payload)
                                                        .WithAtLeastOnceQoS()
                                                        .Build();

                            res = await mqttClient.PublishAsync(ma, CancellationToken.None);

                            //Success = 0,
                            //        NoMatchingSubscribers = 0x10,
                            //        UnspecifiedError = 0x80,
                            //        ImplementationSpecificError = 0x83,
                            //        NotAuthorized = 0x87,
                            //        TopicNameInvalid = 0x90,
                            //        PacketIdentifierInUse = 0x91,
                            //        QuotaExceeded = 0x97,
                            //        PayloadFormatInvalid = 0x99

                            if (res.ReasonCode == MqttClientPublishReasonCode.Success)
                            {
                                Global.Log($"MQTT: ...Sent in {sw.ElapsedMilliseconds}ms, Reason: '{res.ReasonCode}' ({Convert.ToInt32(res.ReasonCode)} - '{res.ReasonString}')");
                            }
                            else
                            {
                                Global.Log($"MQTT: Error sending: ({sw.ElapsedMilliseconds}ms) Reason: '{res.ReasonCode}' ({Convert.ToInt32(res.ReasonCode)} - '{res.ReasonString}')");
                            }
                        }
                        else if (cres != null)
                        {
                            Global.Log($"MQTT:  Error connecting: ({sw.ElapsedMilliseconds}ms) Result: '{cres.ResultCode}' - '{cres.ReasonString}'");
                        }
                        else
                        {
                            Global.Log($"MQTT:  Error connecting: ({sw.ElapsedMilliseconds}ms) cres=null");
                        }

                        if (mqttClient != null && mqttClient.IsConnected)
                        {
                            if (subscribed)
                            {
                                Global.Log($"MQTT: Unsubscribing from topic '{topic}'");
                                await mqttClient.UnsubscribeAsync(topic);
                            }
                            Global.Log($"MQTT: Disconnecting from server.");
                            await mqttClient.DisconnectAsync();
                        }
                    }
                    catch (Exception ex)
                    {
                        Global.Log($"MQTT: Unexpected Error: Topic '{topic}' Payload '{payload}': " + Global.ExMsg(ex));
                    }
                    finally
                    {
                        if (mqttClient != null && mqttClient.IsConnected)
                        {
                            if (subscribed)
                            {
                                Global.Log($"MQTT: Unsubscribing from topic '{topic}'");
                                await mqttClient.UnsubscribeAsync(topic);
                            }
                            Global.Log($"MQTT: Disconnecting from server.");
                            await mqttClient.DisconnectAsync();
                            mqttClient.Dispose();                  //using should dispose anyway
                        }
                    }
                }
            });


            return(res);
        }
Example #18
0
        public async Task <bool> Connect()
        {
            using var Trace = new Trace();  //This c# 8.0 using feature will auto dispose when the function is done.

            bool ret = false;

            try
            {
                this.server  = AppSettings.Settings.mqtt_serverandport.GetWord("", ":");
                this.port    = AppSettings.Settings.mqtt_serverandport.GetWord(":", "/");
                this.portint = 0;

                if (!string.IsNullOrEmpty(this.port))
                {
                    this.portint = Convert.ToInt32(this.port);
                }
                if (this.portint == 0 && AppSettings.Settings.mqtt_UseTLS)
                {
                    this.portint = 8883;
                }
                else if (this.portint == 0)
                {
                    this.portint = 1883;
                }

                bool IsWebSocket = (AppSettings.Settings.mqtt_serverandport.IndexOf("ws://", StringComparison.OrdinalIgnoreCase) >= 0 ||
                                    AppSettings.Settings.mqtt_serverandport.IndexOf("/mqtt", StringComparison.OrdinalIgnoreCase) >= 0 ||
                                    AppSettings.Settings.mqtt_serverandport.IndexOf("wss://", StringComparison.OrdinalIgnoreCase) >= 0);

                bool UseTLS = (AppSettings.Settings.mqtt_UseTLS || portint == 8883 || AppSettings.Settings.mqtt_serverandport.IndexOf("wss://", StringComparison.OrdinalIgnoreCase) >= 0);

                //bool UseCreds = (!string.IsNullOrWhiteSpace(AppSettings.Settings.mqtt_username));



                //=====================================================================
                //Seems like there should be a better way here with this Options builder...
                //I dont see an obvious way to directly modify options without the builder
                //and I cant seem to put IF statements around each part of the option builder
                //parameters.
                //=====================================================================

                var lw = new MqttApplicationMessage()
                {
                    Topic   = AppSettings.Settings.mqtt_LastWillTopic,
                    Payload = Encoding.UTF8.GetBytes(AppSettings.Settings.mqtt_LastWillPayload),
                    QualityOfServiceLevel = MqttQualityOfServiceLevel.AtLeastOnce,
                    Retain = true
                };


                if (UseTLS)
                {
                    if (IsWebSocket)
                    {
                        options = new MqttClientOptionsBuilder()
                                  .WithClientId(AppSettings.Settings.mqtt_clientid)
                                  .WithWebSocketServer(AppSettings.Settings.mqtt_serverandport)
                                  .WithCredentials(AppSettings.Settings.mqtt_username, AppSettings.Settings.mqtt_password)
                                  .WithTls()
                                  .WithWillMessage(lw)
                                  .WithCleanSession()
                                  .Build();
                    }
                    else
                    {
                        options = new MqttClientOptionsBuilder()
                                  .WithClientId(AppSettings.Settings.mqtt_clientid)
                                  .WithTcpServer(server, portint)
                                  .WithCredentials(AppSettings.Settings.mqtt_username, AppSettings.Settings.mqtt_password)
                                  .WithTls()
                                  .WithWillMessage(lw)
                                  .WithCleanSession()
                                  .Build();
                    }
                }
                else
                {
                    if (IsWebSocket)
                    {
                        options = new MqttClientOptionsBuilder()
                                  .WithClientId(AppSettings.Settings.mqtt_clientid)
                                  .WithWebSocketServer(AppSettings.Settings.mqtt_serverandport)
                                  .WithCredentials(AppSettings.Settings.mqtt_username, AppSettings.Settings.mqtt_password)
                                  .WithWillMessage(lw)
                                  .WithCleanSession()
                                  .Build();
                    }
                    else
                    {
                        options = new MqttClientOptionsBuilder()
                                  .WithClientId(AppSettings.Settings.mqtt_clientid)
                                  .WithTcpServer(server, portint)
                                  .WithCredentials(AppSettings.Settings.mqtt_username, AppSettings.Settings.mqtt_password)
                                  .WithWillMessage(lw)
                                  .WithCleanSession()
                                  .Build();
                    }
                }

                mqttClient.UseDisconnectedHandler(async e =>
                {
                    IsConnected = false;
                    string excp = "";
                    if (e.Exception != null)
                    {
                        excp = e.Exception.Message;
                    }
                    Log($"Debug: MQTT: ### DISCONNECTED FROM SERVER ### - Reason: {e.Reason}, ClientWasDisconnected: {e.ClientWasConnected}, {excp}");

                    //reconnect here if needed?
                });


                mqttClient.UseApplicationMessageReceivedHandler(async e =>
                {
                    Log($"Debug: MQTT: ### RECEIVED APPLICATION MESSAGE ###");
                    Log($"Debug: MQTT: + Topic = {e.ApplicationMessage.Topic}");
                    Log($"Debug: MQTT: + Payload = {Encoding.UTF8.GetString(e.ApplicationMessage.Payload).Truncate(128, true)}");
                    Log($"Debug: MQTT: + QoS = {e.ApplicationMessage.QualityOfServiceLevel}");
                    Log($"Debug: MQTT: + Retain = {e.ApplicationMessage.Retain}");
                    Log("");
                });


                mqttClient.UseConnectedHandler(async e =>
                {
                    IsConnected = true;
                    Log($"Debug: MQTT: ### CONNECTED WITH SERVER '{AppSettings.Settings.mqtt_serverandport}' ### - Result: {e.AuthenticateResult.ResultCode}, '{e.AuthenticateResult.ReasonString}'");


                    MqttApplicationMessage ma = new MqttApplicationMessageBuilder()
                                                .WithTopic(AppSettings.Settings.mqtt_LastWillTopic)
                                                .WithPayload(AppSettings.Settings.mqtt_OnlinePayload)
                                                .WithAtLeastOnceQoS()
                                                .WithRetainFlag(true)
                                                .Build();

                    Log($"Debug: MQTT: Sending '{AppSettings.Settings.mqtt_OnlinePayload}' message...");
                    MqttClientPublishResult res = await mqttClient.PublishAsync(ma, CancellationToken.None);

                    //if (!string.IsNullOrWhiteSpace(this.LastTopic))
                    //{
                    //    // Subscribe to the topic
                    //    MqttClientSubscribeResult res = await mqttClient.SubscribeAsync(this.LastTopic, MQTTnet.Protocol.MqttQualityOfServiceLevel.AtLeastOnce);

                    //    IsSubscribed = true;

                    //    Log($"Debug: MQTT: ### SUBSCRIBED to topic '{this.LastTopic}'");
                    //}
                });

                Log($"Debug: MQTT: Connecting to server '{this.server}:{this.portint}' with ClientID '{AppSettings.Settings.mqtt_clientid}', Username '{AppSettings.Settings.mqtt_username}', Password '{AppSettings.Settings.mqtt_username.ReplaceChars('*')}'...");


                cres = await mqttClient.ConnectAsync(options, CancellationToken.None);
            }
            catch (Exception ex)
            {
                Log($"Error: {ex.Msg()}");
            }
            return(ret);
        }
Example #19
0
        public async Task <MqttClientPublishResult> PublishAsync(string topic, string payload, bool retain, ClsImageQueueItem CurImg)
        {
            using var Trace = new Trace();  //This c# 8.0 using feature will auto dispose when the function is done.

            MqttClientPublishResult res = null;
            Stopwatch sw = Stopwatch.StartNew();

            this.LastRetain  = retain;
            this.LastPayload = payload;
            this.LastTopic   = topic;
            if (string.IsNullOrWhiteSpace(topic))
            {
                this.LastTopic = Guid.NewGuid().ToString();
            }

            if (!this.IsConnected)
            {
                await this.Connect();
            }

            if (!this.IsConnected)
            {
                return(res);
            }

            await Task.Run(async() =>
            {
                try
                {
                    Log($"Debug: MQTT: Sending topic '{this.LastTopic}' with payload '{this.LastPayload}' to server '{this.server}:{this.portint}'...");

                    if (cres != null && mqttClient.IsConnected && cres.ResultCode == MqttClientConnectResultCode.Success)
                    {
                        IsConnected = true;

                        MqttApplicationMessage ma;

                        if (CurImg != null)
                        {
                            //using FileStream image_data =  System.IO.File.OpenRead(CurImg.image_path);

                            ma = new MqttApplicationMessageBuilder()
                                 .WithTopic(this.LastTopic)
                                 .WithPayload(CurImg.ToStream())
                                 .WithAtLeastOnceQoS()
                                 .WithRetainFlag(this.LastRetain)
                                 .Build();

                            res = await mqttClient.PublishAsync(ma, CancellationToken.None);


                            if (res.ReasonCode == MqttClientPublishReasonCode.Success)
                            {
                                Log($"Debug: MQTT: ...Sent image in {sw.ElapsedMilliseconds}ms, Reason: '{res.ReasonCode}' ({Convert.ToInt32(res.ReasonCode)} - '{res.ReasonString}')");
                            }
                            else
                            {
                                Log($"Error: MQTT: sending image: ({sw.ElapsedMilliseconds}ms) Reason: '{res.ReasonCode}' ({Convert.ToInt32(res.ReasonCode)} - '{res.ReasonString}')");
                            }
                        }
                        else
                        {
                            ma = new MqttApplicationMessageBuilder()
                                 .WithTopic(this.LastTopic)
                                 .WithPayload(this.LastPayload)
                                 .WithAtLeastOnceQoS()
                                 .WithRetainFlag(this.LastRetain)
                                 .Build();

                            res = await mqttClient.PublishAsync(ma, CancellationToken.None);

                            //Success = 0,
                            //        NoMatchingSubscribers = 0x10,
                            //        UnspecifiedError = 0x80,
                            //        ImplementationSpecificError = 0x83,
                            //        NotAuthorized = 0x87,
                            //        TopicNameInvalid = 0x90,
                            //        PacketIdentifierInUse = 0x91,
                            //        QuotaExceeded = 0x97,
                            //        PayloadFormatInvalid = 0x99

                            if (res.ReasonCode == MqttClientPublishReasonCode.Success)
                            {
                                Log($"Debug: MQTT: ...Sent in {sw.ElapsedMilliseconds}ms, Reason: '{res.ReasonCode}' ({Convert.ToInt32(res.ReasonCode)} - '{res.ReasonString}')");
                            }
                            else
                            {
                                Log($"Error: MQTT: sending: ({sw.ElapsedMilliseconds}ms) Reason: '{res.ReasonCode}' ({Convert.ToInt32(res.ReasonCode)} - '{res.ReasonString}')");
                            }
                        }
                    }
                    else if (cres != null)
                    {
                        IsConnected = false;
                        Log($"Error: MQTT: connecting: ({sw.ElapsedMilliseconds}ms) Result: '{cres.ResultCode}' - '{cres.ReasonString}'");
                    }
                    else
                    {
                        IsConnected = false;
                        Log($"Error: MQTT: Error connecting: ({sw.ElapsedMilliseconds}ms) cres=null");
                    }
                }
                catch (Exception ex)
                {
                    Log($"Error: MQTT: Unexpected Problem: Topic '{this.LastTopic}' Payload '{this.LastPayload}': " + ex.Msg());
                }
                finally
                {
                }
            });


            return(res);
        }