diff --git a/src/core/ext/filters/client_channel/client_channel_plugin.cc b/src/core/ext/filters/client_channel/client_channel_plugin.cc index abd225bcd55..6d774998e69 100644 --- a/src/core/ext/filters/client_channel/client_channel_plugin.cc +++ b/src/core/ext/filters/client_channel/client_channel_plugin.cc @@ -64,9 +64,9 @@ void BuildClientChannelConfiguration(CoreConfiguration::Builder* builder) { RegisterHttpConnectHandshaker(builder); builder->channel_init()->RegisterStage( GRPC_CLIENT_CHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY, - [](grpc_channel_stack_builder* builder) { - return grpc_channel_stack_builder_append_filter( - builder, &ClientChannel::kFilterVtable, nullptr, nullptr); + [](ChannelStackBuilder* builder) { + builder->AppendFilter(&ClientChannel::kFilterVtable, nullptr); + return true; }); } diff --git a/src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb.cc b/src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb.cc index 033732c02e9..fa4c6b15494 100644 --- a/src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb.cc +++ b/src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb.cc @@ -1843,9 +1843,8 @@ namespace grpc_core { void RegisterGrpcLbLoadReportingFilter(CoreConfiguration::Builder* builder) { builder->channel_init()->RegisterStage( GRPC_CLIENT_SUBCHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY, - [](grpc_channel_stack_builder* builder) { - const grpc_channel_args* args = - grpc_channel_stack_builder_get_channel_arguments(builder); + [](ChannelStackBuilder* builder) { + const grpc_channel_args* args = builder->channel_args(); const grpc_arg* channel_arg = grpc_channel_args_find(args, GRPC_ARG_LB_POLICY_NAME); if (channel_arg != nullptr && channel_arg->type == GRPC_ARG_STRING && @@ -1855,8 +1854,7 @@ void RegisterGrpcLbLoadReportingFilter(CoreConfiguration::Builder* builder) { // this filter at the very top of the subchannel stack, since that // will minimize the number of metadata elements that the filter // needs to iterate through to find the ClientStats object. - return grpc_channel_stack_builder_prepend_filter( - builder, &grpc_client_load_reporting_filter, nullptr, nullptr); + builder->PrependFilter(&grpc_client_load_reporting_filter, nullptr); } return true; }); diff --git a/src/core/ext/filters/client_channel/service_config_channel_arg_filter.cc b/src/core/ext/filters/client_channel/service_config_channel_arg_filter.cc index 714896096fc..ebd7d198fec 100644 --- a/src/core/ext/filters/client_channel/service_config_channel_arg_filter.cc +++ b/src/core/ext/filters/client_channel/service_config_channel_arg_filter.cc @@ -141,16 +141,15 @@ void RegisterServiceConfigChannelArgFilter( CoreConfiguration::Builder* builder) { builder->channel_init()->RegisterStage( GRPC_CLIENT_DIRECT_CHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY, - [](grpc_channel_stack_builder* builder) { - const grpc_channel_args* channel_args = - grpc_channel_stack_builder_get_channel_arguments(builder); + [](ChannelStackBuilder* builder) { + const grpc_channel_args* channel_args = builder->channel_args(); if (grpc_channel_args_want_minimal_stack(channel_args) || grpc_channel_args_find_string(channel_args, GRPC_ARG_SERVICE_CONFIG) == nullptr) { return true; } - return grpc_channel_stack_builder_prepend_filter( - builder, &ServiceConfigChannelArgFilter, nullptr, nullptr); + builder->PrependFilter(&ServiceConfigChannelArgFilter, nullptr); + return true; }); } diff --git a/src/core/ext/filters/client_channel/subchannel.cc b/src/core/ext/filters/client_channel/subchannel.cc index 6f2719b6b4b..d44afaa22e2 100644 --- a/src/core/ext/filters/client_channel/subchannel.cc +++ b/src/core/ext/filters/client_channel/subchannel.cc @@ -964,21 +964,16 @@ void ConnectionDestroy(void* arg, grpc_error_handle /*error*/) { bool Subchannel::PublishTransportLocked() { // Construct channel stack. - grpc_channel_stack_builder* builder = - grpc_channel_stack_builder_create("subchannel"); - grpc_channel_stack_builder_set_channel_arguments( - builder, connecting_result_.channel_args); - grpc_channel_stack_builder_set_transport(builder, - connecting_result_.transport); + ChannelStackBuilder builder("subchannel"); + builder.SetChannelArgs(connecting_result_.channel_args) + .SetTransport(connecting_result_.transport); if (!CoreConfiguration::Get().channel_init().CreateStack( - builder, GRPC_CLIENT_SUBCHANNEL)) { - grpc_channel_stack_builder_destroy(builder); + &builder, GRPC_CLIENT_SUBCHANNEL)) { return false; } grpc_channel_stack* stk; - grpc_error_handle error = grpc_channel_stack_builder_finish( - builder, 0, 1, ConnectionDestroy, nullptr, - reinterpret_cast(&stk)); + grpc_error_handle error = builder.Build(0, 1, ConnectionDestroy, nullptr, + reinterpret_cast(&stk)); if (error != GRPC_ERROR_NONE) { grpc_transport_destroy(connecting_result_.transport); gpr_log(GPR_ERROR, diff --git a/src/core/ext/filters/client_idle/client_idle_filter.cc b/src/core/ext/filters/client_idle/client_idle_filter.cc index df8fc07ab35..2abbe90ed9c 100644 --- a/src/core/ext/filters/client_idle/client_idle_filter.cc +++ b/src/core/ext/filters/client_idle/client_idle_filter.cc @@ -250,16 +250,13 @@ const grpc_channel_filter grpc_client_idle_filter = { void RegisterClientIdleFilter(CoreConfiguration::Builder* builder) { builder->channel_init()->RegisterStage( GRPC_CLIENT_CHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY, - [](grpc_channel_stack_builder* builder) { - const grpc_channel_args* channel_args = - grpc_channel_stack_builder_get_channel_arguments(builder); + [](ChannelStackBuilder* builder) { + const grpc_channel_args* channel_args = builder->channel_args(); if (!grpc_channel_args_want_minimal_stack(channel_args) && GetClientIdleTimeout(channel_args) != INT_MAX) { - return grpc_channel_stack_builder_prepend_filter( - builder, &grpc_client_idle_filter, nullptr, nullptr); - } else { - return true; + builder->PrependFilter(&grpc_client_idle_filter, nullptr); } + return true; }); } } // namespace grpc_core diff --git a/src/core/ext/filters/deadline/deadline_filter.cc b/src/core/ext/filters/deadline/deadline_filter.cc index 6cca2a98174..384ea8de977 100644 --- a/src/core/ext/filters/deadline/deadline_filter.cc +++ b/src/core/ext/filters/deadline/deadline_filter.cc @@ -378,11 +378,9 @@ void RegisterDeadlineFilter(CoreConfiguration::Builder* builder) { const grpc_channel_filter* filter) { builder->channel_init()->RegisterStage( type, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY, - [filter](grpc_channel_stack_builder* builder) { - if (grpc_deadline_checking_enabled( - grpc_channel_stack_builder_get_channel_arguments(builder))) { - return grpc_channel_stack_builder_prepend_filter(builder, filter, - nullptr, nullptr); + [filter](ChannelStackBuilder* builder) { + if (grpc_deadline_checking_enabled(builder->channel_args())) { + builder->PrependFilter(filter, nullptr); } return true; }); diff --git a/src/core/ext/filters/http/client_authority_filter.cc b/src/core/ext/filters/http/client_authority_filter.cc index 9540944683d..feb31ec1c49 100644 --- a/src/core/ext/filters/http/client_authority_filter.cc +++ b/src/core/ext/filters/http/client_authority_filter.cc @@ -73,9 +73,8 @@ namespace { const grpc_channel_filter grpc_client_authority_filter = MakePromiseBasedFilter(); -bool add_client_authority_filter(grpc_channel_stack_builder* builder) { - const grpc_channel_args* channel_args = - grpc_channel_stack_builder_get_channel_arguments(builder); +bool add_client_authority_filter(ChannelStackBuilder* builder) { + const grpc_channel_args* channel_args = builder->channel_args(); const grpc_arg* disable_client_authority_filter_arg = grpc_channel_args_find( channel_args, GRPC_ARG_DISABLE_CLIENT_AUTHORITY_FILTER); if (disable_client_authority_filter_arg != nullptr) { @@ -85,8 +84,8 @@ bool add_client_authority_filter(grpc_channel_stack_builder* builder) { return true; } } - return grpc_channel_stack_builder_prepend_filter( - builder, &grpc_client_authority_filter, nullptr, nullptr); + builder->PrependFilter(&grpc_client_authority_filter, nullptr); + return true; } } // namespace diff --git a/src/core/ext/filters/http/http_filters_plugin.cc b/src/core/ext/filters/http/http_filters_plugin.cc index 08fa1685d7a..c3285cec2ec 100644 --- a/src/core/ext/filters/http/http_filters_plugin.cc +++ b/src/core/ext/filters/http/http_filters_plugin.cc @@ -30,8 +30,8 @@ #include "src/core/lib/transport/transport_impl.h" static bool is_building_http_like_transport( - grpc_channel_stack_builder* builder) { - grpc_transport* t = grpc_channel_stack_builder_get_transport(builder); + grpc_core::ChannelStackBuilder* builder) { + grpc_transport* t = builder->transport(); return t != nullptr && strstr(t->vtable->name, "http"); } @@ -44,27 +44,26 @@ void RegisterHttpFilters(CoreConfiguration::Builder* builder) { builder->channel_init()->RegisterStage( channel_type, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY, [enable_in_minimal_stack, control_channel_arg, - filter](grpc_channel_stack_builder* builder) { + filter](ChannelStackBuilder* builder) { if (!is_building_http_like_transport(builder)) return true; - const grpc_channel_args* channel_args = - grpc_channel_stack_builder_get_channel_arguments(builder); + const grpc_channel_args* channel_args = builder->channel_args(); bool enable = grpc_channel_arg_get_bool( grpc_channel_args_find(channel_args, control_channel_arg), enable_in_minimal_stack || !grpc_channel_args_want_minimal_stack(channel_args)); - if (!enable) return true; - return grpc_channel_stack_builder_prepend_filter(builder, filter, - nullptr, nullptr); + if (enable) builder->PrependFilter(filter, nullptr); + return true; }); }; auto required = [builder](grpc_channel_stack_type channel_type, const grpc_channel_filter* filter) { builder->channel_init()->RegisterStage( channel_type, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY, - [filter](grpc_channel_stack_builder* builder) { - if (!is_building_http_like_transport(builder)) return true; - return grpc_channel_stack_builder_prepend_filter(builder, filter, - nullptr, nullptr); + [filter](ChannelStackBuilder* builder) { + if (is_building_http_like_transport(builder)) { + builder->PrependFilter(filter, nullptr); + } + return true; }); }; optional(GRPC_CLIENT_SUBCHANNEL, false, diff --git a/src/core/ext/filters/max_age/max_age_filter.cc b/src/core/ext/filters/max_age/max_age_filter.cc index 16927e2ab1c..2b09879e433 100644 --- a/src/core/ext/filters/max_age/max_age_filter.cc +++ b/src/core/ext/filters/max_age/max_age_filter.cc @@ -539,9 +539,8 @@ namespace grpc_core { void RegisterMaxAgeFilter(CoreConfiguration::Builder* builder) { builder->channel_init()->RegisterStage( GRPC_SERVER_CHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY, - [](grpc_channel_stack_builder* builder) { - const grpc_channel_args* channel_args = - grpc_channel_stack_builder_get_channel_arguments(builder); + [](ChannelStackBuilder* builder) { + const grpc_channel_args* channel_args = builder->channel_args(); bool enable = grpc_channel_arg_get_integer( grpc_channel_args_find( channel_args, GRPC_ARG_MAX_CONNECTION_AGE_MS), @@ -551,11 +550,9 @@ void RegisterMaxAgeFilter(CoreConfiguration::Builder* builder) { channel_args, GRPC_ARG_MAX_CONNECTION_IDLE_MS), MAX_CONNECTION_IDLE_INTEGER_OPTIONS) != INT_MAX; if (enable) { - return grpc_channel_stack_builder_prepend_filter( - builder, &grpc_max_age_filter, nullptr, nullptr); - } else { - return true; + builder->PrependFilter(&grpc_max_age_filter, nullptr); } + return true; }); } } // 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 51fb768b55f..a672f150e88 100644 --- a/src/core/ext/filters/message_size/message_size_filter.cc +++ b/src/core/ext/filters/message_size/message_size_filter.cc @@ -344,21 +344,20 @@ const grpc_channel_filter grpc_message_size_filter = { // Used for GRPC_CLIENT_SUBCHANNEL static bool maybe_add_message_size_filter_subchannel( - grpc_channel_stack_builder* builder) { - const grpc_channel_args* channel_args = - grpc_channel_stack_builder_get_channel_arguments(builder); + grpc_core::ChannelStackBuilder* builder) { + const grpc_channel_args* channel_args = builder->channel_args(); if (grpc_channel_args_want_minimal_stack(channel_args)) { return true; } - return grpc_channel_stack_builder_prepend_filter( - builder, &grpc_message_size_filter, nullptr, nullptr); + builder->PrependFilter(&grpc_message_size_filter, nullptr); + return true; } // Used for GRPC_CLIENT_DIRECT_CHANNEL and GRPC_SERVER_CHANNEL. Adds the filter // only if message size limits or service config is specified. -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); +static bool maybe_add_message_size_filter( + grpc_core::ChannelStackBuilder* builder) { + const grpc_channel_args* channel_args = builder->channel_args(); if (grpc_channel_args_want_minimal_stack(channel_args)) { return true; } @@ -371,15 +370,9 @@ static bool maybe_add_message_size_filter(grpc_channel_stack_builder* builder) { const grpc_arg* a = grpc_channel_args_find(channel_args, GRPC_ARG_SERVICE_CONFIG); const char* svc_cfg_str = grpc_channel_arg_get_string(a); - if (svc_cfg_str != nullptr) { - enable = true; - } - if (enable) { - return grpc_channel_stack_builder_prepend_filter( - builder, &grpc_message_size_filter, nullptr, nullptr); - } else { - return true; - } + if (svc_cfg_str != nullptr) enable = true; + if (enable) builder->PrependFilter(&grpc_message_size_filter, nullptr); + return true; } void grpc_message_size_filter_init(void) { diff --git a/src/core/ext/xds/xds_channel_stack_modifier.cc b/src/core/ext/xds/xds_channel_stack_modifier.cc index bdf7e21aa5b..194350ec2cd 100644 --- a/src/core/ext/xds/xds_channel_stack_modifier.cc +++ b/src/core/ext/xds/xds_channel_stack_modifier.cc @@ -49,35 +49,32 @@ const char* kXdsChannelStackModifierChannelArgName = } // namespace -bool XdsChannelStackModifier::ModifyChannelStack( - grpc_channel_stack_builder* builder) { +bool XdsChannelStackModifier::ModifyChannelStack(ChannelStackBuilder* builder) { // Insert the filters after the census filter if present. - grpc_channel_stack_builder_iterator* it = - grpc_channel_stack_builder_create_iterator_at_first(builder); - while (grpc_channel_stack_builder_move_next(it)) { - if (grpc_channel_stack_builder_iterator_is_end(it)) break; - const char* filter_name_at_it = - grpc_channel_stack_builder_iterator_filter_name(it); + auto it = builder->mutable_stack()->begin(); + while (it != builder->mutable_stack()->end()) { + const char* filter_name_at_it = it->filter->name; if (strcmp("census_server", filter_name_at_it) == 0 || strcmp("opencensus_server", filter_name_at_it) == 0) { break; } + ++it; } - if (grpc_channel_stack_builder_iterator_is_end(it)) { + if (it == builder->mutable_stack()->end()) { // No census filter found. Reset iterator to the beginning. This will result // in prepending the list of xDS HTTP filters to the current stack. Note // that this stage is run before the stage that adds the top server filter, // resulting in these filters being finally placed after the `server` // filter. - grpc_channel_stack_builder_iterator_destroy(it); - it = grpc_channel_stack_builder_create_iterator_at_first(builder); + it = builder->mutable_stack()->begin(); + } else { + ++it; } - GPR_ASSERT(grpc_channel_stack_builder_move_next(it)); for (const grpc_channel_filter* filter : filters_) { - GPR_ASSERT(grpc_channel_stack_builder_add_filter_before(it, filter, nullptr, - nullptr)); + it = builder->mutable_stack()->insert( + it, ChannelStackBuilder::StackEntry{filter, nullptr}); + ++it; } - grpc_channel_stack_builder_iterator_destroy(it); return true; } @@ -98,10 +95,10 @@ XdsChannelStackModifier::GetFromChannelArgs(const grpc_channel_args& args) { void RegisterXdsChannelStackModifier(CoreConfiguration::Builder* builder) { builder->channel_init()->RegisterStage( - GRPC_SERVER_CHANNEL, INT_MAX, [](grpc_channel_stack_builder* builder) { + GRPC_SERVER_CHANNEL, INT_MAX, [](ChannelStackBuilder* builder) { RefCountedPtr channel_stack_modifier = XdsChannelStackModifier::GetFromChannelArgs( - *grpc_channel_stack_builder_get_channel_arguments(builder)); + *builder->channel_args()); if (channel_stack_modifier != nullptr) { return channel_stack_modifier->ModifyChannelStack(builder); } diff --git a/src/core/ext/xds/xds_channel_stack_modifier.h b/src/core/ext/xds/xds_channel_stack_modifier.h index bf6d2ff3962..0a164c2c41c 100644 --- a/src/core/ext/xds/xds_channel_stack_modifier.h +++ b/src/core/ext/xds/xds_channel_stack_modifier.h @@ -30,15 +30,16 @@ namespace grpc_core { // XdsChannelStackModifier allows for inserting xDS HTTP filters into the -// channel stack. It is registered to mutate the `grpc_channel_stack_builder` -// object via ChannelInit::Builder::RegisterStage. +// channel stack. It is registered to mutate the +// `ChannelStackBuilder` object via +// ChannelInit::Builder::RegisterStage. class XdsChannelStackModifier : public RefCounted { public: explicit XdsChannelStackModifier( std::vector filters) : filters_(std::move(filters)) {} // Returns true on success, false otherwise. - bool ModifyChannelStack(grpc_channel_stack_builder* builder); + bool ModifyChannelStack(ChannelStackBuilder* builder); grpc_arg MakeChannelArg() const; static RefCountedPtr GetFromChannelArgs( const grpc_channel_args& args); diff --git a/src/core/lib/channel/channel_stack_builder.cc b/src/core/lib/channel/channel_stack_builder.cc index 207ef19af4f..d105e253bf1 100644 --- a/src/core/lib/channel/channel_stack_builder.cc +++ b/src/core/lib/channel/channel_stack_builder.cc @@ -25,252 +25,55 @@ #include #include +#include "src/core/lib/channel/channel_stack_builder.h" #include "src/core/lib/gprpp/memory.h" -typedef struct filter_node { - struct filter_node* next; - struct filter_node* prev; - const grpc_channel_filter* filter; - grpc_post_filter_create_init_func init; - void* init_arg; -} filter_node; - -struct grpc_channel_stack_builder { - // sentinel nodes for filters that have been added - filter_node begin; - filter_node end; - // various set/get-able parameters - grpc_channel_args* args; - grpc_transport* transport; - char* target; - const char* name; -}; - -struct grpc_channel_stack_builder_iterator { - grpc_channel_stack_builder* builder; - filter_node* node; -}; - -grpc_channel_stack_builder* grpc_channel_stack_builder_create( - const char* name) { - grpc_channel_stack_builder* b = - grpc_core::Zalloc(); - b->begin.filter = nullptr; - b->end.filter = nullptr; - b->begin.next = &b->end; - b->begin.prev = &b->end; - b->end.next = &b->begin; - b->end.prev = &b->begin; - b->name = name; - return b; -} - -void grpc_channel_stack_builder_set_target(grpc_channel_stack_builder* b, - const char* target) { - gpr_free(b->target); - b->target = gpr_strdup(target); -} - -std::string grpc_channel_stack_builder_get_target( - grpc_channel_stack_builder* b) { - return b->target == nullptr ? std::string("unknown") : std::string(b->target); -} - -static grpc_channel_stack_builder_iterator* create_iterator_at_filter_node( - grpc_channel_stack_builder* builder, filter_node* node) { - grpc_channel_stack_builder_iterator* it = - static_cast( - gpr_malloc(sizeof(*it))); - it->builder = builder; - it->node = node; - return it; -} - -void grpc_channel_stack_builder_iterator_destroy( - grpc_channel_stack_builder_iterator* it) { - gpr_free(it); -} - -grpc_channel_stack_builder_iterator* -grpc_channel_stack_builder_create_iterator_at_first( - grpc_channel_stack_builder* builder) { - return create_iterator_at_filter_node(builder, &builder->begin); -} - -grpc_channel_stack_builder_iterator* -grpc_channel_stack_builder_create_iterator_at_last( - grpc_channel_stack_builder* builder) { - return create_iterator_at_filter_node(builder, &builder->end); -} - -bool grpc_channel_stack_builder_iterator_is_end( - grpc_channel_stack_builder_iterator* iterator) { - return iterator->node == &iterator->builder->end; -} - -const char* grpc_channel_stack_builder_iterator_filter_name( - grpc_channel_stack_builder_iterator* iterator) { - if (iterator->node->filter == nullptr) return nullptr; - return iterator->node->filter->name; -} - -bool grpc_channel_stack_builder_move_next( - grpc_channel_stack_builder_iterator* iterator) { - if (iterator->node == &iterator->builder->end) return false; - iterator->node = iterator->node->next; - return true; -} - -bool grpc_channel_stack_builder_move_prev( - grpc_channel_stack_builder_iterator* iterator) { - if (iterator->node == &iterator->builder->begin) return false; - iterator->node = iterator->node->prev; - return true; -} - -grpc_channel_stack_builder_iterator* grpc_channel_stack_builder_iterator_find( - grpc_channel_stack_builder* builder, const char* filter_name) { - GPR_ASSERT(filter_name != nullptr); - grpc_channel_stack_builder_iterator* it = - grpc_channel_stack_builder_create_iterator_at_first(builder); - while (grpc_channel_stack_builder_move_next(it)) { - if (grpc_channel_stack_builder_iterator_is_end(it)) break; - const char* filter_name_at_it = - grpc_channel_stack_builder_iterator_filter_name(it); - if (strcmp(filter_name, filter_name_at_it) == 0) break; - } - return it; -} +namespace grpc_core { -bool grpc_channel_stack_builder_move_prev( - grpc_channel_stack_builder_iterator* iterator); - -void grpc_channel_stack_builder_set_channel_arguments( - grpc_channel_stack_builder* builder, const grpc_channel_args* args) { - if (builder->args != nullptr) { - grpc_channel_args_destroy(builder->args); - } - builder->args = grpc_channel_args_copy(args); +ChannelStackBuilder::~ChannelStackBuilder() { + grpc_channel_args_destroy(args_); } -const grpc_channel_args* grpc_channel_stack_builder_get_channel_arguments( - grpc_channel_stack_builder* builder) { - return builder->args; -} - -void grpc_channel_stack_builder_set_transport( - grpc_channel_stack_builder* builder, grpc_transport* transport) { - GPR_ASSERT(builder->transport == nullptr); - builder->transport = transport; -} - -grpc_transport* grpc_channel_stack_builder_get_transport( - grpc_channel_stack_builder* builder) { - return builder->transport; -} - -bool grpc_channel_stack_builder_append_filter( - grpc_channel_stack_builder* builder, const grpc_channel_filter* filter, - grpc_post_filter_create_init_func post_init_func, void* user_data) { - grpc_channel_stack_builder_iterator* it = - grpc_channel_stack_builder_create_iterator_at_last(builder); - bool ok = grpc_channel_stack_builder_add_filter_before( - it, filter, post_init_func, user_data); - grpc_channel_stack_builder_iterator_destroy(it); - return ok; -} - -bool grpc_channel_stack_builder_remove_filter( - grpc_channel_stack_builder* builder, const char* filter_name) { - grpc_channel_stack_builder_iterator* it = - grpc_channel_stack_builder_iterator_find(builder, filter_name); - if (grpc_channel_stack_builder_iterator_is_end(it)) { - grpc_channel_stack_builder_iterator_destroy(it); - return false; +ChannelStackBuilder& ChannelStackBuilder::SetTarget(const char* target) { + if (target == nullptr) { + target_.clear(); + } else { + target_ = target; } - it->node->prev->next = it->node->next; - it->node->next->prev = it->node->prev; - gpr_free(it->node); - grpc_channel_stack_builder_iterator_destroy(it); - return true; + return *this; } -bool grpc_channel_stack_builder_prepend_filter( - grpc_channel_stack_builder* builder, const grpc_channel_filter* filter, - grpc_post_filter_create_init_func post_init_func, void* user_data) { - grpc_channel_stack_builder_iterator* it = - grpc_channel_stack_builder_create_iterator_at_first(builder); - bool ok = grpc_channel_stack_builder_add_filter_after( - it, filter, post_init_func, user_data); - grpc_channel_stack_builder_iterator_destroy(it); - return ok; +ChannelStackBuilder& ChannelStackBuilder::SetChannelArgs( + const grpc_channel_args* args) { + grpc_channel_args_destroy(args_); + args_ = grpc_channel_args_copy(args); + return *this; } -static void add_after(filter_node* before, const grpc_channel_filter* filter, - grpc_post_filter_create_init_func post_init_func, - void* user_data) { - filter_node* new_node = - static_cast(gpr_malloc(sizeof(*new_node))); - new_node->next = before->next; - new_node->prev = before; - new_node->next->prev = new_node->prev->next = new_node; - new_node->filter = filter; - new_node->init = post_init_func; - new_node->init_arg = user_data; +void ChannelStackBuilder::PrependFilter(const grpc_channel_filter* filter, + PostInitFunc post_init) { + stack_.insert(stack_.begin(), {filter, std::move(post_init)}); } -bool grpc_channel_stack_builder_add_filter_before( - grpc_channel_stack_builder_iterator* iterator, - const grpc_channel_filter* filter, - grpc_post_filter_create_init_func post_init_func, void* user_data) { - if (iterator->node == &iterator->builder->begin) return false; - add_after(iterator->node->prev, filter, post_init_func, user_data); - return true; +void ChannelStackBuilder::AppendFilter(const grpc_channel_filter* filter, + PostInitFunc post_init) { + stack_.push_back({filter, std::move(post_init)}); } -bool grpc_channel_stack_builder_add_filter_after( - grpc_channel_stack_builder_iterator* iterator, - const grpc_channel_filter* filter, - grpc_post_filter_create_init_func post_init_func, void* user_data) { - if (iterator->node == &iterator->builder->end) return false; - add_after(iterator->node, filter, post_init_func, user_data); - return true; -} - -void grpc_channel_stack_builder_destroy(grpc_channel_stack_builder* builder) { - filter_node* p = builder->begin.next; - while (p != &builder->end) { - filter_node* next = p->next; - gpr_free(p); - p = next; - } - if (builder->args != nullptr) { - grpc_channel_args_destroy(builder->args); - } - gpr_free(builder->target); - gpr_free(builder); -} - -grpc_error_handle grpc_channel_stack_builder_finish( - grpc_channel_stack_builder* builder, size_t prefix_bytes, int initial_refs, - grpc_iomgr_cb_func destroy, void* destroy_arg, void** result) { - // count the number of filters - size_t num_filters = 0; - for (filter_node* p = builder->begin.next; p != &builder->end; p = p->next) { - num_filters++; - } - +grpc_error_handle ChannelStackBuilder::Build(size_t prefix_bytes, + int initial_refs, + grpc_iomgr_cb_func destroy, + void* destroy_arg, void** result) { // create an array of filters - const grpc_channel_filter** filters = - static_cast( - gpr_malloc(sizeof(*filters) * num_filters)); - size_t i = 0; - for (filter_node* p = builder->begin.next; p != &builder->end; p = p->next) { - filters[i++] = p->filter; + std::vector filters; + filters.reserve(stack_.size()); + for (const auto& elem : stack_) { + filters.push_back(elem.filter); } // calculate the size of the channel stack - size_t channel_stack_size = grpc_channel_stack_size(filters, num_filters); + size_t channel_stack_size = + grpc_channel_stack_size(filters.data(), filters.size()); // allocate memory, with prefix_bytes followed by channel_stack_size *result = gpr_zalloc(prefix_bytes + channel_stack_size); @@ -280,28 +83,25 @@ grpc_error_handle grpc_channel_stack_builder_finish( // and initialize it grpc_error_handle error = grpc_channel_stack_init( initial_refs, destroy, destroy_arg == nullptr ? *result : destroy_arg, - filters, num_filters, builder->args, builder->transport, builder->name, + filters.data(), filters.size(), args_, transport_, name_.c_str(), channel_stack); if (error != GRPC_ERROR_NONE) { grpc_channel_stack_destroy(channel_stack); gpr_free(*result); *result = nullptr; - } else { - // run post-initialization functions - i = 0; - for (filter_node* p = builder->begin.next; p != &builder->end; - p = p->next) { - if (p->init != nullptr) { - p->init(channel_stack, grpc_channel_stack_element(channel_stack, i), - p->init_arg); - } - i++; - } + return error; } - grpc_channel_stack_builder_destroy(builder); - gpr_free(const_cast(filters)); + // run post-initialization functions + for (size_t i = 0; i < filters.size(); i++) { + if (stack_[i].post_init != nullptr) { + stack_[i].post_init(channel_stack, + grpc_channel_stack_element(channel_stack, i)); + } + } - return error; + return GRPC_ERROR_NONE; } + +} // namespace grpc_core diff --git a/src/core/lib/channel/channel_stack_builder.h b/src/core/lib/channel/channel_stack_builder.h index cf2a700d969..5d190f79c54 100644 --- a/src/core/lib/channel/channel_stack_builder.h +++ b/src/core/lib/channel/channel_stack_builder.h @@ -1,20 +1,16 @@ -/* - * - * Copyright 2016 gRPC authors. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - */ +// Copyright 2016 gRPC authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. #ifndef GRPC_CORE_LIB_CHANNEL_CHANNEL_STACK_BUILDER_H #define GRPC_CORE_LIB_CHANNEL_CHANNEL_STACK_BUILDER_H @@ -26,130 +22,83 @@ #include "src/core/lib/channel/channel_args.h" #include "src/core/lib/channel/channel_stack.h" -/// grpc_channel_stack_builder offers a programmatic interface to selected -/// and order channel filters -typedef struct grpc_channel_stack_builder grpc_channel_stack_builder; -typedef struct grpc_channel_stack_builder_iterator - grpc_channel_stack_builder_iterator; - -/// Create a new channel stack builder. -/// \a name must be statically allocated. -grpc_channel_stack_builder* grpc_channel_stack_builder_create(const char* name); - -/// Set the target uri -void grpc_channel_stack_builder_set_target(grpc_channel_stack_builder* b, - const char* target); - -std::string grpc_channel_stack_builder_get_target( - grpc_channel_stack_builder* b); - -/// Attach \a transport to the builder (does not take ownership) -void grpc_channel_stack_builder_set_transport( - grpc_channel_stack_builder* builder, grpc_transport* transport); - -/// Fetch attached transport -grpc_transport* grpc_channel_stack_builder_get_transport( - grpc_channel_stack_builder* builder); - -/// Set channel arguments: copies args -void grpc_channel_stack_builder_set_channel_arguments( - grpc_channel_stack_builder* builder, const grpc_channel_args* args); - -/// Return a borrowed pointer to the channel arguments -const grpc_channel_args* grpc_channel_stack_builder_get_channel_arguments( - grpc_channel_stack_builder* builder); - -/// Begin iterating over already defined filters in the builder at the beginning -grpc_channel_stack_builder_iterator* -grpc_channel_stack_builder_create_iterator_at_first( - grpc_channel_stack_builder* builder); - -/// Begin iterating over already defined filters in the builder at the end -grpc_channel_stack_builder_iterator* -grpc_channel_stack_builder_create_iterator_at_last( - grpc_channel_stack_builder* builder); - -/// Is an iterator at the first element? -bool grpc_channel_stack_builder_iterator_is_first( - grpc_channel_stack_builder_iterator* iterator); - -/// Is an iterator at the end? -bool grpc_channel_stack_builder_iterator_is_end( - grpc_channel_stack_builder_iterator* iterator); - -/// What is the name of the filter at this iterator position? -const char* grpc_channel_stack_builder_iterator_filter_name( - grpc_channel_stack_builder_iterator* iterator); - -/// Move an iterator to the next item -bool grpc_channel_stack_builder_move_next( - grpc_channel_stack_builder_iterator* iterator); - -/// Move an iterator to the previous item -bool grpc_channel_stack_builder_move_prev( - grpc_channel_stack_builder_iterator* iterator); - -/// Return an iterator at \a filter_name, or at the end of the list if not -/// found. -grpc_channel_stack_builder_iterator* grpc_channel_stack_builder_iterator_find( - grpc_channel_stack_builder* builder, const char* filter_name); - -typedef void (*grpc_post_filter_create_init_func)( - grpc_channel_stack* channel_stack, grpc_channel_element* elem, void* arg); - -/// Add \a filter to the stack, after \a iterator. -/// Call \a post_init_func(..., \a user_data) once the channel stack is -/// created. -bool grpc_channel_stack_builder_add_filter_after( - grpc_channel_stack_builder_iterator* iterator, - const grpc_channel_filter* filter, - grpc_post_filter_create_init_func post_init_func, - void* user_data) GRPC_MUST_USE_RESULT; - -/// Add \a filter to the stack, before \a iterator. -/// Call \a post_init_func(..., \a user_data) once the channel stack is -/// created. -bool grpc_channel_stack_builder_add_filter_before( - grpc_channel_stack_builder_iterator* iterator, - const grpc_channel_filter* filter, - grpc_post_filter_create_init_func post_init_func, - void* user_data) GRPC_MUST_USE_RESULT; - -/// Add \a filter to the beginning of the filter list. -/// Call \a post_init_func(..., \a user_data) once the channel stack is -/// created. -bool grpc_channel_stack_builder_prepend_filter( - grpc_channel_stack_builder* builder, const grpc_channel_filter* filter, - grpc_post_filter_create_init_func post_init_func, - void* user_data) GRPC_MUST_USE_RESULT; - -/// Add \a filter to the end of the filter list. -/// Call \a post_init_func(..., \a user_data) once the channel stack is -/// created. -bool grpc_channel_stack_builder_append_filter( - grpc_channel_stack_builder* builder, const grpc_channel_filter* filter, - grpc_post_filter_create_init_func post_init_func, - void* user_data) GRPC_MUST_USE_RESULT; - -/// Remove any filter whose name is \a filter_name from \a builder. Returns true -/// if \a filter_name was not found. -bool grpc_channel_stack_builder_remove_filter( - grpc_channel_stack_builder* builder, const char* filter_name); - -/// Terminate iteration and destroy \a iterator -void grpc_channel_stack_builder_iterator_destroy( - grpc_channel_stack_builder_iterator* iterator); - -/// Destroy the builder, return the freshly minted channel stack in \a result. -/// Allocates \a prefix_bytes bytes before the channel stack -/// Returns the base pointer of the allocated block -/// \a initial_refs, \a destroy, \a destroy_arg are as per -/// grpc_channel_stack_init -grpc_error_handle grpc_channel_stack_builder_finish( - grpc_channel_stack_builder* builder, size_t prefix_bytes, int initial_refs, - grpc_iomgr_cb_func destroy, void* destroy_arg, void** result); - -/// Destroy the builder without creating a channel stack -void grpc_channel_stack_builder_destroy(grpc_channel_stack_builder* builder); - -#endif /* GRPC_CORE_LIB_CHANNEL_CHANNEL_STACK_BUILDER_H */ +namespace grpc_core { + +// Build a channel stack. +// Allows interested parties to add filters to the stack, and to query an +// in-progress build. +// Carries some useful context for the channel stack, such as a target string +// and a transport. +class ChannelStackBuilder { + public: + // A function that will be called after the channel stack is successfully + // built. + using PostInitFunc = std::function; + + // One filter in the currently building stack. + struct StackEntry { + const grpc_channel_filter* filter; + PostInitFunc post_init; + }; + + // Initialize with a name. + explicit ChannelStackBuilder(std::string name) : name_(std::move(name)) {} + + ~ChannelStackBuilder(); + + // Set the target string. + ChannelStackBuilder& SetTarget(const char* target); + + // Query the target. + absl::string_view target() const { return target_; } + + // Set the transport. + ChannelStackBuilder& SetTransport(grpc_transport* transport) { + GPR_ASSERT(transport_ == nullptr); + transport_ = transport; + return *this; + } + + // Query the transport. + grpc_transport* transport() const { return transport_; } + + // Set channel args (takes a copy of them). + ChannelStackBuilder& SetChannelArgs(const grpc_channel_args* args); + + // Query the channel args. + const grpc_channel_args* channel_args() const { return args_; } + + // Mutable vector of proposed stack entries. + std::vector* mutable_stack() { return &stack_; } + + // Helper to add a filter to the front of the stack. + void PrependFilter(const grpc_channel_filter* filter, PostInitFunc post_init); + + // Helper to add a filter to the end of the stack. + void AppendFilter(const grpc_channel_filter* filter, PostInitFunc post_init); + + // Build the channel stack. + // After success, *result holds the new channel stack, + // prefix_bytes are allocated before the channel stack, + // initial_refs, destroy, destroy_arg are as per grpc_channel_stack_init + // On failure, *result is nullptr. + grpc_error_handle Build(size_t prefix_bytes, int initial_refs, + grpc_iomgr_cb_func destroy, void* destroy_arg, + void** result); + + private: + // The name of the stack + const std::string name_; + // The target + std::string target_; + // The transport + grpc_transport* transport_ = nullptr; + // Channel args + const grpc_channel_args* args_ = nullptr; + // The in-progress stack + std::vector stack_; +}; +} // namespace grpc_core + +#endif // GRPC_CORE_LIB_CHANNEL_CHANNEL_STACK_BUILDER_H diff --git a/src/core/lib/channel/connected_channel.cc b/src/core/lib/channel/connected_channel.cc index c16a46f5819..b004e6287dd 100644 --- a/src/core/lib/channel/connected_channel.cc +++ b/src/core/lib/channel/connected_channel.cc @@ -233,11 +233,15 @@ static void bind_transport(grpc_channel_stack* channel_stack, grpc_transport_stream_size(static_cast(t)); } -bool grpc_add_connected_filter(grpc_channel_stack_builder* builder) { - grpc_transport* t = grpc_channel_stack_builder_get_transport(builder); +bool grpc_add_connected_filter(grpc_core::ChannelStackBuilder* builder) { + grpc_transport* t = builder->transport(); GPR_ASSERT(t != nullptr); - return grpc_channel_stack_builder_append_filter( - builder, &grpc_connected_filter, bind_transport, t); + builder->AppendFilter( + &grpc_connected_filter, + [t](grpc_channel_stack* stk, grpc_channel_element* elem) { + bind_transport(stk, elem, t); + }); + return true; } grpc_stream* grpc_connected_channel_get_stream(grpc_call_element* elem) { diff --git a/src/core/lib/channel/connected_channel.h b/src/core/lib/channel/connected_channel.h index 1aa35d7a78b..7da9b21353d 100644 --- a/src/core/lib/channel/connected_channel.h +++ b/src/core/lib/channel/connected_channel.h @@ -25,7 +25,7 @@ extern const grpc_channel_filter grpc_connected_filter; -bool grpc_add_connected_filter(grpc_channel_stack_builder* builder); +bool grpc_add_connected_filter(grpc_core::ChannelStackBuilder* builder); /* Debug helper to dig the transport stream out of a call element */ grpc_stream* grpc_connected_channel_get_stream(grpc_call_element* elem); diff --git a/src/core/lib/surface/builtins.cc b/src/core/lib/surface/builtins.cc index dbd9cd1f3fe..2e79668b78d 100644 --- a/src/core/lib/surface/builtins.cc +++ b/src/core/lib/surface/builtins.cc @@ -35,14 +35,14 @@ void RegisterBuiltins(CoreConfiguration::Builder* builder) { grpc_add_connected_filter); builder->channel_init()->RegisterStage( GRPC_CLIENT_LAME_CHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY, - [](grpc_channel_stack_builder* builder) { - return grpc_channel_stack_builder_append_filter( - builder, &grpc_lame_filter, nullptr, nullptr); + [](ChannelStackBuilder* builder) { + builder->AppendFilter(&grpc_lame_filter, nullptr); + return true; }); builder->channel_init()->RegisterStage( - GRPC_SERVER_CHANNEL, INT_MAX, [](grpc_channel_stack_builder* builder) { - return grpc_channel_stack_builder_prepend_filter( - builder, &Server::kServerTopFilter, nullptr, nullptr); + GRPC_SERVER_CHANNEL, INT_MAX, [](ChannelStackBuilder* builder) { + builder->PrependFilter(&Server::kServerTopFilter, nullptr); + return true; }); } diff --git a/src/core/lib/surface/channel.cc b/src/core/lib/surface/channel.cc index 5586032b0dc..c6a75ccf2aa 100644 --- a/src/core/lib/surface/channel.cc +++ b/src/core/lib/surface/channel.cc @@ -58,21 +58,20 @@ static void destroy_channel(void* arg, grpc_error_handle error); grpc_channel* grpc_channel_create_with_builder( - grpc_channel_stack_builder* builder, + grpc_core::ChannelStackBuilder* builder, grpc_channel_stack_type channel_stack_type, grpc_error_handle* error) { - std::string target = grpc_channel_stack_builder_get_target(builder); - grpc_channel_args* args = grpc_channel_args_copy( - grpc_channel_stack_builder_get_channel_arguments(builder)); + std::string target(builder->target()); + grpc_channel_args* args = grpc_channel_args_copy(builder->channel_args()); grpc_channel* channel; if (channel_stack_type == GRPC_SERVER_CHANNEL) { GRPC_STATS_INC_SERVER_CHANNELS_CREATED(); } else { GRPC_STATS_INC_CLIENT_CHANNELS_CREATED(); } - std::string name = grpc_channel_stack_builder_get_target(builder); - grpc_error_handle builder_error = grpc_channel_stack_builder_finish( - builder, sizeof(grpc_channel), 1, destroy_channel, nullptr, - reinterpret_cast(&channel)); + std::string name(builder->target()); + grpc_error_handle builder_error = + builder->Build(sizeof(grpc_channel), 1, destroy_channel, nullptr, + reinterpret_cast(&channel)); if (builder_error != GRPC_ERROR_NONE) { gpr_log(GPR_ERROR, "channel stack builder failed: %s", grpc_error_std_string(builder_error).c_str()); @@ -187,9 +186,8 @@ int channelz_node_cmp(void* p1, void* p2) { const grpc_arg_pointer_vtable channelz_node_arg_vtable = { channelz_node_copy, channelz_node_destroy, channelz_node_cmp}; -void CreateChannelzNode(grpc_channel_stack_builder* builder) { - const grpc_channel_args* args = - grpc_channel_stack_builder_get_channel_arguments(builder); +void CreateChannelzNode(grpc_core::ChannelStackBuilder* builder) { + const grpc_channel_args* args = builder->channel_args(); // Check whether channelz is enabled. const bool channelz_enabled = grpc_channel_args_find_bool( args, GRPC_ARG_ENABLE_CHANNELZ, GRPC_ENABLE_CHANNELZ_DEFAULT); @@ -201,7 +199,7 @@ void CreateChannelzNode(grpc_channel_stack_builder* builder) { const bool is_internal_channel = grpc_channel_args_find_bool( args, GRPC_ARG_CHANNELZ_IS_INTERNAL_CHANNEL, false); // Create the channelz node. - std::string target = grpc_channel_stack_builder_get_target(builder); + std::string target(builder->target()); grpc_core::RefCountedPtr channelz_node = grpc_core::MakeRefCounted( target.c_str(), channel_tracer_max_memory, is_internal_channel); @@ -216,7 +214,7 @@ void CreateChannelzNode(grpc_channel_stack_builder* builder) { const char* args_to_remove[] = {GRPC_ARG_CHANNELZ_IS_INTERNAL_CHANNEL}; grpc_channel_args* new_args = grpc_channel_args_copy_and_add_and_remove( args, args_to_remove, GPR_ARRAY_SIZE(args_to_remove), &new_arg, 1); - grpc_channel_stack_builder_set_channel_arguments(builder, new_args); + builder->SetChannelArgs(new_args); grpc_channel_args_destroy(new_args); } @@ -244,7 +242,7 @@ grpc_channel* grpc_channel_create(const char* target, // grpc_shutdown() when the channel is actually destroyed, thus // ensuring that shutdown is deferred until that point. grpc_init(); - grpc_channel_stack_builder* builder = grpc_channel_stack_builder_create( + grpc_core::ChannelStackBuilder builder( grpc_channel_stack_type_string(channel_stack_type)); const grpc_core::UniquePtr default_authority = get_default_authority(input_args); @@ -257,23 +255,21 @@ grpc_channel* grpc_channel_create(const char* target, args = channel_args_mutator(target, args, channel_stack_type); } } - grpc_channel_stack_builder_set_channel_arguments(builder, args); + builder.SetChannelArgs(args).SetTarget(target).SetTransport( + optional_transport); grpc_channel_args_destroy(args); - grpc_channel_stack_builder_set_target(builder, target); - grpc_channel_stack_builder_set_transport(builder, optional_transport); if (!grpc_core::CoreConfiguration::Get().channel_init().CreateStack( - builder, channel_stack_type)) { - grpc_channel_stack_builder_destroy(builder); + &builder, channel_stack_type)) { grpc_shutdown(); // Since we won't call destroy_channel(). return nullptr; } // We only need to do this for clients here. For servers, this will be // done in src/core/lib/surface/server.cc. if (grpc_channel_stack_type_is_client(channel_stack_type)) { - CreateChannelzNode(builder); + CreateChannelzNode(&builder); } grpc_channel* channel = - grpc_channel_create_with_builder(builder, channel_stack_type, error); + grpc_channel_create_with_builder(&builder, channel_stack_type, error); if (channel == nullptr) { grpc_shutdown(); // Since we won't call destroy_channel(). } diff --git a/src/core/lib/surface/channel.h b/src/core/lib/surface/channel.h index 657e83e0048..37b35f96e1b 100644 --- a/src/core/lib/surface/channel.h +++ b/src/core/lib/surface/channel.h @@ -44,7 +44,7 @@ void grpc_channel_destroy_internal(grpc_channel* channel); /// Creates a grpc_channel with a builder. See the description of /// \a grpc_channel_create for variable definitions. grpc_channel* grpc_channel_create_with_builder( - grpc_channel_stack_builder* builder, + grpc_core::ChannelStackBuilder* builder, grpc_channel_stack_type channel_stack_type, grpc_error_handle* error = nullptr); diff --git a/src/core/lib/surface/channel_init.cc b/src/core/lib/surface/channel_init.cc index beeb23d4b7f..8725991357c 100644 --- a/src/core/lib/surface/channel_init.cc +++ b/src/core/lib/surface/channel_init.cc @@ -45,7 +45,7 @@ ChannelInit ChannelInit::Builder::Build() { return result; } -bool ChannelInit::CreateStack(grpc_channel_stack_builder* builder, +bool ChannelInit::CreateStack(ChannelStackBuilder* builder, grpc_channel_stack_type type) const { for (const auto& stage : slots_[type]) { if (!stage(builder)) return false; diff --git a/src/core/lib/surface/channel_init.h b/src/core/lib/surface/channel_init.h index 8f839932cc0..ca58086df9d 100644 --- a/src/core/lib/surface/channel_init.h +++ b/src/core/lib/surface/channel_init.h @@ -33,15 +33,15 @@ /// It also provides a universal entry path to run those mutators to build /// a channel stack for various subsystems. -typedef struct grpc_channel_stack_builder grpc_channel_stack_builder; - namespace grpc_core { +class ChannelStackBuilder; + class ChannelInit { public: /// One stage of mutation: call functions against \a builder to influence the /// finally constructed channel stack - using Stage = std::function; + using Stage = std::function; class Builder { public: @@ -74,7 +74,7 @@ class ChannelInit { /// Construct a channel stack of some sort: see channel_stack.h for details /// \a type is the type of channel stack to create /// \a builder is the channel stack builder to build into. - bool CreateStack(grpc_channel_stack_builder* builder, + bool CreateStack(ChannelStackBuilder* builder, grpc_channel_stack_type type) const; private: diff --git a/src/core/lib/surface/init_secure.cc b/src/core/lib/surface/init_secure.cc index cd336fd4f2c..d86a5511028 100644 --- a/src/core/lib/surface/init_secure.cc +++ b/src/core/lib/surface/init_secure.cc @@ -38,14 +38,13 @@ void grpc_security_pre_init(void) {} static bool maybe_prepend_client_auth_filter( - grpc_channel_stack_builder* builder) { - const grpc_channel_args* args = - grpc_channel_stack_builder_get_channel_arguments(builder); + grpc_core::ChannelStackBuilder* builder) { + const grpc_channel_args* args = builder->channel_args(); if (args) { for (size_t i = 0; i < args->num_args; i++) { if (0 == strcmp(GRPC_ARG_SECURITY_CONNECTOR, args->args[i].key)) { - return grpc_channel_stack_builder_prepend_filter( - builder, &grpc_client_auth_filter, nullptr, nullptr); + builder->PrependFilter(&grpc_client_auth_filter, nullptr); + break; } } } @@ -53,14 +52,13 @@ static bool maybe_prepend_client_auth_filter( } static bool maybe_prepend_server_auth_filter( - grpc_channel_stack_builder* builder) { - const grpc_channel_args* args = - grpc_channel_stack_builder_get_channel_arguments(builder); + grpc_core::ChannelStackBuilder* builder) { + const grpc_channel_args* args = builder->channel_args(); if (args) { for (size_t i = 0; i < args->num_args; i++) { if (0 == strcmp(GRPC_SERVER_CREDENTIALS_ARG, args->args[i].key)) { - return grpc_channel_stack_builder_prepend_filter( - builder, &grpc_server_auth_filter, nullptr, nullptr); + builder->PrependFilter(&grpc_server_auth_filter, nullptr); + break; } } } @@ -68,16 +66,14 @@ static bool maybe_prepend_server_auth_filter( } static bool maybe_prepend_sdk_server_authz_filter( - grpc_channel_stack_builder* builder) { - const grpc_channel_args* args = - grpc_channel_stack_builder_get_channel_arguments(builder); + grpc_core::ChannelStackBuilder* builder) { + const grpc_channel_args* args = builder->channel_args(); const auto* provider = grpc_channel_args_find_pointer( args, GRPC_ARG_AUTHORIZATION_POLICY_PROVIDER); if (provider != nullptr) { - return grpc_channel_stack_builder_prepend_filter( - builder, &grpc_core::SdkServerAuthzFilter::kFilterVtable, nullptr, - nullptr); + builder->PrependFilter(&grpc_core::SdkServerAuthzFilter::kFilterVtable, + nullptr); } return true; } diff --git a/src/cpp/common/channel_filter.cc b/src/cpp/common/channel_filter.cc index aa31c39bfdb..26346d424cb 100644 --- a/src/cpp/common/channel_filter.cc +++ b/src/cpp/common/channel_filter.cc @@ -71,14 +71,13 @@ void RegisterChannelFilter( std::function include_filter, const grpc_channel_filter* filter) { auto maybe_add_filter = [include_filter, - filter](grpc_channel_stack_builder* builder) { + filter](grpc_core::ChannelStackBuilder* builder) { if (include_filter != nullptr) { - const grpc_channel_args* args = - grpc_channel_stack_builder_get_channel_arguments(builder); + const grpc_channel_args* args = builder->channel_args(); if (!include_filter(*args)) return true; } - return grpc_channel_stack_builder_prepend_filter(builder, filter, nullptr, - nullptr); + builder->PrependFilter(filter, nullptr); + return true; }; grpc_core::CoreConfiguration::RegisterBuilder( [stack_type, priority, diff --git a/test/core/channel/channel_stack_builder_test.cc b/test/core/channel/channel_stack_builder_test.cc index b3d0a16dd6f..a69f9083cac 100644 --- a/test/core/channel/channel_stack_builder_test.cc +++ b/test/core/channel/channel_stack_builder_test.cc @@ -54,13 +54,6 @@ void CallDestroyFunc(grpc_call_element* /*elem*/, bool g_replacement_fn_called = false; bool g_original_fn_called = false; -void SetArgOnceFn(grpc_channel_stack* /*channel_stack*/, - grpc_channel_element* /*elem*/, void* arg) { - bool* called = static_cast(arg); - // Make sure this function is only called once per arg. - GPR_ASSERT(*called == false); - *called = true; -} TEST(ChannelStackBuilderTest, ReplaceFilter) { grpc_channel* channel = @@ -101,18 +94,29 @@ const grpc_channel_filter original_filter = { grpc_channel_next_get_info, "filter_name"}; -bool AddReplacementFilter(grpc_channel_stack_builder* builder) { +bool AddReplacementFilter(ChannelStackBuilder* builder) { // Get rid of any other version of the filter, as determined by having the // same name. - GPR_ASSERT(grpc_channel_stack_builder_remove_filter(builder, - replacement_filter.name)); - return grpc_channel_stack_builder_prepend_filter( - builder, &replacement_filter, SetArgOnceFn, &g_replacement_fn_called); + auto* stk = builder->mutable_stack(); + stk->erase(std::remove_if(stk->begin(), stk->end(), + [](const ChannelStackBuilder::StackEntry& entry) { + return strcmp(entry.filter->name, + "filter_name") == 0; + }), + stk->end()); + builder->PrependFilter(&replacement_filter, + [](grpc_channel_stack*, grpc_channel_element*) { + g_replacement_fn_called = true; + }); + return true; } -bool AddOriginalFilter(grpc_channel_stack_builder* builder) { - return grpc_channel_stack_builder_prepend_filter( - builder, &original_filter, SetArgOnceFn, &g_original_fn_called); +bool AddOriginalFilter(ChannelStackBuilder* builder) { + builder->PrependFilter(&original_filter, + [](grpc_channel_stack*, grpc_channel_element*) { + g_original_fn_called = true; + }); + return true; } } // namespace diff --git a/test/core/channel/minimal_stack_is_minimal_test.cc b/test/core/channel/minimal_stack_is_minimal_test.cc index 147af858781..db835ad4dd2 100644 --- a/test/core/channel/minimal_stack_is_minimal_test.cc +++ b/test/core/channel/minimal_stack_is_minimal_test.cc @@ -126,22 +126,20 @@ static int check_stack(const char* file, int line, const char* transport_name, grpc_channel_args* init_args, unsigned channel_stack_type, ...) { // create phony channel stack - grpc_channel_stack_builder* builder = - grpc_channel_stack_builder_create("test"); + grpc_core::ChannelStackBuilder builder("test"); grpc_transport_vtable fake_transport_vtable; memset(&fake_transport_vtable, 0, sizeof(grpc_transport_vtable)); fake_transport_vtable.name = transport_name; grpc_transport fake_transport = {&fake_transport_vtable}; - grpc_channel_stack_builder_set_target(builder, "foo.test.google.fr"); grpc_channel_args* channel_args = grpc_channel_args_copy(init_args); + builder.SetTarget("foo.test.google.fr").SetChannelArgs(channel_args); if (transport_name != nullptr) { - grpc_channel_stack_builder_set_transport(builder, &fake_transport); + builder.SetTransport(&fake_transport); } { grpc_core::ExecCtx exec_ctx; - grpc_channel_stack_builder_set_channel_arguments(builder, channel_args); GPR_ASSERT(grpc_core::CoreConfiguration::Get().channel_init().CreateStack( - builder, (grpc_channel_stack_type)channel_stack_type)); + &builder, (grpc_channel_stack_type)channel_stack_type)); } // build up our expectation list @@ -158,15 +156,12 @@ static int check_stack(const char* file, int line, const char* transport_name, // build up our "got" list parts.clear(); - grpc_channel_stack_builder_iterator* it = - grpc_channel_stack_builder_create_iterator_at_first(builder); - while (grpc_channel_stack_builder_move_next(it)) { - const char* name = grpc_channel_stack_builder_iterator_filter_name(it); + for (const auto& entry : *builder.mutable_stack()) { + const char* name = entry.filter->name; if (name == nullptr) continue; parts.push_back(name); } std::string got = absl::StrJoin(parts, ", "); - grpc_channel_stack_builder_iterator_destroy(it); // figure out result, log if there's an error int result = 0; @@ -206,7 +201,6 @@ static int check_stack(const char* file, int line, const char* transport_name, { grpc_core::ExecCtx exec_ctx; - grpc_channel_stack_builder_destroy(builder); grpc_channel_args_destroy(channel_args); } diff --git a/test/core/end2end/tests/filter_causes_close.cc b/test/core/end2end/tests/filter_causes_close.cc index 6076bee2f2a..ac3fe788334 100644 --- a/test/core/end2end/tests/filter_causes_close.cc +++ b/test/core/end2end/tests/filter_causes_close.cc @@ -256,9 +256,10 @@ void filter_causes_close(grpc_end2end_test_config config) { [](grpc_core::CoreConfiguration::Builder* builder) { grpc_core::BuildCoreConfiguration(builder); builder->channel_init()->RegisterStage( - GRPC_SERVER_CHANNEL, 0, [](grpc_channel_stack_builder* builder) { - return grpc_channel_stack_builder_prepend_filter( - builder, &test_filter, nullptr, nullptr); + GRPC_SERVER_CHANNEL, 0, + [](grpc_core::ChannelStackBuilder* builder) { + builder->PrependFilter(&test_filter, nullptr); + return true; }); }, [config] { test_request(config); }); diff --git a/test/core/end2end/tests/filter_context.cc b/test/core/end2end/tests/filter_context.cc index 1c78570876d..cb93ecda26a 100644 --- a/test/core/end2end/tests/filter_context.cc +++ b/test/core/end2end/tests/filter_context.cc @@ -281,20 +281,16 @@ void filter_context(grpc_end2end_test_config config) { for (auto type : {GRPC_CLIENT_CHANNEL, GRPC_CLIENT_SUBCHANNEL, GRPC_CLIENT_DIRECT_CHANNEL, GRPC_SERVER_CHANNEL}) { builder->channel_init()->RegisterStage( - type, INT_MAX, [](grpc_channel_stack_builder* builder) { + type, INT_MAX, [](grpc_core::ChannelStackBuilder* builder) { // Want to add the filter as close to the end as possible, to // make sure that all of the filters work well together. // However, we can't add it at the very end, because the // connected channel filter must be the last one. So we add it // right before the last one. - grpc_channel_stack_builder_iterator* it = - grpc_channel_stack_builder_create_iterator_at_last(builder); - GPR_ASSERT(grpc_channel_stack_builder_move_prev(it)); - const bool retval = - grpc_channel_stack_builder_add_filter_before( - it, &test_filter, nullptr, nullptr); - grpc_channel_stack_builder_iterator_destroy(it); - return retval; + auto it = builder->mutable_stack()->end(); + --it; + builder->mutable_stack()->insert(it, {&test_filter, nullptr}); + return true; }); } }, diff --git a/test/core/end2end/tests/filter_init_fails.cc b/test/core/end2end/tests/filter_init_fails.cc index 336f3631fe9..eb4a64cfa88 100644 --- a/test/core/end2end/tests/filter_init_fails.cc +++ b/test/core/end2end/tests/filter_init_fails.cc @@ -490,21 +490,17 @@ void filter_init_fails(grpc_end2end_test_config config) { auto register_stage = [builder](grpc_channel_stack_type type, bool* enable) { builder->channel_init()->RegisterStage( - type, INT_MAX, [enable](grpc_channel_stack_builder* builder) { + type, INT_MAX, [enable](grpc_core::ChannelStackBuilder* builder) { if (!*enable) return true; // Want to add the filter as close to the end as possible, // to make sure that all of the filters work well together. // However, we can't add it at the very end, because either the // client_channel filter or connected_channel filter must be the // last one. So we add it right before the last one. - grpc_channel_stack_builder_iterator* it = - grpc_channel_stack_builder_create_iterator_at_last(builder); - GPR_ASSERT(grpc_channel_stack_builder_move_prev(it)); - const bool retval = - grpc_channel_stack_builder_add_filter_before( - it, &test_filter, nullptr, nullptr); - grpc_channel_stack_builder_iterator_destroy(it); - return retval; + auto it = builder->mutable_stack()->end(); + --it; + builder->mutable_stack()->insert(it, {&test_filter, nullptr}); + return true; }); }; register_stage(GRPC_SERVER_CHANNEL, &g_enable_server_channel_filter); diff --git a/test/core/end2end/tests/filter_latency.cc b/test/core/end2end/tests/filter_latency.cc index f5d51d8c883..ac35c11f081 100644 --- a/test/core/end2end/tests/filter_latency.cc +++ b/test/core/end2end/tests/filter_latency.cc @@ -313,20 +313,16 @@ void filter_latency(grpc_end2end_test_config config) { auto register_stage = [builder](grpc_channel_stack_type type, const grpc_channel_filter* filter) { builder->channel_init()->RegisterStage( - type, INT_MAX, [filter](grpc_channel_stack_builder* builder) { + type, INT_MAX, [filter](grpc_core::ChannelStackBuilder* builder) { // Want to add the filter as close to the end as possible, to // make sure that all of the filters work well together. // However, we can't add it at the very end, because the // connected channel filter must be the last one. So we add it // right before the last one. - grpc_channel_stack_builder_iterator* it = - grpc_channel_stack_builder_create_iterator_at_last(builder); - GPR_ASSERT(grpc_channel_stack_builder_move_prev(it)); - const bool retval = - grpc_channel_stack_builder_add_filter_before( - it, filter, nullptr, nullptr); - grpc_channel_stack_builder_iterator_destroy(it); - return retval; + auto it = builder->mutable_stack()->end(); + --it; + builder->mutable_stack()->insert(it, {filter, nullptr}); + return true; }); }; register_stage(GRPC_CLIENT_CHANNEL, &test_client_filter); diff --git a/test/core/end2end/tests/filter_status_code.cc b/test/core/end2end/tests/filter_status_code.cc index d31193afa53..586f7722735 100644 --- a/test/core/end2end/tests/filter_status_code.cc +++ b/test/core/end2end/tests/filter_status_code.cc @@ -360,20 +360,16 @@ void filter_status_code(grpc_end2end_test_config config) { auto register_stage = [builder](grpc_channel_stack_type type, const grpc_channel_filter* filter) { builder->channel_init()->RegisterStage( - type, INT_MAX, [filter](grpc_channel_stack_builder* builder) { + type, INT_MAX, [filter](grpc_core::ChannelStackBuilder* builder) { // Want to add the filter as close to the end as possible, to // make sure that all of the filters work well together. // However, we can't add it at the very end, because the // connected_channel/client_channel filter must be the last one. // So we add it right before the last one. - grpc_channel_stack_builder_iterator* it = - grpc_channel_stack_builder_create_iterator_at_last(builder); - GPR_ASSERT(grpc_channel_stack_builder_move_prev(it)); - const bool retval = - grpc_channel_stack_builder_add_filter_before( - it, filter, nullptr, nullptr); - grpc_channel_stack_builder_iterator_destroy(it); - return retval; + auto it = builder->mutable_stack()->end(); + --it; + builder->mutable_stack()->insert(it, {filter, nullptr}); + return true; }); }; register_stage(GRPC_CLIENT_CHANNEL, &test_client_filter); diff --git a/test/core/end2end/tests/retry_cancel_with_multiple_send_batches.cc b/test/core/end2end/tests/retry_cancel_with_multiple_send_batches.cc index 1d5fde05ddf..bf0d02d6234 100644 --- a/test/core/end2end/tests/retry_cancel_with_multiple_send_batches.cc +++ b/test/core/end2end/tests/retry_cancel_with_multiple_send_batches.cc @@ -306,16 +306,15 @@ grpc_channel_filter FailSendOpsFilter::kFilterVtable = { "FailSendOpsFilter", }; -bool MaybeAddFilter(grpc_channel_stack_builder* builder) { +bool MaybeAddFilter(grpc_core::ChannelStackBuilder* builder) { // Skip on proxy (which explicitly disables retries). - const grpc_channel_args* args = - grpc_channel_stack_builder_get_channel_arguments(builder); + const grpc_channel_args* args = builder->channel_args(); if (!grpc_channel_args_find_bool(args, GRPC_ARG_ENABLE_RETRIES, true)) { return true; } // Install filter. - return grpc_channel_stack_builder_prepend_filter( - builder, &FailSendOpsFilter::kFilterVtable, nullptr, nullptr); + builder->PrependFilter(&FailSendOpsFilter::kFilterVtable, nullptr); + return true; } } // namespace diff --git a/test/core/end2end/tests/retry_recv_trailing_metadata_error.cc b/test/core/end2end/tests/retry_recv_trailing_metadata_error.cc index 7e7411a7010..01bd449fbb6 100644 --- a/test/core/end2end/tests/retry_recv_trailing_metadata_error.cc +++ b/test/core/end2end/tests/retry_recv_trailing_metadata_error.cc @@ -338,16 +338,15 @@ grpc_channel_filter InjectStatusFilter::kFilterVtable = { "InjectStatusFilter", }; -bool AddFilter(grpc_channel_stack_builder* builder) { +bool AddFilter(grpc_core::ChannelStackBuilder* builder) { // Skip on proxy (which explicitly disables retries). - const grpc_channel_args* args = - grpc_channel_stack_builder_get_channel_arguments(builder); + const grpc_channel_args* args = builder->channel_args(); if (!grpc_channel_args_find_bool(args, GRPC_ARG_ENABLE_RETRIES, true)) { return true; } // Install filter. - return grpc_channel_stack_builder_prepend_filter( - builder, &InjectStatusFilter::kFilterVtable, nullptr, nullptr); + builder->PrependFilter(&InjectStatusFilter::kFilterVtable, nullptr); + return true; } } // namespace diff --git a/test/core/end2end/tests/retry_send_op_fails.cc b/test/core/end2end/tests/retry_send_op_fails.cc index f3012235d50..92dc8859ff0 100644 --- a/test/core/end2end/tests/retry_send_op_fails.cc +++ b/test/core/end2end/tests/retry_send_op_fails.cc @@ -365,18 +365,18 @@ void retry_send_op_fails(grpc_end2end_test_config config) { [](grpc_core::CoreConfiguration::Builder* builder) { grpc_core::BuildCoreConfiguration(builder); builder->channel_init()->RegisterStage( - GRPC_CLIENT_SUBCHANNEL, 0, [](grpc_channel_stack_builder* builder) { + GRPC_CLIENT_SUBCHANNEL, 0, + [](grpc_core::ChannelStackBuilder* builder) { // Skip on proxy (which explicitly disables retries). - const grpc_channel_args* args = - grpc_channel_stack_builder_get_channel_arguments(builder); + const grpc_channel_args* args = builder->channel_args(); if (!grpc_channel_args_find_bool(args, GRPC_ARG_ENABLE_RETRIES, true)) { return true; } // Install filter. - return grpc_channel_stack_builder_prepend_filter( - builder, &FailFirstSendOpFilter::kFilterVtable, nullptr, - nullptr); + builder->PrependFilter(&FailFirstSendOpFilter::kFilterVtable, + nullptr); + return true; }); }, [config] { test_retry_send_op_fails(config); }); diff --git a/test/core/xds/xds_channel_stack_modifier_test.cc b/test/core/xds/xds_channel_stack_modifier_test.cc index db3bff022f1..b83184d53d8 100644 --- a/test/core/xds/xds_channel_stack_modifier_test.cc +++ b/test/core/xds/xds_channel_stack_modifier_test.cc @@ -77,33 +77,27 @@ TEST(XdsChannelStackModifierTest, XdsHttpFiltersInsertion) { auto channel_stack_modifier = MakeRefCounted( std::vector{&test_filter_1, &test_filter_2}); grpc_arg arg = channel_stack_modifier->MakeChannelArg(); - // Create a phony grpc_channel_stack_builder object + // Create a phony ChannelStackBuilder object grpc_channel_args* args = grpc_channel_args_copy_and_add(nullptr, &arg, 1); - grpc_channel_stack_builder* builder = - grpc_channel_stack_builder_create("test"); - grpc_channel_stack_builder_set_channel_arguments(builder, args); + ChannelStackBuilder builder("test"); + builder.SetChannelArgs(args); grpc_channel_args_destroy(args); grpc_transport_vtable fake_transport_vtable; memset(&fake_transport_vtable, 0, sizeof(grpc_transport_vtable)); fake_transport_vtable.name = "fake"; grpc_transport fake_transport = {&fake_transport_vtable}; - grpc_channel_stack_builder_set_transport(builder, &fake_transport); + builder.SetTransport(&fake_transport); // Construct channel stack and verify that the test filters were successfully // added ASSERT_TRUE(CoreConfiguration::Get().channel_init().CreateStack( - builder, GRPC_SERVER_CHANNEL)); - grpc_channel_stack_builder_iterator* it = - grpc_channel_stack_builder_create_iterator_at_first(builder); - ASSERT_TRUE(grpc_channel_stack_builder_move_next(it)); - ASSERT_STREQ(grpc_channel_stack_builder_iterator_filter_name(it), "server"); - ASSERT_TRUE(grpc_channel_stack_builder_move_next(it)); - ASSERT_STREQ(grpc_channel_stack_builder_iterator_filter_name(it), - kTestFilter1); - ASSERT_TRUE(grpc_channel_stack_builder_move_next(it)); - ASSERT_STREQ(grpc_channel_stack_builder_iterator_filter_name(it), - kTestFilter2); - grpc_channel_stack_builder_iterator_destroy(it); - grpc_channel_stack_builder_destroy(builder); + &builder, GRPC_SERVER_CHANNEL)); + std::vector filters; + for (const auto& entry : *builder.mutable_stack()) { + filters.push_back(entry.filter->name); + } + filters.resize(3); + EXPECT_EQ(filters, + std::vector({"server", kTestFilter1, kTestFilter2})); grpc_shutdown(); } @@ -122,36 +116,27 @@ TEST(XdsChannelStackModifierTest, XdsHttpFiltersInsertionAfterCensus) { auto channel_stack_modifier = MakeRefCounted( std::vector{&test_filter_1, &test_filter_2}); grpc_arg arg = channel_stack_modifier->MakeChannelArg(); - // Create a phony grpc_channel_stack_builder object + // Create a phony ChannelStackBuilder object grpc_channel_args* args = grpc_channel_args_copy_and_add(nullptr, &arg, 1); - grpc_channel_stack_builder* builder = - grpc_channel_stack_builder_create("test"); - grpc_channel_stack_builder_set_channel_arguments(builder, args); + ChannelStackBuilder builder("test"); + builder.SetChannelArgs(args); grpc_channel_args_destroy(args); grpc_transport_vtable fake_transport_vtable; memset(&fake_transport_vtable, 0, sizeof(grpc_transport_vtable)); fake_transport_vtable.name = "fake"; grpc_transport fake_transport = {&fake_transport_vtable}; - grpc_channel_stack_builder_set_transport(builder, &fake_transport); + builder.SetTransport(&fake_transport); // Construct channel stack and verify that the test filters were successfully // added after the census filter ASSERT_TRUE(CoreConfiguration::Get().channel_init().CreateStack( - builder, GRPC_SERVER_CHANNEL)); - grpc_channel_stack_builder_iterator* it = - grpc_channel_stack_builder_create_iterator_at_first(builder); - ASSERT_TRUE(grpc_channel_stack_builder_move_next(it)); - ASSERT_STREQ(grpc_channel_stack_builder_iterator_filter_name(it), "server"); - ASSERT_TRUE(grpc_channel_stack_builder_move_next(it)); - ASSERT_STREQ(grpc_channel_stack_builder_iterator_filter_name(it), - "opencensus_server"); - ASSERT_TRUE(grpc_channel_stack_builder_move_next(it)); - ASSERT_STREQ(grpc_channel_stack_builder_iterator_filter_name(it), - kTestFilter1); - ASSERT_TRUE(grpc_channel_stack_builder_move_next(it)); - ASSERT_STREQ(grpc_channel_stack_builder_iterator_filter_name(it), - kTestFilter2); - grpc_channel_stack_builder_iterator_destroy(it); - grpc_channel_stack_builder_destroy(builder); + &builder, GRPC_SERVER_CHANNEL)); + std::vector filters; + for (const auto& entry : *builder.mutable_stack()) { + filters.push_back(entry.filter->name); + } + filters.resize(4); + EXPECT_EQ(filters, std::vector({"server", "opencensus_server", + kTestFilter1, kTestFilter2})); grpc_shutdown(); } diff --git a/test/cpp/microbenchmarks/bm_call_create.cc b/test/cpp/microbenchmarks/bm_call_create.cc index 2cd7f7daf54..73d35b13059 100644 --- a/test/cpp/microbenchmarks/bm_call_create.cc +++ b/test/cpp/microbenchmarks/bm_call_create.cc @@ -704,16 +704,13 @@ class IsolatedCallFixture : public TrackCounters { const grpc_channel_args* args = grpc_core::CoreConfiguration::Get() .channel_args_preconditioning() .PreconditionChannelArgs(nullptr); - grpc_channel_stack_builder* builder = - grpc_channel_stack_builder_create("phony"); - grpc_channel_stack_builder_set_target(builder, "phony_target"); - grpc_channel_stack_builder_set_channel_arguments(builder, args); - GPR_ASSERT(grpc_channel_stack_builder_append_filter( - builder, &isolated_call_filter::isolated_call_filter, nullptr, - nullptr)); + grpc_core::ChannelStackBuilder builder("phony"); + builder.SetTarget("phony_target"); + builder.SetChannelArgs(args); + builder.AppendFilter(&isolated_call_filter::isolated_call_filter, nullptr); { grpc_core::ExecCtx exec_ctx; - channel_ = grpc_channel_create_with_builder(builder, GRPC_CLIENT_CHANNEL, + channel_ = grpc_channel_create_with_builder(&builder, GRPC_CLIENT_CHANNEL, nullptr); } cq_ = grpc_completion_queue_create_for_next(nullptr);