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 <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::postOnConnectComponent()
    {
        Component& parent = this->parent<Component>();
 
        // register to MNS
        if (clientPlugin->isMemoryNameSystemEnabled() and clientPlugin->getMemoryNameSystemClient())
        {
            registerServer(parent);
        }
        parent.getTopic(memoryTopic, memoryTopicName);
        iceAdapter.setMemoryListener(memoryTopic);
 
        this->iceAdapter.reloadFromLTM();
 
        connected = true;
    }
 
    void
    Plugin::preOnDisconnectComponent()
    {
        /*
        ARMARX_INFO << "Preparing to save statistics for " << this->workingMemory.name();
        try
        {
            auto first_stats = longtermMemory.getFilterStatistics();
            std::map<std::string,
                     std::map<std::string, ltm::processor::SnapshotFilter::FilterStatistics>>
                information;
            std::map<std::string, armarx::core::time::DateTime> times;
 
            try
            {
                times["Started LTM1"] = longtermMemory.getStatistics().firstStarted;
                times["Stopped LTM1"] = longtermMemory.getStatistics().firstStopped;
                information["LTM"] = first_stats;
            }
            catch (...)
            {
                ARMARX_INFO << "Something went wrong after getting the statistics";
            }
            auto exportPath = longtermMemory.getMemoryBasePath();
            auto exportName = longtermMemory.getExportName();
            auto recording_started = longtermMemory.getStatistics().firstStarted;
            auto recording_stopped = longtermMemory.getStatistics().firstStopped;
            test::save_statistics(information,
                                  times,
                                  recording_started,
                                  recording_stopped,
                                  exportPath,
                                  exportName,
                                  longtermMemory.name());
        }
        catch (...)
        {
            ARMARX_INFO << "Something went wrong with the statistics saving process";
        }
 
        statistics_saved = true;
        */
        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";
        }
 
        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());
 
        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