diff --git a/.gitignore b/.gitignore
index 04a4208..4c88f6c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -14,4 +14,5 @@
 .settings
 bin
 build
+.idea/
 
diff --git a/.gitmodules b/.gitmodules
deleted file mode 100644
index 1f9ea18..0000000
--- a/.gitmodules
+++ /dev/null
@@ -1,3 +0,0 @@
-[submodule "virgo-build"]
-	path = virgo-build
-	url = git://git.eclipse.org/gitroot/virgo/org.eclipse.virgo.virgo-build.git
diff --git a/build-snaps/.ant-targets-build.xml b/build-snaps/.ant-targets-build.xml
deleted file mode 100644
index 916f1ed..0000000
--- a/build-snaps/.ant-targets-build.xml
+++ /dev/null
@@ -1,22 +0,0 @@
-build-sample-app
-build-test-apps
-check-proxy
-clean
-clean-integration
-clean-ivy
-clover
-diagnostics
-findbugs
-jar
-javadoc-all
-javadoc-api
-osgi-validate
-p2.extract-publisher
-package-multi-bundle.package
-publish
-publish-ivy
-publish-maven
-quality-multi-bundle.test
-report
-resolve
-set-hudson-proxy
diff --git a/build-snaps/build.xml b/build-snaps/build.xml
deleted file mode 100644
index e2250a5..0000000
--- a/build-snaps/build.xml
+++ /dev/null
@@ -1,70 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project name="build-snaps" xmlns:ivy="antlib:org.apache.ivy.ant">
-
-	<path id="unit.test.bundles">
-		<pathelement location="../org.eclipse.virgo.snaps.api"/>
-		<pathelement location="../org.eclipse.virgo.snaps.core"/>
-		<pathelement location="../org.eclipse.virgo.snaps"/>
-	</path>
-
-	<path id="bundles">
-		<path refid="unit.test.bundles" />
-		<pathelement location="../org.eclipse.virgo.snaps.test"/>
-	</path>
-
-	<path id="doc.bundles">
-		<pathelement location="../snaps-guide"/>
-	</path>
-
-	<property file="${basedir}/../build.properties"/>
-	<property file="${basedir}/../build.versions"/>
-	<import file="${basedir}/package-top-level.xml" />
-	<import file="${basedir}/../virgo-build/multi-bundle/default.xml"/>
-
-	<target name="precommit" depends="clean, clean-integration, test, findbugs, clover"/>
-
-    <target name="publish-build">
-         <antcall target="publish-package-build">
-            <param name="package.file" value="${package.output.file}"/>
-        </antcall>
-    </target>
-    
-    <target name="publish-download">
-         <antcall target="publish-package-download">
-            <param name="package.file" value="${package.output.file}"/>
-        </antcall>
-    </target>
-    
-	<target name="test" depends="build-test-apps">
-		<ant target="quality-multi-bundle.test" />
-	</target>
-
-	<path id="test.apps.bundles">
-		<pathelement location="../test-apps/simple-host"/>
-		<pathelement location="../test-apps/simple-snap"/>
-		<pathelement location="../test-apps/spring-snap"/>
-		<pathelement location="../test-apps/taglib-host"/>
-		<pathelement location="../test-apps/taglib-snap-one"/>
-		<pathelement location="../test-apps/taglib-snap-two"/>
-	</path>
-
-	<target name="build-test-apps" description="Build all of the test applications">
-		<delete dir="${basedir}/../org.eclipse.virgo.snaps.test/src/test/apps" />
-		<mkdir dir="${basedir}/../org.eclipse.virgo.snaps.test/src/test/apps" />
-		<all-bundles target="clean" buildpathRef="test.apps.bundles"></all-bundles>
-		<all-bundles target="jar" buildpathRef="test.apps.bundles"></all-bundles>
-	</target>
-
-	<path id="sample.app.bundles">
-		<pathelement location="../sample/org.eclipse.virgo.snaps.sample.animal"/>
-		<pathelement location="../sample/org.eclipse.virgo.snaps.sample.blue"/>
-		<pathelement location="../sample/org.eclipse.virgo.snaps.sample.cat"/>
-		<pathelement location="../sample/org.eclipse.virgo.snaps.sample.dog"/>
-	</path>
-
-	<target name="build-sample-app" description="Build all of the sample application bundles">
-		<all-bundles target="clean" buildpathRef="sample.app.bundles"></all-bundles>
-		<all-bundles target="jar" buildpathRef="sample.app.bundles"></all-bundles>
-	</target>
-
-</project>
diff --git a/build-snaps/ivy.xml b/build-snaps/ivy.xml
deleted file mode 100644
index aaaab6f..0000000
--- a/build-snaps/ivy.xml
+++ /dev/null
@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<?xml-stylesheet type="text/xsl" href="http://ivyrep.jayasoft.org/ivy-doc.xsl"?>
-<ivy-module
-		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-		xsi:noNamespaceSchemaLocation="http://incubator.apache.org/ivy/schemas/ivy.xsd"
-		version="1.3">
-
-	<info organisation="org.eclipse.virgo.snaps" module="${ant.project.name}"/>
-
-	<configurations>
-		<include file="${virgo.build.dir}/common/default-ivy-configurations.xml"/>
-	</configurations>
-
-	<publications>
-		<artifact name="subsystem" type="xml" ext="xml"/>
-	</publications>
-
-	<dependencies>
-		<dependency org="org.eclipse.virgo.snaps" name="org.eclipse.virgo.snaps" rev="latest.integration"/>
-		<dependency org="org.eclipse.virgo.snaps" name="org.eclipse.virgo.snaps.core" rev="latest.integration"/>
-		<dependency org="org.eclipse.virgo.snaps" name="org.eclipse.virgo.snaps.api" rev="latest.integration"/>
-	</dependencies>
-
-</ivy-module>
diff --git a/build-snaps/package-bundle.xml b/build-snaps/package-bundle.xml
deleted file mode 100644
index ab94073..0000000
--- a/build-snaps/package-bundle.xml
+++ /dev/null
@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project name="package-bundle">
-
-	<target name="package" depends="ivy.init">
-		<dist-jar/>
-		<src-jar/>
-	</target>
-
-</project>
diff --git a/build-snaps/package-sample.xml b/build-snaps/package-sample.xml
deleted file mode 100644
index 25cebe2..0000000
--- a/build-snaps/package-sample.xml
+++ /dev/null
@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project name="package-sample">
-
-	<target name="package" depends="ivy.init">
-		<src-jar/>
-
-		<property name="subsystem.dir" value="${package.output.dir}/sample"/>
-		<mkdir dir="${subsystem.dir}"/>
-		<dist-jar output.dir="${subsystem.dir}"/>
-	</target>
-
-</project>
diff --git a/build-snaps/package-top-level.xml b/build-snaps/package-top-level.xml
deleted file mode 100644
index 4a7376c..0000000
--- a/build-snaps/package-top-level.xml
+++ /dev/null
@@ -1,41 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project name="package-top-level">
-
-	<target name="package">
-		<delete dir="${package.output.dir}" quiet="true"/>
-		<mkdir dir="${package.output.dir}"/>
-		<delete file="${package.output.file}" quiet="true"/>
-		<mkdir dir="${artifacts.dir}"/>
-
-		<all-bundles target="package">
-			<property name="package.output.dir" value="${package.output.dir}"/>
-		</all-bundles>
-
-		<all-bundles target="clean" buildpathRef="doc.bundles" />
-		<all-bundles target="doc-html" buildpathRef="doc.bundles">
-			<property name="docbook.output.dir" value="${package.docs.dir}"/>
-		</all-bundles>
-
-		<all-bundles target="clean" buildpathRef="sample.app.bundles" />
-		<all-bundles target="jar" buildpathRef="sample.app.bundles" />
-		<all-bundles target="package" buildpathRef="sample.app.bundles">
-			<property name="package.output.dir" value="${package.output.dir}"/>
-		</all-bundles>
-
-		<copy todir="${package.output.dir}" failonerror="false">
-			<fileset dir="${basedir}/resources"/>
-		</copy>
-
-		<ant target="javadoc-api" inheritAll="false">
-			<property name="target.dir" value="${package.docs.dir}"/>
-		</ant>
-
-		<replaceregexp match="build.stamp.*\n" replace="" flags="g" file="${package.output.dir}/projects/build.properties"/>
-		<replaceregexp match="release.type=.*" replace="release.type=integration" flags="g" file="${package.output.dir}/projects/build.properties"/>
-
-		<zip destfile="${package.output.file}">
-			<zipfileset dir="${package.dir}"/>
-		</zip>
-	</target>
-
-</project>
diff --git a/build.gradle b/build.gradle
index 9452db7..26d2bae 100644
--- a/build.gradle
+++ b/build.gradle
@@ -1,11 +1,11 @@
 buildscript {
     repositories {
-        mavenLocal()
-        maven {
-            url "https://plugins.gradle.org/m2/"
-        }
+        mavenCentral()
+        maven { url 'http://build.eclipse.org/rt/virgo/gradle/bundles/' }
+        maven { url 'https://plugins.gradle.org/m2/' }
         dependencies {
-            classpath "gradle.plugin.org.eclipse.virgo.bundlor:bundlor-plugin:0.2"
+            classpath "org.eclipse.virgo.bundlor:org.eclipse.virgo.bundlor.gradle.plugin:${bundlorVersion}"
+            classpath "org.asciidoctor:asciidoctor-gradle-plugin:${asciidoctorVersion}"
         }
     }
 }
@@ -80,10 +80,15 @@
 		ivy {
 			url "http://build.eclipse.org/rt/virgo/ivy/bundles/release/"
 			layout "pattern", { artifact "[organisation]/[module]/[revision]/[artifact]-[revision].[ext]" }
-		}        
+		}
+        ivy {
+            url "http://build.eclipse.org/rt/virgo/ivy/bundles/milestone"
+            layout "pattern", { artifact "[organisation]/[module]/[revision]/[artifact]-[revision].[ext]" }
+        }
         maven{
             url "http://build.eclipse.org/rt/virgo/gradle/bundles/"
         }
+
 	}
     configurations {
     	ecj {}
@@ -92,13 +97,13 @@
 		}
 	}
 	// this is necessary because Gemini Web contains a dependency with wrong groupId/version combination 
