release.gradle

buildscript {
    repositories {
        mavenCentral()
    }

    dependencies {
        classpath 'com.amazonaws:aws-java-sdk:1.7.8.1'
    }
}


import com.amazonaws.*
import com.amazonaws.auth.AWSCredentials
import com.amazonaws.auth.AWSCredentialsProvider
import com.amazonaws.auth.BasicAWSCredentials
import com.amazonaws.auth.DefaultAWSCredentialsProviderChain;
import com.amazonaws.internal.StaticCredentialsProvider;
import com.amazonaws.services.s3.AmazonS3
import com.amazonaws.services.s3.AmazonS3Client
import com.amazonaws.services.s3.model.*

import java.text.SimpleDateFormat

def getSdkBasedPackageNames() {
    def packageNames = []
    packageNames << "sdk"
    packageNames.addAll(getMaridBasedPackageNames())
    return packageNames
}

def getLampBasedPackageNames() {
    return ["lamp"]
}

def getMaridBasedPackageNames() {
    return ["marid",
            "nagios",
            "nagiosMarid",
            "nagiosxi",
            "icinga",
            "icingaMarid",
            "redmine",
            "netcool",
            "zabbix",
            "zabbixMarid",
            "zenoss",
            "zendesk",
            "icinga2",
            "icinga2Marid",
            "xmpp",
            "solarwinds",
            "solarwindsmspncentral",
            "solarwindswebhelpdesk",
            "webex",
            "dynatraceappmon",
            "jira",
            "jiraServiceDesk",
            "op5",
            "bmcRemedy",
            "bmcRemedyMarid",
            "librenms",
            "prtg",
            "zenossMarid",
            "bmcFootPrintsV12",
            "bmcFootPrintsV12Marid",
            "bmcFootPrintsV11",
            "bmcFootPrintsV11Marid",
            "cherwell"
            ]
}


