// WaitForRunningDeployment waits until the specified deployment is no longer New or Pending. Returns true if // the deployment became running, complete, or failed within timeout, false if it did not, and an error if any // other error state occurred. The last observed deployment state is returned. func WaitForRunningDeployment(rn kclient.ReplicationControllersNamespacer, observed *kapi.ReplicationController, timeout time.Duration) (*kapi.ReplicationController, bool, error) { fieldSelector := fields.Set{"metadata.name": observed.Name}.AsSelector() w, err := rn.ReplicationControllers(observed.Namespace).Watch(labels.Everything(), fieldSelector, observed.ResourceVersion) if err != nil { return observed, false, err } defer w.Stop() ch := w.ResultChan() // Passing time.After like this (vs receiving directly in a select) will trigger the channel // and the timeout will have full effect here. expire := time.After(timeout) for { select { case event := <-ch: obj, ok := event.Object.(*kapi.ReplicationController) if !ok { return observed, false, errors.New("received unknown object while watching for deployments") } observed = obj switch deployutil.DeploymentStatusFor(observed) { case api.DeploymentStatusRunning, api.DeploymentStatusFailed, api.DeploymentStatusComplete: return observed, true, nil case api.DeploymentStatusNew, api.DeploymentStatusPending: default: return observed, false, ErrUnknownDeploymentPhase } case <-expire: return observed, false, nil } } }
// WaitForRunningDeployment waits until the specified deployment is no longer New or Pending. Returns true if // the deployment became running, complete, or failed within timeout, false if it did not, and an error if any // other error state occurred. The last observed deployment state is returned. func WaitForRunningDeployment(rn kclient.ReplicationControllersNamespacer, observed *kapi.ReplicationController, timeout time.Duration) (*kapi.ReplicationController, bool, error) { fieldSelector := fields.Set{"metadata.name": observed.Name}.AsSelector() options := kapi.ListOptions{FieldSelector: fieldSelector, ResourceVersion: observed.ResourceVersion} w, err := rn.ReplicationControllers(observed.Namespace).Watch(options) if err != nil { return observed, false, err } defer w.Stop() if _, err := watch.Until(timeout, w, func(e watch.Event) (bool, error) { if e.Type == watch.Error { return false, fmt.Errorf("encountered error while watching for replication controller: %v", e.Object) } obj, isController := e.Object.(*kapi.ReplicationController) if !isController { return false, fmt.Errorf("received unknown object while watching for deployments: %v", obj) } observed = obj switch deployutil.DeploymentStatusFor(observed) { case api.DeploymentStatusRunning, api.DeploymentStatusFailed, api.DeploymentStatusComplete: return true, nil case api.DeploymentStatusNew, api.DeploymentStatusPending: return false, nil default: return false, ErrUnknownDeploymentPhase } }); err != nil { return observed, false, err } return observed, true, nil }
func LoadExistingNextReplicationController(c client.ReplicationControllersNamespacer, namespace, newName string) (*api.ReplicationController, error) { if len(newName) == 0 { return nil, nil } newRc, err := c.ReplicationControllers(namespace).Get(newName) if err != nil && errors.IsNotFound(err) { return nil, nil } return newRc, err }
func FindSourceController(r client.ReplicationControllersNamespacer, namespace, name string) (*api.ReplicationController, error) { list, err := r.ReplicationControllers(namespace).List(labels.Everything()) if err != nil { return nil, err } for ix := range list.Items { rc := &list.Items[ix] if rc.Annotations != nil && strings.HasPrefix(rc.Annotations[sourceIdAnnotation], name) { return rc, nil } } return nil, fmt.Errorf("couldn't find a replication controller with source id == %s/%s", namespace, name) }
func Rename(c client.ReplicationControllersNamespacer, rc *api.ReplicationController, newName string) error { oldName := rc.Name rc.Name = newName rc.ResourceVersion = "" _, err := c.ReplicationControllers(rc.Namespace).Create(rc) if err != nil { return err } err = c.ReplicationControllers(rc.Namespace).Delete(oldName) if err != nil && !errors.IsNotFound(err) { return err } return nil }
// GetReplicationControllerListChannel Returns a pair of channels to a // Replication Controller list and errors that both must be read // numReads times. func GetReplicationControllerListChannel(client client.ReplicationControllersNamespacer, nsQuery *NamespaceQuery, numReads int) ReplicationControllerListChannel { channel := ReplicationControllerListChannel{ List: make(chan *api.ReplicationControllerList, numReads), Error: make(chan error, numReads), } go func() { list, err := client.ReplicationControllers(nsQuery.ToRequestParam()).List(listEverything) var filteredItems []api.ReplicationController for _, item := range list.Items { if nsQuery.Matches(item.ObjectMeta.Namespace) { filteredItems = append(filteredItems, item) } } list.Items = filteredItems for i := 0; i < numReads; i++ { channel.List <- list channel.Error <- err } }() return channel }
// decodeFromLatestDeployment will try to return the decoded version of the current deploymentconfig // found in the annotations of its latest deployment. If there is no previous deploymentconfig (ie. // latestVersion == 0), the returned deploymentconfig will be the same. func decodeFromLatestDeployment(config *deployapi.DeploymentConfig, rn kclient.ReplicationControllersNamespacer, decoder runtime.Decoder) (*deployapi.DeploymentConfig, error) { if config.Status.LatestVersion == 0 { return config, nil } latestDeploymentName := deployutil.LatestDeploymentNameForConfig(config) deployment, err := rn.ReplicationControllers(config.Namespace).Get(latestDeploymentName) if err != nil { // If there's no deployment for the latest config, we have no basis of // comparison. It's the responsibility of the deployment config controller // to make the deployment for the config, so return early. return nil, err } decoded, err := deployutil.DecodeDeploymentConfig(deployment, decoder) if err != nil { return nil, errors.NewInternalError(err) } return decoded, nil }
func Rename(c client.ReplicationControllersNamespacer, rc *api.ReplicationController, newName string) error { oldName := rc.Name rc.Name = newName rc.ResourceVersion = "" // First delete the oldName RC and orphan its pods. trueVar := true err := c.ReplicationControllers(rc.Namespace).Delete(oldName, &api.DeleteOptions{OrphanDependents: &trueVar}) if err != nil && !errors.IsNotFound(err) { return err } err = wait.Poll(5*time.Second, 60*time.Second, func() (bool, error) { _, err := c.ReplicationControllers(rc.Namespace).Get(oldName) if err == nil { return false, nil } else if errors.IsNotFound(err) { return true, nil } else { return false, err } }) if err != nil { return err } // Then create the same RC with the new name. _, err = c.ReplicationControllers(rc.Namespace).Create(rc) if err != nil { return err } return nil }