AbstractOrchestrator

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. The Orchestrator ensures each destination will see an independent strictly monotonically increasing sequence number without gaps.
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

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

Known Subclasses

DistinctIdsOrchestrator, Orchestrator

Type Members

type Receive = PartialFunction[Any, Unit]

Definition Classes
Actor
abstract type S <: State
abstract type T <: AbstractTask[T]
abstract class TaskProxy extends AbstractTask[TaskProxy]

Abstract Value Members

abstract def persistenceId: String

Definition Classes
PersistenceIdentity
abstract def recoverStateOnMessageReceived(task: T, correlationId: CorrelationId, deliveryId: DeliveryId): Unit

Attributes
protected[pt.tecnico.dsi.akkastrator]
abstract def toT(proxy: TaskProxy): T

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: akka.actor.Actor.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
implicit def longToCorrelationId(l: Long): CorrelationId

Definition Classes
IdImplicits
implicit def longToDeliveryId(l: Long): DeliveryId

Definition Classes
IdImplicits
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: T, message: Any, tasks: Map[Status, Seq[T]]): Unit

User overridable callback.
User overridable callback. Its 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 that states "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. Its 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.
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
final def orchestratorCommand: akka.actor.Actor.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: akka.actor.Actor.Receive

Definition Classes
AbstractOrchestrator → Eventsourced
final def receiveRecover: akka.actor.Actor.Receive

Definition Classes
AbstractOrchestrator → 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 saveSnapshotRoughlyEveryXMessages: 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.
Roughly every X messages a snapshot will be saved. Set to 0 to disable automatic saving of snapshots. This is just a rough value because the orchestrator will not save it in the snapshots. In fact it will not save it at all. Instead the value of lastSequenceNr will be used to estimate how many messages have been processed.
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
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. Its called to start the Tasks. By default logs that the orchestrator started and sends it the StartReadyTasks message.
You can override this to prevent the Orchestrator from starting right away. However that strategy will only be effective the first time the orchestrator starts, that is, if this orchestrator restarts with one task already finished, then that task will send the StartReadyTasks so that tasks that depend on it can start.
def stash(): Unit

Definition Classes
StashSupport
final def state: S
final def state_=(state: S): Unit
def supervisorStrategy: SupervisorStrategy

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

Definition Classes
AnyRef
final def tasks: IndexedSeq[T]
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 Doc: package akkastrator

sealed abstract class AbstractOrchestrator extends PersistentActor with AtLeastOnceDelivery with ActorLogging with IdImplicits

Type Members

type Receive = PartialFunction[Any, Unit]

abstract type S <: State

abstract type T <: AbstractTask[T]

abstract class TaskProxy extends AbstractTask[TaskProxy]

Abstract Value Members

abstract def persistenceId: String

abstract def recoverStateOnMessageReceived(task: T, correlationId: CorrelationId, deliveryId: DeliveryId): Unit

abstract def toT(proxy: TaskProxy): T

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: akka.actor.Actor.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

implicit def longToCorrelationId(l: Long): CorrelationId

implicit def longToDeliveryId(l: Long): DeliveryId

def maxUnconfirmedMessages: Int

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def numberOfUnconfirmed: Int

def onEarlyTermination(instigator: T, message: Any, tasks: Map[Status, Seq[T]]): 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

final def orchestratorCommand: akka.actor.Actor.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: akka.actor.Actor.Receive

final def receiveRecover: akka.actor.Actor.Receive

def recovery: Recovery

def recoveryFinished: Boolean

def recoveryRunning: Boolean

def redeliverInterval: FiniteDuration

def redeliveryBurstLimit: Int

def saveSnapshot(snapshot: Any): Unit

def saveSnapshotRoughlyEveryXMessages: Int

implicit final val self: ActorRef

final def sender(): ActorRef

def setDeliverySnapshot(snapshot: AtLeastOnceDeliverySnapshot): Unit

def snapshotPluginId: String

def snapshotSequenceNr: Long