bool PluginRootContext::parsePluginConfig()

in plugins/wasm-cpp/extensions/request_block/plugin.cc [46:197]
151 lines of code
31 McCabe index (conditional complexity)

bool PluginRootContext::parsePluginConfig(const json& configuration,
                                          RequestBlockConfigRule& rule) {
  auto it = configuration.find("blocked_code");
  if (it != configuration.end()) {
    auto blocked_code = JsonValueAs<int64_t>(it.value());
    if (blocked_code.second != Wasm::Common::JsonParserResultDetail::OK) {
      LOG_WARN("cannot parse status code");
      return false;
    }
    rule.blocked_code = blocked_code.first.value();
  }
  it = configuration.find("blocked_message");
  if (it != configuration.end()) {
    auto blocked_message = JsonValueAs<std::string>(it.value());
    if (blocked_message.second != Wasm::Common::JsonParserResultDetail::OK) {
      LOG_WARN("cannot parse blocked_message");
      return false;
    }
    rule.blocked_message = blocked_message.first.value();
  }
  it = configuration.find("case_sensitive");
  if (it != configuration.end()) {
    auto case_sensitive = JsonValueAs<bool>(it.value());
    if (case_sensitive.second != Wasm::Common::JsonParserResultDetail::OK) {
      LOG_WARN("cannot parse case_sensitive");
      return false;
    }
    rule.case_sensitive = case_sensitive.first.value();
  }
  if (!JsonArrayIterate(
          configuration, "block_urls", [&](const json& item) -> bool {
            auto url = JsonValueAs<std::string>(item);
            if (url.second != Wasm::Common::JsonParserResultDetail::OK) {
              LOG_WARN("cannot parse block_urls");
              return false;
            }
            if (rule.case_sensitive) {
              rule.block_urls.push_back(std::move(url.first.value()));
            } else {
              rule.block_urls.push_back(
                  absl::AsciiStrToLower(url.first.value()));
            }
            return true;
          })) {
    LOG_WARN("failed to parse configuration for block_urls.");
    return false;
  }
  if (!JsonArrayIterate(
          configuration, "block_exact_urls", [&](const json& item) -> bool {
            auto url = JsonValueAs<std::string>(item);
            if (url.second != Wasm::Common::JsonParserResultDetail::OK) {
              LOG_WARN("cannot parse block_exact_urls");
              return false;
            }
            if (rule.case_sensitive) {
              rule.block_exact_urls.push_back(std::move(url.first.value()));
            } else {
              rule.block_exact_urls.push_back(
                  absl::AsciiStrToLower(url.first.value()));
            }
            return true;
          })) {
    LOG_WARN("failed to parse configuration for block_exact_urls.");
    return false;
  }
  if (!JsonArrayIterate(
          configuration, "block_regexp_urls", [&](const json& item) -> bool {
            auto url = JsonValueAs<std::string>(item);
            if (url.second != Wasm::Common::JsonParserResultDetail::OK) {
              LOG_WARN("cannot parse block_regexp_urls");
              return false;
            }
            std::string regex;
            if (rule.case_sensitive) {
              regex = url.first.value();
            } else {
              regex = absl::AsciiStrToLower(url.first.value());
            }
            auto re = std::make_unique<ReMatcher>(regex);
            if (!re->error().empty()) {
              LOG_WARN(re->error());
              return false;
            }
            rule.block_regexp_urls.push_back(std::move(re));
            return true;
          })) {
    LOG_WARN("failed to parse configuration for block_regexp_urls.");
    return false;
  }
  if (!JsonArrayIterate(
          configuration, "block_headers", [&](const json& item) -> bool {
            auto header = JsonValueAs<std::string>(item);
            if (header.second != Wasm::Common::JsonParserResultDetail::OK) {
              LOG_WARN("cannot parse block_headers");
              return false;
            }
            if (rule.case_sensitive) {
              rule.block_headers.push_back(std::move(header.first.value()));
            } else {
              rule.block_headers.push_back(
                  absl::AsciiStrToLower(header.first.value()));
            }
            return true;
          })) {
    LOG_WARN("failed to parse configuration for block_headers.");
    return false;
  }
  if (!JsonArrayIterate(
          configuration, "block_bodys", [&](const json& item) -> bool {
            auto body = JsonValueAs<std::string>(item);
            if (body.second != Wasm::Common::JsonParserResultDetail::OK) {
              LOG_WARN("cannot parse block_bodys");
              return false;
            }
            if (rule.case_sensitive) {
              rule.block_bodys.push_back(std::move(body.first.value()));
            } else {
              rule.block_bodys.push_back(
                  absl::AsciiStrToLower(body.first.value()));
            }
            return true;
          })) {
    LOG_WARN("failed to parse configuration for block_bodys.");
    return false;
  }
  // compatiable
  if (!JsonArrayIterate(
          configuration, "block_bodies", [&](const json& item) -> bool {
            auto body = JsonValueAs<std::string>(item);
            if (body.second != Wasm::Common::JsonParserResultDetail::OK) {
              LOG_WARN("cannot parse block_bodies");
              return false;
            }
            if (rule.case_sensitive) {
              rule.block_bodys.push_back(std::move(body.first.value()));
            } else {
              rule.block_bodys.push_back(
                  absl::AsciiStrToLower(body.first.value()));
            }
            return true;
          })) {
    LOG_WARN("failed to parse configuration for block_bodies.");
    return false;
  }
  if (rule.block_bodys.empty() && rule.block_headers.empty() &&
      rule.block_urls.empty() && rule.block_exact_urls.empty() &&
      rule.block_regexp_urls.empty()) {
    LOG_WARN("there is no block rules");
    return false;
  }
  return true;
}