.gitignore

@@ -1 +1 @@
-SOURCES/da67577.tar.gz
+SOURCES/xmvn-3.0.0.tar.xz

.xmvn.metadata

@@ -1 +1 @@
-df6cdcb0a2dd366cc384c03675c1a7f568472aae SOURCES/da67577.tar.gz
+d887a65c5649459f513dd70c688b080e47afc691 SOURCES/xmvn-3.0.0.tar.xz

SOURCES/0001-Don-t-use-JAXB-for-converting-bytes-to-hex-string.patch

@@ -0,0 +1,58 @@
+From 336cbdc97f3c7055ebdf858141bfc160fd4d412b Mon Sep 17 00:00:00 2001
+From: Mikolaj Izdebski <mizdebsk@redhat.com>
+Date: Fri, 8 Dec 2017 18:00:54 +0100
+Subject: [PATCH] Don't use JAXB for converting bytes to hex string
+
+---
+ .../java/org/fedoraproject/xmvn/resolver/impl/CacheManager.java   | 8 ++------
+ 1 file changed, 2 insertions(+), 6 deletions(-)
+
+diff --git a/xmvn-core/src/main/java/org/fedoraproject/xmvn/resolver/impl/CacheManager.java b/xmvn-core/src/main/java/org/fedoraproject/xmvn/resolver/impl/CacheManager.java
+index 1d6c193b..0902aa88 100644
+--- a/xmvn-core/src/main/java/org/fedoraproject/xmvn/resolver/impl/CacheManager.java
++++ b/xmvn-core/src/main/java/org/fedoraproject/xmvn/resolver/impl/CacheManager.java
+@@ -16,14 +16,13 @@
+ package org.fedoraproject.xmvn.resolver.impl;
+ 
+ import java.io.IOException;
++import java.math.BigInteger;
+ import java.nio.file.Files;
+ import java.nio.file.Path;
+ import java.nio.file.Paths;
+ import java.security.MessageDigest;
+ import java.security.NoSuchAlgorithmException;
+ 
+-import javax.xml.bind.annotation.adapters.HexBinaryAdapter;
+-
+ /**
+  * @author Mikolaj Izdebski
+  */
+@@ -31,8 +30,6 @@ class CacheManager
+ {
+     private static final String DIGEST_ALGORITHM = "SHA-1";
+ 
+-    private final HexBinaryAdapter hexAdapter;
+-
+     private final MessageDigest digest;
+ 
+     private static volatile Path cacheHome;
+@@ -41,7 +38,6 @@ class CacheManager
+     {
+         try
+         {
+-            hexAdapter = new HexBinaryAdapter();
+             digest = MessageDigest.getInstance( DIGEST_ALGORITHM );
+         }
+         catch ( NoSuchAlgorithmException e )
+@@ -53,7 +49,7 @@ class CacheManager
+     private String hash( Path path )
+         throws IOException
+     {
+-        return hexAdapter.marshal( digest.digest( Files.readAllBytes( path ) ) );
++        return new BigInteger( 1, digest.digest( Files.readAllBytes( path ) ) ).setBit( 160 ).toString( 16 ).substring( 1 ).toUpperCase();
+     }
+ 
+     private static Path getPathDefault( String key, Object defaultValue )
+-- 
+2.14.3
+

SOURCES/0001-Fix-configuration-of-aliased-plugins.patch

@@ -0,0 +1,76 @@
+From 46ad87218f0be4a4b7e292a1c8b5d5dbce48ae63 Mon Sep 17 00:00:00 2001
+From: Mikolaj Izdebski <mizdebsk@redhat.com>
+Date: Fri, 16 Mar 2018 11:10:35 +0100
+Subject: [PATCH] Fix configuration of aliased plugins
+
+Normally Maven tries to look up plugin configuration using plugin
+coordinates taken from plugin descriptor.  This works with pure Maven
+as plugin descriptor always matches <plugin> reference in POM.
+However in XMvn they can differ when plugin artifact is resolved
+throug artifact alias, so XMvn should force use of coordinates
+specified in <plugin> in POM.
+---
+ .../aether/XMvnMojoExecutionConfigurator.java      | 51 ++++++++++++++++++++++
+ 1 file changed, 51 insertions(+)
+ create mode 100644 xmvn-connector-aether/src/main/java/org/fedoraproject/xmvn/connector/aether/XMvnMojoExecutionConfigurator.java
+
+diff --git a/xmvn-connector-aether/src/main/java/org/fedoraproject/xmvn/connector/aether/XMvnMojoExecutionConfigurator.java b/xmvn-connector-aether/src/main/java/org/fedoraproject/xmvn/connector/aether/XMvnMojoExecutionConfigurator.java
+new file mode 100644
+index 00000000..72e38b37
+--- /dev/null
++++ b/xmvn-connector-aether/src/main/java/org/fedoraproject/xmvn/connector/aether/XMvnMojoExecutionConfigurator.java
+@@ -0,0 +1,51 @@
++/*-
++ * Copyright (c) 2018 Red Hat, Inc.
++ *
++ * 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.
++ */
++package org.fedoraproject.xmvn.connector.aether;
++
++import org.apache.maven.lifecycle.MojoExecutionConfigurator;
++import org.apache.maven.lifecycle.internal.DefaultMojoExecutionConfigurator;
++import org.apache.maven.plugin.MojoExecution;
++import org.apache.maven.plugin.descriptor.PluginDescriptor;
++import org.apache.maven.project.MavenProject;
++import org.codehaus.plexus.component.annotations.Component;
++
++/**
++ * @author Mikolaj Izdebski
++ */
++@Component( role = MojoExecutionConfigurator.class )
++public class XMvnMojoExecutionConfigurator
++    extends DefaultMojoExecutionConfigurator
++{
++    @Override
++    public void configure( MavenProject project, MojoExecution execution, boolean allowPluginLevelConfig )
++    {
++        PluginDescriptor originalPluginDescriptor = execution.getMojoDescriptor().getPluginDescriptor();
++
++        PluginDescriptor aliasedPluginDescriptor = originalPluginDescriptor.clone();
++        aliasedPluginDescriptor.setGroupId( execution.getPlugin().getGroupId() );
++        aliasedPluginDescriptor.setArtifactId( execution.getPlugin().getArtifactId() );
++
++        try
++        {
++            execution.getMojoDescriptor().setPluginDescriptor( aliasedPluginDescriptor );
++            super.configure( project, execution, allowPluginLevelConfig );
++        }
++        finally
++        {
++            execution.getMojoDescriptor().setPluginDescriptor( originalPluginDescriptor );
++        }
++    }
++}
+-- 
+2.14.3
+

SOURCES/0001-Fix-installer-plugin-loading.patch

@@ -0,0 +1,403 @@
+From 0fd7b0d19bd96456292585e883e3ba2ebbaf579b Mon Sep 17 00:00:00 2001
+From: Mikolaj Izdebski <mizdebsk@redhat.com>
+Date: Wed, 21 Jun 2017 10:21:10 +0200
+Subject: [PATCH] Fix installer plugin loading
+
+---
+ .../install/impl/ArtifactInstallerFactory.java     |  97 ++++++--
+ .../tools/install/impl/IsolatedClassRealm.java     | 245 +++++++++++++++++++++
+ 2 files changed, 320 insertions(+), 22 deletions(-)
+ create mode 100644 xmvn-tools/xmvn-install/src/main/java/org/fedoraproject/xmvn/tools/install/impl/IsolatedClassRealm.java
+
+diff --git a/xmvn-tools/xmvn-install/src/main/java/org/fedoraproject/xmvn/tools/install/impl/ArtifactInstallerFactory.java b/xmvn-tools/xmvn-install/src/main/java/org/fedoraproject/xmvn/tools/install/impl/ArtifactInstallerFactory.java
+index 7a80571..e6a9a2d 100644
+--- a/xmvn-tools/xmvn-install/src/main/java/org/fedoraproject/xmvn/tools/install/impl/ArtifactInstallerFactory.java
++++ b/xmvn-tools/xmvn-install/src/main/java/org/fedoraproject/xmvn/tools/install/impl/ArtifactInstallerFactory.java
+@@ -15,8 +15,17 @@
+  */
+ package org.fedoraproject.xmvn.tools.install.impl;
+ 
++import java.io.BufferedReader;
++import java.io.IOException;
++import java.io.InputStream;
++import java.io.InputStreamReader;
++import java.nio.file.Files;
++import java.nio.file.Path;
++import java.nio.file.Paths;
+ import java.util.Arrays;
+-import java.util.Collection;
++import java.util.LinkedHashMap;
++import java.util.List;
++import java.util.Map;
+ import java.util.Properties;
+ 
+ import org.slf4j.Logger;
+@@ -35,49 +44,93 @@ class ArtifactInstallerFactory
+ 
+     private final ArtifactInstaller defaultArtifactInstaller;
+ 
+-    private final ArtifactInstaller eclipseArtifactInstaller;
++    private final IsolatedClassRealm pluginRealm;
+ 
+-    private static ArtifactInstaller loadPlugin( String className )
++    private final Map<String, ArtifactInstaller> cachedPluginsByType = new LinkedHashMap<>();
++
++    private final Map<String, ArtifactInstaller> cachedPluginsByImplClass = new LinkedHashMap<>();
++
++    private ArtifactInstaller tryLoadPlugin( String type )
+     {
++        if ( cachedPluginsByType.containsKey( type ) )
++            return cachedPluginsByType.get( type );
++
+         try
+         {
+-            return (ArtifactInstaller) ArtifactInstallerFactory.class.getClassLoader().loadClass( className ).newInstance();
++            String resourceName = ArtifactInstaller.class.getCanonicalName() + "/" + type;
++            InputStream resourceStream = pluginRealm != null ? pluginRealm.getResourceAsStream( resourceName ) : null;
++            if ( resourceStream == null )
++            {
++                logger.debug( "No XMvn Installer plugin found for packaging type {}", type );
++                cachedPluginsByType.put( type, null );
++                return null;
++            }
++
++            String pluginImplClass;
++            try ( BufferedReader resourceReader = new BufferedReader( new InputStreamReader( resourceStream ) ) )
++            {
++                pluginImplClass = resourceReader.readLine();
++            }
++
++            ArtifactInstaller pluggedInInstaller = cachedPluginsByImplClass.get( pluginImplClass );
++            if ( pluggedInInstaller == null )
++            {
++                pluggedInInstaller = (ArtifactInstaller) pluginRealm.loadClass( pluginImplClass ).newInstance();
++                cachedPluginsByImplClass.put( pluginImplClass, pluggedInInstaller );
++            }
++
++            cachedPluginsByType.put( type, pluggedInInstaller );
++            return pluggedInInstaller;
+         }
+-        catch ( ReflectiveOperationException e )
++        catch ( IOException | ReflectiveOperationException e )
+         {
+-            return null;
++            throw new RuntimeException( "Unable to load XMvn Installer plugin for packaging type " + type, e );
+         }
+     }
+ 
+     public ArtifactInstallerFactory( Configurator configurator )
+     {
+         defaultArtifactInstaller = new DefaultArtifactInstaller( configurator );
+-        // FIXME Don't hardcode plugin class name
+-        eclipseArtifactInstaller = loadPlugin( "org.fedoraproject.p2.xmvn.EclipseArtifactInstaller" );
++
++        Path pluginDir = Paths.get( "/usr/share/xmvn/lib/installer" );
++        if ( Files.isDirectory( pluginDir ) )
++        {
++            ClassLoader parentClassLoader = ArtifactInstallerFactory.class.getClassLoader();
++            pluginRealm = new IsolatedClassRealm( parentClassLoader );
++            pluginRealm.addJarDirectory( pluginDir );
++            PLUGIN_IMPORTS.forEach( pluginRealm::importPackage );
++        }
++        else
++        {
++            pluginRealm = null;
++        }
+     }
+ 
+     /**
+-     * List of Tycho pacgkaging types.
++     * List of packages imported from XMvn Installer class loader to plug-in realms.
+      */
+-    private static final Collection<String> ECLIPSE_PACKAGING_TYPES = Arrays.asList( "eclipse-plugin", //
+-                                                                                     "eclipse-test-plugin", //
+-                                                                                     "eclipse-feature", //
+-                                                                                     "eclipse-repository", //
+-                                                                                     "eclipse-application", //
+-                                                                                     "eclipse-update-site", //
+-                                                                                     "eclipse-target-definition" );
++    private static final List<String> PLUGIN_IMPORTS = Arrays.asList( // XMvn API
++                                                                      "org.fedoraproject.xmvn.artifact", //
++                                                                      "org.fedoraproject.xmvn.config", //
++                                                                      "org.fedoraproject.xmvn.deployer", //
++                                                                      "org.fedoraproject.xmvn.locator", //
++                                                                      "org.fedoraproject.xmvn.metadata", //
++                                                                      "org.fedoraproject.xmvn.resolver", //
++                                                                      // XMvn Installer SPI
++                                                                      "org.fedoraproject.xmvn.tools.install", //
++                                                                      // SLF4J API
++                                                                      "org.slf4j" //
++    );
+ 
+     @SuppressWarnings( "unused" )
+     public ArtifactInstaller getInstallerFor( Artifact artifact, Properties properties )
+     {
+         String type = properties.getProperty( "type" );
+-        if ( type != null && ECLIPSE_PACKAGING_TYPES.contains( type ) )
++        if ( type != null )
+         {
+-            if ( eclipseArtifactInstaller != null )
+-                return eclipseArtifactInstaller;
+-
+-            logger.error( "Unable to load XMvn P2 plugin, Eclipse artifact installation will be impossible" );
+-            throw new RuntimeException( "Unable to load XMvn P2 plugin" );
++            ArtifactInstaller pluggedInInstaller = tryLoadPlugin( type );
++            if ( pluggedInInstaller != null )
++                return pluggedInInstaller;
+         }
+ 
+         return defaultArtifactInstaller;
+diff --git a/xmvn-tools/xmvn-install/src/main/java/org/fedoraproject/xmvn/tools/install/impl/IsolatedClassRealm.java b/xmvn-tools/xmvn-install/src/main/java/org/fedoraproject/xmvn/tools/install/impl/IsolatedClassRealm.java
+new file mode 100644
+index 0000000..3324604
+--- /dev/null
++++ b/xmvn-tools/xmvn-install/src/main/java/org/fedoraproject/xmvn/tools/install/impl/IsolatedClassRealm.java
+@@ -0,0 +1,245 @@
++/*-
++ * Copyright (c) 2014-2017 Red Hat, Inc.
++ *
++ * 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.
++ */
++package org.fedoraproject.xmvn.tools.install.impl;
++
++import java.io.IOException;
++import java.net.MalformedURLException;
++import java.net.URL;
++import java.net.URLClassLoader;
++import java.nio.file.DirectoryStream;
++import java.nio.file.Files;
++import java.nio.file.Path;
++import java.util.Collection;
++import java.util.Collections;
++import java.util.Enumeration;
++import java.util.HashSet;
++import java.util.LinkedHashSet;
++import java.util.Set;
++
++/**
++ * A generic, isolated class loader.
++ * <p>
++ * This class loader has its own classpath, separate from the primary Java classpath. It has a parent class loader, to
++ * which it delegates loading a set of imported classes. All other classes are loaded from its own classpath.
++ * 
++ * @author Mikolaj Izdebski
++ */
++class IsolatedClassRealm
++    extends URLClassLoader
++{
++    static
++    {
++        registerAsParallelCapable();
++    }
++
++    private final ClassLoader parent;
++
++    private final Set<String> imports = new HashSet<>();
++
++    private final Set<String> importsAll = new HashSet<>();
++
++    public IsolatedClassRealm( ClassLoader parent )
++    {
++        super( new URL[0], null );
++        this.parent = parent;
++    }
++
++    public void addJar( Path jar )
++    {
++        try
++        {
++            addURL( jar.toUri().toURL() );
++        }
++        catch ( MalformedURLException e )
++        {
++            throw new RuntimeException( e );
++        }
++    }
++
++    public void addJarDirectory( Path dir )
++    {
++        try ( DirectoryStream<Path> stream = Files.newDirectoryStream( dir, "*.jar" ) )
++        {
++            for ( Path path : stream )
++            {
++                addJar( path );
++            }
++        }
++        catch ( IOException e )
++        {
++            throw new RuntimeException( e );
++        }
++    }
++
++    public void importPackage( String packageName )
++    {
++        imports.add( packageName );
++    }
++
++    public void importAllPackages( String packageName )
++    {
++        importsAll.add( packageName );
++    }
++
++    boolean isImported( String name )
++    {
++        int index = name.lastIndexOf( '/' );
++
++        if ( index >= 0 )
++        {
++            name = name.replace( '/', '.' );
++        }
++        else
++        {
++            index = Math.max( name.lastIndexOf( '.' ), 0 );
++        }
++
++        String namespace = name.substring( 0, index );
++
++        if ( imports.contains( namespace ) )
++            return true;
++
++        while ( !namespace.isEmpty() )
++        {
++            if ( importsAll.contains( namespace ) )
++                return true;
++
++            namespace = namespace.substring( 0, Math.max( namespace.lastIndexOf( '.' ), 0 ) );
++        }
++
++        return false;
++    }
++
++    @Override
++    public Class<?> loadClass( String name )
++        throws ClassNotFoundException
++    {
++        return loadClass( name, false );
++    }
++
++    @Override
++    protected Class<?> loadClass( String name, boolean resolve )
++        throws ClassNotFoundException
++    {
++        if ( isImported( name ) )
++        {
++            try
++            {
++                return parent.loadClass( name );
++            }
++            catch ( ClassNotFoundException e )
++            {
++            }
++        }
++
++        try
++        {
++            return super.loadClass( name, resolve );
++        }
++        catch ( ClassNotFoundException e )
++        {
++        }
++
++        synchronized ( getClassLoadingLock( name ) )
++        {
++            Class<?> clazz = findLoadedClass( name );
++            if ( clazz != null )
++            {
++                return clazz;
++            }
++
++            try
++            {
++                return super.findClass( name );
++            }
++            catch ( ClassNotFoundException e )
++            {
++            }
++        }
++
++        throw new ClassNotFoundException( name );
++    }
++
++    @Override
++    protected Class<?> findClass( String name )
++        throws ClassNotFoundException
++    {
++        throw new ClassNotFoundException( name );
++    }
++
++    @Override
++    public URL getResource( String name )
++    {
++        if ( isImported( name ) )
++        {
++            URL resource = parent.getResource( name );
++            if ( resource != null )
++            {
++                return resource;
++            }
++        }
++
++        URL resource = super.getResource( name );
++        if ( resource != null )
++        {
++            return resource;
++        }
++
++        resource = super.findResource( name );
++        if ( resource != null )
++        {
++            return resource;
++        }
++
++        return null;
++    }
++
++    @Override
++    public Enumeration<URL> getResources( String name )
++        throws IOException
++    {
++        Collection<URL> resources = new LinkedHashSet<>();
++
++        if ( isImported( name ) )
++        {
++            try
++            {
++                resources.addAll( Collections.list( parent.getResources( name ) ) );
++            }
++            catch ( IOException e )
++            {
++            }
++        }
++
++        try
++        {
++            resources.addAll( Collections.list( super.getResources( name ) ) );
++        }
++        catch ( IOException e )
++        {
++        }
++
++        try
++        {
++            resources.addAll( Collections.list( super.findResources( name ) ) );
++        }
++        catch ( IOException e )
++        {
++        }
++
++        return Collections.enumeration( resources );
++    }
++}
+-- 
+2.9.3
+

SOURCES/0001-Initial-PoC-of-XMvn-toolchain-manager.patch

@@ -1,77 +0,0 @@
-From c9362d3f23f950bb6987c63c67b06528de3ce100 Mon Sep 17 00:00:00 2001
-From: Mikolaj Izdebski <mizdebsk@redhat.com>
-Date: Thu, 23 Jan 2020 12:50:42 +0100
-Subject: [PATCH] Initial PoC of XMvn toolchain manager
-
----
- .../aether/XMvnMavenLifecycleParticipant.java | 38 +++++++++++++++++++
- 1 file changed, 38 insertions(+)
-
-diff --git a/xmvn-connector-aether/src/main/java/org/fedoraproject/xmvn/connector/aether/XMvnMavenLifecycleParticipant.java b/xmvn-connector-aether/src/main/java/org/fedoraproject/xmvn/connector/aether/XMvnMavenLifecycleParticipant.java
-index 0e360488..ddd6151b 100644
---- a/xmvn-connector-aether/src/main/java/org/fedoraproject/xmvn/connector/aether/XMvnMavenLifecycleParticipant.java
-+++ b/xmvn-connector-aether/src/main/java/org/fedoraproject/xmvn/connector/aether/XMvnMavenLifecycleParticipant.java
-@@ -15,10 +15,15 @@
-  */
- package org.fedoraproject.xmvn.connector.aether;
- 
-+import java.util.Collections;
-+
- import org.apache.maven.AbstractMavenLifecycleParticipant;
- import org.apache.maven.MavenExecutionException;
- import org.apache.maven.execution.MavenExecutionRequest;
- import org.apache.maven.execution.MavenSession;
-+import org.apache.maven.project.MavenProject;
-+import org.apache.maven.toolchain.MisconfiguredToolchainException;
-+import org.apache.maven.toolchain.ToolchainManagerPrivate;
- import org.codehaus.plexus.component.annotations.Component;
- import org.codehaus.plexus.component.annotations.Requirement;
- import org.codehaus.plexus.logging.Logger;
-@@ -42,6 +47,9 @@ public class XMvnMavenLifecycleParticipant
-     @Requirement( role = XMvnMojoExecutionListener.class )
-     private XMvnMojoExecutionListener mojoExecutionListener;
- 
-+    @Requirement
-+    private ToolchainManagerPrivate toolchainManager;
-+
-     @Override
-     public void afterSessionStart( MavenSession session )
-         throws MavenExecutionException
-@@ -61,4 +69,34 @@ public class XMvnMavenLifecycleParticipant
-         chainedListener.addExecutionListener( reportGenerator );
-         request.setExecutionListener( chainedListener );
-     }
-+
-+    @Override
-+    public void afterProjectsRead( MavenSession session )
-+        throws MavenExecutionException
-+    {
-+        MavenProject currentProject = session.getCurrentProject();
-+
-+        try
-+        {
-+            for ( var toolchain : toolchainManager.getToolchainsForType( "jdk", session ) )
-+            {
-+                if ( toolchain.matchesRequirements( Collections.singletonMap( "xmvn", "xmvn" ) ) )
-+                {
-+                    for ( var project : session.getAllProjects() )
-+                    {
-+                        session.setCurrentProject( project );
-+                        toolchainManager.storeToolchainToBuildContext( toolchain, session );
-+                    }
-+                }
-+            }
-+        }
-+        catch ( MisconfiguredToolchainException e )
-+        {
-+            throw new MavenExecutionException( "Unable to configure toolchains", e );
-+        }
-+        finally
-+        {
-+            session.setCurrentProject( currentProject );
-+        }
-+    }
- }
--- 
-2.21.0
-

SOURCES/0001-Port-to-Gradle-4.2.patch

@@ -0,0 +1,568 @@
+From 34b37637bd469621bb3eadfdf5fb856a806722df Mon Sep 17 00:00:00 2001
+From: Michael Simacek <msimacek@redhat.com>
+Date: Mon, 2 Oct 2017 12:01:09 +0300
+Subject: [PATCH] Port to Gradle 4.2
+
+---
+ libs/gradle-core-api/pom.xml                       |  32 ++++++
+ libs/gradle-logging/pom.xml                        |  32 ++++++
+ libs/gradle-model-core/pom.xml                     |  32 ++++++
+ libs/pom.xml                                       |   3 +
+ xmvn-connector-gradle/pom.xml                      |  15 +++
+ .../xmvn/connector/gradle/GradleResolver.java      | 119 ++++++++++++++-------
+ .../xmvn/connector/gradle/XMvnGradlePlugin.java    |  16 +--
+ .../xmvn/connector/gradle/XMvnInstallTask.java     |  22 +++-
+ xmvn-parent/pom.xml                                |  17 ++-
+ 9 files changed, 235 insertions(+), 53 deletions(-)
+ create mode 100644 libs/gradle-core-api/pom.xml
+ create mode 100644 libs/gradle-logging/pom.xml
+ create mode 100644 libs/gradle-model-core/pom.xml
+
+diff --git a/libs/gradle-core-api/pom.xml b/libs/gradle-core-api/pom.xml
+new file mode 100644
+index 00000000..7b3d68d5
+--- /dev/null
++++ b/libs/gradle-core-api/pom.xml
+@@ -0,0 +1,32 @@
++<?xml version="1.0" encoding="US-ASCII"?>
++<!--
++ ! Copyright (c) 2016-2017 Red Hat, Inc.
++ !
++ ! 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.
++ `-->
++<project xmlns="http://maven.apache.org/POM/4.0.0"
++         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
++         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
++                             http://maven.apache.org/xsd/maven-4.0.0.xsd">
++  <modelVersion>4.0.0</modelVersion>
++  <parent>
++    <groupId>org.fedoraproject.xmvn</groupId>
++    <artifactId>libs</artifactId>
++    <version>3.0.0</version>
++    <relativePath>..</relativePath>
++  </parent>
++  <groupId>org.gradle</groupId>
++  <artifactId>gradle-core-api</artifactId>
++  <version>${gradleVersion}</version>
++  <name>Gradle core API module</name>
++</project>
+diff --git a/libs/gradle-logging/pom.xml b/libs/gradle-logging/pom.xml
+new file mode 100644
+index 00000000..d2dec7c1
+--- /dev/null
++++ b/libs/gradle-logging/pom.xml
+@@ -0,0 +1,32 @@
++<?xml version="1.0" encoding="US-ASCII"?>
++<!--
++ ! Copyright (c) 2016-2017 Red Hat, Inc.
++ !
++ ! 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.
++ `-->
++<project xmlns="http://maven.apache.org/POM/4.0.0"
++         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
++         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
++                             http://maven.apache.org/xsd/maven-4.0.0.xsd">
++  <modelVersion>4.0.0</modelVersion>
++  <parent>
++    <groupId>org.fedoraproject.xmvn</groupId>
++    <artifactId>libs</artifactId>
++    <version>3.0.0</version>
++    <relativePath>..</relativePath>
++  </parent>
++  <groupId>org.gradle</groupId>
++  <artifactId>gradle-logging</artifactId>
++  <version>${gradleVersion}</version>
++  <name>Gradle logging module</name>
++</project>
+diff --git a/libs/gradle-model-core/pom.xml b/libs/gradle-model-core/pom.xml
+new file mode 100644
+index 00000000..f841b960
+--- /dev/null
++++ b/libs/gradle-model-core/pom.xml
+@@ -0,0 +1,32 @@
++<?xml version="1.0" encoding="US-ASCII"?>
++<!--
++ ! Copyright (c) 2016-2017 Red Hat, Inc.
++ !
++ ! 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.
++ `-->
++<project xmlns="http://maven.apache.org/POM/4.0.0"
++         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
++         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
++                             http://maven.apache.org/xsd/maven-4.0.0.xsd">
++  <modelVersion>4.0.0</modelVersion>
++  <parent>
++    <groupId>org.fedoraproject.xmvn</groupId>
++    <artifactId>libs</artifactId>
++    <version>3.0.0</version>
++    <relativePath>..</relativePath>
++  </parent>
++  <groupId>org.gradle</groupId>
++  <artifactId>gradle-model-core</artifactId>
++  <version>${gradleVersion}</version>
++  <name>Gradle model-core module</name>
++</project>
+diff --git a/libs/pom.xml b/libs/pom.xml
+index 2b31c5d0..fc29e359 100644
+--- a/libs/pom.xml
++++ b/libs/pom.xml
+@@ -37,8 +37,11 @@
+     <module>gradle-base-services</module>
+     <module>gradle-base-services-groovy</module>
+     <module>gradle-core</module>
++    <module>gradle-core-api</module>
++    <module>gradle-model-core</module>
+     <module>gradle-dependency-management</module>
+     <module>gradle-resources</module>
++    <module>gradle-logging</module>
+   </modules>
+   <dependencies>
+     <dependency>
+diff --git a/xmvn-connector-gradle/pom.xml b/xmvn-connector-gradle/pom.xml
+index b433e5dd..f18a285e 100644
+--- a/xmvn-connector-gradle/pom.xml
++++ b/xmvn-connector-gradle/pom.xml
+@@ -54,11 +54,21 @@
+     </dependency>
+     <dependency>
+       <groupId>org.gradle</groupId>
++      <artifactId>gradle-core-api</artifactId>
++      <scope>provided</scope>
++    </dependency>
++    <dependency>
++      <groupId>org.gradle</groupId>
+       <artifactId>gradle-core</artifactId>
+       <scope>provided</scope>
+     </dependency>
+     <dependency>
+       <groupId>org.gradle</groupId>
++      <artifactId>gradle-model-core</artifactId>
++      <scope>provided</scope>
++    </dependency>
++    <dependency>
++      <groupId>org.gradle</groupId>
+       <artifactId>gradle-dependency-management</artifactId>
+       <scope>provided</scope>
+     </dependency>
+@@ -68,6 +78,11 @@
+       <scope>provided</scope>
+     </dependency>
+     <dependency>
++      <groupId>org.gradle</groupId>
++      <artifactId>gradle-logging</artifactId>
++      <scope>provided</scope>
++    </dependency>
++    <dependency>
+       <groupId>org.apache.ivy</groupId>
+       <artifactId>ivy</artifactId>
+       <scope>provided</scope>
+diff --git a/xmvn-connector-gradle/src/main/java/org/fedoraproject/xmvn/connector/gradle/GradleResolver.java b/xmvn-connector-gradle/src/main/java/org/fedoraproject/xmvn/connector/gradle/GradleResolver.java
+index a81c5bc0..6305aa86 100644
+--- a/xmvn-connector-gradle/src/main/java/org/fedoraproject/xmvn/connector/gradle/GradleResolver.java
++++ b/xmvn-connector-gradle/src/main/java/org/fedoraproject/xmvn/connector/gradle/GradleResolver.java
+@@ -18,41 +18,47 @@ package org.fedoraproject.xmvn.connector.gradle;
+ import java.nio.file.Path;
+ import java.util.Collections;
+ import java.util.LinkedHashSet;
++import java.util.Map;
+ import java.util.Set;
+ 
++import org.gradle.api.artifacts.ComponentMetadataSupplier;
+ import org.gradle.api.artifacts.ModuleVersionIdentifier;
++import org.gradle.api.artifacts.component.ComponentArtifactIdentifier;
+ import org.gradle.api.artifacts.component.ModuleComponentIdentifier;
++import org.gradle.api.internal.artifacts.ImmutableModuleIdentifierFactory;
+ import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.ConfiguredModuleComponentRepository;
+ import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.ModuleComponentRepositoryAccess;
+ import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.parser.DescriptorParseContext;
+-import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.parser.GradlePomModuleDescriptorParser;
+ import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.parser.MetaDataParser;
+-import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.strategy.DefaultVersionComparator;
+-import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.strategy.DefaultVersionSelectorScheme;
++import org.gradle.api.internal.artifacts.ivyservice.resolveengine.artifact.ResolvableArtifact;
+ import org.gradle.api.internal.artifacts.repositories.AbstractArtifactRepository;
+ import org.gradle.api.internal.artifacts.repositories.ResolutionAwareRepository;
++import org.gradle.api.internal.artifacts.repositories.resolver.MetadataFetchingCost;
+ import org.gradle.api.internal.component.ArtifactType;
+-import org.gradle.internal.component.external.model.DefaultMavenModuleResolveMetaData;
+-import org.gradle.internal.component.external.model.DefaultModuleComponentArtifactMetaData;
+-import org.gradle.internal.component.external.model.ModuleComponentResolveMetaData;
+-import org.gradle.internal.component.external.model.MutableModuleComponentResolveMetaData;
+-import org.gradle.internal.component.model.ComponentArtifactMetaData;
++import org.gradle.internal.component.external.model.DefaultModuleComponentArtifactMetadata;
++import org.gradle.internal.component.external.model.DefaultMutableMavenModuleResolveMetadata;
++import org.gradle.internal.component.external.model.FixedComponentArtifacts;
++import org.gradle.internal.component.external.model.ModuleComponentArtifactMetadata;
++import org.gradle.internal.component.external.model.ModuleComponentResolveMetadata;
++import org.gradle.internal.component.external.model.MutableMavenModuleResolveMetadata;
++import org.gradle.internal.component.external.model.MutableModuleComponentResolveMetadata;
++import org.gradle.internal.component.model.ComponentArtifactMetadata;
+ import org.gradle.internal.component.model.ComponentOverrideMetadata;
+-import org.gradle.internal.component.model.ComponentResolveMetaData;
+-import org.gradle.internal.component.model.ComponentUsage;
++import org.gradle.internal.component.model.ComponentResolveMetadata;
+ import org.gradle.internal.component.model.DefaultIvyArtifactName;
+-import org.gradle.internal.component.model.DependencyMetaData;
++import org.gradle.internal.component.model.DependencyMetadata;
+ import org.gradle.internal.component.model.IvyArtifactName;
+ import org.gradle.internal.component.model.ModuleSource;
+ import org.gradle.internal.resolve.ArtifactResolveException;
+ import org.gradle.internal.resolve.ModuleVersionResolveException;
+ import org.gradle.internal.resolve.result.BuildableArtifactResolveResult;
+ import org.gradle.internal.resolve.result.BuildableArtifactSetResolveResult;
++import org.gradle.internal.resolve.result.BuildableComponentArtifactsResolveResult;
+ import org.gradle.internal.resolve.result.BuildableModuleComponentMetaDataResolveResult;
+ import org.gradle.internal.resolve.result.BuildableModuleVersionListingResolveResult;
+-import org.gradle.internal.resource.local.DefaultLocallyAvailableExternalResource;
+-import org.gradle.internal.resource.local.DefaultLocallyAvailableResource;
++import org.gradle.internal.resource.local.FileResourceRepository;
+ import org.gradle.internal.resource.local.LocallyAvailableExternalResource;
++import org.gradle.internal.resource.metadata.DefaultExternalResourceMetaData;
+ import org.slf4j.Logger;
+ import org.slf4j.LoggerFactory;
+ 
+@@ -72,6 +78,21 @@ public class GradleResolver
+     implements ResolutionAwareRepository, ConfiguredModuleComponentRepository, ModuleComponentRepositoryAccess,
+     DescriptorParseContext
+ {
++    public GradleResolver( MetaDataParser<MutableMavenModuleResolveMetadata> pomParser,
++                           ImmutableModuleIdentifierFactory moduleIdentifierFactory,
++                           FileResourceRepository fileRepository )
++    {
++        this.pomParser = pomParser;
++        this.moduleIdentifierFactory = moduleIdentifierFactory;
++        this.fileRepository = fileRepository;
++    }
++
++    private MetaDataParser<MutableMavenModuleResolveMetadata> pomParser;
++
++    private ImmutableModuleIdentifierFactory moduleIdentifierFactory;
++
++    private FileResourceRepository fileRepository;
++
+     private final Logger logger = LoggerFactory.getLogger( GradleResolver.class );
+ 
+     static class LazyLocatorProvider
+@@ -135,17 +156,17 @@ public class GradleResolver
+     }
+ 
+     @Override
+-    public void listModuleVersions( DependencyMetaData arg0, BuildableModuleVersionListingResolveResult arg1 )
++    public void listModuleVersions( DependencyMetadata arg0, BuildableModuleVersionListingResolveResult arg1 )
+     {
+         logger.debug( "listModuleVersions() called, but it is NOT IMPLEMENTED" );
+     }
+ 
+     @Override
+-    public void resolveArtifact( ComponentArtifactMetaData artifact, ModuleSource module,
++    public void resolveArtifact( ComponentArtifactMetadata artifact, ModuleSource module,
+                                  BuildableArtifactResolveResult result )
+     {
+         ModuleVersionIdentifier moduleId =
+-            ( (DefaultModuleComponentArtifactMetaData) artifact ).toArtifactIdentifier().getModuleVersionIdentifier();
++            ( (DefaultModuleComponentArtifactMetadata) artifact ).toArtifactIdentifier().getModuleVersionIdentifier();
+         String groupId = moduleId.getGroup();
+         String artifactId = artifact.getName().getName();
+         String extension = artifact.getName().getExtension();
+@@ -180,11 +201,9 @@ public class GradleResolver
+         {
+             logger.debug( "Found Maven POM: {}", pomPath );
+ 
+-            MetaDataParser<DefaultMavenModuleResolveMetaData> parser =
+-                new GradlePomModuleDescriptorParser( new DefaultVersionSelectorScheme( new DefaultVersionComparator() ) );
+-            MutableModuleComponentResolveMetaData metaData = parser.parseMetaData( this, pomPath.toFile() );
++            MutableModuleComponentResolveMetadata metaData = pomParser.parseMetaData( this, pomPath.toFile() );
+ 
+-            result.resolved( metaData );
++            result.resolved( metaData.asImmutable() );
+             return;
+         }
+         else
+@@ -204,9 +223,11 @@ public class GradleResolver
+                 if ( path != null )
+                 {
+                     logger.debug( "Artifact {} found, returning minimal model", artifact3 );
+-                    MutableModuleComponentResolveMetaData metaData =
+-                        new DefaultMavenModuleResolveMetaData( id, request.getArtifacts() );
+-                    result.resolved( metaData );
++                    ModuleVersionIdentifier mvi =
++                        moduleIdentifierFactory.moduleWithVersion( id.getGroup(), id.getModule(), id.getVersion() );
++                    MutableModuleComponentResolveMetadata metaData =
++                        new DefaultMutableMavenModuleResolveMetadata( mvi, id, request.getArtifacts() );
++                    result.resolved( metaData.asImmutable() );
+                     return;
+                 }
+             }
+@@ -224,24 +245,15 @@ public class GradleResolver
+ 
+         if ( artifactSet.isEmpty() )
+         {
+-            artifactSet.add( new DefaultIvyArtifactName( id.getModule(), "jar", "jar",
+-                                                         Collections.<String, String>emptyMap() ) );
++            artifactSet.add( new DefaultIvyArtifactName( id.getModule(), "jar", "jar", null ) );
+         }
+ 
+         return artifactSet;
+     }
+ 
+     @Override
+-    public void resolveModuleArtifacts( ComponentResolveMetaData component, ComponentUsage usage,
+-                                        BuildableArtifactSetResolveResult result )
+-    {
+-        result.resolved( Collections.singleton( ( (ModuleComponentResolveMetaData) component ).artifact( "jar", "jar",
+-                                                                                                         null ) ) );
+-    }
+-
+-    @Override
+-    public void resolveModuleArtifacts( ComponentResolveMetaData component, ArtifactType type,
+-                                        BuildableArtifactSetResolveResult result )
++    public void resolveArtifactsWithType( ComponentResolveMetadata component, ArtifactType type,
++                                          BuildableArtifactSetResolveResult result )
+     {
+         if ( type != ArtifactType.MAVEN_POM )
+         {
+@@ -250,15 +262,22 @@ public class GradleResolver
+             return;
+         }
+ 
+-        ModuleComponentResolveMetaData metaData = (ModuleComponentResolveMetaData) component;
+-        ModuleComponentIdentifier id = metaData.getComponentId();
++        ModuleComponentIdentifier id = (ModuleComponentIdentifier) component.getComponentId();
+         DefaultIvyArtifactName name = new DefaultIvyArtifactName( id.getModule(), "pom", "pom" );
+-        DefaultModuleComponentArtifactMetaData resolvedMetaData =
+-            new DefaultModuleComponentArtifactMetaData( id, name );
++        DefaultModuleComponentArtifactMetadata resolvedMetaData =
++            new DefaultModuleComponentArtifactMetadata( id, name );
+         result.resolved( Collections.singleton( resolvedMetaData ) );
+     }
+ 
+     @Override
++    public void resolveArtifacts( ComponentResolveMetadata component, BuildableComponentArtifactsResolveResult result )
++    {
++        ModuleComponentArtifactMetadata artifact =
++            ( (ModuleComponentResolveMetadata) component ).artifact( "jar", "jar", null );
++        result.resolved( new FixedComponentArtifacts( Collections.singleton( artifact ) ) );
++    }
++
++    @Override
+     public LocallyAvailableExternalResource getMetaDataArtifact( ModuleComponentIdentifier id, ArtifactType type )
+     {
+         Path pomPath = resolve( new DefaultArtifact( id.getGroup(), id.getModule(), "pom", id.getVersion() ) );
+@@ -266,7 +285,25 @@ public class GradleResolver
+         if ( pomPath == null )
+             return null;
+ 
+-        return new DefaultLocallyAvailableExternalResource( pomPath.toUri(),
+-                                                            new DefaultLocallyAvailableResource( pomPath.toFile() ) );
++        DefaultExternalResourceMetaData metadata = new DefaultExternalResourceMetaData( pomPath.toUri(), 0, 0 );
++        return fileRepository.resource( pomPath.toFile(), pomPath.toUri(), metadata );
++    }
++
++    @Override
++    public ComponentMetadataSupplier createMetadataSupplier()
++    {
++        return null;
++    }
++
++    @Override
++    public Map<ComponentArtifactIdentifier, ResolvableArtifact> getArtifactCache()
++    {
++        return Collections.emptyMap();
++    }
++
++    @Override
++    public MetadataFetchingCost estimateMetadataFetchingCost( ModuleComponentIdentifier arg0 )
++    {
++        return MetadataFetchingCost.CHEAP;
+     }
+ }
+diff --git a/xmvn-connector-gradle/src/main/java/org/fedoraproject/xmvn/connector/gradle/XMvnGradlePlugin.java b/xmvn-connector-gradle/src/main/java/org/fedoraproject/xmvn/connector/gradle/XMvnGradlePlugin.java
+index 2646f098..c3250e3c 100644
+--- a/xmvn-connector-gradle/src/main/java/org/fedoraproject/xmvn/connector/gradle/XMvnGradlePlugin.java
++++ b/xmvn-connector-gradle/src/main/java/org/fedoraproject/xmvn/connector/gradle/XMvnGradlePlugin.java
+@@ -15,9 +15,11 @@
+  */
+ package org.fedoraproject.xmvn.connector.gradle;
+ 
++import groovy.lang.Closure;
++import groovy.lang.GroovyShell;
+ import org.gradle.api.Plugin;
+ import org.gradle.api.Task;
+-import org.gradle.api.artifacts.repositories.ArtifactRepository;
++import org.gradle.api.artifacts.dsl.RepositoryHandler;
+ import org.gradle.api.invocation.Gradle;
+ 
+ /**
+@@ -26,15 +28,17 @@ import org.gradle.api.invocation.Gradle;
+ public class XMvnGradlePlugin
+     implements Plugin<Gradle>
+ {
++    private void configureRepositories( RepositoryHandler repositories )
++    {
++        repositories.configure( (Closure<?>) new GroovyShell().evaluate( "{ it -> xmvn() }" ) );
++    }
++
+     @Override
+     public void apply( Gradle gradle )
+     {
+-        ArtifactRepository repo = new GradleResolver();
+-        repo.setName( "xmvn" );
+-
+         gradle.allprojects( project -> {
+-            project.getRepositories().addFirst( repo );
+-            project.getBuildscript().getRepositories().addFirst( repo );
++            configureRepositories( project.getRepositories() );
++            configureRepositories( project.getBuildscript().getRepositories() );
+ 
+             Task upload = project.getTasks().create( "xmvnInstall", XMvnInstallTask.class );
+             upload.setDescription( "Installs all artifacts through XMvn" );
+diff --git a/xmvn-connector-gradle/src/main/java/org/fedoraproject/xmvn/connector/gradle/XMvnInstallTask.java b/xmvn-connector-gradle/src/main/java/org/fedoraproject/xmvn/connector/gradle/XMvnInstallTask.java
+index 196f4a5b..07905f1f 100644
+--- a/xmvn-connector-gradle/src/main/java/org/fedoraproject/xmvn/connector/gradle/XMvnInstallTask.java
++++ b/xmvn-connector-gradle/src/main/java/org/fedoraproject/xmvn/connector/gradle/XMvnInstallTask.java
+@@ -17,6 +17,7 @@ package org.fedoraproject.xmvn.connector.gradle;
+ 
+ import java.nio.file.Files;
+ import java.util.Collections;
++import java.util.HashSet;
+ import java.util.List;
+ import java.util.Set;
+ import java.util.stream.Collectors;
+@@ -32,7 +33,7 @@ import org.gradle.api.artifacts.PublishArtifact;
+ import org.gradle.api.artifacts.PublishException;
+ import org.gradle.api.component.SoftwareComponent;
+ import org.gradle.api.internal.component.SoftwareComponentInternal;
+-import org.gradle.api.internal.component.Usage;
++import org.gradle.api.internal.component.UsageContext;
+ import org.gradle.api.tasks.TaskAction;
+ 
+ import org.fedoraproject.xmvn.artifact.Artifact;
+@@ -83,7 +84,7 @@ class XMvnInstallTask
+             Project dependencyProject = projectDependency.getDependencyProject();
+             Stream<SoftwareComponent> components = dependencyProject.getComponents().stream();
+             Stream<SoftwareComponentInternal> internalComponents = components.map( c -> (SoftwareComponentInternal) c );
+-            Stream<Usage> usages = internalComponents.flatMap( ic -> ic.getUsages().stream() );
++            Stream<UsageContext> usages = internalComponents.flatMap( ic -> ic.getUsages().stream() );
+             Stream<PublishArtifact> publishArtifacts = usages.flatMap( usage -> usage.getArtifacts().stream() );
+             Stream<Artifact> artifacts = publishArtifacts.map( pa -> getPublishArtifact( dependencyProject, pa ) );
+             return artifacts.collect( Collectors.toList() );
+@@ -144,7 +145,13 @@ class XMvnInstallTask
+             }
+         }
+ 
+-        DeploymentResult result = getDeployer().deploy( request );
++        DeploymentResult result;
++
++        // prevent parallel access to installation plan
++        synchronized ( XMvnInstallTask.class )
++        {
++            result = getDeployer().deploy( request );
++        }
+ 
+         if ( result.getException() != null )
+         {
+@@ -155,17 +162,22 @@ class XMvnInstallTask
+     @TaskAction
+     protected void deployProject()
+     {
++        Set<PublishArtifact> seenArtifacts = new HashSet<>();
++
+         for ( SoftwareComponent component : getProject().getComponents() )
+         {
+             SoftwareComponentInternal internalComponent = (SoftwareComponentInternal) component;
+ 
+-            for ( Usage usage : internalComponent.getUsages() )
++            for ( UsageContext usage : internalComponent.getUsages() )
+             {
+                 Set<ModuleDependency> dependencies = usage.getDependencies();
+ 
+                 for ( PublishArtifact artifact : usage.getArtifacts() )
+                 {
+-                    deploy( artifact, dependencies );
++                    if ( seenArtifacts.add( artifact ) )
++                    {
++                        deploy( artifact, dependencies );
++                    }
+                 }
+             }
+         }
+diff --git a/xmvn-parent/pom.xml b/xmvn-parent/pom.xml
+index 661cc24d..7e7a6d94 100644
+--- a/xmvn-parent/pom.xml
++++ b/xmvn-parent/pom.xml
+@@ -84,7 +84,7 @@
+     <atinjectVersion>1</atinjectVersion>
+     <ivyVersion>2.4.0</ivyVersion>
+     <jcommanderVersion>1.64</jcommanderVersion>
+-    <gradleVersion>2.13-rc-1</gradleVersion>
++    <gradleVersion>4.2.1</gradleVersion>
+     <groovyVersion>2.4.10</groovyVersion>
+     <mavenInvokerVersion>2.2</mavenInvokerVersion>
+     <mavenResolverVersion>1.0.3</mavenResolverVersion>
+@@ -278,11 +278,21 @@
+       </dependency>
+       <dependency>
+         <groupId>org.gradle</groupId>
++        <artifactId>gradle-core-api</artifactId>
++        <version>${gradleVersion}</version>
++      </dependency>
++      <dependency>
++        <groupId>org.gradle</groupId>
+         <artifactId>gradle-core</artifactId>
+         <version>${gradleVersion}</version>
+       </dependency>
+       <dependency>
+         <groupId>org.gradle</groupId>
++        <artifactId>gradle-model-core</artifactId>
++        <version>${gradleVersion}</version>
++      </dependency>
++      <dependency>
++        <groupId>org.gradle</groupId>
+         <artifactId>gradle-dependency-management</artifactId>
+         <version>${gradleVersion}</version>
+       </dependency>
+@@ -292,6 +302,11 @@
+         <version>${gradleVersion}</version>
+       </dependency>
+       <dependency>
++        <groupId>org.gradle</groupId>
++        <artifactId>gradle-logging</artifactId>
++        <version>${gradleVersion}</version>
++      </dependency>
++      <dependency>
+         <groupId>org.codehaus.groovy</groupId>
+         <artifactId>groovy-all</artifactId>
+         <version>${groovyVersion}</version>
+-- 
+2.13.6
+

SOURCES/0001-Port-to-Gradle-4.3.1.patch

@@ -0,0 +1,62 @@
+From cd6cf796f7c2230c940f95f46dc905a25152c486 Mon Sep 17 00:00:00 2001
+From: Michael Simacek <msimacek@redhat.com>
+Date: Fri, 10 Nov 2017 15:13:45 +0200
+Subject: [PATCH] Port to Gradle 4.3.1
+
+---
+ .../java/org/fedoraproject/xmvn/connector/gradle/GradleResolver.java  | 2 +-
+ .../java/org/fedoraproject/xmvn/connector/gradle/XMvnInstallTask.java | 4 ++--
+ xmvn-parent/pom.xml                                                   | 2 +-
+ 3 files changed, 4 insertions(+), 4 deletions(-)
+
+diff --git a/xmvn-connector-gradle/src/main/java/org/fedoraproject/xmvn/connector/gradle/GradleResolver.java b/xmvn-connector-gradle/src/main/java/org/fedoraproject/xmvn/connector/gradle/GradleResolver.java
+index 6305aa86..9e1a247a 100644
+--- a/xmvn-connector-gradle/src/main/java/org/fedoraproject/xmvn/connector/gradle/GradleResolver.java
++++ b/xmvn-connector-gradle/src/main/java/org/fedoraproject/xmvn/connector/gradle/GradleResolver.java
+@@ -226,7 +226,7 @@ public class GradleResolver
+                     ModuleVersionIdentifier mvi =
+                         moduleIdentifierFactory.moduleWithVersion( id.getGroup(), id.getModule(), id.getVersion() );
+                     MutableModuleComponentResolveMetadata metaData =
+-                        new DefaultMutableMavenModuleResolveMetadata( mvi, id, request.getArtifacts() );
++                        DefaultMutableMavenModuleResolveMetadata.missing( mvi, id );
+                     result.resolved( metaData.asImmutable() );
+                     return;
+                 }
+diff --git a/xmvn-connector-gradle/src/main/java/org/fedoraproject/xmvn/connector/gradle/XMvnInstallTask.java b/xmvn-connector-gradle/src/main/java/org/fedoraproject/xmvn/connector/gradle/XMvnInstallTask.java
+index 07905f1f..d220e266 100644
+--- a/xmvn-connector-gradle/src/main/java/org/fedoraproject/xmvn/connector/gradle/XMvnInstallTask.java
++++ b/xmvn-connector-gradle/src/main/java/org/fedoraproject/xmvn/connector/gradle/XMvnInstallTask.java
+@@ -116,7 +116,7 @@ class XMvnInstallTask
+         } ).collect( Collectors.toList() );
+     }
+ 
+-    private void deploy( PublishArtifact gradleArtifact, Set<ModuleDependency> dependencies )
++    private void deploy( PublishArtifact gradleArtifact, Set<? extends ModuleDependency> dependencies )
+     {
+         DeploymentRequest request = new DeploymentRequest();
+ 
+@@ -170,7 +170,7 @@ class XMvnInstallTask
+ 
+             for ( UsageContext usage : internalComponent.getUsages() )
+             {
+-                Set<ModuleDependency> dependencies = usage.getDependencies();
++                Set<? extends ModuleDependency> dependencies = usage.getDependencies();
+ 
+                 for ( PublishArtifact artifact : usage.getArtifacts() )
+                 {
+diff --git a/xmvn-parent/pom.xml b/xmvn-parent/pom.xml
+index 7e7a6d94..910e27b6 100644
+--- a/xmvn-parent/pom.xml
++++ b/xmvn-parent/pom.xml
+@@ -84,7 +84,7 @@
+     <atinjectVersion>1</atinjectVersion>
+     <ivyVersion>2.4.0</ivyVersion>
+     <jcommanderVersion>1.64</jcommanderVersion>
+-    <gradleVersion>4.2.1</gradleVersion>
++    <gradleVersion>4.3.1</gradleVersion>
+     <groovyVersion>2.4.10</groovyVersion>
+     <mavenInvokerVersion>2.2</mavenInvokerVersion>
+     <mavenResolverVersion>1.0.3</mavenResolverVersion>
+-- 
+2.13.6
+

SOURCES/0001-Support-setting-Xdoclint-none-in-m-javadoc-p-3.0.0.patch

@@ -0,0 +1,30 @@
+From 9aa9c66be355d95e2c532bbdfdc98bdbba9b6606 Mon Sep 17 00:00:00 2001
+From: Michael Simacek <msimacek@redhat.com>
+Date: Thu, 7 Dec 2017 15:50:52 +0200
+Subject: [PATCH] Support setting "-Xdoclint:none" in m-javadoc-p >= 3.0.0
+
+maven-javadoc-plugin 3.0.0 replaced `additionalparam` string property
+with `additionalOptions` list property.
+See: https://issues.apache.org/jira/browse/MJAVADOC-368
+---
+ .../fedoraproject/xmvn/connector/aether/XMvnMojoExecutionListener.java | 3 +++
+ 1 file changed, 3 insertions(+)
+
+diff --git a/xmvn-connector-aether/src/main/java/org/fedoraproject/xmvn/connector/aether/XMvnMojoExecutionListener.java b/xmvn-connector-aether/src/main/java/org/fedoraproject/xmvn/connector/aether/XMvnMojoExecutionListener.java
+index 5f9b5dd4..bb066638 100644
+--- a/xmvn-connector-aether/src/main/java/org/fedoraproject/xmvn/connector/aether/XMvnMojoExecutionListener.java
++++ b/xmvn-connector-aether/src/main/java/org/fedoraproject/xmvn/connector/aether/XMvnMojoExecutionListener.java
+@@ -267,7 +267,10 @@ public class XMvnMojoExecutionListener
+         // Disable doclint
+         if ( JAVADOC_AGGREGATE.equals( execution ) )
+         {
++            // maven-javadoc-plugin < 3.0.0
+             trySetBeanProperty( mojo, "additionalparam", "-Xdoclint:none" );
++            // maven-javadoc-plugin >= 3.0.0
++            trySetBeanProperty( mojo, "additionalOptions", new String[] { "-Xdoclint:none" } );
+         }
+         else if ( XMVN_BUILDDEP.equals( execution ) )
+         {
+-- 
+2.14.3
+

SOURCES/0001-Use-apache-commons-compress-for-manifest-injection-a.patch

@@ -0,0 +1,593 @@
+From 4e1e7377d6318d2bd7dd8620269e172a704650e2 Mon Sep 17 00:00:00 2001
+From: Michael Simacek <msimacek@redhat.com>
+Date: Mon, 16 Apr 2018 15:29:50 +0200
+Subject: [PATCH] Use apache-commons-compress for manifest injection and native
+ code detection
+
+---
+ xmvn-parent/pom.xml                                |   8 +-
+ xmvn-tools/xmvn-install/pom.xml                    |   4 +
+ .../fedoraproject/xmvn/tools/install/JarUtils.java | 176 +++++++++------------
+ .../xmvn/tools/install/impl/JarUtilsTest.java      |  55 +++++++
+ .../src/test/resources/recompression-size.jar      | Bin 0 -> 4376 bytes
+ xmvn.spec                                          |   3 +-
+ 6 files changed, 140 insertions(+), 106 deletions(-)
+ create mode 100644 xmvn-tools/xmvn-install/src/test/resources/recompression-size.jar
+
+diff --git a/xmvn-parent/pom.xml b/xmvn-parent/pom.xml
+index df6af7fb..f6465d90 100644
+--- a/xmvn-parent/pom.xml
++++ b/xmvn-parent/pom.xml
+@@ -92,6 +92,7 @@
+     <plexusUtilsVersion>3.0.24</plexusUtilsVersion>
+     <pluginToolsVersion>3.5</pluginToolsVersion>
+     <slf4jVersion>1.7.25</slf4jVersion>
++    <commonsCompressVersion>1.16.1</commonsCompressVersion>
+ 
+     <!-- Build dependencies -->
+     <apivizVersion>1.3.2.GA</apivizVersion>
+@@ -102,7 +103,7 @@
+     <compilerPluginVersion>3.6.1</compilerPluginVersion>
+     <dependencyPluginVersion>3.0.0</dependencyPluginVersion>
+     <deployPluginVersion>2.8.2</deployPluginVersion>
+-    <easymockVersion>3.4</easymockVersion>
++    <easymockVersion>3.5</easymockVersion>
+     <gpgPluginVersion>1.6</gpgPluginVersion>
+     <installPluginVersion>2.5.2</installPluginVersion>
+     <jacocoVersion>0.7.9</jacocoVersion>
+@@ -321,6 +322,11 @@
+         <artifactId>plexus-container-default</artifactId>
+         <version>${plexusVersion}</version>
+       </dependency>
++      <dependency>
++        <groupId>org.apache.commons</groupId>
++        <artifactId>commons-compress</artifactId>
++        <version>${commonsCompressVersion}</version>
++      </dependency>
+     </dependencies>
+   </dependencyManagement>
+   <dependencies>
+diff --git a/xmvn-tools/xmvn-install/pom.xml b/xmvn-tools/xmvn-install/pom.xml
+index 66ac01d7..fbb36a68 100644
+--- a/xmvn-tools/xmvn-install/pom.xml
++++ b/xmvn-tools/xmvn-install/pom.xml
+@@ -61,5 +61,9 @@
+       <groupId>org.ow2.asm</groupId>
+       <artifactId>asm</artifactId>
+     </dependency>
++    <dependency>
++      <groupId>org.apache.commons</groupId>
++      <artifactId>commons-compress</artifactId>
++    </dependency>
+   </dependencies>
+ </project>
+diff --git a/xmvn-tools/xmvn-install/src/main/java/org/fedoraproject/xmvn/tools/install/JarUtils.java b/xmvn-tools/xmvn-install/src/main/java/org/fedoraproject/xmvn/tools/install/JarUtils.java
+index 98d3a57e..5cb62b0f 100644
+--- a/xmvn-tools/xmvn-install/src/main/java/org/fedoraproject/xmvn/tools/install/JarUtils.java
++++ b/xmvn-tools/xmvn-install/src/main/java/org/fedoraproject/xmvn/tools/install/JarUtils.java
+@@ -16,19 +16,16 @@
+ package org.fedoraproject.xmvn.tools.install;
+ 
+ import java.io.IOException;
+-import java.lang.reflect.Field;
++import java.io.InputStream;
+ import java.nio.file.Files;
+ import java.nio.file.Path;
+-import java.util.Collection;
++import java.util.Enumeration;
+ import java.util.jar.Attributes;
+-import java.util.jar.JarEntry;
+-import java.util.jar.JarInputStream;
+-import java.util.jar.JarOutputStream;
+ import java.util.jar.Manifest;
+-import java.util.zip.ZipEntry;
+-import java.util.zip.ZipInputStream;
+-import java.util.zip.ZipOutputStream;
+ 
++import org.apache.commons.compress.archivers.zip.ZipArchiveEntry;
++import org.apache.commons.compress.archivers.zip.ZipArchiveOutputStream;
++import org.apache.commons.compress.archivers.zip.ZipFile;
+ import org.objectweb.asm.ClassReader;
+ import org.objectweb.asm.ClassVisitor;
+ import org.objectweb.asm.MethodVisitor;
+@@ -43,6 +40,8 @@ import org.fedoraproject.xmvn.artifact.Artifact;
+  */
+ public final class JarUtils
+ {
++    private static final String MANIFEST_PATH = "META-INF/MANIFEST.MF";
++
+     private static final Logger LOGGER = LoggerFactory.getLogger( JarUtils.class );
+ 
+     // From /usr/include/linux/elf.h
+@@ -67,28 +66,33 @@ public final class JarUtils
+      * 
+      * @return {@code true} if native code was found inside given JAR
+      */
+-    public static boolean containsNativeCode( Path jar )
++    public static boolean containsNativeCode( Path jarPath )
+     {
+-        try ( ZipInputStream jis = new ZipInputStream( Files.newInputStream( jar ) ) )
++        try ( ZipFile jar = new ZipFile( jarPath.toFile() ) )
+         {
+-            ZipEntry ent;
+-            while ( ( ent = jis.getNextEntry() ) != null )
++            Enumeration<ZipArchiveEntry> entries = jar.getEntries();
++            while ( entries.hasMoreElements() )
+             {
+-                if ( ent.isDirectory() )
++                ZipArchiveEntry entry = entries.nextElement();
++                if ( entry.isDirectory() )
+                     continue;
+-                if ( jis.read() == ELFMAG0 && jis.read() == ELFMAG1 && jis.read() == ELFMAG2 && jis.read() == ELFMAG3 )
++                try ( InputStream jis = jar.getInputStream( entry ) )
+                 {
+-                    LOGGER.debug( "Native code found inside {}: {}", jar, ent.getName() );
+-                    return true;
++                    if ( jis.read() == ELFMAG0 && jis.read() == ELFMAG1 && jis.read() == ELFMAG2
++                        && jis.read() == ELFMAG3 )
++                    {
++                        LOGGER.debug( "Native code found inside {}: {}", jarPath, entry.getName() );
++                        return true;
++                    }
+                 }
+             }
+ 
+-            LOGGER.trace( "Native code not found inside {}", jar );
++            LOGGER.trace( "Native code not found inside {}", jarPath );
+             return false;
+         }
+         catch ( IOException e )
+         {
+-            LOGGER.debug( "I/O exception caught when trying to determine whether JAR contains native code: {}", jar,
++            LOGGER.debug( "I/O exception caught when trying to determine whether JAR contains native code: {}", jarPath,
+                           e );
+             return false;
+         }
+@@ -122,40 +126,47 @@ public final class JarUtils
+      * 
+      * @return {@code true} given JAR as found inside to use native code
+      */
+-    public static boolean usesNativeCode( Path jar )
++    public static boolean usesNativeCode( Path jarPath )
+     {
+-        try ( ZipInputStream jis = new ZipInputStream( Files.newInputStream( jar ) ) )
++        try ( ZipFile jar = new ZipFile( jarPath.toFile() ) )
+         {
+-            ZipEntry ent;
+-            while ( ( ent = jis.getNextEntry() ) != null )
++            Enumeration<ZipArchiveEntry> entries = jar.getEntries();
++            while ( entries.hasMoreElements() )
+             {
+-                final String entryName = ent.getName();
+-                if ( ent.isDirectory() || !entryName.endsWith( ".class" ) )
++                ZipArchiveEntry entry = entries.nextElement();
++                final String entryName = entry.getName();
++                if ( entry.isDirectory() || !entryName.endsWith( ".class" ) )
+                     continue;
+ 
+-                new ClassReader( jis ).accept( new ClassVisitor( Opcodes.ASM4 )
++                try ( InputStream jis = jar.getInputStream( entry ) )
+                 {
+-                    @Override
+-                    public MethodVisitor visitMethod( int flags, String name, String desc, String sig, String[] exc )
++                    new ClassReader( jis ).accept( new ClassVisitor( Opcodes.ASM4 )
+                     {
+-                        if ( ( flags & Opcodes.ACC_NATIVE ) != 0 )
+-                            throw new NativeMethodFound( entryName, name, sig );
++                        @Override
++                        public MethodVisitor visitMethod( int flags, String name, String desc, String sig,
++                                                          String[] exc )
++                        {
++                            if ( ( flags & Opcodes.ACC_NATIVE ) != 0 )
++                                throw new NativeMethodFound( entryName, name, sig );
+ 
+-                        return super.visitMethod( flags, name, desc, sig, exc );
+-                    }
+-                }, ClassReader.SKIP_CODE );
++                            return super.visitMethod( flags, name, desc, sig, exc );
++                        }
++                    }, ClassReader.SKIP_CODE );
++                }
+             }
+ 
+             return false;
+         }
+         catch ( NativeMethodFound e )
+         {
+-            LOGGER.debug( "Native method {}({}) found in {}: {}", e.methodName, e.methodSignature, jar, e.className );
++            LOGGER.debug( "Native method {}({}) found in {}: {}", e.methodName, e.methodSignature, jarPath,
++                          e.className );
+             return true;
+         }
+         catch ( IOException e )
+         {
+-            LOGGER.debug( "I/O exception caught when trying to determine whether JAR uses native code: {}", jar, e );
++            LOGGER.debug( "I/O exception caught when trying to determine whether JAR uses native code: {}", jarPath,
++                          e );
+             return false;
+         }
+         catch ( RuntimeException e )
+@@ -178,29 +189,13 @@ public final class JarUtils
+         }
+     }
+ 
+-    /**
+-     * OpenJDK has a sanity check that prevents adding duplicate entries to ZIP streams. The problem is that some of
+-     * JARs we try to inject manifests to (especially the ones created by Gradle) already contain duplicate entries, so
+-     * manifest injection would always fail for them with "ZipException: duplicate entry".
+-     * <p>
+-     * This function tries to work around this OpenJDK sanity check, effectively allowing creating ZIP files with
+-     * duplicated entries. It should be called on particular ZIP output stream before adding each duplicate entry.
+-     * 
+-     * @param zipOutputStream ZIP stream to hack
+-     */
+-    private static void openJdkAvoidDuplicateEntryHack( ZipOutputStream zipOutputStream )
++    private static void updateManifest( Artifact artifact, Manifest mf )
+     {
+-        try
+-        {
+-            Field namesField = ZipOutputStream.class.getDeclaredField( "names" );
+-            namesField.setAccessible( true );
+-            Collection<?> names = (Collection<?>) namesField.get( zipOutputStream );
+-            names.clear();
+-        }
+-        catch ( ReflectiveOperationException e )
+-        {
+-            // This hack relies on OpenJDK internals and therefore is not guaranteed to work. Ignore failures.
+-        }
++        putAttribute( mf, Artifact.MF_KEY_GROUPID, artifact.getGroupId(), null );
++        putAttribute( mf, Artifact.MF_KEY_ARTIFACTID, artifact.getArtifactId(), null );
++        putAttribute( mf, Artifact.MF_KEY_EXTENSION, artifact.getExtension(), Artifact.DEFAULT_EXTENSION );
++        putAttribute( mf, Artifact.MF_KEY_CLASSIFIER, artifact.getClassifier(), "" );
++        putAttribute( mf, Artifact.MF_KEY_VERSION, artifact.getVersion(), Artifact.DEFAULT_VERSION );
+     }
+ 
+     /**
+@@ -213,65 +208,38 @@ public final class JarUtils
+     public static void injectManifest( Path targetJar, Artifact artifact )
+     {
+         LOGGER.trace( "Trying to inject manifest to {}", artifact );
+-        Manifest mf = null;
+         try
+         {
+-            try ( JarInputStream jis = new JarInputStream( Files.newInputStream( targetJar ) ) )
++            try ( ZipFile jar = new ZipFile( targetJar.toFile() ) )
+             {
+-                mf = jis.getManifest();
+-                if ( mf == null )
++                ZipArchiveEntry manifestEntry = jar.getEntry( MANIFEST_PATH );
++                if ( manifestEntry != null )
+                 {
+-                    // getManifest sometimes doesn't find the manifest, try finding it as plain entry
+-                    ZipEntry ent;
+-                    while ( ( ent = jis.getNextEntry() ) != null )
++                    Manifest mf = new Manifest( jar.getInputStream( manifestEntry ) );
++                    updateManifest( artifact, mf );
++                    Files.delete( targetJar );
++                    try ( ZipArchiveOutputStream os = new ZipArchiveOutputStream( targetJar.toFile() ) )
+                     {
+-                        if ( ent.getName().equalsIgnoreCase( "META-INF/MANIFEST.MF" ) )
+-                        {
+-                            mf = new Manifest( jis );
+-                            break;
+-                        }
++                        // write manifest
++                        ZipArchiveEntry newManifestEntry = new ZipArchiveEntry( MANIFEST_PATH );
++                        os.putArchiveEntry( newManifestEntry );
++                        mf.write( os );
++                        os.closeArchiveEntry();
++                        // copy the rest of content
++                        jar.copyRawEntries( os, entry -> !entry.equals( manifestEntry ) );
+                     }
+-                }
+-            }
+-
+-            if ( mf == null )
+-            {
+-                LOGGER.trace( "Manifest injection skipped: no pre-existing manifest found to update" );
+-                return;
+-            }
+-
+-            putAttribute( mf, Artifact.MF_KEY_GROUPID, artifact.getGroupId(), null );
+-            putAttribute( mf, Artifact.MF_KEY_ARTIFACTID, artifact.getArtifactId(), null );
+-            putAttribute( mf, Artifact.MF_KEY_EXTENSION, artifact.getExtension(), Artifact.DEFAULT_EXTENSION );
+-            putAttribute( mf, Artifact.MF_KEY_CLASSIFIER, artifact.getClassifier(), "" );
+-            putAttribute( mf, Artifact.MF_KEY_VERSION, artifact.getVersion(), Artifact.DEFAULT_VERSION );
+-
+-            try ( JarInputStream jis = new JarInputStream( Files.newInputStream( targetJar ) ) )
+-            {
+-
+-                targetJar = targetJar.toRealPath();
+-                Files.delete( targetJar );
+-                try ( JarOutputStream jos = new JarOutputStream( Files.newOutputStream( targetJar ), mf ) )
+-                {
+-                    byte[] buf = new byte[512];
+-                    JarEntry entry;
+-                    while ( ( entry = jis.getNextJarEntry() ) != null )
++                    catch ( IOException e )
+                     {
+-                        openJdkAvoidDuplicateEntryHack( jos );
+-                        jos.putNextEntry( entry );
+-
+-                        int sz;
+-                        while ( ( sz = jis.read( buf ) ) > 0 )
+-                            jos.write( buf, 0, sz );
++                        // Re-throw exceptions that occur when processing JAR file after reading header and manifest.
++                        throw new RuntimeException( e );
+                     }
++                    LOGGER.trace( "Manifest injected successfully" );
+                 }
+-                catch ( IOException e )
++                else
+                 {
+-                    // Re-throw exceptions that occur when processing JAR file after reading header and manifest.
+-                    throw new RuntimeException( e );
++                    LOGGER.trace( "Manifest injection skipped: no pre-existing manifest found to update" );
++                    return;
+                 }
+-
+-                LOGGER.trace( "Manifest injected successfully" );
+             }
+         }
+         catch ( IOException e )
+diff --git a/xmvn-tools/xmvn-install/src/test/java/org/fedoraproject/xmvn/tools/install/impl/JarUtilsTest.java b/xmvn-tools/xmvn-install/src/test/java/org/fedoraproject/xmvn/tools/install/impl/JarUtilsTest.java
+index 3ec10cfa..98945a64 100644
+--- a/xmvn-tools/xmvn-install/src/test/java/org/fedoraproject/xmvn/tools/install/impl/JarUtilsTest.java
++++ b/xmvn-tools/xmvn-install/src/test/java/org/fedoraproject/xmvn/tools/install/impl/JarUtilsTest.java
+@@ -19,11 +19,13 @@ import static org.junit.Assert.assertEquals;
+ import static org.junit.Assert.assertFalse;
+ import static org.junit.Assert.assertNotNull;
+ import static org.junit.Assert.assertTrue;
++import static org.junit.Assume.assumeTrue;
+ 
+ import java.nio.file.Files;
+ import java.nio.file.Path;
+ import java.nio.file.Paths;
+ import java.nio.file.StandardCopyOption;
++import java.nio.file.attribute.PosixFilePermission;
+ import java.util.Arrays;
+ import java.util.jar.Attributes;
+ import java.util.jar.JarInputStream;
+@@ -116,6 +118,38 @@ public class JarUtilsTest
+         }
+     }
+ 
++    /**
++     * Regression test for a jar which contains an entry that can recompress with a different size, which caused a
++     * mismatch in sizes.
++     * 
++     * @throws Exception
++     */
++    @Test
++    public void testManifestInjectionRecompressionCausesSizeMismatch()
++        throws Exception
++    {
++        Path testResource = Paths.get( "src/test/resources/recompression-size.jar" );
++        Path testJar = workDir.resolve( "manifest.jar" );
++        Files.copy( testResource, testJar, StandardCopyOption.COPY_ATTRIBUTES, StandardCopyOption.REPLACE_EXISTING );
++
++        Artifact artifact =
++            new DefaultArtifact( "org.eclipse.osgi", "osgi.compatibility.state", "1.1.0.v20180409-1212" );
++        JarUtils.injectManifest( testJar, artifact );
++
++        try ( JarInputStream jis = new JarInputStream( Files.newInputStream( testJar ) ) )
++        {
++            Manifest mf = jis.getManifest();
++            assertNotNull( mf );
++
++            Attributes attr = mf.getMainAttributes();
++            assertNotNull( attr );
++
++            assertEquals( "org.eclipse.osgi", attr.getValue( "JavaPackages-GroupId" ) );
++            assertEquals( "osgi.compatibility.state", attr.getValue( "JavaPackages-ArtifactId" ) );
++            assertEquals( "1.1.0.v20180409-1212", attr.getValue( "JavaPackages-Version" ) );
++        }
++    }
++
+     /**
+      * Test JAR if manifest injection works as expected when some artifact fields have default values.
+      * 
+@@ -148,6 +182,27 @@ public class JarUtilsTest
+         }
+     }
+ 
++    /**
++     * Test JAR if manifest injection preserves sane file perms.
++     *
++     * @throws Exception
++     */
++    @Test
++    public void testManifestInjectionSanePermissions()
++            throws Exception
++    {
++        Path testResource = Paths.get( "src/test/resources/example.jar" );
++        Path testJar = workDir.resolve( "manifest.jar" );
++        Files.copy( testResource, testJar, StandardCopyOption.COPY_ATTRIBUTES, StandardCopyOption.REPLACE_EXISTING );
++
++        assumeTrue( "sane umask", Files.getPosixFilePermissions( testJar ).contains( PosixFilePermission.OTHERS_READ ) );
++
++        Artifact artifact = new DefaultArtifact( "org.apache.maven", "maven-model", "xsd", "model", "2.2.1" );
++        JarUtils.injectManifest( testJar, artifact );
++
++        assertTrue( Files.getPosixFilePermissions( testJar ).contains( PosixFilePermission.OTHERS_READ ) );
++    }
++
+     /**
+      * Test if native code detection works as expected.
+      * 
+diff --git a/xmvn-tools/xmvn-install/src/test/resources/recompression-size.jar b/xmvn-tools/xmvn-install/src/test/resources/recompression-size.jar
+new file mode 100644
+index 00000000..976481ea
+--- /dev/null
++++ b/xmvn-tools/xmvn-install/src/test/resources/recompression-size.jar
+@@ -0,0 +1,145 @@
++PK
++ûL“L²îMETA-INF/MANIFEST.MFUT	ÉGØZ;HØZux
³H³HManifest-Version: 1.0
++
++PK®L“Lõ–^]±¦»
dir/fileUT	7GØZ8GØZux
³H³HíÒáÃ0†áÿ½ËÓ«èÉÕ'
ùQJ	%äa6›m¾çu®,%<25>8£=úÓx}¼yýðû“?ûí<C3BB>WÛ³
TxPáí
ÔPáA…·TxP{@…ÔPáAí
TxP{@…µTxPáAí
ÔPj¨= ÂƒÚê„·ÔPPáí
ÞP{@A…·Tx{@í
ÞPPáA…·Tx{@A…ÞPPáí
TxáAA…µTxP{„ÔPáAí
µTxP{@…µÔPáAí
ÔP{@…µTx{@í
ÔPPáí
µTx{@A…·Ô…<C394>‚
++o(¨ðö€º0PPáí
ÔáAA…·TxP{„ÞPPáAíTxP{@…µGxPPáAí
ÔP*<¨= ÂƒÚêÂ@…µTxP{@]¨ð ö€‚
++o¨ÔPPáí
ua ÂƒÚ
++*¼= .Tx{@A…·TxPáí
ÔPáA…·TxP{@…ÞPPáAí
TxP{@…µTxPáAí
ÔPj¨= ÂƒÚê„·ÔPáAí
ÞP{@A…·Tx{@í
ÞPPáí
µTx{@A…ÞPPáí
TxáAA…µTxP{„ÔPáAíTxP{@…µÔPáAí
ÔP{@…µTx{@í
ÔPPáí
µTxP{@A…·Ô…<C394>‚
++o(¨ðö€º0PPáí
ÞP
++*¼=  ÂƒÚ#<(¨ðö€‚
++j<>ð  ÂƒÚ*<¨=ƒ‚
++j¨ð ö€
++*<¨= ÂƒÚêÂ@…µTxP{@]¨ð ö€
++j¨ÔPPáí
ua ÂƒÚ
++*¼= .Tx{@A…·TxPáí
ÞPPáA…·TxP{@…ÞPPáAí
TxP{@…µTxPáAí
ÔPáAí
µTxP{@]˜ðö€Ú*<¨=  ÂÛj¨ð ö€‚
++o¨=  ÂÛ
++*¼= ö€‚
++o(¨ð ÂÛ
++*¼=  Âƒ
++/<(¨ðö€‚
++j<>ð  ÂƒÚ*<¨=ƒ‚
++j¨ð ö
++*<¨= ÂƒÚj¨ð ö€
++j¨= ÂƒÚ
++*¼= ö€
++j(¨ðö€º0PáAí
ÞP
++*¼=  ÂÛêÂ@A…·TxP{„ÞPPáAíTx{@A…µGxPPáAí
ÔPáA…µTxP{@…ÔPáAí
ua ÂƒÚ*<¨= .TxP{@A…·Ô…<C394>
++j(¨ðö€º0P{@í
ÞPPáA…·Tx{@A…ÞPPáAí
Tx{@A…µTxPáí
ÔPáA…µTxP{@…µÔPáAí
ÔP{@…µTx{@í
ÔPPáí
µTx{@A…·ÔPPáí
ÞP{@A…·TxPá…ÞPPáAíTx{@A…µGxPPáAí
ÔáAA…µTxP{@í
ÔPáAí
µTxP{@…µÔPáAí
ÞP*<¨=  ÂÛêÂ@A…·Tx{@](¨ðö€‚
++o¨ÞPPáAíTx{@A…µGxPPáí
ÔPáA…µTxP{@…ÔPáAí
ua ÂƒÚ*<¨= .TxP{@…µÔ…<C394>
++j(¨ðö€º0P{@í
ÞPPáA…·Tx{@A…ÞPPáí
Tx{@A…µTxPáí
ÔPáA…·TxP{@…µÔPáAí
ÔP{@…µTx{@í
ÔPPáí
µTxP{@A…·ÔPPáí
ÞP{@A…·Tx{@](¨ðö€‚
++j<>ð  ÂÛ
++*<¨=ƒ‚
++j¨ð ö
++*<¨= ÂƒÚ#<(¨ð ö€
++j¨= ÂƒÚ*<¨= ö€
++j(¨ðö€º0PáAí
ÞP*<¨=  ÂÛêÂ@A…·Tx{@](¨ðö€‚
++o¨ÞPPáAíTx{@A…µTxPáAí
ÔPáA…µTxP{@…ÔPáAí
ua ÂƒÚ*<¨= .TxP{@…µÔ…<C394>Új(¨ðö€‚
++o¨=  ÂÛ
++*<¨ðö€‚
++o(¨ð ÂÛ
++*¼=  Âƒ
++o(¨ð ö€
++*¼=  ÂƒÚ*<¨= ö€
++j¨ð ö€Ú*<¨= ÂƒÚj¨ð ö€‚
++o¨= ÂƒÚ
++*¼= ö€
++j(¨ðö€Ú
++*¼=  ÂÛêÂ@A…·TxP{„ÞPPáAíTx{@A…µGxPPáAí
ÔáAA…µTxP{@í
ÔPáAí
µTxP{@…µÔ…<C394>
++j(¨ðö€º0PáAí
ÞP*<¨=  ÂÛêÂ@A…·Tx{@](¨ðö€‚
++j<>ð  ÂÛ
++*<¨= Âƒ
++o(¨ð ö€
++*<¨= ÂƒÚ*<¨ð ö€
++j¨ð ÂƒÚ*<¨= .TxP{@…µÔ…<C394>Új(¨ðö€‚
++o¨=  ÂÛ
++*¼= ö€‚
++o(¨ð ÂÛ
++*¼=  Âƒ
++o(¨ð ö€
++*¼=  ÂƒÚ*<¨=ƒ‚
++j¨ð ö€Ú*<¨= ÂƒÚj¨ð ö€
++j¨= ÂƒÚ
++*¼= ö€
++j(¨ðö€Ú
++*¼=  ÂÛêÂ@A…·Tx{@](¨ðö€‚
++j<>ð  ÂÛ
++*<¨=ƒ‚
++o(¨ð ö
++*<¨= ÂƒÚ#<(¨ð ö€
++j¨= ÂƒÚ*<¨= .TxP{@…µÔ…<C394>
++j(¨ðö€º0PáAí
ÞP
++*¼=  ÂÛêÂ@A…·Tx{@](¨ðö€‚
++j¨ð ÂÛ
++*<¨= Âƒ
++o(¨ð ö€
++*<¨= ÂƒÚ*<¨ð ö€
++j¨ÔPáAí
ua ö€Ú*<¨=  ÂÛj(¨ðö€‚
++o¨=  ÂÛ
++*<¨ðö€‚
++o(¨ð ÂÛ
++*¼=  Âƒ
++o(¨ð ö€
++j<>ð  ÂƒÚ*<¨=ƒ‚
++j¨ð ö€Ú*<¨= ÂƒÚj¨ð ö€‚
++o¨= ÂƒÚ
++*¼= ö€
++j(¨ðö€º0PPáí
ÞP
++*¼=  ÂÛêÂ@A…·TxP{„ÞPPáAíTxP{@…µGxPPáAí
ÔáAA…µTxP{@]¨ð ö€
++j¨ÔPPáí
ua ÂƒÚ
++*¼= .TxP{@A…·Ô…<C394>‚
++o(¨ðö€º0PPáí
ÞPPáA…·TxP{@…ÞPPáAí
TxP{@…µTxPáAí
ÔPáA…µTxP{@]¨= ö€
++j(¨ðö€Ú
++*¼=  ÂÛj(¨ðö€‚
++o¨=  ÂÛ
++*<¨ðö€‚
++o(¨ð ÂÛ
++*¼=  ÂƒÚ#<(¨ð ö€
++j<>ð  ÂƒÚ*<¨= ö€
++j¨ð ö€Ú*<¨= ÂƒÚj¨ð ö€‚
++o¨= ÂƒÚ
++*¼= .TxP{@A…·Ô…<C394>‚
++o(¨ðö€º0PPáí
ÔáAA…·TxP{„ÞPPáAíTxP{@…µGxPPáAí
ÔP*<¨= ÂƒÚêÂ@…µTxP{@]¨ð ö€‚
++o¨ÔPPáí
ua ÂƒÚ
++*¼= .Tx{@A…·TxPáí
ÔPáA…·TxP{@…ÞPPáAí
TxP{@…µTxPáAí
ÔPáAí
µTxP{@A…·ÔPáAí
ÞP{@A…·Tx{@í
ÞPPáí
µTx{@A…ÞPPáí
ÔáAA…µTxP{„ÔPáAíTxP{@…µÔPáAí
ÔP{@…µTxP{@í
ÔPPáí
ua ÂƒÚ
++*¼= .Tx{@A…·Ô…<C394>‚
++o(¨ðö€º0PPáí
ÔáAA…·TxP{„ÔPáAíTxP{@…µTxPáAí
ÔP*<¨= ÂƒÚêÂ@…µTxP{@]¨ð ö€‚
++o¨ÔPPáí
ua  ÂÛ
++*¼=  Âƒ
++o(¨ðö€‚
++*¼=  ÂƒÚ*<¨ðö€‚
++j¨ð ÂÛ
++*<¨= Âƒ
++j¨ð ö€
++j¨= ÂƒÚ
++*¼= ö€
++j(¨ðö€Ú*<¨=  ÂÛj(¨ðö€‚
++o¨=  ÂÛ
++*<¨ðö€‚
++o(¨ð ö
++*¼=  ÂƒÚ#<(¨ð ö€
++j<>ð  ÂƒÚ*<¨=ƒ‚
++j¨ð ö€Ú*<¨= ÂƒÚj¨ð ö€‚
++o¨ÔPPáí
ua ÂƒÚ
++*¼= .Tx{@A…·Ô…<C394>‚
++o(¨ð ö
++*¼=  ÂƒÚ#<(¨ðö€‚
++j<>ð  ÂƒÚ*<¨= Âƒ
++j¨ð ö€
++*<¨= ÂƒÚêÂ@…µTxP{@]¨ð ö€‚
++o¨ÔPPáí
ua ö€Ú
++*¼=  Âƒ
++o(¨ðö€‚
++*¼=  ÂÛ
++*<¨ðö€‚
++j¨ð ÂÛ
++*<¨= Âƒ
++j¨ð ö€
++j¨= ÂƒÚ*<¨= ö€
++j(¨ðö€Ú*<¨=  ÂÛj(¨ðö€‚
++o¨=  ÂÛ
++*¼= ö€‚
++o(¨ð ö
++*¼=  ÂƒÚ#<(¨ðö€‚
++j<>ð  ÂƒÚ*<¨=ƒ‚
++j¨ð ö€Ú*<¨= ÂƒÚj¨ð öÜOPK

++ûL“L²î
´<>META-INF/MANIFEST.MFUTÉGØZux
³H³HPK
®L“Lõ–^]±¦»

´<>gdir/fileUT7GØZux
³H³HPK¨Z
+\ No newline at end of file
+diff --git a/xmvn.spec b/xmvn.spec
+index 8764b63d..0775d4a2 100644
+--- a/xmvn.spec
++++ b/xmvn.spec
+@@ -196,6 +196,7 @@ artifact repository.
+ 
+ %package        install
+ Summary:        XMvn Install
++Requires:       apache-commons-compress
+ 
+ %description    install
+ This package provides XMvn Install, which is a command-line interface
+@@ -284,7 +285,7 @@ done
+ 
+ # helper scripts
+ %jpackage_script org.fedoraproject.xmvn.tools.bisect.BisectCli "" "-Dxmvn.home=%{_datadir}/%{name}" xmvn/xmvn-bisect:beust-jcommander:maven-invoker:plexus/utils xmvn-bisect
+-%jpackage_script org.fedoraproject.xmvn.tools.install.cli.InstallerCli "" "" xmvn/xmvn-install:xmvn/xmvn-api:xmvn/xmvn-core:beust-jcommander:slf4j/api:slf4j/simple:objectweb-asm/asm xmvn-install
++%jpackage_script org.fedoraproject.xmvn.tools.install.cli.InstallerCli "" "" xmvn/xmvn-install:xmvn/xmvn-api:xmvn/xmvn-core:beust-jcommander:slf4j/api:slf4j/simple:objectweb-asm/asm:objenesis/objenesis:commons-compress xmvn-install
+ %jpackage_script org.fedoraproject.xmvn.tools.resolve.ResolverCli "" "" xmvn/xmvn-resolve:xmvn/xmvn-api:xmvn/xmvn-core:beust-jcommander xmvn-resolve
+ %jpackage_script org.fedoraproject.xmvn.tools.subst.SubstCli "" "" xmvn/xmvn-subst:xmvn/xmvn-api:xmvn/xmvn-core:beust-jcommander xmvn-subst
+ 
+-- 
+2.14.3
+

SPECS/xmvn.spec

@@ -2,54 +2,56 @@
 # any additional bundles.
 %global __requires_exclude %{?__requires_exclude:%__requires_exclude|}^osgi\\($
 
+# Integration tests are disabled by default, but you can run them by
+# adding "--with its" to rpmbuild or mock invocation.
+%bcond_with its
+
+%bcond_without gradle
 
 Name:           xmvn
-Version:        4.0.0~20191028.da67577
+Version:        3.0.0
-Release:        3%{?dist}
+Release:        21%{?dist}
 Summary:        Local Extensions for Apache Maven
 License:        ASL 2.0
 URL:            https://fedora-java.github.io/xmvn/
 BuildArch:      noarch
 
-#Source0:        https://github.com/fedora-java/xmvn/releases/download/%{version}/xmvn-%{version}.tar.xz
+Source0:        https://github.com/fedora-java/xmvn/releases/download/%{version}/xmvn-%{version}.tar.xz
-Source0:        https://github.com/fedora-java/xmvn/archive/da67577.tar.gz
 
-Patch0:         0001-Initial-PoC-of-XMvn-toolchain-manager.patch
+Patch0:         0001-Fix-installer-plugin-loading.patch
+Patch1:         0001-Port-to-Gradle-4.2.patch
+Patch2:         0001-Port-to-Gradle-4.3.1.patch
+Patch3:         0001-Support-setting-Xdoclint-none-in-m-javadoc-p-3.0.0.patch
+Patch4:         0001-Fix-configuration-of-aliased-plugins.patch
+Patch5:         0001-Don-t-use-JAXB-for-converting-bytes-to-hex-string.patch
+Patch6:         0001-Use-apache-commons-compress-for-manifest-injection-a.patch
 
+BuildRequires:  maven >= 3.5.0
 BuildRequires:  maven-local
-BuildRequires:  mvn(com.beust:jcommander)
+BuildRequires:  apache-commons-compress
-BuildRequires:  mvn(org.apache.commons:commons-compress)
+BuildRequires:  beust-jcommander
-BuildRequires:  mvn(org.apache.ivy:ivy)
+BuildRequires:  cglib
-BuildRequires:  mvn(org.apache.maven.plugin-tools:maven-plugin-annotations)
+BuildRequires:  maven-dependency-plugin
-BuildRequires:  mvn(org.apache.maven.plugins:maven-assembly-plugin)
+BuildRequires:  maven-plugin-build-helper
-BuildRequires:  mvn(org.apache.maven.plugins:maven-plugin-plugin)
+BuildRequires:  maven-assembly-plugin
-BuildRequires:  mvn(org.apache.maven.resolver:maven-resolver-api)
+BuildRequires:  maven-install-plugin
-BuildRequires:  mvn(org.apache.maven.resolver:maven-resolver-util)
+BuildRequires:  maven-plugin-plugin
-BuildRequires:  mvn(org.apache.maven.shared:maven-invoker)
+BuildRequires:  objectweb-asm
-BuildRequires:  mvn(org.apache.maven:maven-artifact)
+BuildRequires:  modello
-BuildRequires:  mvn(org.apache.maven:maven-core)
+BuildRequires:  xmlunit
-BuildRequires:  mvn(org.apache.maven:maven-model)
+BuildRequires:  apache-ivy
-BuildRequires:  mvn(org.apache.maven:maven-model-builder)
+BuildRequires:  junit
-BuildRequires:  mvn(org.apache.maven:maven-plugin-api)
+BuildRequires:  easymock
-BuildRequires:  mvn(org.codehaus.modello:modello-maven-plugin)
+BuildRequires:  maven-invoker
-BuildRequires:  mvn(org.codehaus.mojo:build-helper-maven-plugin)
+BuildRequires:  plexus-containers-container-default
-BuildRequires:  mvn(org.codehaus.plexus:plexus-classworlds)
+BuildRequires:  plexus-containers-component-annotations
-BuildRequires:  mvn(org.codehaus.plexus:plexus-component-annotations)
+BuildRequires:  plexus-containers-component-metadata
-BuildRequires:  mvn(org.codehaus.plexus:plexus-component-metadata)
+%if %{with gradle}
-BuildRequires:  mvn(org.codehaus.plexus:plexus-container-default)
+BuildRequires:  gradle >= 4.3.1
-BuildRequires:  mvn(org.codehaus.plexus:plexus-utils)
+%endif
-BuildRequires:  mvn(org.easymock:easymock)
-BuildRequires:  mvn(org.junit.jupiter:junit-jupiter)
-BuildRequires:  mvn(org.ow2.asm:asm)
-BuildRequires:  mvn(org.slf4j:slf4j-api)
-BuildRequires:  mvn(org.slf4j:slf4j-simple)
-BuildRequires:  mvn(org.xmlunit:xmlunit-assertj)
-
-# For /usr/bin/mvn, used to determine location of Maven home
-BuildRequires:  maven
 
 Requires:       %{name}-minimal = %{version}-%{release}
-Requires:       maven >= 3.6.1
+Requires:       maven >= 3.4.0
 
 %description
 This package provides extensions for Apache Maven that can be used to
@@ -67,17 +69,21 @@ Requires:       apache-commons-cli
 Requires:       apache-commons-lang3
 Requires:       atinject
 Requires:       google-guice
-Requires:       guava
+Requires:       guava20
 Requires:       maven-lib
-Requires:       maven-resolver
+Requires:       maven-resolver-api
-Requires:       maven-wagon
+Requires:       maven-resolver-impl
+Requires:       maven-resolver-spi
+Requires:       maven-resolver-util
+Requires:       maven-wagon-provider-api
 Requires:       plexus-cipher
 Requires:       plexus-classworlds
 Requires:       plexus-containers-component-annotations
 Requires:       plexus-interpolation
 Requires:       plexus-sec-dispatcher
 Requires:       plexus-utils
-Requires:       sisu
+Requires:       sisu-inject
+Requires:       sisu-plexus
 Requires:       slf4j
 
 %description    minimal
@@ -92,6 +98,7 @@ This package provides XMvn parent POM.
 
 %package        api
 Summary:        XMvn API
+Obsoletes:      %{name}-launcher < 3.0.0
 
 %description    api
 This package provides XMvn API module which contains public interface
@@ -114,6 +121,15 @@ provides integration of Maven Resolver with XMvn.  It provides an
 adapter which allows XMvn resolver to be used as Maven workspace
 reader.
 
+%if %{with gradle}
+%package        connector-gradle
+Summary:        XMvn Connector for Gradle
+
+%description    connector-gradle
+This package provides XMvn Connector for Gradle, which provides
+integration of Gradle with XMvn.  It provides an adapter which allows
+XMvn resolver to be used as Gradle resolver.
+%endif
 
 %package        connector-ivy
 Summary:        XMvn Connector for Apache Ivy
@@ -191,8 +207,14 @@ Summary:        API documentation for %{name}
 This package provides %{summary}.
 
 %prep
-%setup -q -n xmvn-da67577d9252f0b1fffed546c7c23d97a97dec4b
+%setup -q
 %patch0 -p1
+%patch1 -p1
+%patch2 -p1
+%patch3 -p1
+%patch4 -p1
+%patch5 -p1
+%patch6 -p1
 
 # Bisect IT has no chances of working in local, offline mode, without
 # network access - it needs to access remote repositories.
@@ -206,7 +228,9 @@ find -name ResolverIntegrationTest.java -delete
 
 %mvn_package ":xmvn{,-it}" __noinstall
 
+%if %{without gradle}
 %pom_disable_module xmvn-connector-gradle
+%endif
 
 # Upstream code quality checks, not relevant when building RPMs
 %pom_remove_plugin -r :apache-rat-plugin
@@ -227,30 +251,32 @@ maven_home=$(realpath $(dirname $(realpath $(which mvn)))/..)
 mver=$(sed -n '/<mavenVersion>/{s/.*>\(.*\)<.*/\1/;p}' \
            xmvn-parent/pom.xml)
 mkdir -p target/dependency/
-cp -a ${maven_home} target/dependency/apache-maven-$mver
+cp -aL ${maven_home} target/dependency/apache-maven-$mver
 
 %build
+%if %{with its}
+%mvn_build -s -j -- -Prun-its
+%else
 %mvn_build -s -j
+%endif
 
-version=4.0.0-SNAPSHOT
 tar --delay-directory-restore -xvf target/*tar.bz2
-chmod -R +rwX %{name}-${version}*
+chmod -R +rwX %{name}-%{version}*
 # These are installed as doc
-rm -f %{name}-${version}*/{AUTHORS-XMVN,README-XMVN.md,LICENSE,NOTICE,NOTICE-XMVN}
+rm -f %{name}-%{version}*/{AUTHORS-XMVN,README-XMVN.md,LICENSE,NOTICE,NOTICE-XMVN}
 # Not needed - we use JPackage launcher scripts
-rm -Rf %{name}-${version}*/lib/{installer,resolver,subst,bisect}/
+rm -Rf %{name}-%{version}*/lib/{installer,resolver,subst,bisect}/
 # Irrelevant Maven launcher scripts
-rm -f %{name}-${version}*/bin/*
+rm -f %{name}-%{version}*/bin/*
 
 
 %install
 %mvn_install
 
-version=4.0.0-SNAPSHOT
 maven_home=$(realpath $(dirname $(realpath $(which mvn)))/..)
 
 install -d -m 755 %{buildroot}%{_datadir}/%{name}
-cp -r %{name}-${version}*/* %{buildroot}%{_datadir}/%{name}/
+cp -r %{name}-%{version}*/* %{buildroot}%{_datadir}/%{name}/
 
 for cmd in mvn mvnDebug; do
     cat <<EOF >%{buildroot}%{_datadir}/%{name}/bin/$cmd
@@ -271,9 +297,7 @@ done
 cp -r ${maven_home}/lib/* %{buildroot}%{_datadir}/%{name}/lib/
 
 # possibly recreate symlinks that can be automated with xmvn-subst
-%if !0%{?sclraw_phase}
 %{name}-subst -s -R %{buildroot} %{buildroot}%{_datadir}/%{name}/
-%endif
 
 # /usr/bin/xmvn
 ln -s %{_datadir}/%{name}/bin/mvn %{buildroot}%{_bindir}/%{name}
@@ -314,6 +338,9 @@ cp -P ${maven_home}/bin/m2.conf %{buildroot}%{_datadir}/%{name}/bin/
 
 %files connector-aether -f .mfiles-xmvn-connector-aether
 
+%if %{with gradle}
+%files connector-gradle -f .mfiles-xmvn-connector-gradle
+%endif
 
 %files connector-ivy -f .mfiles-xmvn-connector-ivy
 
@@ -337,33 +364,6 @@ cp -P ${maven_home}/bin/m2.conf %{buildroot}%{_datadir}/%{name}/bin/
 %doc LICENSE NOTICE
 
 %changelog
-* Thu Jan 23 2020 Mikolaj Izdebski <mizdebsk@redhat.com> - 4.0.0~20191028.da67577-3
-- Implement toolchain manager
-
-* Tue Nov 05 2019 Mikolaj Izdebski <mizdebsk@redhat.com> - 4.0.0~20191028.da67577-2
-- Mass rebuild for javapackages-tools 201902
-
-* Mon Oct 28 2019 Mikolaj Izdebski <mizdebsk@redhat.com> - 4.0.0~20191028.da67577-1
-- Update to upstream snapshot of 4.0.0
-
-* Fri Jun 28 2019 Mikolaj Izdebski <mizdebsk@redhat.com> - 3.1.0-2
-- Prefer namespaced metadata when duplicates are found
-
-* Fri Jun 14 2019 Mikolaj Izdebski <mizdebsk@redhat.com> - 3.1.0-1
-- Update to upstream version 3.1.0
-
-* Thu May 30 2019 Marian Koncek <mkoncek@redhat.com> - 3.0.0-25
-- Update maven-invoker to version 3.0.1
-
-* Fri May 24 2019 Mikolaj Izdebski <mizdebsk@redhat.com> - 3.0.0-24
-- Mass rebuild for javapackages-tools 201901
-
-* Fri Apr 19 2019 Marian Koncek <mkoncek@redhat.com> - 3.0.0-23
-- Port to Xmlunit 2.6.2
-
-* Sat Apr 13 2019 Mikolaj Izdebski <mizdebsk@redhat.com> - 3.0.0-22
-- Switch to Maven 3.6.1 and non-compat Guava
-
 * Wed Aug 01 2018 Severin Gehwolf <sgehwolf@redhat.com> - 3.0.0-21
 - Add requirement on javapackages-tools since scripts use
   java-functions.