http2: add wrapped Server

Implement Server in terms of net/http.

For #78508

Change-Id: Iad2b592b8c4f32d66126eb52d8881e8e6a6a6964
Reviewed-on: https://go-review.googlesource.com/c/net/+/771220
Reviewed-by: Nicholas Husin <nsh@golang.org>
Auto-Submit: Damien Neil <dneil@google.com>
LUCI-TryBot-Result: golang-scoped@luci-project-accounts.iam.gserviceaccount.com <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Nicholas Husin <husin@google.com>

Author: neild

http2/export_common_test.go

@@ -11,6 +11,10 @@ const (
 	InitialWindowSize      = initialWindowSize
 )
 
+type (
+	ServerConn = serverConn
+)
+
 func SummarizeFrame(f Frame) string {
 	return summarizeFrame(f)
 }

http2/export_test.go

@@ -30,7 +30,6 @@ const (
 )
 
 type (
-	ServerConn  = serverConn
 	Stream      = stream
 	StreamState = streamState
 

http2/export_wrap_test.go

@@ -16,5 +16,3 @@ func (t *Transport) TestTransport() *http.Transport {
 func (s *Server) TestSetNewConnFunc(f func(*ServerConn)) {
 	panic("ServerConns are not available with http2wrap")
 }
-
-type ServerConn struct{}

http2/server_common_test.go

@@ -122,9 +122,10 @@ func newServerTester(t testing.TB, handler http.HandlerFunc, opts ...interface{}
 	h1server := &http.Server{}
 	h2server := &Server{}
 	tlsState := tls.ConnectionState{
-		Version:     tls.VersionTLS13,
-		ServerName:  "go.dev",
-		CipherSuite: tls.TLS_AES_128_GCM_SHA256,
+		Version:            tls.VersionTLS13,
+		ServerName:         "go.dev",
+		CipherSuite:        tls.TLS_AES_128_GCM_SHA256,
+		NegotiatedProtocol: "h2",
 	}
 	noConn := false
 	for _, opt := range opts {
@@ -151,6 +152,10 @@ func newServerTester(t testing.TB, handler http.HandlerFunc, opts ...interface{}
 	cli, srv := synctestNetPipe()
 	cli.SetReadDeadline(time.Now())
 	cli.autoWait = true
+	t.Cleanup(func() {
+		cli.Close()
+		srv.Close()
+	})
 
 	st := &serverTester{
 		t:        t,

http2/server_test.go

@@ -169,10 +169,16 @@ func newServerTesterWithRealConn(t testing.TB, handler http.HandlerFunc, opts ..
 }
 
 func (st *serverTester) streamExists(id uint32) bool {
+	if st.sc == nil {
+		st.t.Fatalf("serverTester has no ServerConn")
+	}
 	return st.sc.TestStreamExists(id)
 }
 
 func (st *serverTester) streamState(id uint32) StreamState {
+	if st.sc == nil {
+		st.t.Fatalf("serverTester has no ServerConn")
+	}
 	return st.sc.TestStreamState(id)
 }
 

http2/server_wrap.go

@@ -9,20 +9,146 @@
 package http2
 
 import (
+	"context"
 	"errors"
 	"net"
 	"net/http"
+	"sync"
+	"time"
 )
 
 type serverInternalState struct {
+	s1            *http.Server
+	initOnce      sync.Once
+	serveConnFunc func(context.Context, net.Conn, http.Handler, bool, *http.Request, []byte)
 }
 
 func configureServer(s *http.Server, conf *Server) error {
-	return errors.New("TODO")
+	if s == nil {
+		panic("nil *http.Server")
+	}
+	if conf == nil {
+		conf = new(Server)
+	}
+	if conf.state != nil {
+		// This isn't a panic in the pre-wrapping implementation,
+		// but calling ConfigureServer twice with the same http2.Server
+		// overwrites internal state on the server.
+		// Make the error explicit and early here.
+		panic("ConfigureServer may be called only once per Server")
+	}
+	if h1, h2 := s, conf; h2.IdleTimeout == 0 {
+		if h1.IdleTimeout != 0 {
+			h2.IdleTimeout = h1.IdleTimeout
+		} else {
+			h2.IdleTimeout = h1.ReadTimeout
+		}
+	}
+	conf.state = &serverInternalState{
+		s1: s,
+	}
+	sconfig := &serverConfig{s: conf}
+	if err := s.Serve(sconfig); err != nil || sconfig.serveConnFunc == nil {
+		panic("http2: net/http does not support this version of x/net/http2")
+	}
+	conf.state.serveConnFunc = sconfig.serveConnFunc
+	return nil
 }
 
-func (s *Server) serveConn(c net.Conn, opts *ServeConnOpts, newf func(*ServerConn)) {
-	c.Close() // TODO
+type serverConfig struct {
+	s             *Server
+	serveConnFunc func(context.Context, net.Conn, http.Handler, bool, *http.Request, []byte)
+}
+
+func (*serverConfig) Accept() (net.Conn, error) {
+	return nil, errors.New("unexpected call to Accept")
+}
+func (*serverConfig) Close() error {
+	return nil
+}
+func (*serverConfig) Addr() net.Addr {
+	return nil
+}
+
+func (s *serverConfig) ServeConnFunc(f func(context.Context, net.Conn, http.Handler, bool, *http.Request, []byte)) {
+	s.serveConnFunc = f
+}
+
+func (s *serverConfig) HTTP2Config() http.HTTP2Config {
+	return http.HTTP2Config{
+		MaxConcurrentStreams:          int(s.s.MaxConcurrentStreams),
+		MaxDecoderHeaderTableSize:     int(s.s.MaxDecoderHeaderTableSize),
+		MaxEncoderHeaderTableSize:     int(s.s.MaxEncoderHeaderTableSize),
+		MaxReadFrameSize:              int(s.s.MaxReadFrameSize),
+		PermitProhibitedCipherSuites:  s.s.PermitProhibitedCipherSuites,
+		MaxReceiveBufferPerConnection: int(s.s.MaxUploadBufferPerConnection),
+		MaxReceiveBufferPerStream:     int(s.s.MaxUploadBufferPerStream),
+		SendPingTimeout:               s.s.ReadIdleTimeout,
+		PingTimeout:                   s.s.PingTimeout,
+		WriteByteTimeout:              s.s.WriteByteTimeout,
+		CountError:                    s.s.CountError,
+	}
+}
+
+func (s *serverConfig) IdleTimeout() time.Duration {
+	return s.s.IdleTimeout
+}
+
+type serverConn struct{}
+
+func (s *Server) serveConn(c net.Conn, opts *ServeConnOpts, _ func(*serverConn)) {
+	var serveConnFunc func(context.Context, net.Conn, http.Handler, bool, *http.Request, []byte)
+	switch {
+	case opts.BaseConfig != nil:
+		// The user has provided us with an http.Server to take configuration from.
+		//
+		// We can't send our request to opts.BaseConfig, because an http.Server can
+		// only be associated with a single http2.Server and the user might
+		// use this one with several http.Servers.
+		//
+		// We can't send our request to s.state.s1, because it doesn't contain
+		// the right configuration.
+		//
+		// So create a one-off copy of opts.BaseConfig and use it.
+		h1 := &http.Server{
+			TLSConfig:         opts.BaseConfig.TLSConfig,
+			ReadTimeout:       opts.BaseConfig.ReadTimeout,
+			ReadHeaderTimeout: opts.BaseConfig.ReadHeaderTimeout,
+			WriteTimeout:      opts.BaseConfig.WriteTimeout,
+			IdleTimeout:       opts.BaseConfig.IdleTimeout,
+			MaxHeaderBytes:    opts.BaseConfig.MaxHeaderBytes,
+			ConnState:         opts.BaseConfig.ConnState,
+			ErrorLog:          opts.BaseConfig.ErrorLog,
+			BaseContext:       opts.BaseConfig.BaseContext,
+			ConnContext:       opts.BaseConfig.ConnContext,
+			HTTP2:             opts.BaseConfig.HTTP2,
+		}
+		sconfig := &serverConfig{s: s}
+		if err := h1.Serve(sconfig); err != nil || sconfig.serveConnFunc == nil {
+			panic("http2: net/http does not support this version of x/net/http2")
+		}
+		serveConnFunc = sconfig.serveConnFunc
+	case s.state != nil:
+		serveConnFunc = s.state.serveConnFunc
+	default:
+		// Strange-but-true: Server has no concurrency-safe way to initialize
+		// its internal state, so historically ServeConn just doesn't use any
+		// persistent state if you don't call ConfigureServer first.
+		//
+		// If ConfigureServer hasn't been called, create a one-off http.Server
+		// for the connection, since we don't have any way to keep one around for reuse.
+		h1 := &http.Server{}
+		sconfig := &serverConfig{s: s}
+		if err := h1.Serve(sconfig); err != nil || sconfig.serveConnFunc == nil {
+			panic("http2: net/http does not support this version of x/net/http2")
+		}
+		serveConnFunc = sconfig.serveConnFunc
+	}
+
+	ctx, cancel := serverConnBaseContext(c, opts)
+	defer cancel()
+	serveConnFunc(ctx, c, opts.handler(), opts.SawClientPreface, opts.UpgradeRequest, opts.Settings)
+
 }
 
 // FrameWriteRequest is a request to write a frame.