v1beta1

package
v1.9.0-rc.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 3, 2024 License: Apache-2.0 Imports: 21 Imported by: 1,494

Documentation

Overview

Package v1beta1 contains the v1beta1 API implementation. +k8s:openapi-gen=true

Package v1beta1 contains API Schema definitions for the cluster v1beta1 API group +kubebuilder:object:generate=true +groupName=cluster.x-k8s.io

Index

Constants

View Source 
const (
	// ClusterPhasePending is the first state a Cluster is assigned by
	// Cluster API Cluster controller after being created.
	ClusterPhasePending = ClusterPhase("Pending")

	// ClusterPhaseProvisioning is the state when the Cluster has a infrastructure
	// object or a control plane object that can start provisioning the control plane endpoint.
	ClusterPhaseProvisioning = ClusterPhase("Provisioning")

	// ClusterPhaseProvisioned is the state when its control plane endpoint has been created and configured
	// and the infrastructure object is ready (if defined).
	// Note: When a cluster reaches this phase parts of the control plane or worker machines might be still provisioning.
	ClusterPhaseProvisioned = ClusterPhase("Provisioned")

	// ClusterPhaseDeleting is the Cluster state when a delete
	// request has been sent to the API Server,
	// but its infrastructure has not yet been fully deleted.
	ClusterPhaseDeleting = ClusterPhase("Deleting")

	// ClusterPhaseFailed is the Cluster state when the system
	// might require user intervention.
	ClusterPhaseFailed = ClusterPhase("Failed")

	// ClusterPhaseUnknown is returned if the Cluster state cannot be determined.
	ClusterPhaseUnknown = ClusterPhase("Unknown")
)
View Source 
const (
	// ClusterFinalizer is the finalizer used by the cluster controller to
	// cleanup the cluster resources when a Cluster is being deleted.
	ClusterFinalizer = "cluster.cluster.x-k8s.io"

	// ClusterKind represents the Kind of Cluster.
	ClusterKind = "Cluster"
)
View Source 
const (
	// ClusterAvailableV1Beta2Condition is true if the Cluster is not deleted, and RemoteConnectionProbe, InfrastructureReady,
	// ControlPlaneAvailable, WorkersAvailable, TopologyReconciled (if present) conditions are true.
	// If conditions are defined in spec.availabilityGates, those conditions must be true as well.
	// Note:
	// - When summarizing TopologyReconciled, all reasons except TopologyReconcileFailed and ClusterClassNotReconciled will
	//   be treated as info. This is because even if topology is not fully reconciled, this is an expected temporary state
	//   and it doesn't impact availability.
	// - When summarizing InfrastructureReady, ControlPlaneAvailable, in case the Cluster is deleting, the absence of the
	//   referenced object won't be considered as an issue.
	ClusterAvailableV1Beta2Condition = AvailableV1Beta2Condition

	// ClusterAvailableV1Beta2Reason surfaces when the cluster availability criteria is met.
	ClusterAvailableV1Beta2Reason = AvailableV1Beta2Reason

	// ClusterNotAvailableV1Beta2Reason surfaces when the cluster availability criteria is not met (and thus the machine is not available).
	ClusterNotAvailableV1Beta2Reason = NotAvailableV1Beta2Reason

	// ClusterAvailableUnknownV1Beta2Reason surfaces when at least one cluster availability criteria is unknown
	// and no availability criteria is not met.
	ClusterAvailableUnknownV1Beta2Reason = AvailableUnknownV1Beta2Reason

	// ClusterAvailableInternalErrorV1Beta2Reason surfaces unexpected error when computing the Available condition.
	ClusterAvailableInternalErrorV1Beta2Reason = InternalErrorV1Beta2Reason
)

Cluster's Available condition and corresponding reasons that will be used in v1Beta2 API version.

View Source 
const (
	// ClusterTopologyReconciledV1Beta2Condition is true if the topology controller is working properly.
	// Note: This condition is added only if the Cluster is referencing a ClusterClass / defining a managed Topology.
	ClusterTopologyReconciledV1Beta2Condition = "TopologyReconciled"

	// ClusterTopologyReconcileSucceededV1Beta2Reason documents the reconciliation of a Cluster topology succeeded.
	ClusterTopologyReconcileSucceededV1Beta2Reason = "ReconcileSucceeded"

	// ClusterTopologyReconciledFailedV1Beta2Reason documents the reconciliation of a Cluster topology
	// failing due to an error.
	ClusterTopologyReconciledFailedV1Beta2Reason = "ReconcileFailed"

	// ClusterTopologyReconciledControlPlaneUpgradePendingV1Beta2Reason documents reconciliation of a Cluster topology
	// not yet completed because Control Plane is not yet updated to match the desired topology spec.
	ClusterTopologyReconciledControlPlaneUpgradePendingV1Beta2Reason = "ControlPlaneUpgradePending"

	// ClusterTopologyReconciledMachineDeploymentsCreatePendingV1Beta2Reason documents reconciliation of a Cluster topology
	// not yet completed because at least one of the MachineDeployments is yet to be created.
	// This generally happens because new MachineDeployment creations are held off while the ControlPlane is not stable.
	ClusterTopologyReconciledMachineDeploymentsCreatePendingV1Beta2Reason = "MachineDeploymentsCreatePending"

	// ClusterTopologyReconciledMachineDeploymentsUpgradePendingV1Beta2Reason documents reconciliation of a Cluster topology
	// not yet completed because at least one of the MachineDeployments is not yet updated to match the desired topology spec.
	ClusterTopologyReconciledMachineDeploymentsUpgradePendingV1Beta2Reason = "MachineDeploymentsUpgradePending"

	// ClusterTopologyReconciledMachineDeploymentsUpgradeDeferredV1Beta2Reason documents reconciliation of a Cluster topology
	// not yet completed because the upgrade for at least one of the MachineDeployments has been deferred.
	ClusterTopologyReconciledMachineDeploymentsUpgradeDeferredV1Beta2Reason = "MachineDeploymentsUpgradeDeferred"

	// ClusterTopologyReconciledMachinePoolsUpgradePendingV1Beta2Reason documents reconciliation of a Cluster topology
	// not yet completed because at least one of the MachinePools is not yet updated to match the desired topology spec.
	ClusterTopologyReconciledMachinePoolsUpgradePendingV1Beta2Reason = "MachinePoolsUpgradePending"

	// ClusterTopologyReconciledMachinePoolsCreatePendingV1Beta2Reason documents reconciliation of a Cluster topology
	// not yet completed because at least one of the MachinePools is yet to be created.
	// This generally happens because new MachinePool creations are held off while the ControlPlane is not stable.
	ClusterTopologyReconciledMachinePoolsCreatePendingV1Beta2Reason = "MachinePoolsCreatePending"

	// ClusterTopologyReconciledMachinePoolsUpgradeDeferredV1Beta2Reason documents reconciliation of a Cluster topology
	// not yet completed because the upgrade for at least one of the MachinePools has been deferred.
	ClusterTopologyReconciledMachinePoolsUpgradeDeferredV1Beta2Reason = "MachinePoolsUpgradeDeferred"

	// ClusterTopologyReconciledHookBlockingV1Beta2Reason documents reconciliation of a Cluster topology
	// not yet completed because at least one of the lifecycle hooks is blocking.
	ClusterTopologyReconciledHookBlockingV1Beta2Reason = "LifecycleHookBlocking"

	// ClusterTopologyReconciledClusterClassNotReconciledV1Beta2Reason documents reconciliation of a Cluster topology not
	// yet completed because the ClusterClass has not reconciled yet. If this condition persists there may be an issue
	// with the ClusterClass surfaced in the ClusterClass status or controller logs.
	ClusterTopologyReconciledClusterClassNotReconciledV1Beta2Reason = "ClusterClassNotReconciled"

	// ClusterTopologyReconciledDeletingV1Beta2Reason surfaces when the Cluster is deleting because the
	// DeletionTimestamp is set.
	ClusterTopologyReconciledDeletingV1Beta2Reason = DeletingV1Beta2Reason

	// ClusterTopologyReconcilePausedV1Beta2Reason surfaces when the Cluster is paused.
	ClusterTopologyReconcilePausedV1Beta2Reason = PausedV1Beta2Reason
)

Cluster's TopologyReconciled condition and corresponding reasons that will be used in v1Beta2 API version.

View Source 
const (
	// ClusterInfrastructureReadyV1Beta2Condition mirrors Cluster's infrastructure Ready condition.
	ClusterInfrastructureReadyV1Beta2Condition = InfrastructureReadyV1Beta2Condition

	// ClusterInfrastructureReadyV1Beta2Reason surfaces when the cluster infrastructure is ready.
	ClusterInfrastructureReadyV1Beta2Reason = ReadyV1Beta2Reason

	// ClusterInfrastructureNotReadyV1Beta2Reason surfaces when the cluster infrastructure is not ready.
	ClusterInfrastructureNotReadyV1Beta2Reason = NotReadyV1Beta2Reason

	// ClusterInfrastructureInvalidConditionReportedV1Beta2Reason surfaces a infrastructure Ready condition (read from an infra cluster object) which is invalid
	// (e.g. its status is missing).
	ClusterInfrastructureInvalidConditionReportedV1Beta2Reason = InvalidConditionReportedV1Beta2Reason

	// ClusterInfrastructureInternalErrorV1Beta2Reason surfaces unexpected failures when reading an infra cluster object.
	ClusterInfrastructureInternalErrorV1Beta2Reason = InternalErrorV1Beta2Reason

	// ClusterInfrastructureDoesNotExistV1Beta2Reason surfaces when a referenced infrastructure object does not exist.
	// Note: this could happen when creating the Cluster. However, this state should be treated as an error if it lasts indefinitely.
	ClusterInfrastructureDoesNotExistV1Beta2Reason = ObjectDoesNotExistV1Beta2Reason

	// ClusterInfrastructureDeletedV1Beta2Reason surfaces when a referenced infrastructure object has been deleted.
	// Note: controllers can't identify if the infrastructure object was deleted by the controller itself, e.g.
	// during the deletion workflow, or by a users.
	ClusterInfrastructureDeletedV1Beta2Reason = ObjectDeletedV1Beta2Reason
)

Cluster's InfrastructureReady condition and corresponding reasons that will be used in v1Beta2 API version.

View Source 
const (
	// ClusterControlPlaneInitializedV1Beta2Condition is true when the Cluster's control plane is functional enough
	// to accept requests. This information is usually used as a signal for starting all the provisioning operations
	// that depends on a functional API server, but do not require a full HA control plane to exists.
	// Note: Once set to true, this condition will never change.
	ClusterControlPlaneInitializedV1Beta2Condition = "ControlPlaneInitialized"

	// ClusterControlPlaneInitializedV1Beta2Reason surfaces when the cluster control plane is initialized.
	ClusterControlPlaneInitializedV1Beta2Reason = "Initialized"

	// ClusterControlPlaneNotInitializedV1Beta2Reason surfaces when the cluster control plane is not yet initialized.
	ClusterControlPlaneNotInitializedV1Beta2Reason = "NotInitialized"

	// ClusterControlPlaneInitializedInternalErrorV1Beta2Reason surfaces unexpected failures when computing the
	// ControlPlaneInitialized condition.
	ClusterControlPlaneInitializedInternalErrorV1Beta2Reason = InternalErrorV1Beta2Reason
)

Cluster's ControlPlaneInitialized condition and corresponding reasons that will be used in v1Beta2 API version.

View Source 
const (
	// ClusterControlPlaneAvailableV1Beta2Condition is a mirror of Cluster's control plane Available condition.
	ClusterControlPlaneAvailableV1Beta2Condition = "ControlPlaneAvailable"

	// ClusterControlPlaneAvailableV1Beta2Reason surfaces when the cluster control plane is available.
	ClusterControlPlaneAvailableV1Beta2Reason = AvailableV1Beta2Reason

	// ClusterControlPlaneNotAvailableV1Beta2Reason surfaces when the cluster control plane is not available.
	ClusterControlPlaneNotAvailableV1Beta2Reason = NotAvailableV1Beta2Reason

	// ClusterControlPlaneInvalidConditionReportedV1Beta2Reason surfaces a control plane Available condition (read from a control plane object) which is invalid.
	// (e.g. its status is missing).
	ClusterControlPlaneInvalidConditionReportedV1Beta2Reason = InvalidConditionReportedV1Beta2Reason

	// ClusterControlPlaneInternalErrorV1Beta2Reason surfaces unexpected failures when reading a control plane object.
	ClusterControlPlaneInternalErrorV1Beta2Reason = InternalErrorV1Beta2Reason

	// ClusterControlPlaneDoesNotExistV1Beta2Reason surfaces when a referenced control plane object does not exist.
	// Note: this could happen when creating the Cluster. However, this state should be treated as an error if it lasts indefinitely.
	ClusterControlPlaneDoesNotExistV1Beta2Reason = ObjectDoesNotExistV1Beta2Reason

	// ClusterControlPlaneDeletedV1Beta2Reason surfaces when a referenced control plane object has been deleted.
	// Note: controllers can't identify if the control plane object was deleted by the controller itself, e.g.
	// during the deletion workflow, or by a users.
	ClusterControlPlaneDeletedV1Beta2Reason = ObjectDeletedV1Beta2Reason
)

Cluster's ControlPlaneAvailable condition and corresponding reasons that will be used in v1Beta2 API version.

View Source 
const (
	// ClusterWorkersAvailableV1Beta2Condition is the summary of MachineDeployment and MachinePool's Available conditions.
	// Note: Stand-alone MachineSets and stand-alone Machines are not included in this condition.
	ClusterWorkersAvailableV1Beta2Condition = "WorkersAvailable"

	// ClusterWorkersAvailableV1Beta2Reason surfaces when all  MachineDeployment and MachinePool's Available conditions are true.
	ClusterWorkersAvailableV1Beta2Reason = AvailableV1Beta2Reason

	// ClusterWorkersNotAvailableV1Beta2Reason surfaces when at least one of the  MachineDeployment and MachinePool's Available
	// conditions is false.
	ClusterWorkersNotAvailableV1Beta2Reason = NotAvailableV1Beta2Reason

	// ClusterWorkersAvailableUnknownV1Beta2Reason surfaces when at least one of the  MachineDeployment and MachinePool's Available
	// conditions is unknown and none of those Available conditions is false.
	ClusterWorkersAvailableUnknownV1Beta2Reason = AvailableUnknownV1Beta2Reason

	// ClusterWorkersAvailableNoWorkersV1Beta2Reason surfaces when no MachineDeployment and MachinePool exist for the Cluster.
	ClusterWorkersAvailableNoWorkersV1Beta2Reason = "NoWorkers"

	// ClusterWorkersAvailableInternalErrorV1Beta2Reason surfaces unexpected failures when listing MachineDeployment and MachinePool
	// or aggregating conditions from those objects.
	ClusterWorkersAvailableInternalErrorV1Beta2Reason = InternalErrorV1Beta2Reason
)

Cluster's WorkersAvailable condition and corresponding reasons that will be used in v1Beta2 API version.

View Source 
const (
	// ClusterControlPlaneMachinesReadyV1Beta2Condition surfaces detail of issues on control plane machines, if any.
	ClusterControlPlaneMachinesReadyV1Beta2Condition = "ControlPlaneMachinesReady"

	// ClusterControlPlaneMachinesReadyV1Beta2Reason surfaces when all control plane machine's Ready conditions are true.
	ClusterControlPlaneMachinesReadyV1Beta2Reason = ReadyV1Beta2Reason

	// ClusterControlPlaneMachinesNotReadyV1Beta2Reason surfaces when at least one of control plane machine's Ready conditions is false.
	ClusterControlPlaneMachinesNotReadyV1Beta2Reason = NotReadyV1Beta2Reason

	// ClusterControlPlaneMachinesReadyUnknownV1Beta2Reason surfaces when at least one of control plane machine's Ready conditions is unknown
	// and none of control plane machine's Ready conditions is false.
	ClusterControlPlaneMachinesReadyUnknownV1Beta2Reason = ReadyUnknownV1Beta2Reason

	// ClusterControlPlaneMachinesReadyNoReplicasV1Beta2Reason surfaces when no control plane machines exist for the Cluster.
	ClusterControlPlaneMachinesReadyNoReplicasV1Beta2Reason = NoReplicasV1Beta2Reason

	// ClusterControlPlaneMachinesReadyInternalErrorV1Beta2Reason surfaces unexpected failures when listing control plane machines
	// or aggregating control plane machine's conditions.
	ClusterControlPlaneMachinesReadyInternalErrorV1Beta2Reason = InternalErrorV1Beta2Reason
)

Cluster's ControlPlaneMachinesReady condition and corresponding reasons that will be used in v1Beta2 API version.

View Source 
const (
	// ClusterWorkerMachinesReadyV1Beta2Condition surfaces detail of issues on the worker machines, if any.
	ClusterWorkerMachinesReadyV1Beta2Condition = "WorkerMachinesReady"

	// ClusterWorkerMachinesReadyV1Beta2Reason surfaces when all the worker machine's Ready conditions are true.
	ClusterWorkerMachinesReadyV1Beta2Reason = ReadyV1Beta2Reason

	// ClusterWorkerMachinesNotReadyV1Beta2Reason surfaces when at least one of the worker machine's Ready conditions is false.
	ClusterWorkerMachinesNotReadyV1Beta2Reason = NotReadyV1Beta2Reason

	// ClusterWorkerMachinesReadyUnknownV1Beta2Reason surfaces when at least one of the worker machine's Ready conditions is unknown
	// and none of the worker machine's Ready conditions is false.
	ClusterWorkerMachinesReadyUnknownV1Beta2Reason = ReadyUnknownV1Beta2Reason

	// ClusterWorkerMachinesReadyNoReplicasV1Beta2Reason surfaces when no worker machines exist for the Cluster.
	ClusterWorkerMachinesReadyNoReplicasV1Beta2Reason = NoReplicasV1Beta2Reason

	// ClusterWorkerMachinesReadyInternalErrorV1Beta2Reason surfaces unexpected failures when listing worker machines
	// or aggregating worker machine's conditions.
	ClusterWorkerMachinesReadyInternalErrorV1Beta2Reason = InternalErrorV1Beta2Reason
)

Cluster's WorkerMachinesReady condition and corresponding reasons that will be used in v1Beta2 API version.

View Source 
const (
	// ClusterControlPlaneMachinesUpToDateV1Beta2Condition surfaces details of control plane machines not up to date, if any.
	// Note: New machines are considered 10s after machine creation. This gives time to the machine's owner controller to recognize the new machine and add the UpToDate condition.
	ClusterControlPlaneMachinesUpToDateV1Beta2Condition = "ControlPlaneMachinesUpToDate"

	// ClusterControlPlaneMachinesUpToDateV1Beta2Reason surfaces when all the control plane machine's UpToDate conditions are true.
	ClusterControlPlaneMachinesUpToDateV1Beta2Reason = UpToDateV1Beta2Reason

	// ClusterControlPlaneMachinesNotUpToDateV1Beta2Reason surfaces when at least one of the control plane machine's UpToDate conditions is false.
	ClusterControlPlaneMachinesNotUpToDateV1Beta2Reason = NotUpToDateV1Beta2Reason

	// ClusterControlPlaneMachinesUpToDateUnknownV1Beta2Reason surfaces when at least one of the control plane machine's UpToDate conditions is unknown
	// and none of the control plane machine's UpToDate conditions is false.
	ClusterControlPlaneMachinesUpToDateUnknownV1Beta2Reason = UpToDateUnknownV1Beta2Reason

	// ClusterControlPlaneMachinesUpToDateNoReplicasV1Beta2Reason surfaces when no control plane machines exist for the Cluster.
	ClusterControlPlaneMachinesUpToDateNoReplicasV1Beta2Reason = NoReplicasV1Beta2Reason

	// ClusterControlPlaneMachinesUpToDateInternalErrorV1Beta2Reason surfaces unexpected failures when listing control plane machines
	// or aggregating status.
	ClusterControlPlaneMachinesUpToDateInternalErrorV1Beta2Reason = InternalErrorV1Beta2Reason
)

Cluster's ControlPlaneMachinesUpToDate condition and corresponding reasons that will be used in v1Beta2 API version.

View Source 
const (
	// ClusterWorkerMachinesUpToDateV1Beta2Condition surfaces details of worker machines not up to date, if any.
	// Note: New machines are considered 10s after machine creation. This gives time to the machine's owner controller to recognize the new machine and add the UpToDate condition.
	ClusterWorkerMachinesUpToDateV1Beta2Condition = "WorkerMachinesUpToDate"

	// ClusterWorkerMachinesUpToDateV1Beta2Reason surfaces when all the worker machine's UpToDate conditions are true.
	ClusterWorkerMachinesUpToDateV1Beta2Reason = UpToDateV1Beta2Reason

	// ClusterWorkerMachinesNotUpToDateV1Beta2Reason surfaces when at least one of the worker machine's UpToDate conditions is false.
	ClusterWorkerMachinesNotUpToDateV1Beta2Reason = NotUpToDateV1Beta2Reason

	// ClusterWorkerMachinesUpToDateUnknownV1Beta2Reason surfaces when at least one of the worker machine's UpToDate conditions is unknown
	// and none of the worker machine's UpToDate conditions is false.
	ClusterWorkerMachinesUpToDateUnknownV1Beta2Reason = UpToDateUnknownV1Beta2Reason

	// ClusterWorkerMachinesUpToDateNoReplicasV1Beta2Reason surfaces when no worker machines exist for the Cluster.
	ClusterWorkerMachinesUpToDateNoReplicasV1Beta2Reason = NoReplicasV1Beta2Reason

	// ClusterWorkerMachinesUpToDateInternalErrorV1Beta2Reason surfaces unexpected failures when listing worker machines
	// or aggregating status.
	ClusterWorkerMachinesUpToDateInternalErrorV1Beta2Reason = InternalErrorV1Beta2Reason
)

Cluster's WorkerMachinesUpToDate condition and corresponding reasons that will be used in v1Beta2 API version.

View Source 
const (
	// ClusterRemoteConnectionProbeV1Beta2Condition is true when control plane can be reached; in case of connection problems.
	// The condition turns to false only if the cluster cannot be reached for 50s after the first connection problem
	// is detected (or whatever period is defined in the --remote-connection-grace-period flag).
	ClusterRemoteConnectionProbeV1Beta2Condition = "RemoteConnectionProbe"

	// ClusterRemoteConnectionProbeFailedV1Beta2Reason surfaces issues with the connection to the workload cluster.
	ClusterRemoteConnectionProbeFailedV1Beta2Reason = "ProbeFailed"

	// ClusterRemoteConnectionProbeSucceededV1Beta2Reason is used to report a working connection with the workload cluster.
	ClusterRemoteConnectionProbeSucceededV1Beta2Reason = "ProbeSucceeded"
)

Cluster's RemoteConnectionProbe condition and corresponding reasons that will be used in v1Beta2 API version.

View Source 
const (
	// ClusterRollingOutV1Beta2Condition is the summary of `RollingOut` conditions from ControlPlane, MachineDeployments
	// and MachinePools.
	ClusterRollingOutV1Beta2Condition = RollingOutV1Beta2Condition

	// ClusterRollingOutV1Beta2Reason surfaces when at least one of the Cluster's control plane, MachineDeployments,
	// or MachinePools are rolling out.
	ClusterRollingOutV1Beta2Reason = RollingOutV1Beta2Reason

	// ClusterNotRollingOutV1Beta2Reason surfaces when none of the Cluster's control plane, MachineDeployments,
	// or MachinePools are rolling out.
	ClusterNotRollingOutV1Beta2Reason = NotRollingOutV1Beta2Reason

	// ClusterRollingOutUnknownV1Beta2Reason surfaces when one of the Cluster's control plane, MachineDeployments,
	// or MachinePools rolling out condition is unknown, and none true.
	ClusterRollingOutUnknownV1Beta2Reason = "RollingOutUnknown"

	// ClusterRollingOutInternalErrorV1Beta2Reason surfaces unexpected failures when listing machines
	// or computing the RollingOut condition.
	ClusterRollingOutInternalErrorV1Beta2Reason = InternalErrorV1Beta2Reason
)

Cluster's RollingOut condition and corresponding reasons that will be used in v1Beta2 API version.

View Source 
const (
	// ClusterScalingUpV1Beta2Condition is the summary of `ScalingUp` conditions from ControlPlane, MachineDeployments,
	// MachinePools and stand-alone MachineSets.
	ClusterScalingUpV1Beta2Condition = ScalingUpV1Beta2Condition

	// ClusterScalingUpV1Beta2Reason surfaces when at least one of the Cluster's control plane, MachineDeployments,
	// MachinePools and stand-alone MachineSets are scaling up.
	ClusterScalingUpV1Beta2Reason = ScalingUpV1Beta2Reason

	// ClusterNotScalingUpV1Beta2Reason surfaces when none of the Cluster's control plane, MachineDeployments,
	// MachinePools and stand-alone MachineSets are scaling up.
	ClusterNotScalingUpV1Beta2Reason = NotScalingUpV1Beta2Reason

	// ClusterScalingUpUnknownV1Beta2Reason surfaces when one of the Cluster's control plane, MachineDeployments,
	// MachinePools and stand-alone MachineSets scaling up condition is unknown, and none true.
	ClusterScalingUpUnknownV1Beta2Reason = "ScalingUpUnknown"

	// ClusterScalingUpInternalErrorV1Beta2Reason surfaces unexpected failures when listing machines
	// or computing the ScalingUp condition.
	ClusterScalingUpInternalErrorV1Beta2Reason = InternalErrorV1Beta2Reason
)

Cluster's ScalingUp condition and corresponding reasons that will be used in v1Beta2 API version.

View Source 
const (
	// ClusterScalingDownV1Beta2Condition is the summary of `ScalingDown` conditions from ControlPlane, MachineDeployments,
	// MachinePools and stand-alone MachineSets.
	ClusterScalingDownV1Beta2Condition = ScalingDownV1Beta2Condition

	// ClusterScalingDownV1Beta2Reason surfaces when at least one of the Cluster's control plane, MachineDeployments,
	// MachinePools and stand-alone MachineSets are scaling down.
	ClusterScalingDownV1Beta2Reason = ScalingDownV1Beta2Reason

	// ClusterNotScalingDownV1Beta2Reason surfaces when none of the Cluster's control plane, MachineDeployments,
	// MachinePools and stand-alone MachineSets are scaling down.
	ClusterNotScalingDownV1Beta2Reason = NotScalingDownV1Beta2Reason

	// ClusterScalingDownUnknownV1Beta2Reason surfaces when one of the Cluster's control plane, MachineDeployments,
	// MachinePools and stand-alone MachineSets scaling down condition is unknown, and none true.
	ClusterScalingDownUnknownV1Beta2Reason = "ScalingDownUnknown"

	// ClusterScalingDownInternalErrorV1Beta2Reason surfaces unexpected failures when listing machines
	// or computing the ScalingDown condition.
	ClusterScalingDownInternalErrorV1Beta2Reason = InternalErrorV1Beta2Reason
)

Cluster's ScalingDown condition and corresponding reasons that will be used in v1Beta2 API version.

View Source 
const (
	// ClusterRemediatingV1Beta2Condition surfaces details about ongoing remediation of the controlled machines, if any.
	ClusterRemediatingV1Beta2Condition = RemediatingV1Beta2Condition

	// ClusterRemediatingV1Beta2Reason surfaces when the Cluster has at least one machine with HealthCheckSucceeded set to false
	// and with the OwnerRemediated condition set to false.
	ClusterRemediatingV1Beta2Reason = RemediatingV1Beta2Reason

	// ClusterNotRemediatingV1Beta2Reason surfaces when the Cluster does not have any machine with HealthCheckSucceeded set to false
	// and with the OwnerRemediated condition set to false.
	ClusterNotRemediatingV1Beta2Reason = NotRemediatingV1Beta2Reason

	// ClusterRemediatingInternalErrorV1Beta2Reason surfaces unexpected failures when computing the Remediating condition.
	ClusterRemediatingInternalErrorV1Beta2Reason = InternalErrorV1Beta2Reason
)

Cluster's Remediating condition and corresponding reasons that will be used in v1Beta2 API version.

View Source 
const (
	// ClusterDeletingV1Beta2Condition surfaces details about ongoing deletion of the cluster.
	ClusterDeletingV1Beta2Condition = DeletingV1Beta2Condition

	// ClusterNotDeletingV1Beta2Reason surfaces when the Cluster is not deleting because the
	// DeletionTimestamp is not set.
	ClusterNotDeletingV1Beta2Reason = NotDeletingV1Beta2Reason

	// ClusterDeletingWaitingForBeforeDeleteHookV1Beta2Reason surfaces when the Cluster deletion
	// waits for the ClusterDelete hooks to allow deletion to complete.
	ClusterDeletingWaitingForBeforeDeleteHookV1Beta2Reason = "WaitingForBeforeDeleteHook"

	// ClusterDeletingWaitingForWorkersDeletionV1Beta2Reason surfaces when the Cluster deletion
	// waits for the workers Machines and the object controlling those machines (MachinePools, MachineDeployments, MachineSets)
	// to be deleted.
	ClusterDeletingWaitingForWorkersDeletionV1Beta2Reason = "WaitingForWorkersDeletion"

	// ClusterDeletingWaitingForControlPlaneDeletionV1Beta2Reason surfaces when the Cluster deletion
	// waits for the ControlPlane to be deleted.
	ClusterDeletingWaitingForControlPlaneDeletionV1Beta2Reason = "WaitingForControlPlaneDeletion"

	// ClusterDeletingWaitingForInfrastructureDeletionV1Beta2Reason surfaces when the Cluster deletion
	// waits for the InfraCluster to be deleted.
	ClusterDeletingWaitingForInfrastructureDeletionV1Beta2Reason = "WaitingForInfrastructureDeletion"

	// ClusterDeletingDeletionCompletedV1Beta2Reason surfaces when the Cluster deletion has been completed.
	// This reason is set right after the `cluster.cluster.x-k8s.io` finalizer is removed.
	// This means that the object will go away (i.e. be removed from etcd), except if there are other
	// finalizers on the Cluster object.
	ClusterDeletingDeletionCompletedV1Beta2Reason = DeletionCompletedV1Beta2Reason

	// ClusterDeletingInternalErrorV1Beta2Reason surfaces unexpected failures when deleting a cluster.
	ClusterDeletingInternalErrorV1Beta2Reason = InternalErrorV1Beta2Reason
)

Cluster's Deleting condition and corresponding reasons that will be used in v1Beta2 API version.

View Source 
const (
	// ClusterClassVariablesReadyV1Beta2Condition is true if the ClusterClass variables, including both inline and external
	// variables, have been successfully reconciled and thus ready to be used to default and validate variables on Clusters using
	// this ClusterClass.
	ClusterClassVariablesReadyV1Beta2Condition = "VariablesReady"

	// ClusterClassVariablesReadyV1Beta2Reason surfaces that the variables are ready.
	ClusterClassVariablesReadyV1Beta2Reason = "VariablesReady"

	// ClusterClassVariablesReadyVariableDiscoveryFailedV1Beta2Reason surfaces that variable discovery failed.
	ClusterClassVariablesReadyVariableDiscoveryFailedV1Beta2Reason = "VariableDiscoveryFailed"
)

ClusterClass VariablesReady condition and corresponding reasons that will be used in v1Beta2 API version.

View Source 
const (
	// ClusterClassRefVersionsUpToDateV1Beta2Condition documents if the references in the ClusterClass are
	// up-to-date (i.e. they are using the latest apiVersion of the current Cluster API contract from
	// the corresponding CRD).
	ClusterClassRefVersionsUpToDateV1Beta2Condition = "RefVersionsUpToDate"

	// ClusterClassRefVersionsUpToDateV1Beta2Reason surfaces that the references in the ClusterClass are
	// up-to-date (i.e. they are using the latest apiVersion of the current Cluster API contract from
	// the corresponding CRD).
	ClusterClassRefVersionsUpToDateV1Beta2Reason = "RefVersionsUpToDate"

	// ClusterClassRefVersionsNotUpToDateV1Beta2Reason surfaces that the references in the ClusterClass are not
	// up-to-date (i.e. they are not using the latest apiVersion of the current Cluster API contract from
	// the corresponding CRD).
	ClusterClassRefVersionsNotUpToDateV1Beta2Reason = "RefVersionsNotUpToDate"

	// ClusterClassRefVersionsUpToDateInternalErrorV1Beta2Reason surfaces that an unexpected error occurred when validating
	// if the references are up-to-date.
	ClusterClassRefVersionsUpToDateInternalErrorV1Beta2Reason = InternalErrorV1Beta2Reason
)

ClusterClass RefVersionsUpToDate condition and corresponding reasons that will be used in v1Beta2 API version.

