static bool decode()

in flex/engines/http_server/graph_db_service.h [209:364]
148 lines of code
37 McCabe index (conditional complexity)

  static bool decode(const Node& config,
                     server::ServiceConfig& service_config) {
    if (!config.IsMap()) {
      LOG(ERROR) << "ServiceConfig should be a map";
      return false;
    }
    // log level: INFO=0, WARNING=1, ERROR=2, FATAL=3
    if (config["log_level"]) {
      auto level_str = gs::toUpper(config["log_level"].as<std::string>());

      if (level_str == "INFO") {
        service_config.log_level = 0;
      } else if (level_str == "WARNING") {
        service_config.log_level = 1;
      } else if (level_str == "ERROR") {
        service_config.log_level = 2;
      } else if (level_str == "FATAL") {
        service_config.log_level = 3;
      } else {
        LOG(ERROR) << "Unsupported log level: " << level_str;
        return false;
      }
    } else {
      LOG(INFO) << "log_level not found, use default value "
                << service_config.log_level;
    }

    // verbose log level
    if (config["verbose_level"]) {
      service_config.verbose_level = config["verbose_level"].as<int>();
    } else {
      LOG(INFO) << "verbose_level not found, use default value "
                << service_config.verbose_level;
    }

    auto engine_node = config["compute_engine"];
    if (engine_node) {
      auto engine_type = engine_node["type"];
      if (engine_type) {
        auto engine_type_str = engine_type.as<std::string>();
        if (engine_type_str != "hiactor" && engine_type_str != "Hiactor") {
          LOG(ERROR) << "compute_engine type should be hiactor, found: "
                     << engine_type_str;
          return false;
        }
      }
      auto shard_num_node = engine_node["thread_num_per_worker"];
      if (shard_num_node) {
        service_config.shard_num = shard_num_node.as<uint32_t>();
      } else {
        LOG(INFO) << "shard_num not found, use default value "
                  << service_config.shard_num;
      }

      auto metadata_store_node = engine_node["metadata_store"];
      if (metadata_store_node) {
        auto metadata_store_type = metadata_store_node["type"];
        if (metadata_store_type) {
          auto metadata_store_type_str = metadata_store_type.as<std::string>();
          if (metadata_store_type_str == "file") {
            service_config.metadata_store_type_ =
                gs::MetadataStoreType::kLocalFile;
          } else {
            LOG(ERROR) << "Unsupported metadata store type: "
                       << metadata_store_type_str;
            return false;
          }
        }
      }
      if (engine_node["wal_uri"]) {
        service_config.wal_uri = engine_node["wal_uri"].as<std::string>();
      }
    } else {
      LOG(ERROR) << "Fail to find compute_engine configuration";
      return false;
    }
    auto http_service_node = config["http_service"];
    if (http_service_node) {
      auto query_port_node = http_service_node["query_port"];
      if (query_port_node) {
        service_config.query_port = query_port_node.as<uint32_t>();
      } else {
        LOG(INFO) << "query_port not found, use default value "
                  << service_config.query_port;
      }
      auto admin_port_node = http_service_node["admin_port"];
      if (admin_port_node) {
        service_config.admin_port = admin_port_node.as<uint32_t>();
      } else {
        LOG(INFO) << "admin_port not found, use default value "
                  << service_config.admin_port;
      }
      if (http_service_node["sharding_mode"]) {
        auto sharding_mode =
            http_service_node["sharding_mode"].as<std::string>();
        if (sharding_mode != "exclusive" && sharding_mode != "cooperative") {
          LOG(ERROR) << "Unsupported sharding mode: " << sharding_mode;
          return false;
        }
        if (sharding_mode == "exclusive" && service_config.shard_num == 1) {
          LOG(ERROR) << "exclusive sharding mode requires at least 2 shards";
          return false;
        }
        service_config.set_sharding_mode(sharding_mode);
        VLOG(1) << "sharding_mode: " << sharding_mode;
      }
      if (http_service_node["max_content_length"]) {
        service_config.set_admin_svc_max_content_length(
            http_service_node["max_content_length"].as<std::string>());
        LOG(INFO) << "max_content_length: "
                  << service_config.admin_svc_max_content_length;
      }
    } else {
      LOG(ERROR) << "Fail to find http_service configuration";
      return false;
    }

    auto compiler_node = config["compiler"];
    if (compiler_node) {
      auto endpoint_node = compiler_node["endpoint"];
      if (endpoint_node) {
        auto bolt_node = endpoint_node["bolt_connector"];
        if (bolt_node && bolt_node["disabled"]) {
          service_config.enable_bolt = !bolt_node["disabled"].as<bool>();
        } else {
          service_config.enable_bolt = true;
        }
        if (bolt_node && bolt_node["port"]) {
          service_config.bolt_port = bolt_node["port"].as<uint32_t>();
        } else {
          LOG(INFO) << "bolt_port not found, or disabled";
        }
        auto gremlin_node = endpoint_node["gremlin_connector"];
        if (gremlin_node && gremlin_node["disabled"]) {
          service_config.enable_gremlin = !gremlin_node["disabled"].as<bool>();
        } else {
          service_config.enable_gremlin = true;
        }
        if (gremlin_node && gremlin_node["port"]) {
          service_config.gremlin_port = gremlin_node["port"].as<uint32_t>();
        } else {
          LOG(INFO) << "gremlin_port not found, use default value "
                    << service_config.gremlin_port;
        }
      }
    }

    auto default_graph_node = config["default_graph"];
    std::string default_graph;
    if (default_graph_node) {
      service_config.default_graph = default_graph_node.as<std::string>();
    } else {
      LOG(WARNING) << "Fail to find default_graph configuration";
    }
    return true;
  }