示例#1
0
        public async Task NewMessageIsProcessedWell()
        {
            // Arrange
            var mockManagedMqttClient        = new Mock <IManagedMqttClient>();
            var mockManagedMqttClientOptions = new Mock <IManagedMqttClientOptions>();
            var mockMqttClientFactory        = new Mock <IMqttClientFactory>();

            mockMqttClientFactory
            .Setup(m => m.CreateManagedMqttClient())
            .Returns(mockManagedMqttClient.Object);

            var config         = new MqttConfiguration("CustomConfig", mockManagedMqttClientOptions.Object);
            var mqttConnection = new MqttConnection(mockMqttClientFactory.Object, config, _mockLogger.Object);

            IMqttMessage receivedMessage = null;

            mqttConnection.OnMessageEventHandler += (MqttMessageReceivedEventArgs arg) =>
            {
                receivedMessage = arg.Message;
                return(Task.CompletedTask);
            };

            // Act
            await mqttConnection.StartAsync();

            mockManagedMqttClient.Raise(x => x.ApplicationMessageReceived += null, new MqttApplicationMessageReceivedEventArgs("ClientId", DefaultMessage));

            // Assert
            Assert.NotNull(receivedMessage);
            Assert.Equal(DefaultMessage.Topic, receivedMessage.Topic);
            Assert.Equal(DefaultMessage.Retain, receivedMessage.Retain);
            Assert.Equal(DefaultMessage.QualityOfServiceLevel.ToString(), receivedMessage.QosLevel.ToString());
            Assert.Equal(DefaultMessage.Payload, receivedMessage.GetMessage());
        }
示例#2
0
        public static void image_mqtt_ingest(
            [MqttTrigger("site/+/grids/+/sensors/image/#")] IMqttMessage message,
            ILogger logger,
            IBinder binder)
        {
            // topic structure: sites/xx/grids/dd/sensors/image/bin/#
            // topic structure: sites/xx/grids/dd/sensors/image/status/#
            var topicParts = message.Topic.Split('/');
            var siteid     = topicParts[1];
            var imagepath  = string.Join('/', topicParts.Skip(6).SkipLast(1));
            var blobname   = topicParts.Last();

            logger.LogInformation($"CreateBlobUsingBinder function processed: {message}");
            using (var writer = binder.Bind <Stream>(new BlobAttribute(
                                                         $"brc-images/sites/{siteid}/{imagepath}/{blobname}.jpg", FileAccess.Write)))
            {
                writer.Write(message.GetMessage());
            };

            using (var writer = binder.Bind <Stream>(new BlobAttribute(
                                                         $"brc-images/sites/{siteid}/{imagepath}/latest.jpg", FileAccess.Write)))
            {
                writer.Write(message.GetMessage());
            };
        }
        public static async Task OnTTNDeviceEvent([MqttTrigger(typeof(TTNConfigProvider), "%TTNAppID%/devices/+/events/#")] IMqttMessage message, ILogger logger)
        {
            logger.LogInformation($"{DateTime.Now:g} Message for topic {message.Topic}");

            var messageParts = message.Topic.Split('/');
            var deviceId     = messageParts[2];
            var deviceEvent  = messageParts[4];

            using (var registryManager = RegistryManager.CreateFromConnectionString(AzureConfigProvider.GetIoTHubConnectionString()))
            {
                // TODO: This is a workaround for https://github.com/chkr1011/MQTTnet/issues/569. To be implemented in the correct way once this is fixed.
                switch (deviceEvent)
                {
                case "create":
                {
                    await registryManager.AddDeviceAsync(new Device(deviceId));

                    logger.LogInformation($"{DateTime.Now:g} Added device {deviceId} to IoT Hub");
                }
                break;

                case "delete":
                {
                    await registryManager.RemoveDeviceAsync(deviceId);

                    logger.LogInformation($"{DateTime.Now:g} Removed device {deviceId} from IoT Hub");
                }
                break;

                default:
                    break;
                }
            }
        }
        public static void AdvancedFunction(
            [MqttTrigger(typeof(ExampleMqttConfigProvider), "testtopic/#")] IMqttMessage message,
            ILogger log)
        {
            var body = Encoding.UTF8.GetString(message.GetMessage());

            log.LogInformation($"Advanced: message from topic {message.Topic} body: {body}");
        }
 public async Task MotionFunction(
     [MqttTrigger("dafang/dafang/motion", ConnectionString = "MqttConnectionForMotion")] IMqttMessage snapshot,
     [Mqtt(ConnectionString = "MqttConnectionForMotion")] ICollector <IMqttMessage> outMessages,
     [Blob("motion/{sys.utcnow}.png", FileAccess.Write)] CloudBlockBlob outputBlob,
     ILogger log,
     ExecutionContext context)
 {
     await DoCameraAndMotionMagic(outMessages, outputBlob, log, context);
 }
        public static void SimpleFunction(
            [MqttTrigger("test/#")] IMqttMessage message,
            [Mqtt] out IMqttMessage outMessage,
            ILogger logger)
        {
            var body       = message.GetMessage();
            var bodyString = Encoding.UTF8.GetString(body);

            logger.LogInformation($"Message for topic {message.Topic}: {bodyString}");
            outMessage = new MqttMessage("testtopic/out", Encoding.UTF8.GetBytes("Hi!"), MqttQualityOfServiceLevel.AtLeastOnce, true);
        }