View Source 
const (
	// ClusterNameLabel is the label set on machines linked to a cluster and
	// external objects(bootstrap and infrastructure providers).
	ClusterNameLabel = "cluster.x-k8s.io/cluster-name"

	// ClusterTopologyOwnedLabel is the label set on all the object which are managed as part of a ClusterTopology.
	ClusterTopologyOwnedLabel = "topology.cluster.x-k8s.io/owned"

	// ClusterTopologyMachineDeploymentNameLabel is the label set on the generated  MachineDeployment objects
	// to track the name of the MachineDeployment topology it represents.
	ClusterTopologyMachineDeploymentNameLabel = "topology.cluster.x-k8s.io/deployment-name"

	// ClusterTopologyHoldUpgradeSequenceAnnotation can be used to hold the entire MachineDeployment upgrade sequence.
	// If the annotation is set on a MachineDeployment topology in Cluster.spec.topology.workers, the Kubernetes upgrade
	// for this MachineDeployment topology and all subsequent ones is deferred.
	// Examples:
	// - If you want to pause upgrade after CP upgrade, this annotation should be applied to the first MachineDeployment
	//   in the list of MachineDeployments in Cluster.spec.topology. The upgrade will not be completed until the annotation
	//   is removed and all MachineDeployments are upgraded.
	// - If you want to pause upgrade after the 50th MachineDeployment, this annotation should be applied to the 51st
	//   MachineDeployment in the list.
	ClusterTopologyHoldUpgradeSequenceAnnotation = "topology.cluster.x-k8s.io/hold-upgrade-sequence"

	// ClusterTopologyDeferUpgradeAnnotation can be used to defer the Kubernetes upgrade of a single MachineDeployment topology.
	// If the annotation is set on a MachineDeployment topology in Cluster.spec.topology.workers, the Kubernetes upgrade
	// for this MachineDeployment topology is deferred. It doesn't affect other MachineDeployment topologies.
	// Example:
	// - If you want to defer the upgrades of the 3rd and 5th MachineDeployments of the list, set the annotation on them.
	//   The upgrade process will upgrade MachineDeployment in position 1,2, (skip 3), 4, (skip 5), 6 etc. The upgrade
	//   will not be completed until the annotation is removed and all MachineDeployments are upgraded.
	ClusterTopologyDeferUpgradeAnnotation = "topology.cluster.x-k8s.io/defer-upgrade"

	// ClusterTopologyUpgradeConcurrencyAnnotation can be set as top-level annotation on the Cluster object of
	// a classy Cluster to define the maximum concurrency while upgrading MachineDeployments.
	ClusterTopologyUpgradeConcurrencyAnnotation = "topology.cluster.x-k8s.io/upgrade-concurrency"

	// ClusterTopologyMachinePoolNameLabel is the label set on the generated  MachinePool objects
	// to track the name of the MachinePool topology it represents.
	ClusterTopologyMachinePoolNameLabel = "topology.cluster.x-k8s.io/pool-name"

	// ClusterTopologyUnsafeUpdateClassNameAnnotation can be used to disable the webhook check on
	// update that disallows a pre-existing Cluster to be populated with Topology information and Class.
	ClusterTopologyUnsafeUpdateClassNameAnnotation = "unsafe.topology.cluster.x-k8s.io/disable-update-class-name-check"

	// ClusterTopologyUnsafeUpdateVersionAnnotation can be used to disable the webhook checks on
	// update that disallows updating the .topology.spec.version on certain conditions.
	ClusterTopologyUnsafeUpdateVersionAnnotation = "unsafe.topology.cluster.x-k8s.io/disable-update-version-check"

	// ProviderNameLabel is the label set on components in the provider manifest.
	// This label allows to easily identify all the components belonging to a provider; the clusterctl
	// tool uses this label for implementing provider's lifecycle operations.
	ProviderNameLabel = "cluster.x-k8s.io/provider"

	// ClusterNameAnnotation is the annotation set on nodes identifying the name of the cluster the node belongs to.
	ClusterNameAnnotation = "cluster.x-k8s.io/cluster-name"

	// ClusterNamespaceAnnotation is the annotation set on nodes identifying the namespace of the cluster the node belongs to.
	ClusterNamespaceAnnotation = "cluster.x-k8s.io/cluster-namespace"

	// MachineAnnotation is the annotation set on nodes identifying the machine the node belongs to.
	MachineAnnotation = "cluster.x-k8s.io/machine"

	// OwnerKindAnnotation is the annotation set on nodes identifying the owner kind.
	OwnerKindAnnotation = "cluster.x-k8s.io/owner-kind"

	// LabelsFromMachineAnnotation is the annotation set on nodes to track the labels originated from machines.
	LabelsFromMachineAnnotation = "cluster.x-k8s.io/labels-from-machine"

	// OwnerNameAnnotation is the annotation set on nodes identifying the owner name.
	OwnerNameAnnotation = "cluster.x-k8s.io/owner-name"

	// PausedAnnotation is an annotation that can be applied to any Cluster API
	// object to prevent a controller from processing a resource.
	//
	// Controllers working with Cluster API objects must check the existence of this annotation
	// on the reconciled object.
	PausedAnnotation = "cluster.x-k8s.io/paused"

	// DisableMachineCreateAnnotation is an annotation that can be used to signal a MachineSet to stop creating new machines.
	// It is utilized in the OnDelete MachineDeploymentStrategy to allow the MachineDeployment controller to scale down
	// older MachineSets when Machines are deleted and add the new replicas to the latest MachineSet.
	DisableMachineCreateAnnotation = "cluster.x-k8s.io/disable-machine-create"

	// WatchLabel is a label othat can be applied to any Cluster API object.
	//
	// Controllers which allow for selective reconciliation may check this label and proceed
	// with reconciliation of the object only if this label and a configured value is present.
	WatchLabel = "cluster.x-k8s.io/watch-filter"

	// DeleteMachineAnnotation marks control plane and worker nodes that will be given priority for deletion
	// when KCP or a machineset scales down. This annotation is given top priority on all delete policies.
	DeleteMachineAnnotation = "cluster.x-k8s.io/delete-machine"

	// TemplateClonedFromNameAnnotation is the infrastructure machine annotation that stores the name of the infrastructure template resource
	// that was cloned for the machine. This annotation is set only during cloning a template. Older/adopted machines will not have this annotation.
	TemplateClonedFromNameAnnotation = "cluster.x-k8s.io/cloned-from-name"

	// TemplateClonedFromGroupKindAnnotation is the infrastructure machine annotation that stores the group-kind of the infrastructure template resource
	// that was cloned for the machine. This annotation is set only during cloning a template. Older/adopted machines will not have this annotation.
	TemplateClonedFromGroupKindAnnotation = "cluster.x-k8s.io/cloned-from-groupkind"

	// MachineSkipRemediationAnnotation is the annotation used to mark the machines that should not be considered for remediation by MachineHealthCheck reconciler.
	MachineSkipRemediationAnnotation = "cluster.x-k8s.io/skip-remediation"

	// RemediateMachineAnnotation is the annotation used to mark machines that should be remediated by MachineHealthCheck reconciler.
	RemediateMachineAnnotation = "cluster.x-k8s.io/remediate-machine"

	// MachineSetSkipPreflightChecksAnnotation is the annotation used to provide a comma-separated list of
	// preflight checks that should be skipped during the MachineSet reconciliation.
	// Supported items are:
	// - KubeadmVersion (skips the kubeadm version skew preflight check)
	// - KubernetesVersion (skips the kubernetes version skew preflight check)
	// - ControlPlaneStable (skips checking that the control plane is neither provisioning nor upgrading)
	// - All (skips all preflight checks)
	// Example: "machineset.cluster.x-k8s.io/skip-preflight-checks": "ControlPlaneStable,KubernetesVersion".
	// Note: The annotation can also be set on a MachineDeployment as MachineDeployment annotations are synced to
	// the MachineSet.
	MachineSetSkipPreflightChecksAnnotation = "machineset.cluster.x-k8s.io/skip-preflight-checks"

	// ClusterSecretType defines the type of secret created by core components.
	// Note: This is used by core CAPI, CAPBK, and KCP to determine whether a secret is created by the controllers
	// themselves or supplied by the user (e.g. bring your own certificates).
	ClusterSecretType corev1.SecretType = "cluster.x-k8s.io/secret" //nolint:gosec

	// InterruptibleLabel is the label used to mark the nodes that run on interruptible instances.
	InterruptibleLabel = "cluster.x-k8s.io/interruptible"

	// ManagedByAnnotation is an annotation that can be applied to InfraCluster resources to signify that
	// some external system is managing the cluster infrastructure.
	//
	// Provider InfraCluster controllers will ignore resources with this annotation.
	// An external controller must fulfill the contract of the InfraCluster resource.
	// External infrastructure providers should ensure that the annotation, once set, cannot be removed.
	ManagedByAnnotation = "cluster.x-k8s.io/managed-by"

	// TopologyDryRunAnnotation is an annotation that gets set on objects by the topology controller
	// only during a server side dry run apply operation. It is used for validating
	// update webhooks for objects which get updated by template rotation (e.g. InfrastructureMachineTemplate).
	// When the annotation is set and the admission request is a dry run, the webhook should
	// skip validation due to immutability. By that the request will succeed (without
	// any changes to the actual object because it is a dry run) and the topology controller
	// will receive the resulting object.
	TopologyDryRunAnnotation = "topology.cluster.x-k8s.io/dry-run"

	// ReplicasManagedByAnnotation is an annotation that indicates external (non-Cluster API) management of infra scaling.
	// The practical effect of this is that the capi "replica" count should be passively derived from the number of observed infra machines,
	// instead of being a source of truth for eventual consistency.
	// This annotation can be used to inform MachinePool status during in-progress scaling scenarios.
	ReplicasManagedByAnnotation = "cluster.x-k8s.io/replicas-managed-by"

	// AutoscalerMinSizeAnnotation defines the minimum node group size.
	// The annotation is used by autoscaler.
	// The annotation is copied from kubernetes/autoscaler.
	// Ref:https://github.com/kubernetes/autoscaler/blob/d8336cca37dbfa5d1cb7b7e453bd511172d6e5e7/cluster-autoscaler/cloudprovider/clusterapi/clusterapi_utils.go#L256-L259
	// Note: With the Kubernetes autoscaler it is possible to use different annotations by configuring a different
	// "Cluster API group" than "cluster.x-k8s.io" via the "CAPI_GROUP" environment variable.
	// We only handle the default group in our implementation.
	// Note: It can be used by setting as top level annotation on MachineDeployment and MachineSets.
	AutoscalerMinSizeAnnotation = "cluster.x-k8s.io/cluster-api-autoscaler-node-group-min-size"

	// AutoscalerMaxSizeAnnotation defines the maximum node group size.
	// The annotations is used by the autoscaler.
	// The annotation definition is copied from kubernetes/autoscaler.
	// Ref:https://github.com/kubernetes/autoscaler/blob/d8336cca37dbfa5d1cb7b7e453bd511172d6e5e7/cluster-autoscaler/cloudprovider/clusterapi/clusterapi_utils.go#L264-L267
	// Note: With the Kubernetes autoscaler it is possible to use different annotations by configuring a different
	// "Cluster API group" than "cluster.x-k8s.io" via the "CAPI_GROUP" environment variable.
	// We only handle the default group in our implementation.
	// Note: It can be used by setting as top level annotation on MachineDeployment and MachineSets.
	AutoscalerMaxSizeAnnotation = "cluster.x-k8s.io/cluster-api-autoscaler-node-group-max-size"

	// VariableDefinitionFromInline indicates a patch or variable was defined in the `.spec` of a ClusterClass
	// rather than from an external patch extension.
	VariableDefinitionFromInline = "inline"
)
View Source 
const (
	// DeletingReason (Severity=Info) documents a condition not in Status=True because the underlying object it is currently being deleted.
	DeletingReason = "Deleting"

	// DeletionFailedReason (Severity=Warning) documents a condition not in Status=True because the underlying object
	// encountered problems during deletion. This is a warning because the reconciler will retry deletion.
	DeletionFailedReason = "DeletionFailed"

	// DeletedReason (Severity=Info) documents a condition not in Status=True because the underlying object was deleted.
	DeletedReason = "Deleted"

	// IncorrectExternalRefReason (Severity=Error) documents a CAPI object with an incorrect external object reference.
	IncorrectExternalRefReason = "IncorrectExternalRef"
)

Common ConditionReason used by Cluster API objects.

View Source 
const (
	// ControlPlaneInitializedCondition reports if the cluster's control plane has been initialized such that the
	// cluster's apiserver is reachable. If no Control Plane provider is in use this condition reports that at least one
	// control plane Machine has a node reference. Once this Condition is marked true, its value is never changed. See
	// the ControlPlaneReady condition for an indication of the current readiness of the cluster's control plane.
	ControlPlaneInitializedCondition ConditionType = "ControlPlaneInitialized"

	// MissingNodeRefReason (Severity=Info) documents a cluster waiting for at least one control plane Machine to have
	// its node reference populated.
	MissingNodeRefReason = "MissingNodeRef"

	// WaitingForControlPlaneProviderInitializedReason (Severity=Info) documents a cluster waiting for the control plane
	// provider to report successful control plane initialization.
	WaitingForControlPlaneProviderInitializedReason = "WaitingForControlPlaneProviderInitialized"

	// ControlPlaneReadyCondition reports the ready condition from the control plane object defined for this cluster.
	// This condition is mirrored from the Ready condition in the control plane ref object, and
	// the absence of this condition might signal problems in the reconcile external loops or the fact that
	// the control plane provider does not implement the Ready condition yet.
	ControlPlaneReadyCondition ConditionType = "ControlPlaneReady"

	// WaitingForControlPlaneFallbackReason (Severity=Info) documents a cluster waiting for the control plane
	// to be available.
	// NOTE: This reason is used only as a fallback when the control plane object is not reporting its own ready condition.
	WaitingForControlPlaneFallbackReason = "WaitingForControlPlane"

	// WaitingForControlPlaneAvailableReason (Severity=Info) documents a Cluster API object
	// waiting for the control plane machine to be available.
	//
	// NOTE: Having the control plane machine available is a pre-condition for joining additional control planes
	// or workers nodes.
	WaitingForControlPlaneAvailableReason = "WaitingForControlPlaneAvailable"
)
View Source 
const (
	// BootstrapReadyCondition reports a summary of current status of the bootstrap object defined for this machine.
	// This condition is mirrored from the Ready condition in the bootstrap ref object, and
	// the absence of this condition might signal problems in the reconcile external loops or the fact that
	// the bootstrap provider does not implement the Ready condition yet.
	BootstrapReadyCondition ConditionType = "BootstrapReady"

	// WaitingForDataSecretFallbackReason (Severity=Info) documents a machine waiting for the bootstrap data secret
	// to be available.
	// NOTE: This reason is used only as a fallback when the bootstrap object is not reporting its own ready condition.
	WaitingForDataSecretFallbackReason = "WaitingForDataSecret"

	// DrainingSucceededCondition provide evidence of the status of the node drain operation which happens during the machine
	// deletion process.
	DrainingSucceededCondition ConditionType = "DrainingSucceeded"

	// DrainingReason (Severity=Info) documents a machine node being drained.
	DrainingReason = "Draining"

	// DrainingFailedReason (Severity=Warning) documents a machine node drain operation failed.
	DrainingFailedReason = "DrainingFailed"

	// PreDrainDeleteHookSucceededCondition reports a machine waiting for a PreDrainDeleteHook before being delete.
	PreDrainDeleteHookSucceededCondition ConditionType = "PreDrainDeleteHookSucceeded"

	// PreTerminateDeleteHookSucceededCondition reports a machine waiting for a PreDrainDeleteHook before being delete.
	PreTerminateDeleteHookSucceededCondition ConditionType = "PreTerminateDeleteHookSucceeded"

	// WaitingExternalHookReason (Severity=Info) provide evidence that we are waiting for an external hook to complete.
	WaitingExternalHookReason = "WaitingExternalHook"

	// VolumeDetachSucceededCondition reports a machine waiting for volumes to be detached.
	VolumeDetachSucceededCondition ConditionType = "VolumeDetachSucceeded"

	// WaitingForVolumeDetachReason (Severity=Info) provide evidence that a machine node waiting for volumes to be attached.
	WaitingForVolumeDetachReason = "WaitingForVolumeDetach"
)
View Source 
const (
	// MachineHealthCheckSucceededCondition is set on machines that have passed a healthcheck by the MachineHealthCheck controller.
	// In the event that the health check fails it will be set to False.
	MachineHealthCheckSucceededCondition ConditionType = "HealthCheckSucceeded"

	// MachineHasFailureReason is the reason used when a machine has either a FailureReason or a FailureMessage set on its status.
	MachineHasFailureReason = "MachineHasFailure"

	// HasRemediateMachineAnnotationReason is the reason that get's set at the MachineHealthCheckSucceededCondition when a machine
	// has the RemediateMachineAnnotation set.
	HasRemediateMachineAnnotationReason = "HasRemediateMachineAnnotation"

	// NodeStartupTimeoutReason is the reason used when a machine's node does not appear within the specified timeout.
	NodeStartupTimeoutReason = "NodeStartupTimeout"

	// UnhealthyNodeConditionReason is the reason used when a machine's node has one of the MachineHealthCheck's unhealthy conditions.
	UnhealthyNodeConditionReason = "UnhealthyNode"
)
View Source 
const (
	// MachineOwnerRemediatedCondition is set on machines that have failed a healthcheck by the MachineHealthCheck controller.
	// MachineOwnerRemediatedCondition is set to False after a health check fails, but should be changed to True by the owning controller after remediation succeeds.
	MachineOwnerRemediatedCondition ConditionType = "OwnerRemediated"

	// WaitingForRemediationReason is the reason used when a machine fails a health check and remediation is needed.
	WaitingForRemediationReason = "WaitingForRemediation"

	// RemediationFailedReason is the reason used when a remediation owner fails to remediate an unhealthy machine.
	RemediationFailedReason = "RemediationFailed"

	// RemediationInProgressReason is the reason used when an unhealthy machine is being remediated by the remediation owner.
	RemediationInProgressReason = "RemediationInProgress"

	// ExternalRemediationTemplateAvailableCondition is set on machinehealthchecks when MachineHealthCheck controller uses external remediation.
	// ExternalRemediationTemplateAvailableCondition is set to false if external remediation template is not found.
	ExternalRemediationTemplateAvailableCondition ConditionType = "ExternalRemediationTemplateAvailable"

	// ExternalRemediationTemplateNotFoundReason is the reason used when a machine health check fails to find external remediation template.
	ExternalRemediationTemplateNotFoundReason = "ExternalRemediationTemplateNotFound"

	// ExternalRemediationRequestAvailableCondition is set on machinehealthchecks when MachineHealthCheck controller uses external remediation.
	// ExternalRemediationRequestAvailableCondition is set to false if creating external remediation request fails.
	ExternalRemediationRequestAvailableCondition ConditionType = "ExternalRemediationRequestAvailable"

	// ExternalRemediationRequestCreationFailedReason is the reason used when a machine health check fails to create external remediation request.
	ExternalRemediationRequestCreationFailedReason = "ExternalRemediationRequestCreationFailed"
)
View Source 
const (
	// MachineNodeHealthyCondition provides info about the operational state of the Kubernetes node hosted on the machine by summarizing  node conditions.
	// If the conditions defined in a Kubernetes node (i.e., NodeReady, NodeMemoryPressure, NodeDiskPressure and NodePIDPressure) are in a healthy state, it will be set to True.
	MachineNodeHealthyCondition ConditionType = "NodeHealthy"

	// WaitingForNodeRefReason (Severity=Info) documents a machine.spec.providerId is not assigned yet.
	WaitingForNodeRefReason = "WaitingForNodeRef"

	// NodeProvisioningReason (Severity=Info) documents machine in the process of provisioning a node.
	// NB. provisioning --> NodeRef == "".
	NodeProvisioningReason = "NodeProvisioning"

	// NodeNotFoundReason (Severity=Error) documents a machine's node has previously been observed but is now gone.
	// NB. provisioned --> NodeRef != "".
	NodeNotFoundReason = "NodeNotFound"

	// NodeConditionsFailedReason (Severity=Warning) documents a node is not in a healthy state due to the failed state of at least 1 Kubelet condition.
	NodeConditionsFailedReason = "NodeConditionsFailed"

	// NodeInspectionFailedReason documents a failure in inspecting the node.
	// This reason is used when the Machine controller is unable to list Nodes to find
	// the corresponding Node for a Machine by ProviderID.
	NodeInspectionFailedReason = "NodeInspectionFailed"
)

Conditions and condition Reasons for the Machine's Node object.

View Source 
const (
	// MachineDeploymentAvailableCondition means the MachineDeployment is available, that is, at least the minimum available
	// machines required (i.e. Spec.Replicas-MaxUnavailable when MachineDeploymentStrategyType = RollingUpdate) are up and running for at least minReadySeconds.
	MachineDeploymentAvailableCondition ConditionType = "Available"

	// MachineSetReadyCondition reports a summary of current status of the MachineSet owned by the MachineDeployment.
	MachineSetReadyCondition ConditionType = "MachineSetReady"

	// WaitingForMachineSetFallbackReason (Severity=Info) documents a MachineDeployment waiting for the underlying MachineSet
	// to be available.
	// NOTE: This reason is used only as a fallback when the MachineSet object is not reporting its own ready condition.
	WaitingForMachineSetFallbackReason = "WaitingForMachineSet"

	// WaitingForAvailableMachinesReason (Severity=Warning) reflects the fact that the required minimum number of machines for a machinedeployment are not available.
	WaitingForAvailableMachinesReason = "WaitingForAvailableMachines"
)
View Source 
const (
	// MachinesCreatedCondition documents that the machines controlled by the MachineSet are created.
	// When this condition is false, it indicates that there was an error when cloning the infrastructure/bootstrap template or
	// when generating the machine object.
	MachinesCreatedCondition ConditionType = "MachinesCreated"

	// MachinesReadyCondition reports an aggregate of current status of the machines controlled by the MachineSet.
	MachinesReadyCondition ConditionType = "MachinesReady"

	// PreflightCheckFailedReason (Severity=Error) documents a MachineSet failing preflight checks
	// to create machine(s).
	PreflightCheckFailedReason = "PreflightCheckFailed"

	// BootstrapTemplateCloningFailedReason (Severity=Error) documents a MachineSet failing to
	// clone the bootstrap template.
	BootstrapTemplateCloningFailedReason = "BootstrapTemplateCloningFailed"

	// InfrastructureTemplateCloningFailedReason (Severity=Error) documents a MachineSet failing to
	// clone the infrastructure template.
	InfrastructureTemplateCloningFailedReason = "InfrastructureTemplateCloningFailed"

	// MachineCreationFailedReason (Severity=Error) documents a MachineSet failing to
	// generate a machine object.
	MachineCreationFailedReason = "MachineCreationFailed"

	// ResizedCondition documents a MachineSet is resizing the set of controlled machines.
	ResizedCondition ConditionType = "Resized"

	// ScalingUpReason (Severity=Info) documents a MachineSet is increasing the number of replicas.
	ScalingUpReason = "ScalingUp"

	// ScalingDownReason (Severity=Info) documents a MachineSet is decreasing the number of replicas.
	ScalingDownReason = "ScalingDown"
)
View Source 
const (
	// TopologyReconciledCondition provides evidence about the reconciliation of a Cluster topology into
	// the managed objects of the Cluster.
	// Status false means that for any reason, the values defined in Cluster.spec.topology are not yet applied to
	// managed objects on the Cluster; status true means that Cluster.spec.topology have been applied to
	// the objects in the Cluster (but this does not imply those objects are already reconciled to the spec provided).
	TopologyReconciledCondition ConditionType = "TopologyReconciled"

	// TopologyReconcileFailedReason (Severity=Error) documents the reconciliation of a Cluster topology
	// failing due to an error.
	TopologyReconcileFailedReason = "TopologyReconcileFailed"

	// TopologyReconciledControlPlaneUpgradePendingReason (Severity=Info) documents reconciliation of a Cluster topology
	// not yet completed because Control Plane is not yet updated to match the desired topology spec.
	TopologyReconciledControlPlaneUpgradePendingReason = "ControlPlaneUpgradePending"

	// TopologyReconciledMachineDeploymentsCreatePendingReason (Severity=Info) documents reconciliation of a Cluster topology
	// not yet completed because at least one of the MachineDeployments is yet to be created.
	// This generally happens because new MachineDeployment creations are held off while the ControlPlane is not stable.
	TopologyReconciledMachineDeploymentsCreatePendingReason = "MachineDeploymentsCreatePending"

	// TopologyReconciledMachineDeploymentsUpgradePendingReason (Severity=Info) documents reconciliation of a Cluster topology
	// not yet completed because at least one of the MachineDeployments is not yet updated to match the desired topology spec.
	TopologyReconciledMachineDeploymentsUpgradePendingReason = "MachineDeploymentsUpgradePending"

	// TopologyReconciledMachineDeploymentsUpgradeDeferredReason (Severity=Info) documents reconciliation of a Cluster topology
	// not yet completed because the upgrade for at least one of the MachineDeployments has been deferred.
	TopologyReconciledMachineDeploymentsUpgradeDeferredReason = "MachineDeploymentsUpgradeDeferred"

	// TopologyReconciledMachinePoolsUpgradePendingReason (Severity=Info) documents reconciliation of a Cluster topology
	// not yet completed because at least one of the MachinePools is not yet updated to match the desired topology spec.
	TopologyReconciledMachinePoolsUpgradePendingReason = "MachinePoolsUpgradePending"

	// TopologyReconciledMachinePoolsCreatePendingReason (Severity=Info) documents reconciliation of a Cluster topology
	// not yet completed because at least one of the MachinePools is yet to be created.
	// This generally happens because new MachinePool creations are held off while the ControlPlane is not stable.
	TopologyReconciledMachinePoolsCreatePendingReason = "MachinePoolsCreatePending"

	// TopologyReconciledMachinePoolsUpgradeDeferredReason (Severity=Info) documents reconciliation of a Cluster topology
	// not yet completed because the upgrade for at least one of the MachinePools has been deferred.
	TopologyReconciledMachinePoolsUpgradeDeferredReason = "MachinePoolsUpgradeDeferred"

	// TopologyReconciledHookBlockingReason (Severity=Info) documents reconciliation of a Cluster topology
	// not yet completed because at least one of the lifecycle hooks is blocking.
	TopologyReconciledHookBlockingReason = "LifecycleHookBlocking"

	// TopologyReconciledClusterClassNotReconciledReason (Severity=Info) documents reconciliation of a Cluster topology not
	// yet completed because the ClusterClass has not reconciled yet. If this condition persists there may be an issue
	// with the ClusterClass surfaced in the ClusterClass status or controller logs.
	TopologyReconciledClusterClassNotReconciledReason = "ClusterClassNotReconciled"

	// TopologyReconciledPausedReason (Severity=Info) surfaces when the Cluster is paused.
	TopologyReconciledPausedReason = "Paused"
)

Conditions and condition reasons for Clusters with a managed Topology.

View Source 
const (
	// ClusterClassRefVersionsUpToDateCondition documents if the references in the ClusterClass are
	// up-to-date (i.e. they are using the latest apiVersion of the current Cluster API contract from
	// the corresponding CRD).
	ClusterClassRefVersionsUpToDateCondition ConditionType = "RefVersionsUpToDate"

	// ClusterClassOutdatedRefVersionsReason (Severity=Warning) that the references in the ClusterClass are not
	// up-to-date (i.e. they are not using the latest apiVersion of the current Cluster API contract from
	// the corresponding CRD).
	ClusterClassOutdatedRefVersionsReason = "OutdatedRefVersions"

	// ClusterClassRefVersionsUpToDateInternalErrorReason (Severity=Warning) surfaces that an unexpected error occurred when validating
	// if the references are up-to-date.
	ClusterClassRefVersionsUpToDateInternalErrorReason = "InternalError"
)

Conditions and condition reasons for ClusterClass.

View Source 
const (
	// MachinePhasePending is the first state a Machine is assigned by
	// Cluster API Machine controller after being created.
	MachinePhasePending = MachinePhase("Pending")

	// MachinePhaseProvisioning is the state when the
	// Machine infrastructure is being created.
	MachinePhaseProvisioning = MachinePhase("Provisioning")

	// MachinePhaseProvisioned is the state when its
	// infrastructure has been created and configured.
	MachinePhaseProvisioned = MachinePhase("Provisioned")

	// MachinePhaseRunning is the Machine state when it has
	// become a Kubernetes Node in a Ready state.
	MachinePhaseRunning = MachinePhase("Running")

	// MachinePhaseDeleting is the Machine state when a delete
	// request has been sent to the API Server,
	// but its infrastructure has not yet been fully deleted.
	MachinePhaseDeleting = MachinePhase("Deleting")

	// MachinePhaseDeleted is the Machine state when the object
	// and the related infrastructure is deleted and
	// ready to be garbage collected by the API Server.
	MachinePhaseDeleted = MachinePhase("Deleted")

	// MachinePhaseFailed is the Machine state when the system
	// might require user intervention.
	MachinePhaseFailed = MachinePhase("Failed")

	// MachinePhaseUnknown is returned if the Machine state cannot be determined.
	MachinePhaseUnknown = MachinePhase("Unknown")
)
View Source 
const (
	// MachineFinalizer is set on PrepareForCreate callback.
	MachineFinalizer = "machine.cluster.x-k8s.io"

	// MachineControlPlaneLabel is the label set on machines or related objects that are part of a control plane.
	MachineControlPlaneLabel = "cluster.x-k8s.io/control-plane"

	// ExcludeNodeDrainingAnnotation annotation explicitly skips node draining if set.
	ExcludeNodeDrainingAnnotation = "machine.cluster.x-k8s.io/exclude-node-draining"

	// ExcludeWaitForNodeVolumeDetachAnnotation annotation explicitly skips the waiting for node volume detaching if set.
	ExcludeWaitForNodeVolumeDetachAnnotation = "machine.cluster.x-k8s.io/exclude-wait-for-node-volume-detach"

	// MachineSetNameLabel is the label set on machines if they're controlled by MachineSet.
	// Note: The value of this label may be a hash if the MachineSet name is longer than 63 characters.
	MachineSetNameLabel = "cluster.x-k8s.io/set-name"

	// MachineDeploymentNameLabel is the label set on machines if they're controlled by MachineDeployment.
	MachineDeploymentNameLabel = "cluster.x-k8s.io/deployment-name"

	// MachinePoolNameLabel is the label indicating the name of the MachinePool a Machine is controlled by.
	// Note: The value of this label may be a hash if the MachinePool name is longer than 63 characters.
	MachinePoolNameLabel = "cluster.x-k8s.io/pool-name"

	// MachineControlPlaneNameLabel is the label set on machines if they're controlled by a ControlPlane.
	// Note: The value of this label may be a hash if the control plane name is longer than 63 characters.
	MachineControlPlaneNameLabel = "cluster.x-k8s.io/control-plane-name"

	// PreDrainDeleteHookAnnotationPrefix annotation specifies the prefix we
	// search each annotation for during the pre-drain.delete lifecycle hook
	// to pause reconciliation of deletion. These hooks will prevent removal of
	// draining the associated node until all are removed.
	PreDrainDeleteHookAnnotationPrefix = "pre-drain.delete.hook.machine.cluster.x-k8s.io"

	// PreTerminateDeleteHookAnnotationPrefix annotation specifies the prefix we
	// search each annotation for during the pre-terminate.delete lifecycle hook
	// to pause reconciliation of deletion. These hooks will prevent removal of
	// an instance from an infrastructure provider until all are removed.
	//
	// Notes for Machines managed by KCP (starting with Cluster API v1.8.2):
	// * KCP adds its own pre-terminate hook on all Machines it controls. This is done to ensure it can later remove
	//   the etcd member right before Machine termination (i.e. before InfraMachine deletion).
	// * Starting with Kubernetes v1.31 the KCP pre-terminate hook will wait for all other pre-terminate hooks to finish to
	//   ensure it runs last (thus ensuring that kubelet is still working while other pre-terminate hooks run). This is only done
	//   for v1.31 or above because the kubeadm ControlPlaneKubeletLocalMode was introduced with kubeadm 1.31. This feature configures
	//   the kubelet to communicate with the local apiserver. Only because of that the kubelet immediately starts failing after the etcd
	//   member is removed. We need the ControlPlaneKubeletLocalMode feature with 1.31 to adhere to the kubelet skew policy.
	PreTerminateDeleteHookAnnotationPrefix = "pre-terminate.delete.hook.machine.cluster.x-k8s.io"

	// MachineCertificatesExpiryDateAnnotation annotation specifies the expiry date of the machine certificates in RFC3339 format.
	// This annotation can be used on control plane machines to trigger rollout before certificates expire.
	// This annotation can be set on BootstrapConfig or Machine objects. The value set on the Machine object takes precedence.
	// This annotation can only be used on Control Plane Machines.
	MachineCertificatesExpiryDateAnnotation = "machine.cluster.x-k8s.io/certificates-expiry"

	// NodeRoleLabelPrefix is one of the CAPI managed Node label prefixes.
	NodeRoleLabelPrefix = "node-role.kubernetes.io"
	// NodeRestrictionLabelDomain is one of the CAPI managed Node label domains.
	NodeRestrictionLabelDomain = "node-restriction.kubernetes.io"
	// ManagedNodeLabelDomain is one of the CAPI managed Node label domains.
	ManagedNodeLabelDomain = "node.cluster.x-k8s.io"
)
View Source 
const (
	// MachineAvailableV1Beta2Condition is true if the machine is Ready for at least MinReadySeconds, as defined by the Machine's MinReadySeconds field.
	// Note: MinReadySeconds is assumed 0 until it will be implemented in v1beta2 API.
	MachineAvailableV1Beta2Condition = AvailableV1Beta2Condition

	// MachineWaitingForMinReadySecondsV1Beta2Reason surfaces when a machine is ready for less than MinReadySeconds (and thus not yet available).
	MachineWaitingForMinReadySecondsV1Beta2Reason = "WaitingForMinReadySeconds"

	// MachineAvailableV1Beta2Reason surfaces when a machine is ready for at least MinReadySeconds.
	// Note: MinReadySeconds is assumed 0 until it will be implemented in v1beta2 API.
	MachineAvailableV1Beta2Reason = AvailableV1Beta2Reason

	// MachineAvailableInternalErrorV1Beta2Reason surfaces unexpected error when computing the Available condition.
	MachineAvailableInternalErrorV1Beta2Reason = InternalErrorV1Beta2Reason
)

Machine's Available condition and corresponding reasons that will be used in v1Beta2 API version.

View Source 
const (
	// MachineReadyV1Beta2Condition is true if the Machine's deletionTimestamp is not set, Machine's BootstrapConfigReady, InfrastructureReady,
	// NodeHealthy and HealthCheckSucceeded (if present) conditions are true; if other conditions are defined in spec.readinessGates,
	// these conditions must be true as well.
	// Note:
	// - When summarizing the Deleting condition:
	//   - Details about Pods stuck in draining or volumes waiting for detach are dropped, in order to improve readability & reduce flickering
	//     of the condition that bubbles up to the owning resources/ to the Cluster (it also makes it more likely this condition might be aggregated with
	//     conditions reported by other machines).
	//   - If deletion is in progress for more than 15m, this surfaces on the summary condition (hint about a possible stale deletion).
	//     - if drain is in progress for more than 5 minutes, a summery of what is blocking drain also surfaces in the message.
	// - When summarizing BootstrapConfigReady, InfrastructureReady, NodeHealthy, in case the Machine is deleting, the absence of the
	//   referenced object won't be considered as an issue.
	MachineReadyV1Beta2Condition = ReadyV1Beta2Condition

	// MachineReadyV1Beta2Reason surfaces when the machine readiness criteria is met.
	MachineReadyV1Beta2Reason = ReadyV1Beta2Reason

	// MachineNotReadyV1Beta2Reason surfaces when the machine readiness criteria is not met.
	// Note: when a machine is not ready, it is also not available.
	MachineNotReadyV1Beta2Reason = NotReadyV1Beta2Reason

	// MachineReadyUnknownV1Beta2Reason surfaces when at least one machine readiness criteria is unknown
	// and no machine readiness criteria is not met.
	MachineReadyUnknownV1Beta2Reason = ReadyUnknownV1Beta2Reason

	// MachineReadyInternalErrorV1Beta2Reason surfaces unexpected error when computing the Ready condition.
	MachineReadyInternalErrorV1Beta2Reason = InternalErrorV1Beta2Reason
)

Machine's Ready condition and corresponding reasons that will be used in v1Beta2 API version.

View Source 
const (
	// MachineUpToDateV1Beta2Condition is true if the Machine spec matches the spec of the Machine's owner resource, e.g. KubeadmControlPlane or MachineDeployment.
	// The Machine's owner (e.g. MachineDeployment) is authoritative to set their owned Machine's UpToDate conditions based on its current spec.
	// NOTE: The Machine's owner might use this condition to surface also other use cases when Machine is considered not up to date, e.g. when MachineDeployment spec.rolloutAfter
	// is expired and the Machine needs to be rolled out.
	MachineUpToDateV1Beta2Condition = "UpToDate"

	// MachineUpToDateV1Beta2Reason surface when a Machine spec matches the spec of the Machine's owner resource, e.g. KubeadmControlPlane or MachineDeployment.
	MachineUpToDateV1Beta2Reason = "UpToDate"

	// MachineNotUpToDateV1Beta2Reason surface when a Machine spec does not match the spec of the Machine's owner resource, e.g. KubeadmControlPlane or MachineDeployment.
	MachineNotUpToDateV1Beta2Reason = "NotUpToDate"
)

Machine's UpToDate condition and corresponding reasons that will be used in v1Beta2 API version. Note: UpToDate condition is set by the controller owning the machine.

