Method Wait

util/initializer.go:100–143

Wait waits until the most recent attempt finishes (i.e., "done" is closed) or until the context is canceled. If the task has never begun (still pending), Wait will block until it eventually starts or ctx is canceled.

(ctx context.Context)

// or until the context is canceled.
// If the task has never begun (still pending), Wait will block until it eventually starts or ctx is canceled.
func (t *BootstrapTask) Wait(ctx context.Context) error {
	for {
		state := TaskState(t.state.Load())
		if state == TaskSucceeded || state == TaskFailed || state == TaskTimedOut || state == TaskFatal {
			lastErr, ok := t.lastErr.Load().(wrappedError)
			if ok && lastErr.err != nil {
				return lastErr.err
			}
			return nil
		}
		ch := t.doneVal.Load()
		if ch == nil {
			// The task hasn't started an attempt yet. If the state is no longer pending, break out.
			if state != TaskPending {
				// It's either running, failed, or succeeded => loop again so we re-fetch the channel.
				continue
			}
			// We'll just do a short sleep or yield.
			select {
			case <-ctx.Done():
				return ctx.Err()
			case <-time.After(10 * time.Millisecond):
				// keep looping until the task actually starts
				continue
			}
		} else {
			// We have a valid channel. Wait on it or until context is canceled.
			select {
			case <-ctx.Done():
				return ctx.Err()
			case <-ch.(chan struct{}):
				// The attempt ended. Check if we failed.
				if TaskState(t.state.Load()) == TaskFailed {
					wr, _ := t.lastErr.Load().(wrappedError)
					if wr.err == nil {
						t.lastErr.Store(wrappedError{err: errors.New("task failed without specific error")})
					}
					return wr.err
				}
				return nil // Succeeded or otherwise finished
			}
		}
	}
}

// attempt is called just before a new attempt to run t.Fn.
func (t *BootstrapTask) beginAttempt() {