cluster-api: sigs.k8s.io/cluster-api/controllers/mdutil Index | Files

package mdutil

import "sigs.k8s.io/cluster-api/controllers/mdutil"

Index

Package Files

util.go

Constants

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 = "MinimumReplicasUnavailable"
)

func CloneAndAddLabel Uses

func CloneAndAddLabel(labels map[string]string, labelKey, labelValue string) map[string]string

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 Uses

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.

func ComputeHash Uses

func ComputeHash(template *clusterv1.MachineTemplateSpec) uint32

func DeepHashObject Uses

func DeepHashObject(hasher hash.Hash, objectToWrite interface{})

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 Uses

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.

func EqualMachineTemplate Uses

func EqualMachineTemplate(template1, template2 *clusterv1.MachineTemplateSpec) bool

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.

func FilterActiveMachineSets Uses

func FilterActiveMachineSets(machineSets []*clusterv1.MachineSet) []*clusterv1.MachineSet

FilterActiveMachineSets returns machine sets that have (or at least ought to have) machines.

func FilterMachineSets Uses

func FilterMachineSets(mSes []*clusterv1.MachineSet, filterFn filterMS) []*clusterv1.MachineSet

FilterMachineSets returns machine sets that are filtered by filterFn (all returned ones should match filterFn).

func FindNewMachineSet Uses

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 Uses

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 Uses

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.

func GetActualReplicaCountForMachineSets Uses

func GetActualReplicaCountForMachineSets(machineSets []*clusterv1.MachineSet) int32

GetActualReplicaCountForMachineSets returns the sum of actual replicas of the given machine sets.

func GetAvailableReplicaCountForMachineSets Uses

func GetAvailableReplicaCountForMachineSets(machineSets []*clusterv1.MachineSet) int32

GetAvailableReplicaCountForMachineSets returns the number of available machines corresponding to the given machine sets.

func GetProportion Uses

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.

func GetReadyReplicaCountForMachineSets Uses

func GetReadyReplicaCountForMachineSets(machineSets []*clusterv1.MachineSet) int32

GetReadyReplicaCountForMachineSets returns the number of ready machines corresponding to the given machine sets.

func GetReplicaCountForMachineSets Uses

func GetReplicaCountForMachineSets(machineSets []*clusterv1.MachineSet) int32

GetReplicaCountForMachineSets returns the sum of Replicas of the given machine sets.

func IsRollingUpdate Uses

func IsRollingUpdate(deployment *clusterv1.MachineDeployment) bool

IsRollingUpdate returns true if the strategy type is a rolling update.

func IsSaturated Uses

func IsSaturated(deployment *clusterv1.MachineDeployment, ms *clusterv1.MachineSet) bool

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.

func MaxRevision Uses

func MaxRevision(allMSs []*clusterv1.MachineSet, logger logr.Logger) int64

MaxRevision finds the highest revision in the machine sets

func MaxSurge Uses

func MaxSurge(deployment clusterv1.MachineDeployment) int32

MaxSurge returns the maximum surge machines a rolling deployment can take.

func MaxUnavailable Uses

func MaxUnavailable(deployment clusterv1.MachineDeployment) int32

MaxUnavailable returns the maximum unavailable machines a rolling deployment can take.

func NewMSNewReplicas Uses

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 Uses

func ReplicasAnnotationsNeedUpdate(ms *clusterv1.MachineSet, desiredReplicas, maxReplicas int32) bool

AnnotationsNeedUpdate return true if ReplicasAnnotations need to be updated

func ResolveFenceposts Uses

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)

func Revision Uses

func Revision(obj runtime.Object) (int64, error)

Revision returns the revision number of the input object.

func SetDeploymentRevision Uses

func SetDeploymentRevision(deployment *clusterv1.MachineDeployment, revision string) bool

SetDeploymentRevision updates the revision for a deployment.

func SetNewMachineSetAnnotations Uses

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.

func SetReplicasAnnotations Uses

func SetReplicasAnnotations(ms *clusterv1.MachineSet, desiredReplicas, maxReplicas int32) bool

SetReplicasAnnotations sets the desiredReplicas and maxReplicas into the annotations

type MachineSetsByCreationTimestamp Uses

type MachineSetsByCreationTimestamp []*clusterv1.MachineSet

MachineSetsByCreationTimestamp sorts a list of MachineSet by creation timestamp, using their names as a tie breaker.

func (MachineSetsByCreationTimestamp) Len Uses

func (o MachineSetsByCreationTimestamp) Len() int

func (MachineSetsByCreationTimestamp) Less Uses

func (o MachineSetsByCreationTimestamp) Less(i, j int) bool

func (MachineSetsByCreationTimestamp) Swap Uses

func (o MachineSetsByCreationTimestamp) Swap(i, j int)

type MachineSetsBySizeNewer Uses

type MachineSetsBySizeNewer []*clusterv1.MachineSet

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.

func (MachineSetsBySizeNewer) Len Uses

func (o MachineSetsBySizeNewer) Len() int

func (MachineSetsBySizeNewer) Less Uses

func (o MachineSetsBySizeNewer) Less(i, j int) bool

func (MachineSetsBySizeNewer) Swap Uses

func (o MachineSetsBySizeNewer) Swap(i, j int)

type MachineSetsBySizeOlder Uses

type MachineSetsBySizeOlder []*clusterv1.MachineSet

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.

func (MachineSetsBySizeOlder) Len Uses

func (o MachineSetsBySizeOlder) Len() int

func (MachineSetsBySizeOlder) Less Uses

func (o MachineSetsBySizeOlder) Less(i, j int) bool

func (MachineSetsBySizeOlder) Swap Uses

func (o MachineSetsBySizeOlder) Swap(i, j int)

Package mdutil imports 17 packages (graph) and is imported by 3 packages. Updated 2020-10-29. Refresh now. Tools for package owners.