Feature flag the HTTP2 work

- added enableHTTP2 to config
- defaults to false
- passes to protocolcheck handler

[cloudfoundry/routing-release#200]

Co-authored-by: Weyman Fung <[email protected]>

Author: ctlong

config/config.go

@@ -195,6 +195,7 @@ type Config struct {
 	EnableSSL       bool              `yaml:"enable_ssl,omitempty"`
 	SSLPort         uint16            `yaml:"ssl_port,omitempty"`
 	DisableHTTP     bool              `yaml:"disable_http,omitempty"`
+	EnableHTTP2     bool              `yaml:"enable_http2,omitempty"`
 	SSLCertificates []tls.Certificate `yaml:"-"`
 	TLSPEM          []TLSPem          `yaml:"tls_pem,omitempty"`
 	CACerts         string            `yaml:"ca_certs,omitempty"`
@@ -292,6 +293,7 @@ var defaultConfig = Config{
 	EnableSSL:     false,
 	SSLPort:       443,
 	DisableHTTP:   false,
+	EnableHTTP2:   false,
 	MinTLSVersion: tls.VersionTLS12,
 	MaxTLSVersion: tls.VersionTLS12,
 

config/config_test.go

@@ -1399,6 +1399,23 @@ disable_http: true
 			})
 		})
 
