Hello community, here is the log from the commit of package gradle for openSUSE:Factory checked in at 2019-12-09 21:36:22 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/gradle (Old) and /work/SRC/openSUSE:Factory/.gradle.new.4691 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "gradle" Mon Dec 9 21:36:22 2019 rev:11 rq:755237 version:4.4.1 Changes: -------- --- /work/SRC/openSUSE:Factory/gradle/gradle.changes 2019-11-28 13:50:45.390697438 +0100 +++ /work/SRC/openSUSE:Factory/.gradle.new.4691/gradle.changes 2019-12-09 21:36:37.774064926 +0100 @@ -1,0 +2,21 @@ +Mon Dec 9 12:38:32 UTC 2019 - Fridrich Strba <[email protected]> + +- Modified patch: + * gradle-4.4.1-asm7.patch + + Rediff and use ASM7 api instead of ASM6, since we are using + objectweb-asm 7.2 +- Added patches: + * cast-estimated-runtime-to-long.patch + + estimatedRuntime must be cast to long otherwise gradle build + fails with "Cannot assign value of type java.math.BigDecimal + to variable of type long". + * java11-compatibility.patch + + Fixes the compatibility with Java 11. This is backport of + upstream changes in 4.8 + * java8-compatibility.patch + + Keep compatibility with Java 8 by avoiding to use Java 9+ + APIs + * remove-timestamps.patch + + Avoid timestamps and thus irreproducible builds + +------------------------------------------------------------------- New: ---- cast-estimated-runtime-to-long.patch java11-compatibility.patch java8-compatibility.patch remove-timestamps.patch ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ gradle.spec ++++++ --- /var/tmp/diff_new_pack.9XjKPe/_old 2019-12-09 21:36:39.086064410 +0100 +++ /var/tmp/diff_new_pack.9XjKPe/_new 2019-12-09 21:36:39.086064410 +0100 @@ -56,6 +56,11 @@ Patch200: gradle-4.4.1-asm7.patch +Patch300: java11-compatibility.patch +Patch301: java8-compatibility.patch +Patch302: remove-timestamps.patch +Patch303: cast-estimated-runtime-to-long.patch + BuildRequires: gradle-local BuildRequires: xmvn-subst @@ -202,7 +207,6 @@ #!BuildRequires: groovy-lib sbt gpars # But we want to avoid cycle with oneself #!BuildRequires: gradle-bootstrap -BuildConflicts: java-devel >= 9 Obsoletes: %{name}-bootstrap @@ -356,11 +360,11 @@ %build export LANG=en_US.UTF8 +export JAVA_OPTS="-Xmx2g -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8" # Disables parallel build and daemon mode rm gradle.properties gradle-local --offline --no-daemon install xmvnInstall \ - -Pgradle_installPath=$PWD/inst \ - -PfinalRelease -Dbuild.number="%{?fedora:Fedora }%{?rhel:Red Hat }%{version}-%{release}" + -Pgradle_installPath=$PWD/inst -PfinalRelease # manpage build mkdir man ++++++ all-released-versions.json ++++++ --- /var/tmp/diff_new_pack.9XjKPe/_old 2019-12-09 21:36:39.154064382 +0100 +++ /var/tmp/diff_new_pack.9XjKPe/_new 2019-12-09 21:36:39.154064382 +0100 @@ -1,6 +1,6 @@ [ { - "version" : "6.0.1-20191128003021+0000", - "buildTime" : "20191128003021+0000", + "version" : "6.0.1-20191209004608+0000", + "buildTime" : "20191209004608+0000", "current" : false, "snapshot" : true, "nightly" : false, @@ -9,12 +9,12 @@ "rcFor" : "", "milestoneFor" : "", "broken" : false, - "downloadUrl" : "https://services.gradle.org/distributions-snapshots/gradle-6.0.1-20191128003021+0000-bin.zip";, - "checksumUrl" : "https://services.gradle.org/distributions-snapshots/gradle-6.0.1-20191128003021+0000-bin.zip.sha256";, - "wrapperChecksumUrl" : "https://services.gradle.org/distributions-snapshots/gradle-6.0.1-20191128003021+0000-wrapper.jar.sha256"; + "downloadUrl" : "https://services.gradle.org/distributions-snapshots/gradle-6.0.1-20191209004608+0000-bin.zip";, + "checksumUrl" : "https://services.gradle.org/distributions-snapshots/gradle-6.0.1-20191209004608+0000-bin.zip.sha256";, + "wrapperChecksumUrl" : "https://services.gradle.org/distributions-snapshots/gradle-6.0.1-20191209004608+0000-wrapper.jar.sha256"; }, { - "version" : "6.1-20191127232441+0000", - "buildTime" : "20191127232441+0000", + "version" : "6.1-20191208230017+0000", + "buildTime" : "20191208230017+0000", "current" : false, "snapshot" : true, "nightly" : true, @@ -23,9 +23,37 @@ "rcFor" : "", "milestoneFor" : "", "broken" : false, - "downloadUrl" : "https://services.gradle.org/distributions-snapshots/gradle-6.1-20191127232441+0000-bin.zip";, - "checksumUrl" : "https://services.gradle.org/distributions-snapshots/gradle-6.1-20191127232441+0000-bin.zip.sha256";, - "wrapperChecksumUrl" : "https://services.gradle.org/distributions-snapshots/gradle-6.1-20191127232441+0000-wrapper.jar.sha256"; + "downloadUrl" : "https://services.gradle.org/distributions-snapshots/gradle-6.1-20191208230017+0000-bin.zip";, + "checksumUrl" : "https://services.gradle.org/distributions-snapshots/gradle-6.1-20191208230017+0000-bin.zip.sha256";, + "wrapperChecksumUrl" : "https://services.gradle.org/distributions-snapshots/gradle-6.1-20191208230017+0000-wrapper.jar.sha256"; +}, { + "version" : "6.1-milestone-3", + "buildTime" : "20191203141333+0000", + "current" : false, + "snapshot" : false, + "nightly" : false, + "releaseNightly" : false, + "activeRc" : false, + "rcFor" : "", + "milestoneFor" : "6.1", + "broken" : false, + "downloadUrl" : "https://services.gradle.org/distributions/gradle-6.1-milestone-3-bin.zip";, + "checksumUrl" : "https://services.gradle.org/distributions/gradle-6.1-milestone-3-bin.zip.sha256";, + "wrapperChecksumUrl" : "https://services.gradle.org/distributions/gradle-6.1-milestone-3-wrapper.jar.sha256"; +}, { + "version" : "6.1-milestone-2", + "buildTime" : "20191128101755+0000", + "current" : false, + "snapshot" : false, + "nightly" : false, + "releaseNightly" : false, + "activeRc" : false, + "rcFor" : "", + "milestoneFor" : "6.1", + "broken" : false, + "downloadUrl" : "https://services.gradle.org/distributions/gradle-6.1-milestone-2-bin.zip";, + "checksumUrl" : "https://services.gradle.org/distributions/gradle-6.1-milestone-2-bin.zip.sha256";, + "wrapperChecksumUrl" : "https://services.gradle.org/distributions/gradle-6.1-milestone-2-wrapper.jar.sha256"; }, { "version" : "6.1-milestone-1", "buildTime" : "20191120132405+0000", ++++++ cast-estimated-runtime-to-long.patch ++++++ --- a/buildSrc/src/main/groovy/org/gradle/testing/DistributedPerformanceTest.groovy +++ b/buildSrc/src/main/groovy/org/gradle/testing/DistributedPerformanceTest.groovy @@ -130,7 +130,7 @@ def scenarios = scenarioList.readLines() .collect { line -> def parts = Splitter.on(';').split(line).toList() - new Scenario(id : parts[0], estimatedRuntime: new BigDecimal(parts[1]), templates: parts.subList(2, parts.size())) + new Scenario(id : parts[0], estimatedRuntime: new BigDecimal(parts[1]) as long, templates: parts.subList(2, parts.size())) } .sort{ -it.estimatedRuntime } ++++++ gradle-4.4.1-asm7.patch ++++++ --- /var/tmp/diff_new_pack.9XjKPe/_old 2019-12-09 21:36:39.166064377 +0100 +++ /var/tmp/diff_new_pack.9XjKPe/_new 2019-12-09 21:36:39.166064377 +0100 @@ -1,5 +1,96 @@ ---- gradle-4.4.1/subprojects/core/src/main/java/org/gradle/process/internal/worker/child/WorkerProcessClassPathProvider.java 2017-12-20 09:05:14.000000000 +0100 -+++ gradle-4.4.1/subprojects/core/src/main/java/org/gradle/process/internal/worker/child/WorkerProcessClassPathProvider.java 2019-11-25 12:06:16.258595142 +0100 +--- a/subprojects/core/src/main/java/org/gradle/api/internal/tasks/compile/ApiMemberSelector.java ++++ b/subprojects/core/src/main/java/org/gradle/api/internal/tasks/compile/ApiMemberSelector.java +@@ -48,7 +48,7 @@ + private boolean thisClassIsPrivateInnerClass; + + public ApiMemberSelector(String className, ClassVisitor apiMemberAdapter, boolean apiIncludesPackagePrivateMembers) { +- super(ASM6); ++ super(ASM7); + this.className = className; + this.apiMemberAdapter = apiMemberAdapter; + this.apiIncludesPackagePrivateMembers = apiIncludesPackagePrivateMembers; +@@ -166,7 +166,7 @@ + if (isCandidateApiMember(access, apiIncludesPackagePrivateMembers) || ("<init>".equals(name) && isInnerClass)) { + final MethodMember methodMember = new MethodMember(access, name, desc, signature, exceptions); + methods.add(methodMember); +- return new MethodVisitor(ASM6) { ++ return new MethodVisitor(ASM7) { + @Override + public AnnotationVisitor visitAnnotation(String desc, boolean visible) { + AnnotationMember ann = new AnnotationMember(desc, visible); +@@ -191,7 +191,7 @@ + Object keepValue = (access & ACC_STATIC) == ACC_STATIC && ((access & ACC_FINAL) == ACC_FINAL) ? value : null; + final FieldMember fieldMember = new FieldMember(access, name, signature, desc, keepValue); + fields.add(fieldMember); +- return new FieldVisitor(ASM6) { ++ return new FieldVisitor(ASM7) { + @Override + public AnnotationVisitor visitAnnotation(String desc, boolean visible) { + AnnotationMember ann = new AnnotationMember(desc, visible); +--- a/subprojects/core/src/main/java/org/gradle/api/internal/tasks/compile/MethodStubbingApiMemberAdapter.java ++++ b/subprojects/core/src/main/java/org/gradle/api/internal/tasks/compile/MethodStubbingApiMemberAdapter.java +@@ -37,7 +37,7 @@ + private String internalClassName; + + public MethodStubbingApiMemberAdapter(ClassWriter cv) { +- super(ASM6, cv); ++ super(ASM7, cv); + } + + @Override +--- a/subprojects/core/src/main/java/org/gradle/api/internal/tasks/compile/SortingAnnotationVisitor.java ++++ b/subprojects/core/src/main/java/org/gradle/api/internal/tasks/compile/SortingAnnotationVisitor.java +@@ -21,7 +21,7 @@ + + import java.util.List; + +-import static org.objectweb.asm.Opcodes.ASM6; ++import static org.objectweb.asm.Opcodes.ASM7; + + public class SortingAnnotationVisitor extends AnnotationVisitor { + +@@ -33,7 +33,7 @@ + private String arrayValueName; + + public SortingAnnotationVisitor(AnnotationMember parentAnnotation, AnnotationVisitor av) { +- super(ASM6, av); ++ super(ASM7, av); + this.annotation = parentAnnotation; + } + +--- a/subprojects/core/src/main/java/org/gradle/groovy/scripts/internal/FileCacheBackedScriptClassCompiler.java ++++ b/subprojects/core/src/main/java/org/gradle/groovy/scripts/internal/FileCacheBackedScriptClassCompiler.java +@@ -215,7 +215,7 @@ + private final String contentHash; + + public BuildScriptRemapper(ClassVisitor cv, ScriptSource source, String originalClassName, String contentHash) { +- super(ASM6, cv); ++ super(ASM7, cv); + this.scriptSource = source; + this.originalClassName = originalClassName; + this.contentHash = contentHash; +@@ -338,7 +338,7 @@ + class MethodRenamer extends MethodVisitor { + + public MethodRenamer(final MethodVisitor mv) { +- super(ASM6, mv); ++ super(ASM7, mv); + } + + public void visitTypeInsn(int i, String name) { +--- a/subprojects/core/src/main/java/org/gradle/initialization/MixInLegacyTypesClassLoader.java ++++ b/subprojects/core/src/main/java/org/gradle/initialization/MixInLegacyTypesClassLoader.java +@@ -122,7 +122,7 @@ + private Set<String> booleanIsGetters = new HashSet<String>(); + + TransformingAdapter(ClassVisitor cv) { +- super(Opcodes.ASM6, cv); ++ super(Opcodes.ASM7, cv); + } + + @Override +--- a/subprojects/core/src/main/java/org/gradle/process/internal/worker/child/WorkerProcessClassPathProvider.java ++++ b/subprojects/core/src/main/java/org/gradle/process/internal/worker/child/WorkerProcessClassPathProvider.java @@ -44,8 +44,8 @@ import org.objectweb.asm.ClassVisitor; import org.objectweb.asm.ClassWriter; @@ -19,3 +110,191 @@ classReader.accept(remappingVisitor, ClassReader.EXPAND_FRAMES); byte[] remappedClass = classWriter.toByteArray(); String remappedClassName = remapper.map(internalName).concat(".class"); +--- a/subprojects/dependency-management/src/main/java/org/gradle/api/internal/runtimeshaded/RuntimeShadedJarCreator.java ++++ b/subprojects/dependency-management/src/main/java/org/gradle/api/internal/runtimeshaded/RuntimeShadedJarCreator.java +@@ -412,7 +412,7 @@ + + @Override + public MethodVisitor visitMethod(int access, final String name, final String desc, String signature, String[] exceptions) { +- return new MethodVisitor(Opcodes.ASM6, super.visitMethod(access, name, desc, signature, exceptions)) { ++ return new MethodVisitor(Opcodes.ASM7, super.visitMethod(access, name, desc, signature, exceptions)) { + @Override + public void visitLdcInsn(Object cst) { + if (cst instanceof String) { +--- a/subprojects/internal-testing/src/main/groovy/org/gradle/test/fixtures/file/ClassFile.groovy ++++ b/subprojects/internal-testing/src/main/groovy/org/gradle/test/fixtures/file/ClassFile.groovy +@@ -34,7 +34,7 @@ + } + + ClassFile(InputStream inputStream) { +- def methodVisitor = new MethodVisitor(Opcodes.ASM6) { ++ def methodVisitor = new MethodVisitor(Opcodes.ASM7) { + @Override + void visitLocalVariable(String name, String desc, String signature, Label start, Label end, int index) { + hasLocalVars = true +@@ -45,7 +45,7 @@ + hasLineNumbers = true + } + } +- def visitor = new ClassVisitor(Opcodes.ASM6) { ++ def visitor = new ClassVisitor(Opcodes.ASM7) { + @Override + void visit(int version, int access, String name, String signature, String superName, String[] interfaces) { + classFileVersion = version +--- a/subprojects/language-groovy/src/main/java/org/gradle/api/internal/tasks/compile/GroovyCompileTransformingClassLoader.java ++++ b/subprojects/language-groovy/src/main/java/org/gradle/api/internal/tasks/compile/GroovyCompileTransformingClassLoader.java +@@ -65,7 +65,7 @@ + private boolean found; + + private AnnotationDetector() { +- super(Opcodes.ASM6); ++ super(Opcodes.ASM7); + } + + @Override +@@ -79,7 +79,7 @@ + + private static class TransformingAdapter extends ClassVisitor { + public TransformingAdapter(ClassWriter classWriter) { +- super(Opcodes.ASM6, classWriter); ++ super(Opcodes.ASM7, classWriter); + } + + @Override +@@ -94,13 +94,13 @@ + private final List<String> names = new ArrayList<String>(); + + public AnnotationTransformingVisitor(AnnotationVisitor annotationVisitor) { +- super(Opcodes.ASM6, annotationVisitor); ++ super(Opcodes.ASM7, annotationVisitor); + } + + @Override + public AnnotationVisitor visitArray(String name) { + if (name.equals("classes")) { +- return new AnnotationVisitor(Opcodes.ASM6){ ++ return new AnnotationVisitor(Opcodes.ASM7){ + @Override + public void visit(String name, Object value) { + Type type = (Type) value; +@@ -108,7 +108,7 @@ + } + }; + } else if (name.equals("value")) { +- return new AnnotationVisitor(Opcodes.ASM6) { ++ return new AnnotationVisitor(Opcodes.ASM7) { + @Override + public void visit(String name, Object value) { + String type = (String) value; +--- a/subprojects/language-java/src/main/java/org/gradle/api/internal/tasks/compile/incremental/asm/ClassDependenciesVisitor.java ++++ b/subprojects/language-java/src/main/java/org/gradle/api/internal/tasks/compile/incremental/asm/ClassDependenciesVisitor.java +@@ -35,7 +35,7 @@ + + public class ClassDependenciesVisitor extends ClassVisitor { + +- private final static int API = Opcodes.ASM6; ++ private final static int API = Opcodes.ASM7; + private static final MethodVisitor EMPTY_VISITOR = new MethodVisitor(API, null) { + }; + +--- a/subprojects/launcher/src/main/java/org/gradle/tooling/internal/provider/serialization/ClientSidePayloadClassLoaderFactory.java ++++ b/subprojects/launcher/src/main/java/org/gradle/tooling/internal/provider/serialization/ClientSidePayloadClassLoaderFactory.java +@@ -97,14 +97,14 @@ + private boolean found; + + private AnnotationDetector() { +- super(Opcodes.ASM6); ++ super(Opcodes.ASM7); + } + + public AnnotationVisitor visitAnnotation(String desc, boolean visible) { + if (desc.equals(ANNOTATION_DESCRIPTOR)) { + found = true; + } +- return new AnnotationVisitor(Opcodes.ASM6) { ++ return new AnnotationVisitor(Opcodes.ASM7) { + + @Override + public void visit(String name, Object value) { +@@ -120,7 +120,7 @@ + private final String mixInInterface; + + public TransformingAdapter(ClassWriter classWriter, String mixInInterface) { +- super(Opcodes.ASM6, classWriter); ++ super(Opcodes.ASM7, classWriter); + this.mixInInterface = mixInInterface; + } + +--- a/subprojects/platform-jvm/src/test/groovy/org/gradle/jvm/tasks/api/internal/ApiClassExtractorTest.groovy ++++ b/subprojects/platform-jvm/src/test/groovy/org/gradle/jvm/tasks/api/internal/ApiClassExtractorTest.groovy +@@ -286,7 +286,7 @@ + when: + def cr = new ClassReader(api.extractApiClassFrom(api.classes.A)) + def stubVersion = 0 +- cr.accept(new ClassVisitor(Opcodes.ASM6) { ++ cr.accept(new ClassVisitor(Opcodes.ASM7) { + @Override + void visit(int version, int access, String name, String signature, String superName, String[] interfaces) { + stubVersion = version +@@ -455,7 +455,7 @@ + when: + def apiClassBytes = api.extractApiClassFrom(api.classes['com.acme.A']) + def cr = new ClassReader(apiClassBytes) +- cr.accept(new ClassVisitor(Opcodes.ASM6) { ++ cr.accept(new ClassVisitor(Opcodes.ASM7) { + @Override + void visitSource(String source, String debug) { + super.visitSource(source, debug) +@@ -469,7 +469,7 @@ + + @Override + MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { +- new MethodVisitor(Opcodes.ASM6) { ++ new MethodVisitor(Opcodes.ASM7) { + @Override + void visitLineNumber(int line, Label start) { + throw new AssertionError("Should not produce any line number information but " + +--- a/subprojects/plugin-development/src/main/java/org/gradle/plugin/devel/tasks/ValidateTaskProperties.java ++++ b/subprojects/plugin-development/src/main/java/org/gradle/plugin/devel/tasks/ValidateTaskProperties.java +@@ -353,7 +353,7 @@ + private final Collection<String> classNames; + + public TaskNameCollectorVisitor(Collection<String> classNames) { +- super(Opcodes.ASM6); ++ super(Opcodes.ASM7); + this.classNames = classNames; + } + +--- a/subprojects/testing-jvm/src/main/java/org/gradle/api/internal/tasks/testing/detection/TestClassVisitor.java ++++ b/subprojects/testing-jvm/src/main/java/org/gradle/api/internal/tasks/testing/detection/TestClassVisitor.java +@@ -27,7 +27,7 @@ + protected final TestFrameworkDetector detector; + + protected TestClassVisitor(TestFrameworkDetector detector) { +- super(Opcodes.ASM6); ++ super(Opcodes.ASM7); + if (detector == null) { + throw new IllegalArgumentException("detector == null!"); + } +--- a/subprojects/testing-jvm/src/main/java/org/gradle/api/internal/tasks/testing/junit/JUnitTestMethodDetecter.java ++++ b/subprojects/testing-jvm/src/main/java/org/gradle/api/internal/tasks/testing/junit/JUnitTestMethodDetecter.java +@@ -24,7 +24,7 @@ + private final JUnitTestClassDetecter testClassDetecter; + + JUnitTestMethodDetecter(JUnitTestClassDetecter testClassDetecter) { +- super(Opcodes.ASM6); ++ super(Opcodes.ASM7); + this.testClassDetecter = testClassDetecter; + } + +--- a/subprojects/testing-jvm/src/main/java/org/gradle/api/internal/tasks/testing/testng/TestNGTestMethodDetecter.java ++++ b/subprojects/testing-jvm/src/main/java/org/gradle/api/internal/tasks/testing/testng/TestNGTestMethodDetecter.java +@@ -27,7 +27,7 @@ + private final Set<String> testMethodAnnotations = new HashSet<String>(); + + public TestNGTestMethodDetecter(TestNGTestClassDetecter testClassDetecter) { +- super(Opcodes.ASM6); ++ super(Opcodes.ASM7); + this.testClassDetecter = testClassDetecter; + testMethodAnnotations.add("Lorg/testng/annotations/Test;"); + testMethodAnnotations.add("Lorg/testng/annotations/BeforeSuite;"); ++++++ java11-compatibility.patch ++++++ --- a/subprojects/base-services/src/main/java/org/gradle/internal/classloader/ClassLoaderUtils.java +++ b/subprojects/base-services/src/main/java/org/gradle/internal/classloader/ClassLoaderUtils.java @@ -15,51 +15,41 @@ */ package org.gradle.internal.classloader; +import org.gradle.api.JavaVersion; import org.gradle.internal.Cast; import org.gradle.internal.UncheckedException; import org.gradle.internal.concurrent.CompositeStoppable; import org.gradle.internal.reflect.JavaMethod; -import org.gradle.internal.reflect.JavaReflectionUtil; -import sun.misc.Unsafe; import javax.annotation.Nullable; import java.io.IOException; -import java.lang.reflect.Field; -import java.net.MalformedURLException; +import java.lang.invoke.MethodHandle; +import java.lang.invoke.MethodHandles; +import java.lang.invoke.MethodType; import java.net.URL; import java.net.URLConnection; -public abstract class ClassLoaderUtils { - - private static final Unsafe UNSAFE; - - static { - try { - Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe"); - theUnsafe.setAccessible(true); - UNSAFE = (Unsafe) theUnsafe.get(null); - } catch (NoSuchFieldException e) { - throw new RuntimeException(e); - } catch (IllegalAccessException e) { - throw new RuntimeException(e); - } - } +import static org.gradle.internal.reflect.JavaReflectionUtil.method; +import static org.gradle.internal.reflect.JavaReflectionUtil.staticMethod; +public abstract class ClassLoaderUtils { + private static final ClassDefiner CLASS_DEFINER; private static final JavaMethod<ClassLoader, Package[]> GET_PACKAGES_METHOD; private static final JavaMethod<ClassLoader, Package> GET_PACKAGE_METHOD; static { + CLASS_DEFINER = JavaVersion.current().isJava9Compatible() ? new LookupClassDefiner() : new ReflectionClassDefiner(); GET_PACKAGES_METHOD = getMethodWithFallback(Package[].class, new Class[0], "getDefinedPackages", "getPackages"); - GET_PACKAGE_METHOD = getMethodWithFallback(Package.class, new Class[] {String.class}, "getDefinedPackage", "getPackage"); + GET_PACKAGE_METHOD = getMethodWithFallback(Package.class, new Class[]{String.class}, "getDefinedPackage", "getPackage"); } private static <T> JavaMethod<ClassLoader, T> getMethodWithFallback(Class<T> clazz, Class<?>[] params, String firstChoice, String fallback) { JavaMethod<ClassLoader, T> method; try { - method = JavaReflectionUtil.method(ClassLoader.class, clazz, firstChoice, params); + method = method(ClassLoader.class, clazz, firstChoice, params); } catch (Throwable e) { // We must not be on Java 9 where the getDefinedPackages() method exists. Fall back to getPackages() - method = JavaReflectionUtil.method(ClassLoader.class, clazz, fallback, params); + method = method(ClassLoader.class, clazz, fallback, params); } return method; } @@ -85,8 +75,6 @@ public static void disableUrlConnectionCaching() { URL url = new URL("jar:file://valid_jar_url_syntax.jar!/"); URLConnection urlConnection = url.openConnection(); urlConnection.setDefaultUseCaches(false); - } catch (MalformedURLException e) { - throw UncheckedException.throwAsUncheckedException(e); } catch (IOException e) { throw UncheckedException.throwAsUncheckedException(e); } @@ -101,6 +89,63 @@ public static void disableUrlConnectionCaching() { } public static <T> Class<T> define(ClassLoader targetClassLoader, String className, byte[] clazzBytes) { - return Cast.uncheckedCast(UNSAFE.defineClass(className, clazzBytes, 0, clazzBytes.length, targetClassLoader, null)); + return CLASS_DEFINER.defineClass(targetClassLoader, className, clazzBytes); + } + + private interface ClassDefiner { + <T> Class<T> defineClass(ClassLoader classLoader, String className, byte[] classBytes); + } + + private static class ReflectionClassDefiner implements ClassDefiner { + private final JavaMethod<ClassLoader, Class> defineClassMethod; + + private ReflectionClassDefiner() { + defineClassMethod = method(ClassLoader.class, Class.class, "defineClass", String.class, byte[].class, int.class, int.class); + } + + @Override + public <T> Class<T> defineClass(ClassLoader classLoader, String className, byte[] classBytes) { + return Cast.uncheckedCast(defineClassMethod.invoke(classLoader, className, classBytes, 0, classBytes.length)); + } + } + + private static class LookupClassDefiner implements ClassDefiner { + private final Class methodHandlesLookupClass; + private final JavaMethod methodHandlesLookup; + private final JavaMethod methodHandlesPrivateLookupIn; + private final JavaMethod lookupFindVirtual; + private final MethodType defineClassMethodType; + + private LookupClassDefiner() { + try { + methodHandlesLookupClass = Class.forName("java.lang.invoke.MethodHandles$Lookup"); + } catch (ClassNotFoundException e) { + throw new RuntimeException(e); + } + methodHandlesLookup = staticMethod(MethodHandles.class, methodHandlesLookupClass, "lookup"); + methodHandlesPrivateLookupIn = staticMethod(MethodHandles.class, methodHandlesLookupClass, "privateLookupIn", Class.class, methodHandlesLookupClass); + lookupFindVirtual = method(methodHandlesLookupClass, MethodHandle.class, "findVirtual", Class.class, String.class, MethodType.class); + defineClassMethodType = MethodType.methodType(Class.class, new Class[]{String.class, byte[].class, int.class, int.class}); + } + + /* + This method is equivalent to the following code but use reflection to compile on Java 7: + + MethodHandles.Lookup baseLookup = MethodHandles.lookup(); + MethodHandles.Lookup lookup = MethodHandles.privateLookupIn(ClassLoader.class, baseLookup); + MethodHandle defineClassMethodHandle = lookup.findVirtual(ClassLoader.class, "defineClass", defineClassMethodType); + handle.bindTo(classLoader).invokeWithArguments(className, classBytes, 0, classBytes.length)); + */ + @Override + public <T> Class<T> defineClass(ClassLoader classLoader, String className, byte[] classBytes) { + Object baseLookup = methodHandlesLookup.invoke(null); + Object lookup = methodHandlesPrivateLookupIn.invoke(null, ClassLoader.class, baseLookup); + MethodHandle defineClassMethodHandle = (MethodHandle) lookupFindVirtual.invoke(lookup, ClassLoader.class, "defineClass", defineClassMethodType); + try { + return Cast.uncheckedCast(defineClassMethodHandle.bindTo(classLoader).invokeWithArguments(className, classBytes, 0, classBytes.length)); + } catch (Throwable throwable) { + throw new RuntimeException(throwable); + } + } } } --- a/subprojects/core/src/main/java/org/gradle/process/internal/worker/child/WorkerProcessClassPathProvider.java +++ b/subprojects/core/src/main/java/org/gradle/process/internal/worker/child/WorkerProcessClassPathProvider.java @@ -18,6 +18,7 @@ import org.gradle.api.Action; import org.gradle.api.GradleException; +import org.gradle.api.JavaVersion; import org.gradle.api.internal.ClassPathProvider; import org.gradle.api.specs.Spec; import org.gradle.cache.CacheRepository; @@ -57,7 +58,9 @@ import java.io.InputStream; import java.net.URL; import java.util.Arrays; +import java.util.HashSet; import java.util.List; +import java.util.Set; import java.util.zip.ZipEntry; import java.util.zip.ZipOutputStream; @@ -116,32 +119,9 @@ public void execute(PersistentCache cache) { try { File jarFile = jarFile(cache); LOGGER.debug("Generating worker process classes to {}.", jarFile); - - // TODO - calculate this list of classes dynamically - List<Class<?>> classes = Arrays.asList( - GradleWorkerMain.class, - BootstrapSecurityManager.class, - EncodedStream.EncodedInput.class, - ClassLoaderUtils.class, - FilteringClassLoader.class, - FilteringClassLoader.Spec.class, - ClassLoaderHierarchy.class, - ClassLoaderVisitor.class, - ClassLoaderSpec.class, - SystemClassLoaderSpec.class, - JavaReflectionUtil.class, - JavaMethod.class, - GradleException.class, - NoSuchPropertyException.class, - NoSuchMethodException.class, - UncheckedException.class, - PropertyAccessor.class, - PropertyMutator.class, - Factory.class, - Spec.class); ZipOutputStream outputStream = new ZipOutputStream(new BufferedOutputStream(new FileOutputStream(jarFile))); try { - for (Class<?> classToMap : classes) { + for (Class<?> classToMap : getClassesForWorkerJar()) { remapClass(classToMap, outputStream); } } finally { @@ -152,6 +132,37 @@ public void execute(PersistentCache cache) { } } + private Set<Class<?>> getClassesForWorkerJar() { + // TODO - calculate this list of classes dynamically + List<Class<?>> classes = Arrays.asList( + GradleWorkerMain.class, + BootstrapSecurityManager.class, + EncodedStream.EncodedInput.class, + ClassLoaderUtils.class, + FilteringClassLoader.class, + ClassLoaderHierarchy.class, + ClassLoaderVisitor.class, + ClassLoaderSpec.class, + SystemClassLoaderSpec.class, + JavaReflectionUtil.class, + JavaMethod.class, + GradleException.class, + NoSuchPropertyException.class, + NoSuchMethodException.class, + UncheckedException.class, + PropertyAccessor.class, + PropertyMutator.class, + Factory.class, + Spec.class, + JavaVersion.class); + Set<Class<?>> result = new HashSet<Class<?>>(classes); + for (Class<?> klass : classes) { + result.addAll(Arrays.asList(klass.getDeclaredClasses())); + } + + return result; + } + private void remapClass(Class<?> classToMap, ZipOutputStream jar) throws IOException { String internalName = Type.getInternalName(classToMap); String resourceName = internalName.concat(".class"); --- a/subprojects/base-services/src/main/java/org/gradle/api/JavaVersion.java +++ b/subprojects/base-services/src/main/java/org/gradle/api/JavaVersion.java @@ -17,25 +17,26 @@ import com.google.common.annotations.VisibleForTesting; -import java.util.regex.Matcher; -import java.util.regex.Pattern; +import java.util.ArrayList; +import java.util.List; /** * An enumeration of Java versions. + * Before 9: http://www.oracle.com/technetwork/java/javase/versioning-naming-139433.html + * 9+: http://openjdk.java.net/jeps/223 */ public enum JavaVersion { - VERSION_1_1(false), VERSION_1_2(false), VERSION_1_3(false), VERSION_1_4(false), - // starting from here versions are 1_ but their official name is "Java 6", "Java 7", ... - VERSION_1_5(true), VERSION_1_6(true), VERSION_1_7(true), VERSION_1_8(true), VERSION_1_9(true), VERSION_1_10(true); + VERSION_1_1, VERSION_1_2, VERSION_1_3, VERSION_1_4, + VERSION_1_5, VERSION_1_6, VERSION_1_7, VERSION_1_8, + VERSION_1_9, VERSION_1_10, VERSION_11, VERSION_HIGHER; + // Since Java 9, version should be X instead of 1.X + // However, to keep backward compatibility, we change from 11 + private static final int FIRST_MAJOR_VERSION_ORDINAL = 10; private static JavaVersion currentJavaVersion; - private final boolean hasMajorVersion; private final String versionName; - private final String majorVersion; - JavaVersion(boolean hasMajorVersion) { - this.hasMajorVersion = hasMajorVersion; - this.versionName = name().substring("VERSION_".length()).replace('_', '.'); - this.majorVersion = name().substring(10); + JavaVersion() { + this.versionName = ordinal() >= FIRST_MAJOR_VERSION_ORDINAL ? getMajorVersion() : "1." + getMajorVersion(); } /** @@ -54,22 +55,18 @@ } String name = value.toString(); - Matcher matcher = Pattern.compile("(\\d{1,2})(\\D.+)?").matcher(name); - if (matcher.matches()) { - int index = Integer.parseInt(matcher.group(1)) - 1; - if (index > 0 && index < values().length && values()[index].hasMajorVersion) { - return values()[index]; - } - } - matcher = Pattern.compile("1\\.(\\d{1,2})(\\D.+)?").matcher(name); - if (matcher.matches()) { - int versionIdx = Integer.parseInt(matcher.group(1)) - 1; - if (versionIdx >= 0 && versionIdx < values().length) { - return values()[versionIdx]; - } + int firstNonVersionCharIndex = findFirstNonVersionCharIndex(name); + + String[] versionStrings = name.substring(0, firstNonVersionCharIndex).split("\\."); + List<Integer> versions = convertToNumber(name, versionStrings); + + if (isLegacyVersion(versions)) { + assertTrue(name, versions.get(1) > 0); + return getVersionForMajor(versions.get(1)); + } else { + return getVersionForMajor(versions.get(0)); } - throw new IllegalArgumentException(String.format("Could not determine java version from '%s'.", name)); } /** @@ -90,11 +87,7 @@ } public static JavaVersion forClassVersion(int classVersion) { - int index = classVersion - 45; //class file versions: 1.1 == 45, 1.2 == 46... - if (index >= 0 && index < values().length) { - return values()[index]; - } - throw new IllegalArgumentException(String.format("Could not determine java version from '%d'.", classVersion)); + return getVersionForMajor(classVersion - 44); //class file versions: 1.1 == 45, 1.2 == 46... } public static JavaVersion forClass(byte[] classData) { @@ -116,18 +109,22 @@ return this == VERSION_1_7; } - private boolean isJava8() { + public boolean isJava8() { return this == VERSION_1_8; } - private boolean isJava9() { + public boolean isJava9() { return this == VERSION_1_9; } - private boolean isJava10() { + public boolean isJava10() { return this == VERSION_1_10; } + public boolean isJava11() { + return this == VERSION_11; + } + public boolean isJava5Compatible() { return this.compareTo(VERSION_1_5) >= 0; } @@ -148,21 +145,69 @@ return this.compareTo(VERSION_1_9) >= 0; } - @Incubating public boolean isJava10Compatible() { return this.compareTo(VERSION_1_10) >= 0; } - @Override - public String toString() { - return getName(); + public boolean isJava11Compatible() { + return this.compareTo(VERSION_11) >= 0; } - private String getName() { + @Override + public String toString() { return versionName; } public String getMajorVersion() { - return majorVersion; + return String.valueOf(ordinal() + 1); + } + + private static JavaVersion getVersionForMajor(int major) { + return major >= values().length ? JavaVersion.VERSION_HIGHER : values()[major - 1]; + } + + private static void assertTrue(String value, boolean condition) { + if (!condition) { + throw new IllegalArgumentException("Could not determine java version from '" + value + "'."); + } + } + + private static boolean isLegacyVersion(List<Integer> versions) { + return 1 == versions.get(0) && versions.size() > 1; + } + + private static List<Integer> convertToNumber(String value, String[] versionStrs) { + List<Integer> result = new ArrayList<Integer>(); + for (String s : versionStrs) { + assertTrue(value, !isNumberStartingWithZero(s)); + try { + result.add(Integer.parseInt(s)); + } catch (NumberFormatException e) { + assertTrue(value, false); + } + } + assertTrue(value, !result.isEmpty() && result.get(0) > 0); + return result; + } + + private static boolean isNumberStartingWithZero(String number) { + return number.length() > 1 && number.startsWith("0"); + } + + private static int findFirstNonVersionCharIndex(String s) { + assertTrue(s, s.length() != 0); + + for (int i = 0; i < s.length(); ++i) { + if (!isDigitOrPeriod(s.charAt(i))) { + assertTrue(s, i != 0); + return i; + } + } + + return s.length(); + } + + private static boolean isDigitOrPeriod(char c) { + return (c >= '0' && c <= '9') || c == '.'; } } --- a/subprojects/jvm-services/src/main/java/org/gradle/internal/jvm/inspection/DefaultJvmVersionDetector.java +++ b/subprojects/jvm-services/src/main/java/org/gradle/internal/jvm/inspection/DefaultJvmVersionDetector.java @@ -62,7 +62,7 @@ public class DefaultJvmVersionDetector i try { String versionStr = reader.readLine(); while (versionStr != null) { - Matcher matcher = Pattern.compile("(?:java|openjdk) version \"(.+?)\"").matcher(versionStr); + Matcher matcher = Pattern.compile("(?:java|openjdk) version \"(.+?)\"( \\d{4}-\\d{2}-\\d{2}( LTS)?)?").matcher(versionStr); if (matcher.matches()) { return JavaVersion.toVersion(matcher.group(1)); } ++++++ java8-compatibility.patch ++++++ --- a/subprojects/messaging/src/main/java/org/gradle/internal/remote/internal/inet/SocketConnection.java +++ b/subprojects/messaging/src/main/java/org/gradle/internal/remote/internal/inet/SocketConnection.java @@ -32,6 +32,7 @@ import java.io.*; import java.net.InetSocketAddress; +import java.nio.Buffer; import java.nio.ByteBuffer; import java.nio.channels.ClosedSelectorException; import java.nio.channels.SelectionKey; @@ -155,7 +156,7 @@ selector = Selector.open(); socket.register(selector, SelectionKey.OP_READ); buffer = ByteBuffer.allocateDirect(4096); - buffer.limit(0); + ((Buffer) buffer).limit(0); } @Override @@ -183,19 +184,19 @@ return -1; } - buffer.clear(); + ((Buffer) buffer).clear(); int nread; try { nread = socket.read(buffer); } catch (IOException e) { if (isEndOfStream(e)) { - buffer.position(0); - buffer.limit(0); + ((Buffer) buffer).position(0); + ((Buffer) buffer).limit(0); return -1; } throw e; } - buffer.flip(); + ((Buffer) buffer).flip(); if (nread < 0) { return -1; @@ -256,7 +257,7 @@ } private void writeBufferToChannel() throws IOException { - buffer.flip(); + ((Buffer) buffer).flip(); int count = writeWithNonBlockingRetry(); if (count == 0) { // buffer was still full after non-blocking retries, now block --- a/subprojects/base-services/src/main/java/org/gradle/internal/io/StreamByteBuffer.java +++ b/subprojects/base-services/src/main/java/org/gradle/internal/io/StreamByteBuffer.java @@ -191,7 +191,7 @@ // copy one by one until the underflow has been resolved buf = ByteBuffer.allocate(buf.remaining() + 1).put(buf); buf.put(nextBuf.get()); - buf.flip(); + ((java.nio.Buffer) buf).flip(); } else { if (hasRemaining(nextBuf)) { buf = nextBuf; @@ -234,7 +234,7 @@ throw UncheckedException.throwAsUncheckedException(e); } } - charbuffer.flip(); + ((java.nio.Buffer) charbuffer).flip(); return charbuffer; } --- a/subprojects/base-services/src/main/java/org/gradle/internal/hash/Hashing.java +++ b/subprojects/base-services/src/main/java/org/gradle/internal/hash/Hashing.java @@ -158,7 +158,7 @@ public class Hashing { private void update(int length) { checkNotDone(); digest.update(buffer.array(), 0, length); - buffer.clear(); + ((java.nio.Buffer) buffer).clear(); } @Override ++++++ remove-timestamps.patch ++++++ --- a/gradle/versioning.gradle +++ b/gradle/versioning.gradle @@ -115,13 +115,12 @@ } task configureBuildReceipt { - dependsOn determineCommitId doLast { createBuildReceipt.versionNumber = rootProject.version createBuildReceipt.baseVersion = rootProject.baseVersion createBuildReceipt.snapshot = rootProject.isSnapshot - createBuildReceipt.buildTimestamp = rootProject.buildTimestamp - createBuildReceipt.commitId = determineCommitId.commitId + createBuildReceipt.buildTimestamp = '20121221000000+0000' + createBuildReceipt.commitId = 'none' } }
