work in progress - this will crash still

source/RobotAPI/interface/skills/SkillManagerInterface.ice

@@ -223,10 +223,13 @@ module armarx
                     //** Fluxio related methods **//
                     //****************************//
 
+                    optional(3) string
+                    executeFluxioSkill(string skillId); // executes a fluxio skill
+
                     dto::FluxioSkillList
                     getSkillList(); // returns skills of all providers
                     
-                    optional(3) dto::FluxioSkill 
+                    optional(4) dto::FluxioSkill 
                     getSkill(string id); // returns a single skill
 
                     bool 
@@ -249,7 +252,7 @@ module armarx
                     dto::FluxioProfileList
                     getProfileList(); // returns all profiles
 
-                    optional(4) dto::FluxioProfile
+                    optional(5) dto::FluxioProfile
                     getProfile(string id); // returns a single profile
 
                     dto::FluxioProfile 
@@ -261,13 +264,13 @@ module armarx
                     dto::FluxioProviderList
                     getProviderList(); // returns all providers
 
-                    optional(5) dto::FluxioProvider
+                    optional(6) dto::FluxioProvider
                     getProvider(string id); // returns a single provider
 
-                    optional(6) dto::FluxioSkillList
+                    optional(7) dto::FluxioSkillList
                     getSkillsOfProvider(string id); // returns all skills of a provider
 
-                    optional(7) dto::FluxioSkill
+                    optional(8) dto::FluxioSkill
                     addSkillToProvider(string userId, string providerId, dto::FluxioSkill skill); // adds a new skill to a provider
                 };
             }

source/RobotAPI/libraries/skills/manager/CMakeLists.txt

@@ -18,9 +18,11 @@ armarx_add_library(
     SOURCES  
         SkillManagerComponentPlugin.cpp
         SkillManagerComponentPluginUser.cpp
+        FluxioExecutor.cpp
     HEADERS
         SkillManagerComponentPlugin.h
         SkillManagerComponentPluginUser.h
+        FluxioExecutor.h
 )
 
 add_library(RobotAPI::skills::manager ALIAS RobotAPISkillsManager)

source/RobotAPI/libraries/skills/manager/FluxioExecutor.cpp

+#include "FluxioExecutor.h"
+
+#include "RobotAPI/libraries/skills/core/ProviderID.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"
+
+namespace armarx::plugins
+{
+    void
+    FluxioNativeExecutor::setPlugin(armarx::plugins::SkillManagerComponentPlugin* plugin)
+    {
+        this->plugin = plugin;
+    }
+
+    void
+    FluxioNativeExecutor::run(std::string& executorName, armarx::aron::data::DictPtr& parameters)
+    {
+        skills::SkillID skillId = skills::SkillID{.providerId =
+                               skills::ProviderID{.providerName = this->skill->skillProviderPtr->id},
+                           .skillName = this->skill->id};
+
+        const auto& skillDescr = this->plugin->getSkillDescription(skillId);
+        if (!skillDescr.has_value())
+        {
+            // error
+            return;
+        }
+
+        skills::SkillExecutionRequest req;
+        req.skillId = skillId;
+        req.parameters = skillDescr->rootProfileDefaults;
+        req.executorName = executorName;
+
+        // FIXME: this may not work
+        *executionId = this->plugin->executeSkillAsync(req);
+    }
+
+    std::optional<skills::SkillStatusUpdate>
+    FluxioNativeExecutor::getStatusUpdate()
+    {
+        if (this->executionId == nullptr || this->plugin == nullptr)
+        {
+            // error
+            return std::nullopt;
+        }
+
+        return this->plugin->getSkillExecutionStatus(*this->executionId);
+    }
+} // namespace armarx::plugins

source/RobotAPI/libraries/skills/manager/FluxioExecutor.h

+#pragma once
+
+#include <string>
+
+#include "RobotAPI/libraries/skills/core/FluxioSkill.h"
+#include "RobotAPI/libraries/skills/core/SkillExecutionID.h"
+#include "RobotAPI/libraries/skills/core/SkillStatusUpdate.h"
+#include "SkillManagerComponentPlugin.h"
+
+namespace armarx::plugins
+{
+    class SkillManagerComponentPlugin; // forward declaration
+
+    class FluxioNativeExecutor
+    {
+    public:
+        std::string id;
+        std::string* executorName = nullptr;
+        skills::FluxioSkill* skill;
+        skills::SkillExecutionID* executionId = nullptr;
+        void run(std::string& executorName,
+                         armarx::aron::data::DictPtr& parameters);
+        std::optional<skills::SkillStatusUpdate> getStatusUpdate();
+
+        void setPlugin(armarx::plugins::SkillManagerComponentPlugin* plugin);
+
+        // TODO: abort etc.
+
+    private:
+        armarx::plugins::SkillManagerComponentPlugin* plugin = nullptr;
+    };
+} // namespace armarx::skills

source/RobotAPI/libraries/skills/manager/SkillManagerComponentPlugin.cpp

@@ -13,6 +13,7 @@
 #include <ArmarXCore/core/time/Duration.h>
 #include <ArmarXCore/core/time/ice_conversions.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/FluxioSkill.h"
@@ -548,6 +549,8 @@ namespace armarx::plugins
                 // convert to manager view
                 auto statusUpdate = skills::SkillStatusUpdate::FromIce(
                     provider_statusUpdate_ice.value(), providerId);
+
+                ARMARX_WARNING << "Status update: " << statusUpdate.result;
                 return statusUpdate;
             }
             catch (...)
@@ -616,6 +619,31 @@ namespace armarx::plugins
     //** Fluxio related methods **//
     //****************************//
 
+    std::optional<std::string>
+    SkillManagerComponentPlugin::executeFluxioSkill(std::string skillId)
+    {
+        const auto& skill = getSkill(skillId);
+        if (!skill.has_value() || !skill.value().native)
+        {
+            ARMARX_WARNING << "Skill with id '" << skillId << "' not found or is not native.";
+            return std::nullopt;
+        }
+
+        std::string executionId = IceUtil::generateUUID();
+        FluxioNativeExecutor executor;
+        executor.setPlugin(this);
+        executor.skill = &fluxioDC.skills[skillId];
+        executor.id = executionId;
+
+        std::string executorName = "Fluxio";
+        armarx::aron::data::DictPtr parameters = {};
+
+        fluxioDC.fluxioExecutors[executionId] = executor;
+        fluxioDC.fluxioExecutors[executionId].run(executorName, parameters);
+
+        return executionId;
+    }
+
     /**
     * @brief converts parametersType or resultType from skilldescription to fluxio parameters
     * @param ret the map to insert the fluxio parameters into
@@ -685,6 +713,45 @@ namespace armarx::plugins
             }
 
             s.parameters = {};
+
+            // add default control flow parameters
+            skills::FluxioParameter start;
+            start.id = IceUtil::generateUUID();
+            start.name = "Start";
+            start.description = "Start the skill";
+            start.type = "Event";
+            start.required = true;
+            start.isInput = true;
+
+            skills::FluxioParameter success;
+            success.id = IceUtil::generateUUID();
+            success.name = "Success";
+            success.description = "Skill has been executed successfully";
+            success.type = "Event";
+            success.required = false;
+            success.isInput = false;
+
+            skills::FluxioParameter failure;
+            failure.id = IceUtil::generateUUID();
+            failure.name = "Failure";
+            failure.description = "Skill has failed";
+            failure.type = "Event";
+            failure.required = false;
+            failure.isInput = false;
+
+            skills::FluxioParameter aborted;
+            aborted.id = IceUtil::generateUUID();
+            aborted.name = "Aborted";
+            aborted.description = "Skill has been aborted";
+            aborted.type = "Event";
+            aborted.required = false;
+            aborted.isInput = false;
+
+            s.parameters[start.id] = start;
+            s.parameters[success.id] = success;
+            s.parameters[failure.id] = failure;
+            s.parameters[aborted.id] = aborted;
+
             if (skillDescription.parametersType != nullptr)
             {
                 // input parameters

source/RobotAPI/libraries/skills/manager/SkillManagerComponentPlugin.h

@@ -20,6 +20,7 @@
 #include <RobotAPI/libraries/skills/core/SkillExecutionRequest.h>
 #include <RobotAPI/libraries/skills/core/SkillStatusUpdate.h>
 
+#include "FluxioExecutor.h"
 #include "SkillManagerComponentPluginUser.h"
 
 namespace armarx
@@ -29,6 +30,8 @@ namespace armarx
 
 namespace armarx::plugins
 {
+    class FluxioNativeExecutor; // forward declaration
+
     class SkillManagerComponentPlugin : public ComponentPlugin
     {
     public:
@@ -70,6 +73,8 @@ namespace armarx::plugins
         //** Fluxio related methods **//
         //****************************//
 
+        std::optional<std::string> executeFluxioSkill(std::string skillId);
+
         std::vector<skills::FluxioSkill> getSkillList();
 
         std::optional<skills::FluxioSkill> getSkill(const std::string& id);
@@ -110,6 +115,7 @@ namespace armarx::plugins
             std::map<std::string, skills::FluxioProvider> providers = {};
             std::map<std::string, std::tuple<std::string, armarx::DateTime>> skillMutexMap = {};
             const std::int64_t mutexTimeout = 30; // minutes
+            std::map<std::string, FluxioNativeExecutor> fluxioExecutors = {};
         };
 
         FluxioDataCollector fluxioDC = {};

source/RobotAPI/libraries/skills/manager/SkillManagerComponentPluginUser.cpp

@@ -156,6 +156,17 @@ namespace armarx
     //** Fluxio related methods **//
     //****************************//
 
+    IceUtil::Optional<std::string> SkillManagerComponentPluginUser::executeFluxioSkill(const std::string& skillId, const Ice::Current& current)
+    {
+        auto res = this->plugin->executeFluxioSkill(skillId);
+        if( res.has_value() )
+        {
+            return *res;
+        }
+
+        return {};
+    }
+
     skills::manager::dto::FluxioSkillList
     SkillManagerComponentPluginUser::getSkillList(const Ice::Current& current)
     {

source/RobotAPI/libraries/skills/manager/SkillManagerComponentPluginUser.h

@@ -68,6 +68,9 @@ namespace armarx
         //** Fluxio related methods **//
         //****************************//
 
+        IceUtil::Optional<std::string> executeFluxioSkill(const std::string& skillId,
+                                       const Ice::Current& current) override;
+
         skills::manager::dto::FluxioSkillList getSkillList(const Ice::Current& current) override;
 
         IceUtil::Optional<skills::manager::dto::FluxioSkill>