sendRequestReplyFuture then you have to use getContext().reply(..)
* to send a reply message to the original sender. If not then the sender will block until the timeout expires.
*/
- def sendRequestReplyFuture[T <: AnyRef](message: AnyRef, timeout: Long, sender: ActorRef): Future[T]
- = !!!(message, timeout)(Option(sender)).asInstanceOf[Future[T]]
+ def sendRequestReplyFuture[T <: AnyRef](message: AnyRef, timeout: Long, sender: ActorRef): Future[T] = !!!(message, timeout)(Option(sender)).asInstanceOf[Future[T]]
/**
* Akka Java API.
@@ -507,7 +503,7 @@ trait ActorRef extends ActorRefShared with java.lang.Comparable[ActorRef] { scal
override def equals(that: Any): Boolean = {
that.isInstanceOf[ActorRef] &&
- that.asInstanceOf[ActorRef].uuid == uuid
+ that.asInstanceOf[ActorRef].uuid == uuid
}
override def toString = "Actor[" + address + ":" + uuid + "]"
@@ -518,7 +514,7 @@ trait ActorRef extends ActorRefShared with java.lang.Comparable[ActorRef] { scal
*
* @author Jonas Bonér
*/
-class LocalActorRef private[akka] (private[this] val actorFactory: () => Actor, val address: String)
+class LocalActorRef private[akka] (private[this] val actorFactory: () ⇒ Actor, val address: String)
extends ActorRef with ScalaActorRef {
protected[akka] val guard = new ReentrantGuard
@@ -551,7 +547,7 @@ class LocalActorRef private[akka] (private[this] val actorFactory: () => Actor,
__lifeCycle: LifeCycle,
__supervisor: Option[ActorRef],
__hotswap: Stack[PartialFunction[Any, Unit]],
- __factory: () => Actor) = {
+ __factory: () ⇒ Actor) = {
this(__factory, __address)
_uuid = __uuid
timeout = __timeout
@@ -559,7 +555,7 @@ class LocalActorRef private[akka] (private[this] val actorFactory: () => Actor,
lifeCycle = __lifeCycle
_supervisor = __supervisor
hotswap = __hotswap
- setActorSelfFields(actor,this)
+ setActorSelfFields(actor, this)
start()
}
@@ -723,15 +719,16 @@ class LocalActorRef private[akka] (private[this] val actorFactory: () => Actor,
actor(messageHandle.message)
currentMessage = null // reset current message after successful invocation
} catch {
- case e: InterruptedException =>
+ case e: InterruptedException ⇒
currentMessage = null // received message while actor is shutting down, ignore
- case e =>
+ case e ⇒
handleExceptionInDispatch(e, messageHandle.message)
- } finally {
+ }
+ finally {
checkReceiveTimeout // Reschedule receive timeout
}
} catch {
- case e =>
+ case e ⇒
EventHandler.error(e, this, messageHandle.message.toString)
throw e
}
@@ -741,34 +738,34 @@ class LocalActorRef private[akka] (private[this] val actorFactory: () => Actor,
protected[akka] def handleTrapExit(dead: ActorRef, reason: Throwable) {
faultHandler match {
- case AllForOneStrategy(trapExit,maxRetries, within) if trapExit.exists(_.isAssignableFrom(reason.getClass)) =>
+ case AllForOneStrategy(trapExit, maxRetries, within) if trapExit.exists(_.isAssignableFrom(reason.getClass)) ⇒
restartLinkedActors(reason, maxRetries, within)
- case OneForOneStrategy(trapExit,maxRetries, within) if trapExit.exists(_.isAssignableFrom(reason.getClass)) =>
+ case OneForOneStrategy(trapExit, maxRetries, within) if trapExit.exists(_.isAssignableFrom(reason.getClass)) ⇒
dead.restart(reason, maxRetries, within)
- case _ =>
+ case _ ⇒
if (_supervisor.isDefined) notifySupervisorWithMessage(Exit(this, reason))
- else dead.stop()
+ else dead.stop()
}
}
private def requestRestartPermission(maxNrOfRetries: Option[Int], withinTimeRange: Option[Int]): Boolean = {
- val denied = if (maxNrOfRetries.isEmpty && withinTimeRange.isEmpty) { //Immortal
+ val denied = if (maxNrOfRetries.isEmpty && withinTimeRange.isEmpty) { //Immortal
false
} else if (withinTimeRange.isEmpty) { // restrict number of restarts
val retries = maxNrOfRetriesCount + 1
maxNrOfRetriesCount = retries //Increment number of retries
retries > maxNrOfRetries.get
- } else { // cannot restart more than N within M timerange
+ } else { // cannot restart more than N within M timerange
val retries = maxNrOfRetriesCount + 1
val windowStart = restartTimeWindowStartNanos
- val now = System.nanoTime
+ val now = System.nanoTime
//We are within the time window if it isn't the first restart, or if the window hasn't closed
- val insideWindow = if (windowStart == 0) false
- else (now - windowStart) <= TimeUnit.MILLISECONDS.toNanos(withinTimeRange.get)
+ val insideWindow = if (windowStart == 0) false
+ else (now - windowStart) <= TimeUnit.MILLISECONDS.toNanos(withinTimeRange.get)
if (windowStart == 0 || !insideWindow) //(Re-)set the start of the window
restartTimeWindowStartNanos = now
@@ -786,25 +783,25 @@ class LocalActorRef private[akka] (private[this] val actorFactory: () => Actor,
}
protected[akka] def restart(reason: Throwable, maxNrOfRetries: Option[Int], withinTimeRange: Option[Int]) {
- def performRestart() {
+ def performRestart() {
val failedActor = actorInstance.get
failedActor match {
- case p: Proxyable =>
+ case p: Proxyable ⇒
failedActor.preRestart(reason)
failedActor.postRestart(reason)
- case _ =>
+ case _ ⇒
failedActor.preRestart(reason)
val freshActor = newActor
setActorSelfFields(failedActor, null) // Only null out the references if we could instantiate the new actor
- actorInstance.set(freshActor) // Assign it here so if preStart fails, we can null out the sef-refs next call
+ actorInstance.set(freshActor) // Assign it here so if preStart fails, we can null out the sef-refs next call
freshActor.preStart()
freshActor.postRestart(reason)
}
}
def tooManyRestarts() {
- _supervisor.foreach { sup =>
+ _supervisor.foreach { sup ⇒
// can supervisor handle the notification?
val notification = MaximumNumberOfRestartsWithinTimeRangeReached(this, maxNrOfRetries, withinTimeRange, reason)
if (sup.isDefinedAt(notification)) notifySupervisorWithMessage(notification)
@@ -812,31 +809,33 @@ class LocalActorRef private[akka] (private[this] val actorFactory: () => Actor,
stop()
}
- @tailrec def attemptRestart() {
- val success = if (requestRestartPermission(maxNrOfRetries,withinTimeRange)) {
+ @tailrec
+ def attemptRestart() {
+ val success = if (requestRestartPermission(maxNrOfRetries, withinTimeRange)) {
guard.withGuard[Boolean] {
_status = ActorRefInternals.BEING_RESTARTED
lifeCycle match {
- case Temporary =>
- shutDownTemporaryActor(this)
- true
+ case Temporary ⇒
+ shutDownTemporaryActor(this)
+ true
- case _ => // either permanent or none where default is permanent
+ case _ ⇒ // either permanent or none where default is permanent
val success = try {
performRestart()
true
} catch {
- case e =>
+ case e ⇒
EventHandler.error(e, this, "Exception in restart of Actor [%s]".format(toString))
false // an error or exception here should trigger a retry
- } finally {
+ }
+ finally {
currentMessage = null
}
if (success) {
_status = ActorRefInternals.RUNNING
dispatcher.resume(this)
- restartLinkedActors(reason,maxNrOfRetries,withinTimeRange)
+ restartLinkedActors(reason, maxNrOfRetries, withinTimeRange)
}
success
}
@@ -859,8 +858,8 @@ class LocalActorRef private[akka] (private[this] val actorFactory: () => Actor,
val actorRef = i.next
actorRef.lifeCycle match {
// either permanent or none where default is permanent
- case Temporary => shutDownTemporaryActor(actorRef)
- case _ => actorRef.restart(reason, maxNrOfRetries, withinTimeRange)
+ case Temporary ⇒ shutDownTemporaryActor(actorRef)
+ case _ ⇒ actorRef.restart(reason, maxNrOfRetries, withinTimeRange)
}
}
}
@@ -899,15 +898,15 @@ class LocalActorRef private[akka] (private[this] val actorFactory: () => Actor,
if (supervisor.isDefined) notifySupervisorWithMessage(Exit(this, reason))
else {
lifeCycle match {
- case Temporary => shutDownTemporaryActor(this)
- case _ => dispatcher.resume(this) //Resume processing for this actor
+ case Temporary ⇒ shutDownTemporaryActor(this)
+ case _ ⇒ dispatcher.resume(this) //Resume processing for this actor
}
}
}
private def notifySupervisorWithMessage(notification: LifeCycleMessage) {
// FIXME to fix supervisor restart of remote actor for oneway calls, inject a supervisor proxy that can send notification back to client
- _supervisor.foreach { sup =>
+ _supervisor.foreach { sup ⇒
if (sup.isShutdown) { // if supervisor is shut down, game over for all linked actors
//Scoped stop all linked actors, to avoid leaking the 'i' val
{
@@ -925,7 +924,8 @@ class LocalActorRef private[akka] (private[this] val actorFactory: () => Actor,
private def setActorSelfFields(actor: Actor, value: ActorRef) {
- @tailrec def lookupAndSetSelfFields(clazz: Class[_],actor: Actor, value: ActorRef): Boolean = {
+ @tailrec
+ def lookupAndSetSelfFields(clazz: Class[_], actor: Actor, value: ActorRef): Boolean = {
val success = try {
val selfField = clazz.getDeclaredField("self")
val someSelfField = clazz.getDeclaredField("someSelf")
@@ -935,7 +935,7 @@ class LocalActorRef private[akka] (private[this] val actorFactory: () => Actor,
someSelfField.set(actor, if (value ne null) Some(value) else null)
true
} catch {
- case e: NoSuchFieldException => false
+ case e: NoSuchFieldException ⇒ false
}
if (success) true
@@ -999,14 +999,14 @@ private[akka] case class RemoteActorRef private[akka] (
import DeploymentConfig._
val remoteAddress = Deployer.deploymentFor(address) match {
- case Deploy(_, _, _, Clustered(home, _, _)) =>
+ case Deploy(_, _, _, Clustered(home, _, _)) ⇒
val hostname = home match {
- case Host(hostname) => hostname
- case IP(address) => address
- case Node(nodeName) => Config.hostname
+ case Host(hostname) ⇒ hostname
+ case IP(address) ⇒ address
+ case Node(nodeName) ⇒ Config.hostname
}
new InetSocketAddress(hostname, Config.remoteServerPort)
- case _ => throw new IllegalStateException(
+ case _ ⇒ throw new IllegalStateException(
"Actor with Address [" + address + "] is not bound to a Clustered Deployment")
}
@@ -1108,7 +1108,7 @@ trait ActorRefShared {
* There are implicit conversions in ../actor/Implicits.scala
* from ActorRef -> ScalaActorRef and back
*/
-trait ScalaActorRef extends ActorRefShared { ref: ActorRef =>
+trait ScalaActorRef extends ActorRefShared { ref: ActorRef ⇒
/**
* Address for actor, must be a unique one.
@@ -1202,7 +1202,7 @@ trait ScalaActorRef extends ActorRefShared { ref: ActorRef =>
try {
future.await
} catch {
- case e: FutureTimeoutException =>
+ case e: FutureTimeoutException ⇒
if (isMessageJoinPoint) {
EventHandler.error(e, this, e.getMessage)
throw e
diff --git a/akka-actor/src/main/scala/akka/actor/ActorRegistry.scala b/akka-actor/src/main/scala/akka/actor/ActorRegistry.scala
index 92f0667af6..032ba917f7 100644
--- a/akka-actor/src/main/scala/akka/actor/ActorRegistry.scala
+++ b/akka-actor/src/main/scala/akka/actor/ActorRegistry.scala
@@ -8,11 +8,11 @@ import scala.collection.mutable.ListBuffer
import scala.reflect.Manifest
import annotation.tailrec
-import java.util.concurrent.{ConcurrentSkipListSet, ConcurrentHashMap}
-import java.util.{Set => JSet}
+import java.util.concurrent.{ ConcurrentSkipListSet, ConcurrentHashMap }
+import java.util.{ Set ⇒ JSet }
import akka.util.ReflectiveAccess._
-import akka.util.{ReflectiveAccess, ReadWriteGuard, ListenerManagement}
+import akka.util.{ ReflectiveAccess, ReadWriteGuard, ListenerManagement }
import akka.serialization._
/**
@@ -33,9 +33,9 @@ case class ActorUnregistered(address: String, actor: ActorRef) extends ActorRegi
private[actor] final class ActorRegistry private[actor] () extends ListenerManagement {
//private val isClusterEnabled = ReflectiveAccess.isClusterEnabled
- private val actorsByAddress = new ConcurrentHashMap[String, ActorRef]
- private val actorsByUuid = new ConcurrentHashMap[String, ActorRef]
- private val guard = new ReadWriteGuard
+ private val actorsByAddress = new ConcurrentHashMap[String, ActorRef]
+ private val actorsByUuid = new ConcurrentHashMap[String, ActorRef]
+ private val guard = new ReadWriteGuard
val local = new LocalActorRegistry(actorsByAddress, actorsByUuid)
@@ -44,8 +44,8 @@ private[actor] final class ActorRegistry private[actor] () extends ListenerManag
*/
def actorFor(address: String): Option[ActorRef] = {
if (actorsByAddress.containsKey(address)) Some(actorsByAddress.get(address))
-// else if (isClusterEnabled) ClusterModule.node.use(address) // FIXME uncomment and fix
- else None
+ // else if (isClusterEnabled) ClusterModule.node.use(address) // FIXME uncomment and fix
+ else None
}
/**
@@ -150,7 +150,7 @@ class LocalActorRegistry(
*/
def actorFor(address: String): Option[ActorRef] = {
if (actorsByAddress.containsKey(address)) Some(actorsByAddress.get(address))
- else None
+ else None
}
/**
@@ -159,7 +159,7 @@ class LocalActorRegistry(
private[akka] def actorFor(uuid: Uuid): Option[ActorRef] = {
val uuidAsString = uuid.toString
if (actorsByUuid.containsKey(uuidAsString)) Some(actorsByUuid.get(uuidAsString))
- else None
+ else None
}
/**
@@ -181,12 +181,12 @@ class LocalActorRegistry(
/**
* Returns all actors in the system.
*/
- def actors: Array[ActorRef] = filter(_ => true)
+ def actors: Array[ActorRef] = filter(_ ⇒ true)
/**
* Invokes a function for all actors.
*/
- def foreach(f: (ActorRef) => Unit) = {
+ def foreach(f: (ActorRef) ⇒ Unit) = {
val elements = actorsByAddress.elements
while (elements.hasMoreElements) f(elements.nextElement)
}
@@ -195,7 +195,7 @@ class LocalActorRegistry(
* Invokes the function on all known actors until it returns Some
* Returns None if the function never returns Some
*/
- def find[T](f: PartialFunction[ActorRef, T]) : Option[T] = {
+ def find[T](f: PartialFunction[ActorRef, T]): Option[T] = {
val elements = actorsByAddress.elements
while (elements.hasMoreElements) {
val element = elements.nextElement
@@ -207,8 +207,8 @@ class LocalActorRegistry(
/**
* Finds all actors that satisfy a predicate.
*/
- def filter(p: ActorRef => Boolean): Array[ActorRef] = {
- val all = new ListBuffer[ActorRef]
+ def filter(p: ActorRef ⇒ Boolean): Array[ActorRef] = {
+ val all = new ListBuffer[ActorRef]
val elements = actorsByAddress.elements
while (elements.hasMoreElements) {
val actorId = elements.nextElement
@@ -222,12 +222,12 @@ class LocalActorRegistry(
/**
* Returns all typed actors in the system.
*/
- def typedActors: Array[AnyRef] = filterTypedActors(_ => true)
+ def typedActors: Array[AnyRef] = filterTypedActors(_ ⇒ true)
/**
* Invokes a function for all typed actors.
*/
- def foreachTypedActor(f: (AnyRef) => Unit) = {
+ def foreachTypedActor(f: (AnyRef) ⇒ Unit) = {
TypedActorModule.ensureEnabled
val elements = actorsByAddress.elements
while (elements.hasMoreElements) {
@@ -240,7 +240,7 @@ class LocalActorRegistry(
* Invokes the function on all known typed actors until it returns Some
* Returns None if the function never returns Some
*/
- def findTypedActor[T](f: PartialFunction[AnyRef,T]) : Option[T] = {
+ def findTypedActor[T](f: PartialFunction[AnyRef, T]): Option[T] = {
TypedActorModule.ensureEnabled
val elements = actorsByAddress.elements
while (elements.hasMoreElements) {
@@ -253,7 +253,7 @@ class LocalActorRegistry(
/**
* Finds all typed actors that satisfy a predicate.
*/
- def filterTypedActors(p: AnyRef => Boolean): Array[AnyRef] = {
+ def filterTypedActors(p: AnyRef ⇒ Boolean): Array[AnyRef] = {
TypedActorModule.ensureEnabled
val all = new ListBuffer[AnyRef]
val elements = actorsByAddress.elements
@@ -281,7 +281,7 @@ class LocalActorRegistry(
*
* @author Viktor Klang
*/
-class Index[K <: AnyRef,V <: AnyRef : Manifest] {
+class Index[K <: AnyRef, V <: AnyRef: Manifest] {
private val Naught = Array[V]() //Nil for Arrays
private val container = new ConcurrentHashMap[K, JSet[V]]
private val emptySet = new ConcurrentSkipListSet[V]
@@ -292,7 +292,8 @@ class Index[K <: AnyRef,V <: AnyRef : Manifest] {
*/
def put(key: K, value: V): Boolean = {
//Tailrecursive spin-locking put
- @tailrec def spinPut(k: K, v: V): Boolean = {
+ @tailrec
+ def spinPut(k: K, v: V): Boolean = {
var retry = false
var added = false
val set = container get k
@@ -310,7 +311,7 @@ class Index[K <: AnyRef,V <: AnyRef : Manifest] {
newSet add v
// Parry for two simultaneous putIfAbsent(id,newSet)
- val oldSet = container.putIfAbsent(k,newSet)
+ val oldSet = container.putIfAbsent(k, newSet)
if (oldSet ne null) {
oldSet.synchronized {
if (oldSet.isEmpty) retry = true //IF the set is empty then it has been removed, so signal retry
@@ -342,7 +343,7 @@ class Index[K <: AnyRef,V <: AnyRef : Manifest] {
* @return Some(value) for the first matching value where the supplied function returns true for the given key,
* if no matches it returns None
*/
- def findValue(key: K)(f: (V) => Boolean): Option[V] = {
+ def findValue(key: K)(f: (V) ⇒ Boolean): Option[V] = {
import scala.collection.JavaConversions._
val set = container get key
if (set ne null) set.iterator.find(f)
@@ -352,10 +353,10 @@ class Index[K <: AnyRef,V <: AnyRef : Manifest] {
/**
* Applies the supplied function to all keys and their values
*/
- def foreach(fun: (K,V) => Unit) {
+ def foreach(fun: (K, V) ⇒ Unit) {
import scala.collection.JavaConversions._
- container.entrySet foreach {
- (e) => e.getValue.foreach(fun(e.getKey,_))
+ container.entrySet foreach { (e) ⇒
+ e.getValue.foreach(fun(e.getKey, _))
}
}
@@ -369,8 +370,8 @@ class Index[K <: AnyRef,V <: AnyRef : Manifest] {
if (set ne null) {
set.synchronized {
if (set.remove(value)) { //If we can remove the value
- if (set.isEmpty) //and the set becomes empty
- container.remove(key,emptySet) //We try to remove the key if it's mapped to an empty set
+ if (set.isEmpty) //and the set becomes empty
+ container.remove(key, emptySet) //We try to remove the key if it's mapped to an empty set
true //Remove succeeded
} else false //Remove failed
@@ -386,5 +387,5 @@ class Index[K <: AnyRef,V <: AnyRef : Manifest] {
/**
* Removes all keys and all values
*/
- def clear = foreach { case (k, v) => remove(k, v) }
+ def clear = foreach { case (k, v) ⇒ remove(k, v) }
}
diff --git a/akka-actor/src/main/scala/akka/actor/BootableActorLoaderService.scala b/akka-actor/src/main/scala/akka/actor/BootableActorLoaderService.scala
index 73fa2e768e..de1bffb7d2 100644
--- a/akka-actor/src/main/scala/akka/actor/BootableActorLoaderService.scala
+++ b/akka-actor/src/main/scala/akka/actor/BootableActorLoaderService.scala
@@ -5,10 +5,10 @@
package akka.actor
import java.io.File
-import java.net.{URL, URLClassLoader}
+import java.net.{ URL, URLClassLoader }
import java.util.jar.JarFile
-import akka.util.{Bootable}
+import akka.util.{ Bootable }
import akka.config.Config._
/**
@@ -19,7 +19,7 @@ trait BootableActorLoaderService extends Bootable {
val BOOT_CLASSES = config.getList("akka.boot")
lazy val applicationLoader: Option[ClassLoader] = createApplicationClassLoader
- protected def createApplicationClassLoader : Option[ClassLoader] = Some({
+ protected def createApplicationClassLoader: Option[ClassLoader] = Some({
if (HOME.isDefined) {
val DEPLOY = HOME.get + "/deploy"
val DEPLOY_DIR = new File(DEPLOY)
@@ -29,7 +29,7 @@ trait BootableActorLoaderService extends Bootable {
val filesToDeploy = DEPLOY_DIR.listFiles.toArray.toList
.asInstanceOf[List[File]].filter(_.getName.endsWith(".jar"))
var dependencyJars: List[URL] = Nil
- filesToDeploy.map { file =>
+ filesToDeploy.map { file ⇒
val jarFile = new JarFile(file)
val en = jarFile.entries
while (en.hasMoreElements) {
@@ -41,14 +41,14 @@ trait BootableActorLoaderService extends Bootable {
val toDeploy = filesToDeploy.map(_.toURI.toURL)
val allJars = toDeploy ::: dependencyJars
- new URLClassLoader(allJars.toArray,Thread.currentThread.getContextClassLoader)
+ new URLClassLoader(allJars.toArray, Thread.currentThread.getContextClassLoader)
} else Thread.currentThread.getContextClassLoader
})
abstract override def onLoad = {
super.onLoad
- for (loader <- applicationLoader; clazz <- BOOT_CLASSES) {
+ for (loader ← applicationLoader; clazz ← BOOT_CLASSES) {
loader.loadClass(clazz).newInstance
}
}
diff --git a/akka-actor/src/main/scala/akka/actor/Deployer.scala b/akka-actor/src/main/scala/akka/actor/Deployer.scala
index 6ecb2ac913..cb35f62a9a 100644
--- a/akka-actor/src/main/scala/akka/actor/Deployer.scala
+++ b/akka-actor/src/main/scala/akka/actor/Deployer.scala
@@ -10,7 +10,7 @@ import java.util.concurrent.ConcurrentHashMap
import akka.event.EventHandler
import akka.actor.DeploymentConfig._
-import akka.config.{ConfigurationException, Config}
+import akka.config.{ ConfigurationException, Config }
import akka.util.ReflectiveAccess
import akka.AkkaException
@@ -147,8 +147,8 @@ object Deployer {
}
def isLocal(deployment: Deploy): Boolean = deployment match {
- case Deploy(_, _, _, Local) => true
- case _ => false
+ case Deploy(_, _, _, Local) ⇒ true
+ case _ ⇒ false
}
def isClustered(deployment: Deploy): Boolean = isLocal(deployment)
@@ -162,8 +162,8 @@ object Deployer {
*/
private[akka] def deploymentFor(address: String): Deploy = {
lookupDeploymentFor(address) match {
- case Some(deployment) => deployment
- case None => thrownNoDeploymentBoundException(address)
+ case Some(deployment) ⇒ deployment
+ case None ⇒ thrownNoDeploymentBoundException(address)
}
}
@@ -175,11 +175,11 @@ object Deployer {
try {
lookupInConfig(address)
} catch {
- case e: ConfigurationException =>
+ case e: ConfigurationException ⇒
EventHandler.error(e, this, e.getMessage)
throw e
}
- newDeployment foreach { d =>
+ newDeployment foreach { d ⇒
if (d eq null) {
val e = new IllegalStateException("Deployment for address [" + address + "] is null")
EventHandler.error(e, this, e.getMessage)
@@ -193,18 +193,18 @@ object Deployer {
private[akka] def deploymentsInConfig: List[Deploy] = {
for {
- address <- addressesInConfig
- deployment <- lookupInConfig(address)
+ address ← addressesInConfig
+ deployment ← lookupInConfig(address)
} yield deployment
}
private[akka] def addressesInConfig: List[String] = {
val deploymentPath = "akka.actor.deployment"
Config.config.getSection(deploymentPath) match {
- case None => Nil
- case Some(addressConfig) =>
+ case None ⇒ Nil
+ case Some(addressConfig) ⇒
addressConfig.map.keySet
- .map(path => path.substring(0, path.indexOf(".")))
+ .map(path ⇒ path.substring(0, path.indexOf(".")))
.toSet.toList // toSet to force uniqueness
}
}
@@ -219,25 +219,25 @@ object Deployer {
// --------------------------------
val addressPath = "akka.actor.deployment." + address
Config.config.getSection(addressPath) match {
- case None => Some(Deploy(address, Direct, "N/A", Local))
- case Some(addressConfig) =>
+ case None ⇒ Some(Deploy(address, Direct, "N/A", Local))
+ case Some(addressConfig) ⇒
// --------------------------------
// akka.actor.deployment..router
// --------------------------------
val router = addressConfig.getString("router", "direct") match {
- case "direct" => Direct
- case "round-robin" => RoundRobin
- case "random" => Random
- case "least-cpu" => LeastCPU
- case "least-ram" => LeastRAM
- case "least-messages" => LeastMessages
- case customRouterClassName =>
+ case "direct" ⇒ Direct
+ case "round-robin" ⇒ RoundRobin
+ case "random" ⇒ Random
+ case "least-cpu" ⇒ LeastCPU
+ case "least-ram" ⇒ LeastRAM
+ case "least-messages" ⇒ LeastMessages
+ case customRouterClassName ⇒
val customRouter = try {
Class.forName(customRouterClassName).newInstance.asInstanceOf[AnyRef]
} catch {
- case e => throw new ConfigurationException(
- "Config option [" + addressPath + ".router] needs to be one of " +
+ case e ⇒ throw new ConfigurationException(
+ "Config option [" + addressPath + ".router] needs to be one of " +
"[\"direct\", \"round-robin\", \"random\", \"least-cpu\", \"least-ram\", \"least-messages\" or FQN of router class]")
}
CustomRouter(customRouter)
@@ -252,33 +252,33 @@ object Deployer {
// akka.actor.deployment..clustered
// --------------------------------
addressConfig.getSection("clustered") match {
- case None =>
+ case None ⇒
Some(Deploy(address, router, "N/A", Local)) // deploy locally
- case Some(clusteredConfig) =>
+ case Some(clusteredConfig) ⇒
// --------------------------------
// akka.actor.deployment..clustered.home
// --------------------------------
val home = clusteredConfig.getString("home", "") match {
- case "" => Host("localhost")
- case home =>
+ case "" ⇒ Host("localhost")
+ case home ⇒
def raiseHomeConfigError() = throw new ConfigurationException(
- "Config option [" + addressPath +
+ "Config option [" + addressPath +
".clustered.home] needs to be on format 'host:Option
* are either instances of case class Some or it is case
diff --git a/akka-actor/src/main/scala/akka/remoteinterface/RemoteEventHandler.scala b/akka-actor/src/main/scala/akka/remoteinterface/RemoteEventHandler.scala
index 297ebdf7b7..4b1d7731fb 100644
--- a/akka-actor/src/main/scala/akka/remoteinterface/RemoteEventHandler.scala
+++ b/akka-actor/src/main/scala/akka/remoteinterface/RemoteEventHandler.scala
@@ -20,24 +20,23 @@ class RemoteEventHandler extends Actor {
def receive = {
// client
- case RemoteClientError(cause, client, address) => EventHandler.error(cause, client, "RemoteClientError - Address[%s]" format address.toString)
- case RemoteClientWriteFailed(request, cause, client, address) => EventHandler.error(cause, client, "RemoteClientWriteFailed - Request[%s] Address[%s]".format(address.toString))
- case RemoteClientDisconnected(client, address) => EventHandler.info(client, "RemoteClientDisconnected - Address[%s]" format address.toString)
- case RemoteClientConnected(client, address) => EventHandler.info(client, "RemoteClientConnected - Address[%s]" format address.toString)
- case RemoteClientStarted(client, address) => EventHandler.info(client, "RemoteClientStarted - Address[%s]" format address.toString)
- case RemoteClientShutdown(client, address) => EventHandler.info(client, "RemoteClientShutdown - Address[%s]" format address.toString)
+ case RemoteClientError(cause, client, address) ⇒ EventHandler.error(cause, client, "RemoteClientError - Address[%s]" format address.toString)
+ case RemoteClientWriteFailed(request, cause, client, address) ⇒ EventHandler.error(cause, client, "RemoteClientWriteFailed - Request[%s] Address[%s]".format(address.toString))
+ case RemoteClientDisconnected(client, address) ⇒ EventHandler.info(client, "RemoteClientDisconnected - Address[%s]" format address.toString)
+ case RemoteClientConnected(client, address) ⇒ EventHandler.info(client, "RemoteClientConnected - Address[%s]" format address.toString)
+ case RemoteClientStarted(client, address) ⇒ EventHandler.info(client, "RemoteClientStarted - Address[%s]" format address.toString)
+ case RemoteClientShutdown(client, address) ⇒ EventHandler.info(client, "RemoteClientShutdown - Address[%s]" format address.toString)
// server
- case RemoteServerError(cause, server) => EventHandler.error(cause, server, "RemoteServerError")
- case RemoteServerWriteFailed(request, cause, server, clientAddress) => EventHandler.error(cause, server, "RemoteServerWriteFailed - Request[%s] Address[%s]" format (request, clientAddress.toString))
- case RemoteServerStarted(server) => EventHandler.info(server, "RemoteServerStarted")
- case RemoteServerShutdown(server) => EventHandler.info(server, "RemoteServerShutdown")
- case RemoteServerClientConnected(server, clientAddress) => EventHandler.info(server, "RemoteServerClientConnected - Address[%s]" format clientAddress.toString)
- case RemoteServerClientDisconnected(server, clientAddress) => EventHandler.info(server, "RemoteServerClientDisconnected - Address[%s]" format clientAddress.toString)
- case RemoteServerClientClosed(server, clientAddress) => EventHandler.info(server, "RemoteServerClientClosed - Address[%s]" format clientAddress.toString)
+ case RemoteServerError(cause, server) ⇒ EventHandler.error(cause, server, "RemoteServerError")
+ case RemoteServerWriteFailed(request, cause, server, clientAddress) ⇒ EventHandler.error(cause, server, "RemoteServerWriteFailed - Request[%s] Address[%s]" format (request, clientAddress.toString))
+ case RemoteServerStarted(server) ⇒ EventHandler.info(server, "RemoteServerStarted")
+ case RemoteServerShutdown(server) ⇒ EventHandler.info(server, "RemoteServerShutdown")
+ case RemoteServerClientConnected(server, clientAddress) ⇒ EventHandler.info(server, "RemoteServerClientConnected - Address[%s]" format clientAddress.toString)
+ case RemoteServerClientDisconnected(server, clientAddress) ⇒ EventHandler.info(server, "RemoteServerClientDisconnected - Address[%s]" format clientAddress.toString)
+ case RemoteServerClientClosed(server, clientAddress) ⇒ EventHandler.info(server, "RemoteServerClientClosed - Address[%s]" format clientAddress.toString)
- case _ => //ignore other
+ case _ ⇒ //ignore other
}
}
-
diff --git a/akka-actor/src/main/scala/akka/remoteinterface/RemoteInterface.scala b/akka-actor/src/main/scala/akka/remoteinterface/RemoteInterface.scala
index a1909ddd82..55b7bcb472 100644
--- a/akka-actor/src/main/scala/akka/remoteinterface/RemoteInterface.scala
+++ b/akka-actor/src/main/scala/akka/remoteinterface/RemoteInterface.scala
@@ -15,46 +15,46 @@ import scala.reflect.BeanProperty
import java.net.InetSocketAddress
import java.util.concurrent.ConcurrentHashMap
-import java.io.{PrintWriter, PrintStream}
+import java.io.{ PrintWriter, PrintStream }
import java.lang.reflect.InvocationTargetException
trait RemoteModule {
val UUID_PREFIX = "uuid:".intern
def optimizeLocalScoped_?(): Boolean //Apply optimizations for remote operations in local scope
- protected[akka] def notifyListeners(message: => Any): Unit
+ protected[akka] def notifyListeners(message: ⇒ Any): Unit
private[akka] def actors: ConcurrentHashMap[String, ActorRef]
private[akka] def actorsByUuid: ConcurrentHashMap[String, ActorRef]
- private[akka] def actorsFactories: ConcurrentHashMap[String, () => ActorRef]
+ private[akka] def actorsFactories: ConcurrentHashMap[String, () ⇒ ActorRef]
private[akka] def typedActors: ConcurrentHashMap[String, AnyRef]
private[akka] def typedActorsByUuid: ConcurrentHashMap[String, AnyRef]
- private[akka] def typedActorsFactories: ConcurrentHashMap[String, () => AnyRef]
+ private[akka] def typedActorsFactories: ConcurrentHashMap[String, () ⇒ AnyRef]
/** Lookup methods **/
- private[akka] def findActorByAddress(address: String) : ActorRef = actors.get(address)
+ private[akka] def findActorByAddress(address: String): ActorRef = actors.get(address)
- private[akka] def findActorByUuid(uuid: String) : ActorRef = actorsByUuid.get(uuid)
+ private[akka] def findActorByUuid(uuid: String): ActorRef = actorsByUuid.get(uuid)
- private[akka] def findActorFactory(address: String) : () => ActorRef = actorsFactories.get(address)
+ private[akka] def findActorFactory(address: String): () ⇒ ActorRef = actorsFactories.get(address)
- private[akka] def findTypedActorByAddress(address: String) : AnyRef = typedActors.get(address)
+ private[akka] def findTypedActorByAddress(address: String): AnyRef = typedActors.get(address)
- private[akka] def findTypedActorFactory(address: String) : () => AnyRef = typedActorsFactories.get(address)
+ private[akka] def findTypedActorFactory(address: String): () ⇒ AnyRef = typedActorsFactories.get(address)
- private[akka] def findTypedActorByUuid(uuid: String) : AnyRef = typedActorsByUuid.get(uuid)
+ private[akka] def findTypedActorByUuid(uuid: String): AnyRef = typedActorsByUuid.get(uuid)
- private[akka] def findActorByAddressOrUuid(address: String, uuid: String) : ActorRef = {
+ private[akka] def findActorByAddressOrUuid(address: String, uuid: String): ActorRef = {
var actorRefOrNull = if (address.startsWith(UUID_PREFIX)) findActorByUuid(address.substring(UUID_PREFIX.length))
- else findActorByAddress(address)
+ else findActorByAddress(address)
if (actorRefOrNull eq null) actorRefOrNull = findActorByUuid(uuid)
actorRefOrNull
}
- private[akka] def findTypedActorByAddressOrUuid(address: String, uuid: String) : AnyRef = {
+ private[akka] def findTypedActorByAddressOrUuid(address: String, uuid: String): AnyRef = {
var actorRefOrNull = if (address.startsWith(UUID_PREFIX)) findTypedActorByUuid(address.substring(UUID_PREFIX.length))
- else findTypedActorByAddress(address)
+ else findTypedActorByAddress(address)
if (actorRefOrNull eq null) actorRefOrNull = findTypedActorByUuid(uuid)
actorRefOrNull
}
@@ -130,8 +130,8 @@ class RemoteServerException private[akka] (message: String) extends AkkaExceptio
*/
case class CannotInstantiateRemoteExceptionDueToRemoteProtocolParsingErrorException private[akka] (cause: Throwable, originalClassName: String, originalMessage: String)
extends AkkaException("\nParsingError[%s]\nOriginalException[%s]\nOriginalMessage[%s]"
- .format(cause.toString, originalClassName, originalMessage)) {
- override def printStackTrace = cause.printStackTrace
+ .format(cause.toString, originalClassName, originalMessage)) {
+ override def printStackTrace = cause.printStackTrace
override def printStackTrace(printStream: PrintStream) = cause.printStackTrace(printStream)
override def printStackTrace(printWriter: PrintWriter) = cause.printStackTrace(printWriter)
}
@@ -156,14 +156,14 @@ abstract class RemoteSupport extends ListenerManagement with RemoteServerModule
}
protected override def manageLifeCycleOfListeners = false
- protected[akka] override def notifyListeners(message: => Any): Unit = super.notifyListeners(message)
+ protected[akka] override def notifyListeners(message: ⇒ Any): Unit = super.notifyListeners(message)
- private[akka] val actors = new ConcurrentHashMap[String, ActorRef]
- private[akka] val actorsByUuid = new ConcurrentHashMap[String, ActorRef]
- private[akka] val actorsFactories = new ConcurrentHashMap[String, () => ActorRef]
- private[akka] val typedActors = new ConcurrentHashMap[String, AnyRef]
- private[akka] val typedActorsByUuid = new ConcurrentHashMap[String, AnyRef]
- private[akka] val typedActorsFactories = new ConcurrentHashMap[String, () => AnyRef]
+ private[akka] val actors = new ConcurrentHashMap[String, ActorRef]
+ private[akka] val actorsByUuid = new ConcurrentHashMap[String, ActorRef]
+ private[akka] val actorsFactories = new ConcurrentHashMap[String, () ⇒ ActorRef]
+ private[akka] val typedActors = new ConcurrentHashMap[String, AnyRef]
+ private[akka] val typedActorsByUuid = new ConcurrentHashMap[String, AnyRef]
+ private[akka] val typedActorsFactories = new ConcurrentHashMap[String, () ⇒ AnyRef]
def clear {
actors.clear
@@ -201,28 +201,28 @@ trait RemoteServerModule extends RemoteModule {
*/
def start(): RemoteServerModule =
start(ReflectiveAccess.RemoteModule.configDefaultAddress.getAddress.getHostAddress,
- ReflectiveAccess.RemoteModule.configDefaultAddress.getPort,
- None)
+ ReflectiveAccess.RemoteModule.configDefaultAddress.getPort,
+ None)
/**
* Starts the server up
*/
def start(loader: ClassLoader): RemoteServerModule =
start(ReflectiveAccess.RemoteModule.configDefaultAddress.getAddress.getHostAddress,
- ReflectiveAccess.RemoteModule.configDefaultAddress.getPort,
- Option(loader))
+ ReflectiveAccess.RemoteModule.configDefaultAddress.getPort,
+ Option(loader))
/**
* Starts the server up
*/
def start(host: String, port: Int): RemoteServerModule =
- start(host,port,None)
+ start(host, port, None)
/**
* Starts the server up
*/
def start(host: String, port: Int, loader: ClassLoader): RemoteServerModule =
- start(host,port,Option(loader))
+ start(host, port, Option(loader))
/**
* Starts the server up
@@ -237,7 +237,7 @@ trait RemoteServerModule extends RemoteModule {
/**
* Register typed actor by interface name.
*/
- def registerTypedActor(intfClass: Class[_], typedActor: AnyRef) : Unit = registerTypedActor(intfClass.getName, typedActor)
+ def registerTypedActor(intfClass: Class[_], typedActor: AnyRef): Unit = registerTypedActor(intfClass.getName, typedActor)
/**
* Register remote typed actor by a specific id.
@@ -249,20 +249,20 @@ trait RemoteServerModule extends RemoteModule {
/**
* Register typed actor by interface name.
*/
- def registerTypedPerSessionActor(intfClass: Class[_], factory: => AnyRef) : Unit = registerTypedActor(intfClass.getName, factory)
+ def registerTypedPerSessionActor(intfClass: Class[_], factory: ⇒ AnyRef): Unit = registerTypedActor(intfClass.getName, factory)
/**
* Register typed actor by interface name.
* Java API
*/
- def registerTypedPerSessionActor(intfClass: Class[_], factory: Creator[AnyRef]) : Unit = registerTypedActor(intfClass.getName, factory)
+ def registerTypedPerSessionActor(intfClass: Class[_], factory: Creator[AnyRef]): Unit = registerTypedActor(intfClass.getName, factory)
/**
* Register remote typed actor by a specific id.
* @param address actor address
* @param typedActor typed actor to register
*/
- def registerTypedPerSessionActor(address: String, factory: => AnyRef): Unit
+ def registerTypedPerSessionActor(address: String, factory: ⇒ AnyRef): Unit
/**
* Register remote typed actor by a specific id.
@@ -295,7 +295,7 @@ trait RemoteServerModule extends RemoteModule {
*
* NOTE: If you use this method to register your remote actor then you must unregister the actor by this ID yourself.
*/
- def registerPerSession(address: String, factory: => ActorRef): Unit
+ def registerPerSession(address: String, factory: ⇒ ActorRef): Unit
/**
* Register Remote Session Actor by a specific 'id' passed as argument.
@@ -332,14 +332,14 @@ trait RemoteServerModule extends RemoteModule {
def unregisterTypedActor(address: String): Unit
/**
- * Unregister Remote Typed Actor by specific 'id'.
- *
- * NOTE: You need to call this method if you have registered an actor by a custom ID.
- */
- def unregisterTypedPerSessionActor(address: String): Unit
+ * Unregister Remote Typed Actor by specific 'id'.
+ *
+ * NOTE: You need to call this method if you have registered an actor by a custom ID.
+ */
+ def unregisterTypedPerSessionActor(address: String): Unit
}
-trait RemoteClientModule extends RemoteModule { self: RemoteModule =>
+trait RemoteClientModule extends RemoteModule { self: RemoteModule ⇒
def actorFor(address: String, hostname: String, port: Int): ActorRef =
actorFor(address, Actor.TIMEOUT, hostname, port, None)
diff --git a/akka-actor/src/main/scala/akka/routing/ConsistentHash.scala b/akka-actor/src/main/scala/akka/routing/ConsistentHash.scala
index 2b89b127ee..9e9a5e41ac 100644
--- a/akka-actor/src/main/scala/akka/routing/ConsistentHash.scala
+++ b/akka-actor/src/main/scala/akka/routing/ConsistentHash.scala
@@ -4,8 +4,8 @@
package akka.routing
-import scala.collection.immutable.{TreeSet, Seq}
-import scala.collection.mutable.{Buffer, Map}
+import scala.collection.immutable.{ TreeSet, Seq }
+import scala.collection.mutable.{ Buffer, Map }
// =============================================================================================
// Adapted from HashRing.scala in Debasish Ghosh's Redis Client, licensed under Apache 2 license
@@ -19,15 +19,15 @@ import scala.collection.mutable.{Buffer, Map}
* @author Jonas Bonér
*/
class ConsistentHash[T](nodes: Seq[T], replicas: Int) {
- private val cluster = Buffer[T]()
+ private val cluster = Buffer[T]()
private var sortedKeys = TreeSet[Long]()
- private var ring = Map[Long, T]()
+ private var ring = Map[Long, T]()
nodes.foreach(this += _)
def +=(node: T) {
cluster += node
- (1 to replicas) foreach { replica =>
+ (1 to replicas) foreach { replica ⇒
val key = hashFor((node + ":" + replica).getBytes("UTF-8"))
ring += (key -> node)
sortedKeys = sortedKeys + key
@@ -36,7 +36,7 @@ class ConsistentHash[T](nodes: Seq[T], replicas: Int) {
def -=(node: T) {
cluster -= node
- (1 to replicas) foreach { replica =>
+ (1 to replicas) foreach { replica ⇒
val key = hashFor((node + ":" + replica).getBytes("UTF-8"))
ring -= key
sortedKeys = sortedKeys - key
@@ -47,9 +47,9 @@ class ConsistentHash[T](nodes: Seq[T], replicas: Int) {
val hash = hashFor(key)
if (sortedKeys contains hash) ring(hash)
else {
- if (hash < sortedKeys.firstKey) ring(sortedKeys.firstKey)
- else if (hash > sortedKeys.lastKey) ring(sortedKeys.lastKey)
- else ring(sortedKeys.rangeImpl(None, Some(hash)).lastKey)
+ if (hash < sortedKeys.firstKey) ring(sortedKeys.firstKey)
+ else if (hash > sortedKeys.lastKey) ring(sortedKeys.lastKey)
+ else ring(sortedKeys.rangeImpl(None, Some(hash)).lastKey)
}
}
@@ -68,7 +68,8 @@ class ConsistentHash[T](nodes: Seq[T], replicas: Int) {
** |/ **
\* */
-/** An implementation of Austin Appleby's MurmurHash 3.0 algorithm
+/**
+ * An implementation of Austin Appleby's MurmurHash 3.0 algorithm
* (32 bit version); reference: http://code.google.com/p/smhasher
*
* This is the hash used by collections and case classes (including
@@ -79,14 +80,15 @@ class ConsistentHash[T](nodes: Seq[T], replicas: Int) {
* @since 2.9
*/
-import java.lang.Integer.{ rotateLeft => rotl }
+import java.lang.Integer.{ rotateLeft ⇒ rotl }
-/** A class designed to generate well-distributed non-cryptographic
+/**
+ * A class designed to generate well-distributed non-cryptographic
* hashes. It is designed to be passed to a collection's foreach method,
* or can take individual hash values with append. Its own hash code is
* set equal to the hash code of whatever it is hashing.
*/
-class MurmurHash[@specialized(Int,Long,Float,Double) T](seed: Int) extends (T => Unit) {
+class MurmurHash[@specialized(Int, Long, Float, Double) T](seed: Int) extends (T ⇒ Unit) {
import MurmurHash._
private var h = startHash(seed)
@@ -105,7 +107,7 @@ class MurmurHash[@specialized(Int,Long,Float,Double) T](seed: Int) extends (T =>
/** Incorporate the hash value of one item. */
def apply(t: T) {
- h = extendHash(h,t.##,c,k)
+ h = extendHash(h, t.##, c, k)
c = nextMagicA(c)
k = nextMagicB(k)
hashed = false
@@ -113,7 +115,7 @@ class MurmurHash[@specialized(Int,Long,Float,Double) T](seed: Int) extends (T =>
/** Incorporate a known hash value. */
def append(i: Int) {
- h = extendHash(h,i,c,k)
+ h = extendHash(h, i, c, k)
c = nextMagicA(c)
k = nextMagicB(k)
hashed = false
@@ -130,7 +132,8 @@ class MurmurHash[@specialized(Int,Long,Float,Double) T](seed: Int) extends (T =>
override def hashCode = hash
}
-/** An object designed to generate well-distributed non-cryptographic
+/**
+ * An object designed to generate well-distributed non-cryptographic
* hashes. It is designed to hash a collection of integers; along with
* the integers to hash, it generates two magic streams of integers to
* increase the distribution of repetitive input sequences. Thus,
@@ -172,7 +175,8 @@ object MurmurHash {
/** The initial magic integer in the second stream. */
def startMagicB = hiddenMagicB
- /** Incorporates a new value into an existing hash.
+ /**
+ * Incorporates a new value into an existing hash.
*
* @param hash the prior hash value
* @param value the new value to incorporate
@@ -181,18 +185,18 @@ object MurmurHash {
* @return the updated hash value
*/
def extendHash(hash: Int, value: Int, magicA: Int, magicB: Int) = {
- (hash ^ rotl(value*magicA,11)*magicB)*3 + visibleMixer
+ (hash ^ rotl(value * magicA, 11) * magicB) * 3 + visibleMixer
}
/** Given a magic integer from the first stream, compute the next */
- def nextMagicA(magicA: Int) = magicA*5 + hiddenMixerA
+ def nextMagicA(magicA: Int) = magicA * 5 + hiddenMixerA
/** Given a magic integer from the second stream, compute the next */
- def nextMagicB(magicB: Int) = magicB*5 + hiddenMixerB
+ def nextMagicB(magicB: Int) = magicB * 5 + hiddenMixerB
/** Once all hashes have been incorporated, this performs a final mixing */
def finalizeHash(hash: Int) = {
- var i = (hash ^ (hash>>>16))
+ var i = (hash ^ (hash >>> 16))
i *= finalMixer1
i ^= (i >>> 13)
i *= finalMixer2
@@ -221,25 +225,26 @@ object MurmurHash {
var c = hiddenMagicA
var k = hiddenMagicB
var j = 0
- while (j+1 < s.length) {
- val i = (s.charAt(j)<<16) + s.charAt(j+1);
- h = extendHash(h,i,c,k)
+ while (j + 1 < s.length) {
+ val i = (s.charAt(j) << 16) + s.charAt(j + 1);
+ h = extendHash(h, i, c, k)
c = nextMagicA(c)
k = nextMagicB(k)
j += 2
}
- if (j < s.length) h = extendHash(h,s.charAt(j),c,k)
+ if (j < s.length) h = extendHash(h, s.charAt(j), c, k)
finalizeHash(h)
}
- /** Compute a hash that is symmetric in its arguments--that is,
+ /**
+ * Compute a hash that is symmetric in its arguments--that is,
* where the order of appearance of elements does not matter.
* This is useful for hashing sets, for example.
*/
def symmetricHash[T](xs: TraversableOnce[T], seed: Int) = {
- var a,b,n = 0
+ var a, b, n = 0
var c = 1
- xs.foreach(i => {
+ xs.foreach(i ⇒ {
val h = i.##
a += h
b ^= h
diff --git a/akka-actor/src/main/scala/akka/routing/Listeners.scala b/akka-actor/src/main/scala/akka/routing/Listeners.scala
index 3b774d9323..448511d8dd 100644
--- a/akka-actor/src/main/scala/akka/routing/Listeners.scala
+++ b/akka-actor/src/main/scala/akka/routing/Listeners.scala
@@ -4,14 +4,14 @@
package akka.routing
-import akka.actor.{Actor, ActorRef}
+import akka.actor.{ Actor, ActorRef }
import java.util.concurrent.ConcurrentSkipListSet
import scala.collection.JavaConversions._
sealed trait ListenerMessage
case class Listen(listener: ActorRef) extends ListenerMessage
case class Deafen(listener: ActorRef) extends ListenerMessage
-case class WithListeners(f: (ActorRef) => Unit) extends ListenerMessage
+case class WithListeners(f: (ActorRef) ⇒ Unit) extends ListenerMessage
/**
* Listeners is a generic trait to implement listening capability on an Actor.
@@ -24,13 +24,13 @@ case class WithListeners(f: (ActorRef) => Unit) extends ListenerMessage
*
* Send WithListeners(fun) to traverse the current listeners.
*/
-trait Listeners { self: Actor =>
+trait Listeners { self: Actor ⇒
private val listeners = new ConcurrentSkipListSet[ActorRef]
protected def listenerManagement: Receive = {
- case Listen(l) => listeners add l
- case Deafen(l) => listeners remove l
- case WithListeners(f) => listeners foreach f
+ case Listen(l) ⇒ listeners add l
+ case Deafen(l) ⇒ listeners remove l
+ case WithListeners(f) ⇒ listeners foreach f
}
protected def gossip(msg: Any) = listeners foreach (_ ! msg)
diff --git a/akka-actor/src/main/scala/akka/routing/Pool.scala b/akka-actor/src/main/scala/akka/routing/Pool.scala
index c95a80b0fc..c036616521 100644
--- a/akka-actor/src/main/scala/akka/routing/Pool.scala
+++ b/akka-actor/src/main/scala/akka/routing/Pool.scala
@@ -4,7 +4,7 @@
package akka.routing
-import akka.actor.{Actor, ActorRef, PoisonPill}
+import akka.actor.{ Actor, ActorRef, PoisonPill }
/**
* Actor pooling
@@ -13,21 +13,21 @@ import akka.actor.{Actor, ActorRef, PoisonPill}
* There are a handful of basic concepts that need to be understood when working with and defining your pool.
*
* Selectors - A selector is a trait that determines how and how many pooled actors will receive an incoming message.
- * Capacitors - A capacitor is a trait that influences the size of pool. There are effectively two types.
+ * Capacitors - A capacitor is a trait that influences the size of pool. There are effectively two types.
* The first determines the size itself - either fixed or bounded.
* The second determines how to adjust of the pool according to some internal pressure characteristic.
* Filters - A filter can be used to refine the raw pressure value returned from a capacitor.
- *
- * It should be pointed out that all actors in the pool are treated as essentially equivalent. This is not to say
+ *
+ * It should be pointed out that all actors in the pool are treated as essentially equivalent. This is not to say
* that one couldn't instance different classes within the pool, only that the pool, when selecting and routing,
* will not take any type information into consideration.
- *
+ *
* @author Garrick Evans
*/
object ActorPool {
case object Stat
- case class Stats(size:Int)
+ case class Stats(size: Int)
}
/**
@@ -44,7 +44,7 @@ trait ActorPool {
* - checks the current capacity and adjusts accordingly if needed
* - routes the incoming message to a selection set of delegate actors
*/
-trait DefaultActorPool extends ActorPool { this: Actor =>
+trait DefaultActorPool extends ActorPool { this: Actor ⇒
import ActorPool._
import akka.actor.MaximumNumberOfRestartsWithinTimeRangeReached
@@ -52,23 +52,23 @@ trait DefaultActorPool extends ActorPool { this: Actor =>
private var _lastCapacityChange = 0
private var _lastSelectorCount = 0
- override def postStop() = _delegates foreach {
- delegate => try {
+ override def postStop() = _delegates foreach { delegate ⇒
+ try {
delegate ! PoisonPill
- } catch { case e: Exception => } //Ignore any exceptions here
+ } catch { case e: Exception ⇒ } //Ignore any exceptions here
}
protected def _route(): Receive = {
// for testing...
- case Stat =>
+ case Stat ⇒
self reply_? Stats(_delegates length)
- case max: MaximumNumberOfRestartsWithinTimeRangeReached =>
+ case max: MaximumNumberOfRestartsWithinTimeRangeReached ⇒
_delegates = _delegates filterNot { _.uuid == max.victim.uuid }
- case msg =>
+ case msg ⇒
resizeIfAppropriate()
select(_delegates) match {
- case (selectedDelegates, count) =>
+ case (selectedDelegates, count) ⇒
_lastSelectorCount = count
selectedDelegates foreach { _ forward msg } //Should we really send the same message to several actors?
}
@@ -77,20 +77,21 @@ trait DefaultActorPool extends ActorPool { this: Actor =>
private def resizeIfAppropriate() {
val requestedCapacity = capacity(_delegates)
val newDelegates = requestedCapacity match {
- case qty if qty > 0 =>
- _delegates ++ { for (i <- 0 until requestedCapacity) yield {
- val delegate = instance()
- self startLink delegate
- delegate
+ case qty if qty > 0 ⇒
+ _delegates ++ {
+ for (i ← 0 until requestedCapacity) yield {
+ val delegate = instance()
+ self startLink delegate
+ delegate
+ }
}
- }
- case qty if qty < 0 =>
+ case qty if qty < 0 ⇒
_delegates.splitAt(_delegates.length + requestedCapacity) match {
- case (keep, abandon) =>
+ case (keep, abandon) ⇒
abandon foreach { _ ! PoisonPill }
keep
}
- case _ => _delegates //No change
+ case _ ⇒ _delegates //No change
}
_lastCapacityChange = requestedCapacity
@@ -98,7 +99,6 @@ trait DefaultActorPool extends ActorPool { this: Actor =>
}
}
-
/**
* Selectors
* These traits define how, when a message needs to be routed, delegate(s) are chosen from the pool
@@ -133,13 +133,13 @@ trait RoundRobinSelector {
def selectionCount: Int
def partialFill: Boolean
- def select(delegates:Seq[ActorRef]):Tuple2[Iterator[ActorRef], Int] = {
+ def select(delegates: Seq[ActorRef]): Tuple2[Iterator[ActorRef], Int] = {
val length = delegates.length
val take = if (partialFill) math.min(selectionCount, length)
- else selectionCount
+ else selectionCount
val set =
- for (i <- 0 until take) yield {
+ for (i ← 0 until take) yield {
_last = (_last + 1) % length
delegates(_last)
}
@@ -148,7 +148,6 @@ trait RoundRobinSelector {
}
}
-
/**
* Capacitors
* These traits define how to alter the size of the pool
@@ -158,7 +157,7 @@ trait RoundRobinSelector {
* Ensures a fixed number of delegates in the pool
*/
trait FixedSizeCapacitor {
- def limit:Int
+ def limit: Int
def capacity(delegates: Seq[ActorRef]): Int = (limit - delegates.size) max 0
}
@@ -170,8 +169,8 @@ trait BoundedCapacitor {
def upperBound: Int
def capacity(delegates: Seq[ActorRef]): Int = {
- val current = delegates length
- val delta = _eval(delegates)
+ val current = delegates length
+ val delta = _eval(delegates)
val proposed = current + delta
if (proposed < lowerBound) delta + (lowerBound - proposed)
@@ -186,7 +185,7 @@ trait BoundedCapacitor {
* Returns the number of delegates required to manage the current message backlogs
*/
trait MailboxPressureCapacitor {
- def pressureThreshold:Int
+ def pressureThreshold: Int
def pressure(delegates: Seq[ActorRef]): Int =
delegates count { _.mailboxSize > pressureThreshold }
}
@@ -199,7 +198,6 @@ trait ActiveFuturesPressureCapacitor {
delegates count { _.senderFuture.isDefined }
}
-
/**
*/
trait CapacityStrategy {
@@ -230,7 +228,7 @@ trait Filter {
// are updated consistently. ramping up is always + and backing off
// is always - and each should return 0 otherwise...
def filter(pressure: Int, capacity: Int): Int =
- rampup (pressure, capacity) + backoff (pressure, capacity)
+ rampup(pressure, capacity) + backoff(pressure, capacity)
}
trait BasicFilter extends Filter with BasicRampup with BasicBackoff
@@ -247,7 +245,7 @@ trait BasicNoBackoffFilter extends BasicRampup {
*/
trait BasicRampup {
def rampupRate: Double
-
+
def rampup(pressure: Int, capacity: Int): Int =
if (pressure < capacity) 0 else math.ceil(rampupRate * capacity) toInt
}
@@ -280,8 +278,8 @@ trait RunningMeanBackoff {
_capacity += capacity
if (capacity > 0 && pressure / capacity < backoffThreshold
- && _capacity > 0 && _pressure / _capacity < backoffThreshold) //Why does the entire clause need to be true?
- math.floor(-1.0 * backoffRate * (capacity-pressure)).toInt
+ && _capacity > 0 && _pressure / _capacity < backoffThreshold) //Why does the entire clause need to be true?
+ math.floor(-1.0 * backoffRate * (capacity - pressure)).toInt
else 0
}
diff --git a/akka-actor/src/main/scala/akka/routing/Routing.scala b/akka-actor/src/main/scala/akka/routing/Routing.scala
index ef8f63e545..b87eef67bc 100644
--- a/akka-actor/src/main/scala/akka/routing/Routing.scala
+++ b/akka-actor/src/main/scala/akka/routing/Routing.scala
@@ -4,7 +4,7 @@
package akka.routing
-import akka.actor.{UntypedActor, Actor, ActorRef}
+import akka.actor.{ UntypedActor, Actor, ActorRef }
import akka.actor.Actor._
import akka.actor.ActorRef
@@ -24,7 +24,7 @@ object Routing {
* and then filtered.apply.
*/
def filter[A, B](filter: PF[A, Unit], filtered: PF[A, B]): PF[A, B] = {
- case a: A if filtered.isDefinedAt(a) && filter.isDefinedAt(a) =>
+ case a: A if filtered.isDefinedAt(a) && filter.isDefinedAt(a) ⇒
filter(a)
filtered(a)
}
@@ -32,13 +32,13 @@ object Routing {
/**
* Interceptor is a filter(x,y) where x.isDefinedAt is considered to be always true.
*/
- def intercept[A, B](interceptor: (A) => Unit, interceptee: PF[A, B]): PF[A, B] =
- filter({case a if a.isInstanceOf[A] => interceptor(a)}, interceptee)
+ def intercept[A, B](interceptor: (A) ⇒ Unit, interceptee: PF[A, B]): PF[A, B] =
+ filter({ case a if a.isInstanceOf[A] ⇒ interceptor(a) }, interceptee)
/**
* Creates a LoadBalancer from the thunk-supplied InfiniteIterator.
*/
- def loadBalancerActor(actors: => InfiniteIterator[ActorRef]): ActorRef =
+ def loadBalancerActor(actors: ⇒ InfiniteIterator[ActorRef]): ActorRef =
actorOf(new Actor with LoadBalancer {
val seq = actors
}).start()
@@ -46,7 +46,7 @@ object Routing {
/**
* Creates a Dispatcher given a routing and a message-transforming function.
*/
- def dispatcherActor(routing: PF[Any, ActorRef], msgTransformer: (Any) => Any): ActorRef =
+ def dispatcherActor(routing: PF[Any, ActorRef], msgTransformer: (Any) ⇒ Any): ActorRef =
actorOf(new Actor with Dispatcher {
override def transform(msg: Any) = msgTransformer(msg)
def routes = routing
@@ -63,8 +63,8 @@ object Routing {
* Creates an actor that pipes all incoming messages to
* both another actor and through the supplied function
*/
- def loggerActor(actorToLog: ActorRef, logger: (Any) => Unit): ActorRef =
- dispatcherActor({case _ => actorToLog}, logger)
+ def loggerActor(actorToLog: ActorRef, logger: (Any) ⇒ Unit): ActorRef =
+ dispatcherActor({ case _ ⇒ actorToLog }, logger)
}
/**
@@ -80,7 +80,8 @@ trait InfiniteIterator[T] extends Iterator[T] {
case class CyclicIterator[T](val items: Seq[T]) extends InfiniteIterator[T] {
def this(items: java.util.List[T]) = this(items.toList)
- @volatile private[this] var current: Seq[T] = items
+ @volatile
+ private[this] var current: Seq[T] = items
def hasNext = items != Nil
@@ -90,26 +91,26 @@ case class CyclicIterator[T](val items: Seq[T]) extends InfiniteIterator[T] {
nc.head
}
- override def exists(f: T => Boolean): Boolean = items.exists(f)
+ override def exists(f: T ⇒ Boolean): Boolean = items.exists(f)
}
/**
* This InfiniteIterator always returns the Actor that has the currently smallest mailbox
* useful for work-stealing.
*/
-case class SmallestMailboxFirstIterator(val items : Seq[ActorRef]) extends InfiniteIterator[ActorRef] {
+case class SmallestMailboxFirstIterator(val items: Seq[ActorRef]) extends InfiniteIterator[ActorRef] {
def this(items: java.util.List[ActorRef]) = this(items.toList)
def hasNext = items != Nil
- def next = items.reduceLeft((a1, a2) => if (a1.mailboxSize < a2.mailboxSize) a1 else a2)
+ def next = items.reduceLeft((a1, a2) ⇒ if (a1.mailboxSize < a2.mailboxSize) a1 else a2)
- override def exists(f: ActorRef => Boolean): Boolean = items.exists(f)
+ override def exists(f: ActorRef ⇒ Boolean): Boolean = items.exists(f)
}
/**
* A Dispatcher is a trait whose purpose is to route incoming messages to actors.
*/
-trait Dispatcher { this: Actor =>
+trait Dispatcher { this: Actor ⇒
protected def transform(msg: Any): Any = msg
@@ -118,9 +119,9 @@ trait Dispatcher { this: Actor =>
protected def broadcast(message: Any) {}
protected def dispatch: Receive = {
- case Routing.Broadcast(message) =>
+ case Routing.Broadcast(message) ⇒
broadcast(message)
- case a if routes.isDefinedAt(a) =>
+ case a if routes.isDefinedAt(a) ⇒
if (isSenderDefined) routes(a).forward(transform(a))(someSelf)
else routes(a).!(transform(a))(None)
}
@@ -158,16 +159,16 @@ abstract class UntypedDispatcher extends UntypedActor {
* A LoadBalancer is a specialized kind of Dispatcher, that is supplied an InfiniteIterator of targets
* to dispatch incoming messages to.
*/
-trait LoadBalancer extends Dispatcher { self: Actor =>
+trait LoadBalancer extends Dispatcher { self: Actor ⇒
protected def seq: InfiniteIterator[ActorRef]
protected def routes = {
- case x if seq.hasNext => seq.next
+ case x if seq.hasNext ⇒ seq.next
}
override def broadcast(message: Any) = seq.items.foreach(_ ! message)
- override def isDefinedAt(msg: Any) = seq.exists( _.isDefinedAt(msg) )
+ override def isDefinedAt(msg: Any) = seq.exists(_.isDefinedAt(msg))
}
/**
@@ -183,6 +184,6 @@ abstract class UntypedLoadBalancer extends UntypedDispatcher {
override def broadcast(message: Any) = seq.items.foreach(_ ! message)
- override def isDefinedAt(msg: Any) = seq.exists( _.isDefinedAt(msg) )
+ override def isDefinedAt(msg: Any) = seq.exists(_.isDefinedAt(msg))
}
diff --git a/akka-actor/src/main/scala/akka/serialization/Format.scala b/akka-actor/src/main/scala/akka/serialization/Format.scala
index bd7cb09392..114dc54830 100644
--- a/akka-actor/src/main/scala/akka/serialization/Format.scala
+++ b/akka-actor/src/main/scala/akka/serialization/Format.scala
@@ -6,13 +6,14 @@ package akka.serialization
import akka.actor.Actor
-import java.io.{ObjectOutputStream, ByteArrayOutputStream, ObjectInputStream, ByteArrayInputStream}
+import java.io.{ ObjectOutputStream, ByteArrayOutputStream, ObjectInputStream, ByteArrayInputStream }
/**
* @author Jonas Bonér
*/
trait Serializer extends scala.Serializable {
- @volatile var classLoader: Option[ClassLoader] = None
+ @volatile
+ var classLoader: Option[ClassLoader] = None
def deepClone(obj: AnyRef): AnyRef = fromBinary(toBinary(obj), Some(obj.getClass))
def toBinary(obj: AnyRef): Array[Byte]
@@ -39,7 +40,7 @@ trait Format[T <: Actor] extends FromBinary[T] with ToBinary[T]
object Format {
object Default extends Serializer {
- import java.io.{ObjectOutputStream, ByteArrayOutputStream, ObjectInputStream, ByteArrayInputStream}
+ import java.io.{ ObjectOutputStream, ByteArrayOutputStream, ObjectInputStream, ByteArrayInputStream }
//import org.apache.commons.io.input.ClassLoaderObjectInputStream
def toBinary(obj: AnyRef): Array[Byte] = {
diff --git a/akka-actor/src/main/scala/akka/util/Address.scala b/akka-actor/src/main/scala/akka/util/Address.scala
index 794039498c..23920b725e 100644
--- a/akka-actor/src/main/scala/akka/util/Address.scala
+++ b/akka-actor/src/main/scala/akka/util/Address.scala
@@ -8,8 +8,8 @@ import java.net.InetSocketAddress
object Address {
def apply(hostname: String, port: Int) = new Address(hostname, port)
def apply(inetAddress: InetSocketAddress): Address = inetAddress match {
- case null => null
- case inet => new Address(inet.getAddress.getHostAddress, inet.getPort)
+ case null ⇒ null
+ case inet ⇒ new Address(inet.getAddress.getHostAddress, inet.getPort)
}
}
@@ -23,7 +23,7 @@ class Address(val hostname: String, val port: Int) {
override def equals(that: Any): Boolean = {
that.isInstanceOf[Address] &&
- that.asInstanceOf[Address].hostname == hostname &&
- that.asInstanceOf[Address].port == port
+ that.asInstanceOf[Address].hostname == hostname &&
+ that.asInstanceOf[Address].port == port
}
}
diff --git a/akka-actor/src/main/scala/akka/util/AkkaLoader.scala b/akka-actor/src/main/scala/akka/util/AkkaLoader.scala
index c780cb48f3..cb246f2ecf 100644
--- a/akka-actor/src/main/scala/akka/util/AkkaLoader.scala
+++ b/akka-actor/src/main/scala/akka/util/AkkaLoader.scala
@@ -13,14 +13,15 @@ import akka.actor.Actor
class AkkaLoader {
private val hasBooted = new Switch(false)
- @volatile private var _bundles: Option[Bootable] = None
+ @volatile
+ private var _bundles: Option[Bootable] = None
def bundles = _bundles;
/*
* Boot initializes the specified bundles
*/
- def boot(withBanner: Boolean, b : Bootable): Unit = hasBooted switchOn {
+ def boot(withBanner: Boolean, b: Bootable): Unit = hasBooted switchOn {
if (withBanner) printBanner()
println("Starting Akka...")
b.onLoad
diff --git a/akka-actor/src/main/scala/akka/util/BoundedBlockingQueue.scala b/akka-actor/src/main/scala/akka/util/BoundedBlockingQueue.scala
index ba4e508454..48d25613ad 100644
--- a/akka-actor/src/main/scala/akka/util/BoundedBlockingQueue.scala
+++ b/akka-actor/src/main/scala/akka/util/BoundedBlockingQueue.scala
@@ -12,12 +12,12 @@ class BoundedBlockingQueue[E <: AnyRef](
val maxCapacity: Int, private val backing: Queue[E]) extends AbstractQueue[E] with BlockingQueue[E] {
backing match {
- case null => throw new IllegalArgumentException("Backing Queue may not be null")
- case b: BlockingQueue[_] =>
+ case null ⇒ throw new IllegalArgumentException("Backing Queue may not be null")
+ case b: BlockingQueue[_] ⇒
require(maxCapacity > 0)
require(b.size() == 0)
require(b.remainingCapacity >= maxCapacity)
- case b: Queue[_] =>
+ case b: Queue[_] ⇒
require(b.size() == 0)
require(maxCapacity > 0)
}
@@ -74,7 +74,7 @@ class BoundedBlockingQueue[E <: AnyRef](
var nanos = unit.toNanos(timeout)
lock.lockInterruptibly()
try {
- while(backing.size() == maxCapacity) {
+ while (backing.size() == maxCapacity) {
if (nanos <= 0)
return false
else
@@ -94,21 +94,21 @@ class BoundedBlockingQueue[E <: AnyRef](
try {
var result: E = null.asInstanceOf[E]
var hasResult = false
- while(!hasResult) {
+ while (!hasResult) {
hasResult = backing.poll() match {
- case null if nanos <= 0 =>
+ case null if nanos <= 0 ⇒
result = null.asInstanceOf[E]
true
- case null =>
+ case null ⇒
try {
nanos = notEmpty.awaitNanos(nanos)
} catch {
- case ie: InterruptedException =>
+ case ie: InterruptedException ⇒
notEmpty.signal()
throw ie
}
false
- case e =>
+ case e ⇒
notFull.signal()
result = e
true
@@ -124,8 +124,8 @@ class BoundedBlockingQueue[E <: AnyRef](
lock.lock()
try {
backing.poll() match {
- case null => null.asInstanceOf[E]
- case e =>
+ case null ⇒ null.asInstanceOf[E]
+ case e ⇒
notFull.signal()
e
}
@@ -204,10 +204,10 @@ class BoundedBlockingQueue[E <: AnyRef](
try {
var n = 0
var e: E = null.asInstanceOf[E]
- while(n < maxElements) {
+ while (n < maxElements) {
backing.poll() match {
- case null => return n
- case e =>
+ case null ⇒ return n
+ case e ⇒
c add e
n += 1
}
@@ -280,7 +280,7 @@ class BoundedBlockingQueue[E <: AnyRef](
lock.lock()
try {
val i = backing.iterator()
- while(i.hasNext) {
+ while (i.hasNext) {
if (i.next eq target) {
i.remove()
notFull.signal()
diff --git a/akka-actor/src/main/scala/akka/util/Convert.scala b/akka-actor/src/main/scala/akka/util/Convert.scala
index 85f274d26f..d91267bf6d 100644
--- a/akka-actor/src/main/scala/akka/util/Convert.scala
+++ b/akka-actor/src/main/scala/akka/util/Convert.scala
@@ -10,7 +10,7 @@ package akka.util
object Convert {
def intToBytes(value: Int): Array[Byte] = {
- val bytes = Array.fill[Byte](4)(0)
+ val bytes = Array.fill[Byte](4)(0)
bytes(0) = (value >>> 24).asInstanceOf[Byte]
bytes(1) = (value >>> 16).asInstanceOf[Byte]
bytes(2) = (value >>> 8).asInstanceOf[Byte]
@@ -19,7 +19,7 @@ object Convert {
}
def bytesToInt(bytes: Array[Byte], offset: Int): Int = {
- (0 until 4).foldLeft(0)((value, index) => value + ((bytes(index + offset) & 0x000000FF) << ((4 - 1 - index) * 8)))
+ (0 until 4).foldLeft(0)((value, index) ⇒ value + ((bytes(index + offset) & 0x000000FF) << ((4 - 1 - index) * 8)))
}
def longToBytes(value: Long): Array[Byte] = {
@@ -30,19 +30,19 @@ object Convert {
writeBuffer(3) = (value >>> 32).asInstanceOf[Byte]
writeBuffer(4) = (value >>> 24).asInstanceOf[Byte]
writeBuffer(5) = (value >>> 16).asInstanceOf[Byte]
- writeBuffer(6) = (value >>> 8).asInstanceOf[Byte]
- writeBuffer(7) = (value >>> 0).asInstanceOf[Byte]
+ writeBuffer(6) = (value >>> 8).asInstanceOf[Byte]
+ writeBuffer(7) = (value >>> 0).asInstanceOf[Byte]
writeBuffer
}
def bytesToLong(buf: Array[Byte]): Long = {
((buf(0) & 0xFFL) << 56) |
- ((buf(1) & 0xFFL) << 48) |
- ((buf(2) & 0xFFL) << 40) |
- ((buf(3) & 0xFFL) << 32) |
- ((buf(4) & 0xFFL) << 24) |
- ((buf(5) & 0xFFL) << 16) |
- ((buf(6) & 0xFFL) << 8) |
- ((buf(7) & 0xFFL) << 0)
+ ((buf(1) & 0xFFL) << 48) |
+ ((buf(2) & 0xFFL) << 40) |
+ ((buf(3) & 0xFFL) << 32) |
+ ((buf(4) & 0xFFL) << 24) |
+ ((buf(5) & 0xFFL) << 16) |
+ ((buf(6) & 0xFFL) << 8) |
+ ((buf(7) & 0xFFL) << 0)
}
}
diff --git a/akka-actor/src/main/scala/akka/util/Crypt.scala b/akka-actor/src/main/scala/akka/util/Crypt.scala
index 63d6aff4df..bf83a546a7 100644
--- a/akka-actor/src/main/scala/akka/util/Crypt.scala
+++ b/akka-actor/src/main/scala/akka/util/Crypt.scala
@@ -4,7 +4,7 @@
package akka.util
-import java.security.{MessageDigest, SecureRandom}
+import java.security.{ MessageDigest, SecureRandom }
/**
* @author Jonas Bonér
@@ -15,11 +15,11 @@ object Crypt {
lazy val random = SecureRandom.getInstance("SHA1PRNG")
- def md5(text: String): String = md5(unifyLineSeparator(text).getBytes("ASCII"))
+ def md5(text: String): String = md5(unifyLineSeparator(text).getBytes("ASCII"))
- def md5(bytes: Array[Byte]): String = digest(bytes, MessageDigest.getInstance("MD5"))
+ def md5(bytes: Array[Byte]): String = digest(bytes, MessageDigest.getInstance("MD5"))
- def sha1(text: String): String = sha1(unifyLineSeparator(text).getBytes("ASCII"))
+ def sha1(text: String): String = sha1(unifyLineSeparator(text).getBytes("ASCII"))
def sha1(bytes: Array[Byte]): String = digest(bytes, MessageDigest.getInstance("SHA1"))
@@ -36,7 +36,7 @@ object Crypt {
def hexify(bytes: Array[Byte]): String = {
val builder = new StringBuilder
- bytes.foreach { byte => builder.append(hex.charAt((byte & 0xF) >> 4)).append(hex.charAt(byte & 0xF)) }
+ bytes.foreach { byte ⇒ builder.append(hex.charAt((byte & 0xF) >> 4)).append(hex.charAt(byte & 0xF)) }
builder.toString
}
diff --git a/akka-actor/src/main/scala/akka/util/Duration.scala b/akka-actor/src/main/scala/akka/util/Duration.scala
index 4e105c198f..2e4b69756b 100644
--- a/akka-actor/src/main/scala/akka/util/Duration.scala
+++ b/akka-actor/src/main/scala/akka/util/Duration.scala
@@ -6,14 +6,14 @@ package akka.util
import java.util.concurrent.TimeUnit
import TimeUnit._
-import java.lang.{Long => JLong, Double => JDouble}
+import java.lang.{ Long ⇒ JLong, Double ⇒ JDouble }
object Duration {
- def apply(length: Long, unit: TimeUnit) : Duration = new FiniteDuration(length, unit)
- def apply(length: Double, unit: TimeUnit) : Duration = fromNanos(unit.toNanos(1) * length)
- def apply(length: Long, unit: String) : Duration = new FiniteDuration(length, timeUnit(unit))
+ def apply(length: Long, unit: TimeUnit): Duration = new FiniteDuration(length, unit)
+ def apply(length: Double, unit: TimeUnit): Duration = fromNanos(unit.toNanos(1) * length)
+ def apply(length: Long, unit: String): Duration = new FiniteDuration(length, timeUnit(unit))
- def fromNanos(nanos : Long) : Duration = {
+ def fromNanos(nanos: Long): Duration = {
if (nanos % 86400000000000L == 0) {
Duration(nanos / 86400000000000L, DAYS)
} else if (nanos % 3600000000000L == 0) {
@@ -31,18 +31,18 @@ object Duration {
}
}
- def fromNanos(nanos : Double) : Duration = fromNanos((nanos + 0.5).asInstanceOf[Long])
+ def fromNanos(nanos: Double): Duration = fromNanos((nanos + 0.5).asInstanceOf[Long])
/**
* Construct a Duration by parsing a String. In case of a format error, a
* RuntimeException is thrown. See `unapply(String)` for more information.
*/
- def apply(s : String) : Duration = unapply(s) getOrElse sys.error("format error")
+ def apply(s: String): Duration = unapply(s) getOrElse sys.error("format error")
/**
* Deconstruct a Duration into length and unit if it is finite.
*/
- def unapply(d : Duration) : Option[(Long, TimeUnit)] = {
+ def unapply(d: Duration): Option[(Long, TimeUnit)] = {
if (d.finite_?) {
Some((d.length, d.unit))
} else {
@@ -50,15 +50,15 @@ object Duration {
}
}
- private val RE = ("""^\s*(\d+(?:\.\d+)?)\s*"""+ // length part
- "(?:"+ // units are distinguished in separate match groups
- "(d|day|days)|"+
- "(h|hour|hours)|"+
- "(min|minute|minutes)|"+
- "(s|sec|second|seconds)|"+
- "(ms|milli|millis|millisecond|milliseconds)|"+
- "(µs|micro|micros|microsecond|microseconds)|"+
- "(ns|nano|nanos|nanosecond|nanoseconds)"+
+ private val RE = ("""^\s*(\d+(?:\.\d+)?)\s*""" + // length part
+ "(?:" + // units are distinguished in separate match groups
+ "(d|day|days)|" +
+ "(h|hour|hours)|" +
+ "(min|minute|minutes)|" +
+ "(s|sec|second|seconds)|" +
+ "(ms|milli|millis|millisecond|milliseconds)|" +
+ "(µs|micro|micros|microsecond|microseconds)|" +
+ "(ns|nano|nanos|nanosecond|nanoseconds)" +
""")\s*$""").r // close the non-capturing group
private val REinf = """^\s*Inf\s*$""".r
private val REminf = """^\s*(?:-\s*|Minus)Inf\s*""".r
@@ -68,73 +68,67 @@ object Duration {
* whitespace is allowed before, between and after the parts. Infinities are
* designated by `"Inf"` and `"-Inf"` or `"MinusInf"`.
*/
- def unapply(s : String) : Option[Duration] = s match {
- case RE(length, d, h, m, s, ms, mus, ns) =>
- if ( d ne null) Some(Duration(JDouble.parseDouble(length), DAYS)) else
- if ( h ne null) Some(Duration(JDouble.parseDouble(length), HOURS)) else
- if ( m ne null) Some(Duration(JDouble.parseDouble(length), MINUTES)) else
- if ( s ne null) Some(Duration(JDouble.parseDouble(length), SECONDS)) else
- if ( ms ne null) Some(Duration(JDouble.parseDouble(length), MILLISECONDS)) else
- if (mus ne null) Some(Duration(JDouble.parseDouble(length), MICROSECONDS)) else
- if ( ns ne null) Some(Duration(JDouble.parseDouble(length), NANOSECONDS)) else
- sys.error("made some error in regex (should not be possible)")
- case REinf() => Some(Inf)
- case REminf() => Some(MinusInf)
- case _ => None
+ def unapply(s: String): Option[Duration] = s match {
+ case RE(length, d, h, m, s, ms, mus, ns) ⇒
+ if (d ne null) Some(Duration(JDouble.parseDouble(length), DAYS)) else if (h ne null) Some(Duration(JDouble.parseDouble(length), HOURS)) else if (m ne null) Some(Duration(JDouble.parseDouble(length), MINUTES)) else if (s ne null) Some(Duration(JDouble.parseDouble(length), SECONDS)) else if (ms ne null) Some(Duration(JDouble.parseDouble(length), MILLISECONDS)) else if (mus ne null) Some(Duration(JDouble.parseDouble(length), MICROSECONDS)) else if (ns ne null) Some(Duration(JDouble.parseDouble(length), NANOSECONDS)) else
+ sys.error("made some error in regex (should not be possible)")
+ case REinf() ⇒ Some(Inf)
+ case REminf() ⇒ Some(MinusInf)
+ case _ ⇒ None
}
/**
* Parse TimeUnit from string representation.
*/
def timeUnit(unit: String) = unit.toLowerCase match {
- case "d" | "day" | "days" => DAYS
- case "h" | "hour" | "hours" => HOURS
- case "min" | "minute" | "minutes" => MINUTES
- case "s" | "sec" | "second" | "seconds" => SECONDS
- case "ms" | "milli" | "millis" | "millisecond" | "milliseconds" => MILLISECONDS
- case "µs" | "micro" | "micros" | "microsecond" | "microseconds" => MICROSECONDS
- case "ns" | "nano" | "nanos" | "nanosecond" | "nanoseconds" => NANOSECONDS
+ case "d" | "day" | "days" ⇒ DAYS
+ case "h" | "hour" | "hours" ⇒ HOURS
+ case "min" | "minute" | "minutes" ⇒ MINUTES
+ case "s" | "sec" | "second" | "seconds" ⇒ SECONDS
+ case "ms" | "milli" | "millis" | "millisecond" | "milliseconds" ⇒ MILLISECONDS
+ case "µs" | "micro" | "micros" | "microsecond" | "microseconds" ⇒ MICROSECONDS
+ case "ns" | "nano" | "nanos" | "nanosecond" | "nanoseconds" ⇒ NANOSECONDS
}
- val Zero : Duration = new FiniteDuration(0, NANOSECONDS)
+ val Zero: Duration = new FiniteDuration(0, NANOSECONDS)
trait Infinite {
- this : Duration =>
+ this: Duration ⇒
- override def equals(other : Any) = false
+ override def equals(other: Any) = false
- def +(other : Duration) : Duration =
+ def +(other: Duration): Duration =
other match {
- case _ : this.type => this
- case _ : Infinite => throw new IllegalArgumentException("illegal addition of infinities")
- case _ => this
+ case _: this.type ⇒ this
+ case _: Infinite ⇒ throw new IllegalArgumentException("illegal addition of infinities")
+ case _ ⇒ this
}
- def -(other : Duration) : Duration =
+ def -(other: Duration): Duration =
other match {
- case _ : this.type => throw new IllegalArgumentException("illegal subtraction of infinities")
- case _ => this
+ case _: this.type ⇒ throw new IllegalArgumentException("illegal subtraction of infinities")
+ case _ ⇒ this
}
- def *(factor : Double) : Duration = this
- def /(factor : Double) : Duration = this
- def /(other : Duration) : Double =
+ def *(factor: Double): Duration = this
+ def /(factor: Double): Duration = this
+ def /(other: Duration): Double =
other match {
- case _ : Infinite => throw new IllegalArgumentException("illegal division of infinities")
+ case _: Infinite ⇒ throw new IllegalArgumentException("illegal division of infinities")
// maybe questionable but pragmatic: Inf / 0 => Inf
- case x => Double.PositiveInfinity * (if ((this > Zero) ^ (other >= Zero)) -1 else 1)
+ case x ⇒ Double.PositiveInfinity * (if ((this > Zero) ^ (other >= Zero)) -1 else 1)
}
-
+
def finite_? = false
-
- def length : Long = throw new IllegalArgumentException("length not allowed on infinite Durations")
- def unit : TimeUnit = throw new IllegalArgumentException("unit not allowed on infinite Durations")
- def toNanos : Long = throw new IllegalArgumentException("toNanos not allowed on infinite Durations")
- def toMicros : Long = throw new IllegalArgumentException("toMicros not allowed on infinite Durations")
- def toMillis : Long = throw new IllegalArgumentException("toMillis not allowed on infinite Durations")
- def toSeconds : Long = throw new IllegalArgumentException("toSeconds not allowed on infinite Durations")
- def toMinutes : Long = throw new IllegalArgumentException("toMinutes not allowed on infinite Durations")
- def toHours : Long = throw new IllegalArgumentException("toHours not allowed on infinite Durations")
- def toDays : Long = throw new IllegalArgumentException("toDays not allowed on infinite Durations")
- def toUnit(unit : TimeUnit) : Double = throw new IllegalArgumentException("toUnit not allowed on infinite Durations")
+
+ def length: Long = throw new IllegalArgumentException("length not allowed on infinite Durations")
+ def unit: TimeUnit = throw new IllegalArgumentException("unit not allowed on infinite Durations")
+ def toNanos: Long = throw new IllegalArgumentException("toNanos not allowed on infinite Durations")
+ def toMicros: Long = throw new IllegalArgumentException("toMicros not allowed on infinite Durations")
+ def toMillis: Long = throw new IllegalArgumentException("toMillis not allowed on infinite Durations")
+ def toSeconds: Long = throw new IllegalArgumentException("toSeconds not allowed on infinite Durations")
+ def toMinutes: Long = throw new IllegalArgumentException("toMinutes not allowed on infinite Durations")
+ def toHours: Long = throw new IllegalArgumentException("toHours not allowed on infinite Durations")
+ def toDays: Long = throw new IllegalArgumentException("toDays not allowed on infinite Durations")
+ def toUnit(unit: TimeUnit): Double = throw new IllegalArgumentException("toUnit not allowed on infinite Durations")
def printHMS = toString
}
@@ -143,12 +137,12 @@ object Duration {
* Infinite duration: greater than any other and not equal to any other,
* including itself.
*/
- val Inf : Duration = new Duration with Infinite {
+ val Inf: Duration = new Duration with Infinite {
override def toString = "Duration.Inf"
- def >(other : Duration) = true
- def >=(other : Duration) = true
- def <(other : Duration) = false
- def <=(other : Duration) = false
+ def >(other: Duration) = true
+ def >=(other: Duration) = true
+ def <(other: Duration) = false
+ def <=(other: Duration) = false
def unary_- : Duration = MinusInf
}
@@ -156,20 +150,20 @@ object Duration {
* Infinite negative duration: lesser than any other and not equal to any other,
* including itself.
*/
- val MinusInf : Duration = new Duration with Infinite {
+ val MinusInf: Duration = new Duration with Infinite {
override def toString = "Duration.MinusInf"
- def >(other : Duration) = false
- def >=(other : Duration) = false
- def <(other : Duration) = true
- def <=(other : Duration) = true
+ def >(other: Duration) = false
+ def >=(other: Duration) = false
+ def <(other: Duration) = true
+ def <=(other: Duration) = true
def unary_- : Duration = Inf
}
// Java Factories
- def create(length : Long, unit : TimeUnit) : Duration = apply(length, unit)
- def create(length : Double, unit : TimeUnit) : Duration = apply(length, unit)
- def create(length : Long, unit : String) : Duration = apply(length, unit)
- def parse(s : String) : Duration = unapply(s).get
+ def create(length: Long, unit: TimeUnit): Duration = apply(length, unit)
+ def create(length: Double, unit: TimeUnit): Duration = apply(length, unit)
+ def create(length: Long, unit: String): Duration = apply(length, unit)
+ def parse(s: String): Duration = unapply(s).get
}
/**
@@ -218,39 +212,39 @@ object Duration {
*
*/
abstract class Duration {
- def length : Long
- def unit : TimeUnit
- def toNanos : Long
- def toMicros : Long
- def toMillis : Long
- def toSeconds : Long
- def toMinutes : Long
- def toHours : Long
- def toDays : Long
- def toUnit(unit : TimeUnit) : Double
- def printHMS : String
- def <(other : Duration) : Boolean
- def <=(other : Duration) : Boolean
- def >(other : Duration) : Boolean
- def >=(other : Duration) : Boolean
- def +(other : Duration) : Duration
- def -(other : Duration) : Duration
- def *(factor : Double) : Duration
- def /(factor : Double) : Duration
- def /(other : Duration) : Double
+ def length: Long
+ def unit: TimeUnit
+ def toNanos: Long
+ def toMicros: Long
+ def toMillis: Long
+ def toSeconds: Long
+ def toMinutes: Long
+ def toHours: Long
+ def toDays: Long
+ def toUnit(unit: TimeUnit): Double
+ def printHMS: String
+ def <(other: Duration): Boolean
+ def <=(other: Duration): Boolean
+ def >(other: Duration): Boolean
+ def >=(other: Duration): Boolean
+ def +(other: Duration): Duration
+ def -(other: Duration): Duration
+ def *(factor: Double): Duration
+ def /(factor: Double): Duration
+ def /(other: Duration): Double
def unary_- : Duration
def finite_? : Boolean
// Java API
- def lt(other : Duration) = this < other
- def lteq(other : Duration) = this <= other
- def gt(other : Duration) = this > other
- def gteq(other : Duration) = this >= other
- def plus(other : Duration) = this + other
- def minus(other : Duration) = this - other
- def mul(factor : Double) = this * factor
- def div(factor : Double) = this / factor
- def div(other : Duration) = this / other
+ def lt(other: Duration) = this < other
+ def lteq(other: Duration) = this <= other
+ def gt(other: Duration) = this > other
+ def gteq(other: Duration) = this >= other
+ def plus(other: Duration) = this + other
+ def minus(other: Duration) = this - other
+ def mul(factor: Double) = this * factor
+ def div(factor: Double) = this / factor
+ def div(other: Duration) = this / other
def neg() = -this
def isFinite() = finite_?
}
@@ -267,28 +261,28 @@ class FiniteDuration(val length: Long, val unit: TimeUnit) extends Duration {
def toMinutes = unit.toMinutes(length)
def toHours = unit.toHours(length)
def toDays = unit.toDays(length)
- def toUnit(u : TimeUnit) = long2double(toNanos) / NANOSECONDS.convert(1, u)
+ def toUnit(u: TimeUnit) = long2double(toNanos) / NANOSECONDS.convert(1, u)
override def toString = this match {
- case Duration(1, DAYS) => "1 day"
- case Duration(x, DAYS) => x+" days"
- case Duration(1, HOURS) => "1 hour"
- case Duration(x, HOURS) => x+" hours"
- case Duration(1, MINUTES) => "1 minute"
- case Duration(x, MINUTES) => x+" minutes"
- case Duration(1, SECONDS) => "1 second"
- case Duration(x, SECONDS) => x+" seconds"
- case Duration(1, MILLISECONDS) => "1 millisecond"
- case Duration(x, MILLISECONDS) => x+" milliseconds"
- case Duration(1, MICROSECONDS) => "1 microsecond"
- case Duration(x, MICROSECONDS) => x+" microseconds"
- case Duration(1, NANOSECONDS) => "1 nanosecond"
- case Duration(x, NANOSECONDS) => x+" nanoseconds"
+ case Duration(1, DAYS) ⇒ "1 day"
+ case Duration(x, DAYS) ⇒ x + " days"
+ case Duration(1, HOURS) ⇒ "1 hour"
+ case Duration(x, HOURS) ⇒ x + " hours"
+ case Duration(1, MINUTES) ⇒ "1 minute"
+ case Duration(x, MINUTES) ⇒ x + " minutes"
+ case Duration(1, SECONDS) ⇒ "1 second"
+ case Duration(x, SECONDS) ⇒ x + " seconds"
+ case Duration(1, MILLISECONDS) ⇒ "1 millisecond"
+ case Duration(x, MILLISECONDS) ⇒ x + " milliseconds"
+ case Duration(1, MICROSECONDS) ⇒ "1 microsecond"
+ case Duration(x, MICROSECONDS) ⇒ x + " microseconds"
+ case Duration(1, NANOSECONDS) ⇒ "1 nanosecond"
+ case Duration(x, NANOSECONDS) ⇒ x + " nanoseconds"
}
def printHMS = "%02d:%02d:%06.3f".format(toHours, toMinutes % 60, toMillis / 1000. % 60)
- def <(other : Duration) = {
+ def <(other: Duration) = {
if (other.finite_?) {
toNanos < other.asInstanceOf[FiniteDuration].toNanos
} else {
@@ -296,7 +290,7 @@ class FiniteDuration(val length: Long, val unit: TimeUnit) extends Duration {
}
}
- def <=(other : Duration) = {
+ def <=(other: Duration) = {
if (other.finite_?) {
toNanos <= other.asInstanceOf[FiniteDuration].toNanos
} else {
@@ -304,7 +298,7 @@ class FiniteDuration(val length: Long, val unit: TimeUnit) extends Duration {
}
}
- def >(other : Duration) = {
+ def >(other: Duration) = {
if (other.finite_?) {
toNanos > other.asInstanceOf[FiniteDuration].toNanos
} else {
@@ -312,7 +306,7 @@ class FiniteDuration(val length: Long, val unit: TimeUnit) extends Duration {
}
}
- def >=(other : Duration) = {
+ def >=(other: Duration) = {
if (other.finite_?) {
toNanos >= other.asInstanceOf[FiniteDuration].toNanos
} else {
@@ -320,7 +314,7 @@ class FiniteDuration(val length: Long, val unit: TimeUnit) extends Duration {
}
}
- def +(other : Duration) = {
+ def +(other: Duration) = {
if (!other.finite_?) {
other
} else {
@@ -329,7 +323,7 @@ class FiniteDuration(val length: Long, val unit: TimeUnit) extends Duration {
}
}
- def -(other : Duration) = {
+ def -(other: Duration) = {
if (!other.finite_?) {
other
} else {
@@ -338,19 +332,19 @@ class FiniteDuration(val length: Long, val unit: TimeUnit) extends Duration {
}
}
- def *(factor : Double) = fromNanos(long2double(toNanos) * factor)
+ def *(factor: Double) = fromNanos(long2double(toNanos) * factor)
- def /(factor : Double) = fromNanos(long2double(toNanos) / factor)
+ def /(factor: Double) = fromNanos(long2double(toNanos) / factor)
- def /(other : Duration) = if (other.finite_?) long2double(toNanos) / other.toNanos else 0
+ def /(other: Duration) = if (other.finite_?) long2double(toNanos) / other.toNanos else 0
def unary_- = Duration(-length, unit)
def finite_? = true
- override def equals(other : Any) =
+ override def equals(other: Any) =
other.isInstanceOf[FiniteDuration] &&
- toNanos == other.asInstanceOf[FiniteDuration].toNanos
+ toNanos == other.asInstanceOf[FiniteDuration].toNanos
override def hashCode = toNanos.asInstanceOf[Int]
}
@@ -362,13 +356,13 @@ class DurationInt(n: Int) {
def nano = Duration(n, NANOSECONDS)
def microseconds = Duration(n, MICROSECONDS)
- def micros = Duration(n, MICROSECONDS)
+ def micros = Duration(n, MICROSECONDS)
def microsecond = Duration(n, MICROSECONDS)
- def micro = Duration(n, MICROSECONDS)
+ def micro = Duration(n, MICROSECONDS)
- def milliseconds = Duration(n, MILLISECONDS)
+ def milliseconds = Duration(n, MILLISECONDS)
def millis = Duration(n, MILLISECONDS)
- def millisecond = Duration(n, MILLISECONDS)
+ def millisecond = Duration(n, MILLISECONDS)
def milli = Duration(n, MILLISECONDS)
def seconds = Duration(n, SECONDS)
@@ -391,13 +385,13 @@ class DurationLong(n: Long) {
def nano = Duration(n, NANOSECONDS)
def microseconds = Duration(n, MICROSECONDS)
- def micros = Duration(n, MICROSECONDS)
+ def micros = Duration(n, MICROSECONDS)
def microsecond = Duration(n, MICROSECONDS)
- def micro = Duration(n, MICROSECONDS)
+ def micro = Duration(n, MICROSECONDS)
- def milliseconds = Duration(n, MILLISECONDS)
+ def milliseconds = Duration(n, MILLISECONDS)
def millis = Duration(n, MILLISECONDS)
- def millisecond = Duration(n, MILLISECONDS)
+ def millisecond = Duration(n, MILLISECONDS)
def milli = Duration(n, MILLISECONDS)
def seconds = Duration(n, SECONDS)
@@ -420,13 +414,13 @@ class DurationDouble(d: Double) {
def nano = Duration(d, NANOSECONDS)
def microseconds = Duration(d, MICROSECONDS)
- def micros = Duration(d, MICROSECONDS)
+ def micros = Duration(d, MICROSECONDS)
def microsecond = Duration(d, MICROSECONDS)
- def micro = Duration(d, MICROSECONDS)
+ def micro = Duration(d, MICROSECONDS)
- def milliseconds = Duration(d, MILLISECONDS)
+ def milliseconds = Duration(d, MILLISECONDS)
def millis = Duration(d, MILLISECONDS)
- def millisecond = Duration(d, MILLISECONDS)
+ def millisecond = Duration(d, MILLISECONDS)
def milli = Duration(d, MILLISECONDS)
def seconds = Duration(d, SECONDS)
diff --git a/akka-actor/src/main/scala/akka/util/HashCode.scala b/akka-actor/src/main/scala/akka/util/HashCode.scala
index 51d2926bb9..4dc74c932a 100644
--- a/akka-actor/src/main/scala/akka/util/HashCode.scala
+++ b/akka-actor/src/main/scala/akka/util/HashCode.scala
@@ -4,8 +4,8 @@
package akka.util
-import java.lang.reflect.{Array => JArray}
-import java.lang.{Float => JFloat, Double => JDouble}
+import java.lang.reflect.{ Array ⇒ JArray }
+import java.lang.{ Float ⇒ JFloat, Double ⇒ JDouble }
/**
* Set of methods which allow easy implementation of hashCode.
@@ -28,25 +28,25 @@ object HashCode {
val SEED = 23
def hash(seed: Int, any: Any): Int = any match {
- case value: Boolean => hash(seed, value)
- case value: Char => hash(seed, value)
- case value: Short => hash(seed, value)
- case value: Int => hash(seed, value)
- case value: Long => hash(seed, value)
- case value: Float => hash(seed, value)
- case value: Double => hash(seed, value)
- case value: Byte => hash(seed, value)
- case value: AnyRef =>
+ case value: Boolean ⇒ hash(seed, value)
+ case value: Char ⇒ hash(seed, value)
+ case value: Short ⇒ hash(seed, value)
+ case value: Int ⇒ hash(seed, value)
+ case value: Long ⇒ hash(seed, value)
+ case value: Float ⇒ hash(seed, value)
+ case value: Double ⇒ hash(seed, value)
+ case value: Byte ⇒ hash(seed, value)
+ case value: AnyRef ⇒
var result = seed
if (value eq null) result = hash(result, 0)
else if (!isArray(value)) result = hash(result, value.hashCode())
- else for (id <- 0 until JArray.getLength(value)) result = hash(result, JArray.get(value, id)) // is an array
+ else for (id ← 0 until JArray.getLength(value)) result = hash(result, JArray.get(value, id)) // is an array
result
}
def hash(seed: Int, value: Boolean): Int = firstTerm(seed) + (if (value) 1 else 0)
def hash(seed: Int, value: Char): Int = firstTerm(seed) + value.asInstanceOf[Int]
def hash(seed: Int, value: Int): Int = firstTerm(seed) + value
- def hash(seed: Int, value: Long): Int = firstTerm(seed) + (value ^ (value >>> 32) ).asInstanceOf[Int]
+ def hash(seed: Int, value: Long): Int = firstTerm(seed) + (value ^ (value >>> 32)).asInstanceOf[Int]
def hash(seed: Int, value: Float): Int = hash(seed, JFloat.floatToIntBits(value))
def hash(seed: Int, value: Double): Int = hash(seed, JDouble.doubleToLongBits(value))
diff --git a/akka-actor/src/main/scala/akka/util/Helpers.scala b/akka-actor/src/main/scala/akka/util/Helpers.scala
index 405df37aac..6b80dfec5a 100644
--- a/akka-actor/src/main/scala/akka/util/Helpers.scala
+++ b/akka-actor/src/main/scala/akka/util/Helpers.scala
@@ -23,28 +23,27 @@ object Helpers {
}
def bytesToInt(bytes: Array[Byte], offset: Int): Int = {
- (0 until 4).foldLeft(0)((value, index) => value + ((bytes(index + offset) & 0x000000FF) << ((4 - 1 - index) * 8)))
+ (0 until 4).foldLeft(0)((value, index) ⇒ value + ((bytes(index + offset) & 0x000000FF) << ((4 - 1 - index) * 8)))
}
def flatten[T: ClassManifest](array: Array[Any]) = array.flatMap {
- case arr: Array[T] => arr
- case elem: T => Array(elem)
+ case arr: Array[T] ⇒ arr
+ case elem: T ⇒ Array(elem)
}
- def ignore[E : Manifest](body: => Unit) {
- try {
- body
- }
- catch {
- case e if manifest[E].erasure.isAssignableFrom(e.getClass) => ()
- }
- }
-
- def withPrintStackTraceOnError(body: => Unit) {
+ def ignore[E: Manifest](body: ⇒ Unit) {
try {
body
} catch {
- case e: Throwable =>
+ case e if manifest[E].erasure.isAssignableFrom(e.getClass) ⇒ ()
+ }
+ }
+
+ def withPrintStackTraceOnError(body: ⇒ Unit) {
+ try {
+ body
+ } catch {
+ case e: Throwable ⇒
EventHandler.error(e, this, e.toString)
throw e
}
@@ -67,7 +66,7 @@ object Helpers {
try {
narrow(o)
} catch {
- case e: ClassCastException =>
+ case e: ClassCastException ⇒
None
}
@@ -80,7 +79,7 @@ object Helpers {
* res0: ResultOrError[Int] = ResultOrError@a96606
*
* scala> res0()
- res1: Int = 1
+ * res1: Int = 1
*
* scala> res0() = 3
*
@@ -103,20 +102,20 @@ object Helpers {
* at Re...
*
*/
- class ResultOrError[R](result: R){
+ class ResultOrError[R](result: R) {
private[this] var contents: Either[R, Throwable] = Left(result)
- def update(value: => R) {
+ def update(value: ⇒ R) {
contents = try {
Left(value)
} catch {
- case (error : Throwable) => Right(error)
+ case (error: Throwable) ⇒ Right(error)
}
}
def apply() = contents match {
- case Left(result) => result
- case Right(error) => throw error.fillInStackTrace
+ case Left(result) ⇒ result
+ case Right(error) ⇒ throw error.fillInStackTrace
}
}
object ResultOrError {
diff --git a/akka-actor/src/main/scala/akka/util/JMX.scala b/akka-actor/src/main/scala/akka/util/JMX.scala
index 05ba9c9ff1..d75269c1e0 100644
--- a/akka-actor/src/main/scala/akka/util/JMX.scala
+++ b/akka-actor/src/main/scala/akka/util/JMX.scala
@@ -7,7 +7,7 @@ package akka.util
import akka.event.EventHandler
import java.lang.management.ManagementFactory
-import javax.management.{ObjectInstance, ObjectName, InstanceAlreadyExistsException, InstanceNotFoundException}
+import javax.management.{ ObjectInstance, ObjectName, InstanceAlreadyExistsException, InstanceNotFoundException }
/**
* @author Jonas Bonér
@@ -21,9 +21,9 @@ object JMX {
def register(name: ObjectName, mbean: AnyRef): Option[ObjectInstance] = try {
Some(mbeanServer.registerMBean(mbean, name))
} catch {
- case e: InstanceAlreadyExistsException =>
+ case e: InstanceAlreadyExistsException ⇒
Some(mbeanServer.getObjectInstance(name))
- case e: Exception =>
+ case e: Exception ⇒
EventHandler.error(e, this, "Error when registering mbean [%s]".format(mbean))
None
}
@@ -31,7 +31,7 @@ object JMX {
def unregister(mbean: ObjectName) = try {
mbeanServer.unregisterMBean(mbean)
} catch {
- case e: InstanceNotFoundException => {}
- case e: Exception => EventHandler.error(e, this, "Error while unregistering mbean [%s]".format(mbean))
+ case e: InstanceNotFoundException ⇒ {}
+ case e: Exception ⇒ EventHandler.error(e, this, "Error while unregistering mbean [%s]".format(mbean))
}
}
diff --git a/akka-actor/src/main/scala/akka/util/ListenerManagement.scala b/akka-actor/src/main/scala/akka/util/ListenerManagement.scala
index ede46fc80a..e667890914 100644
--- a/akka-actor/src/main/scala/akka/util/ListenerManagement.scala
+++ b/akka-actor/src/main/scala/akka/util/ListenerManagement.scala
@@ -5,7 +5,7 @@
package akka.util
import java.util.concurrent.ConcurrentSkipListSet
-import akka.actor.{ActorInitializationException, ActorRef}
+import akka.actor.{ ActorInitializationException, ActorRef }
/**
* A manager for listener actors. Intended for mixin by observables.
@@ -50,7 +50,7 @@ trait ListenerManagement {
*/
def hasListener(listener: ActorRef): Boolean = listeners.contains(listener)
- protected[akka] def notifyListeners(message: => Any) {
+ protected[akka] def notifyListeners(message: ⇒ Any) {
if (hasListeners) {
val msg = message
val iterator = listeners.iterator
@@ -61,7 +61,7 @@ trait ListenerManagement {
try {
listener ! msg
} catch {
- case e : ActorInitializationException =>
+ case e: ActorInitializationException ⇒
if (listener.isShutdown) iterator.remove()
}
}
@@ -71,7 +71,7 @@ trait ListenerManagement {
/**
* Execute f with each listener as argument. ActorInitializationException is not handled.
*/
- protected[akka] def foreachListener(f: (ActorRef) => Unit) {
+ protected[akka] def foreachListener(f: (ActorRef) ⇒ Unit) {
val iterator = listeners.iterator
while (iterator.hasNext) {
val listener = iterator.next
diff --git a/akka-actor/src/main/scala/akka/util/LockUtil.scala b/akka-actor/src/main/scala/akka/util/LockUtil.scala
index bf72714c33..b281ca89be 100644
--- a/akka-actor/src/main/scala/akka/util/LockUtil.scala
+++ b/akka-actor/src/main/scala/akka/util/LockUtil.scala
@@ -4,8 +4,8 @@
package akka.util
-import java.util.concurrent.locks.{ReentrantReadWriteLock, ReentrantLock}
-import java.util.concurrent.atomic. {AtomicBoolean}
+import java.util.concurrent.locks.{ ReentrantReadWriteLock, ReentrantLock }
+import java.util.concurrent.atomic.{ AtomicBoolean }
import akka.event.EventHandler
/**
@@ -14,7 +14,7 @@ import akka.event.EventHandler
final class ReentrantGuard {
val lock = new ReentrantLock
- final def withGuard[T](body: => T): T = {
+ final def withGuard[T](body: ⇒ T): T = {
lock.lock
try {
body
@@ -23,8 +23,8 @@ final class ReentrantGuard {
}
}
- final def tryWithGuard[T](body: => T): T = {
- while(!lock.tryLock) { Thread.sleep(10) } // wait on the monitor to be unlocked
+ final def tryWithGuard[T](body: ⇒ T): T = {
+ while (!lock.tryLock) { Thread.sleep(10) } // wait on the monitor to be unlocked
try {
body
} finally {
@@ -41,7 +41,7 @@ class ReadWriteGuard {
val readLock = rwl.readLock
val writeLock = rwl.writeLock
- def withWriteGuard[T](body: => T): T = {
+ def withWriteGuard[T](body: ⇒ T): T = {
writeLock.lock
try {
body
@@ -50,7 +50,7 @@ class ReadWriteGuard {
}
}
- def withReadGuard[T](body: => T): T = {
+ def withReadGuard[T](body: ⇒ T): T = {
readLock.lock
try {
body
@@ -67,7 +67,7 @@ class ReadWriteGuard {
class SimpleLock {
val acquired = new AtomicBoolean(false)
- def ifPossible(perform: () => Unit): Boolean = {
+ def ifPossible(perform: () ⇒ Unit): Boolean = {
if (tryLock()) {
try {
perform
@@ -78,7 +78,7 @@ class SimpleLock {
} else false
}
- def ifPossibleYield[T](perform: () => T): Option[T] = {
+ def ifPossibleYield[T](perform: () ⇒ T): Option[T] = {
if (tryLock()) {
try {
Some(perform())
@@ -88,7 +88,7 @@ class SimpleLock {
} else None
}
- def ifPossibleApply[T,R](value: T)(function: (T) => R): Option[R] = {
+ def ifPossibleApply[T, R](value: T)(function: (T) ⇒ R): Option[R] = {
if (tryLock()) {
try {
Some(function(value))
@@ -100,11 +100,11 @@ class SimpleLock {
def tryLock() = {
if (acquired.get) false
- else acquired.compareAndSet(false,true)
+ else acquired.compareAndSet(false, true)
}
def tryUnlock() = {
- acquired.compareAndSet(true,false)
+ acquired.compareAndSet(true, false)
}
def locked = acquired.get
@@ -120,12 +120,12 @@ class SimpleLock {
class Switch(startAsOn: Boolean = false) {
private val switch = new AtomicBoolean(startAsOn)
- protected def transcend(from: Boolean, action: => Unit): Boolean = synchronized {
+ protected def transcend(from: Boolean, action: ⇒ Unit): Boolean = synchronized {
if (switch.compareAndSet(from, !from)) {
try {
action
} catch {
- case e: Throwable =>
+ case e: Throwable ⇒
EventHandler.error(e, this, e.getMessage)
switch.compareAndSet(!from, from) // revert status
throw e
@@ -134,61 +134,61 @@ class Switch(startAsOn: Boolean = false) {
} else false
}
- def switchOff(action: => Unit): Boolean = transcend(from = true, action)
- def switchOn(action: => Unit): Boolean = transcend(from = false, action)
+ def switchOff(action: ⇒ Unit): Boolean = transcend(from = true, action)
+ def switchOn(action: ⇒ Unit): Boolean = transcend(from = false, action)
def switchOff: Boolean = synchronized { switch.compareAndSet(true, false) }
- def switchOn: Boolean = synchronized { switch.compareAndSet(false, true) }
+ def switchOn: Boolean = synchronized { switch.compareAndSet(false, true) }
- def ifOnYield[T](action: => T): Option[T] = {
+ def ifOnYield[T](action: ⇒ T): Option[T] = {
if (switch.get) Some(action)
else None
}
- def ifOffYield[T](action: => T): Option[T] = {
+ def ifOffYield[T](action: ⇒ T): Option[T] = {
if (!switch.get) Some(action)
else None
}
- def ifOn(action: => Unit): Boolean = {
+ def ifOn(action: ⇒ Unit): Boolean = {
if (switch.get) {
action
true
} else false
}
- def ifOff(action: => Unit): Boolean = {
+ def ifOff(action: ⇒ Unit): Boolean = {
if (!switch.get) {
action
true
} else false
}
- def whileOnYield[T](action: => T): Option[T] = synchronized {
+ def whileOnYield[T](action: ⇒ T): Option[T] = synchronized {
if (switch.get) Some(action)
else None
}
- def whileOffYield[T](action: => T): Option[T] = synchronized {
+ def whileOffYield[T](action: ⇒ T): Option[T] = synchronized {
if (!switch.get) Some(action)
else None
}
- def whileOn(action: => Unit): Boolean = synchronized {
+ def whileOn(action: ⇒ Unit): Boolean = synchronized {
if (switch.get) {
action
true
} else false
}
- def whileOff(action: => Unit): Boolean = synchronized {
+ def whileOff(action: ⇒ Unit): Boolean = synchronized {
if (switch.get) {
action
true
} else false
}
- def ifElseYield[T](on: => T)(off: => T) = synchronized {
+ def ifElseYield[T](on: ⇒ T)(off: ⇒ T) = synchronized {
if (switch.get) on else off
}
diff --git a/akka-actor/src/main/scala/akka/util/ReflectiveAccess.scala b/akka-actor/src/main/scala/akka/util/ReflectiveAccess.scala
index cb9e8ab0a3..ef0fe59bc9 100644
--- a/akka-actor/src/main/scala/akka/util/ReflectiveAccess.scala
+++ b/akka-actor/src/main/scala/akka/util/ReflectiveAccess.scala
@@ -4,8 +4,8 @@
package akka.util
-import akka.dispatch.{Future, CompletableFuture, MessageInvocation}
-import akka.config.{Config, ModuleNotAvailableException}
+import akka.dispatch.{ Future, CompletableFuture, MessageInvocation }
+import akka.config.{ Config, ModuleNotAvailableException }
import akka.remoteinterface.RemoteSupport
import akka.actor._
@@ -24,13 +24,13 @@ object ReflectiveAccess {
val loader = getClass.getClassLoader
- lazy val isRemotingEnabled: Boolean = RemoteModule.isEnabled
+ lazy val isRemotingEnabled: Boolean = RemoteModule.isEnabled
lazy val isTypedActorEnabled: Boolean = TypedActorModule.isEnabled
- lazy val isClusterEnabled: Boolean = ClusterModule.isEnabled
+ lazy val isClusterEnabled: Boolean = ClusterModule.isEnabled
- def ensureClusterEnabled() { ClusterModule.ensureEnabled() }
- def ensureRemotingEnabled() { RemoteModule.ensureEnabled() }
- def ensureTypedActorEnabled() { TypedActorModule.ensureEnabled() }
+ def ensureClusterEnabled() { ClusterModule.ensureEnabled() }
+ def ensureRemotingEnabled() { RemoteModule.ensureEnabled() }
+ def ensureTypedActorEnabled() { TypedActorModule.ensureEnabled() }
/**
* Reflective access to the Cluster module.
@@ -41,15 +41,15 @@ object ReflectiveAccess {
import java.net.InetAddress
import com.eaio.uuid.UUID
import akka.cluster.NodeAddress
- import Config.{config, TIME_UNIT}
+ import Config.{ config, TIME_UNIT }
- val name = config.getString("akka.cluster.name", "default")
- val zooKeeperServers = config.getString("akka.cluster.zookeeper-server-addresses", "localhost:2181")
- val sessionTimeout = Duration(config.getInt("akka.cluster.session-timeout", 60), TIME_UNIT).toMillis.toInt
- val connectionTimeout = Duration(config.getInt("akka.cluster.connection-timeout", 60), TIME_UNIT).toMillis.toInt
+ val name = config.getString("akka.cluster.name", "default")
+ val zooKeeperServers = config.getString("akka.cluster.zookeeper-server-addresses", "localhost:2181")
+ val sessionTimeout = Duration(config.getInt("akka.cluster.session-timeout", 60), TIME_UNIT).toMillis.toInt
+ val connectionTimeout = Duration(config.getInt("akka.cluster.connection-timeout", 60), TIME_UNIT).toMillis.toInt
val maxTimeToWaitUntilConnected = Duration(config.getInt("akka.cluster.max-time-to-wait-until-connected", 30), TIME_UNIT).toMillis.toInt
- val shouldCompressData = config.getBool("akka.cluster.use-compression", false)
- val nodeAddress = NodeAddress(name, Config.nodename, Config.hostname, Config.remoteServerPort)
+ val shouldCompressData = config.getBool("akka.cluster.use-compression", false)
+ val nodeAddress = NodeAddress(name, Config.nodename, Config.hostname, Config.remoteServerPort)
lazy val isEnabled = clusterInstance.isDefined
@@ -63,22 +63,22 @@ object ReflectiveAccess {
}
lazy val clusterInstance: Option[Cluster] = getObjectFor("akka.cluster.Cluster$") match {
- case Right(value) => Some(value)
- case Left(exception) =>
+ case Right(value) ⇒ Some(value)
+ case Left(exception) ⇒
EventHandler.debug(this, exception.toString)
None
}
lazy val clusterDeployerInstance: Option[ClusterDeployer] = getObjectFor("akka.cluster.ClusterDeployer$") match {
- case Right(value) => Some(value)
- case Left(exception) =>
+ case Right(value) ⇒ Some(value)
+ case Left(exception) ⇒
EventHandler.debug(this, exception.toString)
None
}
lazy val serializerClass: Option[Class[_]] = getClassFor("akka.serialization.Serializer") match {
- case Right(value) => Some(value)
- case Left(exception) =>
+ case Right(value) ⇒ Some(value)
+ case Left(exception) ⇒
EventHandler.debug(this, exception.toString)
None
}
@@ -97,13 +97,9 @@ object ReflectiveAccess {
def start()
def shutdown()
- def store[T <: Actor]
- (address: String, actorClass: Class[T], replicas: Int, serializeMailbox: Boolean)
- (implicit format: Format[T])
+ def store[T <: Actor](address: String, actorClass: Class[T], replicas: Int, serializeMailbox: Boolean)(implicit format: Format[T])
- def store[T <: Actor]
- (address: String, actorRef: ActorRef, replicas: Int, serializeMailbox: Boolean)
- (implicit format: Format[T])
+ def store[T <: Actor](address: String, actorRef: ActorRef, replicas: Int, serializeMailbox: Boolean)(implicit format: Format[T])
def remove(address: String)
def use(address: String): Array[ActorRef]
@@ -150,34 +146,33 @@ object ReflectiveAccess {
def ensureEnabled() = {
if (!isEnabled) {
- val e = new ModuleNotAvailableException("Can't load the remoting module, make sure that akka-remote.jar is on the classpath")
- EventHandler.debug(this, e.toString)
- throw e
+ val e = new ModuleNotAvailableException("Can't load the remoting module, make sure that akka-remote.jar is on the classpath")
+ EventHandler.debug(this, e.toString)
+ throw e
}
}
val remoteSupportClass = getClassFor[RemoteSupport](TRANSPORT) match {
- case Right(value) => Some(value)
- case Left(exception) =>
+ case Right(value) ⇒ Some(value)
+ case Left(exception) ⇒
EventHandler.debug(this, exception.toString)
None
}
- protected[akka] val defaultRemoteSupport: Option[() => RemoteSupport] =
- remoteSupportClass map { remoteClass =>
- () => createInstance[RemoteSupport](
+ protected[akka] val defaultRemoteSupport: Option[() ⇒ RemoteSupport] =
+ remoteSupportClass map { remoteClass ⇒
+ () ⇒ createInstance[RemoteSupport](
remoteClass,
Array[Class[_]](),
- Array[AnyRef]()
- ) match {
- case Right(value) => value
- case Left(exception) =>
- val e = new ModuleNotAvailableException(
- "Can't instantiate [%s] - make sure that akka-remote.jar is on the classpath".format(remoteClass.getName), exception)
- EventHandler.debug(this, e.toString)
- throw e
- }
- }
+ Array[AnyRef]()) match {
+ case Right(value) ⇒ value
+ case Left(exception) ⇒
+ val e = new ModuleNotAvailableException(
+ "Can't instantiate [%s] - make sure that akka-remote.jar is on the classpath".format(remoteClass.getName), exception)
+ EventHandler.debug(this, e.toString)
+ throw e
+ }
+ }
}
/**
@@ -204,8 +199,8 @@ object ReflectiveAccess {
val typedActorObjectInstance: Option[TypedActorObject] =
getObjectFor[TypedActorObject]("akka.actor.TypedActor$") match {
- case Right(value) => Some(value)
- case Left(exception)=>
+ case Right(value) ⇒ Some(value)
+ case Left(exception) ⇒
EventHandler.debug(this, exception.toString)
None
}
@@ -220,11 +215,11 @@ object ReflectiveAccess {
}
val noParams = Array[Class[_]]()
- val noArgs = Array[AnyRef]()
+ val noArgs = Array[AnyRef]()
def createInstance[T](clazz: Class[_],
params: Array[Class[_]],
- args: Array[AnyRef]): Either[Exception,T] = try {
+ args: Array[AnyRef]): Either[Exception, T] = try {
assert(clazz ne null)
assert(params ne null)
assert(args ne null)
@@ -232,10 +227,10 @@ object ReflectiveAccess {
ctor.setAccessible(true)
Right(ctor.newInstance(args: _*).asInstanceOf[T])
} catch {
- case e: java.lang.reflect.InvocationTargetException =>
+ case e: java.lang.reflect.InvocationTargetException ⇒
EventHandler.debug(this, e.getCause.toString)
Left(e)
- case e: Exception =>
+ case e: Exception ⇒
EventHandler.debug(this, e.toString)
Left(e)
}
@@ -243,33 +238,33 @@ object ReflectiveAccess {
def createInstance[T](fqn: String,
params: Array[Class[_]],
args: Array[AnyRef],
- classloader: ClassLoader = loader): Either[Exception,T] = try {
+ classloader: ClassLoader = loader): Either[Exception, T] = try {
assert(params ne null)
assert(args ne null)
getClassFor(fqn) match {
- case Right(value) =>
+ case Right(value) ⇒
val ctor = value.getDeclaredConstructor(params: _*)
ctor.setAccessible(true)
Right(ctor.newInstance(args: _*).asInstanceOf[T])
- case Left(exception) => Left(exception) //We could just cast this to Either[Exception, T] but it's ugly
+ case Left(exception) ⇒ Left(exception) //We could just cast this to Either[Exception, T] but it's ugly
}
} catch {
- case e: Exception =>
+ case e: Exception ⇒
Left(e)
}
//Obtains a reference to fqn.MODULE$
- def getObjectFor[T](fqn: String, classloader: ClassLoader = loader): Either[Exception,T] = try {
+ def getObjectFor[T](fqn: String, classloader: ClassLoader = loader): Either[Exception, T] = try {
getClassFor(fqn) match {
- case Right(value) =>
+ case Right(value) ⇒
val instance = value.getDeclaredField("MODULE$")
instance.setAccessible(true)
val obj = instance.get(null)
if (obj eq null) Left(new NullPointerException) else Right(obj.asInstanceOf[T])
- case Left(exception) => Left(exception) //We could just cast this to Either[Exception, T] but it's ugly
+ case Left(exception) ⇒ Left(exception) //We could just cast this to Either[Exception, T] but it's ugly
}
} catch {
- case e: Exception =>
+ case e: Exception ⇒
Left(e)
}
@@ -280,7 +275,7 @@ object ReflectiveAccess {
val first = try {
Right(classloader.loadClass(fqn).asInstanceOf[Class[T]])
} catch {
- case c: ClassNotFoundException => Left(c)
+ case c: ClassNotFoundException ⇒ Left(c)
}
if (first.isRight) first
@@ -289,15 +284,15 @@ object ReflectiveAccess {
val second = try {
Right(Thread.currentThread.getContextClassLoader.loadClass(fqn).asInstanceOf[Class[T]])
} catch {
- case c: ClassNotFoundException => Left(c)
+ case c: ClassNotFoundException ⇒ Left(c)
}
if (second.isRight) second
else {
val third = try {
- if (classloader ne loader) Right(loader.loadClass(fqn).asInstanceOf[Class[T]]) else Left(null) //Horrid
+ if (classloader ne loader) Right(loader.loadClass(fqn).asInstanceOf[Class[T]]) else Left(null) //Horrid
} catch {
- case c: ClassNotFoundException => Left(c)
+ case c: ClassNotFoundException ⇒ Left(c)
}
if (third.isRight) third
@@ -305,12 +300,12 @@ object ReflectiveAccess {
try {
Right(Class.forName(fqn).asInstanceOf[Class[T]]) // Last option is Class.forName
} catch {
- case c: ClassNotFoundException => Left(c)
+ case c: ClassNotFoundException ⇒ Left(c)
}
}
}
}
} catch {
- case e: Exception => Left(e)
+ case e: Exception ⇒ Left(e)
}
}
diff --git a/akka-actor/src/main/scala/akka/util/package.scala b/akka-actor/src/main/scala/akka/util/package.scala
index 662c0d7393..26a24929c9 100644
--- a/akka-actor/src/main/scala/akka/util/package.scala
+++ b/akka-actor/src/main/scala/akka/util/package.scala
@@ -11,17 +11,17 @@ package object duration {
implicit def longToDurationLong(n: Long) = new DurationLong(n)
implicit def doubleToDurationDouble(d: Double) = new DurationDouble(d)
- implicit def pairIntToDuration(p : (Int, TimeUnit)) = Duration(p._1, p._2)
- implicit def pairLongToDuration(p : (Long, TimeUnit)) = Duration(p._1, p._2)
- implicit def durationToPair(d : Duration) = (d.length, d.unit)
+ implicit def pairIntToDuration(p: (Int, TimeUnit)) = Duration(p._1, p._2)
+ implicit def pairLongToDuration(p: (Long, TimeUnit)) = Duration(p._1, p._2)
+ implicit def durationToPair(d: Duration) = (d.length, d.unit)
- implicit def intMult(i : Int) = new {
- def *(d : Duration) = d * i
+ implicit def intMult(i: Int) = new {
+ def *(d: Duration) = d * i
}
- implicit def longMult(l : Long) = new {
- def *(d : Duration) = d * l
+ implicit def longMult(l: Long) = new {
+ def *(d: Duration) = d * l
}
- implicit def doubleMult(f : Double) = new {
- def *(d : Duration) = d * f
+ implicit def doubleMult(f: Double) = new {
+ def *(d: Duration) = d * f
}
}
diff --git a/akka-cluster/src/main/scala/akka/cluster/Cluster.scala b/akka-cluster/src/main/scala/akka/cluster/Cluster.scala
index 2772652fb5..58faa0fdd5 100644
--- a/akka-cluster/src/main/scala/akka/cluster/Cluster.scala
+++ b/akka-cluster/src/main/scala/akka/cluster/Cluster.scala
@@ -6,18 +6,18 @@ package akka.cluster
import org.apache.zookeeper._
import org.apache.zookeeper.Watcher.Event._
import org.apache.zookeeper.data.Stat
-import org.apache.zookeeper.recipes.lock.{WriteLock, LockListener}
+import org.apache.zookeeper.recipes.lock.{ WriteLock, LockListener }
import org.I0Itec.zkclient._
import org.I0Itec.zkclient.serialize._
import org.I0Itec.zkclient.exception._
-import java.util.concurrent.atomic.{AtomicBoolean, AtomicReference, AtomicInteger}
-import java.util.concurrent.{ConcurrentSkipListSet, CopyOnWriteArrayList, Callable, ConcurrentHashMap}
+import java.util.concurrent.atomic.{ AtomicBoolean, AtomicReference, AtomicInteger }
+import java.util.concurrent.{ ConcurrentSkipListSet, CopyOnWriteArrayList, Callable, ConcurrentHashMap }
import java.net.InetSocketAddress
import javax.management.StandardMBean
-import scala.collection.immutable.{HashMap, HashSet}
+import scala.collection.immutable.{ HashMap, HashSet }
import scala.collection.mutable.ConcurrentMap
import scala.collection.JavaConversions._
@@ -29,10 +29,10 @@ import Helpers._
import akka.actor._
import akka.actor.Actor._
import akka.event.EventHandler
-import akka.dispatch.{Dispatchers, Future}
+import akka.dispatch.{ Dispatchers, Future }
import akka.remoteinterface._
import akka.config.Config._
-import akka.serialization.{Format, Serializers}
+import akka.serialization.{ Format, Serializers }
import akka.serialization.Compression.LZF
import akka.AkkaException
@@ -41,7 +41,7 @@ import akka.cluster.zookeeper._
import com.eaio.uuid.UUID
import com.google.protobuf.ByteString
-import java.util.{List => JList}
+import java.util.{ List ⇒ JList }
// FIXME add watch for each node that when the entry for the node is removed then the node shuts itself down
// FIXME Provisioning data in ZK (file names etc) and files in S3 and on disk
@@ -131,13 +131,13 @@ object Cluster {
trait ChangeListener {
def notify(event: ChangeNotification, client: ClusterNode) {
event match {
- case NodeConnected(name) => nodeConnected(name, client)
- case NodeDisconnected(name) => nodeDisconnected(name, client)
- case NewLeader(name: String) => newLeader(name, client)
- case NewSession => thisNodeNewSession(client)
- case ThisNode.Connected => thisNodeConnected(client)
- case ThisNode.Disconnected => thisNodeDisconnected(client)
- case ThisNode.Expired => thisNodeExpired(client)
+ case NodeConnected(name) ⇒ nodeConnected(name, client)
+ case NodeDisconnected(name) ⇒ nodeDisconnected(name, client)
+ case NewLeader(name: String) ⇒ newLeader(name, client)
+ case NewSession ⇒ thisNodeNewSession(client)
+ case ThisNode.Connected ⇒ thisNodeConnected(client)
+ case ThisNode.Disconnected ⇒ thisNodeDisconnected(client)
+ case ThisNode.Expired ⇒ thisNodeExpired(client)
}
}
@@ -190,8 +190,8 @@ object Cluster {
private val _nodes = new AtomicReference[Nodes](new Nodes)
private val _clusterNames = new ConcurrentSkipListSet[String]
- private[cluster] def updateNodes(f: Nodes => Nodes) {
- while (Some(_nodes.get).map(node => _nodes.compareAndSet(node, f(node)) == false).get) {}
+ private[cluster] def updateNodes(f: Nodes ⇒ Nodes) {
+ while (Some(_nodes.get).map(node ⇒ _nodes.compareAndSet(node, f(node)) == false).get) {}
}
/**
@@ -232,9 +232,9 @@ object Cluster {
* Creates a new cluster node; ClusterNode.
*/
def apply(
- nodeAddress: NodeAddress,
- zkServerAddresses: String = Cluster.zooKeeperServers,
- serializer: ZkSerializer = Cluster.defaultSerializer): ClusterNode =
+ nodeAddress: NodeAddress,
+ zkServerAddresses: String = Cluster.zooKeeperServers,
+ serializer: ZkSerializer = Cluster.defaultSerializer): ClusterNode =
newNode(nodeAddress, zkServerAddresses, serializer)
/**
@@ -259,9 +259,9 @@ object Cluster {
* Creates a new cluster node; ClusterNode.
*/
def newNode(
- nodeAddress: NodeAddress,
- zkServerAddresses: String,
- serializer: ZkSerializer): ClusterNode = {
+ nodeAddress: NodeAddress,
+ zkServerAddresses: String,
+ serializer: ZkSerializer): ClusterNode = {
if (nodeAddress eq null) throw new IllegalArgumentException("NodeAddress can't be null")
@@ -309,7 +309,7 @@ object Cluster {
_zkServer.set(Some(zkServer))
zkServer
} catch {
- case e: Throwable =>
+ case e: Throwable ⇒
EventHandler.error(e, this, "Could not start local ZooKeeper cluster")
throw e
}
@@ -325,11 +325,10 @@ object Cluster {
EventHandler.info(this, "Resetting all clusters connected to in this JVM")
if (!clusters.isEmpty) {
- nodes foreach {
- tp =>
- val (_, node) = tp
- node.disconnect()
- node.remoteService.shutdown()
+ nodes foreach { tp ⇒
+ val (_, node) = tp
+ node.disconnect()
+ node.remoteService.shutdown()
}
implicit val zkClient = newZkClient
clusters foreach (resetNodesInCluster(_))
@@ -371,9 +370,8 @@ object Cluster {
if (uuid == "") throw new ClusterException("UUID is an empty string")
try {
new UUID(uuid)
- }
- catch {
- case e: StringIndexOutOfBoundsException =>
+ } catch {
+ case e: StringIndexOutOfBoundsException ⇒
val error = new ClusterException("UUID not valid [" + uuid + "]")
EventHandler.error(error, this, "")
throw error
@@ -394,11 +392,11 @@ object Cluster {
*
* @author Jonas Bonér
*/
-class ClusterNode private[akka](
- val nodeAddress: NodeAddress,
- val zkServerAddresses: String,
- val serializer: ZkSerializer) extends ErrorHandler {
- self =>
+class ClusterNode private[akka] (
+ val nodeAddress: NodeAddress,
+ val zkServerAddresses: String,
+ val serializer: ZkSerializer) extends ErrorHandler {
+ self ⇒
if (nodeAddress eq null) throw new IllegalArgumentException("'nodeAddress' can not be 'null'")
@@ -414,9 +412,9 @@ class ClusterNode private[akka](
val remoteClientLifeCycleListener = actorOf(new Actor {
def receive = {
- case RemoteClientError(cause, client, address) => client.shutdownClientModule()
- case RemoteClientDisconnected(client, address) => client.shutdownClientModule()
- case _ => //ignore other
+ case RemoteClientError(cause, client, address) ⇒ client.shutdownClientModule()
+ case RemoteClientDisconnected(client, address) ⇒ client.shutdownClientModule()
+ case _ ⇒ //ignore other
}
}, "akka.cluster.remoteClientLifeCycleListener").start()
@@ -530,7 +528,7 @@ class ClusterNode private[akka](
locallyCheckedOutActors.clear()
replicaConnections.toList.foreach({
- case (_, (address, _)) =>
+ case (_, (address, _)) ⇒
Actor.remote.shutdownClientConnection(address) // shut down client connections
})
@@ -602,36 +600,28 @@ class ClusterNode private[akka](
* with the actor passed in as argument. You can use this to save off snapshots of the actor to a highly
* available durable store.
*/
- def store[T <: Actor]
- (actorClass: Class[T], address: String)
- (implicit format: Format[T]): ClusterNode = store(Actor.actorOf(actorClass, address).start, 0, false)
+ def store[T <: Actor](actorClass: Class[T], address: String)(implicit format: Format[T]): ClusterNode = store(Actor.actorOf(actorClass, address).start, 0, false)
/**
* Clusters an actor of a specific type. If the actor is already clustered then the clustered version will be updated
* with the actor passed in as argument. You can use this to save off snapshots of the actor to a highly
* available durable store.
*/
- def store[T <: Actor]
- (actorClass: Class[T], address: String, replicationFactor: Int)
- (implicit format: Format[T]): ClusterNode = store(Actor.actorOf(actorClass, address).start, replicationFactor, false)
+ def store[T <: Actor](actorClass: Class[T], address: String, replicationFactor: Int)(implicit format: Format[T]): ClusterNode = store(Actor.actorOf(actorClass, address).start, replicationFactor, false)
/**
* Clusters an actor of a specific type. If the actor is already clustered then the clustered version will be updated
* with the actor passed in as argument. You can use this to save off snapshots of the actor to a highly
* available durable store.
*/
- def store[T <: Actor]
- (actorClass: Class[T], address: String, serializeMailbox: Boolean)
- (implicit format: Format[T]): ClusterNode = store(Actor.actorOf(actorClass, address).start, 0, serializeMailbox)
+ def store[T <: Actor](actorClass: Class[T], address: String, serializeMailbox: Boolean)(implicit format: Format[T]): ClusterNode = store(Actor.actorOf(actorClass, address).start, 0, serializeMailbox)
/**
* Clusters an actor of a specific type. If the actor is already clustered then the clustered version will be updated
* with the actor passed in as argument. You can use this to save off snapshots of the actor to a highly
* available durable store.
*/
- def store[T <: Actor]
- (actorClass: Class[T], address: String, replicationFactor: Int, serializeMailbox: Boolean)
- (implicit format: Format[T]): ClusterNode =
+ def store[T <: Actor](actorClass: Class[T], address: String, replicationFactor: Int, serializeMailbox: Boolean)(implicit format: Format[T]): ClusterNode =
store(Actor.actorOf(actorClass, address).start, replicationFactor, serializeMailbox)
/**
@@ -639,36 +629,28 @@ class ClusterNode private[akka](
* with the actor passed in as argument. You can use this to save off snapshots of the actor to a highly
* available durable store.
*/
- def store[T <: Actor]
- (actorRef: ActorRef)
- (implicit format: Format[T]): ClusterNode = store(actorRef, 0, false)
+ def store[T <: Actor](actorRef: ActorRef)(implicit format: Format[T]): ClusterNode = store(actorRef, 0, false)
/**
* Clusters an actor with UUID. If the actor is already clustered then the clustered version will be updated
* with the actor passed in as argument. You can use this to save off snapshots of the actor to a highly
* available durable store.
*/
- def store[T <: Actor]
- (actorRef: ActorRef, replicationFactor: Int)
- (implicit format: Format[T]): ClusterNode = store(actorRef, replicationFactor, false)
+ def store[T <: Actor](actorRef: ActorRef, replicationFactor: Int)(implicit format: Format[T]): ClusterNode = store(actorRef, replicationFactor, false)
/**
* Clusters an actor with UUID. If the actor is already clustered then the clustered version will be updated
* with the actor passed in as argument. You can use this to save off snapshots of the actor to a highly
* available durable store.
*/
- def store[T <: Actor]
- (actorRef: ActorRef, serializeMailbox: Boolean)
- (implicit format: Format[T]): ClusterNode = store(actorRef, 0, serializeMailbox)
+ def store[T <: Actor](actorRef: ActorRef, serializeMailbox: Boolean)(implicit format: Format[T]): ClusterNode = store(actorRef, 0, serializeMailbox)
/**
* Clusters an actor with UUID. If the actor is already clustered then the clustered version will be updated
* with the actor passed in as argument. You can use this to save off snapshots of the actor to a highly
* available durable store.
*/
- def store[T <: Actor]
- (actorRef: ActorRef, replicationFactor: Int, serializeMailbox: Boolean)
- (implicit format: Format[T]): ClusterNode = if (isConnected.isOn) {
+ def store[T <: Actor](actorRef: ActorRef, replicationFactor: Int, serializeMailbox: Boolean)(implicit format: Format[T]): ClusterNode = if (isConnected.isOn) {
import akka.serialization.ActorSerialization._
@@ -691,26 +673,26 @@ class ClusterNode private[akka](
try {
Left(zkClient.connection.create(actorRegistryPath, actorBytes, CreateMode.PERSISTENT))
} catch {
- case e: KeeperException.NodeExistsException => Right(e)
+ case e: KeeperException.NodeExistsException ⇒ Right(e)
}
}
}) match {
- case Left(path) => path
- case Right(exception) => actorRegistryPath
+ case Left(path) ⇒ path
+ case Right(exception) ⇒ actorRegistryPath
}
// create UUID -> Format registry
try {
zkClient.createPersistent(actorRegistryFormatPathFor(uuid), format)
} catch {
- case e: ZkNodeExistsException => zkClient.writeData(actorRegistryFormatPathFor(uuid), format)
+ case e: ZkNodeExistsException ⇒ zkClient.writeData(actorRegistryFormatPathFor(uuid), format)
}
// create UUID -> ADDRESS registry
try {
zkClient.createPersistent(actorRegistryActorAddressPathFor(uuid), actorRef.address)
} catch {
- case e: ZkNodeExistsException => zkClient.writeData(actorRegistryActorAddressPathFor(uuid), actorRef.address)
+ case e: ZkNodeExistsException ⇒ zkClient.writeData(actorRegistryActorAddressPathFor(uuid), actorRef.address)
}
// create UUID -> Address registry
@@ -728,9 +710,8 @@ class ClusterNode private[akka](
.setMessageType(USE)
.setActorUuid(uuidToUuidProtocol(uuid))
.build
- replicaConnectionsForReplicationFactor(replicationFactor) foreach {
- connection =>
- connection ! command
+ replicaConnectionsForReplicationFactor(replicationFactor) foreach { connection ⇒
+ connection ! command
}
this
@@ -757,7 +738,7 @@ class ClusterNode private[akka](
isConnected ifOn {
EventHandler.debug(this,
"Removing actor(s) with ADDRESS [%s] from cluster".format(address))
- uuidsForActorAddress(address) foreach (uuid => remove(uuid))
+ uuidsForActorAddress(address) foreach (uuid ⇒ remove(uuid))
}
this
}
@@ -766,9 +747,8 @@ class ClusterNode private[akka](
* Is the actor with uuid clustered or not?
*/
def isClustered(actorAddress: String): Boolean = if (isConnected.isOn) {
- actorUuidsForActorAddress(actorAddress) map {
- uuid =>
- zkClient.exists(actorRegistryPathFor(uuid))
+ actorUuidsForActorAddress(actorAddress) map { uuid ⇒
+ zkClient.exists(actorRegistryPathFor(uuid))
} exists (_ == true)
} else false
@@ -781,9 +761,8 @@ class ClusterNode private[akka](
* Is the actor with uuid in use or not?
*/
def isInUseOnNode(actorAddress: String, node: NodeAddress): Boolean = if (isConnected.isOn) {
- actorUuidsForActorAddress(actorAddress) map {
- uuid =>
- zkClient.exists(actorLocationsPathFor(uuid, node))
+ actorUuidsForActorAddress(actorAddress) map { uuid ⇒
+ zkClient.exists(actorLocationsPathFor(uuid, node))
} exists (_ == true)
} else false
@@ -796,39 +775,38 @@ class ClusterNode private[akka](
import akka.serialization.ActorSerialization._
- actorUuidsForActorAddress(actorAddress) map {
- uuid =>
- EventHandler.debug(this,
- "Checking out actor with UUID [%s] to be used on node [%s]".format(uuid, nodeAddress.nodeName))
+ actorUuidsForActorAddress(actorAddress) map { uuid ⇒
+ EventHandler.debug(this,
+ "Checking out actor with UUID [%s] to be used on node [%s]".format(uuid, nodeAddress.nodeName))
- ignore[ZkNodeExistsException](zkClient.createPersistent(actorAtNodePathFor(nodeAddress.nodeName, uuid), true))
- ignore[ZkNodeExistsException](zkClient.createEphemeral(actorLocationsPathFor(uuid, nodeAddress)))
+ ignore[ZkNodeExistsException](zkClient.createPersistent(actorAtNodePathFor(nodeAddress.nodeName, uuid), true))
+ ignore[ZkNodeExistsException](zkClient.createEphemeral(actorLocationsPathFor(uuid, nodeAddress)))
- // set home address
- ignore[ZkNodeExistsException](zkClient.createPersistent(actorRegistryNodePathFor(uuid)))
- ignore[ZkNodeExistsException](zkClient.createEphemeral(actorRegistryNodePathFor(uuid, remoteServerAddress)))
+ // set home address
+ ignore[ZkNodeExistsException](zkClient.createPersistent(actorRegistryNodePathFor(uuid)))
+ ignore[ZkNodeExistsException](zkClient.createEphemeral(actorRegistryNodePathFor(uuid, remoteServerAddress)))
- val actorPath = actorRegistryPathFor(uuid)
- zkClient.retryUntilConnected(new Callable[Either[Array[Byte], Exception]]() {
- def call: Either[Array[Byte], Exception] = {
- try {
- Left(if (shouldCompressData) LZF.uncompress(zkClient.connection.readData(actorPath, new Stat, false))
- else zkClient.connection.readData(actorPath, new Stat, false))
- } catch {
- case e: KeeperException.NodeExistsException => Right(e)
- }
+ val actorPath = actorRegistryPathFor(uuid)
+ zkClient.retryUntilConnected(new Callable[Either[Array[Byte], Exception]]() {
+ def call: Either[Array[Byte], Exception] = {
+ try {
+ Left(if (shouldCompressData) LZF.uncompress(zkClient.connection.readData(actorPath, new Stat, false))
+ else zkClient.connection.readData(actorPath, new Stat, false))
+ } catch {
+ case e: KeeperException.NodeExistsException ⇒ Right(e)
}
- }) match {
- case Left(bytes) =>
- locallyCheckedOutActors += (uuid -> bytes)
- // FIXME switch to ReplicatedActorRef here
- // val actor = new ReplicatedActorRef(fromBinary[T](bytes, remoteServerAddress)(format))
- val actor = fromBinary[T](bytes, remoteServerAddress)(format)
- remoteService.register(UUID_PREFIX + uuid, actor) // clustered refs are always registered and looked up by UUID
- actor.start()
- actor.asInstanceOf[LocalActorRef]
- case Right(exception) => throw exception
}
+ }) match {
+ case Left(bytes) ⇒
+ locallyCheckedOutActors += (uuid -> bytes)
+ // FIXME switch to ReplicatedActorRef here
+ // val actor = new ReplicatedActorRef(fromBinary[T](bytes, remoteServerAddress)(format))
+ val actor = fromBinary[T](bytes, remoteServerAddress)(format)
+ remoteService.register(UUID_PREFIX + uuid, actor) // clustered refs are always registered and looked up by UUID
+ actor.start()
+ actor.asInstanceOf[LocalActorRef]
+ case Right(exception) ⇒ throw exception
+ }
}
} else Array.empty[LocalActorRef]
@@ -843,12 +821,11 @@ class ClusterNode private[akka](
.setMessageType(USE)
.setActorUuid(uuidToUuidProtocol(uuid))
.build
- membershipNodes foreach {
- node =>
- replicaConnections.get(node) foreach {
- case (_, connection) =>
- connection ! command
- }
+ membershipNodes foreach { node ⇒
+ replicaConnections.get(node) foreach {
+ case (_, connection) ⇒
+ connection ! command
+ }
}
}
}
@@ -859,7 +836,7 @@ class ClusterNode private[akka](
def useActorOnNode(node: String, uuid: UUID) {
isConnected ifOn {
replicaConnections.get(node) foreach {
- case (_, connection) =>
+ case (_, connection) ⇒
connection ! RemoteDaemonMessageProtocol.newBuilder
.setMessageType(USE)
.setActorUuid(uuidToUuidProtocol(uuid))
@@ -873,15 +850,14 @@ class ClusterNode private[akka](
*/
def release(actorAddress: String) {
isConnected ifOn {
- actorUuidsForActorAddress(actorAddress) foreach {
- uuid =>
- EventHandler.debug(this,
- "Releasing actor with UUID [%s] after usage".format(uuid))
- locallyCheckedOutActors.remove(uuid)
- ignore[ZkNoNodeException](zkClient.deleteRecursive(actorAtNodePathFor(nodeAddress.nodeName, uuid)))
- ignore[ZkNoNodeException](zkClient.delete(actorAtNodePathFor(nodeAddress.nodeName, uuid)))
- ignore[ZkNoNodeException](zkClient.delete(actorLocationsPathFor(uuid, nodeAddress)))
- ignore[ZkNoNodeException](zkClient.delete(actorRegistryNodePathFor(uuid, remoteServerAddress)))
+ actorUuidsForActorAddress(actorAddress) foreach { uuid ⇒
+ EventHandler.debug(this,
+ "Releasing actor with UUID [%s] after usage".format(uuid))
+ locallyCheckedOutActors.remove(uuid)
+ ignore[ZkNoNodeException](zkClient.deleteRecursive(actorAtNodePathFor(nodeAddress.nodeName, uuid)))
+ ignore[ZkNoNodeException](zkClient.delete(actorAtNodePathFor(nodeAddress.nodeName, uuid)))
+ ignore[ZkNoNodeException](zkClient.delete(actorLocationsPathFor(uuid, nodeAddress)))
+ ignore[ZkNoNodeException](zkClient.delete(actorRegistryNodePathFor(uuid, remoteServerAddress)))
}
}
}
@@ -897,12 +873,11 @@ class ClusterNode private[akka](
.setMessageType(RELEASE)
.setActorUuid(uuidToUuidProtocol(uuid))
.build
- nodesForActorsInUseWithUuid(uuid) foreach {
- node =>
- replicaConnections.get(node) foreach {
- case (_, connection) =>
- connection ! command
- }
+ nodesForActorsInUseWithUuid(uuid) foreach { node ⇒
+ replicaConnections.get(node) foreach {
+ case (_, connection) ⇒
+ connection ! command
+ }
}
}
}
@@ -920,14 +895,13 @@ class ClusterNode private[akka](
def registerClusterActorRefForAddress(actorRef: ClusterActorRef, addresses: Array[(UUID, InetSocketAddress)]) {
addresses foreach {
- case (_, address) => clusterActorRefs.put(address, actorRef)
+ case (_, address) ⇒ clusterActorRefs.put(address, actorRef)
}
}
// FIXME remove?
def refByUuid(uuid: UUID): ActorRef = {
- val actor = Router newRouter (
- router, addresses,
+ val actor = Router newRouter (router, addresses,
uuidToString(uuid),
Actor.TIMEOUT, actorType)
registerClusterActorRefForAddress(actor, addresses)
@@ -937,8 +911,7 @@ class ClusterNode private[akka](
def refByAddress(actorAddress: String): ActorRef = {
//FIXME: unused uuids
val uuids = uuidsForActorAddress(actorAddress)
- val actor = Router newRouter (
- router, addresses,
+ val actor = Router newRouter (router, addresses,
actorAddress,
Actor.TIMEOUT, actorType)
registerClusterActorRefForAddress(actor, addresses)
@@ -959,7 +932,7 @@ class ClusterNode private[akka](
* Migrate the actor from node 'from' to node 'to'.
*/
def migrate(
- from: NodeAddress, to: NodeAddress, actorAddress: String) {
+ from: NodeAddress, to: NodeAddress, actorAddress: String) {
isConnected ifOn {
if (from eq null) throw new IllegalArgumentException("NodeAddress 'from' can not be 'null'")
if (to eq null) throw new IllegalArgumentException("NodeAddress 'to' can not be 'null'")
@@ -999,9 +972,8 @@ class ClusterNode private[akka](
def actorAddressForUuid(uuid: UUID): String = if (isConnected.isOn) {
try {
zkClient.readData(actorRegistryActorAddressPathFor(uuid)).asInstanceOf[String]
- }
- catch {
- case e: ZkNoNodeException => ""
+ } catch {
+ case e: ZkNoNodeException ⇒ ""
}
} else ""
@@ -1016,9 +988,8 @@ class ClusterNode private[akka](
def uuidsForActorAddress(actorAddress: String): Array[UUID] = if (isConnected.isOn) {
try {
zkClient.getChildren(actorAddressToUuidsPathFor(actorAddress)).toList.map(new UUID(_)).toArray.asInstanceOf[Array[UUID]]
- }
- catch {
- case e: ZkNoNodeException => Array[UUID]()
+ } catch {
+ case e: ZkNoNodeException ⇒ Array[UUID]()
}
} else Array.empty[UUID]
@@ -1028,9 +999,8 @@ class ClusterNode private[akka](
def nodesForActorsInUseWithUuid(uuid: UUID): Array[String] = if (isConnected.isOn) {
try {
zkClient.getChildren(actorLocationsPathFor(uuid)).toList.toArray.asInstanceOf[Array[String]]
- }
- catch {
- case e: ZkNoNodeException => Array[String]()
+ } catch {
+ case e: ZkNoNodeException ⇒ Array[String]()
}
} else Array.empty[String]
@@ -1039,14 +1009,13 @@ class ClusterNode private[akka](
*/
def nodesForActorsInUseWithAddress(address: String): Array[String] = if (isConnected.isOn) {
flatten {
- actorUuidsForActorAddress(address) map {
- uuid =>
- try {
- val list = zkClient.getChildren(actorLocationsPathFor(uuid))
- list.toList.toArray.asInstanceOf[Array[String]]
- } catch {
- case e: ZkNoNodeException => Array[String]()
- }
+ actorUuidsForActorAddress(address) map { uuid ⇒
+ try {
+ val list = zkClient.getChildren(actorLocationsPathFor(uuid))
+ list.toList.toArray.asInstanceOf[Array[String]]
+ } catch {
+ case e: ZkNoNodeException ⇒ Array[String]()
+ }
}
}
} else Array.empty[String]
@@ -1057,9 +1026,8 @@ class ClusterNode private[akka](
def uuidsForActorsInUseOnNode(nodeName: String): Array[UUID] = if (isConnected.isOn) {
try {
zkClient.getChildren(actorsAtNodePathFor(nodeName)).toList.map(new UUID(_)).toArray.asInstanceOf[Array[UUID]]
- }
- catch {
- case e: ZkNoNodeException => Array[UUID]()
+ } catch {
+ case e: ZkNoNodeException ⇒ Array[UUID]()
}
} else Array.empty[UUID]
@@ -1070,9 +1038,8 @@ class ClusterNode private[akka](
val uuids =
try {
zkClient.getChildren(actorsAtNodePathFor(nodeName)).toList.map(new UUID(_)).toArray.asInstanceOf[Array[UUID]]
- }
- catch {
- case e: ZkNoNodeException => Array[UUID]()
+ } catch {
+ case e: ZkNoNodeException ⇒ Array[UUID]()
}
actorAddressForUuids(uuids)
} else Array.empty[String]
@@ -1082,9 +1049,8 @@ class ClusterNode private[akka](
*/
def formatForActor[T <: Actor](actorAddress: String): Format[T] = {
- val formats = actorUuidsForActorAddress(actorAddress) map {
- uuid =>
- zkClient.readData(actorRegistryFormatPathFor(uuid), new Stat).asInstanceOf[Format[T]]
+ val formats = actorUuidsForActorAddress(actorAddress) map { uuid ⇒
+ zkClient.readData(actorRegistryFormatPathFor(uuid), new Stat).asInstanceOf[Format[T]]
}
val format = formats.head
@@ -1100,8 +1066,8 @@ class ClusterNode private[akka](
def addressesForActor(actorAddress: String): Array[(UUID, InetSocketAddress)] = {
try {
for {
- uuid <- actorUuidsForActorAddress(actorAddress)
- address <- zkClient.getChildren(actorRegistryNodePathFor(uuid)).toList
+ uuid ← actorUuidsForActorAddress(actorAddress)
+ address ← zkClient.getChildren(actorRegistryNodePathFor(uuid)).toList
} yield {
val tokenizer = new java.util.StringTokenizer(address, ":")
val hostname = tokenizer.nextToken // hostname
@@ -1109,7 +1075,7 @@ class ClusterNode private[akka](
(uuid, new InetSocketAddress(hostname, port))
}
} catch {
- case e: ZkNoNodeException => Array[(UUID, InetSocketAddress)]()
+ case e: ZkNoNodeException ⇒ Array[(UUID, InetSocketAddress)]()
}
}
@@ -1180,19 +1146,19 @@ class ClusterNode private[akka](
try {
Left(zkClient.connection.create(configurationPathFor(key), compressedBytes, CreateMode.PERSISTENT))
} catch {
- case e: KeeperException.NodeExistsException =>
+ case e: KeeperException.NodeExistsException ⇒
try {
Left(zkClient.connection.writeData(configurationPathFor(key), compressedBytes))
} catch {
- case e: Exception => Right(e)
+ case e: Exception ⇒ Right(e)
}
}
}
}) match {
- case Left(_) => {
+ case Left(_) ⇒ {
/* do nothing */
}
- case Right(exception) => throw exception
+ case Right(exception) ⇒ throw exception
}
}
@@ -1202,7 +1168,7 @@ class ClusterNode private[akka](
def getConfigElement(key: String): Array[Byte] = try {
zkClient.connection.readData(configurationPathFor(key), new Stat, true)
} catch {
- case e: KeeperException.NoNodeException => null
+ case e: KeeperException.NoNodeException ⇒ null
}
def removeConfigElement(key: String) {
@@ -1297,7 +1263,7 @@ class ClusterNode private[akka](
val numberOfReplicas = replicaConnections.size
val replicaConnectionsAsArray = replicaConnections.toList map {
- case (node, (address, actorRef)) => actorRef
+ case (node, (address, actorRef)) ⇒ actorRef
} // the ActorRefs
if (numberOfReplicas < replicationFactor) {
@@ -1319,13 +1285,12 @@ class ClusterNode private[akka](
* Connect to all available replicas unless already connected).
*/
private def connectToAllReplicas() {
- membershipNodes foreach {
- node =>
- if (!replicaConnections.contains(node)) {
- val address = addressForNode(node)
- val clusterDaemon = Actor.remote.actorFor(RemoteClusterDaemon.ADDRESS, address.getHostName, address.getPort)
- replicaConnections.put(node, (address, clusterDaemon))
- }
+ membershipNodes foreach { node ⇒
+ if (!replicaConnections.contains(node)) {
+ val address = addressForNode(node)
+ val clusterDaemon = Actor.remote.actorFor(RemoteClusterDaemon.ADDRESS, address.getHostName, address.getPort)
+ replicaConnections.put(node, (address, clusterDaemon))
+ }
}
}
@@ -1336,7 +1301,7 @@ class ClusterNode private[akka](
"Joining cluster as membership node [%s] on [%s]".format(nodeAddress, membershipNodePath))
zkClient.createEphemeral(membershipNodePath, nodeAddress.toString)
} catch {
- case e: ZkNodeExistsException =>
+ case e: ZkNodeExistsException ⇒
val error = new ClusterException("Can't join the cluster. The node name [" + nodeAddress.nodeName + "] is already in by another node")
EventHandler.error(error, this, "")
throw error
@@ -1357,62 +1322,58 @@ class ClusterNode private[akka](
}
private[cluster] def migrateFromFailedNodes[T <: Actor](currentSetOfClusterNodes: List[String]) = {
- findFailedNodes(currentSetOfClusterNodes).foreach {
- failedNodeName =>
+ findFailedNodes(currentSetOfClusterNodes).foreach { failedNodeName ⇒
- val allNodes = locallyCachedMembershipNodes.toList
- val myIndex = allNodes.indexWhere(_.endsWith(nodeAddress.nodeName))
- val failedNodeIndex = allNodes.indexWhere(_ == failedNodeName)
+ val allNodes = locallyCachedMembershipNodes.toList
+ val myIndex = allNodes.indexWhere(_.endsWith(nodeAddress.nodeName))
+ val failedNodeIndex = allNodes.indexWhere(_ == failedNodeName)
- // Migrate to the successor of the failed node (using a sorted circular list of the node names)
- if ((failedNodeIndex == 0 && myIndex == locallyCachedMembershipNodes.size - 1) || // No leftmost successor exists, check the tail
- (failedNodeIndex == myIndex + 1)) {
- // Am I the leftmost successor?
+ // Migrate to the successor of the failed node (using a sorted circular list of the node names)
+ if ((failedNodeIndex == 0 && myIndex == locallyCachedMembershipNodes.size - 1) || // No leftmost successor exists, check the tail
+ (failedNodeIndex == myIndex + 1)) {
+ // Am I the leftmost successor?
- // Yes I am the node to migrate the actor to (can only be one in the cluster)
- val actorUuidsForFailedNode = zkClient.getChildren(actorsAtNodePathFor(failedNodeName))
+ // Yes I am the node to migrate the actor to (can only be one in the cluster)
+ val actorUuidsForFailedNode = zkClient.getChildren(actorsAtNodePathFor(failedNodeName))
+ EventHandler.debug(this,
+ "Migrating actors from failed node [%s] to node [%s]: Actor UUIDs [%s]"
+ .format(failedNodeName, nodeAddress.nodeName, actorUuidsForFailedNode))
+
+ actorUuidsForFailedNode.foreach { uuid ⇒
EventHandler.debug(this,
- "Migrating actors from failed node [%s] to node [%s]: Actor UUIDs [%s]"
- .format(failedNodeName, nodeAddress.nodeName, actorUuidsForFailedNode))
+ "Cluster node [%s] has failed, migrating actor with UUID [%s] to [%s]"
+ .format(failedNodeName, uuid, nodeAddress.nodeName))
- actorUuidsForFailedNode.foreach {
- uuid =>
- EventHandler.debug(this,
- "Cluster node [%s] has failed, migrating actor with UUID [%s] to [%s]"
- .format(failedNodeName, uuid, nodeAddress.nodeName))
+ val actorAddress = actorAddressForUuid(uuidFrom(uuid))
+ migrateWithoutCheckingThatActorResidesOnItsHomeNode( // since the ephemeral node is already gone, so can't check
+ NodeAddress(nodeAddress.clusterName, failedNodeName), nodeAddress, actorAddress)
- val actorAddress = actorAddressForUuid(uuidFrom(uuid))
- migrateWithoutCheckingThatActorResidesOnItsHomeNode(// since the ephemeral node is already gone, so can't check
- NodeAddress(nodeAddress.clusterName, failedNodeName), nodeAddress, actorAddress)
+ implicit val format: Format[T] = formatForActor(actorAddress)
+ use(actorAddress) foreach { actor ⇒
+ // FIXME remove ugly reflection when we have 1.0 final which has 'fromBinary(byte, homeAddress)(format)'
+ //actor.homeAddress = remoteServerAddress
+ val homeAddress = classOf[LocalActorRef].getDeclaredField("homeAddress")
+ homeAddress.setAccessible(true)
+ homeAddress.set(actor, Some(remoteServerAddress))
- implicit val format: Format[T] = formatForActor(actorAddress)
- use(actorAddress) foreach {
- actor =>
- // FIXME remove ugly reflection when we have 1.0 final which has 'fromBinary(byte, homeAddress)(format)'
- //actor.homeAddress = remoteServerAddress
- val homeAddress = classOf[LocalActorRef].getDeclaredField("homeAddress")
- homeAddress.setAccessible(true)
- homeAddress.set(actor, Some(remoteServerAddress))
-
- remoteService.register(uuid, actor)
- }
- }
-
- // notify all available nodes that they should fail-over all connections from 'from' to 'to'
- val from = nodeNameToAddress.get(failedNodeName)
- val to = remoteServerAddress
- val command = RemoteDaemonMessageProtocol.newBuilder
- .setMessageType(FAIL_OVER_CONNECTIONS)
- .setPayload(ByteString.copyFrom(Serializers.Java.toBinary((from, to))))
- .build
- membershipNodes foreach {
- node =>
- replicaConnections.get(node) foreach {
- case (_, connection) =>
- connection ! command
- }
+ remoteService.register(uuid, actor)
}
}
+
+ // notify all available nodes that they should fail-over all connections from 'from' to 'to'
+ val from = nodeNameToAddress.get(failedNodeName)
+ val to = remoteServerAddress
+ val command = RemoteDaemonMessageProtocol.newBuilder
+ .setMessageType(FAIL_OVER_CONNECTIONS)
+ .setPayload(ByteString.copyFrom(Serializers.Java.toBinary((from, to))))
+ .build
+ membershipNodes foreach { node ⇒
+ replicaConnections.get(node) foreach {
+ case (_, connection) ⇒
+ connection ! command
+ }
+ }
+ }
}
}
@@ -1420,27 +1381,26 @@ class ClusterNode private[akka](
* Used when the ephemeral "home" node is already gone, so we can't check.
*/
private def migrateWithoutCheckingThatActorResidesOnItsHomeNode(
- from: NodeAddress, to: NodeAddress, actorAddress: String) {
+ from: NodeAddress, to: NodeAddress, actorAddress: String) {
- actorUuidsForActorAddress(actorAddress) map {
- uuid =>
- val actorAddress = actorAddressForUuid(uuid)
+ actorUuidsForActorAddress(actorAddress) map { uuid ⇒
+ val actorAddress = actorAddressForUuid(uuid)
- if (!isInUseOnNode(actorAddress, to)) {
- release(actorAddress)
+ if (!isInUseOnNode(actorAddress, to)) {
+ release(actorAddress)
- val newAddress = new InetSocketAddress(to.hostname, to.port)
- ignore[ZkNodeExistsException](zkClient.createPersistent(actorRegistryNodePathFor(uuid)))
- ignore[ZkNodeExistsException](zkClient.createEphemeral(actorRegistryNodePathFor(uuid, newAddress)))
- ignore[ZkNodeExistsException](zkClient.createEphemeral(actorLocationsPathFor(uuid, to)))
- ignore[ZkNodeExistsException](zkClient.createPersistent(actorAtNodePathFor(nodeAddress.nodeName, uuid)))
+ val newAddress = new InetSocketAddress(to.hostname, to.port)
+ ignore[ZkNodeExistsException](zkClient.createPersistent(actorRegistryNodePathFor(uuid)))
+ ignore[ZkNodeExistsException](zkClient.createEphemeral(actorRegistryNodePathFor(uuid, newAddress)))
+ ignore[ZkNodeExistsException](zkClient.createEphemeral(actorLocationsPathFor(uuid, to)))
+ ignore[ZkNodeExistsException](zkClient.createPersistent(actorAtNodePathFor(nodeAddress.nodeName, uuid)))
- ignore[ZkNoNodeException](zkClient.delete(actorLocationsPathFor(uuid, from)))
- ignore[ZkNoNodeException](zkClient.delete(actorAtNodePathFor(from.nodeName, uuid)))
+ ignore[ZkNoNodeException](zkClient.delete(actorLocationsPathFor(uuid, from)))
+ ignore[ZkNoNodeException](zkClient.delete(actorAtNodePathFor(from.nodeName, uuid)))
- // 'use' (check out) actor on the remote 'to' node
- useActorOnNode(to.nodeName, uuid)
- }
+ // 'use' (check out) actor on the remote 'to' node
+ useActorOnNode(to.nodeName, uuid)
+ }
}
}
@@ -1467,18 +1427,17 @@ class ClusterNode private[akka](
}
private def createNodeStructureIfNeeded() {
- baseNodes.foreach {
- path =>
- try {
- zkClient.create(path, null, CreateMode.PERSISTENT)
- EventHandler.debug(this, "Created node [%s]".format(path))
- } catch {
- case e: ZkNodeExistsException => {} // do nothing
- case e =>
- val error = new ClusterException(e.toString)
- EventHandler.error(error, this, "")
- throw error
- }
+ baseNodes.foreach { path ⇒
+ try {
+ zkClient.create(path, null, CreateMode.PERSISTENT)
+ EventHandler.debug(this, "Created node [%s]".format(path))
+ } catch {
+ case e: ZkNodeExistsException ⇒ {} // do nothing
+ case e ⇒
+ val error = new ClusterException(e.toString)
+ EventHandler.error(error, this, "")
+ throw error
+ }
}
}
@@ -1579,16 +1538,14 @@ class MembershipChildListener(self: ClusterNode) extends IZkChildListener with E
if (!childList.isEmpty) EventHandler.debug(this,
"MembershipChildListener at [%s] has children [%s]"
.format(self.nodeAddress.nodeName, childList.mkString(" ")))
- self.findNewlyConnectedMembershipNodes(childList) foreach {
- name =>
- self.nodeNameToAddress.put(name, self.addressForNode(name)) // update 'nodename-address' map
- self.publish(Cluster.NodeConnected(name))
+ self.findNewlyConnectedMembershipNodes(childList) foreach { name ⇒
+ self.nodeNameToAddress.put(name, self.addressForNode(name)) // update 'nodename-address' map
+ self.publish(Cluster.NodeConnected(name))
}
- self.findNewlyDisconnectedMembershipNodes(childList) foreach {
- name =>
- self.nodeNameToAddress.remove(name) // update 'nodename-address' map
- self.publish(Cluster.NodeDisconnected(name))
+ self.findNewlyDisconnectedMembershipNodes(childList) foreach { name ⇒
+ self.nodeNameToAddress.remove(name) // update 'nodename-address' map
+ self.publish(Cluster.NodeDisconnected(name))
}
self.locallyCachedMembershipNodes.clear()
@@ -1604,13 +1561,13 @@ class MembershipChildListener(self: ClusterNode) extends IZkChildListener with E
class StateListener(self: ClusterNode) extends IZkStateListener {
def handleStateChanged(state: KeeperState) {
state match {
- case KeeperState.SyncConnected =>
+ case KeeperState.SyncConnected ⇒
EventHandler.debug(this, "Cluster node [%s] - Connected".format(self.nodeAddress))
self.publish(Cluster.ThisNode.Connected)
- case KeeperState.Disconnected =>
+ case KeeperState.Disconnected ⇒
EventHandler.debug(this, "Cluster node [%s] - Disconnected".format(self.nodeAddress))
self.publish(Cluster.ThisNode.Disconnected)
- case KeeperState.Expired =>
+ case KeeperState.Expired ⇒
EventHandler.debug(this, "Cluster node [%s] - Expired".format(self.nodeAddress))
self.publish(Cluster.ThisNode.Expired)
}
@@ -1630,14 +1587,14 @@ class StateListener(self: ClusterNode) extends IZkStateListener {
* @author Jonas Bonér
*/
trait ErrorHandler {
- def withErrorHandler[T](body: => T) = {
+ def withErrorHandler[T](body: ⇒ T) = {
try {
body
} catch {
- case e: org.I0Itec.zkclient.exception.ZkInterruptedException => {
+ case e: org.I0Itec.zkclient.exception.ZkInterruptedException ⇒ {
/* ignore */
}
- case e: Throwable =>
+ case e: Throwable ⇒
EventHandler.error(e, this, e.toString)
throw e
}
@@ -1665,11 +1622,11 @@ class RemoteClusterDaemon(cluster: ClusterNode) extends Actor {
self.dispatcher = Dispatchers.newThreadBasedDispatcher(self)
def receive: Receive = {
- case message: RemoteDaemonMessageProtocol =>
+ case message: RemoteDaemonMessageProtocol ⇒
EventHandler.debug(this, "Received command to RemoteClusterDaemon [%s]".format(message))
message.getMessageType match {
- case USE =>
+ case USE ⇒
if (message.hasActorUuid) {
val uuid = uuidProtocolToUuid(message.getActorUuid)
val address = cluster.actorAddressForUuid(uuid)
@@ -1682,36 +1639,34 @@ class RemoteClusterDaemon(cluster: ClusterNode) extends Actor {
} else EventHandler.warning(this,
"None of 'uuid', or 'address' is specified, ignoring remote cluster daemon command [%s]".format(message))
- case RELEASE =>
+ case RELEASE ⇒
if (message.hasActorUuid) {
cluster release cluster.actorAddressForUuid(uuidProtocolToUuid(message.getActorUuid))
- }
- else if (message.hasActorAddress) {
+ } else if (message.hasActorAddress) {
cluster release message.getActorAddress
- }
- else EventHandler.warning(this,
+ } else EventHandler.warning(this,
"None of 'uuid' or 'actorAddress'' is specified, ignoring remote cluster daemon command [%s]".format(message))
- case START => cluster.start()
+ case START ⇒ cluster.start()
- case STOP => cluster.stop()
+ case STOP ⇒ cluster.stop()
- case DISCONNECT => cluster.disconnect()
+ case DISCONNECT ⇒ cluster.disconnect()
- case RECONNECT => cluster.reconnect()
+ case RECONNECT ⇒ cluster.reconnect()
- case RESIGN => cluster.resign()
+ case RESIGN ⇒ cluster.resign()
- case FAIL_OVER_CONNECTIONS =>
+ case FAIL_OVER_CONNECTIONS ⇒
val (from, to) = payloadFor(message, classOf[(InetSocketAddress, InetSocketAddress)])
cluster.failOverConnections(from, to)
- case FUNCTION_FUN0_UNIT =>
+ case FUNCTION_FUN0_UNIT ⇒
actorOf(new Actor() {
self.dispatcher = functionServerDispatcher
def receive = {
- case f: Function0[Unit] => try {
+ case f: Function0[Unit] ⇒ try {
f()
} finally {
self.stop()
@@ -1719,12 +1674,12 @@ class RemoteClusterDaemon(cluster: ClusterNode) extends Actor {
}
}).start ! payloadFor(message, classOf[Function0[Unit]])
- case FUNCTION_FUN0_ANY =>
+ case FUNCTION_FUN0_ANY ⇒
actorOf(new Actor() {
self.dispatcher = functionServerDispatcher
def receive = {
- case f: Function0[Any] => try {
+ case f: Function0[Any] ⇒ try {
self.reply(f())
} finally {
self.stop()
@@ -1732,12 +1687,12 @@ class RemoteClusterDaemon(cluster: ClusterNode) extends Actor {
}
}).start forward payloadFor(message, classOf[Function0[Any]])
- case FUNCTION_FUN1_ARG_UNIT =>
+ case FUNCTION_FUN1_ARG_UNIT ⇒
actorOf(new Actor() {
self.dispatcher = functionServerDispatcher
def receive = {
- case t: Tuple2[Function1[Any, Unit], Any] => try {
+ case t: Tuple2[Function1[Any, Unit], Any] ⇒ try {
t._1(t._2)
} finally {
self.stop()
@@ -1745,12 +1700,12 @@ class RemoteClusterDaemon(cluster: ClusterNode) extends Actor {
}
}).start ! payloadFor(message, classOf[Tuple2[Function1[Any, Unit], Any]])
- case FUNCTION_FUN1_ARG_ANY =>
+ case FUNCTION_FUN1_ARG_ANY ⇒
actorOf(new Actor() {
self.dispatcher = functionServerDispatcher
def receive = {
- case t: Tuple2[Function1[Any, Any], Any] => try {
+ case t: Tuple2[Function1[Any, Any], Any] ⇒ try {
self.reply(t._1(t._2))
} finally {
self.stop()
@@ -1759,7 +1714,7 @@ class RemoteClusterDaemon(cluster: ClusterNode) extends Actor {
}).start forward payloadFor(message, classOf[Tuple2[Function1[Any, Any], Any]])
}
- case unknown => EventHandler.warning(this, "Unknown message [%s]".format(unknown))
+ case unknown ⇒ EventHandler.warning(this, "Unknown message [%s]".format(unknown))
}
private def payloadFor[T](message: RemoteDaemonMessageProtocol, clazz: Class[T]): T = {
diff --git a/akka-cluster/src/main/scala/akka/cluster/ClusterActorRef.scala b/akka-cluster/src/main/scala/akka/cluster/ClusterActorRef.scala
index eb614a05fe..ec2060bfb5 100644
--- a/akka-cluster/src/main/scala/akka/cluster/ClusterActorRef.scala
+++ b/akka-cluster/src/main/scala/akka/cluster/ClusterActorRef.scala
@@ -25,7 +25,7 @@ class ClusterActorRef private[akka] (
actorType: ActorType,
val replicationStrategy: ReplicationStrategy)
extends RemoteActorRef(address, timeout, None, actorType) {
- this: ClusterActorRef with Router.Router =>
+ this: ClusterActorRef with Router.Router ⇒
EventHandler.debug(this, "Creating a ClusterActorRef for actor with address [%s]".format(address))
@@ -46,20 +46,20 @@ class ClusterActorRef private[akka] (
route[T](message, timeout)(senderOption).asInstanceOf[CompletableFuture[T]]
private[akka] def failOver(from: InetSocketAddress, to: InetSocketAddress) {
- addresses set (
- addresses.get map { case (address, actorRef) =>
+ addresses set (addresses.get map {
+ case (address, actorRef) ⇒
if (address == from) {
actorRef.stop()
(to, createRemoteActorRef(actorRef.uuid, to))
} else (address, actorRef)
- }
- )
+ })
}
private def createConnections(addresses: Array[Tuple2[UUID, InetSocketAddress]]): Map[InetSocketAddress, ActorRef] = {
var connections = Map.empty[InetSocketAddress, ActorRef]
- addresses foreach { case (uuid, address) =>
- connections = connections + (address -> createRemoteActorRef(uuid, address))
+ addresses foreach {
+ case (uuid, address) ⇒
+ connections = connections + (address -> createRemoteActorRef(uuid, address))
}
connections
}
diff --git a/akka-cluster/src/main/scala/akka/cluster/ClusterDeployer.scala b/akka-cluster/src/main/scala/akka/cluster/ClusterDeployer.scala
index 42984a6872..c850d72077 100644
--- a/akka-cluster/src/main/scala/akka/cluster/ClusterDeployer.scala
+++ b/akka-cluster/src/main/scala/akka/cluster/ClusterDeployer.scala
@@ -4,7 +4,7 @@
package akka.cluster
-import akka.actor.{DeploymentConfig, Deployer, DeploymentException}
+import akka.actor.{ DeploymentConfig, Deployer, DeploymentException }
import DeploymentConfig._
import akka.event.EventHandler
import akka.config.Config
@@ -13,9 +13,9 @@ import akka.util.Helpers._
import akka.cluster.zookeeper.AkkaZkClient
import org.apache.zookeeper.CreateMode
-import org.apache.zookeeper.recipes.lock.{WriteLock, LockListener}
+import org.apache.zookeeper.recipes.lock.{ WriteLock, LockListener }
-import org.I0Itec.zkclient.exception.{ZkNoNodeException, ZkNodeExistsException}
+import org.I0Itec.zkclient.exception.{ ZkNoNodeException, ZkNodeExistsException }
import scala.collection.JavaConversions.collectionAsScalaIterable
@@ -75,22 +75,20 @@ object ClusterDeployer {
Deploy(
address = RemoteClusterDaemon.ADDRESS,
routing = Direct,
- scope = Clustered(Deployer.defaultAddress, NoReplicas, Stateless))
- )
+ scope = Clustered(Deployer.defaultAddress, NoReplicas, Stateless)))
private[akka] def init(deployments: List[Deploy]) {
isConnected.switchOn {
- baseNodes.foreach {
- path =>
- try {
- ignore[ZkNodeExistsException](zkClient.create(path, null, CreateMode.PERSISTENT))
- EventHandler.debug(this, "Created node [%s]".format(path))
- } catch {
- case e =>
- val error = new DeploymentException(e.toString)
- EventHandler.error(error, this)
- throw error
- }
+ baseNodes.foreach { path ⇒
+ try {
+ ignore[ZkNodeExistsException](zkClient.create(path, null, CreateMode.PERSISTENT))
+ EventHandler.debug(this, "Created node [%s]".format(path))
+ } catch {
+ case e ⇒
+ val error = new DeploymentException(e.toString)
+ EventHandler.error(error, this)
+ throw error
+ }
}
val allDeployments = deployments ::: systemDeployments
@@ -121,9 +119,9 @@ object ClusterDeployer {
// FIXME trigger cluster-wide deploy action
} catch {
- case e: NullPointerException =>
+ case e: NullPointerException ⇒
handleError(new DeploymentException("Could not store deployment data [" + deployment + "] in ZooKeeper since client session is closed"))
- case e: Exception =>
+ case e: Exception ⇒
handleError(new DeploymentException("Could not store deployment data [" + deployment + "] in ZooKeeper due to: " + e))
}
}
@@ -134,7 +132,7 @@ object ClusterDeployer {
// FIXME trigger cluster-wide undeployment action
} catch {
- case e: Exception =>
+ case e: Exception ⇒
handleError(new DeploymentException("Could not undeploy deployment [" + deployment + "] in ZooKeeper due to: " + e))
}
}
@@ -142,11 +140,11 @@ object ClusterDeployer {
private[akka] def undeployAll() {
try {
for {
- child <- collectionAsScalaIterable(zkClient.getChildren(deploymentPath))
- deployment <- lookupDeploymentFor(child)
+ child ← collectionAsScalaIterable(zkClient.getChildren(deploymentPath))
+ deployment ← lookupDeploymentFor(child)
} undeploy(deployment)
} catch {
- case e: Exception =>
+ case e: Exception ⇒
handleError(new DeploymentException("Could not undeploy all deployment data in ZooKeeper due to: " + e))
}
}
@@ -155,8 +153,8 @@ object ClusterDeployer {
try {
Some(zkClient.readData(deploymentAddressPath.format(address)).asInstanceOf[Deploy])
} catch {
- case e: ZkNoNodeException => None
- case e: Exception =>
+ case e: ZkNoNodeException ⇒ None
+ case e: Exception ⇒
EventHandler.warning(this, e.toString)
None
}
diff --git a/akka-cluster/src/main/scala/akka/cluster/ReplicatedClusterRef.scala b/akka-cluster/src/main/scala/akka/cluster/ReplicatedClusterRef.scala
index 864870d2ec..ac1be8248d 100644
--- a/akka-cluster/src/main/scala/akka/cluster/ReplicatedClusterRef.scala
+++ b/akka-cluster/src/main/scala/akka/cluster/ReplicatedClusterRef.scala
@@ -13,13 +13,13 @@ import akka.dispatch._
import java.net.InetSocketAddress
import java.util.concurrent.atomic.AtomicReference
-import java.util.{ Map => JMap }
+import java.util.{ Map ⇒ JMap }
import akka.cluster.TransactionLog
/**
* @author Jonas Bonér
*/
-trait Replicable { this: Actor =>
+trait Replicable { this: Actor ⇒
}
/**
@@ -50,7 +50,7 @@ class ReplicatedActorRef private[akka] (actorRef: ActorRef, val address: String)
def start(): ActorRef = {
EventHandler.debug(this, "Starting ReplicatedActorRef for Actor [%s] with transaction log [%s]"
- .format(address, txLog.logId))
+ .format(address, txLog.logId))
actorRef.start()
}
@@ -87,8 +87,7 @@ class ReplicatedActorRef private[akka] (actorRef: ActorRef, val address: String)
message: Any,
timeout: Long,
senderOption: Option[ActorRef],
- senderFuture: Option[CompletableFuture[T]]): CompletableFuture[T]
- = actorRef.postMessageToMailboxAndCreateFutureResultWithTimeout(message, timeout, senderOption, senderFuture)
+ senderFuture: Option[CompletableFuture[T]]): CompletableFuture[T] = actorRef.postMessageToMailboxAndCreateFutureResultWithTimeout(message, timeout, senderOption, senderFuture)
protected[akka] def actorInstance: AtomicReference[Actor] = actorRef.actorInstance
protected[akka] def supervisor_=(sup: Option[ActorRef]) {
actorRef.supervisor_=(sup)
diff --git a/akka-cluster/src/main/scala/akka/cluster/Routing.scala b/akka-cluster/src/main/scala/akka/cluster/Routing.scala
index 0f7408be4b..3713766605 100644
--- a/akka-cluster/src/main/scala/akka/cluster/Routing.scala
+++ b/akka-cluster/src/main/scala/akka/cluster/Routing.scala
@@ -30,21 +30,21 @@ object Router {
replicationStrategy: ReplicationStrategy = ReplicationStrategy.WriteThrough): ClusterActorRef = {
routerType match {
- case Direct => new ClusterActorRef(
+ case Direct ⇒ new ClusterActorRef(
addresses, serviceId, timeout,
actorType, replicationStrategy) with Direct
- case Random => new ClusterActorRef(
+ case Random ⇒ new ClusterActorRef(
addresses, serviceId, timeout,
actorType, replicationStrategy) with Random
- case RoundRobin => new ClusterActorRef(
+ case RoundRobin ⇒ new ClusterActorRef(
addresses, serviceId, timeout,
actorType, replicationStrategy) with RoundRobin
- case LeastCPU => sys.error("Router LeastCPU not supported yet")
- case LeastRAM => sys.error("Router LeastRAM not supported yet")
- case LeastMessages => sys.error("Router LeastMessages not supported yet")
+ case LeastCPU ⇒ sys.error("Router LeastCPU not supported yet")
+ case LeastRAM ⇒ sys.error("Router LeastRAM not supported yet")
+ case LeastMessages ⇒ sys.error("Router LeastMessages not supported yet")
}
}
@@ -65,7 +65,7 @@ object Router {
trait Direct extends Router {
lazy val connection: Option[ActorRef] = {
if (connections.size == 0) throw new IllegalStateException("DirectRouter need a single replica connection found [0]")
- connections.toList.map({ case (address, actor) => actor }).headOption
+ connections.toList.map({ case (address, actor) ⇒ actor }).headOption
}
def route(message: Any)(implicit sender: Option[ActorRef]) {
@@ -75,7 +75,7 @@ object Router {
def route[T](message: Any, timeout: Long)(implicit sender: Option[ActorRef]): Future[T] =
if (connection.isDefined) connection.get.!!!(message, timeout)(sender)
- else throw new RoutingException("No node connections for router")
+ else throw new RoutingException("No node connections for router")
}
/**
@@ -91,12 +91,12 @@ object Router {
def route[T](message: Any, timeout: Long)(implicit sender: Option[ActorRef]): Future[T] =
if (next.isDefined) next.get.!!!(message, timeout)(sender)
- else throw new RoutingException("No node connections for router")
+ else throw new RoutingException("No node connections for router")
private def next: Option[ActorRef] = {
val nrOfConnections = connections.size
if (nrOfConnections == 0) None
- else Some(connections.toArray.apply(random.nextInt(nrOfConnections))._2)
+ else Some(connections.toArray.apply(random.nextInt(nrOfConnections))._2)
}
}
@@ -104,7 +104,7 @@ object Router {
* @author Jonas Bonér
*/
trait RoundRobin extends Router {
- private def items: List[ActorRef] = connections.toList.map({ case (address, actor) => actor })
+ private def items: List[ActorRef] = connections.toList.map({ case (address, actor) ⇒ actor })
@volatile
private var current = items
@@ -116,7 +116,7 @@ object Router {
def route[T](message: Any, timeout: Long)(implicit sender: Option[ActorRef]): Future[T] =
if (next.isDefined) next.get.!!!(message, timeout)(sender)
- else throw new RoutingException("No node connections for router")
+ else throw new RoutingException("No node connections for router")
private def hasNext = items != Nil
diff --git a/akka-cluster/src/main/scala/akka/cluster/TransactionLog.scala b/akka-cluster/src/main/scala/akka/cluster/TransactionLog.scala
index 3d0c466d20..b6e30fca1c 100644
--- a/akka-cluster/src/main/scala/akka/cluster/TransactionLog.scala
+++ b/akka-cluster/src/main/scala/akka/cluster/TransactionLog.scala
@@ -4,7 +4,7 @@ package akka.cluster
* Copyright (C) 2009-2011 Scalable Solutions AB propagation - For controlling how nested transactions behave. *
traceLevel - Transaction trace level.
*/
-class TransactionConfig(val familyName: String = TransactionConfig.FAMILY_NAME,
- val readonly: JBoolean = TransactionConfig.READONLY,
- val maxRetries: Int = TransactionConfig.MAX_RETRIES,
- val timeout: Duration = TransactionConfig.DefaultTimeout,
- val trackReads: JBoolean = TransactionConfig.TRACK_READS,
- val writeSkew: Boolean = TransactionConfig.WRITE_SKEW,
- val blockingAllowed: Boolean = TransactionConfig.BLOCKING_ALLOWED,
- val interruptible: Boolean = TransactionConfig.INTERRUPTIBLE,
- val speculative: Boolean = TransactionConfig.SPECULATIVE,
- val quickRelease: Boolean = TransactionConfig.QUICK_RELEASE,
+class TransactionConfig(val familyName: String = TransactionConfig.FAMILY_NAME,
+ val readonly: JBoolean = TransactionConfig.READONLY,
+ val maxRetries: Int = TransactionConfig.MAX_RETRIES,
+ val timeout: Duration = TransactionConfig.DefaultTimeout,
+ val trackReads: JBoolean = TransactionConfig.TRACK_READS,
+ val writeSkew: Boolean = TransactionConfig.WRITE_SKEW,
+ val blockingAllowed: Boolean = TransactionConfig.BLOCKING_ALLOWED,
+ val interruptible: Boolean = TransactionConfig.INTERRUPTIBLE,
+ val speculative: Boolean = TransactionConfig.SPECULATIVE,
+ val quickRelease: Boolean = TransactionConfig.QUICK_RELEASE,
val propagation: MPropagation = TransactionConfig.PROPAGATION,
- val traceLevel: MTraceLevel = TransactionConfig.TRACE_LEVEL)
+ val traceLevel: MTraceLevel = TransactionConfig.TRACE_LEVEL)
object DefaultTransactionConfig extends TransactionConfig
@@ -121,18 +121,18 @@ object TransactionFactory {
def apply(config: TransactionConfig, defaultName: String) = new TransactionFactory(config, defaultName)
- def apply(familyName: String = TransactionConfig.FAMILY_NAME,
- readonly: JBoolean = TransactionConfig.READONLY,
- maxRetries: Int = TransactionConfig.MAX_RETRIES,
- timeout: Duration = TransactionConfig.DefaultTimeout,
- trackReads: JBoolean = TransactionConfig.TRACK_READS,
- writeSkew: Boolean = TransactionConfig.WRITE_SKEW,
- blockingAllowed: Boolean = TransactionConfig.BLOCKING_ALLOWED,
- interruptible: Boolean = TransactionConfig.INTERRUPTIBLE,
- speculative: Boolean = TransactionConfig.SPECULATIVE,
- quickRelease: Boolean = TransactionConfig.QUICK_RELEASE,
+ def apply(familyName: String = TransactionConfig.FAMILY_NAME,
+ readonly: JBoolean = TransactionConfig.READONLY,
+ maxRetries: Int = TransactionConfig.MAX_RETRIES,
+ timeout: Duration = TransactionConfig.DefaultTimeout,
+ trackReads: JBoolean = TransactionConfig.TRACK_READS,
+ writeSkew: Boolean = TransactionConfig.WRITE_SKEW,
+ blockingAllowed: Boolean = TransactionConfig.BLOCKING_ALLOWED,
+ interruptible: Boolean = TransactionConfig.INTERRUPTIBLE,
+ speculative: Boolean = TransactionConfig.SPECULATIVE,
+ quickRelease: Boolean = TransactionConfig.QUICK_RELEASE,
propagation: MPropagation = TransactionConfig.PROPAGATION,
- traceLevel: MTraceLevel = TransactionConfig.TRACE_LEVEL) = {
+ traceLevel: MTraceLevel = TransactionConfig.TRACE_LEVEL) = {
val config = new TransactionConfig(
familyName, readonly, maxRetries, timeout, trackReads, writeSkew, blockingAllowed,
interruptible, speculative, quickRelease, propagation, traceLevel)
@@ -163,23 +163,23 @@ object TransactionFactory {
*/
class TransactionFactory(
val config: TransactionConfig = DefaultTransactionConfig,
- defaultName: String = TransactionConfig.FAMILY_NAME) { self =>
+ defaultName: String = TransactionConfig.FAMILY_NAME) { self ⇒
// use the config family name if it's been set, otherwise defaultName - used by actors to set class name as default
val familyName = if (config.familyName != TransactionConfig.FAMILY_NAME) config.familyName else defaultName
val factory = {
var builder = (getGlobalStmInstance().asInstanceOf[AlphaStm].getTransactionFactoryBuilder()
- .setFamilyName(familyName)
- .setMaxRetries(config.maxRetries)
- .setTimeoutNs(config.timeout.toNanos)
- .setWriteSkewAllowed(config.writeSkew)
- .setExplicitRetryAllowed(config.blockingAllowed)
- .setInterruptible(config.interruptible)
- .setSpeculativeConfigurationEnabled(config.speculative)
- .setQuickReleaseEnabled(config.quickRelease)
- .setPropagationLevel(config.propagation)
- .setTraceLevel(config.traceLevel))
+ .setFamilyName(familyName)
+ .setMaxRetries(config.maxRetries)
+ .setTimeoutNs(config.timeout.toNanos)
+ .setWriteSkewAllowed(config.writeSkew)
+ .setExplicitRetryAllowed(config.blockingAllowed)
+ .setInterruptible(config.interruptible)
+ .setSpeculativeConfigurationEnabled(config.speculative)
+ .setQuickReleaseEnabled(config.quickRelease)
+ .setPropagationLevel(config.propagation)
+ .setTraceLevel(config.traceLevel))
if (config.readonly ne null) {
builder = builder.setReadonly(config.readonly.booleanValue)
@@ -200,18 +200,18 @@ class TransactionFactory(
*/
object Propagation {
val RequiresNew = MPropagation.RequiresNew
- val Mandatory = MPropagation.Mandatory
- val Requires = MPropagation.Requires
- val Supports = MPropagation.Supports
- val Never = MPropagation.Never
+ val Mandatory = MPropagation.Mandatory
+ val Requires = MPropagation.Requires
+ val Supports = MPropagation.Supports
+ val Never = MPropagation.Never
}
/**
* Mapping to Multiverse TraceLevel.
*/
object TraceLevel {
- val None = MTraceLevel.none
+ val None = MTraceLevel.none
val Coarse = MTraceLevel.course // mispelling?
val Course = MTraceLevel.course
- val Fine = MTraceLevel.fine
+ val Fine = MTraceLevel.fine
}
diff --git a/akka-stm/src/main/scala/akka/stm/TransactionFactoryBuilder.scala b/akka-stm/src/main/scala/akka/stm/TransactionFactoryBuilder.scala
index b71f68c375..147984b5e9 100644
--- a/akka-stm/src/main/scala/akka/stm/TransactionFactoryBuilder.scala
+++ b/akka-stm/src/main/scala/akka/stm/TransactionFactoryBuilder.scala
@@ -4,29 +4,29 @@
package akka.stm
-import java.lang.{Boolean => JBoolean}
+import java.lang.{ Boolean ⇒ JBoolean }
import akka.util.Duration
-import org.multiverse.api.{TraceLevel => MTraceLevel}
-import org.multiverse.api.{PropagationLevel => MPropagation}
+import org.multiverse.api.{ TraceLevel ⇒ MTraceLevel }
+import org.multiverse.api.{ PropagationLevel ⇒ MPropagation }
/**
* For more easily creating TransactionConfig from Java.
*/
class TransactionConfigBuilder {
- var familyName: String = TransactionConfig.FAMILY_NAME
- var readonly: JBoolean = TransactionConfig.READONLY
- var maxRetries: Int = TransactionConfig.MAX_RETRIES
- var timeout: Duration = TransactionConfig.DefaultTimeout
- var trackReads: JBoolean = TransactionConfig.TRACK_READS
- var writeSkew: Boolean = TransactionConfig.WRITE_SKEW
- var blockingAllowed: Boolean = TransactionConfig.BLOCKING_ALLOWED
- var interruptible: Boolean = TransactionConfig.INTERRUPTIBLE
- var speculative: Boolean = TransactionConfig.SPECULATIVE
- var quickRelease: Boolean = TransactionConfig.QUICK_RELEASE
+ var familyName: String = TransactionConfig.FAMILY_NAME
+ var readonly: JBoolean = TransactionConfig.READONLY
+ var maxRetries: Int = TransactionConfig.MAX_RETRIES
+ var timeout: Duration = TransactionConfig.DefaultTimeout
+ var trackReads: JBoolean = TransactionConfig.TRACK_READS
+ var writeSkew: Boolean = TransactionConfig.WRITE_SKEW
+ var blockingAllowed: Boolean = TransactionConfig.BLOCKING_ALLOWED
+ var interruptible: Boolean = TransactionConfig.INTERRUPTIBLE
+ var speculative: Boolean = TransactionConfig.SPECULATIVE
+ var quickRelease: Boolean = TransactionConfig.QUICK_RELEASE
var propagation: MPropagation = TransactionConfig.PROPAGATION
- var traceLevel: MTraceLevel = TransactionConfig.TRACE_LEVEL
+ var traceLevel: MTraceLevel = TransactionConfig.TRACE_LEVEL
def setFamilyName(familyName: String) = { this.familyName = familyName; this }
def setReadonly(readonly: JBoolean) = { this.readonly = readonly; this }
@@ -50,18 +50,18 @@ class TransactionConfigBuilder {
* For more easily creating TransactionFactory from Java.
*/
class TransactionFactoryBuilder {
- var familyName: String = TransactionConfig.FAMILY_NAME
- var readonly: JBoolean = TransactionConfig.READONLY
- var maxRetries: Int = TransactionConfig.MAX_RETRIES
- var timeout: Duration = TransactionConfig.DefaultTimeout
- var trackReads: JBoolean = TransactionConfig.TRACK_READS
- var writeSkew: Boolean = TransactionConfig.WRITE_SKEW
- var blockingAllowed: Boolean = TransactionConfig.BLOCKING_ALLOWED
- var interruptible: Boolean = TransactionConfig.INTERRUPTIBLE
- var speculative: Boolean = TransactionConfig.SPECULATIVE
- var quickRelease: Boolean = TransactionConfig.QUICK_RELEASE
+ var familyName: String = TransactionConfig.FAMILY_NAME
+ var readonly: JBoolean = TransactionConfig.READONLY
+ var maxRetries: Int = TransactionConfig.MAX_RETRIES
+ var timeout: Duration = TransactionConfig.DefaultTimeout
+ var trackReads: JBoolean = TransactionConfig.TRACK_READS
+ var writeSkew: Boolean = TransactionConfig.WRITE_SKEW
+ var blockingAllowed: Boolean = TransactionConfig.BLOCKING_ALLOWED
+ var interruptible: Boolean = TransactionConfig.INTERRUPTIBLE
+ var speculative: Boolean = TransactionConfig.SPECULATIVE
+ var quickRelease: Boolean = TransactionConfig.QUICK_RELEASE
var propagation: MPropagation = TransactionConfig.PROPAGATION
- var traceLevel: MTraceLevel = TransactionConfig.TRACE_LEVEL
+ var traceLevel: MTraceLevel = TransactionConfig.TRACE_LEVEL
def setFamilyName(familyName: String) = { this.familyName = familyName; this }
def setReadonly(readonly: JBoolean) = { this.readonly = readonly; this }
diff --git a/akka-stm/src/main/scala/akka/stm/TransactionalMap.scala b/akka-stm/src/main/scala/akka/stm/TransactionalMap.scala
index 61b131b211..1f833e9b06 100644
--- a/akka-stm/src/main/scala/akka/stm/TransactionalMap.scala
+++ b/akka-stm/src/main/scala/akka/stm/TransactionalMap.scala
@@ -6,7 +6,7 @@ package akka.stm
import scala.collection.immutable.HashMap
-import akka.actor.{newUuid}
+import akka.actor.{ newUuid }
/**
* Transactional map that implements the mutable Map interface with an underlying Ref and HashMap.
@@ -43,7 +43,7 @@ class TransactionalMap[K, V](initialValue: HashMap[K, V]) extends Transactional
def +=(key: K, value: V) = put(key, value)
def +=(kv: (K, V)) = {
- put(kv._1,kv._2)
+ put(kv._1, kv._2)
this
}
@@ -83,7 +83,7 @@ class TransactionalMap[K, V](initialValue: HashMap[K, V]) extends Transactional
override def equals(other: Any): Boolean =
other.isInstanceOf[TransactionalMap[_, _]] &&
- other.hashCode == hashCode
+ other.hashCode == hashCode
override def toString = if (Stm.activeTransaction) super.toString else "