chore: missing retry function with actor system provider (#32690)

---------

Co-authored-by: Johan Andrén <johan@markatta.com>

Author: aludwiko

akka-actor-tests/src/test/java/akka/pattern/RetrySettingsTest.java

@@ -4,14 +4,26 @@
 
 package akka.pattern;
 
+import static org.junit.Assert.assertEquals;
+
+import akka.testkit.AkkaJUnitActorSystemResource;
+import akka.testkit.AkkaSpec;
 import com.typesafe.config.ConfigFactory;
 import java.time.Duration;
 import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.TimeUnit;
+import org.junit.ClassRule;
 import org.junit.Test;
 import org.scalatestplus.junit.JUnitSuite;
 
 public class RetrySettingsTest extends JUnitSuite {
 
+  @ClassRule
+  public static AkkaJUnitActorSystemResource actorSystemResource =
+      new AkkaJUnitActorSystemResource("RetrySettingsTest", AkkaSpec.testConf());
+
   @Test
   public void shouldCreateRetrySetting() {
     // mostly for testing compilation issues
@@ -23,4 +35,17 @@ public void shouldCreateRetrySetting() {
     RetrySettings.create(2).withJavaDelayFunction(retryNum -> Optional.of(Duration.ofSeconds(1)));
     RetrySettings.create(2).withJavaDecider(__ -> true);
   }
+
+  @Test
+  public void retryCallableWithClassicSystem() throws Exception {
+
+    // make sure the overload is callable
+    CompletionStage<String> result =
+        Patterns.retry(
+            () -> CompletableFuture.completedFuture("woho"),
+            RetrySettings.create(2),
+            actorSystemResource.getSystem());
+
+    assertEquals("woho", result.toCompletableFuture().get(3, TimeUnit.SECONDS));
+  }
 }

akka-actor-tests/src/test/scala/akka/pattern/RetrySpec.scala

@@ -173,4 +173,12 @@ class RetrySpec extends AkkaSpec with RetrySupport {
     }
   }
 
+  "provide a retry settings based api" in {
+    // just a successful try to cover API and implicit system provider
+    val retried = retry(RetrySettings(5).withFixedDelay(40.millis)) { () =>
+      Future.successful(5)
+    }
+    retried.futureValue should ===(5)
+  }
+
 }

akka-actor-typed-tests/src/test/java/akka/pattern/RetryTest.java

@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2025 Lightbend Inc. <https://www.lightbend.com>
+ */
+
+package akka.pattern;
+
+import static org.junit.Assert.assertEquals;
+
+import akka.actor.testkit.typed.javadsl.TestKitJunitResource;
+import akka.testkit.AkkaSpec;
+import java.time.Duration;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.TimeUnit;
+import org.junit.ClassRule;
+import org.junit.Test;
+import org.scalatestplus.junit.JUnitSuite;
+
+public class RetryTest extends JUnitSuite {
+
+  @ClassRule
+  public static final TestKitJunitResource testKit = new TestKitJunitResource(AkkaSpec.testConf());
+
+  @Test
+  public void testRetryIsCallableWithTypedSystem() throws Exception {
+
+    // just a successful try to cover API and implicit system provider
+    CompletionStage<Integer> retried =
+        Patterns.retry(
+            () -> CompletableFuture.completedFuture(5),
+            RetrySettings.create(5).withFixedDelay(Duration.ofMillis(40)),
+            testKit.system());
+
+    assertEquals(Integer.valueOf(5), retried.toCompletableFuture().get(3, TimeUnit.SECONDS));
+  }
+}

akka-actor-typed-tests/src/test/scala/akka/pattern/RetrySpec.scala

