resource

type Base struct{}

type Deb struct {
	Name string `structs:"name"`
	// Suffix is either "=" followed by the version, or "/" followed by the release stream (stable|testing|unstable).
	// Examples:
	//   Name: "busybox"
	//   Name: "busybox", Suffix: "/stable"
	//   Name: "busybox", Suffix: "=1:1.27.2-2ubuntu3.2"
	Suffix string `structs:"suffix"`
}

type Dir struct {
	// Path at which to create directory
	Path fmt.Stringer `structs:"path,omitempty"`
	// RecursiveDelete makes the undo operation recursive
	RecursiveDelete bool
}

type File struct {
	// Source is a path to a local file. Only of of (Source, Content) can be
	// specified at once.
	Source string `structs:"source,omitempty"`
	// Content is the file content. Only of of (Source, Content) can be specified
	// at once.
	Content string `structs:"content,omitempty"`
	// Destination is the file destination path (required).
	Destination string `structs:"destination"`
	// File MD5 checksum. We use md5sum as it's part of coreutils and even part of
	// the default alpine image.
	Checksum string `structs:"checksum" plan:"hide"`
}

type GatherFactFunc func(ctx context.Context, o *OS, r plan.Runner) error

type KubeSecret struct {
	Base

	// SecretName is the name of the secret to read
	SecretName string `structs:"secretName"`
	// Checksum contains the sha256 checksum of the secret data
	Checksum [sha256.Size]byte `structs:"checksum"`
	// DestinationDirectory is the location in which to write stored file data
	DestinationDirectory string `structs:"destinationDirectory"`
	// SecretData holds the actual secret contents -- not serialized
	SecretData SecretData `structs:"-" plan:"hide"`
	// FileNameTransform transforms a secret key into the file name for its contents
	FileNameTransform func(string) string
}

type KubeadmInit struct {
	Base

	// PublicIP is public IP of the master node we are trying to setup here.
	PublicIP string `structs:"publicIP"`
	// PrivateIP is private IP of the master node we are trying to setup here.
	PrivateIP string `structs:"privateIP"`
	// NodeName, if non-empty, will override the default node name guessed by kubeadm.
	NodeName string
	// KubeletConfig groups all options & flags which need to be passed to kubelet.
	KubeletConfig *config.KubeletConfig `structs:"kubeletConfig"`
	// ConntrackMax is the maximum number of NAT connections for kubeproxy to track (0 to leave as-is).
	ConntrackMax int32 `structs:"conntrackMax"`
	// UseIPTables controls whether the following command is called or not:
	//   sysctl net.bridge.bridge-nf-call-iptables=1
	// prior to running kubeadm init.
	UseIPTables bool `structs:"useIPTables"`
	// kubeadmInitScriptPath is the path to the "kubeadm init" script to use.
	KubeadmInitScriptPath string `structs:"kubeadmInitScriptPath"`
	// IgnorePreflightErrors is optionally used to skip kubeadm's preflight checks.
	IgnorePreflightErrors []string `structs:"ignorePreflightErrors"`
	// SSHKeyPath is the path to the private SSH key used by WKS to SSH into
	// nodes to add/remove them to/from the Kubernetes cluster. Only one of SSHKeyPath
	// and SSHKey may be specified
	SSHKeyPath string `structs:"sshKeyPath"`
	// SSHKey is the private SSH key used by WKS to SSH into
	// nodes to add/remove them to/from the Kubernetes cluster. Only one of SSHKeyPath
	// and SSHKey may be specified
	SSHKey string `structs:"-" plan:"hide"`
	// BootstrapToken is the token used by kubeadm init and kubeadm join to
	// safely form new clusters.
	BootstrapToken *kubeadmapi.BootstrapTokenString `structs:"bootstrapToken"`
	// The version of Kubernetes to install
	KubernetesVersion string `structs:"kubernetesVersion"`
	// ControlPlaneEndpoint is the IP:port of the control plane load balancer.
	// Default: localhost:6443
	// See also: https://kubernetes.io/docs/setup/independent/high-availability/#stacked-control-plane-and-etcd-nodes
	ControlPlaneEndpoint string `structs:"controlPlaneEndpoint"`
	// Cloud provider setting which is needed for kubeadm and kubelet
	CloudProvider string `structs:"cloudProvider"`
	// ImageRepository sets the container registry to pull images from. If empty,
	// `k8s.gcr.io` will be used by default.
	ImageRepository string `structs:"imageRepository"`
	// AssetDescriptions specifies the image repository and image tag for each potentially overridden
	// asset (currently, DNS, Etcd, and Kubernetes)
	AssetDescriptions map[string]kubeadmutil.AssetDescription `structs:"assetDescriptions"`
	// AdditionalSANs can hold additional SANs to add to the API server certificate.
	AdditionalSANs []string
	// The namespace in which to init kubeadm
	Namespace fmt.Stringer
	// Extra arguments to pass to the APIServer
	ExtraAPIServerArgs map[string]string
	// The IP range for service VIPs
	ServiceCIDRBlock string
	// PodCIDRBlock is the subnet used by pods.
	PodCIDRBlock string
}