View Source 
const (
	// MachineBootstrapConfigReadyV1Beta2Condition condition mirrors the corresponding Ready condition from the Machine's BootstrapConfig resource.
	MachineBootstrapConfigReadyV1Beta2Condition = BootstrapConfigReadyV1Beta2Condition

	// MachineBootstrapDataSecretProvidedV1Beta2Reason surfaces when a bootstrap data secret is provided (not originated
	// from a BoostrapConfig object referenced from the machine).
	MachineBootstrapDataSecretProvidedV1Beta2Reason = "DataSecretProvided"

	// MachineBootstrapConfigReadyV1Beta2Reason surfaces when the machine bootstrap config is ready.
	MachineBootstrapConfigReadyV1Beta2Reason = ReadyV1Beta2Reason

	// MachineBootstrapConfigNotReadyV1Beta2Reason surfaces when the machine bootstrap config is not ready.
	MachineBootstrapConfigNotReadyV1Beta2Reason = NotReadyV1Beta2Reason

	// MachineBootstrapConfigInvalidConditionReportedV1Beta2Reason surfaces a BootstrapConfig Ready condition (read from a bootstrap config object) which is invalid.
	// (e.g. its status is missing).
	MachineBootstrapConfigInvalidConditionReportedV1Beta2Reason = InvalidConditionReportedV1Beta2Reason

	// MachineBootstrapConfigInternalErrorV1Beta2Reason surfaces unexpected failures when reading a BootstrapConfig object.
	MachineBootstrapConfigInternalErrorV1Beta2Reason = InternalErrorV1Beta2Reason

	// MachineBootstrapConfigDoesNotExistV1Beta2Reason surfaces when a referenced bootstrap config object does not exist.
	// Note: this could happen when creating the machine. However, this state should be treated as an error if it lasts indefinitely.
	MachineBootstrapConfigDoesNotExistV1Beta2Reason = ObjectDoesNotExistV1Beta2Reason

	// MachineBootstrapConfigDeletedV1Beta2Reason surfaces when a referenced bootstrap config object has been deleted.
	// Note: controllers can't identify if the bootstrap config object was deleted the controller itself, e.g.
	// during the deletion workflow, or by a users.
	MachineBootstrapConfigDeletedV1Beta2Reason = ObjectDeletedV1Beta2Reason
)

Machine's BootstrapConfigReady condition and corresponding reasons that will be used in v1Beta2 API version. Note: when possible, BootstrapConfigReady condition will use reasons surfaced from the underlying bootstrap config object.

View Source 
const (
	// MachineInfrastructureReadyV1Beta2Condition mirrors the corresponding Ready condition from the Machine's infrastructure resource.
	MachineInfrastructureReadyV1Beta2Condition = InfrastructureReadyV1Beta2Condition

	// MachineInfrastructureReadyV1Beta2Reason surfaces when the machine infrastructure is ready.
	MachineInfrastructureReadyV1Beta2Reason = ReadyV1Beta2Reason

	// MachineInfrastructureNotReadyV1Beta2Reason surfaces when the machine infrastructure is not ready.
	MachineInfrastructureNotReadyV1Beta2Reason = NotReadyV1Beta2Reason

	// MachineInfrastructureInvalidConditionReportedV1Beta2Reason surfaces a infrastructure Ready condition (read from an infra machine object) which is invalid.
	// (e.g. its status is missing).
	MachineInfrastructureInvalidConditionReportedV1Beta2Reason = InvalidConditionReportedV1Beta2Reason

	// MachineInfrastructureInternalErrorV1Beta2Reason surfaces unexpected failures when reading an infra machine object.
	MachineInfrastructureInternalErrorV1Beta2Reason = InternalErrorV1Beta2Reason

	// MachineInfrastructureDoesNotExistV1Beta2Reason surfaces when a referenced infrastructure object does not exist.
	// Note: this could happen when creating the machine. However, this state should be treated as an error if it lasts indefinitely.
	MachineInfrastructureDoesNotExistV1Beta2Reason = ObjectDoesNotExistV1Beta2Reason

	// MachineInfrastructureDeletedV1Beta2Reason surfaces when a referenced infrastructure object has been deleted.
	// Note: controllers can't identify if the infrastructure object was deleted by the controller itself, e.g.
	// during the deletion workflow, or by a users.
	MachineInfrastructureDeletedV1Beta2Reason = ObjectDeletedV1Beta2Reason
)

Machine's InfrastructureReady condition and corresponding reasons that will be used in v1Beta2 API version. Note: when possible, InfrastructureReady condition will use reasons surfaced from the underlying infra machine object.

View Source 
const (
	// MachineNodeHealthyV1Beta2Condition is true if the Machine's Node is ready and it does not report MemoryPressure, DiskPressure and PIDPressure.
	MachineNodeHealthyV1Beta2Condition = "NodeHealthy"

	// MachineNodeReadyV1Beta2Condition is true if the Machine's Node is ready.
	MachineNodeReadyV1Beta2Condition = "NodeReady"

	// MachineNodeReadyV1Beta2Reason surfaces when Machine's Node Ready condition is true.
	MachineNodeReadyV1Beta2Reason = "NodeReady"

	// MachineNodeNotReadyV1Beta2Reason surfaces when Machine's Node Ready condition is false.
	MachineNodeNotReadyV1Beta2Reason = "NodeNotReady"

	// MachineNodeReadyUnknownV1Beta2Reason surfaces when Machine's Node Ready condition is unknown.
	MachineNodeReadyUnknownV1Beta2Reason = "NodeReadyUnknown"

	// MachineNodeHealthyV1Beta2Reason surfaces when all the node conditions report healthy state.
	MachineNodeHealthyV1Beta2Reason = "NodeHealthy"

	// MachineNodeNotHealthyV1Beta2Reason surfaces when at least one node conditions report not healthy state.
	MachineNodeNotHealthyV1Beta2Reason = "NodeNotHealthy"

	// MachineNodeHealthUnknownV1Beta2Reason surfaces when at least one node conditions report healthy state unknown
	// and no node conditions report not healthy state.
	MachineNodeHealthUnknownV1Beta2Reason = "NodeHealthyUnknown"

	// MachineNodeInternalErrorV1Beta2Reason surfaces unexpected failures when reading a Node object.
	MachineNodeInternalErrorV1Beta2Reason = InternalErrorV1Beta2Reason

	// MachineNodeDoesNotExistV1Beta2Reason surfaces when the node hosted on the machine does not exist.
	// Note: this could happen when creating the machine. However, this state should be treated as an error if it lasts indefinitely.
	MachineNodeDoesNotExistV1Beta2Reason = "NodeDoesNotExist"

	// MachineNodeDeletedV1Beta2Reason surfaces when the node hosted on the machine has been deleted.
	// Note: controllers can't identify if the Node was deleted by the controller itself, e.g.
	// during the deletion workflow, or by a users.
	MachineNodeDeletedV1Beta2Reason = "NodeDeleted"

	// MachineNodeInspectionFailedV1Beta2Reason documents a failure when inspecting the status of a Node.
	MachineNodeInspectionFailedV1Beta2Reason = InspectionFailedV1Beta2Reason

	// MachineNodeConnectionDownV1Beta2Reason surfaces that the connection to the workload cluster is down.
	MachineNodeConnectionDownV1Beta2Reason = ConnectionDownV1Beta2Reason
)

Machine's NodeHealthy and NodeReady conditions and corresponding reasons that will be used in v1Beta2 API version. Note: when possible, NodeHealthy and NodeReady conditions will use reasons surfaced from the underlying node.

View Source 
const (
	// MachineHealthCheckSucceededV1Beta2Condition is true if MHC instances targeting this machine report the Machine
	// is healthy according to the definition of healthy present in the spec of the MachineHealthCheck object.
	MachineHealthCheckSucceededV1Beta2Condition = "HealthCheckSucceeded"

	// MachineHealthCheckSucceededV1Beta2Reason surfaces when a machine passes all the health checks defined by a MachineHealthCheck object.
	MachineHealthCheckSucceededV1Beta2Reason = "HealthCheckSucceeded"

	// MachineHealthCheckUnhealthyNodeV1Beta2Reason surfaces when the node hosted on the machine does not pass the health checks
	// defined by a MachineHealthCheck object.
	MachineHealthCheckUnhealthyNodeV1Beta2Reason = "UnhealthyNode"

	// MachineHealthCheckNodeStartupTimeoutV1Beta2Reason surfaces when the node hosted on the machine does not appear within
	// the timeout defined by a MachineHealthCheck object.
	MachineHealthCheckNodeStartupTimeoutV1Beta2Reason = "NodeStartupTimeout"

	// MachineHealthCheckNodeDeletedV1Beta2Reason surfaces when a MachineHealthCheck detects that the node hosted on the
	// machine has been deleted while the Machine is still running.
	MachineHealthCheckNodeDeletedV1Beta2Reason = "NodeDeleted"

	// MachineHealthCheckHasRemediateAnnotationV1Beta2Reason surfaces when a MachineHealthCheck detects that a Machine was
	// marked for remediation via the `cluster.x-k8s.io/remediate-machine` annotation.
	MachineHealthCheckHasRemediateAnnotationV1Beta2Reason = "HasRemediateAnnotation"
)

Machine's HealthCheckSucceeded condition and corresponding reasons that will be used in v1Beta2 API version. Note: HealthCheckSucceeded condition is set by the MachineHealthCheck controller.

View Source 
const (
	// MachineOwnerRemediatedV1Beta2Condition is only present if MHC instances targeting this machine
	// determine that the controller owning this machine should perform remediation.
	MachineOwnerRemediatedV1Beta2Condition = "OwnerRemediated"

	// MachineOwnerRemediatedWaitingForRemediationV1Beta2Reason surfaces the machine is waiting for the owner controller
	// to start remediation.
	MachineOwnerRemediatedWaitingForRemediationV1Beta2Reason = "WaitingForRemediation"
)

Machine's OwnerRemediated conditions and corresponding reasons that will be used in v1Beta2 API version. Note: OwnerRemediated condition is initially set by the MachineHealthCheck controller; then it is up to the Machine's owner controller to update or delete this condition.

View Source 
const (
	// MachineExternallyRemediatedV1Beta2Condition is only present if MHC instances targeting this machine
	// determine that an external controller should perform remediation.
	MachineExternallyRemediatedV1Beta2Condition = "ExternallyRemediated"

	// MachineExternallyRemediatedWaitingForRemediationV1Beta2Reason surfaces the machine is waiting for the
	// external remediation controller to start remediation.
	MachineExternallyRemediatedWaitingForRemediationV1Beta2Reason = "WaitingForRemediation"

	// MachineExternallyRemediatedRemediationTemplateNotFoundV1Beta2Reason surfaces that the MachineHealthCheck cannot
	// find the template for an external remediation request.
	MachineExternallyRemediatedRemediationTemplateNotFoundV1Beta2Reason = "RemediationTemplateNotFound"

	// MachineExternallyRemediatedRemediationRequestCreationFailedV1Beta2Reason surfaces that the MachineHealthCheck cannot
	// create a request for the external remediation controller.
	MachineExternallyRemediatedRemediationRequestCreationFailedV1Beta2Reason = "RemediationRequestCreationFailed"
)

Machine's ExternallyRemediated conditions and corresponding reasons that will be used in v1Beta2 API version. Note: ExternallyRemediated condition is initially set by the MachineHealthCheck controller; then it is up to the external remediation controller to update or delete this condition.

View Source 
const (
	// MachineDeletingV1Beta2Condition surfaces details about progress in the machine deletion workflow.
	MachineDeletingV1Beta2Condition = DeletingV1Beta2Condition

	// MachineNotDeletingV1Beta2Reason surfaces when the Machine is not deleting because the
	// DeletionTimestamp is not set.
	MachineNotDeletingV1Beta2Reason = NotDeletingV1Beta2Reason

	// MachineDeletingV1Beta2Reason surfaces when the Machine is deleting because the
	// DeletionTimestamp is set. This reason is used if none of the more specific reasons apply.
	MachineDeletingV1Beta2Reason = DeletingV1Beta2Reason

	// MachineDeletingInternalErrorV1Beta2Reason surfaces unexpected failures when deleting a Machine.
	MachineDeletingInternalErrorV1Beta2Reason = InternalErrorV1Beta2Reason

	// MachineDeletingWaitingForPreDrainHookV1Beta2Reason surfaces when the Machine deletion
	// waits for pre-drain hooks to complete. I.e. it waits until there are no annotations
	// with the `pre-drain.delete.hook.machine.cluster.x-k8s.io` prefix on the Machine anymore.
	MachineDeletingWaitingForPreDrainHookV1Beta2Reason = "WaitingForPreDrainHook"

	// MachineDeletingDrainingNodeV1Beta2Reason surfaces when the Machine deletion is draining the Node.
	MachineDeletingDrainingNodeV1Beta2Reason = "DrainingNode"

	// MachineDeletingWaitingForVolumeDetachV1Beta2Reason surfaces when the Machine deletion is
	// waiting for volumes to detach from the Node.
	MachineDeletingWaitingForVolumeDetachV1Beta2Reason = "WaitingForVolumeDetach"

	// MachineDeletingWaitingForPreTerminateHookV1Beta2Reason surfaces when the Machine deletion
	// waits for pre-terminate hooks to complete. I.e. it waits until there are no annotations
	// with the `pre-terminate.delete.hook.machine.cluster.x-k8s.io` prefix on the Machine anymore.
	MachineDeletingWaitingForPreTerminateHookV1Beta2Reason = "WaitingForPreTerminateHook"

	// MachineDeletingWaitingForInfrastructureDeletionV1Beta2Reason surfaces when the Machine deletion
	// waits for InfraMachine deletion to complete.
	MachineDeletingWaitingForInfrastructureDeletionV1Beta2Reason = "WaitingForInfrastructureDeletion"

	// MachineDeletingWaitingForBootstrapDeletionV1Beta2Reason surfaces when the Machine deletion
	// waits for BootstrapConfig deletion to complete.
	MachineDeletingWaitingForBootstrapDeletionV1Beta2Reason = "WaitingForBootstrapDeletion"

	// MachineDeletingDeletingNodeV1Beta2Reason surfaces when the Machine deletion is
	// deleting the Node.
	MachineDeletingDeletingNodeV1Beta2Reason = "DeletingNode"

	// MachineDeletingDeletionCompletedV1Beta2Reason surfaces when the Machine deletion has been completed.
	// This reason is set right after the `machine.cluster.x-k8s.io` finalizer is removed.
	// This means that the object will go away (i.e. be removed from etcd), except if there are other
	// finalizers on the Machine object.
	MachineDeletingDeletionCompletedV1Beta2Reason = DeletionCompletedV1Beta2Reason
)

Machine's Deleting condition and corresponding reasons that will be used in v1Beta2 API version.

View Source 
const (
	// MachineDeploymentTopologyFinalizer is the finalizer used by the topology MachineDeployment controller to
	// clean up referenced template resources if necessary when a MachineDeployment is being deleted.
	MachineDeploymentTopologyFinalizer = "machinedeployment.topology.cluster.x-k8s.io"

	// MachineDeploymentFinalizer is the finalizer used by the MachineDeployment controller to
	// ensure ordered cleanup of corresponding MachineSets when a MachineDeployment is being deleted.
	MachineDeploymentFinalizer = "cluster.x-k8s.io/machinedeployment"
)
View Source 
const (
	// RollingUpdateMachineDeploymentStrategyType replaces the old MachineSet by new one using rolling update
	// i.e. gradually scale down the old MachineSet and scale up the new one.
	RollingUpdateMachineDeploymentStrategyType MachineDeploymentStrategyType = "RollingUpdate"

	// OnDeleteMachineDeploymentStrategyType replaces old MachineSets when the deletion of the associated machines are completed.
	OnDeleteMachineDeploymentStrategyType MachineDeploymentStrategyType = "OnDelete"

	// RevisionAnnotation is the revision annotation of a machine deployment's machine sets which records its rollout sequence.
	RevisionAnnotation = "machinedeployment.clusters.x-k8s.io/revision"

	// RevisionHistoryAnnotation maintains the history of all old revisions that a machine set has served for a machine deployment.
	//
	// Deprecated: This annotation is deprecated and is going to be removed in the next apiVersion. Please see https://github.com/kubernetes-sigs/cluster-api/issues/10479 for more details.
	RevisionHistoryAnnotation = "machinedeployment.clusters.x-k8s.io/revision-history"

	// DesiredReplicasAnnotation is the desired replicas for a machine deployment recorded as an annotation
	// in its machine sets. Helps in separating scaling events from the rollout process and for
	// determining if the new machine set for a deployment is really saturated.
	DesiredReplicasAnnotation = "machinedeployment.clusters.x-k8s.io/desired-replicas"

	// MaxReplicasAnnotation is the maximum replicas a deployment can have at a given point, which
	// is machinedeployment.spec.replicas + maxSurge. Used by the underlying machine sets to estimate their
	// proportions in case the deployment has surge replicas.
	MaxReplicasAnnotation = "machinedeployment.clusters.x-k8s.io/max-replicas"

	// MachineDeploymentUniqueLabel is used to uniquely identify the Machines of a MachineSet.
	// The MachineDeployment controller will set this label on a MachineSet when it is created.
	// The label is also applied to the Machines of the MachineSet and used in the MachineSet selector.
	// Note: For the lifetime of the MachineSet the label's value has to stay the same, otherwise the
	// MachineSet selector would no longer match its Machines.
	// Note: In previous Cluster API versions (< v1.4.0), the label value was the hash of the full machine template.
	// With the introduction of in-place mutation the machine template of the MachineSet can change.
	// Because of that it is impossible that the label's value to always be the hash of the full machine template.
	// (Because the hash changes when the machine template changes).
	// As a result, we use the hash of the machine template while ignoring all in-place mutable fields, i.e. the
	// machine template with only fields that could trigger a rollout for the machine-template-hash, making it
	// independent of the changes to any in-place mutable fields.
	// A random string is appended at the end of the label value (label value format is "<hash>-<random string>"))
	// to distinguish duplicate MachineSets that have the exact same spec but were created as a result of rolloutAfter.
	MachineDeploymentUniqueLabel = "machine-template-hash"
)
View Source 
const (
	// MachineDeploymentAvailableV1Beta2Condition is true if the MachineDeployment is not deleted, and it has minimum
	// availability according to parameters specified in the deployment strategy, e.g. If using RollingUpgrade strategy,
	// availableReplicas must be greater or equal than desired replicas - MaxUnavailable replicas.
	MachineDeploymentAvailableV1Beta2Condition = AvailableV1Beta2Condition

	// MachineDeploymentAvailableWaitingForReplicasSetV1Beta2Reason surfaces when the .spec.replicas
	// field of the MachineDeployment is not set.
	MachineDeploymentAvailableWaitingForReplicasSetV1Beta2Reason = WaitingForReplicasSetV1Beta2Reason

	// MachineDeploymentAvailableWaitingForAvailableReplicasSetV1Beta2Reason surfaces when the .status.v1beta2.availableReplicas
	// field of the MachineDeployment is not set.
	MachineDeploymentAvailableWaitingForAvailableReplicasSetV1Beta2Reason = "WaitingForAvailableReplicasSet"

	// MachineDeploymentAvailableV1Beta2Reason surfaces when a Deployment is available.
	MachineDeploymentAvailableV1Beta2Reason = AvailableV1Beta2Reason

	// MachineDeploymentNotAvailableV1Beta2Reason surfaces when a Deployment is not available.
	MachineDeploymentNotAvailableV1Beta2Reason = NotAvailableV1Beta2Reason

	// MachineDeploymentAvailableInternalErrorV1Beta2Reason surfaces unexpected failures when computing the Available condition.
	MachineDeploymentAvailableInternalErrorV1Beta2Reason = InternalErrorV1Beta2Reason
)

MachineDeployment's Available condition and corresponding reasons that will be used in v1Beta2 API version.

View Source 
const (
	// MachineDeploymentMachinesReadyV1Beta2Condition surfaces detail of issues on the controlled machines, if any.
	MachineDeploymentMachinesReadyV1Beta2Condition = MachinesReadyV1Beta2Condition

	// MachineDeploymentMachinesReadyV1Beta2Reason surfaces when all the controlled machine's Ready conditions are true.
	MachineDeploymentMachinesReadyV1Beta2Reason = ReadyV1Beta2Reason

	// MachineDeploymentMachinesNotReadyV1Beta2Reason surfaces when at least one of the controlled machine's Ready conditions is false.
	MachineDeploymentMachinesNotReadyV1Beta2Reason = NotReadyV1Beta2Reason

	// MachineDeploymentMachinesReadyUnknownV1Beta2Reason surfaces when at least one of the controlled machine's Ready conditions is unknown
	// and none of the controlled machine's Ready conditions is false.
	MachineDeploymentMachinesReadyUnknownV1Beta2Reason = ReadyUnknownV1Beta2Reason

	// MachineDeploymentMachinesReadyNoReplicasV1Beta2Reason surfaces when no machines exist for the MachineDeployment.
	MachineDeploymentMachinesReadyNoReplicasV1Beta2Reason = NoReplicasV1Beta2Reason

	// MachineDeploymentMachinesReadyInternalErrorV1Beta2Reason surfaces unexpected failures when listing machines
	// or aggregating machine's conditions.
	MachineDeploymentMachinesReadyInternalErrorV1Beta2Reason = InternalErrorV1Beta2Reason
)

MachineDeployment's MachinesReady condition and corresponding reasons that will be used in v1Beta2 API version.

View Source 
const (
	// MachineDeploymentMachinesUpToDateV1Beta2Condition surfaces details of controlled machines not up to date, if any.
	// Note: New machines are considered 10s after machine creation. This gives time to the machine's owner controller to recognize the new machine and add the UpToDate condition.
	MachineDeploymentMachinesUpToDateV1Beta2Condition = MachinesUpToDateV1Beta2Condition

	// MachineDeploymentMachinesUpToDateV1Beta2Reason surfaces when all the controlled machine's UpToDate conditions are true.
	MachineDeploymentMachinesUpToDateV1Beta2Reason = UpToDateV1Beta2Reason

	// MachineDeploymentMachinesNotUpToDateV1Beta2Reason surfaces when at least one of the controlled machine's UpToDate conditions is false.
	MachineDeploymentMachinesNotUpToDateV1Beta2Reason = NotUpToDateV1Beta2Reason

	// MachineDeploymentMachinesUpToDateUnknownV1Beta2Reason surfaces when at least one of the controlled machine's UpToDate conditions is unknown
	// and none of the controlled machine's UpToDate conditions is false.
	MachineDeploymentMachinesUpToDateUnknownV1Beta2Reason = UpToDateUnknownV1Beta2Reason

	// MachineDeploymentMachinesUpToDateNoReplicasV1Beta2Reason surfaces when no machines exist for the MachineDeployment.
	MachineDeploymentMachinesUpToDateNoReplicasV1Beta2Reason = NoReplicasV1Beta2Reason

	// MachineDeploymentMachinesUpToDateInternalErrorV1Beta2Reason surfaces unexpected failures when listing machines
	// or aggregating status.
	MachineDeploymentMachinesUpToDateInternalErrorV1Beta2Reason = InternalErrorV1Beta2Reason
)

MachineDeployment's MachinesUpToDate condition and corresponding reasons that will be used in v1Beta2 API version.

View Source 
const (
	// MachineDeploymentRollingOutV1Beta2Condition is true if there is at least one machine not up-to-date.
	MachineDeploymentRollingOutV1Beta2Condition = RollingOutV1Beta2Condition

	// MachineDeploymentRollingOutV1Beta2Reason surfaces when there is at least one machine not up-to-date.
	MachineDeploymentRollingOutV1Beta2Reason = RollingOutV1Beta2Reason

	// MachineDeploymentNotRollingOutV1Beta2Reason surfaces when all the machines are up-to-date.
	MachineDeploymentNotRollingOutV1Beta2Reason = NotRollingOutV1Beta2Reason

	// MachineDeploymentRollingOutInternalErrorV1Beta2Reason surfaces unexpected failures when listing machines.
	MachineDeploymentRollingOutInternalErrorV1Beta2Reason = InternalErrorV1Beta2Reason
)

MachineDeployment's RollingOut condition and corresponding reasons that will be used in v1Beta2 API version.

View Source 
const (
	// MachineDeploymentScalingUpV1Beta2Condition is true if actual replicas < desired replicas.
	MachineDeploymentScalingUpV1Beta2Condition = ScalingUpV1Beta2Condition

	// MachineDeploymentScalingUpV1Beta2Reason surfaces when actual replicas < desired replicas.
	MachineDeploymentScalingUpV1Beta2Reason = ScalingUpV1Beta2Reason

	// MachineDeploymentNotScalingUpV1Beta2Reason surfaces when actual replicas >= desired replicas.
	MachineDeploymentNotScalingUpV1Beta2Reason = NotScalingUpV1Beta2Reason

	// MachineDeploymentScalingUpInternalErrorV1Beta2Reason surfaces unexpected failures when listing machines.
	MachineDeploymentScalingUpInternalErrorV1Beta2Reason = InternalErrorV1Beta2Reason

	// MachineDeploymentScalingUpWaitingForReplicasSetV1Beta2Reason surfaces when the .spec.replicas
	// field of the MachineDeployment is not set.
	MachineDeploymentScalingUpWaitingForReplicasSetV1Beta2Reason = WaitingForReplicasSetV1Beta2Reason
)

MachineDeployment's ScalingUp condition and corresponding reasons that will be used in v1Beta2 API version.

View Source 
const (
	// MachineDeploymentScalingDownV1Beta2Condition is true if actual replicas > desired replicas.
	MachineDeploymentScalingDownV1Beta2Condition = ScalingDownV1Beta2Condition

	// MachineDeploymentScalingDownV1Beta2Reason surfaces when actual replicas > desired replicas.
	MachineDeploymentScalingDownV1Beta2Reason = ScalingDownV1Beta2Reason

	// MachineDeploymentNotScalingDownV1Beta2Reason surfaces when actual replicas <= desired replicas.
	MachineDeploymentNotScalingDownV1Beta2Reason = NotScalingDownV1Beta2Reason

	// MachineDeploymentScalingDownInternalErrorV1Beta2Reason surfaces unexpected failures when listing machines.
	MachineDeploymentScalingDownInternalErrorV1Beta2Reason = InternalErrorV1Beta2Reason

	// MachineDeploymentScalingDownWaitingForReplicasSetV1Beta2Reason surfaces when the .spec.replicas
	// field of the MachineDeployment is not set.
	MachineDeploymentScalingDownWaitingForReplicasSetV1Beta2Reason = WaitingForReplicasSetV1Beta2Reason
)

MachineDeployment's ScalingDown condition and corresponding reasons that will be used in v1Beta2 API version.

View Source 
const (
	// MachineDeploymentRemediatingV1Beta2Condition surfaces details about ongoing remediation of the controlled machines, if any.
	MachineDeploymentRemediatingV1Beta2Condition = RemediatingV1Beta2Condition

	// MachineDeploymentRemediatingV1Beta2Reason surfaces when the MachineDeployment has at least one machine with HealthCheckSucceeded set to false
	// and with the OwnerRemediated condition set to false.
	MachineDeploymentRemediatingV1Beta2Reason = RemediatingV1Beta2Reason

	// MachineDeploymentNotRemediatingV1Beta2Reason surfaces when the MachineDeployment does not have any machine with HealthCheckSucceeded set to false
	// and with the OwnerRemediated condition set to false.
	MachineDeploymentNotRemediatingV1Beta2Reason = NotRemediatingV1Beta2Reason

	// MachineDeploymentRemediatingInternalErrorV1Beta2Reason surfaces unexpected failures when computing the Remediating condition.
	MachineDeploymentRemediatingInternalErrorV1Beta2Reason = InternalErrorV1Beta2Reason
)

MachineDeployment's Remediating condition and corresponding reasons that will be used in v1Beta2 API version.

View Source 
const (
	// MachineDeploymentDeletingV1Beta2Condition surfaces details about ongoing deletion of the controlled machines.
	MachineDeploymentDeletingV1Beta2Condition = DeletingV1Beta2Condition

	// MachineDeploymentNotDeletingV1Beta2Reason surfaces when the MachineDeployment is not deleting because the
	// DeletionTimestamp is not set.
	MachineDeploymentNotDeletingV1Beta2Reason = NotDeletingV1Beta2Reason

	// MachineDeploymentDeletingV1Beta2Reason surfaces when the MachineDeployment is deleting because the
	// DeletionTimestamp is set.
	MachineDeploymentDeletingV1Beta2Reason = DeletingV1Beta2Reason

	// MachineDeploymentDeletingInternalErrorV1Beta2Reason surfaces unexpected failures when deleting a MachineDeployment.
	MachineDeploymentDeletingInternalErrorV1Beta2Reason = InternalErrorV1Beta2Reason
)

MachineDeployment's Deleting condition and corresponding reasons that will be used in v1Beta2 API version.

View Source 
const (
	// MachineDeploymentPhaseScalingUp indicates the MachineDeployment is scaling up.
	MachineDeploymentPhaseScalingUp = MachineDeploymentPhase("ScalingUp")

	// MachineDeploymentPhaseScalingDown indicates the MachineDeployment is scaling down.
	MachineDeploymentPhaseScalingDown = MachineDeploymentPhase("ScalingDown")

	// MachineDeploymentPhaseRunning indicates scaling has completed and all Machines are running.
	MachineDeploymentPhaseRunning = MachineDeploymentPhase("Running")

	// MachineDeploymentPhaseFailed indicates there was a problem scaling and user intervention might be required.
	MachineDeploymentPhaseFailed = MachineDeploymentPhase("Failed")

	// MachineDeploymentPhaseUnknown indicates the state of the MachineDeployment cannot be determined.
	MachineDeploymentPhaseUnknown = MachineDeploymentPhase("Unknown")
)
View Source 
const (
	// MachineHealthCheckRemediationAllowedV1Beta2Condition surfaces whether the MachineHealthCheck is
	// allowed to remediate any Machines or whether it is blocked from remediating any further.
	MachineHealthCheckRemediationAllowedV1Beta2Condition = "RemediationAllowed"

	// MachineHealthCheckTooManyUnhealthyV1Beta2Reason is the reason used when too many Machines are unhealthy and
	// the MachineHealthCheck is blocked from making any further remediation.
	MachineHealthCheckTooManyUnhealthyV1Beta2Reason = "TooManyUnhealthy"

	// MachineHealthCheckRemediationAllowedV1Beta2Reason is the reason used when the number of unhealthy machine
	// is within the limits defined by the MachineHealthCheck, and thus remediation is allowed.
	MachineHealthCheckRemediationAllowedV1Beta2Reason = "RemediationAllowed"
)

MachineHealthCheck's RemediationAllowed condition and corresponding reasons that will be used in v1Beta2 API version.

View Source 
const (
	// MachineSetTopologyFinalizer is the finalizer used by the topology MachineDeployment controller to
	// clean up referenced template resources if necessary when a MachineSet is being deleted.
	MachineSetTopologyFinalizer = "machineset.topology.cluster.x-k8s.io"

	// MachineSetFinalizer is the finalizer used by the MachineSet controller to
	// ensure ordered cleanup of corresponding Machines when a Machineset is being deleted.
	MachineSetFinalizer = "cluster.x-k8s.io/machineset"
)
View Source 
const (
	// MachineSetScalingUpV1Beta2Condition is true if actual replicas < desired replicas.
	// Note: In case a MachineSet preflight check is preventing scale up, this will surface in the condition message.
	MachineSetScalingUpV1Beta2Condition = ScalingUpV1Beta2Condition

	// MachineSetScalingUpV1Beta2Reason surfaces when actual replicas < desired replicas.
	MachineSetScalingUpV1Beta2Reason = ScalingUpV1Beta2Reason

	// MachineSetNotScalingUpV1Beta2Reason surfaces when actual replicas >= desired replicas.
	MachineSetNotScalingUpV1Beta2Reason = NotScalingUpV1Beta2Reason

	// MachineSetScalingUpInternalErrorV1Beta2Reason surfaces unexpected failures when listing machines.
	MachineSetScalingUpInternalErrorV1Beta2Reason = InternalErrorV1Beta2Reason

	// MachineSetScalingUpWaitingForReplicasSetV1Beta2Reason surfaces when the .spec.replicas
	// field of the MachineSet is not set.
	MachineSetScalingUpWaitingForReplicasSetV1Beta2Reason = WaitingForReplicasSetV1Beta2Reason
)

MachineSet's ScalingUp condition and corresponding reasons that will be used in v1Beta2 API version.

View Source 
const (
	// MachineSetScalingDownV1Beta2Condition is true if actual replicas > desired replicas.
	MachineSetScalingDownV1Beta2Condition = ScalingDownV1Beta2Condition

	// MachineSetScalingDownV1Beta2Reason surfaces when actual replicas > desired replicas.
	MachineSetScalingDownV1Beta2Reason = ScalingDownV1Beta2Reason

	// MachineSetNotScalingDownV1Beta2Reason surfaces when actual replicas <= desired replicas.
	MachineSetNotScalingDownV1Beta2Reason = NotScalingDownV1Beta2Reason

	// MachineSetScalingDownInternalErrorV1Beta2Reason surfaces unexpected failures when listing machines.
	MachineSetScalingDownInternalErrorV1Beta2Reason = InternalErrorV1Beta2Reason

	// MachineSetScalingDownWaitingForReplicasSetV1Beta2Reason surfaces when the .spec.replicas
	// field of the MachineSet is not set.
	MachineSetScalingDownWaitingForReplicasSetV1Beta2Reason = WaitingForReplicasSetV1Beta2Reason
)

MachineSet's ScalingDown condition and corresponding reasons that will be used in v1Beta2 API version.

View Source 
const (
	// MachineSetMachinesReadyV1Beta2Condition surfaces detail of issues on the controlled machines, if any.
	MachineSetMachinesReadyV1Beta2Condition = MachinesReadyV1Beta2Condition

	// MachineSetMachinesReadyV1Beta2Reason surfaces when all the controlled machine's Ready conditions are true.
	MachineSetMachinesReadyV1Beta2Reason = ReadyV1Beta2Reason

	// MachineSetMachinesNotReadyV1Beta2Reason surfaces when at least one of the controlled machine's Ready conditions is false.
	MachineSetMachinesNotReadyV1Beta2Reason = NotReadyV1Beta2Reason

	// MachineSetMachinesReadyUnknownV1Beta2Reason surfaces when at least one of the controlled machine's Ready conditions is unknown
	// and none of the controlled machine's Ready conditions is false.
	MachineSetMachinesReadyUnknownV1Beta2Reason = ReadyUnknownV1Beta2Reason

	// MachineSetMachinesReadyNoReplicasV1Beta2Reason surfaces when no machines exist for the MachineSet.
	MachineSetMachinesReadyNoReplicasV1Beta2Reason = NoReplicasV1Beta2Reason

	// MachineSetMachinesReadyInternalErrorV1Beta2Reason surfaces unexpected failures when listing machines
	// or aggregating machine's conditions.
	MachineSetMachinesReadyInternalErrorV1Beta2Reason = InternalErrorV1Beta2Reason
)

MachineSet's MachinesReady condition and corresponding reasons that will be used in v1Beta2 API version. Note: Reason's could also be derived from the aggregation of machine's Ready conditions.

View Source 
const (
	// MachineSetMachinesUpToDateV1Beta2Condition surfaces details of controlled machines not up to date, if any.
	// Note: New machines are considered 10s after machine creation. This gives time to the machine's owner controller to recognize the new machine and add the UpToDate condition.
	MachineSetMachinesUpToDateV1Beta2Condition = MachinesUpToDateV1Beta2Condition

	// MachineSetMachinesUpToDateV1Beta2Reason surfaces when all the controlled machine's UpToDate conditions are true.
	MachineSetMachinesUpToDateV1Beta2Reason = UpToDateV1Beta2Reason

	// MachineSetMachinesNotUpToDateV1Beta2Reason surfaces when at least one of the controlled machine's UpToDate conditions is false.
	MachineSetMachinesNotUpToDateV1Beta2Reason = NotUpToDateV1Beta2Reason

	// MachineSetMachinesUpToDateUnknownV1Beta2Reason surfaces when at least one of the controlled machine's UpToDate conditions is unknown
	// and none of the controlled machine's UpToDate conditions is false.
	MachineSetMachinesUpToDateUnknownV1Beta2Reason = UpToDateUnknownV1Beta2Reason

	// MachineSetMachinesUpToDateNoReplicasV1Beta2Reason surfaces when no machines exist for the MachineSet.
	MachineSetMachinesUpToDateNoReplicasV1Beta2Reason = NoReplicasV1Beta2Reason

	// MachineSetMachinesUpToDateInternalErrorV1Beta2Reason surfaces unexpected failures when listing machines
	// or aggregating status.
	MachineSetMachinesUpToDateInternalErrorV1Beta2Reason = InternalErrorV1Beta2Reason
)

