Akka-stream and delegating processing to an actor

Question

I have the following case, where I'm trying to delegate processing to an actor. What I want to happen is that whenever my flow processes a message, it sends it to the actor, and the actor will uppercase it and write it to the stream as a response.

So I should be able to connect to port 8000, type in "hello", have the flow send it to the actor, and have the actor publish it back to the stream so it's echoed back to me uppercased. The actor itself is pretty basic, from the ActorPublisher example in the docs.

I know this code doesn't work, I cleaned up my experiments to get it to compile. Right now, it's just two separate streams. I tried to experiment with merging the sources or the sinks, to no avail.

object Sample  {
  def main(args: Array[String]): Unit = {
    implicit val system = ActorSystem("sample")
    implicit val materializer = ActorMaterializer()

    val connections: Source[IncomingConnection, 
        Future[ServerBinding]] = Tcp().bind("localhost", 8000)
    val filter = Source.actorPublisher[ByteString](Props[Filter])

    val filterRef = Flow[ByteString]
      .to(Sink.ignore)
      .runWith(filter)

    connections runForeach { conn =>
      val echo = Flow[ByteString] .map {


        // would like to send 'p' to the actor, 
        // and have it publish to the stream
        case p:ByteString => filterRef ! p
      }
    }
  }
}

// this actor is supposed to simply uppercase all 
// input and write it to the stream
class Filter extends ActorPublisher[ByteString] with Actor
{
  var buf = Vector.empty[ByteString]
  val delay = 0

  def receive = {
    case p: ByteString =>
      if (buf.isEmpty && totalDemand > 0)
        onNext(p)
      else {
        buf :+= ByteString(p.utf8String.toUpperCase)
        deliverBuf()
      }
    case Request(_) =>
      deliverBuf()
    case Cancel =>
      context.stop(self)
  }


   @tailrec final def deliverBuf(): Unit =
    if (totalDemand > 0) {
      if (totalDemand <= Int.MaxValue) {
        val (use, keep) = buf.splitAt(totalDemand.toInt)
        buf = keep
        use foreach onNext
      } else {
        val (use, keep) = buf.splitAt(Int.MaxValue)
        buf = keep
        use foreach onNext
        deliverBuf()
      }
    }
}

If you need a custom actor to participate as part of a `Flow`, why not just let it be a regular `Actor` (not a publisher or subscriber) and then integrate into a `Flow` via `ask` and `mapAsync`? The code is really simple that way and you delegate the reactive streams backpressure handling code to the framework and let your actor focus on doing just what it needs to do. — cmbaxter, Feb 05 '16 at 14:36
I didn't specify in the original post since I didn't want to detract from the spirit of the questions, but in some cases I want the actor to be processing a different stream, but be able to publish to the connection stream. In which case, I wouldn't be able to use an 'ask' if the target (not source) stream had no activity. — Will I Am, Feb 05 '16 at 15:32

score 1 · Accepted Answer · edited Nov 15 '17 at 16:04

I've had this problem too before, solved it in a bit of roundabout way, hopefully you're ok with this way. Essentially, it involves creating a sink that immediately forwards the messages it gets to the src actor.

Of course, you can use a direct flow (commented it out), but I guess that's not the point of this exercise :)

object Sample  {
  def main(args: Array[String]): Unit = {
    implicit val system = ActorSystem("sample")
    implicit val materializer = ActorMaterializer()

    val connections: Source[IncomingConnection,
      Future[ServerBinding]] = Tcp().bind("localhost", 8000)

    def filterProps = Props[Filter]

    connections runForeach { conn =>
      val actorRef = system.actorOf(filterProps)
      val snk = Sink.foreach[ByteString]{s => actorRef ! s}
      val src = Source.fromPublisher(ActorPublisher[ByteString](actorRef))
      conn.handleWith(Flow.fromSinkAndSource(snk, src))

//      conn.handleWith(Flow[ByteString].map(s => ByteString(s.utf8String.toUpperCase())))
    }
  }
}

// this actor is supposed to simply uppercase all
// input and write it to the stream
class Filter extends ActorPublisher[ByteString]
{
  import akka.stream.actor.ActorPublisherMessage._
  var buf = mutable.Queue.empty[String]
  val delay = 0

  def receive = {
    case p: ByteString =>
      buf += p.utf8String.toUpperCase
      deliverBuf()
    case Request(n) =>
      deliverBuf()
    case Cancel =>
      context.stop(self)
  }

  def deliverBuf(): Unit = {
    while (totalDemand > 0 && buf.nonEmpty) {
      val s = ByteString(buf.dequeue() + "\n")
      onNext(s)
    }
  }

Thanks, this works. Do you see any reason why this would not work if the actor had a different source but I still want to output to the connection? For example, actor's source being an internal event pump, and when an event happens, publish it to the connection. — Will I Am, Feb 05 '16 at 15:34
No reason why it shouldn't. The Filter actor can generate its own data and publish it when it wants as long as there is demand. I do that in my code. That's the main reason I had to use a ActorPublisher. — Ajay Padala, Feb 05 '16 at 15:48
Thanks. Using this syntax where the Flow is created dynamically from source and sink, is there a way to pass control back to my original flow that was handling the connection? I'm getting lost in this streams thing. How do I connect the Flow.fromSinkAndSource() to a next flow? — Will I Am, Feb 08 '16 at 05:06

Akka-stream and delegating processing to an actor

1 Answers1