PersistentShardCoordinator

Instance Constructors

new PersistentShardCoordinator(typeName: String, settings: ClusterShardingSettings, allocationStrategy: ShardAllocationStrategy)

Type Members

type Receive = PartialFunction[Any, Unit]

Definition Classes
Actor

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
def +(other: String): String

Implicit information
This member is added by an implicit conversion from PersistentShardCoordinator to any2stringadd[PersistentShardCoordinator] performed by method any2stringadd in scala.Predef.
Definition Classes
any2stringadd
def ->[B](y: B): (PersistentShardCoordinator, B)

Implicit information
This member is added by an implicit conversion from PersistentShardCoordinator to ArrowAssoc[PersistentShardCoordinator] performed by method ArrowAssoc in scala.Predef.
Definition Classes
ArrowAssoc
Annotations
@inline()
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def active: Receive

Definition Classes
ShardCoordinator
var aliveRegions: Set[ActorRef]

Definition Classes
ShardCoordinator
var allRegionsRegistered: Boolean

Definition Classes
ShardCoordinator
def allocateShardHomesForRememberEntities(): Unit

Definition Classes
ShardCoordinator
def aroundPostRestart(reason: Throwable): Unit

Attributes
protected[akka]
Definition Classes
Eventsourced → Actor
def aroundPostStop(): Unit

Attributes
protected[akka]
Definition Classes
Eventsourced → Actor
def aroundPreRestart(reason: Throwable, message: Option[Any]): Unit

Attributes
protected[akka]
Definition Classes
Eventsourced → Actor
def aroundPreStart(): Unit

Attributes
protected[akka]
Definition Classes
Eventsourced → Actor
def aroundReceive(receive: Receive, message: Any): Unit

Attributes
protected[akka]
Definition Classes
Eventsourced → Actor
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
val cluster: Cluster

Definition Classes
ShardCoordinator
implicit val context: ActorContext

Definition Classes
Actor
def continueGetShardHome(shard: ShardId, region: ActorRef, getShardHomeSender: ActorRef): Unit

Definition Classes
ShardCoordinator
def continueRebalance(shards: Set[ShardId]): Unit

Definition Classes
ShardCoordinator
def defer[A](event: A)(handler: (A) ⇒ Unit): Unit

Definition Classes
PersistentActor
def deferAsync[A](event: A)(handler: (A) ⇒ Unit): Unit

Definition Classes
PersistentActor
def deleteMessages(toSequenceNr: Long): Unit

Definition Classes
Eventsourced
def deleteSnapshot(sequenceNr: Long): Unit

Definition Classes
Snapshotter
def deleteSnapshots(criteria: SnapshotSelectionCriteria): Unit

Definition Classes
Snapshotter
def ensuring(cond: (PersistentShardCoordinator) ⇒ Boolean, msg: ⇒ Any): PersistentShardCoordinator

Implicit information
This member is added by an implicit conversion from PersistentShardCoordinator to Ensuring[PersistentShardCoordinator] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: (PersistentShardCoordinator) ⇒ Boolean): PersistentShardCoordinator

Implicit information
This member is added by an implicit conversion from PersistentShardCoordinator to Ensuring[PersistentShardCoordinator] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: Boolean, msg: ⇒ Any): PersistentShardCoordinator

Implicit information
This member is added by an implicit conversion from PersistentShardCoordinator to Ensuring[PersistentShardCoordinator] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: Boolean): PersistentShardCoordinator

Implicit information
This member is added by an implicit conversion from PersistentShardCoordinator to Ensuring[PersistentShardCoordinator] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def formatted(fmtstr: String): String

Implicit information
This member is added by an implicit conversion from PersistentShardCoordinator to StringFormat[PersistentShardCoordinator] performed by method StringFormat in scala.Predef.
Definition Classes
StringFormat
Annotations
@inline()
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
var gracefulShutdownInProgress: Set[ActorRef]

Definition Classes
ShardCoordinator
def handleGetShardHome(shard: ShardId): Boolean

returns
true if the message could be handled without state update, i.e. the shard location was known or the request was deferred or ignored

Definition Classes
ShardCoordinator
def hasAllRegionsRegistered(): Boolean

Definition Classes
ShardCoordinator
def hashCode(): Int

Definition Classes
AnyRef → Any
def internalStashOverflowStrategy: StashOverflowStrategy

Definition Classes
PersistenceStash
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def isMember(region: ActorRef): Boolean

Definition Classes
ShardCoordinator
def journalPluginId: String

Definition Classes
PersistentShardCoordinator → PersistenceIdentity
def lastSequenceNr: Long

Definition Classes
Eventsourced
def loadSnapshot(persistenceId: String, criteria: SnapshotSelectionCriteria, toSequenceNr: Long): Unit

Definition Classes
Snapshotter
def log: LoggingAdapter

