SkillManagerComponentPlugin.h

Go to the documentation of this file.

#pragma once
 
#include <exception>
#include <memory>
#include <mutex>
#include <optional>
#include <shared_mutex>
#include <string>
#include <vector>
 
#include <boost/uuid/uuid.hpp>
 
#include <SimoxUtility/json/json.hpp>
 
#include <ArmarXCore/core/ComponentPlugin.h>
#include <ArmarXCore/core/ManagedIceObject.h>
#include <ArmarXCore/core/time/DateTime.h>
 
#include "RobotAPI/libraries/aron/core/data/variant/container/Dict.h"
#include "RobotAPI/libraries/aron/core/type/variant/container/Object.h"
#include "RobotAPI/libraries/skills/core/FluxioSkillStatusUpdate.h"
#include "RobotAPI/libraries/skills/core/error/FluxioException.h"
#include <RobotAPI/interface/aron/Aron.h>
#include <RobotAPI/interface/skills/SkillManagerInterface.h>
#include <RobotAPI/libraries/skills/core/FluxioEdge.h>
#include <RobotAPI/libraries/skills/core/FluxioNode.h>
#include <RobotAPI/libraries/skills/core/FluxioParameter.h>
#include <RobotAPI/libraries/skills/core/FluxioProfile.h>
#include <RobotAPI/libraries/skills/core/FluxioProvider.h>
#include <RobotAPI/libraries/skills/core/FluxioResult.h>
#include <RobotAPI/libraries/skills/core/FluxioSkill.h>
#include <RobotAPI/libraries/skills/core/FluxioValue.h>
#include <RobotAPI/libraries/skills/core/ProviderID.h>
#include <RobotAPI/libraries/skills/core/ProviderInfo.h>
#include <RobotAPI/libraries/skills/core/SkillExecutionRequest.h>
#include <RobotAPI/libraries/skills/core/SkillStatusUpdate.h>
#include <RobotAPI/libraries/skills/core/error/Exception.h>
#include <RobotAPI/libraries/skills/core/executor/FluxioExecutor.h>
 
#include "SkillManagerComponentPluginUser.h"
 
namespace armarx
{
    class SkillManagerComponentPluginUser; // forward declaration
}
 
namespace armarx::plugins
{
    class SkillManagerComponentPlugin : public ComponentPlugin
    {
    public:
        using ComponentPlugin::ComponentPlugin;
 
        void preOnInitComponent() override;
 
        void preOnConnectComponent() override;
 
        void postCreatePropertyDefinitions(PropertyDefinitionsPtr& properties) override;
 
        void addProvider(const skills::ProviderInfo& info);
 
        void removeProvider(const skills::ProviderID& id);
 
        skills::SkillStatusUpdate executeSkill(const skills::SkillExecutionRequest& req);
 
        skills::SkillExecutionID executeSkillAsync(const skills::SkillExecutionRequest& req);
 
        bool updateSkillParameters(const skills::SkillExecutionID& id,
                                   const aron::data::DictPtr& data);
 
        bool abortSkill(const skills::SkillExecutionID& id);
 
        bool abortSkillAsync(const skills::SkillExecutionID& id);
 
        std::optional<skills::SkillDescription> getSkillDescription(const skills::SkillID& id);
 
        std::map<skills::SkillID, skills::SkillDescription> getSkillDescriptions();
 
        std::optional<skills::SkillStatusUpdate>
        getSkillExecutionStatus(const skills::SkillExecutionID& id);
 
        std::map<skills::SkillExecutionID, skills::SkillStatusUpdate> getSkillExecutionStatuses();
 
    protected:
        skills::ProviderID getFirstProviderNameThatHasSkill(const skills::SkillID& skillid);
 
        //****************************//
        //** Fluxio related methods **//
        //****************************//
 
        aron::type::ObjectPtr getTypes();
 
        skills::Result<std::experimental::observer_ptr<skills::FluxioExecutor>,
                       skills::error::FluxioException>
        executeFluxioSkill(const std::string& skillId,
                           const std::string& profileId,
                           const std::string& executorName,
                           armarx::aron::data::DictPtr parameters = nullptr);
 
        void abortFluxioSkill(const std::string& executionId);
 
        skills::Result<std::vector<skills::FluxioSkillStatusUpdate>, skills::error::FluxioException>
        getFluxioSkillExecutionStatus(const std::string& executionId);
 
        skills::Result<std::vector<std::experimental::observer_ptr<const skills::FluxioSkill>>,
                       skills::error::FluxioException>
        getSkillList();
 
        skills::Result<std::experimental::observer_ptr<const skills::FluxioSkill>,
                       skills::error::FluxioException>
        getSkill(const std::string& id);
 
        std::optional<std::vector<std::experimental::observer_ptr<const skills::FluxioSkill>>>
        deleteSkill(const std::string& skillId, const std::string& userId, bool dryRun);
 
        skills::Result<bool, skills::error::FluxioException>
        getSkillMutex(const std::string& skillId, const std::string& userId);
 
        void deleteSkillMutex(const std::string& skillId, const std::string& userId);
 
