@ -26,6 +26,8 @@
# include <stdio.h> # include <stdio.h>
# include <string.h> # include <string.h>
# include <set>
# include <grpc/support/alloc.h> # include <grpc/support/alloc.h>
# include <grpc/support/log.h> # include <grpc/support/log.h>
# include <grpc/support/string_util.h> # include <grpc/support/string_util.h>
@ -53,7 +55,6 @@
# include "src/core/lib/gprpp/inlined_vector.h" # include "src/core/lib/gprpp/inlined_vector.h"
# include "src/core/lib/gprpp/manual_constructor.h" # include "src/core/lib/gprpp/manual_constructor.h"
# include "src/core/lib/gprpp/map.h" # include "src/core/lib/gprpp/map.h"
# include "src/core/lib/gprpp/set.h"
# include "src/core/lib/gprpp/sync.h" # include "src/core/lib/gprpp/sync.h"
# include "src/core/lib/iomgr/combiner.h" # include "src/core/lib/iomgr/combiner.h"
# include "src/core/lib/iomgr/iomgr.h" # include "src/core/lib/iomgr/iomgr.h"
@ -161,7 +162,7 @@ class ChannelData {
MutexLock lock ( & external_watchers_mu_ ) ; MutexLock lock ( & external_watchers_mu_ ) ;
// Will be deleted when the watch is complete.
// Will be deleted when the watch is complete.
GPR_ASSERT ( external_watchers_ [ on_complete ] = = nullptr ) ; GPR_ASSERT ( external_watchers_ [ on_complete ] = = nullptr ) ;
external_watchers_ [ on_complete ] = New < ExternalConnectivityWatcher > ( external_watchers_ [ on_complete ] = new ExternalConnectivityWatcher (
this , pollent , state , on_complete , watcher_timer_init ) ; this , pollent , state , on_complete , watcher_timer_init ) ;
} }
@ -227,7 +228,7 @@ class ChannelData {
void UpdateStateAndPickerLocked ( void UpdateStateAndPickerLocked (
grpc_connectivity_state state , const char * reason , grpc_connectivity_state state , const char * reason ,
UniqueP tr< LoadBalancingPolicy : : SubchannelPicker > picker ) ; std : : unique_p tr< LoadBalancingPolicy : : SubchannelPicker > picker ) ;
void UpdateServiceConfigLocked ( void UpdateServiceConfigLocked (
RefCountedPtr < ServerRetryThrottleData > retry_throttle_data , RefCountedPtr < ServerRetryThrottleData > retry_throttle_data ,
@ -251,7 +252,7 @@ class ChannelData {
void ProcessLbPolicy ( void ProcessLbPolicy (
const Resolver : : Result & resolver_result , const Resolver : : Result & resolver_result ,
const internal : : ClientChannelGlobalParsedConfig * parsed_service_config , const internal : : ClientChannelGlobalParsedConfig * parsed_service_config ,
UniqueP tr< char > * lb_policy_name , std : : unique_p tr< char > * lb_policy_name ,
RefCountedPtr < LoadBalancingPolicy : : Config > * lb_policy_config ) ; RefCountedPtr < LoadBalancingPolicy : : Config > * lb_policy_config ) ;
//
//
@ -264,15 +265,15 @@ class ChannelData {
ClientChannelFactory * client_channel_factory_ ; ClientChannelFactory * client_channel_factory_ ;
const grpc_channel_args * channel_args_ ; const grpc_channel_args * channel_args_ ;
RefCountedPtr < ServiceConfig > default_service_config_ ; RefCountedPtr < ServiceConfig > default_service_config_ ;
UniqueP tr< char > server_name_ ; std : : unique_p tr< char > server_name_ ;
UniqueP tr< char > target_uri_ ; std : : unique_p tr< char > target_uri_ ;
channelz : : ChannelNode * channelz_node_ ; channelz : : ChannelNode * channelz_node_ ;
//
//
// Fields used in the data plane. Guarded by data_plane_mu.
// Fields used in the data plane. Guarded by data_plane_mu.
//
//
mutable Mutex data_plane_mu_ ; mutable Mutex data_plane_mu_ ;
UniqueP tr< LoadBalancingPolicy : : SubchannelPicker > picker_ ; std : : unique_p tr< LoadBalancingPolicy : : SubchannelPicker > picker_ ;
QueuedPick * queued_picks_ = nullptr ; // Linked list of queued picks.
QueuedPick * queued_picks_ = nullptr ; // Linked list of queued picks.
// Data from service config.
// Data from service config.
bool received_service_config_data_ = false ; bool received_service_config_data_ = false ;
@ -287,19 +288,19 @@ class ChannelData {
RefCountedPtr < SubchannelPoolInterface > subchannel_pool_ ; RefCountedPtr < SubchannelPoolInterface > subchannel_pool_ ;
OrphanablePtr < ResolvingLoadBalancingPolicy > resolving_lb_policy_ ; OrphanablePtr < ResolvingLoadBalancingPolicy > resolving_lb_policy_ ;
ConnectivityStateTracker state_tracker_ ; ConnectivityStateTracker state_tracker_ ;
UniqueP tr< char > health_check_service_name_ ; std : : unique_p tr< char > health_check_service_name_ ;
RefCountedPtr < ServiceConfig > saved_service_config_ ; RefCountedPtr < ServiceConfig > saved_service_config_ ;
bool received_first_resolver_result_ = false ; bool received_first_resolver_result_ = false ;
// The number of SubchannelWrapper instances referencing a given Subchannel.
// The number of SubchannelWrapper instances referencing a given Subchannel.
M ap< Subchannel * , int > subchannel_refcount_map_ ; std : : m ap< Subchannel * , int > subchannel_refcount_map_ ;
// The set of SubchannelWrappers that currently exist.
// The set of SubchannelWrappers that currently exist.
// No need to hold a ref, since the map is updated in the control-plane
// No need to hold a ref, since the map is updated in the control-plane
// combiner when the SubchannelWrappers are created and destroyed.
// combiner when the SubchannelWrappers are created and destroyed.
S et< SubchannelWrapper * > subchannel_wrappers_ ; std : : s et< SubchannelWrapper * > subchannel_wrappers_ ;
// Pending ConnectedSubchannel updates for each SubchannelWrapper.
// Pending ConnectedSubchannel updates for each SubchannelWrapper.
// Updates are queued here in the control plane combiner and then applied
// Updates are queued here in the control plane combiner and then applied
// in the data plane mutex when the picker is updated.
// in the data plane mutex when the picker is updated.
M ap< RefCountedPtr < SubchannelWrapper > , RefCountedPtr < ConnectedSubchannel > , std : : m ap< RefCountedPtr < SubchannelWrapper > , RefCountedPtr < ConnectedSubchannel > ,
RefCountedPtrLess < SubchannelWrapper > > RefCountedPtrLess < SubchannelWrapper > >
pending_subchannel_updates_ ; pending_subchannel_updates_ ;
@ -313,15 +314,15 @@ class ChannelData {
// synchronously via get_channel_info().
// synchronously via get_channel_info().
//
//
gpr_mu info_mu_ ; gpr_mu info_mu_ ;
UniqueP tr< char > info_lb_policy_name_ ; std : : unique_p tr< char > info_lb_policy_name_ ;
UniqueP tr< char > info_service_config_json_ ; std : : unique_p tr< char > info_service_config_json_ ;
//
//
// Fields guarded by a mutex, since they need to be accessed
// Fields guarded by a mutex, since they need to be accessed
// synchronously via grpc_channel_num_external_connectivity_watchers().
// synchronously via grpc_channel_num_external_connectivity_watchers().
//
//
mutable Mutex external_watchers_mu_ ; mutable Mutex external_watchers_mu_ ;
M ap< grpc_closure * , ExternalConnectivityWatcher * > external_watchers_ ; std : : m ap< grpc_closure * , ExternalConnectivityWatcher * > external_watchers_ ;
} ; } ;
//
//
@ -403,8 +404,9 @@ class CallData {
intptr_t handle ) const override { intptr_t handle ) const override {
grpc_linked_mdelem * linked_mdelem = grpc_linked_mdelem * linked_mdelem =
reinterpret_cast < grpc_linked_mdelem * > ( handle ) ; reinterpret_cast < grpc_linked_mdelem * > ( handle ) ;
return std : : make_pair ( StringView ( GRPC_MDKEY ( linked_mdelem - > md ) ) , return std : : make_pair (
StringView ( GRPC_MDVALUE ( linked_mdelem - > md ) ) ) ; StringViewFromSlice ( GRPC_MDKEY ( linked_mdelem - > md ) ) ,
StringViewFromSlice ( GRPC_MDVALUE ( linked_mdelem - > md ) ) ) ;
} }
CallData * calld_ ; CallData * calld_ ;
@ -841,7 +843,7 @@ class CallData {
class ChannelData : : SubchannelWrapper : public SubchannelInterface { class ChannelData : : SubchannelWrapper : public SubchannelInterface {
public : public :
SubchannelWrapper ( ChannelData * chand , Subchannel * subchannel , SubchannelWrapper ( ChannelData * chand , Subchannel * subchannel ,
UniqueP tr< char > health_check_service_name ) std : : unique_p tr< char > health_check_service_name )
: SubchannelInterface ( & grpc_client_channel_routing_trace ) , : SubchannelInterface ( & grpc_client_channel_routing_trace ) ,
chand_ ( chand ) , chand_ ( chand ) ,
subchannel_ ( subchannel ) , subchannel_ ( subchannel ) ,
@ -896,15 +898,15 @@ class ChannelData::SubchannelWrapper : public SubchannelInterface {
void WatchConnectivityState ( void WatchConnectivityState (
grpc_connectivity_state initial_state , grpc_connectivity_state initial_state ,
UniqueP tr< ConnectivityStateWatcherInterface > watcher ) override { std : : unique_p tr< ConnectivityStateWatcherInterface > watcher ) override {
auto & watcher_wrapper = watcher_map_ [ watcher . get ( ) ] ; auto & watcher_wrapper = watcher_map_ [ watcher . get ( ) ] ;
GPR_ASSERT ( watcher_wrapper = = nullptr ) ; GPR_ASSERT ( watcher_wrapper = = nullptr ) ;
watcher_wrapper = New < WatcherWrapper > ( std : : move ( watcher ) , watcher_wrapper = new WatcherWrapper ( std : : move ( watcher ) ,
Ref ( DEBUG_LOCATION , " WatcherWrapper " ) , Ref ( DEBUG_LOCATION , " WatcherWrapper " ) ,
initial_state ) ; initial_state ) ;
subchannel_ - > WatchConnectivityState ( subchannel_ - > WatchConnectivityState (
initial_state , initial_state ,
UniqueP tr< char > ( gpr_strdup ( health_check_service_name_ . get ( ) ) ) , std : : unique_p tr< char > ( gpr_strdup ( health_check_service_name_ . get ( ) ) ) ,
OrphanablePtr < Subchannel : : ConnectivityStateWatcherInterface > ( OrphanablePtr < Subchannel : : ConnectivityStateWatcherInterface > (
watcher_wrapper ) ) ; watcher_wrapper ) ) ;
} }
@ -926,7 +928,8 @@ class ChannelData::SubchannelWrapper : public SubchannelInterface {
return subchannel_ - > channel_args ( ) ; return subchannel_ - > channel_args ( ) ;
} }
void UpdateHealthCheckServiceName ( UniquePtr < char > health_check_service_name ) { void UpdateHealthCheckServiceName (
std : : unique_ptr < char > health_check_service_name ) {
if ( GRPC_TRACE_FLAG_ENABLED ( grpc_client_channel_routing_trace ) ) { if ( GRPC_TRACE_FLAG_ENABLED ( grpc_client_channel_routing_trace ) ) {
gpr_log ( GPR_INFO , gpr_log ( GPR_INFO ,
" chand=%p: subchannel wrapper %p: updating health check service " " chand=%p: subchannel wrapper %p: updating health check service "
@ -952,7 +955,7 @@ class ChannelData::SubchannelWrapper : public SubchannelInterface {
watcher_wrapper = replacement ; watcher_wrapper = replacement ;
subchannel_ - > WatchConnectivityState ( subchannel_ - > WatchConnectivityState (
replacement - > last_seen_state ( ) , replacement - > last_seen_state ( ) ,
UniqueP tr< char > ( gpr_strdup ( health_check_service_name . get ( ) ) ) , std : : unique_p tr< char > ( gpr_strdup ( health_check_service_name . get ( ) ) ) ,
OrphanablePtr < Subchannel : : ConnectivityStateWatcherInterface > ( OrphanablePtr < Subchannel : : ConnectivityStateWatcherInterface > (
replacement ) ) ; replacement ) ) ;
} }
@ -992,7 +995,7 @@ class ChannelData::SubchannelWrapper : public SubchannelInterface {
class WatcherWrapper : public Subchannel : : ConnectivityStateWatcherInterface { class WatcherWrapper : public Subchannel : : ConnectivityStateWatcherInterface {
public : public :
WatcherWrapper ( WatcherWrapper (
UniqueP tr< SubchannelInterface : : ConnectivityStateWatcherInterface > std : : unique_p tr< SubchannelInterface : : ConnectivityStateWatcherInterface >
watcher , watcher ,
RefCountedPtr < SubchannelWrapper > parent , RefCountedPtr < SubchannelWrapper > parent ,
grpc_connectivity_state initial_state ) grpc_connectivity_state initial_state )
@ -1016,7 +1019,7 @@ class ChannelData::SubchannelWrapper : public SubchannelInterface {
connected_subchannel . get ( ) , ConnectivityStateName ( new_state ) ) ; connected_subchannel . get ( ) , ConnectivityStateName ( new_state ) ) ;
} }
// Will delete itself.
// Will delete itself.
New < Updater > ( Ref ( ) , new_state , std : : move ( connected_subchannel ) ) ; new Updater ( Ref ( ) , new_state , std : : move ( connected_subchannel ) ) ;
} }
grpc_pollset_set * interested_parties ( ) override { grpc_pollset_set * interested_parties ( ) override {
@ -1028,7 +1031,7 @@ class ChannelData::SubchannelWrapper : public SubchannelInterface {
WatcherWrapper * MakeReplacement ( ) { WatcherWrapper * MakeReplacement ( ) {
auto * replacement = auto * replacement =
New < WatcherWrapper > ( std : : move ( watcher_ ) , parent_ , last_seen_state_ ) ; new WatcherWrapper ( std : : move ( watcher_ ) , parent_ , last_seen_state_ ) ;
replacement_ = replacement ; replacement_ = replacement ;
return replacement ; return replacement ;
} }
@ -1072,7 +1075,7 @@ class ChannelData::SubchannelWrapper : public SubchannelInterface {
self - > parent_ - > parent_ - > MaybeUpdateConnectedSubchannel ( self - > parent_ - > parent_ - > MaybeUpdateConnectedSubchannel (
std : : move ( self - > connected_subchannel_ ) ) ; std : : move ( self - > connected_subchannel_ ) ) ;
self - > parent_ - > watcher_ - > OnConnectivityStateChange ( self - > state_ ) ; self - > parent_ - > watcher_ - > OnConnectivityStateChange ( self - > state_ ) ;
Delete ( self ) ; delete self ;
} }
RefCountedPtr < WatcherWrapper > parent_ ; RefCountedPtr < WatcherWrapper > parent_ ;
@ -1081,7 +1084,8 @@ class ChannelData::SubchannelWrapper : public SubchannelInterface {
grpc_closure closure_ ; grpc_closure closure_ ;
} ; } ;
UniquePtr < SubchannelInterface : : ConnectivityStateWatcherInterface > watcher_ ; std : : unique_ptr < SubchannelInterface : : ConnectivityStateWatcherInterface >
watcher_ ;
RefCountedPtr < SubchannelWrapper > parent_ ; RefCountedPtr < SubchannelWrapper > parent_ ;
grpc_connectivity_state last_seen_state_ ; grpc_connectivity_state last_seen_state_ ;
WatcherWrapper * replacement_ = nullptr ; WatcherWrapper * replacement_ = nullptr ;
@ -1110,13 +1114,13 @@ class ChannelData::SubchannelWrapper : public SubchannelInterface {
ChannelData * chand_ ; ChannelData * chand_ ;
Subchannel * subchannel_ ; Subchannel * subchannel_ ;
UniqueP tr< char > health_check_service_name_ ; std : : unique_p tr< char > health_check_service_name_ ;
// Maps from the address of the watcher passed to us by the LB policy
// Maps from the address of the watcher passed to us by the LB policy
// to the address of the WrapperWatcher that we passed to the underlying
// to the address of the WrapperWatcher that we passed to the underlying
// subchannel. This is needed so that when the LB policy calls
// subchannel. This is needed so that when the LB policy calls
// CancelConnectivityStateWatch() with its watcher, we know the
// CancelConnectivityStateWatch() with its watcher, we know the
// corresponding WrapperWatcher to cancel on the underlying subchannel.
// corresponding WrapperWatcher to cancel on the underlying subchannel.
M ap< ConnectivityStateWatcherInterface * , WatcherWrapper * > watcher_map_ ; std : : m ap< ConnectivityStateWatcherInterface * , WatcherWrapper * > watcher_map_ ;
// To be accessed only in the control plane combiner.
// To be accessed only in the control plane combiner.
RefCountedPtr < ConnectedSubchannel > connected_subchannel_ ; RefCountedPtr < ConnectedSubchannel > connected_subchannel_ ;
// To be accessed only in the data plane mutex.
// To be accessed only in the data plane mutex.
@ -1163,7 +1167,7 @@ void ChannelData::ExternalConnectivityWatcher::Notify(
chand_ - > RemoveExternalConnectivityWatcher ( on_complete_ , /*cancel=*/ false ) ; chand_ - > RemoveExternalConnectivityWatcher ( on_complete_ , /*cancel=*/ false ) ;
// Report new state to the user.
// Report new state to the user.
* state_ = state ; * state_ = state ;
GRPC_CLOSURE_SCHED ( on_complete_ , GRPC_ERROR_NONE ) ; ExecCtx : : Run ( DEBUG_LOCATION , on_complete_ , GRPC_ERROR_NONE ) ;
// Hop back into the combiner to clean up.
// Hop back into the combiner to clean up.
// Not needed in state SHUTDOWN, because the tracker will
// Not needed in state SHUTDOWN, because the tracker will
// automatically remove all watchers in that case.
// automatically remove all watchers in that case.
@ -1180,7 +1184,7 @@ void ChannelData::ExternalConnectivityWatcher::Cancel() {
MemoryOrder : : RELAXED ) ) { MemoryOrder : : RELAXED ) ) {
return ; // Already done.
return ; // Already done.
} }
GRPC_CLOSURE_SCHED ( on_complete_ , GRPC_ERROR_CANCELLED ) ; ExecCtx : : Run ( DEBUG_LOCATION , on_complete_ , GRPC_ERROR_CANCELLED ) ;
// Hop back into the combiner to clean up.
// Hop back into the combiner to clean up.
chand_ - > combiner_ - > Run ( chand_ - > combiner_ - > Run (
GRPC_CLOSURE_INIT ( & remove_closure_ , RemoveWatcherLocked , this , nullptr ) , GRPC_CLOSURE_INIT ( & remove_closure_ , RemoveWatcherLocked , this , nullptr ) ,
@ -1234,7 +1238,7 @@ class ChannelData::ConnectivityWatcherAdder {
std : : move ( self - > watcher_ ) ) ; std : : move ( self - > watcher_ ) ) ;
GRPC_CHANNEL_STACK_UNREF ( self - > chand_ - > owning_stack_ , GRPC_CHANNEL_STACK_UNREF ( self - > chand_ - > owning_stack_ ,
" ConnectivityWatcherAdder " ) ; " ConnectivityWatcherAdder " ) ;
Delete ( self ) ; delete self ;
} }
ChannelData * chand_ ; ChannelData * chand_ ;
@ -1267,7 +1271,7 @@ class ChannelData::ConnectivityWatcherRemover {
self - > chand_ - > state_tracker_ . RemoveWatcher ( self - > watcher_ ) ; self - > chand_ - > state_tracker_ . RemoveWatcher ( self - > watcher_ ) ;
GRPC_CHANNEL_STACK_UNREF ( self - > chand_ - > owning_stack_ , GRPC_CHANNEL_STACK_UNREF ( self - > chand_ - > owning_stack_ ,
" ConnectivityWatcherRemover " ) ; " ConnectivityWatcherRemover " ) ;
Delete ( self ) ; delete self ;
} }
ChannelData * chand_ ; ChannelData * chand_ ;
@ -1295,7 +1299,7 @@ class ChannelData::ClientChannelControlHelper
const grpc_channel_args & args ) override { const grpc_channel_args & args ) override {
bool inhibit_health_checking = grpc_channel_arg_get_bool ( bool inhibit_health_checking = grpc_channel_arg_get_bool (
grpc_channel_args_find ( & args , GRPC_ARG_INHIBIT_HEALTH_CHECKING ) , false ) ; grpc_channel_args_find ( & args , GRPC_ARG_INHIBIT_HEALTH_CHECKING ) , false ) ;
UniqueP tr< char > health_check_service_name ; std : : unique_p tr< char > health_check_service_name ;
if ( ! inhibit_health_checking ) { if ( ! inhibit_health_checking ) {
health_check_service_name . reset ( health_check_service_name . reset (
gpr_strdup ( chand_ - > health_check_service_name_ . get ( ) ) ) ; gpr_strdup ( chand_ - > health_check_service_name_ . get ( ) ) ) ;
@ -1318,7 +1322,7 @@ class ChannelData::ClientChannelControlHelper
void UpdateState ( void UpdateState (
grpc_connectivity_state state , grpc_connectivity_state state ,
UniqueP tr< LoadBalancingPolicy : : SubchannelPicker > picker ) override { std : : unique_p tr< LoadBalancingPolicy : : SubchannelPicker > picker ) override {
grpc_error * disconnect_error = chand_ - > disconnect_error ( ) ; grpc_error * disconnect_error = chand_ - > disconnect_error ( ) ;
if ( GRPC_TRACE_FLAG_ENABLED ( grpc_client_channel_routing_trace ) ) { if ( GRPC_TRACE_FLAG_ENABLED ( grpc_client_channel_routing_trace ) ) {
const char * extra = disconnect_error = = GRPC_ERROR_NONE const char * extra = disconnect_error = = GRPC_ERROR_NONE
@ -1491,7 +1495,7 @@ ChannelData::~ChannelData() {
void ChannelData : : UpdateStateAndPickerLocked ( void ChannelData : : UpdateStateAndPickerLocked (
grpc_connectivity_state state , const char * reason , grpc_connectivity_state state , const char * reason ,
UniqueP tr< LoadBalancingPolicy : : SubchannelPicker > picker ) { std : : unique_p tr< LoadBalancingPolicy : : SubchannelPicker > picker ) {
// Clean the control plane when entering IDLE.
// Clean the control plane when entering IDLE.
if ( picker_ = = nullptr ) { if ( picker_ = = nullptr ) {
health_check_service_name_ . reset ( ) ; health_check_service_name_ . reset ( ) ;
@ -1591,8 +1595,8 @@ void ChannelData::CreateResolvingLoadBalancingPolicyLocked() {
lb_args . combiner = combiner_ ; lb_args . combiner = combiner_ ;
lb_args . channel_control_helper = MakeUnique < ClientChannelControlHelper > ( this ) ; lb_args . channel_control_helper = MakeUnique < ClientChannelControlHelper > ( this ) ;
lb_args . args = channel_args_ ; lb_args . args = channel_args_ ;
UniqueP tr< char > target_uri ( gpr_strdup ( target_uri_ . get ( ) ) ) ; std : : unique_p tr< char > target_uri ( gpr_strdup ( target_uri_ . get ( ) ) ) ;
resolving_lb_policy_ . reset ( New < ResolvingLoadBalancingPolicy > ( resolving_lb_policy_ . reset ( new ResolvingLoadBalancingPolicy (
std : : move ( lb_args ) , & grpc_client_channel_routing_trace , std : : move ( lb_args ) , & grpc_client_channel_routing_trace ,
std : : move ( target_uri ) , ProcessResolverResultLocked , this ) ) ; std : : move ( target_uri ) , ProcessResolverResultLocked , this ) ) ;
grpc_pollset_set_add_pollset_set ( resolving_lb_policy_ - > interested_parties ( ) , grpc_pollset_set_add_pollset_set ( resolving_lb_policy_ - > interested_parties ( ) ,
@ -1614,7 +1618,7 @@ void ChannelData::DestroyResolvingLoadBalancingPolicyLocked() {
void ChannelData : : ProcessLbPolicy ( void ChannelData : : ProcessLbPolicy (
const Resolver : : Result & resolver_result , const Resolver : : Result & resolver_result ,
const internal : : ClientChannelGlobalParsedConfig * parsed_service_config , const internal : : ClientChannelGlobalParsedConfig * parsed_service_config ,
UniqueP tr< char > * lb_policy_name , std : : unique_p tr< char > * lb_policy_name ,
RefCountedPtr < LoadBalancingPolicy : : Config > * lb_policy_config ) { RefCountedPtr < LoadBalancingPolicy : : Config > * lb_policy_config ) {
// Prefer the LB policy name found in the service config.
// Prefer the LB policy name found in the service config.
if ( parsed_service_config ! = nullptr & & if ( parsed_service_config ! = nullptr & &
@ -1709,7 +1713,7 @@ bool ChannelData::ProcessResolverResultLocked(
return false ; return false ;
} }
// Process service config.
// Process service config.
UniqueP tr< char > service_config_json ; std : : unique_p tr< char > service_config_json ;
const internal : : ClientChannelGlobalParsedConfig * parsed_service_config = const internal : : ClientChannelGlobalParsedConfig * parsed_service_config =
nullptr ; nullptr ;
if ( service_config ! = nullptr ) { if ( service_config ! = nullptr ) {
@ -1743,8 +1747,8 @@ bool ChannelData::ProcessResolverResultLocked(
} }
// Update health check service name used by existing subchannel wrappers.
// Update health check service name used by existing subchannel wrappers.
for ( auto * subchannel_wrapper : chand - > subchannel_wrappers_ ) { for ( auto * subchannel_wrapper : chand - > subchannel_wrappers_ ) {
subchannel_wrapper - > UpdateHealthCheckServiceName ( subchannel_wrapper - > UpdateHealthCheckServiceName ( std : : unique_ptr < char > (
UniquePtr < char > ( gpr_strdup ( chand - > health_check_service_name_ . get ( ) ) ) ) ; gpr_strdup ( chand - > health_check_service_name_ . get ( ) ) ) ) ;
} }
// Save service config.
// Save service config.
chand - > saved_service_config_ = std : : move ( service_config ) ; chand - > saved_service_config_ = std : : move ( service_config ) ;
@ -1769,7 +1773,7 @@ bool ChannelData::ProcessResolverResultLocked(
chand - > UpdateServiceConfigLocked ( std : : move ( retry_throttle_data ) , chand - > UpdateServiceConfigLocked ( std : : move ( retry_throttle_data ) ,
chand - > saved_service_config_ ) ; chand - > saved_service_config_ ) ;
} }
UniqueP tr< char > processed_lb_policy_name ; std : : unique_p tr< char > processed_lb_policy_name ;
chand - > ProcessLbPolicy ( result , parsed_service_config , chand - > ProcessLbPolicy ( result , parsed_service_config ,
& processed_lb_policy_name , lb_policy_config ) ; & processed_lb_policy_name , lb_policy_config ) ;
// Swap out the data used by GetChannelInfo().
// Swap out the data used by GetChannelInfo().
@ -1825,8 +1829,9 @@ void ChannelData::StartTransportOpLocked(void* arg, grpc_error* /*ignored*/) {
if ( op - > send_ping . on_initiate ! = nullptr | | op - > send_ping . on_ack ! = nullptr ) { if ( op - > send_ping . on_initiate ! = nullptr | | op - > send_ping . on_ack ! = nullptr ) {
grpc_error * error = chand - > DoPingLocked ( op ) ; grpc_error * error = chand - > DoPingLocked ( op ) ;
if ( error ! = GRPC_ERROR_NONE ) { if ( error ! = GRPC_ERROR_NONE ) {
GRPC_CLOSURE_SCHED ( op - > send_ping . on_initiate , GRPC_ERROR_REF ( error ) ) ; ExecCtx : : Run ( DEBUG_LOCATION , op - > send_ping . on_initiate ,
GRPC_CLOSURE_SCHED ( op - > send_ping . on_ack , error ) ; GRPC_ERROR_REF ( error ) ) ;
ExecCtx : : Run ( DEBUG_LOCATION , op - > send_ping . on_ack , error ) ;
} }
op - > bind_pollset = nullptr ; op - > bind_pollset = nullptr ;
op - > send_ping . on_initiate = nullptr ; op - > send_ping . on_initiate = nullptr ;
@ -1868,7 +1873,7 @@ void ChannelData::StartTransportOpLocked(void* arg, grpc_error* /*ignored*/) {
} }
} }
GRPC_CHANNEL_STACK_UNREF ( chand - > owning_stack_ , " start_transport_op " ) ; GRPC_CHANNEL_STACK_UNREF ( chand - > owning_stack_ , " start_transport_op " ) ;
GRPC_CLOSURE_SCHED ( op - > on_consumed , GRPC_ERROR_NONE ) ; ExecCtx : : Run ( DEBUG_LOCATION , op - > on_consumed , GRPC_ERROR_NONE ) ;
} }
void ChannelData : : StartTransportOp ( grpc_channel_element * elem , void ChannelData : : StartTransportOp ( grpc_channel_element * elem ,
@ -1960,12 +1965,12 @@ grpc_connectivity_state ChannelData::CheckConnectivityState(
void ChannelData : : AddConnectivityWatcher ( void ChannelData : : AddConnectivityWatcher (
grpc_connectivity_state initial_state , grpc_connectivity_state initial_state ,
OrphanablePtr < AsyncConnectivityStateWatcherInterface > watcher ) { OrphanablePtr < AsyncConnectivityStateWatcherInterface > watcher ) {
New < ConnectivityWatcherAdder > ( this , initial_state , std : : move ( watcher ) ) ; new ConnectivityWatcherAdder ( this , initial_state , std : : move ( watcher ) ) ;
} }
void ChannelData : : RemoveConnectivityWatcher ( void ChannelData : : RemoveConnectivityWatcher (
AsyncConnectivityStateWatcherInterface * watcher ) { AsyncConnectivityStateWatcherInterface * watcher ) {
New < ConnectivityWatcherRemover > ( this , watcher ) ; new ConnectivityWatcherRemover ( this , watcher ) ;
} }
//
//
@ -2057,7 +2062,8 @@ void CallData::Destroy(grpc_call_element* elem,
then_schedule_closure = nullptr ; then_schedule_closure = nullptr ;
} }
calld - > ~ CallData ( ) ; calld - > ~ CallData ( ) ;
GRPC_CLOSURE_SCHED ( then_schedule_closure , GRPC_ERROR_NONE ) ; // TODO(yashkt) : This can potentially be a Closure::Run
ExecCtx : : Run ( DEBUG_LOCATION , then_schedule_closure , GRPC_ERROR_NONE ) ;
} }
void CallData : : StartTransportStreamOpBatch ( void CallData : : StartTransportStreamOpBatch (
@ -3681,7 +3687,7 @@ void CallData::CreateSubchannelCall(grpc_call_element* elem) {
void CallData : : AsyncPickDone ( grpc_call_element * elem , grpc_error * error ) { void CallData : : AsyncPickDone ( grpc_call_element * elem , grpc_error * error ) {
GRPC_CLOSURE_INIT ( & pick_closure_ , PickDone , elem , grpc_schedule_on_exec_ctx ) ; GRPC_CLOSURE_INIT ( & pick_closure_ , PickDone , elem , grpc_schedule_on_exec_ctx ) ;
GRPC_CLOSURE_SCHED ( & pick_closure_ , error ) ; ExecCtx : : Run ( DEBUG_LOCATION , & pick_closure_ , error ) ;
} }
void CallData : : PickDone ( void * arg , grpc_error * error ) { void CallData : : PickDone ( void * arg , grpc_error * error ) {
@ -3733,7 +3739,7 @@ class CallData::QueuedPickCanceller {
YieldCallCombinerIfPendingBatchesFound ) ; YieldCallCombinerIfPendingBatchesFound ) ;
} }
GRPC_CALL_STACK_UNREF ( calld - > owning_call_ , " QueuedPickCanceller " ) ; GRPC_CALL_STACK_UNREF ( calld - > owning_call_ , " QueuedPickCanceller " ) ;
Delete ( self ) ; delete self ;
} }
grpc_call_element * elem_ ; grpc_call_element * elem_ ;
@ -3762,7 +3768,7 @@ void CallData::AddCallToQueuedPicksLocked(grpc_call_element* elem) {
pick_ . elem = elem ; pick_ . elem = elem ;
chand - > AddQueuedPick ( & pick_ , pollent_ ) ; chand - > AddQueuedPick ( & pick_ , pollent_ ) ;
// Register call combiner cancellation callback.
// Register call combiner cancellation callback.
pick_canceller_ = New < QueuedPickCanceller > ( elem ) ; pick_canceller_ = new QueuedPickCanceller ( elem ) ;
} }
void CallData : : ApplyServiceConfigToCallLocked ( grpc_call_element * elem ) { void CallData : : ApplyServiceConfigToCallLocked ( grpc_call_element * elem ) {
Yash Tibrewal
6 years ago