build.gradle

import groovy.text.markup.MarkupTemplateEngine
import groovy.text.markup.TemplateConfiguration

buildscript {
  repositories {
    mavenLocal()
    mavenCentral()
    maven {
      url "http://repo.spring.io/snapshot"
    }
    maven {
      url "http://repo.spring.io/milestone"
    }
    maven {
      url "http://repo.spring.io/release"
    }
    maven {
      url "http://repo.spring.io/libs-staging-local/"
    }
    jcenter()
  }
  dependencies {
    classpath "org.springframework.boot:spring-boot-gradle-plugin:${hasProperty("BOOT_VERSION") ? "${project.property("BOOT_VERSION")}" : "1.4.4.RELEASE"}"
    if (hasProperty("docker")) {
      classpath 'se.transmode.gradle:gradle-docker:1.2'
    }
    //classpath 'org.codehaus.groovy:groovy-all:2.4.5'
  }
}

def commonProject = project(':common')
def commonZipkinProject = project(':common-zipkin')
def commonZipkinProjectOld = project(':common-zipkin-old')
def commonZipkinStreamProject = project(':common-zipkin-stream')
def acceptanceTestsProject = project(':acceptance-tests')
def zipkinServerProject = project(':zipkin-server')
def eurekaProject = project(':eureka')
def configServerProject = project(':config-server')
def zookeeperServerProject = project(':zookeeper')
def techProjects = [commonProject, commonZipkinProject, commonZipkinProjectOld, commonZipkinStreamProject, acceptanceTestsProject,
                    eurekaProject, zipkinServerProject, configServerProject,
                    zookeeperServerProject]
def nonZipkinProjects = techProjects - zipkinServerProject
def nonDockerProjects = [commonProject, commonZipkinProject, commonZipkinProjectOld, commonZipkinStreamProject, acceptanceTestsProject]
def zipkinRelatedProjects = subprojects - nonZipkinProjects

allprojects {
  apply plugin: 'java'
}

configure(subprojects) {

  apply plugin: 'java'
  apply plugin: 'eclipse'
  apply plugin: 'idea'
  apply plugin: 'org.springframework.boot'

  ext {
    dockerConfiguration = { int port ->
      if (hasProperty("docker")) {
        int debugPort = port - 1000
        dependsOn 'build'
        dryRun true
        addFile("${libsDir}/${project.name}-${buildNrLoc}.jar", "/${project.name}/${project.name}.jar")
        exposePort(port)
        exposePort(debugPort)
        // Random beacuse of https://wiki.apache.org/tomcat/HowTo/FasterStartUp
        entryPoint(['java', '-Xmx64m', '-Xss1024k',
                    "-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=$debugPort",
                    '-Djava.security.egd=file:/dev/./urandom', '-jar', "/${project.name}/${project.name}.jar"])
      } else {
        getLogger().debug("docker property is not set")
      }
    }
    createDockerTaskWithPort = { int port ->
      if (hasProperty("docker")) {
        project.task([type: Docker], "docker", ext.dockerConfiguration.curry(port))
      } else {
        getLogger().debug("docker property is not set")
      }
    }
    systemPropsFromGradle = {
      project.gradle.startParameter.systemPropertiesArgs.entrySet().collect { "-D${it.key}=${it.value}" }
    }
    systemPropsFromGradleContains = { String key ->
      project.gradle.startParameter.systemPropertiesArgs.containsKey(key)
    }
    whatToTest = { String propName ->
      String whatToTestProp = "WHAT_TO_TEST"
      return propName.equalsIgnoreCase(project.gradle.startParameter.systemPropertiesArgs.get(whatToTestProp)) ?:
        propName.equalsIgnoreCase(System.getenv(whatToTestProp))
    }
    propOrSysEnvPresent = { String propName ->
      project.hasProperty(propName) || systemPropsFromGradleContains(propName) || System.getenv(propName.toUpperCase())
    }
    moduleEnabled = { boolean enabled ->
      if (!enabled) {
        project.tasks*.enabled = false
      }
    }
    oldSleuthPresent = {
      String bom = "$BOM_VERSION".toString()
      return ["Brixton", "Camden"].any { bom.contains(it) }
    }
    //buildNrLoc = project.hasProperty('buildNr') ? "${buildNr}" : "1.0.0"
    //Since the migration is in progress - would keep the versions to snapshots
    buildNrLoc = project.hasProperty('buildNr') ? "${buildNr}" : "1.0-SNAPSHOT"
  }

  group = 'io.spring.cloud.samples.brewery'
  version = buildNrLoc

  sourceCompatibility = '1.8'

  configurations {
    all {
      resolutionStrategy {
        eachDependency { DependencyResolveDetails details ->
          // To prevent an accidental usage of groovy-all.jar and groovy.jar in different versions
          // all modularized Groovy jars are replaced with groovy-all.jar by default.
          if (details.requested.group == 'org.codehaus.groovy' && details.requested.name != "groovy-all") {
            details.useTarget("org.codehaus.groovy:groovy-all:${details.requested.version}")
          }
        }
      }
    }
  }

  repositories {
    mavenLocal()
    mavenCentral()
    maven {
      url "http://repo.spring.io/snapshot"
    }
    maven {
      url "http://repo.spring.io/milestone"
    }
    maven {
      url "http://repo.spring.io/release"
    }
    maven {
      url "http://repo.spring.io/libs-staging-local/"
    }
    jcenter()
  }

  dependencyManagement {
    imports {
      mavenBom "org.springframework.cloud:spring-cloud-dependencies:$BOM_VERSION"
      if (hasProperty("BOOT_VERSION")) {
        println "Using boot in version [${project.property("BOOT_VERSION")}]"
        mavenBom "org.springframework.boot:spring-boot-dependencies:${project.property("BOOT_VERSION")}"
      }
      if (ext.whatToTest('SCS')) mavenBom "io.pivotal.spring.cloud:spring-cloud-services-dependencies:$SCS_VERSION"
    }
  }

  task allDeps(type: DependencyReportTask) {}
}

