SkillProviderComponentPlugin.h

Go to the documentation of this file.

#pragma once
 
#include <experimental/memory>
#include <map>
#include <memory>
#include <optional>
#include <shared_mutex>
#include <string>
#include <vector>
 
#include <Ice/Current.h>
#include <IceUtil/Optional.h>
 
#include <ArmarXCore/core/ComponentPlugin.h>
#include <ArmarXCore/core/ManagedIceObject.h>
#include <ArmarXCore/core/application/properties/forward_declarations.h>
#include <ArmarXCore/core/services/tasks/RunningTask.h>
 
#include <RobotAPI/interface/aron/Aron.h>
#include <RobotAPI/interface/skills/SkillManagerInterface.h>
#include <RobotAPI/interface/skills/SkillProviderInterface.h>
#include <RobotAPI/libraries/aron/core/data/variant/container/Dict.h>
#include <RobotAPI/libraries/skills/core/Skill.h>
#include <RobotAPI/libraries/skills/core/SkillDescription.h>
#include <RobotAPI/libraries/skills/core/SkillExecutionID.h>
#include <RobotAPI/libraries/skills/core/SkillExecutionRequest.h>
#include <RobotAPI/libraries/skills/core/SkillID.h>
#include <RobotAPI/libraries/skills/core/SkillStatusUpdate.h>
#include <RobotAPI/libraries/skills/provider/LambdaSkill.h>
#include <RobotAPI/libraries/skills/provider/SkillFactory.h>
#include <RobotAPI/libraries/skills/provider/detail/SkillImplementationWrapper.h>
 
namespace armarx
{
    class SkillProviderComponentPluginUser; // forward declaration
}
 
namespace armarx::plugins
{
    class SkillProviderComponentPlugin : public ComponentPlugin
    {
    public:
        using ComponentPlugin::ComponentPlugin;
 
        void preOnInitComponent() override;
 
        void preOnConnectComponent() override;
        void postOnConnectComponent() override;
 
        void postCreatePropertyDefinitions(PropertyDefinitionsPtr& properties) override;
 
        void preOnDisconnectComponent() override;
 
        void addSkillFactory(std::unique_ptr<skills::SkillBlueprint>&&);
 
        skills::SkillBlueprint* addSkillFactory(const skills::SkillDescription&,
                                                const skills::LambdaSkill::FunctionType&);
 
        template <class SkillT, typename... Args>
 
            requires skills::isSkill<SkillT>
        skills::SkillBlueprint*
        addSkillFactory(Args&&... args)
        {
            auto fac = skills::SkillBlueprint::ForSkill<SkillT>(std::forward<Args>(args)...);
            auto* facPtr = fac.get();
            addSkillFactory(std::move(fac));
            return static_cast<skills::SkillBlueprint*>(facPtr);
        }
 
        template <typename FactoryT, typename... Args>
 
            requires skills::isSkillBlueprint<FactoryT>
        FactoryT*
        addCustomSkillFactory(Args&&... args)
        {
            auto fac = std::make_unique<FactoryT>(std::forward<Args>(args)...);
            auto* facPtr = fac.get();
            addSkillFactory(std::move(fac));
            return static_cast<FactoryT*>(facPtr);
        }
 
        // Ice forwards
        std::optional<skills::SkillStatusUpdate>
        getSkillExecutionStatus(const skills::SkillExecutionID&) const;
        std::map<skills::SkillExecutionID, skills::SkillStatusUpdate>
        getSkillExecutionStatuses() const;
 
        std::optional<skills::SkillDescription> getSkillDescription(const skills::SkillID&) const;
        std::map<skills::SkillID, skills::SkillDescription> getSkillDescriptions() const;
 
        skills::SkillStatusUpdate executeSkill(const skills::SkillExecutionRequest& executionInfo);
 
        skills::SkillExecutionID
        executeSkillAsync(const skills::SkillExecutionRequest& executionInfo);
 
        bool updateSkillParameters(const skills::SkillExecutionID& id,
                                   const armarx::aron::data::DictPtr& params);
 
        bool abortSkill(const skills::SkillExecutionID& execId);
 
        bool abortSkillAsync(const skills::SkillExecutionID& execId);
 
        void updateSubSkillStatus(const skills::SkillStatusUpdate& statusUpdate);
 
        const skills::manager::dti::SkillManagerInterfacePrx& skillManager() const;
 
    private:
        skills::SkillBlueprint* getSkillFactory(const armarx::skills::SkillID& name);
 
 
        skills::manager::dti::SkillManagerInterfacePrx manager;
        skills::provider::dti::SkillProviderInterfacePrx myPrx;
 
