types

package
v0.2.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Sep 21, 2022 License: MIT Imports: 9 Imported by: 12

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var (
	ErrDuplicateSubs = errors.New("duplicate subscriber")
	ErrNoSubs        = errors.New("subscriber does not exist")
	ErrNoData        = errors.New("no data in message")
	ErrBadParser     = errors.New("bad parser")

	DefaultSubsChSize = 10
)
View Source 
var (
	// ErrReplicaStoreFull is returned when more than the intended number of replicas register with the scheduler tool
	ErrReplicaStoreFull = errors.New("replica store is full")
)

Functions

func Max added in v0.2.0 

func Max[T constraints.Ordered](one, two T) T

func VarSetGet added in v0.2.0 

func VarSetGet[T any](v *VarSet, label string) (T, bool)

VarSetGet returns the value with the specified label and typecasts it

Types

type BaseService 

type BaseService struct {
	Logger *log.Logger
	// contains filtered or unexported fields
}

BaseService provides the basic nuts an bolts needed to implement a service

func NewBaseService 

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

NewBaseService instantiates BaseService

func (*BaseService) Name 

func (b *BaseService) Name() string

Name returns the name of the service

func (*BaseService) QuitCh 

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

QuitCh returns the quit channel which will be closed when the service stops running

func (*BaseService) Running 

func (b *BaseService) Running() bool

Running returns the flag

func (*BaseService) SetLogger added in v0.1.3 

func (b *BaseService) SetLogger(logger *log.Logger)

func (*BaseService) StartRunning 

func (b *BaseService) StartRunning()

StartRunning is called to set the running flag

func (*BaseService) StopRunning 

func (b *BaseService) StopRunning()

StopRunning is called to unset the running flag

type ClockValue 

type ClockValue []float64

func ZeroClock added in v0.1.1 

func ZeroClock(replicas int) ClockValue

func (ClockValue) Eq 

func (c ClockValue) Eq(other ClockValue) bool

func (ClockValue) Lt 

func (c ClockValue) Lt(other ClockValue) bool

type Clonable 

type Clonable interface {
	Clone() Clonable
}

Clonable is any type which returns a copy of itself on Clone()

type Counter added in v0.1.1 

type Counter struct {
	// contains filtered or unexported fields
}

Counter threadsafe counter

func NewCounter added in v0.1.1 

func NewCounter() *Counter

NewCounter returns a counter

func (*Counter) Incr added in v0.1.1 

func (c *Counter) Incr()

Incr increments the counter

func (*Counter) SetValue added in v0.1.1 

func (c *Counter) SetValue(v int)

SetValue sets the counter to the specified value

func (*Counter) Value added in v0.1.1 

func (c *Counter) Value() int

Value returns the counter value

type Event 

type Event struct {
	// Replica at which the event occurs
	Replica ReplicaID `json:"replica"`
	// Type of the event
	Type EventType `json:"-"`
	// TypeS is the string representation of the event
	TypeS string `json:"type"`
	// ID unique identifier assigned for every new event
	ID EventID `json:"id"`
	// Timestamp of the event
	Timestamp int64 `json:"timestamp"`
}

Event is a generic event that occurs at a replica

func NewEvent 

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

func (*Event) Clone 

func (e *Event) Clone() Clonable

Clone implements Clonable

func (*Event) IsGeneric added in v0.1.5 

func (e *Event) IsGeneric() bool

func (*Event) IsMessageReceive 

func (e *Event) IsMessageReceive() bool

func (*Event) IsMessageSend 

func (e *Event) IsMessageSend() bool

func (*Event) IsTimeoutEnd 

func (e *Event) IsTimeoutEnd() bool

func (*Event) IsTimeoutStart 

func (e *Event) IsTimeoutStart() bool

func (*Event) MessageID 

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

func (*Event) Timeout 

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

type EventDAG 

type EventDAG struct {
	// contains filtered or unexported fields
}

func NewEventDag 

func NewEventDag(replicaStore *ReplicaStore) *EventDAG

func (*EventDAG) AddNode 

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

func (*EventDAG) GetLatestNode 

func (d *EventDAG) GetLatestNode(replica ReplicaID) (*Event, bool)

func (*EventDAG) GetNode 

func (d *EventDAG) GetNode(eid EventID) (*EventNode, bool)

func (*EventDAG) MarshalJSON 

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

func (*EventDAG) Reset added in v0.1.4 

func (d *EventDAG) Reset()

type EventID added in v0.1.1 

type EventID uint64

type EventNode 

