Plugin.cpp

Go to the documentation of this file.

#include "Plugin.h"
 
#include <chrono>
 
#include "ArmarXCore/util/CPPUtility/trace.h"
#include <ArmarXCore/core/Component.h>
#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
#include <ArmarXCore/core/logging/Logging.h>
 
#include "RobotAPI/libraries/armem/server/ltm/persistence/MemoryPersistenceStrategy.h"
#include "RobotAPI/libraries/armem/server/ltm/persistence/RedundantPersistenceStrategy.h"
#include "RobotAPI/libraries/armem/server/ltm/persistence/rest/RestPersistence.h"
#include <RobotAPI/libraries/armem/client/plugins/Plugin.h>
#include <RobotAPI/libraries/armem/client/util/MemoryListener.h>
#include <RobotAPI/libraries/armem/core/error.h>
 
namespace armarx::armem::server::plugins
{
 
    Plugin::~Plugin() = default;
 
    Plugin::Plugin(ManagedIceObject& parent, std::string prefix) :
        armarx::ComponentPlugin(parent, prefix)
    {
        ARMARX_TRACE;
        addPlugin(clientPlugin);
        ARMARX_CHECK_NOT_NULL(clientPlugin);
        addPluginDependency(clientPlugin);
    }
 
    void
    Plugin::postCreatePropertyDefinitions(PropertyDefinitionsPtr& properties)
    {
        const std::string prefix = "mem.";
 
        // set Memory name if not already set
        if (workingMemory.name().empty())
        {
            Component& parent = this->parent<Component>();
            workingMemory.name() = parent.getName();
        }
 
        // also add scenario param to overwrite the chosen name
        if (not properties->hasDefinition(prefix + "MemoryName"))
        {
            properties->optional(
                workingMemory.name(), prefix + "MemoryName", "Name of this memory server.");
        }
 
        longtermMemory.createPropertyDefinitions(properties, prefix + "ltm.");
    }
 
    void
    Plugin::preOnInitComponent()
    {
        ARMARX_TRACE;
        memoryTopicName =
            client::util::MemoryListener::MakeMemoryTopicName(MemoryID(workingMemory.name()));
        parent().offeringTopic(memoryTopicName);
    }
 
    void
    Plugin::postOnInitComponent()
    {
        Component& parent = this->parent<Component>();
 
        // activate LTM
        ARMARX_TRACE;
 
 
        if (not workingMemory.id().memoryName.empty())
        {
            longtermMemory.setMemoryID(workingMemory.id());
        }
        else
        {
            longtermMemory.setMemoryID(MemoryID(parent.getDefaultName(), ""));
        }
 
        longtermMemory.configure();
 
        initialized = true;
    }
 
    void
    Plugin::preOnConnectComponent()
    {
        Component& parent = this->parent<Component>();
 
        // register new server info to MNS
        if (clientPlugin->isMemoryNameSystemEnabled() and clientPlugin->getMemoryNameSystemClient())
        {
            registerServer(parent);
        }
    }
 
    void
    Plugin::postOnConnectComponent()
    {
        Component& parent = this->parent<Component>();
        parent.getTopic(memoryTopic, memoryTopicName);
        iceAdapter.setMemoryListener(memoryTopic);
 
        this->iceAdapter.reloadFromLTMOnStartup();
 
        connected = true;
    }
 
    void
    Plugin::preOnDisconnectComponent()
    {
        //Storing rest of WM into LTM when component is shut down:
        try
        {
            if (longtermMemory.p.storeOnStop)
            {
                longtermMemory.directlyStore(workingMemory);
                ARMARX_INFO
                    << "Stored working memory contents into long-term memory on component stop";
            }
            else
            {
                ARMARX_DEBUG
                    << "Not storing WM into LTM on stop, as longtermMemory.p.storeOnstop is "
                    << longtermMemory.p.storeOnStop;
            }
        }
        catch (...)
        {
            ARMARX_WARNING
                << "Could not store working memory into the long-term memory on component stop.";
        }
        //Storing statistics aout LTM recording:
        try
        {
            if (longtermMemory.isRecording())
            {
                ARMARX_INFO << "Recording still in progress, stopping component anyways. "
                               "Saving statistics...";
                longtermMemory.getAndSaveStatistics();
            }
        }
        catch (...)
        {
            ARMARX_WARNING << "Statistics could not be saved for recording that was interrupted by "
                              "disconnecting the component";
        }
        //removing server:
        if (clientPlugin->isMemoryNameSystemEnabled() and clientPlugin->getMemoryNameSystemClient())
        {
            removeServer();
        }
    }
 
    void
    Plugin::setMemoryName(const std::string& memoryName)
    {
        if (initialized)
        {
            ARMARX_WARNING << "Please set the memory name before initializing the component. "
                              "Otherwise the WM and LTM may have different names";
        }
 
        workingMemory.name() = memoryName;
    }
 
    mns::dto::RegisterServerResult
    Plugin::registerServer(armarx::Component& parent)
    {
        ARMARX_INFO << "Registering server for " << workingMemory.name();
        ARMARX_TRACE;
 
        MemoryID id = MemoryID().withMemoryName(workingMemory.name());
        mns::dto::MemoryServerInterfaces server;
        server.reading = ReadingMemoryInterfacePrx::uncheckedCast(parent.getProxy());
        server.writing = WritingMemoryInterfacePrx::uncheckedCast(parent.getProxy());
        server.prediction = PredictingMemoryInterfacePrx::uncheckedCast(parent.getProxy());
        server.actions = actions::ActionsInterfacePrx::uncheckedCast(parent.getProxy());
        server.configuration = ConfiguringMemoryInterfacePrx::uncheckedCast(parent.getProxy());
        server.loading = LoadingMemoryInterfacePrx::uncheckedCast(parent.getProxy());
        server.readingLtm = ReadingLongTermMemoryInterfacePrx::uncheckedCast(parent.getProxy());
 
        mns::dto::RegisterServerResult result;
        try
        {
            clientPlugin->getMemoryNameSystemClient().registerServer(id, server);
            result.success = true;
            ARMARX_DEBUG << "Registered memory server for " << id
                         << " in the Memory Name System (MNS).";
        }
        catch (const armem::error::ServerRegistrationOrRemovalFailed& e)
        {
            result.success = false;
            result.errorMessage = e.what();
            ARMARX_WARNING << e.what();
        }
 
 
        return result;
    }
 
    mns::dto::RemoveServerResult
    Plugin::removeServer()
    {
        MemoryID id = MemoryID().withMemoryName(workingMemory.name());
 
        mns::dto::RemoveServerResult result;
        try
        {
            clientPlugin->getMemoryNameSystemClient().removeServer(id);
            result.success = true;
            ARMARX_DEBUG << "Removed memory server for " << id
                         << " from the Memory Name System (MNS).";
        }
        catch (const armem::error::ServerRegistrationOrRemovalFailed& e)
        {
            result.success = false;
            result.errorMessage = e.what();
            ARMARX_WARNING << e.what();
        }
        catch (const Ice::NotRegisteredException&)
        {
            // It's ok, the MNS is gone.
            result.success = false;
            result.errorMessage = "Memory Name System is gone.";
        }
        return result;
    }
 
} // namespace armarx::armem::server::plugins