director_config.hpp

Go to the documentation of this file.

/*
  ____  _               _
 |  _ \‍(_)_ __ ___  ___| |_ ___  _ __
 | | | | | '__/ _ \/ __| __/ _ \| '__|
 | |_| | | | |  __/ (__| || (_) | |
 |____/|_|_|  \___|\___|\__\___/|_|
   ____             __ _
  / ___|___  _ __  / _(_) __ _
 | |   / _ \| '_ \| |_| |/ _` |
 | |__| (_) | | | |  _| | (_| |
  \____\___/|_| |_|_| |_|\__, |
                         |___/
 
Pure config module for `mads up` (src/main/up.cpp): parses `director.toml` (the
config format owned by https://github.com/mads-net/mads_director), validates
it, expands `scale`/`${PWD}`/`${ID}` templating, and orders processes so that
every dependency (`after`) starts before its dependents.
 
No ZMQ, no process spawning, no `Mads::Agent` dependency here on purpose (see
the "Parser ownership" decision in NEW_FEATURES.md's P5 section): this file is
meant to be liftable wholesale into a future shared header, or contributed
upstream to mads_director.
 
Author(s): Paolo Bosetti
*/
#ifndef MADS_DIRECTOR_CONFIG_HPP
#define MADS_DIRECTOR_CONFIG_HPP
 
#include <chrono>
#include <cstdint>
#include <filesystem>
#include <optional>
#include <string>
#include <vector>
 
namespace Mads {
 
std::optional<std::chrono::milliseconds> parse_duration(const std::string &text);
 
enum class ReadyKind { Broker, Port, Log, Delay };
 
struct ReadySpec {
  ReadyKind kind = ReadyKind::Delay;
  std::string broker_uri;   // ReadyKind::Broker (defaulted if not given)
  int port = 0;             // ReadyKind::Port
  std::string log_pattern;  // ReadyKind::Log (ECMAScript regex, matched
                             // against each captured stdout/stderr line)
  std::chrono::milliseconds delay{0}; // ReadyKind::Delay
};
 
constexpr const char *kDefaultBrokerProbeUri = "tcp://localhost:9092";
 
std::optional<ReadySpec> parse_ready_spec(const std::string &value,
                                          std::string *out_error);
 
struct ProcessConfig {
  std::string name;      // instance name, e.g. "api" or "api[2]" when scale>1
  std::string base_name; // section name before scale expansion, e.g. "api"
  std::string command;   // fully expanded (${PWD}/${ID} substituted)
  std::string workdir;   // absolute, resolved against the config file's dir
  bool enabled = true;
  bool relaunch = false;
  bool tty = false; // parsed for fidelity; headless mads-up ignores it
  // The value `${ID}` expanded to: `base_instance_id + <0-based index>`,
  // matching Director's own substitution. Plain 0-based when the section
  // leaves `base_instance_id` at its 0 default.
  int instance_id = 0;
  // Resolved dependency instance names (a base process with scale>1 that
  // another depends on via `after` expands to *all* of its instances, exactly
  // as mads_director's ProcessManager::build_process_definitions does).
  std::vector<std::string> after;
  std::optional<ReadySpec> ready;
};
 
struct DirectorConfig {
  std::optional<std::string> terminal;    // GUI-only, ignored headless
  double sample_rate_seconds = 2.0;       // GUI-only, ignored headless
  std::filesystem::path base_dir;         // directory containing the config
  std::vector<ProcessConfig> processes;   // topologically ordered
};
 
struct DirectorLoadOptions {
  std::optional<int> base_instance_id;
};
 
std::optional<DirectorConfig>
load_director_config(const std::string &path, std::string *out_error,
                     std::vector<std::string> *out_warnings = nullptr,
                     const DirectorLoadOptions &options = {});
 
} // namespace Mads
 
#endif // MADS_DIRECTOR_CONFIG_HPP