+		Context("enable_http2", func() {
+			It("defaults to false", func() {
+				Expect(config.Process()).To(Succeed())
+				Expect(config.EnableHTTP2).To(BeFalse())
+			})
+
+			It("setting enable_http2 succeeds", func() {
+				var b = []byte(fmt.Sprintf(`
+enable_http2: true
+`))
+				err := config.Initialize(b)
+				Expect(err).NotTo(HaveOccurred())
+				Expect(config.Process()).To(Succeed())
+				Expect(config.EnableHTTP2).To(BeTrue())
+			})
+		})
+
 		Context("When given a routing_table_sharding_mode that is supported ", func() {
 			Context("sharding mode `all`", func() {
 				It("succeeds", func() {

handlers/protocolcheck.go

@@ -16,19 +16,21 @@ import (
 type protocolCheck struct {
 	logger      logger.Logger
 	errorWriter errorwriter.ErrorWriter
+	enableHTTP2 bool
 }
 
 // NewProtocolCheck creates a handler responsible for checking the protocol of
 // the request
-func NewProtocolCheck(logger logger.Logger, errorWriter errorwriter.ErrorWriter) negroni.Handler {
+func NewProtocolCheck(logger logger.Logger, errorWriter errorwriter.ErrorWriter, enableHTTP2 bool) negroni.Handler {
 	return &protocolCheck{
 		logger:      logger,
 		errorWriter: errorWriter,
+		enableHTTP2: enableHTTP2,
 	}
 }
 
 func (p *protocolCheck) ServeHTTP(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
-	if !isProtocolSupported(r) {
+	if !p.isProtocolSupported(r) {
 		// must be hijacked, otherwise no response is sent back
 		conn, buf, err := p.hijack(rw)
 		if err != nil {
@@ -58,6 +60,6 @@ func (p *protocolCheck) hijack(rw http.ResponseWriter) (net.Conn, *bufio.ReadWri
 	return hijacker.Hijack()
 }
 
-func isProtocolSupported(request *http.Request) bool {
-	return request.ProtoMajor == 2 || (request.ProtoMajor == 1 && (request.ProtoMinor == 0 || request.ProtoMinor == 1))
+func (p *protocolCheck) isProtocolSupported(request *http.Request) bool {
+	return (p.enableHTTP2 && request.ProtoMajor == 2) || (request.ProtoMajor == 1 && (request.ProtoMinor == 0 || request.ProtoMinor == 1))
 }

handlers/protocolcheck_test.go

@@ -21,20 +21,21 @@ var _ = Describe("Protocolcheck", func() {
 		logger logger.Logger
 		ew     = errorwriter.NewPlaintextErrorWriter()
 
-		nextCalled bool
-		server     *ghttp.Server
-		n          *negroni.Negroni
+		nextCalled  bool
+		server      *ghttp.Server
+		n           *negroni.Negroni
+		enableHTTP2 bool
 	)
 
-	BeforeEach(func() {
+	JustBeforeEach(func() {
 		logger = test_util.NewTestZapLogger("protocolcheck")
 		nextCalled = false
 
 		n = negroni.New()
 		n.UseFunc(func(rw http.ResponseWriter, req *http.Request, next http.HandlerFunc) {
 			next(rw, req)
 		})
-		n.Use(handlers.NewProtocolCheck(logger, ew))
+		n.Use(handlers.NewProtocolCheck(logger, ew, enableHTTP2))
 		n.UseHandlerFunc(func(http.ResponseWriter, *http.Request) {
 			nextCalled = true
 		})
@@ -49,18 +50,44 @@ var _ = Describe("Protocolcheck", func() {
 	})
 
 	Context("http2", func() {
-		It("passes the request through", func() {
-			conn, err := net.Dial("tcp", server.Addr())
-			defer conn.Close()
-			Expect(err).ToNot(HaveOccurred())
-			respReader := bufio.NewReader(conn)
+		Context("when http2 is enabled", func() {
+			BeforeEach(func() {
+				enableHTTP2 = true
+			})
+
+			It("passes the request through", func() {
+				conn, err := net.Dial("tcp", server.Addr())
+				defer conn.Close()
+				Expect(err).ToNot(HaveOccurred())
+				respReader := bufio.NewReader(conn)
+
+				conn.Write([]byte("PRI * HTTP/2.0\r\nHost: example.com\r\n\r\n"))
+				resp, err := http.ReadResponse(respReader, nil)
+				Expect(err).ToNot(HaveOccurred())
+
+				Expect(resp.StatusCode).To(Equal(200))
+				Expect(nextCalled).To(BeTrue())
+			})
+		})
 
-			conn.Write([]byte("PRI * HTTP/2.0\r\nHost: example.com\r\n\r\n"))
-			resp, err := http.ReadResponse(respReader, nil)
-			Expect(err).ToNot(HaveOccurred())
+		Context("when http2 is disabled", func() {
+			BeforeEach(func() {
+				enableHTTP2 = false
+			})
 
-			Expect(resp.StatusCode).To(Equal(200))
-			Expect(nextCalled).To(BeTrue())
+			It("returns a 400 witha helpful error ", func() {
+				conn, err := net.Dial("tcp", server.Addr())
+				defer conn.Close()
+				Expect(err).ToNot(HaveOccurred())
+				respReader := bufio.NewReader(conn)
+
+				conn.Write([]byte("PRI * HTTP/2.0\r\nHost: example.com\r\n\r\n"))
+				resp, err := http.ReadResponse(respReader, nil)
+				Expect(err).ToNot(HaveOccurred())
+
+				Expect(resp.StatusCode).To(Equal(400))
+				Expect(nextCalled).To(BeFalse())
+			})
 		})
 	})
 

integration/main_test.go

@@ -255,12 +255,14 @@ var _ = Describe("Router Integration", func() {
 			clientTLSConfig *tls.Config
 			mbusClient      *nats.Conn
 		)
+
 		BeforeEach(func() {
 			cfg, clientTLSConfig = createSSLConfig(statusPort, proxyPort, sslPort, natsPort)
-
 		})
+
 		JustBeforeEach(func() {
 			var err error
+			cfg.EnableHTTP2 = true
 			writeConfig(cfg, cfgFile)
 			mbusClient, err = newMessageBus(cfg)
 			Expect(err).ToNot(HaveOccurred())
@@ -297,7 +299,6 @@ var _ = Describe("Router Integration", func() {
 	})
 
 	Context("Drain", func() {
-
 		BeforeEach(func() {
 			cfg = createConfig(statusPort, proxyPort, cfgFile, defaultPruneInterval, defaultPruneThreshold, 1, false, 0, natsPort)
 		})

proxy/proxy.go

@@ -174,7 +174,7 @@ func NewProxy(
 	n.Use(handlers.NewProxyHealthcheck(cfg.HealthCheckUserAgent, p.health, logger))
 	n.Use(zipkinHandler)
 	n.Use(w3cHandler)
-	n.Use(handlers.NewProtocolCheck(logger, errorWriter))
+	n.Use(handlers.NewProtocolCheck(logger, errorWriter, cfg.EnableHTTP2))
 	n.Use(handlers.NewLookup(registry, reporter, logger, errorWriter, cfg.EmptyPoolResponseCode503))
 	n.Use(handlers.NewClientCert(
 		SkipSanitize(routeServiceHandler.(*handlers.RouteService)),