Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

types

package

Go to main page

Versions in this module

v0

v0.1.4

Jan 25, 2022

v0.1.3

Jan 18, 2022

v0.1.2

Jan 17, 2022

v0.1.1

Jan 16, 2022

v0.1.0

Jan 12, 2022

Changes in this version

+ var DefaultSubsChSize = 10

+ var ErrBadParser = errors.New("bad parser")

+ var ErrDuplicateSubs = errors.New("duplicate subscriber")

+ var ErrNoData = errors.New("no data in message")

+ var ErrNoSubs = errors.New("subscriber does not exist")

+ var ErrReplicaStoreFull = errors.New("replica store is full")

+ type AnnotatedEventDAG struct

+ func NewAnnotatedEventDag(d *EventDAG) *AnnotatedEventDAG

+ func (a *AnnotatedEventDAG) AddEvent(e *Event, parents []*Event)

+ func (a *AnnotatedEventDAG) Check() bool

+ func (a *AnnotatedEventDAG) SetFrameOfReference(e *Event) bool

+ type BaseService struct

+ Logger *log.Logger

+ func NewBaseService(name string, parentLogger *log.Logger) *BaseService

+ func (b *BaseService) Name() string

+ func (b *BaseService) QuitCh() <-chan struct{}

+ func (b *BaseService) Running() bool

+ func (b *BaseService) StartRunning()

+ func (b *BaseService) StopRunning()

+ type ClockValue []float64

+ func (c ClockValue) Eq(other ClockValue) bool

+ func (c ClockValue) Lt(other ClockValue) bool

+ type Clonable interface

+ Clone func() Clonable

+ type Event struct

+ ClockValue ClockValue

+ ID uint64

+ Replica ReplicaID

+ Timestamp int64

+ Type EventType

+ TypeS string

+ func NewEvent(replica ReplicaID, t EventType, ts string, id uint64, time int64) *Event

+ func (e *Event) Clone() Clonable

+ func (e *Event) IsMessageReceive() bool

+ func (e *Event) IsMessageSend() bool

+ func (e *Event) IsTimeoutEnd() bool

+ func (e *Event) IsTimeoutStart() bool

+ func (e *Event) Lt(other *Event) bool

+ func (e *Event) MessageID() (string, bool)

+ func (e *Event) Timeout() (*ReplicaTimeout, bool)

+ type EventDAG struct

+ func NewEventDag() *EventDAG

+ func (d *EventDAG) AddDirty(e *Event, parents []*Event)

+ func (d *EventDAG) AddNode(e *Event, parents []*Event)

+ func (d *EventDAG) Clean()

+ func (d *EventDAG) Clone() *EventDAG

+ func (d *EventDAG) GetLatestNode(e *Event) (*Event, bool)

+ func (d *EventDAG) GetNode(eid uint64) (*EventNode, bool)

+ func (d *EventDAG) GetReceiveNode(e *Event) (*Event, bool)

+ func (d *EventDAG) GetSendNode(e *Event) (*Event, bool)

+ func (d *EventDAG) GetTimeoutEnd(e *Event) (*Event, bool)

+ func (d *EventDAG) GetTimeoutStart(e *Event) (*Event, bool)

+ func (d *EventDAG) MarshalJSON() ([]byte, error)

+ type EventNode struct

+ Children *EventNodeSet

+ Event *Event

+ Parents *EventNodeSet

+ func NewEventNode(e *Event) *EventNode

+ func (n *EventNode) AddParents(parents []*EventNode)

+ func (n *EventNode) Clone() *EventNode

+ func (n *EventNode) GetNext() uint64

+ func (n *EventNode) GetPrev() uint64

+ func (n *EventNode) IsDirty() bool

+ func (n *EventNode) MarkClean()

+ func (n *EventNode) MarkDirty()

+ func (n *EventNode) SetNext(next uint64)

+ func (n *EventNode) SetPrev(prev uint64)

+ type EventNodeSet struct

+ func NewEventNodeSet() *EventNodeSet

+ func (d *EventNodeSet) Add(nid uint64)

