ratpack.gradle

/*
 * Copyright 2013 the original author or authors.
 *
 * Licensed 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.
 */
import java.util.concurrent.atomic.AtomicBoolean
import java.util.concurrent.locks.ReentrantLock

buildscript {
  repositories {
    jcenter()
  }

  dependencies {
    classpath "org.jfrog.buildinfo:build-info-extractor-gradle:2.2.3"

    // Artifactory plugin pulls in very old Guava, which conflicts with child projects.
    // Force to newer version here.
    classpath 'com.google.guava:guava:18.0'

    classpath "org.kt3k.gradle.plugin:coveralls-gradle-plugin:2.3.1"
    classpath "com.github.ben-manes:gradle-versions-plugin:0.8"
  }
}

def jvmEncoding = java.nio.charset.Charset.defaultCharset().name()
if (jvmEncoding != "UTF-8") {
  throw new IllegalStateException("Build environment must be UTF-8 (it is: $jvmEncoding) - add '-Dfile.encoding=UTF-8' to the GRADLE_OPTS environment variable ")
}

if (!JavaVersion.current().java8Compatible) {
  throw new IllegalStateException("Must be built with Java 8 or higher")
}

apply plugin: "artifactory"
apply plugin: "com.github.kt3k.coveralls"
apply plugin: "com.github.ben-manes.versions"

artifactory {
  contextUrl = 'http://oss.jfrog.org'
}

artifactoryPublish {
  skip true
}

task bintrayPublish << {
  if (!(ratpackBintrayUser && ratpackBintrayApiKey)) {
    throw new InvalidUserDataException("You must provide ratpackBintrayUser and ratpackBintrayApiKey")
  }

  if (!project.hasProperty('buildNumber')) {
    throw new GradleException("Must provide buildNumber of a release binary from oss.jfrog.org")
  }

  def baseUrl = 'https://oss.jfrog.org/api/plugins/build/promote/releaseToBintray/ratpack/'
  def params = '?params=org=ratpack|repo=maven|package=ratpack'
  def curlUrl = [baseUrl, project.buildNumber, params].join('')
  def curl = ['curl', '-X', 'POST', '-u',
              /"${ratpackBintrayUser}:${ratpackBintrayApiKey}"/, curlUrl].execute()
  logger.info("Received response: ${curl.text}")
}

