loadgen

type AfterRunner interface {
	AfterRun(r *RunReport) error
}

type AfterSuite func(config *GeneratorConfig) error

type Annotations struct {
	List []interface{} `json:"list"`
}

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

type Attack interface {
	Runnable
	// Setup should establish the connection to the service
	// It may want to access the Config of the Runner.
	Setup(c RunnerConfig) error
	// Do performs one request and is executed in a separate goroutine.
	// The context is used to cancel the request on timeout.
	Do(ctx context.Context) DoResult
	// Teardown can be used to close the connection to the service
	Teardown() error
	// Clone should return a fresh new Attack
	// Make sure the new Attack has values for shared struct fields initialized at Setup.
	Clone(r *Runner) Attack
}

type AttackerWithLabel struct {
	Name  string
	Label string
}

type BeforeRunner interface {
	BeforeRun(c RunnerConfig) error
}

type BeforeSuite func(config *GeneratorConfig) error

type CSVData struct {
	Mu *sync.Mutex

	CsvWriter *csv.Writer
	CsvReader *csv.Reader
	Recycle   bool
	// contains filtered or unexported fields
}

type CSVMonitored struct {
	Attack
}

type ChartLine struct {
	XValues []float64
	YValues []float64
}

type Checks struct {
	// Type error check mode, ex.: error | prometheus
	Type string
	// Query prometheus bool query
	Query string
	// Threshold fail threshold, from 0 to 1, float
	Threshold float64
	// Interval check interval in seconds
	Interval int
}

type ClusterSpec struct {
	Region    string
	Instances []InstanceSpec
}

type Dashboard struct {
	Inputs        Inputs        `json:"__inputs"`
	Requires      Requires      `json:"__requires"`
	Annotations   Annotations   `json:"annotations"`
	Editable      bool          `json:"editable"`
	GnetID        interface{}   `json:"gnetId"`
	GraphTooltip  int           `json:"graphTooltip"`
	HideControls  bool          `json:"hideControls"`
	ID            interface{}   `json:"id"`
	Links         []interface{} `json:"links"`
	Refresh       string        `json:"refresh"`
	Rows          []Row         `json:"rows"`
	SchemaVersion int           `json:"schemaVersion"`
	Style         string        `json:"style"`
	Tags          []interface{} `json:"tags"`
	Templating    Templating    `json:"templating"`
	Time          Time          `json:"time"`
	Timepicker    TimePicker    `json:"timepicker"`
	Timezone      string        `json:"timezone"`
	Title         string        `json:"title"`
	Version       int           `json:"version"`
}

type Datable interface {
	// PutData writes object representation to handle file
	PutData(mo interface{}) error
	// GetData reads object from handle file
	GetData() (interface{}, error)
}

type DoResult struct {
	// Label identifying the request that was send which is only used for reporting the Metrics.
	RequestLabel string
	// The error that happened when sending the request or receiving the response.
	Error error
	// The HTTP status code.
	StatusCode int
	// Number of bytes transferred when sending the request.
	BytesIn int64
	// Number of bytes transferred when receiving the response.
	BytesOut int64
}

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

