api

type ChaosMonkeyConfig struct {
	// NodeFailure is a config for simulated node failures.
	NodeFailure *NodeFailureConfig `json:"nodeFailure"`
	// ExcludedNodes is a config for excluding certain nodes from failure.
	ExcludedNodes sets.String `json:"excludedNodes"`
}

type Config struct {
	// Name of the test case.
	Name string `json:"name"`
	// Dependencies is a list of dependencies that must be set up before steps begin
	// and torn down after test completion.
	Dependencies []*Dependency `json:"dependencies,omitempty"`
	// TODO(#1696): Clean up after removing automanagedNamespaces
	AutomanagedNamespaces int32 `json:"automanagedNamespaces,omitempty"`
	// Namespace is a structure for namespace configuration.
	Namespace NamespaceConfig `json:"namespace"`
	// Steps is a sequence of test steps executed in serial.
	Steps []*Step `json:"steps"`
	// TuningSets is a collection of tuning sets that can be used by steps.
	TuningSets []*TuningSet `json:"tuningSets"`
	// ChaosMonkey is a config for simulated component failures.
	ChaosMonkey ChaosMonkeyConfig `json:"chaosMonkey"`
}

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

type Dependency struct {
	// Name is a human-readable name for this dependency instance.
	Name string `json:"name"`
	// Method is a name of a method registered in the ClusterLoader dependency factory.
	Method string `json:"method"`
	// Timeout is the maximum duration for both setup and teardown operations.
	// If set to 0, operations will wait forever.
	Timeout Duration `json:"timeout,omitempty"`
	// Params is a map of {name: value} pairs which will be passed to the dependency method - allowing for injection
	// of arbitrary parameters to it.
	Params map[string]interface{} `json:"params"`
}

type Duration time.Duration

type GlobalQPSLoad struct {
	// QPS defines desired average rate of actions.
	QPS float64 `json:"qps"`
	// Burst defines maxumim number of actions that can happen at the same time.
	Burst int `json:"burst"`
}

type ListUnknownObjectOptions struct {
	LabelSelector *metav1.LabelSelector `json:"labelSelector"`
}

type Measurement struct {
	// Method is a name of a method registered in the ClusterLoader factory.
	Method string `json:"method"`
	// Params is a map of {name: value} pairs which will be passed to the measurement method - allowing for injection of arbitrary parameters to it.
	Params map[string]interface{} `json:"params"`

	// Exactly one of Identifier or Instances must be supplied.
	// Identifier is for single measurements while Instances is for wrapper measurements.
	// Identifier is a string that differentiates measurement instances of the same method.
	Identifier string `json:"identifier"`
	// MeasurementInstanceConfig contains the Identifier and Params of the measurement.
	// It shouldn't be set when Identifier is set.
	Instances []*MeasurementInstanceConfig
}

type MeasurementInstanceConfig struct {
	// Identifier is a string that identifies a single instance of measurement within a wrapper measurement
	Identifier string `json:"identifier"`
	// Params is an optional map which is specific to the measurement instance defined above by the identifier.
	// In case the Measurement level params also contain the same configs as defined in this, then while executing that
	// particular Measurement Instance, the params defined here would be given higher priority.
	Params map[string]interface{} `json:"params"`
}

type Module struct {
	// Steps is the list of steps composing the module. Steps are executed
	// serially.
	Steps []*Step `json:"steps"`
}

type ModuleRef struct {
	// Path is the path to the filename with the module template.
	Path string `json:"path"`
	// Params specifies template parameters to be substituted inside the template.
	Params map[string]interface{} `json:"params"`
}

type NamespaceConfig struct {
	// Number is a number of automanaged namespaces.
	Number int32 `json:"number,omitempty"`
	// NamePrefix is the name prefix of automanaged namespaces.
	// It's optional, if set CL will use it, otherwise generate one with random string.
	Prefix string `json:"prefix,omitempty"`
	// DeleteStaleNamespaces specifies whether or not delete stale namespaces.
	DeleteStaleNamespaces *bool `json:"deleteStaleNamespaces,omitempty"`
	// DeleteAutomanangedNamespaces specifies whether or not delete namespaces after a test.
	DeleteAutomanagedNamespaces *bool `json:"deleteAutomanagedNamespaces,omitempty"`
	// EnableExistingNamespaces enables to use pre-created namespaces in a test.
	EnableExistingNamespaces *bool `json:"enableExistingNamespaces,omitempty"`
	// DeleteNamespaceTimeout controls a timeout for waiting until automanaged namespaces are deleted.
	// Defaults to 10m, if not set.
	DeleteNamespaceTimeout *Duration `json:"deleteNamespaceTimeout,omitempty"`
}

type NamespaceRange struct {
	// Min is the lower index of namespace range.
	Min int32 `json:"min"`
	// Max is the upper index of namespace range.
	Max int32 `json:"max"`
	// Basename defines the group of selected namespaces.
	// All of the namespaces, with name "<Basename>-<i>"
	// where <i> in [Min, Max], will be selected.
	// If no Basename is specified, automanaged namespace is assumed.
	Basename *string
}

type NodeFailureConfig struct {
	// FailureRate is a percentage of all nodes that could fail simultinously.
	FailureRate float64 `json:"failureRate"`
	// Interval is time between node failures.
	Interval Duration `json:"interval"`
	// JitterFactor is factor used to jitter node failures.
	// Node will be killed between [Interval, Interval + (1.0 + JitterFactor)].
	JitterFactor float64 `json:"jitterFactor"`
	// SimulatedDowntime is a duration between node is killed and recreated.
	SimulatedDowntime Duration `json:"simulatedDowntime"`
}

