core

type ChaosKind string

type Checker interface {
	// Check a series of operations with the given model.
	// Return false or error if operations do not satisfy the model.
	Check(m Model, ops []Operation) (bool, error)

	// Name returns the unique name for the checker.
	Name() string
}

type Client interface {
	// SetUp sets up the client.
	SetUp(ctx context.Context, nodes []cluster.Node, clientNodes []cluster.ClientNode, idx int) error
	// TearDown tears down the client.
	TearDown(ctx context.Context, nodes []cluster.ClientNode, idx int) error
	// Invoke invokes a request to the database.
	// Mostly, the return Response should implement UnknownResponse interface
	Invoke(ctx context.Context, node cluster.ClientNode, r interface{}) UnknownResponse
	// NextRequest generates a request for latter Invoke.
	NextRequest() interface{}
	// DumpState the database state(also the model's state)
	DumpState(ctx context.Context) (interface{}, error)
	// Start runs self scheduled cases
	// this function will block Invoke trigger
	// if you want to schedule cases by yourself, use this function only
	Start(ctx context.Context, cfg interface{}, clientNodes []cluster.ClientNode) error
}

type ClientCreator interface {
	// Create creates the client.
	Create(node cluster.ClientNode) Client
}

type DB interface {
	// SetUp initializes the database.
	SetUp(ctx context.Context, nodes []cluster.Node, node cluster.Node) error
	// TearDown tears down the database.
	TearDown(ctx context.Context, nodes []cluster.Node, node cluster.Node) error
	// Name returns the unique name for the database
	Name() string
}

type DelayNemesisGenerator struct {
	Gen   NemesisGenerator
	Delay time.Duration
}

type Model interface {
	// Prepare the initial state of the data object.
	Prepare(state interface{})

	// Initial state of the data object.
	Init() interface{}

	// Step function for the data object. Returns whether or not the system
	// could take this step with the given inputs and outputs and also
	// returns the new state. This should not mutate the existing state.
	//
	// state must support encoding to and decoding from json.
	Step(state interface{}, input interface{}, output interface{}) (bool, interface{})

	// Equality on states.
	Equal(state1, state2 interface{}) bool

	// Name returns the unique name for the model.
	Name() string
}

type Nemesis interface {

	// Invoke executes the nemesis
	Invoke(ctx context.Context, node *cluster.Node, args ...interface{}) error
	// Recover recovers the nemesis
	Recover(ctx context.Context, node *cluster.Node, args ...interface{}) error
	// Name returns the unique name for the nemesis
	Name() string
}

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

type NemesisGenerator interface {
	// Generate generates the nemesis operation for all nodes.
	// Every node will be assigned a nemesis operation.
	Generate(nodes []cluster.Node) []*NemesisOperation
	Name() string
}

type NemesisGeneratorRecord struct {
	Name string
	Ops  []*NemesisOperation
}

type NemesisGenerators interface {
	Next() NemesisGenerator
	HasNext() bool
	// Reset resets iterator, return false if it cannot be reset
	Reset() bool
}

type NemesisOperation struct {
	Type        ChaosKind     // Nemesis name
	Node        *cluster.Node // Nemesis target node, optional if it affects
	InvokeArgs  []interface{} // Nemesis invoke args
	RecoverArgs []interface{} // Nemesis recover args

	// We have two approaches to trigger recovery
	// 1. through `RunTime`
	// 2. through `NemesisControl` WaitForRollback
	RunTime        time.Duration   // Nemesis duration time
	NemesisControl *NemesisControl // Nemesis recovery signal
}

type NoopChecker struct{}

type NoopClientCreator struct {
}

type NoopDB struct {
}

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

type Operation struct {
	Action string      `json:"action"`
	Proc   int64       `json:"proc"`
	Data   interface{} `json:"data"`
	Time   time.Time   `json:"time"`
}

type UnknownResponse interface {
	IsUnknown() bool
}