gen

package

Go to main page

Versions in this module

v1

v1.999.224

May 1, 2023

v1.999.223

Apr 2, 2023

v1.999.222

Mar 1, 2023

Changes in this version

+ const EnvKeyAppSpec

+ type Pool struct

+ func (p *Pool) HandleCall(process *ServerProcess, from ServerFrom, message etf.Term) (etf.Term, ServerStatus)

+ func (p *Pool) HandleCast(process *ServerProcess, message etf.Term) ServerStatus

+ func (p *Pool) HandleInfo(process *ServerProcess, message etf.Term) ServerStatus

+ func (p *Pool) Init(process *ServerProcess, args ...etf.Term) error

+ type PoolBehavior interface

+ InitPool func(process *PoolProcess, args ...etf.Term) (PoolOptions, error)

+ type PoolOptions struct

+ NumWorkers int

+ Worker PoolWorkerBehavior

+ WorkerArgs []etf.Term

+ WorkerOptions ProcessOptions

+ type PoolProcess struct

+ type PoolWorker struct

+ func (pw *PoolWorker) HandleInfo(process *ServerProcess, message etf.Term) ServerStatus

+ func (pw *PoolWorker) HandleWorkerCall(process *PoolWorkerProcess, message etf.Term) etf.Term

+ func (pw *PoolWorker) HandleWorkerCast(process *PoolWorkerProcess, message etf.Term)

+ func (pw *PoolWorker) HandleWorkerInfo(process *PoolWorkerProcess, message etf.Term)

+ func (pw *PoolWorker) Init(process *ServerProcess, args ...etf.Term) error

+ type PoolWorkerBehavior interface

+ HandleWorkerCall func(process *PoolWorkerProcess, message etf.Term) etf.Term

+ HandleWorkerCast func(process *PoolWorkerProcess, message etf.Term)

+ HandleWorkerInfo func(process *PoolWorkerProcess, message etf.Term)

+ InitPoolWorker func(process *PoolWorkerProcess, args ...etf.Term) error

+ type PoolWorkerProcess struct

v1.999.221

Feb 1, 2023

v1.999.220

Oct 18, 2022

v1.999.211

Jun 15, 2022

v1.999.210

Apr 19, 2022

v1.999.202

Jan 4, 2022

v1.999.201

Nov 22, 2021

v1.999.200

Oct 14, 2021

Changes in this version

+ var ErrServerTerminated = fmt.Errorf("Server terminated")

+ var ErrUnsupportedRequest = fmt.Errorf("Unsupported request")

type ApplicationSpec

+ Environment map[string]interface{}

+ type Monitor interface

+ IsMonitor func(ref etf.Ref) bool

type Process

+ SendSyncRequest func(ref etf.Ref, to interface{}, message etf.Term) error

+ SendSyncRequestRaw func(ref etf.Ref, node etf.Atom, messages ...etf.Term) error

type ProcessDirectMessage

+ Reply chan ProcessDirectMessage

type ProcessInfo

+ Reductions uint64

+ type Registrar interface

+ IsAlias func(etf.Alias) bool

+ IsProcessAlive func(process Process) bool

+ MakeRef func() etf.Ref

+ NodeName func() string

+ NodeStop func()

+ ProcessByAlias func(alias etf.Alias) Process

+ ProcessByName func(name string) Process

+ ProcessByPid func(pid etf.Pid) Process

+ ProcessInfo func(pid etf.Pid) (ProcessInfo, error)

+ ProcessList func() []Process

+ RegisterBehavior func(group, name string, behavior ProcessBehavior, data interface{}) error

+ RegisteredBehavior func(group, name string) (RegisteredBehavior, error)

+ RegisteredBehaviorGroup func(group string) []RegisteredBehavior

+ UnregisterBehavior func(group, name string) error

type RemoteSpawnOptions

+ RegisterName string

+ Timeout int

type RemoteSpawnRequest

+ Function string

type Stage

+ func (s *Stage) DisableAutoDemand(p Process, subscription StageSubscription) error

+ func (s *Stage) DisableForwardDemand(p Process) error

+ func (s *Stage) EnableAutoDemand(p Process, subscription StageSubscription) error

+ func (s *Stage) EnableForwardDemand(p Process) error

type StageOptions

+ DisableForwarding bool

type SupervisorChildSpec

+ Node string

v1.199.221

Feb 1, 2023

Changes in this version

+ const ApplicationStartPermanent

+ const ApplicationStartTemporary

+ const ApplicationStartTransient

+ const DefaultCallTimeout

+ const DefaultRaftAppendTimeout

+ const DefaultRaftGetTimeout

+ const DefaultRaftHeartbeat

+ const EnvKeySpec

+ const SupervisorRestartIntensity

+ const SupervisorRestartPeriod

+ const SupervisorStrategyOneForAll

+ const SupervisorStrategyOneForOne

+ const SupervisorStrategyRestForOne

+ const SupervisorStrategyRestartPermanent

+ const SupervisorStrategyRestartTemporary

+ const SupervisorStrategyRestartTransient

+ const SupervisorStrategySimpleOneForOne

+ var DirectStatusIgnore DirectStatus = fmt.Errorf("ignore")

+ var DirectStatusOK DirectStatus = nil

+ var ErrRaftBusy = fmt.Errorf("another append request is in progress")

+ var ErrRaftNoLeader = fmt.Errorf("no leader")

+ var ErrRaftNoQuorum = fmt.Errorf("no quorum")

+ var ErrRaftNoSerial = fmt.Errorf("no peers with requested serial")

+ var ErrRaftState = fmt.Errorf("incorrect raft state")

+ var ErrRaftWrongTimeout = fmt.Errorf("wrong timeout value")

+ var ErrSagaJobUnknown = fmt.Errorf("Unknown job")

+ var ErrSagaNotAllowed = fmt.Errorf("Operation is not allowed")

+ var ErrSagaResultAlreadySent = fmt.Errorf("Result is already sent")

+ var ErrSagaTxCanceled = fmt.Errorf("Tx is canceled")

+ var ErrSagaTxEndOfLifespan = fmt.Errorf("End of TX lifespan")

+ var ErrSagaTxInProgress = fmt.Errorf("Tx is still in progress")

+ var ErrSagaTxNextTimeout = fmt.Errorf("Next saga timeout")

