SkillManagerComponentPlugin.cpp

Go to the documentation of this file.

#include "SkillManagerComponentPlugin.h"
 
#include <experimental/memory>
#include <list>
#include <memory>
#include <mutex>
#include <optional>
#include <shared_mutex>
#include <stdexcept>
#include <string>
#include <thread>
#include <tuple>
#include <utility>
#include <vector>
 
#include <boost/locale.hpp>
#include <boost/uuid/name_generator.hpp>
#include <boost/uuid/nil_generator.hpp>
#include <boost/uuid/string_generator.hpp>
#include <boost/uuid/uuid.hpp>
#include <boost/uuid/uuid_generators.hpp>
#include <boost/uuid/uuid_io.hpp>
 
#include <IceUtil/UUID.h>
 
#include <SimoxUtility/algorithm/string/string_tools.h>
#include <SimoxUtility/json/json.hpp>
 
#include <ArmarXCore/core/Component.h>
#include <ArmarXCore/core/logging/Logging.h>
#include <ArmarXCore/core/time/DateTime.h>
#include <ArmarXCore/core/time/Duration.h>
#include <ArmarXCore/core/time/ice_conversions.h>
 
#include "RobotAPI/libraries/aron/core/data/variant/container/Dict.h"
#include "RobotAPI/libraries/aron/core/type/variant/container/Object.h"
#include "RobotAPI/libraries/aron/core/type/variant/forward_declarations.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/FluxioSubSkillNode.h"
#include "RobotAPI/libraries/skills/core/FluxioTypeIdentificator.h"
#include "RobotAPI/libraries/skills/core/FluxioValue.h"
#include "RobotAPI/libraries/skills/core/SkillDescription.h"
#include "RobotAPI/libraries/skills/core/error/FluxioErrorMessages.h"
#include "RobotAPI/libraries/skills/core/error/FluxioException.h"
#include "RobotAPI/libraries/skills/core/executor/FluxioCompositeExecutor.h"
#include "RobotAPI/libraries/skills/core/executor/FluxioExecutor.h"
#include "RobotAPI/libraries/skills/core/executor/FluxioMergerExecutor.h"
#include "RobotAPI/libraries/skills/core/executor/FluxioNativeExecutor.h"
#include <RobotAPI/interface/aron/Aron.h>
#include <RobotAPI/interface/skills/SkillManagerInterface.h>
#include <RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.h>
#include <RobotAPI/libraries/skills/core/SkillID.h>
#include <RobotAPI/libraries/skills/core/SkillStatusUpdate.h>
#include <RobotAPI/libraries/skills/core/error/Exception.h>
 
namespace armarx::plugins
{
    void
    SkillManagerComponentPlugin::preOnInitComponent()
    {
        // Create mock root profile
        skills::FluxioProfile root;
        root.id = "root";
        root.name = "root";
        root.description = "This is the root profile. It is the parent of all other profiles.";
        root.parentPtr = nullptr;
 
        std::unique_lock profilesLock(fluxioDC.profilesMutex);
        fluxioDC.profiles[root.id] = root;
        profilesLock.unlock();
 
        // event parameter type
        const auto& baseTypesPtr = std::make_shared<aron::type::Object>();
        const std::string& keyName = "BaseTypesNamespace";
        baseTypesPtr->setObjectName(keyName);
        const auto& eventTypePtr = std::make_shared<aron::type::Object>();
        eventTypePtr->setObjectName("Event");
        baseTypesPtr->addMemberType("Event", eventTypePtr);
 
        std::unique_lock typesLock(fluxioDC.typesMutex);
        fluxioDC.types[keyName] = baseTypesPtr;
        typesLock.unlock();
    }
 
    template <typename S, typename T>
    std::vector<std::experimental::observer_ptr<const T>>
    SkillManagerComponentPlugin::convertMapValuesToObserverVector(std::map<S, T>& map)
    {
        std::vector<std::experimental::observer_ptr<const T>> ret;
        for (const auto& [k, v] : map)
        {
            ret.push_back(std::experimental::make_observer(&v));
        }
        return ret;
    }
 
    void
    SkillManagerComponentPlugin::preOnConnectComponent()
    {
        auto& p = parent<SkillManagerComponentPluginUser>();
        p.getProxy(myPrx, -1);
    }
 
    void
    SkillManagerComponentPlugin::postCreatePropertyDefinitions(PropertyDefinitionsPtr& properties)
    {
    }
 
    skills::ProviderID
    SkillManagerComponentPlugin::getFirstProviderNameThatHasSkill(const skills::SkillID& skillId)
    {
        // NON LOCKING! WE ASSERT THAT THE CALLER HOLDS LOCK
        for (const auto& [providerName, providerPrx] : skillProviderMap)
        {
            auto allSkills = providerPrx->getSkillDescriptions();
            for (const auto& [currentSkillID, skillDesc] : allSkills)
            {
                if (currentSkillID.skillName == skillId.skillName)
                {
                    return {providerName};
                }
            }
        }
        return {"INVALID PROVIDER NAME"};
    }
 
    void
    SkillManagerComponentPlugin::addProvider(const skills::ProviderInfo& providerInfo)
    {
        std::scoped_lock l(skillProviderMapMutex);
        if (skillProviderMap.find(providerInfo.providerId) == skillProviderMap.end())
        {
            ARMARX_INFO << "Adding a provider with name '" << providerInfo.providerId.providerName
                        << "'.";
            skillProviderMap.insert({providerInfo.providerId, providerInfo.providerInterface});
        }
        else
        {
            ARMARX_INFO << "Trying to add a provider with name '"
                        << providerInfo.providerId.providerName
                        << "' but the provider already exists. "
                        << "Overwriting the old provider info.";
            skillProviderMap[providerInfo.providerId] = providerInfo.providerInterface;
        }
 
        for (const auto& [skillID, skillDesc] : providerInfo.providedSkills)
        {
            descriptionIdToFluxioSkill(skillID, skillDesc);
            ARMARX_INFO << "Adding skill '" << skillID.skillName << "' as FluxioSkill.";
        }
    }
 
    void
    SkillManagerComponentPlugin::removeProvider(const skills::ProviderID& providerId)
    {
        std::scoped_lock l(skillProviderMapMutex);
        if (auto it = skillProviderMap.find(providerId); it != skillProviderMap.end())
        {
            ARMARX_INFO << "Removing a provider with name '" << providerId.providerName << "'.";
            skillProviderMap.erase(it);
        }
        else
        {
            ARMARX_INFO << "Trying to remove a provider with name '" << providerId.providerName
                        << "' but it couldn't be found.";
        }
    }
 
    skills::SkillStatusUpdate
    SkillManagerComponentPlugin::executeSkill(const skills::SkillExecutionRequest& executionRequest)
    {
        ARMARX_CHECK(executionRequest.skillId.isFullySpecified())
            << "Got: " << executionRequest.skillId.toString();
 
        std::unique_lock l(skillProviderMapMutex);
 
        skills::ProviderID provderId(*executionRequest.skillId.providerId);
 
        // TODO: Really support regexes!
        if (executionRequest.skillId.providerId->providerName == "*")
        {
            provderId = getFirstProviderNameThatHasSkill(executionRequest.skillId);
        }
 
        if (auto it = skillProviderMap.find(provderId); it != skillProviderMap.end())
        {
            const auto& provider = it->second;
 
            if (!provider)
            {
                ARMARX_WARNING << __PRETTY_FUNCTION__ << ": Found disconnected skill provider '"
                               << provderId << "'. Removing it from skills.";
                skillProviderMap.erase(it);
 
                throw skills::error::SkillException(
                    __PRETTY_FUNCTION__,
                    "Skill execution failed. Could not execute a skill of provider '" +
                        provderId.toString() + "' because the provider does not exist.");
            }
 
            try
            {
                skills::SkillExecutionRequest provider_executionRequest{
                    .skillId = executionRequest.skillId,
                    .executorName = executionRequest.executorName,
                    .parameters = executionRequest.parameters,
                    .callbackInterface = myPrx};
 
                auto async =
                    provider->begin_executeSkill(provider_executionRequest.toProviderIce());
                l.unlock(); // allow parallel e.g. stopping. Otherwise the manager would lock himself in nested calls
                auto provider_statusUpdate_ice = provider->end_executeSkill(async);
 
                // convert to manager view
                auto statusUpdate =
                    skills::SkillStatusUpdate::FromIce(provider_statusUpdate_ice, provderId);
                return statusUpdate;
            }
            catch (const std::exception& e)
            {
                l.lock();
 
                handleExceptionNonLockingThrow(__PRETTY_FUNCTION__, e, provderId);
            }
        }
        else
        {
            throw skills::error::SkillException(
                __PRETTY_FUNCTION__,
                "Skill execution failed. Could not execute a skill of provider '" +
                    provderId.toString() + "' because the provider does not exist.");
        }
    }
 
