// finishRequest makes a given resultFunc asynchronous and handles errors returned by the response.
// Any api.Status object returned is considered an "error", which interrupts the normal response flow.
func finishRequest(timeout time.Duration, fn resultFunc) (result runtime.Object, err error) {
// these channels need to be buffered to prevent the goroutine below from hanging indefinitely
// when the select statement reads something other than the one the goroutine sends on.
ch := make(chan runtime.Object, 1)
errCh := make(chan error, 1)
go func() {
if result, err := fn(); err != nil {
errCh <- err
} else {
ch <- result
}
}()
select {
case result = <-ch:
if status, ok := result.(*api.Status); ok {
return nil, errors.FromObject(status)
}
return result, nil
case err = <-errCh:
return nil, err
case <-time.After(timeout):
return nil, errors.NewTimeoutError("request did not complete within allowed duration", 0)
}
}
func (r *REST) waitForBuild(ctx kapi.Context, build *api.Build) error {
fieldSelector := fields.Set{"metadata.name": build.Name}.AsSelector()
w, err := r.BuildRegistry.WatchBuilds(ctx, labels.Everything(), fieldSelector, build.ResourceVersion)
if err != nil {
return err
}
defer w.Stop()
done := make(chan struct{})
errchan := make(chan error)
go func(ch <-chan watch.Event) {
for event := range ch {
obj, ok := event.Object.(*api.Build)
if !ok {
errchan <- fmt.Errorf("event object is not a Build: %#v", event.Object)
break
}
switch obj.Status {
case api.BuildStatusCancelled:
errchan <- fmt.Errorf("Build %s/%s was cancelled", build.Namespace, build.Name)
break
case api.BuildStatusError:
errchan <- fmt.Errorf("Build %s/%s is in an error state", build.Namespace, build.Name)
break
case api.BuildStatusRunning, api.BuildStatusComplete, api.BuildStatusFailed:
done <- struct{}{}
break
}
}
}(w.ResultChan())
select {
case err := <-errchan:
return err
case <-done:
return nil
case <-time.After(r.Timeout):
return errors.NewTimeoutError(fmt.Sprintf("timed out waiting for Build %s/%s", build.Namespace, build.Name), 1)
}
}