Spray(12)spray-can - Http Client HttpDialog and Spray Client

Spray(12)spray-can - Http Client HttpDialog and Spray Client

3. HttpClient
HttpsExample
The difference between Http and Https for HttpDialog is that, what tags we bring to it.

val responseFuture =
     HttpDialog(httpClient, "github.com", port = 443, HttpClient.SslEnabled)
     .send(HttpRequest(uri = "/spray/spray"))
     .end

Google Query Example
Check all the configuration in spray-can/src/main/resources/reference.conf

What I need to for the spray-can is as follow:
spray.can {
  client {
     idle-timeout = 60 s
     request-timeout = 30 s
  }
  server {
request-timeout = 50s
}

}


We can do the requests in queue.

4. Http Dialog
package com.sillycat.easyspray.httpdialog

import java.util.concurrent.TimeUnit._
import scala.concurrent.Future
import scala.concurrent.duration.Duration
import spray.can.client.{ HttpDialog, HttpClient }
import spray.io._
import spray.http._
import HttpMethods._
import akka.actor.ActorSystem
import akka.actor.Props
import spray.httpx.RequestBuilding._

object SimpleExampleApp extends App {

  implicit valsystem = ActorSystem("simple-example")
  import system.log

  //different way to get the httpClient object
  val ioBridge = IOExtension(system).ioBridge()
  val client = system.actorOf(Props(new HttpClient(ioBridge)))

  //simple request
  val response: Future[HttpResponse] =
    HttpDialog(client, "www.google.com", 80)
      .send(HttpRequest(method = GET, uri = "/"))
      .end
  //multiple requests, fire one by one
  val responses1: Future[Seq[HttpResponse]] =
    HttpDialog(client, "www.google.com", 80)
      .send(Post("/shout", "yeah!"))
      .awaitResponse
      .send(Put("/count", "42"))
      .end

  //multiple requests, fire at same time
  val responses2: Future[Seq[HttpResponse]] =
    HttpDialog(client, "www.google.com", 80)
      .send(Get("/img/a.gif"))
      .send(Get("/img/b.gif"))
      .send(Get("/img/c.gif"))
      .end

  //multiple requests, fire follow this request -> response ->request
  val response3: Future[HttpResponse] =
    HttpDialog(client, "www.google.com", 80)
      .send(Get("/ping"))
      .reply(response => Get("/ping2", response.entity))
      .end

}

5. Spray Client
The default configuration file will be spray-client/src/main/resources/reference.conf

My first Simplest Example
package com.sillycat.easyspray.sprayclient

import spray.client._
import scala.concurrent.Future
import akka.actor._
import spray.can.client.HttpClient
import spray.client.HttpConduit
import spray.io._
import spray.util._
import spray.http._
import HttpMethods._
import scala.util.{Success, Failure}
import scala.concurrent.duration._
import akka.actor.{Props, ActorSystem}
import akka.pattern.ask
import akka.util.Timeout
import akka.event.Logging
import spray.json.{JsonFormat, DefaultJsonProtocol}
import spray.httpx.SprayJsonSupport
import spray.http._
import spray.util._

object SprayClientApp extends App  {

  implicit val system = ActorSystem()
  val ioBridge = IOExtension(system).ioBridge()
  val httpClient = system.actorOf(Props(new HttpClient(ioBridge)))

  val conduit = system.actorOf(
    props = Props(new HttpConduit(httpClient, "maps.googleapis.com", 80)),
    name = "http-conduit")
   
  val pipeline = HttpConduit.sendReceive(conduit)
 
  val response: Future[HttpResponse] = pipeline(HttpRequest(method = GET, uri = "/maps/api/elevation/json?locations=27.988056,86.925278&sensor=false"))

  response onComplete {
    case Success(responseContent) =>
      println("The elevation of Mt. Everest is: {} m" + responseContent)
      shutdown()

    case Failure(error) =>
      println("Couldn't get elevation")
      shutdown()
  }

  def shutdown(): Unit = {
    system.shutdown()
  }


}

Let's take a look at the the Example from official website
First of all, the json Marshall things.
package com.sillycat.easyspray.sprayclient.version11m7

import spray.json.{JsonFormat, DefaultJsonProtocol}


