loadtest

type CalculatedStats struct {
	AvgTotalClientTime float64           // Average total time that we were waiting for a single client's interactions/requests to complete.
	CountPerClient     float64           // Number of interactions/requests per client.
	AvgTimePerClient   float64           // Average time per interaction/request per client.
	PerSecPerClient    float64           // Interactions/requests per second per client.
	PerSec             float64           // Interactions/requests per second overall.
	AbsPerSec          float64           // Interactions/requests per second overall, including wait times.
	FailureRate        float64           // The % of interactions/requests that failed.
	TopErrors          []*FlattenedError // The top 10 errors by error count.
}

type Client interface {
	// Interact is intended to perform the relevant requests that make up an
	// interaction with a Tendermint node.
	Interact()

	// GetStats must return the combined statistics for all interactions and
	// requests for this client.
	GetStats() *messages.CombinedStats
}

type ClientConfig struct {
	Type               string            `toml:"type"`                // The type of client to spawn.
	Spawn              int               `toml:"spawn"`               // The number of clients to spawn, per slave.
	SpawnRate          float64           `toml:"spawn_rate"`          // The rate at which to spawn clients, per second, on each slave.
	MaxInteractions    int               `toml:"max_interactions"`    // The maximum number of interactions emanating from each client.
	MaxTestTime        ParseableDuration `toml:"max_test_time"`       // The maximum duration of the test, beyond which this client must be stopped.
	RequestWaitMin     ParseableDuration `toml:"request_wait_min"`    // The minimum wait period before each request before sending another one.
	RequestWaitMax     ParseableDuration `toml:"request_wait_max"`    // The maximum wait period before each request before sending another one.
	RequestTimeout     ParseableDuration `toml:"request_timeout"`     // The maximum time allowed before considering a request to have timed out.
	InteractionTimeout ParseableDuration `toml:"interaction_timeout"` // The maximum time allowed for an overall interaction.
}

type ClientFactory interface {
	// NewStats must create and initialize an empty CombinedStats object for
	// this kind of client.
	NewStats(params ClientParams) *messages.CombinedStats

	NewClient(params ClientParams) Client
}

type ClientParams struct {
	TargetNodes        []string      // The addresses of the target nodes for this client.
	InteractionTimeout time.Duration // The maximum time to allow for an interaction.
	RequestWaitMin     time.Duration // The minimum time to wait prior to executing a request.
	RequestWaitMax     time.Duration // The maximum time to wait prior to executing a request.
	RequestTimeout     time.Duration // The maximum time to allow for a request.
	TotalClients       int64         // The total number of clients for which to initialize the load testing.
}

type Config struct {
	Master      MasterConfig      `toml:"master"`       // The master's load testing configuration.
	Slave       SlaveConfig       `toml:"slave"`        // The slaves' load testing configuration.
	TestNetwork TestNetworkConfig `toml:"test_network"` // The test network layout/configuration.
	Clients     ClientConfig      `toml:"clients"`      // Load testing client-related configuration.
}

type Error struct {
	Code     ErrorCode
	Message  string
	Upstream error
}

type ErrorCode int

type FlattenedError struct {
	ErrorType string
	Count     int64
}

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

type MasterConfig struct {
	Bind               string            `toml:"bind"`                 // The address to which to bind the master (host:port).
	ExpectSlaves       int               `toml:"expect_slaves"`        // The number of slaves to expect to connect before starting the load test.
	ExpectSlavesWithin ParseableDuration `toml:"expect_slaves_within"` // The time period within which to expect to hear from all slaves, otherwise causes a failure.
	ResultsDir         string            `toml:"results_dir"`          // The root of the results output directory.
}

type MetricFamilyData struct {
	ID         string
	Help       string
	Timestamps []float64
	Data       []float64
}

type NodePrometheusStats map[string]map[int64]float64

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

type NoopClientFactory struct{}

type NoopProbe struct{}

type ParseableDuration time.Duration

type Probe interface {
	OnStartup(ctx actor.Context)
	OnShutdown(ctx actor.Context, err error)
	OnStopped(ctx actor.Context)
}

type PrometheusEndpoint struct {
	ID  string
	URL string
}

type PrometheusStats struct {
	StartTime                time.Time                      // When was the load test started?
	MetricFamilyDescriptions map[string]string              // Mapping of metric family ID -> description
	TargetNodesStats         map[string]NodePrometheusStats // Target node stats organized by hostname.
	// contains filtered or unexported fields
}

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

type RPCClientFactory struct{}

type SingleTestNodeChart struct {
	ID        template.JS
	Title     template.JS
	Hostnames template.JS
	NodesData template.JS
}

type SingleTestSummaryContext struct {
	// Summary parameters
	ClientType            template.HTML
	SlaveNodeCount        template.HTML
	ClientSpawn           template.HTML
	ClientSpawnRate       template.HTML
	ClientRequestWaitMin  template.HTML
	ClientRequestWaitMax  template.HTML
	ClientRequestTimeout  template.HTML
	ClientMaxInteractions template.HTML
	TotalTestTime         template.HTML

	// Interaction-related parameters
	InteractionsTotalClients template.HTML
	InteractionsPerSec       template.HTML
	InteractionsCount        template.HTML
	InteractionsErrors       template.HTML
	InteractionsErrorRate    template.HTML
	InteractionsMinTime      template.HTML
	InteractionsMaxTime      template.HTML

	// For the interaction response times histogram
	InteractionsResponseTimesBins   template.JS
	InteractionsResponseTimesCounts template.JS

	// Top errors encountered by interactions
	ErrorCounts []SingleTestSummaryErrorCount

	// Request-related parameters
	Requests []SingleTestSummaryRequestParams

	// Node-related chart parameters
	NodeCharts []SingleTestNodeChart
}

type SingleTestSummaryErrorCount struct {
	Description template.HTML
	Count       template.HTML
}

type SingleTestSummaryRequestParams struct {
	Name      template.HTML
	PerSec    template.HTML
	Count     template.HTML
	Errors    template.HTML
	ErrorRate template.HTML
	MinTime   template.HTML
	MaxTime   template.HTML

	// For the request response times histogram
	ResponseTimesBins   template.JS
	ResponseTimesCounts template.JS

	// Error counts
	ErrorCounts []SingleTestSummaryErrorCount
}

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

type SlaveConfig struct {
	Bind           string            `toml:"bind"`            // The address to which to bind slave nodes (host:port).
	Master         string            `toml:"master"`          // The master's external address (host:port).
	UpdateInterval ParseableDuration `toml:"update_interval"` // The interval with which to send stats updates to the master.
}

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

type TestNetworkConfig struct {
	EnablePrometheus       bool              `toml:"enable_prometheus"`        // Should we enable collections of Prometheus stats during testing?
	PrometheusPollInterval ParseableDuration `toml:"prometheus_poll_interval"` // How often should we poll the Prometheus endpoint?
	PrometheusPollTimeout  ParseableDuration `toml:"prometheus_poll_timeout"`  // At what point do we consider a Prometheus polling operation a failure?

	Targets []TestNetworkTargetConfig `toml:"targets"` // Configuration for each of the Tendermint nodes in the network.
}

type TestNetworkTargetConfig struct {
	ID             string `toml:"id"`                        // A short, descriptive identifier for this node.
	URL            string `toml:"url"`                       // The RPC URL for this target node.
	PrometheusURLs string `toml:"prometheus_urls,omitempty"` // The URL(s) (comma-separated) to poll for this target node, if Prometheus polling is enabled.

	Outages string `toml:"outages,omitempty"` // Specify an outage schedule to try to affect for this host.
}