<!-- 
	This document is provided as a template along with some guidance for creating
	your project proposal. This is just a template. Feel free to change it as
	you see fit (add sections, remove section). We feel, however, that the
	suggestions represented in this document represent the reasonable minimum
	amount of information to move forward.
	
	Please keep the formatting in this document simple. Please do not edit 
	this document in Microsoft Word as it adds huge piles of markup that make
	it difficult to restyle.
	
	More information is available here:
	
	http://wiki.eclipse.org/Development_Resources/HOWTO/Pre-Proposal_Phase
	
	Direct any questions about this template to emo@eclipse.org
 -->

<html>
<head>

<!-- 
	Include the title here. We will parse it out of here and include it on the
	rendered webpage. Do not duplicate the title within the text of your page.
 -->

<title>Libra</title>

</head>

<!-- 
	We make use of the 'classic' HTML Definition List (dl) tag to specify
	committers. I know... you haven't seen this tag in a long while...
 -->

<style>
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>

<body>
<p>Libra is a proposed open source project under the <a
	href="http://www.eclipse.org/projects/project_summary.php?projectid=webtools">Web
Tools Platform Container Project</a>.</p>

<!-- 
	The communication channel must be specified. Typically, this is a forum
	that is available from http://www.eclipse.org/forums with a URL using the
	project's short name; it will be something along the lines of
	of http://www.eclipse.org/forums/eclipse.woolsey. EMO can (and will)
	provide assistance if you're not sure what to put here.
 -->
<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="/forums/eclipse.osgi-enterprise-tools">OSGi Enterprise Tools</a>

Forum.</p>

<h2>Background</h2>

<!-- 
	Optionally provide the background that has lead you to creating this project.
 -->

<p>In the recent years almost all of the major application server
vendors declared plans to migrate their application servers to the OSGi
component model. Having the OSGi model in the middleware, a natural step
for evolving further the enterprise model is to adapt the OSGi model for
enterprise applications. This led to the creation of the <a
	href="http://www.osgi.org/EEG/">OSGi Service Platform Enterprise</a>
specification. It defines how enterprise applications look like in the
OSGi world: a WAR archive can be now deployed as a <i>Web
Application Bundle</i>, a JAR with persistency logic - as a <i>Persistence
Bundle</i>, and so on. The OSGi Enterprise specification has already being
implemented in several runtime projects.</p>

<p>The Eclipse <a href="http://www.eclipse.org/webtools/">Web
Tools Platform</a> (WTP) project delivers tooling for Web and Java EE
development for long years, but the OSGi Enterprise space is still not
addressed. On the other hand, the Eclipse Plug-in Development
Environment (PDE) project is the de-facto standard tooling for
development of OSGi bundles. But again, PDE does not provide all
necessary features when it comes to OSGi Enterprise. And most
importantly, PDE lacks fundamental features for Web development. A
natural and evolutional step for providing OSGi Enterprise tooling is to
bring the PDE and WTP tooling together.
<h2>Scope</h2>

<!-- 
	All projects must have a well-defined scope. Describe, concisely, what
	is in-scope and (optionally) what is out-of-scope. An Eclipse project
	cannot have an open-ended scope.
 -->

<p>This project will be focused on providing standard tools for OSGi
Enterprise application development. This will happen in two directions:
</p>
<ul>
	<li>Tools that integrate the existing WTP tooling and PDE tooling
	in a way that OSGi Enterprise application can be developed with both
	tooling at the same time.</li>
	<li>Tools for better user experience in the <a
		href="http://www.eclipse.org/equinox/server/">Server-Side Equinox</a>
	scenario.</li>
</ul>

<p>In scope:</p>

<ul>
	<li>Tools for creation of deployable artifacts for application
	servers implementing the OSGi Enterprise specification, e.g. wizard for
	creating new Web Application Bundle projects.</li>
	<li>Tools for converting existing Java EE deployable artifacts to
	OSGi Enterprise deployable artifacts, e.g. wizard for converting
	Dynamic Web projects to a Web Application Bundle projects.</li>
	<li>Tools for editing and validation of the metadata of OSGi
	Enterprise artifacts, e.g. extension of the PDE Manifest Editor for
	editing manifest headers that are specific to Web Application Bundles.
	</li>
	<li>OSGi server adapter, providing basic implementation of
	configuring an OSGi-based application server, starting it and deploying
	OSGi enterprise artifacts. This server adapter should be customizable
	and extensible by adopters.</li>
	<li>Tools that improve the experience of developing Server-Side
	Equinox applications.</li>
	<li>Extensibility of the tools in scope, so adopters can extend
	them for their own application model.</li>
