lokinet/llarp/config/definition.cpp

#include "definition.hpp"

#include <llarp/util/logging.hpp>

#include <cassert>
#include <iterator>
#include <stdexcept>

namespace llarp
{
  template <>
  bool
  OptionDefinition<bool>::from_string(const std::string& input)
  {
    if (input == "false" || input == "off" || input == "0" || input == "no")
      return false;
    if (input == "true" || input == "on" || input == "1" || input == "yes")
      return true;
    throw std::invalid_argument{fmt::format("{} is not a valid bool", input)};
  }

  ConfigDefinition&
  ConfigDefinition::define_option(std::unique_ptr<OptionDefinitionBase> def)
  {
    using namespace config;
    // If explicitly deprecated or is a {client,relay} option in a {relay,client} config then add a
    // dummy, warning option instead of this one.
    if (def->deprecated || (relay ? def->clientOnly : def->relay_only))
    {
      return define_option<std::string>(
          def->section,
          def->name,
          MultiValue,
          Hidden,
          [deprecated = def->deprecated,
           relay = relay,
           opt = "[" + def->section + "]:" + def->name](std::string_view) {
            LogWarn(
                "*** WARNING: The config option ",
                opt,
                (deprecated  ? " is deprecated"
                     : relay ? " is not valid in service node configuration files"
                             : " is not valid in client configuration files"),
                " and has been ignored.");
          });
    }

    auto [sectionItr, newSect] = definitions.try_emplace(def->section);
    if (newSect)
      section_ordering.push_back(def->section);
    auto& section = sectionItr->first;

    auto [it, added] = definitions[section].try_emplace(std::string{def->name}, std::move(def));
    if (!added)
      throw std::invalid_argument{
          fmt::format("definition for [{}]:{} already exists", def->section, def->name)};

    definition_ordering[section].push_back(it->first);

    if (!it->second->comments.empty())
      add_option_comments(section, it->first, std::move(it->second->comments));

    return *this;
  }

  ConfigDefinition&
  ConfigDefinition::add_config_value(
      std::string_view section, std::string_view name, std::string_view value)
  {
    // see if we have an undeclared handler to fall back to in case section or section:name is
    // absent
    auto undItr = undeclared_handlers.find(std::string(section));
    bool haveUndeclaredHandler = (undItr != undeclared_handlers.end());

    // get section, falling back to undeclared handler if needed
    auto secItr = definitions.find(std::string(section));
    if (secItr == definitions.end())
    {
      // fallback to undeclared handler if available
      if (not haveUndeclaredHandler)
        throw std::invalid_argument{fmt::format("unrecognized section [{}]", section)};
      auto& handler = undItr->second;
      handler(section, name, value);
      return *this;
    }

    // section was valid, get definition by name
    // fall back to undeclared handler if needed
    auto& sectionDefinitions = secItr->second;
    auto defItr = sectionDefinitions.find(std::string(name));
    if (defItr != sectionDefinitions.end())
    {
      std::unique_ptr<OptionDefinitionBase>& definition = defItr->second;
      definition->parse_value(std::string(value));
      return *this;
    }

    if (not haveUndeclaredHandler)
      throw std::invalid_argument{fmt::format("unrecognized option [{}]: {}", section, name)};

    auto& handler = undItr->second;
    handler(section, name, value);
    return *this;
  }

  void
  ConfigDefinition::add_undeclared_handler(
      const std::string& section, UndeclaredValueHandler handler)
  {
    auto itr = undeclared_handlers.find(section);
    if (itr != undeclared_handlers.end())
      throw std::logic_error{fmt::format("section {} already has a handler", section)};

    undeclared_handlers[section] = std::move(handler);
  }

  void
  ConfigDefinition::remove_undeclared_handler(const std::string& section)
  {
    auto itr = undeclared_handlers.find(section);
    if (itr != undeclared_handlers.end())
      undeclared_handlers.erase(itr);
  }

  void
  ConfigDefinition::validate_required_fields()
  {
    visit_sections([&](const std::string& section, const DefinitionMap&) {
      visit_definitions(
          section, [&](const std::string&, const std::unique_ptr<OptionDefinitionBase>& def) {
            if (def->required and def->get_number_found() < 1)
            {
              throw std::invalid_argument{
                  fmt::format("[{}]:{} is required but missing", section, def->name)};
            }

            // should be handled earlier in OptionDefinition::parse_value()
            assert(def->get_number_found() <= 1 or def->multi_valued);
          });
    });
  }

