Sending messages to your Akka Actors from JMX

Lately I was a bit busy learning new technologies like Scala, Akka and changing my mind to start to think in functional way. As I promised, my next posts will be about Scala and all technologies related to this language.

 Today I want to show you how to combine an old friend like JMX with and application done with Akka. Scala runs on the JVM so you have all the tools available in the Java platform. To follow this tutorial, it is necessary to have an idea about what does it means the Actor Model

Also you need to have installed Scala. Please follow this instructions if you don't have any installation. I recommend to you IntelliJ as a development environment, it provides a cool support to work with Scala.

Cool! We are ready to start. Our application is very simple, we are going to create an Actor called Pong, and this actor will be waiting a message from a JMX client. This client will be able to send messages to our actor Pong. If the message sent is "end", Pong will be terminated. Otherwise the message will be stored in memory. From our JMX client, we can ask for the last message received by the actor Pong. Let's see some code.

First of all , our support to code actors with JMX support. Extending this trait the actor will be registered in our MBeanServer automatically using the methods preStart and postStop. Note that method getMXTypeName is an abstract method and is implemented by the child class.

	trait ActorWithJMXSupport extends Actor {
	val mBeanServer = ManagementFactory.getPlatformMBeanServer();
	val objName = new ObjectName("hdbandit", {
	import scala.collection.JavaConverters._
	new java.util.Hashtable(
	Map(
	"name" -> self.path.toStringWithoutAddress,
	"type" -> getMXTypeName
	).asJava
	)
	})
	def getMXTypeName : String
	override def preStart() = mBeanServer.registerMBean(this, objName)
	override def postStop() = mBeanServer.unregisterMBean(objName)
	}

view raw ActorWithJMXSupport.scala hosted with ❤ by GitHub

Is time to define our MBean. By convention the MBean is defined with the suffix MBean. Here is the trait that exposes the operations available from our MBean.

	trait PongMBean {
	def lastReceivedMessage(): String
	def sendMessage(p1: String): Unit
	}

view raw PongMBean.scala hosted with ❤ by GitHub

Finally the actor Pong implements the trait showed above and extends from our ActorWithJMXSupport.

	class Pong extends ActorWithJMXSupport with ActorLogging with PongMBean{
	import Pong._
	var lastReceivedMessage = "UNKNOWN"
	def receive = {
	case PongMessage(text) =>
	log.info("In PongActor - received message: {}", text)
	lastReceivedMessage = text
	}
	override def getMXTypeName: String = "InstrumentedPongActor"
	override def sendMessage(p1: String): Unit = {
	if (p1.equals("end")) {
	self ! PoisonPill
	} else {
	self ! PongMessage(p1)
	}
	}
	}
	object Pong {
	val props = Props[Pong]
	case class PongMessage(text: String)
	}

view raw Pong.scala hosted with ❤ by GitHub

Then we need a main application to start up the actor Pong.

	object ApplicationMain extends App {
	val system = ActorSystem("MyActorSystem")
	val pongActor = system.actorOf(Pong.props, "pongActor")
	pongActor ! PongMessage("Initial message")
	// waiting for JMX "end" message to terminate
	system.awaitTermination()
	}

view raw Main.scala hosted with ❤ by GitHub

Ok! The hard work is done. Now you have to start your application passing to the JVM this parameters:

-Dcom.sun.management.jmxremote 
-Dcom.sun.management.jmxremote.port=1617 
-Dcom.sun.management.jmxremote.authenticate=false 
-Dcom.sun.management.jmxremote.ssl=false

At this point, you have the application running with the actor Pong waiting for requests. As you can see the MBean server is listening in port 1617.

Finally executing jmc in a console, the JMX client provided by the jdk, will be opened. Then you can browse in the MBean browser to find our MBean registered. In the tab operations, you can execute the operations defined by the PongMBean. In the next video, you can see this last part clearly.