deployment controller 源码分析

// cmd/kube-controller-manager/app/apps.gofunc startDeploymentController(ctx ControllerContext) (http.Handler, bool, error) {  if !ctx.AvailableResources[schema.GroupVersionResource{Group: "apps", Version: "v1", Resource: "deployments"}] {    return nil, false, nil  }  dc, err := deployment.NewDeploymentController(    ctx.InformerFactory.Apps().V1().Deployments(),    ctx.InformerFactory.Apps().V1().ReplicaSets(),    ctx.InformerFactory.Core().V1().Pods(),    ctx.ClientBuilder.ClientOrDie("deployment-controller"),  )  if err != nil {    return nil, true, fmt.Errorf("error creating Deployment controller: %v", err)  }  go dc.Run(int(ctx.ComponentConfig.DeploymentController.ConcurrentDeploymentSyncs), ctx.Stop)  return nil, true, nil}

// pkg/controller/deployment/deployment_controller.go// NewDeploymentController creates a new DeploymentController.func NewDeploymentController(dInformer appsinformers.DeploymentInformer, rsInformer appsinformers.ReplicaSetInformer, podInformer coreinformers.PodInformer, client clientset.Interface) (*DeploymentController, error) {  eventBroadcaster := record.NewBroadcaster()  eventBroadcaster.StartLogging(klog.Infof)  eventBroadcaster.StartRecordingToSink(&v1core.EventSinkImpl{Interface: client.CoreV1().Events("")})
  if client != nil && client.CoreV1().RESTClient().GetRateLimiter() != nil {    if err := ratelimiter.RegisterMetricAndTrackRateLimiterUsage("deployment_controller", client.CoreV1().RESTClient().GetRateLimiter()); err != nil {      return nil, err    }  }  dc := &DeploymentController{    client:        client,    eventRecorder: eventBroadcaster.NewRecorder(scheme.Scheme, v1.EventSource{Component: "deployment-controller"}),    queue:         workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), "deployment"),  }  dc.rsControl = controller.RealRSControl{    KubeClient: client,    Recorder:   dc.eventRecorder,  }
  dInformer.Informer().AddEventHandler(cache.ResourceEventHandlerFuncs{    AddFunc:    dc.addDeployment,    UpdateFunc: dc.updateDeployment,    // This will enter the sync loop and no-op, because the deployment has been deleted from the store.    DeleteFunc: dc.deleteDeployment,  })  rsInformer.Informer().AddEventHandler(cache.ResourceEventHandlerFuncs{    AddFunc:    dc.addReplicaSet,    UpdateFunc: dc.updateReplicaSet,    DeleteFunc: dc.deleteReplicaSet,  })  podInformer.Informer().AddEventHandler(cache.ResourceEventHandlerFuncs{    DeleteFunc: dc.deletePod,  })
  dc.syncHandler = dc.syncDeployment  dc.enqueueDeployment = dc.enqueue
  dc.dLister = dInformer.Lister()  dc.rsLister = rsInformer.Lister()  dc.podLister = podInformer.Lister()  dc.dListerSynced = dInformer.Informer().HasSynced  dc.rsListerSynced = rsInformer.Informer().HasSynced  dc.podListerSynced = podInformer.Informer().HasSynced  return dc, nil}

// pkg/controller/deployment/deployment_controller.gofunc (dc *DeploymentController) Run(workers int, stopCh <-chan struct{}) {  defer utilruntime.HandleCrash()  defer dc.queue.ShutDown()
  klog.Infof("Starting deployment controller")  defer klog.Infof("Shutting down deployment controller")
  if !cache.WaitForNamedCacheSync("deployment", stopCh, dc.dListerSynced, dc.rsListerSynced, dc.podListerSynced) {    return  }
  for i := 0; i < workers; i++ {    go wait.Until(dc.worker, time.Second, stopCh)  }
  <-stopCh}

// pkg/controller/deployment/deployment_controller.gofunc (dc *DeploymentController) worker() {  for dc.processNextWorkItem() {  }}
func (dc *DeploymentController) processNextWorkItem() bool {  key, quit := dc.queue.Get()  if quit {    return false  }  defer dc.queue.Done(key)
  err := dc.syncHandler(key.(string))  dc.handleErr(err, key)
  return true}

apiVersion: v1kind: Pod...status:  conditions:  - lastProbeTime: null    lastTransitionTime: "2021-08-04T08:47:03Z"    status: "True"    type: Ready  ...