+ func (d *EventNodeSet) Clone() *EventNodeSet

+ func (d *EventNodeSet) Exists(nid uint64) bool

+ func (d *EventNodeSet) Iter() []uint64

+ func (d *EventNodeSet) MarshalJSON() ([]byte, error)

+ func (d *EventNodeSet) Size() int

+ type EventNodeTag struct

+ Event *Event

+ Max *IntW

+ Min *IntW

+ Type EventNodeTagType

+ func NewEventNodeTag(e *Event) *EventNodeTag

+ type EventNodeTagType = string

+ var MessageReceive EventNodeTagType = "MessageReceive"

+ var MessageSend EventNodeTagType = "MessageSend"

+ var Other EventNodeTagType = "Other"

+ var TimeoutEnd EventNodeTagType = "TimeoutEnd"

+ var TimeoutStart EventNodeTagType = "TimeoutStart"

+ type EventQueue struct

+ func NewEventQueue(logger *log.Logger) *EventQueue

+ func (q *EventQueue) Add(m *Event)

+ func (q *EventQueue) Flush()

+ func (q *EventQueue) Restart() error

+ func (q *EventQueue) Start() error

+ func (q *EventQueue) Stop() error

+ func (q *EventQueue) Subscribe(label string) chan *Event

+ type EventType interface

+ Clone func() EventType

+ String func() string

+ Type func() string

+ type GenericEventType struct

+ Params map[string]string

+ T string

+ func NewGenericEventType(params map[string]string, t string) *GenericEventType

+ func (g *GenericEventType) Clone() EventType

+ func (g *GenericEventType) String() string

+ func (g *GenericEventType) Type() string

+ type GlobalClock struct

+ func NewGlobalClock(dag *EventDAG, messageStore *MessageStore) *GlobalClock

+ type IntW struct

+ func NewIntW() *IntW

+ func (i *IntW) Set(v int)

+ func (i *IntW) Undefined() bool

+ type Message struct

+ Data []byte

+ From ReplicaID

+ ID string

+ Intercept bool

+ ParsedMessage ParsedMessage

+ Repr string

+ To ReplicaID

+ Type string

+ func (m *Message) Clone() Clonable

+ func (m *Message) Parse(parser MessageParser) error

+ type MessageParser interface

+ Parse func([]byte) (ParsedMessage, error)

+ type MessageQueue struct

+ func NewMessageQueue(logger *log.Logger) *MessageQueue

+ func (q *MessageQueue) Add(m *Message)

+ func (q *MessageQueue) Disable()

+ func (q *MessageQueue) Enable()

+ func (q *MessageQueue) Flush()

+ func (q *MessageQueue) Pop() (*Message, bool)

+ func (q *MessageQueue) Restart() error

+ func (q *MessageQueue) Start() error

+ func (q *MessageQueue) Stop() error

+ func (q *MessageQueue) Subscribe(label string) chan *Message

+ type MessageReceiveEventType struct

+ MessageID string

+ func NewMessageReceiveEventType(messageID string) *MessageReceiveEventType

+ func (r *MessageReceiveEventType) Clone() EventType

+ func (r *MessageReceiveEventType) String() string

+ func (r *MessageReceiveEventType) Type() string

+ type MessageSendEventType struct

+ MessageID string

+ func NewMessageSendEventType(messageID string) *MessageSendEventType

+ func (s *MessageSendEventType) Clone() EventType

+ func (s *MessageSendEventType) String() string

+ func (s *MessageSendEventType) Type() string

+ type MessageStore struct

+ func NewMessageStore() *MessageStore

+ func (s *MessageStore) Add(m *Message) *Message

+ func (s *MessageStore) Exists(id string) bool

+ func (s *MessageStore) Get(id string) (*Message, bool)

+ func (s *MessageStore) Iter() []*Message

+ func (s *MessageStore) Remove(id string) *Message

+ func (s *MessageStore) RemoveAll()

+ func (s *MessageStore) Size() int

+ type ParsedMessage interface

+ Clone func() ParsedMessage

+ Marshal func() ([]byte, error)

