Sessions and 'clean session' works

Wiebe Cazemier
1 parent 3cb1fae8
Showing 7 changed files with 44 additions and 26 deletions
client.cpp
client.h
mqttpacket.cpp
session.cpp
session.h
subscriptionstore.cpp
subscriptionstore.h
@@ -327,12 +327,13 @@ bool Client::bufferToMqttPackets(std::vector&lt;MqttPacket&gt; &amp;packetQueueIn, Client_
     return true;
 }
-void Client::setClientProperties(const std::string &clientId, const std::string username, bool connectPacketSeen, uint16_t keepalive)
+void Client::setClientProperties(const std::string &clientId, const std::string username, bool connectPacketSeen, uint16_t keepalive, bool cleanSession)
 {
     this->clientid = clientId;
     this->username = username;
     this->connectPacketSeen = connectPacketSeen;
     this->keepalive = keepalive;
+    this->cleanSession = cleanSession;
 }
 void Client::setWill(const std::string &topic, const std::string &payload, bool retain, char qos)
@@ -41,6 +41,7 @@ class Client
     std::string clientid;
     std::string username;
     uint16_t keepalive = 0;
+    bool cleanSession = false;
     std::string will_topic;
     std::string will_payload;
@@ -64,13 +65,14 @@ public:
     void markAsDisconnecting();
     bool readFdIntoBuffer();
     bool bufferToMqttPackets(std::vector<MqttPacket> &packetQueueIn, Client_p &sender);
-    void setClientProperties(const std::string &clientId, const std::string username, bool connectPacketSeen, uint16_t keepalive);
+    void setClientProperties(const std::string &clientId, const std::string username, bool connectPacketSeen, uint16_t keepalive, bool cleanSession);
     void setWill(const std::string &topic, const std::string &payload, bool retain, char qos);
     void setAuthenticated(bool value) { authenticated = value;}
     bool getAuthenticated() { return authenticated; }
     bool hasConnectPacketSeen() { return connectPacketSeen; }
     ThreadData_p getThreadData() { return threadData; }
     std::string &getClientId() { return this->clientid; }
+    bool getCleanSession() { return cleanSession; }
     void writePingResp();
     void writeMqttPacket(const MqttPacket &packet);
@@ -216,7 +216,7 @@ void MqttPacket::handleConnect()
             return;
         }
-        sender->setClientProperties(client_id, username, true, keep_alive);
+        sender->setClientProperties(client_id, username, true, keep_alive, clean_session);
         sender->setWill(will_topic, will_payload, will_retain, will_qos);
         if (sender->getThreadData()->authPlugin.unPwdCheck(username, password) == AuthResult::success)
@@ -5,11 +5,6 @@ Session::Session()
 }
-Session::Session(std::shared_ptr<Client> &client)
-{
-    this->client = client;
-}
-
 bool Session::clientDisconnected() const
 {
     return client.expired();
@@ -17,5 +12,10 @@ bool Session::clientDisconnected() const
 std::shared_ptr<Client> Session::makeSharedClient() const
 {
-     return client.lock();
+    return client.lock();
+}
+
+void Session::assignActiveConnection(std::shared_ptr<Client> &client)
+{
+    this->client = client;
 }
@@ -11,10 +11,12 @@ class Session
     // TODO: qos message queue, as some kind of movable pointer.
 public:
     Session();
-    Session(std::shared_ptr<Client> &client);
+    Session(const Session &other) = delete;
+    Session(Session &&other) = delete;
     bool clientDisconnected() const;
     std::shared_ptr<Client> makeSharedClient() const;
+    void assignActiveConnection(std::shared_ptr<Client> &client);
 };
 #endif // SESSION_H