def generateDownloadsProperties() {
    copy {
        from getDownloadsTemplate()
        filter {
            it.replace('[[sdk]]', project.ext.versions.getProperty('sdk'))
                    .replace('[[lamp]]', project.ext.versions.getProperty('lamp'))
                    .replace('[[marid]]', project.ext.versions.getProperty('marid'))
                    .replace('[[nagios]]', project.ext.versions.getProperty('nagios'))
                    .replace('[[nagiosIncoming]]', project.ext.versions.getProperty('nagiosIncoming'))
                    .replace('[[nagiosMarid]]', project.ext.versions.getProperty('nagiosMarid'))
                    .replace('[[nagiosxi]]', project.ext.versions.getProperty('nagiosxi'))
                    .replace('[[nagiosxiIncoming]]', project.ext.versions.getProperty('nagiosxiIncoming'))
                    .replace('[[nagiosxiMarid]]', project.ext.versions.getProperty('nagiosxiMarid'))
                    .replace('[[icinga]]', project.ext.versions.getProperty('icinga'))
                    .replace('[[icingaIncoming]]', project.ext.versions.getProperty('icingaIncoming'))
                    .replace('[[icingaMarid]]', project.ext.versions.getProperty('icingaMarid'))
                    .replace('[[icinga2]]', project.ext.versions.getProperty('icinga2'))
                    .replace('[[icinga2Incoming]]', project.ext.versions.getProperty('icinga2Incoming'))
                    .replace('[[icinga2Marid]]', project.ext.versions.getProperty('icinga2Marid'))
                    .replace('[[redmine]]', project.ext.versions.getProperty('redmine'))
                    .replace('[[netcool]]', project.ext.versions.getProperty('netcool'))
                    .replace('[[zabbix]]', project.ext.versions.getProperty('zabbix'))
                    .replace('[[zabbixIncoming]]', project.ext.versions.getProperty('zabbixIncoming'))
                    .replace('[[zabbixMarid]]', project.ext.versions.getProperty('zabbixMarid'))
                    .replace('[[zenossIncoming]]', project.ext.versions.getProperty('zenossIncoming'))
                    .replace('[[zenossMarid]]', project.ext.versions.getProperty('zenossMarid'))
                    .replace('[[zenoss]]', project.ext.versions.getProperty('zenoss'))
                    .replace('[[zendesk]]', project.ext.versions.getProperty('zendesk'))
                    .replace('[[solarwinds]]', project.ext.versions.getProperty('solarwinds'))
                    .replace('[[solarwindsmspncentral]]', project.ext.versions.getProperty('solarwindsmspncentral'))
                    .replace('[[solarwindswebhelpdesk]]', project.ext.versions.getProperty('solarwindswebhelpdesk'))
                    .replace('[[oem]]', project.ext.versions.getProperty('oem'))
                    .replace('[[vcenter]]', project.ext.versions.getProperty('vcenter'))
                    .replace('[[xmpp]]', project.ext.versions.getProperty('xmpp'))
                    .replace('[[trackit]]', project.ext.versions.getProperty('trackit'))
                    .replace('[[webex]]', project.ext.versions.getProperty('webex'))
                    .replace('[[jira]]', project.ext.versions.getProperty('jira'))
                    .replace('[[jiraServiceDesk]]', project.ext.versions.getProperty('jiraServiceDesk'))
                    .replace('[[prtg]]', project.ext.versions.getProperty('prtg'))
                    .replace('[[dynatraceappmon]]', project.ext.versions.getProperty('dynatraceappmon'))
                    .replace('[[op5]]', project.ext.versions.getProperty('op5'))
                    .replace('[[bmcRemedy]]', project.ext.versions.getProperty('bmcRemedy'))
                    .replace('[[bmcRemedyIncoming]]', project.ext.versions.getProperty('bmcRemedyIncoming'))
                    .replace('[[bmcRemedyMarid]]', project.ext.versions.getProperty('bmcRemedyMarid'))
                    .replace('[[vcsa]]', project.ext.versions.getProperty('vcsa'))
                    .replace('[[librenms]]', project.ext.versions.getProperty('librenms'))
                    .replace('[[opsview]]', project.ext.versions.getProperty('opsview'))
                    .replace('[[bmcFootPrintsV12Incoming]]', project.ext.versions.getProperty('bmcFootPrintsV12Incoming'))
                    .replace('[[bmcFootPrintsV12Marid]]', project.ext.versions.getProperty('bmcFootPrintsV12Marid'))
                    .replace('[[bmcFootPrintsV12]]', project.ext.versions.getProperty('bmcFootPrintsV12'))
                    .replace('[[bmcFootPrintsV11]]', project.ext.versions.getProperty('bmcFootPrintsV11'))
                    .replace('[[bmcFootPrintsV11Incoming]]', project.ext.versions.getProperty('bmcFootPrintsV11Incoming'))
                    .replace('[[bmcFootPrintsV11Marid]]', project.ext.versions.getProperty('bmcFootPrintsV11Marid'))
                    .replace('[[cherwell]]', project.ext.versions.getProperty('cherwell'))
                    .replace('[[activeDirectory]]', project.ext.versions.getProperty('activeDirectory'))
                    .replace('[[opsviewv6]]', project.ext.versions.getProperty('opsviewv6'))
        }
        into "${buildDir}/distributions"
        rename "downloads.template.properties", "downloads.properties"
    }
}

task generateDownloadsProperties << {
    generateDownloadsProperties()
}

def getUploadOptions() {
    def options
    if(project.hasProperty('options')) {
        options = project.options;
    } else {
        options = "${projectDir}/uploadOptions.properties";
    }
    Properties properties = new Properties();
    properties.load(new FileInputStream(options))
    return properties
}

def getAWSClient() {
    def props = getUploadOptions()

    def amazonAccessKey = props.getProperty('amazonAccessKey')
    def amazonSecretKey = props.getProperty('amazonSecretKey')
    def amazonConnectionTimeout = Integer.valueOf(props.getProperty('amazonConnectionTimeout'))
    def amazonMaxConnections = Integer.valueOf(props.getProperty('amazonMaxConnections'))
    def amazonMaxErrorRetry = Integer.valueOf(props.getProperty('amazonMaxErrorRetry'))

    AWSCredentialsProvider provider;
    if (amazonAccessKey != null && amazonSecretKey != null) {
        provider = new StaticCredentialsProvider( new BasicAWSCredentials(amazonAccessKey, amazonSecretKey));
    } else {
        provider = new DefaultAWSCredentialsProviderChain();
    }

    ClientConfiguration clientConfiguration = new ClientConfiguration()
    clientConfiguration.setConnectionTimeout(amazonConnectionTimeout);
    clientConfiguration.setMaxConnections(amazonMaxConnections);
    clientConfiguration.setMaxErrorRetry(amazonMaxErrorRetry);

    AmazonS3 client = new AmazonS3Client(provider, clientConfiguration)
    client.setEndpoint("s3-us-west-2.amazonaws.com")
    return client
}