    skills::SkillExecutionID
    SkillManagerComponentPlugin::executeSkillAsync(
        const skills::SkillExecutionRequest& executionRequest)
    {
        ARMARX_CHECK(executionRequest.skillId.isFullySpecified())
            << "Got: " << executionRequest.skillId.toString();
 
        std::unique_lock l(skillProviderMapMutex);
 
        skills::ProviderID provderId(*executionRequest.skillId.providerId);
 
        // TODO: Really support regexes!
        if (executionRequest.skillId.providerId->providerName == "*")
        {
            provderId = getFirstProviderNameThatHasSkill(executionRequest.skillId);
        }
 
        if (auto it = skillProviderMap.find(provderId); it != skillProviderMap.end())
        {
            const auto& provider = it->second;
 
            if (!provider)
            {
                ARMARX_WARNING << __PRETTY_FUNCTION__ << ": Found disconnected skill provider '"
                               << provderId << "'. Removing it from skills.";
                skillProviderMap.erase(it);
 
                throw skills::error::SkillException(
                    __PRETTY_FUNCTION__,
                    "Skill execution failed. Could not execute a skill of provider '" +
                        provderId.toString() + "' because the provider does not exist.");
            }
 
            try
            {
                skills::SkillExecutionRequest provider_executionRequest{
                    .skillId = executionRequest.skillId,
                    .executorName = executionRequest.executorName,
                    .parameters = executionRequest.parameters,
                    .callbackInterface = myPrx};
 
                auto async =
                    provider->begin_executeSkillAsync(provider_executionRequest.toProviderIce());
                l.unlock(); // allow parallel e.g. stopping. Otherwise the manager would lock himself in nested calls
                auto provider_executionID_ice = provider->end_executeSkillAsync(async);
 
                // convert to manager view
                auto executionId =
                    skills::SkillExecutionID::FromIce(provider_executionID_ice, provderId);
                executionId.skillId.providerId = provderId;
                return executionId;
            }
            catch (const std::exception& e)
            {
                l.lock();
 
                handleExceptionNonLockingThrow(__PRETTY_FUNCTION__, e, provderId);
            }
        }
        else
        {
            throw skills::error::SkillException(
                __PRETTY_FUNCTION__,
                "Skill execution failed. Could not execute a skill of provider '" +
                    provderId.toString() + "' because the provider does not exist.");
        }
    }
 
    bool
    SkillManagerComponentPlugin::updateSkillParameters(const skills::SkillExecutionID& executionId,
                                                       const aron::data::DictPtr& data)
    {
        ARMARX_DEBUG << "updateSkillParameters for skill " << executionId.skillId;
 
        ARMARX_CHECK(executionId.skillId.isFullySpecified())
            << "Got: " << executionId.skillId.toString();
 
        std::unique_lock l(skillProviderMapMutex);
        if (auto it = skillProviderMap.find(*executionId.skillId.providerId);
            it != skillProviderMap.end())
        {
            const auto& providerId = it->first;
            const auto& provider = it->second;
 
            if (!provider)
            {
                ARMARX_WARNING << __PRETTY_FUNCTION__ << ": Found disconnected skill provider '"
                               << providerId << "'. Removing it from skills.";
                skillProviderMap.erase(it);
                return false;
            }
 
            try
            {
                auto async = provider->begin_updateSkillParameters(executionId.toProviderIce(),
                                                                   data->toAronDictDTO());
                l.unlock(); // allow parallel e.g. stopping. Otherwise the manager would lock himself in nested calls
                auto r = provider->end_updateSkillParameters(async);
                return r.success;
            }
            catch (const std::exception& e)
            {
                l.lock();
 
                handleExceptionNonLocking(__PRETTY_FUNCTION__, e, providerId);
 
                return false;
            }
        }
        else
        {
            return false;
        }
    }
 
    bool
    SkillManagerComponentPlugin::abortSkill(const skills::SkillExecutionID& executionId)
    {
        ARMARX_DEBUG << "abortSkill for skill " << executionId.skillId;
 
        ARMARX_CHECK(executionId.skillId.isFullySpecified())
            << "Got: " << executionId.skillId.toString();
 
        std::unique_lock l(skillProviderMapMutex);
        if (auto it = skillProviderMap.find(*executionId.skillId.providerId);
            it != skillProviderMap.end())
        {
            const auto& providerId = it->first;
            const auto& provider = it->second;
 
            if (!provider)
            {
                ARMARX_WARNING << __PRETTY_FUNCTION__ << ": Found disconnected skill provider '"
                               << providerId << "'. Removing it from skills.";
                skillProviderMap.erase(it);
                return false;
            }
 
            try
            {
                auto async = provider->begin_abortSkill(executionId.toProviderIce());
                l.unlock(); // allow parallel e.g. stopping. Otherwise the manager would lock himself in nested calls
                auto r = provider->end_abortSkill(async);
                return r.success;
            }
            catch (const std::exception& e)
            {
                l.lock();
 
                handleExceptionNonLocking(__PRETTY_FUNCTION__, e, providerId);
 
                return false;
            }
        }
        else
        {
            return false;
        }
    }
 
    bool
    SkillManagerComponentPlugin::abortSkillAsync(const skills::SkillExecutionID& executionId)
    {
        ARMARX_CHECK(executionId.skillId.isFullySpecified())
            << "Got: " << executionId.skillId.toString();
 
        std::unique_lock l(skillProviderMapMutex);
        if (auto it = skillProviderMap.find(*executionId.skillId.providerId);
            it != skillProviderMap.end())
        {
            const auto& providerId = it->first;
            const auto& provider = it->second;
 
            if (!provider)
            {
                ARMARX_WARNING << __PRETTY_FUNCTION__ << ": Found disconnected skill provider '"
                               << providerId << "'. Removing it from skills.";
                skillProviderMap.erase(it);
                return false;
            }
 
            try
            {
                auto async = provider->begin_abortSkillAsync(executionId.toProviderIce());
                l.unlock(); // allow parallel e.g. stopping. Otherwise the manager would lock himself in nested calls
                auto r = provider->end_abortSkillAsync(async);
                return r.success;
            }
            catch (const std::exception& e)
            {
                l.lock();
 
                handleExceptionNonLocking(__PRETTY_FUNCTION__, e, providerId);
 
                return false;
            }
        }
        else
        {
            return false;
        }
    }
 
    std::optional<skills::SkillDescription>
    SkillManagerComponentPlugin::getSkillDescription(const skills::SkillID& skillId)
    {
        ARMARX_DEBUG << "getSkillDescription for skill " << skillId;
 
        ARMARX_CHECK(skillId.isFullySpecified()) << "Got: " << skillId.toString();
 
        std::unique_lock l(skillProviderMapMutex);
        if (auto it = skillProviderMap.find(*skillId.providerId); it != skillProviderMap.end())
        {
            const auto& providerId = it->first;
            const auto& provider = it->second;
 
            if (!provider)
            {
                ARMARX_WARNING << __PRETTY_FUNCTION__ << ": Found disconnected skill provider '"
                               << providerId << "'. Removing it from skills.";
                skillProviderMap.erase(it);
 
                throw skills::error::SkillException(__PRETTY_FUNCTION__,
                                                    "Skill execution failed. Could not query a "
                                                    "status update of a skill of provider '" +
                                                        providerId.toString() +
                                                        "' because the provider does not exist.");
            }
 
            try
            {
                auto async = provider->begin_getSkillDescription(skillId.toProviderIce());
                l.unlock(); // allow parallel e.g. stopping. Otherwise the manager would lock himself in nested calls
                auto provider_desc_ice = provider->end_getSkillDescription(async);
 
                if (not provider_desc_ice)
                {
                    return std::nullopt;
                }
 
                // convert to manager view
                auto desc =
                    skills::SkillDescription::FromIce(provider_desc_ice.value(), providerId);
                return desc;
            }
            catch (const std::exception& e)
            {
                l.lock();
 
                handleExceptionNonLockingThrow(__PRETTY_FUNCTION__, e, providerId);
            }
        }
        else
        {
            return std::nullopt;
        }
    }
 
