Akka Cookbook

Akka Cookbook

By : Vivek Mishra, Héctor Veiga Ortiz

Buy this Book

Akka Cookbook

By: Vivek Mishra, Héctor Veiga Ortiz

Buy this Book

Overview of this book

Akka is an open source toolkit that simplifies the construction of distributed and concurrent applications on the JVM. This book will teach you how to develop reactive applications in Scala using the Akka framework. This book will show you how to build concurrent, scalable, and reactive applications in Akka. You will see how to create high performance applications, extend applications, build microservices with Lagom, and more. We will explore Akka's actor model and show you how to incorporate concurrency into your applications. The book puts a special emphasis on performance improvement and how to make an application available for users. We also make a special mention of message routing and construction. By the end of this book, you will be able to create a high-performing Scala application using the Akka framework.

Title Page

Credits

About the Authors

About the Reviewer

www.PacktPub.com

Customer Feedback

Preface

Free Chapter

Diving into Akka

Introduction

Creating an Akka Scala SBT project from scratch

Creating and understanding ActorSystem

Defining the actor's behavior and state

Sending messages to actors

Asking for a result from an actor

Communication between actors

Creating a custom mailbox for an actor

Prioritizing messages that an actor receives

Creating a control-aware mailbox for an actor

Become/unbecome behavior of an actor

Stopping an actor

Supervision and Monitoring

Introduction

Creating child actors of a parent actor

Overriding the life cycle hooks of an actor

Sending messages to actors and collecting responses

Understanding OneForOneStrategy for actors

Understanding AllForOneStrategy for actors

Monitoring an actor life cycle using DeathWatch

Routing Messages

Introduction

Creating a SmallestMailboxPool of actors

Creating a BalancingPool of actors

Creating a RoundRobinPool of actors

Creating a BroadcastPool of actors

Creating a ScatterGatherFirstCompletedPool of actors

Creating a TailChoppingPool of actors.

Creating a ConsistentHashingPool of actors

Creating a RandomPool of actors

Sending specially handled messages to routers

Creating a dynamically resizable pool of actors

Using Futures and Agents

Introduction

Using a future directly for a simple operation

Using futures with actors

Using futures inside actors

Using for-comprehensions for futures

Handling callback on futures

Creating a simple parallel application using futures

Reducing a sequence of futures

Reading and updating agents

Composing agents monadically

Scheduling Actors and Other Utilities

Introduction

Scheduling an operation at a specified interval

Scheduling an actor's operation at a specified interval

Canceling a scheduled operation of the actor

Creating a circuit breaker to avoid cascading failure

How to introduce logging with actors

Writing unit test for actors

Packaging and deploying the Akka standalone application

Packaging and deploying Akka application inside a Docker container

Configurating Akka applications

Akka Persistence

Introduction

Preparing an actor for persistence

Recovering the state of an actor

Safely shutting down a persistent actor

Reducing recovery time using snapshots

Creating a persistence FSM model

Persisting the state to LevelDB

Persisting the state to Cassandra

Persisting the state to Redis

Understanding event sourcing

Handling failure in event sourcing

Using persistence query

Persistence query for LevelDB

Remoting and Akka Clustering

Introduction

Enabling Akka applications for remoting

Creating remote actors on different machines

Looking up remote actors from different machines

Deploying remote actors programmatically on different nodes

Scaling out your application using remote actors

Creating a chat-based application using remote actors

Enabling Akka clustering for your project

Using Distributed Publish-Subscribe in the cluster

Cluster Sharding

Sharing data between nodes in an Akka cluster

Creating a singleton actor across clusters

Akka Streams

Introduction

Creating simple Akka Streams

How to transform streams and consume them

Creating stream sources, flows, and sinks

Custom stream processing

Error handling in Akka streams

Pipelining and parallelizing streams

Working with streaming I/O

Integrating streams with Akka actors

Working with graphs

Processing RabbitMQ messages with Akka streams

Integrating Akka Streams with Kafka using Reactive Kafka

Akka HTTP

Introduction

Creating a minimal HTTP server using Akka HTTP

Consuming Akka HTTP services using a client-side API

Writing routing DSL for HTTP servers

Understanding the configuration of Akka HTTP

Marshaling and unmarshaling data

