feat(courierhttp/client): h2c supported

Author: morlay

example/cmd/example/main_test.go

@@ -3,127 +3,93 @@ package main_test
 import (
 	"bytes"
 	"context"
-	"crypto/tls"
 	"fmt"
 	"io"
-	"net"
 	"net/http"
+	"net/http/httptest"
+	"net/http/httputil"
 	"testing"
-	"time"
 
 	"github.com/go-courier/logr"
 	"github.com/go-courier/logr/slog"
 	"github.com/octohelm/courier/example/apis"
 	"github.com/octohelm/courier/example/client/example"
 	domainorg "github.com/octohelm/courier/example/pkg/domain/org"
 	"github.com/octohelm/courier/internal/testingutil"
-	"github.com/octohelm/courier/pkg/courierhttp/client"
 	"github.com/octohelm/courier/pkg/courierhttp/handler/httprouter"
 	testingx "github.com/octohelm/x/testing"
-	"golang.org/x/net/http2"
+	"github.com/octohelm/x/testing/bdd"
 )
 
-var htLogger = client.HttpTransportFunc(func(req *http.Request, next client.RoundTrip) (*http.Response, error) {
-	startedAt := time.Now()
-
-	ctx, logger := logr.Start(req.Context(), "Request")
-	defer logger.End()
-
-	resp, err := next(req.WithContext(ctx))
-
-	defer func() {
-		cost := time.Since(startedAt)
-
-		logger := logger.WithValues(
-			"cost", fmt.Sprintf("%0.3fms", float64(cost/time.Millisecond)),
-			"method", req.Method,
-			"url", req.URL.String(),
-			"metadata", req.Header,
-			"http.content-length", req.ContentLength,
-		)
-
-		if err == nil {
-			logger.WithValues("response.proto", resp.Proto).Info("success")
-		} else {
-			logger.Warn(fmt.Errorf("http request failed: %w", err))
-		}
-	}()
-
-	return resp, err
-})
-
 func TestAll(t *testing.T) {
-	h, err := httprouter.New(apis.R, "example")
-	testingx.Expect(t, err, testingx.BeNil[error]())
+	h := bdd.Must(httprouter.New(apis.R, "example"))
 
-	srv := testingutil.Serve(t, h)
+	hh := http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
+		raw, _ := httputil.DumpRequest(request, true)
+		fmt.Println(string(raw))
 
-	c := &example.Client{
-		Endpoint:       srv.URL,
-		HttpTransports: []client.HttpTransport{htLogger},
-	}
-	ctx := c.InjectContext(context.Background())
-	ctx = logr.WithLogger(ctx, slog.Logger(slog.Default()))
+		h.ServeHTTP(writer, request)
+	})
 
-	t.Run("Do Some Request", func(t *testing.T) {
-		org := &example.GetOrg{}
-		org.OrgName = "test"
+	for i, srv := range []*httptest.Server{
+		testingutil.ServeWithH2C(t, hh),
+		testingutil.Serve(t, hh),
+	} {
+		t.Run(fmt.Sprintf("serve http/%d", 2-i), func(t *testing.T) {
+			c := &example.Client{
+				Endpoint:   srv.URL,
+				SupportH2C: i == 0,
+			}
 
-		resp, err := example.Do(ctx, org)
-		testingx.Expect(t, err, testingx.BeNil[error]())
-		testingx.Expect(t, resp.Name, testingx.Be(org.OrgName))
-		testingx.Expect(t, resp.Type, testingx.Be(domainorg.TYPE__GOV))
-	})
+			ctx := c.InjectContext(context.Background())
+			ctx = logr.WithLogger(ctx, slog.Logger(slog.Default()))
 
-	t.Run("Do Some Request with h2", func(t *testing.T) {
-		org := &example.GetOrg{}
-		org.OrgName = "test"
+			t.Run("Do Some Request", func(t *testing.T) {
+				org := &example.GetOrg{}
+				org.OrgName = "test"
 
-		resp, err := example.Do(client.ContextWithRoundTripperCreator(ctx, func() http.RoundTripper {
-			return &http2.Transport{
-				AllowHTTP: true,
-				DialTLSContext: func(ctx context.Context, network, addr string, cfg *tls.Config) (net.Conn, error) {
-					return net.Dial(network, addr)
-				},
-			}
-		}), org)
-		testingx.Expect(t, err, testingx.BeNil[error]())
-		testingx.Expect(t, resp.Name, testingx.Be(org.OrgName))
-	})
+				resp, err := example.Do(ctx, org)
+				testingx.Expect(t, err, testingx.BeNil[error]())
 
-	t.Run("Upload", func(t *testing.T) {
-		v := &example.UploadBlob{}
-		v.RequestBody = io.NopCloser(bytes.NewBufferString("1234567"))
+				testingx.Expect(t, resp.Name, testingx.Be(org.OrgName))
+				testingx.Expect(t, resp.Type, testingx.Be(domainorg.TYPE__GOV))
+			})
 
-		_, err := example.Do(ctx, v)
-		testingx.Expect(t, err, testingx.BeNil[error]())
-	})
+			t.Run("Upload", func(t *testing.T) {
+				v := &example.UploadBlob{}
+				v.RequestBody = io.NopCloser(bytes.NewBufferString("1234567"))
 
-	t.Run("UploadStoreBlob", func(t *testing.T) {
-		v := &example.UploadStoreBlob{}
-		v.Scope = "a/b/c"
-		v.RequestBody = io.NopCloser(bytes.NewBufferString("1234567"))
+				_, err := example.Do(ctx, v)
+				testingx.Expect(t, err, testingx.BeNil[error]())
+			})
 
-		_, err := example.Do(ctx, v)
-		testingx.Expect(t, err, testingx.BeNil[error]())
-	})
+			t.Run("UploadStoreBlob", func(t *testing.T) {
+				v := &example.UploadStoreBlob{}
+				v.Scope = "a/b/c"
+				v.RequestBody = io.NopCloser(bytes.NewBufferString("1234567"))
 
-	t.Run("GetStoreBlob", func(t *testing.T) {
-		v := &example.GetStoreBlob{}
-		v.Scope = "a/b/c"
-		v.Digest = "xxx"
+				_, err := example.Do(ctx, v)
+				testingx.Expect(t, err, testingx.BeNil[error]())
+			})
 
-		resp, err := example.Do(ctx, v)
-		testingx.Expect(t, err, testingx.BeNil[error]())
-		testingx.Expect(t, *resp, testingx.Be("a/b/c@xxx"))
-	})
+			t.Run("GetStoreBlob", func(t *testing.T) {
+				v := &example.GetStoreBlob{}
+				v.Scope = "a/b/c"
+				v.Digest = "xxx"
 
-	t.Run("GetFile", func(t *testing.T) {
-		v := &example.GetFile{}
-		v.Path = "a/b/c"
+				resp, err := example.Do(ctx, v)
+				testingx.Expect(t, err, testingx.BeNil[error]())
+				testingx.Expect(t, *resp, testingx.Be("a/b/c@xxx"))
+			})
 
-		resp, err := example.Do(ctx, v)
-		testingx.Expect(t, err, testingx.BeNil[error]())
-		testingx.Expect(t, *resp, testingx.Be("a/b/c"))
-	})
+			t.Run("GetFile", func(t *testing.T) {
+				v := &example.GetFile{}
+				v.Path = "a/b/c"
+
+				resp, err := example.Do(ctx, v)
+				testingx.Expect(t, err, testingx.BeNil[error]())
+				testingx.Expect(t, *resp, testingx.Be("a/b/c"))
+			})
+		})
+	}
 }