+ String func() string

+ type Replica struct

+ Addr string

+ ID ReplicaID

+ Info map[string]interface{}

+ Ready bool

+ type ReplicaID string

+ type ReplicaLog struct

+ Message string

+ Params map[string]string

+ Replica ReplicaID

+ Timestamp int64

+ func (l *ReplicaLog) Clone() Clonable

+ type ReplicaLogQueue struct

+ func NewReplicaLogQueue(logger *log.Logger) *ReplicaLogQueue

+ func (q *ReplicaLogQueue) Add(log *ReplicaLog)

+ func (q *ReplicaLogQueue) Flush()

+ func (q *ReplicaLogQueue) Start()

+ func (q *ReplicaLogQueue) Stop()

+ func (q *ReplicaLogQueue) Subscribe(label string) chan *ReplicaLog

+ type ReplicaLogStore struct

+ func NewReplicaLogStore() *ReplicaLogStore

+ func (store *ReplicaLogStore) Add(log *ReplicaLog)

+ func (store *ReplicaLogStore) GetLogs(replica ReplicaID, from, to int) ([]*ReplicaLog, int)

+ func (store *ReplicaLogStore) Reset()

+ type ReplicaState struct

+ Replica ReplicaID

+ State string

+ Timestamp int64

+ type ReplicaStateStore struct

+ func NewReplicaStateStore() *ReplicaStateStore

+ type ReplicaStore struct

+ func NewReplicaStore(size int) *ReplicaStore

+ func (s *ReplicaStore) Add(p *Replica)

+ func (s *ReplicaStore) Cap() int

+ func (s *ReplicaStore) Count() int

+ func (s *ReplicaStore) Get(id ReplicaID) (p *Replica, ok bool)

+ func (s *ReplicaStore) Iter() []*Replica

+ func (s *ReplicaStore) NumReady() int

+ func (s *ReplicaStore) ResetReady()

+ type ReplicaTimeout struct

+ Duration time.Duration

+ Replica ReplicaID

+ Type string

+ func TimeoutFromParams(replica ReplicaID, params map[string]string) (*ReplicaTimeout, bool)

+ func (t *ReplicaTimeout) Eq(other *ReplicaTimeout) bool

+ func (t *ReplicaTimeout) MarshalJSON() ([]byte, error)

+ type RestartableService interface

+ Restart func() error

+ type Service interface

+ Name func() string

+ QuitCh func() <-chan struct{}

+ Running func() bool

+ Start func() error

+ Stop func() error

+ type Subscriber struct

+ Ch chan interface{}

+ type TimeoutContext struct

+ PendingReceives map[string]*Event

+ PendingTimeouts map[string]*timeoutWrapper

+ func NewTimeoutContext(d *EventDAG) *TimeoutContext

+ func (t *TimeoutContext) AddEvent(e *Event)

+ func (t *TimeoutContext) CanDeliverMessages(messages []*Message)

+ type TimeoutEndEventType struct

+ Timeout *ReplicaTimeout

+ func NewTimeoutEndEventType(timeout *ReplicaTimeout) *TimeoutEndEventType

+ func (te *TimeoutEndEventType) Clone() EventType

+ func (te *TimeoutEndEventType) String() string

+ func (te *TimeoutEndEventType) Type() string

+ type TimeoutStartEventType struct

+ Timeout *ReplicaTimeout

+ func NewTimeoutStartEventType(timeout *ReplicaTimeout) *TimeoutStartEventType

+ func (ts *TimeoutStartEventType) Clone() EventType

+ func (ts *TimeoutStartEventType) String() string

+ func (ts *TimeoutStartEventType) Type() string

+ type TimeoutStore struct

+ func NewTimeoutStore(logger *log.Logger) *TimeoutStore

+ func (s *TimeoutStore) AddTimeout(t *ReplicaTimeout)

+ func (s *TimeoutStore) Reset()

+ func (s *TimeoutStore) Start() error

+ func (s *TimeoutStore) Stop() error

+ func (s *TimeoutStore) ToDispatch() []*ReplicaTimeout