HTTP spec conformance during CI

.github/workflows/http-conformance.yml

@@ -0,0 +1,77 @@
+name: HTTP Conformance
+
+on:
+  pull_request:
+    branches: ["**"]
+  push:
+    branches: ["**"]
+    tags: [v*]
+
+env:
+  GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+  JDK_JAVA_OPTIONS: "-Xms4G -Xmx8G -XX:+UseG1GC -Xss10M -XX:ReservedCodeCacheSize=1G -XX:NonProfiledCodeHeapSize=512m -Dfile.encoding=UTF-8"
+  SBT_OPTS: "-Xms4G -Xmx8G -XX:+UseG1GC -Xss10M -XX:ReservedCodeCacheSize=1G -XX:NonProfiledCodeHeapSize=512m -Dfile.encoding=UTF-8"
+
+jobs:
+  build:
+    name: Build and Test
+    strategy:
+      matrix:
+        os: [ubuntu-latest]
+        scala: [2.12.19, 2.13.14, 3.3.3]
+        java:
+          - graal_graalvm@17
+          - graal_graalvm@21
+          - temurin@17
+          - temurin@21
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 60
+
+    steps:
+      - name: Checkout current branch (full)
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup GraalVM (graal_graalvm@17)
+        if: matrix.java == 'graal_graalvm@17'
+        uses: graalvm/setup-graalvm@v1
+        with:
+          java-version: 17
+          distribution: graalvm
+          components: native-image
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          cache: sbt
+
+      - uses: coursier/setup-action@v1
+        with:
+          apps: sbt
+
+      - name: Setup GraalVM (graal_graalvm@21)
+        if: matrix.java == 'graal_graalvm@21'
+        uses: graalvm/setup-graalvm@v1
+        with:
+          java-version: 21
+          distribution: graalvm
+          components: native-image
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          cache: sbt
+
+      - name: Setup Java (temurin@17)
+        if: matrix.java == 'temurin@17'
+        uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: 17
+          cache: sbt
+
+      - name: Setup Java (temurin@21)
+        if: matrix.java == 'temurin@21'
+        uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: 21
+          cache: sbt
+
+      - name: Run HTTP Conformance Tests
+        run: sbt "project zioHttpJVM" "testOnly zio.http.ConformanceSpec zio.http.ConformanceE2ESpec"

zio-http-example/src/main/scala/example/HelloWorldAdvanced.scala

@@ -27,16 +27,17 @@ object HelloWorldAdvanced extends ZIOAppDefault {
     // Configure thread count using CLI
     val nThreads: Int = args.headOption.flatMap(x => Try(x.toInt).toOption).getOrElse(0)
 
-    val config           = Server.Config.default
+    val config              = Server.Config.default
       .port(PORT)
-    val nettyConfig      = NettyConfig.default
+    val nettyConfig         = NettyConfig.default
       .leakDetection(LeakDetectionLevel.PARANOID)
       .maxThreads(nThreads)
-    val configLayer      = ZLayer.succeed(config)
-    val nettyConfigLayer = ZLayer.succeed(nettyConfig)
+    val configLayer         = ZLayer.succeed(config)
+    val nettyConfigLayer    = ZLayer.succeed(nettyConfig)
+    val serverRuntimeConfig = configLayer.flatMap(env => ZLayer.succeed(ServerRuntimeConfig(env.get)))
 
     (fooBar ++ app)
       .serve[Any]
-      .provide(configLayer, nettyConfigLayer, Server.customized)
+      .provide(serverRuntimeConfig, nettyConfigLayer, Server.customized)
   }
 }

zio-http-example/src/main/scala/example/PlainTextBenchmarkServer.scala

