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 OrderedProxy[Long] with Id

   

3. final class DeliveryId extends AnyVal with OrderedProxy[Long] with Id

   

4. trait DistinctIds extends AnyRef

   

5. abstract class DistinctIdsOrchestrator extends AbstractOrchestrator

   

6. sealed trait Event extends AnyRef

   

7. sealed trait Id extends Any

   

8. trait IdImplicits extends AnyRef

   

9. case class MessageReceived(taskIndex: Int, response: Any, correlationId: CorrelationId, deliveryId: DeliveryId) extends Event with Product with Serializable

   

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

    

11. class MinimalState extends State with DistinctIds

    

12. abstract class Orchestrator extends AbstractOrchestrator

    

13. 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))

14. trait State extends AnyRef

    

15. case class StatusResponse(tasks: Seq[TaskStatus]) extends Product with Serializable

    

16. case class TaskStatus(index: Int, description: String, status: Status, dependencies: Set[Int]) extends Product with Serializable