docker.gradle

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/*
 * Configuration for running (dunit) tests in parallel in Docker containers.
 * The container used must hava JAVA_HOME set in it's environment and must
 * have 'java' defined on the path. For example, the relevant Dockerfile
 * content could be:
 *
 *   ENV JAVA_HOME=/opt/jdk1.8.0_u101
 *   ENV PATH=$PATH:$JAVA_HOME/bin
 *
 * In addition, the container must have docker installed.
 *
 * The plugin can be activated with the Gradle property 'parallelDunit'.
 * Additional properties that can be set are:
 *
 *  dunitDockerImage   - The docker image used for running parallel dunits. The
 *                       default image is 'openjdk:8'. The image is required to
 *                       have 'JAVA_HOME' set as an environment variable.
 *  dunitParallelForks - The number of parallel containers that will be
 *                       launched. The default is 8.
 *  dunitDockerUser    - The user used within the docker container to run tests.
 *                       The default is 'root'.
 */


if (project.hasProperty('parallelDunit')) {
  def pwd = System.getenv('PWD')
  def geodeDir = new File(pwd).getCanonicalPath()
  ext.dunitDockerVolumes = ["${geodeDir}":geodeDir]
}

def dockerConfig = {
  maxParallelForks = dunitParallelForks.toInteger()

  docker {
    // base image for creating docker containers that execute the tests
    image = dunitDockerImage

    // volumes mounted to the containers
    // in a form: host_dir : container_dir
    def gradleHome = System.getenv('GRADLE_USER_HOME') ?: "${System.getenv('HOME')}/.gradle"
    volumes = ["${gradleHome}":gradleHome]

    // Add volumes configured by top-level build script
    volumes << project.dunitDockerVolumes

    // specify the user for starting Gradle test worker within the container.
    user = dunitDockerUser

    beforeContainerCreate = { cmd, client ->
      def javaHomeIdx = -1
      def pathIdx = -1
      def tmpEnv = []
      cmd.getEnv().each { tmpEnv << it }

      tmpEnv.eachWithIndex { x, j ->
        if (x.startsWith('JAVA_HOME')) {
          javaHomeIdx = j
        }
        if (x.startsWith('PATH')) {
          pathIdx = j
        }
      }

      // Remove JAVA_HOME and PATH env variables - they might not be the same as the container needs
      if (javaHomeIdx >= 0) {
        tmpEnv[javaHomeIdx] = 'JAVA_HOME_REMOVED='
      }
      if (pathIdx >= 0) {
        tmpEnv[pathIdx] = 'PATH_REMOVED='
      }

      if (project.hasProperty('testJVM') && !testJVM.trim().isEmpty()) {
        // Docker command is just 'java' so set to full path
        tmpEnv << ("JAVA_HOME=${project.testJVM}" as String)
      }


      // Unfortunately this snippet of code is here and is required by dev-tools/docker/base/entrypoint.sh.
      // This allows preserving the outer user inside the running container. Required for Jenkins
      // and other environments. There doesn't seem to be a way to pass this environment variable
      // in from a Jenkins Gradle job.
      if (System.env['LOCAL_USER_ID'] == null) {
        def username = System.getProperty("user.name")
        def uid = ['id', '-u', username].execute().text.trim()
        tmpEnv << ("LOCAL_USER_ID=${uid}" as String)
      }

      cmd.withEnv(tmpEnv)

      // Infer the index of this invocation
      def cmdList = cmd.getCmd()

      if (project.hasProperty('testJVM') && !testJVM.trim().isEmpty()) {
        // Docker command is just 'java' so set to full path
        cmdList[0] = ("${project.testJVM}/bin/java" as String)
      }

      def matcher = (cmdList[cmdList.length - 1] =~ /.*Executor (\d*).*/)

      def workdir = new File(cmd.getWorkingDir() + matcher[0][1])
      workdir.mkdirs()
      cmd.withWorkingDir(workdir.toString())

      // copy the classpath file to the working dir
      def classPathFileIndex = cmdList.findIndexOf { it =~ /^@.*gradle-worker-classpath.*txt$/ }
      if (classPathFileIndex > 0) {
        def dst = new File(workdir, "gradle-worker-classpath.txt")
        if (!dst.exists()) {
          def src = new File(cmdList[classPathFileIndex].substring(1))
          dst.write(src.text)
        }
        cmdList[classPathFileIndex] = '@'+dst.toString()
      }

      //println cmd
    }
  }
}
subprojects {
  apply plugin: 'com.github.pedjak.dockerized-test'

  if (project.hasProperty('parallelDunit')) {
    uiTest.configure(dockerConfig)
    repeatUnitTest.configure(dockerConfig)

    integrationTest.configure(dockerConfig)
    repeatIntegrationTest.configure(dockerConfig)

    distributedTest.configure(dockerConfig)
    repeatDistributedTest.configure(dockerConfig)

    upgradeTest.configure(dockerConfig)
    repeatUpgradeTest.configure(dockerConfig)

    acceptanceTest.configure(dockerConfig)
    repeatAcceptanceTest.configure(dockerConfig)
  }
}