func WaitFor(timeout int, predicate func() (bool, error)) error {
	type WaitForResult struct {
		Success bool
		Error   error
	}
	start := time.Now().Unix()
	for {
		if timeout >= 0 && time.Now().Unix()-start >= int64(timeout) {
			return fmt.Errorf("A timeout occurred")
		}
		time.Sleep(1 * time.Second)
		var result WaitForResult
		ch := make(chan bool, 1)
		go func() {
			defer close(ch)
			satisfied, err := predicate()
			result.Success = satisfied
			result.Error = err
		}()
		select {
		case <-ch:
			if result.Error != nil {
				return result.Error
			}
			if result.Success {
				return nil
			}
		case <-time.After(time.Duration(timeout) * time.Second):
			return fmt.Errorf("A timeout occurred")
		}
	}
}
WaitFor polls a predicate function, once per second, up to a timeout limit.
This is useful to wait for a resource to transition to a certain state.
To handle situations when the predicate might hang indefinitely, the
predicate will be prematurely cancelled after the timeout.
Resource packages will wrap this in a more convenient function that's
specific to a certain resource, but it can also be useful on its own.
package gophercloud
import (
	"fmt"
	"net/url"
	"path/filepath"
	"strings"
	"time"
)