debian/changelog

+gradle (4.4.1-7) UNRELEASED; urgency=medium
+
+  * Use JRE provided xml-apis (Closes: #925586)
+
+ -- Jongmin Kim <jmkim@pukyong.ac.kr>  Tue, 25 Jun 2019 11:32:22 +0200
+
+gradle (4.4.1-6) unstable; urgency=medium
+
+  [ Tiago Stürmer Daitx ]
+  * Fix OpenJDK 8 compatibility: (Closes: #925225)
+    - debian/patches/java8-compatibility.patch: cast ByteBuffer to Buffer
+      in org.gradle.internal.hash.Hashing to prevent NoSuchMethodError
+      exception.
+    - debian/patches/java11-compatibility.patch: copy upstream commit for
+      "Use Lookup to invoke defineClass on Java 9+ (#4976)" instead using
+      the previous partial backport to enable both OpenJDK 8 and 11 support.
+  * debian/control: revert gradle Depends back to java 8
+
+ -- Emmanuel Bourg <ebourg@apache.org>  Sat, 22 Jun 2019 00:52:47 +0200
+
 gradle (4.4.1-5) unstable; urgency=medium
 
   * Team upload.

debian/control

@@ -40,7 +40,6 @@ Build-Depends: ant,
                libjarjar-java,
                libjatl-java,
                libjaxen-java,
-               libjaxp1.3-java,
                libjcifs-java,
                libjcip-annotations-java,
                libjgit-java,
@@ -76,7 +75,7 @@ Homepage: https://gradle.org
 
 Package: gradle
 Architecture: all
-Depends: default-jre-headless (>= 2:1.9) | java9-runtime-headless,
+Depends: default-jre-headless (>= 2:1.8) | java8-runtime-headless,
          libgradle-core-java (>= ${binary:Version}),
          libgradle-plugins-java (>= ${binary:Version}),
          ${misc:Depends}

debian/patches/java11-compatibility.patch

@@ -4,51 +4,238 @@ Origin: backport, https://github.com/gradle/gradle/commit/ac15612d41b43c39c8e39d
                   https://github.com/gradle/gradle/commit/3db6e256987053171178aa96a0ef46caedc8d1a4
 --- 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
-@@ -24,6 +24,9 @@
+@@ -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.lang.reflect.Field;
- import java.net.MalformedURLException;
  import java.net.URL;
-@@ -31,16 +34,15 @@
- 
- public abstract class ClassLoaderUtils {
+ import java.net.URLConnection;
  
+-public abstract class ClassLoaderUtils {
+-
 -    private static final Unsafe UNSAFE;
-+    private static MethodHandle defineClassMethodHandle;
- 
-     static {
-         try {
+-
+-    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) {
-+            MethodHandles.Lookup baseLookup = MethodHandles.lookup();
-+            MethodType defineClassMethodType = MethodType.methodType(Class.class, new Class[]{String.class, byte[].class, int.class, int.class});
-+            MethodHandles.Lookup lookup = MethodHandles.privateLookupIn(ClassLoader.class, baseLookup);
-+            defineClassMethodHandle = lookup.findVirtual(ClassLoader.class, "defineClass", defineClassMethodType);
-+        } catch (Throwable e) {
-             throw new RuntimeException(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 +103,10 @@
+@@ -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 {
-+            return (Class) defineClassMethodHandle.bindTo(targetClassLoader).invokeWithArguments(className, clazzBytes, 0, clazzBytes.length);
-+        } catch (Throwable e) {
++                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);
++            }
++        }
+     }
+ }
+diff --git 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
+index 9a7fd911c78f..c1324a04fef5 100644
+--- 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 @@

debian/patches/java8-compatibility.patch

@@ -74,3 +74,14 @@ Bug-Ubuntu: https://bugs.launchpad.net/ubuntu/+source/gradle/+bug/1760359
          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

debian/patches/use-local-artifacts.patch

@@ -7,17 +7,15 @@ Subject: use local artifacts
  to patch some artifact names here.
 Forwarded: not-needed
 ---
- build.gradle                                       |  4 +--
- buildSrc/build.gradle                              |  7 ++--
- gradle/dependencies.gradle                         | 42 +++++++++++-----------
- gradle/testSetup.gradle                            |  2 +-
- .../dependency-management.gradle                   |  5 ---
- subprojects/docs/docs.gradle                       | 15 ++------
- subprojects/javascript/javascript.gradle           |  2 +-
- subprojects/maven/maven.gradle                     |  2 +-
- subprojects/reporting/reporting.gradle             |  2 +-
- .../testing/worker/ForkingTestClassProcessor.java  |  4 +--
- 10 files changed, 35 insertions(+), 50 deletions(-)
+ build.gradle                                        |    5 --
+ buildSrc/build.gradle                               |    8 +--
+ gradle/dependencies.gradle                          |   21 ++++++----
+ subprojects/build-init/build-init.gradle            |    1
+ subprojects/core/core.gradle                        |    1
+ .../dependency-management.gradle                    |    5 --
+ subprojects/reporting/reporting.gradle              |    2
+ .../testing/worker/ForkingTestClassProcessor.java   |    2
+ 8 files changed, 22 insertions(+), 23 deletions(-)
 
 --- a/build.gradle
 +++ b/build.gradle
@@ -78,7 +76,7 @@ Forwarded: not-needed
      kryo: 'com.esotericsoftware.kryo:kryo:2.20',
      jsr305: 'com.google.code.findbugs:jsr305:1.3.9@jar',
      groovy: "org.codehaus.groovy:groovy-all:${versions.groovy}",
-@@ -102,7 +102,7 @@
+@@ -102,11 +102,10 @@
      equalsVerifier: 'nl.jqno.equalsverifier:equalsverifier:2.1.6',
      xbean: 'org.apache.xbean:xbean-reflect:3.4@jar', //required by maven3 classes
      nativePlatform: 'net.rubygrapefruit:native-platform:0.14',
@@ -87,7 +85,11 @@ Forwarded: not-needed
      xerces: "xerces:xercesImpl:2.11.0",
      objenesis: 'org.objenesis:objenesis:1.2@jar',
      jsoup: 'org.jsoup:jsoup:1.6.3',
-@@ -157,7 +157,7 @@
+-    xmlApis: 'xml-apis:xml-apis:1.4.01',
+     jgit: [
+         'org.eclipse.jgit:org.eclipse.jgit:4.5.3.201708160445-r@jar', // 4.6+ requires Java 8
+         libraries.commons_httpclient,
+@@ -157,7 +156,7 @@
      dependency 'org.apache.maven.wagon:wagon-file:2.4@jar'
      dependency 'org.apache.maven.wagon:wagon-http:2.4@jar'
      dependency 'org.apache.maven.wagon:wagon-provider-api:2.4@jar'
@@ -96,7 +98,7 @@ Forwarded: not-needed
  
      //eather:
      dependency 'org.apache.maven.resolver:maven-resolver-api:1.13.1@jar'
-@@ -200,8 +200,8 @@
+@@ -200,8 +199,8 @@
      dependency libraries.mina
  }
  
@@ -107,7 +109,7 @@ Forwarded: not-needed
      dependency libraries.bouncycastle_provider
  }
  
-@@ -252,3 +252,11 @@
+@@ -252,3 +251,11 @@
          }
      }
  }
@@ -119,6 +121,16 @@ Forwarded: not-needed
 +    apply from: "${rootDir}/../debian/substituteDependencies.gradle"
 +  }
 +}
+--- a/subprojects/core/core.gradle
++++ b/subprojects/core/core.gradle
+@@ -55,7 +55,6 @@
+     implementation libraries.jcip
+     implementation libraries.nativePlatform
+     implementation libraries.commons_compress
+-    implementation libraries.xmlApis
+ 
+     runtimeOnly project(":docs")
+ 
 --- a/subprojects/dependency-management/dependency-management.gradle
 +++ b/subprojects/dependency-management/dependency-management.gradle
 @@ -6,11 +6,6 @@