RestPersistence.cpp

Go to the documentation of this file.

#include "RobotAPI/libraries/armem/server/ltm/persistence/rest/RestPersistence.h"
 
#include <RobotAPI/libraries/armem/server/ltm/detail/mixins/util/filesystem.h>
 
namespace armarx::armem::server::ltm::persistence
{
 
    const std::string RestPersistence::DEFAULT_HOST = "localhost";
 
    std::vector<std::string>
    RestPersistence::getContainerKeys(const armarx::armem::MemoryID& id)
    {
        if (!enabled_)
        {
            ARMARX_DEBUG << "Rest strategy " << identifier_ << " disabled. Aborting call.";
 
            return std::vector<std::string>();
        }
 
        return getRestContainers(id);
    }
 
    std::vector<std::string>
    RestPersistence::getItemKeys(const armarx::armem::MemoryID& id)
    {
        if (!enabled_)
        {
            ARMARX_DEBUG << "Rest strategy " << identifier_ << " disabled. Aborting call.";
 
            return std::vector<std::string>();
        }
 
        return getRestItems(id);
    }
 
    bool
    RestPersistence::containsContainer(const armarx::armem::MemoryID& id, std::string key)
    {
        if (!enabled_)
        {
            ARMARX_DEBUG << "Rest strategy " << identifier_ << " disabled. Aborting call.";
 
            return false;
        }
 
        return restContainsContainer(id, key);
    }
 
    bool
    RestPersistence::containsItem(const armarx::armem::MemoryID& id, std::string key)
    {
        if (!enabled_)
        {
            ARMARX_DEBUG << "Rest strategy " << identifier_ << " disabled. Aborting call.";
 
            return false;
        }
 
        return restContainsItem(id, key);
    }
 
    void
    RestPersistence::storeItem(const armarx::armem::MemoryID& id,
                               std::string key,
                               std::vector<unsigned char>& data)
    {
        if (!enabled_)
        {
            ARMARX_DEBUG << "Rest strategy " << identifier_ << " disabled. Aborting call.";
 
            return;
        }
 
        writeItemToRest(id, key, data);
    }
 
    std::vector<unsigned char>
    RestPersistence::retrieveItem(const armarx::armem::MemoryID& id, std::string key)
    {
        if (!enabled_)
        {
            ARMARX_DEBUG << "Rest strategy " << identifier_ << " disabled. Aborting call.";
 
            return std::vector<unsigned char>();
        }
 
        if (containsItem(id, key))
        {
            return readItemFromRest(id, key);
        }
 
        return std::vector<unsigned char>();
    }
 
    void
    RestPersistence::createPropertyDefinitions(PropertyDefinitionsPtr& defs,
                                               const std::string& prefix)
    {
        defs->optional(host_, prefix + "host");
        defs->optional(port_, prefix + "port");
    }
 
    bool
    RestPersistence::checkConnection()
    {
        std::string path = "/ltm";
 
        auto res = client_->Get(path);
 
        if (res)
        {
            ARMARX_IMPORTANT << "MemoryX-REST server is running at host=" << host_
                             << ", port=" << port_;
 
            return true;
        }
 
        ARMARX_IMPORTANT << "MemoryX-REST server is not running at host=" << host_
                         << ", port=" << port_;
 
        return false;
    }
 
    void
    RestPersistence::resetClient()
    {
        if (client_)
        {
            client_->stop();
        }
 
        client_ = std::make_shared<httplib::Client>(host_, port_);
    }
 
    bool
    RestPersistence::restContainsItem(const armarx::armem::MemoryID& id, std::string& key)
    {
        std::string path = buildPath(id);
        std::string query = "item=" + key;
        std::string url = path + "?" + query;
 
        ARMARX_DEBUG << "GET request: Read data from MemoryX-REST server: item=" << key
                     << ", url=" << url;
 
        auto res = client_->Get(url);
 
        bool containsItem = false;
 
        if (res && res->status == httplib::StatusCode::OK_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 == httplib::StatusCode::NotFound_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_DEBUG << "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;
    }
 
    bool
    RestPersistence::restContainsContainer(const armarx::armem::MemoryID& id, std::string& key)
    {
        std::string path = buildPath(id);
        std::string query = "container=" + key;
        std::string url = path + "?" + query;
 
        ARMARX_DEBUG << "GET request: Read data from MemoryX-REST server: container=" << key
                     << ", url=" << url;
 
        auto res = client_->Get(url);
 
        bool containsContainer = false;
 
        if (res && res->status == httplib::StatusCode::OK_200)
        {
            ARMARX_DEBUG << "GET request successful: REST-LTM contain container with key=" << key;
            ARMARX_DEBUG << "Response: " << res->body;
 
            containsContainer = true;
        }
        else if (res && res->status == httplib::StatusCode::NotFound_404)
        {
            ARMARX_DEBUG << "GET request successful: REST-LTM does not contain container with key="
                         << key;
            ARMARX_DEBUG << "Response: " << res->body;
 
            containsContainer = false;
        }
        else if (res)
        {
            ARMARX_DEBUG << "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 containsContainer;
    }
 
    std::vector<std::string>
    RestPersistence::getRestItems(const armarx::armem::MemoryID& id)
    {
        std::string path = buildPath(id);
        std::string query = "items";
        std::string url = path + "?" + query;
 
        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 == httplib::StatusCode::OK_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_DEBUG << "GET request: Error parsing JSON: " << e.what();
            }
        }
        else if (res)
        {
            ARMARX_DEBUG << "GET request failed. status=" << res->status << ", url=" << url;
        }
        else
        {
            ARMARX_DEBUG << "GET request failed. No connection could be established to the "
                            "MemoryX-REST server at host="
                         << host_ << ", port=" << port_;
        }
 
        return item_keys;
    }
 