type EventNode struct {
	Event      *Event     `json:"event"`
	ClockValue ClockValue `json:"-"`

	Parents  *EventNodeSet `json:"parents"`
	Children *EventNodeSet `json:"children"`
	// contains filtered or unexported fields
}

func NewEventNode 

func NewEventNode(e *Event) *EventNode

func (*EventNode) AddParents 

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

func (*EventNode) Clone 

func (n *EventNode) Clone() *EventNode

func (*EventNode) GetNext 

func (n *EventNode) GetNext() EventID

func (*EventNode) GetPrev 

func (n *EventNode) GetPrev() EventID

func (*EventNode) Lt added in v0.1.1 

func (n *EventNode) Lt(other *EventNode) bool

func (*EventNode) SetClock added in v0.1.1 

func (n *EventNode) SetClock(cv ClockValue)

func (*EventNode) SetNext 

func (n *EventNode) SetNext(next EventID)

func (*EventNode) SetPrev 

func (n *EventNode) SetPrev(prev EventID)

type EventNodeSet 

type EventNodeSet struct {
	// contains filtered or unexported fields
}

func NewEventNodeSet 

func NewEventNodeSet() *EventNodeSet

func (*EventNodeSet) Add 

func (d *EventNodeSet) Add(nid EventID)

func (*EventNodeSet) Clone 

func (d *EventNodeSet) Clone() *EventNodeSet

func (*EventNodeSet) Exists 

func (d *EventNodeSet) Exists(nid EventID) bool

func (*EventNodeSet) Iter 

func (d *EventNodeSet) Iter() []EventID

func (*EventNodeSet) MarshalJSON 

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

func (*EventNodeSet) Size 

func (d *EventNodeSet) Size() int

type EventType 

type EventType interface {
	// Clone copies the event type
	Clone() EventType
	// Type is a unique key for that event type
	Type() string
	// String should return a string representation of the event type
	String() string
}

EventType abstract type for representing different types of events

type GenericEventType 

type GenericEventType struct {
	// Marshalled parameters
	Params map[string]string `json:"params"`
	// Type of event for reference
	// Eg: Commit
	T string `json:"type"`
}

GenericEventType is the event type published by a replica It can be specific to the algorithm that is implemented

func NewGenericEventType 

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

NewGenericEventType instantiates GenericEventType

func (*GenericEventType) Clone 

func (g *GenericEventType) Clone() EventType

Clone returns a copy of the current GenericEventType

func (*GenericEventType) String 

func (g *GenericEventType) String() string

String returns a string representation of the event type

func (*GenericEventType) Type 

func (g *GenericEventType) Type() string

Type returns a unique key for GenericEventType

type GlobalClock 

type GlobalClock struct {
	// contains filtered or unexported fields
}

func NewGlobalClock 

func NewGlobalClock(dag *EventDAG, messageStore *Map[string, *Message]) *GlobalClock

type List added in v0.1.5 

type List[V any] struct {
	// contains filtered or unexported fields
}

func NewEmptyList added in v0.1.5 

func NewEmptyList[V any]() *List[V]

func NewList added in v0.1.5 

func NewList[V any](cur []V) *List[V]

func (*List[V]) Append added in v0.1.5 

func (l *List[V]) Append(e V)

func (*List[V]) Elem added in v0.1.5 

func (l *List[V]) Elem(index int) (V, bool)

func (*List[V]) Iter added in v0.1.5 

func (l *List[V]) Iter() []V

func (*List[V]) RemoveAll added in v0.1.5 

func (l *List[V]) RemoveAll() []V

func (*List[V]) Size added in v0.1.5 

func (l *List[V]) Size() int

type Map added in v0.1.3 

type Map[T constraints.Ordered, V any] struct {
	// contains filtered or unexported fields
}

func NewMap added in v0.1.3 

func NewMap[T constraints.Ordered, V any]() *Map[T, V]

func (*Map[T, V]) Add added in v0.1.3 

func (s *Map[T, V]) Add(key T, val V)

func (*Map[T, V]) Exists added in v0.1.3 

func (s *Map[T, V]) Exists(key T) bool

func (*Map[T, V]) Get added in v0.1.3 

func (s *Map[T, V]) Get(key T) (V, bool)

func (*Map[T, V]) IterValues added in v0.1.3 

func (s *Map[T, V]) IterValues() []V

func (*Map[T, V]) Keys added in v0.2.0 

func (s *Map[T, V]) Keys() []T

func (*Map[T, V]) RandomValue added in v0.1.4 

func (s *Map[T, V]) RandomValue() (V, bool)