@@ -48,7 +48,12 @@ void SubscriptionStore::addSubscription(Client_p &amp;client, const std::string &amp;top
     if (deepestNode)
     {
-        deepestNode->subscribers.push_front(client->getClientId());
+        auto session_it = sessionsByIdConst.find(client->getClientId());
+        if (session_it != sessionsByIdConst.end())
+        {
+            std::weak_ptr<Session> b = session_it->second;
+            deepestNode->subscribers.push_front(b);
+        }
     }
     lock_guard.unlock();
@@ -65,35 +70,43 @@ void SubscriptionStore::registerClientAndKickExistingOne(Client_p &amp;client)
     if (client->getClientId().empty())
         throw ProtocolError("Trying to store client without an ID.");
+    std::shared_ptr<Session> session;
     auto session_it = sessionsById.find(client->getClientId());
     if (session_it != sessionsById.end())
     {
-        Session &session = session_it->second;
+        session = session_it->second;
-        if (!session.clientDisconnected())
+        if (session && !session->clientDisconnected())
         {
-            std::shared_ptr<Client> cl = session.makeSharedClient();
+            std::shared_ptr<Client> cl = session->makeSharedClient();
             logger->logf(LOG_NOTICE, "Disconnecting existing client with id '%s'", cl->getClientId().c_str());
             cl->setReadyForDisconnect();
             cl->getThreadData()->removeClient(cl);
             cl->markAsDisconnecting();
         }
     }
-    sessionsById[client->getClientId()] = client;
+
+    if (!session || client->getCleanSession())
+    {
+        session.reset(new Session());
+        sessionsById[client->getClientId()] = session;
+    }
+
+    session->assignActiveConnection(client);
 }
 // TODO: should I implement cache, this needs to be changed to returning a list of clients.
-void SubscriptionStore::publishNonRecursively(const MqttPacket &packet, const std::forward_list<std::string> &subscribers) const
+void SubscriptionStore::publishNonRecursively(const MqttPacket &packet, const std::forward_list<std::weak_ptr<Session>> &subscribers) const
 {
-    for (const std::string &client_id : subscribers)
+    for (const std::weak_ptr<Session> session_weak : subscribers)
     {
-        auto session_it = sessionsByIdConst.find(client_id);
-        if (session_it != sessionsByIdConst.end())
+        if (!session_weak.expired()) // Shared pointer expires when session has been cleaned by 'clean session' connect.
         {
-            const Session &session = session_it->second;
-            if (!session.clientDisconnected())
+            const std::shared_ptr<Session> session = session_weak.lock();
+
+            if (!session->clientDisconnected())
             {
-                Client_p c = session.makeSharedClient();
+                Client_p c = session->makeSharedClient();
                 c->writeMqttPacketAndBlameThisClient(packet);
             }
         }
@@ -30,7 +30,7 @@ public:
     SubscriptionNode(const SubscriptionNode &node) = delete;
     SubscriptionNode(SubscriptionNode &&node) = delete;
-    std::forward_list<std::string> subscribers; // The idea is to store subscriptions by client id, to support persistent sessions.
+    std::forward_list<std::weak_ptr<Session>> subscribers; // The idea is to store subscriptions by client id, to support persistent sessions.
     std::unordered_map<std::string, std::unique_ptr<SubscriptionNode>> children;
     std::unique_ptr<SubscriptionNode> childrenPlus;
     std::unique_ptr<SubscriptionNode> childrenPound;
@@ -40,15 +40,15 @@ class SubscriptionStore
 {
     std::unique_ptr<SubscriptionNode> root;
     pthread_rwlock_t subscriptionsRwlock = PTHREAD_RWLOCK_INITIALIZER;
-    std::unordered_map<std::string, Session> sessionsById;
-    const std::unordered_map<std::string, Session> &sessionsByIdConst;
+    std::unordered_map<std::string, std::shared_ptr<Session>> sessionsById;
+    const std::unordered_map<std::string, std::shared_ptr<Session>> &sessionsByIdConst;
     pthread_rwlock_t retainedMessagesRwlock = PTHREAD_RWLOCK_INITIALIZER;
     std::unordered_set<RetainedMessage> retainedMessages;
     Logger *logger = Logger::getInstance();
-    void publishNonRecursively(const MqttPacket &packet, const std::forward_list<std::string> &subscribers) const;
+    void publishNonRecursively(const MqttPacket &packet, const std::forward_list<std::weak_ptr<Session>> &subscribers) const;
     void publishRecursively(std::vector<std::string>::const_iterator cur_subtopic_it, std::vector<std::string>::const_iterator end,
                             std::unique_ptr<SubscriptionNode> &next, const MqttPacket &packet) const;
 public: