RandomChaining.cpp

Go to the documentation of this file.

 
#include "RandomChaining.h"
 
#include <chrono>
#include <cstdlib>
#include <thread>
 
#include "RobotAPI/libraries/skills/core/SkillExecutionHandle.h"
 
namespace armarx::skills::provider
{
    namespace util
    {
        int
        randomgen(int max, int min) //Pass in range
        {
            srand(time(NULL)); //Changed from rand(). srand() seeds rand for you.
            int random = rand() % max + min;
            return random;
        }
    } // namespace util
 
    RandomChainingSkill::RandomChainingSkill() : SimpleSkill(GetSkillDescription())
    {
    }
 
    SkillDescription
    RandomChainingSkill::GetSkillDescription()
    {
        return SkillDescription{.skillId = armarx::skills::SkillID{.skillName = "RandomChaining"},
                                .description = "This skill calls 100 random subskills from the "
                                               "skillProviderExample excluding the segfault skill.",
                                .rootProfileDefaults = armarx::aron::make_dict(),
                                .timeout = armarx::core::time::Duration::MilliSeconds(120000)};
    }
 
    Skill::MainResult
    RandomChainingSkill::main(const MainInput& in)
    {
        std::vector<std::string> subskillNames = {"Timeout",
                                                  "Chaining",
                                                  "Foo",
                                                  "HelloWorld",
                                                  "Incomplete",
                                                  "ShowMeCallbacks",
                                                  "BusyWaiting",
                                                  "Recursive"};
 
        ARMARX_CHECK(subskillNames.size() > 0);
 
        {
            std::vector<skills::SkillExecutionHandlePtr> handles;
 
            for (unsigned int i = 0; i < 100; ++i)
            {
                this->throwIfSkillShouldTerminate();
 
                auto index = util::randomgen(subskillNames.size() - 1, 0);
 
                auto subskillName = subskillNames[index];
 
 
                skills::SkillID skillId{.providerId = *getSkillId().providerId,
                                        .skillName = subskillName};
 
                if (util::randomgen(10, 0) < 2)
                {
                    callSubskill(skillId);
                }
                else
                {
                    auto handle = callSubskillAsync(skillId);
 
                    auto sleep_milliseconds = util::randomgen(1000, 0);
 
                    ARMARX_INFO << "SLEEP FOR " << sleep_milliseconds << "ms";
                    std::this_thread::sleep_for(std::chrono::milliseconds(sleep_milliseconds));
 
                    // avoid call of d'tors before skill is done
                    handles.emplace_back(std::move(handle));
                }
            }
            ARMARX_CHECK(::armarx::skills::util::joinAll(handles));
        }
 
        return {TerminatedSkillStatus::Succeeded, nullptr};
    }
} // namespace armarx::skills::provider