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)

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

@ServiceScope(Scope.Global.class)
public interface FileLockManager {
    /**
     * Creates a lock for the given file with the given mode. Acquires a lock with the given mode, which is held until the lock is
     * released by calling {@link FileLock#close()}. This method blocks until the lock can be acquired.
     *
     * @param target The file to be locked.
     * @param options The lock options.

     *
     * <p>The Ivy instance of the calling thread is reused if the thread is already executing an action against an Ivy instance.
     */
    void withIvy(Action<? super Ivy> action);

    /**
     * Executes the given action against an Ivy instance and returns the result. Sets up the Ivy context before the action and cleans up at the end.
     *

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

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

import org.gradle.api.problems.Severity;

public interface InternalProblemBuilder extends InternalProblemSpec {

    /**
     * Creates the new problem. Calling this method won't report the problem via build operations, it can be done separately by calling {@link org.gradle.api.problems.internal.InternalProblemReporter#report(Problem)}.
     *
     * @return the new problem
     */
    Problem build();

    @Override

The new methods [Value.Seq] and [Value.Seq2] return sequences that iterate over the value
as though it were used in a for/range loop.
The new methods [Type.CanSeq] and [Type.CanSeq2] report whether calling