bool PluginRootContext::parsePluginConfig()

in plugins/wasm-cpp/extensions/key_rate_limit/plugin.cc [57:148]
92 lines of code
15 McCabe index (conditional complexity)

bool PluginRootContext::parsePluginConfig(const json& configuration,
                                          KeyRateLimitConfigRule& rule) {
  if (!JsonArrayIterate(
          configuration, "limit_keys", [&](const json& item) -> bool {
            std::string key =
                Wasm::Common::JsonGetField<std::string>(item, "key").value();
            uint64_t qps =
                Wasm::Common::JsonGetField<uint64_t>(item, "query_per_second")
                    .value_or(0);
            if (qps > 0) {
              rule.limit_keys.emplace(key, LimitItem{
                                               key,
                                               qps,
                                               second_nano,
                                               qps,
                                           });
              return true;
            }
            uint64_t qpm =
                Wasm::Common::JsonGetField<uint64_t>(item, "query_per_minute")
                    .value_or(0);
            if (qpm > 0) {
              rule.limit_keys.emplace(key, LimitItem{
                                               key,
                                               qpm,
                                               minute_nano,
                                               qpm,
                                           });
              return true;
            }
            uint64_t qph =
                Wasm::Common::JsonGetField<uint64_t>(item, "query_per_hour")
                    .value_or(0);
            if (qph > 0) {
              rule.limit_keys.emplace(key, LimitItem{
                                               key,
                                               qph,
                                               hour_nano,
                                               qph,
                                           });
              return true;
            }
            uint64_t qpd =
                Wasm::Common::JsonGetField<uint64_t>(item, "query_per_day")
                    .value_or(0);
            if (qpd > 0) {
              rule.limit_keys.emplace(key, LimitItem{
                                               key,
                                               qpd,
                                               day_nano,
                                               qpd,
                                           });
              return true;
            }
            LOG_WARN(
                "one of 'query_per_second', 'query_per_minute', "
                "'query_per_hour' or 'query_per_day' must be set");
            return false;
          })) {
    LOG_WARN("failed to parse configuration for limit_keys.");
    return false;
  }
  if (rule.limit_keys.empty()) {
    LOG_WARN("no limit keys found in configuration");
    return false;
  }
  auto it = configuration.find("limit_by_header");
  if (it != configuration.end()) {
    auto limit_by_header = JsonValueAs<std::string>(it.value());
    if (limit_by_header.second != Wasm::Common::JsonParserResultDetail::OK) {
      LOG_WARN("cannot parse limit_by_header");
      return false;
    }
    rule.limit_by_header = limit_by_header.first.value();
  }
  it = configuration.find("limit_by_param");
  if (it != configuration.end()) {
    auto limit_by_param = JsonValueAs<std::string>(it.value());
    if (limit_by_param.second != Wasm::Common::JsonParserResultDetail::OK) {
      LOG_WARN("cannot parse limit_by_param");
      return false;
    }
    rule.limit_by_param = limit_by_param.first.value();
  }
  auto emptyHeader = rule.limit_by_header.empty();
  auto emptyParam = rule.limit_by_param.empty();
  if ((emptyHeader && emptyParam) || (!emptyHeader && !emptyParam)) {
    LOG_WARN("only one of 'limit_by_param' and 'limit_by_header' can be set");
    return false;
  }
  return true;
}