    std::map<skills::SkillID, skills::SkillDescription>
    SkillManagerComponentPlugin::getSkillDescriptions()
    {
        std::map<skills::SkillID, skills::SkillDescription> ret;
 
        std::unique_lock l(skillProviderMapMutex);
        for (auto it = skillProviderMap.cbegin(); it != skillProviderMap.cend();)
        {
            const auto& providerId = it->first;
            const auto& provider = it->second;
 
            if (!provider)
            {
                ARMARX_WARNING << __PRETTY_FUNCTION__ << ": Found disconnected skill provider '"
                               << providerId << "'. Removing it from skills.";
                it = skillProviderMap.erase(it);
                continue;
            }
 
            try
            {
                auto async = provider->begin_getSkillDescriptions();
                l.unlock();
                auto m = provider->end_getSkillDescriptions(async);
                l.lock();
 
                for (const auto& [provider_skillId_ice, skillDescription_ice] : m)
                {
                    ret.insert(
                        {skills::SkillID::FromIce(provider_skillId_ice, providerId),
                         skills::SkillDescription::FromIce(skillDescription_ice, providerId)});
                }
 
                ++it;
            }
            catch (const std::exception& e)
            {
                l.lock();
 
                if (auto _it = handleExceptionNonLocking(__PRETTY_FUNCTION__, e, providerId))
                {
                    it = _it.value(); // next element
                }
            }
        }
        return ret;
    }
 
    std::optional<skills::SkillStatusUpdate>
    SkillManagerComponentPlugin::getSkillExecutionStatus(
        const skills::SkillExecutionID& executionId)
    {
        ARMARX_CHECK(executionId.skillId.isFullySpecified())
            << "Got: " << executionId.skillId.toString();
 
        std::unique_lock l(skillProviderMapMutex);
        if (auto it = skillProviderMap.find(*executionId.skillId.providerId);
            it != skillProviderMap.end())
        {
            const auto& providerId = it->first;
            const auto& provider = it->second;
 
            if (!provider)
            {
                ARMARX_WARNING << __PRETTY_FUNCTION__ << ": Found disconnected skill provider '"
                               << providerId << "'. Removing it from skills.";
                skillProviderMap.erase(it);
 
                throw skills::error::SkillException(__PRETTY_FUNCTION__,
                                                    "Skill execution failed. Could not query a "
                                                    "status update of a skill of provider '" +
                                                        providerId.toString() +
                                                        "' because the provider does not exist.");
            }
 
            try
            {
                auto async = provider->begin_getSkillExecutionStatus(executionId.toProviderIce());
                l.unlock(); // allow parallel e.g. stopping. Otherwise the manager would lock himself in nested calls
                auto provider_statusUpdate_ice = provider->end_getSkillExecutionStatus(async);
 
                if (not provider_statusUpdate_ice)
                {
                    return std::nullopt;
                }
 
                // convert to manager view
                auto statusUpdate = skills::SkillStatusUpdate::FromIce(
                    provider_statusUpdate_ice.value(), providerId);
 
                // ARMARX_WARNING << "Status update: " << statusUpdate.result;
                return statusUpdate;
            }
            catch (const std::exception& e)
            {
                l.lock();
 
                handleExceptionNonLockingThrow(__PRETTY_FUNCTION__, e, providerId);
            }
        }
        else
        {
            return std::nullopt;
        }
    }
 
    std::map<skills::SkillExecutionID, skills::SkillStatusUpdate>
    SkillManagerComponentPlugin::getSkillExecutionStatuses()
    {
        std::map<skills::SkillExecutionID, skills::SkillStatusUpdate> ret;
 
        std::unique_lock l(skillProviderMapMutex);
        for (auto it = skillProviderMap.cbegin(); it != skillProviderMap.cend();)
        {
            const auto& providerId = it->first;
            const auto& provider = it->second;
 
            if (!provider)
            {
                ARMARX_WARNING << __PRETTY_FUNCTION__ << ": Found disconnected skill provider '"
                               << providerId << "'. Removing it from skills.";
                it = skillProviderMap.erase(it);
                continue;
            }
 
            try
            {
                auto async = provider->begin_getSkillExecutionStatuses();
                l.unlock(); // allow parallel e.g. stopping. Otherwise the manager would lock himself in nested calls
                auto m = provider->end_getSkillExecutionStatuses(async);
                l.lock();
 
                for (const auto& [provider_executionId_ice, provider_statusUpdate_ice] : m)
                {
                    ret.insert(
                        {skills::SkillExecutionID::FromIce(provider_executionId_ice, providerId),
                         skills::SkillStatusUpdate::FromIce(provider_statusUpdate_ice,
                                                            providerId)});
                }
                it++;
            }
            catch (const std::exception& e)
            {
                if (auto _it = handleExceptionNonLocking(__PRETTY_FUNCTION__, e, providerId))
                {
                    it = _it.value(); // next element
                }
            }
        }
        return ret;
    }
 
    std::optional<
        std::map<skills::ProviderID, skills::provider::dti::SkillProviderInterfacePrx>::iterator>
    SkillManagerComponentPlugin::handleExceptionNonLocking(const char* funcName,
                                                           const std::exception& e,
                                                           skills::ProviderID providerId,
                                                           bool eraseSkillProvider)
    {
        // NON LOCKING! WE ASSERT THAT THE CALLER HOLDS LOCK
        if (auto it = skillProviderMap.find(providerId);
            eraseSkillProvider and it != skillProviderMap.end())
        {
            ARMARX_WARNING << funcName << ": Found disconnected or buggy skill provider '"
                           << providerId << "' during execution. Removing it from skills. "
                           << "Error: " << e.what();
            return skillProviderMap.erase(it);
        }
        else
        {
            ARMARX_WARNING << funcName << ": Found disconnected or buggy skill provider '"
                           << providerId
                           << "' during execution. However, it already got removed... "
                           << "Error: " << e.what();
            return std::nullopt;
        }
    }
 
    void
    SkillManagerComponentPlugin::handleExceptionNonLockingThrow(const char* funcName,
                                                                const std::exception& e,
                                                                skills::ProviderID providerId,
                                                                bool eraseSkillProvider)
    {
        // NON LOCKING! WE ASSERT THAT THE CALLER HOLDS LOCK
        handleExceptionNonLocking(funcName, e, providerId, eraseSkillProvider);
 
        throw skills::error::SkillException(
            funcName,
            "Skill execution failed. Could not execute a skill of provider '" +
                providerId.toString() + "' because the provider does not exist.");
    }
 
    //****************************//
    //** Fluxio related methods **//
    //****************************//
 