+ var ErrSagaTxUnknown = fmt.Errorf("Unknown TX")

+ var ErrSagaUnknown = fmt.Errorf("Unknown saga")

+ var RaftQuorumState11 RaftQuorumState = 11

+ var RaftQuorumState3 RaftQuorumState = 3

+ var RaftQuorumState5 RaftQuorumState = 5

+ var RaftQuorumState7 RaftQuorumState = 7

+ var RaftQuorumState9 RaftQuorumState = 9

+ var RaftStatusDiscard RaftStatus = fmt.Errorf("discard")

+ var RaftStatusOK RaftStatus

+ var RaftStatusStop RaftStatus = fmt.Errorf("stop")

+ var SagaStatusOK SagaStatus

+ var SagaStatusStop SagaStatus = fmt.Errorf("stop")

+ var ServerStatusIgnore ServerStatus = fmt.Errorf("ignore")

+ var ServerStatusOK ServerStatus = nil

+ var ServerStatusStop ServerStatus = fmt.Errorf("stop")

+ type Application struct

+ func (a *Application) ProcessInit(p Process, args ...etf.Term) (ProcessState, error)

+ func (a *Application) ProcessLoop(ps ProcessState, started chan<- bool) string

+ type ApplicationBehavior interface

+ Load func(args ...etf.Term) (ApplicationSpec, error)

+ Start func(process Process, args ...etf.Term)

+ type ApplicationChildSpec struct

+ Args []etf.Term

+ Child ProcessBehavior

+ Name string

+ Options ProcessOptions

+ type ApplicationInfo struct

+ Description string

+ Name string

+ PID etf.Pid

+ Version string

+ type ApplicationSpec struct

+ Applications []string

+ Children []ApplicationChildSpec

+ Description string

+ Env map[EnvKey]interface{}

+ Lifespan time.Duration

+ Name string

+ Process Process

+ StartType ApplicationStartType

+ Version string

+ type ApplicationStartType = string

+ type CancelFunc func() bool

+ type Core interface

+ IsAlias func(etf.Alias) bool

+ IsMonitor func(ref etf.Ref) bool

+ MakeRef func() etf.Ref

+ ProcessByAlias func(alias etf.Alias) Process

+ ProcessByName func(name string) Process

+ ProcessByPid func(pid etf.Pid) Process

+ ProcessInfo func(pid etf.Pid) (ProcessInfo, error)

+ ProcessList func() []Process

+ RegisterBehavior func(group, name string, behavior ProcessBehavior, data interface{}) error

+ RegisteredBehavior func(group, name string) (RegisteredBehavior, error)

+ RegisteredBehaviorGroup func(group string) []RegisteredBehavior

+ UnregisterBehavior func(group, name string) error

+ type DirectStatus error

+ type EnvKey string

+ type Event string

+ type EventMessage interface

+ type MessageDirectChildren struct

+ type MessageDown struct

+ Pid etf.Pid

+ ProcessID ProcessID

+ Reason string

+ Ref etf.Ref

+ func IsMessageDown(message etf.Term) (MessageDown, bool)

+ type MessageEventDown struct

+ Event Event

+ Reason string

+ type MessageExit struct

+ Pid etf.Pid

+ Reason string

+ func IsMessageExit(message etf.Term) (MessageExit, bool)

+ type MessageFallback struct

+ Message etf.Term

+ Process etf.Pid

+ Tag string

+ func IsMessageFallback(message etf.Term) (MessageFallback, bool)

+ type MessageManageRPC struct

+ Fun RPC

+ Function string

+ Module string

+ Provide bool

+ type MessageNodeDown struct

+ Name string

+ Ref etf.Ref

+ type MessageProxyDown struct

+ Node string

+ Proxy string

+ Reason string

+ Ref etf.Ref

+ func IsMessageProxyDown(message etf.Term) (MessageProxyDown, bool)

+ type MessageSagaCancel struct

+ NextID SagaNextID

+ Reason string

+ TransactionID SagaTransactionID

+ type MessageSagaError struct

+ Details string

+ Error string

+ NextID SagaNextID

+ TransactionID SagaTransactionID

+ type Process interface

+ Aliases func() []etf.Alias

+ Behavior func() ProcessBehavior

+ CancelSyncRequest func(ref etf.Ref)

+ Children func() ([]etf.Pid, error)

+ Compression func() bool

+ CompressionLevel func() int

+ CompressionThreshold func() int

+ Context func() context.Context

+ CreateAlias func() (etf.Alias, error)

+ DeleteAlias func(alias etf.Alias) error

+ DemonitorEvent func(event Event) error

+ DemonitorNode func(ref etf.Ref) bool

+ DemonitorProcess func(ref etf.Ref) bool

+ Direct func(request interface{}) (interface{}, error)

+ DirectWithTimeout func(request interface{}, timeout int) (interface{}, error)

+ Env func(name EnvKey) interface{}

+ Exit func(reason string) error

+ GroupLeader func() Process

+ Info func() ProcessInfo

+ IsAlive func() bool

+ Kill func()

+ Link func(with etf.Pid) error

+ Links func() []etf.Pid

+ ListEnv func() map[EnvKey]interface{}

+ MonitorEvent func(event Event) error

+ MonitorNode func(name string) etf.Ref

+ MonitorProcess func(process interface{}) etf.Ref

+ MonitoredBy func() []etf.Pid

+ Monitors func() []etf.Pid

+ MonitorsByName func() []ProcessID

+ Name func() string

+ NodeName func() string

+ NodeStop func()

+ NodeUptime func() int64

+ Parent func() Process

+ ProcessChannels func() ProcessChannels

+ PutSyncReply func(ref etf.Ref, term etf.Term, err error) error

+ PutSyncRequest func(ref etf.Ref) error

+ RegisterEvent func(event Event, messages ...EventMessage) error

+ RegisterName func(name string) error

+ RemoteSpawn func(node string, object string, opts RemoteSpawnOptions, args ...etf.Term) (etf.Pid, error)

+ RemoteSpawnWithTimeout func(timeout int, node string, object string, opts RemoteSpawnOptions, ...) (etf.Pid, error)

+ Self func() etf.Pid

+ Send func(to interface{}, message etf.Term) error