Encoding and decoding data

Understanding directives

Exception handling

Uploading a file using Akka HTTP

Building JSON support with Akka HTTP

XML support with Akka HTTP

Understanding Various Akka patterns

Introduction

The Master Slave work pulling pattern

Ordered termination of actors

Shutdown patterns in Akka

Scheduling periodic messages to an actor

Throttling of messages while sending them to an actor

Balancing workload across actors

The aggregator pattern

The CountDownLatch pattern

Finite-state machine

The pausable actor pattern

Enveloping actor

Microservices with Lagom

Introduction

Installing Lagom and creating a Lagom project

Understanding the service locator

Understanding service descriptors

Implementing Lagom services

Consuming services

Testing services

Writing persistent and clustered services

Running Lagom in production

Integrating with Akka

Customer Reviews

5 star

4 star

3 star

2 star

1 star

Stopping an actor

It is obvious that an actor has to be shut down gracefully after it has processed all the messages or on application shutdown.

Getting ready

To step through this recipe, we need import the Hello-Akka project in an IDE like IntelliJ Idea. Prerequisites are the same as those in previous recipes.

How to do it...

Create a file, Shutdown.scala, in package com.packt.chapter1.
Add the following imports to the top of file:

        import akka.actor.{PoisonPill, Props, ActorSystem, Actor}

Create a case object, Stop, as the message:

        case object Stop

Define an actor, ShutdownActor, as follows:

        class ShutdownActor extends Actor { 
          override def receive: Receive = { 
            case msg:String => println(s"$msg") 
            case Stop => context.stop(self) 
          } 
        }

There are two ways we can stop the actor:

Using PoisonPill
Using context.self(actorRef)

Create an actor and send it a message as shown in the following code:

        object ShutdownApp extends App{ 
          val actorSystem = ActorSystem("HelloAkka") 
          val shutdownActor1 = 
           actorSystem.actorOf(Props[ShutdownActor], 
           "shutdownActor1") 
          shutdownActor1 ! "hello" 
          shutdownActor1 ! PoisonPill 
          shutdownActor1 ! "Are you there?" 
          val shutdownActor2 = 
           actorSystem.actorOf(Props[ShutdownActor], 
           "shutdownActor2") 
          shutdownActor2 ! "hello" 
          shutdownActor2 ! Stop 
          shutdownActor2 ! "Are you there?" 
        }

Run the preceding application, and you will get the following output:

      hello
      hello
      [INFO] [05/22/2016 20:39:53.137] [HelloAkka-akka.actor.default-
      dispatcher-4] [akka://HelloAkka/user/shutdownActor1] Message
      [java.lang.String] from Actor[akka://HelloAkka/deadLetters] to
      Actor[akka://HelloAkka/user/shutdownActor1#417818231] was not
      delivered. [1] dead letters encountered.
      [INFO] [05/22/2016 20:39:53.138] [HelloAkka-
      akka.actor.default-dispatcher-4]
      [akka://HelloAkka/user/shutdownActor2] Message
      [java.lang.String] from Actor[akka://HelloAkka/deadLetters]
      to Actor[akka://HelloAkka/user/shutdownActor2#788021817] was
      not delivered. [2] dead letters encountered.

How it works...

In step three, we create a Stop message. Upon receiving this message, the actor will stop using context.stop(self).

In step four, we define an actor which handles the Stop message.

In step five, we create two actors of the same class, shutdownActor1 and shutdownActor2. We shut down shutdownActor1 using PoisonPill and shutdownActor2 using context.stop(self).

PoisonPill and context.stop(self) are the two ways to kill an actor. PoisonPill is the inbuilt message that is handled after all the messages that were already queued in the mailbox.

Context.stop is basically used for an ordered shutdown of actors when you want the child actors to stop first, then the parent actor, followed by the ActorSystem to stop top-level actors.

Akka Cookbook

By : Vivek Mishra, Héctor Veiga Ortiz

Akka Cookbook

By: Vivek Mishra, Héctor Veiga Ortiz

Overview of this book

Related Content you might be interested in

Current Title:

Akka Cookbook

Hands-On Data Structures and Algorithms with Python – Third Edition

Stopping an actor

Getting ready

How to do it...

How it works...