func (*Map[T, V]) RandomValueWithSource added in v0.1.4 

func (s *Map[T, V]) RandomValueWithSource(src rand.Source) (V, bool)

func (*Map[T, V]) Remove added in v0.1.3 

func (s *Map[T, V]) Remove(key T)

func (*Map[T, V]) RemoveAll added in v0.1.3 

func (s *Map[T, V]) RemoveAll()

func (*Map[T, V]) Size added in v0.1.3 

func (s *Map[T, V]) Size() int

func (*Map[T, V]) ToMap added in v0.1.3 

func (s *Map[T, V]) ToMap() map[T]V

type Message 

type Message struct {
	From          ReplicaID     `json:"from"`
	To            ReplicaID     `json:"to"`
	Data          []byte        `json:"data"`
	Type          string        `json:"type"`
	ID            MessageID     `json:"id"`
	Intercept     bool          `json:"intercept"`
	ParsedMessage ParsedMessage `json:"-"`
	Repr          string        `json:"repr"`
}

Message stores a message that has been intercepted between two replicas

func (*Message) Clone 

func (m *Message) Clone() Clonable

Clone to create a new Message object with the same attributes

func (*Message) Parse 

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

type MessageID added in v0.1.3 

type MessageID string

type MessageParser 

type MessageParser interface {
	Parse([]byte) (ParsedMessage, error)
}

type MessageReceiveEventType 

type MessageReceiveEventType struct {
	// MessageID is the ID of the message received
	MessageID MessageID
}

MessageReceiveEventType is the event type when a replica receives a message

func NewMessageReceiveEventType 

func NewMessageReceiveEventType(messageID string) *MessageReceiveEventType

NewMessageReceiveEventType instantiates MessageReceiveEventType

func (*MessageReceiveEventType) Clone 

func (r *MessageReceiveEventType) Clone() EventType

Clone returns a copy of the current MessageReceiveEventType

func (*MessageReceiveEventType) String 

func (r *MessageReceiveEventType) String() string

String returns a string representation of the event type

func (*MessageReceiveEventType) Type 

func (r *MessageReceiveEventType) Type() string

Type returns a unique key for MessageReceiveEventType

type MessageSendEventType 

type MessageSendEventType struct {
	// MessageID of the message that was sent
	MessageID MessageID
}

MessageSendEventType is the event type where a message is sent from the replica

func NewMessageSendEventType 

func NewMessageSendEventType(messageID string) *MessageSendEventType

NewMessageSendEventType instantiates MessageSendEventType

func (*MessageSendEventType) Clone 

func (s *MessageSendEventType) Clone() EventType

Clone returns a copy of the current MessageSendEventType

func (*MessageSendEventType) String 

func (s *MessageSendEventType) String() string

String returns a string representation of the event type

func (*MessageSendEventType) Type 

func (s *MessageSendEventType) Type() string

Type returns a unique key for MessageSendEventType

type ParsedMessage 

type ParsedMessage interface {
	String() string
	Clone() ParsedMessage
	Marshal() ([]byte, error)
}

type Queue added in v0.1.3 

type Queue[V Clonable] struct {
	*BaseService
	// contains filtered or unexported fields
}

func NewQueue added in v0.1.3 

func NewQueue[V Clonable](logger *log.Logger) *Queue[V]

NewQueue[V] returns an empty Queue[V]

func (*Queue[V]) Add added in v0.1.3 

func (q *Queue[V]) Add(m V)

Add adds a message to the queue

func (*Queue[V]) Flush added in v0.1.3 

func (q *Queue[V]) Flush()

Flush clears the queue of all messages

func (*Queue[V]) Restart added in v0.1.3 

func (q *Queue[V]) Restart() error

Restart implements Service

func (*Queue[V]) Start added in v0.1.3 

func (q *Queue[V]) Start() error

Start implements Service

func (*Queue[V]) Stop added in v0.1.3 

func (q *Queue[V]) Stop() error

Stop implements Service

func (*Queue[V]) Subscribe added in v0.1.3 

func (q *Queue[V]) Subscribe(label string) chan V

Subscribe creates and returns a channel for the subscriber with the given label

type Replica 

type Replica struct {
	ID    ReplicaID              `json:"id"`
	Ready bool                   `json:"ready"`
	Info  map[string]interface{} `json:"info"`
	Addr  string                 `json:"addr"`
	// contains filtered or unexported fields
}

Replica immutable representation of the attributes of a replica

type ReplicaID 

type ReplicaID string

ReplicaID is an identifier for the replica encoded as a string

