/*
 *
 * Copyright 2014 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.
 *
 */

package grpc

import (
	
	
	
	
	
	
	
	
	
	

	
	
	
	
	
	
	
	
	
	iresolver 
	
	
	
	
	
	

	_            // To register roundrobin.
	_  // To register passthrough resolver.
	_         // To register unix resolver.
	_                   // To register dns resolver.
)

const (
	// minimum time to give a connection to complete
	minConnectTimeout = 20 * time.Second
)

var (
	// ErrClientConnClosing indicates that the operation is illegal because
	// the ClientConn is closing.
	//
	// Deprecated: this error should not be relied upon by users; use the status
	// code of Canceled instead.
	ErrClientConnClosing = status.Error(codes.Canceled, "grpc: the client connection is closing")
	// errConnDrain indicates that the connection starts to be drained and does not accept any new RPCs.
	errConnDrain = errors.New("grpc: the connection is drained")
	// errConnClosing indicates that the connection is closing.
	errConnClosing = errors.New("grpc: the connection is closing")
	// errConnIdling indicates the connection is being closed as the channel
	// is moving to an idle mode due to inactivity.
	errConnIdling = errors.New("grpc: the connection is closing due to channel idleness")
	// invalidDefaultServiceConfigErrPrefix is used to prefix the json parsing error for the default
	// service config.
	invalidDefaultServiceConfigErrPrefix = "grpc: the provided default service config is invalid"
	// PickFirstBalancerName is the name of the pick_first balancer.
	PickFirstBalancerName = pickfirst.Name
)

// The following errors are returned from Dial and DialContext
var (
	// errNoTransportSecurity indicates that there is no transport security
	// being set for ClientConn. Users should either set one or explicitly
	// call WithInsecure DialOption to disable security.
	errNoTransportSecurity = errors.New("grpc: no transport security set (use grpc.WithTransportCredentials(insecure.NewCredentials()) explicitly or set credentials)")
	// errTransportCredsAndBundle indicates that creds bundle is used together
	// with other individual Transport Credentials.
	errTransportCredsAndBundle = errors.New("grpc: credentials.Bundle may not be used with individual TransportCredentials")
	// errNoTransportCredsInBundle indicated that the configured creds bundle
	// returned a transport credentials which was nil.
	errNoTransportCredsInBundle = errors.New("grpc: credentials.Bundle must return non-nil transport credentials")
	// errTransportCredentialsMissing indicates that users want to transmit
	// security information (e.g., OAuth2 token) which requires secure
	// connection on an insecure connection.
	errTransportCredentialsMissing = errors.New("grpc: the credentials require transport level security (use grpc.WithTransportCredentials() to set)")
)

const (
	defaultClientMaxReceiveMessageSize = 1024 * 1024 * 4
	defaultClientMaxSendMessageSize    = math.MaxInt32
	// http2IOBufSize specifies the buffer size for sending frames.
	defaultWriteBufSize = 32 * 1024
	defaultReadBufSize  = 32 * 1024
)

type defaultConfigSelector struct {
	sc *ServiceConfig
}

func ( *defaultConfigSelector) ( iresolver.RPCInfo) (*iresolver.RPCConfig, error) {
	return &iresolver.RPCConfig{
		Context:      .Context,
		MethodConfig: getMethodConfig(.sc, .Method),
	}, nil
}

// NewClient creates a new gRPC "channel" for the target URI provided.  No I/O
// is performed.  Use of the ClientConn for RPCs will automatically cause it to
// connect.  The Connect method may be called to manually create a connection,
// but for most users this should be unnecessary.
//
// The target name syntax is defined in
// https://github.com/grpc/grpc/blob/master/doc/naming.md.  E.g. to use the dns
// name resolver, a "dns:///" prefix may be applied to the target.  The default
// name resolver will be used if no scheme is detected, or if the parsed scheme
// is not a registered name resolver.  The default resolver is "dns" but can be
// overridden using the resolver package's SetDefaultScheme.
//
// Examples:
//
//   - "foo.googleapis.com:8080"
//   - "dns:///foo.googleapis.com:8080"
//   - "dns:///foo.googleapis.com"
//   - "dns:///10.0.0.213:8080"
//   - "dns:///%5B2001:db8:85a3:8d3:1319:8a2e:370:7348%5D:443"
//   - "dns://8.8.8.8/foo.googleapis.com:8080"
//   - "dns://8.8.8.8/foo.googleapis.com"
//   - "zookeeper://zk.example.com:9900/example_service"
//
// The DialOptions returned by WithBlock, WithTimeout,
// WithReturnConnectionError, and FailOnNonTempDialError are ignored by this
// function.
func ( string,  ...DialOption) ( *ClientConn,  error) {
	 := &ClientConn{
		target: ,
		conns:  make(map[*addrConn]struct{}),
		dopts:  defaultDialOptions(),
	}

	.retryThrottler.Store((*retryThrottler)(nil))
	.safeConfigSelector.UpdateConfigSelector(&defaultConfigSelector{nil})
	.ctx, .cancel = context.WithCancel(context.Background())

	// Apply dial options.
	 := false
	for ,  := range  {
		if ,  := .(*disableGlobalDialOptions);  {
			 = true
			break
		}
	}

	if ! {
		for ,  := range globalDialOptions {
			.apply(&.dopts)
		}
	}

	for ,  := range  {
		.apply(&.dopts)
	}

	// Determine the resolver to use.
	if  := .initParsedTargetAndResolverBuilder();  != nil {
		return nil, 
	}

	for ,  := range globalPerTargetDialOptions {
		.DialOptionForTarget(.parsedTarget.URL).apply(&.dopts)
	}

	chainUnaryClientInterceptors()
	chainStreamClientInterceptors()

	if  := .validateTransportCredentials();  != nil {
		return nil, 
	}

	if .dopts.defaultServiceConfigRawJSON != nil {
		 := parseServiceConfig(*.dopts.defaultServiceConfigRawJSON, .dopts.maxCallAttempts)
		if .Err != nil {
			return nil, fmt.Errorf("%s: %v", invalidDefaultServiceConfigErrPrefix, .Err)
		}
		.dopts.defaultServiceConfig, _ = .Config.(*ServiceConfig)
	}
	.keepaliveParams = .dopts.copts.KeepaliveParams

	if  = .initAuthority();  != nil {
		return nil, 
	}

	// Register ClientConn with channelz. Note that this is only done after
	// channel creation cannot fail.
	.channelzRegistration()
	channelz.Infof(logger, .channelz, "parsed dial target is: %#v", .parsedTarget)
	channelz.Infof(logger, .channelz, "Channel authority set to %q", .authority)

	.csMgr = newConnectivityStateManager(.ctx, .channelz)
	.pickerWrapper = newPickerWrapper()

	.metricsRecorderList = stats.NewMetricsRecorderList(.dopts.copts.StatsHandlers)

	.initIdleStateLocked() // Safe to call without the lock, since nothing else has a reference to cc.
	.idlenessMgr = idle.NewManager((*idler)(), .dopts.idleTimeout)

	return , nil
}

// Dial calls DialContext(context.Background(), target, opts...).
//
// Deprecated: use NewClient instead.  Will be supported throughout 1.x.
func ( string,  ...DialOption) (*ClientConn, error) {
	return DialContext(context.Background(), , ...)
}

