DiskPersistence.h

Go to the documentation of this file.

#pragma once
 
#include <filesystem>
#include <string>
#include <vector>
 
#include "RobotAPI/libraries/armem/core/MemoryID.h"
#include "RobotAPI/libraries/armem/server/ltm/persistence/MemoryPersistenceStrategy.h"
 
namespace armarx::armem::server::ltm::persistence
{
    class FileIdentifier : public ItemIdentifier
    {
    public:
        FileIdentifier(std::string& filename, std::string& fileType) :
            filename_(filename),
            fileType_(fileType){
 
            };
 
        virtual ~FileIdentifier()
        {
        }
 
        std::string
        getKey() override
        {
            return filename_ + fileType_;
        }
 
    private:
        std::string filename_;
        std::string fileType_;
    };
 
    /**
   * @brief Persistence strategy that writes items (e.g. json files) to a specific container (a directory)
   * Use it to write the data of a WM to disk.
   *
   * Where are the items written (=:location)?
   *  /memoryParentPath/exportName/path(id)/
   *
   * How is the file of an item named?
   * -> Just they key (e.g. filename = key = "data.aron.json")
   *    If you might want a more sophisticated solution fell free to implement your custom ItemIdentifier today!
   */
    class DiskPersistence : public MemoryPersistenceStrategy
    {
    public:
        DiskPersistence() : DiskPersistence(std::filesystem::path("."))
        {
        }
 
        DiskPersistence(const std::filesystem::path& memoryParentPath) :
            DiskPersistence("Disk", "DefaultExport", memoryParentPath)
        {
        }
 
        /**
       * @param identifier basically a unique name for the strategy (important if you use different strategies @see RedundantPersistenceStrategy)
       * @param exportName identifier for the exported memory. A new directory with name is created beneath the memoryParentPath. Everything is stored inside it.
       * @param memoryParentPath path where the memory should be exported to
       */
        DiskPersistence(const std::string& identifier,
                        const std::string& exportName,
                        const std::filesystem::path& memoryParentPath) :
            MemoryPersistenceStrategy(identifier, exportName), memoryParentPath_(memoryParentPath)
        {
        }
 
        /**
       * Returns all containers for the current id.
       * @return containers <=> directories at current location (=/memoryParentPath/exportName/path(id)/)
       */
        std::vector<std::string> getContainerKeys(const armarx::armem::MemoryID& id) override;
 
        /**
       * Returns all items for the current id.
       * @return items <=> files at the current location (=/memoryParentPath/exportName/path(id)/)
       */
        std::vector<std::string> getItemKeys(const armarx::armem::MemoryID& id) override;
 
        /**
       * Checks if the container is available for the current memory id.
       * @return true if the current location contains the directory with name 'key'
       */
        bool containsContainer(const armarx::armem::MemoryID& id, std::string key) override;
 
        /**
       * Checks if current container contains the item defined by its key.
       * @return true if the current location contains a file with the name 'key'
       */
        bool containsItem(const armarx::armem::MemoryID& id, std::string key) override;
 
        /**
       * Create a new file with name 'key' and stores the data inside it.
       */
        void storeItem(const armarx::armem::MemoryID& id,
                       std::string key,
                       std::vector<unsigned char>& data) override;
 
        /**
       * Reads the data of the file with name 'key' at the current location.
       * @return data if a file was found, an empty vector if the file is empty or was not found
       */
        std::vector<unsigned char> retrieveItem(const armarx::armem::MemoryID& id,
                                                std::string key) override;
 
        void
        createPropertyDefinitions(PropertyDefinitionsPtr& defs, const std::string& prefix) override
        {
            // Nothing to do
        }
 
        void
        setMinAvailableDiskSpace(const int minDiskSpace)
        {
            this->minDiskSpace = minDiskSpace;
            if (!enoughDiskSpaceLeft())
            {
                ARMARX_WARNING << "Not enough available disk space for DiskPersistance Strategy. "
                                  "You need at least "
                               << this->minDiskSpace
                               << " GB available disk space to record into LTM using this strategy";
            }
        }
 
        int minDiskSpace = 50; // in GB
 
 
    private:
        std::filesystem::path memoryParentPath_;
 
        /* Internal disk logic */
 
        bool fullPathExists(const armarx::armem::MemoryID& id);
 
        std::vector<std::filesystem::path> getAllFiles(const armarx::armem::MemoryID& id);
 
        std::vector<std::filesystem::path> getAllDirectories(const armarx::armem::MemoryID& id);
 
        bool fileExists(const armarx::armem::MemoryID& id, const std::string& filename);
 
        std::filesystem::path getFullPath(const armarx::armem::MemoryID& id);
 
        void ensureFullPathExists(const armarx::armem::MemoryID& id,
                                  bool createIfNotExistent = false);
 
        void ensureFileExists(const armarx::armem::MemoryID& id,
                              const std::string& filename,
                              bool createIfNotExistent = false);
 
        void writeDataToFile(const armarx::armem::MemoryID& id,
                             const std::string& filename,
                             const std::vector<unsigned char>& data);
 
        std::vector<unsigned char> readDataFromFile(const armarx::armem::MemoryID& id,
                                                    const std::string& filename);
 
        std::filesystem::path getMemoryParentPath();
 
        bool enoughDiskSpaceLeft();
    };
} // namespace armarx::armem::server::ltm::persistence