apiVersion: v1kind: Pod...status:  ...  containerStatuses:  - containerID: xxx    image: xxx    imageID: xxx    lastState: {}    name: test    ready: true    ...

// pkg/controller/deployment/deployment_controller.go// syncDeployment will sync the deployment with the given key.// This function is not meant to be invoked concurrently with the same key.func (dc *DeploymentController) syncDeployment(key string) error {  startTime := time.Now()  klog.V(4).Infof("Started syncing deployment %q (%v)", key, startTime)  defer func() {    klog.V(4).Infof("Finished syncing deployment %q (%v)", key, time.Since(startTime))  }()
  namespace, name, err := cache.SplitMetaNamespaceKey(key)  if err != nil {    return err  }  deployment, err := dc.dLister.Deployments(namespace).Get(name)  if errors.IsNotFound(err) {    klog.V(2).Infof("Deployment %v has been deleted", key)    return nil  }  if err != nil {    return err  }
  // Deep-copy otherwise we are mutating our cache.  // TODO: Deep-copy only when needed.  d := deployment.DeepCopy()
  everything := metav1.LabelSelector{}  if reflect.DeepEqual(d.Spec.Selector, &everything) {    dc.eventRecorder.Eventf(d, v1.EventTypeWarning, "SelectingAll", "This deployment is selecting all pods. A non-empty selector is required.")    if d.Status.ObservedGeneration < d.Generation {      d.Status.ObservedGeneration = d.Generation      dc.client.AppsV1().Deployments(d.Namespace).UpdateStatus(d)    }    return nil  }
  // List ReplicaSets owned by this Deployment, while reconciling ControllerRef  // through adoption/orphaning.  rsList, err := dc.getReplicaSetsForDeployment(d)  if err != nil {    return err  }  // List all Pods owned by this Deployment, grouped by their ReplicaSet.  // Current uses of the podMap are:  //  // * check if a Pod is labeled correctly with the pod-template-hash label.  // * check that no old Pods are running in the middle of Recreate Deployments.  podMap, err := dc.getPodMapForDeployment(d, rsList)  if err != nil {    return err  }
  if d.DeletionTimestamp != nil {    return dc.syncStatusOnly(d, rsList)  }
  // Update deployment conditions with an Unknown condition when pausing/resuming  // a deployment. In this way, we can be sure that we won't timeout when a user  // resumes a Deployment with a set progressDeadlineSeconds.  if err = dc.checkPausedConditions(d); err != nil {    return err  }
  if d.Spec.Paused {    return dc.sync(d, rsList)  }
  // rollback is not re-entrant in case the underlying replica sets are updated with a new  // revision so we should ensure that we won't proceed to update replica sets until we  // make sure that the deployment has cleaned up its rollback spec in subsequent enqueues.  if getRollbackTo(d) != nil {    return dc.rollback(d, rsList)  }
  scalingEvent, err := dc.isScalingEvent(d, rsList)  if err != nil {    return err  }  if scalingEvent {    return dc.sync(d, rsList)  }
  switch d.Spec.Strategy.Type {  case apps.RecreateDeploymentStrategyType:    return dc.rolloutRecreate(d, rsList, podMap)  case apps.RollingUpdateDeploymentStrategyType:    return dc.rolloutRolling(d, rsList)  }  return fmt.Errorf("unexpected deployment strategy type: %s", d.Spec.Strategy.Type)}

// pkg/controller/deployment/deployment_controller.go// getReplicaSetsForDeployment uses ControllerRefManager to reconcile// ControllerRef by adopting and orphaning.// It returns the list of ReplicaSets that this Deployment should manage.func (dc *DeploymentController) getReplicaSetsForDeployment(d *apps.Deployment) ([]*apps.ReplicaSet, error) {  // List all ReplicaSets to find those we own but that no longer match our  // selector. They will be orphaned by ClaimReplicaSets().  rsList, err := dc.rsLister.ReplicaSets(d.Namespace).List(labels.Everything())  if err != nil {    return nil, err  }  deploymentSelector, err := metav1.LabelSelectorAsSelector(d.Spec.Selector)  if err != nil {    return nil, fmt.Errorf("deployment %s/%s has invalid label selector: %v", d.Namespace, d.Name, err)  }  // If any adoptions are attempted, we should first recheck for deletion with  // an uncached quorum read sometime after listing ReplicaSets (see #42639).  canAdoptFunc := controller.RecheckDeletionTimestamp(func() (metav1.Object, error) {    fresh, err := dc.client.AppsV1().Deployments(d.Namespace).Get(d.Name, metav1.GetOptions{})    if err != nil {      return nil, err    }    if fresh.UID != d.UID {      return nil, fmt.Errorf("original Deployment %v/%v is gone: got uid %v, wanted %v", d.Namespace, d.Name, fresh.UID, d.UID)    }    return fresh, nil  })  cm := controller.NewReplicaSetControllerRefManager(dc.rsControl, d, deploymentSelector, controllerKind, canAdoptFunc)  return cm.ClaimReplicaSets(rsList)}