// DialContext calls NewClient and then exits idle mode.  If WithBlock(true) is
// used, it calls Connect and WaitForStateChange until either the context
// expires or the state of the ClientConn is Ready.
//
// One subtle difference between NewClient and Dial and DialContext is that the
// former uses "dns" as the default name resolver, while the latter use
// "passthrough" for backward compatibility.  This distinction should not matter
// to most users, but could matter to legacy users that specify a custom dialer
// and expect it to receive the target string directly.
//
// Deprecated: use NewClient instead.  Will be supported throughout 1.x.
func ( context.Context,  string,  ...DialOption) ( *ClientConn,  error) {
	// At the end of this method, we kick the channel out of idle, rather than
	// waiting for the first rpc.
	//
	// WithLocalDNSResolution dial option in `grpc.Dial` ensures that it
	// preserves behavior: when default scheme passthrough is used, skip
	// hostname resolution, when "dns" is used for resolution, perform
	// resolution on the client.
	 = append([]DialOption{withDefaultScheme("passthrough"), WithLocalDNSResolution()}, ...)
	,  := NewClient(, ...)
	if  != nil {
		return nil, 
	}

	// We start the channel off in idle mode, but kick it out of idle now,
	// instead of waiting for the first RPC.  This is the legacy behavior of
	// Dial.
	defer func() {
		if  != nil {
			.Close()
		}
	}()

	// This creates the name resolver, load balancer, etc.
	if  := .idlenessMgr.ExitIdleMode();  != nil {
		return nil, 
	}

	// Return now for non-blocking dials.
	if !.dopts.block {
		return , nil
	}

	if .dopts.timeout > 0 {
		var  context.CancelFunc
		,  = context.WithTimeout(, .dopts.timeout)
		defer ()
	}
	defer func() {
		select {
		case <-.Done():
			switch {
			case .Err() == :
				 = nil
			case  == nil || !.dopts.returnLastError:
				,  = nil, .Err()
			default:
				,  = nil, fmt.Errorf("%v: %v", .Err(), )
			}
		default:
		}
	}()

	// A blocking dial blocks until the clientConn is ready.
	for {
		 := .GetState()
		if  == connectivity.Idle {
			.Connect()
		}
		if  == connectivity.Ready {
			return , nil
		} else if .dopts.copts.FailOnNonTempDialError &&  == connectivity.TransientFailure {
			if  = .connectionError();  != nil {
				,  := .(interface {
					() bool
				})
				if  && !.() {
					return nil, 
				}
			}
		}
		if !.WaitForStateChange(, ) {
			// ctx got timeout or canceled.
			if  = .connectionError();  != nil && .dopts.returnLastError {
				return nil, 
			}
			return nil, .Err()
		}
	}
}

// addTraceEvent is a helper method to add a trace event on the channel. If the
// channel is a nested one, the same event is also added on the parent channel.
func ( *ClientConn) ( string) {
	 := &channelz.TraceEvent{
		Desc:     fmt.Sprintf("Channel %s", ),
		Severity: channelz.CtInfo,
	}
	if .dopts.channelzParent != nil {
		.Parent = &channelz.TraceEvent{
			Desc:     fmt.Sprintf("Nested channel(id:%d) %s", .channelz.ID, ),
			Severity: channelz.CtInfo,
		}
	}
	channelz.AddTraceEvent(logger, .channelz, 0, )
}

type idler ClientConn

func ( *idler) () {
	(*ClientConn)().enterIdleMode()
}

func ( *idler) () error {
	return (*ClientConn)().exitIdleMode()
}

// exitIdleMode moves the channel out of idle mode by recreating the name
// resolver and load balancer.  This should never be called directly; use
// cc.idlenessMgr.ExitIdleMode instead.
func ( *ClientConn) () ( error) {
	.mu.Lock()
	if .conns == nil {
		.mu.Unlock()
		return errConnClosing
	}
	.mu.Unlock()

	// This needs to be called without cc.mu because this builds a new resolver
	// which might update state or report error inline, which would then need to
	// acquire cc.mu.
	if  := .resolverWrapper.start();  != nil {
		return 
	}

	.addTraceEvent("exiting idle mode")
	return nil
}

// initIdleStateLocked initializes common state to how it should be while idle.
func ( *ClientConn) () {
	.resolverWrapper = newCCResolverWrapper()
	.balancerWrapper = newCCBalancerWrapper()
	.firstResolveEvent = grpcsync.NewEvent()
	// cc.conns == nil is a proxy for the ClientConn being closed. So, instead
	// of setting it to nil here, we recreate the map. This also means that we
	// don't have to do this when exiting idle mode.
	.conns = make(map[*addrConn]struct{})
}

// enterIdleMode puts the channel in idle mode, and as part of it shuts down the
// name resolver, load balancer, and any subchannels.  This should never be
// called directly; use cc.idlenessMgr.EnterIdleMode instead.
func ( *ClientConn) () {
	.mu.Lock()

	if .conns == nil {
		.mu.Unlock()
		return
	}

	 := .conns

	 := .resolverWrapper
	.close()
	.pickerWrapper.reset()
	 := .balancerWrapper
	.close()
	.csMgr.updateState(connectivity.Idle)
	.addTraceEvent("entering idle mode")

	.initIdleStateLocked()

	.mu.Unlock()

	// Block until the name resolver and LB policy are closed.
	<-.serializer.Done()
	<-.serializer.Done()

	// Close all subchannels after the LB policy is closed.
	for  := range  {
		.tearDown(errConnIdling)
	}
}

// validateTransportCredentials performs a series of checks on the configured
// transport credentials. It returns a non-nil error if any of these conditions
// are met:
//   - no transport creds and no creds bundle is configured
//   - both transport creds and creds bundle are configured
//   - creds bundle is configured, but it lacks a transport credentials
//   - insecure transport creds configured alongside call creds that require
//     transport level security
//
// If none of the above conditions are met, the configured credentials are
// deemed valid and a nil error is returned.
func ( *ClientConn) () error {
	if .dopts.copts.TransportCredentials == nil && .dopts.copts.CredsBundle == nil {
		return errNoTransportSecurity
	}
	if .dopts.copts.TransportCredentials != nil && .dopts.copts.CredsBundle != nil {
		return errTransportCredsAndBundle
	}
	if .dopts.copts.CredsBundle != nil && .dopts.copts.CredsBundle.TransportCredentials() == nil {
		return errNoTransportCredsInBundle
	}
	 := .dopts.copts.TransportCredentials
	if  == nil {
		 = .dopts.copts.CredsBundle.TransportCredentials()
	}
	if .Info().SecurityProtocol == "insecure" {
		for ,  := range .dopts.copts.PerRPCCredentials {
			if .RequireTransportSecurity() {
				return errTransportCredentialsMissing
			}
		}
	}
	return nil
}

// channelzRegistration registers the newly created ClientConn with channelz and
// stores the returned identifier in `cc.channelz`.  A channelz trace event is
// emitted for ClientConn creation. If the newly created ClientConn is a nested
// one, i.e a valid parent ClientConn ID is specified via a dial option, the
// trace event is also added to the parent.
//
// Doesn't grab cc.mu as this method is expected to be called only at Dial time.
func ( *ClientConn) ( string) {
	,  := .dopts.channelzParent.(*channelz.Channel)
	.channelz = channelz.RegisterChannel(, )
	.addTraceEvent("created")
}

