MonoRail/Castle.MonoRail.Framework/RoutingModule.cs

   1 // Copyright 2004-2008 Castle Project - http://www.castleproject.org/
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 namespace Castle.MonoRail.Framework
  16 {
  17         using System;
  18         using System.Collections;
  19         using System.Web;
  20         using Castle.MonoRail.Framework.Configuration;
  21
  22         /// <summary>
  23         /// Provides routing basic services in response to rules defined in
  24         /// <see cref="MonoRailConfiguration.RoutingRules"/>.
  25         /// <remarks>
  26         /// This class delegates the resolving of the path that will be evaluated
  27         /// to derivided classes.
  28         /// </remarks>
  29         /// </summary>
  30         public class RoutingModule : IHttpModule
  31         {
  32                 internal static readonly String OriginalPathKey = "rails.original_path";
  33                 private IList routingRules;
  34
  35                 /// <summary>
  36                 /// Initializes a module and prepares it to handle requests.
  37                 /// </summary>
  38                 /// <param name="context">An <see cref="T:System.Web.HttpApplication"></see> that provides access to the methods, properties, and events common to all application objects within an ASP.NET application</param>
  39                 public void Init(HttpApplication context)
  40                 {
  41                         context.BeginRequest += OnBeginRequest;
  42
  43                         routingRules = MonoRailConfiguration.GetConfig().RoutingRules;
  44                 }
  45
  46                 /// <summary>
  47                 /// Disposes of the resources (other than memory) used by the module that implements <see cref="T:System.Web.IHttpModule"></see>.
  48                 /// </summary>
  49                 public void Dispose()
  50                 {
  51                 }
  52
  53                 /// <summary>
  54                 /// Called when [begin request].
  55                 /// </summary>
  56                 /// <param name="sender">The sender.</param>
  57                 /// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
  58                 private void OnBeginRequest(object sender, EventArgs e)
  59                 {
  60                         if (routingRules.Count == 0) return;
  61
  62                         HttpContext context = HttpContext.Current;
  63                         HttpRequest request = context.Request;
  64
  65                         String newPath;
  66
  67                         String sourcePath = GetSourcePath();
  68
  69                         SaveOriginalPath(context, sourcePath);
  70
  71                         if (FindMatchAndReplace(sourcePath, out newPath))
  72                         {
  73                                 // Handle things differently depending on wheter we need
  74                                 // to keep a query string or not
  75
  76                                 int queryStringIndex = newPath.IndexOf('?');
  77
  78                                 if (queryStringIndex == -1)
  79                                 {
  80                                         context.RewritePath(newPath);
  81                                 }
  82                                 else
  83                                 {
  84                                         String path = newPath.Substring(0, queryStringIndex);
  85                                         String queryString = newPath.Substring(queryStringIndex + 1);
  86                                         context.RewritePath(path, request.PathInfo, queryString);
  87                                 }
  88                         }
  89                 }
  90
  91                 /// <summary>
  92                 /// Gets the source path.
  93                 /// </summary>
  94                 /// <returns></returns>
  95                 protected static string GetSourcePath()
  96                 {
  97                         if (ShouldUseHostAndPath)
  98                         {
  99                                 return GetHostNameAndPath();
 100                         }
 101                         else if (ExcludeAppPath)
 102                         {
 103                                 return GetPathWithoutAppPath();
 104                         }
 105                         else
 106                         {
 107                                 return GetPath();
 108                         }
 109                 }
 110
 111                 private static bool ShouldUseHostAndPath
 112                 {
 113                         get { return MonoRailConfiguration.GetConfig().MatchHostNameAndPath; }
 114                 }
 115
 116                 private static bool ExcludeAppPath
 117                 {
 118                         get { return MonoRailConfiguration.GetConfig().ExcludeAppPath; }
 119                 }
 120
 121                 private static string GetHostNameAndPath()
 122                 {
 123                         HttpContext context = HttpContext.Current;
 124                         HttpRequest request = context.Request;
 125
 126                         String host = request.Headers["host"];
 127
 128                         if (String.IsNullOrEmpty(host))
 129                         {
 130                                 return request.FilePath;
 131                         }
 132                         else
 133                         {
 134                                 return host + request.FilePath;
 135                         }
 136                 }
 137
 138                 private static string GetPathWithoutAppPath()
 139                 {
 140                         //if ApplicationPath.Length == 1 then it must be "/" which we don't want to remove
 141
 142                         string appPath = HttpContext.Current.Request.ApplicationPath;
 143                         string filePath = HttpContext.Current.Request.FilePath;
 144
 145                         return (appPath.Length == 1) ? filePath : filePath.Remove(0, appPath.Length);
 146                 }
 147
 148                 private static string GetPath()
 149                 {
 150                         return HttpContext.Current.Request.FilePath;
 151                 }
 152
 153                 private bool FindMatchAndReplace(String currentPath, out String newPath)
 154                 {
 155                         newPath = String.Empty;
 156
 157                         foreach(RoutingRule rule in routingRules)
 158                         {
 159                                 if (rule.CompiledRule.IsMatch(currentPath))
 160                                 {
 161                                         newPath = rule.CompiledRule.Replace(currentPath, rule.Replace);
 162
 163                                         //Append the query string
 164                                         String queryString = HttpContext.Current.Request.Url.Query;
 165
 166                                         if (queryString.Length > 0)
 167                                         {
 168                                                 //If we already have some query string params on the new path...
 169                                                 bool hasParams = (newPath.LastIndexOf("?") != -1);
 170
 171                                                 if (hasParams)
 172                                                 {
 173                                                         //...make sure we append the query string nicely rather than adding another ?
 174                                                         queryString = queryString.Replace("?", "&");
 175                                                 }
 176
 177                                                 newPath += queryString;
 178                                         }
 179
 180                                         if (ExcludeAppPath)
 181                                         {
 182                                                 string appPath = HttpContext.Current.Request.ApplicationPath;
 183
 184                                                 if (appPath.Length > 1)
 185                                                 {
 186                                                         newPath = appPath + newPath;
 187                                                 }
 188                                         }
 189
 190                                         return true;
 191                                 }
 192                         }
 193
 194                         return false;
 195                 }
 196
 197                 /// <summary>
 198                 /// Returns the original path
 199                 /// (before rewriting occured), or <c>null</c>
 200                 /// if rewriting didn't occur on this request.
 201                 /// </summary>
 202                 public static String OriginalPath
 203                 {
 204                         get
 205                         {
 206                                 HttpContext context = HttpContext.Current;
 207
 208                                 if (context.Items.Contains(OriginalPathKey))
 209                                 {
 210                                         return context.Items[OriginalPathKey] as String;
 211                                 }
 212
 213                                 return null;
 214                         }
 215                 }
 216
 217                 private static void SaveOriginalPath(HttpContext context, String virtualPath)
 218                 {
 219                         context.Items.Add(OriginalPathKey, virtualPath);
 220                 }
 221         }
 222 }