public void OnMqttMsgPublishReceived(MqttMsgPublish msg) { if (this.ConnectionManager != null) { this.ConnectionManager.OnMqttMsgPublishReceived(this, msg); } }
public void OnMqttMsgPublishReceived(MqttMsgPublish msg) { if (ProcessingManager != null) { ProcessingManager.OnMqttMsgPublishReceived(this, msg); } }
public void Publish(MqttMsgPublish publish) { sessionManager.AddInflightMessage(publish); switch (publish.QosLevel) { case MqttMsgBase.QOS_LEVEL_AT_MOST_ONCE: { CrestronLogger.WriteToLog("MQTTPUBLISHERMANAGER - RouteOnQoS - Routing qos0 message", 5); ManageQoS0(publish); break; } case MqttMsgBase.QOS_LEVEL_AT_LEAST_ONCE: { CrestronLogger.WriteToLog("MQTTPUBLISHERMANAGER - RouteOnQoS - Routing qos1 message", 5); ManageQoS1(publish); break; } case MqttMsgBase.QOS_LEVEL_EXACTLY_ONCE: { CrestronLogger.WriteToLog("MQTTPUBLISHERMANAGER - RouteOnQoS - Routing qos2 message", 5); ManageQoS2(publish); break; } default: break; } }
public void PublishAdvancedBinaryDecodeTestv5() { // Arrange byte[] encodedCorrect = new byte[] { 109, 0, 19, 116, 104, 105, 115, 116, 111, 112, 105, 99, 47, 115, 111, 109, 101, 116, 104, 105, 110, 103, 0, 42, 79, 2, 0, 0, 48, 57, 35, 0, 33, 8, 0, 14, 114, 101, 115, 112, 111, 110, 115, 101, 32, 116, 111, 112, 105, 99, 9, 0, 6, 1, 2, 3, 4, 5, 6, 38, 0, 3, 79, 110, 101, 0, 4, 112, 114, 111, 112, 38, 0, 6, 115, 101, 99, 111, 110, 100, 0, 8, 112, 114, 111, 112, 101, 114, 116, 121, 11, 254, 255, 255, 127, 3, 0, 6, 98, 105, 110, 97, 114, 121, 6, 5, 4, 3, 2, 1 }; MokChannel mokChannel = new(encodedCorrect); // Act MqttMsgPublish publish = MqttMsgPublish.Parse(60, MqttProtocolVersion.Version_5, mokChannel); // Assert Assert.Equal(Topic, publish.Topic); Assert.Equal(MessageId, publish.MessageId); Assert.Equal(new byte[] { 6, 5, 4, 3, 2, 1 }, publish.Message); Assert.Equal((byte)MqttQoSLevel.ExactlyOnce, (byte)publish.QosLevel); Assert.Equal(true, publish.DupFlag); Assert.Equal(false, publish.Retain); Assert.Equal(publish.ContentType, "binary"); Assert.Equal(publish.IsPayloadUTF8, false); Assert.Equal(publish.SubscriptionIdentifier, 268435454); Assert.Equal(publish.UserProperties.Count, 2); var prop = new UserProperty("One", "prop"); Assert.Equal(((UserProperty)publish.UserProperties[0]).Name, prop.Name); Assert.Equal(((UserProperty)publish.UserProperties[0]).Value, prop.Value); prop = new UserProperty("second", "property"); Assert.Equal(((UserProperty)publish.UserProperties[1]).Name, prop.Name); Assert.Equal(((UserProperty)publish.UserProperties[1]).Value, prop.Value); Assert.Equal(publish.CorrelationData, new byte[] { 1, 2, 3, 4, 5, 6 }); Assert.Equal(publish.ResponseTopic, "response topic"); Assert.Equal(publish.TopicAlias, (ushort)33); Assert.Equal(publish.MessageExpiryInterval, 12345); }
public static void CheckForAndSetRetainedMessage(MqttMsgPublish publish) { if (publish.Retain) { // retained message already exists for the topic if (RetainedMessages.ContainsKey(publish.Topic)) { // if empty message, remove current retained message if (publish.Message.Length == 0) { MqttMsgPublish oldRetained; RetainedMessages.TryRemove(publish.Topic, out oldRetained); } else { // set new retained message for the topic RetainedMessages[publish.Topic] = publish; } } else { // add new topic with related retained message RetainedMessages.TryAdd(publish.Topic, publish); } } }
private void CheckRetain(MqttMsgPublish publish) { if (publish.Retain) { // retained message already exists for the topic if (retainedMessages.ContainsKey(publish.Topic)) { // if empty message, remove current retained message if (publish.Message.Length == 0) { retainedMessages.Remove(publish.Topic); } // set new retained message for the topic else { retainedMessages[publish.Topic] = publish; } } else { // add new topic with related retained message retainedMessages.Add(publish.Topic, publish); } } }
private void RouteOnTheQoSLevelOfTheSubscriber(string topic) { MqttMsgPublish publish = publishQueue[topic].Dequeue(); //var connectedClients = MqttServer.GetConnectedClientIds(); var connectedClients = PacketManager.GetConnectedClientIds(); var subscriptionsByTopic = subscriptionManager.GetSubscriptionsByTopic(publish.Topic); var subscriptions = subscriptionsByTopic != null?subscriptionsByTopic.Where(s => connectedClients.Contains(s.ClientId)) : null; if (subscriptions != null) { foreach (var sub in subscriptions) { if (sub.QosLevel == 0x00 && publish.QosLevel > MqttMsgBase.QOS_LEVEL_AT_MOST_ONCE) { MqttMsgPublish pub = MqttMsgPublish.Parse(publish.GetBytes()); pub.QosLevel = MqttMsgBase.QOS_LEVEL_AT_MOST_ONCE; RouteOnQoS(pub, sub); } else if (sub.QosLevel == 0x01 && publish.QosLevel > MqttMsgBase.QOS_LEVEL_AT_LEAST_ONCE) { MqttMsgPublish pub = MqttMsgPublish.Parse(publish.GetBytes()); pub.QosLevel = MqttMsgBase.QOS_LEVEL_AT_LEAST_ONCE; RouteOnQoS(pub, sub); } else { RouteOnQoS(publish, sub); } } } }
/// <summary> /// Publish message /// </summary> /// <param name="publish">Message to publish</param> public void Publish(MqttMsgPublish publish) { retainedMessageManager.CheckForAndSetRetainedMessage(publish); // enqueue publishQueue.Add(publish); sessionsPublishQueue.Add(publish); }
public void Publish(string topic, string value, uint retain) { byte[] payload = Encoding.ASCII.GetBytes(value); MqttMsgPublish msg = MsgBuilder.BuildPublish(topic, false, (retain > 0), payload, GetNewPacketIdentifier()); publisherManager.Publish(msg); FreePacketIdentifier(msg.MessageId); // this can be done automatically as long as we only publish at QoS 0 }
/// <summary> /// Publish message /// </summary> /// <param name="publish">Message to publish</param> public void Publish(MqttMsgPublish publish) { RetainedMessageManager.CheckForAndSetRetainedMessage(publish); // enqueue this.publishQueue.Add(publish); this.sessionPublishQueue.Add(publish); }
/// <summary> /// Wrapper method for raising PUBLISH message received event /// </summary> /// <param name="publish">PUBLISH message received</param> private void OnMqttMsgPublishReceived(MqttMsgPublish publish) { if (this.MqttMsgPublishReceived != null) { this.MqttMsgPublishReceived(this, new MqttMsgPublishEventArgs(publish.Topic, publish.Message, publish.QosLevel, publish.Retain)); } }
private void HandlePUBLISHType(uint clientIndex, MqttMsgPublish packet) { try { publishManager.Publish(packet); } catch (Exception) { throw; } }
/// <summary> /// Publish a message asynchronously /// </summary> /// <param name="topic">Message topic</param> /// <param name="message">Message data (payload)</param> /// <param name="qosLevel">QoS Level</param> /// <param name="retain">Retain flag</param> /// <returns>Message Id related to PUBLISH message</returns> public static ushort Publish(MqttClientConnection clientConnection, string topic, byte[] message, byte qosLevel, bool retain) { MqttMsgPublish publish = new MqttMsgPublish(topic, message, false, qosLevel, retain); publish.MessageId = clientConnection.GetMessageId(); // enqueue message to publish into the inflight queue EnqueueInflight(clientConnection, publish, MqttMsgFlow.ToPublish); return(publish.MessageId); }
public void Publish(string topic, string value) { byte[] payload = Encoding.ASCII.GetBytes(value); MqttMsgPublish msg = MsgBuilder.BuildPublish(topic, false, (byte)this.PublishQoSLevel, Retain, payload, GetNewPacketIdentifier()); publisherManager.Publish(msg); if (this.PublishQoSLevel == 0x00) { FreePacketIdentifier(msg.MessageId); } }
/// <summary> /// Delivers to the subscribers with qos 0 of the publish topic the publish message /// </summary> /// <param name="sender"></param> /// <param name="publish"></param> private void ManageQoS0(MqttMsgPublish publish, Subscription subscription) { try { //MqttServer.Instance.Send(subscription.ClientId, publish.GetBytes()); OnPacketReadyToBeSent(subscription.ClientId, publish.GetBytes()); } catch (Exception) { throw; } }
void Client_MqttMsgPublishReceived(object sender, MqttMsgPublishEventArgs e) { MqttClient client = (MqttClient)sender; // create PUBLISH message to publish // [v3.1.1] DUP flag from an incoming PUBLISH message is not propagated to subscribers // It should be set in the outgoing PUBLISH message based on transmission for each subscriber MqttMsgPublish publish = new MqttMsgPublish(e.Topic, e.Message, false, e.QosLevel, e.Retain); // publish message through publisher manager this.publisherManager.Publish(publish); }
public static MqttMsgPublish BuildPublish(string topic, bool dupFlag, byte qosLevel, bool retain, byte[] message, ushort messageId) { MqttMsgPublish publish = new MqttMsgPublish(); publish.DupFlag = dupFlag; publish.QosLevel = qosLevel; publish.Retain = retain; publish.Topic = topic; publish.MessageId = messageId; publish.Message = message; return(publish); }
public static MqttMsgPublish BuildPublish(string topic, bool dupFlag, bool retain, byte[] message, ushort messageId) { MqttMsgPublish publish = new MqttMsgPublish(); publish.DupFlag = dupFlag; publish.QosLevel = 0x00; // publishing at QoS 0 is all that is currently supported publish.Retain = retain; publish.Topic = topic; publish.MessageId = messageId; publish.Message = message; return(publish); }
public void OnMqttMsgPublishReceived(MqttClientConnection clientConnection, MqttMsgPublish msg) { if (uacManager.AuthenticatePublish(clientConnection, msg.Topic)) { // create PUBLISH message to publish // [v3.1.1] DUP flag from an incoming PUBLISH message is not propagated to subscribers // It should be set in the outgoing PUBLISH message based on transmission for each subscriber MqttMsgPublish publish = new MqttMsgPublish(msg.Topic, msg.Message, false, msg.QosLevel, msg.Retain); // publish message through publisher manager this.publishManager.Publish(publish); } }
/// <summary> /// Close a client /// </summary> /// <param name="client">Client to close</param> private void CloseClient(MqttClient client) { if (PreClients.Contains(client)) { // close the client client.Close(); // remove client from the collection this.PreClients.Remove(client); } else if (this.Clients.ContainsKey(client.ClientId)) { // if client is connected and it has a will message if (!client.IsConnected && client.WillFlag) { // create the will PUBLISH message MqttMsgPublish publish = new MqttMsgPublish(client.WillTopic, Encoding.UTF8.GetBytes(client.WillMessage), false, client.WillQosLevel, false); // publish message through publisher manager this.publisherManager.Publish(publish); } // if not clean session if (!client.CleanSession) { List <MqttSubscription> subscriptions = this.subscriberManager.GetSubscriptionsByClient(client.ClientId); if ((subscriptions != null) && (subscriptions.Count > 0)) { this.sessionManager.SaveSession(client.ClientId, client.Session, subscriptions); // TODO : persist client session if broker close } } // delete client from runtime subscription this.subscriberManager.Unsubscribe(client); // close the client client.Close(); // remove client from the collection this.Clients.Remove(client.ClientId); } }
void Client_MqttMsgPublishReceived(object sender, MqttMsgPublishEventArgs e) { MqttClient client = (MqttClient)sender; // create PUBLISH message to publish // [v3.1.1] DUP flag from an incoming PUBLISH message is not propagated to subscribers // It should be set in the outgoing PUBLISH message based on transmission for each subscriber MqttMsgPublish publish = new MqttMsgPublish(e.Topic, e.Message, false, e.QosLevel, e.Retain); string payload = Encoding.ASCII.GetString(e.Message); Console.WriteLine("Publish Received: [{0},{1}]", e.Topic, payload); SDCommandHandler.HandleCommand(payload); // publish message through publisher manager this.publisherManager.Publish(publish); }
public void PublishBasicDecodeTestv311() { // Arrange byte[] encodedCorrect = new byte[] { 47, 0, 19, 116, 104, 105, 115, 116, 111, 112, 105, 99, 47, 115, 111, 109, 101, 116, 104, 105, 110, 103, 0, 42, 84, 104, 105, 115, 32, 105, 115, 32, 97, 32, 115, 116, 114, 105, 110, 103, 32, 109, 101, 115, 115, 97, 103, 101 }; MokChannel mokChannel = new(encodedCorrect); // Act MqttMsgPublish publish = MqttMsgPublish.Parse(60, MqttProtocolVersion.Version_3_1_1, mokChannel); // Assert Assert.Equal(Topic, publish.Topic); Assert.Equal(MessageId, publish.MessageId); Assert.Equal(MessageString, Encoding.UTF8.GetString(publish.Message, 0, publish.Message.Length)); Assert.Equal((byte)MqttQoSLevel.ExactlyOnce, (byte)publish.QosLevel); Assert.Equal(true, publish.DupFlag); Assert.Equal(false, publish.Retain); }
public void OnConnectionClosed(MqttClientConnection clientConnection) { // if client is connected MqttClientConnection connectedClient; if (clientConnection.IsConnected && MqttBroker.TryRemoveClientConnection(clientConnection.ClientId, out connectedClient)) { // client has a will message if (clientConnection.WillFlag) { // create the will PUBLISH message MqttMsgPublish publish = new MqttMsgPublish(clientConnection.WillTopic, Encoding.UTF8.GetBytes(clientConnection.WillMessage), false, clientConnection.WillQosLevel, false); // publish message through publisher manager this.publishManager.Publish(publish); } // if not clean session if (!clientConnection.CleanSession) { List <MqttSubscription> subscriptions = clientConnection.Subscriptions.Values.ToList(); if (subscriptions.Count > 0) { MqttSessionManager.SaveSession(clientConnection.ClientId, clientConnection.Session, subscriptions); // TODO : persist client session if broker close } } foreach (var topic in clientConnection.Subscriptions.Keys) { // delete client from runtime subscription MqttSubscriberManager.Unsubscribe(topic, clientConnection); } // close the client CloseClientConnection(clientConnection); clientConnectionManager.ReturnConnection(clientConnection); Interlocked.Decrement(ref numberOfConnectedClients); } }
internal void Publish(MqttMsgPublish packet) { CheckRetain(packet); packet.Retain = false; //MQTT-3.3.1-9 if (!publishQueue.ContainsKey(packet.Topic)) { publishQueue.Add(packet.Topic, new Queue <MqttMsgPublish>()); } publishQueue[packet.Topic].Enqueue(packet); RouteOnTheQoSLevelOfTheSubscriber(packet.Topic); lock (publishQueue) { if (publishQueue.ContainsKey(packet.Topic)) { if (publishQueue[packet.Topic].Count == 0) { publishQueue.Remove(packet.Topic); } } } }
private void HandlePUBLISHType(MqttMsgPublish publish) { try { switch (publish.QosLevel) { case MqttMsgBase.QOS_LEVEL_AT_MOST_ONCE: { CrestronLogger.WriteToLog("MQTTCLIENT - HandlePUBLISHType - Routing qos0 message", 5); string publishPayload = System.Text.Encoding.ASCII.GetString(publish.Message, 0, publish.Message.Length); OnMessageArrived(publish.Topic, PayloadMapper.Map(publishPayload)); break; } case MqttMsgBase.QOS_LEVEL_AT_LEAST_ONCE: { CrestronLogger.WriteToLog("MQTTCLIENT - HandlePUBLISHType - Routing qos1 message", 5); string publishPayload = System.Text.Encoding.ASCII.GetString(publish.Message, 0, publish.Message.Length); Send(MsgBuilder.BuildPubAck(publish.MessageId)); OnMessageArrived(publish.Topic, PayloadMapper.Map(publishPayload)); break; } case MqttMsgBase.QOS_LEVEL_EXACTLY_ONCE: { CrestronLogger.WriteToLog("MQTTCLIENT - HandlePUBLISHType - Routing qos2 message", 5); //ManageQoS2(publish); break; } default: break; } //TODO: Raise MessageArrived event , handle the necessary responses with the publisher manager. } catch (ArgumentException e) { OnErrorOccured(e.Message); } }
protected void OnClientDisconnected(MqttClient client, bool withDisconnectPacket) { try { if (!withDisconnectPacket && client.WillFlag) { MqttMsgPublish publish = MsgBuilder.BuildPublish(client.WillTopic, false, client.WillQosLevel, client.WillRetain, Encoding.ASCII.GetBytes(client.WillMessage), GetNewPacketIdentifier()); //Send(client.ClientIndex, publish.GetBytes()); OnPacketReceived(client.ClientIndex, publish, client.IsWebSocketClient); } else if (withDisconnectPacket) { SessionManager.Destroy(client.ClientId); client.IsConnected = false; } } catch (Exception e) { CrestronLogger.WriteToLog("MQTTSERVER - OnClientDisconnected , error message : " + e.Message, 8); CrestronLogger.WriteToLog("MQTTSERVER - OnClientDisconnected , error STACK TRACE : " + e.StackTrace, 8); } }
void Client_MqttMsgPublishReceived(object sender, MqttMsgPublishEventArgs e) { MqttClient client = (MqttClient)sender; // create PUBLISH message to publish // [v3.1.1] DUP flag from an incoming PUBLISH message is not propagated to subscribers // It should be set in the outgoing PUBLISH message based on transmission for each subscriber MqttMsgPublish publish = new MqttMsgPublish(e.Topic, e.Message, false, e.QosLevel, e.Retain); // publish message through publisher manager this.publisherManager.Publish(publish); //signal EventHandler <MqttClientEventArgs> handler = DidRecievePublishMessageFromClient; if (handler != null) { MqttClientEventArgs arg = new MqttClientEventArgs(); arg.Client = client; handler(this, arg); } }
void Client_MqttMsgPublishReceived(object sender, MqttMsgPublishEventArgs e) { MqttClient client = (MqttClient)sender; // Fire event on threadpool so that a host application can directly access published messages. var mqttPublihForEvent = new MqttMsgPublish(e.Topic, e.Message, false, e.QosLevel, e.Retain); var messageEvent = new KeyValuePair <string, MqttMsgPublish>(client.ClientId, mqttPublihForEvent); Task.Run(() => { Interlocked.CompareExchange(ref MessagePublished, null, null)?.Invoke(messageEvent); }); // create PUBLISH message to publish // [v3.1.1] DUP flag from an incoming PUBLISH message is not propagated to subscribers // It should be set in the outgoing PUBLISH message based on transmission for each subscriber MqttMsgPublish publish = new MqttMsgPublish(e.Topic, e.Message, false, e.QosLevel, e.Retain); // publish message through publisher manager this.publisherManager.Publish(publish); }
public void CheckForAndSetRetainedMessage(MqttMsgPublish publish) { if (publish.Retain) { if (RetainedMessages.ContainsKey(publish.Topic)) { if (publish.Message.Length == 0) { MqttMsgPublish oldRetained; RetainedMessages.TryRemove(publish.Topic, out oldRetained); } else { // set new retained message for the topic RetainedMessages[publish.Topic] = publish; } } else { RetainedMessages.TryAdd(publish.Topic, publish); } } }
/// <summary> /// Publish message /// </summary> /// <param name="publish">Message to publish</param> public void Publish(MqttMsgPublish publish) { if (publish.Retain) { lock (this.retainedMessages) { // retained message already exists for the topic if (retainedMessages.ContainsKey(publish.Topic)) { // if empty message, remove current retained message if (publish.Message.Length == 0) { retainedMessages.Remove(publish.Topic); } // set new retained message for the topic else { retainedMessages[publish.Topic] = publish; } } else { // add new topic with related retained message retainedMessages.Add(publish.Topic, publish); } } } // enqueue lock (this.publishQueue) { this.publishQueue.Enqueue(publish); } // unlock thread for sending messages to the subscribers this.publishQueueWaitHandle.Set(); }