Refactor: ServerResponseHandler

zio-http/src/main/scala/zhttp/http/Http.scala

@@ -5,8 +5,7 @@ import io.netty.channel.ChannelHandler
 import io.netty.handler.codec.http.HttpHeaderNames
 import zhttp.html._
 import zhttp.http.headers.HeaderModifier
-import zhttp.service.server.ServerTime
-import zhttp.service.{Handler, HttpRuntime, Server}
+import zhttp.service.{Handler, HttpRuntime, Server, ServerResponseWriter}
 import zio._
 import zio.blocking.{Blocking, effectBlocking}
 import zio.clock.Clock
@@ -638,11 +637,11 @@ object Http {
     private[zhttp] def compile[R1 <: R](
       zExec: HttpRuntime[R1],
       settings: Server.Config[R1, Throwable],
-      serverTimeGenerator: ServerTime,
+      resWriter: ServerResponseWriter[R1],
     )(implicit
       evE: E <:< Throwable,
     ): ChannelHandler =
-      Handler(http.asInstanceOf[HttpApp[R1, Throwable]], zExec, settings, serverTimeGenerator)
+      Handler(http.asInstanceOf[HttpApp[R1, Throwable]], zExec, settings, resWriter)
 
     /**
      * Patches the response produced by the app

zio-http/src/main/scala/zhttp/service/Handler.scala

@@ -4,8 +4,7 @@ import io.netty.channel.ChannelHandler.Sharable
 import io.netty.channel.{ChannelHandlerContext, SimpleChannelInboundHandler}
 import io.netty.handler.codec.http._
 import zhttp.http._
-import zhttp.service.server.content.handlers.ServerResponseHandler
-import zhttp.service.server.{ServerTime, WebSocketUpgrade}
+import zhttp.service.server.WebSocketUpgrade
 import zio.{UIO, ZIO}
 
 import java.net.{InetAddress, InetSocketAddress}
@@ -15,10 +14,9 @@ private[zhttp] final case class Handler[R](
   app: HttpApp[R, Throwable],
   runtime: HttpRuntime[R],
   config: Server.Config[R, Throwable],
-  serverTimeGenerator: ServerTime,
+  resWriter: ServerResponseWriter[R],
 ) extends SimpleChannelInboundHandler[HttpObject](false)
-    with WebSocketUpgrade[R]
-    with ServerResponseHandler[R] { self =>
+    with WebSocketUpgrade[R] { self =>
 
   override def channelRead0(ctx: Ctx, msg: HttpObject): Unit = {
 
@@ -56,7 +54,7 @@ private[zhttp] final case class Handler[R](
           )
         catch {
           case throwable: Throwable =>
-            writeResponse(
+            resWriter.write(
               Response
                 .fromHttpError(HttpError.InternalServerError(cause = Some(throwable)))
                 .withConnection(HeaderValues.close),
@@ -100,7 +98,7 @@ private[zhttp] final case class Handler[R](
           )
         catch {
           case throwable: Throwable =>
-            writeResponse(
+            resWriter.write(
               Response
                 .fromHttpError(HttpError.InternalServerError(cause = Some(throwable)))
                 .withConnection(HeaderValues.close),
@@ -139,20 +137,20 @@ private[zhttp] final case class Handler[R](
               cause.failureOrCause match {
                 case Left(Some(cause)) =>
                   UIO {
-                    writeResponse(
+                    resWriter.write(
                       Response.fromHttpError(HttpError.InternalServerError(cause = Some(cause))),
                       jReq,
                     )
                   }
                 case Left(None)        =>
                   UIO {
-                    writeResponse(Response.status(Status.NotFound), jReq)
+                    resWriter.write(Response.status(Status.NotFound), jReq)
                   }
                 case Right(other)      =>
                   other.dieOption match {
                     case Some(defect) =>
                       UIO {
-                        writeResponse(
+                        resWriter.write(
                           Response.fromHttpError(HttpError.InternalServerError(cause = Some(defect))),
                           jReq,
                         )
@@ -166,7 +164,7 @@ private[zhttp] final case class Handler[R](
               else {
                 for {
                   _ <- ZIO {
-                    writeResponse(res, jReq)
+                    resWriter.write(res, jReq)
                   }
                 } yield ()
               },
@@ -177,17 +175,23 @@ private[zhttp] final case class Handler[R](
         if (self.isWebSocket(res)) {
           self.upgradeToWebSocket(jReq, res)
         } else {
-          writeResponse(res, jReq): Unit
+          resWriter.write(res, jReq): Unit
         }
 
       case HExit.Failure(e) =>
-        writeResponse(Response.fromHttpError(HttpError.InternalServerError(cause = Some(e))), jReq): Unit
+        resWriter.write(
+          Response.fromHttpError(HttpError.InternalServerError(cause = Some(e))),
+          jReq,
+        ): Unit
 
       case HExit.Die(e) =>
-        writeResponse(Response.fromHttpError(HttpError.InternalServerError(cause = Some(e))), jReq): Unit
+        resWriter.write(
+          Response.fromHttpError(HttpError.InternalServerError(cause = Some(e))),
+          jReq,
+        ): Unit
 
       case HExit.Empty =>
-        writeResponse(Response.fromHttpError(HttpError.NotFound(Path(jReq.uri()))), jReq): Unit
+        resWriter.write(Response.fromHttpError(HttpError.NotFound(Path(jReq.uri()))), jReq): Unit
 
     }
   }
@@ -196,15 +200,12 @@ private[zhttp] final case class Handler[R](
    * Executes program
    */
   private def unsafeRunZIO(program: ZIO[R, Throwable, Any])(implicit ctx: Ctx): Unit =
-    rt.unsafeRun(ctx) {
+    runtime.unsafeRun(ctx) {
       program
     }
 
-  override def serverTime: ServerTime = serverTimeGenerator
-
-  override val rt: HttpRuntime[R] = runtime
-
   override def exceptionCaught(ctx: Ctx, cause: Throwable): Unit = {
     config.error.fold(super.exceptionCaught(ctx, cause))(f => runtime.unsafeRun(ctx)(f(cause)))
   }
+
 }

zio-http/src/main/scala/zhttp/service/Server.scala

@@ -249,7 +249,8 @@ object Server {
       channelFactory <- ZManaged.access[ServerChannelFactory](_.get)
       eventLoopGroup <- ZManaged.access[EventLoopGroup](_.get)
       zExec          <- HttpRuntime.sticky[R](eventLoopGroup).toManaged_
-      reqHandler      = settings.app.compile(zExec, settings, ServerTime.make)
+      handler         = new ServerResponseWriter(zExec, settings, ServerTime.make)
+      reqHandler      = settings.app.compile(zExec, settings, handler)
       init            = ServerChannelInitializer(zExec, settings, reqHandler)
       serverBootstrap = new ServerBootstrap().channelFactory(channelFactory).group(eventLoopGroup)
       chf  <- ZManaged.effect(serverBootstrap.childHandler(init).bind(settings.address))

zio-http/src/main/scala/zhttp/service/server/content/handlers/ServerResponseHandler.scala → zio-http/src/main/scala/zhttp/service/ServerResponseWriter.scala

@@ -1,24 +1,22 @@
-package zhttp.service.server.content.handlers
+package zhttp.service
 
 import io.netty.buffer.ByteBuf
 import io.netty.channel.{ChannelHandlerContext, DefaultFileRegion}
 import io.netty.handler.codec.http._
 import zhttp.http.{HttpData, Response}
 import zhttp.service.server.ServerTime
-import zhttp.service.{ChannelFuture, HttpRuntime, Server}
 import zio.stream.ZStream
 import zio.{UIO, ZIO}
 
 import java.io.File
 
-private[zhttp] trait ServerResponseHandler[R] {
-  type Ctx = ChannelHandlerContext
-  val rt: HttpRuntime[R]
-  val config: Server.Config[R, Throwable]
+private[zhttp] final class ServerResponseWriter[R](
+  runtime: HttpRuntime[R],
+  config: Server.Config[R, Throwable],
+  serverTime: ServerTime,
+) {
 
-  def serverTime: ServerTime
-
-  def writeResponse(msg: Response, jReq: HttpRequest)(implicit ctx: Ctx): Unit = {
+  def write(msg: Response, jReq: HttpRequest)(implicit ctx: Ctx): Unit = {
     ctx.write(encodeResponse(msg))
     writeData(msg.data.asInstanceOf[HttpData.Complete], jReq)
     ()
@@ -104,7 +102,7 @@ private[zhttp] trait ServerResponseHandler[R] {
       case HttpData.Empty => flushReleaseAndRead(jReq)
 
       case HttpData.BinaryStream(stream) =>
-        rt.unsafeRun(ctx) {
+        runtime.unsafeRun(ctx) {
           writeStreamContent(stream).ensuring(UIO(releaseAndRead(jReq)))
         }
 

zio-http/src/main/scala/zhttp/service/package.scala

@@ -1,6 +1,12 @@
 package zhttp
 
-import io.netty.channel.{Channel, ChannelFactory => JChannelFactory, EventLoopGroup => JEventLoopGroup, ServerChannel}
+import io.netty.channel.{
+  Channel,
+  ChannelFactory => JChannelFactory,
+  ChannelHandlerContext,
+  EventLoopGroup => JEventLoopGroup,
+  ServerChannel,
+}
 import zio.Has
 
 package object service {
@@ -27,4 +33,6 @@ package object service {
   type EventLoopGroup       = Has[JEventLoopGroup]
   type ServerChannelFactory = Has[JChannelFactory[ServerChannel]]
   type UServer              = Server[Any, Nothing]
+  private[zhttp] type Ctx   = ChannelHandlerContext
+
 }