logger.lifecycle("WHAT_TO_TEST is: System prop: [${project.gradle.startParameter.systemPropertiesArgs.get("WHAT_TO_TEST")}] , Env prop: [${System.getenv("WHAT_TO_TEST")}]")

configure(subprojects - zipkinServerProject - acceptanceTestsProject - zookeeperServerProject - configServerProject) {

  dependencies {
    compile 'org.projectlombok:lombok:1.16.6'
    compile "org.springframework.cloud:spring-cloud-starter-sleuth"
    if (!whatToTest('SCS')) compile "org.springframework.cloud:spring-cloud-starter-config"
    if (whatToTest('SCS')) compile("io.pivotal.spring.cloud:spring-cloud-services-starter-config-client")
    if (whatToTest('SCS')) compile("io.pivotal.spring.cloud:spring-cloud-services-starter-service-registry")
    compile "org.springframework.cloud:spring-cloud-starter-hystrix"
    compile "org.springframework.cloud:spring-cloud-starter-stream-${propOrSysEnvPresent('kafka') ? 'kafka' : 'rabbit'}"
    if (!whatToTest('SLEUTH')) {
      compile "org.springframework.cloud:spring-cloud-sleuth-stream"
    }
    compile "org.springframework.amqp:spring-amqp"
    compile "io.dropwizard.metrics:metrics-core"
    compile "io.dropwizard.metrics:metrics-graphite"
  }
}

configure(zipkinRelatedProjects) {

  dependencies {
    if (whatToTest('SLEUTH')) {
      compile "org.springframework.cloud:spring-cloud-starter-zipkin"
    }
  }
}

configure(nonDockerProjects) {

  bootRepackage {
    enabled = false
  }

  bootRun {
    enabled = false
  }
}

if (hasProperty("docker")) {
  configure(subprojects - nonDockerProjects) {

    apply plugin: 'docker'

    docker {
      baseImage 'frolvlad/alpine-oraclejdk8'
    }


  }
}

