Move Lease usage settings inside akka-coordination (#26637)

akka-cluster-sharding/src/main/scala/akka/cluster/sharding/ClusterShardingSettings.scala

@@ -10,8 +10,9 @@ import akka.actor.ActorSystem
 import akka.actor.NoSerializationVerificationNeeded
 import akka.annotation.{ ApiMayChange, InternalApi }
 import com.typesafe.config.Config
-import akka.cluster.{ Cluster, ClusterLeaseSettings }
+import akka.cluster.Cluster
 import akka.cluster.singleton.ClusterSingletonManagerSettings
+import akka.coordination.lease.LeaseUsageSettings
 import akka.util.JavaDurationConverters._
 
 object ClusterShardingSettings {
@@ -61,7 +62,7 @@ object ClusterShardingSettings {
 
     val lease = config.getString("use-lease") match {
       case s if s.isEmpty ⇒ None
-      case other ⇒ Some(new ClusterLeaseSettings(other, config.getDuration("lease-retry-interval").asScala))
+      case other ⇒ Some(new LeaseUsageSettings(other, config.getDuration("lease-retry-interval").asScala))
     }
 
     new ClusterShardingSettings(
@@ -220,7 +221,7 @@ final class ClusterShardingSettings(
     val passivateIdleEntityAfter: FiniteDuration,
     val tuningParameters: ClusterShardingSettings.TuningParameters,
     val coordinatorSingletonSettings: ClusterSingletonManagerSettings,
-    val leaseSettings: Option[ClusterLeaseSettings])
+    val leaseSettings: Option[LeaseUsageSettings])
     extends NoSerializationVerificationNeeded {
 
   // bin compat for 2.5.21
@@ -302,7 +303,7 @@ final class ClusterShardingSettings(
     copy(passivateIdleAfter = duration.asScala)
 
   @ApiMayChange
-  def withLeaseSettings(leaseSettings: ClusterLeaseSettings): ClusterShardingSettings =
+  def withLeaseSettings(leaseSettings: LeaseUsageSettings): ClusterShardingSettings =
     copy(leaseSettings = Some(leaseSettings))
 
   /**
@@ -322,7 +323,7 @@ final class ClusterShardingSettings(
       passivateIdleAfter: FiniteDuration = passivateIdleEntityAfter,
       tuningParameters: ClusterShardingSettings.TuningParameters = tuningParameters,
       coordinatorSingletonSettings: ClusterSingletonManagerSettings = coordinatorSingletonSettings,
-      leaseSettings: Option[ClusterLeaseSettings] = leaseSettings): ClusterShardingSettings =
+      leaseSettings: Option[LeaseUsageSettings] = leaseSettings): ClusterShardingSettings =
     new ClusterShardingSettings(
       role,
       rememberEntities,

akka-cluster-sharding/src/test/scala/akka/cluster/sharding/ShardSpec.scala

@@ -7,8 +7,9 @@ package akka.cluster.sharding
 import java.util.concurrent.atomic.AtomicInteger
 
 import akka.actor.{ Actor, ActorLogging, PoisonPill, Props }
-import akka.cluster.{ ClusterLeaseSettings, TestLeaseExt }
+import akka.cluster.TestLeaseExt
 import akka.cluster.sharding.ShardRegion.ShardInitialized
+import akka.coordination.lease.LeaseUsageSettings
 import akka.testkit.{ AkkaSpec, ImplicitSender, TestProbe }
 
 import scala.concurrent.Future
@@ -100,7 +101,7 @@ class ShardSpec extends AkkaSpec(ShardSpec.config) with ImplicitSender {
   trait Setup {
     val shardId = nextShardId
     val parent = TestProbe()
-    val settings = ClusterShardingSettings(system).withLeaseSettings(new ClusterLeaseSettings("test-lease", 2.seconds))
+    val settings = ClusterShardingSettings(system).withLeaseSettings(new LeaseUsageSettings("test-lease", 2.seconds))
     def lease = awaitAssert {
       testLeaseExt.getTestLease(leaseNameForShard(typeName, shardId))
     }

akka-cluster-tools/src/main/scala/akka/cluster/singleton/ClusterSingletonManager.scala

@@ -30,6 +30,7 @@ import scala.concurrent.Promise
 import akka.Done
 import akka.actor.CoordinatedShutdown
 import akka.annotation.{ ApiMayChange, DoNotInherit }
+import akka.coordination.lease.LeaseUsageSettings
 import akka.pattern.ask
 import akka.util.Timeout
 import akka.coordination.lease.scaladsl.{ Lease, LeaseProvider }
@@ -56,7 +57,7 @@ object ClusterSingletonManagerSettings {
     val lease = config.getString("use-lease") match {
       case s if s.isEmpty ⇒ None
       case leaseConfigPath =>
-        Some(new ClusterLeaseSettings(leaseConfigPath, config.getDuration("lease-retry-interval").asScala))
+        Some(new LeaseUsageSettings(leaseConfigPath, config.getDuration("lease-retry-interval").asScala))
     }
     new ClusterSingletonManagerSettings(
       singletonName = config.getString("singleton-name"),
@@ -113,7 +114,7 @@ final class ClusterSingletonManagerSettings(
     val role: Option[String],
     val removalMargin: FiniteDuration,
     val handOverRetryInterval: FiniteDuration,
-    val leaseSettings: Option[ClusterLeaseSettings])
+    val leaseSettings: Option[LeaseUsageSettings])
     extends NoSerializationVerificationNeeded {
 
   // bin compat for akka 2.5.21
@@ -137,7 +138,7 @@ final class ClusterSingletonManagerSettings(
   def withHandOverRetryInterval(retryInterval: FiniteDuration): ClusterSingletonManagerSettings =
     copy(handOverRetryInterval = retryInterval)
 
-  def withLeaseSettings(leaseSettings: ClusterLeaseSettings): ClusterSingletonManagerSettings =
+  def withLeaseSettings(leaseSettings: LeaseUsageSettings): ClusterSingletonManagerSettings =
     copy(leaseSettings = Some(leaseSettings))
 
   private def copy(
@@ -145,7 +146,7 @@ final class ClusterSingletonManagerSettings(
       role: Option[String] = role,
       removalMargin: FiniteDuration = removalMargin,
       handOverRetryInterval: FiniteDuration = handOverRetryInterval,
-      leaseSettings: Option[ClusterLeaseSettings] = leaseSettings): ClusterSingletonManagerSettings =
+      leaseSettings: Option[LeaseUsageSettings] = leaseSettings): ClusterSingletonManagerSettings =
     new ClusterSingletonManagerSettings(singletonName, role, removalMargin, handOverRetryInterval, leaseSettings)
 }
 

akka-coordination/src/main/scala/akka/coordination/lease/LeaseUsageSettings.scala

@@ -2,17 +2,17 @@
  * Copyright (C) 2019 Lightbend Inc. <https://www.lightbend.com>
  */
 
-package akka.cluster
+package akka.coordination.lease
 
 import akka.annotation.ApiMayChange
-
-import scala.concurrent.duration.FiniteDuration
 import akka.util.JavaDurationConverters._
 import akka.util.PrettyDuration._
 
+import scala.concurrent.duration.FiniteDuration
+
 @ApiMayChange
-class ClusterLeaseSettings private[akka] (val leaseImplementation: String, val leaseRetryInterval: FiniteDuration) {
+class LeaseUsageSettings private[akka] (val leaseImplementation: String, val leaseRetryInterval: FiniteDuration) {
   def getLeaseRetryInterval(): java.time.Duration = leaseRetryInterval.asJava
 
-  override def toString = s"ClusterLeaseSettings($leaseImplementation, ${leaseRetryInterval.pretty})"
+  override def toString = s"LeaseUsageSettings($leaseImplementation, ${leaseRetryInterval.pretty})"
 }