+ SendAfter func(to interface{}, message etf.Term, after time.Duration) CancelFunc

+ SendEventMessage func(event Event, message EventMessage) error

+ SetCompression func(enabled bool)

+ SetCompressionLevel func(level int) bool

+ SetCompressionThreshold func(threshold int) bool

+ SetEnv func(name EnvKey, value interface{})

+ SetTrapExit func(trap bool)

+ Spawn func(name string, opts ProcessOptions, object ProcessBehavior, args ...etf.Term) (Process, error)

+ TrapExit func() bool

+ Unlink func(with etf.Pid) error

+ UnregisterEvent func(event Event) error

+ UnregisterName func(name string) error

+ Wait func()

+ WaitSyncReply func(ref etf.Ref, timeout int) (etf.Term, error)

+ WaitWithTimeout func(d time.Duration) error

+ type ProcessBehavior interface

+ ProcessInit func(Process, ...etf.Term) (ProcessState, error)

+ ProcessLoop func(ProcessState, chan<- bool) string

+ type ProcessChannels struct

+ Direct <-chan ProcessDirectMessage

+ GracefulExit <-chan ProcessGracefulExitRequest

+ Mailbox <-chan ProcessMailboxMessage

+ type ProcessDirectMessage struct

+ Err error

+ Message interface{}

+ Ref etf.Ref

+ type ProcessFallback struct

+ Name string

+ Tag string

+ type ProcessGracefulExitRequest struct

+ From etf.Pid

+ Reason string

+ type ProcessID struct

+ Name string

+ Node string

+ func (p ProcessID) String() string

+ type ProcessInfo struct

+ Aliases []etf.Alias

+ Compression bool

+ CurrentFunction string

+ Dictionary etf.Map

+ GroupLeader etf.Pid

+ Links []etf.Pid

+ MessageQueueLen int

+ MonitoredBy []etf.Pid

+ Monitors []etf.Pid

+ MonitorsByName []ProcessID

+ Name string

+ PID etf.Pid

+ Status string

+ TrapExit bool

+ type ProcessMailboxMessage struct

+ From etf.Pid

+ Message interface{}

+ type ProcessOptions struct

+ Context context.Context

+ DirectboxSize uint16

+ Env map[EnvKey]interface{}

+ Fallback ProcessFallback

+ GroupLeader Process

+ MailboxSize uint16

+ type ProcessState struct

+ State interface{}

+ type RPC func(...etf.Term) etf.Term

+ type Raft struct

+ func (r *Raft) HandleCall(process *ServerProcess, from ServerFrom, message etf.Term) (etf.Term, ServerStatus)

+ func (r *Raft) HandleCancel(process *RaftProcess, ref etf.Ref, reason string) RaftStatus

+ func (r *Raft) HandleCast(process *ServerProcess, message etf.Term) ServerStatus

+ func (r *Raft) HandleInfo(process *ServerProcess, message etf.Term) ServerStatus

+ func (r *Raft) HandleLeader(process *RaftProcess, leader *RaftLeader) RaftStatus

+ func (r *Raft) HandlePeer(process *RaftProcess, peer etf.Pid, serial uint64) RaftStatus

+ func (r *Raft) HandleQuorum(process *RaftProcess, quorum *RaftQuorum) RaftStatus

+ func (r *Raft) HandleRaftCall(process *RaftProcess, from ServerFrom, message etf.Term) (etf.Term, ServerStatus)

+ func (r *Raft) HandleRaftCast(process *RaftProcess, message etf.Term) ServerStatus

+ func (r *Raft) HandleRaftDirect(process *RaftProcess, message interface{}) (interface{}, error)

+ func (r *Raft) HandleRaftInfo(process *RaftProcess, message etf.Term) ServerStatus

+ func (r *Raft) HandleSerial(process *RaftProcess, ref etf.Ref, serial uint64, key string, value etf.Term) RaftStatus

+ func (r *Raft) Init(process *ServerProcess, args ...etf.Term) error

+ type RaftBehavior interface

+ HandleAppend func(process *RaftProcess, ref etf.Ref, serial uint64, key string, value etf.Term) RaftStatus

+ HandleCancel func(process *RaftProcess, ref etf.Ref, reason string) RaftStatus

+ HandleGet func(process *RaftProcess, serial uint64) (string, etf.Term, RaftStatus)

+ HandleLeader func(process *RaftProcess, leader *RaftLeader) RaftStatus

+ HandlePeer func(process *RaftProcess, peer etf.Pid, serial uint64) RaftStatus

+ HandleQuorum func(process *RaftProcess, quorum *RaftQuorum) RaftStatus

+ HandleRaftCall func(process *RaftProcess, from ServerFrom, message etf.Term) (etf.Term, ServerStatus)

+ HandleRaftCast func(process *RaftProcess, message etf.Term) ServerStatus

+ HandleRaftDirect func(process *RaftProcess, message interface{}) (interface{}, error)

+ HandleRaftInfo func(process *RaftProcess, message etf.Term) ServerStatus

+ HandleSerial func(process *RaftProcess, ref etf.Ref, serial uint64, key string, value etf.Term) RaftStatus

+ InitRaft func(process *RaftProcess, arr ...etf.Term) (RaftOptions, error)

+ type RaftLeader struct

+ Leader etf.Pid

+ Serial uint64

+ State RaftQuorumState

+ type RaftOptions struct

+ ID string

+ Peers []ProcessID

+ Serial uint64

+ type RaftProcess struct

+ func (rp *RaftProcess) Append(key string, value etf.Term) (etf.Ref, error)

+ func (rp *RaftProcess) AppendWithTimeout(key string, value etf.Term, timeout int) (etf.Ref, error)

+ func (rp *RaftProcess) Get(serial uint64) (etf.Ref, error)

+ func (rp *RaftProcess) GetWithTimeout(serial uint64, timeout int) (etf.Ref, error)

+ func (rp *RaftProcess) Join(peer interface{}) error

+ func (rp *RaftProcess) Leader() *RaftLeader

+ func (rp *RaftProcess) Peers() []etf.Pid

+ func (rp *RaftProcess) Quorum() *RaftQuorum

+ func (rp *RaftProcess) Serial() uint64

+ type RaftQuorum struct

+ Member bool

+ Peers []etf.Pid

+ State RaftQuorumState

