Package net.sodacan.core

package net.sodacan.core

This package contains most of the Interfaces of Sodacan. It also contains a few of the concrete classes.

InterHost communication

On the other end is a Receiver. A Receiver can be implemented as an HTTP server. However, a Netty server is sufficient because it does not need to spawn a thread to handle the request. Rather, the message is immediately queued for processing within Sodacan. A Receiver is a delegate of a host and is responsible for accepting inbound messages addressed to this host. The receiver dispatches Jugs received to the inbound queue of the appropriate actor group. Implementation Note: Because the path from a received Jug to the target ActorGroup is very short and fast, the server need not bother creating threads to process requests. Details of the steps at this point are:

• Upon receiving an inbound Jug, the Jug is added to the inbound queue of the target ActorGroup. (The ActorGroup will then distribute the Jug to the appropriate Actor's inbound queue.)
• The Receiver can immediately return to listening for the next request. If an HTTP server is used then a response is returned saying, in effect, Jug received and queued.
• The Receiver must determine which ActorGroup to queue the Jug. Once this is done, the Receiver's job is done. The Receiver does not maintain any Jug state.
• The Jug is then further dispatched into the Actor's queue. The ActorGroup then returns to process more Jugs from its queue.
• An internal ActorEntry, on behalf of the Actor, processes inbound Jugs. In a thread allocated to the Actor, a Jug is removed from the queue, deserialized into a Message, and the Actor's "processMessage" method is called, thus concluding the Jug's journey.

Package Contents

This package contains all of the important interfaces used in Sodacan. Each of the packages below this package contain the implementation classes and a more detailed description of the capabilities provided by that package.

Author:

John Churin

Related Packages

Package	Description
net.sodacan.core.actor	A small island of compute sending and receiving messages to/from other Actors.
net.sodacan.core.actorgroup	An ActorGroup contains a dynamic number of actors.
net.sodacan.core.annotation
net.sodacan.core.config
net.sodacan.core.coordinator	The Sodacan coordinator keeps a network-wide "ideal" distribution of ActorGroups along with a snapshot of the current Host/ActorGroup arrangement.
net.sodacan.core.host	A Host manages ActorGroups.
net.sodacan.core.journal	A Sodacan journal primarily stores Actor state messages which can also be interleaved with other messages.
net.sodacan.core.jug	These subclasses of Jug are used within an ActorGroup for special purposes
net.sodacan.core.message	A message flows from a source Actor to a destination Actor.
net.sodacan.core.persist
net.sodacan.core.scheduler	The Scheduler for an ActorGroup is concerned with thread coordination.
net.sodacan.core.serialize	Serializer implementations are in this package.
net.sodacan.core.util

Class	Description
Actor	An actor has a unique and permanent Id. An actor is persistent.
Actor.Builtin
ActorGroup	An actor exists in a single permanent actorGroup.
ActorGroupAssigner	When an actorId is created, it depends on an implementation of this class to determine which ActorGroup to assign the new ActorId to.
ActorId	An actorId is made up of a type, an actorGroup, and a unique id for the instance of the actor.
ActorIdFactory	An ActorId has no meaning in the business model.
Config	The Sodacan configuration contains settings for specifying factories, singleton objects, and static and dynamic settings.
Coordinator
Host	A Host sits at the top of the hierarchy of actorGroups and actors in a single Java application
Jug	Why the name Jug?
Main
Message	Overview
MessageId	A messageId is statistically unique and sortable by its timestamp.
Persister	Implementations of this interface save and restore a serialized form of an Actor.
Receiver	A Receiver implementation receives an inbound serialized message and adds the message to an appropriate ActorGroup queue.
Route	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.
Scheduler
Sender	A Sender is a delegate of a Host tasked with sending messages to other hosts.
Serializer	A Serializer is concerned with serializing and deserializing Actors and Messages.
SodacanException
Stage	While an Actor processes a message, it populates this object with messages to be sent to other actors upon completion of processing the message.
Verb