// pkg/controller/controller_ref_manager.gofunc (m *ReplicaSetControllerRefManager) ClaimReplicaSets(sets []*apps.ReplicaSet) ([]*apps.ReplicaSet, error) {  var claimed []*apps.ReplicaSet  var errlist []error
  match := func(obj metav1.Object) bool {    return m.Selector.Matches(labels.Set(obj.GetLabels()))  }  adopt := func(obj metav1.Object) error {    return m.AdoptReplicaSet(obj.(*apps.ReplicaSet))  }  release := func(obj metav1.Object) error {    return m.ReleaseReplicaSet(obj.(*apps.ReplicaSet))  }
  for _, rs := range sets {    ok, err := m.ClaimObject(rs, match, adopt, release)    if err != nil {      errlist = append(errlist, err)      continue    }    if ok {      claimed = append(claimed, rs)    }  }  return claimed, utilerrors.NewAggregate(errlist)}

// pkg/controller/deployment/deployment_controller.gofunc (dc *DeploymentController) getPodMapForDeployment(d *apps.Deployment, rsList []*apps.ReplicaSet) (map[types.UID][]*v1.Pod, error) {    // Get all Pods that potentially belong to this Deployment.    selector, err := metav1.LabelSelectorAsSelector(d.Spec.Selector)    if err != nil {      return nil, err    }    pods, err := dc.podLister.Pods(d.Namespace).List(selector)  if err != nil {    return nil, err  }  // Group Pods by their controller (if it's in rsList).  podMap := make(map[types.UID][]*v1.Pod, len(rsList))  for _, rs := range rsList {    podMap[rs.UID] = []*v1.Pod{}  }  for _, pod := range pods {    // Do not ignore inactive Pods because Recreate Deployments need to verify that no    // Pods from older versions are running before spinning up new Pods.    controllerRef := metav1.GetControllerOf(pod)    if controllerRef == nil {      continue    }    // Only append if we care about this UID.    if _, ok := podMap[controllerRef.UID]; ok {      podMap[controllerRef.UID] = append(podMap[controllerRef.UID], pod)    }  }  return podMap, nil}

// pkg/controller/deployment/sync.gofunc (dc *DeploymentController) syncStatusOnly(d *apps.Deployment, rsList []*apps.ReplicaSet) error {  newRS, oldRSs, err := dc.getAllReplicaSetsAndSyncRevision(d, rsList, false)  if err != nil {    return err  }
  allRSs := append(oldRSs, newRS)  return dc.syncDeploymentStatus(allRSs, newRS, d)}

// pkg/controller/deployment/sync.gofunc (dc *DeploymentController) syncDeploymentStatus(allRSs []*apps.ReplicaSet, newRS *apps.ReplicaSet, d *apps.Deployment) error {  newStatus := calculateStatus(allRSs, newRS, d)
  if reflect.DeepEqual(d.Status, newStatus) {    return nil  }
  newDeployment := d  newDeployment.Status = newStatus  _, err := dc.client.AppsV1().Deployments(newDeployment.Namespace).UpdateStatus(newDeployment)  return err}

// pkg/controller/deployment/rollback.gofunc getRollbackTo(d *apps.Deployment) *extensions.RollbackConfig {  // Extract the annotation used for round-tripping the deprecated RollbackTo field.  revision := d.Annotations[apps.DeprecatedRollbackTo]  if revision == "" {    return nil  }  revision64, err := strconv.ParseInt(revision, 10, 64)  if err != nil {    // If it's invalid, ignore it.    return nil  }  return &extensions.RollbackConfig{    Revision: revision64,  }}

