check

type Check ¶

type Check interface {
	Check() (bool, error)
}

A Check implements a workflow that validates a condition. If an error occurs while running the check, it returns false and the error. If the check is able to successfully determine the condition, it returns true if satisfied, or false otherwise.

type ClosableCheck ¶

type ClosableCheck interface {
	Check
	Close() error
}

A ClosableCheck implements a long-running check workflow that requires closing

type Distro ¶

type Distro string

Distro is a Linux distribution that the inspector supports

const (
	Ubuntu      Distro = "ubuntu"
	RHEL        Distro = "rhel"
	CentOS      Distro = "centos"
	Darwin      Distro = "darwin"
	Unsupported Distro = ""
)

func DetectDistro() (Distro, error)

type DockerInPathCheck ¶ added in v1.8.0

type DockerInPathCheck struct {
	InstallationDisabled bool
}

DockerInPathCheck returns true if the docker binary is on the executable path The check only runs when InstallationDisabled is true and the binary should already be insalled

func (c DockerInPathCheck) Check() (bool, error)

type ExecutableInPathCheck ¶

type ExecutableInPathCheck struct {
	Name string
}

ExecutableInPathCheck checks whether the binary is on the executable path

func (c ExecutableInPathCheck) Check() (bool, error)

type FileContentCheck ¶

type FileContentCheck struct {
	File         string
	SearchString string
}

FileContentCheck runs a search against the contents of the specified file. The SearchString is a regular expression that is in accordance with the RE2 syntax defined by the Go regexp package.

func (c FileContentCheck) Check() (bool, error)

type FreeSpaceCheck ¶ added in v1.3.0

type FreeSpaceCheck struct {
	MinimumBytes uint64
	Path         string
}

FreeSpaceCheck checks the available disk space on a path

func (c FreeSpaceCheck) Check() (bool, error)

type PackageCheck ¶ added in v1.3.0

type PackageCheck struct {
	PackageQuery               PackageQuery
	PackageManager             PackageManager
	InstallationDisabled       bool
	DockerInstallationDisabled bool
	DisconnectedInstallation   bool
}

The PackageCheck uses the operating system to determine whether a package is installed.

func (c PackageCheck) Check() (bool, error)

type PackageManager ¶

type PackageManager interface {
	IsAvailable(PackageQuery) (bool, error)
	IsInstalled(PackageQuery) (bool, error)
}

PackageManager runs queries against the underlying operating system's package manager

func NewPackageManager(distro Distro) (PackageManager, error)

type PackageNotInstalledCheck ¶ added in v1.7.0

type PackageNotInstalledCheck struct {
	PackageQuery               PackageQuery
	AcceptablePackageVersion   string
	PackageManager             PackageManager
	InstallationDisabled       bool
	DockerInstallationDisabled bool
}

func (c PackageNotInstalledCheck) Check() (bool, error)

type PackageQuery ¶

type PackageQuery struct {
	Name    string
	Version string
}

PackageQuery is a query for finding a package

func (p PackageQuery) String() string

type Python2Check ¶

type Python2Check struct {
	SupportedVersions []string
}

Python2Check returns true if python 2 is installed on the node and the version prefix-matches one of the supported versions

func (c Python2Check) Check() (bool, error)

type TCPPortClientCheck ¶

type TCPPortClientCheck struct {
	// IPAddress is the IP of the remote node
	IPAddress string
	// PortNumber is the target service port
	PortNumber int
	// Timeout is the maximum amount of time the check will
	// wait when connecting to the server before bailing out
	Timeout time.Duration
}

TCPPortClientCheck verifies that a given port on a remote node is accessible through the network

func (c *TCPPortClientCheck) Check() (bool, error)

type TCPPortServerCheck ¶

type TCPPortServerCheck struct {
	PortNumber int
	ProcName   string
	// contains filtered or unexported fields
}

TCPPortServerCheck ensures that the given port is free, or bound to the right process. In the case that it is free, it stands up a TCP server that can be used to check TCP connectivity to the host using TCPPortClientCheck

func (c *TCPPortServerCheck) Check() (bool, error)

func (c *TCPPortServerCheck) Close() error