<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE chapter PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN" "http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd">
<chapter id="installation">
	<title>Installing @project.name@</title>
	<section id="installation-prereqs">
		<title>Prerequisites</title>
		<para>
			The @product.name@, or @short.product.name@ for short, requires Java SE 7 or later to be installed. Java is available from
			<ulink url="http://www.java.com/">http://www.java.com/</ulink> and elsewhere.
		</para>
	</section>
	<section id="installation-zip">
		<title>Installing from the ZIP Download</title>
		<itemizedlist>
			<listitem>
				<para>
					<ulink url="http://download.eclipse.org/equinox/">Download</ulink> the Equinox JAR, for example <ulink url="http://download.eclipse.org/equinox/drops/R-LunaSR1-201409250400/download.php?dropFile=org.eclipse.osgi_3.10.1.v20140909-1633.jar">org.eclipse.osgi_3.10.1.v20140909-1633.jar</ulink>, and move it to a suitable directory (e.g. ~/gemini-web-test).
					On the <ulink url="http://download.eclipse.org/equinox/">Download</ulink> page, first choose the desired Release or Build, then download the JAR from the 'Framework Only' section.
				</para>
			</listitem>
			<listitem>
				<para>
					<ulink url="http://download.eclipse.org/equinox/">Download</ulink> the Equinox Console, for example <ulink url="http://download.eclipse.org/equinox/drops/R-LunaSR1-201409250400/download.php?dropFile=equinox-SDK-LunaSR1.zip">equinox-SDK-LunaSR1.zip</ulink>.
					You will need the bundles listed below:
					<itemizedlist>
						<listitem>org.apache.felix.gogo.command_0.10.0.v201209301215.jar</listitem>
						<listitem>org.apache.felix.gogo.runtime_0.10.0.v201209301036.jar</listitem>
						<listitem>org.apache.felix.gogo.shell_0.10.0.v201212101605.jar</listitem>
						<listitem>org.eclipse.equinox.console_1.1.0.v20140131-1639.jar</listitem>
					</itemizedlist>
					Move them to a suitable directory (e.g. ~/gemini-web-test).
					On the <ulink url="http://download.eclipse.org/equinox/">Download</ulink> page, first choose the desired Release or Build, then download the ZIP from the 'All of Equinox' section. Bundles can be found in the plugins folder.
				</para>
			</listitem>
			<listitem>
				<para>
					@product.name@ is distributed as a ZIP file.
					<ulink url="http://www.eclipse.org/gemini/web/download">Download</ulink> @product.name@ and unzip it to ~/gemini-web-test/gemini-web. 
				</para>
			</listitem>
			<listitem>
				<para>
					Configure Equinox by creating a directory ~/gemini-web-test/configuration and create a file config.ini in the configuration directory. 
					Example file which works with 3.0.0.M01 is available in <ulink url="https://wiki.eclipse.org/images/f/f5/Config.ini.3.0.0.M01.zip">config.ini.zip</ulink>.
					Essentially config.ini ensures that the dependencies of @product.name@, which come in the dep directory, are installed and then the @product.name@ bundles are installed and started. 
				</para>
			</listitem>
			<listitem>
				<para>
					Start Equinox as follows:
					<programlisting language="xml"><![CDATA[java -jar org.eclipse.osgi_3.10.1.v20140909-1633.jar -console]]></programlisting></para>
			</listitem>
			<listitem>
				<para>
					You can then deploy WAR files (a trivial example is available in <ulink url="https://wiki.eclipse.org/images/a/a0/Simple-war.war.zip">Simple-war.war.zip</ulink>) and web bundles using the install and start commands from the console.
					<programlisting language="xml"><![CDATA[osgi> install webbundle:file:simple-war.war
Bundle id is 40
osgi> start 40]]></programlisting></para>
			</listitem>
			<listitem>
				<para>
					Drive the WAR or web bundle using a web browser, e.g. http://localhost:8080/simple-war should display "Hello World!". 
				</para>
			</listitem>
			<listitem>
				<para>
					Stop @product.name@ as follows:
					<programlisting language="xml"><![CDATA[osgi> close]]></programlisting>
					<tip>
						You need to stop any old instance of Gemini Web before starting it again. Otherwise, the new instance will not start correctly, because the old one still occupies the http port (and, perhaps, other system resources).
					</tip>
				</para>
			</listitem>
		</itemizedlist>
	</section>
</chapter>