<!-- 
	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>Cloud Deployment Toolkit</title>
</head>

<body>
<p>The Cloud Deployment Toolkit (CDTK) project is a proposed open source project under the 
<a href="http://www.eclipse.org/technology/">Eclipse Technology 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.cdtk">CDTK forum</a>.</p>

<h2>Background</h2>

<!-- 
	Optionally provide the background that has lead you to creating this project.
 -->
<p>Cloud computing is changing the Software Development Life-Cycle (SDLC) by allowing developers 
to rapidly provision systems and test new code on a fully functional clone of the target production 
environment.  In order for the development process to use cloud effectively the environment 
provisioning and code deployment needs to be integrated in the IDE.</p>

<p>Cloud computing has three different Service Models as defined in the
<a href="http://csrc.nist.gov/groups/SNS/cloud-computing/">NIST Definition of Cloud Computing</a>.
Infrastructure as a Service (IaaS) is the Service Model that allows server platforms to be 
provisioned.  Cloud IaaS is an emerging technology with many different implementations.  These 
differences lead to inefficiences in the development process as teams need to learn 
to interact with each cloud functions without an abstraction to facilitate the deployment
 process across each IaaS cloud.</p>

<p>The Cloud Deployment Toolkit will provide this abstraction allowing developers to use the
same workflow to provision resources across multiple providers.  This will allieviate
IT management concerns that applications will become locked in to a specific IaaS platform.</p>

<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>The objectives of the Cloud Deployment Tool kit (CDTK) are:</p>

<ul>
	<li>Allow architects to define and share system specifications in an abstract format.</li>
	<li>Allow developers to easily manage, share, and clone IaaS cloud infrastructures.</li>
	<li>Allow developers to easily deploy code to IaaS cloud infrastructures.</li>
	<li>Provide reports on IaaS resource utilization for IT management.</li>
	<li>Allow developers to easily share reports on IaaS resource utilization.</li>
	<li>Provide integration with application server code deployment plugins.</li>
	<li>Provide integration with debugger plugins.</li>
	<li>Provide integration with testing and performance tool plugins.</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 Cloud Deployment Toolkit provides an abstraction to multiple IaaS cloud platforms
allowing developers to create and work with a full clone of the production environment.
They can test code changes for both functionality and performance speeding up the 
development process.</p>

<p>Through the reporting module developers can provide IT management with resource usage
and associated costs.  By integrating this with performance analysis tools production
operating costs can be accurately modeled.</p>

<h2>Initial Contribution</h2>

<!-- 
	Describe any existing code that will be contributed to the project.
 -->
<p>With the CDTK we are looking at building on foundation libraries to handle the
interface abstraction to the IaaS infrastructure.  Projects under consideration
are <a href="http://github.com/jclouds/jclouds">jclouds</a> and the
<a href="http://dasein-cloud.sourceforge.net/">Dasein Cloud API</a>.  The project
communities are represented on the project by Adrian Cole and George Reese 
respectively.</p>

<p>For the abstraction to define the IaaS system architecture the project team
will evaluate and consieder existing similar mechanisms including 
<a href="http://www.dmtf.org/standards/published_documents/DSP0243_1.1.0.pdf">
OVF (Open Virtualization Format) 1.1</a> from the DMTF (Distributed Management Task Force)
, the <a href="http://www.occi-wg.org/">OCCI (Open Cloud Computing Interface)</a> 
Infrastructure Model from the OGF (Open Grid Forum), and the
<a href="http://libvirt.org/format.html">Libvirt XML Format</a>.

<h2>Relationship to Other Eclipse Projects</h2>

<!-- 
	Describe any existing Eclipse projects that are related to the proposal.
 -->
<p><a href="http://www.geclipse.eu/">g-Eclipse</a> is an existing Eclipse project
that has its roots in grid computing.  We believe the Cloud Deployment Toolkit (CDTK)
is a similar but complementary approach to g-Eclipse. CDTK is focused on providing
an abstraction to multiple IaaS platforms and a pluggable architecture for integration
with other Eclipse tool projects.</p>

<p> A discussion with the g-Eclipse project team will continue in more detail at 
EclipseCon -- timing TBD -- for all interested parties to consider potential
code re-use and project integration.</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?
 -->
 
<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>Mike Mayo, Rackspace Hosting - proposed project lead</li>
	<li>George Reese, enStratus</li>
	<li>Adrian Cole, jclouds</li>	
	<li>Wade Minter, Rackspace Hosting</li>
	<li>Max Andersen, Red Hat</li>
	<li>Michael Neale, Red Hat</li>
	<li>Rob Stryker, Red Hat</li>
	<li>Roy Ganor, Zend</li>
	<li>Kenn Hussey, Cloudsmith</li>
	<li>Henrik Lindberg, Cloudsmith</li>
	<li>Thomas Hallgren, Cloudsmith</li>
	<li>Michal R&ucirc;&#382;i&#269;ka, Cloudsmith</li>
</ul>

<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>Gunnar Wagenknecht</li>
	<li>Chris Aniszczyk</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, organisations, companies and projects have 
expressed interest in this project:</p>

<ul>
	<li>Basil Hashem, Aptana</li>
	<li>Bret Piatt, Rackspace Hosting</li>
	<li>Bob McWhirter, Red Hat</li>
	<li>Andi Gutmans, Zend Technologies</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.
 -->

2010-03 v0.1: Preview release for EclipseCon<br>
2010-06 v0.2: Functional release with IaaS provisioning<br>
2010-09 v0.3: Stable IaaS provisioning, functional IT management reporting<br>
2011-01 v0.5: Stable IT management reporting<br>
2011-03 v0.6: Functional framework for interaction with other plugins<br>
2011-05 v0.8: Stable framework for interaction with other plugins<br>
2011-09 v1.0: Stable complete plugin with support for a majority of IaaS cloud platforms<br>

<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>20-December-2009</td>
		<td>Document created</td>
	</tr>
	<tr>
		<td>20-February-2010</td>
		<td>Draft revision based on feedback from project team</td>
	</tr>
	<tr>
		<td>02-March-2010</td>
		<td>
			Added Roy Ganor to project team.
			Clarified bullet points in the scope section.
			Added projects to the initial contribution section.
		</td>
	</tr>
	<tr>
		<td>11-March-2011</td>
		<td>
			Added Basil Hashem as an interested party.
			Added OVF, OCCI, and Libvirt evaluation to initial contribution section.
		</td>
	</tr>
	<tr>
		<td>19-March-2011</td>
		<td>
			Added mentors.
		</td>
	</tr>
</table>
</body>
</html>
