Next generation message driven systems with Akka

Akka Typed
Johan Andrén, Akka Team
Øredev Malmö, 2018-11-20
Next generation
message driven
systems with Akka

Johan Andrén
Akka Team
Stockholm Scala User Group
@apnylle
markatta.com/codemonkey/
johan.andren@lightbend.com

Build powerful reactive, concurrent,
and distributed applications more easily
Akka

What’s in the toolkit?
Actors – simple & high performance concurrency
Cluster, Cluster tools – tools for building distributed
systems
Streams – reactive streams implementation
Persistence – CQRS + Event Sourcing for Actors
HTTP – fully async streaming HTTP Server
Alpakka – Reactive Streams Integrations a’la Camel

Actors – simple & high performance concurrency
Cluster, Cluster tools – tools for building distributed
systems
Streams – reactive streams implementation
Persistence – CQRS + Event Sourcing for Actors
HTTP – fully async streaming HTTP Server
Alpakka – Reactive Streams Integrations a’la Camel
Typed
Typed
Typed
(already type-safe)
(already type-safe)
(already type-safe)
What is coming soon?
(already type-safe)

Languages
Complete APIs for both Java and Scala

Actor
Message
Inbox
MessageMessage
actorRef.tell(message)
Akka Actor fundamentals
The only way for the rest of the
application to interact with the actor

• mutate state (including spawning a child actor)
• send messages to other actors
• change its behavior
Actor
Message
Inbox
MessageMessage
An Actor can…

MVS
(Minimum Viable Sample)
Na-na na-na na-na na-naSample-time!
Also known as “hello world”

import akka.actor.typed.ActorRef;
import akka.actor.typed.ActorSystem;
import akka.actor.typed.Behavior;
import akka.actor.typed.javadsl.Behaviors;
import java.io.IOException;
public class Sample1 {
static class Hello {
public final String who;
public Hello(String who) {
this.who = who;
}
}
final static Behavior<Hello> greetingBehavior =
Behaviors.receive(Hello.class)
.onMessage(Hello.class, (context, message) -> {
context.getLog().info("Hello {}!", message.who);
return Behavior.same();
}).build();
public static void main(String[] args) throws IOException {
ActorSystem<Hello> actorSystem =
ActorSystem.create(greetingBehavior, "my-system");
ActorRef<Hello> rootActor = actorSystem;
rootActor.tell(new Hello("Johan"));
rootActor.tell(new Hello(“Øredev audience"));
System.out.println("Press that any-key to terminate");
System.in.read();
actorSystem.terminate();
}
}

public class Sample1 {
static class Hello {
this.who = who;
}
}
}).build();

}
}
}).build();
rootActor.tell(new Hello(“Øredev audience"));
System.out.println("Press that any-key to terminate");
System.in.read();
actorSystem.terminate();
}
}

import akka.actor.typed.{ActorRef, ActorSystem, Behavior}
import akka.actor.typed.scaladsl.Behaviors
import scala.io.StdIn
object Sample1 {
case class Hello(who: String)
val greetingBehavior: Behavior[Hello] =
Behaviors.receive { (ctx, hello) =>
ctx.log.info(s"Hello ${hello.who}!")
Behaviors.same
}
def main(args: Array[String]): Unit = {
val system = ActorSystem(greetingBehavior, "my-system")
val rootActor: ActorRef[Hello] = system
rootActor ! Hello("Johan")
rootActor ! Hello(“Øredev audience")
println("Press the any-key to terminate")
StdIn.readLine()
system.terminate()
}
}

Let’s do another one
right away
The mystery of the changing state
🔎

interface Command {}
static class ChangeGreeting implements Command {
public final String newGreeting;
public ChangeGreeting(String newGreeting) {
this.newGreeting = newGreeting;
}
}
static class Hello implements Command {
this.who = who;
}
}
public static Behavior<Command> dynamicGreetingBehavior(String greeting) {
return Behaviors.receive(Command.class)
context.getLog().info(greeting + " " + message.who + "!");
}).onMessage(ChangeGreeting.class, (context, changeGreeting) ->
dynamicGreetingBehavior(changeGreeting.newGreeting)
).build();
}
var actorSystem =
ActorSystem.create(dynamicGreetingBehavior("Hello"), "my-system");
actorSystem.tell(new Hello("Johan"));
actorSystem.tell(new ChangeGreeting("Hej"));
actorSystem.tell(new Hello(“Øredev audience"));
}

interface Command {}
static class ChangeGreeting implements Command {
public final String newGreeting;
public ChangeGreeting(String newGreeting) {
this.newGreeting = newGreeting;
}
}
this.who = who;
}
}
).build();
}

