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

use java.time.Duration in Typed javadsl, #24646 (#24804)

Browse source
This commit is contained in:
Patrik Nordwall 2018-04-02 09:30:49 +02:00 • committed by Christopher Batey
parent 6229c6f34e
commit 896aa7e33b
21 changed files with 287 additions and 150 deletions
Download patch file Download diff file Expand all files Collapse all files

13
akka-cluster-typed/src/main/scala/akka/cluster/ddata/typed/internal/ReplicatorBehavior.scala
View file

@ -16,6 +16,7 @@ import akka.actor.typed.Behavior
import akka.actor.typed.scaladsl.Behaviors
import akka.actor.typed.scaladsl.adapter._
import akka.util.Timeout
import akka.util.JavaDurationConverters._
import akka.cluster.ddata.ReplicatedData
import akka.actor.typed.Terminated
@ -67,8 +68,8 @@ import akka.actor.typed.Terminated
case cmd: JReplicator.Get[d] ⇒
implicit val timeout = Timeout(cmd.consistency.timeout match {
case Duration.Zero ⇒ localAskTimeout
case t ⇒ t + additionalAskTimeout
case java.time.Duration.ZERO ⇒ localAskTimeout
case t ⇒ t.asScala + additionalAskTimeout
})
import ctx.executionContext
val reply =
@ -91,8 +92,8 @@ import akka.actor.typed.Terminated
case cmd: JReplicator.Update[d] ⇒
implicit val timeout = Timeout(cmd.writeConsistency.timeout match {
case Duration.Zero ⇒ localAskTimeout
case t ⇒ t + additionalAskTimeout
case java.time.Duration.ZERO ⇒ localAskTimeout
case t ⇒ t.asScala + additionalAskTimeout
})
import ctx.executionContext
val reply =
@ -146,8 +147,8 @@ import akka.actor.typed.Terminated
case cmd: JReplicator.Delete[d] ⇒
implicit val timeout = Timeout(cmd.consistency.timeout match {
case Duration.Zero ⇒ localAskTimeout
case t ⇒ t + additionalAskTimeout
case java.time.Duration.ZERO ⇒ localAskTimeout
case t ⇒ t.asScala + additionalAskTimeout
})
import ctx.executionContext
val reply =

64
akka-cluster-typed/src/main/scala/akka/cluster/ddata/typed/javadsl/Replicator.scala
View file