def createDownloadBucketIfNonExist() {
    def props = getUploadOptions()
    def downloadsBucket = props.getProperty('amazonDownloadsBucket')
    createBucketIfNonExist(downloadsBucket)
}

def createBucketIfNonExist(String bucketName) {
    def client = getAWSClient()

    if (!client.doesBucketExist(bucketName)) {
        println "[RELEASE] Bucket $bucketName not exist. Creating new One!"
        //This will not run for prod account , prod buckets need to created from another place , jenkins is not secure to have a create bucket access key
        client.createBucket(bucketName)
    }
}

def uploadJavaDocToS3() {

    def client = getAWSClient()
    def props = getUploadOptions()
    def javadocBucket = props.getProperty('amazonDownloadsBucket')
    def folderName = "java-sdk-doc/"

    println '[Release] Deleting existing JavaDoc'
    ObjectListing objects = client.listObjects(new ListObjectsRequest().withBucketName(javadocBucket).withPrefix(folderName));
    List<S3ObjectSummary> objectSummaries = objects.getObjectSummaries();
    for (S3ObjectSummary next : objectSummaries) {
        client.deleteObject(new DeleteObjectRequest(next.getBucketName(), next.getKey()));
    }
    println '[Release] Deleting existing JavaDoc - Finished'
    println '[Release] Started to upload JavaDoc'
    client.setBucketWebsiteConfiguration(javadocBucket, new BucketWebsiteConfiguration("index.html"))
    FileTree javadoc = fileTree(dir: "${project(':sdk').buildDir}/docs/all")
    javadoc.each { File file ->
        println("Uploading " + file.getAbsolutePath() + " to bucket [${javadocBucket}/${folderName}] with path ${directoryPath}")
        def directoryPath =  ''
        if (project.hasProperty('testMode')) {
            println('It is going to be test release')
            directoryPath += 'test/'
        }
        fileName = file.getCanonicalPath().replace("${project(':sdk').buildDir}/docs/all/", folderName)
        PutObjectRequest request = new PutObjectRequest(javadocBucket, directoryPath + fileName, file)
        request.setCannedAcl(CannedAccessControlList.PublicRead)
        client.putObject(request)
    }
    println '[Release] Started to upload JavaDoc - Finished'
}

def uploadMaridPackagesToS3() {
    def client = getAWSClient()
    def props = getUploadOptions()
    def downloadsBucket = props.getProperty('amazonDownloadsBucket')

    FileTree packages = fileTree(dir: "${project(':marid').buildDir}/distributions")
    packages.include '*.zip'
    packages.include '*.deb'
    packages.include '*.rpm'

    println '[Release] Started to upload client packages'
    packages.each { File file ->
        def directoryPath = ''
        if (project.hasProperty('testMode')) {
            println('It is going to be test release')
            directoryPath += 'test/'
        }
        directoryPath += 'repo/'
        println("Uploading " + file.getAbsolutePath() + " to " + "bucket [${downloadsBucket}] with path ${directoryPath}")
        PutObjectRequest request = new PutObjectRequest(downloadsBucket, directoryPath + "${file.getName()}", file)
        request.setCannedAcl(CannedAccessControlList.PublicRead)
        client.putObject(request)
    }
    println '[Release] Started to upload client packages - Finished'
}

def uploadSdkPackageToS3() {
    def client = getAWSClient()
    def props = getUploadOptions()
    def downloadsBucket = props.getProperty('amazonDownloadsBucket')

    println '[Release] Started to upload opsgenie-java-sdk'
    FileTree sdk = fileTree(dir: "${buildDir}/distributions")
    sdk.include 'opsgenie-java-sdk**'

    sdk.each { File file ->
        def directoryPath = ''
        if (project.hasProperty('testMode')) {
            println('It is going to be test release')
            directoryPath += 'test/'
        }
        directoryPath += 'repo/'
        println("Uploading " + file.getAbsolutePath() + " to " + "bucket [${downloadsBucket}] with path ${directoryPath}")
        PutObjectRequest request = new PutObjectRequest(downloadsBucket, directoryPath + "${directoryPath}${file.getName()}", file)
        request.setCannedAcl(CannedAccessControlList.PublicRead)
        client.putObject(request)
    }
    println '[Release] Started to upload opsgenie-java-sdk - Finished'
}

