Send attachment to email Gateway using Akka Actors - scala

Question

I am new to Akka, Scala.
I have to build a service which sends emails with attachment to emailIds given. I am using Sendgrid as a gateway.
For the attachment I have a file uploaded in S3 of size 28KB.
I have REST service to which I can pass document Id through which I can fetch the document as InputStream. Now this input Stream has to be sent to many email Ids . All this downloading the file is handled by an actor called "attachmentActor" which I am creating below.
Now lets say I have two emailIds which I need to send that attachment to, the problem I am facing is its not sending complete file to both , infact 28KB file gets divided into 16KB and 12KB which are finally sent to emailIds.
so emailId 1 would receive 16KB //it should actually have 28KB
email 2 would receive 12KB //it should actually have 28KB
Following is the code:
class SendgridConsumer{
def receive(request: EmailRequest) = {
val service = Sendgrid(username , password)
val logData = request.logData
var errorMessage = new String
val attachmentRef = system.actorOf(Props[AttachmentRequestConsumer], "attachmentActor")
val future = attachmentRef ? AttachmentRequest(request.documentId.get)
var targetStream = Await.result(future, timeout.duration).asInstanceOf[InputStream]
val results = request.emailContacts.par.map( emailContact => {
val email=postData(new Email(),request , emailContact, targetStream,request.documentName.get)
val sendGridResponse=service.send(email)
}
}
// postData() creates an Email Object
// This is my Attachment Actor
class AttachmentRequestConsumer extends Actor with ActorLogging {
def receive = {
case request:AttachmentRequest => {
log.info(" inside Attachment RequestConsumer with document Id:" + request.documentId)
val req: HttpRequest = Http(url)
val response = req.asBytes
val targetStream = ByteSource.wrap(response.body).openStream()
log.info("response body :" + response.body)
sender ! targetStream
targetStream.close()
}
}
}

Answer 1

One of the things you should know about actors is that you should not be sending mutable objects (such as InputStream) as messages (technically you can as long as you won't mutate them). Another thing is that sending of messages is asynchronous. This means that the targetStream.close() is called before the other actor receives the message. That is probably the reason why you are getting truncated attachments.
One thing that you could do is send the data instead of an InputStream. Something like
def receive = {
case request:AttachmentRequest => {
log.info(" inside Attachment RequestConsumer with document Id:" + request.documentId)
val req: HttpRequest = Http(url)
val response = req.asBytes
val data = ByteSource.wrap(response.body).read.toVector
log.info("response body :" + response.body)
sender ! data
}
}
That is if you can comfortably fit the contents of the attachment into memory. If that is not the case, you can try to break it into chunks or something.
On a side note, you should not be blocking in receive (the Await.result). A better approach would be to just send a message to AttachmentRequestConsumer and then expect a message of type Seq[Byte] (or even better some wrapper like AttachmentResponse) back in SendgridConsumer's receive.