示例#7
0
 protected void FireNetworkError(IMqttMessage message, Exception ex)
 {
     if (NetworkError != null)
     {
         NetworkError(this, new MqttMessageEventArgs
         {
             Message   = message,
             Exception = ex
         });
     }
 }
示例#8
0
            public static void Testert(
                [MqttTrigger("test/topic", ConnectionString = "MqttConnectionWithCustomPort")] IMqttMessage incomgingMessage,
                [Mqtt] out IMqttMessage outGoingMessage)
            {
                LastIncomingMessage = incomgingMessage;
                CallCount++;

                var updatedBody = Encoding.UTF8.GetBytes("{\"test\":\"message\"}");

                outGoingMessage = new MqttMessage("test/outtopic", updatedBody, MqttQualityOfServiceLevel.AtLeastOnce, true);
            }
示例#9
0
        protected override void OnSendMessageAsyncCompleted(string clientUid, IMqttMessage message, Exception exception)
        {
            MessageType messageType = message.MessageType;

            if (messageType == MessageType.Connect && exception == null)
            {
                _keepAliveTimer.Start();
            }
            else
            {
                _keepAliveTimer.Reset();
            }
        }
示例#10
0
            public static void Testert(
                [MqttTrigger("test/topic")] IMqttMessage incomgingMessage,
                [Mqtt] out IMqttMessage outGoingMessage,
                [Mqtt] out IMqttMessage outGoingMessage2)
            {
                LastIncomingMessage = incomgingMessage;
                Interlocked.Increment(ref CallCount);

                var updatedBody = Encoding.UTF8.GetBytes("{\"test\":\"message\"}");

                outGoingMessage  = new MqttMessage("test/outtopic", updatedBody, MqttQualityOfServiceLevel.AtLeastOnce, true);
                outGoingMessage2 = new MqttMessage("test/outtopic2", updatedBody, MqttQualityOfServiceLevel.AtLeastOnce, true);
            }
        public static async Task OnTTNDeviceDeleted([MqttTrigger(typeof(TTNConfigProvider), "%TTNAppID%/devices/+/events/delete")] IMqttMessage message, ILogger logger)
        {
            logger.LogInformation($"{DateTime.Now:g} Device deletion message for topic {message.Topic}");

            var messageParts = message.Topic.Split('/');
            var deviceId     = messageParts[2];

            using (var registryManager = RegistryManager.CreateFromConnectionString(AzureConfigProvider.GetIoTHubConnectionString()))
            {
                await registryManager.RemoveDeviceAsync(deviceId);

                logger.LogInformation($"{DateTime.Now:g} Removed device {deviceId} from IoT Hub");
            }
        }