</ul>

<p>Out of scope:</p>

<ul>
	<li>Application models that extend and/or are in conflict with the
	OSGi Enterprise specification.</li>
	<li>Any tools that are replacement of existing tooling in the WTP
	and PDE projects. If WTP and PDE tooling have any limitations, then
	these limitations will be addressed in the corresponding projects. This
	project will do the best effort to extend the currently available
	tooling. In certain cases it would be acceptable to incubate new ideas
	in this project as proof of concept and then hand them over to the
	corresponding PDE or WTP subproject when agreement is already in place.
	</li>
</ul>

<h2>Description</h2>

<!-- 
	Describe the project here. Be concise, but provide enough information that
	somebody who doesn't already know very much about your project idea or domain
	has at least a fighting chance of understanding its purpose.
 -->

<p>The Plug-in Development Environment project and Web Tools
Platform project provide plenty of tools for OSGi development and Java
EE development, respectively. This project will provide the missing
pieces that will bring the PDE and WTP tooling together for implementing
OSGi Enterprise scenarios.</p>

<p>Potential development in this project:</p>

<ul>
	<li>Tools for working with Bundle projects:</li>
	<ul>
		<li><i>OSGi Bundle</i> facet for extending the current WTP
		projects with PDE capabilities. The behavior of this facet will be
		influenced by the existence of other WTP facets like the Web facet and
		JPA facet. This means that a combination of Web facet and OSGi Bundle
		facet will give Web Application Bundle nature to the project, and a
		combination of JPA facet and OSGi Bundle facet will give Persistence
		Bundle nature to the project.</li>
		<li>Wizards to convert existing WTP project to OSGi Enterprise
		bundle projects.</li>
		<li>Extensions of the existing PDE Manifest Editor for editing
		additional manifest headers, specified by the OSGi Enterprise
		specification, e.g. <i>Web-ContextPath</i></li>
		<li>Extensions of the existing PDE and WTP validations for
		ensuring consistency between the PDE and WTP models.</li>
		<li>Synchronizers between the PDE and WTP models to ensure
		consistency, e.g. changing the <i>Web-ContextPath</i> manifest headers
		should request a change in the corresponding object in the WTP model.
		</li>
		<li>Wizards for import and export of Bundle projects.</li>
		<li>Tools for generation and automatic maintenance of the
		MANIFEST.MF descriptor, derived from the SpringSource Bundlor.</li>
		<li>Other tools for easier working with Bundle projects.</li>
	</ul>

	<li>Extensible OSGi based Server Adapter tools complete with
	editors and wizards with exemplar implementations for Apache Felix,
	Eclipse Equinox and Knoplerfish will enable bundle projects to run,
	debug and be published to these OSGi runtimes:</li>
	<ul>
		<li>The runtime preference pages will be able to download,
		install, define and validate runtime installations.</li>
		<li>The server wizard will be able to define runtime instances,
		to which OSGi bundles can be targeted and deployed.</li>
		<li>Each server will create a proper PDE target definition.</li>
		<li>New server instances will be created from existing PDE target
		definitions.</li>
		<li>Server editor will allow editing modules, configuration
		parameters and the PDE target platform for each specific server
		configuration.</li>
		<li>Bundle Overview - Server editor will provide overview of the
		installed bundles and basic management operations.</li>
		<li>Bundle Dependencies Graph - Server editor will display
		package and service dependencies in graphical form.</li>
		<li>Launch configuration types will be provided for contributed
		runtimes.</li>
		<li>OSGi framework extension for contributed runtimes support
		will allow PDE to treat server/runtimes as regular OSGi frameworks.</li>
		<li>Publisher to manage bundle (workspace and external)
		deployment to runtimes.</li>
	</ul>

	<li><a href="http://wiki.eclipse.org/RAP/Equinox_WAR_products">WAR
	deployment for Equinox based applications</a></li>
	<ul>
		<li>Other tools that improve the experience of developing
		Server-Side Equinox applications.</li>
	</ul>
	<li>Other tooling that falls in the scope of the OSGi Enterprise
	specification, e.g. tooling for Blueprint Container specification.</li>
</ul>

<h2>Initial Contribution</h2>

<!-- 
	Describe any existing code that will be contributed to the project.
 -->

<p>The below is the consolidated vision of the contributing
companies about the initial contribution of the project. There will be
some technical time needed to assemble all the pieces the each of the
contributors will donate.</p>

