<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> 
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
<title>RT Packaging</title>

<style type="text/css">
dt {
display: list-item;
list-style-position:outside;
list-style-image:url(/eclipse.org-common/themes/Phoenix/images/arrow.gif);
margin-left:16px;
}
dd {
margin-left:25px;
margin-bottom:5px;
}
</style>

</head>

<body>
<p>
The RT Packaging project (RTP) project is a proposed open source project under the 
<a href="http://eclipse.org/projects/project_summary.php?projectid=technology.packaging">Eclipse Packaging Project</a>.
</p>
<p>
This proposal is in the Project Proposal Phase (as defined in the
Eclipse Development Process) and is written to declare its intent and
scope. We solicit additional participation and input from the Eclipse
community. Please send all feedback to the 
<a href="http://www.eclipse.org/forums/eclipse.proposals">Eclipse Proposals</a> Forum.
</p>

<h2>Background</h2>
<p>
Over the last three years, the Eclipse ecosystem has created a rich software stack that demonstrated tremendous 
growth in the area of runtimes based on Eclipse <a href="http://eclipse.org/equinox/">Equinox</a>. In 2008 a top 
level project was created (RT) to bring all Eclipse-based runtime technologies together under one umbrella. 
Currently the growing RT project hosts 10 different projects with several sub projects. 
</p>
<p>
When a developer creates an application based on EclipseRT technologies the common approach is to pack different 
technologies together to build a platform for the application. The developer usually has two options to build this 
runtime platform:
</p>
<ol>
	<li>Select the relevant EclipseRT projects, download the project's artifacts and put it all together manually.</li>
	<li>Select the relevant EclipseRT projects, and if it exists, copy their p2 repository URLs and let p2 put the parts together.</li>
</ol>
<p>
This approach has some drawbacks:
</p>
<ul>
	<li>Not all EclipseRT projects are able to work together seamlessly. For example, until late 2010, it was not
		possible to combine Riena and RAP.</li>
	<li>If a runtime platform was created manually, it cannot receive updates. As a result, the developer has to download 
		new versions and add them to his platform.</li>
	<li>Every developer who wants to build a runtime platform has to start from scratch. He doesn't profit from work by 
		other developers.</li>
</ul>
<p>
The goal of the RT Packaging project is to provide a solution for the structured set up of a runtime platform with user 
friendly configuration tools that support users in assembling and further evolving valid configurations.
</p>

<h2>Description</h2>
<p>
Problems similar to those with building the runtime, existed in the Eclipse ecosystem three years ago before the 
<a href="http://eclipse.org/epp">Eclipse Packaging project (EPP)</a> was created. With a growing number of people 
using Eclipse and with a single Platform SDK download, it was very painful to find and select the necessary 
plug-ins to work in areas other than Java and Plug-in development. The EPP project solved this problem by providing 
several configurations to the end user. At writing, the EPP project provides 11 entry level downloads suitable 
for different user profiles.
</p>
<p>
Using existing EclipseRT technologies, the RT Packaging project will create one or more EPP-like packages for setting 
up a runtime platform for different platforms and architectures. These packages will be based on a common structure. 
They will also be available in the form of p2 repositories for remote consumption. In 
addition, a user friendly configuration tool will be built to create and extend the 
packages.
</p>

<h2>Scope</h2>
<p>
The objectives of the RT Packaging project are to:
</p>
<ul>
	<li>Create one or more extendable packages based on EclipseRT technology. The project will define a minimal 
		configuration based on <a href="http://eclipse.org/equinox/">Equinox</a> and 
		<a href="http://eclipse.org/equinox/p2/">p2</a>. Creating more advanced packages enriched with other EclipseRT technologies 
		will also be considered. In creating the packages the existing Eclipse build and EPP infrastructure will be reused 
		wherever possible. The starting point for the packages will be the 
		<a href="http://download.eclipse.org/jetty/7.1.4.v20100610/dist-eclipse/">EclipseRT starter kits</a>.</li>
	<li>Provide packages for different platforms and architectures. The RT Packaging project will create packages for 
		common server/client platforms and architectures. The possible initial set of platforms are Debian and Ubuntu (.deb), 
		Fedora and SuSe (.rpm), Windows (.zip) and Mac OS X (.pkg). There will also be platform independent packages (.zip). 
		Additionally, a set of cloud images (S3 and Azure) will be created with pre-configured RT Package instances.</li>
	<li>Provide a configuration tool.  Users should have the option to configure a package themselves, similar to how the 
		EPP Download Wizard enables customized downloads. To this end, a configurator will be created that allows users to 
		assemble different EclipseRT technologies and create a single download in the formats described above. This configurator 
		probably will be part of the RT Packaging website and can be optionally included in a RT package to reconfigure and update the 
		package after downloading.</li>
  <li>Provide a headless variant of the configuration tool, which allows an automated system to install and subsequently 
    extend/reduce the system by adding/removing particular technology. It'll support both scenarios ‚Äì to install 
    a product from outside or to grow itself into a product.</li>
  <li>Provide guidance on how EclipseRT projects can structure their p2 repositories and subsequently test/validate their 
    packages in order to benefit from the defined distribution flow. A critical part of that is how to define the wiring 
    and versioning specifics between the different modules in order to make it possible for them to work together when 
    assembled in the same runtime environment. These kind of guidance will be created as Wiki pages and examples.</li>