+ type RaftQuorumState int

+ type RaftStatus error

+ type RegisteredBehavior struct

+ Behavior ProcessBehavior

+ Data interface{}

+ type RemoteSpawnOptions struct

+ Function string

+ Link bool

+ Monitor etf.Ref

+ Name string

+ type RemoteSpawnRequest struct

+ From etf.Pid

+ Options RemoteSpawnOptions

+ Ref etf.Ref

+ type Saga struct

+ func (gs *Saga) HandleCall(process *ServerProcess, from ServerFrom, message etf.Term) (etf.Term, ServerStatus)

+ func (gs *Saga) HandleCast(process *ServerProcess, message etf.Term) ServerStatus

+ func (gs *Saga) HandleDirect(process *ServerProcess, ref etf.Ref, message interface{}) (interface{}, DirectStatus)

+ func (gs *Saga) HandleInfo(process *ServerProcess, message etf.Term) ServerStatus

+ func (gs *Saga) HandleJobFailed(process *SagaProcess, id SagaTransactionID, from SagaJobID, reason string) SagaStatus

+ func (gs *Saga) HandleJobInterim(process *SagaProcess, id SagaTransactionID, from SagaJobID, ...) SagaStatus

+ func (gs *Saga) HandleJobResult(process *SagaProcess, id SagaTransactionID, from SagaJobID, result interface{}) SagaStatus

+ func (gs *Saga) HandleSagaCall(process *SagaProcess, from ServerFrom, message etf.Term) (etf.Term, ServerStatus)

+ func (gs *Saga) HandleSagaCast(process *SagaProcess, message etf.Term) ServerStatus

+ func (gs *Saga) HandleSagaDirect(process *SagaProcess, ref etf.Ref, message interface{}) (interface{}, DirectStatus)

+ func (gs *Saga) HandleSagaInfo(process *SagaProcess, message etf.Term) ServerStatus

+ func (gs *Saga) HandleTxCommit(process *SagaProcess, id SagaTransactionID, final interface{}) SagaStatus

+ func (gs *Saga) HandleTxDone(process *SagaProcess, id SagaTransactionID, result interface{}) (interface{}, SagaStatus)

+ func (gs *Saga) HandleTxInterim(process *SagaProcess, id SagaTransactionID, from SagaNextID, ...) SagaStatus

+ func (gs *Saga) Init(process *ServerProcess, args ...etf.Term) error

+ func (gs *Saga) SetMaxTransactions(process Process, max uint) error

+ type SagaBehavior interface

+ HandleJobFailed func(process *SagaProcess, id SagaTransactionID, from SagaJobID, reason string) SagaStatus

+ HandleJobInterim func(process *SagaProcess, id SagaTransactionID, from SagaJobID, ...) SagaStatus

+ HandleJobResult func(process *SagaProcess, id SagaTransactionID, from SagaJobID, result interface{}) SagaStatus

+ HandleSagaCall func(process *SagaProcess, from ServerFrom, message etf.Term) (etf.Term, ServerStatus)

+ HandleSagaCast func(process *SagaProcess, message etf.Term) ServerStatus

+ HandleSagaDirect func(process *SagaProcess, ref etf.Ref, message interface{}) (interface{}, DirectStatus)

+ HandleSagaInfo func(process *SagaProcess, message etf.Term) ServerStatus

+ HandleTxCancel func(process *SagaProcess, id SagaTransactionID, reason string) SagaStatus

+ HandleTxCommit func(process *SagaProcess, id SagaTransactionID, final interface{}) SagaStatus

+ HandleTxDone func(process *SagaProcess, id SagaTransactionID, result interface{}) (interface{}, SagaStatus)

+ HandleTxInterim func(process *SagaProcess, id SagaTransactionID, from SagaNextID, ...) SagaStatus

+ HandleTxNew func(process *SagaProcess, id SagaTransactionID, value interface{}) SagaStatus

+ HandleTxResult func(process *SagaProcess, id SagaTransactionID, from SagaNextID, ...) SagaStatus

+ InitSaga func(process *SagaProcess, args ...etf.Term) (SagaOptions, error)

+ type SagaJob struct

+ ID SagaJobID

+ TransactionID SagaTransactionID

+ Value interface{}

+ type SagaJobID etf.Ref

+ func (id SagaJobID) String() string

+ type SagaJobOptions struct

+ Timeout uint

+ type SagaNext struct

+ Saga interface{}

+ Timeout uint

+ TrapCancel bool

+ Value interface{}

+ type SagaNextID etf.Ref

+ func (id SagaNextID) String() string

+ type SagaOptions struct

+ MaxTransactions uint

+ Worker SagaWorkerBehavior

+ type SagaProcess struct

+ func (sp *SagaProcess) CancelJob(id SagaTransactionID, job SagaJobID, reason string) error

+ func (sp *SagaProcess) CancelTransaction(id SagaTransactionID, reason string) error

+ func (sp *SagaProcess) Next(id SagaTransactionID, next SagaNext) (SagaNextID, error)

+ func (sp *SagaProcess) SendInterim(id SagaTransactionID, interim interface{}) error

+ func (sp *SagaProcess) SendResult(id SagaTransactionID, result interface{}) error

+ func (sp *SagaProcess) StartJob(id SagaTransactionID, options SagaJobOptions, value interface{}) (SagaJobID, error)

+ func (sp *SagaProcess) StartTransaction(options SagaTransactionOptions, value interface{}) SagaTransactionID

+ type SagaStatus error

+ type SagaTransaction struct

+ type SagaTransactionID etf.Ref

+ func (id SagaTransactionID) String() string

+ type SagaTransactionOptions struct

+ HopLimit uint

+ Lifespan uint

+ TwoPhaseCommit bool

+ type SagaWorker struct

+ func (w *SagaWorker) HandleCall(process *ServerProcess, from ServerFrom, message etf.Term) (etf.Term, ServerStatus)

+ func (w *SagaWorker) HandleCast(process *ServerProcess, message etf.Term) ServerStatus

+ func (w *SagaWorker) HandleDirect(process *ServerProcess, ref etf.Ref, message interface{}) (interface{}, DirectStatus)

+ func (w *SagaWorker) HandleInfo(process *ServerProcess, message etf.Term) ServerStatus