this.who = who;
}
}
).build();
}
var actorSystem =
}

).build();
}
var actorSystem =
}

sealed trait Command
case class Hello(who: String) extends Command
case class ChangeGreeting(newGreeting: String) extends Command
def dynamicGreetingBehavior(greeting: String): Behavior[Command] =
Behaviors.receive { (ctx, message) =>
message match {
case Hello(who) =>
ctx.log.info(s"$greeting ${who}!")
Behaviors.same
case ChangeGreeting(newGreeting) =>
dynamicGreetingBehavior(newGreeting)
}
}
val system = ActorSystem(dynamicGreetingBehavior("Hello"), "my-system")
system ! Hello("Johan")
system ! ChangeGreeting("Hej")
system ! Hello(“Øredev audience")
}

But I don’t like it
(the FP style, that is)

static class DynamicGreetingBehavior extends AbstractBehavior<Command> {
private final ActorContext<Command> context;
private String greeting;
public DynamicGreetingBehavior(String initialGreeting, ActorContext<Command> context) {
this.context = context;
greeting = initialGreeting;
}
@Override
public Receive<Command> createReceive() {
return receiveBuilder()
.onMessage(Hello.class, this::onHello)
.onMessage(ChangeGreeting.class, this::onChangeGreeting)
.build();
}
private Behavior<Command> onHello(Hello hello) {
context.getLog().info(greeting + " " + hello.who + "!");
return Behaviors.same();
}
private Behavior<Command> onChangeGreeting(ChangeGreeting changeGreeting) {
greeting = changeGreeting.newGreeting;
}
}

static class DynamicGreetingBehavior extends AbstractBehavior<Command> {
private final ActorContext<Command> context;
public DynamicGreetingBehavior(String initialGreeting, ActorContext<Command> contex
}
@Override
.build();
}
}

public DynamicGreetingBehavior(String initialGreeting, ActorContext<Command> contex
}
@Override
.build();
}
}
private Behavior<Command> onChangeGreeting(ChangeGreeting changeGreeting) {
greeting = changeGreeting.newGreeting;
}
}

