Akka Futures and Akka Remoting
-
Upload
knoldus-software-llp -
Category
Technology
-
view
1.920 -
download
5
Transcript of Akka Futures and Akka Remoting
AKKA FUTURES AND REMOTE ACTORS
Piyush Mishra
Software Consultant
Knoldus Software LLP
TOPICS COVERED TOPICS COVERED
Future
Composing Futures
For Comprehentions
Remoting
Enabling Remote capabilities for your Akka Project
Remote Actors
Look up Remote Actors
FUTURE
Future is a data structure used to retrieve the result of some concurrent operation. This operation is usually performed by an Actor or by the Dispatcher directly. This result can be accessed synchronously (blocking) or asynchronously (non-blocking).
Execution Context
import akka.dispatch.{ ExecutionContext, Promise }
implicit val ec = ExecutionContext.fromExecutorService(yourExecutorServiceGoesHere)
// Do stuff with your brand new shiny ExecutionContext
val f = Promise.successful("foo")
// Then shut your ExecutionContext down at some
// appropriate place in your program/application
ec.shutdown()
Use With Actors
import akka.dispatch.Await
import akka.pattern.ask
import akka.util.Timeout
import akka.util.duration._
implicit val timeout = Timeout(5 seconds)
val future = actor ? msg // enabled by the “ask” import
val result = Await.result(future, timeout.duration).asInstanceOf[String]
Use Directly
A common use case within Akka is to have some computation performed concurrently without needing the extra utility of an Actor. If you find yourself creating a pool of Actors for the sole reason of performing a calculation in parallel, there is an easier (and faster) way:
import akka.dispatch.Await
import akka.dispatch.Future
import akka.util.duration._
val future = Future {
"Hello" + "World"
}
val result = Await.result(future, 1 second)
Functional FuturesAkka’s Future has several monadic methods that are very similar to the ones used by Scala’s collections. These allow you to create ‘pipelines’ or ‘streams’ that the result will travel through.
val f1 = Future {
"Hello" + "World"
}
val f2 = f1 map { x ⇒
x.length
}
val result = Await.result(f2, 1 second)
result must be(10)
f1.value must be(Some(Right("HelloWorld")))
For Comprehension
val f = for {
a ← Future(10 / 2) // 10 / 2 = 5
b ← Future(a + 1) // 5 + 1 = 6
c ← Future(a - 1) // 5 - 1 = 4
if c > 3 // Future.filter
} yield b * c // 6 * 4 = 24
// Note that the execution of futures a, b, and c
// are not done in parallel.
val result = Await.result(f, 1 second)
result must be(24)
Composing Futures
val f1 = ask(actor1, msg1)
val f2 = ask(actor2, msg2)
val f3 = for {
a ← f1.mapTo[Int]
b ← f2.mapTo[Int]
c ← ask(actor3, (a + b)).mapTo[Int]
} yield c
val result = Await.result(f3, 1 second).asInstanceOf[Int]
Callback methods
future onSuccess {
case "bar" println("Got my bar alright!")⇒
case x: String println("Got some random string: " + x)⇒
}
future onFailure {
case ise: IllegalStateException if ise.getMessage == "OHNOES" ⇒
//OHNOES! We are in deep trouble, do something!
case e: Exception ⇒
//Do something else
}
future onComplete {
case Right(result) doSomethingOnSuccess(result)⇒
case Left(failure) doSomethingOnFailure(failure)⇒
}
Remoting
Remoting refers to the machenism by which you can send messages another actor running on other
machines or in another JVM.
This is a process to process communication.
Remoting
To enable remote capabilities in your Akka project you should, at a minimum, add the following changes to your application.conf file:
akka {
actor {
provider = "akka.remote.RemoteActorRefProvider"
}
remote {
transport = "akka.remote.netty.NettyRemoteTransport"
netty {
hostname = "127.0.0.1"
port = 2552
}}}
Creating Remote Actor
val configString = """akka {actor {
provider = "akka.remote.RemoteActorRefProvider" }
remote {netty { hostname = "HOST"}}}
akka {
remote.netty.port = PORT}"""
val customConf = ConfigFactory.parseString(configString)
val remoteSystem = ActorSystem("RemoteApplication", ConfigFactory.load(customConf))
val remoteActor = remoteSystem..actorOf(Props("your actor" , "remote")
Look up Remote Actor
val configString = """
akka {actor {
provider = "akka.remote.RemoteActorRefProvider"
}
remote {netty {hostname = "HOST"}}}
akka {remote.netty.port = PORT }
"""
val customConf = ConfigFactory.parseString(config)
val system = ActorSystem("test", ConfigFactory.load(customConf))
val remoteActor = system.actorFor("akka://RemoteApplication@" + remoteHost + ":" + remotePort + "/user/remote")
References
http://blog.knoldus.com/2013/01/12/akka-futures-in-scala-with-a-simple-example/
https://github.com/meetumaltiar/Akka2Bench
http://doc.akka.io/docs/akka/1.3.1/scala/tutorial-chat-server.html
Thank you