diff --git a/docs/install/requirements.rst b/docs/install/requirements.rst index a1d1703264585..28f840b860a13 100644 --- a/docs/install/requirements.rst +++ b/docs/install/requirements.rst @@ -14,10 +14,10 @@ Envoy has the following requirements: * `libevent `_ (last tested with 2.0.22) * `tclap `_ (last tested with 1.2.1) * `gperftools `_ (last tested with 2.5.0) -* `jansson `_ (last tesed with 2.7) -* `openssl `_ (last tesed with 1.0.2i) +* `openssl `_ (last tested with 1.0.2i) * `protobuf `_ (last tested with 3.0.0) * `lightstep-tracer-cpp `_ (last tested with 0.16) +* `rapidjson `_ (last tested with 1.1.0) In order to compile and run the tests the following is required: diff --git a/include/envoy/json/json_object.h b/include/envoy/json/json_object.h new file mode 100644 index 0000000000000..b1ad72fefd6f2 --- /dev/null +++ b/include/envoy/json/json_object.h @@ -0,0 +1,132 @@ +#pragma once + +#include "envoy/common/exception.h" +#include "envoy/common/pure.h" + +namespace Json { +class Object; + +typedef std::unique_ptr ObjectPtr; + +// @return false if immediate exit from iteration required. +typedef std::function ObjectCallback; + +/** + * Exception thrown when a JSON error occurs. + */ +class Exception : public EnvoyException { +public: + Exception(const std::string& message) : EnvoyException(message) {} +}; + +/** + * Wraps an individual JSON node. + */ +class Object { +public: + virtual ~Object() {} + + /** + * Convert a generic object into an array of objects. This is useful for dealing + * with arrays of arrays. + * @return std::vector the converted object. + */ + virtual std::vector asObjectArray() const PURE; + + /** + * Get a boolean value by name. + * @param name supplies the key name. + * @return bool the value. + */ + virtual bool getBoolean(const std::string& name) const PURE; + + /** + * Get a boolean value by name. + * @param name supplies the key name. + * @param default_value supplies the value to return if the name does not exist. + * @return bool the value. + */ + virtual bool getBoolean(const std::string& name, bool default_value) const PURE; + + /** + * Get an integer value by name. + * @param name supplies the key name. + * @return int64_t the value. + */ + virtual int64_t getInteger(const std::string& name) const PURE; + + /** + * Get an integer value by name or return a default if name does not exist. + * @param name supplies the key name. + * @param default_value supplies the value to return if name does not exist. + * @return int64_t the value. + */ + virtual int64_t getInteger(const std::string& name, int64_t default_value) const PURE; + + /** + * Get a sub-object by name. + * @param name supplies the key name. + * @param allow_empty supplies whether to return an empty object if the key does not + * exist. + * @return ObjectObjectPtr the sub-object. + */ + virtual ObjectPtr getObject(const std::string& name, bool allow_empty = false) const PURE; + + /** + * Get an array by name. + * @param name supplies the key name. + * @return std::vector the array of JSON objects. + */ + virtual std::vector getObjectArray(const std::string& name) const PURE; + + /** + * Get a string value by name. + * @param name supplies the key name. + * @return std::string the value. + */ + virtual std::string getString(const std::string& name) const PURE; + + /** + * Get a string value by name or return a default if name does not exist. + * @param name supplies the key name. + * @param default_value supplies the value to return if name does not exist. + * @return std::string the value. + */ + virtual std::string getString(const std::string& name, + const std::string& default_value) const PURE; + + /** + * Get a string array by name. + * @param name supplies the key name. + * @return std::vector the array of strings. + */ + virtual std::vector getStringArray(const std::string& name) const PURE; + + /** + * Get a double value by name. + * @param name supplies the key name. + * @return double the value. + */ + virtual double getDouble(const std::string& name) const PURE; + + /** + * Get a double value by name. + * @param name supplies the key name. + * @param default_value supplies the value to return if name does not exist. + * @return double the value. + */ + virtual double getDouble(const std::string& name, double default_value) const PURE; + + /** + * Iterate over key-value pairs in an Object and call callback on each pair. + */ + virtual void iterate(const ObjectCallback& callback) const PURE; + + /** + * @return TRUE if the Object contains the key. + * @param name supplies the key name to lookup. + */ + virtual bool hasObject(const std::string& name) const PURE; +}; + +} // Json diff --git a/source/common/CMakeLists.txt b/source/common/CMakeLists.txt index 3fb9920e306ae..f8ba91900fe43 100644 --- a/source/common/CMakeLists.txt +++ b/source/common/CMakeLists.txt @@ -109,6 +109,7 @@ add_library( include_directories(SYSTEM ${ENVOY_HTTP_PARSER_INCLUDE_DIR}) include_directories(${ENVOY_JANSSON_INCLUDE_DIR}) +include_directories(${ENVOY_RAPIDJSON_INCLUDE_DIR}) if (NOT ENVOY_SANITIZE) include_directories(${ENVOY_GPERFTOOLS_INCLUDE_DIR}) diff --git a/source/common/dynamo/dynamo_filter.cc b/source/common/dynamo/dynamo_filter.cc index 5a9ad5f0a79ed..9714fa6dbe898 100644 --- a/source/common/dynamo/dynamo_filter.cc +++ b/source/common/dynamo/dynamo_filter.cc @@ -44,8 +44,8 @@ void DynamoFilter::onDecodeComplete(const Buffer::Instance& data) { std::string body = buildBody(decoder_callbacks_->decodingBuffer(), data); if (!body.empty()) { try { - Json::StringLoader json_body(body); - table_descriptor_ = RequestParser::parseTable(operation_, json_body); + Json::ObjectPtr json_body = Json::Factory::LoadFromString(body); + table_descriptor_ = RequestParser::parseTable(operation_, *json_body); } catch (const Json::Exception& jsonEx) { // Body parsing failed. This should not happen, just put a stat for that. stats_.counter(fmt::format("{}invalid_req_body", stat_prefix_)).inc(); @@ -64,17 +64,17 @@ void DynamoFilter::onEncodeComplete(const Buffer::Instance& data) { std::string body = buildBody(encoder_callbacks_->encodingBuffer(), data); if (!body.empty()) { try { - Json::StringLoader json_body(body); - chargeTablePartitionIdStats(json_body); + Json::ObjectPtr json_body = Json::Factory::LoadFromString(body); + chargeTablePartitionIdStats(*json_body); if (Http::CodeUtility::is4xx(status)) { - chargeFailureSpecificStats(json_body); + chargeFailureSpecificStats(*json_body); } // Batch Operations will always return status 200 for a partial or full success. Check // unprocessed keys to determine partial success. // http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.Errors.html#Programming.Errors.BatchOperations if (RequestParser::isBatchOperation(operation_)) { - chargeUnProcessedKeysStats(json_body); + chargeUnProcessedKeysStats(*json_body); } } catch (const Json::Exception&) { // Body parsing failed. This should not happen, just put a stat for that. diff --git a/source/common/dynamo/dynamo_request_parser.cc b/source/common/dynamo/dynamo_request_parser.cc index 3f1e4053d376d..da92600c8e5f6 100644 --- a/source/common/dynamo/dynamo_request_parser.cc +++ b/source/common/dynamo/dynamo_request_parser.cc @@ -69,8 +69,8 @@ RequestParser::TableDescriptor RequestParser::parseTable(const std::string& oper table.table_name = json_data.getString("TableName", ""); } else if (find(BATCH_OPERATIONS.begin(), BATCH_OPERATIONS.end(), operation) != BATCH_OPERATIONS.end()) { - Json::Object tables = json_data.getObject("RequestItems", true); - tables.iterate([&table](const std::string& key, const Json::Object&) { + Json::ObjectPtr tables = json_data.getObject("RequestItems", true); + tables->iterate([&table](const std::string& key, const Json::Object&) { if (table.table_name.empty()) { table.table_name = key; } else { @@ -88,8 +88,8 @@ RequestParser::TableDescriptor RequestParser::parseTable(const std::string& oper } std::vector RequestParser::parseBatchUnProcessedKeys(const Json::Object& json_data) { std::vector unprocessed_tables; - Json::Object tables = json_data.getObject("UnprocessedKeys", true); - tables.iterate([&unprocessed_tables](const std::string& key, const Json::Object&) { + Json::ObjectPtr tables = json_data.getObject("UnprocessedKeys", true); + tables->iterate([&unprocessed_tables](const std::string& key, const Json::Object&) { unprocessed_tables.emplace_back(key); return true; }); @@ -120,15 +120,15 @@ std::vector RequestParser::parsePartitions(const Json::Object& json_data) { std::vector partition_descriptors; - Json::Object partitions = - json_data.getObject("ConsumedCapacity", true).getObject("Partitions", true); - partitions.iterate([&partition_descriptors, &partitions](const std::string& key, - const Json::Object&) { + Json::ObjectPtr partitions = + json_data.getObject("ConsumedCapacity", true)->getObject("Partitions", true); + partitions->iterate([&partition_descriptors, &partitions](const std::string& key, + const Json::Object&) { // For a given partition id, the amount of capacity used is returned in the body as a double. // A stat will be created to track the capacity consumed for the operation, table and partition. // Stats counter only increments by whole numbers, capacity is round up to the nearest integer // to account for this. - uint64_t capacity_integer = static_cast(std::ceil(partitions.getDouble(key, 0.0))); + uint64_t capacity_integer = static_cast(std::ceil(partitions->getDouble(key, 0.0))); partition_descriptors.emplace_back(key, capacity_integer); return true; }); diff --git a/source/common/filter/auth/client_ssl.cc b/source/common/filter/auth/client_ssl.cc index f23188b48d642..d7210108ddb1d 100644 --- a/source/common/filter/auth/client_ssl.cc +++ b/source/common/filter/auth/client_ssl.cc @@ -45,9 +45,9 @@ GlobalStats Config::generateStats(Stats::Store& store, const std::string& prefix AllowedPrincipalsPtr Config::parseAuthResponse(Http::Message& message) { AllowedPrincipalsPtr new_principals(new AllowedPrincipals()); - Json::StringLoader loader(message.bodyAsString()); - for (const Json::Object& certificate : loader.getObjectArray("certificates")) { - new_principals->add(certificate.getString("fingerprint_sha256")); + Json::ObjectPtr loader = Json::Factory::LoadFromString(message.bodyAsString()); + for (const Json::ObjectPtr& certificate : loader->getObjectArray("certificates")) { + new_principals->add(certificate->getString("fingerprint_sha256")); } return new_principals; diff --git a/source/common/filter/ratelimit.cc b/source/common/filter/ratelimit.cc index 75740643be5d9..a00dd51b5b1ce 100644 --- a/source/common/filter/ratelimit.cc +++ b/source/common/filter/ratelimit.cc @@ -9,10 +9,10 @@ Config::Config(const Json::Object& config, Stats::Store& stats_store, Runtime::L : domain_(config.getString("domain")), stats_(generateStats(config.getString("stat_prefix"), stats_store)), runtime_(runtime) { - for (const Json::Object& descriptor : config.getObjectArray("descriptors")) { + for (const Json::ObjectPtr& descriptor : config.getObjectArray("descriptors")) { Descriptor new_descriptor; - for (const Json::Object& entry : descriptor.asObjectArray()) { - new_descriptor.entries_.push_back({entry.getString("key"), entry.getString("value")}); + for (const Json::ObjectPtr& entry : descriptor->asObjectArray()) { + new_descriptor.entries_.push_back({entry->getString("key"), entry->getString("value")}); } descriptors_.push_back(new_descriptor); } diff --git a/source/common/http/access_log/access_log_impl.cc b/source/common/http/access_log/access_log_impl.cc index 0910e0f7225ab..5fd6658bca46e 100644 --- a/source/common/http/access_log/access_log_impl.cc +++ b/source/common/http/access_log/access_log_impl.cc @@ -110,14 +110,14 @@ bool RuntimeFilter::evaluate(const RequestInfo&, const HeaderMap& request_header OperatorFilter::OperatorFilter(const Json::Object& json, Runtime::Loader& runtime) { if (json.hasObject("filters")) { - std::vector filters = json.getObjectArray("filters"); + std::vector filters = json.getObjectArray("filters"); if (filters.size() < 2) { throw EnvoyException(fmt::format("Filter list must have at least 2 filters, {} filters given", filters.size())); } - for (Json::Object& filter : filters) { - filters_.emplace_back(FilterImpl::fromJson(filter, runtime)); + for (Json::ObjectPtr& filter : filters) { + filters_.emplace_back(FilterImpl::fromJson(*filter, runtime)); } } else { throw EnvoyException(fmt::format("Filter list cannot be empty in OperatorFilter")); @@ -174,8 +174,8 @@ InstancePtr InstanceImpl::fromJson(Json::Object& json, Api::Api& api, Event::Dis FilterPtr filter; if (json.hasObject("filter")) { - Json::Object filterObject = json.getObject("filter"); - filter = FilterImpl::fromJson(filterObject, runtime); + Json::ObjectPtr filterObject = json.getObject("filter"); + filter = FilterImpl::fromJson(*filterObject, runtime); } FormatterPtr formatter; diff --git a/source/common/http/filter/fault_filter.cc b/source/common/http/filter/fault_filter.cc index 73ee6d5737222..4ec144f69bf8a 100644 --- a/source/common/http/filter/fault_filter.cc +++ b/source/common/http/filter/fault_filter.cc @@ -18,8 +18,8 @@ FaultFilterConfig::FaultFilterConfig(const Json::Object& json_config, Runtime::L : runtime_(runtime), stats_{ALL_FAULT_FILTER_STATS(POOL_COUNTER_PREFIX(stats, stat_prefix))} { if (json_config.hasObject("abort")) { - const Json::Object& abort = json_config.getObject("abort"); - abort_percent_ = static_cast(abort.getInteger("abort_percent", 0)); + const Json::ObjectPtr& abort = json_config.getObject("abort"); + abort_percent_ = static_cast(abort->getInteger("abort_percent", 0)); if (abort_percent_ > 0) { if (abort_percent_ > 100) { @@ -28,19 +28,19 @@ FaultFilterConfig::FaultFilterConfig(const Json::Object& json_config, Runtime::L } // TODO: Throw error if invalid return code is provided - if (abort.hasObject("http_status")) { - http_status_ = static_cast(abort.getInteger("http_status")); + if (abort->hasObject("http_status")) { + http_status_ = static_cast(abort->getInteger("http_status")); } else { throw EnvoyException("missing http_status in abort config"); } } if (json_config.hasObject("delay")) { - const Json::Object& delay = json_config.getObject("delay"); - const std::string type = delay.getString("type", "empty"); + const Json::ObjectPtr& delay = json_config.getObject("delay"); + const std::string type = delay->getString("type", "empty"); if (type == "fixed") { - fixed_delay_percent_ = static_cast(delay.getInteger("fixed_delay_percent", 0)); - fixed_duration_ms_ = static_cast(delay.getInteger("fixed_duration_ms", 0)); + fixed_delay_percent_ = static_cast(delay->getInteger("fixed_delay_percent", 0)); + fixed_duration_ms_ = static_cast(delay->getInteger("fixed_duration_ms", 0)); if (fixed_delay_percent_ > 0) { if (fixed_delay_percent_ > 100) { @@ -56,11 +56,11 @@ FaultFilterConfig::FaultFilterConfig(const Json::Object& json_config, Runtime::L } if (json_config.hasObject("headers")) { - std::vector config_headers = json_config.getObjectArray("headers"); - for (const Json::Object& header_map : config_headers) { + std::vector config_headers = json_config.getObjectArray("headers"); + for (const Json::ObjectPtr& header_map : config_headers) { // allow header value to be empty, allows matching to be only based on header presence. - fault_filter_headers_.emplace_back(Http::LowerCaseString(header_map.getString("name")), - header_map.getString("value", EMPTY_STRING)); + fault_filter_headers_.emplace_back(Http::LowerCaseString(header_map->getString("name")), + header_map->getString("value", EMPTY_STRING)); } } } diff --git a/source/common/http/filter/ratelimit.cc b/source/common/http/filter/ratelimit.cc index c2a2ae7bf3b47..2b453339846ef 100644 --- a/source/common/http/filter/ratelimit.cc +++ b/source/common/http/filter/ratelimit.cc @@ -70,12 +70,12 @@ FilterConfig::FilterConfig(const Json::Object& config, const std::string& local_ Stats::Store& stats_store, Runtime::Loader& runtime) : domain_(config.getString("domain")), local_service_cluster_(local_service_cluster), stats_store_(stats_store), runtime_(runtime) { - for (const Json::Object& action : config.getObjectArray("actions")) { - std::string type = action.getString("type"); + for (const Json::ObjectPtr& action : config.getObjectArray("actions")) { + std::string type = action->getString("type"); if (type == "service_to_service") { actions_.emplace_back(new ServiceToServiceAction()); } else if (type == "request_headers") { - actions_.emplace_back(new RequestHeadersAction(action)); + actions_.emplace_back(new RequestHeadersAction(*action)); } else if (type == "remote_address") { actions_.emplace_back(new RemoteAddressAction()); } else { diff --git a/source/common/json/json_loader.cc b/source/common/json/json_loader.cc index d83a6de0cc553..6bf2feda67614 100644 --- a/source/common/json/json_loader.cc +++ b/source/common/json/json_loader.cc @@ -1,178 +1,192 @@ #include "json_loader.h" -// Do not let jansson leak outside of this file. +// Do not let RapidJson leak outside of this file. #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wold-style-cast" -#include "jansson.h" +#include "rapidjson/document.h" +#include "rapidjson/error/en.h" +#include "rapidjson/istreamwrapper.h" #pragma GCC diagnostic pop namespace Json { -FileLoader::FileLoader(const std::string& file_path) { - json_error_t error; - json_ = json_load_file(file_path.c_str(), 0, &error); - if (!json_) { - throw Exception(fmt::format("json parsing error: {} line: {} column: {}", error.text, - error.line, error.column)); - } -} - -FileLoader::~FileLoader() { json_decref(json_); } +/** + * Implementation of Object. + */ +class ObjectImplBase : public Object { +public: + ObjectImplBase(const rapidjson::Value& value, const std::string& name) + : name_(name), value_(value) {} + + std::vector asObjectArray() const override { + if (!value_.IsArray()) { + throw Exception(fmt::format("'{}' is not an array", name_)); + } -StringLoader::StringLoader(const std::string& json) { - json_error_t error; - json_ = json_loads(json.c_str(), 0, &error); - if (!json_) { - throw Exception(fmt::format("json parsing error: {}", error.text)); + std::vector object_array; + object_array.reserve(value_.Size()); + for (auto& array_value : value_.GetArray()) { + object_array.emplace_back(new ObjectImplBase(array_value, name_ + " (array item)")); + } + return object_array; } -} - -StringLoader::~StringLoader() { json_decref(json_); } -Object::EmptyObject Object::empty_; - -Object::EmptyObject::EmptyObject() : json_(json_object()) {} - -Object::EmptyObject::~EmptyObject() { json_decref(json_); } - -std::vector Object::asObjectArray() const { - if (!json_is_array(json_)) { - throw Exception(fmt::format("'{}' is not an array", name_)); + bool getBoolean(const std::string& name) const override { + rapidjson::Value::ConstMemberIterator member_itr = value_.FindMember(name.c_str()); + if (member_itr == value_.MemberEnd() || !member_itr->value.IsBool()) { + throw Exception(fmt::format("key '{}' missing or not a boolean in '{}'", name, name_)); + } + return member_itr->value.GetBool(); } - std::vector object_array; - for (size_t i = 0; i < json_array_size(json_); i++) { - object_array.emplace_back(json_array_get(json_, i), name_ + " (array item)"); + bool getBoolean(const std::string& name, bool default_value) const override { + if (!value_.HasMember(name.c_str())) { + return default_value; + } else { + return getBoolean(name); + } } - return object_array; -} - -bool Object::getBoolean(const std::string& name) const { - json_t* boolean = json_object_get(json_, name.c_str()); - if (!boolean || !json_is_boolean(boolean)) { - throw Exception(fmt::format("key '{}' missing or not a boolean in '{}'", name, name_)); + int64_t getInteger(const std::string& name) const override { + rapidjson::Value::ConstMemberIterator member_itr = value_.FindMember(name.c_str()); + if (member_itr == value_.MemberEnd() || !member_itr->value.IsInt64()) { + throw Exception(fmt::format("key '{}' missing or not an integer in '{}'", name, name_)); + } + return member_itr->value.GetInt64(); } - return json_boolean_value(boolean); -} - -bool Object::getBoolean(const std::string& name, bool default_value) const { - if (!json_object_get(json_, name.c_str())) { - return default_value; - } else { - return getBoolean(name); + int64_t getInteger(const std::string& name, int64_t default_value) const override { + if (!value_.HasMember(name.c_str())) { + return default_value; + } else { + return getInteger(name); + } } -} -int64_t Object::getInteger(const std::string& name) const { - json_t* integer = json_object_get(json_, name.c_str()); - if (!integer || !json_is_integer(integer)) { - throw Exception(fmt::format("key '{}' missing or not an integer in '{}'", name, name_)); + ObjectPtr getObject(const std::string& name, bool allow_empty) const override { + rapidjson::Value::ConstMemberIterator member_itr = value_.FindMember(name.c_str()); + if (member_itr == value_.MemberEnd() && !allow_empty) { + throw Exception(fmt::format("key '{}' missing or not an integer in '{}'", name, name_)); + } else if (member_itr == value_.MemberEnd()) { + return ObjectPtr{new ObjectImplBase(empty_rapid_json_value_, name)}; + } + return ObjectPtr{new ObjectImplBase(member_itr->value, name)}; } - return json_integer_value(integer); -} + std::vector getObjectArray(const std::string& name) const override { + rapidjson::Value::ConstMemberIterator member_itr = value_.FindMember(name.c_str()); + if (member_itr == value_.MemberEnd() || !member_itr->value.IsArray()) { + throw Exception(fmt::format("key '{}' missing or not a array in '{}'", name, name_)); + } -int64_t Object::getInteger(const std::string& name, int64_t default_value) const { - if (!json_object_get(json_, name.c_str())) { - return default_value; - } else { - return getInteger(name); + std::vector object_array; + object_array.reserve(member_itr->value.Size()); + for (auto& array_value : member_itr->value.GetArray()) { + object_array.emplace_back(new ObjectImplBase(array_value, name + " (array item)")); + } + return object_array; } -} -Object Object::getObject(const std::string& name, bool allow_empty) const { - json_t* object = json_object_get(json_, name.c_str()); - if (!object && allow_empty) { - object = empty_.json_; + std::string getString(const std::string& name) const override { + rapidjson::Value::ConstMemberIterator member_itr = value_.FindMember(name.c_str()); + if (member_itr == value_.MemberEnd() || !member_itr->value.IsString()) { + throw Exception(fmt::format("key '{}' missing or not a string in '{}'", name, name_)); + } + return member_itr->value.GetString(); } - if (!object) { - throw Exception(fmt::format("key '{}' missing in '{}'", name, name_)); + std::string getString(const std::string& name, const std::string& default_value) const override { + if (!value_.HasMember(name.c_str())) { + return default_value; + } else { + return getString(name); + } } - return Object(object, name); -} - -std::vector Object::getObjectArray(const std::string& name) const { - json_t* array = json_object_get(json_, name.c_str()); - if (!array || !json_is_array(array)) { - throw Exception(fmt::format("key '{}' missing or not an array in '{}'", name, name_)); - } + std::vector getStringArray(const std::string& name) const override { + rapidjson::Value::ConstMemberIterator member_itr = value_.FindMember(name.c_str()); + if (member_itr == value_.MemberEnd() || !member_itr->value.IsArray()) { + throw Exception(fmt::format("key '{}' missing or not an array in '{}'", name, name_)); + } - std::vector object_array; - for (size_t i = 0; i < json_array_size(array); i++) { - object_array.emplace_back(json_array_get(array, i), name + " (array item)"); + std::vector string_array; + string_array.reserve(member_itr->value.Size()); + for (auto& array_value : member_itr->value.GetArray()) { + if (!array_value.IsString()) { + throw Exception(fmt::format("array '{}' does not contain all strings", name)); + } + string_array.push_back(array_value.GetString()); + } + return string_array; } - return object_array; -} - -std::string Object::getString(const std::string& name) const { - json_t* string = json_object_get(json_, name.c_str()); - if (!string || !json_is_string(string)) { - throw Exception(fmt::format("key '{}' missing or not a string in '{}'", name, name_)); + double getDouble(const std::string& name) const override { + rapidjson::Value::ConstMemberIterator member_itr = value_.FindMember(name.c_str()); + if (member_itr == value_.MemberEnd() || !member_itr->value.IsDouble()) { + throw Exception(fmt::format("key '{}' missing or not a double in '{}'", name, name_)); + } + return member_itr->value.GetDouble(); } - return json_string_value(string); -} - -std::string Object::getString(const std::string& name, const std::string& default_value) const { - if (!json_object_get(json_, name.c_str())) { - return default_value; - } else { - return getString(name); + double getDouble(const std::string& name, double default_value) const override { + if (!value_.HasMember(name.c_str())) { + return default_value; + } else { + return getDouble(name); + } } -} -std::vector Object::getStringArray(const std::string& name) const { - std::vector string_array; - for (Object& object : getObjectArray(name)) { - if (!json_is_string(object.json_)) { - throw Exception(fmt::format("array '{}' does not contain all strings", name)); - } else { - string_array.push_back(json_string_value(object.json_)); + void iterate(const ObjectCallback& callback) const override { + for (auto& member : value_.GetObject()) { + ObjectImplBase object(member.value, member.name.GetString()); + bool need_continue = callback(member.name.GetString(), object); + if (!need_continue) { + break; + } } } - return string_array; -} + bool hasObject(const std::string& name) const override { return value_.HasMember(name.c_str()); } -double Object::getDouble(const std::string& name) const { - json_t* real = json_object_get(json_, name.c_str()); - if (!real || !json_is_real(real)) { - throw Exception(fmt::format("key '{}' missing or not a double in '{}'", name, name_)); - } +private: + const std::string name_; + const rapidjson::Value& value_; - return json_real_value(real); -} + static const rapidjson::Value empty_rapid_json_value_; +}; -double Object::getDouble(const std::string& name, double default_value) const { - if (!json_object_get(json_, name.c_str())) { - return default_value; - } else { - return getDouble(name); - } -} +const rapidjson::Value ObjectImplBase::empty_rapid_json_value_; -void Object::iterate(const ObjectCallback& callback) { - const char* key; - json_t* value; +/** + * Holds the root Object reference. + */ +class ObjectImplRoot : public ObjectImplBase { +public: + ObjectImplRoot(rapidjson::Document&& document) + : ObjectImplBase(root_, "root"), root_(std::move(document)) {} - json_object_foreach(json_, key, value) { - Object object_value(value, "root"); - std::string object_key(key); +private: + rapidjson::Document root_; +}; - bool need_continue = callback(object_key, object_value); - if (!need_continue) { - break; - } +ObjectPtr Factory::LoadFromFile(const std::string& file_path) { + rapidjson::Document document; + std::fstream file_stream(file_path); + rapidjson::IStreamWrapper stream_wrapper(file_stream); + if (document.ParseStream(stream_wrapper).HasParseError()) { + throw Exception(fmt::format("Error(offset {}): {}\n", document.GetErrorOffset(), + GetParseError_En(document.GetParseError()))); } + return ObjectPtr{new ObjectImplRoot(std::move(document))}; } -bool Object::hasObject(const std::string& name) const { - return json_object_get(json_, name.c_str()) != nullptr; +ObjectPtr Factory::LoadFromString(const std::string& json) { + rapidjson::Document document; + if (document.Parse<0>(json.c_str()).HasParseError()) { + throw Exception(fmt::format("Error(offset {}): {}\n", document.GetErrorOffset(), + GetParseError_En(document.GetParseError()))); + } + return ObjectPtr{new ObjectImplRoot(std::move(document))}; } } // Json diff --git a/source/common/json/json_loader.h b/source/common/json/json_loader.h index 95d435f2aa757..5e905d8b41822 100644 --- a/source/common/json/json_loader.h +++ b/source/common/json/json_loader.h @@ -1,165 +1,20 @@ #pragma once -#include "envoy/common/exception.h" - -#include "common/common/non_copyable.h" - -struct json_t; +#include "envoy/json/json_object.h" namespace Json { -/** - * Exception thrown when a JSON error occurs. - */ -class Exception : public EnvoyException { -public: - Exception(const std::string& message) : EnvoyException(message) {} -}; - -class Object; -// @return false if immediate exit from iteration required. -typedef std::function ObjectCallback; - -/** - * Wraps an individual JSON node. Nodes are only valid while the Loader root object is alive. - */ -class Object { +class Factory { public: - Object(json_t* json, const std::string& name) : json_(json), name_(name) {} - - /** - * Convert a generic object into an array of objects. This is useful for dealing with arrays - * of arrays. - * @return std::vector the converted object. - */ - std::vector asObjectArray() const; - - /** - * Get a boolean value by name. - * @param name supplies the key name. - * @return bool the value. - */ - bool getBoolean(const std::string& name) const; - - /** - * Get a boolean value by name. - * @param name supplies the key name. - * @param default_value supplies the value to return if the name does not exist. - * @return bool the value. - */ - bool getBoolean(const std::string& name, bool default_value) const; - - /** - * Get an integer value by name. - * @param name supplies the key name. - * @return int64_t the value. - */ - int64_t getInteger(const std::string& name) const; - - /** - * Get an integer value by name or return a default if name does not exist. - * @param name supplies the key name. - * @param default_value supplies the value to return if name does not exist. - * @return int64_t the value. - */ - int64_t getInteger(const std::string& name, int64_t default_value) const; - - /** - * Get a sub-object by name. - * @param name supplies the key name. - * @param allow_empty supplies whether to return an empty object if the key does not exist. - * @return Object the sub-object. - */ - Object getObject(const std::string& name, bool allow_empty = false) const; - - /** - * Get an array by name. - * @param name supplies the key name. - * @return std::vector the array of JSON objects. - */ - std::vector getObjectArray(const std::string& name) const; - - /** - * Get a string value by name. - * @param name supplies the key name. - * @return std::string the value. + /* + * Constructs a Json Object from a File. */ - std::string getString(const std::string& name) const; + static ObjectPtr LoadFromFile(const std::string& file_path); - /** - * Get a string value by name or return a default if name does not exist. - * @param name supplies the key name. - * @param default_value supplies the value to return if name does not exist. - * @return std::string the value. + /* + * Constructs a Json Object from a String. */ - std::string getString(const std::string& name, const std::string& default_value) const; - - /** - * Get a string array by name. - * @param name supplies the key name. - * @return std::vector the array of strings. - */ - std::vector getStringArray(const std::string& name) const; - - /** - * Get a double value by name. - * @param name supplies the key name. - * @return double the value. - */ - double getDouble(const std::string& name) const; - - /** - * Get a double value by name. - * @param name supplies the key name. - * @param default_value supplies the value to return if name does not exist. - * @return double the value. - */ - double getDouble(const std::string& name, double default_value) const; - - /** - * Iterate Object and call callback on key-value pairs - */ - void iterate(const ObjectCallback& callback); - - /** - * @return TRUE if the object contains an element. - * @param name supplies the key name to lookup. - */ - bool hasObject(const std::string& name) const; - -protected: - Object() : name_("root") {} - - json_t* json_; - std::string name_; - -private: - struct EmptyObject { - EmptyObject(); - ~EmptyObject(); - - json_t* json_; - }; - - static EmptyObject empty_; -}; - -/** - * Loads a JSON file into memory. - */ -class FileLoader : NonCopyable, public Object { -public: - FileLoader(const std::string& file_path); - ~FileLoader(); -}; - -/** - * Loads JSON from a string. - */ -class StringLoader : NonCopyable, public Object { -public: - StringLoader(const std::string& json); - ~StringLoader(); + static ObjectPtr LoadFromString(const std::string& json); }; } // Json diff --git a/source/common/mongo/utility.cc b/source/common/mongo/utility.cc index aa8f06e724e06..b5e18b8d6822b 100644 --- a/source/common/mongo/utility.cc +++ b/source/common/mongo/utility.cc @@ -66,8 +66,8 @@ std::string QueryMessageInfo::parseCallingFunction(const QueryMessage& query) { std::string QueryMessageInfo::parseCallingFunctionJson(const std::string& json_string) { try { - Json::StringLoader json(json_string); - return json.getString("callingFunction"); + Json::ObjectPtr json = Json::Factory::LoadFromString(json_string); + return json->getString("callingFunction"); } catch (Json::Exception&) { return ""; } diff --git a/source/common/router/config_impl.cc b/source/common/router/config_impl.cc index 114cdd9724e79..6f1ec9440bed7 100644 --- a/source/common/router/config_impl.cc +++ b/source/common/router/config_impl.cc @@ -24,8 +24,8 @@ RetryPolicyImpl::RetryPolicyImpl(const Json::Object& config) { return; } - num_retries_ = config.getObject("retry_policy").getInteger("num_retries", 1); - retry_on_ = RetryStateImpl::parseRetryOn(config.getObject("retry_policy").getString("retry_on")); + num_retries_ = config.getObject("retry_policy")->getInteger("num_retries", 1); + retry_on_ = RetryStateImpl::parseRetryOn(config.getObject("retry_policy")->getString("retry_on")); } ShadowPolicyImpl::ShadowPolicyImpl(const Json::Object& config) { @@ -33,8 +33,8 @@ ShadowPolicyImpl::ShadowPolicyImpl(const Json::Object& config) { return; } - cluster_ = config.getObject("shadow").getString("cluster"); - runtime_key_ = config.getObject("shadow").getString("runtime_key", ""); + cluster_ = config.getObject("shadow")->getString("cluster"); + runtime_key_ = config.getObject("shadow")->getString("runtime_key", ""); } Upstream::ResourcePriority ConfigUtility::parsePriority(const Json::Object& config) { @@ -88,11 +88,11 @@ RouteEntryImplBase::RouteEntryImplBase(const VirtualHost& vhost, const Json::Obj } if (route.hasObject("headers")) { - std::vector config_headers = route.getObjectArray("headers"); - for (const Json::Object& header_map : config_headers) { + std::vector config_headers = route.getObjectArray("headers"); + for (const Json::ObjectPtr& header_map : config_headers) { // allow header value to be empty, allows matching to be only based on header presence. - config_headers_.emplace_back(Http::LowerCaseString(header_map.getString("name")), - header_map.getString("value", EMPTY_STRING)); + config_headers_.emplace_back(Http::LowerCaseString(header_map->getString("name")), + header_map->getString("value", EMPTY_STRING)); } } } @@ -125,8 +125,8 @@ RouteEntryImplBase::loadRuntimeData(const Json::Object& route) { Optional runtime; if (route.hasObject("runtime")) { RuntimeData data; - data.key_ = route.getObject("runtime").getString("key"); - data.default_ = route.getObject("runtime").getInteger("default"); + data.key_ = route.getObject("runtime")->getString("key"); + data.default_ = route.getObject("runtime")->getInteger("default"); runtime.value(data); } @@ -226,11 +226,11 @@ VirtualHost::VirtualHost(const Json::Object& virtual_host, Runtime::Loader& runt throw EnvoyException(fmt::format("unknown 'require_ssl' type '{}'", require_ssl)); } - for (const Json::Object& route : virtual_host.getObjectArray("routes")) { - if (route.hasObject("prefix")) { - routes_.emplace_back(new PrefixRouteEntryImpl(*this, route, runtime)); - } else if (route.hasObject("path")) { - routes_.emplace_back(new PathRouteEntryImpl(*this, route, runtime)); + for (const Json::ObjectPtr& route : virtual_host.getObjectArray("routes")) { + if (route->hasObject("prefix")) { + routes_.emplace_back(new PrefixRouteEntryImpl(*this, *route, runtime)); + } else if (route->hasObject("path")) { + routes_.emplace_back(new PathRouteEntryImpl(*this, *route, runtime)); } else { throw EnvoyException("unknown routing configuration type"); } @@ -251,8 +251,8 @@ VirtualHost::VirtualHost(const Json::Object& virtual_host, Runtime::Loader& runt } if (virtual_host.hasObject("virtual_clusters")) { - for (const Json::Object& virtual_cluster : virtual_host.getObjectArray("virtual_clusters")) { - virtual_clusters_.push_back(VirtualClusterEntry(virtual_cluster)); + for (const Json::ObjectPtr& virtual_cluster : virtual_host.getObjectArray("virtual_clusters")) { + virtual_clusters_.push_back(VirtualClusterEntry(*virtual_cluster)); } } } @@ -279,11 +279,11 @@ VirtualHost::VirtualClusterEntry::VirtualClusterEntry(const Json::Object& virtua RouteMatcher::RouteMatcher(const Json::Object& config, Runtime::Loader& runtime, Upstream::ClusterManager& cm) { - for (const Json::Object& virtual_host_config : config.getObjectArray("virtual_hosts")) { - VirtualHostPtr virtual_host(new VirtualHost(virtual_host_config, runtime, cm)); + for (const Json::ObjectPtr& virtual_host_config : config.getObjectArray("virtual_hosts")) { + VirtualHostPtr virtual_host(new VirtualHost(*virtual_host_config, runtime, cm)); uses_runtime_ |= virtual_host->usesRuntime(); - for (const std::string& domain : virtual_host_config.getStringArray("domains")) { + for (const std::string& domain : virtual_host_config->getStringArray("domains")) { if ("*" == domain) { if (default_virtual_host_) { throw EnvoyException(fmt::format("Only a single single wildcard domain is permitted")); @@ -395,9 +395,9 @@ ConfigImpl::ConfigImpl(const Json::Object& config, Runtime::Loader& runtime, } if (config.hasObject("response_headers_to_add")) { - for (const Json::Object& header : config.getObjectArray("response_headers_to_add")) { + for (const Json::ObjectPtr& header : config.getObjectArray("response_headers_to_add")) { response_headers_to_add_.push_back( - {Http::LowerCaseString(header.getString("key")), header.getString("value")}); + {Http::LowerCaseString(header->getString("key")), header->getString("value")}); } } diff --git a/source/common/router/config_impl.h b/source/common/router/config_impl.h index 1f04f98895f15..7fe3065b0ccda 100644 --- a/source/common/router/config_impl.h +++ b/source/common/router/config_impl.h @@ -142,8 +142,8 @@ class RetryPolicyImpl : public RetryPolicy { class RateLimitPolicyImpl : public RateLimitPolicy { public: RateLimitPolicyImpl(const Json::Object& config) - : do_global_limiting_(config.getObject("rate_limit", true).getBoolean("global", false)), - route_key_(config.getObject("rate_limit", true).getString("route_key", "")) {} + : do_global_limiting_(config.getObject("rate_limit", true)->getBoolean("global", false)), + route_key_(config.getObject("rate_limit", true)->getString("route_key", "")) {} // Router::RateLimitPolicy bool doGlobalLimiting() const override { return do_global_limiting_; } diff --git a/source/common/upstream/cluster_manager_impl.cc b/source/common/upstream/cluster_manager_impl.cc index 36a63cb39b780..cfa0cefb5465f 100644 --- a/source/common/upstream/cluster_manager_impl.cc +++ b/source/common/upstream/cluster_manager_impl.cc @@ -24,23 +24,23 @@ ClusterManagerImpl::ClusterManagerImpl(const Json::Object& config, Stats::Store& const std::string& local_address) : runtime_(runtime), tls_(tls), stats_(stats), thread_local_slot_(tls.allocateSlot()) { - std::vector clusters = config.getObjectArray("clusters"); + std::vector clusters = config.getObjectArray("clusters"); pending_cluster_init_ = clusters.size(); if (config.hasObject("sds")) { pending_cluster_init_++; - loadCluster(config.getObject("sds").getObject("cluster"), stats, dns_resolver, + loadCluster(*config.getObject("sds")->getObject("cluster"), stats, dns_resolver, ssl_context_manager, runtime, random); SdsConfig sds_config{ - local_zone_name, config.getObject("sds").getObject("cluster").getString("name"), - std::chrono::milliseconds(config.getObject("sds").getInteger("refresh_delay_ms"))}; + local_zone_name, config.getObject("sds")->getObject("cluster")->getString("name"), + std::chrono::milliseconds(config.getObject("sds")->getInteger("refresh_delay_ms"))}; sds_config_.value(sds_config); } - for (const Json::Object& cluster : clusters) { - loadCluster(cluster, stats, dns_resolver, ssl_context_manager, runtime, random); + for (const Json::ObjectPtr& cluster : clusters) { + loadCluster(*cluster, stats, dns_resolver, ssl_context_manager, runtime, random); } Optional local_cluster_name; @@ -127,14 +127,14 @@ void ClusterManagerImpl::loadCluster(const Json::Object& cluster, Stats::Store& }); if (cluster.hasObject("health_check")) { - Json::Object health_check_config = cluster.getObject("health_check"); - std::string hc_type = health_check_config.getString("type"); + Json::ObjectPtr health_check_config = cluster.getObject("health_check"); + std::string hc_type = health_check_config->getString("type"); if (hc_type == "http") { new_cluster->setHealthChecker(HealthCheckerPtr{new ProdHttpHealthCheckerImpl( - *new_cluster, health_check_config, dns_resolver.dispatcher(), stats, runtime, random)}); + *new_cluster, *health_check_config, dns_resolver.dispatcher(), stats, runtime, random)}); } else if (hc_type == "tcp") { new_cluster->setHealthChecker(HealthCheckerPtr{new TcpHealthCheckerImpl( - *new_cluster, health_check_config, dns_resolver.dispatcher(), stats, runtime, random)}); + *new_cluster, *health_check_config, dns_resolver.dispatcher(), stats, runtime, random)}); } else { throw EnvoyException(fmt::format("cluster: unknown health check type '{}'", hc_type)); } diff --git a/source/common/upstream/health_checker_impl.cc b/source/common/upstream/health_checker_impl.cc index 211b7fb10348a..241edaa6ec84a 100644 --- a/source/common/upstream/health_checker_impl.cc +++ b/source/common/upstream/health_checker_impl.cc @@ -324,11 +324,11 @@ ProdHttpHealthCheckerImpl::createCodecClient(Upstream::Host::CreateConnectionDat } TcpHealthCheckMatcher::MatchSegments -TcpHealthCheckMatcher::loadJsonBytes(const std::vector& byte_array) { +TcpHealthCheckMatcher::loadJsonBytes(const std::vector& byte_array) { MatchSegments result; - for (const Json::Object& entry : byte_array) { - std::string hex_string = entry.getString("binary"); + for (const Json::ObjectPtr& entry : byte_array) { + std::string hex_string = entry->getString("binary"); result.push_back(Hex::decode(hex_string)); } diff --git a/source/common/upstream/health_checker_impl.h b/source/common/upstream/health_checker_impl.h index 83be6bc738918..35c60cbf08e9d 100644 --- a/source/common/upstream/health_checker_impl.h +++ b/source/common/upstream/health_checker_impl.h @@ -216,7 +216,7 @@ class TcpHealthCheckMatcher { public: typedef std::list> MatchSegments; - static MatchSegments loadJsonBytes(const std::vector& byte_array); + static MatchSegments loadJsonBytes(const std::vector& byte_array); static bool match(const MatchSegments& expected, const Buffer::Instance& buffer); }; diff --git a/source/common/upstream/logical_dns_cluster.cc b/source/common/upstream/logical_dns_cluster.cc index d88a04844ff25..4d9c2ba37679d 100644 --- a/source/common/upstream/logical_dns_cluster.cc +++ b/source/common/upstream/logical_dns_cluster.cc @@ -13,12 +13,12 @@ LogicalDnsCluster::LogicalDnsCluster(const Json::Object& config, Runtime::Loader tls_(tls), tls_slot_(tls.allocateSlot()), resolve_timer_(dns_resolver.dispatcher().createTimer([this]() -> void { startResolve(); })) { - std::vector hosts_json = config.getObjectArray("hosts"); + std::vector hosts_json = config.getObjectArray("hosts"); if (hosts_json.size() != 1) { throw EnvoyException("logical_dns clusters must have a single host"); } - dns_url_ = hosts_json[0].getString("url"); + dns_url_ = hosts_json[0]->getString("url"); Network::Utility::hostFromUrl(dns_url_); Network::Utility::portFromUrl(dns_url_); startResolve(); diff --git a/source/common/upstream/sds.cc b/source/common/upstream/sds.cc index ee687072033e0..511ba48c71551 100644 --- a/source/common/upstream/sds.cc +++ b/source/common/upstream/sds.cc @@ -50,20 +50,20 @@ void SdsClusterImpl::onFailure(Http::AsyncClient::FailureReason) { } void SdsClusterImpl::parseSdsResponse(Http::Message& response) { - Json::StringLoader json(response.bodyAsString()); + Json::ObjectPtr json = Json::Factory::LoadFromString(response.bodyAsString()); std::vector new_hosts; - for (const Json::Object& host : json.getObjectArray("hosts")) { + for (const Json::ObjectPtr& host : json->getObjectArray("hosts")) { bool canary = false; uint32_t weight = 1; std::string zone = ""; - if (host.hasObject("tags")) { - canary = host.getObject("tags").getBoolean("canary", canary); - weight = host.getObject("tags").getInteger("load_balancing_weight", weight); - zone = host.getObject("tags").getString("az", zone); + if (host->hasObject("tags")) { + canary = host->getObject("tags")->getBoolean("canary", canary); + weight = host->getObject("tags")->getInteger("load_balancing_weight", weight); + zone = host->getObject("tags")->getString("az", zone); } new_hosts.emplace_back(new HostImpl( - *this, Network::Utility::urlForTcp(host.getString("ip_address"), host.getInteger("port")), + *this, Network::Utility::urlForTcp(host->getString("ip_address"), host->getInteger("port")), canary, weight, zone)); } diff --git a/source/common/upstream/upstream_impl.cc b/source/common/upstream/upstream_impl.cc index 38f9175ecb3f9..73cda74c7116b 100644 --- a/source/common/upstream/upstream_impl.cc +++ b/source/common/upstream/upstream_impl.cc @@ -77,7 +77,7 @@ ClusterImplBase::ClusterImplBase(const Json::Object& config, Runtime::Loader& ru ssl_ctx_ = nullptr; if (config.hasObject("ssl_context")) { - Ssl::ContextConfigImpl context_config(config.getObject("ssl_context")); + Ssl::ContextConfigImpl context_config(*config.getObject("ssl_context")); ssl_ctx_ = &ssl_context_manager.createSslClientContext(stat_prefix_, stats, context_config); } } @@ -185,11 +185,11 @@ ResourceManagerImplPtr ClusterImplBase::ResourceManagers::load(const Json::Objec uint64_t max_retries = 3; std::string runtime_prefix = fmt::format("circuit_breakers.{}.{}.", cluster_name, priority); - Json::Object settings = config.getObject("circuit_breakers", true).getObject(priority, true); - max_connections = settings.getInteger("max_connections", max_connections); - max_pending_requests = settings.getInteger("max_pending_requests", max_pending_requests); - max_requests = settings.getInteger("max_requests", max_requests); - max_retries = settings.getInteger("max_retries", max_retries); + Json::ObjectPtr settings = config.getObject("circuit_breakers", true)->getObject(priority, true); + max_connections = settings->getInteger("max_connections", max_connections); + max_pending_requests = settings->getInteger("max_pending_requests", max_pending_requests); + max_requests = settings->getInteger("max_requests", max_requests); + max_retries = settings->getInteger("max_retries", max_retries); return ResourceManagerImplPtr{new ResourceManagerImpl( runtime, runtime_prefix, max_connections, max_pending_requests, max_requests, max_retries)}; @@ -198,10 +198,10 @@ ResourceManagerImplPtr ClusterImplBase::ResourceManagers::load(const Json::Objec StaticClusterImpl::StaticClusterImpl(const Json::Object& config, Runtime::Loader& runtime, Stats::Store& stats, Ssl::ContextManager& ssl_context_manager) : ClusterImplBase(config, runtime, stats, ssl_context_manager) { - std::vector hosts_json = config.getObjectArray("hosts"); + std::vector hosts_json = config.getObjectArray("hosts"); HostVectorPtr new_hosts(new std::vector()); - for (Json::Object& host : hosts_json) { - std::string url = host.getString("url"); + for (Json::ObjectPtr& host : hosts_json) { + std::string url = host->getString("url"); // resolve the URL to make sure it's valid Network::Utility::resolve(url); new_hosts->emplace_back(HostPtr{new HostImpl(*this, url, false, 1, "")}); @@ -293,8 +293,8 @@ StrictDnsClusterImpl::StrictDnsClusterImpl(const Json::Object& config, Runtime:: : BaseDynamicClusterImpl(config, runtime, stats, ssl_context_manager), dns_resolver_(dns_resolver), dns_refresh_rate_ms_(std::chrono::milliseconds( config.getInteger("dns_refresh_rate_ms", 5000))) { - for (Json::Object& host : config.getObjectArray("hosts")) { - resolve_targets_.emplace_back(new ResolveTarget(*this, host.getString("url"))); + for (Json::ObjectPtr& host : config.getObjectArray("hosts")) { + resolve_targets_.emplace_back(new ResolveTarget(*this, host->getString("url"))); } } diff --git a/source/server/config/network/http_connection_manager.cc b/source/server/config/network/http_connection_manager.cc index 5e5d7d667f303..5bf816c80d1d8 100644 --- a/source/server/config/network/http_connection_manager.cc +++ b/source/server/config/network/http_connection_manager.cc @@ -73,7 +73,7 @@ HttpConnectionManagerConfig::HttpConnectionManagerConfig(const Json::Object& con : server_(server), stats_prefix_(fmt::format("http.{}.", config.getString("stat_prefix"))), stats_(Http::ConnectionManagerImpl::generateStats(stats_prefix_, server.stats())), codec_options_(Http::Utility::parseCodecOptions(config)), - route_config_(new Router::ConfigImpl(config.getObject("route_config"), server.runtime(), + route_config_(new Router::ConfigImpl(*config.getObject("route_config"), server.runtime(), server.clusterManager())), drain_timeout_(config.getInteger("drain_timeout_ms", 5000)), generate_request_id_(config.getBoolean("generate_request_id", true)), @@ -88,9 +88,9 @@ HttpConnectionManagerConfig::HttpConnectionManagerConfig(const Json::Object& con } if (config.hasObject("tracing")) { - const std::string operation_name = config.getObject("tracing").getString("operation_name"); + const std::string operation_name = config.getObject("tracing")->getString("operation_name"); - std::string tracing_type = config.getObject("tracing").getString("type", "all"); + std::string tracing_type = config.getObject("tracing")->getString("type", "all"); Http::TracingType type; if (tracing_type == "all") { type = Http::TracingType::All; @@ -108,9 +108,9 @@ HttpConnectionManagerConfig::HttpConnectionManagerConfig(const Json::Object& con } if (config.hasObject("access_log")) { - for (Json::Object& access_log : config.getObjectArray("access_log")) { + for (Json::ObjectPtr& access_log : config.getObjectArray("access_log")) { Http::AccessLog::InstancePtr current_access_log = Http::AccessLog::InstanceImpl::fromJson( - access_log, server.api(), server.dispatcher(), server.accessLogLock(), server.stats(), + *access_log, server.api(), server.dispatcher(), server.accessLogLock(), server.stats(), server.runtime()); server.accessLogManager().registerAccessLog(current_access_log); access_logs_.push_back(current_access_log); @@ -130,11 +130,11 @@ HttpConnectionManagerConfig::HttpConnectionManagerConfig(const Json::Object& con throw EnvoyException(fmt::format("invalid connection manager codec '{}'", codec_type)); } - std::vector filters = config.getObjectArray("filters"); + std::vector filters = config.getObjectArray("filters"); for (size_t i = 0; i < filters.size(); i++) { - std::string string_type = filters[i].getString("type"); - std::string string_name = filters[i].getString("name"); - Json::Object config = filters[i].getObject("config"); + std::string string_type = filters[i]->getString("type"); + std::string string_name = filters[i]->getString("name"); + Json::ObjectPtr config_object = filters[i]->getObject("config"); log().info(" filter #{}", i); log().info(" type: {}", string_type); @@ -144,7 +144,7 @@ HttpConnectionManagerConfig::HttpConnectionManagerConfig(const Json::Object& con bool found_filter = false; for (HttpFilterConfigFactory* factory : filterConfigFactories()) { HttpFilterFactoryCb callback = - factory->tryCreateFilterFactory(type, string_name, config, stats_prefix_, server); + factory->tryCreateFilterFactory(type, string_name, *config_object, stats_prefix_, server); if (callback) { filter_factories_.push_back(callback); found_filter = true; diff --git a/source/server/configuration_impl.cc b/source/server/configuration_impl.cc index ca07f5878984e..39a7520be8973 100644 --- a/source/server/configuration_impl.cc +++ b/source/server/configuration_impl.cc @@ -26,41 +26,41 @@ void FilterChainUtility::buildFilterChain(Network::FilterManager& filter_manager MainImpl::MainImpl(Server::Instance& server) : server_(server) {} void MainImpl::initialize(const std::string& file_path) { - Json::FileLoader loader(file_path); + Json::ObjectPtr loader = Json::Factory::LoadFromFile(file_path); cluster_manager_.reset(new Upstream::ProdClusterManagerImpl( - loader.getObject("cluster_manager"), server_.stats(), server_.threadLocal(), + *loader->getObject("cluster_manager"), server_.stats(), server_.threadLocal(), server_.dnsResolver(), server_.sslContextManager(), server_.runtime(), server_.random(), server_.options().serviceZone(), server_.getLocalAddress())); - std::vector listeners = loader.getObjectArray("listeners"); + std::vector listeners = loader->getObjectArray("listeners"); log().info("loading {} listener(s)", listeners.size()); for (size_t i = 0; i < listeners.size(); i++) { log().info("listener #{}:", i); listeners_.emplace_back( - Server::Configuration::ListenerPtr{new ListenerConfig(*this, listeners[i])}); + Server::Configuration::ListenerPtr{new ListenerConfig(*this, *listeners[i])}); } - if (loader.hasObject("statsd_local_udp_port")) { - statsd_udp_port_.value(loader.getInteger("statsd_local_udp_port")); + if (loader->hasObject("statsd_local_udp_port")) { + statsd_udp_port_.value(loader->getInteger("statsd_local_udp_port")); } - if (loader.hasObject("statsd_tcp_cluster_name")) { - statsd_tcp_cluster_name_.value(loader.getString("statsd_tcp_cluster_name")); + if (loader->hasObject("statsd_tcp_cluster_name")) { + statsd_tcp_cluster_name_.value(loader->getString("statsd_tcp_cluster_name")); } - if (loader.hasObject("tracing")) { - initializeTracers(loader.getObject("tracing")); + if (loader->hasObject("tracing")) { + initializeTracers(*loader->getObject("tracing")); } else { http_tracer_.reset(new Tracing::HttpNullTracer()); } - if (loader.hasObject("rate_limit_service")) { - Json::Object rate_limit_service_config = loader.getObject("rate_limit_service"); - std::string type = rate_limit_service_config.getString("type"); + if (loader->hasObject("rate_limit_service")) { + Json::ObjectPtr rate_limit_service_config = loader->getObject("rate_limit_service"); + std::string type = rate_limit_service_config->getString("type"); if (type == "grpc_service") { ratelimit_client_factory_.reset(new RateLimit::GrpcFactoryImpl( - rate_limit_service_config.getObject("config"), *cluster_manager_, server_.stats())); + *rate_limit_service_config->getObject("config"), *cluster_manager_, server_.stats())); } else { throw EnvoyException(fmt::format("unknown rate limit service type '{}'", type)); } @@ -76,20 +76,20 @@ void MainImpl::initializeTracers(const Json::Object& tracing_configuration_) { if (tracing_configuration_.hasObject("http")) { http_tracer_.reset(new Tracing::HttpTracerImpl(server_.runtime(), server_.stats())); - Json::Object http_tracer_config = tracing_configuration_.getObject("http"); + Json::ObjectPtr http_tracer_config = tracing_configuration_.getObject("http"); - if (http_tracer_config.hasObject("sinks")) { - std::vector sinks = http_tracer_config.getObjectArray("sinks"); + if (http_tracer_config->hasObject("sinks")) { + std::vector sinks = http_tracer_config->getObjectArray("sinks"); log().info(fmt::format(" loading {} http sink(s):", sinks.size())); - for (const Json::Object& sink : sinks) { - std::string type = sink.getString("type"); + for (const Json::ObjectPtr& sink : sinks) { + std::string type = sink->getString("type"); log().info(fmt::format(" loading {}", type)); if (type == "lightstep") { ::Runtime::RandomGenerator& rand = server_.random(); std::unique_ptr opts(new lightstep::TracerOptions()); - opts->access_token = server_.api().fileReadToEnd(sink.getString("access_token_file")); + opts->access_token = server_.api().fileReadToEnd(sink->getString("access_token_file")); StringUtil::rtrim(opts->access_token); opts->tracer_attributes["lightstep.component_name"] = @@ -97,7 +97,7 @@ void MainImpl::initializeTracers(const Json::Object& tracing_configuration_) { opts->guid_generator = [&rand]() { return rand.random(); }; http_tracer_->addSink(Tracing::HttpSinkPtr{new Tracing::LightStepSink( - sink.getObject("config"), *cluster_manager_, server_.stats(), + *sink->getObject("config"), *cluster_manager_, server_.stats(), server_.options().serviceNodeName(), server_.threadLocal(), server_.runtime(), std::move(opts))}); } else { @@ -117,7 +117,7 @@ MainImpl::ListenerConfig::ListenerConfig(MainImpl& parent, Json::Object& json) log().info(" port={}", port_); if (json.hasObject("ssl_context")) { - Ssl::ContextConfigImpl context_config(json.getObject("ssl_context")); + Ssl::ContextConfigImpl context_config(*json.getObject("ssl_context")); ssl_context_ = &parent_.server_.sslContextManager().createSslServerContext( fmt::format("listener.{}.", port_), parent_.server_.stats(), context_config); } @@ -126,11 +126,11 @@ MainImpl::ListenerConfig::ListenerConfig(MainImpl& parent, Json::Object& json) use_proxy_proto_ = json.getBoolean("use_proxy_proto"); } - std::vector filters = json.getObjectArray("filters"); + std::vector filters = json.getObjectArray("filters"); for (size_t i = 0; i < filters.size(); i++) { - std::string string_type = filters[i].getString("type"); - std::string string_name = filters[i].getString("name"); - Json::Object config = filters[i].getObject("config"); + std::string string_type = filters[i]->getString("type"); + std::string string_name = filters[i]->getString("name"); + Json::ObjectPtr config = filters[i]->getObject("config"); log().info(" filter #{}:", i); log().info(" type: {}", string_type); log().info(" name: {}", string_name); @@ -151,7 +151,7 @@ MainImpl::ListenerConfig::ListenerConfig(MainImpl& parent, Json::Object& json) bool found_filter = false; for (NetworkFilterConfigFactory* config_factory : filterConfigFactories()) { NetworkFilterFactoryCb callback = - config_factory->tryCreateFilterFactory(type, string_name, config, parent_.server_); + config_factory->tryCreateFilterFactory(type, string_name, *config, parent_.server_); if (callback) { filter_factories_.push_back(callback); found_filter = true; @@ -171,21 +171,21 @@ void MainImpl::ListenerConfig::createFilterChain(Network::Connection& connection } InitialImpl::InitialImpl(const std::string& file_path) { - Json::FileLoader loader(file_path); - Json::Object admin = loader.getObject("admin"); - admin_.access_log_path_ = admin.getString("access_log_path"); - admin_.port_ = admin.getInteger("port"); + Json::ObjectPtr loader = Json::Factory::LoadFromFile(file_path); + Json::ObjectPtr admin = loader->getObject("admin"); + admin_.access_log_path_ = admin->getString("access_log_path"); + admin_.port_ = admin->getInteger("port"); - if (loader.hasObject("flags_path")) { - flags_path_.value(loader.getString("flags_path")); + if (loader->hasObject("flags_path")) { + flags_path_.value(loader->getString("flags_path")); } - if (loader.hasObject("runtime")) { + if (loader->hasObject("runtime")) { runtime_.reset(new RuntimeImpl()); - runtime_->symlink_root_ = loader.getObject("runtime").getString("symlink_root"); - runtime_->subdirectory_ = loader.getObject("runtime").getString("subdirectory"); + runtime_->symlink_root_ = loader->getObject("runtime")->getString("symlink_root"); + runtime_->subdirectory_ = loader->getObject("runtime")->getString("subdirectory"); runtime_->override_subdirectory_ = - loader.getObject("runtime").getString("override_subdirectory", ""); + loader->getObject("runtime")->getString("override_subdirectory", ""); } } diff --git a/test/common/dynamo/dynamo_request_parser_test.cc b/test/common/dynamo/dynamo_request_parser_test.cc index 651eb0b55cae1..7868c4b650b8e 100644 --- a/test/common/dynamo/dynamo_request_parser_test.cc +++ b/test/common/dynamo/dynamo_request_parser_test.cc @@ -46,42 +46,44 @@ TEST(DynamoRequestParser, parseTableNameSingleOperation) { } } )EOF"; - Json::StringLoader json_data(json_string); + Json::ObjectPtr json_data = Json::Factory::LoadFromString(json_string); // Supported operation for (const std::string& operation : supported_single_operations) { - EXPECT_EQ("Pets", RequestParser::parseTable(operation, json_data).table_name); + EXPECT_EQ("Pets", RequestParser::parseTable(operation, *json_data).table_name); } // Not supported operation - EXPECT_EQ("", RequestParser::parseTable("NotSupportedOperation", json_data).table_name); + EXPECT_EQ("", RequestParser::parseTable("NotSupportedOperation", *json_data).table_name); } { - Json::StringLoader json_data("{\"TableName\":\"Pets\"}"); - EXPECT_EQ("Pets", RequestParser::parseTable("GetItem", json_data).table_name); + Json::ObjectPtr json_data = Json::Factory::LoadFromString("{\"TableName\":\"Pets\"}"); + EXPECT_EQ("Pets", RequestParser::parseTable("GetItem", *json_data).table_name); } } TEST(DynamoRequestParser, parseErrorType) { - { EXPECT_THROW(RequestParser::parseErrorType(Json::StringLoader("{test")), Json::Exception); } - { - EXPECT_EQ("ResourceNotFoundException", - RequestParser::parseErrorType(Json::StringLoader( - "{\"__type\":\"com.amazonaws.dynamodb.v20120810#ResourceNotFoundException\"}"))); + EXPECT_EQ( + "ResourceNotFoundException", + RequestParser::parseErrorType( + *Json::Factory::LoadFromString( + "{\"__type\":\"com.amazonaws.dynamodb.v20120810#ResourceNotFoundException\"}"))); } { - EXPECT_EQ("ResourceNotFoundException", - RequestParser::parseErrorType(Json::StringLoader( - "{\"__type\":\"com.amazonaws.dynamodb.v20120810#ResourceNotFoundException\"," - "\"message\":\"Requested resource not found: Table: tablename not found\"}"))); + EXPECT_EQ( + "ResourceNotFoundException", + RequestParser::parseErrorType( + *Json::Factory::LoadFromString( + "{\"__type\":\"com.amazonaws.dynamodb.v20120810#ResourceNotFoundException\"," + "\"message\":\"Requested resource not found: Table: tablename not found\"}"))); } { - EXPECT_EQ("", - RequestParser::parseErrorType(Json::StringLoader("{\"__type\":\"UnKnownError\"}"))); + EXPECT_EQ("", RequestParser::parseErrorType( + *Json::Factory::LoadFromString("{\"__type\":\"UnKnownError\"}"))); } } @@ -95,9 +97,9 @@ TEST(DynamoRequestParser, parseTableNameBatchOperation) { } } )EOF"; - Json::StringLoader json_data(json_string); + Json::ObjectPtr json_data = Json::Factory::LoadFromString(json_string); - RequestParser::TableDescriptor table = RequestParser::parseTable("BatchGetItem", json_data); + RequestParser::TableDescriptor table = RequestParser::parseTable("BatchGetItem", *json_data); EXPECT_EQ("", table.table_name); EXPECT_FALSE(table.is_single_table); } @@ -111,9 +113,9 @@ TEST(DynamoRequestParser, parseTableNameBatchOperation) { } } )EOF"; - Json::StringLoader json_data(json_string); + Json::ObjectPtr json_data = Json::Factory::LoadFromString(json_string); - RequestParser::TableDescriptor table = RequestParser::parseTable("BatchGetItem", json_data); + RequestParser::TableDescriptor table = RequestParser::parseTable("BatchGetItem", *json_data); EXPECT_EQ("table_2", table.table_name); EXPECT_TRUE(table.is_single_table); } @@ -128,9 +130,9 @@ TEST(DynamoRequestParser, parseTableNameBatchOperation) { } } )EOF"; - Json::StringLoader json_data(json_string); + Json::ObjectPtr json_data = Json::Factory::LoadFromString(json_string); - RequestParser::TableDescriptor table = RequestParser::parseTable("BatchGetItem", json_data); + RequestParser::TableDescriptor table = RequestParser::parseTable("BatchGetItem", *json_data); EXPECT_EQ("", table.table_name); EXPECT_FALSE(table.is_single_table); } @@ -144,54 +146,51 @@ TEST(DynamoRequestParser, parseTableNameBatchOperation) { } } )EOF"; - Json::StringLoader json_data(json_string); + Json::ObjectPtr json_data = Json::Factory::LoadFromString(json_string); - RequestParser::TableDescriptor table = RequestParser::parseTable("BatchWriteItem", json_data); + RequestParser::TableDescriptor table = RequestParser::parseTable("BatchWriteItem", *json_data); EXPECT_EQ("table_2", table.table_name); EXPECT_TRUE(table.is_single_table); } { + Json::ObjectPtr json_data = Json::Factory::LoadFromString("{}"); RequestParser::TableDescriptor table = - RequestParser::parseTable("BatchWriteItem", Json::StringLoader("{}")); + RequestParser::parseTable("BatchWriteItem", *Json::Factory::LoadFromString("{}")); EXPECT_EQ("", table.table_name); EXPECT_TRUE(table.is_single_table); } { - RequestParser::TableDescriptor table = - RequestParser::parseTable("BatchWriteItem", Json::StringLoader("{\"RequestItems\":{}}")); + Json::ObjectPtr json_data = Json::Factory::LoadFromString("{\"RequestItems\":{}}"); + RequestParser::TableDescriptor table = RequestParser::parseTable("BatchWriteItem", *json_data); EXPECT_EQ("", table.table_name); EXPECT_TRUE(table.is_single_table); } { - RequestParser::TableDescriptor table = - RequestParser::parseTable("BatchGetItem", Json::StringLoader("{}")); + Json::ObjectPtr json_data = Json::Factory::LoadFromString("{}"); + RequestParser::TableDescriptor table = RequestParser::parseTable("BatchGetItem", *json_data); EXPECT_EQ("", table.table_name); EXPECT_TRUE(table.is_single_table); } } TEST(DynamoRequestParser, parseBatchUnProcessedKeys) { { - EXPECT_THROW(RequestParser::parseBatchUnProcessedKeys(Json::StringLoader("{test")), - Json::Exception); - } - - { + Json::ObjectPtr json_data = Json::Factory::LoadFromString("{}"); std::vector unprocessed_tables = - RequestParser::parseBatchUnProcessedKeys(Json::StringLoader("{}")); + RequestParser::parseBatchUnProcessedKeys(*json_data); EXPECT_EQ(0u, unprocessed_tables.size()); } { - std::vector unprocessed_tables = - RequestParser::parseBatchUnProcessedKeys(Json::StringLoader("{\"UnprocessedKeys\":{}}")); + std::vector unprocessed_tables = RequestParser::parseBatchUnProcessedKeys( + *Json::Factory::LoadFromString("{\"UnprocessedKeys\":{}}")); EXPECT_EQ(0u, unprocessed_tables.size()); } { std::vector unprocessed_tables = RequestParser::parseBatchUnProcessedKeys( - Json::StringLoader("{\"UnprocessedKeys\":{\"table_1\" :{}}}")); + *Json::Factory::LoadFromString("{\"UnprocessedKeys\":{\"table_1\" :{}}}")); EXPECT_EQ("table_1", unprocessed_tables[0]); EXPECT_EQ(1u, unprocessed_tables.size()); } @@ -205,10 +204,10 @@ TEST(DynamoRequestParser, parseBatchUnProcessedKeys) { } } )EOF"; - Json::StringLoader json_data(json_string); + Json::ObjectPtr json_data = Json::Factory::LoadFromString(json_string); std::vector unprocessed_tables = - RequestParser::parseBatchUnProcessedKeys(json_data); + RequestParser::parseBatchUnProcessedKeys(*json_data); EXPECT_TRUE(find(unprocessed_tables.begin(), unprocessed_tables.end(), "table_1") != unprocessed_tables.end()); EXPECT_TRUE(find(unprocessed_tables.begin(), unprocessed_tables.end(), "table_2") != @@ -220,17 +219,17 @@ TEST(DynamoRequestParser, parseBatchUnProcessedKeys) { TEST(DynamoRequestParser, parsePartitionIds) { { std::vector partitions = - RequestParser::parsePartitions(Json::StringLoader("{}")); + RequestParser::parsePartitions(*Json::Factory::LoadFromString("{}")); EXPECT_EQ(0u, partitions.size()); } { std::vector partitions = - RequestParser::parsePartitions(Json::StringLoader("{\"ConsumedCapacity\":{}}")); + RequestParser::parsePartitions(*Json::Factory::LoadFromString("{\"ConsumedCapacity\":{}}")); EXPECT_EQ(0u, partitions.size()); } { std::vector partitions = RequestParser::parsePartitions( - Json::StringLoader("{\"ConsumedCapacity\":{ \"Partitions\":{}}}")); + *Json::Factory::LoadFromString("{\"ConsumedCapacity\":{ \"Partitions\":{}}}")); EXPECT_EQ(0u, partitions.size()); } { @@ -244,10 +243,10 @@ TEST(DynamoRequestParser, parsePartitionIds) { } } )EOF"; - Json::StringLoader json_data(json_string); + Json::ObjectPtr json_data = Json::Factory::LoadFromString(json_string); std::vector partitions = - RequestParser::parsePartitions(json_data); + RequestParser::parsePartitions(*json_data); for (const RequestParser::PartitionDescriptor& partition : partitions) { if (partition.partition_id_ == "partition_1") { EXPECT_EQ(1u, partition.capacity_); diff --git a/test/common/filter/auth/client_ssl_test.cc b/test/common/filter/auth/client_ssl_test.cc index d80f0d154ec57..46e2aa82aa5de 100644 --- a/test/common/filter/auth/client_ssl_test.cc +++ b/test/common/filter/auth/client_ssl_test.cc @@ -41,10 +41,10 @@ class ClientSslAuthFilterTest : public testing::Test { } )EOF"; - Json::StringLoader loader(json); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); EXPECT_CALL(cm_, get("vpn")); setupRequest(); - config_.reset(new Config(loader, tls_, cm_, dispatcher_, stats_store_, runtime_)); + config_.reset(new Config(*loader, tls_, cm_, dispatcher_, stats_store_, runtime_)); createAuthFilter(); } @@ -88,9 +88,9 @@ TEST_F(ClientSslAuthFilterTest, NoCluster) { } )EOF"; - Json::StringLoader loader(json); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); EXPECT_CALL(cm_, get("bad_cluster")).WillOnce(Return(nullptr)); - EXPECT_THROW(new Config(loader, tls_, cm_, dispatcher_, stats_store_, runtime_), EnvoyException); + EXPECT_THROW(new Config(*loader, tls_, cm_, dispatcher_, stats_store_, runtime_), EnvoyException); } TEST_F(ClientSslAuthFilterTest, NoSsl) { diff --git a/test/common/filter/ratelimit_test.cc b/test/common/filter/ratelimit_test.cc index 1fdf258559505..079400f9c95c0 100644 --- a/test/common/filter/ratelimit_test.cc +++ b/test/common/filter/ratelimit_test.cc @@ -35,8 +35,8 @@ class RateLimitFilterTest : public testing::Test { ON_CALL(runtime_.snapshot_, featureEnabled("ratelimit.tcp_filter_enforcing", 100)) .WillByDefault(Return(true)); - Json::StringLoader config(json); - config_.reset(new Config(config, stats_store_, runtime_)); + Json::ObjectPtr config = Json::Factory::LoadFromString(json); + config_.reset(new Config(*config, stats_store_, runtime_)); client_ = new MockClient(); filter_.reset(new Instance(config_, ClientPtr{client_})); filter_->initializeReadFilterCallbacks(filter_callbacks_); diff --git a/test/common/filter/tcp_proxy_test.cc b/test/common/filter/tcp_proxy_test.cc index 6ac820c92830e..67e7583944a7f 100644 --- a/test/common/filter/tcp_proxy_test.cc +++ b/test/common/filter/tcp_proxy_test.cc @@ -24,10 +24,10 @@ TEST(TcpProxyConfigTest, NoCluster) { } )EOF"; - Json::StringLoader config(json); + Json::ObjectPtr config = Json::Factory::LoadFromString(json); NiceMock cluster_manager; EXPECT_CALL(cluster_manager, get("fake_cluster")).WillOnce(Return(nullptr)); - EXPECT_THROW(TcpProxyConfig(config, cluster_manager, cluster_manager.cluster_.stats_store_), + EXPECT_THROW(TcpProxyConfig(*config, cluster_manager, cluster_manager.cluster_.stats_store_), EnvoyException); } @@ -41,9 +41,9 @@ class TcpProxyTest : public testing::Test { } )EOF"; - Json::StringLoader config(json); + Json::ObjectPtr config = Json::Factory::LoadFromString(json); config_.reset( - new TcpProxyConfig(config, cluster_manager_, cluster_manager_.cluster_.stats_store_)); + new TcpProxyConfig(*config, cluster_manager_, cluster_manager_.cluster_.stats_store_)); } void setup(bool return_connection) { diff --git a/test/common/http/access_log/access_log_impl_test.cc b/test/common/http/access_log/access_log_impl_test.cc index eddd7878a81fc..50dd949c0af39 100644 --- a/test/common/http/access_log/access_log_impl_test.cc +++ b/test/common/http/access_log/access_log_impl_test.cc @@ -83,10 +83,10 @@ TEST_F(AccessLogImplTest, LogMoreData) { } )EOF"; - Json::StringLoader loader(json); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); Stats::IsolatedStoreImpl store; Runtime::MockLoader runtime; - InstancePtr log = InstanceImpl::fromJson(loader, api_, dispatcher_, lock_, store, runtime); + InstancePtr log = InstanceImpl::fromJson(*loader, api_, dispatcher_, lock_, store, runtime); EXPECT_CALL(*file_, write(_)); request_info_.failure_reason_ = FailureReason::UpstreamConnectionFailure; @@ -108,10 +108,10 @@ TEST_F(AccessLogImplTest, EnvoyUpstreamServiceTime) { } )EOF"; - Json::StringLoader loader(json); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); Stats::IsolatedStoreImpl store; Runtime::MockLoader runtime; - InstancePtr log = InstanceImpl::fromJson(loader, api_, dispatcher_, lock_, store, runtime); + InstancePtr log = InstanceImpl::fromJson(*loader, api_, dispatcher_, lock_, store, runtime); EXPECT_CALL(*file_, write(_)); response_headers_.addViaCopy(Http::Headers::get().EnvoyUpstreamServiceTime, "999"); @@ -129,10 +129,10 @@ TEST_F(AccessLogImplTest, NoFilter) { } )EOF"; - Json::StringLoader loader(json); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); Stats::IsolatedStoreImpl store; Runtime::MockLoader runtime; - InstancePtr log = InstanceImpl::fromJson(loader, api_, dispatcher_, lock_, store, runtime); + InstancePtr log = InstanceImpl::fromJson(*loader, api_, dispatcher_, lock_, store, runtime); EXPECT_CALL(*file_, write(_)); log->log(&request_headers_, &response_headers_, request_info_); @@ -152,10 +152,10 @@ TEST_F(AccessLogImplTest, UpstreamHost) { } )EOF"; - Json::StringLoader loader(json); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); Stats::IsolatedStoreImpl store; Runtime::MockLoader runtime; - InstancePtr log = InstanceImpl::fromJson(loader, api_, dispatcher_, lock_, store, runtime); + InstancePtr log = InstanceImpl::fromJson(*loader, api_, dispatcher_, lock_, store, runtime); EXPECT_CALL(*file_, write(_)); log->log(&request_headers_, &response_headers_, request_info_); @@ -176,10 +176,10 @@ TEST_F(AccessLogImplTest, WithFilterMiss) { } )EOF"; - Json::StringLoader loader(json); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); Stats::IsolatedStoreImpl store; Runtime::MockLoader runtime; - InstancePtr log = InstanceImpl::fromJson(loader, api_, dispatcher_, lock_, store, runtime); + InstancePtr log = InstanceImpl::fromJson(*loader, api_, dispatcher_, lock_, store, runtime); EXPECT_CALL(*file_, write(_)).Times(0); log->log(&request_headers_, &response_headers_, request_info_); @@ -201,10 +201,10 @@ TEST_F(AccessLogImplTest, WithFilterHit) { } )EOF"; - Json::StringLoader loader(json); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); Stats::IsolatedStoreImpl store; Runtime::MockLoader runtime; - InstancePtr log = InstanceImpl::fromJson(loader, api_, dispatcher_, lock_, store, runtime); + InstancePtr log = InstanceImpl::fromJson(*loader, api_, dispatcher_, lock_, store, runtime); EXPECT_CALL(*file_, write(_)).Times(3); log->log(&request_headers_, &response_headers_, request_info_); @@ -225,10 +225,10 @@ TEST_F(AccessLogImplTest, RuntimeFilter) { } )EOF"; - Json::StringLoader loader(json); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); Stats::IsolatedStoreImpl store; NiceMock runtime; - InstancePtr log = InstanceImpl::fromJson(loader, api_, dispatcher_, lock_, store, runtime); + InstancePtr log = InstanceImpl::fromJson(*loader, api_, dispatcher_, lock_, store, runtime); // Value is taken from random generator. EXPECT_CALL(runtime.snapshot_, featureEnabled("access_log.test_key", 0)).WillOnce(Return(true)); @@ -259,10 +259,10 @@ TEST_F(AccessLogImplTest, PathRewrite) { } )EOF"; - Json::StringLoader loader(json); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); Stats::IsolatedStoreImpl store; Runtime::MockLoader runtime; - InstancePtr log = InstanceImpl::fromJson(loader, api_, dispatcher_, lock_, store, runtime); + InstancePtr log = InstanceImpl::fromJson(*loader, api_, dispatcher_, lock_, store, runtime); EXPECT_CALL(*file_, write(_)); log->log(&request_headers_, &response_headers_, request_info_); @@ -279,10 +279,10 @@ TEST_F(AccessLogImplTest, healthCheckTrue) { } )EOF"; - Json::StringLoader loader(json); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); Stats::IsolatedStoreImpl store; NiceMock runtime; - InstancePtr log = InstanceImpl::fromJson(loader, api_, dispatcher_, lock_, store, runtime); + InstancePtr log = InstanceImpl::fromJson(*loader, api_, dispatcher_, lock_, store, runtime); TestHeaderMapImpl header_map{}; request_info_.hc_request_ = true; @@ -299,10 +299,10 @@ TEST_F(AccessLogImplTest, healthCheckFalse) { } )EOF"; - Json::StringLoader loader(json); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); Stats::IsolatedStoreImpl store; NiceMock runtime; - InstancePtr log = InstanceImpl::fromJson(loader, api_, dispatcher_, lock_, store, runtime); + InstancePtr log = InstanceImpl::fromJson(*loader, api_, dispatcher_, lock_, store, runtime); TestHeaderMapImpl header_map{}; EXPECT_CALL(*file_, write(_)); @@ -327,10 +327,10 @@ TEST_F(AccessLogImplTest, requestTracing) { } )EOF"; - Json::StringLoader loader(json); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); Stats::IsolatedStoreImpl store; NiceMock runtime; - InstancePtr log = InstanceImpl::fromJson(loader, api_, dispatcher_, lock_, store, runtime); + InstancePtr log = InstanceImpl::fromJson(*loader, api_, dispatcher_, lock_, store, runtime); { TestHeaderMapImpl forced_header{{"x-request-id", force_tracing_guid}}; @@ -365,8 +365,8 @@ TEST(AccessLogImplTestCtor, OperatorIsNotSupported) { "{ \"path\": \"/dev/null\", \"filter\": {\"type\": \"status_code\", \"op\": \"" + oper + "\", \"value\" : 500}}"; - Json::StringLoader loader(json); - EXPECT_THROW(InstanceImpl::fromJson(loader, api, dispatcher, lock, store, runtime), + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); + EXPECT_THROW(InstanceImpl::fromJson(*loader, api, dispatcher, lock, store, runtime), EnvoyException); } } @@ -384,9 +384,9 @@ TEST(AccessLogImplTestCtor, FilterTypeNotSupported) { "filter": {"type": "unknown"} } )EOF"; - Json::StringLoader loader(json); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); - EXPECT_THROW(InstanceImpl::fromJson(loader, api, dispatcher, lock, store, runtime), + EXPECT_THROW(InstanceImpl::fromJson(*loader, api, dispatcher, lock, store, runtime), EnvoyException); } @@ -404,9 +404,9 @@ TEST(AccessLogImplTestCtor, FiltersMissingInOrAndFilter) { "filter": {"type": "logical_or"} } )EOF"; - Json::StringLoader loader(json); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); - EXPECT_THROW(InstanceImpl::fromJson(loader, api, dispatcher, lock, store, runtime), + EXPECT_THROW(InstanceImpl::fromJson(*loader, api, dispatcher, lock, store, runtime), EnvoyException); } @@ -417,9 +417,9 @@ TEST(AccessLogImplTestCtor, FiltersMissingInOrAndFilter) { "filter": {"type": "logical_and"} } )EOF"; - Json::StringLoader loader(json); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); - EXPECT_THROW(InstanceImpl::fromJson(loader, api, dispatcher, lock, store, runtime), + EXPECT_THROW(InstanceImpl::fromJson(*loader, api, dispatcher, lock, store, runtime), EnvoyException); } } @@ -438,9 +438,9 @@ TEST(AccessLogImplTestCtor, lessThanTwoInFilterList) { "filter": {"type": "logical_or", "filters" : []} } )EOF"; - Json::StringLoader loader(json); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); - EXPECT_THROW(InstanceImpl::fromJson(loader, api, dispatcher, lock, store, runtime), + EXPECT_THROW(InstanceImpl::fromJson(*loader, api, dispatcher, lock, store, runtime), EnvoyException); } @@ -451,9 +451,9 @@ TEST(AccessLogImplTestCtor, lessThanTwoInFilterList) { "filter": {"type": "logical_and", "filters" : []} } )EOF"; - Json::StringLoader loader(json); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); - EXPECT_THROW(InstanceImpl::fromJson(loader, api, dispatcher, lock, store, runtime), + EXPECT_THROW(InstanceImpl::fromJson(*loader, api, dispatcher, lock, store, runtime), EnvoyException); } @@ -464,9 +464,9 @@ TEST(AccessLogImplTestCtor, lessThanTwoInFilterList) { "filter": {"type": "logical_or", "filters" : [ {"type": "not_healthcheck"} ]} } )EOF"; - Json::StringLoader loader(json); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); - EXPECT_THROW(InstanceImpl::fromJson(loader, api, dispatcher, lock, store, runtime), + EXPECT_THROW(InstanceImpl::fromJson(*loader, api, dispatcher, lock, store, runtime), EnvoyException); } @@ -477,9 +477,9 @@ TEST(AccessLogImplTestCtor, lessThanTwoInFilterList) { "filter": {"type": "logical_and", "filters" : [ {"type": "not_healthcheck"} ]} } )EOF"; - Json::StringLoader loader(json); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); - EXPECT_THROW(InstanceImpl::fromJson(loader, api, dispatcher, lock, store, runtime), + EXPECT_THROW(InstanceImpl::fromJson(*loader, api, dispatcher, lock, store, runtime), EnvoyException); } } @@ -496,10 +496,10 @@ TEST_F(AccessLogImplTest, andFilter) { } )EOF"; - Json::StringLoader loader(json); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); Stats::IsolatedStoreImpl store; Runtime::MockLoader runtime; - InstancePtr log = InstanceImpl::fromJson(loader, api_, dispatcher_, lock_, store, runtime); + InstancePtr log = InstanceImpl::fromJson(*loader, api_, dispatcher_, lock_, store, runtime); request_info_.response_code_.value(500); { @@ -529,10 +529,10 @@ TEST_F(AccessLogImplTest, orFilter) { } )EOF"; - Json::StringLoader loader(json); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); Stats::IsolatedStoreImpl store; Runtime::MockLoader runtime; - InstancePtr log = InstanceImpl::fromJson(loader, api_, dispatcher_, lock_, store, runtime); + InstancePtr log = InstanceImpl::fromJson(*loader, api_, dispatcher_, lock_, store, runtime); request_info_.response_code_.value(500); { @@ -565,10 +565,10 @@ TEST_F(AccessLogImplTest, multipleOperators) { } )EOF"; - Json::StringLoader loader(json); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); Stats::IsolatedStoreImpl store; Runtime::MockLoader runtime; - InstancePtr log = InstanceImpl::fromJson(loader, api_, dispatcher_, lock_, store, runtime); + InstancePtr log = InstanceImpl::fromJson(*loader, api_, dispatcher_, lock_, store, runtime); request_info_.response_code_.value(500); { @@ -594,11 +594,11 @@ TEST(AccessLogFilterTest, DurationWithRuntimeKey) { } )EOF"; - Json::StringLoader loader(filter_json); + Json::ObjectPtr loader = Json::Factory::LoadFromString(filter_json); NiceMock runtime; - Json::Object filter_object = loader.getObject("filter"); - DurationFilter filter(filter_object, runtime); + Json::ObjectPtr filter_object = loader->getObject("filter"); + DurationFilter filter(*filter_object, runtime); TestHeaderMapImpl request_headers{{":method", "GET"}, {":path", "/"}}; TestRequestInfo request_info; @@ -626,11 +626,11 @@ TEST(AccessLogFilterTest, StatusCodeWithRuntimeKey) { } )EOF"; - Json::StringLoader loader(filter_json); + Json::ObjectPtr loader = Json::Factory::LoadFromString(filter_json); NiceMock runtime; - Json::Object filter_object = loader.getObject("filter"); - StatusCodeFilter filter(filter_object, runtime); + Json::ObjectPtr filter_object = loader->getObject("filter"); + StatusCodeFilter filter(*filter_object, runtime); TestHeaderMapImpl request_headers{{":method", "GET"}, {":path", "/"}}; TestRequestInfo info; diff --git a/test/common/http/filter/fault_filter_test.cc b/test/common/http/filter/fault_filter_test.cc index 243aa8136a30e..10f67b227ea53 100644 --- a/test/common/http/filter/fault_filter_test.cc +++ b/test/common/http/filter/fault_filter_test.cc @@ -76,8 +76,8 @@ class FaultFilterTest : public testing::Test { )EOF"; void SetUpTest(const std::string json) { - Json::StringLoader config(json); - config_.reset(new FaultFilterConfig(config, runtime_, "", stats_)); + Json::ObjectPtr config = Json::Factory::LoadFromString(json); + config_.reset(new FaultFilterConfig(*config, runtime_, "", stats_)); filter_.reset(new FaultFilter(config_)); filter_->setDecoderFilterCallbacks(filter_callbacks_); } @@ -108,9 +108,9 @@ TEST(FaultFilterBadConfigTest, BadAbortPercent) { } )EOF"; Stats::IsolatedStoreImpl stats; - Json::StringLoader config(json); + Json::ObjectPtr config = Json::Factory::LoadFromString(json); NiceMock runtime; - EXPECT_THROW(FaultFilterConfig(config, runtime, "", stats), EnvoyException); + EXPECT_THROW(FaultFilterConfig(*config, runtime, "", stats), EnvoyException); } TEST(FaultFilterBadConfigTest, MissingHTTPStatus) { @@ -122,9 +122,9 @@ TEST(FaultFilterBadConfigTest, MissingHTTPStatus) { } )EOF"; Stats::IsolatedStoreImpl stats; - Json::StringLoader config(json); + Json::ObjectPtr config = Json::Factory::LoadFromString(json); NiceMock runtime; - EXPECT_THROW(FaultFilterConfig(config, runtime, "", stats), EnvoyException); + EXPECT_THROW(FaultFilterConfig(*config, runtime, "", stats), EnvoyException); } TEST(FaultFilterBadConfigTest, BadDelayType) { @@ -138,9 +138,9 @@ TEST(FaultFilterBadConfigTest, BadDelayType) { } )EOF"; Stats::IsolatedStoreImpl stats; - Json::StringLoader config(json); + Json::ObjectPtr config = Json::Factory::LoadFromString(json); NiceMock runtime; - EXPECT_THROW(FaultFilterConfig(config, runtime, "", stats), EnvoyException); + EXPECT_THROW(FaultFilterConfig(*config, runtime, "", stats), EnvoyException); } TEST(FaultFilterBadConfigTest, BadDelayPercent) { @@ -154,9 +154,9 @@ TEST(FaultFilterBadConfigTest, BadDelayPercent) { } )EOF"; Stats::IsolatedStoreImpl stats; - Json::StringLoader config(json); + Json::ObjectPtr config = Json::Factory::LoadFromString(json); NiceMock runtime; - EXPECT_THROW(FaultFilterConfig(config, runtime, "", stats), EnvoyException); + EXPECT_THROW(FaultFilterConfig(*config, runtime, "", stats), EnvoyException); } TEST(FaultFilterBadConfigTest, BadDelayDuration) { @@ -170,9 +170,9 @@ TEST(FaultFilterBadConfigTest, BadDelayDuration) { } )EOF"; Stats::IsolatedStoreImpl stats; - Json::StringLoader config(json); + Json::ObjectPtr config = Json::Factory::LoadFromString(json); NiceMock runtime; - EXPECT_THROW(FaultFilterConfig(config, runtime, "", stats), EnvoyException); + EXPECT_THROW(FaultFilterConfig(*config, runtime, "", stats), EnvoyException); } TEST(FaultFilterBadConfigTest, MissingDelayDuration) { @@ -185,9 +185,9 @@ TEST(FaultFilterBadConfigTest, MissingDelayDuration) { } )EOF"; Stats::IsolatedStoreImpl stats; - Json::StringLoader config(json); + Json::ObjectPtr config = Json::Factory::LoadFromString(json); NiceMock runtime; - EXPECT_THROW(FaultFilterConfig(config, runtime, "", stats), EnvoyException); + EXPECT_THROW(FaultFilterConfig(*config, runtime, "", stats), EnvoyException); } TEST_F(FaultFilterTest, AbortWithHttpStatus) { diff --git a/test/common/http/filter/ratelimit_test.cc b/test/common/http/filter/ratelimit_test.cc index 6440dcf947b88..ad0634f5a6d38 100644 --- a/test/common/http/filter/ratelimit_test.cc +++ b/test/common/http/filter/ratelimit_test.cc @@ -30,10 +30,10 @@ TEST(HttpRateLimitFilterBadConfigTest, BadType) { } )EOF"; - Json::StringLoader config(json); + Json::ObjectPtr config = Json::Factory::LoadFromString(json); Stats::IsolatedStoreImpl stats_store; NiceMock runtime; - EXPECT_THROW(FilterConfig(config, "service_cluster", stats_store, runtime), EnvoyException); + EXPECT_THROW(FilterConfig(*config, "service_cluster", stats_store, runtime), EnvoyException); } TEST(HttpRateLimitFilterBadConfigTest, NoDescriptorKey) { @@ -49,10 +49,10 @@ TEST(HttpRateLimitFilterBadConfigTest, NoDescriptorKey) { } )EOF"; - Json::StringLoader config(json); + Json::ObjectPtr config = Json::Factory::LoadFromString(json); Stats::IsolatedStoreImpl stats_store; NiceMock runtime; - EXPECT_THROW(FilterConfig(config, "service_cluster", stats_store, runtime), EnvoyException); + EXPECT_THROW(FilterConfig(*config, "service_cluster", stats_store, runtime), EnvoyException); } class HttpRateLimitFilterTest : public testing::Test { @@ -67,8 +67,8 @@ class HttpRateLimitFilterTest : public testing::Test { } void SetUpTest(const std::string json) { - Json::StringLoader config(json); - config_.reset(new FilterConfig(config, "service_cluster", stats_store_, runtime_)); + Json::ObjectPtr config = Json::Factory::LoadFromString(json); + config_.reset(new FilterConfig(*config, "service_cluster", stats_store_, runtime_)); client_ = new ::RateLimit::MockClient(); filter_.reset(new Filter(config_, ::RateLimit::ClientPtr{client_})); diff --git a/test/common/http/utility_test.cc b/test/common/http/utility_test.cc index 10799a9063336..d0d3fe77d9955 100644 --- a/test/common/http/utility_test.cc +++ b/test/common/http/utility_test.cc @@ -74,18 +74,19 @@ TEST(HttpUtility, createSslRedirectPath) { TEST(HttpUtility, parseCodecOptions) { { - Json::StringLoader json("{}"); - EXPECT_EQ(0UL, Utility::parseCodecOptions(json)); + Json::ObjectPtr json = Json::Factory::LoadFromString("{}"); + EXPECT_EQ(0UL, Utility::parseCodecOptions(*json)); } { - Json::StringLoader json("{\"http_codec_options\": \"no_compression\"}"); - EXPECT_EQ(CodecOptions::NoCompression, Utility::parseCodecOptions(json)); + Json::ObjectPtr json = + Json::Factory::LoadFromString("{\"http_codec_options\": \"no_compression\"}"); + EXPECT_EQ(CodecOptions::NoCompression, Utility::parseCodecOptions(*json)); } { - Json::StringLoader json("{\"http_codec_options\": \"foo\"}"); - EXPECT_THROW(Utility::parseCodecOptions(json), EnvoyException); + Json::ObjectPtr json = Json::Factory::LoadFromString("{\"http_codec_options\": \"foo\"}"); + EXPECT_THROW(Utility::parseCodecOptions(*json), EnvoyException); } } diff --git a/test/common/json/json_loader_test.cc b/test/common/json/json_loader_test.cc index 2346bbe7d1260..f8c6a0c4b125b 100644 --- a/test/common/json/json_loader_test.cc +++ b/test/common/json/json_loader_test.cc @@ -3,46 +3,46 @@ namespace Json { TEST(JsonLoaderTest, Basic) { - EXPECT_THROW(FileLoader("bad_file"), Exception); - EXPECT_THROW(StringLoader("{"), Exception); + EXPECT_THROW(Factory::LoadFromFile("bad_file"), Exception); + EXPECT_THROW(Factory::LoadFromString("{"), Exception); { - StringLoader json("{\"hello\":123}"); - EXPECT_TRUE(json.hasObject("hello")); - EXPECT_FALSE(json.hasObject("world")); - EXPECT_THROW(json.getObject("world"), Exception); - EXPECT_THROW(json.getBoolean("hello"), Exception); - EXPECT_THROW(json.getObjectArray("hello"), Exception); - EXPECT_THROW(json.getString("hello"), Exception); + ObjectPtr json = Factory::LoadFromString("{\"hello\":123}"); + EXPECT_TRUE(json->hasObject("hello")); + EXPECT_FALSE(json->hasObject("world")); + EXPECT_THROW(json->getObject("world"), Exception); + EXPECT_THROW(json->getBoolean("hello"), Exception); + EXPECT_THROW(json->getObjectArray("hello"), Exception); + EXPECT_THROW(json->getString("hello"), Exception); } { - StringLoader json("{\"hello\":\"123\"}"); - EXPECT_THROW(json.getInteger("hello"), Exception); + ObjectPtr json = Factory::LoadFromString("{\"hello\":\"123\"}"); + EXPECT_THROW(json->getInteger("hello"), Exception); } { - StringLoader json("{\"hello\":true}"); - EXPECT_TRUE(json.getBoolean("hello")); - EXPECT_TRUE(json.getBoolean("hello", false)); - EXPECT_FALSE(json.getBoolean("world", false)); + ObjectPtr json = Factory::LoadFromString("{\"hello\":true}"); + EXPECT_TRUE(json->getBoolean("hello")); + EXPECT_TRUE(json->getBoolean("hello", false)); + EXPECT_FALSE(json->getBoolean("world", false)); } { - StringLoader json("{\"hello\": [\"a\", \"b\", 3]}"); - EXPECT_THROW(json.getStringArray("hello"), Exception); + ObjectPtr json = Factory::LoadFromString("{\"hello\": [\"a\", \"b\", 3]}"); + EXPECT_THROW(json->getStringArray("hello"), Exception); } { - StringLoader json("{\"hello\":123}"); - EXPECT_EQ(123, json.getInteger("hello", 456)); - EXPECT_EQ(456, json.getInteger("world", 456)); + ObjectPtr json = Factory::LoadFromString("{\"hello\":123}"); + EXPECT_EQ(123, json->getInteger("hello", 456)); + EXPECT_EQ(456, json->getInteger("world", 456)); } { - StringLoader json("{\"1\":{\"11\":\"111\"},\"2\":{\"22\":\"222\"}}"); + ObjectPtr json = Factory::LoadFromString("{\"1\":{\"11\":\"111\"},\"2\":{\"22\":\"222\"}}"); int pos = 0; - json.iterate([&pos](const std::string& key, const Json::Object& value) { + json->iterate([&pos](const std::string& key, const Json::Object& value) { EXPECT_TRUE(key == "1" || key == "2"); if (key == "1") { @@ -59,9 +59,9 @@ TEST(JsonLoaderTest, Basic) { } { - StringLoader json("{\"1\":{\"11\":\"111\"},\"2\":{\"22\":\"222\"}}"); + ObjectPtr json = Factory::LoadFromString("{\"1\":{\"11\":\"111\"},\"2\":{\"22\":\"222\"}}"); int pos = 0; - json.iterate([&pos](const std::string& key, const Json::Object& value) { + json->iterate([&pos](const std::string& key, const Json::Object& value) { EXPECT_TRUE(key == "1" || key == "2"); if (key == "1") { @@ -87,9 +87,9 @@ TEST(JsonLoaderTest, Basic) { } )EOF"; - Json::StringLoader config(json); - EXPECT_EQ(2U, config.getObjectArray("descriptors")[0].asObjectArray().size()); - EXPECT_EQ(1U, config.getObjectArray("descriptors")[1].asObjectArray().size()); + ObjectPtr config = Factory::LoadFromString(json); + EXPECT_EQ(2U, config->getObjectArray("descriptors")[0]->asObjectArray().size()); + EXPECT_EQ(1U, config->getObjectArray("descriptors")[1]->asObjectArray().size()); } { @@ -99,9 +99,9 @@ TEST(JsonLoaderTest, Basic) { } )EOF"; - Json::StringLoader config(json); - std::vector array = config.getObjectArray("descriptors"); - EXPECT_THROW(array[0].asObjectArray(), Exception); + ObjectPtr config = Factory::LoadFromString(json); + std::vector array = config->getObjectArray("descriptors"); + EXPECT_THROW(array[0]->asObjectArray(), Exception); } { @@ -110,39 +110,41 @@ TEST(JsonLoaderTest, Basic) { } )EOF"; - Json::StringLoader config(json); - Object object = config.getObject("foo", true); - EXPECT_EQ(2, object.getInteger("bar", 2)); + ObjectPtr config = Factory::LoadFromString(json); + ObjectPtr object = config->getObject("foo", true); + EXPECT_EQ(2, object->getInteger("bar", 2)); } } TEST(JsonLoaderTest, Integer) { { - StringLoader json("{\"max\":9223372036854775807, \"min\":-9223372036854775808}"); - EXPECT_EQ(std::numeric_limits::max(), json.getInteger("max")); - EXPECT_EQ(std::numeric_limits::min(), json.getInteger("min")); + ObjectPtr json = + Factory::LoadFromString("{\"max\":9223372036854775807, \"min\":-9223372036854775808}"); + EXPECT_EQ(std::numeric_limits::max(), json->getInteger("max")); + EXPECT_EQ(std::numeric_limits::min(), json->getInteger("min")); } - { - EXPECT_THROW(StringLoader("{\"val\":9223372036854775808}"), Exception); - EXPECT_THROW(StringLoader("{\"val\":-9223372036854775809}"), Exception); + ObjectPtr json_max = Factory::LoadFromString("{\"val\":9223372036854775808}"); + EXPECT_THROW(json_max->getInteger("val"), Exception); + ObjectPtr json_min = Factory::LoadFromString("{\"val\":-9223372036854775809}"); + EXPECT_THROW(json_min->getInteger("val"), Exception); } } TEST(JsonLoaderTest, Double) { { - StringLoader json("{\"value1\": 10.5, \"value2\": -12.3}"); - EXPECT_EQ(10.5, json.getDouble("value1")); - EXPECT_EQ(-12.3, json.getDouble("value2")); + ObjectPtr json = Factory::LoadFromString("{\"value1\": 10.5, \"value2\": -12.3}"); + EXPECT_EQ(10.5, json->getDouble("value1")); + EXPECT_EQ(-12.3, json->getDouble("value2")); } { - StringLoader json("{\"foo\": 13.22}"); - EXPECT_EQ(13.22, json.getDouble("foo", 0)); - EXPECT_EQ(0, json.getDouble("bar", 0)); + ObjectPtr json = Factory::LoadFromString("{\"foo\": 13.22}"); + EXPECT_EQ(13.22, json->getDouble("foo", 0)); + EXPECT_EQ(0, json->getDouble("bar", 0)); } { - StringLoader json("{\"foo\": \"bar\"}"); - EXPECT_THROW(json.getDouble("foo"), Exception); + ObjectPtr json = Factory::LoadFromString("{\"foo\": \"bar\"}"); + EXPECT_THROW(json->getDouble("foo"), Exception); } } diff --git a/test/common/network/utility_test.cc b/test/common/network/utility_test.cc index d081d88baab7a..830b2c96583fc 100644 --- a/test/common/network/utility_test.cc +++ b/test/common/network/utility_test.cc @@ -12,8 +12,8 @@ TEST(IpWhiteListTest, Errors) { } )EOF"; - Json::StringLoader loader(json); - EXPECT_THROW({ IpWhiteList wl(loader); }, EnvoyException); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); + EXPECT_THROW({ IpWhiteList wl(*loader); }, EnvoyException); } { @@ -23,8 +23,8 @@ TEST(IpWhiteListTest, Errors) { } )EOF"; - Json::StringLoader loader(json); - EXPECT_THROW({ IpWhiteList wl(loader); }, EnvoyException); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); + EXPECT_THROW({ IpWhiteList wl(*loader); }, EnvoyException); } { @@ -34,8 +34,8 @@ TEST(IpWhiteListTest, Errors) { } )EOF"; - Json::StringLoader loader(json); - EXPECT_THROW({ IpWhiteList wl(loader); }, EnvoyException); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); + EXPECT_THROW({ IpWhiteList wl(*loader); }, EnvoyException); } { @@ -45,8 +45,8 @@ TEST(IpWhiteListTest, Errors) { } )EOF"; - Json::StringLoader loader(json); - EXPECT_THROW({ IpWhiteList wl(loader); }, EnvoyException); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); + EXPECT_THROW({ IpWhiteList wl(*loader); }, EnvoyException); } } @@ -61,8 +61,8 @@ TEST(IpWhiteListTest, Normal) { } )EOF"; - Json::StringLoader loader(json); - IpWhiteList wl(loader); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); + IpWhiteList wl(*loader); EXPECT_TRUE(wl.contains("192.168.3.0")); EXPECT_TRUE(wl.contains("192.168.3.3")); diff --git a/test/common/ratelimit/ratelimit_impl_test.cc b/test/common/ratelimit/ratelimit_impl_test.cc index 77f41e87a401a..1e90a59ff8683 100644 --- a/test/common/ratelimit/ratelimit_impl_test.cc +++ b/test/common/ratelimit/ratelimit_impl_test.cc @@ -118,12 +118,12 @@ TEST(RateLimitGrpcFactoryTest, NoCluster) { } )EOF"; - Json::StringLoader config(json); + Json::ObjectPtr config = Json::Factory::LoadFromString(json); Upstream::MockClusterManager cm; Stats::IsolatedStoreImpl stats_store; EXPECT_CALL(cm, get("foo")).WillOnce(Return(nullptr)); - EXPECT_THROW(GrpcFactoryImpl(config, cm, stats_store), EnvoyException); + EXPECT_THROW(GrpcFactoryImpl(*config, cm, stats_store), EnvoyException); } TEST(RateLimitGrpcFactoryTest, Create) { @@ -133,12 +133,12 @@ TEST(RateLimitGrpcFactoryTest, Create) { } )EOF"; - Json::StringLoader config(json); + Json::ObjectPtr config = Json::Factory::LoadFromString(json); Upstream::MockClusterManager cm; Stats::IsolatedStoreImpl stats_store; EXPECT_CALL(cm, get("foo")); - GrpcFactoryImpl factory(config, cm, stats_store); + GrpcFactoryImpl factory(*config, cm, stats_store); factory.create(Optional()); } diff --git a/test/common/router/config_impl_test.cc b/test/common/router/config_impl_test.cc index 4de4dbb86f75d..e2407b5edfe7b 100644 --- a/test/common/router/config_impl_test.cc +++ b/test/common/router/config_impl_test.cc @@ -144,10 +144,10 @@ TEST(RouteMatcherTest, TestRoutes) { } )EOF"; - Json::StringLoader loader(json); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); NiceMock runtime; NiceMock cm; - ConfigImpl config(loader, runtime, cm); + ConfigImpl config(*loader, runtime, cm); EXPECT_FALSE(config.usesRuntime()); @@ -350,10 +350,10 @@ TEST(RouteMatcherTest, InvalidPriority) { } )EOF"; - Json::StringLoader loader(json); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); NiceMock runtime; NiceMock cm; - EXPECT_THROW(ConfigImpl(loader, runtime, cm), EnvoyException); + EXPECT_THROW(ConfigImpl(*loader, runtime, cm), EnvoyException); } TEST(RouteMatcherTest, Priority) { @@ -381,10 +381,10 @@ TEST(RouteMatcherTest, Priority) { } )EOF"; - Json::StringLoader loader(json); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); NiceMock runtime; NiceMock cm; - ConfigImpl config(loader, runtime, cm); + ConfigImpl config(*loader, runtime, cm); EXPECT_FALSE(config.usesRuntime()); @@ -446,10 +446,10 @@ TEST(RouteMatcherTest, HeaderMatchedRouting) { } )EOF"; - Json::StringLoader loader(json); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); NiceMock runtime; NiceMock cm; - ConfigImpl config(loader, runtime, cm); + ConfigImpl config(*loader, runtime, cm); EXPECT_FALSE(config.usesRuntime()); @@ -511,10 +511,10 @@ TEST(RouteMatcherTest, ContentType) { } )EOF"; - Json::StringLoader loader(json); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); NiceMock runtime; NiceMock cm; - ConfigImpl config(loader, runtime, cm); + ConfigImpl config(*loader, runtime, cm); EXPECT_FALSE(config.usesRuntime()); @@ -562,14 +562,14 @@ TEST(RouteMatcherTest, Runtime) { } )EOF"; - Json::StringLoader loader(json); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); NiceMock runtime; NiceMock cm; Runtime::MockSnapshot snapshot; ON_CALL(runtime, snapshot()).WillByDefault(ReturnRef(snapshot)); - ConfigImpl config(loader, runtime, cm); + ConfigImpl config(*loader, runtime, cm); EXPECT_TRUE(config.usesRuntime()); @@ -607,10 +607,10 @@ TEST(RouteMatcherTest, RateLimit) { } )EOF"; - Json::StringLoader loader(json); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); NiceMock runtime; NiceMock cm; - ConfigImpl config(loader, runtime, cm); + ConfigImpl config(*loader, runtime, cm); EXPECT_FALSE(config.usesRuntime()); @@ -643,13 +643,13 @@ TEST(RouteMatcherTest, ShadowClusterNotFound) { } )EOF"; - Json::StringLoader loader(json); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); NiceMock runtime; NiceMock cm; EXPECT_CALL(cm, get("www2")).WillRepeatedly(Return(&cm.cluster_)); EXPECT_CALL(cm, get("some_cluster")).WillRepeatedly(Return(nullptr)); - EXPECT_THROW(ConfigImpl(loader, runtime, cm), EnvoyException); + EXPECT_THROW(ConfigImpl(*loader, runtime, cm), EnvoyException); } TEST(RouteMatcherTest, Shadow) { @@ -685,10 +685,10 @@ TEST(RouteMatcherTest, Shadow) { } )EOF"; - Json::StringLoader loader(json); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); NiceMock runtime; NiceMock cm; - ConfigImpl config(loader, runtime, cm); + ConfigImpl config(*loader, runtime, cm); EXPECT_TRUE(config.usesRuntime()); @@ -747,10 +747,10 @@ TEST(RouteMatcherTest, Retry) { } )EOF"; - Json::StringLoader loader(json); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); NiceMock runtime; NiceMock cm; - ConfigImpl config(loader, runtime, cm); + ConfigImpl config(*loader, runtime, cm); EXPECT_FALSE(config.usesRuntime()); @@ -809,10 +809,10 @@ TEST(RouteMatcherTest, TestBadDefaultConfig) { } )EOF"; - Json::StringLoader loader(json); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); NiceMock runtime; NiceMock cm; - EXPECT_THROW(ConfigImpl config(loader, runtime, cm), EnvoyException); + EXPECT_THROW(ConfigImpl config(*loader, runtime, cm), EnvoyException); } TEST(RouteMatcherTest, TestDuplicateDomainConfig) { @@ -843,10 +843,10 @@ TEST(RouteMatcherTest, TestDuplicateDomainConfig) { } )EOF"; - Json::StringLoader loader(json); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); NiceMock runtime; NiceMock cm; - EXPECT_THROW(ConfigImpl config(loader, runtime, cm), EnvoyException); + EXPECT_THROW(ConfigImpl config(*loader, runtime, cm), EnvoyException); } static Http::TestHeaderMapImpl genRedirectHeaders(const std::string& host, const std::string& path, @@ -909,10 +909,10 @@ TEST(RouteMatcherTest, Redirect) { } )EOF"; - Json::StringLoader loader(json); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); NiceMock runtime; NiceMock cm; - ConfigImpl config(loader, runtime, cm); + ConfigImpl config(*loader, runtime, cm); EXPECT_FALSE(config.usesRuntime()); diff --git a/test/common/ssl/connection_impl_test.cc b/test/common/ssl/connection_impl_test.cc index f299b344e903a..cdac48668d84b 100644 --- a/test/common/ssl/connection_impl_test.cc +++ b/test/common/ssl/connection_impl_test.cc @@ -26,8 +26,8 @@ TEST(SslConnectionImplTest, ClientAuth) { } )EOF"; - Json::StringLoader server_ctx_loader(server_ctx_json); - ContextConfigImpl server_ctx_config(server_ctx_loader); + Json::ObjectPtr server_ctx_loader = Json::Factory::LoadFromString(server_ctx_json); + ContextConfigImpl server_ctx_config(*server_ctx_loader); ServerContextImpl server_ctx("server_ctx", stats_store, server_ctx_config, runtime); Event::DispatcherImpl dispatcher; @@ -43,8 +43,8 @@ TEST(SslConnectionImplTest, ClientAuth) { } )EOF"; - Json::StringLoader client_ctx_loader(client_ctx_json); - ContextConfigImpl client_ctx_config(client_ctx_loader); + Json::ObjectPtr client_ctx_loader = Json::Factory::LoadFromString(client_ctx_json); + ContextConfigImpl client_ctx_config(*client_ctx_loader); ClientContextImpl client_ctx("client_ctx", stats_store, client_ctx_config); Network::ClientConnectionPtr client_connection = dispatcher.createSslClientConnection(client_ctx, "tcp://127.0.0.1:10000"); @@ -84,8 +84,8 @@ TEST(SslConnectionImplTest, ClientAuthBadVerification) { } )EOF"; - Json::StringLoader server_ctx_loader(server_ctx_json); - ContextConfigImpl server_ctx_config(server_ctx_loader); + Json::ObjectPtr server_ctx_loader = Json::Factory::LoadFromString(server_ctx_json); + ContextConfigImpl server_ctx_config(*server_ctx_loader); ServerContextImpl server_ctx("server_ctx", stats_store, server_ctx_config, runtime); Event::DispatcherImpl dispatcher; @@ -101,8 +101,8 @@ TEST(SslConnectionImplTest, ClientAuthBadVerification) { } )EOF"; - Json::StringLoader client_ctx_loader(client_ctx_json); - ContextConfigImpl client_ctx_config(client_ctx_loader); + Json::ObjectPtr client_ctx_loader = Json::Factory::LoadFromString(client_ctx_json); + ContextConfigImpl client_ctx_config(*client_ctx_loader); ClientContextImpl client_ctx("client_ctx", stats_store, client_ctx_config); Network::ClientConnectionPtr client_connection = dispatcher.createSslClientConnection(client_ctx, "tcp://127.0.0.1:10000"); @@ -138,8 +138,8 @@ TEST(SslConnectionImplTest, SslError) { } )EOF"; - Json::StringLoader server_ctx_loader(server_ctx_json); - ContextConfigImpl server_ctx_config(server_ctx_loader); + Json::ObjectPtr server_ctx_loader = Json::Factory::LoadFromString(server_ctx_json); + ContextConfigImpl server_ctx_config(*server_ctx_loader); ServerContextImpl server_ctx("server_ctx", stats_store, server_ctx_config, runtime); Event::DispatcherImpl dispatcher; diff --git a/test/common/ssl/context_impl_test.cc b/test/common/ssl/context_impl_test.cc index 3ef8e49b4fb73..9de192acf8083 100644 --- a/test/common/ssl/context_impl_test.cc +++ b/test/common/ssl/context_impl_test.cc @@ -26,8 +26,8 @@ TEST(SslContextImplTest, TestCipherSuites) { } )EOF"; - Json::StringLoader loader(json); - ContextConfigImpl cfg(loader); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); + ContextConfigImpl cfg(*loader); Stats::IsolatedStoreImpl store; EXPECT_THROW(ClientContextImpl("", store, cfg), EnvoyException); } @@ -40,8 +40,8 @@ TEST(SslContextImplTest, TestExpiringCert) { } )EOF"; - Json::StringLoader loader(json); - ContextConfigImpl cfg(loader); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); + ContextConfigImpl cfg(*loader); Stats::IsolatedStoreImpl store; ClientContextImpl context("", store, cfg); @@ -61,8 +61,8 @@ TEST(SslContextImplTest, TestExpiredCert) { } )EOF"; - Json::StringLoader loader(json); - ContextConfigImpl cfg(loader); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); + ContextConfigImpl cfg(*loader); Stats::IsolatedStoreImpl store; ClientContextImpl context("", store, cfg); EXPECT_EQ(0U, context.daysUntilFirstCertExpires()); @@ -77,8 +77,8 @@ TEST(SslContextImplTest, TestGetCertInformation) { } )EOF"; - Json::StringLoader loader(json); - ContextConfigImpl cfg(loader); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); + ContextConfigImpl cfg(*loader); Stats::IsolatedStoreImpl store; ClientContextImpl context("", store, cfg); @@ -99,8 +99,8 @@ TEST(SslContextImplTest, TestGetCertInformation) { } TEST(SslContextImplTest, TestNoCert) { - Json::StringLoader loader("{}"); - ContextConfigImpl cfg(loader); + Json::ObjectPtr loader = Json::Factory::LoadFromString("{}"); + ContextConfigImpl cfg(*loader); Stats::IsolatedStoreImpl store; ClientContextImpl context("", store, cfg); EXPECT_EQ("", context.getCaCertInformation()); diff --git a/test/common/tracing/http_tracer_impl_test.cc b/test/common/tracing/http_tracer_impl_test.cc index 7e0157e6cc5c0..615b1e3f3678b 100644 --- a/test/common/tracing/http_tracer_impl_test.cc +++ b/test/common/tracing/http_tracer_impl_test.cc @@ -328,9 +328,9 @@ class LightStepSinkTest : public Test { std::string valid_config = R"EOF( {"collector_cluster": "lightstep_saas"} )EOF"; - Json::StringLoader loader(valid_config); + Json::ObjectPtr loader = Json::Factory::LoadFromString(valid_config); - setup(loader, true); + setup(*loader, true); } const std::string operation_name_{"test"}; @@ -354,16 +354,16 @@ TEST_F(LightStepSinkTest, InitializeSink) { std::string invalid_config = R"EOF( {"fake" : "fake"} )EOF"; - Json::StringLoader loader(invalid_config); + Json::ObjectPtr loader = Json::Factory::LoadFromString(invalid_config); - EXPECT_THROW(setup(loader, false), EnvoyException); + EXPECT_THROW(setup(*loader, false), EnvoyException); } { std::string empty_config = "{}"; - Json::StringLoader loader(empty_config); + Json::ObjectPtr loader = Json::Factory::LoadFromString(empty_config); - EXPECT_THROW(setup(loader, false), EnvoyException); + EXPECT_THROW(setup(*loader, false), EnvoyException); } { @@ -373,9 +373,9 @@ TEST_F(LightStepSinkTest, InitializeSink) { std::string valid_config = R"EOF( {"collector_cluster": "lightstep_saas"} )EOF"; - Json::StringLoader loader(valid_config); + Json::ObjectPtr loader = Json::Factory::LoadFromString(valid_config); - EXPECT_THROW(setup(loader, false), EnvoyException); + EXPECT_THROW(setup(*loader, false), EnvoyException); } { @@ -386,9 +386,9 @@ TEST_F(LightStepSinkTest, InitializeSink) { std::string valid_config = R"EOF( {"collector_cluster": "lightstep_saas"} )EOF"; - Json::StringLoader loader(valid_config); + Json::ObjectPtr loader = Json::Factory::LoadFromString(valid_config); - EXPECT_THROW(setup(loader, false), EnvoyException); + EXPECT_THROW(setup(*loader, false), EnvoyException); } { @@ -398,9 +398,9 @@ TEST_F(LightStepSinkTest, InitializeSink) { std::string valid_config = R"EOF( {"collector_cluster": "lightstep_saas"} )EOF"; - Json::StringLoader loader(valid_config); + Json::ObjectPtr loader = Json::Factory::LoadFromString(valid_config); - setup(loader, true); + setup(*loader, true); } } diff --git a/test/common/upstream/cluster_manager_impl_test.cc b/test/common/upstream/cluster_manager_impl_test.cc index 751072a9dcdc1..be98d3c9f24e0 100644 --- a/test/common/upstream/cluster_manager_impl_test.cc +++ b/test/common/upstream/cluster_manager_impl_test.cc @@ -59,8 +59,8 @@ TEST_F(ClusterManagerImplTest, NoSdsConfig) { } )EOF"; - Json::StringLoader loader(json); - EXPECT_THROW(create(loader), EnvoyException); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); + EXPECT_THROW(create(*loader), EnvoyException); } TEST_F(ClusterManagerImplTest, UnknownClusterType) { @@ -76,8 +76,8 @@ TEST_F(ClusterManagerImplTest, UnknownClusterType) { } )EOF"; - Json::StringLoader loader(json); - EXPECT_THROW(create(loader), EnvoyException); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); + EXPECT_THROW(create(*loader), EnvoyException); } TEST_F(ClusterManagerImplTest, LocalClusterNotDefined) { @@ -102,8 +102,8 @@ TEST_F(ClusterManagerImplTest, LocalClusterNotDefined) { } )EOF"; - Json::StringLoader loader(json); - EXPECT_THROW(create(loader), EnvoyException); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); + EXPECT_THROW(create(*loader), EnvoyException); } TEST_F(ClusterManagerImplTest, LocalClusterDefined) { @@ -135,8 +135,8 @@ TEST_F(ClusterManagerImplTest, LocalClusterDefined) { } )EOF"; - Json::StringLoader loader(json); - create(loader); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); + create(*loader); } TEST_F(ClusterManagerImplTest, DuplicateCluster) { @@ -160,8 +160,8 @@ TEST_F(ClusterManagerImplTest, DuplicateCluster) { } )EOF"; - Json::StringLoader loader(json); - EXPECT_THROW(create(loader), EnvoyException); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); + EXPECT_THROW(create(*loader), EnvoyException); } TEST_F(ClusterManagerImplTest, UnknownHcType) { @@ -181,8 +181,8 @@ TEST_F(ClusterManagerImplTest, UnknownHcType) { } )EOF"; - Json::StringLoader loader(json); - EXPECT_THROW(create(loader), EnvoyException); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); + EXPECT_THROW(create(*loader), EnvoyException); } TEST_F(ClusterManagerImplTest, TcpHealthChecker) { @@ -212,11 +212,11 @@ TEST_F(ClusterManagerImplTest, TcpHealthChecker) { } )EOF"; - Json::StringLoader loader(json); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); Network::MockClientConnection* connection = new NiceMock(); EXPECT_CALL(dns_resolver_.dispatcher_, createClientConnection_("tcp://127.0.0.1:11001")) .WillOnce(Return(connection)); - create(loader); + create(*loader); } TEST_F(ClusterManagerImplTest, UnknownCluster) { @@ -233,8 +233,8 @@ TEST_F(ClusterManagerImplTest, UnknownCluster) { } )EOF"; - Json::StringLoader loader(json); - create(loader); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); + create(*loader); EXPECT_EQ(nullptr, cluster_manager_->get("hello")); EXPECT_THROW(cluster_manager_->httpConnPoolForCluster("hello", ResourcePriority::Default), EnvoyException); @@ -256,12 +256,12 @@ TEST_F(ClusterManagerImplTest, DynamicHostRemove) { } )EOF"; - Json::StringLoader loader(json); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); Network::DnsResolver::ResolveCb dns_callback; Event::MockTimer* dns_timer_ = new NiceMock(&dns_resolver_.dispatcher_); EXPECT_CALL(dns_resolver_, resolve(_, _)).WillRepeatedly(SaveArg<1>(&dns_callback)); - create(loader); + create(*loader); // Test for no hosts returning the correct values before we have hosts. EXPECT_EQ(nullptr, diff --git a/test/common/upstream/health_checker_impl_test.cc b/test/common/upstream/health_checker_impl_test.cc index 0fa55c00814f0..9ca96d8c04226 100644 --- a/test/common/upstream/health_checker_impl_test.cc +++ b/test/common/upstream/health_checker_impl_test.cc @@ -63,9 +63,9 @@ class HttpHealthCheckerImplTest : public testing::Test { } )EOF"; - Json::StringLoader config(json); + Json::ObjectPtr config = Json::Factory::LoadFromString(json); health_checker_.reset( - new TestHttpHealthCheckerImpl(*cluster_, config, dispatcher_, stats_, runtime_, random_)); + new TestHttpHealthCheckerImpl(*cluster_, *config, dispatcher_, stats_, runtime_, random_)); health_checker_->addHostCheckCompleteCb([this](HostPtr host, bool changed_state) -> void { onHostStatus(host, changed_state); }); } @@ -84,9 +84,9 @@ class HttpHealthCheckerImplTest : public testing::Test { } )EOF"; - Json::StringLoader config(json); + Json::ObjectPtr config = Json::Factory::LoadFromString(json); health_checker_.reset( - new TestHttpHealthCheckerImpl(*cluster_, config, dispatcher_, stats_, runtime_, random_)); + new TestHttpHealthCheckerImpl(*cluster_, *config, dispatcher_, stats_, runtime_, random_)); health_checker_->addHostCheckCompleteCb([this](HostPtr host, bool changed_state) -> void { onHostStatus(host, changed_state); }); } @@ -492,9 +492,9 @@ TEST(TcpHealthCheckMatcher, loadJsonBytes) { } )EOF"; - Json::StringLoader config(json); + Json::ObjectPtr config = Json::Factory::LoadFromString(json); TcpHealthCheckMatcher::MatchSegments segments = - TcpHealthCheckMatcher::loadJsonBytes(config.getObjectArray("bytes")); + TcpHealthCheckMatcher::loadJsonBytes(config->getObjectArray("bytes")); EXPECT_EQ(2U, segments.size()); } @@ -507,8 +507,8 @@ TEST(TcpHealthCheckMatcher, loadJsonBytes) { } )EOF"; - Json::StringLoader config(json); - EXPECT_THROW(TcpHealthCheckMatcher::loadJsonBytes(config.getObjectArray("bytes")), + Json::ObjectPtr config = Json::Factory::LoadFromString(json); + EXPECT_THROW(TcpHealthCheckMatcher::loadJsonBytes(config->getObjectArray("bytes")), EnvoyException); } @@ -521,8 +521,8 @@ TEST(TcpHealthCheckMatcher, loadJsonBytes) { } )EOF"; - Json::StringLoader config(json); - EXPECT_THROW(TcpHealthCheckMatcher::loadJsonBytes(config.getObjectArray("bytes")), + Json::ObjectPtr config = Json::Factory::LoadFromString(json); + EXPECT_THROW(TcpHealthCheckMatcher::loadJsonBytes(config->getObjectArray("bytes")), EnvoyException); } } @@ -541,9 +541,9 @@ TEST(TcpHealthCheckMatcher, match) { } )EOF"; - Json::StringLoader config(json); + Json::ObjectPtr config = Json::Factory::LoadFromString(json); TcpHealthCheckMatcher::MatchSegments segments = - TcpHealthCheckMatcher::loadJsonBytes(config.getObjectArray("bytes")); + TcpHealthCheckMatcher::loadJsonBytes(config->getObjectArray("bytes")); Buffer::OwnedImpl buffer; EXPECT_FALSE(TcpHealthCheckMatcher::match(segments, buffer)); @@ -585,9 +585,9 @@ class TcpHealthCheckerImplTest : public testing::Test { } )EOF"; - Json::StringLoader config(json); + Json::ObjectPtr config = Json::Factory::LoadFromString(json); health_checker_.reset( - new TcpHealthCheckerImpl(*cluster_, config, dispatcher_, stats_, runtime_, random_)); + new TcpHealthCheckerImpl(*cluster_, *config, dispatcher_, stats_, runtime_, random_)); } void expectSessionCreate() { diff --git a/test/common/upstream/logical_dns_cluster_test.cc b/test/common/upstream/logical_dns_cluster_test.cc index cdc5dd162d2a4..fe997c2072e5f 100644 --- a/test/common/upstream/logical_dns_cluster_test.cc +++ b/test/common/upstream/logical_dns_cluster_test.cc @@ -15,9 +15,9 @@ namespace Upstream { class LogicalDnsClusterTest : public testing::Test { public: void setup(const std::string& json) { - Json::StringLoader config(json); + Json::ObjectPtr config = Json::Factory::LoadFromString(json); resolve_timer_ = new Event::MockTimer(&dns_resolver_.dispatcher_); - cluster_.reset(new LogicalDnsCluster(config, runtime_, stats_store_, ssl_context_manager_, + cluster_.reset(new LogicalDnsCluster(*config, runtime_, stats_store_, ssl_context_manager_, dns_resolver_, tls_)); cluster_->addMemberUpdateCb([&](const std::vector&, const std::vector&) -> void { membership_updated_.ready(); }); diff --git a/test/common/upstream/outlier_detection_impl_test.cc b/test/common/upstream/outlier_detection_impl_test.cc index 53614d8b98dfa..9d3c2afed6dbb 100644 --- a/test/common/upstream/outlier_detection_impl_test.cc +++ b/test/common/upstream/outlier_detection_impl_test.cc @@ -10,10 +10,10 @@ using testing::NiceMock; namespace Upstream { TEST(OutlierDetectorImplFactoryTest, NoDetector) { - Json::StringLoader loader("{}"); + Json::ObjectPtr loader = Json::Factory::LoadFromString("{}"); MockCluster cluster; Event::MockDispatcher dispatcher; - EXPECT_EQ(nullptr, OutlierDetectorImplFactory::createForCluster(cluster, loader, dispatcher)); + EXPECT_EQ(nullptr, OutlierDetectorImplFactory::createForCluster(cluster, *loader, dispatcher)); } TEST(OutlierDetectorImplFactoryTest, Detector) { @@ -23,10 +23,10 @@ TEST(OutlierDetectorImplFactoryTest, Detector) { } )EOF"; - Json::StringLoader loader(json); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); NiceMock cluster; NiceMock dispatcher; - EXPECT_NE(nullptr, OutlierDetectorImplFactory::createForCluster(cluster, loader, dispatcher)); + EXPECT_NE(nullptr, OutlierDetectorImplFactory::createForCluster(cluster, *loader, dispatcher)); } TEST(OutlierDetectorImplTest, Callbacks) { diff --git a/test/common/upstream/sds_test.cc b/test/common/upstream/sds_test.cc index b1f63f0734251..bf8bba88cf9f1 100644 --- a/test/common/upstream/sds_test.cc +++ b/test/common/upstream/sds_test.cc @@ -33,10 +33,10 @@ class SdsTest : public testing::Test { } )EOF"; - Json::StringLoader config(raw_config); + Json::ObjectPtr config = Json::Factory::LoadFromString(raw_config); timer_ = new Event::MockTimer(&dispatcher_); - cluster_.reset(new SdsClusterImpl(config, runtime_, stats_, ssl_context_manager_, sds_config_, + cluster_.reset(new SdsClusterImpl(*config, runtime_, stats_, ssl_context_manager_, sds_config_, cm_, dispatcher_, random_)); } diff --git a/test/common/upstream/upstream_impl_test.cc b/test/common/upstream/upstream_impl_test.cc index 92e47a25bcfa3..b810c343032b1 100644 --- a/test/common/upstream/upstream_impl_test.cc +++ b/test/common/upstream/upstream_impl_test.cc @@ -81,8 +81,8 @@ TEST(StrictDnsClusterImplTest, Basic) { } )EOF"; - Json::StringLoader loader(json); - StrictDnsClusterImpl cluster(loader, runtime, stats, ssl_context_manager, dns_resolver); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); + StrictDnsClusterImpl cluster(*loader, runtime, stats, ssl_context_manager, dns_resolver); EXPECT_EQ(43U, cluster.resourceManager(ResourcePriority::Default).connections().max()); EXPECT_EQ(57U, cluster.resourceManager(ResourcePriority::Default).pendingRequests().max()); EXPECT_EQ(50U, cluster.resourceManager(ResourcePriority::Default).requests().max()); @@ -206,8 +206,8 @@ TEST(StaticClusterImplTest, OutlierDetector) { } )EOF"; - Json::StringLoader config(json); - StaticClusterImpl cluster(config, runtime, stats, ssl_context_manager); + Json::ObjectPtr config = Json::Factory::LoadFromString(json); + StaticClusterImpl cluster(*config, runtime, stats, ssl_context_manager); MockOutlierDetector* detector = new MockOutlierDetector(); EXPECT_CALL(*detector, addChangedStateCb(_)); @@ -244,8 +244,8 @@ TEST(StaticClusterImplTest, UrlConfig) { } )EOF"; - Json::StringLoader config(json); - StaticClusterImpl cluster(config, runtime, stats, ssl_context_manager); + Json::ObjectPtr config = Json::Factory::LoadFromString(json); + StaticClusterImpl cluster(*config, runtime, stats, ssl_context_manager); EXPECT_EQ(1024U, cluster.resourceManager(ResourcePriority::Default).connections().max()); EXPECT_EQ(1024U, cluster.resourceManager(ResourcePriority::Default).pendingRequests().max()); EXPECT_EQ(1024U, cluster.resourceManager(ResourcePriority::Default).requests().max()); @@ -279,8 +279,8 @@ TEST(StaticClusterImplTest, UnsupportedLBType) { } )EOF"; - Json::StringLoader config(json); - EXPECT_THROW(StaticClusterImpl(config, runtime, stats, ssl_context_manager), EnvoyException); + Json::ObjectPtr config = Json::Factory::LoadFromString(json); + EXPECT_THROW(StaticClusterImpl(*config, runtime, stats, ssl_context_manager), EnvoyException); } TEST(StaticClusterImplTest, UnsupportedFeature) { @@ -299,8 +299,8 @@ TEST(StaticClusterImplTest, UnsupportedFeature) { } )EOF"; - Json::StringLoader config(json); - EXPECT_THROW(StaticClusterImpl(config, runtime, stats, ssl_context_manager), EnvoyException); + Json::ObjectPtr config = Json::Factory::LoadFromString(json); + EXPECT_THROW(StaticClusterImpl(*config, runtime, stats, ssl_context_manager), EnvoyException); } } // Upstream diff --git a/test/integration/ssl_integration_test.cc b/test/integration/ssl_integration_test.cc index d3a19ecf40b7e..d634cc853a6c7 100644 --- a/test/integration/ssl_integration_test.cc +++ b/test/integration/ssl_integration_test.cc @@ -21,8 +21,8 @@ ServerContextPtr SslIntegrationTest::createUpstreamSslContext(const std::string& } )EOF"; - Json::StringLoader loader(json); - ContextConfigImpl cfg(loader); + Json::ObjectPtr loader = Json::Factory::LoadFromString(json); + ContextConfigImpl cfg(*loader); return ServerContextPtr(new TestServerContextImpl(name, store, cfg)); } @@ -45,8 +45,8 @@ ClientContextPtr SslIntegrationTest::createClientSslContext(const std::string& n } )EOF"; - Json::StringLoader loader(alpn ? json_alpn : json_no_alpn); - ContextConfigImpl cfg(loader); + Json::ObjectPtr loader = Json::Factory::LoadFromString(alpn ? json_alpn : json_no_alpn); + ContextConfigImpl cfg(*loader); return ClientContextPtr(new ClientContextImpl(name, store, cfg)); } diff --git a/test/server/http/health_check_test.cc b/test/server/http/health_check_test.cc index 108c7d68c912a..daca189202970 100644 --- a/test/server/http/health_check_test.cc +++ b/test/server/http/health_check_test.cc @@ -196,22 +196,23 @@ TEST_F(HealthCheckFilterCachingTest, NotHcRequest) { TEST(HealthCheckFilterConfig, failsWhenNotPassThroughButTimeoutSet) { Server::Configuration::HealthCheckFilterConfig healthCheckFilterConfig; - Json::StringLoader config( + Json::ObjectPtr config = Json::Factory::LoadFromString( "{\"pass_through_mode\":false, \"cache_time_ms\":234, \"endpoint\":\"foo\"}"); NiceMock serverMock; EXPECT_THROW(healthCheckFilterConfig.tryCreateFilterFactory( - Server::Configuration::HttpFilterType::Both, "health_check", config, + Server::Configuration::HttpFilterType::Both, "health_check", *config, "dummy_stats_prefix", serverMock), EnvoyException); } TEST(HealthCheckFilterConfig, notFailingWhenNotPassThroughAndTimeoutNotSet) { Server::Configuration::HealthCheckFilterConfig healthCheckFilterConfig; - Json::StringLoader config("{\"pass_through_mode\":false, \"endpoint\":\"foo\"}"); + Json::ObjectPtr config = + Json::Factory::LoadFromString("{\"pass_through_mode\":false, \"endpoint\":\"foo\"}"); NiceMock serverMock; healthCheckFilterConfig.tryCreateFilterFactory(Server::Configuration::HttpFilterType::Both, - "health_check", config, "dummy_stats_prefix", + "health_check", *config, "dummy_stats_prefix", serverMock); }