示例#12
0
        public async Task ProcessTimeRace([MqttTrigger("ESP/TimeRace/ToDB", ConnectionString = "MqttConnection2")] IMqttMessage message, ILogger logger)
        {
            try
            {
                var body       = message.GetMessage();
                var bodyString = Encoding.UTF8.GetString(body);
                var records    = JsonConvert.DeserializeObject <timelogtodb>(bodyString);

                CloudStorageAccount storageAccount = CloudStorageAccount.Parse(Environment.GetEnvironmentVariable("tablestorageconnection"));
                CloudTableClient    tableClient    = storageAccount.CreateCloudTableClient(new Microsoft.Azure.Cosmos.Table.TableClientConfiguration());
                CloudTable          table          = tableClient.GetTableReference("LeaderboardTimeRace");

                TableQuery <timelogtodbEntity> getquery = new TableQuery <timelogtodbEntity>()
                                                          .Where(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, records.name));

                var getQueryResult = await table.ExecuteQuerySegmentedAsync <timelogtodbEntity>(getquery, null);

                timelogtodbEntity entity = new timelogtodbEntity();

                if (getQueryResult.Results.Count == 0)
                {
                    entity.PartitionKey = records.name;
                    entity.RowKey       = Guid.NewGuid().ToString();
                    entity.isFinished   = records.isFinished;
                    entity.totalTime    = records.totalTime;
                }
                else
                {
                    entity.PartitionKey = records.name;
                    entity.RowKey       = getQueryResult.Results[0].RowKey;
                    if (records.totalTime == 0)
                    {
                        entity.isFinished = records.isFinished;
                        entity.totalTime  = getQueryResult.Results[0].totalTime;
                    }
                    else
                    {
                        entity.isFinished = records.isFinished;
                        entity.totalTime  = records.totalTime;
                    }
                }

                TableOperation insertOrMergeOperation = Microsoft.Azure.Cosmos.Table.TableOperation.InsertOrMerge(entity);
                TableResult    result = await table.ExecuteAsync(insertOrMergeOperation);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        public static async Task Run([MqttTrigger("minicursoiot/+/#", ConnectionString = "MqttConnectionString")] IMqttMessage data, ILogger log, ExecutionContext context)
        {
            log.LogInformation($"Payload {Convert.ToBase64String(data.GetMessage())}");
            var config = new ConfigurationBuilder()
                         .SetBasePath(context.FunctionAppDirectory)
                         .AddJsonFile("local.settings.json", optional: true, reloadOnChange: true)
                         .AddEnvironmentVariables()
                         .Build();

            if (IoTHub == null)
            {
                IoTHub = new IoTHubClient(config["IoTHubConnectionString"]);
            }
            await IoTHub.SendRaw(data.Topic, data.GetMessage());
        }
        public static void SimpleFunction(
            [MqttTrigger(new[] { "owntracks/kees/kees01", "owntracks/marleen/marleen01" })]IMqttMessage message,
            ILogger log,
            [Table("Locations", Connection = "AzureWebJobsStorage")] out Trail trail)
        {
            var body = Encoding.UTF8.GetString(message.GetMessage());

            log.LogInformation($"Message from topic {message.Topic} body: {body}");

            trail = JsonConvert.DeserializeObject<Trail>(body);
            trail.PartitionKey = message.Topic.Replace("/", "_");
            trail.RowKey = DateTime.Now.Ticks.ToString();
            trail.QosLevel = message.QosLevel.ToString();
            trail.Retain = message.Retain;
        }
示例#15
0
        public static void MQTTFunctionsNoResend([MqttTrigger("/home/temperature")] IMqttMessage message, ILogger log)
        {
            //getting the message that has been sent
            var    body        = message.GetMessage();
            string bodyMessage = Encoding.UTF8.GetString(body);

            log.LogInformation($"MQTTFunctionsNoResend: {bodyMessage}");

            /*
             *
             * Do stuff with the message
             * for example Post to database, etc...
             *
             */
        }
示例#16
0
        private async Task PublishAsync(IMqttMessage message)
        {
            var payload = message.Payload;

            var applicationMessage = new MqttApplicationMessageBuilder()
                                     .WithTopic(_topic)
                                     .WithPayload(payload)
                                     .WithAtLeastOnceQoS()
                                     .Build();

            Console.WriteLine("### SENDING APPLICATION MESSAGE ###");
            Console.WriteLine($"+ Topic = {_topic}");
            Console.WriteLine($"+ Payload = {payload}");
            Console.WriteLine();

            await _mqttClient.PublishAsync(applicationMessage);
        }
示例#17
0
        public static ActionResult AddTimeRaceTotalTime(
            [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "TimeRace/Time")] HttpRequest req,
            [Mqtt] out IMqttMessage outMessage,
            ILogger log)
        {
            try
            {
                string requestBody = new StreamReader(req.Body).ReadToEnd();

                outMessage = new MqttMessage("ESP/TimeRace/ToDB", Encoding.ASCII.GetBytes(requestBody), MqttQualityOfServiceLevel.AtMostOnce, false);

                return(new StatusCodeResult(200));
            }
            catch (Exception ex)
            {
                outMessage = null;
                return(new StatusCodeResult(500));
            }
        }
