Is there any way for a mqtt client to know when his queue was processed and he is "up-to-date" again?
I want to prevent editing of certain elements in the frontend until I am sure that I received all queued changes after a reconnect.
Is that possible?
No, queued messages are not flagged in any way, but they will all be delivered as soon as the client connects.
You could just set a flag when connecting to just stop all UI updates for a period of time to allow messages to arrive and then update with the last data.
Related
I have a requirement where I want to get some kind of notification while the message retention period is over and the message is about to be discarded from the MQTT topic.
So the actual requirement is, we have Bluetooth bands, which are send their presence through a centralized agent and an MQTT broker. Now we got a requirement where we need to upgrade the band firmware. For doing so, we will send a message to the topic with a message and a specific retention period. Infra will receive the message notification and look for the band. If the band is found then it's ok otherwise it will wait for new bands to be available. Once the retention period is over, in some cases we have to retry, so to implement the retry mechanism, I wanted to receive the notification from the MQTT broker if a message retention period is over.
Please help me if this is even possible into MQTT?
The broker won't tell you when it drops messages, but since you know when you sent the message and what expiry time you set there is nothing to stop you implementing this yourself.
I do use the PAHO C client library in my application. I do subscribe topics with MQTTAsync_subscribe() and QoS set to 1. From what I understand is that 1 means, that a message is send to the client at least one time.
I disconnect the client that subscribed the topic and the client that published the topic is still sending messages to the Mosquitto broker. If I start the subscriber lets say hours later, I get all the buffered messages beginning from the last one when the subscriber was shut down. So far so good! But the problem is, that the messages arrive in the same interval as the publisher sends new messages. By doing so, you will never get the latest message queued up by the publisher.
What I expect is that the Mosquitto broker tries to send all pending messages one after the other to the client instead of sending one old message when a new one is published.
Maybe someone can help me to understand why this happens or maybe how to overcome this situation?
Queued messages should all be batch delivered when the client reconnects.
They are not queued up and delivered with the same time offset, mosquitto wouldn't even keep time of arrival to be able to do time offset delayed delivery (Time of arrival is kept for MQTT v5 messages because they can now have TTL value, but this is only used to remove expired messages from the queue, not to delay late delivery).
I have an application that uses mqtt for communication between modules and with a mobile terminal.
In some situations when the messages do not arrive, the node performs a self test of MQTT (sending a msg to itself), and when the selftest fails, tries to reconnect to the broker (mqtt offline not always arrives). And then two problems may arise:
If I perform a mqtt.client:close() to assure that the client is closed (to avoid the second problem) and the client is already closed, the node resets.
If I perform a mqtt.client:connect() and the client is still connected, an exception and a restet occurs.
is there a way to know if the mqtt client is connected or not?
Thanks for your comment. I am going to describe what I am doing, to see if you can help me:
I have two independent system, a master and a slave. The master publish a test message every 10 minutes. If there is no answer from the slave. it publish a test message to itself. If this self test does not arrive, a disconnection from the broker is assumed, and a reconnection is initiated.
And here is where the problem comes, sometimes the client is disconnected and everything go well, but sometimes it is still connected but unresponsive, and the node resets with an exception "already connected".
Performing a mqtt:close() previously to the reconnection, should be safe, but if I send it and the client is truly disconnected, the node resets without any reason (known to me).
All this is happening without receiving any offline message.
Instead of waiting for messages manually sent by the master client (which could fail to send for various reasons, leading a listening device to the wrong conclusion about the state of its connection to the broker), I recommend using MQTT's built-in connection management.
First, you can make sure that each client's initial connection has succeeded by including an error handler in :connect(). If the client really opens, nothing in the NodeMCU documentation indicates that it will close itself; it may go offline.
Once connected, the client only knows that something is wrong when it sends a message and does not receive a response. It sounds like you are not calling :publish() much (which would otherwise let you know by returning false), so pinging may be best. If you expect to receive a message from the broker every n seconds, set a keepalive time slightly higher than that on the client.
Then, failure to get a response to those messages should trigger an event that you can respond to. That might be something like the following (not tested, may work better called outside the callback):
m:on("offline", function(client) m:close() end)
So we have a messenger ( I know we should just switch to Xmpp, but no time right now) - problem being if a user sends say 20 messages rapid fire there is more than a good chance of them storing ALLLLL out of order.Is there any way to ensure the requests are sent in order without blocking the user from sending at the pace they want to send?
You can create a queue of NSURLRequest. When the user fires a message, this message is added to the queue and the oldest message of the queue is sent. When the completion blocks (success or failure) are called, send the new oldest message, and so on...
Just be careful to have only one process which send messages.
You can also take a look to NSOperation and NSOperationQueue.
I am doing Comet chat with Erlang. I only use one connection (long-polling) for the message transportation. But, as you know, the long-polling connection can not be stay connected all the time. Every time a new message comes or reaches the timeout, it will break and then connect to the server again. If a message is sent before the connection re-connected, it is a problem to keep the integrity of chat.
And also, if a user opens more than one window with Comet-chat, all the chat messages have to keep sync, which means a user can have lots of long-polling connections. So it is hard to keep every message delivered on time.
Should I build a message queue for every connection? Or what else better way to solve this?
For me seems simplest way to have one process/message queue per user connected to chat (even have more than one chat window). Than keep track of timestamp of last message in chat window application and when reconnect ask for messages after this timestamp. Message queue process should keeps messages only for reasonable time span. In this scenario reconnecting is all up to client. In another scenario you can send some sort of hart beats from server but it seems less reliable for me. It is not solving issue with other reason of disconnection than timeout. There are many variant of server side queuing as one queue per client, per user, per chat room, per ...