ServiceEntity

trait ServiceEntity extends ServiceActor

An event sourced persistent entity definition. The entity refers to all actors defined by the the Id.

This is implemented using typed akka persistent actors and cluster sharding. Additional functionality:

- always replies when handing a request - will automatically derive a JSON codec for Storage events - StopEnvelope will always stop the entity - entity will automatically passivate after no events

import glngn.server.prelude._

final object MyServiceEntity extends ServiceEntity {
  val name = "my-service-entity"

  // example declaration of state as case class
  final case class State(state: String) extends Message

  // standard Proto and Storage declarations as sealed traits
  sealed trait Proto extends Message
  sealed trait Storage extends Proto

  // a request event that's recorded to storage
  final case class Add(value: String) extends Command[State] with Storage with Proto

  def activity(injector: ImpureInjector, id: Id) = new Activity(injector) {
    val init = State(Map.empty)

    def protoHandler(ctx: ActorContext[Envelope], state: State) = {
      case persistedEvent: Storage => Handler.persist(persistedEvent)
      case _: Proto                => Handler.none
    }

    def storageHandler(state: State) = {
      case add: Add => state.copy(state = state.state + add.value)
    }
  }
}

Linear Supertypes

ServiceActor, prelude.external.DirectLogging, AnyRef, Any

Known Subclasses

AbstractSetIndex, EntityIdIndex, IntValueEntity, StringMap, StringValueEntity

Ordering

Grouped
Alphabetic
By Inheritance

Inherited

ServiceEntity
ServiceActor
DirectLogging
AnyRef
Any

Hide All
Show All

Visibility

Public
All

Type Members

abstract class Activity extends AnyRef

The entity defines the activity of an instance.

The entity defines the activity of an instance. This activity defines the

the initial state
effects of protocol messages
change of state on storage events

def activity(injector: ImpureInjector, id: Id) = new Activity(injector) {
  val init = State(0)

  def protoHandler(ctx: ActorContext[Envelope], state: State) = {
    case storage: Storage => Handler.persist(storage)
    case _                => Handler.none
  }

  def storageHandler(state: State) = {
    case Inc(amount) => {
      State(state.value + amount)
    }
    case Dec(amount) => {
      State(state.value - amount)
    }
    case Set(value) => {
      State(value)
    }
  }
}

Attributes: protected

final type AnyRequest = Proto with Request[_]
AnyRequest is a Command or Query with no particular response type.
AnyRequest is a Command or Query with no particular response type.

Definition Classes
ServiceActor
sealed trait Handler extends AnyRef
Defines how protocol messages will be handled, see Handler$.
Defines how protocol messages will be handled, see Handler$.
Similar API to akka's Effect:
- what events should be persisted?
- what IO should occur after any events are persisted and integrated into State?
- should the current protocol message be stashed? Or should messages be unstashed?
type Id = String
case class OpenHandler extends Handler with Product with Serializable
A Handler that can be extend with IO actions.
abstract type Proto <: Message
Type of protocol messages this service entity supports.
Type of protocol messages this service entity supports.
```
sealed trait Proto extends Message
```
Definition Classes
ServiceEntity → ServiceActor
final type RequestWithId = (Request[State] with Proto, Id)
sealed trait SealedHandler extends Handler
A Handler that cannot be extended with IO actions.
abstract type State
Entity state type.
abstract type Storage <: Message
Type of persisted events.
Type of persisted events.
```
sealed trait Storage extends Message
```
```
sealed trait Storage extends Proto
```
abstract class Command[Response] extends Request[Response] with proto.ProtoDecl.Command with proto.ProtoDecl.Request
All commands are Requests with Proto: extends Command[R] with Proto.
All commands are Requests with Proto: extends Command[R] with Proto.
```
sealed trait Proto extends Message
case class ExampleCommand(msg: String) extends Command[ExampleResponse] with Proto
```
Definition Classes
ServiceActor
sealed trait Envelope extends Product with Message with Serializable
A Proto event with additional attributes and claims.
A Proto event with additional attributes and claims. To pattern match on an Envelope use the Event.unapply or Request.unapply extractors.
```
val behavior: Behavior[Envelope] = Behaviors.receiveMessagePartial {
  case Event(SomeEvent(eventData)) => ???
  case Request(scope, SomeCommand(eventData)) => ???
}
```
An Envelope can be implicitly constructed from any Proto.
```
val delegate: ActorRef[Envelope] = ???
val anEvent: Proto = SomeEvent(eventData)
delegate ! anEvent
```
Definition Classes
ServiceActor
abstract class Query[Response] extends Request[Response] with proto.ProtoDecl.Query with proto.ProtoDecl.Request
All queries are Requests with Proto: extends Query[R] with Proto.
All queries are Requests with Proto: extends Query[R] with Proto.
```
sealed trait Proto extends Message
case class ExampleQuery(msg: String) extends Query[ExampleResponse] with Proto
```
Definition Classes
ServiceActor
sealed abstract class Request[R] extends AnyRef
A protocol event can be declared as a Request using Command or Query.
A protocol event can be declared as a Request using Command or Query. The type parameter is the response that resolves the request.
```
sealed trait Proto extends Message
case class ExampleCommand(msg: String) extends Command[ExampleResponse] with Proto
case class ExampleQuery(msg: String) extends Query[ExampleResponse] with Proto
```
Definition Classes
ServiceActor

