diff --git a/org.eclipse.gemini.web.documentation/user-guide/src/configuring.xml b/org.eclipse.gemini.web.documentation/user-guide/src/configuring.xml
index 6a39697..f0b7dd4 100755
--- a/org.eclipse.gemini.web.documentation/user-guide/src/configuring.xml
+++ b/org.eclipse.gemini.web.documentation/user-guide/src/configuring.xml
@@ -17,8 +17,8 @@
 		<programlisting language="xml"><![CDATA[<?xml version='1.0' encoding='utf-8'?>
 <Server>
 
+  <Listener className="org.apache.catalina.startup.VersionLoggerListener" />
   <Listener className="org.apache.catalina.core.AprLifecycleListener" SSLEngine="on" />
-  <Listener className="org.apache.catalina.core.JasperListener" />
   <Listener className="org.apache.catalina.core.JreMemoryLeakPreventionListener" />
   <Listener className="org.apache.catalina.core.ThreadLocalLeakPreventionListener" />
 
@@ -42,7 +42,7 @@
 		<section id="overview-tomcat-servlet-container">
 			<title>Description of the Default Apache Tomcat Configuration</title>
 			<para>
-				The following bullets describe the main elements and attributes in the default <literal>tomcat-server.xml</literal> file; for details about updating this file to further configure the embedded Apache Tomcat server, see the <ulink url="http://tomcat.apache.org/tomcat-7.0-doc/config/index.html">Apache Tomcat Configuration Reference</ulink>.
+				The following bullets describe the main elements and attributes in the default <literal>tomcat-server.xml</literal> file; for details about updating this file to further configure the embedded Apache Tomcat server, see the <ulink url="http://tomcat.apache.org/tomcat-8.0-doc/config/index.html">Apache Tomcat Configuration Reference</ulink>.
 			</para>
 			<tip>
 				<title>Relative paths</title>
@@ -86,8 +86,8 @@
 		<section id="configuring-tomcat-connectors">
 			<title>Connector Configuration</title>
 			<para>The @product.name@ supports the configuration of any connector supported by Apache Tomcat. 
-				See the default configuration above for syntax examples, and for further details of the configuration properties supported for various <literal>&lt;Connector&gt;</literal> implementations, consult the official <ulink url="http://tomcat.apache.org/tomcat-7.0-doc/config/http.html">Apache Tomcat HTTP Connector</ulink> documentation.
-				For detailed instructions on how to configure Apache Tomcat's SSL support, consult the official <ulink url="http://tomcat.apache.org/tomcat-7.0-doc/ssl-howto.html">Apache Tomcat SSL Configuration HOW-TO</ulink>.
+				See the default configuration above for syntax examples, and for further details of the configuration properties supported for various <literal>&lt;Connector&gt;</literal> implementations, consult the official <ulink url="http://tomcat.apache.org/tomcat-8.0-doc/config/http.html">Apache Tomcat HTTP Connector</ulink> documentation.
+				For detailed instructions on how to configure Apache Tomcat's SSL support, consult the official <ulink url="http://tomcat.apache.org/tomcat-8.0-doc/ssl-howto.html">Apache Tomcat SSL Configuration HOW-TO</ulink>.
 			</para>
 		</section>
 		<section id="configuring-tomcat-clustering">
@@ -95,7 +95,7 @@
 			<para>
 				@product.name@ supports standard Apache Tomcat cluster configuration.
 				By default, clustering of the embedded servlet container is disabled, and the default configuration does not include any clustering information.  
-				See <ulink url="http://tomcat.apache.org/tomcat-7.0-doc/cluster-howto.html">Apache Tomcat Clustering/Session Replication HOW-TO</ulink> for detailed information about enabling and configuring clustering.
+				See <ulink url="http://tomcat.apache.org/tomcat-8.0-doc/cluster-howto.html">Apache Tomcat Clustering/Session Replication HOW-TO</ulink> for detailed information about enabling and configuring clustering.
 			</para>
 		</section>
 		<section id="configuring-default-web-xml">
@@ -115,10 +115,11 @@
 				Here's an extract of the default configuration distributed with the @short.product.name@.
 			</para>
 			<programlisting language="xml"><![CDATA[<?xml version="1.0" encoding="ISO-8859-1"?>
-<web-app xmlns="http://java.sun.com/xml/ns/javaee"
-    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
-    version="3.0">
+<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
+                      http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
+  version="3.1">
 
     <servlet>
         <servlet-name>default</servlet-name>
@@ -164,13 +165,13 @@
     </session-config>
 
     <mime-mapping>
-        <extension>abs</extension>
-        <mime-type>audio/x-mpeg</mime-type>
+        <extension>123</extension>
+        <mime-type>application/vnd.lotus-1-2-3</mime-type>
     </mime-mapping>
     ......
     <mime-mapping>
-        <extension>ppt</extension>
-        <mime-type>application/vnd.ms-powerpoint</mime-type>
+        <extension>zmm</extension>
+        <mime-type>application/vnd.handheld-entertainment+xml</mime-type>
     </mime-mapping>
 
     <welcome-file-list>
@@ -190,13 +191,13 @@
 							<listitem>
 								<para>
 									The default servlet serves static resources and processes the requests that are not mapped to any servlet.
-									For details about default servlet configuration, see the <ulink url="http://tomcat.apache.org/tomcat-7.0-doc/default-servlet.html">Apache Tomcat Default Servlet Reference.</ulink>.
+									For details about default servlet configuration, see the <ulink url="http://tomcat.apache.org/tomcat-8.0-doc/default-servlet.html">Apache Tomcat Default Servlet Reference.</ulink>.
 								</para>
 							</listitem>
 							<listitem>
 								<para>
 									The jsp servlet serves the requests to JavaServer Pages. It is mapped to the URL pattern "*.jsp" and "*.jspx".
-									For details about jsp servlet configuration, see the <ulink url="http://tomcat.apache.org/tomcat-7.0-doc/jasper-howto.html">Apache Tomcat Jasper 2 JSP Engine.</ulink>.
+									For details about jsp servlet configuration, see the <ulink url="http://tomcat.apache.org/tomcat-8.0-doc/jasper-howto.html">Apache Tomcat Jasper 2 JSP Engine.</ulink>.
 								</para>
 							</listitem>
 						</itemizedlist>
@@ -230,8 +231,8 @@
 			<title>Context Configuration</title>
 			<para>
 				@product.name@ supports standard Apache Tomcat web application context configuration.
-				The <ulink url="http://tomcat.apache.org/tomcat-7.0-doc/config/index.html">Apache Tomcat Configuration Reference</ulink> has a section on
-				<ulink url="http://tomcat.apache.org/tomcat-7.0-doc/config/context.html">The Context Container</ulink> which describes the mechanism that
+				The <ulink url="http://tomcat.apache.org/tomcat-8.0-doc/config/index.html">Apache Tomcat Configuration Reference</ulink> has a section on
+				<ulink url="http://tomcat.apache.org/tomcat-8.0-doc/config/context.html">The Context Container</ulink> which describes the mechanism that
 				is used in @short.product.name@ for searching context configuration files and details the context configuration properties.
 			</para>
 			<para>
@@ -282,7 +283,7 @@
 			<title>JNDI Resources</title>
 			<para>
 				By default @product.name@ supports standard Apache Tomcat JNDI Resources handling.
-				The <ulink url="http://tomcat.apache.org/tomcat-7.0-doc/jndi-resources-howto.html">Apache Tomcat JDNI Resources How-To</ulink> 
+				The <ulink url="http://tomcat.apache.org/tomcat-8.0-doc/jndi-resources-howto.html">Apache Tomcat JDNI Resources How-To</ulink>
 				describes in details how the JNDI resources can be configured and used.
 			</para>
 			<para>
@@ -321,10 +322,10 @@
 		<section id="configuring-jsp-compilation">
 			<title>JSP Compilation</title>
 			<para>
-				By default Apache Tomcat compiles JSP files in web applications agains Java 1.6.
-				In order to enable JSP compilation against Java 1.7 for your web application,
+				By default Apache Tomcat compiles JSP files in web applications against Java 1.7.
+				In order to enable JSP compilation against Java 1.8 for your web application,
 				additional init parameters (<literal>compilerSourceVM</literal> and <literal>compilerTargetVM</literal>) should be added for the <literal>org.apache.jasper.servlet.JspServlet</literal> configuration.
-				For details about <literal>org.apache.jasper.servlet.JspServlet</literal> configuration, see the <ulink url="http://tomcat.apache.org/tomcat-7.0-doc/jasper-howto.html">Apache Tomcat Jasper 2 JSP Engine</ulink>.
+				For details about <literal>org.apache.jasper.servlet.JspServlet</literal> configuration, see the <ulink url="http://tomcat.apache.org/tomcat-8.0-doc/jasper-howto.html">Apache Tomcat Jasper 2 JSP Engine</ulink>.
 				<literal>org.apache.jasper.servlet.JspServlet</literal> configuration can be provided with the web application's web.xml.
 			</para>
 			<programlisting language="xml"><![CDATA[<?xml version="1.0" encoding="ISO-8859-1"?>
@@ -333,11 +334,11 @@
     <servlet-class>org.apache.jasper.servlet.JspServlet</servlet-class>
     <init-param>
         <param-name>compilerSourceVM</param-name>
-        <param-value>1.7</param-value>
+        <param-value>1.8</param-value>
     </init-param>
     <init-param>
         <param-name>compilerTargetVM</param-name>
-        <param-value>1.7</param-value>
+        <param-value>1.8</param-value>
     </init-param>
     <init-param>
         <param-name>fork</param-name>
@@ -359,7 +360,7 @@
 		<section id="configuring-jar-scanner">
 			<title>Jar Scanner Configuration</title>
 			<para>
-				The standard <ulink url="http://tomcat.apache.org/tomcat-7.0-doc/config/jar-scanner.html">Jar Scanner</ulink> provided by Apache Tomcat is used to scan the web application for jar files containing configuration files - TLDs or web-fragment.xml files.
+				The standard <ulink url="http://tomcat.apache.org/tomcat-8.0-doc/config/jar-scanner.html">Jar Scanner</ulink> provided by Apache Tomcat is used to scan the web application for jar files containing configuration files - TLDs or web-fragment.xml files.
 				In addition to this functionality, @product.name@ provides Bundle Dependencies Jar Scanner. It is used to scan the web application bundle dependencies for such configuration files.
 				The bundles that are treated as web application bundle dependencies are:
 				<itemizedlist>
@@ -374,6 +375,7 @@
 					<listitem>javax.servlet</listitem>
 					<listitem>javax.servlet.jsp</listitem>
 					<listitem>javax.el</listitem>
+					<listitem>javax.websocket</listitem>
 				</itemizedlist>
 				The default behavior can be changed with @product.name@ property <literal>org.eclipse.gemini.web.tomcat.scanner.skip.bundles</literal>.
 				The syntax is <literal>org.eclipse.gemini.web.tomcat.scanner.skip.bundles=&lt;bundle-symbolic-name&gt;,&lt;bundle-symbolic-name&gt;,...</literal>
@@ -404,7 +406,7 @@
 					</row>
 					<row>
 						<entry>
-							<literal>java6-server.profile</literal>
+							<literal>java7-server.profile</literal>
 						</entry>
 						<entry>Configures the <link linkend="configuring-framework-profile">OSGi framework profile</link>.</entry>
 					</row>
@@ -441,7 +443,7 @@
 							</entry>
 							<entry>
 								Specifies the profile to use using a <literal>file:</literal> URI with default value
-								<literal>file:configuration/java6-server.profile</literal>.
+								<literal>file:configuration/java7-server.profile</literal>.
 							</entry>
 						</row>
 						<row>
@@ -462,7 +464,7 @@
 		<section id="configuring-framework-profile">
 			<title>Configuring OSGi Framework Profile</title>
 			<para>
-				You specify the framework profile in the <literal>$GW_HOME/configuration/java6-server.profile</literal> file. 
+				You specify the framework profile in the <literal>$GW_HOME/configuration/java7-server.profile</literal> file.
 				The properties relevant to users are described in the following table.
 			</para>
 			<para>
diff --git a/org.eclipse.gemini.web.documentation/user-guide/src/gemini-web-user-guide.xml b/org.eclipse.gemini.web.documentation/user-guide/src/gemini-web-user-guide.xml
index 7348032..db77536 100755
--- a/org.eclipse.gemini.web.documentation/user-guide/src/gemini-web-user-guide.xml
+++ b/org.eclipse.gemini.web.documentation/user-guide/src/gemini-web-user-guide.xml
@@ -8,7 +8,7 @@
 		<releaseinfo>@bundle.version@</releaseinfo>
 		<legalnotice>
 			<para>
-				Copyright &copy; 2009, 2014 VMware Inc. and others
+				Copyright &copy; 2009, 2015 VMware Inc. and others
 			</para>
 			<para>
 				Contributors:
diff --git a/org.eclipse.gemini.web.documentation/user-guide/src/installing.xml b/org.eclipse.gemini.web.documentation/user-guide/src/installing.xml
index 69a80e1..8d1ae80 100755
--- a/org.eclipse.gemini.web.documentation/user-guide/src/installing.xml
+++ b/org.eclipse.gemini.web.documentation/user-guide/src/installing.xml
@@ -5,7 +5,7 @@
 	<section id="installation-prereqs">
 		<title>Prerequisites</title>
 		<para>
-			The @product.name@, or @short.product.name@ for short, requires Java SE 6 or later to be installed. Java is available from
+			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>
@@ -14,8 +14,22 @@
 		<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-3.8.1-201209141800/download.php?dropFile=org.eclipse.osgi_3.8.1.v20120830-144521.jar">org.eclipse.osgi_3.8.1.v20120830-144521.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 section. 
+					<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>
@@ -27,14 +41,14 @@
 			<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 2.2.0.RELEASE is available in <ulink url="http://wiki.eclipse.org/images/0/03/Config.ini.2.2.0.zip">config.ini.zip</ulink>. 
+					Example file which works with 3.0.0.M01 is available in <ulink url="http://wiki.eclipse.org/images/0/03/Config.ini.2.2.0.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.8.1.v20120830-144521.jar -console]]></programlisting></para>
+					<programlisting language="xml"><![CDATA[java -jar org.eclipse.osgi_3.10.1.v20140909-1633.jar -console]]></programlisting></para>
 			</listitem>
 			<listitem>
 				<para>