</ul>

<h2>Out of Scope</h2>
<ul>
	<li>The RT Packaging project will not create a new Server. It will use the two existing Servers (
		<a href="http://eclipse.org/jetty/">Jetty</a> and <a href="http://eclipse.org/virgo/">Virgo</a>) and 
		help to improve these through contributions.</li>
	<li>The RT Packaging will not create another provisioning platform for updating a platform. It will use the existing 
		p2 platform to achieve its goal and help to improve p2.</li>
	<li>The RT Packaging project will not compete with any existing EclipseRT projects. It is rather envisioned as an ordered 
		and easy to use collection of existing EclipseRT technologies.</li>
</ul>
 
<h2>Initial Contribution</h2>
<p>
There will be two initial contributions made by the <a href="http://eclipse.org/equinox/">Equinox</a> and 
<a href="http://eclipse.org/jetty/">Jetty</a> teams. Both teams have created an  EclipseRT starter kit which can be 
found <a href="http://download.eclipse.org/jetty/7.1.4.v20100610/dist-eclipse/">here</a>. These starter kits will 
be copied to RTP and act as templates to create the first two packages of the RT Packaging project.<br/> 
EclipseSource's initial contribution will include the automated build setup and the first two packages based on the contributions 
from the Equinox and Jetty Team. EclipseSource's contribution can be found 
<a href="https://github.com/hstaudacher/org.eclipse.rtp">here</a> and will move to the RTP project.<br/>
SAP's initial contribution will include the 'p2 installer'. This installer can be used as the basis 
for the configuration tool. It allows developers to start from a 'bare bone' equinox installation and assemble 
a system from existing p2 repositories. The 'p2 installer' was an internal effort made by SAP and will move to the RTP project.
</p>
 
<h2>Committers</h2>
<p>The following individuals are proposed as initial committers to the project:</p>
<dl>
	<dt>Holger Staudacher, EclipseSource</dt>
	<dd>Project Lead.</dd>
	<dt>Florian Waibel, EclipseSource</dt>
	<dd>Florian will act as a link to the Virgo project.</dd>
	<dt>Markus Knauer, EclipseSource</dt>
	<dd>Markus will support this project with his knowledge about the EPP project.</dd>
	<dt>Ian Bull, EclipseSource</dt>
	<dd>Ian will support the RT Packaging project with his knowledge about p2.</dd>
  <dt>Hugues Malphettes, Intalio</dt>
  <dd>Hugues will contribute the EclipseRT Starter Kit as an initial contribution. He agreed to maintain it within the RTP project.</dd>
  <dt>Beyhan Veliev, EclipseSource</dt>
  <dd>Beyhan will support the RTP project with his knowledge about equinox and p2.</dd>	
  <dt>Georgi Stanev, SAP</dt>
  <dd>Georgi is the driving force behind SAP's 'p2 installer'. He will maintain it within the RTP project.</dd>
</dl>
<p>We welcome additional committers and contributions.</p>

<h2>Mentors</h2>
<p>The following Architecture Council members will mentor this project:</p>
<ul>
	<li><a href="http://eclipsesource.com/blogs/author/mknauer/">Markus Knauer</a>, EclipseSource</li>
	<li><a href="http://aniszczyk.org/">Chris Aniszczyk</a>, Red Hat</li>
</ul>

<h2>Interested Parties</h2>
<p>The following individuals, organisations, companies and projects have 
expressed interest in this project:</p>
<ul>
	<li>Harald Kornmayer, g-Eclipse Project</li>
	<li>Jeff McAffer, EclipseSource</li>
	<li>Benjamin Muskalla, Tasktop Technologies</li>
	<li>Glyn Normington, VMWare</li>
	<li>Chris Aniszczyk, Red Hat</li>
	<li>Igor Novakovic, Attensity Europe GmbH</li>
	<li>Gunnar Wagenknecht, Gyrex Project</li>
	<li>Kaloyan Raev, SAP</li>
	<li>Karsten Schmidt, SAP</li>
	<li>Krasimir Semerdzhiev, SAP</li>
</ul>

<h2>Project Scheduling</h2>
<p>
The initial milestone deliverables will be a minimal configuration of an EclipseRT package and provisioning the 
project on the eclipse.org infrastructure. The initial milestone will be created within 1Q2011. The goal of the 
RT Packaging project is to become a formal part of the release train in 2011 (Indigo).
</p>

<h2>Changes to this Document</h2>
<table>
	<tr>
		<th>Date</th>
		<th>Change</th>
	</tr>
	<tr>
		<td>26-November-2010</td>
		<td>Document created</td>
	</tr>
  <tr>
    <td>03-December-2010</td>
    <td>Added a more precise description of how the initial contributions will be handled. Added Hugues Marlphettes as an initial committer.</td>
  </tr>	
  <tr>
    <td>20-December-2010</td>
    <td>Added Beyhan Veliev as an initial committer. Added Kaloyan Raev, Karsten Schmidt and Krasimir Semerdzhiev to the interested parties. Added SAP's
    initial contribution. Extended the scope of the project to cover automated systems.</td>
  </tr> 
  <tr>
    <td>03-January-2011</td>
    <td>Added description of EclipseSource's initial contribution.</td>
  </tr>   
</table>
</body>
</html>