Linux Tools Project/Eclipse Build/Inner Workings

Given an archive with Eclipse SDK sources Eclipse Build will extract the sources and remove all the pre-built OSGI jars, but collects all the OSGI metadata (contained in MANIFEST.MF files). Then Eclipse Build tries use jars provided by the system, verifying that versions match the OSGI information provided in the eclipse sources archive.

Fetching Sources

When an SDK source tarball is not available, sources can be fetched using buildSDKSource.sh. This can be the case for example if a release has not yet been made of the version you wish to build.

To fetch the sources you need the build ID. The build ID is the git (or CVS) tag which is used to create particular version. For more details about the upstream Eclipse build cycle click here. Here you can find recent builds, the build ID's (tags) which were used to create them and and you can inspect the build results.

Example:

./buildSDKSource.sh I20110719-0800

Dependencies

Packages which Eclipse depends on are normally provided in an Eclipse download as jars. Eclipse Build replaces those with jars provided by the distribution. In eclipsebuild/*.properties files you will find a list of Eclipse dependencies and a search path indicating where they are found on a Linux distribution. If Eclipse Build does not know about a needed dependency this is where you would add it. If Eclipse Build knows about a dependency but cannot find it, you would edit the search path for that dependency in one of these .properties files.

Each entry in a .properties file must have a corresponding MANIFEST.MF file in eclipse-build/dependencyManifests/. These manifest files should be obtained from a jar from the corresponding eclipse build or from an Orbit download. The directory structure should be in this format:

eclipse-build/dependencyManifests/<name and version of the jar>/META-INF/MANIFEST.MF

At a later stage Eclipse Build will use these files to ensure that the system files which you have pointed it to match the Eclipse requirement.

Building Eclipse

This process is started when you run ant in the eclipse-build directory. This runs build.xml which does the following.

• Source tarball is extracted.
• Eclipse Build patches are applied.
• Symlinks to system jars are created to satisfy Eclipse dependencies.
• Start the bootstrapping process by calling the bootstart target in pdebuild.xml

Searching And Symlinking System Jars

The following Java files are used to define ant tasks which perform the version verification and symlinking of the system jars

task-src/org/eclipse/linuxtools/eclipsebuild/SymlinkInstalledOSGiJars.java
task-src/org/eclipse/linuxtools/eclipsebuild/SymlinkOSGiJars.java
task-src/org/eclipse/linuxtools/eclipsebuild/SymlinkNonOSGiJars.java

The search path used by the ant tasks above is specified in *.properties files. For example:

org.objectweb.asm_3.3.1.v201101071600.jar=/usr/share/java/objectweb-asm/asm-all.jar:/usr/share/java/asm3-all.jar

means that the MANIFEST.MF files of /usr/share/java/objectweb-asm/asm-all.jar and /usr/share/java/asm3-all.jar will be examined to see if they satisfied the requirement of org.objectweb.asm_3.3.1.v201101071600.jar. If a match if found a symlink to that jar is created in the plugins directory.

Bootstrapping Eclipse

Bootstrapping is done in 3 steps:

• use pregenerated build scripts to build org.eclipse.pde.build and all of its dependencies. At this step we have enough bootstrapped to generate build.xml files.
• use the result from step one to generate build.xml files for build utilities like pde.apitools and others. Now we have something very close to what Releng are calling a basebuilder.
• use the result from step two to cleanup, regeneate all the build.xml files and build the whole SDK. This steps is trying to mimic the regular releng procedure where possible.

pdebuild.xml will first unzip pregenerated build scripts found in eclipse-build-generatedScripts.tar.bz2. It will then use those scripts to build Eclipse upto and including pde-build. This pde-build is then used to generate build.xml files and rebuild it self again to ensure that a full build is done (pregenerated ant scripts may not run all the pre/post ant targets if any). The result is then used to finish the build.