build.gradle

version = readVersion()

apply from: "gradle/vertx.gradle"
apply plugin: "jacoco"

/*
Usage:

./gradlew task_name

(or gradlew.bat task_name if you have the misfortune to have to use Windows)

If no task name is specified then the default task 'assemble' is run

Task names are:

idea - generate a skeleton IntelliJ IDEA project

eclipse - generate a skeleton Eclipse IDE project

assemble - builds the outputs, by default this is the module zip file. It can also include a jar file if produceJar
          in gradle.properties is set to true. Outputs are created in build/libs.
          if pullInDeps in gradle.properties is set to 'true' then the modules dependencies will be
          automatically pulled into a nested mods directory inside the module during the build

copyMod - builds and copies the module to the local 'mods' directory so you can execute vertx runmod (etc)
          directly from the command line

modZip - creates the module zip into build/libs

clean - cleans everything up

test - runs the tests. An nice html test report is created in build/reports/tests (index.html)

runMod - runs the module. This is similar to executing vertx runmod from the command line except that it does
         not use the version of Vert.x installed and on the PATH to run it. Instead it uses the version of Vert.x
         that the module was compiled and tested against.

pullInDeps - pulls in all dependencies of the module into a nested module directory

uploadArchives - upload the module zip file (and jar if one has been created) to Nexus. You will need to
                 configure sonatypeUsername and sonatypePassword in ~/.gradle/gradle.properties.

install - install any jars produced to the local Maven repository (.m2)

 */

dependencies {
  /*
  Add your module jar dependencies here
  E.g.
  compile "com.foo:foo-lib:1.0.1" - for compile time deps - this will end up in your module too!
  testCompile "com.foo:foo-lib:1.0.1" - for test time deps
  provided "com.foo:foo-lib:1.0.1" - if you DON'T want it to be packaged in the module zip
  */

  // If you're creating Groovy compiled verticles you may need the following dependencies
  provided "org.codehaus.groovy:groovy-all:$groovyVersion"
  provided "io.vertx:lang-groovy:$groovyLangModVersion@jar"

}

test {
}

jacoco {
    toolVersion = "0.7.1.201405082137"
}

String readVersion() {
    def versionFile = file('version.properties')

    def env = System.getenv()
    def versionSuffix = (env.PIPE_FLOW_NUMBER != null) ? ".$env.PIPE_FLOW_NUMBER" : '-SNAPSHOT'

    Properties versionProps = new Properties()

    versionFile.withInputStream { stream ->
        versionProps.load(stream)
    }

    return versionProps.APP_VERSION_PREFIX + versionSuffix
}

task versionNumber << {
    println "version: $version"
}

/*
If you're uploading stuff to Maven, Gradle needs to generate a POM.
Please edit the details below.
 */
def configurePom(def pom) {
  pom.project {
    name rootProject.name
    description 'CH OPEN Workshoptage 2014 - Continuous Delivery - Beispiel Projekt - issumy'
    inceptionYear '2014'
    packaging 'jar'

    url 'https://github.com/ollin/cd-ws-issumy'

    developers {
      developer {
        id 'ollin'
        name 'Oliver Nautsch'
        email 'oliver.nautsch@gmail.com'
      }
    }

    scm {
      url 'https://github.com/ollin/cd-ws-issumy.git'
    }

    licenses {
      license {
        name 'The MIT License (MIT)'
        url 'http://opensource.org/licenses/MIT'
        distribution 'repo'
      }
    }

    properties {
      setProperty('project.build.sourceEncoding', 'UTF8')
    }
  }
}

uploadArchives {
    repositories {
        mavenDeployer {
            repository(url: "http://localhost:8181/nexus/content/repositories/releases/") {
                authentication(
                        userName: "deployment",
                        password: "deployment9"
                )
            }
            snapshotRepository(url: "http://localhost:8181/nexus/content/repositories/snapshots/") {
                authentication(
                        userName: "deployment",
                        password: "deployment9"
                )
            }
        }
    }
}

task prepareModZipForDocker (type: Copy) {
    from modZip
    into 'build/docker'
}

task createDockerfile << {
    def dockerFile = 'build/docker/Dockerfile'

    def oldDockerFile = new File(dockerFile)

    if (oldDockerFile.exists()) {
        oldDockerFile.delete();
    }

    def newDockerFile = new File(dockerFile)
    newDockerFile.createNewFile();

    newDockerFile.withWriter { out ->
        out.writeLine("FROM ollin/vertx")
        out.writeLine("MAINTAINER Oliver Nautsch <oliver.nautsch@gmail.com>")
        out.writeLine("")
        out.writeLine("VOLUME /home/issumy")
        out.writeLine("ADD $modZip.archiveName /home/issumy/$modZip.archiveName")
        out.writeLine("EXPOSE 8080")
        out.writeLine("")
        out.writeLine("WORKDIR /home/issumy")
        out.writeLine("CMD [\"runzip\", \"$modZip.archiveName\"]")
    }
}
createDockerfile.dependsOn prepareModZipForDocker

task createDockerImage (type: Exec) {
    workingDir 'build/docker'
    commandLine 'sudo', 'docker', 'build', '-t', "inventage/issumy:$version", '.'
}
createDockerImage.dependsOn createDockerfile, prepareModZipForDocker
build.dependsOn createDockerImage

task tagDockerImageLatest (type: Exec) {
    commandLine 'sudo', 'docker', 'tag', "inventage/issumy:$version", "localhost:5000/inventage/issumy:latest"
}
tagDockerImageLatest.dependsOn createDockerImage

task pushDockerImageLatest (type: Exec) {
    commandLine 'sudo', 'docker', 'push', "localhost:5000/inventage/issumy:latest"
}
pushDockerImageLatest.dependsOn tagDockerImageLatest


task tagDockerImageVersion (type: Exec) {
    commandLine 'sudo', 'docker', 'tag', "inventage/issumy:$version", "localhost:5000/inventage/issumy:$version"
}
tagDockerImageVersion.dependsOn createDockerImage

task pushDockerImageVersion (type: Exec) {
    commandLine 'sudo', 'docker', 'push', "localhost:5000/inventage/issumy:$version"
}
pushDockerImageVersion.dependsOn tagDockerImageVersion
//uploadArchives.dependsOn pushDockerImageVersion, pushDockerImageLatest