build.gradle

/*
 * Copyright (c) 2007-2015 Concurrent, Inc. All Rights Reserved.
 *
 * Project and contact information: http://www.concurrentinc.com/
 */

import org.apache.tools.ant.filters.ReplaceTokens

import java.text.SimpleDateFormat

import com.monochromeroad.gradle.plugin.aws.s3.S3Sync
import com.monochromeroad.gradle.plugin.aws.s3.ACL

if( project.properties[ 'teamcity' ] ) // make them system properties
  System.properties.putAll( project.properties[ 'teamcity' ] )

if( System.properties[ 'aws.properties' ] )
{
  file( System.properties[ 'aws.properties' ] ).withReader { reader ->
    def awsProperties = new Properties()
    awsProperties.load( reader )
    System.properties.putAll( awsProperties )
  }
}

ext.majorVersion = 2.7
ext.applicationGroup = "sdk"
ext.applicationName = "Cascading-${majorVersion}-SDK"
ext.timestamp = new SimpleDateFormat( "yyyyMMdd" ).format( new Date() )
ext.archiveBaseName = "${applicationName}-${timestamp}"
ext.distDir = "${buildDir}/dist/${archiveBaseName}"
ext.distributionDir = "${buildDir}/distribution"

ext.sourceBucket = System.getProperty("source.bucket")  ?: "files.concurrentinc.com"
ext.docSourceBucket = System.getProperty("doc.source.bucket") ?: "docs.concurrentinc.com"

ext.publishBucket = System.properties[ 'publish.bucket' ] ?:  "files.concurrentinc.com"

buildscript {
  repositories {
    mavenCentral()
    mavenLocal()
    maven{ url 'http://repository-monochromeroad.forge.cloudbees.com/release/' }
    maven{ url 'http://conjars.org/repo/' }
  }
  dependencies {
    classpath group: 'com.monochromeroad.gradle', name: "gradle-aws-s3-sync", version: '0.5'
  }
}

allprojects {
  repositories {
    mavenLocal()
    mavenCentral()
    maven{ url 'http://conjars.org/repo/' }
  }
}

task copyDriven( type: Copy ) {
  from 'driven'
  into "${distDir}/driven"
}

task copyEnv( type: Copy, dependsOn: copyDriven) {
  from 'etc/setenv.sh'
  fileMode 0755
  into "${distDir}/etc"
}

task copyEMRScript(type: Copy){
    from fileTree("etc/emr")
    into distributionDir
    filter( ReplaceTokens, tokens: [ 'SOURCE_BUCKET' : publishBucket ] )
}

copyEnv.doFirst() {
  mkdir "${distDir}/etc"

  def binPaths = [ ]

  fileTree( distDir ) {
    include '*/*/bin/'
  }.visit { element ->
    if( element.isDirectory() && element.getName().equals( 'bin' ) )
      binPaths << element.getRelativePath()
  }

  def pathString = binPaths.collect { path -> "\${CASCADING_SDK_HOME}/${path}" }.join( ':' )

  filter( ReplaceTokens, tokens: [ BIN_PATHS: pathString ] )
}

task copySupport( type: Copy, dependsOn: copyEnv ) {
  from 'README.md'
  into distDir
}

task packageDist( type: Tar, dependsOn: copySupport ) {
  description = 'Creates the sdk archive.'

  baseName = applicationName
  version = timestamp
  compression = "GZIP"
  destinationDir = file( distributionDir )
  from "${buildDir}/dist/"
}

allprojects {
  task clean( type: Delete ) {
    delete buildDir
  }
}

subprojects {

  ext.distDir = "${buildDir}/dist"

  task fetchLatest {
    ext.latestURL = null
    ext.distroURL = null
    ext.isArchive = true
    ext.typePath = ''

    outputs.dir distDir
  }

  fetchLatest.onlyIf { fetchLatest.latestURL != null || fetchLatest.distroURL != null }

  fetchLatest << {

    mkdir buildDir
    mkdir distDir

    if( distroURL == null )
    {
      def latestFile = new File( buildDir, 'LATEST.TXT' )

      ant.get( src: latestURL, dest: latestFile.absolutePath, skipexisting: false )

      distroURL = latestFile.readLines()[ 0 ]
    }

    def distroZip = new File( buildDir, distroURL.substring( distroURL.lastIndexOf( '/' ) ) )

    ext.typeDir = new File( distDir, typePath )
    mkdir typeDir

    if (isArchive)
        ant.get( src: distroURL, dest: distroZip.absolutePath, skipexisting: true )
    else
        ant.get( src: distroURL, dest: typeDir, skipexisting: true )


    if( distroURL.endsWith( 'zip' ) || distroURL.contains( 'zipball' ) )
      ant.unzip( src: distroZip, dest: typeDir )
    else if( distroURL.endsWith( 'tgz' ) || distroURL.endsWith( 'tar.gz' ) || distroURL.contains( 'tarball' ))
      nativeUntar( distroZip,  typeDir )
  }

  task distCopy( type: Copy, dependsOn: fetchLatest ) {
    from( distDir )
    into( rootProject.distDir )

    rootProject.tasks[ 'packageDist' ].dependsOn << distCopy
    rootProject.tasks[ 'copyEnv' ].dependsOn << distCopy
  }
}

// we shell out to tar to preserve symlinks from the tarballs.
def nativeUntar( src, dest ) {
    def command = "tar xf ${src} -C ${dest} "
    def proc = command.execute()
    proc.waitFor()
}


// publishing code

task createArchiveLatest( dependsOn: packageDist ) {

  ext.latestArchivePath = null
}

createArchiveLatest << {

  def releaseTar = packageDist.archiveName

  assert publishBucket

  latestArchivePath = new File( distributionDir, 'latest.txt' )
  latestArchivePath.write( "http://${publishBucket}/${applicationGroup}/${majorVersion}/${releaseTar}" )
}


task s3Upload(type: S3Sync,  dependsOn: [copyEMRScript, createArchiveLatest] ){

  accessKey = System.properties[ 'publish.aws.accessId' ]
  secretKey = System.properties[ 'publish.aws.secretKey' ]

  acl ACL.PublicRead

  def s3Bucket = publishBucket

  // XXX this should probably be enabled, but it is off for now to ease development
  //assert accessKey
  //assert secretKey
  //assert s3Bucket

  keepFiles = true

  configFile = "${rootProject.projectDir}/etc/synchronizer.properties"

  into "${s3Bucket}/${applicationGroup}/${majorVersion}/"
  from distributionDir

}