+
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.

+
This will create all the Gradle build files you need, even for <<migmvn:multimodule_builds,multi-module builds>>.
For simpler Maven projects, the Gradle build will be ready to run!
+
 . link:https://scans.gradle.com[Create a build scan for the Gradle build].
+
A build scan will make it easier to visualize what's happening in the build.

	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 {

== Finding problems with task output caching

Below we describe a step-by-step process that should help shake out any problems with caching in your build.

=== Ensure incremental build works

First, make sure your build does the right thing without the cache.
Run a build twice without enabling the Gradle build cache.
The expected outcome is that all actionable tasks that produce file outputs are up-to-date.

     *       {@code "META-INF/versions/{n}/"} subdirectory, builds a singleton map with
     *       the module name declared in that descriptor.</li>
     *   <li>Otherwise if an {@code "Automatic-Module-Name"} attribute is declared in the
     *       {@code META-INF/MANIFEST.MF} file, builds a singleton map with the value of that attribute.</li>
     * </ul>
     *
     * Otherwise builds an empty map.
     *

== Step 7. Understanding the Build script
Each subproject contains its own `build.gradle(.kts)` file.

The `build.gradle(.kts)` file is the core component of the build process and defines the tasks necessary to build the project.

The `build.gradle(.kts)` file is read and executed by Gradle.

Take a closer look at the build file in your `app` subproject (under the `app` directory):

        val builds = mutableMapOf<BuildState, BuildToStore>()
        host.visitBuilds { build ->
            val state = build.state
            builds[state] = BuildToStore(build, build.hasScheduledWork, build.isRootBuild)
            if (build.hasScheduledWork && state is StandAloneNestedBuild) {
                // Also require the owner of a buildSrc build

        when:
        def build = executer.withTasks("help").withArguments("--info").start()

        then:
        build.waitForFinish()

        and:
        daemons.daemons.size() == 2

        and:
        !build.standardOutput.contains(DaemonMessages.WAITING_ON_CANCELED)
    }

    def "starts a new daemon when daemons with canceled builds do not become available"() {
        buildFile << """

                }
                configurations['default'].outgoing.artifact(jar)
            }
        '''
        fixture.prepare()
    }

    @ToBeFixedForConfigurationCache
    def "selects and builds from master for latest.integration selector"() {
        given:
        buildFile << """
            dependencies { compile 'test:test:latest.integration' }
        """
        repo.commit("v1")

    }

    /**
     * Pause between builds for the following reasons:
     *
     * <ul>
     * <li>better simulate a normal development lifecycle where builds are rarely executed
     * back-to-back, as there is typically some work being done between the builds,</li>
     * <li>give file system events a chance to arrive; otherwise we might detect them during
     * the build, and invalidating the VFS,