Skill.cpp

Go to the documentation of this file.

#include "Skill.h"
 
namespace armarx
{
    namespace skills
    {
        Skill::Skill(const SkillDescription& desc) : description(desc), constructing(true)
        {
            // replace constructor if you want to have a specific logging tag
            Logging::setTag("armarx::skills::" + description.skillId.toString());
        }
 
        // install a local condition via a lambda
        void
        Skill::installConditionWithCallback(std::function<bool()>&& f, std::function<void()>&& cb)
        {
            std::scoped_lock l(conditionCallbacksMutex);
            conditionCallbacks.push_back({f, cb});
        }
 
        std::optional<TerminatedSkillStatusUpdate>
        Skill::callSubskill(const SkillProxy& proxy)
        {
            return callSubskill(proxy, proxy.getRootProfileParameters());
        }
 
        std::optional<TerminatedSkillStatusUpdate>
        Skill::callSubskill(const SkillProxy& proxy, const aron::data::DictPtr& parameters)
        {
            auto executionId = callSubskillAsync(proxy, parameters);
            auto ret = proxy.join(executionId);
 
            // While the sub skill was running, our skill might also have been aborted.
            // In this case, the correct behavour would be aborting ourselves.
            // The caller of callSubskill() can catch the thrown error::SkillAbortedException
            // if necessary.
            throwIfSkillShouldTerminate();
            return ret;
        }
 
        skills::SkillExecutionID
        Skill::callSubskillAsync(const skills::SkillProxy& prx, const aron::data::DictPtr& params)
        {
            std::unique_lock l(subskillsMutex);
 
            std::string executorHistory = this->executorName + "->" + getSkillId().toString();
            auto eid = prx.executeSkillAsync(executorHistory, params);
            this->subskills.push_back(eid);
            return eid;
        }
 
        std::optional<TerminatedSkillStatusUpdate>
        Skill::callSubskill(const SkillID& skillId)
        {
            return callSubskill(SkillProxy(manager, skillId));
        }
 
        std::optional<TerminatedSkillStatusUpdate>
        Skill::callSubskill(const SkillID& skillId, const aron::data::DictPtr& parameters)
        {
            return callSubskill(SkillProxy(manager, skillId), parameters);
        }
 
        std::optional<TerminatedSkillStatusUpdate>
        Skill::callSubskill(const SkillID& skillId,
                            std::function<void(aron::data::DictPtr&)> parametersFunction)
        {
            SkillProxy proxy(manager, skillId);
 
            aron::data::DictPtr parameters = proxy.getRootProfileParameters();
            if (not parameters)
            {
                parameters = armarx::aron::make_dict();
            }
 
            parametersFunction(parameters);
 
            return callSubskill(proxy, parameters);
        }
 
        void
        Skill::updateParameters(const aron::data::DictPtr& d)
        {
            std::scoped_lock l(this->parametersMutex);
            if (this->parameters == nullptr)
            {
                // set params as there has been no update before.
                this->parameters = d;
            }
            else
            {
                // merge params into existing. Note that this may update already set params.
                this->parameters->mergeAndReplaceCopy(d);
            }
        }
 
        void
        Skill::setParameters(const aron::data::DictPtr& d)
        {
            // we only set the params if the skill is not already running
            if (running or exiting or finished)
            {
                return;
            }
 
            std::scoped_lock l(this->parametersMutex);
            this->parameters = d;
        }
 
        aron::data::DictPtr
        Skill::getParameters() const
        {
            return this->parameters;
        }
 
        Skill::InitResult
        Skill::_init()
        {
            //ARMARX_IMPORTANT << "Initializing skill '" << description.skillName << "'";
            this->initializing = true;
            this->constructing = false;
            this->preparing = false;
            this->running = false;
            this->exiting = false;
            this->finished = false;
 
            // install timeout condition
            installConditionWithCallback(
                [&]() {
                    return (armarx::core::time::DateTime::Now() >= (started + description.timeout));
                },
                [&]() { notifyTimeoutReached(); });
 
            conditionCheckingThread = std::thread(
                [&]()
                {
                    armarx::core::time::Metronome metronome(conditionCheckingThreadFrequency);
                    while (initializing or preparing or
                           running) // when the skill ends/aborts this variable will be set to false
                    {
                        {
                            std::scoped_lock l(conditionCallbacksMutex);
                            for (auto& p : conditionCallbacks)
                            {
                                auto& f = p.first;
                                auto& cb = p.second;
                                if (f())
                                {
                                    cb();
                                }
                            }
                        }
 
                        const auto sleepDuration = metronome.waitForNextTick();
                        if (not sleepDuration.isPositive())
                        {
                            ARMARX_WARNING << deactivateSpam()
                                           << "ConditionCheckingThread: execution took too long ("
                                           << -sleepDuration << " vs "
                                           << conditionCheckingThreadFrequency.toCycleDuration()
                                           << ")";
                        }
                    }
                });
            return {.status = TerminatedSkillStatus::Succeeded};
        }
 
        Skill::PrepareResult
        Skill::_prepare()
        {
            this->preparing = true;
            this->initializing = false;
            this->constructing = false;
            this->running = false;
            this->exiting = false;
            this->finished = false;
 
            if (shouldSkillTerminate())
            {
                return {.status = ActiveOrTerminatedSkillStatus::Aborted};
            }
 
            // Default nothing to prepare
            if (not description.parametersType)
            {
                return {.status = ActiveOrTerminatedSkillStatus::Succeeded};
            }
            if (this->parameters && this->parameters->fullfillsType(description.parametersType))
            {
                // wait until parameters fulfill type
                return {.status = ActiveOrTerminatedSkillStatus::Succeeded};
            }
 
            // false if we have to wait for parameters
            return {.status = ActiveOrTerminatedSkillStatus::Running};
        }
 
