import org.gradle.api.attributes.Attribute;

/**
 * Represents the target JVM environment. Typically, a standard JVM or Android.
 * This attribute can be used by libraries to indicate that a certain variant is better suited for
 * a certain JVM environment. It does however NOT strictly require environments to match, as the
 * general assumption is that Java libraries can also run on environments they are not optimized for.
 *
 * @since 7.0
 */

	))
}

func mustBuildEnvs(baseEnv *environment.EnvSet) map[string]*environment.EnvSet {
	buildEnvSet := func(envOpts []cel.EnvOption, declTypes []*apiservercel.DeclType) *environment.EnvSet {
		env, err := baseEnv.Extend(environment.VersionedOptions{
			IntroducedVersion: version.MajorMinor(1, 0),
			EnvOptions:        envOpts,
			DeclTypes:         declTypes,

The install is organized in 'environments' - each environment consists of a set of components
in different namespaces that are configured to work together. Regardless of 'environment',
workloads can talk with each other and obey the Istio configuration resources, but each environment
can use different Istio versions and different configuration defaults.

        public final Map<String, String> environments = new HashMap<>();
        public final List<String> args = new ArrayList<>();
        public File executable;

        @Override
        public CompilerExecSpec environment(String key, String value) {
            environments.put(key, value);
            return this;
        }

        @Override

apiVersion: release-notes/v2
kind: enhancement
area: environments
issue:
- 31732
releaseNotes:
- |

about just retrofitting monolithic applications onto modern container based compute environment. A cloud-native application is portable and resilient by design, and can scale horizontally by simply replicating. Modern orchestration platforms like Kubernetes, DC/OS make replicating and managing containers in huge clusters easier than ever.

While containers provide isolated application execution environment, orchestration platforms allow seamless scaling by helping replicate and manage containers....

   ([#123001](https://github.com/kubernetes/kubernetes/pull/123001), [@tkashem](https://github.com/tkashem))
- Introduced a feature gate mechanism to `client-go`. Depending on the actual implementation, users can control features via environmental variables or command line options. ([#122555](https://github.com/kubernetes/kubernetes/pull/122555), [@p0lyn0mial](https://github.com/p0lyn0mial))

Finally, you'll need to provide an environment-agnostic constructor for your component:

```go
package mycomponent

func New(ctx resource.Context) (i Instance, err error){
    err = resource.UnsupportedEnvironment(ctx.Environment())
    ctx.Environment().Case(environment.Native, func() {
        i, err = newNative(ctx)
    })
    ctx.Environment().Case(environment.Kube, func() {
        i, err = newKube(ctx)

                if (expected[key] != actual[key]) {
                    throw new GradleException(""\"
Environment's \$key did not match!
Expected: \${expected[key]}
Actual: \${actual[key]}
""\")
                }
            }

            rootProject {
                def gradleEnvironment = file("gradle-environment")
                tasks.matching { it.name == '$ideTaskName' }.all { ideTask ->
                    ideTask.doLast {

	// combinations for the convenience of reading logs at build.golang.org
	// and local development. It's not a goal to recognize all environments.
	if v, ok := node(); ok {
		return "Node.js " + v, nil
	}
	return "", fmt.Errorf("unrecognized environment")
}

func node() (version string, ok bool) {
	// Try the https://nodejs.org/api/process.html#processversion API.
	p := js.Global().Get("process")