type GeneratorConfig struct {
	// Host current vm host configuration
	Host struct {
		// Name used in grafana metrics as prefix
		Name string `mapstructure:"name"`
		// NetworkIface default network interface to collect metrics from
		NetworkIface string `mapstructure:"network_iface"`
		// CollectMetrics collect host metrics flag
		CollectMetrics bool `mapstructure:"collect_metrics"`
	} `mapstructure:"host"`
	// Remotes contains remote generator vm data
	Remotes []struct {
		// Name hostname of remote generator
		Name string `mapstructure:"name"`
		// RemoteRootDir remote root dir of a test
		RemoteRootDir string `mapstructure:"remote_root_dir"`
		// KeyPath path to ssh pub key
		KeyPath string `mapstructure:"key_path"`
	}
	// Generator generator specific config
	Generator struct {
		// Target base url to attack
		Target string `mapstructure:"target"`
		// ResponseTimeoutSec response timeout in seconds
		ResponseTimeoutSec int `mapstructure:"responseTimeoutSec"`
		// RampUpStrategy ramp up strategy: linear | exp2
		RampUpStrategy string `mapstructure:"ramp_up_strategy"`
		// Verbose allows to print debug generator logs
		Verbose bool `mapstructure:"verbose"`
	} `mapstructure:"generator"`
	// ExecutionMode step execution mode: sequence, sequence_validate, parallel
	ExecutionMode string `mapstructure:"execution_mode"`
	// Grafana related config
	Grafana struct {
		// URL base url of grafana, ex.: http://0.0.0.0:8181
		URL string `mapstructure:"url"`
		// Login login
		Login string `mapstructure:"login"`
		// Password password
		Password string `mapstructure:"password"`
	} `mapstructure:"grafana"`
	// Graphite related config
	Graphite struct {
		// URL graphite base url, ex.: 0.0.0.0:2003
		URL string `mapstructure:"url"`
		// FlushIntervalSec flush interval in seconds
		FlushIntervalSec int `mapstructure:"flushDurationSec"`
		// LoadGeneratorPrefix prefix to be used in graphite metrics
		LoadGeneratorPrefix string `mapstructure:"loadGeneratorPrefix"`
	} `mapstructure:"graphite"`
	Prometheus *Prometheus `mapstructure:"prometheus"`
	// LoadScriptsDir relative from cwd load dir path, ex.: load
	LoadScriptsDir string `mapstructure:"load_scripts_dir"`
	// Timezone timezone used for grafana url, ex.: Europe/Moscow
	Timezone string `mapstructure:"timezone"`
	// Logging logging related config
	Logging struct {
		// Level level of allowed log messages,ex.: debug | info
		Level string `mapstructure:"level"`
		// Encoding encoding of logs, ex.: console | json
		Encoding string `mapstructure:"encoding"`
	} `mapstructure:"logging"`
}

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

type ImportPayload struct {
	Dashboard Dashboard     `json:"dashboard"`
	Overwrite bool          `json:"overwrite"`
	Inputs    []UploadInput `json:"inputs"`
}

type InfrastructureProviderAWS struct {
	ClusterSpec      ClusterSpec
	RunningInstances map[string]*RunningInstance
	// contains filtered or unexported fields
}

type Inputs []struct {
	Name        string `json:"name"`
	Label       string `json:"label"`
	Description string `json:"description"`
	Type        string `json:"type"`
	PluginID    string `json:"pluginId"`
	PluginName  string `json:"pluginName"`
}

type InstanceSpec struct {
	Role  string
	Name  string
	Image string
	Type  string
}

type LabelKV struct {
	Label     string
	LabelName string
}

type LatencyMetrics struct {
	// Total is the total latency sum of all requests in an attack.
	Total time.Duration `json:"total"`
	// Mean is the mean request latency.
	Mean time.Duration `json:"mean"`
	// P50 is the 50th percentile request latency.
	P50 time.Duration `json:"50th"`
	// P95 is the 95th percentile request latency.
	P95 time.Duration `json:"95th"`
	// P99 is the 99th percentile request latency.
	P99 time.Duration `json:"99th"`
	// Max is the maximum observed request latency.
	Max time.Duration `json:"max"`
}

type Legend struct {
	Avg     bool `json:"avg"`
	Current bool `json:"current"`
	Max     bool `json:"max"`
	Min     bool `json:"min"`
	Show    bool `json:"show"`
	Total   bool `json:"total"`
	Values  bool `json:"values"`
}

