src: unify option parsing methods

Author: pmarchini

src/node_config_file.cc

@@ -148,52 +148,27 @@ ParseResult ConfigReader::ProcessOptionValue(
   return ParseResult::Valid;
 }
 
-ParseResult ConfigReader::ParseNodeOptions(
-    simdjson::ondemand::object* node_options_object) {
-  auto env_options_map = options_parser::MapEnvOptionsFlagInputType();
-  simdjson::ondemand::value ondemand_value;
-  std::string_view key;
-
-  for (auto field : *node_options_object) {
-    if (field.unescaped_key().get(key) || field.value().get(ondemand_value)) {
-      return ParseResult::InvalidContent;
-    }
-
-    // The key needs to match the CLI option
-    std::string prefix = "--";
-    auto it = env_options_map.find(prefix.append(key));
-    if (it != env_options_map.end()) {
-      // If the option has already been set, return an error
-      if (unique_options_.contains(it->first)) {
-        FPrintF(stderr, "Option %s is already defined\n", it->first.c_str());
-        return ParseResult::InvalidContent;
-      }
-      ParseResult result = ProcessOptionValue(key,
-                                              it->first,
-                                              ondemand_value,
-                                              it->second,
-                                              &node_options_,
-                                              &unique_options_);
-      if (result != ParseResult::Valid) {
-        return result;
-      }
-    } else {
-      FPrintF(stderr, "Unknown or not allowed option %s\n", key.data());
-      return ParseResult::InvalidContent;
-    }
-  }
-  return ParseResult::Valid;
-}
-
-ParseResult ConfigReader::ParseNamespaceOptions(
+ParseResult ConfigReader::ParseOptions(
     simdjson::ondemand::object* options_object,
     const std::string& namespace_name) {
-  // MapOptions could send also options non settable via nodeOptions
-  auto options_map = options_parser::MapOptionsByNamespace(namespace_name);
-
-  if (!env_options_initialized_) {
-    env_options_map_ = options_parser::MapEnvOptionsFlagInputType();
-    env_options_initialized_ = true;
+  // Determine which options map to use and output vector
+  std::unordered_map<std::string, options_parser::OptionType> options_map;
+  std::vector<std::string>* output_vector;
+
+  if (namespace_name == "nodeOptions") {
+    // Special case for backward compatibility: handle nodeOptions with env
+    // options map
+    options_map = options_parser::MapEnvOptionsFlagInputType();
+    output_vector = &node_options_;
+  } else {
+    // Handle other namespaces
+    options_map = options_parser::MapOptionsByNamespace(namespace_name);
+    output_vector = &namespace_options_;
+
+    if (!env_options_initialized_) {
+      env_options_map_ = options_parser::MapEnvOptionsFlagInputType();
+      env_options_initialized_ = true;
+    }
   }
 
   simdjson::ondemand::value ondemand_value;
@@ -204,7 +179,7 @@ ParseResult ConfigReader::ParseNamespaceOptions(
       return ParseResult::InvalidContent;
     }
 
-    // The key needs to match the option for this namespace
+    // The key needs to match the CLI option
     std::string prefix = "--";
     auto it = options_map.find(prefix.append(key));
     if (it != options_map.end()) {
@@ -213,12 +188,11 @@ ParseResult ConfigReader::ParseNamespaceOptions(
         FPrintF(stderr, "Option %s is already defined\n", it->first.c_str());
         return ParseResult::InvalidContent;
       }
-      // Process the option for env options
       ParseResult result = ProcessOptionValue(key,
                                               it->first,
                                               ondemand_value,
                                               it->second,
-                                              &namespace_non_env_options_,
+                                              output_vector,
                                               &unique_options_);
       if (result != ParseResult::Valid) {
         return result;
@@ -304,20 +278,10 @@ ParseResult ConfigReader::ParseConfig(const std::string_view& config_path) {
       return ParseResult::InvalidContent;
     }
 
-    // Special case for backward compatibility: handle nodeOptions with existing
-    // method
-    if (namespace_name == "nodeOptions") {
-      ParseResult result = ParseNodeOptions(&namespace_object);
-      if (result != ParseResult::Valid) {
-        return result;
-      }
-    } else {
-      // Process options for this namespace
-      ParseResult result =
-          ParseNamespaceOptions(&namespace_object, namespace_name);
-      if (result != ParseResult::Valid) {
-        return result;
-      }
+    // Process options for this namespace using the unified method
+    ParseResult result = ParseOptions(&namespace_object, namespace_name);
+    if (result != ParseResult::Valid) {
+      return result;
     }
   }
 
@@ -335,7 +299,7 @@ std::string ConfigReader::AssignNodeOptions() {
 }
 
 std::vector<std::string> ConfigReader::AssignNodeNonEnvOptions() {
-  return namespace_non_env_options_;
+  return namespace_options_;
 }
 
 size_t ConfigReader::GetFlagsSize() {

src/node_config_file.h

@@ -38,12 +38,10 @@ class ConfigReader {
   size_t GetFlagsSize();
 
  private:
-  // Parse the nodeOptions object from the configuration file
-  ParseResult ParseNodeOptions(simdjson::ondemand::object* node_options_object);
-
-  // Parse options for a specific namespace
-  ParseResult ParseNamespaceOptions(simdjson::ondemand::object* options_object,
-                                    const std::string& namespace_name);
+  // Parse options for a specific namespace (including nodeOptions for backward
+  // compatibility)
+  ParseResult ParseOptions(simdjson::ondemand::object* options_object,
+                           const std::string& namespace_name);
 
   // Process a single option value based on its type
   ParseResult ProcessOptionValue(
@@ -57,7 +55,6 @@ class ConfigReader {
   std::unordered_set<std::string> unique_options_;
   std::vector<std::string> node_options_;
   std::vector<std::string> namespace_options_;
-  std::vector<std::string> namespace_non_env_options_;
 
   // Cache for fast lookup of environment options
   std::unordered_map<std::string, options_parser::OptionType> env_options_map_;