// pkg/controller/deployment/rollback.gofunc (dc *DeploymentController) rollback(d *apps.Deployment, rsList []*apps.ReplicaSet) error {  newRS, allOldRSs, err := dc.getAllReplicaSetsAndSyncRevision(d, rsList, true)  if err != nil {    return err  }
  allRSs := append(allOldRSs, newRS)  rollbackTo := getRollbackTo(d)  // If rollback revision is 0, rollback to the last revision  if rollbackTo.Revision == 0 {    if rollbackTo.Revision = deploymentutil.LastRevision(allRSs); rollbackTo.Revision == 0 {      // If we still can't find the last revision, gives up rollback      dc.emitRollbackWarningEvent(d, deploymentutil.RollbackRevisionNotFound, "Unable to find last revision.")      // Gives up rollback      return dc.updateDeploymentAndClearRollbackTo(d)    }  }  for _, rs := range allRSs {    v, err := deploymentutil.Revision(rs)    if err != nil {      klog.V(4).Infof("Unable to extract revision from deployment's replica set %q: %v", rs.Name, err)      continue    }    if v == rollbackTo.Revision {      klog.V(4).Infof("Found replica set %q with desired revision %d", rs.Name, v)      // rollback by copying podTemplate.Spec from the replica set      // revision number will be incremented during the next getAllReplicaSetsAndSyncRevision call      // no-op if the spec matches current deployment's podTemplate.Spec      performedRollback, err := dc.rollbackToTemplate(d, rs)      if performedRollback && err == nil {        dc.emitRollbackNormalEvent(d, fmt.Sprintf("Rolled back deployment %q to revision %d", d.Name, rollbackTo.Revision))      }      return err    }  }  dc.emitRollbackWarningEvent(d, deploymentutil.RollbackRevisionNotFound, "Unable to find the revision to rollback to.")  // Gives up rollback  return dc.updateDeploymentAndClearRollbackTo(d)}

// pkg/controller/deployment/sync.go// sync is responsible for reconciling deployments on scaling events or when they// are paused.func (dc *DeploymentController) sync(d *apps.Deployment, rsList []*apps.ReplicaSet) error {  newRS, oldRSs, err := dc.getAllReplicaSetsAndSyncRevision(d, rsList, false)  if err != nil {    return err  }  if err := dc.scale(d, newRS, oldRSs); err != nil {    // If we get an error while trying to scale, the deployment will be requeued    // so we can abort this resync    return err  }
  // Clean up the deployment when it's paused and no rollback is in flight.  if d.Spec.Paused && getRollbackTo(d) == nil {    if err := dc.cleanupDeployment(oldRSs, d); err != nil {      return err    }  }
  allRSs := append(oldRSs, newRS)  return dc.syncDeploymentStatus(allRSs, newRS, d)}