<p>Tools for working with Bundle projects:</p>
<ul>
	<li>OSGi Bundle facet and corresponding install delegate and
	install wizard page. This will result in enhanced WTP project wizards:
	</li>
	<ul>
		<li>The Dynamic Web Project wizard will be able to create Web
		Application Bundle projects</li>
		<li>The JPA Project wizard will be able to create Persistent
		Bundle projects</li>
		<li>The Utility Project wizard will be able to create ordinary
		OSGi Bundle projects</li>
	</ul>
	<li>Wizard for converting WTP standard projects to OSGi Enterprise
	bundle projects. The wizard will be able to convert:</li>
	<ul>
		<li>Dynamic Web projects to Web Application Bundle projects</li>
		<li>JPA projects to Persistent Bundle projects</li>
		<li>Utility projects and simple Java projects to OSGi Bundle
		projects</li>
	</ul>
</ul>

<p>Extensible OSGi based Server Adapter tools complete with editors
and wizards with exemplar implementations for Apache Felix, Eclipse
Equinox and Knoplerfish will enable bundle projects to run, debug and be
published to these OSGi runtimes:</p>
<ul>
	<li>The runtime preference pages will be able to download,
	install, define and validate runtime installations.</li>
	<li>The server wizard will be able to define runtime instances, to
	which OSGi bundles can be targeted and deployed.</li>
	<li>Each server will create a proper PDE target definition.</li>
	<li>New server instances will be created from existing PDE target
	definitions.</li>
	<li>Server editor will allow editing modules, configuration
	parameters and the PDE target platform for each specific server
	configuration.</li>
	<li>Launch configuration types will be provided for contributed
	runtimes.</li>
	<li>OSGi framework extension for contributed runtimes support will
	allow PDE to treat server/runtimes as regular OSGi frameworks.</li>
	<li>Publisher to manage bundle (workspace and external) deployment
	to runtimes.</li>
</ul>

<p><a href="http://wiki.eclipse.org/RAP/Equinox_WAR_products">WAR
deployment for Equinox based applications</a>. It was developed during
Google Summer of Code 2010. The source code is already contributed to
the Eclipse PDE Incubator after a successful IP review. After the
Creation Review the code will be moved to the Libra
project and the work will continue there.</p>

<p>Some contributing parties decided to exchange some code from
their planned initial contributions ahead of the Creation Review. Follow
<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=330491">bug
330491</a> for details.</p>

<h2>Legal Issues</h2>

<!-- 
	Please describe any potential legal issues in this section. Does somebody else
	own the trademark to the project name? Is there some issue that prevents you
	from licensing the project under the Eclipse Public License? Are parts of the 
	code available under some other license? Are there any LGPL/GPL bits that you
	absolutely require?
 -->

<p>No legal issues identified yet.</p>

<h2>Relationship to other projects</h2>

<h3>Plug-in Development Tools</h3>

<p>Libra does not aim to compete with
the PDE project. The goal is to supplement the OSGi development tools
currently provided by PDE with new capabilities that are relevant of
OSGi Enterprise application development and Server-Side Equinox
application development. If any issues can be addressed in the PDE
project, they will be addressed there. It could the case that an OSGi
related capability is first developed in the Libra
project, but later, after agreement with the PDE project, it is moved to
PDE.</p>

<h3>Web Tools Platform</h3>

<p>Similarly to PDE, the Libra project does not aim
to compete with the WTP project. Any new features regarding Web and Java
EE development will be addressed directly in the corresponding WTP
subprojects. Libra will provide the bits for
integrating the PDE and WTP tooling.</p>

<h3>Virgo Tools</h3>

<p>The Virgo Tools, which VMWare plans to contribute to the Eclipse
Foundation, is overlapping in scope with current project proposal. Due
to the complexity of the contribution, the Virgo team will first
contribute the Virgo Tools as a separate project under the Eclipse
Runtime top-level project and then will factor out the generic, standard
based capabilities that will go to other existing Eclipse projects like
PDE or Libra.</p>

<p>The Libra and Virgo Tools projects are not going to
compete with each other, but will work together to find a way to
consolidate the features provided by both projects.</p>

<p>See the following <a
	href="http://www.eclipse.org/forums/index.php?t=msg&th=198541">forum
topic</a> for details.</p>

<h2>Committers</h2>

<!-- 
	List any initial committers that should be provisioned along with the
	new project. Include affiliation, but do not include email addresses at
	this point.
 -->

