signal

type Action interface {
	// these fields are same as in Signal
	ID() string
	EntityID() string
	ArrivedTime() time.Time
	JSONMap() map[string]interface{}
	String() string

	// comparator, excluding uuid
	Equals(o Action) bool

	// triggered time (only orchestrator should call this)
	TriggeredTime() time.Time

	// set triggered time (only orchestrator should call this)
	SetTriggeredTime(time.Time)

	// in fault actions, can be nil (but not always)
	Event() Event
}

type ArrivalSignal interface {
	LoadJSONMap(map[string]interface{}) error
	SetArrivedTime(time.Time)
}

type BasicAction struct {
	BasicSignal
	// capitalized for encoding/gob
	Triggered  time.Time
	CauseEvent Event
}

type BasicEvent struct {
	BasicSignal
}

type BasicPBAction struct {
	BasicAction
}

type BasicSignal struct {
	M       map[string]interface{}
	Arrived time.Time
}

type CFunctionEvent struct {
	FunctionName      string
	FunctionEventType FunctionEventType
	// contains filtered or unexported fields
}

type Event interface {
	// these fields are same as in Signal
	ID() string
	EntityID() string
	ArrivedTime() time.Time
	JSONMap() map[string]interface{}
	String() string

	// comparator, excluding uuid
	Equals(o Event) bool

	// if deferred, the inspector is waiting for an action from the orchestrator.
	//
	// json name: "deferred"
	Deferred() bool

	// explore policy can use this hash string as a hint for semi-deterministic replaying.
	// The hint should not contain time-dependent or random things for better determinism.
	// Note that we will not support fully deterministic replaying.
	//
	// The hint can contain any character.
	//
	// json name: "replay_hint"
	ReplayHint() string

	// default positive action. can be NopAction, but cannot be nil.
	// (NopAction is used for history storage)
	DefaultAction() (Action, error)

	// default negative action. can be nil.
	DefaultFaultAction() (Action, error)
}

type EventAcceptanceAction struct {
	BasicPBAction
}

type Event_JavaSpecific_Param struct {
	Name  string
	Value string
}

type Event_JavaSpecific_StackTraceElement struct {
	LineNumber int
	ClassName  string
	MethodName string
	FileName   string
}

type FilesystemEvent struct {
	BasicEvent
}

type FilesystemFaultAction struct {
	BasicAction
}

type FilesystemOp string

type FunctionEventType int

type JavaFunctionEvent struct {
	FunctionName       string
	FunctionEventType  FunctionEventType
	ThreadName         string
	StackTraceElements []Event_JavaSpecific_StackTraceElement
	Params             []Event_JavaSpecific_Param
	// contains filtered or unexported fields
}

type LogEvent struct {
	BasicEvent
}

type NopAction struct {
	BasicAction
}

type NopEvent struct {
	BasicEvent
}

type OrchestratorSideAction interface {
	// if true, the action will not be propagated to inspectors.
	//
	// this field exists mainly for NopAction(for syslog events) and some fault actions
	OrchestratorSideOnly() bool

	// execute shell command or something else
	ExecuteOnOrchestrator() error
}

type PBAction interface {
	// can be nil, if Action.Event() does not implement PBEvent interface.
	PBResponseMessage() *pb.InspectorMsgRsp
}

type PBEvent interface {
	PBRequestMessage() *pb.InspectorMsgReq
}

type PacketEvent struct {
	BasicEvent
}

type PacketFaultAction struct {
	BasicAction
}

type ProcSetEvent struct {
	BasicEvent
}

type ProcSetSchedAction struct {
	BasicAction
}

type ShellAction struct {
	BasicAction
}

type Signal interface {
	// RFC 4122 UUID
	//
	// json name: "uuid"
	ID() string

	// Entity ID string (e.g. "zksrv1")
	//
	// json name: "entity"
	EntityID() string

	// arrived time
	//
	// for event, only orchestrator should call this.
	// for action, only inspector should call this.
	ArrivedTime() time.Time

	// JSON map. PBEvent also implements this method, mainly for MongoDB storage.
	JSONMap() map[string]interface{}

	// debug string
	String() string
}