// pkg/controller/deployment/sync.gofunc (dc *DeploymentController) scale(deployment *apps.Deployment, newRS *apps.ReplicaSet, oldRSs []*apps.ReplicaSet) error {  // If there is only one active replica set then we should scale that up to the full count of the  // deployment. If there is no active replica set, then we should scale up the newest replica set.  if activeOrLatest := deploymentutil.FindActiveOrLatest(newRS, oldRSs); activeOrLatest != nil {    if *(activeOrLatest.Spec.Replicas) == *(deployment.Spec.Replicas) {      return nil    }    _, _, err := dc.scaleReplicaSetAndRecordEvent(activeOrLatest, *(deployment.Spec.Replicas), deployment)    return err  }
  // If the new replica set is saturated, old replica sets should be fully scaled down.  // This case handles replica set adoption during a saturated new replica set.  if deploymentutil.IsSaturated(deployment, newRS) {    for _, old := range controller.FilterActiveReplicaSets(oldRSs) {      if _, _, err := dc.scaleReplicaSetAndRecordEvent(old, 0, deployment); err != nil {        return err      }    }    return nil  }
  // There are old replica sets with pods and the new replica set is not saturated.  // We need to proportionally scale all replica sets (new and old) in case of a  // rolling deployment.  if deploymentutil.IsRollingUpdate(deployment) {    allRSs := controller.FilterActiveReplicaSets(append(oldRSs, newRS))    allRSsReplicas := deploymentutil.GetReplicaCountForReplicaSets(allRSs)
    allowedSize := int32(0)    if *(deployment.Spec.Replicas) > 0 {      allowedSize = *(deployment.Spec.Replicas) + deploymentutil.MaxSurge(*deployment)    }
    // Number of additional replicas that can be either added or removed from the total    // replicas count. These replicas should be distributed proportionally to the active    // replica sets.    deploymentReplicasToAdd := allowedSize - allRSsReplicas
    // The additional replicas should be distributed proportionally amongst the active    // replica sets from the larger to the smaller in size replica set. Scaling direction    // drives what happens in case we are trying to scale replica sets of the same size.    // In such a case when scaling up, we should scale up newer replica sets first, and    // when scaling down, we should scale down older replica sets first.    var scalingOperation string    switch {    case deploymentReplicasToAdd > 0:      sort.Sort(controller.ReplicaSetsBySizeNewer(allRSs))      scalingOperation = "up"
    case deploymentReplicasToAdd < 0:      sort.Sort(controller.ReplicaSetsBySizeOlder(allRSs))      scalingOperation = "down"    }
    // Iterate over all active replica sets and estimate proportions for each of them.    // The absolute value of deploymentReplicasAdded should never exceed the absolute    // value of deploymentReplicasToAdd.    deploymentReplicasAdded := int32(0)    nameToSize := make(map[string]int32)    for i := range allRSs {      rs := allRSs[i]
      // Estimate proportions if we have replicas to add, otherwise simply populate      // nameToSize with the current sizes for each replica set.      if deploymentReplicasToAdd != 0 {        proportion := deploymentutil.GetProportion(rs, *deployment, deploymentReplicasToAdd, deploymentReplicasAdded)
        nameToSize[rs.Name] = *(rs.Spec.Replicas) + proportion        deploymentReplicasAdded += proportion      } else {        nameToSize[rs.Name] = *(rs.Spec.Replicas)      }    }
    // Update all replica sets    for i := range allRSs {      rs := allRSs[i]
      // Add/remove any leftovers to the largest replica set.      if i == 0 && deploymentReplicasToAdd != 0 {        leftover := deploymentReplicasToAdd - deploymentReplicasAdded        nameToSize[rs.Name] = nameToSize[rs.Name] + leftover        if nameToSize[rs.Name] < 0 {          nameToSize[rs.Name] = 0        }      }
      // TODO: Use transactions when we have them.      if _, _, err := dc.scaleReplicaSet(rs, nameToSize[rs.Name], deployment, scalingOperation); err != nil {        // Return as soon as we fail, the deployment is requeued        return err      }    }  }  return nil}

// pkg/controller/deployment/sync.gofunc (dc *DeploymentController) cleanupDeployment(oldRSs []*apps.ReplicaSet, deployment *apps.Deployment) error {  if !deploymentutil.HasRevisionHistoryLimit(deployment) {    return nil  }
  // Avoid deleting replica set with deletion timestamp set  aliveFilter := func(rs *apps.ReplicaSet) bool {    return rs != nil && rs.ObjectMeta.DeletionTimestamp == nil  }  cleanableRSes := controller.FilterReplicaSets(oldRSs, aliveFilter)
  diff := int32(len(cleanableRSes)) - *deployment.Spec.RevisionHistoryLimit  if diff <= 0 {    return nil  }
  sort.Sort(controller.ReplicaSetsByCreationTimestamp(cleanableRSes))  klog.V(4).Infof("Looking to cleanup old replica sets for deployment %q", deployment.Name)
  for i := int32(0); i < diff; i++ {    rs := cleanableRSes[i]    // Avoid delete replica set with non-zero replica counts    if rs.Status.Replicas != 0 || *(rs.Spec.Replicas) != 0 || rs.Generation > rs.Status.ObservedGeneration || rs.DeletionTimestamp != nil {      continue    }    klog.V(4).Infof("Trying to cleanup replica set %q for deployment %q", rs.Name, deployment.Name)    if err := dc.client.AppsV1().ReplicaSets(rs.Namespace).Delete(rs.Name, nil); err != nil && !errors.IsNotFound(err) {      // Return error instead of aggregating and continuing DELETEs on the theory      // that we may be overloading the api server.      return err    }  }
  return nil}