def uploadIntegrationsToS3() {
    def client = getAWSClient()
    def props = getUploadOptions()
    def downloadsBucket = props.getProperty('amazonDownloadsBucket')

    FileTree integrations = fileTree(dir: "${buildDir}/distributions")
    integrations.include '*.zip'
    integrations.include '*.deb'
    integrations.include '*.rpm'
    integrations.exclude 'opsgenie-java-sdk**'
    println '[Release] Started to upload integration packages'
    integrations.each { File file ->
        def directoryPath = ''
        if (project.hasProperty('testMode')) {
            println('It is going to be test release')
            directoryPath += 'test/'
        }
        directoryPath += 'repo/'
        println("Uploading " + file.getAbsolutePath() + " to " + "bucket [${downloadsBucket}] with path ${directoryPath}" )
        PutObjectRequest request = new PutObjectRequest(downloadsBucket, directoryPath + "${file.getName()}", file)
        request.setCannedAcl(CannedAccessControlList.PublicRead)
        client.putObject(request)
    }
    println '[Release] Started to upload integration packages - Finished'
}

def uploadDownloadsPropertiesToS3() {
    def client = getAWSClient()
    def props = getUploadOptions()
    def downloadsBucket = props.getProperty('amazonDownloadsBucket')

    def file = file("${buildDir}/distributions/downloads.properties")
    println '[Release] Started to upload download.properties'
    logger.info("Uploading " + file.getAbsolutePath())
    def directoryPath = ''
    if (project.hasProperty('testMode')) {
        println('It is going to be test release')
        directoryPath += 'test/'
    }
    PutObjectRequest request = new PutObjectRequest(downloadsBucket, directoryPath + "${file.getName()}", file)
    request.setCannedAcl(CannedAccessControlList.PublicRead)
    client.putObject(request)
    println '[Release] Started to upload download.properties - finished'
}

def getIncreasedBugfix(String version) {
    String[] versions = version.split('\\.')
    int bugfix = Integer.valueOf(versions[2]) + 1
    return versions[0] + "." + versions[1] + "." + bugfix
}

def getIncreasedMinor(String version) {
    String[] versions = version.split("\\.")
    int minor = Integer.valueOf(versions[1]) + 1
    return versions[0] + "." + minor + ".0"
}

def getIncreasedMajor(String version) {
    String[] versions = version.split("\\.")
    int major = Integer.valueOf(versions[0]) + 1
    return major + ".0.0"
}


def increaseVersion(String type) {
    def args
    if(!project.hasProperty('args')) {
        println "You must add integrations e.g -Pargs=redmine,nagios"
    }

    args = project.args.split(',')

    Set versionNames = []

    Properties versions = project.ext.versions

    if (args.contains("all")) {
        versionNames.addAll(versions.stringPropertyNames())
    } else {
        if (args.contains("sdk")) {
            versionNames.addAll(getSdkBasedPackageNames())
        }
        if(args.contains("marid")) {
            versionNames.addAll(getMaridBasedPackageNames())
        }
        if(args.contains("lamp")) {
            versionNames.addAll(getLampBasedPackageNames())
        }

        versionNames.addAll(args)
    }

    increaseVersions(type, versionNames);
}

def increaseVersions(String type, Set versionNames) {
    Properties versions = project.ext.versions
    versions.store(new FileOutputStream("${projectDir}/version.old.properties"), "")
    for (String integration : versionNames) {
        String oldVersion = versions.getProperty(integration)
        if(oldVersion == null) {
            throw new TaskExecutionException(tasks.release, new Exception(integration +" does not exist! "))
        }

        String newVersion = oldVersion;
        if(type.equals("bugfix")) {
            newVersion = getIncreasedBugfix(oldVersion)
        } else if (type.equals("minor")) {
            newVersion = getIncreasedMinor(oldVersion)
        } else if(type.equals("major")) {
            newVersion = getIncreasedMajor(oldVersion)
        }
        versions.setProperty(integration, newVersion)
    }

    println "${type} versions increased for ${versionNames}!"
    versions.store(new FileOutputStream("${projectDir}/version.properties"), "")
}