    skills::Result<std::experimental::observer_ptr<skills::FluxioExecutor>,
                   skills::error::FluxioException>
    SkillManagerComponentPlugin::executeFluxioSkill(const std::string& skillId,
                                                    const std::string& profileId,
                                                    const std::string& executorName,
                                                    armarx::aron::data::DictPtr parameters)
    {
        const auto& result = getSkill(skillId);
        if (!result.isSuccess())
        {
            ARMARX_WARNING << "Skill with id '" << skillId << "' not found.";
            return {skills::error::FluxioException::create(
                skills::error::createErrorMessage(skills::error::ErrorCode::SkillNotFound,
                                                  {skillId}),
                skills::error::FluxioExceptionType::NOT_FOUND,
                "SkillManagerComponentPlugin",
                __FUNCTION__,
                __LINE__)};
        }
 
        const auto& skill = result.getResult();
        if (skill == nullptr)
        {
            ARMARX_WARNING << "Unexpected nullptr for skill with id '" << skillId << "'.";
            return {skills::error::FluxioException::create(
                skills::error::createErrorMessage(skills::error::ErrorCode::SkillNotFound,
                                                  {skillId}),
                skills::error::FluxioExceptionType::NOT_FOUND,
                "SkillManagerComponentPlugin",
                __FUNCTION__,
                __LINE__)};
        }
 
        const std::string& executionId = IceUtil::generateUUID();
        const bool isNative = skill->native;
        std::experimental::observer_ptr<skills::FluxioExecutor> executorPtr = nullptr;
 
        if (parameters == nullptr)
        {
            ARMARX_WARNING << "No parameters supplied for skill '" << skill->name << "(" << skillId
                           << ")'. Using profile values instead.";
 
            parameters = std::make_shared<aron::data::Dict>();
        }
 
        ARMARX_WARNING
            << "Initializing skill execution with the following parameter values (overrides): "
            << aron::data::converter::AronNlohmannJSONConverter::ConvertToNlohmannJSON(parameters);
 
        if (!isNative)
        {
            const auto& executeFluxioSkillFunc =
                [this](const std::string& skillId,
                       const std::string& profileId,
                       const std::string& executorName,
                       const armarx::aron::data::DictPtr& parameters)
            {
                return this->executeFluxioSkill(skillId, profileId, executorName, parameters)
                    .getResult();
            };
 
            const auto& abortFluxioSkill = [this](const std::string& executionId)
            { this->abortFluxioSkill(executionId); };
 
            const auto& addMergerExecutorToDCFunc =
                [this](const std::vector<std::string>& parameterIds)
            {
                const auto& executorId = IceUtil::generateUUID();
                std::unique_lock l(this->fluxioDC.fluxioExecutorsMutex);
 
                this->fluxioDC.fluxioExecutors[executorId] =
                    std::make_unique<skills::FluxioMergerExecutor>(executorId, parameterIds);
 
                const auto& ret = std::experimental::make_observer(
                    this->fluxioDC.fluxioExecutors[executorId].get());
                l.unlock();
                return ret;
            };
 
            std::shared_lock skillLock(fluxioDC.skillsMutex);
            const auto& skillRef = fluxioDC.skills[skillId];
            skillLock.unlock();
 
            std::unique_lock l(fluxioDC.fluxioExecutorsMutex);
            fluxioDC.fluxioExecutors[executionId] =
                std::make_unique<skills::FluxioCompositeExecutor>(
                    executionId,
                    skillRef,
                    std::move(abortFluxioSkill),
                    std::move(executeFluxioSkillFunc),
                    std::move(addMergerExecutorToDCFunc));
 
            executorPtr =
                std::experimental::make_observer(fluxioDC.fluxioExecutors[executionId].get());
            l.unlock();
 
            const auto& profilePtr =
                std::experimental::make_observer(&(fluxioDC.profiles[profileId]));
 
            std::thread([executorPtr, executorName, parameters, profilePtr]()
                        { executorPtr->run(executorName, parameters, profilePtr); })
                .detach();
        }
        else
        {
            skills::SkillID sID = skills::SkillID{
                .providerId = skills::ProviderID{.providerName = skill->skillProviderPtr->name},
                .skillName = skill->name};
 
            auto skillDescr = getSkillDescription(sID);
            if (!skillDescr.has_value())
            {
                ARMARX_WARNING << "Skill description for skill with id '" << skillId
                               << "' not found. Aborting execution." << sID.toString();
 
                return {skills::error::FluxioException::create(
                    skills::error::createErrorMessage(skills::error::ErrorCode::SkillDescNotFound,
                                                      {skillId}),
                    skills::error::FluxioExceptionType::NOT_FOUND,
                    "SkillManagerComponentPlugin",
                    __FUNCTION__,
                    __LINE__)};
            }
 
            const auto& abortSkillFunc = [this](const skills::SkillExecutionID& executionId)
            { return this->abortSkill(executionId); };
 
            const auto& executeSkillAsyncFunc = [this](const skills::SkillExecutionRequest& req)
            { return this->executeSkillAsync(req); };
 
            const auto& getSkillExecutionStatusFunc =
                [this](const skills::SkillExecutionID& executionId)
            { return this->getSkillExecutionStatus(executionId); };
 
            std::unique_lock l(fluxioDC.fluxioExecutorsMutex);
            fluxioDC.fluxioExecutors[executionId] = std::make_unique<skills::FluxioNativeExecutor>(
                executionId,
                sID,
                *skill,
                std::move(abortSkillFunc),
                std::move(executeSkillAsyncFunc),
                std::move(getSkillExecutionStatusFunc));
 
            executorPtr =
                std::experimental::make_observer(fluxioDC.fluxioExecutors[executionId].get());
            l.unlock();
 
            const auto& profilePtr =
                std::experimental::make_observer(&(fluxioDC.profiles[profileId]));
 
            std::thread([executorPtr, executorName, parameters, profilePtr]()
                        { executorPtr->run(executorName, parameters, profilePtr); })
                .detach();
        }
 
        return {executorPtr};
    }
 
    void
    SkillManagerComponentPlugin::abortFluxioSkill(const std::string& executionId)
    {
        std::shared_lock l(fluxioDC.fluxioExecutorsMutex);
        const auto& executorIt = fluxioDC.fluxioExecutors.find(executionId);
        if (executorIt == fluxioDC.fluxioExecutors.end())
        {
            ARMARX_WARNING << "Execution with id '" << executionId << "' not found.";
 
            l.unlock();
            throw skills::error::FluxioException::create(
                skills::error::createErrorMessage(skills::error::ErrorCode::ExecutionNotFound,
                                                  {executionId}),
                skills::error::FluxioExceptionType::NOT_FOUND,
                "SkillManagerComponentPlugin",
                __FUNCTION__,
                __LINE__)
                .toManagerIce();
        }
        l.unlock();
 
        executorIt->second->abort();
    }
 
    skills::Result<std::vector<skills::FluxioSkillStatusUpdate>, skills::error::FluxioException>
    SkillManagerComponentPlugin::getFluxioSkillExecutionStatus(const std::string& executionId)
    {
        std::shared_lock l(fluxioDC.fluxioExecutorsMutex);
        const auto& executorIt = fluxioDC.fluxioExecutors.find(executionId);
        if (executorIt == fluxioDC.fluxioExecutors.end())
        {
            ARMARX_WARNING << "Execution with id '" << executionId << "' not found.";
 
            l.unlock();
            return {skills::error::FluxioException::create(
                skills::error::createErrorMessage(skills::error::ErrorCode::ExecutionNotFound,
                                                  {executionId}),
                skills::error::FluxioExceptionType::NOT_FOUND,
                "SkillManagerComponentPlugin",
                __FUNCTION__,
                __LINE__)};
        }
        l.unlock();
 
        return {executorIt->second->getStatusUpdate().value()};
    }
 
    /**
    * @brief converts parametersType or resultType from skilldescription to fluxio parameters
    * @param ret the map to insert the fluxio parameters into
    * @param ptr the aron object ptr to convert (this is either skillDescription.parametersType or skillDescription.resultType)
    * @param isInput value for the isInput field of the fluxio parameter(s)
    */
    void
    SkillManagerComponentPlugin::convertAronObjectPtrToFluxioParameters(
        std::map<std::string, skills::FluxioParameter>& ret,
        const aron::type::ObjectPtr& ptr,
        bool isInput,
        const boost::uuids::uuid& skillId)
    {
        for (const auto& [name, typeInfo] : ptr->getMemberTypes())
        {
            skills::FluxioParameter p;
 
            const auto& seed = name + (isInput ? "isInput" : "isOutput");
            p.id = boost::uuids::to_string(createUuidWithString(seed, skillId));
            p.name = name;
            // Full type name may contain some extra info like dimensions etc.
            p.description = typeInfo->getFullName();
            p.type = typeInfo;
            p.typeIdentificator = {boost::uuids::to_string(skillId), p.id};
            p.required = (typeInfo->getMaybe() == 0);
            p.isInput = isInput;
 
            ret[p.id] = p;
            std::unique_lock l(fluxioDC.typesMutex);
            fluxioDC.types[boost::uuids::to_string(skillId)]->addMemberType(p.id, typeInfo);
 
            l.unlock();
        }
    }
 
    boost::uuids::uuid
    SkillManagerComponentPlugin::createUuidWithString(
        const std::string& str,
        std::optional<const boost::uuids::uuid> namespaceUUID)
    {
        boost::uuids::uuid nameS;
        if (namespaceUUID.has_value())
        {
            nameS = namespaceUUID.value();
        }
        else
        {
            // use default null uuid
            nameS = boost::uuids::nil_uuid();
        }
 
        // initialise the name generator with the starting UUID
        boost::uuids::name_generator generator(nameS);
 
        // generate a new UUID, seeded with the given string
        return generator(str);
    }
 