internal/testingutil/serve.go

@@ -10,9 +10,15 @@ import (
 )
 
 func Serve(t testing.TB, handler http.Handler) *httptest.Server {
-	srv := httptest.NewServer(h2c.NewHandler(handler, &http2.Server{}))
-	t.Cleanup(func() {
-		srv.Close()
-	})
+	srv := httptest.NewUnstartedServer(handler)
+	srv.Start()
+	t.Cleanup(srv.Close)
+	return srv
+}
+
+func ServeWithH2C(t testing.TB, handler http.Handler) *httptest.Server {
+	srv := httptest.NewUnstartedServer(h2c.NewHandler(handler, &http2.Server{}))
+	srv.Start()
+	t.Cleanup(srv.Close)
 	return srv
 }

pkg/courierhttp/client/client.go

@@ -50,7 +50,9 @@ func (h *httpTransportFunc) RoundTrip(request *http.Request) (*http.Response, er
 }
 
 type Client struct {
-	Endpoint       string `flag:""`
+	Endpoint   string `flag:""`
+	SupportH2C bool   `flag:",omitzero"`
+
 	NewError       func() error
 	HttpTransports []HttpTransport
 }
@@ -70,14 +72,19 @@ func (c *Client) Do(ctx context.Context, req any, metas ...courier.Metadata) cou
 
 	httpClient := HttpClientFromContext(ctx)
 	if httpClient == nil {
-		httpClient = GetReasonableClientContext(ctx, c.HttpTransports...)
-	} else {
-		if httpClient.Transport == nil {
-			httpClient.Transport = http.DefaultTransport
-		}
-		httpClient.Transport = WithHttpTransports(c.HttpTransports...)(httpClient.Transport)
+		httpClient = GetReasonableClientContext(ctx)
+	}
+
+	if httpClient.Transport == nil {
+		httpClient.Transport = reasonableRoundTripper
 	}
 
+	if c.SupportH2C {
+		httpClient.Transport = UpgradeToSupportH2c(httpClient.Transport)
+	}
+
+	httpClient.Transport = WithHttpTransports(c.HttpTransports...)(httpClient.Transport)
+
 	resp, err := httpClient.Do(httpReq)
 	if err != nil {
 		if errors.Is(err, context.Canceled) {

pkg/courierhttp/client/http_default.go

@@ -6,6 +6,8 @@ import (
 	"net"
 	"net/http"
 	"time"
+
+	"golang.org/x/net/http2"
 )
 
 var reasonableRoundTripper = &http.Transport{
@@ -29,7 +31,6 @@ var reasonableRoundTripper = &http.Transport{
 }
 
 var defaultTlsConfig = &tls.Config{}
-
 var defaultHosts = Hosts{}
 
 func AddHostAlias(hostAliases ...HostAlias) {
@@ -89,3 +90,21 @@ func GetShortConnClientContext(ctx context.Context, httpTransports ...HttpTransp
 
 	return &http.Client{Transport: WithHttpTransports(httpTransports...)(t)}
 }
+
+func UpgradeToSupportH2c(t http.RoundTripper) http.RoundTripper {
+	if t1, ok := t.(*http.Transport); ok {
+		if !t1.DisableKeepAlives {
+			if t2, err := http2.ConfigureTransports(t1); err == nil {
+				t2.AllowHTTP = true
+				t2.DialTLSContext = func(ctx context.Context, network, addr string, cfg *tls.Config) (net.Conn, error) {
+					return t1.DialContext(ctx, network, addr)
+				}
+				t2.ConnPool = nil
+
+				return t2
+			}
+		}
+	}
+
+	return t
+}