Definition Classes
ActorLogging
val minMembers: Int

Definition Classes
ShardCoordinator
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def onPersistFailure(cause: Throwable, event: Any, seqNr: Long): Unit

Attributes
protected
Definition Classes
Eventsourced
Annotations
@InternalStableApi()
def onPersistRejected(cause: Throwable, event: Any, seqNr: Long): Unit

Attributes
protected
Definition Classes
Eventsourced
Annotations
@InternalStableApi()
def onRecoveryFailure(cause: Throwable, event: Option[Any]): Unit

Attributes
protected
Definition Classes
Eventsourced
Annotations
@InternalStableApi()
def persist[A](event: A)(handler: (A) ⇒ Unit): Unit

Definition Classes
PersistentActor
Annotations
@InternalStableApi()
def persistAll[A](events: Seq[A])(handler: (A) ⇒ Unit): Unit

Definition Classes
PersistentActor
Annotations
@InternalStableApi()
def persistAllAsync[A](events: Seq[A])(handler: (A) ⇒ Unit): Unit

Definition Classes
PersistentActor
def persistAsync[A](event: A)(handler: (A) ⇒ Unit): Unit

Definition Classes
PersistentActor
def persistenceId: String

Definition Classes
PersistentShardCoordinator → PersistenceIdentity
def postRestart(reason: Throwable): Unit

Definition Classes
Actor
Annotations
@throws( classOf[java.lang.Exception] )
def postStop(): Unit

Definition Classes
UnrestrictedStash → Actor
Annotations
@throws( classOf[java.lang.Exception] )
def preRestart(reason: Throwable, message: Option[Any]): Unit

Definition Classes
UnrestrictedStash → Actor
Annotations
@throws( classOf[java.lang.Exception] )
def preStart(): Unit

Definition Classes
Actor
Annotations
@throws( classOf[java.lang.Exception] )
var rebalanceInProgress: Map[ShardId, Set[ActorRef]]

Definition Classes
ShardCoordinator
val rebalanceTask: Cancellable

Definition Classes
ShardCoordinator
def receive: Receive

Definition Classes
PersistentActor → Actor
def receiveCommand: Receive

Definition Classes
PersistentShardCoordinator → Eventsourced
def receiveRecover: Receive

Definition Classes
PersistentShardCoordinator → Eventsourced
def receiveSnapshotResult: Receive
def receiveTerminated: Receive

Definition Classes
ShardCoordinator
def recovery: Recovery

Definition Classes
PersistenceRecovery
def recoveryFinished: Boolean

Definition Classes
Eventsourced
def recoveryRunning: Boolean

Definition Classes
Eventsourced
def regionProxyTerminated(ref: ActorRef): Unit

Definition Classes
ShardCoordinator
def regionTerminated(ref: ActorRef): Unit

Definition Classes
ShardCoordinator
var regionTerminationInProgress: Set[ActorRef]

Definition Classes
ShardCoordinator
val removalMargin: FiniteDuration

Definition Classes
ShardCoordinator
def saveSnapshot(snapshot: Any): Unit

Definition Classes
Snapshotter
def saveSnapshotWhenNeeded(): Unit
implicit final val self: ActorRef

Definition Classes
Actor
def sendHostShardMsg(shard: ShardId, region: ActorRef): Unit

Definition Classes
ShardCoordinator
final def sender(): ActorRef

Definition Classes
Actor
def shuttingDown: Receive

Definition Classes
ShardCoordinator
def snapshotPluginId: String

Definition Classes
PersistentShardCoordinator → PersistenceIdentity
def snapshotSequenceNr: Long

Definition Classes
Eventsourced → Snapshotter
def snapshotterId: String

Definition Classes
Eventsourced → Snapshotter
def stash(): Unit

Definition Classes
Eventsourced → StashSupport
var state: State

Definition Classes
ShardCoordinator
def stateInitialized(): Unit

Definition Classes
ShardCoordinator
def supervisorStrategy: SupervisorStrategy

Definition Classes
Actor
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
var unAckedHostShards: Map[ShardId, Cancellable]

Definition Classes
ShardCoordinator
def unhandled(message: Any): Unit

Definition Classes
Eventsourced → Actor
def unstashAll(): Unit

Definition Classes
Eventsourced → StashSupport
def update[E <: DomainEvent](evt: E)(f: (E) ⇒ Unit): Unit

Definition Classes
PersistentShardCoordinator → ShardCoordinator
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def waitingForStateInitialized: Receive
def watchStateActors(): Unit

Definition Classes
ShardCoordinator
def →[B](y: B): (PersistentShardCoordinator, B)

Implicit information
This member is added by an implicit conversion from PersistentShardCoordinator to ArrowAssoc[PersistentShardCoordinator] performed by method ArrowAssoc in scala.Predef.
Definition Classes
ArrowAssoc

