build.gradle

plugins {
    id 'idea'
    id 'eclipse'
    id 'java'
    id 'net.saliman.cobertura' version '4.0.0'
    id 'distribution'
    id 'com.github.johnrengelman.shadow' version '6.1.0'
    id 'com.github.jk1.dependency-license-report' version '1.19'
    id 'signing'
    id 'maven'
    id 'org.ajoberstar.git-publish' version '3.0.1'
    id 'nebula.release' version '15.3.1'
}

group 'com.emc.ecs'
description = 'The purpose of the bucket-wipe tool is to enumerate a bucket and delete its contents in parallel threads. At the end the bucket is optionally deleted.'

// name of the github project repository
ext.githubProjectName = project.name
// 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 = 'http://www.apache.org/licenses/'
// main execution class
ext.mainClass = 'com.emc.ecs.tool.BucketWipe'

defaultTasks 'distZip'

repositories {
    mavenCentral()
    mavenLocal()
}

dependencies {
    implementation 'com.emc.ecs:object-client:3.4.4'
    implementation 'com.emc.ecs:smart-client-ecs:3.0.1'
    implementation 'org.apache.logging.log4j:log4j-slf4j-impl:2.19.0'
    implementation 'commons-cli:commons-cli:1.5.0'
    testImplementation 'junit:junit:4.13.2'
}

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
    }
}

shadowJar {
    classifier ''
    mergeServiceFiles()
    manifest {
        attributes 'Main-Class': mainClass,
                'Implementation-Version': project.version,
                'Class-Path': { configurations.runtime.collect { it.getName() }.join(' ') }
    }
}

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
}

generateLicenseReport.dependsOn 'compileJava'

distributions {
    main {
        contents {
            from('.') {
                include '*.txt'
            }
            into('3rd-party-licenses') {
                from generateLicenseReport
            }
            from shadowJar
            into('doc') {
                from javadocJar
            }
            into('src') {
                from sourcesJar
            }
        }
    }
}

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
        }
    }
}

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

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

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

clean {
    delete aggregatedDocsDir
}

// allow typing in credentials
// note: this only works when run without the Gradle daemon (--no-daemon)
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
    }
    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)
    }
}