Function newProxyProtoBackend

caddytest/integration/proxyprotocol_test.go:79–127

newProxyProtoBackend starts a TCP listener wrapped with go-proxyproto on a random local port and serves requests with a simple "OK" body. The PROXY header source addresses are accumulated in headerAddrs so tests can inspect them.

(t *testing.T)

// header source addresses are accumulated in headerAddrs so tests can
// inspect them.
func newProxyProtoBackend(t *testing.T) *proxyProtoBackend {
	t.Helper()

	b := &proxyProtoBackend{}

	rawLn, err := net.Listen("tcp", "127.0.0.1:0")
	if err != nil {
		t.Fatalf("backend: listen: %v", err)
	}

	// Wrap with go-proxyproto so the PROXY header is stripped and parsed
	// before the HTTP server sees the connection.  We use REQUIRE so that a
	// missing header returns an error instead of silently passing through.
	pLn := &goproxy.Listener{
		Listener: rawLn,
		Policy: func(_ net.Addr) (goproxy.Policy, error) {
			return goproxy.REQUIRE, nil
		},
	}
	b.ln = pLn

	// Wrap the handler with h2c support so the backend can speak HTTP/2
	// cleartext (h2c) as well as plain HTTP/1.1.  Without this, Caddy's
	// reverse proxy would receive a 'frame too large' error when the
	// upstream transport is configured to use h2c.
	h2Server := &http2.Server{}
	handlerFn := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		// go-proxyproto has already updated the net.Conn's remote
		// address to the value from the PROXY header; the HTTP server
		// surfaces it in r.RemoteAddr.
		b.mu.Lock()
		b.headerAddrs = append(b.headerAddrs, r.RemoteAddr)
		b.mu.Unlock()
		w.WriteHeader(http.StatusOK)
		_, _ = fmt.Fprint(w, "OK")
	})

	b.srv = &http.Server{
		Handler: h2c.NewHandler(handlerFn, h2Server),
	}

	go b.srv.Serve(pLn) //nolint:errcheck
	t.Cleanup(func() {
		_ = b.srv.Close()
		_ = rawLn.Close()
	})

	return b
}

// addr returns the listening address (host:port) of the backend.
func (b *proxyProtoBackend) addr() string {