tendermint/rpc/client/helpers.go

package client

import (
	"time"

	"github.com/pkg/errors"
	"github.com/tendermint/tendermint/types"
	cmn "github.com/tendermint/tmlibs/common"
	events "github.com/tendermint/tmlibs/events"
)

// Waiter is informed of current height, decided whether to quit early
type Waiter func(delta int) (abort error)

// DefaultWaitStrategy is the standard backoff algorithm,
// but you can plug in another one
func DefaultWaitStrategy(delta int) (abort error) {
	if delta > 10 {
		return errors.Errorf("Waiting for %d blocks... aborting", delta)
	} else if delta > 0 {
		// estimate of wait time....
		// wait half a second for the next block (in progress)
		// plus one second for every full block
		delay := time.Duration(delta-1)*time.Second + 500*time.Millisecond
		time.Sleep(delay)
	}
	return nil
}

// Wait for height will poll status at reasonable intervals until
// the block at the given height is available.
//
// If waiter is nil, we use DefaultWaitStrategy, but you can also
// provide your own implementation
func WaitForHeight(c StatusClient, h int, waiter Waiter) error {
	if waiter == nil {
		waiter = DefaultWaitStrategy
	}
	delta := 1
	for delta > 0 {
		s, err := c.Status()
		if err != nil {
			return err
		}
		delta = h - s.LatestBlockHeight
		// wait for the time, or abort early
		if err := waiter(delta); err != nil {
			return err
		}
	}
	return nil
}

// WaitForOneEvent subscribes to a websocket event for the given
// event time and returns upon receiving it one time, or
// when the timeout duration has expired.
//
// This handles subscribing and unsubscribing under the hood
func WaitForOneEvent(evsw types.EventSwitch,
	evtTyp string, timeout time.Duration) (types.TMEventData, error) {
	listener := cmn.RandStr(12)

	evts, quit := make(chan events.EventData, 10), make(chan bool, 1)
	// start timeout count-down
	go func() {
		time.Sleep(timeout)
		quit <- true
	}()

	// register for the next event of this type
	evsw.AddListenerForEvent(listener, evtTyp, func(data events.EventData) {
		evts <- data
	})
	// make sure to unregister after the test is over
	defer evsw.RemoveListenerForEvent(evtTyp, listener)
	// defer evsw.RemoveListener(listener)  // this also works

	select {
	case <-quit:
		return types.TMEventData{}, errors.New("timed out waiting for event")
	case evt := <-evts:
		tmevt, ok := evt.(types.TMEventData)
		if ok {
			return tmevt, nil
		}
		return types.TMEventData{}, errors.Errorf("Got unexpected event type: %#v", evt)
	}
}