// WaitForADeployment waits for a Deployment to fulfill the isOK function
func WaitForADeployment(client kclient.ReplicationControllerInterface,
name string,
isOK, isFailed func(*kapi.ReplicationController) bool) error {
startTime := time.Now()
endTime := startTime.Add(15 * time.Minute)
for time.Now().Before(endTime) {
requirement, err := labels.NewRequirement(deployapi.DeploymentConfigAnnotation, labels.EqualsOperator, sets.NewString(name))
if err != nil {
return fmt.Errorf("unexpected error generating label selector: %v", err)
}
list, err := client.List(labels.LabelSelector{*requirement}, fields.Everything())
if err != nil {
return err
}
for i := range list.Items {
if isOK(&list.Items[i]) {
return nil
}
if isFailed(&list.Items[i]) {
return fmt.Errorf("The deployment %q status is %q",
name, list.Items[i].Annotations[deployapi.DeploymentStatusAnnotation])
}
}
rv := list.ResourceVersion
w, err := client.Watch(labels.LabelSelector{*requirement}, fields.Everything(), rv)
if err != nil {
return err
}
defer w.Stop()
for {
val, ok := <-w.ResultChan()
if !ok {
// reget and re-watch
break
}
if e, ok := val.Object.(*kapi.ReplicationController); ok {
if isOK(e) {
return nil
}
if isFailed(e) {
return fmt.Errorf("The deployment %q status is %q",
name, e.Annotations[deployapi.DeploymentStatusAnnotation])
}
}
}
}
return fmt.Errorf("the deploy did not finish within 3 minutes")
}
// WaitForADeployment waits for a deployment to fulfill either isOK or isFailed.
// When isOK returns true, WaitForADeployment returns nil, when isFailed returns
// true, WaitForADeployment returns an error including the deployment status.
// WaitForADeployment waits for at most a certain timeout (non-configurable).
func WaitForADeployment(client kclient.ReplicationControllerInterface, name string, isOK, isFailed func(*kapi.ReplicationController) bool, oc *CLI) error {
timeout := 15 * time.Minute
// closing done signals that any pending operation should be aborted.
done := make(chan struct{})
defer close(done)
// okOrFailed returns whether a replication controller matches either of
// the predicates isOK or isFailed, and the associated error in case of
// failure.
okOrFailed := func(rc *kapi.ReplicationController) (err error, matched bool) {
if isOK(rc) {
return nil, true
}
if isFailed(rc) {
return fmt.Errorf("The deployment %q status is %q", name, rc.Annotations[deployapi.DeploymentStatusAnnotation]), true
}
return nil, false
}
// waitForDeployment waits until okOrFailed returns true or the done
// channel is closed.
waitForDeployment := func() (err error, retry bool) {
requirement, err := labels.NewRequirement(deployapi.DeploymentConfigAnnotation, selection.Equals, sets.NewString(name))
if err != nil {
return fmt.Errorf("unexpected error generating label selector: %v", err), false
}
list, err := client.List(kapi.ListOptions{LabelSelector: labels.NewSelector().Add(*requirement)})
if err != nil {
return err, false
}
// multiple deployments are conceivable; so we look to see how the latest depoy does
var lastRC *kapi.ReplicationController
for _, rc := range list.Items {
if lastRC == nil {
lastRC = &rc
continue
}
// assuming won't have to deal with more than 9 deployments
if lastRC.GetName() <= rc.GetName() {
lastRC = &rc
}
}
if lastRC != nil {
err, matched := okOrFailed(lastRC)
if matched {
return err, false
}
}
w, err := client.Watch(kapi.ListOptions{LabelSelector: labels.NewSelector().Add(*requirement), ResourceVersion: list.ResourceVersion})
if err != nil {
return err, false
}
defer w.Stop()
for {
select {
case val, ok := <-w.ResultChan():
if !ok {
// watcher error, re-get and re-watch
return nil, true
}
if rc, ok := val.Object.(*kapi.ReplicationController); ok {
if lastRC == nil {
lastRC = rc
}
// multiple deployments are conceivable; so we look to see how the latest depoy does
if lastRC.GetName() <= rc.GetName() {
lastRC = rc
err, matched := okOrFailed(rc)
if matched {
return err, false
}
}
}
case <-done:
// no more time left, stop what we were doing,
// do no retry.
return nil, false
}
}
}
// errCh is buffered so the goroutine below never blocks on sending,
// preventing a goroutine leak if we reach the timeout.
errCh := make(chan error, 1)
go func() {
defer close(errCh)
err, retry := waitForDeployment()
for retry {
err, retry = waitForDeployment()
}
errCh <- err
}()
select {
case err := <-errCh:
if err != nil {
DumpDeploymentLogs(name, oc)
}
return err
case <-time.After(timeout):
DumpDeploymentLogs(name, oc)
// end for timing issues where we miss watch updates
return fmt.Errorf("timed out waiting for deployment %q after %v", name, timeout)
}
}