public static void main(String[] args) {
ActorSystem<Command> system = ActorSystem.<Command>create(
Behaviors.setup((context) ->
new DynamicGreetingBehavior("Hello", context)),
"my-system"
);
system.tell(new Hello("Johan"));
system.tell(new ChangeGreeting(“Hej"));
system.tell(new Hello(“Øredev audience"));
}

• Discoverability, how are things related
• More compile time type-safety, less runtime debugging 
Types helps productivity!
(and results in more reliable systems in production)
The need for strong/strict typing
“Sending the wrong message to an actor is
actually quite uncommon”
– Myself

Burglar Alarm
• enabled/disabled with a pin code
• accepts notifications about “activity”
• if enabled on activity, sound the alarm
“Realistic” Example
DIY

interface AlarmMessage {}
static class EnableAlarm implements AlarmMessage {
public final String pinCode;
public EnableAlarm(String pinCode) {
this.pinCode = pinCode;
}
}
static class DisableAlarm implements AlarmMessage {
public DisableAlarm(String pinCode) {
}
}
static class ActivityEvent implements AlarmMessage { }

public static Behavior<AlarmMessage> enabledAlarm(String pinCode) {
return Behaviors.receive(AlarmMessage.class)
.onMessage(
DisableAlarm.class,
// predicate
(disable) -> disable.pinCode.equals(pinCode),
(context, message) -> {
context.getLog().info("Correct pin entered, disabling alarm");
return disabledAlarm(pinCode);
}
).onMessage(ActivityEvent.class, (context, activityEvent) -> {
context.getLog().warning("EOEOEOEOEOE ALARM ALARM!!!");
}).build();
}

public static Behavior<AlarmMessage> disabledAlarm(String pinCode) {
return Behaviors.receive(AlarmMessage.class)
.onMessage(EnableAlarm.class,
// predicate
(enable) -> enable.pinCode.equals(pinCode),
(context, message) -> {
context.getLog().info("Correct pin entered, enabling alarm");
return enabledAlarm(pinCode);
}
).build();
}

public static void main(String[] args) {
var system = ActorSystem.create(enabledAlarm("0000"), "my-system");
system.tell(new ActivityEvent());
system.tell(new DisableAlarm("1234"));
system.tell(new DisableAlarm("0000"));
system.tell(new EnableAlarm("0000"));
}

sealed trait AlarmMessage
case class EnableAlarm(pinCode: String) extends AlarmMessage
case class DisableAlarm(pinCode: String) extends AlarmMessage
case object ActivityEvent extends AlarmMessage
def enabledAlarm(pinCode: String): Behavior[AlarmMessage] =
Behaviors.receive { (context, message) =>
message match {
case ActivityEvent =>
context.log.warning("EOEOEOEOEOE ALARM ALARM!!!")
Behaviors.same
case DisableAlarm(`pinCode`) =>
context.log.info("Correct pin entered, disabling alarm");
disabledAlarm(pinCode)
case _ => Behaviors.unhandled
}
}
def disabledAlarm(pinCode: String): Behavior[AlarmMessage] =
Behaviors.receivePartial {
case (context, EnableAlarm(`pinCode`)) =>
context.log.info("Correct pin entered, enabling alarm")
enabledAlarm(pinCode)
}
val system = ActorSystem.create(enabledAlarm("0000"), "my-system")
system.tell(ActivityEvent)
system.tell(DisableAlarm("1234"))
system.tell(DisableAlarm("0000"))
system.tell(EnableAlarm("0000"))
}

Request-response with other actors
• In untyped actors the sender was
auto-magically available
• In Akka Typed the recipient of
response has to be encoded in
message (why?)

Actor<ProtocolA> Actor<ProtocolB>
RequestForB
ActorRef<ResponseFromB>
ResponseFromBProtocolA
?

Actor<ProtocolA> Actor<ProtocolB>
RequestForB
ActorRef<ResponseFromB>
ResponseFromBProtocolA
ResponseFromB -> ProtocolA
?

One oﬀ with Ask
context.ask(
ResponseFromB.class,
actorB,
Timeout.create(Duration.ofSeconds(5)),
(ActorRef<ResponseFromB> respondTo) -> new RequestForB(respondTo),
(ResponseFromB res, Throwable failure) -> {
if (res != null) return new ProtocolAMessage(res);
else throw new RuntimeException("Request failed", failure);
}
);

Long live the adapter
ActorRef<ResponseFromB> adapter = context.messageAdapter(
ResponseFromB.class,
(responseFromB) -> new ProtocolAMessage(responseFromB)
);
actorB.tell(new RequestForB(adapter));

Keeping parts of the protocol to ourselves
ActorRef<ProtocolA> actorRef = …
ActorRef<SubProtocolA> moreNarrowActorRef = actorRef.narrow();
ProtocolA
SubProtocolA SubProtocolA2

Actor Model vs Network
Interaction already modelled as immutable messages 
Data travels over the network in packages, changes has to be explicitly
sent back.
At most once 
Data reaches a node on the other side at most once, but can be lost,
already part of model!
A recipient of a message can reply directly to sender 
Regardless if there were intermediate recipients of the message
Messages not limited to request response 
Messages can flow in either direction when two systems are connected.

Local
ActorSystem
Message
Message
Actor
Actor
Actor

JVM 2
JVM 1
Distributed
ActorSystem
ActorSystem
Message
Message
Actor
Actor
Actor

Akka Cluster + Akka Typed
ActorSystem ActorSystem
ActorSystem

Receptionist
Typed Receptionist
Receptionist
Receptionist
ActorRef<AlarmMessage>
Sensor-Actor
Subscribe(key, actorRef)

Receptionist
Typed Receptionist
Receptionist
Receptionist
Register(Key<AlarmMessage>,
ActorRef<AlarmMessage>)
Sensor-Actor

Receptionist
Typed Receptionist
Receptionist
Receptionist
ActorRef[AlarmMessage]
Sensor-Actor
Listing(key, actorRefs)

Receptionist
Typed Receptionist
Receptionist
Receptionist
Sensor-Actor
AlarmMessage

Distributed Burglar Alarm
• we can have any number of
nodes
• a sensor on any node can
report activity to the alarm
Example
DYI
Distributed

static final ServiceKey<ActivityEvent> serviceKey =
ServiceKey.create(ActivityEvent.class, "alarm");
interface AlarmMessage extends Serializable {}
static class EnableAlarm implements AlarmMessage {
public EnableAlarm(String pinCode) {
}
}
static class DisableAlarm implements AlarmMessage {
public DisableAlarm(String pinCode) {
}
}
static class ActivityEvent implements AlarmMessage { }

public static Behavior<AlarmMessage> alarm(String pinCode) {
return Behaviors.setup((context) -> {
ActorRef<Receptionist.Command> receptionist =
context.getSystem().receptionist();
receptionist.tell(
Receptionist.register(serviceKey, context.getSelf().narrow()));
return enabledAlarm(pinCode);
});
}

public static class SensorBehavior extends AbstractBehavior<TriggerCommand> {
private final ActorContext<TriggerCommand> context;
private Set<ActorRef<ActivityEvent>> alarms = Collections.EMPTY_SET;
public SensorBehavior(ActorContext<TriggerCommand> context) {
// we need to transform the messages from the receptionist protocol
// into our own protocol:
ActorRef<Receptionist.Listing> adapter = context.messageAdapter(
Receptionist.Listing.class,
(listing) -> new AlarmActorUpdate(listing.getServiceInstances(serviceKey))
);
ActorRef<Receptionist.Command> receptionist = context.getSystem().receptionist();
receptionist.tell(Receptionist.subscribe(serviceKey, adapter));
}
@Override
public Behaviors.Receive<TriggerCommand> createReceive() {
.onMessage(TriggerSensor.class, this::onTrigger)
.onMessage(AlarmActorUpdate.class, this::onAlarmActorUpdate)
.build();
}
private Behavior<TriggerCommand> onTrigger(TriggerSensor trigger) {
final ActivityEvent activityEvent = new ActivityEvent();
if (alarms.isEmpty()) context.getLog().warning("Saw trigger but no alarms known yet");
alarms.forEach((alarm) ->
alarm.tell(activityEvent)
);
}
private Behavior<TriggerCommand> onAlarmActorUpdate(AlarmActorUpdate update) {
context.getLog().info("Got alarm actor list update");
alarms = update.alarms;
}
}

public static class SensorBehavior extends AbstractBehavior<TriggerCommand> {
private final ActorContext<TriggerCommand> context;
private Set<ActorRef<ActivityEvent>> alarms = Collections.EMPTY_SET;
public SensorBehavior(ActorContext<TriggerCommand> context) {
// we need to transform the messages from the receptionist protocol
// into our own protocol:
ActorRef<Receptionist.Listing> adapter = context.messageAdapter(
Receptionist.Listing.class,
(listing) -> new AlarmActorUpdate(listing.getServiceInstances(serviceKey))
);
}
@Override
.build();
}

);
}
@Override
.build();
}
if (alarms.isEmpty()) context.getLog().warning("Saw trigger but no alarms known yet");
alarms.forEach((alarm) ->
alarm.tell(activityEvent)
);
}
private Behavior<TriggerCommand> onAlarmActorUpdate(AlarmActorUpdate update) {
context.getLog().info("Got alarm actor list update");
alarms = update.alarms;
}
}