task gradlePluginPortalPublish << {

  def packages = ['ratpack-java', 'ratpack-groovy']

  packages.each { bintrayPackage ->
    def bintraySubject = 'ratpack'
    def bintrayRepo = 'gradle-plugins-meta'

    def version = project.version
    def parts = "$bintraySubject/$bintrayRepo/$bintrayPackage"
    def baseUrl = 'https://api.bintray.com'

    def createUrl = "$baseUrl/packages/$parts/versions"
    logger.info("Creating new version")
    exec {
      executable = 'curl'
      args = ['-H', '"Content-Type: application/json"', '-X', 'POST', '-d', /{\"name\":\"$version\"}/,
              '-u', /"${ratpackBintrayUser}:${ratpackBintrayApiKey}"/, createUrl]
    }

    def attributeUrl = "$baseUrl/packages/$parts/versions/$version/attributes"
    logger.info("Creating attributes")
    exec {
      executable = 'curl'
      args = ['-H', '"Content-Type: application/json"', '-X', 'POST', '-d', /[{\"name\":\"gradle-plugin\",\"values\":[\"io.ratpack.$bintrayPackage:io.ratpack:ratpack-gradle\"]}]/,
              '-u', /"${ratpackBintrayUser}:${ratpackBintrayApiKey}"/, attributeUrl]
    }

    def f = File.createTempFile("$bintrayPackage-$version", ".txt")
    f.write('This is a placeholder file.')
    f.deleteOnExit()

    def uploadUrl = "$baseUrl/content/$parts/$version/${bintrayPackage}-${version}.txt"
    logger.info("Uploading file")
    exec {
      executable = 'curl'
      args = ['-T', f.absolutePath, '-u', /"${ratpackBintrayUser}:${ratpackBintrayApiKey}"/, uploadUrl]
    }

    def publishUrl = "$baseUrl/content/$parts/$version/publish"
    logger.info("Publishing")
    exec {
      executable = 'curl'
      args = ['-X', 'POST', '-u', /"${ratpackBintrayUser}:${ratpackBintrayApiKey}"/, publishUrl]
    }
  }

}

allprojects {
  group = "io.ratpack"
  version = "0.9.16-SNAPSHOT"

  apply plugin: "base"
  apply plugin: "idea"
  apply plugin: "eclipse"
  apply plugin: "java"
  apply plugin: "jacoco"
  apply from: "$rootDir/gradle/dependencyRules.gradle"

  repositories {
    jcenter()
    maven { url 'http://oss.jfrog.org/artifactory/repo' }
  }

  jacoco {
    toolVersion = "0.7.2.201409121644"
  }
}

apply from: "gradle/idea/idea.gradle"

ext {
  isSnapshot = version.endsWith("SNAPSHOT")
  isTravis = System.getenv("TRAVIS") != null
  isDrone = System.getenv("DRONE") != null
  isCodeship = System.getenv("CI_NAME") == "codeship"
  isSnapCi = System.getenv("SNAP_CI") != null
  isAppveyor = System.getenv("APPVEYOR") != null
  isCloudCi = isTravis || isDrone || isCodeship || isSnapCi || isAppveyor
  isHeroku = System.getenv("HEROKU") != null

  publishedModules = [
    "ratpack-core", "ratpack-groovy", "ratpack-guice", "ratpack-session", "ratpack-test", "ratpack-groovy-test",
    "ratpack-manual", "ratpack-gradle", "ratpack-handlebars", "ratpack-remote", "ratpack-remote-test", "ratpack-jackson",
    "ratpack-codahale-metrics", "ratpack-h2", "ratpack-thymeleaf", "ratpack-rx", "ratpack-hikari", "ratpack-newrelic",
    "ratpack-pac4j", "ratpack-hystrix", "ratpack-spring-boot", "ratpack-config"
  ].collect { project(it) }

  apiModules = publishedModules.findAll { !(it.name in ["ratpack-manual", "ratpack-gradle"]) }

  localRepoUrl = "${buildDir.toURI()}/localrepo"
}

apply from: "gradle/dependencies.gradle"

subprojects {
  tasks.withType(Upload).matching { it.name != "install" }.all {
    rootProject.subprojects {
      mustRunAfter tasks.matching { it instanceof VerificationTask }
    }
  }

  // CodeNarc appears to hang in drone.io
  tasks.withType(CodeNarc) {
    onlyIf { !rootProject.hasProperty("ciBuild") }
  }

  tasks.withType(Test) {
    allprojects {
      mustRunAfter tasks.withType(Checkstyle)
    }
  }

  tasks.withType(GroovyCompile) {
    allprojects {
      mustRunAfter tasks.withType(CodeNarc)
    }
  }

  apply from: "$rootDir/gradle/ratpackLocal.gradle"

  tasks.withType(Javadoc) {
    options.encoding = "utf-8"
    options.docEncoding = "utf-8"
    options.charSet = "utf-8"
    exclude "**/internal/**"
  }

  apply plugin: "maven"
  apply from: "${rootDir}/gradle/pom.gradle"
  apply plugin: "signing"

  if (rootProject.hasProperty("ciBuild")) {
    plugins.withType(ReportingBasePlugin) {
      reporting.baseDir = rootProject.file("build/reports/$name")
    }
  }

  jacocoTestReport {
    additionalSourceDirs = files(sourceSets.main.allSource.srcDirs)
    sourceDirectories = files(sourceSets.main.allSource.srcDirs)
    classDirectories = files(sourceSets.main.output)
    reports {
      html.enabled = true
      xml.enabled = true
      csv.enabled = false
    }
  }
}

// Have to evaluate the children before setting up the publishing stuff so the dependencies are defined.
evaluationDependsOnChildren()

subprojects {
  configurations.signatures.artifacts.all {
    extension = toSignArtifact.extension + "." + extension
  }

  if (project in publishedModules) {
    apply plugin: "artifactory"
    artifactoryPublish { task ->
      rootProject.artifactory {
        publish {
          repository {
            repoKey = isSnapshot ? 'oss-snapshot-local' : 'oss-release-local'
            gradle.taskGraph.whenReady { taskGraph ->
              if (taskGraph.hasTask(task)) {
                username = ratpackBintrayUser
                password = ratpackBintrayApiKey
              }
            }
          }
        }
      }
    }

    assert description: "Project $project.path is published, must have a description"

    modifyPom {
      project {
        name project.name
        description project.description
        url "http://www.ratpack.io"
        licenses {
          license {
            name "The Apache Software License, Version 2.0"
            url "http://www.apache.org/licenses/LICENSE-2.0.txt"
            distribution "repo"
          }
        }
        scm {
          connection "scm:https://ratpack@github.com/ratpack/ratpack"
          developerConnection "scm:git@github.com:ratpack/ratpack.git"
          url "https://github.com/ratpack/ratpack"
        }
        developers {
          developer {
            id "ratpack"
            name "Team Ratpack"
          }
        }
      }
    }
  }

  tasks.withType(Test) {
    testLogging {
      exceptionFormat "full"
      events "failed"
    }

    jvmArgs "-Xss320k"
    minHeapSize "312m"
    maxHeapSize "312m"

    doFirst {
      if (isCloudCi) {
        maxParallelForks 1
      }
    }
  }
}

task ciZip(type: Zip) {
  into "reports", { from "build/reports" }
  into "manual", { from { project(":ratpack-manual").packageManual } }
  archiveName = "ci.zip"
  destinationDir = buildDir
}

task stage {
  dependsOn "clean", ":ratpack-site:installApp"
}

task jacocoReport(type: org.gradle.testing.jacoco.tasks.JacocoReport) {
  dependsOn publishedModules.test
  sourceDirectories = files(publishedModules.sourceSets.main.allSource.srcDirs)
  classDirectories = files(publishedModules.sourceSets.main.output)
  executionData = files(publishedModules.jacocoTestReport.executionData)
  reports {
    html.enabled = true
    xml.enabled = true
    csv.enabled = false
  }
}

coveralls {
  service = System.getenv().get("CI_NAME")
  sourceDirs = jacocoReport.sourceDirectories.files.toList()
  jacocoReportPath = jacocoReport.reports.xml.destination.absolutePath - rootDir.absolutePath
}

task testReport(type: TestReport) {
  destinationDir file("$buildDir/tests")
  reportOn subprojects.collect { it.tasks.test }
}

task allDependencies << {
  allprojects { p ->
    configurations.each { c ->
      println "Downloading dependencies for $p.path - $c.name"
      c.files
    }
  }
}

// Maven POM generation is not thread safe, so serialize all the Upload tasks we can use `--parallel`.
def lock = new ReentrantLock()
def available = lock.newCondition()
def busy = new AtomicBoolean()
allprojects {
  tasks.withType(Upload) { uploadTask ->
    doFirst {
      lock.lock()
      while (busy.get()) {
        available.await()
      }
      busy.set(true)
    }
  }
}
gradle.taskGraph.afterTask {
  if (it instanceof Upload && lock.heldByCurrentThread) {
    busy.set(false)
    available.signal()
    lock.unlock()
  }
}