var clientConnectionCounter … var metadataFromOutgoingContextRaw … type http2Client … func dial(ctx context.Context, fn func(context.Context, string) (net.Conn, error), addr resolver.Address, useProxy bool, grpcUA string) (net.Conn, error) { … } func isTemporary(err error) bool { … } // newHTTP2Client constructs a connected ClientTransport to addr based on HTTP2 // and starts to receive messages on it. Non-nil error returns if construction // fails. func newHTTP2Client(connectCtx, ctx context.Context, addr resolver.Address, opts ConnectOptions, onClose func(GoAwayReason)) (_ *http2Client, err error) { … } func (t *http2Client) newStream(ctx context.Context, callHdr *CallHdr) *Stream { … } func (t *http2Client) getPeer() *peer.Peer { … } // OutgoingGoAwayHandler writes a GOAWAY to the connection. Always returns (false, err) as we want the GoAway // to be the last frame loopy writes to the transport. func (t *http2Client) outgoingGoAwayHandler(g *goAway) (bool, error) { … } func (t *http2Client) createHeaderFields(ctx context.Context, callHdr *CallHdr) ([]hpack.HeaderField, error) { … } func (t *http2Client) createAudience(callHdr *CallHdr) string { … } func (t *http2Client) getTrAuthData(ctx context.Context, audience string) (map[string]string, error) { … } func (t *http2Client) getCallAuthData(ctx context.Context, audience string, callHdr *CallHdr) (map[string]string, error) { … } type NewStreamError … func (e NewStreamError) Error() string { … } // NewStream creates a stream and registers it into the transport as "active" // streams. All non-nil errors returned will be *NewStreamError. func (t *http2Client) NewStream(ctx context.Context, callHdr *CallHdr) (*Stream, error) { … } // CloseStream clears the footprint of a stream when the stream is not needed any more. // This must not be executed in reader's goroutine. func (t *http2Client) CloseStream(s *Stream, err error) { … } func (t *http2Client) closeStream(s *Stream, err error, rst bool, rstCode http2.ErrCode, st *status.Status, mdata map[string][]string, eosReceived bool) { … } // Close kicks off the shutdown process of the transport. This should be called // only once on a transport. Once it is called, the transport should not be // accessed anymore. func (t *http2Client) Close(err error) { … } // GracefulClose sets the state to draining, which prevents new streams from // being created and causes the transport to be closed when the last active // stream is closed. If there are no active streams, the transport is closed // immediately. This does nothing if the transport is already draining or // closing. func (t *http2Client) GracefulClose() { … } // Write formats the data into HTTP2 data frame(s) and sends it out. The caller // should proceed only if Write returns nil. func (t *http2Client) Write(s *Stream, hdr []byte, data []byte, opts *Options) error { … } func (t *http2Client) getStream(f http2.Frame) *Stream { … } // adjustWindow sends out extra window update over the initial window size // of stream if the application is requesting data larger in size than // the window. func (t *http2Client) adjustWindow(s *Stream, n uint32) { … } // updateWindow adjusts the inbound quota for the stream. // Window updates will be sent out when the cumulative quota // exceeds the corresponding threshold. func (t *http2Client) updateWindow(s *Stream, n uint32) { … } // updateFlowControl updates the incoming flow control windows // for the transport and the stream based on the current bdp // estimation. func (t *http2Client) updateFlowControl(n uint32) { … } func (t *http2Client) handleData(f *http2.DataFrame) { … } func (t *http2Client) handleRSTStream(f *http2.RSTStreamFrame) { … } func (t *http2Client) handleSettings(f *http2.SettingsFrame, isFirst bool) { … } func (t *http2Client) handlePing(f *http2.PingFrame) { … } func (t *http2Client) handleGoAway(f *http2.GoAwayFrame) { … } // setGoAwayReason sets the value of t.goAwayReason based // on the GoAway frame received. // It expects a lock on transport's mutex to be held by // the caller. func (t *http2Client) setGoAwayReason(f *http2.GoAwayFrame) { … } func (t *http2Client) GetGoAwayReason() (GoAwayReason, string) { … } func (t *http2Client) handleWindowUpdate(f *http2.WindowUpdateFrame) { … } // operateHeaders takes action on the decoded headers. func (t *http2Client) operateHeaders(frame *http2.MetaHeadersFrame) { … } // readServerPreface reads and handles the initial settings frame from the // server. func (t *http2Client) readServerPreface() error { … } // reader verifies the server preface and reads all subsequent data from // network connection. If the server preface is not read successfully, an // error is pushed to errCh; otherwise errCh is closed with no error. func (t *http2Client) reader(errCh chan<- error) { … } func minTime(a, b time.Duration) time.Duration { … } // keepalive running in a separate goroutine makes sure the connection is alive by sending pings. func (t *http2Client) keepalive() { … } func (t *http2Client) Error() <-chan struct{ … } func (t *http2Client) GoAway() <-chan struct{ … } func (t *http2Client) socketMetrics() *channelz.EphemeralSocketMetrics { … } func (t *http2Client) RemoteAddr() net.Addr { … } func (t *http2Client) IncrMsgSent() { … } func (t *http2Client) IncrMsgRecv() { … } func (t *http2Client) getOutFlowWindow() int64 { … } func (t *http2Client) stateForTesting() transportState { … }
Codebase Browser
kubernetes