From 356e7c21079659aa083e131acb0c5cb4d6709feb Mon Sep 17 00:00:00 2001 From: "Mark D. Roth" Date: Tue, 14 May 2019 14:37:20 -0700 Subject: [PATCH] Clean up some names in the service config code. --- .../filters/client_channel/client_channel.cc | 26 ++-- .../client_channel/resolver_result_parsing.cc | 14 +- .../client_channel/resolver_result_parsing.h | 8 +- .../filters/client_channel/service_config.cc | 42 +++-- .../filters/client_channel/service_config.h | 54 ++++--- .../message_size/message_size_filter.cc | 24 +-- .../message_size/message_size_filter.h | 4 +- src/core/lib/channel/context.h | 2 +- .../client_channel/service_config_test.cc | 144 +++++++++--------- 9 files changed, 157 insertions(+), 161 deletions(-) diff --git a/src/core/ext/filters/client_channel/client_channel.cc b/src/core/ext/filters/client_channel/client_channel.cc index cc4bfdded13..c0586d459b2 100644 --- a/src/core/ext/filters/client_channel/client_channel.cc +++ b/src/core/ext/filters/client_channel/client_channel.cc @@ -66,7 +66,7 @@ #include "src/core/lib/transport/static_metadata.h" #include "src/core/lib/transport/status_metadata.h" -using grpc_core::internal::ClientChannelMethodParsedObject; +using grpc_core::internal::ClientChannelMethodParsedConfig; using grpc_core::internal::ServerRetryThrottleData; // @@ -234,7 +234,7 @@ class ChannelData { void ProcessLbPolicy( const Resolver::Result& resolver_result, - const internal::ClientChannelGlobalParsedObject* parsed_service_config, + const internal::ClientChannelGlobalParsedConfig* parsed_service_config, UniquePtr* lb_policy_name, RefCountedPtr* lb_policy_config); @@ -629,7 +629,7 @@ class CallData { RefCountedPtr retry_throttle_data_; ServiceConfig::CallData service_config_call_data_; - const ClientChannelMethodParsedObject* method_params_ = nullptr; + const ClientChannelMethodParsedConfig* method_params_ = nullptr; RefCountedPtr subchannel_call_; @@ -772,7 +772,7 @@ class ChannelData::ServiceConfigSetter { public: ServiceConfigSetter( ChannelData* chand, - Optional + Optional retry_throttle_data, RefCountedPtr service_config) : chand_(chand), @@ -811,7 +811,7 @@ class ChannelData::ServiceConfigSetter { } ChannelData* chand_; - Optional + Optional retry_throttle_data_; RefCountedPtr service_config_; grpc_closure closure_; @@ -1141,7 +1141,7 @@ ChannelData::~ChannelData() { void ChannelData::ProcessLbPolicy( const Resolver::Result& resolver_result, - const internal::ClientChannelGlobalParsedObject* parsed_service_config, + const internal::ClientChannelGlobalParsedConfig* parsed_service_config, UniquePtr* lb_policy_name, RefCountedPtr* lb_policy_config) { // Prefer the LB policy name found in the service config. @@ -1238,12 +1238,12 @@ bool ChannelData::ProcessResolverResultLocked( } // Process service config. UniquePtr service_config_json; - const internal::ClientChannelGlobalParsedObject* parsed_service_config = + const internal::ClientChannelGlobalParsedConfig* parsed_service_config = nullptr; if (service_config != nullptr) { parsed_service_config = - static_cast( - service_config->GetParsedGlobalServiceConfigObject( + static_cast( + service_config->GetGlobalParsedConfig( internal::ClientChannelServiceConfigParser::ParserIndex())); } // TODO(roth): Eliminate this hack as part of hiding health check @@ -1282,7 +1282,7 @@ bool ChannelData::ProcessResolverResultLocked( // if we feel it is unnecessary. if (service_config_changed || !chand->received_first_resolver_result_) { chand->received_first_resolver_result_ = true; - Optional + Optional retry_throttle_data; if (parsed_service_config != nullptr) { retry_throttle_data = parsed_service_config->retry_throttling(); @@ -3245,10 +3245,10 @@ void CallData::ApplyServiceConfigToCallLocked(grpc_call_element* elem) { service_config_call_data_ = ServiceConfig::CallData(chand->service_config(), path_); if (service_config_call_data_.service_config() != nullptr) { - call_context_[GRPC_SERVICE_CONFIG_CALL_DATA].value = + call_context_[GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA].value = &service_config_call_data_; - method_params_ = static_cast( - service_config_call_data_.GetMethodParsedObject( + method_params_ = static_cast( + service_config_call_data_.GetMethodParsedConfig( internal::ClientChannelServiceConfigParser::ParserIndex())); } retry_throttle_data_ = chand->retry_throttle_data(); diff --git a/src/core/ext/filters/client_channel/resolver_result_parsing.cc b/src/core/ext/filters/client_channel/resolver_result_parsing.cc index ac6bc7ed16a..6a811a2d936 100644 --- a/src/core/ext/filters/client_channel/resolver_result_parsing.cc +++ b/src/core/ext/filters/client_channel/resolver_result_parsing.cc @@ -92,11 +92,11 @@ bool ParseDuration(grpc_json* field, grpc_millis* duration) { return true; } -UniquePtr ParseRetryPolicy( +UniquePtr ParseRetryPolicy( grpc_json* field, grpc_error** error) { GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE); auto retry_policy = - MakeUnique(); + MakeUnique(); if (field->type != GRPC_JSON_OBJECT) { *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING( "field:retryPolicy error:should be of type object"); @@ -270,7 +270,7 @@ ClientChannelServiceConfigParser::ParseGlobalParams(const grpc_json* json, InlinedVector error_list; RefCountedPtr parsed_lb_config; UniquePtr lb_policy_name; - Optional retry_throttling; + Optional retry_throttling; const char* health_check_service_name = nullptr; for (grpc_json* field = json->child; field != nullptr; field = field->next) { if (field->key == nullptr) { @@ -409,7 +409,7 @@ ClientChannelServiceConfigParser::ParseGlobalParams(const grpc_json* json, } } } - ClientChannelGlobalParsedObject::RetryThrottling data; + ClientChannelGlobalParsedConfig::RetryThrottling data; if (!max_milli_tokens.has_value()) { error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING( "field:retryThrottling field:maxTokens error:Not found")); @@ -440,7 +440,7 @@ ClientChannelServiceConfigParser::ParseGlobalParams(const grpc_json* json, &error_list); if (*error == GRPC_ERROR_NONE) { return UniquePtr( - New( + New( std::move(parsed_lb_config), std::move(lb_policy_name), retry_throttling, health_check_service_name)); } @@ -454,7 +454,7 @@ ClientChannelServiceConfigParser::ParsePerMethodParams(const grpc_json* json, InlinedVector error_list; Optional wait_for_ready; grpc_millis timeout = 0; - UniquePtr retry_policy; + UniquePtr retry_policy; for (grpc_json* field = json->child; field != nullptr; field = field->next) { if (field->key == nullptr) continue; if (strcmp(field->key, "waitForReady") == 0) { @@ -494,7 +494,7 @@ ClientChannelServiceConfigParser::ParsePerMethodParams(const grpc_json* json, *error = GRPC_ERROR_CREATE_FROM_VECTOR("Client channel parser", &error_list); if (*error == GRPC_ERROR_NONE) { return UniquePtr( - New(timeout, wait_for_ready, + New(timeout, wait_for_ready, std::move(retry_policy))); } return nullptr; diff --git a/src/core/ext/filters/client_channel/resolver_result_parsing.h b/src/core/ext/filters/client_channel/resolver_result_parsing.h index 9af8b16876a..7750791c779 100644 --- a/src/core/ext/filters/client_channel/resolver_result_parsing.h +++ b/src/core/ext/filters/client_channel/resolver_result_parsing.h @@ -37,14 +37,14 @@ namespace grpc_core { namespace internal { -class ClientChannelGlobalParsedObject : public ServiceConfig::ParsedConfig { +class ClientChannelGlobalParsedConfig : public ServiceConfig::ParsedConfig { public: struct RetryThrottling { intptr_t max_milli_tokens = 0; intptr_t milli_token_ratio = 0; }; - ClientChannelGlobalParsedObject( + ClientChannelGlobalParsedConfig( RefCountedPtr parsed_lb_config, UniquePtr parsed_deprecated_lb_policy, const Optional& retry_throttling, @@ -77,7 +77,7 @@ class ClientChannelGlobalParsedObject : public ServiceConfig::ParsedConfig { const char* health_check_service_name_; }; -class ClientChannelMethodParsedObject : public ServiceConfig::ParsedConfig { +class ClientChannelMethodParsedConfig : public ServiceConfig::ParsedConfig { public: struct RetryPolicy { int max_attempts = 0; @@ -87,7 +87,7 @@ class ClientChannelMethodParsedObject : public ServiceConfig::ParsedConfig { StatusCodeSet retryable_status_codes; }; - ClientChannelMethodParsedObject(grpc_millis timeout, + ClientChannelMethodParsedConfig(grpc_millis timeout, const Optional& wait_for_ready, UniquePtr retry_policy) : timeout_(timeout), diff --git a/src/core/ext/filters/client_channel/service_config.cc b/src/core/ext/filters/client_channel/service_config.cc index 86d4f7368c0..d41859bf45a 100644 --- a/src/core/ext/filters/client_channel/service_config.cc +++ b/src/core/ext/filters/client_channel/service_config.cc @@ -96,16 +96,15 @@ grpc_error* ServiceConfig::ParseGlobalParams(const grpc_json* json_tree) { if (parser_error != GRPC_ERROR_NONE) { error_list.push_back(parser_error); } - parsed_global_service_config_objects_.push_back(std::move(parsed_obj)); + parsed_global_configs_.push_back(std::move(parsed_obj)); } return GRPC_ERROR_CREATE_FROM_VECTOR("Global Params", &error_list); } -grpc_error* ServiceConfig::ParseJsonMethodConfigToServiceConfigObjectsTable( +grpc_error* ServiceConfig::ParseJsonMethodConfigToServiceConfigVectorTable( const grpc_json* json, - SliceHashTable::Entry* entries, - size_t* idx) { - auto objs_vector = MakeUnique(); + SliceHashTable::Entry* entries, size_t* idx) { + auto objs_vector = MakeUnique(); InlinedVector error_list; for (size_t i = 0; i < g_registered_parsers->size(); i++) { grpc_error* parser_error = GRPC_ERROR_NONE; @@ -116,10 +115,10 @@ grpc_error* ServiceConfig::ParseJsonMethodConfigToServiceConfigObjectsTable( } objs_vector->push_back(std::move(parsed_obj)); } - service_config_objects_vectors_storage_.push_back(std::move(objs_vector)); + parsed_method_config_vectors_storage_.push_back(std::move(objs_vector)); const auto* vector_ptr = - service_config_objects_vectors_storage_ - [service_config_objects_vectors_storage_.size() - 1] + parsed_method_config_vectors_storage_ + [parsed_method_config_vectors_storage_.size() - 1] .get(); // Construct list of paths. InlinedVector, 10> paths; @@ -160,7 +159,7 @@ wrap_error: grpc_error* ServiceConfig::ParsePerMethodParams(const grpc_json* json_tree) { GPR_DEBUG_ASSERT(json_tree_->type == GRPC_JSON_OBJECT); GPR_DEBUG_ASSERT(json_tree_->key == nullptr); - SliceHashTable::Entry* entries = nullptr; + SliceHashTable::Entry* entries = nullptr; size_t num_entries = 0; InlinedVector error_list; for (grpc_json* field = json_tree->child; field != nullptr; @@ -187,14 +186,13 @@ grpc_error* ServiceConfig::ParsePerMethodParams(const grpc_json* json_tree) { } num_entries += static_cast(count); } - entries = static_cast< - SliceHashTable::Entry*>(gpr_zalloc( - num_entries * - sizeof(SliceHashTable::Entry))); + entries = static_cast::Entry*>( + gpr_zalloc(num_entries * + sizeof(SliceHashTable::Entry))); size_t idx = 0; for (grpc_json* method = field->child; method != nullptr; method = method->next) { - grpc_error* error = ParseJsonMethodConfigToServiceConfigObjectsTable( + grpc_error* error = ParseJsonMethodConfigToServiceConfigVectorTable( method, entries, &idx); if (error != GRPC_ERROR_NONE) { error_list.push_back(error); @@ -206,9 +204,9 @@ grpc_error* ServiceConfig::ParsePerMethodParams(const grpc_json* json_tree) { } } if (entries != nullptr) { - parsed_method_service_config_objects_table_ = - SliceHashTable::Create( - num_entries, entries, nullptr); + parsed_method_configs_table_ = + SliceHashTable::Create(num_entries, entries, + nullptr); gpr_free(entries); } return GRPC_ERROR_CREATE_FROM_VECTOR("Method Params", &error_list); @@ -287,12 +285,12 @@ UniquePtr ServiceConfig::ParseJsonMethodName(grpc_json* json, return UniquePtr(path); } -const ServiceConfig::ServiceConfigObjectsVector* -ServiceConfig::GetMethodServiceConfigObjectsVector(const grpc_slice& path) { - if (parsed_method_service_config_objects_table_.get() == nullptr) { +const ServiceConfig::ParsedConfigVector* +ServiceConfig::GetMethodParsedConfigVector(const grpc_slice& path) { + if (parsed_method_configs_table_.get() == nullptr) { return nullptr; } - const auto* value = parsed_method_service_config_objects_table_->Get(path); + const auto* value = parsed_method_configs_table_->Get(path); // If we didn't find a match for the path, try looking for a wildcard // entry (i.e., change "/service/method" to "/service/*"). if (value == nullptr) { @@ -305,7 +303,7 @@ ServiceConfig::GetMethodServiceConfigObjectsVector(const grpc_slice& path) { buf[len + 1] = '\0'; grpc_slice wildcard_path = grpc_slice_from_copied_string(buf); gpr_free(buf); - value = parsed_method_service_config_objects_table_->Get(wildcard_path); + value = parsed_method_configs_table_->Get(wildcard_path); grpc_slice_unref_internal(wildcard_path); gpr_free(path_str); if (value == nullptr) return nullptr; diff --git a/src/core/ext/filters/client_channel/service_config.h b/src/core/ext/filters/client_channel/service_config.h index e6f855ad934..189a0b9bca2 100644 --- a/src/core/ext/filters/client_channel/service_config.h +++ b/src/core/ext/filters/client_channel/service_config.h @@ -88,7 +88,7 @@ class ServiceConfig : public RefCounted { static constexpr int kNumPreallocatedParsers = 4; typedef InlinedVector, kNumPreallocatedParsers> - ServiceConfigObjectsVector; + ParsedConfigVector; /// When a service config is applied to a call in the client_channel_filter, /// we create an instance of this object and store it in the call_data for @@ -102,25 +102,25 @@ class ServiceConfig : public RefCounted { : service_config_(std::move(svc_cfg)) { if (service_config_ != nullptr) { method_params_vector_ = - service_config_->GetMethodServiceConfigObjectsVector(path); + service_config_->GetMethodParsedConfigVector(path); } } ServiceConfig* service_config() { return service_config_.get(); } - ParsedConfig* GetMethodParsedObject(size_t index) const { + ParsedConfig* GetMethodParsedConfig(size_t index) const { return method_params_vector_ != nullptr ? (*method_params_vector_)[index].get() : nullptr; } - ParsedConfig* GetGlobalParsedObject(size_t index) const { - return service_config_->GetParsedGlobalServiceConfigObject(index); + ParsedConfig* GetGlobalParsedConfig(size_t index) const { + return service_config_->GetGlobalParsedConfig(index); } private: RefCountedPtr service_config_; - const ServiceConfigObjectsVector* method_params_vector_ = nullptr; + const ParsedConfigVector* method_params_vector_ = nullptr; }; /// Creates a new service config from parsing \a json_string. @@ -132,25 +132,24 @@ class ServiceConfig : public RefCounted { const char* service_config_json() const { return service_config_json_.get(); } - /// Retrieves the parsed global service config object at index \a index. The + /// Retrieves the global parsed config at index \a index. The /// lifetime of the returned object is tied to the lifetime of the /// ServiceConfig object. - ParsedConfig* GetParsedGlobalServiceConfigObject(size_t index) { - GPR_DEBUG_ASSERT(index < parsed_global_service_config_objects_.size()); - return parsed_global_service_config_objects_[index].get(); + ParsedConfig* GetGlobalParsedConfig(size_t index) { + GPR_DEBUG_ASSERT(index < parsed_global_configs_.size()); + return parsed_global_configs_[index].get(); } - /// Retrieves the vector of method service config objects for a given path \a - /// path. The lifetime of the returned vector and contained objects is tied to - /// the lifetime of the ServiceConfig object. - const ServiceConfigObjectsVector* GetMethodServiceConfigObjectsVector( - const grpc_slice& path); + /// Retrieves the vector of parsed configs for the method identified + /// by \a path. The lifetime of the returned vector and contained objects + /// is tied to the lifetime of the ServiceConfig object. + const ParsedConfigVector* GetMethodParsedConfigVector(const grpc_slice& path); /// Globally register a service config parser. On successful registration, it /// returns the index at which the parser was registered. On failure, -1 is /// returned. Each new service config update will go through all the /// registered parser. Each parser is responsible for reading the service - /// config json and returning a parsed object. This parsed object can later be + /// config json and returning a parsed config. This parsed config can later be /// retrieved using the same index that was returned at registration time. static size_t RegisterParser(UniquePtr parser); @@ -180,26 +179,25 @@ class ServiceConfig : public RefCounted { static UniquePtr ParseJsonMethodName(grpc_json* json, grpc_error** error); - grpc_error* ParseJsonMethodConfigToServiceConfigObjectsTable( + grpc_error* ParseJsonMethodConfigToServiceConfigVectorTable( const grpc_json* json, - SliceHashTable::Entry* entries, - size_t* idx); + SliceHashTable::Entry* entries, size_t* idx); UniquePtr service_config_json_; UniquePtr json_string_; // Underlying storage for json_tree. grpc_json* json_tree_; InlinedVector, kNumPreallocatedParsers> - parsed_global_service_config_objects_; - // A map from the method name to the service config objects vector. Note that - // we are using a raw pointer and not a unique pointer so that we can use the - // same vector for multiple names. - RefCountedPtr> - parsed_method_service_config_objects_table_; + parsed_global_configs_; + // A map from the method name to the parsed config vector. Note that we are + // using a raw pointer and not a unique pointer so that we can use the same + // vector for multiple names. + RefCountedPtr> + parsed_method_configs_table_; // Storage for all the vectors that are being used in - // parsed_method_service_config_objects_table_. - InlinedVector, 32> - service_config_objects_vectors_storage_; + // parsed_method_configs_table_. + InlinedVector, 32> + parsed_method_config_vectors_storage_; }; } // namespace grpc_core diff --git a/src/core/ext/filters/message_size/message_size_filter.cc b/src/core/ext/filters/message_size/message_size_filter.cc index a973cbca121..8e93d11c9c0 100644 --- a/src/core/ext/filters/message_size/message_size_filter.cc +++ b/src/core/ext/filters/message_size/message_size_filter.cc @@ -88,7 +88,7 @@ UniquePtr MessageSizeParser::ParsePerMethodParams( *error = GRPC_ERROR_CREATE_FROM_VECTOR("Message size parser", &error_list); return nullptr; } - return UniquePtr(New( + return UniquePtr(New( max_request_message_bytes, max_response_message_bytes)); } @@ -102,7 +102,7 @@ size_t MessageSizeParser::ParserIndex() { return g_message_size_parser_index; } namespace { struct channel_data { - grpc_core::MessageSizeParsedObject::message_size_limits limits; + grpc_core::MessageSizeParsedConfig::message_size_limits limits; grpc_core::RefCountedPtr svc_cfg; }; @@ -119,21 +119,21 @@ struct call_data { // Note: Per-method config is only available on the client, so we // apply the max request size to the send limit and the max response // size to the receive limit. - const grpc_core::MessageSizeParsedObject* limits = nullptr; + const grpc_core::MessageSizeParsedConfig* limits = nullptr; grpc_core::ServiceConfig::CallData* svc_cfg_call_data = nullptr; if (args.context != nullptr) { svc_cfg_call_data = static_cast( - args.context[GRPC_SERVICE_CONFIG_CALL_DATA].value); + args.context[GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA].value); } if (svc_cfg_call_data != nullptr) { - limits = static_cast( - svc_cfg_call_data->GetMethodParsedObject( + limits = static_cast( + svc_cfg_call_data->GetMethodParsedConfig( grpc_core::MessageSizeParser::ParserIndex())); } else if (chand.svc_cfg != nullptr) { const auto* objs_vector = - chand.svc_cfg->GetMethodServiceConfigObjectsVector(args.path); + chand.svc_cfg->GetMethodParsedConfigVector(args.path); if (objs_vector != nullptr) { - limits = static_cast( + limits = static_cast( (*objs_vector)[grpc_core::MessageSizeParser::ParserIndex()].get()); } } @@ -154,7 +154,7 @@ struct call_data { ~call_data() { GRPC_ERROR_UNREF(error); } grpc_core::CallCombiner* call_combiner; - grpc_core::MessageSizeParsedObject::message_size_limits limits; + grpc_core::MessageSizeParsedConfig::message_size_limits limits; // Receive closures are chained: we inject this closure as the // recv_message_ready up-call on transport_stream_op, and remember to // call our next_recv_message_ready member after handling it. @@ -300,9 +300,9 @@ static int default_size(const grpc_channel_args* args, return without_minimal_stack; } -grpc_core::MessageSizeParsedObject::message_size_limits get_message_size_limits( +grpc_core::MessageSizeParsedConfig::message_size_limits get_message_size_limits( const grpc_channel_args* channel_args) { - grpc_core::MessageSizeParsedObject::message_size_limits lim; + grpc_core::MessageSizeParsedConfig::message_size_limits lim; lim.max_send_size = default_size(channel_args, GRPC_DEFAULT_MAX_SEND_MESSAGE_LENGTH); lim.max_recv_size = @@ -392,7 +392,7 @@ static bool maybe_add_message_size_filter(grpc_channel_stack_builder* builder, const grpc_channel_args* channel_args = grpc_channel_stack_builder_get_channel_arguments(builder); bool enable = false; - grpc_core::MessageSizeParsedObject::message_size_limits lim = + grpc_core::MessageSizeParsedConfig::message_size_limits lim = get_message_size_limits(channel_args); if (lim.max_send_size != -1 || lim.max_recv_size != -1) { enable = true; diff --git a/src/core/ext/filters/message_size/message_size_filter.h b/src/core/ext/filters/message_size/message_size_filter.h index cab8bd9627f..1dde55f40b1 100644 --- a/src/core/ext/filters/message_size/message_size_filter.h +++ b/src/core/ext/filters/message_size/message_size_filter.h @@ -26,14 +26,14 @@ extern const grpc_channel_filter grpc_message_size_filter; namespace grpc_core { -class MessageSizeParsedObject : public ServiceConfig::ParsedConfig { +class MessageSizeParsedConfig : public ServiceConfig::ParsedConfig { public: struct message_size_limits { int max_send_size; int max_recv_size; }; - MessageSizeParsedObject(int max_send_size, int max_recv_size) { + MessageSizeParsedConfig(int max_send_size, int max_recv_size) { limits_.max_send_size = max_send_size; limits_.max_recv_size = max_recv_size; } diff --git a/src/core/lib/channel/context.h b/src/core/lib/channel/context.h index fd9d0ce711a..e8a024547f6 100644 --- a/src/core/lib/channel/context.h +++ b/src/core/lib/channel/context.h @@ -36,7 +36,7 @@ typedef enum { GRPC_CONTEXT_TRAFFIC, /// Holds a pointer to ServiceConfig::CallData associated with this call. - GRPC_SERVICE_CONFIG_CALL_DATA, + GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA, GRPC_CONTEXT_COUNT } grpc_context_index; diff --git a/test/core/client_channel/service_config_test.cc b/test/core/client_channel/service_config_test.cc index 9734304c9ac..919441d706a 100644 --- a/test/core/client_channel/service_config_test.cc +++ b/test/core/client_channel/service_config_test.cc @@ -31,9 +31,9 @@ namespace grpc_core { namespace testing { -class TestParsedObject1 : public ServiceConfig::ParsedConfig { +class TestParsedConfig1 : public ServiceConfig::ParsedConfig { public: - TestParsedObject1(int value) : value_(value) {} + TestParsedConfig1(int value) : value_(value) {} int value() const { return value_; } @@ -61,7 +61,7 @@ class TestParser1 : public ServiceConfig::Parser { return nullptr; } return UniquePtr( - New(value)); + New(value)); } } return nullptr; @@ -99,7 +99,7 @@ class TestParser2 : public ServiceConfig::Parser { return nullptr; } return UniquePtr( - New(value)); + New(value)); } } return nullptr; @@ -216,10 +216,10 @@ TEST_F(ServiceConfigTest, Parser1BasicTest1) { grpc_error* error = GRPC_ERROR_NONE; auto svc_cfg = ServiceConfig::Create(test_json, &error); ASSERT_TRUE(error == GRPC_ERROR_NONE); - EXPECT_TRUE((static_cast( - svc_cfg->GetParsedGlobalServiceConfigObject(0))) - ->value() == 5); - EXPECT_TRUE(svc_cfg->GetMethodServiceConfigObjectsVector( + EXPECT_TRUE( + (static_cast(svc_cfg->GetGlobalParsedConfig(0))) + ->value() == 5); + EXPECT_TRUE(svc_cfg->GetMethodParsedConfigVector( grpc_slice_from_static_string("/TestServ/TestMethod")) == nullptr); } @@ -229,9 +229,9 @@ TEST_F(ServiceConfigTest, Parser1BasicTest2) { grpc_error* error = GRPC_ERROR_NONE; auto svc_cfg = ServiceConfig::Create(test_json, &error); ASSERT_TRUE(error == GRPC_ERROR_NONE); - EXPECT_TRUE((static_cast( - svc_cfg->GetParsedGlobalServiceConfigObject(0))) - ->value() == 1000); + EXPECT_TRUE( + (static_cast(svc_cfg->GetGlobalParsedConfig(0))) + ->value() == 1000); } TEST_F(ServiceConfigTest, Parser1ErrorInvalidType) { @@ -267,11 +267,11 @@ TEST_F(ServiceConfigTest, Parser2BasicTest) { grpc_error* error = GRPC_ERROR_NONE; auto svc_cfg = ServiceConfig::Create(test_json, &error); ASSERT_TRUE(error == GRPC_ERROR_NONE); - const auto* vector_ptr = svc_cfg->GetMethodServiceConfigObjectsVector( + const auto* vector_ptr = svc_cfg->GetMethodParsedConfigVector( grpc_slice_from_static_string("/TestServ/TestMethod")); EXPECT_TRUE(vector_ptr != nullptr); - auto parsed_object = ((*vector_ptr)[1]).get(); - EXPECT_TRUE(static_cast(parsed_object)->value() == 5); + auto parsed_config = ((*vector_ptr)[1]).get(); + EXPECT_TRUE(static_cast(parsed_config)->value() == 5); } TEST_F(ServiceConfigTest, Parser2ErrorInvalidType) { @@ -371,10 +371,10 @@ TEST_F(ClientChannelParserTest, ValidLoadBalancingConfigPickFirst) { grpc_error* error = GRPC_ERROR_NONE; auto svc_cfg = ServiceConfig::Create(test_json, &error); ASSERT_TRUE(error == GRPC_ERROR_NONE); - const auto* parsed_object = - static_cast( - svc_cfg->GetParsedGlobalServiceConfigObject(0)); - auto lb_config = parsed_object->parsed_lb_config(); + const auto* parsed_config = + static_cast( + svc_cfg->GetGlobalParsedConfig(0)); + auto lb_config = parsed_config->parsed_lb_config(); EXPECT_TRUE(strcmp(lb_config->name(), "pick_first") == 0); } @@ -384,10 +384,10 @@ TEST_F(ClientChannelParserTest, ValidLoadBalancingConfigRoundRobin) { grpc_error* error = GRPC_ERROR_NONE; auto svc_cfg = ServiceConfig::Create(test_json, &error); ASSERT_TRUE(error == GRPC_ERROR_NONE); - auto parsed_object = - static_cast( - svc_cfg->GetParsedGlobalServiceConfigObject(0)); - auto lb_config = parsed_object->parsed_lb_config(); + auto parsed_config = + static_cast( + svc_cfg->GetGlobalParsedConfig(0)); + auto lb_config = parsed_config->parsed_lb_config(); EXPECT_TRUE(strcmp(lb_config->name(), "round_robin") == 0); } @@ -398,10 +398,10 @@ TEST_F(ClientChannelParserTest, ValidLoadBalancingConfigGrpclb) { grpc_error* error = GRPC_ERROR_NONE; auto svc_cfg = ServiceConfig::Create(test_json, &error); ASSERT_TRUE(error == GRPC_ERROR_NONE); - const auto* parsed_object = - static_cast( - svc_cfg->GetParsedGlobalServiceConfigObject(0)); - auto lb_config = parsed_object->parsed_lb_config(); + const auto* parsed_config = + static_cast( + svc_cfg->GetGlobalParsedConfig(0)); + auto lb_config = parsed_config->parsed_lb_config(); EXPECT_TRUE(strcmp(lb_config->name(), "grpclb") == 0); } @@ -417,10 +417,10 @@ TEST_F(ClientChannelParserTest, ValidLoadBalancingConfigXds) { auto svc_cfg = ServiceConfig::Create(test_json, &error); gpr_log(GPR_ERROR, "%s", grpc_error_string(error)); ASSERT_TRUE(error == GRPC_ERROR_NONE); - const auto* parsed_object = - static_cast( - svc_cfg->GetParsedGlobalServiceConfigObject(0)); - auto lb_config = parsed_object->parsed_lb_config(); + const auto* parsed_config = + static_cast( + svc_cfg->GetGlobalParsedConfig(0)); + auto lb_config = parsed_config->parsed_lb_config(); EXPECT_TRUE(strcmp(lb_config->name(), "xds_experimental") == 0); } @@ -484,10 +484,10 @@ TEST_F(ClientChannelParserTest, ValidLoadBalancingPolicy) { grpc_error* error = GRPC_ERROR_NONE; auto svc_cfg = ServiceConfig::Create(test_json, &error); ASSERT_TRUE(error == GRPC_ERROR_NONE); - const auto* parsed_object = - static_cast( - svc_cfg->GetParsedGlobalServiceConfigObject(0)); - const auto* lb_policy = parsed_object->parsed_deprecated_lb_policy(); + const auto* parsed_config = + static_cast( + svc_cfg->GetGlobalParsedConfig(0)); + const auto* lb_policy = parsed_config->parsed_deprecated_lb_policy(); ASSERT_TRUE(lb_policy != nullptr); EXPECT_TRUE(strcmp(lb_policy, "pick_first") == 0); } @@ -498,10 +498,10 @@ TEST_F(ClientChannelParserTest, ValidLoadBalancingPolicyAllCaps) { auto svc_cfg = ServiceConfig::Create(test_json, &error); gpr_log(GPR_ERROR, "%s", grpc_error_string(error)); ASSERT_TRUE(error == GRPC_ERROR_NONE); - const auto* parsed_object = - static_cast( - svc_cfg->GetParsedGlobalServiceConfigObject(0)); - const auto* lb_policy = parsed_object->parsed_deprecated_lb_policy(); + const auto* parsed_config = + static_cast( + svc_cfg->GetGlobalParsedConfig(0)); + const auto* lb_policy = parsed_config->parsed_deprecated_lb_policy(); ASSERT_TRUE(lb_policy != nullptr); EXPECT_TRUE(strcmp(lb_policy, "pick_first") == 0); } @@ -549,10 +549,10 @@ TEST_F(ClientChannelParserTest, ValidRetryThrottling) { auto svc_cfg = ServiceConfig::Create(test_json, &error); gpr_log(GPR_ERROR, "%s", grpc_error_string(error)); ASSERT_TRUE(error == GRPC_ERROR_NONE); - const auto* parsed_object = - static_cast( - svc_cfg->GetParsedGlobalServiceConfigObject(0)); - const auto retryThrottling = parsed_object->retry_throttling(); + const auto* parsed_config = + static_cast( + svc_cfg->GetGlobalParsedConfig(0)); + const auto retryThrottling = parsed_config->retry_throttling(); ASSERT_TRUE(retryThrottling.has_value()); EXPECT_EQ(retryThrottling.value().max_milli_tokens, 2000); EXPECT_EQ(retryThrottling.value().milli_token_ratio, 1000); @@ -633,12 +633,12 @@ TEST_F(ClientChannelParserTest, ValidTimeout) { grpc_error* error = GRPC_ERROR_NONE; auto svc_cfg = ServiceConfig::Create(test_json, &error); ASSERT_TRUE(error == GRPC_ERROR_NONE); - const auto* vector_ptr = svc_cfg->GetMethodServiceConfigObjectsVector( + const auto* vector_ptr = svc_cfg->GetMethodParsedConfigVector( grpc_slice_from_static_string("/TestServ/TestMethod")); EXPECT_TRUE(vector_ptr != nullptr); - auto parsed_object = ((*vector_ptr)[0]).get(); - EXPECT_EQ((static_cast( - parsed_object)) + auto parsed_config = ((*vector_ptr)[0]).get(); + EXPECT_EQ((static_cast( + parsed_config)) ->timeout(), 5000); } @@ -680,18 +680,18 @@ TEST_F(ClientChannelParserTest, ValidWaitForReady) { grpc_error* error = GRPC_ERROR_NONE; auto svc_cfg = ServiceConfig::Create(test_json, &error); ASSERT_TRUE(error == GRPC_ERROR_NONE); - const auto* vector_ptr = svc_cfg->GetMethodServiceConfigObjectsVector( + const auto* vector_ptr = svc_cfg->GetMethodParsedConfigVector( grpc_slice_from_static_string("/TestServ/TestMethod")); EXPECT_TRUE(vector_ptr != nullptr); - auto parsed_object = ((*vector_ptr)[0]).get(); + auto parsed_config = ((*vector_ptr)[0]).get(); EXPECT_TRUE( - (static_cast( - parsed_object)) + (static_cast( + parsed_config)) ->wait_for_ready() .has_value()); EXPECT_TRUE( - (static_cast( - parsed_object)) + (static_cast( + parsed_config)) ->wait_for_ready() .value()); } @@ -740,18 +740,18 @@ TEST_F(ClientChannelParserTest, ValidRetryPolicy) { auto svc_cfg = ServiceConfig::Create(test_json, &error); gpr_log(GPR_ERROR, "%s", grpc_error_string(error)); ASSERT_TRUE(error == GRPC_ERROR_NONE); - const auto* vector_ptr = svc_cfg->GetMethodServiceConfigObjectsVector( + const auto* vector_ptr = svc_cfg->GetMethodParsedConfigVector( grpc_slice_from_static_string("/TestServ/TestMethod")); EXPECT_TRUE(vector_ptr != nullptr); - const auto* parsed_object = - static_cast( + const auto* parsed_config = + static_cast( ((*vector_ptr)[0]).get()); - EXPECT_TRUE(parsed_object->retry_policy() != nullptr); - EXPECT_EQ(parsed_object->retry_policy()->max_attempts, 3); - EXPECT_EQ(parsed_object->retry_policy()->initial_backoff, 1000); - EXPECT_EQ(parsed_object->retry_policy()->max_backoff, 120000); - EXPECT_EQ(parsed_object->retry_policy()->backoff_multiplier, 1.6f); - EXPECT_TRUE(parsed_object->retry_policy()->retryable_status_codes.Contains( + EXPECT_TRUE(parsed_config->retry_policy() != nullptr); + EXPECT_EQ(parsed_config->retry_policy()->max_attempts, 3); + EXPECT_EQ(parsed_config->retry_policy()->initial_backoff, 1000); + EXPECT_EQ(parsed_config->retry_policy()->max_backoff, 120000); + EXPECT_EQ(parsed_config->retry_policy()->backoff_multiplier, 1.6f); + EXPECT_TRUE(parsed_config->retry_policy()->retryable_status_codes.Contains( GRPC_STATUS_ABORTED)); } @@ -915,11 +915,11 @@ TEST_F(ClientChannelParserTest, ValidHealthCheck) { grpc_error* error = GRPC_ERROR_NONE; auto svc_cfg = ServiceConfig::Create(test_json, &error); ASSERT_TRUE(error == GRPC_ERROR_NONE); - const auto* parsed_object = - static_cast( - svc_cfg->GetParsedGlobalServiceConfigObject(0)); - ASSERT_TRUE(parsed_object != nullptr); - EXPECT_EQ(strcmp(parsed_object->health_check_service_name(), + const auto* parsed_config = + static_cast( + svc_cfg->GetGlobalParsedConfig(0)); + ASSERT_TRUE(parsed_config != nullptr); + EXPECT_EQ(strcmp(parsed_config->health_check_service_name(), "health_check_service_name"), 0); } @@ -974,14 +974,14 @@ TEST_F(MessageSizeParserTest, Valid) { auto svc_cfg = ServiceConfig::Create(test_json, &error); gpr_log(GPR_ERROR, "%s", grpc_error_string(error)); ASSERT_TRUE(error == GRPC_ERROR_NONE); - const auto* vector_ptr = svc_cfg->GetMethodServiceConfigObjectsVector( + const auto* vector_ptr = svc_cfg->GetMethodParsedConfigVector( grpc_slice_from_static_string("/TestServ/TestMethod")); EXPECT_TRUE(vector_ptr != nullptr); - auto parsed_object = - static_cast(((*vector_ptr)[0]).get()); - ASSERT_TRUE(parsed_object != nullptr); - EXPECT_EQ(parsed_object->limits().max_send_size, 1024); - EXPECT_EQ(parsed_object->limits().max_recv_size, 1024); + auto parsed_config = + static_cast(((*vector_ptr)[0]).get()); + ASSERT_TRUE(parsed_config != nullptr); + EXPECT_EQ(parsed_config->limits().max_send_size, 1024); + EXPECT_EQ(parsed_config->limits().max_recv_size, 1024); } TEST_F(MessageSizeParserTest, InvalidMaxRequestMessageBytes) {