Akka-HTTP backend

build.sbt

@@ -319,6 +319,27 @@ lazy val `play-ahc-ws-standalone` = project
     `shaded`
   ).disablePlugins(sbtassembly.AssemblyPlugin)
 
+//---------------------------------------------------------------
+// Akka Http implementation of WS
+//---------------------------------------------------------------
+
+lazy val `play-akka-http-ws-standalone` = project
+  .in(file("play-akka-http-ws-standalone"))
+  .settings(commonSettings)
+  .settings(formattingSettings)
+  .settings(
+    fork in Test := true,
+    testOptions in Test := Seq(Tests.Argument(TestFrameworks.JUnit, "-a", "-v"))
+  )
+  .settings(
+    // The scaladoc generation
+  )
+  .settings(libraryDependencies ++= standaloneAkkaHttpWSDependencies)
+  .dependsOn(
+    `play-ws-standalone`
+  )
+  .disablePlugins(sbtassembly.AssemblyPlugin)
+
 //---------------------------------------------------------------
 // JSON Readables and Writables
 //---------------------------------------------------------------
@@ -380,6 +401,7 @@ lazy val `integration-tests` = project.in(file("integration-tests"))
   .settings(shadedOAuthSettings)
   .dependsOn(
     `play-ahc-ws-standalone`,
+    `play-akka-http-ws-standalone`,
     `play-ws-standalone-json`,
     `play-ws-standalone-xml`
   )
@@ -402,6 +424,7 @@ lazy val root = project
     `play-ws-standalone-json`,
     `play-ws-standalone-xml`,
     `play-ahc-ws-standalone`,
+    `play-akka-http-ws-standalone`,
     `integration-tests`
   )
   .disablePlugins(sbtassembly.AssemblyPlugin)

integration-tests/src/test/resources/README.md

