test

        SessionData        *_next;

        friend class Session;

        friend class LocalSession;

        friend class ClusterSession;

        friend class client::Client;

    };

    // Session listing info (used by listSessions)

    struct SessionInfo {

        uuid::uuid sid, uid, did;

        std::string username;

    };

    // Abstract session store interface

    class Session{

    public:

        Session();

        Session(const Session &src);

        ~Session();

        const SessionData *addSession(AuthBackend &backend,uuid::uuid domainid,uuid::uuid userid);

        void                         relSession(AuthBackend &backend,uuid::uuid sessionid);

        const SessionData *getSession(uuid::uuid sessionid);

        void                         remSession(uuid::uuid sessionid);

        Session() = default;

        virtual ~Session() = default;

        virtual const SessionData *addSession(AuthBackend &backend,uuid::uuid domainid,uuid::uuid userid) = 0;

        virtual void               relSession(AuthBackend &backend,uuid::uuid sessionid) = 0;

        virtual const SessionData *getSession(uuid::uuid sessionid) = 0;

        virtual void               remSession(uuid::uuid sessionid) = 0;

        virtual void               listSessions(std::vector<SessionInfo> &out) = 0;

        virtual void               clear() = 0;

        Session(const Session&) = delete;

        Session& operator=(const Session&) = delete;

    };

        void clear();

    // Single-node session store: in-memory linked list

    class LocalSession : public Session {

    public:

        LocalSession();

        ~LocalSession() override;

        const SessionData *addSession(AuthBackend &backend,uuid::uuid domainid,uuid::uuid userid) override;

        void               relSession(AuthBackend &backend,uuid::uuid sessionid) override;

        const SessionData *getSession(uuid::uuid sessionid) override;

        void               remSession(uuid::uuid sessionid) override;

        void               listSessions(std::vector<SessionInfo> &out) override;

        void               clear() override;

    protected:

        SessionData *findLocal(uuid::uuid sessionid);

        void         appendLocal(SessionData *sess);

        void         removeLocal(uuid::uuid sessionid);

        void         cleanupExpired();

        const SessionData *firstData() const;

    private:

        SessionData   *_firstData;

        SessionData   *_lastData;

        std::mutex     _lock;

    };

    // Cluster session store: uses cluster session_store_ as single source of truth

    class ClusterSession : public LocalSession {

    public:

        ClusterSession();

        ~ClusterSession() override;

        const SessionData *addSession(AuthBackend &backend,uuid::uuid domainid,uuid::uuid userid) override;

        void               relSession(AuthBackend &backend,uuid::uuid sessionid) override;

        const SessionData *getSession(uuid::uuid sessionid) override;

        void               remSession(uuid::uuid sessionid) override;

        void               listSessions(std::vector<SessionInfo> &out) override;

    };

};