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

format source with scalafmt

Browse source
This commit is contained in:
Auto Format 2019-03-11 10:38:24 +01:00 • committed by Patrik Nordwall
parent 0f40491d42
commit ce404e4f53
1669 changed files with 43208 additions and 35404 deletions
Download patch file Download diff file Expand all files Collapse all files

275
akka-remote/src/main/scala/akka/remote/RemoteActorRefProvider.scala
View file

@ -35,7 +35,7 @@ import akka.serialization.Serialization
@InternalApi
private[akka] object RemoteActorRefProvider {
private final case class Internals(transport: RemoteTransport, remoteDaemon: InternalActorRef)
extends NoSerializationVerificationNeeded
extends NoSerializationVerificationNeeded
sealed trait TerminatorState
case object Uninitialized extends TerminatorState
@ -44,8 +44,10 @@ private[akka] object RemoteActorRefProvider {
case object WaitTransportShutdown extends TerminatorState
case object Finished extends TerminatorState
private class RemotingTerminator(systemGuardian: ActorRef) extends Actor with FSM[TerminatorState, Option[Internals]]
with RequiresMessageQueue[UnboundedMessageQueueSemantics] {
private class RemotingTerminator(systemGuardian: ActorRef)
extends Actor
with FSM[TerminatorState, Option[Internals]]
with RequiresMessageQueue[UnboundedMessageQueueSemantics] {
import context.dispatcher
startWith(Uninitialized, None)
@ -53,7 +55,7 @@ private[akka] object RemoteActorRefProvider {
when(Uninitialized) {
case Event(i: Internals, _) =>
systemGuardian ! RegisterTerminationHook
goto(Idle) using Some(i)
goto(Idle).using(Some(i))
}
when(Idle) {
@ -67,7 +69,7 @@ private[akka] object RemoteActorRefProvider {
when(WaitDaemonShutdown) {
case Event(TerminationHookDone, Some(internals)) =>
log.info("Remote daemon shut down; proceeding with flushing remote transports.")
internals.transport.shutdown() pipeTo self
internals.transport.shutdown().pipeTo(self)
goto(WaitTransportShutdown)
}
@ -91,10 +93,8 @@ private[akka] object RemoteActorRefProvider {
* and handled as dead letters to the original (remote) destination. Without this special case, DeathWatch related
* functionality breaks, like the special handling of Watch messages arriving to dead letters.
*/
private class RemoteDeadLetterActorRef(
_provider: ActorRefProvider,
_path: ActorPath,
_eventStream: EventStream) extends DeadLetterActorRef(_provider, _path, _eventStream) {
private class RemoteDeadLetterActorRef(_provider: ActorRefProvider, _path: ActorPath, _eventStream: EventStream)
extends DeadLetterActorRef(_provider, _path, _eventStream) {
import EndpointManager.Send
override def !(message: Any)(implicit sender: ActorRef): Unit = message match {
@ -107,11 +107,15 @@ private[akka] object RemoteActorRefProvider {
// the dead letter status
if (seqOpt.isEmpty) super.!(DeadLetter(m, senderOption.getOrElse(_provider.deadLetters), recipient))
case env: OutboundEnvelope =>
super.!(DeadLetter(unwrapSystemMessageEnvelope(env.message), env.sender.getOrElse(_provider.deadLetters),
env.recipient.getOrElse(_provider.deadLetters)))
super.!(
DeadLetter(unwrapSystemMessageEnvelope(env.message),
env.sender.getOrElse(_provider.deadLetters),
env.recipient.getOrElse(_provider.deadLetters)))
case DeadLetter(env: OutboundEnvelope, _, _) =>
super.!(DeadLetter(unwrapSystemMessageEnvelope(env.message), env.sender.getOrElse(_provider.deadLetters),
env.recipient.getOrElse(_provider.deadLetters)))
super.!(
DeadLetter(unwrapSystemMessageEnvelope(env.message),
env.sender.getOrElse(_provider.deadLetters),
env.recipient.getOrElse(_provider.deadLetters)))
case _ => super.!(message)(sender)
}
@ -132,11 +136,11 @@ private[akka] object RemoteActorRefProvider {
* Remote ActorRefProvider. Starts up actor on remote node and creates a RemoteActorRef representing it.
*
*/
private[akka] class RemoteActorRefProvider(
val systemName: String,
val settings: ActorSystem.Settings,
val eventStream: EventStream,
val dynamicAccess: DynamicAccess) extends ActorRefProvider {
private[akka] class RemoteActorRefProvider(val systemName: String,
val settings: ActorSystem.Settings,
val eventStream: EventStream,
val dynamicAccess: DynamicAccess)
extends ActorRefProvider {
import RemoteActorRefProvider._
val remoteSettings: RemoteSettings = new RemoteSettings(settings.config)
@ -149,7 +153,12 @@ private[akka] class RemoteActorRefProvider(
*/
protected def createDeployer: RemoteDeployer = new RemoteDeployer(settings, dynamicAccess)
private val local = new LocalActorRefProvider(systemName, settings, eventStream, dynamicAccess, deployer,
private val local = new LocalActorRefProvider(
systemName,
settings,
eventStream,
dynamicAccess,
deployer,
Some(deadLettersPath => new RemoteDeadLetterActorRef(this, deadLettersPath, eventStream)))
@volatile
@ -164,7 +173,8 @@ private[akka] class RemoteActorRefProvider(
override def guardian: LocalActorRef = local.guardian
override def systemGuardian: LocalActorRef = local.systemGuardian
override def terminationFuture: Future[Terminated] = local.terminationFuture
override def registerTempActor(actorRef: InternalActorRef, path: ActorPath): Unit = local.registerTempActor(actorRef, path)
override def registerTempActor(actorRef: InternalActorRef, path: ActorPath): Unit =
local.registerTempActor(actorRef, path)
override def unregisterTempActor(path: ActorPath): Unit = local.unregisterTempActor(path)
override def tempPath(): ActorPath = local.tempPath()
override def tempContainer: VirtualPathContainer = local.tempContainer
@ -195,23 +205,20 @@ private[akka] class RemoteActorRefProvider(
val internals = Internals(
remoteDaemon = {
val d = new RemoteSystemDaemon(
system,
local.rootPath / "remote",
rootGuardian,
remotingTerminator,
_log,
untrustedMode = remoteSettings.UntrustedMode)
val d = new RemoteSystemDaemon(system,
local.rootPath / "remote",
rootGuardian,
remotingTerminator,
_log,
untrustedMode = remoteSettings.UntrustedMode)
local.registerExtraNames(Map(("remote", d)))
d
},
transport =
if (remoteSettings.Artery.Enabled) remoteSettings.Artery.Transport match {
case ArterySettings.AeronUpd => new ArteryAeronUdpTransport(system, this)
case ArterySettings.Tcp => new ArteryTcpTransport(system, this, tlsEnabled = false)
case ArterySettings.TlsTcp => new ArteryTcpTransport(system, this, tlsEnabled = true)
}
else new Remoting(system, this))
transport = if (remoteSettings.Artery.Enabled) remoteSettings.Artery.Transport match {
case ArterySettings.AeronUpd => new ArteryAeronUdpTransport(system, this)
case ArterySettings.Tcp => new ArteryTcpTransport(system, this, tlsEnabled = false)
case ArterySettings.TlsTcp => new ArteryTcpTransport(system, this, tlsEnabled = true)
} else new Remoting(system, this))
_internals = internals
remotingTerminator ! internals
@ -230,26 +237,34 @@ private[akka] class RemoteActorRefProvider(
val failureDetector = createRemoteWatcherFailureDetector(system)
system.systemActorOf(
configureDispatcher(
RemoteWatcher.props(
failureDetector,
heartbeatInterval = WatchHeartBeatInterval,
unreachableReaperInterval = WatchUnreachableReaperInterval,
heartbeatExpectedResponseAfter = WatchHeartbeatExpectedResponseAfter)),
RemoteWatcher.props(failureDetector,
heartbeatInterval = WatchHeartBeatInterval,
unreachableReaperInterval = WatchUnreachableReaperInterval,
heartbeatExpectedResponseAfter = WatchHeartbeatExpectedResponseAfter)),
"remote-watcher")
}
protected def createRemoteWatcherFailureDetector(system: ExtendedActorSystem): FailureDetectorRegistry[Address] = {
def createFailureDetector(): FailureDetector =
FailureDetectorLoader.load(remoteSettings.WatchFailureDetectorImplementationClass, remoteSettings.WatchFailureDetectorConfig, system)
FailureDetectorLoader.load(remoteSettings.WatchFailureDetectorImplementationClass,
remoteSettings.WatchFailureDetectorConfig,
system)
new DefaultFailureDetectorRegistry(() => createFailureDetector())
}
protected def createRemoteDeploymentWatcher(system: ActorSystemImpl): ActorRef =
system.systemActorOf(remoteSettings.configureDispatcher(Props[RemoteDeploymentWatcher]()), "remote-deployment-watcher")
system.systemActorOf(remoteSettings.configureDispatcher(Props[RemoteDeploymentWatcher]()),
"remote-deployment-watcher")
def actorOf(system: ActorSystemImpl, props: Props, supervisor: InternalActorRef, path: ActorPath,
systemService: Boolean, deploy: Option[Deploy], lookupDeploy: Boolean, async: Boolean): InternalActorRef =
def actorOf(system: ActorSystemImpl,
props: Props,
supervisor: InternalActorRef,
path: ActorPath,
systemService: Boolean,
deploy: Option[Deploy],
lookupDeploy: Boolean,
async: Boolean): InternalActorRef =
if (systemService) local.actorOf(system, props, supervisor, path, systemService, deploy, lookupDeploy, async)
else {
@ -298,38 +313,42 @@ private[akka] class RemoteActorRefProvider(
case "user" | "system" => deployer.lookup(elems.drop(1))
case "remote" => lookupRemotes(elems)
case _ => None
}
else None
} else None
val deployment = {
deploy.toList ::: lookup.toList match {
case Nil => Nil
case l => List(l reduce ((a, b) => b withFallback a))
case l => List(l.reduce((a, b) => b.withFallback(a)))
}
}
Iterator(props.deploy) ++ deployment.iterator reduce ((a, b) => b withFallback a) match {
(Iterator(props.deploy) ++ deployment.iterator).reduce((a, b) => b.withFallback(a)) match {
case d @ Deploy(_, _, _, RemoteScope(address), _, _) =>
if (hasAddress(address)) {
local.actorOf(system, props, supervisor, path, false, deployment.headOption, false, async)
} else if (props.deploy.scope == LocalScope) {
throw new ConfigurationException(s"configuration requested remote deployment for local-only Props at [$path]")
} else try {
throw new ConfigurationException(
s"configuration requested remote deployment for local-only Props at [$path]")
} else
try {
// for consistency we check configuration of dispatcher and mailbox locally
val dispatcher = system.dispatchers.lookup(props.dispatcher)
system.mailboxes.getMailboxType(props, dispatcher.configurator.config)
try {
// for consistency we check configuration of dispatcher and mailbox locally
val dispatcher = system.dispatchers.lookup(props.dispatcher)
system.mailboxes.getMailboxType(props, dispatcher.configurator.config)
} catch {
case NonFatal(e) =>
throw new ConfigurationException(
s"configuration problem while creating [$path] with dispatcher [${props.dispatcher}] and mailbox [${props.mailbox}]",
e)
}
val localAddress = transport.localAddressForRemote(address)
val rpath =
(RootActorPath(address) / "remote" / localAddress.protocol / localAddress.hostPort / path.elements)
.withUid(path.uid)
new RemoteActorRef(transport, localAddress, rpath, supervisor, Some(props), Some(d))
} catch {
case NonFatal(e) => throw new ConfigurationException(
s"configuration problem while creating [$path] with dispatcher [${props.dispatcher}] and mailbox [${props.mailbox}]", e)
case NonFatal(e) => throw new IllegalArgumentException(s"remote deployment failed for [$path]", e)
}
val localAddress = transport.localAddressForRemote(address)
val rpath = (RootActorPath(address) / "remote" / localAddress.protocol / localAddress.hostPort / path.elements).
withUid(path.uid)
new RemoteActorRef(transport, localAddress, rpath, supervisor, Some(props), Some(d))
} catch {
case NonFatal(e) => throw new IllegalArgumentException(s"remote deployment failed for [$path]", e)
}
case _ =>
local.actorOf(system, props, supervisor, path, systemService, deployment.headOption, false, async)
@ -339,14 +358,19 @@ private[akka] class RemoteActorRefProvider(
@deprecated("use actorSelection instead of actorFor", "2.2")
override private[akka] def actorFor(path: ActorPath): InternalActorRef = {
if (hasAddress(path.address)) actorFor(rootGuardian, path.elements)
else try {
new RemoteActorRef(transport, transport.localAddressForRemote(path.address),
path, Nobody, props = None, deploy = None)
} catch {
case NonFatal(e) =>
log.error(e, "Error while looking up address [{}]", path.address)
new EmptyLocalActorRef(this, path, eventStream)
}
else
try {
new RemoteActorRef(transport,
transport.localAddressForRemote(path.address),
path,
Nobody,
props = None,
deploy = None)
} catch {
case NonFatal(e) =>
log.error(e, "Error while looking up address [{}]", path.address)
new EmptyLocalActorRef(this, path, eventStream)
}
}
@deprecated("use actorSelection instead of actorFor", "2.2")
@ -356,8 +380,12 @@ private[akka] class RemoteActorRefProvider(
else {
val rootPath = RootActorPath(address) / elems
try {
new RemoteActorRef(transport, transport.localAddressForRemote(address),
rootPath, Nobody, props = None, deploy = None)
new RemoteActorRef(transport,
transport.localAddressForRemote(address),
rootPath,
Nobody,
props = None,
deploy = None)
} catch {
case NonFatal(e) =>
log.error(e, "Error while looking up address [{}]", rootPath.address)
@ -373,14 +401,19 @@ private[akka] class RemoteActorRefProvider(
def rootGuardianAt(address: Address): ActorRef = {
if (hasAddress(address)) rootGuardian
else try {
new RemoteActorRef(transport, transport.localAddressForRemote(address),
RootActorPath(address), Nobody, props = None, deploy = None)
} catch {
case NonFatal(e) =>
log.error(e, "No root guardian at [{}]", address)
new EmptyLocalActorRef(this, RootActorPath(address), eventStream)
}
else
try {
new RemoteActorRef(transport,
transport.localAddressForRemote(address),
RootActorPath(address),
Nobody,
props = None,
deploy = None)
} catch {
case NonFatal(e) =>
log.error(e, "No root guardian at [{}]", address)
new EmptyLocalActorRef(this, RootActorPath(address), eventStream)
}
}
/**
@ -392,13 +425,19 @@ private[akka] class RemoteActorRefProvider(
case ActorPathExtractor(address, elems) =>
if (hasAddress(address))
local.resolveActorRef(rootGuardian, elems)
else try {
new RemoteActorRef(transport, localAddress, RootActorPath(address) / elems, Nobody, props = None, deploy = None)
} catch {
case NonFatal(e) =>
log.warning("Error while resolving ActorRef [{}] due to [{}]", path, e.getMessage)
new EmptyLocalActorRef(this, RootActorPath(address) / elems, eventStream)
}
else
try {
new RemoteActorRef(transport,
localAddress,
RootActorPath(address) / elems,
Nobody,
props = None,
deploy = None)
} catch {
case NonFatal(e) =>
log.warning("Error while resolving ActorRef [{}] due to [{}]", path, e.getMessage)
new EmptyLocalActorRef(this, RootActorPath(address) / elems, eventStream)
}
case _ =>
log.debug("Resolve (deserialization) of unknown (invalid) path [{}], using deadLetters.", path)
deadLetters
@ -424,8 +463,12 @@ private[akka] class RemoteActorRefProvider(
else {
val rootPath = RootActorPath(address) / elems
try {
new RemoteActorRef(transport, transport.localAddressForRemote(address),
rootPath, Nobody, props = None, deploy = None)
new RemoteActorRef(transport,
transport.localAddressForRemote(address),
rootPath,
Nobody,
props = None,
deploy = None)
} catch {
case NonFatal(e) =>
log.warning("Error while resolving ActorRef [{}] due to [{}]", path, e.getMessage)
@ -439,14 +482,19 @@ private[akka] class RemoteActorRefProvider(
def resolveActorRef(path: ActorPath): ActorRef = {
if (hasAddress(path.address)) local.resolveActorRef(rootGuardian, path.elements)
else try {
new RemoteActorRef(transport, transport.localAddressForRemote(path.address),
path, Nobody, props = None, deploy = None)
} catch {
case NonFatal(e) =>
log.warning("Error while resolving ActorRef [{}] due to [{}]", path, e.getMessage)
new EmptyLocalActorRef(this, path, eventStream)
}
else
try {
new RemoteActorRef(transport,
transport.localAddressForRemote(path.address),
path,
Nobody,
props = None,
deploy = None)
} catch {
case NonFatal(e) =>
log.warning("Error while resolving ActorRef [{}] due to [{}]", path, e.getMessage)
new EmptyLocalActorRef(this, path, eventStream)
}
}
/**
@ -459,16 +507,18 @@ private[akka] class RemoteActorRefProvider(
// actorSelection can't be used here because then it is not guaranteed that the actor is created
// before someone can send messages to it
resolveActorRef(RootActorPath(ref.path.address) / "remote") !
DaemonMsgCreate(props, deploy, ref.path.toSerializationFormat, supervisor)
DaemonMsgCreate(props, deploy, ref.path.toSerializationFormat, supervisor)
remoteDeploymentWatcher ! RemoteDeploymentWatcher.WatchRemote(ref, supervisor)
}
def getExternalAddressFor(addr: Address): Option[Address] = {
addr match {
case _ if hasAddress(addr) => Some(local.rootPath.address)
case Address(_, _, Some(_), Some(_)) => try Some(transport.localAddressForRemote(addr)) catch { case NonFatal(_) => None }
case _ => None
case _ if hasAddress(addr) => Some(local.rootPath.address)
case Address(_, _, Some(_), Some(_)) =>
try Some(transport.localAddressForRemote(addr))
catch { case NonFatal(_) => None }
case _ => None
}
}
@ -513,14 +563,14 @@ private[akka] trait RemoteRef extends ActorRefScope {
* Remote ActorRef that is used when referencing the Actor on a different node than its "home" node.
* This reference is network-aware (remembers its origin) and immutable.
*/
private[akka] class RemoteActorRef private[akka] (
remote: RemoteTransport,
val localAddressToUse: Address,
val path: ActorPath,
val getParent: InternalActorRef,
props: Option[Props],
deploy: Option[Deploy])
extends InternalActorRef with RemoteRef {
private[akka] class RemoteActorRef private[akka] (remote: RemoteTransport,
val localAddressToUse: Address,
val path: ActorPath,
val getParent: InternalActorRef,
props: Option[Props],
deploy: Option[Deploy])
extends InternalActorRef
with RemoteRef {
if (path.address.hasLocalScope)
throw new IllegalArgumentException(s"Unexpected local address in RemoteActorRef [$this]")
@ -542,7 +592,7 @@ private[akka] class RemoteActorRef private[akka] (
val s = name.toStream
s.headOption match {
case None => this
case Some("..") => getParent getChild name
case Some("..") => getParent.getChild(name)
case _ => new RemoteActorRef(remote, localAddressToUse, path / s, Nobody, props = None, deploy = None)
}
}
@ -565,7 +615,9 @@ private[akka] class RemoteActorRef private[akka] (
*/
def isWatchIntercepted(watchee: ActorRef, watcher: ActorRef) =
if (watchee.path.uid == akka.actor.ActorCell.undefinedUid) {
provider.log.debug("actorFor is deprecated, and watching a remote ActorRef acquired with actorFor is not reliable: [{}]", watchee.path)
provider.log.debug(
"actorFor is deprecated, and watching a remote ActorRef acquired with actorFor is not reliable: [{}]",
watchee.path)
false // Not managed by the remote watcher, so not reliable to communication failure or remote system crash
} else {
// If watchee != this then watcher should == this. This is a reverse watch, and it is not intercepted
@ -588,7 +640,8 @@ private[akka] class RemoteActorRef private[akka] (
override def !(message: Any)(implicit sender: ActorRef = Actor.noSender): Unit = {
if (message == null) throw InvalidMessageException("Message is null")
try remote.send(message, OptionVal(sender), this) catch handleException(message, sender)
try remote.send(message, OptionVal(sender), this)
catch handleException(message, sender)
}
override def provider: RemoteActorRefProvider = remote.provider