*/

plugins {
    id("gradlebuild.distribution.implementation-java")
    id("gradlebuild.launchable-jar")
    id("gradlebuild.start-scripts")
}

description = "Java 6-compatible entry point of the `gradle` command. Boostraps the Gradle client implementation in :launcher."

gradlebuildJava.usedForStartup()

app {
    mainClassName = "org.gradle.launcher.GradleMain"
}

dependencies {

	return filepath.Join(b.plugin.host.GetPodPluginDir(b.podUID, utilstrings.EscapeQualifiedName(gitRepoPluginName)), b.volName)
}

func (b *gitRepoVolumeMounter) execCommand(command string, args []string, dir string) ([]byte, error) {
	cmd := b.exec.Command(command, args...)
	cmd.SetDir(dir)
	return cmd.CombinedOutput()
}

func validateVolume(src *v1.GitRepoVolumeSource) error {

          effect: "NoExecute"
      nodeSelector:
        kubernetes.io/os: linux
      containers:
        - image: registry.k8s.io/kas-network-proxy/proxy-agent:v0.30.3
          name: konnectivity-agent
          command: ["/proxy-agent"]
          args: [
                  "--logtostderr=true",
                  "--ca-cert=/var/run/secrets/kubernetes.io/serviceaccount/ca.crt",
__EXTRA_PARAMS__

        then:
        isDaemon action
    }

    def "daemon is used when command line option is used"() {
        when:
        def action = convert('--daemon', 'args')

        then:
        isDaemon action
    }

    def "does not use daemon when no-daemon command line option issued"() {
        given:
        useCurrentProcess = true

        when:

version: '3.7'

# Settings and configurations that are common for all containers
x-minio-common: &minio-common
  image: quay.io/minio/minio:${JOB_NAME}
  command: server --console-address ":9001" http://minio{1...4}/rdata{1...2}
  expose:
    - "9000"
    - "9001"
  environment:
    MINIO_CI_CD: "on"
    MINIO_ROOT_USER: "minio"
    MINIO_ROOT_PASSWORD: "minio123"
    MINIO_KMS_SECRET_KEY: "my-minio-key:OSMM+vkKUTCvQs9YL/CVMIMt43HFhkUpqJxTmGl6rYw="

import org.gradle.configuration.GradleLauncherMetaData;
import org.gradle.internal.invocation.BuildAction;
import org.gradle.launcher.exec.BuildActionParameters;

import java.util.UUID;

public class Build extends Command {
    private final BuildAction action;
    private final GradleLauncherMetaData buildClientMetaData;
    private final long startTime;
    private final boolean interactive;

    image: {{pillar['kube_docker_registry']}}/kube-proxy-{{pillar['host_arch']}}:{{pillar['kube-proxy_docker_tag']}}
    resources:
      requests:
        cpu: {{ cpurequest }}
        memory: {{ memoryrequest }}
    command:
    - /bin/sh
    - -c
    - exec kube-proxy {{api_servers_with_port}} {{kubeconfig}} {{cluster_cidr}} --oom-score-adj=-998 {{params}} 1>>/var/log/kube-proxy.log 2>&1
    {{container_env}}

                mainClass = 'None'
            }
        """

        when:
        withInstallations(jdk).run(":run", "--info")

        then:
        executedAndNotSkipped(":run")
        outputContains("Command: ${jdk.javaHome.absolutePath}")

        where:
        type           | jdk                                 | plugin
        'differentJdk' | AvailableJavaHomes.differentVersion | 'java-base'

    }

    static SystemPropertyInjection commandLine(String prop, String value) {
        return new SystemPropertyInjection() {
            @Override
            String getDescription() {
                return "using command-line"
            }

            @Override
            List<String> getGradleArgs() {
                return ["-D${prop}=${value}"]
            }
        }
    }

EXPOSE 5000

ARG service_version
ENV SERVICE_VERSION ${service_version:-v1}

# image will bind on TCP6 by default. In k8s pod spec (in a deployment pod template most likely) override for explicit IPv4 if needed with the command shown below:
# ["gunicorn", "-b", "[0.0.0.0]:5000", "app:app", "-k", "gevent"]