type ReplicaLog 

type ReplicaLog struct {
	// Params is a marhsalled params of the log message
	Params map[string]string `json:"params"`
	// Message is the message that was logged
	Message string `json:"message"`
	// Timestamp of the log
	Timestamp int64 `json:"timestamp"`
	// Replica which posted the log
	Replica ReplicaID `json:"replica"`
}

ReplicaLog encapsulates a log message with the necessary attributes

func (*ReplicaLog) Clone 

func (l *ReplicaLog) Clone() Clonable

Clone implements Clonable

type ReplicaLogQueue 

type ReplicaLogQueue struct {
	*BaseService
	// contains filtered or unexported fields
}

ReplicaLogQueue is the queue of log messages

func NewReplicaLogQueue 

func NewReplicaLogQueue(logger *log.Logger) *ReplicaLogQueue

NewReplicaLogQueue instantiates ReplicaLogQueue

func (*ReplicaLogQueue) Add 

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

Add adds to the queue

func (*ReplicaLogQueue) Flush 

func (q *ReplicaLogQueue) Flush()

Flush erases the contents of the queue

func (*ReplicaLogQueue) Start 

func (q *ReplicaLogQueue) Start()

Start implements Service

func (*ReplicaLogQueue) Stop 

func (q *ReplicaLogQueue) Stop()

Stop implements Service

func (*ReplicaLogQueue) Subscribe 

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

Subscribe creates and returns a channel for the subscriber

type ReplicaLogStore 

type ReplicaLogStore struct {
	// contains filtered or unexported fields
}

ReplicaLogStore stores the logs as a map indexed by the replica ID

func NewReplicaLogStore 

func NewReplicaLogStore() *ReplicaLogStore

NewReplicaLogStore instantiates a ReplicaLogStore

func (*ReplicaLogStore) Add 

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

Add adds to the log store

func (*ReplicaLogStore) GetLogs 

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

GetLogs returns the list of logs for a replica where from <=index<to

func (*ReplicaLogStore) Reset 

func (store *ReplicaLogStore) Reset()

type ReplicaState 

type ReplicaState struct {
	State     string    `json:"state"`
	Timestamp int64     `json:"timestamp"`
	Replica   ReplicaID `json:"replica"`
}

type ReplicaStateStore 

type ReplicaStateStore struct {
	// contains filtered or unexported fields
}

func NewReplicaStateStore 

func NewReplicaStateStore() *ReplicaStateStore

type ReplicaStore 

type ReplicaStore struct {
	// contains filtered or unexported fields
}

ReplicaStore to store all replica information, thread safe

func NewReplicaStore 

func NewReplicaStore(size int) *ReplicaStore

NewReplicaStore creates an empty ReplicaStore

func (*ReplicaStore) Add 

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

Add adds or updates a replica to the store

func (*ReplicaStore) Cap 

func (s *ReplicaStore) Cap() int

Cap returns the set of replicas used for the test

func (*ReplicaStore) Count 

func (s *ReplicaStore) Count() int

Count returns the total number of replicas

func (*ReplicaStore) Get 

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

Get returns the replica and a bool indicating if it exists or not

func (*ReplicaStore) GetRandom added in v0.1.1 

func (s *ReplicaStore) GetRandom() (*Replica, bool)

func (*ReplicaStore) Iter 

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

Iter returns a list of the existing replicas

func (*ReplicaStore) NumReady 

func (s *ReplicaStore) NumReady() int

NumReady returns the number of replicas with Ready attribute set to true

func (*ReplicaStore) ResetReady 

func (s *ReplicaStore) ResetReady()

ResetReady sets the Ready attribute of all replicas to false

type ReplicaTimeout 

type ReplicaTimeout struct {
	Replica  ReplicaID     `json:"replica"`
	Type     string        `json:"type"`
	Duration time.Duration `json:"duration"`
}

func TimeoutFromParams 

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

func (*ReplicaTimeout) Eq 

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

func (*ReplicaTimeout) Key added in v0.1.3 

func (t *ReplicaTimeout) Key() string

func (*ReplicaTimeout) MarshalJSON 

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

type ReportLogs added in v0.1.3 

type ReportLogs struct {
	// contains filtered or unexported fields
}

func NewReportLogs added in v0.1.3 

func NewReportLogs() *ReportLogs

func (*ReportLogs) GetLogs added in v0.1.3 

func (r *ReportLogs) GetLogs(keyvals map[string]string, count int, from int) []*reportLog

func (*ReportLogs) Log added in v0.1.3 

