Building Rodin Headless

From Event-B
Revision as of 09:43, 3 January 2014 by imported>Tommy (→‎Pre Build Verifications)
Jump to navigationJump to search

This page documents the procedure followed for building the binary packages of the Rodin platform that are distributed on SourceForge. The build is done in two steps

  1. Fetch the sources from the repository and make a source archive with them.
  2. Build the platform headless from this set of sources using Apache Ant.

Pre Build Verifications

Before building, several checks have to be made in the sources:

  • clean build all RodinCore plug-ins, so that generated files are regenerated using repository sources
  • JUnit tests are OK
  • versions of plug-ins, features and product obey Eclipse versioning policy
  • API Tooling build against previous Rodin release produces no errors on any plug-in
  • the correct Eclipse version is referenced in the p2 configuration (org.rodinp.platform/p2.inf) and matches the one defined whithin the parent pom file (org.eventb.parent/pom.xml) :
	<repository>
		<id>indigo</id>
		<layout>p2</layout>
		<url>http://download.eclipse.org/releases/indigo</url>
	</repository>
  • the correct link for the Rodin Handbook is provided in the parent pom file (org.eventb.parent/pom.xml) :
<repository>
	<id>handbook</id>
	<layout>p2</layout>
	<url>http://handbook.event-b.org/updatesite</url>
</repository>
  • branding plug-ins display the correct Eclipse version (text information found in several about.properties/plugin.properties files)
  • documentation is up to date for /org.rodinp.platform/html/root.html
  • generated documentation matches latest wiki sources for
    • /org.eventb.keyboard/doc

When everything works, any changes to the sources made during this verification process are pushed to the Source Forge repository.

Build Parameters

Several parameters need to be defined for each build:

  1. the platform version, that is the user-visible version which is displayed in About Rodin Platform. Example of versions are 1.0 and 2.3RC1.
  2. the Git commit number, which permits to know very precisely which source versions are used for the build.
  3. the Git branch from which the commit can be checked out
  4. the full platform version used for provisioning. This version is made of the platform version and the commit number, separated by a dot. Example of full versions are 2.8RC1.r365721c and 2.8.1.r6f52165.

Fetching Sources

Sources are fetched from Subversion using the script below. The script can be run on any Unix machine and takes the first two parameters described above (i.e., platform version and subversion revision). For instance, to build Rodin 1.1, the script was invoked as 

fetchSources 1.1 7661

The script itself is 

#!/bin/sh 
# 
#  Fetch sources of the Rodin Platform from the Subversion repository on 
#  SourceForge. 
# 
 
. ./version.sh 
 
GITROOT=ssh://pcb//git/c572/RodinCore.git 
 
fatal() { 
    echo "$@" >&2 
    exit 1 
} 
 
checkCommit() { 
    if expr "$GIT_COMMIT" : '^[0-9a-f][0-9a-f]*$' >/dev/null; then 
        : OK 
    else 
        fatal "Invalid GIT commit: $GIT_COMMIT" 
    fi 
} 
 
fetchSources() { 
    mkdir gitrepo || fatal "Some sources have already been checked out." 
    git clone --branch $GIT_BRANCH $GITROOT gitrepo 
    cd gitrepo 
    git checkout $GIT_COMMIT 
 
    mkdir ../sources 
    cp -R org.rodinp.releng ../sources 
 
    cat org.rodinp.releng/rodin-core.psf |  
    grep "^<project" | 
    sed -e 's/.*\,master\,//' -e 's/\".*//' | 
    xargs -i cp -R {} ../sources 
 
    cd .. 
} 
 
checkCommit 
fetchSources 
 
cd sources 
zip -q -r "../rodin-${VERSION}-sources.zip" *

Installing Eclipse for Headless Build

To install Eclipse for headless build, you first need to download two bundles from the Eclipse download site:

  • eclipse-SDK-${VERSION}-${PLATFORM}.tar.gz
  • eclipse-${VERSION}-delta-pack.zip