  void
  ConfigDefinition::accept_all_options()
  {
    visit_sections([this](const std::string& section, const DefinitionMap&) {
      visit_definitions(
          section, [](const std::string&, const std::unique_ptr<OptionDefinitionBase>& def) {
            def->try_accept();
          });
    });
  }

  void
  ConfigDefinition::add_section_comments(
      const std::string& section, std::vector<std::string> comments)
  {
    auto& sectionComments = section_comments[section];
    for (auto& c : comments)
      sectionComments.emplace_back(std::move(c));
  }

  void
  ConfigDefinition::add_option_comments(
      const std::string& section, const std::string& name, std::vector<std::string> comments)
  {
    auto& defComments = definition_comments[section][name];
    if (defComments.empty())
      defComments = std::move(comments);
    else
      defComments.insert(
          defComments.end(),
          std::make_move_iterator(comments.begin()),
          std::make_move_iterator(comments.end()));
  }

  std::string
  ConfigDefinition::generate_ini_config(bool useValues)
  {
    std::string ini;
    auto ini_append = std::back_inserter(ini);

    int sectionsVisited = 0;

    visit_sections([&](const std::string& section, const DefinitionMap&) {
      std::string sect_str;
      auto sect_append = std::back_inserter(sect_str);

      visit_definitions(
          section, [&](const std::string& name, const std::unique_ptr<OptionDefinitionBase>& def) {
            bool has_comment = false;
            // TODO: as above, this will create empty objects
            // TODO: as above (but more important): this won't handle definitions with no entries
            //       (i.e. those handled by UndeclaredValueHandler's)
            for (const std::string& comment : definition_comments[section][name])
            {
              fmt::format_to(sect_append, "\n# {}", comment);
              has_comment = true;
            }

            if (useValues and def->get_number_found() > 0)
            {
              for (const auto& val : def->values_as_string())
                fmt::format_to(sect_append, "\n{}={}", name, val);
              *sect_append = '\n';
            }
            else if (not def->hidden)
            {
              if (auto defaults = def->default_values_as_string(); not defaults.empty())
                for (const auto& val : defaults)
                  fmt::format_to(sect_append, "\n{}{}={}", def->required ? "" : "#", name, val);
              else
                // We have no defaults so we append it as "#opt-name=" so that we show the option
                // name, and make it simple to uncomment and edit to the desired value.
                fmt::format_to(sect_append, "\n#{}=", name);
              *sect_append = '\n';
            }
            else if (has_comment)
              *sect_append = '\n';
          });

      if (sect_str.empty())
        return;  // Skip sections with no options

      if (sectionsVisited > 0)
        ini += "\n\n";

      fmt::format_to(ini_append, "[{}]\n", section);

      // TODO: this will create empty objects as a side effect of map's operator[]
      // TODO: this also won't handle sections which have no definition
      for (const std::string& comment : section_comments[section])
      {
        fmt::format_to(ini_append, "# {}\n", comment);
      }
      ini += "\n";
      ini += sect_str;

      sectionsVisited++;
    });

    return ini;
  }

  const std::unique_ptr<OptionDefinitionBase>&
  ConfigDefinition::lookup_definition_or_throw(
      std::string_view section, std::string_view name) const
  {
    const auto sectionItr = definitions.find(std::string(section));
    if (sectionItr == definitions.end())
      throw std::invalid_argument{fmt::format("No config section [{}]", section)};

    auto& sectionDefinitions = sectionItr->second;
    const auto definitionItr = sectionDefinitions.find(std::string(name));
    if (definitionItr == sectionDefinitions.end())
      throw std::invalid_argument{
          fmt::format("No config item {} within section {}", name, section)};

    return definitionItr->second;
  }

  std::unique_ptr<OptionDefinitionBase>&
  ConfigDefinition::lookup_definition_or_throw(std::string_view section, std::string_view name)
  {
    return const_cast<std::unique_ptr<OptionDefinitionBase>&>(
        const_cast<const ConfigDefinition*>(this)->lookup_definition_or_throw(section, name));
  }

  void
  ConfigDefinition::visit_sections(SectionVisitor visitor) const
  {
    for (const std::string& section : section_ordering)
    {
      const auto itr = definitions.find(section);
      assert(itr != definitions.end());
      visitor(section, itr->second);
    }
  };
  void
  ConfigDefinition::visit_definitions(const std::string& section, DefVisitor visitor) const
  {
    const auto& defs = definitions.at(section);
    const auto& defOrdering = definition_ordering.at(section);
    for (const std::string& name : defOrdering)
    {
      const auto itr = defs.find(name);
      assert(itr != defs.end());
      visitor(name, itr->second);
    }
  };

}  // namespace llarp