        Skill::MainResult
        Skill::_main()
        {
            this->running = true;
            this->initializing = false;
            this->constructing = false;
            this->preparing = false;
            this->exiting = false;
            this->finished = false;
            return {.status = TerminatedSkillStatus::Succeeded};
        }
 
        Skill::ExitResult
        Skill::_exit()
        {
            // ARMARX_IMPORTANT << "Exiting Skill '" << description.skillName << "'";
            this->exiting = true;
            this->running = false;
            this->initializing = false;
            this->constructing = false;
            this->preparing = false;
            this->finished = false;
 
            if (conditionCheckingThread.joinable())
            {
                conditionCheckingThread.join();
            }
            exited = armarx::core::time::DateTime::Now();
 
            this->finished = true;
            this->exiting = false;
            return {.status = TerminatedSkillStatus::Succeeded};
        }
 
        Skill::InitResult
        Skill::initSkill()
        {
            std::scoped_lock l(parametersMutex);
            auto _res = this->_init();
            auto res = this->init();
            return {.status = skills::mergeSkillStatuseses(_res.status, res.status)};
        }
 
        Skill::PrepareResult
        Skill::prepareSkill()
        {
            std::scoped_lock l(parametersMutex);
            auto _res = this->_prepare();
            auto res = this->prepare();
            return {.status = skills::mergeSkillStatuseses(_res.status, res.status)};
        }
 
        Skill::MainResult
        Skill::mainOfSkill()
        {
            std::scoped_lock l(parametersMutex);
            auto _res = this->_main();
            auto res = this->main();
            return {.status = skills::mergeSkillStatuseses(_res.status, res.status),
                    .data = res.data};
        }
 
        Skill::ExitResult
        Skill::exitSkill()
        {
            std::scoped_lock l(parametersMutex);
            auto res = this->exit();
            auto _res = this->_exit();
            return {.status = skills::mergeSkillStatuseses(_res.status, res.status)};
        }
 
        void
        Skill::throwIfSkillShouldTerminate(const std::function<void()>& do_before,
                                           const std::string& abortedMessage)
        {
            if (shouldSkillTerminate())
            {
                do_before();
                throwIfSkillShouldTerminate(abortedMessage);
            }
        }
 
        void
        Skill::throwIfSkillShouldTerminate(const std::string& abortedMessage)
        {
            if (stopped)
            {
                std::string message =
                    std::string("The skill '" + getSkillId().toString() + "' was asked to stop.");
                message += abortedMessage.empty() ? "" : " Additional message: " + abortedMessage;
 
                throw error::SkillAbortedException(__PRETTY_FUNCTION__, message);
                return;
            }
 
            if (timeoutReached)
            {
                std::string message =
                    std::string("The skill '" + getSkillId().toString() + "' reached timeout.");
                message += abortedMessage.empty() ? "" : " Additional message: " + abortedMessage;
 
                ARMARX_WARNING << message;
                throw error::SkillFailedException(__PRETTY_FUNCTION__, message);
            }
        }
 
        Skill::MainResult
        Skill::MakeSucceededResult(aron::data::DictPtr data)
        {
            return MainResult{
                .status = TerminatedSkillStatus::Succeeded,
                .data = data,
            };
        }
 
        Skill::MainResult
        Skill::MakeFailedResult()
        {
            return MainResult{
                .status = TerminatedSkillStatus::Failed,
                .data = nullptr,
            };
        }
 
        Skill::MainResult
        Skill::MakeAbortedResult()
        {
            return MainResult{
                .status = TerminatedSkillStatus::Aborted,
                .data = nullptr,
            };
        }
 
        void
        Skill::notifySkillToStop()
        {
            std::scoped_lock l(subskillsMutex);
            stopped = true;
            _onStopRequested();
            onStopRequested();
        }
 
        void
        Skill::notifyTimeoutReached()
        {
            std::scoped_lock l(subskillsMutex);
            timeoutReached = true;
            _onTimeoutReached();
            onTimeoutReached();
        }
 
        bool
        Skill::shouldSkillTerminate() const
        {
            return stopped || timeoutReached;
        }
 
        // condition effects
        void
        Skill::_onTimeoutReached()
        {
            if (!manager)
            {
                return;
            }
            for (const auto& execId : subskills)
            {
                manager->abortSkillAsync(execId.toManagerIce());
            }
        }
 
        void
        Skill::_onStopRequested()
        {
            if (!manager)
            {
                return;
            }
            for (const auto& execId : subskills)
            {
                manager->abortSkillAsync(execId.toManagerIce());
            }
        }
 
        void
        Skill::onTimeoutReached()
        {
        }
 
        void
        Skill::onStopRequested()
        {
        }
 
        // always called before prepare (should not take longer than 100ms)
        Skill::InitResult
        Skill::init()
        {
            // Default nothing to init
            return {.status = TerminatedSkillStatus::Succeeded};
        }
 
        // always called before main (should not take longer than 100ms)
        Skill::PrepareResult
        Skill::prepare()
        {
            // Default nothing to prepare
            return {.status = ActiveOrTerminatedSkillStatus::Succeeded};
        }
 
        // always called after main or if skill fails (should not take longer than 100ms)
        Skill::ExitResult
        Skill::exit()
        {
            // Default nothing to exit
            return {.status = TerminatedSkillStatus::Succeeded};
        }
 
        Skill::MainResult
        Skill::main()
        {
            // This is just a dummy implementation
            ARMARX_IMPORTANT << "Dummy executing skill '" << description.skillId
                             << "'. Please overwrite this method.";
            return {.status = TerminatedSkillStatus::Succeeded, .data = nullptr};
        }
    } // namespace skills
} // namespace armarx