stack.hpp

Go to the documentation of this file.

/*
 * Copyright 2020 Robert Bosch GmbH
 *
 * 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.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#pragma once
 
#include <filesystem>  // for filesystem::path
#include <map>         // for map<>
#include <memory>      // for shared_ptr<>
#include <optional>    // for optional<>
#include <set>         // for set<>
#include <string>      // for string
#include <utility>     // for move
#include <vector>      // for vector<>
 
#include <fable/schema/custom.hpp>          // for CustomDeserializer
#include <fable/schema/factory.hpp>         // for Factory
 
#include <cloe/component.hpp>        // for ComponentFactory
#include <cloe/controller.hpp>       // for ControllerFactory
#include <cloe/core.hpp>             // for Conf, Confable, Json
#include <cloe/simulator.hpp>        // for SimulatorFactory
#include <cloe/trigger.hpp>          // for Source
#include <cloe/utility/command.hpp>  // for Command
 
#include "config.hpp"
#include "plugin.hpp"  // for Plugin
 
namespace cloe {
 
class PersistentConfable : public Confable {
 public:
  const Conf& conf() const { return conf_; }
 
  void from_conf(const Conf& c) override {
    Confable::from_conf(c);
    conf_ = c;
  }
 
 protected:
  Conf conf_;
};
 
inline auto id_prototype(std::string desc = "") {
  return schema::make_prototype<std::string>(std::move(desc)).c_identifier();
}
 
inline auto id_path_prototype(std::string desc = "") {
  return schema::make_prototype<std::string>(std::move(desc))
      .pattern("^([a-zA-Z_][a-zA-Z0-9_]*/?)+$");
}
 
// --------------------------------------------------------------------------------------------- //
 
using IncludeConf = std::filesystem::path;
using IncludeSchema = decltype(schema::make_schema(static_cast<IncludeConf*>(nullptr), ""));
using IncludesSchema = schema::Vector<IncludeConf, IncludeSchema>;
 
// --------------------------------------------------------------------------------------------- //
 
struct LoggingConf : public Confable {
  std::string name;
  std::optional<std::string> pattern;
  std::optional<LogLevel> level;
 
 public:  // Special
  void apply() const;
 
 public:  // Confable Overrides
  CONFABLE_SCHEMA(LoggingConf) {
    using namespace schema;  // NOLINT(build/namespaces)
    return Schema{
        {"name", make_schema(&name, "name of the logger to configure").require()},
        {"pattern", make_schema(&pattern, "pattern of the logger")},
        {"level", make_schema(&level, "level of the logger")},
    };
  }
 
  bool validate(const Conf& c, std::optional<SchemaError>& err) const override {
    const auto& s = this->schema();
    if (!s.validate(c, err)) {
      return false;
    }
    if (!c.has("pattern") && !c.has("level")) {
      err.emplace(SchemaError(c, s.json_schema(),
                              "require at least one of 'pattern' or 'level' properties"));
      return false;
    }
    return true;
  }
};
 
// --------------------------------------------------------------------------------------------- //
 
struct ServerConf : public Confable {
  bool listen{true};
  std::string listen_address{"127.0.0.1"};
  uint16_t listen_port{8080};
  uint16_t listen_threads{10};
  std::string api_prefix{"/api"};
  std::string static_prefix{""};
 
 public:  // Confable Overrides
  CONFABLE_SCHEMA(ServerConf) {
    using namespace schema;  // NOLINT(build/namespaces)
    return Schema{
        {"listen", make_schema(&listen, "whether web server is enabled")},
        {"listen_address", make_schema(&listen_address, "address web server should listen at")},
        {"listen_port", make_schema(&listen_port, "port web server should listen at")},
        {"listen_threads", make_schema(&listen_threads, "threads web server should use")},
        {"static_prefix", make_schema(&static_prefix, "endpoint prefix for static resources")},
        {"api_prefix", make_schema(&api_prefix, "endpoint prefix for API resources")},
    };
  }
};
 
// --------------------------------------------------------------------------------------------- //
 
struct PluginConf : public PersistentConfable {
  std::filesystem::path plugin_path{};
 
