monkey-works / buildmonkey Goto Github PK

The gradle -artifactory-deployer uses the jFrob binaries for a command line call deploying the configured folders. There is a Java API, which should be used, This will reduce the shipping size of the plugin,

First step is a materialisation per ant scripts. They can be filled static matching the sample from #4 . It should be called from gradle in an easy way with less configuration.

For changes in Gradle API the plugin was developed for Gradle version 3.4. With a higher version the following error occurs:

> Failed to apply plugin [id 'de.monkeyworks.buildmonkey.pde.PluginTestPlugin']
   > Could not generate a proxy class for class de.monkeyworks.buildmonkey.pde.testing.PluginTestExtension.

This should be fixed for usage with Gradle 3.5 or higher

In the P2 plugin we can mirror P2 repositories and create a target platform file. But this file should be published over the plugin too. Possible targets are Artifactory, Git or a PUT target.

p2publish can be extended processing the last prerequisite step 'Providing 3rd party dependencies'. This are dependencies taken from Maven repositories (instead of P2 repositories how it mirrorP2repository does). They will be provided as Maven repository (for gradle) and P2 repository (for Eclipse). The artefacts must be renamed be adding a prefix avoiding resolution against mcentral or jcenter. The dependencies in the manifests must contain this prefix too.

Hi,

i'm trying to get the Example RCP App running, but when i try to launch it from inside eclipse it fails because it cannot resolve org.eclipse.equinox.ds

I builded the root project with resolveManifestDependencies build publish and then activated the builded target platform.

After that I tried to launch the application from inside eclipse via the MonkeyExcampleE4Application.product file.

This is the log:
1519401509430.log

Currently our dependency resolution plugin identifies project dependencies by an optional naming pattern only. This can be improved by traversing the gradle project tree and checking dependencies against all to be build projects.

After creating a third party repository, the target platform file (published with publishTargetPlatform) needs to check, if it still contains this feature on this server. If not, it needs to be appended.

As enhancement to #3 we need a tutorial about the build pipeline for an Eclipse RCP applucation. It contains more plugins, features and needs the materialisation at the end. Therefor the materialisation must be implemented first.

A simply to apply task (modifyBundle) with the follwong (script) code has to been provided:

    // Make the crated jar file matching OSGi bundle and Eclipse plugin nature
    jar {
        if (project.file("${resourcesPath}").exists()) {
                with copySpec {
                    from "${projectDir}/${resourcesPath}"
                    into "${resourcesPath}"
                }  
        }
        if (project.file('OSGI-INF').exists()) {
            with copySpec {
                from "${projectDir}/OSGI-INF"
                into 'OSGI-INF'
            }       
        }
    
        manifest {
            // benutze das im Projekt vorliegende File, falls vorhanden:
            def manif = "${projectDir}/META-INF/MANIFEST.MF"
            if (new File(manif).exists()) {
                from (manif) { 
                    eachEntry { details ->
                        if (details.key == 'Bundle-Version') {
                            details.value = "1.0.0"
                        }
                    }
                }
            }
        }
        from file ('plugin.xml')
    }

The resourcePath and some other value have configurable

p2publish does not use the established eclipse handling, like SDK detection, download and launcher detection. This should be changed.

We need a small Eclipse RCP application for developing and testing the materialisation and as real world example for the tutorial and documentation. The application should produced by Eclipse at first.

We have many prerequisites for the materialisation used for the plugins before, but for the easy materialsation we duplicate them. This are the target platform, the Eclipse SDK and the artefact publication of the build artefacts. This enhancement get acces to this configurations and create the build.properties file needed for the materialisation (and other files if necessary) and calls the pde build with the existing Eclipse SDK.

We always have a small example called MonkeyPlugin in examples/example1. It just produces one OSGi bundle. There should be a step by step description of the steps to fill out the build.gradle files with the right plugins, extensions and instructions building this plugin.

There is in the custom handling method of the ManifestDependencyPlugin a remaining part of the ancient implementation. It uses the branch names given by the build scripts. This should be moved to the content of the projectGroup property in the projectPatter closure.