build.gradle

/*
 * Copyright 2016 SimplifyOps, Inc. (http://simplifyops.com)
 *
 * 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.
 */

/**
 * Rundeck Master-Build Project
 * 
 * This project does not contain any buildable code and does not generate any 
 * artifacts, however it allows us to set defaults for the subjects and provides 
 * Groovy syntax highlighting for gradle build files (like this one)
 **/
 import org.gradle.plugins.signing.Sign
 buildscript {
    repositories {
	maven {
		name 'mavenCentralProxy'
		url mavenCentralUrl
		if (project.hasProperty('mavenUser') && project.hasProperty('mavenPassword')) {
			credentials {
				username mavenUser
				password mavenPassword
			}
		}
	}
        mavenCentral()
    }
    dependencies {
        classpath 'com.adaptc.gradle:nexus-workflow:0.6'
        classpath 'com.google.gradle:osdetector-gradle-plugin:1.4.0'
    }
}
description = 'The master-build project for Rundeck';

apply plugin: 'nexus-workflow'
apply plugin: 'eclipse';
apply plugin: 'idea'
apply plugin: 'com.google.osdetector'

eclipse.project.name = 'rundeck'

ext.exportedProjects = [
        ":core",
        ":rundeck-storage:rundeck-storage-api",
        ":rundeck-storage:rundeck-storage-data",
        ":rundeck-storage:rundeck-storage-filesys",
        ":rundeck-storage:rundeck-storage-conf",
        ":rundeck"
]
/**
 * Defaults for all projects
 */
subprojects {
    // set the eclipse project naming convention to rundeck:<path>:<projectName>
    // so it matches the logical hierarchy more closely
    apply from: "${rootDir}/gradle/java.gradle"
    apply plugin: 'eclipse'
    eclipse.project.name = "${project.getParent().eclipse.project.name}:${name}"

    // the environment can be set by adding -Penvironment={value} as a command
    // line switch. by default we run as 'development'
    ext.environment = project.hasProperty('environment') ? environment : 'development';

    // Unless we're doing a release build, append -SNAPSHOT to the end of the
    // artifacts. Otherwise use the currentVersion as defined in gradle.properties and
    // the releaseTag if it is not 'GA'
    def vtag = environment != 'release' ? '-SNAPSHOT' : (project.hasProperty('releaseTag') && releaseTag != 'GA' ? '-' + releaseTag : '')
    version = currentVersion + vtag
}
allprojects{
    ext.isReleaseBuild = false
    ext.isSnapshotBuild = false
    ext.isDevBuild = false
    if(project.hasProperty('environment') && project.environment == 'release'){
        ext.isReleaseBuild=true
    }else if(project.hasProperty("snapshot")){
        ext.isSnapshotBuild=true
    }else{
        ext.isDevBuild=true
    }
}

task wrapper(type: Wrapper) {
    gradleVersion = '4.7'
}

// prompt for PGP key passphrase if not set
gradle.taskGraph.whenReady { taskGraph ->
    if (taskGraph.allTasks.any { it instanceof Sign } && project.hasProperty("signing.keyId") && !project.hasProperty( "signing.password") && !project.isDevBuild) {
        // Use Java 6's console to read from the console (no good for a CI environment)
        Console console = System.console()
        console.printf "\n\nWe have to sign some things in this build.\n\nPlease enter your signing details.\n\n"

        //def id = console.readLine("PGP Key Id: ")
        //def file = console.readLine("PGP Secret Key Ring File (absolute path): ")
        def password = console.readPassword("PGP Private Key Password: ")

        //allprojects { ext."signing.keyId" = id }
        //allprojects { ext."signing.secretKeyRingFile" = file }
        allprojects { ext."signing.password" = password }

        console.printf "\nThanks.\n\n"
    }
}

//subproject libs that are uploaded to maven central
exportedProjects.each {
    project(it) {
        apply plugin: 'signing'

        //********* artifact signing *********
        if (isReleaseBuild && project.hasProperty("signing.keyId")) {
            signing {
                sign configurations.archives
            }
        } else {
            task signArchives {
                // do nothing
            }
        }
        def archiveName=project.name.startsWith('rundeck')?project.name: "rundeck-${project.name}"
        //build a pom we reuse for both maven builds and release to sonatype
        ext.publishPom = pom {
            project {
                artifactId archiveName
                groupId project.group
                inceptionYear '2014'
                packaging 'jar'
                version version
                name "Rundeck library ${project.name}"
                description project.description?:'Rundeck'
                url 'http://rundeck.org'
                licenses {
                    license {
                        name 'The Apache Software License, Version 2.0'
                        url 'http://www.apache.org/licenses/LICENSE-2.0.txt'
                        distribution 'repo'
                    }
                }
                scm {
                    url 'https://github.com/rundeck/rundeck'
                    connection 'scm:git:git@github.com/rundeck/rundeck.git'
                    developerConnection 'scm:git:git@github.com:rundeck/rundeck.git'
                }
                developers {
                    developer {
                        id('gschueler')
                        name('Greg Schueler')
                        email('greg@rundeck.com')
                    }
                }
                parent {
                    groupId('org.sonatype.oss')
                    artifactId('oss-parent')
                    version('7')
                }
            }
        }


        uploadArchives {
            if (isDevBuild) {
                repositories {
                    repositories.mavenDeployer {
                        configuration = configurations.archives
                        pom = project.publishPom
                    }
                }
            } else {
                repositories.mavenDeployer {
                    if (isReleaseBuild) {
                        beforeDeployment { MavenDeployment deployment -> signing.signPom(deployment) }
                    }

                    configuration = configurations.archives
                    if (project.hasProperty('sonatypeUsername') && project.hasProperty('sonatypePassword')) {
                        repository(url: 'https://oss.sonatype.org/service/local/staging/deploy/maven2') {
                            authentication(userName: sonatypeUsername, password: sonatypePassword)
                        }
                        snapshotRepository(url: 'https://oss.sonatype.org/content/repositories/snapshots/') {
                            authentication(userName: sonatypeUsername, password: sonatypePassword)
                        }
                    }
                    pom = project.publishPom
                }
            }
        }

        //utility to create a pom for building
        if(!(project.name in ['core','launcher'])){
            //:core buildfile will generate its own pom for specialized purpose
            task('createPom').doLast {
                publishPom.writeTo("pom.xml")
            }
        }
    }
}

task alljavadoc(type: Javadoc) {
    source exportedProjects.collect { project(it).sourceSets.main.allJava }
    classpath = files(exportedProjects.collect { project(it).sourceSets.main.compileClasspath })
    destinationDir = file("${buildDir}/docs/javadoc")

    if (JavaVersion.current().isJava8Compatible()) {
        options.addStringOption('Xdoclint:none', '-quiet')
    }
}