// chainUnaryClientInterceptors chains all unary client interceptors into one.
func chainUnaryClientInterceptors( *ClientConn) {
	 := .dopts.chainUnaryInts
	// Prepend dopts.unaryInt to the chaining interceptors if it exists, since unaryInt will
	// be executed before any other chained interceptors.
	if .dopts.unaryInt != nil {
		 = append([]UnaryClientInterceptor{.dopts.unaryInt}, ...)
	}
	var  UnaryClientInterceptor
	if len() == 0 {
		 = nil
	} else if len() == 1 {
		 = [0]
	} else {
		 = func( context.Context,  string, ,  any,  *ClientConn,  UnaryInvoker,  ...CallOption) error {
			return [0](, , , , , getChainUnaryInvoker(, 0, ), ...)
		}
	}
	.dopts.unaryInt = 
}

// getChainUnaryInvoker recursively generate the chained unary invoker.
func getChainUnaryInvoker( []UnaryClientInterceptor,  int,  UnaryInvoker) UnaryInvoker {
	if  == len()-1 {
		return 
	}
	return func( context.Context,  string, ,  any,  *ClientConn,  ...CallOption) error {
		return [+1](, , , , , (, +1, ), ...)
	}
}

// chainStreamClientInterceptors chains all stream client interceptors into one.
func chainStreamClientInterceptors( *ClientConn) {
	 := .dopts.chainStreamInts
	// Prepend dopts.streamInt to the chaining interceptors if it exists, since streamInt will
	// be executed before any other chained interceptors.
	if .dopts.streamInt != nil {
		 = append([]StreamClientInterceptor{.dopts.streamInt}, ...)
	}
	var  StreamClientInterceptor
	if len() == 0 {
		 = nil
	} else if len() == 1 {
		 = [0]
	} else {
		 = func( context.Context,  *StreamDesc,  *ClientConn,  string,  Streamer,  ...CallOption) (ClientStream, error) {
			return [0](, , , , getChainStreamer(, 0, ), ...)
		}
	}
	.dopts.streamInt = 
}

// getChainStreamer recursively generate the chained client stream constructor.
func getChainStreamer( []StreamClientInterceptor,  int,  Streamer) Streamer {
	if  == len()-1 {
		return 
	}
	return func( context.Context,  *StreamDesc,  *ClientConn,  string,  ...CallOption) (ClientStream, error) {
		return [+1](, , , , (, +1, ), ...)
	}
}

// newConnectivityStateManager creates an connectivityStateManager with
// the specified channel.
func newConnectivityStateManager( context.Context,  *channelz.Channel) *connectivityStateManager {
	return &connectivityStateManager{
		channelz: ,
		pubSub:   grpcsync.NewPubSub(),
	}
}

// connectivityStateManager keeps the connectivity.State of ClientConn.
// This struct will eventually be exported so the balancers can access it.
//
// TODO: If possible, get rid of the `connectivityStateManager` type, and
// provide this functionality using the `PubSub`, to avoid keeping track of
// the connectivity state at two places.
type connectivityStateManager struct {
	mu         sync.Mutex
	state      connectivity.State
	notifyChan chan struct{}
	channelz   *channelz.Channel
	pubSub     *grpcsync.PubSub
}

// updateState updates the connectivity.State of ClientConn.
// If there's a change it notifies goroutines waiting on state change to
// happen.
func ( *connectivityStateManager) ( connectivity.State) {
	.mu.Lock()
	defer .mu.Unlock()
	if .state == connectivity.Shutdown {
		return
	}
	if .state ==  {
		return
	}
	.state = 
	.channelz.ChannelMetrics.State.Store(&)
	.pubSub.Publish()

	channelz.Infof(logger, .channelz, "Channel Connectivity change to %v", )
	if .notifyChan != nil {
		// There are other goroutines waiting on this channel.
		close(.notifyChan)
		.notifyChan = nil
	}
}

func ( *connectivityStateManager) () connectivity.State {
	.mu.Lock()
	defer .mu.Unlock()
	return .state
}

func ( *connectivityStateManager) () <-chan struct{} {
	.mu.Lock()
	defer .mu.Unlock()
	if .notifyChan == nil {
		.notifyChan = make(chan struct{})
	}
	return .notifyChan
}

// ClientConnInterface defines the functions clients need to perform unary and
// streaming RPCs.  It is implemented by *ClientConn, and is only intended to
// be referenced by generated code.
type ClientConnInterface interface {
	// Invoke performs a unary RPC and returns after the response is received
	// into reply.
	Invoke(ctx context.Context, method string, args any, reply any, opts ...CallOption) error
	// NewStream begins a streaming RPC.
	NewStream(ctx context.Context, desc *StreamDesc, method string, opts ...CallOption) (ClientStream, error)
}

// Assert *ClientConn implements ClientConnInterface.
var _ ClientConnInterface = (*ClientConn)(nil)

// ClientConn represents a virtual connection to a conceptual endpoint, to
// perform RPCs.
//
// A ClientConn is free to have zero or more actual connections to the endpoint
// based on configuration, load, etc. It is also free to determine which actual
// endpoints to use and may change it every RPC, permitting client-side load
// balancing.
//
// A ClientConn encapsulates a range of functionality including name
// resolution, TCP connection establishment (with retries and backoff) and TLS
// handshakes. It also handles errors on established connections by
// re-resolving the name and reconnecting.
type ClientConn struct {
	ctx    context.Context    // Initialized using the background context at dial time.
	cancel context.CancelFunc // Cancelled on close.

	// The following are initialized at dial time, and are read-only after that.
	target              string            // User's dial target.
	parsedTarget        resolver.Target   // See initParsedTargetAndResolverBuilder().
	authority           string            // See initAuthority().
	dopts               dialOptions       // Default and user specified dial options.
	channelz            *channelz.Channel // Channelz object.
	resolverBuilder     resolver.Builder  // See initParsedTargetAndResolverBuilder().
	idlenessMgr         *idle.Manager
	metricsRecorderList *stats.MetricsRecorderList

	// The following provide their own synchronization, and therefore don't
	// require cc.mu to be held to access them.
	csMgr              *connectivityStateManager
	pickerWrapper      *pickerWrapper
	safeConfigSelector iresolver.SafeConfigSelector
	retryThrottler     atomic.Value // Updated from service config.

	// mu protects the following fields.
	// TODO: split mu so the same mutex isn't used for everything.
	mu              sync.RWMutex
	resolverWrapper *ccResolverWrapper         // Always recreated whenever entering idle to simplify Close.
	balancerWrapper *ccBalancerWrapper         // Always recreated whenever entering idle to simplify Close.
	sc              *ServiceConfig             // Latest service config received from the resolver.
	conns           map[*addrConn]struct{}     // Set to nil on close.
	keepaliveParams keepalive.ClientParameters // May be updated upon receipt of a GoAway.
	// firstResolveEvent is used to track whether the name resolver sent us at
	// least one update. RPCs block on this event.  May be accessed without mu
	// if we know we cannot be asked to enter idle mode while accessing it (e.g.
	// when the idle manager has already been closed, or if we are already
	// entering idle mode).
	firstResolveEvent *grpcsync.Event

	lceMu               sync.Mutex // protects lastConnectionError
	lastConnectionError error
}

