Implement ServerRequest.connectionInfo for Netty servers (#4853)

Author: adamw

server/netty-server/src/main/scala/sttp/tapir/server/netty/NettyServerRequest.scala

@@ -2,19 +2,42 @@ package sttp.tapir.server.netty
 
 import scala.collection.JavaConverters._
 import scala.collection.immutable.Seq
+import io.netty.channel.ChannelHandlerContext
 import io.netty.handler.codec.http.{HttpRequest, QueryStringDecoder}
+import io.netty.handler.ssl.SslHandler
 import sttp.model.{Header, Method, QueryParams, Uri}
 import sttp.tapir.{AttributeKey, AttributeMap}
 import sttp.tapir.model.{ConnectionInfo, ServerRequest}
 import sttp.tapir.server.netty.internal.RichNettyHttpHeaders
 import io.netty.handler.codec.http.FullHttpRequest
+import java.net.InetSocketAddress
 
-case class NettyServerRequest(req: HttpRequest, attributes: AttributeMap = AttributeMap.Empty) extends ServerRequest {
+case class NettyServerRequest(req: HttpRequest, ctx: ChannelHandlerContext, attributes: AttributeMap = AttributeMap.Empty)
+    extends ServerRequest {
   // non-lazy, so that we can validate that the URI parses upfront
   override val uri: Uri = Uri.unsafeParse(req.uri())
 
   override lazy val protocol: String = req.protocolVersion().text()
-  override lazy val connectionInfo: ConnectionInfo = ConnectionInfo.NoInfo
+
+  override lazy val connectionInfo: ConnectionInfo = {
+    val local = ctx.channel().localAddress() match {
+      case inet: InetSocketAddress => Some(inet)
+      case _                       => None
+    }
+
+    val remote = ctx.channel().remoteAddress() match {
+      case inet: InetSocketAddress => Some(inet)
+      case _                       => None
+    }
+
+    val secure = uri.scheme match {
+      case Some("https") | Some("wss") => Some(true)
+      case Some("http") | Some("ws")   => Some(false)
+      case _                           => None
+    }
+
+    ConnectionInfo(local, remote, secure)
+  }
   override lazy val underlying: Any = req
   override lazy val queryParameters: QueryParams = {
     val decoder = new QueryStringDecoder(req.uri())
@@ -37,5 +60,5 @@ case class NettyServerRequest(req: HttpRequest, attributes: AttributeMap = Attri
   override def attribute[T](k: AttributeKey[T]): Option[T] = attributes.get(k)
   override def attribute[T](k: AttributeKey[T], v: T): NettyServerRequest = copy(attributes = attributes.put(k, v))
   override def withUnderlying(underlying: Any): ServerRequest =
-    NettyServerRequest(req = underlying.asInstanceOf[HttpRequest], attributes)
+    NettyServerRequest(req = underlying.asInstanceOf[HttpRequest], ctx = ctx, attributes = attributes)
 }

server/netty-server/src/main/scala/sttp/tapir/server/netty/internal/NettyServerHandler.scala

@@ -143,7 +143,7 @@ class NettyServerHandler[F[_]](
       requestTimeoutHandler.foreach(h => ctx.pipeline().addFirst(h))
       val (runningFuture, cancellationSwitch) = unsafeRunAsync { () =>
         try {
-          route(NettyServerRequest(req))
+          route(NettyServerRequest(req, ctx))
             .map {
               case Some(response) => response
               case None           => ServerResponse.notFound

server/netty-server/src/test/scala/sttp/tapir/server/netty/NettyServerRequestSpec.scala

@@ -3,6 +3,7 @@ package sttp.tapir.server.netty
 import java.net.{URI => JavaUri}
 
 import io.netty.buffer.Unpooled
+import io.netty.channel.embedded.EmbeddedChannel
 import io.netty.handler.codec.http._
 import org.scalatest.freespec.AnyFreeSpec
 import org.scalatest.matchers.should.Matchers
@@ -28,7 +29,21 @@ class NettyServerRequestSpec extends AnyFreeSpec with Matchers {
     trailingHeaders
   )
 
-  val nettyServerRequest: NettyServerRequest = NettyServerRequest(emptyPostRequest)
+  // Use EmbeddedChannel for testing - it provides a ChannelHandlerContext
+  private val embeddedChannel = new EmbeddedChannel()
+  private var capturedCtx: io.netty.channel.ChannelHandlerContext = null
+
+  embeddedChannel
+    .pipeline()
+    .addLast(new io.netty.channel.ChannelInboundHandlerAdapter {
+      override def channelActive(ctx: io.netty.channel.ChannelHandlerContext): Unit = {
+        capturedCtx = ctx
+        super.channelActive(ctx)
+      }
+    })
+    .fireChannelActive()
+
+  val nettyServerRequest: NettyServerRequest = NettyServerRequest(emptyPostRequest, capturedCtx)
 
   "uri is the same as in request" in {
     nettyServerRequest.uri.toString should equal(uri.toString)