+ func (w *SagaWorker) HandleJobCommit(process *SagaWorkerProcess, final interface{})

+ func (w *SagaWorker) HandleWorkerCall(process *SagaWorkerProcess, from ServerFrom, message etf.Term) (etf.Term, ServerStatus)

+ func (w *SagaWorker) HandleWorkerCast(process *SagaWorkerProcess, message etf.Term) ServerStatus

+ func (w *SagaWorker) HandleWorkerDirect(process *SagaWorkerProcess, ref etf.Ref, message interface{}) (interface{}, DirectStatus)

+ func (w *SagaWorker) HandleWorkerInfo(process *SagaWorkerProcess, message etf.Term) ServerStatus

+ func (w *SagaWorker) HandleWorkerTerminate(process *SagaWorkerProcess, reason string)

+ func (w *SagaWorker) Init(process *ServerProcess, args ...etf.Term) error

+ func (w *SagaWorker) Terminate(process *ServerProcess, reason string)

+ type SagaWorkerBehavior interface

+ HandleJobCancel func(process *SagaWorkerProcess, reason string)

+ HandleJobCommit func(process *SagaWorkerProcess, final interface{})

+ HandleJobStart func(process *SagaWorkerProcess, job SagaJob) error

+ HandleWorkerCall func(process *SagaWorkerProcess, from ServerFrom, message etf.Term) (etf.Term, ServerStatus)

+ HandleWorkerCast func(process *SagaWorkerProcess, message etf.Term) ServerStatus

+ HandleWorkerDirect func(process *SagaWorkerProcess, ref etf.Ref, message interface{}) (interface{}, DirectStatus)

+ HandleWorkerInfo func(process *SagaWorkerProcess, message etf.Term) ServerStatus

+ HandleWorkerTerminate func(process *SagaWorkerProcess, reason string)

+ type SagaWorkerProcess struct

+ func (wp *SagaWorkerProcess) SendInterim(interim interface{}) error

+ func (wp *SagaWorkerProcess) SendResult(result interface{}) error

+ type Server struct

+ func (gs *Server) HandleCall(process *ServerProcess, from ServerFrom, message etf.Term) (etf.Term, ServerStatus)

+ func (gs *Server) HandleCast(process *ServerProcess, message etf.Term) ServerStatus

+ func (gs *Server) HandleDirect(process *ServerProcess, ref etf.Ref, message interface{}) (interface{}, DirectStatus)

+ func (gs *Server) HandleInfo(process *ServerProcess, message etf.Term) ServerStatus

+ func (gs *Server) Init(process *ServerProcess, args ...etf.Term) error

+ func (gs *Server) ProcessInit(p Process, args ...etf.Term) (ProcessState, error)

+ func (gs *Server) ProcessLoop(ps ProcessState, started chan<- bool) string

+ func (gs *Server) Terminate(process *ServerProcess, reason string)

+ type ServerBehavior interface

+ HandleCall func(process *ServerProcess, from ServerFrom, message etf.Term) (etf.Term, ServerStatus)

+ HandleCast func(process *ServerProcess, message etf.Term) ServerStatus

+ HandleDirect func(process *ServerProcess, ref etf.Ref, message interface{}) (interface{}, DirectStatus)

+ HandleInfo func(process *ServerProcess, message etf.Term) ServerStatus

+ Init func(process *ServerProcess, args ...etf.Term) error

+ Terminate func(process *ServerProcess, reason string)

+ type ServerFrom struct

+ Pid etf.Pid

+ Ref etf.Ref

+ ReplyByAlias bool

+ type ServerProcess struct

+ func (sp *ServerProcess) Call(to interface{}, message etf.Term) (etf.Term, error)

+ func (sp *ServerProcess) CallRPC(node, module, function string, args ...etf.Term) (etf.Term, error)

+ func (sp *ServerProcess) CallRPCWithTimeout(timeout int, node, module, function string, args ...etf.Term) (etf.Term, error)

+ func (sp *ServerProcess) CallWithTimeout(to interface{}, message etf.Term, timeout int) (etf.Term, error)

+ func (sp *ServerProcess) Cast(to interface{}, message etf.Term) error

+ func (sp *ServerProcess) CastAfter(to interface{}, message etf.Term, after time.Duration) CancelFunc

+ func (sp *ServerProcess) CastRPC(node, module, function string, args ...etf.Term) error

+ func (sp *ServerProcess) MessageCounter() uint64

+ func (sp *ServerProcess) Reply(ref etf.Ref, reply etf.Term, err error) error

+ func (sp *ServerProcess) SendReply(from ServerFrom, reply etf.Term) error

+ type ServerStatus error

+ func ServerStatusStopWithReason(s string) ServerStatus

+ type Stage struct

+ func (gst *Stage) HandleCall(process *ServerProcess, from ServerFrom, message etf.Term) (etf.Term, ServerStatus)

+ func (gst *Stage) HandleCancel(process *StageProcess, subscription StageSubscription, reason string) StageStatus

+ func (gst *Stage) HandleCanceled(process *StageProcess, subscription StageSubscription, reason string) StageStatus

+ func (gst *Stage) HandleCast(process *ServerProcess, message etf.Term) ServerStatus

+ func (gst *Stage) HandleDemand(process *StageProcess, subscription StageSubscription, count uint) (etf.List, StageStatus)

+ func (gst *Stage) HandleDirect(process *ServerProcess, ref etf.Ref, message interface{}) (interface{}, DirectStatus)

+ func (gst *Stage) HandleEvents(process *StageProcess, subscription StageSubscription, events etf.List) StageStatus

+ func (gst *Stage) HandleInfo(process *ServerProcess, message etf.Term) ServerStatus

+ func (gst *Stage) HandleStageCall(process *StageProcess, from ServerFrom, message etf.Term) (etf.Term, ServerStatus)

+ func (gst *Stage) HandleStageCast(process *StageProcess, message etf.Term) ServerStatus

+ func (gst *Stage) HandleStageDirect(process *StageProcess, ref etf.Ref, message interface{}) (interface{}, DirectStatus)

+ func (gst *Stage) HandleStageInfo(process *StageProcess, message etf.Term) ServerStatus

+ func (gst *Stage) HandleStageTerminate(process *StageProcess, reason string)

