}

                @TaskAction
                void doDeployment() {
                    // we set a different key for every build so we can detect if we
                    // somehow get a different deployment handle between builds
                    def key = System.currentTimeMillis()

                    TestDeploymentHandle handle = getDeploymentRegistry().get('test', TestDeploymentHandle.class)

.PHONY: docker.push

### Docker commands ###
# Below provides various commands to build/push docker images.
# These are all wrappers around ./tools/docker, the binary that controls docker builds.
# Builds can also be done through direct ./tools/docker invocations.
# When using these commands the flow is:
#  1) make target calls ./tools/docker
#  2) ./tools/docker calls `make build.docker.x` targets to compute the dependencies required

        this.projectBuilds = projectBuilds;
    }

    public int getNumberOfBuilds() {
        return projectBuilds.size();
    }

    /**
     * Gets all the builds that have no reactor-dependencies
     *
     * @return A set of all the initial builds
     */
    public List<MavenProject> getRootSchedulableBuilds() {
        Set<MavenProject> result = new LinkedHashSet<>();

	servicePortStatPattern       = "%SERVICE_PORT%"
	serviceTargetPortStatPattern = "%TARGET_PORT%"
	servicePortNameStatPattern   = "%SERVICE_PORT_NAME%"
	subsetNameStatPattern        = "%SUBSET_NAME%"
)

// BuildStatPrefix builds a stat prefix based on the stat pattern.
func BuildStatPrefix(statPattern string, host string, subset string, port *model.Port, targetPort int, attributes *model.ServiceAttributes) string {

        if (jvmArgs.size > 1) {
            throw GradleException("gradle.properties and build-logic/gradle.properties have different org.gradle.jvmargs " +
                "which may cause two daemons to be spawned on CI and in IDEA. " +
                "Use the same org.gradle.jvmargs for both builds.")
        }
    }
}

fun readProperties(propertiesFile: File) = java.util.Properties().apply {

tasks.register('downloadGradle', DownloadGradle) {
    description = 'Downloads the Gradle distribution with a given version.'
    gradleVersion = '4.6'
}

tasks.register('createCustomGradleDistribution', Zip) {
    description = 'Builds custom Gradle distribution and bundles initialization scripts.'

    dependsOn downloadGradle

    def projectVersion = project.version
    archiveFileName = downloadGradle.gradleVersion.map { gradleVersion ->

plugins {
    id("gradlebuild.distribution.api-java")
}

description = "Tooling API model builders for native builds"

errorprone {
    disabledChecks.addAll(
        "MixedMutabilityReturnType", // 1 occurrences
    )
}

dependencies {
    api(projects.serviceProvider)
    api(project(":core-api"))
    api(project(":core"))
    api(project(":ide")) {
        because("To pick up various builders (which should live somewhere else)")

     *       {@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.
     *

# It's absurd, but builds with -compiler=gccgo used to fail to build module m.
# golang.org/issue/34358

env GO111MODULE=off

[short] skip
[cross] skip # gccgo can't necessarily cross-compile

cd m
go build
exists m$GOEXE
rm m$GOEXE
[exec:gccgo] go build -compiler=gccgo
[exec:gccgo] exists m$GOEXE

-- m/go.mod --
module m
-- m/main.go --
package main

== 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):