Return exact response/header?

Question

From the client-side of a webapp, I hit a server-side route which is just a wrapper for a third-party API. Using dispatch, I am trying to make that server-side request return the exact header and response of the third-party API to the client-side AJAX call.

When I do this:

val req = host("third-pary.api.com, 80)
val post = req.as("user", "pass") / "route" << Map("key" -> "akey", "val" -> "aval")
Http(post > as.String)

I always see a 200 response returned to the AJAX call (kind of expectedly). I have seen an Either syntax used, but I'm really more of an Any, as it's just the exact response and header. How would this be written?

I should mention I'm using Scalatra on the server-side, so the local route is:

post("/route") {

}

EDIT:

Here is the suggested Either matching example, which I'm playing with, but the match syntax doesn't make sense - I don't care if there is an error, I just want to return it. Also, I can't seem to get the BODY returned with this method.

val asHeaders = as.Response { response =>
  println("BODY: " + response.getResponseBody())
  scala.collection.JavaConverters.mapAsScalaMapConverter(
    response.getHeaders).asScala.toMap.mapValues(_.asScala.toList)
}

val response: Either[Throwable, Map[String, List[String]]] =
  Http(post > asHeaders).either()

response match {
  case Left(wrong) =>
    println("Left: " + wrong.getMessage())
    // return Action with header + body
  case Right(good) =>
    println("Right: " + good)
    // return Action with header + body
}

Ideally, the solutions returns the Scalatra ActionResult(responseStatus(status, reason), body, headers).

In response to your edit: I personally tend to use `Either` even in cases where I don't care about fancy error handling. Just write `response.right.get` and you've unwrapped the headers (at the risk of a runtime exception). And then when you find yourself reusing this code and wanting something more robust, it's simple to see exactly where you've sinned. — Travis Brown, Nov 30 '12 at 22:15

score 5 · Answer 1 · answered Nov 30 '12 at 20:54

It's actually very easy to get response headers while using Dispatch. For example with 0.9.4:

import dispatch._
import scala.collection.JavaConverters._

val headers: java.util.Map[String, java.util.List[String]] = Http(
   url("http://www.google.com")
)().getHeaders

And now, for example:

scala> headers.asScala.mapValues(_.asScala).foreach {
     |   case (k, v) => println(k + ": " + v)
     | }
X-Frame-Options: Buffer(SAMEORIGIN)
Transfer-Encoding: Buffer(chunked)
Date: Buffer(Fri, 30 Nov 2012 20:42:45 GMT)
...

If you do this often it's better to encapsulate it, like this, for example:

val asHeaders = as.Response { response =>
  scala.collection.JavaConverters.mapAsScalaMapConverter(
    response.getHeaders
  ).asScala.toMap.mapValues(_.asScala.toList)
}

Now you can write the following:

val response: Either[Throwable, Map[String, List[String]]] =
  Http(url("http://www.google.com") OK asHeaders).either()

And you've got error checking, nice immutable collections, etc.

The thing is, I don't need to match on Left or Right, which is why Either doesn't make sense. I just want to return a response to the client-side from the third-party with the same headers and body returned to the server-side. — , Nov 30 '12 at 21:55
It's not a matter of _needing_ to match on a `Left` or `Right`. Any time you make an HTTP request—even locally—there's a chance something will go wrong. `Either` provides a clean, concise way of modeling that. You don't have to use it if you don't want to (see my first example), but it's a really, really good idea to, even in simple cases. — Travis Brown, Nov 30 '12 at 22:04
But now I don't have an indication if the request succeed or failed, or am I wrong? — Michael Vashchinsky, Feb 01 '15 at 13:26

Michael Vashchinsky · Answer 2 · 2015-02-02T09:28:06.727

We needed the response body of failed requests to an API, so we came up with this solution:

Define your own ApiHttpError class with code and body (for the body text):

case class ApiHttpError(code: Int, body: String)
  extends Exception("Unexpected response status: %d".format(code))

Define OkWithBodyHandler similar to what is used in the source of displatch:

class OkWithBodyHandler[T](f: Response => T) extends AsyncCompletionHandler[T] {
  def onCompleted(response: Response) = {
    if (response.getStatusCode / 100 == 2) {
      f(response)
    } else {
      throw ApiHttpError(response.getStatusCode, response.getResponseBody)
    }
  }
}

Now, near your call to the code that might throw and exception (calling API), add implicit override to the ToupleBuilder (again similar to the source code) and call OkWithBody on request:

class MyApiService {
  implicit class MyRequestHandlerTupleBuilder(req: Req) {
    def OKWithBody[T](f: Response => T) =
      (req.toRequest, new OkWithBodyHandler(f))
  }

  def callApi(request: Req) = {
    Http(request OKWithBody as.String).either
  }
}

From now on, fetching either will give you the [Throwable, String] (using as.String), and the Throwable is our ApiHttpError with code and body.

Hope it helped.

Return exact response/header?

2 Answers2

Linked