command

Documentation

Index

• type Command
• type CreateEntityCommand
  • func (self *CreateEntityCommand[T]) Apply() error
  • func (self *CreateEntityCommand[T]) Encode() ([]byte, error)
• type Decoder
• type DecoderF
  • func (self DecoderF) Decode(commandType int32, data []byte) (Command, error)
• type Decoders
  • func GetDefaultDecoders() Decoders
  • func NewDecoders() Decoders
• type DeleteEntityCommand
  • func (self *DeleteEntityCommand) Apply() error
  • func (self *DeleteEntityCommand) Encode() ([]byte, error)
• type Dispatcher
• type EntityCreator
• type EntityDeleter
• type EntityManager
• type EntityMarshaller
• type EntityUpdater
• type LocalDispatcher
  • func (self *LocalDispatcher) Dispatch(command Command) error
  • func (self *LocalDispatcher) GetPeers() map[string]channel.Channel
  • func (self *LocalDispatcher) IsLeaderOrLeaderless() bool
• type SyncSnapshotCommand
  • func (self *SyncSnapshotCommand) Apply() error
  • func (self *SyncSnapshotCommand) Encode() ([]byte, error)
• type UpdateEntityCommand
  • func (self *UpdateEntityCommand[T]) Apply() error
  • func (self *UpdateEntityCommand[T]) Encode() ([]byte, error)
• type Validatable

Types

type Command

type Command interface {
	// Apply runs the commands
	Apply() error

	// Encode returns a serialized representation of the command
	Encode() ([]byte, error)
}

Command instances represent actions to be taken by the fabric controller. They are serializable, so they can be shipped from one controller for RAFT coordination

type CreateEntityCommand

type CreateEntityCommand[T models.Entity] struct {
	Creator        EntityCreator[T]
	Entity         T
	PostCreateHook func(tx *bbolt.Tx, entity T) error
	Flags          uint32
}

func (*CreateEntityCommand[T]) Apply

func (self *CreateEntityCommand[T]) Apply() error

func (*CreateEntityCommand[T]) Encode

func (self *CreateEntityCommand[T]) Encode() ([]byte, error)

type Decoder

type Decoder interface {
	Decode(commandType int32, data []byte) (Command, error)
}

Decoder instances know how to decode encoded commands

type DecoderF

type DecoderF func(commandType int32, data []byte) (Command, error)

DecoderF is a function version of the Decoder interface

func (DecoderF) Decode

func (self DecoderF) Decode(commandType int32, data []byte) (Command, error)

type Decoders

type Decoders interface {
	Register(id int32, decoder Decoder)
	RegisterF(id int32, decoder DecoderF)
	Decode(data []byte) (Command, error)
	GetDecoder(id int32) Decoder
	Clear()
}

func GetDefaultDecoders

func GetDefaultDecoders() Decoders

func NewDecoders

func NewDecoders() Decoders

type DeleteEntityCommand

type DeleteEntityCommand struct {
	Deleter EntityDeleter
	Id      string
}

func (*DeleteEntityCommand) Apply

func (self *DeleteEntityCommand) Apply() error

func (*DeleteEntityCommand) Encode

func (self *DeleteEntityCommand) Encode() ([]byte, error)

type Dispatcher

type Dispatcher interface {
	Dispatch(command Command) error
	IsLeaderOrLeaderless() bool
	GetPeers() map[string]channel.Channel
}

Dispatcher instances will take a command and either send it to the leader to be applied, or if the current system is the leader, apply it locally

type EntityCreator

type EntityCreator[T models.Entity] interface {
	EntityMarshaller[T]

	// ApplyCreate creates the entity described by the given command
	ApplyCreate(cmd *CreateEntityCommand[T]) error
}

EntityCreator instances can apply a create entity command to create entities of a given type

type EntityDeleter

type EntityDeleter interface {
	GetEntityTypeId() string

	// ApplyDelete deletes the entity described by the given command
	ApplyDelete(cmd *DeleteEntityCommand) error
}

EntityDeleter instances can apply a delete entity command to delete entities of a given type

type EntityManager

type EntityManager[T models.Entity] interface {
	EntityCreator[T]
	EntityUpdater[T]
	EntityDeleter
}

EntityManager instances can handle create, update and delete entities of a specific type

type EntityMarshaller

type EntityMarshaller[T any] interface {
	// GetEntityTypeId returns the entity type id. This is distinct from the Store entity id
	// which may be shared by types, such as service and router. The entity type is unique
	// for each type
	GetEntityTypeId() string

	// Marshall marshals the entity to a bytes encoded format
	Marshall(entity T) ([]byte, error)

	// Unmarshall unmarshalls the bytes back into an entity
	Unmarshall(bytes []byte) (T, error)
}

EntityMarshaller instances can marshal and unmarshal entities of the type that they manage as well as knowing their entity type

type EntityUpdater

type EntityUpdater[T models.Entity] interface {
	EntityMarshaller[T]

	// ApplyUpdate updates the entity described by the given command
	ApplyUpdate(cmd *UpdateEntityCommand[T]) error
}

EntityUpdater instances can apply an update entity command to update entities of a given type

type LocalDispatcher

type LocalDispatcher struct {
	EncodeDecodeCommands bool
}

LocalDispatcher should be used when running a non-clustered system

func (*LocalDispatcher) Dispatch

func (self *LocalDispatcher) Dispatch(command Command) error

func (*LocalDispatcher) GetPeers

func (self *LocalDispatcher) GetPeers() map[string]channel.Channel

func (*LocalDispatcher) IsLeaderOrLeaderless

func (self *LocalDispatcher) IsLeaderOrLeaderless() bool

type SyncSnapshotCommand

type SyncSnapshotCommand struct {
	SnapshotId   string
	Snapshot     []byte
	SnapshotSink func(cmd *SyncSnapshotCommand) error
}

func (*SyncSnapshotCommand) Apply

func (self *SyncSnapshotCommand) Apply() error

func (*SyncSnapshotCommand) Encode

func (self *SyncSnapshotCommand) Encode() ([]byte, error)

type UpdateEntityCommand

type UpdateEntityCommand[T models.Entity] struct {
	Updater       EntityUpdater[T]
	Entity        T
	UpdatedFields fields.UpdatedFields
	Flags         uint32
}

func (*UpdateEntityCommand[T]) Apply

func (self *UpdateEntityCommand[T]) Apply() error

func (*UpdateEntityCommand[T]) Encode

func (self *UpdateEntityCommand[T]) Encode() ([]byte, error)

type Validatable

type Validatable interface {
	Validate() error
}

Validatable instances can be validated. Command instances which implement Validable will be validated before Command.Apply is called