// WaitForStateChange waits until the connectivity.State of ClientConn changes from sourceState or
// ctx expires. A true value is returned in former case and false in latter.
func ( *ClientConn) ( context.Context,  connectivity.State) bool {
	 := .csMgr.getNotifyChan()
	if .csMgr.getState() !=  {
		return true
	}
	select {
	case <-.Done():
		return false
	case <-:
		return true
	}
}

// GetState returns the connectivity.State of ClientConn.
func ( *ClientConn) () connectivity.State {
	return .csMgr.getState()
}

// Connect causes all subchannels in the ClientConn to attempt to connect if
// the channel is idle.  Does not wait for the connection attempts to begin
// before returning.
//
// # Experimental
//
// Notice: This API is EXPERIMENTAL and may be changed or removed in a later
// release.
func ( *ClientConn) () {
	if  := .idlenessMgr.ExitIdleMode();  != nil {
		.addTraceEvent(.Error())
		return
	}
	// If the ClientConn was not in idle mode, we need to call ExitIdle on the
	// LB policy so that connections can be created.
	.mu.Lock()
	.balancerWrapper.exitIdle()
	.mu.Unlock()
}

// waitForResolvedAddrs blocks until the resolver provides addresses or the
// context expires, whichever happens first.
//
// Error is nil unless the context expires first; otherwise returns a status
// error based on the context.
//
// The returned boolean indicates whether it did block or not. If the
// resolution has already happened once before, it returns false without
// blocking. Otherwise, it wait for the resolution and return true if
// resolution has succeeded or return false along with error if resolution has
// failed.
func ( *ClientConn) ( context.Context) (bool, error) {
	// This is on the RPC path, so we use a fast path to avoid the
	// more-expensive "select" below after the resolver has returned once.
	if .firstResolveEvent.HasFired() {
		return false, nil
	}
	internal.NewStreamWaitingForResolver()
	select {
	case <-.firstResolveEvent.Done():
		return true, nil
	case <-.Done():
		return false, status.FromContextError(.Err()).Err()
	case <-.ctx.Done():
		return false, ErrClientConnClosing
	}
}

var emptyServiceConfig *ServiceConfig

func init() {
	 := parseServiceConfig("{}", defaultMaxCallAttempts)
	if .Err != nil {
		panic(fmt.Sprintf("impossible error parsing empty service config: %v", .Err))
	}
	emptyServiceConfig = .Config.(*ServiceConfig)

	internal.SubscribeToConnectivityStateChanges = func( *ClientConn,  grpcsync.Subscriber) func() {
		return .csMgr.pubSub.Subscribe()
	}
	internal.EnterIdleModeForTesting = func( *ClientConn) {
		.idlenessMgr.EnterIdleModeForTesting()
	}
	internal.ExitIdleModeForTesting = func( *ClientConn) error {
		return .idlenessMgr.ExitIdleMode()
	}
}

func ( *ClientConn) () {
	if .sc != nil {
		.applyServiceConfigAndBalancer(.sc, nil)
		return
	}
	if .dopts.defaultServiceConfig != nil {
		.applyServiceConfigAndBalancer(.dopts.defaultServiceConfig, &defaultConfigSelector{.dopts.defaultServiceConfig})
	} else {
		.applyServiceConfigAndBalancer(emptyServiceConfig, &defaultConfigSelector{emptyServiceConfig})
	}
}

func ( *ClientConn) ( resolver.State,  error) error {
	defer .firstResolveEvent.Fire()
	// Check if the ClientConn is already closed. Some fields (e.g.
	// balancerWrapper) are set to nil when closing the ClientConn, and could
	// cause nil pointer panic if we don't have this check.
	if .conns == nil {
		.mu.Unlock()
		return nil
	}

	if  != nil {
		// May need to apply the initial service config in case the resolver
		// doesn't support service configs, or doesn't provide a service config
		// with the new addresses.
		.maybeApplyDefaultServiceConfig()

		.balancerWrapper.resolverError()

		// No addresses are valid with err set; return early.
		.mu.Unlock()
		return balancer.ErrBadResolverState
	}

	var  error
	if .dopts.disableServiceConfig {
		channelz.Infof(logger, .channelz, "ignoring service config from resolver (%v) and applying the default because service config is disabled", .ServiceConfig)
		.maybeApplyDefaultServiceConfig()
	} else if .ServiceConfig == nil {
		.maybeApplyDefaultServiceConfig()
		// TODO: do we need to apply a failing LB policy if there is no
		// default, per the error handling design?
	} else {
		if ,  := .ServiceConfig.Config.(*ServiceConfig); .ServiceConfig.Err == nil &&  {
			 := iresolver.GetConfigSelector()
			if  != nil {
				if len(.ServiceConfig.Config.(*ServiceConfig).Methods) != 0 {
					channelz.Infof(logger, .channelz, "method configs in service config will be ignored due to presence of config selector")
				}
			} else {
				 = &defaultConfigSelector{}
			}
			.applyServiceConfigAndBalancer(, )
		} else {
			 = balancer.ErrBadResolverState
			if .sc == nil {
				// Apply the failing LB only if we haven't received valid service config
				// from the name resolver in the past.
				.applyFailingLBLocked(.ServiceConfig)
				.mu.Unlock()
				return 
			}
		}
	}

	 := .sc.lbConfig
	 := .balancerWrapper
	.mu.Unlock()

	 := .updateClientConnState(&balancer.ClientConnState{ResolverState: , BalancerConfig: })
	if  == nil {
		 =  // prefer ErrBadResolver state since any other error is
		// currently meaningless to the caller.
	}
	return 
}

// applyFailingLBLocked is akin to configuring an LB policy on the channel which
// always fails RPCs. Here, an actual LB policy is not configured, but an always
// erroring picker is configured, which returns errors with information about
// what was invalid in the received service config. A config selector with no
// service config is configured, and the connectivity state of the channel is
// set to TransientFailure.
func ( *ClientConn) ( *serviceconfig.ParseResult) {
	var  error
	if .Err != nil {
		 = status.Errorf(codes.Unavailable, "error parsing service config: %v", .Err)
	} else {
		 = status.Errorf(codes.Unavailable, "illegal service config type: %T", .Config)
	}
	.safeConfigSelector.UpdateConfigSelector(&defaultConfigSelector{nil})
	.pickerWrapper.updatePicker(base.NewErrPicker())
	.csMgr.updateState(connectivity.TransientFailure)
}

// Makes a copy of the input addresses slice. Addresses are passed during
// subconn creation and address update operations.
func copyAddresses( []resolver.Address) []resolver.Address {
	 := make([]resolver.Address, len())
	copy(, )
	return 
}

// newAddrConnLocked creates an addrConn for addrs and adds it to cc.conns.
//
// Caller needs to make sure len(addrs) > 0.
func ( *ClientConn) ( []resolver.Address,  balancer.NewSubConnOptions) (*addrConn, error) {
	if .conns == nil {
		return nil, ErrClientConnClosing
	}

	 := &addrConn{
		state:        connectivity.Idle,
		cc:           ,
		addrs:        copyAddresses(),
		scopts:       ,
		dopts:        .dopts,
		channelz:     channelz.RegisterSubChannel(.channelz, ""),
		resetBackoff: make(chan struct{}),
	}
	.ctx, .cancel = context.WithCancel(.ctx)
	// Start with our address set to the first address; this may be updated if
	// we connect to different addresses.
	.channelz.ChannelMetrics.Target.Store(&[0].Addr)

	channelz.AddTraceEvent(logger, .channelz, 0, &channelz.TraceEvent{
		Desc:     "Subchannel created",
		Severity: channelz.CtInfo,
		Parent: &channelz.TraceEvent{
			Desc:     fmt.Sprintf("Subchannel(id:%d) created", .channelz.ID),
			Severity: channelz.CtInfo,
		},
	})

	// Track ac in cc. This needs to be done before any getTransport(...) is called.
	.conns[] = struct{}{}
	return , nil
}

