http3: remove Settingser, StreamCreator, return Connection from Hijacker (#4425)

http3/body.go

@@ -3,7 +3,6 @@ package http3
 import (
 	"context"
 	"io"
-	"net"
 
 	"github.com/quic-go/quic-go"
 )
@@ -17,33 +16,10 @@ type HTTPStreamer interface {
 	HTTPStream() Stream
 }
 
-type StreamCreator interface {
-	// Context returns a context that is cancelled when the underlying connection is closed.
-	Context() context.Context
-	OpenStream() (quic.Stream, error)
-	OpenStreamSync(context.Context) (quic.Stream, error)
-	OpenUniStream() (quic.SendStream, error)
-	OpenUniStreamSync(context.Context) (quic.SendStream, error)
-	LocalAddr() net.Addr
-	RemoteAddr() net.Addr
-	ConnectionState() quic.ConnectionState
-}
-
-var _ StreamCreator = quic.Connection(nil)
-
 // A Hijacker allows hijacking of the stream creating part of a quic.Session from a http.Response.Body.
 // It is used by WebTransport to create WebTransport streams after a session has been established.
 type Hijacker interface {
-	StreamCreator() StreamCreator
-}
-
-// Settingser allows the server to retrieve the client's SETTINGS.
-// The http.Request.Body implements this interface.
-type Settingser interface {
-	// Settings returns the client's HTTP settings.
-	// It blocks until the SETTINGS frame has been received.
-	// Note that it is not guaranteed that this happens during the lifetime of the request.
-	Settings(context.Context) (*Settings, error)
+	Connection() Connection
 }
 
 // The body is used in the requestBody (for a http.Request) and the responseBody (for a http.Response).
@@ -83,7 +59,6 @@ type requestBody struct {
 var (
 	_ io.ReadCloser = &requestBody{}
 	_ HTTPStreamer  = &requestBody{}
-	_ Settingser    = &requestBody{}
 )
 
 func newRequestBody(str Stream, connCtx context.Context, rcvdSettings <-chan struct{}, getSettings func() *Settings) *requestBody {
@@ -95,20 +70,8 @@ func newRequestBody(str Stream, connCtx context.Context, rcvdSettings <-chan str
 	}
 }
 
-func (r *requestBody) Settings(ctx context.Context) (*Settings, error) {
-	select {
-	case <-ctx.Done():
-		return nil, context.Cause(ctx)
-	case <-r.connCtx.Done():
-		return nil, context.Cause(r.connCtx)
-	case <-r.rcvdSettings:
-		return r.getSettings(), nil
-	}
-}
-
 type hijackableBody struct {
 	body body
-	conn quic.Connection // only needed to implement Hijacker
 
 	// only set for the http.Response
 	// The channel is closed when the user is done with this response:
@@ -117,16 +80,12 @@ type hijackableBody struct {
 	reqDoneClosed bool
 }
 
-var (
-	_ io.ReadCloser = &hijackableBody{}
-	_ Hijacker      = &hijackableBody{}
-)
+var _ io.ReadCloser = &hijackableBody{}
 
-func newResponseBody(str Stream, conn quic.Connection, done chan<- struct{}) *hijackableBody {
+func newResponseBody(str Stream, done chan<- struct{}) *hijackableBody {
 	return &hijackableBody{
 		body:    body{str: str},
 		reqDone: done,
-		conn:    conn,
 	}
 }
 
@@ -154,5 +113,3 @@ func (r *hijackableBody) Close() error {
 	r.body.str.CancelRead(quic.StreamErrorCode(ErrCodeRequestCanceled))
 	return nil
 }
-
-func (r *hijackableBody) StreamCreator() StreamCreator { return r.conn }

http3/body_test.go

@@ -1,7 +1,6 @@
 package http3
 
 import (
-	"context"
 	"errors"
 
 	"github.com/quic-go/quic-go"
@@ -12,29 +11,6 @@ import (
 	"go.uber.org/mock/gomock"
 )
 
-var _ = Describe("Request Body", func() {
-	It("makes the SETTINGS available", func() {
-		str := mockquic.NewMockStream(mockCtrl)
-		rcvdSettings := make(chan struct{})
-		close(rcvdSettings)
-		settings := &Settings{EnableExtendedConnect: true}
-		body := newRequestBody(str, context.Background(), rcvdSettings, func() *Settings { return settings })
-		s, err := body.Settings(context.Background())
-		Expect(err).ToNot(HaveOccurred())
-		Expect(s).To(Equal(settings))
-	})
-
-	It("unblocks Settings() when the connection is closed", func() {
-		str := mockquic.NewMockStream(mockCtrl)
-		ctx, cancel := context.WithCancelCause(context.Background())
-		testErr := errors.New("test error")
-		cancel(testErr)
-		body := newRequestBody(str, ctx, make(chan struct{}), func() *Settings { return nil })
-		_, err := body.Settings(context.Background())
-		Expect(err).To(MatchError(testErr))
-	})
-})
-
 var _ = Describe("Response Body", func() {
 	var reqDone chan struct{}
 
@@ -43,7 +19,7 @@ var _ = Describe("Response Body", func() {
 	It("closes the reqDone channel when Read errors", func() {
 		str := mockquic.NewMockStream(mockCtrl)
 		str.EXPECT().Read(gomock.Any()).Return(0, errors.New("test error"))
-		rb := newResponseBody(str, nil, reqDone)
+		rb := newResponseBody(str, reqDone)
 		_, err := rb.Read([]byte{0})
 		Expect(err).To(MatchError("test error"))
 		Expect(reqDone).To(BeClosed())
@@ -52,7 +28,7 @@ var _ = Describe("Response Body", func() {
 	It("allows multiple calls to Read, when Read errors", func() {
 		str := mockquic.NewMockStream(mockCtrl)
 		str.EXPECT().Read(gomock.Any()).Return(0, errors.New("test error")).Times(2)
-		rb := newResponseBody(str, nil, reqDone)
+		rb := newResponseBody(str, reqDone)
 		_, err := rb.Read([]byte{0})
 		Expect(err).To(HaveOccurred())
 		Expect(reqDone).To(BeClosed())
@@ -62,14 +38,14 @@ var _ = Describe("Response Body", func() {
 
 	It("closes responses", func() {
 		str := mockquic.NewMockStream(mockCtrl)
-		rb := newResponseBody(str, nil, reqDone)
+		rb := newResponseBody(str, reqDone)
 		str.EXPECT().CancelRead(quic.StreamErrorCode(ErrCodeRequestCanceled))
 		Expect(rb.Close()).To(Succeed())
 	})
 
 	It("allows multiple calls to Close", func() {
 		str := mockquic.NewMockStream(mockCtrl)
-		rb := newResponseBody(str, nil, reqDone)
+		rb := newResponseBody(str, reqDone)
 		str.EXPECT().CancelRead(quic.StreamErrorCode(ErrCodeRequestCanceled)).MaxTimes(2)
 		Expect(rb.Close()).To(Succeed())
 		Expect(reqDone).To(BeClosed())

http3/conn.go

@@ -10,6 +10,14 @@ import (
 	"github.com/quic-go/quic-go/quicvarint"
 )
 
+type Connection interface {
+	quic.Connection
+	// ReceivedSettings returns a channel that is closed once the client's SETTINGS frame was received.
+	ReceivedSettings() <-chan struct{}
+	// Settings returns the settings received on this connection.
+	Settings() *Settings
+}
+
 type connection struct {
 	quic.Connection
 

http3/http_stream.go

@@ -210,7 +210,7 @@ func (s *requestStream) ReadResponse() (*http.Response, error) {
 	} else {
 		httpStr = s.stream
 	}
-	respBody := newResponseBody(httpStr, s.conn, s.reqDone)
+	respBody := newResponseBody(httpStr, s.reqDone)
 
 	// Rules for when to set Content-Length are defined in https://tools.ietf.org/html/rfc7230#section-3.3.2.
 	_, hasTransferEncoding := res.Header["Transfer-Encoding"]

http3/response_writer.go

@@ -63,7 +63,7 @@ func (hw *headerWriter) Write(p []byte) (int, error) {
 
 type responseWriter struct {
 	*headerWriter
-	conn        quic.Connection
+	conn        Connection
 	bufferedStr *bufio.Writer
 	buf         []byte
 
@@ -79,7 +79,7 @@ var (
 	_ Hijacker            = &responseWriter{}
 )
 
-func newResponseWriter(str quic.Stream, conn quic.Connection, logger utils.Logger) *responseWriter {
+func newResponseWriter(str quic.Stream, conn Connection, logger utils.Logger) *responseWriter {
 	hw := &headerWriter{
 		str:    str,
 		header: http.Header{},
@@ -196,7 +196,7 @@ func (w *responseWriter) Flush() {
 	}
 }
 
-func (w *responseWriter) StreamCreator() StreamCreator {
+func (w *responseWriter) Connection() Connection {
 	return w.conn
 }
 

integrationtests/self/http_test.go

@@ -590,13 +590,13 @@ var _ = Describe("HTTP tests", func() {
 		settingsChan := make(chan *http3.Settings, 1)
 		mux.HandleFunc("/settings", func(w http.ResponseWriter, r *http.Request) {
 			defer GinkgoRecover()
-			// The http.Request.Body is guaranteed to implement the http3.Settingser interface.
-			settings, err := r.Body.(http3.Settingser).Settings(context.Background())
-			if err != nil {
-				w.WriteHeader(http.StatusInternalServerError)
-				return
+			conn := w.(http3.Hijacker).Connection()
+			select {
+			case <-conn.ReceivedSettings():
+			case <-time.After(5 * time.Second):
+				Fail("didn't receive SETTINGS")
 			}
-			settingsChan <- settings
+			settingsChan <- conn.Settings()
 			w.WriteHeader(http.StatusOK)
 		})
 
@@ -615,7 +615,8 @@ var _ = Describe("HTTP tests", func() {
 		_, err = rt.RoundTrip(req)
 		Expect(err).ToNot(HaveOccurred())
 		var settings *http3.Settings
-		Eventually(settingsChan).Should(Receive(&settings))
+		Expect(settingsChan).To(Receive(&settings))
+		Expect(settings).ToNot(BeNil())
 		Expect(settings.EnableDatagram).To(BeTrue())
 		Expect(settings.EnableExtendedConnect).To(BeFalse())
 		Expect(settings.Other).To(HaveKeyWithValue(uint64(1337), uint64(42)))