@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2009-2025 Lightbend Inc. <https://www.lightbend.com>
+ */
+
+package akka.pattern
+
+import akka.actor.testkit.typed.scaladsl.ScalaTestWithActorTestKit
+import org.scalatest.concurrent.Futures
+import org.scalatest.matchers.should.Matchers
+import org.scalatest.wordspec.AnyWordSpecLike
+
+import scala.concurrent.Future
+import scala.concurrent.duration.DurationInt
+
+class RetrySpec extends ScalaTestWithActorTestKit with AnyWordSpecLike with Matchers with Futures {
+
+  "The RetrySettings based retry api" should {
+
+    "work with typed actor system" in {
+
+      // just a successful try to cover API and implicit system provider
+      val retried = retry(RetrySettings(5).withFixedDelay(40.millis)) { () =>
+        Future.successful(5)
+      }
+
+      retried.futureValue should ===(5)
+    }
+  }
+
+}

akka-actor/src/main/scala/akka/pattern/Patterns.scala

@@ -735,26 +735,9 @@ object Patterns {
       attempt: Callable[CompletionStage[T]],
       retrySettings: RetrySettings,
       system: ClassicActorSystemProvider): CompletionStage[T] = {
-    retry(attempt, retrySettings, system.classicSystem.scheduler, system.classicSystem.dispatcher)
-  }
-
-  /**
-   * Returns an internally retrying [[java.util.concurrent.CompletionStage]].
-   * The first attempt will be made immediately, each subsequent attempt will be made based on the provided [[akka.pattern.RetrySettings]].
-   * A scheduler (e.g. context.system().scheduler()) must be provided to delay retries.
-   *
-   * If attempts are exhausted, the returned CompletionStage is that of the last attempt.
-   * Note that the attempt function will be invoked on the given execution context for subsequent tries and therefore
-   * must be thread safe (not touch unsafe mutable state).
-   */
-  def retry[T](
-      attempt: Callable[CompletionStage[T]],
-      retrySettings: RetrySettings,
-      scheduler: Scheduler,
-      context: ExecutionContext): CompletionStage[T] = {
     scalaRetry(retrySettings) { () =>
       attempt.call().asScala
-    }(context, scheduler).asJava
+    }(system).asJava
   }
 
   /**

akka-actor/src/main/scala/akka/pattern/RetrySupport.scala

@@ -4,6 +4,8 @@
 
 package akka.pattern
 
+import akka.actor.ClassicActorSystemProvider
+
 import java.util.concurrent.ThreadLocalRandom
 import scala.concurrent.{ ExecutionContext, Future }
 import scala.concurrent.duration.{ Duration, FiniteDuration }
@@ -254,14 +256,6 @@ trait RetrySupport {
    * Given a function from Unit to Future, returns an internally retrying Future.
    * The first attempt will be made immediately, any subsequent attempt will be made based on provided [[RetrySettings]].
    *
-   * A scheduler (eg context.system.scheduler) must be provided to delay each retry.
-   * You could provide a function to generate the next delay duration after first attempt,
-   * this function should never return `null`, otherwise an [[IllegalArgumentException]] will be thrown.
-   *
-   * If attempts are exhausted the returned future is simply the result of invoking attempt.
-   * Note that the attempt function will be invoked on the given execution context for subsequent
-   * tries and therefore must be thread safe (not touch unsafe mutable state).
-   *
    * <b>Example usage:</b>
    *
    * // retry with backoff
@@ -273,14 +267,14 @@ trait RetrySupport {
    *   }
    * }}}
    */
-  def retry[T](retrySettings: RetrySettings)(
-      attempt: () => Future[T])(implicit ec: ExecutionContext, scheduler: Scheduler): Future[T] = {
+  def retry[T](retrySettings: RetrySettings)(attempt: () => Future[T])(
+      implicit system: ClassicActorSystemProvider): Future[T] = {
     RetrySupport.retry(
       attempt,
       retrySettings.maxRetries,
       retrySettings.delayFunction,
       attempted = 0,
-      retrySettings.shouldRetry)
+      retrySettings.shouldRetry)(system.classicSystem.dispatcher, system.classicSystem.scheduler)
   }
 }