checks

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

type Config struct {
	// Remote is an interface for validating and executing commands on remote nodes.
	Remote Remote
	// Manifest is the cluster manifest the checker validates nodes against.
	Manifest schema.Manifest
	// Servers is a list of nodes for validation.
	Servers []Server
	// Requirements maps node roles to their validation requirements.
	Requirements map[string]Requirements
	// Features allows to turn certain checks off.
	Features
}

type Features struct {
	// TestBandwidth specifies whether the network bandwidth test should
	// be executed.
	TestBandwidth bool
	// TestPorts specifies whether the ports availability test should
	// be executed.
	TestPorts bool
	// TestEtcdDisk specifies whether the device where etcd data resides
	// should be performance-tested.
	TestEtcdDisk bool
}

type Interface interface {
	// Run runs a full set of checks on the nodes configured in the checker.
	Run(ctx context.Context) error
	// CheckNode executes single-node checks (such as CPU/RAM requirements,
	// disk space, etc) for the provided server.
	CheckNode(ctx context.Context, server Server) []*agentpb.Probe
	// CheckNodes executes multi-node checks (such as network reachability,
	// bandwidth, etc) on the provided set of servers.
	CheckNodes(ctx context.Context, servers []Server) []*agentpb.Probe
	// Check executes all checks on configured servers and returns failed probes.
	Check(ctx context.Context) []*agentpb.Probe
}

type LocalChecksRequest struct {
	// Manifest is the application manifest to check against
	Manifest schema.Manifest
	// Role is the node profile name to check
	Role string
	// Options is additional validation options
	Options *validationpb.ValidateOptions
	// Docker specifies Docker configuration overrides (if any)
	Docker storage.DockerConfig
	// Mounts specifies optional mount overrides as name -> source path pairs
	Mounts map[string]string
	// AutoFix when set to true attempts to fix some common problems
	AutoFix bool
	// Progress is used to report information about auto-fixed problems
	utils.Progress
}

type LocalChecksResult struct {
	// Failed is a list of failed probes
	Failed []*agentpb.Probe
	// Fixed is a list of probes that failed but have been auto-fixed
	Fixed []*agentpb.Probe
	// Fixable is a list of probes that can be attempted to auto-fix
	Fixable []*agentpb.Probe
}

type ManifestValidator struct {
	// Manifest specifies the manifest to validate against
	Manifest schema.Manifest
	// Profile specifies the node profile to validate against
	Profile schema.NodeProfile
	// StateDir specifies the state directory on the local node
	StateDir string
	// Docker specifies optional docker configuration.
	// If specified, overrides the system docker configuration
	Docker *storage.DockerConfig
	// Mounts specifies the mount overrides as name -> source path pairs
	Mounts map[string]string
}

type Network struct {
	// MinTransferRate is minimum required transfer rate.
	MinTransferRate utils.TransferRate
	// Ports specifies requirements for ports to be available on server.
	Ports Ports
}

type PingPongGame map[string]PingPongRequest

type PingPongGameResults map[string]PingPongResult

type PingPongRequest struct {
	// Listen is the listening servers
	Listen []pb.Addr `json:"listen"`
	// Ping is the remote servers
	Ping []pb.Addr `json:"ping"`
	// Duration is the duration of the game
	Duration time.Duration `json:"duration"`
	// Mode is the game mode: pingpong or bandwidth
	Mode string `json:"mode"`
}

type PingPongResult struct {
	// Code means that the whole operation has succeeded
	// 0 does not mean that all results are success, it just
	// means that experiment went uninterrupted, and there
	// still can be some failures in results
	Code int `json:"code"`
	// Message contains string message
	Message string `json:"message"`
	// ListenResults contains information about attempts to start listening servers
	ListenResults []pb.ServerResult `json:"listen_result"`
	// RemoteResponses is a result of attempts to reach out to remote servers
	PingResults []pb.ServerResult `json:"ping_results"`
	// BandwidthResult is the result of the bandwidth test
	BandwidthResult uint64 `json:"bandwidth_result"`
}

type Ports struct {
	// TCP lists a range of TCP ports.
	TCP []int
	// UDP lists a range of UDP ports.
	UDP []int
}

type RawServerInfo struct {
	// System describes the remote system as a JSON-encoded blob
	System []byte
	// RuntimeConfig is the server's runtime configuration
	pb.RuntimeConfig
	// LocalTime is the localtime at the point when this measurement
	// was taken
	LocalTime time.Time `json:"local_time"`
	// ServerTime is the remote time
	ServerTime time.Time `json:"server_time"`
}

type Remote interface {
	// Exec executes the command remotely on the specified node.
	Exec(ctx context.Context, addr string, command []string, stdout, stderr io.Writer) error
	// CheckPorts executes network test to test port availability.
	CheckPorts(context.Context, PingPongGame) (PingPongGameResults, error)
	// CheckBandwidth executes network bandwidth test.
	CheckBandwidth(context.Context, PingPongGame) (PingPongGameResults, error)
	// CheckDisks executes disk performance test on the specified node.
	CheckDisks(ctx context.Context, addr string, req *proto.CheckDisksRequest) (*proto.CheckDisksResponse, error)
	// Validate performs local checks on the specified node.
	Validate(ctx context.Context, addr string, config ValidateConfig) ([]*agentpb.Probe, error)
}

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

type Requirements struct {
	// CPU describes CPU requirements.
	CPU *schema.CPU
	// RAM describes RAM requirements.
	RAM *schema.RAM
	// OS describes OS requirements
	OS []schema.OS
	// Network describes network requirements.
	Network Network
	// Volumes describes volumes requirements.
	Volumes []schema.Volume
	// Docker describes Docker requirements.
	Docker storage.DockerConfig
}

type Server struct {
	// Server defines a remote node
	storage.Server
	// ServerInfo describes the remote node environment
	ServerInfo
}

type ServerInfo struct {
	// System describes the remote system
	storage.System
	// RuntimeConfig is the server's runtime configuration
	pb.RuntimeConfig
	// LocalTime is the localtime at the point when this measurement
	// was taken
	LocalTime time.Time `json:"local_time"`
	// ServerTime is the remote time
	ServerTime time.Time `json:"server_time"`
}

type ServerInfos []ServerInfo

type ValidateConfig struct {
	// Manifest is the manifest to validate against.
	Manifest schema.Manifest
	// Profile is the node profile name to validate against.
	Profile string
	// Docker is the Docker configuration to validate.
	Docker storage.DockerConfig
}