<p>The following individuals are proposed as initial committers to
the project:</p>

<ul>
	<li><a href="mailto:kaloyan.raev@sap.com">Kaloyan Raev</a>, SAP -
	Lead</li>
	<li><a href="mailto:dimitar.giormov@sap.com">Dimitar Giormov</a>,
	SAP</li>
	<li><a href="mailto:dimo.stoilov@sap.com">Dimo Stoilov</a>, SAP</li>
	<li><a href="mailto:murat.yener@eteration.com">Murat Yener</a>,
	Eteration</li>
	<li><a href="mailto:umut.duman@eteration.com">Umut Duman</a>,
	Eteration</li>
	<li><a href="mailto:naci.dai@eteration.com">Naci Dai</a>,
	Eteration</li>
	<li><a href="mailto:caniszczyk@gmail.com">Chris Aniszczyk</a>, Red
	Hat</li>
	<li><a href="mailto:hstaudacher@eclipsesource.com">Holger
	Staudacher</a>, EclipseSource</li>
	<li><a href="mailto:mlippert@vmware.com">Martin Lippert</a>,
	VMWare</li>
	<li><a href="mailto:gnormington@vmware.com">Glyn Normington</a>,
	VMWare</li>
	<li><a href="mailto:frostc@vmware.com">Christopher Frost</a>,
	VMWare</li>
</ul>

<!-- 
	Describe any initial contributions of code that will be brought to the 
	project. If there is no existing code, just remove this section.
 -->

<h2>Mentors</h2>

<!-- 
	New Eclipse projects require a minimum of two mentors from the Architecture
	Council. You need to identify two mentors before the project is created. The
	proposal can be posted before this section is filled in (it's a little easier
	to find a mentor when the proposal itself is public).
 -->

<p>The following Architecture Council members will mentor this
project:</p>

<ul>
	<li>Chris Aniszczyk, Red Hat</li>
	<li>Naci Dai, Eteration</li>
</ul>

<h2>Interested Parties</h2>

<!-- 
	Provide a list of individuals, organisations, companies, and other Eclipse
	projects that are interested in this project. This list will provide some
	insight into who your project's community will ultimately include. Where
	possible, include affiliations. Do not include email addresses.
 -->

<p>The following individuals, organizations, companies and projects
have expressed interest in this project:</p>

<ul>
	<li>Tim Deboer, IBM</li>
	<li>Neil Hauge, Oracle</li>
	<li>Konstantin Komissarchik, Oracle</li>
	<li>Naci Dai, Eteration</li>
	<li>Martin Lippert, VMWare</li>
	<li>Glyn Normington, VMWare</li>
	<li>Christopher Frost, VMWare</li>
</ul>

<h2>Project Scheduling</h2>

<!-- 
	Describe, in rough terms, what the basic scheduling of the project will
	be. You might, for example, include an indication of when an initial contribution
	should be expected, when your first build will be ready, etc. Exact
	dates are not required.
 -->

<ul>
	<li>October 2010 - proposal</li>
	<li>November 2010 - creation review and initial contribution</li>
	<li>December 2010 - first milestone release aligned with Indigo M4</li>
	<li>March 2011 - milestone release aligned with Indigo M6</li>
	<li>June 2011 - incubating release aligned with the Indigo
	Simultaneous Release</li>
</ul>

<h2>Changes to this Document</h2>

<!-- 
	List any changes that have occurred in the document here.
	You only need to document changes that have occurred after the document
	has been posted live for the community to view and comment.
 -->

<table>
	<tr>
		<th>Date</th>
		<th>Change</th>
	</tr>
	<tr>
		<td>01-September-2010</td>
		<td>Document created</td>
	</tr>
	<tr>
		<td>13-October-2010</td>
		<td>Small changes in Scope and Description. Eteration added as a
		major contributor. Chris Aniszczyk added as a committer and mentor.
		Interested Parties updated.</td>
	</tr>
	<tr>
		<td>22-October-2010</td>
		<td>Equinox Server-Side added to the scope. Holger Staudacher
		added as a committer. Section about relationship to other projects
		added. Interested Parties updated.</td>
	</tr>
	<tr>
		<td>04-November-2010</td>
		<td>Added info about the proposed initial contribution by
		Eteration.</td>
	</tr>
	<tr>
		<td>23-November-2010</td>
		<td>Initial contribution consolidated to a common vision of the
		contributing parties. Added info about VMWare initial committers.</td>
	</tr>
</table>
</body>
</html>