CODEWITHSUNDEEP
scalaakkaactor
Krever
Krever

Reputation: 1467

How do you know what messages you can send to actor?

Is there any standard way of formalizing my scala/akka actor api? Imho, situation where I need to look into implementation to know what to send is not really a good option. Also, if implementation has changed and my message is no longer valid(not invoking action I think it invokes) I don't get any warning or error.

Upvotes: 3

Views: 171

Answers (2)

Alexey Romanov
Alexey Romanov

Reputation: 170713

The approach generally taken in Erlang is to avoid sending messages to a process directly, and to provide additional API in the same module which defines the behavior of the process. In Akka it would look like

class Foo extends Actor {
  // handles messages Bar(x: Int) and Baz
}

object Foo {
  def bar(foo: ActorRef, x: Int) = foo ! Bar(x)

  def baz(foo: ActorRef) = (foo ? Baz).mapTo[TypeOfResponseToBaz]
}

One problem is handling return messages, since Erlang generally promotes more synchronous style than Akka does. This may be handled by a naming convention (e.g. BarResponse or FooBarResponse if different actors handle the same message with different responses).

Upvotes: 1

pushy
pushy

Reputation: 9635

This is a question that is discussed very much in the community. I heard that maybe Akka 3 will have better support for typesafe actors, but that is some time down the road.

In the mean time you could use TypedActors, though the general suggestion is to use them at the boundaries of your application.

A nice approach that does not give you any typesafety, but makes the contract of an actor more visible, is to define the messages an actor can receive in their companion object. This way each time you want to send a message to an actor you choose from the message its companion object defines. This of course works best if you have specific messages for each actor. If you change the implementation you could remove the old message and add a new one, so that everyone who wanted to use the old implementation would get compiler errors.

Lastly there was a nice pattern last week on the mailing list. He creates traits to define the contracts for the actors and their consumers, but you still need to take care that the consumer mix in the correct trait.

In my experience, the best way to make sure everything works is an extensive test suite which will test each actor for itself, but also the communication between specific actors.

Upvotes: 6

Related Questions