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()); }
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); }
protected void FireNetworkError(IMqttMessage message, Exception ex) { if (NetworkError != null) { NetworkError(this, new MqttMessageEventArgs { Message = message, Exception = ex }); } }
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); }
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(); } }
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"); } }
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; }
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... * */ }
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); }
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)); } }
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; } }
/// <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(); }
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... * */ }
public static void Testert2([MqttTrigger(typeof(TestMqttConfigProvider), "test/+/2")] IMqttMessage mqttMessage) { CallCountFunction2++; LastReceivedMessageFunction2 = mqttMessage; }
/// <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); }
/// <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; } }
public static void Testert([MqttTrigger("test/topic", ConnectionString = "MqttConnectionWithCustomClientId")] IMqttMessage mqttMessage) { CallCount++; LastReceivedMessage = mqttMessage; }
/// <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)); }
/// <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; }
public static void Testert([MqttTrigger("test/topic", ConnectionString = "MqttConnectionWithUsernameAndPassword")] IMqttMessage mqttMessage) { CallCount++; }
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); }
/// <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) { }
public static void Testert([Mqtt] out IMqttMessage mqttMessage) { mqttMessage = new MqttMessage("test/topic", new byte[] { }, MqttQualityOfServiceLevel.AtLeastOnce, true); }
public static void Testert([MqttTrigger(typeof(TestMqttConfigProvider), "%TopicName%/#")] IMqttMessage mqttMessage) { CallCount++; LastReceivedMessage = mqttMessage; }
public static void Testert([MqttTrigger("test/topic")] IMqttMessage mqttMessage) { CallCount++; LastReceivedMessage = mqttMessage; }
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); }