build.gradle

/*
 * Copyright (c) 2015-2021 Dell Inc., or its subsidiaries. All Rights Reserved.
 *
 * 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 com.github.jk1.license.render.InventoryHtmlReportRenderer

plugins {
    id 'idea'
    id 'eclipse'
    id 'java'
    id 'net.saliman.cobertura' version '4.0.0' apply false
    id 'com.github.jk1.dependency-license-report' version '1.17' apply false
    id 'org.ajoberstar.git-publish' version '3.0.1'
    id 'nebula.release' version '15.3.1'
}

// name of the github project repository
ext.githubProjectName = 'smart-client-java'
// URL to github project
ext.githubProjectUrl = "https://github.com/EMCECS/${githubProjectName}"
// git remote scm address
ext.githubScmUrl = "scm:git@github.com:EMCECS/${githubProjectName}.git"
// git remote https address
ext.githubRemoteUrl = "https://github.com/EMCECS/${githubProjectName}.git"
// license info
ext.licenseName = 'Apache License 2.0'
ext.licenseUrl = 'https://www.apache.org/licenses/'

subprojects {
    apply plugin: 'java-library'
    apply plugin: 'net.saliman.cobertura'
    apply plugin: 'com.github.jk1.dependency-license-report'
    apply plugin: 'distribution'
    apply plugin: 'signing'
    apply plugin: 'maven'

    group 'com.emc.ecs'

    defaultTasks 'distZip'

    repositories {
        mavenCentral()
        mavenLocal()
    }

    configurations {
        jars.extendsFrom(signatures)
    }

    [compileJava, compileTestJava]*.options*.encoding = 'UTF-8'

    sourceCompatibility = 1.8

    def projectPom = {
        project {
            name project.name
            description project.description
            url githubProjectUrl

            scm {
                url githubProjectUrl
                connection githubScmUrl
                developerConnection githubScmUrl
            }

            licenses {
                license {
                    name licenseName
                    url licenseUrl
                    distribution 'repo'
                }
            }

            developers {
                developer {
                    id 'EMCECS'
                    name 'Dell EMC ECS'
                }
            }
        }
    }

    task writePom {
        ext.pomFile = file("$buildDir/pom.xml")
        outputs.file pomFile
        doLast {
            pom(projectPom).writeTo pomFile
        }
    }

    jar {
        doFirst {
            manifest {
                attributes 'Implementation-Version': project.version,
                        'Class-Path': configurations.runtime.collect { it.getName() }.join(' ')
            }
        }
        into("META-INF/maven/$project.group/$project.name") {
            from writePom
        }
    }

    javadoc {
        options.addStringOption('Xdoclint:none', '-quiet')
    }

    task javadocJar(type: Jar) {
        archiveClassifier = 'javadoc'
        from "${docsDir}/javadoc"
    }
    tasks.javadocJar.dependsOn javadoc

    task sourcesJar(type: Jar) {
        archiveClassifier = 'sources'
        from sourceSets.main.allSource
    }

    artifacts {
        jars jar
        jars javadocJar
        jars sourcesJar
    }

    // remove zips and tars from "install" task
    configurations.archives.artifacts.removeAll {it.file =~ /(zip|tar)$/}

    licenseReport {
        renderers = [new InventoryHtmlReportRenderer()]
    }

    distributions {
        main {
            contents {
                from configurations.jars.artifacts.files
                from('.') {
                    include '*.txt'
                }
                into('3rd-party-licenses') {
                    from generateLicenseReport
                }
                into('lib') {
                    from configurations.runtimeClasspath
                }
            }
        }
    }

    signing {
        required { gradle.taskGraph.hasTask(uploadJars) }
        sign configurations.jars
    }

    uploadJars {
        repositories {
            mavenDeployer {
                beforeDeployment { deployment -> signing.signPom(deployment) }

                repository(url: 'https://oss.sonatype.org/service/local/staging/deploy/maven2/') {
                    authentication(userName: '', password: '')
                }

                pom projectPom
            }
        }
    }

    // allow typing in credentials
    // note: this only works when run without the Gradle daemon (--no-daemon).
    //       if that's not possible, it's best to read passwords into env. variables and set these properties on the gradle
    //       command line ( -PsigningPass="${SIGNING_PASS}" -PsonatypePass="${SONATYPE_PASS}" )
    gradle.taskGraph.whenReady { taskGraph ->
        if (taskGraph.hasTask(uploadJars)) {
            if (!rootProject.hasProperty('signingSecretKeyRingFile'))
                rootProject.ext.signingSecretKeyRingFile = new String(System.console().readLine('\nSecret key ring file: '))
            if (!rootProject.hasProperty('signingKeyId'))
                rootProject.ext.signingKeyId = new String(System.console().readLine('\nSigning key id: '))
            if (!rootProject.hasProperty('signingPass'))
                rootProject.ext.signingPass = new String(System.console().readPassword('\nSigning key passphrase: '))
            if (!rootProject.hasProperty('sonatypeUser'))
                rootProject.ext.sonatypeUser = new String(System.console().readLine('\nSonatype username: '))
            if (!rootProject.hasProperty('sonatypePass'))
                rootProject.ext.sonatypePass = new String(System.console().readPassword('\nSonatype password: '))
            ext.'signing.keyId' = rootProject.ext.signingKeyId
            ext.'signing.secretKeyRingFile' = rootProject.ext.signingSecretKeyRingFile
            ext.'signing.password' = rootProject.ext.signingPass
            uploadJars.repositories.mavenDeployer.repository.authentication.userName = rootProject.ext.sonatypeUser
            uploadJars.repositories.mavenDeployer.repository.authentication.password = rootProject.ext.sonatypePass
        }
    }
}

ext.aggregatedDocsDir = "$buildDir/aggregatedDocs"
task aggregateDocs {
    doLast {
        if (project.hasProperty('release.stage') && project.ext['release.stage'] == 'final') {
            subprojects.each { sp ->
                copy {
                    from sp.docsDir
                    into "${aggregatedDocsDir}/${sp.name}/latest"
                }
            }
        }
        subprojects.each {sp ->
            copy {
                from sp.docsDir
                into "${aggregatedDocsDir}/${sp.name}/${sp.version}"
            }
        }
    }
}
tasks.aggregateDocs.dependsOn subprojects.javadoc

gitPublish {
    repoUri = githubRemoteUrl
    branch = 'gh-pages'
    contents {
        from aggregatedDocsDir
    }
    preserve { include '**/*' }
}
tasks.gitPublishPush.dependsOn aggregateDocs

tasks.release.dependsOn subprojects.test, subprojects.uploadJars, gitPublishPush, subprojects.distZip

clean {
    delete aggregatedDocsDir
}

// allow typing in credentials
// note: this only works when run without the Gradle daemon (--no-daemon).
//       if that's not possible, it's best to read passwords into env. variables and set these properties on the gradle
//       command line ( -PgitPassword="${GIT_PASSWORD}" )
gradle.taskGraph.whenReady { taskGraph ->
    if (taskGraph.hasTask(':gitPublishPush') || taskGraph.hasTask(':release')) {
        if (!rootProject.hasProperty('gitUsername'))
            rootProject.ext.gitUsername = new String(System.console().readLine('\nGit username: '))
        if (!rootProject.hasProperty('gitPassword'))
            rootProject.ext.gitPassword = new String(System.console().readPassword('\nGit password: '))
        System.setProperty('org.ajoberstar.grgit.auth.username', rootProject.ext.gitUsername)
        System.setProperty('org.ajoberstar.grgit.auth.password', rootProject.ext.gitPassword)
    }
}