// removeAddrConn removes the addrConn in the subConn from clientConn.
// It also tears down the ac with the given error.
func ( *ClientConn) ( *addrConn,  error) {
	.mu.Lock()
	if .conns == nil {
		.mu.Unlock()
		return
	}
	delete(.conns, )
	.mu.Unlock()
	.tearDown()
}

// Target returns the target string of the ClientConn.
func ( *ClientConn) () string {
	return .target
}

// CanonicalTarget returns the canonical target string used when creating cc.
//
// This always has the form "<scheme>://[authority]/<endpoint>".  For example:
//
//   - "dns:///example.com:42"
//   - "dns://8.8.8.8/example.com:42"
//   - "unix:///path/to/socket"
func ( *ClientConn) () string {
	return .parsedTarget.String()
}

func ( *ClientConn) () {
	.channelz.ChannelMetrics.CallsStarted.Add(1)
	.channelz.ChannelMetrics.LastCallStartedTimestamp.Store(time.Now().UnixNano())
}

func ( *ClientConn) () {
	.channelz.ChannelMetrics.CallsSucceeded.Add(1)
}

func ( *ClientConn) () {
	.channelz.ChannelMetrics.CallsFailed.Add(1)
}

// connect starts creating a transport.
// It does nothing if the ac is not IDLE.
// TODO(bar) Move this to the addrConn section.
func ( *addrConn) () error {
	.mu.Lock()
	if .state == connectivity.Shutdown {
		if logger.V(2) {
			logger.Infof("connect called on shutdown addrConn; ignoring.")
		}
		.mu.Unlock()
		return errConnClosing
	}
	if .state != connectivity.Idle {
		if logger.V(2) {
			logger.Infof("connect called on addrConn in non-idle state (%v); ignoring.", .state)
		}
		.mu.Unlock()
		return nil
	}

	.resetTransportAndUnlock()
	return nil
}

// equalAddressIgnoringBalAttributes returns true is a and b are considered equal.
// This is different from the Equal method on the resolver.Address type which
// considers all fields to determine equality. Here, we only consider fields
// that are meaningful to the subConn.
func equalAddressIgnoringBalAttributes(,  *resolver.Address) bool {
	return .Addr == .Addr && .ServerName == .ServerName &&
		.Attributes.Equal(.Attributes) &&
		.Metadata == .Metadata
}

func equalAddressesIgnoringBalAttributes(,  []resolver.Address) bool {
	return slices.EqualFunc(, , func(,  resolver.Address) bool { return equalAddressIgnoringBalAttributes(&, &) })
}

// updateAddrs updates ac.addrs with the new addresses list and handles active
// connections or connection attempts.
func ( *addrConn) ( []resolver.Address) {
	 = copyAddresses()
	 := len()
	if  > 5 {
		 = 5
	}
	channelz.Infof(logger, .channelz, "addrConn: updateAddrs addrs (%d of %d): %v", , len(), [:])

	.mu.Lock()
	if equalAddressesIgnoringBalAttributes(.addrs, ) {
		.mu.Unlock()
		return
	}

	.addrs = 

	if .state == connectivity.Shutdown ||
		.state == connectivity.TransientFailure ||
		.state == connectivity.Idle {
		// We were not connecting, so do nothing but update the addresses.
		.mu.Unlock()
		return
	}

	if .state == connectivity.Ready {
		// Try to find the connected address.
		for ,  := range  {
			.ServerName = .cc.getServerName()
			if equalAddressIgnoringBalAttributes(&, &.curAddr) {
				// We are connected to a valid address, so do nothing but
				// update the addresses.
				.mu.Unlock()
				return
			}
		}
	}

	// We are either connected to the wrong address or currently connecting.
	// Stop the current iteration and restart.

	.cancel()
	.ctx, .cancel = context.WithCancel(.cc.ctx)

	// We have to defer here because GracefulClose => onClose, which requires
	// locking ac.mu.
	if .transport != nil {
		defer .transport.GracefulClose()
		.transport = nil
	}

	if len() == 0 {
		.updateConnectivityState(connectivity.Idle, nil)
	}

	// Since we were connecting/connected, we should start a new connection
	// attempt.
	go .resetTransportAndUnlock()
}

// getServerName determines the serverName to be used in the connection
// handshake. The default value for the serverName is the authority on the
// ClientConn, which either comes from the user's dial target or through an
// authority override specified using the WithAuthority dial option. Name
// resolvers can specify a per-address override for the serverName through the
// resolver.Address.ServerName field which is used only if the WithAuthority
// dial option was not used. The rationale is that per-address authority
// overrides specified by the name resolver can represent a security risk, while
// an override specified by the user is more dependable since they probably know
// what they are doing.
func ( *ClientConn) ( resolver.Address) string {
	if .dopts.authority != "" {
		return .dopts.authority
	}
	if .ServerName != "" {
		return .ServerName
	}
	return .authority
}

func getMethodConfig( *ServiceConfig,  string) MethodConfig {
	if  == nil {
		return MethodConfig{}
	}
	if ,  := .Methods[];  {
		return 
	}
	 := strings.LastIndex(, "/")
	if ,  := .Methods[[:+1]];  {
		return 
	}
	return .Methods[""]
}

// GetMethodConfig gets the method config of the input method.
// If there's an exact match for input method (i.e. /service/method), we return
// the corresponding MethodConfig.
// If there isn't an exact match for the input method, we look for the service's default
// config under the service (i.e /service/) and then for the default for all services (empty string).
//
// If there is a default MethodConfig for the service, we return it.
// Otherwise, we return an empty MethodConfig.
func ( *ClientConn) ( string) MethodConfig {
	// TODO: Avoid the locking here.
	.mu.RLock()
	defer .mu.RUnlock()
	return getMethodConfig(.sc, )
}

func ( *ClientConn) () *healthCheckConfig {
	.mu.RLock()
	defer .mu.RUnlock()
	if .sc == nil {
		return nil
	}
	return .sc.healthCheckConfig
}

func ( *ClientConn) ( *ServiceConfig,  iresolver.ConfigSelector) {
	if  == nil {
		// should never reach here.
		return
	}
	.sc = 
	if  != nil {
		.safeConfigSelector.UpdateConfigSelector()
	}

	if .sc.retryThrottling != nil {
		 := &retryThrottler{
			tokens: .sc.retryThrottling.MaxTokens,
			max:    .sc.retryThrottling.MaxTokens,
			thresh: .sc.retryThrottling.MaxTokens / 2,
			ratio:  .sc.retryThrottling.TokenRatio,
		}
		.retryThrottler.Store()
	} else {
		.retryThrottler.Store((*retryThrottler)(nil))
	}
}

