All Classes and Interfaces
Class
Description
A host starts out by hosting no actorGroups.
This abstract class provides two services to concrete subclasses:
First, it stores the configuration and actorId of the Actor instance for which it applies.
An actor has a unique and permanent Id.
An actor is persistent.
The scheduler for a actorGroup manages a map of ActorEntries.
An actor exists in a single permanent actorGroup.
When an actorId is created, it depends on an implementation of this class to
determine which ActorGroup to assign the new ActorId to.
This special Actor handles outbound messages from an ActorGroup to another ActorGroup.
This host-bound actor displays statistics periodically.
An actorId is made up of a type, an actorGroup, and a unique id for the instance of the actor.
An ActorId has no meaning in the business model.
Actor Metadata is gathered during configuration so that it can be static while the system is Active.
The ActorType annotation is optional on an ActorClass but strongly advised.
Contains all the logic for configuration but no actual configuration.
This BTree can exist on disk.
The Sodacan configuration contains settings for specifying factories, singleton objects,
and static and dynamic settings.
Default implementation of the Config interface.
Contains ordinary host behavior.
All Messages have a messageId and a routing stack.
MessageId is normally a Java Instant plus a random integer.
Persist all @Save fields for one actor into a file.
Only for testing, always assigns a single group number
Random that is fixed, for testing
Serialize and deserialize Actors and Messages to Json using Google's Gson.
Factory that creates individual Serializers.
A Host sits at the top of the hierarchy of actorGroups and actors
in a single Java application
A host bound Actor is locked to a specific host rather than moving with its
actor group.
Contains a combination of host number, actorgroup number, and actorGroup state.
Active state means that this actorGroup is able to process messages.
Replica state means that this actorGroup is only receiving actor state messages
and storing them locally in anticipation of possibly becoming active.
The Host mode allows the specified ActorGroup to remain bound to the host; It can't move
like an ordinary ActorrGroup.
A journal entry suitable for writing/reading with nio.
The first 2^16 bytes of a journal file are reserved for header information pertaining to the format of the rest of the file.
A JournalWriter Actor is responsible for writing state to a journal.
Why the name Jug?
Factory that creates individual Serializers.
As with all persisters, the factory hangs around until host closes it.
Overview
A messageId is statistically unique and sortable by its timestamp.
The carrier for messages sent between Actors.
Implementations of this interface save and restore a serialized form of an Actor.
A persister Factory is created during configuration.
A Receiver implementation receives an inbound serialized message and adds the message to an appropriate ActorGroup queue.
Only one persister factory in a host so this is where we open RocksDb.
A message route carries the information needed to get a message to where
it is going and what it's purpose is when it gets there.
A Route needs special handling, specifically because of the verb contained within.
Any field annotated with @Save will be saved and restored as needed.
A Sender is a delegate of a Host tasked with sending messages to other hosts.
Create a sequential ActorId for testing.
A Serializer is concerned with serializing and deserializing Actors and Messages.
A serializer Factory is created during configuration.
For this Single host coordinator, the static configuration is provided and used.
A kind of WorkerActor that Sleeps for a while, sends a message, and then goes away.
While an Actor processes a message, it populates this object with messages to be sent to other actors upon completion of processing the message.
Hold live statistics for an actor group
This timer actor provides a simple but important service for other Actors:
It will accept a message, hold on to the message for a specified amount
of time and then forward that message to its next step which could be
the Actor that sent the message or any other actor.
A WorkerActor has no state, it's ephemeral.