code: func UntilWithoutRetry(ctx context.Context, watcher watch.Interface, conditions ...ConditionFunc) (*watch.Event, error) {
  	ch := watcher.ResultChan()
  	defer watcher.Stop()
  	var lastEvent *watch.Event
  	for _, condition := range conditions {
  		// check the next condition against the previous event and short circuit waiting for the next watch
  		if lastEvent != nil {
  			done, err := condition(*lastEvent)
  			if err != nil {
  				return lastEvent, err
  			}
  			if done {
  				continue
  			}
  		}
  	ConditionSucceeded:
  		for {
  			select {
  			case event, ok := <-ch:
  				if !ok {
  					return lastEvent, ErrWatchClosed
  				}
  				lastEvent = &event
  
  				done, err := condition(event)
  				if err != nil {
  					return lastEvent, err
  				}
  				if done {
  					break ConditionSucceeded
  				}
  
  			case <-ctx.Done():
  				return lastEvent, wait.ErrWaitTimeout
  			}
  		}
  	}
  	return lastEvent, nil
  }
docs: // UntilWithoutRetry reads items from the watch until each provided condition succeeds, and then returns the last watch
  // encountered. The first condition that returns an error terminates the watch (and the event is also returned).
  // If no event has been received, the returned event will be nil.
  // Conditions are satisfied sequentially so as to provide a useful primitive for higher level composition.
  // Waits until context deadline or until context is canceled.
  //
  // Warning: Unless you have a very specific use case (probably a special Watcher) don't use this function!!!
  // Warning: This will fail e.g. on API timeouts and/or 'too old resource version' error.
  // Warning: You are most probably looking for a function *Until* or *UntilWithSync* below,
  // Warning: solving such issues.
  // TODO: Consider making this function private to prevent misuse when the other occurrences in our codebase are gone.