@@ -40,10 +40,11 @@ object PlainTextBenchmarkServer extends ZIOAppDefault {
   private val nettyConfig = NettyConfig.default
     .leakDetection(LeakDetectionLevel.DISABLED)
 
-  private val configLayer      = ZLayer.succeed(config)
-  private val nettyConfigLayer = ZLayer.succeed(nettyConfig)
+  private val configLayer              = ZLayer.succeed(config)
+  private val nettyConfigLayer         = ZLayer.succeed(nettyConfig)
+  private val serverRuntimeConfigLayer = configLayer.flatMap(env => ZLayer.succeed(ServerRuntimeConfig(env.get)))
 
   val run: UIO[ExitCode] =
-    Server.serve(routes).provide(configLayer, nettyConfigLayer, Server.customized).exitCode
+    Server.serve(routes).provide(serverRuntimeConfigLayer, nettyConfigLayer, Server.customized).exitCode
 
 }

zio-http-example/src/main/scala/example/SimpleEffectBenchmarkServer.scala

@@ -37,10 +37,11 @@ object SimpleEffectBenchmarkServer extends ZIOAppDefault {
   private val nettyConfig = NettyConfig.default
     .leakDetection(LeakDetectionLevel.DISABLED)
 
-  private val configLayer      = ZLayer.succeed(config)
-  private val nettyConfigLayer = ZLayer.succeed(nettyConfig)
+  private val configLayer              = ZLayer.succeed(config)
+  private val nettyConfigLayer         = ZLayer.succeed(nettyConfig)
+  private val serverRuntimeConfigLayer = configLayer.flatMap(env => ZLayer.succeed(ServerRuntimeConfig(env.get)))
 
   val run: UIO[ExitCode] =
-    Server.serve(routes).provide(configLayer, nettyConfigLayer, Server.customized).exitCode
+    Server.serve(routes).provide(serverRuntimeConfigLayer, nettyConfigLayer, Server.customized).exitCode
 
 }

zio-http-testkit/src/main/scala/zio/http/TestServer.scala

@@ -142,6 +142,7 @@ object TestServer {
   val default: ZLayer[Any, Nothing, TestServer] = ZLayer.make[TestServer][Nothing](
     TestServer.layer.orDie,
     ZLayer.succeed(Server.Config.default.onAnyOpenPort),
+    ServerRuntimeConfig.layer,
     NettyDriver.customized.orDie,
     ZLayer.succeed(NettyConfig.defaultWithFastShutdown),
   )

zio-http-testkit/src/test/scala/zio/http/RoutesPrecedentsSpec.scala

@@ -45,6 +45,7 @@ object RoutesPrecedentsSpec extends ZIOSpecDefault {
           ZLayer.succeed(new MyServiceLive(code)),
         )
       }.provide(
+        ServerRuntimeConfig.layer,
         ZLayer.succeed(Server.Config.default.onAnyOpenPort),
         TestServer.layer,
         Client.default,

zio-http-testkit/src/test/scala/zio/http/SocketContractSpec.scala

@@ -103,6 +103,7 @@ object SocketContractSpec extends ZIOHttpSpec {
           _        <- promise.await.timeout(10.seconds)
         } yield assert(response.status)(equalTo(Status.SwitchingProtocols))
       }.provideSome[Client](
+        ServerRuntimeConfig.layer,
         TestServer.layer,
         NettyDriver.customized,
         ZLayer.succeed(NettyConfig.defaultWithFastShutdown),

zio-http-testkit/src/test/scala/zio/http/TestServerSpec.scala

@@ -115,6 +115,10 @@ object TestServerSpec extends ZIOHttpSpec {
       port <- ZIO.serviceWithZIO[Server](_.port)
     } yield Request
       .get(url = URL.root.port(port))
-      .addHeaders(Headers(Header.Accept(MediaType.text.`plain`)))
-
+      .addHeaders(
+        Headers(
+          Header.Accept(MediaType.text.`plain`),
+          Header.Host("localhost"),
+        ),
+      )
 }

zio-http/jvm/src/main/scala/zio/http/ServerPlatformSpecific.scala

