avoid method signature change

Author: Roiocam

akka-actor-typed-tests/src/test/java/akka/actor/typed/javadsl/ActorCompile.java

@@ -173,9 +173,15 @@ public Behavior<MyMsg> receive(TypedActorContext<MyMsg> context, MyMsg message)
     SupervisorStrategy strategy7 = strategy6.withResetBackoffAfter(Duration.ofSeconds(2));
 
     Behavior<MyMsg> behv =
-        Behaviors.supervise(Behaviors.<MyMsg>ignore())
-            .onFailure(IllegalStateException.class, strategy6)
+        Behaviors.supervise(
+                Behaviors.supervise(Behaviors.<MyMsg>ignore())
+                    .onFailure(IllegalStateException.class, strategy6))
             .onFailure(RuntimeException.class, strategy1);
+    // or using flattern API:
+      Behavior<MyMsg> flatternBehv =
+          Behaviors.supervise(Behaviors.<MyMsg>ignore())
+              .whenFailure(IllegalStateException.class, strategy6)
+              .whenFailure(RuntimeException.class, strategy1);
   }
 
   // actor context

akka-actor-typed-tests/src/test/java/jdocs/akka/typed/supervision/SupervisionCompileOnlyTest.java

@@ -117,8 +117,8 @@ static Behavior<String> parent2() {
           final ActorRef<String> child2 = ctx.spawn(child(0), "child2");
 
           // supervision strategy inside the setup to not recreate children on restart
-          return Behaviors.supervise(
-                  Behaviors.<String>receiveMessage(
+          return Behaviors.<String>supervise(
+                  Behaviors.receiveMessage(
                       msg -> {
                         // message handling that might throw an exception
                         String[] parts = msg.split(" ");

akka-actor-typed-tests/src/test/scala/akka/actor/typed/SupervisionSpec.scala

@@ -164,11 +164,9 @@ class StubbedSupervisionSpec extends AnyWordSpec with Matchers with LogCapturing
       inbox.receiveMessage() should ===(State(1, Map.empty))
     }
 
-    "support nesting to handle different exceptions" in {
+    def testNestedSupervision[T](supervisedBehavior: Behavior[Command] => Behavior[Command]): Unit = {
       val inbox = TestInbox[Event]("evt")
-      val behv = supervise(targetBehavior(inbox.ref))
-        .onFailure[Exc2](SupervisorStrategy.resume)
-        .onFailure[Exc3](SupervisorStrategy.restart)
+      val behv = supervisedBehavior(targetBehavior(inbox.ref))
       val testkit = BehaviorTestKit(behv)
       testkit.run(IncrementState)
       testkit.run(GetState)
@@ -192,6 +190,14 @@ class StubbedSupervisionSpec extends AnyWordSpec with Matchers with LogCapturing
       inbox.receiveMessage() should ===(ReceivedSignal(PostStop))
     }
 
+    "support nesting to handle different exceptions" in testNestedSupervision { behv =>
+      supervise(supervise(behv).onFailure[Exc2](SupervisorStrategy.resume)).onFailure[Exc3](SupervisorStrategy.restart)
+    }
+
+    "flatten support nesting to handle different exceptions" in testNestedSupervision { behv =>
+      supervise(behv).whenFailure[Exc2](SupervisorStrategy.resume).whenFailure[Exc3](SupervisorStrategy.restart)
+    }
+
     "not catch fatal error" in {
       val inbox = TestInbox[Event]()
       val behv = Behaviors.supervise(targetBehavior(inbox.ref)).onFailure[Throwable](SupervisorStrategy.restart)
@@ -397,11 +403,9 @@ class SupervisionSpec extends ScalaTestWithActorTestKit("""
       }
     }
 
-    "support nesting exceptions with different strategies" in {
+    def testNestedSupervision[T](supervisedBehavior: Behavior[Command] => Behavior[Command]): Unit = {
       val probe = TestProbe[Event]("evt")
-      val behv =
-        supervise(supervise(targetBehavior(probe.ref)).onFailure[RuntimeException](SupervisorStrategy.stop))
-          .onFailure[Exception](SupervisorStrategy.restart)
+      val behv = supervisedBehavior(targetBehavior(probe.ref))
 
       val ref = spawn(behv)
 
@@ -416,13 +420,21 @@ class SupervisionSpec extends ScalaTestWithActorTestKit("""
       }
     }
 
-    "support nesting exceptions with outer restart and inner backoff strategies" in {
+    "support nesting exceptions with different strategies" in testNestedSupervision { behv =>
+      supervise(supervise(behv).onFailure[RuntimeException](SupervisorStrategy.stop))
+        .onFailure[Exception](SupervisorStrategy.restart)
+    }
+
+    "flatten support nesting exceptions with different strategies" in testNestedSupervision { behv =>
+      supervise(behv)
+        .whenFailure[RuntimeException](SupervisorStrategy.stop)
+        .whenFailure[Exception](SupervisorStrategy.restart)
+    }
+
+    def testNestedSupervisionWithRestartThenBackoff[T](
+        supervisedBehavior: Behavior[Command] => Behavior[Command]): Unit = {
       val probe = TestProbe[Event]("evt")
-      val behv =
-        supervise(
-          supervise(targetBehavior(probe.ref))
-            .onFailure[IllegalArgumentException](SupervisorStrategy.restartWithBackoff(10.millis, 10.millis, 0.0)))
-          .onFailure[IOException](SupervisorStrategy.restart)
+      val behv = supervisedBehavior(targetBehavior(probe.ref))
 
       val ref = spawn(behv)
 
@@ -444,11 +456,25 @@ class SupervisionSpec extends ScalaTestWithActorTestKit("""
       probe.expectMessage(Pong(2))
     }
 
-    "support nesting exceptions with inner restart and outer backoff strategies" in {
+    "support nesting exceptions with outer restart and inner backoff strategies" in testNestedSupervisionWithRestartThenBackoff {
+      behv =>
+        supervise(
+          supervise(behv).onFailure[IllegalArgumentException](
+            SupervisorStrategy.restartWithBackoff(10.millis, 10.millis, 0.0)))
+          .onFailure[IOException](SupervisorStrategy.restart)
+    }
+
+    "flatten support nesting exceptions with outer restart and inner backoff strategies" in testNestedSupervisionWithRestartThenBackoff {
+      behv =>
+        supervise(behv)
+          .whenFailure[IllegalArgumentException](SupervisorStrategy.restartWithBackoff(10.millis, 10.millis, 0.0))
+          .whenFailure[IOException](SupervisorStrategy.restart)
+    }
+
+    def testNestedSupervisionWithBackoffThenRestart[T](
+        supervisedBehavior: Behavior[Command] => Behavior[Command]): Unit = {
       val probe = TestProbe[Event]("evt")
-      val behv =
-        supervise(supervise(targetBehavior(probe.ref)).onFailure[IllegalArgumentException](SupervisorStrategy.restart))
-          .onFailure[IOException](SupervisorStrategy.restartWithBackoff(10.millis, 10.millis, 0.0))
+      val behv = supervisedBehavior(targetBehavior(probe.ref))
 
       val ref = spawn(behv)
 
@@ -470,6 +496,19 @@ class SupervisionSpec extends ScalaTestWithActorTestKit("""
       probe.expectMessage(Pong(2))
     }
 
+    "support nesting exceptions with inner restart and outer backoff strategies" in testNestedSupervisionWithBackoffThenRestart {
+      behv =>
+        supervise(supervise(behv).onFailure[IllegalArgumentException](SupervisorStrategy.restart))
+          .onFailure[IOException](SupervisorStrategy.restartWithBackoff(10.millis, 10.millis, 0.0))
+    }
+
+    "flatten support nesting exceptions with inner restart and outer backoff strategies" in testNestedSupervisionWithBackoffThenRestart {
+      behv =>
+        supervise(behv)
+          .whenFailure[IllegalArgumentException](SupervisorStrategy.restart)
+          .whenFailure[IOException](SupervisorStrategy.restartWithBackoff(10.millis, 10.millis, 0.0))
+    }
+
     "stop when not supervised" in {
       val probe = TestProbe[Event]("evt")
       val behv = targetBehavior(probe.ref)

akka-actor-typed-tests/src/test/scala/docs/akka/typed/supervision/SupervisionCompileOnly.scala

@@ -34,9 +34,14 @@ object SupervisionCompileOnly {
 
   //#multiple
   Behaviors
-    .supervise(behavior)
-    .onFailure[IllegalStateException](SupervisorStrategy.restart)
+    .supervise(Behaviors.supervise(behavior).onFailure[IllegalStateException](SupervisorStrategy.restart))
     .onFailure[IllegalArgumentException](SupervisorStrategy.stop)
+
+  // or flatten ways
+  Behaviors
+    .supervise(behavior)
+    .whenFailure[IllegalStateException](SupervisorStrategy.restart)
+    .whenFailure[IllegalArgumentException](SupervisorStrategy.stop)
   //#multiple
 
   //#wrap

akka-actor-typed/src/main/mima-filters/2.9.6.backwards.excludes/issue-32465.excludes

@@ -124,7 +124,7 @@ class SuperviseBehavior[T] private[akka] (val wrapped: Behavior[T])
   private final val ThrowableClassTag = ClassTag(classOf[Throwable])
 
   /** Specify the [[SupervisorStrategy]] to be invoked when the wrapped behavior throws. */
-  def onFailure[Thr <: Throwable](strategy: SupervisorStrategy)(
+  def whenFailure[Thr <: Throwable](strategy: SupervisorStrategy)(
       implicit tag: ClassTag[Thr] = ThrowableClassTag): SuperviseBehavior[T] = {
     val effectiveTag = if (tag == ClassTag.Nothing) ThrowableClassTag else tag
     new SuperviseBehavior[T](Supervisor(Behavior.validateAsInitial(wrapped), strategy)(effectiveTag))
@@ -135,8 +135,8 @@ class SuperviseBehavior[T] private[akka] (val wrapped: Behavior[T])
    *
    * Only exceptions of the given type (and their subclasses) will be handled by this supervision behavior.
    */
-  def onFailure[Thr <: Throwable](clazz: Class[Thr], strategy: SupervisorStrategy): SuperviseBehavior[T] =
-    onFailure(strategy)(ClassTag(clazz))
+  def whenFailure[Thr <: Throwable](clazz: Class[Thr], strategy: SupervisorStrategy): SuperviseBehavior[T] =
+    whenFailure(strategy)(ClassTag(clazz))
 
   private[akka] def unwrap: Behavior[T] = wrapped
 }

akka-actor-typed/src/main/scala/akka/actor/typed/Behavior.scala

@@ -254,16 +254,24 @@ object Behaviors {
      *
      * Only exceptions of the given type (and their subclasses) will be handled by this supervision behavior.
      */
-    def onFailure[Thr <: Throwable](clazz: Class[Thr], strategy: SupervisorStrategy): SuperviseBehavior[T] =
-      new SuperviseBehavior[T](wrapped).onFailure(clazz, strategy)
+    def onFailure[Thr <: Throwable](clazz: Class[Thr], strategy: SupervisorStrategy): Behavior[T] =
+      new SuperviseBehavior[T](wrapped).whenFailure(clazz, strategy).unwrap
 
     /**
      * Specify the [[SupervisorStrategy]] to be invoked when the wrapped behavior throws.
      *
      * All non-fatal (see [[scala.util.control.NonFatal]]) exceptions types will be handled using the given strategy.
      */
     def onFailure(strategy: SupervisorStrategy): Behavior[T] =
-      new SuperviseBehavior[T](wrapped).onFailure(strategy)
+      onFailure(classOf[Exception], strategy)
+
+    /**
+     * Specify the [[SupervisorStrategy]] to be invoked when the wrapped behavior throws by use flatten ways.
+     *
+     * Only exceptions of the given type (and their subclasses) will be handled by this supervision behavior.
+     */
+    def whenFailure[Thr <: Throwable](clazz: Class[Thr], strategy: SupervisorStrategy): SuperviseBehavior[T] =
+      new SuperviseBehavior[T](wrapped).whenFailure(clazz, strategy)
   }
 
   /**

akka-actor-typed/src/main/scala/akka/actor/typed/javadsl/Behaviors.scala

@@ -220,8 +220,14 @@ object Behaviors {
   final class Supervise[T] private[akka] (val wrapped: Behavior[T]) extends AnyVal {
 
     /** Specify the [[SupervisorStrategy]] to be invoked when the wrapped behavior throws. */
-    def onFailure[Thr <: Throwable](strategy: SupervisorStrategy)(implicit tag: ClassTag[Thr]): SuperviseBehavior[T] = {
-      new SuperviseBehavior[T](wrapped).onFailure(strategy)(tag)
+    def onFailure[Thr <: Throwable](strategy: SupervisorStrategy)(implicit tag: ClassTag[Thr]): Behavior[T] = {
+      whenFailure(strategy)(tag).unwrap
+    }
+
+    /** Specify the [[SupervisorStrategy]] to be invoked when the wrapped behavior throws by use flatten ways. */
+    def whenFailure[Thr <: Throwable](strategy: SupervisorStrategy)(
+        implicit tag: ClassTag[Thr]): SuperviseBehavior[T] = {
+      new SuperviseBehavior[T](wrapped).whenFailure(strategy)(tag)
     }
   }