lib

type Agenda = []ScheduledEvent

type Args interface{ Args() }

type ClientRequest struct {
	Id      uint64
	Request Request
}

type ClientResponse struct {
	Id       uint64   `json:"id"`
	Response Response `json:"response"`
}

type Crash struct {
	From string
	At   int
}

type CreateRunEvent struct {
	Seed          Seed
	Faults        Faults
	TickFrequency float64
	MinTimeNs     time.Duration
	MaxTimeNs     time.Duration
}

type DeploymentInfo struct {
	Reactor string          `json:"reactor"`
	Type    string          `json:"type"`
	Args    json.RawMessage `json:"args"`
}

type Event interface{ IsEvent() }

type FailSpec struct {
	EFF         int // End (time) of finite failures.
	Crashes     int // Max amount of node (permanent) crashes.
	EOT         int // End of time, for the test.
	LimitFaults int // Have a limit of how many faults may be generated, 0 is no limit
}

type Fault struct {
	Kind string
	Args FaultArgs
}

type FaultArgs interface{ FaultArgs() }

type Faults = struct {
	Faults []Fault `json:"faults"`
}

type InEvent interface{ InEvent() }

type InternalMessage struct {
	Message Message `json:"message"`
}

type Item struct {
	Name    string
	Reactor Reactor
}

type LTLResult struct {
	Result bool   `json:"result"`
	Reason string `json:"reason"`
}

type Marshaler interface {
	UnmarshalRequest(request string, input json.RawMessage, output *Request) error
	UnmarshalMessage(message string, input json.RawMessage, output *Message) error
}

type Message interface {
	MessageEvent() string
}

type MetaInfo struct {
	TestId      TestId `json:"test-id"`
	RunId       RunId  `json:"run-id"`
	LogicalTime int    `json:"logical-time"`
}

type Omission struct {
	From string
	To   string
	At   int
}

type OutEvent struct {
	To   []Receiver // Assumed to be a set.
	Args Args
}

type QueueSize struct {
	QueueSize int `json:"queue-size"`
}

type Reactor interface {
	Receive(at time.Time, from string, event InEvent) []OutEvent
	Tick(at time.Time) []OutEvent
	Timer(at time.Time) []OutEvent
	Init() []OutEvent
}

type Receiver = string

type Request interface {
	RequestEvent() string
}

type Response interface {
	ResponseEvent() string
}

type RunId struct {
	RunId int
}

type ScheduledEvent struct {
	At    time.Time
	From  string
	To    string
	Event InEvent
	Meta  MetaInfo
}

type SchedulerFault struct {
	Kind string `json:"kind"`
	From string `json:"from"`
	To   string `json:"to"`
	At   int    `json:"at"` // should be time.Time?
}

type SchedulerRequest struct {
	Command    string      `json:"command"`
	Parameters interface{} `json:"parameters"`
}

type Seed int

type TestId struct {
	TestId int
}

type TimeFromString time.Time

type TimePico time.Time

type Timer struct {
	Duration time.Duration `json:"duration"`
}

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