MachineSet's MachinesUpToDate condition and corresponding reasons that will be used in v1Beta2 API version. Note: Reason's could also be derived from the aggregation of machine's MachinesUpToDate conditions.

View Source 
const (
	// MachineSetRemediatingV1Beta2Condition surfaces details about ongoing remediation of the controlled machines, if any.
	MachineSetRemediatingV1Beta2Condition = RemediatingV1Beta2Condition

	// MachineSetRemediatingV1Beta2Reason surfaces when the MachineSet has at least one machine with HealthCheckSucceeded set to false
	// and with the OwnerRemediated condition set to false.
	MachineSetRemediatingV1Beta2Reason = RemediatingV1Beta2Reason

	// MachineSetNotRemediatingV1Beta2Reason surfaces when the MachineSet does not have any machine with HealthCheckSucceeded set to false
	// and with the OwnerRemediated condition set to false.
	MachineSetNotRemediatingV1Beta2Reason = NotRemediatingV1Beta2Reason

	// MachineSetRemediatingInternalErrorV1Beta2Reason surfaces unexpected failures when computing the Remediating condition.
	MachineSetRemediatingInternalErrorV1Beta2Reason = InternalErrorV1Beta2Reason
)

MachineSet's Remediating condition and corresponding reasons that will be used in v1Beta2 API version.

View Source 
const (
	// MachineSetMachineCannotBeRemediatedV1Beta2Reason surfaces when remediation of a MachineSet machine can't be started.
	MachineSetMachineCannotBeRemediatedV1Beta2Reason = "CannotBeRemediated"

	// MachineSetMachineRemediationDeferredV1Beta2Reason surfaces when remediation of a MachineSet machine must be deferred.
	MachineSetMachineRemediationDeferredV1Beta2Reason = "RemediationDeferred"

	// MachineSetMachineRemediationMachineDeletingV1Beta2Reason surfaces when remediation of a MachineSet machine
	// has been completed by deleting the unhealthy machine.
	// Note: After an unhealthy machine is deleted, a new one is created by the MachineSet as part of the
	// regular reconcile loop that ensures the correct number of replicas exist.
	MachineSetMachineRemediationMachineDeletingV1Beta2Reason = "MachineDeleting"
)

Reasons that will be used for the OwnerRemediated condition set by MachineHealthCheck on MachineSet controlled machines being remediated in v1Beta2 API version.

View Source 
const (
	// MachineSetDeletingV1Beta2Condition surfaces details about ongoing deletion of the controlled machines.
	MachineSetDeletingV1Beta2Condition = DeletingV1Beta2Condition

	// MachineSetNotDeletingV1Beta2Reason surfaces when the MachineSet is not deleting because the
	// DeletionTimestamp is not set.
	MachineSetNotDeletingV1Beta2Reason = NotDeletingV1Beta2Reason

	// MachineSetDeletingV1Beta2Reason surfaces when the MachineSet is deleting because the
	// DeletionTimestamp is set.
	MachineSetDeletingV1Beta2Reason = DeletingV1Beta2Reason

	// MachineSetDeletingInternalErrorV1Beta2Reason surfaces unexpected failures when deleting a MachineSet.
	MachineSetDeletingInternalErrorV1Beta2Reason = InternalErrorV1Beta2Reason
)

MachineSet's Deleting condition and corresponding reasons that will be used in v1Beta2 API version.

View Source 
const (
	// AvailableV1Beta2Condition reports if an object is available.
	// Note: This condition type is defined to ensure consistent naming of conditions across objects.
	// Please use object specific variants of this condition which provides more details for each context where
	// the same condition type exists.
	AvailableV1Beta2Condition = "Available"

	// ReadyV1Beta2Condition reports if an object is ready.
	// Note: This condition type is defined to ensure consistent naming of conditions across objects.
	// Please use object specific variants of this condition which provides more details for each context where
	// the same condition type exists.
	ReadyV1Beta2Condition = "Ready"

	// BootstrapConfigReadyV1Beta2Condition reports if an object's bootstrap config is ready.
	// Note: This condition type is defined to ensure consistent naming of conditions across objects.
	// Please use object specific variants of this condition which provides more details for each context where
	// the same condition type exists.
	BootstrapConfigReadyV1Beta2Condition = "BootstrapConfigReady"

	// InfrastructureReadyV1Beta2Condition reports if an object's infrastructure is ready.
	// Note: This condition type is defined to ensure consistent naming of conditions across objects.
	// Please use object specific variants of this condition which provides more details for each context where
	// the same condition type exists.
	InfrastructureReadyV1Beta2Condition = "InfrastructureReady"

	// MachinesReadyV1Beta2Condition surfaces detail of issues on the controlled machines, if any.
	// Note: This condition type is defined to ensure consistent naming of conditions across objects.
	// Please use object specific variants of this condition which provides more details for each context where
	// the same condition type exists.
	MachinesReadyV1Beta2Condition = "MachinesReady"

	// MachinesUpToDateV1Beta2Condition surfaces details of controlled machines not up to date, if any.
	// Note: This condition type is defined to ensure consistent naming of conditions across objects.
	// Please use object specific variants of this condition which provides more details for each context where
	// the same condition type exists.
	MachinesUpToDateV1Beta2Condition = "MachinesUpToDate"

	// RollingOutV1Beta2Condition reports if an object is rolling out changes to machines; Cluster API usually
	// rolls out changes to machines by replacing not up-to-date machines with new ones.
	// Note: This condition type is defined to ensure consistent naming of conditions across objects.
	// Please use object specific variants of this condition which provides more details for each context where
	// the same condition type exists.
	RollingOutV1Beta2Condition = "RollingOut"

	// ScalingUpV1Beta2Condition reports if an object is scaling up.
	// Note: This condition type is defined to ensure consistent naming of conditions across objects.
	// Please use object specific variants of this condition which provides more details for each context where
	// the same condition type exists.
	ScalingUpV1Beta2Condition = "ScalingUp"

	// ScalingDownV1Beta2Condition reports if an object is scaling down.
	// Note: This condition type is defined to ensure consistent naming of conditions across objects.
	// Please use object specific variants of this condition which provides more details for each context where
	// the same condition type exists.
	ScalingDownV1Beta2Condition = "ScalingDown"

	// RemediatingV1Beta2Condition surfaces details about ongoing remediation of the controlled machines, if any.
	// Note: This condition type is defined to ensure consistent naming of conditions across objects.
	// Please use object specific variants of this condition which provides more details for each context where
	// the same condition type exists.
	RemediatingV1Beta2Condition = "Remediating"

	// DeletingV1Beta2Condition surfaces details about progress of the object deletion workflow.
	// Note: This condition type is defined to ensure consistent naming of conditions across objects.
	// Please use object specific variants of this condition which provides more details for each context where
	// the same condition type exists.
	DeletingV1Beta2Condition = "Deleting"

	// PausedV1Beta2Condition reports if reconciliation for an object or the cluster is paused.
	// Note: This condition type is defined to ensure consistent naming of conditions across objects.
	// Please use object specific variants of this condition which provides more details for each context where
	// the same condition type exists.
	PausedV1Beta2Condition = "Paused"
)

Conditions types that are used across different objects.

View Source 
const (
	// AvailableV1Beta2Reason applies to a condition surfacing object availability.
	AvailableV1Beta2Reason = "Available"

	// NotAvailableV1Beta2Reason applies to a condition surfacing object not satisfying availability criteria.
	NotAvailableV1Beta2Reason = "NotAvailable"

	// AvailableUnknownV1Beta2Reason applies to a condition surfacing object availability unknown.
	AvailableUnknownV1Beta2Reason = "AvailableUnknown"

	// ReadyV1Beta2Reason applies to a condition surfacing object readiness.
	ReadyV1Beta2Reason = "Ready"

	// NotReadyV1Beta2Reason applies to a condition surfacing object not satisfying readiness criteria.
	NotReadyV1Beta2Reason = "NotReady"

	// ReadyUnknownV1Beta2Reason applies to a condition surfacing object readiness unknown.
	ReadyUnknownV1Beta2Reason = "ReadyUnknown"

	// UpToDateV1Beta2Reason applies to a condition surfacing object up-tp-date.
	UpToDateV1Beta2Reason = "UpToDate"

	// NotUpToDateV1Beta2Reason applies to a condition surfacing object not up-tp-date.
	NotUpToDateV1Beta2Reason = "NotUpToDate"

	// UpToDateUnknownV1Beta2Reason applies to a condition surfacing object up-tp-date unknown.
	UpToDateUnknownV1Beta2Reason = "UpToDateUnknown"

	// RollingOutV1Beta2Reason surfaces when an object is rolling out.
	RollingOutV1Beta2Reason = "RollingOut"

	// NotRollingOutV1Beta2Reason surfaces when an object is not rolling out.
	NotRollingOutV1Beta2Reason = "NotRollingOut"

	// ScalingUpV1Beta2Reason surfaces when an object is scaling up.
	ScalingUpV1Beta2Reason = "ScalingUp"

	// NotScalingUpV1Beta2Reason surfaces when an object is not scaling up.
	NotScalingUpV1Beta2Reason = "NotScalingUp"

	// ScalingDownV1Beta2Reason surfaces when an object is scaling down.
	ScalingDownV1Beta2Reason = "ScalingDown"

	// NotScalingDownV1Beta2Reason surfaces when an object is not scaling down.
	NotScalingDownV1Beta2Reason = "NotScalingDown"

	// RemediatingV1Beta2Reason surfaces when an object owns at least one machine with HealthCheckSucceeded
	// set to false and with the OwnerRemediated condition set to false by the MachineHealthCheck controller.
	RemediatingV1Beta2Reason = "Remediating"

	// NotRemediatingV1Beta2Reason surfaces when an object does not own any machines with HealthCheckSucceeded
	// set to false and with the OwnerRemediated condition set to false by the MachineHealthCheck controller.
	NotRemediatingV1Beta2Reason = "NotRemediating"

	// NoReplicasV1Beta2Reason surfaces when an object that manage replicas does not have any.
	NoReplicasV1Beta2Reason = "NoReplicas"

	// WaitingForReplicasSetV1Beta2Reason surfaces when the replica field of an object is not set.
	WaitingForReplicasSetV1Beta2Reason = "WaitingForReplicasSet"

	// InvalidConditionReportedV1Beta2Reason applies to a condition, usually read from an external object, that is invalid
	// (e.g. its status is missing).
	InvalidConditionReportedV1Beta2Reason = "InvalidConditionReported"

	// NoReasonReportedV1Beta2Reason applies to a condition, usually read from an external object, that reports no reason.
	// Note: this could happen e.g. when an external object still uses Cluster API v1beta1 Conditions.
	NoReasonReportedV1Beta2Reason = "NoReasonReported"

	// InternalErrorV1Beta2Reason surfaces unexpected errors reporting by controllers.
	// In most cases, it will be required to look at controllers logs to properly triage those issues.
	InternalErrorV1Beta2Reason = "InternalError"

	// ObjectDoesNotExistV1Beta2Reason surfaces when a referenced object does not exist.
	ObjectDoesNotExistV1Beta2Reason = "ObjectDoesNotExist"

	// ObjectDeletedV1Beta2Reason surfaces when a referenced object has been deleted.
	// Note: controllers can't identify if the object was deleted by the controller itself, e.g.
	// during the deletion workflow, or by a users.
	ObjectDeletedV1Beta2Reason = "ObjectDeleted"

	// NotPausedV1Beta2Reason surfaces when an object is not paused.
	NotPausedV1Beta2Reason = "NotPaused"

	// PausedV1Beta2Reason surfaces when an object is paused.
	PausedV1Beta2Reason = "Paused"

	// ConnectionDownV1Beta2Reason surfaces that the connection to the workload cluster is down.
	ConnectionDownV1Beta2Reason = "ConnectionDown"

	// NotDeletingV1Beta2Reason surfaces when an object is not deleting because the
	// DeletionTimestamp is not set.
	NotDeletingV1Beta2Reason = "NotDeleting"

	// DeletingV1Beta2Reason surfaces when an object is deleting because the
	// DeletionTimestamp is set. This reason is used if none of the more specific reasons apply.
	DeletingV1Beta2Reason = "Deleting"

	// DeletionCompletedV1Beta2Reason surfaces when the deletion process has been completed.
	// This reason is set right after the corresponding finalizer is removed.
	// This means that the object will go away (i.e. be removed from etcd), except if there are other
	// finalizers on the object.
	DeletionCompletedV1Beta2Reason = "DeletionCompleted"

	// InspectionFailedV1Beta2Reason applies to a condition when inspection of the underlying object failed.
	InspectionFailedV1Beta2Reason = "InspectionFailed"
)

Reasons that are used across different objects.

View Source 
const ClusterClassKind = "ClusterClass"

ClusterClassKind represents the Kind of ClusterClass.

View Source 
const (
	// PodDrainLabel is the label that can be set on Pods in workload clusters to ensure a Pod is not drained.
	// The only valid value is "skip".
	// This label takes precedence over MachineDrainRules defined in the management cluster.
	PodDrainLabel = "cluster.x-k8s.io/drain"
)
View Source 
const (
	// TemplateSuffix is the object kind suffix used by template types.
	TemplateSuffix = "Template"
)

Variables

View Source 
var (
	// GroupVersion is group version used to register these objects.
	GroupVersion = schema.GroupVersion{Group: "cluster.x-k8s.io", Version: "v1beta1"}

	// AddToScheme adds the types in this group-version to the given scheme.
	AddToScheme = schemeBuilder.AddToScheme
)
View Source 
var (
	// DefaultNodeStartupTimeout is the time allowed for a node to start up.
	// Can be made longer as part of spec if required for particular provider.
	// 10 minutes should allow the instance to start and the node to join the
	// cluster on most providers.
	DefaultNodeStartupTimeout = metav1.Duration{Duration: 10 * time.Minute}
)
View Source 
var NodeOutdatedRevisionTaint = corev1.Taint{
	Key:    "node.cluster.x-k8s.io/outdated-revision",
	Effect: corev1.TaintEffectPreferNoSchedule,
}

NodeOutdatedRevisionTaint can be added to Nodes at rolling updates in general triggered by updating MachineDeployment This taint is used to prevent unnecessary pod churn, i.e., as the first node is drained, pods previously running on that node are scheduled onto nodes who have yet to be replaced, but will be torn down soon.

View Source 
var NodeUninitializedTaint = corev1.Taint{
	Key:    "node.cluster.x-k8s.io/uninitialized",
	Effect: corev1.TaintEffectNoSchedule,
}

NodeUninitializedTaint can be added to Nodes at creation by the bootstrap provider, e.g. the KubeadmBootstrap provider will add the taint. This taint is used to prevent workloads to be scheduled on Nodes before the node is initialized by Cluster API. As of today the Node initialization consists of syncing labels from Machines to Nodes. Once the labels have been initially synced the taint is removed from the Node.

View Source 
var (
	// ZeroDuration is a zero value of the metav1.Duration type.
	ZeroDuration = metav1.Duration{}
)

Functions

func GetOpenAPIDefinitions added in v1.2.0 

func GetOpenAPIDefinitions(ref common.ReferenceCallback) map[string]common.OpenAPIDefinition

Types

type APIEndpoint 

type APIEndpoint struct {
	// The hostname on which the API server is serving.
	Host string `json:"host"`

	// The port on which the API server is serving.
	Port int32 `json:"port"`
}

APIEndpoint represents a reachable Kubernetes API endpoint.

func (*APIEndpoint) DeepCopy 

func (in *APIEndpoint) DeepCopy() *APIEndpoint

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new APIEndpoint.

func (*APIEndpoint) DeepCopyInto 

func (in *APIEndpoint) DeepCopyInto(out *APIEndpoint)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (APIEndpoint) IsValid 

func (v APIEndpoint) IsValid() bool

IsValid returns true if both host and port are non-zero values.

func (APIEndpoint) IsZero 

func (v APIEndpoint) IsZero() bool

IsZero returns true if both host and port are zero values.

func (APIEndpoint) String 

func (v APIEndpoint) String() string

String returns a formatted version HOST:PORT of this APIEndpoint.

type Bootstrap 

type Bootstrap struct {
	// configRef is a reference to a bootstrap provider-specific resource
	// that holds configuration details. The reference is optional to
	// allow users/operators to specify Bootstrap.DataSecretName without
	// the need of a controller.
	// +optional
	ConfigRef *corev1.ObjectReference `json:"configRef,omitempty"`

	// dataSecretName is the name of the secret that stores the bootstrap data script.
	// If nil, the Machine should remain in the Pending state.
	// +optional
	DataSecretName *string `json:"dataSecretName,omitempty"`
}

Bootstrap encapsulates fields to configure the Machine’s bootstrapping mechanism.

func (*Bootstrap) DeepCopy 

func (in *Bootstrap) DeepCopy() *Bootstrap

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Bootstrap.

func (*Bootstrap) DeepCopyInto 

func (in *Bootstrap) DeepCopyInto(out *Bootstrap)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type Cluster 

type Cluster struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   ClusterSpec   `json:"spec,omitempty"`
	Status ClusterStatus `json:"status,omitempty"`
}

Cluster is the Schema for the clusters API.

func (*Cluster) DeepCopy 

func (in *Cluster) DeepCopy() *Cluster

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Cluster.

func (*Cluster) DeepCopyInto 

func (in *Cluster) DeepCopyInto(out *Cluster)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*Cluster) DeepCopyObject 

func (in *Cluster) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*Cluster) GetClassKey added in v1.8.0 

func (c *Cluster) GetClassKey() types.NamespacedName

GetClassKey returns the namespaced name for the class associated with this object.

func (*Cluster) GetConditions 

func (c *Cluster) GetConditions() Conditions

GetConditions returns the set of conditions for this object.

func (*Cluster) GetIPFamily deprecated 

func (c *Cluster) GetIPFamily() (ClusterIPFamily, error)

GetIPFamily returns a ClusterIPFamily from the configuration provided.

Deprecated: IPFamily is not a concept in Kubernetes. It was originally introduced in CAPI for CAPD. IPFamily will be dropped in a future release. More details at https://github.com/kubernetes-sigs/cluster-api/issues/7521

func (*Cluster) GetV1Beta2Conditions added in v1.9.0 

func (c *Cluster) GetV1Beta2Conditions() []metav1.Condition

GetV1Beta2Conditions returns the set of conditions for this object.

func (*Cluster) Hub 

func (*Cluster) Hub()

func (*Cluster) SetConditions 

func (c *Cluster) SetConditions(conditions Conditions)

SetConditions sets the conditions on this object.

func (*Cluster) SetV1Beta2Conditions added in v1.9.0 

func (c *Cluster) SetV1Beta2Conditions(conditions []metav1.Condition)

SetV1Beta2Conditions sets conditions for an API object.

type ClusterAvailabilityGate added in v1.9.0 

type ClusterAvailabilityGate struct {
	// conditionType refers to a positive polarity condition (status true means good) with matching type in the Cluster's condition list.
	// If the conditions doesn't exist, it will be treated as unknown.
	// Note: Both Cluster API conditions or conditions added by 3rd party controllers can be used as availability gates.
	// +required
	// +kubebuilder:validation:Pattern=`^([a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*/)?(([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9])$`
	// +kubebuilder:validation:MaxLength=316
	// +kubebuilder:validation:MinLength=1
	ConditionType string `json:"conditionType"`
}

ClusterAvailabilityGate contains the type of a Cluster condition to be used as availability gate.

func (*ClusterAvailabilityGate) DeepCopy added in v1.9.0 

func (in *ClusterAvailabilityGate) DeepCopy() *ClusterAvailabilityGate

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterAvailabilityGate.

func (*ClusterAvailabilityGate) DeepCopyInto added in v1.9.0 

func (in *ClusterAvailabilityGate) DeepCopyInto(out *ClusterAvailabilityGate)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ClusterClass 

type ClusterClass struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   ClusterClassSpec   `json:"spec,omitempty"`
	Status ClusterClassStatus `json:"status,omitempty"`
}

ClusterClass is a template which can be used to create managed topologies.

func (*ClusterClass) DeepCopy 

func (in *ClusterClass) DeepCopy() *ClusterClass

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterClass.

func (*ClusterClass) DeepCopyInto 

func (in *ClusterClass) DeepCopyInto(out *ClusterClass)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ClusterClass) DeepCopyObject 

func (in *ClusterClass) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*ClusterClass) GetConditions added in v1.3.0 

func (c *ClusterClass) GetConditions() Conditions

GetConditions returns the set of conditions for this object.

func (*ClusterClass) GetV1Beta2Conditions added in v1.9.0 

func (c *ClusterClass) GetV1Beta2Conditions() []metav1.Condition

GetV1Beta2Conditions returns the set of conditions for this object.

func (*ClusterClass) Hub 

func (*ClusterClass) Hub()

func (*ClusterClass) SetConditions added in v1.3.0 

func (c *ClusterClass) SetConditions(conditions Conditions)

SetConditions sets the conditions on this object.

func (*ClusterClass) SetV1Beta2Conditions added in v1.9.0 

func (c *ClusterClass) SetV1Beta2Conditions(conditions []metav1.Condition)

SetV1Beta2Conditions sets conditions for an API object.

type ClusterClassList 

type ClusterClassList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []ClusterClass `json:"items"`
}

ClusterClassList contains a list of Cluster.

func (*ClusterClassList) DeepCopy 

func (in *ClusterClassList) DeepCopy() *ClusterClassList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterClassList.

func (*ClusterClassList) DeepCopyInto 

func (in *ClusterClassList) DeepCopyInto(out *ClusterClassList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ClusterClassList) DeepCopyObject 

func (in *ClusterClassList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*ClusterClassList) Hub 

func (*ClusterClassList) Hub()

type ClusterClassPatch 

type ClusterClassPatch struct {
	// name of the patch.
	Name string `json:"name"`

	// description is a human-readable description of this patch.
	Description string `json:"description,omitempty"`

	// enabledIf is a Go template to be used to calculate if a patch should be enabled.
	// It can reference variables defined in .spec.variables and builtin variables.
	// The patch will be enabled if the template evaluates to `true`, otherwise it will
	// be disabled.
	// If EnabledIf is not set, the patch will be enabled per default.
	// +optional
	EnabledIf *string `json:"enabledIf,omitempty"`

	// definitions define inline patches.
	// Note: Patches will be applied in the order of the array.
	// Note: Exactly one of Definitions or External must be set.
	// +optional
	Definitions []PatchDefinition `json:"definitions,omitempty"`

	// external defines an external patch.
	// Note: Exactly one of Definitions or External must be set.
	// +optional
	External *ExternalPatchDefinition `json:"external,omitempty"`
}

ClusterClassPatch defines a patch which is applied to customize the referenced templates.

func (*ClusterClassPatch) DeepCopy 

func (in *ClusterClassPatch) DeepCopy() *ClusterClassPatch

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterClassPatch.

func (*ClusterClassPatch) DeepCopyInto 

func (in *ClusterClassPatch) DeepCopyInto(out *ClusterClassPatch)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ClusterClassSpec 

type ClusterClassSpec struct {
	// infrastructure is a reference to a provider-specific template that holds
	// the details for provisioning infrastructure specific cluster
	// for the underlying provider.
	// The underlying provider is responsible for the implementation
	// of the template to an infrastructure cluster.
	// +optional
	Infrastructure LocalObjectTemplate `json:"infrastructure,omitempty"`

	// controlPlane is a reference to a local struct that holds the details
	// for provisioning the Control Plane for the Cluster.
	// +optional
	ControlPlane ControlPlaneClass `json:"controlPlane,omitempty"`

	// workers describes the worker nodes for the cluster.
	// It is a collection of node types which can be used to create
	// the worker nodes of the cluster.
	// +optional
	Workers WorkersClass `json:"workers,omitempty"`

	// variables defines the variables which can be configured
	// in the Cluster topology and are then used in patches.
	// +optional
	Variables []ClusterClassVariable `json:"variables,omitempty"`

	// patches defines the patches which are applied to customize
	// referenced templates of a ClusterClass.
	// Note: Patches will be applied in the order of the array.
	// +optional
	Patches []ClusterClassPatch `json:"patches,omitempty"`
}

ClusterClassSpec describes the desired state of the ClusterClass.

func (*ClusterClassSpec) DeepCopy 

func (in *ClusterClassSpec) DeepCopy() *ClusterClassSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterClassSpec.

func (*ClusterClassSpec) DeepCopyInto 

