akkastrator

Type Members

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

   

   An Orchestrator executes a set of, possibly dependent, Tasks.

   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 = ???
     }
   }

2. final class CorrelationId extends AnyVal with Ordered[CorrelationId] with Id

   

3. case class CreateAndStartTasks[R](collection: Seq[R], id: Long) extends Product with Serializable

   

4. final class DeliveryId extends AnyVal with Ordered[DeliveryId] with Id

   

5. trait DistinctIds extends AnyRef

   

6. abstract class DistinctIdsOrchestrator extends AbstractOrchestrator

   

7. sealed trait Event extends AnyRef

   

8. case class Finished[R](result: R) extends TaskState with Product with Serializable

   

9. sealed trait Id extends Typed[Long]

   

10. trait IdImplicits extends AnyRef

    

11. case class MessageReceived(taskIndex: Int, response: Serializable) extends Event with Product with Serializable

    

12. case class MessageSent(taskIndex: Int) extends Event with Product with Serializable

    

13. class MinimalState extends State with DistinctIds

    

    The simplest implementation of a State with DistinctIds.

    The simplest implementation of a State with DistinctIds. The is the default state used by a DistinctIdsOrchestrator.

    It is not a case class so the user can extend it and implement more complex states.

14. abstract class Orchestrator extends AbstractOrchestrator

    

15. class Settings extends AnyRef

    

    This class holds all the settings that parameterize akkastrator.

    This class holds all the settings that parameterize akkastrator.

    By default these settings are read from the Config obtained with ConfigFactory.load().

    You can change the settings in multiple ways:

    • Change them in the default configuration file (e.g. application.conf)
    • Pass a different config holding your configurations:

    new Settings(yourConfig)

    However it will be more succinct to pass your config directly to your akkastrator:

    context.actorOf(Props(classOf[YourAkkastrator], yourConfig))

    • Extend this class overriding the settings you want to redefine

    object YourSettings extends Settings() {
      override val saveSnapshotEveryXMessages = 1000
    }
    context.actorOf(Props(classOf[YourAkkastrator], YourSettings))

16. trait State extends AnyRef

    

17. case class StatusResponse(tasks: IndexedSeq[TaskReport]) extends Product with Serializable

    

18. abstract class Task[R] extends AnyRef

    

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

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

    The answer(s) to the sent message must be handled in behavior. behavior must invoke finish when no further processing is necessary or terminateEarly if the received message will prevent subsequent tasks from executing properly.

    The pattern matching inside behavior must invoke matchId to ensure the received message is in fact the one that this task its waiting to receive.

    The internal state of the orchestrator might be mutated inside behavior.

    This class is very tightly coupled with Orchestrator and the reverse is also true. Because of this you can only create instances of Task inside an orchestrator.

19. abstract class TaskBundle[I, R] extends Task[Seq[R]]

    

    TaskBundle: Variable number of tasks Fixed destination Different messages

20. case class TaskReport(description: String, dependencies: Set[Int], destination: ActorPath, state: TaskState) extends Product with Serializable

    

21. sealed trait TaskState extends AnyRef

    

22. case class TasksFinished[R](results: Seq[R], id: Long) extends Product with Serializable

    

23. case class Waiting(expectedDeliveryId: DeliveryId) extends TaskState with Product with Serializable