diff --git a/.gitignore b/.gitignore index 9ea4f9ff..a680191b 100644 --- a/.gitignore +++ b/.gitignore @@ -1,14 +1,15 @@ .gradle annotations .idea/* -!.idea/modules.xml -buildScript +*.iml +nonBuildScript kobaltBuild -test-output local.properties classes libs .kobalt/ -./build/ out .DS_Store +lib/kotlin-* +build +.history diff --git a/.idea/modules.xml b/.idea/modules.xml deleted file mode 100644 index a41ffd7c..00000000 --- a/.idea/modules.xml +++ /dev/null @@ -1,11 +0,0 @@ - - - - - - - - - - - \ No newline at end of file diff --git a/.travis.yml b/.travis.yml deleted file mode 100644 index b9fa0cde..00000000 --- a/.travis.yml +++ /dev/null @@ -1,12 +0,0 @@ -cache: - directories: - - $HOME/.m2 - -language: java - -jdk: - - oraclejdk8 - -install: true - -script: ./kobaltw test --log 1 diff --git a/README.md b/README.md index 29bc3bd1..d5d7cbe0 100644 --- a/README.md +++ b/README.md @@ -1,11 +1,15 @@ # Kobalt +[](https://teamcity.jetbrains.com/project.html?projectId=OpenSourceProjects_Kobalt&tab=projectOverview) + + Kobalt is a universal build system. To build it: ``` -./kobaltw assemble +$ ./kobaltw assemble ``` Please see [the web site](http://beust.com/kobalt/) for the full documentation. + diff --git a/TODO.md b/TODO.md index 2bd27c88..c4625308 100644 --- a/TODO.md +++ b/TODO.md @@ -2,48 +2,31 @@ To do: Android: -- [ ] Dex dependencies into kobaltBuild/intermediates/pre-dexed and preserve those across builds -- [ ] Move the calculated applicationId back into the merged AndroidManifest.xml -- [ ] Dex from android builder -- [ ] Keep exploded aars between runs -- [ ] aars keep being refetched -- [ ] See if there is an android manifest file in builder General +- [ ] KFiles.findSourceFiles should cache its results +- [ ] createCompilerAction should calculate source files once and for all, including contributors and interceptors +- [ ] Need a -resolve with no dependency which gives the tree for the whole project +- [ ] If jitpack specified with http and not https, 301 is not handled correctly - [ ] Apt should run from serviceloader -- [ ] Auto add variant -- [ ] The test runner only selects classes with a parameterless constructor, which works for JUnit but not for TestNG - factories -- [ ] Add a "Auto complete Build.kt" menu in the plug-in -- [ ] "All artifacts successfully uploaded" is shown before the upload is actually done -- [ ] use groupId/artifactId - [ ] Console mode with watch service, so recompilation can occur as soon as a source file is modified - [ ] ProjectGenerator: support migration from pom.xml (starting with dependencies) - [ ] Specify where to upload snapshots -- [ ] Upload in a thread pool - [ ] repos() must appear before plugins(): fix that -- [ ] Support version ranges - [ ] Generate .idea and other IDEA files -- [ ] logs for users should not show any timestamp, class file or thread id, this should only be in --dev mode - [ ] Fetch .pom with DynamicGraph - [ ] Centralize all the executors - [ ] Archetypes (e.g. "--initWith kobalt-plug-in") -- [ ] Compile TestNG (including generating Version.java and OSGi headers) +- [ ] Compile TestNG (last piece missing: OSGi headers) - [ ] Support additional .kt files in ~/.kobalt/src -- [ ] generateArchive() should use Path instead of File - [ ] --init: import dependencies from build.gradle - [ ] --init: also extract kobalt.bat (or generate it along with kobaltw) -- [ ] Bug: --tasks displays multiple tasks when there are multiple projects -- [ ] Bug: ./kobaltw --dryRun kobalt:uploadJcenter runs "kobalt-wrapper:clean" twice -- [ ] Replace File with java.nio.Files and Path -- [ ] Create a wiki page for plugins -- [ ] Make kobaltw executable in the zip file - [ ] Encapsulate ProcessBuilder code -- [ ] --resolve Done: +- [x] Dex dependencies into kobaltBuild/intermediates/pre-dexed and preserve those across builds - [x] Compile with javax.tool - [x] Android: multiple -source/-target flags - [x] Dokka: allow multiple format outputs e.g `outputFormat("html", "javadoc")` @@ -84,5 +67,24 @@ just a straight Java class with minimal dependencies for fast start up - [x] Upload non maven files - [x] Jar packaging: include the jar in the jar (not supported by JarFile) - [x] Encapsulate BuildFile for better log messages +- [x] The test runner only selects classes with a parameterless constructor, which works for JUnit but not for TestNG +- [x] Add a "Auto complete Build.kt" menu in the plug-in +- [x] "All artifacts successfully uploaded" is shown before the upload is actually done +- [x] use groupId/artifactId + factories +- [x] Support version ranges +- [x] Upload in a thread pool +- [x] logs for users should not show any timestamp, class file or thread id, this should only be in --dev mode +- [x] Bug: --tasks displays multiple tasks when there are multiple projects +- [x] Bug: ./kobaltw --dryRun kobalt:uploadJcenter runs "kobalt-wrapper:clean" twice +- [x] Create a wiki page for plugins +- [x] Make kobaltw executable in the zip file +- [x] --resolve +- [x] Move the calculated applicationId back into the merged AndroidManifest.xml +- [x] Dex from android builder +- [x] Keep exploded aars between runs +- [x] aars keep being refetched +- [x] See if there is an android manifest file in builder +- [x] Auto add variant diff --git a/build-travis.sh b/build-travis.sh new file mode 100755 index 00000000..c7cb1152 --- /dev/null +++ b/build-travis.sh @@ -0,0 +1,8 @@ +ulimit -s 1082768 + +#java -Xmx2048m -jar $(dirname $0)/kobalt/wrapper/kobalt-wrapper.jar $* clean +java -Xmx2048m -jar $(dirname $0)/kobalt/wrapper/kobalt-wrapper.jar $* clean assemble test --parallel + + + + diff --git a/build.gradle b/build.gradle index f179b96d..3f0053cc 100644 --- a/build.gradle +++ b/build.gradle @@ -1,92 +1,58 @@ -buildscript { - ext.kotlin_version = '1.0.0-beta-2423' +allprojects { + group = 'com.beust' + version = '1.1.0' +} + +subprojects { + apply plugin: 'java' + apply plugin: 'maven-publish' + + ext { + bndlib = '3.5.0' + findbugs = '3.0.2' + groovy = '2.4.12' + gson = '2.8.2' + guice = '4.2.2' + inject = '1' + jaxb = '2.3.0' + jcommander = '1.72' + kotlin = '1.2.71' + maven = '3.5.2' + mavenResolver = '1.1.0' + okhttp = '3.9.1' + okio = '1.13.0' + retrofit = '2.3.0' + slf4j = '1.7.3' + spark = '2.6.0' + testng = '6.12' + + junit = '4.12' + junitJupiter = '5.1.0' + junitPlatform = '1.1.0' + } repositories { + mavenCentral() + mavenLocal() jcenter() - } - dependencies { - classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${kotlin_version}" - } -} + maven { + url = 'https://dl.bintray.com/cbeust/maven' + } -plugins { - id "com.jfrog.bintray" version "1.2" -} - -version = '0.121' - -//apply plugin: 'java' -apply plugin: 'kotlin' -apply plugin: 'com.jfrog.bintray' - -apply from: 'gradle/publishing.gradle' - -repositories { - jcenter() -} - -dependencies { - compile "org.jetbrains.kotlin:kotlin-stdlib:${kotlin_version}", - "org.jetbrains.kotlin:kotlin-compiler-embeddable:${kotlin_version}", - 'org.jetbrains.kotlinx:kotlinx.dom:0.0.4', - 'org.jetbrains.dokka:dokka-fatjar:0.9.2', -// "org.jetbrains.kotlin:kotlin-compiler:${kotlin_version}", - - "com.android.tools.build:builder:2.0.0-alpha3", - - 'com.beust:jcommander:1.48', - 'com.squareup.okhttp:okhttp:2.5.0', - 'org.jsoup:jsoup:1.8.3', - 'com.google.inject:guice:4.0', - 'com.google.inject.extensions:guice-assistedinject:4.0', - 'javax.inject:javax.inject:1', - 'com.google.guava:guava:19.0-rc2', - 'org.apache.maven:maven-model:3.3.3', - 'com.github.spullara.mustache.java:compiler:0.9.1', - 'io.reactivex:rxjava:1.0.16', - 'com.google.code.gson:gson:2.4', - 'com.squareup.retrofit:retrofit:1.9.0', - 'com.squareup.okio:okio:1.6.0', - project("modules/wrapper") - -// compile files("/Users/beust/.kobalt/repository/com/beust/kobalt-example-plugin/build/libs/kobalt-example-plugin.jar") - testCompile 'org.testng:testng:6.9.9' -// testCompile 'junit:junit:4.12' -} - -task sourceJar(type: Jar) { - group 'Build' - description 'An archive of the source code' - classifier 'sources' - from sourceSets.main.allSource -} - -artifacts { - file('build/libs/kobalt.jar') - sourceJar -} - -test { - useTestNG() - beforeTest { descriptor -> - logger.lifecycle(" Running test: " + descriptor) - } -} - -compileKotlin { - kotlinOptions.suppressWarnings = true -} - -apply plugin: 'application' -mainClassName = 'com.beust.kobalt.KobaltPackage' - -jar { - manifest { - attributes "Main-Class": "$mainClassName" + maven { + url = 'https://repo.maven.apache.org/maven2' + } } - from { - configurations.compile.collect { it.isDirectory() ? it : zipTree(it) } + sourceCompatibility = '1.7' + + task sourcesJar(type: Jar) { + from sourceSets.main.allJava + archiveClassifier = 'sources' + } + + task javadocJar(type: Jar) { + from javadoc + archiveClassifier = 'javadoc' } } - diff --git a/dist/kobaltw b/dist/kobaltw new file mode 100755 index 00000000..333738df --- /dev/null +++ b/dist/kobaltw @@ -0,0 +1,11 @@ +#!/usr/bin/env sh + +case "$(uname)" in + CYGWIN*) DIRNAME=$(cygpath -d "$(dirname "$(readlink -f "$0")")");; + Darwin*) DIRNAME=$(dirname "$(readlink "$0")");; + *) DIRNAME=$(dirname "$(readlink -f "$0")");; +esac +if [ "$DIRNAME" = "." ]; then + DIRNAME="$(dirname "$0")" +fi +java -jar "${DIRNAME}/../kobalt/wrapper/kobalt-wrapper.jar" $* \ No newline at end of file diff --git a/dist/kobaltw.bat b/dist/kobaltw.bat new file mode 100644 index 00000000..2d95345e --- /dev/null +++ b/dist/kobaltw.bat @@ -0,0 +1,4 @@ +@echo off +set DIRNAME=%~dp0 +if "%DIRNAME%" == "" set DIRNAME=. +java -jar "%~dp0/../kobalt/wrapper/kobalt-wrapper.jar" %* diff --git a/gradle/buildWithTravis.sh b/gradle/buildWithTravis.sh deleted file mode 100644 index 9f0ddf10..00000000 --- a/gradle/buildWithTravis.sh +++ /dev/null @@ -1 +0,0 @@ -../gradlew check diff --git a/gradle/publishing.gradle b/gradle/publishing.gradle deleted file mode 100644 index 3e9e7c42..00000000 --- a/gradle/publishing.gradle +++ /dev/null @@ -1,60 +0,0 @@ -import java.text.SimpleDateFormat - -Date buildTimeAndDate = new Date() -ext { - buildTime = new SimpleDateFormat('yyyy-MM-dd').format(buildTimeAndDate) - buildDate = new SimpleDateFormat('HH:mm:ss.SSSZ').format(buildTimeAndDate) -} - -apply plugin: 'maven-publish' -apply plugin: 'com.jfrog.bintray' - -jar { - manifest { - attributes( - 'Built-By': System.properties['user.name'], - 'Created-By': System.properties['java.version'] + " (" + System.properties['java.vendor'] + " " + System.getProperty("java.vm.version") + ")", - 'Build-Date': project.buildTime, - 'Build-Time': project.buildDate, - 'Specification-Title': project.name, - 'Specification-Version': project.version, - ) - } -} - -publishing { - publications { - mavenCustom(MavenPublication) { - from components.java - artifact sourceJar - - groupId 'com.beust' - artifactId 'kobalt' - version project.version - } - } -} - -task install(dependsOn: publishToMavenLocal) - -Properties properties = new Properties() -if (new File('local.properties').exists()) { - properties.load(project.rootProject.file('local.properties').newDataInputStream()) -} - -bintray { - user = properties.getProperty("bintray.user") - key = properties.getProperty("bintray.apikey") - publications = ['mavenCustom'] - pkg { - repo = 'maven' - name = 'klaxon' - desc = 'JSON parsing for Kotlin' - licenses = ['Apache-2.0'] - labels = ['kotlin'] - - version { - name = project.version //Bintray logical version name - } - } -} diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar index 30d399d8..5c2d1cf0 100644 Binary files a/gradle/wrapper/gradle-wrapper.jar and b/gradle/wrapper/gradle-wrapper.jar differ diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties index 5724a1d2..838e6bc8 100644 --- a/gradle/wrapper/gradle-wrapper.properties +++ b/gradle/wrapper/gradle-wrapper.properties @@ -1,6 +1,5 @@ -#Sun Oct 04 21:38:45 EDT 2015 distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists +distributionUrl=https\://services.gradle.org/distributions/gradle-5.3-bin.zip zipStoreBase=GRADLE_USER_HOME zipStorePath=wrapper/dists -distributionUrl=https\://services.gradle.org/distributions/gradle-2.9-all.zip diff --git a/gradlew b/gradlew index 91a7e269..b0d6d0ab 100755 --- a/gradlew +++ b/gradlew @@ -1,4 +1,20 @@ -#!/usr/bin/env bash +#!/usr/bin/env sh + +# +# Copyright 2015 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. +# ############################################################################## ## @@ -6,47 +22,6 @@ ## ############################################################################## -# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. -DEFAULT_JVM_OPTS="" - -APP_NAME="Gradle" -APP_BASE_NAME=`basename "$0"` - -# Use the maximum available, or set MAX_FD != -1 to use that value. -MAX_FD="maximum" - -warn ( ) { - echo "$*" -} - -die ( ) { - echo - echo "$*" - echo - exit 1 -} - -# OS specific support (must be 'true' or 'false'). -cygwin=false -msys=false -darwin=false -case "`uname`" in - CYGWIN* ) - cygwin=true - ;; - Darwin* ) - darwin=true - ;; - MINGW* ) - msys=true - ;; -esac - -# For Cygwin, ensure paths are in UNIX format before anything is touched. -if $cygwin ; then - [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"` -fi - # Attempt to set APP_HOME # Resolve links: $0 may be a link PRG="$0" @@ -61,9 +36,49 @@ while [ -h "$PRG" ] ; do fi done SAVED="`pwd`" -cd "`dirname \"$PRG\"`/" >&- +cd "`dirname \"$PRG\"`/" >/dev/null APP_HOME="`pwd -P`" -cd "$SAVED" >&- +cd "$SAVED" >/dev/null + +APP_NAME="Gradle" +APP_BASE_NAME=`basename "$0"` + +# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' + +# Use the maximum available, or set MAX_FD != -1 to use that value. +MAX_FD="maximum" + +warn () { + echo "$*" +} + +die () { + echo + echo "$*" + echo + exit 1 +} + +# OS specific support (must be 'true' or 'false'). +cygwin=false +msys=false +darwin=false +nonstop=false +case "`uname`" in + CYGWIN* ) + cygwin=true + ;; + Darwin* ) + darwin=true + ;; + MINGW* ) + msys=true + ;; + NONSTOP* ) + nonstop=true + ;; +esac CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar @@ -90,7 +105,7 @@ location of your Java installation." fi # Increase the maximum file descriptors if we can. -if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then +if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then MAX_FD_LIMIT=`ulimit -H -n` if [ $? -eq 0 ] ; then if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then @@ -114,6 +129,7 @@ fi if $cygwin ; then APP_HOME=`cygpath --path --mixed "$APP_HOME"` CLASSPATH=`cygpath --path --mixed "$CLASSPATH"` + JAVACMD=`cygpath --unix "$JAVACMD"` # We build the pattern for arguments to be converted via cygpath ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null` @@ -154,11 +170,19 @@ if $cygwin ; then esac fi -# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules -function splitJvmOpts() { - JVM_OPTS=("$@") +# Escape application args +save () { + for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done + echo " " } -eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS -JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME" +APP_ARGS=$(save "$@") -exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@" +# Collect all arguments for the java command, following the shell quoting and substitution rules +eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS" + +# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong +if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then + cd "$(dirname "$0")" +fi + +exec "$JAVACMD" "$@" diff --git a/gradlew.bat b/gradlew.bat index 8a0b282a..9991c503 100644 --- a/gradlew.bat +++ b/gradlew.bat @@ -1,3 +1,19 @@ +@rem +@rem Copyright 2015 the original author or authors. +@rem +@rem Licensed under the Apache License, Version 2.0 (the "License"); +@rem you may not use this file except in compliance with the License. +@rem You may obtain a copy of the License at +@rem +@rem http://www.apache.org/licenses/LICENSE-2.0 +@rem +@rem Unless required by applicable law or agreed to in writing, software +@rem distributed under the License is distributed on an "AS IS" BASIS, +@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +@rem See the License for the specific language governing permissions and +@rem limitations under the License. +@rem + @if "%DEBUG%" == "" @echo off @rem ########################################################################## @rem @@ -8,14 +24,14 @@ @rem Set local scope for the variables with windows NT shell if "%OS%"=="Windows_NT" setlocal -@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. -set DEFAULT_JVM_OPTS= - set DIRNAME=%~dp0 if "%DIRNAME%" == "" set DIRNAME=. set APP_BASE_NAME=%~n0 set APP_HOME=%DIRNAME% +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" + @rem Find java.exe if defined JAVA_HOME goto findJavaFromJavaHome @@ -46,10 +62,9 @@ echo location of your Java installation. goto fail :init -@rem Get command-line arguments, handling Windowz variants +@rem Get command-line arguments, handling Windows variants if not "%OS%" == "Windows_NT" goto win9xME_args -if "%@eval[2+2]" == "4" goto 4NT_args :win9xME_args @rem Slurp the command line arguments. @@ -60,11 +75,6 @@ set _SKIP=2 if "x%~1" == "x" goto execute set CMD_LINE_ARGS=%* -goto execute - -:4NT_args -@rem Get arguments from the 4NT Shell from JP Software -set CMD_LINE_ARGS=%$ :execute @rem Setup the command line diff --git a/kobalt-incremental-tasks.md b/kobalt-incremental-tasks.md new file mode 100644 index 00000000..f799a81a --- /dev/null +++ b/kobalt-incremental-tasks.md @@ -0,0 +1,78 @@ +Kobalt's incremental task algorithm is not based on timestamps but on checksums. + +You make a task incremental by declaring it `@IncrementalTask` instead of `@Task`. The only other difference is that instead of returning a `TaskResult`, incremental tasks return an `IncrementalTaskInfo`: + +``` +class IncrementalTaskInfo( + val inputChecksum: String?, + val outputChecksum: String?, + val task: (Project) -> TaskResult) +``` + +This class contains three fields: + +- A task closure, which is your effective task: `(Project) -> TaskResult` +- An input checksum (`String?`) +- An output checksum (`String?`) + +These checksums are numbers that each task calculates for their input and output. For example, the `"compile"` task calculates an MD5 checksum of all the source files. Similarly, the output checksum is for produced artifacts, e.g. checksum of `.class` files or `.jar` files, etc... + +Example of an incremental task: + +``` + @IncrementalTask(name = JvmCompilerPlugin.TASK_COMPILE, description = "Compile the project") + fun taskCompile(project: Project) : IncrementalTaskInfo { + val inputChecksum = Md5.toMd5Directories(project.sourceDirectories.map { + File(project.directory, it) + }) + return IncrementalTaskInfo( + inputChecksum = inputChecksum, + outputChecksum = "1", + task = { project -> doTaskCompile(project) } + ) + } +``` + +The advantage of checksums is that they take care of all the scenarios that would cause that task to run: + +- A file was modified +- A file was added +- A file was removed + +The output checksum covers the case where the input is unchanged but the output files were deleted or modified. If +both the input and output checksums match the previous run, it's extremely likely that the task has nothing to do. + +Another advantage of checksums is that they are generic and not necessarily tied to files. For example, a Kobalt task might perform some network operations and return a checksum based on a network result to avoid performing a more expensive operation (e.g. don't download a file from a server if it hasn't changed). + +Internally, Kobalt maintains information about all the checksums and tasks that it has seen in a file `.kobalt/build-info.json`. Whenever an incremental task is about to run, Kobalt compares its input and output checksums to the ones from the previous run and if any differs, that task is run. Otherwise, it's skipped. + +Example timings for Kobalt: + +| Task | First run | Second run | +| ---- | --------- | ---------- | +| kobalt-wrapper:compile | 627 ms | 22 ms | +| kobalt-wrapper:assemble | 9 ms | 9 ms | +| kobalt-plugin-api:compile | 10983 ms | 54 ms | +| kobalt-plugin-api:assemble | 1763 ms | 154 ms | +| kobalt:compile | 11758 ms | 11 ms | +| kobalt:assemble | 42333 ms | 2130 ms | +| | 70 seconds | 2 seconds | + +Android (u2020): + +| Task | First run | Second run | +| ---- | --------- | ---------- | +| u2020:generateRInternalDebug | 32350 ms | 1652 ms | +| u2020:compileInternalDebug | 3629 ms | 24 ms | +| u2020:retrolambdaInternalDebug | 668 ms | 473 ms | +| u2020:generateDexInternalDebug | 6130 ms |55 ms | +| u2020:signApkInternalDebug | 449 ms | 404 ms | +| u2020:assembleInternalDebug | 0 ms | 0 ms | +| | 43 seconds | 2 seconds | + + + + + + + diff --git a/kobalt.iml b/kobalt.iml deleted file mode 100644 index 2b0a7d1a..00000000 --- a/kobalt.iml +++ /dev/null @@ -1,18 +0,0 @@ - - - - - - - - - - - - - - - - - - \ No newline at end of file diff --git a/kobalt/Build.kt.iml b/kobalt/Build.kt.iml deleted file mode 100644 index 2f22cf63..00000000 --- a/kobalt/Build.kt.iml +++ /dev/null @@ -1,13 +0,0 @@ - - - - - - - - - - - - - \ No newline at end of file diff --git a/kobalt/src/Build.kt b/kobalt/src/Build.kt index bc7f53f2..0d09844a 100644 --- a/kobalt/src/Build.kt +++ b/kobalt/src/Build.kt @@ -1,29 +1,61 @@ -import com.beust.kobalt.TaskResult -import com.beust.kobalt.api.License +import com.beust.kobalt.* import com.beust.kobalt.api.Project -import com.beust.kobalt.api.Scm import com.beust.kobalt.api.annotation.Task -import com.beust.kobalt.homeDir import com.beust.kobalt.plugin.application.application import com.beust.kobalt.plugin.java.javaCompiler -import com.beust.kobalt.plugin.java.javaProject import com.beust.kobalt.plugin.kotlin.kotlinCompiler -import com.beust.kobalt.plugin.kotlin.kotlinProject import com.beust.kobalt.plugin.packaging.assemble +import com.beust.kobalt.plugin.publish.autoGitTag +import com.beust.kobalt.plugin.publish.bintray import com.beust.kobalt.plugin.publish.github -import com.beust.kobalt.plugin.publish.jcenter -import com.beust.kobalt.repos -import com.beust.kobalt.test +import org.apache.maven.model.Developer +import org.apache.maven.model.License +import org.apache.maven.model.Model +import org.apache.maven.model.Scm import java.io.File import java.nio.file.Files import java.nio.file.Paths import java.nio.file.StandardCopyOption +import java.util.zip.ZipEntry +import java.util.zip.ZipOutputStream -val r = repos("http://dl.bintray.com/kotlin/kotlinx.dom") +val bs = buildScript { + repos("https://dl.bintray.com/cbeust/maven") +} -val wrapper = javaProject { +object Versions { + val kotlin = "1.2.71" + val okhttp = "3.9.1" + val okio = "1.13.0" + val retrofit = "2.3.0" + val gson = "2.8.2" + val guice = "4.2.2" + val maven = "3.5.2" + val mavenResolver = "1.1.0" + val slf4j = "1.7.3" + val aether = "1.0.2.v20150114" + val testng = "6.12" + val jcommander = "1.72" + + // JUnit 5 + val junit = "4.12" + val junitPlatform = "1.1.0" + val junitJupiter = "5.1.0" +} + +fun mavenResolver(vararg m: String) + = m.map { "org.apache.maven.resolver:maven-resolver-$it:${Versions.mavenResolver}" } + .toTypedArray() + +fun aether(vararg m: String) + = m.map { "org.eclipse.aether:aether-$it:${Versions.aether}" } + .toTypedArray() + +val wrapper = project { name = "kobalt-wrapper" + group = "com.beust" + artifactId = name version = readVersion() directory = "modules/wrapper" @@ -32,6 +64,7 @@ val wrapper = javaProject { } assemble { + jar { } jar { name = projectName + ".jar" manifest { @@ -43,41 +76,60 @@ val wrapper = javaProject { application { mainClass = "com.beust.kobalt.wrapper.Main" } + + bintray { + publish = true + sign = true + } + + pom = createPom(name, "Wrapper for Kobalt") } - -val kobaltPluginApi = kotlinProject { +val kobaltPluginApi = project { name = "kobalt-plugin-api" group = "com.beust" artifactId = name version = readVersion() directory = "modules/kobalt-plugin-api" description = "A build system in Kotlin" - url = "http://beust.com/kobalt" - licenses = arrayListOf(License("Apache 2.0", "http://www.apache.org/licenses/LICENSE-2.0")) - scm = Scm(url = "http://github.com/cbeust/kobalt", - connection = "https://github.com/cbeust/kobalt.git", - developerConnection = "git@github.com:cbeust/kobalt.git") + url = "https://beust.com/kobalt" - dependenciesTest { - compile("org.testng:testng:6.9.9") - } + pom = createPom(name, "A build system in Kotlin") dependencies { - compile("org.jetbrains.kotlinx:kotlinx.dom:0.0.4", - - "com.squareup.okhttp:okhttp:2.5.0", - "com.squareup.okio:okio:1.6.0", - "com.google.inject:guice:4.0", - "com.google.inject.extensions:guice-assistedinject:4.0", + compile( + "org.jetbrains.kotlin:kotlin-stdlib:${Versions.kotlin}", + "com.google.inject:guice:${Versions.guice}", + "com.google.inject.extensions:guice-assistedinject:4.1.0", "javax.inject:javax.inject:1", - "com.google.guava:guava:19.0-rc2", - "org.apache.maven:maven-model:3.3.3", - "io.reactivex:rxjava:1.0.16", - "com.google.code.gson:gson:2.4", - "com.squareup.retrofit:retrofit:1.9.0", - "com.beust:jcommander:1.48" - ) + "com.google.guava:guava:27.0.1-jre", + "org.apache.maven:maven-model:${Versions.maven}", + "io.reactivex:rxjava:1.3.3", + "com.squareup.okio:okio:${Versions.okio}", + "com.google.code.gson:gson:${Versions.gson}", + "com.squareup.okhttp3:okhttp:${Versions.okhttp}", + "com.squareup.retrofit2:retrofit:${Versions.retrofit}", + "com.squareup.retrofit2:converter-gson:${Versions.retrofit}", + "com.beust:jcommander:${Versions.jcommander}", + "org.eclipse.jgit:org.eclipse.jgit:4.9.0.201710071750-r", + "org.slf4j:slf4j-simple:${Versions.slf4j}", + *mavenResolver("api", "spi", "util", "impl", "connector-basic", "transport-http", "transport-file"), + "org.apache.maven:maven-aether-provider:3.3.9", + "org.testng.testng-remote:testng-remote:1.3.2", + "org.testng:testng:${Versions.testng}", + "org.junit.platform:junit-platform-surefire-provider:${Versions.junitPlatform}", + "org.junit.platform:junit-platform-runner:${Versions.junitPlatform}", + "org.junit.platform:junit-platform-engine:${Versions.junitPlatform}", + "org.junit.platform:junit-platform-console:${Versions.junitPlatform}", + "org.junit.jupiter:junit-jupiter-engine:${Versions.junitJupiter}", + "org.junit.vintage:junit-vintage-engine:${Versions.junitJupiter}", + "org.apache.commons:commons-compress:1.15", + "commons-io:commons-io:2.6", + + // Java 9 + "javax.xml.bind:jaxb-api:2.3.0" + ) + exclude(*aether("impl", "spi", "util", "api")) } @@ -90,24 +142,16 @@ val kobaltPluginApi = kotlinProject { } } -// install { -// libDir = "lib-test" -// } - - test { - args("-log", "1", "src/test/resources/testng.xml") - } - kotlinCompiler { - args("-nowarn") + args("nowarn") } - jcenter { + bintray { publish = true } } -val kobaltApp = kotlinProject(kobaltPluginApi, wrapper) { +val kobaltApp = project(kobaltPluginApi, wrapper) { name = "kobalt" group = "com.beust" artifactId = name @@ -115,25 +159,53 @@ val kobaltApp = kotlinProject(kobaltPluginApi, wrapper) { dependencies { // Used by the plugins - compile("com.android.tools.build:builder:2.0.0-alpha3", - "org.jetbrains.kotlin:kotlin-compiler-embeddable:1.0.0-beta-3595", - "org.jetbrains.dokka:dokka-fatjar:0.9.3") + compile("org.jetbrains.kotlin:kotlin-compiler-embeddable:${Versions.kotlin}") // Used by the main app - compile("com.github.spullara.mustache.java:compiler:0.9.1", - "com.squareup.okhttp:okhttp:2.5.0", + compile( + "org.jetbrains.kotlin:kotlin-stdlib:${Versions.kotlin}", + "com.github.spullara.mustache.java:compiler:0.9.5", "javax.inject:javax.inject:1", - "com.google.inject:guice:4.0", - "com.google.inject.extensions:guice-assistedinject:4.0", - "com.beust:jcommander:1.48", - "com.squareup.retrofit:retrofit:1.9.0", - "org.apache.maven:maven-model:3.3.3", - "org.codehaus.plexus:plexus-utils:3.0.22") + "com.google.inject:guice:${Versions.guice}", + "com.google.inject.extensions:guice-assistedinject:${Versions.guice}", + "com.beust:jcommander:${Versions.jcommander}", + "org.apache.maven:maven-model:${Versions.maven}", + "com.google.code.findbugs:jsr305:3.0.2", + "com.google.code.gson:gson:${Versions.gson}", + "com.squareup.retrofit2:retrofit:${Versions.retrofit}", + "com.squareup.retrofit2:converter-gson:${Versions.retrofit}", +// "com.squareup.okhttp3:okhttp-ws:3.4.2", + "biz.aQute.bnd:biz.aQute.bndlib:3.5.0", + *mavenResolver("spi"), + + "com.squareup.okhttp3:logging-interceptor:3.9.0", + + "com.sparkjava:spark-core:2.6.0", + "org.codehaus.groovy:groovy:2.4.12", + + // Java 9 + "javax.xml.bind:jaxb-api:2.3.0", + "com.sun.xml.bind:jaxb-impl:2.3.0", + "com.sun.xml.bind:jaxb-core:2.3.0", + "com.sun.activation:javax.activation:1.2.0" + +// "org.eclipse.jetty:jetty-server:${Versions.jetty}", +// "org.eclipse.jetty:jetty-servlet:${Versions.jetty}", +// "org.glassfish.jersey.core:jersey-server:${Versions.jersey}", +// "org.glassfish.jersey.containers:jersey-container-servlet-core:${Versions.jersey}", +// "org.glassfish.jersey.containers:jersey-container-jetty-http:${Versions.jersey}", +// "org.glassfish.jersey.media:jersey-media-moxy:${Versions.jersey}", +// "org.wasabi:wasabi:0.1.182" + ) } dependenciesTest { - compile("org.testng:testng:6.9.9") + compile("org.jetbrains.kotlin:kotlin-test:${Versions.kotlin}", + "org.testng:testng:${Versions.testng}", + "org.assertj:assertj-core:3.8.0", + *mavenResolver("util") + ) } assemble { @@ -144,47 +216,111 @@ val kobaltApp = kotlinProject(kobaltPluginApi, wrapper) { } } zip { - include("kobaltw") - include(from("$buildDirectory/libs"), to("kobalt/wrapper"), - "$projectName-$version.jar") - include(from("modules/wrapper/$buildDirectory/libs"), to("kobalt/wrapper"), - "$projectName-wrapper.jar") + val dir = "kobalt-$version" + val files = listOf( + "dist", "$dir/bin", "kobaltw", + "dist", "$dir/bin", "kobaltw.bat", + "$buildDirectory/libs", "$dir/kobalt/wrapper", "$projectName-$version.jar", + "modules/wrapper/$buildDirectory/libs", "$dir/kobalt/wrapper", "$projectName-wrapper.jar") + + (0 .. files.size - 1 step 3).forEach { i -> + include(from(files[i]), to(files[i + 1]), files[i + 2]) + } + + // Package the sources + val currentDir = Paths.get(".").toAbsolutePath().normalize().toString() + zipFolders("$currentDir/$buildDirectory/libs/all-sources/$projectName-$version-sources.jar", + "$currentDir/$directory/src/main/kotlin", + "$currentDir/${kobaltPluginApi.directory}/src/main/kotlin") + include(from("$buildDirectory/libs/all-sources"), to("$dir/kobalt/wrapper"), "$projectName-$version-sources.jar") } } kotlinCompiler { - args("-nowarn") + args("nowarn") } - jcenter { + bintray { publish = true } github { file("$buildDirectory/libs/$name-$version.zip", "$name/$version/$name-$version.zip") } + + test { + args("-log", "2", "src/test/resources/testng.xml") + } + + autoGitTag { + enabled = true + } +} + +fun zipFolders(zipFilePath: String, vararg foldersPath: String) { + val zip = Paths.get(zipFilePath) + Files.deleteIfExists(zip) + Files.createDirectories(zip.parent) + val zipPath = Files.createFile(zip) + ZipOutputStream(Files.newOutputStream(zipPath)).use { + foldersPath.map {Paths.get(it)}.forEach { folderPath -> + Files.walk(folderPath) + .filter { path -> !Files.isDirectory(path) } + .forEach { path -> + val zipEntry = ZipEntry(folderPath.relativize(path).toString()) + try { + it.putNextEntry(zipEntry) + Files.copy(path, it) + it.closeEntry() + } catch (e: Exception) { + } + } + } + } } fun readVersion() : String { - val p = java.util.Properties() - var localFile = java.io.File("src/main/resources/kobalt.properties") - if (! localFile.exists()) { - localFile = File(homeDir("kotlin", "kobalt", "src/main/resources/kobalt.properties")) + val localFile = + listOf("src/main/resources/kobalt.properties", + homeDir("kotlin", "kobalt", "src/main/resources/kobalt.properties")).first { File(it).exists() } + with(java.util.Properties()) { + load(java.io.FileReader(localFile)) + return getProperty("kobalt.version") } - p.load(java.io.FileReader(localFile)) - return p.getProperty("kobalt.version") } -@Task(name = "copyVersionForWrapper", runBefore = arrayOf("assemble"), runAfter = arrayOf("compile"), description = "") +@Task(name = "copyVersionForWrapper", reverseDependsOn = arrayOf("assemble"), runAfter = arrayOf("clean")) fun taskCopyVersionForWrapper(project: Project) : TaskResult { if (project.name == "kobalt-wrapper") { val toString = "modules/wrapper/kobaltBuild/classes" File(toString).mkdirs() val from = Paths.get("src/main/resources/kobalt.properties") val to = Paths.get("$toString/kobalt.properties") - Files.copy(from, - to, - StandardCopyOption.REPLACE_EXISTING) + // Only copy if necessary so we don't break incremental compilation + if (! to.toFile().exists() || (from.toFile().readLines() != to.toFile().readLines())) { + Files.copy(from, + to, + StandardCopyOption.REPLACE_EXISTING) + } } return TaskResult() } + +fun createPom(projectName: String, projectDescription: String) = Model().apply { + name = projectName + description = projectDescription + url = "https://beust.com/kobalt" + licenses = listOf(License().apply { + name = "Apache-2.0" + url = "https://www.apache.org/licenses/LICENSE-2.0" + }) + scm = Scm().apply { + url = "https://github.com/cbeust/kobalt" + connection = "https://github.com/cbeust/kobalt.git" + developerConnection = "git@github.com:cbeust/kobalt.git" + } + developers = listOf(Developer().apply { + name = "Cedric Beust" + email = "cedric@beust.com" + }) +} diff --git a/kobalt/wrapper/kobalt-wrapper.jar b/kobalt/wrapper/kobalt-wrapper.jar index 6a522ad5..848fb463 100644 Binary files a/kobalt/wrapper/kobalt-wrapper.jar and b/kobalt/wrapper/kobalt-wrapper.jar differ diff --git a/kobalt/wrapper/kobalt-wrapper.properties b/kobalt/wrapper/kobalt-wrapper.properties index 8785d764..0ca8045f 100644 --- a/kobalt/wrapper/kobalt-wrapper.properties +++ b/kobalt/wrapper/kobalt-wrapper.properties @@ -1 +1 @@ -kobalt.version=0.351 \ No newline at end of file +kobalt.version=1.0.122 \ No newline at end of file diff --git a/kobaltw b/kobaltw index 1fd228db..c5186d5a 100755 --- a/kobaltw +++ b/kobaltw @@ -1,2 +1,2 @@ -#!/usr/bin/env bash -java -jar $(dirname $0)/kobalt/wrapper/kobalt-wrapper.jar $* +#!/usr/bin/env sh +java -jar "`dirname "$0"`/kobalt/wrapper/kobalt-wrapper.jar" $* diff --git a/kobaltw-test b/kobaltw-test new file mode 100755 index 00000000..2693c3aa --- /dev/null +++ b/kobaltw-test @@ -0,0 +1,8 @@ +#!/usr/bin/env sh +JAR=$(ls -1 -t kobaltBuild/libs/*.jar | grep -Ev "(sources|javadoc)" | head -1) +TEMPDIR=$(mktemp -d) +cp -pf "$JAR" "$TEMPDIR" +TEMPJAR=$TEMPDIR/$(basename "$JAR") +export KOBALT_JAR=$TEMPJAR +java -jar "$TEMPJAR" "$@" +rm -rf "$TEMPDIR" \ No newline at end of file diff --git a/kobaltw.bat b/kobaltw.bat index 8caea129..2887a567 100644 --- a/kobaltw.bat +++ b/kobaltw.bat @@ -1,2 +1,4 @@ -@echo off -java -jar %~dp0/kobalt/wrapper/kobalt-wrapper.jar %* +@echo off +set DIRNAME=%~dp0 +if "%DIRNAME%" == "" set DIRNAME=. +java -jar "%DIRNAME%/kobalt/wrapper/kobalt-wrapper.jar" %* diff --git a/modules/kobalt-plugin-api/build.gradle b/modules/kobalt-plugin-api/build.gradle new file mode 100644 index 00000000..56085220 --- /dev/null +++ b/modules/kobalt-plugin-api/build.gradle @@ -0,0 +1,85 @@ +plugins { + id 'org.jetbrains.kotlin.jvm' version '1.2.71' + id 'com.github.johnrengelman.shadow' version '5.0.0' +} + +dependencies { + implementation "biz.aQute.bnd:biz.aQute.bndlib:$bndlib" + implementation "com.google.code.findbugs:jsr305:$findbugs" + implementation "com.sparkjava:spark-core:$spark" + implementation "com.squareup.okhttp3:logging-interceptor:$okhttp" + implementation 'commons-io:commons-io:2.6' + implementation 'io.reactivex:rxjava:1.3.3' + implementation "javax.inject:javax.inject:$inject" + implementation "javax.xml.bind:jaxb-api:$jaxb" + implementation 'org.apache.commons:commons-compress:1.15' + implementation 'org.apache.maven:maven-aether-provider:3.3.9' + implementation "org.apache.maven.resolver:maven-resolver-api:$mavenResolver" + implementation "org.apache.maven.resolver:maven-resolver-connector-basic:$mavenResolver" + implementation "org.apache.maven.resolver:maven-resolver-impl:$mavenResolver" + implementation "org.apache.maven.resolver:maven-resolver-spi:$mavenResolver" + implementation "org.apache.maven.resolver:maven-resolver-transport-file:$mavenResolver" + implementation "org.apache.maven.resolver:maven-resolver-transport-http:$mavenResolver" + implementation "org.apache.maven.resolver:maven-resolver-util:$mavenResolver" + implementation "org.codehaus.groovy:groovy:$groovy" + implementation 'org.eclipse.jgit:org.eclipse.jgit:4.9.0.201710071750-r' + implementation "org.junit.jupiter:junit-jupiter-engine:$junitJupiter" + implementation "org.junit.platform:junit-platform-console:$junitPlatform" + implementation "org.junit.platform:junit-platform-engine:$junitPlatform" + implementation "org.junit.platform:junit-platform-runner:$junitPlatform" + implementation "org.junit.platform:junit-platform-surefire-provider:$junitPlatform" + implementation "org.junit.vintage:junit-vintage-engine:$junitJupiter" + implementation "org.slf4j:slf4j-simple:$slf4j" + implementation "org.testng:testng:$testng" + implementation 'org.testng.testng-remote:testng-remote:1.3.2' + implementation "com.beust:jcommander:$jcommander" + implementation "com.google.code.gson:gson:$gson" + implementation "com.google.inject:guice:$guice" + implementation "com.google.inject.extensions:guice-assistedinject:$guice" + implementation "com.squareup.okio:okio:$okio" + implementation "com.squareup.retrofit2:converter-gson:$retrofit" + implementation "com.squareup.retrofit2:retrofit:$retrofit" + implementation "org.apache.maven:maven-model:$maven" + implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin" +} + +shadowJar { + classifier = null +} + +test { + useTestNG() +} + +publishing { + publications { + shadow(MavenPublication) { publication -> + project.shadow.component(publication) + artifact sourcesJar + artifact javadocJar + + pom { + name = project.name + description = 'A build system in Kotlin' + url = 'https://beust.com/kobalt' + licenses { + license { + name = 'Apache-2.0' + url = 'https://www.apache.org/licenses/LICENSE-2.0' + } + } + developers { + developer { + name = 'Cedric Beust' + email = 'cedric@beust.com' + } + } + scm { + connection = 'scm:https://github.com/cbeust/kobalt.git' + developerConnection = 'scm:git@github.com:cbeust/kobalt.git' + url = 'https://github.com/cbeust/kobalt' + } + } + } + } +} diff --git a/modules/kobalt-plugin-api/kobalt-plugin-api.iml b/modules/kobalt-plugin-api/kobalt-plugin-api.iml deleted file mode 100644 index 5562e359..00000000 --- a/modules/kobalt-plugin-api/kobalt-plugin-api.iml +++ /dev/null @@ -1,13 +0,0 @@ - - - - - - - - - - - - - \ No newline at end of file diff --git a/modules/kobalt-plugin-api/pom.xml b/modules/kobalt-plugin-api/pom.xml new file mode 100644 index 00000000..f9026387 --- /dev/null +++ b/modules/kobalt-plugin-api/pom.xml @@ -0,0 +1,279 @@ + + 4.0.0 + + com.beust + kobalt-pom + 1.1.0 + ../.. + + + kobalt-plugin-api + jar + 1.1.0 + + + + org.jetbrains.kotlin + kotlin-stdlib + ${kotlin.version} + + + org.apache.maven + maven-aether-provider + 3.3.9 + + + org.eclipse.aether + impl + + + org.eclipse.aether + spi + + + org.eclipse.aether + util + + + org.eclipse.aether + api + + + + + org.apache.maven.resolver + maven-resolver-api + ${mavenresolver.version} + + + org.apache.maven.resolver + maven-resolver-spi + ${mavenresolver.version} + + + org.apache.maven.resolver + maven-resolver-util + ${mavenresolver.version} + + + org.apache.maven.resolver + maven-resolver-impl + ${mavenresolver.version} + + + org.apache.maven.resolver + maven-resolver-connector-basic + ${mavenresolver.version} + + + org.apache.maven.resolver + maven-resolver-transport-http + ${mavenresolver.version} + + + org.apache.maven.resolver + maven-resolver-transport-file + ${mavenresolver.version} + + + io.reactivex + rxjava + 1.3.3 + + + com.squareup.okio + okio + ${okio.version} + + + javax.inject + javax.inject + 1 + compile + + + com.google.inject + guice + 4.2.2 + + + com.google.inject.extensions + guice-assistedinject + 4.2.2 + + + com.beust + jcommander + 1.72 + + + org.apache.maven + maven-model + 3.5.2 + + + com.google.code.findbugs + jsr305 + 3.0.2 + + + com.google.code.gson + gson + 2.8.2 + + + com.squareup.retrofit2 + retrofit + 2.3.0 + + + com.squareup.retrofit2 + converter-gson + 2.3.0 + + + biz.aQute.bnd + biz.aQute.bndlib + 3.5.0 + + + com.squareup.okhttp3 + logging-interceptor + ${okhttp3.version} + + + com.sparkjava + spark-core + 2.6.0 + + + org.codehaus.groovy + groovy + 2.4.12 + + + org.apache.commons + commons-compress + 1.15 + + + commons-io + commons-io + 2.6 + + + org.junit.platform + junit-platform-surefire-provider + ${junit.version} + + + org.junit.platform + junit-platform-runner + ${junit.version} + + + org.junit.platform + junit-platform-engine + ${junit.version} + + + org.junit.platform + junit-platform-console + ${junit.version} + + + org.junit.jupiter + junit-jupiter-engine + ${junitJupiter.version} + + + org.junit.vintage + junit-vintage-engine + ${junitJupiter.version} + + + org.testng.testng-remote + testng-remote + 1.3.2 + + + org.testng + testng + ${testng.version} + + + org.eclipse.jgit + org.eclipse.jgit + 4.9.0.201710071750-r + + + org.slf4j + slf4j-simple + ${slf4j.version} + + + + javax.xml.bind + jaxb-api + 2.3.0 + + + + + + + org.jetbrains.kotlin + kotlin-maven-plugin + ${kotlin.version} + + + compile + compile + + + ${project.basedir}/src/main/kotlin + + + + + test-compile + test-compile + + + ${project.basedir}/src/test/kotlin + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + 3.5.1 + + + + default-compile + none + + + + default-testCompile + none + + + java-compile + compile + compile + + + java-test-compile + test-compile + testCompile + + + + + + \ No newline at end of file diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/ArchiveGenerator.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/ArchiveGenerator.kt new file mode 100644 index 00000000..8158c642 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/ArchiveGenerator.kt @@ -0,0 +1,21 @@ +package com.beust.kobalt + +import com.beust.kobalt.api.KobaltContext +import com.beust.kobalt.api.Project +import com.beust.kobalt.archive.Zip +import com.beust.kobalt.misc.KFiles +import java.io.File + +interface ArchiveGenerator { + fun findIncludedFiles(project: Project, context: KobaltContext, zip: Zip) : List + val suffix: String + fun generateArchive(project: Project, context: KobaltContext, zip: Zip, files: List) : File + + fun fullArchiveName(project: Project, context: KobaltContext, archiveName: String?) : File { + val fullArchiveName = context.variant.archiveName(project, archiveName, suffix) + val archiveDir = File(KFiles.libsDir(project)) + val result = File(archiveDir.path, fullArchiveName) + return result + } + +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Args.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Args.kt index bf1b44e8..372f1ba1 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Args.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Args.kt @@ -7,7 +7,7 @@ class Args { var targets: List = arrayListOf() @Parameter(names = arrayOf("-bf", "--buildFile"), description = "The build file") - var buildFile: String? = null + var buildFile: String? = "kobalt/src/Build.kt" @Parameter(names = arrayOf("--checkVersions"), description = "Check if there are any newer versions of the " + "dependencies") @@ -16,38 +16,86 @@ class Args { @Parameter(names = arrayOf("--client")) var client: Boolean = false - @Parameter(names = arrayOf("--dev"), description = "Turn of dev mode, resulting in a more verbose log output") + @Parameter(names = arrayOf("--dev"), description = "Turn on dev mode, resulting in a more verbose log output") var dev: Boolean = false @Parameter(names = arrayOf("--download"), description = "Force a download from the downloadUrl in the wrapper") var download: Boolean = false + @Parameter(names = arrayOf("--downloadSources"), + description = "Force a download of sources and javadocs when resolving dependencies") + var downloadSources: Boolean = false + @Parameter(names = arrayOf("--dryRun"), description = "Display all the tasks that will get run without " + "actually running them") var dryRun: Boolean = false + @Parameter(names = arrayOf("--force"), description = "Force a new server to be launched even if another one" + + " is already running") + var force: Boolean = false + + @Parameter(names = arrayOf("--gc"), description = "Delete old files") + var gc: Boolean = false + @Parameter(names = arrayOf("--help", "--usage"), description = "Display the help") var usage: Boolean = false - @Parameter(names = arrayOf("-i", "--init"), description = "Create a build file based on the current project") - var init: Boolean = false + @Parameter(names = arrayOf("-i", "--init"), description = "Invoke the templates named, separated by a comma") + var templates: String? = null - @Parameter(names = arrayOf("--log"), description = "Define the log level (1-3)") - var log: Int = 1 + @Parameter(names = arrayOf("--listTemplates"), description = "List the available templates") + var listTemplates: Boolean = false - companion object { - const val DEFAULT_SERVER_PORT = 1234 - } + @Parameter(names = arrayOf("--log"), description = "Define the log level " + + "(${Constants.LOG_QUIET_LEVEL}-${Constants.LOG_MAX_LEVEL})") + var log: Int = Constants.LOG_DEFAULT_LEVEL + + @Parameter(names = arrayOf("--logTags"), + description = "Comma-separated list of tags to enable logging for") + var logTags: String = "" + + @Parameter(names = arrayOf("--forceIncremental"), + description = "Force the build to be incremental even if the build file was modified") + var forceIncremental: Boolean = false + + @Parameter(names = arrayOf("--noIncremental"), description = "Turn off incremental builds") + var noIncremental: Boolean = false + + @Parameter(names = arrayOf("--offline"), description = "Don't try to download dependencies even if there is no cached version") + var offline: Boolean = false + + @Parameter(names = arrayOf("--plugins"), description = "Comma-separated list of plug-in Maven id's") + var pluginIds: String? = null + + @Parameter(names = arrayOf("--pluginJarFiles"), description = "Comma-separated list of plug-in jar files") + var pluginJarFiles: String? = null @Parameter(names = arrayOf("--port"), description = "Port, if --server was specified") - var port: Int = DEFAULT_SERVER_PORT + var port: Int? = null @Parameter(names = arrayOf("--profiles"), description = "Comma-separated list of profiles to run") var profiles: String? = null - @Parameter(names = arrayOf("--resolve"), description = "Resolve the given dependency and display its tree") + @Parameter(names = arrayOf("--profiling"), description = "Display task timings at the end of the build") + var profiling: Boolean = false + + @Parameter(names = arrayOf("--resolve"), + description = "Resolve the given dependency and display its tree") var dependency: String? = null + @Parameter(names = arrayOf("--projectInfo"), description = "Display information about the current projects") + var projectInfo: Boolean = false + + @Parameter(names = arrayOf("--noIncrementalKotlin"), description = "Disable incremental Kotlin compilation") + var noIncrementalKotlin: Boolean = false + + companion object { + const val SEQUENTIAL = "--sequential" + } + + @Parameter(names = arrayOf(Args.SEQUENTIAL), description = "Build all the projects in sequence") + var sequential: Boolean = false + @Parameter(names = arrayOf("--server"), description = "Run in server mode") var serverMode: Boolean = false @@ -56,5 +104,8 @@ class Args { @Parameter(names = arrayOf("--update"), description = "Update to the latest version of Kobalt") var update: Boolean = false + + @Parameter(names = arrayOf("--version"), description = "Display the current version of Kobalt") + var version: Boolean = false } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/AsciiArt.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/AsciiArt.kt index de16f9d7..e138fabc 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/AsciiArt.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/AsciiArt.kt @@ -1,23 +1,32 @@ package com.beust.kobalt -import com.beust.kobalt.misc.log import java.util.* - +/** + * Make Kobalt's output awesome and unique. + * + * I spend so much time staring at build outputs I decided I might as well make them pretty. + * Note that I also experimented with colors but it's hard to come up with a color scheme that + * will work with all the various backgrounds developers use, so I decided to be conservative + * and stick to simple red/yellow for errors and warnings. + * + * @author Cedric Beust + * @since 10/1/2015 + */ class AsciiArt { companion object { private val BANNERS = arrayOf( " __ __ __ __ __ \n" + - " / //_/ ____ / /_ ____ _ / / / /_\n" + - " / ,< / __ \\ / __ \\ / __ `/ / / / __/\n" + - " / /| | / /_/ / / /_/ // /_/ / / / / /_ \n" + - " /_/ |_| \\____/ /_.___/ \\__,_/ /_/ \\__/ ", + " / //_/ ____ / /_ ____ _ / / / /_\n" + + " / ,< / __ \\ / __ \\ / __ `/ / / / __/\n" + + " / /| | / /_/ / / /_/ // /_/ / / / / /_ \n" + + " /_/ |_| \\____/ /_.___/ \\__,_/ /_/ \\__/ ", " _ __ _ _ _ \n" + - " | |/ / ___ | |__ __ _ | | | |_ \n" + - " | ' / / _ \\ | '_ \\ / _` | | | | __|\n" + - " | . \\ | (_) | | |_) | | (_| | | | | |_ \n" + - " |_|\\_\\ \\___/ |_.__/ \\__,_| |_| \\__| " + " | |/ / ___ | |__ __ _ | | | |_ \n" + + " | ' / / _ \\ | '_ \\ / _` | | | | __|\n" + + " | . \\ | (_) | | |_) | | (_| | | | | |_ \n" + + " |_|\\_\\ \\___/ |_.__/ \\__,_| |_| \\__| " ) val banner : String get() = BANNERS[Random().nextInt(BANNERS.size)] @@ -26,47 +35,59 @@ class AsciiArt { val horizontalSingleLine = "\u2500\u2500\u2500\u2500\u2500" val horizontalDoubleLine = "\u2550\u2550\u2550\u2550\u2550" + val verticalBar = "\u2551" // fun horizontalLine(n: Int) = StringBuffer().apply { // repeat(n, { append("\u2500") }) // }.toString() - fun box(strings: List) : List { - val ul = "\u2554" - val ur = "\u2557" - val h = "\u2550" - val v = "\u2551" - val bl = "\u255a" - val br = "\u255d" - - fun r(n: Int, w: String) : String { - with(StringBuffer()) { - repeat(n, { append(w) }) - return toString() - } + // Repeat + fun r(n: Int, w: String) : String { + with(StringBuffer()) { + repeat(n, { append(w) }) + return toString() } + } + + val h = "\u2550" + val ul = "\u2554" + val ur = "\u2557" + val bottomLeft = "\u255a" + val bottomRight = "\u255d" + + // Bottom left with continuation + val bottomLeft2 = "\u2560" + // Bottom right with continuation + val bottomRight2 = "\u2563" + + fun upperBox(max: Int) = ul + r(max + 2, h) + ur + fun lowerBox(max: Int, bl: String = bottomLeft, br : String = bottomRight) = bl + r(max + 2, h) + br + + private fun box(strings: List, bl: String = bottomLeft, br: String = bottomRight) : List { + val v = verticalBar val maxString: String = strings.maxBy { it.length } ?: "" val max = maxString.length - val result = arrayListOf(ul + r(max + 2, h) + ur) + val result = arrayListOf(upperBox(max)) result.addAll(strings.map { "$v ${center(it, max - 2)} $v" }) - result.add(bl + r(max + 2, h) + br) + result.add(lowerBox(max, bl, br)) return result } - private fun fill(n: Int) = StringBuffer().apply { repeat(n, { append(" ")})}.toString() - - val defaultLog : (s: String) -> Unit = { log(1, " $it") } - - fun logBox(strings: List, print: (String) -> Unit = defaultLog) { - box(strings).forEach { - print(it) + fun logBox(strings: List, bl: String = bottomLeft, br: String = bottomRight, indent: Int = 0): String { + return buildString { + val boxLines = box(strings, bl, br) + boxLines.withIndex().forEach { iv -> + append(fill(indent)).append(iv.value) + if (iv.index < boxLines.size - 1) append("\n") + } } } - fun logBox(s: String, print: (String) -> Unit = defaultLog) { - logBox(listOf(s), print) - } + fun logBox(s: String, bl: String = bottomLeft, br: String = bottomRight, indent: Int = 0) + = logBox(listOf(s), bl, br, indent) + + fun fill(n: Int) = buildString { repeat(n, { append(" ")})}.toString() fun center(s: String, width: Int) : String { val diff = width - s.length @@ -84,14 +105,60 @@ class AsciiArt { const val CYAN = "\u001B[36m" const val WHITE = "\u001B[37m" - private fun wrap(s: String, color: String) = color + s + RESET - private fun blue(s: String) = wrap(s, BLUE) - private fun red(s: String) = wrap(s, RED) - private fun yellow(s: String) = wrap(s, YELLOW) + fun wrap(s: CharSequence, color: String) = color + s + RESET + private fun blue(s: CharSequence) = wrap(s, BLUE) + private fun red(s: CharSequence) = wrap(s, RED) + private fun yellow(s: CharSequence) = wrap(s, YELLOW) - fun taskColor(s: String) = s - fun errorColor(s: String) = red(s) - fun warnColor(s: String) = red(s) + fun taskColor(s: CharSequence) = s + fun errorColor(s: CharSequence) = red(s) + fun warnColor(s: CharSequence) = red(s) } } +class AsciiTable { + class Builder { + private val headers = arrayListOf() + fun header(name: String) = headers.add(name) + fun headers(vararg names: String) = headers.addAll(names) + + private val widths = arrayListOf() + fun columnWidth(w: Int) : Builder { + widths.add(w) + return this + } + + private val rows = arrayListOf>() + fun addRow(row: List) = rows.add(row) + + private fun col(width: Int, s: String) : String { + val format = " %1\$-${width.toString()}s" + val result = String.format(format, s) + return result + } + + val vb = AsciiArt.verticalBar + + fun build() : String { + val formattedHeaders = + headers.mapIndexed { index, s -> + val s2 = col(widths[index], s) + s2 + }.joinToString(vb) + val result = StringBuffer().apply { + append(AsciiArt.logBox(formattedHeaders, AsciiArt.bottomLeft2, AsciiArt.bottomRight2)) + append("\n") + } + var lineLength = 0 + rows.forEachIndexed { _, row -> + val formattedRow = row.mapIndexed { i, s -> col(widths[i], s) }.joinToString(vb) + val line = "$vb $formattedRow $vb" + result.append(line).append("\n") + lineLength = line.length + } + result.append(AsciiArt.lowerBox(lineLength - 4)) + return result.toString() + } + + } +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/BasePluginTask.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/BasePluginTask.kt index 855d4271..e55f1b2a 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/BasePluginTask.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/BasePluginTask.kt @@ -4,8 +4,9 @@ import com.beust.kobalt.api.IPlugin import com.beust.kobalt.api.PluginTask import com.beust.kobalt.api.Project -public abstract class BasePluginTask(override val plugin: IPlugin, +abstract class BasePluginTask(override val plugin: IPlugin, override val name: String, override val doc: String, + override val group: String, override val project: Project) : PluginTask() diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/BuildScript.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/BuildScript.kt index c3c8981c..4c35b9ed 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/BuildScript.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/BuildScript.kt @@ -3,34 +3,89 @@ package com.beust.kobalt import com.beust.kobalt.api.IClasspathDependency import com.beust.kobalt.api.Kobalt import com.beust.kobalt.api.annotation.Directive -import com.beust.kobalt.maven.DepFactory +import com.beust.kobalt.internal.KobaltSettings +import com.beust.kobalt.internal.PluginInfo +import com.beust.kobalt.maven.DependencyManager import com.beust.kobalt.maven.dependency.FileDependency +import com.beust.kobalt.misc.KobaltLogger +import org.eclipse.aether.repository.Proxy import java.io.File +import java.net.InetSocketAddress + +var BUILD_SCRIPT_CONFIG : BuildScriptConfig? = null + +class BuildScriptConfig { + /** The list of repos used to locate plug-ins. */ + @Directive + fun repos(vararg r: String) = newRepos(*r) + + /** The list of plug-ins to use for this build file. */ + @Directive + fun plugins(vararg pl: String) = newPlugins(*pl) + + /** The build file classpath. */ + @Directive + fun buildFileClasspath(vararg bfc: String) = newBuildFileClasspath(*bfc) + + /** Options passed to Kobalt */ + @Directive + fun kobaltOptions(vararg options: String) = Kobalt.addKobaltOptions(options) + + /** Where to find additional build files */ + @Directive + fun buildSourceDirs(vararg dirs: String) = Kobalt.addBuildSourceDirs(dirs) + + // The following settings modify the compiler used to compile the build file, which regular users should + // probably never need to do. Projects should use kotlinCompiler { compilerVersion } to configure the + // Kotin compiler for their source files. + var kobaltCompilerVersion : String? = null + var kobaltCompilerRepo: String? = null + var kobaltCompilerFlags: String? = null +} @Directive fun homeDir(vararg dirs: String) : String = SystemProperties.homeDir + - File.separator + dirs.toArrayList().joinToString(File.separator) - -@Directive -fun localMavenRepo() = homeDir(".m2" + File.separator + "repository/") + File.separator + dirs.toMutableList().joinToString(File.separator) @Directive fun file(file: String) : String = FileDependency.PREFIX_FILE + file -@Directive fun plugins(vararg dependency : IClasspathDependency) { dependency.forEach { Plugins.addDynamicPlugin(it) } } -@Directive fun plugins(vararg dependencies : String) { - val factory = Kobalt.INJECTOR.getInstance(DepFactory::class.java) + KobaltLogger.logger.warn("Build.kt", + "Invoking plugins() directly is deprecated, use the buildScript{} directive") + newPlugins(*dependencies) +} + +@Directive +fun newPlugins(vararg dependencies : String) { + val factory = Kobalt.INJECTOR.getInstance(DependencyManager::class.java) dependencies.forEach { Plugins.addDynamicPlugin(factory.create(it)) } } -data class HostConfig(var url: String = "", var username: String? = null, var password: String? = null) { +data class ProxyConfig(val host: String = "", val port: Int = 0, val type: String = "", val nonProxyHosts: String = "") { + fun toProxy() = java.net.Proxy(java.net.Proxy.Type.HTTP, InetSocketAddress(host, port)) + + fun toAetherProxy() = Proxy(type, host, port) // TODO make support for proxy auth +} + +data class HostConfig(var url: String = "", var name: String = HostConfig.createRepoName(url), + var username: String? = null, var password: String? = null) { + + companion object { + /** + * For repos specified in the build file (repos()) that don't have an associated unique name, + * create such a name from the URL. This is a requirement from Maven Resolver, and failing to do + * this leads to very weird resolution errors. + */ + private fun createRepoName(url: String) = url.replace("/", "_").replace("\\", "_").replace(":", "_") + } + fun hasAuth() : Boolean { return (! username.isNullOrBlank()) && (! password.isNullOrBlank()) } @@ -44,18 +99,47 @@ data class HostConfig(var url: String = "", var username: String? = null, var pa } } -@Directive fun repos(vararg repos : String) { + KobaltLogger.logger.warn("Build.kt", + "Invoking repos() directly is deprecated, use the buildScript{} directive") + newRepos(*repos) +} + +fun newRepos(vararg repos: String) { repos.forEach { Kobalt.addRepo(HostConfig(it)) } } +fun buildFileClasspath(vararg deps: String) { + KobaltLogger.logger.warn("Build.kt", + "Invoking buildFileClasspath() directly is deprecated, use the buildScript{} directive") + newBuildFileClasspath(*deps) +} + +fun newBuildFileClasspath(vararg deps: String) { + //FIXME newBuildFileClasspath called twice + deps.forEach { Kobalt.addBuildFileClasspath(it) } +} + @Directive fun authRepos(vararg repos : HostConfig) { repos.forEach { Kobalt.addRepo(it) } } @Directive -fun authRepo(init: HostConfig.() -> Unit) = HostConfig().apply { init() } +fun authRepo(init: HostConfig.() -> Unit) = HostConfig(name = "").apply { init() } @Directive -fun glob(g: String) : IFileSpec.Glob = IFileSpec.Glob(g) +fun glob(g: String) : IFileSpec.GlobSpec = IFileSpec.GlobSpec(g) + +/** + * The location of the local Maven repository. + */ +@Directive +fun localMaven() : String { + val pluginInfo = Kobalt.INJECTOR.getInstance(PluginInfo::class.java) + val initial = Kobalt.INJECTOR.getInstance(KobaltSettings::class.java).localMavenRepo + val result = pluginInfo.localMavenRepoPathInterceptors.fold(initial) { current, interceptor -> + File(interceptor.repoPath(current.absolutePath)) + } + return result.toURI().toString() +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Constants.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Constants.kt index 773c1097..8eb73c84 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Constants.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Constants.kt @@ -1,14 +1,25 @@ package com.beust.kobalt +import com.beust.kobalt.misc.KFiles + object Constants { + const val LOG_QUIET_LEVEL = 0 + const val LOG_DEFAULT_LEVEL = 1 + const val LOG_MAX_LEVEL = 3 val BUILD_FILE_NAME = "Build.kt" val BUILD_FILE_DIRECTORY = "kobalt/src" + val BUILD_FILE_PATH = KFiles.joinDir(BUILD_FILE_DIRECTORY, BUILD_FILE_NAME) + val KOTLIN_COMPILER_VERSION = "1.2.70" - internal val DEFAULT_REPOS = listOf( - "http://repo1.maven.org/maven2/", - "https://maven-central.storage.googleapis.com/", - "https://repository.jboss.org/nexus/content/repositories/root_repository/", - "https://jcenter.bintray.com/" + internal val DEFAULT_REPOS = listOf( + // "https://maven-central.storage.googleapis.com/", + HostConfig("https://repo1.maven.org/maven2/", "Maven"), + HostConfig("https://jcenter.bintray.com/", "JCenter") +// "https://repository.jetbrains.com/all/", // <-- contains snapshots + + // snapshots +// "https://oss.sonatype.org/content/repositories/snapshots/" +// , "https://repository.jboss.org/nexus/content/repositories/root_repository/" ) } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Directives.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Directives.kt new file mode 100644 index 00000000..93d9434c --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Directives.kt @@ -0,0 +1,39 @@ +package com.beust.kobalt + +import com.beust.kobalt.api.Kobalt +import com.beust.kobalt.api.Project +import com.beust.kobalt.api.annotation.Directive +import com.beust.kobalt.internal.JvmCompilerPlugin +import kotlin.properties.ReadWriteProperty +import kotlin.reflect.KProperty + +@Directive +fun project(vararg projects: Project, init: Project.() -> Unit): Project { + return Project("").apply { + init() + (Kobalt.findPlugin(JvmCompilerPlugin.PLUGIN_NAME) as JvmCompilerPlugin) + .addDependentProjects(this, projects.toList()) + } +} + +@Directive +fun buildScript(init: BuildScriptConfig.() -> Unit): BuildScriptConfig { + val buildScriptConfig = BuildScriptConfig().apply { init() } + BUILD_SCRIPT_CONFIG = buildScriptConfig + return buildScriptConfig +} + +@Directive +fun profile(): ReadWriteProperty { + val result = object: ReadWriteProperty { + var value: Boolean = false + override operator fun getValue(thisRef: Nothing?, property: KProperty<*>): Boolean { + return value + } + + override operator fun setValue(thisRef: Nothing?, property: KProperty<*>, value: Boolean) { + this.value = value + } + } + return result +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/FileSpec.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/FileSpec.kt index 28e4ea00..1eb409f4 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/FileSpec.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/FileSpec.kt @@ -1,38 +1,102 @@ package com.beust.kobalt -import com.beust.kobalt.misc.log +import com.beust.kobalt.misc.kobaltLog import java.io.File import java.nio.file.* import java.nio.file.attribute.BasicFileAttributes +/** + * Subclasses of IFileSpec can be turned into a list of files. There are two kings: FileSpec (a single file) + * and GlobSpec (a spec defined by a glob, e.g. ** slash *Test.class) + */ sealed class IFileSpec { - abstract fun toFiles(directory: String): List + abstract fun toFiles(baseDir: String?, filePath: String, excludes: List = emptyList()): List class FileSpec(val spec: String) : IFileSpec() { - override public fun toFiles(directory: String) = arrayListOf(File(spec)) + override fun toFiles(baseDir: String?, filePath: String, excludes: List) = listOf(File(spec)) - override public fun toString() = spec + override fun toString() = spec } - class Glob(val spec: String) : IFileSpec() { - override public fun toFiles(directory: String): List { - val result = arrayListOf() + /** + * A glob matcher, see http://docs.oracle.com/javase/7/docs/api/java/nio/file/FileSystem.html#getPathMatcher%28java.lang.String%29 + */ + class GlobSpec(val spec: List) : IFileSpec() { - val matcher = FileSystems.getDefault().getPathMatcher("glob:${spec}") - Files.walkFileTree(Paths.get(directory), object : SimpleFileVisitor() { - override public fun visitFile(path: Path, attrs: BasicFileAttributes): FileVisitResult { - val rel = Paths.get(directory).relativize(path) - if (matcher.matches(rel)) { - log(3, "Adding ${rel.toFile()}") - result.add(rel.toFile()) - } - return FileVisitResult.CONTINUE + constructor(spec: String) : this(arrayListOf(spec)) + + private fun isIncluded(includeMatchers: Glob, excludes: List, rel: Path) : Boolean { + excludes.forEach { + if (it.matches(rel)) { + kobaltLog(3, " Excluding ${rel.toFile()}") + return false } - }) + } + if (includeMatchers.matches(rel)) { + kobaltLog(3, " Including ${rel.toFile().path}") + return true + } + kobaltLog(2, " Excluding ${rel.toFile()} (not matching any include pattern") + return false + } + + override fun toFiles(baseDir: String?, filePath: String, excludes: List): List { + val result = arrayListOf() + val includes = Glob(*spec.toTypedArray()) + + if (File(baseDir, filePath).isDirectory) { + val orgRootDir = (if (File(filePath).isAbsolute) Paths.get(filePath) + else if (baseDir != null) Paths.get(baseDir, filePath) + else Paths.get(filePath)).run { normalize() } + // Paths.get(".").normalize() returns an empty string, which is not a valid file :-( + val rootDir = if (orgRootDir.toFile().path.isEmpty()) Paths.get("./") else orgRootDir + if (rootDir.toFile().exists()) { + Files.walkFileTree(rootDir, object : SimpleFileVisitor() { + override fun visitFile(p: Path, attrs: BasicFileAttributes): FileVisitResult { + val path = p.normalize() + val rel = orgRootDir.relativize(path) + if (isIncluded(includes, excludes, path)) { + kobaltLog(3, " including file " + rel.toFile() + " from rootDir $rootDir") + result.add(rel.toFile()) + } + return FileVisitResult.CONTINUE + } + }) + } else { + throw AssertionError("Directory \"$rootDir\" should exist") + } + } else { + if (isIncluded(includes, excludes, Paths.get(filePath))) { + result.add(File(filePath)) + } + } + return result } - override public fun toString() = spec + override fun toString(): String { + var result = "" + spec.apply { + if (!isEmpty()) { + result += "Included files: " + joinToString { ", " } + } + } + return result + } } } + +/** + * A Glob is a simple file name matcher. + */ +class Glob(vararg specs: String) { + val matchers = prepareMatchers(specs.toList()) + + private fun prepareMatchers(specs: List): List = + specs.map { it -> FileSystems.getDefault().getPathMatcher("glob:$it") } + + fun matches(s: String) = matches(Paths.get(s)) + + fun matches(path: Path) = matchers.any { it.matches(path) } +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/IncludeFromTo.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/IncludeFromTo.kt new file mode 100644 index 00000000..ea189851 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/IncludeFromTo.kt @@ -0,0 +1,43 @@ +package com.beust.kobalt + +import com.beust.kobalt.api.annotation.Directive +import java.io.File + +/** + * Base classes for directives that support install(from,to) (e.g. install{} or jar{}). + */ +open class IncludeFromTo { + /** + * Prefix path to be removed from the zip file. For example, if you add "build/lib/a.jar" to the zip + * file and the excludePrefix is "build/lib", then "a.jar" will be added at the root of the zip file. + */ + val includedFiles = arrayListOf() + + @Directive + fun from(s: String) = From(s) + + @Directive + fun to(s: String) = To(s) + + @Directive + fun copy(from: From, to: To) { + val dir = File(from.path).absoluteFile.parentFile + includedFiles.add(IncludedFile(from(dir.absolutePath), to, listOf(IFileSpec.FileSpec(from.path)))) + } + + @Directive + fun include(vararg files: String) { + includedFiles.add(IncludedFile(files.map { IFileSpec.FileSpec(it) })) + } + + @Directive + fun include(from: From, to: To, vararg specs: String) { + includedFiles.add(IncludedFile(from, to, specs.map { IFileSpec.FileSpec(it) })) + } + + @Directive + fun include(from: From, to: To, vararg specs: IFileSpec.GlobSpec) { + includedFiles.add(IncludedFile(from, to, listOf(*specs))) + } +} + diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/IncludedFile.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/IncludedFile.kt new file mode 100644 index 00000000..46dea15e --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/IncludedFile.kt @@ -0,0 +1,44 @@ +package com.beust.kobalt + +import com.beust.kobalt.misc.KFiles +import com.beust.kobalt.misc.toString +import java.io.File +import java.nio.file.Paths + +class IncludedFile(val fromOriginal: From, val toOriginal: To, val specs: List, + val expandJarFiles: Boolean = false) { + constructor(specs: List, expandJarFiles: Boolean = false) : this(From(""), To(""), specs, expandJarFiles) + fun from(s: String) = File(if (fromOriginal.isCurrentDir()) s else KFiles.joinDir(from, s)) + val from: String get() = fromOriginal.path.replace("\\", "/") + fun to(s: String) = File(if (toOriginal.isCurrentDir()) s else KFiles.joinDir(to, s)) + val to: String get() = toOriginal.path.replace("\\", "/") + override fun toString() = toString("IncludedFile", + "files - ", specs.map { it.toString() }, + "from", from, + "to", to) + + fun allFromFiles(directory: String? = null): List { + val result = arrayListOf() + specs.forEach { spec -> +// val fullDir = if (directory == null) from else KFiles.joinDir(directory, from) + spec.toFiles(directory, from).forEach { source -> + result.add(if (source.isAbsolute) source else File(source.path)) + } + } + return result.map { Paths.get(it.path).normalize().toFile()} + } +} + +open class Direction(open val p: String) { + override fun toString() = path + fun isCurrentDir() = path == "./" + + val path: String get() = + if (p.isEmpty()) "./" + else if (p.startsWith("/") || p.endsWith("/")) p + else p + "/" +} + +class From(override val p: String) : Direction(p) + +class To(override val p: String) : Direction(p) diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/IncrementalTaskInfo.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/IncrementalTaskInfo.kt index 6e07fa49..b1c56e5a 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/IncrementalTaskInfo.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/IncrementalTaskInfo.kt @@ -1,13 +1,17 @@ package com.beust.kobalt +import com.beust.kobalt.api.KobaltContext import com.beust.kobalt.api.Project /** - * @param inputChecksum The checksum for the input to this task. It gets compared against the checksum of - * if they differ, the task gets run. If they are equal, outputChecksums are then compared. + * @param inputChecksum The checksum for the input to this task. It gets compared against the previous checksum + * calculated by Kobalt. If they differ, the task gets run. If they are equal, outputChecksums are then compared. * @param outputChecksum The checksum for the output of this task. If null, the output is absent * and the task will be run. If non null, it gets compared against the checksum of the previous run and * if they differ, the task gets run. * @param task The task to run. */ -class IncrementalTaskInfo(val inputChecksum: String, val outputChecksum: String?, val task: (Project) -> TaskResult) +class IncrementalTaskInfo(val inputChecksum: () -> String?, + val outputChecksum: () -> String?, + val task: (Project) -> TaskResult, + val context: KobaltContext) diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/JarGenerator.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/JarGenerator.kt new file mode 100644 index 00000000..19bb52c6 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/JarGenerator.kt @@ -0,0 +1,162 @@ +package com.beust.kobalt + +import com.beust.kobalt.api.KobaltContext +import com.beust.kobalt.api.Project +import com.beust.kobalt.archive.Archives +import com.beust.kobalt.archive.MetaArchive +import com.beust.kobalt.archive.Zip +import com.beust.kobalt.maven.DependencyManager +import com.beust.kobalt.maven.aether.Scope +import com.beust.kobalt.misc.KFiles +import com.beust.kobalt.misc.kobaltLog +import com.google.inject.Inject +import java.io.File +import java.io.FileInputStream +import java.nio.file.Paths +import java.util.jar.Manifest + +class JarGenerator @Inject constructor(val dependencyManager: DependencyManager) : ArchiveGenerator { + companion object { + fun findIncludedFiles(directory: String, files: List, excludes: List, + throwOnError: Boolean = true) + : List { + val result = arrayListOf() + files.forEach { includedFile -> + val includedSpecs = arrayListOf() + includedFile.specs.forEach { spec -> + val fromPath = includedFile.from + if (File(directory, fromPath).exists()) { + spec.toFiles(directory, fromPath).forEach { file -> + val fullFile = File(KFiles.joinDir(directory, fromPath, file.path)) + if (! fullFile.exists() && throwOnError) { + throw AssertionError("File should exist: $fullFile") + } + + if (!KFiles.isExcluded(fullFile, excludes)) { + val normalized = Paths.get(file.path).normalize().toFile().path + includedSpecs.add(IFileSpec.FileSpec(normalized)) + } else { + kobaltLog(2, "Not adding ${file.path} to jar file because it's excluded") + } + + } + } else { + kobaltLog(2, " Directory $fromPath doesn't exist, not including it in the jar") + } + } + if (includedSpecs.size > 0) { + kobaltLog(3, "Including specs $includedSpecs") + result.add(IncludedFile(From(includedFile.from), To(includedFile.to), includedSpecs)) + } + } + return result + } + } + + override val suffix = ".jar" + + override fun findIncludedFiles(project: Project, context: KobaltContext, zip: Zip) : List { + // + // Add all the applicable files for the current project + // + val buildDir = KFiles.buildDir(project) + val result = arrayListOf() + val classesDir = KFiles.makeDir(buildDir.path, "classes") + + if (zip.includedFiles.isEmpty()) { + // If no includes were specified, assume the user wants a simple jar file made of the + // classes of the project, so we specify a From("build/classes/"), To("") and + // a list of files containing everything under it + val relClassesDir = Paths.get(project.directory).relativize(Paths.get(classesDir.path)) + val prefixPath = Paths.get(project.directory).relativize(Paths.get(classesDir.path + "/")) + + // Class files + val files = KFiles.findRecursively(classesDir).map { File(relClassesDir.toFile(), it) } + val filesNotExcluded : List = files.filter { + ! KFiles.Companion.isExcluded(KFiles.joinDir(project.directory, it.path), zip.excludes) + } + val fileSpecs = arrayListOf() + filesNotExcluded.forEach { + fileSpecs.add(IFileSpec.FileSpec(it.path.toString().substring(prefixPath.toString().length + 1))) + } + result.add(IncludedFile(From(prefixPath.toString()), To(""), fileSpecs)) + + // Resources, if applicable + context.variant.resourceDirectories(project).forEach { + result.add(IncludedFile(From(it.path), To(""), listOf(IFileSpec.GlobSpec("**")))) + } + } else { + // + // The user specified an include, just use it verbatim + // + val includedFiles = findIncludedFiles(project.directory, zip.includedFiles, zip.excludes, false) + result.addAll(includedFiles) + } + + // + // If fatJar is true, add all the transitive dependencies as well: compile, runtime and dependent projects + // + if (zip.fatJar) { + val seen = hashSetOf() + @Suppress("UNCHECKED_CAST") + val allDependencies = project.compileDependencies + project.compileRuntimeDependencies + + context.variant.buildType.compileDependencies + + context.variant.buildType.compileRuntimeDependencies + + context.variant.productFlavor.compileDependencies + + context.variant.productFlavor.compileRuntimeDependencies + val transitiveDependencies = dependencyManager.calculateDependencies(project, context, + scopes = listOf(Scope.COMPILE), passedDependencies = allDependencies) + transitiveDependencies.map { + it.jarFile.get() + }.forEach { file : File -> + if (! seen.contains(file.path)) { + seen.add(file.path) + if (! KFiles.Companion.isExcluded(file, zip.excludes)) { + result.add(IncludedFile(specs = arrayListOf(IFileSpec.FileSpec(file.absolutePath)), + expandJarFiles = true)) + } + } + } + } + + return result + } + + override fun generateArchive(project: Project, context: KobaltContext, zip: Zip, + includedFiles: List) : File { + // + // Generate the manifest + // If manifest attributes were specified in the build file, use those to generateAndSave the manifest. Otherwise, + // try to find a META-INF/MANIFEST.MF and use that one if we find any. Otherwise, use the default manifest. + // + val manifest = + if (zip.attributes.size > 1) { + context.logger.log(project.name, 2, "Creating MANIFEST.MF from " + zip.attributes.size + " attributes") + Manifest().apply { + zip.attributes.forEach { attribute -> + mainAttributes.putValue(attribute.first, attribute.second) + } + } + } else { + fun findManifestFile(project: Project, includedFiles: List): File? { + val allFiles = includedFiles.flatMap { file -> + file.allFromFiles(project.directory).map { file.from(it.path) } + } + val manifestFiles = allFiles.filter { it.path.contains(MetaArchive.MANIFEST_MF) } + return if (manifestFiles.any()) manifestFiles[0] else null + } + + val manifestFile = findManifestFile(project, includedFiles) + if (manifestFile != null) { + context.logger.log(project.name, 2, "Including MANIFEST.MF file $manifestFile") + Manifest(FileInputStream(manifestFile)) + } else { + null + } + } + + return Archives.generateArchive(project, context, zip.name, ".jar", includedFiles, + true /* expandJarFiles */, manifest) + } + +} \ No newline at end of file diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/JavaInfo.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/JavaInfo.kt index 53c4e010..3c957454 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/JavaInfo.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/JavaInfo.kt @@ -2,18 +2,18 @@ package com.beust.kobalt import java.io.File -abstract public class JavaInfo { - public var javaExecutable: File? = null +abstract class JavaInfo { + val javaExecutable: File? get() = findExecutable("java") - public var javacExecutable: File? = null + val javacExecutable: File? get() = findExecutable("javac") - public var javadocExecutable: File? = null + val javadocExecutable: File? get() = findExecutable("javadoc") - abstract public var javaHome: File? - abstract public var runtimeJar: File? - abstract public var toolsJar: File? + abstract var javaHome: File? + abstract var runtimeJar: File? + abstract var toolsJar: File? - abstract public fun findExecutable(command: String) : File + abstract fun findExecutable(command: String) : File companion object { fun create(javaBase: File?): Jvm { diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Jvm.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Jvm.kt index 7dda6015..14c55efd 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Jvm.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Jvm.kt @@ -1,18 +1,18 @@ package com.beust.kobalt -import com.beust.kobalt.misc.log +import com.beust.kobalt.misc.kobaltLog import com.beust.kobalt.misc.warn import java.io.File import java.io.IOException -public open class Jvm constructor( +open class Jvm constructor( val os: OperatingSystem, var javaBase: File? = null) : JavaInfo() { private var _javaHome: File? = null - override public var javaHome: File? = null + override var javaHome: File? = null get() = _javaHome!! - override public var runtimeJar: File? = null + override var runtimeJar: File? = null private fun findRuntimeJar() : File? { var runtimeJar = File(javaBase, "lib/rt.jar") if (runtimeJar.exists()) { @@ -21,7 +21,7 @@ public open class Jvm constructor( runtimeJar = File(javaBase, "jre/lib/rt.jar") return if (runtimeJar.exists()) runtimeJar else null } - override public var toolsJar: File? = null + override var toolsJar: File? = null private var userSupplied: Boolean? = false private var javaVersion: String? = null @@ -67,7 +67,7 @@ public open class Jvm constructor( return toolsJar } if (javaHome!!.name.equals("jre", true)) { - javaHome = javaHome!!.parentFile + _javaHome = javaHome!!.parentFile toolsJar = File(javaHome, "lib/tools.jar") if (toolsJar.exists()) { return toolsJar @@ -78,7 +78,7 @@ public open class Jvm constructor( val version = SystemProperties.Companion.javaVersion if (javaHome!!.name.toRegex().matches("jre\\d+") || javaHome!!.name == "jre$version") { - javaHome = File(javaHome!!.parentFile, "jdk$version") + _javaHome = File(javaHome!!.parentFile, "jdk$version") toolsJar = File(javaHome, "lib/tools.jar") if (toolsJar.exists()) { return toolsJar @@ -89,15 +89,15 @@ public open class Jvm constructor( return null } -// open public fun isIbmJvm(): Boolean { +// open fun isIbmJvm(): Boolean { // return false // } - override public fun findExecutable(command: String): File { + override fun findExecutable(command: String): File { if (javaHome != null) { val jdkHome = if (javaHome!!.endsWith("jre")) javaHome!!.parentFile else javaHome val exec = File(jdkHome, "bin/" + command) - var executable = File(os.getExecutableName(exec.absolutePath)) + val executable = File(os.getExecutableName(exec.absolutePath)) if (executable.isFile) { return executable } @@ -110,7 +110,7 @@ public open class Jvm constructor( val pathExecutable = os.findInPath(command) if (pathExecutable != null) { - log(2, "Unable to find the $command executable using home: " + + kobaltLog(2, "Unable to find the $command executable using home: " + "$javaHome but found it on the PATH: $pathExecutable.") return pathExecutable } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Plugins.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Plugins.kt index fdae0167..0102dd8b 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Plugins.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Plugins.kt @@ -3,29 +3,32 @@ package com.beust.kobalt import com.beust.kobalt.api.* import com.beust.kobalt.api.annotation.IncrementalTask import com.beust.kobalt.api.annotation.Task +import com.beust.kobalt.internal.IncrementalManager +import com.beust.kobalt.internal.KobaltSettings import com.beust.kobalt.internal.PluginInfo import com.beust.kobalt.internal.TaskManager -import com.beust.kobalt.maven.DepFactory -import com.beust.kobalt.maven.LocalRepo +import com.beust.kobalt.maven.DependencyManager import com.beust.kobalt.misc.JarUtils import com.beust.kobalt.misc.KFiles import com.beust.kobalt.misc.KobaltExecutors -import com.beust.kobalt.misc.log +import com.beust.kobalt.misc.kobaltLog import com.google.inject.Provider +import java.io.File import java.lang.reflect.Method import java.lang.reflect.Modifier +import java.net.URLClassLoader import java.util.* import java.util.jar.JarFile import javax.inject.Inject import javax.inject.Singleton @Singleton -public class Plugins @Inject constructor (val taskManagerProvider : Provider, +class Plugins @Inject constructor (val taskManagerProvider : Provider, val files: KFiles, - val depFactory: DepFactory, - val localRepo: LocalRepo, + val depManager: DependencyManager, + val settings: KobaltSettings, val executors: KobaltExecutors, - val pluginInfo: PluginInfo, + val incrementalManagerFactory: IncrementalManager.IFactory, val taskManager: TaskManager) { companion object { @@ -47,6 +50,8 @@ public class Plugins @Inject constructor (val taskManagerProvider : Provider) { plugins.forEach { plugin -> addPluginInstance(plugin) @@ -59,7 +64,7 @@ public class Plugins @Inject constructor (val taskManagerProvider : Provider plugin.apply(project, context) } @@ -75,7 +80,26 @@ public class Plugins @Inject constructor (val taskManagerProvider : Provider + taskManager.dynamicTasks.addAll(it.tasksFor(project, context)) + } + } + + // ... and from the incremental task contributors + val incrementalManager = incrementalManagerFactory.create() + context.pluginInfo.incrementalTaskContributors.forEach { + projects.forEach { project -> + it.incrementalTasksFor(project, context).forEach { + // Convert the closure (Project) -> IncrementalTaskInfo to (Project) -> TaskResult + // and create a DynamicTask out of it + val closure = + incrementalManager.toIncrementalTaskClosure(it.name, it.incrementalClosure, Variant()) + val task = DynamicTask(it.plugin, it.name, it.doc, it.group, it.project, it.dependsOn, + it.reverseDependsOn, it.runBefore, it.runAfter, it.alwaysRunAfter, + closure) + taskManager.dynamicTasks.add(task) + } + } } // Now that we have collected all static and dynamic tasks, turn them all into plug-in tasks @@ -86,7 +110,7 @@ public class Plugins @Inject constructor (val taskManagerProvider : Provider> { val result = arrayListOf>() - var currentClass : Class = plugin.javaClass + var currentClass : Class? = plugin.javaClass // Tasks can come from two different places: plugin classes and build files. // When a task is read from a build file, ScriptCompiler adds it right away to plugin.methodTasks. @@ -146,20 +170,34 @@ public class Plugins @Inject constructor (val taskManagerProvider : Provider() - fun installPlugins(dependencies: List, classLoader: ClassLoader) { +// @Inject +// lateinit var pluginInfo: PluginInfo + + fun installPlugins(dependencies: List, scriptClassLoader: ClassLoader) { val executor = executors.newExecutor("Plugins", 5) dependencies.forEach { // // Load all the jar files synchronously (can't compile the build script until // they are installed locally). - depFactory.create(it.id, executor) + depManager.create(it.id) // // Open the jar, parse its kobalt-plugin.xml and add the resulting PluginInfo to pluginInfo // - val pluginXml = JarUtils.extractTextFile(JarFile(it.jarFile.get()), PluginInfo.PLUGIN_XML) + val file = it.jarFile.get() + val pluginXml = if (file.isDirectory) { + // The plug-in can point to a directory (e.g. plugin("classes")), in which case we just + // read kobalt-plugin.xml directly + File(file, PluginInfo.PLUGIN_XML).readText() + } else { + // The plug-in is pointing to a jar file, read kobalt-plugin.xml from it + JarUtils.extractTextFile(JarFile(file), PluginInfo.PLUGIN_XML) + } + + val pluginInfo = Kobalt.INJECTOR.getInstance(PluginInfo::class.java) if (pluginXml != null) { - val thisPluginInfo = PluginInfo.readPluginXml(pluginXml, classLoader) + val pluginClassLoader = URLClassLoader(arrayOf(file.toURI().toURL())) + val thisPluginInfo = PluginInfo.readPluginXml(pluginXml, pluginClassLoader, scriptClassLoader) pluginInfo.addPluginInfo(thisPluginInfo) thisPluginInfo.plugins.forEach { Plugins.addPluginInstance(it) diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/ResolveDependency.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/ResolveDependency.kt index a5ef7abb..0d1223e9 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/ResolveDependency.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/ResolveDependency.kt @@ -3,18 +3,20 @@ package com.beust.kobalt import com.beust.kobalt.api.IClasspathDependency import com.beust.kobalt.maven.LocalRepo import com.beust.kobalt.maven.MavenId -import com.beust.kobalt.maven.RepoFinder -import com.beust.kobalt.maven.SimpleDep -import com.beust.kobalt.maven.dependency.MavenDependency -import com.beust.kobalt.misc.Node -import com.beust.kobalt.misc.log +import com.beust.kobalt.maven.aether.* +import com.beust.kobalt.misc.* import com.google.inject.Inject +import org.eclipse.aether.artifact.DefaultArtifact +import org.eclipse.aether.graph.DependencyNode import java.util.* /** * Display information about a Maven id. */ -class ResolveDependency @Inject constructor(val repoFinder: RepoFinder, val localRepo: LocalRepo) { +class ResolveDependency @Inject constructor( + val localRepo: LocalRepo, + val aether: KobaltMavenResolver, + val executors: KobaltExecutors) { val increment = 8 val leftFirst = "\u2558" val leftMiddle = "\u255f" @@ -23,24 +25,51 @@ class ResolveDependency @Inject constructor(val repoFinder: RepoFinder, val loca class Dep(val dep: IClasspathDependency, val level: Int) - fun run(id: String) { - val repoResult = repoFinder.findCorrectRepo(id) + fun run(id: String) = displayDependenciesFor(id) + private fun latestMavenArtifact(group: String, artifactId: String, extension: String = "jar"): DependencyNode { + val artifact = DefaultArtifact(group, artifactId, extension, "(0,]") + val resolved = aether.resolveRange(artifact) + if (resolved != null) { + val newArtifact = DefaultArtifact(artifact.groupId, artifact.artifactId, artifact.extension, + resolved.highestVersion.toString()) + val artifactResult = aether.resolve(KobaltMavenResolver.artifactToId(newArtifact), null) + return artifactResult.root + } else { + throw KobaltException("Couldn't find latest artifact for $group:$artifactId") + } + } + + class PairResult(val dependency: IClasspathDependency, val repoUrl: String) + + fun latestArtifact(group: String, artifactId: String, extension: String = "jar"): PairResult + = latestMavenArtifact(group, artifactId, extension).let { + PairResult(AetherDependency(it.artifact), "(TBD repo)") + } + + private fun displayDependenciesFor(id: String) { + val mavenId = MavenId.create(id) + val resolved : PairResult = + if (mavenId.hasVersion) { + val node = aether.resolve(id, filter = Filters.EXCLUDE_OPTIONAL_FILTER) + PairResult(AetherDependency(node.root.artifact), node.artifactResults[0].repository.toString()) + } else { + latestArtifact(mavenId.groupId, mavenId.artifactId) + } + + displayDependencies(resolved.dependency, resolved.repoUrl) + } + + private fun displayDependencies(dep: IClasspathDependency, url: String) { val indent = -1 - val originalDep = MavenDependency.create(id) - // We want to display the dependencies of the id we found, not the one we queries - val dep = MavenDependency.create(originalDep.shortId + repoResult.version) val root = Node(Dep(dep, indent)) - val seen = hashSetOf(id) + val seen = hashSetOf(dep.id) root.addChildren(findChildren(root, seen)) - val simpleDep = SimpleDep(MavenId.create(id)) - val url = repoResult.hostConfig.url + simpleDep.toJarFile(repoResult) - val localFile = localRepo.toFullPath(simpleDep.toJarFile(repoResult)) - AsciiArt.logBox(listOf(id, url, localFile).map { " $it" }, {s -> println(s) }) + kobaltLog(1, AsciiArt.logBox(listOf(dep.id, url, dep.jarFile.get()).map { " $it" })) display(root.children) - println("") + kobaltLog(1, "") } private fun display(nodes: List>) { @@ -52,10 +81,12 @@ class ResolveDependency @Inject constructor(val repoFinder: RepoFinder, val loca else leftMiddle val indent = level * increment for(i in 0..indent - 2) { - if (i % increment == 0) print(vertical) - else print(" ") + if (!KobaltLogger.isQuiet) { + if (i == 0 || ((i + 1) % increment == 0)) print(vertical) + else print(" ") + } } - println(left + " " + dep.id) + kobaltLog(1, left + " " + dep.id + (if (dep.optional) " (optional)" else "")) display(node.children) } } @@ -68,13 +99,18 @@ class ResolveDependency @Inject constructor(val repoFinder: RepoFinder, val loca if (! seen.contains(it.id)) { val dep = Dep(it, root.value.level + 1) val node = Node(dep) - log(2, "Found dependency ${dep.dep.id} level: ${dep.level}") + kobaltLog(2, "Found dependency ${dep.dep.id} level: ${dep.level}") result.add(node) seen.add(it.id) - node.addChildren(findChildren(node, seen)) + try { + node.addChildren(findChildren(node, seen)) + } catch(ex: Exception) { + if (! it.optional) warn("Couldn't resolve " + node) + // else don't warn about missing optional dependencies + } } } - log(2, "Children for ${root.value.dep.id}: ${result.size}") + kobaltLog(2, "Children for ${root.value.dep.id}: ${result.size}") return result } } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/SystemProperties.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/SystemProperties.kt index b7877264..d5507497 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/SystemProperties.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/SystemProperties.kt @@ -1,9 +1,17 @@ package com.beust.kobalt -public class SystemProperties { +class SystemProperties { companion object { - val javaBase = System.getProperty("java.home") ?: - (System.getenv("JAVA_HOME") ?: throw IllegalArgumentException("JAVA_HOME not defined")) + val javaBase : String + get() { + val jh = System.getenv("JAVA_HOME") + ?: System.getProperty("java.home") + ?: throw IllegalArgumentException("JAVA_HOME not defined") + val result = + if (jh.toLowerCase().endsWith("jre")) jh.substring(0, jh.length - 4) + else jh + return result + } val javaVersion = System.getProperty("java.version") val homeDir = System.getProperty("user.home") val tmpDir = System.getProperty("java.io.tmpdir") diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/TaskResult.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/TaskResult.kt index 4d6a45f3..241bc045 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/TaskResult.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/TaskResult.kt @@ -1,3 +1,8 @@ package com.beust.kobalt -open public class TaskResult(val success: Boolean = true, val errorMessage: String? = null) +class TestResult(val success: Boolean, val shortMessage: String? = null, val longMessage: String? = null) + +open class TaskResult(val success: Boolean = true, + val testResult: TestResult? = null, + val errorMessage: String? = null +) diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/TestConfig.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/TestConfig.kt new file mode 100644 index 00000000..f84b094d --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/TestConfig.kt @@ -0,0 +1,40 @@ +package com.beust.kobalt + +import com.beust.kobalt.api.Project +import com.beust.kobalt.api.annotation.Directive + +class TestConfig(val project: Project, val isDefault : Boolean = false) { + val testArgs = arrayListOf() + val jvmArgs = arrayListOf() + val testIncludes = arrayListOf("**/*Test.class") + val testExcludes = arrayListOf() + + @Directive + var name: String = "" + + @Directive + fun args(vararg arg: String) { + testArgs.addAll(arg) + } + + @Directive + fun jvmArgs(vararg arg: String) { + jvmArgs.addAll(arg) + } + + @Directive + fun include(vararg arg: String) { + testIncludes.apply { + clear() + addAll(arg) + } + } + + @Directive + fun exclude(vararg arg: String) { + testExcludes.apply { + clear() + addAll(arg) + } + } +} \ No newline at end of file diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/TestDirective.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/TestDirective.kt index 31052002..ad026380 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/TestDirective.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/TestDirective.kt @@ -3,21 +3,16 @@ package com.beust.kobalt import com.beust.kobalt.api.Project import com.beust.kobalt.api.annotation.Directive -class TestConfig(val project: Project) { - fun args(vararg arg: String) { - project.testArgs.addAll(arg) - } - - fun jvmArgs(vararg arg: String) { - project.testJvmArgs.addAll(arg) - } -} - @Directive -fun Project.test(init: TestConfig.() -> Unit) : TestConfig { - val result = TestConfig(this) - result.init() - return result +fun Project.test(init: TestConfig.() -> Unit): TestConfig = let { project -> + with(testConfigs) { + val tf = TestConfig(project).apply { init() } + if (! map { it.name }.contains(tf.name)) { + add(tf) + tf + } else { + throw KobaltException("Test configuration \"${tf.name}\" already exists, give it a different " + + "name with test { name = ... }") + } + } } - - diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Variant.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Variant.kt index 83c04625..13120fa0 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Variant.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Variant.kt @@ -1,9 +1,12 @@ package com.beust.kobalt import com.beust.kobalt.api.* +import com.beust.kobalt.internal.ActorUtils +import com.beust.kobalt.internal.ParallelLogger +import com.beust.kobalt.internal.SourceSet import com.beust.kobalt.misc.KFiles -import com.beust.kobalt.misc.log import java.io.File +import java.util.* /** * Capture the product flavor and the build type of a build. @@ -26,49 +29,71 @@ class Variant(val initialProductFlavor: ProductFlavorConfig? = null, /** * for {internal, release}, return [internalRelease, internal, release] */ - fun allDirectories(project: Project): List { - val result = arrayListOf() - result.add(toCamelcaseDir()) - if (productFlavor != null) result.add(productFlavor.name) - if (buildType != null) result.add(buildType.name) - return result + fun allDirectories(): List { + return arrayListOf().apply { + add(toCamelcaseDir()) + add(productFlavor.name) + add(buildType.name) + } } - fun resDirectories(project: Project) : List = sourceDirectories(project, "res") + fun sourceDirectories(project: Project, context: KobaltContext, sourceSet: SourceSet) : List { + val result = arrayListOf() + val compilerContributors = ActorUtils.selectAffinityActors(project, context, + context.pluginInfo.compilerContributors) + compilerContributors.forEach { + it.compilersFor(project, context).forEach { compiler -> + result.addAll(sourceDirectories(project, compiler.sourceDirectory, variantFirst = true, + sourceSet = sourceSet)) + } - fun sourceDirectories(project: Project) : List = - sourceDirectories(project, project.projectInfo.sourceDirectory) + } + return result.filter { ! KFiles.isResource(it.path) }.toList() + } /** - * suffix is either "java" (to find source files) or "res" (to find resources) + * Might be used by plug-ins. */ - private fun sourceDirectories(project: Project, suffix: String) : List { + fun resourceDirectories(project: Project, sourceSet: SourceSet = SourceSet.MAIN) + = sourceDirectories(project, "resources", variantFirst = false, sourceSet = sourceSet) + .filter { KFiles.isResource(it.path) } + + /** + * suffix is either "java" (to find source files) or "resources" (to find resources). + * The priority directory is always returned first. For example, if a "pro" product flavor + * is requested, "src/pro/kotlin" will appear in the result before "src/main/kotlin". Later, + * files that have already been seen get skipped, which is how compilation and resources + * receive the correct priority in the final jar. + */ + private fun sourceDirectories(project: Project, suffix: String, variantFirst: Boolean, sourceSet: SourceSet) + : List { val result = arrayListOf() - val sourceDirectories = project.sourceDirectories.map { File(it) } + val sourceDirectories = sourceSet.correctSourceSet(project) + .filter { File(project.directory, it).exists() } + .map(::File) + if (isDefault) { result.addAll(sourceDirectories) } else { - result.addAll(allDirectories(project).map { - File(KFiles.joinDir("src", it, suffix)) - }.filter { - it.exists() - }) - // // The ordering of files is: 1) build type 2) product flavor 3) default + val kobaltLog = Kobalt.INJECTOR.getInstance(ParallelLogger::class.java) buildType.let { - val dir = File(KFiles.joinDir("src", it.name, project.projectInfo.sourceDirectory)) - log(3, "Adding source for build type ${it.name}: ${dir.path}") + val dir = File(KFiles.joinDir("src", it.name, suffix)) + kobaltLog.log(project.name, 3, "Adding source for build type ${it.name}: ${dir.path}") result.add(dir) } productFlavor.let { - val dir = File(KFiles.joinDir("src", it.name, project.projectInfo.sourceDirectory)) - log(3, "Adding source for product flavor ${it.name}: ${dir.path}") + val dir = File(KFiles.joinDir("src", it.name, suffix)) + kobaltLog.log(project.name, 3, "Adding source for product flavor ${it.name}: ${dir.path}") result.add(dir) } + result.addAll(allDirectories() + .map { File(KFiles.joinDir("src", it, suffix)) } + .filter(File::exists)) + // Now that all the variant source directories have been added, add the project's default ones result.addAll(sourceDirectories) - return result } // Generated directory, if applicable @@ -76,7 +101,11 @@ class Variant(val initialProductFlavor: ProductFlavorConfig? = null, result.add(it) } - return result + val filteredResult = result.filter { File(project.directory, it.path).exists() } + val sortedResult = if (variantFirst) filteredResult + else filteredResult.reversed().toList() + val deduplicatedResult = LinkedHashSet(sortedResult).toList() + return deduplicatedResult } fun archiveName(project: Project, archiveName: String?, suffix: String) : String { @@ -84,28 +113,27 @@ class Variant(val initialProductFlavor: ProductFlavorConfig? = null, if (isDefault) { archiveName ?: project.name + "-" + project.version + suffix } else { - val base = if (archiveName != null) archiveName.substring(0, archiveName.length - suffix.length) - else project.name + "-" + project.version - val result: String = - base + "-${productFlavor.name}" + "-${buildType.name}" + val base = archiveName?.substring(0, archiveName.length - suffix.length) + ?: project.name + "-" + project.version + val flavor = if (productFlavor.name.isEmpty()) "" else "-" + productFlavor.name + val type = if (buildType.name.isEmpty()) "" else "-" + buildType.name + val result: String = base + flavor + type + suffix result } return result } - val shortArchiveName = if (isDefault) "" else "-" + productFlavor.name + "-" + buildType.name - var generatedSourceDirectory: File? = null private fun findBuildTypeBuildConfig(project: Project, variant: Variant?) : BuildConfig? { val buildTypeName = variant?.buildType?.name - return project.buildTypes.getRaw(buildTypeName)?.buildConfig ?: null + return project.buildTypes[buildTypeName]?.buildConfig } private fun findProductFlavorBuildConfig(project: Project, variant: Variant?) : BuildConfig? { val buildTypeName = variant?.productFlavor?.name - return project.productFlavors.getRaw(buildTypeName)?.buildConfig ?: null + return project.productFlavors[buildTypeName]?.buildConfig } /** @@ -123,7 +151,7 @@ class Variant(val initialProductFlavor: ProductFlavorConfig? = null, /** * Generate BuildConfig.java if requested. Also look up if any BuildConfig is defined on the current build type, - * product flavor or main project, and use them to generate any additional field (in that order to + * product flavor or main project, and use them to generateAndSave any additional field (in that order to * respect the priorities). Return the generated file if it was generated, null otherwise. */ fun maybeGenerateBuildConfig(project: Project, context: KobaltContext) : File? { @@ -132,18 +160,24 @@ class Variant(val initialProductFlavor: ProductFlavorConfig? = null, if (buildConfigs.size > 0) { val pkg = project.packageName ?: project.group ?: throw KobaltException( - "packageName needs to be defined on the project in order to generate BuildConfig") + "packageName needs to be defined on the project in order to generateAndSave BuildConfig") - val code = project.projectInfo.generateBuildConfig(project, context, pkg, this, buildConfigs) - val result = KFiles.makeDir(KFiles.generatedSourceDir(project, this, "buildConfig")) - // Make sure the generatedSourceDirectory doesn't contain the project.directory since - // that directory will be added when trying to find recursively all the sources in it - generatedSourceDirectory = File(result.relativeTo(File(project.directory))) - val outputGeneratedSourceDirectory = File(result, pkg.replace('.', File.separatorChar)) - val outputDir = File(outputGeneratedSourceDirectory, "BuildConfig" + project.sourceSuffix) - KFiles.saveFile(outputDir, code) - log(2, "Generated ${outputDir.path}") - return result + val contributor = ActorUtils.selectAffinityActor(project, context, + context.pluginInfo.buildConfigContributors) + if (contributor != null) { + val code = contributor.generateBuildConfig(project, context, pkg, this, buildConfigs) + val result = KFiles.makeDir(KFiles.generatedSourceDir(project, this, "buildConfig")) + // Make sure the generatedSourceDirectory doesn't contain the project.directory since + // that directory will be added when trying to find recursively all the sources in it + generatedSourceDirectory = result.relativeTo(File(project.directory)) + val outputGeneratedSourceDirectory = File(result, pkg.replace('.', File.separatorChar)) + val outputDir = File(outputGeneratedSourceDirectory, "BuildConfig." + contributor.buildConfigSuffix) + KFiles.saveFile(outputDir, code) + context.logger.log(project.name, 2, "Generated ${outputDir.path}") + return result + } else { + throw KobaltException("Couldn't find a contributor to generateAndSave BuildConfig") + } } else { return null } @@ -151,9 +185,10 @@ class Variant(val initialProductFlavor: ProductFlavorConfig? = null, override fun toString() = toTask("") + companion object { val DEFAULT_PRODUCT_FLAVOR = ProductFlavorConfig("") - val DEFAULT_BUILD_TYPE = BuildTypeConfig(null, "") + val DEFAULT_BUILD_TYPE = BuildTypeConfig("") fun allVariants(project: Project): List { val result = arrayListOf() @@ -186,9 +221,9 @@ class Variant(val initialProductFlavor: ProductFlavorConfig? = null, } fun toCamelcaseDir() : String { - val pfName = productFlavor.name - val btName = buildType.name - return pfName[0].toLowerCase() + pfName.substring(1) + btName[0].toUpperCase() + btName.substring(1) + fun lci(s : String) = if (s.isEmpty() || s.length == 1) s else s[0].toLowerCase() + s.substring(1) + + return lci(productFlavor.name) + buildType.name.capitalize() } fun toIntermediateDir() : String { diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/BasePlugin.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/BasePlugin.kt index c74bfa71..ff6d1e95 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/BasePlugin.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/BasePlugin.kt @@ -3,7 +3,7 @@ package com.beust.kobalt.api import com.beust.kobalt.Plugins import com.beust.kobalt.internal.TaskManager -abstract public class BasePlugin : IPlugin { +abstract class BasePlugin : IPlugin { lateinit var context: KobaltContext override fun accept(project: Project) = true @@ -12,13 +12,7 @@ abstract public class BasePlugin : IPlugin { this.context = context } - /** - * The list of projects depended upon (e.g. val p = javaProject(dependentProject)). - */ - protected val projects = arrayListOf() - - fun addProject(project: Project, dependsOn: Array) = - projects.add(ProjectDescription(project, dependsOn.toList())) + override fun shutdown() {} override lateinit var taskManager: TaskManager lateinit var plugins: Plugins diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/BuildTypeConfig.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/BuildTypeConfig.kt new file mode 100644 index 00000000..2db3d939 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/BuildTypeConfig.kt @@ -0,0 +1,11 @@ +package com.beust.kobalt.api + +class BuildTypeConfig(val name: String) : IBuildConfig, IDependencyHolder by DependencyHolder() { + + var minifyEnabled = false + var applicationIdSuffix: String? = null + var proguardFile: String? = null + + override var buildConfig : BuildConfig? = BuildConfig() +} + diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/CompilerActionInfo.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/CompilerActionInfo.kt index 9a1d374d..e323e474 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/CompilerActionInfo.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/CompilerActionInfo.kt @@ -8,7 +8,9 @@ import java.io.File data class CompilerActionInfo(val directory: String?, val dependencies: List, val sourceFiles: List, + val suffixesBeingCompiled: List, val outputDir: File, - val compilerArgs: List) - - + val compilerArgs: List, + val friendPaths: List, + val forceRecompile: Boolean, + val compilerSeparateProcess: Boolean = false) diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ConfigActor.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ConfigActor.kt new file mode 100644 index 00000000..cd4ae745 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ConfigActor.kt @@ -0,0 +1,19 @@ +package com.beust.kobalt.api + +import java.util.* + +/** + * Actors that have one config object per project can implement `IConfigActor` by delegating to + * `ConfigActor`. Then they can easily add and look up configurations per project. + */ +interface IConfigActor { + val configurations : HashMap + + fun configurationFor(project: Project?) = if (project != null) configurations[project.name] else null + + fun addConfiguration(project: Project, configuration: T) = configurations.put(project.name, configuration) +} + +open class ConfigActor: IConfigActor { + override val configurations : HashMap = hashMapOf() +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ConfigPlugin.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ConfigPlugin.kt deleted file mode 100644 index c05e3177..00000000 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ConfigPlugin.kt +++ /dev/null @@ -1,12 +0,0 @@ -package com.beust.kobalt.api - -/** - * A plug-in that has some per-project configuration in the build file. - */ -abstract public class ConfigPlugin : BasePlugin() { - private val configurations = hashMapOf() - - fun configurationFor(project: Project?) = if (project != null) configurations[project.name] else null - - fun addConfiguration(project: Project, configuration: T) = configurations.put(project.name, configuration) -} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ConfigsActor.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ConfigsActor.kt new file mode 100644 index 00000000..5ec4ce53 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ConfigsActor.kt @@ -0,0 +1,19 @@ +package com.beust.kobalt.api + +import com.google.common.collect.ArrayListMultimap +import com.google.common.collect.ListMultimap + +/** + * Actors that have more than config object per project can use this helper class. + */ +interface IConfigsActor { + val configurations : ListMultimap + + fun configurationFor(project: Project?) = if (project != null) configurations[project.name] else null + + fun addConfiguration(project: Project, configuration: T) = configurations.put(project.name, configuration) +} + +open class ConfigsActor: IConfigsActor { + override val configurations = ArrayListMultimap.create() +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ConfigsPlugin.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ConfigsPlugin.kt deleted file mode 100644 index 845f6b24..00000000 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ConfigsPlugin.kt +++ /dev/null @@ -1,14 +0,0 @@ -package com.beust.kobalt.api - -import com.google.common.collect.ArrayListMultimap - -/** - * A plug-in that has some per-project list of configurations in the build file. - */ -abstract public class ConfigsPlugin : BasePlugin() { - private val configurations = ArrayListMultimap.create() - - fun configurationFor(project: Project) = configurations[project.name] - - fun addConfiguration(project: Project, configuration: T) = configurations.put(project.name, configuration) -} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/DependencyHolder.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/DependencyHolder.kt new file mode 100644 index 00000000..e1195ca3 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/DependencyHolder.kt @@ -0,0 +1,47 @@ +package com.beust.kobalt.api + +import com.beust.kobalt.api.annotation.Directive +import java.util.* + +/** + * Various elements in a build file let you specify dependencies: projects, buildType and productFlavor. + * They all implement this interface and delegate to an instance of the `DependencyHolder` concrete class. + */ +interface IDependencyHolder { + var project: Project + + val compileDependencies : ArrayList + val optionalDependencies : ArrayList + val compileProvidedDependencies : ArrayList + val compileOnlyDependencies : ArrayList + val compileRuntimeDependencies : ArrayList + val excludedDependencies : ArrayList + val nativeDependencies : ArrayList + + @Directive + var dependencies: Dependencies? + + @Directive + fun dependencies(init: Dependencies.() -> Unit) : Dependencies +} + +open class DependencyHolder : IDependencyHolder { + override lateinit var project: Project + override val compileDependencies : ArrayList = arrayListOf() + override val optionalDependencies : ArrayList = arrayListOf() + override val compileProvidedDependencies : ArrayList = arrayListOf() + override val compileOnlyDependencies : ArrayList = arrayListOf() + override val compileRuntimeDependencies : ArrayList = arrayListOf() + override val excludedDependencies : ArrayList = arrayListOf() + override val nativeDependencies : ArrayList = arrayListOf() + + override var dependencies : Dependencies? = null + + override fun dependencies(init: Dependencies.() -> Unit) : Dependencies { + dependencies = Dependencies(project, compileDependencies, optionalDependencies, compileProvidedDependencies, + compileOnlyDependencies, compileRuntimeDependencies, excludedDependencies, nativeDependencies) + dependencies!!.init() + return dependencies!! + } +} + diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IAssemblyContributor.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IAssemblyContributor.kt new file mode 100644 index 00000000..6c35fc1d --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IAssemblyContributor.kt @@ -0,0 +1,10 @@ +package com.beust.kobalt.api + +import com.beust.kobalt.TaskResult + +/** + * Plug-ins that will be invoked during the "assemble" task. + */ +interface IAssemblyContributor : IContributor { + fun assemble(project: Project, context: KobaltContext) : TaskResult +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IBuildConfigContributor.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IBuildConfigContributor.kt new file mode 100644 index 00000000..ef9d3b4d --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IBuildConfigContributor.kt @@ -0,0 +1,16 @@ +package com.beust.kobalt.api + +import com.beust.kobalt.Variant + +/** + * Plug-ins that can generate a BuildConfig file. + */ +interface IBuildConfigContributor : IProjectAffinity { + fun generateBuildConfig(project: Project, context: KobaltContext, packageName: String, variant: Variant, + buildConfigs: List) : String + + /** + * The suffix of the generated BuildConfig, e.g. ".java". + */ + val buildConfigSuffix: String +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IBuildConfigFieldContributor.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IBuildConfigFieldContributor.kt index 8c4dc843..0d26032f 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IBuildConfigFieldContributor.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IBuildConfigFieldContributor.kt @@ -5,6 +5,6 @@ class BuildConfigField(val type: String, val name: String, val value: Any) /** * Plug-ins that want to add fields to BuildConfig need to implement this interface. */ -interface IBuildConfigFieldContributor { +interface IBuildConfigFieldContributor : IContributor { fun fieldsFor(project: Project, context: KobaltContext) : List } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IBuildDirectoryInterceptor.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IBuildDirectoryInterceptor.kt index 5a317c0f..afb0f1ef 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IBuildDirectoryInterceptor.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IBuildDirectoryInterceptor.kt @@ -3,7 +3,7 @@ package com.beust.kobalt.api /** * Plug-ins can alter the build directory by implementing this interface. */ -interface IBuildDirectoryIncerceptor : IInterceptor { +interface IBuildDirectoryInterceptor : IInterceptor { fun intercept(project: Project, context: KobaltContext, buildDirectory: String) : String } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IBuildListener.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IBuildListener.kt new file mode 100644 index 00000000..2b0fdadb --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IBuildListener.kt @@ -0,0 +1,20 @@ +package com.beust.kobalt.api + +/** + * Plug-ins that listen to build events. + */ +interface IBuildListener : IListener { + + class TaskEndInfo(val success: Boolean, val shortMessage: String? = null, + val longMessage: String? = null) + + fun taskStart(project: Project, context: KobaltContext, taskName: String) {} + fun taskEnd(project: Project, context: KobaltContext, taskName: String, info: TaskEndInfo) {} + + fun projectStart(project: Project, context: KobaltContext) {} + fun projectEnd(project: Project, context: KobaltContext, status: ProjectBuildStatus) {} +} + +enum class ProjectBuildStatus { + SUCCESS, FAILED, SKIPPED +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IBuildReportContributor.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IBuildReportContributor.kt new file mode 100644 index 00000000..130c50d2 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IBuildReportContributor.kt @@ -0,0 +1,8 @@ +package com.beust.kobalt.api + +/** + * Plug-ins that produce build reports. + */ +interface IBuildReportContributor : IContributor { + fun generateReport(context: KobaltContext) +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IClasspathContributor.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IClasspathContributor.kt index 1474d342..ce9afc39 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IClasspathContributor.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IClasspathContributor.kt @@ -1,12 +1,10 @@ package com.beust.kobalt.api -import com.beust.kobalt.api.IClasspathDependency - /** * Plugins that export classpath entries need to implement this interface. */ interface IClasspathContributor : IContributor { - fun entriesFor(project: Project?) : Collection + fun classpathEntriesFor(project: Project?, context: KobaltContext) : Collection } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IClasspathDependency.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IClasspathDependency.kt index 9ee3f4dc..527e6f13 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IClasspathDependency.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IClasspathDependency.kt @@ -8,20 +8,34 @@ import java.util.concurrent.Future * Encapsulate a dependency that can be put on the classpath. This interface * has two subclasses: FileDependency, a physical file, and MavenDependency, * which represents a dependency living in a Maven repo. + * + * You can instantiate either of these concrete classes with DependencyManager#createMaven + * and DependencyManager#createFile. */ interface IClasspathDependency { /** Identifier for this dependency */ val id: String + /** Version for this identifier */ + val version: String + + /** @return true if this dependency represents a Maven coordinate */ + val isMaven: Boolean + + /** @return true if this dependency is optional */ + val optional: Boolean + /** Absolute path to the jar file on the local file system */ val jarFile: Future /** Convert to a Maven model tag */ - fun toMavenDependencies() : Dependency + fun toMavenDependencies(scope: String? = null) : Dependency - /** The list of dependencies for this element (not the transitive closure */ + /** The list of dependencies for this element (not the transitive closure) */ fun directDependencies(): List /** Used to only keep the most recent version for an artifact if no version was specified */ val shortId: String + + val excluded: ArrayList } \ No newline at end of file diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ICompilerContributor.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ICompilerContributor.kt index 1de85643..b6ce8fd2 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ICompilerContributor.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ICompilerContributor.kt @@ -1,9 +1,68 @@ package com.beust.kobalt.api import com.beust.kobalt.TaskResult -import com.beust.kobalt.api.IClasspathDependency -import java.io.File -interface ICompilerContributor : IProjectAffinity { +interface ICompilerDescription : Comparable { + /** + * The name of the language compiled by this compiler. + */ + val name: String + + /** + * The suffixes handled by this compiler (without the dot, e.g. "java" or "kt"). + */ + val sourceSuffixes: List + + /** + * The trailing end of the source directory (e.g. "kotlin" in "src/main/kotlin") + */ + val sourceDirectory: String + + /** + * Run the compilation based on the info. + */ fun compile(project: Project, context: KobaltContext, info: CompilerActionInfo) : TaskResult + + companion object { + val DEFAULT_PRIORITY: Int = 10 + } + + /** + * The priority of this compiler. Lower priority compilers are run first. + */ + val priority: Int get() = DEFAULT_PRIORITY + + override fun compareTo(other: ICompilerDescription) = priority.compareTo(other.priority) + + /** + * Can this compiler be passed directories or does it need individual source files? + */ + val canCompileDirectories: Boolean get() = false } + +interface ICompilerContributor : IProjectAffinity, IContributor { + fun compilersFor(project: Project, context: KobaltContext): List +} + +interface ICompiler { + fun compile(project: Project, context: KobaltContext, info: CompilerActionInfo): TaskResult +} + +class CompilerDescription(override val name: String, override val sourceDirectory: String, + override val sourceSuffixes: List, val compiler: ICompiler, + override val priority: Int = ICompilerDescription.DEFAULT_PRIORITY, + override val canCompileDirectories: Boolean = false) : ICompilerDescription { + override fun compile(project: Project, context: KobaltContext, info: CompilerActionInfo): TaskResult { + val result = + if (info.sourceFiles.isNotEmpty()) { + compiler.compile(project, context, info) + } else { + context.logger.log(project.name, 2, "$name couldn't find any source files to compile") + TaskResult() + } + return result + } + + override fun toString() = name + " compiler" +} + diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ICompilerFlagContributor.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ICompilerFlagContributor.kt index 13396d0e..2d8febe4 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ICompilerFlagContributor.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ICompilerFlagContributor.kt @@ -3,6 +3,27 @@ package com.beust.kobalt.api /** * Plugins that add compiler flags. */ -interface ICompilerFlagContributor : IContributor { - fun flagsFor(project: Project, context: KobaltContext, currentFlags: List): List +class FlagContributor(val flagPriority: Int = DEFAULT_FLAG_PRIORITY, + val closure: (project: Project, context: KobaltContext, currentFlags: List, + suffixesBeingCompiled: List) -> List) : IContributor { + companion object { + val DEFAULT_FLAG_PRIORITY = 20 + } + + fun flagsFor(project: Project, context: KobaltContext, currentFlags: List, + suffixesBeingCompiled: List) = closure(project, context, currentFlags, suffixesBeingCompiled) } + +interface IFlagBase { + val flagPriority: Int get() = FlagContributor.DEFAULT_FLAG_PRIORITY +} + +interface ICompilerFlagContributor : IContributor, IFlagBase { + fun compilerFlagsFor(project: Project, context: KobaltContext, currentFlags: List, + suffixesBeingCompiled: List): List +} + +interface IDocFlagContributor : IContributor, IFlagBase { + fun docFlagsFor(project: Project, context: KobaltContext, currentFlags: List, + suffixesBeingCompiled: List): List +} \ No newline at end of file diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IDependencyManager.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IDependencyManager.kt new file mode 100644 index 00000000..3a66f980 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IDependencyManager.kt @@ -0,0 +1,88 @@ +package com.beust.kobalt.api + +import com.beust.kobalt.maven.aether.Filters.EXCLUDE_OPTIONAL_FILTER +import com.beust.kobalt.maven.aether.KobaltMavenResolver +import com.beust.kobalt.maven.aether.Scope +import com.beust.kobalt.misc.kobaltLog +import org.eclipse.aether.graph.DependencyFilter +import org.eclipse.aether.graph.DependencyNode + +/** + * Manage the creation of dependencies and also provide dependencies for projects. + */ +interface IDependencyManager { + /** + * Parse the id and return the correct IClasspathDependency + */ + fun create(id: String, optional: Boolean = false, projectDirectory: String? = null): IClasspathDependency + + /** + * Create an IClasspathDependency from a Maven id. + */ + fun createMaven(id: String, optional: Boolean = false): IClasspathDependency + + /** + * Create an IClasspathDependency from a path. + */ + fun createFile(path: String): IClasspathDependency + + /** + * @return the source dependencies for this project, including the contributors. + */ + fun dependencies(project: Project, context: KobaltContext, scopes: List): List + + /** + * @return the test dependencies for this project, including the contributors. + */ + fun testDependencies(project: Project, context: KobaltContext): List + + /** + * @return the classpath for this project, including the IClasspathContributors. + * allDependencies is typically either compileDependencies or testDependencies + */ + fun calculateDependencies(project: Project?, context: KobaltContext, + dependencyFilter: DependencyFilter = + createDependencyFilter(project, project?.compileDependencies ?: emptyList()), + scopes: List = listOf(Scope.COMPILE), + vararg passedDependencies: List): List + + /** + * Create an Aether dependency filter that uses the dependency configuration included in each + * IClasspathDependency. + */ + fun createDependencyFilter(project: Project?, dependencies: List) : DependencyFilter { + return DependencyFilter { p0, p1 -> + fun isNodeExcluded(node: DependencyNode, passedDep: IClasspathDependency) : Boolean { + val dep = create(KobaltMavenResolver.artifactToId(node.artifact)) + return passedDep.excluded.any { ex -> ex.isExcluded(dep)} + } + fun isDepExcluded(node: DependencyNode, excluded: List?) : Boolean { + val dep = create(KobaltMavenResolver.artifactToId(node.artifact)) + return excluded?.map { it.id }?.contains(dep.id) ?: false + } + + val accept = dependencies.isEmpty() || dependencies.any { + // Is this dependency excluded? + val isExcluded = isNodeExcluded(p0, it) || isDepExcluded(p0, project?.excludedDependencies) + + // Is the parent dependency excluded? + val isParentExcluded = + if (p1.any()) { + isNodeExcluded(p1[0], it) || isDepExcluded(p1[0], project?.excludedDependencies) + } else { + false + } + + // Only accept if no exclusions were found + ! isExcluded && ! isParentExcluded + } + + if (! accept) { + kobaltLog(2, "Excluding $p0") + } + + if (accept) EXCLUDE_OPTIONAL_FILTER.accept(p0, p1) + else accept + } + } +} \ No newline at end of file diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IDocContributor.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IDocContributor.kt index 8979783f..48797530 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IDocContributor.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IDocContributor.kt @@ -2,7 +2,7 @@ package com.beust.kobalt.api import com.beust.kobalt.TaskResult -interface IDocContributor : IProjectAffinity { +interface IDocContributor : IProjectAffinity, IContributor { fun generateDoc(project: Project, context: KobaltContext, info: CompilerActionInfo) : TaskResult } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IIncrementalAssemblyContributor.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IIncrementalAssemblyContributor.kt new file mode 100644 index 00000000..cd730171 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IIncrementalAssemblyContributor.kt @@ -0,0 +1,12 @@ +package com.beust.kobalt.api + +import com.beust.kobalt.IncrementalTaskInfo + +/** + * Plug-ins that will be invoked during the "assemble" task and wish to return an incremental task instead + * of a regular one. + */ +interface IIncrementalAssemblyContributor : IContributor { + fun assemble(project: Project, context: KobaltContext) : IncrementalTaskInfo +} + diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IIncrementalTaskContributor.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IIncrementalTaskContributor.kt new file mode 100644 index 00000000..1decac22 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IIncrementalTaskContributor.kt @@ -0,0 +1,28 @@ +package com.beust.kobalt.api + +import com.beust.kobalt.IncrementalTaskInfo + +/** + * Plug-ins that need to add incremental dynamic tasks (tasks that are not methods annotated with @Task) need + * to implement this interface. + */ +interface IIncrementalTaskContributor : IContributor { + fun incrementalTasksFor(project: Project, context: KobaltContext) : List +} + +class IncrementalDynamicTask(val context: KobaltContext, + val plugin: IPlugin, + val name: String, + val doc: String, + val group: String, + val project: Project, + val dependsOn: List = listOf(), + val reverseDependsOn: List = listOf(), + val runBefore: List = listOf(), + val runAfter: List = listOf(), + val alwaysRunAfter: List = listOf(), + val incrementalClosure: (Project) -> IncrementalTaskInfo) { + override fun toString() = "[IncrementalDynamicTask $name dependsOn=$dependsOn reverseDependsOn=$reverseDependsOn]" +} + + diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IInitContributor.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IInitContributor.kt deleted file mode 100644 index 4d537107..00000000 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IInitContributor.kt +++ /dev/null @@ -1,15 +0,0 @@ -package com.beust.kobalt.api - -import java.io.OutputStream - -/** - * Plugins that want to participate in the --init process (they can generate files to initialize - * a new project). - */ -interface IInitContributor : ISimpleAffinity { - /** - * Generate the Build.kt file into the given OutputStream. - */ - fun generateBuildFile(os: OutputStream) -} - diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IJvmFlagContributor.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IJvmFlagContributor.kt new file mode 100644 index 00000000..f912ae1d --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IJvmFlagContributor.kt @@ -0,0 +1,13 @@ +package com.beust.kobalt.api + +/** + * Plug-ins that add flags to the JVM used to run apps should implement this interface. + */ +interface IJvmFlagContributor : IContributor { + /** + * The list of JVM flags that will be added to the JVM when the app gets run. @param[currentFlags] is only here + * for convenience, in case you need to look at the current JVM flags before adding your own flags. + */ + fun jvmFlagsFor(project: Project, context: KobaltContext, currentFlags: List) : List +} + diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ILocalMavenRepoPathInterceptor.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ILocalMavenRepoPathInterceptor.kt new file mode 100644 index 00000000..1993f130 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ILocalMavenRepoPathInterceptor.kt @@ -0,0 +1,8 @@ +package com.beust.kobalt.api + +/** + * Plug-ins that want to override the local maven repo path. + */ +interface ILocalMavenRepoPathInterceptor : IInterceptor { + fun repoPath(currentPath: String) : String +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IPlugin.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IPlugin.kt index 97eaa2e0..e9d7acb6 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IPlugin.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IPlugin.kt @@ -2,9 +2,29 @@ package com.beust.kobalt.api import com.beust.kobalt.internal.TaskManager -public interface IPlugin : IPluginActor { +interface IPlugin : IPluginActor { + /** + * The name of this plug-in. + */ val name: String + + /** + * @return true if this plug-in decided it should be enabled for this project. + */ fun accept(project: Project) : Boolean + + /** + * Invoked on all plug-ins before the Kobalt execution stops. + */ + fun shutdown() + + /** + * Main entry point for a plug-in to initialize itself based on a project and a context. + */ fun apply(project: Project, context: KobaltContext) {} + + /** + * Injected by Kobalt to manage tasks. + */ var taskManager : TaskManager } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IPluginActor.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IPluginActor.kt index 79732eb0..96d54218 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IPluginActor.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IPluginActor.kt @@ -1,9 +1,15 @@ package com.beust.kobalt.api -interface IPluginActor +interface IPluginActor { + /** + * Clean up any state that your actor might have saved so it can be run again. + */ + fun cleanUpActors() {} +} interface IContributor : IPluginActor interface IInterceptor : IPluginActor +interface IListener : IPluginActor diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IRunnerContributor.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IRunnerContributor.kt index 5ab88cb0..f8c28b52 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IRunnerContributor.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IRunnerContributor.kt @@ -1,10 +1,11 @@ package com.beust.kobalt.api import com.beust.kobalt.TaskResult -import com.beust.kobalt.api.IClasspathDependency /** * Plugins that can run a project (task "run" or "test") should implement this interface. + * + * Currently not used. */ interface IRunnerContributor : IContributor, IProjectAffinity { /** diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ISimpleAffinity.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ISimpleAffinity.kt index 2711248b..b9c7cdfe 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ISimpleAffinity.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ISimpleAffinity.kt @@ -8,5 +8,5 @@ interface ISimpleAffinity : IAffinity { * @return an integer indicating the affinity of your actor. The actor that returns * the highest affinity gets selected. */ - fun affinity(arg: T) : Int + fun affinity(project: T) : Int } \ No newline at end of file diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ISourceDirectoriesInterceptor.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ISourceDirectoriesInterceptor.kt index aa39712b..33ec6e7c 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ISourceDirectoriesInterceptor.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ISourceDirectoriesInterceptor.kt @@ -5,7 +5,7 @@ import java.io.File /** * Plug-ins can alter the source directories by implementing this interface. */ -interface ISourceDirectoryIncerceptor : IInterceptor { +interface ISourceDirectoryInterceptor : IInterceptor { fun intercept(project: Project, context: KobaltContext, sourceDirectories: List) : List } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ISourceDirectoryContributor.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ISourceDirectoryContributor.kt index 29394d40..fced0771 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ISourceDirectoryContributor.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ISourceDirectoryContributor.kt @@ -5,6 +5,16 @@ import java.io.File /** * Plug-ins that add source directories to be compiled need to implement this interface. */ -interface ISourceDirectoryContributor { +interface ISourceDirectoryContributor : IContributor { fun sourceDirectoriesFor(project: Project, context: KobaltContext): List } + +/** + * @return the source directories for this project including source contributors. + */ +fun KobaltContext.sourceDirectories(project: Project) : Set { + val result = pluginInfo.sourceDirContributors.flatMap { + it.sourceDirectoriesFor(project, this) + } + return result.toSet() +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ITaskContributor.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ITaskContributor.kt index 1cd39e8c..c606d54f 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ITaskContributor.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ITaskContributor.kt @@ -1,17 +1,32 @@ package com.beust.kobalt.api import com.beust.kobalt.TaskResult +import com.beust.kobalt.internal.TaskResult2 /** * Plug-ins that need to add dynamic tasks (tasks that are not methods annotated with @Task) need * to implement this interface. */ interface ITaskContributor : IContributor { - fun tasksFor(context: KobaltContext) : List + fun tasksFor(project: Project, context: KobaltContext) : List } -class DynamicTask(val plugin: IPlugin, val name: String, val description: String = "", +class DynamicTask(override val plugin: IPlugin, override val name: String, override val doc: String, + override val group: String, + override val project: Project, + val dependsOn: List = listOf(), + val reverseDependsOn: List = listOf(), val runBefore: List = listOf(), val runAfter: List = listOf(), val alwaysRunAfter: List = listOf(), - val closure: (Project) -> TaskResult) + val closure: (Project) -> TaskResult) : ITask { + + override fun call(): TaskResult2 { + val taskResult = closure.invoke(project) + return TaskResult2(taskResult.success, errorMessage = taskResult.errorMessage, value = this) + } + + override fun toString() = + "[DynamicTask ${project.name}:$name dependsOn=$dependsOn reverseDependsOn=$reverseDependsOn]" +} + diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ITemplateContributor.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ITemplateContributor.kt new file mode 100644 index 00000000..9af4bb7d --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ITemplateContributor.kt @@ -0,0 +1,45 @@ +package com.beust.kobalt.api + +import com.beust.kobalt.Args + +/** + * Plugins that want to participate in the --init process (they can generate files to initialize + * a new project). + */ +interface ITemplateContributor : IContributor { + companion object { + val DIRECTORY_NAME = "templates" + } + + val templates: List +} + +interface ITemplate { + /** + * The name of this template. This is the name that will be looked up when passed to the --init + * argument. + */ + val templateName: String + + /** + * Description of this template. + */ + val templateDescription: String + + /** + * The plug-in this template belongs to. + */ + val pluginName: String + + /** + * Instructions to display to the user after a template has been generated. + */ + val instructions : String get() = "Build this project with `./kobaltw assemble`" + + /** + * Generate the files for this template. The parameter is the arguments that were passed to the kobaltw + * command. + */ + fun generateTemplate(args: Args, classLoader: ClassLoader) +} + diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ITestJvmFlagContributor.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ITestJvmFlagContributor.kt new file mode 100644 index 00000000..6f1c0bfb --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ITestJvmFlagContributor.kt @@ -0,0 +1,12 @@ +package com.beust.kobalt.api + +/** + * Plug-ins that add flags to the JVM used to run tests should implement this interface. + */ +interface ITestJvmFlagContributor : IContributor { + /** + * The list of JVM flags that will be added to the JVM when the tests get run. @param[currentFlags] is only here + * for convenience, in case you need to look at the current JVM flags before adding your own flags. + */ + fun testJvmFlagsFor(project: Project, context: KobaltContext, currentFlags: List) : List +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ITestJvmFlagInterceptor.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ITestJvmFlagInterceptor.kt new file mode 100644 index 00000000..389f4704 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ITestJvmFlagInterceptor.kt @@ -0,0 +1,14 @@ +package com.beust.kobalt.api + +/** + * Plug-ins that add flags to the JVM used to run tests should implement this interface. + */ +interface ITestJvmFlagInterceptor : IInterceptor { + /** + * @return the list of all flags that should be used. If you only want to add flags to the current list, + * just return the concatenation of @param[currentFlags] and your own list (or use ITestJvmFlagContributor). + * If you actually alter the list of flags, make sure you don't remove anything critical from @param[currentFlags]. + */ + fun testJvmFlagsFor(project: Project, context: KobaltContext, currentFlags: List) : List +} + diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ITestRunnerContributor.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ITestRunnerContributor.kt index 52bc9551..b8b860f6 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ITestRunnerContributor.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ITestRunnerContributor.kt @@ -7,8 +7,9 @@ import com.beust.kobalt.TaskResult */ interface ITestRunnerContributor : IContributor, IProjectAffinity { /** - * Run the project. + * Run the tests. If [[configName]] is not empty, a specific test configuration is requested. */ - fun run(project: Project, context: KobaltContext, classpath: List) : TaskResult + fun run(project: Project, context: KobaltContext, configName: String, + classpath: List) : TaskResult } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ITestSourceDirectoryContributor.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ITestSourceDirectoryContributor.kt index d88ca197..646d9dd2 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ITestSourceDirectoryContributor.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ITestSourceDirectoryContributor.kt @@ -3,9 +3,16 @@ package com.beust.kobalt.api import java.io.File /** - * Plug-ins that add tets source directories to be compiled need to implement this interface. + * Plug-ins that add test source directories to be compiled need to implement this interface. */ -interface ITestSourceDirectoryContributor { +interface ITestSourceDirectoryContributor : IContributor { fun testSourceDirectoriesFor(project: Project, context: KobaltContext): List } +fun KobaltContext.testSourceDirectories(project: Project) : List { + val result = pluginInfo.testSourceDirContributors.flatMap { + it.testSourceDirectoriesFor(project, this) + } + return result +} + diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/InputStreamJarTemplate.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/InputStreamJarTemplate.kt new file mode 100644 index 00000000..222a2829 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/InputStreamJarTemplate.kt @@ -0,0 +1,55 @@ +package com.beust.kobalt.api + +import com.beust.kobalt.Args +import com.beust.kobalt.misc.KFiles +import com.beust.kobalt.misc.kobaltLog +import java.io.* +import java.net.URL +import java.util.jar.JarInputStream + +/** + * Base class for templates that decompress a jar file. + */ +interface InputStreamJarTemplate : ITemplate { + val inputStream: InputStream + + override fun generateTemplate(args: Args, classLoader: ClassLoader) { + val destDir = File(".") + JarInputStream(inputStream).use { ins -> + var entry = ins.nextEntry + while (entry != null) { + val f = File(destDir.path + File.separator + entry.name) + if (entry.isDirectory) { + f.mkdir() + entry = ins.nextEntry + continue + } + + kobaltLog(2, " Extracting: $entry to ${f.absolutePath}") + FileOutputStream(f).use { fos -> + KFiles.copy(ins, fos) + } + entry = ins.nextEntry + } + } + } +} + +abstract class ResourceJarTemplate(jarName: String, val classLoader: ClassLoader) : InputStreamJarTemplate { + override val inputStream : InputStream = classLoader.getResource(jarName).openConnection().inputStream +} + +abstract class FileJarTemplate(val fileName: String) : InputStreamJarTemplate { + override val inputStream = FileInputStream(File(fileName)) +} + +abstract class HttpJarTemplate(val url: String) : InputStreamJarTemplate { + override val inputStream : InputStream + get() { + try { + return URL(url).openConnection().inputStream + } catch(ex: IOException) { + throw IllegalArgumentException("Couldn't connect to $url") + } + } +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/JarFinder.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/JarFinder.kt index 829cae53..08f08924 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/JarFinder.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/JarFinder.kt @@ -1,20 +1,15 @@ package com.beust.kobalt.api -import com.beust.kobalt.maven.DepFactory -import com.beust.kobalt.misc.KobaltExecutors +import com.beust.kobalt.maven.DependencyManager import java.io.File import java.util.concurrent.Future -public class JarFinder { +class JarFinder { companion object { /** * @return a Future for the jar file corresponding to this id. */ - fun byIdFuture(id: String) : Future { - val executor = Kobalt.INJECTOR.getInstance(KobaltExecutors::class.java).miscExecutor - val depFactory = Kobalt.INJECTOR.getInstance(DepFactory::class.java) - return depFactory.create(id, executor).jarFile - } + fun byIdFuture(id: String) : Future = DependencyManager.create(id).jarFile /** * @return the jar file corresponding to this id. This might cause a network call. diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/Kobalt.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/Kobalt.kt index 930f5d8a..7d37a0b8 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/Kobalt.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/Kobalt.kt @@ -3,27 +3,81 @@ package com.beust.kobalt.api import com.beust.kobalt.Constants import com.beust.kobalt.HostConfig import com.beust.kobalt.Plugins +import com.beust.kobalt.internal.PluginInfo +import com.beust.kobalt.maven.DependencyManager +import com.beust.kobalt.maven.aether.KobaltMavenResolver +import com.google.inject.Guice import com.google.inject.Injector +import com.google.inject.Module import java.io.InputStream +import java.time.Duration import java.util.* -public class Kobalt { +class Kobalt { companion object { - // This injector will eventually be replaced with a different injector initialized with the - // correct arguments (or with a TestModule) but it's necessary to give it a default value - // here so the kobalt-plugin.xml file can be read since this is done very early lateinit var INJECTOR : Injector + fun init(module: Module) { + Kobalt.INJECTOR = Guice.createInjector(module) + + // + // Add all the plugins read in kobalt-plugin.xml to the Plugins singleton, so that code + // in the build file that calls Plugins.findPlugin() can find them (code in the + // build file do not have access to the KobaltContext). + // + val pluginInfo = Kobalt.INJECTOR.getInstance(PluginInfo::class.java) + pluginInfo.plugins.forEach { Plugins.addPluginInstance(it) } + } + var context: KobaltContext? = null - val repos = HashSet(Constants.DEFAULT_REPOS.map { HostConfig(it) }) + /** + * @return the repos calculated from various places where repos can be specified. + */ + val repos : Set + get() { + val settingsRepos = Kobalt.context?.settings?.defaultRepos?.map { HostConfig(it) } ?: emptyList() + // Repos from in the settings + val result = ArrayList( + (if (settingsRepos.isEmpty()) Constants.DEFAULT_REPOS + else settingsRepos) + ) - fun addRepo(repo: HostConfig) = repos.add( + // Repo from in the settings + Kobalt.context?.settings?.kobaltCompilerRepo?.let { + result.add(HostConfig(it)) + } + + // Repos from the repo contributors + Kobalt.context?.pluginInfo?.repoContributors?.forEach { + result.addAll(it.reposFor(null)) + } + + // Repos from the build file + result.addAll(reposFromBuildFiles) + + result.forEach { + KobaltMavenResolver.initAuthentication(it) + } + return result.toHashSet() + } + + val reposFromBuildFiles = hashSetOf() + + fun addRepo(repo: HostConfig) = reposFromBuildFiles.add( if (repo.url.endsWith("/")) repo else repo.copy(url = (repo.url + "/"))) - private val PROPERTY_KOBALT_VERSION = "kobalt.version" + val buildFileClasspath = arrayListOf() + + fun addBuildFileClasspath(dep: String) { + val dependencyManager = Kobalt.INJECTOR.getInstance(DependencyManager::class.java) + buildFileClasspath.add(dependencyManager.create(dep)) + } + private val KOBALT_PROPERTIES = "kobalt.properties" + private val PROPERTY_KOBALT_VERSION = "kobalt.version" + private val PROPERTY_KOBALT_VERSION_CHECK_TIMEOUT = "kobalt.version.checkTimeout" // ISO-8601 /** kobalt.properties */ private val kobaltProperties: Properties by lazy { readProperties() } @@ -60,8 +114,28 @@ public class Kobalt { properties.forEach { es -> System.setProperty(es.key.toString(), es.value.toString()) } } - val version = kobaltProperties.getProperty(PROPERTY_KOBALT_VERSION) + val version: String + get() = kobaltProperties.getProperty(PROPERTY_KOBALT_VERSION) + + // Note: Duration is Java 8 only, might need an alternative if we want to support Java < 8 + val versionCheckTimeout: Duration + get() = Duration.parse( kobaltProperties.getProperty(PROPERTY_KOBALT_VERSION_CHECK_TIMEOUT) ?: "P1D") fun findPlugin(name: String) = Plugins.findPlugin(name) + + val optionsFromBuild = arrayListOf() + fun addKobaltOptions(options: Array) { + optionsFromBuild.addAll(options) + } + + val buildSourceDirs = arrayListOf() + fun addBuildSourceDirs(dirs: Array) { + buildSourceDirs.addAll(dirs) + } + + fun cleanUp() { + buildSourceDirs.clear() + buildFileClasspath.clear() + } } } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/KobaltContext.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/KobaltContext.kt index 896ca753..b7e5ace8 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/KobaltContext.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/KobaltContext.kt @@ -1,24 +1,77 @@ package com.beust.kobalt.api import com.beust.kobalt.Args +import com.beust.kobalt.KobaltException import com.beust.kobalt.Plugins import com.beust.kobalt.Variant +import com.beust.kobalt.internal.ILogger +import com.beust.kobalt.internal.IncrementalManager +import com.beust.kobalt.internal.KobaltSettings import com.beust.kobalt.internal.PluginInfo import com.beust.kobalt.maven.DependencyManager +import com.beust.kobalt.maven.MavenId +import com.beust.kobalt.maven.PomGenerator +import com.beust.kobalt.maven.SimpleDep +import com.beust.kobalt.maven.aether.KobaltMavenResolver import com.beust.kobalt.misc.KobaltExecutors +import java.io.File -public class KobaltContext(val args: Args) { - var variant: Variant = Variant() +class KobaltContext(val args: Args) { + lateinit var variant: Variant val profiles = arrayListOf() init { - args.profiles?.split(",")?.filterNotNull()?.forEach { + args.profiles?.split(',')?.filterNotNull()?.forEach { profiles.add(it) } } fun findPlugin(name: String) = Plugins.findPlugin(name) + /** + * Files that can be resolved in the local cache. + */ + enum class FileType { JAR, POM, SOURCES, JAVADOC, OTHER } + + /** + * @param{id} is the Maven coordinate (e.g. "org.testng:testng:6.9.11"). If you are looking for a file + * that is not described by the enum (e.g. "aar"), use OTHER and make sure your @param{id} contains + * the fully qualified id (e.g. "com.example:example::aar:1.0"). + */ + fun fileFor(id: String, fileType: FileType) : File { + val dep = SimpleDep(MavenId.create(id)) + fun toQualifier(dep: SimpleDep, ext: String, qualifier: String?) = + dep.groupId + ":" + dep.artifactId + + ":$ext" + + (if (qualifier != null) ":$qualifier" else "") + + ":" + dep.version + val fullId = + when (fileType) { + FileType.JAR -> toQualifier(dep, "jar", null) + FileType.POM -> toQualifier(dep, "pom", null) + FileType.SOURCES -> toQualifier(dep, "", "sources") + FileType.JAVADOC -> toQualifier(dep, "", "javadoc") + FileType.OTHER -> id + } + val resolved = resolver.resolveToArtifact(fullId) + if (resolved != null) { + return resolved.file + } else { + throw KobaltException("Couldn't resolve $id") + } + } + + /** + * @return the content of the pom.xml for the given project. + */ + fun generatePom(project: Project) = pomGeneratorFactory.create(project).generate() + + /** All the projects that are being built during this run */ + val allProjects = arrayListOf() + + /** For internal use only */ + val internalContext = InternalContext() + // // Injected // @@ -26,5 +79,38 @@ public class KobaltContext(val args: Args) { lateinit var pluginProperties: PluginProperties lateinit var dependencyManager: DependencyManager lateinit var executors: KobaltExecutors + lateinit var settings: KobaltSettings + lateinit var incrementalManager: IncrementalManager + lateinit var resolver: KobaltMavenResolver + lateinit var pomGeneratorFactory: PomGenerator.IFactory + lateinit var logger: ILogger } +class InternalContext { + /** + * When an incremental task decides it's up to date, it sets this boolean to true so that subsequent + * tasks in that project can be skipped as well. This is an internal field that should only be set by Kobalt. + */ + private val incrementalSuccesses = hashSetOf() + fun previousTaskWasIncrementalSuccess(projectName: String) = incrementalSuccesses.contains(projectName) ?: false + fun setIncrementalSuccess(projectName: String) = incrementalSuccesses.add(projectName) + + /** + * Keep track of whether the build file was modified. If this boolean is true, incremental compilation + * will be disabled. + */ + var buildFileOutOfDate: Boolean = false + + /** + * The absolute directory of the current project. + */ + var absoluteDir: File? = null + + /** + * If true, will force a recompile of the files even if using the incremental compile + */ + var forceRecompile: Boolean = false + + var noIncrementalKotlin: Boolean = false + +} \ No newline at end of file diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/PluginTask.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/PluginTask.kt index be0994fa..b416f96b 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/PluginTask.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/PluginTask.kt @@ -1,16 +1,20 @@ package com.beust.kobalt.api import com.beust.kobalt.internal.TaskResult2 -import com.beust.kobalt.misc.toString import java.util.concurrent.Callable -abstract public class PluginTask : Callable> { - abstract val plugin: IPlugin - open val name: String = "" - open val doc: String = "" - abstract val project: Project - - override public fun toString() : String { - return toString("PluginTask", "id", project.name + ":" + name) - } +interface ITask : Callable> { + val plugin: IPlugin + val project: Project + val name: String + val doc: String + val group: String +} + +abstract class PluginTask : ITask { + override val name: String = "" + override open val doc: String = "" + override open val group: String = "other" + + override fun toString() = project.name + ":" + name } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ProductFlavorConfig.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ProductFlavorConfig.kt new file mode 100644 index 00000000..86c69301 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ProductFlavorConfig.kt @@ -0,0 +1,9 @@ +package com.beust.kobalt.api + +class ProductFlavorConfig(val name: String) : IBuildConfig, + IDependencyHolder by DependencyHolder() { + var applicationId: String? = null + override var buildConfig : BuildConfig? = BuildConfig() +} + + diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/Project.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/Project.kt index b5de85d1..e54e30ec 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/Project.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/Project.kt @@ -1,41 +1,69 @@ package com.beust.kobalt.api +import com.beust.kobalt.TestConfig import com.beust.kobalt.api.annotation.Directive -import com.beust.kobalt.internal.IProjectInfo -import com.beust.kobalt.maven.dependency.MavenDependency +import com.beust.kobalt.maven.DependencyManager +import com.beust.kobalt.maven.aether.AetherDependency +import com.beust.kobalt.maven.aether.KobaltMavenResolver import com.beust.kobalt.misc.KFiles +import com.beust.kobalt.misc.kobaltLog +import org.apache.maven.model.Model +import java.io.File import java.util.* +import java.util.concurrent.Future +import java.util.concurrent.FutureTask +import java.util.regex.Pattern open class Project( - @Directive open var name: String, + @Directive open var name: String = "", @Directive open var version: String? = null, @Directive open var directory: String = ".", @Directive open var buildDirectory: String = KFiles.KOBALT_BUILD_DIR, @Directive open var group: String? = null, @Directive open var artifactId: String? = null, @Directive open var packaging: String? = null, - @Directive open var dependencies: Dependencies? = null, - @Directive open var sourceSuffix : String = "", @Directive open var description : String = "", - @Directive open var scm : Scm? = null, @Directive open var url: String? = null, - @Directive open var licenses: List = arrayListOf(), - @Directive open var packageName: String? = group, - val projectInfo: IProjectInfo) : IBuildConfig { + @Directive open var pom: Model? = null, + @Directive open var dependsOn: ArrayList = arrayListOf(), + @Directive open var testsDependOn: ArrayList = arrayListOf(), + @Directive open var packageName: String? = group) + : IBuildConfig, IDependencyHolder by DependencyHolder() { - override var buildConfig : BuildConfig? = null //BuildConfig() + init { + this.project = this + } - val testArgs = arrayListOf() - val testJvmArgs = arrayListOf() + fun allProjectDependedOn() = project.dependsOn + project.testsDependOn + + class ProjectExtra(project: Project) { + var isDirty = false + + /** + * @return true if any of the projects we depend on is dirty. + */ + fun dependsOnDirtyProjects(project: Project) = project.allProjectDependedOn().any { it.projectExtra.isDirty } + } + + /** + * This field caches a bunch of things we don't want to recalculate all the time, such as the list of suffixes + * found in this project. + */ + val projectExtra = ProjectExtra(this) + + val testConfigs = arrayListOf() + + // If one is specified by default, we only generateAndSave a BuildConfig, find a way to fix that + override var buildConfig : BuildConfig? = null // BuildConfig() val projectProperties = ProjectProperties() - override fun equals(other: Any?): Boolean { - return name == (other as Project).name - } + override fun equals(other: Any?) = name == (other as Project).name + override fun hashCode() = name.hashCode() - override fun hashCode(): Int { - return name.hashCode() + companion object { + val DEFAULT_SOURCE_DIRECTORIES = setOf("src/main/java", "src/main/kotlin", "src/main/resources") + val DEFAULT_SOURCE_DIRECTORIES_TEST = setOf("src/test/java", "src/test/kotlin", "src/test/resources") } // @@ -44,49 +72,27 @@ open class Project( @Directive fun sourceDirectories(init: Sources.() -> Unit) : Sources { - val sources = Sources(this, sourceDirectories) - sources.init() - return sources + return Sources(this, sourceDirectories).apply { init() } } - var sourceDirectories : HashSet = hashSetOf() - get() = if (field.isEmpty()) projectInfo.defaultSourceDirectories else field - set(value) { - field = value - } + var sourceDirectories = hashSetOf().apply { addAll(DEFAULT_SOURCE_DIRECTORIES)} @Directive fun sourceDirectoriesTest(init: Sources.() -> Unit) : Sources { - val sources = Sources(this, sourceDirectoriesTest) - sources.init() - return sources + return Sources(this, sourceDirectoriesTest).apply { init() } } - var sourceDirectoriesTest : HashSet = hashSetOf() - get() = if (field.isEmpty()) projectInfo.defaultTestDirectories - else field - set(value) { - field = value - } + var sourceDirectoriesTest = hashSetOf().apply { addAll(DEFAULT_SOURCE_DIRECTORIES_TEST)} // // Dependencies // - @Directive - fun dependencies(init: Dependencies.() -> Unit) : Dependencies { - dependencies = Dependencies(this, compileDependencies, compileProvidedDependencies, compileRuntimeDependencies) - dependencies!!.init() - return dependencies!! - } - - val compileDependencies : ArrayList = arrayListOf() - val compileProvidedDependencies : ArrayList = arrayListOf() - val compileRuntimeDependencies : ArrayList = arrayListOf() - @Directive fun dependenciesTest(init: Dependencies.() -> Unit) : Dependencies { - dependencies = Dependencies(this, testDependencies, testProvidedDependencies, compileRuntimeDependencies) + dependencies = Dependencies(this, testDependencies, arrayListOf(), + testProvidedDependencies, compileOnlyDependencies, compileRuntimeDependencies, + excludedDependencies, nativeDependencies) dependencies!!.init() return dependencies!! } @@ -94,6 +100,9 @@ open class Project( val testDependencies : ArrayList = arrayListOf() val testProvidedDependencies : ArrayList = arrayListOf() + fun testsDependOn(vararg projects: Project) = testsDependOn.addAll(projects) + fun dependsOn(vararg projects: Project) = dependsOn.addAll(projects) + /** Used to disambiguate various name properties */ @Directive val projectName: String get() = name @@ -104,6 +113,8 @@ open class Project( productFlavors.put(name, pf) } + var defaultConfig : BuildConfig? = null + val buildTypes = hashMapOf() fun addBuildType(name: String, bt: BuildTypeConfig) { @@ -117,6 +128,20 @@ open class Project( }) return result } + + class Dep(val file: File, val id: String) + + /** + * @return a list of the transitive dependencies (absolute paths to jar files) for the given dependencies. + * Can be used for example as `collect(compileDependencies)`. + */ + @Directive + fun collect(dependencies: List) : List { + return (Kobalt.context?.dependencyManager?.transitiveClosure(dependencies) ?: emptyList()) + .map { Dep(it.jarFile.get(), it.id) } + } + + override fun toString() = "[Project $name]" } class Sources(val project: Project, val sources: HashSet) { @@ -126,39 +151,130 @@ class Sources(val project: Project, val sources: HashSet) { } } -class Dependencies(val project: Project, val dependencies: ArrayList, +class Dependencies(val project: Project, + val dependencies: ArrayList, + val optionalDependencies: ArrayList, val providedDependencies: ArrayList, - val runtimeDependencies: ArrayList) { + val compileOnlyDependencies: ArrayList, + val runtimeDependencies: ArrayList, + val excludedDependencies: ArrayList, + val nativeDependencies: ArrayList) { + + /** + * Add the dependencies to the given ArrayList and return a list of future jar files corresponding to + * these dependencies. Futures are necessary here since this code is invoked from the build file and + * we might not have set up the extra IRepositoryContributors just yet. By the time these + * future tasks receive a get(), the repos will be correct. + */ + private fun addToDependencies(project: Project, dependencies: ArrayList, + dep: Array, optional: Boolean = false, excludeConfig: ExcludeConfig? = null): List> + = with(dep.map { + val resolved = + if (KobaltMavenResolver.isRangeVersion(it)) { + // Range id + val node = Kobalt.INJECTOR.getInstance(KobaltMavenResolver::class.java).resolveToArtifact(it) + val result = KobaltMavenResolver.artifactToId(node) + kobaltLog(2, "Resolved range id $it to $result") + result + } else { + it + } + DependencyManager.create(resolved, optional, project.directory) + }) { + dependencies.addAll(this) + if (excludeConfig != null) { + this.forEach { it.excluded.add(excludeConfig) } + } + + this.map { FutureTask { it.jarFile.get() } } + } + @Directive - fun compile(vararg dep: String) { - dep.forEach { dependencies.add(MavenDependency.create(it)) } + fun compile(vararg dep: String) = addToDependencies(project, dependencies, dep) + + class ExcludeConfig { + val ids = arrayListOf() + + @Directive + fun exclude(vararg passedIds: String) = ids.addAll(passedIds) + + class ArtifactConfig( + var groupId: String? = null, + var artifactId: String? = null, + var version: String? = null + ) + + val artifacts = arrayListOf() + + @Directive + fun exclude(groupId: String? = null, artifactId: String? = null, version: String? = null) + = artifacts.add(ArtifactConfig(groupId, artifactId, version)) + + fun match(pattern: String?, id: String) : Boolean { + return pattern == null || Pattern.compile(pattern).matcher(id).matches() + } + + /** + * @return true if the dependency is excluded with any of the exclude() directives. The matches + * are performed by a regular expression match against the dependency. + */ + fun isExcluded(dep: IClasspathDependency) : Boolean { + // Straight id match + var result = ids.any { match(it, dep.id) } + + // Match on any combination of (groupId, artifactId, version) + if (! result && dep.isMaven) { + val mavenDep = dep as AetherDependency + val artifact = mavenDep.artifact + result = artifacts.any { + val match1 = it.groupId == null || match(it.groupId, artifact.groupId) + val match2 = it.artifactId == null || match(it.artifactId, artifact.artifactId) + val match3 = it.version == null || match(it.version, artifact.version) + match1 && match2 && match3 + } + } + + return result + } + } + + @Directive + fun compile(dep: String, init: ExcludeConfig.() -> Unit) { + val excludeConfig = ExcludeConfig().apply { + init() + } + addToDependencies(project, dependencies, arrayOf(dep), excludeConfig = excludeConfig) + } + + @Directive + fun compileOnly(vararg dep: String) = addToDependencies(project, compileOnlyDependencies, dep) + + @Directive + fun compileOptional(vararg dep: String) { + addToDependencies(project, optionalDependencies, dep, optional = true) + addToDependencies(project, dependencies, dep, optional = true) } @Directive fun provided(vararg dep: String) { - dep.forEach { providedDependencies.add(MavenDependency.create(it))} + addToDependencies(project, providedDependencies, dep) } @Directive - fun runtime(vararg dep: String) { - dep.forEach { runtimeDependencies.add(MavenDependency.create(it))} - } -} + fun runtime(vararg dep: String) = addToDependencies(project, runtimeDependencies, dep) -class Scm(val connection: String, val developerConnection: String, val url: String) - -class License(val name: String, val url: String) { - fun toMavenLicense() : org.apache.maven.model.License { - val result = org.apache.maven.model.License() - result.name = name - result.url = url - return result - } + @Directive + fun exclude(vararg dep: String) = addToDependencies(project, excludedDependencies, dep) + @Directive + fun native(vararg dep: String) = addToDependencies(project, nativeDependencies, dep) } class BuildConfig { - class Field(val name: String, val type: String, val value: Any) + class Field(val name: String, val type: String, val value: Any) { + override fun hashCode() = name.hashCode() + override fun equals(other: Any?) = (other as Field).name == name + } val fields = arrayListOf() @@ -177,32 +293,22 @@ interface IBuildConfig { } } -class ProductFlavorConfig(val name: String) : IBuildConfig { - var applicationId: String? = null - override var buildConfig : BuildConfig? = BuildConfig() +fun Project.defaultConfig(init: BuildConfig.() -> Unit) = let { project -> + BuildConfig().apply { + init() + project.defaultConfig = this + } } +@Directive +fun Project.buildType(name: String, init: BuildTypeConfig.() -> Unit) = BuildTypeConfig(name).apply { + init() + addBuildType(name, this) +} + + @Directive fun Project.productFlavor(name: String, init: ProductFlavorConfig.() -> Unit) = ProductFlavorConfig(name).apply { - init() - addProductFlavor(name, this) - } - -class BuildTypeConfig(val project: Project?, val name: String) : IBuildConfig { - var minifyEnabled = false - var applicationIdSuffix: String? = null - var proguardFile: String? = null - -// fun getDefaultProguardFile(name: String) : String { -// val androidPlugin = Plugins.findPlugin(AndroidPlugin.PLUGIN_NAME) as AndroidPlugin -// return Proguard(androidPlugin.androidHome(project)).getDefaultProguardFile(name) -// } - - override var buildConfig : BuildConfig? = BuildConfig() + init() + addProductFlavor(name, this) } - -@Directive -fun Project.buildType(name: String, init: BuildTypeConfig.() -> Unit) = BuildTypeConfig(this, name).apply { - init() - addBuildType(name, this) - } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/Task.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/Task.kt index c1586211..c45a820d 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/Task.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/Task.kt @@ -2,8 +2,6 @@ package com.beust.kobalt.api import com.beust.kobalt.misc.toString -data public class Task(val pluginName: String, val taskName: String) { - override public fun toString() : String { - return toString("Task", pluginName, taskName) - } -} \ No newline at end of file +data class Task(val pluginName: String, val taskName: String) { + override fun toString() = toString("Task", pluginName, taskName) +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/TaskContributor.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/TaskContributor.kt index b90926d9..8c68be94 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/TaskContributor.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/TaskContributor.kt @@ -1,13 +1,18 @@ package com.beust.kobalt.api +import com.beust.kobalt.IncrementalTaskInfo import com.beust.kobalt.TaskResult import com.beust.kobalt.Variant +import com.beust.kobalt.api.annotation.AnnotationDefault +import com.beust.kobalt.internal.IncrementalManager +import com.google.inject.Inject /** * Plug-ins that are ITaskContributor can use this class to manage their collection of tasks and * implement the interface by delegating to an instance of this class (if injection permits). */ -class TaskContributor : ITaskContributor { +class TaskContributor @Inject constructor(val incrementalManagerFactory: IncrementalManager.IFactory) + : ITaskContributor { val dynamicTasks = arrayListOf() /** @@ -19,16 +24,19 @@ class TaskContributor : ITaskContributor { * depends on variants of that task. */ fun addVariantTasks(plugin: IPlugin, project: Project, context: KobaltContext, taskName: String, + group: String = AnnotationDefault.GROUP, + dependsOn: List = emptyList(), + reverseDependsOn : List = emptyList(), runBefore : List = emptyList(), runAfter : List = emptyList(), - alwaysRunAfter : List = emptyList(), runTask: (Project) -> TaskResult) { Variant.allVariants(project).forEach { variant -> val variantTaskName = variant.toTask(taskName) - dynamicTasks.add(DynamicTask(plugin, variantTaskName, variantTaskName, + dynamicTasks.add(DynamicTask(plugin, variantTaskName, variantTaskName, group, project, + dependsOn = dependsOn.map { variant.toTask(it) }, + reverseDependsOn = reverseDependsOn.map { variant.toTask(it) }, runBefore = runBefore.map { variant.toTask(it) }, runAfter = runAfter.map { variant.toTask(it) }, - alwaysRunAfter = alwaysRunAfter.map { variant.toTask(it) }, closure = { p: Project -> context.variant = variant runTask(project) @@ -36,5 +44,43 @@ class TaskContributor : ITaskContributor { } } - override fun tasksFor(context: KobaltContext) : List = dynamicTasks + fun addTask(plugin: IPlugin, project: Project, taskName: String, description: String, + group: String = AnnotationDefault.GROUP, + dependsOn: List = emptyList(), + reverseDependsOn : List = emptyList(), + runBefore : List = emptyList(), + runAfter : List = emptyList(), + alwaysRunAfter: List = emptyList(), + runTask: (Project) -> TaskResult) { + dynamicTasks.add(DynamicTask(plugin, taskName, description, group, project, + dependsOn = dependsOn, + reverseDependsOn = reverseDependsOn, + runBefore = runBefore, + runAfter = runAfter, + alwaysRunAfter = alwaysRunAfter, + closure = { p: Project -> + runTask(project) + })) + } + + fun addIncrementalVariantTasks(plugin: IPlugin, project: Project, context: KobaltContext, taskName: String, + group: String = AnnotationDefault.GROUP, + dependsOn: List = emptyList(), + reverseDependsOn : List = emptyList(), + runBefore : List = emptyList(), + runAfter : List = emptyList(), + runTask: (Project) -> IncrementalTaskInfo) { + Variant.allVariants(project).forEach { variant -> + val variantTaskName = variant.toTask(taskName) + context.variant = variant + dynamicTasks.add(DynamicTask(plugin, variantTaskName, variantTaskName, group, project, + dependsOn = dependsOn.map { variant.toTask(it) }, + reverseDependsOn = reverseDependsOn.map { variant.toTask(it) }, + runBefore = runBefore.map { variant.toTask(it) }, + runAfter = runAfter.map { variant.toTask(it) }, + closure = incrementalManagerFactory.create().toIncrementalTaskClosure(taskName, runTask, variant))) + } + } + + override fun tasksFor(project: Project, context: KobaltContext) : List = dynamicTasks } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/annotation/Annotations.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/annotation/Annotations.kt index 5488be5a..f4269d47 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/annotation/Annotations.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/annotation/Annotations.kt @@ -6,33 +6,61 @@ package com.beust.kobalt.api.annotation */ annotation class Directive +object AnnotationDefault { + const val GROUP = "other" +} + @Retention(AnnotationRetention.RUNTIME) annotation class Task( + /* This task's name */ val name: String, + + /* The documentation for this task */ val description: String = "", - /** Tasks that this task depends on */ + /** Used to show the task in the correct group in the IDE */ + val group: String = AnnotationDefault.GROUP, + + /** Dependency: tasks this task depends on */ + val dependsOn: Array = arrayOf(), + + /** Dependency: tasks this task will be made dependend upon */ + val reverseDependsOn: Array = arrayOf(), + + /** Ordering: tasks that need to be run before this one */ val runBefore: Array = arrayOf(), - /** Tasks that this task will run after if they get run */ + /** Ordering: tasks this task runs after */ val runAfter: Array = arrayOf(), - /** Tasks that this task will always run after */ + /** Wrapper tasks */ val alwaysRunAfter: Array = arrayOf() ) @Retention(AnnotationRetention.RUNTIME) annotation class IncrementalTask( + /* This task's name */ val name: String, + + /* The documentation for this task */ val description: String = "", + /** Used to show the task in the correct group in the IDE */ + val group: String = AnnotationDefault.GROUP, + + /** Dependency: tasks this task depends on */ + val dependsOn: Array = arrayOf(), + + /** Dependency: tasks this task will be made dependend upon */ + val reverseDependsOn: Array = arrayOf(), + /** Tasks that this task depends on */ val runBefore: Array = arrayOf(), - /** Tasks that this task will run after if they get run */ + /** Ordering: tasks this task runs after */ val runAfter: Array = arrayOf(), - /** Tasks that this task will always run after */ + /** Wrapper tasks */ val alwaysRunAfter: Array = arrayOf() ) diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/archive/Archives.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/archive/Archives.kt new file mode 100644 index 00000000..5334e09f --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/archive/Archives.kt @@ -0,0 +1,83 @@ +package com.beust.kobalt.archive + +import com.beust.kobalt.* +import com.beust.kobalt.api.KobaltContext +import com.beust.kobalt.api.Project +import com.beust.kobalt.api.annotation.ExportedProjectProperty +import com.beust.kobalt.misc.JarUtils +import com.beust.kobalt.misc.KFiles +import com.beust.kobalt.misc.kobaltLog +import java.io.File +import java.util.* + +class Archives { + companion object { + @ExportedProjectProperty(doc = "The name of the jar file", type = "String") + const val JAR_NAME = "jarName" + @ExportedProjectProperty(doc = "The name of the a jar file with a main() method", type = "String") + const val JAR_NAME_WITH_MAIN_CLASS = "jarNameWithMainClass" + + fun defaultArchiveName(project: Project) = project.name + + if (project.version.isNullOrBlank()) "" else "-${project.version}" + + fun generateArchive(project: Project, + context: KobaltContext, + archiveName: String?, + suffix: String, + includedFiles: List, + expandJarFiles : Boolean = false, + manifest: java.util.jar.Manifest? = null) : File { + val fullArchiveName = context.variant.archiveName(project, archiveName, suffix) + val archiveDir = File(KFiles.libsDir(project)) + val result = File(archiveDir.path, fullArchiveName) + context.logger.log(project.name, 3, "Creating $result") + if (! Features.USE_TIMESTAMPS || isOutdated(project.directory, includedFiles, result)) { + try { + MetaArchive(result, manifest).use { metaArchive -> + JarUtils.addFiles(project.directory, includedFiles, metaArchive, expandJarFiles) + context.logger.log(project.name, 2, "Added ${includedFiles.size} files to $result") + context.logger.log(project.name, 1, " Created $result") + } + } catch (e: Throwable) { + // make sure that incomplete archive is deleted + // otherwise incremental build does not work on next run + result.delete() + throw e + } + + } else { + context.logger.log(project.name, 3, " $result is up to date") + } + + return result + } + + private fun isOutdated(directory: String, includedFiles: List, output: File): Boolean { + if (! output.exists()) return true + + val lastModified = output.lastModified() + includedFiles.forEach { root -> + val allFiles = root.allFromFiles(directory) + allFiles.forEach { relFile -> + val file = if (relFile.isAbsolute) + relFile // e.g. jar file or classes folder (of another project) when building a fat jar + else + File(KFiles.joinDir(directory, root.from, relFile.path)) + if (file.isFile) { + if (file.lastModified() > lastModified) { + kobaltLog(3, " TS - Outdated $file and $output " + + Date(file.lastModified()) + " " + Date(output.lastModified())) + return true + } + } else if (file.isDirectory) { + // e.g. classes folder (of another project) when building a fat jar + val includedFile = IncludedFile(From(""), To(""), listOf(IFileSpec.GlobSpec("**"))) + if (isOutdated(file.absolutePath, listOf(includedFile), output)) + return true + } + } + } + return false + } + } +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/archive/AttributeHolder.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/archive/AttributeHolder.kt new file mode 100644 index 00000000..4abffb21 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/archive/AttributeHolder.kt @@ -0,0 +1,6 @@ +package com.beust.kobalt.archive + +interface AttributeHolder { + fun addAttribute(k: String, v: String) +} + diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/archive/Jar.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/archive/Jar.kt new file mode 100644 index 00000000..d5086cbd --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/archive/Jar.kt @@ -0,0 +1,28 @@ +package com.beust.kobalt.archive + +import com.beust.kobalt.api.Project +import com.beust.kobalt.api.annotation.Directive + +/** + * A jar is exactly like a zip with the addition of a manifest and an optional fatJar boolean. + */ +open class Jar(override val project: Project, + override var name : String = Archives.defaultArchiveName(project) + ".jar", + override var fatJar: Boolean = false) : Zip(project, name, fatJar), AttributeHolder { + @Directive + fun manifest(init: Manifest.(p: Manifest) -> Unit) : Manifest { + val m = Manifest(this) + m.init(m) + return m + } + + // Need to specify the version or attributes will just be dropped + @Directive + override val attributes = arrayListOf(Pair("Manifest-Version", "1.0")) + + override fun addAttribute(k: String, v: String) { + attributes.add(Pair(k, v)) + } +} + + diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/archive/Manifest.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/archive/Manifest.kt new file mode 100644 index 00000000..1771dbe8 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/archive/Manifest.kt @@ -0,0 +1,11 @@ +package com.beust.kobalt.archive + +import com.beust.kobalt.api.annotation.Directive + +class Manifest(val jar: AttributeHolder) { + @Directive + fun attributes(k: String, v: String) { + jar.addAttribute(k, v) + } +} + diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/archive/MetaArchive.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/archive/MetaArchive.kt new file mode 100644 index 00000000..c217c83e --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/archive/MetaArchive.kt @@ -0,0 +1,125 @@ +package com.beust.kobalt.archive + +import com.beust.kobalt.Glob +import com.beust.kobalt.misc.KFiles +import org.apache.commons.compress.archivers.ArchiveEntry +import org.apache.commons.compress.archivers.zip.ZipArchiveEntry +import org.apache.commons.compress.archivers.zip.ZipArchiveOutputStream +import java.io.Closeable +import java.io.File +import java.io.FileInputStream +import java.io.FileOutputStream +import java.util.jar.Manifest +import org.apache.commons.compress.archivers.zip.ZipFile as ApacheZipFile + +/** + * Abstraction of a zip/jar/war archive that automatically manages the addition of expanded jar files. + * Uses ZipArchiveOutputStream for fast inclusion of expanded jar files. + */ +class MetaArchive(outputFile: File, val manifest: Manifest?) : Closeable { + companion object { + const val MANIFEST_MF = "META-INF/MANIFEST.MF" + } + + private val zos= ZipArchiveOutputStream(outputFile).apply { + encoding = "UTF-8" + } + + init { + // If no manifest was passed, create an empty one so it's the first one in the archive + val m = manifest ?: Manifest() + val manifestFile = File.createTempFile("kobalt", "tmpManifest") + addEntry(ZipArchiveEntry("META-INF/"), null) + if (manifest != null) { + FileOutputStream(manifestFile).use { fos -> + m.write(fos) + } + } + val entry = zos.createArchiveEntry(manifestFile, MetaArchive.MANIFEST_MF) + addEntry(entry, FileInputStream(manifestFile)) + } + + + fun addFile(f: File, entryFile: File, path: String?) { + maybeCreateParentDirectories(f) + addFile2(f, entryFile, path) + } + + private fun addFile2(f: File, entryFile: File, path: String?) { + val file = f.normalize() + FileInputStream(file).use { inputStream -> + val actualPath = KFiles.fixSlashes(if (path != null) path + entryFile.path else entryFile.path) + ZipArchiveEntry(actualPath).let { entry -> + maybeCreateParentDirectories(File(actualPath)) + maybeAddEntry(entry) { + addEntry(entry, inputStream) + } + } + } + } + + private val createdDirs = hashSetOf() + + /** + * For an entry a/b/c/File, an entry needs to be created for each individual directory: + * a/ + * a/b/ + * a/b/c + * a/b/c/File + */ + private fun maybeCreateParentDirectories(file: File) { + val toCreate = arrayListOf() + var current = file.parentFile + while (current != null && current.path != ".") { + if (!createdDirs.contains(current.path)) { + toCreate.add(0, KFiles.fixSlashes(current) + "/") + createdDirs.add(current.path) + } + current = current.parentFile + } + toCreate.forEach { dir -> + addEntry(ZipArchiveEntry(dir), null) + } + } + + fun addArchive(jarFile: File) { + ApacheZipFile(jarFile).use { jar -> + val jarEntries = jar.entries + for (entry in jarEntries) { + maybeAddEntry(entry) { + zos.addRawArchiveEntry(entry, jar.getRawInputStream(entry)) + } + } + } + } + + + + private fun okToAdd(name: String) : Boolean { + val result = !KFiles.isExcluded(name, + Glob("META-INF/*.SF", "META-INF/*.DSA", "META-INF/*.RSA", MANIFEST_MF)) +// if (name.startsWith("META-INF")) println((if (result) "ADDING" else "NOT ADDING") + " $name") + return result + } + + override fun close() = zos.close() + + private fun addEntry(entry: ArchiveEntry, inputStream: FileInputStream?) { + zos.putArchiveEntry(entry) + inputStream?.use { ins -> + ins.copyTo(zos, 50 * 1024) + } + zos.closeArchiveEntry() + } + + private val seen = hashSetOf() + + private fun maybeAddEntry(entry: ArchiveEntry, action:() -> Unit) { + entry.name.let { name -> + if (!seen.contains(name) && okToAdd(name)) { + action() + } + seen.add(name) + } + } +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/archive/War.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/archive/War.kt new file mode 100644 index 00000000..978f21bf --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/archive/War.kt @@ -0,0 +1,13 @@ +package com.beust.kobalt.archive + +import com.beust.kobalt.api.Project +import com.beust.kobalt.glob + +class War(override val project: Project, override var name: String = Archives.defaultArchiveName(project) + ".war") + : Jar(project, name), AttributeHolder { + init { + include(from("src/main/webapp"), to(""), glob("**")) + include(from("kobaltBuild/classes"), to("WEB-INF/classes"), glob("**")) + } +} + diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/archive/Zip.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/archive/Zip.kt new file mode 100644 index 00000000..41957218 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/archive/Zip.kt @@ -0,0 +1,27 @@ +package com.beust.kobalt.archive + +import com.beust.kobalt.* +import com.beust.kobalt.api.Project +import com.beust.kobalt.api.annotation.Directive + +open class Zip(open val project: Project, open var name: String = Archives.defaultArchiveName(project) + ".zip", + open var fatJar: Boolean = false): AttributeHolder, IncludeFromTo() { + val excludes = arrayListOf() + + @Directive + fun exclude(vararg files: String) { + files.forEach { excludes.add(Glob(it)) } + } + + @Directive + fun exclude(vararg specs: Glob) { + specs.forEach { excludes.add(it) } + } + + @Directive + open val attributes = arrayListOf(Pair("Manifest-Version", "1.0")) + + override fun addAttribute(k: String, v: String) { + attributes.add(Pair(k, v)) + } +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/ActorUtils.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/ActorUtils.kt index 6216ecfb..e9b315a5 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/ActorUtils.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/ActorUtils.kt @@ -1,7 +1,6 @@ package com.beust.kobalt.internal import com.beust.kobalt.api.IProjectAffinity -import com.beust.kobalt.api.ISimpleAffinity import com.beust.kobalt.api.KobaltContext import com.beust.kobalt.api.Project @@ -11,12 +10,13 @@ class ActorUtils { * Return the plug-in actor with the highest affinity. */ fun selectAffinityActor(project: Project, context: KobaltContext, actors: List) - = actors.maxBy { it.affinity(project, context) } + = actors.maxBy { it.affinity(project, context) } /** - * Return the plug-in actor with the highest affinity. + * Return all the plug-in actors with a non zero affinity sorted from the highest to the lowest. */ - fun , A> selectAffinityActor(actors: List, arg: A) = actors.maxBy { it.affinity(arg) } + fun selectAffinityActors(project: Project, context: KobaltContext, actors: List) + = actors.filter { it.affinity(project, context) > 0 } + .sortedByDescending { it.affinity(project, context) } } - } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/BaseJvmPlugin.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/BaseJvmPlugin.kt new file mode 100644 index 00000000..e89fc9aa --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/BaseJvmPlugin.kt @@ -0,0 +1,37 @@ +package com.beust.kobalt.internal + +import com.beust.kobalt.api.* +import com.beust.kobalt.misc.KFiles + +/** + * Base class for JVM language plug-ins. + */ +abstract class BaseJvmPlugin(open val configActor: ConfigActor) : + BasePlugin(), + IConfigActor by configActor, + ICompilerFlagContributor { + companion object { + // Run before other flag contributors + val FLAG_CONTRIBUTOR_PRIORITY = FlagContributor.DEFAULT_FLAG_PRIORITY - 10 + } + + protected fun maybeCompilerArgs(sourceSuffixes: List, suffixesBeingCompiled: List, + args: List) + = if (sourceSuffixes.any { suffixesBeingCompiled.contains(it) }) args else emptyList() + + override val flagPriority = FLAG_CONTRIBUTOR_PRIORITY + + override fun accept(project: Project) = sourceFileCount(project) > 0 + + // IBuildConfigContributor + protected fun sourceFileCount(project: Project) + = KFiles.findSourceFiles(project.directory, project.sourceDirectories, sourceSuffixes()).size + + KFiles.findSourceFiles(project.directory, project.sourceDirectoriesTest, sourceSuffixes()).size + + fun affinity(project: Project) = sourceFileCount(project) + + // IDocContributor + open fun affinity(project: Project, context: KobaltContext) = sourceFileCount(project) + + abstract fun sourceSuffixes() : List +} \ No newline at end of file diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/BaseProjectRunner.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/BaseProjectRunner.kt new file mode 100644 index 00000000..963255bd --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/BaseProjectRunner.kt @@ -0,0 +1,186 @@ +package com.beust.kobalt.internal + +import com.beust.kobalt.TestResult +import com.beust.kobalt.api.IBuildListener +import com.beust.kobalt.api.KobaltContext +import com.beust.kobalt.api.Project +import com.beust.kobalt.api.ProjectBuildStatus +import com.beust.kobalt.misc.kobaltLog +import com.google.common.annotations.VisibleForTesting +import com.google.common.collect.ArrayListMultimap +import com.google.common.collect.Multimap +import java.util.* + +abstract class BaseProjectRunner { + + abstract fun runProjects(taskInfos: List, projects: List) + : TaskManager.RunTargetResult + + companion object { + val TAG = "graph" + + fun runBuildListenersForProject(project: Project, context: KobaltContext, start: Boolean, + status: ProjectBuildStatus = ProjectBuildStatus.SUCCESS) { + context.pluginInfo.buildListeners.forEach { + if (start) it.projectStart(project, context) else it.projectEnd(project, context, status) + } + } + + fun runBuildListenersForTask(project: Project, context: KobaltContext, taskName: String, start: Boolean, + success: Boolean = false, testResult: TestResult? = null) { + context.pluginInfo.buildListeners.forEach { + if (start) { + it.taskStart(project, context, taskName) + } else { + val info = IBuildListener.TaskEndInfo(success, testResult?.shortMessage, testResult?.longMessage) + it.taskEnd(project, context, taskName, info) + } + } + } + + /** + * Create a graph representing the tasks and their dependencies. That graph will then be run + * in topological order. + * + * @taskNames is the list of tasks requested by the user. @nodeMap maps these tasks to the nodes + * we'll be adding to the graph while @toName extracts the name of a node. + */ + @VisibleForTesting + fun createTaskGraph(projectName: String, passedTasks: List, + nodeMap: Multimap, + dependsOn: Multimap, + reverseDependsOn: Multimap, + runBefore: Multimap, + runAfter: Multimap, + alwaysRunAfter: Multimap, + toName: (T) -> String, + accept: (T) -> Boolean): + DynamicGraph { + + /** + * Add an edge from @param from to all its tasks. + */ + fun addEdge(result: DynamicGraph, from: String, to: String, newToProcess: ArrayList, text: String) { + val froms = nodeMap[from] + froms.forEach { f: T -> + nodeMap[to].forEach { t: T -> + kobaltLog(TAG, " Adding edge ($text) $f -> $t") + result.addEdge(f, t) + newToProcess.add(t) + } + } + } + + val result = DynamicGraph() + val newToProcess = arrayListOf() + val seen = hashSetOf() + + // + // Reverse the always map so that tasks can be looked up. + // + val always = ArrayListMultimap.create().apply { + alwaysRunAfter.keySet().forEach { k -> + alwaysRunAfter[k].forEach { v -> + put(v, k) + } + } + } + + // + // Keep only the tasks we need to run. + // + val taskInfos = passedTasks.filter { + it.matches(projectName) + } + + // The nodes we need to process, initialized with the set of tasks requested by the user. + // As we run the graph and discover dependencies, new nodes get added to @param[newToProcess]. At + // the end of the loop, @param[toProcess] is cleared and all the new nodes get added to it. Then we loop. + val toProcess = ArrayList(taskInfos) + + while (toProcess.size > 0) { + + /** + * Whenever a task is added to the graph, we also add its alwaysRunAfter tasks. + */ + fun processAlways(always: Multimap, node: T) { + kobaltLog(TAG, " Processing always for $node") + always[toName(node)]?.let { to: Collection -> + to.forEach { t -> + nodeMap[t].forEach { from -> + kobaltLog(TAG, " Adding always edge $from -> $node") + result.addEdge(from, node) + } + } + kobaltLog(TAG, " ... done processing always for $node") + } + } + + kobaltLog(TAG, " Current batch to process: $toProcess") + + // + // Move dependsOn + reverseDependsOn in one multimap called allDepends + // + val allDependsOn = ArrayListMultimap.create() + dependsOn.keySet().forEach { key -> + dependsOn[key].forEach { value -> + allDependsOn.put(key, value) + } + } + reverseDependsOn.keySet().forEach { key -> + reverseDependsOn[key].forEach { value -> + allDependsOn.put(value, key) + } + } + + // + // Process each node one by one + // + toProcess.forEach { taskInfo -> + val taskName = taskInfo.taskName + kobaltLog(TAG, " ***** Current node: $taskName") + nodeMap[taskName].forEach { + result.addNode(it) + processAlways(always, it) + } + + // + // dependsOn and reverseDependsOn are considered for all tasks, explicit and implicit + // + allDependsOn[taskName].forEach { to -> + addEdge(result, taskName, to, newToProcess, "dependsOn") + } + + seen.add(taskName) + } + + newToProcess.forEach { processAlways(always, it) } + + toProcess.clear() + toProcess.addAll( + newToProcess + .filter { !seen.contains(toName(it)) } + .map { TaskManager.TaskInfo(toName(it)) }) + newToProcess.clear() + } + + // + // Now that we have all the tasks tnat need to run, process runBefore/runAfter, which + // are not allowed to add new tasks. Therefore, we only add edges to the graph if both + // the from and the to are already present. + // + val finalTaskNames = result.nodes.map { TaskManager.TaskInfo(it.toString()).taskName } + finalTaskNames.forEach { taskName -> + runBefore[taskName].filter { finalTaskNames.contains(it) }.forEach { from -> + addEdge(result, from, taskName, newToProcess, "runBefore") + } + runAfter[taskName].filter { finalTaskNames.contains(it) }.forEach { to -> + addEdge(result, to, taskName, newToProcess, "runAfter") + } + } + + + return result + } + } +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/BuildListeners.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/BuildListeners.kt new file mode 100644 index 00000000..58d8eed8 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/BuildListeners.kt @@ -0,0 +1,128 @@ +package com.beust.kobalt.internal + +import com.beust.kobalt.Args +import com.beust.kobalt.AsciiArt +import com.beust.kobalt.api.* +import com.beust.kobalt.misc.kobaltLog +import java.util.concurrent.ConcurrentHashMap + +/** + * Record timings and statuses for tasks and projects and display them at the end of the build. + */ +class BuildListeners : IBuildListener, IBuildReportContributor { + class ProfilerInfo(val taskName: String, val durationMillis: Long) + class ProjectInfo(val projectName: String, var durationMillis: Long = 0, + var shortMessage: String? = null, var longMessage: String? = null) + + private val startTimes = ConcurrentHashMap() + private val timings = arrayListOf() + private val projectInfos = hashMapOf() + private var hasFailures = false + private val args: Args get() = Kobalt.INJECTOR.getInstance(Args::class.java) + private var buildStartTime: Long? = null + + // IBuildListener + override fun taskStart(project: Project, context: KobaltContext, taskName: String) { + startTimes.put(taskName, System.currentTimeMillis()) + if (! projectInfos.containsKey(project.name)) { + projectInfos.put(project.name, ProjectInfo(project.name)) + } + } + + // IBuildListener + override fun taskEnd(project: Project, context: KobaltContext, taskName: String, info: IBuildListener.TaskEndInfo) { + val success = info.success + if (! success) hasFailures = true + startTimes[taskName]?.let { + val taskTime = System.currentTimeMillis() - it + timings.add(ProfilerInfo(taskName, taskTime)) + projectInfos[project.name]?.let { + it.durationMillis += taskTime + if (info.shortMessage != null && it.shortMessage == null) it.shortMessage = info.shortMessage + if (info.longMessage != null && it.longMessage == null) it.longMessage = info.longMessage + } + } + } + + private val projectStatuses = arrayListOf>() + + // IBuildListener + override fun projectStart(project: Project, context: KobaltContext) { + if (buildStartTime == null) buildStartTime = System.currentTimeMillis() + } + + // IBuildListener + override fun projectEnd(project: Project, context: KobaltContext, status: ProjectBuildStatus) { + val shortMessage = projectInfos[project.name]?.shortMessage + val statusText = status.toString() + (if (shortMessage != null) " ($shortMessage)" else "") + projectStatuses.add(Pair(project, statusText)) + } + + // IBuildReportContributor + override fun generateReport(context: KobaltContext) { + fun formatMillis(millis: Long, format: String) = String.format(format, millis.toDouble() / 1000) + fun formatMillisRight(millis: Long, length: Int) = formatMillis(millis, "%1\$$length.2f") + fun formatMillisLeft(millis: Long, length: Int) = formatMillis(millis, "%1\$-$length.2f") + + fun millisToSeconds(millis: Long) = (millis.toDouble() / 1000).toInt() + + val profiling = args.profiling + if (profiling) { + kobaltLog(1, "\n" + AsciiArt.horizontalSingleLine + " Timings (in seconds)") + timings.sortedByDescending { it.durationMillis }.forEach { + kobaltLog(1, formatMillisRight(it.durationMillis, 10) + " " + it.taskName) + } + kobaltLog(1, "\n") + + } + + // Calculate the longest short message so we can create a column long enough to contain it + val width = 12 + (projectInfos.values.map { it.shortMessage?.length ?: 0 }.maxBy { it } ?: 0) + + fun col1(s: String) = String.format(" %1\$-30s", s) + fun col2(s: String) = String.format(" %1\$-${width}s", s) + fun col3(s: String) = String.format(" %1\$-8s", s) + + + + // Only print the build report if there is more than one project and at least one of them failed + if (timings.any()) { +// if (timings.size > 1 && hasFailures) { + val line = listOf(col1("Project"), col2("Build status"), col3("Time")) + .joinToString(AsciiArt.verticalBar) + val table = StringBuffer() + table.append(AsciiArt.logBox(listOf(line), AsciiArt.bottomLeft2, AsciiArt.bottomRight2, indent = 10) + "\n") + projectStatuses.forEach { pair -> + val projectName = pair.first.name + val cl = listOf(col1(projectName), col2(pair.second), + col3(formatMillisLeft(projectInfos[projectName]!!.durationMillis, 8))) + .joinToString(AsciiArt.verticalBar) + table.append(" " + AsciiArt.verticalBar + " " + cl + " " + AsciiArt.verticalBar + "\n") + } + table.append(" " + AsciiArt.lowerBox(line.length)) + kobaltLog(1, table.toString()) +// } + } + + val buildTime = + if (buildStartTime != null) + millisToSeconds(System.currentTimeMillis() - buildStartTime!!) + else + 0 + // BUILD SUCCESSFUL / FAILED message + val message = + if (hasFailures) { + String.format("BUILD FAILED", buildTime) + } else if (! args.sequential) { + val sequentialBuildTime = ((projectInfos.values.sumByDouble { it.durationMillis.toDouble() }) / 1000) + .toInt() + String.format("PARALLEL BUILD SUCCESSFUL (%d SECONDS), sequential build would have taken %d seconds", + buildTime, sequentialBuildTime) + } else { + String.format("BUILD SUCCESSFUL (%d SECONDS)", buildTime) + } + kobaltLog(1, message) + + } + +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/CollectionUtils.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/CollectionUtils.kt new file mode 100644 index 00000000..62258d62 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/CollectionUtils.kt @@ -0,0 +1,14 @@ +package com.beust.kobalt.internal + +fun Collection.doWhile(condition: (T) -> Boolean, action: (T) -> Unit) { + var i = 0 + var done = false + while (i < size && ! done) { + elementAt(i).let { element -> + if (! condition(element)) done = true + else action(element) + } + i++ + } +} + diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/CompilerUtils.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/CompilerUtils.kt new file mode 100644 index 00000000..758a10e9 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/CompilerUtils.kt @@ -0,0 +1,232 @@ +package com.beust.kobalt.internal + +import com.beust.kobalt.TaskResult +import com.beust.kobalt.api.* +import com.beust.kobalt.maven.DependencyManager +import com.beust.kobalt.maven.aether.Scope +import com.beust.kobalt.maven.dependency.FileDependency +import com.beust.kobalt.misc.KFiles +import com.google.inject.Inject +import java.io.File +import java.nio.file.Paths +import java.util.* + +/** + * Central place to compile files, used by plug-ins and non plug-ins. + */ +class CompilerUtils @Inject constructor(val files: KFiles, val dependencyManager: DependencyManager) { + + class CompilerResult(val successResults: List, val failedResult: TaskResult?) + + fun invokeCompiler(project: Project, context: KobaltContext, compiler: ICompilerDescription, + sourceDirectories: List, isTest: Boolean, buildDirectory: File): CompilerResult { + val results = arrayListOf() + var failedResult: TaskResult? = null + val contributedSourceDirs = + if (isTest) { + context.testSourceDirectories(project) + } else { + context.sourceDirectories(project) + } + val sourceFiles = KFiles.findSourceFiles(project.directory, + contributedSourceDirs.map { it.path }, compiler.sourceSuffixes) + if (sourceFiles.isNotEmpty()) { + // TODO: createCompilerActionInfo recalculates the source files, only compute them + // once and pass them + val info = createCompilerActionInfo(project, context, compiler, isTest, + sourceDirectories, sourceSuffixes = compiler.sourceSuffixes, buildDirectory = buildDirectory) + val thisResult = invokeCompiler(project, context, compiler, info) + results.addAll(thisResult.successResults) + if (failedResult == null) { + failedResult = thisResult.failedResult + } + } else { + context.logger.log(project.name, 2, + "${compiler.name} compiler not running on ${project.name} since no source files were found") + } + + return CompilerResult(results, failedResult) + } + + fun invokeCompiler(project: Project, context: KobaltContext, compiler: ICompilerDescription, info: CompilerActionInfo) + : CompilerResult { + val results = arrayListOf() + var failedResult: TaskResult? = null + val thisResult = compiler.compile(project, context, info) + results.add(thisResult) + if (!thisResult.success && failedResult == null) { + failedResult = thisResult + } + return CompilerResult(results, failedResult) + } + + /** + * Create a CompilerActionInfo (all the information that a compiler needs to know) for the given parameters. + * Runs all the contributors and interceptors relevant to that task. + */ + fun createCompilerActionInfo(project: Project, context: KobaltContext, compiler: ICompilerDescription, + isTest: Boolean, sourceDirectories: List, sourceSuffixes: List, buildDirectory: File) + : CompilerActionInfo { + copyResources(project, context, SourceSet.of(isTest)) + + val fullClasspath = dependencyManager.calculateDependencies(project, context, + scopes = if (isTest) { + listOf(Scope.COMPILE, Scope.COMPILEONLY, Scope.TEST) + } else { + listOf(Scope.COMPILE, Scope.COMPILEONLY) + }) + + + File(project.directory, buildDirectory.path).mkdirs() + + // Remove all the excluded dependencies from the classpath + var classpath = fullClasspath + + // The classpath needs to contain $buildDirectory/classes as well so that projects that contain + // multiple languages can use classes compiled by the compiler run before them. + fun containsClassFiles(dir: File) = + KFiles.containsCertainFile(dir) { + it.isFile && it.name.endsWith("class") + } + +// if (buildDirectory.exists()) { + if (containsClassFiles(buildDirectory)) { + classpath += FileDependency(buildDirectory.path) + } + + val initialSourceDirectories = ArrayList(sourceDirectories) + // Source directories from the contributors + val contributedSourceDirs = + if (isTest) { + context.pluginInfo.testSourceDirContributors.flatMap { it.testSourceDirectoriesFor(project, context) } + } else { + context.pluginInfo.sourceDirContributors.flatMap { it.sourceDirectoriesFor(project, context) } + } + + initialSourceDirectories.addAll(contributedSourceDirs) + + // Transform them with the interceptors, if any + val allSourceDirectories = + if (isTest) { + initialSourceDirectories + } else { + context.pluginInfo.sourceDirectoriesInterceptors.fold(initialSourceDirectories.toList(), + { sd, interceptor -> interceptor.intercept(project, context, sd) }) + }.filter { + File(project.directory, it.path).exists() + }.filter { + ! KFiles.isResource(it.path) + }.distinctBy { + Paths.get(it.path) + } + + // Now that we have all the source directories, find all the source files in them. Note that + // depending on the compiler's ability, sourceFiles can actually contain a list of directories + // instead of individual source files. + val projectDirectory = File(project.directory) + val sourceFiles = + if (compiler.canCompileDirectories) { + allSourceDirectories.map { File(projectDirectory, it.path).path } + } else { + files.findRecursively(projectDirectory, allSourceDirectories, + { file -> sourceSuffixes.any { file.endsWith(it) } }) + .map { File(projectDirectory, it).path } + } + + // Special treatment if we are compiling Kotlin files and the project also has a java source + // directory. In this case, also pass that java source directory to the Kotlin compiler as is + // so that it can parse its symbols + // Note: this should actually be queried on the compiler object so that this method, which + // is compiler agnostic, doesn't hardcode Kotlin specific stuff + val extraSourceFiles = arrayListOf() + + fun containsJavaFiles(dir: File) = + KFiles.containsCertainFile(dir) { + it.isFile && it.name.endsWith("java") + } + + if (sourceSuffixes.any { it.contains("kt")}) { + val directories = if (isTest) project.sourceDirectoriesTest else project.sourceDirectories + directories.forEach { + val javaDir = File(KFiles.joinDir(project.directory, it)) + if (javaDir.exists() && containsJavaFiles(javaDir) && ! KFiles.isResource(javaDir.path)) { + extraSourceFiles.add(javaDir.path) + // Add all the source directories contributed as potential Java directories too + // (except our own) + context.pluginInfo.sourceDirContributors.forEach { + val sd = it.sourceDirectoriesFor(project, context).map { it.path } + .filter { ! it.contains("kotlin") } + if (! sd.contains("kotlin")) { + extraSourceFiles.addAll(sd) + } + } + } + } + } + + val distinctSources = (sourceFiles + extraSourceFiles).distinctBy { File(it).toURI().normalize().path } + val allSources = distinctSources + .map { File(it).path } + .distinct() + .filter { File(it).exists() } + + // Finally, alter the info with the compiler interceptors before returning it + val initialActionInfo = CompilerActionInfo(projectDirectory.path, classpath, allSources, + sourceSuffixes, buildDirectory, emptyList() /* the flags will be provided by flag contributors */, + emptyList(), context.internalContext.forceRecompile) + val result = context.pluginInfo.compilerInterceptors.fold(initialActionInfo, { ai, interceptor -> + interceptor.intercept(project, context, ai) + }) + + // + // friendPaths + // + val friendPaths = KFiles.joinDir(project.buildDirectory, KFiles.CLASSES_DIR) + + return result + } + + /** + * Copy the resources from a source directory to the build one + */ + private fun copyResources(project: Project, context: KobaltContext, sourceSet: SourceSet) { + val outputDir = sourceSet.outputDir + + val variantSourceDirs = context.variant.resourceDirectories(project, sourceSet) + if (variantSourceDirs.isNotEmpty()) { + context.logger.log(project.name, 2, "Copying $sourceSet resources") + val absOutputDir = File(KFiles.joinDir(project.directory, project.buildDirectory, outputDir)) + variantSourceDirs + .map { File(project.directory, it.path) } + .filter(File::exists) + .forEach { + context.logger.log(project.name, 2, "Copying from $it to $absOutputDir") + KFiles.copyRecursively(it, absOutputDir, replaceExisting = true) + } + } else { + context.logger.log(project.name, 2, "No resources to copy for $sourceSet") + } + } + + fun sourceCompilerFlags(project: Project?, context: KobaltContext, info: CompilerActionInfo) : List { + val adapters = context.pluginInfo.compilerFlagContributors.map { + val closure = { project: Project, context: KobaltContext, currentFlags: List, + suffixesBeingCompiled: List + -> it.compilerFlagsFor(project, context, currentFlags, suffixesBeingCompiled) } + FlagContributor(it.flagPriority, closure) + } + return compilerFlags(project, context, info, adapters) + } + + fun compilerFlags(project: Project?, context: KobaltContext, info: CompilerActionInfo, + adapters: List) : List { + val result = arrayListOf() + if (project != null) { + adapters.sortedBy { it.flagPriority } + adapters.forEach { + result.addAll(it.flagsFor(project, context, result, info.suffixesBeingCompiled)) + } + } + return result + } +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/DocUrl.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/DocUrl.kt index 8acab0ab..93010294 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/DocUrl.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/DocUrl.kt @@ -2,7 +2,7 @@ package com.beust.kobalt.internal class DocUrl { companion object { - private const val HOST = "http://beust.com/kobalt/" + private const val HOST = "https://beust.com/kobalt/" private fun url(path: String) = HOST + path val PUBLISH_PLUGIN_URL = url("plug-ins/index.html#publishing") diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/DynamicGraph.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/DynamicGraph.kt index a0d22bdb..a3e26afd 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/DynamicGraph.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/DynamicGraph.kt @@ -1,32 +1,177 @@ package com.beust.kobalt.internal -import com.beust.kobalt.KobaltException -import com.beust.kobalt.TaskResult -import com.beust.kobalt.misc.NamedThreadFactory -import com.beust.kobalt.misc.error -import com.beust.kobalt.misc.log -import com.beust.kobalt.misc.toString +import com.beust.kobalt.* +import com.beust.kobalt.misc.* import com.google.common.collect.HashMultimap import java.lang.reflect.InvocationTargetException +import java.util.* import java.util.concurrent.* -open class TaskResult2(success: Boolean, errorMessage: String?, val value: T) : TaskResult(success, errorMessage) { - override fun toString() = toString("TaskResult", "value", value, "success", success) +open class TaskResult2(success: Boolean, testResult: TestResult? = null, + errorMessage: String? = null, val value: T) : TaskResult(success, testResult, errorMessage) { + override fun toString() = com.beust.kobalt.misc.toString("TaskResult", "value", value, "success", success) } -public interface IWorker : Callable> { +class DynamicGraph { + val VERBOSE = 3 + val values : Collection get() = nodes.map { it.value } + val nodes = hashSetOf>() + private val dependedUpon = HashMultimap.create, PrivateNode>() + private val dependingOn = HashMultimap.create, PrivateNode>() + + class PrivateNode(val value: T) { + override fun hashCode() = value!!.hashCode() + override fun equals(other: Any?) : Boolean { + val result = if (other is PrivateNode<*>) other.value == value else false + return result + } + override fun toString() = value.toString() + } + + companion object { + fun transitiveClosure(root: T, childrenFor: (T) -> List) : List { + val result = arrayListOf() + val seen = hashSetOf() + val toProcess = arrayListOf().apply { + add(root) + } + while (toProcess.any()) { + val newToProcess = arrayListOf() + toProcess.forEach { + if (! seen.contains(it)) { + result.add(it) + newToProcess.addAll(childrenFor(it)) + seen.add(it) + } + } + toProcess.clear() + toProcess.addAll(newToProcess) + } + return result + } + + class Node(val value: T, val children: List>) { + fun dump(root : Node = this, indent: String = "") : String { + return StringBuffer().apply { + append(indent).append(root.value).append("\n") + root.children.forEach { + append(dump(it, indent + " ")) + } + }.toString() + } + } + + fun transitiveClosureGraph(roots: List, childrenFor: (T) -> List, + filter: (T) -> Boolean): List> + = roots.map { transitiveClosureGraph(it, childrenFor, filter) } + + fun transitiveClosureGraph(root: T, childrenFor: (T) -> List, + filter: (T) -> Boolean = { t: T -> true }, + seen: HashSet = hashSetOf()) : Node { + val children = arrayListOf>() + childrenFor(root).filter(filter).forEach { child -> + if (! seen.contains(child)) { + seen.add(child) + val c = transitiveClosureGraph(child, childrenFor, filter, seen) + children.add(c) + } + } + return Node(root, children) + } + } + + fun childrenOf(v: T) : Collection = dependedUpon[PrivateNode(v)].map { it.value } + + fun transitiveClosure(root: T) + = transitiveClosure(root) { element -> dependedUpon[PrivateNode(element)].map { it.value } } + + fun addNode(t: T) = synchronized(nodes) { + nodes.add(PrivateNode(t)) + } + + fun removeNode(t: T) = synchronized(nodes) { + kobaltLog(VERBOSE, " Removing node $t") + PrivateNode(t).let { node -> + nodes.remove(node) + dependingOn.removeAll(node) + val set = dependedUpon.keySet() + val toReplace = arrayListOf, Collection>>>() + set.forEach { du -> + val l = ArrayList(dependedUpon[du]) + l.remove(node) + toReplace.add(Pair(du, l)) + } + toReplace.forEach { + dependedUpon.replaceValues(it.first, it.second) + } + } + } + + /** + * Make "from" depend on "to" ("from" is no longer free). + */ + fun addEdge(from: T, to: T) { + val fromNode = PrivateNode(from) + nodes.add(fromNode) + val toNode = PrivateNode(to) + nodes.add(PrivateNode(to)) + dependingOn.put(toNode, fromNode) + dependedUpon.put(fromNode, toNode) + } + + val freeNodes: Set + get() { + val nonFree = hashSetOf() + synchronized(nodes) { + nodes.forEach { + val du = dependedUpon[it] + if (du != null && du.size > 0) { + nonFree.add(it.value) + } + } + val result = nodes.map { it.value }.filter { !nonFree.contains(it) }.toHashSet() + kobaltLog(VERBOSE, " Free nodes: $result") + return result + } + } + + fun dump() : String { + val result = StringBuffer() + result.append("************ Graph dump ***************\n") + val free = arrayListOf>() + nodes.forEach { node -> + val d = dependedUpon.get(node) + if (d == null || d.isEmpty()) { + free.add(node) + } + } + + result.append("All nodes: $values\n").append("Free nodes: $free").append("\nDependent nodes:\n") + nodes.forEach { + val deps = dependedUpon.get(it) + if (! deps.isEmpty()) { + result.append(" $it -> $deps\n") + } + } + return result.toString() + } +} + +interface IWorker : Callable> { /** * @return list of tasks this worker is working on. */ // val tasks : List + val name: String + /** * @return the priority of this task. */ val priority : Int } -public interface IThreadWorkerFactory { +interface IThreadWorkerFactory { /** * Creates {@code IWorker} for specified set of tasks. It is not necessary that @@ -35,251 +180,229 @@ public interface IThreadWorkerFactory { * @param nodes tasks that need to be executed * @return list of workers */ - fun createWorkers(nodes: List) : List> + fun createWorkers(nodes: Collection) : List> } -public class DynamicGraphExecutor(val graph: DynamicGraph, - val factory: IThreadWorkerFactory) { - val executor = Executors.newFixedThreadPool(5, NamedThreadFactory("DynamicGraphExecutor")) +class DynamicGraphExecutor(val graph : DynamicGraph, val factory: IThreadWorkerFactory, + val threadCount: Int = 1) { + val executor : ExecutorService + = Executors.newFixedThreadPool(threadCount, NamedThreadFactory("DynamicGraphExecutor")) val completion = ExecutorCompletionService>(executor) - /** - * @return 0 if all went well, > 0 otherwise - */ - public fun run() : Int { - var lastResult = TaskResult() - var gotError = false - var nodesRunning = 0 - while (graph.freeNodes.size > 0 && ! gotError) { - log(3, "Current node count: ${graph.nodeCount}") - synchronized(graph) { - val freeNodes = graph.freeNodes - freeNodes.forEach { graph.setStatus(it, DynamicGraph.Status.RUNNING)} - log(3, " ==> Submitting " + freeNodes) - val callables : List> = factory.createWorkers(freeNodes) - callables.forEach { completion.submit(it) } - nodesRunning += callables.size + data class HistoryLog(val name: String, val timestamp: Long, val threadId: Long, val start: Boolean) - // When a callable ends, see if it freed a node. If not, keep looping - while (graph.nodesRunning.size > 0 && graph.freeNodes.size == 0 && ! gotError) { - try { - val future = completion.take() - val taskResult = future.get(2, TimeUnit.SECONDS) - lastResult = taskResult - log(3, " <== Received task result $taskResult") - graph.setStatus(taskResult.value, - if (taskResult.success) { - DynamicGraph.Status.FINISHED - } else { - DynamicGraph.Status.ERROR - }) - } catch(ex: TimeoutException) { - log(2, "Time out") - } catch(ex: Exception) { - if (ex.cause is InvocationTargetException) { - val ite = ex.cause - if (ite.targetException is KobaltException) { - throw (ex.cause as InvocationTargetException).targetException - } else { - error("Error: ${ite.cause?.message}", ite.cause) - gotError = true - } - } else { - error("Error: ${ex.message}", ex) - gotError = true - } + val historyLog = arrayListOf() + val threadIds = ConcurrentHashMap() + + fun run() : TaskResult { + try { + return run2() + } finally { + executor.shutdown() + } + } + + private fun run2() : TaskResult { + var running = 0 + val nodesRun = hashSetOf() + var failedResult: TaskResult? = null + val newFreeNodes = HashSet(graph.freeNodes) + while (failedResult == null && (running > 0 || newFreeNodes.size > 0)) { + nodesRun.addAll(newFreeNodes) + val callables : List> = factory.createWorkers(newFreeNodes).map { + it -> object: IWorker { + override val priority: Int + get() = it.priority + + override val name: String get() = it.name + override fun call(): TaskResult2 { + val threadId = Thread.currentThread().id + historyLog.add(HistoryLog(it.name, System.currentTimeMillis(), threadId, + start = true)) + threadIds.put(threadId, threadId) + val result = it.call() + historyLog.add(HistoryLog(it.name, System.currentTimeMillis(), Thread.currentThread().id, + start = false)) + return result } } } - } - executor.shutdown() - if (graph.freeNodes.size == 0 && graph.nodesReady.size > 0) { - throw KobaltException("Couldn't find any free nodes but a few nodes still haven't run, there is " + - "a cycle in the dependencies.\n Nodes left: " + graph.dump(graph.nodesReady)) - } - return if (lastResult.success) 0 else 1 - } -} + callables.forEach { completion.submit(it) } + running += callables.size -/** - * Representation of the graph of methods. - */ -public class DynamicGraph { - val nodesReady = linkedSetOf() - val nodesRunning = linkedSetOf() - private val nodesFinished = linkedSetOf() - private val nodesInError = linkedSetOf() - private val nodesSkipped = linkedSetOf() - private val dependedUpon = HashMultimap.create() - private val dependingOn = HashMultimap.create() - - /** - * Define a comparator for the nodes of this graph, which will be used - * to order the free nodes when they are asked. - */ -// public val comparator : Comparator? = null - - enum class Status { - READY, RUNNING, FINISHED, ERROR, SKIPPED - } - - /** - * Add a node to the graph. - */ - public fun addNode(value: T) : T { - nodes.add(value) - nodesReady.add(value) - return value - } - - /** - * Add an edge between two nodes, which don't have to already be in the graph - * (they will be added by this method). Makes "to" depend on "from". - */ - public fun addEdge(from: T, to: T) { - nodes.add(from) - nodes.add(to) - val fromNode = addNode(from) - val toNode = addNode(to) - dependingOn.put(toNode, fromNode) - dependedUpon.put(fromNode, toNode) - } - - /** - * @return a set of all the nodes that don't depend on any other nodes. - */ - public val freeNodes : List - get() { - val result = arrayListOf() - nodesReady.forEach { m -> - // A node is free if... - - val du = dependedUpon.get(m) - // - no other nodes depend on it - if (! dependedUpon.containsKey(m)) { - result.add(m) - } else if (getUnfinishedNodes(du).size == 0) { - result.add(m) + try { + val future = completion.take() + val taskResult = future.get(2, TimeUnit.SECONDS) + running-- + if (taskResult.success) { + nodesRun.add(taskResult.value) + kobaltLog(3, "Task succeeded: $taskResult") + graph.removeNode(taskResult.value) + newFreeNodes.clear() + newFreeNodes.addAll(graph.freeNodes.minus(nodesRun)) + } else { + kobaltLog(3, "Task failed: $taskResult") + newFreeNodes.clear() + if (failedResult == null) { + failedResult = taskResult + } + } + } catch(ex: TimeoutException) { + kobaltLog(3, "Time out") + } catch(ex: Exception) { + val ite = ex.cause + if (ite is InvocationTargetException) { + if (ite.targetException is KobaltException) { + throw (ex.cause as InvocationTargetException).targetException + } else { + error("Error: ${ite.cause?.message}", ite.cause) + failedResult = TaskResult(success = false, errorMessage = ite.cause?.message) + } + } else { + error("Error: ${ex.message}", ex) + failedResult = TaskResult(success = false, errorMessage = ex.message) } } + } + return if (failedResult != null) failedResult else TaskResult() + } - // Sort the free nodes if requested (e.g. priorities) -// if (! result.isEmpty()) { -// if (comparator != null) { -// Collections.sort(result, comparator) -// debug("Nodes after sorting:" + result.get(0)) -// } -// } + fun dumpHistory() { + kobaltLog(1, "Thread report") - log(3, " freeNodes: $result") - return result + val table = AsciiTable.Builder() + .columnWidth(11) + threadIds.keys.forEach { + table.columnWidth(24) + } + table.header("Time (sec)") + threadIds.keys.forEach { + table.header("Thread " + it.toString()) } - /** - * @return a list of all the nodes that have a status other than FINISHED. - */ - private fun getUnfinishedNodes(nodes: Set) : Collection { - val result = hashSetOf() - nodes.forEach { node -> - if (nodesReady.contains(node) || nodesRunning.contains(node)) { - result.add(node); + fun toSeconds(millis: Long) = (millis / 1000).toInt().toString() + + fun displayCompressedLog(table: AsciiTable.Builder) : AsciiTable.Builder { + data class CompressedLog(val timestamp: Long, val threadMap: HashMap) + + fun compressLog(historyLog: List): ArrayList { + val compressed = arrayListOf() + + var currentLog: CompressedLog? = null + + val projectStart = hashMapOf() + fun toName(hl: HistoryLog) : String { + var duration = "" + if (! hl.start) { + val start = projectStart[hl.name] + if (start != null) { + duration = " (" + ((hl.timestamp - start) / 1000) + .toInt().toString() + ")" + } else { + kobaltLog(1, "DONOTCOMMIT") + } + } + return hl.name + duration + } + + historyLog.forEach { hl -> + kobaltLog(1, "CURRENT LOG: " + currentLog + " HISTORY LINE: " + hl) + if (hl.start) { + projectStart[hl.name] = hl.timestamp + } + if (currentLog == null) { + currentLog = CompressedLog(hl.timestamp, hashMapOf(hl.threadId to hl.name)) + } else currentLog?.let { cl -> + if (! hl.start || hl.timestamp - cl.timestamp < 1000) { + kobaltLog(1, " CURRENT LOG IS WITHING ONE SECOND: $hl") + cl.threadMap[hl.threadId] = toName(hl) + } else { + kobaltLog(1, " ADDING COMPRESSED LINE $cl") + compressed.add(cl) + currentLog = CompressedLog(hl.timestamp, hashMapOf(hl.threadId to toName(hl))) + } + } + } + return compressed } - } - return result; - } - /** - * Set the status for a set of nodes. - */ - public fun setStatus(nodes: Collection, status: Status) { - nodes.forEach { setStatus(it, status) } - } - - /** - * Mark all dependees of this node SKIPPED - */ - private fun setSkipStatus(node: T, status: Status) { - dependingOn.get(node).forEach { - if (! nodesSkipped.contains(it)) { - log(3, "Node skipped: $it") - nodesSkipped.add(it) - nodesReady.remove(it) - setSkipStatus(it, status) + compressLog(historyLog).forEach { + val row = arrayListOf() + row.add(toSeconds(it.timestamp)) + it.threadMap.values.forEach { + row.add(it) + } + table.addRow(row) } - } - } - /** - * Set the status for a node. - */ - public fun setStatus(node: T, status: Status) { - removeNode(node); - when(status) { - Status.READY -> nodesReady.add(node) - Status.RUNNING -> nodesRunning.add(node) - Status.FINISHED -> nodesFinished.add(node) - Status.ERROR -> { - log(3, "Node in error: $node") - nodesReady.remove(node) - nodesInError.add(node) - setSkipStatus(node, status) - } - else -> { - throw IllegalArgumentException() - } - } - } - - private fun removeNode(node: T) { - if (! nodesReady.remove(node)) { - if (! nodesRunning.remove(node)) { - nodesFinished.remove(node) - } - } - } - - /** - * @return the number of nodes in this graph. - */ - public val nodeCount: Int - get() = nodesReady.size + nodesRunning.size + nodesFinished.size - - override public fun toString() : String { - val result = StringBuilder("[DynamicGraph ") - result.append("\n Ready:" + nodesReady) - result.append("\n Running:" + nodesRunning) - result.append("\n Finished:" + nodesFinished) - result.append("\n Edges:\n") - // dependingOn.entrySet().forEach { es -> - // result.append(" " + es.getKey() + "\n"); - // es.getValue().forEach { t -> - // result.append(" " + t + "\n"); - // } - // } - result.append("]"); - return result.toString(); - } - - val nodes = hashSetOf() - - fun dump(nodes: Collection) : String { - val result = StringBuffer() - result.append("************ Graph dump ***************\n") - val free = arrayListOf() - nodes.forEach { node -> - val d = dependedUpon.get(node) - if (d == null || d.isEmpty()) { - free.add(node) + return table + } + + fun displayRegularLog(table: AsciiTable.Builder) : AsciiTable.Builder { + if (historyLog.any()) { + if (historyLog[0] != null) { + val start = historyLog[0].timestamp + val projectStart = ConcurrentHashMap() + historyLog.forEach { line -> + val row = arrayListOf() + row.add(toSeconds(line.timestamp - start)) + threadIds.keys.forEach { + if (line.threadId == it) { + var duration = "" + if (line.start) { + projectStart[line.name] = line.timestamp + } else { + val projectStart = projectStart[line.name] + if (projectStart != null) { + duration = " (" + ((line.timestamp - projectStart) / 1000) + .toInt().toString() + ")" + } else { + warn("Couldn't determine project start: " + line.name) + } + } + row.add((line.name + duration)) + } else { + row.add("") + } + } + table.addRow(row) + } + } else { + warn("Couldn't find historyLog") + } } + return table } - result.append("Free nodes: $free").append("\n Dependent nodes:\n") - nodes.forEach { - result.append(" $it -> ${dependedUpon.get(it)}\n") - } - return result.toString() + kobaltLog(1, displayRegularLog(table).build()) } - - fun dump() = dump(nodesReady) } +fun main(argv: Array) { + val dg = DynamicGraph().apply { + // a -> b + // b -> c, d + // e + addEdge("a", "b") + addEdge("b", "c") + addEdge("b", "d") + addNode("e") + } + val factory = object : IThreadWorkerFactory { + override fun createWorkers(nodes: Collection): List> { + return nodes.map { + object: IWorker { + override fun call(): TaskResult2? { + kobaltLog(1, " Running worker $it") + return TaskResult2(true, value = it) + } + + override val priority: Int get() = 0 + override val name: String = "workerName" + } + } + } + } + + DynamicGraphExecutor(dg, factory).run() +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/GenericRunner.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/GenericRunner.kt index e7b4756b..995dba53 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/GenericRunner.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/GenericRunner.kt @@ -1,87 +1,198 @@ package com.beust.kobalt.internal -import com.beust.kobalt.JavaInfo -import com.beust.kobalt.SystemProperties -import com.beust.kobalt.TaskResult +import com.beust.kobalt.* import com.beust.kobalt.api.* import com.beust.kobalt.misc.KFiles -import com.beust.kobalt.misc.log +import com.google.common.annotations.VisibleForTesting +import com.google.inject.Inject import java.io.File -import java.net.URLClassLoader +import java.util.* /** * Base class for testing frameworks that are invoked from a main class with arguments. Test runners can * subclass this class and override mainClass, args and the name of the dependency that should trigger this runner. */ -abstract class GenericTestRunner : ITestRunnerContributor { +abstract class GenericTestRunner: ITestRunnerContributor { abstract val dependencyName : String abstract val mainClass: String - abstract fun args(project: Project, classpath: List) : List + abstract val annotationPackage: String + abstract val runnerName: String + open var shortMessage: String? = null + open var longMessage: String? = null - override fun run(project: Project, context: KobaltContext, classpath: List) - = TaskResult(runTests(project, classpath)) + @Inject + private lateinit var jvm: Jvm - override fun affinity(project: Project, context: KobaltContext) = - if (project.testDependencies.any { it.id.contains(dependencyName)}) IAffinity.DEFAULT_POSITIVE_AFFINITY + abstract fun args(project: Project, context: KobaltContext, classpath: List, + testConfig: TestConfig) : List + + open fun onFinish(project: Project) {} + + open val extraClasspath: List = emptyList() + + open fun filterTestClasses(project: Project, context: KobaltContext, classes: List) : List = classes + + override fun run(project: Project, context: KobaltContext, configName: String, + classpath: List) : TaskResult { + val tr = runTests(project, context, classpath, configName) + return TaskResult(tr.success, testResult = tr) + } + + override fun affinity(project: Project, context: KobaltContext) : Int { + val result = + if (project.testDependencies.any { it.id.contains(dependencyName) }) IAffinity.DEFAULT_POSITIVE_AFFINITY else 0 - - protected fun findTestClasses(project: Project, classpath: List): List { - val path = KFiles.joinDir(project.directory, project.buildDirectory, KFiles.TEST_CLASSES_DIR) - val result = KFiles.findRecursively(File(path), arrayListOf(File(".")), { - file -> file.endsWith(".class") - }).map { - it.replace("/", ".").replace("\\", ".").replace(".class", "").substring(2) - }.filter { - try { - // Only keep classes with a parameterless constructor - val urls = arrayOf(File(path).toURI().toURL()) + - classpath.map { it.jarFile.get().toURI().toURL() } - URLClassLoader(urls).loadClass(it).getConstructor() - true - } catch(ex: Exception) { - log(2, "Skipping non test class $it: ${ex.message}") - false - } - } - - log(2, "Found ${result.size} test classes") return result } + protected fun findTestClasses(project: Project, context: KobaltContext, testConfig: TestConfig): List { + val testClassDir = KFiles.joinDir(project.buildDirectory, KFiles.TEST_CLASSES_DIR) + val path = testClassDir.apply { + File(this).mkdirs() + } + + val files = IFileSpec.GlobSpec(toClassPaths(testConfig.testIncludes)) + .toFiles(project.directory, path, testConfig.testExcludes.map { Glob(it) }) + val testClasses = files + .map { + File(KFiles.joinDir(project.directory, testClassDir, it.path)) + } + val result = testClasses.map { + val prefix = KFiles.joinDir(project.directory, testClassDir) + val className = it.toString().substring(prefix.length + 1) + .replace("/", ".").replace("\\", ".").replace(".class", "") + Pair(it, className) + } +// .filter { +// val result = acceptClass(it.first, it.second, testClasspath, File(testClassDir)) +// result +// } + + context.logger.log(project.name, 2, "Found ${result.size} test classes") + return filterTestClasses(project, context, result.map { it.second }) + } + + /** + * Accept the given class if it contains an annotation of the current test runner's package. Annotations + * are looked up on both the classes and methods. + */ +// private fun acceptClass(cf: File, className: String, testClasspath: List, +// testClassDir: File): Boolean { +// val cp = (testClasspath.map { it.jarFile.get() } + listOf(testClassDir)).map { it.toURI().toURL() } +// try { +// val cls = URLClassLoader(cp.toTypedArray()).loadClass(className) +// val ann = cls.annotations.filter { +// val qn = it.annotationClass.qualifiedName +// qn != null && qn.contains(annotationPackage) +// } +// if (ann.any()) { +// return true +// } else { +// val ann2 = cls.declaredMethods.flatMap { it.declaredAnnotations.toList() }.filter { it.toString() +// .contains(annotationPackage)} +// if (ann2.any()) { +// val a0 = ann2[0] +// return true +// } +// } +// } catch(ex: Throwable) { +// println("Exception: " + ex.message) +// return false +// } +// return false +// } + + private fun toClassPaths(paths: List): ArrayList = + paths.map { if (it.endsWith("class")) it else it + "class" }.toCollection(ArrayList()) + /** * @return true if all the tests passed */ - fun runTests(project: Project, classpath: List) : Boolean { - val jvm = JavaInfo.create(File(SystemProperties.javaBase)) - val java = jvm.javaExecutable - val args = args(project, classpath) - if (args.size > 0) { - val allArgs = arrayListOf().apply { - add(java!!.absolutePath) - addAll(project.testJvmArgs) - add("-classpath") - add(classpath.map { it.jarFile.get().absolutePath }.joinToString(File.pathSeparator)) - add(mainClass) - addAll(args) - } + open fun runTests(project: Project, context: KobaltContext, classpath: List, + configName: String) : TestResult { + var result = false - val pb = ProcessBuilder(allArgs) - pb.directory(File(project.directory)) - pb.inheritIO() - log(1, "Running tests with classpath size ${classpath.size}") - log(2, "Launching " + allArgs.joinToString(" ")) - val process = pb.start() - val errorCode = process.waitFor() - if (errorCode == 0) { - log(1, "All tests passed") + context.logger.log(project.name, 1, "Running tests with $runnerName") + + val testConfig = project.testConfigs.firstOrNull { it.name == configName } + + var errorCode = -1 + if (testConfig != null) { + val args = args(project, context, classpath, testConfig) + if (args.size > 0) { + + val java = jvm.javaExecutable + val jvmArgs = calculateAllJvmArgs(project, context, testConfig, classpath, + Kobalt.INJECTOR.getInstance (PluginInfo::class.java)) + val allArgs = arrayListOf().apply { + add(java!!.absolutePath) + addAll(jvmArgs) + add(mainClass) + addAll(args) + } + + val pb = ProcessBuilder(allArgs) + pb.directory(File(project.directory)) + pb.inheritIO() + context.logger.log(project.name, 2, "Running tests with classpath size ${classpath.size}") + context.logger.log(project.name, 2, "Launching " + allArgs.joinToString(" ")) + val process = pb.start() + errorCode = process.waitFor() + result = result || errorCode == 0 } else { - log(1, "Test failures") + context.logger.log(project.name, 1, " No tests to run") + result = true } - return errorCode == 0 } else { - log(2, "Couldn't find any test classes") - return true + throw KobaltException("Couldn't find a test configuration named \"$configName\"") } + + onFinish(project) + + if (errorCode == 0) { + context.logger.log(project.name, 1, "All tests passed") + } else { + context.logger.log(project.name, 1, longMessage!!) + } + + return TestResult(result, shortMessage, longMessage) } + + /* + ** @return all the JVM flags from contributors and interceptors. + */ + @VisibleForTesting + fun calculateAllJvmArgs(project: Project, context: KobaltContext, + testConfig: TestConfig, classpath: List, pluginInfo: IPluginInfo) : List { + val fullClasspath = classpath.map { it.jarFile.get().absolutePath } + extraClasspath + // Default JVM args + val jvmFlags = arrayListOf().apply { + addAll(testConfig.jvmArgs) + add("-ea") + add("-classpath") + add(fullClasspath.joinToString(File.pathSeparator)) + } + + // JVM flags from the contributors + val jvmFlagsFromContributors = pluginInfo.testJvmFlagContributors.flatMap { + it.testJvmFlagsFor(project, context, jvmFlags) + } + + // JVM flags from the interceptors (these overwrite flags instead of just adding to the list) + val result = ArrayList(jvmFlags + jvmFlagsFromContributors) + pluginInfo.testJvmFlagInterceptors.forEach { + val newFlags = it.testJvmFlagsFor(project, context, result) + result.clear() + result.addAll(newFlags) + } + + if (result.any()) { + context.logger.log(project.name, 2, + "Final JVM test flags after running the contributors and interceptors: $result") + } + + return result + } + } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/GraphUtil.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/GraphUtil.kt new file mode 100644 index 00000000..6cef8ada --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/GraphUtil.kt @@ -0,0 +1,35 @@ +package com.beust.kobalt.internal + +/** + * Generic operations on graph-like structures. + */ +object GraphUtil { + /** + * Apply the operation in `closure` to all the nodes in the tree. + */ + fun map(roots: List, children: (T) -> List, closure: (T) -> Unit) { + roots.forEach { + closure(it) + map(children(it), children, closure) + } + } + + /** + * Display each node in the roots by calling the `display` function on each of them. + */ + fun displayGraph(roots: List, + children: (T) -> List, + display: (node: T, indent: String) -> Unit) { + + fun pd(node: T, indent: String) { + display(node, indent) + children(node).forEach { + pd(it, indent + " ") + } + } + roots.forEach { + pd(it, "") + } + } +} + diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/IncrementalManager.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/IncrementalManager.kt index 3ff1536f..067cf0c1 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/IncrementalManager.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/IncrementalManager.kt @@ -1,8 +1,17 @@ package com.beust.kobalt.internal +import com.beust.kobalt.Args +import com.beust.kobalt.IncrementalTaskInfo +import com.beust.kobalt.TaskResult +import com.beust.kobalt.Variant +import com.beust.kobalt.api.Kobalt +import com.beust.kobalt.api.Project import com.beust.kobalt.misc.KFiles +import com.beust.kobalt.misc.kobaltLog import com.google.gson.Gson import com.google.gson.GsonBuilder +import com.google.inject.Inject +import com.google.inject.assistedinject.Assisted import java.io.File import java.io.FileReader import java.nio.charset.Charset @@ -10,17 +19,23 @@ import java.nio.file.Files import java.nio.file.Paths import java.util.* -data class TaskInfo(val taskName: String, var inputChecksum: String? = null, var outputChecksum: String? = null) - -class BuildInfo(var tasks: List) - /** - * Manage the file .kobalt/build-info.kt, which keeps track of input and output checksums to manage + * Manage the file .kobalt/buildInfo.json, which keeps track of input and output checksums to manage * incremental builds. */ -class IncrementalManager(val fileName: String = IncrementalManager.BUILD_INFO_FILE) { +class IncrementalManager @Inject constructor(val args: Args, @Assisted val fileName : String) { + + private data class TaskInfo(val taskName: String, var inputChecksum: String? = null, + var outputChecksum: String? = null) + + private class BuildInfo(var tasks: List) + + interface IFactory { + fun create(@Assisted fileName: String = IncrementalManager.BUILD_INFO_FILE) : IncrementalManager + } + companion object { - val BUILD_INFO_FILE = KFiles.joinDir(KFiles.KOBALT_DOT_DIR, "build-info.json") + val BUILD_INFO_FILE = KFiles.joinDir(KFiles.KOBALT_DOT_DIR, "buildInfo.json") } private fun buildInfo() = File(fileName).let { file -> @@ -32,14 +47,15 @@ class IncrementalManager(val fileName: String = IncrementalManager.BUILD_INFO_FI } private fun taskInfos() = hashMapOf().apply { - buildInfo().tasks.forEach { - put(it.taskName, it) - } + buildInfo().tasks.forEach { + put(it.taskName, it) } + } private fun save(map: Map) { val bi = BuildInfo(map.values.toList()) val json = GsonBuilder().setPrettyPrinting().create().toJson(bi) + Files.write(Paths.get(fileName), json.toByteArray(Charset.defaultCharset())) } @@ -47,22 +63,124 @@ class IncrementalManager(val fileName: String = IncrementalManager.BUILD_INFO_FI = taskInfos.getOrPut(taskName, { -> TaskInfo(taskName) }) fun saveInputChecksum(taskName: String, inputChecksum: String) { - with(taskInfos()) { - taskInfoFor(this, taskName).inputChecksum = inputChecksum - save(this) + synchronized(BUILD_INFO_FILE) { + with(taskInfos()) { + taskInfoFor(this, taskName).inputChecksum = inputChecksum + save(this) + } } } fun inputChecksumFor(taskName: String) : String? = + synchronized(BUILD_INFO_FILE) { taskInfoFor(taskInfos(), taskName).inputChecksum + } fun saveOutputChecksum(taskName: String, outputChecksum: String) { - with(taskInfos()) { - taskInfoFor(this, taskName).outputChecksum = outputChecksum - save(this) + synchronized(BUILD_INFO_FILE) { + with(taskInfos()) { + taskInfoFor(this, taskName).outputChecksum = outputChecksum + save(this) + } } } fun outputChecksumFor(taskName: String) : String? = + synchronized(BUILD_INFO_FILE) { taskInfoFor(taskInfos(), taskName).outputChecksum + } + + /** + * @param method is assumed to return an IncrementalTaskInfo. + * @return a closure that invokes that method and decide whether to run the task or not based + * on the content of that IncrementalTaskInfo + */ + fun toIncrementalTaskClosure(shortTaskName: String, method: (Project) -> IncrementalTaskInfo, + variant: Variant): (Project) -> TaskResult { + return { project: Project -> + Kobalt.context?.variant = variant + val iti = method(project) + val taskName = project.name + ":" + shortTaskName + var upToDate = false + var taskOutputChecksum : String? = null + + if (! args.forceIncremental && + (args.noIncremental || (Kobalt.context?.internalContext?.buildFileOutOfDate as Boolean))) { + // + // If the user turned off incremental builds or if the build file was modified, always run this task + // + logIncremental(LEVEL, "Incremental builds are turned off, running $taskName") + upToDate = false +// } else if (iti.context.internalContext.previousTaskWasIncrementalSuccess(project.name)) { +// // +// // If the previous task was an incremental success, no need to run this task. + // + // Disabled for now since this can only work if exactly the previous task was + // an incremental success. If it was a regular task, then this boolean should be + // set back to false, which is currently not done. +// // +// logIncremental(LEVEL, "Previous incremental task was a success, not running $shortTaskName") +// upToDate = true + } else { + // + // First, compare the input checksums + // + inputChecksumFor(taskName)?.let { inputChecksum -> + val dependsOnDirtyProjects = project.projectExtra.dependsOnDirtyProjects(project) + if (inputChecksum == iti.inputChecksum() && !dependsOnDirtyProjects) { + // + // Input checksums are equal, compare the output checksums + // + outputChecksumFor(taskName)?.let { outputChecksum -> + taskOutputChecksum = iti.outputChecksum() + if (outputChecksum == taskOutputChecksum) { + upToDate = true + } else { + logIncremental(LEVEL, "Incremental task $taskName output is out of date" + + " (different output checksums), running it") + } + } + } else { + if (dependsOnDirtyProjects) { + logIncremental(LEVEL, "Project ${project.name} depends on dirty project, running $taskName") + } else { + logIncremental(LEVEL, "Incremental task $taskName input is out of date, running it" + + " (different input checksums old: $inputChecksum new: ${iti.inputChecksum()})") + } + project.projectExtra.isDirty = true + } + } + } + + if (!upToDate) { + // + // The task is out of date, invoke the task on the IncrementalTaskInfo object + // + val result = iti.task(project) + if (result.success) { + logIncremental(LEVEL, "Incremental task $taskName done running, saving checksums") + iti.inputChecksum()?.let { + saveInputChecksum(taskName, it) + logIncremental(LEVEL, " input checksum \"$it\" saved") + } + // Important to rerun the checksum here since the output of the task might have changed it + iti.outputChecksum()?.let { + saveOutputChecksum(taskName, it) + logIncremental(LEVEL, " output checksum \"$it\" saved") + } + } + result + } else { + // + // Identical input and output checksums, don't run the task + // + logIncremental(LEVEL, "Incremental task \"$taskName\" is up to date, not running it") + iti.context.internalContext.setIncrementalSuccess(project.name) + TaskResult() + } + } + } + + val LEVEL = 2 + private fun logIncremental(level: Int, s: String) = kobaltLog(level, " INC - $s") } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/JUnit5Runner.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/JUnit5Runner.kt new file mode 100644 index 00000000..2e9b534c --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/JUnit5Runner.kt @@ -0,0 +1,152 @@ +package com.beust.kobalt.internal + +import com.beust.jcommander.JCommander +import com.beust.jcommander.Parameter +import com.beust.kobalt.TestConfig +import com.beust.kobalt.api.IAffinity +import com.beust.kobalt.api.IClasspathDependency +import com.beust.kobalt.api.KobaltContext +import com.beust.kobalt.api.Project +import com.beust.kobalt.misc.KFiles +import com.beust.kobalt.misc.KobaltLogger +import com.google.inject.Inject +import org.junit.platform.engine.TestExecutionResult +import org.junit.platform.engine.discovery.DiscoverySelectors +import org.junit.platform.engine.reporting.ReportEntry +import org.junit.platform.engine.support.descriptor.MethodSource +import org.junit.platform.launcher.LauncherDiscoveryRequest +import org.junit.platform.launcher.TestExecutionListener +import org.junit.platform.launcher.TestIdentifier +import org.junit.platform.launcher.TestPlan +import org.junit.platform.launcher.core.LauncherDiscoveryRequestBuilder +import org.junit.platform.launcher.core.LauncherFactory +import java.io.File +import java.nio.file.Paths + +/** + * Runner for JUnit 5 tests. This class also contains a main() entry point since JUnit 5 no longer supplies one. + */ +class JUnit5Runner @Inject constructor(kFiles: KFiles) : GenericTestRunner() { + + override val dependencyName = "jupiter" + override val annotationPackage = "org.junit.jupiter.api" + override val mainClass = "com.beust.kobalt.internal.JUnit5RunnerKt" + override val runnerName = "JUnit 5" + + override fun affinity(project: Project, context: KobaltContext) : Int { + val result = + if (project.testDependencies.any { it.id.contains("junit5") || it.id.contains("jupiter") }) + IAffinity.DEFAULT_POSITIVE_AFFINITY + 100 + else 0 + return result + + } + + override fun args(project: Project, context: KobaltContext, classpath: List, testConfig: TestConfig): List { + val testClassDir = KFiles.joinDir(project.buildDirectory, KFiles.TEST_CLASSES_DIR) + val classDir = KFiles.joinDir(project.buildDirectory, KFiles.CLASSES_DIR) + val args = listOf("--testClassDir", testClassDir, + "--classDir", classDir, + "--log", KobaltLogger.LOG_LEVEL.toString()) + return args + } + + override val extraClasspath = kFiles.kobaltJar +} + +private class Args { + @Parameter(names = arrayOf("--log")) + var log: Int = 1 + + @Parameter(names = arrayOf("--testClassDir")) + var testClassDir: String = "kobaltBuild/test-classes" + + @Parameter(names = arrayOf("--classDir")) + var classDir: String = "kobaltBuild/classes" +} + +fun main(argv: Array) { + val args = Args() + val jc = JCommander(args) + jc.parse(*argv) + + val testClassDir = File(args.testClassDir).absolutePath + val classDir = File(args.classDir).absolutePath + val request : LauncherDiscoveryRequest = LauncherDiscoveryRequestBuilder() + .selectors(DiscoverySelectors.selectClasspathRoots(setOf( + Paths.get(testClassDir), + Paths.get(classDir) + ))) + .selectors(DiscoverySelectors.selectDirectory(testClassDir)) + .build() + + fun testName(id: TestIdentifier) : String? { + val result = + if (id.source.isPresent) { + val source = id.source.get() + if (source is MethodSource) { + source.className + "." + source.methodName + } else { + null + } + } else { + null + } + return result + } + + var passed = 0 + var failed = 0 + var skipped = 0 + var aborted = 0 + + fun log(level: Int, s: String) { + if (level <= args.log) println(s) + } + + val listener = object: TestExecutionListener { + override fun executionFinished(testIdentifier: TestIdentifier, testExecutionResult: TestExecutionResult) { + val testName = testName(testIdentifier) + if (testName != null) { + when(testExecutionResult.status) { + TestExecutionResult.Status.FAILED -> { + log(1, "FAILED: $testName, reason: " + testExecutionResult.throwable.get().toString()) + failed++ + } + TestExecutionResult.Status.ABORTED -> { + log(1, "ABORTED: $testName, reason: " + testExecutionResult.throwable.get().toString()) + aborted++ + } + TestExecutionResult.Status.SUCCESSFUL -> { + log(2, "PASSED: $testName") + passed++ + } else -> { + + } + } + } + } + + override fun executionSkipped(testIdentifier: TestIdentifier, reason: String) { + testName(testIdentifier)?.let { + log(1, "Skipping $it because $reason") + skipped++ + } + } + + override fun executionStarted(testIdentifier: TestIdentifier) { + testName(testIdentifier)?.let { + log(2, "Starting $it") + } + } + + override fun testPlanExecutionStarted(testPlan: TestPlan?) {} + override fun dynamicTestRegistered(testIdentifier: TestIdentifier?) {} + override fun reportingEntryPublished(testIdentifier: TestIdentifier?, entry: ReportEntry?) {} + override fun testPlanExecutionFinished(testPlan: TestPlan?) {} + } + + LauncherFactory.create().execute(request, listener) + + log(1, "TEST RESULTS: $passed PASSED, $failed FAILED, $skipped SKIPPED, $aborted ABORTED") +} \ No newline at end of file diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/JUnitRunner.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/JUnitRunner.kt index 64350134..c5b36997 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/JUnitRunner.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/JUnitRunner.kt @@ -1,14 +1,32 @@ package com.beust.kobalt.internal +import com.beust.kobalt.TestConfig import com.beust.kobalt.api.IClasspathDependency +import com.beust.kobalt.api.KobaltContext import com.beust.kobalt.api.Project +import com.beust.kobalt.maven.DependencyManager +import com.google.inject.Inject +import java.lang.reflect.Modifier +import java.net.URLClassLoader -open public class JUnitRunner() : GenericTestRunner() { +open class JUnitRunner() : GenericTestRunner() { override val mainClass = "org.junit.runner.JUnitCore" - + override val annotationPackage = "org.junit" override val dependencyName = "junit" + override val runnerName = "JUnit 4" + + override fun args(project: Project, context: KobaltContext, classpath: List, + testConfig: TestConfig) = findTestClasses(project, context, testConfig) + + @Inject + lateinit var dependencyManager: DependencyManager + + override fun filterTestClasses(project: Project, context: KobaltContext, classes: List) : List { + val deps = dependencyManager.testDependencies(project, context) + val cl = URLClassLoader(deps.map { it.jarFile.get().toURI().toURL() }.toTypedArray()) + return classes.filter { !Modifier.isAbstract(cl.loadClass(it).modifiers) } + } - override fun args(project: Project, classpath: List) = findTestClasses(project, classpath) } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/JvmCompiler.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/JvmCompiler.kt index a770ffc5..e7773737 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/JvmCompiler.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/JvmCompiler.kt @@ -15,43 +15,36 @@ import java.util.* * Also validates the classpath and run all the contributors. */ class JvmCompiler @Inject constructor(val dependencyManager: DependencyManager) { - /** * Take the given CompilerActionInfo and enrich it with all the applicable contributors and * then pass it to the ICompilerAction. */ - fun doCompile(project: Project?, context: KobaltContext?, action: ICompilerAction, info: CompilerActionInfo) - : TaskResult { + fun doCompile(project: Project?, context: KobaltContext?, action: ICompilerAction, info: CompilerActionInfo, + flags: List): TaskResult { // Dependencies - val allDependencies = (info.dependencies - + dependencyManager.calculateDependencies(project, context!!, allDependencies = info.dependencies)) + val allDependencies = (info.dependencies + dependencyManager.calculateDependencies(project, context!!, + passedDependencies = info.dependencies)) .distinct() // Plugins that add flags to the compiler - val contributorFlags = if (project != null) { - context.pluginInfo.compilerFlagContributors.flatMap { - it.flagsFor(project, context, info.compilerArgs) - } - } else { - emptyList() - } + val contributorFlags : List = if (project != null) flags else emptyList() val addedFlags = contributorFlags + ArrayList(info.compilerArgs) validateClasspath(allDependencies.map { it.jarFile.get().absolutePath }) - return action.compile(info.copy(dependencies = allDependencies, compilerArgs = addedFlags)) + return action.compile(project, info.copy(dependencies = allDependencies, compilerArgs = addedFlags)) } private fun validateClasspath(cp: List) { cp.forEach { if (! File(it).exists()) { - throw KobaltException("Couldn't find $it") + throw KobaltException("Invalid classpath: couldn't find $it") } } } } interface ICompilerAction { - fun compile(info: CompilerActionInfo): TaskResult + fun compile(project: Project?, info: CompilerActionInfo): TaskResult } \ No newline at end of file diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/JvmCompilerPlugin.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/JvmCompilerPlugin.kt index fd07cb5a..5e2a9354 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/JvmCompilerPlugin.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/JvmCompilerPlugin.kt @@ -1,17 +1,19 @@ package com.beust.kobalt.internal -import com.beust.kobalt.Features +import com.beust.kobalt.IncrementalTaskInfo import com.beust.kobalt.KobaltException import com.beust.kobalt.TaskResult +import com.beust.kobalt.TestConfig import com.beust.kobalt.api.* import com.beust.kobalt.api.annotation.ExportedProjectProperty +import com.beust.kobalt.api.annotation.IncrementalTask import com.beust.kobalt.api.annotation.Task -import com.beust.kobalt.maven.DepFactory import com.beust.kobalt.maven.DependencyManager -import com.beust.kobalt.maven.LocalRepo +import com.beust.kobalt.maven.Md5 +import com.beust.kobalt.maven.aether.Scope import com.beust.kobalt.misc.KFiles import com.beust.kobalt.misc.KobaltExecutors -import com.beust.kobalt.misc.log +import com.beust.kobalt.misc.error import com.beust.kobalt.misc.warn import java.io.File import java.util.* @@ -19,24 +21,20 @@ import javax.inject.Inject import javax.inject.Singleton /** - * Base classes for plug-ins that compile files on the JVM. This base class requires the bare minimum - * contributors (source files, projects and tasks). Subclasses can add more as they see fit (e.g. test - * source directory, etc...). + * This plug-in takes care of compilation: it declares several common tasks ("compile", "compileTest") + * and picks up all the compiler contributors in order to run them whenever a compilation is requested. */ @Singleton -abstract class JvmCompilerPlugin @Inject constructor( - open val localRepo: LocalRepo, +open class JvmCompilerPlugin @Inject constructor( open val files: KFiles, - open val depFactory: DepFactory, open val dependencyManager: DependencyManager, open val executors: KobaltExecutors, - open val jvmCompiler: JvmCompiler, - val taskContributor : TaskContributor = TaskContributor()) + open val taskContributor : TaskContributor, + val compilerUtils: CompilerUtils) : BasePlugin(), ISourceDirectoryContributor, IProjectContributor, ITaskContributor by taskContributor { companion object { - @ExportedProjectProperty(doc = "Projects this project depends on", type = "List") - const val DEPENDENT_PROJECTS = "dependentProjects" + val PLUGIN_NAME = "JvmCompiler" @ExportedProjectProperty(doc = "Compiler args", type = "List") const val COMPILER_ARGS = "compilerArgs" @@ -46,217 +44,218 @@ abstract class JvmCompilerPlugin @Inject constructor( const val TASK_CLEAN = "clean" const val TASK_TEST = "test" - const val SOURCE_SET_MAIN = "main" - const val SOURCE_SET_TEST = "test" const val DOCS_DIRECTORY = "docs/javadoc" + + const val GROUP_TEST = "test" + const val GROUP_BUILD = "build" + const val GROUP_DOCUMENTATION = "documentation" } - /** - * Log with a project. - */ - protected fun lp(project: Project, s: String) { - log(2, "${project.name}: $s") - } + override val name: String = PLUGIN_NAME + + override fun accept(project: Project) = true override fun apply(project: Project, context: KobaltContext) { super.apply(project, context) - project.projectProperties.put(DEPENDENT_PROJECTS, projects()) - taskContributor.addVariantTasks(this, project, context, "compile", runTask = { taskCompile(project) }) +// cleanUpActors() + taskContributor.addIncrementalVariantTasks(this, project, context, "compile", GROUP_BUILD, + runTask = { taskCompile(project) }) + + // + // Add each test config as a test task. If none was specified, create a default one so that + // users don't have to specify a test{} + // + if (project.testConfigs.isEmpty()) { + project.testConfigs.add(TestConfig(project, isDefault = true)) + } + project.testConfigs.forEach { config -> + val taskName = if (config.name.isEmpty()) TASK_TEST else TASK_TEST + config.name + + taskManager.addTask(this, project, taskName, group = GROUP_TEST, + dependsOn = listOf(JvmCompilerPlugin.TASK_COMPILE, JvmCompilerPlugin.TASK_COMPILE_TEST), + task = { taskTest(project, config.name)} ) + } + } - @Task(name = TASK_TEST, description = "Run the tests", - runAfter = arrayOf(JvmCompilerPlugin.TASK_COMPILE, JvmCompilerPlugin.TASK_COMPILE_TEST)) - fun taskTest(project: Project) : TaskResult { - lp(project, "Running tests") + private fun taskTest(project: Project, configName: String): TaskResult { + context.logger.log(project.name, 2, "Running tests: $configName") - val runContributor = ActorUtils.selectAffinityActor(project, context, + val testContributor = ActorUtils.selectAffinityActor(project, context, context.pluginInfo.testRunnerContributors) - if (runContributor != null && runContributor.affinity(project, context) > 0) { - return runContributor.run(project, context, dependencyManager.testDependencies(project, context, - projects())) + if (testContributor != null && testContributor.affinity(project, context) > 0) { +// val td1 = dependencyManager.testDependencies(project, context) + val testDependencies = dependencyManager.calculateDependencies(project, context, + dependencyFilter = dependencyManager.createDependencyFilter(project, project.testDependencies), + scopes = listOf(Scope.TEST)) + val compileDependencies = dependencyManager.calculateDependencies(project, context, + scopes = listOf(Scope.COMPILE, Scope.COMPILEONLY)) + val allDependencies = (testDependencies + compileDependencies).distinct() + return testContributor.run(project, context, configName, allDependencies.toList()) } else { - log(1, "Couldn't find a test runner for project ${project.name}, not running any tests") + context.logger.log(project.name, 2, + "Couldn't find a test runner for project ${project.name}, did you specify dependenciesTest{}?") return TaskResult() } } - @Task(name = TASK_CLEAN, description = "Clean the project") - fun taskClean(project : Project ) : TaskResult { + @Task(name = TASK_CLEAN, description = "Clean the project", group = GROUP_BUILD, + runBefore = arrayOf(JvmCompilerPlugin.TASK_COMPILE)) + fun taskClean(project: Project): TaskResult { java.io.File(project.directory, project.buildDirectory).let { dir -> - if (! dir.deleteRecursively()) { + if (!dir.deleteRecursively()) { warn("Couldn't delete $dir") } } return TaskResult() } - /** - * Copy the resources from a source directory to the build one - */ - protected fun copyResources(project: Project, sourceSet: String) { - val sourceDirs: ArrayList = arrayListOf() - var outputDir: String? - if (sourceSet == JvmCompilerPlugin.SOURCE_SET_MAIN) { - sourceDirs.addAll(project.sourceDirectories.filter { it.contains("resources") }) - outputDir = KFiles.CLASSES_DIR - } else if (sourceSet == JvmCompilerPlugin.SOURCE_SET_TEST) { - sourceDirs.addAll(project.sourceDirectoriesTest.filter { it.contains("resources") }) - outputDir = KFiles.TEST_CLASSES_DIR + @IncrementalTask(name = TASK_COMPILE_TEST, description = "Compile the tests", group = GROUP_BUILD, + dependsOn = arrayOf(TASK_COMPILE)) + fun taskCompileTest(project: Project): IncrementalTaskInfo { + return IncrementalTaskInfo( + inputChecksum = { + Md5.toMd5Directories(context.testSourceDirectories(project).map { File(project.directory, it.path)}) + }, + outputChecksum = { + Md5.toMd5Directories(listOf(KFiles.makeOutputTestDir(project))) + }, + task = { project -> doTaskCompileTest(project)}, + context = context + ) + } + + private fun sourceDirectories(project: Project, context: KobaltContext, isTest: Boolean) + = context.variant.sourceDirectories(project, context, SourceSet.of(isTest)) + + @IncrementalTask(name = JvmCompilerPlugin.TASK_COMPILE, description = "Compile the project", group = GROUP_BUILD, + runAfter = arrayOf(TASK_CLEAN)) + fun taskCompile(project: Project): IncrementalTaskInfo { + return IncrementalTaskInfo( + inputChecksum = { + Md5.toMd5Directories(context.sourceDirectories(project).map { File(project.directory, it.path) }) + }, + outputChecksum = { + Md5.toMd5Directories(listOf(File(project.directory, project.classesDir(context)))) + }, + task = { project -> doTaskCompile(project) }, + context = context + ) + } + + private fun doTaskCompile(project: Project) = doTaskCompile(project, isTest = false) + + private fun doTaskCompileTest(project: Project) = doTaskCompile(project, isTest = true) + + private fun doTaskCompile(project: Project, isTest: Boolean): TaskResult { + val results = arrayListOf() + + val compilerContributors = context.pluginInfo.compilerContributors + ActorUtils.selectAffinityActors(project, context, context.pluginInfo.compilerContributors) + + var failedResult: TaskResult? = null + if (compilerContributors.isEmpty()) { + throw KobaltException("Couldn't find any compiler for project ${project.name}") } else { - throw IllegalArgumentException("Custom source sets not supported yet: $sourceSet") - } - if (sourceDirs.size > 0) { - lp(project, "Copying $sourceSet resources") - val absOutputDir = File(KFiles.joinDir(project.directory, project.buildDirectory, outputDir)) - sourceDirs.map { File(project.directory, it) }.filter { - it.exists() - } .forEach { - log(2, "Copying from $sourceDirs to $absOutputDir") - KFiles.copyRecursively(it, absOutputDir, deleteFirst = false) + // Generate BuildConfig if applicable + context.variant.maybeGenerateBuildConfig(project, context) + + val allCompilers = compilerContributors.flatMap { it.compilersFor(project, context)}.sorted() + + /** + * Swap the Java and Kotlin compilers from the list. + */ + fun swapJavaAndKotlin(allCompilers: List): List { + val result = ArrayList(allCompilers) + var ik = -1 + var ij = -1 + allCompilers.withIndex().forEach { wi -> + if (wi.value.sourceSuffixes.contains("java")) ij = wi.index + if (wi.value.sourceSuffixes.contains("kt")) ik = wi.index + } + + if (ik >= 0 && ij >= 0) { + Collections.swap(result, ik, ij) + } + return result } - } else { - lp(project, "No resources to copy for $sourceSet") - } - } - protected fun compilerArgsFor(project: Project) : List { - val result = project.projectProperties.get(COMPILER_ARGS) - if (result != null) { - @Suppress("UNCHECKED_CAST") - return result as List - } else { - return emptyList() - } - } + // If this project has a kapt{} directive, we want to run the Java compiler first + val hasKapt = project.projectProperties.get("kaptConfig") != null + val allCompilersSorted = if (hasKapt) swapJavaAndKotlin(allCompilers) else allCompilers + var done = false + // The directory where the classes get compiled + val buildDirectory = + if (isTest) File(KFiles.joinDir(project.buildDirectory, KFiles.TEST_CLASSES_DIR)) + else File(KFiles.joinDir(project.classesDir(context))) - open fun toClassFile(sourceFile: String) = sourceFile + ".class" - - fun addCompilerArgs(project: Project, vararg args: String) { - project.projectProperties.put(COMPILER_ARGS, arrayListOf(*args)) - } - - fun isOutdated(project: Project, context: KobaltContext, actionInfo: CompilerActionInfo) : Boolean { - fun stripSourceDir(sourceFile: String) : String { - project.sourceDirectories.forEach { - val d = listOf(project.directory, it).joinToString("/") - if (sourceFile.startsWith(d)) return sourceFile.substring(d.length + 1) + allCompilersSorted.doWhile({ ! done }) { compiler -> + val compilerResults = compilerUtils.invokeCompiler(project, context, compiler, + sourceDirectories(project, context, isTest), isTest, buildDirectory) + results.addAll(compilerResults.successResults) + if (failedResult == null) failedResult = compilerResults.failedResult + compilerResults.failedResult?.let { failedResult -> + done = true + failedResult.errorMessage?.let { errorMessage -> + error(text = errorMessage) + } + } } - throw KobaltException("Couldn't strip source dir from $sourceFile") - } - fun stripSuffix( sourceFile: String) : String { - val index = sourceFile.indexOf(project.sourceSuffix) - if (index >= 0) return sourceFile.substring(0, index) - else return sourceFile - } - - actionInfo.sourceFiles.map { it.replace("\\", "/") }.forEach { sourceFile -> - val stripped = stripSourceDir(sourceFile) - val classFile = File(KFiles.joinDir(project.directory, project.classesDir(context), - toClassFile(stripSuffix(stripped)))) - if (! classFile.exists() || File(sourceFile).lastModified() > classFile.lastModified()) { - log(2, "Outdated $sourceFile $classFile " + Date(File(sourceFile).lastModified()) + - " " + classFile.lastModified()) - return true - } - } - return false - } - - @Task(name = JvmCompilerPlugin.TASK_COMPILE, description = "Compile the project") - fun taskCompile(project: Project) : TaskResult { - // Set up the source files now that we have the variant - sourceDirectories.addAll(context.variant.sourceDirectories(project)) - - val sourceDirectory = context.variant.maybeGenerateBuildConfig(project, context) - if (sourceDirectory != null) { - sourceDirectories.add(sourceDirectory) - } - val info = createCompilerActionInfo(project, context, isTest = false) - if (! Features.USE_TIMESTAMPS || isOutdated(project, context, info)) { - val compiler = ActorUtils.selectAffinityActor(project, context, context.pluginInfo.compilerContributors) - if (compiler != null) { - return compiler.compile(project, context, info) - } else { - throw KobaltException("Couldn't find any compiler for project ${project.name}") - } - } else { - log(2, " Source files are up to date, not compiling") - return TaskResult() + return if (failedResult != null) failedResult!! + else if (results.size > 0) results[0] + else TaskResult(true) } } - override fun projects() = projects + private val allProjects = arrayListOf() - @Task(name = "doc", description = "Generate the documentation for the project") - fun taskJavadoc(project: Project) : TaskResult { + // IProjectContributor + override fun projects() = allProjects + + override fun cleanUpActors() { + allProjects.clear() + } + + fun addDependentProjects(project: Project, dependents: List) { + project.dependsOn.addAll(dependents) + with(ProjectDescription(project, dependents)) { + allProjects.add(this) + } + } + + @Task(name = "doc", description = "Generate the documentation for the project", group = GROUP_DOCUMENTATION, + runBefore = arrayOf("assemble"), runAfter = arrayOf("clean")) + fun taskJavadoc(project: Project): TaskResult { val docGenerator = ActorUtils.selectAffinityActor(project, context, context.pluginInfo.docContributors) if (docGenerator != null) { - return docGenerator.generateDoc(project, context, createCompilerActionInfo(project, context, - isTest = false)) + val buildDirectory = File(project.buildDirectory, JvmCompilerPlugin.DOCS_DIRECTORY) + val contributors = + ActorUtils.selectAffinityActors(project, context, context.pluginInfo.compilerContributors) + var result: TaskResult? = null + contributors.forEach { + it.compilersFor(project, context).forEach { compiler -> + result = docGenerator.generateDoc(project, context, + compilerUtils.createCompilerActionInfo(project, context, compiler, + isTest = false, sourceDirectories = sourceDirectories(project, context, false), + sourceSuffixes = compiler.sourceSuffixes, buildDirectory = buildDirectory)) + } + } + return result!! } else { warn("Couldn't find any doc contributor for project ${project.name}") return TaskResult() } } - /** - * Create a CompilerActionInfo (all the information that a compiler needs to know) for the given parameters. - * Runs all the contributors and interceptors relevant to that task. - */ - protected fun createCompilerActionInfo(project: Project, context: KobaltContext, isTest: Boolean) : - CompilerActionInfo { - copyResources(project, JvmCompilerPlugin.SOURCE_SET_MAIN) - - val classpath = if (isTest) - dependencyManager.testDependencies(project, context, projects) - else - dependencyManager.dependencies(project, context, projects) - - val projectDirectory = File(project.directory) - val buildDirectory = if (isTest) KFiles.makeOutputTestDir(project) - else File(project.classesDir(context)) - buildDirectory.mkdirs() - - val initialSourceDirectories = arrayListOf() - - // Source directories from the contributors - initialSourceDirectories.addAll( - if (isTest) { - context.pluginInfo.testSourceDirContributors.flatMap { it.testSourceDirectoriesFor(project, context) } - } else { - context.pluginInfo.sourceDirContributors.flatMap { it.sourceDirectoriesFor(project, context) } - }) - - // Transform them with the interceptors, if any - val sourceDirectories = if (isTest) { - initialSourceDirectories - } else { - context.pluginInfo.sourceDirectoriesInterceptors.fold(initialSourceDirectories.toList(), - { sd, interceptor -> interceptor.intercept(project, context, sd) }) - }.filter { - File(project.directory, it.path).exists() - } - - // Now that we have the final list of source dirs, find source files in them - val sourceFiles = files.findRecursively(projectDirectory, sourceDirectories, - { it .endsWith(project.sourceSuffix) }) - .map { File(projectDirectory, it).path } - - // Finally, alter the info with the compiler interceptors before returning it - val initialActionInfo = CompilerActionInfo(projectDirectory.path, classpath, sourceFiles, buildDirectory, - emptyList()) - val result = context.pluginInfo.compilerInterceptors.fold(initialActionInfo, { ai, interceptor -> - interceptor.intercept(project, context, ai) - }) - return result - } - - val sourceDirectories = hashSetOf() - // ISourceDirectoryContributor override fun sourceDirectoriesFor(project: Project, context: KobaltContext) - = if (accept(project)) sourceDirectories.toList() else arrayListOf() -} + = if (accept(project)) { + sourceDirectories(project, context, isTest = false) + } else { + arrayListOf() + } + open val compiler: ICompilerContributor? = null +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/KobaltPluginXml.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/KobaltPluginXml.kt index 0b4f9e89..d8ca3555 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/KobaltPluginXml.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/KobaltPluginXml.kt @@ -1,9 +1,9 @@ package com.beust.kobalt.internal +import com.beust.kobalt.KobaltException import com.beust.kobalt.api.* -import com.beust.kobalt.misc.log +import com.beust.kobalt.misc.kobaltLog import java.io.ByteArrayInputStream -import java.io.File import java.io.InputStream import javax.xml.bind.JAXBContext import javax.xml.bind.annotation.XmlElement @@ -50,22 +50,35 @@ class ClassNameXml { var className: List = arrayListOf() } +/** + * The fields in this interface have tests. + */ +interface IPluginInfo { + val testJvmFlagContributors : List + val testJvmFlagInterceptors : List +} + +open class BasePluginInfo : IPluginInfo { + override val testJvmFlagContributors = arrayListOf() + override val testJvmFlagInterceptors = arrayListOf() +} /** * Turn a KobaltPluginXml (the raw content of kobalt-plugin.xml mapped to POJO's) into a PluginInfo object, which * contains all the contributors instantiated and other information that Kobalt can actually use. Kobalt code that * needs to access plug-in info can then just inject a PluginInfo object. */ -class PluginInfo(val xml: KobaltPluginXml, val classLoader: ClassLoader?) { +class PluginInfo(val xml: KobaltPluginXml, val pluginClassLoader: ClassLoader?, val classLoader: ClassLoader?) + : BasePluginInfo() { val plugins = arrayListOf() val projectContributors = arrayListOf() val classpathContributors = arrayListOf() - val initContributors = arrayListOf>() + val templateContributors = arrayListOf() val repoContributors = arrayListOf() val compilerFlagContributors = arrayListOf() val compilerInterceptors = arrayListOf() - val sourceDirectoriesInterceptors = arrayListOf() - val buildDirectoryInterceptors = arrayListOf() - val runnerContributors = arrayListOf() + val sourceDirectoriesInterceptors = arrayListOf() + val buildDirectoryInterceptors = arrayListOf() +// val runnerContributors = arrayListOf() val testRunnerContributors = arrayListOf() val classpathInterceptors = arrayListOf() val compilerContributors = arrayListOf() @@ -74,8 +87,23 @@ class PluginInfo(val xml: KobaltPluginXml, val classLoader: ClassLoader?) { val testSourceDirContributors = arrayListOf() val buildConfigFieldContributors = arrayListOf() val taskContributors = arrayListOf() + val assemblyContributors = arrayListOf() + val incrementalAssemblyContributors = arrayListOf() + val incrementalTaskContributors = arrayListOf() + // Not documented yet + val buildConfigContributors = arrayListOf() val mavenIdInterceptors = arrayListOf() + val jvmFlagContributors = arrayListOf() + val localMavenRepoPathInterceptors = arrayListOf() + val buildListeners = arrayListOf() + val buildReportContributors = arrayListOf() + val docFlagContributors = arrayListOf() + + // Note: intentionally repeating them here even though they are defined by our base class so + // that this class always contains the full list of contributors and interceptors + override val testJvmFlagContributors = arrayListOf() + override val testJvmFlagInterceptors = arrayListOf() companion object { /** @@ -96,7 +124,7 @@ class PluginInfo(val xml: KobaltPluginXml, val classLoader: ClassLoader?) { fun readKobaltPluginXml(): PluginInfo { // Note: use forward slash here since we're looking up this file in a .jar file val url = Kobalt::class.java.classLoader.getResource(PLUGIN_CORE_XML) - log(2, "URL for core kobalt-plugin.xml: $url") + kobaltLog(2, "URL for core kobalt-plugin.xml: $url") if (url != null) { return readPluginXml(url.openConnection().inputStream) } else { @@ -107,16 +135,24 @@ class PluginInfo(val xml: KobaltPluginXml, val classLoader: ClassLoader?) { /** * Read a general kobalt-plugin.xml. */ - fun readPluginXml(ins: InputStream, classLoader: ClassLoader? = null): PluginInfo { + fun readPluginXml(ins: InputStream, pluginClassLoader: ClassLoader? = null, + classLoader: ClassLoader? = null): PluginInfo { val jaxbContext = JAXBContext.newInstance(KobaltPluginXml::class.java) - val kotlinPlugin: KobaltPluginXml = jaxbContext.createUnmarshaller().unmarshal(ins) + val kobaltPlugin: KobaltPluginXml = jaxbContext.createUnmarshaller().unmarshal(ins) as KobaltPluginXml - log(2, "Parsed plugin XML file, found: " + kotlinPlugin.name) - return PluginInfo(kotlinPlugin, classLoader) + kobaltLog(2, "Parsed plugin XML file, found: " + kobaltPlugin.name) + val result = + try { + PluginInfo(kobaltPlugin, pluginClassLoader, classLoader) + } catch(ex: Exception) { + throw KobaltException("Couldn't create PluginInfo: " + ex.message, ex) + } + return result } - fun readPluginXml(s: String, classLoader: ClassLoader? = null) - = readPluginXml(ByteArrayInputStream(s.toByteArray(Charsets.UTF_8)), classLoader) + fun readPluginXml(s: String, pluginClassLoader: ClassLoader?, scriptClassLoader: ClassLoader? = null) + = readPluginXml(ByteArrayInputStream(s.toByteArray(Charsets.UTF_8)), pluginClassLoader, + scriptClassLoader) } init { @@ -126,9 +162,21 @@ class PluginInfo(val xml: KobaltPluginXml, val classLoader: ClassLoader?) { GuiceFactory() } - fun forName(className: String) = - if (classLoader != null) classLoader.loadClass(className) - else Class.forName(className) + fun forName(className: String) : Class<*> { + fun loadClass(className: String, classLoader: ClassLoader?) : Class<*>? { + try { + return classLoader?.loadClass(className) + } catch(ex: ClassNotFoundException) { + return null + } + } + + val result = loadClass(className, classLoader) + ?: loadClass(className, pluginClassLoader) + ?: Class.forName(className) + + return result + } // // Populate pluginInfo with what was found in Kobalt's own kobalt-plugin.xml @@ -138,46 +186,73 @@ class PluginInfo(val xml: KobaltPluginXml, val classLoader: ClassLoader?) { with(factory.instanceOf(forName(it))) { // Note: can't use "when" here since the same instance can implement multiple interfaces if (this is IBuildConfigFieldContributor) buildConfigFieldContributors.add(this) - if (this is IBuildDirectoryIncerceptor) buildDirectoryInterceptors.add(this) + if (this is IBuildDirectoryInterceptor) buildDirectoryInterceptors.add(this) if (this is IClasspathContributor) classpathContributors.add(this) if (this is IClasspathInterceptor) classpathInterceptors.add(this) if (this is ICompilerContributor) compilerContributors.add(this) if (this is ICompilerFlagContributor) compilerFlagContributors.add(this) if (this is ICompilerInterceptor) compilerInterceptors.add(this) if (this is IDocContributor) docContributors.add(this) - if (this is IInitContributor<*>) initContributors.add(this as IInitContributor) + if (this is ITemplateContributor) templateContributors.add(this) if (this is IPlugin) plugins.add(this) if (this is IProjectContributor) projectContributors.add(this) if (this is IRepoContributor) repoContributors.add(this) - if (this is IRunnerContributor) runnerContributors.add(this) +// if (this is IRunnerContributor) runnerContributors.add(this) if (this is ISourceDirectoryContributor) sourceDirContributors.add(this) - if (this is ISourceDirectoryIncerceptor) sourceDirectoriesInterceptors.add(this) + if (this is ISourceDirectoryInterceptor) sourceDirectoriesInterceptors.add(this) if (this is ITaskContributor) taskContributors.add(this) if (this is ITestRunnerContributor) testRunnerContributors.add(this) - - // Not documented yet if (this is IMavenIdInterceptor) mavenIdInterceptors.add(this) if (this is ITestSourceDirectoryContributor) testSourceDirContributors.add(this) + if (this is IBuildConfigContributor) buildConfigContributors.add(this) + if (this is IAssemblyContributor) assemblyContributors.add(this) + if (this is IIncrementalAssemblyContributor) incrementalAssemblyContributors.add(this) + if (this is IIncrementalTaskContributor) incrementalTaskContributors.add(this) + + // Not documented yet + if (this is ITestJvmFlagContributor) testJvmFlagContributors.add(this) + if (this is ITestJvmFlagInterceptor) testJvmFlagInterceptors.add(this) + if (this is IJvmFlagContributor) jvmFlagContributors.add(this) + if (this is ILocalMavenRepoPathInterceptor) localMavenRepoPathInterceptors.add(this) + if (this is IBuildListener) buildListeners.add(this) + if (this is IBuildReportContributor) buildReportContributors.add(this) + if (this is IDocFlagContributor) docFlagContributors.add(this) } } } + fun cleanUp() { + listOf(projectContributors, classpathContributors, templateContributors, + repoContributors, compilerFlagContributors, compilerInterceptors, + sourceDirectoriesInterceptors, buildDirectoryInterceptors, + /* runnerContributors, */ testRunnerContributors, classpathInterceptors, + compilerContributors, docContributors, sourceDirContributors, + testSourceDirContributors, buildConfigFieldContributors, + taskContributors, incrementalTaskContributors, assemblyContributors, + incrementalAssemblyContributors, testJvmFlagInterceptors, + jvmFlagContributors, localMavenRepoPathInterceptors, buildListeners, + buildReportContributors, docFlagContributors + ).forEach { + it.forEach(IPluginActor::cleanUpActors) + } + } + /** - * Populate pluginInfo with what was found in the plug-in's kobalt-plugin.xml + * Add the content of @param[pluginInfo] to this pluginInfo. */ fun addPluginInfo(pluginInfo: PluginInfo) { - log(2, "Found new plug-in, adding it to pluginInfo: $pluginInfo") + kobaltLog(2, "Found new plug-in, adding it to pluginInfo: $pluginInfo") plugins.addAll(pluginInfo.plugins) classpathContributors.addAll(pluginInfo.classpathContributors) projectContributors.addAll(pluginInfo.projectContributors) - initContributors.addAll(pluginInfo.initContributors) + templateContributors.addAll(pluginInfo.templateContributors) repoContributors.addAll(pluginInfo.repoContributors) compilerFlagContributors.addAll(pluginInfo.compilerFlagContributors) compilerInterceptors.addAll(pluginInfo.compilerInterceptors) sourceDirectoriesInterceptors.addAll(pluginInfo.sourceDirectoriesInterceptors) buildDirectoryInterceptors.addAll(pluginInfo.buildDirectoryInterceptors) - runnerContributors.addAll(pluginInfo.runnerContributors) +// runnerContributors.addAll(pluginInfo.runnerContributors) testRunnerContributors.addAll(pluginInfo.testRunnerContributors) classpathInterceptors.addAll(pluginInfo.classpathInterceptors) compilerContributors.addAll(pluginInfo.compilerContributors) @@ -185,8 +260,19 @@ class PluginInfo(val xml: KobaltPluginXml, val classLoader: ClassLoader?) { sourceDirContributors.addAll(pluginInfo.sourceDirContributors) buildConfigFieldContributors.addAll(pluginInfo.buildConfigFieldContributors) taskContributors.addAll(pluginInfo.taskContributors) + incrementalTaskContributors.addAll(pluginInfo.incrementalTaskContributors) testSourceDirContributors.addAll(pluginInfo.testSourceDirContributors) mavenIdInterceptors.addAll(pluginInfo.mavenIdInterceptors) + buildConfigContributors.addAll(pluginInfo.buildConfigContributors) + assemblyContributors.addAll(pluginInfo.assemblyContributors) + incrementalAssemblyContributors.addAll(pluginInfo.incrementalAssemblyContributors) + testJvmFlagContributors.addAll(pluginInfo.testJvmFlagContributors) + testJvmFlagInterceptors.addAll(pluginInfo.testJvmFlagInterceptors) + jvmFlagContributors.addAll(pluginInfo.jvmFlagContributors) + localMavenRepoPathInterceptors.addAll(pluginInfo.localMavenRepoPathInterceptors) + buildListeners.addAll(pluginInfo.buildListeners) + buildReportContributors.addAll(pluginInfo.buildReportContributors) + docFlagContributors.addAll(pluginInfo.docFlagContributors) } } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/KobaltSettingsXml.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/KobaltSettingsXml.kt new file mode 100644 index 00000000..2eb5374c --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/KobaltSettingsXml.kt @@ -0,0 +1,167 @@ +package com.beust.kobalt.internal + +import com.beust.kobalt.BUILD_SCRIPT_CONFIG +import com.beust.kobalt.Constants +import com.beust.kobalt.ProxyConfig +import com.beust.kobalt.homeDir +import com.beust.kobalt.misc.KFiles +import com.beust.kobalt.misc.kobaltLog +import com.google.inject.Inject +import com.google.inject.Singleton +import java.io.File +import java.io.FileInputStream +import javax.xml.bind.JAXBContext +import javax.xml.bind.annotation.XmlElement +import javax.xml.bind.annotation.XmlRootElement + +/** + * The root element of kobalt-settings.xml + */ +@XmlRootElement(name = "kobaltSettings") +class KobaltSettingsXml { + @XmlElement(name = "localCache") @JvmField + var localCache: String = homeDir(KFiles.KOBALT_DOT_DIR, "cache") + + @XmlElement(name = "localMavenRepo") @JvmField + var localMavenRepo: String = homeDir(KFiles.KOBALT_DOT_DIR, "localMavenRepo") + + @XmlElement(name = "defaultRepos") @JvmField + var defaultRepos: DefaultReposXml? = null + + @XmlElement(name = "proxies") @JvmField + var proxies: ProxiesXml? = null + + @XmlElement(name = "kobaltCompilerVersion") @JvmField + var kobaltCompilerVersion: String = Constants.KOTLIN_COMPILER_VERSION + + @XmlElement(name = "kobaltCompilerRepo") @JvmField + var kobaltCompilerRepo: String? = null + + @XmlElement(name = "kobaltCompilerFlags") @JvmField + var kobaltCompilerFlags: String? = null + + @XmlElement(name = "kobaltCompilerSeparateProcess") @JvmField + var kobaltCompilerSeparateProcess: Boolean = false + + @XmlElement(name = "autoUpdate") @JvmField + var autoUpdate: Boolean = false +} + +class ProxiesXml { + @XmlElement @JvmField + var proxy: List = arrayListOf() +} + +class ProxyXml { + @XmlElement @JvmField + var host: String = "" + + @XmlElement @JvmField + var port: String = "" + + @XmlElement @JvmField + var type: String = "" + + @XmlElement @JvmField + var nonProxyHosts: String = "" +} + +class DefaultReposXml { + @XmlElement @JvmField + var repo: List = arrayListOf() +} + +fun List.getProxy(protocol:String) = find { it.type==protocol } + +/** + * The object Kobalt refers to for settings. + */ +@Singleton +class KobaltSettings @Inject constructor(val xmlFile: KobaltSettingsXml) { + /** + * Location of the cache repository. + */ + var localCache = KFiles.makeDir(xmlFile.localCache) // var for testing + + /** + * Location of the local Maven repo for the task "publishToLocalMaven". + */ + val localMavenRepo = KFiles.makeDir(xmlFile.localMavenRepo) + + /** + * If true, Kobalt will automatically update itself if a new version is found. + */ + val autoUpdate = xmlFile.autoUpdate + + /** + * If true, the Kotlin compiler will always be launched in a separate JVM, even if the requested + * version is the same as the internal version. + */ + val kobaltCompilerSeparateProcess = xmlFile.kobaltCompilerSeparateProcess + + val defaultRepos = xmlFile.defaultRepos?.repo + + val proxyConfigs = with(xmlFile.proxies?.proxy) { + fun toIntOr(s: String, defaultValue: Int) = try { //TODO can be extracted to some global Utils + s.toInt() + } catch(e: NumberFormatException) { + defaultValue + } + + if (this != null) { + map { proxyXml-> + ProxyConfig(proxyXml.host, toIntOr(proxyXml.port, 0), proxyXml.type, proxyXml.nonProxyHosts) + } + } else { + null + } + } + + val kobaltCompilerVersion : String? + get() { + return if (BUILD_SCRIPT_CONFIG != null && BUILD_SCRIPT_CONFIG?.kobaltCompilerVersion != null) { + BUILD_SCRIPT_CONFIG?.kobaltCompilerVersion + } else { + xmlFile.kobaltCompilerVersion + } + } + + val kobaltCompilerRepo : String? + get() { + return if (BUILD_SCRIPT_CONFIG != null && BUILD_SCRIPT_CONFIG?.kobaltCompilerRepo != null) { + BUILD_SCRIPT_CONFIG?.kobaltCompilerRepo + } else { + xmlFile.kobaltCompilerRepo + } + } + + val kobaltCompilerFlags : String? + get() { + return if (BUILD_SCRIPT_CONFIG != null && BUILD_SCRIPT_CONFIG?.kobaltCompilerFlags != null) { + BUILD_SCRIPT_CONFIG?.kobaltCompilerFlags + } else { + xmlFile.kobaltCompilerFlags + } + } + + companion object { + val SETTINGS_FILE_PATH = KFiles.joinDir(KFiles.HOME_KOBALT_DIR.absolutePath, "settings.xml") + + fun readSettingsXml() : KobaltSettings { + val file = File(KobaltSettings.SETTINGS_FILE_PATH) + if (file.exists()) { + FileInputStream(file).use { + val jaxbContext = JAXBContext.newInstance(KobaltSettingsXml::class.java) + val xmlFile: KobaltSettingsXml = jaxbContext.createUnmarshaller().unmarshal(it) + as KobaltSettingsXml + val result = KobaltSettings(xmlFile) + return result + } + } else { + kobaltLog(2, "Couldn't find ${KobaltSettings.SETTINGS_FILE_PATH}, using default settings") + return KobaltSettings(KobaltSettingsXml()) + } + } + } + +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/KotlinJarFiles.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/KotlinJarFiles.kt new file mode 100644 index 00000000..123e8b76 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/KotlinJarFiles.kt @@ -0,0 +1,20 @@ +package com.beust.kobalt.internal + +import com.beust.kobalt.maven.DependencyManager +import com.google.inject.Inject +import java.io.File + +/** + * The jar files that Kotlin needs to run. + */ +class KotlinJarFiles @Inject constructor(val dependencyManager: DependencyManager, + val settings: KobaltSettings){ + private fun getKotlinCompilerJar(name: String): File { + val id = "org.jetbrains.kotlin:kotlin-$name:${settings.kobaltCompilerVersion}" + val dep = dependencyManager.create(id) + return dep.jarFile.get().absoluteFile + } + + val stdlib: File get() = getKotlinCompilerJar("stdlib") + val compiler: File get() = getKotlinCompilerJar("compiler-embeddable") +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/KotlinTestRunner.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/KotlinTestRunner.kt new file mode 100644 index 00000000..24e643d5 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/KotlinTestRunner.kt @@ -0,0 +1,21 @@ +package com.beust.kobalt.internal + +import com.beust.kobalt.api.KobaltContext +import com.beust.kobalt.api.Project + +/** + * KotlinTestRunner triggers if it finds a dependency on io.kotlintest but other than that, it just + * uses the regular JUnitRunner. + */ +class KotlinTestRunner : JUnitRunner() { + override val dependencyName = "io.kotlintest" + override val runnerName = "Kotlin Test" + + /** + * KotlinTestRunner runs tests in the init{} initializer, so ignore all the extra + * classes generated by the Kotlin compiler. + */ + override fun filterTestClasses(projet: Project, context: KobaltContext, classes: List) + = classes.filter { !it.contains("$") } +} + diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/ParallelLogger.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/ParallelLogger.kt new file mode 100644 index 00000000..519a94c9 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/ParallelLogger.kt @@ -0,0 +1,130 @@ +package com.beust.kobalt.internal + +import com.beust.kobalt.Args +import com.beust.kobalt.KobaltException +import com.beust.kobalt.misc.* +import com.google.inject.Inject +import com.google.inject.Singleton +import java.util.* +import java.util.concurrent.ConcurrentHashMap +import java.util.concurrent.ConcurrentLinkedQueue + +interface ILogger { + fun log(tag: CharSequence, level: Int, message: CharSequence, newLine: Boolean = true) +} + +/** + * This class manages logs for parallel builds. These logs come from multiple projects interwoven as + * they are being scheduled on different threads. This class maintains a "current" project which has + * its logs always displayed instantaneously while logs from other projects are being stored for later display. + * Once the current project is done, this class will catch up all the finished project logs and then + * pick the next current project to be displayed live. + * + * Yes, this code was pretty painful to write and I'm pretty sure it can be made less ugly. + */ +@Singleton +class ParallelLogger @Inject constructor(val args: Args) : ILogger { + enum class Type { LOG, WARN, ERROR } + + class LogLine(val name: CharSequence? = null, val level: Int, val message: CharSequence, val type: Type, + val newLine: Boolean) + private val logLines = ConcurrentHashMap>() + + private val runningProjects = ConcurrentLinkedQueue() + var startTime: Long? = null + + fun onProjectStarted(name: String) { + if (startTime == null) { + startTime = System.currentTimeMillis() + } + runningProjects.add(name) + logLines[name] = arrayListOf() + if (currentName == null) { + currentName = name + } + } + + val stoppedProjects = ConcurrentHashMap() + + fun onProjectStopped(name: String) { + debug("onProjectStopped($name)") + stoppedProjects[name] = name + + if (name == currentName && runningProjects.any()) { + emptyProjectLog(name) + var nextProject = runningProjects.peek() + while (nextProject != null && stoppedProjects.containsKey(nextProject)) { + val sp = runningProjects.remove() + emptyProjectLog(sp) + nextProject = runningProjects.peek() + } + currentName = nextProject + } else { + debug("Non current project $name stopping, not doing anything") + } + } + + private fun debug(s: CharSequence) { + if (args.log >= 3) { + val time = System.currentTimeMillis() - startTime!! + kobaltLog(1, " ### [$time] $s") + } + } + + val LOCK = Any() + var currentName: String? = null + set(newName) { + field = newName + } + + private fun displayLine(ll: LogLine) { + val time = System.currentTimeMillis() - startTime!! + val m = (if (args.dev) "### [$time] " else "") + ll.message + when(ll.type) { + Type.LOG -> kobaltLog(ll.level, m, ll.newLine) + Type.WARN -> kobaltWarn(m) + Type.ERROR -> kobaltError(m) + } + } + + private fun emptyProjectLog(name: CharSequence?) { + val lines = logLines[name] + if (lines != null && lines.any()) { + debug("emptyProjectLog($name)") + lines.forEach { + displayLine(it) + } + lines.clear() + debug("Done emptyProjectLog($name)") +// logLines.remove(name) + } else if (lines == null) { + throw KobaltException("Didn't call onStartProject() for $name") + } + } + + private fun addLogLine(name: CharSequence, ll: LogLine) { + if (name != currentName) { + val list = logLines[name] ?: arrayListOf() + logLines[name] = list + list.add(ll) + } else { + emptyProjectLog(name) + displayLine(ll) + } + } + + override fun log(tag: CharSequence, level: Int, message: CharSequence, newLine: Boolean) { + if (args.sequential) { + kobaltLog(level, message, newLine) + } else { + addLogLine(tag, LogLine(tag, level, message, Type.LOG, newLine)) + } + } + + fun shutdown() { + runningProjects.forEach { + emptyProjectLog(it) + } + kobaltLog(1, "") + } +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/ParallelProjectRunner.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/ParallelProjectRunner.kt new file mode 100644 index 00000000..d98f0d8a --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/ParallelProjectRunner.kt @@ -0,0 +1,114 @@ +package com.beust.kobalt.internal + +import com.beust.kobalt.Args +import com.beust.kobalt.AsciiArt +import com.beust.kobalt.TaskResult +import com.beust.kobalt.api.ITask +import com.beust.kobalt.api.Kobalt +import com.beust.kobalt.api.Project +import com.beust.kobalt.api.ProjectBuildStatus +import com.beust.kobalt.misc.kobaltLog +import com.google.common.collect.ListMultimap +import com.google.common.collect.TreeMultimap +import java.util.concurrent.Callable + +/** + * Build the projects in parallel. + * + * The projects are sorted in topological order and then run by the DynamicGraphExecutor in background threads + * wherever appropriate. Inside a project, all the tasks are run sequentially. + */ +class ParallelProjectRunner(val tasksByNames: (Project) -> ListMultimap, + val dependsOn: TreeMultimap, + val reverseDependsOn: TreeMultimap, val runBefore: TreeMultimap, + val runAfter: TreeMultimap, + val alwaysRunAfter: TreeMultimap, val args: Args, val pluginInfo: PluginInfo, + val logger: ParallelLogger) + : BaseProjectRunner() { + override fun runProjects(taskInfos: List, projects: List) + : TaskManager .RunTargetResult { + class ProjectTask(val project: Project, val dryRun: Boolean) : Callable> { + override fun toString() = "[ProjectTask " + project.name + "]" + override fun hashCode() = project.hashCode() + override fun equals(other: Any?) : Boolean = + if (other is ProjectTask) other.project.name == project.name + else false + + override fun call(): TaskResult2 { + val context = Kobalt.context!! + runBuildListenersForProject(project, context, true) + val tasksByNames = tasksByNames(project) + val graph = createTaskGraph(project.name, taskInfos, tasksByNames, + dependsOn, reverseDependsOn, runBefore, runAfter, alwaysRunAfter, + ITask::name, + { task: ITask -> task.plugin.accept(project) }) + var lastResult = TaskResult() + logger.onProjectStarted(project.name) + context.logger.log(project.name, 1, AsciiArt.logBox("Building ${project.name}", indent = 5)) + while (graph.freeNodes.any()) { + val toProcess = graph.freeNodes + toProcess.forEach { node -> + val tasks = tasksByNames[node.name] + tasks.forEach { task -> + + runBuildListenersForTask(project, context, task.name, start = true) + logger.log(project.name, 1, + AsciiArt.taskColor(AsciiArt.horizontalSingleLine + " ${project.name}:${task.name}")) + val thisResult = if (dryRun) TaskResult2(true, value = task) else task.call() + if (lastResult.success) { + lastResult = thisResult + } + runBuildListenersForTask(project, context, task.name, start = false, + success = thisResult.success, testResult = thisResult.testResult) + } + } + graph.freeNodes.forEach { graph.removeNode(it) } + } + + logger.onProjectStopped(project.name) + runBuildListenersForProject(project, context, false, + if (lastResult.success) ProjectBuildStatus.SUCCESS else ProjectBuildStatus.FAILED) + + return TaskResult2(lastResult.success, errorMessage = lastResult.errorMessage, value = this) + } + + } + + val factory = object : IThreadWorkerFactory { + override fun createWorkers(nodes: Collection): List> { + val result = nodes.map { it -> + object: IWorker { + override val priority: Int get() = 0 + override val name: String get() = it.project.name + override fun call(): TaskResult2 { + val tr = it.call() + return tr + } + + } + } + return result + } + } + + val projectGraph = DynamicGraph().apply { + projects.forEach { project -> + addNode(ProjectTask(project, args.dryRun)) + project.allProjectDependedOn().forEach { + addEdge(ProjectTask(project, args.dryRun), ProjectTask(it, args.dryRun)) + } + } + } + + val executor = DynamicGraphExecutor(projectGraph, factory, 5) + kobaltLog(1, "Parallel build starting") + val taskResult = executor.run() + + logger.shutdown() + + if (! args.sequential) { + executor.dumpHistory() + } + return TaskManager.RunTargetResult(taskResult, emptyList()) + } +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/ProjectInfo.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/ProjectInfo.kt index ce23efc3..df865cec 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/ProjectInfo.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/ProjectInfo.kt @@ -5,28 +5,51 @@ import com.beust.kobalt.api.BuildConfig import com.beust.kobalt.api.BuildConfigField import com.beust.kobalt.api.KobaltContext import com.beust.kobalt.api.Project -import java.util.* /** * Data that is useful for projects to have but should not be specified in the DSL. */ -interface IProjectInfo { - /** Used to determine the last directory segment of the flavored sources, e.g. src/main/JAVA */ - val sourceDirectory : String - - val defaultSourceDirectories: HashSet - val defaultTestDirectories: HashSet - +interface IBuildConfig { /** * If at least one build config was found either on the project or the variant, this function - * will be used to generate the BuildConfig file with the correct language. + * will be used to generateAndSave the BuildConfig file with the correct language. */ fun generateBuildConfig(project: Project, context: KobaltContext, packageName: String, variant: Variant, buildConfigs: List) : String + } -interface BaseProjectInfo : IProjectInfo { - fun generate(field: BuildConfigField) : String +abstract class BaseBuildConfig : IBuildConfig { + abstract fun generate(field: BuildConfigField) : String + + /** + * Add all the fields found in 1) the field contributors 2) the build configs and 3) the default config + */ + fun generateCommonPart(project: Project, context: KobaltContext, buildConfigs: List) : List { + val result = arrayListOf() + + // Fields from the field contributors + result.addAll(generateFieldsFromContributors(project, context)) + + val seen = hashSetOf() + + // Fields from the build config + buildConfigs.forEach { + it.fields.forEach { field -> + result.add(generate(field.type, field.name, field.value)) + seen.add(field) + } + } + + // Add all the fields in the default config that haven't been added yet + project.defaultConfig?.let { + it.fields.filter { ! seen.contains(it) }.forEach { + result.add(generate(it.type, it.name, it.value)) + } + } + return result + } + fun generate(type: String, name: String, value: Any) = generate(BuildConfigField(type, name, value)) fun generateFieldsFromContributors(project: Project, context: KobaltContext) diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/SequentialProjectRunner.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/SequentialProjectRunner.kt new file mode 100644 index 00000000..ec99b723 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/SequentialProjectRunner.kt @@ -0,0 +1,96 @@ +package com.beust.kobalt.internal + +import com.beust.kobalt.Args +import com.beust.kobalt.AsciiArt +import com.beust.kobalt.TaskResult +import com.beust.kobalt.api.ITask +import com.beust.kobalt.api.Kobalt +import com.beust.kobalt.api.Project +import com.beust.kobalt.api.ProjectBuildStatus +import com.beust.kobalt.misc.Strings +import com.beust.kobalt.misc.kobaltError +import com.google.common.collect.ListMultimap +import com.google.common.collect.TreeMultimap +import java.util.* + +/** + * Build the projects in parallel. + * + * The projects are sorted in topological order and then run by the DynamicGraphExecutor in a single thread. + */ +class SequentialProjectRunner(val tasksByNames: (Project) -> ListMultimap, + val dependsOn: TreeMultimap, + val reverseDependsOn: TreeMultimap, val runBefore: TreeMultimap, + val runAfter: TreeMultimap, + val alwaysRunAfter: TreeMultimap, val args: Args, val pluginInfo: PluginInfo) + : BaseProjectRunner() { + + override fun runProjects(taskInfos: List, projects: List) + : TaskManager.RunTargetResult { + var result = TaskResult() + val failedProjects = hashSetOf() + val messages = Collections.synchronizedList(arrayListOf()) + + val context = Kobalt.context!! + + projects.forEach { project -> + val projectName = project.name + fun klog(level: Int, message: String) = context.logger.log(projectName, level, message) + klog(1, AsciiArt.logBox("Building $projectName", indent = 5)) + + // Does the current project depend on any failed projects? + val fp = project.allProjectDependedOn().filter { failedProjects.contains(it.name) }.map(Project::name) + + if (fp.size > 0) { + klog(2, "Marking project $projectName as skipped") + failedProjects.add(project.name) + runBuildListenersForProject(project, context, false, ProjectBuildStatus.SKIPPED) + kobaltError("Not building project ${project.name} since it depends on failed " + + Strings.pluralize(fp.size, "project") + + " " + fp.joinToString(",")) + } else { + runBuildListenersForProject(project, context, true) + + // There can be multiple tasks by the same name (e.g. PackagingPlugin and AndroidPlugin both + // define "install"), so use a multimap + val tasksByNames = tasksByNames(project) + + klog(3, "Tasks:") + tasksByNames.keys().forEach { + klog(3, " $it: " + tasksByNames.get(it)) + } + + val graph = createTaskGraph(project.name, taskInfos, tasksByNames, + dependsOn, reverseDependsOn, runBefore, runAfter, alwaysRunAfter, + ITask::name, + { task: ITask -> task.plugin.accept(project) }) + + // + // Now that we have a full graph, run it + // + klog(2, "About to run graph:\n ${graph.dump()} ") + + val factory = object : IThreadWorkerFactory { + override fun createWorkers(nodes: Collection) + = nodes.map { TaskWorker(listOf(it), args.dryRun, pluginInfo) } + } + + val executor = DynamicGraphExecutor(graph, factory) + val thisResult = executor.run() + if (! thisResult.success) { + klog(2, "Marking project ${project.name} as failed") + failedProjects.add(project.name) + } + + runBuildListenersForProject(project, context, false, + if (thisResult.success) ProjectBuildStatus.SUCCESS else ProjectBuildStatus.FAILED) + + if (result.success) { + result = thisResult + } + } + } + + return TaskManager.RunTargetResult(result, messages) + } +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/SourceSet.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/SourceSet.kt new file mode 100644 index 00000000..7d606906 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/SourceSet.kt @@ -0,0 +1,22 @@ +package com.beust.kobalt.internal + +import com.beust.kobalt.KobaltException +import com.beust.kobalt.api.Project +import com.beust.kobalt.misc.KFiles + +enum class SourceSet(val outputDir: String) { + MAIN(KFiles.CLASSES_DIR), + TEST(KFiles.TEST_CLASSES_DIR); + + fun correctSourceSet(project: Project) = when(this) { + SourceSet.MAIN -> project.sourceDirectories + SourceSet.TEST -> project.sourceDirectoriesTest + else -> unknown(this) + } + + companion object { + fun of(isTest: Boolean) = if (isTest) TEST else MAIN + private fun unknown(sourceSet: SourceSet) : Nothing = throw KobaltException("Unknown source set: $sourceSet") + } +} + diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/SpekRunner.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/SpekRunner.kt index b3feaf69..0c1ddad6 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/SpekRunner.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/SpekRunner.kt @@ -4,7 +4,8 @@ package com.beust.kobalt.internal * SpekRunner triggers if it finds a dependency on org.jetbrains.spek but other than that, it just * uses the regular JUnitRunner. */ -public class SpekRunner() : JUnitRunner() { +class SpekRunner : JUnitRunner() { override val dependencyName = "org.jetbrains.spek" + override val runnerName = "Spek" } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/TaskManager.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/TaskManager.kt index a191c1cf..99aa7624 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/TaskManager.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/TaskManager.kt @@ -1,15 +1,13 @@ package com.beust.kobalt.internal import com.beust.kobalt.* -import com.beust.kobalt.api.DynamicTask -import com.beust.kobalt.api.IPlugin -import com.beust.kobalt.api.PluginTask -import com.beust.kobalt.api.Project +import com.beust.kobalt.api.* import com.beust.kobalt.api.annotation.IncrementalTask import com.beust.kobalt.api.annotation.Task -import com.beust.kobalt.misc.log +import com.beust.kobalt.misc.Topological +import com.beust.kobalt.misc.kobaltLog import com.google.common.collect.ArrayListMultimap -import com.google.common.collect.Multimap +import com.google.common.collect.ListMultimap import com.google.common.collect.TreeMultimap import java.lang.reflect.Method import java.util.* @@ -17,204 +15,161 @@ import javax.inject.Inject import javax.inject.Singleton @Singleton -public class TaskManager @Inject constructor(val args: Args) { +class TaskManager @Inject constructor(val args: Args, + val incrementalManagerFactory: IncrementalManager.IFactory, + val kobaltLog: ParallelLogger) { + private val dependsOn = TreeMultimap.create() + private val reverseDependsOn = TreeMultimap.create() private val runBefore = TreeMultimap.create() + private val runAfter = TreeMultimap.create() private val alwaysRunAfter = TreeMultimap.create() /** - * Called by plugins to indicate task dependencies defined at runtime. Keys depend on values. - * Declare that `task1` depends on `task2`. - * - * Note: there is no runAfter on this class since a runAfter(a, b) in a task simply translates - * to a runBefore(b, a) here. + * Dependency: task2 depends on task 1. */ - fun runBefore(task1: String, task2: String) { - runBefore.put(task1, task2) - } + fun dependsOn(task1: String, task2: String) = dependsOn.put(task2, task1) - fun alwaysRunAfter(task1: String, task2: String) { - alwaysRunAfter.put(task1, task2) - } + /** + * Dependency: task2 depends on task 1. + */ + fun reverseDependsOn(task1: String, task2: String) = reverseDependsOn.put(task2, task1) + + /** + * Ordering: task1 runs before task 2. + */ + fun runBefore(task1: String, task2: String) = runBefore.put(task2, task1) + + /** + * Ordering: task2 runs after task 1. + */ + fun runAfter(task1: String, task2: String) = runAfter.put(task1, task2) + + /** + * Wrapper task: task2 runs after task 1. + */ + fun alwaysRunAfter(task1: String, task2: String) = alwaysRunAfter.put(task2, task1) data class TaskInfo(val id: String) { constructor(project: String, task: String) : this(project + ":" + task) val project: String? - get() = if (id.contains(":")) id.split(":")[0] else null + get() = if (id.contains(':')) id.split(':')[0] else null val taskName: String - get() = if (id.contains(":")) id.split(":")[1] else id + get() = if (id.contains(':')) id.split(':')[1] else id + fun matches(projectName: String) = project == null || project == projectName + + override fun toString() = id } - public fun runTargets(taskNames: List, projects: List) : Int { - var result = 0 - projects.forEach { project -> - val projectName = project.name - // There can be multiple tasks by the same name (e.g. PackagingPlugin and AndroidPlugin both - // define "install"), so use a multimap - val tasksByNames = ArrayListMultimap.create() + class RunTargetResult(val taskResult: TaskResult, val timings: List) + + /** + * @return the list of tasks available for the given project. + * + * There can be multiple tasks by the same name (e.g. PackagingPlugin and AndroidPlugin both + * define "install"), so return a multimap. + */ + fun tasksByNames(project: Project): ListMultimap { + return ArrayListMultimap.create().apply { annotationTasks.filter { it.project.name == project.name }.forEach { - tasksByNames.put(it.name, it) - } - - AsciiArt.logBox("Building ${project.name}") - - log(3, "Tasks:") - tasksByNames.keys().forEach { - log(3, " $it: " + tasksByNames.get(it)) - } - val graph = DynamicGraph() - taskNames.forEach { taskName -> - val ti = TaskInfo(taskName) - if (! tasksByNames.keys().contains(ti.taskName)) { - throw KobaltException("Unknown task: $taskName") - } - - if (ti.matches(projectName)) { - tasksByNames[ti.taskName].forEach { task -> - if (task != null && task.plugin.accept(project)) { - val reverseAfter = hashMapOf() - alwaysRunAfter.keys().forEach { from -> - val tasks = alwaysRunAfter.get(from) - tasks.forEach { - reverseAfter.put(it, from) - } - } - - // - // If the current target is free, add it as a single node to the graph - // - val allFreeTasks = calculateFreeTasks(tasksByNames, reverseAfter) - val currentFreeTask = allFreeTasks.filter { - TaskInfo(projectName, it.name).taskName == task.name - } - if (currentFreeTask.size == 1) { - currentFreeTask[0].let { - graph.addNode(it) - } - } - - // - // Add the transitive closure of the current task as edges to the graph - // - val transitiveClosure = calculateTransitiveClosure(project, tasksByNames, ti) - transitiveClosure.forEach { pluginTask -> - val rb = runBefore.get(pluginTask.name) - rb.forEach { - val tos = tasksByNames[it] - if (tos != null && tos.size > 0) { - tos.forEach { to -> - graph.addEdge(pluginTask, to) - } - } else { - log(2, "Couldn't find node $it: not applicable to project ${project.name}") - } - } - } - - // - // If any of the nodes in the graph has an "alwaysRunAfter", add that edge too - // - val allNodes = arrayListOf() - allNodes.addAll(graph.nodes) - allNodes.forEach { node -> - val other = alwaysRunAfter.get(node.name) - other?.forEach { o -> - tasksByNames[o]?.forEach { - graph.addEdge(it, node) - } - } - } - } - } - } - } - - // - // Now that we have a full graph, run it - // - log(3, "About to run graph:\n ${graph.dump()} ") - - val factory = object : IThreadWorkerFactory { - override public fun createWorkers(nodes: List): List> { - val thisResult = arrayListOf>() - nodes.forEach { - thisResult.add(TaskWorker(arrayListOf(it), args.dryRun)) - } - return thisResult - } - } - - val executor = DynamicGraphExecutor(graph, factory) - val thisResult = executor.run() - if (result == 0) { - result = thisResult - } - - } - return result - } - - /** - * Find the free tasks of the graph. - */ - private fun calculateFreeTasks(tasksByNames: Multimap, reverseAfter: HashMap) - : Collection { - val freeTaskMap = hashMapOf() - tasksByNames.keys().forEach { - if (! runBefore.containsKey(it) && ! reverseAfter.containsKey(it)) { - tasksByNames[it].forEach { t -> - freeTaskMap.put(it, t) - } + put(it.name, it) } } - - return freeTaskMap.values } - /** - * Find the transitive closure for the given TaskInfo - */ - private fun calculateTransitiveClosure(project: Project, tasksByNames: Multimap, ti: TaskInfo): - HashSet { - log(3, "Processing ${ti.taskName}") +// @Inject +// lateinit var pluginInfo: PluginInfo - val transitiveClosure = hashSetOf() - val seen = hashSetOf(ti.taskName) - val toProcess = hashSetOf(ti) - var done = false - while (! done) { - val newToProcess = hashSetOf() - log(3, "toProcess size: " + toProcess.size) - toProcess.forEach { target -> + fun runTargets(passedTaskNames: List, allProjects: List): RunTargetResult { + // Check whether tasks passed at command line exist + passedTaskNames.forEach { + if (!hasTask(TaskInfo(it))) + throw KobaltException("Unknown task: $it") + } - val currentTask = TaskInfo(project.name, target.taskName) - val thisTask = tasksByNames[currentTask.taskName] - if (thisTask != null) { - transitiveClosure.addAll(thisTask) - val dependencyNames = runBefore.get(currentTask.taskName) - dependencyNames.forEach { dependencyName -> - if (!seen.contains(dependencyName)) { - newToProcess.add(currentTask) - seen.add(dependencyName) - } - } + val pluginInfo = Kobalt.INJECTOR.getInstance(PluginInfo::class.java) + var taskInfos = calculateDependentTaskNames(passedTaskNames, allProjects) - dependencyNames.forEach { - newToProcess.add(TaskInfo(project.name, it)) - } + // Remove non existing tasks (e.g. dynamic task defined for a single project) + taskInfos = taskInfos.filter { hasTask(it) } + + val projectsToRun = findProjectsToRun(taskInfos, allProjects) + val projectRunner = + if (args.sequential) { + SequentialProjectRunner({ p -> tasksByNames(p) }, dependsOn, + reverseDependsOn, runBefore, runAfter, alwaysRunAfter, args, pluginInfo) } else { - log(2, "Couldn't find task ${currentTask.taskName}: not applicable to project ${project.name}") - } + ParallelProjectRunner({ p -> tasksByNames(p) }, dependsOn, + reverseDependsOn, runBefore, runAfter, alwaysRunAfter, args, pluginInfo, kobaltLog) } - done = newToProcess.isEmpty() - toProcess.clear() - toProcess.addAll(newToProcess) + return projectRunner.runProjects(taskInfos, projectsToRun) + } + + /** + * Determine which projects to run based on the request tasks. Also make sure that all the requested projects + * exist. + */ + private fun findProjectsToRun(taskInfos: List, projects: List) : List { + + // Validate projects + val result = LinkedHashSet() + val projectMap = HashMap().apply { + projects.forEach { put(it.name, it)} } - return transitiveClosure + // Extract all the projects we need to run from the tasks + taskInfos.forEach { + val p = it.project + if (p != null && ! projectMap.containsKey(p)) { + throw KobaltException("Unknown project: ${it.project}") + } + result.add(projectMap[it.project]!!) + } + + // If at least one task didn't specify a project, run them all + return if (result.any()) result.toList() else projects + } + + class ProfilerInfo(val taskName: String, val durationMillis: Long) + + /** + * If the user wants to run a single task on a single project (e.g. "kobalt:assemble"), we need to + * see if that project depends on others and if it does, compile these projects first. This + * function returns all these task names (including the dependent ones). + */ + fun calculateDependentTaskNames(taskNames: List, projects: List): List { + return taskNames.flatMap { calculateDependentTaskNames(it, projects) } + } + + private fun calculateDependentTaskNames(taskName: String, projects: List): List { + fun sortProjectsTopologically(projects: List) : List { + val topological = Topological().apply { + projects.forEach { project -> + addNode(project) + project.allProjectDependedOn().forEach { + addEdge(project, it) + } + } + } + val sortedProjects = topological.sort() + return sortedProjects + } + + val ti = TaskInfo(taskName) + if (ti.project == null) { + val result = sortProjectsTopologically(projects).map { TaskInfo(it.name, taskName) } + return result + } else { + val rootProject = projects.find { it.name == ti.project }!! + val allProjects = DynamicGraph.transitiveClosure(rootProject, Project::allProjectDependedOn) + val sortedProjects = sortProjectsTopologically(allProjects) + val sortedMaps = sortedProjects.map { TaskInfo(it.name, "compile")} + val result = sortedMaps.subList(0, sortedMaps.size - 1) + listOf(ti) + return result + } } ///// @@ -226,17 +181,23 @@ public class TaskManager @Inject constructor(val args: Args) { private val taskAnnotations = arrayListOf() class TaskAnnotation(val method: Method, val plugin: IPlugin, val name: String, val description: String, - val runBefore: Array, val runAfter: Array, val alwaysRunAfter: Array, - val callable: (Project) -> TaskResult) + val group: String, + val dependsOn: Array, val reverseDependsOn: Array, + val runBefore: Array, val runAfter: Array, + val alwaysRunAfter: Array, + val callable: (Project) -> TaskResult) { + override fun toString() = "[TaskAnnotation $name]" + } /** * Invoking a @Task means simply calling the method and returning its returned TaskResult. */ fun toTaskAnnotation(method: Method, plugin: IPlugin, ta: Task) - = TaskAnnotation(method, plugin, ta.name, ta.description, ta.runBefore, ta.runAfter, ta.alwaysRunAfter, + = TaskAnnotation(method, plugin, ta.name, ta.description, ta.group, ta.dependsOn, ta.reverseDependsOn, + ta.runBefore, ta.runAfter, ta.alwaysRunAfter, { project -> + Kobalt.context?.variant = Variant() method.invoke(plugin, project) as TaskResult - }) /** @@ -244,20 +205,17 @@ public class TaskManager @Inject constructor(val args: Args) { * of the returned IncrementalTaskInfo. */ fun toTaskAnnotation(method: Method, plugin: IPlugin, ta: IncrementalTask) - = TaskAnnotation(method, plugin, ta.name, ta.description, ta.runBefore, ta.runAfter, ta.alwaysRunAfter, - { project -> - val iit = method.invoke(plugin, project) as IncrementalTaskInfo - // TODO: compare the checksums with the previous run - iit.task(project) - }) - - class PluginDynamicTask(val plugin: IPlugin, val task: DynamicTask) + = TaskAnnotation(method, plugin, ta.name, ta.description, ta.group, ta.dependsOn, ta.reverseDependsOn, + ta.runBefore, ta.runAfter, ta.alwaysRunAfter, + incrementalManagerFactory.create().toIncrementalTaskClosure(ta.name, { project -> + method.invoke(plugin, project) as IncrementalTaskInfo + }, Variant())) /** Tasks annotated with @Task or @IncrementalTask */ val annotationTasks = arrayListOf() /** Tasks provided by ITaskContributors */ - val dynamicTasks = arrayListOf() + val dynamicTasks = arrayListOf() fun addAnnotationTask(plugin: IPlugin, method: Method, annotation: Task) = taskAnnotations.add(toTaskAnnotation(method, plugin, annotation)) @@ -270,16 +228,14 @@ public class TaskManager @Inject constructor(val args: Args) { */ fun computePluginTasks(projects: List) { installAnnotationTasks(projects) - installDynamicTasks(projects) + installDynamicTasks() } - private fun installDynamicTasks(projects: List) { - dynamicTasks.forEach { dynamicTask -> - val task = dynamicTask.task - projects.filter { dynamicTask.plugin.accept(it) }.forEach { project -> - addTask(dynamicTask.plugin, project, task.name, task.description, task.runBefore, task.runAfter, - task.alwaysRunAfter, task.closure) - } + private fun installDynamicTasks() { + dynamicTasks.forEach { task -> + addTask(task.plugin, task.project, task.name, task.doc, task.group, + task.dependsOn, task.reverseDependsOn, task.runBefore, task.runAfter, task.alwaysRunAfter, + task.closure) } } @@ -288,7 +244,7 @@ public class TaskManager @Inject constructor(val args: Args) { val method = staticTask.method val methodName = method.declaringClass.toString() + "." + method.name - log(3, " Found task:${staticTask.name} method: $methodName") + kobaltLog(3, " Found task:${staticTask.name} method: $methodName") val plugin = staticTask.plugin projects.filter { plugin.accept(it) }.forEach { project -> @@ -299,55 +255,80 @@ public class TaskManager @Inject constructor(val args: Args) { private fun addAnnotationTask(plugin: IPlugin, project: Project, annotation: TaskAnnotation, task: (Project) -> TaskResult) { - addTask(plugin, project, annotation.name, annotation.description, annotation.runBefore.toList(), - annotation.runAfter.toList(), annotation.alwaysRunAfter.toList(), task) + addTask(plugin, project, annotation.name, annotation.description, annotation.group, + annotation.dependsOn.toList(), annotation.reverseDependsOn.toList(), + annotation.runBefore.toList(), annotation.runAfter.toList(), + annotation.alwaysRunAfter.toList(), task) } - fun addTask(plugin: IPlugin, project: Project, name: String, description: String = "", + fun addTask(plugin: IPlugin, project: Project, name: String, description: String = "", group: String, + dependsOn: List = listOf(), + reverseDependsOn: List = listOf(), runBefore: List = listOf(), runAfter: List = listOf(), alwaysRunAfter: List = listOf(), task: (Project) -> TaskResult) { annotationTasks.add( - object : BasePluginTask(plugin, name, description, project) { - override fun call(): TaskResult2 { + object : BasePluginTask(plugin, name, description, group, project) { + override fun call(): TaskResult2 { val taskResult = task(project) - return TaskResult2(taskResult.success, taskResult.errorMessage, this) + return TaskResult2(taskResult.success, errorMessage = taskResult.errorMessage, value = this, + testResult = taskResult.testResult) } }) + dependsOn.forEach { dependsOn(it, name) } + reverseDependsOn.forEach { reverseDependsOn(it, name) } runBefore.forEach { runBefore(it, name) } - runAfter.forEach { runBefore(name, it) } - alwaysRunAfter.forEach { alwaysRunAfter(it, name)} + runAfter.forEach { runAfter(it, name) } + alwaysRunAfter.forEach { alwaysRunAfter(it, name) } + } + + fun hasTask(ti: TaskInfo): Boolean { + val taskName = ti.taskName + val project = ti.project + return annotationTasks.any { taskName == it.name && (project == null || project == it.project.name) } + } + + /** + * Invoked by the server whenever it's done processing a command so the state can be reset for the next command. + */ + fun cleanUp() { + annotationTasks.clear() + dynamicTasks.clear() + taskAnnotations.clear() } // - // + // Manage the tasks ///// - } -class TaskWorker(val tasks: List, val dryRun: Boolean) : IWorker { -// override fun compareTo(other: IWorker2): Int { -// return priority.compareTo(other.priority) -// } +class TaskWorker(val tasks: List, val dryRun: Boolean, val pluginInfo: PluginInfo) : IWorker { - override fun call() : TaskResult2 { + override fun call() : TaskResult2 { if (tasks.size > 0) { tasks[0].let { - log(1, AsciiArt.taskColor(AsciiArt.horizontalSingleLine + " ${it.project.name}:${it.name}")) + kobaltLog(1, AsciiArt.taskColor(AsciiArt.horizontalSingleLine + " ${it.project.name}:${it.name}")) } } var success = true val errorMessages = arrayListOf() + val context = Kobalt.context!! tasks.forEach { + val name = it.project.name + ":" + it.name + BaseProjectRunner.runBuildListenersForTask(it.project, context, name, start = true) val tr = if (dryRun) TaskResult() else it.call() + BaseProjectRunner.runBuildListenersForTask(it.project, context, name, start = false, success = tr.success) success = success and tr.success - if (tr.errorMessage != null) errorMessages.add(tr.errorMessage) + tr.errorMessage?.let { + errorMessages.add(it) + } } - return TaskResult2(success, errorMessages.joinToString("\n"), tasks[0]) + return TaskResult2(success, errorMessage = errorMessages.joinToString("\n"), value = tasks[0]) } // override val timeOut : Long = 10000 override val priority: Int = 0 -} \ No newline at end of file + override val name: String get() = "[Taskworker " + tasks.map(ITask::toString).joinToString(",") + "]" +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/TestNgRunner.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/TestNgRunner.kt index fb2e0dba..f4ee96f8 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/TestNgRunner.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/TestNgRunner.kt @@ -1,27 +1,268 @@ package com.beust.kobalt.internal +import com.beust.kobalt.AsciiArt +import com.beust.kobalt.TestConfig +import com.beust.kobalt.TestResult import com.beust.kobalt.api.IClasspathDependency +import com.beust.kobalt.api.KobaltContext import com.beust.kobalt.api.Project -import com.beust.kobalt.misc.KFiles +import com.beust.kobalt.maven.aether.AetherDependency +import com.beust.kobalt.misc.* +import org.testng.remote.RemoteArgs +import org.testng.remote.strprotocol.JsonMessageSender +import org.testng.remote.strprotocol.MessageHelper +import org.testng.remote.strprotocol.MessageHub +import org.testng.remote.strprotocol.TestResultMessage +import org.w3c.dom.Attr +import org.w3c.dom.NodeList +import org.xml.sax.InputSource import java.io.File +import java.io.FileReader +import java.io.IOException +import javax.xml.parsers.DocumentBuilderFactory +import javax.xml.xpath.XPathConstants +import javax.xml.xpath.XPathFactory -public class TestNgRunner() : GenericTestRunner() { +class TestNgRunner : GenericTestRunner() { override val mainClass = "org.testng.TestNG" + override val dependencyName = "testng" + override val annotationPackage = "org.testng" + override val runnerName = "TestNG" - override val dependencyName = "org.testng" + private fun defaultOutputWithoutProjectDir(project: Project) + = KFiles.joinDir(project.buildDirectory, "test-output") + private fun defaultOutput(project: Project) + = KFiles.joinDir(project.directory, project.buildDirectory, "test-output") - override fun args(project: Project, classpath: List) = arrayListOf().apply { - if (project.testArgs.size > 0) { - addAll(project.testArgs) + override fun args(project: Project, context: KobaltContext, classpath: List, + testConfig: TestConfig) = arrayListOf().apply { + + if (KobaltLogger.isQuiet) { + add("-log") + add("0") + } + + if (testConfig.testArgs.none { it == "-d" }) { + add("-d") + // Don't include the project directory here since the generic runner will cd to that directory before + // running the tests + add(defaultOutputWithoutProjectDir(project)) + } + + if (testConfig.testArgs.size == 0) { + // No arguments, so we'll do it ourselves. Either testng.xml or the list of classes + val testngXml = File(project.directory, KFiles.joinDir("src", "test", "resources", "testng.xml")) + if (testngXml.exists()) { + add(testngXml.absolutePath) } else { - val testngXml = File(project.directory, KFiles.joinDir("src", "test", "resources", "testng.xml")) - if (testngXml.exists()) { - add(testngXml.absolutePath) - } else { + val testClasses = findTestClasses(project, context, testConfig) + if (testClasses.isNotEmpty()) { + addAll(testConfig.testArgs) + add("-testclass") - add(findTestClasses(project, classpath).joinToString(",")) + add(testClasses.joinToString(",")) + } else { + if (!testConfig.isDefault) warn("Couldn't find any test classes for ${project.name}") + // else do nothing: since the user didn't specify an explicit test{} directive, not finding + // any test sources is not a problem } } + } else { + addAll(testConfig.testArgs) } + } + + /** + * Extract test results from testng-results.xml and initialize shortMessage. + */ + override fun onFinish(project: Project) { + File(defaultOutput(project), "testng-results.xml").let { file -> + val ins = InputSource(FileReader(file)) + val doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(ins) + + val root = doc.documentElement + var failed = 0 + var skipped = 0 + var passed = 0 + val xp = XPathFactory.newInstance().newXPath() + val testMethods = xp.compile("/testng-results/suite/test/class/test-method[@status='FAIL']") + .evaluate(doc, XPathConstants.NODESET) + as NodeList + val failedMethods = arrayListOf() + repeat(testMethods.length) { + val tm = testMethods.item(it) + failedMethods.add(tm.attributes.getNamedItem("signature").textContent) + } + repeat(root.attributes.length) { + val attribute = root.attributes.item(it) + if (attribute is Attr) when (attribute.name) { + "failed" -> failed = Integer.parseInt(attribute.value) + "skipped" -> skipped = Integer.parseInt(attribute.value) + "passed" -> passed = Integer.parseInt(attribute.value) + } + } + + if (failed == 0) { + shortMessage = "$passed tests" + } else if (failed > 0) { + shortMessage = "$failed failed" + (if (skipped > 0) ", $skipped skipped" else "") + " tests" + longMessage = "Failed tests:\n " + failedMethods.joinToString("\n ") + } + } + } + + val VERSION_6_10 = StringVersion("6.10") + + fun _runTests(project: Project, context: KobaltContext, classpath: List, +// override fun runTests(project: Project, context: KobaltContext, classpath: List, + configName: String): TestResult { + + val testConfig = project.testConfigs.firstOrNull { it.name == configName } + + if (testConfig != null) { + context.logger.log(project.name, 1, "Running enhanced TestNG runner") + + val testngDependency = (project.testDependencies.filter { it.id.contains("testng") } + .firstOrNull() as AetherDependency).version + val versions = findRemoteRunnerVersion(testngDependency) + val useOldRunner = System.getProperty("testng.oldRunner") != null + val result = + if (versions != null && ! useOldRunner) { + context.logger.log(project.name, 1, "Modern TestNG, displaying colors") + displayPrettyColors(project, context, classpath, testConfig, versions) + } else { + context.logger.log(project.name, 1, "Older TestNG ($testngDependency), using the old runner") + super.runTests(project, context, classpath, configName) + } + return result + } else { + return TestResult(true) + } + } + + private fun findRemoteRunnerVersion(testngVersion: String) : Pair? { + val tng = StringVersion(testngVersion) + val result = + if (tng >= VERSION_6_10) Pair(testngVersion, "testng-remote6_10") + else if (tng >= StringVersion("6.9.10")) Pair("6.9.10", "testng-remote6_9_10") + else if (tng >= StringVersion("6.9.7")) Pair("6.9.7", "testng-remote6_9_7") + else if (tng >= StringVersion("6.5.1")) Pair("6.5.1", "testng-remote6_5_0") + else if (tng >= StringVersion("6.0")) Pair("6.0", "testng-remote6_0") + else null + return result + } + + private fun displayPrettyColors(project: Project, context: KobaltContext, + classpath: List, testConfig: TestConfig, versions: Pair) + : TestResult { + val port = 2345 +// launchRemoteServer(project, context, classpath, testConfig, versions, port) + + val mh = MessageHub(JsonMessageSender("localhost", port, true)) + mh.setDebug(true) + mh.initReceiver() + val passed = arrayListOf() + + data class FailedTest(val method: String, val cls: String, val stackTrace: String) + + val failed = arrayListOf() + val skipped = arrayListOf() + + fun d(n: Int, color: String) + = AsciiArt.wrap(String.format("%4d", n), color) + + fun red(s: String) = AsciiArt.wrap(s, AsciiArt.RED) + fun green(s: String) = AsciiArt.wrap(s, AsciiArt.GREEN) + fun yellow(s: String) = AsciiArt.wrap(s, AsciiArt.YELLOW) + + try { + var message = mh.receiveMessage() + kobaltLog(1, "") + kobaltLog(1, green("PASSED") + " | " + red("FAILED") + " | " + yellow("SKIPPED")) + while (message != null) { + message = mh.receiveMessage() + if (message is TestResultMessage) { + when (message.result) { + MessageHelper.PASSED_TEST -> passed.add(message.name) + MessageHelper.FAILED_TEST -> failed.add(FailedTest(message.testClass, + message.method, message.stackTrace)) + MessageHelper.SKIPPED_TEST -> skipped.add(message.name) + } + } + if (!KobaltLogger.isQuiet) { + print("\r " + d(passed.size, AsciiArt.GREEN) + + " | " + d(failed.size, AsciiArt.RED) + + " | " + d(skipped.size, AsciiArt.YELLOW)) + } + } + } catch(ex: IOException) { + kobaltLog(1, "Exception: ${ex.message}") + } + kobaltLog(1, "\nPassed: " + passed.size + ", Failed: " + failed.size + ", Skipped: " + skipped.size) + failed.forEach { + val top = it.stackTrace.substring(0, it.stackTrace.indexOf("\n")) + kobaltLog(1, " " + it.cls + "." + it.method + "\n " + top) + } + return TestResult(failed.isEmpty() && skipped.isEmpty()) + } + + fun launchRemoteServer(project: Project, context: KobaltContext, classpath: List, + testConfig: TestConfig, versions: Pair, port: Int) { + val testngVersion = versions.first + val remoteRunnerVersion = versions.second + val dep = with(context.dependencyManager) { + val jf = create("org.testng.testng-remote:testng-remote:1.3.0") + val tr = create("org.testng.testng-remote:$remoteRunnerVersion:1.3.0") + val testng = create("org.testng:testng:6.11") + transitiveClosure(kotlin.collections.listOf(jf, tr /*, testng */)) + } + + val cp = (classpath + dep).distinct().map { it.jarFile.get() } + .joinToString(File.pathSeparator) + val calculatedArgs = args(project, context, classpath, testConfig) + + val jvmArgs = arrayListOf("-classpath", cp) + if (testConfig.jvmArgs.any()) { + jvmArgs.addAll(testConfig.jvmArgs) + } + val remoteArgs = listOf( + "org.testng.remote.RemoteTestNG", + "-serport", port.toString(), + "-version", testngVersion, + "-dontexit", + RemoteArgs.PROTOCOL, + "json") + + val passedArgs = jvmArgs + remoteArgs + calculatedArgs + + Thread { + runCommand { + command = "java" + directory = File(project.directory) + args = passedArgs + } + }.start() + +// Thread { +// val args2 = arrayOf("-serport", port.toString(), "-dontexit", RemoteArgs.PROTOCOL, "json", +// "-version", "6.10", +// "src/test/resources/testng.xml") +// RemoteTestNG.main(args2) +// }.start() + } +} + +fun main(args: Array) { + fun d(n: Int, color: String) + = AsciiArt.wrap(String.format("%4d", n), color) + + if (!KobaltLogger.isQuiet) { + println("PASSED | FAILED | SKIPPED") + repeat(20) { i -> + print("\r " + d(i, AsciiArt.GREEN) + " | " + d(i * 2, AsciiArt.RED) + " | " + d(i, AsciiArt.YELLOW)) + Thread.sleep(500) + } + println("") + } } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/build/BuildFile.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/build/BuildFile.kt index 6e7a8976..a2eb91e9 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/build/BuildFile.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/build/BuildFile.kt @@ -3,16 +3,12 @@ package com.beust.kobalt.internal.build import java.io.File import java.nio.file.Files import java.nio.file.Path -import java.nio.file.attribute.BasicFileAttributes /** * Sometimes, build files are moved to temporary files, so we give them a specific name for clarity. * @param path is the path where that file was moved, @param realPath is where the actual file is. */ class BuildFile(val path: Path, val name: String, val realPath: Path = path) { - public fun exists() : Boolean = Files.exists(path) + fun exists() : Boolean = Files.exists(path) - public val lastModified : Long - get() = Files.readAttributes(realPath, BasicFileAttributes::class.java).lastModifiedTime().toMillis() - - public val directory : File get() = path.toFile().directory + val directory : File get() = path.toFile().parentFile } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/build/BuildSources.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/build/BuildSources.kt new file mode 100644 index 00000000..78425f18 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/build/BuildSources.kt @@ -0,0 +1,61 @@ +package com.beust.kobalt.internal.build + +import com.beust.kobalt.homeDir +import java.io.File +import java.nio.file.* +import java.nio.file.attribute.BasicFileAttributes + +/** + * The abstraction to represent a directory that contains source files. @param{root} is typically + * the root of the project and build files are searched under root/kobalt/src/ *kt. + */ +interface IBuildSources { + fun findSourceFiles() : List + val root: File + fun exists(): Boolean +} + +class SingleFileBuildSources(val file: File) : IBuildSources { + override fun exists() = file.exists() + override fun findSourceFiles() = listOf(file) + override val root: File = file.parentFile.parentFile.parentFile + override fun toString() : String = file.path +} + +class BuildSources(val file: File = File("")) : IBuildSources { + + override val root = file + + override fun findSourceFiles() : List { + return findBuildFiles(listOf(file)) + } + + override fun exists() = findSourceFiles().isNotEmpty() + + override fun toString() = "{BuildSources " + findSourceFiles().joinToString(", ") + "}" + + fun findBuildFiles(roots: List) : List { + val result = arrayListOf() + roots.forEach { file -> + Files.walkFileTree(Paths.get(file.path), object : SimpleFileVisitor() { + override fun preVisitDirectory(dir: Path?, attrs: BasicFileAttributes?): FileVisitResult { + if (dir != null) { + val path = dir.toFile() + if (path.name == "src" && path.parentFile.name == "kobalt") { + val sources = path.listFiles().filter { it.name.endsWith(".kt") } + result.addAll(sources) + } + } + + return FileVisitResult.CONTINUE + } + }) + } + return result + } +} + +fun main(args: Array) { + val sources = BuildSources(File(homeDir("kotlin/kobalt"))).findSourceFiles() + println("sources: " + sources) +} \ No newline at end of file diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/build/VersionCheckTimestampFile.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/build/VersionCheckTimestampFile.kt new file mode 100644 index 00000000..ea0ff924 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/build/VersionCheckTimestampFile.kt @@ -0,0 +1,22 @@ +package com.beust.kobalt.internal.build + +import com.beust.kobalt.misc.KFiles +import java.io.File +import java.time.Instant + +class VersionCheckTimestampFile { + companion object { + private val KOBALT_VERSION_CHECK_TIMESTAMP_FILE = "versionCheckTimestamp.txt" + private val CHECK_TIMESTAMP_FILE = File(KFiles.KOBALT_DOT_DIR, KOBALT_VERSION_CHECK_TIMESTAMP_FILE) + + fun updateTimestamp(timestamp: Instant) = KFiles.saveFile(CHECK_TIMESTAMP_FILE, timestamp.toString()) + + val timestamp : Instant + get() = if (CHECK_TIMESTAMP_FILE.exists()) { + Instant.parse(CHECK_TIMESTAMP_FILE.readText()) + } else { + updateTimestamp(Instant.MIN) + Instant.MIN + } + } +} \ No newline at end of file diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/eventbus/Events.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/eventbus/Events.kt new file mode 100644 index 00000000..a57be9a2 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/eventbus/Events.kt @@ -0,0 +1,5 @@ +package com.beust.kobalt.internal.eventbus + +import org.eclipse.aether.repository.ArtifactRepository + +class ArtifactDownloadedEvent(val artifactId: String, val repository: ArtifactRepository) diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/remote/GetDependenciesCommand.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/remote/GetDependenciesCommand.kt deleted file mode 100644 index 88b22fd1..00000000 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/remote/GetDependenciesCommand.kt +++ /dev/null @@ -1,13 +0,0 @@ -package com.beust.kobalt.internal.remote - -import com.beust.kobalt.Constants -import java.io.PrintWriter -import java.net.Socket - -fun main(argv: Array) { - val socket = Socket("localhost", 1234) - (PrintWriter(socket.outputStream, true)).use { out -> - out.println("""{ "name" : "getDependencies", "buildFile": - "/Users/beust/kotlin/kobalt/kobalt/src/${Constants.BUILD_FILE_NAME}"}""") - } -} \ No newline at end of file diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/remote/KobaltServer.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/remote/KobaltServer.kt index 9704cd0b..9c2935c5 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/remote/KobaltServer.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/remote/KobaltServer.kt @@ -1,5 +1,6 @@ package com.beust.kobalt.internal.remote +import com.beust.kobalt.api.Project import com.google.gson.JsonObject /** @@ -14,15 +15,16 @@ interface ICommand { /** * Run this command based on the information received from the client. When done, use * the sender object to send back a response. + * @param initCallback The string is a path to the build file */ - fun run(sender: ICommandSender, received: JsonObject) + fun run(sender: ICommandSender, received: JsonObject, initCallback: (String) -> List) - fun toCommandData(data: String) = CommandData(name, data) + fun toCommandData(data: String, error: String? = null) = CommandData(name, data, error) } /** * Passed to a command in its `run` method so it can send information back to the caller. - * @param The string content that will be sent in the "data" field. + * @param commandData The string content that will be sent in the "data" field. */ interface ICommandSender { fun sendData(commandData: CommandData) diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/remote/PingCommand.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/remote/PingCommand.kt index ad9b2f21..555ded39 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/remote/PingCommand.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/remote/PingCommand.kt @@ -1,6 +1,6 @@ package com.beust.kobalt.internal.remote -import com.beust.kobalt.misc.log +import com.beust.kobalt.api.Project import com.google.gson.Gson import com.google.gson.JsonObject @@ -15,7 +15,7 @@ import com.google.gson.JsonObject class PingCommand() : ICommand { override val name = "ping" - override fun run(sender: ICommandSender, received: JsonObject) { + override fun run(sender: ICommandSender, received: JsonObject, initCallback: (String) -> List) { sender.sendData(toCommandData(Gson().toJson(PingData(received.toString())))) } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/kotlin/ParentLastClassLoader.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/kotlin/ParentLastClassLoader.kt index 10269d52..6d5fa9d2 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/kotlin/ParentLastClassLoader.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/kotlin/ParentLastClassLoader.kt @@ -9,7 +9,7 @@ import java.net.URLClassLoader * Will probably be made obsolete by making the wrapper a standalone module instead of * being inside Kobalt itself. */ -public class ParentLastClassLoader(val classpath: List) +class ParentLastClassLoader(val classpath: List) : ClassLoader(Thread.currentThread().contextClassLoader) { private val childClassLoader: ChildURLClassLoader @@ -22,7 +22,7 @@ public class ParentLastClassLoader(val classpath: List) * This class makes it possible to call findClass on a classloader */ private class FindClassClassLoader(parent: ClassLoader) : ClassLoader(parent) { - override public fun findClass(name: String) = super.findClass(name) + override fun findClass(name: String) = super.findClass(name) } /** @@ -43,7 +43,7 @@ public class ParentLastClassLoader(val classpath: List) } } - override public @Synchronized fun loadClass(name: String, resolve: Boolean) : Class<*> { + override @Synchronized fun loadClass(name: String, resolve: Boolean) : Class<*> { try { // first we try to find a class inside the child classloader return childClassLoader.findClass(name) diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/ArtifactFetcher.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/ArtifactFetcher.kt deleted file mode 100644 index e067b67d..00000000 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/ArtifactFetcher.kt +++ /dev/null @@ -1,83 +0,0 @@ -package com.beust.kobalt.maven - -import com.beust.kobalt.HostConfig -import com.beust.kobalt.misc.KFiles -import com.beust.kobalt.misc.log -import com.beust.kobalt.misc.warn -import com.google.common.cache.CacheBuilder -import com.google.common.cache.CacheLoader -import com.google.common.cache.LoadingCache -import com.google.inject.assistedinject.Assisted -import java.io.File -import java.nio.file.Files -import java.nio.file.Paths -import java.nio.file.StandardCopyOption -import java.util.concurrent.Callable -import java.util.concurrent.ExecutorService -import java.util.concurrent.Future -import javax.inject.Inject -import javax.inject.Singleton - -@Singleton -class DownloadManager @Inject constructor(val factory: ArtifactFetcher.IFactory) { - class Key(val hostInfo: HostConfig, val fileName: String, val executor: ExecutorService) { - override fun equals(other: Any?): Boolean { - return (other as Key).hostInfo.url == hostInfo.url - } - - override fun hashCode(): Int { - return hostInfo.url.hashCode() - } - } - - private val CACHE : LoadingCache> = CacheBuilder.newBuilder() - .build(object : CacheLoader>() { - override fun load(key: Key): Future { - return key.executor.submit(factory.create(key.hostInfo, key.fileName)) - } - }) - - fun download(hostInfo: HostConfig, fileName: String, executor: ExecutorService) - : Future = CACHE.get(Key(hostInfo, fileName, executor)) -} - -/** - * Fetches an artifact (a file in a Maven repo, .jar, -javadoc.jar, ...) to the given local file. - */ -class ArtifactFetcher @Inject constructor(@Assisted("hostInfo") val hostInfo: HostConfig, - @Assisted("fileName") val fileName: String, - val files: KFiles) : Callable { - interface IFactory { - fun create(@Assisted("hostInfo") hostInfo: HostConfig, @Assisted("fileName") fileName: String) : ArtifactFetcher - } - - override fun call() : File { - val k = Kurl(hostInfo.copy(url = hostInfo.url + ".md5")) - val remoteMd5 = - if (k.exists) k.string.trim(' ', '\t', '\n').substring(0, 32) - else null - - val tmpFile = Paths.get(fileName + ".tmp") - val file = Paths.get(fileName) - val url = hostInfo.url - if (! Files.exists(file)) { - with(tmpFile.toFile()) { - parentFile.mkdirs() - Kurl(hostInfo).toFile(this) - } - log(2, "Done downloading, renaming $tmpFile to $file") - Files.move(tmpFile, file, StandardCopyOption.REPLACE_EXISTING) - log(1, " Downloaded $url") - log(2, " to $file") - } - - val localMd5 = Md5.toMd5(file.toFile()) - if (remoteMd5 != null && remoteMd5 != localMd5) { - warn("MD5 not matching for $url") - } else { - log(2, "No md5 found for $url, skipping md5 check") - } - - return file.toFile() - } -} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/CompletedFuture.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/CompletedFuture.kt index f64c32b5..1e24cd8e 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/CompletedFuture.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/CompletedFuture.kt @@ -3,7 +3,7 @@ package com.beust.kobalt.maven import java.util.concurrent.Future import java.util.concurrent.TimeUnit -public class CompletedFuture(val value: T) : Future { +class CompletedFuture(val value: T) : Future { override fun cancel(mayInterruptIfRunning: Boolean) = true override fun get(): T = value override fun get(timeout: Long, unit: TimeUnit): T = value diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/DepFactory.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/DepFactory.kt deleted file mode 100644 index 10f2e4a7..00000000 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/DepFactory.kt +++ /dev/null @@ -1,60 +0,0 @@ -package com.beust.kobalt.maven - -import com.beust.kobalt.KobaltException -import com.beust.kobalt.api.IClasspathDependency -import com.beust.kobalt.api.Kobalt -import com.beust.kobalt.maven.dependency.FileDependency -import com.beust.kobalt.maven.dependency.MavenDependency -import com.beust.kobalt.misc.DependencyExecutor -import com.beust.kobalt.misc.KobaltExecutors -import com.google.inject.Key -import java.util.concurrent.ExecutorService -import javax.inject.Inject - -public class DepFactory @Inject constructor(val localRepo: LocalRepo, - val remoteRepo: RepoFinder, - val executors: KobaltExecutors, - val downloadManager: DownloadManager, - val pomFactory: Pom.IFactory) { - - companion object { - val defExecutor : ExecutorService by lazy { - Kobalt.INJECTOR.getInstance(Key.get(ExecutorService::class.java, DependencyExecutor::class.java)) - } - } - - /** - * Parse the id and return the correct IClasspathDependency - */ - public fun create(id: String, executor: ExecutorService = defExecutor, localFirst : Boolean = true) - : IClasspathDependency { - if (id.startsWith(FileDependency.PREFIX_FILE)) { - return FileDependency(id.substring(FileDependency.PREFIX_FILE.length)) - } else { - val mavenId = MavenId.create(id) - var tentativeVersion = mavenId.version - var packaging = mavenId.packaging - var repoResult: RepoFinder.RepoResult? - - val version = - if (tentativeVersion != null && ! MavenId.isRangedVersion(tentativeVersion)) tentativeVersion - else { - var localVersion: String? = tentativeVersion - if (localFirst) localVersion = localRepo.findLocalVersion(mavenId.groupId, mavenId.artifactId, mavenId.packaging) - if (localFirst && localVersion != null) { - localVersion - } else { - repoResult = remoteRepo.findCorrectRepo(id) - if (!repoResult.found) { - throw KobaltException("Couldn't resolve $id") - } else { - repoResult.version?.version - } - } - } - - return MavenDependency(MavenId.create(mavenId.groupId, mavenId.artifactId, packaging, version), - executor, localRepo, remoteRepo, pomFactory, downloadManager) - } - } -} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/DependencyManager.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/DependencyManager.kt index 1e1b480a..ff2d9fd9 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/DependencyManager.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/DependencyManager.kt @@ -1,40 +1,175 @@ package com.beust.kobalt.maven +import com.beust.kobalt.KobaltException import com.beust.kobalt.api.* +import com.beust.kobalt.maven.aether.Filters +import com.beust.kobalt.maven.aether.KobaltMavenResolver +import com.beust.kobalt.maven.aether.Scope import com.beust.kobalt.maven.dependency.FileDependency import com.beust.kobalt.misc.KFiles import com.beust.kobalt.misc.KobaltExecutors import com.google.common.collect.ArrayListMultimap +import org.eclipse.aether.graph.DependencyFilter +import org.eclipse.aether.util.filter.OrDependencyFilter +import java.io.File import java.util.* import javax.inject.Inject import javax.inject.Singleton @Singleton -public class DependencyManager @Inject constructor(val executors: KobaltExecutors, - val depFactory: DepFactory){ +class DependencyManager @Inject constructor(val executors: KobaltExecutors, + val resolver: KobaltMavenResolver) : IDependencyManager { + + companion object { + fun create(id: String, optional: Boolean = false, projectDirectory: String? = null) = + Kobalt.INJECTOR.getInstance(DependencyManager::class.java).create(id, optional, projectDirectory) + } /** - * @return the classpath for this project, including the IClasspathContributors. - * allDependencies is typically either compileDependencies or testDependencies + * Parse the id and return the correct IClasspathDependency */ - fun calculateDependencies(project: Project?, context: KobaltContext, - dependentProjects: List = emptyList(), - vararg allDependencies: List): List { - var result = arrayListOf() + override fun create(id: String, optional: Boolean, projectDirectory: String?) : IClasspathDependency { + if (id.startsWith(FileDependency.PREFIX_FILE)) { + val path = if (projectDirectory != null) { + val idPath = id.substring(FileDependency.PREFIX_FILE.length) + if (! File(idPath).isAbsolute) { + // If the project directory is relative, we might not be in the correct directory to locate + // that file, so we'll use the absolute directory deduced from the build file path. Pick + // the first one that produces an actual file + val result = listOf(File(projectDirectory), Kobalt.context?.internalContext?.absoluteDir).map { + File(it, idPath) + }.firstOrNull { + it.exists() + } + result ?: throw KobaltException("Couldn't find $id") + + } else { + File(idPath) + } + } else { + File(id.substring(FileDependency.PREFIX_FILE.length)) + } + return createFile(path.path) + } else { + // Convert to a Kobalt id first (so that if it doesn't have a version, it gets translated to + // an Aether ranged id "[0,)") + return createMaven(MavenId.create(id).toId, optional) + } + } + + /** + * Create an IClasspathDependency from a Maven id. + */ + override fun createMaven(id: String, optional: Boolean) : IClasspathDependency = resolver.create(id, optional) + + /** + * Create an IClasspathDependency from a path. + */ + override fun createFile(path: String) : IClasspathDependency = FileDependency(path) + + /** + * @return the source dependencies for this project, including the contributors. + */ + override fun dependencies(project: Project, context: KobaltContext, scopes: List) + = privateDependencies(project, context, listOf(Scope.COMPILE)) + + /** + * @return the test dependencies for this project, including the contributors. + */ + override fun testDependencies(project: Project, context: KobaltContext) + = privateDependencies(project, context, listOf(Scope.COMPILE, Scope.TEST)) + + /** + * Transitive dependencies for the compilation of this project. + */ +// fun calculateTransitiveDependencies(project: Project, context: KobaltContext) +// = calculateDependencies(project, context, project.dependentProjects, +// project.compileDependencies + project.compileRuntimeDependencies) + + /** + * @return the classpath for this project, including the IClasspathContributors. Excluded dependencies + * are removed from the result. + * + * @param{allDependencies} is typically either compileDependencies or testDependencies. If no dependencies + * are passed, they are calculated from the scope filters. + */ + override fun calculateDependencies(project: Project?, context: KobaltContext, + dependencyFilter: DependencyFilter, + scopes: List, + vararg passedDependencies: List): List { + val result = arrayListOf() + + /** + * Extract the correct dependencies from the project based on the scope filters. + */ + fun filtersToDependencies(project: Project, scopes: Collection): List { + val result = arrayListOf().apply { + if (scopes.contains(Scope.COMPILE)) { + addAll(project.compileDependencies) + addAll(project.compileProvidedDependencies) + } + if (scopes.contains(Scope.COMPILEONLY)) { + addAll(project.compileOnlyDependencies) + } + if (scopes.contains(Scope.RUNTIME)) { + addAll(project.compileRuntimeDependencies) + } + if (scopes.contains(Scope.TEST)) { + addAll(project.testDependencies) + } + } + return result.filter { ! it.optional } + } + + val allDependencies : Array> = + if (project == null || passedDependencies.any()) passedDependencies + else arrayOf(filtersToDependencies(project, scopes)) + + // Make sure that classes/ and test-classes/ are always at the top of this classpath, + // so that older versions of that project on the classpath don't shadow them + if (project != null && scopes.contains(Scope.TEST)) { + result.add(FileDependency(KFiles.makeOutputDir(project).path)) + result.add(FileDependency(KFiles.makeOutputTestDir(project).path)) + } + allDependencies.forEach { dependencies -> - result.addAll(transitiveClosure(dependencies)) + result.addAll(transitiveClosure(dependencies, dependencyFilter, project?.name)) } result.addAll(runClasspathContributors(project, context)) - result.addAll(dependentProjectDependencies(dependentProjects, project, context)) + result.addAll(dependentProjectDependencies(project, context, dependencyFilter, scopes)) - return result + /** + * Naïve implementation: just exclude all dependencies that start with one of the excluded dependencies. + * Should probably make exclusion more generic (full on string) or allow exclusion to be specified + * formally by groupId or artifactId. + */ + fun isDependencyExcluded(dep: IClasspathDependency, excluded: List): Boolean { + excluded.any { excluded -> dep.id == excluded.id }.let { result -> + if (result) { + context.logger.log(project?.name ?: "", 2, " Excluding dependency $dep") + } + return result + } + } + + // Dependencies get reordered by transitiveClosure() but since we just added a bunch of new ones, + // we need to reorder them again in case we're adding dependencies that are already present + // but with a different version + val shortResult = + if (project != null) { + result.filter { ! isDependencyExcluded(it, project.excludedDependencies) } + } else { + result + }.toHashSet() + val reordered = reorderDependencies(shortResult) + return reordered } private fun runClasspathContributors(project: Project?, context: KobaltContext) : Collection { val result = hashSetOf() context.pluginInfo.classpathContributors.forEach { it: IClasspathContributor -> - result.addAll(it.entriesFor(project)) + result.addAll(it.classpathEntriesFor(project, context)) } return result } @@ -43,37 +178,26 @@ public class DependencyManager @Inject constructor(val executors: KobaltExecutor * Return the transitive closure of the dependencies *without* running the classpath contributors. * TODO: This should be private, everyone should be calling calculateDependencies(). */ - fun transitiveClosure(dependencies : List): List { - var executor = executors.newExecutor("JvmCompiler}", 10) - - var result = hashSetOf() - - dependencies.forEach { projectDependency -> - result.add(projectDependency) - projectDependency.id.let { - result.add(depFactory.create(it, executor)) - val downloaded = transitiveClosure(projectDependency.directDependencies()) - - result.addAll(downloaded) + fun transitiveClosure(dependencies : List, + filter: DependencyFilter = Filters.EXCLUDE_OPTIONAL_FILTER, + requiredBy: String? = null): List { + val result = arrayListOf() + dependencies.forEach { dependency -> + result.add(dependency) + if (dependency.isMaven) { + val resolved = resolver.resolveToIds(dependency.id, null, filter).map { create(it) } + result.addAll(resolved) } } - - val result2 = reorderDependencies(result).filter { - // Only keep existent files (nonexistent files are probably optional dependencies or parent poms - // that point to other poms but don't have a jar file themselves) - it.jarFile.get().exists() - } - - executor.shutdown() - - return result2 + val reordered = reorderDependencies(result) + return reordered } /** * Reorder dependencies so that if an artifact appears several times, only the one with the higest version * is included. */ - public fun reorderDependencies(dependencies: Collection): List { + private fun reorderDependencies(dependencies: Collection): List { val result = arrayListOf() val map : ArrayListMultimap = ArrayListMultimap.create() // The multilist maps each artifact to a list of all the versions found @@ -84,7 +208,7 @@ public class DependencyManager @Inject constructor(val executors: KobaltExecutor for (k in map.keySet()) { val l = map.get(k) Collections.sort(l, Collections.reverseOrder()) - result.add(l.get(0)) + result.add(l[0]) } return result } @@ -93,59 +217,87 @@ public class DependencyManager @Inject constructor(val executors: KobaltExecutor * If this project depends on other projects, we need to include their jar file and also * their own dependencies */ - private fun dependentProjectDependencies(projectDescriptions: List, - project: Project?, context: KobaltContext) : - List { - val result = arrayListOf() - projectDescriptions.filter { - it.project.name == project?.name - }.forEach { pd -> - pd.dependsOn.forEach { p -> - result.add(FileDependency(KFiles.joinDir(p.directory, p.classesDir(context)))) - val otherDependencies = calculateDependencies(p, context, projectDescriptions, - p.compileDependencies) + private fun dependentProjectDependencies(project: Project?, context: KobaltContext, + dependencyFilter: DependencyFilter, scopes: List): List { + if (project == null) { + return emptyList() + } else { + val result = arrayListOf() + + fun maybeAddClassDir(classDir: String) { + // A project is allowed not to have any kobaltBuild/classes or test-classes directory if it doesn't have + // any sources + if (File(classDir).exists()) { + result.add(FileDependency(classDir)) + } + } + + val isTest = scopes.contains(Scope.TEST) + + project.dependsOn.forEach { p -> + maybeAddClassDir(KFiles.joinDir(p.directory, p.classesDir(context))) + if (isTest) maybeAddClassDir(KFiles.makeOutputTestDir(project).path) + val otherDependencies = calculateDependencies(p, context, dependencyFilter, scopes) result.addAll(otherDependencies) } + + if (isTest) { + project.testsDependOn.forEach { p -> + val otherDependencies = calculateDependencies(p, context, dependencyFilter, scopes) + result.addAll(otherDependencies) + } + } + return result + } + } + + private fun privateDependencies(project: Project, context: KobaltContext, passedScopes: List) + : List { + val isTest = passedScopes.contains(Scope.TEST) + val transitive = hashSetOf() + with(project) { + val scopeFilters : ArrayList = arrayListOf(Scope.COMPILE) + context.variant.let { variant -> + val deps: ArrayList> = + if (passedScopes.contains(Scope.COMPILE)) { + arrayListOf(compileDependencies, compileProvidedDependencies, + variant.buildType.compileDependencies, + variant.buildType.compileProvidedDependencies, + variant.productFlavor.compileDependencies, + variant.productFlavor.compileProvidedDependencies) + } else if (passedScopes.contains(Scope.RUNTIME)) { + arrayListOf(compileRuntimeDependencies) + } else { + arrayListOf(arrayListOf()) + } + val runtimeDeps = arrayListOf(compileRuntimeDependencies) + if (isTest) { + deps.add(testDependencies) + deps.add(testProvidedDependencies) + scopeFilters.add(Scope.TEST) + } + val filter = + if (isTest) OrDependencyFilter(Filters.COMPILE_FILTER, Filters.TEST_FILTER) + else Filters.COMPILE_FILTER + runtimeDeps.filter { it.any() }.forEach { + transitive.addAll(calculateDependencies(project, context, filter, + passedScopes, // scopes = Scope.toScopes(isTest), + passedDependencies = it)) + } + } + } + + // Make sure that classes/ and test-classes/ are always at the top of this classpath, + // so that older versions of that project on the classpath don't shadow them + val result = arrayListOf().apply { + if (isTest) { + add(FileDependency(KFiles.makeOutputDir(project).path)) + add(FileDependency(KFiles.makeOutputTestDir(project).path)) + } + addAll(reorderDependencies(transitive)) } return result } - /** - * @return the compile dependencies for this project, including the contributors. - */ - fun dependencies(project: Project, context: KobaltContext, - projects: List) : List { - val result = arrayListOf() - result.add(FileDependency(KFiles.makeOutputDir(project).absolutePath)) - result.add(FileDependency(KFiles.makeOutputTestDir(project).absolutePath)) - with(project) { - arrayListOf(compileDependencies, compileProvidedDependencies).forEach { - result.addAll(calculateDependencies(project, context, projects, it)) - } - } - val result2 = reorderDependencies(result) - return result2 - } - - /** - * @return the test dependencies for this project, including the contributors. - */ - fun testDependencies(project: Project, context: KobaltContext, - projects: List) : List { - val result = arrayListOf() - result.add(FileDependency(KFiles.makeOutputDir(project).absolutePath)) - result.add(FileDependency(KFiles.makeOutputTestDir(project).absolutePath)) - with(project) { - arrayListOf(compileDependencies, compileProvidedDependencies, testDependencies, - testProvidedDependencies).forEach { - result.addAll(calculateDependencies(project, context, projects, it)) - } - } - val result2 = reorderDependencies(result) - return result2 - } - - - } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/Gpg.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/Gpg.kt index 5fb85508..60a4335c 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/Gpg.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/Gpg.kt @@ -1,16 +1,18 @@ package com.beust.kobalt.maven import com.beust.kobalt.OperatingSystem +import com.beust.kobalt.misc.LocalProperties import com.beust.kobalt.misc.error -import com.beust.kobalt.misc.log +import com.beust.kobalt.misc.kobaltLog import com.beust.kobalt.misc.warn +import com.google.inject.Inject import com.google.inject.Singleton import java.io.BufferedReader import java.io.File import java.io.InputStreamReader @Singleton -public class Gpg { +class Gpg @Inject constructor(val localProperties: LocalProperties) { val COMMANDS = listOf("gpg", "gpg2") fun findGpgCommand() : String? { @@ -36,18 +38,33 @@ public class Gpg { val result = arrayListOf() val gpg = findGpgCommand() if (gpg != null) { - val directory = files.get(0).parentFile.absoluteFile + val directory = files[0].parentFile.absoluteFile files.forEach { file -> val ascFile = File(file.absolutePath + ".asc") ascFile.delete() val allArgs = arrayListOf() allArgs.add(gpg) + + fun maybeAdd(prop: String, f: (String) -> Unit) = localProperties.getNoThrows(prop)?.let { + f(it) + } + + maybeAdd("gpg.password") { + allArgs.addAll(listOf("--passphrase", it, "--batch", "--yes")) + } + maybeAdd("gpg.keyId") { + allArgs.addAll(listOf("--local-user", it)) + } + maybeAdd("gpg.secretKeyRingFile") { + allArgs.addAll(listOf("--secret-keyring", "\"$it\"")) + } + allArgs.add("-ab") allArgs.add(file.absolutePath) val pb = ProcessBuilder(allArgs) pb.directory(directory) - log(2, "Signing file: " + allArgs.joinToString(" ")) + kobaltLog(2, "Signing file: " + allArgs.joinToString(" ")) val process = pb.start() val br = BufferedReader(InputStreamReader(process.errorStream)) diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/Http.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/Http.kt index a591fead..df286a47 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/Http.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/Http.kt @@ -1,17 +1,28 @@ package com.beust.kobalt.maven import com.beust.kobalt.KobaltException +import com.beust.kobalt.internal.KobaltSettings import com.beust.kobalt.misc.CountingFileRequestBody +import com.beust.kobalt.misc.kobaltLog import com.beust.kobalt.misc.log -import com.squareup.okhttp.* -import retrofit.mime.TypedFile +import com.google.inject.Inject +import okhttp3.* +import java.io.File import java.io.IOException import javax.inject.Singleton @Singleton -public class Http { - public fun get(user: String?, password: String?, url: String) : Response { - val client = OkHttpClient(); +class Http @Inject constructor(val settings:KobaltSettings) { + companion object { + // HTTP statuses + val CREATED = 201 + } + class TypedFile(val mimeType: String, val file: File) { + override fun toString() = file.name + } + + fun get(user: String?, password: String?, url: String) : Response { + val client = OkHttpClient.Builder().proxy(settings.proxyConfigs?.firstOrNull()?.toProxy()).build() val request = Request.Builder().url(url) if (user != null) { request.header("Authorization", Credentials.basic(user, password)) @@ -24,14 +35,14 @@ public class Http { } } - public fun get(url: String) : Response { + fun get(url: String) : Response { return get(null, null, url) } fun percentProgressCallback(totalSize: Long) : (Long) -> Unit { return { num: Long -> val progress = num * 100 / totalSize - log(1, "\rUploaded: $progress%", newLine = false) + kobaltLog(1, "\rUploaded: $progress%", newLine = false) } } @@ -39,7 +50,7 @@ public class Http { error("Couldn't upload file: " + r.message()) } - public fun uploadFile(user: String? = null, password: String? = null, url: String, file: TypedFile, + fun uploadFile(user: String? = null, password: String? = null, url: String, file: TypedFile, post: Boolean, progressCallback: (Long) -> Unit = {}, headers: Headers = Headers.of(), @@ -47,7 +58,7 @@ public class Http { error: (Response) -> Unit = DEFAULT_ERROR_RESPONSE) { val fullHeaders = Headers.Builder() - fullHeaders.set("Content-Type", file.mimeType()) + fullHeaders.set("Content-Type", file.mimeType) headers.names().forEach { fullHeaders.set(it, headers.get(it)) } user?.let { @@ -59,13 +70,13 @@ public class Http { .url(url) val request = (if (post) - requestBuilder.post(CountingFileRequestBody(file.file(), file.mimeType(), progressCallback)) + requestBuilder.post(CountingFileRequestBody(file.file, file.mimeType, progressCallback)) else - requestBuilder.put(CountingFileRequestBody(file.file(), file.mimeType(), progressCallback))) + requestBuilder.put(CountingFileRequestBody(file.file, file.mimeType, progressCallback))) .build() - log(2, "Uploading $file to $url") - val response = OkHttpClient().newCall(request).execute() + kobaltLog(2, "Uploading $file to $url") + val response = OkHttpClient.Builder().proxy(settings.proxyConfigs?.firstOrNull()?.toProxy()).build().newCall(request).execute() if (! response.isSuccessful) { error(response) } else { diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/Kurl.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/Kurl.kt index 683536a7..909c18c5 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/Kurl.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/Kurl.kt @@ -1,9 +1,8 @@ package com.beust.kobalt.maven import com.beust.kobalt.HostConfig -import com.beust.kobalt.KobaltException +import com.beust.kobalt.maven.aether.KobaltMavenResolver import com.beust.kobalt.maven.dependency.FileDependency -import com.beust.kobalt.misc.LocalProperties import java.io.* import java.net.HttpURLConnection import java.net.URL @@ -21,29 +20,11 @@ class Kurl(val hostInfo: HostConfig) { } init { - // See if the URL needs to be authenticated. Look in local.properties for keys - // of the format authUrl..user=xxx and authUrl..password=xxx - val properties = LocalProperties().localProperties - val host = java.net.URL(hostInfo.url).host - properties.entries.forEach { - val key = it.key.toString() - if (key == "$KEY.$host.$VALUE_USER") { - hostInfo.username = properties.getProperty(key) - } else if (key == "$KEY.$host.$VALUE_PASSWORD") { - hostInfo.password = properties.getProperty(key) - } - } - fun error(s1: String, s2: String) { - throw KobaltException("Found \"$s1\" but not \"$s2\" in local.properties for $KEY.$host", - docUrl = "http://beust.com/kobalt/documentation/index.html#maven-repos-authenticated") - } - if (! hostInfo.username.isNullOrBlank() && hostInfo.password.isNullOrBlank()) { - error("username", "password") - } else if(hostInfo.username.isNullOrBlank() && ! hostInfo.password.isNullOrBlank()) { - error("password", "username") - } + KobaltMavenResolver.initAuthentication(hostInfo) } + override fun toString() = hostInfo.toString() + val connection : URLConnection get() { val result = URL(hostInfo.url).openConnection() @@ -66,7 +47,7 @@ class Kurl(val hostInfo: HostConfig) { if (connection is HttpURLConnection) { val responseCode = (connection as HttpURLConnection).responseCode checkResponseCode(responseCode) - responseCode == 200 + responseCode == 200 || responseCode == 301 } else if (url.startsWith(FileDependency.PREFIX_FILE)) { val fileName = url.substring(FileDependency.PREFIX_FILE.length) File(fileName).exists() diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/LocalDep.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/LocalDep.kt index 0816b953..53cb1c89 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/LocalDep.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/LocalDep.kt @@ -1,18 +1,9 @@ package com.beust.kobalt.maven -import com.beust.kobalt.maven.CompletedFuture -import com.beust.kobalt.misc.Strings -import java.io.File -import java.util.concurrent.Future -import kotlin.properties.Delegates - -open public class LocalDep(override val mavenId: MavenId, open val localRepo: LocalRepo) +open class LocalDep(override val mavenId: MavenId, open val localRepo: LocalRepo) : SimpleDep(mavenId) { fun toAbsoluteJarFilePath(v: String) = localRepo.toFullPath(toJarFile(v)) - fun toAbsolutePomFile(v: String): String { - return localRepo.toFullPath(Strings.Companion.join("/", arrayListOf(toPomFile(v)))) - } - + fun toAbsolutePomFile(v: String) = localRepo.toFullPath(listOf(toPomFile(v)).joinToString("/")) } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/LocalRepo.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/LocalRepo.kt index ffeaad86..35f8c50a 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/LocalRepo.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/LocalRepo.kt @@ -1,58 +1,16 @@ package com.beust.kobalt.maven -import com.beust.kobalt.misc.KFiles -import com.beust.kobalt.misc.Versions +import com.beust.kobalt.internal.KobaltSettings +import com.google.inject.Inject import java.io.File -import java.util.Collections import javax.inject.Singleton @Singleton -open public class LocalRepo(open val localRepo: String = KFiles.localRepo) { - init { - val l = File(localRepo) - if (! l.exists()) { - l.mkdirs() - } - } +open class LocalRepo @Inject constructor(val kobaltSettings: KobaltSettings) { + val localRepo: File + get() = kobaltSettings.localCache - fun existsPom(d: LocalDep, v: String) : Boolean { - return File(d.toAbsolutePomFile(v)).exists() - } - - fun existsJar(d: LocalDep, v: String) : Boolean { - return File(d.toAbsoluteJarFilePath(v)).exists() - } - - /** - * If the dependency is local, return the correct version for it - */ - fun findLocalVersion(groupId: String, artifactId: String, packaging: String? = null) : String? { - // No version: look at all the directories under group/artifactId, pick the latest and see - // if it contains a maven and jar file - val dir = toFullPath(KFiles.joinDir(groupId.replace(".", File.separator), artifactId)) - val files = File(dir).listFiles() - - if (files != null) { - val directories = files.filter { it.isDirectory } - if (directories.size > 0) { - Collections.sort(directories, { f1, f2 -> - val v1 = Versions.toLongVersion(f1.name) - val v2 = Versions.toLongVersion(f2.name) - v2.compareTo(v1) // we want the most recent at position 0 - }) - val result = directories[0].name - val newDep = LocalDep(MavenId.create(groupId, artifactId, packaging, result), this) - if (existsPom(newDep, result) && existsJar(newDep, result)) { - return result - } - } - } - return null - } - - fun toFullPath(path: String) : String { - return localRepo + File.separatorChar + path - } + fun toFullPath(path: String): String = File(localRepo, path).absolutePath } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/MavenId.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/MavenId.kt index efbe37a1..13fff154 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/MavenId.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/MavenId.kt @@ -1,6 +1,7 @@ package com.beust.kobalt.maven import com.beust.kobalt.api.Kobalt +import org.eclipse.aether.artifact.DefaultArtifact /** * Encapsulate a Maven id captured in one string, as used by Gradle or Ivy, e.g. "org.testng:testng:6.9.9". @@ -13,15 +14,15 @@ import com.beust.kobalt.api.Kobalt * usually means "latest version") but it doesn't handle version ranges yet. */ class MavenId private constructor(val groupId: String, val artifactId: String, val packaging: String?, - val version: String?) { + val classifier: String?, val version: String?) { companion object { - fun isMavenId(id: String) = with(id.split(":")) { - size == 3 || size == 4 - } - - private fun isVersion(s: String): Boolean { - return Character.isDigit(s[0]) || isRangedVersion(s) + fun isMavenId(id: String) = if (id.startsWith("file://")) { + false + } else { + with(id.split(':')) { + size >= 3 && size <= 5 + } } fun isRangedVersion(s: String): Boolean { @@ -31,34 +32,18 @@ class MavenId private constructor(val groupId: String, val artifactId: String, v /** * Similar to create(MavenId) but don't run IMavenIdInterceptors. */ - fun createNoInterceptors(id: String) : MavenId { - var groupId: String? = null - var artifactId: String? = null - var version: String? = null - var packaging: String? = null - if (!isMavenId(id)) { - throw IllegalArgumentException("Illegal id: $id") + fun createNoInterceptors(id: String) : MavenId = DefaultArtifact(id).run { + MavenId(groupId, artifactId, extension, classifier, version) } - val c = id.split(":") - groupId = c[0] - artifactId = c[1] - if (!c[2].isEmpty()) { - val split = c[2].split('@') - if (isVersion(split[0])) { - version = split[0] - } - packaging = if (split.size == 2) split[1] else null - } - - return MavenId(groupId, artifactId, packaging, version) - } + fun toMavenId(id: String) = if (id.endsWith(":")) id + "(0,]" else id /** * The main entry point to create Maven Id's. Id's created by this function * will run through IMavenIdInterceptors. */ - fun create(id: String) : MavenId { + fun create(originalId: String) : MavenId { + val id = toMavenId(originalId) var originalMavenId = createNoInterceptors(id) var interceptedMavenId = originalMavenId val interceptors = Kobalt.context?.pluginInfo?.mavenIdInterceptors @@ -70,17 +55,20 @@ class MavenId private constructor(val groupId: String, val artifactId: String, v return interceptedMavenId } - fun create(groupId: String, artifactId: String, packaging: String?, version: String?) = - create(toId(groupId, artifactId, packaging, version)) + fun create(groupId: String, artifactId: String, packaging: String?, classifier: String?, version: String?) = + create(toId(groupId, artifactId, packaging, classifier, version)) - fun toId(groupId: String, artifactId: String, packaging: String? = null, version: String?) = - "$groupId:$artifactId:$version" + - (if (packaging != null) "@$packaging" else "") + fun toId(groupId: String, artifactId: String, packaging: String? = null, classifier: String? = null, + version: String?) = + "$groupId:$artifactId" + + (if (packaging != null && packaging != "") ":$packaging" else "") + + (if (classifier != null && classifier != "") ":$classifier" else "") + + ":$version" } val hasVersion = version != null - val toId = MavenId.toId(groupId, artifactId, packaging, version) + val toId = MavenId.toId(groupId, artifactId, packaging, classifier, version) } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/Md5.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/Md5.kt index c432bbed..efa34944 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/Md5.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/Md5.kt @@ -1,11 +1,69 @@ package com.beust.kobalt.maven +import com.beust.kobalt.misc.KFiles +import com.beust.kobalt.misc.kobaltLog import java.io.File import java.security.MessageDigest import javax.xml.bind.DatatypeConverter -public class Md5 { +class Md5 { companion object { +// private fun md5(file: File) : String { +// if (file.isDirectory) { +// println("PROBLEM") +// } +// val md5 = MessageDigest.getInstance("MD5") +// val bytes = file.readBytes() +// md5.update(bytes, 0, bytes.size) +// return DatatypeConverter.printHexBinary(md5.digest()).toLowerCase() +// } + + /** + * Calculate a checksum for all the files/directories. The conversion from File to + * bytes can be customized by the @param{toBytes} parameter. The default implementation calculates + * a checksum of the last modified timestamp. + */ + fun toMd5Directories(filesOrDirectories: List, + toBytes: (File) -> ByteArray = { "${it.path} ${it.lastModified()} ${it.length()}".toByteArray() } ) + : String? { + if (filesOrDirectories.any(File::exists)) { + MessageDigest.getInstance("MD5").let { md5 -> + var fileCount = 0 + filesOrDirectories.filter(File::exists).forEach { file -> + if (file.isFile) { + kobaltLog(3, " Calculating checksum of $file") + val bytes = toBytes(file) + md5.update(bytes, 0, bytes.size) + fileCount++ + } else { + val files = KFiles.findRecursively(file) // , { f -> f.endsWith("java")}) + kobaltLog(3, " Calculating checksum of ${files.size} files in $file") + files.map { + File(file, it) + }.filter { + it.isFile + }.forEach { + fileCount++ + val bytes = toBytes(it) + md5.update(bytes, 0, bytes.size) + } + } + } + + // The output directory might exist but with no files in it, in which case + // we must run the task + if (fileCount > 0) { + val result = DatatypeConverter.printHexBinary(md5.digest()).toLowerCase() + return result + } else { + return null + } + } + } else { + return null + } + } + fun toMd5(file: File) = MessageDigest.getInstance("MD5").let { md5 -> file.forEachBlock { bytes, size -> md5.update(bytes, 0, size) @@ -14,3 +72,4 @@ public class Md5 { } } } + diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/Pom.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/Pom.kt index 7797cce3..a6263e22 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/Pom.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/Pom.kt @@ -1,16 +1,14 @@ package com.beust.kobalt.maven -import com.beust.kobalt.misc.log import com.beust.kobalt.misc.toString +import com.beust.kobalt.misc.warn import com.google.inject.assistedinject.Assisted -import kotlinx.dom.childElements import org.w3c.dom.Element import org.w3c.dom.NodeList -import org.xml.sax.InputSource -import java.io.FileReader +import javax.xml.parsers.DocumentBuilderFactory import javax.xml.xpath.XPathConstants -public class Pom @javax.inject.Inject constructor(@Assisted val id: String, +class Pom @javax.inject.Inject constructor(@Assisted val id: String, @Assisted documentFile: java.io.File) { val XPATH_FACTORY = javax.xml.xpath.XPathFactory.newInstance() val XPATH = XPATH_FACTORY.newXPath() @@ -18,39 +16,47 @@ public class Pom @javax.inject.Inject constructor(@Assisted val id: String, var artifactId: String? = null var packaging: String? = null var version: String? = null + + /** + * If the version is a string, extract it, look it up and evaluate it if we find it. Otherwise, error. + */ + private fun calculateVersion(s: String) : String { + val v = extractVar(s) + if (v != null) { + val value = properties[v] + if (value != null) { + return value + } else { + warn("Unknown variable for version: " + s) + return "" + } + } else { + return s + } + } + + private fun extractVar(s: String) : String? { + if (s.startsWith("\${") && s.endsWith("}")) { + return s.substring(2, s.length - 1) + } else { + return null + } + } + var name: String? = null var properties = sortedMapOf() var repositories = listOf() - public interface IFactory { + interface IFactory { fun create(@Assisted id: String, @Assisted documentFile: java.io.File): Pom } - data public class Dependency(val groupId: String, val artifactId: String, val packaging: String?, + data class Dependency(val groupId: String, val artifactId: String, val packaging: String?, val version: String, val optional: Boolean = false, val scope: String? = null) { - /** When a variable is used in a maven file, e.g. ${version} */ - private val VAR = "$" + "{" - val mustDownload: Boolean get() = !optional && "provided" != scope && "test" != scope - val isValid: Boolean - get() { - var result = false - if (version.contains(VAR)) { - log(3, "Skipping variable version ${this}") - } else if (groupId.contains(VAR)) { - log(3, "Skipping variable groupId ${this}") - } else if (artifactId.contains(VAR)) { - log(3, "Skipping variable artifactId ${this}") - } else { - result = true - } - return result - } - - val id: String = "$groupId:$artifactId:$version" } @@ -58,8 +64,8 @@ public class Pom @javax.inject.Inject constructor(@Assisted val id: String, init { val DEPENDENCIES = XPATH.compile("/project/dependencies/dependency") + val document = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(documentFile) - val document = kotlinx.dom.parseXml(InputSource(FileReader(documentFile))) groupId = XPATH.compile("/project/groupId").evaluate(document) artifactId = XPATH.compile("/project/artifactId").evaluate(document) version = XPATH.compile("/project/version").evaluate(document) @@ -67,11 +73,12 @@ public class Pom @javax.inject.Inject constructor(@Assisted val id: String, var repositoriesList = XPATH.compile("/project/repositories").evaluate(document, XPathConstants.NODESET) as NodeList var repoElem = repositoriesList.item(0) as Element? - repositories = repoElem.childElements().map({ it.getElementsByTagName("url").item(0).textContent }) + repositories = childElements(repoElem).map({ it.getElementsByTagName("url").item(0) + .textContent }) val propertiesList = XPATH.compile("/project/properties").evaluate(document, XPathConstants.NODESET) as NodeList var propsElem = propertiesList.item(0) as Element? - propsElem.childElements().forEach { + childElements(propsElem).forEach { properties.put(it.nodeName, it.textContent) } @@ -81,7 +88,7 @@ public class Pom @javax.inject.Inject constructor(@Assisted val id: String, var groupId: String? = null var artifactId: String? = null var packaging: String? = null - var version: String = "" + var readVersion: String = "" var optional: Boolean? = false var scope: String? = null for (j in 0..d.length - 1) { @@ -91,16 +98,30 @@ public class Pom @javax.inject.Inject constructor(@Assisted val id: String, "groupId" -> groupId = e.textContent "artifactId" -> artifactId = e.textContent "type" -> packaging = e.textContent - "version" -> version = e.textContent + "version" -> readVersion = e.textContent "optional" -> optional = "true".equals(e.textContent, true) "scope" -> scope = e.textContent } } } + val version = calculateVersion(readVersion) val tmpDependency = Dependency(groupId!!, artifactId!!, packaging, version, optional!!, scope) dependencies.add(tmpDependency) } } - override public fun toString() = toString("Pom", id, "id") + private fun childElements(repoElem: Element?): List { + val result = arrayListOf() + if (repoElem != null) { + for (i in 0..repoElem.childNodes.length - 1) { + val elem = repoElem.childNodes.item(i) + if (elem is Element) { + result.add(elem) + } + } + } + return result + } + + override fun toString() = toString("Pom", "id", id) } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/Pom2.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/Pom2.kt new file mode 100644 index 00000000..879f6d51 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/Pom2.kt @@ -0,0 +1,163 @@ +package com.beust.kobalt.maven + +import com.beust.kobalt.misc.kobaltLog +import org.w3c.dom.Element +import org.xml.sax.InputSource +import java.io.File +import java.io.FileReader +import javax.xml.bind.JAXBContext +import javax.xml.bind.annotation.* +import javax.xml.parsers.SAXParserFactory +import javax.xml.transform.sax.SAXSource + +@XmlRootElement(name = "project") +class PomProject { + var modelVersion: String? = null + var groupId: String? = null + var artifactId: String? = null + var version: String? = null + var name: String? = null + var description: String? = null + var url: String? = null + var packaging: String? = null + var properties: Properties? = null + var parent: Parent? = null + @XmlElement(name = "dependencies") @JvmField + var pomDependencies: Dependencies? = null + val dependencies: List + get() = + if (pomDependencies != null) pomDependencies!!.dependencies + else emptyList() + + var pluginRepositories: PluginRepositories? = null + + val propertyMap = hashMapOf() + fun propertyValue(s: String) : String? { + if (propertyMap.isEmpty()) { + properties?.properties?.forEach { + propertyMap.put(it.nodeName, it.textContent.trim()) + } + } + return propertyMap[s] + } +} + +class Either(val exception: E?, val value: V?) + +class Pom2(val pomProject: PomProject) { + companion object { + fun parse(documentFile: File, dependencyManager: DependencyManager): Either { + val jaxbContext = JAXBContext.newInstance(PomProject::class.java) + val unmarshaller = jaxbContext.createUnmarshaller() + + val sax = SAXParserFactory.newInstance() + sax.isNamespaceAware = false + val reader = sax.newSAXParser().xmlReader + val er = SAXSource(reader, InputSource(FileReader(documentFile))) + + try { + val result = unmarshaller.unmarshal(er) as PomProject + result.parent?.let { + val id = with(it) { + groupId + ":" + artifactId + ":" + version + } + val dep = dependencyManager.createMaven(id) + } + return Either(null, Pom2(result)) + } catch(ex: Exception) { + return Either(ex, null) + } + } + } +} + +class Properties { + @XmlAnyElement @JvmField + val properties = arrayListOf() +} + +class Developers { + @XmlElement(name = "developer") @JvmField + val developers = arrayListOf() +} + +class Developer { + var name: String? = null + var id: String? = null +} + +class Licenses { + @XmlElement(name = "license") @JvmField + val licenses = arrayListOf() +} + +class License { + var name: String? = null + var url: String? = null + var distribution: String? = null +} + +class PluginRepositories { + @XmlElement(name = "pluginRepository") @JvmField + val pluginRepository = arrayListOf() +} + +class PluginRepository { + var id: String? = null + var name: String? = null + var url: String? = null +} + +class Dependencies { + @XmlElement(name = "dependency") @JvmField + val dependencies = arrayListOf() +} + +class Dependency { + @JvmField + var groupId: String = "" + fun groupId(pom: Pom2) : String = expandVariable(groupId, pom) + + @JvmField + var artifactId: String = "" + fun artifactId(pom: Pom2) : String = expandVariable(artifactId, pom) + + @JvmField + var version: String = "" + fun version(pom: Pom2) : String = expandVariable(version, pom) + + @JvmField + var optional: String = "false" + @JvmField + var scope: String = "" + @JvmField + var packaging: String = "" + + fun id(pom: Pom2) = groupId(pom) + ":" + artifactId(pom) + ":" + version(pom) + + val mustDownload: Boolean + get() = ! optional.toBoolean() && "provided" != scope && "test" != scope + + val isValid : Boolean get() = true //! isVariable(groupId) && ! isVariable(artifactId) && ! isVariable(version) + + private fun extractVariable(s: String) = if (s.startsWith("\${") && s.endsWith("}")) s.substring(2, s.length - 1) + else null + + private fun expandVariable(s: String, pom: Pom2) : String { + val variable = extractVariable(s) + if (variable != null) { + kobaltLog(2, "Expanding variable $variable") + val value = pom.pomProject.propertyValue(variable) + return s + } else { + return s + } + } +} + +class Parent { + var groupId: String? = null + var artifactId: String? = null + var version: String? = null +} + diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/PomGenerator.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/PomGenerator.kt index d0986dea..79c5e4b8 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/PomGenerator.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/PomGenerator.kt @@ -1,65 +1,113 @@ package com.beust.kobalt.maven import com.beust.kobalt.SystemProperties +import com.beust.kobalt.api.IClasspathDependency import com.beust.kobalt.api.Project import com.beust.kobalt.misc.KFiles -import com.beust.kobalt.misc.log +import com.beust.kobalt.misc.kobaltLog import com.google.inject.assistedinject.Assisted import org.apache.maven.model.Developer import org.apache.maven.model.Model -import org.apache.maven.model.Scm import org.apache.maven.model.io.xpp3.MavenXpp3Writer import java.io.File import java.io.StringWriter import java.nio.charset.Charset import javax.inject.Inject -public class PomGenerator @Inject constructor(@Assisted val project: Project) { +class PomGenerator @Inject constructor(@Assisted val project: Project) { interface IFactory { fun create(project: Project) : PomGenerator } - fun generate() { - requireNotNull(project.version, { "version mandatory on project ${project.name}" }) - requireNotNull(project.group, { "group mandatory on project ${project.name}" }) - requireNotNull(project.artifactId, { "artifactId mandatory on project ${project.name}" }) - - val m = Model().apply { - name = project.name - artifactId = project.artifactId - groupId = project.group - version = project.version - description = project.description - licenses = project.licenses.map { it.toMavenLicense() } - url = project.url - scm = Scm().apply { - project.scm?.let { - url = it.url - connection = it.connection - developerConnection = it.developerConnection - } - } - } - with(Developer()) { - name = SystemProperties.username - m.addDeveloper(this) - } - - val dependencies = arrayListOf() - m.dependencies = dependencies - project.compileDependencies.forEach { dep -> - dependencies.add(dep.toMavenDependencies()) - } - - val s = StringWriter() - MavenXpp3Writer().write(s, m) + /** + * Generate the POM file and save it. + */ + fun generateAndSave() { + requireNotNull(project.version, { "version is mandatory on project ${project.name}" }) + requireNotNull(project.group, { "group is mandatory on project ${project.name}" }) + requireNotNull(project.artifactId, { "artifactId is mandatory on project ${project.name}" }) val buildDir = KFiles.makeDir(project.directory, project.buildDirectory) val outputDir = KFiles.makeDir(buildDir.path, "libs") - val mavenId = MavenId.create(project.group!!, project.artifactId!!, project.packaging, project.version!!) + val NO_CLASSIFIER = null + val mavenId = MavenId.create(project.group!!, project.artifactId!!, project.packaging, NO_CLASSIFIER, + project.version!!) val pomFile = SimpleDep(mavenId).toPomFileName() val outputFile = File(outputDir, pomFile) - outputFile.writeText(s.toString(), Charset.defaultCharset()) - log(1, " Wrote $outputFile") + outputFile.writeText(generate(), Charset.defaultCharset()) + kobaltLog(1, " Created $outputFile") } -} \ No newline at end of file + + /** + * @return the text content of the POM file. + */ + fun generate() : String { + val pom = (project.pom ?: Model()).apply { + // Make sure the pom has reasonable default values + if (name == null) name = project.name + if (artifactId == null) artifactId = project.artifactId + if (groupId == null) groupId = project.group + if (modelVersion == null) modelVersion = "4.0.0" + if (version == null) version = project.version + if (description == null) description = project.description + if (url == null) url = project.url + if (developers == null) { + developers = listOf(Developer().apply { + name = SystemProperties.username + }) + } + } + + // + // Dependencies + // + pom.dependencies = arrayListOf() + + /** + * optional and provided dependencies are added both to the compile dependencies (since they are needed + * to build the project) and to their respective list as well (for POM generation). Make sure they + * don't get added twice to the .pom in such cases. + */ + fun providedOrOptional(dep: IClasspathDependency) = + project.compileProvidedDependencies.contains(dep) || + project.optionalDependencies.contains(dep) + + // Compile dependencies + project.compileDependencies.filterNot(::providedOrOptional).forEach { dep -> + pom.dependencies.add(dep.toMavenDependencies()) + } + + // Optional compile dependencies + project.optionalDependencies.forEach { dep -> + pom.dependencies.add(dep.toMavenDependencies()) + } + + // Provided dependencies + project.compileProvidedDependencies.forEach { dep -> + pom.dependencies.add(dep.toMavenDependencies("provided")) + } + + // Test dependencies + project.testDependencies.forEach { dep -> + pom.dependencies.add(dep.toMavenDependencies("test")) + } + + // Test provided dependencies + project.testProvidedDependencies.forEach { dep -> + pom.dependencies.add(dep.toMavenDependencies("test")) + } + + // Project dependencies + project.dependsOn.forEach { + pom.dependencies.add(org.apache.maven.model.Dependency().apply { + version = it.version + groupId = it.group + artifactId = it.artifactId + }) + } + + val s = StringWriter() + MavenXpp3Writer().write(s, pom) + return s.toString() + } +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/RepoFinder.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/RepoFinder.kt deleted file mode 100644 index 365ca110..00000000 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/RepoFinder.kt +++ /dev/null @@ -1,218 +0,0 @@ -package com.beust.kobalt.maven - -import com.beust.kobalt.HostConfig -import com.beust.kobalt.api.Kobalt -import com.beust.kobalt.maven.dependency.FileDependency -import com.beust.kobalt.misc.* -import com.google.common.cache.CacheBuilder -import com.google.common.cache.CacheLoader -import com.google.common.cache.LoadingCache -import kotlinx.dom.asElementList -import kotlinx.dom.parseXml -import org.w3c.dom.NodeList -import java.io.File -import java.util.concurrent.Callable -import java.util.concurrent.ExecutorCompletionService -import java.util.concurrent.TimeUnit -import javax.inject.Inject -import javax.xml.xpath.XPathConstants -import javax.xml.xpath.XPathFactory - -/** - * Find the repo that contains the given dependency among a list of repos. Searches are performed in parallel and - * cached so we never make a network call for the same dependency more than once. - */ -public class RepoFinder @Inject constructor(val executors: KobaltExecutors) { - public fun findCorrectRepo(id: String): RepoResult { - return FOUND_REPOS.get(id) - } - - data class RepoResult(val hostConfig: HostConfig, val found: Boolean, val version: Version? = null, - val hasJar: Boolean = true, val snapshotVersion: Version? = null) - - private val FOUND_REPOS: LoadingCache = CacheBuilder.newBuilder() - .build(object : CacheLoader() { - override fun load(key: String): RepoResult { - return loadCorrectRepo(key) - }}) - - /** - * Schedule an HTTP request to each repo in its own thread. - */ - private fun loadCorrectRepo(id: String): RepoResult { - val executor = executors.newExecutor("RepoFinder-$id", Kobalt.repos.size) - val cs = ExecutorCompletionService(executor) - - val results = arrayListOf() - try { - log(2, "Looking for $id") - Kobalt.repos.forEach { cs.submit(RepoFinderCallable(id, it)) } - for (i in 0..Kobalt.repos.size - 1) { - try { - val result = cs.take().get(2000, TimeUnit.MILLISECONDS) - log(2, " Result for repo #$i: $result") - if (result.found) { - log(2, "Located $id in ${result.hostConfig.url}") - results.add(result) - } - } catch(ex: Exception) { - warn("Error: $ex") - } - } - } finally { - executor.shutdownNow() - } - - if (results.size > 0) { -// results.sortByDescending { Versions.toLongVersion(it.version) } - results.sort({ left, right -> left.version!!.compareTo(right.version!!) }) - return results[0] - } else { - return RepoResult(HostConfig(""), false, Version.of(id)) - } - } - - /** - * Execute a single HTTP request to one repo. - */ - inner class RepoFinderCallable(val id: String, val repo: HostConfig) : Callable { - override fun call(): RepoResult { - val repoUrl = repo.url - log(2, " Checking $repoUrl for $id") - - val mavenId = MavenId.create(id) - val groupId = mavenId.groupId - val artifactId = mavenId.artifactId - - if (mavenId.version == null) { - val ud = UnversionedDep(groupId, artifactId) - val isLocal = repoUrl.startsWith(FileDependency.PREFIX_FILE) - val foundVersion = findCorrectVersionRelease(ud.toMetadataXmlPath(false, isLocal), repoUrl) - if (foundVersion != null) { - return RepoResult(repo, true, Version.of(foundVersion)) - } else { - return RepoResult(repo, false) - } - } else { - val version = Version.of(mavenId.version) - if (version.isSnapshot()) { - val dep = SimpleDep(mavenId) - val isLocal = repoUrl.startsWith(FileDependency.PREFIX_FILE) - val metadataXmlPath = dep.toMetadataXmlPath(false, isLocal, version.version) - val snapshotVersion = - if (isLocal) version - else findSnapshotVersion(metadataXmlPath, repoUrl, mavenId.version) - if (snapshotVersion != null) { - val url = repoUrl + metadataXmlPath - val kurl = Kurl(HostConfig(url)) - val found = kurl.exists - return RepoResult(repo, found, version, true /* hasJar, potential bug here */, - snapshotVersion) - } else { - return RepoResult(repo, false) - } - } else if (version.isRangedVersion() ) { - val foundVersion = findRangedVersion(SimpleDep(mavenId), repoUrl) - if (foundVersion != null) { - return RepoResult(repo, true, foundVersion) - } else { - return RepoResult(repo, false) - } - - } else { - val dep = SimpleDep(mavenId) - // Try to find the jar file - val urlJar = repo.copy(url = repo.url + dep.toJarFile(dep.version)) - val hasJar = Kurl(urlJar).exists - val found = - if (! hasJar) { - // No jar, try to find the directory - val url = repo.copy(url = repoUrl - + File(dep.toJarFile(dep.version)).parentFile.path.replace("\\", "/")) - Kurl(url).exists - } else { - true - } - log(2, "Result for $repoUrl for $id: $found") - return RepoResult(repo, found, Version.of(dep.version), hasJar) - } - } - } - } - - val XPATH_FACTORY = XPathFactory.newInstance(); - val XPATH = XPATH_FACTORY.newXPath(); - - fun findCorrectVersionRelease(metadataPath: String, repoUrl: String): String? { - val XPATHS = arrayListOf( - XPATH.compile("/metadata/version"), - XPATH.compile("/metadata/versioning/latest"), - XPATH.compile("/metadata/versioning/release")) - // No version in this dependency, find out the most recent one by parsing maven-metadata.xml, if it exists - val url = repoUrl + metadataPath - try { - val doc = parseXml(url) - arrayListOf(XPATHS.forEach { - val result = it.evaluate(doc, XPathConstants.STRING) as String - if (! result.isEmpty()) { - return result - } - }) - } catch(ex: Exception) { - log(2, "Couldn't find metadata at $url: ${ex.message}") - } - return null - } - - fun findRangedVersion(dep: SimpleDep, repoUrl: String): Version? { - val l = listOf(dep.groupId.replace(".", "/"), dep.artifactId.replace(".", "/"), "maven-metadata.xml") - var metadataPath = l.joinToString("/") - - val versionsXpath = XPATH.compile("/metadata/versioning/versions/version") - - // No version in this dependency, find out the most recent one by parsing maven-metadata.xml, if it exists - val url = repoUrl + metadataPath - try { - val doc = parseXml(url) - val version = Version.of(dep.version) - if(version.isRangedVersion()) { - val versions = (versionsXpath.evaluate(doc, XPathConstants.NODESET) as NodeList) - .asElementList().map { Version.of(it.textContent) } - return version.select(versions) - } else { - return Version.of(XPATH.compile("/metadata/versioning/versions/version/$version") - .evaluate(doc, XPathConstants.STRING) as String) - } - } catch(ex: Exception) { - log(2, "Couldn't find metadata at ${url}") - } - return null - } - - fun findSnapshotVersion(metadataPath: String, repoUrl: String, snapshotVersion: String): Version? { - val timestamp = XPATH.compile("/metadata/versioning/snapshot/timestamp") - val buildNumber = XPATH.compile("/metadata/versioning/snapshot/buildNumber") - // No version in this dependency, find out the most recent one by parsing maven-metadata.xml, if it exists - val url = repoUrl + metadataPath - try { - val doc = parseXml(url) - val ts = timestamp.evaluate(doc, XPathConstants.STRING) - val bn = buildNumber.evaluate(doc, XPathConstants.STRING) - if (! Strings.isEmpty(ts.toString()) && ! Strings.isEmpty(bn.toString())) { - return Version(snapshotVersion, ts.toString() + "-" + bn.toString()) - } else { - val lastUpdated = XPATH.compile("/metadata/versioning/lastUpdated") - if (! lastUpdated.toString().isEmpty()) { - return Version.of(lastUpdated.toString()) - } - - } - } catch(ex: Exception) { - log(2, "Couldn't find metadata at $url") - } - return null - } - - - -} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/SimpleDep.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/SimpleDep.kt index cd4ba5fc..7c93f2ea 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/SimpleDep.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/SimpleDep.kt @@ -9,31 +9,34 @@ open class SimpleDep(open val mavenId: MavenId) : UnversionedDep(mavenId.groupId } } - val version: String get() = mavenId.version!! + override fun toString() = mavenId.toId + + val version: String get() = + if (mavenId.version == null) { + "" +// throw AssertionError("Version should have been resolved: ${mavenId.toId}") + } else { + mavenId.version!! + } private fun toFile(version: Version, suffix: String): String { + val dir = toDirectory(version.version, false, trailingSlash = false) val list = - if (version.snapshotTimestamp != null) { - listOf(toDirectory(version.version, false), - artifactId + "-" + version.noSnapshotVersion + "-" + version.snapshotTimestamp + suffix) - } else { - listOf(toDirectory(version.version, false), artifactId + "-" + version.version + suffix) - } - return list.joinToString("/") + if (version.snapshotTimestamp != null) { + listOf(dir, artifactId + "-" + version.noSnapshotVersion + "-" + version.snapshotTimestamp + suffix) + } else { + listOf(dir, artifactId + "-" + version.version + suffix) + } + return list.joinToString("/").replace("//", "/") } fun toPomFile(v: String) = toFile(Version.of(v), ".pom") - fun toPomFile(r: RepoFinder.RepoResult) = toFile(r.snapshotVersion ?: r.version!!, ".pom") - fun toJarFile(v: String = version) = toFile(Version.of(v), suffix) - - fun toJarFile(v: Version) = toFile(v, suffix) + fun toAarFile(v: String = version) = toFile(Version.of(v), ".aar") fun toPomFileName() = "$artifactId-$version.pom" - fun toJarFile(r: RepoFinder.RepoResult) = toFile(r.snapshotVersion ?: r.version!!, suffix) - val suffix : String get() { val packaging = mavenId.packaging diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/UnversionedDep.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/UnversionedDep.kt index ed76b1d3..40d9c524 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/UnversionedDep.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/UnversionedDep.kt @@ -1,6 +1,5 @@ package com.beust.kobalt.maven -import com.beust.kobalt.misc.Strings import java.io.File /** @@ -19,13 +18,12 @@ open class UnversionedDep(open val groupId: String, open val artifactId: String) /** * Turn this dependency to a directory. If fileSystem is true, use the file system - * dependent path separator, otherwise, use '/' (used to create URL's). The returned - * string always ends with the path separator. + * dependent path separator, otherwise, use '/' (used to create URL's). */ - fun toDirectory(v: String, fileSystem: Boolean = true): String { + fun toDirectory(v: String, fileSystem: Boolean = true, trailingSlash: Boolean = true): String { val sep = if (fileSystem) File.separator else "/" val l = listOf(groupId.replace(".", sep), artifactId, v) - val result = Strings.Companion.join(sep, l) - return if (result.endsWith(sep)) result else result + sep + val result = l.joinToString(sep) + return if (trailingSlash && ! result.endsWith(sep)) result + sep else result } } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/AetherDependency.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/AetherDependency.kt new file mode 100644 index 00000000..825a8ae8 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/AetherDependency.kt @@ -0,0 +1,94 @@ +package com.beust.kobalt.maven.aether + +import com.beust.kobalt.Args +import com.beust.kobalt.api.Dependencies +import com.beust.kobalt.api.IClasspathDependency +import com.beust.kobalt.api.Kobalt +import com.beust.kobalt.maven.CompletedFuture +import com.beust.kobalt.misc.StringVersion +import com.beust.kobalt.misc.warn +import org.eclipse.aether.artifact.Artifact +import org.eclipse.aether.artifact.DefaultArtifact +import org.eclipse.aether.resolution.DependencyResolutionException +import java.io.File +import java.util.concurrent.Future + +class AetherDependency(val artifact: Artifact, override val optional: Boolean = false, val args: Args? = null) + : IClasspathDependency, Comparable { + val aether: KobaltMavenResolver get() = Kobalt.INJECTOR.getInstance(KobaltMavenResolver::class.java) + + override val id: String = toId(artifact) + + override val version: String = artifact.version + + override val isMaven = true + + private fun toId(a: Artifact) = a.toString() + + override val jarFile: Future + get() { + resolveSourcesIfNeeded() + return if (artifact.file != null) { + CompletedFuture(artifact.file) + } else { + val td = aether.resolve(artifact) + CompletedFuture(td.root.artifact.file) + } + } + + private fun resolveSourcesIfNeeded() { + if (args?.downloadSources ?: false) { + listOf(artifact.toSourcesArtifact(), artifact.toJavaDocArtifact()).forEach { artifact -> + if (artifact.file == null) { + try { + aether.resolve(artifact) + } catch(e: DependencyResolutionException) { + // Ignore + } + } + } + } + } + + override fun toMavenDependencies(scope: String?) : org.apache.maven.model.Dependency { + val passedScope = scope + val op = this.optional + return org.apache.maven.model.Dependency().apply { + groupId = artifact.groupId + artifactId = artifact.artifactId + version = artifact.version + if (op) optional = op.toString() + if (passedScope != null) this.scope = passedScope + } + } + + override fun directDependencies(): List { + val result = arrayListOf() + val deps = aether.directDependencies(artifact) + if (deps != null) { + deps.root.children.forEach { + result.add(AetherDependency(it.artifact, it.dependency.optional)) + } + } else { + warn("Couldn't resolve $artifact") + } + return result + } + + override val shortId = artifact.groupId + ":" + artifact.artifactId + ":" + artifact.classifier + + override val excluded = arrayListOf() + + override fun compareTo(other: AetherDependency): Int { + return StringVersion(artifact.version).compareTo(StringVersion(other.artifact.version)) + } + + override fun hashCode() = id.hashCode() + + override fun equals(other: Any?) = if (other is AetherDependency) other.id == id else false + + override fun toString() = id + + fun Artifact.toSourcesArtifact() = DefaultArtifact(groupId, artifactId, "sources", extension, version) + fun Artifact.toJavaDocArtifact() = DefaultArtifact(groupId, artifactId, "javadoc", extension, version) +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/Booter.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/Booter.kt new file mode 100644 index 00000000..02917929 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/Booter.kt @@ -0,0 +1,55 @@ +package com.beust.kobalt.maven.aether + +import com.beust.kobalt.internal.KobaltSettings +import com.google.common.eventbus.EventBus +import com.beust.kobalt.Args +import org.eclipse.aether.DefaultRepositorySystemSession +import org.eclipse.aether.RepositorySystem +import org.eclipse.aether.repository.LocalRepository +import java.io.File + +object Booter { + + fun newRepositorySystem(): RepositorySystem { + return ManualRepositorySystemFactory.newRepositorySystem() + // return org.eclipse.aether.examples.guice.GuiceRepositorySystemFactory.newRepositorySystem(); + // return org.eclipse.aether.examples.sisu.SisuRepositorySystemFactory.newRepositorySystem(); + // return org.eclipse.aether.examples.plexus.PlexusRepositorySystemFactory.newRepositorySystem(); + } + +// fun newRepositorySystemSession(system: RepositorySystem): DefaultRepositorySystemSession { +// val session = org.apache.maven.repository.internal.MavenRepositorySystemUtils.newSession() +// +// val localRepo = LocalRepository("target/local-repo") +// session.localRepositoryManager = system.newLocalRepositoryManager(session, localRepo) +// +// session.transferListener = ConsoleTransferListener() +// session.repositoryListener = ConsoleRepositoryListener(System.out, EventBus()) +// +// // uncomment to generate dirty trees +// // session.setDependencyGraphTransformer( null ); +// +// return session +// } + + fun newRepositorySystemSession(system: RepositorySystem, repo: File, settings: KobaltSettings, + args: Args, eventBus: EventBus): DefaultRepositorySystemSession { + val session = MavenRepositorySystemUtils.newSession(settings) + session.isOffline = args.offline + + val localRepo = LocalRepository(repo.absolutePath) + session.localRepositoryManager = system.newLocalRepositoryManager(session, localRepo) + + session.transferListener = ConsoleTransferListener() + session.repositoryListener = ConsoleRepositoryListener(eventBus = eventBus) + + // uncomment to generate dirty trees + // session.setDependencyGraphTransformer( null ); + + return session + } + +// fun newRepositories(repositories: Collection) +// = repositories.map { RemoteRepository.Builder("maven", "default", it).build() } +} + diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/ConsoleRepositoryListener.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/ConsoleRepositoryListener.kt new file mode 100644 index 00000000..fdbdbac7 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/ConsoleRepositoryListener.kt @@ -0,0 +1,93 @@ +package com.beust.kobalt.maven.aether + +import com.beust.kobalt.internal.eventbus.ArtifactDownloadedEvent +import com.beust.kobalt.misc.kobaltLog +import com.google.common.eventbus.EventBus +import org.eclipse.aether.AbstractRepositoryListener +import org.eclipse.aether.RepositoryEvent +import java.io.PrintStream + +/** + * A simplistic repository listener that logs events to the console. + */ +class ConsoleRepositoryListener @JvmOverloads constructor(out: PrintStream? = null, val eventBus: EventBus) + : AbstractRepositoryListener() { + companion object { + val LOG_LEVEL = 4 + } + + override fun artifactDeployed(event: RepositoryEvent?) { + kobaltLog(LOG_LEVEL, "Deployed " + event!!.artifact + " to " + event.repository) + } + + override fun artifactDeploying(event: RepositoryEvent?) { + kobaltLog(LOG_LEVEL, "Deploying " + event!!.artifact + " to " + event.repository) + } + + override fun artifactDescriptorInvalid(event: RepositoryEvent?) { + kobaltLog(LOG_LEVEL, "Invalid artifact descriptor for " + event!!.artifact + ": " + + event.exception.message) + } + + override fun artifactDescriptorMissing(event: RepositoryEvent?) { + kobaltLog(LOG_LEVEL, "Missing artifact descriptor for " + event!!.artifact) + } + + override fun artifactInstalled(event: RepositoryEvent?) { + kobaltLog(LOG_LEVEL, "Installed " + event!!.artifact + " to " + event.file) + } + + override fun artifactInstalling(event: RepositoryEvent?) { + kobaltLog(LOG_LEVEL, "Installing " + event!!.artifact + " to " + event.file) + } + + override fun artifactResolved(event: RepositoryEvent?) { + kobaltLog(LOG_LEVEL, "Resolved artifact " + event!!.artifact + " from " + event.repository) + } + + override fun artifactDownloading(event: RepositoryEvent?) { + kobaltLog(LOG_LEVEL, "Downloading artifact " + event!!.artifact + " from " + event.repository) + } + + override fun artifactDownloaded(event: RepositoryEvent?) { + if (event?.file != null && event?.artifact != null) { + val artifact = event!!.artifact + kobaltLog(1, "Downloaded artifact " + artifact + " from " + event.repository) + eventBus.post(ArtifactDownloadedEvent(artifact.toString(), event.repository)) + } + } + + override fun artifactResolving(event: RepositoryEvent?) { + kobaltLog(LOG_LEVEL, "Resolving artifact " + event!!.artifact) + } + + override fun metadataDeployed(event: RepositoryEvent?) { + kobaltLog(LOG_LEVEL, "Deployed " + event!!.metadata + " to " + event.repository) + } + + override fun metadataDeploying(event: RepositoryEvent?) { + kobaltLog(LOG_LEVEL, "Deploying " + event!!.metadata + " to " + event.repository) + } + + override fun metadataInstalled(event: RepositoryEvent?) { + kobaltLog(LOG_LEVEL, "Installed " + event!!.metadata + " to " + event.file) + } + + override fun metadataInstalling(event: RepositoryEvent?) { + kobaltLog(LOG_LEVEL, "Installing " + event!!.metadata + " to " + event.file) + } + + override fun metadataInvalid(event: RepositoryEvent?) { + kobaltLog(LOG_LEVEL, "Invalid metadata " + event!!.metadata) + } + + override fun metadataResolved(event: RepositoryEvent?) { + kobaltLog(LOG_LEVEL, "Resolved metadata " + event!!.metadata + " from " + event.repository) + } + + override fun metadataResolving(event: RepositoryEvent?) { + kobaltLog(LOG_LEVEL, "Resolving metadata " + event!!.metadata + " from " + event.repository) + } + +} + diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/ConsoleTransferListener.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/ConsoleTransferListener.kt new file mode 100644 index 00000000..46d8eb15 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/ConsoleTransferListener.kt @@ -0,0 +1,133 @@ +package com.beust.kobalt.maven.aether + +import com.beust.kobalt.misc.KobaltLogger +import com.beust.kobalt.misc.kobaltLog +import org.eclipse.aether.transfer.AbstractTransferListener +import org.eclipse.aether.transfer.MetadataNotFoundException +import org.eclipse.aether.transfer.TransferEvent +import org.eclipse.aether.transfer.TransferResource +import java.io.PrintStream +import java.text.DecimalFormat +import java.text.DecimalFormatSymbols +import java.util.* +import java.util.concurrent.ConcurrentHashMap + +class ConsoleTransferListener @JvmOverloads constructor(out: PrintStream? = null) : AbstractTransferListener() { + + private val out: PrintStream + + private val downloads = ConcurrentHashMap() + + private var lastLength: Int = 0 + + init { + this.out = out ?: System.out + } + + override fun transferInitiated(event: TransferEvent?) { + val message = if (event!!.requestType == TransferEvent.RequestType.PUT) "Uploading" else "Downloading" + + kobaltLog(2, message + ": " + event.resource.repositoryUrl + event.resource.resourceName) + } + + val PROPERTY_NO_ANIMATIONS = "com.beust.kobalt.noAnimations" + + override fun transferProgressed(event: TransferEvent?) { + // Not on a terminal: don't display the progress + if (System.console() == null || System.getProperty(PROPERTY_NO_ANIMATIONS) != null) return + + val resource = event!!.resource + downloads.put(resource, java.lang.Long.valueOf(event.transferredBytes)) + + val buffer = StringBuilder(64) + + for (entry in downloads.entries) { + val total = entry.key.contentLength + val complete = entry.value + + buffer.append(getStatus(complete, total)).append(" ") + } + + val pad = lastLength - buffer.length + lastLength = buffer.length + pad(buffer, pad) + buffer.append('\r') + + out.print(buffer) + } + + private fun getStatus(complete: Long, total: Long): String { + if (total >= 1024) { + return toKB(complete).toString() + "/" + toKB(total) + " KB " + } else if (total >= 0) { + return complete.toString() + "/" + total + " B " + } else if (complete >= 1024) { + return toKB(complete).toString() + " KB " + } else { + return complete.toString() + " B " + } + } + + private fun pad(buffer: StringBuilder, spaces: Int) { + var spaces = spaces + val block = " " + while (spaces > 0) { + val n = Math.min(spaces, block.length) + buffer.append(block, 0, n) + spaces -= n + } + } + + override fun transferSucceeded(event: TransferEvent) { + transferCompleted(event) + + val resource = event.resource + val contentLength = event.transferredBytes + if (contentLength >= 0) { + val type = if (event.requestType == TransferEvent.RequestType.PUT) "Uploaded" else "Downloaded" + val len = if (contentLength >= 1024) toKB(contentLength).toString() + " KB" + else contentLength.toString() + " B" + + var throughput = "" + val duration = System.currentTimeMillis() - resource.transferStartTime + if (duration > 0) { + val bytes = contentLength - resource.resumeOffset + val format = DecimalFormat("0.0", DecimalFormatSymbols(Locale.ENGLISH)) + val kbPerSec = bytes / 1024.0 / (duration / 1000.0) + throughput = " at " + format.format(kbPerSec) + " KB/sec" + } + + kobaltLog(2, type + ": " + resource.repositoryUrl + resource.resourceName + " (" + len + + throughput + ")") + } + } + + override fun transferFailed(event: TransferEvent) { + transferCompleted(event) + + if (event.exception !is MetadataNotFoundException) { + if (KobaltLogger.LOG_LEVEL > 2) { + Exceptions.printStackTrace(event.exception) + } + } + } + + private fun transferCompleted(event: TransferEvent) { + downloads.remove(event.resource) + + val buffer = StringBuilder(64) + pad(buffer, lastLength) + buffer.append('\r') + out.print(buffer) + } + + override fun transferCorrupted(event: TransferEvent?) { + Exceptions.printStackTrace(event!!.exception) + } + + fun toKB(bytes: Long): Long { + return (bytes + 1023) / 1024 + } + +} + diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/Exceptions.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/Exceptions.kt new file mode 100644 index 00000000..37fcda39 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/Exceptions.kt @@ -0,0 +1,14 @@ +package com.beust.kobalt.maven.aether + +object Exceptions { + fun printStackTrace(t: Throwable) { + t.printStackTrace(System.out) + +// println("PRINT STACK TRACE FOR $t") +// t.printStackTrace(System.out) +// println(t.message) +// t.stackTrace.forEach { +// println(" " + it) +// } + } +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/Filters.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/Filters.kt new file mode 100644 index 00000000..0a661c2c --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/Filters.kt @@ -0,0 +1,25 @@ +package com.beust.kobalt.maven.aether + +import com.beust.kobalt.misc.kobaltLog +import org.eclipse.aether.graph.DependencyFilter +import org.eclipse.aether.graph.DependencyNode +import org.eclipse.aether.util.artifact.JavaScopes + +object Filters { + val COMPILE_FILTER = DependencyFilter { p0, p1 -> + p0.dependency.scope == "" || p0.dependency.scope == JavaScopes.COMPILE + } + val TEST_FILTER = DependencyFilter { p0, p1 -> p0.dependency.scope == JavaScopes.TEST } + + val EXCLUDE_OPTIONAL_FILTER = object: DependencyFilter { + override fun accept(p0: DependencyNode, p1: MutableList): Boolean { + val result = p0.dependency != null && ! p0.dependency.optional + if (! result) { + kobaltLog(3, "Excluding from optional filter: $p0") + } + return result + } + + override fun toString() = "EXCLUDE_OPTIONAL_FILTER" + } +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/KobaltMavenResolver.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/KobaltMavenResolver.kt new file mode 100644 index 00000000..7c8b705f --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/KobaltMavenResolver.kt @@ -0,0 +1,180 @@ +package com.beust.kobalt.maven.aether + +import com.beust.kobalt.Args +import com.beust.kobalt.HostConfig +import com.beust.kobalt.KobaltException +import com.beust.kobalt.api.Kobalt +import com.beust.kobalt.internal.KobaltSettings +import com.beust.kobalt.internal.getProxy +import com.beust.kobalt.maven.Kurl +import com.beust.kobalt.maven.LocalRepo +import com.beust.kobalt.maven.MavenId +import com.beust.kobalt.misc.LocalProperties +import com.google.common.eventbus.EventBus +import com.google.inject.Inject +import org.eclipse.aether.artifact.Artifact +import org.eclipse.aether.artifact.DefaultArtifact +import org.eclipse.aether.collection.CollectRequest +import org.eclipse.aether.collection.CollectResult +import org.eclipse.aether.graph.DefaultDependencyNode +import org.eclipse.aether.graph.Dependency +import org.eclipse.aether.graph.DependencyFilter +import org.eclipse.aether.repository.RemoteRepository +import org.eclipse.aether.resolution.DependencyRequest +import org.eclipse.aether.resolution.DependencyResult +import org.eclipse.aether.resolution.VersionRangeRequest +import org.eclipse.aether.resolution.VersionRangeResult +import org.eclipse.aether.util.repository.AuthenticationBuilder +import java.util.* + +class KobaltMavenResolver @Inject constructor(val settings: KobaltSettings, + val args: Args, + localRepo: LocalRepo, eventBus: EventBus) { + + companion object { + fun artifactToId(artifact: Artifact) = artifact.let { + MavenId.toId(it.groupId, it.artifactId, it.extension, it.classifier, it.version) + } + fun isRangeVersion(id: String) = id.contains(",") + + fun initAuthentication(hostInfo: HostConfig) { + // See if the URL needs to be authenticated. Look in local.properties for keys + // of the format authUrl..user=xxx and authUrl..password=xxx + val properties = LocalProperties().localProperties + val host = java.net.URL(hostInfo.url).host + properties.entries.forEach { + val key = it.key.toString() + if (key == "${Kurl.KEY}.$host.${Kurl.VALUE_USER}") { + hostInfo.username = properties.getProperty(key) + } else if (key == "${Kurl.KEY}.$host.${Kurl.VALUE_PASSWORD}") { + hostInfo.password = properties.getProperty(key) + } + } + fun error(s1: String, s2: String) { + throw KobaltException("Found \"$s1\" but not \"$s2\" in local.properties for ${Kurl.KEY}.$host", + docUrl = "https://beust.com/kobalt/documentation/index.html#maven-repos-authenticated") + } + if (! hostInfo.username.isNullOrBlank() && hostInfo.password.isNullOrBlank()) { + error("username", "password") + } else if(hostInfo.username.isNullOrBlank() && ! hostInfo.password.isNullOrBlank()) { + error("password", "username") + } + + } + } + + fun resolveToArtifact(id: String, scope: Scope? = null, + filter: DependencyFilter = Filters.EXCLUDE_OPTIONAL_FILTER) : Artifact + = resolve(id, scope, filter).root.artifact + + fun resolve(passedId: String, scope: Scope? = null, + filter: DependencyFilter = Filters.EXCLUDE_OPTIONAL_FILTER, + repos: List = emptyList()): DependencyResult { + val mavenId = MavenId.toMavenId(passedId) + val id = + if (isRangeVersion(mavenId)) { + val artifact = DefaultArtifact(mavenId) + val request = VersionRangeRequest(artifact, createRepos(repos), null) + val rr = system.resolveVersionRange(session, request) + if (rr.highestVersion != null) { + val newArtifact = DefaultArtifact(artifact.groupId, artifact.artifactId, artifact.classifier, + artifact.extension, rr.highestVersion.toString()) + artifactToId(newArtifact) + } else { + throw KobaltException("Couldn't resolve $passedId") + } + } else { + passedId + } + + val collectRequest = createCollectRequest(id, scope, repos) + val dependencyRequest = DependencyRequest(collectRequest, filter) + val result = system.resolveDependencies(session, dependencyRequest) + // GraphUtil.displayGraph(listOf(result.root), { it -> it.children }, + // { it: DependencyNode, indent: String -> println(indent + it.toString()) }) + return result + } + + fun resolve(artifact: Artifact, scope: Scope? = null, + filter: DependencyFilter = Filters.EXCLUDE_OPTIONAL_FILTER) + = resolve(artifactToId(artifact), scope, filter) + + fun resolveToIds(id: String, scope: Scope? = null, + filter: DependencyFilter = Filters.EXCLUDE_OPTIONAL_FILTER, + seen: HashSet = hashSetOf()) : List { + val rr = resolve(id, scope, filter) + val children = + rr.root.children.filter { + filter.accept(DefaultDependencyNode(it.dependency), emptyList()) + }.filter { + it.dependency.scope != Scope.SYSTEM.scope + } + val result = listOf(artifactToId(rr.root.artifact)) + children.flatMap { + val thisId = artifactToId(it.artifact) + if (! seen.contains(thisId)) { + seen.add(thisId) + resolveToIds(thisId, scope, filter, seen) + } else { + emptyList() + } + } + return result + } + + fun directDependencies(id: String, scope: Scope? = null): CollectResult? + = system.collectDependencies(session, createCollectRequest(id, scope)) + + fun directDependencies(artifact: Artifact, scope: Scope? = null): CollectResult? + = artifactToId(artifact).let { id -> + directDependencies(id, scope) + } + + fun resolveRange(artifact: Artifact): VersionRangeResult? { + val request = VersionRangeRequest(artifact, kobaltRepositories, null) + val result = system.resolveVersionRange(session, request) + return result + } + + /** + * Create an IClasspathDependency from a Kobalt id. + */ + fun create(id: String, optional: Boolean) = AetherDependency(DefaultArtifact(id), optional, args) + + private val system = Booter.newRepositorySystem() + private val session = Booter.newRepositorySystemSession(system, localRepo.localRepo, settings, args, eventBus) + + private fun createRepo(hostConfig: HostConfig) : RemoteRepository { + val builder = RemoteRepository.Builder(hostConfig.name, "default", hostConfig.url) + if (hostConfig.hasAuth()) { + val auth = AuthenticationBuilder() + .addUsername(hostConfig.username) + .addPassword(hostConfig.password) + .build() + builder.setAuthentication(auth) + } + return builder.build() + } + + private val kobaltRepositories: List + get() = Kobalt.repos.map { + createRepo(it).let { repository -> + val proxyConfigs = settings.proxyConfigs ?: return@map repository + RemoteRepository.Builder(repository).apply { + setProxy(proxyConfigs.getProxy(repository.protocol)?.toAetherProxy()) + }.build() + } + } + + private fun createRepos(repos: List) : List + = kobaltRepositories + repos.map { createRepo(HostConfig(it)) } + + private fun createCollectRequest(id: String, scope: Scope? = null, repos: List = emptyList()) + = CollectRequest().apply { + val allIds = arrayListOf(MavenId.toMavenId(id)) + + dependencies = allIds.map { Dependency(DefaultArtifact(it), scope?.scope) } + + root = Dependency(DefaultArtifact(MavenId.toMavenId(id)), scope?.scope) + repositories = createRepos(repos) + } +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/ManualRepositorySystemFactory.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/ManualRepositorySystemFactory.kt new file mode 100644 index 00000000..7f019533 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/ManualRepositorySystemFactory.kt @@ -0,0 +1,39 @@ +package com.beust.kobalt.maven.aether + +import org.eclipse.aether.RepositorySystem +import org.eclipse.aether.connector.basic.BasicRepositoryConnectorFactory +import org.eclipse.aether.impl.DefaultServiceLocator +import org.eclipse.aether.spi.connector.RepositoryConnectorFactory +import org.eclipse.aether.spi.connector.transport.TransporterFactory +import org.eclipse.aether.transport.file.FileTransporterFactory +import org.eclipse.aether.transport.http.HttpTransporterFactory + +/** + * A factory for repository system instances that employs Aether's built-in service locator infrastructure to wire up + * the system's components. + */ +object ManualRepositorySystemFactory { + + fun newRepositorySystem(): RepositorySystem { + /* + * Aether's components implement org.eclipse.aether.spi.locator.Service to ease manual wiring and using the + * prepopulated DefaultServiceLocator, we only need to register the repository connector and transporter + * factories. + */ + val locator = MavenRepositorySystemUtils.newServiceLocator() + locator.addService(RepositoryConnectorFactory::class.java, BasicRepositoryConnectorFactory::class.java) + locator.addService(TransporterFactory::class.java, FileTransporterFactory::class.java) + locator.addService(TransporterFactory::class.java, HttpTransporterFactory::class.java) + + locator.setErrorHandler(object : DefaultServiceLocator.ErrorHandler() { + override fun serviceCreationFailed(type: Class<*>, impl: Class<*>, exception: Throwable) { + Exceptions.printStackTrace(exception) + } + }) + + return locator.getService(RepositorySystem::class.java) + } + +} + + diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/MavenRepositorySystemUtils.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/MavenRepositorySystemUtils.kt new file mode 100644 index 00000000..1b8a5e0f --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/MavenRepositorySystemUtils.kt @@ -0,0 +1,70 @@ +package com.beust.kobalt.maven.aether + +import com.beust.kobalt.internal.KobaltSettings +import org.apache.maven.repository.internal.* +import org.eclipse.aether.DefaultRepositorySystemSession +import org.eclipse.aether.artifact.DefaultArtifactType +import org.eclipse.aether.impl.* +import org.eclipse.aether.util.artifact.DefaultArtifactTypeRegistry +import org.eclipse.aether.util.graph.manager.ClassicDependencyManager +import org.eclipse.aether.util.graph.selector.AndDependencySelector +import org.eclipse.aether.util.graph.selector.ExclusionDependencySelector +import org.eclipse.aether.util.graph.selector.OptionalDependencySelector +import org.eclipse.aether.util.graph.selector.ScopeDependencySelector +import org.eclipse.aether.util.graph.transformer.* +import org.eclipse.aether.util.graph.traverser.FatArtifactTraverser +import org.eclipse.aether.util.repository.DefaultProxySelector +import org.eclipse.aether.util.repository.SimpleArtifactDescriptorPolicy + +object MavenRepositorySystemUtils { + + fun newServiceLocator(): DefaultServiceLocator { + val locator = DefaultServiceLocator() + locator.addService(ArtifactDescriptorReader::class.java, DefaultArtifactDescriptorReader::class.java) + locator.addService(VersionResolver::class.java, DefaultVersionResolver::class.java) + locator.addService(VersionRangeResolver::class.java, DefaultVersionRangeResolver::class.java) + locator.addService(MetadataGeneratorFactory::class.java, SnapshotMetadataGeneratorFactory::class.java) + locator.addService(MetadataGeneratorFactory::class.java, VersionsMetadataGeneratorFactory::class.java) + return locator + } + + fun newSession(settings: KobaltSettings): DefaultRepositorySystemSession { + val session = DefaultRepositorySystemSession() + val depTraverser = FatArtifactTraverser() + session.dependencyTraverser = depTraverser + val depManager = ClassicDependencyManager() + session.dependencyManager = depManager + val depFilter = AndDependencySelector(*arrayOf(ScopeDependencySelector(*arrayOf("test", "provided")), OptionalDependencySelector(), ExclusionDependencySelector())) + session.dependencySelector = depFilter + val transformer = ConflictResolver(NearestVersionSelector(), JavaScopeSelector(), SimpleOptionalitySelector(), JavaScopeDeriver()) + ChainedDependencyGraphTransformer(*arrayOf(transformer, JavaDependencyContextRefiner())) + session.dependencyGraphTransformer = transformer + val stereotypes = DefaultArtifactTypeRegistry() + stereotypes.add(DefaultArtifactType("pom")) + stereotypes.add(DefaultArtifactType("maven-plugin", "jar", "", "java")) + stereotypes.add(DefaultArtifactType("jar", "jar", "", "java")) + stereotypes.add(DefaultArtifactType("ejb", "jar", "", "java")) + stereotypes.add(DefaultArtifactType("ejb-client", "jar", "client", "java")) + stereotypes.add(DefaultArtifactType("test-jar", "jar", "tests", "java")) + stereotypes.add(DefaultArtifactType("javadoc", "jar", "javadoc", "java")) + stereotypes.add(DefaultArtifactType("java-source", "jar", "sources", "java", false, false)) + stereotypes.add(DefaultArtifactType("war", "war", "", "java", false, true)) + stereotypes.add(DefaultArtifactType("ear", "ear", "", "java", false, true)) + stereotypes.add(DefaultArtifactType("rar", "rar", "", "java", false, true)) + stereotypes.add(DefaultArtifactType("par", "par", "", "java", false, true)) + session.artifactTypeRegistry = stereotypes + session.artifactDescriptorPolicy = SimpleArtifactDescriptorPolicy(true, true) + val sysProps = System.getProperties() + session.setSystemProperties(sysProps) + session.setConfigProperties(sysProps) + settings.proxyConfigs?.let { proxyConfigs-> + session.proxySelector = DefaultProxySelector().apply { + proxyConfigs.forEach {config-> + add(config.toAetherProxy(), config.nonProxyHosts) + } + } + } + return session + } +} + diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/Scope.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/Scope.kt new file mode 100644 index 00000000..7822159e --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/Scope.kt @@ -0,0 +1,19 @@ +package com.beust.kobalt.maven.aether + +import com.beust.kobalt.api.IClasspathDependency +import com.beust.kobalt.api.Project +import org.eclipse.aether.util.artifact.JavaScopes + +sealed class Scope(val scope: String, val dependencyLambda: (Project) -> List) { + + companion object { + fun toScopes(isTest: Boolean) = if (isTest) listOf(TEST, COMPILE) else listOf(COMPILE) + } + + object COMPILE : Scope(JavaScopes.COMPILE, Project::compileDependencies) + object PROVIDED : Scope(JavaScopes.PROVIDED, Project::compileProvidedDependencies) + object COMPILEONLY : Scope("compileOnly", Project::compileOnlyDependencies) + object SYSTEM : Scope(JavaScopes.SYSTEM, { project -> emptyList() }) + object RUNTIME : Scope(JavaScopes.RUNTIME, Project::compileRuntimeDependencies) + object TEST : Scope(JavaScopes.TEST, Project::testDependencies) +} \ No newline at end of file diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/dependency/FileDependency.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/dependency/FileDependency.kt index 368e37a4..047754e2 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/dependency/FileDependency.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/dependency/FileDependency.kt @@ -1,22 +1,29 @@ package com.beust.kobalt.maven.dependency +import com.beust.kobalt.api.Dependencies import com.beust.kobalt.api.IClasspathDependency import com.beust.kobalt.maven.CompletedFuture import org.apache.maven.model.Dependency import java.io.File -open public class FileDependency(open val fileName: String) : IClasspathDependency, Comparable { +open class FileDependency(open val fileName: String, override val optional: Boolean = false) + : IClasspathDependency, Comparable { companion object { val PREFIX_FILE: String = "file://" } override val id = PREFIX_FILE + fileName + override val version = "0.0" + + override val isMaven = false + override val jarFile = CompletedFuture(File(fileName)) - override fun toMavenDependencies(): Dependency { + override fun toMavenDependencies(scope: String?): Dependency { with(Dependency()) { systemPath = jarFile.get().absolutePath + this.scope = scope return this } } @@ -25,6 +32,8 @@ open public class FileDependency(open val fileName: String) : IClasspathDependen override fun directDependencies() = arrayListOf() + override val excluded = arrayListOf() + override fun compareTo(other: FileDependency) = fileName.compareTo(other.fileName) override fun toString() = fileName diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/dependency/MavenDependency.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/dependency/MavenDependency.kt deleted file mode 100644 index c034213e..00000000 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/dependency/MavenDependency.kt +++ /dev/null @@ -1,94 +0,0 @@ -package com.beust.kobalt.maven.dependency - -import com.beust.kobalt.HostConfig -import com.beust.kobalt.KobaltException -import com.beust.kobalt.api.IClasspathDependency -import com.beust.kobalt.api.Kobalt -import com.beust.kobalt.maven.* -import com.beust.kobalt.misc.DependencyExecutor -import com.beust.kobalt.misc.Versions -import com.beust.kobalt.misc.warn -import com.google.inject.Key -import org.apache.maven.model.Dependency -import java.io.File -import java.util.concurrent.ExecutorService -import java.util.concurrent.Future -import javax.inject.Inject -import kotlin.properties.Delegates - -public class MavenDependency @Inject constructor(mavenId: MavenId, - val executor: ExecutorService, - override val localRepo: LocalRepo, - val repoFinder: RepoFinder, - val pomFactory: Pom.IFactory, - val downloadManager: DownloadManager) - : LocalDep(mavenId, localRepo), IClasspathDependency, Comparable { - override var jarFile: Future by Delegates.notNull() - var pomFile: Future by Delegates.notNull() - - init { - val jar = File(localRepo.toFullPath(toJarFile(version))) - val pom = File(localRepo.toFullPath(toPomFile(version))) - if (jar.exists() && pom.exists()) { - jarFile = CompletedFuture(jar) - pomFile = CompletedFuture(pom) - } else { - val repoResult = repoFinder.findCorrectRepo(mavenId.toId) - if (repoResult.found) { - jarFile = - if (repoResult.hasJar) { - downloadManager.download(HostConfig(url = repoResult.hostConfig.url + toJarFile(repoResult)), - jar.absolutePath, executor) - } else { - CompletedFuture(File("nonexistentFile")) // will be filtered out - } - pomFile = downloadManager.download(HostConfig(url = repoResult.hostConfig.url + toPomFile(repoResult)), - pom.absolutePath, executor) - } else { - throw KobaltException("Couldn't resolve ${mavenId.toId}") - } - } - } - - companion object { - val executor = Kobalt.INJECTOR.getInstance(Key.get(ExecutorService::class.java, DependencyExecutor::class.java)) - val depFactory = Kobalt.INJECTOR.getInstance(DepFactory::class.java) - - fun create(id: String, ex: ExecutorService = executor) = depFactory.create(id, ex) - - fun create(mavenId: MavenId, ex: ExecutorService = executor) = depFactory.create(mavenId.toId, ex) - } - - override fun toString() = mavenId.toId - - override val id = mavenId.toId - - override fun toMavenDependencies(): Dependency { - return Dependency().apply { - setGroupId(groupId) - setArtifactId(artifactId) - setVersion(version) - } - } - - override fun compareTo(other: MavenDependency): Int { - return Versions.toLongVersion(version).compareTo(Versions.toLongVersion(other.version)) - } - - override val shortId = "$groupId:$artifactId:" - - override fun directDependencies() : List { - val result = arrayListOf() - try { - pomFactory.create(id, pomFile.get()).dependencies.filter { - it.mustDownload && it.isValid - }.forEach { - result.add(create(MavenId.toId(it.groupId, it.artifactId, it.packaging, it.version))) - } - } catch(ex: Exception) { - warn("Exception when trying to resolve dependencies for $id: " + ex.message) - } - return result - } -} - diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/Benchmarks.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/Benchmarks.kt index 70378e2f..7209c51e 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/Benchmarks.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/Benchmarks.kt @@ -1,8 +1,15 @@ package com.beust.kobalt.misc -public fun benchmark(run: () -> Unit) : Long { +fun benchmarkMillis(run: () -> T) : Pair { val start = System.currentTimeMillis() - run() - return (System.currentTimeMillis() - start) / 1000 + val result = run() + return Pair(System.currentTimeMillis() - start, result) } +fun benchmarkSeconds(run: () -> T) : Pair { + val result = benchmarkMillis(run) + return Pair(result.first / 1000, result.second) +} + + + diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/BlockExtractor.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/BlockExtractor.kt new file mode 100644 index 00000000..a854156a --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/BlockExtractor.kt @@ -0,0 +1,119 @@ +package com.beust.kobalt.misc + +import java.io.File +import java.util.regex.Pattern + +class Section(val start: Int, val end: Int) { + override fun toString() = "$start-$end" +} + +class IncludedBuildSourceDir(val line: Int, val dirs: List) + +class BuildScriptInfo(val file: File, val fullBuildFile: List, val sections: List
, + val imports: List, val topLines: List) { + fun isInSection(lineNumber: Int): Boolean { + sections.forEach { + if (lineNumber >= it.start && lineNumber <= it.end) return true + } + return false + } + + val includedBuildSourceDirs = arrayListOf() + + fun addBuildSourceDir(dir: IncludedBuildSourceDir) = includedBuildSourceDirs.add(dir) + + fun includedBuildSourceDirsForLine(line: Int): List { + val result = includedBuildSourceDirs.find { it.line == line }?.dirs + return result ?: emptyList() + } +} + +/** + * Used to extract a keyword followed by opening and closing tags out of a list of strings, + * e.g. buildScript { ... }. + */ +class BlockExtractor(val regexp: Pattern, val opening: Char, val closing: Char) { + fun extractBlock(file: File, lines: List): BuildScriptInfo? { + var currentLineNumber = 0 + // First line of the buildScript block + var startLine = 0 + // Last line of the buildScript block + var endLine = 0 + var foundKeyword = false + var foundClosing = false + var count = 0 + val buildScript = arrayListOf() + val topLines = arrayListOf() + val finalTopLines = arrayListOf() + + fun updateCount(line: String) { + val currentLine = StringBuffer() + line.toCharArray().forEach { c -> + if (c == opening) { + count++ + } + if (c == closing) { + count-- + if (count == 0) { + currentLine.append(closing).append("\n") + foundClosing = true + endLine = currentLineNumber + } + } + if (foundKeyword && count > 0) currentLine.append(c) + } + + if (currentLine.isNotEmpty() && foundKeyword) buildScript.add(currentLine.toString()) + } + + val imports = arrayListOf() + val sections = arrayListOf
() + lines.forEach { line -> + val found = regexp.matcher(line).matches() + if (found) { + startLine = currentLineNumber + foundKeyword = true + count = 1 + buildScript.add(line) + finalTopLines.addAll(topLines) + } else { + if (line.startsWith("import")) { + if (isAllowedImport(line)) { + imports.add(line) + } + } else { + topLines.add(line) + } + updateCount(line) + } + + if (foundKeyword && foundClosing && count == 0) { + sections.add(Section(startLine, endLine)) + foundKeyword = false + foundClosing = false + count = 0 + startLine = 0 + endLine = 0 + } + + currentLineNumber++ + } + + if (sections.isNotEmpty()) { + val result = (imports.distinct() + buildScript).joinToString("\n") + "\n" + + return BuildScriptInfo(file, lines, sections, imports, finalTopLines) + } else { + return null + } + } + + companion object { + private val allowedImports = listOf("com.beust", "java") + private val disallowedImports = listOf("com.beust.kobalt.plugin") + + fun isAllowedImport(line: String) : Boolean { + return allowedImports.any { line.contains(it) } && !disallowedImports.any { line.contains(it) } + } + } +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/CheckVersions.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/CheckVersions.kt index e81e8d55..d15e8056 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/CheckVersions.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/CheckVersions.kt @@ -2,47 +2,51 @@ package com.beust.kobalt.misc import com.beust.kobalt.KobaltException import com.beust.kobalt.api.Project -import com.beust.kobalt.maven.DepFactory +import com.beust.kobalt.maven.DependencyManager import com.beust.kobalt.maven.MavenId -import com.beust.kobalt.maven.dependency.MavenDependency +import com.beust.kobalt.maven.aether.AetherDependency +import com.beust.kobalt.maven.aether.KobaltMavenResolver import javax.inject.Inject /** * Find out if any newer versions of the dependencies are available. */ -public class CheckVersions @Inject constructor(val depFactory : DepFactory, - val executors : KobaltExecutors) { +class CheckVersions @Inject constructor(val depManager: DependencyManager, + val executors : KobaltExecutors, val resolver: KobaltMavenResolver) { - fun run(projects: List) { + fun run(projects: List) = projects.forEach { run(it) } + + fun run(project: Project) { val executor = executors.newExecutor("CheckVersions", 5) val newVersions = hashSetOf() - projects.forEach { - listOf(it.compileDependencies, it.testDependencies).forEach { cds -> - cds.forEach { compileDependency -> - if (MavenId.isMavenId(compileDependency.id)) { - try { - val dep = depFactory.create(compileDependency.shortId, executor, localFirst = false) - if (dep is MavenDependency) { - val other = compileDependency as MavenDependency - if (dep.id != compileDependency.id - && Versions.toLongVersion(dep.version) > Versions.toLongVersion(other.version)) { - newVersions.add(dep.id) - } + listOf(project.compileDependencies, project.testDependencies).forEach { cds -> + cds.forEach { dep -> + if (MavenId.isMavenId(dep.id)) { + try { + val latestDep = depManager.create(dep.shortId, false, project.directory) + val artifact = (latestDep as AetherDependency).artifact + val rangeResult = resolver.resolveRange(artifact) + + if (rangeResult != null) { + val highest = rangeResult.highestVersion?.toString() + if (highest != null && highest != dep.id + && StringVersion(highest) > StringVersion(dep.version)) { + newVersions.add(artifact.groupId + ":" + artifact.artifactId + ":" + highest) } - } catch(e: KobaltException) { - log(1, " Cannot resolve ${compileDependency.shortId}. ignoring") } + } catch(e: KobaltException) { + kobaltLog(1, " Cannot resolve ${dep.shortId}. ignoring") } } } } if (newVersions.size > 0) { - log(1, "New versions found:") - newVersions.forEach { log(1, " $it") } + kobaltLog(1, " New versions found:") + newVersions.forEach { kobaltLog(1, " $it") } } else { - log(1, "All dependencies up to date") + kobaltLog(1, " All dependencies up to date") } executor.shutdown() } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/CountingFileRequestBody.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/CountingFileRequestBody.kt index fd90564c..ca64d3d6 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/CountingFileRequestBody.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/CountingFileRequestBody.kt @@ -1,7 +1,7 @@ package com.beust.kobalt.misc -import com.squareup.okhttp.MediaType -import com.squareup.okhttp.RequestBody +import okhttp3.MediaType +import okhttp3.RequestBody import okio.BufferedSink import okio.Okio import java.io.File @@ -19,15 +19,17 @@ class CountingFileRequestBody(val file: File, val contentType: String, override fun contentType() = MediaType.parse(contentType) override fun writeTo(sink: BufferedSink) { - Okio.source(file).use { source -> - var total = 0L - var read: Long = source.read(sink.buffer(), SEGMENT_SIZE) + file.inputStream().use { fis -> + Okio.source(fis).use { source -> + var total = 0L + var read: Long = source.read(sink.buffer(), SEGMENT_SIZE) - while (read != -1L) { - total += read - sink.flush(); - listenerCallback(total) - read = source.read(sink.buffer(), SEGMENT_SIZE) + while (read != -1L) { + total += read + sink.flush(); + listenerCallback(total) + read = source.read(sink.buffer(), SEGMENT_SIZE) + } } } } @@ -52,7 +54,7 @@ class CountingFileRequestBody(val file: File, val contentType: String, // // .post(requestBody) // .build(); // -// val response = OkHttpClient().newCall(request).execute() +// val response = OkHttpClient.Builder().proxy(Kobalt.proxyConfig.toProxy()).build().newCall(request).execute() // if (! response.isSuccessful) { // println("ERROR") // } else { diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/Git.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/Git.kt new file mode 100644 index 00000000..cf6b5885 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/Git.kt @@ -0,0 +1,52 @@ +package com.beust.kobalt.misc + +import com.beust.kobalt.TaskResult +import com.beust.kobalt.api.Project +import com.google.inject.Inject +import java.io.File + +class Git @Inject constructor() { + fun maybeTagRelease(project: Project, uploadResult: TaskResult, enabled: Boolean, annotated: Boolean, + push: Boolean, tag: String, message: String) : TaskResult { + val result = + if (uploadResult.success && enabled) { + val tagSuccess = tagRelease(project, annotated, push, tag, message) + if (! tagSuccess) { + TaskResult(false, errorMessage = "Couldn't tag the project") + } else { + TaskResult() + } + } else { + TaskResult() + } + return result + } + + private fun tagRelease(project: Project, annotated: Boolean, push: Boolean, tag: String, message: String) : Boolean { + val version = if (tag.isNullOrBlank()) project.version else tag + val success = try { + log(2, "Tagging this release as \"$version\"") + val repo = org.eclipse.jgit.storage.file.FileRepositoryBuilder() + .setGitDir(File(KFiles.joinDir(project.directory, ".git"))) + .readEnvironment() + .findGitDir() + .build() + val git = org.eclipse.jgit.api.Git(repo) + // jGit library will complain and not tag if setAnnotated(false) + var ref = if (annotated) { + git.tag().setAnnotated(annotated).setName(version).setMessage(message).call() + } else { + git.tag().setName(version).setMessage(message).call() + } + if (push) { + git.push().setPushTags().call() + } + true + } catch(ex: Exception) { + warn("Couldn't create tag ${version}: ${ex.message}", ex) + false + } + + return success + } +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/GithubApi.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/GithubApi.kt deleted file mode 100644 index c04583cc..00000000 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/GithubApi.kt +++ /dev/null @@ -1,148 +0,0 @@ -package com.beust.kobalt.misc - -import com.beust.kobalt.KobaltException -import com.beust.kobalt.internal.DocUrl -import com.beust.kobalt.maven.Http -import com.google.gson.Gson -import com.google.gson.annotations.SerializedName -import com.squareup.okhttp.Headers -import com.squareup.okhttp.OkHttpClient -import retrofit.RestAdapter -import retrofit.RetrofitError -import retrofit.client.OkClient -import retrofit.http.* -import retrofit.mime.TypedByteArray -import retrofit.mime.TypedFile -import rx.Observable -import java.io.File -import java.util.* -import java.util.concurrent.Callable -import java.util.concurrent.Future -import javax.inject.Inject - -/** - * Retrieve Kobalt's latest release version from github. - */ -public class GithubApi @Inject constructor(val executors: KobaltExecutors, - val localProperties: LocalProperties, val http: Http) { - companion object { - const val PROPERTY_ACCESS_TOKEN = "github.accessToken" - const val PROPERTY_USERNAME = "github.username" - } - - class RetrofitErrorResponse(val code: String?, val field: String?) - class RetrofitErrorsResponse(val message: String?, val errors: List) - - private val DOC_URL = DocUrl.PUBLISH_PLUGIN_URL - - private fun parseRetrofitError(e: Throwable) : RetrofitErrorsResponse { - val re = e as RetrofitError - val json = String((re.response.body as TypedByteArray).bytes) - return Gson().fromJson(json, RetrofitErrorsResponse::class.java) - } - - fun uploadRelease(packageName: String, tagName: String, zipFile: File) { - log(1, "Uploading release ${zipFile.name}") - - val username = localProperties.get(PROPERTY_USERNAME, DOC_URL) - val accessToken = localProperties.get(PROPERTY_ACCESS_TOKEN, DOC_URL) - try { - service.createRelease(username, accessToken, packageName, CreateRelease(tagName)) - .flatMap { response -> - uploadAsset(accessToken, response.uploadUrl!!, TypedFile("application/zip", zipFile), - tagName) - } - .toBlocking() - .forEach { action -> - log(1, "\n${zipFile.name} successfully uploaded") - } - } catch(e: RetrofitError) { - val error = parseRetrofitError(e) - throw KobaltException("Couldn't upload release, ${error.message}: " - + error.errors[0].code + " field: " + error.errors[0].field) - } - } - - private fun uploadAsset(token: String, uploadUrl: String, typedFile: TypedFile, tagName: String) - : Observable { - val strippedUrl = uploadUrl.substring(0, uploadUrl.indexOf("{")) - val fileName = typedFile.file().name - val url = "$strippedUrl?name=$fileName&label=$fileName" - val headers = Headers.of("Authorization", "token $token") - val totalSize = typedFile.file().length() - http.uploadFile(url = url, file = typedFile, headers = headers, post = true, // Github requires POST - progressCallback = http.percentProgressCallback(totalSize)) - - return Observable.just(UploadAssetResponse(tagName, tagName)) - } - - // - // Read only Api - // - - private val service = RestAdapter.Builder() -// .setLogLevel(RestAdapter.LogLevel.FULL) - .setClient(OkClient(OkHttpClient())) - .setEndpoint("https://api.github.com") - .build() - .create(Api::class.java) - - // - // JSON mapped classes that get sent up and down - // - class CreateRelease(@SerializedName("tag_name") var tagName: String? = null, - var name: String? = tagName) - class CreateReleaseResponse(var id: String? = null, @SerializedName("upload_url") var uploadUrl: String?) - class UploadAssetResponse(var id: String? = null, val name: String? = null) - class ReleasesResponse(@SerializedName("tag_name") var tagName: String? = null, - var name: String? = tagName) - - interface Api { - @POST("/repos/{owner}/{repo}/releases") - fun createRelease(@Path("owner") owner: String, - @Query("access_token") accessToken: String, - @Path("repo") repo: String, - @Body createRelease: CreateRelease): Observable - - @GET("/repos/{owner}/{repo}/releases") - fun getReleases(@Path("owner") owner: String, - @Query("access_token") accessToken: String, - @Path("repo") repo: String): List - - @GET("/repos/{owner}/{repo}/releases") - fun getReleasesNoAuth(@Path("owner") owner: String, - @Path("repo") repo: String): List - } - - val latestKobaltVersion: Future - get() { - val callable = Callable { - var result = "0" - - val username = localProperties.getNoThrows(PROPERTY_USERNAME, DOC_URL) - val accessToken = localProperties.getNoThrows(PROPERTY_ACCESS_TOKEN, DOC_URL) - try { - val releases = - if (username != null && accessToken != null) { - service.getReleases(username, accessToken, "kobalt") - } else { - service.getReleasesNoAuth("cbeust", "kobalt") - } - releases.firstOrNull()?.let { - try { - result = listOf(it.name, it.tagName).filterNotNull().first { !it.isBlank() } - } catch(ex: NoSuchElementException) { - throw KobaltException("Couldn't find the latest release") - } - } - } catch(e: RetrofitError) { - val error = parseRetrofitError(e) - throw KobaltException("Couldn't retrieve releases, ${error.message}: " - + error.errors[0].code + " field: " + error.errors[0].field) - } - result - } - - return executors.miscExecutor.submit(callable) - } -} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/GithubApi2.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/GithubApi2.kt new file mode 100644 index 00000000..b33286e0 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/GithubApi2.kt @@ -0,0 +1,171 @@ +package com.beust.kobalt.misc + +import com.beust.kobalt.Args +import com.beust.kobalt.KobaltException +import com.beust.kobalt.api.Kobalt +import com.beust.kobalt.internal.DocUrl +import com.beust.kobalt.internal.KobaltSettings +import com.beust.kobalt.internal.build.VersionCheckTimestampFile +import com.beust.kobalt.maven.Http +import com.beust.kobalt.maven.aether.Exceptions +import com.google.gson.Gson +import com.google.gson.JsonParser +import com.google.gson.annotations.SerializedName +import com.google.inject.Inject +import okhttp3.OkHttpClient +import retrofit2.Call +import retrofit2.Retrofit +import retrofit2.converter.gson.GsonConverterFactory +import retrofit2.http.* +import rx.Observable +import java.io.File +import java.time.Duration +import java.time.Instant +import java.util.* +import java.util.concurrent.Callable +import java.util.concurrent.Future + +class GithubApi2 @Inject constructor( + val executors: KobaltExecutors, val localProperties: LocalProperties, val http: Http, + val settings:KobaltSettings, val args: Args) { + + companion object { + const val PROPERTY_ACCESS_TOKEN = "github.accessToken" + const val PROPERTY_USERNAME = "github.username" + } + + private val DOC_URL = DocUrl.PUBLISH_PLUGIN_URL + + // + // JSON mapped classes that get sent up and down + // + class CreateRelease(@SerializedName("tag_name") var tagName: String? = null, + var name: String? = tagName) + class CreateReleaseResponse(var id: String? = null, @SerializedName("upload_url") var uploadUrl: String?) + class UploadAssetResponse(var id: String? = null, val name: String? = null) + class ReleasesResponse(@SerializedName("tag_name") var tagName: String? = null, + var name: String? = tagName) + + interface Api { + @POST("/repos/{owner}/{repo}/releases") + fun createRelease(@Path("owner") owner: String, + @Path("repo") repo: String, + @Query("access_token") accessToken: String, + @Body createRelease: CreateRelease): Call + + @GET("/repos/{owner}/{repo}/releases") + fun getReleases(@Path("owner") owner: String, + @Path("repo") repo: String, + @Query("access_token") accessToken: String): Call> + + @GET("/repos/{owner}/{repo}/releases") + fun getReleasesNoAuth(@Path("owner") owner: String, + @Path("repo") repo: String): Call> + } + + // + // Read only Api + // + private val service = Retrofit.Builder() + .client(OkHttpClient.Builder().proxy(settings.proxyConfigs?.firstOrNull()?.toProxy()).build()) + .baseUrl("https://api.github.com") + .addConverterFactory(GsonConverterFactory.create()) + .build() + .create(Api::class.java) + + // JSON Retrofit error + class Error(val code: String) + class RetrofitError(var message: String = "", var errors : List = arrayListOf()) + + fun uploadRelease(packageName: String, tagName: String, zipFile: File) { + kobaltLog(1, "Uploading release ${zipFile.name}") + + val username = localProperties.get(PROPERTY_USERNAME, DOC_URL) + val accessToken = localProperties.get(PROPERTY_ACCESS_TOKEN, DOC_URL) + val response = service.createRelease(username, packageName, accessToken, CreateRelease(tagName)) + .execute() + val code = response.code() + if (code != Http.CREATED) { + val error = Gson().fromJson(response.errorBody()?.string(), RetrofitError::class.java) + throw KobaltException("Couldn't upload release, ${error.message}: " + error.errors[0].code) + } else { + val body = response.body() + + uploadAsset(accessToken, body?.uploadUrl!!, Http.TypedFile("application/zip", zipFile), tagName) + .toBlocking() + .forEach { action -> + kobaltLog(1, "\n${zipFile.name} successfully uploaded") + } + } + } + + private fun uploadAsset(token: String, uploadUrl: String, typedFile: Http.TypedFile, tagName: String) + : Observable { + val strippedUrl = uploadUrl.substring(0, uploadUrl.indexOf("{")) + val fileName = typedFile.file.name + val url = "$strippedUrl?name=$fileName&label=$fileName" + val headers = okhttp3.Headers.of("Authorization", "token $token") + val totalSize = typedFile.file.length() + http.uploadFile(url = url, file = typedFile, headers = headers, post = true, // Github requires POST + progressCallback = http.percentProgressCallback(totalSize)) + + return Observable.just(UploadAssetResponse(tagName, tagName)) + } + + val latestKobaltVersion: Future + get() { + val callable = Callable { + var result = Kobalt.version + if (! args.dev && Duration.ofMinutes(10L) > + Duration.between(VersionCheckTimestampFile.timestamp, Instant.now())) { + kobaltLog(2, "Skipping GitHub latest release check, too soon.") + } else { + val username = localProperties.getNoThrows(PROPERTY_USERNAME) + val accessToken = localProperties.getNoThrows(PROPERTY_ACCESS_TOKEN) + try { + val req = + if (username != null && accessToken != null) { + service.getReleases(username, "kobalt", accessToken) + } else { + service.getReleasesNoAuth("cbeust", "kobalt") + } + val ex = req.execute() + val errorBody = ex.errorBody() + if (errorBody != null) { + val jsonError = JsonParser().parse(errorBody.string()) + warn("Couldn't call Github.getReleases(): $jsonError") + } else { + val releases = ex.body() + if (releases != null) { + releases.firstOrNull()?.let { + result = try { + listOf(it.name, it.tagName).filterNotNull().first { !it.isBlank() } + } catch(ex: NoSuchElementException) { + throw KobaltException("Couldn't find the latest release") + } + } + } else { + warn("Didn't receive any body in the response to GitHub.getReleases()") + } + } + } catch(e: Exception) { + kobaltLog(1, "Couldn't retrieve releases from github: " + e.message) + Exceptions.printStackTrace(e) +// val error = parseRetrofitError(e) +// val details = if (error.errors != null) { +// error.errors[0] +// } else { +// null +// } +// // TODO: If the credentials didn't work ("bad credentials"), should start again +// // using cbeust/kobalt, like above. Right now, just bailing. +// kobaltLog(2, "Couldn't retrieve releases from github, ${error.message ?: e}: " +// + details?.code + " field: " + details?.field) + } + } + result + } + + return executors.miscExecutor.submit(callable) + } +} \ No newline at end of file diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/Io.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/Io.kt new file mode 100644 index 00000000..8d2b0580 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/Io.kt @@ -0,0 +1,84 @@ +package com.beust.kobalt.misc + +import java.io.File +import java.nio.file.* + +class Io(val dryRun: Boolean = false) { + fun mkdirs(dir: String) { + kobaltLog("mkdirs $dir") + if (! dryRun) { + File(dir).mkdirs() + } + } + + fun rm(path: String) { + kobaltLog("rm $path") + + if (! dryRun) { + File(path).deleteRecursively() + } + } + + fun moveFile(from: File, toDir: File) { + kobaltLog("mv $from $toDir") + if (! dryRun) { + require(from.exists(), { -> "$from should exist" }) + require(from.isFile, { -> "$from should be a file" }) + require(toDir.isDirectory, { -> "$toDir should be a file"}) + + val toFile = File(toDir, from.name) + Files.move(Paths.get(from.absolutePath), Paths.get(toFile.absolutePath), StandardCopyOption.ATOMIC_MOVE) + } + } + + fun rename(from: File, to: File) { + kobaltLog("rename $from $to") + moveFile(from, to.parentFile) + if (from.name != to.name) { + File(to, from.name).renameTo(to) + } + } + + fun copyDirectory(from: File, toDir: File) { + kobaltLog("cp -r $from $toDir") + + if (! dryRun) { + KFiles.copyRecursively(from, toDir) + require(from.exists(), { -> "$from should exist" }) + require(from.isDirectory, { -> kobaltLog(1, "$from should be a directory")}) + require(toDir.isDirectory, { -> kobaltLog(1, "$toDir should be a file")}) + + } + } + + fun rmDir(dir: File, keep: (File) -> Boolean = { t -> false }) = rmDir(dir, keep, " ") + + private fun rmDir(dir: File, keep: (File) -> Boolean, indent : String) { + kobaltLog("rm -rf $dir") + + require(dir.isDirectory, { -> kobaltLog(1, "$dir should be a directory")}) + + dir.listFiles({ p0 -> ! keep(p0!!) }).forEach { + if (it.isDirectory) { + rmDir(it, keep, indent + " ") + it.deleteRecursively() + } + else { + kobaltLog(indent + "rm $it") + if (! dryRun) it.delete() + } + } + } + + fun mkdir(dir: File) { + kobaltLog("mkdir $dir") + if (! dryRun) { + dir.mkdirs() + } + } + + private fun kobaltLog(s: String) { + kobaltLog(1, "[Io] $s") + } + +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/JarUtils.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/JarUtils.kt index ffca6332..ba83b0a6 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/JarUtils.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/JarUtils.kt @@ -1,17 +1,18 @@ package com.beust.kobalt.misc +import com.beust.kobalt.From import com.beust.kobalt.IFileSpec +import com.beust.kobalt.IncludedFile +import com.beust.kobalt.To +import com.beust.kobalt.archive.MetaArchive import com.google.common.io.CharStreams -import java.io.* -import java.util.jar.JarEntry +import java.io.File +import java.io.FileOutputStream +import java.io.InputStreamReader import java.util.jar.JarFile -import java.util.jar.JarInputStream -import java.util.zip.ZipEntry -import java.util.zip.ZipException import java.util.zip.ZipFile -import java.util.zip.ZipOutputStream -public class JarUtils { +class JarUtils { companion object { val DEFAULT_HANDLER: (Exception) -> Unit = { ex: Exception -> // Ignore duplicate entry exceptions @@ -20,97 +21,57 @@ public class JarUtils { } } - public fun addFiles(directory: String, files: List, target: ZipOutputStream, + fun addFiles(directory: String, files: List, metaArchive: MetaArchive, expandJarFiles: Boolean, onError: (Exception) -> Unit = DEFAULT_HANDLER) { files.forEach { - addSingleFile(directory, it, target, expandJarFiles, onError) + addSingleFile(directory, it, metaArchive, expandJarFiles, onError) } } - private val DEFAULT_JAR_EXCLUDES = arrayListOf( - IFileSpec.Glob("META-INF/*.SF"), - IFileSpec.Glob("META-INF/*.DSA"), - IFileSpec.Glob("META-INF/*.RSA")) - - public fun addSingleFile(directory: String, file: IncludedFile, outputStream: ZipOutputStream, + fun addSingleFile(directory: String, file: IncludedFile, metaArchive: MetaArchive, expandJarFiles: Boolean, onError: (Exception) -> Unit = DEFAULT_HANDLER) { - val allFiles = file.allFromFiles(directory) - allFiles.forEach { relSource -> - val source = - if (relSource.isAbsolute) relSource - else File(KFiles.joinDir(directory, file.from, relSource.path)) - if (source.isDirectory) { - log(2, "Writing contents of directory $source") + val foundFiles = file.allFromFiles(directory) + foundFiles.forEach { foundFile -> + + // Turn the found file into the local physical file that will be put in the jar file + val fromFile = file.from(foundFile.path) + val localFile = if (fromFile.isAbsolute) fromFile + else File(directory, fromFile.path) + + if (!localFile.exists()) { + throw AssertionError("File should exist: $localFile") + } + + if (foundFile.isDirectory) { + kobaltLog(2, " Writing contents of directory $foundFile") // Directory - var name = source.name - if (!name.isEmpty()) { - if (!name.endsWith("/")) name += "/" - val entry = JarEntry(name) - entry.time = source.lastModified() - try { - outputStream.putNextEntry(entry) - } catch(ex: ZipException) { - log(2, "Can't add $name: ${ex.message}") - } finally { - outputStream.closeEntry() - } - } - val includedFile = IncludedFile(From(source.path), To(""), listOf(IFileSpec.Glob("**"))) - addSingleFile(".", includedFile, outputStream, expandJarFiles) + val includedFile = IncludedFile(From(""), To(""), listOf(IFileSpec.GlobSpec("**"))) + addSingleFile(localFile.path, includedFile, metaArchive, expandJarFiles) } else { - if (expandJarFiles and source.name.endsWith(".jar")) { - log(2, "Writing contents of jar file $source") - val stream = JarInputStream(FileInputStream(source)) - var entry = stream.nextEntry - while (entry != null) { - if (!entry.isDirectory && !KFiles.isExcluded(entry.name, DEFAULT_JAR_EXCLUDES)) { - val ins = JarFile(source).getInputStream(entry) - addEntry(ins, JarEntry(entry), outputStream, onError) - } - entry = stream.nextEntry + try { + if (file.expandJarFiles && foundFile.name.endsWith(".jar") && !file.from.contains("resources")) { + kobaltLog(2, " Writing contents of jar file $foundFile") + metaArchive.addArchive(foundFile) + } else { + val toPath = File(file.to).normalize().path + val finalPath = if (toPath.isEmpty()) null else (toPath + "/") + metaArchive.addFile(File(directory, fromFile.path), foundFile, finalPath) } - } else { - val entry = JarEntry(file.to + relSource.path.replace("\\", "/")) - entry.time = source.lastModified() - val entryFile = source - if (!entryFile.exists()) { - throw AssertionError("File should exist: $entryFile") - } - addEntry(FileInputStream(entryFile), entry, outputStream, onError) + } catch(ex: Exception) { + onError(ex) } } } } - private fun addEntry(inputStream: InputStream, entry: ZipEntry, outputStream: ZipOutputStream, - onError: (Exception) -> Unit = DEFAULT_HANDLER) { - var bis: BufferedInputStream? = null - try { - outputStream.putNextEntry(entry) - bis = BufferedInputStream(inputStream) - - val buffer = ByteArray(50 * 1024) - while (true) { - val count = bis.read(buffer) - if (count == -1) break - outputStream.write(buffer, 0, count) - } - outputStream.closeEntry() - } catch(ex: Exception) { - onError(ex) - } finally { - bis?.close() - } - } - fun extractTextFile(zip : ZipFile, fileName: String) : String? { val enumEntries = zip.entries() while (enumEntries.hasMoreElements()) { val file = enumEntries.nextElement() if (file.name == fileName) { - log(2, "Found $fileName in ${zip.name}") + kobaltLog(2, "Found $fileName in ${zip.name}") zip.getInputStream(file).use { ins -> return CharStreams.toString(InputStreamReader(ins, "UTF-8")) } @@ -119,9 +80,10 @@ public class JarUtils { return null } - fun extractJarFile(jarFile: File, destDir: File) { - val jar = JarFile(jarFile) - val enumEntries = jar.entries() + fun extractJarFile(file: File, destDir: File) = extractZipFile(JarFile(file), destDir) + + fun extractZipFile(zipFile: ZipFile, destDir: File) { + val enumEntries = zipFile.entries() while (enumEntries.hasMoreElements()) { val file = enumEntries.nextElement() val f = File(destDir.path + File.separator + file.name) @@ -130,7 +92,7 @@ public class JarUtils { continue } - jar.getInputStream(file).use { ins -> + zipFile.getInputStream(file).use { ins -> f.parentFile.mkdirs() FileOutputStream(f).use { fos -> while (ins.available() > 0) { @@ -143,32 +105,3 @@ public class JarUtils { } } -open class Direction(open val p: String) { - override public fun toString() = path - public val path: String get() = if (p.isEmpty() or p.endsWith("/")) p else p + "/" -} - -class IncludedFile(val fromOriginal: From, val toOriginal: To, val specs: List) { - constructor(specs: List) : this(From(""), To(""), specs) - public val from: String get() = fromOriginal.path.replace("\\", "/") - public val to: String get() = toOriginal.path.replace("\\", "/") - override public fun toString() = toString("IncludedFile", - "files", specs.map { it.toString() }.joinToString(", "), - "from", from, - "to", to) - - fun allFromFiles(directory: String): List { - val result = arrayListOf() - specs.forEach { spec -> - val fullDir = KFiles.joinDir(directory, from) - spec.toFiles(fullDir).forEach { source -> - result.add(if (source.isAbsolute) source else File(source.path)) - } - } - return result - } -} - -class From(override val p: String) : Direction(p) - -class To(override val p: String) : Direction(p) diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/KFiles.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/KFiles.kt index 76558e90..fcf5b86a 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/KFiles.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/KFiles.kt @@ -3,39 +3,68 @@ package com.beust.kobalt.misc import com.beust.kobalt.* import com.beust.kobalt.api.Kobalt import com.beust.kobalt.api.Project -import com.beust.kobalt.internal.build.BuildFile import com.beust.kobalt.maven.Md5 -import java.io.File -import java.io.IOException -import java.nio.file.* -import kotlin.io.FileAlreadyExistsException -import kotlin.io.FileSystemException -import kotlin.io.NoSuchFileException +import org.apache.commons.io.FileUtils +import java.io.* +import java.nio.file.Files +import java.nio.file.Path +import java.nio.file.Paths +import java.nio.file.StandardCopyOption +import java.util.* +import java.util.jar.JarInputStream +import java.util.regex.Pattern + class KFiles { /** * This actually returns a list of strings because in development mode, we are not pointing to a single - * jar file but to a set of /classes directories. + * jar file but to a set of classes/directories. */ val kobaltJar : List get() { + val PATTERN = Pattern.compile("kobalt-([-.0-9]+)") + + fun latestInstalledVersion() : StringVersion { + val versions = File(distributionsDir).listFiles().map { it.name }.map { + val matcher = PATTERN.matcher(it) + val result = + if (matcher.matches()) matcher.group(1) + else null + result + }.filterNotNull().map(::StringVersion) + Collections.sort(versions, reverseOrder()) + return versions[0] + } + val envJar = System.getenv("KOBALT_JAR") if (envJar != null) { debug("Using kobalt jar $envJar") return listOf(File(envJar).absolutePath) } else { - val jar = joinDir(distributionsDir, Kobalt.version, "kobalt/wrapper/kobalt-" + Kobalt.version + ".jar") + val jar = joinDir(distributionsDir, "kobalt-" + Kobalt.version, + "kobalt/wrapper/kobalt-" + Kobalt.version + ".jar") val jarFile = File(jar) if (jarFile.exists()) { return listOf(jarFile.absolutePath) } else { - // Will only happen when building kobalt itself: the jar file might not be in the dist/ directory - // yet since we're currently building it. Instead, use the classes directly - val result = listOf("kobalt", "kobalt-plugin-api", "kobalt-wrapper").map { - File(homeDir(KFiles.joinDir("kotlin", "kobalt", "out", "production", it))).absolutePath - } + // In development mode, keep your kobalt.properties version to a nonexistent version + // kobalt.properties: kobalt.version=0.828 + // kobalt-wrapper.properties: kobalt.version=0.827 + // When Kobalt can't find the newest jar file, it will instead use the classes produced by IDEA + // in the directories specified here: + val previousVersion = latestInstalledVersion().version + val previousJar = joinDir(distributionsDir, "kobalt-" + previousVersion, + "kobalt/wrapper/kobalt-$previousVersion.jar") + latestInstalledVersion() + val result = listOf("", "modules/kobalt-plugin-api", "modules/wrapper").map { + File(homeDir(KFiles.joinDir("kotlin", "kobalt", it, "kobaltBuild", "classes"))) //kobalt build dirs + .absolutePath + } + listOf("modules/kobalt", "modules/kobalt-plugin-api", "modules/wrapper").map { + File(homeDir(KFiles.joinDir("kotlin", "kobalt", it, "target", "classes"))) //maven build dirs + .absolutePath + } + listOf(previousJar) debug("Couldn't find ${jarFile.absolutePath}, using\n " + result.joinToString(" ")) - return result + return result.filter { File(it).exists() } } } } @@ -45,12 +74,10 @@ class KFiles { } companion object { - private const val KOBALT_DOT_DIR : String = ".kobalt" - const val KOBALT_DIR : String = "kobalt" - const val KOBALT_BUILD_DIR = "kobaltBuild" - - // Directories under ~/.kobalt - val localRepo = homeDir(KOBALT_DOT_DIR, "repository") + const val KOBALT_DOT_DIR : String = ".kobalt" + val KOBALT_DIR : String = "kobalt" + val HOME_KOBALT_DIR = makeDir(homeDir(".config", KOBALT_DIR)) + val KOBALT_BUILD_DIR = "kobaltBuild" /** Where all the .zip files are extracted */ val distributionsDir = homeDir(KOBALT_DOT_DIR, "wrapper", "dist") @@ -64,8 +91,9 @@ class KFiles { val TEST_CLASSES_DIR : String = "test-classes" - private fun generatedDir(project: Project, variant: Variant) - = KFiles.joinDir(project.directory, project.buildDirectory, "generated", variant.toIntermediateDir()) + val NATIVES_DIR : String = "native" + + fun nativeBuildDir(project: Project) = KFiles.joinDir(project.directory, project.buildDirectory, NATIVES_DIR) fun generatedSourceDir(project: Project, variant: Variant, name: String) = KFiles.joinDir(project.directory, project.buildDirectory, "generated", "source", name, @@ -81,7 +109,14 @@ class KFiles { /** * Join the paths elements with the file separator. */ - fun joinDir(vararg ts: String): String = ts.toArrayList().joinToString(File.separator) + fun joinDir(vararg ts: String): String = ts.toMutableList().joinToString(File.separator) + + val LIBS_DIR = "libs" + + /** + * Where assemblies get generated ("kobaltBuild/libs") + */ + fun libsDir(project: Project): String = KFiles.makeDir(KFiles.buildDir(project).path, LIBS_DIR).path /** * The paths elements are expected to be a directory. Make that directory and join the @@ -101,15 +136,18 @@ class KFiles { */ fun joinFileAndMakeDir(vararg ts: String) = joinDir(joinAndMakeDir(ts.slice(0..ts.size - 2)), ts[ts.size - 1]) + fun fixSlashes(f: File) = f.normalize().path.replace('\\', '/') + fun fixSlashes(s: String) = s.replace('\\', '/') + fun makeDir(dir: String, s: String? = null) = (if (s != null) File(dir, s) else File(dir)).apply { mkdirs() } fun findRecursively(rootDir: File) : List = - findRecursively(rootDir, arrayListOf(), { s -> true }) + findRecursively(rootDir, arrayListOf(), { _ -> true }) fun findRecursively(rootDir: File, directories: List, function: Function1): List { - var result = arrayListOf() + val result = arrayListOf() val allDirs = arrayListOf() if (directories.isEmpty()) { @@ -121,7 +159,9 @@ class KFiles { val seen = hashSetOf() allDirs.forEach { dir -> if (! dir.exists()) { - log(2, "Couldn't find directory $dir") + kobaltLog(2, "Couldn't find directory $dir") + } else if (! dir.isDirectory) { + throw IllegalArgumentException("$dir is not a directory") } else { val files = findRecursively(dir, function) files.map { Paths.get(it) }.forEach { @@ -130,7 +170,7 @@ class KFiles { result.add(File(dir, rel.toFile().path).path) seen.add(rel) } else { - log(2, "Skipped file already seen in previous flavor: $rel") + kobaltLog(2, "Skipped file already seen in previous flavor: $rel") } } } @@ -141,7 +181,7 @@ class KFiles { } fun findRecursively(directory: File, function: Function1): List { - var result = arrayListOf() + val result = arrayListOf() directory.listFiles().forEach { if (it.isFile && function(it.path)) { result.add(it.path) @@ -152,121 +192,94 @@ class KFiles { return result } - fun copyRecursively(from: File, to: File, replaceExisting: Boolean = true, deleteFirst: Boolean = false, - onError: (File, IOException) -> OnErrorAction = { file, exception -> throw exception }) { - // Need to wait until copyRecursively supports an overwrite: Boolean = false parameter - // Until then, wipe everything first - if (deleteFirst) to.deleteRecursively() -// to.mkdirs() - hackCopyRecursively(from, to, replaceExisting = replaceExisting, onError = onError) - } - - /** Private exception class, used to terminate recursive copying */ - private class TerminateException(file: File) : FileSystemException(file) {} - /** - * Copy/pasted from kotlin/io/Utils.kt to add support for overwriting. + * List the files contained in a directory or a jar file. */ - private fun hackCopyRecursively(from: File, dst: File, - replaceExisting: Boolean, - checkTimestamp: Boolean = false, - onError: (File, IOException) -> OnErrorAction = - { file, exception -> throw exception } - ): Boolean { - if (!from.exists()) { - return onError(from, NoSuchFileException(file = from, reason = "The source file doesn't exist")) != - OnErrorAction.TERMINATE - } - try { - // We cannot break for loop from inside a lambda, so we have to use an exception here - for (src in from.walkTopDown().fail { f, e -> if (onError(f, e) == OnErrorAction.TERMINATE) throw TerminateException(f) }) { - if (!src.exists()) { - if (onError(src, NoSuchFileException(file = src, reason = "The source file doesn't exist")) == - OnErrorAction.TERMINATE) - return false - } else { - val relPath = src.relativeTo(from) - val dstFile = File(dst, relPath) - if (dstFile.exists() && !replaceExisting && !(src.isDirectory && dstFile.isDirectory)) { - if (onError(dstFile, FileAlreadyExistsException(file = src, - other = dstFile, - reason = "The destination file already exists")) == OnErrorAction.TERMINATE) - return false - } else if (src.isDirectory) { - dstFile.mkdirs() - } else { - if (Features.USE_TIMESTAMPS && dstFile.exists() && Md5.toMd5(src) == Md5.toMd5(dstFile)) { - log(2, " Identical files, not copying $src to $dstFile") - } else { - if (src.copyTo(dstFile, true) != src.length()) { - if (onError(src, - IOException("src.length() != dst.length()")) == OnErrorAction.TERMINATE) - return false - } - } + fun listFiles(file: File, block: (String) -> Unit) { + if (file.isDirectory) { + KFiles.findRecursively(file).forEach { + block(it) + } + } else if (file.name.endsWith(".jar")) { + FileInputStream(file).use { + JarInputStream(it).use { stream -> + var entry = stream.nextJarEntry + while (entry != null) { + block(entry.name) + entry = stream.nextJarEntry; } } } - return true - } catch (e: TerminateException) { - return false - } - } - fun findDotDir(startDir: File) : File { - var result = startDir - while (result != null && ! File(result, KOBALT_DOT_DIR).exists()) { - result = result.parentFile + } else { + throw KobaltException("Can't list files of a file: " + file) } - if (result == null) { - throw IllegalArgumentException("Couldn't locate $KOBALT_DOT_DIR in $startDir") - } - return File(result, KOBALT_DOT_DIR) } /** * The build location for build scripts is .kobalt/build */ - fun findBuildScriptLocation(buildFile: BuildFile, jarFile: String) : String { - val result = joinDir(findDotDir(buildFile.directory).absolutePath, KFiles.SCRIPT_BUILD_DIR, jarFile) - log(2, "Script jar file: $result") + fun findBuildScriptDir(parent: String = ".") : File { + val result = File(joinAndMakeDir(parent, KFiles.dotKobaltDir.path, KFiles.SCRIPT_BUILD_DIR)) + kobaltLog(2, " Script jar files in: $result") return result } fun saveFile(file: File, text: String) { - file.absoluteFile.parentFile.mkdirs() - file.writeText(text) - log(2, "Wrote $file") - } - - private fun isWindows() = System.getProperty("os.name").contains("Windows"); - - fun copy(from: Path?, to: Path?, option: StandardCopyOption = StandardCopyOption.REPLACE_EXISTING) { - if (isWindows() && to!!.toFile().exists()) { - log(2, "Windows detected, not overwriting $to") - } else { - try { - if (from != null && to != null) { - if (!Files.exists(to) || Md5.toMd5(from.toFile()) != Md5.toMd5(to.toFile())) { - log(2, "Copy from $from to ${to}") - Files.copy(from, to, option) - } else { - log(2, " Not copying, indentical files: $from $to") - } + var canCreate = true + with(file.absoluteFile.parentFile) { + if (!exists()) { + val success = mkdirs() + if (!success) { + warn("Couldn't create directory to save $file") + canCreate = false } - } catch(ex: IOException) { - // Windows is anal about this - log(1, "Couldn't copy $from to $to: ${ex.message}") } } + if (canCreate) { + file.writeText(text) + kobaltLog(2, "Created $file") + } } - fun createTempFile(suffix : String = "", deleteOnExit: Boolean = false) : File = - File.createTempFile("kobalt", suffix, File(SystemProperties.tmpDir)).let { + private fun isWindows() = System.getProperty("os.name").contains("Windows") + + fun copy(from: Path?, to: Path?, option: StandardCopyOption = StandardCopyOption.REPLACE_EXISTING) { + try { + if (from != null && to != null) { + if (!Files.exists(to) || Md5.toMd5(from.toFile()) != Md5.toMd5(to.toFile())) { + kobaltLog(3, "Copy from $from to $to") + Files.copy(from, to, option) + } else { + kobaltLog(3, " Not copying, indentical files: $from $to") + } + } + } catch(ex: IOException) { + // Windows is anal about this + kobaltLog(1, "Couldn't copy $from to $to: ${ex.message}") + } + } + + fun copy(from: InputStream, to: OutputStream) { + var read = from.read() + while (read != -1) { + to.write(read) + read = from.read() + } + } + + fun createTempBuildFileInTempDirectory(deleteOnExit: Boolean = false) : File = + File(createTempDirectory("kobalt", deleteOnExit), Constants.BUILD_FILE_NAME).let { if (deleteOnExit) it.deleteOnExit() return it } + fun createTempDirectory(prefix : String = "kobalt", deleteOnExit: Boolean = false) : File = + Files.createTempDirectory(prefix).let { + if (deleteOnExit) it.toFile().deleteOnExit() + return it.toFile() + } + fun src(filePath: String): String = KFiles.joinDir(KOBALT_DIR, SRC, filePath) fun makeDir(project: Project, suffix: String) : File { @@ -277,24 +290,84 @@ class KFiles { fun makeOutputTestDir(project: Project) : File = makeDir(project, KFiles.TEST_CLASSES_DIR) - fun isExcluded(file: File, excludes: List) = isExcluded(file.path, excludes) + fun isExcluded(file: String, excludes: Glob) = isExcluded(file, listOf(excludes)) - fun isExcluded(file: String, excludes: List) : Boolean { - if (excludes.isEmpty()) { - return false - } else { - val ex = arrayListOf() - excludes.forEach { - ex.add(FileSystems.getDefault().getPathMatcher("glob:${it.spec}")) - } - ex.forEach { - if (it.matches(Paths.get(file))) { - log(3, "Excluding $file") - return true - } + fun isExcluded(file: File, excludes: List) = isExcluded(file.path, excludes) + + fun isExcluded(file: String, excludes: List): Boolean = excludes.any { it.matches(file) } + + /** + * TODO: cache these per project so we don't do it more than once. + */ + fun findSourceFiles(projectDirectory: String, sourceDirectories: Collection, + suffixes: List) : Set { + val result = hashSetOf() + sourceDirectories.forEach { source -> + val sourceDir = File(KFiles.joinDir(projectDirectory, source)) + if (sourceDir.exists()) { + KFiles.findRecursively(sourceDir, { file -> + val ind = file.lastIndexOf(".") + if (ind >= 0) { + val suffix = file.substring(ind + 1) + if (suffixes.contains(suffix)) { + result.add(file) + } + } + false + }) + } else { + kobaltLog(3, "Skipping nonexistent source directory $sourceDir") } } - return false + return result + } + + fun isResource(name: String) = name.contains("res") || name.contains("resources") + + /** + * @return true as soon as a file meeting the condition is found. + */ + fun containsCertainFile(dir: File, condition: (File) -> Boolean) : Boolean { + if (dir.isDirectory) { + val directories = arrayListOf() + dir.listFiles().forEach { + if (condition(it)) return true + if (it.isDirectory) directories.add(it) + } + return directories.any { containsCertainFile(it, condition) } + } else { + return false + } + } + + val dotKobaltDir = File(KFiles.joinAndMakeDir(KFiles.KOBALT_DOT_DIR)) + + /** + * Turn the IncludedFiles into actual Files + */ + fun materializeIncludedFiles(project: Project, includedFiles: List) : List { + val result = includedFiles.fold(arrayListOf()) { files, includedFile: IncludedFile -> + val foundFiles = includedFile.allFromFiles(project.directory) + val absFiles = foundFiles.map { + if (it.isAbsolute) { + it + } else if (File(includedFile.from).isAbsolute) { + File(includedFile.from, it.path) + } else { + File(KFiles.joinDir(project.directory, includedFile.from, it.path)) + } + } + files.addAll(absFiles) + files + } + return result + } + + fun copyRecursively(from: File, to: File, replaceExisting: Boolean = true, deleteFirst: Boolean = false) { +// fun copy(relativePath: String, sourceDir: File, targetDir: File) = +// sourceDir.resolve(relativePath).copyRecursively(targetDir.resolve(relativePath), overwrite = true) + if (from.isFile) FileUtils.copyFileToDirectory(from, to) + else FileUtils.copyDirectory(from, to) } } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/KobaltExecutors.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/KobaltExecutors.kt index eb41ec5b..1dc9ab41 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/KobaltExecutors.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/KobaltExecutors.kt @@ -5,11 +5,10 @@ import java.util.concurrent.* class NamedThreadFactory(val n: String) : ThreadFactory { private val PREFIX = "K-" - public val name: String + val name: String get() = PREFIX + n - override - public fun newThread(r: Runnable) : Thread { + override fun newThread(r: Runnable) : Thread { val result = Thread(r) result.name = name + "-" + result.id return result @@ -20,7 +19,7 @@ class KobaltExecutor(name: String, threadCount: Int) : ThreadPoolExecutor(threadCount, threadCount, 5L, TimeUnit.SECONDS, LinkedBlockingQueue(), NamedThreadFactory(name)) { - override protected fun afterExecute(r: Runnable, t: Throwable?) { + override fun afterExecute(r: Runnable, t: Throwable?) { super.afterExecute(r, t) var ex : Throwable? = null if (t == null && r is Future<*>) { @@ -35,13 +34,13 @@ class KobaltExecutor(name: String, threadCount: Int) } } if (ex != null) { - error(ex.toString()) + error(ex.toString(), ex) } } } -public class KobaltExecutors { - public fun newExecutor(name: String, threadCount: Int) : ExecutorService +class KobaltExecutors { + fun newExecutor(name: String, threadCount: Int) : ExecutorService = KobaltExecutor(name, threadCount) val dependencyExecutor = newExecutor("Dependency", 5) @@ -67,14 +66,14 @@ public class KobaltExecutors { progress(r) result.add(r) remainingMs -= (System.currentTimeMillis() - start) - log(2, "Received $r, remaining: $remainingMs ms") + kobaltLog(3, "Received $r, remaining: $remainingMs ms") i++ } if (remainingMs < 0) { warn("Didn't receive all the results in time: $i / ${tasks.size}") } else { - log(2, "Received all results in ${maxMs - remainingMs} ms") + kobaltLog(2, "Received all results in ${maxMs - remainingMs} ms") } executor.shutdown() diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/KobaltLogger.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/KobaltLogger.kt index a8d5a17f..e2bd89de 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/KobaltLogger.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/KobaltLogger.kt @@ -1,84 +1,116 @@ package com.beust.kobalt.misc +import com.beust.kobalt.Args import com.beust.kobalt.AsciiArt +import com.beust.kobalt.Constants import com.beust.kobalt.KobaltException import com.beust.kobalt.api.Kobalt -import java.text.SimpleDateFormat -import java.util.* +import com.beust.kobalt.maven.aether.Exceptions +import java.lang.Exception +import java.time.LocalDateTime +import java.time.format.DateTimeFormatter -fun Any.log(level: Int, text: String, newLine : Boolean = true) { - if (level <= KobaltLogger.LOG_LEVEL) { +fun Any.log(level: Int, text: CharSequence, newLine : Boolean = true) { + if (level <= KobaltLogger.LOG_LEVEL && !KobaltLogger.isQuiet) { KobaltLogger.logger.log(javaClass.simpleName, text, newLine) } } -fun Any.logWrap(level: Int, text1: String, text2: String, function: () -> Unit) { - if (level <= KobaltLogger.LOG_LEVEL) { +fun Any.kobaltLog(level: Int, text: CharSequence, newLine : Boolean = true) = log(level, text, newLine) +fun Any.kobaltWarn(text: CharSequence) = warn(text) +fun Any.kobaltError(text: CharSequence) = error(text) +fun Any.kobaltLog(tag: String, text: CharSequence, newLine : Boolean = true) { + if (Kobalt.INJECTOR.getInstance(Args::class.java).logTags.split(',').contains(tag)) { + log(1, text, newLine) + } +} + +fun Any.logWrap(level: Int, text1: CharSequence, text2: CharSequence, function: () -> Unit) { + if (level <= KobaltLogger.LOG_LEVEL && !KobaltLogger.isQuiet) { KobaltLogger.logger.log(javaClass.simpleName, text1, newLine = false) } function() - if (level <= KobaltLogger.LOG_LEVEL) { + if (level <= KobaltLogger.LOG_LEVEL && !KobaltLogger.isQuiet) { KobaltLogger.logger.log(javaClass.simpleName, text2, newLine = true) } } -fun Any.debug(text: String) { +fun Any.debug(text: CharSequence) { KobaltLogger.logger.debug(javaClass.simpleName, text) } -fun Any.warn(text: String) { - KobaltLogger.logger.warn(javaClass.simpleName, text) +fun Any.warn(text: CharSequence, exception: Exception? = null) { + KobaltLogger.logger.warn(javaClass.simpleName, text, exception) } -fun Any.error(text: String, e: Throwable? = null) { +fun Any.kobaltError(text: CharSequence, e: Throwable? = null) = error(text, e) + +fun Any.error(text: CharSequence, e: Throwable? = null) { KobaltLogger.logger.error(javaClass.simpleName, text, e) } object KobaltLogger { - public var LOG_LEVEL: Int = 1 + var LOG_LEVEL: Int = 1 + + val isQuiet: Boolean get() = (LOG_LEVEL == Constants.LOG_QUIET_LEVEL) val logger: Logger get() = - if (Kobalt.context != null) { - Logger(Kobalt.context!!.args.dev) - } else { - Logger(false) + if (Kobalt.context != null) { + Logger(Kobalt.context!!.args.dev) + } else { + Logger(false) + } + + fun setLogLevel(args: Args) { + LOG_LEVEL = when { + args.log < Constants.LOG_QUIET_LEVEL -> Constants.LOG_DEFAULT_LEVEL + args.log > Constants.LOG_MAX_LEVEL -> Constants.LOG_MAX_LEVEL + else -> args.log + } } } class Logger(val dev: Boolean) { - val FORMAT = SimpleDateFormat("HH:mm:ss.SSS") + val FORMAT = DateTimeFormatter.ofPattern("HH:mm:ss.SSS") - private fun getPattern(shortTag: String, shortMessage: String, longMessage: String, tag: String) = + private fun getPattern(shortTag: String, shortMessage: CharSequence, longMessage: CharSequence, tag: String) = if (dev) { - val ts = FORMAT.format(Date()) + val ts = LocalDateTime.now().format(FORMAT) "$shortTag/$ts [" + Thread.currentThread().name + "] $tag - $shortMessage" } else { longMessage } - final fun debug(tag: String, message: String) = + fun debug(tag: String, message: CharSequence) = println(getPattern("D", message, message, tag)) - final fun error(tag: String, message: String, e: Throwable? = null) { + fun error(tag: String, message: CharSequence, e: Throwable? = null) { val docUrl = if (e is KobaltException && e.docUrl != null) e.docUrl else null - val text = if (! message.isBlank()) message + val text = + if (message.isNotBlank()) message else if (e != null && (! e.message.isNullOrBlank())) e.message - else { "" } + else { e?.toString() } val shortMessage = "***** E $text " + if (docUrl != null) " Documentation: $docUrl" else "" val longMessage = "*****\n***** ERROR $text\n*****" println(AsciiArt.errorColor(getPattern("E", shortMessage, longMessage, tag))) - if (KobaltLogger.LOG_LEVEL > 1) { - e?.printStackTrace() + if (KobaltLogger.LOG_LEVEL > 1 && e != null) { + Exceptions.printStackTrace(e) } } - final fun warn(tag: String, message: String, e: Throwable? = null) { - val fullMessage = "***** WARNING " + (e?.message ?: message) + fun warn(tag: String, message: CharSequence, e: Throwable? = null) { + val fullMessage = "***** WARNING " + + if (message.isNotBlank()) message + else if (e != null && (!e.message.isNullOrBlank())) e.message + else e?.toString() println(AsciiArt.Companion.warnColor(getPattern("W", fullMessage, fullMessage, tag))) + if (KobaltLogger.LOG_LEVEL > 1 && e != null) { + Exceptions.printStackTrace(e) + } } - final fun log(tag: String, message: String, newLine: Boolean) = + fun log(tag: String, message: CharSequence, newLine: Boolean) = with(getPattern("L", message, message, tag)) { if (newLine) println(this) else print("\r" + this) diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/KobaltWrapperProperties.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/KobaltWrapperProperties.kt index 8af0da44..a7b5177d 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/KobaltWrapperProperties.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/KobaltWrapperProperties.kt @@ -16,7 +16,7 @@ class KobaltWrapperProperties @Inject constructor() { private val PROPERTY_DOWNLOAD_URL = "kobalt.downloadUrl" fun create(version: String) { - log(2, "Creating $file with $version and ${defaultUrlFor(version)}") + kobaltLog(2, "Creating $file with $version and ${defaultUrlFor(version)}") KFiles.saveFile(file, listOf( "$PROPERTY_VERSION=$version" // "$PROPERTY_DOWNLOAD_URL=${defaultUrlFor(version)}" @@ -24,7 +24,7 @@ class KobaltWrapperProperties @Inject constructor() { } private fun defaultUrlFor(version: String) = - "http://beust.com/kobalt/kobalt-$version.zip" + "https://beust.com/kobalt/kobalt-$version.zip" private val file: File get() = File("$WRAPPER_DIR/$KOBALT_WRAPPER_PROPERTIES") diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/LocalProperties.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/LocalProperties.kt index 4fe16a5c..2cf0775e 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/LocalProperties.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/LocalProperties.kt @@ -6,6 +6,9 @@ import java.nio.file.Files import java.nio.file.Paths import java.util.* +/** + * Encapsulate read access to local.properties. + */ @Singleton class LocalProperties { val localProperties: Properties by lazy { @@ -22,11 +25,11 @@ class LocalProperties { result } - fun getNoThrows(name: String, docUrl: String? = null) = localProperties.getProperty(name) + fun getNoThrows(name: String): String? = localProperties.getProperty(name) fun get(name: String, docUrl: String? = null) : String { - val result = getNoThrows(name, docUrl) + val result = getNoThrows(name) ?: throw KobaltException("Couldn't find $name in local.properties", docUrl = docUrl) - return result as String + return result } } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/NewRunCommand.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/NewRunCommand.kt new file mode 100644 index 00000000..e105133b --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/NewRunCommand.kt @@ -0,0 +1,144 @@ +package com.beust.kobalt.misc + +import java.io.BufferedReader +import java.io.File +import java.io.InputStream +import java.io.InputStreamReader +import java.util.concurrent.TimeUnit + +class RunCommandInfo { + lateinit var command: String + var args : List = arrayListOf() + var directory : File = File("") + var env : Map = hashMapOf() + + /** + * Some commands fail but return 0, so the only way to find out if they failed is to look + * at the error stream. However, some commands succeed but output text on the error stream. + * This field is used to specify how errors are caught. + */ + var useErrorStreamAsErrorIndicator : Boolean = true + var useInputStreamAsErrorIndicator : Boolean = false + var ignoreExitValue : Boolean = false + + var errorCallback: Function1, Unit> = NewRunCommand.DEFAULT_ERROR + var successCallback: Function1, Unit> = NewRunCommand.DEFAULT_SUCCESS + + var isSuccess: (Boolean, List, List) -> Boolean = { + isSuccess: Boolean, + input: List, + error: List -> + var hasErrors = ! isSuccess + if (useErrorStreamAsErrorIndicator && ! hasErrors) { + hasErrors = hasErrors || error.size > 0 + } + if (useInputStreamAsErrorIndicator && ! hasErrors) { + hasErrors = hasErrors || input.size > 0 + } + + ! hasErrors + } + + var containsErrors: ((List) -> Boolean)? = null +} + +fun runCommand(init: RunCommandInfo.() -> Unit) = NewRunCommand(RunCommandInfo().apply { init() }).invoke() + +open class NewRunCommand(val info: RunCommandInfo) { + + companion object { + val DEFAULT_SUCCESS = { output: List -> } + // val DEFAULT_SUCCESS_VERBOSE = { output: List -> kobaltLog(2, "Success:\n " + output.joinToString + // ("\n"))} + // val defaultSuccess = DEFAULT_SUCCESS + val DEFAULT_ERROR = { output: List -> + kobaltError(output.joinToString("\n ")) + } + } + + // fun useErrorStreamAsErrorIndicator(f: Boolean) : RunCommand { + // useErrorStreamAsErrorIndicator = f + // return this + // } + + fun invoke() : Int { + val allArgs = arrayListOf() + allArgs.add(info.command) + allArgs.addAll(info.args) + + val pb = ProcessBuilder(allArgs) + pb.directory(info.directory) + kobaltLog(2, "Running command in directory ${info.directory.absolutePath}" + + "\n " + allArgs.joinToString(" ").replace("\\", "/")) + pb.environment().let { pbEnv -> + info.env.forEach { + pbEnv.put(it.key, it.value) + } + } + + val process = pb.start() + + // Run the command and collect the return code and streams + val processFinished = process.waitFor(120, TimeUnit.SECONDS) + + if (!processFinished) + kobaltError("process timed out!") + + val input = + if (process.inputStream.available() > 0) fromStream(process.inputStream) + else listOf() + val error = + if (process.errorStream.available() > 0) fromStream(process.errorStream) + else listOf() + + kobaltLog(3, "info contains errors: " + (info.containsErrors != null)) + + // Check to see if the command succeeded + val isSuccess = + if (info.containsErrors != null) ! info.containsErrors!!(error) + else isSuccess(if (info.ignoreExitValue) true else processFinished, input, error) + + if (isSuccess) { + if (!info.useErrorStreamAsErrorIndicator) { + info.successCallback(error + input) + } else { + info.successCallback(input) + } + } else { + info.errorCallback(error + input) + } + + return if (isSuccess) 0 else 1 + } + + /** + * Subclasses can override this method to do their own error handling, since commands can + * have various ways to signal errors. + */ + open protected fun isSuccess(isSuccess: Boolean, input: List, error: List) : Boolean { + var hasErrors: Boolean = ! isSuccess + if (info.useErrorStreamAsErrorIndicator && ! hasErrors) { + hasErrors = hasErrors || error.isNotEmpty() + } + if (info.useInputStreamAsErrorIndicator && ! hasErrors) { + hasErrors = hasErrors || input.isNotEmpty() + } + + return ! hasErrors + } + + /** + * Turn the given InputStream into a list of strings. + */ + private fun fromStream(ins: InputStream) : List { + val result = arrayListOf() + val br = BufferedReader(InputStreamReader(ins)) + var line = br.readLine() + + while (line != null) { + result.add(line) + line = br.readLine() + } + return result + } +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/Node.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/Node.kt index 4fd2f216..26707f03 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/Node.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/Node.kt @@ -1,10 +1,10 @@ package com.beust.kobalt.misc -public data class Node(val value: T) { +data class Node(val value: T) { val children = arrayListOf>() var parent: Node? = null - public fun addChildren(values: List>) { + fun addChildren(values: List>) { values.forEach { it.parent = this children.add(it) @@ -12,15 +12,15 @@ public data class Node(val value: T) { } private fun p(s: String) { - println(s) + kobaltLog(1, s) } - public fun dump(r: T, children: List>, indent: Int) { + fun dump(r: T, children: List>, indent: Int) { p(" ".repeat(indent) + r) children.forEach { dump(it.value, it.children, indent + 2) } } - public fun dump(indent: Int = 0) { + fun dump(indent: Int = 0) { dump(value, children, indent) } } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/RunCommand.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/RunCommand.kt deleted file mode 100644 index 7d6646d4..00000000 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/RunCommand.kt +++ /dev/null @@ -1,90 +0,0 @@ -package com.beust.kobalt.misc - -import java.io.BufferedReader -import java.io.File -import java.io.InputStream -import java.io.InputStreamReader -import java.util.concurrent.TimeUnit - -open class RunCommand(val command: String) { - val DEFAULT_SUCCESS = { output: List -> } -// val DEFAULT_SUCCESS_VERBOSE = { output: List -> log(2, "Success:\n " + output.joinToString("\n"))} - val defaultSuccess = DEFAULT_SUCCESS - val DEFAULT_ERROR = { - output: List -> error(output.joinToString("\n ")) - } - - var directory = File(".") - var env = hashMapOf() - - /** - * Some commands fail but return 0, so the only way to find out if they failed is to look - * at the error stream. However, some commands succeed but output text on the error stream. - * This field is used to specify how errors are caught. - */ - var useErrorStreamAsErrorIndicator = true - var useInputStreamAsErrorIndicator = false - - fun useErrorStreamAsErrorIndicator(f: Boolean) : RunCommand { - useErrorStreamAsErrorIndicator = f - return this - } - - open fun run(args: List, - errorCallback: Function1, Unit> = DEFAULT_ERROR, - successCallback: Function1, Unit> = defaultSuccess) : Int { - val allArgs = arrayListOf() - allArgs.add(command) - allArgs.addAll(args) - - val pb = ProcessBuilder(allArgs) - pb.directory(directory) - log(2, "Running command in directory ${directory.absolutePath}" + - "\n " + allArgs.joinToString(" ").replace("\\", "/")) - val process = pb.start() - pb.environment().let { pbEnv -> - env.forEach { - pbEnv.put(it.key, it.value) - } - } - val callSucceeded = process.waitFor(30, TimeUnit.SECONDS) - val input = if (process.inputStream.available() > 0) fromStream(process.inputStream) else emptyList() - val error = if (process.errorStream.available() > 0) fromStream(process.errorStream) else emptyList() - val isSuccess = isSuccess(callSucceeded, input, error) - - if (isSuccess) { - successCallback(fromStream(process.inputStream)) - } else { - errorCallback(error + input) - } - - return if (isSuccess) 0 else 1 - } - - open protected fun isSuccess(callSucceeded: Boolean, input: List, error: List) : Boolean { - var hasErrors = ! callSucceeded - if (useErrorStreamAsErrorIndicator && ! hasErrors) { - hasErrors = hasErrors || error.size > 0 - } - if (useInputStreamAsErrorIndicator && ! hasErrors) { - hasErrors = hasErrors || input.size > 0 - } - - return ! hasErrors - } - - private fun fromStream(ins: InputStream) : List { - val result = arrayListOf() - val br = BufferedReader(InputStreamReader(ins)) - var line = br.readLine() - - while (line != null) { - result.add(line) - line = br.readLine() - } - return result - -// val result = CharStreams.toString(InputStreamReader(ins, Charset.defaultCharset())) -// return result.split("\n") - } -} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/StringVersion.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/StringVersion.kt new file mode 100644 index 00000000..b421e558 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/StringVersion.kt @@ -0,0 +1,50 @@ +package com.beust.kobalt.misc + +import java.lang.Long +import java.lang.NumberFormatException +import java.util.* + +/** + * Compare string versions, e.g. "1.2.0", "0.9", etc... + */ +class StringVersion(val version: String) : Comparable { + override fun compareTo(other: StringVersion): Int { + val s1 = arrayListOf().apply { addAll(version.split('.')) } + val s2 = arrayListOf().apply { addAll(other.version.split('.')) } + + // Normalize both strings, so they have the same length, e.g. 1 -> 1.0.0 + val max = Math.max(s1.size, s2.size) + val shorterList : ArrayList = if (s1.size == max) s2 else s1 + repeat(max - shorterList.size) { + shorterList.add("0") + } + + // Compare each section + repeat(max) { index -> + try { + fun parse(s: String) = Long.parseLong(s.filter(Char::isDigit)) + + val v1 = parse(s1[index]) + val v2 = parse(s2[index]) + if (v1 < v2) return -1 + else if (v1 > v2) return 1 + } catch(ex: NumberFormatException) { + if (version == other.toString()) { + return 0 + } else { + log(2, "Couldn't parse version $version or $other") + return -1 + } + } + } + return 0 + } + + override fun equals(other: Any?) = + if (other is StringVersion) this.compareTo(other) == 0 + else false + + override fun hashCode() = version.hashCode() + + override fun toString() = version +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/Strings.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/Strings.kt index 113488f1..01f39a17 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/Strings.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/Strings.kt @@ -2,23 +2,10 @@ package com.beust.kobalt.misc import com.google.common.base.CharMatcher -public class Strings { +class Strings { companion object { - fun join(separator: String, strings: List) : String { - var result = StringBuffer() - var i = 0 - strings.forEach { - if (i++ > 0) { - result.append(separator) - } - result.append(it) - } - return result.toString() - } - - fun isEmpty(s: String?): Boolean { - return s == null || s.isEmpty() - } + fun pluralize(n:Int, string: String, plural: String = string + "s") = if (n != 1) plural else string + fun pluralizeAll(n:Int, string: String, plural: String = string + "s") = "$n " + pluralize(n, string, plural) } } @@ -26,6 +13,6 @@ public class Strings { /** * @Return the number of times the given character occurs in the string */ -public infix fun String.countChar(c: Char) : Int { +infix fun String.countChar(c: Char) : Int { return CharMatcher.`is`(c).countIn(this) } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/Topological.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/Topological.kt index 0003b4a4..38c4c503 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/Topological.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/Topological.kt @@ -10,22 +10,25 @@ import java.util.* */ class Topological { private val dependingOn = ArrayListMultimap.create() + private val nodes = hashSetOf() + + fun addNode(t: T) = nodes.add(t) fun addEdge(t: T, other: T) { + addNode(t) + addNode(other) dependingOn.put(t, other) } - fun addEdge(t: T, others: Array) { - dependingOn.putAll(t, others.toArrayList()) - } - /** * @return the Ts sorted topologically. */ - fun sort(all: ArrayList) : List { + fun sort() : List { + val all = ArrayList(nodes) val result = arrayListOf() var dependMap = HashMultimap.create() dependingOn.keySet().forEach { dependMap.putAll(it, dependingOn.get(it))} + nodes.forEach { dependMap.putAll(it, emptyList())} while (all.size > 0) { val freeNodes = all.filter { dependMap.get(it).isEmpty() diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/Versions.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/Versions.kt index 1d3a3fd7..205c2ced 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/Versions.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/Versions.kt @@ -1,41 +1,10 @@ package com.beust.kobalt.misc import com.beust.kobalt.maven.MavenId -import com.google.common.base.CharMatcher +import java.lang.* import java.math.BigInteger import java.util.* -public class Versions { - companion object { - /** - * Turn "6.9.4" into 600090004 - */ - public fun toLongVersion(version: String) : Long { - val count = version.countChar('.') - val normalizedVersion = if (count == 2) version else if (count == 1) version + ".0" - else version + ".0.0" - - fun parseLong(s: String, radix: Int) : Long { - try { - return java.lang.Long.parseLong(s, radix) - } catch(ex: NumberFormatException) { - warn("Couldn't parse version \"${version}\"") - return 0L - } - } - - return normalizedVersion - .split(".") - .take(3) - .map { - val s = CharMatcher.inRange('0', '9').or(CharMatcher.`is`('.')).retainFrom(it) - parseLong(s, 10) - } - .fold(0L, { n, s -> s + n * 10000 }) - } - } -} - class Version(val version: String, val snapshotTimestamp: String? = null): Comparable { companion object { @@ -85,30 +54,20 @@ class Version(val version: String, val snapshotTimestamp: String? = null): Compa } } - override fun compareTo(other: Version): Int { - return comparator.compare(this, other) - } + override fun compareTo(other: Version) = comparator.compare(this, other) - override fun equals(other: Any?): Boolean { - return (other is Version) && comparator.compare(this, other) == 0 - } + override fun equals(other: Any?) = (other is Version) && comparator.compare(this, other) == 0 override fun hashCode(): Int { if ( hash == -1 ) hash = Arrays.hashCode(items.toTypedArray()) return hash } - override fun toString(): String { - return version - } + override fun toString() = version - fun isSnapshot(): Boolean { - return items.firstOrNull { it.isSnapshot } != null - } + fun isSnapshot() = items.firstOrNull { it.isSnapshot } != null - fun isRangedVersion(): Boolean { - return MavenId.isRangedVersion(version) - } + fun isRangedVersion() = MavenId.isRangedVersion(version) fun select(list: List): Version? { if (!(version.first() in listOf('[', '(') && version.last() in listOf(']', ')'))) { @@ -117,7 +76,7 @@ class Version(val version: String, val snapshotTimestamp: String? = null): Compa var lowerExclusive = version.startsWith("(") var upperExclusive = version.endsWith(")") - val split = version.drop(1).dropLast(1).split(",") + val split = version.drop(1).dropLast(1).split(',') val lower = Version.of(split[0].substring(1)) val upper = if(split.size > 1) { diff --git a/modules/kobalt/build.gradle b/modules/kobalt/build.gradle new file mode 100644 index 00000000..57e009c7 --- /dev/null +++ b/modules/kobalt/build.gradle @@ -0,0 +1,79 @@ +plugins { + id 'org.jetbrains.kotlin.jvm' version '1.2.71' + id 'com.github.johnrengelman.shadow' version '5.0.0' +} + +dependencies { + implementation project(':wrapper') + implementation project(':kobalt-plugin-api') + implementation "biz.aQute.bnd:biz.aQute.bndlib:$bndlib" + implementation 'com.github.spullara.mustache.java:compiler:0.9.5' + implementation "com.google.code.findbugs:jsr305:$findbugs" + implementation "com.sparkjava:spark-core:$spark" + implementation "com.squareup.okhttp3:logging-interceptor:$okhttp" + implementation 'com.sun.activation:javax.activation:1.2.0' + implementation "com.sun.xml.bind:jaxb-core:$jaxb" + implementation "com.sun.xml.bind:jaxb-impl:$jaxb" + implementation "javax.inject:javax.inject:$inject" + implementation "javax.xml.bind:jaxb-api:$jaxb" + implementation "org.apache.maven.resolver:maven-resolver-spi:$mavenResolver" + implementation "org.codehaus.groovy:groovy:$groovy" + implementation "com.beust:jcommander:$jcommander" + implementation "com.google.code.gson:gson:$gson" + implementation "com.google.inject:guice:$guice" + implementation "com.google.inject.extensions:guice-assistedinject:$guice" + implementation "com.squareup.retrofit2:converter-gson:$retrofit" + implementation "com.squareup.retrofit2:retrofit:$retrofit" + implementation "org.apache.maven:maven-model:$maven" + implementation "org.jetbrains.kotlin:kotlin-compiler-embeddable:$kotlin" + implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin" + testImplementation 'org.assertj:assertj-core:3.8.0' + testImplementation "org.jetbrains.kotlin:kotlin-test:$kotlin" + testImplementation "org.testng:testng:$testng" +} + +sourceSets { + main.kotlin.srcDirs += "${rootProject.projectDir}../../src/main/kotlin" + test.kotlin.srcDirs += "${rootProject.projectDir}../../src/test/kotlin" +} + +shadowJar { + classifier = null +} + +test { + useTestNG() +} + +publishing { + publications { + shadow(MavenPublication) { publication -> + project.shadow.component(publication) + artifact sourcesJar + artifact javadocJar + + pom { + name = project.name + description = 'A build system in Kotlin' + url = 'https://beust.com/kobalt' + licenses { + license { + name = 'Apache-2.0' + url = 'https://www.apache.org/licenses/LICENSE-2.0' + } + } + developers { + developer { + name = 'Cedric Beust' + email = 'cedric@beust.com' + } + } + scm { + connection = 'scm:https://github.com/cbeust/kobalt.git' + developerConnection = 'scm:git@github.com:cbeust/kobalt.git' + url = 'https://github.com/cbeust/kobalt' + } + } + } + } +} diff --git a/modules/kobalt/pom.xml b/modules/kobalt/pom.xml new file mode 100644 index 00000000..44dc799c --- /dev/null +++ b/modules/kobalt/pom.xml @@ -0,0 +1,231 @@ + + 4.0.0 + + com.beust + kobalt-pom + 1.1.0 + ../.. + + + kobalt + jar + 1.1.0 + + + + com.beust + kobalt-plugin-api + 1.1.0 + + + com.beust + wrapper + 1.1.0 + + + org.jetbrains.kotlin + kotlin-compiler-embeddable + ${kotlin.version} + + + org.jetbrains.kotlin + kotlin-stdlib + ${kotlin.version} + + + com.github.spullara.mustache.java + compiler + 0.9.5 + compile + + + javax.inject + javax.inject + 1 + compile + + + com.google.inject + guice + 4.2.2 + + + com.google.inject.extensions + guice-assistedinject + 4.2.2 + + + com.beust + jcommander + 1.72 + + + org.apache.maven + maven-model + 3.5.2 + + + com.google.code.findbugs + jsr305 + 3.0.2 + + + com.google.code.gson + gson + 2.8.2 + + + com.squareup.retrofit2 + retrofit + 2.3.0 + + + com.squareup.retrofit2 + converter-gson + 2.3.0 + + + biz.aQute.bnd + biz.aQute.bndlib + 3.5.0 + + + com.squareup.okhttp3 + logging-interceptor + ${okhttp3.version} + + + com.sparkjava + spark-core + 2.6.0 + + + org.codehaus.groovy + groovy + 2.4.12 + + + org.apache.maven.resolver + maven-resolver-spi + ${mavenresolver.version} + + + + javax.xml.bind + jaxb-api + 2.3.0 + + + com.sun.xml.bind + jaxb-impl + 2.3.0 + + + com.sun.xml.bind + jaxb-core + 2.3.0 + + + com.sun.activation + javax.activation + 1.2.0 + + + + org.assertj + assertj-core + 3.8.0 + test + + + org.jetbrains.kotlin + kotlin-test + ${kotlin.version} + test + + + org.testng + testng + ${testng.version} + test + + + + + + + org.jetbrains.kotlin + kotlin-maven-plugin + ${kotlin.version} + + + compile + compile + + + ${project.basedir}../../src/main/kotlin + + + + + test-compile + test-compile + + + ${project.basedir}../../src/test/kotlin + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + 3.5.1 + + + + default-compile + none + + + + default-testCompile + none + + + java-compile + compile + compile + + + java-test-compile + test-compile + testCompile + + + + + org.apache.maven.plugins + maven-shade-plugin + 3.2.1 + + + + com.beust.kobalt.MainKt + + + + + + package + + shade + + + + + + + \ No newline at end of file diff --git a/modules/wrapper/build.gradle b/modules/wrapper/build.gradle index e3b313bc..c0b5dafe 100644 --- a/modules/wrapper/build.gradle +++ b/modules/wrapper/build.gradle @@ -1,4 +1,38 @@ -apply plugin: 'java' -apply plugin: 'application' +jar { + manifest { + attributes 'Main-Class': 'com.beust.kobalt.wrapper.Main' + } +} -mainClassName = 'com.beust.kobalt.wrapper.Main' +publishing { + publications { + maven(MavenPublication) { + from(components.java) + artifact sourcesJar + artifact javadocJar + + pom { + name = project.name + description = 'Wrapper for Kobalt' + url = 'https://beust.com/kobalt' + licenses { + license { + name = 'Apache-2.0' + url = 'https://www.apache.org/licenses/LICENSE-2.0' + } + } + developers { + developer { + name = 'Cedric Beust' + email = 'cedric@beust.com' + } + } + scm { + connection = 'scm:https://github.com/cbeust/kobalt.git' + developerConnection = 'scm:git@github.com:cbeust/kobalt.git' + url = 'https://github.com/cbeust/kobalt' + } + } + } + } +} diff --git a/modules/wrapper/kobalt-wrapper.iml b/modules/wrapper/kobalt-wrapper.iml deleted file mode 100644 index 6001749a..00000000 --- a/modules/wrapper/kobalt-wrapper.iml +++ /dev/null @@ -1,12 +0,0 @@ - - - - - - - - - - - - diff --git a/modules/wrapper/modules_wrapper.iml b/modules/wrapper/modules_wrapper.iml deleted file mode 100644 index 2b976c0b..00000000 --- a/modules/wrapper/modules_wrapper.iml +++ /dev/null @@ -1,18 +0,0 @@ - - - - - - - - - - - - - - - - - - \ No newline at end of file diff --git a/modules/wrapper/pom.xml b/modules/wrapper/pom.xml new file mode 100644 index 00000000..a9dc8796 --- /dev/null +++ b/modules/wrapper/pom.xml @@ -0,0 +1,28 @@ + + 4.0.0 + + com.beust + kobalt-pom + 1.1.0 + ../.. + + + wrapper + jar + 1.1.0 + + + + + org.apache.maven.plugins + maven-compiler-plugin + 3.8.0 + + 1.7 + 1.7 + + + + + \ No newline at end of file diff --git a/modules/wrapper/src/main/java/com/beust/kobalt/wrapper/Config.java b/modules/wrapper/src/main/java/com/beust/kobalt/wrapper/Config.java new file mode 100644 index 00000000..f6eb4b09 --- /dev/null +++ b/modules/wrapper/src/main/java/com/beust/kobalt/wrapper/Config.java @@ -0,0 +1,72 @@ +package com.beust.kobalt.wrapper; + + +import org.w3c.dom.Document; +import org.w3c.dom.Element; +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +import javax.xml.parsers.DocumentBuilder; +import javax.xml.parsers.DocumentBuilderFactory; +import java.io.ByteArrayInputStream; +import java.io.IOException; +import java.net.InetSocketAddress; +import java.net.Proxy; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; + +class Config { + + static Proxy getProxy() { + String configFilePath = getConfigFilePath(); + DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); + try { + DocumentBuilder builder = factory.newDocumentBuilder(); + ByteArrayInputStream input = new ByteArrayInputStream(getConfigFileContent(configFilePath)); + Document doc = builder.parse(input); + NodeList proxies =doc.getElementsByTagName("proxies"); + for (int temp = 0; temp < proxies.getLength(); temp++) { + Node node = proxies.item(temp); + if (node.getNodeType() == Node.ELEMENT_NODE) { + Element element = (Element) node; + String type = element.getElementsByTagName("type").item(0).getTextContent(); + if (type.toLowerCase().equals("http")) { + String host = element.getElementsByTagName("host").item(0).getTextContent(); + String portString = element.getElementsByTagName("port").item(0).getTextContent(); + try { + int port = Integer.parseInt(portString); + Main.log(2, String.format("Using HTTP proxy: %s:%s", host, port)); + return new Proxy(java.net.Proxy.Type.HTTP, new InetSocketAddress(host, port)); + } catch (NumberFormatException e) { + Main.log(1, String.format("Invalid proxy port number: %s in config file: %s", portString, configFilePath)); + } + } + } + } + } catch (Exception e) { + Main.log(2, String.format("%s while parsing config file: %s", e.getMessage(), configFilePath)); + return null; + } + Main.log(2, String.format("No HTTP proxy found in config file: %s", configFilePath)); + return null; + } + + private static String getConfigFilePath() { + String userHome = System.getProperty("user.home"); + String fileSeparator = System.getProperty("file.separator"); + String configDir = ".config"; + String appName = "kobalt"; + String configFileName = "settings.xml"; + return userHome + + fileSeparator + configDir + + fileSeparator + appName + + fileSeparator + configFileName; + } + + private static byte[] getConfigFileContent(String configFilePath) throws IOException { + Path path = Paths.get(configFilePath); + return Files.readAllBytes(path); + } + +} diff --git a/modules/wrapper/src/main/java/com/beust/kobalt/wrapper/Main.java b/modules/wrapper/src/main/java/com/beust/kobalt/wrapper/Main.java index 3ff097d5..f31bbc3f 100644 --- a/modules/wrapper/src/main/java/com/beust/kobalt/wrapper/Main.java +++ b/modules/wrapper/src/main/java/com/beust/kobalt/wrapper/Main.java @@ -2,7 +2,9 @@ package com.beust.kobalt.wrapper; import java.io.*; import java.net.HttpURLConnection; +import java.net.Proxy; import java.net.URL; +import java.nio.charset.Charset; import java.nio.file.*; import java.util.*; import java.util.zip.ZipEntry; @@ -12,29 +14,50 @@ import java.util.zip.ZipFile; //@com.beust.apt.processor.Version("1.3") public class Main { public static void main(String[] argv) throws IOException, InterruptedException { - new Main().installAndLaunchMain(argv); + int exitCode = new Main().installAndLaunchMain(argv); + System.exit(exitCode); } + private static final boolean DEV = false; + private static final int DEV_VERSION_INT = 662; + private static final String DEV_VERSION = "0." + DEV_VERSION_INT; + private static final String DEV_ZIP = "/Users/beust/kotlin/kobalt/kobaltBuild/libs/kobalt-" + DEV_VERSION + ".zip"; + private static final String KOBALT_PROPERTIES = "kobalt.properties"; private static final String KOBALTW = "kobaltw"; + private static final String KOBALTW_BAT = "kobaltw.bat"; private static final String KOBALT_WRAPPER_PROPERTIES = "kobalt-wrapper.properties"; private static final String PROPERTY_VERSION = "kobalt.version"; private static final String PROPERTY_DOWNLOAD_URL = "kobalt.downloadUrl"; private static final String FILE_NAME = "kobalt"; private static final String DISTRIBUTIONS_DIR = System.getProperty("user.home") + "/.kobalt/wrapper/dist"; + private static final File VERSION_TXT = new File(".kobalt", "wrapperVersion.txt"); private final Properties wrapperProperties = new Properties(); + private static int logQuietLevel = 0; private static int logLevel = 1; private boolean noOverwrite = false; - private void installAndLaunchMain(String[] argv) throws IOException, InterruptedException { + private String getVersion() throws IOException { + Properties properties = maybeCreateProperties(); + return properties.getProperty(PROPERTY_VERSION); + } + + private int installAndLaunchMain(String[] argv) throws IOException, InterruptedException { + String version = getVersion(); + List kobaltArgv = new ArrayList<>(); boolean noLaunch = false; + boolean exit = false; for (int i = 0; i < argv.length; i++) { boolean passToKobalt = true; switch(argv[i]) { + case "--version": + System.out.println("Kobalt " + version + ", Wrapper " + getWrapperVersion()); + exit = true; + break; case "--noOverwrite": noOverwrite = true; passToKobalt = false; @@ -52,10 +75,15 @@ public class Main { kobaltArgv.add(argv[i]); } } - Path kobaltJarFile = installDistribution(); - if (! noLaunch) { - launchMain(kobaltJarFile, kobaltArgv.toArray(new String[kobaltArgv.size()])); + int result = 0; + if (! exit) { + initWrapperFile(version); + Path kobaltJarFile = installDistribution(); + if (!noLaunch) { + result = launchMain(kobaltJarFile, kobaltArgv); + } } + return result; } private void readProperties(Properties properties, InputStream ins) throws IOException { @@ -90,7 +118,7 @@ public class Main { } private static String downloadUrl(String version) { - return "http://beust.com/kobalt/kobalt-" + version + ".zip"; + return "https://beust.com/kobalt/kobalt-" + version + ".zip"; } private void initWrapperFile(String version) throws IOException { @@ -105,7 +133,7 @@ public class Main { } private String getWrapperVersion() { - return wrapperProperties.getProperty(PROPERTY_VERSION); + return wrapperProperties.getProperty(PROPERTY_VERSION, "N/A"); } private String getWrapperDownloadUrl(String version) { @@ -120,33 +148,44 @@ public class Main { return System.getProperty("os.name").contains("Windows"); } - private Path installDistribution() throws IOException { - Properties properties = maybeCreateProperties(); + private static final String[] FILES = new String[] { KOBALTW, KOBALTW_BAT, "kobalt/wrapper/" + FILE_NAME + "-wrapper.jar" }; - String version = properties.getProperty(PROPERTY_VERSION); - initWrapperFile(version); - String wrapperVersion = getWrapperVersion(); + private Path installDistribution() throws IOException { + String wrapperVersion; + String version; + Path localZipFile; + if (DEV) { + version = DEV_VERSION; + wrapperVersion = DEV_VERSION; + localZipFile = Paths.get(DEV_ZIP); + } else { + version = getVersion(); + wrapperVersion = getWrapperVersion(); + String fileName = FILE_NAME + "-" + wrapperVersion + ".zip"; + Files.createDirectories(Paths.get(DISTRIBUTIONS_DIR)); + localZipFile = Paths.get(DISTRIBUTIONS_DIR, fileName); + } log(2, "Wrapper version: " + wrapperVersion); - String fileName = FILE_NAME + "-" + wrapperVersion + ".zip"; - Files.createDirectories(Paths.get(DISTRIBUTIONS_DIR)); - Path localZipFile = Paths.get(DISTRIBUTIONS_DIR, fileName); - String zipOutputDir = DISTRIBUTIONS_DIR + "/" + wrapperVersion; - Path kobaltJarFile = Paths.get(zipOutputDir, + String toZipOutputDir = DISTRIBUTIONS_DIR; + Path kobaltJarFile = Paths.get(toZipOutputDir, + "kobalt-" + wrapperVersion, getWrapperDir().getPath() + "/" + FILE_NAME + "-" + wrapperVersion + ".jar"); + boolean downloadedZipFile = false; if (! Files.exists(localZipFile) || ! Files.exists(kobaltJarFile)) { download(localZipFile.toFile(), wrapperVersion); + downloadedZipFile = true; } // // Extract all the zip files // - if (! noOverwrite) { + if (! noOverwrite && downloadedZipFile) { int retries = 0; while (retries < 2) { try { - extractZipFile(localZipFile, zipOutputDir); + extractZipFile(localZipFile, toZipOutputDir); break; } catch (ZipException e) { retries++; @@ -159,54 +198,110 @@ public class Main { } // - // Copy the wrapper files in the current kobalt/wrapper directory - // + // If the user didn't specify --noOverwrite, compare the installed wrapper to the one + // we're trying to install and if they are the same, no need to overwrite if (! noOverwrite) { - log(2, "Copying the wrapper files"); - for (String file : FILES) { - Path to = Paths.get(new File(".").getAbsolutePath(), file); - - if (Files.exists(to)) { - log(2, " $to already exists, not overwriting it"); - continue; - } else if (file.equals(KOBALTW)) { - generateKobaltW(to); - } else { - Path from = Paths.get(zipOutputDir, file); - try { - if (isWindows() && to.toFile().exists()) { - log(2, " Windows detected, not overwriting " + to); + if (VERSION_TXT.exists()) { + try (FileReader fw = new FileReader(VERSION_TXT)) { + try (BufferedReader bw = new BufferedReader(fw)) { + String installedVersion = bw.readLine(); + if (!wrapperVersion.equals(installedVersion)) { + log(2, " Trying to install a different version " + + wrapperVersion + " != " + installedVersion + + ", overwriting the installed wrapper"); + installWrapperFiles(version, wrapperVersion); } else { - Files.copy(from, to, StandardCopyOption.REPLACE_EXISTING); + log(2, " Trying to install the same version " + wrapperVersion + " == " + installedVersion + + ", not overwriting the installed wrapper"); } - } catch (IOException ex) { - log(1, " Couldn't copy " + from + " to " + to + ": " + ex.getMessage()); } } + } else { + log(2, " Couldn't find $VERSION_TEXT, overwriting the installed wrapper"); + installWrapperFiles(version, wrapperVersion); + } + + // + // Install the launcher(s) if not already found. + // + File kobaltw = new File(KOBALTW); + File kobaltwBat = new File(KOBALTW_BAT); + + if (!kobaltw.exists()) { + generateKobaltW(kobaltw.toPath()); + } + + if (!kobaltwBat.exists()) { + generateKobaltWBat(kobaltwBat.toPath()); } } return kobaltJarFile; } + private void installWrapperFiles(String version, String wrapperVersion) throws IOException { + String fromZipOutputDir = DISTRIBUTIONS_DIR + File.separator + "kobalt-" + wrapperVersion; + + for (String file : FILES) { + Path to = Paths.get(file); + to.toFile().getAbsoluteFile().getParentFile().mkdirs(); + + if (file.endsWith(KOBALTW)) { + generateKobaltW(Paths.get(KOBALTW)); + } else if (file.endsWith(KOBALTW_BAT)) { + generateKobaltWBat(Paths.get(KOBALTW_BAT)); + } else { + Path from = Paths.get(fromZipOutputDir, file); + try { + if (isWindows() && to.toFile().exists()) { + log(2, " Windows detected, not overwriting " + to); + } else { + log(2, " Copying " + from + " to " + to); + Files.copy(from, to, StandardCopyOption.REPLACE_EXISTING); + } + } catch (IOException ex) { + log(1, " Couldn't copy " + from + " to " + to + ": " + ex.getMessage()); + } + } + } + + // + // Save wrapperVersion.txt + // + log(2, " Writing " + VERSION_TXT); + File parentDir = VERSION_TXT.getParentFile(); + parentDir.mkdirs(); + if (parentDir.exists()) { + try (FileWriter fw = new FileWriter(VERSION_TXT)) { + try (BufferedWriter bw = new BufferedWriter(fw)) { + bw.write(wrapperVersion); + } + } + } else { + log(1, "Warning: could not create the directory " + parentDir.getAbsolutePath() + + ", can't write " + VERSION_TXT); + } + } + private void generateKobaltW(Path filePath) throws IOException { // - // For kobaltw: try to generate it with the correct env shebang. If this fails, - // we'll generate it without the env shebang + // For kobaltw: try to generate it with the correct env shebang. // - File envFile = new File("/bin/env"); - if (!envFile.exists()) { - envFile = new File("/usr/bin/env"); + String envPath; + if (isWindows()) { + envPath = "/usr/bin/env"; + } else { + File envFile = new File("/bin/env"); + if (!envFile.canExecute()) { + envFile = new File("/usr/bin/env"); + } + envPath = envFile.getAbsolutePath(); } - String content = ""; + String content = "#!" + envPath + " sh\n" + + "java -jar \"`dirname \"$0\"`/kobalt/wrapper/kobalt-wrapper.jar\" $*\n"; - if (envFile.exists()) { - content = "#!" + envFile.getAbsolutePath() + " bash\n"; - } - log(2, "Generating " + KOBALTW + (envFile.exists() ? " with shebang" : "") + "."); - - content += "java -jar $(dirname $0)/kobalt/wrapper/kobalt-wrapper.jar $*\n"; + log(2, " Generating " + KOBALTW + " with shebang."); Files.write(filePath, content.getBytes()); @@ -217,6 +312,21 @@ public class Main { } } + private void generateKobaltWBat(Path filePath) throws IOException { + if (isWindows() && filePath.toFile().exists()) { + log(2, " Windows detected, not overwriting " + filePath); + } else { + String content = "@echo off\r\n" + + "set DIRNAME=%~dp0\r\n" + + "if \"%DIRNAME%\" == \"\" set DIRNAME=.\r\n" + + "java -jar \"%DIRNAME%/kobalt/wrapper/kobalt-wrapper.jar\" %*\r\n"; + + log(2, " Generating " + KOBALTW_BAT + " for Windows."); + + Files.write(filePath, content.getBytes()); + } + } + /** * Extract the zip file in ~/.kobalt/wrapper/dist/$version */ @@ -235,6 +345,11 @@ public class Main { try { Files.createDirectories(entryPath.getParent()); Files.copy(zipFile.getInputStream(entry), entryPath, StandardCopyOption.REPLACE_EXISTING); + if (!isWindows() && entry.getName().endsWith(KOBALTW)) { + if (!entryPath.toFile().setExecutable(true)) { + log(1, "Couldn't make distribution " + KOBALTW + " executable"); + } + } } catch (FileSystemException ex) { log(2, "Couldn't copy to " + entryPath); } @@ -243,8 +358,6 @@ public class Main { } } - private static final String[] FILES = new String[] { KOBALTW, "kobalt/wrapper/" + FILE_NAME + "-wrapper.jar" }; - private void download(File file, String version) throws IOException { for (int attempt = 0; attempt < 3; ++attempt) { try { @@ -270,13 +383,18 @@ public class Main { log(2, "Downloading " + fileUrl); boolean done = false; + Proxy proxy = Config.getProxy(); HttpURLConnection httpConn = null; try { int responseCode = 0; URL url = null; while (!done) { url = new URL(fileUrl); - httpConn = (HttpURLConnection) url.openConnection(); + if (proxy != null) { + httpConn = (HttpURLConnection) url.openConnection(proxy); + } else { + httpConn = (HttpURLConnection) url.openConnection(); + } responseCode = httpConn.getResponseCode(); if (responseCode == HttpURLConnection.HTTP_MOVED_TEMP || responseCode == HttpURLConnection.HTTP_MOVED_PERM) { @@ -322,6 +440,8 @@ public class Main { } else { error("No file to download. Server replied HTTP code: " + responseCode); } + } catch(IOException ex) { + log(1, "Warning: couldn't download " + fileUrl); } finally { if (httpConn != null) { httpConn.disconnect(); @@ -329,20 +449,28 @@ public class Main { } } + private static String PROPERTY_NO_ANIMATIONS = "com.beust.kobalt.noAnimations"; + private void copyToStreamWithProgress(InputStream inputStream, OutputStream outputStream, long contentLength, String url) throws IOException { int bytesRead; long bytesSoFar = 0; byte[] buffer = new byte[100_000]; + boolean hasTerminal = System.console() != null && System.getProperty(PROPERTY_NO_ANIMATIONS) == null; + if (! hasTerminal) { + log2(1, "\rDownloading " + url); + } while ((bytesRead = inputStream.read(buffer)) != -1) { outputStream.write(buffer, 0, bytesRead); bytesSoFar += bytesRead; - if (bytesRead > 0) { - if (contentLength > 0) { - float percent = bytesSoFar * 100 / contentLength; - log2(1, "\rDownloading " + url + " " + percent + "%"); - } else { - log2(1, "."); + if (hasTerminal) { + if (bytesRead > 0) { + if (contentLength > 0) { + float percent = bytesSoFar * 100 / contentLength; + log2(1, "\rDownloading " + url + " " + percent + "%"); + } else { + log2(1, "."); + } } } } @@ -365,7 +493,7 @@ public class Main { } private static void p(int level, String s, boolean newLine) { - if (level <= logLevel) { + if (level != logQuietLevel && level <= logLevel) { if (newLine) System.out.println(s); else System.out.print(s); } @@ -375,19 +503,28 @@ public class Main { System.out.println("[Wrapper error] *** " + s); } - private void launchMain(Path kobaltJarFile, String[] argv) throws IOException, InterruptedException { + private int launchMain(Path kobaltJarFile, List argv) throws IOException, InterruptedException { List args = new ArrayList<>(); args.add("java"); + args.add("-Dfile.encoding=" + Charset.defaultCharset().name()); + // jvm parameters must go before -jar + Iterator i = argv.iterator(); + while (i.hasNext()) { + String arg = i.next(); + if (arg.matches("-D(.+?)=(.*)")) { + args.add(arg); + i.remove(); + } + } args.add("-jar"); args.add(kobaltJarFile.toFile().getAbsolutePath()); - Collections.addAll(args, argv); + Collections.addAll(args, argv.toArray(new String[argv.size()])); ProcessBuilder pb = new ProcessBuilder(args); pb.inheritIO(); log(2, "Launching " + args); Process process = pb.start(); - process.waitFor(); - + return process.waitFor(); } -} \ No newline at end of file +} diff --git a/modules/wrapper/wrapper.iml b/modules/wrapper/wrapper.iml deleted file mode 100644 index d3218a2d..00000000 --- a/modules/wrapper/wrapper.iml +++ /dev/null @@ -1,13 +0,0 @@ - - - - - - - - - - - - - \ No newline at end of file diff --git a/pom.xml b/pom.xml new file mode 100644 index 00000000..3a87c7ac --- /dev/null +++ b/pom.xml @@ -0,0 +1,34 @@ + + 4.0.0 + + com.beust + kobalt-pom + pom + 1.1.0 + + + modules/kobalt-plugin-api + modules/wrapper + modules/kobalt + + + + + testng + https://dl.bintray.com/cbeust/maven + + + + + 1.2.71 + 1.13.0 + 3.9.1 + 1.1.0 + 1.1.0 + 5.1.0 + 6.12 + 1.7.3 + + + \ No newline at end of file diff --git a/settings.gradle b/settings.gradle index 91ce3de2..c36e45fd 100644 --- a/settings.gradle +++ b/settings.gradle @@ -1 +1,5 @@ -include ':modules/wrapper' +rootProject.name = 'kobalt-pom' +include(':kobalt-plugin-api', ':wrapper', ':kobalt') +project(':kobalt-plugin-api').projectDir = file('modules/kobalt-plugin-api') +project(':wrapper').projectDir = file('modules/wrapper') +project(':kobalt').projectDir = file('modules/kobalt') diff --git a/src/main/kotlin/com/beust/kobalt/Main.kt b/src/main/kotlin/com/beust/kobalt/Main.kt index 6de5f819..19b85404 100644 --- a/src/main/kotlin/com/beust/kobalt/Main.kt +++ b/src/main/kotlin/com/beust/kobalt/Main.kt @@ -3,272 +3,134 @@ package com.beust.kobalt import com.beust.jcommander.JCommander import com.beust.kobalt.api.IClasspathDependency import com.beust.kobalt.api.Kobalt -import com.beust.kobalt.api.PluginTask -import com.beust.kobalt.api.Project -import com.beust.kobalt.app.BuildFileCompiler import com.beust.kobalt.app.MainModule -import com.beust.kobalt.app.ProjectGenerator import com.beust.kobalt.app.UpdateKobalt import com.beust.kobalt.app.remote.KobaltClient -import com.beust.kobalt.app.remote.KobaltServer +import com.beust.kobalt.internal.KobaltSettings import com.beust.kobalt.internal.PluginInfo -import com.beust.kobalt.internal.TaskManager -import com.beust.kobalt.internal.build.BuildFile -import com.beust.kobalt.maven.DepFactory +import com.beust.kobalt.maven.DependencyManager import com.beust.kobalt.maven.Http -import com.beust.kobalt.maven.LocalRepo +import com.beust.kobalt.maven.dependency.FileDependency import com.beust.kobalt.misc.* -import com.google.common.collect.HashMultimap -import com.google.inject.Guice import java.io.File -import java.nio.file.Paths -import java.util.* -import java.util.concurrent.TimeUnit -import java.util.concurrent.TimeoutException +import java.net.URLClassLoader import javax.inject.Inject -public fun main(argv: Array) { - val result = mainNoExit(argv) +fun main(argv: Array) { + val result = Main.mainNoExit(argv) if (result != 0) { System.exit(result) } } -private fun parseArgs(argv: Array): Main.RunInfo { - val args = Args() - val result = JCommander(args) - result.parse(*argv) - KobaltLogger.LOG_LEVEL = args.log - return Main.RunInfo(result, args) -} - - -public fun mainNoExit(argv: Array): Int { - val (jc, args) = parseArgs(argv) - Kobalt.INJECTOR = Guice.createInjector(MainModule(args)) - return Kobalt.INJECTOR.getInstance(Main::class.java).run(jc, args, argv) -} - -private class Main @Inject constructor( - val buildFileCompilerFactory: BuildFileCompiler.IFactory, +class Main @Inject constructor( val plugins: Plugins, - val taskManager: TaskManager, val http: Http, val files: KFiles, val executors: KobaltExecutors, - val localRepo: LocalRepo, - val depFactory: DepFactory, - val checkVersions: CheckVersions, - val github: GithubApi, + val dependencyManager: DependencyManager, + val github: GithubApi2, val updateKobalt: UpdateKobalt, val client: KobaltClient, - val server: KobaltServer, val pluginInfo: PluginInfo, - val projectGenerator: ProjectGenerator, - val resolveDependency: ResolveDependency) { + val options: Options) { + + companion object { + fun mainNoExit(argv: Array): Int { + val (jc, args) = parseArgs(argv) + if (args.usage) { + jc.usage() + return 0 + } + if (args.version) { + println("Kobalt ${Kobalt.version}") + return 0 + } + Kobalt.init(MainModule(args, KobaltSettings.readSettingsXml())) + val result = launchMain(Kobalt.INJECTOR.getInstance(Main::class.java), jc, args, argv) + return result + } + + private fun parseArgs(argv: Array): Main.RunInfo { + val args = Args() + val result = JCommander(args) + result.parse(*argv) + KobaltLogger.setLogLevel(args) + return Main.RunInfo(result, args) + } + + /** + * Entry point for tests, which can instantiate their main object with their own module and injector. + */ + fun launchMain(main: Main, jc: JCommander, args: Args, argv: Array) : Int { + return main.run { + val runResult = run(jc, args, argv) + pluginInfo.cleanUp() + executors.shutdown() + runResult + } + } + } data class RunInfo(val jc: JCommander, val args: Args) - private fun addReposFromContributors(project: Project?) = - pluginInfo.repoContributors.forEach { - it.reposFor(project).forEach { - Kobalt.addRepo(it) - } - } + private fun installCommandLinePlugins(args: Args): ClassLoader { + var pluginClassLoader = javaClass.classLoader + val dependencies = arrayListOf() + args.pluginIds?.let { + // We want this call to go to the network if no version was specified, so set localFirst to false + dependencies.addAll(it.split(',').map { dependencyManager.create(it) }) + } + args.pluginJarFiles?.let { + dependencies.addAll(it.split(',').map { FileDependency(it) }) + } + if (dependencies.size > 0) { + val urls = dependencies.map { it.jarFile.get().toURI().toURL() } + pluginClassLoader = URLClassLoader(urls.toTypedArray()) + plugins.installPlugins(dependencies, pluginClassLoader) + } - public fun run(jc: JCommander, args: Args, argv: Array): Int { -// github.uploadRelease("kobalt", "0.101", File("/Users/beust/t/a.zip")) + return pluginClassLoader + } + + fun run(jc: JCommander, args: Args, argv: Array): Int { // - // Add all the repos from repo contributors (at least those that return values without a Project) + // Install plug-ins requested from the command line // - addReposFromContributors(null) - - // - // Add all the plugins read in kobalt-plugin.xml to the Plugins singleton, so that code - // in the build file that calls Plugins.findPlugin() can find them (code in the - // build file do not have access to the KobaltContext). - // - pluginInfo.plugins.forEach { Plugins.addPluginInstance(it) } + installCommandLinePlugins(args) if (args.client) { client.run() return 0 } - var result = 0 + var result = 1 + val latestVersionFuture = github.latestKobaltVersion - val seconds = benchmark { - try { - result = runWithArgs(jc, args, argv) - } catch(ex: KobaltException) { - error("", ex.cause ?: ex) - result = 1 - } finally { - executors.shutdown() - } - } - log(1, if (result != 0) "BUILD FAILED: $result" else "BUILD SUCCESSFUL ($seconds seconds)") - - // Check for new version try { - val latestVersionString = latestVersionFuture.get(1, TimeUnit.SECONDS) - val latestVersion = Versions.toLongVersion(latestVersionString) - val current = Versions.toLongVersion(Kobalt.version) - val distFile = File(KFiles.joinDir(KFiles.distributionsDir, latestVersionString)) - if (latestVersion > current) { - if (distFile.exists()) { - log(1, "**** Version $latestVersionString is installed") - } else { - listOf("", "New Kobalt version available: $latestVersionString", - "To update, run ./kobaltw --update", "").forEach { - log(1, "**** $it") - } - } - } - } catch(ex: TimeoutException) { - log(2, "Didn't get the new version in time, skipping it") + result = runWithArgs(jc, args, argv) + } catch(ex: Throwable) { + error("", ex.cause ?: ex) } - return result - } - - // public fun runTest() { - // val file = File("src\\main\\resources\\META-INF\\plugin.ml") - // } - - private fun runWithArgs(jc: JCommander, args: Args, argv: Array): Int { -// val file = File("/Users/beust/.kobalt/repository/com/google/guava/guava/19.0-rc2/guava-19.0-rc2.pom") -// val md5 = Md5.toMd5(file) -// val md52 = MessageDigest.getInstance("MD5").digest(file.readBytes()).toHexString() - var result = 0 - val p = if (args.buildFile != null) File(args.buildFile) else findBuildFile() - args.buildFile = p.absolutePath - val buildFile = BuildFile(Paths.get(p.absolutePath), p.name) if (!args.update) { - println(AsciiArt.banner + Kobalt.version + "\n") - } - - if (args.init) { - // - // --init: create a new build project and install the wrapper - // Make sure the wrapper won't call us back with --noLaunch - // - com.beust.kobalt.wrapper.Main.main(arrayOf("--noLaunch") + argv) - projectGenerator.run(args) - } else if (args.usage) { - jc.usage() - } else if (args.serverMode) { - server.run() - } else { - if (!buildFile.exists()) { - error(buildFile.path.toFile().path + " does not exist") - } else { - val allProjects = buildFileCompilerFactory.create(listOf(buildFile), pluginInfo) - .compileBuildFiles(args) - - // - // Now that we have projects, add all the repos from repo contributors that need a Project - // - allProjects.forEach { addReposFromContributors(it) } - - // - // Run all their dependencies through the IDependencyInterceptors - // - runClasspathInterceptors(allProjects) - - log(2, "Final list of repos:\n " + Kobalt.repos.joinToString("\n ")) - - if (args.dependency != null) { - // --resolve - resolveDependency.run(args.dependency as String) - } else if (args.tasks) { - // --tasks - displayTasks() - } else if (args.checkVersions) { - // --checkVersions - checkVersions.run(allProjects) - } else if (args.download) { - // -- download - updateKobalt.downloadKobalt() - } else if (args.update) { - // --update - updateKobalt.updateKobalt() - } else { - // - // Launch the build - // - val thisResult = taskManager.runTargets(args.targets, allProjects) - if (result == 0) { - result = thisResult - } - } - } + updateKobalt.checkForNewVersion(latestVersionFuture) } return result } - private fun displayTasks() { - // - // List of tasks, --tasks - // - val tasksByPlugins = HashMultimap.create() - taskManager.annotationTasks.forEach { - tasksByPlugins.put(it.plugin.name, it) - } - val sb = StringBuffer("List of tasks\n") - tasksByPlugins.keySet().forEach { name -> - sb.append("\n " + AsciiArt.horizontalDoubleLine + " $name " - + AsciiArt.horizontalDoubleLine + "\n") - tasksByPlugins[name].distinctBy { - it.name - }.sortedBy { - it.name - }.forEach { task -> - sb.append(" ${task.name}\t\t${task.doc}\n") - } + private fun runWithArgs(jc: JCommander, args: Args, argv: Array): Int { + val p = if (args.buildFile != null) File(args.buildFile) else File(".") + args.buildFile = p.absolutePath + + if (!args.update) { + kobaltLog(1, AsciiArt.banner + Kobalt.version + "\n") } - println(sb.toString()) + return options.run(jc, args, argv) } - private fun runClasspathInterceptors(allProjects: List) { - allProjects.forEach { - runClasspathInterceptors(it, it.compileDependencies) - runClasspathInterceptors(it, it.compileProvidedDependencies) - runClasspathInterceptors(it, it.compileRuntimeDependencies) - runClasspathInterceptors(it, it.testProvidedDependencies) - runClasspathInterceptors(it, it.testDependencies) - } - } - private fun runClasspathInterceptors(project: Project, dependencies: ArrayList) - = with(dependencies) { - val deps = interceptDependencies(project, pluginInfo, this) - clear() - addAll(deps) - } - - private fun interceptDependencies(project: Project, pluginInfo: PluginInfo, - dependencies: ArrayList) : ArrayList { - val result = arrayListOf() - pluginInfo.classpathInterceptors.forEach { - result.addAll(it.intercept(project, dependencies)) - } - return result - } - - private fun findBuildFile() : File { - val deprecatedLocation = File(Constants.BUILD_FILE_NAME) - val result: File = - if (deprecatedLocation.exists()) { - warn(Constants.BUILD_FILE_NAME + " is in a deprecated location, please move it to " - + Constants.BUILD_FILE_DIRECTORY) - deprecatedLocation - } else { - File(KFiles.joinDir(Constants.BUILD_FILE_DIRECTORY, Constants.BUILD_FILE_NAME)) - } - return result - } } diff --git a/src/main/kotlin/com/beust/kobalt/Options.kt b/src/main/kotlin/com/beust/kobalt/Options.kt new file mode 100644 index 00000000..ef4cbfd4 --- /dev/null +++ b/src/main/kotlin/com/beust/kobalt/Options.kt @@ -0,0 +1,210 @@ +package com.beust.kobalt + +import com.beust.jcommander.JCommander +import com.beust.kobalt.api.ITask +import com.beust.kobalt.api.Kobalt +import com.beust.kobalt.api.KobaltContext +import com.beust.kobalt.api.Project +import com.beust.kobalt.app.ProjectFinder +import com.beust.kobalt.app.ProjectGenerator +import com.beust.kobalt.app.Templates +import com.beust.kobalt.app.UpdateKobalt +import com.beust.kobalt.app.remote.KobaltServer +import com.beust.kobalt.internal.PluginInfo +import com.beust.kobalt.internal.TaskManager +import com.beust.kobalt.internal.build.BuildSources +import com.beust.kobalt.internal.build.SingleFileBuildSources +import com.beust.kobalt.misc.CheckVersions +import com.beust.kobalt.misc.kobaltLog +import com.beust.kobalt.wrapper.Main +import com.google.common.collect.HashMultimap +import com.google.inject.Inject +import java.io.File + +/** + * Some options require a build file, others shouldn't have one and some don't care. This + * class captures these requirements. + */ +open class Option(open val enabled: () -> Boolean, open val action: () -> Unit, + open val requireBuildFile: Boolean = true) +class OptionalBuildOption(override val enabled: () -> Boolean, override val action: () -> Unit) + : Option(enabled, action, false) + +class Options @Inject constructor( + val plugins: Plugins, + val checkVersions: CheckVersions, + val projectGenerator: ProjectGenerator, + val pluginInfo: PluginInfo, + val serverFactory: KobaltServer.IFactory, + val updateKobalt: UpdateKobalt, + val projectFinder: ProjectFinder, + val taskManager: TaskManager, + val resolveDependency: ResolveDependency + ) { + + fun run(jc: JCommander, args: Args, argv: Array): Int { + val p = if (args.buildFile != null) File(args.buildFile) else File(".") +// val buildFile = BuildFile(Paths.get(p.absolutePath), p.name) + val buildSources = if (p.isDirectory) BuildSources(p.absoluteFile) else SingleFileBuildSources(p) + val pluginClassLoader = javaClass.classLoader + + // + // Attempt to parse the build file in order to correctly set up repos, plug-ins, etc... + // If the build file can't be parsed, don't give up just yet since some options don't need + // a correct build file to work. + // + var buildError: Throwable? = null + val allProjects = + try { + projectFinder.initForBuildFile(buildSources, args).projects + } catch(ex: Exception) { + buildError = ex + listOf() + } + + fun runIfSuccessfulBuild(buildError: Throwable?, action: () -> Unit) { + buildError?.let { throw it } + action() + } + + // Modify `args` with options found in buildScript { kobaltOptions(...) }, if any + addOptionsFromBuild(args, Kobalt.optionsFromBuild) + + val options = listOf