@@ -10,11 +10,12 @@ trait ServerPlatformSpecific {
 
   private[http] def base: ZLayer[Driver & Config, Throwable, Server]
 
-  val customized: ZLayer[Config & NettyConfig, Throwable, Driver with Server] = {
+  val customized: ZLayer[ServerRuntimeConfig & NettyConfig, Throwable, Driver with Server] = {
     // tmp val Needed for Scala2
     val tmp: ZLayer[Driver & Config, Throwable, Server] = ZLayer.suspend(base)
 
-    ZLayer.makeSome[Config & NettyConfig, Driver with Server](
+    ZLayer.makeSome[ServerRuntimeConfig & NettyConfig, Driver with Server](
+      ZLayer.fromFunction((runtime: ServerRuntimeConfig) => runtime.config),
       NettyDriver.customized,
       tmp,
     )

zio-http/jvm/src/main/scala/zio/http/netty/server/NettyDriver.scala

@@ -22,21 +22,21 @@ import java.net.InetSocketAddress
 import zio._
 
 import zio.http.Driver.StartResult
+import zio.http._
 import zio.http.netty._
 import zio.http.netty.client.NettyClientDriver
-import zio.http.{ClientDriver, Driver, Response, Routes, Server}
 
 import io.netty.bootstrap.ServerBootstrap
-import io.netty.channel._
+import io.netty.channel.{Channel => NettyChannel, ChannelFactory, ChannelInitializer, ChannelOption, ServerChannel}
 import io.netty.util.ResourceLeakDetector
 
 private[zio] final case class NettyDriver(
   appRef: RoutesRef,
   channelFactory: ChannelFactory[ServerChannel],
-  channelInitializer: ChannelInitializer[Channel],
+  channelInitializer: ChannelInitializer[NettyChannel],
   serverInboundHandler: ServerInboundHandler,
   eventLoopGroups: ServerEventLoopGroups,
-  serverConfig: Server.Config,
+  serverConfig: ServerRuntimeConfig,
   nettyConfig: NettyConfig,
 ) extends Driver { self =>
 
@@ -47,9 +47,9 @@ private[zio] final case class NettyDriver(
           .group(eventLoopGroups.boss, eventLoopGroups.worker)
           .channelFactory(channelFactory)
           .childHandler(channelInitializer)
-          .option[Integer](ChannelOption.SO_BACKLOG, serverConfig.soBacklog)
-          .childOption[JBoolean](ChannelOption.TCP_NODELAY, serverConfig.tcpNoDelay)
-          .bind(serverConfig.address)
+          .option[Integer](ChannelOption.SO_BACKLOG, serverConfig.config.soBacklog)
+          .childOption[JBoolean](ChannelOption.TCP_NODELAY, serverConfig.config.tcpNoDelay)
+          .bind(serverConfig.config.address)
       }
       _       <- NettyFutureExecutor.scoped(chf)
       _       <- ZIO.succeed(ResourceLeakDetector.setLevel(nettyConfig.leakDetectionLevel.toNetty))
@@ -96,9 +96,9 @@ object NettyDriver {
   val make: ZIO[
     RoutesRef
       & ChannelFactory[ServerChannel]
-      & ChannelInitializer[Channel]
+      & ChannelInitializer[NettyChannel]
       & ServerEventLoopGroups
-      & Server.Config
+      & ServerRuntimeConfig
       & NettyConfig
       & ServerInboundHandler,
     Nothing,
@@ -107,9 +107,9 @@ object NettyDriver {
     for {
       app   <- ZIO.service[RoutesRef]
       cf    <- ZIO.service[ChannelFactory[ServerChannel]]
-      cInit <- ZIO.service[ChannelInitializer[Channel]]
+      cInit <- ZIO.service[ChannelInitializer[NettyChannel]]
       elg   <- ZIO.service[ServerEventLoopGroups]
-      sc    <- ZIO.service[Server.Config]
+      sc    <- ZIO.service[ServerRuntimeConfig]
       nsc   <- ZIO.service[NettyConfig]
       sih   <- ZIO.service[ServerInboundHandler]
     } yield new NettyDriver(
@@ -122,23 +122,24 @@ object NettyDriver {
       nettyConfig = nsc,
     )
 
-  val manual
-    : ZLayer[ServerEventLoopGroups & ChannelFactory[ServerChannel] & Server.Config & NettyConfig, Nothing, Driver] = {
+  val manual: ZLayer[ServerEventLoopGroups & ChannelFactory[
+    ServerChannel,
+  ] & ServerRuntimeConfig & NettyConfig, Nothing, Driver] = {
     implicit val trace: Trace = Trace.empty
-    ZLayer.makeSome[ServerEventLoopGroups & ChannelFactory[ServerChannel] & Server.Config & NettyConfig, Driver](
+    ZLayer.makeSome[ServerEventLoopGroups & ChannelFactory[ServerChannel] & ServerRuntimeConfig & NettyConfig, Driver](
       ZLayer(AppRef.empty),
       ServerChannelInitializer.layer,
       ServerInboundHandler.live,
       ZLayer(make),
     )
   }
 
-  val customized: ZLayer[Server.Config & NettyConfig, Throwable, Driver] = {
+  val customized: ZLayer[ServerRuntimeConfig & NettyConfig, Throwable, Driver] = {
     val serverChannelFactory: ZLayer[NettyConfig, Nothing, ChannelFactory[ServerChannel]] =
       ChannelFactories.Server.fromConfig
     val eventLoopGroup: ZLayer[NettyConfig, Nothing, ServerEventLoopGroups]               = ServerEventLoopGroups.live
 
-    ZLayer.makeSome[Server.Config & NettyConfig, Driver](
+    ZLayer.makeSome[ServerRuntimeConfig & NettyConfig, Driver](
       eventLoopGroup,
       serverChannelFactory,
       manual,
@@ -148,6 +149,7 @@ object NettyDriver {
   val live: ZLayer[Server.Config, Throwable, Driver] =
     ZLayer.makeSome[Server.Config, Driver](
       ZLayer.succeed(NettyConfig.default),
+      ServerRuntimeConfig.layer,
       customized,
     )
 }

zio-http/jvm/src/main/scala/zio/http/netty/server/ServerChannelInitializer.scala

@@ -21,10 +21,10 @@ import java.util.concurrent.TimeUnit
 import zio._
 import zio.stacktracer.TracingImplicits.disableAutoTrace
 
-import zio.http.Server
 import zio.http.Server.RequestStreaming
 import zio.http.netty.model.Conversions
 import zio.http.netty.{HybridContentLengthHandler, Names}
+import zio.http.{Server, ServerRuntimeConfig}
 
 import io.netty.channel.ChannelHandler.Sharable
 import io.netty.channel._
@@ -38,7 +38,7 @@ import io.netty.handler.timeout.ReadTimeoutHandler
  */
 @Sharable
 private[zio] final case class ServerChannelInitializer(
-  cfg: Server.Config,
+  cfg: ServerRuntimeConfig,
   reqHandler: ChannelInboundHandler,
 ) extends ChannelInitializer[Channel] {
 
@@ -48,11 +48,11 @@ private[zio] final case class ServerChannelInitializer(
     val pipeline = channel.pipeline()
     // SSL
     // Add SSL Handler if CTX is available
-    cfg.sslConfig.foreach { sslCfg =>
-      pipeline.addFirst(Names.SSLHandler, new ServerSSLDecoder(sslCfg, cfg))
+    cfg.config.sslConfig.foreach { sslCfg =>
+      pipeline.addFirst(Names.SSLHandler, new ServerSSLDecoder(sslCfg, cfg.config))
     }
 
-    cfg.idleTimeout.foreach { timeout =>
+    cfg.config.idleTimeout.foreach { timeout =>
       pipeline.addLast(Names.ReadTimeoutHandler, new ReadTimeoutHandler(timeout.toMillis, TimeUnit.MILLISECONDS))
     }
 
@@ -62,27 +62,29 @@ private[zio] final case class ServerChannelInitializer(
       Names.HttpRequestDecoder,
       new HttpRequestDecoder(
         new HttpDecoderConfig()
-          .setMaxInitialLineLength(cfg.maxInitialLineLength)
-          .setMaxHeaderSize(cfg.maxHeaderSize)
+          .setMaxInitialLineLength(cfg.config.maxInitialLineLength)
+          .setMaxHeaderSize(cfg.config.maxHeaderSize)
           .setMaxChunkSize(DEFAULT_MAX_CHUNK_SIZE)
-          .setValidateHeaders(false),
+          .setValidateHeaders(cfg.validateHeaders),
       ),
     )
     pipeline.addLast(Names.HttpResponseEncoder, new HttpResponseEncoder())
 
     // HttpContentDecompressor
-    if (cfg.requestDecompression.enabled)
-      pipeline.addLast(Names.HttpRequestDecompression, new HttpContentDecompressor(cfg.requestDecompression.strict, 0))
-
-    cfg.responseCompression.foreach(ops => {
+    if (cfg.config.requestDecompression.enabled)
+      pipeline.addLast(
+        Names.HttpRequestDecompression,
+        new HttpContentDecompressor(cfg.config.requestDecompression.strict, 0),
+      )
+    cfg.config.responseCompression.foreach(ops => {
       pipeline.addLast(
         Names.HttpResponseCompression,
         new HttpContentCompressor(ops.contentThreshold, ops.options.map(Conversions.compressionOptionsToNetty): _*),
       )
     })
 
     // ObjectAggregator
-    cfg.requestStreaming match {
+    cfg.config.requestStreaming match {
       case RequestStreaming.Enabled                         =>
       case RequestStreaming.Disabled(maximumContentLength)  =>
         pipeline.addLast(Names.HttpObjectAggregator, new HttpObjectAggregator(maximumContentLength))
@@ -93,11 +95,12 @@ private[zio] final case class ServerChannelInitializer(
 
     // ExpectContinueHandler
     // Add expect continue handler is settings is true
-    if (cfg.acceptContinue) pipeline.addLast(Names.HttpServerExpectContinue, new HttpServerExpectContinueHandler())
+    if (cfg.config.acceptContinue)
+      pipeline.addLast(Names.HttpServerExpectContinue, new HttpServerExpectContinueHandler())
 
     // KeepAliveHandler
     // Add Keep-Alive handler is settings is true
-    if (cfg.keepAlive) pipeline.addLast(Names.HttpKeepAliveHandler, new HttpServerKeepAliveHandler)
+    if (cfg.config.keepAlive) pipeline.addLast(Names.HttpKeepAliveHandler, new HttpServerKeepAliveHandler)
 
     pipeline.addLast(Names.HttpServerFlushConsolidation, new FlushConsolidationHandler())
 
@@ -112,10 +115,11 @@ private[zio] final case class ServerChannelInitializer(
 object ServerChannelInitializer {
   implicit val trace: Trace = Trace.empty
 
-  val layer: ZLayer[SimpleChannelInboundHandler[HttpObject] with Server.Config, Nothing, ServerChannelInitializer] =
+  val layer
+    : ZLayer[SimpleChannelInboundHandler[HttpObject] with ServerRuntimeConfig, Nothing, ServerChannelInitializer] =
     ZLayer.fromZIO {
       for {
-        cfg     <- ZIO.service[Server.Config]
+        cfg     <- ZIO.service[ServerRuntimeConfig]
         handler <- ZIO.service[SimpleChannelInboundHandler[HttpObject]]
       } yield ServerChannelInitializer(cfg, handler)
     }