*
     * <p>If the target Gradle version is &gt;=6.8 then you can execute tasks from included builds. You can target tasks from included builds by specifying the task identity path (i.e. {@code
     * ':included-build-name:subproject-name:taskName'}).</p>
     *

    default DependencyResolverResult collect(@Nonnull Session session, @Nonnull DependencyCoordinate root) {
        return collect(DependencyResolverRequest.build(session, DependencyResolverRequest.RequestType.COLLECT, root));
    }

    /**
     * Collects the transitive dependencies of some artifacts and builds a dependency graph. Note that this operation is

By watching the file system, Gradle keeps the VFS current between builds.

== Enable

Gradle enables file system watching by default for supported operating systems since Gradle 7.

Run the build with the '--watch-fs' flag to force file system watching for a build.

  # command to reattempt build a few times in the case of failure (b/302558736)
  set +e
  for i in $(seq 1 5)
  do
    docker build \
    --build-arg REQUIREMENTS_FILE=jax.requirements.txt \
    --target=$target \
    --cache-from "$IMAGE" \
    -t "$IMAGE" -t "$AR_IMAGE" . && break
  done
  final=$?
  if [ $final -ne 0 ]; then
    exit $final
  fi
  set -e

package org.gradle.integtests.composite

import org.gradle.integtests.fixtures.AbstractIntegrationSpec
import org.gradle.integtests.fixtures.build.BuildTestFile

class CompositeBuildBuildSrcIntegrationTest extends AbstractIntegrationSpec {

    def "included and composing builds can contain buildSrc builds"() {
        def outerBuild = new BuildTestFile(testDirectory, "root")

    /**
     * Called once per build invocation on a build, to register any build scoped services to use during that build invocation. These services are closed at the end of the build invocation.
     *
     * <p>Global, user home, build session and build tree services are visible to the build scope services, but not vice versa.</p>
     *
     * @see Scope.Build
     */

            projects.values().each { it.writeFiles() }
        }
    }

    class ProjectFixture {
        final BuildFixture build
        final String path
        final Map<String, TaskFixture> tasks = [:]

        ProjectFixture(BuildFixture build, String path) {
            this.build = build
            this.path = path
        }

        TaskFixture task(String name) {

	return push.Telemetry.TCPFilters(proxy, class, svc)
}

// setAccessLogAndBuildTCPFilter sets the AccessLog configuration in the given
// TcpProxy instance and builds a TCP filter out of it.
func setAccessLogAndBuildTCPFilter(push *model.PushContext, node *model.Proxy,
	config *tcp.TcpProxy, class istionetworking.ListenerClass, svc *model.Service,
) *listener.Filter {

		}
	}
	return webhookAuthResolverWrapper
}

// AuthenticationInfoResolver builds rest.Config base on the server or service
// name and service namespace.
type AuthenticationInfoResolver interface {
	// ClientConfigFor builds rest.Config based on the hostPort.
	ClientConfigFor(hostPort string) (*rest.Config, error)
	// ClientConfigForService builds rest.Config based on the serviceName and
	// serviceNamespace.

import org.gradle.internal.service.scopes.StatefulListener;

/**
 * A listener that is notified when a root build is started and completed. No more than one root build may run at a given time.
 *
 * A root build may contain zero or more nested builds, such as `buildSrc` or included builds.
 *
 * This listener type is available to services from build tree up to global services.
 */
@EventScope(Scope.BuildTree.class)
@StatefulListener