ReadWritePluginUser.cpp

Go to the documentation of this file.

#include "ReadWritePluginUser.h"
 
#include <ArmarXCore/core/Component.h>
#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
 
#include <RobotAPI/libraries/armem/core/Prediction.h>
#include <RobotAPI/libraries/armem/core/error.h>
#include <RobotAPI/libraries/armem/server/MemoryToIceAdapter.h>
 
#include <RobotAPI/libraries/armem/server/ltm/persistence/RedundantPersistenceStrategy.h>
#include <RobotAPI/libraries/armem/server/ltm/persistence/rest/RestPersistence.h>
#include <RobotAPI/libraries/armem/server/ltm/persistence/disk/DiskPersistence.h>
 
#include "Plugin.h"
 
namespace armarx::armem::server::plugins
{
 
    ReadWritePluginUser::ReadWritePluginUser()
    {
        addPlugin(plugin);
    }
 
    ReadWritePluginUser::~ReadWritePluginUser()
    {
    }
 
    void
    ReadWritePluginUser::setMemoryName(const std::string& memoryName)
    {
        plugin->setMemoryName(memoryName);
    }
 
    // WRITING
    data::AddSegmentsResult
    ReadWritePluginUser::addSegments(const data::AddSegmentsInput& input, const Ice::Current&)
    {
        ARMARX_TRACE;
        bool addCoreSegmentOnUsage = false;
        return addSegments(input, addCoreSegmentOnUsage);
    }
 
    data::AddSegmentsResult
    ReadWritePluginUser::addSegments(const data::AddSegmentsInput& input, bool addCoreSegments)
    {
        ARMARX_TRACE;
        data::AddSegmentsResult result = iceAdapter().addSegments(input, addCoreSegments);
        return result;
    }
 
    data::CommitResult
    ReadWritePluginUser::commit(const data::Commit& commitIce, const Ice::Current&)
    {
        ARMARX_TRACE;
        return iceAdapter().commitLocking(commitIce);
    }
 
    void ReadWritePluginUser::clearWorkingMemory(const Ice::Current&)
    {
        ARMARX_TRACE;
 
        ARMARX_DEBUG << "Clear working memory id=" << iceAdapter().workingMemory->id().cleanID().str();
 
        iceAdapter().workingMemory->forEachCoreSegment([](auto& coreSegment) {
            coreSegment.clear();
        });
    }
 
    // READING
    armem::query::data::Result
    ReadWritePluginUser::query(const armem::query::data::Input& input, const Ice::Current&)
    {
        ARMARX_TRACE;
        return iceAdapter().query(input);
    }
 
    armem::query::data::Result
    ReadWritePluginUser::queryLTM(const armem::query::data::Input& input, bool storeIntoWM, const Ice::Current&)
    {
        ARMARX_TRACE;
        return iceAdapter().queryLTM(input, storeIntoWM);
    }
 
    structure::data::GetServerStructureResult
    ReadWritePluginUser::getServerStructure(const Ice::Current&)
    {
        ARMARX_TRACE;
        return iceAdapter().getServerStructure();
    }
 
    // LTM STORING AND RECORDING
    dto::DirectlyStoreResult
    ReadWritePluginUser::directlyStore(const dto::DirectlyStoreInput& input, const Ice::Current&)
    {
        ARMARX_TRACE;
        return iceAdapter().directlyStore(input);
    }
 
    dto::StartRecordResult
    ReadWritePluginUser::startRecord(const dto::StartRecordInput& startRecordInput,
                                     const Ice::Current&)
    {
        ARMARX_TRACE;
        return iceAdapter().startRecord(startRecordInput);
    }
 
    dto::StopRecordResult
    ReadWritePluginUser::stopRecord(const Ice::Current&)
    {
        ARMARX_TRACE;
        return iceAdapter().stopRecord();
    }
 
    dto::RecordStatusResult
    ReadWritePluginUser::getRecordStatus(const Ice::Current&)
    {
        ARMARX_TRACE;
        return iceAdapter().getRecordStatus();
    }
 
    Plugin&
    ReadWritePluginUser::memoryServerPlugin()
    {
        return *plugin;
    }
 
    wm::Memory&
    ReadWritePluginUser::workingMemory()
    {
        return plugin->workingMemory;
    }
 
    MemoryToIceAdapter&
    ReadWritePluginUser::iceAdapter()
    {
        return plugin->iceAdapter;
    }
 
    ltm::Memory&
    ReadWritePluginUser::longtermMemory()
    {
        return plugin->longtermMemory;
    }
 
    // ACTIONS
    armem::actions::GetActionsOutputSeq
    ReadWritePluginUser::getActions(const armem::actions::GetActionsInputSeq& inputs,
                                    const ::Ice::Current& /*unused*/)
    {
        return getActions(inputs);
    }
 
    armem::actions::GetActionsOutputSeq
    ReadWritePluginUser::getActions(const armem::actions::GetActionsInputSeq& inputs)
    {
        (void)inputs;
        return {};
    }
 