func ( *ClientConn) ( resolver.ResolveNowOptions) {
	.mu.RLock()
	.resolverWrapper.resolveNow()
	.mu.RUnlock()
}

func ( *ClientConn) ( resolver.ResolveNowOptions) {
	.resolverWrapper.resolveNow()
}

// ResetConnectBackoff wakes up all subchannels in transient failure and causes
// them to attempt another connection immediately.  It also resets the backoff
// times used for subsequent attempts regardless of the current state.
//
// In general, this function should not be used.  Typical service or network
// outages result in a reasonable client reconnection strategy by default.
// However, if a previously unavailable network becomes available, this may be
// used to trigger an immediate reconnect.
//
// # Experimental
//
// Notice: This API is EXPERIMENTAL and may be changed or removed in a
// later release.
func ( *ClientConn) () {
	.mu.Lock()
	 := .conns
	.mu.Unlock()
	for  := range  {
		.resetConnectBackoff()
	}
}

// Close tears down the ClientConn and all underlying connections.
func ( *ClientConn) () error {
	defer func() {
		.cancel()
		<-.csMgr.pubSub.Done()
	}()

	// Prevent calls to enter/exit idle immediately, and ensure we are not
	// currently entering/exiting idle mode.
	.idlenessMgr.Close()

	.mu.Lock()
	if .conns == nil {
		.mu.Unlock()
		return ErrClientConnClosing
	}

	 := .conns
	.conns = nil
	.csMgr.updateState(connectivity.Shutdown)

	// We can safely unlock and continue to access all fields now as
	// cc.conns==nil, preventing any further operations on cc.
	.mu.Unlock()

	.resolverWrapper.close()
	// The order of closing matters here since the balancer wrapper assumes the
	// picker is closed before it is closed.
	.pickerWrapper.close()
	.balancerWrapper.close()

	<-.resolverWrapper.serializer.Done()
	<-.balancerWrapper.serializer.Done()
	var  sync.WaitGroup
	for  := range  {
		.Add(1)
		go func( *addrConn) {
			defer .Done()
			.tearDown(ErrClientConnClosing)
		}()
	}
	.Wait()
	.addTraceEvent("deleted")
	// TraceEvent needs to be called before RemoveEntry, as TraceEvent may add
	// trace reference to the entity being deleted, and thus prevent it from being
	// deleted right away.
	channelz.RemoveEntry(.channelz.ID)

	return nil
}

// addrConn is a network connection to a given address.
type addrConn struct {
	ctx    context.Context
	cancel context.CancelFunc

	cc     *ClientConn
	dopts  dialOptions
	acbw   *acBalancerWrapper
	scopts balancer.NewSubConnOptions

	// transport is set when there's a viable transport (note: ac state may not be READY as LB channel
	// health checking may require server to report healthy to set ac to READY), and is reset
	// to nil when the current transport should no longer be used to create a stream (e.g. after GoAway
	// is received, transport is closed, ac has been torn down).
	transport transport.ClientTransport // The current transport.

	// This mutex is used on the RPC path, so its usage should be minimized as
	// much as possible.
	// TODO: Find a lock-free way to retrieve the transport and state from the
	// addrConn.
	mu      sync.Mutex
	curAddr resolver.Address   // The current address.
	addrs   []resolver.Address // All addresses that the resolver resolved to.

	// Use updateConnectivityState for updating addrConn's connectivity state.
	state connectivity.State

	backoffIdx   int // Needs to be stateful for resetConnectBackoff.
	resetBackoff chan struct{}

	channelz *channelz.SubChannel
}

// Note: this requires a lock on ac.mu.
func ( *addrConn) ( connectivity.State,  error) {
	if .state ==  {
		return
	}
	.state = 
	.channelz.ChannelMetrics.State.Store(&)
	if  == nil {
		channelz.Infof(logger, .channelz, "Subchannel Connectivity change to %v", )
	} else {
		channelz.Infof(logger, .channelz, "Subchannel Connectivity change to %v, last error: %s", , )
	}
	.acbw.updateState(, .curAddr, )
}

// adjustParams updates parameters used to create transports upon
// receiving a GoAway.
func ( *addrConn) ( transport.GoAwayReason) {
	if  == transport.GoAwayTooManyPings {
		 := 2 * .dopts.copts.KeepaliveParams.Time
		.cc.mu.Lock()
		if  > .cc.keepaliveParams.Time {
			.cc.keepaliveParams.Time = 
		}
		.cc.mu.Unlock()
	}
}

// resetTransportAndUnlock unconditionally connects the addrConn.
//
// ac.mu must be held by the caller, and this function will guarantee it is released.
func ( *addrConn) () {
	 := .ctx
	if .Err() != nil {
		.mu.Unlock()
		return
	}

	 := .addrs
	 := .dopts.bs.Backoff(.backoffIdx)
	// This will be the duration that dial gets to finish.
	 := minConnectTimeout
	if .dopts.minConnectTimeout != nil {
		 = .dopts.minConnectTimeout()
	}

	if  <  {
		// Give dial more time as we keep failing to connect.
		 = 
	}
	// We can potentially spend all the time trying the first address, and
	// if the server accepts the connection and then hangs, the following
	// addresses will never be tried.
	//
	// The spec doesn't mention what should be done for multiple addresses.
	// https://github.com/grpc/grpc/blob/master/doc/connection-backoff.md#proposed-backoff-algorithm
	 := time.Now().Add()

	.updateConnectivityState(connectivity.Connecting, nil)
	.mu.Unlock()

	if  := .tryAllAddrs(, , );  != nil {
		// TODO: #7534 - Move re-resolution requests into the pick_first LB policy
		// to ensure one resolution request per pass instead of per subconn failure.
		.cc.resolveNow(resolver.ResolveNowOptions{})
		.mu.Lock()
		if .Err() != nil {
			// addrConn was torn down.
			.mu.Unlock()
			return
		}
		// After exhausting all addresses, the addrConn enters
		// TRANSIENT_FAILURE.
		.updateConnectivityState(connectivity.TransientFailure, )

		// Backoff.
		 := .resetBackoff
		.mu.Unlock()

		 := time.NewTimer()
		select {
		case <-.C:
			.mu.Lock()
			.backoffIdx++
			.mu.Unlock()
		case <-:
			.Stop()
		case <-.Done():
			.Stop()
			return
		}

		.mu.Lock()
		if .Err() == nil {
			.updateConnectivityState(connectivity.Idle, )
		}
		.mu.Unlock()
		return
	}
	// Success; reset backoff.
	.mu.Lock()
	.backoffIdx = 0
	.mu.Unlock()
}

// tryAllAddrs tries to create a connection to the addresses, and stop when at
// the first successful one. It returns an error if no address was successfully
// connected, or updates ac appropriately with the new transport.
func ( *addrConn) ( context.Context,  []resolver.Address,  time.Time) error {
	var  error
	for ,  := range  {
		.channelz.ChannelMetrics.Target.Store(&.Addr)
		if .Err() != nil {
			return errConnClosing
		}
		.mu.Lock()

		.cc.mu.RLock()
		.dopts.copts.KeepaliveParams = .cc.keepaliveParams
		.cc.mu.RUnlock()

		 := .dopts.copts
		if .scopts.CredsBundle != nil {
			.CredsBundle = .scopts.CredsBundle
		}
		.mu.Unlock()

		channelz.Infof(logger, .channelz, "Subchannel picks a new address %q to connect", .Addr)

		 := .createTransport(, , , )
		if  == nil {
			return nil
		}
		if  == nil {
			 = 
		}
		.cc.updateConnectionError()
	}

	// Couldn't connect to any address.
	return 
}

