com.diffplug.gradle.p2

Class AsMavenPlugin

java.lang.Object

com.diffplug.gradle.ProjectPlugin

com.diffplug.gradle.p2.AsMavenPlugin

All Implemented Interfaces:

Plugin<Project>

public class AsMavenPlugin
extends ProjectPlugin

Downloads a set of artifacts from a p2 repository and stuffs them into a local maven repository in the build/p2asmaven folder, then adds this repository to the project.

apply plugin: 'com.diffplug.p2.asmaven'
p2AsMaven {
    // the maven group they shall have
    group 'eclipse-deps', {
        // the repositories and artifacts to download
        repoEclipse '4.5.2'
        iu          'org.eclipse.jdt.core'
    }
}

dependencies {
    compile 'eclipse-deps:org.eclipse.jdt.core:+'
}

You can also specify multiple groups, as such

def SUPPORTED_VERSIONS = ['4.4', '4.5', '4.6']
p2AsMaven {
    for (version in SUPPORTED_VERSIONS) {
        group 'eclipse-deps-' + version, {
            repoEclipse version
            iu 'org.eclipse.swt'
            // this will cause any OSGi jars which ask to be expanded into
            // folders to be exploded, e.g. Eclipse-BundleShape: dir 
            repo2runnable()
        }
    }
}

// build folder will look like this:
build/p2AsMaven/
    maven/
        eclipse-deps-4.4/
        eclipse-deps-4.5/
        eclipse-deps-4.6/
    p2/
        eclipse-deps-4.4/
        eclipse-deps-4.5/
        eclipse-deps-4.6/
    p2runnable/
        eclipse-deps-4.4/
        eclipse-deps-4.5/
        eclipse-deps-4.6/

The maven repository does not contain any dependency information, just the raw jars. In the example above, when p2 downloads org.eclipse.jdt.core, it also downloads all of its dependencies. But none of these dependencies are added automatically - you have to add them yourself.

Multiprojects

If you have a dedicated p2 project, and other projects refer to it, it needs to look like this in gradle 6+:

maven {
  url project(':project-with-p2asmaven').file('build/p2asmaven/maven')
  metadataSources {
    mavenPom()
    artifact()
  }
}
evaluationDependsOn(':project-with-p2asmaven')

Example projects

• spotless
• gradle-and-eclipse-rcp
• (send us yours in a PR!)

Proxy support

If you need to pass through a proxy, you’ll need to create a file called proxies.ini with content like this:

org.eclipse.core.net/proxyData/HTTP/host=someproxy.ericsson.se
org.eclipse.core.net/proxyData/HTTPS/host=someproxy.ericsson.se
org.eclipse.core.net/proxyData/HTTPS/hasAuth=false
org.eclipse.core.net/proxyData/HTTP/port=8080
org.eclipse.core.net/proxyData/HTTPS/port=8080
org.eclipse.core.net/org.eclipse.core.net.hasMigrated=true
org.eclipse.core.net/nonProxiedHosts=*.ericsson.com|127.0.0.1
org.eclipse.core.net/systemProxiesEnabled=false
org.eclipse.core.net/proxyData/HTTP/hasAuth=false 

Once you’ve done this, add this to your build.gradle:

p2AsMaven {
    group 'myGroup', {
        ...
        p2ant {
            it.addArg('plugincustomization', '<path to proxies.ini>')
        }
    }
}

If you think this is too hard, vote for this issue on GitHub and this bug on eclipse and we can make it easier.

Slicing options

You can control how the iu’s are resolved using

p2AsMaven {
  group 'eclipse-deps', {
    ...
    slicingOption 'latestVersionOnly', 'true'
  }
}

You can see all the available slicing options here.

Append option

You can control whether iu’s should be appended to destination repository true: already downloaded iu’s are preserved, new iu’s are downloaded into the existing repo false: Default value for goomph, repository will be completely cleared before download new iu’s

p2AsMaven {
  group 'eclipse-deps', {
    ...
    append true
  }
}

More info here.

Acknowledgements and comparisons to other options

Inspired by Andrey Hihlovskiy’s unpuzzle. Unpuzzle downloads a zipped-up copy of the eclipse IDE and stuffs its jars into a maven repository. Additionally, it parses out the Require-Bundle directives to put partial dependency information in the maven metadata.

Simon Templer has a fork which supports parsing the Import-Package and Export-Package directive to build even more detailed dependency information.

A third option is Dr. David Akehurst’s p2 dependency resolver, which is a partial re-implementation of P2, and uses internal gradle APIs to hook into Gradle’s dependency resolution. It’s very impressive, but it has a few limitations:

• It does not support composite repositories
• It does not work on Gradle > 2.8

All of the above are great work, and served as useful examples. The central problem which is the cause of so many not-quite-satisfying implementations is this:

• Using the real p2 is cumbersome, but possible.
• Re-implementing the first 70% of p2 is easy, but the last 30% is hard and moving (they’re still adding features).
• Gradle doesn’t yet have an extensible API for repositories.

In Goomph, we will always use the real p2. While we work around limitations in gradle and p2, we will only use public APIs in both products.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	AsMavenPlugin.Legacy

Constructor Summary

Constructors

Constructor and Description
AsMavenPlugin()

Method Summary

Modifier and Type	Method and Description
protected void	applyOnce(Project project) Plugin application, which is guaranteed to execute only once.
AsMavenExtension	extension()

Methods inherited from class com.diffplug.gradle.ProjectPlugin

apply, getPlugin, treeDef

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

AsMavenPlugin

public AsMavenPlugin()

Method Detail

applyOnce

protected void applyOnce(Project project)

Description copied from class: ProjectPlugin

Plugin application, which is guaranteed to execute only once.

Specified by:

applyOnce in class ProjectPlugin

extension

public AsMavenExtension extension()