func (r *ReportLogs) Log(keyvals map[string]string)

type RestartableService 

type RestartableService interface {
	Service
	// Restart restarts the service
	Restart() error
}

RestartableService is a service which can be restarted

type Service 

type Service interface {
	// Name of the service
	Name() string
	// Start to start the service
	Start() error
	// Running to indicate if the service is running
	Running() bool
	// Stop to stop the service
	Stop() error
	// Quit returns a channel which will be closed once the service stops running
	QuitCh() <-chan struct{}
	// SetLogger initializes the logger for the service
	SetLogger(*log.Logger)
}

Service is any entity which runs on a separate thread

type Set added in v0.2.0 

type Set[T constraints.Ordered] struct {
	// contains filtered or unexported fields
}

func NewSet added in v0.2.0 

func NewSet[T constraints.Ordered]() *Set[T]

func (*Set[T]) Add added in v0.2.0 

func (s *Set[T]) Add(elem T)

func (*Set[T]) Contains added in v0.2.0 

func (s *Set[T]) Contains(elem T) bool

func (*Set[T]) Iter added in v0.2.0 

func (s *Set[T]) Iter() []T

func (*Set[T]) Remove added in v0.2.0 

func (s *Set[T]) Remove(elem T)

func (*Set[T]) Size added in v0.2.0 

func (s *Set[T]) Size() int

type TimeoutEndEventType 

type TimeoutEndEventType struct {
	Timeout *ReplicaTimeout
}

func NewTimeoutEndEventType 

func NewTimeoutEndEventType(timeout *ReplicaTimeout) *TimeoutEndEventType

func (*TimeoutEndEventType) Clone 

func (te *TimeoutEndEventType) Clone() EventType

func (*TimeoutEndEventType) String 

func (te *TimeoutEndEventType) String() string

func (*TimeoutEndEventType) Type 

func (te *TimeoutEndEventType) Type() string

type TimeoutStartEventType 

type TimeoutStartEventType struct {
	Timeout *ReplicaTimeout
}

func NewTimeoutStartEventType 

func NewTimeoutStartEventType(timeout *ReplicaTimeout) *TimeoutStartEventType

func (*TimeoutStartEventType) Clone 

func (ts *TimeoutStartEventType) Clone() EventType

func (*TimeoutStartEventType) String 

func (ts *TimeoutStartEventType) String() string

func (*TimeoutStartEventType) Type 

func (ts *TimeoutStartEventType) Type() string

type VarSet added in v0.1.1 

type VarSet struct {
	// contains filtered or unexported fields
}

VarSet is a dictionary for storing auxiliary state during the execution of the testcase VarSet is stored in the context passed to actions and conditions

func NewVarSet added in v0.1.1 

func NewVarSet() *VarSet

NewVarSet instantiates Vars

func (*VarSet) Exists added in v0.1.1 

func (v *VarSet) Exists(label string) bool

Exists returns true if there is a variable of the specified key

func (*VarSet) Get added in v0.1.1 

func (v *VarSet) Get(label string) (interface{}, bool)

Get returns the value stored of the specified label the second return argument is false if the label does not exist

func (*VarSet) GetBool added in v0.1.1 

func (v *VarSet) GetBool(label string) (bool, bool)

GetBool casts the value at label (if it exists) into boolean and returns it

func (*VarSet) GetCounter added in v0.1.1 

func (v *VarSet) GetCounter(label string) (*Counter, bool)

GetCounter returns the counter at the label if it exists (nil, false) otherwise

func (*VarSet) GetInt added in v0.1.1 

func (v *VarSet) GetInt(label string) (int, bool)

GetInt casts the value at label (if it exists) into integer and returns it

func (*VarSet) GetMessageSet added in v0.1.1 

func (v *VarSet) GetMessageSet(label string) (*Map[MessageID, *Message], bool)

GetMessageSet returns the message set at label if one exists (nil, false) otherwise

func (*VarSet) GetString added in v0.1.1 

func (v *VarSet) GetString(label string) (string, bool)

GetString casts the value at label (if it exists) into string and returns it

func (*VarSet) NewMessageSet added in v0.1.1 

func (v *VarSet) NewMessageSet(label string)

NewMessageSet creates a message set at the specified label

func (*VarSet) Set added in v0.1.1 

func (v *VarSet) Set(label string, value interface{})

Set the value at the specified label

func (*VarSet) SetCounter added in v0.1.1 

func (v *VarSet) SetCounter(label string)

SetCounter sets a counter instance at the specified label with initial value 1

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.