    /**
    * @brief Converts the old skill structure to the new FluxioSkill structure.
    * @param skillId The id of the skill.
    * @param skillDescription The description of the skill.
    */
    void
    SkillManagerComponentPlugin::descriptionIdToFluxioSkill(
        skills::SkillID skillId,
        skills::SkillDescription skillDescription)
    {
        {
            // generate skill id (idempotent)
            const auto& providerId = createUuidWithString(skillId.providerId->providerName);
            const auto& id = createUuidWithString(skillId.skillName, providerId);
 
            std::unique_lock skillsLock(fluxioDC.skillsMutex);
            auto skillsEntry = fluxioDC.skills.find(boost::uuids::to_string(id));
            if (skillsEntry != fluxioDC.skills.end())
            {
                skillsLock.unlock();
                return;
            }
 
            skills::FluxioSkill s;
 
            s.id = boost::uuids::to_string(id);
            s.name = skillId.skillName;
            s.description = skillDescription.description;
            s.timeout = skillDescription.timeout;
            s.lastChanged = "";
            s.executable = false;
            s.native = true;
 
            std::unique_lock providersLock(fluxioDC.providersMutex);
            const auto& providersEntry =
                fluxioDC.providers.find(boost::uuids::to_string(providerId));
            if (providersEntry != fluxioDC.providers.end())
            {
                s.skillProviderPtr = std::experimental::make_observer(&(providersEntry->second));
                providersLock.unlock();
            }
            else
            {
                providersLock.unlock();
                const auto& res = addFluxioProvider(skillId.providerId->providerName);
                if (!res.isSuccess())
                {
                    ARMARX_WARNING << "Failed to add provider with name '"
                                   << skillId.providerId->providerName << "'. Skill: '" << s.name
                                   << " with id: '" << s.id << "' will not be added.";
                    skillsLock.unlock();
                    return;
                }
                const auto p = res.getResult(); // TODO: nullptr check
                s.skillProviderPtr = p;
            }
            std::unique_lock typesLock(fluxioDC.typesMutex);
            const auto& eventTypeIt = fluxioDC.types.find("BaseTypesNamespace");
            if (eventTypeIt == fluxioDC.types.end())
            {
                ARMARX_WARNING << "Event type not found. Skill: '" << s.name << " with id: '"
                               << s.id << "' will not be added.";
                typesLock.unlock();
                skillsLock.unlock();
                return;
            }
            typesLock.unlock();
            const auto& eventType = eventTypeIt->second->getMemberType("Event");
            const skills::FluxioTypeIdentificator& eventTypeIdent = {
                .skillId = "BaseTypesNamespace", .parameterId = "Event"};
            // add default control flow parameters
            skills::FluxioParameter start;
            start.name = "Start";
            start.type = eventType;
            start.typeIdentificator = eventTypeIdent;
            const auto& startIdStr = start.name + start.type->getFullName() + "isInput";
            start.id = boost::uuids::to_string(createUuidWithString(startIdStr, id));
            start.description = "Start the skill";
            start.required = true;
            start.isInput = true;
 
            skills::FluxioParameter succeeded;
            succeeded.name = "Succeeded";
            succeeded.type = eventType;
            succeeded.typeIdentificator = eventTypeIdent;
            const auto& successIdStr = succeeded.name + succeeded.type->getFullName() + "isOutput";
            succeeded.id = boost::uuids::to_string(createUuidWithString(successIdStr, id));
            succeeded.description = "Skill has been executed successfully";
            succeeded.required = false;
            succeeded.isInput = false;
 
            skills::FluxioParameter failed;
            failed.name = "Failed";
            failed.type = eventType;
            failed.typeIdentificator = eventTypeIdent;
            const auto& failedIdStr = failed.name + failed.type->getShortName() + "isOutput";
            failed.id = boost::uuids::to_string(createUuidWithString(failedIdStr, id));
            failed.description = "Skill has failed";
            failed.required = false;
            failed.isInput = false;
 
            skills::FluxioParameter aborted;
            aborted.name = "Aborted";
            aborted.type = eventType;
            aborted.typeIdentificator = eventTypeIdent;
            const auto& abortedIdStr = aborted.name + aborted.type->getShortName() + "isOutput";
            aborted.id = boost::uuids::to_string(createUuidWithString(abortedIdStr, id));
            aborted.description = "Skill has been aborted";
            aborted.required = false;
            aborted.isInput = false;
 
            s.parameters[start.id] = start;
            s.parameters[succeeded.id] = succeeded;
            s.parameters[failed.id] = failed;
            s.parameters[aborted.id] = aborted;
 
            const auto& parameters = std::make_shared<aron::type::Object>();
            typesLock.lock();
            if (fluxioDC.types.find(s.id) == fluxioDC.types.end())
            {
                fluxioDC.types[s.id] = parameters;
            }
            typesLock.unlock();
 
            if (skillDescription.parametersType != nullptr)
            {
                // input parameters
                convertAronObjectPtrToFluxioParameters(
                    s.parameters, skillDescription.parametersType, true, id);
            }
 
            if (skillDescription.resultType != nullptr)
            {
                // output parameters
                convertAronObjectPtrToFluxioParameters(
                    s.parameters, skillDescription.resultType, false, id);
            }
 
            if (skillDescription.rootProfileDefaults != nullptr)
            {
                auto rootProfilePtr = std::experimental::make_observer(&fluxioDC.profiles["root"]);
 
                for (const auto& [k, v] : skillDescription.rootProfileDefaults->getElements())
                {
                    if (v == nullptr)
                    {
                        // nullptr values are not allowed (will lead to problems down the line)
                        continue;
                    }
 
                    skills::FluxioValue val;
                    val.profilePtr = rootProfilePtr;
                    val.content = v;
 
                    for (const auto& [pId, param] : s.parameters)
                    {
                        if (param.name == k && param.isInput)
                        {
                            s.parameters[pId].values.push_back(val);
                            break;
                        }
                    }
                }
            }
            else
            {
                ARMARX_INFO << "No root profile defaults found for skill '" << s.name << "'.";
            }
 
            fluxioDC.skills.emplace(s.id, std::move(s));
            skillsLock.unlock();
        }
    }
 
    skills::Result<std::vector<std::experimental::observer_ptr<const skills::FluxioSkill>>,
                   skills::error::FluxioException>
    SkillManagerComponentPlugin::getSkillList()
    {
        return {convertMapValuesToObserverVector(fluxioDC.skills)};
    }
 
    skills::Result<std::experimental::observer_ptr<const skills::FluxioSkill>,
                   skills::error::FluxioException>
    SkillManagerComponentPlugin::getSkill(const std::string& id)
    {
        std::shared_lock l(fluxioDC.skillsMutex);
        const auto& skillsEntry = fluxioDC.skills.find(id);
        if (skillsEntry == fluxioDC.skills.end())
        {
            ARMARX_WARNING << "Skill with id '" << id << "' not found.";
            l.unlock();
            return {skills::error::FluxioException::create(
                skills::error::createErrorMessage(skills::error::ErrorCode::SkillNotFound, {id}),
                skills::error::FluxioExceptionType::NOT_FOUND,
                "SkillManagerComponentPlugin",
                __FUNCTION__,
                __LINE__)};
        }
 
        l.unlock();
        return {std::experimental::make_observer(&skillsEntry->second)};
    }
 