+ func (gst *Stage) HandleSubscribe(process *StageProcess, subscription StageSubscription, ...) StageStatus

+ func (gst *Stage) HandleSubscribed(process *StageProcess, subscription StageSubscription, ...) (bool, StageStatus)

+ func (gst *Stage) Init(process *ServerProcess, args ...etf.Term) error

+ func (gst *Stage) InitStage(process *StageProcess, args ...etf.Term) error

+ func (gst *Stage) Terminate(process *ServerProcess, reason string)

+ func (s *Stage) SetCancelMode(p Process, subscription StageSubscription, cancel StageCancelMode) error

+ type StageBehavior interface

+ HandleCancel func(process *StageProcess, subscription StageSubscription, reason string) StageStatus

+ HandleCanceled func(process *StageProcess, subscription StageSubscription, reason string) StageStatus

+ HandleDemand func(process *StageProcess, subscription StageSubscription, count uint) (etf.List, StageStatus)

+ HandleEvents func(process *StageProcess, subscription StageSubscription, events etf.List) StageStatus

+ HandleStageCall func(process *StageProcess, from ServerFrom, message etf.Term) (etf.Term, ServerStatus)

+ HandleStageCast func(process *StageProcess, message etf.Term) ServerStatus

+ HandleStageDirect func(process *StageProcess, ref etf.Ref, message interface{}) (interface{}, DirectStatus)

+ HandleStageInfo func(process *StageProcess, message etf.Term) ServerStatus

+ HandleStageTerminate func(process *StageProcess, reason string)

+ HandleSubscribe func(process *StageProcess, subscription StageSubscription, ...) StageStatus

+ HandleSubscribed func(process *StageProcess, subscription StageSubscription, ...) (bool, StageStatus)

+ InitStage func(process *StageProcess, args ...etf.Term) (StageOptions, error)

+ type StageCancelMode uint

+ const StageCancelPermanent

+ const StageCancelTemporary

+ const StageCancelTransient

+ type StageCancelReason struct

+ Cancel string

+ Reason string

+ type StageDispatchItem struct

+ type StageDispatcher int

+ type StageDispatcherBehavior interface

+ Ask func(state interface{}, subscription StageSubscription, count uint)

+ Cancel func(state interface{}, subscription StageSubscription)

+ Dispatch func(state interface{}, events etf.List) []StageDispatchItem

+ Init func(opts StageOptions) (state interface{})

+ Subscribe func(state interface{}, subscription StageSubscription, opts StageSubscribeOptions) error

+ func CreateStageDispatcherBroadcast() StageDispatcherBehavior

+ func CreateStageDispatcherDemand() StageDispatcherBehavior

+ func CreateStageDispatcherPartition(n uint, hash func(etf.Term) int) StageDispatcherBehavior

+ type StageOptions struct

+ BufferKeepLast bool

+ BufferSize uint

+ DisableDemandHandle bool

+ Dispatcher StageDispatcherBehavior

+ type StageProcess struct

+ func (p *StageProcess) Ask(subscription StageSubscription, count uint) error

+ func (p *StageProcess) AutoDemand(subscription StageSubscription) (bool, error)

+ func (p *StageProcess) Cancel(subscription StageSubscription, reason string) error

+ func (p *StageProcess) CancelMode(subscription StageSubscription) (StageCancelMode, error)

+ func (p *StageProcess) DemandHandle() bool

+ func (p *StageProcess) SendEvents(events etf.List) error

+ func (p *StageProcess) SetAutoDemand(subscription StageSubscription, autodemand bool) error

+ func (p *StageProcess) SetCancelMode(subscription StageSubscription, mode StageCancelMode) error

+ func (p *StageProcess) SetDemandHandle(enable bool)

+ func (p *StageProcess) Subscribe(producer etf.Term, opts StageSubscribeOptions) (StageSubscription, error)

+ type StageStatus error

+ var StageStatusNotAProducer StageStatus = fmt.Errorf("not a producer")

+ var StageStatusOK StageStatus = nil

+ var StageStatusStop StageStatus = fmt.Errorf("stop")

+ var StageStatusUnsupported StageStatus = fmt.Errorf("unsupported")

+ type StageSubscribeOptions struct

+ Cancel StageCancelMode

+ Extra etf.Term

+ ManualDemand bool

+ MaxDemand uint

+ MinDemand uint

+ Partition uint

+ type StageSubscription struct

+ ID etf.Ref

+ Pid etf.Pid

+ type Supervisor struct

+ func (sv *Supervisor) ProcessInit(p Process, args ...etf.Term) (ProcessState, error)

+ func (sv *Supervisor) ProcessLoop(ps ProcessState, started chan<- bool) string

+ func (sv *Supervisor) StartChild(supervisor Process, name string, args ...etf.Term) (Process, error)

+ type SupervisorBehavior interface

+ Init func(args ...etf.Term) (SupervisorSpec, error)

+ type SupervisorChildSpec struct

+ Args []etf.Term

+ Child ProcessBehavior

+ Name string

+ Options ProcessOptions

+ type SupervisorSpec struct

+ Children []SupervisorChildSpec

+ Name string

+ Strategy SupervisorStrategy

+ type SupervisorStrategy struct

+ Intensity uint16

+ Period uint16

+ Restart SupervisorStrategyRestart

+ Type SupervisorStrategyType

+ type SupervisorStrategyRestart = string

+ type SupervisorStrategyType = string

+ type TCP struct

+ func (tcp *TCP) HandleCall(process *ServerProcess, from ServerFrom, message etf.Term) (etf.Term, ServerStatus)

+ func (tcp *TCP) HandleCast(process *ServerProcess, message etf.Term) ServerStatus

+ func (tcp *TCP) HandleInfo(process *ServerProcess, message etf.Term) ServerStatus

+ func (tcp *TCP) HandleTCPCall(process *TCPProcess, from ServerFrom, message etf.Term) (etf.Term, ServerStatus)

+ func (tcp *TCP) HandleTCPCast(process *TCPProcess, message etf.Term) ServerStatus

+ func (tcp *TCP) HandleTCPInfo(process *TCPProcess, message etf.Term) ServerStatus

+ func (tcp *TCP) HandleTCPTerminate(process *TCPProcess, reason string)

+ func (tcp *TCP) Init(process *ServerProcess, args ...etf.Term) error