示例#18
0
        public static void CloudToDeviceMessages(
            [MqttTrigger("devices/testdevice/messages/devicebound/#", "$iothub/methods/POST/#", ConnectionString = "IoTHubConnectionString"), Disable] IMqttMessage message,
            [Mqtt(ConnectionString = "IoTHubConnectionString"), Disable] out IMqttMessage response,
            ILogger logger)
        {
            var body       = message.GetMessage();
            var bodyString = Encoding.UTF8.GetString(body);

            logger.LogInformation($"{DateTime.Now:g} Message for topic {message.Topic}: {bodyString}");

            if (message.Topic.Contains("methods"))
            {
                response = CloudToDeviceMethodCall(message.Topic);
            }
            else
            {
                response = null;
            }
        }
示例#19
0
        /// <summary>
        /// Saves a message into the store and begins the response timer. If the message is not pulled from the store
        /// before the response timer ends, the MessageTimeout event is fired.
        /// </summary>
        /// <param name="message">The message sent to the remote endpoint. I.e. Publish, Subscribe, etc.</param>
        /// <param name="eventData">Client defined data associated with the message.</param>
        /// <param name="clientUid">The socket connection context.</param>
        public void Add(IMqttMessage message, object eventData, string clientUid)
        {
            var storeData = new MessageStoreData
            {
                Message       = message,
                MessageId     = MqttMessageBase.GetMessageIdOrDefault(message),
                EventData     = eventData,
                ResponseTimer = new TimeoutTimer(MqttProtocolInformation.Settings.NetworkTimeout),
                ClientUid     = clientUid
            };

            lock (_lock)
            {
                _pendingMessageData.Add(storeData);
            }

            storeData.ResponseTimer.TimeOutData = storeData;
            storeData.ResponseTimer.Timeout    += ResponseTimerOnTimeout;
            storeData.ResponseTimer.Start();
        }
示例#20
0
        /// <summary>
        /// Saves a message into the store and begins the response timer. If the message is not pulled from the store
        /// before the response timer ends, the MessageTimeout event is fired.
        /// </summary>
        /// <param name="message">The message sent to the remote endpoint. I.e. Publish, Subscribe, etc.</param>
        /// <param name="eventData">Client defined data associated with the message.</param>
        /// <param name="clientUid">The socket connection context.</param>
        public void Add(IMqttMessage message, object eventData, string clientUid)
        {
            var storeData = new MessageStoreData
            {
                Message = message,
                MessageId = MqttMessageBase.GetMessageIdOrDefault(message),
                EventData = eventData,
                ResponseTimer = new TimeoutTimer(MqttProtocolInformation.Settings.NetworkTimeout),
                ClientUid = clientUid
            };

            lock (_lock)
            {
                _pendingMessageData.Add(storeData);
            }

            storeData.ResponseTimer.TimeOutData = storeData;
            storeData.ResponseTimer.Timeout += ResponseTimerOnTimeout;
            storeData.ResponseTimer.Start();
        }
示例#21
0
        public static void MQTTFunctionsWithResend([MqttTrigger("/home/temperature")] IMqttMessage message, [Mqtt] out IMqttMessage outMessage, ILogger log)
        {
            //getting the message that has been sent
            var    body        = message.GetMessage();
            string bodyMessage = Encoding.UTF8.GetString(body);

            log.LogInformation($"MQTTFunctionsWithResend: {bodyMessage}");

            //sending back a message to a topic
            var newMessage = $"{message} from server";

            outMessage = new MqttMessage("/out", Encoding.ASCII.GetBytes(newMessage),
                                         MqttQualityOfServiceLevel.AtLeastOnce, true);

            /*
             *
             * Do stuff with the message
             * for example Post to database, etc...
             *
             */
        }