-	configurations.all {
+	/*configurations.all {
 		resolutionStrategy {
 			dependencySubstitution {
 				substitute module('javax.servlet:javax.servlet:3.0.0.v201103241009') with module('org.eclipse.virgo.mirrored:javax.servlet:3.0.0.v201103241009')  
 			}
 		}
-	}
+	}*/
     jar {
     	// add SUA to archive
         from "$rootDir/build-bundlor/resources/about/notice.html"
diff --git a/build.versions b/build.versions
index e36e50b..61bae2e 100644
--- a/build.versions
+++ b/build.versions
@@ -42,3 +42,4 @@
 org.eclipse.virgo.medic=3.7.0.D-20140919123043
 org.eclipse.virgo.repository=3.7.0.D-20140919123728
 org.eclipse.gemini.blueprint=2.0.0.M02
+
diff --git a/gradle.properties b/gradle.properties
index 1b94dac..1c322a4 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -2,24 +2,23 @@
 version = 3.7.0
 description = 'Virgo Snaps allows you to construct a web application from multiple OSGi bundles, each of which serves up content for a distinct sub-portion of your application's URL space.'
 
+# Versions of buildscript dependencies
+bundlorVersion = 1.1.3.M01
+asciidoctorVersion = 1.5.3
+
 # Eclipse Java Compiler Version
-ecjVersion = 4.5.1
+ecjVersion = 4.6.1
 
 # Versions of runtime dependencies
-
-# current 3.7.0.M04 Virgo build includes servlet spec 3.1, although Gemini Web 2.2.7 does not support it
-#javaxServletVersion = 3.1.0.v201410161800
-# therefore we are using the same servlet spec version as Gemini Web 2.2.7 until we can upgrade to Gemini Web 3.0.0
-javaxServletVersion = 3.0.0.v201103241009
-
-javaxServletJspVersion = 2.2.0.v201112011158
+javaxServletVersion = 3.1.0.20170128
+javaxServletJspVersion = 2.3.0.20170128
 eclipseOsgiVersion = 3.8.1.v20120830-144521
-eclipseGeminiWebVersion = 2.2.7.RELEASE
-eclipseVirgoVersion = 3.7.0.D-20161102123413
-slf4jVersion = 1.7.13
-apacheCatalina = 7.0.61
+eclipseGeminiWebVersion = 3.0.0.RC6
+eclipseVirgoVersion = 3.7.0.D-20170201213529
+slf4jVersion = 1.7.22
+apacheCatalinaVersion = 8.5.11
 
 # Versions of test dependencies
 junitVersion = 4.7
 easymockVersion = 2.3
-springframeworkVersion = 4.2.4.RELEASE
+springframeworkVersion = 4.2.9.RELEASE
diff --git a/java6-server.profile b/java6-server.profile
deleted file mode 100644
index 670c0cb..0000000
--- a/java6-server.profile
+++ /dev/null
@@ -1,212 +0,0 @@
-org.osgi.framework.system.packages = \
- javax.accessibility,\
- javax.activation,\
- javax.activation;version="1.1.0",\
- javax.activity,\
- javax.annotation,\
- javax.annotation;version="1.0.0",\
- javax.annotation.processing,\
- javax.crypto,\
- javax.crypto.interfaces,\
- javax.crypto.spec,\
- javax.imageio,\
- javax.imageio.event,\
- javax.imageio.metadata,\
- javax.imageio.plugins.bmp,\
- javax.imageio.plugins.jpeg,\
- javax.imageio.spi,\
- javax.imageio.stream,\
- javax.jws,\
- javax.jws;version="2.0",\
- javax.jws.soap,\
- javax.jws.soap;version="2.0",\
- javax.lang.model,\
- javax.lang.model.element,\
- javax.lang.model.type,\
- javax.lang.model.util,\
- javax.management,\
- javax.management.loading,\
- javax.management.modelmbean,\
- javax.management.monitor,\
- javax.management.openmbean,\
- javax.management.relation,\
- javax.management.remote,\
- javax.management.remote.rmi,\
- javax.management.timer,\
- javax.naming,\
- javax.naming.directory,\
- javax.naming.event,\
- javax.naming.ldap,\
- javax.naming.spi,\
- javax.net,\
- javax.net.ssl,\
- javax.print,\
- javax.print.attribute,\
- javax.print.attribute.standard,\
- javax.print.event,\
- javax.rmi,\
- javax.rmi.CORBA,\
- javax.rmi.ssl,\
- javax.script,\
- javax.script;version="1.1",\
- javax.security.auth,\
- javax.security.auth.callback,\
- javax.security.auth.kerberos,\
- javax.security.auth.login,\
- javax.security.auth.spi,\
- javax.security.auth.x500,\
- javax.security.cert,\
- javax.security.sasl,\
- javax.sound.midi,\
- javax.sound.midi.spi,\
- javax.sound.sampled,\
- javax.sound.sampled.spi,\
- javax.sql,\
- javax.sql.rowset,\
- javax.sql.rowset.serial,\
- javax.sql.rowset.spi,\
- javax.swing,\
- javax.swing.border,\
- javax.swing.colorchooser,\
- javax.swing.event,\
- javax.swing.filechooser,\
- javax.swing.plaf,\
- javax.swing.plaf.basic,\
- javax.swing.plaf.metal,\
- javax.swing.plaf.multi,\
- javax.swing.plaf.synth,\
- javax.swing.table,\
- javax.swing.text,\
- javax.swing.text.html,\
- javax.swing.text.html.parser,\
- javax.swing.text.rtf,\
- javax.swing.tree,\
- javax.swing.undo,\
- javax.tools,\
- javax.transaction,\
- javax.transaction;version="1.0.1",\
- javax.transaction;version="1.1.0",\
- javax.transaction.xa,\
- javax.transaction.xa;version="1.0.1",\
- javax.transaction.xa;version="1.1.0",\
- javax.xml,\
- javax.xml;version="1.0.1",\
- javax.xml.bind,\
- javax.xml.bind;version="2.0",\
- javax.xml.bind.annotation,\
- javax.xml.bind.annotation;version="2.0",\
- javax.xml.bind.annotation.adapters,\
- javax.xml.bind.annotation.adapters;version="2.0",\
- javax.xml.bind.attachment,\
- javax.xml.bind.attachment;version="2.0",\
- javax.xml.bind.helpers,\
- javax.xml.bind.helpers;version="2.0",\
- javax.xml.bind.util,\
- javax.xml.bind.util;version="2.0",\
- javax.xml.crypto,\
- javax.xml.crypto;version="1.0",\
- javax.xml.crypto.dom,\
- javax.xml.crypto.dom;version="1.0",\
- javax.xml.crypto.dsig,\
- javax.xml.crypto.dsig;version="1.0",\
- javax.xml.crypto.dsig.dom,\
- javax.xml.crypto.dsig.dom;version="1.0",\
- javax.xml.crypto.dsig.keyinfo,\
- javax.xml.crypto.dsig.keyinfo;version="1.0",\
- javax.xml.crypto.dsig.spec,\
- javax.xml.crypto.dsig.spec;version="1.0",\
- javax.xml.datatype,\
- javax.xml.namespace,\
- javax.xml.parsers,\
- javax.xml.soap,\
- javax.xml.soap;version="1.3.0",\
- javax.xml.stream,\
- javax.xml.stream;version="1.0.1",\
- javax.xml.stream.events,\
- javax.xml.stream.events;version="1.0.1",\
- javax.xml.stream.util,\
- javax.xml.stream.util;version="1.0.1",\
- javax.xml.transform,\
- javax.xml.transform.dom,\
- javax.xml.transform.sax,\
- javax.xml.transform.stax,\
- javax.xml.transform.stream,\
- javax.xml.validation,\
- javax.xml.ws,\
- javax.xml.ws;version="2.1.1",\
- javax.xml.ws.handler,\
- javax.xml.ws.handler;version="2.1.1",\
- javax.xml.ws.handler.soap,\
- javax.xml.ws.handler.soap;version="2.1.1",\
- javax.xml.ws.http,\
- javax.xml.ws.http;version="2.1.1",\
- javax.xml.ws.soap,\
- javax.xml.ws.soap;version="2.1.1",\
- javax.xml.ws.spi,\
- javax.xml.ws.spi;version="2.1.1",\
- javax.xml.xpath,\
- org.eclipse.virgo.kernel.equinox.extensions;version="3.7.0",\
- org.eclipse.virgo.kernel.equinox.extensions.hooks;version="3.7.0",\
- org.eclipse.virgo.test.launcher;version="3.7.0",\
- org.eclipse.virgo.util.launcher.parser;version="3.7.0",\
- org.ietf.jgss,\
- org.omg.CORBA,\
- org.omg.CORBA_2_3,\
- org.omg.CORBA_2_3.portable,\
- org.omg.CORBA.DynAnyPackage,\
- org.omg.CORBA.ORBPackage,\
- org.omg.CORBA.portable,\
- org.omg.CORBA.TypeCodePackage,\
- org.omg.CosNaming,\
- org.omg.CosNaming.NamingContextExtPackage,\
- org.omg.CosNaming.NamingContextPackage,\
- org.omg.Dynamic,\
- org.omg.DynamicAny,\
- org.omg.DynamicAny.DynAnyFactoryPackage,\
- org.omg.DynamicAny.DynAnyPackage,\
- org.omg.IOP,\
- org.omg.IOP.CodecFactoryPackage,\
- org.omg.IOP.CodecPackage,\
- org.omg.Messaging,\
- org.omg.PortableInterceptor,\
- org.omg.PortableInterceptor.ORBInitInfoPackage,\
- org.omg.PortableServer,\
- org.omg.PortableServer.CurrentPackage,\
- org.omg.PortableServer.POAManagerPackage,\
- org.omg.PortableServer.POAPackage,\
- org.omg.PortableServer.portable,\
- org.omg.PortableServer.ServantLocatorPackage,\
- org.omg.SendingContext,\
- org.omg.stub.java.rmi,\
- org.w3c.dom,\
- org.w3c.dom.bootstrap,\
- org.w3c.dom.css,\
- org.w3c.dom.events,\
- org.w3c.dom.html,\
- org.w3c.dom.ls,\
- org.w3c.dom.ranges,\
- org.w3c.dom.stylesheets,\
- org.w3c.dom.traversal,\
- org.w3c.dom.views ,\
- org.xml.sax,\
- org.xml.sax.ext,\
- org.xml.sax.helpers
-org.osgi.framework.bootdelegation = \
- com_cenqua_clover,\
- com.cenqua.*,\
- com.yourkit.*,\
- org.eclipse.virgo.nano.authentication,\
- com.sun.*,\
- javax.xml.*,\
- org.apache.xerces.jaxp.*,\
- org.w3c.*,\
- org.xml.*,\
- sun.*
-org.osgi.framework.executionenvironment = \
- OSGi/Minimum-1.0,\
- OSGi/Minimum-1.1,\
- J2SE-1.3,\
- J2SE-1.4,\
- J2SE-1.5,\
- JavaSE-1.6
-osgi.java.profile.name = SpringSource-dm-Server-Java6
diff --git a/org.eclipse.virgo.snaps.api/build.xml b/org.eclipse.virgo.snaps.api/build.xml
deleted file mode 100644
index fc61a1c..0000000
--- a/org.eclipse.virgo.snaps.api/build.xml
+++ /dev/null
@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project name="org.eclipse.virgo.snaps.api">
-	
-	<property file="${basedir}/../build.properties"/>
-	<property file="${basedir}/../build.versions"/>
-	<import file="${basedir}/../build-snaps/package-bundle.xml"/>
-	<import file="${basedir}/../virgo-build/standard/default.xml"/>
-
-</project>
diff --git a/org.eclipse.virgo.snaps.api/ivy.xml b/org.eclipse.virgo.snaps.api/ivy.xml
deleted file mode 100644
index a10523a..0000000
--- a/org.eclipse.virgo.snaps.api/ivy.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?> 
-<?xml-stylesheet type="text/xsl" href="http://ivyrep.jayasoft.org/ivy-doc.xsl"?> 
-<ivy-module xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://incubator.apache.org/ivy/schemas/ivy.xsd" version="1.3">
-    <info organisation="${project.organisation}" module="${ant.project.name}"/>
-
-    <configurations>
-        <include file="${virgo.build.dir}/common/default-ivy-configurations.xml"/>
-    </configurations>
-
-    <publications>
-        <artifact name="${ant.project.name}"/>
-        <artifact name="${ant.project.name}-sources" ext="jar" type="src"/>
-    </publications>
-
-    <dependencies>
-        <dependency org="org.eclipse.virgo.mirrored" name="org.eclipse.osgi" rev="${org.eclipse.osgi}" conf="compile->compile"/>
-        <dependency org="org.eclipse.virgo.mirrored" name="javax.servlet" rev="${javax.servlet}" conf="compile->runtime"/>
-        <dependency org="org.eclipse.virgo.mirrored" name="javax.servlet.jsp" rev="${javax.servlet.jsp}" conf="compile->compile"/>
-        <dependency org="org.eclipse.gemini" name="org.eclipse.gemini.web.core" rev="${org.eclipse.gemini.web}" conf="compile->compile" />
-        <dependency org="org.junit" name="com.springsource.org.junit" rev="${org.junit}" conf="test->runtime"/>
-        <dependency org="org.springframework" name="org.springframework.test" rev="${org.springframework}" conf="test->runtime"/>
-        <dependency org="org.springframework" name="org.springframework.core" rev="${org.springframework}" conf="test->runtime"/>
-        <dependency org="org.easymock" name="com.springsource.org.easymock" rev="${org.easymock}" conf="test->runtime"/>
-        <dependency org="org.eclipse.virgo.test" name="org.eclipse.virgo.test.stubs" rev="${org.eclipse.virgo.test}" conf="test->runtime"/>
-    </dependencies>
-
-</ivy-module>
diff --git a/org.eclipse.virgo.snaps.core/build.xml b/org.eclipse.virgo.snaps.core/build.xml
deleted file mode 100644
index 1a02c5d..0000000
--- a/org.eclipse.virgo.snaps.core/build.xml
+++ /dev/null
@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project name="org.eclipse.virgo.snaps.core">
-
-	<property file="${basedir}/../build.properties"/>
-	<property file="${basedir}/../build.versions"/>
-	<import file="${basedir}/../build-snaps/package-bundle.xml"/>
-	<import file="${basedir}/../virgo-build/standard/default.xml"/>
-
-</project>
diff --git a/org.eclipse.virgo.snaps.core/ivy.xml b/org.eclipse.virgo.snaps.core/ivy.xml
deleted file mode 100644
index a370e77..0000000
--- a/org.eclipse.virgo.snaps.core/ivy.xml
+++ /dev/null
@@ -1,43 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<?xml-stylesheet type="text/xsl" href="http://ivyrep.jayasoft.org/ivy-doc.xsl"?>
-<ivy-module xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://incubator.apache.org/ivy/schemas/ivy.xsd" version="1.3">
-	<info organisation="${project.organisation}" module="${ant.project.name}"/>
-	
-	<configurations>
-		<include file="${virgo.build.dir}/common/default-ivy-configurations.xml"/>
-	</configurations>
-	
-	<publications>
-		<artifact name="${ant.project.name}"/>
-		<artifact name="${ant.project.name}-sources" type="src" ext="jar"/>
-	</publications>
-	
-	<dependencies>
-		<dependency org="org.eclipse.virgo.mirrored" name="org.eclipse.osgi" rev="${org.eclipse.osgi}" conf="compile->compile"/>
-		<dependency org="org.eclipse.virgo.mirrored" name="javax.servlet" rev="${javax.servlet}" conf="compile->runtime"/>
-		<dependency org="org.eclipse.virgo.snaps" name="org.eclipse.virgo.snaps.api" rev="latest.integration" conf="compile->compile"/>
-        <dependency org="org.eclipse.virgo.nano" name="org.eclipse.virgo.nano.deployer.api" rev="${org.eclipse.virgo.nano}" conf="compile->compile"/>
-		<dependency org="org.eclipse.virgo.kernel" name="org.eclipse.virgo.kernel.deployer" rev="${org.eclipse.virgo.kernel}" conf="compile->compile"/>
-		<dependency org="org.eclipse.gemini" name="org.eclipse.gemini.web.core" rev="${org.eclipse.gemini.web}" conf="compile->compile"/>
-		<dependency org="org.eclipse.gemini" name="org.eclipse.gemini.web.tomcat" rev="${org.eclipse.gemini.web}" conf="compile->compile"/>
-		<dependency org="org.eclipse.virgo.util" name="org.eclipse.virgo.util.common" rev="${org.eclipse.virgo.util}" conf="compile->runtime"/>
-		<dependency org="org.eclipse.virgo.util" name="org.eclipse.virgo.util.osgi.manifest" rev="${org.eclipse.virgo.util}" conf="compile->compile"/>
-		<dependency org="org.eclipse.virgo.util" name="org.eclipse.virgo.util.osgi" rev="${org.eclipse.virgo.util}" conf="compile->compile"/>
-		<dependency org="org.eclipse.virgo.mirrored" name="org.slf4j.api" rev="${org.slf4j.api}" conf="compile->runtime"/>
-		<dependency org="org.eclipse.virgo.mirrored" name="org.slf4j.nop" rev="${org.slf4j.nop}" conf="test->runtime"/>
-		<dependency org="org.eclipse.virgo.medic" name="org.eclipse.virgo.medic" rev="${org.eclipse.virgo.medic}" conf="compile->runtime"/>
-		<dependency org="org.eclipse.virgo.mirrored" name="org.apache.catalina" rev="${org.apache.catalina}" conf="compile->runtime"/>
-		<dependency org="org.eclipse.virgo.medic" name="org.eclipse.virgo.medic.core" rev="${org.eclipse.virgo.medic}" conf="test->runtime"/>
-		<dependency org="org.eclipse.virgo.medic" name="org.eclipse.virgo.medic.test" rev="${org.eclipse.virgo.medic}" conf="test->runtime"/>
-		<dependency org="org.springframework" name="org.springframework.test" rev="${org.springframework}" conf="test->compile"/>
-		<dependency org="org.springframework" name="org.springframework.core" rev="${org.springframework}" conf="test->compile"/>
-		<dependency org="org.junit" name="com.springsource.org.junit" rev="${org.junit}" conf="test->runtime"/>
-		<dependency org="org.easymock" name="com.springsource.org.easymock" rev="${org.easymock}" conf="test->runtime"/>
-		<dependency org="org.eclipse.virgo.test" name="org.eclipse.virgo.test.stubs" rev="${org.eclipse.virgo.test}" conf="test->runtime"/>
-		
-		<!-- Override util from Gemini Web -->
-		<override org="org.eclipse.virgo.util" rev="${org.eclipse.virgo.util}"/>
-		
-	</dependencies>
-	
-</ivy-module>
diff --git a/org.eclipse.virgo.snaps.core/src/main/java/org/eclipse/virgo/snaps/core/internal/webapp/SnapServletContext.java b/org.eclipse.virgo.snaps.core/src/main/java/org/eclipse/virgo/snaps/core/internal/webapp/SnapServletContext.java
index 82ab2c4..5cececa 100644
--- a/org.eclipse.virgo.snaps.core/src/main/java/org/eclipse/virgo/snaps/core/internal/webapp/SnapServletContext.java
+++ b/org.eclipse.virgo.snaps.core/src/main/java/org/eclipse/virgo/snaps/core/internal/webapp/SnapServletContext.java
@@ -36,9 +36,8 @@
 import javax.servlet.descriptor.JspConfigDescriptor;
 
 import org.eclipse.virgo.snaps.core.internal.SnapException;
-import org.osgi.framework.Bundle;
-
 import org.eclipse.virgo.util.common.IterableEnumeration;
+import org.osgi.framework.Bundle;
 
 /**
  * TODO Document SnapServletContext
@@ -52,13 +51,13 @@
 public class SnapServletContext implements ServletContext {
 
     private static final String HOST_PATH_PREFIX = "host:";
-    
+
     private final ServletContext delegate;
-    
+
     private final Bundle snapBundle;
-    
+
     private final String snapContextPath;
-    
+
     private final Map<String, Object> attributes = new ConcurrentHashMap<String, Object>();
 
     public SnapServletContext(ServletContext delegate, Bundle snapBundle, String snapContextPath) {
@@ -66,7 +65,7 @@
         this.snapBundle = snapBundle;
         this.snapContextPath = snapContextPath;
     }
-    
+
     public String getSnapContextPath() {
         return this.snapContextPath;
     }
@@ -81,7 +80,7 @@
         if (attribute == null) {
             attribute = delegate.getAttribute(name);
         }
-        return attribute; 
+        return attribute;
     }
 
     /**
@@ -90,7 +89,7 @@
      */
     public Enumeration<String> getAttributeNames() {
         Set<String> attributeNamesSet = new HashSet<String>(this.attributes.keySet());
-        IterableEnumeration<String> delegateAttributeNames = new IterableEnumeration<String>((Enumeration<String>)delegate.getAttributeNames());        
+        IterableEnumeration<String> delegateAttributeNames = new IterableEnumeration<String>((Enumeration<String>) delegate.getAttributeNames());
         for (String delegateAttributeName : delegateAttributeNames) {
             attributeNamesSet.add(delegateAttributeName);
         }
@@ -194,18 +193,18 @@
      * @see javax.servlet.ServletContext#getResource(java.lang.String)
      */
     public URL getResource(String path) throws MalformedURLException {
-    	boolean hostOnly = false;
+        boolean hostOnly = false;
         if (path.startsWith(HOST_PATH_PREFIX)) {
             path = path.substring(HOST_PATH_PREFIX.length());
             hostOnly = true;
         }
-		if (path == null || !path.startsWith("/")) {
-			throw new MalformedURLException(String.format("'%s' is not a valid resource path", path));
-		}
-        if(hostOnly){
-        	return delegate.getResource(path);
+        if (path == null || !path.startsWith("/")) {
+            throw new MalformedURLException(String.format("'%s' is not a valid resource path", path));
+        }
+        if (hostOnly) {
+            return delegate.getResource(path);
         } else {
-        	URL resource = getLocalResource(path);
+            URL resource = getLocalResource(path);
             if (resource == null) {
                 resource = delegate.getResource(path);
             }
@@ -230,14 +229,14 @@
         if (path.startsWith(HOST_PATH_PREFIX)) {
             path = path.substring(HOST_PATH_PREFIX.length());
         } else {
-	        URL resource = getLocalResource(path);
-	        if (resource != null) {
-	            try {
-	                return resource.openStream();
-	            } catch (IOException e) {
-	                throw new SnapException("Failed to open stream for resource " + resource + " in bundle " + this.snapBundle, e);
-	            }
-	        }
+            URL resource = getLocalResource(path);
+            if (resource != null) {
+                try {
+                    return resource.openStream();
+                } catch (IOException e) {
+                    throw new SnapException("Failed to open stream for resource " + resource + " in bundle " + this.snapBundle, e);
+                }
+            }
         }
         return delegate.getResourceAsStream(path);
     }
@@ -247,21 +246,21 @@
      * @return
      * @see javax.servlet.ServletContext#getResourcePaths(java.lang.String)
      */
-    public Set<String> getResourcePaths(String path) {       
+    public Set<String> getResourcePaths(String path) {
         Enumeration<?> entryPaths = this.snapBundle.getEntryPaths(path);
         if (entryPaths == null) {
             return null;
         } else {
             Set<String> resourcePaths = new HashSet<String>();
             while (entryPaths.hasMoreElements()) {
-                String entryPath = (String)entryPaths.nextElement();
+                String entryPath = (String) entryPaths.nextElement();
                 if (path.startsWith("/") && !entryPath.startsWith("/")) {
                     entryPath = "/" + entryPath;
                 }
-                resourcePaths.add((String)entryPath);
+                resourcePaths.add((String) entryPath);
             }
             return resourcePaths;
-        }                
+        }
     }
 
     /**
@@ -353,133 +352,133 @@
         this.attributes.put(name, object);
     }
 
-	@Override
-	public int getEffectiveMajorVersion() {
-		return this.delegate.getEffectiveMajorVersion();
-	}
+    @Override
+    public int getEffectiveMajorVersion() {
+        return this.delegate.getEffectiveMajorVersion();
+    }
 
-	@Override
-	public int getEffectiveMinorVersion() {
-		return this.delegate.getEffectiveMinorVersion();
-	}
+    @Override
+    public int getEffectiveMinorVersion() {
+        return this.delegate.getEffectiveMinorVersion();
+    }
 
-	@Override
-	public boolean setInitParameter(String name, String value) {
-		return this.delegate.setInitParameter(name, value);
-	}
+    @Override
+    public boolean setInitParameter(String name, String value) {
+        return this.delegate.setInitParameter(name, value);
+    }
 
-	@Override
-	public Dynamic addServlet(String servletName, String className) {
-		return this.delegate.addServlet(servletName, className);
-	}
+    @Override
+    public Dynamic addServlet(String servletName, String className) {
+        return this.delegate.addServlet(servletName, className);
+    }
 
-	@Override
-	public Dynamic addServlet(String servletName, Servlet servlet) {
-		return this.delegate.addServlet(servletName, servlet);
-	}
+    @Override
+    public Dynamic addServlet(String servletName, Servlet servlet) {
+        return this.delegate.addServlet(servletName, servlet);
+    }
 
-	@Override
-	public Dynamic addServlet(String servletName, Class<? extends Servlet> servletClass) {
-		return this.delegate.addServlet(servletName, servletClass);
-	}
+    @Override
+    public Dynamic addServlet(String servletName, Class<? extends Servlet> servletClass) {
+        return this.delegate.addServlet(servletName, servletClass);
+    }
 
-	@Override
-	public <T extends Servlet> T createServlet(Class<T> clazz) throws ServletException {
-		return this.delegate.createServlet(clazz);
-	}
+    @Override
+    public <T extends Servlet> T createServlet(Class<T> clazz) throws ServletException {
+        return this.delegate.createServlet(clazz);
+    }
 
-	@Override
-	public ServletRegistration getServletRegistration(String servletName) {
-		return this.delegate.getServletRegistration(servletName);
-	}
+    @Override
+    public ServletRegistration getServletRegistration(String servletName) {
+        return this.delegate.getServletRegistration(servletName);
+    }
 
-	@Override
-	public Map<String, ? extends ServletRegistration> getServletRegistrations() {
-		return this.delegate.getServletRegistrations();
-	}
+    @Override
+    public Map<String, ? extends ServletRegistration> getServletRegistrations() {
+        return this.delegate.getServletRegistrations();
+    }
 
-	@Override
-	public javax.servlet.FilterRegistration.Dynamic addFilter(String filterName, String className) {
-		return this.delegate.addFilter(filterName, className);
-	}
+    @Override
+    public javax.servlet.FilterRegistration.Dynamic addFilter(String filterName, String className) {
+        return this.delegate.addFilter(filterName, className);
+    }
 
-	@Override
-	public javax.servlet.FilterRegistration.Dynamic addFilter(String filterName, Filter filter) {
-		return this.delegate.addFilter(filterName, filter);
-	}
+    @Override
+    public javax.servlet.FilterRegistration.Dynamic addFilter(String filterName, Filter filter) {
+        return this.delegate.addFilter(filterName, filter);
+    }
 
-	@Override
-	public javax.servlet.FilterRegistration.Dynamic addFilter(String filterName, Class<? extends Filter> filterClass) {
-		return this.delegate.addFilter(filterName, filterClass);
-	}
+    @Override
+    public javax.servlet.FilterRegistration.Dynamic addFilter(String filterName, Class<? extends Filter> filterClass) {
+        return this.delegate.addFilter(filterName, filterClass);
+    }
 
-	@Override
-	public <T extends Filter> T createFilter(Class<T> clazz) throws ServletException {
-		return this.delegate.createFilter(clazz);
-	}
+    @Override
+    public <T extends Filter> T createFilter(Class<T> clazz) throws ServletException {
+        return this.delegate.createFilter(clazz);
+    }
 
-	@Override
-	public FilterRegistration getFilterRegistration(String filterName) {
-		return this.delegate.getFilterRegistration(filterName);
-	}
+    @Override
+    public FilterRegistration getFilterRegistration(String filterName) {
+        return this.delegate.getFilterRegistration(filterName);
+    }
 
-	@Override
-	public Map<String, ? extends FilterRegistration> getFilterRegistrations() {
-		return this.delegate.getFilterRegistrations();
-	}
+    @Override
+    public Map<String, ? extends FilterRegistration> getFilterRegistrations() {
+        return this.delegate.getFilterRegistrations();
+    }
 
-	@Override
-	public SessionCookieConfig getSessionCookieConfig() {
-		return this.delegate.getSessionCookieConfig();
-	}
+    @Override
+    public SessionCookieConfig getSessionCookieConfig() {
+        return this.delegate.getSessionCookieConfig();
+    }
 
-	@Override
-	public void setSessionTrackingModes(Set<SessionTrackingMode> sessionTrackingModes) {
-		this.delegate.setSessionTrackingModes(sessionTrackingModes);
-	}
+    @Override
+    public void setSessionTrackingModes(Set<SessionTrackingMode> sessionTrackingModes) {
+        this.delegate.setSessionTrackingModes(sessionTrackingModes);
+    }
 
-	@Override
-	public Set<SessionTrackingMode> getDefaultSessionTrackingModes() {
-		return this.delegate.getDefaultSessionTrackingModes();
-	}
+    @Override
+    public Set<SessionTrackingMode> getDefaultSessionTrackingModes() {
+        return this.delegate.getDefaultSessionTrackingModes();
+    }
 
-	@Override
-	public Set<SessionTrackingMode> getEffectiveSessionTrackingModes() {
-		return this.delegate.getEffectiveSessionTrackingModes();
-	}
+    @Override
+    public Set<SessionTrackingMode> getEffectiveSessionTrackingModes() {
+        return this.delegate.getEffectiveSessionTrackingModes();
+    }
 
-	@Override
-	public void addListener(String className) {
-		this.delegate.addListener(className);
-	}
+    @Override
+    public void addListener(String className) {
+        this.delegate.addListener(className);
+    }
 
-	@Override
-	public <T extends EventListener> void addListener(T t) {
-		this.delegate.addListener(t);
-	}
+    @Override
+    public <T extends EventListener> void addListener(T t) {
+        this.delegate.addListener(t);
+    }
 
-	@Override
-	public void addListener(Class<? extends EventListener> listenerClass) {
-		this.delegate.addListener(listenerClass);
-	}
+    @Override
+    public void addListener(Class<? extends EventListener> listenerClass) {
+        this.delegate.addListener(listenerClass);
+    }
 
-	@Override
-	public <T extends EventListener> T createListener(Class<T> clazz) throws ServletException {
-		return this.delegate.createListener(clazz);
-	}
+    @Override
+    public <T extends EventListener> T createListener(Class<T> clazz) throws ServletException {
+        return this.delegate.createListener(clazz);
+    }
 
-	@Override
-	public JspConfigDescriptor getJspConfigDescriptor() {
-		return this.delegate.getJspConfigDescriptor();
-	}
+    @Override
+    public JspConfigDescriptor getJspConfigDescriptor() {
+        return this.delegate.getJspConfigDescriptor();
+    }
 
-	@Override
-	public ClassLoader getClassLoader() {
-		return this.delegate.getClassLoader();
-	}
+    @Override
+    public ClassLoader getClassLoader() {
+        return this.delegate.getClassLoader();
+    }
 
-	@Override
-	public void declareRoles(String... roleNames) {
-		this.delegate.declareRoles(roleNames);
-	}
+    @Override
+    public void declareRoles(String... roleNames) {
+        this.delegate.declareRoles(roleNames);
+    }
 }
diff --git a/org.eclipse.virgo.snaps.core/src/main/java/org/eclipse/virgo/snaps/core/internal/webapp/container/HttpServletRequestWrapper.java b/org.eclipse.virgo.snaps.core/src/main/java/org/eclipse/virgo/snaps/core/internal/webapp/container/HttpServletRequestWrapper.java
index d68a2e1..f0c40fc 100644
--- a/org.eclipse.virgo.snaps.core/src/main/java/org/eclipse/virgo/snaps/core/internal/webapp/container/HttpServletRequestWrapper.java
+++ b/org.eclipse.virgo.snaps.core/src/main/java/org/eclipse/virgo/snaps/core/internal/webapp/container/HttpServletRequestWrapper.java
@@ -32,6 +32,7 @@
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import javax.servlet.http.HttpSession;
+import javax.servlet.http.HttpUpgradeHandler;
 import javax.servlet.http.Part;
 
 /**
@@ -582,5 +583,4 @@
 	public Part getPart(String name) throws IOException, ServletException {
 		return this.delegate.getPart(name);
 	}
-
 }
diff --git a/org.eclipse.virgo.snaps.test/build.xml b/org.eclipse.virgo.snaps.test/build.xml
deleted file mode 100644
index eacfbaf..0000000
--- a/org.eclipse.virgo.snaps.test/build.xml
+++ /dev/null
@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project name="org.eclipse.virgo.snaps.test">
-
-	<property file="${basedir}/../build.properties"/>
-	<property file="${basedir}/../build.versions"/>
-	<import file="${basedir}/../virgo-build/standard/default.xml"/>
-
-</project>
diff --git a/org.eclipse.virgo.snaps.test/ivy.xml b/org.eclipse.virgo.snaps.test/ivy.xml
deleted file mode 100644
index 68e199d..0000000
--- a/org.eclipse.virgo.snaps.test/ivy.xml
+++ /dev/null
@@ -1,72 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<?xml-stylesheet type="text/xsl" href="http://ivyrep.jayasoft.org/ivy-doc.xsl"?>
-<ivy-module xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://incubator.apache.org/ivy/schemas/ivy.xsd" version="1.3">
-	<info organisation="${project.organisation}" module="${ant.project.name}"/>
-
-	<configurations>
-		<include file="${virgo.build.dir}/common/default-ivy-configurations.xml"/>
-	</configurations>
-
-	<publications>
-		<artifact name="${ant.project.name}"/>
-		<artifact name="${ant.project.name}-sources" type="src" ext="jar"/>
-	</publications>
-
-	<dependencies>
-		<dependency org="org.eclipse.virgo.util" name="org.eclipse.virgo.util.osgi.manifest" rev="${org.eclipse.virgo.util}" conf="compile->compile"/>
-		<dependency org="org.eclipse.virgo.util" name="org.eclipse.virgo.util.osgi" rev="${org.eclipse.virgo.util}" conf="compile->compile"/>
-		<dependency org="org.eclipse.virgo.snaps" name="org.eclipse.virgo.snaps.api" rev="latest.integration"/>
-		<dependency org="org.eclipse.virgo.snaps" name="org.eclipse.virgo.snaps.core" rev="latest.integration"/>
-		<dependency org="org.eclipse.virgo.kernel" name="org.eclipse.virgo.kernel" rev="${org.eclipse.virgo.kernel}" conf="test->compile"/>
-		<dependency org="org.eclipse.virgo.nano" name="org.eclipse.virgo.nano.core" rev="${org.eclipse.virgo.nano}" conf="test->compile"/>
-		<dependency org="org.eclipse.virgo.nano" name="org.eclipse.virgo.nano.deployer.api" rev="${org.eclipse.virgo.nano}" conf="test->compile"/>
-		<dependency org="org.eclipse.virgo.nano" name="org.eclipse.virgo.nano.deployer.hot" rev="${org.eclipse.virgo.nano}" conf="test->compile"/>
-        <dependency org="org.eclipse.virgo.nano" name="org.eclipse.virgo.nano.management" rev="${org.eclipse.virgo.nano}" conf="test->compile"/>
-		<dependency org="org.eclipse.virgo.web" name="org.eclipse.virgo.web.tomcat.support" rev="${org.eclipse.virgo.web}" conf="test->compile"/>
-		<dependency org="org.eclipse.virgo.web" name="org.eclipse.virgo.web.tomcat" rev="${org.eclipse.virgo.web}" conf="test->runtime"/>
-		<dependency org="org.eclipse.virgo.test" name="org.eclipse.virgo.test.framework" rev="${org.eclipse.virgo.test}" conf="test->runtime"/>
-		<dependency org="org.springframework" name="org.springframework.test" rev="${org.springframework}" conf="test->runtime"/>
-		<dependency org="org.springframework" name="org.springframework.spring-library" rev="${org.springframework}" conf="test->runtime"/>
-		<dependency org="org.springframework" name="org.springframework.aspects" rev="${org.springframework}" conf="test->runtime"/>
-		<dependency org="org.eclipse.virgo.mirrored" name="org.slf4j.jcl" rev="${org.slf4j.jcl}" conf="test->runtime"/>
-		<dependency org="org.eclipse.virgo.mirrored" name="org.slf4j.jul" rev="${org.slf4j.jul}" conf="test->runtime"/>
-		<dependency org="org.eclipse.virgo.medic" name="org.eclipse.virgo.medic" rev="${org.eclipse.virgo.medic}" conf="test->runtime"/>
-		<dependency org="org.eclipse.virgo.medic" name="org.eclipse.virgo.medic.core" rev="${org.eclipse.virgo.medic}" conf="test->runtime"/>
-		<dependency org="org.eclipse.virgo.mirrored" name="javax.mail" rev="${javax.mail}" conf="test->runtime"/>
-		<dependency org="org.eclipse.virgo.mirrored" name="javax.persistence" rev="${javax.persistence}" conf="test->runtime"/>
-		<dependency org="org.eclipse.virgo.mirrored" name="javax.websocket" rev="${javax.websocket}" conf="test->runtime"/>
-		<dependency org="javax.servlet" name="com.springsource.javax.servlet.jsp.jstl" rev="${javax.servlet.jsp.jstl}" conf="test->runtime"/>
-		<dependency org="org.apache.taglibs" name="com.springsource.org.apache.taglibs.standard" rev="${org.apache.taglibs}" conf="test->runtime" />
-		<dependency org="org.eclipse.virgo.mirrored" name="org.eclipse.equinox.event" rev="${org.eclipse.equinox.event}" conf="test->runtime"/>
-		<dependency org="org.eclipse.virgo.mirrored" name="org.eclipse.equinox.util" rev="${org.eclipse.equinox.util}" conf="test->runtime"/>
-		<dependency org="org.eclipse.virgo.mirrored" name="org.eclipse.equinox.ds" rev="${org.eclipse.equinox.ds}" conf="test->runtime"/>
-		<dependency org="org.eclipse.virgo.mirrored" name="org.eclipse.equinox.cm" rev="${org.eclipse.equinox.cm}" conf="test->runtime"/>
-		<dependency org="org.eclipse.virgo.mirrored" name="org.eclipse.equinox.region" rev="${org.eclipse.equinox.region}" conf="test->runtime"/>
-		<dependency org="org.junit" name="com.springsource.org.junit" rev="${org.junit}" conf="test->runtime"/>
-		<dependency org="org.easymock" name="com.springsource.org.easymock" rev="${org.easymock}" conf="test->runtime"/>
-		<dependency org="org.eclipse.virgo.mirrored" name="com.springsource.org.aspectj.weaver" rev="${org.aspectj}" conf="test->runtime"/>
-    	<dependency org="org.eclipse.virgo.medic" name="org.eclipse.virgo.medic.core" rev="${org.eclipse.virgo.medic}" conf="test->runtime"/>
-		<dependency org="org.eclipse.virgo.medic" name="org.eclipse.virgo.medic.logbackcorefragment" rev="${org.eclipse.virgo.medic}" conf="test->runtime"/>
-		<dependency org="org.eclipse.virgo.medic" name="org.eclipse.virgo.medic.logbackclassicfragment" rev="${org.eclipse.virgo.medic}" conf="test->runtime"/>
-		<dependency org="org.eclipse.virgo.mirrored" name="ch.qos.logback.classic" rev="${ch.qos.logback.classic}" conf="test->runtime"/>
-		<dependency org="org.eclipse.virgo.mirrored" name="ch.qos.logback.core" rev="${ch.qos.logback.core}" conf="test->runtime"/>
-		<dependency org="org.eclipse.virgo.mirrored" name="ch.qos.logback.slf4j" rev="${ch.qos.logback.slf4j}" conf="test->runtime"/>
-
-
-		<!-- Prevent Xerces and Xalan from being on the classpath to work around Java bug 6723276 during integration testing -->
-		<exclude org="org.apache.xerces"/>
-		<exclude org="org.apache.xalan"/>
-        <exclude org="javax.servlet" module="javax.servlet"/>
-        <exclude org="org.eclipse.osgi"/>
-		
-		<!--  Prevent Derby coming down until we move to a Spring version when its JDCB bundle's Derby dependency is optional 
-		<exclude org="org.apache.derby"/>-->
-		<override org="org.aspectj" rev="${org.aspectj}" />
-		<override org="org.eclipse.virgo.util" rev="${org.eclipse.virgo.util}"/>
-		<override org="org.eclipse.virgo.repository" rev="${org.eclipse.virgo.repository}"/>
-		<override org="org.eclipse.virgo.kernel" rev="${org.eclipse.virgo.kernel}"/>
-		<override org="org.eclipse.gemini" module="org.eclipse.gemini.web.core" rev="${org.eclipse.gemini.web}"/>
-		<override org="org.eclipse.gemini" module="org.eclipse.gemini.web.tomcat" rev="${org.eclipse.gemini.web}"/>
-	</dependencies>
-
-</ivy-module>
diff --git a/org.eclipse.virgo.snaps/build.xml b/org.eclipse.virgo.snaps/build.xml
deleted file mode 100644
index 8102136..0000000
--- a/org.eclipse.virgo.snaps/build.xml
+++ /dev/null
@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project name="org.eclipse.virgo.snaps">
-
-	<property file="${basedir}/../build.properties"/>
-	<property file="${basedir}/../build.versions"/>
-	<import file="${basedir}/../build-snaps/package-bundle.xml"/>
-	<import file="${basedir}/../virgo-build/resource/default.xml"/>
-
-</project>
diff --git a/org.eclipse.virgo.snaps/ivy.xml b/org.eclipse.virgo.snaps/ivy.xml
deleted file mode 100644
index f4b6fd0..0000000
--- a/org.eclipse.virgo.snaps/ivy.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<?xml-stylesheet type="text/xsl" href="http://ivyrep.jayasoft.org/ivy-doc.xsl"?>
-<ivy-module
-		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-		xsi:noNamespaceSchemaLocation="http://incubator.apache.org/ivy/schemas/ivy.xsd"
-		version="1.3">
-
-	<info organisation="${project.organisation}" module="${ant.project.name}"/>
-
-	<configurations>
-		<include file="${virgo.build.dir}/common/default-ivy-configurations.xml"/>
-	</configurations>
-
-	<publications>
-		<artifact name="org.eclipse.virgo.snaps" type="plan" ext="plan"/>
-	</publications>
-
-	<dependencies>
-		<dependency org="org.eclipse.virgo.kernel" name="org.eclipse.virgo.kernel" rev="${org.eclipse.virgo.kernel}" conf="provided->compile"/>
-        <dependency org="org.eclipse.virgo.nano" name="org.eclipse.virgo.nano.core" rev="${org.eclipse.virgo.nano}" conf="provided->compile"/>
-        <dependency org="org.eclipse.virgo.nano" name="org.eclipse.virgo.nano.deployer.api" rev="${org.eclipse.virgo.nano}" conf="provided->compile"/>
-		<dependency org="org.eclipse.virgo.snaps" name="org.eclipse.virgo.snaps.core" rev="latest.integration"/>
-		<dependency org="org.eclipse.virgo.snaps" name="org.eclipse.virgo.snaps.api" rev="latest.integration"/>
-
-	</dependencies>
-
-</ivy-module>
diff --git a/org.eclipse.virgo.snaps/src/main/resources/org.eclipse.virgo.snaps.plan b/org.eclipse.virgo.snaps/src/main/resources/org.eclipse.virgo.snaps.plan
index 8f1bd76..57ba235 100644
--- a/org.eclipse.virgo.snaps/src/main/resources/org.eclipse.virgo.snaps.plan
+++ b/org.eclipse.virgo.snaps/src/main/resources/org.eclipse.virgo.snaps.plan
@@ -1,4 +1,4 @@
-<plan name="org.eclipse.virgo.snaps" version="3.7.0" scoped="false" atomic="true"
+<plan name="org.eclipse.virgo.snaps" version="3.7.0.RC01" scoped="false" atomic="true"
                 xmlns="http://www.eclipse.org/virgo/schema/plan"
 				xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 				xsi:schemaLocation="http://www.eclipse.org/virgo/schema/plan 
diff --git a/sample/org.eclipse.virgo.snaps.sample.animal/build.xml b/sample/org.eclipse.virgo.snaps.sample.animal/build.xml
deleted file mode 100644
index 7f17a65..0000000
--- a/sample/org.eclipse.virgo.snaps.sample.animal/build.xml
+++ /dev/null
@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project name="org.eclipse.virgo.snaps.sample.animal">
-
-	<property file="${basedir}/../build.properties"/>
-	<property file="${basedir}/../../build.versions"/>
-	<import file="${basedir}/../../build-snaps/package-sample.xml"/>
-	<import file="${basedir}/../../virgo-build/wab/default.xml"/>
-
-</project>
diff --git a/sample/org.eclipse.virgo.snaps.sample.animal/ivy.xml b/sample/org.eclipse.virgo.snaps.sample.animal/ivy.xml
deleted file mode 100644
index 495c3cb..0000000
--- a/sample/org.eclipse.virgo.snaps.sample.animal/ivy.xml
+++ /dev/null
@@ -1,21 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<?xml-stylesheet type="text/xsl" href="http://ivyrep.jayasoft.org/ivy-doc.xsl"?>
-<ivy-module
-        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-        xsi:noNamespaceSchemaLocation="http://incubator.apache.org/ivy/schemas/ivy.xsd"
-        version="1.3">
-
-    <info organisation="com.springsource.snaps.menu-bar" module="${ant.project.name}"/>
-
-    <configurations>
-        <include file="${virgo.build.dir}/common/default-ivy-configurations.xml"/>
-    </configurations>
-
-    <publications>
-        <artifact name="${ant.project.name}" type="wab" ext="jar"/>
-        <artifact name="${ant.project.name}-sources" type="src" ext="jar"/>
-    </publications>
-
-    <dependencies/>
-
-</ivy-module>
diff --git a/sample/org.eclipse.virgo.snaps.sample.blue/build.xml b/sample/org.eclipse.virgo.snaps.sample.blue/build.xml
deleted file mode 100644
index f128e52..0000000
--- a/sample/org.eclipse.virgo.snaps.sample.blue/build.xml
+++ /dev/null
@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project name="org.eclipse.virgo.snaps.sample.blue">
-	
-	<property file="${basedir}/../build.properties"/>
-	<property file="${basedir}/../../build.versions"/>
-	<import file="${basedir}/../../build-snaps/package-sample.xml"/>
-	<import file="${basedir}/../../virgo-build/wab/default.xml"/>
-
-</project>
diff --git a/sample/org.eclipse.virgo.snaps.sample.blue/ivy.xml b/sample/org.eclipse.virgo.snaps.sample.blue/ivy.xml
deleted file mode 100644
index e126443..0000000
--- a/sample/org.eclipse.virgo.snaps.sample.blue/ivy.xml
+++ /dev/null
@@ -1,21 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<?xml-stylesheet type="text/xsl" href="http://ivyrep.jayasoft.org/ivy-doc.xsl"?>
-<ivy-module
-        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-        xsi:noNamespaceSchemaLocation="http://incubator.apache.org/ivy/schemas/ivy.xsd"
-        version="1.3">
-
-    <info organisation="com.springsource.snaps.styling" module="${ant.project.name}"/>
-
-    <configurations>
-        <include file="${virgo.build.dir}/common/default-ivy-configurations.xml"/>
-    </configurations>
-
-    <publications>
-        <artifact name="${ant.project.name}" type="wab" ext="jar"/>
-        <artifact name="${ant.project.name}-sources" type="src" ext="jar"/>
-    </publications>
-
-    <dependencies/>
-
-</ivy-module>
diff --git a/sample/org.eclipse.virgo.snaps.sample.cat/build.xml b/sample/org.eclipse.virgo.snaps.sample.cat/build.xml
deleted file mode 100644
index 1ef211e..0000000
--- a/sample/org.eclipse.virgo.snaps.sample.cat/build.xml
+++ /dev/null
@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project name="org.eclipse.virgo.snaps.sample.cat">
-	
-	<property file="${basedir}/../build.properties"/>
-	<property file="${basedir}/../../build.versions"/>
-	<import file="${basedir}/../../build-snaps/package-sample.xml"/>
-	<import file="${basedir}/../../virgo-build/wab/default.xml"/>
-
-</project>
diff --git a/sample/org.eclipse.virgo.snaps.sample.cat/ivy.xml b/sample/org.eclipse.virgo.snaps.sample.cat/ivy.xml
deleted file mode 100644
index 86b294d..0000000
--- a/sample/org.eclipse.virgo.snaps.sample.cat/ivy.xml
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<?xml-stylesheet type="text/xsl" href="http://ivyrep.jayasoft.org/ivy-doc.xsl"?>
-<ivy-module
-        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-        xsi:noNamespaceSchemaLocation="http://incubator.apache.org/ivy/schemas/ivy.xsd"
-        version="1.3">
-
-    <info organisation="com.springsource.snaps.menu-bar" module="${ant.project.name}"/>
-
-    <configurations>
-        <include file="${virgo.build.dir}/common/default-ivy-configurations.xml"/>
-    </configurations>
-
-    <publications>
-        <artifact name="${ant.project.name}" type="wab" ext="jar"/>
-        <artifact name="${ant.project.name}-sources" type="src" ext="jar"/>
-    </publications>
-
-    <dependencies>    
-		<dependency org="org.eclipse.virgo.mirrored" name="javax.servlet" rev="${javax.servlet}" conf="provided->runtime"/>
-		<dependency org="org.springframework" name="org.springframework.context" rev="${org.springframework}" conf="provided->runtime"/>
-		<dependency org="org.springframework" name="org.springframework.web" rev="${org.springframework}" conf="provided->runtime"/>
-        <dependency org="org.springframework" name="org.springframework.web.servlet" rev="${org.springframework}" conf="provided->runtime"/>
-	</dependencies>
-
-</ivy-module>
diff --git a/sample/org.eclipse.virgo.snaps.sample.dog/build.xml b/sample/org.eclipse.virgo.snaps.sample.dog/build.xml
deleted file mode 100644
index 18533f6..0000000
--- a/sample/org.eclipse.virgo.snaps.sample.dog/build.xml
+++ /dev/null
@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project name="org.eclipse.virgo.snaps.sample.dog">
-	
-	<property file="${basedir}/../build.properties"/>
-	<property file="${basedir}/../../build.versions"/>
-	<import file="${basedir}/../../build-snaps/package-sample.xml"/>
-	<import file="${basedir}/../../virgo-build/wab/default.xml"/>
-
-</project>
diff --git a/sample/org.eclipse.virgo.snaps.sample.dog/ivy.xml b/sample/org.eclipse.virgo.snaps.sample.dog/ivy.xml
deleted file mode 100644
index 495c3cb..0000000
--- a/sample/org.eclipse.virgo.snaps.sample.dog/ivy.xml
+++ /dev/null
@@ -1,21 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<?xml-stylesheet type="text/xsl" href="http://ivyrep.jayasoft.org/ivy-doc.xsl"?>
-<ivy-module
-        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-        xsi:noNamespaceSchemaLocation="http://incubator.apache.org/ivy/schemas/ivy.xsd"
-        version="1.3">
-
-    <info organisation="com.springsource.snaps.menu-bar" module="${ant.project.name}"/>
-
-    <configurations>
-        <include file="${virgo.build.dir}/common/default-ivy-configurations.xml"/>
-    </configurations>
-
-    <publications>
-        <artifact name="${ant.project.name}" type="wab" ext="jar"/>
-        <artifact name="${ant.project.name}-sources" type="src" ext="jar"/>
-    </publications>
-
-    <dependencies/>
-
-</ivy-module>
diff --git a/settings.gradle b/settings.gradle
index e84344f..fb73e22 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -3,3 +3,5 @@
 include ':org.eclipse.virgo.snaps.api'
 include ':org.eclipse.virgo.snaps.core'
 include ':org.eclipse.virgo.snaps.test'
+include ':snaps-guide'
+
diff --git a/snaps-guide/build.gradle b/snaps-guide/build.gradle
new file mode 100644
index 0000000..5d1975b
--- /dev/null
+++ b/snaps-guide/build.gradle
@@ -0,0 +1,3 @@
+description = 'Virgo Snaps documentation'
+
+apply plugin: 'org.asciidoctor.convert'
diff --git a/snaps-guide/build.xml b/snaps-guide/build.xml
deleted file mode 100644
index 7d70637..0000000
--- a/snaps-guide/build.xml
+++ /dev/null
@@ -1,13 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project name="virgo-snaps-guide">
-	
-	<property file="${basedir}/../build.properties"/>
-	<property file="${basedir}/../build.versions"/>
-	<import file="${basedir}/../virgo-build/docbook/default.xml"/>
-
-	<filterset id="docbook.filters">
-		<filter token="bundle.version" value="${bundle.version}"/>
-		<filtersfile file="${basedir}/filters.properties"/>
-	</filterset>
-
-</project>
diff --git a/snaps-guide/filters.properties b/snaps-guide/filters.properties
deleted file mode 100644
index 7a9cf8c..0000000
--- a/snaps-guide/filters.properties
+++ /dev/null
@@ -1,11 +0,0 @@
-project.name=Virgo
-umbrella.product.name=Virgo Server
-tomcat.product.name=Virgo Tomcat Server
-tomcat.product.name.short=VTS
-jetty.product.name=Virgo Jetty Server
-jetty.product.name.short=VTS
-kernel.product.name=Virgo Kernel
-kernel.product.name.short=VK
-snaps.product.name=Virgo Snaps
-snaps.product.name.short=VS
-ebr=SpringSource Enterprise Bundle Repository
\ No newline at end of file
diff --git a/snaps-guide/ivy.xml b/snaps-guide/ivy.xml
deleted file mode 100644
index 2ef6586..0000000
--- a/snaps-guide/ivy.xml
+++ /dev/null
@@ -1,23 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<?xml-stylesheet type="text/xsl" href="http://ivyrep.jayasoft.org/ivy-doc.xsl"?>
-<ivy-module
-		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-		xsi:noNamespaceSchemaLocation="http://incubator.apache.org/ivy/schemas/ivy.xsd"
-		version="1.3">
-
-	<info organisation="org.eclipse.virgo.documentation" module="${ant.project.name}"/>
-
-	<configurations>
-		<include file="${virgo.build.dir}/common/default-ivy-configurations.xml"/>
-   	    <conf name="doc" visibility="public" description="Documentation"/>
-	</configurations>
-
-	<publications>
-		<!-- <artifact name="${ant.project.name}" ext="pdf" type="pdf"/> -->
-		<artifact name="${ant.project.name}" ext="zip" type="zip"/>
-		<artifact name="${ant.project.name}-single" ext="zip" type="zip"/>
-	</publications>
-
-	<dependencies/>
-
-</ivy-module>
diff --git a/snaps-guide/src/docs/asciidoc/further-reading.adoc b/snaps-guide/src/docs/asciidoc/further-reading.adoc
new file mode 100644
index 0000000..ce21f39
--- /dev/null
+++ b/snaps-guide/src/docs/asciidoc/further-reading.adoc
@@ -0,0 +1,17 @@
+[[further-reading]]
+== Further Reading
+
+The User and Programmer Guides provide a lot of information about using
+and developing applications for the Virgo Server.
+
+http://www.eclipse.org/virgo/documentation/[Virgo Documentation
+page]
+
+link:../../virgo-programmer-guide/html/index.html[Virgo Server for Apache Tomcat
+Programmer Guide]
+
+link:../../virgo-user-guide/html/index.html[Virgo Server for Apache Tomcat User
+Guide]
+
+http://www.slideshare.net/cgfrost/eclipsecon2011-virgo-snaps[Slides from
+a presentation at EclipseCon 2011 about Virgo Snaps.]
diff --git a/snaps-guide/images/s2-logo.png b/snaps-guide/src/docs/asciidoc/images/s2-logo.png
similarity index 100%
rename from snaps-guide/images/s2-logo.png
rename to snaps-guide/src/docs/asciidoc/images/s2-logo.png
Binary files differ
diff --git a/snaps-guide/images/sampleApp.png b/snaps-guide/src/docs/asciidoc/images/sampleApp.png
similarity index 100%
rename from snaps-guide/images/sampleApp.png
rename to snaps-guide/src/docs/asciidoc/images/sampleApp.png
Binary files differ
diff --git a/snaps-guide/images/sampleBlue.png b/snaps-guide/src/docs/asciidoc/images/sampleBlue.png
similarity index 100%
rename from snaps-guide/images/sampleBlue.png
rename to snaps-guide/src/docs/asciidoc/images/sampleBlue.png
Binary files differ
diff --git a/snaps-guide/images/sampleCat.png b/snaps-guide/src/docs/asciidoc/images/sampleCat.png
similarity index 100%
rename from snaps-guide/images/sampleCat.png
rename to snaps-guide/src/docs/asciidoc/images/sampleCat.png
Binary files differ
diff --git a/snaps-guide/images/sampleDog.png b/snaps-guide/src/docs/asciidoc/images/sampleDog.png
similarity index 100%
rename from snaps-guide/images/sampleDog.png
rename to snaps-guide/src/docs/asciidoc/images/sampleDog.png
Binary files differ
diff --git a/snaps-guide/images/snapsAndHosts.png b/snaps-guide/src/docs/asciidoc/images/snapsAndHosts.png
similarity index 100%
rename from snaps-guide/images/snapsAndHosts.png
rename to snaps-guide/src/docs/asciidoc/images/snapsAndHosts.png
Binary files differ
diff --git a/snaps-guide/images/snapsZipFile.png b/snaps-guide/src/docs/asciidoc/images/snapsZipFile.png
similarity index 100%
rename from snaps-guide/images/snapsZipFile.png
rename to snaps-guide/src/docs/asciidoc/images/snapsZipFile.png
Binary files differ
diff --git a/snaps-guide/images/virgo-logo-large.png b/snaps-guide/src/docs/asciidoc/images/virgo-logo-large.png
similarity index 100%
rename from snaps-guide/images/virgo-logo-large.png
rename to snaps-guide/src/docs/asciidoc/images/virgo-logo-large.png
Binary files differ
diff --git a/snaps-guide/images/virgo-logo-small.png b/snaps-guide/src/docs/asciidoc/images/virgo-logo-small.png
similarity index 100%
rename from snaps-guide/images/virgo-logo-small.png
rename to snaps-guide/src/docs/asciidoc/images/virgo-logo-small.png
Binary files differ
diff --git a/snaps-guide/src/docs/asciidoc/installing.adoc b/snaps-guide/src/docs/asciidoc/installing.adoc
new file mode 100644
index 0000000..ea2e11f
--- /dev/null
+++ b/snaps-guide/src/docs/asciidoc/installing.adoc
@@ -0,0 +1,92 @@
+[[installation]]
+== Installing Virgo Snaps
+
+[[installation-zip]]
+=== Installing from the Zip Download
+
+VS is distributed as a Zip file. This can be
+downloaded from http://www.eclipse.org/virgo/download/[here].
+
+Once the Zip file is unpacked you will find several things inside,
+including a copy of this documentation in the `docs` folder. The layout
+is shown below.
+
+image::images/snapsZipFile.png[]
+
+Take the bundles and plan in the `dist` folder and place them in either
+the `/repository/usr` or `/repository/ext` folder of your Virgo install.
+Later you need the bundles in the `sample` folder. If you wish to view
+the source for VS or its sample, then these are
+in the `src` folder.
+
+In order to start the Snaps system as a part of your
+Virgo Server for Apache Tomcat, the Snaps plan needs to be referenced from the
+`initialArtifacts` property. This is located in the config file at
+`${SERVER_HOME}/config/org.eclipse.virgo.kernel.userregion.properties`.
+The property should be extended like this.
+
+....
+initialArtifacts=repository:plan/org.eclipse.virgo.kernel.userregion.springdm, 
+        repository:plan/org.eclipse.virgo.web.tomcat, 
+        repository:plan/org.eclipse.virgo.snaps
+....
+
+Now you are ready to check that Snaps is working.
+
+[[installation-post]]
+=== Verifying it's working
+
+The sample application in the Zip file demonstrates all of the features
+of Snaps. You will cover this application in detail later, but for now
+install it to verify that you have a working Snaps install. Start the
+server up and check the output it produces contains the following:
+
+....
+<DE0004I> Starting plan 'org.eclipse.virgo.snaps' version '3.0.0'. 
+<DE0004I> Starting bundle 'org.eclipse.virgo.snaps.api' version '[version]'. 
+<DE0005I> Started bundle 'org.eclipse.virgo.snaps.api' version '[version]'. 
+<DE0004I> Starting bundle 'org.eclipse.virgo.snaps.core' version '[version]'. 
+<DE0005I> Started bundle 'org.eclipse.virgo.snaps.core' version '[version]'. 
+<DE0005I> Started plan 'org.eclipse.virgo.snaps' version '3.0.0'.
+....
+
+Open up the Virgo Admin Console by navigating to
+`http://localhost:8080/admin` and then go to the artifacts tab to deploy
+some new bundles. The first bundle to deploy is located at
+`/sample/org.eclipse.virgo.snaps.sample.animal-[version].jar`,
+select it in the browser and upload. In the terminal window you started
+the Virgo Server for Apache Tomcat in you should see the usual messages about the
+bundle starting and this message:
+
+....
+<SN0000I> Host created for path '/animal-menu-bar'
+....
+
+This shows that the host has been registered and is ready for Snaps to
+attach to it. To view the application take your browser to
+`http://localhost:8080/animal-menu-bar/`. You should be presented with a
+green looking page that has a menu bar with two links on it. One will
+take you to the page you are currently on while the other goes back to
+the admin page.
+
+This is all very nice, but it's time to deploy another snap that will
+dynamicaly add some extra content to the app. The next bundle to deploy
+is located at
+`/sample/org.eclipse.virgo.snaps.sample.dog-[version].jar`.
+Deploy it the same way as the last one using the admin console and check
+the messages to verify it has been bound to the host:
+
+....
+<SN0010I> Snap bound to path '/animal-menu-bar/dog' 
+....
+
+In your browser, go back to the application and refresh the page and a
+new menu item should now be present. If you click it a new page will
+load with content from the newly installed snap. In this case a picture
+of a dog.
+
+image::images/sampleDog.png[]
+
+You have now verified that your install is working and can continue on
+to learn how Snaps works and how you can use it to break up your web
+applications.
diff --git a/snaps-guide/src/docs/asciidoc/introduction.adoc b/snaps-guide/src/docs/asciidoc/introduction.adoc
new file mode 100644
index 0000000..23db8f2
--- /dev/null
+++ b/snaps-guide/src/docs/asciidoc/introduction.adoc
@@ -0,0 +1,36 @@
+[[introduction]]
+== Introduction
+
+This Guide covers Virgo Snaps and assumes you are already
+familiar with OSGi and Eclipse Virgo. See link:#further-reading[here].
+
+[[introduction-concepts]]
+=== Concepts
+
+Using Virgo Snaps, or VS for short, you
+can construct a web application from multiple OSGi bundles, each of
+which serves up content for a distinct sub-portion of your application's
+URL space. VS applications are arranged in a
+parent/child structure, with each application having at most one
+top-level parent, and zero or more children/grand children and so on.
+Parents are referred to as the hosts, children as snaps.
+
+image::images/snapsAndHosts.png[]
+
+Here you see that any `HTTP` requests for '/app' will be dealt with by
+the host bundle while '/app/orders' and '/app/billing' will be dealt
+with by their respective snaps bundles. Each host/snap can use
+completely different web technologies to deal with the requests,
+Virgo Snaps places no restrictions on your choices. The
+developer decides how to split the application up and how closely to
+couple the host and various snaps. VS has been
+designed to be as un-invasive as possible while still making it easy to
+share information between the host and its snaps.
+
+[[introduction-prereqs]]
+=== Prerequisites
+
+VS requires Virgo Server for Apache Tomcat and Java SE 6
+or later to be installed. Java is available from http://www.java.com/
+and elsewhere. Virgo Server for Apache Tomcat is available from
+http://www.eclipse.org/virgo/download/[here].
diff --git a/snaps-guide/src/docs/asciidoc/known-issues.adoc b/snaps-guide/src/docs/asciidoc/known-issues.adoc
new file mode 100644
index 0000000..1360e59
--- /dev/null
+++ b/snaps-guide/src/docs/asciidoc/known-issues.adoc
@@ -0,0 +1,11 @@
+[[known-issues]]
+== Known Issues
+
+This section describes known issues that you might run into, along with
+corresponding workarounds.
+
+[[known-issues-jetty-restriction]]
+=== Virgo Jetty Server Restriction
+
+Virgo Snaps is not supported on the Virgo Jetty Server,
+please use with the Virgo Server for Apache Tomcat.
diff --git a/snaps-guide/src/docs/asciidoc/sample-application.adoc b/snaps-guide/src/docs/asciidoc/sample-application.adoc
new file mode 100644
index 0000000..aaef3f0
--- /dev/null
+++ b/snaps-guide/src/docs/asciidoc/sample-application.adoc
@@ -0,0 +1,107 @@
+[[sample-application]]
+== A Sample Application
+
+The Virgo Snaps Zip file comes with a sample application that
+you may have already deployed to verify your VS
+install. In this chapter you will look at it in more detail to see how
+an application can be composed and see all the Snaps features in action.
+
+[[sample-application-structure]]
+=== Structure of the sample application
+
+The application is very simple, it consists of just a front end,
+composed of four bundles, a host with three Snaps.
+
+image::images/sampleApp.png[]
+
+The host and three snaps show their `Snap-ContextPath`s. The Cat and Dog
+snaps both contribute content while the final snap just contributes
+styling information in the form of `css` files. The following sections
+look at each of these in detail.
+
+[[sample-application-host]]
+=== The Host bundle
+
+This bundle is very simple with no Java code. It defines the Snaps
+filter in its `web.xml` just as you have seen in the
+link:#using-snaps-configuring-the-host[Using Snaps] section. The menu
+bar uses the taglibs support to render links for each registered Snap.
+
+....
+<ul>
+    <li><a href="<c:url value="/"/>">Home</a></li>
+    <snaps:snaps var="snaps">
+        <c:forEach var="snap" items="${snaps}">
+            <c:if test="${snap.contextPath ne '/styles'}">
+                <li><a href="<c:url value="${snap.contextPath}${snap.properties['link.path']}"/>">
+                    ${snap.properties['link.text']}</a>
+                </li>
+            </c:if>
+        </c:forEach>
+    </snaps:snaps>
+</ul>
+        
+....
+
+This is very similar to an example you have already seen. It puts the
+links in a list and adds a link at the beginning to return to the host.
+The properties it is referencing are located in the snaps themselves at
+`/META-INF/snap.properties`.
+
+[[sample-application-new-content]]
+=== Adding New Content
+
+If you now deploy both the Dog and Cat snaps, two new items will appear
+on the menu bar, each providing content from their respective snaps.
+
+image::images/sampleCat.png[]
+
+If you look at the Cat page you will see it is also displaying some
+properties. The Cat Snap is a little more complex, it has it's own
+`DispatcherServlet` defined in its `web.xml` and a controller defined
+using annotations. If you look at the controller code you will see where
+these two properties come from.
+
+....
+@Controller
+public class CatController {
+
+    @RequestMapping("/meow")
+    public ModelAndView cat(HttpServletRequest request) throws IOException {
+        URL host = request.getServletContext().getResource("host:/WEB-INF/sample.properties");
+        Properties host_props = new Properties();
+        if(host != null){
+            host_props.load(host.openStream());
+        }
+        URL snap = request.getServletContext().getResource("/WEB-INF/sample.properties");
+        Properties snap_props = new Properties();
+        if(snap != null){
+            snap_props.load(snap.openStream());
+        }
+        return new ModelAndView("index").addObject("host", host_props.getProperty("some.property"))
+                    .addObject("snap", snap_props.getProperty("some.property"));
+    }
+}
+        
+....
+
+There are two properties files called `sample.properties` located at the
+same path within both the Cat snap and the host. Each contains a
+property called `some.property` but with distinct value. Looking at the
+code above you can see the `host:` prefix being used to ensure the first
+lookup only looks in the host and skips the snap. These values are then
+placed in the Model for the JSP page to render.
+
+[[sample-application-dynamic-styling]]
+=== Re-styling
+
+Finally the Blue styling snap shows how Snaps can be used in other ways.
+Deploying this will cause all requests to `/styles` to be redirected and
+the application will change in appearance but not content. All this
+happens without re-deploying the host bundle, although you may need to
+do a full refresh to clear your browser's cache.
+
+image::images/sampleBlue.png[]
+
+This is the same page as before, being rendered by the host and the Cat
+snap, but with the style information now coming from the Blue snap.
diff --git a/snaps-guide/src/docs/asciidoc/using-snaps.adoc b/snaps-guide/src/docs/asciidoc/using-snaps.adoc
new file mode 100644
index 0000000..8e477e0
--- /dev/null
+++ b/snaps-guide/src/docs/asciidoc/using-snaps.adoc
@@ -0,0 +1,108 @@
+[[using-snaps]]
+== Using Virgo Snaps in your application
+
+Every snap or host should also be a regular WAB (Web Application
+Bundle), all you have to do is add some additional configuration to
+benefit from VS.
+
+[[using-snaps-configuring-the-host]]
+=== Configuring the Host
+
+In the WAB that is to act as a host to Snaps bundles, all that needs to
+be added is a filter in the hosts ' `web.xml`'. This filter can be
+mapped to any sub path that you want forwarded to registered snaps. It
+is important to note the extra `dispatcher` declarations in the
+`filter-mapping`. Without these internal lookups, resources like JSPs
+won't get passed to the appropriate snap when needed.
+
+....
+<filter>
+    <filter-name>host-filter-name</filter-name>
+    <filter-class>org.eclipse.virgo.snaps.core.SnapHostFilter</filter-class>
+</filter>
+
+<filter-mapping>
+    <filter-name>host-filter-name</filter-name>
+    <url-pattern>/*</url-pattern>
+    <dispatcher>INCLUDE</dispatcher>
+    <dispatcher>FORWARD</dispatcher>
+    <dispatcher>REQUEST</dispatcher>
+</filter-mapping>
+        
+....
+
+[[using-snaps-configuring-a-snap]]
+=== Configuring a Snap
+
+A snap is a normal WAB with the addition of two extra manifest headers.
+The first `Snap-Host` is used to resolve the WAB you want to act as a
+host for this snap. The second `Snap-ContextPath` gives the path the
+snap will answer to. In order to reach the snap a request must be made
+for the host's context path, plus any path in the host's Snaps filter
+followed by the path given with the `Snap-ContextPath` header.
+
+....
+Snap-Host: org.eclipse.virgo.snaps.sample.animal;version="${version:[=.=.=, =.+1)}"
+Snap-ContextPath: /dog
+        
+....
+
+[[using-snaps-taglibs]]
+=== Using the Snaps taglibs
+
+There is a tag library available that makes information about the Snaps
+environment available to the host from within a JSP page. The prefix and
+URI to declare are
+`<%@ taglib prefix="snaps" uri="http://www.eclipse.org/virgo/snaps" 
+            %>`. You can now access an array of all the Snaps currently
+registered with the host. Each snap in the array has two values, the
+first is the context path the Snap is registered with, as given in the
+snaps manifest header. The second is an array of properties, if any,
+given in a property file in the snap. The file must be in the `META-INF
+            ` directory and have a name of `snap.properties`. The
+following code snippet shows all of these in use to produce links to
+each of the installed snaps.
+
+....
+<snaps:snaps var="snaps">
+    <c:forEach var="snap" items="${snaps}">
+        <a href="<c:url value="${snap.contextPath}${snap.properties['link.path']}"/>">
+                     ${snap.properties['link.text']}</a>
+    </c:forEach>
+</snaps:snaps>
+        
+....
+
+The first line uses the Snaps tag library to place the array of snaps
+into the `snaps` variable. Then a `forEach` loop goes through each snap.
+The content of the `forEach` loop is the really interesting bit. The
+first variable `${snap.contextPath}` returns the context path of the
+snap. The two lookups are for properties
+`${snap.properties['something']}`. They rely on the snap having the
+properties file in place with `link.path` and `link.text` defined in it.
+This shows the flexibility you have for defining your own contract
+between the host and its snaps. In this case each snap can contribute
+extra information about how links in a menu should be constructed.
+
+[[using-snaps-host-prefix]]
+=== Referencing Resources
+
+If the snap needs to lookup any resources, this can be done in the
+normal way and if the resource cannot be found in the snap, then the
+host will be checked. Remember that a host and all its snaps use a
+single `ServletContext`. As the snap is always checked first it can hide
+resources at the same path in its host. So if you want to look up a
+resource in the snaps host that exists in the snap simply prefix the
+path with `host:`. This will then cause the Snaps system to bypass the
+snap and look only in its host for the requested resource. If it is not
+found in its host the snap will NOT be checked, the lookup will return
+with nothing.
+
+....
+request.getServletContext().getResource("host:/WEB-INF/sample.properties");
+            
+....
+
+This line of Java code gets the ServletContext from the HttpRequest
+object and then tries to get a resource from the host, bypassing the
+snap.
diff --git a/snaps-guide/src/docs/asciidoc/virgo-snaps-guide.adoc b/snaps-guide/src/docs/asciidoc/virgo-snaps-guide.adoc
new file mode 100644
index 0000000..0eb5834
--- /dev/null
+++ b/snaps-guide/src/docs/asciidoc/virgo-snaps-guide.adoc
@@ -0,0 +1,27 @@
+= Virgo Snaps User Guide
+Daniel Marthaler
+2017-02-04
+:nofooter:
+:appversion: 3.7.0.RC01
+
+[%hardbreaks]
+Christopher Frost
+Daniel Marthaler
+
+*Virgo Snaps {appversion}* image:images/virgo-logo-large.png[Eclipse Virgo,300,float="right"]
+
+[%hardbreaks]
+VMware Inc. - initial contribution
+Copyright (C) 2009, 2011 VMware Inc. and others
+
+'''
+
+:toc:
+
+:numbered:
+include::introduction.adoc[]
+include::installing.adoc[]
+include::using-snaps.adoc[]
+include::sample-application.adoc[]
+include::further-reading.adoc[]
+include::known-issues.adoc[]
diff --git a/snaps-guide/src/further-reading.xml b/snaps-guide/src/further-reading.xml
deleted file mode 100644
index 8fabcea..0000000
--- a/snaps-guide/src/further-reading.xml
+++ /dev/null
@@ -1,29 +0,0 @@
-<?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="further-reading">
-	<title>Further Reading</title>
-	<para>
-		The User and Programmer Guides provide a lot of information about using and developing applications for the @umbrella.product.name@.
-	</para>
-	<para>
-		<ulink url="http://www.eclipse.org/virgo/documentation/">
-			@project.name@ Documentation page
-		</ulink>
-	</para>
-	<para>
-		<ulink url="../../virgo-programmer-guide/html/index.html">
-			@tomcat.product.name@ Programmer Guide
-		</ulink>
-	</para>
-	<para>
-		<ulink url="../../virgo-user-guide/html/index.html">
-			@tomcat.product.name@ User Guide
-		</ulink>
-	</para>
-	<para>
-		<ulink url="http://www.slideshare.net/cgfrost/eclipsecon2011-virgo-snaps">
-			Slides from a presentation at EclipseCon 2011 about @snaps.product.name@.
-		</ulink>
-	</para>
-</chapter>
\ No newline at end of file
diff --git a/snaps-guide/src/installing.xml b/snaps-guide/src/installing.xml
deleted file mode 100644
index df2b3d0..0000000
--- a/snaps-guide/src/installing.xml
+++ /dev/null
@@ -1,86 +0,0 @@
-<?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 @snaps.product.name@</title>
-	
-	<section id="installation-zip">
-		<title>Installing from the Zip Download</title>
-		<para>
-			@snaps.product.name.short@ is distributed as a Zip file. This can be downloaded from 
-			<ulink url="http://www.eclipse.org/virgo/download/">here</ulink>.
-		</para>
-		<para>
-			Once the Zip file is unpacked you will find several things inside, including a copy of this documentation in the 
-			<literal>docs</literal> folder. The layout is shown below.
-		</para>
-		<para>
-			<imagedata fileref="images/snapsZipFile.png" align="center" width="12cm"/>
-		</para>
-		<para>
-			Take the bundles and plan in the <literal>dist</literal> folder and place them in either the <literal>/repository/usr</literal> 
-			or <literal>/repository/ext</literal> folder of your Virgo install. Later you need the bundles in the <literal>sample</literal> 
-			folder. If you wish to view the source for @snaps.product.name.short@ or its sample, then these are in the <literal>src</literal> 
-			folder.
-		</para>
-		<para>
-			In order to start the Snaps system as a part of your @tomcat.product.name@, the Snaps plan needs to be referenced 
-			from the <literal>initialArtifacts</literal> property. This is located in the config file at 
-			<literal>${SERVER_HOME}/config/org.eclipse.virgo.kernel.userregion.properties</literal>. The property should be 
-			extended like this.
-		</para>
-		<screen>initialArtifacts=repository:plan/org.eclipse.virgo.kernel.userregion.springdm, 
-		repository:plan/org.eclipse.virgo.web.tomcat, 
-		<emphasis>repository:plan/org.eclipse.virgo.snaps</emphasis></screen>
-		<para>
-			Now you are ready to check that Snaps is working.
-		</para>
-	</section>
-	
-	<section id="installation-post">
-		<title>Verifying it's working</title>
-		<para>
-			The sample application in the Zip file demonstrates all of the features of Snaps. You will cover this application in 
-			detail later, but for now install it to verify that you have a working Snaps install. Start the server up and check 
-			the output it produces contains the following:
-		</para>
-		<screen>&#60;DE0004I&#62; Starting plan 'org.eclipse.virgo.snaps' version '3.0.0'. 
-&#60;DE0004I&#62; Starting bundle 'org.eclipse.virgo.snaps.api' version '@bundle.version@'. 
-&#60;DE0005I&#62; Started bundle 'org.eclipse.virgo.snaps.api' version '@bundle.version@'. 
-&#60;DE0004I&#62; Starting bundle 'org.eclipse.virgo.snaps.core' version '@bundle.version@'. 
-&#60;DE0005I&#62; Started bundle 'org.eclipse.virgo.snaps.core' version '@bundle.version@'. 
-&#60;DE0005I&#62; Started plan 'org.eclipse.virgo.snaps' version '3.0.0'.</screen>
-		<para>
-			Open up the @project.name@ Admin Console by navigating to <literal>http://localhost:8080/admin</literal> and then go 
-			to the artifacts tab to deploy some new bundles. The first bundle to deploy is located at 
-			<literal>/sample/org.eclipse.virgo.snaps.sample.animal-@bundle.version@.jar</literal>, select it in the browser and 
-			upload. In the terminal window you started the @tomcat.product.name@ in you should see the usual messages about the 
-			bundle starting and this message:
-		</para>
-		<screen>&#60;SN0000I&#62; Host created for path '/animal-menu-bar'</screen>
-		<para>
-			This shows that the host has been registered and is ready for Snaps to attach to it. To view the application take 
-			your browser to <literal>http://localhost:8080/animal-menu-bar/</literal>. You should be presented with a green looking 
-			page that has a menu bar with two links on it. One will take you to the page you are currently on while the other goes 
-			back to the admin page.
-		</para>
-		<para>
-			This is all very nice, but it's time to deploy another snap that will dynamicaly add some extra content to the app. The next bundle
-			to deploy is located at <literal>/sample/org.eclipse.virgo.snaps.sample.dog-@bundle.version@.jar</literal>. Deploy it the same way 
-			as the last one using the admin console and check the messages to verify it has been bound to the host:
-		</para>
-		<screen>&#60;SN0010I&#62; Snap bound to path '/animal-menu-bar/dog' </screen>
-		<para>
-			In your browser, go back to the application and refresh the page and a new menu item should now be present. If you click it a new 
-			page will load with content from the newly installed snap. In this case a picture of a dog.
-		</para>
-		<para>	
-			<imagedata fileref="images/sampleDog.png"/>
-		</para>
-		<para>
-			You have now verified that your install is working and can continue on to learn how Snaps works and how you can use it to break up 
-			your web applications.
-		</para>
-	</section>
-	
-</chapter>
diff --git a/snaps-guide/src/introduction.xml b/snaps-guide/src/introduction.xml
deleted file mode 100644
index 9394989..0000000
--- a/snaps-guide/src/introduction.xml
+++ /dev/null
@@ -1,39 +0,0 @@
-<?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="introduction">
-	<title>Introduction</title>
-	<para>
-		This Guide covers @snaps.product.name@ and assumes you are already familiar with OSGi and @project.name@. See <link linkend="further-reading">here</link>.
-	</para>
-	
-	<section id="introduction-concepts">
-		<title>Concepts</title>
-		<para>
-			Using @snaps.product.name@, or @snaps.product.name.short@ for short, you can construct a web application from multiple OSGi 
-			bundles, each of which serves up content for a distinct sub-portion of your application's URL space. @snaps.product.name.short@ 
-			applications are arranged in a parent/child structure, with each application having at most one top-level parent, and zero or more 
-			children/grand children and so on. Parents are referred to as the hosts, children as snaps.
-		</para>
-		<para>
-			<imagedata fileref="images/snapsAndHosts.png"/>
-		</para>
-		<para>
-			Here you see that any <literal>HTTP</literal> requests for '/app' will be dealt with by the host bundle while '/app/orders' 
-			and '/app/billing' will be dealt with by their respective snaps bundles. Each host/snap can use completely different web technologies 
-			to deal with the requests, @snaps.product.name.short@ places no restrictions on your choices. The developer decides how to split 
-			the application up and how closely to couple the host and various snaps. @snaps.product.name.short@ has been designed to be as 
-			un-invasive as possible while still making it easy to share information between the host and its snaps.
-		</para>
-	</section>
-	
-	<section id="introduction-prereqs">
-		<title>Prerequisites</title>
-		<para>
-			@snaps.product.name.short@ requires @tomcat.product.name@ and Java SE 6 or later to be installed. Java is available from 
-			<ulink url="http://www.java.com/">http://www.java.com/</ulink> and elsewhere. @tomcat.product.name@ is available from 
-			<ulink url="http://www.eclipse.org/virgo/download/">here</ulink>.
-		</para>
-	</section>
-	
-</chapter>
\ No newline at end of file
diff --git a/snaps-guide/src/known-issues.xml b/snaps-guide/src/known-issues.xml
deleted file mode 100644
index 0248011..0000000
--- a/snaps-guide/src/known-issues.xml
+++ /dev/null
@@ -1,17 +0,0 @@
-<?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="known-issues">
-	<title>Known Issues</title>
-	<para>
-		This section describes known issues that you might run into, along with corresponding workarounds.
-	</para>
-	
-	<section id="known-issues-jetty-restriction">
-		<title>@jetty.product.name@ Restriction</title>
-		<para>
-			@snaps.product.name@ is not supported on the @jetty.product.name@, please use with the @tomcat.product.name@.
-		</para>
-	</section>
-	
-</chapter>
\ No newline at end of file
diff --git a/snaps-guide/src/sample-application.xml b/snaps-guide/src/sample-application.xml
deleted file mode 100644
index 44d5877..0000000
--- a/snaps-guide/src/sample-application.xml
+++ /dev/null
@@ -1,114 +0,0 @@
-<?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="sample-application">
-	<title>A Sample Application</title>
-	<para>
-		The @snaps.product.name@ Zip file comes with a sample application that you may have already deployed to verify 
-		your @snaps.product.name.short@ install. In this chapter you will look at it in more detail to see how an 
-		application can be composed and see all the Snaps features in action.
-	</para>
-	<section id="sample-application-structure">
-		<title>Structure of the sample application</title>
-		<para>
-			The application is very simple, it consists of just a front end, composed of four bundles, a host with 
-			three Snaps.
-		</para>
-		<para>
-			<imagedata fileref="images/sampleApp.png"/>
-		</para>
-		<para>
-			The host and three snaps show their <literal>Snap-ContextPath</literal>s. The Cat and Dog snaps both 
-			contribute content while the final snap just contributes styling information in the form of <literal>css</literal> 
-			files. The following sections look at each of these in detail.
-		</para>
-	</section>
-	
-	<section id="sample-application-host">
-		<title>The Host bundle</title>
-		<para>
-			This bundle is very simple with no Java code. It defines the Snaps filter in its <literal>web.xml</literal> 
-			just as you have seen in the <link linkend="using-snaps-configuring-the-host">Using Snaps</link> section. The 
-			menu bar uses the taglibs support to render links for each registered Snap.  
-		</para>
-		<programlisting>
-<![CDATA[<ul>
-    <li><a href="<c:url value="/"/>">Home</a></li>
-    <snaps:snaps var="snaps">
-        <c:forEach var="snap" items="${snaps}">
-            <c:if test="${snap.contextPath ne '/styles'}">
-                <li><a href="<c:url value="${snap.contextPath}${snap.properties['link.path']}"/>">
-                    ${snap.properties['link.text']}</a>
-                </li>
-            </c:if>
-        </c:forEach>
-    </snaps:snaps>
-</ul>]]>
-		</programlisting>
-		<para>
-			This is very similar to an example you have already seen. It puts the links in a list and adds a link at the 
-			beginning to return to the host. The properties it is referencing are located in the snaps themselves at 
-			<literal>/META-INF/snap.properties</literal>.
-		</para>
-	</section>
-	
-	<section id="sample-application-new-content">
-		<title>Adding New Content</title>
-		<para>
-			If you now deploy both the Dog and Cat snaps, two new items will appear on the menu bar, each providing content 
-			from their respective snaps.
-		</para>
-		<para>
-			<imagedata fileref="images/sampleCat.png"/>
-		</para>
-		<para>
-			If you look at the Cat page you will see it is also displaying some properties. The Cat Snap is a little more 
-			complex, it has it's own <literal>DispatcherServlet</literal> defined in its <literal>web.xml</literal> and a 
-			controller defined using annotations. If you look at the controller code you will see where these two properties 
-			come from.
-		</para>
-<programlisting>
-<![CDATA[@Controller
-public class CatController {
-
-    @RequestMapping("/meow")
-    public ModelAndView cat(HttpServletRequest request) throws IOException {
-        URL host = request.getServletContext().getResource("host:/WEB-INF/sample.properties");
-        Properties host_props = new Properties();
-        if(host != null){
-            host_props.load(host.openStream());
-        }
-        URL snap = request.getServletContext().getResource("/WEB-INF/sample.properties");
-        Properties snap_props = new Properties();
-        if(snap != null){
-            snap_props.load(snap.openStream());
-        }
-        return new ModelAndView("index").addObject("host", host_props.getProperty("some.property"))
-                    .addObject("snap", snap_props.getProperty("some.property"));
-    }
-}]]>
-		</programlisting>
-		<para>
-			There are two properties files called <literal>sample.properties</literal> located at the same path within both 
-			the Cat snap and the host. Each contains a property called <literal>some.property</literal> but with distinct 
-			value. Looking at the code above you can see the <code>host:</code> prefix being used to ensure the first lookup
-			only looks in the host and skips the snap. These values are then placed in the Model for the JSP page to render.
-		</para>
-	</section>
-	
-	<section id="sample-application-dynamic-styling">
-		<title>Re-styling</title>
-		<para>
-			Finally the Blue styling snap shows how Snaps can be used in other ways. Deploying this will cause all requests 
-			to <literal>/styles</literal> to be redirected and the application will change in appearance but not content. All 
-			this happens without re-deploying the host bundle, although you may need to do a full refresh to clear your browser's 
-			cache.
-		</para>
-		<para>
-			<imagedata fileref="images/sampleBlue.png"/>
-		</para>
-		This is the same page as before, being rendered by the host and the Cat snap, but with the style information now coming
-		from the Blue snap.
-	</section>
-	
-</chapter>
\ No newline at end of file
diff --git a/snaps-guide/src/using-snaps.xml b/snaps-guide/src/using-snaps.xml
deleted file mode 100644
index f61a6e2..0000000
--- a/snaps-guide/src/using-snaps.xml
+++ /dev/null
@@ -1,98 +0,0 @@
-<?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="using-snaps">
-	<title>Using @snaps.product.name@ in your application</title>
-	<para>
-		Every snap or host should also be a regular WAB (Web Application Bundle), all you have to do is add some additional 
-		configuration to benefit from @snaps.product.name.short@.
-	</para>
-	
-	<section id="using-snaps-configuring-the-host">
-		<title>Configuring the Host</title>
-		<para>
-			In the WAB that is to act as a host to Snaps bundles, all that needs to be added is a filter in the hosts '
-			<literal>web.xml</literal>'. This filter can be mapped to any sub path that you want forwarded to registered 
-			snaps. It is important to note the extra <literal>dispatcher</literal> declarations in the <literal>filter-mapping</literal>. 
-			Without these internal lookups, resources like JSPs won't get passed to the appropriate snap when needed.
-		</para>
-		<programlisting>
-<![CDATA[<filter>
-    <filter-name>host-filter-name</filter-name>
-    <filter-class>org.eclipse.virgo.snaps.core.SnapHostFilter</filter-class>
-</filter>
-
-<filter-mapping>
-    <filter-name>host-filter-name</filter-name>
-    <url-pattern>/*</url-pattern>
-    <dispatcher>INCLUDE</dispatcher>
-    <dispatcher>FORWARD</dispatcher>
-    <dispatcher>REQUEST</dispatcher>
-</filter-mapping>]]>
-		</programlisting>
-	</section>
-	
-	<section id="using-snaps-configuring-a-snap">
-		<title>Configuring a Snap</title>
-		<para>
-			A snap is a normal WAB with the addition of two extra manifest headers. The first <literal>Snap-Host</literal> is used 
-			to resolve the WAB you want to act as a host for this snap. The second <literal>Snap-ContextPath</literal> gives the 
-			path the snap will answer to. In order to reach the snap a request must be made for the host's context path, plus any 
-			path in the host's Snaps filter followed by the path given with the <literal>Snap-ContextPath</literal> header.
-		</para>
-		<programlisting>
-<![CDATA[Snap-Host: org.eclipse.virgo.snaps.sample.animal;version="${version:[=.=.=, =.+1)}"
-Snap-ContextPath: /dog]]>
-		</programlisting>
-	</section>
-	
-	<section id="using-snaps-taglibs">
-		<title>Using the Snaps taglibs</title>
-		<para>
-			There is a tag library available that makes information about the Snaps environment available to the host from within a 
-			JSP page. The prefix and URI to declare are <code>&#60;%@ taglib prefix="snaps" uri="http://www.eclipse.org/virgo/snaps" 
-			%&#62;</code>. You can now access an array of all the Snaps currently registered with the host. Each snap in the array
-			has two values, the first is the context path the Snap is registered with, as given in the snaps manifest header. The 
-			second is an array of properties, if any, given in a property file in the snap. The file must be in the <literal>META-INF
-			</literal> directory and have a name of <literal>snap.properties</literal>. The following code snippet shows all of these 
-			in use to produce links to each of the installed snaps.
-		</para>
-		<programlisting>
-<![CDATA[<snaps:snaps var="snaps">
-    <c:forEach var="snap" items="${snaps}">
-        <a href="<c:url value="${snap.contextPath}${snap.properties['link.path']}"/>">
-                     ${snap.properties['link.text']}</a>
-    </c:forEach>
-</snaps:snaps>]]>
-		</programlisting>
-		<para>
-			The first line uses the Snaps tag library to place the array of snaps into the <code>snaps</code> variable. Then a 
-			<code>forEach</code> loop goes through each snap. The content of the <code>forEach</code> loop is the really interesting 
-			bit. The first variable <code>${snap.contextPath}</code> returns the context path of the snap. The two lookups are for 
-			properties <code>${snap.properties['something']}</code>. They rely on the snap having the properties file in place with 
-			<literal>link.path</literal> and <literal>link.text</literal> defined in it. This shows the flexibility you have for defining 
-			your own contract between the host and its snaps. In this case each snap can contribute extra information about how links in 
-			a menu should be constructed.
-		</para>
-	</section>
-	
-	<section id="using-snaps-host-prefix">
-		<title>Referencing Resources</title>
-		<para>
-			If the snap needs to lookup any resources, this can be done in the normal way and if the resource cannot be found in the snap, 
-			then the host will be checked. Remember that a host and all its snaps use a single <literal>ServletContext</literal>. As the 
-			snap is always checked first it can hide resources at the same path in its host. So if you want to look up a resource in the 
-			snaps host that exists in the snap simply prefix the path with <code>host:</code>. This will then cause the Snaps system to 
-			bypass the snap and look only in its host for the requested resource. If it is not found in its host the snap will NOT be 
-			checked, the lookup will return with nothing.
-			<programlisting>
-<![CDATA[request.getServletContext().getResource("host:/WEB-INF/sample.properties");]]>
-			</programlisting>
-			<para>
-				This line of Java code gets the ServletContext from the HttpRequest object and then tries to get a resource from the host, 
-				bypassing the snap.
-			</para>
-		</para>
-	</section>
-	
-</chapter>
\ No newline at end of file
diff --git a/snaps-guide/src/virgo-snaps-guide.xml b/snaps-guide/src/virgo-snaps-guide.xml
deleted file mode 100644
index e981c5c..0000000
--- a/snaps-guide/src/virgo-snaps-guide.xml
+++ /dev/null
@@ -1,41 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN" 
-		"http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd">
-<book xmlns:xi="http://www.w3.org/2001/XInclude">
-	<bookinfo>
-		<title>@snaps.product.name@ User Guide</title>
-		<titleabbrev>Snaps User Guide</titleabbrev>
-		<productname>@snaps.product.name@</productname>
-		<releaseinfo>@bundle.version@</releaseinfo>
-
-		<mediaobject>
-			<imageobject role="fo">
-				<imagedata align="center" fileref="images/virgo-logo-small.png" format="PNG" />
-			</imageobject>
-			<imageobject role="html">
-				<imagedata align="right" fileref="images/virgo-logo-small.png" format="PNG" />
-			</imageobject>
-		</mediaobject>
-
-		<authorgroup>
-			<author>
-				<firstname>Christopher</firstname>
-				<surname>Frost</surname>
-			</author>
-		</authorgroup>
-
-		<legalnotice>
-			<para>
-				Copyright &copy; 2011 VMware Inc.
-			</para>
-		</legalnotice>
-	</bookinfo>
-
-	<toc />
-	<xi:include href="introduction.xml"/>
-	<xi:include href="installing.xml"/>
-	<xi:include href="using-snaps.xml"/>
-	<xi:include href="sample-application.xml"/>
-    <xi:include href="further-reading.xml"/>
-    <xi:include href="known-issues.xml"/>
-</book>
diff --git a/test-apps/simple-host/build.xml b/test-apps/simple-host/build.xml
deleted file mode 100644
index 8bb1b59..0000000
--- a/test-apps/simple-host/build.xml
+++ /dev/null
@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project name="simple-host">
-
-	<property file="${basedir}/../build.properties"/>
-	<property file="${basedir}/../../build.versions"/>
-	<property name="wab.output.dir" value="${basedir}/../../org.eclipse.virgo.snaps.test/target/test-apps"/>
-	<import file="${basedir}/../../virgo-build/wab/default.xml"/>
-
-</project>
diff --git a/test-apps/simple-host/ivy.xml b/test-apps/simple-host/ivy.xml
deleted file mode 100644
index e9db7d1..0000000
--- a/test-apps/simple-host/ivy.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<?xml-stylesheet type="text/xsl" href="http://ivyrep.jayasoft.org/ivy-doc.xsl"?>
-<ivy-module
-        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-        xsi:noNamespaceSchemaLocation="http://incubator.apache.org/ivy/schemas/ivy.xsd"
-        version="1.3">
-
-    <info organisation="org.eclipse.virgo.snaps" module="${ant.project.name}"/>
-
-    <configurations>
-        <include file="${virgo.build.dir}/common/default-ivy-configurations.xml"/>
-    </configurations>
-
-    <publications>
-        <artifact name="${ant.project.name}" type="wab" ext="jar"/>
-        <artifact name="${ant.project.name}-sources" type="src" ext="jar"/>
-    </publications>
-
-    <dependencies>
-        <dependency org="org.eclipse.virgo.mirrored" name="org.slf4j.api" rev="${org.slf4j.api}" conf="provided->runtime"/>
-        <dependency org="org.eclipse.virgo.mirrored" name="org.slf4j.nop" rev="${org.slf4j.nop}" conf="test->runtime"/>
- 	    <dependency org="org.eclipse.virgo.mirrored" name="javax.servlet" rev="${javax.servlet}" conf="provided->runtime"/>
-    </dependencies>
-
-</ivy-module>
diff --git a/test-apps/simple-snap/build.xml b/test-apps/simple-snap/build.xml
deleted file mode 100644
index ee2b873..0000000
--- a/test-apps/simple-snap/build.xml
+++ /dev/null
@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project name="simple-snap">
-
-	<property file="${basedir}/../build.properties"/>
-	<property file="${basedir}/../../build.versions"/>
-	<property name="wab.output.dir" value="${basedir}/../../org.eclipse.virgo.snaps.test/target/test-apps"/>
-	<import file="${basedir}/../../virgo-build/wab/default.xml"/>
-
-</project>
diff --git a/test-apps/simple-snap/ivy.xml b/test-apps/simple-snap/ivy.xml
deleted file mode 100644
index 5d8257d..0000000
--- a/test-apps/simple-snap/ivy.xml
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<?xml-stylesheet type="text/xsl" href="http://ivyrep.jayasoft.org/ivy-doc.xsl"?>
-<ivy-module
-        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-        xsi:noNamespaceSchemaLocation="http://incubator.apache.org/ivy/schemas/ivy.xsd"
-        version="1.3">
-
-    <info organisation="org.eclipse.virgo.snaps" module="${ant.project.name}"/>
-
-    <configurations>
-        <include file="${virgo.build.dir}/common/default-ivy-configurations.xml"/>
-    </configurations>
-
-    <publications>
-        <artifact name="${ant.project.name}" type="wab" ext="jar"/>
-        <artifact name="${ant.project.name}-sources" type="src" ext="jar"/>
-    </publications>
-
-    <dependencies>
-    	<dependency org="org.eclipse.virgo.mirrored" name="org.eclipse.osgi" rev="${org.eclipse.osgi}" conf="provided->runtime"/>
-        <dependency org="org.eclipse.virgo.mirrored" name="org.slf4j.api" rev="${org.slf4j.api}" conf="provided->runtime"/>
-	    <dependency org="org.eclipse.virgo.mirrored" name="javax.servlet" rev="${javax.servlet}" conf="provided->runtime"/>
-        <dependency org="org.eclipse.virgo.mirrored" name="org.slf4j.nop" rev="${org.slf4j.nop}" conf="test->runtime"/>
-    </dependencies>
-
-</ivy-module>
diff --git a/test-apps/spring-snap/build.xml b/test-apps/spring-snap/build.xml
deleted file mode 100644
index afe6de0..0000000
--- a/test-apps/spring-snap/build.xml
+++ /dev/null
@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project name="spring-snap">
-
-	<property file="${basedir}/../build.properties"/>
-	<property file="${basedir}/../../build.versions"/>
-	<property name="wab.output.dir" value="${basedir}/../../org.eclipse.virgo.snaps.test/target/test-apps"/>
-	<import file="${basedir}/../../virgo-build/wab/default.xml"/>
-
-</project>
diff --git a/test-apps/spring-snap/ivy.xml b/test-apps/spring-snap/ivy.xml
deleted file mode 100644
index 58fcd33..0000000
--- a/test-apps/spring-snap/ivy.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<?xml-stylesheet type="text/xsl" href="http://ivyrep.jayasoft.org/ivy-doc.xsl"?>
-<ivy-module
-        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-        xsi:noNamespaceSchemaLocation="http://incubator.apache.org/ivy/schemas/ivy.xsd"
-        version="1.3">
-
-    <info organisation="org.eclipse.virgo.snaps" module="${ant.project.name}"/>
-
-    <configurations>
-        <include file="${virgo.build.dir}/common/default-ivy-configurations.xml"/>
-    </configurations>
-
-    <publications>
-        <artifact name="${ant.project.name}" type="wab" ext="jar"/>
-        <artifact name="${ant.project.name}-sources" type="src" ext="jar"/>
-    </publications>
-
-    <dependencies>
-        <dependency org="org.eclipse.virgo.mirrored" name="org.slf4j.api" rev="${org.slf4j.api}" conf="provided->runtime"/>
-	    <dependency org="org.eclipse.virgo.mirrored" name="javax.servlet" rev="${javax.servlet}" conf="provided->runtime"/>
-	    <dependency org="org.springframework" name="org.springframework.spring-library" rev="${org.springframework}" conf="provided->runtime"/>
-        
-        <dependency org="org.eclipse.virgo.mirrored" name="org.slf4j.nop" rev="${org.slf4j.nop}" conf="test->runtime"/>
-    </dependencies>
-
-</ivy-module>
diff --git a/test-apps/taglib-host/build.xml b/test-apps/taglib-host/build.xml
deleted file mode 100644
index 09759e4..0000000
--- a/test-apps/taglib-host/build.xml
+++ /dev/null
@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project name="taglib-host">
-
-	<property file="${basedir}/../build.properties"/>
-	<property file="${basedir}/../../build.versions"/>
-	<property name="wab.output.dir" value="${basedir}/../../org.eclipse.virgo.snaps.test/target/test-apps"/>
-	<import file="${basedir}/../../virgo-build/wab/default.xml"/>
-
-</project>
diff --git a/test-apps/taglib-host/ivy.xml b/test-apps/taglib-host/ivy.xml
deleted file mode 100644
index e9db7d1..0000000
--- a/test-apps/taglib-host/ivy.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<?xml-stylesheet type="text/xsl" href="http://ivyrep.jayasoft.org/ivy-doc.xsl"?>
-<ivy-module
-        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-        xsi:noNamespaceSchemaLocation="http://incubator.apache.org/ivy/schemas/ivy.xsd"
-        version="1.3">
-
-    <info organisation="org.eclipse.virgo.snaps" module="${ant.project.name}"/>
-
-    <configurations>
-        <include file="${virgo.build.dir}/common/default-ivy-configurations.xml"/>
-    </configurations>
-
-    <publications>
-        <artifact name="${ant.project.name}" type="wab" ext="jar"/>
-        <artifact name="${ant.project.name}-sources" type="src" ext="jar"/>
-    </publications>
-
-    <dependencies>
-        <dependency org="org.eclipse.virgo.mirrored" name="org.slf4j.api" rev="${org.slf4j.api}" conf="provided->runtime"/>
-        <dependency org="org.eclipse.virgo.mirrored" name="org.slf4j.nop" rev="${org.slf4j.nop}" conf="test->runtime"/>
- 	    <dependency org="org.eclipse.virgo.mirrored" name="javax.servlet" rev="${javax.servlet}" conf="provided->runtime"/>
-    </dependencies>
-
-</ivy-module>
diff --git a/test-apps/taglib-snap-one/build.xml b/test-apps/taglib-snap-one/build.xml
deleted file mode 100644
index 18b8899..0000000
--- a/test-apps/taglib-snap-one/build.xml
+++ /dev/null
@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project name="taglib-snap-one">
-
-	<property file="${basedir}/../build.properties"/>
-	<property file="${basedir}/../../build.versions"/>
-	<property name="wab.output.dir" value="${basedir}/../../org.eclipse.virgo.snaps.test/target/test-apps"/>
-	<import file="${basedir}/../../virgo-build/wab/default.xml"/>
-
-</project>
diff --git a/test-apps/taglib-snap-one/ivy.xml b/test-apps/taglib-snap-one/ivy.xml
deleted file mode 100644
index 5d8257d..0000000
--- a/test-apps/taglib-snap-one/ivy.xml
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<?xml-stylesheet type="text/xsl" href="http://ivyrep.jayasoft.org/ivy-doc.xsl"?>
-<ivy-module
-        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-        xsi:noNamespaceSchemaLocation="http://incubator.apache.org/ivy/schemas/ivy.xsd"
-        version="1.3">
-
-    <info organisation="org.eclipse.virgo.snaps" module="${ant.project.name}"/>
-
-    <configurations>
-        <include file="${virgo.build.dir}/common/default-ivy-configurations.xml"/>
-    </configurations>
-
-    <publications>
-        <artifact name="${ant.project.name}" type="wab" ext="jar"/>
-        <artifact name="${ant.project.name}-sources" type="src" ext="jar"/>
-    </publications>
-
-    <dependencies>
-    	<dependency org="org.eclipse.virgo.mirrored" name="org.eclipse.osgi" rev="${org.eclipse.osgi}" conf="provided->runtime"/>
-        <dependency org="org.eclipse.virgo.mirrored" name="org.slf4j.api" rev="${org.slf4j.api}" conf="provided->runtime"/>
-	    <dependency org="org.eclipse.virgo.mirrored" name="javax.servlet" rev="${javax.servlet}" conf="provided->runtime"/>
-        <dependency org="org.eclipse.virgo.mirrored" name="org.slf4j.nop" rev="${org.slf4j.nop}" conf="test->runtime"/>
-    </dependencies>
-
-</ivy-module>
diff --git a/test-apps/taglib-snap-two/build.xml b/test-apps/taglib-snap-two/build.xml
deleted file mode 100644
index bc063fd..0000000
--- a/test-apps/taglib-snap-two/build.xml
+++ /dev/null
@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project name="taglib-snap-two">
-
-	<property file="${basedir}/../build.properties"/>
-	<property file="${basedir}/../../build.versions"/>
-	<property name="wab.output.dir" value="${basedir}/../../org.eclipse.virgo.snaps.test/target/test-apps"/>
-	<import file="${basedir}/../../virgo-build/wab/default.xml"/>
-
-</project>
diff --git a/test-apps/taglib-snap-two/ivy.xml b/test-apps/taglib-snap-two/ivy.xml
deleted file mode 100644
index 5d8257d..0000000
--- a/test-apps/taglib-snap-two/ivy.xml
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<?xml-stylesheet type="text/xsl" href="http://ivyrep.jayasoft.org/ivy-doc.xsl"?>
-<ivy-module
-        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-        xsi:noNamespaceSchemaLocation="http://incubator.apache.org/ivy/schemas/ivy.xsd"
-        version="1.3">
-
-    <info organisation="org.eclipse.virgo.snaps" module="${ant.project.name}"/>
-
-    <configurations>
-        <include file="${virgo.build.dir}/common/default-ivy-configurations.xml"/>
-    </configurations>
-
-    <publications>
-        <artifact name="${ant.project.name}" type="wab" ext="jar"/>
-        <artifact name="${ant.project.name}-sources" type="src" ext="jar"/>
-    </publications>
-
-    <dependencies>
-    	<dependency org="org.eclipse.virgo.mirrored" name="org.eclipse.osgi" rev="${org.eclipse.osgi}" conf="provided->runtime"/>
-        <dependency org="org.eclipse.virgo.mirrored" name="org.slf4j.api" rev="${org.slf4j.api}" conf="provided->runtime"/>
-	    <dependency org="org.eclipse.virgo.mirrored" name="javax.servlet" rev="${javax.servlet}" conf="provided->runtime"/>
-        <dependency org="org.eclipse.virgo.mirrored" name="org.slf4j.nop" rev="${org.slf4j.nop}" conf="test->runtime"/>
-    </dependencies>
-
-</ivy-module>
diff --git a/virgo-build b/virgo-build
deleted file mode 160000
index b3513e2..0000000
--- a/virgo-build
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit b3513e2cdfc6f908d7b03f30a2e863c3203b62cb