public static void main(String[] args) throws Exception {
ActorSystem<AlarmMessage> system1 =
ActorSystem.create(alarm("0000"), "my-cluster");
ActorSystem<TriggerCommand> system2 =
ActorSystem.create(sensorBehavior(), "my-cluster");
ActorSystem<TriggerCommand> system3 =
ActorSystem.create(sensorBehavior(), "my-cluster");
// first join the first node to itself to form a cluster
Cluster node1 = Cluster.get(system1);
node1.manager().tell(Join.create(node1.selfMember().address()));
// then have node 2 and 3 join that cluster
Scanner in = new Scanner(System.in);
while (true) {

// then have node 2 and 3 join that cluster
Scanner in = new Scanner(System.in);
while (true) {
try {
System.out.println("Enter 2 or 3 to trigger activity on that node");
int chosenNode = Integer.parseInt(in.next());
System.out.println("Triggering sensor on node " + chosenNode);
if (chosenNode == 2) system2.tell(new TriggerSensor());
else if (chosenNode == 3) system3.tell(new TriggerSensor());
} catch (Exception ex) {
// we don't care, loop!
}
}
}

Summary
• On message - message another actor, change
state or behavior
• Types gives better guardrails and makes
understanding the system easier
• We can use the same abstraction for local and
distributed

GitHub repo with all samples in this talk
https://bit.ly/2OKRFxD
Akka typed docs
doc.akka.io/docs/akka/2.5/typed/index.html
More resources
blog.akka.io - news and articles
discuss.akka.io - forums
developer.lightbend.com - samples
github.com/akka/akka - sources and getting involved
Further reading

Questions?
GitHub repo with all samples in this talk
https://bit.ly/2OKRFxD

http://akka.io
@apnylle
johan.andren@lightbend.com
Thanks for listening!

Next generation message driven systems with Akka

Recommended

More Related Content

What's hot (20)

Similar to Next generation message driven systems with Akka (20)

More from Johan Andrén (10)

Recently uploaded (20)

Next generation message driven systems with Akka