From ef29f63037fa8f9f8e5e2e3f6a07a3f5d176cf90 Mon Sep 17 00:00:00 2001 From: "bartlomiej.zylinski" Date: Tue, 16 Apr 2024 12:49:17 +0200 Subject: [PATCH] Renamed NettyId to NettySync --- doc/server/netty.md | 8 +-- .../loom/{NettyId.scala => NettySync.scala} | 14 ++--- ...tBody.scala => NettySyncRequestBody.scala} | 2 +- ...tyIdServer.scala => NettySyncServer.scala} | 56 +++++++++---------- ...scala => NettySyncServerInterpreter.scala} | 14 ++--- ...ons.scala => NettySyncServerOptions.scala} | 22 ++++---- ...erTest.scala => NettySyncServerTest.scala} | 4 +- ...a => NettySyncTestServerInterpreter.scala} | 12 ++-- 8 files changed, 66 insertions(+), 66 deletions(-) rename perf-tests/src/main/scala/sttp/tapir/perf/netty/loom/{NettyId.scala => NettySync.scala} (66%) rename server/netty-server/loom/src/main/scala/sttp/tapir/server/netty/loom/{NettyIdRequestBody.scala => NettySyncRequestBody.scala} (90%) rename server/netty-server/loom/src/main/scala/sttp/tapir/server/netty/loom/{NettyIdServer.scala => NettySyncServer.scala} (72%) rename server/netty-server/loom/src/main/scala/sttp/tapir/server/netty/loom/{NettyIdServerInterpreter.scala => NettySyncServerInterpreter.scala} (53%) rename server/netty-server/loom/src/main/scala/sttp/tapir/server/netty/loom/{NettyIdServerOptions.scala => NettySyncServerOptions.scala} (64%) rename server/netty-server/loom/src/test/scala/sttp/tapir/server/netty/loom/{NettyIdServerTest.scala => NettySyncServerTest.scala} (89%) rename server/netty-server/loom/src/test/scala/sttp/tapir/server/netty/loom/{NettyIdTestServerInterpreter.scala => NettySyncTestServerInterpreter.scala} (67%) diff --git a/doc/server/netty.md b/doc/server/netty.md index cbeee80c9c..c6e7e44adf 100644 --- a/doc/server/netty.md +++ b/doc/server/netty.md @@ -19,7 +19,7 @@ To expose an endpoint using a [Netty](https://netty.io)-based server, first add Then, use: - `NettyFutureServer().addEndpoints` to expose `Future`-based server endpoints. -- `NettyIdServer().addEndpoints` to expose `Loom`-based server endpoints. +- `NettySyncServer().addEndpoints` to expose `Loom`-based server endpoints. - `NettyCatsServer().addEndpoints` to expose `F`-based server endpoints, where `F` is any cats-effect supported effect. [Streaming](../endpoint/streaming.md) request and response bodies is supported with fs2. - `NettyZioServer().addEndpoints` to expose `ZIO`-based server endpoints, where `R` represents ZIO requirements supported effect. Streaming is supported with ZIO Streams. @@ -48,7 +48,7 @@ The `tapir-netty-server-loom` server uses `Id[T]` as its wrapper effect for comp ```scala import sttp.tapir._ -import sttp.tapir.server.netty.loom.{Id, NettyIdServer, NettyIdServerBinding} +import sttp.tapir.server.netty.loom.{Id, NettySyncServer, NettySyncServerBinding} val helloWorld = endpoint .get @@ -56,8 +56,8 @@ val helloWorld = endpoint .out(stringBody) .serverLogicSuccess[Id](name => s"Hello, $name!") -val binding: NettyIdServerBinding = - NettyIdServer().addEndpoint(helloWorld).start() +val binding: NettySyncServerBinding = + NettySyncServer().addEndpoint(helloWorld).start() ``` ## Configuration diff --git a/perf-tests/src/main/scala/sttp/tapir/perf/netty/loom/NettyId.scala b/perf-tests/src/main/scala/sttp/tapir/perf/netty/loom/NettySync.scala similarity index 66% rename from perf-tests/src/main/scala/sttp/tapir/perf/netty/loom/NettyId.scala rename to perf-tests/src/main/scala/sttp/tapir/perf/netty/loom/NettySync.scala index 0fe76cedb6..399cb3d629 100644 --- a/perf-tests/src/main/scala/sttp/tapir/perf/netty/loom/NettyId.scala +++ b/perf-tests/src/main/scala/sttp/tapir/perf/netty/loom/NettySync.scala @@ -8,15 +8,15 @@ import sttp.tapir.server.ServerEndpoint object Tapir extends Endpoints -object NettyId { +object NettySync { def runServer(endpoints: List[ServerEndpoint[Any, Id]], withServerLog: Boolean = false): IO[ServerRunner.KillSwitch] = { val declaredPort = Port val declaredHost = "0.0.0.0" - val serverOptions = buildOptions(NettyIdServerOptions.customiseInterceptors, withServerLog) + val serverOptions = buildOptions(NettySyncServerOptions.customiseInterceptors, withServerLog) // Starting netty server - val serverBinding: NettyIdServerBinding = - NettyIdServer(serverOptions) + val serverBinding: NettySyncServerBinding = + NettySyncServer(serverOptions) .port(declaredPort) .host(declaredHost) .addEndpoints(endpoints) @@ -25,8 +25,8 @@ object NettyId { } } -object TapirServer extends ServerRunner { override def start = NettyId.runServer(Tapir.genEndpointsId(1)) } -object TapirMultiServer extends ServerRunner { override def start = NettyId.runServer(Tapir.genEndpointsId(128)) } +object TapirServer extends ServerRunner { override def start = NettySync.runServer(Tapir.genEndpointsId(1)) } +object TapirMultiServer extends ServerRunner { override def start = NettySync.runServer(Tapir.genEndpointsId(128)) } object TapirInterceptorMultiServer extends ServerRunner { - override def start = NettyId.runServer(Tapir.genEndpointsId(128), withServerLog = true) + override def start = NettySync.runServer(Tapir.genEndpointsId(128), withServerLog = true) } diff --git a/server/netty-server/loom/src/main/scala/sttp/tapir/server/netty/loom/NettyIdRequestBody.scala b/server/netty-server/loom/src/main/scala/sttp/tapir/server/netty/loom/NettySyncRequestBody.scala similarity index 90% rename from server/netty-server/loom/src/main/scala/sttp/tapir/server/netty/loom/NettyIdRequestBody.scala rename to server/netty-server/loom/src/main/scala/sttp/tapir/server/netty/loom/NettySyncRequestBody.scala index 7a9373e6c3..4817bf175b 100644 --- a/server/netty-server/loom/src/main/scala/sttp/tapir/server/netty/loom/NettyIdRequestBody.scala +++ b/server/netty-server/loom/src/main/scala/sttp/tapir/server/netty/loom/NettySyncRequestBody.scala @@ -11,7 +11,7 @@ import sttp.tapir.model.ServerRequest import sttp.tapir.server.netty.internal.NettyRequestBody import sttp.tapir.server.netty.internal.reactivestreams.{FileWriterSubscriber, SimpleSubscriber} -private[netty] class NettyIdRequestBody(val createFile: ServerRequest => TapirFile) extends NettyRequestBody[Id, NoStreams] { +private[netty] class NettySyncRequestBody(val createFile: ServerRequest => TapirFile) extends NettyRequestBody[Id, NoStreams] { override implicit val monad: MonadError[Id] = idMonad override val streams: capabilities.Streams[NoStreams] = NoStreams diff --git a/server/netty-server/loom/src/main/scala/sttp/tapir/server/netty/loom/NettyIdServer.scala b/server/netty-server/loom/src/main/scala/sttp/tapir/server/netty/loom/NettySyncServer.scala similarity index 72% rename from server/netty-server/loom/src/main/scala/sttp/tapir/server/netty/loom/NettyIdServer.scala rename to server/netty-server/loom/src/main/scala/sttp/tapir/server/netty/loom/NettySyncServer.scala index 85fc5bdd26..4418d2d4a8 100644 --- a/server/netty-server/loom/src/main/scala/sttp/tapir/server/netty/loom/NettyIdServer.scala +++ b/server/netty-server/loom/src/main/scala/sttp/tapir/server/netty/loom/NettySyncServer.scala @@ -26,40 +26,40 @@ import scala.concurrent.Promise import scala.concurrent.duration.FiniteDuration import scala.util.control.NonFatal -case class NettyIdServer(routes: Vector[IdRoute], options: NettyIdServerOptions, config: NettyConfig) { +case class NettySyncServer(routes: Vector[IdRoute], options: NettySyncServerOptions, config: NettyConfig) { private val executor = Executors.newVirtualThreadPerTaskExecutor() - def addEndpoint(se: ServerEndpoint[Any, Id]): NettyIdServer = addEndpoints(List(se)) - def addEndpoint(se: ServerEndpoint[Any, Id], overrideOptions: NettyIdServerOptions): NettyIdServer = + def addEndpoint(se: ServerEndpoint[Any, Id]): NettySyncServer = addEndpoints(List(se)) + def addEndpoint(se: ServerEndpoint[Any, Id], overrideOptions: NettySyncServerOptions): NettySyncServer = addEndpoints(List(se), overrideOptions) - def addEndpoints(ses: List[ServerEndpoint[Any, Id]]): NettyIdServer = addRoute(NettyIdServerInterpreter(options).toRoute(ses)) - def addEndpoints(ses: List[ServerEndpoint[Any, Id]], overrideOptions: NettyIdServerOptions): NettyIdServer = - addRoute(NettyIdServerInterpreter(overrideOptions).toRoute(ses)) + def addEndpoints(ses: List[ServerEndpoint[Any, Id]]): NettySyncServer = addRoute(NettySyncServerInterpreter(options).toRoute(ses)) + def addEndpoints(ses: List[ServerEndpoint[Any, Id]], overrideOptions: NettySyncServerOptions): NettySyncServer = + addRoute(NettySyncServerInterpreter(overrideOptions).toRoute(ses)) - def addRoute(r: IdRoute): NettyIdServer = copy(routes = routes :+ r) - def addRoutes(r: Iterable[IdRoute]): NettyIdServer = copy(routes = routes ++ r) + def addRoute(r: IdRoute): NettySyncServer = copy(routes = routes :+ r) + def addRoutes(r: Iterable[IdRoute]): NettySyncServer = copy(routes = routes ++ r) - def options(o: NettyIdServerOptions): NettyIdServer = copy(options = o) - def config(c: NettyConfig): NettyIdServer = copy(config = c) - def modifyConfig(f: NettyConfig => NettyConfig): NettyIdServer = config(f(config)) + def options(o: NettySyncServerOptions): NettySyncServer = copy(options = o) + def config(c: NettyConfig): NettySyncServer = copy(config = c) + def modifyConfig(f: NettyConfig => NettyConfig): NettySyncServer = config(f(config)) - def host(hostname: String): NettyIdServer = modifyConfig(_.host(hostname)) + def host(hostname: String): NettySyncServer = modifyConfig(_.host(hostname)) - def port(p: Int): NettyIdServer = modifyConfig(_.port(p)) + def port(p: Int): NettySyncServer = modifyConfig(_.port(p)) - def start(): NettyIdServerBinding = + def start(): NettySyncServerBinding = startUsingSocketOverride[InetSocketAddress](None) match { case (socket, stop) => - NettyIdServerBinding(socket, stop) + NettySyncServerBinding(socket, stop) } - def startUsingDomainSocket(path: Option[Path] = None): NettyIdDomainSocketBinding = + def startUsingDomainSocket(path: Option[Path] = None): NettySyncDomainSocketBinding = startUsingDomainSocket(path.getOrElse(Paths.get(System.getProperty("java.io.tmpdir"), UUID.randomUUID().toString))) - def startUsingDomainSocket(path: Path): NettyIdDomainSocketBinding = + def startUsingDomainSocket(path: Path): NettySyncDomainSocketBinding = startUsingSocketOverride(Some(new DomainSocketAddress(path.toFile))) match { case (socket, stop) => - NettyIdDomainSocketBinding(socket, stop) + NettySyncDomainSocketBinding(socket, stop) } private def startUsingSocketOverride[SA <: SocketAddress](socketOverride: Option[SA]): (SA, () => Unit) = { @@ -174,22 +174,22 @@ case class NettyIdServer(routes: Vector[IdRoute], options: NettyIdServerOptions, } } -object NettyIdServer { - def apply(): NettyIdServer = NettyIdServer(Vector.empty, NettyIdServerOptions.default, NettyConfig.default) +object NettySyncServer { + def apply(): NettySyncServer = NettySyncServer(Vector.empty, NettySyncServerOptions.default, NettyConfig.default) - def apply(serverOptions: NettyIdServerOptions): NettyIdServer = - NettyIdServer(Vector.empty, serverOptions, NettyConfig.default) + def apply(serverOptions: NettySyncServerOptions): NettySyncServer = + NettySyncServer(Vector.empty, serverOptions, NettyConfig.default) - def apply(config: NettyConfig): NettyIdServer = - NettyIdServer(Vector.empty, NettyIdServerOptions.default, config) + def apply(config: NettyConfig): NettySyncServer = + NettySyncServer(Vector.empty, NettySyncServerOptions.default, config) - def apply(serverOptions: NettyIdServerOptions, config: NettyConfig): NettyIdServer = - NettyIdServer(Vector.empty, serverOptions, config) + def apply(serverOptions: NettySyncServerOptions, config: NettyConfig): NettySyncServer = + NettySyncServer(Vector.empty, serverOptions, config) } -case class NettyIdServerBinding(localSocket: InetSocketAddress, stop: () => Unit) { +case class NettySyncServerBinding(localSocket: InetSocketAddress, stop: () => Unit) { def hostName: String = localSocket.getHostName def port: Int = localSocket.getPort } -case class NettyIdDomainSocketBinding(localSocket: DomainSocketAddress, stop: () => Unit) { +case class NettySyncDomainSocketBinding(localSocket: DomainSocketAddress, stop: () => Unit) { def path: String = localSocket.path() } diff --git a/server/netty-server/loom/src/main/scala/sttp/tapir/server/netty/loom/NettyIdServerInterpreter.scala b/server/netty-server/loom/src/main/scala/sttp/tapir/server/netty/loom/NettySyncServerInterpreter.scala similarity index 53% rename from server/netty-server/loom/src/main/scala/sttp/tapir/server/netty/loom/NettyIdServerInterpreter.scala rename to server/netty-server/loom/src/main/scala/sttp/tapir/server/netty/loom/NettySyncServerInterpreter.scala index 059f772382..d09dc679ea 100644 --- a/server/netty-server/loom/src/main/scala/sttp/tapir/server/netty/loom/NettyIdServerInterpreter.scala +++ b/server/netty-server/loom/src/main/scala/sttp/tapir/server/netty/loom/NettySyncServerInterpreter.scala @@ -3,8 +3,8 @@ package sttp.tapir.server.netty.loom import sttp.tapir.server.ServerEndpoint import sttp.tapir.server.netty.internal.{NettyToResponseBody, NettyServerInterpreter, RunAsync} -trait NettyIdServerInterpreter { - def nettyServerOptions: NettyIdServerOptions +trait NettySyncServerInterpreter { + def nettyServerOptions: NettySyncServerOptions def toRoute( ses: List[ServerEndpoint[Any, Id]] @@ -12,7 +12,7 @@ trait NettyIdServerInterpreter { NettyServerInterpreter.toRoute[Id]( ses, nettyServerOptions.interceptors, - new NettyIdRequestBody(nettyServerOptions.createFile), + new NettySyncRequestBody(nettyServerOptions.createFile), new NettyToResponseBody[Id](RunAsync.Id), nettyServerOptions.deleteFile, RunAsync.Id @@ -20,10 +20,10 @@ trait NettyIdServerInterpreter { } } -object NettyIdServerInterpreter { - def apply(serverOptions: NettyIdServerOptions = NettyIdServerOptions.default): NettyIdServerInterpreter = { - new NettyIdServerInterpreter { - override def nettyServerOptions: NettyIdServerOptions = serverOptions +object NettySyncServerInterpreter { + def apply(serverOptions: NettySyncServerOptions = NettySyncServerOptions.default): NettySyncServerInterpreter = { + new NettySyncServerInterpreter { + override def nettyServerOptions: NettySyncServerOptions = serverOptions } } } diff --git a/server/netty-server/loom/src/main/scala/sttp/tapir/server/netty/loom/NettyIdServerOptions.scala b/server/netty-server/loom/src/main/scala/sttp/tapir/server/netty/loom/NettySyncServerOptions.scala similarity index 64% rename from server/netty-server/loom/src/main/scala/sttp/tapir/server/netty/loom/NettyIdServerOptions.scala rename to server/netty-server/loom/src/main/scala/sttp/tapir/server/netty/loom/NettySyncServerOptions.scala index 4d7659570c..02c38b300b 100644 --- a/server/netty-server/loom/src/main/scala/sttp/tapir/server/netty/loom/NettyIdServerOptions.scala +++ b/server/netty-server/loom/src/main/scala/sttp/tapir/server/netty/loom/NettySyncServerOptions.scala @@ -7,36 +7,36 @@ import sttp.tapir.server.netty.internal.NettyDefaults import sttp.tapir.server.interceptor.{CustomiseInterceptors, Interceptor} import sttp.tapir.{Defaults, TapirFile} -case class NettyIdServerOptions( +case class NettySyncServerOptions( interceptors: List[Interceptor[Id]], createFile: ServerRequest => TapirFile, deleteFile: TapirFile => Unit ) { - def prependInterceptor(i: Interceptor[Id]): NettyIdServerOptions = copy(interceptors = i :: interceptors) - def appendInterceptor(i: Interceptor[Id]): NettyIdServerOptions = copy(interceptors = interceptors :+ i) + def prependInterceptor(i: Interceptor[Id]): NettySyncServerOptions = copy(interceptors = i :: interceptors) + def appendInterceptor(i: Interceptor[Id]): NettySyncServerOptions = copy(interceptors = interceptors :+ i) } -object NettyIdServerOptions { +object NettySyncServerOptions { - /** Default options, using TCP sockets (the most common case). This can be later customised using [[NettyIdServerOptions#nettyOptions()]]. + /** Default options, using TCP sockets (the most common case). This can be later customised using [[NettySyncServerOptions#nettyOptions()]]. */ - def default: NettyIdServerOptions = customiseInterceptors.options + def default: NettySyncServerOptions = customiseInterceptors.options private def default( interceptors: List[Interceptor[Id]] - ): NettyIdServerOptions = - NettyIdServerOptions( + ): NettySyncServerOptions = + NettySyncServerOptions( interceptors, _ => Defaults.createTempFile(), Defaults.deleteFile() ) /** Customise the interceptors that are being used when exposing endpoints as a server. By default uses TCP sockets (the most common - * case), but this can be later customised using [[NettyIdServerOptions#nettyOptions()]]. + * case), but this can be later customised using [[NettySyncServerOptions#nettyOptions()]]. */ - def customiseInterceptors: CustomiseInterceptors[Id, NettyIdServerOptions] = { + def customiseInterceptors: CustomiseInterceptors[Id, NettySyncServerOptions] = { CustomiseInterceptors( - createOptions = (ci: CustomiseInterceptors[Id, NettyIdServerOptions]) => default(ci.interceptors) + createOptions = (ci: CustomiseInterceptors[Id, NettySyncServerOptions]) => default(ci.interceptors) ).serverLog(defaultServerLog) } diff --git a/server/netty-server/loom/src/test/scala/sttp/tapir/server/netty/loom/NettyIdServerTest.scala b/server/netty-server/loom/src/test/scala/sttp/tapir/server/netty/loom/NettySyncServerTest.scala similarity index 89% rename from server/netty-server/loom/src/test/scala/sttp/tapir/server/netty/loom/NettyIdServerTest.scala rename to server/netty-server/loom/src/test/scala/sttp/tapir/server/netty/loom/NettySyncServerTest.scala index e4053d18be..08761f8f95 100644 --- a/server/netty-server/loom/src/test/scala/sttp/tapir/server/netty/loom/NettyIdServerTest.scala +++ b/server/netty-server/loom/src/test/scala/sttp/tapir/server/netty/loom/NettySyncServerTest.scala @@ -10,14 +10,14 @@ import sttp.tapir.tests.{Test, TestSuite} import scala.concurrent.Future import scala.concurrent.duration.FiniteDuration -class NettyIdServerTest extends TestSuite with EitherValues { +class NettySyncServerTest extends TestSuite with EitherValues { override def tests: Resource[IO, List[Test]] = backendResource.flatMap { backend => Resource .make(IO.delay { val eventLoopGroup = new NioEventLoopGroup() - val interpreter = new NettyIdTestServerInterpreter(eventLoopGroup) + val interpreter = new NettySyncTestServerInterpreter(eventLoopGroup) val createServerTest = new DefaultCreateServerTest(backend, interpreter) val sleeper: Sleeper[Id] = (duration: FiniteDuration) => Thread.sleep(duration.toMillis) diff --git a/server/netty-server/loom/src/test/scala/sttp/tapir/server/netty/loom/NettyIdTestServerInterpreter.scala b/server/netty-server/loom/src/test/scala/sttp/tapir/server/netty/loom/NettySyncTestServerInterpreter.scala similarity index 67% rename from server/netty-server/loom/src/test/scala/sttp/tapir/server/netty/loom/NettyIdTestServerInterpreter.scala rename to server/netty-server/loom/src/test/scala/sttp/tapir/server/netty/loom/NettySyncTestServerInterpreter.scala index c4535bbc61..a5bd2159e2 100644 --- a/server/netty-server/loom/src/test/scala/sttp/tapir/server/netty/loom/NettyIdTestServerInterpreter.scala +++ b/server/netty-server/loom/src/test/scala/sttp/tapir/server/netty/loom/NettySyncTestServerInterpreter.scala @@ -10,11 +10,11 @@ import sttp.tapir.tests.Port import scala.concurrent.duration.FiniteDuration -class NettyIdTestServerInterpreter(eventLoopGroup: NioEventLoopGroup) - extends TestServerInterpreter[Id, Any, NettyIdServerOptions, IdRoute] { +class NettySyncTestServerInterpreter(eventLoopGroup: NioEventLoopGroup) + extends TestServerInterpreter[Id, Any, NettySyncServerOptions, IdRoute] { override def route(es: List[ServerEndpoint[Any, Id]], interceptors: Interceptors): IdRoute = { - val serverOptions: NettyIdServerOptions = interceptors(NettyIdServerOptions.customiseInterceptors).options - NettyIdServerInterpreter(serverOptions).toRoute(es) + val serverOptions: NettySyncServerOptions = interceptors(NettySyncServerOptions.customiseInterceptors).options + NettySyncServerInterpreter(serverOptions).toRoute(es) } override def serverWithStop( @@ -24,8 +24,8 @@ class NettyIdTestServerInterpreter(eventLoopGroup: NioEventLoopGroup) val config = NettyConfig.default.eventLoopGroup(eventLoopGroup).randomPort.withDontShutdownEventLoopGroupOnClose.noGracefulShutdown val customizedConfig = gracefulShutdownTimeout.map(config.withGracefulShutdownTimeout).getOrElse(config) - val options = NettyIdServerOptions.default - val bind = IO.blocking(NettyIdServer(options, customizedConfig).addRoutes(routes.toList).start()) + val options = NettySyncServerOptions.default + val bind = IO.blocking(NettySyncServer(options, customizedConfig).addRoutes(routes.toList).start()) Resource .make(bind.map(b => (b.port, IO.blocking(b.stop())))) { case (_, stop) => stop }