func (in *ClusterClassSpec) DeepCopyInto(out *ClusterClassSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ClusterClassStatus added in v1.3.0 

type ClusterClassStatus struct {
	// variables is a list of ClusterClassStatusVariable that are defined for the ClusterClass.
	// +optional
	Variables []ClusterClassStatusVariable `json:"variables,omitempty"`

	// conditions defines current observed state of the ClusterClass.
	// +optional
	Conditions Conditions `json:"conditions,omitempty"`

	// observedGeneration is the latest generation observed by the controller.
	// +optional
	ObservedGeneration int64 `json:"observedGeneration,omitempty"`

	// v1beta2 groups all the fields that will be added or modified in ClusterClass's status with the V1Beta2 version.
	// +optional
	V1Beta2 *ClusterClassV1Beta2Status `json:"v1beta2,omitempty"`
}

ClusterClassStatus defines the observed state of the ClusterClass.

func (*ClusterClassStatus) DeepCopy added in v1.3.0 

func (in *ClusterClassStatus) DeepCopy() *ClusterClassStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterClassStatus.

func (*ClusterClassStatus) DeepCopyInto added in v1.3.0 

func (in *ClusterClassStatus) DeepCopyInto(out *ClusterClassStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ClusterClassStatusVariable added in v1.4.0 

type ClusterClassStatusVariable struct {
	// name is the name of the variable.
	Name string `json:"name"`

	// definitionsConflict specifies whether or not there are conflicting definitions for a single variable name.
	// +optional
	DefinitionsConflict bool `json:"definitionsConflict"`

	// definitions is a list of definitions for a variable.
	Definitions []ClusterClassStatusVariableDefinition `json:"definitions"`
}

ClusterClassStatusVariable defines a variable which appears in the status of a ClusterClass.

func (*ClusterClassStatusVariable) DeepCopy added in v1.4.0 

func (in *ClusterClassStatusVariable) DeepCopy() *ClusterClassStatusVariable

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterClassStatusVariable.

func (*ClusterClassStatusVariable) DeepCopyInto added in v1.4.0 

func (in *ClusterClassStatusVariable) DeepCopyInto(out *ClusterClassStatusVariable)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ClusterClassStatusVariableDefinition added in v1.4.0 

type ClusterClassStatusVariableDefinition struct {
	// from specifies the origin of the variable definition.
	// This will be `inline` for variables defined in the ClusterClass or the name of a patch defined in the ClusterClass
	// for variables discovered from a DiscoverVariables runtime extensions.
	From string `json:"from"`

	// required specifies if the variable is required.
	// Note: this applies to the variable as a whole and thus the
	// top-level object defined in the schema. If nested fields are
	// required, this will be specified inside the schema.
	Required bool `json:"required"`

	// metadata is the metadata of a variable.
	// It can be used to add additional data for higher level tools to
	// a ClusterClassVariable.
	//
	// Deprecated: This field is deprecated and is going to be removed in the next apiVersion.
	//
	// +optional
	Metadata ClusterClassVariableMetadata `json:"metadata,omitempty"`

	// schema defines the schema of the variable.
	Schema VariableSchema `json:"schema"`
}

ClusterClassStatusVariableDefinition defines a variable which appears in the status of a ClusterClass.

func (*ClusterClassStatusVariableDefinition) DeepCopy added in v1.4.0 

func (in *ClusterClassStatusVariableDefinition) DeepCopy() *ClusterClassStatusVariableDefinition

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterClassStatusVariableDefinition.

func (*ClusterClassStatusVariableDefinition) DeepCopyInto added in v1.4.0 

func (in *ClusterClassStatusVariableDefinition) DeepCopyInto(out *ClusterClassStatusVariableDefinition)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ClusterClassV1Beta2Status added in v1.9.0 

type ClusterClassV1Beta2Status struct {
	// conditions represents the observations of a ClusterClass's current state.
	// Known condition types are VariablesReady, RefVersionsUpToDate, Paused.
	// +optional
	// +listType=map
	// +listMapKey=type
	// +kubebuilder:validation:MaxItems=32
	Conditions []metav1.Condition `json:"conditions,omitempty"`
}

ClusterClassV1Beta2Status groups all the fields that will be added or modified in ClusterClass with the V1Beta2 version. See https://github.com/kubernetes-sigs/cluster-api/blob/main/docs/proposals/20240916-improve-status-in-CAPI-resources.md for more context.

func (*ClusterClassV1Beta2Status) DeepCopy added in v1.9.0 

func (in *ClusterClassV1Beta2Status) DeepCopy() *ClusterClassV1Beta2Status

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterClassV1Beta2Status.

func (*ClusterClassV1Beta2Status) DeepCopyInto added in v1.9.0 

func (in *ClusterClassV1Beta2Status) DeepCopyInto(out *ClusterClassV1Beta2Status)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ClusterClassVariable 

type ClusterClassVariable struct {
	// name of the variable.
	Name string `json:"name"`

	// required specifies if the variable is required.
	// Note: this applies to the variable as a whole and thus the
	// top-level object defined in the schema. If nested fields are
	// required, this will be specified inside the schema.
	Required bool `json:"required"`

	// metadata is the metadata of a variable.
	// It can be used to add additional data for higher level tools to
	// a ClusterClassVariable.
	//
	// Deprecated: This field is deprecated and is going to be removed in the next apiVersion. Please use XMetadata in JSONSchemaProps instead.
	//
	// +optional
	Metadata ClusterClassVariableMetadata `json:"metadata,omitempty"`

	// schema defines the schema of the variable.
	Schema VariableSchema `json:"schema"`
}

ClusterClassVariable defines a variable which can be configured in the Cluster topology and used in patches.

func (*ClusterClassVariable) DeepCopy 

func (in *ClusterClassVariable) DeepCopy() *ClusterClassVariable

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterClassVariable.

func (*ClusterClassVariable) DeepCopyInto 

func (in *ClusterClassVariable) DeepCopyInto(out *ClusterClassVariable)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ClusterClassVariableMetadata deprecated added in v1.6.4 

type ClusterClassVariableMetadata struct {
	// Map of string keys and values that can be used to organize and categorize
	// (scope and select) variables.
	// +optional
	Labels map[string]string `json:"labels,omitempty"`

	// annotations is an unstructured key value map that can be used to store and
	// retrieve arbitrary metadata.
	// They are not queryable.
	// +optional
	Annotations map[string]string `json:"annotations,omitempty"`
}

ClusterClassVariableMetadata is the metadata of a variable. It can be used to add additional data for higher level tools to a ClusterClassVariable.

Deprecated: This struct is deprecated and is going to be removed in the next apiVersion.

func (*ClusterClassVariableMetadata) DeepCopy added in v1.6.4 

func (in *ClusterClassVariableMetadata) DeepCopy() *ClusterClassVariableMetadata

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterClassVariableMetadata.

func (*ClusterClassVariableMetadata) DeepCopyInto added in v1.6.4 

func (in *ClusterClassVariableMetadata) DeepCopyInto(out *ClusterClassVariableMetadata)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ClusterControlPlaneStatus added in v1.9.0 

type ClusterControlPlaneStatus struct {
	// desiredReplicas is the total number of desired control plane machines in this cluster.
	// +optional
	DesiredReplicas *int32 `json:"desiredReplicas,omitempty"`

	// replicas is the total number of control plane machines in this cluster.
	// NOTE: replicas also includes machines still being provisioned or being deleted.
	// +optional
	Replicas *int32 `json:"replicas,omitempty"`

	// upToDateReplicas is the number of up-to-date control plane machines in this cluster. A machine is considered up-to-date when Machine's UpToDate condition is true.
	// +optional
	UpToDateReplicas *int32 `json:"upToDateReplicas,omitempty"`

	// readyReplicas is the total number of ready control plane machines in this cluster. A machine is considered ready when Machine's Ready condition is true.
	// +optional
	ReadyReplicas *int32 `json:"readyReplicas,omitempty"`

	// availableReplicas is the total number of available control plane machines in this cluster. A machine is considered available when Machine's Available condition is true.
	// +optional
	AvailableReplicas *int32 `json:"availableReplicas,omitempty"`
}

ClusterControlPlaneStatus groups all the observations about control plane current state.

func (*ClusterControlPlaneStatus) DeepCopy added in v1.9.0 

func (in *ClusterControlPlaneStatus) DeepCopy() *ClusterControlPlaneStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterControlPlaneStatus.

func (*ClusterControlPlaneStatus) DeepCopyInto added in v1.9.0 

func (in *ClusterControlPlaneStatus) DeepCopyInto(out *ClusterControlPlaneStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ClusterIPFamily 

type ClusterIPFamily int

ClusterIPFamily defines the types of supported IP families. 

const (
	InvalidIPFamily ClusterIPFamily = iota
	IPv4IPFamily
	IPv6IPFamily
	DualStackIPFamily
)

Define the ClusterIPFamily constants.

func (ClusterIPFamily) String 

func (f ClusterIPFamily) String() string

type ClusterList 

type ClusterList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []Cluster `json:"items"`
}

ClusterList contains a list of Cluster.

func (*ClusterList) DeepCopy 

func (in *ClusterList) DeepCopy() *ClusterList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterList.

func (*ClusterList) DeepCopyInto 

func (in *ClusterList) DeepCopyInto(out *ClusterList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ClusterList) DeepCopyObject 

func (in *ClusterList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*ClusterList) Hub 

func (*ClusterList) Hub()

type ClusterNetwork 

type ClusterNetwork struct {
	// apiServerPort specifies the port the API Server should bind to.
	// Defaults to 6443.
	// +optional
	APIServerPort *int32 `json:"apiServerPort,omitempty"`

	// The network ranges from which service VIPs are allocated.
	// +optional
	Services *NetworkRanges `json:"services,omitempty"`

	// The network ranges from which Pod networks are allocated.
	// +optional
	Pods *NetworkRanges `json:"pods,omitempty"`

	// Domain name for services.
	// +optional
	ServiceDomain string `json:"serviceDomain,omitempty"`
}

ClusterNetwork specifies the different networking parameters for a cluster.

func (*ClusterNetwork) DeepCopy 

func (in *ClusterNetwork) DeepCopy() *ClusterNetwork

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterNetwork.

func (*ClusterNetwork) DeepCopyInto 

func (in *ClusterNetwork) DeepCopyInto(out *ClusterNetwork)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ClusterPhase 

type ClusterPhase string

ClusterPhase is a string representation of a Cluster Phase.

This type is a high-level indicator of the status of the Cluster as it is provisioned, from the API user’s perspective.

The value should not be interpreted by any software components as a reliable indication of the actual state of the Cluster, and controllers should not use the Cluster Phase field value when making decisions about what action to take.

Controllers should always look at the actual state of the Cluster’s fields to make those decisions.

type ClusterSpec 

type ClusterSpec struct {
	// paused can be used to prevent controllers from processing the Cluster and all its associated objects.
	// +optional
	Paused bool `json:"paused,omitempty"`

	// Cluster network configuration.
	// +optional
	ClusterNetwork *ClusterNetwork `json:"clusterNetwork,omitempty"`

	// controlPlaneEndpoint represents the endpoint used to communicate with the control plane.
	// +optional
	ControlPlaneEndpoint APIEndpoint `json:"controlPlaneEndpoint,omitempty"`

	// controlPlaneRef is an optional reference to a provider-specific resource that holds
	// the details for provisioning the Control Plane for a Cluster.
	// +optional
	ControlPlaneRef *corev1.ObjectReference `json:"controlPlaneRef,omitempty"`

	// infrastructureRef is a reference to a provider-specific resource that holds the details
	// for provisioning infrastructure for a cluster in said provider.
	// +optional
	InfrastructureRef *corev1.ObjectReference `json:"infrastructureRef,omitempty"`

	// This encapsulates the topology for the cluster.
	// NOTE: It is required to enable the ClusterTopology
	// feature gate flag to activate managed topologies support;
	// this feature is highly experimental, and parts of it might still be not implemented.
	// +optional
	Topology *Topology `json:"topology,omitempty"`

	// availabilityGates specifies additional conditions to include when evaluating Cluster Available condition.
	//
	// NOTE: this field is considered only for computing v1beta2 conditions.
	// +optional
	// +listType=map
	// +listMapKey=conditionType
	// +kubebuilder:validation:MaxItems=32
	AvailabilityGates []ClusterAvailabilityGate `json:"availabilityGates,omitempty"`
}

ClusterSpec defines the desired state of Cluster.

func (*ClusterSpec) DeepCopy 

func (in *ClusterSpec) DeepCopy() *ClusterSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterSpec.

func (*ClusterSpec) DeepCopyInto 

func (in *ClusterSpec) DeepCopyInto(out *ClusterSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ClusterStatus 

type ClusterStatus struct {
	// failureDomains is a slice of failure domain objects synced from the infrastructure provider.
	// +optional
	FailureDomains FailureDomains `json:"failureDomains,omitempty"`

	// failureReason indicates that there is a fatal problem reconciling the
	// state, and will be set to a token value suitable for
	// programmatic interpretation.
	//
	// Deprecated: This field is deprecated and is going to be removed in the next apiVersion. Please see https://github.com/kubernetes-sigs/cluster-api/blob/main/docs/proposals/20240916-improve-status-in-CAPI-resources.md for more details.
	//
	// +optional
	FailureReason *capierrors.ClusterStatusError `json:"failureReason,omitempty"`

	// failureMessage indicates that there is a fatal problem reconciling the
	// state, and will be set to a descriptive error message.
	//
	// Deprecated: This field is deprecated and is going to be removed in the next apiVersion. Please see https://github.com/kubernetes-sigs/cluster-api/blob/main/docs/proposals/20240916-improve-status-in-CAPI-resources.md for more details.
	//
	// +optional
	FailureMessage *string `json:"failureMessage,omitempty"`

	// phase represents the current phase of cluster actuation.
	// E.g. Pending, Running, Terminating, Failed etc.
	// +optional
	Phase string `json:"phase,omitempty"`

	// infrastructureReady is the state of the infrastructure provider.
	// +optional
	InfrastructureReady bool `json:"infrastructureReady"`

	// controlPlaneReady denotes if the control plane became ready during initial provisioning
	// to receive requests.
	// NOTE: this field is part of the Cluster API contract and it is used to orchestrate provisioning.
	// The value of this field is never updated after provisioning is completed. Please use conditions
	// to check the operational state of the control plane.
	// +optional
	ControlPlaneReady bool `json:"controlPlaneReady"`

	// conditions defines current service state of the cluster.
	// +optional
	Conditions Conditions `json:"conditions,omitempty"`

	// observedGeneration is the latest generation observed by the controller.
	// +optional
	ObservedGeneration int64 `json:"observedGeneration,omitempty"`

	// v1beta2 groups all the fields that will be added or modified in Cluster's status with the V1Beta2 version.
	// +optional
	V1Beta2 *ClusterV1Beta2Status `json:"v1beta2,omitempty"`
}

ClusterStatus defines the observed state of Cluster.

func (*ClusterStatus) DeepCopy 

func (in *ClusterStatus) DeepCopy() *ClusterStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterStatus.

func (*ClusterStatus) DeepCopyInto 

func (in *ClusterStatus) DeepCopyInto(out *ClusterStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ClusterStatus) GetTypedPhase 

func (c *ClusterStatus) GetTypedPhase() ClusterPhase

GetTypedPhase attempts to parse the Phase field and return the typed ClusterPhase representation as described in `machine_phase_types.go`.

func (*ClusterStatus) SetTypedPhase 

func (c *ClusterStatus) SetTypedPhase(p ClusterPhase)

SetTypedPhase sets the Phase field to the string representation of ClusterPhase.

type ClusterV1Beta2Status added in v1.9.0 

type ClusterV1Beta2Status struct {
	// conditions represents the observations of a Cluster's current state.
	// Known condition types are Available, InfrastructureReady, ControlPlaneInitialized, ControlPlaneAvailable, WorkersAvailable, MachinesReady
	// MachinesUpToDate, RemoteConnectionProbe, ScalingUp, ScalingDown, Remediating, Deleting, Paused.
	// Additionally, a TopologyReconciled condition will be added in case the Cluster is referencing a ClusterClass / defining a managed Topology.
	// +optional
	// +listType=map
	// +listMapKey=type
	// +kubebuilder:validation:MaxItems=32
	Conditions []metav1.Condition `json:"conditions,omitempty"`

	// controlPlane groups all the observations about Cluster's ControlPlane current state.
	// +optional
	ControlPlane *ClusterControlPlaneStatus `json:"controlPlane,omitempty"`

	// workers groups all the observations about Cluster's Workers current state.
	// +optional
	Workers *WorkersStatus `json:"workers,omitempty"`
}

ClusterV1Beta2Status groups all the fields that will be added or modified in Cluster with the V1Beta2 version. See https://github.com/kubernetes-sigs/cluster-api/blob/main/docs/proposals/20240916-improve-status-in-CAPI-resources.md for more context.

func (*ClusterV1Beta2Status) DeepCopy added in v1.9.0 

func (in *ClusterV1Beta2Status) DeepCopy() *ClusterV1Beta2Status

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterV1Beta2Status.

func (*ClusterV1Beta2Status) DeepCopyInto added in v1.9.0 

func (in *ClusterV1Beta2Status) DeepCopyInto(out *ClusterV1Beta2Status)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ClusterVariable 

type ClusterVariable struct {
	// name of the variable.
	Name string `json:"name"`

	// definitionFrom specifies where the definition of this Variable is from.
	//
	// Deprecated: This field is deprecated, must not be set anymore and is going to be removed in the next apiVersion.
	//
	// +optional
	DefinitionFrom string `json:"definitionFrom,omitempty"`

	// value of the variable.
	// Note: the value will be validated against the schema of the corresponding ClusterClassVariable
	// from the ClusterClass.
	// Note: We have to use apiextensionsv1.JSON instead of a custom JSON type, because controller-tools has a
	// hard-coded schema for apiextensionsv1.JSON which cannot be produced by another type via controller-tools,
	// i.e. it is not possible to have no type field.
	// Ref: https://github.com/kubernetes-sigs/controller-tools/blob/d0e03a142d0ecdd5491593e941ee1d6b5d91dba6/pkg/crd/known_types.go#L106-L111
	Value apiextensionsv1.JSON `json:"value"`
}

ClusterVariable can be used to customize the Cluster through patches. Each ClusterVariable is associated with a Variable definition in the ClusterClass `status` variables.

func (*ClusterVariable) DeepCopy 

func (in *ClusterVariable) DeepCopy() *ClusterVariable

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterVariable.

func (*ClusterVariable) DeepCopyInto 

func (in *ClusterVariable) DeepCopyInto(out *ClusterVariable)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type Condition 

type Condition struct {
	// type of condition in CamelCase or in foo.example.com/CamelCase.
	// Many .condition.type values are consistent across resources like Available, but because arbitrary conditions
	// can be useful (see .node.status.conditions), the ability to deconflict is important.
	Type ConditionType `json:"type"`

	// status of the condition, one of True, False, Unknown.
	Status corev1.ConditionStatus `json:"status"`

	// severity provides an explicit classification of Reason code, so the users or machines can immediately
	// understand the current situation and act accordingly.
	// The Severity field MUST be set only when Status=False.
	// +optional
	Severity ConditionSeverity `json:"severity,omitempty"`

	// Last time the condition transitioned from one status to another.
	// This should be when the underlying condition changed. If that is not known, then using the time when
	// the API field changed is acceptable.
	LastTransitionTime metav1.Time `json:"lastTransitionTime"`

	// The reason for the condition's last transition in CamelCase.
	// The specific API may choose whether or not this field is considered a guaranteed API.
	// This field may be empty.
	// +optional
	Reason string `json:"reason,omitempty"`

	// A human readable message indicating details about the transition.
	// This field may be empty.
	// +optional
	Message string `json:"message,omitempty"`
}

Condition defines an observation of a Cluster API resource operational state.

func (*Condition) DeepCopy 

func (in *Condition) DeepCopy() *Condition

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Condition.

func (*Condition) DeepCopyInto 

func (in *Condition) DeepCopyInto(out *Condition)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ConditionSeverity 

type ConditionSeverity string

ConditionSeverity expresses the severity of a Condition Type failing. 

const (
	// ConditionSeverityError specifies that a condition with `Status=False` is an error.
	ConditionSeverityError ConditionSeverity = "Error"

	// ConditionSeverityWarning specifies that a condition with `Status=False` is a warning.
	ConditionSeverityWarning ConditionSeverity = "Warning"

	// ConditionSeverityInfo specifies that a condition with `Status=False` is informative.
	ConditionSeverityInfo ConditionSeverity = "Info"

	// ConditionSeverityNone should apply only to conditions with `Status=True`.
	ConditionSeverityNone ConditionSeverity = ""
)

type ConditionType 

type ConditionType string

ConditionType is a valid value for Condition.Type. 

const (
	// InfrastructureReadyCondition reports a summary of current status of the infrastructure object defined for this cluster/machine/machinepool.
	// This condition is mirrored from the Ready condition in the infrastructure ref object, and
	// the absence of this condition might signal problems in the reconcile external loops or the fact that
	// the infrastructure provider does not implement the Ready condition yet.
	InfrastructureReadyCondition ConditionType = "InfrastructureReady"

	// WaitingForInfrastructureFallbackReason (Severity=Info) documents a cluster/machine/machinepool waiting for the underlying infrastructure
	// to be available.
	// NOTE: This reason is used only as a fallback when the infrastructure object is not reporting its own ready condition.
	WaitingForInfrastructureFallbackReason = "WaitingForInfrastructure"
)
const (
	// ClusterClassVariablesReconciledCondition reports if the ClusterClass variables, including both inline and external
	// variables, have been successfully reconciled.
	// This signals that the ClusterClass is ready to be used to default and validate variables on Clusters using
	// this ClusterClass.
	ClusterClassVariablesReconciledCondition ConditionType = "VariablesReconciled"

	// VariableDiscoveryFailedReason (Severity=Error) documents a ClusterClass with VariableDiscovery extensions that
	// failed.
	VariableDiscoveryFailedReason = "VariableDiscoveryFailed"
)

Conditions and condition Reasons for the ClusterClass object. 

const (
	// RemediationAllowedCondition is set on MachineHealthChecks to show the status of whether the MachineHealthCheck is
	// allowed to remediate any Machines or whether it is blocked from remediating any further.
	RemediationAllowedCondition ConditionType = "RemediationAllowed"

	// TooManyUnhealthyReason is the reason used when too many Machines are unhealthy and the MachineHealthCheck is blocked
	// from making any further remediations.
	TooManyUnhealthyReason = "TooManyUnhealthy"
)
const (
	// ReadyCondition defines the Ready condition type that summarizes the operational state of a Cluster API object.
	ReadyCondition ConditionType = "Ready"
)

Common ConditionTypes used by Cluster API objects.

type Conditions 

type Conditions []Condition

Conditions provide observations of the operational state of a Cluster API resource.

func (Conditions) DeepCopy 

func (in Conditions) DeepCopy() Conditions

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Conditions.

func (Conditions) DeepCopyInto 

func (in Conditions) DeepCopyInto(out *Conditions)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ControlPlaneClass 

type ControlPlaneClass struct {
	// metadata is the metadata applied to the ControlPlane and the Machines of the ControlPlane
	// if the ControlPlaneTemplate referenced is machine based. If not, it is applied only to the
	// ControlPlane.
	// At runtime this metadata is merged with the corresponding metadata from the topology.
	//
	// This field is supported if and only if the control plane provider template
	// referenced is Machine based.
	// +optional
	Metadata ObjectMeta `json:"metadata,omitempty"`

	// LocalObjectTemplate contains the reference to the control plane provider.
	LocalObjectTemplate `json:",inline"`

	// machineInfrastructure defines the metadata and infrastructure information
	// for control plane machines.
	//
	// This field is supported if and only if the control plane provider template
	// referenced above is Machine based and supports setting replicas.
	//
	// +optional
	MachineInfrastructure *LocalObjectTemplate `json:"machineInfrastructure,omitempty"`

	// machineHealthCheck defines a MachineHealthCheck for this ControlPlaneClass.
	// This field is supported if and only if the ControlPlane provider template
	// referenced above is Machine based and supports setting replicas.
	// +optional
	MachineHealthCheck *MachineHealthCheckClass `json:"machineHealthCheck,omitempty"`

	// namingStrategy allows changing the naming pattern used when creating the control plane provider object.
	// +optional
	NamingStrategy *ControlPlaneClassNamingStrategy `json:"namingStrategy,omitempty"`

	// nodeDrainTimeout is the total amount of time that the controller will spend on draining a node.
	// The default value is 0, meaning that the node can be drained without any time limitations.
	// NOTE: NodeDrainTimeout is different from `kubectl drain --timeout`
	// NOTE: This value can be overridden while defining a Cluster.Topology.
	// +optional
	NodeDrainTimeout *metav1.Duration `json:"nodeDrainTimeout,omitempty"`

	// nodeVolumeDetachTimeout is the total amount of time that the controller will spend on waiting for all volumes
	// to be detached. The default value is 0, meaning that the volumes can be detached without any time limitations.
	// NOTE: This value can be overridden while defining a Cluster.Topology.
	// +optional
	NodeVolumeDetachTimeout *metav1.Duration `json:"nodeVolumeDetachTimeout,omitempty"`

	// nodeDeletionTimeout defines how long the controller will attempt to delete the Node that the Machine
	// hosts after the Machine is marked for deletion. A duration of 0 will retry deletion indefinitely.
	// Defaults to 10 seconds.
	// NOTE: This value can be overridden while defining a Cluster.Topology.
	// +optional
	NodeDeletionTimeout *metav1.Duration `json:"nodeDeletionTimeout,omitempty"`
}

ControlPlaneClass defines the class for the control plane.

func (*ControlPlaneClass) DeepCopy 

func (in *ControlPlaneClass) DeepCopy() *ControlPlaneClass

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ControlPlaneClass.

func (*ControlPlaneClass) DeepCopyInto 

func (in *ControlPlaneClass) DeepCopyInto(out *ControlPlaneClass)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ControlPlaneClassNamingStrategy added in v1.5.2 

type ControlPlaneClassNamingStrategy struct {
	// template defines the template to use for generating the name of the ControlPlane object.
	// If not defined, it will fallback to `{{ .cluster.name }}-{{ .random }}`.
	// If the templated string exceeds 63 characters, it will be trimmed to 58 characters and will
	// get concatenated with a random suffix of length 5.
	// The templating mechanism provides the following arguments:
	// * `.cluster.name`: The name of the cluster object.
	// * `.random`: A random alphanumeric string, without vowels, of length 5.
	// +optional
	Template *string `json:"template,omitempty"`
}

ControlPlaneClassNamingStrategy defines the naming strategy for control plane objects.

func (*ControlPlaneClassNamingStrategy) DeepCopy added in v1.5.2 

func (in *ControlPlaneClassNamingStrategy) DeepCopy() *ControlPlaneClassNamingStrategy

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ControlPlaneClassNamingStrategy.

func (*ControlPlaneClassNamingStrategy) DeepCopyInto added in v1.5.2 

func (in *ControlPlaneClassNamingStrategy) DeepCopyInto(out *ControlPlaneClassNamingStrategy)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ControlPlaneTopology 

type ControlPlaneTopology struct {
	// metadata is the metadata applied to the ControlPlane and the Machines of the ControlPlane
	// if the ControlPlaneTemplate referenced by the ClusterClass is machine based. If not, it
	// is applied only to the ControlPlane.
	// At runtime this metadata is merged with the corresponding metadata from the ClusterClass.
	// +optional
	Metadata ObjectMeta `json:"metadata,omitempty"`

	// replicas is the number of control plane nodes.
	// If the value is nil, the ControlPlane object is created without the number of Replicas
	// and it's assumed that the control plane controller does not implement support for this field.
	// When specified against a control plane provider that lacks support for this field, this value will be ignored.
	// +optional
	Replicas *int32 `json:"replicas,omitempty"`

	// machineHealthCheck allows to enable, disable and override
	// the MachineHealthCheck configuration in the ClusterClass for this control plane.
	// +optional
	MachineHealthCheck *MachineHealthCheckTopology `json:"machineHealthCheck,omitempty"`

	// nodeDrainTimeout is the total amount of time that the controller will spend on draining a node.
	// The default value is 0, meaning that the node can be drained without any time limitations.
	// NOTE: NodeDrainTimeout is different from `kubectl drain --timeout`
	// +optional
	NodeDrainTimeout *metav1.Duration `json:"nodeDrainTimeout,omitempty"`

	// nodeVolumeDetachTimeout is the total amount of time that the controller will spend on waiting for all volumes
	// to be detached. The default value is 0, meaning that the volumes can be detached without any time limitations.
	// +optional
	NodeVolumeDetachTimeout *metav1.Duration `json:"nodeVolumeDetachTimeout,omitempty"`

	// nodeDeletionTimeout defines how long the controller will attempt to delete the Node that the Machine
	// hosts after the Machine is marked for deletion. A duration of 0 will retry deletion indefinitely.
	// Defaults to 10 seconds.
	// +optional
	NodeDeletionTimeout *metav1.Duration `json:"nodeDeletionTimeout,omitempty"`

	// variables can be used to customize the ControlPlane through patches.
	// +optional
	Variables *ControlPlaneVariables `json:"variables,omitempty"`
}

ControlPlaneTopology specifies the parameters for the control plane nodes in the cluster.

func (*ControlPlaneTopology) DeepCopy 

func (in *ControlPlaneTopology) DeepCopy() *ControlPlaneTopology

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ControlPlaneTopology.

func (*ControlPlaneTopology) DeepCopyInto 

func (in *ControlPlaneTopology) DeepCopyInto(out *ControlPlaneTopology)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ControlPlaneVariables added in v1.7.3 

type ControlPlaneVariables struct {
	// overrides can be used to override Cluster level variables.
	// +optional
	// +listType=map
	// +listMapKey=name
	Overrides []ClusterVariable `json:"overrides,omitempty"`
}

ControlPlaneVariables can be used to provide variables for the ControlPlane.

func (*ControlPlaneVariables) DeepCopy added in v1.7.3 

func (in *ControlPlaneVariables) DeepCopy() *ControlPlaneVariables

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ControlPlaneVariables.

func (*ControlPlaneVariables) DeepCopyInto added in v1.7.3 

func (in *ControlPlaneVariables) DeepCopyInto(out *ControlPlaneVariables)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ExternalPatchDefinition added in v1.2.0 

type ExternalPatchDefinition struct {
	// generateExtension references an extension which is called to generate patches.
	// +optional
	GenerateExtension *string `json:"generateExtension,omitempty"`

	// validateExtension references an extension which is called to validate the topology.
	// +optional
	ValidateExtension *string `json:"validateExtension,omitempty"`

	// discoverVariablesExtension references an extension which is called to discover variables.
	// +optional
	DiscoverVariablesExtension *string `json:"discoverVariablesExtension,omitempty"`

	// settings defines key value pairs to be passed to the extensions.
	// Values defined here take precedence over the values defined in the
	// corresponding ExtensionConfig.
	// +optional
	Settings map[string]string `json:"settings,omitempty"`
}

ExternalPatchDefinition defines an external patch. Note: At least one of GenerateExtension or ValidateExtension must be set.

func (*ExternalPatchDefinition) DeepCopy added in v1.2.0 

func (in *ExternalPatchDefinition) DeepCopy() *ExternalPatchDefinition

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ExternalPatchDefinition.

func (*ExternalPatchDefinition) DeepCopyInto added in v1.2.0 

func (in *ExternalPatchDefinition) DeepCopyInto(out *ExternalPatchDefinition)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type FailureDomainSpec 

type FailureDomainSpec struct {
	// controlPlane determines if this failure domain is suitable for use by control plane machines.
	// +optional
	ControlPlane bool `json:"controlPlane,omitempty"`

	// attributes is a free form map of attributes an infrastructure provider might use or require.
	// +optional
	Attributes map[string]string `json:"attributes,omitempty"`
}

FailureDomainSpec is the Schema for Cluster API failure domains. It allows controllers to understand how many failure domains a cluster can optionally span across.

func (*FailureDomainSpec) DeepCopy 

func (in *FailureDomainSpec) DeepCopy() *FailureDomainSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new FailureDomainSpec.

func (*FailureDomainSpec) DeepCopyInto 

func (in *FailureDomainSpec) DeepCopyInto(out *FailureDomainSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type FailureDomains 

type FailureDomains map[string]FailureDomainSpec

FailureDomains is a slice of FailureDomains.

func (FailureDomains) DeepCopy 

func (in FailureDomains) DeepCopy() FailureDomains

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new FailureDomains.

func (FailureDomains) DeepCopyInto 

func (in FailureDomains) DeepCopyInto(out *FailureDomains)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (FailureDomains) FilterControlPlane 

func (in FailureDomains) FilterControlPlane() FailureDomains

FilterControlPlane returns a FailureDomain slice containing only the domains suitable to be used for control plane nodes.

func (FailureDomains) GetIDs 

func (in FailureDomains) GetIDs() []*string

GetIDs returns a slice containing the ids for failure domains.

type FieldValueErrorReason added in v1.8.0 

type FieldValueErrorReason string

FieldValueErrorReason is a machine-readable value providing more detail about why a field failed the validation. 

const (
	// FieldValueRequired is used to report required values that are not
	// provided (e.g. empty strings, null values, or empty arrays).
	FieldValueRequired FieldValueErrorReason = "FieldValueRequired"
	// FieldValueDuplicate is used to report collisions of values that must be
	// unique (e.g. unique IDs).
	FieldValueDuplicate FieldValueErrorReason = "FieldValueDuplicate"
	// FieldValueInvalid is used to report malformed values (e.g. failed regex
	// match, too long, out of bounds).
	FieldValueInvalid FieldValueErrorReason = "FieldValueInvalid"
	// FieldValueForbidden is used to report valid (as per formatting rules)
	// values which would be accepted under some conditions, but which are not
	// permitted by the current conditions (such as security policy).
	FieldValueForbidden FieldValueErrorReason = "FieldValueForbidden"
)

type JSONPatch 

type JSONPatch struct {
	// op defines the operation of the patch.
	// Note: Only `add`, `replace` and `remove` are supported.
	Op string `json:"op"`

	// path defines the path of the patch.
	// Note: Only the spec of a template can be patched, thus the path has to start with /spec/.
	// Note: For now the only allowed array modifications are `append` and `prepend`, i.e.:
	// * for op: `add`: only index 0 (prepend) and - (append) are allowed
	// * for op: `replace` or `remove`: no indexes are allowed
	Path string `json:"path"`

	// value defines the value of the patch.
	// Note: Either Value or ValueFrom is required for add and replace
	// operations. Only one of them is allowed to be set at the same time.
	// Note: We have to use apiextensionsv1.JSON instead of our JSON type,
	// because controller-tools has a hard-coded schema for apiextensionsv1.JSON
	// which cannot be produced by another type (unset type field).
	// Ref: https://github.com/kubernetes-sigs/controller-tools/blob/d0e03a142d0ecdd5491593e941ee1d6b5d91dba6/pkg/crd/known_types.go#L106-L111
	// +optional
	Value *apiextensionsv1.JSON `json:"value,omitempty"`

	// valueFrom defines the value of the patch.
	// Note: Either Value or ValueFrom is required for add and replace
	// operations. Only one of them is allowed to be set at the same time.
	// +optional
	ValueFrom *JSONPatchValue `json:"valueFrom,omitempty"`
}

JSONPatch defines a JSON patch.

func (*JSONPatch) DeepCopy 

func (in *JSONPatch) DeepCopy() *JSONPatch

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JSONPatch.

func (*JSONPatch) DeepCopyInto 

func (in *JSONPatch) DeepCopyInto(out *JSONPatch)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type JSONPatchValue 

type JSONPatchValue struct {
	// variable is the variable to be used as value.
	// Variable can be one of the variables defined in .spec.variables or a builtin variable.
	// +optional
	Variable *string `json:"variable,omitempty"`

	// template is the Go template to be used to calculate the value.
	// A template can reference variables defined in .spec.variables and builtin variables.
	// Note: The template must evaluate to a valid YAML or JSON value.
	// +optional
	Template *string `json:"template,omitempty"`
}

JSONPatchValue defines the value of a patch. Note: Only one of the fields is allowed to be set at the same time.

func (*JSONPatchValue) DeepCopy 

func (in *JSONPatchValue) DeepCopy() *JSONPatchValue

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JSONPatchValue.

func (*JSONPatchValue) DeepCopyInto 

func (in *JSONPatchValue) DeepCopyInto(out *JSONPatchValue)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type JSONSchemaProps 

type JSONSchemaProps struct {
	// description is a human-readable description of this variable.
	Description string `json:"description,omitempty"`

	// example is an example for this variable.
	Example *apiextensionsv1.JSON `json:"example,omitempty"`

	// type is the type of the variable.
	// Valid values are: object, array, string, integer, number or boolean.
	// +optional
	Type string `json:"type,omitempty"`

	// properties specifies fields of an object.
	// NOTE: Can only be set if type is object.
	// NOTE: Properties is mutually exclusive with AdditionalProperties.
	// NOTE: This field uses PreserveUnknownFields and Schemaless,
	// because recursive validation is not possible.
	// +optional
	// +kubebuilder:pruning:PreserveUnknownFields
	// +kubebuilder:validation:Schemaless
	Properties map[string]JSONSchemaProps `json:"properties,omitempty"`

	// additionalProperties specifies the schema of values in a map (keys are always strings).
	// NOTE: Can only be set if type is object.
	// NOTE: AdditionalProperties is mutually exclusive with Properties.
	// NOTE: This field uses PreserveUnknownFields and Schemaless,
	// because recursive validation is not possible.
	// +optional
	// +kubebuilder:pruning:PreserveUnknownFields
	// +kubebuilder:validation:Schemaless
	AdditionalProperties *JSONSchemaProps `json:"additionalProperties,omitempty"`

	// maxProperties is the maximum amount of entries in a map or properties in an object.
	// NOTE: Can only be set if type is object.
	// +optional
	MaxProperties *int64 `json:"maxProperties,omitempty"`

	// minProperties is the minimum amount of entries in a map or properties in an object.
	// NOTE: Can only be set if type is object.
	// +optional
	MinProperties *int64 `json:"minProperties,omitempty"`

	// required specifies which fields of an object are required.
	// NOTE: Can only be set if type is object.
	// +optional
	Required []string `json:"required,omitempty"`

	// items specifies fields of an array.
	// NOTE: Can only be set if type is array.
	// NOTE: This field uses PreserveUnknownFields and Schemaless,
	// because recursive validation is not possible.
	// +optional
	// +kubebuilder:pruning:PreserveUnknownFields
	// +kubebuilder:validation:Schemaless
	Items *JSONSchemaProps `json:"items,omitempty"`

	// maxItems is the max length of an array variable.
	// NOTE: Can only be set if type is array.
	// +optional
	MaxItems *int64 `json:"maxItems,omitempty"`

	// minItems is the min length of an array variable.
	// NOTE: Can only be set if type is array.
	// +optional
	MinItems *int64 `json:"minItems,omitempty"`

	// uniqueItems specifies if items in an array must be unique.
	// NOTE: Can only be set if type is array.
	// +optional
	UniqueItems bool `json:"uniqueItems,omitempty"`

	// format is an OpenAPI v3 format string. Unknown formats are ignored.
	// For a list of supported formats please see: (of the k8s.io/apiextensions-apiserver version we're currently using)
	// https://github.com/kubernetes/apiextensions-apiserver/blob/master/pkg/apiserver/validation/formats.go
	// NOTE: Can only be set if type is string.
	// +optional
	Format string `json:"format,omitempty"`

	// maxLength is the max length of a string variable.
	// NOTE: Can only be set if type is string.
	// +optional
	MaxLength *int64 `json:"maxLength,omitempty"`

	// minLength is the min length of a string variable.
	// NOTE: Can only be set if type is string.
	// +optional
	MinLength *int64 `json:"minLength,omitempty"`

	// pattern is the regex which a string variable must match.
	// NOTE: Can only be set if type is string.
	// +optional
	Pattern string `json:"pattern,omitempty"`

	// maximum is the maximum of an integer or number variable.
	// If ExclusiveMaximum is false, the variable is valid if it is lower than, or equal to, the value of Maximum.
	// If ExclusiveMaximum is true, the variable is valid if it is strictly lower than the value of Maximum.
	// NOTE: Can only be set if type is integer or number.
	// +optional
	Maximum *int64 `json:"maximum,omitempty"`

	// exclusiveMaximum specifies if the Maximum is exclusive.
	// NOTE: Can only be set if type is integer or number.
	// +optional
	ExclusiveMaximum bool `json:"exclusiveMaximum,omitempty"`

	// minimum is the minimum of an integer or number variable.
	// If ExclusiveMinimum is false, the variable is valid if it is greater than, or equal to, the value of Minimum.
	// If ExclusiveMinimum is true, the variable is valid if it is strictly greater than the value of Minimum.
	// NOTE: Can only be set if type is integer or number.
	// +optional
	Minimum *int64 `json:"minimum,omitempty"`

	// exclusiveMinimum specifies if the Minimum is exclusive.
	// NOTE: Can only be set if type is integer or number.
	// +optional
	ExclusiveMinimum bool `json:"exclusiveMinimum,omitempty"`

	// x-kubernetes-preserve-unknown-fields allows setting fields in a variable object
	// which are not defined in the variable schema. This affects fields recursively,
	// except if nested properties or additionalProperties are specified in the schema.
	// +optional
	XPreserveUnknownFields bool `json:"x-kubernetes-preserve-unknown-fields,omitempty"`

	// enum is the list of valid values of the variable.
	// NOTE: Can be set for all types.
	// +optional
	Enum []apiextensionsv1.JSON `json:"enum,omitempty"`

	// default is the default value of the variable.
	// NOTE: Can be set for all types.
	// +optional
	Default *apiextensionsv1.JSON `json:"default,omitempty"`

	// x-kubernetes-validations describes a list of validation rules written in the CEL expression language.
	// +optional
	// +listType=map
	// +listMapKey=rule
	XValidations []ValidationRule `json:"x-kubernetes-validations,omitempty"`

	// x-metadata is the metadata of a variable or a nested field within a variable.
	// It can be used to add additional data for higher level tools.
	// +optional
	XMetadata *VariableSchemaMetadata `json:"x-metadata,omitempty"`

	// x-kubernetes-int-or-string specifies that this value is
	// either an integer or a string. If this is true, an empty
	// type is allowed and type as child of anyOf is permitted
	// if following one of the following patterns:
	//
	// 1) anyOf:
	//    - type: integer
	//    - type: string
	// 2) allOf:
	//    - anyOf:
	//      - type: integer
	//      - type: string
	//    - ... zero or more
	// +optional
	XIntOrString bool `json:"x-kubernetes-int-or-string,omitempty"`

	// allOf specifies that the variable must validate against all of the subschemas in the array.
	// NOTE: This field uses PreserveUnknownFields and Schemaless,
	// because recursive validation is not possible.
	// +optional
	// +kubebuilder:pruning:PreserveUnknownFields
	// +kubebuilder:validation:Schemaless
	AllOf []JSONSchemaProps `json:"allOf,omitempty"`

	// oneOf specifies that the variable must validate against exactly one of the subschemas in the array.
	// NOTE: This field uses PreserveUnknownFields and Schemaless,
	// because recursive validation is not possible.
	// +optional
	// +kubebuilder:pruning:PreserveUnknownFields
	// +kubebuilder:validation:Schemaless
	OneOf []JSONSchemaProps `json:"oneOf,omitempty"`

	// anyOf specifies that the variable must validate against one or more of the subschemas in the array.
	// NOTE: This field uses PreserveUnknownFields and Schemaless,
	// because recursive validation is not possible.
	// +optional
	// +kubebuilder:pruning:PreserveUnknownFields
	// +kubebuilder:validation:Schemaless
	AnyOf []JSONSchemaProps `json:"anyOf,omitempty"`

	// not specifies that the variable must not validate against the subschema.
	// NOTE: This field uses PreserveUnknownFields and Schemaless,
	// because recursive validation is not possible.
	// +optional
	// +kubebuilder:pruning:PreserveUnknownFields
	// +kubebuilder:validation:Schemaless
	Not *JSONSchemaProps `json:"not,omitempty"`
}

JSONSchemaProps is a JSON-Schema following Specification Draft 4 (http://json-schema.org/). This struct has been initially copied from apiextensionsv1.JSONSchemaProps, but all fields which are not supported in CAPI have been removed.

func (*JSONSchemaProps) DeepCopy 

func (in *JSONSchemaProps) DeepCopy() *JSONSchemaProps

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JSONSchemaProps.

func (*JSONSchemaProps) DeepCopyInto 

func (in *JSONSchemaProps) DeepCopyInto(out *JSONSchemaProps)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type LocalObjectTemplate 

type LocalObjectTemplate struct {
	// ref is a required reference to a custom resource
	// offered by a provider.
	Ref *corev1.ObjectReference `json:"ref"`
}

LocalObjectTemplate defines a template for a topology Class.

func (*LocalObjectTemplate) DeepCopy 

func (in *LocalObjectTemplate) DeepCopy() *LocalObjectTemplate

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LocalObjectTemplate.

func (*LocalObjectTemplate) DeepCopyInto 

func (in *LocalObjectTemplate) DeepCopyInto(out *LocalObjectTemplate)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type Machine 

type Machine struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   MachineSpec   `json:"spec,omitempty"`
	Status MachineStatus `json:"status,omitempty"`
}

Machine is the Schema for the machines API.

func (*Machine) DeepCopy 

func (in *Machine) DeepCopy() *Machine

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Machine.

func (*Machine) DeepCopyInto 

func (in *Machine) DeepCopyInto(out *Machine)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*Machine) DeepCopyObject 

func (in *Machine) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*Machine) GetConditions 

func (m *Machine) GetConditions() Conditions

GetConditions returns the set of conditions for this object.

func (*Machine) GetV1Beta2Conditions added in v1.9.0 

func (m *Machine) GetV1Beta2Conditions() []metav1.Condition

GetV1Beta2Conditions returns the set of conditions for this object.

func (*Machine) Hub 

func (*Machine) Hub()

func (*Machine) SetConditions 

func (m *Machine) SetConditions(conditions Conditions)

SetConditions sets the conditions on this object.

func (*Machine) SetV1Beta2Conditions added in v1.9.0 

func (m *Machine) SetV1Beta2Conditions(conditions []metav1.Condition)

SetV1Beta2Conditions sets conditions for an API object.

type MachineAddress 

type MachineAddress struct {
	// Machine address type, one of Hostname, ExternalIP, InternalIP, ExternalDNS or InternalDNS.
	Type MachineAddressType `json:"type"`

	// The machine address.
	Address string `json:"address"`
}

MachineAddress contains information for the node's address.

func (*MachineAddress) DeepCopy 

func (in *MachineAddress) DeepCopy() *MachineAddress

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachineAddress.

func (*MachineAddress) DeepCopyInto 

func (in *MachineAddress) DeepCopyInto(out *MachineAddress)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MachineAddressType 

type MachineAddressType string

MachineAddressType describes a valid MachineAddress type. 

const (
	MachineHostName    MachineAddressType = "Hostname"
	MachineExternalIP  MachineAddressType = "ExternalIP"
	MachineInternalIP  MachineAddressType = "InternalIP"
	MachineExternalDNS MachineAddressType = "ExternalDNS"
	MachineInternalDNS MachineAddressType = "InternalDNS"
)

Define the MachineAddressType constants.

type MachineAddresses 

type MachineAddresses []MachineAddress

MachineAddresses is a slice of MachineAddress items to be used by infrastructure providers.

func (MachineAddresses) DeepCopy 

func (in MachineAddresses) DeepCopy() MachineAddresses

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachineAddresses.

func (MachineAddresses) DeepCopyInto 

func (in MachineAddresses) DeepCopyInto(out *MachineAddresses)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MachineDeletionStatus added in v1.9.0 

type MachineDeletionStatus struct {
	// nodeDrainStartTime is the time when the drain of the node started and is used to determine
	// if the NodeDrainTimeout is exceeded.
	// Only present when the Machine has a deletionTimestamp and draining the node had been started.
	// +optional
	NodeDrainStartTime *metav1.Time `json:"nodeDrainStartTime,omitempty"`

	// waitForNodeVolumeDetachStartTime is the time when waiting for volume detachment started
	// and is used to determine if the NodeVolumeDetachTimeout is exceeded.
	// Detaching volumes from nodes is usually done by CSI implementations and the current state
	// is observed from the node's `.Status.VolumesAttached` field.
	// Only present when the Machine has a deletionTimestamp and waiting for volume detachments had been started.
	// +optional
	WaitForNodeVolumeDetachStartTime *metav1.Time `json:"waitForNodeVolumeDetachStartTime,omitempty"`
}

MachineDeletionStatus is the deletion state of the Machine.

func (*MachineDeletionStatus) DeepCopy added in v1.9.0 

func (in *MachineDeletionStatus) DeepCopy() *MachineDeletionStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachineDeletionStatus.

func (*MachineDeletionStatus) DeepCopyInto added in v1.9.0 

func (in *MachineDeletionStatus) DeepCopyInto(out *MachineDeletionStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MachineDeployment 

type MachineDeployment struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   MachineDeploymentSpec   `json:"spec,omitempty"`
	Status MachineDeploymentStatus `json:"status,omitempty"`
}

MachineDeployment is the Schema for the machinedeployments API.

func (*MachineDeployment) DeepCopy 

func (in *MachineDeployment) DeepCopy() *MachineDeployment

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachineDeployment.

func (*MachineDeployment) DeepCopyInto 

func (in *MachineDeployment) DeepCopyInto(out *MachineDeployment)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*MachineDeployment) DeepCopyObject 

func (in *MachineDeployment) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*MachineDeployment) GetConditions 

