MongoDBStorageMixin.h

Go to the documentation of this file.

#pragma once
 
#include <atomic>
#include <fstream>
#include <map>
#include <memory>
#include <mutex>
#include <sstream>
#include <string>
 
#include "util/mongodb.h"
 
namespace armarx::armem::server::ltm::detail::mixin
{
    class MongoDBSettings
    {
    public:
        std::string host = "";
        unsigned int port = 0;
        std::string user = "";
        std::string password = "";
        int minPoolSize = 5;
        int maxPoolSize = 100;
 
    public:
        MongoDBSettings()
        {
            initializeFromArmarXConfig();
        };
 
        /// Fills missing fields from armarx config file
        void initializeFromArmarXConfig();
 
        bool isSet() const;
 
        std::string baseUri() const;
 
        std::string key() const;
 
        std::string uri() const;
 
        std::string toString() const;
    };
 
    class MongoDBStorageMixin
    {
    public:
        MongoDBStorageMixin() = default;
        MongoDBStorageMixin(const MongoDBSettings& settings,
                            const std::string& exportName,
                            const armem::MemoryID& id);
 
        MongoDBSettings getSettings() const;
 
        std::string getDocumentName() const;
        std::string getCollectionName() const;
        std::string getPreviousCollectionName() const;
        std::string getDatabaseName() const;
 
        std::optional<mongocxx::database> databaseExists() const;
        std::optional<mongocxx::collection> collectionExists() const;
        std::optional<mongocxx::collection> previousCollectionExists() const;
        std::optional<nlohmann::json> documentExists() const;
        std::optional<nlohmann::json> documentExists(const std::string& id) const;
 
        mongocxx::database ensureDatabaseExists(bool createIfNotExistent = false);
        mongocxx::collection ensureCollectionExists(bool createIfNotExistent = false);
        mongocxx::collection ensurePreviousCollectionExists(bool createIfNotExistent = false);
        nlohmann::json ensureDocumentExists(bool createIfNotExistent = false);
        nlohmann::json ensureDocumentExists(const std::string& id,
                                            bool createIfNotExistent = false);
 
        void writeForeignKeyToPreviousDocument();
        void writeForeignKeyToPreviousDocument(const nlohmann::json& type);
 
        void writeDataToDocument(const nlohmann::json& data);
        nlohmann::json readDataFromDocument() const;
 
        void writeDataToDocument(const std::string& id, const nlohmann::json& data);
        nlohmann::json readDataFromDocument(const std::string& id) const;
 
        std::vector<nlohmann::json> getAllDocuments() const;
 
    protected:
        void connect() const;
        bool connected() const;
 
        /// setter
        void setMixinMemoryID(const armem::MemoryID&);
        void setMixinExportName(const std::string& n);
        void setHost(const std::string&);
        void setPort(const unsigned int);
        void setUser(const std::string&);
        void setPassword(const std::string&);
 
        /// start
        void start();
        void stop();
 
        /// configuration
        void configureMixin(const nlohmann::json& json);
 
    private:
        mongocxx::pool* getPool(bool tryToConnect = true) const;
        mongocxx::pool* ensurePool() const;
 
    protected:
        static const constexpr char* ID = "_id";
        static const constexpr char* FOREIGN_KEY = "_foreign_key";
        static const constexpr char* TYPE = "_type";
        static const constexpr char* DATA = "_data";
        static const constexpr char* METADATA = "_metadata";
 
    private:
        MongoDBSettings settings;
        std::string exportName;
        armem::MemoryID _id;
 
        static std::unique_ptr<mongocxx::instance> MongoCXXInstance;
        static std::atomic_bool MongoCXXInitialized;
        static std::recursive_mutex MongoCXXConnectionPoolMutex;
        static std::map<std::string, std::unique_ptr<mongocxx::pool>> MongoCXXConnectionPool;
    };
 
} // namespace armarx::armem::server::ltm::detail::mixin