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/persistence/MemoryPersistenceStrategy.h>
 
#include <RobotAPI/libraries/armem/server/ltm/detail/mixins/util/httplib.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