task newMinor << {
    increaseVersion('minor')
}

task newMajor << {
    increaseVersion('major')
}


def updateGit(def args) {
    def date = new Date()
    def sdf = new SimpleDateFormat("yyyy.MM.dd-HH.mm.ss.SSSS")
    exec {
        commandLine './updateGit.sh', projectDir, "${project(":sdk").projectDir}/..",
                "Version test bump for ${args}", "OpsGenieClient-v2-${sdf.format(date)}-1"
    }
}

def resetGit(def args) {
    exec {
        commandLine './resetGit.sh'
    }
}

def versionUpdate(def type) {
    if(type.equals("minor") || type.equals("major") || type.equals("bugfix")) {
        increaseVersion(type)
        return true
    } else {
        println "=======[VERSION UPDATE SKIPPED]========"
        return false
    }
}

//DUMMY TASK ONLY TO REMOVE SNAPSHOT from version
task removeSnapshot << {

}

def getDownloadsTemplate() {
    def downloadsFile
    if(project.hasProperty("downloads")) {
        downloadsFile = project.downloads
    } else {
        downloadsFile = "${project.projectDir}/downloads.template.properties"
    }
    return downloadsFile
}

def isReleaseForAll() {
    def args = project.args.toString().split('\\,')
    return args.contains('all')
}

def isReleaseForSdk() {
    def args = project.args.toString().split('\\,')
    return args.contains('sdk')
}

def isReleaseForMarid(){
    def args = project.args.toString().split('\\,')
    return args.contains('marid')
}

def generateReleaseTasks() {
    Set tasks = ['removeSnapshot', 'clean']
    if(!project.hasProperty('args')) {
        throw new IllegalArgumentException("Please give integrations as args to release! E.g. gradle release -Pargs=nagios,redmine")
    }


    boolean testMode = project.hasProperty('testMode');

    Set args = project.args.toString().split('\\,')

    if(isReleaseForAll()) {
        tasks << 'packageAll'
        tasks << 'packageSdk'
        if (!testMode) {
            tasks << 'uploadArchives'
        }
    }else{
        if(isReleaseForSdk()){
            args.addAll(getSdkBasedPackageNames())
            if (!testMode) {
                tasks << 'uploadArchives'
            }
        }
        if(isReleaseForMarid()){
            args.addAll(getMaridBasedPackageNames())
        }
        if(isReleaseForLamp()) {
            args.addAll(getLampBasedPackageNames())
        }

        for(String integration : args) {
            String taskName = "package${Character.toUpperCase(integration.charAt(0))}${integration.substring(1)}"
            tasks << taskName
        }
    }

    return tasks
}

def isReleaseForLamp() {
    def args = project.args.toString().split('\\,')
    return args.contains('lamp')
}

def createPropertiesToUploadToNexus() {
    copy {
        from project.options
        into buildDir
    }
}

task release(type: GradleBuild ) {
    def isVersionUpdated = false;
    boolean testMode = project.hasProperty('testMode');
    if (testMode) {
        print "TEST_MODE IS ACTIVATED!"
    }
    doFirst {
        if (project.hasProperty("type")) {
            isVersionUpdated = versionUpdate(project.type);
        }
        tasks = generateReleaseTasks();
        createPropertiesToUploadToNexus();
    }
    doLast {
        generateDownloadsProperties()
        createDownloadBucketIfNonExist()
        uploadIntegrationsToS3()
        if (isReleaseForAll() || isReleaseForSdk()) {
            uploadSdkPackageToS3()
            //uploadJavaDocToS3()
            uploadMaridPackagesToS3()
        } else if (isReleaseForMarid()) {
            uploadMaridPackagesToS3()
        }

        uploadDownloadsPropertiesToS3()
        if (isVersionUpdated && !testMode) {
            updateGit(project.args)
        } else if (testMode) {
            resetGit()
        }
    }
}