Abstract Value Members

abstract def activity(injector: ImpureInjector, id: Id): Activity

An instance of Activity that defines the entity's behavior:

the initial state
effects of protocol messages
change of state on storage events

def activity(injector: ImpureInjector, id: Id) = new Activity(injector) {
  val init = State(0)

  def protoHandler(ctx: ActorContext[Envelope], state: State) = {
    case storage: Storage => Handler.persist(storage)
    case _                => Handler.none
  }

  def storageHandler(state: State) = {
    case Inc(amount) => {
      State(state.value + amount)
    }
    case Dec(amount) => {
      State(state.value - amount)
    }
    case Set(value) => {
      State(value)
    }
  }
}

abstract val name: EntityName

Logical name of the entity.

final object AnEntity extends ServiceEntity {
  val name = "an-entity"
  ???
}

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
final def asInstanceOf[T0]: T0

Definition Classes
Any
def behavior(entityDomain: EntityDomain, injector: ImpureInjector): (prelude.external.EntityContext) ⇒ prelude.external.Behavior[Envelope]
Instantiates the activity as a persistent behavior.
Instantiates the activity as a persistent behavior. Requests requiring replies will receive the result state in reply.

Attributes
protected[glngn]
def clone(): AnyRef

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws( ... ) @native()
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
Annotations
@native()
def hashCode(): Int

Definition Classes
AnyRef → Any
Annotations
@native()
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
lazy val logger: prelude.external.Logger

Attributes
protected
Definition Classes
DirectLogging
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
Annotations
@native()
final def notifyAll(): Unit

Definition Classes
AnyRef
Annotations
@native()
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
def typeKey(entityDomain: EntityDomain): prelude.external.EntityTypeKey[Envelope]
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( ... ) @native()
object AutoPassivateTimerId
object Handler
Constructors for Handlers used in Activity.protoHandler.
object OpenHandler extends Serializable
See Handler$.
object SealedHandler
object Envelope extends Serializable

Definition Classes
ServiceActor
object Event
Any statement in the protocol can be considered an Event not associated with any additional scope.
Any statement in the protocol can be considered an Event not associated with any additional scope.
- see also ServiceActor.RequestScope and Request.unapply

Definition Classes
ServiceActor
object Request

Definition Classes
ServiceActor
object StopEnvelope extends Envelope with Product with Serializable

Definition Classes
ServiceActor

Packages

ServiceEntity

trait ServiceEntity extends ServiceActor

Type Members

Abstract Value Members

Concrete Value Members

Inherited from ServiceActor

Inherited from prelude.external.DirectLogging

Inherited from AnyRef

Inherited from Any

Domain

Service Logic

Implementation Detail

Ungrouped

Packages

ServiceEntity 

trait ServiceEntity extends ServiceActor

Type Members

Abstract Value Members

Concrete Value Members

Inherited from ServiceActor

Inherited from prelude.external.DirectLogging

Inherited from AnyRef

Inherited from Any

Domain

Service Logic

Implementation Detail

Ungrouped

ServiceEntity