type KubeadmJoin struct {
	Base

	// IsMaster should be true if this node should join as a master, or false otherwise.
	IsMaster bool `structs:"isMaster"`
	// NodeIP is the IP of the node trying to join the cluster.
	NodeIP string `structs:"nodeIP"`
	// NodeName, if non-empty, will override the default node name guessed by kubeadm.
	NodeName string
	// MasterIP is the IP of the master node to connect to in order to join the cluster --
	// hidden because the value can change in multi-master configurations but should not make the node plan
	// appear to have changed.
	MasterIP string `structs:"masterIP" plan:"hide"`
	// MasterPort is the port of the master node to connect to in order to join the cluster.
	MasterPort int `structs:"masterPort"`
	// Token is used to authenticate with the Kubernetes API server.
	Token string `structs:"token" plan:"hide"`
	// DiscoveryTokenCaCertHash is used to validate that the root CA public key of the cluster we are trying to join matches.
	DiscoveryTokenCaCertHash string `structs:"discoveryTokenCaCertHash" plan:"hide"`
	// CertificateKey is used to add master nodes to the cluster.
	CertificateKey string `structs:"certificateKey" plan:"hide"`
	// IgnorePreflightErrors is optionally used to skip kubeadm's preflight checks.
	IgnorePreflightErrors []string `structs:"ignorePreflightErrors"`
	// External Load Balancer name or IP address to be used instead of the master's IP
	ControlPlaneEndpoint string `structs:"controlPlaneEndpoint"`
	// Kubernetes Version is used to prepare different parameters
	KubernetesVersion string `structs:"version"`
}

type KubectlAnnotateSingleNode struct {
	Base

	Key   string // Which annotation to apply
	Value string // Value of annotation
}

type KubectlApply struct {
	Base

	// Filename is the remote manifest file name.
	// Only provide this if you do NOT provide ManifestPath or ManifestURL.
	Filename fmt.Stringer `structs:"filename"`
	// Suffix to append to image tags if required (e.g. EKS-D has a special tag suffix of "-eks-1-18-1")
	ImageSuffix fmt.Stringer `structs:"imageSuffix:omitempty"`
	// Manifest is the actual YAML/JSON content of the manifest to apply.
	// If this is provided, then there is no need to provide ManifestPath, but
	// Filename should be provided in order to name the remote manifest file.
	Manifest []byte `structs:"manifest"`
	// ManifestPath is the path to the manifest to apply.
	// If this is provided, then there is no need to provide Manifest.
	ManifestPath fmt.Stringer `structs:"manifestPath"`
	// ManifestURL is the URL of a remote manifest; if specified,
	// neither Filename, Manifest, nor ManifestPath should be specified.
	ManifestURL fmt.Stringer `structs:"manifestURL"`
	// WaitCondition, if not empty, makes Apply() perform "kubectl wait --for=<value>" on the resource.
	Namespace fmt.Stringer `structs:"namespace"`
	// OpaqueManifest is an alternative to Manifest for a resource to
	// apply whose content should not be exposed in a serialized plan.
	// If this is provided, then there is no need to provide
	// ManifestPath, but Filename should be provided in order to name
	// the remote manifest file.
	OpaqueManifest []byte `structs:"-" plan:"hide"`
	// ManifestPath is the path to the manifest to apply.
	// If this is provided, then there is no need to provide Manifest.
	// For example, waiting for "condition=established" is required after creating a CRD - see issue #530.
	WaitCondition string `structs:"afterApplyWaitsFor"`
}

type KubectlApplyArgs struct {
	// Content is the YAML manifest to be applied. Must be non-empty.
	Content []byte
	// WaitCondition, if non-empty, makes RunKubectlApply do "kubectl wait --for=<value>" on the applied resource.
	WaitCondition string
}

type KubectlWait struct {
	Base

	// Namespace specifies the namespace in which to search for the object being waited on
	WaitNamespace string `structs:"namespace"`
	// WaitType specifies the object type to wait for
	WaitType string `structs:"typeWaitedFor"`
	// WaitSelector, if not empty, specifies which instances of the type to wait for
	WaitSelector string `structs:"itemsWaitedFor"`
	// WaitCondition specifies the condition to wait for
	WaitCondition string `structs:"waitFor"`
	// WaitTimeout, if specified, indicates how long to wait for the WaitCondition to become true before failing (default 30s)
	WaitTimeout string `structs:"waitTimeout"`
}

type OS struct {
	MachineID  string `structs:"MachineID"`
	SystemUUID string `structs:"SystemUUID"`
	// contains filtered or unexported fields
}

type PkgType string

type RPM struct {
	Name string `structs:"name"`
	// Version is optional
	Version             string `structs:"version,omitempty"`
	Release             string `structs:"release,omitempty"`
	IgnoreOtherVersions bool   `structs:"ignoreOtherVersions,omitempty"`
	DisableExcludes     string `structs:"disableExcludes,omitempty"`
}

type Run struct {
	Base

	Script       fmt.Stringer  `structs:"script"`
	UndoScript   fmt.Stringer  `structs:"undoScript,omitempty"`
	UndoResource plan.Resource `structs:"undoResource,omitempty"`
	Output       *string       // for later resources to use
}

type SELinuxMode int

type SELinuxStatus int

type SecretData map[string][]byte

type Service struct {
	// Name of the systemd unit.
	Name string `structs:"name"`
	// Status is the desired service status. Only "active" or "inactive" are valid
	// input.
	Status string `structs:"status"`
	// Whether the service is enabled (systemctl enable) or not.
	Enabled bool `structs:"enabled"`
}