<div id="midcolumn">
	<h1>Migrating from Gemini Blueprint 1.0.x to 2.0.0</h1>

	Gemini Blueprint 2.0.0 now requires Spring 4.2.x and requires Java 1.7+ to run. Furthermore, OSGi Spring bundles are now provided by the Apache ServiceMix team.
	Both the Gemini Blueprint artifacts and the Spring OSGi artifacts are available from maven central. For more details, see
	<a href="https://www.eclipse.org/gemini/blueprint/download/">Download Gemini Blueprint</a>. To migrate, one must thus:

	<ul>
		<li>Use Spring 4.2.x</li>
		<li>Run at Least Java 1.7</li>
		<li>Update the maven dependencies to reflect the group and artifaact id changes of the spring dependencies</li>
		<li>Remove outdated repository configurations as everything is now available via maven central</li>
	</ul>

	<h1>Migrating from Spring Dynamic Modules to Eclipse Gemini Blueprint</h1>
	
	
	<p>This guide is aimed at helping developers using Spring DM in their application to migrate to Eclipse Gemini Blueprint.</p>
	
	<h3>Overview</h3>
	<p>Gemini Blueprint was created through the migration of Spring Dynamic Modules to the Eclipse Foundation. While certain things have
	changed in the process, mainly to reflect the new project name and hosting infrastructure, the project architecture, ideas, code base and dependencies
	have remained intact. Use this to your advantage when encountering errors, by looking first for references to 'old' packages or classes as these are likely
	to be the problem in the vast majority of cases.
	</p>
	
	<h2>1.0.0.RC1</h2>
	
	<h3>Changed Package Name</h3>
	<p>The most disruptive change for Spring DM users when transitioning to Gemini Blueprint is the renaming of the project packages: 
	from <tt>org.springframework.osgi</tt> to <tt>org.eclipse.gemini.blueprint</tt>. If you are referring to the Spring DM classes, in any way,
	either inside Java code or XML configuration, you need to update the package.<br/>
	The actual class names and method signatures have <b>not</b> been changed so in most cases the changed can be accommodated through a simple "search & replace"
	operation.<br/>
	Note that for configuration purposes, one can shield itself from the package change by relying on the Spring DM/Eclipse Gemini Blueprint namespaces 
	which hide the actual classes used for configuring, making the change transparent.	 
	</p>
	
	<h3>Changed Exported Packages (Versions Included)</h3>
	<p>Inherent to the package name changes, the artifact manifests have been updated as well. Besides changing the imported package names as indicated above, consumers should modify
	the imported version to <tt>1.0.0</tt> (or <tt>1.0.0.M1</tt> for wiring only to the M1 artifact).
	
	<h3>Deprecated Namespace/Schema Location</h3>
	<p>The existing Spring DM schema definition (named <tt>spring-osgi.xsd</tt> and located at <tt>http://www.springframework.org/schema/osgi</tt>) are still available and supported
	by Eclipse Gemini Blueprint. However we recommend users to migrate to the newly added schemas at <tt>http://www.eclipse.org/gemini/blueprint/schema/blueprint/gemini-blueprint.xsd</tt>
	and <tt>http://www.eclipse.org/gemini/blueprint/schema/blueprint-compendium/gemini-blueprint-compendium.xsd</tt>. Except for the schema location, the new schemas are identical to the
	old ones and will be the target of any new improvements and further development.</p>
	
	<h3>Deprecated Spring-DM specific service properties</h3>
	<p>Similar to the schema deprecation, the Spring-DM specific properties on exported services (such as <tt>org.springframework.osgi.bean.name</tt>) have been deprecated. While they are still supported
	users are recommended to use the newly introduced Gemini Blueprint props (simply replace <tt>org.sprinframework.osgi</tt> prefix with <tt>org.eclipse.gemini.blueprint</tt>).</p>
	
	<h3>Removed deprecated classes</h3>
	<p>During the move, several deprecated or unused classes have been removed. If you cannot find a class name in the new package, it's likely that it has been removed in the process. Feel free
	to confirm this over the forums.</p>

	<h3>Removed deprecated modules</h3>
	<p>As of Gemini Blueprint M1, not all modules or projects inside Spring DM have been moved. At the moment only the <tt>io</tt>, <tt>core</tt>, <tt>extender</tt> and <tt>test</tt> modules have 
	transitioned are provided in M1. With the up-coming release of OSGi RFC-66, the web support is being discontinued. Existing users are encouraged to look at Eclipse Gemini Web 
	<a href="http://www.eclipse.org/gemini/blueprint/">project</a>. The plans for the Maven archetype and annotation extension are undefined for the moment and these modules are <b>NOT</b> included
	in Gemini Blueprint project.</p>
	
	<h3>Changed Maven artifact groupId/artifactId and repository</h3>
	<p>The Maven artifacts have changed as well during the transition. For the time being, the artifacts are hosted at a new repository (<tt>zodiac.springsource.com</tt>):
	  <pre>
  &lt;repository&gt;
    &lt;id&gt;zodiac-repository&lt;/id&gt;
    &lt;name&gt;Zodiac Milestone Repository&lt;/name&gt;
    &lt;url&gt;http://zodiac.springsource.com/maven/bundles/milestone&lt;/url&gt;
  &lt;/repository&gt;
  	 </pre>
    The groupId has changed from <tt>org.springframework.osgi</tt> to <tt>org.eclipse.gemini.blueprint</tt> and artifactId from <tt>spring-osgi-*</tt> to <tt>gemini-blueprint-*</tt> (e.g.
    <tt>spring-osgi-core</tt> is now <tt>gemini-blueprint-core</tt>).		
	</p>
	
	<p>The content and names of the artifacts have remained mainly unchanged.</p>
	
</div>