// createTransport creates a connection to addr. It returns an error if the
// address was not successfully connected, or updates ac appropriately with the
// new transport.
func ( *addrConn) ( context.Context,  resolver.Address,  transport.ConnectOptions,  time.Time) error {
	.ServerName = .cc.getServerName()
	,  := context.WithCancel()

	 := func( transport.GoAwayReason) {
		.mu.Lock()
		defer .mu.Unlock()
		// adjust params based on GoAwayReason
		.adjustParams()
		if .Err() != nil {
			// Already shut down or connection attempt canceled.  tearDown() or
			// updateAddrs() already cleared the transport and canceled hctx
			// via ac.ctx, and we expected this connection to be closed, so do
			// nothing here.
			return
		}
		()
		if .transport == nil {
			// We're still connecting to this address, which could error.  Do
			// not update the connectivity state or resolve; these will happen
			// at the end of the tryAllAddrs connection loop in the event of an
			// error.
			return
		}
		.transport = nil
		// Refresh the name resolver on any connection loss.
		.cc.resolveNow(resolver.ResolveNowOptions{})
		// Always go idle and wait for the LB policy to initiate a new
		// connection attempt.
		.updateConnectivityState(connectivity.Idle, nil)
	}

	,  := context.WithDeadline(, )
	defer ()
	.ChannelzParent = .channelz

	,  := transport.NewHTTP2Client(, .cc.ctx, , , )
	if  != nil {
		if logger.V(2) {
			logger.Infof("Creating new client transport to %q: %v", , )
		}
		// newTr is either nil, or closed.
		()
		channelz.Warningf(logger, .channelz, "grpc: addrConn.createTransport failed to connect to %s. Err: %v", , )
		return 
	}

	.mu.Lock()
	defer .mu.Unlock()
	if .Err() != nil {
		// This can happen if the subConn was removed while in `Connecting`
		// state. tearDown() would have set the state to `Shutdown`, but
		// would not have closed the transport since ac.transport would not
		// have been set at that point.
		//
		// We run this in a goroutine because newTr.Close() calls onClose()
		// inline, which requires locking ac.mu.
		//
		// The error we pass to Close() is immaterial since there are no open
		// streams at this point, so no trailers with error details will be sent
		// out. We just need to pass a non-nil error.
		//
		// This can also happen when updateAddrs is called during a connection
		// attempt.
		go .Close(transport.ErrConnClosing)
		return nil
	}
	if .Err() != nil {
		// onClose was already called for this connection, but the connection
		// was successfully established first.  Consider it a success and set
		// the new state to Idle.
		.updateConnectivityState(connectivity.Idle, nil)
		return nil
	}
	.curAddr = 
	.transport = 
	.startHealthCheck() // Will set state to READY if appropriate.
	return nil
}

// startHealthCheck starts the health checking stream (RPC) to watch the health
// stats of this connection if health checking is requested and configured.
//
// LB channel health checking is enabled when all requirements below are met:
// 1. it is not disabled by the user with the WithDisableHealthCheck DialOption
// 2. internal.HealthCheckFunc is set by importing the grpc/health package
// 3. a service config with non-empty healthCheckConfig field is provided
// 4. the load balancer requests it
//
// It sets addrConn to READY if the health checking stream is not started.
//
// Caller must hold ac.mu.
func ( *addrConn) ( context.Context) {
	var  bool
	defer func() {
		if ! {
			.updateConnectivityState(connectivity.Ready, nil)
		}
	}()

	if .cc.dopts.disableHealthCheck {
		return
	}
	 := .cc.healthCheckConfig()
	if  == nil {
		return
	}
	if !.scopts.HealthCheckEnabled {
		return
	}
	 := internal.HealthCheckFunc
	if  == nil {
		// The health package is not imported to set health check function.
		//
		// TODO: add a link to the health check doc in the error message.
		channelz.Error(logger, .channelz, "Health check is requested but health check function is not set.")
		return
	}

	 = true

	// Set up the health check helper functions.
	 := .transport
	 := func( string) (any, error) {
		.mu.Lock()
		if .transport !=  {
			.mu.Unlock()
			return nil, status.Error(codes.Canceled, "the provided transport is no longer valid to use")
		}
		.mu.Unlock()
		return newNonRetryClientStream(, &StreamDesc{ServerStreams: true}, , , )
	}
	 := func( connectivity.State,  error) {
		.mu.Lock()
		defer .mu.Unlock()
		if .transport !=  {
			return
		}
		.updateConnectivityState(, )
	}
	// Start the health checking stream.
	go func() {
		 := (, , , .ServiceName)
		if  != nil {
			if status.Code() == codes.Unimplemented {
				channelz.Error(logger, .channelz, "Subchannel health check is unimplemented at server side, thus health check is disabled")
			} else {
				channelz.Errorf(logger, .channelz, "Health checking failed: %v", )
			}
		}
	}()
}

func ( *addrConn) () {
	.mu.Lock()
	close(.resetBackoff)
	.backoffIdx = 0
	.resetBackoff = make(chan struct{})
	.mu.Unlock()
}

// getReadyTransport returns the transport if ac's state is READY or nil if not.
func ( *addrConn) () transport.ClientTransport {
	.mu.Lock()
	defer .mu.Unlock()
	if .state == connectivity.Ready {
		return .transport
	}
	return nil
}

// tearDown starts to tear down the addrConn.
//
// Note that tearDown doesn't remove ac from ac.cc.conns, so the addrConn struct
// will leak. In most cases, call cc.removeAddrConn() instead.
func ( *addrConn) ( error) {
	.mu.Lock()
	if .state == connectivity.Shutdown {
		.mu.Unlock()
		return
	}
	 := .transport
	.transport = nil
	// We have to set the state to Shutdown before anything else to prevent races
	// between setting the state and logic that waits on context cancellation / etc.
	.updateConnectivityState(connectivity.Shutdown, nil)
	.cancel()
	.curAddr = resolver.Address{}

	channelz.AddTraceEvent(logger, .channelz, 0, &channelz.TraceEvent{
		Desc:     "Subchannel deleted",
		Severity: channelz.CtInfo,
		Parent: &channelz.TraceEvent{
			Desc:     fmt.Sprintf("Subchannel(id:%d) deleted", .channelz.ID),
			Severity: channelz.CtInfo,
		},
	})
	// TraceEvent needs to be called before RemoveEntry, as TraceEvent may add
	// trace reference to the entity being deleted, and thus prevent it from
	// being deleted right away.
	channelz.RemoveEntry(.channelz.ID)
	.mu.Unlock()

	// We have to release the lock before the call to GracefulClose/Close here
	// because both of them call onClose(), which requires locking ac.mu.
	if  != nil {
		if  == errConnDrain {
			// Close the transport gracefully when the subConn is being shutdown.
			//
			// GracefulClose() may be executed multiple times if:
			// - multiple GoAway frames are received from the server
			// - there are concurrent name resolver or balancer triggered
			//   address removal and GoAway
			.GracefulClose()
		} else {
			// Hard close the transport when the channel is entering idle or is
			// being shutdown. In the case where the channel is being shutdown,
			// closing of transports is also taken care of by cancellation of cc.ctx.
			// But in the case where the channel is entering idle, we need to
			// explicitly close the transports here. Instead of distinguishing
			// between these two cases, it is simpler to close the transport
			// unconditionally here.
			.Close()
		}
	}
}