func (m *MachineDeployment) GetConditions() Conditions

GetConditions returns the set of conditions for the machinedeployment.

func (*MachineDeployment) GetV1Beta2Conditions added in v1.9.0 

func (m *MachineDeployment) GetV1Beta2Conditions() []metav1.Condition

GetV1Beta2Conditions returns the set of conditions for this object.

func (*MachineDeployment) Hub 

func (*MachineDeployment) Hub()

func (*MachineDeployment) SetConditions 

func (m *MachineDeployment) SetConditions(conditions Conditions)

SetConditions updates the set of conditions on the machinedeployment.

func (*MachineDeployment) SetV1Beta2Conditions added in v1.9.0 

func (m *MachineDeployment) SetV1Beta2Conditions(conditions []metav1.Condition)

SetV1Beta2Conditions sets conditions for an API object.

type MachineDeploymentClass 

type MachineDeploymentClass struct {
	// class denotes a type of worker node present in the cluster,
	// this name MUST be unique within a ClusterClass and can be referenced
	// in the Cluster to create a managed MachineDeployment.
	Class string `json:"class"`

	// template is a local struct containing a collection of templates for creation of
	// MachineDeployment objects representing a set of worker nodes.
	Template MachineDeploymentClassTemplate `json:"template"`

	// machineHealthCheck defines a MachineHealthCheck for this MachineDeploymentClass.
	// +optional
	MachineHealthCheck *MachineHealthCheckClass `json:"machineHealthCheck,omitempty"`

	// failureDomain is the failure domain the machines will be created in.
	// Must match a key in the FailureDomains map stored on the cluster object.
	// NOTE: This value can be overridden while defining a Cluster.Topology using this MachineDeploymentClass.
	// +optional
	FailureDomain *string `json:"failureDomain,omitempty"`

	// namingStrategy allows changing the naming pattern used when creating the MachineDeployment.
	// +optional
	NamingStrategy *MachineDeploymentClassNamingStrategy `json:"namingStrategy,omitempty"`

	// nodeDrainTimeout is the total amount of time that the controller will spend on draining a node.
	// The default value is 0, meaning that the node can be drained without any time limitations.
	// NOTE: NodeDrainTimeout is different from `kubectl drain --timeout`
	// NOTE: This value can be overridden while defining a Cluster.Topology using this MachineDeploymentClass.
	// +optional
	NodeDrainTimeout *metav1.Duration `json:"nodeDrainTimeout,omitempty"`

	// nodeVolumeDetachTimeout is the total amount of time that the controller will spend on waiting for all volumes
	// to be detached. The default value is 0, meaning that the volumes can be detached without any time limitations.
	// NOTE: This value can be overridden while defining a Cluster.Topology using this MachineDeploymentClass.
	// +optional
	NodeVolumeDetachTimeout *metav1.Duration `json:"nodeVolumeDetachTimeout,omitempty"`

	// nodeDeletionTimeout defines how long the controller will attempt to delete the Node that the Machine
	// hosts after the Machine is marked for deletion. A duration of 0 will retry deletion indefinitely.
	// Defaults to 10 seconds.
	// NOTE: This value can be overridden while defining a Cluster.Topology using this MachineDeploymentClass.
	// +optional
	NodeDeletionTimeout *metav1.Duration `json:"nodeDeletionTimeout,omitempty"`

	// Minimum number of seconds for which a newly created machine should
	// be ready.
	// Defaults to 0 (machine will be considered available as soon as it
	// is ready)
	// NOTE: This value can be overridden while defining a Cluster.Topology using this MachineDeploymentClass.
	MinReadySeconds *int32 `json:"minReadySeconds,omitempty"`

	// The deployment strategy to use to replace existing machines with
	// new ones.
	// NOTE: This value can be overridden while defining a Cluster.Topology using this MachineDeploymentClass.
	Strategy *MachineDeploymentStrategy `json:"strategy,omitempty"`
}

MachineDeploymentClass serves as a template to define a set of worker nodes of the cluster provisioned using the `ClusterClass`.

func (*MachineDeploymentClass) DeepCopy 

func (in *MachineDeploymentClass) DeepCopy() *MachineDeploymentClass

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachineDeploymentClass.

func (*MachineDeploymentClass) DeepCopyInto 

func (in *MachineDeploymentClass) DeepCopyInto(out *MachineDeploymentClass)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MachineDeploymentClassNamingStrategy added in v1.5.2 

type MachineDeploymentClassNamingStrategy struct {
	// template defines the template to use for generating the name of the MachineDeployment object.
	// If not defined, it will fallback to `{{ .cluster.name }}-{{ .machineDeployment.topologyName }}-{{ .random }}`.
	// If the templated string exceeds 63 characters, it will be trimmed to 58 characters and will
	// get concatenated with a random suffix of length 5.
	// The templating mechanism provides the following arguments:
	// * `.cluster.name`: The name of the cluster object.
	// * `.random`: A random alphanumeric string, without vowels, of length 5.
	// * `.machineDeployment.topologyName`: The name of the MachineDeployment topology (Cluster.spec.topology.workers.machineDeployments[].name).
	// +optional
	Template *string `json:"template,omitempty"`
}

MachineDeploymentClassNamingStrategy defines the naming strategy for machine deployment objects.

func (*MachineDeploymentClassNamingStrategy) DeepCopy added in v1.5.2 

func (in *MachineDeploymentClassNamingStrategy) DeepCopy() *MachineDeploymentClassNamingStrategy

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachineDeploymentClassNamingStrategy.

func (*MachineDeploymentClassNamingStrategy) DeepCopyInto added in v1.5.2 

func (in *MachineDeploymentClassNamingStrategy) DeepCopyInto(out *MachineDeploymentClassNamingStrategy)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MachineDeploymentClassTemplate 

type MachineDeploymentClassTemplate struct {
	// metadata is the metadata applied to the MachineDeployment and the machines of the MachineDeployment.
	// At runtime this metadata is merged with the corresponding metadata from the topology.
	// +optional
	Metadata ObjectMeta `json:"metadata,omitempty"`

	// bootstrap contains the bootstrap template reference to be used
	// for the creation of worker Machines.
	Bootstrap LocalObjectTemplate `json:"bootstrap"`

	// infrastructure contains the infrastructure template reference to be used
	// for the creation of worker Machines.
	Infrastructure LocalObjectTemplate `json:"infrastructure"`
}

MachineDeploymentClassTemplate defines how a MachineDeployment generated from a MachineDeploymentClass should look like.

func (*MachineDeploymentClassTemplate) DeepCopy 

func (in *MachineDeploymentClassTemplate) DeepCopy() *MachineDeploymentClassTemplate

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachineDeploymentClassTemplate.

func (*MachineDeploymentClassTemplate) DeepCopyInto 

func (in *MachineDeploymentClassTemplate) DeepCopyInto(out *MachineDeploymentClassTemplate)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MachineDeploymentList 

type MachineDeploymentList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []MachineDeployment `json:"items"`
}

MachineDeploymentList contains a list of MachineDeployment.

func (*MachineDeploymentList) DeepCopy 

func (in *MachineDeploymentList) DeepCopy() *MachineDeploymentList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachineDeploymentList.

func (*MachineDeploymentList) DeepCopyInto 

func (in *MachineDeploymentList) DeepCopyInto(out *MachineDeploymentList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*MachineDeploymentList) DeepCopyObject 

func (in *MachineDeploymentList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*MachineDeploymentList) Hub 

func (*MachineDeploymentList) Hub()

type MachineDeploymentPhase 

type MachineDeploymentPhase string

MachineDeploymentPhase indicates the progress of the machine deployment.

type MachineDeploymentSpec 

type MachineDeploymentSpec struct {
	// clusterName is the name of the Cluster this object belongs to.
	// +kubebuilder:validation:MinLength=1
	ClusterName string `json:"clusterName"`

	// Number of desired machines.
	// This is a pointer to distinguish between explicit zero and not specified.
	//
	// Defaults to:
	// * if the Kubernetes autoscaler min size and max size annotations are set:
	//   - if it's a new MachineDeployment, use min size
	//   - if the replicas field of the old MachineDeployment is < min size, use min size
	//   - if the replicas field of the old MachineDeployment is > max size, use max size
	//   - if the replicas field of the old MachineDeployment is in the (min size, max size) range, keep the value from the oldMD
	// * otherwise use 1
	// Note: Defaulting will be run whenever the replicas field is not set:
	// * A new MachineDeployment is created with replicas not set.
	// * On an existing MachineDeployment the replicas field was first set and is now unset.
	// Those cases are especially relevant for the following Kubernetes autoscaler use cases:
	// * A new MachineDeployment is created and replicas should be managed by the autoscaler
	// * An existing MachineDeployment which initially wasn't controlled by the autoscaler
	//   should be later controlled by the autoscaler
	// +optional
	Replicas *int32 `json:"replicas,omitempty"`

	// rolloutAfter is a field to indicate a rollout should be performed
	// after the specified time even if no changes have been made to the
	// MachineDeployment.
	// Example: In the YAML the time can be specified in the RFC3339 format.
	// To specify the rolloutAfter target as March 9, 2023, at 9 am UTC
	// use "2023-03-09T09:00:00Z".
	// +optional
	RolloutAfter *metav1.Time `json:"rolloutAfter,omitempty"`

	// Label selector for machines. Existing MachineSets whose machines are
	// selected by this will be the ones affected by this deployment.
	// It must match the machine template's labels.
	Selector metav1.LabelSelector `json:"selector"`

	// template describes the machines that will be created.
	Template MachineTemplateSpec `json:"template"`

	// The deployment strategy to use to replace existing machines with
	// new ones.
	// +optional
	Strategy *MachineDeploymentStrategy `json:"strategy,omitempty"`

	// minReadySeconds is the minimum number of seconds for which a Node for a newly created machine should be ready before considering the replica available.
	// Defaults to 0 (machine will be considered available as soon as the Node is ready)
	// +optional
	MinReadySeconds *int32 `json:"minReadySeconds,omitempty"`

	// The number of old MachineSets to retain to allow rollback.
	// This is a pointer to distinguish between explicit zero and not specified.
	// Defaults to 1.
	//
	// Deprecated: This field is deprecated and is going to be removed in the next apiVersion. Please see https://github.com/kubernetes-sigs/cluster-api/issues/10479 for more details.
	//
	// +optional
	RevisionHistoryLimit *int32 `json:"revisionHistoryLimit,omitempty"`

	// Indicates that the deployment is paused.
	// +optional
	Paused bool `json:"paused,omitempty"`

	// The maximum time in seconds for a deployment to make progress before it
	// is considered to be failed. The deployment controller will continue to
	// process failed deployments and a condition with a ProgressDeadlineExceeded
	// reason will be surfaced in the deployment status. Note that progress will
	// not be estimated during the time a deployment is paused. Defaults to 600s.
	//
	// Deprecated: This field is deprecated and is going to be removed in the next apiVersion. Please see https://github.com/kubernetes-sigs/cluster-api/issues/11470 for more details.
	//
	// +optional
	ProgressDeadlineSeconds *int32 `json:"progressDeadlineSeconds,omitempty"`
}

MachineDeploymentSpec defines the desired state of MachineDeployment.

func (*MachineDeploymentSpec) DeepCopy 

func (in *MachineDeploymentSpec) DeepCopy() *MachineDeploymentSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachineDeploymentSpec.

func (*MachineDeploymentSpec) DeepCopyInto 

func (in *MachineDeploymentSpec) DeepCopyInto(out *MachineDeploymentSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MachineDeploymentStatus 

type MachineDeploymentStatus struct {
	// The generation observed by the deployment controller.
	// +optional
	ObservedGeneration int64 `json:"observedGeneration,omitempty"`

	// selector is the same as the label selector but in the string format to avoid introspection
	// by clients. The string will be in the same format as the query-param syntax.
	// More info about label selectors: http://kubernetes.io/docs/user-guide/labels#label-selectors
	// +optional
	Selector string `json:"selector,omitempty"`

	// Total number of non-terminated machines targeted by this deployment
	// (their labels match the selector).
	// +optional
	Replicas int32 `json:"replicas"`

	// Total number of non-terminated machines targeted by this deployment
	// that have the desired template spec.
	// +optional
	UpdatedReplicas int32 `json:"updatedReplicas"`

	// Total number of ready machines targeted by this deployment.
	// +optional
	ReadyReplicas int32 `json:"readyReplicas"`

	// Total number of available machines (ready for at least minReadySeconds)
	// targeted by this deployment.
	// +optional
	AvailableReplicas int32 `json:"availableReplicas"`

	// Total number of unavailable machines targeted by this deployment.
	// This is the total number of machines that are still required for
	// the deployment to have 100% available capacity. They may either
	// be machines that are running but not yet available or machines
	// that still have not been created.
	//
	// Deprecated: This field is deprecated and is going to be removed in the next apiVersion. Please see https://github.com/kubernetes-sigs/cluster-api/blob/main/docs/proposals/20240916-improve-status-in-CAPI-resources.md for more details.
	//
	// +optional
	UnavailableReplicas int32 `json:"unavailableReplicas"`

	// phase represents the current phase of a MachineDeployment (ScalingUp, ScalingDown, Running, Failed, or Unknown).
	// +optional
	Phase string `json:"phase,omitempty"`

	// conditions defines current service state of the MachineDeployment.
	// +optional
	Conditions Conditions `json:"conditions,omitempty"`

	// v1beta2 groups all the fields that will be added or modified in MachineDeployment's status with the V1Beta2 version.
	// +optional
	V1Beta2 *MachineDeploymentV1Beta2Status `json:"v1beta2,omitempty"`
}

MachineDeploymentStatus defines the observed state of MachineDeployment.

func (*MachineDeploymentStatus) DeepCopy 

func (in *MachineDeploymentStatus) DeepCopy() *MachineDeploymentStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachineDeploymentStatus.

func (*MachineDeploymentStatus) DeepCopyInto 

func (in *MachineDeploymentStatus) DeepCopyInto(out *MachineDeploymentStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*MachineDeploymentStatus) GetTypedPhase 

func (md *MachineDeploymentStatus) GetTypedPhase() MachineDeploymentPhase

GetTypedPhase attempts to parse the Phase field and return the typed MachineDeploymentPhase representation.

func (*MachineDeploymentStatus) SetTypedPhase 

func (md *MachineDeploymentStatus) SetTypedPhase(p MachineDeploymentPhase)

SetTypedPhase sets the Phase field to the string representation of MachineDeploymentPhase.

type MachineDeploymentStrategy 

type MachineDeploymentStrategy struct {
	// type of deployment. Allowed values are RollingUpdate and OnDelete.
	// The default is RollingUpdate.
	// +kubebuilder:validation:Enum=RollingUpdate;OnDelete
	// +optional
	Type MachineDeploymentStrategyType `json:"type,omitempty"`

	// Rolling update config params. Present only if
	// MachineDeploymentStrategyType = RollingUpdate.
	// +optional
	RollingUpdate *MachineRollingUpdateDeployment `json:"rollingUpdate,omitempty"`

	// remediation controls the strategy of remediating unhealthy machines
	// and how remediating operations should occur during the lifecycle of the dependant MachineSets.
	// +optional
	Remediation *RemediationStrategy `json:"remediation,omitempty"`
}

MachineDeploymentStrategy describes how to replace existing machines with new ones.

func (*MachineDeploymentStrategy) DeepCopy 

func (in *MachineDeploymentStrategy) DeepCopy() *MachineDeploymentStrategy

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachineDeploymentStrategy.

func (*MachineDeploymentStrategy) DeepCopyInto 

func (in *MachineDeploymentStrategy) DeepCopyInto(out *MachineDeploymentStrategy)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MachineDeploymentStrategyType 

type MachineDeploymentStrategyType string

MachineDeploymentStrategyType defines the type of MachineDeployment rollout strategies.

type MachineDeploymentTopology 

type MachineDeploymentTopology struct {
	// metadata is the metadata applied to the MachineDeployment and the machines of the MachineDeployment.
	// At runtime this metadata is merged with the corresponding metadata from the ClusterClass.
	// +optional
	Metadata ObjectMeta `json:"metadata,omitempty"`

	// class is the name of the MachineDeploymentClass used to create the set of worker nodes.
	// This should match one of the deployment classes defined in the ClusterClass object
	// mentioned in the `Cluster.Spec.Class` field.
	Class string `json:"class"`

	// name is the unique identifier for this MachineDeploymentTopology.
	// The value is used with other unique identifiers to create a MachineDeployment's Name
	// (e.g. cluster's name, etc). In case the name is greater than the allowed maximum length,
	// the values are hashed together.
	Name string `json:"name"`

	// failureDomain is the failure domain the machines will be created in.
	// Must match a key in the FailureDomains map stored on the cluster object.
	// +optional
	FailureDomain *string `json:"failureDomain,omitempty"`

	// replicas is the number of worker nodes belonging to this set.
	// If the value is nil, the MachineDeployment is created without the number of Replicas (defaulting to 1)
	// and it's assumed that an external entity (like cluster autoscaler) is responsible for the management
	// of this value.
	// +optional
	Replicas *int32 `json:"replicas,omitempty"`

	// machineHealthCheck allows to enable, disable and override
	// the MachineHealthCheck configuration in the ClusterClass for this MachineDeployment.
	// +optional
	MachineHealthCheck *MachineHealthCheckTopology `json:"machineHealthCheck,omitempty"`

	// nodeDrainTimeout is the total amount of time that the controller will spend on draining a node.
	// The default value is 0, meaning that the node can be drained without any time limitations.
	// NOTE: NodeDrainTimeout is different from `kubectl drain --timeout`
	// +optional
	NodeDrainTimeout *metav1.Duration `json:"nodeDrainTimeout,omitempty"`

	// nodeVolumeDetachTimeout is the total amount of time that the controller will spend on waiting for all volumes
	// to be detached. The default value is 0, meaning that the volumes can be detached without any time limitations.
	// +optional
	NodeVolumeDetachTimeout *metav1.Duration `json:"nodeVolumeDetachTimeout,omitempty"`

	// nodeDeletionTimeout defines how long the controller will attempt to delete the Node that the Machine
	// hosts after the Machine is marked for deletion. A duration of 0 will retry deletion indefinitely.
	// Defaults to 10 seconds.
	// +optional
	NodeDeletionTimeout *metav1.Duration `json:"nodeDeletionTimeout,omitempty"`

	// Minimum number of seconds for which a newly created machine should
	// be ready.
	// Defaults to 0 (machine will be considered available as soon as it
	// is ready)
	// +optional
	MinReadySeconds *int32 `json:"minReadySeconds,omitempty"`

	// The deployment strategy to use to replace existing machines with
	// new ones.
	// +optional
	Strategy *MachineDeploymentStrategy `json:"strategy,omitempty"`

	// variables can be used to customize the MachineDeployment through patches.
	// +optional
	Variables *MachineDeploymentVariables `json:"variables,omitempty"`
}

MachineDeploymentTopology specifies the different parameters for a set of worker nodes in the topology. This set of nodes is managed by a MachineDeployment object whose lifecycle is managed by the Cluster controller.

func (*MachineDeploymentTopology) DeepCopy 

func (in *MachineDeploymentTopology) DeepCopy() *MachineDeploymentTopology

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachineDeploymentTopology.

func (*MachineDeploymentTopology) DeepCopyInto 

func (in *MachineDeploymentTopology) DeepCopyInto(out *MachineDeploymentTopology)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MachineDeploymentV1Beta2Status added in v1.9.0 

type MachineDeploymentV1Beta2Status struct {
	// conditions represents the observations of a MachineDeployment's current state.
	// Known condition types are Available, MachinesReady, MachinesUpToDate, ScalingUp, ScalingDown, Remediating, Deleting, Paused.
	// +optional
	// +listType=map
	// +listMapKey=type
	// +kubebuilder:validation:MaxItems=32
	Conditions []metav1.Condition `json:"conditions,omitempty"`

	// readyReplicas is the number of ready replicas for this MachineDeployment. A machine is considered ready when Machine's Ready condition is true.
	// +optional
	ReadyReplicas *int32 `json:"readyReplicas,omitempty"`

	// availableReplicas is the number of available replicas for this MachineDeployment. A machine is considered available when Machine's Available condition is true.
	// +optional
	AvailableReplicas *int32 `json:"availableReplicas,omitempty"`

	// upToDateReplicas is the number of up-to-date replicas targeted by this deployment. A machine is considered up-to-date when Machine's UpToDate condition is true.
	// +optional
	UpToDateReplicas *int32 `json:"upToDateReplicas,omitempty"`
}

MachineDeploymentV1Beta2Status groups all the fields that will be added or modified in MachineDeployment with the V1Beta2 version. See https://github.com/kubernetes-sigs/cluster-api/blob/main/docs/proposals/20240916-improve-status-in-CAPI-resources.md for more context.

func (*MachineDeploymentV1Beta2Status) DeepCopy added in v1.9.0 

func (in *MachineDeploymentV1Beta2Status) DeepCopy() *MachineDeploymentV1Beta2Status

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachineDeploymentV1Beta2Status.

func (*MachineDeploymentV1Beta2Status) DeepCopyInto added in v1.9.0 

func (in *MachineDeploymentV1Beta2Status) DeepCopyInto(out *MachineDeploymentV1Beta2Status)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MachineDeploymentVariables added in v1.1.0 

type MachineDeploymentVariables struct {
	// overrides can be used to override Cluster level variables.
	// +optional
	// +listType=map
	// +listMapKey=name
	Overrides []ClusterVariable `json:"overrides,omitempty"`
}

MachineDeploymentVariables can be used to provide variables for a specific MachineDeployment.

func (*MachineDeploymentVariables) DeepCopy added in v1.1.0 

func (in *MachineDeploymentVariables) DeepCopy() *MachineDeploymentVariables

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachineDeploymentVariables.

func (*MachineDeploymentVariables) DeepCopyInto added in v1.1.0 

func (in *MachineDeploymentVariables) DeepCopyInto(out *MachineDeploymentVariables)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MachineDrainRule added in v1.9.0 

type MachineDrainRule struct {
	metav1.TypeMeta `json:",inline"`

	// +required
	metav1.ObjectMeta `json:"metadata"`

	// spec defines the spec of a MachineDrainRule.
	// +required
	Spec MachineDrainRuleSpec `json:"spec"`
}

MachineDrainRule is the Schema for the MachineDrainRule API.

func (*MachineDrainRule) DeepCopy added in v1.9.0 

func (in *MachineDrainRule) DeepCopy() *MachineDrainRule

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachineDrainRule.

func (*MachineDrainRule) DeepCopyInto added in v1.9.0 

func (in *MachineDrainRule) DeepCopyInto(out *MachineDrainRule)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*MachineDrainRule) DeepCopyObject added in v1.9.0 

func (in *MachineDrainRule) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type MachineDrainRuleDrainBehavior added in v1.9.0 

type MachineDrainRuleDrainBehavior string

MachineDrainRuleDrainBehavior defines the drain behavior. Can be either "Drain" or "Skip". +kubebuilder:validation:Enum=Drain;Skip 

const (
	// MachineDrainRuleDrainBehaviorDrain means a Pod should be drained.
	MachineDrainRuleDrainBehaviorDrain MachineDrainRuleDrainBehavior = "Drain"

	// MachineDrainRuleDrainBehaviorSkip means the drain for a Pod should be skipped.
	MachineDrainRuleDrainBehaviorSkip MachineDrainRuleDrainBehavior = "Skip"
)

type MachineDrainRuleDrainConfig added in v1.9.0 

type MachineDrainRuleDrainConfig struct {
	// behavior defines the drain behavior.
	// Can be either "Drain" or "Skip".
	// "Drain" means that the Pods to which this MachineDrainRule applies will be drained.
	// If behavior is set to "Drain" the order in which Pods are drained can be configured
	// with the order field. When draining Pods of a Node the Pods will be grouped by order
	// and one group after another will be drained (by increasing order). Cluster API will
	// wait until all Pods of a group are terminated / removed from the Node before starting
	// with the next group.
	// "Skip" means that the Pods to which this MachineDrainRule applies will be skipped during drain.
	// +required
	Behavior MachineDrainRuleDrainBehavior `json:"behavior"`

	// order defines the order in which Pods are drained.
	// Pods with higher order are drained after Pods with lower order.
	// order can only be set if behavior is set to "Drain".
	// If order is not set, 0 will be used.
	// Valid values for order are from -2147483648 to 2147483647 (inclusive).
	// +optional
	Order *int32 `json:"order,omitempty"`
}

MachineDrainRuleDrainConfig configures if and how Pods are drained.

func (*MachineDrainRuleDrainConfig) DeepCopy added in v1.9.0 

func (in *MachineDrainRuleDrainConfig) DeepCopy() *MachineDrainRuleDrainConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachineDrainRuleDrainConfig.

func (*MachineDrainRuleDrainConfig) DeepCopyInto added in v1.9.0 

func (in *MachineDrainRuleDrainConfig) DeepCopyInto(out *MachineDrainRuleDrainConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MachineDrainRuleList added in v1.9.0 

type MachineDrainRuleList struct {
	metav1.TypeMeta `json:",inline"`

	// +required
	metav1.ListMeta `json:"metadata"`

	// items contains the items of the MachineDrainRuleList.
	// +required
	Items []MachineDrainRule `json:"items"`
}

MachineDrainRuleList contains a list of MachineDrainRules.

func (*MachineDrainRuleList) DeepCopy added in v1.9.0 

func (in *MachineDrainRuleList) DeepCopy() *MachineDrainRuleList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachineDrainRuleList.

func (*MachineDrainRuleList) DeepCopyInto added in v1.9.0 

func (in *MachineDrainRuleList) DeepCopyInto(out *MachineDrainRuleList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*MachineDrainRuleList) DeepCopyObject added in v1.9.0 

func (in *MachineDrainRuleList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type MachineDrainRuleMachineSelector added in v1.9.0 

type MachineDrainRuleMachineSelector struct {
	// selector is a label selector which selects Machines by their labels.
	// This field follows standard label selector semantics; if not present or
	// empty, it selects all Machines.
	//
	// If clusterSelector is also set, then the selector as a whole selects
	// Machines matching selector belonging to Clusters selected by clusterSelector.
	// If clusterSelector is not set, it selects all Machines matching selector in
	// all Clusters.
	// +optional
	Selector *metav1.LabelSelector `json:"selector,omitempty"`

	// clusterSelector is a label selector which selects Machines by the labels of
	// their Clusters.
	// This field follows standard label selector semantics; if not present or
	// empty, it selects Machines of all Clusters.
	//
	// If selector is also set, then the selector as a whole selects
	// Machines matching selector belonging to Clusters selected by clusterSelector.
	// If selector is not set, it selects all Machines belonging to Clusters
	// selected by clusterSelector.
	// +optional
	ClusterSelector *metav1.LabelSelector `json:"clusterSelector,omitempty"`
}

MachineDrainRuleMachineSelector defines to which Machines this MachineDrainRule should be applied. +kubebuilder:validation:MinProperties=1

func (*MachineDrainRuleMachineSelector) DeepCopy added in v1.9.0 

func (in *MachineDrainRuleMachineSelector) DeepCopy() *MachineDrainRuleMachineSelector

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachineDrainRuleMachineSelector.

func (*MachineDrainRuleMachineSelector) DeepCopyInto added in v1.9.0 

func (in *MachineDrainRuleMachineSelector) DeepCopyInto(out *MachineDrainRuleMachineSelector)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MachineDrainRulePodSelector added in v1.9.0 

type MachineDrainRulePodSelector struct {
	// selector is a label selector which selects Pods by their labels.
	// This field follows standard label selector semantics; if not present or
	// empty, it selects all Pods.
	//
	// If namespaceSelector is also set, then the selector as a whole selects
	// Pods matching selector in Namespaces selected by namespaceSelector.
	// If namespaceSelector is not set, it selects all Pods matching selector in
	// all Namespaces.
	// +optional
	Selector *metav1.LabelSelector `json:"selector,omitempty"`

	// namespaceSelector is a label selector which selects Pods by the labels of
	// their Namespaces.
	// This field follows standard label selector semantics; if not present or
	// empty, it selects Pods of all Namespaces.
	//
	// If selector is also set, then the selector as a whole selects
	// Pods matching selector in Namespaces selected by namespaceSelector.
	// If selector is not set, it selects all Pods in Namespaces selected by
	// namespaceSelector.
	// +optional
	NamespaceSelector *metav1.LabelSelector `json:"namespaceSelector,omitempty"`
}

MachineDrainRulePodSelector defines to which Pods this MachineDrainRule should be applied. +kubebuilder:validation:MinProperties=1

func (*MachineDrainRulePodSelector) DeepCopy added in v1.9.0 

func (in *MachineDrainRulePodSelector) DeepCopy() *MachineDrainRulePodSelector

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachineDrainRulePodSelector.

func (*MachineDrainRulePodSelector) DeepCopyInto added in v1.9.0 

func (in *MachineDrainRulePodSelector) DeepCopyInto(out *MachineDrainRulePodSelector)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MachineDrainRuleSpec added in v1.9.0 

type MachineDrainRuleSpec struct {
	// drain configures if and how Pods are drained.
	// +required
	Drain MachineDrainRuleDrainConfig `json:"drain"`

	// machines defines to which Machines this MachineDrainRule should be applied.
	//
	// If machines is not set, the MachineDrainRule applies to all Machines in the Namespace.
	// If machines contains multiple selectors, the results are ORed.
	// Within a single Machine selector the results of selector and clusterSelector are ANDed.
	// Machines will be selected from all Clusters in the Namespace unless otherwise
	// restricted with the clusterSelector.
	//
	// Example: Selects control plane Machines in all Clusters or
	//          Machines with label "os" == "linux" in Clusters with label
	//          "stage" == "production".
	//
	//  - selector:
	//      matchExpressions:
	//      - key: cluster.x-k8s.io/control-plane
	//        operator: Exists
	//  - selector:
	//      matchLabels:
	//        os: linux
	//    clusterSelector:
	//      matchExpressions:
	//      - key: stage
	//        operator: In
	//        values:
	//        - production
	//
	// +optional
	// +listType=atomic
	// +kubebuilder:validation:MinItems=1
	// +kubebuilder:validation:MaxItems=32
	Machines []MachineDrainRuleMachineSelector `json:"machines,omitempty"`

	// pods defines to which Pods this MachineDrainRule should be applied.
	//
	// If pods is not set, the MachineDrainRule applies to all Pods in all Namespaces.
	// If pods contains multiple selectors, the results are ORed.
	// Within a single Pod selector the results of selector and namespaceSelector are ANDed.
	// Pods will be selected from all Namespaces unless otherwise
	// restricted with the namespaceSelector.
	//
	// Example: Selects Pods with label "app" == "logging" in all Namespaces or
	//          Pods with label "app" == "prometheus" in the "monitoring"
	//          Namespace.
	//
	//  - selector:
	//      matchExpressions:
	//      - key: app
	//        operator: In
	//        values:
	//        - logging
	//  - selector:
	//      matchLabels:
	//        app: prometheus
	//    namespaceSelector:
	//      matchLabels:
	//        kubernetes.io/metadata.name: monitoring
	//
	// +optional
	// +listType=atomic
	// +kubebuilder:validation:MinItems=1
	// +kubebuilder:validation:MaxItems=32
	Pods []MachineDrainRulePodSelector `json:"pods,omitempty"`
}

MachineDrainRuleSpec defines the spec of a MachineDrainRule.

func (*MachineDrainRuleSpec) DeepCopy added in v1.9.0 

func (in *MachineDrainRuleSpec) DeepCopy() *MachineDrainRuleSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachineDrainRuleSpec.

func (*MachineDrainRuleSpec) DeepCopyInto added in v1.9.0 

func (in *MachineDrainRuleSpec) DeepCopyInto(out *MachineDrainRuleSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MachineHealthCheck 

type MachineHealthCheck struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	// Specification of machine health check policy
	Spec MachineHealthCheckSpec `json:"spec,omitempty"`

	// Most recently observed status of MachineHealthCheck resource
	Status MachineHealthCheckStatus `json:"status,omitempty"`
}

MachineHealthCheck is the Schema for the machinehealthchecks API.

func (*MachineHealthCheck) DeepCopy 

func (in *MachineHealthCheck) DeepCopy() *MachineHealthCheck

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachineHealthCheck.

func (*MachineHealthCheck) DeepCopyInto 

func (in *MachineHealthCheck) DeepCopyInto(out *MachineHealthCheck)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*MachineHealthCheck) DeepCopyObject 

func (in *MachineHealthCheck) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*MachineHealthCheck) GetConditions 