示例#22
0
 public static void Testert2([MqttTrigger(typeof(TestMqttConfigProvider), "test/+/2")] IMqttMessage mqttMessage)
 {
     CallCountFunction2++;
     LastReceivedMessageFunction2 = mqttMessage;
 }
示例#23
0
 /// <summary>
 /// Finds the original message for the given response, pulls it out of the store, stops the response timeout
 /// and returns the client defined event data
 /// </summary>
 /// <param name="responseMessage">The expected response message for the stored message. I.e. PubAck, SubAck, etc.</param>
 /// <param name="clientUid">The connection context.</param>
 /// <returns></returns>
 public object Remove(IMqttMessage responseMessage, string clientUid)
 {
     return Remove(responseMessage.MessageType, MqttMessageBase.GetMessageIdOrDefault(responseMessage), clientUid);
 }
示例#24
0
 /// <summary>
 /// Called when an send message has completed but before any expected responsed.
 /// </summary>
 /// <param name="clientUid"></param>
 /// <param name="message"></param>
 /// <param name="exception"></param>
 /// <returns></returns>
 protected virtual void OnSendMessageAsyncCompleted(string clientUid, IMqttMessage message, Exception exception)
 {
 }
        public static void Run(
            [MqttTrigger("/luemniro/id/request")] IMqttMessage message, [Mqtt] out IMqttMessage outMessage, ILogger logger)
        {
            // Creating Telemetry client for logging events!
            TelemetryClient telemetry = new TelemetryClient();

            // Getting connection string
            telemetry.InstrumentationKey = Environment.GetEnvironmentVariable("insightsString");
            // Receiving the message and creating an object from it
            var body       = message.GetMessage();
            var bodyString = Encoding.UTF8.GetString(body);

            // Logging with time
            logger.LogInformation($"{DateTime.Now:g} Message for topic {message.Topic}: {bodyString}");
            ID iD = JsonConvert.DeserializeObject <ID>(bodyString);

            // Checking if the ID isn't already in the database

            // Checking if the ID is exactly 6 digits long
            try
            {
                if (iD.Id.ToString().Length == 6)
                {
                    bool IDResponse = InsertGameID.InsertId(iD.Id);
                    // If it's 6 digits long and NOT in the database
                    if (IDResponse)
                    {
                        var response     = new { id = iD.Id, status = "OK" };
                        var jsonResponse = JsonConvert.SerializeObject(response);
                        outMessage = new MqttMessage("/luemniro/id/response", Encoding.ASCII.GetBytes(jsonResponse), MqttQualityOfServiceLevel.AtLeastOnce, true);
                        logger.LogInformation("ID {iD.Id} is OK", iD.Id);
                        telemetry.TrackEvent("ID_Given");
                        telemetry.TrackEvent("ID_OK");
                    }
                    // If the ID is already in the database
                    else
                    {
                        var response     = new { id = iD.Id, status = "NOK" };
                        var jsonResponse = JsonConvert.SerializeObject(response);
                        outMessage = new MqttMessage("/luemniro/id/response", Encoding.ASCII.GetBytes(jsonResponse), MqttQualityOfServiceLevel.AtLeastOnce, true);
                        logger.LogInformation("ID {iD.Id} is NOK, ID already in database", iD.Id);
                        telemetry.TrackEvent("ID_NOK");
                    }
                }
                // If the ID is NOT 6 digits long!
                else
                {
                    var response     = new { id = iD.Id, status = "NOK" };
                    var jsonResponse = JsonConvert.SerializeObject(response);
                    outMessage = new MqttMessage("/luemniro/id/response", Encoding.ASCII.GetBytes(jsonResponse), MqttQualityOfServiceLevel.AtLeastOnce, true);
                    logger.LogInformation("ID {iD.Id} is NOK, ID does not consist of exactly 6 digits", iD.Id);
                    telemetry.TrackEvent("ID_NOK");
                }
            }
            catch (Exception ex)
            {
                logger.LogInformation("ID {iD.Id} is NOK: " + ex);
                telemetry.TrackEvent("ID_NOK");

                throw ex;
            }
        }
