*
     * Implementations should consider caching the results, so the subsequent invocations should be performed instantly.
     *
     * Implementation cannot use the Kotlin resolve inside, as this function is called during session initialization, so Analysis API access is forbidden.
     */

if [[ "$TFCI_DOCKER_PULL_ENABLE" == 1 ]]; then
  # Simple retry logic for docker-pull errors. Sleeps if a pull fails.
  # Pulling an already-pulled container image will finish instantly, so
  # repeating the command costs nothing.
  docker pull "$TFCI_DOCKER_IMAGE" || sleep 15
  docker pull "$TFCI_DOCKER_IMAGE" || sleep 30
  docker pull "$TFCI_DOCKER_IMAGE" || sleep 60
  docker pull "$TFCI_DOCKER_IMAGE"

 *
 * @param <T> type of build operations to hold
 */
public interface BuildOperationQueue<T extends BuildOperation> {

    /**
     * Adds an operation to be executed, potentially executing it instantly.
     *
     * @param operation operation to execute
     */
    void add(T operation);

    /**
     * Cancels all queued operations in this queue.  Any operations that have started will be allowed to complete.

 *
 * TODO: The logic in this visitor should be integrated directly into the DefaultLocalConfigurationMetadataBuilder
 * so that we instantly mark configurations as observed as their metadata is constructed. That would be an improvement
 * over this visitor, since here we only mark a configuration observed if its metadata is present in the final graph.

		}
		if windows.SupportTCPInitialRTONoSYNRetransmissions() {
			// In Windows 10.0.16299 TCP_INITIAL_RTO_NO_SYN_RETRANSMISSIONS makes ConnectEx() fails instantly.
			params.MaxSynRetransmissions = windows.TCP_INITIAL_RTO_NO_SYN_RETRANSMISSIONS
		}
		var out uint32
		// Don't abort the connection if WSAIoctl fails, as it is only an optimization.

// in threaded C programs that use popen.
//
// Luckily, the file descriptors that are most important not to
// inherit are not the ones that can take an arbitrarily long time
// to create: pipe returns instantly, and the net package uses
// non-blocking I/O to accept on a listening socket.
// The rules for which file descriptor-creating operations use the
// ForkLock are as follows:
//

/**
 * A dynamic collection of {@link NamedInstant} objects. When a property of this object is accessed from a test thread, a new instant is defined. When
 * accessed from the main thread, queries an existing instant, asserting that it exists.
 */
class Instants implements InstantFactory, OperationListener {
    private final Object lock = new Object()
    private final Map<String, NamedInstant> timePoints = [:]

/**
 * A point in time.
 */
class Instant implements Comparable<Instant> {
    final long nanos

    Instant(long nanos) {
        this.nanos = nanos
    }

    @Override
    String toString() {
        return "[instant at $nanos]"
    }

    int compareTo(Instant t) {
        return nanos.compareTo(t.nanos)
    }

    Instant plus(long millis) {

    /**
     * An object that allows instants to be defined and queried.
     *
     * @see NamedInstant
     */
    final Instants instant = new Instants(logger)

    /**
     * An object that allows operations to be defined and queried.
     *
     * @see NamedOperation
     */
    final Operations operation = new Operations(instant, instant)

    /**

/**
 * A target for blocking. Exposes each named instant as a property, and accessing that property will block until the
 * instant has been reached.
 */
class BlockTarget {
    private final Instants instants

    BlockTarget(Instants instants) {
        this.instants = instants
    }

    def getProperty(String name) {
        instants.waitFor(name)
        true
    }