Orchestrator

An Orchestrator executes a set of, possibly dependent, Tasks. A task corresponds to sending a message to an actor, handling its response and possibly mutate the internal state of the Orchestrator.

The Orchestrator together with the Task is able to:

Handling the persistence of the internal state maintained by both the Orchestrator and the Tasks.
Delivering messages with at-least-once delivery guarantee.
Handling Status messages, that is, if some actor is interested in querying the Orchestrator for its current status, the Orchestrator will respond with the status of each task.
Tasks that have no dependencies will be started right away and the Orchestrator will, from that point onwards, be prepared to handle the responses to the sent messages.
If the Orchestrator crashes, the state it maintains will be correctly restored.

NOTE: the responses that are received must be Serializable.

In order for the Orchestrator and the Tasks to be able to achieve all of this they have to access and modify each others state directly. This means they are very tightly coupled with each other. To make this relation more obvious and to enforce it, you will only be able to create tasks inside an orchestrator.

If you have the need to refactor the creation of tasks so that you can use them in multiple orchestrators you can leverage self type annotations like so:

trait DatabaseTasks { self: Orchestrator =>
  def createQueryTask(): Task = new Task("") {
    val destination: ActorPath = ???
    def createMessage(correlationId: CorrelationId): Any = ???

    def behavior: Receive = ???
  }
}

Linear Supertypes

ActorLogging, AtLeastOnceDelivery, AtLeastOnceDeliveryLike, PersistentActor, Eventsourced, PersistenceRecovery, PersistenceIdentity, PersistenceStash, StashFactory, Stash, RequiresMessageQueue[DequeBasedMessageQueueSemantics], UnrestrictedStash, StashSupport, Snapshotter, Actor, AnyRef, Any

Instance Constructors

new Orchestrator(settings: Settings = new Settings())

Type Members

type Receive = PartialFunction[Any, Unit]

Definition Classes
Actor

Abstract Value Members

abstract def persistenceId: String

Definition Classes
PersistenceIdentity

Concrete Value Members

final def !=(arg0: Any): Boolean

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

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def aroundPostRestart(reason: Throwable): Unit

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

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

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

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

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

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def confirmDelivery(deliveryId: Long): Boolean

Definition Classes
AtLeastOnceDeliveryLike
implicit val context: ActorContext

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

Definition Classes
Eventsourced
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 deliver(destination: ActorSelection)(deliveryIdToMessage: (Long) ⇒ Any): Unit

Definition Classes
AtLeastOnceDeliveryLike
def deliver(destination: ActorPath)(deliveryIdToMessage: (Long) ⇒ Any): Unit

Definition Classes
AtLeastOnceDeliveryLike
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def extraCommands: Receive

Override this method to add extra commands that are always handled by this orchestrator (except when recovering).
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getDeliverySnapshot: AtLeastOnceDeliverySnapshot

Definition Classes
AtLeastOnceDeliveryLike
def hashCode(): Int

Definition Classes
AnyRef → Any
def internalStashOverflowStrategy: StashOverflowStrategy

Definition Classes
PersistenceStash
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def journalPluginId: String

Definition Classes
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
def maxUnconfirmedMessages: Int

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

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def numberOfUnconfirmed: Int

Definition Classes
AtLeastOnceDeliveryLike
def onEarlyTermination(instigator: Task, message: Any, tasks: Map[Status, Seq[Task]]): Unit

User overridable callback.
User overridable callback. Is called when a task requests an early termination. Empty default implementation.
instigator
the task that initiated the early termination.
message
the message that caused the early termination.
tasks
Map with the tasks status at the moment of early termination.

Note
if you invoke become/unbecome inside this method the contract stating: Tasks that are waiting will remain untouched and the orchestrator will still be prepared to handle their responses. Will no longer be guaranteed.
def onFinish(): Unit

User overridable callback.
User overridable callback. Is called once every task finishes. By default logs that the Orchestrator has finished then stops it.
You can use this to implement your termination strategy.
You can safely invoke become/unbecome inside this method.
def onPersistFailure(cause: Throwable, event: Any, seqNr: Long): Unit

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

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

Attributes
protected
Definition Classes
Eventsourced
implicit final val orchestrator: Orchestrator
final def orchestratorCommand: Receive
def persist[A](event: A)(handler: (A) ⇒ Unit): Unit

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

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

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

Definition Classes
Eventsourced
def postRestart(reason: Throwable): Unit

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

Definition Classes
UnrestrictedStash → Actor
def preRestart(reason: Throwable, message: Option[Any]): Unit

Definition Classes
UnrestrictedStash → Actor
def preStart(): Unit

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

Definition Classes
PersistentActor → Actor
final def receiveCommand: Receive

Definition Classes
Orchestrator → Eventsourced
final def receiveRecover: Receive