        mutable std::shared_mutex skillFactoriesMutex;
        std::map<skills::SkillID, std::unique_ptr<skills::SkillBlueprint>> skillFactories;
 
        // Skill runtimes are owned via shared_ptr so the executing thread (which
        // captures the shared_ptr by value in its lambda) can keep the runtime
        // alive even if it has been removed from the map. Without this, a raw
        // pointer into the map became dangling as soon as the cleanup pass
        // erased the entry, or the local pointer variable in executeSkillAsync
        // was destroyed when the function returned -> use-after-free.
        mutable std::shared_mutex skillExecutionsMutex;
        std::map<skills::SkillExecutionID, std::shared_ptr<skills::detail::SkillRuntime>>
            skillExecutions;
 
        // Removes entries from skillExecutions whose execution thread has
        // already finished. Caller MUST hold an exclusive lock on
        // skillExecutionsMutex. Joining of finished threads happens after
        // collecting candidates and is done by the caller after releasing the
        // lock to avoid blocking other operations on the map.
        std::vector<std::shared_ptr<skills::detail::SkillRuntime>>
        collectFinishedExecutions_locked();
 
        friend class armarx::SkillProviderComponentPluginUser;
    };
} // namespace armarx::plugins
 
namespace armarx
 
{
    class SkillProviderComponentPluginUser :
        virtual public ManagedIceObject,
        virtual public skills::provider::dti::SkillProviderInterface
    {
    public:
        SkillProviderComponentPluginUser();
 
        // Ice Implementations
        IceUtil::Optional<skills::provider::dto::SkillDescription>
        getSkillDescription(const skills::provider::dto::SkillID& skill,
                            const Ice::Current& current = Ice::Current()) override;
 
        skills::provider::dto::SkillDescriptionMap
        getSkillDescriptions(const Ice::Current& current = Ice::Current()) override;
 
        IceUtil::Optional<skills::provider::dto::SkillStatusUpdate>
        getSkillExecutionStatus(const skills::provider::dto::SkillExecutionID& executionId,
                                const Ice::Current& current = Ice::Current()) override;
 
        skills::provider::dto::SkillStatusUpdateMap
        getSkillExecutionStatuses(const Ice::Current& current = Ice::Current()) override;
 
        skills::provider::dto::SkillStatusUpdate
        executeSkill(const skills::provider::dto::SkillExecutionRequest& executionInfo,
                     const Ice::Current& current = Ice::Current()) override;
 
        skills::provider::dto::SkillExecutionID
        executeSkillAsync(const skills::provider::dto::SkillExecutionRequest& executionInfo,
                          const Ice::Current& current = Ice::Current()) override;
 
        skills::provider::dto::ParameterUpdateResult
        updateSkillParameters(const skills::provider::dto::SkillExecutionID& executionId,
                              const armarx::aron::data::dto::DictPtr& parameters,
                              const Ice::Current& current = Ice::Current()) override;
 
        skills::provider::dto::AbortSkillResult
        abortSkill(const skills::provider::dto::SkillExecutionID& skill,
                   const Ice::Current& current = Ice::Current()) override;
 
        skills::provider::dto::AbortSkillResult
        abortSkillAsync(const skills::provider::dto::SkillExecutionID& skill,
                        const Ice::Current& current = Ice::Current()) override;
 
        void reportSkillEvent(const skills::provider::dto::SkillStatusUpdate& statusUpdate,
                              const std::string& providerName,
                              const Ice::Current& current) override;
 
        // Plugin
        const std::experimental::observer_ptr<plugins::SkillProviderComponentPlugin>&
        getSkillProviderPlugin() const;
 
    protected:
        // -----------------------------------------------------------------------------------------
        // New
        // -----------------------------------------------------------------------------------------
        skills::SkillBlueprint*
        addSkillFactory(const skills::SkillDescription& desc,
                        const skills::LambdaSkill::FunctionType& f)
        {
            auto ret = plugin->addSkillFactory(desc, f);
            return ret;
        }
 
        template <class SkillT, typename... Args>
 
            requires skills::isSkill<SkillT>
        skills::SkillBlueprint*
        addSkillFactory(Args&&... args)
        {
            return plugin->addSkillFactory<SkillT>(std::forward<Args>(args)...);
        }
 
        template <typename FacT, typename... Args>
 
            requires skills::isSkillBlueprint<FacT>
        FacT*
        addCustomSkillFactory(Args&&... args)
        {
            return plugin->addCustomSkillFactory<FacT>(std::forward<Args>(args)...);
        }
 
    private:
        std::experimental::observer_ptr<plugins::SkillProviderComponentPlugin> plugin = nullptr;
    };
} // namespace armarx