const minConnectTimeout … var ErrClientConnClosing … var errConnDrain … var errConnClosing … var errConnIdling … var invalidDefaultServiceConfigErrPrefix … var PickFirstBalancerName … var errNoTransportSecurity … var errTransportCredsAndBundle … var errNoTransportCredsInBundle … var errTransportCredentialsMissing … const defaultClientMaxReceiveMessageSize … const defaultClientMaxSendMessageSize … const defaultWriteBufSize … const defaultReadBufSize … type defaultConfigSelector … func (dcs *defaultConfigSelector) SelectConfig(rpcInfo iresolver.RPCInfo) (*iresolver.RPCConfig, error) { … } // 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. Connect may be used to manually create a connection, but for most // users this is unnecessary. // // The target name syntax is defined in // https://github.com/grpc/grpc/blob/master/doc/naming.md. e.g. to use dns // resolver, a "dns:///" prefix should be applied to the target. // // The DialOptions returned by WithBlock, WithTimeout, // WithReturnConnectionError, and FailOnNonTempDialError are ignored by this // function. func NewClient(target string, opts ...DialOption) (conn *ClientConn, err error) { … } // Dial calls DialContext(context.Background(), target, opts...). // // Deprecated: use NewClient instead. Will be supported throughout 1.x. func Dial(target string, opts ...DialOption) (*ClientConn, error) { … } // 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 DialContext(ctx context.Context, target string, opts ...DialOption) (conn *ClientConn, err error) { … } // 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 (cc *ClientConn) addTraceEvent(msg string) { … } type idler … func (i *idler) EnterIdleMode() { … } func (i *idler) ExitIdleMode() error { … } // 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 (cc *ClientConn) exitIdleMode() (err error) { … } // initIdleStateLocked initializes common state to how it should be while idle. func (cc *ClientConn) initIdleStateLocked() { … } // 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 (cc *ClientConn) enterIdleMode() { … } // 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 (cc *ClientConn) validateTransportCredentials() error { … } // 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 (cc *ClientConn) channelzRegistration(target string) { … } // chainUnaryClientInterceptors chains all unary client interceptors into one. func chainUnaryClientInterceptors(cc *ClientConn) { … } // getChainUnaryInvoker recursively generate the chained unary invoker. func getChainUnaryInvoker(interceptors []UnaryClientInterceptor, curr int, finalInvoker UnaryInvoker) UnaryInvoker { … } // chainStreamClientInterceptors chains all stream client interceptors into one. func chainStreamClientInterceptors(cc *ClientConn) { … } // getChainStreamer recursively generate the chained client stream constructor. func getChainStreamer(interceptors []StreamClientInterceptor, curr int, finalStreamer Streamer) Streamer { … } // newConnectivityStateManager creates an connectivityStateManager with // the specified channel. func newConnectivityStateManager(ctx context.Context, channel *channelz.Channel) *connectivityStateManager { … } type connectivityStateManager … // updateState updates the connectivity.State of ClientConn. // If there's a change it notifies goroutines waiting on state change to // happen. func (csm *connectivityStateManager) updateState(state connectivity.State) { … } func (csm *connectivityStateManager) getState() connectivity.State { … } func (csm *connectivityStateManager) getNotifyChan() <-chan struct{ … } type ClientConnInterface … var _ … type ClientConn … // 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. // // # Experimental // // Notice: This API is EXPERIMENTAL and may be changed or removed in a // later release. func (cc *ClientConn) WaitForStateChange(ctx context.Context, sourceState connectivity.State) bool { … } // GetState returns the connectivity.State of ClientConn. // // # Experimental // // Notice: This API is EXPERIMENTAL and may be changed or removed in a later // release. func (cc *ClientConn) GetState() connectivity.State { … } // 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 (cc *ClientConn) Connect() { … } // waitForResolvedAddrs blocks until the resolver has provided addresses or the // context expires. Returns nil unless the context expires first; otherwise // returns a status error based on the context. func (cc *ClientConn) waitForResolvedAddrs(ctx context.Context) error { … } var emptyServiceConfig … func init() { … } func (cc *ClientConn) maybeApplyDefaultServiceConfig() { … } func (cc *ClientConn) updateResolverStateAndUnlock(s resolver.State, err error) error { … } // 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 (cc *ClientConn) applyFailingLBLocked(sc *serviceconfig.ParseResult) { … } // Makes a copy of the input addresses slice and clears out the balancer // attributes field. Addresses are passed during subconn creation and address // update operations. In both cases, we will clear the balancer attributes by // calling this function, and therefore we will be able to use the Equal method // provided by the resolver.Address type for comparison. func copyAddressesWithoutBalancerAttributes(in []resolver.Address) []resolver.Address { … } // newAddrConnLocked creates an addrConn for addrs and adds it to cc.conns. // // Caller needs to make sure len(addrs) > 0. func (cc *ClientConn) newAddrConnLocked(addrs []resolver.Address, opts balancer.NewSubConnOptions) (*addrConn, error) { … } // removeAddrConn removes the addrConn in the subConn from clientConn. // It also tears down the ac with the given error. func (cc *ClientConn) removeAddrConn(ac *addrConn, err error) { … } // Target returns the target string of the ClientConn. func (cc *ClientConn) Target() string { … } // CanonicalTarget returns the canonical target string of the ClientConn. func (cc *ClientConn) CanonicalTarget() string { … } func (cc *ClientConn) incrCallsStarted() { … } func (cc *ClientConn) incrCallsSucceeded() { … } func (cc *ClientConn) incrCallsFailed() { … } // connect starts creating a transport. // It does nothing if the ac is not IDLE. // TODO(bar) Move this to the addrConn section. func (ac *addrConn) connect() error { … } func equalAddresses(a, b []resolver.Address) bool { … } // updateAddrs updates ac.addrs with the new addresses list and handles active // connections or connection attempts. func (ac *addrConn) updateAddrs(addrs []resolver.Address) { … } // 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 (cc *ClientConn) getServerName(addr resolver.Address) string { … } func getMethodConfig(sc *ServiceConfig, method string) MethodConfig { … } // 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 (cc *ClientConn) GetMethodConfig(method string) MethodConfig { … } func (cc *ClientConn) healthCheckConfig() *healthCheckConfig { … } func (cc *ClientConn) getTransport(ctx context.Context, failfast bool, method string) (transport.ClientTransport, balancer.PickResult, error) { … } func (cc *ClientConn) applyServiceConfigAndBalancer(sc *ServiceConfig, configSelector iresolver.ConfigSelector) { … } func (cc *ClientConn) resolveNow(o resolver.ResolveNowOptions) { … } func (cc *ClientConn) resolveNowLocked(o resolver.ResolveNowOptions) { … } // 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 (cc *ClientConn) ResetConnectBackoff() { … } // Close tears down the ClientConn and all underlying connections. func (cc *ClientConn) Close() error { … } type addrConn … // Note: this requires a lock on ac.mu. func (ac *addrConn) updateConnectivityState(s connectivity.State, lastErr error) { … } // adjustParams updates parameters used to create transports upon // receiving a GoAway. func (ac *addrConn) adjustParams(r transport.GoAwayReason) { … } func (ac *addrConn) resetTransport() { … } // tryAllAddrs tries to creates 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 (ac *addrConn) tryAllAddrs(ctx context.Context, addrs []resolver.Address, connectDeadline time.Time) error { … } // 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 (ac *addrConn) createTransport(ctx context.Context, addr resolver.Address, copts transport.ConnectOptions, connectDeadline time.Time) error { … } // 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 (ac *addrConn) startHealthCheck(ctx context.Context) { … } func (ac *addrConn) resetConnectBackoff() { … } // getReadyTransport returns the transport if ac's state is READY or nil if not. func (ac *addrConn) getReadyTransport() transport.ClientTransport { … } // getTransport waits until the addrconn is ready and returns the transport. // If the context expires first, returns an appropriate status. If the // addrConn is stopped first, returns an Unavailable status error. func (ac *addrConn) getTransport(ctx context.Context) (transport.ClientTransport, error) { … } // 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 (ac *addrConn) tearDown(err error) { … } type retryThrottler … // 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 (rt *retryThrottler) throttle() bool { … } func (rt *retryThrottler) successfulRPC() { … } func (ac *addrConn) incrCallsStarted() { … } func (ac *addrConn) incrCallsSucceeded() { … } func (ac *addrConn) incrCallsFailed() { … } var ErrClientConnTimeout … // 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 (cc *ClientConn) getResolver(scheme string) resolver.Builder { … } func (cc *ClientConn) updateConnectionError(err error) { … } func (cc *ClientConn) connectionError() error { … } // 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 (cc *ClientConn) initParsedTargetAndResolverBuilder() error { … } // 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(target string) (resolver.Target, error) { … } // encodeAuthority escapes the authority string based on valid chars defined in // https://datatracker.ietf.org/doc/html/rfc3986#section-3.2. func encodeAuthority(authority string) 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 (cc *ClientConn) initAuthority() error { … }
Codebase Browser
kubernetes