const ( DefaultMachineDeploymentUniqueLabelKey = "machine-template-hash" // FailedMSCreateReason is added in a machine deployment when it cannot create a new machine set. FailedMSCreateReason = "MachineSetCreateError" // FoundNewMSReason is added in a machine deployment when it adopts an existing machine set. FoundNewMSReason = "FoundNewMachineSet" // PausedDeployReason is added in a deployment when it is paused. Lack of progress shouldn't be // estimated once a deployment is paused. PausedDeployReason = "DeploymentPaused" // // Available: // // MinimumReplicasAvailable is added in a deployment when it has its minimum replicas required available. MinimumReplicasAvailable = "MinimumReplicasAvailable" // MinimumReplicasUnavailable is added in a deployment when it doesn't have the minimum required replicas // available. = "MinimumReplicasUnavailable" )
Clones the given map and returns a new map with the given key and value added. Returns the given map, if labelKey is empty.
func CloneSelectorAndAddLabel(selector *metav1.LabelSelector, labelKey, labelValue string) *metav1.LabelSelector
Clones the given selector and returns a new selector with the given key and value added. Returns the given selector, if labelKey is empty.
DeepHashObject writes specified object to hash using the spew library which follows pointers and prints actual values of the nested objects ensuring the hash does not change when a pointer changes.
func DeploymentComplete(deployment *clusterv1.MachineDeployment, newStatus *clusterv1.MachineDeploymentStatus) bool
DeploymentComplete considers a deployment to be complete once all of its desired replicas are updated and available, and no old machines are running.
EqualMachineTemplate returns true if two given machineTemplateSpec are equal, ignoring the diff in value of Labels["machine-template-hash"], and the version from external references.
FilterActiveMachineSets returns machine sets that have (or at least ought to have) machines.
FilterMachineSets returns machine sets that are filtered by filterFn (all returned ones should match filterFn).
func FindNewMachineSet(deployment *clusterv1.MachineDeployment, msList *clusterv1.MachineSet) *clusterv1.MachineSet
FindNewMachineSet returns the new MS this given deployment targets (the one with the same machine template).
func FindOldMachineSets(deployment *clusterv1.MachineDeployment, msList *clusterv1.MachineSet) (*clusterv1.MachineSet, *clusterv1.MachineSet)
FindOldMachineSets returns the old machine sets targeted by the given Deployment, with the given slice of MSes. Returns two list of machine sets
- the first contains all old machine sets with all non-zero replicas - the second contains all old machine sets
func FindOneActiveOrLatest(newMS *clusterv1.MachineSet, oldMSs *clusterv1.MachineSet) *clusterv1.MachineSet
FindOneActiveOrLatest returns the only active or the latest machine set in case there is at most one active machine set. If there are more than one active machine sets, return nil so machine sets can be scaled down to the point where there is only one active machine set.
GetActualReplicaCountForMachineSets returns the sum of actual replicas of the given machine sets.
GetAvailableReplicaCountForMachineSets returns the number of available machines corresponding to the given machine sets.
func GetProportion(ms *clusterv1.MachineSet, d clusterv1.MachineDeployment, deploymentReplicasToAdd, deploymentReplicasAdded int32, logger logr.Logger) int32
GetProportion will estimate the proportion for the provided machine set using 1. the current size of the parent deployment, 2. the replica count that needs be added on the machine sets of the deployment, and 3. the total replicas added in the machine sets of the deployment so far.
GetReadyReplicaCountForMachineSets returns the number of ready machines corresponding to the given machine sets.
GetReplicaCountForMachineSets returns the sum of Replicas of the given machine sets.
IsRollingUpdate returns true if the strategy type is a rolling update.
IsSaturated checks if the new machine set is saturated by comparing its size with its deployment size. Both the deployment and the machine set have to believe this machine set can own all of the desired replicas in the deployment and the annotation helps in achieving that. All machines of the MachineSet need to be available.
MaxRevision finds the highest revision in the machine sets
MaxSurge returns the maximum surge machines a rolling deployment can take.
MaxUnavailable returns the maximum unavailable machines a rolling deployment can take.
func NewMSNewReplicas(deployment *clusterv1.MachineDeployment, allMSs *clusterv1.MachineSet, newMS *clusterv1.MachineSet) (int32, error)
NewMSNewReplicas calculates the number of replicas a deployment's new MS should have. When one of the following is true, we're rolling out the deployment; otherwise, we're scaling it. 1) The new MS is saturated: newMS's replicas == deployment's replicas 2) Max number of machines allowed is reached: deployment's replicas + maxSurge == all MSs' replicas
func ReplicasAnnotationsNeedUpdate(ms *clusterv1.MachineSet, desiredReplicas, maxReplicas int32) bool
AnnotationsNeedUpdate return true if ReplicasAnnotations need to be updated
func ResolveFenceposts(maxSurge, maxUnavailable *intstrutil.IntOrString, desired int32) (int32, int32, error)
ResolveFenceposts resolves both maxSurge and maxUnavailable. This needs to happen in one step. For example:
2 desired, max unavailable 1%, surge 0% - should scale old(-1), then new(+1), then old(-1), then new(+1) 1 desired, max unavailable 1%, surge 0% - should scale old(-1), then new(+1) 2 desired, max unavailable 25%, surge 1% - should scale new(+1), then old(-1), then new(+1), then old(-1) 1 desired, max unavailable 25%, surge 1% - should scale new(+1), then old(-1) 2 desired, max unavailable 0%, surge 1% - should scale new(+1), then old(-1), then new(+1), then old(-1) 1 desired, max unavailable 0%, surge 1% - should scale new(+1), then old(-1)
Revision returns the revision number of the input object.
SetDeploymentRevision updates the revision for a deployment.
func SetNewMachineSetAnnotations(deployment *clusterv1.MachineDeployment, newMS *clusterv1.MachineSet, newRevision string, exists bool, logger logr.Logger) bool
SetNewMachineSetAnnotations sets new machine set's annotations appropriately by updating its revision and copying required deployment annotations to it; it returns true if machine set's annotation is changed.
SetReplicasAnnotations sets the desiredReplicas and maxReplicas into the annotations
TotalMachineSetsReplicaSum returns sum of max(ms.Spec.Replicas, ms.Status.Replicas) across all the machine sets.
This is used to guarantee that the total number of machines will not exceed md.Spec.Replicas + maxSurge. Use max(spec.Replicas,status.Replicas) to cover the cases that: 1. Scale up, where spec.Replicas increased but no machine created yet, so spec.Replicas > status.Replicas 2. Scale down, where spec.Replicas decreased but machine not deleted yet, so spec.Replicas < status.Replicas
MachineSetsByCreationTimestamp sorts a list of MachineSet by creation timestamp, using their names as a tie breaker.
MachineSetsBySizeNewer sorts a list of MachineSet by size in descending order, using their creation timestamp or name as a tie breaker. By using the creation timestamp, this sorts from new to old machine sets.
MachineSetsBySizeOlder sorts a list of MachineSet by size in descending order, using their creation timestamp or name as a tie breaker. By using the creation timestamp, this sorts from old to new machine sets.