configure(subprojects) {

  apply plugin: 'maven'

  //Generate pom
  task generatePom {

    doLast {

      pom {

        withXml {

        }.writeTo("$buildDir/tmp/pom.xml")

      }

      def pomXml = new XmlParser().parse(file("$buildDir/tmp/pom.xml"))

      StringWriter stringWriter = new StringWriter()

      PrintWriter pw = new PrintWriter(stringWriter)

      XmlNodePrinter xmlNodePrinter = new XmlNodePrinter(pw)

      xmlNodePrinter.preserveWhitespace = true
      xmlNodePrinter.namespaceAware = false
      xmlNodePrinter.print(pomXml.dependencies[0])

      stringWriter.flush()
      stringWriter.close()

      def projectDepsXml = stringWriter.toString()

      def model = [groupId           : project.group,
                   artifactId        : project.name,
                   version           : buildNrLoc,
                   f8mpVersion       : '3.2-SNAPSHOT',
                   springCloudVersion: 'Dalston.SR1',
                   springBootVersion : '1.5.4.RELEASE',
                   fabric8           : project.fabric8,
                   springBoot        : project.springboot,
                   groovy            : project.groovy,
                   projectDeps       : projectDepsXml]

      TemplateConfiguration tplConf = new TemplateConfiguration()
      tplConf.autoNewLine = true
      tplConf.autoIndent = true
      tplConf.cacheTemplates = false

      MarkupTemplateEngine engine = new MarkupTemplateEngine(tplConf)

      def pomXmlTemplate = engine.createTemplate(file("$projectDir/../pom.tpl"))

      pomXmlTemplate.make(model).writeTo(new FileWriter(file("$projectDir/pom.xml")))

      file("$buildDir/tmp/pom.xml").delete()

    }
  }

  //Utility for doing oc apply/delete from respective sub projects whereever its needed
  project.ext.ocApply = {
    def f8dir = new File("$projectDir/target/classes/META-INF/fabric8")

    if (f8dir.exists()) {
      def standardOutput = new ByteArrayOutputStream()
      exec {
        workingDir "$projectDir/target/classes/META-INF/fabric8"
        commandLine 'oc', 'apply', '-f', 'openshift.yml'
      }
      return standardOutput.toString()
    }
  }

  project.ext.ocDelete = {
    def f8dir = new File("$projectDir/target/classes/META-INF/fabric8")

    if (f8dir.exists()) {

      def standardOutput = new ByteArrayOutputStream()

      exec {
        workingDir "$projectDir/target/classes/META-INF/fabric8"
        commandLine 'oc', 'delete', '-f', 'openshift.yml'
      }

      return standardOutput.toString()
    }
  }

  generatePom.onlyIf { project.hasProperty('fabric8') }
}

configure(subprojects - techProjects - commonZipkinProject - commonZipkinProjectOld - commonZipkinStreamProject) {

  dependencies {
    compile(commonProject)
    if (whatToTest('SLEUTH')) {
      if (oldSleuthPresent()) {
        compile commonZipkinProjectOld
      } else {
        compile commonZipkinProject
      }
    }
    if (whatToTest('SLEUTH_STREAM')) {
      compile commonZipkinStreamProject
    }

    compile "org.springframework.boot:spring-boot-starter-actuator"
    compile 'com.fasterxml.jackson.core:jackson-databind'
    if (!whatToTest('CONSUL') && !whatToTest('EUREKA') && !whatToTest('SLEUTH_STREAM') && !whatToTest('SCS')) {
      compile "org.springframework.cloud:spring-cloud-starter-zookeeper-discovery"
    }
    if (whatToTest('CONSUL')) {
      compile "org.springframework.cloud:spring-cloud-starter-consul-discovery"
    }
    if (whatToTest('EUREKA') || whatToTest('SLEUTH_STREAM')) {
      compile "org.springframework.cloud:spring-cloud-starter-eureka"
    }
    compile "org.springframework.cloud:spring-cloud-starter-feign"
    compile "org.codehaus.jackson:jackson-mapper-asl:$jacksonMapper"
    compile "org.codehaus.jackson:jackson-core-asl:$jacksonMapper"
    compile 'org.apache.commons:commons-lang3:3.4'
    compile 'com.jayway.jsonpath:json-path-assert:2.0.0'
    compile 'org.yaml:snakeyaml'
    compile 'org.hibernate:hibernate-validator'
    compile "org.aspectj:aspectjrt"

    runtime 'cglib:cglib-nodep:3.1'
    runtime 'org.objenesis:objenesis:2.2'
    runtime 'org.aspectj:aspectjweaver'
  }

  wrapper {
    gradleVersion '3.3'
  }

  bootRun {
    jvmArgs = systemPropsFromGradle()
  }

  test {
    jvmArgs systemPropsFromGradle()
    testLogging {
      exceptionFormat = 'full'
      showStandardStreams = true
    }
  }
}