logger.V(4).Info(log("calling NodePrepareResources rpc"), "request", req)

	conn, err := p.getOrCreateGRPCConn()
	if err != nil {
		return nil, err
	}

	ctx, cancel := context.WithTimeout(ctx, p.clientTimeout)
	defer cancel()

	nodeClient := drapb.NewNodeClient(conn)
	response, err := nodeClient.NodePrepareResources(ctx, req)

    /**
     * Opens this file as an input stream. Generally, calling this method is more performant than calling {@code new
     * FileInputStream(getFile())}.
     *
     * @return The input stream. Never returns null. The caller is responsible for closing this stream.
     */
    InputStream open();

    /**
     * Copies the content of this file to an output stream. Generally, calling this method is more performant than

	getg().schedlink.set(callingG)
	mcall(func(gp *g) {
		callingG := gp.schedlink.ptr()
		gp.schedlink = 0

		// Unlock this goroutine from the M if necessary. The
		// calling G will relock.
		if gp.lockedm != 0 {
			gp.lockedm = 0
			gp.m.lockedg = 0
		}

		// Switch back to the calling goroutine. At some point
		// the scheduler will schedule us again and we'll
		// finish exiting.

    }

    def "does not fail when calling get() after producer task has completed"() {
        given:
        def property = propertyWithCompletedProducer()
        def provider = property.map { Integer.parseInt(it) }

        when:
        provider.get()

        then:
        0 * progressEventEmitter._
    }

    def "fails when calling getOrNull() before producer task has completed"() {
        given:

interface ProblemFactory {
    /**
     * Returns a default location inferred from the calling thread's state.
     */
    fun locationForCaller(consumer: String? = null): PropertyTrace

    /**
     * Creates a problem with the given message and exception.
     *
     * Problem has no documentation, and a default location is inferred from the calling thread's state.
     */

 */
public interface ResolutionAccess {

    /**
     * Get the owner of the resolution.
     */
    ResolutionHost getHost();

    /**
     * Get the request attributes for this resolution. Calling this method will lock-in the
     * request attributes from further mutation but will not perform resolution.
     */
    ImmutableAttributes getAttributes();

    /**

    /**
     * {@inheritDoc}
     *
     * <p>
     * This is similar to calling {@link #value(Iterable)} with a <code>null</code> argument.
     * </p>
     */
    @Override
    ListProperty<T> unset();

    /**
     * {@inheritDoc}
     *
     * <p>
     * This is similar to calling {@link #convention(Iterable)} with a <code>null</code> argument.
     * </p>
     */
    @Override

    /**
     * Updates the current value. The function is passed the current value or {@code null} if there is no value, and the function's return value is
     * used as the new value.
     *
     * <p>The calling thread must own the mutable state from which the value is calculated (via {@link ModelContainer#fromMutableState(Function)}). At most a single thread

            true
        }

        when:
        controller.load(key, cacheableEntity)

        then:
        0 * local.storeLocally(key, _)
    }

    def "stops calling through after read error"() {
        local = null

        when:
        def controller = getController()
        controller.load(key, cacheableEntity)
        controller.load(key, cacheableEntity)

// Multiple observed events may collapse to a single invocation of eventHandler().
//
// eventHandler() is invoked immediately after successful initialization of the filesystem watch,
// in case the path changed concurrent with calling WatchUntil().
func WatchUntil(ctx context.Context, pollInterval time.Duration, path string, eventHandler func(), errorHandler func(err error)) {
	if pollInterval <= 0 {
		panic(fmt.Errorf("pollInterval must be > 0"))
	}