How to wrap an REST API client in an Actor - scala

Question

I'm trying to write an actor that calls an HTTP REST API. The rest API needs a query parameter that will be passed from the invoking Actor. The official documentation has an example to achieve the above using a preStart method that pipes the message to itself:
import akka.actor.{ Actor, ActorLogging }
import akka.http.scaladsl.Http
import akka.http.scaladsl.model._
import akka.stream.{ ActorMaterializer, ActorMaterializerSettings }
import akka.util.ByteString
class Myself extends Actor
with ActorLogging {
import akka.pattern.pipe
import context.dispatcher
final implicit val materializer: ActorMaterializer = ActorMaterializer(ActorMaterializerSettings(context.system))
val http = Http(context.system)
override def preStart() = {
http.singleRequest(HttpRequest(uri = "http://akka.io"))
.pipeTo(self)
}
def receive = {
case HttpResponse(StatusCodes.OK, headers, entity, _) =>
entity.dataBytes.runFold(ByteString(""))(_ ++ _).foreach { body =>
log.info("Got response, body: " + body.utf8String)
}
case resp # HttpResponse(code, _, _, _) =>
log.info("Request failed, response code: " + code)
resp.discardEntityBytes()
}
}
The above works but the URL is hardcoded. What I want to achieve is a REST client actor that I can send parameters as a message to and get back results of the call. I modified the code above to receive parameters as message (pseudo code):
def receive = {
case param: RESTAPIParameter => {
http.singleRequest(HttpRequest(URI("http://my-rest-url").withQuery("name", "value"))
.pipeTo(self)
}
case HttpResponse(StatusCodes.OK, headers, entity, _) =>
entity.dataBytes.runFold(ByteString(""))(_ ++ _).foreach { body =>
log.info("Got response, body: " + body.utf8String)
sender! body.utf8String //Will not work
}
case resp # HttpResponse(code, _, _, _) =>
log.info("Request failed, response code: " + code)
resp.discardEntityBytes()
}
The above should work, but can't really be used to send a response back to the client as the sender reference is lost when the result of REST call is piped back to self.
I guess I could try and store the sender locally in a variable and use it to pass the response back, but I don't think that is a great idea.
So, what is the right way to handle such a scenario?
Edit: The solution suggested below by #PH88 works, but I would like to keep the pattern matching on HttpResponse in the outer loop.
Edit 2: The reason I wanted to pipe the response back to self is because I wanted to implement a state machine ..kind of. The state changes based on the type of message received by the actor. As an example:
The first state could be receiving a query string from a calling actor. The actor invokes the REST api and becomes awaitingResult. Data piped to self for further processing.
When it receives an HTTPResponse with success code, the state becomes dataRecevied. Data is piped to self again for more processing.
The received data is then transformed into internal vendor neutral format and the result is finally sent back to the calling actor.
If the Response code is not successful in 1 above, the state could be changed to HttpError and handled accordingly.
Hope that clarifies the intent. Any other suggestions/designs to achieve a clean/simple design are welcome :-)

Answer 1

You can wrap the HttpResponse with your own case class and bundle the sender with it:
case class ServerResponse(requester: ActorRef, resp: HttpResponse)
then:
def receive = {
case param: RESTAPIParameter => {
val requester = sender
http.singleRequest(HttpRequest(URI("http://my-rest-url").withQuery("name", "value"))
.map(httpResp =>
// This will execute in some other thread, thus
// it's important to NOT use sender directly
ServerResponse(requester, httpResp)
)
.pipeTo(self)
}
case ServerResponse(requester, HttpResponse(...)) =>
val result = ...
requester ! result
...
}

Answer 2

The pipeTo method takes in the sender as an implicit argument:
def pipeTo(recipient: ActorRef)(implicit sender: ActorRef = Actor.noSender): Future[T]
Within an Actor self is defined as an implicit ActorRef:
implicit final val self: ActorRef
Therefore self is the sender that is being specified in pipeTo.
You can simply specify the sender explicitly to be the original sender:
def receive = {
case param: RESTAPIParameter =>
http.singleRequest(HttpRequest(URI("http://my-rest-url").withQuery("name", "value"))
.pipeTo(self)(sender) //specify original sender
case HttpResponse(StatusCodes.OK, headers, entity, _) =>
entity.dataBytes.runFold(ByteString(""))(_ ++ _).foreach { body =>
log.info("Got response, body: " + body.utf8String)
sender! body.utf8String //Works now!
}
case resp # HttpResponse(code, _, _, _) => {
log.info("Request failed, response code: " + code)
resp.discardEntityBytes()
}
}