| /* |
| * Copyright 2010 the original author or authors. |
| * |
| * 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. |
| */ |
| |
| /** |
| * Apache S4 Application Build File |
| * |
| * Use this script to buils and package S4 apps. |
| * |
| * Run 'gradle install' on the s4 project to publish to your local maven repo. |
| * |
| * TODO: This should probably be distributed as an s4 plugin for Gradle. |
| * TODO: There seem to be to be similarities with the war and jetty plugins. (war -> s4r, jetty -> s4Run). |
| * We should make it easy to test the app from this script by a running a test task that starts and stops |
| * an s4 server. See: http://www.gradle.org/releases/1.0-milestone-3/docs/userguide/userguide_single.html#war_plugin |
| * |
| * This is an interesting discussion: |
| * http://gradle.1045684.n5.nabble.com/Exclude-properties-file-from-war-td3365147.html |
| * |
| */ |
| |
| /* Set the destination where we want to install the apps. */ |
| //s4AppInstallDir = "/tmp/s4Apps" // TODO: decide how to standarize dirs, use env var? |
| |
| project.ext["s4AppInstallDir"] = hasProperty('appsDir') ? "$appsDir" : "/tmp/appsDir" |
| |
| project.ext["s4Version"] = '0.5.0-SNAPSHOT' |
| description = 'Apache S4 App' |
| //defaultTasks 'installS4R' |
| archivesBaseName = "$project.name" |
| distRootFolder = "$archivesBaseName-${-> version}" |
| |
| |
| // Append the suffix 'SNAPSHOT' when the build is not for release. |
| version = new Version(major: 0, minor: 0, bugfix: 0, isRelease: false) |
| group = 'org.apache.s4' |
| |
| apply plugin: 'java' |
| apply plugin: 'eclipse' |
| |
| /* The app classname is set automatically from the source files. */ |
| def appClassname = '' |
| |
| /* Set Java version. */ |
| sourceCompatibility = 1.6 |
| targetCompatibility = 1.6 |
| |
| |
| |
| /* All project libraries must be defined here. */ |
| project.ext["libraries"] = [ |
| json: 'org.json:json:20090211', |
| guava: 'com.google.guava:guava:10.0.1', |
| gson: 'com.google.code.gson:gson:1.6', |
| guice: 'com.google.inject:guice:3.0', |
| guice_assist: 'com.google.inject.extensions:guice-assistedinject:3.0', |
| guice_grapher: 'com.google.inject:guice-grapher:3.0', |
| flexjson: 'net.sf.flexjson:flexjson:2.1', |
| bcel: 'org.apache.bcel:bcel:5.2', |
| jakarta_regexp: 'jakarta-regexp:jakarta-regexp:1.4', |
| kryo: 'com.googlecode:kryo:1.04', |
| netty: 'org.jboss.netty:netty:3.2.5.Final', |
| reflectasm: 'com.esotericsoftware:reflectasm:0.8', |
| minlog: 'com.esotericsoftware:minlog:1.2', |
| asm: 'asm:asm:3.2', |
| commons_io: 'commons-io:commons-io:2.0.1', |
| commons_config: 'commons-configuration:commons-configuration:1.6', |
| commons_codec: 'commons-codec:commons-codec:1.4', |
| commons_httpclient: 'commons-httpclient:commons-httpclient:3.1', |
| commons_coll: 'net.sourceforge.collections:collections-generic:4.01', // Use this lib until the commons collection with Generics is released. |
| slf4j: 'org.slf4j:slf4j-api:1.6.1', |
| logback_core: 'ch.qos.logback:logback-core:0.9.29', |
| logback_classic: 'ch.qos.logback:logback-classic:0.9.29', |
| zk: 'org.apache.zookeeper:zookeeper:3.3.1', |
| jcip: 'net.jcip:jcip-annotations:1.0', |
| junit: 'junit:junit:4.10', |
| ] |
| |
| |
| dependencies { |
| |
| /* S4 Platform. We only need the API, not the transitive dependencies. */ |
| // s4Libs.each { module -> |
| // compile( module ) //{ transitive = false } |
| // s4API( module ) |
| // } |
| |
| compile project(":s4-base") |
| compile project(":s4-comm") |
| compile project(":s4-core") |
| |
| /* Logging. */ |
| compile( libraries.slf4j ) |
| compile( libraries.logback_core ) |
| compile( libraries.logback_classic ) |
| |
| /* Commons. */ |
| compile( libraries.commons_io ) |
| compile( libraries.commons_config ) |
| compile( libraries.commons_coll ) |
| |
| /* Misc. */ |
| compile( libraries.jcip ) |
| |
| /* Testing. */ |
| testCompile( libraries.junit ) |
| } |
| |
| /* Set the manifest attributes for the S4 archive here. |
| * TODO: separate custom properties from std ones and set custom properties at the top of the build script. |
| */ |
| manifest.mainAttributes( |
| provider: 'gradle', |
| 'Implementation-Url': 'http://incubator.apache.org/projects/s4.html', |
| 'Implementation-Version': version, |
| 'Implementation-Vendor': 'Apache S4', |
| 'Implementation-Vendor-Id': 's4app', |
| 'S4-App-Class': appClassname, // gets set by the s4r task. |
| 'S4-Version': s4Version |
| ) |
| |
| project.ext["appDependencies"] = ( configurations.compile ) |
| |
| /* This task will extract all the class files and create a fat jar. We set the manifest and the extension to make it an S4 archive file. */ |
| // TODO: exclude schenma files as needed (not critical) see: http://forums.gradle.org/gradle/topics/using_gradle_to_fat_jar_a_spring_project |
| task s4r(type: Jar) { |
| dependsOn jar |
| from { appDependencies.collect { it.isDirectory() ? it : zipTree(it) } } |
| from { configurations.archives.allArtifacts.files.collect { it.isDirectory() ? it : zipTree(it) } } |
| manifest = project.manifest |
| extension = 's4r' |
| |
| /* Set class name in manifest. Parse source files until we find a class that extends App. |
| * Get fully qualified Java class name and set attribute in Manifest. |
| */ |
| sourceSets.main.allSource.files.each { File file -> |
| if (appClassname =="" || appClassname == "UNKNOWN") { |
| // only execute the closure for this file if we haven't already found the app class name |
| appClassname = getAppClassname(file) |
| if(appClassname != "") { |
| manifest.mainAttributes('S4-App-Class': appClassname) |
| } |
| } |
| } |
| |
| if (appClassname == "UNKNOWN") { |
| |
| println "Couldn't find App class in source files...aborting." |
| exit(1) |
| } |
| } |
| |
| /* List the artifacts that will br added to the s4 archive (and explode if needed). */ |
| s4r << { |
| appDependencies.each { File file -> println 'Adding to s4 archive: ' + file.name } |
| configurations.archives.allArtifacts.files.each { File file -> println 'Adding to s4 archive: ' + file.name } |
| |
| /* This is for debugging. */ |
| //configurations.s4All.each { File file -> println 's4All: ' + file.name } |
| //deployableDependencies.each { File file -> println 'Deploy: ' + file.name } |
| |
| // more debugging statements. |
| //sourceSets.main.compileClasspath.each { File file -> println 'compileClasspath: ' + file.name } |
| |
| } |
| |
| /* Install the S4 archive to the install directory. */ |
| task installS4R (type: Copy) { |
| dependsOn s4r |
| from s4r.archivePath |
| into s4AppInstallDir |
| } |
| |
| /* Generates the gradlew scripts. |
| http://www.gradle.org/1.0-milestone-3/docs/userguide/gradle_wrapper.html */ |
| task wrapper(type: Wrapper) { gradleVersion = '1.0-milestone-3' } |
| |
| |
| /* Parse source file to get the app classname so we can use it in the manifest. |
| * TODO: Use a real Java parser. (This is not skippong comments for example.) |
| */ |
| def getAppClassname(file) { |
| def classname = "UNKNOWN" |
| def lines= file.readLines() |
| def packageName = "" |
| for(line in lines) { |
| |
| def pn = line =~ /.*package\s+([\w\.]+)\s*;.*/ |
| if(pn) { |
| packageName = pn[0][1] + "." |
| } |
| |
| def an = line =~ /.*public\s+class\s+(\w+)\s+extends.+App.*\{/ |
| if (an) { |
| classname = packageName + an[0][1] |
| println "Found app class name: " + classname |
| break |
| } |
| } |
| classname |
| } |
| |
| class Version { |
| int major |
| int minor |
| int bugfix |
| boolean isRelease |
| |
| String toString() { |
| "$major.$minor.$bugfix${isRelease ? '' : '-SNAPSHOT'}" |
| } |
| } |