+ func (tcp *TCP) Terminate(process *ServerProcess, reason string)

+ type TCPBehavior interface

+ HandleTCPCall func(process *TCPProcess, from ServerFrom, message etf.Term) (etf.Term, ServerStatus)

+ HandleTCPCast func(process *TCPProcess, message etf.Term) ServerStatus

+ HandleTCPInfo func(process *TCPProcess, message etf.Term) ServerStatus

+ HandleTCPTerminate func(process *TCPProcess, reason string)

+ InitTCP func(process *TCPProcess, args ...etf.Term) (TCPOptions, error)

+ type TCPConnection struct

+ Addr net.Addr

+ Socket io.Writer

+ State interface{}

+ type TCPHandler struct

+ func (tcph *TCPHandler) HandleCall(process *ServerProcess, from ServerFrom, message etf.Term) (etf.Term, ServerStatus)

+ func (tcph *TCPHandler) HandleCast(process *ServerProcess, message etf.Term) ServerStatus

+ func (tcph *TCPHandler) HandleConnect(process *TCPHandlerProcess, conn *TCPConnection) TCPHandlerStatus

+ func (tcph *TCPHandler) HandleDirect(process *ServerProcess, ref etf.Ref, message interface{}) (interface{}, DirectStatus)

+ func (tcph *TCPHandler) HandleDisconnect(process *TCPHandlerProcess, conn *TCPConnection)

+ func (tcph *TCPHandler) HandleInfo(process *ServerProcess, message etf.Term) ServerStatus

+ func (tcph *TCPHandler) HandleTCPHandlerCall(process *TCPHandlerProcess, from ServerFrom, message etf.Term) (etf.Term, ServerStatus)

+ func (tcph *TCPHandler) HandleTCPHandlerCast(process *TCPHandlerProcess, message etf.Term) ServerStatus

+ func (tcph *TCPHandler) HandleTCPHandlerInfo(process *TCPHandlerProcess, message etf.Term) ServerStatus

+ func (tcph *TCPHandler) HandleTCPHandlerTerminate(process *TCPHandlerProcess, reason string)

+ func (tcph *TCPHandler) HandleTimeout(process *TCPHandlerProcess, conn *TCPConnection) TCPHandlerStatus

+ func (tcph *TCPHandler) Init(process *ServerProcess, args ...etf.Term) error

+ func (tcph *TCPHandler) Terminate(process *ServerProcess, reason string)

+ type TCPHandlerBehavior interface

+ HandleConnect func(process *TCPHandlerProcess, conn *TCPConnection) TCPHandlerStatus

+ HandleDisconnect func(process *TCPHandlerProcess, conn *TCPConnection)

+ HandlePacket func(process *TCPHandlerProcess, packet []byte, conn *TCPConnection) (int, int, TCPHandlerStatus)

+ HandleTCPHandlerCall func(process *TCPHandlerProcess, from ServerFrom, message etf.Term) (etf.Term, ServerStatus)

+ HandleTCPHandlerCast func(process *TCPHandlerProcess, message etf.Term) ServerStatus

+ HandleTCPHandlerInfo func(process *TCPHandlerProcess, message etf.Term) ServerStatus

+ HandleTCPHandlerTerminate func(process *TCPHandlerProcess, reason string)

+ HandleTimeout func(process *TCPHandlerProcess, conn *TCPConnection) TCPHandlerStatus

+ type TCPHandlerProcess struct

+ func (tcpp *TCPHandlerProcess) SetTrapExit(trap bool)

+ type TCPHandlerStatus error

+ var TCPHandlerStatusClose TCPHandlerStatus = fmt.Errorf("close")

+ var TCPHandlerStatusOK TCPHandlerStatus = nil

+ type TCPOptions struct

+ DeadlineTimeout int

+ ExtraHandlers bool

+ Handler TCPHandlerBehavior

+ Host string

+ IdleTimeout int

+ KeepAlivePeriod int

+ MaxPacketSize int

+ NumHandlers int

+ Port uint16

+ QueueLength int

+ TLS *tls.Config

+ type TCPProcess struct

+ type TCPStatus error

+ var TCPStatusOK TCPStatus

+ var TCPStatusStop TCPStatus = fmt.Errorf("stop")

+ type UDP struct

+ func (udp *UDP) HandleCall(process *ServerProcess, from ServerFrom, message etf.Term) (etf.Term, ServerStatus)

+ func (udp *UDP) HandleCast(process *ServerProcess, message etf.Term) ServerStatus

+ func (udp *UDP) HandleInfo(process *ServerProcess, message etf.Term) ServerStatus

+ func (udp *UDP) HandleUDPCall(process *UDPProcess, from ServerFrom, message etf.Term) (etf.Term, ServerStatus)

+ func (udp *UDP) HandleUDPCast(process *UDPProcess, message etf.Term) ServerStatus

+ func (udp *UDP) HandleUDPInfo(process *UDPProcess, message etf.Term) ServerStatus

+ func (udp *UDP) HandleUDPTerminate(process *UDPProcess, reason string)

+ func (udp *UDP) Init(process *ServerProcess, args ...etf.Term) error

+ func (udp *UDP) Terminate(process *ServerProcess, reason string)

+ type UDPBehavior interface

+ HandleUDPCall func(process *UDPProcess, from ServerFrom, message etf.Term) (etf.Term, ServerStatus)

+ HandleUDPCast func(process *UDPProcess, message etf.Term) ServerStatus

+ HandleUDPInfo func(process *UDPProcess, message etf.Term) ServerStatus

+ HandleUDPTerminate func(process *UDPProcess, reason string)

+ InitUDP func(process *UDPProcess, args ...etf.Term) (UDPOptions, error)

+ type UDPHandler struct

+ func (udph *UDPHandler) HandleCall(process *ServerProcess, from ServerFrom, message etf.Term) (etf.Term, ServerStatus)

+ func (udph *UDPHandler) HandleCast(process *ServerProcess, message etf.Term) ServerStatus

+ func (udph *UDPHandler) HandleInfo(process *ServerProcess, message etf.Term) ServerStatus

+ func (udph *UDPHandler) HandleTimeout(process *UDPHandlerProcess)

+ func (udph *UDPHandler) HandleUDPHandlerCall(process *UDPHandlerProcess, from ServerFrom, message etf.Term) (etf.Term, ServerStatus)