type LoadManager struct {
	RootMemberPrivateKey *ecdsa.PrivateKey
	RootMemberPublicKey  *ecdsa.PublicKey
	// SuiteConfig holds data common for all groups
	SuiteConfig *SuiteConfig
	// GeneratorConfig holds generator data
	GeneratorConfig *GeneratorConfig
	// Steps runner objects that fires .Do()
	Steps []RunStep
	// AttackerConfigs attacker configs
	AttackerConfigs map[string]RunnerConfig
	// Reports run reports for every handle
	Reports map[string]*RunReport
	// CsvStore stores data for all attackers
	CsvMu    *sync.Mutex
	CsvStore map[string]*CSVData
	// all handles csv logs
	CSVLogMu      *sync.Mutex
	CSVLog        *csv.Writer
	RPSScalingLog *csv.Writer
	ReportDir     string
	// When degradation threshold is reached for any handle, see default Config
	Degradation bool
	// When there are Errors in any handle
	Failed bool
	// When max rps validation failed
	ValidationFailed bool
}

type Logger struct {
	*zap.SugaredLogger
}

type Metrics struct {
	// Latencies holds computed request latency Metrics.
	Latencies LatencyMetrics `json:"latencies"`
	// First is the earliest timestamp in a Result set.
	Earliest time.Time `json:"earliest"`
	// Latest is the latest timestamp in a Result set.
	Latest time.Time `json:"latest"`
	// End is the latest timestamp in a Result set plus its latency.
	End time.Time `json:"end"`
	// Duration is the duration of the attack.
	Duration time.Duration `json:"duration"`
	// Wait is the extra time waiting for responses from targets.
	Wait time.Duration `json:"wait"`
	// Requests is the total number of requests executed.
	Requests uint64 `json:"requests"`
	// Rate is the rate of requests per second.
	Rate float64 `json:"rate"`
	// Success is the percentage of non-error responses.
	Success float64 `json:"success"`
	// StatusCodes is a histogram of the responses' status codes.
	StatusCodes map[string]int `json:"status_codes"`
	// Errors is a set of unique Errors returned by the targets during the attack.
	Errors []string `json:"Errors"`
	// contains filtered or unexported fields
}

type Monitored struct {
	Attack
}

type Panel struct {
	AliasColors     struct{}      `json:"aliasColors"`
	Bars            bool          `json:"bars"`
	DashLength      int           `json:"dashLength"`
	Dashes          bool          `json:"dashes"`
	Datasource      string        `json:"datasource"`
	Fill            int           `json:"fill"`
	ID              int           `json:"id"`
	Legend          Legend        `json:"legend"`
	Lines           bool          `json:"lines"`
	Linewidth       int           `json:"linewidth"`
	Links           []interface{} `json:"links"`
	NullPointMode   string        `json:"nullPointMode"`
	Percentage      bool          `json:"percentage"`
	Pointradius     int           `json:"pointradius"`
	Points          bool          `json:"points"`
	Renderer        string        `json:"renderer"`
	SeriesOverrides []interface{} `json:"seriesOverrides"`
	SpaceLength     int           `json:"spaceLength"`
	Span            int           `json:"span"`
	Stack           bool          `json:"stack"`
	SteppedLine     bool          `json:"steppedLine"`
	Targets         []Target      `json:"targets"`
	Thresholds      []interface{} `json:"thresholds"`
	TimeFrom        interface{}   `json:"timeFrom"`
	TimeShift       interface{}   `json:"timeShift"`
	Title           string        `json:"title"`
	Tooltip         Tooltip       `json:"tooltip"`
	Type            string        `json:"type"`
	Xaxis           Xaxe          `json:"xaxis"`
	Yaxes           []Yaxe        `json:"yaxes"`
}

type Prometheus struct {
	// URL prometheus base url
	URL string `mapstructure:"url"`
	// EnvLabel prometheus environment label
	EnvLabel string `mapstructure:"env_label"`
	// Namespace prometheus namespace
	Namespace string `mapstructure:"namespace"`
}

type Requires []struct {
	Type    string `json:"type"`
	ID      string `json:"id"`
	Name    string `json:"name"`
	Version string `json:"version"`
}