        skills::Result<std::vector<std::experimental::observer_ptr<const skills::FluxioSkill>>,
                       skills::error::FluxioException>
        deleteSkillParameter(const std::string& skillId,
                             const std::string& parameterId,
                             const std::string& userId,
                             bool dryRun);
 
        skills::Result<std::vector<std::experimental::observer_ptr<const skills::FluxioSkill>>,
                       skills::error::FluxioException>
        updateSkillParameter(const std::string& skillId,
                             const skills::manager::dto::FluxioParameter& parameter,
                             const std::string& userId,
                             bool dryRun);
 
        skills::Result<std::vector<std::experimental::observer_ptr<const skills::FluxioProfile>>,
                       skills::error::FluxioException>
        getProfileList();
 
        skills::Result<skills::FluxioProfile, skills::error::FluxioException>
        getProfile(const std::string& id);
 
        skills::Result<skills::FluxioProfile, skills::error::FluxioException>
        createProfile(const skills::FluxioProfile& profile);
 
        void updateProfile(const skills::FluxioProfile& profile);
 
        skills::Result<std::vector<std::experimental::observer_ptr<const skills::FluxioProvider>>,
                       skills::error::FluxioException>
        getProviderList();
 
        skills::Result<skills::FluxioProvider, skills::error::FluxioException>
        getProvider(const std::string& id);
 
        skills::Result<std::experimental::observer_ptr<const skills::FluxioProvider>,
                       skills::error::FluxioException>
        addFluxioProvider(const std::string& name);
 
        skills::Result<std::vector<std::experimental::observer_ptr<const skills::FluxioSkill>>,
                       skills::error::FluxioException>
        getSkillsOfProvider(const std::string& id);
 
        skills::Result<std::experimental::observer_ptr<const skills::FluxioSkill>,
                       skills::error::FluxioException>
        addSkillToProvider(const std::string& userId,
                           const std::string& providerId,
                           skills::FluxioSkill&& skill);
 
    private:
        struct FluxioDataCollector
        {
            std::map<std::string, skills::FluxioSkill> skills;
            std::shared_mutex skillsMutex;
 
            std::map<std::string, skills::FluxioProfile> profiles;
            std::shared_mutex profilesMutex;
 
            std::map<std::string, skills::FluxioProvider> providers;
            std::shared_mutex providersMutex;
 
            std::map<std::string, std::tuple<std::string, armarx::DateTime>> skillMutexMap;
            std::shared_mutex skillMutexMapMutex;
            const std::int64_t mutexTimeout = 30; // minutes
 
            std::map<std::string, std::unique_ptr<skills::FluxioExecutor>> fluxioExecutors;
            std::shared_mutex fluxioExecutorsMutex;
 
            std::map<std::string, aron::type::ObjectPtr> types;
            std::shared_mutex typesMutex;
        };
 
        FluxioDataCollector fluxioDC = {};
        [[noreturn]] void handleExceptionNonLockingThrow(const char* funcName,
                                                         const std::exception& e,
                                                         skills::ProviderID providerId,
                                                         bool eraseSkillProvider = true);
 
        std::optional<std::map<skills::ProviderID,
                               skills::provider::dti::SkillProviderInterfacePrx>::iterator>
        handleExceptionNonLocking(const char* funcName,
                                  const std::exception& e,
                                  skills::ProviderID providerId,
                                  bool eraseSkillProvider = true);
 
        skills::manager::dti::SkillManagerInterfacePrx myPrx;
 
        std::mutex skillProviderMapMutex;
        std::map<skills::ProviderID, skills::provider::dti::SkillProviderInterfacePrx>
            skillProviderMap;
 
        template <typename S, typename T>
        std::vector<std::experimental::observer_ptr<const T>>
        convertMapValuesToObserverVector(std::map<S, T>& map);
 
        static boost::uuids::uuid
        createUuidWithString(const std::string& str,
                             std::optional<const boost::uuids::uuid> namespaceUUID = std::nullopt);
 
        void
        convertAronObjectPtrToFluxioParameters(std::map<std::string, skills::FluxioParameter>& ret,
                                               const aron::type::ObjectPtr& ptr,
                                               bool isInput,
                                               const boost::uuids::uuid& skillId);
 
        template <typename T>
        void replaceVectorContent(std::vector<T>& originalVector,
                                  const std::vector<T>& replacementVector);
 
        bool setEditFluxioSkillMutex(bool aquireMutex,
                                     const std::string& userId,
                                     const std::string& skillId);
 
        void descriptionIdToFluxioSkill(skills::SkillID skillId,
                                        skills::SkillDescription skillDescription);
 
        skills::Result<std::vector<std::experimental::observer_ptr<const skills::FluxioSkill>>,
                       skills::error::FluxioException>
        updateFluxioParameter(
            const std::string& skillId,
            const std::string& parameterId,
            const std::string& userId,
            bool dryRun,
            bool deleteParameter,
            const std::optional<skills::manager::dto::FluxioParameter>& parameterDT = std::nullopt);
 
        friend class armarx::SkillManagerComponentPluginUser;
    };
} // namespace armarx::plugins