func (m *MachineHealthCheck) GetConditions() Conditions

GetConditions returns the set of conditions for this object.

func (*MachineHealthCheck) GetV1Beta2Conditions added in v1.9.0 

func (m *MachineHealthCheck) GetV1Beta2Conditions() []metav1.Condition

GetV1Beta2Conditions returns the set of conditions for this object.

func (*MachineHealthCheck) Hub 

func (*MachineHealthCheck) Hub()

func (*MachineHealthCheck) SetConditions 

func (m *MachineHealthCheck) SetConditions(conditions Conditions)

SetConditions sets the conditions on this object.

func (*MachineHealthCheck) SetV1Beta2Conditions added in v1.9.0 

func (m *MachineHealthCheck) SetV1Beta2Conditions(conditions []metav1.Condition)

SetV1Beta2Conditions sets conditions for an API object.

type MachineHealthCheckClass added in v1.1.0 

type MachineHealthCheckClass struct {
	// unhealthyConditions contains a list of the conditions that determine
	// whether a node is considered unhealthy. The conditions are combined in a
	// logical OR, i.e. if any of the conditions is met, the node is unhealthy.
	//
	// +optional
	UnhealthyConditions []UnhealthyCondition `json:"unhealthyConditions,omitempty"`

	// Any further remediation is only allowed if at most "MaxUnhealthy" machines selected by
	// "selector" are not healthy.
	// +optional
	MaxUnhealthy *intstr.IntOrString `json:"maxUnhealthy,omitempty"`

	// Any further remediation is only allowed if the number of machines selected by "selector" as not healthy
	// is within the range of "UnhealthyRange". Takes precedence over MaxUnhealthy.
	// Eg. "[3-5]" - This means that remediation will be allowed only when:
	// (a) there are at least 3 unhealthy machines (and)
	// (b) there are at most 5 unhealthy machines
	// +optional
	// +kubebuilder:validation:Pattern=^\[[0-9]+-[0-9]+\]$
	UnhealthyRange *string `json:"unhealthyRange,omitempty"`

	// nodeStartupTimeout allows to set the maximum time for MachineHealthCheck
	// to consider a Machine unhealthy if a corresponding Node isn't associated
	// through a `Spec.ProviderID` field.
	//
	// The duration set in this field is compared to the greatest of:
	// - Cluster's infrastructure ready condition timestamp (if and when available)
	// - Control Plane's initialized condition timestamp (if and when available)
	// - Machine's infrastructure ready condition timestamp (if and when available)
	// - Machine's metadata creation timestamp
	//
	// Defaults to 10 minutes.
	// If you wish to disable this feature, set the value explicitly to 0.
	// +optional
	NodeStartupTimeout *metav1.Duration `json:"nodeStartupTimeout,omitempty"`

	// remediationTemplate is a reference to a remediation template
	// provided by an infrastructure provider.
	//
	// This field is completely optional, when filled, the MachineHealthCheck controller
	// creates a new object from the template referenced and hands off remediation of the machine to
	// a controller that lives outside of Cluster API.
	// +optional
	RemediationTemplate *corev1.ObjectReference `json:"remediationTemplate,omitempty"`
}

MachineHealthCheckClass defines a MachineHealthCheck for a group of Machines.

func (*MachineHealthCheckClass) DeepCopy added in v1.1.0 

func (in *MachineHealthCheckClass) DeepCopy() *MachineHealthCheckClass

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachineHealthCheckClass.

func (*MachineHealthCheckClass) DeepCopyInto added in v1.1.0 

func (in *MachineHealthCheckClass) DeepCopyInto(out *MachineHealthCheckClass)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (MachineHealthCheckClass) IsZero added in v1.3.0 

func (m MachineHealthCheckClass) IsZero() bool

IsZero returns true if none of the values of MachineHealthCheckClass are defined.

type MachineHealthCheckList 

type MachineHealthCheckList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []MachineHealthCheck `json:"items"`
}

MachineHealthCheckList contains a list of MachineHealthCheck.

func (*MachineHealthCheckList) DeepCopy 

func (in *MachineHealthCheckList) DeepCopy() *MachineHealthCheckList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachineHealthCheckList.

func (*MachineHealthCheckList) DeepCopyInto 

func (in *MachineHealthCheckList) DeepCopyInto(out *MachineHealthCheckList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*MachineHealthCheckList) DeepCopyObject 

func (in *MachineHealthCheckList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*MachineHealthCheckList) Hub 

func (*MachineHealthCheckList) Hub()

type MachineHealthCheckSpec 

type MachineHealthCheckSpec struct {
	// clusterName is the name of the Cluster this object belongs to.
	// +kubebuilder:validation:MinLength=1
	ClusterName string `json:"clusterName"`

	// Label selector to match machines whose health will be exercised
	Selector metav1.LabelSelector `json:"selector"`

	// unhealthyConditions contains a list of the conditions that determine
	// whether a node is considered unhealthy.  The conditions are combined in a
	// logical OR, i.e. if any of the conditions is met, the node is unhealthy.
	//
	// +optional
	UnhealthyConditions []UnhealthyCondition `json:"unhealthyConditions,omitempty"`

	// Any further remediation is only allowed if at most "MaxUnhealthy" machines selected by
	// "selector" are not healthy.
	//
	// Deprecated: This field is deprecated and is going to be removed in the next apiVersion. Please see https://github.com/kubernetes-sigs/cluster-api/issues/10722 for more details.
	//
	// +optional
	MaxUnhealthy *intstr.IntOrString `json:"maxUnhealthy,omitempty"`

	// Any further remediation is only allowed if the number of machines selected by "selector" as not healthy
	// is within the range of "UnhealthyRange". Takes precedence over MaxUnhealthy.
	// Eg. "[3-5]" - This means that remediation will be allowed only when:
	// (a) there are at least 3 unhealthy machines (and)
	// (b) there are at most 5 unhealthy machines
	//
	// Deprecated: This field is deprecated and is going to be removed in the next apiVersion. Please see https://github.com/kubernetes-sigs/cluster-api/issues/10722 for more details.
	//
	// +optional
	// +kubebuilder:validation:Pattern=^\[[0-9]+-[0-9]+\]$
	UnhealthyRange *string `json:"unhealthyRange,omitempty"`

	// nodeStartupTimeout allows to set the maximum time for MachineHealthCheck
	// to consider a Machine unhealthy if a corresponding Node isn't associated
	// through a `Spec.ProviderID` field.
	//
	// The duration set in this field is compared to the greatest of:
	// - Cluster's infrastructure ready condition timestamp (if and when available)
	// - Control Plane's initialized condition timestamp (if and when available)
	// - Machine's infrastructure ready condition timestamp (if and when available)
	// - Machine's metadata creation timestamp
	//
	// Defaults to 10 minutes.
	// If you wish to disable this feature, set the value explicitly to 0.
	// +optional
	NodeStartupTimeout *metav1.Duration `json:"nodeStartupTimeout,omitempty"`

	// remediationTemplate is a reference to a remediation template
	// provided by an infrastructure provider.
	//
	// This field is completely optional, when filled, the MachineHealthCheck controller
	// creates a new object from the template referenced and hands off remediation of the machine to
	// a controller that lives outside of Cluster API.
	// +optional
	RemediationTemplate *corev1.ObjectReference `json:"remediationTemplate,omitempty"`
}

MachineHealthCheckSpec defines the desired state of MachineHealthCheck.

func (*MachineHealthCheckSpec) DeepCopy 

func (in *MachineHealthCheckSpec) DeepCopy() *MachineHealthCheckSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachineHealthCheckSpec.

func (*MachineHealthCheckSpec) DeepCopyInto 

func (in *MachineHealthCheckSpec) DeepCopyInto(out *MachineHealthCheckSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MachineHealthCheckStatus 

type MachineHealthCheckStatus struct {
	// total number of machines counted by this machine health check
	// +kubebuilder:validation:Minimum=0
	// +optional
	ExpectedMachines int32 `json:"expectedMachines"`

	// total number of healthy machines counted by this machine health check
	// +kubebuilder:validation:Minimum=0
	// +optional
	CurrentHealthy int32 `json:"currentHealthy"`

	// remediationsAllowed is the number of further remediations allowed by this machine health check before
	// maxUnhealthy short circuiting will be applied
	// +kubebuilder:validation:Minimum=0
	// +optional
	RemediationsAllowed int32 `json:"remediationsAllowed"`

	// observedGeneration is the latest generation observed by the controller.
	// +optional
	ObservedGeneration int64 `json:"observedGeneration,omitempty"`

	// targets shows the current list of machines the machine health check is watching
	// +optional
	Targets []string `json:"targets,omitempty"`

	// conditions defines current service state of the MachineHealthCheck.
	// +optional
	Conditions Conditions `json:"conditions,omitempty"`

	// v1beta2 groups all the fields that will be added or modified in MachineHealthCheck's status with the V1Beta2 version.
	// +optional
	V1Beta2 *MachineHealthCheckV1Beta2Status `json:"v1beta2,omitempty"`
}

MachineHealthCheckStatus defines the observed state of MachineHealthCheck.

func (*MachineHealthCheckStatus) DeepCopy 

func (in *MachineHealthCheckStatus) DeepCopy() *MachineHealthCheckStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachineHealthCheckStatus.

func (*MachineHealthCheckStatus) DeepCopyInto 

func (in *MachineHealthCheckStatus) DeepCopyInto(out *MachineHealthCheckStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MachineHealthCheckTopology added in v1.3.0 

type MachineHealthCheckTopology struct {
	// enable controls if a MachineHealthCheck should be created for the target machines.
	//
	// If false: No MachineHealthCheck will be created.
	//
	// If not set(default): A MachineHealthCheck will be created if it is defined here or
	//  in the associated ClusterClass. If no MachineHealthCheck is defined then none will be created.
	//
	// If true: A MachineHealthCheck is guaranteed to be created. Cluster validation will
	// block if `enable` is true and no MachineHealthCheck definition is available.
	// +optional
	Enable *bool `json:"enable,omitempty"`

	// MachineHealthCheckClass defines a MachineHealthCheck for a group of machines.
	// If specified (any field is set), it entirely overrides the MachineHealthCheckClass defined in ClusterClass.
	MachineHealthCheckClass `json:",inline"`
}

MachineHealthCheckTopology defines a MachineHealthCheck for a group of machines.

func (*MachineHealthCheckTopology) DeepCopy added in v1.3.0 

func (in *MachineHealthCheckTopology) DeepCopy() *MachineHealthCheckTopology

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachineHealthCheckTopology.

func (*MachineHealthCheckTopology) DeepCopyInto added in v1.3.0 

func (in *MachineHealthCheckTopology) DeepCopyInto(out *MachineHealthCheckTopology)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MachineHealthCheckV1Beta2Status added in v1.9.0 

type MachineHealthCheckV1Beta2Status struct {
	// conditions represents the observations of a MachineHealthCheck's current state.
	// Known condition types are RemediationAllowed, Paused.
	// +optional
	// +listType=map
	// +listMapKey=type
	// +kubebuilder:validation:MaxItems=32
	Conditions []metav1.Condition `json:"conditions,omitempty"`
}

MachineHealthCheckV1Beta2Status groups all the fields that will be added or modified in MachineHealthCheck with the V1Beta2 version. See https://github.com/kubernetes-sigs/cluster-api/blob/main/docs/proposals/20240916-improve-status-in-CAPI-resources.md for more context.

func (*MachineHealthCheckV1Beta2Status) DeepCopy added in v1.9.0 

func (in *MachineHealthCheckV1Beta2Status) DeepCopy() *MachineHealthCheckV1Beta2Status

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachineHealthCheckV1Beta2Status.

func (*MachineHealthCheckV1Beta2Status) DeepCopyInto added in v1.9.0 

func (in *MachineHealthCheckV1Beta2Status) DeepCopyInto(out *MachineHealthCheckV1Beta2Status)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MachineList 

type MachineList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []Machine `json:"items"`
}

MachineList contains a list of Machine.

func (*MachineList) DeepCopy 

func (in *MachineList) DeepCopy() *MachineList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachineList.

func (*MachineList) DeepCopyInto 

func (in *MachineList) DeepCopyInto(out *MachineList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*MachineList) DeepCopyObject 

func (in *MachineList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*MachineList) Hub 

func (*MachineList) Hub()

type MachinePhase 

type MachinePhase string

MachinePhase is a string representation of a Machine Phase.

This type is a high-level indicator of the status of the Machine as it is provisioned, from the API user’s perspective.

The value should not be interpreted by any software components as a reliable indication of the actual state of the Machine, and controllers should not use the Machine Phase field value when making decisions about what action to take.

Controllers should always look at the actual state of the Machine’s fields to make those decisions.

type MachinePoolClass added in v1.6.0 

type MachinePoolClass struct {
	// class denotes a type of machine pool present in the cluster,
	// this name MUST be unique within a ClusterClass and can be referenced
	// in the Cluster to create a managed MachinePool.
	Class string `json:"class"`

	// template is a local struct containing a collection of templates for creation of
	// MachinePools objects representing a pool of worker nodes.
	Template MachinePoolClassTemplate `json:"template"`

	// failureDomains is the list of failure domains the MachinePool should be attached to.
	// Must match a key in the FailureDomains map stored on the cluster object.
	// NOTE: This value can be overridden while defining a Cluster.Topology using this MachinePoolClass.
	// +optional
	FailureDomains []string `json:"failureDomains,omitempty"`

	// namingStrategy allows changing the naming pattern used when creating the MachinePool.
	// +optional
	NamingStrategy *MachinePoolClassNamingStrategy `json:"namingStrategy,omitempty"`

	// nodeDrainTimeout is the total amount of time that the controller will spend on draining a node.
	// The default value is 0, meaning that the node can be drained without any time limitations.
	// NOTE: NodeDrainTimeout is different from `kubectl drain --timeout`
	// NOTE: This value can be overridden while defining a Cluster.Topology using this MachinePoolClass.
	// +optional
	NodeDrainTimeout *metav1.Duration `json:"nodeDrainTimeout,omitempty"`

	// nodeVolumeDetachTimeout is the total amount of time that the controller will spend on waiting for all volumes
	// to be detached. The default value is 0, meaning that the volumes can be detached without any time limitations.
	// NOTE: This value can be overridden while defining a Cluster.Topology using this MachinePoolClass.
	// +optional
	NodeVolumeDetachTimeout *metav1.Duration `json:"nodeVolumeDetachTimeout,omitempty"`

	// nodeDeletionTimeout defines how long the controller will attempt to delete the Node that the Machine
	// hosts after the Machine Pool is marked for deletion. A duration of 0 will retry deletion indefinitely.
	// Defaults to 10 seconds.
	// NOTE: This value can be overridden while defining a Cluster.Topology using this MachinePoolClass.
	// +optional
	NodeDeletionTimeout *metav1.Duration `json:"nodeDeletionTimeout,omitempty"`

	// Minimum number of seconds for which a newly created machine pool should
	// be ready.
	// Defaults to 0 (machine will be considered available as soon as it
	// is ready)
	// NOTE: This value can be overridden while defining a Cluster.Topology using this MachinePoolClass.
	MinReadySeconds *int32 `json:"minReadySeconds,omitempty"`
}

MachinePoolClass serves as a template to define a pool of worker nodes of the cluster provisioned using `ClusterClass`.

func (*MachinePoolClass) DeepCopy added in v1.6.0 

func (in *MachinePoolClass) DeepCopy() *MachinePoolClass

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachinePoolClass.

func (*MachinePoolClass) DeepCopyInto added in v1.6.0 

func (in *MachinePoolClass) DeepCopyInto(out *MachinePoolClass)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MachinePoolClassNamingStrategy added in v1.6.0 

type MachinePoolClassNamingStrategy struct {
	// template defines the template to use for generating the name of the MachinePool object.
	// If not defined, it will fallback to `{{ .cluster.name }}-{{ .machinePool.topologyName }}-{{ .random }}`.
	// If the templated string exceeds 63 characters, it will be trimmed to 58 characters and will
	// get concatenated with a random suffix of length 5.
	// The templating mechanism provides the following arguments:
	// * `.cluster.name`: The name of the cluster object.
	// * `.random`: A random alphanumeric string, without vowels, of length 5.
	// * `.machinePool.topologyName`: The name of the MachinePool topology (Cluster.spec.topology.workers.machinePools[].name).
	// +optional
	Template *string `json:"template,omitempty"`
}

MachinePoolClassNamingStrategy defines the naming strategy for machine pool objects.

func (*MachinePoolClassNamingStrategy) DeepCopy added in v1.6.0 

func (in *MachinePoolClassNamingStrategy) DeepCopy() *MachinePoolClassNamingStrategy

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachinePoolClassNamingStrategy.

func (*MachinePoolClassNamingStrategy) DeepCopyInto added in v1.6.0 

func (in *MachinePoolClassNamingStrategy) DeepCopyInto(out *MachinePoolClassNamingStrategy)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MachinePoolClassTemplate added in v1.6.0 

type MachinePoolClassTemplate struct {
	// metadata is the metadata applied to the MachinePool.
	// At runtime this metadata is merged with the corresponding metadata from the topology.
	// +optional
	Metadata ObjectMeta `json:"metadata,omitempty"`

	// bootstrap contains the bootstrap template reference to be used
	// for the creation of the Machines in the MachinePool.
	Bootstrap LocalObjectTemplate `json:"bootstrap"`

	// infrastructure contains the infrastructure template reference to be used
	// for the creation of the MachinePool.
	Infrastructure LocalObjectTemplate `json:"infrastructure"`
}

MachinePoolClassTemplate defines how a MachinePool generated from a MachinePoolClass should look like.

func (*MachinePoolClassTemplate) DeepCopy added in v1.6.0 

func (in *MachinePoolClassTemplate) DeepCopy() *MachinePoolClassTemplate

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachinePoolClassTemplate.

func (*MachinePoolClassTemplate) DeepCopyInto added in v1.6.0 

func (in *MachinePoolClassTemplate) DeepCopyInto(out *MachinePoolClassTemplate)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MachinePoolTopology added in v1.6.0 

type MachinePoolTopology struct {
	// metadata is the metadata applied to the MachinePool.
	// At runtime this metadata is merged with the corresponding metadata from the ClusterClass.
	// +optional
	Metadata ObjectMeta `json:"metadata,omitempty"`

	// class is the name of the MachinePoolClass used to create the pool of worker nodes.
	// This should match one of the deployment classes defined in the ClusterClass object
	// mentioned in the `Cluster.Spec.Class` field.
	Class string `json:"class"`

	// name is the unique identifier for this MachinePoolTopology.
	// The value is used with other unique identifiers to create a MachinePool's Name
	// (e.g. cluster's name, etc). In case the name is greater than the allowed maximum length,
	// the values are hashed together.
	Name string `json:"name"`

	// failureDomains is the list of failure domains the machine pool will be created in.
	// Must match a key in the FailureDomains map stored on the cluster object.
	// +optional
	FailureDomains []string `json:"failureDomains,omitempty"`

	// nodeDrainTimeout is the total amount of time that the controller will spend on draining a node.
	// The default value is 0, meaning that the node can be drained without any time limitations.
	// NOTE: NodeDrainTimeout is different from `kubectl drain --timeout`
	// +optional
	NodeDrainTimeout *metav1.Duration `json:"nodeDrainTimeout,omitempty"`

	// nodeVolumeDetachTimeout is the total amount of time that the controller will spend on waiting for all volumes
	// to be detached. The default value is 0, meaning that the volumes can be detached without any time limitations.
	// +optional
	NodeVolumeDetachTimeout *metav1.Duration `json:"nodeVolumeDetachTimeout,omitempty"`

	// nodeDeletionTimeout defines how long the controller will attempt to delete the Node that the MachinePool
	// hosts after the MachinePool is marked for deletion. A duration of 0 will retry deletion indefinitely.
	// Defaults to 10 seconds.
	// +optional
	NodeDeletionTimeout *metav1.Duration `json:"nodeDeletionTimeout,omitempty"`

	// Minimum number of seconds for which a newly created machine pool should
	// be ready.
	// Defaults to 0 (machine will be considered available as soon as it
	// is ready)
	// +optional
	MinReadySeconds *int32 `json:"minReadySeconds,omitempty"`

	// replicas is the number of nodes belonging to this pool.
	// If the value is nil, the MachinePool is created without the number of Replicas (defaulting to 1)
	// and it's assumed that an external entity (like cluster autoscaler) is responsible for the management
	// of this value.
	// +optional
	Replicas *int32 `json:"replicas,omitempty"`

	// variables can be used to customize the MachinePool through patches.
	// +optional
	Variables *MachinePoolVariables `json:"variables,omitempty"`
}

MachinePoolTopology specifies the different parameters for a pool of worker nodes in the topology. This pool of nodes is managed by a MachinePool object whose lifecycle is managed by the Cluster controller.

func (*MachinePoolTopology) DeepCopy added in v1.6.0 

func (in *MachinePoolTopology) DeepCopy() *MachinePoolTopology

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachinePoolTopology.

func (*MachinePoolTopology) DeepCopyInto added in v1.6.0 

func (in *MachinePoolTopology) DeepCopyInto(out *MachinePoolTopology)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MachinePoolVariables added in v1.6.0 

type MachinePoolVariables struct {
	// overrides can be used to override Cluster level variables.
	// +optional
	// +listType=map
	// +listMapKey=name
	Overrides []ClusterVariable `json:"overrides,omitempty"`
}

MachinePoolVariables can be used to provide variables for a specific MachinePool.

func (*MachinePoolVariables) DeepCopy added in v1.6.0 

func (in *MachinePoolVariables) DeepCopy() *MachinePoolVariables

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachinePoolVariables.

func (*MachinePoolVariables) DeepCopyInto added in v1.6.0 

func (in *MachinePoolVariables) DeepCopyInto(out *MachinePoolVariables)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MachineReadinessGate added in v1.9.0 

type MachineReadinessGate struct {
	// conditionType refers to a positive polarity condition (status true means good) with matching type in the Machine's condition list.
	// If the conditions doesn't exist, it will be treated as unknown.
	// Note: Both Cluster API conditions or conditions added by 3rd party controllers can be used as readiness gates.
	// +required
	// +kubebuilder:validation:Pattern=`^([a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*/)?(([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9])$`
	// +kubebuilder:validation:MaxLength=316
	// +kubebuilder:validation:MinLength=1
	ConditionType string `json:"conditionType"`
}

MachineReadinessGate contains the type of a Machine condition to be used as a readiness gate.

func (*MachineReadinessGate) DeepCopy added in v1.9.0 

func (in *MachineReadinessGate) DeepCopy() *MachineReadinessGate

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachineReadinessGate.

func (*MachineReadinessGate) DeepCopyInto added in v1.9.0 

func (in *MachineReadinessGate) DeepCopyInto(out *MachineReadinessGate)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MachineRollingUpdateDeployment 

type MachineRollingUpdateDeployment struct {
	// The maximum number of machines that can be unavailable during the update.
	// Value can be an absolute number (ex: 5) or a percentage of desired
	// machines (ex: 10%).
	// Absolute number is calculated from percentage by rounding down.
	// This can not be 0 if MaxSurge is 0.
	// Defaults to 0.
	// Example: when this is set to 30%, the old MachineSet can be scaled
	// down to 70% of desired machines immediately when the rolling update
	// starts. Once new machines are ready, old MachineSet can be scaled
	// down further, followed by scaling up the new MachineSet, ensuring
	// that the total number of machines available at all times
	// during the update is at least 70% of desired machines.
	// +optional
	MaxUnavailable *intstr.IntOrString `json:"maxUnavailable,omitempty"`

	// The maximum number of machines that can be scheduled above the
	// desired number of machines.
	// Value can be an absolute number (ex: 5) or a percentage of
	// desired machines (ex: 10%).
	// This can not be 0 if MaxUnavailable is 0.
	// Absolute number is calculated from percentage by rounding up.
	// Defaults to 1.
	// Example: when this is set to 30%, the new MachineSet can be scaled
	// up immediately when the rolling update starts, such that the total
	// number of old and new machines do not exceed 130% of desired
	// machines. Once old machines have been killed, new MachineSet can
	// be scaled up further, ensuring that total number of machines running
	// at any time during the update is at most 130% of desired machines.
	// +optional
	MaxSurge *intstr.IntOrString `json:"maxSurge,omitempty"`

	// deletePolicy defines the policy used by the MachineDeployment to identify nodes to delete when downscaling.
	// Valid values are "Random, "Newest", "Oldest"
	// When no value is supplied, the default DeletePolicy of MachineSet is used
	// +kubebuilder:validation:Enum=Random;Newest;Oldest
	// +optional
	DeletePolicy *string `json:"deletePolicy,omitempty"`
}

MachineRollingUpdateDeployment is used to control the desired behavior of rolling update.

func (*MachineRollingUpdateDeployment) DeepCopy 

func (in *MachineRollingUpdateDeployment) DeepCopy() *MachineRollingUpdateDeployment

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachineRollingUpdateDeployment.

func (*MachineRollingUpdateDeployment) DeepCopyInto 

func (in *MachineRollingUpdateDeployment) DeepCopyInto(out *MachineRollingUpdateDeployment)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MachineSet 

type MachineSet struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   MachineSetSpec   `json:"spec,omitempty"`
	Status MachineSetStatus `json:"status,omitempty"`
}

MachineSet is the Schema for the machinesets API.

func (*MachineSet) DeepCopy 

func (in *MachineSet) DeepCopy() *MachineSet

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachineSet.

func (*MachineSet) DeepCopyInto 

func (in *MachineSet) DeepCopyInto(out *MachineSet)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*MachineSet) DeepCopyObject 

func (in *MachineSet) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*MachineSet) GetConditions 

func (m *MachineSet) GetConditions() Conditions

GetConditions returns the set of conditions for the MachineSet.

func (*MachineSet) GetV1Beta2Conditions added in v1.9.0 

func (m *MachineSet) GetV1Beta2Conditions() []metav1.Condition

GetV1Beta2Conditions returns the set of conditions for this object.

func (*MachineSet) Hub 

func (*MachineSet) Hub()

func (*MachineSet) SetConditions 

func (m *MachineSet) SetConditions(conditions Conditions)

SetConditions updates the set of conditions on the MachineSet.

func (*MachineSet) SetV1Beta2Conditions added in v1.9.0 

func (m *MachineSet) SetV1Beta2Conditions(conditions []metav1.Condition)

SetV1Beta2Conditions sets conditions for an API object.

func (*MachineSet) Validate 

func (m *MachineSet) Validate() field.ErrorList

Validate validates the MachineSet fields.

type MachineSetDeletePolicy 

type MachineSetDeletePolicy string

MachineSetDeletePolicy defines how priority is assigned to nodes to delete when downscaling a MachineSet. Defaults to "Random". 

const (
	// RandomMachineSetDeletePolicy prioritizes both Machines that have the annotation
	// "cluster.x-k8s.io/delete-machine=yes" and Machines that are unhealthy
	// (Status.FailureReason or Status.FailureMessage are set to a non-empty value
	// or NodeHealthy type of Status.Conditions is not true).
	// Finally, it picks Machines at random to delete.
	RandomMachineSetDeletePolicy MachineSetDeletePolicy = "Random"

	// NewestMachineSetDeletePolicy prioritizes both Machines that have the annotation
	// "cluster.x-k8s.io/delete-machine=yes" and Machines that are unhealthy
	// (Status.FailureReason or Status.FailureMessage are set to a non-empty value
	// or NodeHealthy type of Status.Conditions is not true).
	// It then prioritizes the newest Machines for deletion based on the Machine's CreationTimestamp.
	NewestMachineSetDeletePolicy MachineSetDeletePolicy = "Newest"

	// OldestMachineSetDeletePolicy prioritizes both Machines that have the annotation
	// "cluster.x-k8s.io/delete-machine=yes" and Machines that are unhealthy
	// (Status.FailureReason or Status.FailureMessage are set to a non-empty value
	// or NodeHealthy type of Status.Conditions is not true).
	// It then prioritizes the oldest Machines for deletion based on the Machine's CreationTimestamp.
	OldestMachineSetDeletePolicy MachineSetDeletePolicy = "Oldest"
)

type MachineSetList 

type MachineSetList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []MachineSet `json:"items"`
}

MachineSetList contains a list of MachineSet.

func (*MachineSetList) DeepCopy 

func (in *MachineSetList) DeepCopy() *MachineSetList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachineSetList.

func (*MachineSetList) DeepCopyInto 

func (in *MachineSetList) DeepCopyInto(out *MachineSetList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*MachineSetList) DeepCopyObject 

func (in *MachineSetList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*MachineSetList) Hub 

func (*MachineSetList) Hub()

type MachineSetPreflightCheck added in v1.5.0 

type MachineSetPreflightCheck string

MachineSetPreflightCheck defines a valid MachineSet preflight check. 

const (
	// MachineSetPreflightCheckAll can be used to represent all the MachineSet preflight checks.
	MachineSetPreflightCheckAll MachineSetPreflightCheck = "All"

	// MachineSetPreflightCheckKubeadmVersionSkew is the name of the preflight check
	// that verifies if the machine being created or remediated for the MachineSet conforms to the kubeadm version
	// skew policy that requires the machine to be at the same version as the control plane.
	// Note: This is a stopgap while the root cause of the problem is fixed in kubeadm; this check will become
	// a no-op when this check will be available in kubeadm, and then eventually be dropped when all the
	// supported Kuberenetes/kubeadm versions have implemented the fix.
	// The preflight check is only run if a ControlPlane is used (controlPlaneRef must exist in the Cluster),
	// the ControlPlane has a version, the MachineSet has a version and the MachineSet uses the Kubeadm bootstrap
	// provider.
	MachineSetPreflightCheckKubeadmVersionSkew MachineSetPreflightCheck = "KubeadmVersionSkew"

	// MachineSetPreflightCheckKubernetesVersionSkew is the name of the preflight check that verifies
	// if the machines being created or remediated for the MachineSet conform to the Kubernetes version skew policy
	// that requires the machines to be at a version that is not more than 2 minor lower than the ControlPlane version.
	// The preflight check is only run if a ControlPlane is used (controlPlaneRef must exist in the Cluster),
	// the ControlPlane has a version and the MachineSet has a version.
	MachineSetPreflightCheckKubernetesVersionSkew MachineSetPreflightCheck = "KubernetesVersionSkew"

	// MachineSetPreflightCheckControlPlaneIsStable is the name of the preflight check
	// that verifies if the control plane is not provisioning and not upgrading.
	// The preflight check is only run if a ControlPlane is used (controlPlaneRef must exist in the Cluster)
	// and the ControlPlane has a version.
	MachineSetPreflightCheckControlPlaneIsStable MachineSetPreflightCheck = "ControlPlaneIsStable"
)

type MachineSetSpec 

type MachineSetSpec struct {
	// clusterName is the name of the Cluster this object belongs to.
	// +kubebuilder:validation:MinLength=1
	ClusterName string `json:"clusterName"`

	// replicas is the number of desired replicas.
	// This is a pointer to distinguish between explicit zero and unspecified.
	//
	// Defaults to:
	// * if the Kubernetes autoscaler min size and max size annotations are set:
	//   - if it's a new MachineSet, use min size
	//   - if the replicas field of the old MachineSet is < min size, use min size
	//   - if the replicas field of the old MachineSet is > max size, use max size
	//   - if the replicas field of the old MachineSet is in the (min size, max size) range, keep the value from the oldMS
	// * otherwise use 1
	// Note: Defaulting will be run whenever the replicas field is not set:
	// * A new MachineSet is created with replicas not set.
	// * On an existing MachineSet the replicas field was first set and is now unset.
	// Those cases are especially relevant for the following Kubernetes autoscaler use cases:
	// * A new MachineSet is created and replicas should be managed by the autoscaler
	// * An existing MachineSet which initially wasn't controlled by the autoscaler
	//   should be later controlled by the autoscaler
	// +optional
	Replicas *int32 `json:"replicas,omitempty"`

	// minReadySeconds is the minimum number of seconds for which a Node for a newly created machine should be ready before considering the replica available.
	// Defaults to 0 (machine will be considered available as soon as the Node is ready)
	// +optional
	MinReadySeconds int32 `json:"minReadySeconds,omitempty"`

	// deletePolicy defines the policy used to identify nodes to delete when downscaling.
	// Defaults to "Random".  Valid values are "Random, "Newest", "Oldest"
	// +kubebuilder:validation:Enum=Random;Newest;Oldest
	// +optional
	DeletePolicy string `json:"deletePolicy,omitempty"`

	// selector is a label query over machines that should match the replica count.
	// Label keys and values that must match in order to be controlled by this MachineSet.
	// It must match the machine template's labels.
	// More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors
	Selector metav1.LabelSelector `json:"selector"`

	// template is the object that describes the machine that will be created if
	// insufficient replicas are detected.
	// Object references to custom resources are treated as templates.
	// +optional
	Template MachineTemplateSpec `json:"template,omitempty"`
}

MachineSetSpec defines the desired state of MachineSet.

func (*MachineSetSpec) DeepCopy 

func (in *MachineSetSpec) DeepCopy() *MachineSetSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachineSetSpec.

func (*MachineSetSpec) DeepCopyInto 

