From 25b06a88ab89a55c4f81b24a6819414779edd415 Mon Sep 17 00:00:00 2001
From: "shannon@ShandemVaio" <unknown@kiln.example.com>
Date: Fri, 20 Jul 2012 01:04:35 +0600
Subject: [PATCH] Began integration of Stephen's new routing logic. The sln
 compiles and things have been refactored from the initial concept. The module
 is not active as it currently will not work because of contructor
 dependencies and classes marked as internal, will liase with Stephen
 regarding this.

---
 src/Umbraco.Core/ApplicationContext.cs        |  94 ++++
 src/Umbraco.Core/PluginResolver.cs            |  23 +
 src/Umbraco.Core/Properties/AssemblyInfo.cs   |   2 +
 src/Umbraco.Core/Umbraco.Core.csproj          |   9 +
 src/Umbraco.Core/UriExtensions.cs             |  22 +
 src/Umbraco.Web/ContentStore.cs               | 148 ++++++
 src/Umbraco.Web/LegacyRequestInitializer.cs   |  31 ++
 src/Umbraco.Web/Mvc/ControllerExtensions.cs   |  28 +
 src/Umbraco.Web/NiceUrls.cs                   | 151 ++++++
 src/Umbraco.Web/PluginResolverExtensions.cs   |  55 ++
 src/Umbraco.Web/Routing/DocumentRequest.cs    | 499 ++++++++++++++++++
 src/Umbraco.Web/Routing/ILookup.cs            |   9 +
 src/Umbraco.Web/Routing/ILookupNotFound.cs    |   7 +
 src/Umbraco.Web/Routing/LookupByAlias.cs      |  45 ++
 src/Umbraco.Web/Routing/LookupById.cs         |  65 +++
 src/Umbraco.Web/Routing/LookupByPath.cs       |  69 +++
 .../Routing/LookupByPathWithTemplate.cs       |  55 ++
 src/Umbraco.Web/Routing/LookupByProfile.cs    |  59 +++
 src/Umbraco.Web/Routing/LookupFor404.cs       | 153 ++++++
 .../Routing/LookupWeightAttribute.cs          |  32 ++
 src/Umbraco.Web/Routing/RoutesCache.cs        |  81 +++
 src/Umbraco.Web/Routing/RoutingEnvironment.cs |  42 ++
 src/Umbraco.Web/Umbraco.Web.csproj            |  24 +
 src/Umbraco.Web/UmbracoContext.cs             | 221 ++++++++
 src/Umbraco.Web/UmbracoModule.cs              | 371 +++++++++++++
 src/Umbraco.Web/UrlUtility.cs                 | 145 +++++
 .../umbraco.presentation/UmbracoContext.cs    |   3 +-
 .../umbraco.presentation/UmbracoRequest.cs    |   1 +
 .../umbraco.presentation/UmbracoResponse.cs   |   1 +
 .../UmbracoServerUtility.cs                   |   1 +
 30 files changed, 2445 insertions(+), 1 deletion(-)
 create mode 100644 src/Umbraco.Core/ApplicationContext.cs
 create mode 100644 src/Umbraco.Core/PluginResolver.cs
 create mode 100644 src/Umbraco.Core/UriExtensions.cs
 create mode 100644 src/Umbraco.Web/ContentStore.cs
 create mode 100644 src/Umbraco.Web/LegacyRequestInitializer.cs
 create mode 100644 src/Umbraco.Web/Mvc/ControllerExtensions.cs
 create mode 100644 src/Umbraco.Web/NiceUrls.cs
 create mode 100644 src/Umbraco.Web/PluginResolverExtensions.cs
 create mode 100644 src/Umbraco.Web/Routing/DocumentRequest.cs
 create mode 100644 src/Umbraco.Web/Routing/ILookup.cs
 create mode 100644 src/Umbraco.Web/Routing/ILookupNotFound.cs
 create mode 100644 src/Umbraco.Web/Routing/LookupByAlias.cs
 create mode 100644 src/Umbraco.Web/Routing/LookupById.cs
 create mode 100644 src/Umbraco.Web/Routing/LookupByPath.cs
 create mode 100644 src/Umbraco.Web/Routing/LookupByPathWithTemplate.cs
 create mode 100644 src/Umbraco.Web/Routing/LookupByProfile.cs
 create mode 100644 src/Umbraco.Web/Routing/LookupFor404.cs
 create mode 100644 src/Umbraco.Web/Routing/LookupWeightAttribute.cs
 create mode 100644 src/Umbraco.Web/Routing/RoutesCache.cs
 create mode 100644 src/Umbraco.Web/Routing/RoutingEnvironment.cs
 create mode 100644 src/Umbraco.Web/UmbracoContext.cs
 create mode 100644 src/Umbraco.Web/UmbracoModule.cs
 create mode 100644 src/Umbraco.Web/UrlUtility.cs