where VERSION is the version of Eclipse (e.g., 3.4.2) and PLATFORM specifies the host platform for the build (e.g., linux-gtk).

Once downloaded, you need to extract the first archive, and then the second archive on top of the first. You now have an Eclipse installation able to build binary distribution for all platforms supported by Eclipse.

Building the Platform

To build the platform, you just need to run the script below after possibly modifying some of the variables at the beginning of it. The meaning of the variables is

BUILD_ID Simple platform version (first parameter above)
SVNREV Subversion revision number with an r prepended
VERSION Full platform version used for provisioning (must contain $SVNREV as qualifier)
JAVA_HOME Absolute path to a Java Runtime Environment
BUILD_BASE Absolute path to the directory used for building. As a result of a previous step, this directory must contain a sources folder where the Rodin sources have been downloaded.
ECLIPSE_HOME Absolute path to the Eclipse installation (including the delta pack) to use for building
PDE_BUILD Absolute path to the PDE plug-in in your Eclipse installation.
BASE_OS Operating system of the host platform
BASE_WS Windowing system of the host platform
BASE_ARCH Architecture of the host platform

The build script is 

#!/bin/sh

BUILD_ID=2.8 
GIT_COMMIT=05788b6 
GIT_BRANCH=2.8-master 
VERSION=$BUILD_ID.r$GIT_COMMIT 

JAVA_HOME=/usr/lib/jvm/java-6-sun/jre

BUILD_BASE=$HOME/Rodin/$BUILD_ID
BUILD_DIR=$BUILD_BASE/work
RELENG=$BUILD_BASE/sources/org.rodinp.releng

ECLIPSE_HOME=$HOME/eclipse-3.7.2
PDE_BUILD=$ECLIPSE_HOME/plugins/org.eclipse.pde.build_3.7.0.v20111116-2009
ANT_SCRIPT=$PDE_BUILD/scripts/productBuild/productBuild.xml
REPO=$BUILD_BASE/REPO 

BASE_OS=linux
BASE_WS=gtk
BASE_ARCH=x86

$JAVA_HOME/bin/java \
    -jar $ECLIPSE_HOME/plugins/org.eclipse.equinox.launcher_*.jar \
    -application org.eclipse.ant.core.antRunner \
    -buildfile $ANT_SCRIPT \
    -Dbuilder=$RELENG \
    -DbuildDirectory=$BUILD_DIR \
    -DpluginPath=$BUILD_DIR/plugins/org.rodinp.platform \
    -Dbase=$ECLIPSE_HOME \
    -DbaseLocation=$ECLIPSE_HOME \
    -Dbaseos=$BASE_OS \
    -Dbasews=$BASE_WS \
    -Dbasearch=$BASE_ARCH \
    -DbuildId="$BUILD_ID" \
    -DbuildVersion="$VERSION" \
    -DforceContextQualifier="r$GIT_COMMIT" \
    -Dconfigs="linux,gtk,x86 & linux,gtk,x86_64 & win32,win32,x86 & win32,win32,x86_64 & macosx,cocoa,x86_64" \ 
    -Dp2.gathering=true \ 
    -Dp2.metadata.repo=$REPO \ 
    -Dp2.artifact.repo=$REPO \ 
    -Dp2.compress=true

Post Build Verifications

When the build worked, the "work/result" directory contains zipped archives for all platforms. For each of them, check that:

  • "rodin" binary is an executable file (for Linux and Mac)
  • a directory "dropins" exists at the root (under "rodin", among "features", plugins", ...)
  • in "configuration/org.eclipse.equinox.simpleconfigurator/bundles.info", plug-in "org.eclipse.equinox.p2.reconciler.dropins" is configured with auto start mode ("true" at the end of the line)

Failures must be manually corrected. Final archives shall match the above requirements.

Providing Sources

Sources must also be provided, in both these ways:

Last operations to perform

Retrieved from ‘https://wiki.event-b.org/index.php?title=Building_Rodin_Headless&oldid=1005’