AbstractDeployer.hpp

/*
 * Copyright 2017 ONERA
 *
 * This file is part of the MAUVE Runtime project.
 *
 * MAUVE Runtime is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License version 3 as
 * published by the Free Software Foundation.
 *
 * MAUVE Runtime is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with MAUVE.  If not, see <https://www.gnu.org/licenses/lgpl-3.0>.
 */
#ifndef MAUVE_RUNTIME_ABSTRACT_DEPLOYER_HPP
#define MAUVE_RUNTIME_ABSTRACT_DEPLOYER_HPP

#include <signal.h>
#include <map>
#include <vector>
#include <string>

#include "common.hpp"

#define DEPLOYER_SIG SIGINT

namespace mauve {
  namespace runtime {

    class Architecture;
    class AbstractComponent;
    class AbstractDeployer;
    class Task;
    class DeployerLogger;

    template <typename A>
    class Manager;

    template <typename ARCHI>
    AbstractDeployer* mk_abstract_deployer(ARCHI * architecture, Manager<ARCHI> * manager = nullptr);

    class AbstractDeployer {
    public:
      static AbstractDeployer* instance() { return deployer; }
      virtual ~AbstractDeployer() noexcept;

      // ---------- Architecture ----------

      virtual Architecture* get_architecture() = 0;

      // ---------- Manager ----------

      virtual std::vector<std::string> manager_actions() const = 0;
      virtual bool manager_apply(std::string name) = 0;

      // ---------- Components & Tasks ----------

      Task* get_task(AbstractComponent * component);

      // ---------- Start/Stop ----------

      time_ns_t now() const;

      time_ns_t get_time() const;

      bool create_tasks();

      bool create_task(AbstractComponent * component);

      bool activate();

      bool activate(AbstractComponent * component);

      bool activate(std::string name);

      bool start();

      bool start(AbstractComponent * component, time_ns_t start_time);

      bool start(std::string name, time_ns_t start_time);

      bool start_deployer();
      void loop();

      void stop();

      bool stop(AbstractComponent * component);

      bool stop(std::string name);

      void clear_tasks();

      bool clear_task(AbstractComponent * component);

      inline DeployerLogger* logger() { return _logger; };

    protected:
      AbstractDeployer();
      static AbstractDeployer* deployer;
      DeployerLogger* _logger;

    private:
      template <typename ARCHI>
      friend AbstractDeployer* mk_abstract_deployer(ARCHI* a, Manager<ARCHI>* m);

      std::map<AbstractComponent*, Task*> tasks;
      time_ns_t start_time;
      sigset_t sig_set;

    };

    void mk_python_deployer();

  }
}

#endif // MAUVE_RUNTIME_ABSTRACT_DEPLOYER_HPP