Clean up the deprecation warnings

Author: rossabaker

README.md

@@ -5,10 +5,10 @@ Scala's answer to Ruby's Rack, Python's WSGI, Haskell's WAI, and Java's
 Servlets.
 
 ```scala
-val service = HttpService {
-    case GET -> Root / "hello" =>
-      Ok("Hello, better world.")
-  }
+val http = HttpRoutes.of {
+  case GET -> Root / "hello" =>
+    Ok("Hello, better world.")
+}
 ```
 
 Learn more at [http4s.org](http://http4s.org/).

blaze-server/src/main/scala/org/http4s/server/blaze/BlazeBuilder.scala

@@ -124,7 +124,7 @@ class BlazeBuilder[F[_]](
 
   def enableHttp2(enabled: Boolean): Self = copy(http2Support = enabled)
 
-  override def mountService(service: HttpService[F], prefix: String): Self = {
+  override def mountService(service: HttpRoutes[F], prefix: String): Self = {
     val prefixedService =
       if (prefix.isEmpty || prefix == "/") service
       else {
@@ -310,4 +310,4 @@ object BlazeBuilder {
     )
 }
 
-private final case class ServiceMount[F[_]](service: HttpService[F], prefix: String)
+private final case class ServiceMount[F[_]](service: HttpRoutes[F], prefix: String)

blaze-server/src/main/scala/org/http4s/server/blaze/Http1ServerStage.scala

@@ -23,7 +23,7 @@ import scala.util.{Either, Failure, Left, Right, Success, Try}
 private[blaze] object Http1ServerStage {
 
   def apply[F[_]: Effect](
-      service: HttpService[F],
+      routes: HttpRoutes[F],
       attributes: AttributeMap,
       executionContext: ExecutionContext,
       enableWebSockets: Boolean,
@@ -32,15 +32,15 @@ private[blaze] object Http1ServerStage {
       serviceErrorHandler: ServiceErrorHandler[F]): Http1ServerStage[F] =
     if (enableWebSockets)
       new Http1ServerStage(
-        service,
+        routes,
         attributes,
         executionContext,
         maxRequestLineLen,
         maxHeadersLen,
         serviceErrorHandler) with WebSocketSupport[F]
     else
       new Http1ServerStage(
-        service,
+        routes,
         attributes,
         executionContext,
         maxRequestLineLen,
@@ -49,7 +49,7 @@ private[blaze] object Http1ServerStage {
 }
 
 private[blaze] class Http1ServerStage[F[_]](
-    service: HttpService[F],
+    routes: HttpRoutes[F],
     requestAttrs: AttributeMap,
     implicit protected val executionContext: ExecutionContext,
     maxRequestLineLen: Int,
@@ -58,8 +58,8 @@ private[blaze] class Http1ServerStage[F[_]](
     extends Http1Stage[F]
     with TailStage[ByteBuffer] {
 
-  // micro-optimization: unwrap the service and call its .run directly
-  private[this] val serviceFn = service.run
+  // micro-optimization: unwrap the routes and call its .run directly
+  private[this] val routesFn = routes.run
 
   // both `parser` and `isClosed` are protected by synchronization on `parser`
   private[this] val parser = new Http1ServerParser[F](logger, maxRequestLineLen, maxHeadersLen)
@@ -142,7 +142,7 @@ private[blaze] class Http1ServerStage[F[_]](
         executionContext.execute(new Runnable {
           def run(): Unit =
             F.runAsync {
-                try serviceFn(req)
+                try routesFn(req)
                   .getOrElse(Response.notFound)
                   .handleErrorWith(serviceErrorHandler(req))
                 catch serviceErrorHandler(req)

blaze-server/src/main/scala/org/http4s/server/blaze/Http2NodeStage.scala

@@ -26,7 +26,7 @@ private class Http2NodeStage[F[_]](
     timeout: Duration,
     implicit private val executionContext: ExecutionContext,
     attributes: AttributeMap,
-    service: HttpService[F],
+    service: HttpRoutes[F],
     serviceErrorHandler: ServiceErrorHandler[F])(implicit F: Effect[F])
     extends TailStage[NodeMsg.Http2Msg] {
 

blaze-server/src/main/scala/org/http4s/server/blaze/ProtocolSelector.scala

@@ -14,7 +14,7 @@ import scala.concurrent.duration.Duration
 private[blaze] object ProtocolSelector {
   def apply[F[_]: Effect](
       engine: SSLEngine,
-      service: HttpService[F],
+      routes: HttpRoutes[F],
       maxRequestLineLen: Int,
       maxHeadersLen: Int,
       requestAttributes: AttributeMap,
@@ -30,7 +30,7 @@ private[blaze] object ProtocolSelector {
             Duration.Inf,
             executionContext,
             requestAttributes,
-            service,
+            routes,
             serviceErrorHandler))
       }
 
@@ -46,7 +46,7 @@ private[blaze] object ProtocolSelector {
 
     def http1Stage(): TailStage[ByteBuffer] =
       Http1ServerStage[F](
-        service,
+        routes,
         requestAttributes,
         executionContext,
         enableWebSockets = false,

blaze-server/src/test/scala/org/http4s/server/blaze/Http1ServerStageSpec.scala

@@ -33,13 +33,13 @@ class Http1ServerStageSpec extends Http4sSpec {
 
   def runRequest(
       req: Seq[String],
-      service: HttpService[IO],
+      routes: HttpRoutes[IO],
       maxReqLine: Int = 4 * 1024,
       maxHeaders: Int = 16 * 1024): Future[ByteBuffer] = {
     val head = new SeqTestHead(
       req.map(s => ByteBuffer.wrap(s.getBytes(StandardCharsets.ISO_8859_1))))
     val httpStage = Http1ServerStage[IO](
-      service,
+      routes,
       AttributeMap.empty,
       testExecutionContext,
       enableWebSockets = true,
@@ -55,19 +55,19 @@ class Http1ServerStageSpec extends Http4sSpec {
   "Http1ServerStage: Invalid Lengths" should {
     val req = "GET /foo HTTP/1.1\r\nheader: value\r\n\r\n"
 
-    val service = HttpService[IO] {
+    val routes = HttpRoutes.of[IO] {
       case _ => Ok("foo!")
     }
 
     "fail on too long of a request line" in {
-      val buff = Await.result(runRequest(Seq(req), service, maxReqLine = 1), 5.seconds)
+      val buff = Await.result(runRequest(Seq(req), routes, maxReqLine = 1), 5.seconds)
       val str = StandardCharsets.ISO_8859_1.decode(buff.duplicate()).toString
       // make sure we don't have signs of chunked encoding.
       str.contains("400 Bad Request") must_== true
     }
 
     "fail on too long of a header" in {
-      val buff = Await.result(runRequest(Seq(req), service, maxHeaders = 1), 5.seconds)
+      val buff = Await.result(runRequest(Seq(req), routes, maxHeaders = 1), 5.seconds)
       val str = StandardCharsets.ISO_8859_1.decode(buff.duplicate()).toString
       // make sure we don't have signs of chunked encoding.
       str.contains("400 Bad Request") must_== true
@@ -90,7 +90,7 @@ class Http1ServerStageSpec extends Http4sSpec {
   }
 
   "Http1ServerStage: Errors" should {
-    val exceptionService = HttpService[IO] {
+    val exceptionService = HttpRoutes.of[IO] {
       case GET -> Root / "sync" => sys.error("Synchronous error!")
       case GET -> Root / "async" => IO.raiseError(new Exception("Asynchronous error!"))
       case GET -> Root / "sync" / "422" =>
@@ -148,7 +148,7 @@ class Http1ServerStageSpec extends Http4sSpec {
 
   "Http1ServerStage: routes" should {
     "Do not send `Transfer-Encoding: identity` response" in {
-      val service = HttpService[IO] {
+      val routes = HttpRoutes.of[IO] {
         case _ =>
           val headers = Headers(H.`Transfer-Encoding`(TransferCoding.identity))
           IO.pure(
@@ -159,7 +159,7 @@ class Http1ServerStageSpec extends Http4sSpec {
       // The first request will get split into two chunks, leaving the last byte off
       val req = "GET /foo HTTP/1.1\r\n\r\n"
 
-      val buff = Await.result(runRequest(Seq(req), service), 5.seconds)
+      val buff = Await.result(runRequest(Seq(req), routes), 5.seconds)
 
       val str = StandardCharsets.ISO_8859_1.decode(buff.duplicate()).toString
       // make sure we don't have signs of chunked encoding.
@@ -171,7 +171,7 @@ class Http1ServerStageSpec extends Http4sSpec {
     }
 
     "Do not send an entity or entity-headers for a status that doesn't permit it" in {
-      val service: HttpService[IO] = HttpService[IO] {
+      val routes: HttpRoutes[IO] = HttpRoutes.of[IO] {
         case _ =>
           IO.pure(
             Response[IO](status = Status.NotModified)
@@ -181,7 +181,7 @@ class Http1ServerStageSpec extends Http4sSpec {
 
       val req = "GET /foo HTTP/1.1\r\n\r\n"
 
-      val buf = Await.result(runRequest(Seq(req), service), 5.seconds)
+      val buf = Await.result(runRequest(Seq(req), routes), 5.seconds)
       val (status, hs, body) = ResponseParser.parseBuffer(buf)
 
       val hss = Headers(hs.toList)
@@ -191,14 +191,14 @@ class Http1ServerStageSpec extends Http4sSpec {
     }
 
     "Add a date header" in {
-      val service = HttpService[IO] {
+      val routes = HttpRoutes.of[IO] {
         case req => IO.pure(Response(body = req.body))
       }
 
       // The first request will get split into two chunks, leaving the last byte off
       val req1 = "POST /sync HTTP/1.1\r\nConnection:keep-alive\r\nContent-Length: 4\r\n\r\ndone"
 
-      val buff = Await.result(runRequest(Seq(req1), service), 5.seconds)
+      val buff = Await.result(runRequest(Seq(req1), routes), 5.seconds)
 
       // Both responses must succeed
       val (_, hdrs, _) = ResponseParser.apply(buff)
@@ -207,14 +207,14 @@ class Http1ServerStageSpec extends Http4sSpec {
 
     "Honor an explicitly added date header" in {
       val dateHeader = Date(HttpDate.Epoch)
-      val service = HttpService[IO] {
+      val routes = HttpRoutes.of[IO] {
         case req => IO.pure(Response(body = req.body).replaceAllHeaders(dateHeader))
       }
 
       // The first request will get split into two chunks, leaving the last byte off
       val req1 = "POST /sync HTTP/1.1\r\nConnection:keep-alive\r\nContent-Length: 4\r\n\r\ndone"
 
-      val buff = Await.result(runRequest(Seq(req1), service), 5.seconds)
+      val buff = Await.result(runRequest(Seq(req1), routes), 5.seconds)
 
       // Both responses must succeed
       val (_, hdrs, _) = ResponseParser.apply(buff)
@@ -223,22 +223,22 @@ class Http1ServerStageSpec extends Http4sSpec {
     }
 
     "Handle routes that echos full request body for non-chunked" in {
-      val service = HttpService[IO] {
+      val routes = HttpRoutes.of[IO] {
         case req => IO.pure(Response(body = req.body))
       }
 
       // The first request will get split into two chunks, leaving the last byte off
       val req1 = "POST /sync HTTP/1.1\r\nConnection:keep-alive\r\nContent-Length: 4\r\n\r\ndone"
       val (r11, r12) = req1.splitAt(req1.length - 1)
 
-      val buff = Await.result(runRequest(Seq(r11, r12), service), 5.seconds)
+      val buff = Await.result(runRequest(Seq(r11, r12), routes), 5.seconds)
 
       // Both responses must succeed
       parseAndDropDate(buff) must_== ((Ok, Set(H.`Content-Length`.unsafeFromLong(4)), "done"))
     }
 
     "Handle routes that consumes the full request body for non-chunked" in {
-      val service = HttpService[IO] {
+      val routes = HttpRoutes.of[IO] {
         case req =>
           req.as[String].map { s =>
             Response().withEntity("Result: " + s)
@@ -249,7 +249,7 @@ class Http1ServerStageSpec extends Http4sSpec {
       val req1 = "POST /sync HTTP/1.1\r\nConnection:keep-alive\r\nContent-Length: 4\r\n\r\ndone"
       val (r11, r12) = req1.splitAt(req1.length - 1)
 
-      val buff = Await.result(runRequest(Seq(r11, r12), service), 5.seconds)
+      val buff = Await.result(runRequest(Seq(r11, r12), routes), 5.seconds)
 
       // Both responses must succeed
       parseAndDropDate(buff) must_== (
@@ -263,15 +263,15 @@ class Http1ServerStageSpec extends Http4sSpec {
 
     "Maintain the connection if the body is ignored but was already read to completion by the Http1Stage" in {
 
-      val service = HttpService[IO] {
+      val routes = HttpRoutes.of[IO] {
         case _ => IO.pure(Response().withEntity("foo"))
       }
 
       // The first request will get split into two chunks, leaving the last byte off
       val req1 = "POST /sync HTTP/1.1\r\nConnection:keep-alive\r\nContent-Length: 4\r\n\r\ndone"
       val req2 = "POST /sync HTTP/1.1\r\nConnection:keep-alive\r\nContent-Length: 5\r\n\r\ntotal"
 
-      val buff = Await.result(runRequest(Seq(req1, req2), service), 5.seconds)
+      val buff = Await.result(runRequest(Seq(req1, req2), routes), 5.seconds)
 
       val hs = Set(
         H.`Content-Type`(MediaType.`text/plain`, Charset.`UTF-8`),
@@ -283,7 +283,7 @@ class Http1ServerStageSpec extends Http4sSpec {
 
     "Drop the connection if the body is ignored and was not read to completion by the Http1Stage" in {
 
-      val service = HttpService[IO] {
+      val routes = HttpRoutes.of[IO] {
         case _ => IO.pure(Response().withEntity("foo"))
       }
 
@@ -293,7 +293,7 @@ class Http1ServerStageSpec extends Http4sSpec {
 
       val req2 = "POST /sync HTTP/1.1\r\nConnection:keep-alive\r\nContent-Length: 5\r\n\r\ntotal"
 
-      val buff = Await.result(runRequest(Seq(r11, r12, req2), service), 5.seconds)
+      val buff = Await.result(runRequest(Seq(r11, r12, req2), routes), 5.seconds)
 
       val hs = Set(
         H.`Content-Type`(MediaType.`text/plain`, Charset.`UTF-8`),
@@ -305,7 +305,7 @@ class Http1ServerStageSpec extends Http4sSpec {
 
     "Handle routes that runs the request body for non-chunked" in {
 
-      val service = HttpService[IO] {
+      val routes = HttpRoutes.of[IO] {
         case req => req.body.compile.drain *> IO.pure(Response().withEntity("foo"))
       }
 
@@ -314,7 +314,7 @@ class Http1ServerStageSpec extends Http4sSpec {
       val (r11, r12) = req1.splitAt(req1.length - 1)
       val req2 = "POST /sync HTTP/1.1\r\nConnection:keep-alive\r\nContent-Length: 5\r\n\r\ntotal"
 
-      val buff = Await.result(runRequest(Seq(r11, r12, req2), service), 5.seconds)
+      val buff = Await.result(runRequest(Seq(r11, r12, req2), routes), 5.seconds)
 
       val hs = Set(
         H.`Content-Type`(MediaType.`text/plain`, Charset.`UTF-8`),
@@ -327,7 +327,7 @@ class Http1ServerStageSpec extends Http4sSpec {
     // Think of this as drunk HTTP pipelining
     "Not die when two requests come in back to back" in {
 
-      val service = HttpService[IO] {
+      val routes = HttpRoutes.of[IO] {
         case req =>
           IO.pure(Response(body = req.body))
       }
@@ -336,7 +336,7 @@ class Http1ServerStageSpec extends Http4sSpec {
       val req1 = "POST /sync HTTP/1.1\r\nConnection:keep-alive\r\nContent-Length: 4\r\n\r\ndone"
       val req2 = "POST /sync HTTP/1.1\r\nConnection:keep-alive\r\nContent-Length: 5\r\n\r\ntotal"
 
-      val buff = Await.result(runRequest(Seq(req1 + req2), service), 5.seconds)
+      val buff = Await.result(runRequest(Seq(req1 + req2), routes), 5.seconds)
 
       // Both responses must succeed
       dropDate(ResponseParser.parseBuffer(buff)) must_== (
@@ -353,15 +353,15 @@ class Http1ServerStageSpec extends Http4sSpec {
 
     "Handle using the request body as the response body" in {
 
-      val service = HttpService[IO] {
+      val routes = HttpRoutes.of[IO] {
         case req => IO.pure(Response(body = req.body))
       }
 
       // The first request will get split into two chunks, leaving the last byte off
       val req1 = "POST /sync HTTP/1.1\r\nConnection:keep-alive\r\nContent-Length: 4\r\n\r\ndone"
       val req2 = "POST /sync HTTP/1.1\r\nConnection:keep-alive\r\nContent-Length: 5\r\n\r\ntotal"
 
-      val buff = Await.result(runRequest(Seq(req1, req2), service), 5.seconds)
+      val buff = Await.result(runRequest(Seq(req1, req2), routes), 5.seconds)
 
       // Both responses must succeed
       dropDate(ResponseParser.parseBuffer(buff)) must_== (
@@ -384,7 +384,7 @@ class Http1ServerStageSpec extends Http4sSpec {
           "0\r\n" +
           "Foo:Bar\r\n\r\n"
 
-      val service = HttpService[IO] {
+      val routes = HttpRoutes.of[IO] {
         case req if req.pathInfo == "/foo" =>
           for {
             _ <- req.body.compile.drain
@@ -402,15 +402,15 @@ class Http1ServerStageSpec extends Http4sSpec {
       }
 
       "Handle trailing headers" in {
-        val buff = Await.result(runRequest(Seq(req("foo")), service), 5.seconds)
+        val buff = Await.result(runRequest(Seq(req("foo")), routes), 5.seconds)
 
         val results = dropDate(ResponseParser.parseBuffer(buff))
         results._1 must_== Ok
         results._3 must_== "Foo: Bar"
       }
 
       "Fail if you use the trailers before they have resolved" in {
-        val buff = Await.result(runRequest(Seq(req("bar")), service), 5.seconds)
+        val buff = Await.result(runRequest(Seq(req("bar")), routes), 5.seconds)
 
         val results = dropDate(ResponseParser.parseBuffer(buff))
         results._1 must_== InternalServerError