  std::optional<std::string> plugin_name{};
 
  std::optional<std::string> plugin_prefix{};
 
  std::optional<bool> ignore_missing{};
 
  std::optional<bool> ignore_failure{};
 
  std::optional<bool> allow_clobber{};
 
 public:  // Constructors
  PluginConf() = default;
  explicit PluginConf(const std::string& p) : plugin_path(p) {}
 
 public:  // Special
  std::string canonical() const;
 
 public:  // Confable Overrides
  CONFABLE_SCHEMA(PluginConf) {
    // clang-format off
    using namespace schema;  // NOLINT(build/namespaces)
    auto proto = String(nullptr, "").c_identifier();
    return Struct{
        {"path", make_schema(&plugin_path, "absolute or relative path to plugin").require().not_empty().normalize(true)},
        {"name", make_schema(&plugin_name, proto, "alternative name plugin is available by")},
        {"prefix", make_schema(&plugin_prefix, proto, "prefix the plugin name with this")},
        {"ignore_missing", make_schema(&ignore_missing, "ignore not-exist errors")},
        {"ignore_failure", make_schema(&ignore_failure, "ignore plugin loading errors")},
        {"allow_clobber", make_schema(&allow_clobber, "replace same-named plugins")},
    };
    // clang-format on
  }
};
 
using PluginsSchema = schema_type<std::vector<PluginConf>>::type;
 
// --------------------------------------------------------------------------------------------- //
 
enum class WatchdogMode {
  Off,    
  Log,    
  Abort,  
  Kill,   
};
 
// clang-format off
ENUM_SERIALIZATION(WatchdogMode, ({
  {WatchdogMode::Off, "off"},
  {WatchdogMode::Log, "log"},
  {WatchdogMode::Abort, "abort"},
  {WatchdogMode::Kill, "kill"},
}))
// clang-format on
 
struct EngineConf : public Confable {
  // Parsing:
  std::vector<std::string> ignore_sections{};
 
  // Security:
  bool security_enable_hooks{true};
  bool security_enable_commands{false};
  bool security_enable_includes{true};
  size_t security_max_include_depth{64};
 
  // Plugins:
  std::vector<std::string> plugin_path{};
  bool plugins_ignore_missing{false};
  bool plugins_ignore_failure{false};
  bool plugins_allow_clobber{true};
 
  // Hooks:
  std::vector<Command> hooks_pre_connect{};
  std::vector<Command> hooks_post_disconnect{};
 
  // Triggers:
  bool triggers_ignore_source{false};
 
  // Output:
  std::optional<std::filesystem::path> registry_path{CLOE_DATA_HOME "/registry"};
  std::optional<std::filesystem::path> output_path{"${CLOE_SIMULATION_UUID}"};
  std::optional<std::filesystem::path> output_file_config{"config.json"};
  std::optional<std::filesystem::path> output_file_result{"result.json"};
  std::optional<std::filesystem::path> output_file_triggers{"triggers.json"};
  std::optional<std::filesystem::path> output_file_signals{"signals.json"};
  std::optional<std::filesystem::path> output_file_signals_autocompletion;
  std::optional<std::filesystem::path> output_file_data_stream;
  bool output_clobber_files{true};
 
  std::chrono::milliseconds polling_interval{100};
 
  WatchdogMode watchdog_mode{WatchdogMode::Off};
 