// pkg/controller/deployment/recreate.go// rolloutRecreate implements the logic for recreating a replica set.func (dc *DeploymentController) rolloutRecreate(d *apps.Deployment, rsList []*apps.ReplicaSet, podMap map[types.UID][]*v1.Pod) error {  // Don't create a new RS if not already existed, so that we avoid scaling up before scaling down.  newRS, oldRSs, err := dc.getAllReplicaSetsAndSyncRevision(d, rsList, false)  if err != nil {    return err  }  allRSs := append(oldRSs, newRS)  activeOldRSs := controller.FilterActiveReplicaSets(oldRSs)
  // scale down old replica sets.  scaledDown, err := dc.scaleDownOldReplicaSetsForRecreate(activeOldRSs, d)  if err != nil {    return err  }  if scaledDown {    // Update DeploymentStatus.    return dc.syncRolloutStatus(allRSs, newRS, d)  }
  // Do not process a deployment when it has old pods running.  if oldPodsRunning(newRS, oldRSs, podMap) {    return dc.syncRolloutStatus(allRSs, newRS, d)  }
  // If we need to create a new RS, create it now.  if newRS == nil {    newRS, oldRSs, err = dc.getAllReplicaSetsAndSyncRevision(d, rsList, true)    if err != nil {      return err    }    allRSs = append(oldRSs, newRS)  }
  // scale up new replica set.  if _, err := dc.scaleUpNewReplicaSetForRecreate(newRS, d); err != nil {    return err  }
  if util.DeploymentComplete(d, &d.Status) {    if err := dc.cleanupDeployment(oldRSs, d); err != nil {      return err    }  }
  // Sync deployment status.  return dc.syncRolloutStatus(allRSs, newRS, d)}

// pkg/controller/deployment/sync.gofunc (dc *DeploymentController) getAllReplicaSetsAndSyncRevision(d *apps.Deployment, rsList []*apps.ReplicaSet, createIfNotExisted bool) (*apps.ReplicaSet, []*apps.ReplicaSet, error) {  _, allOldRSs := deploymentutil.FindOldReplicaSets(d, rsList)
  // Get new replica set with the updated revision number  newRS, err := dc.getNewReplicaSet(d, rsList, allOldRSs, createIfNotExisted)  if err != nil {    return nil, nil, err  }
  return newRS, allOldRSs, nil}

// pkg/controller/deployment/progress.gofunc (dc *DeploymentController) syncRolloutStatus(allRSs []*apps.ReplicaSet, newRS *apps.ReplicaSet, d *apps.Deployment) error {    newStatus := calculateStatus(allRSs, newRS, d)    ...}

// pkg/controller/deployment/recreate.gofunc oldPodsRunning(newRS *apps.ReplicaSet, oldRSs []*apps.ReplicaSet, podMap map[types.UID][]*v1.Pod) bool {  if oldPods := util.GetActualReplicaCountForReplicaSets(oldRSs); oldPods > 0 {    return true  }  for rsUID, podList := range podMap {    // If the pods belong to the new ReplicaSet, ignore.    if newRS != nil && newRS.UID == rsUID {      continue    }    for _, pod := range podList {      switch pod.Status.Phase {      case v1.PodFailed, v1.PodSucceeded:        // Don't count pods in terminal state.        continue      case v1.PodUnknown:        // This happens in situation like when the node is temporarily disconnected from the cluster.        // If we can't be sure that the pod is not running, we have to count it.        return true      default:        // Pod is not in terminal phase.        return true      }    }  }  return false}

// pkg/controller/deployment/sync.gofunc (dc *DeploymentController) getAllReplicaSetsAndSyncRevision(d *apps.Deployment, rsList []*apps.ReplicaSet, createIfNotExisted bool) (*apps.ReplicaSet, []*apps.ReplicaSet, error) {  _, allOldRSs := deploymentutil.FindOldReplicaSets(d, rsList)
  // Get new replica set with the updated revision number  newRS, err := dc.getNewReplicaSet(d, rsList, allOldRSs, createIfNotExisted)  if err != nil {    return nil, nil, err  }
  return newRS, allOldRSs, nil}

// pkg/controller/deployment/recreate.gofunc (dc *DeploymentController) scaleDownOldReplicaSetsForRecreate(oldRSs []*apps.ReplicaSet, deployment *apps.Deployment) (bool, error) {  scaled := false  for i := range oldRSs {    rs := oldRSs[i]    // Scaling not required.    if *(rs.Spec.Replicas) == 0 {      continue    }    scaledRS, updatedRS, err := dc.scaleReplicaSetAndRecordEvent(rs, 0, deployment)    if err != nil {      return false, err    }    if scaledRS {      oldRSs[i] = updatedRS      scaled = true    }  }  return scaled, nil}