    // TODO: Outsource to a helper function or a separate class
    std::optional<std::vector<std::experimental::observer_ptr<const skills::FluxioSkill>>>
    SkillManagerComponentPlugin::deleteSkill(const std::string& skillId,
                                             const std::string& userId,
                                             const bool dryRun)
    {
        std::shared_lock l(fluxioDC.skillsMutex);
        const auto& skillIt = fluxioDC.skills.find(skillId);
        if (skillIt == fluxioDC.skills.end())
        {
            ARMARX_WARNING << "Skill with id '" << skillId << "' not found.";
            l.unlock();
            return std::nullopt;
        }
        l.unlock();
 
        if (skillIt->second.native)
        {
            ARMARX_WARNING << "Skill with id '" << skillId
                           << "' is a native skill and cannot be deleted.";
            return std::nullopt;
        }
 
        const auto& skillMutexResult = getSkillMutex(skillId, userId);
 
        if (!skillMutexResult.isSuccess())
        {
            ARMARX_WARNING << "User '" << userId << "' needs to acquire the mutex for skill '"
                           << skillId << "' in order to delete it.";
            return std::nullopt;
        }
 
        if (!skillMutexResult.getResult())
        {
            ARMARX_WARNING << "User '" << userId << "' needs to acquire the mutex for skill '"
                           << skillId << "' in order to delete it.";
            return std::nullopt;
        }
 
        std::vector<std::experimental::observer_ptr<skills::FluxioSkill>> affectedSkills;
        std::vector<std::experimental::observer_ptr<const skills::FluxioSkill>> ret;
        l.lock();
        for (auto& [id, s] : fluxioDC.skills)
        {
            if (s.native || s.id == skillId)
            {
                continue; // ignore native skills and the to-delete skill
            }
 
            for (const auto& [nodeId, node] : s.nodes)
            {
                if (node == nullptr)
                {
                    ARMARX_WARNING << "Unexpected nullptr!";
                    continue;
                }
 
                if (node->nodeType == skills::FluxioNodeType::SUBSKILL)
                {
                    // cast to the right node type
                    const auto& subSkillNodeptr =
                        dynamic_cast<skills::FluxioSubSkillNode*>(node.get());
                    if (subSkillNodeptr == nullptr)
                    {
                        ARMARX_WARNING << "Error while casting node to FluxioSubSkillNode.";
                        continue;
                    }
 
                    if (subSkillNodeptr->skillPtr != nullptr &&
                        subSkillNodeptr->skillPtr->id == skillId)
                    {
                        affectedSkills.emplace_back(std::experimental::make_observer(&s));
                        ret.emplace_back(std::experimental::make_observer(&s));
                        break;
                    }
                }
            }
        }
        l.unlock();
 
        if (dryRun)
        {
            return ret;
        }
 
        // get mutex of all affected skills
        bool mutexesAquired = true;
        for (const auto& affectedSkill : affectedSkills)
        {
            const auto& affectedMutexResult = getSkillMutex(affectedSkill->id, userId);
 
            if (!affectedMutexResult.isSuccess() || !affectedMutexResult.getResult())
            {
                mutexesAquired = false;
                ARMARX_WARNING << "Someone else is editing the skill '" << affectedSkill->name
                               << "(" << affectedSkill->id << ")' right now.";
            }
        }
 
        if (mutexesAquired)
        {
            ARMARX_WARNING << "Updating affected skills.";
            for (const auto& affectedSkill : affectedSkills)
            {
                affectedSkill->removeSubSkillNodesAndEdges(skillId);
            }
 
            ARMARX_WARNING << "Deleting skill '" << skillIt->second.name << "' (" << skillId
                           << ").";
            std::unique_lock skillsLock(fluxioDC.skillsMutex);
            fluxioDC.skills.erase(skillId);
            skillsLock.unlock();
        }
        else
        {
            ARMARX_WARNING
                << "Not all Mutexes for affected skills could be aquired. Aborting deletion.";
        }
 
        //release mutexes
        for (const auto& affectedSkill : affectedSkills)
        {
            deleteSkillMutex(affectedSkill->id, userId);
        }
 
        if (mutexesAquired)
        {
            return ret;
        }
        return std::nullopt;
    }
 
    skills::Result<std::vector<std::experimental::observer_ptr<const skills::FluxioSkill>>,
                   skills::error::FluxioException>
    SkillManagerComponentPlugin::deleteSkillParameter(const std::string& skillId,
                                                      const std::string& parameterId,
                                                      const std::string& userId,
                                                      bool dryRun)
    {
        return updateFluxioParameter(skillId, parameterId, userId, dryRun, true);
    }
 
    skills::Result<std::vector<std::experimental::observer_ptr<const skills::FluxioSkill>>,
                   skills::error::FluxioException>
    SkillManagerComponentPlugin::updateSkillParameter(
        const std::string& skillId,
        const skills::manager::dto::FluxioParameter& parameter,
        const std::string& userId,
        bool dryRun)
    {
        const auto& parameterId = parameter.id;
        return updateFluxioParameter(skillId, parameterId, userId, dryRun, false, parameter);
    }
 