+ func (udph *UDPHandler) HandleUDPHandlerCast(process *UDPHandlerProcess, message etf.Term) ServerStatus

+ func (udph *UDPHandler) HandleUDPHandlerInfo(process *UDPHandlerProcess, message etf.Term) ServerStatus

+ func (udph *UDPHandler) HandleUDPHandlerTerminate(process *UDPHandlerProcess, reason string)

+ func (udph *UDPHandler) Init(process *ServerProcess, args ...etf.Term) error

+ func (udph *UDPHandler) Terminate(process *ServerProcess, reason string)

+ type UDPHandlerBehavior interface

+ HandlePacket func(process *UDPHandlerProcess, data []byte, packet UDPPacket)

+ HandleTimeout func(process *UDPHandlerProcess)

+ HandleUDPHandlerCall func(process *UDPHandlerProcess, from ServerFrom, message etf.Term) (etf.Term, ServerStatus)

+ HandleUDPHandlerCast func(process *UDPHandlerProcess, message etf.Term) ServerStatus

+ HandleUDPHandlerInfo func(process *UDPHandlerProcess, message etf.Term) ServerStatus

+ HandleUDPHandlerTerminate func(process *UDPHandlerProcess, reason string)

+ type UDPHandlerProcess struct

+ func (udpp *UDPHandlerProcess) SetTrapExit(trap bool)

+ type UDPOptions struct

+ DeadlineTimeout int

+ ExtraHandlers bool

+ Handler UDPHandlerBehavior

+ Host string

+ IdleTimeout int

+ MaxPacketSize int

+ NumHandlers int

+ Port uint16

+ QueueLength int

+ type UDPPacket struct

+ Addr net.Addr

+ Socket io.Writer

+ type UDPProcess struct

+ type UDPStatus error

+ var UDPStatusOK UDPStatus

+ var UDPStatusStop UDPStatus = fmt.Errorf("stop")

+ type Web struct

+ func (web *Web) HandleCall(process *ServerProcess, from ServerFrom, message etf.Term) (etf.Term, ServerStatus)

+ func (web *Web) HandleCast(process *ServerProcess, message etf.Term) ServerStatus

+ func (web *Web) HandleDirect(process *ServerProcess, ref etf.Ref, message interface{}) (interface{}, DirectStatus)

+ func (web *Web) HandleInfo(process *ServerProcess, message etf.Term) ServerStatus

+ func (web *Web) HandleWebCall(process *WebProcess, from ServerFrom, message etf.Term) (etf.Term, ServerStatus)

+ func (web *Web) HandleWebCast(process *WebProcess, message etf.Term) ServerStatus

+ func (web *Web) HandleWebInfo(process *WebProcess, message etf.Term) ServerStatus

+ func (web *Web) Init(process *ServerProcess, args ...etf.Term) error

+ func (web *Web) Terminate(process *ServerProcess, reason string)

+ type WebBehavior interface

+ HandleWebCall func(process *WebProcess, from ServerFrom, message etf.Term) (etf.Term, ServerStatus)

+ HandleWebCast func(process *WebProcess, message etf.Term) ServerStatus

+ HandleWebInfo func(process *WebProcess, message etf.Term) ServerStatus

+ InitWeb func(process *WebProcess, args ...etf.Term) (WebOptions, error)

+ type WebHandler struct

+ func (wh *WebHandler) HandleCall(process *ServerProcess, from ServerFrom, message etf.Term) (etf.Term, ServerStatus)

+ func (wh *WebHandler) HandleCast(process *ServerProcess, message etf.Term) ServerStatus

+ func (wh *WebHandler) HandleDirect(process *ServerProcess, ref etf.Ref, message interface{}) (interface{}, DirectStatus)

+ func (wh *WebHandler) HandleInfo(process *ServerProcess, message etf.Term) ServerStatus

+ func (wh *WebHandler) HandleWebHandlerCall(process *WebHandlerProcess, from ServerFrom, message etf.Term) (etf.Term, ServerStatus)

+ func (wh *WebHandler) HandleWebHandlerCast(process *WebHandlerProcess, message etf.Term) ServerStatus

+ func (wh *WebHandler) HandleWebHandlerInfo(process *WebHandlerProcess, message etf.Term) ServerStatus

+ func (wh *WebHandler) HandleWebHandlerTerminate(process *WebHandlerProcess, reason string, count int64)

+ func (wh *WebHandler) Init(process *ServerProcess, args ...etf.Term) error

+ func (wh *WebHandler) ServeHTTP(w http.ResponseWriter, r *http.Request)

+ func (wh *WebHandler) Terminate(process *ServerProcess, reason string)

+ type WebHandlerBehavior interface

+ HandleRequest func(process *WebHandlerProcess, request WebMessageRequest) WebHandlerStatus

+ HandleWebHandlerCall func(process *WebHandlerProcess, from ServerFrom, message etf.Term) (etf.Term, ServerStatus)

+ HandleWebHandlerCast func(process *WebHandlerProcess, message etf.Term) ServerStatus

+ HandleWebHandlerInfo func(process *WebHandlerProcess, message etf.Term) ServerStatus

+ HandleWebHandlerTerminate func(process *WebHandlerProcess, reason string, count int64)

+ type WebHandlerOptions struct

+ IdleTimeout int

+ NumHandlers int

+ RequestQueueLength int

+ RequestTimeout int

+ type WebHandlerProcess struct

+ func (whp *WebHandlerProcess) SetTrapExit(trap bool)

+ type WebHandlerStatus error

+ var WebHandlerStatusDone WebHandlerStatus = nil

+ var WebHandlerStatusWait WebHandlerStatus = fmt.Errorf("wait")

+ type WebMessageRequest struct

+ Ref etf.Ref

+ Request *http.Request

+ Response http.ResponseWriter

+ type WebOptions struct

+ Handler http.Handler

+ Host string

+ Port uint16

+ TLS *tls.Config

+ type WebProcess struct

+ func (wp *WebProcess) StartWebHandler(web WebHandlerBehavior, options WebHandlerOptions) http.Handler

+ type WebStatus error

+ var WebStatusOK WebStatus

+ var WebStatusStop WebStatus = fmt.Errorf("stop")

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL