// NewRollingDeploymentStrategy makes a new RollingDeploymentStrategy. func NewRollingDeploymentStrategy(namespace string, client kclient.Interface, codec runtime.Codec, initialStrategy acceptingDeploymentStrategy) *RollingDeploymentStrategy { updaterClient := &rollingUpdaterClient{ ControllerHasDesiredReplicasFn: func(rc *kapi.ReplicationController) wait.ConditionFunc { return kclient.ControllerHasDesiredReplicas(client, rc) }, GetReplicationControllerFn: func(namespace, name string) (*kapi.ReplicationController, error) { return client.ReplicationControllers(namespace).Get(name) }, UpdateReplicationControllerFn: func(namespace string, rc *kapi.ReplicationController) (*kapi.ReplicationController, error) { return client.ReplicationControllers(namespace).Update(rc) }, // This guards against the RollingUpdater's built-in behavior to create // RCs when the supplied old RC is nil. We won't pass nil, but it doesn't // hurt to further guard against it since we would have no way to identify // or clean up orphaned RCs RollingUpdater might inadvertently create. CreateReplicationControllerFn: func(namespace string, rc *kapi.ReplicationController) (*kapi.ReplicationController, error) { return nil, fmt.Errorf("unexpected attempt to create Deployment: %#v", rc) }, // We give the RollingUpdater a policy which should prevent it from // deleting the source deployment after the transition, but it doesn't // hurt to guard by removing its ability to delete. DeleteReplicationControllerFn: func(namespace, name string) error { return fmt.Errorf("unexpected attempt to delete Deployment %s/%s", namespace, name) }, } return &RollingDeploymentStrategy{ codec: codec, initialStrategy: initialStrategy, client: updaterClient, rollingUpdate: func(config *kubectl.RollingUpdaterConfig) error { updater := kubectl.NewRollingUpdater(namespace, updaterClient) return updater.Update(config) }, hookExecutor: &stratsupport.HookExecutor{ PodClient: &stratsupport.HookExecutorPodClientImpl{ CreatePodFunc: func(namespace string, pod *kapi.Pod) (*kapi.Pod, error) { return client.Pods(namespace).Create(pod) }, PodWatchFunc: func(namespace, name, resourceVersion string, stopChannel chan struct{}) func() *kapi.Pod { return stratsupport.NewPodWatch(client, namespace, name, resourceVersion, stopChannel) }, }, }, getUpdateAcceptor: func(timeout time.Duration) kubectl.UpdateAcceptor { return stratsupport.NewAcceptNewlyObservedReadyPods(client, timeout, AcceptorInterval) }, } }
func runReplicationControllerTest(c *client.Client) { clientAPIVersion := c.APIVersion() data, err := ioutil.ReadFile("cmd/integration/" + clientAPIVersion + "-controller.json") if err != nil { glog.Fatalf("Unexpected error: %v", err) } var controller api.ReplicationController if err := api.Scheme.DecodeInto(data, &controller); err != nil { glog.Fatalf("Unexpected error: %v", err) } glog.Infof("Creating replication controllers") updated, err := c.ReplicationControllers("test").Create(&controller) if err != nil { glog.Fatalf("Unexpected error: %v", err) } glog.Infof("Done creating replication controllers") // In practice the controller doesn't need 60s to create a handful of pods, but network latencies on CI // systems have been observed to vary unpredictably, so give the controller enough time to create pods. // Our e2e scalability tests will catch controllers that are *actually* slow. if err := wait.Poll(time.Second, time.Second*60, client.ControllerHasDesiredReplicas(c, updated)); err != nil { glog.Fatalf("FAILED: pods never created %v", err) } // Poll till we can retrieve the status of all pods matching the given label selector from their minions. // This involves 3 operations: // - The scheduler must assign all pods to a minion // - The assignment must reflect in a `List` operation against the apiserver, for labels matching the selector // - We need to be able to query the kubelet on that minion for information about the pod if err := wait.Poll( time.Second, time.Second*30, podsOnMinions(c, "test", labels.Set(updated.Spec.Selector).AsSelector())); err != nil { glog.Fatalf("FAILED: pods never started running %v", err) } glog.Infof("Pods created") }
func (c *realRollingUpdaterClient) ControllerHasDesiredReplicas(rc *api.ReplicationController) wait.ConditionFunc { return client.ControllerHasDesiredReplicas(c.client, rc) }
// ControllerHasDesiredReplicas checks whether the provided replication controller has the desired replicas // number set func (c *realScalerClient) ControllerHasDesiredReplicas(rc *kapi.ReplicationController) wait.ConditionFunc { return kclient.ControllerHasDesiredReplicas(c.kc, rc) }