func (in *MachineSetSpec) DeepCopyInto(out *MachineSetSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MachineSetStatus 

type MachineSetStatus struct {
	// selector is the same as the label selector but in the string format to avoid introspection
	// by clients. The string will be in the same format as the query-param syntax.
	// More info about label selectors: http://kubernetes.io/docs/user-guide/labels#label-selectors
	// +optional
	Selector string `json:"selector,omitempty"`

	// replicas is the most recently observed number of replicas.
	// +optional
	Replicas int32 `json:"replicas"`

	// The number of replicas that have labels matching the labels of the machine template of the MachineSet.
	//
	// Deprecated: This field is deprecated and is going to be removed in the next apiVersion. Please see https://github.com/kubernetes-sigs/cluster-api/blob/main/docs/proposals/20240916-improve-status-in-CAPI-resources.md for more details.
	//
	// +optional
	FullyLabeledReplicas int32 `json:"fullyLabeledReplicas"`

	// The number of ready replicas for this MachineSet. A machine is considered ready when the node has been created and is "Ready".
	// +optional
	ReadyReplicas int32 `json:"readyReplicas"`

	// The number of available replicas (ready for at least minReadySeconds) for this MachineSet.
	// +optional
	AvailableReplicas int32 `json:"availableReplicas"`

	// observedGeneration reflects the generation of the most recently observed MachineSet.
	// +optional
	ObservedGeneration int64 `json:"observedGeneration,omitempty"`

	// In the event that there is a terminal problem reconciling the
	// replicas, both FailureReason and FailureMessage will be set. FailureReason
	// will be populated with a succinct value suitable for machine
	// interpretation, while FailureMessage will contain a more verbose
	// string suitable for logging and human consumption.
	//
	// These fields should not be set for transitive errors that a
	// controller faces that are expected to be fixed automatically over
	// time (like service outages), but instead indicate that something is
	// fundamentally wrong with the MachineTemplate's spec or the configuration of
	// the machine controller, and that manual intervention is required. Examples
	// of terminal errors would be invalid combinations of settings in the
	// spec, values that are unsupported by the machine controller, or the
	// responsible machine controller itself being critically misconfigured.
	//
	// Any transient errors that occur during the reconciliation of Machines
	// can be added as events to the MachineSet object and/or logged in the
	// controller's output.
	//
	// Deprecated: This field is deprecated and is going to be removed in the next apiVersion. Please see https://github.com/kubernetes-sigs/cluster-api/blob/main/docs/proposals/20240916-improve-status-in-CAPI-resources.md for more details.
	//
	// +optional
	FailureReason *capierrors.MachineSetStatusError `json:"failureReason,omitempty"`
	// Deprecated: This field is deprecated and is going to be removed in the next apiVersion. Please see https://github.com/kubernetes-sigs/cluster-api/blob/main/docs/proposals/20240916-improve-status-in-CAPI-resources.md for more details.
	//
	// +optional
	FailureMessage *string `json:"failureMessage,omitempty"`
	// conditions defines current service state of the MachineSet.
	// +optional
	Conditions Conditions `json:"conditions,omitempty"`

	// v1beta2 groups all the fields that will be added or modified in MachineSet's status with the V1Beta2 version.
	// +optional
	V1Beta2 *MachineSetV1Beta2Status `json:"v1beta2,omitempty"`
}

MachineSetStatus defines the observed state of MachineSet.

func (*MachineSetStatus) DeepCopy 

func (in *MachineSetStatus) DeepCopy() *MachineSetStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachineSetStatus.

func (*MachineSetStatus) DeepCopyInto 

func (in *MachineSetStatus) DeepCopyInto(out *MachineSetStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MachineSetV1Beta2Status added in v1.9.0 

type MachineSetV1Beta2Status struct {
	// conditions represents the observations of a MachineSet's current state.
	// Known condition types are MachinesReady, MachinesUpToDate, ScalingUp, ScalingDown, Remediating, Deleting, Paused.
	// +optional
	// +listType=map
	// +listMapKey=type
	// +kubebuilder:validation:MaxItems=32
	Conditions []metav1.Condition `json:"conditions,omitempty"`

	// readyReplicas is the number of ready replicas for this MachineSet. A machine is considered ready when Machine's Ready condition is true.
	// +optional
	ReadyReplicas *int32 `json:"readyReplicas,omitempty"`

	// availableReplicas is the number of available replicas for this MachineSet. A machine is considered available when Machine's Available condition is true.
	// +optional
	AvailableReplicas *int32 `json:"availableReplicas,omitempty"`

	// upToDateReplicas is the number of up-to-date replicas for this MachineSet. A machine is considered up-to-date when Machine's UpToDate condition is true.
	// +optional
	UpToDateReplicas *int32 `json:"upToDateReplicas,omitempty"`
}

MachineSetV1Beta2Status groups all the fields that will be added or modified in MachineSetStatus with the V1Beta2 version. See https://github.com/kubernetes-sigs/cluster-api/blob/main/docs/proposals/20240916-improve-status-in-CAPI-resources.md for more context.

func (*MachineSetV1Beta2Status) DeepCopy added in v1.9.0 

func (in *MachineSetV1Beta2Status) DeepCopy() *MachineSetV1Beta2Status

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachineSetV1Beta2Status.

func (*MachineSetV1Beta2Status) DeepCopyInto added in v1.9.0 

func (in *MachineSetV1Beta2Status) DeepCopyInto(out *MachineSetV1Beta2Status)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MachineSpec 

type MachineSpec struct {
	// clusterName is the name of the Cluster this object belongs to.
	// +kubebuilder:validation:MinLength=1
	ClusterName string `json:"clusterName"`

	// bootstrap is a reference to a local struct which encapsulates
	// fields to configure the Machine’s bootstrapping mechanism.
	Bootstrap Bootstrap `json:"bootstrap"`

	// infrastructureRef is a required reference to a custom resource
	// offered by an infrastructure provider.
	InfrastructureRef corev1.ObjectReference `json:"infrastructureRef"`

	// version defines the desired Kubernetes version.
	// This field is meant to be optionally used by bootstrap providers.
	// +optional
	Version *string `json:"version,omitempty"`

	// providerID is the identification ID of the machine provided by the provider.
	// This field must match the provider ID as seen on the node object corresponding to this machine.
	// This field is required by higher level consumers of cluster-api. Example use case is cluster autoscaler
	// with cluster-api as provider. Clean-up logic in the autoscaler compares machines to nodes to find out
	// machines at provider which could not get registered as Kubernetes nodes. With cluster-api as a
	// generic out-of-tree provider for autoscaler, this field is required by autoscaler to be
	// able to have a provider view of the list of machines. Another list of nodes is queried from the k8s apiserver
	// and then a comparison is done to find out unregistered machines and are marked for delete.
	// This field will be set by the actuators and consumed by higher level entities like autoscaler that will
	// be interfacing with cluster-api as generic provider.
	// +optional
	ProviderID *string `json:"providerID,omitempty"`

	// failureDomain is the failure domain the machine will be created in.
	// Must match a key in the FailureDomains map stored on the cluster object.
	// +optional
	FailureDomain *string `json:"failureDomain,omitempty"`

	// readinessGates specifies additional conditions to include when evaluating Machine Ready condition.
	//
	// This field can be used e.g. by Cluster API control plane providers to extend the semantic of the
	// Ready condition for the Machine they control, like the kubeadm control provider adding ReadinessGates
	// for the APIServerPodHealthy, SchedulerPodHealthy conditions, etc.
	//
	// Another example are external controllers, e.g. responsible to install special software/hardware on the Machines;
	// they can include the status of those components with a new condition and add this condition to ReadinessGates.
	//
	// NOTE: This field is considered only for computing v1beta2 conditions.
	// NOTE: In case readinessGates conditions start with the APIServer, ControllerManager, Scheduler prefix, and all those
	// readiness gates condition are reporting the same message, when computing the Machine's Ready condition those
	// readinessGates will be replaced by a single entry reporting "Control plane components: " + message.
	// This helps to improve readability of conditions bubbling up to the Machine's owner resource / to the Cluster).
	// +optional
	// +listType=map
	// +listMapKey=conditionType
	// +kubebuilder:validation:MaxItems=32
	ReadinessGates []MachineReadinessGate `json:"readinessGates,omitempty"`

	// nodeDrainTimeout is the total amount of time that the controller will spend on draining a node.
	// The default value is 0, meaning that the node can be drained without any time limitations.
	// NOTE: NodeDrainTimeout is different from `kubectl drain --timeout`
	// +optional
	NodeDrainTimeout *metav1.Duration `json:"nodeDrainTimeout,omitempty"`

	// nodeVolumeDetachTimeout is the total amount of time that the controller will spend on waiting for all volumes
	// to be detached. The default value is 0, meaning that the volumes can be detached without any time limitations.
	// +optional
	NodeVolumeDetachTimeout *metav1.Duration `json:"nodeVolumeDetachTimeout,omitempty"`

	// nodeDeletionTimeout defines how long the controller will attempt to delete the Node that the Machine
	// hosts after the Machine is marked for deletion. A duration of 0 will retry deletion indefinitely.
	// Defaults to 10 seconds.
	// +optional
	NodeDeletionTimeout *metav1.Duration `json:"nodeDeletionTimeout,omitempty"`
}

MachineSpec defines the desired state of Machine.

func (*MachineSpec) DeepCopy 

func (in *MachineSpec) DeepCopy() *MachineSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachineSpec.

func (*MachineSpec) DeepCopyInto 

func (in *MachineSpec) DeepCopyInto(out *MachineSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MachineStatus 

type MachineStatus struct {
	// nodeRef will point to the corresponding Node if it exists.
	// +optional
	NodeRef *corev1.ObjectReference `json:"nodeRef,omitempty"`

	// nodeInfo is a set of ids/uuids to uniquely identify the node.
	// More info: https://kubernetes.io/docs/concepts/nodes/node/#info
	// +optional
	NodeInfo *corev1.NodeSystemInfo `json:"nodeInfo,omitempty"`

	// lastUpdated identifies when the phase of the Machine last transitioned.
	// +optional
	LastUpdated *metav1.Time `json:"lastUpdated,omitempty"`

	// failureReason will be set in the event that there is a terminal problem
	// reconciling the Machine and will contain a succinct value suitable
	// for machine interpretation.
	//
	// This field should not be set for transitive errors that a controller
	// faces that are expected to be fixed automatically over
	// time (like service outages), but instead indicate that something is
	// fundamentally wrong with the Machine's spec or the configuration of
	// the controller, and that manual intervention is required. Examples
	// of terminal errors would be invalid combinations of settings in the
	// spec, values that are unsupported by the controller, or the
	// responsible controller itself being critically misconfigured.
	//
	// Any transient errors that occur during the reconciliation of Machines
	// can be added as events to the Machine object and/or logged in the
	// controller's output.
	//
	// Deprecated: This field is deprecated and is going to be removed in the next apiVersion. Please see https://github.com/kubernetes-sigs/cluster-api/blob/main/docs/proposals/20240916-improve-status-in-CAPI-resources.md for more details.
	//
	// +optional
	FailureReason *capierrors.MachineStatusError `json:"failureReason,omitempty"`

	// failureMessage will be set in the event that there is a terminal problem
	// reconciling the Machine and will contain a more verbose string suitable
	// for logging and human consumption.
	//
	// This field should not be set for transitive errors that a controller
	// faces that are expected to be fixed automatically over
	// time (like service outages), but instead indicate that something is
	// fundamentally wrong with the Machine's spec or the configuration of
	// the controller, and that manual intervention is required. Examples
	// of terminal errors would be invalid combinations of settings in the
	// spec, values that are unsupported by the controller, or the
	// responsible controller itself being critically misconfigured.
	//
	// Any transient errors that occur during the reconciliation of Machines
	// can be added as events to the Machine object and/or logged in the
	// controller's output.
	//
	// Deprecated: This field is deprecated and is going to be removed in the next apiVersion. Please see https://github.com/kubernetes-sigs/cluster-api/blob/main/docs/proposals/20240916-improve-status-in-CAPI-resources.md for more details.
	//
	// +optional
	FailureMessage *string `json:"failureMessage,omitempty"`

	// addresses is a list of addresses assigned to the machine.
	// This field is copied from the infrastructure provider reference.
	// +optional
	Addresses MachineAddresses `json:"addresses,omitempty"`

	// phase represents the current phase of machine actuation.
	// E.g. Pending, Running, Terminating, Failed etc.
	// +optional
	Phase string `json:"phase,omitempty"`

	// certificatesExpiryDate is the expiry date of the machine certificates.
	// This value is only set for control plane machines.
	// +optional
	CertificatesExpiryDate *metav1.Time `json:"certificatesExpiryDate,omitempty"`

	// bootstrapReady is the state of the bootstrap provider.
	// +optional
	BootstrapReady bool `json:"bootstrapReady"`

	// infrastructureReady is the state of the infrastructure provider.
	// +optional
	InfrastructureReady bool `json:"infrastructureReady"`

	// observedGeneration is the latest generation observed by the controller.
	// +optional
	ObservedGeneration int64 `json:"observedGeneration,omitempty"`

	// conditions defines current service state of the Machine.
	// +optional
	Conditions Conditions `json:"conditions,omitempty"`

	// deletion contains information relating to removal of the Machine.
	// Only present when the Machine has a deletionTimestamp and drain or wait for volume detach started.
	// +optional
	Deletion *MachineDeletionStatus `json:"deletion,omitempty"`

	// v1beta2 groups all the fields that will be added or modified in Machine's status with the V1Beta2 version.
	// +optional
	V1Beta2 *MachineV1Beta2Status `json:"v1beta2,omitempty"`
}

MachineStatus defines the observed state of Machine.

func (*MachineStatus) DeepCopy 

func (in *MachineStatus) DeepCopy() *MachineStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachineStatus.

func (*MachineStatus) DeepCopyInto 

func (in *MachineStatus) DeepCopyInto(out *MachineStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*MachineStatus) GetTypedPhase 

func (m *MachineStatus) GetTypedPhase() MachinePhase

GetTypedPhase attempts to parse the Phase field and return the typed MachinePhase representation as described in `machine_phase_types.go`.

func (*MachineStatus) SetTypedPhase 

func (m *MachineStatus) SetTypedPhase(p MachinePhase)

SetTypedPhase sets the Phase field to the string representation of MachinePhase.

type MachineTemplateSpec 

type MachineTemplateSpec struct {
	// Standard object's metadata.
	// More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
	// +optional
	ObjectMeta `json:"metadata,omitempty"`

	// Specification of the desired behavior of the machine.
	// More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status
	// +optional
	Spec MachineSpec `json:"spec,omitempty"`
}

MachineTemplateSpec describes the data needed to create a Machine from a template.

func (*MachineTemplateSpec) DeepCopy 

func (in *MachineTemplateSpec) DeepCopy() *MachineTemplateSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachineTemplateSpec.

func (*MachineTemplateSpec) DeepCopyInto 

func (in *MachineTemplateSpec) DeepCopyInto(out *MachineTemplateSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MachineV1Beta2Status added in v1.9.0 

type MachineV1Beta2Status struct {
	// conditions represents the observations of a Machine's current state.
	// Known condition types are Available, Ready, UpToDate, BootstrapConfigReady, InfrastructureReady, NodeReady,
	// NodeHealthy, Deleting, Paused.
	// If a MachineHealthCheck is targeting this machine, also HealthCheckSucceeded, OwnerRemediated conditions are added.
	// Additionally control plane Machines controlled by KubeadmControlPlane will have following additional conditions:
	// APIServerPodHealthy, ControllerManagerPodHealthy, SchedulerPodHealthy, EtcdPodHealthy, EtcdMemberHealthy.
	// +optional
	// +listType=map
	// +listMapKey=type
	// +kubebuilder:validation:MaxItems=32
	Conditions []metav1.Condition `json:"conditions,omitempty"`
}

MachineV1Beta2Status groups all the fields that will be added or modified in MachineStatus with the V1Beta2 version. See https://github.com/kubernetes-sigs/cluster-api/blob/main/docs/proposals/20240916-improve-status-in-CAPI-resources.md for more context.

func (*MachineV1Beta2Status) DeepCopy added in v1.9.0 

func (in *MachineV1Beta2Status) DeepCopy() *MachineV1Beta2Status

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachineV1Beta2Status.

func (*MachineV1Beta2Status) DeepCopyInto added in v1.9.0 

func (in *MachineV1Beta2Status) DeepCopyInto(out *MachineV1Beta2Status)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type NetworkRanges 

type NetworkRanges struct {
	CIDRBlocks []string `json:"cidrBlocks"`
}

NetworkRanges represents ranges of network addresses.

func (*NetworkRanges) DeepCopy 

func (in *NetworkRanges) DeepCopy() *NetworkRanges

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NetworkRanges.

func (*NetworkRanges) DeepCopyInto 

func (in *NetworkRanges) DeepCopyInto(out *NetworkRanges)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (NetworkRanges) String 

func (n NetworkRanges) String() string

type ObjectMeta 

type ObjectMeta struct {
	// Map of string keys and values that can be used to organize and categorize
	// (scope and select) objects. May match selectors of replication controllers
	// and services.
	// More info: http://kubernetes.io/docs/user-guide/labels
	// +optional
	Labels map[string]string `json:"labels,omitempty"`

	// annotations is an unstructured key value map stored with a resource that may be
	// set by external tools to store and retrieve arbitrary metadata. They are not
	// queryable and should be preserved when modifying objects.
	// More info: http://kubernetes.io/docs/user-guide/annotations
	// +optional
	Annotations map[string]string `json:"annotations,omitempty"`
}

ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create. This is a copy of customizable fields from metav1.ObjectMeta.

ObjectMeta is embedded in `Machine.Spec`, `MachineDeployment.Template` and `MachineSet.Template`, which are not top-level Kubernetes objects. Given that metav1.ObjectMeta has lots of special cases and read-only fields which end up in the generated CRD validation, having it as a subset simplifies the API and some issues that can impact user experience.

During the [upgrade to controller-tools@v2](https://github.com/kubernetes-sigs/cluster-api/pull/1054) for v1alpha2, we noticed a failure would occur running Cluster API test suite against the new CRDs, specifically `spec.metadata.creationTimestamp in body must be of type string: "null"`. The investigation showed that `controller-tools@v2` behaves differently than its previous version when handling types from metav1(k8s.io/apimachinery/pkg/apis/meta/v1) package.

In more details, we found that embedded (non-top level) types that embedded `metav1.ObjectMeta` had validation properties, including for `creationTimestamp` (metav1.Time). The `metav1.Time` type specifies a custom json marshaller that, when IsZero() is true, returns `null` which breaks validation because the field isn't marked as nullable.

In future versions, controller-tools@v2 might allow overriding the type and validation for embedded types. When that happens, this hack should be revisited.

func (*ObjectMeta) DeepCopy 

func (in *ObjectMeta) DeepCopy() *ObjectMeta

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ObjectMeta.

func (*ObjectMeta) DeepCopyInto 

func (in *ObjectMeta) DeepCopyInto(out *ObjectMeta)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ObjectMeta) Validate added in v1.6.0 

func (metadata *ObjectMeta) Validate(parent *field.Path) field.ErrorList

Validate validates the labels and annotations in ObjectMeta.

type PatchDefinition 

type PatchDefinition struct {
	// selector defines on which templates the patch should be applied.
	Selector PatchSelector `json:"selector"`

	// jsonPatches defines the patches which should be applied on the templates
	// matching the selector.
	// Note: Patches will be applied in the order of the array.
	JSONPatches []JSONPatch `json:"jsonPatches"`
}

PatchDefinition defines a patch which is applied to customize the referenced templates.

func (*PatchDefinition) DeepCopy 

func (in *PatchDefinition) DeepCopy() *PatchDefinition

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PatchDefinition.

func (*PatchDefinition) DeepCopyInto 

func (in *PatchDefinition) DeepCopyInto(out *PatchDefinition)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type PatchSelector 

type PatchSelector struct {
	// apiVersion filters templates by apiVersion.
	APIVersion string `json:"apiVersion"`

	// kind filters templates by kind.
	Kind string `json:"kind"`

	// matchResources selects templates based on where they are referenced.
	MatchResources PatchSelectorMatch `json:"matchResources"`
}

PatchSelector defines on which templates the patch should be applied. Note: Matching on APIVersion and Kind is mandatory, to enforce that the patches are written for the correct version. The version of the references in the ClusterClass may be automatically updated during reconciliation if there is a newer version for the same contract. Note: The results of selection based on the individual fields are ANDed.

func (*PatchSelector) DeepCopy 

func (in *PatchSelector) DeepCopy() *PatchSelector

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PatchSelector.

func (*PatchSelector) DeepCopyInto 

func (in *PatchSelector) DeepCopyInto(out *PatchSelector)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type PatchSelectorMatch 

type PatchSelectorMatch struct {
	// controlPlane selects templates referenced in .spec.ControlPlane.
	// Note: this will match the controlPlane and also the controlPlane
	// machineInfrastructure (depending on the kind and apiVersion).
	// +optional
	ControlPlane bool `json:"controlPlane,omitempty"`

	// infrastructureCluster selects templates referenced in .spec.infrastructure.
	// +optional
	InfrastructureCluster bool `json:"infrastructureCluster,omitempty"`

	// machineDeploymentClass selects templates referenced in specific MachineDeploymentClasses in
	// .spec.workers.machineDeployments.
	// +optional
	MachineDeploymentClass *PatchSelectorMatchMachineDeploymentClass `json:"machineDeploymentClass,omitempty"`

	// machinePoolClass selects templates referenced in specific MachinePoolClasses in
	// .spec.workers.machinePools.
	// +optional
	MachinePoolClass *PatchSelectorMatchMachinePoolClass `json:"machinePoolClass,omitempty"`
}

PatchSelectorMatch selects templates based on where they are referenced. Note: The selector must match at least one template. Note: The results of selection based on the individual fields are ORed.

func (*PatchSelectorMatch) DeepCopy 

func (in *PatchSelectorMatch) DeepCopy() *PatchSelectorMatch

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PatchSelectorMatch.

func (*PatchSelectorMatch) DeepCopyInto 

func (in *PatchSelectorMatch) DeepCopyInto(out *PatchSelectorMatch)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type PatchSelectorMatchMachineDeploymentClass 

type PatchSelectorMatchMachineDeploymentClass struct {
	// names selects templates by class names.
	// +optional
	Names []string `json:"names,omitempty"`
}

PatchSelectorMatchMachineDeploymentClass selects templates referenced in specific MachineDeploymentClasses in .spec.workers.machineDeployments.

func (*PatchSelectorMatchMachineDeploymentClass) DeepCopy 

func (in *PatchSelectorMatchMachineDeploymentClass) DeepCopy() *PatchSelectorMatchMachineDeploymentClass

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PatchSelectorMatchMachineDeploymentClass.

func (*PatchSelectorMatchMachineDeploymentClass) DeepCopyInto 

func (in *PatchSelectorMatchMachineDeploymentClass) DeepCopyInto(out *PatchSelectorMatchMachineDeploymentClass)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type PatchSelectorMatchMachinePoolClass added in v1.6.0 

type PatchSelectorMatchMachinePoolClass struct {
	// names selects templates by class names.
	// +optional
	Names []string `json:"names,omitempty"`
}

PatchSelectorMatchMachinePoolClass selects templates referenced in specific MachinePoolClasses in .spec.workers.machinePools.

func (*PatchSelectorMatchMachinePoolClass) DeepCopy added in v1.6.0 

func (in *PatchSelectorMatchMachinePoolClass) DeepCopy() *PatchSelectorMatchMachinePoolClass

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PatchSelectorMatchMachinePoolClass.

func (*PatchSelectorMatchMachinePoolClass) DeepCopyInto added in v1.6.0 

func (in *PatchSelectorMatchMachinePoolClass) DeepCopyInto(out *PatchSelectorMatchMachinePoolClass)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type RemediationStrategy added in v1.7.4 

type RemediationStrategy struct {
	// maxInFlight determines how many in flight remediations should happen at the same time.
	//
	// Remediation only happens on the MachineSet with the most current revision, while
	// older MachineSets (usually present during rollout operations) aren't allowed to remediate.
	//
	// Note: In general (independent of remediations), unhealthy machines are always
	// prioritized during scale down operations over healthy ones.
	//
	// MaxInFlight can be set to a fixed number or a percentage.
	// Example: when this is set to 20%, the MachineSet controller deletes at most 20% of
	// the desired replicas.
	//
	// If not set, remediation is limited to all machines (bounded by replicas)
	// under the active MachineSet's management.
	//
	// +optional
	MaxInFlight *intstr.IntOrString `json:"maxInFlight,omitempty"`
}

RemediationStrategy allows to define how the MachineSet can control scaling operations.

func (*RemediationStrategy) DeepCopy added in v1.7.4 

func (in *RemediationStrategy) DeepCopy() *RemediationStrategy

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RemediationStrategy.

func (*RemediationStrategy) DeepCopyInto added in v1.7.4 

func (in *RemediationStrategy) DeepCopyInto(out *RemediationStrategy)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type Topology 

type Topology struct {
	// The name of the ClusterClass object to create the topology.
	Class string `json:"class"`

	// The Kubernetes version of the cluster.
	Version string `json:"version"`

	// rolloutAfter performs a rollout of the entire cluster one component at a time,
	// control plane first and then machine deployments.
	//
	// Deprecated: This field has no function and is going to be removed in the next apiVersion.
	//
	// +optional
	RolloutAfter *metav1.Time `json:"rolloutAfter,omitempty"`

	// controlPlane describes the cluster control plane.
	// +optional
	ControlPlane ControlPlaneTopology `json:"controlPlane,omitempty"`

	// workers encapsulates the different constructs that form the worker nodes
	// for the cluster.
	// +optional
	Workers *WorkersTopology `json:"workers,omitempty"`

	// variables can be used to customize the Cluster through
	// patches. They must comply to the corresponding
	// VariableClasses defined in the ClusterClass.
	// +optional
	// +listType=map
	// +listMapKey=name
	Variables []ClusterVariable `json:"variables,omitempty"`
}

Topology encapsulates the information of the managed resources.

func (*Topology) DeepCopy 

func (in *Topology) DeepCopy() *Topology

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Topology.

func (*Topology) DeepCopyInto 

func (in *Topology) DeepCopyInto(out *Topology)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type UnhealthyCondition 

type UnhealthyCondition struct {
	// +kubebuilder:validation:Type=string
	// +kubebuilder:validation:MinLength=1
	Type corev1.NodeConditionType `json:"type"`

	// +kubebuilder:validation:Type=string
	// +kubebuilder:validation:MinLength=1
	Status corev1.ConditionStatus `json:"status"`

	Timeout metav1.Duration `json:"timeout"`
}

UnhealthyCondition represents a Node condition type and value with a timeout specified as a duration. When the named condition has been in the given status for at least the timeout value, a node is considered unhealthy.

func (*UnhealthyCondition) DeepCopy 

func (in *UnhealthyCondition) DeepCopy() *UnhealthyCondition

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new UnhealthyCondition.

func (*UnhealthyCondition) DeepCopyInto 

func (in *UnhealthyCondition) DeepCopyInto(out *UnhealthyCondition)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ValidationRule added in v1.8.0 

type ValidationRule struct {
	// rule represents the expression which will be evaluated by CEL.
	// ref: https://github.com/google/cel-spec
	// The Rule is scoped to the location of the x-kubernetes-validations extension in the schema.
	// The `self` variable in the CEL expression is bound to the scoped value.
	// If the Rule is scoped to an object with properties, the accessible properties of the object are field selectable
	// via `self.field` and field presence can be checked via `has(self.field)`.
	// If the Rule is scoped to an object with additionalProperties (i.e. a map) the value of the map
	// are accessible via `self[mapKey]`, map containment can be checked via `mapKey in self` and all entries of the map
	// are accessible via CEL macros and functions such as `self.all(...)`.
	// If the Rule is scoped to an array, the elements of the array are accessible via `self[i]` and also by macros and
	// functions.
	// If the Rule is scoped to a scalar, `self` is bound to the scalar value.
	// Examples:
	// - Rule scoped to a map of objects: {"rule": "self.components['Widget'].priority < 10"}
	// - Rule scoped to a list of integers: {"rule": "self.values.all(value, value >= 0 && value < 100)"}
	// - Rule scoped to a string value: {"rule": "self.startsWith('kube')"}
	//
	// Unknown data preserved in custom resources via x-kubernetes-preserve-unknown-fields is not accessible in CEL
	// expressions. This includes:
	// - Unknown field values that are preserved by object schemas with x-kubernetes-preserve-unknown-fields.
	// - Object properties where the property schema is of an "unknown type". An "unknown type" is recursively defined as:
	//   - A schema with no type and x-kubernetes-preserve-unknown-fields set to true
	//   - An array where the items schema is of an "unknown type"
	//   - An object where the additionalProperties schema is of an "unknown type"
	//
	// Only property names of the form `[a-zA-Z_.-/][a-zA-Z0-9_.-/]*` are accessible.
	// Accessible property names are escaped according to the following rules when accessed in the expression:
	// - '__' escapes to '__underscores__'
	// - '.' escapes to '__dot__'
	// - '-' escapes to '__dash__'
	// - '/' escapes to '__slash__'
	// - Property names that exactly match a CEL RESERVED keyword escape to '__{keyword}__'. The keywords are:
	//	  "true", "false", "null", "in", "as", "break", "const", "continue", "else", "for", "function", "if",
	//	  "import", "let", "loop", "package", "namespace", "return".
	// Examples:
	//   - Rule accessing a property named "namespace": {"rule": "self.__namespace__ > 0"}
	//   - Rule accessing a property named "x-prop": {"rule": "self.x__dash__prop > 0"}
	//   - Rule accessing a property named "redact__d": {"rule": "self.redact__underscores__d > 0"}
	//
	//
	// If `rule` makes use of the `oldSelf` variable it is implicitly a
	// `transition rule`.
	//
	// By default, the `oldSelf` variable is the same type as `self`.
	//
	// Transition rules by default are applied only on UPDATE requests and are
	// skipped if an old value could not be found.
	//
	// +required
	Rule string `json:"rule"`
	// message represents the message displayed when validation fails. The message is required if the Rule contains
	// line breaks. The message must not contain line breaks.
	// If unset, the message is "failed rule: {Rule}".
	// e.g. "must be a URL with the host matching spec.host"
	// +optional
	Message string `json:"message,omitempty"`
	// messageExpression declares a CEL expression that evaluates to the validation failure message that is returned when this rule fails.
	// Since messageExpression is used as a failure message, it must evaluate to a string.
	// If both message and messageExpression are present on a rule, then messageExpression will be used if validation
	// fails. If messageExpression results in a runtime error, the validation failure message is produced
	// as if the messageExpression field were unset. If messageExpression evaluates to an empty string, a string with only spaces, or a string
	// that contains line breaks, then the validation failure message will also be produced as if the messageExpression field were unset.
	// messageExpression has access to all the same variables as the rule; the only difference is the return type.
	// Example:
	// "x must be less than max ("+string(self.max)+")"
	// +optional
	MessageExpression string `json:"messageExpression,omitempty"`
	// reason provides a machine-readable validation failure reason that is returned to the caller when a request fails this validation rule.
	// The currently supported reasons are: "FieldValueInvalid", "FieldValueForbidden", "FieldValueRequired", "FieldValueDuplicate".
	// If not set, default to use "FieldValueInvalid".
	// All future added reasons must be accepted by clients when reading this value and unknown reasons should be treated as FieldValueInvalid.
	// +optional
	// +kubebuilder:validation:Enum=FieldValueInvalid;FieldValueForbidden;FieldValueRequired;FieldValueDuplicate
	// +kubebuilder:default=FieldValueInvalid
	// +default=ref(sigs.k8s.io/cluster-api/api/v1beta1.FieldValueInvalid)
	Reason FieldValueErrorReason `json:"reason,omitempty"`
	// fieldPath represents the field path returned when the validation fails.
	// It must be a relative JSON path (i.e. with array notation) scoped to the location of this x-kubernetes-validations extension in the schema and refer to an existing field.
	// e.g. when validation checks if a specific attribute `foo` under a map `testMap`, the fieldPath could be set to `.testMap.foo`
	// If the validation checks two lists must have unique attributes, the fieldPath could be set to either of the list: e.g. `.testList`
	// It does not support list numeric index.
	// It supports child operation to refer to an existing field currently. Refer to [JSONPath support in Kubernetes](https://kubernetes.io/docs/reference/kubectl/jsonpath/) for more info.
	// Numeric index of array is not supported.
	// For field name which contains special characters, use `['specialName']` to refer the field name.
	// e.g. for attribute `foo.34$` appears in a list `testList`, the fieldPath could be set to `.testList['foo.34$']`
	// +optional
	FieldPath string `json:"fieldPath,omitempty"`
}

ValidationRule describes a validation rule written in the CEL expression language.

func (*ValidationRule) DeepCopy added in v1.8.0 

func (in *ValidationRule) DeepCopy() *ValidationRule

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ValidationRule.

func (*ValidationRule) DeepCopyInto added in v1.8.0 

func (in *ValidationRule) DeepCopyInto(out *ValidationRule)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VariableSchema 

type VariableSchema struct {
	// openAPIV3Schema defines the schema of a variable via OpenAPI v3
	// schema. The schema is a subset of the schema used in
	// Kubernetes CRDs.
	OpenAPIV3Schema JSONSchemaProps `json:"openAPIV3Schema"`
}

VariableSchema defines the schema of a variable.

func (*VariableSchema) DeepCopy 

func (in *VariableSchema) DeepCopy() *VariableSchema

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VariableSchema.

func (*VariableSchema) DeepCopyInto 

func (in *VariableSchema) DeepCopyInto(out *VariableSchema)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VariableSchemaMetadata added in v1.8.0 

type VariableSchemaMetadata struct {
	// Map of string keys and values that can be used to organize and categorize
	// (scope and select) variables.
	// +optional
	Labels map[string]string `json:"labels,omitempty"`

	// annotations is an unstructured key value map that can be used to store and
	// retrieve arbitrary metadata.
	// They are not queryable.
	// +optional
	Annotations map[string]string `json:"annotations,omitempty"`
}

VariableSchemaMetadata is the metadata of a variable or a nested field within a variable. It can be used to add additional data for higher level tools.

func (*VariableSchemaMetadata) DeepCopy added in v1.8.0 

func (in *VariableSchemaMetadata) DeepCopy() *VariableSchemaMetadata

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VariableSchemaMetadata.

func (*VariableSchemaMetadata) DeepCopyInto added in v1.8.0 

func (in *VariableSchemaMetadata) DeepCopyInto(out *VariableSchemaMetadata)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type WorkersClass 

type WorkersClass struct {
	// machineDeployments is a list of machine deployment classes that can be used to create
	// a set of worker nodes.
	// +optional
	// +listType=map
	// +listMapKey=class
	MachineDeployments []MachineDeploymentClass `json:"machineDeployments,omitempty"`

	// machinePools is a list of machine pool classes that can be used to create
	// a set of worker nodes.
	// +optional
	// +listType=map
	// +listMapKey=class
	MachinePools []MachinePoolClass `json:"machinePools,omitempty"`
}

WorkersClass is a collection of deployment classes.

func (*WorkersClass) DeepCopy 

func (in *WorkersClass) DeepCopy() *WorkersClass

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new WorkersClass.

func (*WorkersClass) DeepCopyInto 

func (in *WorkersClass) DeepCopyInto(out *WorkersClass)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type WorkersStatus added in v1.9.0 

type WorkersStatus struct {
	// desiredReplicas is the total number of desired worker machines in this cluster.
	// +optional
	DesiredReplicas *int32 `json:"desiredReplicas,omitempty"`

	// replicas is the total number of worker machines in this cluster.
	// NOTE: replicas also includes machines still being provisioned or being deleted.
	// +optional
	Replicas *int32 `json:"replicas,omitempty"`

	// upToDateReplicas is the number of up-to-date worker machines in this cluster. A machine is considered up-to-date when Machine's UpToDate condition is true.
	// +optional
	UpToDateReplicas *int32 `json:"upToDateReplicas,omitempty"`

	// readyReplicas is the total number of ready worker machines in this cluster. A machine is considered ready when Machine's Ready condition is true.
	// +optional
	ReadyReplicas *int32 `json:"readyReplicas,omitempty"`

	// availableReplicas is the total number of available worker machines in this cluster. A machine is considered available when Machine's Available condition is true.
	// +optional
	AvailableReplicas *int32 `json:"availableReplicas,omitempty"`
}

WorkersStatus groups all the observations about workers current state.

func (*WorkersStatus) DeepCopy added in v1.9.0 

func (in *WorkersStatus) DeepCopy() *WorkersStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new WorkersStatus.

func (*WorkersStatus) DeepCopyInto added in v1.9.0 

func (in *WorkersStatus) DeepCopyInto(out *WorkersStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type WorkersTopology 

type WorkersTopology struct {
	// machineDeployments is a list of machine deployments in the cluster.
	// +optional
	// +listType=map
	// +listMapKey=name
	MachineDeployments []MachineDeploymentTopology `json:"machineDeployments,omitempty"`

	// machinePools is a list of machine pools in the cluster.
	// +optional
	// +listType=map
	// +listMapKey=name
	MachinePools []MachinePoolTopology `json:"machinePools,omitempty"`
}

WorkersTopology represents the different sets of worker nodes in the cluster.

func (*WorkersTopology) DeepCopy 

func (in *WorkersTopology) DeepCopy() *WorkersTopology

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new WorkersTopology.

func (*WorkersTopology) DeepCopyInto 

func (in *WorkersTopology) DeepCopyInto(out *WorkersTopology)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

Source Files

View all Source files

Directories

Path Synopsis
Package index provides indexes for the api.
 Package index provides indexes for the api.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.