RESTStorageMixin.h

Go to the documentation of this file.

#pragma once
 
#include <string>
#include <vector>
 
#include <SimoxUtility/json.h>
#include <ArmarXCore/core/logging/Logging.h>
 
#include "RobotAPI/libraries/armem/core/MemoryID.h"
#include <RobotAPI/libraries/armem/core/wm/memory_definitions.h>
 
 
#include <ArmarXCore/core/services/tasks/PeriodicTask.h>
#include <RobotAPI/libraries/armem/server/ltm/detail/mixins/util/filesystem.h>
#include <RobotAPI/libraries/armem/server/ltm/detail/mixins/util/httplib.h>
 
namespace armarx::armem::server::ltm::detail::mixin
{
    enum DataType {
        JSON, PNG
    };
 
    struct RESTServerConfig {
        std::string host;
        std::string ltm_path;
    };
 
    class RESTStorageMixin
    {
    public:
        RESTStorageMixin() : RESTStorageMixin("DefaultExport", armem::MemoryID()) {}
        RESTStorageMixin(const std::string& exportName, const armem::MemoryID& id, std::string host = "localhost", int port = 8080) : exportName_(exportName), id_(id), host_(host), port_(port) {
            client_ = std::make_shared<httplib::Client>(host, port);
            
            checkConnection();
        }
 
 
 
        bool checkConnection()
        {
            std::string path = "/ltm";
 
            auto res = client_->Get(path);
 
            if (res) 
            {
                ARMARX_INFO << "MemoryX-REST server is running at host=" << host_ << ", port=" << port_;
 
 
                return true;
            } 
 
            ARMARX_INFO << "MemoryX-REST server is not running at host=" << host_ << ", port=" << port_;
            
            return false;
        }
 
        void resetClient()
        {
            if (client_)
            {
                client_->stop();
            }
 
            client_ = std::make_shared<httplib::Client>(host_, port_);
        }
 
        bool containsItem(std::string& key)
        {
            std::string path = buildPath();
            std::string query = "key=" + key;
            std::string url = path + "?" + query;
 
            ARMARX_DEBUG << "GET request: Read data from MemoryX-REST server: key=" << key << ", url=" << url;
 
            auto res = client_->Get(url);
 
            bool containsItem = false;
 
            if (res && res->status == 200) 
            {
                ARMARX_DEBUG << "GET request successful: REST-LTM contain item with key=" << key;
                ARMARX_DEBUG << "Response: " << res->body;
                
                containsItem = true;
            } 
            else if (res && res->status == 404) 
            {
                ARMARX_DEBUG << "GET request successful: REST-LTM does not contain item with key=" << key;
                ARMARX_DEBUG << "Response: " << res->body;
 
                containsItem = false;
            }
            else if (res)
            {
                ARMARX_ERROR << "GET request failed. Status: " << res->status;
                ARMARX_DEBUG << "Response: " << res->body;
            }
            else 
            {
                ARMARX_DEBUG << "GET request failed. No connection could be established to the MemoryX-REST server at host=" << host_ << ", port=" << port_; 
            }
 
            return containsItem;
        }
 
 
        void writeDataToRest(std::string& key, const std::vector<unsigned char>& data)
        {
            std::string path = buildPath();
            std::string query = "key=" + key;
            std::string url = path + "?" + query;
 
            ARMARX_DEBUG << "PUT request: Write data to MemoryX-REST server: key=" << key << ", url=" << url;
 
            std::string body(data.begin(), data.end());
 
            auto res = client_->Put(url, body, "application/json");
 
            if (res && res->status == 200) 
            {
                ARMARX_DEBUG << "PUT request response: " << res->body;
            } 
            else if (res) 
            {
                ARMARX_ERROR << "PUT request failed. Status: " << res->status;
            }
            else 
            {
                ARMARX_DEBUG << "PUT request failed. No connection could be established to the MemoryX-REST server at host=" << host_ << ", port=" << port_; 
            }
        }
 
        std::vector<unsigned char> readDataFromRest(std::string& key)
        {
            std::string path = buildPath();
            std::string query = "key=" + key;
            std::string url = path + "?" + query;
 
            ARMARX_DEBUG << "GET request: Read data from MemoryX-REST server: key=" << key << ", url=" << url;
 
            auto res = client_->Get(url);
 
            std::vector<unsigned char> data;
 
            if (res && res->status == 200) 
            {
                ARMARX_DEBUG << "GET request response: " << res->body;
 
                data = std::vector<unsigned char>(res->body.begin(), res->body.end());
            }
            else if (res && res->status == 404) 
            {
                ARMARX_ERROR << "GET request failed: REST-LTM does not contain any item with key=" << key;
            } 
            else if (res) 
            {
                ARMARX_ERROR << "GET request failed. Status: " << res->status;
            }
            else 
            {
                ARMARX_DEBUG << "GET request failed. No connection could be established to the MemoryX-REST server at host=" << host_ << ", port=" << port_; 
            }
 
            return data;
        }
 