type Row struct {
	Collapse        bool        `json:"collapse"`
	Height          int         `json:"height"`
	Panels          []Panel     `json:"panels"`
	Repeat          interface{} `json:"repeat"`
	RepeatIteration interface{} `json:"repeatIteration"`
	RepeatRowID     interface{} `json:"repeatRowId"`
	ShowTitle       bool        `json:"showTitle"`
	Title           string      `json:"title"`
	TitleSize       string      `json:"titleSize"`
}

type RunReport struct {
	StartedAt     time.Time    `json:"startedAt"`
	FinishedAt    time.Time    `json:"finishedAt"`
	Configuration RunnerConfig `json:"configuration"`
	// RunError is set when a Run could not be called or executed.
	RunError string              `json:"runError"`
	Metrics  map[string]*Metrics `json:"Metrics"`
	// Failed can be set by your loadtest test program to indicate that the results are not acceptable.
	Failed bool `json:"failed"`
	// Output is used to publish any custom output in the report.
	Output map[string]interface{} `json:"output"`
}

type RunStep struct {
	Name          string
	ExecutionMode string
	Runners       []*Runner
}

type Runnable interface {
	// GetManager get test manager with all required data files/readers/writers
	GetManager() *LoadManager
	// GetRunner get current runner
	GetRunner() *Runner
}

type Runner struct {
	TestStage    int
	ReadCsvName  string
	WriteCsvName string
	RecycleData  bool
	Manager      *LoadManager
	Config       RunnerConfig

	CheckData []Checks

	// Other clients for checks
	PromClient v1.API

	RateLog []float64
	MaxRPS  float64
	// RampUpMetrics store only rampup interval metrics, cleared every interval
	RampUpMetrics map[string]*Metrics
	// Metrics store full attack metrics
	Metrics map[string]*Metrics

	Errors map[string]metrics.Counter

	L *Logger
	// contains filtered or unexported fields
}

type RunnerConfig struct {
	// WaitBeforeSec debug sleep before starting runner when checking condition is impossible
	WaitBeforeSec int `mapstructure:"wait_before_sec" yaml:"wait_before_sec"`
	// HandleName name of a handle, must be the same as test label in labels.go
	HandleName string `mapstructure:"name" yaml:"name"`
	// RPS max requests per second limit, load profile depends on AttackTimeSec and RampUpTimeSec
	RPS int `mapstructure:"rps" yaml:"rps"`
	// AttackTimeSec time of the test in seconds
	AttackTimeSec int `mapstructure:"attack_time_sec" yaml:"attack_time_sec"`
	// RampUpTimeSec ramp up period in seconds, in which RPS will be increased to max of RPS parameter
	RampUpTimeSec int `mapstructure:"ramp_up_sec" yaml:"ramp_up_sec"`
	// RampUpStrategy ramp up strategy: linear | exp2
	RampUpStrategy string `mapstructure:"ramp_up_strategy" yaml:"ramp_up_strategy"`
	// MaxAttackers max amount of goroutines to attack
	MaxAttackers int `mapstructure:"max_attackers" yaml:"max_attackers"`
	// OutputFilename report filename
	OutputFilename string `mapstructure:"outputFilename,omitempty" yaml:"outputFilename,omitempty"`
	// Verbose allows to print generator debug info
	Verbose bool `mapstructure:"verbose" yaml:"verbose"`
	// Metadata load run metadata
	Metadata map[string]string `mapstructure:"metadata,omitempty" yaml:"metadata,omitempty"`
	// DoTimeoutSec attacker.Do() func timeout
	DoTimeoutSec int `mapstructure:"do_timeout_sec" yaml:"do_timeout_sec"`
	// StoreData flag to check if test must put some data in csv for later validation
	StoreData bool `mapstructure:"store_data" yaml:"store_data"`
	// RecycleData flag to allow recycling data from csv when it ends
	RecycleData bool `mapstructure:"recycle_data" yaml:"recycle_data"`
	// ReadFromCsvName path to csv file to get data for test, use DefaultReadCSV/DefaultWriteCSV to read/write data for test
	ReadFromCsvName string `mapstructure:"csv_read,omitempty" yaml:"csv_read,omitempty"`
	// WriteToCsvName path to csv file to write data from test, use DefaultReadCSV/DefaultWriteCSV to read/write data for test
	WriteToCsvName string `mapstructure:"csv_write,omitempty" yaml:"csv_write,omitempty"`
	// HandleParams handle params metadata, ex. limit=100
	HandleParams map[string]string `mapstructure:"handle_params,omitempty" yaml:"handle_params,omitempty"`
	// IsValidationRun flag to know it's test run that validates max rps
	IsValidationRun bool `mapstructure:"validation_run" yaml:"validation_run"`
	// StopIf describes stop test criteria
	StopIf []Checks `mapstructure:"stop_if" yaml:"stop_if"`
	// Validation validation config
	Validation Validation `mapstructure:"validation" yaml:"validation"`

	// DebugSleep used as a crutch to not affect response time when one need to run test < 1 rps
	DebugSleep int `mapstructure:"debug_sleep"`
}

type RunningInstance struct {
	Id              string
	Name            string
	KeyFileName     string
	Role            string
	PrivateKeyPem   string
	PublicDNSName   string
	PublicIPAddress string
}

type RuntimeCheckFunc func(r *Runner) bool

type Step struct {
	// Name loadtest step name
	Name string `mapstructure:"name" yaml:"name"`
	// ExecutionMode handles execution mode: sequence, sequence_validate, parallel
	ExecutionMode string `mapstructure:"execution_mode" yaml:"execution_mode"`
	// Handles handle configs
	Handles []RunnerConfig `mapstructure:"handles" yaml:"handles"`
}

type SuiteConfig struct {
	RootKeys string `mapstructure:"rootkeys,omitempty" yaml:"rootkeys,omitempty"`
	RootRef  string `mapstructure:"rootref,omitempty" yaml:"rootref,omitempty"`
	// DumpTransport dumps request/response in stdout
	DumpTransport bool `mapstructure:"dumptransport" yaml:"dumptransport"`
	// GoroutinesDump dump goroutines when SIGHUP
	GoroutinesDump bool `mapstructure:"goroutines_dump" yaml:"goroutines_dump"`
	// HttpTimeout default http client timeout
	HttpTimeout int `mapstructure:"http_timeout" yaml:"http_timeout"`
	// Steps load test steps
	Steps []Step `mapstructure:"steps" yaml:"steps"`
}

type Target struct {
	RefID  string `json:"refId"`
	Target string `json:"target"`
}

type Templating struct {
	List []interface{} `json:"list"`
}

type Time struct {
	From string `json:"from"`
	To   string `json:"to"`
}

type TimePicker struct {
	RefreshIntervals []string `json:"refresh_intervals"`
	TimeOptions      []string `json:"time_options"`
}

type Tooltip struct {
	Shared    bool   `json:"shared"`
	Sort      int    `json:"sort"`
	ValueType string `json:"value_type"`
}

type UploadInput struct {
	Name     string `json:"name"`
	Type     string `json:"type"`
	PluginID string `json:"pluginId"`
	Value    string `json:"value"`
}

type Validation struct {
	// AttackTimeSec validation attack time sec
	AttackTimeSec int `mapstructure:"attack_time_sec" yaml:"attack_time_sec"`
	// Threshold percent of max rps to validate, ex.: 0.7 means 70% of max rps
	Threshold float64 `mapstructure:"threshold" yaml:"threshold"`
}

type WithData struct {
}

type WithRunner struct {
	R *Runner
}

type Xaxe struct {
	Buckets interface{}   `json:"buckets"`
	Mode    string        `json:"mode"`
	Name    interface{}   `json:"name"`
	Show    bool          `json:"show"`
	Values  []interface{} `json:"values"`
}

type Yaxe struct {
	Format  string      `json:"format"`
	Label   interface{} `json:"label"`
	LogBase int         `json:"logBase"`
	Max     interface{} `json:"max"`
	Min     interface{} `json:"min"`
	Show    bool        `json:"show"`
}