private PluginResolution resolveFromIncludedPluginBuilds(PluginId requestedPluginId) {
            for (IncludedBuildState build : buildIncluder.getRegisteredPluginBuilds()) {
                buildIncluder.prepareForPluginResolution(build);
                Optional<PluginResolution> pluginResolution = build.withState(gradleInternal -> LocalPluginResolution.resolvePlugin(gradleInternal, requestedPluginId));

This way, the configuration time of a large multi-project build can be reduced.

The configuration-on-demand feature is _incubating_, so only some builds are guaranteed to work correctly.
The feature works well for <<#sec:decoupled_projects,decoupled>> multi-project builds.

	"k8s.io/kubernetes/pkg/scheduler/framework"
	frameworkruntime "k8s.io/kubernetes/pkg/scheduler/framework/runtime"
)

// RecorderFactory builds an EventRecorder for a given scheduler name.
type RecorderFactory func(string) events.EventRecorder

// newProfile builds a Profile for the given configuration.
func newProfile(ctx context.Context, cfg config.KubeSchedulerProfile, r frameworkruntime.Registry, recorderFact RecorderFactory,

				b.Args = append(b.Args, args)
			}
			builds = append(builds, b)
		}
	}

	// Warm up our base images while we are building everything. This isn't pulling them -- we actually
	// never pull them -- but it is pulling the config file from the remote registry.
	builder.WarmBase(ctx, a.Architectures, sets.SortedList(bases)...)

	// Build all dependencies
	makeStart := time.Now()

    }

    @Requires(IntegTestPreconditions.NotParallelExecutor)
    @UnsupportedWithConfigurationCache(because = "parallel by default")
    def "reuses compiler daemons within a multi-project build across multiple builds when enabled"() {
        withMultiProjectSources()
        withPersistentScalaCompilerDaemons()

        when:
        succeeds("compileAll")

        then:

+
At this point, you should be able to switch to using proper project dependencies attached to the appropriate dependency configurations.
 7. Clean up projects once no part of the Ant build depends on them.
+
We mentioned in step 5 that you might need to add copy tasks to satisfy the requirements of dependent Ant builds.
Once those builds have been migrated, such build logic will no longer be needed and should be removed.

== Step 4. Understanding Remote Caching
In addition to the local build cache present on a developer's machine, Gradle can make use of remote build caches which can be used by multiple developers.

The idea of a remote cache is to share commonly built task outputs across remote builds to improve build times.

When both remote and local caches are enabled, then the build output is first checked in the local cache.

 * under the License.
 */
package org.apache.maven.settings.building;

/**
 * Builds the effective settings from a user settings file, a project settings file
 * and/or a global settings file.
 *
 */
public interface SettingsBuilder {

    /**
     * Builds the effective settings of the specified settings files.
     *

        failure.assertThatCause(Matchers.containsText("Multiple build operations failed"));
    }

    // This is the current behavior:
    // We need to make sure that the build operation ids of nested builds started by a GradleBuild task do not overlap.

    private static final String IS_DEPRECATED = "(but this behavior is marked deprecated)";

    private UsageDescriber() { /* not instantiable */ }

    /**
     * Builds a human-readable description of the usage allowed by the given role.
     *
     * @param role the role to describe
     * @return a human-readable description of the role's allowed usage
     */