type retryThrottler struct {
	max    float64
	thresh float64
	ratio  float64

	mu     sync.Mutex
	tokens float64 // TODO(dfawley): replace with atomic and remove lock.
}

// throttle subtracts a retry token from the pool and returns whether a retry
// should be throttled (disallowed) based upon the retry throttling policy in
// the service config.
func ( *retryThrottler) () bool {
	if  == nil {
		return false
	}
	.mu.Lock()
	defer .mu.Unlock()
	.tokens--
	if .tokens < 0 {
		.tokens = 0
	}
	return .tokens <= .thresh
}

func ( *retryThrottler) () {
	if  == nil {
		return
	}
	.mu.Lock()
	defer .mu.Unlock()
	.tokens += .ratio
	if .tokens > .max {
		.tokens = .max
	}
}

func ( *addrConn) () {
	.channelz.ChannelMetrics.CallsStarted.Add(1)
	.channelz.ChannelMetrics.LastCallStartedTimestamp.Store(time.Now().UnixNano())
}

func ( *addrConn) () {
	.channelz.ChannelMetrics.CallsSucceeded.Add(1)
}

func ( *addrConn) () {
	.channelz.ChannelMetrics.CallsFailed.Add(1)
}

// ErrClientConnTimeout indicates that the ClientConn cannot establish the
// underlying connections within the specified timeout.
//
// Deprecated: This error is never returned by grpc and should not be
// referenced by users.
var ErrClientConnTimeout = errors.New("grpc: timed out when dialing")

// getResolver finds the scheme in the cc's resolvers or the global registry.
// scheme should always be lowercase (typically by virtue of url.Parse()
// performing proper RFC3986 behavior).
func ( *ClientConn) ( string) resolver.Builder {
	for ,  := range .dopts.resolvers {
		if  == .Scheme() {
			return 
		}
	}
	return resolver.Get()
}

func ( *ClientConn) ( error) {
	.lceMu.Lock()
	.lastConnectionError = 
	.lceMu.Unlock()
}

func ( *ClientConn) () error {
	.lceMu.Lock()
	defer .lceMu.Unlock()
	return .lastConnectionError
}

// initParsedTargetAndResolverBuilder parses the user's dial target and stores
// the parsed target in `cc.parsedTarget`.
//
// The resolver to use is determined based on the scheme in the parsed target
// and the same is stored in `cc.resolverBuilder`.
//
// Doesn't grab cc.mu as this method is expected to be called only at Dial time.
func ( *ClientConn) () error {
	logger.Infof("original dial target is: %q", .target)

	var  resolver.Builder
	,  := parseTarget(.target)
	if  == nil {
		 = .getResolver(.URL.Scheme)
		if  != nil {
			.parsedTarget = 
			.resolverBuilder = 
			return nil
		}
	}

	// We are here because the user's dial target did not contain a scheme or
	// specified an unregistered scheme. We should fallback to the default
	// scheme, except when a custom dialer is specified in which case, we should
	// always use passthrough scheme. For either case, we need to respect any overridden
	// global defaults set by the user.
	 := .dopts.defaultScheme
	if internal.UserSetDefaultScheme {
		 = resolver.GetDefaultScheme()
	}

	 :=  + ":///" + .target

	,  = parseTarget()
	if  != nil {
		return 
	}
	 = .getResolver(.URL.Scheme)
	if  == nil {
		return fmt.Errorf("could not get resolver for default scheme: %q", .URL.Scheme)
	}
	.parsedTarget = 
	.resolverBuilder = 
	return nil
}

// parseTarget uses RFC 3986 semantics to parse the given target into a
// resolver.Target struct containing url. Query params are stripped from the
// endpoint.
func parseTarget( string) (resolver.Target, error) {
	,  := url.Parse()
	if  != nil {
		return resolver.Target{}, 
	}

	return resolver.Target{URL: *}, nil
}

// encodeAuthority escapes the authority string based on valid chars defined in
// https://datatracker.ietf.org/doc/html/rfc3986#section-3.2.
func encodeAuthority( string) string {
	const  = "0123456789ABCDEF"

	// Return for characters that must be escaped as per
	// Valid chars are mentioned here:
	// https://datatracker.ietf.org/doc/html/rfc3986#section-3.2
	 := func( byte) bool {
		// Alphanum are always allowed.
		if 'a' <=  &&  <= 'z' || 'A' <=  &&  <= 'Z' || '0' <=  &&  <= '9' {
			return false
		}
		switch  {
		case '-', '_', '.', '~': // Unreserved characters
			return false
		case '!', '$', '&', '\'', '(', ')', '*', '+', ',', ';', '=': // Subdelim characters
			return false
		case ':', '[', ']', '@': // Authority related delimiters
			return false
		}
		// Everything else must be escaped.
		return true
	}

	 := 0
	for  := 0;  < len(); ++ {
		 := []
		if () {
			++
		}
	}

	if  == 0 {
		return 
	}

	 := len() + 2*
	 := make([]byte, )

	 := 0
	// This logic is a barebones version of escape in the go net/url library.
	for  := 0;  < len(); ++ {
		switch  := []; {
		case ():
			[] = '%'
			[+1] = [>>4]
			[+2] = [&15]
			 += 3
		default:
			[] = []
			++
		}
	}
	return string()
}

// Determine channel authority. The order of precedence is as follows:
// - user specified authority override using `WithAuthority` dial option
// - creds' notion of server name for the authentication handshake
// - endpoint from dial target of the form "scheme://[authority]/endpoint"
//
// Stores the determined authority in `cc.authority`.
//
// Returns a non-nil error if the authority returned by the transport
// credentials do not match the authority configured through the dial option.
//
// Doesn't grab cc.mu as this method is expected to be called only at Dial time.
func ( *ClientConn) () error {
	 := .dopts
	// Historically, we had two options for users to specify the serverName or
	// authority for a channel. One was through the transport credentials
	// (either in its constructor, or through the OverrideServerName() method).
	// The other option (for cases where WithInsecure() dial option was used)
	// was to use the WithAuthority() dial option.
	//
	// A few things have changed since:
	// - `insecure` package with an implementation of the `TransportCredentials`
	//   interface for the insecure case
	// - WithAuthority() dial option support for secure credentials
	 := ""
	if  := .copts.TransportCredentials;  != nil && .Info().ServerName != "" {
		 = .Info().ServerName
	}
	 := .authority
	if ( != "" &&  != "") &&  !=  {
		return fmt.Errorf("ClientConn's authority from transport creds %q and dial option %q don't match", , )
	}

	 := .parsedTarget.Endpoint()
	if  != "" {
		.authority = 
	} else if  != "" {
		.authority = 
	} else if ,  := .resolverBuilder.(resolver.AuthorityOverrider);  {
		.authority = .OverrideAuthority(.parsedTarget)
	} else if strings.HasPrefix(, ":") {
		.authority = "localhost" + encodeAuthority()
	} else {
		.authority = encodeAuthority()
	}
	return nil
}