@@ -0,0 +1 @@
+The `rootCA.crt` and `server.p12` have been taken from [Akka Http Tls Tests Keys](https://github.com/akka/akka-http/tree/v10.0.11/akka-http-core/src/test/resources/keys).

integration-tests/src/test/resources/rootCA.crt

@@ -0,0 +1,21 @@
+-----BEGIN CERTIFICATE-----
+MIIDXTCCAkWgAwIBAgIJANYwx08wP3STMA0GCSqGSIb3DQEBCwUAMEUxCzAJBgNV
+BAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRlcm5ldCBX
+aWRnaXRzIFB0eSBMdGQwHhcNMTUwNzIzMDk0ODI2WhcNMjUwNDIxMDk0ODI2WjBF
+MQswCQYDVQQGEwJBVTETMBEGA1UECAwKU29tZS1TdGF0ZTEhMB8GA1UECgwYSW50
+ZXJuZXQgV2lkZ2l0cyBQdHkgTHRkMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIB
+CgKCAQEArk0K/Rn7uND2YGFBks5Sok1WvNdHQccPESEw2hNVF32ExAhbBXCrFaIl
+Io0q4eYSbypeauEjDXB/NJXurEefL8ONXK62erJDKKQ0aTTYqsVifoNYA9ORWoGE
+XhtAfOx4xvzr6vF1e3kz0PB/A4ftn0vvVygYnf/2E2bQZgaw8dXP5lIGasEzzigB
+LX/qTEW/vBOL98Rxp6JvjwvYMbPSZGwNwSz+tI5W2psdE1Mga2Qnsv3j+STWlD9v
++JlgdN8r3PyR1sl3jC7gCj3AaOhv4RbAbqjwnZ9nrckx16PFiMtJiVRea7CQXN7g
+191EVujQnlg1LOhiSMKwVsuoXr08ywIDAQABo1AwTjAdBgNVHQ4EFgQU2THI/ilU
+M0xds3vZlV4CvhAZ1d8wHwYDVR0jBBgwFoAU2THI/ilUM0xds3vZlV4CvhAZ1d8w
+DAYDVR0TBAUwAwEB/zANBgkqhkiG9w0BAQsFAAOCAQEAK9LO0HyIi0xbTISsc+A5
+LQyZowgRAGqsNNmni7NKDXauPLZrCfDVhvo/FPP1XSFShXo7ARvro9lul4AJlkNN
+VgX0gbWtkiAx0uLqlbMsC6imj2L9boRse7mzI/Ymem5SNTn9GUnlMiZ74rca9UT4
+Dk9YytrT4FSpomiL6z8Xj604W3RuLSdEfpfcn3Jh2tFSZ9hyLwB7ATUTA/yuj1SU
+G1gmoPMvlnPzNj2lIqyIdQxGdxt+L3mFO20CxBkeieWqQuNptpjwptliFjkZJJZP
+wQlx9qLLvs/eFC2AUWj+hbsl37PuARR9hoeqbKRcUjwGtaXOqikrvX1qzPc2+ij9
+/w==
+-----END CERTIFICATE-----

integration-tests/src/test/scala/akka/io/AkkaExampleOrgToLocalhostDnsProvider.scala

@@ -0,0 +1,15 @@
+package akka.io
+
+import java.net.InetAddress
+
+import scala.concurrent.duration._
+
+class AkkaExampleOrgToLocalhostDnsProvider extends DnsProvider {
+  override def cache: Dns = {
+    val cache = new SimpleDnsCache()
+    cache.put(Dns.Resolved("akka.example.org", Seq(InetAddress.getByName("127.0.0.1"))), 1.hour.toMillis)
+    cache
+  }
+  override def actorClass = classOf[InetAddressDnsResolver]
+  override def managerClass = classOf[SimpleDnsManager]
+}

integration-tests/src/test/scala/play/AkkaServerProvider.scala

@@ -3,10 +3,17 @@
  */
 package play
 
+import java.io.InputStream
+import java.net.{ InetAddress, UnknownHostException }
+import java.security.cert.CertificateFactory
+import java.security.{ KeyStore, SecureRandom }
+import javax.net.ssl.{ KeyManagerFactory, SSLContext, SSLParameters, TrustManagerFactory }
+
 import akka.actor.ActorSystem
-import akka.http.scaladsl.Http
+import akka.http.scaladsl.{ Http, HttpsConnectionContext }
 import akka.http.scaladsl.server.Route
 import akka.stream.ActorMaterializer
+import com.typesafe.config.ConfigFactory
 import org.specs2.concurrent.ExecutionEnv
 import org.specs2.specification.BeforeAfterAll
 
@@ -26,29 +33,79 @@ trait AkkaServerProvider extends BeforeAfterAll {
   def executionEnv: ExecutionEnv
 
   var testServerPort: Int = _
+  var testServerPortHttps: Int = _
   val defaultTimeout: FiniteDuration = 5.seconds
 
   // Create Akka system for thread and streaming management
-  implicit val system = ActorSystem()
+  implicit val system = ActorSystem("AkkaServerProvider", ConfigFactory.parseString(
+    s"""
+       |akka.io.dns.inet-address.provider-object = ${classOf[akka.io.AkkaExampleOrgToLocalhostDnsProvider].getName}
+     """.stripMargin).withFallback(ConfigFactory.load()))
   implicit val materializer = ActorMaterializer()
 
-  lazy val futureServer: Future[Http.ServerBinding] = {
+  lazy val futureServer: Future[Seq[Http.ServerBinding]] = {
+    implicit val ec = executionEnv.executionContext
+
     // Using 0 (zero) means that a random free port will be used.
     // So our tests can run in parallel and won't mess with each other.
-    Http().bindAndHandle(routes, "localhost", 0)
+    val httpBinding = Http().bindAndHandle(routes, "localhost", 0)
+      .map { b => testServerPort = b.localAddress.getPort; b }
+    val httpsBinding = Http().bindAndHandle(routes, "localhost", 0, connectionContext = serverHttpContext())
+      .map { b => testServerPortHttps = b.localAddress.getPort; b }
+
+    Future.sequence(Seq(httpBinding, httpBinding))
   }
 
   override def beforeAll(): Unit = {
-    val portFuture = futureServer.map(_.localAddress.getPort)(executionEnv.executionContext)
-    portFuture.onSuccess {
-      case port => testServerPort = port
-    }(executionEnv.executionContext)
-    Await.ready(portFuture, defaultTimeout)
+    implicit val ec = executionEnv.executionContext
+    Await.ready(futureServer, defaultTimeout)
   }
 
   override def afterAll(): Unit = {
-    futureServer.foreach(_.unbind())(executionEnv.executionContext)
+    futureServer.foreach(_.foreach(_.unbind()))(executionEnv.executionContext)
     val terminate = system.terminate()
     Await.ready(terminate, defaultTimeout)
   }
-}
+
+  private def serverHttpContext() = {
+    // never put passwords into code!
+    val password = "abcdef".toCharArray
+
+    val ks = KeyStore.getInstance("PKCS12")
+    ks.load(resourceStream("server.p12"), password)
+
+    val keyManagerFactory = KeyManagerFactory.getInstance("SunX509")
+    keyManagerFactory.init(ks, password)
+
+    val context = SSLContext.getInstance("TLS")
+    context.init(keyManagerFactory.getKeyManagers, null, new SecureRandom)
+
+    new HttpsConnectionContext(context)
+  }
+
+  def clientHttpsContext() = {
+    val certStore = KeyStore.getInstance(KeyStore.getDefaultType)
+    certStore.load(null, null)
+    // only do this if you want to accept a custom root CA. Understand what you are doing!
+    certStore.setCertificateEntry("ca", loadX509Certificate("rootCA.crt"))
+
+    val certManagerFactory = TrustManagerFactory.getInstance("SunX509")
+    certManagerFactory.init(certStore)
+
+    val context = SSLContext.getInstance("TLS")
+    context.init(null, certManagerFactory.getTrustManagers, new SecureRandom)
+
+    val params = new SSLParameters()
+    params.setEndpointIdentificationAlgorithm("https")
+    new HttpsConnectionContext(context, sslParameters = Some(params))
+  }
+
+  private def resourceStream(resourceName: String): InputStream = {
+    val is = getClass.getClassLoader.getResourceAsStream(resourceName)
+    require(is ne null, s"Resource $resourceName not found")
+    is
+  }
+
+  private def loadX509Certificate(resourceName: String) =
+    CertificateFactory.getInstance("X.509").generateCertificate(resourceStream(resourceName))
+}