Function newFrontedClient

internal/carrier/fronting.go:349–407

newFrontedClient builds a single *http.Client that dials googleIP and presents sniHost in the TLS handshake.

(googleIP, sniHost string, pollTimeout time.Duration, sessionCache tls.ClientSessionCache)

// newFrontedClient builds a single *http.Client that dials googleIP and
// presents sniHost in the TLS handshake.
func newFrontedClient(googleIP, sniHost string, pollTimeout time.Duration, sessionCache tls.ClientSessionCache) *http.Client {
	dialer := &net.Dialer{Timeout: 30 * time.Second, KeepAlive: 30 * time.Second}

	transport := &http.Transport{
		DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
			if googleIP != "" {
				return dialer.DialContext(ctx, "tcp", googleIP)
			}
			return dialer.DialContext(ctx, network, addr)
		},
		TLSClientConfig: &tls.Config{
			ServerName: sniHost,
			// Pin TLS 1.3 floor to prevent downgrade; Go's default minimum is 1.2.
			MinVersion: tls.VersionTLS13,
			// Enable TLS session resumption tickets so reconnects after
			// idle timeout (and the prewarm dial in NewFrontedClients) can
			// skip a full handshake round-trip.
			ClientSessionCache: sessionCache,
			// Pin ALPN so the resumed session matches the prewarm dial.
			// (The TLS 1.3 resumption ticket is bound to ALPN; mismatched
			// NextProtos causes the server to fall back to a full handshake.)
			NextProtos: []string{"h2", "http/1.1"},
		},
		ForceAttemptHTTP2: true,
		MaxIdleConns:      16,
		// Default MaxIdleConnsPerHost is 2, which forces idle h1 conns to be
		// recycled between poll workers when ALPN downgrades or the server
		// closes h2 streams. Pin it to roughly the worker count per endpoint
		// so each worker can keep its own warm conn.
		MaxIdleConnsPerHost: workersPerEndpoint * 2,
		// Larger HTTP read/write buffers cut syscall count on bulk batch
		// bodies (server can return up to ~12 MB per poll under busy
		// fan-out: 144 frames × 256 KB max payload, base64-expanded).
		WriteBufferSize:       64 * 1024,
		ReadBufferSize:        64 * 1024,
		IdleConnTimeout:       90 * time.Second,
		TLSHandshakeTimeout:   15 * time.Second,
		ExpectContinueTimeout: 1 * time.Second,
	}

	// Configure HTTP/2 so the long-lived h2 connection sends pings and detects
	// black-holed peers quickly. Without ReadIdleTimeout, a dead h2 conn can
	// linger until the kernel's TCP keepalive fires (~2 hours by default),
	// leaking poll worker time as in-flight requests stall.
	if h2t, err := http2.ConfigureTransports(transport); err == nil && h2t != nil {
		h2t.ReadIdleTimeout = 30 * time.Second
		h2t.PingTimeout = 15 * time.Second
		// Raise the max DATA frame size we are willing to receive from 16 KiB
		// (spec default) to 1 MiB. Each DATA frame carries a 9-byte header,
		// so on a long bulk download (Apps Script gateway streaming a video
		// chunk back) the framing overhead drops by ~64× and the receiver
		// makes ~64× fewer Read syscalls per MiB. Stream/conn flow control
		// windows in golang.org/x/net/http2 already default to 4 MiB / 1 GiB,
		// so the actual throughput cap is RTT-bound, not window-bound.
		h2t.MaxReadFrameSize = 1 << 20
	}

	return &http.Client{Transport: transport, Timeout: pollTimeout}