Definition Classes
Orchestrator → Eventsourced
def recovery: Recovery

Definition Classes
PersistenceRecovery
def recoveryFinished: Boolean

Definition Classes
Eventsourced
def recoveryRunning: Boolean

Definition Classes
Eventsourced
def redeliverInterval: FiniteDuration

Definition Classes
AtLeastOnceDeliveryLike
def redeliveryBurstLimit: Int

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

Definition Classes
Snapshotter
def saveSnapshotEveryXMessages: Int

Every X messages a snapshot will be saved.
Every X messages a snapshot will be saved. Set to 0 to disable automatic saving of snapshots. By default this method returns the value defined in the configuration.
This value is not a strict one because the orchestrator will not save it in snapshots. This means that when this actor crashes more messages than the ones defined here might have to be processed in other to trigger a save snapshot.
You can trigger a save snapshot manually by sending a SaveSnapshot message to this orchestrator.
implicit final val self: ActorRef

Definition Classes
Actor
final def sender(): ActorRef

Definition Classes
Actor
def setDeliverySnapshot(snapshot: AtLeastOnceDeliverySnapshot): Unit

Definition Classes
AtLeastOnceDeliveryLike
val settings: Settings
def snapshotPluginId: String

Definition Classes
PersistenceIdentity
def snapshotSequenceNr: Long

Definition Classes
Eventsourced → Snapshotter
def snapshotterId: String

Definition Classes
Eventsourced → Snapshotter
def startTasks(): Unit

User overridable callback.
User overridable callback. Is called to start the Tasks. By default logs that the orchestrator started and sends it the StartReadyTasks message.
def stash(): Unit

Definition Classes
StashSupport
def state[S <: State]: S
def state_=[S <: State](state: S): Unit
def supervisorStrategy: SupervisorStrategy

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

Definition Classes
AnyRef
def tasks: IndexedSeq[Task]
def toString(): String

Definition Classes
AnyRef → Any
def unhandled(message: Any): Unit

Definition Classes
Eventsourced → Actor
def unstashAll(): Unit

Definition Classes
Eventsourced → StashSupport
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 warnAfterNumberOfUnconfirmedAttempts: Int

Definition Classes
AtLeastOnceDeliveryLike

Deprecated Value Members

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

Definition Classes
Eventsourced
Annotations
@deprecated
Deprecated
(Since version 2.4) use persistAll instead
def persistAsync[A](events: Seq[A])(handler: (A) ⇒ Unit): Unit

Definition Classes
Eventsourced
Annotations
@deprecated
Deprecated
(Since version 2.4) use persistAllAsync instead

Related Docs: object Orchestrator | package akkastrator

abstract class Orchestrator extends PersistentActor with AtLeastOnceDelivery with ActorLogging

Instance Constructors

new Orchestrator(settings: Settings = new Settings())

Type Members

type Receive = PartialFunction[Any, Unit]

Abstract Value Members

abstract def persistenceId: String

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

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

def confirmDelivery(deliveryId: Long): Boolean

implicit val context: ActorContext

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 deliver(destination: ActorSelection)(deliveryIdToMessage: (Long) ⇒ Any): Unit

def deliver(destination: ActorPath)(deliveryIdToMessage: (Long) ⇒ Any): Unit

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def extraCommands: Receive

def finalize(): Unit

final def getClass(): Class[_]

def getDeliverySnapshot: AtLeastOnceDeliverySnapshot

def hashCode(): Int

def internalStashOverflowStrategy: StashOverflowStrategy

final def isInstanceOf[T0]: Boolean

def journalPluginId: String

def lastSequenceNr: Long

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

def log: LoggingAdapter

def maxUnconfirmedMessages: Int

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def numberOfUnconfirmed: Int

def onEarlyTermination(instigator: Task, message: Any, tasks: Map[Status, Seq[Task]]): Unit

def onFinish(): 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

implicit final val orchestrator: Orchestrator

final def orchestratorCommand: Receive

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 postRestart(reason: Throwable): Unit

def postStop(): Unit

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

def preStart(): Unit

def receive: Receive

final def receiveCommand: Receive

final def receiveRecover: Receive

def recovery: Recovery

def recoveryFinished: Boolean

def recoveryRunning: Boolean

def redeliverInterval: FiniteDuration

def redeliveryBurstLimit: Int

def saveSnapshot(snapshot: Any): Unit

def saveSnapshotEveryXMessages: Int

implicit final val self: ActorRef

final def sender(): ActorRef

def setDeliverySnapshot(snapshot: AtLeastOnceDeliverySnapshot): Unit

val settings: Settings

def snapshotPluginId: String

def snapshotSequenceNr: Long

def snapshotterId: String

def startTasks(): Unit

def stash(): Unit