Documentation

Overview

    Package v1alpha3 contains API Schema definitions for the cluster v1alpha3 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 provider infrastructure
    	// object associated and can start provisioning.
    	ClusterPhaseProvisioning = ClusterPhase("Provisioning")
    
    	// ClusterPhaseProvisioned is the state when its
    	// infrastructure has been created and configured.
    	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 (
    	// ClusterLabelName is the label set on machines linked to a cluster and
    	// external objects(bootstrap and infrastructure providers)
    	ClusterLabelName = "cluster.x-k8s.io/cluster-name"
    
    	// ProviderLabelName 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.
    	ProviderLabelName = "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"
    
    	// 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"
    
    	// 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"
    
    	// ClusterSecretType defines the type of secret created by core components
    	ClusterSecretType corev1.SecretType = "cluster.x-k8s.io/secret" //nolint:gosec
    )
    View Source
    const (
    	// DeletingReason (Severity=Info) documents an condition not in Status=True because the underlying object it is currently being deleted.
    	DeletingReason = "Deleting"
    
    	// DeletionFailedReason (Severity=Warning) documents an 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 an condition not in Status=True because the underlying object was deleted.
    	DeletedReason = "Deleted"
    )

      Common ConditionReason used by Cluster API objects.

      View Source
      const (
      	// ControlPlaneReady 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 not implements 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"
      )
      View Source
      const (
      	// MachineHealthCheckSuccededCondition 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.
      	MachineHealthCheckSuccededCondition ConditionType = "HealthCheckSucceeded"
      
      	// MachineHasFailureReason is the reason used when a machine has either a FailureReason or a FailureMessage set on its status.
      	MachineHasFailureReason = "MachineHasFailure"
      
      	// 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"
      
      	// ExternalRemediationTemplateAvailable is set on machinehealthchecks when MachineHealthCheck controller uses external remediation.
      	// ExternalRemediationTemplateAvailable is set to false if external remediation template is not found.
      	ExternalRemediationTemplateAvailable ConditionType = "ExternalRemediationTemplateAvailable"
      
      	// ExternalRemediationTemplateNotFound is the reason used when a machine health check fails to find external remediation template.
      	ExternalRemediationTemplateNotFound = "ExternalRemediationTemplateNotFound"
      
      	// ExternalRemediationRequestAvailable is set on machinehealthchecks when MachineHealthCheck controller uses external remediation.
      	// ExternalRemediationRequestAvailable is set to false if creating external remediation request fails.
      	ExternalRemediationRequestAvailable ConditionType = "ExternalRemediationRequestAvailable"
      
      	// ExternalRemediationRequestCreationFailed is the reason used when a machine health check fails to create external remediation request.
      	ExternalRemediationRequestCreationFailed = "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, NodePIDPressure, and NodeNetworkUnavailable) 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"
      )

        Conditions and condition Reasons for the Machine's Node object

        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"
        
        	// MachineControlPlaneLabelName is the label set on machines or related objects that are part of a control plane.
        	MachineControlPlaneLabelName = "cluster.x-k8s.io/control-plane"
        
        	// ExcludeNodeDrainingAnnotation annotation explicitly skips node draining if set
        	ExcludeNodeDrainingAnnotation = "machine.cluster.x-k8s.io/exclude-node-draining"
        
        	// MachineSetLabelName is the label set on machines if they're controlled by MachineSet
        	MachineSetLabelName = "cluster.x-k8s.io/set-name"
        
        	// MachineDeploymentLabelName is the label set on machines if they're controlled by MachineDeployment
        	MachineDeploymentLabelName = "cluster.x-k8s.io/deployment-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.
        	PreTerminateDeleteHookAnnotationPrefix = "pre-terminate.delete.hook.machine.cluster.x-k8s.io"
        )
        View Source
        const (
        	// Replace 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"
        
        	// 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.
        	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"
        )
        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 (
        	ClusterFinalizer = "cluster.cluster.x-k8s.io"
        )

        Variables

        View Source
        var (
        	// GroupVersion is group version used to register these objects
        	GroupVersion = schema.GroupVersion{Group: "cluster.x-k8s.io", Version: "v1alpha3"}
        
        	// SchemeBuilder is used to add go types to the GroupVersionKind scheme
        	SchemeBuilder = &scheme.Builder{GroupVersion: GroupVersion}
        
        	// AddToScheme adds the types in this group-version to the given scheme.
        	AddToScheme = SchemeBuilder.AddToScheme
        )

        Functions

        func PopulateDefaultsMachineDeployment

        func PopulateDefaultsMachineDeployment(d *MachineDeployment)

          PopulateDefaultsMachineDeployment fills in default field values. This is also called during MachineDeployment sync.

          func SetMinNodeStartupTimeout

          func SetMinNodeStartupTimeout(d metav1.Duration)

            SetMinNodeStartupTimeout allows users to optionally set a custom timeout for the validation webhook.

            This function is mostly used within envtest (integration tests), and should never be used in a production environment.

            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.Data without
                        	// the need of a controller.
                        	// +optional
                        	ConfigRef *corev1.ObjectReference `json:"configRef,omitempty"`
                        
                        	// Data contains the bootstrap data, such as cloud-init details scripts.
                        	// If nil, the Machine should remain in the Pending state.
                        	//
                        	// Deprecated: This field has been deprecated in v1alpha3 and
                        	// will be removed in a future version. Switch to DataSecretName.
                        	//
                        	// +optional
                        	Data *string `json:"data,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 capsulates 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) Default

                                      func (c *Cluster) Default()

                                      func (*Cluster) GetConditions

                                      func (c *Cluster) GetConditions() Conditions

                                      func (*Cluster) Hub

                                      func (*Cluster) Hub()

                                      func (*Cluster) SetConditions

                                      func (c *Cluster) SetConditions(conditions Conditions)

                                      func (*Cluster) SetupWebhookWithManager

                                      func (c *Cluster) SetupWebhookWithManager(mgr ctrl.Manager) error

                                      func (*Cluster) ValidateCreate

                                      func (c *Cluster) ValidateCreate() error

                                        ValidateCreate implements webhook.Validator so a webhook will be registered for the type

                                        func (*Cluster) ValidateDelete

                                        func (c *Cluster) ValidateDelete() error

                                          ValidateDelete implements webhook.Validator so a webhook will be registered for the type

                                          func (*Cluster) ValidateUpdate

                                          func (c *Cluster) ValidateUpdate(old runtime.Object) error

                                            ValidateUpdate implements webhook.Validator so a webhook will be registered for the type

                                            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"`
                                                            
                                                            	// 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"`
                                                            }

                                                              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.
                                                                  	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.
                                                                  	// +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.
                                                                  	// +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"`
                                                                  
                                                                  	// ControlPlaneInitialized defines if the control plane has been initialized.
                                                                  	// +optional
                                                                  	ControlPlaneInitialized bool `json:"controlPlaneInitialized"`
                                                                  
                                                                  	// ControlPlaneReady defines if the control plane is ready.
                                                                  	// +optional
                                                                  	ControlPlaneReady bool `json:"controlPlaneReady,omitempty"`
                                                                  
                                                                  	// 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"`
                                                                  }

                                                                    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 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.
                                                                            	// +required
                                                                            	Type ConditionType `json:"type"`
                                                                            
                                                                            	// Status of the condition, one of True, False, Unknown.
                                                                            	// +required
                                                                            	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.
                                                                            	// +required
                                                                            	LastTransitionTime metav1.Time `json:"lastTransitionTime,omitempty"`
                                                                            
                                                                            	// 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 not 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 (
                                                                                      	// 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"
                                                                                      
                                                                                      	// TooManyUnhealthy 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 FailureDomainSpec

                                                                                              type FailureDomainSpec struct {
                                                                                              	// ControlPlane determines if this failure domain is suitable for use by control plane machines.
                                                                                              	// +optional
                                                                                              	ControlPlane bool `json:"controlPlane"`
                                                                                              
                                                                                              	// 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 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) Default

                                                                                                                      func (m *Machine) Default()

                                                                                                                        Default implements webhook.Defaulter so a webhook will be registered for the type

                                                                                                                        func (*Machine) GetConditions

                                                                                                                        func (m *Machine) GetConditions() Conditions

                                                                                                                        func (*Machine) Hub

                                                                                                                        func (*Machine) Hub()

                                                                                                                        func (*Machine) SetConditions

                                                                                                                        func (m *Machine) SetConditions(conditions Conditions)

                                                                                                                        func (*Machine) SetupWebhookWithManager

                                                                                                                        func (m *Machine) SetupWebhookWithManager(mgr ctrl.Manager) error

                                                                                                                        func (*Machine) ValidateCreate

                                                                                                                        func (m *Machine) ValidateCreate() error

                                                                                                                          ValidateCreate implements webhook.Validator so a webhook will be registered for the type

                                                                                                                          func (*Machine) ValidateDelete

                                                                                                                          func (m *Machine) ValidateDelete() error

                                                                                                                            ValidateDelete implements webhook.Validator so a webhook will be registered for the type

                                                                                                                            func (*Machine) ValidateUpdate

                                                                                                                            func (m *Machine) ValidateUpdate(old runtime.Object) error

                                                                                                                              ValidateUpdate implements webhook.Validator so a webhook will be registered for the type

                                                                                                                              type MachineAddress

                                                                                                                              type MachineAddress struct {
                                                                                                                              	// Machine address type, one of Hostname, ExternalIP or InternalIP.
                                                                                                                              	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"
                                                                                                                                      
                                                                                                                                      	// MachineNodeNameIndex is used by the Machine Controller to index Machines by Node name, and add a watch on Nodes.
                                                                                                                                      	MachineNodeNameIndex = "status.nodeRef.name"
                                                                                                                                      )

                                                                                                                                      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 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) Default

                                                                                                                                                    func (m *MachineDeployment) Default()

                                                                                                                                                      Default implements webhook.Defaulter so a webhook will be registered for the type

                                                                                                                                                      func (*MachineDeployment) Hub

                                                                                                                                                      func (*MachineDeployment) Hub()

                                                                                                                                                      func (*MachineDeployment) SetupWebhookWithManager

                                                                                                                                                      func (m *MachineDeployment) SetupWebhookWithManager(mgr ctrl.Manager) error

                                                                                                                                                      func (*MachineDeployment) ValidateCreate

                                                                                                                                                      func (m *MachineDeployment) ValidateCreate() error

                                                                                                                                                        ValidateCreate implements webhook.Validator so a webhook will be registered for the type

                                                                                                                                                        func (*MachineDeployment) ValidateDelete

                                                                                                                                                        func (m *MachineDeployment) ValidateDelete() error

                                                                                                                                                          ValidateDelete implements webhook.Validator so a webhook will be registered for the type

                                                                                                                                                          func (*MachineDeployment) ValidateUpdate

                                                                                                                                                          func (m *MachineDeployment) ValidateUpdate(old runtime.Object) error

                                                                                                                                                            ValidateUpdate implements webhook.Validator so a webhook will be registered for the type

                                                                                                                                                            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

                                                                                                                                                                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. Defaults to 1.
                                                                                                                                                                      	// This is a pointer to distinguish between explicit zero and not specified.
                                                                                                                                                                      	Replicas *int32 `json:"replicas,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"`
                                                                                                                                                                      
                                                                                                                                                                      	// 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 number of old MachineSets to retain to allow rollback.
                                                                                                                                                                      	// This is a pointer to distinguish between explicit zero and not specified.
                                                                                                                                                                      	// Defaults to 1.
                                                                                                                                                                      	// +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.
                                                                                                                                                                      	ProgressDeadlineSeconds *int32 `json:"progressDeadlineSeconds,omitempty"`
                                                                                                                                                                      }

                                                                                                                                                                        MachineDeploymentSpec defines the desired state of MachineDeployment

                                                                                                                                                                        func (*MachineDeploymentSpec) DeepCopy

                                                                                                                                                                          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,omitempty"`
                                                                                                                                                                            
                                                                                                                                                                            	// Total number of non-terminated machines targeted by this deployment
                                                                                                                                                                            	// that have the desired template spec.
                                                                                                                                                                            	// +optional
                                                                                                                                                                            	UpdatedReplicas int32 `json:"updatedReplicas,omitempty"`
                                                                                                                                                                            
                                                                                                                                                                            	// Total number of ready machines targeted by this deployment.
                                                                                                                                                                            	// +optional
                                                                                                                                                                            	ReadyReplicas int32 `json:"readyReplicas,omitempty"`
                                                                                                                                                                            
                                                                                                                                                                            	// Total number of available machines (ready for at least minReadySeconds)
                                                                                                                                                                            	// targeted by this deployment.
                                                                                                                                                                            	// +optional
                                                                                                                                                                            	AvailableReplicas int32 `json:"availableReplicas,omitempty"`
                                                                                                                                                                            
                                                                                                                                                                            	// 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.
                                                                                                                                                                            	// +optional
                                                                                                                                                                            	UnavailableReplicas int32 `json:"unavailableReplicas,omitempty"`
                                                                                                                                                                            
                                                                                                                                                                            	// Phase represents the current phase of a MachineDeployment (ScalingUp, ScalingDown, Running, Failed, or Unknown).
                                                                                                                                                                            	// +optional
                                                                                                                                                                            	Phase string `json:"phase,omitempty"`
                                                                                                                                                                            }

                                                                                                                                                                              MachineDeploymentStatus defines the observed state of MachineDeployment

                                                                                                                                                                              func (*MachineDeploymentStatus) DeepCopy

                                                                                                                                                                                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. Currently the only supported strategy is
                                                                                                                                                                                      	// "RollingUpdate".
                                                                                                                                                                                      	// Default is RollingUpdate.
                                                                                                                                                                                      	// +optional
                                                                                                                                                                                      	Type MachineDeploymentStrategyType `json:"type,omitempty"`
                                                                                                                                                                                      
                                                                                                                                                                                      	// Rolling update config params. Present only if
                                                                                                                                                                                      	// MachineDeploymentStrategyType = RollingUpdate.
                                                                                                                                                                                      	// +optional
                                                                                                                                                                                      	RollingUpdate *MachineRollingUpdateDeployment `json:"rollingUpdate,omitempty"`
                                                                                                                                                                                      }

                                                                                                                                                                                        MachineDeploymentStrategy describes how to replace existing machines with new ones.

                                                                                                                                                                                        func (*MachineDeploymentStrategy) DeepCopy

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

                                                                                                                                                                                          func (*MachineDeploymentStrategy) DeepCopyInto

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

                                                                                                                                                                                            type MachineDeploymentStrategyType

                                                                                                                                                                                            type MachineDeploymentStrategyType string

                                                                                                                                                                                            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) Default

                                                                                                                                                                                                    func (m *MachineHealthCheck) Default()

                                                                                                                                                                                                      Default implements webhook.Defaulter so a webhook will be registered for the type

                                                                                                                                                                                                      func (*MachineHealthCheck) GetConditions

                                                                                                                                                                                                      func (m *MachineHealthCheck) GetConditions() Conditions

                                                                                                                                                                                                      func (*MachineHealthCheck) Hub

                                                                                                                                                                                                      func (*MachineHealthCheck) Hub()

                                                                                                                                                                                                      func (*MachineHealthCheck) SetConditions

                                                                                                                                                                                                      func (m *MachineHealthCheck) SetConditions(conditions Conditions)

                                                                                                                                                                                                      func (*MachineHealthCheck) SetupWebhookWithManager

                                                                                                                                                                                                      func (m *MachineHealthCheck) SetupWebhookWithManager(mgr ctrl.Manager) error

                                                                                                                                                                                                      func (*MachineHealthCheck) ValidateCreate

                                                                                                                                                                                                      func (m *MachineHealthCheck) ValidateCreate() error

                                                                                                                                                                                                        ValidateCreate implements webhook.Validator so a webhook will be registered for the type

                                                                                                                                                                                                        func (*MachineHealthCheck) ValidateDelete

                                                                                                                                                                                                        func (m *MachineHealthCheck) ValidateDelete() error

                                                                                                                                                                                                          ValidateDelete implements webhook.Validator so a webhook will be registered for the type

                                                                                                                                                                                                          func (*MachineHealthCheck) ValidateUpdate

                                                                                                                                                                                                          func (m *MachineHealthCheck) ValidateUpdate(old runtime.Object) error

                                                                                                                                                                                                            ValidateUpdate implements webhook.Validator so a webhook will be registered for the type

                                                                                                                                                                                                            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

                                                                                                                                                                                                                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.
                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                    	// +kubebuilder:validation:MinItems=1
                                                                                                                                                                                                                    	UnhealthyConditions []UnhealthyCondition `json:"unhealthyConditions"`
                                                                                                                                                                                                                    
                                                                                                                                                                                                                    	// Any further remediation is only allowed if at most "MaxUnhealthy" machines selected by
                                                                                                                                                                                                                    	// "selector" are not healthy.
                                                                                                                                                                                                                    	// +optional
                                                                                                                                                                                                                    	MaxUnhealthy *intstr.IntOrString `json:"maxUnhealthy,omitempty"`
                                                                                                                                                                                                                    
                                                                                                                                                                                                                    	// Machines older than this duration without a node will be considered to have
                                                                                                                                                                                                                    	// failed and will be remediated.
                                                                                                                                                                                                                    	// +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

                                                                                                                                                                                                                        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
                                                                                                                                                                                                                          	ExpectedMachines int32 `json:"expectedMachines,omitempty"`
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          	// total number of healthy machines counted by this machine health check
                                                                                                                                                                                                                          	// +kubebuilder:validation:Minimum=0
                                                                                                                                                                                                                          	CurrentHealthy int32 `json:"currentHealthy,omitempty"`
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          	// RemediationsAllowed is the number of further remediations allowed by this machine health check before
                                                                                                                                                                                                                          	// maxUnhealthy short circuiting will be applied
                                                                                                                                                                                                                          	// +kubebuilder:validation:Minimum=0
                                                                                                                                                                                                                          	RemediationsAllowed int32 `json:"remediationsAllowed,omitempty"`
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          	// 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"`
                                                                                                                                                                                                                          }

                                                                                                                                                                                                                            MachineHealthCheckStatus defines the observed state of MachineHealthCheck

                                                                                                                                                                                                                            func (*MachineHealthCheckStatus) DeepCopy

                                                                                                                                                                                                                              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 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 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"`
                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                            MachineRollingUpdateDeployment is used to control the desired behavior of rolling update.

                                                                                                                                                                                                                                            func (*MachineRollingUpdateDeployment) DeepCopy

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

                                                                                                                                                                                                                                              func (*MachineRollingUpdateDeployment) DeepCopyInto

                                                                                                                                                                                                                                                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) Default

                                                                                                                                                                                                                                                        func (m *MachineSet) Default()

                                                                                                                                                                                                                                                          DefaultingFunction sets default MachineSet field values.

                                                                                                                                                                                                                                                          func (*MachineSet) Hub

                                                                                                                                                                                                                                                          func (*MachineSet) Hub()

                                                                                                                                                                                                                                                          func (*MachineSet) SetupWebhookWithManager

                                                                                                                                                                                                                                                          func (m *MachineSet) SetupWebhookWithManager(mgr ctrl.Manager) error

                                                                                                                                                                                                                                                          func (*MachineSet) Validate

                                                                                                                                                                                                                                                          func (m *MachineSet) Validate() field.ErrorList

                                                                                                                                                                                                                                                            Validate validates the MachineSet fields.

                                                                                                                                                                                                                                                            func (*MachineSet) ValidateCreate

                                                                                                                                                                                                                                                            func (m *MachineSet) ValidateCreate() error

                                                                                                                                                                                                                                                              ValidateCreate implements webhook.Validator so a webhook will be registered for the type

                                                                                                                                                                                                                                                              func (*MachineSet) ValidateDelete

                                                                                                                                                                                                                                                              func (m *MachineSet) ValidateDelete() error

                                                                                                                                                                                                                                                                ValidateDelete implements webhook.Validator so a webhook will be registered for the type

                                                                                                                                                                                                                                                                func (*MachineSet) ValidateUpdate

                                                                                                                                                                                                                                                                func (m *MachineSet) ValidateUpdate(old runtime.Object) error

                                                                                                                                                                                                                                                                  ValidateUpdate implements webhook.Validator so a webhook will be registered for the type

                                                                                                                                                                                                                                                                  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).
                                                                                                                                                                                                                                                                    	// 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).
                                                                                                                                                                                                                                                                    	// 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).
                                                                                                                                                                                                                                                                    	// 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 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 1.
                                                                                                                                                                                                                                                                            	// +optional
                                                                                                                                                                                                                                                                            	Replicas *int32 `json:"replicas,omitempty"`
                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                            	// MinReadySeconds is the 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"`
                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                            	// 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
                                                                                                                                                                                                                                                                            	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 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,omitempty"`
                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                  	// The number of replicas that have labels matching the labels of the machine template of the MachineSet.
                                                                                                                                                                                                                                                                                  	// +optional
                                                                                                                                                                                                                                                                                  	FullyLabeledReplicas int32 `json:"fullyLabeledReplicas,omitempty"`
                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                  	// 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,omitempty"`
                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                  	// The number of available replicas (ready for at least minReadySeconds) for this MachineSet.
                                                                                                                                                                                                                                                                                  	// +optional
                                                                                                                                                                                                                                                                                  	AvailableReplicas int32 `json:"availableReplicas,omitempty"`
                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                  	// 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.
                                                                                                                                                                                                                                                                                  	// +optional
                                                                                                                                                                                                                                                                                  	FailureReason *capierrors.MachineSetStatusError `json:"failureReason,omitempty"`
                                                                                                                                                                                                                                                                                  	// +optional
                                                                                                                                                                                                                                                                                  	FailureMessage *string `json:"failureMessage,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 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"`
                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                        	// 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"`
                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                          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"`
                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                              	// LastUpdated identifies when the phase of the Machine last transitioned.
                                                                                                                                                                                                                                                                                              	// +optional
                                                                                                                                                                                                                                                                                              	LastUpdated *metav1.Time `json:"lastUpdated,omitempty"`
                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                              	// Version specifies the current version of Kubernetes running
                                                                                                                                                                                                                                                                                              	// on the corresponding Node. This is meant to be a means of bubbling
                                                                                                                                                                                                                                                                                              	// up status from the Node to the Machine.
                                                                                                                                                                                                                                                                                              	// It is entirely optional, but useful for end-user UX if it’s present.
                                                                                                                                                                                                                                                                                              	// +optional
                                                                                                                                                                                                                                                                                              	Version *string `json:"version,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.
                                                                                                                                                                                                                                                                                              	// +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.
                                                                                                                                                                                                                                                                                              	// +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"`
                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                              	// 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"`
                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                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 NetworkRanges

                                                                                                                                                                                                                                                                                                              type NetworkRanges struct {
                                                                                                                                                                                                                                                                                                              	CIDRBlocks []string `json:"cidrBlocks"`
                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                ANCHOR: NetworkRanges 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 {
                                                                                                                                                                                                                                                                                                                    	// Name must be unique within a namespace. Is required when creating resources, although
                                                                                                                                                                                                                                                                                                                    	// some resources may allow a client to request the generation of an appropriate name
                                                                                                                                                                                                                                                                                                                    	// automatically. Name is primarily intended for creation idempotence and configuration
                                                                                                                                                                                                                                                                                                                    	// definition.
                                                                                                                                                                                                                                                                                                                    	// Cannot be updated.
                                                                                                                                                                                                                                                                                                                    	// More info: http://kubernetes.io/docs/user-guide/identifiers#names
                                                                                                                                                                                                                                                                                                                    	// +optional
                                                                                                                                                                                                                                                                                                                    	Name string `json:"name,omitempty"`
                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                    	// GenerateName is an optional prefix, used by the server, to generate a unique
                                                                                                                                                                                                                                                                                                                    	// name ONLY IF the Name field has not been provided.
                                                                                                                                                                                                                                                                                                                    	// If this field is used, the name returned to the client will be different
                                                                                                                                                                                                                                                                                                                    	// than the name passed. This value will also be combined with a unique suffix.
                                                                                                                                                                                                                                                                                                                    	// The provided value has the same validation rules as the Name field,
                                                                                                                                                                                                                                                                                                                    	// and may be truncated by the length of the suffix required to make the value
                                                                                                                                                                                                                                                                                                                    	// unique on the server.
                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                    	// If this field is specified and the generated name exists, the server will
                                                                                                                                                                                                                                                                                                                    	// NOT return a 409 - instead, it will either return 201 Created or 500 with Reason
                                                                                                                                                                                                                                                                                                                    	// ServerTimeout indicating a unique name could not be found in the time allotted, and the client
                                                                                                                                                                                                                                                                                                                    	// should retry (optionally after the time indicated in the Retry-After header).
                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                    	// Applied only if Name is not specified.
                                                                                                                                                                                                                                                                                                                    	// More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency
                                                                                                                                                                                                                                                                                                                    	// +optional
                                                                                                                                                                                                                                                                                                                    	GenerateName string `json:"generateName,omitempty"`
                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                    	// Namespace defines the space within each name must be unique. An empty namespace is
                                                                                                                                                                                                                                                                                                                    	// equivalent to the "default" namespace, but "default" is the canonical representation.
                                                                                                                                                                                                                                                                                                                    	// Not all objects are required to be scoped to a namespace - the value of this field for
                                                                                                                                                                                                                                                                                                                    	// those objects will be empty.
                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                    	// Must be a DNS_LABEL.
                                                                                                                                                                                                                                                                                                                    	// Cannot be updated.
                                                                                                                                                                                                                                                                                                                    	// More info: http://kubernetes.io/docs/user-guide/namespaces
                                                                                                                                                                                                                                                                                                                    	// +optional
                                                                                                                                                                                                                                                                                                                    	Namespace string `json:"namespace,omitempty"`
                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                    	// 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"`
                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                    	// List of objects depended by this object. If ALL objects in the list have
                                                                                                                                                                                                                                                                                                                    	// been deleted, this object will be garbage collected. If this object is managed by a controller,
                                                                                                                                                                                                                                                                                                                    	// then an entry in this list will point to this controller, with the controller field set to true.
                                                                                                                                                                                                                                                                                                                    	// There cannot be more than one managing controller.
                                                                                                                                                                                                                                                                                                                    	// +optional
                                                                                                                                                                                                                                                                                                                    	// +patchMergeKey=uid
                                                                                                                                                                                                                                                                                                                    	// +patchStrategy=merge
                                                                                                                                                                                                                                                                                                                    	OwnerReferences []metav1.OwnerReference `json:"ownerReferences,omitempty" patchStrategy:"merge" patchMergeKey:"uid"`
                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                      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.

                                                                                                                                                                                                                                                                                                                          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.