type Object struct {
	// Basename is a string from which names of objects will be created.
	Basename string `json:"basename"`
	// ObjectTemplatePath specifies the path to object definition.
	ObjectTemplatePath string `json:"objectTemplatePath"`
	// TemplateFillMap specifies for each placeholder what value should it be replaced with.
	TemplateFillMap map[string]interface{} `json:"templateFillMap"`
	// ListUnknownObjectOptions, if set, will result in listing objects that were
	// not created directly via ClusterLoader2 before executing Phase. The main
	// use case for that is deleting unknown objects using the Phase mechanism,
	// e.g. deleting PVs that were created via StatefulSets leveraging all Phase
	// functionalities, e.g. respecting given QPS, doing it in parallel with other
	// Phases, etc.
	ListUnknownObjectOptions *ListUnknownObjectOptions `json:"listUnknownObjectOptions"`
}

type ParallelismLimitedLoad struct {
	// ParallelismLimit specifies the limit of the parallelism for the action executions.
	ParallelismLimit int32 `json:"parallelismLimit"`
}

type Phase struct {
	// NamespaceRange defines the range of generated namespaces in which objects
	// should be reconciled.
	// If null, objects are assumed to be cluster scoped.
	// Note: Only one of NamespaceList and NamespaceRange should be set
	NamespaceRange *NamespaceRange `json:"namespaceRange"`
	// NamespaceList defines a list of namespaces in which objects
	// should be reconciled. This is used for resources that should be forced
	// into specific namespaces.
	// If null, assumed to use NamespaceRange.
	// Note: Only one of NamespaceList and NamespaceRange should be set
	NamespaceList []string `json:"namespaceList"`
	// ReplicasPerNamespace is a number of instances of a given object
	// to exist in each of referenced namespaces.
	ReplicasPerNamespace int32 `json:"replicasPerNamespace"`
	// TuningSet is the name of TuningSet to be used.
	TuningSet string `json:"tuningSet"`
	// ObjectBundle declaratively defines a set of objects.
	// For every specified namespace and for every required replica,
	// these objects will be reconciled in serial.
	ObjectBundle []*Object `json:"objectBundle"`
}

type PoissonLoad struct {
	// ExpectedActionsPerSecond specifies the possion rate parameter per second.
	ExpectedActionsPerSecond float64 `json:"expectedActionsPerSecond"`
}

type QPSLoad struct {
	// QPS specifies requested qps.
	QPS float64 `json:"qps"`
}

type RandomizedLoad struct {
	// AverageQPS specifies the expected average qps.
	AverageQPS float64 `json:"averageQps"`
}

type RandomizedTimeLimitedLoad struct {
	// TimeLimit specifies the amount of time that the operations will be spread over.
	TimeLimit Duration `json:"timeLimit"`
}

type Step struct {
	// Phases is a collection of declarative definitions of objects.
	// Phases will be executed in parallel.
	Phases []*Phase `json:"phases"`
	// Measurements is a collection of parallel measurement calls.
	Measurements []*Measurement `json:"measurements"`
	// Module points to a CL2 module defined in a separate file.
	Module ModuleRef `json:"module"`
	// Name is an optional name for given step. If name is set the step execution
	// time will be measured and the step will be reported at the end of the test.
	// The name is ignored if the step is of type 'Module'.
	Name string `json:"name"`
}

type SteppedLoad struct {
	// BurstSize specifies the qps peek.
	BurstSize int32 `json:"burstSize"`
	// StepDelay specifies the interval between peeks.
	StepDelay Duration `json:"stepDelay"`
}

type TestScenario struct {
	// Identifier is a unique test scenario name across test suite.
	Identifier string `json:"identifier"`
	// ConfigPath defines path to the file containing a single Config definition.
	ConfigPath string `json:"configPath"`
	// OverridePaths defines what override files should be applied
	// to the config specified by the ConfigPath. This supersedes the global
	// config provided by ClusterLoaderConfig.
	OverridePaths []string `json:"overridePaths"`
}

type TestSuite []TestScenario

type TimeLimitedLoad struct {
	// TimeLimit specifies the amount of time that the operations will be spread over.
	TimeLimit Duration `json:"timeLimit"`
}

type TuningSet struct {
	// Name by which the TuningSet will be referenced.
	Name string `json:"name"`
	// InitialDelay specifies the waiting time before starting phase execution.
	InitialDelay Duration `json:"initialDelay"`
	// QPSLoad is a definition for QPSLoad tuning set.
	QPSLoad *QPSLoad `json:"qpsLoad"`
	// RandomizedLoad is a definition for RandomizedLoad tuning set.
	RandomizedLoad *RandomizedLoad `json:"randomizedLoad"`
	// SteppedLoad is a definition for SteppedLoad tuning set.
	SteppedLoad *SteppedLoad `json:"steppedLoad"`
	// TimeLimitedLoad is a definition for TimeLimitedLoad tuning set.
	TimeLimitedLoad *TimeLimitedLoad `json:"timeLimitedLoad"`
	// RandomizedTimeLimitedLoad is a definition for RandomizedTimeLimitedLoad tuning set.
	RandomizedTimeLimitedLoad *RandomizedTimeLimitedLoad `json:"randomizedTimeLimitedLoad"`
	// ParallelismLimitedLoad is a definition for ParallelismLimitedLoad tuning set.
	ParallelismLimitedLoad *ParallelismLimitedLoad `json:"parallelismLimitedLoad"`
	// GlobalQPSLoad is a definition for GlobalQPSLoad tuning set.
	GlobalQPSLoad *GlobalQPSLoad `json:"globalQPSLoad"`
	// PoissonLoad is a definition for PoissonLoad tuning set.
	PoissonLoad *PoissonLoad `json:"poissonLoad"`
}