process_launcher.h

Go to the documentation of this file.

/* * NRP Core - Backend infrastructure to synchronize simulations
 *
 * Copyright 2020-2023 NRP Team
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * This project has received funding from the European Union’s Horizon 2020
 * Framework Programme for Research and Innovation under the Specific Grant
 * Agreement No. 945539 (Human Brain Project SGA3).
 */
 
#ifndef PROCESS_LAUNCHER_H
#define PROCESS_LAUNCHER_H
 
#include "nrp_general_library/process_launchers/launch_commands/launch_command.h"
#include "nrp_general_library/utils/fixed_string.h"
#include "nrp_general_library/utils/ptr_templates.h"
 
#include "nrp_general_library/utils/json_schema_utils.h"
 
class ProcessLauncherInterface
        : public PtrTemplates<ProcessLauncherInterface>
{
    public:
        // Process status options
        using ENGINE_RUNNING_STATUS = LaunchCommandInterface::ENGINE_RUNNING_STATUS;
        static constexpr auto UNKNOWN = LaunchCommandInterface::ENGINE_RUNNING_STATUS::UNKNOWN;
        static constexpr auto RUNNING = LaunchCommandInterface::ENGINE_RUNNING_STATUS::RUNNING;
        static constexpr auto STOPPED = LaunchCommandInterface::ENGINE_RUNNING_STATUS::STOPPED;
 
        virtual ~ProcessLauncherInterface() = default;
 
        virtual std::string launcherName() const = 0;
 
        virtual ProcessLauncherInterface::unique_ptr createLauncher(int logFD = -1) = 0;
 
        virtual pid_t launchProcess(nlohmann::json procConfig, bool appendParentEnv = true) = 0;
 
        virtual pid_t stopProcess(unsigned int killWait) = 0;
 
        virtual ENGINE_RUNNING_STATUS getProcessStatus()
        {   return this->_launchCmd ? this->_launchCmd->getProcessStatus() : ENGINE_RUNNING_STATUS::UNKNOWN;    }
 
        LaunchCommandInterface *launchCommand() const;
 
        void setFileDescriptor(int logFD);
 
    protected:
        static bool checkEnvVar(const std::string &envVar);
 
        static std::tuple<std::string,std::string> splitEnvVar(const std::string &envVar);
 
        LaunchCommandInterface::unique_ptr _launchCmd = nullptr;
 
         int _logFD = -1;
};
 
 
template<class PROCESS_LAUNCHER,const char *LAUNCHER_TYPE, class ...LAUNCHER_COMMANDS>
class ProcessLauncher
        : public ProcessLauncherInterface
{
    public:
        static constexpr auto LauncherType = LAUNCHER_TYPE;
 
        ProcessLauncher() {
            static_assert((std::is_base_of_v<LaunchCommandInterface, LAUNCHER_COMMANDS> && ...) ,"Parameter LAUNCHER_COMMANDS must derive from LaunchCommandInterface");
            static_assert((std::is_convertible_v<const volatile LAUNCHER_COMMANDS*, const volatile LaunchCommandInterface*> && ...),"Parameter LAUNCHER_COMMANDS must be convertible to LaunchCommandInterface");
        }
 
        ~ProcessLauncher() override = default;
 
        ProcessLauncherInterface::unique_ptr createLauncher(int logFD = -1) override
        {
            ProcessLauncherInterface::unique_ptr launcher(new PROCESS_LAUNCHER());
            launcher->setFileDescriptor(logFD);
            return launcher;
        }
 
        std::string launcherName() const override final
        {   return std::string(LauncherType);   }
 
        pid_t launchProcess(nlohmann::json procConfig, bool appendParentEnv = true) override final
        {
            json_utils::validateJson(procConfig, "json://nrp-core/process_launcher.json#ProcessLauncher");
 
            nlohmann::json launcherConfig = procConfig.at("LaunchCommand");
 
            if constexpr (sizeof...(LAUNCHER_COMMANDS) == 0)
            {   throw noLauncherFound(launcherConfig.at("LaunchType"));  }
 
            this->_launchCmd = ProcessLauncher::findLauncher<LAUNCHER_COMMANDS...>(launcherConfig.at("LaunchType"));
            return this->_launchCmd->launchProcess(launcherConfig, procConfig.at("ProcCmd"),
                                                   procConfig.contains("ProcEnvParams") ? procConfig.at("ProcEnvParams").get<std::vector<std::string>>() : std::vector<std::string>(),
                                                   procConfig.contains("ProcStartParams") ? procConfig.at("ProcStartParams").get<std::vector<std::string>>() : std::vector<std::string>(),
                                                           appendParentEnv,
                                                           _logFD);
        }
 
        pid_t stopProcess(unsigned int killWait) override final
        {   return this->_launchCmd->stopProcess(killWait);   }
 
    private:
        template<class LAUNCH_CMD, class ...REST>
        inline LaunchCommandInterface::unique_ptr findLauncher(const std::string &launchCmd)
        {
            if(std::string(LAUNCH_CMD::LaunchType) == launchCmd)
                return LaunchCommandInterface::unique_ptr(new LAUNCH_CMD());
            else
            {
                if constexpr (sizeof...(REST) > 0)
                {   return findLauncher<REST...>(launchCmd);    }
                else
                {   throw noLauncherFound(launchCmd);   }
            }
        }
 
        static inline std::runtime_error noLauncherFound(const std::string &launchCmd)
        {   return std::runtime_error("Unable to find launcher with name \"" + launchCmd + "\"");   }
};
 
#endif // PROCESS_LAUNCHER_H