    skills::Result<std::vector<std::experimental::observer_ptr<const skills::FluxioSkill>>,
                   skills::error::FluxioException>
    SkillManagerComponentPlugin::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)
    {
        if (!deleteParameter && parameterDT == std::nullopt)
        {
            ARMARX_WARNING << "Required parameter data transfer object not provided.";
            return {skills::error::FluxioException::create(
                skills::error::createErrorMessage(skills::error::ErrorCode::MissingRequired,
                                                  {"parameter data transfer object"}),
                skills::error::FluxioExceptionType::NOT_FOUND,
                "SkillManagerComponentPlugin",
                __FUNCTION__,
                __LINE__)};
        }
 
        // check if skill exists
        const auto& res = getSkill(skillId);
        if (!res.isSuccess())
        {
            return {skills::error::FluxioException::create(
                skills::error::createErrorMessage(skills::error::ErrorCode::SkillNotFound,
                                                  {skillId}),
                skills::error::FluxioExceptionType::NOT_FOUND,
                "SkillManagerComponentPlugin",
                __FUNCTION__,
                __LINE__)};
        }
        const auto& skill = res.getResult();
 
        // check if parameter exists
        const auto& parameterIt = skill->parameters.find(parameterId);
        if (parameterIt == skill->parameters.end())
        {
            return {skills::error::FluxioException::create(
                skills::error::createErrorMessage(skills::error::ErrorCode::ParameterNotFound,
                                                  {parameterId}),
                skills::error::FluxioExceptionType::NOT_FOUND,
                "SkillManagerComponentPlugin",
                __FUNCTION__,
                __LINE__)};
        }
        const auto& parameterOld = parameterIt->second;
 
        // check if user has mutex
        const auto& mutexResult = getSkillMutex(skillId, userId);
        if (!mutexResult.isSuccess())
        {
            return {mutexResult.getError()};
        }
 
        // find affected skills
        std::vector<std::experimental::observer_ptr<skills::FluxioSkill>> affectedSkills;
        std::vector<std::experimental::observer_ptr<const skills::FluxioSkill>> ret;
 
        // skip this part, if the parameter is updated and neither type nor isInput has changed
        if (deleteParameter ||
            parameterOld.typeIdentificator.toManagerIce() != parameterDT.value().type ||
            parameterOld.isInput != parameterDT.value().isInput)
        {
            std::shared_lock l(fluxioDC.skillsMutex);
            for (auto& [id, s] : fluxioDC.skills)
            {
                if (s.native || s.id == skillId)
                {
                    continue; // ignore native skills and the skill with the parameter itself
                }
 
                for (const auto& e : s.edges)
                {
                    if ((e.fromParameterPtr != nullptr && e.fromParameterPtr->id == parameterId) ||
                        (e.toParameterPtr != nullptr && e.toParameterPtr->id == parameterId))
                    {
                        affectedSkills.emplace_back(std::experimental::make_observer(&s));
                        ret.emplace_back(std::experimental::make_observer(&s));
                        break;
                    }
                }
            }
            l.unlock();
        }
 
        if (dryRun)
        {
            return {ret};
        }
 
        // get mutex of all affected skills
        bool mutexesAquired = true;
        for (const auto& affectedSkill : affectedSkills)
        {
            const auto& affectedMutexResult = getSkillMutex(affectedSkill->id, userId);
 
            if (!affectedMutexResult.isSuccess() || !affectedMutexResult.getResult())
            {
                mutexesAquired = false;
                ARMARX_WARNING << "Someone else is editing the skill '" << affectedSkill->name
                               << "(" << affectedSkill->id << ")' right now.";
            }
        }
 
        // update or delete parameter
        if (mutexesAquired)
        {
            ARMARX_WARNING << "Updating affected skills.";
            for (const auto& affectedSkill : affectedSkills)
            {
                affectedSkill->removeEdgesConnectedToParameter(parameterId);
            }
 
            if (deleteParameter)
            {
                ARMARX_WARNING << "Deleting skill parameter'" << parameterOld.name << "' ("
                               << parameterId << ").";
                std::unique_lock skillsLock(fluxioDC.skillsMutex);
                fluxioDC.skills[skillId].deleteParameter(parameterId);
                skillsLock.unlock();
            }
            else
            {
                ARMARX_WARNING << "Updating skill parameter'" << parameterOld.name << "' ("
                               << parameterId << ").";
                std::scoped_lock l(fluxioDC.skillsMutex,
                                   fluxioDC.profilesMutex,
                                   fluxioDC.providersMutex,
                                   fluxioDC.typesMutex);
                auto& profilesMap = fluxioDC.profiles;
                auto& typesMap = fluxioDC.types;
                fluxioDC.skills[skillId].removeParameterNodesAndEdges(parameterId, true);
                fluxioDC.skills[skillId].parameters[parameterId].updateFromIce(
                    *parameterDT, profilesMap, typesMap);
            }
        }
        else
        {
            ARMARX_WARNING << "Not all Mutexes for affected skills could be aquired. Aborting "
                           << (deleteParameter ? "deletion" : "update") << " of parameter.";
        }
 
        //release mutexes
        for (const auto& affectedSkill : affectedSkills)
        {
            deleteSkillMutex(affectedSkill->id, userId);
        }
 
        if (mutexesAquired)
        {
            return ret;
        }
 
        return {skills::error::FluxioException::create(
            skills::error::createErrorMessage(skills::error::ErrorCode::GenericMutexError,
                                              {userId}),
            skills::error::FluxioExceptionType::NOT_FOUND,
            "SkillManagerComponentPlugin",
            __FUNCTION__,
            __LINE__)};
    }
 
    skills::Result<bool, skills::error::FluxioException>
    SkillManagerComponentPlugin::getSkillMutex(const std::string& skillId,
                                               const std::string& userId)
    {
        return setEditFluxioSkillMutex(true, userId, skillId);
    }
 
    void
    SkillManagerComponentPlugin::deleteSkillMutex(const std::string& skillId,
                                                  const std::string& userId)
    {
        setEditFluxioSkillMutex(false, userId,
                                skillId); // ignore return value for now
    }
 
    skills::Result<std::vector<std::experimental::observer_ptr<const skills::FluxioProfile>>,
                   skills::error::FluxioException>
    SkillManagerComponentPlugin::getProfileList()
    {
        std::shared_lock l(fluxioDC.profilesMutex);
        const auto& ret = convertMapValuesToObserverVector(fluxioDC.profiles);
        l.unlock();
        return {ret};
    }
 
    skills::Result<skills::FluxioProfile, skills::error::FluxioException>
    SkillManagerComponentPlugin::getProfile(const std::string& id)
    {
        std::shared_lock l(fluxioDC.profilesMutex);
        const auto& profilesEntry = fluxioDC.profiles.find(id);
 
        if (profilesEntry == fluxioDC.profiles.end())
        {
            l.unlock();
            return {skills::error::FluxioException::create(
                skills::error::createErrorMessage(skills::error::ErrorCode::ProfileNotFound, {id}),
                skills::error::FluxioExceptionType::NOT_FOUND,
                "SkillManagerComponentPlugin",
                __FUNCTION__,
                __LINE__)};
        }
 
        l.unlock();
        return {profilesEntry->second};
    }
 
    skills::Result<skills::FluxioProfile, skills::error::FluxioException>
    SkillManagerComponentPlugin::createProfile(const skills::FluxioProfile& profile)
    {
        if (profile.parentPtr == nullptr)
        {
            ARMARX_WARNING << "Profile with name '" << profile.name << "' has no parent.";
            return {skills::error::FluxioException::create(
                skills::error::createErrorMessage(skills::error::ErrorCode::ProfileHasNoParent,
                                                  {profile.name}),
                skills::error::FluxioExceptionType::BAD_REQUEST,
                "SkillManagerComponentPlugin",
                __FUNCTION__,
                __LINE__)};
        }
 
        const auto& parentId = profile.parentPtr->id;
        const auto& nameLowerCase = simox::alg::to_lower(profile.name);
 
        std::unique_lock l(fluxioDC.profilesMutex);
        auto it = std::find_if(
            fluxioDC.profiles.begin(),
            fluxioDC.profiles.end(),
            [&parentId, &nameLowerCase](const std::pair<std::string, skills::FluxioProfile>& p)
            {
                return p.second.parentPtr != nullptr && p.second.parentPtr->id == parentId &&
                       simox::alg::to_lower(p.second.name) == nameLowerCase;
            });
 
        if (nameLowerCase == "root" || it != fluxioDC.profiles.end())
        {
            ARMARX_WARNING << "Profile with name '" << profile.name << "' already exists.";
            l.unlock();
            return {skills::error::FluxioException::create(
                skills::error::createErrorMessage(skills::error::ErrorCode::ProfileAlreadyExists,
                                                  {profile.name}),
                skills::error::FluxioExceptionType::BAD_REQUEST,
                "SkillManagerComponentPlugin",
                __FUNCTION__,
                __LINE__)};
        }
 
        std::string id = profile.id;
 
        bool validId = false;
        try
        {
            const auto& result = boost::uuids::string_generator()(id);
            validId = result.version() != boost::uuids::uuid::version_unknown;
        }
        catch (...)
        {
            validId = false;
        }
 
        if (!validId)
        {
            id = IceUtil::generateUUID();
        }
        else if (fluxioDC.profiles.find(profile.id) != fluxioDC.profiles.end())
        {
            ARMARX_INFO << "The id '" << profile.id
                        << "' is already taken. A new uuid will be generated.";
            id = IceUtil::generateUUID();
        }
        else
        {
            id = profile.id;
        }
 
        fluxioDC.profiles[id] = profile; // a copy is created when the profile is added to the map
        fluxioDC.profiles[id].id = id; // this copy can then be modified
        const auto& ret = fluxioDC.profiles[id];
 
        l.unlock();
 
        return {ret};
    }
 
    void
    SkillManagerComponentPlugin::updateProfile(const skills::FluxioProfile& profile)
    {
        auto oldProfile = getProfile(profile.id);
 
        if (oldProfile.isSuccess() && oldProfile.getResult().id == profile.id)
        {
            std::unique_lock l(fluxioDC.profilesMutex);
            fluxioDC.profiles[profile.id].name = profile.name;
            fluxioDC.profiles[profile.id].description = profile.description;
            fluxioDC.profiles[profile.id].parentPtr = profile.parentPtr;
            l.unlock();
        }
        else
        {
            //TODO: Do we throw the error here?
        }
    }
 
    skills::Result<std::experimental::observer_ptr<const skills::FluxioProvider>,
                   skills::error::FluxioException>
    SkillManagerComponentPlugin::addFluxioProvider(const std::string& name)
    {
        const std::string& providerId = boost::uuids::to_string(createUuidWithString(name));
 
        std::unique_lock l(fluxioDC.providersMutex);
        if (fluxioDC.providers.find(providerId) != fluxioDC.providers.end())
        {
            ARMARX_WARNING << "Provider with name '" << name << "' already exists.";
            l.unlock();
            return {std::experimental::make_observer(&fluxioDC.providers[providerId])};
        }
 
        skills::FluxioProvider p;
        p.id = providerId;
        p.name = name;
 
        fluxioDC.providers[p.id] = p;
        const auto& ret = std::experimental::make_observer(&fluxioDC.providers[p.id]);
        l.unlock();
 
        return {ret};
    }
 
    skills::Result<std::vector<std::experimental::observer_ptr<const skills::FluxioProvider>>,
                   skills::error::FluxioException>
    SkillManagerComponentPlugin::getProviderList()
    {
        for (const auto& [providerID, providerPrx] : skillProviderMap)
        {
            const auto& id = boost::uuids::to_string(createUuidWithString(providerID.providerName));
 
            std::shared_lock l(fluxioDC.providersMutex);
            const auto& providersEntry = fluxioDC.providers.find(id);
 
            if (providersEntry != fluxioDC.providers.end())
            {
                l.unlock();
                continue; // provider already exists
            }
 
            l.unlock();
            addFluxioProvider(providerID.providerName);
        }
 
        return {convertMapValuesToObserverVector(fluxioDC.providers)};
    }
 
    skills::Result<skills::FluxioProvider, skills::error::FluxioException>
    SkillManagerComponentPlugin::getProvider(const std::string& id)
    {
        getProviderList();
 
        std::shared_lock l(fluxioDC.providersMutex);
        const auto& providersEntry = fluxioDC.providers.find(id);
 
        if (providersEntry != fluxioDC.providers.end())
        {
            l.unlock();
            return {providersEntry->second};
        }
 
        l.unlock();
        return {skills::error::FluxioException::create(
            skills::error::createErrorMessage(skills::error::ErrorCode::ProfileNotFound, {id}),
            skills::error::FluxioExceptionType::NOT_FOUND,
            "SkillManagerComponentPlugin",
            __FUNCTION__,
            __LINE__)};
    }
 
    skills::Result<std::vector<std::experimental::observer_ptr<const skills::FluxioSkill>>,
                   skills::error::FluxioException>
    SkillManagerComponentPlugin::getSkillsOfProvider(const std::string& id)
    {
        getProviderList();
 
        std::shared_lock l(fluxioDC.providersMutex);
        const auto& providersEntry = fluxioDC.providers.find(id);
 
        if (providersEntry == fluxioDC.providers.end())
        {
            l.unlock();
            return {skills::error::FluxioException::create(
                skills::error::createErrorMessage(skills::error::ErrorCode::ProviderNotFound, {id}),
                skills::error::FluxioExceptionType::NOT_FOUND,
                "SkillManagerComponentPlugin",
                __FUNCTION__,
                __LINE__)};
        }
 
        l.unlock();
 
        auto res = getSkillList();
        if (!res.isSuccess())
        {
            auto e = res.getError();
            e.addToContext(std::nullopt, "SkillManagerComponentPlugin", __FUNCTION__, __LINE__);
            return {e};
        }
 
        auto allSkills = res.getResult();
 
        allSkills.erase(std::remove_if(allSkills.begin(),
                                       allSkills.end(),
                                       [id](const auto& skillPtr)
                                       { return skillPtr->skillProviderPtr->id != id; }),
                        allSkills.end());
 
        return {allSkills};
    }
 
    skills::Result<std::experimental::observer_ptr<const skills::FluxioSkill>,
                   skills::error::FluxioException>
    SkillManagerComponentPlugin::addSkillToProvider(const std::string& userId,
                                                    const std::string& providerId,
                                                    skills::FluxioSkill&& skill)
    {
        std::shared_lock l(fluxioDC.providersMutex);
        const auto& providerIt = fluxioDC.providers.find(providerId);
        if (providerIt == fluxioDC.providers.end())
        {
            ARMARX_WARNING << "Provider with id '" << providerId << "' not found.";
            l.unlock();
            return {skills::error::FluxioException::create(
                skills::error::createErrorMessage(skills::error::ErrorCode::ProviderNotFound,
                                                  {providerId}),
                skills::error::FluxioExceptionType::NOT_FOUND,
                "SkillManagerComponentPlugin",
                __FUNCTION__,
                __LINE__)};
        }
        l.unlock();
 
        if (skill.id.empty())
        {
            // its a new skill, its a new world, ...
            skill.id = IceUtil::generateUUID();
        }
        else
        {
            // TODO(me): check if a skill with the same id already exists
        }
 
        boost::uuids::uuid uuid;
        try
        {
            boost::uuids::string_generator gen;
            uuid = gen(skill.id);
        }
        catch (std::runtime_error& e)
        {
            ARMARX_WARNING << "Could not convert skill id to uuid: " << e.what();
            skill.id = IceUtil::generateUUID(); // fallback
        }
 
        std::unique_lock typesLock(fluxioDC.typesMutex);
        const auto& eventType = fluxioDC.types["BaseTypesNamespace"]->getMemberType("Event");
        typesLock.unlock();
        const skills::FluxioTypeIdentificator& eventTypeIdent = {.skillId = "BaseTypesNamespace",
                                                                 .parameterId = "Event"};
 
        // add default control flow parameters
        skills::FluxioParameter start;
        start.name = "Start";
        start.id = boost::uuids::to_string(createUuidWithString(start.name, uuid));
        start.description = "Start the skill";
        start.type = eventType;
        start.typeIdentificator = eventTypeIdent;
        start.required = true;
        start.isInput = true;
 
        skills::FluxioParameter succeeded;
        succeeded.name = "Succeeded";
        succeeded.id = boost::uuids::to_string(createUuidWithString(succeeded.name, uuid));
        succeeded.description = "Skill has been executed successfully";
        succeeded.type = eventType;
        succeeded.typeIdentificator = eventTypeIdent;
        succeeded.required = false;
        succeeded.isInput = false;
 
        skills::FluxioParameter failed;
        failed.name = "Failed";
        failed.id = boost::uuids::to_string(createUuidWithString(failed.name, uuid));
        failed.description = "Skill has failed";
        failed.type = eventType;
        failed.typeIdentificator = eventTypeIdent;
        failed.required = false;
        failed.isInput = false;
 
        skills::FluxioParameter aborted;
        aborted.name = "Aborted";
        aborted.id = boost::uuids::to_string(createUuidWithString(aborted.name, uuid));
        aborted.description = "Skill has been aborted";
        aborted.type = eventType;
        aborted.typeIdentificator = eventTypeIdent;
        aborted.required = false;
        aborted.isInput = false;
 
        skill.parameters[start.id] = start;
        skill.parameters[succeeded.id] = succeeded;
        skill.parameters[failed.id] = failed;
        skill.parameters[aborted.id] = aborted;
 
        skill.lastChanged = armarx::DateTime::Now().toDateTimeString();
 
        // store in data collector
        const auto skillId = skill.id;
        std::unique_lock skillsLock(fluxioDC.skillsMutex);
        fluxioDC.skills.emplace(skillId, std::move(skill));
        const auto& ret = std::experimental::make_observer(&(fluxioDC.skills[skillId]));
        skillsLock.unlock();
 
        // set mutex
        setEditFluxioSkillMutex(true, userId, skill.id);
        return {ret};
    }
 
    bool
    SkillManagerComponentPlugin::setEditFluxioSkillMutex(bool aquireMutex,
                                                         const std::string& userId,
                                                         const std::string& skillId)
    {
        std::scoped_lock l(fluxioDC.skillMutexMapMutex);
        const auto& skillMutexIt = fluxioDC.skillMutexMap.find(skillId);
 
        // aquire mutex
        if (aquireMutex)
        {
            if (skillMutexIt == fluxioDC.skillMutexMap.end())
            {
                // skill is free, set mutex
                fluxioDC.skillMutexMap[skillId] = std::make_tuple(userId, armarx::DateTime::Now());
                return true;
            }
 
            // skill is already locked
            if (std::get<0>(fluxioDC.skillMutexMap[skillId]) == userId)
            {
                // user already holds the mutex -> reset timestamp / prolong mutex
                std::get<1>(fluxioDC.skillMutexMap[skillId]) = armarx::DateTime::Now();
                return true;
            }
 
            // another user holds the mutex -> is it still valid ?
            armarx::Duration elapsedTime =
                armarx::DateTime::Now() - std::get<1>(fluxioDC.skillMutexMap[skillId]);
            if (elapsedTime.toMinutes() > fluxioDC.mutexTimeout)
            {
                // mutex invalid, requesting user gets the mutex instead
                fluxioDC.skillMutexMap[skillId] = std::make_tuple(userId, armarx::DateTime::Now());
                return true;
            }
 
            // mutex could not be aquired
            throw skills::error::FluxioException::create(
                skills::error::createErrorMessage(skills::error::ErrorCode::GenericMutexError,
                                                  {skillId}),
                skills::error::FluxioExceptionType::FORBIDDEN,
                "SkillManagerComponentPlugin",
                __FUNCTION__,
                __LINE__)
                .toManagerIce();
        }
 
        // remove mutex
        if (skillMutexIt == fluxioDC.skillMutexMap.end())
        {
            // skill is already free
            return true;
        }
 
 
        // check if the user holds the mutex, as only the user that holds the mutex
        // can release it
        if (std::get<0>(fluxioDC.skillMutexMap[skillId]) == userId)
        {
            fluxioDC.skillMutexMap.erase(skillId);
            return true;
        }
 
        // mutex could not be removed
        throw skills::error::FluxioException::create(
            skills::error::createErrorMessage(skills::error::ErrorCode::UserHasNoMutexError,
                                              {skillId}),
            skills::error::FluxioExceptionType::BAD_REQUEST,
            "SkillManagerComponentPlugin",
            __FUNCTION__,
            __LINE__)
            .toManagerIce();
    }
 
    aron::type::ObjectPtr
    SkillManagerComponentPlugin::getTypes()
    {
        auto ret = std::make_shared<aron::type::Object>();
        const skills::Result<
            std::vector<std::experimental::observer_ptr<const skills::FluxioSkill>>,
            skills::error::FluxioException>& res = getSkillList();
 
        if (!res.isSuccess())
        {
            ARMARX_WARNING << "Failed to get skill list.";
            return nullptr;
        }
 
        std::shared_lock l(fluxioDC.typesMutex);
        for (const auto& [skillId, skillTypes] : fluxioDC.types)
        {
            if (skillTypes == nullptr)
            {
                ARMARX_WARNING << "SkillTypes with id '" << skillId << "' not found.";
                continue;
            }
            ret->addMemberType(skillId, skillTypes);
        }
        l.unlock();
        ret->setObjectName("SkillTypes");
        return ret;
    }
 
} // namespace armarx::plugins