diff --git a/src/Umbraco.Core/ApplicationContext.cs b/src/Umbraco.Core/ApplicationContext.cs
new file mode 100644
index 0000000000..4f1e449a20
--- /dev/null
+++ b/src/Umbraco.Core/ApplicationContext.cs
@@ -0,0 +1,94 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Umbraco.Core
+{
+    /// <summary>
+    /// the Umbraco Application context
+    /// </summary>
+    /// <remarks>
+    /// one per AppDomain, represents the global Umbraco application
+    /// </remarks>
+    public class ApplicationContext
+    {
+
+        private static ApplicationContext _instance;
+        private static readonly object Locker = new object();
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="pluginResolver"></param>
+        public ApplicationContext(PluginResolver pluginResolver)
+        {
+            Plugins = pluginResolver;
+        }
+
+        /// <summary>
+        /// Singleton accessor
+        /// </summary>
+        public static ApplicationContext Current
+        {
+            get
+            {
+                return _instance;
+            }
+            set
+            {
+                lock (Locker)
+                {
+                    _instance = value;
+                }
+            }
+        }
+
+        // IsReady is set to true by the boot manager once it has successfully booted
+        // note - the original umbraco module checks on content.Instance in umbraco.dll
+        //   now, the boot task that setup the content store ensures that it is ready
+        bool _isReady = false;
+        public bool IsReady
+        {
+            get
+            {
+                return _isReady;
+            }
+            internal set
+            {
+                AssertIsNotReady();
+                _isReady = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets the plugin resolver for the application
+        /// </summary>
+        public PluginResolver Plugins { get; private set; }
+
+        // notes
+        //   GlobalSettings.ConfigurationStatus returns the value that's in the web.config, so it's the "configured version"
+        //   GlobalSettings.CurrentVersion returns the hard-coded "current version"
+        //   the system is configured if they match
+        //   if they don't, install runs, updates web.config (presumably) and updates GlobalSettings.ConfiguredStatus
+        //
+        //   then there is Application["umbracoNeedConfiguration"] which makes no sense... getting rid of it...
+        //
+        public bool IsConfigured
+        {
+            // fixme - let's do this for the time being
+            get { return umbraco.GlobalSettings.Configured; }
+        }
+
+        private void AssertIsReady()
+        {
+            if (!this.IsReady)
+                throw new Exception("ApplicationContext is not ready yet.");
+        }
+
+        private void AssertIsNotReady()
+        {
+            if (this.IsReady)
+                throw new Exception("ApplicationContext has already been initialized.");
+        }
+    }
+}
diff --git a/src/Umbraco.Core/PluginResolver.cs b/src/Umbraco.Core/PluginResolver.cs
new file mode 100644
index 0000000000..1ba705345d
--- /dev/null
+++ b/src/Umbraco.Core/PluginResolver.cs
@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Umbraco.Core
+{
+
+    /// <summary>
+    /// Used to resolve all plugin types
+    /// </summary>
+    /// <remarks>
+    /// 
+    /// This class should be used to resolve all plugin types, the TypeFinder should not be used directly!
+    /// 
+    /// This class can expose extension methods to resolve custom plugins
+    /// 
+    /// </remarks>
+    public class PluginResolver
+    {
+        
+    }
+}
diff --git a/src/Umbraco.Core/Properties/AssemblyInfo.cs b/src/Umbraco.Core/Properties/AssemblyInfo.cs
index cb87b228d3..41a997d394 100644
--- a/src/Umbraco.Core/Properties/AssemblyInfo.cs
+++ b/src/Umbraco.Core/Properties/AssemblyInfo.cs
@@ -18,3 +18,5 @@ using System.Runtime.InteropServices;
 // The following GUID is for the ID of the typelib if this project is exposed to COM
 [assembly: Guid("130a6b5c-50e7-4df3-a0dd-e9e7eb0b7c5c")]
 
+[assembly: InternalsVisibleTo("umbraco")]
+
diff --git a/src/Umbraco.Core/Umbraco.Core.csproj b/src/Umbraco.Core/Umbraco.Core.csproj
index b45944b80c..ca5650e3d8 100644
--- a/src/Umbraco.Core/Umbraco.Core.csproj
+++ b/src/Umbraco.Core/Umbraco.Core.csproj
@@ -44,14 +44,23 @@
     <Compile Include="..\SolutionInfo.cs">
       <Link>Properties\SolutionInfo.cs</Link>
     </Compile>
+    <Compile Include="ApplicationContext.cs" />
     <Compile Include="DelegateEqualityComparer.cs" />
     <Compile Include="EnumerableExtensions.cs" />
     <Compile Include="IfExtensions.cs" />
+    <Compile Include="PluginResolver.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="StringAliasCaseType.cs" />
     <Compile Include="StringExtensions.cs" />
+    <Compile Include="UriExtensions.cs" />
     <Compile Include="WriteLock.cs" />
   </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\umbraco.businesslogic\umbraco.businesslogic.csproj">
+      <Project>{E469A9CE-1BEC-423F-AC44-713CD72457EA}</Project>
+      <Name>umbraco.businesslogic</Name>
+    </ProjectReference>
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/src/Umbraco.Core/UriExtensions.cs b/src/Umbraco.Core/UriExtensions.cs
new file mode 100644
index 0000000000..8611e8bd71
--- /dev/null
+++ b/src/Umbraco.Core/UriExtensions.cs
@@ -0,0 +1,22 @@
+using System;
+using System.Text;
+
+namespace Umbraco.Core
+{
+    internal static class UriExtensions
+    {
+        public static Uri Rewrite(this Uri uri, string path, string query)
+        {
+            var pathAndQuery = new StringBuilder();
+
+            if (!path.StartsWith("/"))
+                pathAndQuery.Append("/");
+            pathAndQuery.Append(path);
+            if (!query.StartsWith("?"))
+                pathAndQuery.Append("?");
+            pathAndQuery.Append(query);
+
+            return new Uri(uri, pathAndQuery.ToString());
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Umbraco.Web/ContentStore.cs b/src/Umbraco.Web/ContentStore.cs
new file mode 100644
index 0000000000..d123342f22
--- /dev/null
+++ b/src/Umbraco.Web/ContentStore.cs
@@ -0,0 +1,148 @@
+using System;
+using System.Text;
+using System.Xml;
+using umbraco;
+using umbraco.interfaces;
+
+namespace Umbraco.Web
+{
+
+    /// <summary>
+    /// Used for the new routing system
+    /// </summary>
+    internal class ContentStore
+    {
+        private readonly UmbracoContext _umbracoContext;
+
+        public ContentStore(UmbracoContext umbracoContext)
+        {
+            _umbracoContext = umbracoContext;
+        }
+
+        public XmlNode GetNodeById(int nodeId)
+        {
+            return GetXml().GetElementById(nodeId.ToString());
+        }
+
+        public XmlNode GetNodeByRoute(string route)
+        {
+            string startNodeIdString = "0";
+            string path = route;
+            if (!route.StartsWith("/"))
+            {
+                int pos = route.IndexOf('/');
+                startNodeIdString = route.Substring(0, pos);
+                path = route.Substring(pos + 1);
+            }
+            int startNodeId = int.Parse(startNodeIdString);
+
+            var xpath = CreateXpathQuery(startNodeId, path);
+            //RequestContext.Current.Trace.Write(TraceCategory, "xpath='" + xpath + "'.");
+            return GetXml().SelectSingleNode(xpath);
+        }
+
+        public XmlNode GetNodeByUrlAlias(int rootNodeId, string alias)
+        {
+
+            // the alias may be "foo/bar" or "/foo/bar"
+            // there may be spaces as in "/foo/bar,  /foo/nil"
+            // these should probably be taken care of earlier on
+
+            alias = alias.TrimStart('/');
+            var xpathBuilder = new StringBuilder();
+            xpathBuilder.Append("/root");
+            if (rootNodeId > 0)
+                xpathBuilder.AppendFormat("//*[@isDoc and @id={0}]", rootNodeId);
+            xpathBuilder.Append("//*[@isDoc and (");
+            xpathBuilder.AppendFormat("contains(concat(',',translate(umbracoUrlAlias, ' ', ''),','),',{0},')", alias);
+            xpathBuilder.AppendFormat(" or contains(concat(',',translate(umbracoUrlAlias, ' ', ''),','),',/{0},')", alias);
+            xpathBuilder.Append(")]");
+
+            var xpath = xpathBuilder.ToString();
+            //RequestContext.Current.Trace.Write(TraceCategory, "xpath='" + xpath + "'.");
+            return GetXml().SelectSingleNode(xpath);
+        }
+
+        public XmlNode GetNodeParent(XmlNode node)
+        {
+            return node.ParentNode;
+        }
+
+        public string GetNodeProperty(XmlNode node, string propertyAlias)
+        {
+            if (propertyAlias.StartsWith("@"))
+            {
+                var attribute = node.Attributes.GetNamedItem(propertyAlias.Substring(1));
+                return attribute == null ? null : attribute.Value;
+            }
+            else
+            {
+                var propertyNode = node.SelectSingleNode("./" + propertyAlias);
+                return propertyNode == null ? null : propertyNode.InnerText;
+            }
+        }
+
+        XmlDocument GetXml()
+        {
+            // UmbracoModule will call LegacyRequestInitializer before anything else
+            // and that will create an UmbracoContext... so we should be safe here.
+            return _umbracoContext.GetXml();
+        }
+
+        static readonly char[] SlashChar = new char[] { '/' };
+
+        // allow hideTopLevelNodeFromPath overriding at runtime
+        protected virtual string CreateXpathQuery(int startNodeId, string path)
+        {
+            return CreateXpathQuery(startNodeId, path, GlobalSettings.HideTopLevelNodeFromPath);
+        }
+
+        protected string CreateXpathQuery(int startNodeId, string path, bool hideTopLevelNodeFromPath)
+        {
+            string xpath;
+
+            if (path == string.Empty || path == "/")
+            {
+                // if url is empty
+                if (startNodeId > 0)
+                {
+                    // if in a domain then use the root node of the domain
+                    xpath = string.Format("/root//*[@isDoc and @id={0}]", startNodeId);
+                }
+                else
+                {
+                    // if not in a domain - what is the default page?
+                    // let's say it is the first one in the tree, if any
+                    xpath = "/root/*[@isDoc and first]";
+                }
+            }
+            else
+            {
+                // if url is not empty, then use it to try lookup a matching page
+                var urlParts = path.Split(SlashChar, StringSplitOptions.RemoveEmptyEntries);
+                var xpathBuilder = new StringBuilder();
+                int partsIndex = 0;
+
+                xpathBuilder.Append("/root");
+
+                if (startNodeId == 0)
+                {
+                    if (hideTopLevelNodeFromPath)
+                        xpathBuilder.Append("/*[@isDoc]"); // first node is not in the url
+                }
+                else
+                {
+                    xpathBuilder.AppendFormat("//*[@isDoc and @id={0}]", startNodeId);
+                    if (!hideTopLevelNodeFromPath)
+                        xpathBuilder.AppendFormat("[@urlName='{0}']", urlParts[partsIndex++]); // first node is in the url
+                }
+                while (partsIndex < urlParts.Length)
+                    xpathBuilder.AppendFormat("/*[@isDoc and @urlName='{0}']", urlParts[partsIndex++]);
+
+                xpath = xpathBuilder.ToString();
+            }
+
+            return xpath;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Umbraco.Web/LegacyRequestInitializer.cs b/src/Umbraco.Web/LegacyRequestInitializer.cs
new file mode 100644
index 0000000000..301c9308ad
--- /dev/null
+++ b/src/Umbraco.Web/LegacyRequestInitializer.cs
@@ -0,0 +1,31 @@
+namespace Umbraco.Web
+{
+    /// <summary>
+    /// A legacy class for old style handling of URL requests
+    /// </summary>
+    internal class LegacyRequestInitializer
+    {
+        private readonly UmbracoContext _umbracoContext;
+
+        public LegacyRequestInitializer(UmbracoContext umbracoContext)
+        {
+            _umbracoContext = umbracoContext;
+        }
+
+        public void InitializeRequest()
+        {
+            var uri = _umbracoContext.OriginalUrl;
+
+            // legacy - umbOriginalUrl used by default.aspx to rewritepath so forms are happy
+            // legacy - umbOriginalUrl used by presentation/umbraco/urlRewriter/UrlRewriterFormWriter which handles <form action="..."
+            // legacy - umbOriginalUrl also in Umbraco's back-end!
+            _umbracoContext.HttpContext.Items["umbOriginalUrl"] = uri.AbsolutePath;
+            // legacy - umbPage used by default.aspx to get the "clean url"... whatever... fixme - we prob. don't want it anymore
+            _umbracoContext.HttpContext.Items["UmbPage"] = uri.AbsolutePath;
+            // legacy - virtualUrl used by presentation/template.cs to handle <form action="..."
+            // legacy - virtualUrl used by presentation/umbraco/urlRewriter/UrlRewriterFormWriter which handles <form action="..." too
+            // but, what if we RewritePath as soon as default.aspx begins, shouldn't it clear the form action?
+            _umbracoContext.HttpContext.Items["VirtualUrl"] = uri.PathAndQuery; //String.Format("{0}{1}{2}", uri.AbsolutePath, string.IsNullOrWhiteSpace(docreq.QueryString) ? "" : "?", docreq.QueryString);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Umbraco.Web/Mvc/ControllerExtensions.cs b/src/Umbraco.Web/Mvc/ControllerExtensions.cs
new file mode 100644
index 0000000000..10c38985ab
--- /dev/null
+++ b/src/Umbraco.Web/Mvc/ControllerExtensions.cs
@@ -0,0 +1,28 @@
+using System;
+
+namespace Umbraco.Web.Mvc
+{
+    public static class ControllerExtensions
+    {
+        /// <summary>
+        /// Return the controller name from the controller type
+        /// </summary>
+        /// <param name="controllerType"></param>
+        /// <returns></returns>
+        public static string GetControllerName(Type controllerType)
+        {
+            return controllerType.Name.Substring(0, controllerType.Name.LastIndexOf("Controller"));
+        }
+
+        /// <summary>
+        /// Return the controller name from the controller type
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <returns></returns>
+        /// <remarks></remarks>
+        public static string GetControllerName<T>()
+        {
+            return GetControllerName(typeof(T));
+        }
+    }
+}
diff --git a/src/Umbraco.Web/NiceUrls.cs b/src/Umbraco.Web/NiceUrls.cs
new file mode 100644
index 0000000000..ae2ff6cf70
--- /dev/null
+++ b/src/Umbraco.Web/NiceUrls.cs
@@ -0,0 +1,151 @@
+using System.Collections.Generic;
+using System.Linq;
+using Umbraco.Web.Routing;
+using umbraco;
+using umbraco.IO;
+using umbraco.cms.businesslogic.web;
+
+namespace Umbraco.Web
+{
+    internal class NiceUrls
+    {
+        public NiceUrls(ContentStore contentStore, UmbracoContext umbracoContext, RoutesCache routesCache)
+        {
+            _umbracoContext = umbracoContext;
+            _contentStore = contentStore;
+            _routesCache = routesCache;
+        }
+
+        private readonly UmbracoContext _umbracoContext;
+        private readonly ContentStore _contentStore;
+        private readonly RoutesCache _routesCache;
+
+        // note: this could be a parameter...
+        const string UrlNameProperty = "@urlName";
+
+        public virtual string GetNiceUrl(int nodeId)
+        {
+            int startNodeDepth = 1;
+            if (GlobalSettings.HideTopLevelNodeFromPath)
+                startNodeDepth = 2;
+
+            return GetNiceUrl(nodeId, startNodeDepth, false);
+        }
+
+        public virtual string GetNiceUrl(int nodeId, int startNodeDepth, bool forceDomain)
+        {
+            string route;
+            string path;
+
+            route = _routesCache.GetRoute(nodeId); // will not read cache if previewing
+            if (route != null)
+            {
+                int pos = route.IndexOf('/');
+                path = route.Substring(pos);
+
+                if (UmbracoSettings.UseDomainPrefixes || forceDomain)
+                {
+                    int rootNodeId = int.Parse(route.Substring(0, pos));
+                    if (rootNodeId > 0)
+                        return DomainAtNode(rootNodeId) + path;
+                }
+
+                return path;
+            }
+
+            // else there was not route in the cache, must build route...
+
+            var node = _contentStore.GetNodeById(nodeId);
+            if (node == null)
+                return "#"; // legacy wrote to the log here...
+
+            var parts = new List<string>();
+            var depth = int.Parse(_contentStore.GetNodeProperty(node, "@level"));
+            var id = nodeId;
+            string domain = null;
+            while (depth >= 1)
+            {
+                // if not hiding that depth, add urlName
+                if (depth >= startNodeDepth)
+                    parts.Add(_contentStore.GetNodeProperty(node, UrlNameProperty));
+
+                var tmp = DomainAtNode(id);
+                if (tmp != null)
+                {
+                    if (UmbracoSettings.UseDomainPrefixes || forceDomain)
+                        domain = tmp;
+                    break; // break to capture the id
+                }
+
+                node = _contentStore.GetNodeParent(node);
+                id = int.Parse(_contentStore.GetNodeProperty(node, "@id"));
+                depth--;
+            }
+
+            parts.Reverse();
+            path = "/" + string.Join("/", parts);
+            route = string.Format("{0}{1}", id, path);
+            _routesCache.Store(nodeId, route); // will not write if previewing
+
+            return FormatUrl(domain, path);
+        }
+
+        protected string DomainAtNode(int nodeId)
+        {
+            // be safe
+            if (nodeId <= 0)
+                return null;
+
+            // get domains defined on that node
+            Domain[] domains = Domain.GetDomainsById(nodeId);
+
+            // no domain set on that node, return null
+            if (domains.Length == 0)
+                return null;
+
+            // else try to find the first domain that matches the current request
+            // else take the first domain of the list
+            Domain domain = domains.FirstOrDefault(d => UrlUtility.IsBaseOf(d.Name, _umbracoContext.OriginalUrl)) ?? domains[0];
+
+            var domainName = domain.Name.TrimEnd('/');
+            domainName = UrlUtility.EnsureScheme(domainName, _umbracoContext.OriginalUrl.Scheme);
+            var pos = domainName.IndexOf("//");
+            pos = domainName.IndexOf("/", pos + 2);
+            if (pos > 0)
+                domainName = domainName.Substring(0, pos);
+
+            // return a scheme + host eg http://example.com with no trailing slash
+            return domainName;
+        }
+
+        protected string FormatUrl(string domain, string path)
+        {
+            if (domain == null) // else vdir needs to be in the domain
+            {
+                // get the application virtual dir (empty if no vdir)
+                string vdir = SystemDirectories.Root;
+                if (!string.IsNullOrEmpty(vdir))
+                    domain = "/" + vdir;
+            }
+
+            string url = (domain ?? "") + path;
+            if (path != "/")
+            {
+                // not at root
+                if (GlobalSettings.UseDirectoryUrls)
+                {
+                    // add trailing / if required
+                    if (UmbracoSettings.AddTrailingSlash)
+                        url += "/";
+                }
+                else
+                {
+                    // add .aspx
+                    url += ".aspx";
+                }
+            }
+
+            return url;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Umbraco.Web/PluginResolverExtensions.cs b/src/Umbraco.Web/PluginResolverExtensions.cs
new file mode 100644
index 0000000000..fbbf81c853
--- /dev/null
+++ b/src/Umbraco.Web/PluginResolverExtensions.cs
@@ -0,0 +1,55 @@
+using System;
+using System.Collections.Generic;
+using Umbraco.Core;
+using Umbraco.Web.Routing;
+using umbraco.BusinessLogic;
+using umbraco.BusinessLogic.Utils;
+
+namespace Umbraco.Web
+{
+    /// <summary>
+    /// Extension methods for the PluginResolver
+    /// </summary>
+    public static class PluginResolverExtensions
+    {
+
+        private static volatile IEnumerable<ILookup> _lookups;
+        private static readonly object Locker = new object();
+
+        /// <summary>
+        /// Returns all available ILookup objects
+        /// </summary>
+        /// <param name="plugins"></param>
+        /// <returns></returns>
+        internal static IEnumerable<ILookup> ResolveLookups(this PluginResolver plugins)
+        {
+            if (_lookups == null)
+            {
+                lock(Locker)
+                {
+                    if (_lookups == null)
+                    {
+                        var lookupTypes = TypeFinder.FindClassesOfType<ILookup>();
+                        var lookups = new List<ILookup>();
+                        foreach (var l in lookupTypes)
+                        {
+                            try
+                            {
+                                var typeInstance = Activator.CreateInstance(l) as ILookup;
+                                lookups.Add(typeInstance);
+                            }
+                            catch (Exception ex)
+                            {
+                                Log.Add(LogTypes.Error, -1, "Error loading ILookup: " + ex.ToString());
+                            }
+                        }
+                        //set the global
+                        _lookups = lookups;
+                    }
+                }
+            }
+            return _lookups;
+        }
+
+    }
+}
\ No newline at end of file
diff --git a/src/Umbraco.Web/Routing/DocumentRequest.cs b/src/Umbraco.Web/Routing/DocumentRequest.cs
new file mode 100644
index 0000000000..efa44a1881
--- /dev/null
+++ b/src/Umbraco.Web/Routing/DocumentRequest.cs
@@ -0,0 +1,499 @@
+using System;
+using System.Linq;
+using System.Text;
+using System.Xml;
+using System.Globalization;
+using System.Diagnostics;
+
+// legacy
+using umbraco.cms.businesslogic.web;
+using umbraco.cms.businesslogic.template;
+using umbraco.cms.businesslogic.member;
+using umbraco.cms.businesslogic.language;
+namespace Umbraco.Web.Routing
+{
+    internal class DocumentRequest
+    {
+        static readonly TraceSource Trace = new TraceSource("DocumentRequest");
+
+        public DocumentRequest(Uri uri, RoutingEnvironment lookups, UmbracoContext umbracoContext, NiceUrls niceUrls)
+        {
+            // register lookups
+            _environment = lookups;
+            _umbracoContext = umbracoContext;
+            _niceUrls = niceUrls;
+
+            // prepare the host
+            var host = uri.Host;
+
+            // fixme
+            //var serverVarHost = httpContext.Request.ServerVariables["X_UMBRACO_HOST"];
+            //if (!string.IsNullOrWhiteSpace(serverVarHost))
+            //{
+            //    host = serverVarHost;
+            //    RequestContext.Current.Trace.Write(TraceCategory, "Domain='" + host + "' (X_UMBRACO_HOST)");
+            //}
+
+            // initialize the host
+            this.Host = host;
+
+            // prepare the path
+            var path = uri.AbsolutePath;
+            path = path.Substring(UrlUtility.AppVirtualPathPrefix.Length); // remove virtual directory
+            path = path.TrimEnd('/'); // remove trailing /
+            if (!path.StartsWith("/")) // ensure it starts with /
+                path = "/" + path;
+            path = path.ToLower(); // make it all lowercase
+            //url = url.Replace('\'', '_'); // make it xpath compatible !! was in legacy, should be handled in xpath query, not here
+            if (path.EndsWith(".aspx")) // remove trailing .aspx
+                path = path.Substring(0, path.Length - ".aspx".Length);
+
+            // initialize the path
+            this.Path = path;
+
+            // initialize the query
+            this.QueryString = uri.Query.TrimStart('?');
+        }
+
+        #region Properties
+
+        // the id of the requested node, if any, else zero.
+        int _nodeId = 0;
+
+        // the requested node, if any, else null.
+        XmlNode _node = null;
+
+        /// <summary>
+        /// Gets the request host name.
+        /// </summary>
+        /// <remarks>This is the original uri's host, unless modified (fixme).</remarks>
+        public string Host { get; private set; }
+
+        /// <summary>
+        /// Gets the request path.
+        /// </summary>
+        /// <remarks>This is the original uri's path, cleaned up, without vdir, without .aspx, etc.</remarks>
+        public string Path { get; private set; }
+
+        /// <summary>
+        /// Gets the request query string.
+        /// </summary>
+        /// <remarks>This is the original uri's querystring, without the initial '?'.</remarks>
+        public string QueryString { get; private set; }
+
+        /// <summary>
+        /// Gets or sets the document request's domain.
+        /// </summary>
+        public Domain Domain { get; private set; }
+
+        /// <summary>
+        /// Gets a value indicating whether the document request has a domain.
+        /// </summary>
+        public bool HasDomain
+        {
+            get { return this.Domain != null; }
+        }
+
+        /// <summary>
+        /// Gets or sets the document request's culture
+        /// </summary>
+        public CultureInfo Culture { get; private set; }
+
+        // fixme - do we want to have an ordered list of alternate cultures,
+        //         to allow for fallbacks when doing dictionnary lookup and such?
+
+        /// <summary>
+        /// Gets or sets the document request's document xml node.
+        /// </summary>
+        public XmlNode Node
+        {
+            get
+            {
+                return _node;
+            }
+            set
+            {
+                _node = value;
+                this.Template = null;
+                if (_node != null)
+                    _nodeId = int.Parse(_environment.ContentStore.GetNodeProperty(_node, "@id"));
+                else
+                    _nodeId = 0;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the document request's template.
+        /// </summary>
+        public Template Template { get; set; }
+
+        /// <summary>
+        /// Gets a value indicating whether the document request has a template.
+        /// </summary>
+        public bool HasTemplate
+        {
+            get { return this.Template != null; }
+        }
+
+        /// <summary>
+        /// Gets the id of the document.
+        /// </summary>
+        /// <exception cref="InvalidOperationException">Thrown when the document request has no document.</exception>
+        public int NodeId
+        {
+            get
+            {
+                if (this.Node == null)
+                    throw new InvalidOperationException("DocumentRequest has no document.");
+                return _nodeId;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the document request has a document.
+        /// </summary>
+        public bool HasNode
+        {
+            get { return this.Node != null; }
+        }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether the requested document could not be found.
+        /// </summary>
+        public bool Is404 { get; private set; }
+
+        /// <summary>
+        /// Gets a value indicating whether the document request triggers a redirect.
+        /// </summary>
+        public bool IsRedirect { get { return !string.IsNullOrWhiteSpace(this.RedirectUrl); } }
+
+        /// <summary>
+        /// Gets the url to redirect to, when the document request triggers a redirect.
+        /// </summary>
+        public string RedirectUrl { get; set; }
+
+        #endregion
+
+        #region Resolve
+
+        readonly RoutingEnvironment _environment;
+        private readonly UmbracoContext _umbracoContext;
+        private readonly NiceUrls _niceUrls;
+
+        /// <summary>
+        /// Determines the site root (if any) matching the http request.
+        /// </summary>
+        /// <param name="host">The host name part of the http request, eg. <c>www.example.com</c>.</param>
+        /// <param name="url">The url part of the http request, starting with a slash, eg. <c>/foo/bar</c>.</param>
+        /// <returns>A value indicating whether a domain was found.</returns>
+        public bool ResolveSiteRoot()
+        {
+            const string tracePrefix = "ResolveSiteRoot: ";
+
+            // note - we are not handling schemes nor ports here.
+
+            Trace.TraceInformation("{0}Host=\"{1}\"", tracePrefix, this.Host);
+
+            Domain domain = null;
+
+            // get domains, those with a slash coming first, so that 'foo.com/en' takes precedence over 'foo.com'.
+            // domains should NOT begin with 'http://'.
+            var domains = Domain.GetDomains().OrderByDescending(od => od.Name.IndexOf('/'));
+
+            // try to find a domain matching the current request
+            string urlWithDomain = UrlUtility.EnsureScheme(this.Host + this.Path, "http"); // FIXME-NICEURL - current Uri?!
+            domain = domains.FirstOrDefault(d => UrlUtility.IsBaseOf(d.Name, urlWithDomain));
+
+            // handle domain
+            if (domain != null)
+            {
+                // matching an existing domain
+                Trace.TraceInformation("{0}Matches domain=\"{1}\", rootId={2}, culture=\"{3}\"",
+                                       tracePrefix,
+                                       domain.Name, domain.RootNodeId, domain.Language.CultureAlias);
+
+                this.Domain = domain;
+                this.Culture = new CultureInfo(domain.Language.CultureAlias);
+
+                // canonical?
+                // FIXME - NOT IMPLEMENTED AT THE MOMENT + THEN WE WOULD RETURN THE CANONICAL DOMAIN AND ASK FOR REDIRECT
+                // but then how do I translate if domain is bar.com/en ? will depend on how we handle domains
+            }
+            else
+            {
+                // not matching any existing domain
+                Trace.TraceInformation("{0}Matches no domain", tracePrefix);
+
+                var defaultLanguage = Language.GetAllAsList().FirstOrDefault();
+                this.Culture = defaultLanguage == null ? CultureInfo.CurrentUICulture : new CultureInfo(defaultLanguage.CultureAlias);
+            }
+
+            Trace.TraceInformation("{0}Culture=\"{1}\"", tracePrefix, this.Culture.Name);
+            return this.Domain != null;
+        }
+
+        /// <summary>
+        /// Determines the Umbraco document (if any) matching the http request.
+        /// </summary>
+        /// <returns>A value indicating whether a document and template nave been found.</returns>
+        public bool ResolveDocument()
+        {
+            const string tracePrefix = "ResolveDocument: ";
+            Trace.TraceInformation("{0}Path=\"{1}\"", tracePrefix, this.Path);
+
+            // look for the document
+            // the first successful lookup, if any, will set this.Node, and may also set this.Template
+            // some lookups may implement caching
+            Trace.TraceInformation("{0}Begin lookup", tracePrefix);
+            _environment.Lookups.Any(lookup => lookup.LookupDocument(this));
+            Trace.TraceInformation("{0}End lookup, {1}", tracePrefix, (this.HasNode ? "a document was found" : "no document was found"));
+
+            // fixme - not handling umbracoRedirect
+            // should come after internal redirects
+            // so after ResolveDocument2() => docreq.IsRedirect => handled by the module!
+
+            // handle not-found, redirects, access, template
+            ResolveDocument2();
+
+            // handle umbracoRedirect (moved from umbraco.page)
+            FollowRedirect();
+
+            bool resolved = this.HasNode && this.HasTemplate;
+            return resolved;
+        }
+
+        /// <summary>
+        /// Performs the document resolution second pass.
+        /// </summary>
+        /// <remarks>The second pass consists in handling "not found", internal redirects, access validation, and template.</remarks>
+        void ResolveDocument2()
+        {
+            const string tracePrefix = "ResolveDocument2: ";
+
+            // handle "not found", follow internal redirects, validate access, template
+            // because these might loop, we have to have some sort of infinite loop detection 
+            int i = 0, j = 0;
+            const int maxLoop = 12;
+            do
+            {
+                Trace.TraceInformation("{0}{1}", tracePrefix, (i == 0 ? "Begin" : "Loop"));
+
+                // handle not found
+                if (!this.HasNode)
+                {
+                    this.Is404 = true;
+                    Trace.TraceInformation("{0}No document, try notFound lookup", tracePrefix);
+
+                    // if it fails then give up, there isn't much more that we can do
+                    if (_environment.LookupNotFound == null || !_environment.LookupNotFound.LookupDocument(this))
+                    {
+                        Trace.TraceInformation("{0}Failed to find a document, give up", tracePrefix);
+                        break;
+                    }
+                    else
+                    {
+                        Trace.TraceInformation("{0}Found a document", tracePrefix);
+                    }
+                }
+
+                // follow internal redirects as long as it's not running out of control ie infinite loop of some sort
+                j = 0;
+                while (FollowInternalRedirects() && j++ < maxLoop) ;
+                if (j == maxLoop) // we're running out of control
+                    break;
+
+                // ensure access
+                if (this.HasNode)
+                    EnsureNodeAccess();
+
+                // resolve template
+                if (this.HasNode)
+                    ResolveTemplate();
+
+                // loop while we don't have page, ie the redirect or access
+                // got us to nowhere and now we need to run the notFoundLookup again
+                // as long as it's not running out of control ie infinite loop of some sort
+
+            } while (!this.HasNode && i++ < maxLoop);
+
+            if (i == maxLoop || j == maxLoop)
+            {
+                Trace.TraceInformation("{0}Looks like we're running into an infinite loop, abort", tracePrefix);
+                this.Node = null;
+            }
+            Trace.TraceInformation("{0}End", tracePrefix);
+        }
+
+        /// <summary>
+        /// Follows internal redirections through the <c>umbracoInternalRedirectId</c> document property.
+        /// </summary>
+        /// <returns>A value indicating whether redirection took place and led to a new published document.</returns>
+        /// <remarks>Redirecting to a different site root and/or culture will not pick the new site root nor the new culture.</remarks>
+        bool FollowInternalRedirects()
+        {
+            const string tracePrefix = "FollowInternalRedirects: ";
+
+            if (this.Node == null)
+                throw new InvalidOperationException("There is no node.");
+
+            bool redirect = false;
+            string internalRedirect = _environment.ContentStore.GetNodeProperty(this.Node, "umbracoInternalRedirectId");
+
+            if (!string.IsNullOrWhiteSpace(internalRedirect))
+            {
+                Trace.TraceInformation("{0}Found umbracoInternalRedirectId={1}", tracePrefix, internalRedirect);
+
+                int internalRedirectId;
+                if (!int.TryParse(internalRedirect, out internalRedirectId))
+                    internalRedirectId = -1;
+
+                if (internalRedirectId <= 0)
+                {
+                    // bad redirect
+                    this.Node = null;
+                    Trace.TraceInformation("{0}Failed to redirect to id={1}: invalid value", tracePrefix, internalRedirect);
+                }
+                else if (internalRedirectId == this.NodeId)
+                {
+                    // redirect to self
+                    Trace.TraceInformation("{0}Redirecting to self, ignore", tracePrefix);
+                }
+                else
+                {
+                    // redirect to another page
+                    var node = _environment.ContentStore.GetNodeById(internalRedirectId);
+                    this.Node = node;
+                    if (node != null)
+                    {
+                        redirect = true;
+                        Trace.TraceInformation("{0}Redirecting to id={1}", tracePrefix, internalRedirectId);
+                    }
+                    else
+                    {
+                        Trace.TraceInformation("{0}Failed to redirect to id={1}: no such published document", tracePrefix, internalRedirectId);
+                    }
+                }
+            }
+
+            return redirect;
+        }
+
+        /// <summary>
+        /// Ensures that access to current node is permitted.
+        /// </summary>
+        /// <remarks>Redirecting to a different site root and/or culture will not pick the new site root nor the new culture.</remarks>
+        void EnsureNodeAccess()
+        {
+            const string tracePrefix = "EnsurePageAccess: ";
+
+            if (this.Node == null)
+                throw new InvalidOperationException("There is no node.");
+
+            var path = _environment.ContentStore.GetNodeProperty(this.Node, "@path");
+
+            if (Access.IsProtected(this.NodeId, path))
+            {
+                Trace.TraceInformation("{0}Page is protected, check for access", tracePrefix);
+
+                var user = System.Web.Security.Membership.GetUser();
+
+                if (user == null || !Member.IsLoggedOn())
+                {
+                    Trace.TraceInformation("{0}Not logged in, redirect to login page", tracePrefix);
+                    var loginPageId = Access.GetLoginPage(path);
+                    if (loginPageId != this.NodeId)
+                        this.Node = _environment.ContentStore.GetNodeById(loginPageId);
+                }
+                else if (!Access.HasAccces(this.NodeId, user.ProviderUserKey))
+                {
+                    Trace.TraceInformation("{0}Current member has not access, redirect to error page", tracePrefix);
+                    var errorPageId = Access.GetErrorPage(path);
+                    if (errorPageId != this.NodeId)
+                        this.Node = _environment.ContentStore.GetNodeById(errorPageId);
+                }
+                else
+                {
+                    Trace.TraceInformation("{0}Current member has access", tracePrefix);
+                }
+            }
+            else
+            {
+                Trace.TraceInformation("{0}Page is not protected", tracePrefix);
+            }
+        }
+
+        /// <summary>
+        /// Resolves a template for the current node.
+        /// </summary>
+        void ResolveTemplate()
+        {
+            const string tracePrefix = "ResolveTemplate: ";
+
+            if (this.Node == null)
+                throw new InvalidOperationException("There is no node.");
+
+            var templateAlias = _umbracoContext.HttpContext.Request.QueryString["altTemplate"];
+            if (string.IsNullOrWhiteSpace(templateAlias))
+                templateAlias = _umbracoContext.HttpContext.Request.Form["altTemplate"];
+
+            // fixme - we might want to support cookies?!? NO but provide a hook to change the template
+
+            if (!this.HasTemplate || !string.IsNullOrWhiteSpace(templateAlias))
+            {
+                if (string.IsNullOrWhiteSpace(templateAlias))
+                {
+                    templateAlias = _environment.ContentStore.GetNodeProperty(this.Node, "@template");
+                    Trace.TraceInformation("{0}Look for template id={1}", tracePrefix, templateAlias);
+                    int templateId;
+                    if (!int.TryParse(templateAlias, out templateId))
+                        templateId = 0;
+                    this.Template = templateId > 0 ? new Template(templateId) : null;
+                }
+                else
+                {
+                    Trace.TraceInformation("{0}Look for template alias=\"{1}\" (altTemplate)", tracePrefix, templateAlias);
+                    this.Template = Template.GetByAlias(templateAlias);
+                }
+
+                if (!this.HasTemplate)
+                {
+                    Trace.TraceInformation("{0}No template was found", tracePrefix);
+
+                    //TODO: I like the idea of this new setting, but lets get this in to the core at a later time, for now lets just get the basics working.
+                    //if (Settings.HandleMissingTemplateAs404)
+                    //{
+                    //    this.Node = null;
+                    //    Trace.TraceInformation("{0}Assume page not found (404)", tracePrefix);
+                    //}
+
+                    // else we have no template
+                    // and there isn't much more we can do about it
+                }
+                else
+                {
+                    Trace.TraceInformation("{0}Found", tracePrefix);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Follows external redirection through <c>umbracoRedirect</c> document property.
+        /// </summary>
+        void FollowRedirect()
+        {
+            if (this.HasNode)
+            {
+                int redirectId;
+                if (!int.TryParse(_environment.ContentStore.GetNodeProperty(this.Node, "umbracoRedirect"), out redirectId))
+                    redirectId = -1;
+                string redirectUrl = "#";
+                if (redirectId > 0)
+                    redirectUrl = _niceUrls.GetNiceUrl(redirectId);
+                if (redirectUrl != "#")
+                    this.RedirectUrl = redirectUrl;
+            }
+        }
+
+        #endregion
+    }
+}
\ No newline at end of file
diff --git a/src/Umbraco.Web/Routing/ILookup.cs b/src/Umbraco.Web/Routing/ILookup.cs
new file mode 100644
index 0000000000..3dc00d70ef
--- /dev/null
+++ b/src/Umbraco.Web/Routing/ILookup.cs
@@ -0,0 +1,9 @@
+namespace Umbraco.Web.Routing
+{
+
+
+    internal interface ILookup
+    {
+        bool LookupDocument(DocumentRequest docRequest);
+    }
+}
\ No newline at end of file
diff --git a/src/Umbraco.Web/Routing/ILookupNotFound.cs b/src/Umbraco.Web/Routing/ILookupNotFound.cs
new file mode 100644
index 0000000000..1d1745e74f
--- /dev/null
+++ b/src/Umbraco.Web/Routing/ILookupNotFound.cs
@@ -0,0 +1,7 @@
+namespace Umbraco.Web.Routing
+{
+    internal interface ILookupNotFound
+    {
+        bool LookupDocument(DocumentRequest docRequest);
+    }
+}
\ No newline at end of file
diff --git a/src/Umbraco.Web/Routing/LookupByAlias.cs b/src/Umbraco.Web/Routing/LookupByAlias.cs
new file mode 100644
index 0000000000..8d9cf2c081
--- /dev/null
+++ b/src/Umbraco.Web/Routing/LookupByAlias.cs
@@ -0,0 +1,45 @@
+using System.Diagnostics;
+using System.Xml;
+
+namespace Umbraco.Web.Routing
+{
+    // handles /just/about/anything where /just/about/anything is the umbracoUrlAlias property of a document
+    //
+    // the alias is the full path to the document
+    // there can be more than one alias, separated by commas
+    // at the moment aliases are not cleaned up into nice urls
+    //
+
+    [LookupWeight(50)]
+    internal class LookupByAlias : ILookup
+    {
+        public LookupByAlias(ContentStore contentStore)
+        {
+            _contentStore = contentStore;
+        }
+
+        static readonly TraceSource Trace = new TraceSource("LookupByAlias");
+
+        readonly ContentStore _contentStore;
+
+        public bool LookupDocument(DocumentRequest docreq)
+        {
+            XmlNode node = null;
+
+            if (docreq.Path != "/") // no alias if "/"
+            {
+                node = _contentStore.GetNodeByUrlAlias(docreq.HasDomain ? docreq.Domain.RootNodeId : 0, docreq.Path);
+                if (node != null)
+                {
+                    Trace.TraceInformation("Path \"{0}\" is an alias for id={1}", docreq.Path, docreq.NodeId);
+                    docreq.Node = node;
+                }
+            }
+
+            if (node == null)
+                Trace.TraceInformation("Not an alias");
+
+            return node != null;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Umbraco.Web/Routing/LookupById.cs b/src/Umbraco.Web/Routing/LookupById.cs
new file mode 100644
index 0000000000..8370df4ecc
--- /dev/null
+++ b/src/Umbraco.Web/Routing/LookupById.cs
@@ -0,0 +1,65 @@
+using System;
+using System.Diagnostics;
+using System.Xml;
+
+namespace Umbraco.Web.Routing
+{
+
+    // handles /1234 where 1234 is the id of a document
+    //
+    [LookupWeight(20)]
+    internal class LookupById : ILookup
+    {
+        public LookupById(ContentStore contentStore)
+        {
+            _contentStore = contentStore;
+        }
+
+        static readonly TraceSource Trace = new TraceSource("LookupById");
+
+        readonly ContentStore _contentStore;
+
+        ////[Import]
+        //IContentStore ContentStoreImport
+        //{
+        //    set { _contentStore = value; }
+        //}
+
+        //public LookupById()
+        //{ }
+
+        public bool LookupDocument(DocumentRequest docreq)
+        {
+            XmlNode node = null;
+
+            int nodeId = -1;
+            if (docreq.Path != "/") // no id if "/"
+            {
+                string noSlashPath = docreq.Path.Substring(1);
+
+                if (!Int32.TryParse(noSlashPath, out nodeId))
+                    nodeId = -1;
+
+                if (nodeId > 0)
+                {
+                    Trace.TraceInformation("Id={0}", nodeId);
+                    node = _contentStore.GetNodeById(nodeId);
+                    if (node != null)
+                    {
+                        docreq.Node = node;
+                        Trace.TraceInformation("Found node with id={0}", docreq.NodeId);
+                    }
+                    else
+                    {
+                        nodeId = -1; // trigger message below
+                    }
+                }
+            }
+
+            if (nodeId == -1)
+                Trace.TraceInformation("Not a node id");
+
+            return node != null;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Umbraco.Web/Routing/LookupByPath.cs b/src/Umbraco.Web/Routing/LookupByPath.cs
new file mode 100644
index 0000000000..d5e9dbba19
--- /dev/null
+++ b/src/Umbraco.Web/Routing/LookupByPath.cs
@@ -0,0 +1,69 @@
+using System.Diagnostics;
+using System.Xml;
+
+namespace Umbraco.Web.Routing
+{
+    // handles "/foo/bar" where "/foo/bar" is the path to a document
+    //
+
+    [LookupWeight(10)]
+    internal class LookupByPath : ILookup
+    {
+        public LookupByPath(ContentStore contentStore, RoutesCache routesCache)
+        {
+            ContentStore = contentStore;
+            RoutesCache = routesCache;
+        }
+
+        static readonly TraceSource Trace = new TraceSource("LookupByPath");
+
+        protected ContentStore ContentStore;
+        protected RoutesCache RoutesCache;
+
+        public virtual bool LookupDocument(DocumentRequest docreq)
+        {
+            var route = docreq.HasDomain ? (docreq.Domain.RootNodeId.ToString() + docreq.Path) : docreq.Path;
+            var node = LookupDocumentNode(docreq, route);
+            return node != null;
+        }
+
+        protected XmlNode LookupDocumentNode(DocumentRequest docreq, string route)
+        {
+            Trace.TraceInformation("Test route \"{0}\"", route);
+
+            var nodeId = RoutesCache.GetNodeId(route);
+            XmlNode node = null;
+            if (nodeId > 0)
+            {
+                node = ContentStore.GetNodeById(nodeId);
+                if (node != null)
+                {
+                    docreq.Node = node;
+                    Trace.TraceInformation("Cache hit, id={0}", nodeId);
+                }
+                else
+                {
+                    RoutesCache.ClearNode(nodeId);
+                }
+            }
+
+            if (node == null)
+            {
+                Trace.TraceInformation("Cache miss, query");
+                node = ContentStore.GetNodeByRoute(route);
+                if (node != null)
+                {
+                    docreq.Node = node;
+                    Trace.TraceInformation("Query matches, id={0}", docreq.NodeId);
+                    RoutesCache.Store(docreq.NodeId, route);
+                }
+                else
+                {
+                    Trace.TraceInformation("Query does not match");
+                }
+            }
+
+            return node;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Umbraco.Web/Routing/LookupByPathWithTemplate.cs b/src/Umbraco.Web/Routing/LookupByPathWithTemplate.cs
new file mode 100644
index 0000000000..1b91be23aa
--- /dev/null
+++ b/src/Umbraco.Web/Routing/LookupByPathWithTemplate.cs
@@ -0,0 +1,55 @@
+using System.Diagnostics;
+using System.Xml;
+using umbraco.cms.businesslogic.template;
+
+namespace Umbraco.Web.Routing
+{
+
+    // handles /foo/bar/<template> where <template> is a valid template alias
+    // and /foo/bar the nice url of a document
+    //
+    [LookupWeight(30)]
+    internal class LookupByPathWithTemplate : LookupByPath, ILookup
+    {
+        static readonly TraceSource Trace = new TraceSource("LookupByPathWithTemplate");
+
+        public LookupByPathWithTemplate(ContentStore contentStore, RoutesCache routesCache)
+            : base(contentStore, routesCache)
+        {
+        }
+
+        public override bool LookupDocument(DocumentRequest docreq)
+        {
+            XmlNode node = null;
+
+            if (docreq.Path != "/") // no template if "/"
+            {
+                var pos = docreq.Path.LastIndexOf('/');
+                var templateAlias = docreq.Path.Substring(pos + 1);
+                var path = docreq.Path.Substring(0, pos);
+
+                var template = Template.GetByAlias(templateAlias);
+                if (template != null)
+                {
+                    Trace.TraceInformation("Valid template: \"{0}\"", templateAlias);
+
+                    var route = docreq.HasDomain ? (docreq.Domain.RootNodeId.ToString() + path) : path;
+                    node = LookupDocumentNode(docreq, route);
+
+                    if (node != null)
+                        docreq.Template = template;
+                }
+                else
+                {
+                    Trace.TraceInformation("Not a valid template: \"{0}\"", templateAlias);
+                }
+            }
+            else
+            {
+                Trace.TraceInformation("No template in path \"/\"");
+            }
+
+            return node != null;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Umbraco.Web/Routing/LookupByProfile.cs b/src/Umbraco.Web/Routing/LookupByProfile.cs
new file mode 100644
index 0000000000..a65eafac2e
--- /dev/null
+++ b/src/Umbraco.Web/Routing/LookupByProfile.cs
@@ -0,0 +1,59 @@
+using System.Diagnostics;
+using System.Xml;
+using umbraco;
+
+namespace Umbraco.Web.Routing
+{
+
+    // lookup /<profile>/<login> where <profile> is the profile page and <login> a login
+    // this is a faily limited way of doing it, it should better be done with a rewriting
+    // rule that would support multiple profile pages for multilingual websites, etc.
+    //
+    // we're keeping it here only for backward compatibility.
+    //
+    [LookupWeight(40)]
+    internal class LookupByProfile : LookupByPath, ILookup
+    {
+        private readonly UmbracoContext _umbracoContext;
+        static readonly TraceSource Trace = new TraceSource("LookupByProfile");
+
+
+        public LookupByProfile(ContentStore contentStore, RoutesCache routesCache, UmbracoContext umbracoContext)
+            : base(contentStore, routesCache)
+        {
+            _umbracoContext = umbracoContext;
+        }
+
+        public override bool LookupDocument(DocumentRequest docreq)
+        {
+            XmlNode node = null;
+
+            bool isProfile = false;
+            var pos = docreq.Path.LastIndexOf('/');
+            if (pos > 0)
+            {
+                var memberLogin = docreq.Path.Substring(pos + 1);
+                var path = docreq.Path.Substring(0, pos);
+
+                if (path == GlobalSettings.ProfileUrl)
+                {
+                    isProfile = true;
+                    Trace.TraceInformation("Path \"{0}\" is the profile path", path);
+
+                    var route = docreq.HasDomain ? (docreq.Domain.RootNodeId.ToString() + path) : path;
+                    node = LookupDocumentNode(docreq, route);
+
+                    if (node != null)
+                        _umbracoContext.HttpContext.Items["umbMemberLogin"] = memberLogin;
+                    else
+                        Trace.TraceInformation("No document matching profile path?");
+                }
+            }
+
+            if (!isProfile)
+                Trace.TraceInformation("Not the profile path");
+
+            return node != null;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Umbraco.Web/Routing/LookupFor404.cs b/src/Umbraco.Web/Routing/LookupFor404.cs
new file mode 100644
index 0000000000..08bc6ec0cd
--- /dev/null
+++ b/src/Umbraco.Web/Routing/LookupFor404.cs
@@ -0,0 +1,153 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Reflection;
+using System.Web;
+using System.Xml;
+using umbraco.IO;
+using umbraco.interfaces;
+
+namespace Umbraco.Web.Routing
+{
+    internal class LookupFor404 : ILookupNotFound
+    {
+        public LookupFor404(ContentStore contentStore)
+        {
+            _contentStore = contentStore;
+        }
+
+        static TraceSource _trace = new TraceSource("LookupByAlias");
+
+        private readonly ContentStore _contentStore;
+
+        public bool LookupDocument(DocumentRequest docRequest)
+        {
+            docRequest.Node = HandlePageNotFound(docRequest.Path);
+            return docRequest.HasNode;
+        }
+
+        // --------
+
+        // copied from presentation/requestHandler
+        // temporary!!
+        XmlNode HandlePageNotFound(string url)
+        {
+            HttpContext.Current.Trace.Write("NotFoundHandler", string.Format("Running for url='{0}'.", url));
+            XmlNode currentPage = null;
+
+            foreach (var handler in GetNotFoundHandlers())
+            {
+                if (handler.Execute(url) && handler.redirectID > 0)
+                {
+                    //currentPage = umbracoContent.GetElementById(handler.redirectID.ToString());
+                    currentPage = _contentStore.GetNodeById(handler.redirectID);
+
+                    // FIXME - could it be null?
+
+                    HttpContext.Current.Trace.Write("NotFoundHandler",
+                                                    string.Format("Handler '{0}' found node with id={1}.", handler.GetType().FullName, handler.redirectID));
+
+                    //// check for caching
+                    //if (handler.CacheUrl)
+                    //{
+                    //    if (url.StartsWith("/"))
+                    //        url = "/" + url;
+
+                    //    var cacheKey = (currentDomain == null ? "" : currentDomain.Name) + url;
+                    //    var culture = currentDomain == null ? null : currentDomain.Language.CultureAlias;
+                    //    SetCache(cacheKey, new CacheEntry(handler.redirectID.ToString(), culture));
+
+                    //    HttpContext.Current.Trace.Write("NotFoundHandler",
+                    //        string.Format("Added to cache '{0}', {1}.", url, handler.redirectID));
+                    //}
+
+                    break;
+                }
+            }
+
+            return currentPage;
+        }
+
+        static List<Type> _customHandlerTypes = null;
+        static readonly object CustomHandlerTypesLock = new object();
+
+        void InitializeNotFoundHandlers()
+        {
+            // initialize handlers
+            // create the definition cache
+
+            HttpContext.Current.Trace.Write("NotFoundHandler", "Registering custom handlers.");
+
+            _customHandlerTypes = new List<Type>();
+
+            var customHandlers = new XmlDocument();
+            customHandlers.Load(IOHelper.MapPath(SystemFiles.NotFoundhandlersConfig));
+
+            foreach (XmlNode n in customHandlers.DocumentElement.ChildNodes)
+            {
+                var assemblyName = n.Attributes.GetNamedItem("assembly").Value;
+
+                // skip those that are in umbraco.dll because we have
+                // replaced them with ILookups already -- so we just
+                // want to load user-defined NotFound handlers...
+                if (assemblyName == "umbraco")
+                    continue;
+
+                var typeName = n.Attributes.GetNamedItem("type").Value;
+                string ns = assemblyName;
+                var nsAttr = n.Attributes.GetNamedItem("namespace");
+                if (nsAttr != null && !string.IsNullOrWhiteSpace(nsAttr.Value))
+                    ns = nsAttr.Value;
+                Type type = null;
+
+                HttpContext.Current.Trace.Write("NotFoundHandler",
+                                                string.Format("Registering '{0}.{1},{2}'.", ns, typeName, assemblyName));
+
+                try
+                {
+                    var assembly = Assembly.LoadFrom(IOHelper.MapPath(SystemDirectories.Bin + "/" + assemblyName + ".dll"));
+                    type = assembly.GetType(ns + "." + typeName);
+                }
+                catch (Exception e)
+                {
+                    HttpContext.Current.Trace.Warn("NotFoundHandler", "Error registering handler, ignoring.", e);
+                }
+
+                if (type != null)
+                    _customHandlerTypes.Add(type);
+            }
+        }
+
+        IEnumerable<INotFoundHandler> GetNotFoundHandlers()
+        {
+            // instanciate new handlers
+            // using definition cache
+
+            lock (CustomHandlerTypesLock)
+            {
+                if (_customHandlerTypes == null)
+                    InitializeNotFoundHandlers();
+            }
+
+            var handlers = new List<INotFoundHandler>();
+
+            foreach (var type in _customHandlerTypes)
+            {
+                try
+                {
+                    var handler = Activator.CreateInstance(type) as INotFoundHandler;
+                    if (handler != null)
+                        handlers.Add(handler);
+                }
+                catch (Exception e)
+                {
+                    HttpContext.Current.Trace.Warn("NotFoundHandler",
+                                                   string.Format("Error instanciating handler {0}, ignoring.", type.FullName),
+                                                   e);
+                }
+            }
+
+            return handlers;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Umbraco.Web/Routing/LookupWeightAttribute.cs b/src/Umbraco.Web/Routing/LookupWeightAttribute.cs
new file mode 100644
index 0000000000..8e120b4455
--- /dev/null
+++ b/src/Umbraco.Web/Routing/LookupWeightAttribute.cs
@@ -0,0 +1,32 @@
+using System;
+
+namespace Umbraco.Web.Routing
+{
+    /// <summary>
+    /// Specifies the relative weight of an ILookup.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
+    internal class LookupWeightAttribute : Attribute
+    {
+
+        /// <summary>
+        /// Gets the default part weight.
+        /// </summary>
+        public const int DefaultWeight = 100;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="LookupWeightAttribute"/> class with the weight.
+        /// </summary>
+        /// <param name="weight">The weight of the part.</param>
+        public LookupWeightAttribute(int weight)
+            : base()
+        {
+            this.Weight = weight;
+        }
+
+        /// <summary>
+        /// Gets the weight of the part.
+        /// </summary>
+        public int Weight { get; private set; }
+    }
+}
\ No newline at end of file
diff --git a/src/Umbraco.Web/Routing/RoutesCache.cs b/src/Umbraco.Web/Routing/RoutesCache.cs
new file mode 100644
index 0000000000..d366dc23f9
--- /dev/null
+++ b/src/Umbraco.Web/Routing/RoutesCache.cs
@@ -0,0 +1,81 @@
+using System.Collections.Generic;
+
+namespace Umbraco.Web.Routing
+{
+    internal class RoutesCache
+    {
+        private readonly object _lock = new object();
+        private Dictionary<int, string> _routes;
+        private Dictionary<string, int> _nodeIds;
+
+        private readonly UmbracoContext _umbracoContext;
+
+        public RoutesCache(UmbracoContext umbracoContext)
+        {
+            _umbracoContext = umbracoContext;
+
+            Clear();
+
+            // here we should register handlers to clear the cache when content changes
+            // at the moment this is done by library, which clears everything when content changed
+            //
+            // but really, we should do some partial refreshes!
+            // otherwise, we could even cache 404 errors...
+        }
+
+        public void Store(int nodeId, string route)
+        {
+            if (_umbracoContext.InPreviewMode)
+                return;
+
+            lock (_lock)
+            {
+                _routes[nodeId] = route;
+                _nodeIds[route] = nodeId;
+            }
+        }
+
+        public string GetRoute(int nodeId)
+        {
+            if (_umbracoContext.InPreviewMode)
+                return null;
+
+            lock (_lock)
+            {
+                return _routes.ContainsKey(nodeId) ? _routes[nodeId] : null;
+            }
+        }
+
+        public int GetNodeId(string route)
+        {
+            if (_umbracoContext.InPreviewMode)
+                return 0;
+
+            lock (_lock)
+            {
+                return _nodeIds.ContainsKey(route) ? _nodeIds[route] : 0;
+            }
+        }
+
+        public void ClearNode(int nodeId)
+        {
+            lock (_lock)
+            {
+                if (_routes.ContainsKey(nodeId))
+                {
+                    _nodeIds.Remove(_routes[nodeId]);
+                    _routes.Remove(nodeId);
+                }
+            }
+        }
+
+        public void Clear()
+        {
+            lock (_lock)
+            {
+                _routes = new Dictionary<int, string>();
+                _nodeIds = new Dictionary<string, int>();
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Umbraco.Web/Routing/RoutingEnvironment.cs b/src/Umbraco.Web/Routing/RoutingEnvironment.cs
new file mode 100644
index 0000000000..cf848625be
--- /dev/null
+++ b/src/Umbraco.Web/Routing/RoutingEnvironment.cs
@@ -0,0 +1,42 @@
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Umbraco.Web.Routing
+{
+    // represents a request for one specified Umbraco document to be rendered
+    // by one specified template, using one particular culture.
+    //
+
+    internal class RoutingEnvironment
+    {
+        public RoutingEnvironment(
+            IEnumerable<ILookup> lookups,
+            ILookupNotFound lookupNotFound,
+            ContentStore contentStore)
+        {
+            Lookups = SortByPartWeight(lookups);
+            LookupNotFound = lookupNotFound;
+            ContentStore = contentStore;
+        }
+
+        private static IEnumerable<ILookup> SortByPartWeight(IEnumerable<ILookup> lookups)
+        {
+            return lookups.OrderBy(x =>
+                {
+                    var attribute = x.GetType().GetCustomAttributes(true).OfType<LookupWeightAttribute>().SingleOrDefault();
+                    return attribute == null ? LookupWeightAttribute.DefaultWeight : attribute.Weight;
+                }).ToList();
+        }
+
+        public IEnumerable<ILookup> Lookups
+        {
+            get;
+            private set;
+        }
+
+        public ILookupNotFound LookupNotFound { get; private set; }
+
+        public ContentStore ContentStore { get; private set; }
+
+    }
+}
\ No newline at end of file
diff --git a/src/Umbraco.Web/Umbraco.Web.csproj b/src/Umbraco.Web/Umbraco.Web.csproj
index 0ad3996c92..98d3136fef 100644
--- a/src/Umbraco.Web/Umbraco.Web.csproj
+++ b/src/Umbraco.Web/Umbraco.Web.csproj
@@ -198,6 +198,10 @@
       <Project>{5BA5425F-27A7-4677-865E-82246498AA2E}</Project>
       <Name>SqlCE4Umbraco</Name>
     </ProjectReference>
+    <ProjectReference Include="..\Umbraco.Core\Umbraco.Core.csproj">
+      <Project>{31785BC3-256C-4613-B2F5-A1B0BDDED8C1}</Project>
+      <Name>Umbraco.Core</Name>
+    </ProjectReference>
     <ProjectReference Include="..\umbraco.macroRenderings\umbraco.macroRenderings.csproj">
       <Project>{52AB8F1F-FB76-4E8C-885F-0747B6CE71EC}</Project>
       <Name>umbraco.macroRenderings</Name>
@@ -233,6 +237,23 @@
     <Compile Include="..\SolutionInfo.cs">
       <Link>Properties\SolutionInfo.cs</Link>
     </Compile>
+    <Compile Include="ContentStore.cs" />
+    <Compile Include="LegacyRequestInitializer.cs" />
+    <Compile Include="Mvc\ControllerExtensions.cs" />
+    <Compile Include="NiceUrls.cs" />
+    <Compile Include="PluginResolverExtensions.cs" />
+    <Compile Include="Routing\DocumentRequest.cs" />
+    <Compile Include="Routing\ILookup.cs" />
+    <Compile Include="Routing\ILookupNotFound.cs" />
+    <Compile Include="Routing\LookupByAlias.cs" />
+    <Compile Include="Routing\LookupById.cs" />
+    <Compile Include="Routing\LookupByPath.cs" />
+    <Compile Include="Routing\LookupByPathWithTemplate.cs" />
+    <Compile Include="Routing\LookupByProfile.cs" />
+    <Compile Include="Routing\LookupFor404.cs" />
+    <Compile Include="Routing\LookupWeightAttribute.cs" />
+    <Compile Include="Routing\RoutesCache.cs" />
+    <Compile Include="Routing\RoutingEnvironment.cs" />
     <Compile Include="umbraco.presentation\EnsureSystemPathsApplicationStartupHandler.cs" />
     <Compile Include="umbraco.presentation\install\steps\database.ascx.cs">
       <DependentUpon>database.ascx</DependentUpon>
@@ -1738,6 +1759,9 @@
     <Compile Include="umbraco.presentation\umbraco\plugins\tinymce3\SpellCheckerInput.cs" />
     <Compile Include="umbraco.presentation\umbraco\plugins\tinymce3\SpellCheckerResult.cs" />
     <Compile Include="umbraco.presentation\viewstateMoverModule.cs" />
+    <Compile Include="UmbracoContext.cs" />
+    <Compile Include="UmbracoModule.cs" />
+    <Compile Include="UrlUtility.cs" />
     <Compile Include="Web References\org.umbraco.update\Reference.cs">
       <AutoGen>True</AutoGen>
       <DesignTime>True</DesignTime>
diff --git a/src/Umbraco.Web/UmbracoContext.cs b/src/Umbraco.Web/UmbracoContext.cs
new file mode 100644
index 0000000000..4992fa3e07
--- /dev/null
+++ b/src/Umbraco.Web/UmbracoContext.cs
@@ -0,0 +1,221 @@
+using System;
+using System.Web;
+using Umbraco.Core;
+using Umbraco.Web.Routing;
+using umbraco;
+using umbraco.IO;
+using umbraco.presentation;
+using umbraco.presentation.LiveEditing;
+using umbraco.BasePages;
+using umbraco.cms.businesslogic.web;
+using umbraco.BusinessLogic;
+using System.Xml;
+using umbraco.presentation.preview;
+using Examine.Providers;
+using Examine;
+
+namespace Umbraco.Web
+{
+    /// <summary>
+    /// Class that encapsulates Umbraco information of a specific HTTP request
+    /// </summary>
+    public class UmbracoContext
+    {
+
+        private const string HttpContextItemName = "Umbraco.Web.UmbracoContext";
+        private static readonly object Locker = new object();
+
+        private PreviewContent _previewContent;
+
+        /// <summary>
+        /// Used if not running in a web application (no real HttpContext)
+        /// </summary>
+        private static UmbracoContext _umbracoContext;
+
+        /// <summary>
+        /// Creates a new Umbraco context.
+        /// </summary>
+        /// <param name="httpContext"></param>
+        /// <param name="applicationContext"> </param>
+        internal UmbracoContext(HttpContextBase httpContext, ApplicationContext applicationContext)
+        {
+            if (httpContext == null) throw new ArgumentNullException("httpContext");
+            if (applicationContext == null) throw new ArgumentNullException("applicationContext");
+
+            HttpContext = httpContext;            
+            Application = applicationContext;
+        }
+
+        /// <summary>
+        /// Gets the current Umbraco Context.
+        /// </summary>
+        public static UmbracoContext Current
+        {
+            get
+            {
+                //if we have a real context then return the request based object
+                if (System.Web.HttpContext.Current != null)
+                {
+                    return (UmbracoContext)System.Web.HttpContext.Current.Items[HttpContextItemName];
+                }
+
+                //return the object if not running in a real HttpContext
+                return _umbracoContext;
+            }
+
+            set
+            {
+                lock (Locker)
+                {
+                    //if running in a real HttpContext, this can only be set once
+                    if (System.Web.HttpContext.Current != null && Current != null)
+                    {
+                        throw new ApplicationException("The current httpContext can only be set once during a request.");
+                    }
+
+                    //if there is an HttpContext, return the item
+                    if (System.Web.HttpContext.Current != null)
+                    {
+                        System.Web.HttpContext.Current.Items[HttpContextItemName] = value;
+                    }
+                    else
+                    {
+                        _umbracoContext = value;
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets the current ApplicationContext
+        /// </summary>
+        public ApplicationContext Application { get; private set; }
+
+        /// <summary>
+        /// Gets/sets the original URL of the request
+        /// </summary>
+        internal Uri OriginalUrl { get; set; }
+
+        /// <summary>
+        /// Returns the XML Cache document
+        /// </summary>
+        /// <returns></returns>
+        /// <remarks>
+        /// This is marked internal for now because perhaps we might return a wrapper like CacheData so that it doesn't have a reliance
+        /// specifically on XML.
+        /// </remarks>
+        internal XmlDocument GetXml()
+        {
+            if (InPreviewMode)
+            {
+                if (_previewContent == null)
+                {
+                    _previewContent = new PreviewContent(UmbracoUser, new Guid(StateHelper.Cookies.Preview.GetValue()), true);
+                    if (_previewContent.ValidPreviewSet)
+                        _previewContent.LoadPreviewset();
+                }
+                if (_previewContent.ValidPreviewSet)
+                    return _previewContent.XmlContent;
+            }
+            return content.Instance.XmlContent;
+
+        }
+
+        /// <summary>
+        /// Gets/sets the DocumentRequest object
+        /// </summary>
+        internal DocumentRequest DocumentRequest { get; set; }
+
+        /// <summary>
+        /// Exposes the HttpContext for the current request
+        /// </summary>
+        public HttpContextBase HttpContext { get; private set; }
+
+        /// <summary>
+        /// Gets a value indicating whether the request has debugging enabled
+        /// </summary>
+        /// <value><c>true</c> if this instance is debug; otherwise, <c>false</c>.</value>
+        public bool IsDebug
+        {
+            get
+            {
+                return GlobalSettings.DebugMode && (!string.IsNullOrEmpty(HttpContext.Request["umbdebugshowtrace"]) || !string.IsNullOrEmpty(HttpContext.Request["umbdebug"]));
+            }
+        }
+
+        /// <summary>
+        /// Gets the current page ID, or <c>null</c> if no page ID is available (e.g. a custom page).
+        /// </summary>
+        public virtual int? PageId
+        {
+            get
+            {
+                try
+                {
+                    //TODO: this should be done with a wrapper: http://issues.umbraco.org/issue/U4-61
+                    return int.Parse(HttpContext.Items["pageID"].ToString());
+                }
+                catch
+                {
+                    return null;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets the current logged in Umbraco user (editor).
+        /// </summary>
+        /// <value>The Umbraco user object or null</value>
+        public virtual User UmbracoUser
+        {
+            get
+            {
+                return UmbracoEnsuredPage.CurrentUser;
+            }
+
+        }
+
+        /// <summary>
+        /// Determines whether the current user is in a preview mode and browsing the site (ie. not in the admin UI)
+        /// </summary>
+        public virtual bool InPreviewMode
+        {
+            get
+            {
+                if (HttpContext.Request == null || HttpContext.Request.Url == null)
+                    return false;
+
+                var currentUrl = HttpContext.Request.Url.AbsolutePath;
+                // zb-00004 #29956 : refactor cookies names & handling
+                return
+                    StateHelper.Cookies.Preview.HasValue // has preview cookie
+                    && UmbracoUser != null // has user
+                    && !currentUrl.StartsWith(IOHelper.ResolveUrl(SystemDirectories.Umbraco)); // is not in admin UI
+            }
+        }   
+
+        /// <summary>
+        /// Gets the current Live Editing Context.
+        /// </summary>
+        public virtual ILiveEditingContext LiveEditingContext
+        {
+            get
+            {
+                //TODO: this should be done with a wrapper: http://issues.umbraco.org/issue/U4-61
+                var value = (ILiveEditingContext)HttpContext.Items["LiveEditingContext"];
+                if (value == null)
+                {
+                    LiveEditingContext = value = new DefaultLiveEditingContext();
+                }
+                return value;
+            }
+
+            set
+            {
+                //TODO: this should be done with a wrapper: http://issues.umbraco.org/issue/U4-61
+                HttpContext.Items["LiveEditingContext"] = value;
+            }
+        }
+
+    }
+}
\ No newline at end of file
diff --git a/src/Umbraco.Web/UmbracoModule.cs b/src/Umbraco.Web/UmbracoModule.cs
new file mode 100644
index 0000000000..fd978332ba
--- /dev/null
+++ b/src/Umbraco.Web/UmbracoModule.cs
@@ -0,0 +1,371 @@
+using System;
+using System.Diagnostics;
+using System.Linq;
+using System.Threading;
+using System.Web;
+using Umbraco.Core;
+using Umbraco.Web.Routing;
+using umbraco;
+using umbraco.IO;
+
+namespace Umbraco.Web
+{
+    // also look at IOHelper.ResolveUrlsFromTextString - nightmarish?!
+
+    // context.RewritePath supports ~/ or else must begin with /vdir
+    //  Request.RawUrl is still there
+    // response.Redirect does?! always remap to /vdir?!
+
+    public class UmbracoModule : IHttpModule
+    {
+        private static readonly TraceSource Trace = new TraceSource("UmbracoModule");                
+
+        // entry point for a request
+        void ProcessRequest(HttpContext httpContext)
+        {
+            Trace.TraceInformation("Process request");
+
+            var uri = httpContext.Request.Url;
+            var lpath = uri.AbsolutePath.ToLower();
+
+            // add Umbraco's signature header
+            if (!UmbracoSettings.RemoveUmbracoVersionHeader)
+                httpContext.Response.AddHeader("X-Umbraco-Version", string.Format("{0}.{1}", GlobalSettings.VersionMajor, GlobalSettings.VersionMinor));
+
+            //create the UmbracoContext singleton, one per request!!
+            var umbracoContext = new UmbracoContext(new HttpContextWrapper(httpContext), ApplicationContext.Current);
+            UmbracoContext.Current = umbracoContext;
+
+            //create a content store
+            var contentStore = new ContentStore(umbracoContext);
+            //create the routes cache
+            var routesCache = new RoutesCache(umbracoContext);
+            //create the nice urls
+            var niceUrls = new NiceUrls(contentStore, umbracoContext, routesCache);
+            //create the RoutingEnvironment (one per http request as it relies on the umbraco context!)
+            var routingEnvironment = new RoutingEnvironment(
+                            ApplicationContext.Current.Plugins.ResolveLookups().ToArray(),
+                            new LookupFor404(contentStore),
+                            contentStore);
+            // create the new document request which will cleanup the uri once and for all
+            var docreq = new DocumentRequest(uri, routingEnvironment, umbracoContext, niceUrls);
+            
+            // initialize the document request on the UmbracoContext (this is circular dependency!!!)
+            umbracoContext.DocumentRequest = docreq;
+
+            //create the LegacyRequestInitializer (one per http request as it relies on the umbraco context!)
+            var legacyRequestInitializer = new LegacyRequestInitializer(umbracoContext);
+
+            // legacy - initialize legacy stuff
+            legacyRequestInitializer.InitializeRequest();
+
+            // note - at that point the original legacy module did something do handle IIS custom 404 errors
+            //   ie pages looking like /anything.aspx?404;/path/to/document - I guess the reason was to support
+            //   "directory urls" without having to do wildcard mapping to ASP.NET on old IIS. This is a pain
+            //   to maintain and probably not used anymore - removed as of 06/2012. @zpqrtbnk.
+            //
+            //   to trigger Umbraco's not-found, one should configure IIS and/or ASP.NET custom 404 errors
+            //   so that they point to a non-existing page eg /redirect-404.aspx
+
+            var ok = true;
+
+            // ensure this is a document request
+            ok = ok && EnsureDocumentRequest(httpContext, uri, lpath);
+            // ensure Umbraco is ready to serve documents
+            ok = ok && EnsureIsReady(httpContext, uri);
+            // ensure Umbraco is properly configured to serve documents
+            ok = ok && EnsureIsConfigured(httpContext, uri);
+            //TODO: I like the idea of this new setting, but lets get this in to the core at a later time, for now lets just get the basics working.
+            //ok = ok && (!Settings.Legacy.EnableBaseRestHandler || EnsureNotBaseRestHandler(httpContext, lpath));
+            ok = ok && (EnsureNotBaseRestHandler(httpContext, lpath));
+
+            if (!ok)
+            {
+                Trace.TraceInformation("End");
+                return;
+            }
+
+            // legacy - no idea what this is
+            LegacyCleanUmbPageFromQueryString(ref uri, ref lpath);
+
+            docreq.ResolveSiteRoot();
+            if (docreq.IsRedirect)
+                httpContext.Response.Redirect(docreq.RedirectUrl, true);
+            Thread.CurrentThread.CurrentUICulture = Thread.CurrentThread.CurrentCulture = docreq.Culture;
+            docreq.ResolveDocument();
+            if (docreq.IsRedirect)
+                httpContext.Response.Redirect(docreq.RedirectUrl, true);
+
+            if (docreq.Is404)
+                httpContext.Response.StatusCode = 404;
+
+            // fixme - should use an IComponent here, so that we could hand the request over to MVC
+            Trace.TraceInformation("Transfer to UmbracoDefault (default.aspx)");
+            TransferRequest("~/default.aspx?" + docreq.QueryString);
+
+            // it is up to default.aspx to figure out what to display in case
+            // there is no document (ugly 404 page?) or no template (blank page?)
+        }
+
+        // ensures that the request is a document request
+        // ie one that the module should handle
+        bool EnsureDocumentRequest(HttpContext httpContext, Uri uri, string lpath)
+        {
+            bool maybeDoc = true;
+
+            // handle directory-urls used for asmx
+            // legacy - what's the point really?
+            if (maybeDoc && GlobalSettings.UseDirectoryUrls)
+            {
+                int asmxPos = lpath.IndexOf(".asmx/");
+                if (asmxPos >= 0)
+                {
+                    // use uri.AbsolutePath, not path, 'cos path has been lowercased
+                    httpContext.RewritePath(uri.AbsolutePath.Substring(0, asmxPos + 5), // filePath
+                        uri.AbsolutePath.Substring(asmxPos + 5), // pathInfo
+                        uri.Query.TrimStart('?'));
+                    maybeDoc = false;
+                }
+            }
+
+            // a document request should be
+            // /foo/bar/nil
+            // /foo/bar/nil/
+            // /foo/bar/nil.aspx
+            // where /foo is not a reserved path
+
+            // if the path contains an extension that is not .aspx
+            // then it cannot be a document request
+            if (maybeDoc && lpath.Contains('.') && !lpath.EndsWith(".aspx"))
+                maybeDoc = false;
+
+            // at that point, either we have no extension, or it is .aspx
+
+            // if the path is reserved then it cannot be a document request
+            if (maybeDoc && GlobalSettings.IsReservedPathOrUrl(lpath))
+                maybeDoc = false;
+
+            if (!maybeDoc)
+                Trace.TraceInformation("Not a document");
+            return maybeDoc;
+        }
+
+        // ensures Umbraco is ready to handle requests
+        // if not, set status to 503 and transfer request, and return false
+        // if yes, return true
+        bool EnsureIsReady(HttpContext httpContext, Uri uri)
+        {
+            // ensure we are ready
+            if (!ApplicationContext.Current.IsReady)
+            {
+                Trace.TraceEvent(TraceEventType.Warning, 0, "Umbraco is not ready");
+                httpContext.Response.StatusCode = 503;
+                string bootUrl = null;
+                if (UmbracoSettings.EnableSplashWhileLoading) // legacy - should go
+                {
+                    string configPath = UrlUtility.ToAbsolute(SystemDirectories.Config);
+                    bootUrl = string.Format("{0}/splashes/booting.aspx?url={1}", configPath, HttpUtility.UrlEncode(uri.ToString()));
+                    // fixme ?orgurl=... ?retry=...
+                }
+
+                //TODO: I like the idea of this new setting, but lets get this in to the core at a later time, for now lets just get the basics working.
+                //else if (!string.IsNullOrWhiteSpace(Settings.BootSplashPage))
+                //{
+                //    bootUrl = UrlUtility.ToAbsolute(Settings.BootSplashPage);
+                //}
+
+                else
+                {
+                    // fixme - default.aspx has to be ready for RequestContext.DocumentRequest==null
+                    // fixme - in fact we should transfer to an empty html page...
+                    bootUrl = UrlUtility.ToAbsolute("~/default.aspx");
+                }
+                TransferRequest(bootUrl);
+                return false;
+            }
+
+            return true;
+        }
+
+        // ensures Umbraco is configured
+        // if not, redirect to install and return false
+        // if yes, return true
+        bool EnsureIsConfigured(HttpContext httpContext, Uri uri)
+        {
+            if (!ApplicationContext.Current.IsConfigured)
+            {
+                Trace.TraceEvent(TraceEventType.Warning, 0, "Umbraco is not configured");
+                string installPath = UrlUtility.ToAbsolute(SystemDirectories.Install);
+                string installUrl = string.Format("{0}/default.aspx?redir=true&url={1}", installPath, HttpUtility.UrlEncode(uri.ToString()));
+                httpContext.Response.Redirect(installUrl, true);
+                return false;
+            }
+            return true;
+        }
+
+        // checks if the current request is a /base REST handler request
+        // returns false if it is, otherwise true
+        bool EnsureNotBaseRestHandler(HttpContext httpContext, string lpath)
+        {
+            // the /base REST handler still lives in umbraco.dll and has
+            // not been refactored at the moment. it still is a module,
+            // although it should be a handler, or it should be replaced
+            // by clean WebAPI.
+
+            // fixme - do it once when initializing the module
+            string baseUrl = UrlUtility.ToAbsolute(SystemDirectories.Base).ToLower();
+            if (!baseUrl.EndsWith("/"))
+                baseUrl += "/";
+            if (lpath.StartsWith(baseUrl))
+            {
+                Trace.TraceInformation("Detected /base REST handler");
+                return false;
+            }
+            return true;
+        }
+
+        // transfers the request using the fastest method available on the server
+        void TransferRequest(string path)
+        {
+            bool integrated = HttpRuntime.UsingIntegratedPipeline;
+
+            // fixme - are we doing this properly?
+            // fixme - handle virtual directory?
+            // fixme - this does not work 'cos it resets the HttpContext
+            //  so we should move the DocumentRequest stuff etc back to default.aspx?
+            //  but, also, with TransferRequest, auth & co will run on the new (default.aspx) url,
+            //  is that really what we want? I need to talk about it with others. @zpqrtbnk
+            integrated = false;
+
+            // http://msmvps.com/blogs/luisabreu/archive/2007/10/09/are-you-using-the-new-transferrequest.aspx
+            // http://msdn.microsoft.com/en-us/library/aa344903.aspx
+            // http://forums.iis.net/t/1146511.aspx
+
+            if (integrated)
+                HttpContext.Current.Server.TransferRequest(path);
+            else
+                HttpContext.Current.RewritePath(path);
+        }
+
+        #region Legacy
+
+        // "Clean umbPage from querystring, caused by .NET 2.0 default Auth Controls"
+        // but really, at the moment I have no idea what this does, and why...
+        void LegacyCleanUmbPageFromQueryString(ref Uri uri, ref string lpath)
+        {
+            string receivedQuery = uri.Query;
+            string path = uri.AbsolutePath;
+            string query = null;
+
+            if (receivedQuery.Length > 0)
+            {
+                // Clean umbPage from querystring, caused by .NET 2.0 default Auth Controls
+                if (receivedQuery.IndexOf("umbPage") > 0)
+                {
+                    int ampPos = receivedQuery.IndexOf('&');
+                    // query contains no ampersand?
+                    if (ampPos < 0)
+                    {
+                        // no ampersand means no original query string
+                        query = String.Empty;
+                        // ampersand would occur past then end the of received query
+                        ampPos = receivedQuery.Length;
+                    }
+                    else
+                    {
+                        // original query string past ampersand
+                        query = receivedQuery.Substring(ampPos + 1,
+                                                        receivedQuery.Length - ampPos - 1);
+                    }
+                    // get umbPage out of query string (9 = "&umbPage".Length() + 1)
+                    path = receivedQuery.Substring(9, ampPos - 9); //this will fail if there are < 9 characters before the &umbPage query string
+
+                    // --added when refactoring--
+                    uri = uri.Rewrite(path, query);
+                    lpath = path.ToLower();
+                }
+                //else
+                //{
+                //    // strip off question mark
+                //    query = receivedQuery.Substring(1);
+                //}
+            }
+        }
+
+        
+
+        #endregion
+
+        #region IHttpModule
+
+        // initialize the module,  this will trigger for each new application
+        // and there may be more than 1 application per application domain
+        public void Init(HttpApplication app)
+        {
+            InitializeApplication(app);
+        }
+
+        public void Dispose()
+        { }
+
+        #endregion
+
+        #region Initialize
+
+        private static volatile bool _appDomainInitialized = false;
+        static readonly object AppDomainLock = new object();
+
+        /// <summary>
+        /// Initializes the application one time only
+        /// </summary>
+        void InitializeDomain()
+        {
+            if (!_appDomainInitialized)
+            {
+                lock (AppDomainLock)
+                {
+                    if (!_appDomainInitialized)
+                    {
+                        Trace.TraceInformation("Initialize AppDomain");
+
+                        //create the ApplicationContext
+                        ApplicationContext.Current = new ApplicationContext(new PluginResolver());
+                        
+                        //TODO: Why is this necessary? if the ApplicationContext is null, then its not ready
+                        ApplicationContext.Current.IsReady = true; // fixme
+
+                        // Backwards compatibility - set the path and URL type for ClientDependency 1.5.1 [LK]
+                        ClientDependency.Core.CompositeFiles.Providers.XmlFileMapper.FileMapVirtualFolder = "~/App_Data/TEMP/ClientDependency";
+                        ClientDependency.Core.CompositeFiles.Providers.BaseCompositeFileProcessingProvider.UrlTypeDefault = ClientDependency.Core.CompositeFiles.Providers.CompositeUrlType.Base64QueryStrings;
+
+                        _appDomainInitialized = true;
+                    }
+                    Trace.TraceInformation("AppDomain is initialized");
+                }
+            }            
+        }
+
+        void InitializeApplication(HttpApplication app)
+        {
+            // we can't do in in module.Init because we need HttpContext.
+            app.BeginRequest += (sender, e) =>
+            {
+                Trace.TraceInformation("Welcome to Umbraco!");
+                InitializeDomain();
+            };
+
+            // used to be done in PostAuthorizeRequest but then it disabled OutputCaching due
+            // to rewriting happening too early in the chain (Alex Norcliffe 2010-02).
+            app.PostResolveRequestCache += (sender, e) =>
+            {
+                HttpContext httpContext = ((HttpApplication)sender).Context;
+                ProcessRequest(httpContext);
+            };
+
+            // todo: initialize request errors handler
+            // todo: initialize XML cache flush
+        }
+
+        #endregion
+    }
+}
diff --git a/src/Umbraco.Web/UrlUtility.cs b/src/Umbraco.Web/UrlUtility.cs
new file mode 100644
index 0000000000..94ea704a9f
--- /dev/null
+++ b/src/Umbraco.Web/UrlUtility.cs
@@ -0,0 +1,145 @@
+using System;
+using System.Text;
+using System.Web;
+
+namespace Umbraco.Web
+{
+    static class UrlUtility
+    {
+        static readonly string _appVirtualPath;
+        static readonly string _appVirtualPathPrefix;
+
+        static UrlUtility()
+        {
+            _appVirtualPath = HttpRuntime.AppDomainAppVirtualPath ?? "/";
+            _appVirtualPathPrefix = _appVirtualPath;
+            if (_appVirtualPathPrefix == "/")
+                _appVirtualPathPrefix = string.Empty;
+        }
+
+        public static string AppVirtualPath
+        {
+            get { return _appVirtualPath; }
+        }
+
+        public static string AppVirtualPathPrefix
+        {
+            get { return _appVirtualPathPrefix; }
+        }
+
+        public static string ToAbsolute(string url)
+        {
+            return ResolveUrl(url);
+        }
+
+        public static string ToAppRelative(string url)
+        {
+            if (url.StartsWith(_appVirtualPathPrefix))
+                url = url.Substring(_appVirtualPathPrefix.Length);
+            return url;
+        }
+
+        #region ResolveUrl
+
+        // http://www.codeproject.com/Articles/53460/ResolveUrl-in-ASP-NET-The-Perfect-Solution
+        // note
+        // if browsing http://example.com/sub/page1.aspx then 
+        // ResolveUrl("page2.aspx") returns "/page2.aspx"
+        // Page.ResolveUrl("page2.aspx") returns "/sub/page2.aspx" (relative...)
+        //
+        public static string ResolveUrl(string relativeUrl)
+        {
+            if (relativeUrl == null) throw new ArgumentNullException("relativeUrl");
+
+            if (relativeUrl.Length == 0 || relativeUrl[0] == '/' || relativeUrl[0] == '\\')
+                return relativeUrl;
+
+            int idxOfScheme = relativeUrl.IndexOf(@"://", StringComparison.Ordinal);
+            if (idxOfScheme != -1)
+            {
+                int idxOfQM = relativeUrl.IndexOf('?');
+                if (idxOfQM == -1 || idxOfQM > idxOfScheme) return relativeUrl;
+            }
+
+            StringBuilder sbUrl = new StringBuilder();
+            sbUrl.Append(HttpRuntime.AppDomainAppVirtualPath);
+            if (sbUrl.Length == 0 || sbUrl[sbUrl.Length - 1] != '/') sbUrl.Append('/');
+
+            // found question mark already? query string, do not touch!
+            bool foundQM = false;
+            bool foundSlash; // the latest char was a slash?
+            if (relativeUrl.Length > 1
+                && relativeUrl[0] == '~'
+                && (relativeUrl[1] == '/' || relativeUrl[1] == '\\'))
+            {
+                relativeUrl = relativeUrl.Substring(2);
+                foundSlash = true;
+            }
+            else foundSlash = false;
+            foreach (char c in relativeUrl)
+            {
+                if (!foundQM)
+                {
+                    if (c == '?') foundQM = true;
+                    else
+                    {
+                        if (c == '/' || c == '\\')
+                        {
+                            if (foundSlash) continue;
+                            else
+                            {
+                                sbUrl.Append('/');
+                                foundSlash = true;
+                                continue;
+                            }
+                        }
+                        else if (foundSlash) foundSlash = false;
+                    }
+                }
+                sbUrl.Append(c);
+            }
+
+            return sbUrl.ToString();
+        }
+
+        #endregion
+
+        #region Utilities
+
+        public static bool HasScheme(string uri)
+        {
+            return uri.StartsWith("http://", StringComparison.CurrentCultureIgnoreCase)
+                   || uri.StartsWith("https://", StringComparison.CurrentCultureIgnoreCase);
+        }
+
+        public static string EnsureScheme(string uri, string scheme)
+        {
+            return HasScheme(uri) ? uri : string.Format("{0}://{1}", scheme, uri);
+        }
+
+        public static string WithTrailingSlash(string uri)
+        {
+            return uri.EndsWith("/") ? uri : uri + "/";
+        }
+
+        // indicates whether uri2 is within uri1
+        public static bool IsBaseOf(string uri1, string uri2)
+        {
+            uri2 = WithTrailingSlash(uri2);
+            Uri testUri2 = new Uri(uri2);
+
+            uri1 = WithTrailingSlash(uri1);
+            uri1 = EnsureScheme(uri1, testUri2.Scheme);
+            Uri testUri1 = new Uri(uri1);
+
+            return testUri1.IsBaseOf(testUri2);
+        }
+
+        public static bool IsBaseOf(string uri1, Uri uri2)
+        {
+            return IsBaseOf(uri1, uri2.ToString());
+        }
+
+        #endregion
+    }
+}
\ No newline at end of file
diff --git a/src/Umbraco.Web/umbraco.presentation/UmbracoContext.cs b/src/Umbraco.Web/umbraco.presentation/UmbracoContext.cs
index 7ad562640e..29d6ba6ee4 100644
--- a/src/Umbraco.Web/umbraco.presentation/UmbracoContext.cs
+++ b/src/Umbraco.Web/umbraco.presentation/UmbracoContext.cs
@@ -15,6 +15,7 @@ namespace umbraco.presentation
     /// <summary>
     /// Class that encapsulates Umbraco information of a specific HTTP request.
     /// </summary>
+    [Obsolete("Use Umbraco.Web.UmbracoContext instead")]
     public class UmbracoContext
     {
         private UmbracoServerUtility _server;
@@ -55,7 +56,7 @@ namespace umbraco.presentation
                 return null;
             }
 
-            set
+            internal set
             {
                 if (Current != null)
                     throw new ApplicationException("The current httpContext can only be set once during a request.");
diff --git a/src/Umbraco.Web/umbraco.presentation/UmbracoRequest.cs b/src/Umbraco.Web/umbraco.presentation/UmbracoRequest.cs
index 6d3de459a4..5b6207654b 100644
--- a/src/Umbraco.Web/umbraco.presentation/UmbracoRequest.cs
+++ b/src/Umbraco.Web/umbraco.presentation/UmbracoRequest.cs
@@ -19,6 +19,7 @@ namespace umbraco.presentation
     /// 
     /// This now needs to exist only because of backwards compatibility
     /// </remarks>
+    [Obsolete("This class is no longer used, for the IsDebug method use Umbraco.Web.UmbracoContext.IsDebug")]
     public class UmbracoRequest : HttpRequestBase
     {
         private readonly HttpRequestBase _request;
diff --git a/src/Umbraco.Web/umbraco.presentation/UmbracoResponse.cs b/src/Umbraco.Web/umbraco.presentation/UmbracoResponse.cs
index bc02c88ea9..33abc4d5cf 100644
--- a/src/Umbraco.Web/umbraco.presentation/UmbracoResponse.cs
+++ b/src/Umbraco.Web/umbraco.presentation/UmbracoResponse.cs
@@ -14,6 +14,7 @@ namespace umbraco.presentation
     /// it still has a reliance on the real HttpResponse object which means that the UmbracoContext still has 
     /// a reliance on the real HttpContext.
     /// </summary>
+    [Obsolete("This class is no longer used")]
     public class UmbracoResponse : HttpResponseBase
     {
         private readonly HttpResponseBase _response;
diff --git a/src/Umbraco.Web/umbraco.presentation/UmbracoServerUtility.cs b/src/Umbraco.Web/umbraco.presentation/UmbracoServerUtility.cs
index acf61aadc0..c35ef9768b 100644
--- a/src/Umbraco.Web/umbraco.presentation/UmbracoServerUtility.cs
+++ b/src/Umbraco.Web/umbraco.presentation/UmbracoServerUtility.cs
@@ -24,6 +24,7 @@ namespace umbraco.presentation
     /// 
     /// This now needs to exist only because of backwards compatibility
     /// </remarks>
+    [Obsolete("This class is no longer used, for the overridden MapPath methods and custom methods use IOHelper")]
     public class UmbracoServerUtility : HttpServerUtilityBase
     {
         private readonly HttpServerUtilityBase _server;