  std::chrono::milliseconds watchdog_default_timeout{90'000};
 
  std::map<std::string, std::optional<std::chrono::milliseconds>> watchdog_state_timeouts{
      {"CONNECT", std::chrono::milliseconds{300'000}},
      {"ABORT", std::chrono::milliseconds{90'000}},
      {"STOP", std::chrono::milliseconds{300'000}},
      {"DISCONNECT", std::chrono::milliseconds{600'000}},
  };
 
  bool keep_alive{false};
 
 public:  // Confable Overrides
  CONFABLE_SCHEMA(EngineConf) {
    // clang-format off
    using namespace schema;  // NOLINT(build/namespaces)
    auto dir_proto = []() { return make_prototype<std::filesystem::path>().not_file(); };
    auto file_proto = []() { return make_prototype<std::filesystem::path>().not_dir().resolve(false); };
    return Struct{
        {"ignore", make_schema(&ignore_sections, "JSON pointers to sections that should be ignored").extend(true)},
        {"security", Struct{
           {"enable_hooks_section",      make_schema(&security_enable_hooks, "whether to enable engine hooks")},
           {"enable_command_action",   make_schema(&security_enable_commands, "whether to enable the command action")},
           {"enable_include_section",   make_schema(&security_enable_includes, "whether to allow config files to include other files")},
           {"max_include_depth", make_schema(&security_max_include_depth, "how many recursive includes are allowed")},
        }},
        {"hooks", Struct{
           {"pre_connect", make_schema(&hooks_pre_connect, "pre-connect hooks to execute").extend(true)},
           {"post_disconnect", make_schema(&hooks_post_disconnect, "post-disconnect hooks to execute").extend(true)},
        }},
        {"plugin_path", make_schema(&plugin_path, "list of directories to scan for plugins").extend(false)},
        {"plugins", Struct{
           {"ignore_missing", make_schema(&plugins_ignore_missing, "ignore not-exist errors")},
           {"ignore_failure", make_schema(&plugins_ignore_failure, "ignore plugin loading errors")},
           {"allow_clobber", make_schema(&plugins_allow_clobber, "replace same-named plugins")},
        }},
        {"registry_path", make_schema(&registry_path, dir_proto(), "cloe registry directory")},
        {"output", Struct{
           {"path", make_schema(&output_path, dir_proto().resolve(false), "directory to dump output files in, relative to registry path")},
           {"clobber", make_schema(&output_clobber_files, "whether to clobber existing files or not")},
           {"files", Struct{
              {"config", make_schema(&output_file_config, file_proto(), "file to store config in")},
              {"result", make_schema(&output_file_result, file_proto(), "file to store simulation result in")},
              {"triggers", make_schema(&output_file_triggers, file_proto(), "file to store triggers in")},
              {"signals", make_schema(&output_file_signals, file_proto(), "file to store signals in")},
              {"signals_autocompletion", make_schema(&output_file_signals_autocompletion, file_proto(), "file to store signal autocompletion in")},
              {"api_recording", make_schema(&output_file_data_stream, file_proto(), "file to store api data stream")},
           }},
        }},
        {"triggers", Struct{
           {"ignore_source", make_schema(&triggers_ignore_source, "ignore trigger source when reading in triggers")},
        }},
        {"polling_interval", make_schema(&polling_interval, "milliseconds to sleep when polling for next state")},
        {"watchdog", Struct{
           {"mode", make_schema(&watchdog_mode, "modus operandi of watchdog [one of: off, log, abort, kill]")},
           {"default_timeout", make_schema(&watchdog_default_timeout, "default timeout if not overridden, 0 for no timeout")},
           {"state_timeouts", make_schema(&watchdog_state_timeouts, "timeout specific to a given state, 0 for no timeout").unique_properties(false)},
        }},
        {"keep_alive", make_schema(&keep_alive, "keep simulation alive after termination")},
    };
    // clang-format on
  }
};
 
using EngineSchema = schema_type<EngineConf>::type;
 
// --------------------------------------------------------------------------------------------- //
 
struct DefaultConf : public Confable {
  std::optional<std::string> name;
  std::optional<std::string> binding;
  Conf args;
 
 public:  // Confable Overrides
  CONFABLE_SCHEMA(DefaultConf) {
    using namespace schema;  // NOLINT(build/namespaces)
    return Struct{
        {"binding", make_schema(&binding, "name of binding")},
        {"name", make_schema(&name, id_prototype(), "globally unique identifier for component")},
        {"args", make_schema(&args, "defaults to set for binding/name combination").require()},
    };
  }
};
 
// --------------------------------------------------------------------------------------------- //
 
template <typename C, typename F>
class FactoryPlugin : public fable::schema::FactoryPointerless<C> {
 public:
  FactoryPlugin() {
    this->set_factory_key("binding");
    this->set_args_subset(false);
  }
  virtual ~FactoryPlugin() = default;
 
  void add_plugin(const std::string& name, std::shared_ptr<Plugin> p) {
    this->set_factory(name, p->make<F>()->schema(), [p, name](const Conf& c) {
      C tmp{name, p->make<F>()};
      tmp.from_conf(c);
      return tmp;
    });
  }
};
 
// --------------------------------------------------------------------------------------------- //
 
struct SimulatorConf : public Confable {
  const std::string binding;
  std::optional<std::string> name;
  std::shared_ptr<SimulatorFactory> factory;
  Conf args;
 
 public:  // Constructors
  SimulatorConf(const std::string& b, std::shared_ptr<SimulatorFactory> f)
      : binding(b), factory(std::move(f)) {}
 
 public:  // Confable Overrides
  CONFABLE_SCHEMA(SimulatorConf) {
    using namespace schema;  // NOLINT(build/namespaces)
    return Struct{
        {"binding", make_const_schema(binding, "name of simulator binding").require()},
        {"name", make_schema(&name, id_prototype(), "identifier override for binding")},
        {"args", make_schema(&args, factory->schema(), "factory-specific arguments")},
    };
  }
};
 
class SimulatorSchema : public FactoryPlugin<SimulatorConf, SimulatorFactory> {
 public:
  SimulatorSchema();
  virtual ~SimulatorSchema() = default;
};
 
// --------------------------------------------------------------------------------------------- //
 
struct ControllerConf : public Confable {
  const std::string binding;
  std::optional<std::string> name;
  std::string vehicle;
  std::shared_ptr<ControllerFactory> factory;
  Conf args;
 
 public:  // Constructors
  ControllerConf(const std::string& b, std::shared_ptr<ControllerFactory> f)
      : binding(b), factory(std::move(f)) {}
 
 public:  // Confable Overrides
  CONFABLE_SCHEMA(ControllerConf) {
    // clang-format off
    using namespace schema;  // NOLINT(build/namespaces)
    return Struct{
        {"binding", make_const_schema(binding, "name of controller binding").require()},
        {"name", make_schema(&name, id_prototype(), "identifier override for binding")},
        {"vehicle", make_schema(&vehicle, "vehicle controller is assigned to").c_identifier().require()},
        {"args", make_schema(&args, factory->schema(), "factory-specific arguments")},
    };
    // clang-format on
  }
};
 
class ControllerSchema : public FactoryPlugin<ControllerConf, ControllerFactory> {
 public:
  ControllerSchema();
  virtual ~ControllerSchema() = default;
};
 
// --------------------------------------------------------------------------------------------- //
 
struct FromSimulator : public Confable {
  std::string simulator;
  std::string index_str;
  size_t index_num;
 
 public:  // Special
  bool is_by_name() const { return !index_str.empty(); }
  bool is_by_index() const { return index_str.empty(); }
  void clear() {
    simulator.clear();
    index_str.clear();
    index_num = 0;
  }
 
 public:  // Confable Overrides
  CONFABLE_SCHEMA(FromSimulator) {
    // clang-format off
      using namespace schema;  // NOLINT(build/namespaces)
      return Variant{
          Struct{
              {"simulator", make_schema(&simulator, "simulator").not_empty().require()},
              {"index", make_schema(&index_num, "index of vehicle in simulator").require()},
          },
          Struct{
              {"simulator", make_schema(&simulator, "simulator").not_empty().require()},
              {"name", make_schema(&index_str, "name of vehicle in simulator").not_empty().require()},
          },
      };
    // clang-format on
  }
 
  void from_conf(const Conf& c) override {
    clear();  // Avoid inconsistent state
    Confable::from_conf(c);
  }
 
  void to_json(Json& j) const override {
    if (is_by_index()) {
      j = Json{
          {"simulator", simulator},
          {"index", index_num},
      };
    } else {
      j = Json{
          {"simulator", simulator},
          {"name", index_str},
      };
    }
  }
};
 
struct ComponentConf : public Confable {
  const std::string binding;
  std::optional<std::string> name;
  std::vector<std::string> from;
  std::shared_ptr<ComponentFactory> factory;
  Conf args;
 
 public:  // Constructors
  ComponentConf(const std::string& b, std::shared_ptr<ComponentFactory> f)
      : binding(b), factory(std::move(f)) {}
 
 public:  // Confable Overrides
  CONFABLE_SCHEMA(ComponentConf) {
    // clang-format off
    using namespace schema;  // NOLINT(build/namespaces)
    return Struct{
        {"binding", make_const_schema(binding, "name of binding").require()},
        {"name", make_schema(&name, id_prototype(), "globally unique identifier for component")},
        {"from", Variant{
             make_schema(&from, "component inputs for binding"),
             CustomDeserializer(
                 make_prototype<std::string>("component input for binding"),
                 [this](CustomDeserializer*, const Conf& c) {
                   this->from.push_back(c.get<std::string>());
                 }
             ),
        }},
        {"args", make_schema(&args, factory->schema(), "factory-specific args")},
    };
    // clang-format on
  }
};
 
class ComponentSchema : public FactoryPlugin<ComponentConf, ComponentFactory> {
 public:
  ComponentSchema();
  virtual ~ComponentSchema() = default;
};
 
// TODO(ben): Add AliasConf as alternative to ComponentConf.
 
struct VehicleConf : public Confable {
  std::string name;
  FromSimulator from_sim;
  std::string from_veh;
  std::map<std::string, ComponentConf> components;
 
 private:  // Schemas
  ComponentSchema component_schema;
 
 public:  // Constructors
  explicit VehicleConf(const ComponentSchema& s) : component_schema(s) {}
 
 public:  // Special
  bool is_from_simulator() const { return from_veh.empty(); }
  bool is_from_vehicle() const { return !from_veh.empty(); }
  void clear() {
    name.clear();
    from_sim.clear();
    from_veh.clear();
  }
 
 public:  // Confable Overrides
  CONFABLE_SCHEMA(VehicleConf) {
    // clang-format off
    using namespace schema;  // NOLINT(build/namespaces)
    return Struct{
        {"name", make_schema(&name, "globally unique identifier for vehicle").c_identifier().require()},
        {"from", Variant{
             make_schema(&from_sim, "simulator source"),
             make_schema(&from_veh, "vehicle source").c_identifier(),
        }.require()},
        {"components", make_schema(&components, component_schema, "component configuration of vehicle")},
    };
    // clang-format on
  }
 
  void from_conf(const Conf& c) override {
    clear();  // Avoid inconsistent state
    Confable::from_conf(c);
  }
 
  void to_json(Json& j) const override {
    Json from = is_from_simulator() ? Json(from_sim) : Json(from_veh);
    j = Json{
        {"name", name},
        {"from", from},
        {"components", components},
    };
  }
};
 
class VehicleSchema : public fable::schema::Base<VehicleSchema> {
 public:  // Constructors
  using Type = VehicleConf;
  using MakeFunc = ComponentSchema::MakeFunc;
  using TypeFactory = ComponentSchema::TypeFactory;
 
  explicit VehicleSchema(std::string desc = "") : Base(std::move(desc)) {}
 
 public:  // Special
  bool has_factory(const std::string& name) const { return components_.has_factory(name); }
  void add_plugin(const std::string& name, std::shared_ptr<Plugin> p) {
    components_.add_plugin(name, p);
  }
 
 public:  // Overrides
  Json json_schema() const override {
    VehicleConf v{components_};
    return v.schema().json_schema();
  }
 
  bool validate(const Conf& c, std::optional<SchemaError>& err) const override {
    VehicleConf v{components_};
    return v.schema().validate(c, err);
  }
 
  Json serialize(const Type& x) const { return x.to_json(); }
 
  Type make(const Conf& c) const { return deserialize(c); }
 
  Type deserialize(const Conf& c) const {
    VehicleConf v{components_};
    v.from_conf(c);
    return v;
  }
 
  void from_conf(const Conf&) override {
    throw std::logic_error("VehicleSchema does not implement from_conf");
  }
 
  void to_json(Json&) const override {
    throw std::logic_error("VehicleSchema does not implement to_json");
  }
 
  void reset_ptr() override {}
 
 private:  // State
  ComponentSchema components_;
};
 
// --------------------------------------------------------------------------------------------- //
 
struct TriggerConf : public PersistentConfable {
  std::optional<std::string> label{};
  Source source{Source::FILESYSTEM};
  Conf action{};
  Conf event{};
  bool conceal{false};
  bool sticky{false};
  bool optional{false};
 
 public:  // Confable Overrides
  CONFABLE_SCHEMA(TriggerConf) {
    // clang-format off
    using namespace schema;  // NOLINT(build/namespaces)
    auto EANDA_SCHEMA = Variant{
      String{nullptr, "inline format"}.pattern("^[a-zA-Z0-9_/]+(=.*)?$"),
      Struct{
        {"name", id_path_prototype().require()}
      }.additional_properties(true),
    };
    return Struct{
        {"label", make_schema(&label, "description of trigger")},
        {"source", make_schema(&source, "source from which trigger originates")},
        {"event", make_schema(&event, EANDA_SCHEMA, "event").require()},
        {"action", make_schema(&action, EANDA_SCHEMA, "action").require()},
        {"sticky", make_schema(&sticky, "whether trigger should be sticky")},
        {"conceal", make_schema(&conceal, "whether trigger should be concealed in history")},
        {"optional", make_schema(&optional, "whether errors creating event or action should be ignored")},
        {"at", Ignore("time at which trigger was executed", JsonType::string)},
        {"since", Ignore("time since which trigger was in queue", JsonType::string)},
    };
    // clang-format on
  }
};
 
// --------------------------------------------------------------------------------------------- //
 
struct SimulationConf : public Confable {
  std::optional<std::string> name{};
 
  Duration model_step_width = Duration{20'000'000};  // 20 ms
 
  int64_t controller_retry_limit{1000};
 
  std::chrono::milliseconds controller_retry_sleep{1};
 
  bool abort_on_controller_failure{true};
 
 public:  // Confable Overrides
  CONFABLE_SCHEMA(SimulationConf) {
    // clang-format off
    using namespace schema;  // NOLINT(build/namespaces)
    return Struct{
        {"namespace", make_schema(&name, id_prototype(), "namespace for simulation events and actions")},
        {"model_step_width", make_schema(&model_step_width, "default model time step in ns")},
        {"controller_retry_limit", make_schema(&controller_retry_limit, "times to retry controller processing before aborting")},
        {"controller_retry_sleep", make_schema(&controller_retry_sleep, "time to sleep before retrying controller process")},
        {"abort_on_controller_failure", make_schema(&abort_on_controller_failure, "abort simulation on controller failure")},
    };
    // clang-format on
  }
};
 
// --------------------------------------------------------------------------------------------- //
 
class StackIncompleteError : public Error {
 public:
  explicit StackIncompleteError(std::vector<std::string>&& missing);
 
  [[nodiscard]] std::string all_sections_missing(const std::string& sep = ", ") const;
  [[nodiscard]] const std::vector<std::string>& sections_missing() const { return sections_missing_; }
 
 private:
  std::vector<std::string> sections_missing_;
};
 
using ConfReader = std::function<Conf(const std::string&)>;
 
class Stack : public Confable {
 private:  // Constants (1)
  std::vector<std::string> reserved_ids_;
  std::optional<std::string> schema_ref_;
 
 public:  // Configuration (13)
  std::string version;
  EngineConf engine;
  ServerConf server;
  std::vector<IncludeConf> include;
  std::vector<LoggingConf> logging;
  std::vector<PluginConf> plugins;
  std::vector<DefaultConf> simulator_defaults;
  std::vector<SimulatorConf> simulators;
  std::vector<DefaultConf> controller_defaults;
  std::vector<ControllerConf> controllers;
  std::vector<DefaultConf> component_defaults;
  std::vector<VehicleConf> vehicles;
  std::vector<TriggerConf> triggers;
  SimulationConf simulation;
 
 private:  // Schemas (3) & Prototypes (3)
  EngineSchema engine_schema;
  IncludesSchema include_schema;
  PluginsSchema plugins_schema;
 
  SimulatorSchema simulator_prototype;
  ControllerSchema controller_prototype;
  VehicleSchema vehicle_prototype;
 
 private:  // State (3)
  std::set<std::string> scanned_plugin_paths_;
  std::map<std::string, std::shared_ptr<Plugin>> all_plugins_;
  std::vector<Conf> applied_confs_;
  ConfReader conf_reader_func_;
 
 public:  // Constructors
  Stack();
  Stack(const Stack& other);
  Stack(Stack&& other) noexcept;
  Stack& operator=(const Stack& other);
  Stack& operator=(Stack&& other) noexcept;
  ~Stack() override = default;
 
  friend void swap(Stack& left, Stack& right);
 
 public:  // Special
  Logger logger() const { return logger::get("cloe"); }
 
  void set_conf_reader(ConfReader fn) {
    assert(fn != nullptr);
    conf_reader_func_ = std::move(fn);
  }
 
  void merge_stackfile(const std::string& filepath);
 
  void apply_plugin_conf(const PluginConf& c);
 
  void insert_plugin(const PluginConf& c);
 
  void insert_plugin(std::shared_ptr<Plugin> p, const PluginConf& c = {});
 
  bool has_plugin_with_name(const std::string& key) const;
 
  bool has_plugin_with_path(const std::string& path) const;
 
  std::shared_ptr<Plugin> get_plugin_with_name(const std::string& key) const;
 
  std::shared_ptr<Plugin> get_plugin_with_path(const std::string& key) const;
 
  std::shared_ptr<Plugin> get_plugin_or_load(const std::string& key_or_path) const;
 
  const std::map<std::string, std::shared_ptr<Plugin>>& get_all_plugins() const {
    return all_plugins_;
  }
 
  std::vector<DefaultConf> get_simulator_defaults(std::string binding, std::string name) const;
  std::vector<DefaultConf> get_controller_defaults(std::string binding, std::string name) const;
  std::vector<DefaultConf> get_vehicle_defaults(std::string name) const;
  std::vector<DefaultConf> get_component_defaults(std::string binding, std::string name) const;
 
  void validate_self() const;
 
  bool is_valid() const;
 
  void check_consistency() const;
 
  void check_defaults() const;
 
  bool is_complete() const;
 
  void check_completeness() const;
 
  void initialize() { from_conf(Conf{Json{{"version", CLOE_STACK_VERSION}}}); }
 
  Json active_config() const;
 
  Json input_config() const;
 
 public:  // Confable Overrides
  bool validate(const Conf& c, std::optional<SchemaError>& err) const override;
  void validate_or_throw(const Conf& c) const override;
 
  void to_json(Json& j) const override;
  void from_conf(const Conf& c) override { from_conf(c, 0); }
  void reset_schema() override;
 
  CONFABLE_SCHEMA(Stack) {
    // clang-format off
    using namespace schema;  // NOLINT(build/namespaces)
 
    return Struct{
        {"$schema", make_schema(&schema_ref_, "valid URI to schema describing this cloe stack version")},
        {"version", make_schema(&version, "version of stackfile").require().enum_of(
          CLOE_STACK_SUPPORTED_VERSIONS
        )},
        {"engine", engine_schema},
        {"include", include_schema},
        {"logging", make_schema(&logging, "logging configuration").extend(true)},
        {"plugins", plugins_schema},
        {"server", make_schema(&server, "server configuration")},
        {"defaults", Struct{
           {"simulators", make_schema(&simulator_defaults, "simulator default configurations").extend(true)},
           {"controllers", make_schema(&controller_defaults, "controller default configurations").extend(true)},
           {"components", make_schema(&component_defaults, "component default configurations").extend(true)},
        }},
        {"vehicles", make_schema(&vehicles, vehicle_prototype, "vehicle configuration").extend(true)},
        {"simulators", make_schema(&simulators, simulator_prototype, "simulator configuration").extend(true)},
        {"controllers", make_schema(&controllers, controller_prototype, "controller configuration").extend(true)},
        {"triggers", make_schema(&triggers, "triggers").extend(true)},
        {"simulation", make_schema(&simulation, "simulation configuration")},
    };
    // clang-format on
  }
 
 protected:
  void from_conf(const Conf& c, size_t depth);
};
 
}  // namespace cloe