@ -4,27 +4,23 @@
package akka.cluster.ddata.typed.javadsl
import java.util.function.{ Function ⇒ JFunction }
import akka.cluster.{ ddata ⇒ dd }
import akka.cluster.ddata.Key
import akka.cluster.ddata.ReplicatedData
import akka.actor.typed.ActorRef
import akka.actor.typed.Behavior
import akka.cluster.ddata.typed.internal.ReplicatorBehavior
import scala.concurrent.duration.FiniteDuration
import scala.concurrent.duration.Duration
import java.time.Duration
import java.util.Optional
import java.util.function.{ Function ⇒ JFunction }
import akka.actor.{ DeadLetterSuppression, NoSerializationVerificationNeeded }
import akka.actor.typed.{ ActorRef, Behavior }
import akka.annotation.{ DoNotInherit, InternalApi }
import scala.util.control.NoStackTrace
import akka.actor.typed.ActorRef
import akka.actor.typed.Behavior
import akka.actor.DeadLetterSuppression
import akka.actor.NoSerializationVerificationNeeded
import akka.annotation.DoNotInherit
import akka.annotation.InternalApi
import akka.cluster.ddata.Key
import akka.cluster.ddata.ReplicatedData
import akka.cluster.ddata.typed.internal.ReplicatorBehavior
import akka.cluster.{ ddata ⇒ dd }
import scala.concurrent.duration.{ Duration, FiniteDuration }
import scala.util.control.NoStackTrace
import akka.util.JavaDurationConverters._
/**
* @see [[akka.cluster.ddata.Replicator]].
@ -48,61 +44,61 @@ object Replicator {
@DoNotInherit trait Command extends akka.cluster.ddata.typed.scaladsl.Replicator.Command
sealed trait ReadConsistency {
def timeout: FiniteDuration
def timeout: Duration
/** INTERNAL API */
@InternalApi private[akka] def toUntyped: dd.Replicator.ReadConsistency
}
case object ReadLocal extends ReadConsistency {
override def timeout: FiniteDuration = Duration.Zero
override def timeout: Duration = Duration.ZERO
/** INTERNAL API */
@InternalApi private[akka] override def toUntyped = dd.Replicator.ReadLocal
}
final case class ReadFrom(n: Int, timeout: FiniteDuration) extends ReadConsistency {
final case class ReadFrom(n: Int, timeout: Duration) extends ReadConsistency {
require(n >= 2, "ReadFrom n must be >= 2, use ReadLocal for n=1")
/** INTERNAL API */
@InternalApi private[akka] override def toUntyped = dd.Replicator.ReadFrom(n, timeout)
@InternalApi private[akka] override def toUntyped = dd.Replicator.ReadFrom(n, timeout.asScala)
}
final case class ReadMajority(timeout: FiniteDuration, minCap: Int = DefaultMajorityMinCap) extends ReadConsistency {
def this(timeout: FiniteDuration) = this(timeout, DefaultMajorityMinCap)
final case class ReadMajority(timeout: Duration, minCap: Int = DefaultMajorityMinCap) extends ReadConsistency {
def this(timeout: Duration) = this(timeout, DefaultMajorityMinCap)
/** INTERNAL API */
@InternalApi private[akka] override def toUntyped = dd.Replicator.ReadMajority(timeout, minCap)
@InternalApi private[akka] override def toUntyped = dd.Replicator.ReadMajority(timeout.asScala, minCap)
}
final case class ReadAll(timeout: FiniteDuration) extends ReadConsistency {
final case class ReadAll(timeout: Duration) extends ReadConsistency {
/** INTERNAL API */
@InternalApi private[akka] override def toUntyped = dd.Replicator.ReadAll(timeout)
@InternalApi private[akka] override def toUntyped = dd.Replicator.ReadAll(timeout.asScala)
}
sealed trait WriteConsistency {
def timeout: FiniteDuration
def timeout: Duration
/** INTERNAL API */
@InternalApi private[akka] def toUntyped: dd.Replicator.WriteConsistency
}
case object WriteLocal extends WriteConsistency {
override def timeout: FiniteDuration = Duration.Zero
override def timeout: Duration = Duration.ZERO
/** INTERNAL API */
@InternalApi private[akka] override def toUntyped = dd.Replicator.WriteLocal
}
final case class WriteTo(n: Int, timeout: FiniteDuration) extends WriteConsistency {
final case class WriteTo(n: Int, timeout: Duration) extends WriteConsistency {
require(n >= 2, "WriteTo n must be >= 2, use WriteLocal for n=1")
/** INTERNAL API */
@InternalApi private[akka] override def toUntyped = dd.Replicator.WriteTo(n, timeout)
@InternalApi private[akka] override def toUntyped = dd.Replicator.WriteTo(n, timeout.asScala)
}
final case class WriteMajority(timeout: FiniteDuration, minCap: Int = DefaultMajorityMinCap) extends WriteConsistency {
def this(timeout: FiniteDuration) = this(timeout, DefaultMajorityMinCap)
final case class WriteMajority(timeout: Duration, minCap: Int = DefaultMajorityMinCap) extends WriteConsistency {
def this(timeout: Duration) = this(timeout, DefaultMajorityMinCap)
/** INTERNAL API */
@InternalApi private[akka] override def toUntyped = dd.Replicator.WriteMajority(timeout, minCap)
@InternalApi private[akka] override def toUntyped = dd.Replicator.WriteMajority(timeout.asScala, minCap)
}
final case class WriteAll(timeout: FiniteDuration) extends WriteConsistency {
final case class WriteAll(timeout: Duration) extends WriteConsistency {
/** INTERNAL API */
@InternalApi private[akka] override def toUntyped = dd.Replicator.WriteAll(timeout)
@InternalApi private[akka] override def toUntyped = dd.Replicator.WriteAll(timeout.asScala)
}
/**

11
akka-cluster-typed/src/main/scala/akka/cluster/typed/ClusterSingleton.scala
View file

@ -10,6 +10,7 @@ import akka.cluster.ClusterSettings.DataCenter
import akka.cluster.singleton.{ ClusterSingletonProxySettings, ClusterSingletonManagerSettings ⇒ UntypedClusterSingletonManagerSettings }
import akka.cluster.typed.internal.AdaptedClusterSingletonImpl
import akka.actor.typed.{ ActorRef, ActorSystem, Behavior, Extension, ExtensionId, Props }
import akka.util.JavaDurationConverters._
import com.typesafe.config.Config
import scala.concurrent.duration._
@ -60,8 +61,10 @@ final class ClusterSingletonSettings(
def withNoDataCenter(): ClusterSingletonSettings = copy(dataCenter = None)
def withRemovalMargin(removalMargin: FiniteDuration): ClusterSingletonSettings = copy(removalMargin = removalMargin)
def withRemovalMargin(removalMargin: java.time.Duration): ClusterSingletonSettings = withRemovalMargin(removalMargin.asScala)
def withHandoverRetryInterval(handOverRetryInterval: FiniteDuration): ClusterSingletonSettings = copy(handOverRetryInterval = handOverRetryInterval)
def withHandoverRetryInterval(handOverRetryInterval: java.time.Duration): ClusterSingletonSettings = withHandoverRetryInterval(handOverRetryInterval.asScala)
def withBufferSize(bufferSize: Int): ClusterSingletonSettings = copy(bufferSize = bufferSize)
@ -113,7 +116,7 @@ object ClusterSingleton extends ExtensionId[ClusterSingleton] {
*/
@InternalApi
private[akka] object ClusterSingletonImpl {
def managerNameFor(singletonName: String) = s"singletonManager${singletonName}"
def managerNameFor(singletonName: String) = s"singletonManager$singletonName"
}
/**
@ -213,13 +216,17 @@ final class ClusterSingletonManagerSettings(
def withRole(role: String): ClusterSingletonManagerSettings = copy(role = UntypedClusterSingletonManagerSettings.roleOption(role))
def withRole(role: Option[String]) = copy(role = role)
def withRole(role: Option[String]): ClusterSingletonManagerSettings = copy(role = role)
def withRemovalMargin(removalMargin: FiniteDuration): ClusterSingletonManagerSettings =
copy(removalMargin = removalMargin)
def withRemovalMargin(removalMargin: java.time.Duration): ClusterSingletonManagerSettings =
withRemovalMargin(removalMargin.asScala)
def withHandOverRetryInterval(retryInterval: FiniteDuration): ClusterSingletonManagerSettings =
copy(handOverRetryInterval = retryInterval)
def withHandOverRetryInterval(retryInterval: java.time.Duration): ClusterSingletonManagerSettings =
withHandOverRetryInterval(retryInterval.asScala)
private def copy(
singletonName: String = singletonName,