<?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 Pre-requisites</title>

<para>
Before building and running the @greenpages@ sample, it is essential to install a <emphasis>JDK</emphasis>,
<emphasis>@webserv@</emphasis> and <emphasis>@maven.full@</emphasis>.
</para>

<section id="installation.prereqs">
<title>Installing a JDK</title>

<para>
Before proceeding, ensure that a Java<trademark class="trade"/> Standard Edition Development Kit (JDK)
for Java 6 or later is installed and that the <literal>JAVA_HOME</literal> environment variable 
is set to the root directory of the JDK.
(<emphasis>A Java Runtime Environment (JRE) alone is not sufficient for building the sample.</emphasis>)
</para>

</section>

<section id="installation.dmserver">

<title>Installing @webserv@</title>

<para>
Unzip the @webserv@ Zip file.
Ensure the destination path does not contain spaces.
On Windows<trademark class="trade"/> operating systems, ensure you unzip this near the root of a drive to avoid issues with long path names.
</para>
<para>
Please refer to the Virgo User Guide for full installation instructions.
See <link linkend="further.resources.documentation">Documentation</link>.
</para>

</section>

<section id="installation.virgotooling">

<title>Installing the Eclipse Tooling</title>

<para>
This is necessary only if you would like to run the sample under Eclipse.
</para>
<para>
Please refer to the Virgo Programmer Guide for installation instructions of the @virgo@ tooling.
See <link linkend="further.resources.documentation">Documentation</link>.
</para>

<para>
This sample also uses Maven and to support the build in Eclipse you need to install the m2e plugin. 
This is simple to do from the 'Help' -> 'Install New Software..' menu item. Add a new update site of 
<literal>http://download.eclipse.org/technology/m2e/releases/</literal> and then use it to install the plugin.
</para>

</section>

<section id="installation.maven">
<title>Installing @maven.full@</title>

<para>
<emphasis>@maven.full@</emphasis>, or @maven@ for short, is a software project management and comprehension tool
which uses a central <emphasis>Project Object Model</emphasis> (POM) to manage a project&rsquo;s build, reporting 
and documentation generation. POM files (<literal>pom.xml</literal>) are included in the projects for
@greenpages@.
</para>

<para>
To install @maven@, visit the @maven@ website (<ulink url="@maven.url@">@maven.url@</ulink>) 
and follow the download instructions from there.
This document has been written and tested with @maven@ version @maven.version@. The rest of the document 
assumes that @maven@ 
commands (<literal>mvn …</literal>) are available from the command line.
</para>
</section>

</chapter>
