diff --git a/akka-camel/src/test/java/se/scalablesolutions/akka/camel/PojoBase.java b/akka-camel/src/test/java/se/scalablesolutions/akka/camel/PojoBase.java index 05bf1625bbf..7a9b5c95cc1 100644 --- a/akka-camel/src/test/java/se/scalablesolutions/akka/camel/PojoBase.java +++ b/akka-camel/src/test/java/se/scalablesolutions/akka/camel/PojoBase.java @@ -4,11 +4,12 @@ import org.apache.camel.Header; import se.scalablesolutions.akka.actor.annotation.consume; +import se.scalablesolutions.akka.actor.*; /** * @author Martin Krasser */ -public class PojoBase { +public class PojoBase extends TypedActor implements PojoBaseIntf { public String m1(String b, String h) { return "m1base: " + b + " " + h; diff --git a/akka-camel/src/test/java/se/scalablesolutions/akka/camel/PojoBaseIntf.java b/akka-camel/src/test/java/se/scalablesolutions/akka/camel/PojoBaseIntf.java new file mode 100644 index 00000000000..2ca8ef43602 --- /dev/null +++ b/akka-camel/src/test/java/se/scalablesolutions/akka/camel/PojoBaseIntf.java @@ -0,0 +1,21 @@ +package se.scalablesolutions.akka.camel; + +import org.apache.camel.Body; +import org.apache.camel.Header; + +import se.scalablesolutions.akka.actor.annotation.consume; + +/** + * @author Martin Krasser + */ +public interface PojoBaseIntf { + + public String m1(String b, String h); + @consume("direct:m2base") + public String m2(@Body String b, @Header("test") String h); + @consume("direct:m3base") + public String m3(@Body String b, @Header("test") String h); + @consume("direct:m4base") + public String m4(@Body String b, @Header("test") String h); + public void m5(@Body String b, @Header("test") String h); +} diff --git a/akka-camel/src/test/java/se/scalablesolutions/akka/camel/PojoImpl.java b/akka-camel/src/test/java/se/scalablesolutions/akka/camel/PojoImpl.java index b48202d4dc7..f26719585e0 100644 --- a/akka-camel/src/test/java/se/scalablesolutions/akka/camel/PojoImpl.java +++ b/akka-camel/src/test/java/se/scalablesolutions/akka/camel/PojoImpl.java @@ -4,11 +4,12 @@ import org.apache.camel.Header; import se.scalablesolutions.akka.actor.annotation.consume; +import se.scalablesolutions.akka.actor.*; /** * @author Martin Krasser */ -public class PojoImpl implements PojoIntf { +public class PojoImpl extends TypedActor implements PojoIntf { public String m1(String b, String h) { return "m1impl: " + b + " " + h; diff --git a/akka-camel/src/test/java/se/scalablesolutions/akka/camel/Pojo.java b/akka-camel/src/test/java/se/scalablesolutions/akka/camel/PojoNonConsumer.java similarity index 56% rename from akka-camel/src/test/java/se/scalablesolutions/akka/camel/Pojo.java rename to akka-camel/src/test/java/se/scalablesolutions/akka/camel/PojoNonConsumer.java index d1848c49eec..fc6ea834fdf 100644 --- a/akka-camel/src/test/java/se/scalablesolutions/akka/camel/Pojo.java +++ b/akka-camel/src/test/java/se/scalablesolutions/akka/camel/PojoNonConsumer.java @@ -1,11 +1,11 @@ package se.scalablesolutions.akka.camel; -import se.scalablesolutions.akka.actor.annotation.consume; +import se.scalablesolutions.akka.actor.*; /** * @author Martin Krasser */ -public class Pojo { +public class PojoNonConsumer extends TypedActor implements PojoNonConsumerIntf { public String foo(String s) { return String.format("foo: %s", s); diff --git a/akka-camel/src/test/java/se/scalablesolutions/akka/camel/PojoNonConsumerIntf.java b/akka-camel/src/test/java/se/scalablesolutions/akka/camel/PojoNonConsumerIntf.java new file mode 100644 index 00000000000..aec8caaf191 --- /dev/null +++ b/akka-camel/src/test/java/se/scalablesolutions/akka/camel/PojoNonConsumerIntf.java @@ -0,0 +1,9 @@ +package se.scalablesolutions.akka.camel; + +/** + * @author Martin Krasser + */ +public interface PojoNonConsumerIntf { + + public String foo(String s); +} \ No newline at end of file diff --git a/akka-camel/src/test/java/se/scalablesolutions/akka/camel/PojoRemote.java b/akka-camel/src/test/java/se/scalablesolutions/akka/camel/PojoRemote.java index e9d3377581b..61ea4d7a17e 100644 --- a/akka-camel/src/test/java/se/scalablesolutions/akka/camel/PojoRemote.java +++ b/akka-camel/src/test/java/se/scalablesolutions/akka/camel/PojoRemote.java @@ -1,11 +1,12 @@ package se.scalablesolutions.akka.camel; import se.scalablesolutions.akka.actor.annotation.consume; +import se.scalablesolutions.akka.actor.*; /** * @author Martin Krasser */ -public class PojoRemote { +public class PojoRemote extends TypedActor implements PojoRemoteIntf { @consume("direct:remote-active-object") public String foo(String s) { diff --git a/akka-camel/src/test/java/se/scalablesolutions/akka/camel/PojoRemoteIntf.java b/akka-camel/src/test/java/se/scalablesolutions/akka/camel/PojoRemoteIntf.java new file mode 100644 index 00000000000..639a440598f --- /dev/null +++ b/akka-camel/src/test/java/se/scalablesolutions/akka/camel/PojoRemoteIntf.java @@ -0,0 +1,12 @@ +package se.scalablesolutions.akka.camel; + +import se.scalablesolutions.akka.actor.annotation.consume; + +/** + * @author Martin Krasser + */ +public interface PojoRemoteIntf { + + @consume("direct:remote-active-object") + public String foo(String s); +} diff --git a/akka-camel/src/test/java/se/scalablesolutions/akka/camel/PojoSingle.java b/akka-camel/src/test/java/se/scalablesolutions/akka/camel/PojoSingle.java index 7d577535b26..d4cbe1aabed 100644 --- a/akka-camel/src/test/java/se/scalablesolutions/akka/camel/PojoSingle.java +++ b/akka-camel/src/test/java/se/scalablesolutions/akka/camel/PojoSingle.java @@ -1,11 +1,12 @@ package se.scalablesolutions.akka.camel; import se.scalablesolutions.akka.actor.annotation.consume; +import se.scalablesolutions.akka.actor.*; /** * @author Martin Krasser */ -public class PojoSingle { +public class PojoSingle extends TypedActor implements PojoSingleIntf { @consume("direct:foo") public void foo(String b) { diff --git a/akka-camel/src/test/java/se/scalablesolutions/akka/camel/PojoSingleIntf.java b/akka-camel/src/test/java/se/scalablesolutions/akka/camel/PojoSingleIntf.java new file mode 100644 index 00000000000..22a25325a3b --- /dev/null +++ b/akka-camel/src/test/java/se/scalablesolutions/akka/camel/PojoSingleIntf.java @@ -0,0 +1,12 @@ +package se.scalablesolutions.akka.camel; + +import se.scalablesolutions.akka.actor.annotation.consume; + +/** + * @author Martin Krasser + */ +public interface PojoSingleIntf { + + @consume("direct:foo") + public void foo(String b); +} diff --git a/akka-camel/src/test/java/se/scalablesolutions/akka/camel/PojoSub.java b/akka-camel/src/test/java/se/scalablesolutions/akka/camel/PojoSub.java index be5b4536983..24caf373488 100644 --- a/akka-camel/src/test/java/se/scalablesolutions/akka/camel/PojoSub.java +++ b/akka-camel/src/test/java/se/scalablesolutions/akka/camel/PojoSub.java @@ -4,8 +4,9 @@ import org.apache.camel.Header; import se.scalablesolutions.akka.actor.annotation.consume; +import se.scalablesolutions.akka.actor.*; -public class PojoSub extends PojoBase { +public class PojoSub extends PojoBase implements PojoSubIntf { @Override @consume("direct:m1sub") diff --git a/akka-camel/src/test/java/se/scalablesolutions/akka/camel/PojoSubIntf.java b/akka-camel/src/test/java/se/scalablesolutions/akka/camel/PojoSubIntf.java new file mode 100644 index 00000000000..08a153b1242 --- /dev/null +++ b/akka-camel/src/test/java/se/scalablesolutions/akka/camel/PojoSubIntf.java @@ -0,0 +1,18 @@ +package se.scalablesolutions.akka.camel; + +import org.apache.camel.Body; +import org.apache.camel.Header; + +import se.scalablesolutions.akka.actor.annotation.consume; + +public interface PojoSubIntf extends PojoBaseIntf { + @consume("direct:m1sub") + public String m1(@Body String b, @Header("test") String h); + + @Override + public String m2(String b, String h); + + @Override + @consume("direct:m3sub") + public String m3(@Body String b, @Header("test") String h); +} diff --git a/akka-camel/src/test/scala/CamelServiceFeatureTest.scala b/akka-camel/src/test/scala/CamelServiceFeatureTest.scala index c6c04531e31..cd525115176 100644 --- a/akka-camel/src/test/scala/CamelServiceFeatureTest.scala +++ b/akka-camel/src/test/scala/CamelServiceFeatureTest.scala @@ -122,7 +122,7 @@ class CamelServiceFeatureTest extends FeatureSpec with BeforeAndAfterAll with Gi given("an typed actor registered after CamelService startup") var latch = service.expectEndpointActivationCount(3) - val obj = TypedActor.newInstance(classOf[PojoBase]) + val obj = TypedActor.newInstance(classOf[PojoBaseIntf], classOf[PojoBase]) assert(latch.await(5000, TimeUnit.MILLISECONDS)) when("requests are sent to published methods") @@ -148,7 +148,7 @@ class CamelServiceFeatureTest extends FeatureSpec with BeforeAndAfterAll with Gi given("an typed actor registered after CamelService startup") var latch = service.expectEndpointActivationCount(3) - val obj = TypedActor.newInstance(classOf[PojoBase]) + val obj = TypedActor.newInstance(classOf[PojoBaseIntf], classOf[PojoBase]) assert(latch.await(5000, TimeUnit.MILLISECONDS)) when("the typed actor is stopped") diff --git a/akka-camel/src/test/scala/ConsumerMethodRegisteredTest.scala b/akka-camel/src/test/scala/ConsumerMethodRegisteredTest.scala index 41051b9335f..964fe8e7bf3 100644 --- a/akka-camel/src/test/scala/ConsumerMethodRegisteredTest.scala +++ b/akka-camel/src/test/scala/ConsumerMethodRegisteredTest.scala @@ -12,8 +12,8 @@ class ConsumerMethodRegisteredTest extends JUnitSuite { import ConsumerMethodRegisteredTest._ val remoteAddress = new InetSocketAddress("localhost", 8888); - val remoteAspectInit = AspectInit(classOf[String], null, Some(remoteAddress), 1000) - val localAspectInit = AspectInit(classOf[String], null, None, 1000) + val remoteAspectInit = AspectInit(classOf[String], null, null, Some(remoteAddress), 1000) + val localAspectInit = AspectInit(classOf[String], null, null, None, 1000) val ascendingMethodName = (r1: ConsumerMethodRegistered, r2: ConsumerMethodRegistered) => r1.method.getName < r2.method.getName @@ -44,9 +44,9 @@ class ConsumerMethodRegisteredTest extends JUnitSuite { } object ConsumerMethodRegisteredTest { - val activePojoBase = TypedActor.newInstance(classOf[PojoBase]) - val activePojoSub = TypedActor.newInstance(classOf[PojoSub]) - val activePojoIntf = TypedActor.newInstance(classOf[PojoIntf], new PojoImpl) + val activePojoBase = TypedActor.newInstance(classOf[PojoBaseIntf], classOf[PojoBase]) + val activePojoSub = TypedActor.newInstance(classOf[PojoSubIntf], classOf[PojoSub]) + val activePojoIntf = TypedActor.newInstance(classOf[PojoIntf], classOf[PojoImpl]) @AfterClass def afterClass = { diff --git a/akka-camel/src/test/scala/PublishRequestorTest.scala b/akka-camel/src/test/scala/PublishRequestorTest.scala index 7ce8ef9c811..984f8568756 100644 --- a/akka-camel/src/test/scala/PublishRequestorTest.scala +++ b/akka-camel/src/test/scala/PublishRequestorTest.scala @@ -32,8 +32,8 @@ class PublishRequestorTest extends JUnitSuite { } @Test def shouldReceiveConsumerMethodRegisteredEvent = { - val obj = TypedActor.newInstance(classOf[PojoSingle]) - val init = AspectInit(classOf[PojoSingle], null, None, 1000) + val obj = TypedActor.newInstance(classOf[PojoSingleIntf], classOf[PojoSingle]) + val init = AspectInit(classOf[PojoSingleIntf], null, null, None, 1000) val latch = (publisher !! SetExpectedTestMessageCount(1)).as[CountDownLatch].get requestor ! AspectInitRegistered(obj, init) assert(latch.await(5000, TimeUnit.MILLISECONDS)) @@ -45,8 +45,8 @@ class PublishRequestorTest extends JUnitSuite { } @Test def shouldReceiveConsumerMethodUnregisteredEvent = { - val obj = TypedActor.newInstance(classOf[PojoSingle]) - val init = AspectInit(classOf[PojoSingle], null, None, 1000) + val obj = TypedActor.newInstance(classOf[PojoSingleIntf], classOf[PojoSingle]) + val init = AspectInit(classOf[PojoSingleIntf], null, null, None, 1000) val latch = (publisher !! SetExpectedTestMessageCount(1)).as[CountDownLatch].get requestor ! AspectInitUnregistered(obj, init) assert(latch.await(5000, TimeUnit.MILLISECONDS)) diff --git a/akka-camel/src/test/scala/RemoteConsumerTest.scala b/akka-camel/src/test/scala/RemoteConsumerTest.scala index 08f116bdda5..3f0770127fb 100644 --- a/akka-camel/src/test/scala/RemoteConsumerTest.scala +++ b/akka-camel/src/test/scala/RemoteConsumerTest.scala @@ -58,7 +58,7 @@ class RemoteConsumerTest extends FeatureSpec with BeforeAndAfterAll with GivenWh feature("Client-initiated remote consumer typed actor") { scenario("access published remote consumer method") { given("a client-initiated remote consumer typed actor") - val consumer = TypedActor.newRemoteInstance(classOf[PojoRemote], host, port) + val consumer = TypedActor.newRemoteInstance(classOf[PojoRemoteIntf], classOf[PojoRemote], host, port) when("remote consumer publication is triggered") var latch = service.expectEndpointActivationCount(1) diff --git a/akka-camel/src/test/scala/component/ActiveObjectComponentFeatureTest.scala b/akka-camel/src/test/scala/component/TypedActorComponentFeatureTest.scala similarity index 95% rename from akka-camel/src/test/scala/component/ActiveObjectComponentFeatureTest.scala rename to akka-camel/src/test/scala/component/TypedActorComponentFeatureTest.scala index 79a35297dfc..4a2c4e8e282 100644 --- a/akka-camel/src/test/scala/component/ActiveObjectComponentFeatureTest.scala +++ b/akka-camel/src/test/scala/component/TypedActorComponentFeatureTest.scala @@ -17,9 +17,9 @@ class TypedActorComponentFeatureTest extends FeatureSpec with BeforeAndAfterAll import CamelContextManager.template override protected def beforeAll = { - val activePojo = TypedActor.newInstance(classOf[Pojo]) // not a consumer - val activePojoBase = TypedActor.newInstance(classOf[PojoBase]) - val activePojoIntf = TypedActor.newInstance(classOf[PojoIntf], new PojoImpl) + val activePojo = TypedActor.newInstance(classOf[PojoNonConsumerIntf], classOf[PojoNonConsumer]) // not a consumer + val activePojoBase = TypedActor.newInstance(classOf[PojoBaseIntf], classOf[PojoBase]) + val activePojoIntf = TypedActor.newInstance(classOf[PojoIntf], classOf[PojoImpl]) val registry = new SimpleRegistry registry.put("pojo", activePojo) diff --git a/akka-core/src/main/scala/actor/TypedActor.scala b/akka-core/src/main/scala/actor/TypedActor.scala index bd5235242bd..a40a3d6adf2 100644 --- a/akka-core/src/main/scala/actor/TypedActor.scala +++ b/akka-core/src/main/scala/actor/TypedActor.scala @@ -385,8 +385,15 @@ object TypedActor extends Logging { private[akka] def newTypedActor(targetClass: Class[_]): TypedActor = { val instance = targetClass.newInstance - if (instance.isInstanceOf[TypedActor]) instance.asInstanceOf[TypedActor] - else throw new IllegalArgumentException("Actor [" + targetClass.getName + "] is not a sub class of 'TypedActor'") + val typedActor = + if (instance.isInstanceOf[TypedActor]) instance.asInstanceOf[TypedActor] + else throw new IllegalArgumentException("Actor [" + targetClass.getName + "] is not a sub class of 'TypedActor'") + typedActor.init + import se.scalablesolutions.akka.stm.local.atomic + atomic { + typedActor.initTransactionalState + } + typedActor } private[akka] def supervise(restartStrategy: RestartStrategy, components: List[Supervise]): Supervisor = diff --git a/akka-core/src/test/java/se/scalablesolutions/akka/actor/NestedTransactionalTypedActor.java b/akka-core/src/test/java/se/scalablesolutions/akka/actor/NestedTransactionalTypedActor.java index fa13417f8b5..ee7998f69a4 100644 --- a/akka-core/src/test/java/se/scalablesolutions/akka/actor/NestedTransactionalTypedActor.java +++ b/akka-core/src/test/java/se/scalablesolutions/akka/actor/NestedTransactionalTypedActor.java @@ -1,86 +1,12 @@ package se.scalablesolutions.akka.actor; -import se.scalablesolutions.akka.actor.annotation.transactionrequired; -import se.scalablesolutions.akka.actor.annotation.inittransactionalstate; -import se.scalablesolutions.akka.stm.*; - -@transactionrequired -public class NestedTransactionalTypedActor { - private TransactionalMap mapState; - private TransactionalVector vectorState; - private Ref refState; - private boolean isInitialized = false; - - @inittransactionalstate - public void init() { - if (!isInitialized) { - mapState = new TransactionalMap(); - vectorState = new TransactionalVector(); - refState = new Ref(); - isInitialized = true; - } - } - - public String getMapState(String key) { - return (String) mapState.get(key).get(); - } - - - public String getVectorState() { - return (String) vectorState.last(); - } - - - public String getRefState() { - return (String) refState.get().get(); - } - - - public void setMapState(String key, String msg) { - mapState.put(key, msg); - } - - - public void setVectorState(String msg) { - vectorState.add(msg); - } - - - public void setRefState(String msg) { - refState.swap(msg); - } - - - public void success(String key, String msg) { - mapState.put(key, msg); - vectorState.add(msg); - refState.swap(msg); - } - - - public String failure(String key, String msg, TypedActorFailer failer) { - mapState.put(key, msg); - vectorState.add(msg); - refState.swap(msg); - failer.fail(); - return msg; - } - - - public void thisMethodHangs(String key, String msg, TypedActorFailer failer) { - setMapState(key, msg); - } - - /* - public void clashOk(String key, String msg, InMemClasher clasher) { - mapState.put(key, msg); - clasher.clash(); - } - - public void clashNotOk(String key, String msg, InMemClasher clasher) { - mapState.put(key, msg); - clasher.clash(); - this.success("clash", "clash"); - } - */ +public interface NestedTransactionalTypedActor { + public String getMapState(String key); + public String getVectorState(); + public String getRefState(); + public void setMapState(String key, String msg); + public void setVectorState(String msg); + public void setRefState(String msg); + public void success(String key, String msg); + public String failure(String key, String msg, TypedActorFailer failer); } \ No newline at end of file diff --git a/akka-core/src/test/java/se/scalablesolutions/akka/actor/NestedTransactionalTypedActorImpl.java b/akka-core/src/test/java/se/scalablesolutions/akka/actor/NestedTransactionalTypedActorImpl.java new file mode 100644 index 00000000000..699f33785d4 --- /dev/null +++ b/akka-core/src/test/java/se/scalablesolutions/akka/actor/NestedTransactionalTypedActorImpl.java @@ -0,0 +1,59 @@ +package se.scalablesolutions.akka.actor; + +import se.scalablesolutions.akka.actor.*; +import se.scalablesolutions.akka.stm.*; + +public class NestedTransactionalTypedActorImpl extends TypedTransactor implements NestedTransactionalTypedActor { + private TransactionalMap mapState; + private TransactionalVector vectorState; + private Ref refState; + private boolean isInitialized = false; + + @Override + public void init() { + if (!isInitialized) { + mapState = new TransactionalMap(); + vectorState = new TransactionalVector(); + refState = new Ref(); + isInitialized = true; + } + } + + public String getMapState(String key) { + return (String) mapState.get(key).get(); + } + + public String getVectorState() { + return (String) vectorState.last(); + } + + public String getRefState() { + return (String) refState.get().get(); + } + + public void setMapState(String key, String msg) { + mapState.put(key, msg); + } + + public void setVectorState(String msg) { + vectorState.add(msg); + } + + public void setRefState(String msg) { + refState.swap(msg); + } + + public void success(String key, String msg) { + mapState.put(key, msg); + vectorState.add(msg); + refState.swap(msg); + } + + public String failure(String key, String msg, TypedActorFailer failer) { + mapState.put(key, msg); + vectorState.add(msg); + refState.swap(msg); + failer.fail(); + return msg; + } +} \ No newline at end of file diff --git a/akka-core/src/test/java/se/scalablesolutions/akka/actor/SamplePojo.java b/akka-core/src/test/java/se/scalablesolutions/akka/actor/SamplePojo.java index 50f3e432216..715953152ec 100644 --- a/akka-core/src/test/java/se/scalablesolutions/akka/actor/SamplePojo.java +++ b/akka-core/src/test/java/se/scalablesolutions/akka/actor/SamplePojo.java @@ -2,36 +2,11 @@ import java.util.concurrent.CountDownLatch; -public class SamplePojo { - - private CountDownLatch latch; - - public boolean _pre = false; - public boolean _post = false; - public boolean _down = false; - - public CountDownLatch newCountdownLatch(int count) { - latch = new CountDownLatch(count); - return latch; - } - - public String fail() { - throw new RuntimeException("expected"); - } - - public void pre() { - _pre = true; - latch.countDown(); - } - - public void post() { - _post = true; - latch.countDown(); - } - - public void down() { - _down = true; - latch.countDown(); - } - -} +public interface SamplePojo { + public boolean pre(); + public boolean post(); + public boolean down(); + public CountDownLatch newCountdownLatch(int count); + public String greet(String s); + public String fail(); +} \ No newline at end of file diff --git a/akka-core/src/test/java/se/scalablesolutions/akka/actor/SamplePojoAnnotated.java b/akka-core/src/test/java/se/scalablesolutions/akka/actor/SamplePojoImpl.java similarity index 52% rename from akka-core/src/test/java/se/scalablesolutions/akka/actor/SamplePojoAnnotated.java rename to akka-core/src/test/java/se/scalablesolutions/akka/actor/SamplePojoImpl.java index 8bf4ba36d3d..da241484e27 100644 --- a/akka-core/src/test/java/se/scalablesolutions/akka/actor/SamplePojoAnnotated.java +++ b/akka-core/src/test/java/se/scalablesolutions/akka/actor/SamplePojoImpl.java @@ -1,12 +1,10 @@ package se.scalablesolutions.akka.actor; -import se.scalablesolutions.akka.actor.annotation.postrestart; -import se.scalablesolutions.akka.actor.annotation.prerestart; -import se.scalablesolutions.akka.actor.annotation.shutdown; +import se.scalablesolutions.akka.actor.*; import java.util.concurrent.CountDownLatch; -public class SamplePojoAnnotated { +public class SamplePojoImpl extends TypedActor implements SamplePojo { private CountDownLatch latch; @@ -14,7 +12,7 @@ public class SamplePojoAnnotated { public boolean _post = false; public boolean _down = false; - public SamplePojoAnnotated() { + public SamplePojoImpl() { latch = new CountDownLatch(1); } @@ -23,6 +21,18 @@ public CountDownLatch newCountdownLatch(int count) { return latch; } + public boolean pre() { + return _pre; + } + + public boolean post() { + return _post; + } + + public boolean down() { + return _down; + } + public String greet(String s) { return "hello " + s; } @@ -31,22 +41,21 @@ public String fail() { throw new RuntimeException("expected"); } - @prerestart - public void pre() { - _pre = true; - latch.countDown(); + @Override + public void preRestart(Throwable e) { + _pre = true; + latch.countDown(); } - @postrestart - public void post() { - _post = true; - latch.countDown(); + @Override + public void postRestart(Throwable e) { + _post = true; + latch.countDown(); } - - @shutdown - public void down() { + + @Override + public void shutdown() { _down = true; latch.countDown(); } - } \ No newline at end of file diff --git a/akka-core/src/test/java/se/scalablesolutions/akka/actor/SimpleJavaPojo.java b/akka-core/src/test/java/se/scalablesolutions/akka/actor/SimpleJavaPojo.java index b068af4f128..340afe6f65f 100644 --- a/akka-core/src/test/java/se/scalablesolutions/akka/actor/SimpleJavaPojo.java +++ b/akka-core/src/test/java/se/scalablesolutions/akka/actor/SimpleJavaPojo.java @@ -1,48 +1,13 @@ package se.scalablesolutions.akka.actor; -import se.scalablesolutions.akka.actor.annotation.prerestart; -import se.scalablesolutions.akka.actor.annotation.postrestart; -import se.scalablesolutions.akka.actor.TypedActorContext; import se.scalablesolutions.akka.dispatch.CompletableFuture; -public class SimpleJavaPojo { - - TypedActorContext context; - - public boolean pre = false; - public boolean post = false; - - private String name; - - public Object getSender() { - return context.getSender(); - } - - public CompletableFuture getSenderFuture() { - return context.getSenderFuture(); - } - - public void setName(String name) { - this.name = name; - } - - public String getName() { - return name; - } - - @prerestart - public void pre() { - System.out.println("** pre()"); - pre = true; - } - - @postrestart - public void post() { - System.out.println("** post()"); - post = true; - } - - public void throwException() { - throw new RuntimeException(); - } +public interface SimpleJavaPojo { + public Object getSender(); + public CompletableFuture getSenderFuture(); + public void setName(String name); + public String getName(); + public void throwException(); + public boolean pre(); + public boolean post(); } diff --git a/akka-core/src/test/java/se/scalablesolutions/akka/actor/SimpleJavaPojoCaller.java b/akka-core/src/test/java/se/scalablesolutions/akka/actor/SimpleJavaPojoCaller.java index 0fb6aff9c53..a1bdab5337e 100644 --- a/akka-core/src/test/java/se/scalablesolutions/akka/actor/SimpleJavaPojoCaller.java +++ b/akka-core/src/test/java/se/scalablesolutions/akka/actor/SimpleJavaPojoCaller.java @@ -2,19 +2,8 @@ import se.scalablesolutions.akka.dispatch.CompletableFuture; -public class SimpleJavaPojoCaller { - - SimpleJavaPojo pojo; - - public void setPojo(SimpleJavaPojo pojo) { - this.pojo = pojo; - } - - public Object getSenderFromSimpleJavaPojo() { - return pojo.getSender(); - } - - public CompletableFuture getSenderFutureFromSimpleJavaPojo() { - return pojo.getSenderFuture(); - } +public interface SimpleJavaPojoCaller { + public void setPojo(SimpleJavaPojo pojo); + public Object getSenderFromSimpleJavaPojo(); + public CompletableFuture getSenderFutureFromSimpleJavaPojo(); } diff --git a/akka-core/src/test/java/se/scalablesolutions/akka/actor/SimpleJavaPojoCallerImpl.java b/akka-core/src/test/java/se/scalablesolutions/akka/actor/SimpleJavaPojoCallerImpl.java new file mode 100644 index 00000000000..15a6aec8e03 --- /dev/null +++ b/akka-core/src/test/java/se/scalablesolutions/akka/actor/SimpleJavaPojoCallerImpl.java @@ -0,0 +1,21 @@ +package se.scalablesolutions.akka.actor; + +import se.scalablesolutions.akka.actor.*; +import se.scalablesolutions.akka.dispatch.CompletableFuture; + +public class SimpleJavaPojoCallerImpl extends TypedActor implements SimpleJavaPojoCaller { + + SimpleJavaPojo pojo; + + public void setPojo(SimpleJavaPojo pojo) { + this.pojo = pojo; + } + + public Object getSenderFromSimpleJavaPojo() { + return pojo.getSender(); + } + + public CompletableFuture getSenderFutureFromSimpleJavaPojo() { + return pojo.getSenderFuture(); + } +} diff --git a/akka-core/src/test/java/se/scalablesolutions/akka/actor/SimpleJavaPojoImpl.java b/akka-core/src/test/java/se/scalablesolutions/akka/actor/SimpleJavaPojoImpl.java new file mode 100644 index 00000000000..0e2e72ff060 --- /dev/null +++ b/akka-core/src/test/java/se/scalablesolutions/akka/actor/SimpleJavaPojoImpl.java @@ -0,0 +1,52 @@ +package se.scalablesolutions.akka.actor; + +import se.scalablesolutions.akka.actor.*; +import se.scalablesolutions.akka.dispatch.CompletableFuture; + +public class SimpleJavaPojoImpl extends TypedActor implements SimpleJavaPojo { + + public boolean pre = false; + public boolean post = false; + + private String name; + + public boolean pre() { + return pre; + } + + public boolean post() { + return post; + } + + public Object getSender() { + return getContext().getSender(); + } + + public CompletableFuture getSenderFuture() { + return getContext().getSenderFuture(); + } + + public void setName(String name) { + this.name = name; + } + + public String getName() { + return name; + } + + @Override + public void preRestart(Throwable e) { + System.out.println("** pre()"); + pre = true; + } + + @Override + public void postRestart(Throwable e) { + System.out.println("** post()"); + post = true; + } + + public void throwException() { + throw new RuntimeException(); + } +} diff --git a/akka-core/src/test/java/se/scalablesolutions/akka/actor/TransactionalTypedActor.java b/akka-core/src/test/java/se/scalablesolutions/akka/actor/TransactionalTypedActor.java index 222a8c82fac..6e7c43745b3 100644 --- a/akka-core/src/test/java/se/scalablesolutions/akka/actor/TransactionalTypedActor.java +++ b/akka-core/src/test/java/se/scalablesolutions/akka/actor/TransactionalTypedActor.java @@ -1,92 +1,14 @@ package se.scalablesolutions.akka.actor; -import se.scalablesolutions.akka.actor.annotation.transactionrequired; -import se.scalablesolutions.akka.actor.annotation.prerestart; -import se.scalablesolutions.akka.actor.annotation.postrestart; -import se.scalablesolutions.akka.actor.annotation.inittransactionalstate; -import se.scalablesolutions.akka.stm.*; - -@transactionrequired -public class TransactionalTypedActor { - private TransactionalMap mapState; - private TransactionalVector vectorState; - private Ref refState; - private boolean isInitialized = false; - - @inittransactionalstate - public void init() { - if (!isInitialized) { - mapState = new TransactionalMap(); - vectorState = new TransactionalVector(); - refState = new Ref(); - isInitialized = true; - } - } - - public String getMapState(String key) { - return (String)mapState.get(key).get(); - } - - public String getVectorState() { - return (String)vectorState.last(); - } - - public String getRefState() { - return (String)refState.get().get(); - } - - public void setMapState(String key, String msg) { - mapState.put(key, msg); - } - - public void setVectorState(String msg) { - vectorState.add(msg); - } - - public void setRefState(String msg) { - refState.swap(msg); - } - - public void success(String key, String msg) { - mapState.put(key, msg); - vectorState.add(msg); - refState.swap(msg); - } - - public void success(String key, String msg, NestedTransactionalTypedActor nested) { - mapState.put(key, msg); - vectorState.add(msg); - refState.swap(msg); - nested.success(key, msg); - } - - public String failure(String key, String msg, TypedActorFailer failer) { - mapState.put(key, msg); - vectorState.add(msg); - refState.swap(msg); - failer.fail(); - return msg; - } - - public String failure(String key, String msg, NestedTransactionalTypedActor nested, TypedActorFailer failer) { - mapState.put(key, msg); - vectorState.add(msg); - refState.swap(msg); - nested.failure(key, msg, failer); - return msg; - } - - public void thisMethodHangs(String key, String msg, TypedActorFailer failer) { - setMapState(key, msg); - } - - @prerestart - public void preRestart() { - System.out.println("################ PRE RESTART"); - } - - @postrestart - public void postRestart() { - System.out.println("################ POST RESTART"); - } +public interface TransactionalTypedActor { + public String getMapState(String key); + public String getVectorState(); + public String getRefState(); + public void setMapState(String key, String msg); + public void setVectorState(String msg); + public void setRefState(String msg); + public void success(String key, String msg); + public void success(String key, String msg, NestedTransactionalTypedActor nested); + public String failure(String key, String msg, TypedActorFailer failer); + public String failure(String key, String msg, NestedTransactionalTypedActor nested, TypedActorFailer failer); } diff --git a/akka-core/src/test/java/se/scalablesolutions/akka/actor/TransactionalTypedActorImpl.java b/akka-core/src/test/java/se/scalablesolutions/akka/actor/TransactionalTypedActorImpl.java new file mode 100644 index 00000000000..ddaf2fb47df --- /dev/null +++ b/akka-core/src/test/java/se/scalablesolutions/akka/actor/TransactionalTypedActorImpl.java @@ -0,0 +1,84 @@ +package se.scalablesolutions.akka.actor; + +import se.scalablesolutions.akka.actor.*; +import se.scalablesolutions.akka.stm.*; + +public class TransactionalTypedActorImpl extends TypedTransactor implements TransactionalTypedActor { + private TransactionalMap mapState; + private TransactionalVector vectorState; + private Ref refState; + private boolean isInitialized = false; + + @Override + public void initTransactionalState() { + if (!isInitialized) { + mapState = new TransactionalMap(); + vectorState = new TransactionalVector(); + refState = new Ref(); + isInitialized = true; + } + } + + public String getMapState(String key) { + return (String)mapState.get(key).get(); + } + + public String getVectorState() { + return (String)vectorState.last(); + } + + public String getRefState() { + return (String)refState.get().get(); + } + + public void setMapState(String key, String msg) { + mapState.put(key, msg); + } + + public void setVectorState(String msg) { + vectorState.add(msg); + } + + public void setRefState(String msg) { + refState.swap(msg); + } + + public void success(String key, String msg) { + mapState.put(key, msg); + vectorState.add(msg); + refState.swap(msg); + } + + public void success(String key, String msg, NestedTransactionalTypedActor nested) { + mapState.put(key, msg); + vectorState.add(msg); + refState.swap(msg); + nested.success(key, msg); + } + + public String failure(String key, String msg, TypedActorFailer failer) { + mapState.put(key, msg); + vectorState.add(msg); + refState.swap(msg); + failer.fail(); + return msg; + } + + public String failure(String key, String msg, NestedTransactionalTypedActor nested, TypedActorFailer failer) { + mapState.put(key, msg); + vectorState.add(msg); + refState.swap(msg); + nested.failure(key, msg, failer); + return msg; + } + + @Override + public void preRestart(Throwable e) { + System.out.println("################ PRE RESTART"); + } + + @Override + public void postRestart(Throwable e) { + System.out.println("################ POST RESTART"); + } +} diff --git a/akka-core/src/test/java/se/scalablesolutions/akka/actor/TypedAcotrFailer.java b/akka-core/src/test/java/se/scalablesolutions/akka/actor/TypedAcotrFailer.java deleted file mode 100644 index 311e9595270..00000000000 --- a/akka-core/src/test/java/se/scalablesolutions/akka/actor/TypedAcotrFailer.java +++ /dev/null @@ -1,7 +0,0 @@ -package se.scalablesolutions.akka.actor; - -public class TypedActorFailer implements java.io.Serializable { - public int fail() { - throw new RuntimeException("expected"); - } -} diff --git a/akka-core/src/test/java/se/scalablesolutions/akka/actor/TypedActorFailer.java b/akka-core/src/test/java/se/scalablesolutions/akka/actor/TypedActorFailer.java new file mode 100644 index 00000000000..b4a69e1cd12 --- /dev/null +++ b/akka-core/src/test/java/se/scalablesolutions/akka/actor/TypedActorFailer.java @@ -0,0 +1,5 @@ +package se.scalablesolutions.akka.actor; + +public interface TypedActorFailer extends java.io.Serializable { + public int fail(); +} diff --git a/akka-core/src/test/java/se/scalablesolutions/akka/actor/TypedActorFailerImpl.java b/akka-core/src/test/java/se/scalablesolutions/akka/actor/TypedActorFailerImpl.java new file mode 100644 index 00000000000..0d01fd801c4 --- /dev/null +++ b/akka-core/src/test/java/se/scalablesolutions/akka/actor/TypedActorFailerImpl.java @@ -0,0 +1,9 @@ +package se.scalablesolutions.akka.actor; + +import se.scalablesolutions.akka.actor.*; + +public class TypedActorFailerImpl extends TypedActor implements TypedActorFailer { + public int fail() { + throw new RuntimeException("expected"); + } +} diff --git a/akka-core/src/test/scala/NestedTransactionalActiveObjectSpec.scala b/akka-core/src/test/scala/NestedTransactionalActiveObjectSpec.scala index c1dde6a582d..e0c59800bc1 100644 --- a/akka-core/src/test/scala/NestedTransactionalActiveObjectSpec.scala +++ b/akka-core/src/test/scala/NestedTransactionalActiveObjectSpec.scala @@ -28,11 +28,9 @@ class NestedTransactionalTypedActorSpec extends describe("Declaratively nested supervised transactional in-memory TypedActor") { it("map should not rollback state for stateful server in case of success") { - val stateful = TypedActor.newInstance(classOf[TransactionalTypedActor]) - stateful.init + val stateful = TypedActor.newInstance(classOf[TransactionalTypedActor], classOf[TransactionalTypedActorImpl]) stateful.setMapState("testShouldNotRollbackStateForStatefulServerInCaseOfSuccess", "init") // set init state - val nested = TypedActor.newInstance(classOf[NestedTransactionalTypedActor]) - nested.init + val nested = TypedActor.newInstance(classOf[NestedTransactionalTypedActor], classOf[NestedTransactionalTypedActorImpl]) nested.setMapState("testShouldNotRollbackStateForStatefulServerInCaseOfSuccess", "init") // set init state stateful.success("testShouldNotRollbackStateForStatefulServerInCaseOfSuccess", "new state", nested) // transactionrequired stateful.getMapState("testShouldNotRollbackStateForStatefulServerInCaseOfSuccess") should equal("new state") @@ -40,13 +38,11 @@ class NestedTransactionalTypedActorSpec extends } it("map should rollback state for stateful server in case of failure") { - val stateful = TypedActor.newInstance(classOf[TransactionalTypedActor]) - stateful.init + val stateful = TypedActor.newInstance(classOf[TransactionalTypedActor], classOf[TransactionalTypedActorImpl]) stateful.setMapState("testShouldRollbackStateForStatefulServerInCaseOfFailure", "init") // set init state - val nested = TypedActor.newInstance(classOf[NestedTransactionalTypedActor]) - nested.init + val nested = TypedActor.newInstance(classOf[NestedTransactionalTypedActor], classOf[NestedTransactionalTypedActorImpl]) nested.setMapState("testShouldRollbackStateForStatefulServerInCaseOfFailure", "init") // set init state - val failer = TypedActor.newInstance(classOf[TypedActorFailer]) + val failer = TypedActor.newInstance(classOf[TypedActorFailer], classOf[TypedActorFailerImpl]) try { stateful.failure("testShouldRollbackStateForStatefulServerInCaseOfFailure", "new state", nested, failer) fail("should have thrown an exception") @@ -56,11 +52,9 @@ class NestedTransactionalTypedActorSpec extends } it("vector should not rollback state for stateful server in case of success") { - val stateful = TypedActor.newInstance(classOf[TransactionalTypedActor]) - stateful.init + val stateful = TypedActor.newInstance(classOf[TransactionalTypedActor], classOf[TransactionalTypedActorImpl]) stateful.setVectorState("init") // set init state - val nested = TypedActor.newInstance(classOf[NestedTransactionalTypedActor]) - nested.init + val nested = TypedActor.newInstance(classOf[NestedTransactionalTypedActor], classOf[NestedTransactionalTypedActorImpl]) nested.setVectorState("init") // set init state stateful.success("testShouldNotRollbackStateForStatefulServerInCaseOfSuccess", "new state", nested) // transactionrequired stateful.getVectorState should equal("new state") @@ -68,13 +62,11 @@ class NestedTransactionalTypedActorSpec extends } it("vector should rollback state for stateful server in case of failure") { - val stateful = TypedActor.newInstance(classOf[TransactionalTypedActor]) - stateful.init + val stateful = TypedActor.newInstance(classOf[TransactionalTypedActor], classOf[TransactionalTypedActorImpl]) stateful.setVectorState("init") // set init state - val nested = TypedActor.newInstance(classOf[NestedTransactionalTypedActor]) - nested.init + val nested = TypedActor.newInstance(classOf[NestedTransactionalTypedActor], classOf[NestedTransactionalTypedActorImpl]) nested.setVectorState("init") // set init state - val failer = TypedActor.newInstance(classOf[TypedActorFailer]) + val failer = TypedActor.newInstance(classOf[TypedActorFailer], classOf[TypedActorFailerImpl]) try { stateful.failure("testShouldRollbackStateForStatefulServerInCaseOfFailure", "new state", nested, failer) fail("should have thrown an exception") @@ -84,10 +76,8 @@ class NestedTransactionalTypedActorSpec extends } it("ref should not rollback state for stateful server in case of success") { - val stateful = TypedActor.newInstance(classOf[TransactionalTypedActor]) - stateful.init - val nested = TypedActor.newInstance(classOf[NestedTransactionalTypedActor]) - nested.init + val stateful = TypedActor.newInstance(classOf[TransactionalTypedActor], classOf[TransactionalTypedActorImpl]) + val nested = TypedActor.newInstance(classOf[NestedTransactionalTypedActor], classOf[NestedTransactionalTypedActorImpl]) stateful.setRefState("init") // set init state nested.setRefState("init") // set init state stateful.success("testShouldNotRollbackStateForStatefulServerInCaseOfSuccess", "new state", nested) @@ -96,13 +86,11 @@ class NestedTransactionalTypedActorSpec extends } it("ref should rollback state for stateful server in case of failure") { - val stateful = TypedActor.newInstance(classOf[TransactionalTypedActor]) - stateful.init - val nested = TypedActor.newInstance(classOf[NestedTransactionalTypedActor]) - nested.init + val stateful = TypedActor.newInstance(classOf[TransactionalTypedActor], classOf[TransactionalTypedActorImpl]) + val nested = TypedActor.newInstance(classOf[NestedTransactionalTypedActor], classOf[NestedTransactionalTypedActorImpl]) stateful.setRefState("init") // set init state nested.setRefState("init") // set init state - val failer = TypedActor.newInstance(classOf[TypedActorFailer]) + val failer = TypedActor.newInstance(classOf[TypedActorFailer], classOf[TypedActorFailerImpl]) try { stateful.failure("testShouldRollbackStateForStatefulServerInCaseOfFailure", "new state", nested, failer) fail("should have thrown an exception") diff --git a/akka-core/src/test/scala/TransactionalActiveObjectSpec.scala b/akka-core/src/test/scala/TransactionalActiveObjectSpec.scala index 280c6df652c..e8ac4c3fd7b 100644 --- a/akka-core/src/test/scala/TransactionalActiveObjectSpec.scala +++ b/akka-core/src/test/scala/TransactionalActiveObjectSpec.scala @@ -27,18 +27,16 @@ class TransactionalTypedActorSpec extends describe("Declaratively supervised transactional in-memory Active Object ") { it("map should not rollback state for stateful server in case of success") { - val stateful = TypedActor.newInstance(classOf[TransactionalTypedActor]) - stateful.init + val stateful = TypedActor.newInstance(classOf[TransactionalTypedActor], classOf[TransactionalTypedActorImpl]) stateful.setMapState("testShouldNotRollbackStateForStatefulServerInCaseOfSuccess", "init") stateful.success("testShouldNotRollbackStateForStatefulServerInCaseOfSuccess", "new state") stateful.getMapState("testShouldNotRollbackStateForStatefulServerInCaseOfSuccess") should equal("new state") } it("map should rollback state for stateful server in case of failure") { - val stateful = TypedActor.newInstance(classOf[TransactionalTypedActor]) - stateful.init + val stateful = TypedActor.newInstance(classOf[TransactionalTypedActor], classOf[TransactionalTypedActorImpl]) stateful.setMapState("testShouldRollbackStateForStatefulServerInCaseOfFailure", "init") - val failer = TypedActor.newInstance(classOf[TypedActorFailer]) + val failer = TypedActor.newInstance(classOf[TypedActorFailer], classOf[TypedActorFailerImpl]) try { stateful.failure("testShouldRollbackStateForStatefulServerInCaseOfFailure", "new state", failer) fail("should have thrown an exception") @@ -47,18 +45,16 @@ class TransactionalTypedActorSpec extends } it("vector should not rollback state for stateful server in case of success") { - val stateful = TypedActor.newInstance(classOf[TransactionalTypedActor]) - stateful.init + val stateful = TypedActor.newInstance(classOf[TransactionalTypedActor], classOf[TransactionalTypedActorImpl]) stateful.setVectorState("init") // set init state stateful.success("testShouldNotRollbackStateForStatefulServerInCaseOfSuccess", "new state") stateful.getVectorState should equal("new state") } it("vector should rollback state for stateful server in case of failure") { - val stateful = TypedActor.newInstance(classOf[TransactionalTypedActor]) - stateful.init + val stateful = TypedActor.newInstance(classOf[TransactionalTypedActor], classOf[TransactionalTypedActorImpl]) stateful.setVectorState("init") // set init state - val failer = TypedActor.newInstance(classOf[TypedActorFailer]) + val failer = TypedActor.newInstance(classOf[TypedActorFailer], classOf[TypedActorFailerImpl]) try { stateful.failure("testShouldRollbackStateForStatefulServerInCaseOfFailure", "new state", failer) fail("should have thrown an exception") @@ -67,18 +63,16 @@ class TransactionalTypedActorSpec extends } it("ref should not rollback state for stateful server in case of success") { - val stateful = TypedActor.newInstance(classOf[TransactionalTypedActor]) - stateful.init + val stateful = TypedActor.newInstance(classOf[TransactionalTypedActor], classOf[TransactionalTypedActorImpl]) stateful.setRefState("init") // set init state stateful.success("testShouldNotRollbackStateForStatefulServerInCaseOfSuccess", "new state") stateful.getRefState should equal("new state") } it("ref should rollback state for stateful server in case of failure") { - val stateful = TypedActor.newInstance(classOf[TransactionalTypedActor]) - stateful.init + val stateful = TypedActor.newInstance(classOf[TransactionalTypedActor], classOf[TransactionalTypedActorImpl]) stateful.setRefState("init") // set init state - val failer = TypedActor.newInstance(classOf[TypedActorFailer]) + val failer = TypedActor.newInstance(classOf[TypedActorFailer], classOf[TypedActorFailerImpl]) try { stateful.failure("testShouldRollbackStateForStatefulServerInCaseOfFailure", "new state", failer) fail("should have thrown an exception") diff --git a/akka-core/src/test/scala/TypedActorContextSpec.scala b/akka-core/src/test/scala/TypedActorContextSpec.scala index b83da592061..5c3fb629ad6 100644 --- a/akka-core/src/test/scala/TypedActorContextSpec.scala +++ b/akka-core/src/test/scala/TypedActorContextSpec.scala @@ -21,8 +21,8 @@ class TypedActorContextSpec extends describe("TypedActorContext") { it("context.sender should return the sender TypedActor reference") { - val pojo = TypedActor.newInstance(classOf[SimpleJavaPojo]) - val pojoCaller = TypedActor.newInstance(classOf[SimpleJavaPojoCaller]) + val pojo = TypedActor.newInstance(classOf[SimpleJavaPojo], classOf[SimpleJavaPojoImpl]) + val pojoCaller = TypedActor.newInstance(classOf[SimpleJavaPojoCaller], classOf[SimpleJavaPojoCallerImpl]) pojoCaller.setPojo(pojo) try { pojoCaller.getSenderFromSimpleJavaPojo should equal (pojoCaller) @@ -32,8 +32,8 @@ class TypedActorContextSpec extends } it("context.senderFuture should return the senderFuture TypedActor reference") { - val pojo = TypedActor.newInstance(classOf[SimpleJavaPojo]) - val pojoCaller = TypedActor.newInstance(classOf[SimpleJavaPojoCaller]) + val pojo = TypedActor.newInstance(classOf[SimpleJavaPojo], classOf[SimpleJavaPojoImpl]) + val pojoCaller = TypedActor.newInstance(classOf[SimpleJavaPojoCaller], classOf[SimpleJavaPojoCallerImpl]) pojoCaller.setPojo(pojo) try { pojoCaller.getSenderFutureFromSimpleJavaPojo.getClass.getName should equal (classOf[DefaultCompletableFuture[_]].getName) diff --git a/akka-core/src/test/scala/TypedActorLifecycleSpec.scala b/akka-core/src/test/scala/TypedActorLifecycleSpec.scala index b250e3da377..bf5be693109 100644 --- a/akka-core/src/test/scala/TypedActorLifecycleSpec.scala +++ b/akka-core/src/test/scala/TypedActorLifecycleSpec.scala @@ -22,24 +22,25 @@ class TypedActorLifecycleSpec extends Spec with ShouldMatchers with BeforeAndAft override protected def beforeAll() = { val strategy = new RestartStrategy(new AllForOne(), 3, 1000, Array(classOf[Exception])) - val comp1 = new Component(classOf[SamplePojoAnnotated], new LifeCycle(new Permanent()), 1000) - val comp2 = new Component(classOf[SamplePojoAnnotated], new LifeCycle(new Temporary()), 1000) - val comp3 = new Component(classOf[SamplePojo], new LifeCycle(new Permanent(), new RestartCallbacks("pre", "post")), 1000) - val comp4 = new Component(classOf[SamplePojo], new LifeCycle(new Temporary(), new ShutdownCallback("down")), 1000) - conf1 = new TypedActorConfigurator().configure(strategy, Array(comp1)).supervise - conf2 = new TypedActorConfigurator().configure(strategy, Array(comp2)).supervise +// val comp1 = new Component(classOf[SamplePojoAnnotated], classOf[SamplePojoAnnotatedImpl], new LifeCycle(new Permanent()), 1000) +// val comp2 = new Component(classOf[SamplePojoAnnotated], classOf[SamplePojoAnnotatedImpl], new LifeCycle(new Temporary()), 1000) + val comp3 = new Component(classOf[SamplePojo], classOf[SamplePojoImpl], new LifeCycle(new Permanent(), new RestartCallbacks("pre", "post")), 1000) + val comp4 = new Component(classOf[SamplePojo], classOf[SamplePojoImpl], new LifeCycle(new Temporary(), new ShutdownCallback("down")), 1000) +// conf1 = new TypedActorConfigurator().configure(strategy, Array(comp1)).supervise +// conf2 = new TypedActorConfigurator().configure(strategy, Array(comp2)).supervise conf3 = new TypedActorConfigurator().configure(strategy, Array(comp3)).supervise conf4 = new TypedActorConfigurator().configure(strategy, Array(comp4)).supervise } override protected def afterAll() = { - conf1.stop - conf2.stop +// conf1.stop +// conf2.stop conf3.stop conf4.stop } describe("TypedActor lifecycle management") { + /* it("should restart supervised, annotated typed actor on failure") { val obj = conf1.getInstance[SamplePojoAnnotated](classOf[SamplePojoAnnotated]) val cdl = obj.newCountdownLatch(2) @@ -50,9 +51,9 @@ class TypedActorLifecycleSpec extends Spec with ShouldMatchers with BeforeAndAft } catch { case e: RuntimeException => { cdl.await - assert(obj._pre) - assert(obj._post) - assert(!obj._down) + assert(obj.pre) + assert(obj.post) + assert(!obj.down) assert(AspectInitRegistry.initFor(obj) ne null) } } @@ -68,14 +69,14 @@ class TypedActorLifecycleSpec extends Spec with ShouldMatchers with BeforeAndAft } catch { case e: RuntimeException => { cdl.await - assert(!obj._pre) - assert(!obj._post) - assert(obj._down) + assert(!obj.pre) + assert(!obj.post) + assert(obj.down) assert(AspectInitRegistry.initFor(obj) eq null) } } } - +*/ it("should restart supervised, non-annotated typed actor on failure") { val obj = conf3.getInstance[SamplePojo](classOf[SamplePojo]) val cdl = obj.newCountdownLatch(2) @@ -86,9 +87,9 @@ class TypedActorLifecycleSpec extends Spec with ShouldMatchers with BeforeAndAft } catch { case e: RuntimeException => { cdl.await - assert(obj._pre) - assert(obj._post) - assert(!obj._down) + assert(obj.pre) + assert(obj.post) + assert(!obj.down) assert(AspectInitRegistry.initFor(obj) ne null) } } @@ -104,28 +105,28 @@ class TypedActorLifecycleSpec extends Spec with ShouldMatchers with BeforeAndAft } catch { case e: RuntimeException => { cdl.await - assert(!obj._pre) - assert(!obj._post) - assert(obj._down) + assert(!obj.pre) + assert(!obj.post) + assert(obj.down) assert(AspectInitRegistry.initFor(obj) eq null) } } } - +/* it("should shutdown non-supervised, annotated typed actor on TypedActor.stop") { val obj = TypedActor.newInstance(classOf[SamplePojoAnnotated]) assert(AspectInitRegistry.initFor(obj) ne null) assert("hello akka" === obj.greet("akka")) TypedActor.stop(obj) assert(AspectInitRegistry.initFor(obj) eq null) - assert(!obj._pre) - assert(!obj._post) - assert(obj._down) + assert(!obj.pre) + assert(!obj.post) + assert(obj.down) try { obj.greet("akka") fail("access to stopped typed actor") } catch { - case e: Exception => { /* test passed */ } + case e: Exception => {} } } @@ -135,9 +136,9 @@ class TypedActorLifecycleSpec extends Spec with ShouldMatchers with BeforeAndAft assert("hello akka" === obj.greet("akka")) ActorRegistry.shutdownAll assert(AspectInitRegistry.initFor(obj) eq null) - assert(!obj._pre) - assert(!obj._post) - assert(obj._down) + assert(!obj.pre) + assert(!obj.post) + assert(obj.down) try { obj.greet("akka") fail("access to stopped typed actor") @@ -145,18 +146,19 @@ class TypedActorLifecycleSpec extends Spec with ShouldMatchers with BeforeAndAft case e: Exception => { /* test passed */ } } } + */ it("should shutdown non-supervised, non-initialized typed actor on TypedActor.stop") { - val obj = TypedActor.newInstance(classOf[SamplePojoAnnotated]) + val obj = TypedActor.newInstance(classOf[SamplePojo], classOf[SamplePojoImpl]) TypedActor.stop(obj) - assert(!obj._pre) - assert(!obj._post) - assert(obj._down) + assert(!obj.pre) + assert(!obj.post) + assert(obj.down) } it("both preRestart and postRestart methods should be invoked when an actor is restarted") { - val pojo = TypedActor.newInstance(classOf[SimpleJavaPojo]) - val supervisor = TypedActor.newInstance(classOf[SimpleJavaPojo]) + val pojo = TypedActor.newInstance(classOf[SimpleJavaPojo], classOf[SimpleJavaPojoImpl]) + val supervisor = TypedActor.newInstance(classOf[SimpleJavaPojo], classOf[SimpleJavaPojoImpl]) link(supervisor,pojo, new OneForOneStrategy(3, 2000),Array(classOf[Throwable])) pojo.throwException Thread.sleep(500) diff --git a/akka-spring/src/test/java/se/scalablesolutions/akka/spring/SampleBean.java b/akka-spring/src/test/java/se/scalablesolutions/akka/spring/SampleBean.java index e8adaa38e73..2828c42bcb7 100644 --- a/akka-spring/src/test/java/se/scalablesolutions/akka/spring/SampleBean.java +++ b/akka-spring/src/test/java/se/scalablesolutions/akka/spring/SampleBean.java @@ -1,22 +1,25 @@ package se.scalablesolutions.akka.spring; -import se.scalablesolutions.akka.actor.annotation.shutdown; +import se.scalablesolutions.akka.actor.*; -public class SampleBean { +public class SampleBean extends TypedActor implements SampleBeanIntf { - public boolean down; + private boolean down; public SampleBean() { down = false; } + public boolean down() { + return down; + } + public String foo(String s) { return "hello " + s; } - @shutdown + @Override public void shutdown() { down = true; } - } diff --git a/akka-spring/src/test/java/se/scalablesolutions/akka/spring/SampleBeanIntf.java b/akka-spring/src/test/java/se/scalablesolutions/akka/spring/SampleBeanIntf.java new file mode 100644 index 00000000000..ec189ecd5f8 --- /dev/null +++ b/akka-spring/src/test/java/se/scalablesolutions/akka/spring/SampleBeanIntf.java @@ -0,0 +1,6 @@ +package se.scalablesolutions.akka.spring; + +public interface SampleBeanIntf { + public boolean down(); + public String foo(String s); + } diff --git a/akka-spring/src/test/scala/CamelServiceSpringFeatureTest.scala b/akka-spring/src/test/scala/CamelServiceSpringFeatureTest.scala index b78f5d552fb..edcf2fa995c 100644 --- a/akka-spring/src/test/scala/CamelServiceSpringFeatureTest.scala +++ b/akka-spring/src/test/scala/CamelServiceSpringFeatureTest.scala @@ -31,7 +31,7 @@ class CamelServiceSpringFeatureTest extends FeatureSpec with BeforeAndAfterEach val appctx = new ClassPathXmlApplicationContext("/appContextCamelServiceDefault.xml") // create a custom registry val registry = new SimpleRegistry - registry.put("custom", TypedActor.newInstance(classOf[SampleBean])) + registry.put("custom", TypedActor.newInstance(classOf[SampleBeanIntf], classOf[SampleBean])) // set custom registry in DefaultCamelContext assert(context.isInstanceOf[DefaultCamelContext]) context.asInstanceOf[DefaultCamelContext].setRegistry(registry)