std::unique_ptr compileRuleset()

in src/oomd/config/ConfigCompiler.cpp [104:192]
73 lines of code
17 McCabe index (conditional complexity)

std::unique_ptr<Oomd::Engine::Ruleset> compileRuleset(
    const Oomd::Config2::IR::Ruleset& ruleset,
    bool dropin,
    const Oomd::PluginConstructionContext& context) {
  uint32_t silenced_logs = 0;
  int post_action_delay = DEFAULT_POST_ACTION_DELAY;
  int prekill_hook_timeout = DEFAULT_PREKILL_HOOK_TIMEOUT;

  std::vector<std::unique_ptr<Oomd::Engine::DetectorGroup>> detector_groups;
  std::vector<std::unique_ptr<Oomd::Engine::BasePlugin>> actions;

  if (ruleset.name.empty()) {
    OLOG << "Ruleset is missing name";
    return nullptr;
  }

  // Log silencing field is optional
  if (ruleset.silence_logs.size()) {
    auto copy = ruleset.silence_logs;
    Oomd::Util::trim(copy);
    auto parts = Oomd::Util::split(copy, ',');

    for (auto& part : parts) {
      Oomd::Util::trim(part);

      if (part == "engine") {
        silenced_logs |= Oomd::Engine::LogSources::ENGINE;
      } else if (part == "plugins") {
        silenced_logs |= Oomd::Engine::LogSources::PLUGINS;
      } else {
        OLOG << "Unrecognized log source=" << part;
        return nullptr;
      }
    }
  }

  if (!dropin && (ruleset.dgs.empty() || ruleset.acts.empty())) {
    OLOG << "Ruleset is missing DetectorGroups or missing Actions";
    return nullptr;
  }

  // post_action_delay field is optional
  if (ruleset.post_action_delay.size()) {
    post_action_delay = std::stoi(ruleset.post_action_delay);
    if (post_action_delay < 0) {
      OLOG << "Ruleset post_action_delay must be non-negative";
      return nullptr;
    }
  }

  // prekill_hook_timeout field is optional
  if (ruleset.prekill_hook_timeout.size()) {
    prekill_hook_timeout = std::stoi(ruleset.prekill_hook_timeout);
    if (prekill_hook_timeout < 0) {
      OLOG << "Ruleset prekill_hook_timeout must be non-negative";
      return nullptr;
    }
  }

  for (const auto& dg : ruleset.dgs) {
    auto compiled_detectorgroup = compileDetectorGroup(dg, context);
    if (!compiled_detectorgroup) {
      return nullptr;
    }

    detector_groups.emplace_back(std::move(compiled_detectorgroup));
  }

  for (const auto& action : ruleset.acts) {
    auto compiled_action =
        compilePlugin<Oomd::Config2::IR::Action>(action, context);
    if (!compiled_action) {
      return nullptr;
    }

    actions.emplace_back(std::move(compiled_action));
  }

  return std::make_unique<Oomd::Engine::Ruleset>(
      ruleset.name,
      std::move(detector_groups),
      std::move(actions),
      ruleset.dropin.disable_on_drop_in,
      ruleset.dropin.detectorgroups_enabled,
      ruleset.dropin.actiongroup_enabled,
      silenced_logs,
      post_action_delay,
      prekill_hook_timeout);
}