Inherited from PersistentActor

Inherited from Eventsourced

Inherited from PersistenceRecovery

Inherited from PersistenceIdentity

Inherited from PersistenceStash

Inherited from StashFactory

Inherited from Stash

Inherited from RequiresMessageQueue[DequeBasedMessageQueueSemantics]

Inherited from UnrestrictedStash

Inherited from StashSupport

Inherited from Snapshotter

Inherited from ShardCoordinator

Inherited from ActorLogging

Inherited from Actor

Inherited from AnyRef

Inherited from Any

Inherited by implicit conversion any2stringadd from PersistentShardCoordinator to any2stringadd[PersistentShardCoordinator]

Inherited by implicit conversion StringFormat from PersistentShardCoordinator to StringFormat[PersistentShardCoordinator]

Inherited by implicit conversion Ensuring from PersistentShardCoordinator to Ensuring[PersistentShardCoordinator]

Inherited by implicit conversion ArrowAssoc from PersistentShardCoordinator to ArrowAssoc[PersistentShardCoordinator]

Ungrouped

Related Doc: package sharding

class PersistentShardCoordinator extends ShardCoordinator with PersistentActor

Instance Constructors

new PersistentShardCoordinator(typeName: String, settings: ClusterShardingSettings, allocationStrategy: ShardAllocationStrategy)

Type Members

type Receive = PartialFunction[Any, Unit]

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (PersistentShardCoordinator, B)

final def ==(arg0: Any): Boolean

def active: Receive

var aliveRegions: Set[ActorRef]

var allRegionsRegistered: Boolean

def allocateShardHomesForRememberEntities(): Unit

def aroundPostRestart(reason: Throwable): Unit

def aroundPostStop(): Unit

def aroundPreRestart(reason: Throwable, message: Option[Any]): Unit

def aroundPreStart(): Unit

def aroundReceive(receive: Receive, message: Any): Unit

final def asInstanceOf[T0]: T0

def clone(): AnyRef

val cluster: Cluster

implicit val context: ActorContext

def continueGetShardHome(shard: ShardId, region: ActorRef, getShardHomeSender: ActorRef): Unit

def continueRebalance(shards: Set[ShardId]): Unit

def defer[A](event: A)(handler: (A) ⇒ Unit): Unit

def deferAsync[A](event: A)(handler: (A) ⇒ Unit): Unit

def deleteMessages(toSequenceNr: Long): Unit

def deleteSnapshot(sequenceNr: Long): Unit

def deleteSnapshots(criteria: SnapshotSelectionCriteria): Unit

def ensuring(cond: (PersistentShardCoordinator) ⇒ Boolean, msg: ⇒ Any): PersistentShardCoordinator

def ensuring(cond: (PersistentShardCoordinator) ⇒ Boolean): PersistentShardCoordinator

def ensuring(cond: Boolean, msg: ⇒ Any): PersistentShardCoordinator

def ensuring(cond: Boolean): PersistentShardCoordinator

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def formatted(fmtstr: String): String

final def getClass(): Class[_]

var gracefulShutdownInProgress: Set[ActorRef]

def handleGetShardHome(shard: ShardId): Boolean

def hasAllRegionsRegistered(): Boolean

def hashCode(): Int

def internalStashOverflowStrategy: StashOverflowStrategy

final def isInstanceOf[T0]: Boolean

def isMember(region: ActorRef): Boolean

def journalPluginId: String

def lastSequenceNr: Long

def loadSnapshot(persistenceId: String, criteria: SnapshotSelectionCriteria, toSequenceNr: Long): Unit

def log: LoggingAdapter

val minMembers: Int

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def onPersistFailure(cause: Throwable, event: Any, seqNr: Long): Unit

def onPersistRejected(cause: Throwable, event: Any, seqNr: Long): Unit

def onRecoveryFailure(cause: Throwable, event: Option[Any]): Unit

def persist[A](event: A)(handler: (A) ⇒ Unit): Unit

def persistAll[A](events: Seq[A])(handler: (A) ⇒ Unit): Unit

def persistAllAsync[A](events: Seq[A])(handler: (A) ⇒ Unit): Unit

def persistAsync[A](event: A)(handler: (A) ⇒ Unit): Unit

def persistenceId: String

def postRestart(reason: Throwable): Unit

def postStop(): Unit

def preRestart(reason: Throwable, message: Option[Any]): Unit

def preStart(): Unit

var rebalanceInProgress: Map[ShardId, Set[ActorRef]]

val rebalanceTask: Cancellable

def receive: Receive

def receiveCommand: Receive

def receiveRecover: Receive

def receiveSnapshotResult: Receive

def receiveTerminated: Receive

def recovery: Recovery

def recoveryFinished: Boolean

def recoveryRunning: Boolean

def regionProxyTerminated(ref: ActorRef): Unit