    armem::actions::ExecuteActionOutputSeq
    ReadWritePluginUser::executeActions(const armem::actions::ExecuteActionInputSeq& inputs,
                                        const ::Ice::Current& /*unused*/)
    {
        return executeActions(inputs);
    }
 
    armem::actions::ExecuteActionOutputSeq
    ReadWritePluginUser::executeActions(const armem::actions::ExecuteActionInputSeq& inputs)
    {
        return {};
    }
 
    // PREDICTIONS
    armem::prediction::data::PredictionResultSeq
    ReadWritePluginUser::predict(const armem::prediction::data::PredictionRequestSeq& requests)
    {
        return iceAdapter().predict(requests);
    }
 
    armem::prediction::data::EngineSupportMap
    ReadWritePluginUser::getAvailableEngines()
    {
        return iceAdapter().getAvailableEngines();
    }
 
    armem::prediction::data::PredictionResultSeq
    ReadWritePluginUser::predict(const armem::prediction::data::PredictionRequestSeq& requests,
                                 const ::Ice::Current& /*unused*/)
    {
        return predict(requests);
    }
 
    armem::prediction::data::EngineSupportMap
    ReadWritePluginUser::getAvailableEngines(const ::Ice::Current& /*unused*/)
    {
        return getAvailableEngines();
    }
 
    armem::CommitResult
    ReadWritePluginUser::reloadFromLTM()
    {
        // Only take the core segments defined in the property 'loadedCoreSegments'
        // Why not full? Legacy code, previously also only retrieved not all core segments.
        iceAdapter().reloadFromLTMOnStartup();
        return armem::CommitResult();
    }
 
    void ReadWritePluginUser::useRestPersistenceStrategy(const std::string& identifier, const std::string& exportName, const std::string& host, int port, bool overwritePrevStrategy, const ::Ice::Current&) 
    {
        ARMARX_IMPORTANT << "Setting persistence strategy=rest via PROXY";
 
        std::shared_ptr<armem::server::ltm::persistence::RestPersistence> restPersistence = 
            std::make_shared<armem::server::ltm::persistence::RestPersistence>(identifier, 
                                                                               exportName, 
                                                                               host, 
                                                                               port);
 
        ARMARX_INFO << "MemoryID=" << iceAdapter().longtermMemory->getMemoryID().str();
        ARMARX_INFO << "Identifier=" << identifier;
        ARMARX_INFO << "Export name=" << exportName;
        ARMARX_INFO << "Host=" << host;
        ARMARX_INFO << "Port=" << port;
        ARMARX_INFO << "OverwritePrevStrategy=" << overwritePrevStrategy;
 
        if (overwritePrevStrategy)
        {
            iceAdapter().longtermMemory->getPersistenceStrategy()->clearStrategies();
            iceAdapter().longtermMemory->getPersistenceStrategy()->addStrategy(restPersistence);
        }
        else
        {
            iceAdapter().longtermMemory->getPersistenceStrategy()->addStrategy(restPersistence);
        }
    }
 
    void ReadWritePluginUser::useDiskPersistenceStrategy(const std::string& identifier, const std::string&  exportName, const std::string& exportPath, bool overwritePrevStrategy, const ::Ice::Current&) 
    {
        ARMARX_IMPORTANT << "Setting persistence strategy=disk via PROXY";
            
        std::shared_ptr<armem::server::ltm::persistence::DiskPersistence> diskPersistence = 
            std::make_shared<armem::server::ltm::persistence::DiskPersistence>(identifier, 
                                                                               exportName, 
                                                                               std::filesystem::path(exportPath));
 
        ARMARX_INFO << "MemoryID=" << iceAdapter().longtermMemory->getMemoryID().str();
        ARMARX_INFO << "Identifier=" << identifier;
        ARMARX_INFO << "Export name=" << exportName;
        ARMARX_INFO << "Export path=" << exportPath;
        ARMARX_INFO << "OverwritePrevStrategy=" << overwritePrevStrategy;
 
        if (overwritePrevStrategy)
        {
            iceAdapter().longtermMemory->getPersistenceStrategy()->clearStrategies();
            iceAdapter().longtermMemory->getPersistenceStrategy()->addStrategy(diskPersistence);
        }
        else
        {
            iceAdapter().longtermMemory->getPersistenceStrategy()->addStrategy(diskPersistence);
        }    
    }
 
    void ReadWritePluginUser::useMongoDbPersistenceStrategy(const std::string& identifier,const std::string&  exportName, bool overwritePrevStrategy, const ::Ice::Current&) 
    {
        // TODO
    }
 
    void ReadWritePluginUser::loadLTMintoWM(bool complete, const ::Ice::Current&) 
    {
        if (complete)
        {
            iceAdapter().reloadAllFromLTM();
        }
        else 
        {
            // Only take the core segments defined in the property 'loadedCoreSegments'
            iceAdapter().reloadPropertyDefinedCoreSegmentsFromLTM();
        }
    }
 
} // namespace armarx::armem::server::plugins