// pkg/controller/deployment/recreate.gofunc (dc *DeploymentController) scaleUpNewReplicaSetForRecreate(newRS *apps.ReplicaSet, deployment *apps.Deployment) (bool, error) {  scaled, _, err := dc.scaleReplicaSetAndRecordEvent(newRS, *(deployment.Spec.Replicas), deployment)  return scaled, err}

// pkg/controller/deployment/rolling.go// rolloutRolling implements the logic for rolling a new replica set.func (dc *DeploymentController) rolloutRolling(d *apps.Deployment, rsList []*apps.ReplicaSet) error {  newRS, oldRSs, err := dc.getAllReplicaSetsAndSyncRevision(d, rsList, true)  if err != nil {    return err  }  allRSs := append(oldRSs, newRS)
  // Scale up, if we can.  scaledUp, err := dc.reconcileNewReplicaSet(allRSs, newRS, d)  if err != nil {    return err  }  if scaledUp {    // Update DeploymentStatus    return dc.syncRolloutStatus(allRSs, newRS, d)  }
  // Scale down, if we can.  scaledDown, err := dc.reconcileOldReplicaSets(allRSs, controller.FilterActiveReplicaSets(oldRSs), newRS, d)  if err != nil {    return err  }  if scaledDown {    // Update DeploymentStatus    return dc.syncRolloutStatus(allRSs, newRS, d)  }
  if deploymentutil.DeploymentComplete(d, &d.Status) {    if err := dc.cleanupDeployment(oldRSs, d); err != nil {      return err    }  }
  // Sync deployment status  return dc.syncRolloutStatus(allRSs, newRS, d)}

// pkg/controller/deployment/rolling.gofunc (dc *DeploymentController) reconcileNewReplicaSet(allRSs []*apps.ReplicaSet, newRS *apps.ReplicaSet, deployment *apps.Deployment) (bool, error) {  if *(newRS.Spec.Replicas) == *(deployment.Spec.Replicas) {    // Scaling not required.    return false, nil  }  if *(newRS.Spec.Replicas) > *(deployment.Spec.Replicas) {    // Scale down.    scaled, _, err := dc.scaleReplicaSetAndRecordEvent(newRS, *(deployment.Spec.Replicas), deployment)    return scaled, err  }  newReplicasCount, err := deploymentutil.NewRSNewReplicas(deployment, allRSs, newRS)  if err != nil {    return false, err  }  scaled, _, err := dc.scaleReplicaSetAndRecordEvent(newRS, newReplicasCount, deployment)  return scaled, err}

// pkg/controller/deployment/util/deployment_util.gofunc NewRSNewReplicas(deployment *apps.Deployment, allRSs []*apps.ReplicaSet, newRS *apps.ReplicaSet) (int32, error) {  switch deployment.Spec.Strategy.Type {  case apps.RollingUpdateDeploymentStrategyType:    // Check if we can scale up.    maxSurge, err := intstrutil.GetValueFromIntOrPercent(deployment.Spec.Strategy.RollingUpdate.MaxSurge, int(*(deployment.Spec.Replicas)), true)    if err != nil {      return 0, err    }    // Find the total number of pods    currentPodCount := GetReplicaCountForReplicaSets(allRSs)    maxTotalPods := *(deployment.Spec.Replicas) + int32(maxSurge)    if currentPodCount >= maxTotalPods {      // Cannot scale up.      return *(newRS.Spec.Replicas), nil    }    // Scale up.    scaleUpCount := maxTotalPods - currentPodCount    // Do not exceed the number of desired replicas.    scaleUpCount = int32(integer.IntMin(int(scaleUpCount), int(*(deployment.Spec.Replicas)-*(newRS.Spec.Replicas))))    return *(newRS.Spec.Replicas) + scaleUpCount, nil  case apps.RecreateDeploymentStrategyType:    return *(deployment.Spec.Replicas), nil  default:    return 0, fmt.Errorf("deployment type %v isn't supported", deployment.Spec.Strategy.Type)  }}

// staging/src/k8s.io/apimachinery/pkg/util/intstr/intstr.gofunc GetValueFromIntOrPercent(intOrPercent *IntOrString, total int, roundUp bool) (int, error) {  if intOrPercent == nil {    return 0, errors.New("nil value for IntOrString")  }  value, isPercent, err := getIntOrPercentValue(intOrPercent)  if err != nil {    return 0, fmt.Errorf("invalid value for IntOrString: %v", err)  }  if isPercent {    if roundUp {      value = int(math.Ceil(float64(value) * (float64(total)) / 100))    } else {      value = int(math.Floor(float64(value) * (float64(total)) / 100))    }  }  return value, nil}