        std::vector<std::string> getItems() 
        {
            std::string path = buildPath();
            std::string url = path;
 
            ARMARX_DEBUG << "GET request: Get items from MemoryX-REST server: url=" << url;
 
            auto res = client_->Get(url);
 
            std::vector<std::string> item_keys;
 
            if (res && res->status == 200) 
            {
                ARMARX_DEBUG << "GET request response: " << res->body;
 
                try 
                {
                    nlohmann::json json_response = nlohmann::json::parse(res->body);
 
                    if (json_response.contains("keys") && json_response["keys"].is_array()) 
                    {                        
                        item_keys = json_response["keys"].get<std::vector<std::string>>();                    
                    }
                } 
                catch (const std::exception& e) 
                {
                    ARMARX_ERROR << "GET request: Error parsing JSON: " << e.what();
                }
            } 
            else if (res) 
            {
                ARMARX_ERROR << "GET request failed. Status: " << res->status;
            }
            else 
            {
                ARMARX_DEBUG << "GET request failed. No connection could be established to the MemoryX-REST server at host=" << host_ << ", port=" << port_; 
            }
 
            return item_keys;
        }
 
 
        void writeDataToRest(std::string& key, nlohmann::json& jsonData) 
        {
            std::string str_data = jsonData.dump();
            std::vector<unsigned char> data(str_data.begin(), str_data.end());
 
            writeDataToRest(key, DataType::JSON, data);
        }
 
        void writeDataToRest(std::string& key, DataType type, const std::vector<unsigned char>& data)
        {
            std::string path = buildPath();
            std::string mime_type = getMimeType(type);
            std::string query = "?item=" + key;
            
            std::string body(data.begin(), data.end());
 
            auto res = client_->Put(path + query, body, mime_type);
 
            if (res) 
            {
                ARMARX_DEBUG << "Status: " << res->status;
                ARMARX_DEBUG << "Response: " << res->body;
            } 
            else 
            {
                ARMARX_ERROR << "Request failed. Error: " << res.error();
            }
        }
 
        
 
        void removeData(std::string& key)
        {
            std::string path = buildPath();
            std::string query = "key=" + key;
            std::string url = path + "?" + query;
 
            ARMARX_DEBUG << "DELETE request: Remove item from MemoryX-REST server: key=" << key << ", url=" << url;
 
 
            auto res = client_->Delete(url);
 
            if (res && res->status == 200) 
            {
                ARMARX_DEBUG << "DELETE request successlful: " << res->body;
            }
            else if (res && res->status == 404) 
            {
                ARMARX_ERROR << "DELETE request failed. REST-LTM does not contain any item with key=" << key;
            } 
            else if (res) 
            {
                ARMARX_ERROR << "DELETE request failed. Status: " << res->status;
            }
            else 
            {
                ARMARX_DEBUG << "DELETE request failed. No connection could be established to the MemoryX-REST server at host=" << host_ << ", port=" << port_; 
            }
        }
 
        void setMixinMemoryID(armem::MemoryID& id)
        {
            id_ = id;
        }
 
        void setMixinExportName(const std::string& exportName)
        {
            exportName_ = exportName;
        }
 
        void createPropertyDefinitions(PropertyDefinitionsPtr& defs, const std::string& prefix)
        {
            defs->optional(host_, prefix + "host");
            defs->optional(port_, prefix + "port");
            defs->optional(exportName_, prefix + "exportName");
        }
 
        void setPort(int port)
        {
            port_ = port;
            resetClient();
        }
 
        int getPort() const
        {
            return port_;
        }
 
        void setHost(std::string& host)
        {
            host_ = host;
            resetClient();
        }
 
        std::string getHost()
        {
            return host_;
        }
 
    private:
        // RESTServerConfig m_config;
        std::string exportName_;
        std::shared_ptr<httplib::Client> client_;
        armem::MemoryID id_;
 
        std::string host_ = "localhost";
        int port_ = 8080;
 
        std::string buildPath() {
            std::string url = "/ltm/" + exportName_;
 
            if (id_.hasMemoryName())
            {
                url += "/" + armarx::armem::server::ltm ::util::fs::detail::escapeName(id_.memoryName);
            }
            if (id_.hasCoreSegmentName())
            {
                url += "/" + armarx::armem::server::ltm ::util::fs::detail::escapeName(id_.coreSegmentName);
            }
            if (id_.hasProviderSegmentName())
            {
                url += "/" + armarx::armem::server::ltm ::util::fs::detail::escapeName(id_.providerSegmentName);
            }
            if (id_.hasEntityName())
            {
                url += "/" + armarx::armem::server::ltm ::util::fs::detail::escapeName(id_.entityName);
            }
            if (id_.hasTimestamp())
            {
                url += "/" + id_.timestampStr();
            }
            if (id_.hasInstanceIndex())
            {
                url += "/" + id_.instanceIndexStr();
            }
 
            return url;
        }
 
        std::string getMimeType(DataType type) {
            
            if (type == DataType::JSON) 
            {
                return "application/json";
            } 
            else if (type == DataType::PNG) 
            {
                return "image/png";
            } 
            else 
            {
                return "";
            }
        }
    };
 
} // namespace armarx::armem::server::ltm::detail::mixin