raboof/pekko
1
0
Fork 0
Code Issues Pull requests Projects Releases 6 Packages Wiki Activity Actions 10

Quieten the multi-jvm tests

Browse source
This commit is contained in:
Peter Vlugter 2011-08-04 16:49:05 +12:00
parent 6a476b6e69
commit ea369a4b65
20 changed files with 120 additions and 64 deletions
Download patch file Download diff file Expand all files Collapse all files

4
akka-cluster/src/multi-jvm/scala/akka/cluster/ClusterTestNode.scala
View file

@ -55,7 +55,6 @@ object ClusterTestNode {
val Timeout = 1.minute
def ready(className: String) = {
println("ClusterTest: READY")
readyFile(className).createNewFile()
}
@ -64,11 +63,9 @@ object ClusterTestNode {
cleanUp(className)
sys.error("Timeout waiting for cluster ready")
}
println("ClusterTest: GO")
}
def exit(className: String) = {
println("ClusterTest: EXIT")
exitFile(className).createNewFile()
}
@ -77,7 +74,6 @@ object ClusterTestNode {
cleanUp(className)
sys.error("Timeout waiting for node exits")
}
println("ClusterTest: SHUTDOWN")
}
def cleanUp(className: String) = {

20
akka-cluster/src/multi-jvm/scala/akka/cluster/QuietReporter.scala Normal file
View file

@ -0,0 +1,20 @@
/**
* Copyright (C) 2009-2011 Typesafe Inc. <http://www.typesafe.com>
*/
package org.scalatest.akka
import org.scalatest.tools.StandardOutReporter
import org.scalatest.events._
import java.lang.Boolean.getBoolean
class QuietReporter(inColor: Boolean) extends StandardOutReporter(false, inColor, false, false) {
def this() = this(!getBoolean("akka.test.nocolor"))
override def apply(event: Event): Unit = event match {
case _: RunStarting ⇒ ()
case _ ⇒ super.apply(event)
}
override def makeFinalReport(resourceName: String, duration: Option[Long], summaryOption: Option[Summary]): Unit = {}
}

1
akka-cluster/src/multi-jvm/scala/akka/cluster/reflogic/ClusterActorRefCleanupMultiJvmNode1.conf
View file

@ -1,4 +1,5 @@
akka.enabled-modules = ["cluster"]
akka.event-handlers = ["akka.testkit.TestEventListener"]
akka.event-handler-level = "ERROR"
akka.actor.deployment.service-test.router = "round-robin"
akka.actor.deployment.service-test.clustered.preferred-nodes = ["node:node2","node:node3"]

27
akka-cluster/src/multi-jvm/scala/akka/cluster/reflogic/ClusterActorRefCleanupMultiJvmSpec.scala
View file

@ -7,7 +7,10 @@ package akka.cluster.reflogic
import akka.cluster._
import akka.cluster.Cluster._
import akka.actor.Actor
import akka.event.EventHandler
import akka.testkit.{ EventFilter, TestEvent }
import akka.routing.RoutingException
import java.net.ConnectException
import java.nio.channels.{ ClosedChannelException, NotYetConnectedException }
object ClusterActorRefCleanupMultiJvmSpec {
@ -15,16 +18,16 @@ object ClusterActorRefCleanupMultiJvmSpec {
val NrOfNodes = 3
class TestActor extends Actor with Serializable {
println("--------------------------------------")
println("TestActor created")
println("--------------------------------------")
//println("--------------------------------------")
//println("TestActor created")
//println("--------------------------------------")
def receive = {
case "Die" ⇒
println("Killing JVM: " + Cluster.node.nodeAddress)
//println("Killing JVM: " + Cluster.node.nodeAddress)
System.exit(0)
case _ ⇒
println("Hello")
//println("Hello")
}
}
@ -50,6 +53,15 @@ class ClusterActorRefCleanupMultiJvmNode1 extends MasterClusterTestNode {
//verify that all remote actors are there.
clusteredRef.connections.size must be(2)
// ignore exceptions from killing nodes
val ignoreExceptions = Seq(
EventFilter[ClosedChannelException],
EventFilter[NotYetConnectedException],
EventFilter[RoutingException],
EventFilter[ConnectException])
EventHandler.notify(TestEvent.Mute(ignoreExceptions))
//let one of the actors die.
clusteredRef ! "Die"
@ -89,11 +101,8 @@ class ClusterActorRefCleanupMultiJvmNode1 extends MasterClusterTestNode {
clusteredRef.connections.size must be(0)
//and lets make sure we now get the correct exception if we try to use the ref.
try {
intercept[RoutingException] {
clusteredRef ! "Hello"
assert(false)
} catch {
case e: RoutingException ⇒
}
node.shutdown()

2
akka-cluster/src/multi-jvm/scala/akka/cluster/replication/transactionlog/writebehind/nosnapshot/ReplicationTransactionLogWriteBehindNoSnapshotMultiJvmNode2.conf
View file

@ -1,5 +1,5 @@
akka.enabled-modules = ["cluster"]
akka.event-handler-level = "WARNING"
akka.event-handler-level = "ERROR"
akka.actor.deployment.hello-world.router = "direct"
akka.actor.deployment.hello-world.clustered.replication-factor = 1
akka.actor.deployment.hello-world.clustered.replication.storage = "transaction-log"

2
akka-cluster/src/multi-jvm/scala/akka/cluster/replication/transactionlog/writebehind/snapshot/ReplicationTransactionLogWriteBehindSnapshotMultiJvmNode2.conf
View file

@ -1,5 +1,5 @@
akka.enabled-modules = ["cluster"]
akka.event-handler-level = "WARNING"
akka.event-handler-level = "ERROR"
akka.actor.deployment.hello-world.router = "direct"
akka.actor.deployment.hello-world.clustered.replication-factor = 1
akka.actor.deployment.hello-world.clustered.replication.storage = "transaction-log"

4
akka-cluster/src/multi-jvm/scala/akka/cluster/replication/transactionlog/writebehind/snapshot/ReplicationTransactionLogWriteBehindSnapshotMultiJvmSpec.scala
View file

@ -19,11 +19,11 @@ object ReplicationTransactionLogWriteBehindSnapshotMultiJvmSpec {
class HelloWorld extends Actor with Serializable {
var log = ""
println("Creating HelloWorld log =======> " + log)
//println("Creating HelloWorld log =======> " + log)
def receive = {
case Count(nr) ⇒
log += nr.toString
println("Message to HelloWorld log =======> " + log)
//println("Message to HelloWorld log =======> " + log)
self.reply("World from node [" + Config.nodename + "]")
case GetLog ⇒
self.reply(Log(log))

2
akka-cluster/src/multi-jvm/scala/akka/cluster/replication/transactionlog/writethrough/nosnapshot/ReplicationTransactionLogWriteThroughNoSnapshotMultiJvmNode2.conf
View file

@ -1,5 +1,5 @@
akka.enabled-modules = ["cluster"]
akka.event-handler-level = "WARNING"
akka.event-handler-level = "ERROR"
akka.actor.deployment.hello-world.router = "direct"
akka.actor.deployment.hello-world.clustered.replication-factor = 1
akka.actor.deployment.hello-world.clustered.replication.storage = "transaction-log"

2
akka-cluster/src/multi-jvm/scala/akka/cluster/replication/transactionlog/writethrough/snapshot/ReplicationTransactionLogWriteThroughSnapshotMultiJvmNode2.conf
View file

@ -1,5 +1,5 @@
akka.enabled-modules = ["cluster"]
akka.event-handler-level = "WARNING"
akka.event-handler-level = "ERROR"
akka.actor.deployment.hello-world.router = "direct"
akka.actor.deployment.hello-world.clustered.replication-factor = 1
akka.actor.deployment.hello-world.clustered.replication.storage = "transaction-log"

4
akka-cluster/src/multi-jvm/scala/akka/cluster/replication/transactionlog/writethrough/snapshot/ReplicationTransactionLogWriteThroughSnapshotMultiJvmSpec.scala
View file

@ -19,11 +19,11 @@ object ReplicationTransactionLogWriteThroughSnapshotMultiJvmSpec {
class HelloWorld extends Actor with Serializable {
var log = ""
println("Creating HelloWorld log =======> " + log)
//println("Creating HelloWorld log =======> " + log)
def receive = {
case Count(nr) ⇒
log += nr.toString
println("Message to HelloWorld log =======> " + log)
//println("Message to HelloWorld log =======> " + log)
self.reply("World from node [" + Config.nodename + "]")
case GetLog ⇒
self.reply(Log(log))

1
akka-cluster/src/multi-jvm/scala/akka/cluster/routing/direct/failover/FailoverDirectRoutingMultiJvmNode1.conf
View file

@ -1,4 +1,5 @@
akka.enabled-modules = ["cluster"]
akka.event-handlers = ["akka.testkit.TestEventListener"]
akka.event-handler-level = "WARNING"
akka.actor.deployment.service-hello.router = "direct"
akka.actor.deployment.service-hello.clustered.home = "node:node2"

30
akka-cluster/src/multi-jvm/scala/akka/cluster/routing/direct/failover/FailoverDirectRoutingMultiJvmSpec.scala
View file

@ -4,22 +4,26 @@ import akka.config.Config
import scala.Predef._
import akka.cluster.{ ClusterActorRef, Cluster, MasterClusterTestNode, ClusterTestNode }
import akka.actor.{ ActorInitializationException, Actor }
import akka.event.EventHandler
import akka.testkit.{ EventFilter, TestEvent }
import java.net.ConnectException
import java.nio.channels.NotYetConnectedException
object FailoverDirectRoutingMultiJvmSpec {
val NrOfNodes = 2
class SomeActor extends Actor with Serializable {
println("---------------------------------------------------------------------------")
println("SomeActor has been created on node [" + Config.nodename + "]")
println("---------------------------------------------------------------------------")
//println("---------------------------------------------------------------------------")
//println("SomeActor has been created on node [" + Config.nodename + "]")
//println("---------------------------------------------------------------------------")
def receive = {
case "identify" ⇒
println("The node received the 'identify' command: " + Config.nodename)
//println("The node received the 'identify' command: " + Config.nodename)
self.reply(Config.nodename)
case "die" ⇒
println("The node received the 'die' command: " + Config.nodename)
//println("The node received the 'die' command: " + Config.nodename)
Cluster.node.shutdown
}
}
@ -35,27 +39,27 @@ class FailoverDirectRoutingMultiJvmNode1 extends MasterClusterTestNode {
"Direct Router" must {
"not yet be able to failover to another node" in {
println("==================================================================================================")
println(" FAILOVER DIRECT ROUTING")
println("==================================================================================================")
//println("==================================================================================================")
//println(" FAILOVER DIRECT ROUTING")
//println("==================================================================================================")
val ignoreExceptions = Seq(EventFilter[NotYetConnectedException], EventFilter[ConnectException])
EventHandler.notify(TestEvent.Mute(ignoreExceptions))
Cluster.node.start()
Cluster.barrier("waiting-for-begin", NrOfNodes).await()
val actor = Actor.actorOf[SomeActor]("service-hello").start().asInstanceOf[ClusterActorRef]
println("retrieved identity was: " + (actor ? "identify").get)
//println("retrieved identity was: " + (actor ? "identify").get)
(actor ? "identify").get must equal("node2")
actor ! "die"
Thread.sleep(4000)
try {
intercept[ActorInitializationException] {
actor ! "identify"
fail()
} catch {
case e: ActorInitializationException ⇒
}
}
}

8
akka-cluster/src/multi-jvm/scala/akka/cluster/routing/direct/normalusage/SingleReplicaDirectRoutingMultiJvmSpec.scala
View file

@ -8,13 +8,13 @@ object SingleReplicaDirectRoutingMultiJvmSpec {
val NrOfNodes = 2
class SomeActor extends Actor with Serializable {
println("---------------------------------------------------------------------------")
println("SomeActor has been created on node [" + Config.nodename + "]")
println("---------------------------------------------------------------------------")
//println("---------------------------------------------------------------------------")
//println("SomeActor has been created on node [" + Config.nodename + "]")
//println("---------------------------------------------------------------------------")
def receive = {
case "identify" ⇒ {
println("The node received the 'identify' command: " + Config.nodename)
//println("The node received the 'identify' command: " + Config.nodename)
self.reply(Config.nodename)
}
}

1
akka-cluster/src/multi-jvm/scala/akka/cluster/routing/random/failover/RandomFailoverMultiJvmNode1.conf
View file

@ -1,4 +1,5 @@
akka.enabled-modules = ["cluster"]
akka.event-handlers = ["akka.testkit.TestEventListener"]
akka.event-handler-level = "WARNING"
akka.actor.deployment.service-hello.router = "random"
akka.actor.deployment.service-hello.clustered.preferred-nodes = ["node:node2"]

29
akka-cluster/src/multi-jvm/scala/akka/cluster/routing/random/failover/RandomFailoverMultiJvmSpec.scala
View file

@ -3,24 +3,28 @@ package akka.cluster.routing.random.failover
import akka.config.Config
import akka.cluster._
import akka.actor.{ ActorRef, Actor }
import akka.event.EventHandler
import akka.testkit.{ EventFilter, TestEvent }
import java.util.{ Collections, Set ⇒ JSet }
import java.net.ConnectException
import java.nio.channels.NotYetConnectedException
object RandomFailoverMultiJvmSpec {
val NrOfNodes = 3
class SomeActor extends Actor with Serializable {
println("---------------------------------------------------------------------------")
println("SomeActor has been created on node [" + Config.nodename + "]")
println("---------------------------------------------------------------------------")
//println("---------------------------------------------------------------------------")
//println("SomeActor has been created on node [" + Config.nodename + "]")
//println("---------------------------------------------------------------------------")
def receive = {
case "identify" ⇒ {
println("The node received the 'identify' command")
//println("The node received the 'identify' command")
self.reply(Config.nodename)
}
case "shutdown" ⇒ {
println("The node received the 'shutdown' command")
//println("The node received the 'shutdown' command")
Cluster.node.shutdown()
}
}
@ -35,13 +39,16 @@ class RandomFailoverMultiJvmNode1 extends MasterClusterTestNode {
def testNodes = NrOfNodes
def sleepSome() {
println("Starting sleep")
//println("Starting sleep")
Thread.sleep(1000) //nasty.. but ok for now.
println("Finished doing sleep")
//println("Finished doing sleep")
}
"Random: when routing fails" must {
"jump to another replica" in {
val ignoreExceptions = Seq(EventFilter[NotYetConnectedException], EventFilter[ConnectException])
EventHandler.notify(TestEvent.Mute(ignoreExceptions))
Cluster.node.start()
Cluster.barrier("waiting-for-begin", NrOfNodes).await()
@ -49,8 +56,8 @@ class RandomFailoverMultiJvmNode1 extends MasterClusterTestNode {
val actor = Actor.actorOf[SomeActor]("service-hello").asInstanceOf[ClusterActorRef]
val oldFoundConnections = identifyConnections(actor)
println("---------------------------- oldFoundConnections ------------------------")
println(oldFoundConnections)
//println("---------------------------- oldFoundConnections ------------------------")
//println(oldFoundConnections)
//since we have replication factor 2
oldFoundConnections.size() must be(2)
@ -65,8 +72,8 @@ class RandomFailoverMultiJvmNode1 extends MasterClusterTestNode {
//the test code has been deactivated to prevent causing problems.
val newFoundConnections = identifyConnections(actor)
println("---------------------------- newFoundConnections ------------------------")
println(newFoundConnections)
//println("---------------------------- newFoundConnections ------------------------")
//println(newFoundConnections)
//it still must be 2 since a different node should have been used to failover to
newFoundConnections.size() must be(2)

1
akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/failover/RoundRobinFailoverMultiJvmNode1.conf
View file

@ -1,4 +1,5 @@
akka.enabled-modules = ["cluster"]
akka.event-handlers = ["akka.testkit.TestEventListener"]
akka.event-handler-level = "WARNING"
akka.actor.deployment.service-hello.router = "round-robin"
akka.actor.deployment.service-hello.clustered.preferred-nodes = ["node:node2"]

33
akka-cluster/src/multi-jvm/scala/akka/cluster/routing/roundrobin/failover/RoundRobinFailoverMultiJvmSpec.scala
View file

@ -3,24 +3,28 @@ package akka.cluster.routing.roundrobin.failover
import akka.config.Config
import akka.cluster._
import akka.actor.{ ActorRef, Actor }
import akka.event.EventHandler
import akka.testkit.{ EventFilter, TestEvent }
import java.util.{ Collections, Set ⇒ JSet }
import java.net.ConnectException
import java.nio.channels.NotYetConnectedException
object RoundRobinFailoverMultiJvmSpec {
val NrOfNodes = 3
class SomeActor extends Actor with Serializable {
println("---------------------------------------------------------------------------")
println("SomeActor has been created on node [" + Config.nodename + "]")
println("---------------------------------------------------------------------------")
//println("---------------------------------------------------------------------------")
//println("SomeActor has been created on node [" + Config.nodename + "]")
//println("---------------------------------------------------------------------------")
def receive = {
case "identify" ⇒ {
println("The node received the 'identify' command")
//println("The node received the 'identify' command")
self.reply(Config.nodename)
}
case "shutdown" ⇒ {
println("The node received the 'shutdown' command")
//println("The node received the 'shutdown' command")
Cluster.node.shutdown()
}
}
@ -35,13 +39,20 @@ class RoundRobinFailoverMultiJvmNode1 extends MasterClusterTestNode {
def testNodes = NrOfNodes
def sleepSome() {
println("Starting sleep")
//println("Starting sleep")
Thread.sleep(1000) //nasty.. but ok for now.
println("Finished doing sleep")
//println("Finished doing sleep")
}
"Round Robin: when round robin fails" must {
"jump to another replica" in {
val ignoreExceptions = Seq(
EventFilter[NotYetConnectedException],
EventFilter[ConnectException],
EventFilter[ClusterException])
EventHandler.notify(TestEvent.Mute(ignoreExceptions))
Cluster.node.start()
Cluster.barrier("waiting-for-begin", NrOfNodes).await()
@ -49,8 +60,8 @@ class RoundRobinFailoverMultiJvmNode1 extends MasterClusterTestNode {
val actor = Actor.actorOf[SomeActor]("service-hello").asInstanceOf[ClusterActorRef]
val oldFoundConnections = identifyConnections(actor)
println("---------------------------- oldFoundConnections ------------------------")
println(oldFoundConnections)
//println("---------------------------- oldFoundConnections ------------------------")
//println(oldFoundConnections)
//since we have replication factor 2
oldFoundConnections.size() must be(2)
@ -66,8 +77,8 @@ class RoundRobinFailoverMultiJvmNode1 extends MasterClusterTestNode {
/*
val newFoundConnections = identifyConnections(actor)
println("---------------------------- newFoundConnections ------------------------")
println(newFoundConnections)
//println("---------------------------- newFoundConnections ------------------------")
//println(newFoundConnections)
//it still must be 2 since a different node should have been used to failover to
newFoundConnections.size() must be(2)

2
akka-cluster/src/test/resources/log4j.properties
View file

@ -1,6 +1,6 @@
# Define some default values that can be overridden by system properties
zookeeper.root.logger=INFO, CONSOLE
zookeeper.console.threshold=INFO
zookeeper.console.threshold=OFF
zookeeper.log.dir=.
zookeeper.log.file=zookeeper.log
zookeeper.log.threshold=DEBUG

9
project/AkkaBuild.scala
View file

@ -1,7 +1,8 @@
import sbt._
import Keys._
import MultiJvmPlugin.{ MultiJvm, extraOptions }
import MultiJvmPlugin.{ MultiJvm, extraOptions, jvmOptions, scalatestOptions }
import ScalariformPlugin.{ format, formatPreferences }
import java.lang.Boolean.getBoolean
object AkkaBuild extends Build {
System.setProperty("akka.mode", "test") // Is there better place for this?
@ -71,6 +72,10 @@ object AkkaBuild extends Build {
extraOptions in MultiJvm <<= (sourceDirectory in MultiJvm) { src =>
(name: String) => (src ** (name + ".conf")).get.headOption.map("-Dakka.config=" + _.absolutePath).toSeq
},
scalatestOptions in MultiJvm := Seq("-r", "org.scalatest.akka.QuietReporter"),
jvmOptions in MultiJvm := Seq("-Xmx256") ++ {
if (getBoolean("sbt.log.noformat")) Seq("-Dakka.test.nocolor=true") else Nil
},
test in Test <<= (test in Test) dependsOn (test in MultiJvm)
)
) configs (MultiJvm)
@ -456,7 +461,7 @@ object Dependency {
val springBeans = "org.springframework" % "spring-beans" % V.Spring // ApacheV2
val springContext = "org.springframework" % "spring-context" % V.Spring // ApacheV2
val staxApi = "javax.xml.stream" % "stax-api" % "1.0-2" // ApacheV2
val twttrUtilCore = "com.twitter" % "util-core" % "1.8.1" // ApacheV2
val twttrUtilCore = "com.twitter" % "util-core" % "1.8.1" // ApacheV2
val zkClient = "zkclient" % "zkclient" % "0.3" // ApacheV2
val zookeeper = "org.apache.hadoop.zookeeper" % "zookeeper" % V.Zookeeper // ApacheV2
val zookeeperLock = "org.apache.hadoop.zookeeper" % "zookeeper-recipes-lock" % V.Zookeeper // ApacheV2

2
project/plugins/build.sbt
View file

@ -1,6 +1,6 @@
resolvers += "Typesafe Repo" at "http://repo.typesafe.com/typesafe/releases/"
libraryDependencies += "com.typesafe.sbt-multi-jvm" %% "sbt-multi-jvm" % "0.1.3"
libraryDependencies += "com.typesafe.sbt-multi-jvm" %% "sbt-multi-jvm" % "0.1.4"
libraryDependencies += "com.typesafe.sbt-scalariform" %% "sbt-scalariform" % "0.1.2"