<?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="prerequisites">
	<title>Prerequisites</title>

	<section id="prerequisites-environment">
		<title>Runtime Environment</title>
		<para>
			@project.name@ requires Java SE 6 or later to be installed. Java is available from
			<ulink url="http://java.sun.com/javase/downloads/index.jsp">Sun</ulink> and elsewhere.
		</para>
	</section>

	<section id="prerequisites-references">
		<title>References</title>
		<para>
			To make effective use of the @tomcat.product.name@, you should also refer to the following:
		</para>
		<itemizedlist>
			<listitem><ulink url="../../virgo-user-guide/html/index.html">@project.name@ User Guide</ulink></listitem>
			<listitem><ulink url="../../virgo-tooling-guide/html/index.html">@project.name@ Tooling Guide</ulink></listitem>
			<listitem><ulink url="http://static.springframework.org/osgi/docs/current/reference/html/">Spring Dynamic Modules Reference</ulink></listitem>
			<listitem><ulink url="http://www.osgi.org/Specifications/HomePage">Blueprint Container Specification</ulink>
			(in the OSGi 4.2 and 5.0 Enterprise Specifications)</listitem>
			<listitem><ulink url="http://static.springsource.org/spring/docs/3.0.x/spring-framework-reference/html/index.html">Spring Framework Reference</ulink></listitem>
		</itemizedlist>
	</section>

</chapter>