case class Elevation(location: Location, elevation: Double)
case class Location(lat: Double, lng: Double)
case class GoogleApiResult[T](status: String, results: List[T])

object ElevationJsonProtocol extends DefaultJsonProtocol {
  implicit val locationFormat = jsonFormat2(Location)
  implicit val elevationFormat = jsonFormat2(Elevation)
  implicit def googleApiResultFormat[T :JsonFormat] = jsonFormat2(GoogleApiResult.apply[T])

}

Here is the main part.
package com.sillycat.easyspray.sprayclient.version11m7

import scala.util.{Success, Failure}
import akka.actor.{Props, ActorSystem}
import spray.can.client.DefaultHttpClient
import spray.client.HttpConduit
import spray.httpx.SprayJsonSupport
import spray.http._
import spray.util._


object Main extends App {
  // we need an ActorSystem to host our application in
  implicit val system = ActorSystem("simple-spray-client")
  import system.log

  // create and start the default spray-can HttpClient
  val httpClient = DefaultHttpClient(system)

  startExample1()

  def startExample1() {
    log.info("Getting http://github.com ...")
    // an HttpConduit gives us access to an HTTP server,
    // it manages a pool of connections to _one_ host/port combination
    // Get a Conduit
    val conduit = system.actorOf(
      props = Props(new HttpConduit(httpClient, "github.com")),
      name = "http-conduit-1"
    )

    // send a simple request
    val pipeline = HttpConduit.sendReceive(conduit)
    val responseFuture = pipeline(HttpRequest(method = HttpMethods.GET, uri = "/"))
    responseFuture onComplete {
      case Success(response) =>
        log.info(
          """|Response for GET request to github.com:
             |status : {}
             |headers: {}
             |body   : {}""".stripMargin,
          response.status.value, response.headers.mkString("\n  ", "\n  ", ""), response.entity.asString
        )
        system.stop(conduit) // the conduit can be stopped when all operations on it have been completed
        startExample2()

      case Failure(error) =>
        log.error(error, "Couldn't get http://github.com")
        system.shutdown() // also stops all conduits (since they are actors)
    }
  }

  //Build the Second conduit
  def startExample2() {
    log.info("Requesting the elevation of Mt. Everest from Googles Elevation API...")
    val conduit = system.actorOf(
      props = Props(new HttpConduit(httpClient, "maps.googleapis.com")),
      name = "http-conduit-2"
    )

    import HttpConduit._
    import ElevationJsonProtocol._
    import SprayJsonSupport._


    //send the request and unmarshal
    val pipeline = sendReceive(conduit) ~> unmarshal[GoogleApiResult[Elevation]]

    val responseF = pipeline(Get("/maps/api/elevation/json?locations=27.988056,86.925278&sensor=false"))
    responseF onComplete {
      case Success(response) =>
        log.info("The elevation of Mt. Everest is: {} m", response.results.head.elevation)
        system.shutdown() // also stops all conduits (since they are actors)

      case Failure(error) =>
        log.error(error, "Couldn't get elevation")
        system.shutdown() // also stops all conduits (since they are actors)
    }
  }

}

Some other magic Not in the Example

case class Order(id: Int)
case class OrderConfirmation(id: Int)

object MyJsonProtocol extends DefaultJsonProtocol {
  implicit val orderFormat = jsonFormat1(Order)
  implicit val orderConfirmationFormat = jsonFormat1(OrderConfirmation)
}

import HttpConduit._
import MyJsonProtocol._

val pipeline: HttpRequest => Future[OrderConfirmation] = (
  addHeader("X-My-Special-Header", "fancy-value")
  ~> addCredentials(BasicHttpCredentials("bob", "secret"))
  ~> encode(Gzip)
  ~> sendReceive(conduit)
  ~> decode(Deflate)
  ~> unmarshal[OrderConfirmation]
)
val confirmation: Future[OrderConfirmation] =
  pipeline(Post("/orders", Order(42))

Till now, I got everything from the document. I plan to integrate that in the project.

Tips:

References:
spray(12)spray-can - Http Client
http://sillycat.iteye.com/blog/1882919

Http Dialog
http://spray.io/documentation/spray-can/http-dialog/