示例#26
0
 public static void Testert([MqttTrigger("test/topic", ConnectionString = "MqttConnectionWithCustomClientId")] IMqttMessage mqttMessage)
 {
     CallCount++;
     LastReceivedMessage = mqttMessage;
 }
示例#27
0
 /// <summary>
 /// Finds the original message for the given response, pulls it out of the store, stops the response timeout
 /// and returns the client defined event data
 /// </summary>
 /// <param name="responseMessage">The expected response message for the stored message. I.e. PubAck, SubAck, etc.</param>
 /// <param name="clientUid">The connection context.</param>
 /// <returns></returns>
 public object Remove(IMqttMessage responseMessage, string clientUid)
 {
     return(Remove(responseMessage.MessageType, MqttMessageBase.GetMessageIdOrDefault(responseMessage), clientUid));
 }
示例#28
0
 protected void FireNetworkError(IMqttMessage message, Exception ex)
 {
     if (NetworkError != null)
     {
         NetworkError(this, new MqttMessageEventArgs
         {
             Message = message,
             Exception = ex
         });
     }
 }
示例#29
0
 /// <summary>
 /// If the specified message has an ID, it will return it. Otherwise return the pre-defined default ID.
 /// </summary>
 /// <param name="message"></param>
 /// <returns></returns>
 public static int GetMessageIdOrDefault(IMqttMessage message)
 {
     var msgWithId = message as IMqttIdMessage;
     return msgWithId == null ? DefaultMessageId : msgWithId.MessageId;
 }
示例#30
0
 public static void Testert([MqttTrigger("test/topic", ConnectionString = "MqttConnectionWithUsernameAndPassword")] IMqttMessage mqttMessage)
 {
     CallCount++;
 }
示例#31
0
 public static void Testert([MqttTrigger("test/topic")] IMqttMessage mqttMessage)
 {
     Interlocked.Increment(ref CallCount);
     LastReceivedMessage = mqttMessage;
 }
        public static IMqttMessage Deserialize(
#if WIN_PCL
            [ReadOnlyArray]
#endif
            byte[] buffer
            )
        {
            var          msgType      = ReadMessageTypeFromHeader(buffer[0]);
            IMqttMessage resultingMsg = null;

            switch (msgType)
            {
            case MessageType.Connect:
                resultingMsg = MqttConnectMessage.InternalDeserialize(buffer);
                break;

            case MessageType.ConnAck:
                resultingMsg = MqttConnectAckMessage.InternalDeserialize(buffer);
                break;

            case MessageType.Disconnect:
                resultingMsg = MqttDisconnectMessage.InternalDeserialize(buffer);
                break;

            case MessageType.PubAck:
                resultingMsg = MqttPublishAckMessage.InternalDeserialize(buffer);
                break;

            case MessageType.PubRec:
                resultingMsg = MqttPublishReceivedMessage.InternalDeserialize(buffer);
                break;

            case MessageType.PubRel:
                resultingMsg = MqttPublishReleaseMessage.InternalDeserialize(buffer);
                break;

            case MessageType.PubComp:
                resultingMsg = MqttPublishCompleteMessage.InternalDeserialize(buffer);
                break;

            case MessageType.Publish:
                resultingMsg = MqttPublishMessage.InternalDeserialize(buffer);
                break;

            case MessageType.Subscribe:
                resultingMsg = MqttSubscribeMessage.InternalDeserialize(buffer);
                break;

            case MessageType.SubAck:
                resultingMsg = MqttSubscribeAckMessage.InternalDeserialize(buffer);
                break;

            case MessageType.Unsubscribe:
                resultingMsg = MqttUnsubscribeMessage.InternalDeserialize(buffer);
                break;

            case MessageType.UnsubAck:
                resultingMsg = MqttUnsubscribeAckMessage.InternalDeserialize(buffer);
                break;

            case MessageType.PingReq:
                resultingMsg = MqttPingRequestMessage.InternalDeserialize(buffer);
                break;

            case MessageType.PingResp:
                resultingMsg = MqttPingResponseMessage.InternalDeserialize(buffer);
                break;
            }

            return(resultingMsg);
        }
