HTTP/2 消除 HTTP 响应顺序阻塞

package main

import (
	"context"
	"crypto/tls"
	"fmt"
	"io"
	"net"
	"net/http"
	"net/http/httptest"
	"net/http/httptrace"
	"runtime"
	"sync"
	"sync/atomic"
	"time"
)

type connectionKey struct{}

func must(err error) {
	if err != nil {
		panic(err)
	}
}

func check(ok bool, message string) {
	if !ok {
		panic(message)
	}
}

func exercise(h2 bool) {
	slowEntered, releaseSlow, stop := make(chan struct{}), make(chan struct{}), make(chan struct{})
	var connections atomic.Int64
	var slowPassed atomic.Bool
	var orderMu sync.Mutex
	var order []string
	server := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.URL.Path == "/slow" {
			close(slowEntered)
			select {
			case <-releaseSlow:
				slowPassed.Store(true)
			case <-r.Context().Done():
				return
			case <-stop:
				return
			}
		}
		orderMu.Lock()
		order = append(order, r.URL.Path)
		orderMu.Unlock()
		w.Header().Set("X-Connection-ID", fmt.Sprint(r.Context().Value(connectionKey{})))
		fmt.Fprint(w, r.URL.Path)
	}))
	server.Config.ConnContext = func(ctx context.Context, _ net.Conn) context.Context {
		return context.WithValue(ctx, connectionKey{}, connections.Add(1))
	}
	server.EnableHTTP2 = h2
	server.TLS = &tls.Config{MinVersion: tls.VersionTLS13, MaxVersion: tls.VersionTLS13}
	server.StartTLS()
	defer server.Close()
	defer close(stop)
	config := server.Client().Transport.(*http.Transport).TLSClientConfig.Clone()
	check(!config.InsecureSkipVerify, "certificate verification must stay enabled")
	transport := &http.Transport{TLSClientConfig: config, ForceAttemptHTTP2: h2, MaxConnsPerHost: 1}
	defer transport.CloseIdleConnections()
	client := &http.Client{Transport: transport, Timeout: 2 * time.Second}
	protocol := "HTTP/1.1"
	if h2 {
		protocol = "HTTP/2.0"
	}
	call := func(route string, trace *httptrace.ClientTrace) string {
		request, err := http.NewRequest(http.MethodGet, server.URL+route, nil)
		must(err)
		if trace != nil {
			request = request.WithContext(httptrace.WithClientTrace(request.Context(), trace))
		}
		response, err := client.Do(request)
		must(err)
		body, readError := io.ReadAll(response.Body)
		closeError := response.Body.Close()
		must(readError)
		must(closeError)
		check(response.StatusCode == 200 && response.Proto == protocol, "wrong HTTP response or protocol")
		check(response.Header.Get("X-Connection-ID") == "1", "requests must share the first TCP connection")
		check(response.TLS.Version == tls.VersionTLS13 && len(response.TLS.VerifiedChains) > 0, "verified TLS 1.3 required")
		if h2 {
			check(response.TLS.NegotiatedProtocol == "h2", "HTTP/2 must be negotiated")
		}
		return string(body)
	}
	slowDone, fastDone := make(chan string, 1), make(chan string, 1)
	go func() { slowDone <- call("/slow", nil) }()
	<-slowEntered
	fastAttempted := make(chan struct{}, 1)
	trace := &httptrace.ClientTrace{GetConn: func(string) {
		select {
		case fastAttempted <- struct{}{}:
		default:
		}
	}}
	go func() { fastDone <- call("/fast", trace) }()
	<-fastAttempted
	wantFirst := "/slow"
	if h2 {
		check(<-fastDone == "/fast" && !slowPassed.Load(), "fast stream must finish while slow is gated")
		close(releaseSlow)
		check(<-slowDone == "/slow", "wrong slow response")
		wantFirst = "/fast"
	} else {
		close(releaseSlow)
		check(<-slowDone == "/slow" && <-fastDone == "/fast", "wrong sequential responses")
	}
	orderMu.Lock()
	defer orderMu.Unlock()
	check(len(order) == 2 && order[0] == wantFirst && order[1] != wantFirst, "wrong handler response order")
	check(connections.Load() == 1, "fixture must use exactly one TCP connection")
	fmt.Println(protocol, order, "one TCP connection")
}

func main() {
	exercise(false)
	exercise(true)
	fmt.Println("gated ordering test; no packet-loss or speedup measurement")
	fmt.Println(runtime.Version())
}