RestPersistence.h

Go to the documentation of this file.

#pragma once
 
#include <SimoxUtility/json.h>
 
#include <RobotAPI/libraries/armem/core/MemoryID.h>
#include <RobotAPI/libraries/armem/server/ltm/detail/mixins/util/httplib.h>
#include <RobotAPI/libraries/armem/server/ltm/persistence/MemoryPersistenceStrategy.h>
 
namespace armarx::armem::server::ltm::persistence
{
    enum DataType
    {
        JSON,
        PNG
    };
 
    /**
   * Persistence strategy that uses a rest server as its data sink.
   * How the data is stored on the rest server is up to the server.
   * 
   * The structure of rest endpoints are very similar to a directory structure.
   * 
   * General endpoint:
   * /endpoint
   * GET: /endpoint?containers: return all container keys of the endpoint
   * GET: /endpoint?container=key: check if a container with key exists (true = Status Code 200, false = Status Code 404)
   * GET: /endpoint?items: return all item keys of the endpoint
   * GET: /endpoint?item=key: return Status Code 200 with item data OR Status Code 404 if the item is not inside of the container
   * PUT: /endpoint?item: store item data (data = http body content)
   * DELETE: /endpoint?item=key: removes item with key, return Status Code 200 on success and Status Code 404 if item not found 
   * DELETE: /endpoint?container=key: removes container with key, return Status Code 200 on success and Status Code 404 if container not found
   *
   * NOTE: DELETE-methods are implemented, but the curren memory system does not use it in general.
   *
   * Available endpoints:
   * /ltm/:exportName
   * -> memories
   * /ltm/:exportName/:memoryName
   * -> core segments
   * /ltm/:exportName/:memoryName/:coreSegmentName
   * -> provider segments
   * /ltm/:exportName/:memoryName/:coreSegmentName/:providerSegmentName
   * -> entities
   * /ltm/:exportName/:memoryName/:coreSegmentName/:providerSegmentName/:entityName
   * -> entity snapshots
   * /ltm/:exportName/:memoryName/:coreSegmentName/:providerSegmentName/:entityName/:timestamp
   * -> entity instances
   * /ltm/:exportName/:memoryName/:coreSegmentName/:providerSegmentName/:entityName/:timestamp/:instanceIndex 
   * -> entity instance (here you will definitely find some items)
   */
    class RestPersistence : public MemoryPersistenceStrategy
    {
    public:
        RestPersistence() : RestPersistence("Rest", "DefaultExport")
        {
        }
 
        RestPersistence(const std::string& identifier, const std::string& exportName) :
            MemoryPersistenceStrategy(identifier, exportName)
        {
        }
 
        /**
       * @param identifier basically a unique name for the strategy (important if you use different strategies @see RedundantPersistenceStrategy)
       * @param exportName identifier for the exported memory where any items are written. Changes http endpoints.
       * @param id memory id, gives us the hierarchy depth to store some items for it (e.g. a core segment)
       * @param host rest server address (e.g. localhost or a specific ip or a domain)
       * @param port network port where the rest server runs
       */
        RestPersistence(const std::string& identifier,
                        const std::string& exportName,
                        const std::string& host,
                        int port,
                        bool disableIfNotAvailable = false) :
            MemoryPersistenceStrategy(identifier, exportName), host_(host), port_(port)
        {
            client_ = std::make_shared<httplib::Client>(host, port);
 
            bool available = checkConnection();
 
            if (disableIfNotAvailable && !available)
            {
                ARMARX_IMPORTANT << "REST Server not available. Disabling...";
                disable();
            }
        }
 
        const static std::string DEFAULT_HOST;
        const static int DEFAULT_PORT = 8080;
 
        std::vector<std::string> getContainerKeys(const armarx::armem::MemoryID& id) override;
 
        std::vector<std::string> getItemKeys(const armarx::armem::MemoryID& id) override;
 
        bool containsContainer(const armarx::armem::MemoryID& id, std::string key) override;
 
        bool containsItem(const armarx::armem::MemoryID& id, std::string key) override;
 
        void storeItem(const armarx::armem::MemoryID& id,
                       std::string key,
                       std::vector<unsigned char>& data) override;
 
        std::vector<unsigned char> retrieveItem(const armarx::armem::MemoryID& id,
                                                std::string key) override;
 
        void createPropertyDefinitions(PropertyDefinitionsPtr& defs,
                                       const std::string& prefix) override;
 
 
        /**
       * Checks if the server is up
       */
        bool checkConnection();
 
    private:
        std::shared_ptr<httplib::Client> client_;
 
        std::string host_ = "localhost";
        int port_ = DEFAULT_PORT;
 
 
        /* Internal rest logic */
 
        /**
       * Stops and restarts the client (e.g. if some parameters like the port are changed)
       */
        void resetClient();
 
        bool restContainsItem(const armarx::armem::MemoryID& id, std::string& key);
 
        bool restContainsContainer(const armarx::armem::MemoryID& id, std::string& key);
 
        std::vector<std::string> getRestItems(const armarx::armem::MemoryID& id);
 
        std::vector<std::string> getRestContainers(const armarx::armem::MemoryID& id);
 
        std::vector<unsigned char> readItemFromRest(const armarx::armem::MemoryID& id,
                                                    std::string& key);
 
        void writeItemToRest(const armarx::armem::MemoryID& id,
                             std::string& key,
                             const std::vector<unsigned char>& data);
 
        void writeItemToRest(const armarx::armem::MemoryID& id,
                             std::string& key,
                             nlohmann::json& jsonData);
 
        void writeItemToRest(const armarx::armem::MemoryID& id,
                             std::string& key,
                             DataType type,
                             const std::vector<unsigned char>& data);
 
        void removeRestItem(const armarx::armem::MemoryID& id, std::string& key);
 
        void setPort(int port);
 
        int getPort() const;
 
        void setHost(std::string& host);
 
        std::string getHost();
 
        /**
       * Creates our endpoint resp. http request path using the export name and memory id
       */
        std::string buildPath(const armarx::armem::MemoryID& id);
 
        std::string getMimeType(DataType type);
    };
} // namespace armarx::armem::server::ltm::persistence