build.gradle

/*
 * Licensed to Elasticsearch under one or more contributor
 * license agreements. See the NOTICE file distributed with
 * this work for additional information regarding copyright
 * ownership. Elasticsearch licenses this file to you 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.bmuschko.gradle.nexus.NexusPlugin
import org.gradle.plugins.ide.eclipse.model.SourceFolder

// common maven publishing configuration
subprojects {
  group = 'org.elasticsearch'
  version = org.elasticsearch.gradle.VersionProperties.elasticsearch

  plugins.withType(NexusPlugin).whenPluginAdded {
    modifyPom {
      project {
        url 'https://github.com/elastic/elasticsearch'
        inceptionYear '2009'

        scm {
          url 'https://github.com/elastic/elasticsearch'
          connection 'scm:https://elastic@github.com/elastic/elasticsearch'
          developerConnection 'scm:git://github.com/elastic/elasticsearch.git'
        }

        licenses {
          license {
            name 'The Apache Software License, Version 2.0'
            url 'http://www.apache.org/licenses/LICENSE-2.0.txt'
            distribution 'repo'
          }
        }
      }
    }  
    extraArchive {
      javadoc = false
      tests = false
    }
    // we have our own username/password prompts so that they only happen once
    // TODO: add gpg signing prompts
    project.gradle.taskGraph.whenReady { taskGraph ->
      if (taskGraph.allTasks.any { it.name == 'uploadArchives' }) {
        Console console = System.console()
        if (project.hasProperty('nexusUsername') == false) {
          String nexusUsername = console.readLine('\nNexus username: ')
          project.rootProject.allprojects.each {
            it.ext.nexusUsername = nexusUsername
          }
        }
        if (project.hasProperty('nexusPassword') == false) {
          String nexusPassword = new String(console.readPassword('\nNexus password: '))
          project.rootProject.allprojects.each {
            it.ext.nexusPassword = nexusPassword
          }
        }
      }
    }
  }
}

if (hasProperty('projectsPrefix') == false) {
  allprojects {
    project.ext['projectsPrefix'] = ''
  }  
}

allprojects {
  // injecting groovy property variables into all projects
  project.ext {
    // for eclipse hacks...
    isEclipse = System.getProperty("eclipse.launcher") != null || gradle.startParameter.taskNames.contains('eclipse') || gradle.startParameter.taskNames.contains('cleanEclipse')
  }
}

subprojects {
  // include license and notice in jars
  gradle.projectsEvaluated {
    tasks.withType(Jar) {
      into('META-INF') {
        from project.rootProject.rootDir
        include 'LICENSE.txt'   
        include 'NOTICE.txt'   
      }
    }
  }

  configurations {
    all {
      resolutionStrategy {
        dependencySubstitution {
          substitute module("org.elasticsearch:rest-api-spec:${version}") with project("${projectsPrefix}:rest-api-spec")
          substitute module("org.elasticsearch:elasticsearch:${version}") with project("${projectsPrefix}:core")
          substitute module("org.elasticsearch:test-framework:${version}") with project("${projectsPrefix}:test-framework")
          substitute module("org.elasticsearch.distribution.zip:elasticsearch:${version}") with project("${projectsPrefix}:distribution:zip")
          substitute module("org.elasticsearch.distribution.tar:elasticsearch:${version}") with project("${projectsPrefix}:distribution:tar")
        }
      }
    }
  }
}

// intellij configuration
allprojects {
  apply plugin: 'idea'
}

if (projectsPrefix.isEmpty()) {
  idea {
    project {
      languageLevel = org.elasticsearch.gradle.BuildPlugin.minimumJava
      vcs = 'Git'
    }
  }
  tasks.cleanIdea {
    delete '.idea'
  }
}

// eclipse configuration
allprojects {
  apply plugin: 'eclipse'

  plugins.withType(JavaBasePlugin) {
    eclipse.classpath.defaultOutputDir = new File(project.buildDir, 'eclipse')
    eclipse.classpath.file.whenMerged { classpath ->
      // give each source folder a unique corresponding output folder
      int i = 0;
      classpath.entries.findAll { it instanceof SourceFolder }.each { folder ->
        i++;
        // this is *NOT* a path or a file.
        folder.output = "build/eclipse/" + i
      }
    }
  }
  task copyEclipseSettings(type: Copy) {
    // TODO: "package this up" for external builds
    from new File(project.rootDir, 'buildSrc/src/main/resources/eclipse.settings')
    into '.settings'
  }
  // otherwise .settings is not nuked entirely
  tasks.cleanEclipse {
    delete '.settings'
  }
  // otherwise the eclipse merging is *super confusing*
  tasks.eclipse.dependsOn(cleanEclipse, copyEclipseSettings)
}

// add buildSrc itself as a groovy project
task buildSrcEclipse(type: GradleBuild) {
  buildFile = 'buildSrc/build.gradle'
  tasks = ['cleanEclipse', 'eclipse']
}
tasks.eclipse.dependsOn(buildSrcEclipse)

task clean(type: GradleBuild) {
  buildFile = 'buildSrc/build.gradle'
  tasks = ['clean']
}

// we need to add the same --debug-jvm option as
// the real RunTask has, so we can pass it through
class Run extends DefaultTask {
  boolean debug = false

  @org.gradle.api.internal.tasks.options.Option(
        option = "debug-jvm",
        description = "Enable debugging configuration, to allow attaching a debugger to elasticsearch."
  )
  public void setDebug(boolean enabled) {
    project.project(':distribution').run.clusterConfig.debug = enabled
  } 
}
task run(type: Run) {
  dependsOn ':distribution:run'
  description = 'Runs elasticsearch in the foreground'
  group = 'Verification'
}