// pkg/controller/deployment/rolling.gofunc (dc *DeploymentController) reconcileOldReplicaSets(allRSs []*apps.ReplicaSet, oldRSs []*apps.ReplicaSet, newRS *apps.ReplicaSet, deployment *apps.Deployment) (bool, error) {  oldPodsCount := deploymentutil.GetReplicaCountForReplicaSets(oldRSs)  if oldPodsCount == 0 {    // Can't scale down further    return false, nil  }
  allPodsCount := deploymentutil.GetReplicaCountForReplicaSets(allRSs)  klog.V(4).Infof("New replica set %s/%s has %d available pods.", newRS.Namespace, newRS.Name, newRS.Status.AvailableReplicas)  maxUnavailable := deploymentutil.MaxUnavailable(*deployment)    minAvailable := *(deployment.Spec.Replicas) - maxUnavailable  newRSUnavailablePodCount := *(newRS.Spec.Replicas) - newRS.Status.AvailableReplicas  maxScaledDown := allPodsCount - minAvailable - newRSUnavailablePodCount  if maxScaledDown <= 0 {    return false, nil  }
  // Clean up unhealthy replicas first, otherwise unhealthy replicas will block deployment  // and cause timeout. See https://github.com/kubernetes/kubernetes/issues/16737  oldRSs, cleanupCount, err := dc.cleanupUnhealthyReplicas(oldRSs, deployment, maxScaledDown)  if err != nil {    return false, nil  }  klog.V(4).Infof("Cleaned up unhealthy replicas from old RSes by %d", cleanupCount)
  // Scale down old replica sets, need check maxUnavailable to ensure we can scale down  allRSs = append(oldRSs, newRS)  scaledDownCount, err := dc.scaleDownOldReplicaSetsForRollingUpdate(allRSs, oldRSs, deployment)  if err != nil {    return false, nil  }  klog.V(4).Infof("Scaled down old RSes of deployment %s by %d", deployment.Name, scaledDownCount)
  totalScaledDown := cleanupCount + scaledDownCount  return totalScaledDown > 0, nil}

// pkg/controller/deployment/rolling.gofunc (dc *DeploymentController) scaleDownOldReplicaSetsForRollingUpdate(allRSs []*apps.ReplicaSet, oldRSs []*apps.ReplicaSet, deployment *apps.Deployment) (int32, error) {  maxUnavailable := deploymentutil.MaxUnavailable(*deployment)
  // Check if we can scale down.  minAvailable := *(deployment.Spec.Replicas) - maxUnavailable  // Find the number of available pods.  availablePodCount := deploymentutil.GetAvailableReplicaCountForReplicaSets(allRSs)  if availablePodCount <= minAvailable {    // Cannot scale down.    return 0, nil  }  klog.V(4).Infof("Found %d available pods in deployment %s, scaling down old RSes", availablePodCount, deployment.Name)
  sort.Sort(controller.ReplicaSetsByCreationTimestamp(oldRSs))
  totalScaledDown := int32(0)  totalScaleDownCount := availablePodCount - minAvailable  for _, targetRS := range oldRSs {    if totalScaledDown >= totalScaleDownCount {      // No further scaling required.      break    }    if *(targetRS.Spec.Replicas) == 0 {      // cannot scale down this ReplicaSet.      continue    }    // Scale down.    scaleDownCount := int32(integer.IntMin(int(*(targetRS.Spec.Replicas)), int(totalScaleDownCount-totalScaledDown)))    newReplicasCount := *(targetRS.Spec.Replicas) - scaleDownCount    if newReplicasCount > *(targetRS.Spec.Replicas) {      return 0, fmt.Errorf("when scaling down old RS, got invalid request to scale down %s/%s %d -> %d", targetRS.Namespace, targetRS.Name, *(targetRS.Spec.Replicas), newReplicasCount)    }    _, _, err := dc.scaleReplicaSetAndRecordEvent(targetRS, newReplicasCount, deployment)    if err != nil {      return totalScaledDown, err    }
    totalScaledDown += scaleDownCount  }
  return totalScaledDown, nil}

速记：配置百分比时，maxSurge向上取整，maxUnavailable向下取整

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