示例#33
0
 /// <summary>
 /// Called when an MQTT message has completed processing.
 /// I.e. at the end of a publish qos=2 sequence, at the end of a connect/conack sequence, etc.
 /// </summary>
 /// <param name="clientUid"></param>
 /// <param name="message"></param>
 /// <param name="eventData"></param>
 /// <param name="exception"></param>
 /// <returns></returns>
 protected virtual void OnMqttMessageCompleted(string clientUid, IMqttMessage message, object eventData, Exception exception)
 {
 }
示例#34
0
 public static void Testert([Mqtt] out IMqttMessage mqttMessage)
 {
     mqttMessage = new MqttMessage("test/topic", new byte[] { }, MqttQualityOfServiceLevel.AtLeastOnce, true);
 }
示例#35
0
 public static void Testert([MqttTrigger(typeof(TestMqttConfigProvider), "%TopicName%/#")] IMqttMessage mqttMessage)
 {
     CallCount++;
     LastReceivedMessage = mqttMessage;
 }
示例#36
0
 public static void Testert([MqttTrigger("test/topic")] IMqttMessage mqttMessage)
 {
     CallCount++;
     LastReceivedMessage = mqttMessage;
 }
示例#37
0
        public void SendMessageAsync(IMqttMessage msg, object eventData, string clientUid)
        {
            Logger.LogMessage("Protocol", LogLevel.Verbose, "SendMessageAsync(" + msg.MessageType + ")");

            var args = new SocketEventArgs
            {
                MessageToSend = msg,
                ClientUid = clientUid
            };

            // If we expect a response, push the event data on our stack and retrieve it with the response
            if (args.MessageToSend.ExpectedResponse != MessageType.None)
            {
                _messageStore.Add(args.MessageToSend, eventData, clientUid);
            }

            args.OnOperationComplete((eventArgs) =>
            {
                MessageType messageType = eventArgs.MessageToSend.MessageType;

                string exceptionText = eventArgs.SocketException == null
                    ? "Success."
                    : "Error: " + eventArgs.SocketException.ToString();
                Logger.LogMessage("Protocol", LogLevel.Verbose, "SendMessageAsync(" + messageType + ") completed callback. " + exceptionText);

                if (eventArgs.SocketException != null)
                {
                    // Clean up pending message queue
                    _messageStore.Remove(args.MessageToSend.ExpectedResponse, MqttMessageBase.GetMessageIdOrDefault(args.MessageToSend), clientUid);
                }

                OnSendMessageAsyncCompleted(clientUid, eventArgs.MessageToSend, eventArgs.SocketException);

                if (messageType == MessageType.Connect && eventArgs.SocketException != null)
                {
                    FireConnectComplete(new MqttNetEventArgs
                    {
                        Message = args.MessageToSend,
                        Exception = eventArgs.SocketException,
                        AdditionalErrorInfo = eventArgs.AdditionalErrorInfo,
                        EventData = eventData,
                        ClientUid = clientUid
                    });
                }
                else if (messageType == MessageType.Disconnect)
                {
                    CloseConnection(clientUid);
                    FireSendMessageComplete(new MqttNetEventArgs
                    {
                        Message = args.MessageToSend,
                        Exception = eventArgs.SocketException,
                        AdditionalErrorInfo = eventArgs.AdditionalErrorInfo,
                        EventData = eventData,
                        ClientUid = clientUid
                    });
                }
                else if (messageType == MessageType.Subscribe && eventArgs.SocketException != null)
                {
                    FireSubscribeMessageComplete(new MqttNetEventArgs
                    {
                        Message = args.MessageToSend,
                        Exception = eventArgs.SocketException,
                        AdditionalErrorInfo = eventArgs.AdditionalErrorInfo,
                        EventData = eventData,
                        ClientUid = clientUid
                    });
                }
                else if (args.MessageToSend.ExpectedResponse == MessageType.None || eventArgs.SocketException != null)
                {
                    FireSendMessageComplete(new MqttNetEventArgs
                    {
                        Message = args.MessageToSend,
                        Exception = eventArgs.SocketException,
                        AdditionalErrorInfo = eventArgs.AdditionalErrorInfo,
                        EventData = eventData,
                        ClientUid = clientUid
                    });
                }
            });

            Socket.WriteAsync(args);
        }