    std::vector<std::string>
    RestPersistence::getRestContainers(const armarx::armem::MemoryID& id)
    {
        std::string path = buildPath(id);
        std::string query = "containers";
        std::string url = path + "?" + query;
 
        ARMARX_DEBUG << "GET request: Get containers from MemoryX-REST server: url=" << url;
 
        auto res = client_->Get(url);
 
        std::vector<std::string> item_keys;
 
        if (res && res->status == httplib::StatusCode::OK_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_DEBUG << "GET request failed. status=" << res->status << ", url=" << url;
        }
        else
        {
            ARMARX_DEBUG << "GET request failed. No connection could be established to the "
                            "MemoryX-REST server at host="
                         << host_ << ", port=" << port_;
        }
 
        return item_keys;
    }
 
    std::vector<unsigned char>
    RestPersistence::readItemFromRest(const armarx::armem::MemoryID& id, std::string& key)
    {
        std::string path = buildPath(id);
        std::string query = "item=" + 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 == httplib::StatusCode::OK_200)
        {
            ARMARX_DEBUG << "GET request response: " << res->body;
 
            data = std::vector<unsigned char>(res->body.begin(), res->body.end());
        }
        else if (res && res->status == httplib::StatusCode::NotFound_404)
        {
            ARMARX_DEBUG << "GET request failed: REST-LTM does not contain any item with key="
                         << key;
        }
        else if (res)
        {
            ARMARX_DEBUG << "GET request failed. status=" << res->status << ", key=" << key
                         << ", url=" << url;
        }
        else
        {
            ARMARX_DEBUG << "GET request failed. No connection could be established to the "
                            "MemoryX-REST server at host="
                         << host_ << ", port=" << port_;
        }
 
        return data;
    }
 
    void
    RestPersistence::writeItemToRest(const armarx::armem::MemoryID& id,
                                     std::string& key,
                                     const std::vector<unsigned char>& data)
    {
        std::string path = buildPath(id);
        std::string query = "item=" + 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 == httplib::StatusCode::OK_200)
        {
            ARMARX_DEBUG << "PUT request response: " << res->body;
        }
        else if (res)
        {
            ARMARX_DEBUG << "PUT request failed. status=" << res->status << ", key=" << key
                         << ", url=" << url;
        }
        else
        {
            ARMARX_DEBUG << "PUT request failed. No connection could be established to the "
                            "MemoryX-REST server at host="
                         << host_ << ", port=" << port_;
        }
    }
 
    void
    RestPersistence::writeItemToRest(const armarx::armem::MemoryID& id,
                                     std::string& key,
                                     nlohmann::json& jsonData)
    {
        std::string str_data = jsonData.dump();
        std::vector<unsigned char> data(str_data.begin(), str_data.end());
 
        writeItemToRest(id, key, DataType::JSON, data);
    }
 
    void
    RestPersistence::writeItemToRest(const armarx::armem::MemoryID& id,
                                     std::string& key,
                                     DataType type,
                                     const std::vector<unsigned char>& data)
    {
        std::string path = buildPath(id);
        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_DEBUG << "Request failed. Error: " << res.error();
        }
    }
 
    void
    RestPersistence::removeRestItem(const armarx::armem::MemoryID& id, std::string& key)
    {
        std::string path = buildPath(id);
        std::string query = "item=" + 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 == httplib::StatusCode::OK_200)
        {
            ARMARX_DEBUG << "DELETE request successful: " << res->body;
        }
        else if (res && res->status == httplib::StatusCode::NotFound_404)
        {
            ARMARX_DEBUG << "DELETE request failed. REST-LTM does not contain any item with key="
                         << key;
        }
        else if (res)
        {
            ARMARX_DEBUG << "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
    RestPersistence::setPort(int port)
    {
        port_ = port;
        resetClient();
    }
 
    int
    RestPersistence::getPort() const
    {
        return port_;
    }
 
    void
    RestPersistence::setHost(std::string& host)
    {
        host_ = host;
        resetClient();
    }
 
    std::string
    RestPersistence::getHost()
    {
        return host_;
    }
 
    std::string
    RestPersistence::buildPath(const armarx::armem::MemoryID& id)
    {
        std::string url = "/ltm/" + getExportName();
 
        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
    RestPersistence::getMimeType(DataType type)
    {
 
        std::string mime_type;
 
        if (type == DataType::JSON)
        {
            mime_type = "application/json";
        }
        else if (type == DataType::PNG)
        {
            mime_type = "image/png";
        }
 
        return mime_type;
    }
 
} // namespace armarx::armem::server::ltm::persistence