MonoRail/Castle.MonoRail.Framework/EngineContextModule.cs

   1 // Copyright 2004-2007 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.Web;
  19         using Castle.Core.Logging;
  20         using Castle.MonoRail.Framework.Adapters;
  21         using Castle.MonoRail.Framework.Extensions.ExceptionChaining;
  22         using Routing;
  23
  24         /// <summary>
  25         /// Provides the services used and shared by the framework. Also
  26         /// is in charge of creating an implementation of <see cref="IRailsEngineContext"/>
  27         /// upon the start of a new request.
  28         /// </summary>
  29         public class EngineContextModule : IHttpModule
  30         {
  31                 internal static readonly String RailsContextKey = "rails.context";
  32                 private static readonly Object initLock = new Object();
  33
  34                 private static MonoRailServiceContainer container;
  35
  36                 private ILogger logger = NullLogger.Instance;
  37
  38                 /// <summary>
  39                 /// Configures the framework, starts the services
  40                 /// and application hooks.
  41                 /// </summary>
  42                 /// <param name="context"></param>
  43                 public void Init(HttpApplication context)
  44                 {
  45                         if (context.Context.Error != null)
  46                         {
  47                                 throw new Exception(
  48                                         "An exception happened on Global application or on a module that run before MonoRail's module. " +
  49                                         "MonoRail will not be initialized and further requests are going to fail. " +
  50                                         "Fix the cause of the error reported below.", context.Context.Error);
  51                         }
  52
  53                         lock(initLock)
  54                         {
  55                                 CreateAndStartContainer(context);
  56                         }
  57
  58                         context.BeginRequest += OnStartMonoRailRequest;
  59                         context.AuthorizeRequest += CreateControllerAndRunStartRequestFilters;
  60
  61                         SubscribeToApplicationHooks(context);
  62                 }
  63
  64                 /// <summary>
  65                 /// Disposes of the resources (other than memory) used by the
  66                 /// module that implements <see langword="IHttpModule."/>
  67                 /// </summary>
  68                 public void Dispose()
  69                 {
  70                 }
  71
  72                 /// <summary>
  73                 /// Creates and starts MonoRail's service container.
  74                 /// </summary>
  75                 /// <param name="context"></param>
  76                 public void CreateAndStartContainer(HttpApplication context)
  77                 {
  78                         if (container == null)
  79                         {
  80                                 container = new MonoRailServiceContainer();
  81                                 container.RegisterBaseService(typeof(IServerUtility), new ServerUtilityAdapter(context.Server));
  82                                 container.RegisterBaseService(typeof(IRoutingEngine), RoutingModuleEx.Engine);
  83                                 container.Start();
  84
  85                                 ILoggerFactory loggerFactory = (ILoggerFactory) container.GetService(typeof(ILoggerFactory));
  86
  87                                 if (loggerFactory != null)
  88                                 {
  89                                         logger = loggerFactory.Create(typeof(EngineContextModule));
  90                                 }
  91                         }
  92
  93                         ServiceContainerAccessor.ServiceContainer = container;
  94                 }
  95
  96                 #region MonoRail Request Lifecycle
  97
  98                 /// <summary>
  99                 /// This method is invoked in response to BeginRequest event.
 100                 /// It checks if the request should be treat by MonoRail (by reading the file extension)
 101                 /// and if so, creates the <see cref="IRailsEngineContext"/> instance.
 102                 /// </summary>
 103                 /// <param name="sender">The HttpApplication instance</param>
 104                 /// <param name="e">Event information</param>
 105                 private void OnStartMonoRailRequest(object sender, EventArgs e)
 106                 {
 107                         HttpApplication app = (HttpApplication) sender;
 108
 109                         // Is this request a MonoRail request?
 110                         if (!container.IsMonoRailRequest(app.Context.Request.FilePath))
 111                         {
 112                                 return;
 113                         }
 114
 115                         // Mark it so we dont have to check the file extension again
 116                         MarkRequestAsMonoRailRequest(app.Context);
 117
 118                         // Creates the our context
 119                         IRailsEngineContext context = CreateRailsEngineContext(app.Context);
 120
 121                         #region TestSupport related
 122
 123                         String isTest = context.Request.Headers["IsTestWorkerRequest"];
 124
 125                         if ("true" == isTest)
 126                         {
 127                                 Castle.MonoRail.Framework.Internal.Test.TestContextHolder.SetContext(app.Context);
 128                         }
 129
 130                         #endregion
 131                 }
 132
 133                 /// <summary>
 134                 /// Creates the controller, selects the target action
 135                 /// and run start request filters.
 136                 /// </summary>
 137                 /// <param name="sender">The HttpApplication instance</param>
 138                 /// <param name="e">Event information</param>
 139                 private void CreateControllerAndRunStartRequestFilters(object sender, EventArgs e)
 140                 {
 141                         HttpApplication app = (HttpApplication) sender;
 142                         if (!IsMonoRailRequest(app.Context)) return;
 143
 144                         IRailsEngineContext context = ObtainRailsEngineContext(app.Context);
 145
 146                         Controller controller;
 147
 148                         try
 149                         {
 150                                 controller = CreateController(context);
 151                         }
 152                         catch(Exception ex)
 153                         {
 154                                 IViewEngineManager viewEngineManager = context.GetService<IViewEngineManager>();
 155
 156                                 if (viewEngineManager.HasTemplate("rescues/404"))
 157                                 {
 158                                         viewEngineManager.Process(context, new Controller.EmptyController(context), "rescues/404");
 159
 160                                         IExceptionProcessor exProcessor = context.GetService<IExceptionProcessor>();
 161
 162                                         if (exProcessor != null)
 163                                         {
 164                                                 exProcessor.ProcessException(ex);
 165                                         }
 166
 167                                         app.Context.Response.End();
 168                                 }
 169                                 else
 170                                 {
 171                                         throw;
 172                                 }
 173
 174                                 return;
 175                         }
 176
 177                         IControllerLifecycleExecutor executor = CreateControllerExecutor(controller, context);
 178
 179                         UrlInfo info = context.UrlInfo;
 180
 181                         executor.InitializeController(info.Area, info.Controller, info.Action);
 182
 183                         if (!executor.SelectAction(info.Action, info.Controller))
 184                         {
 185                                 // Could not even select the action, stop here
 186
 187                                 return;
 188                         }
 189
 190                         if (!executor.RunStartRequestFilters())
 191                         {
 192                                 // Cancel request execution as
 193                                 // one of the filters returned false
 194                                 // We assume that the filter that stopped the request, also sent a redirect
 195                                 // or something similar
 196
 197                                 context.UnderlyingContext.Response.End();
 198
 199                                 executor.Dispose();
 200                         }
 201                 }
 202
 203                 #endregion
 204
 205                 private static void MarkRequestAsMonoRailRequest(HttpContext context)
 206                 {
 207                         context.Items["is.mr.request"] = true;
 208                 }
 209
 210                 private static bool IsMonoRailRequest(HttpContext context)
 211                 {
 212                         return context.Items.Contains("is.mr.request");
 213                 }
 214
 215                 /// <summary>
 216                 /// Uses the url information and the controller factory
 217                 /// to instantiate the proper controller.
 218                 /// </summary>
 219                 /// <param name="context">MonoRail's request context</param>
 220                 /// <returns>A controller instance</returns>
 221                 private Controller CreateController(IRailsEngineContext context)
 222                 {
 223                         UrlInfo info = context.UrlInfo;
 224
 225                         if (logger.IsDebugEnabled)
 226                         {
 227                                 logger.DebugFormat("Starting request process for '{0}'/'{1}.{2}' Extension '{3}' with url '{4}'",
 228                                         info.Area, info.Controller, info.Action, info.Extension, info.UrlRaw);
 229                         }
 230
 231                         IControllerFactory controllerFactory = (IControllerFactory) context.GetService(typeof(IControllerFactory));
 232
 233                         Controller controller = controllerFactory.CreateController(info);
 234
 235                         return controller;
 236                 }
 237
 238                 /// <summary>
 239                 /// Creates the and initialize executor.
 240                 /// </summary>
 241                 /// <param name="controller">The controller.</param>
 242                 /// <param name="context">The context.</param>
 243                 /// <returns></returns>
 244                 private IControllerLifecycleExecutor CreateControllerExecutor(Controller controller, IRailsEngineContext context)
 245                 {
 246                         IControllerLifecycleExecutorFactory factory =
 247                                 (IControllerLifecycleExecutorFactory) context.GetService(typeof(IControllerLifecycleExecutorFactory));
 248
 249                         IControllerLifecycleExecutor executor = factory.CreateExecutor(controller, context);
 250
 251                         context.Items[ControllerLifecycleExecutor.ExecutorEntry] = executor;
 252
 253                         return executor;
 254                 }
 255
 256                 /// <summary>
 257                 /// Registers to <c>HttpApplication</c> events
 258                 /// </summary>
 259                 /// <param name="context">The application instance</param>
 260                 private void SubscribeToApplicationHooks(HttpApplication context)
 261                 {
 262                         context.BeginRequest += OnBeginRequest;
 263                         context.EndRequest += OnEndRequest;
 264                         context.AcquireRequestState += OnAcquireRequestState;
 265                         context.ReleaseRequestState += OnReleaseRequestState;
 266                         context.PreRequestHandlerExecute += OnPreRequestHandlerExecute;
 267                         context.PostRequestHandlerExecute += OnPostRequestHandlerExecute;
 268                         context.AuthenticateRequest += OnAuthenticateRequest;
 269                         context.AuthorizeRequest += OnAuthorizeRequest;
 270                         context.Error += OnError;
 271                         context.ResolveRequestCache += OnResolveRequestCache;
 272                         context.UpdateRequestCache += OnUpdateRequestCache;
 273                 }
 274
 275                 #region Hooks dispatched to extensions
 276
 277                 private void OnBeginRequest(object sender, EventArgs e)
 278                 {
 279                         HttpApplication app = (HttpApplication) sender;
 280                         if (!IsMonoRailRequest(app.Context)) return;
 281                         IRailsEngineContext mrContext = ObtainContextFromApplication(sender);
 282
 283                         if (mrContext == null) throw new NullReferenceException("mrContext");
 284
 285                         if (container == null) throw new NullReferenceException("container");
 286                         if (container.extensionManager == null) throw new NullReferenceException("container.extensionManager");
 287
 288                         container.extensionManager.RaiseContextCreated(mrContext);
 289                 }
 290
 291                 private void OnAuthenticateRequest(object sender, EventArgs e)
 292                 {
 293                         HttpApplication app = (HttpApplication)sender;
 294                         if (!IsMonoRailRequest(app.Context)) return;
 295                         IRailsEngineContext mrContext = ObtainContextFromApplication(sender);
 296
 297                         container.extensionManager.RaiseAuthenticateRequest(mrContext);
 298                 }
 299
 300                 private void OnAuthorizeRequest(object sender, EventArgs e)
 301                 {
 302                         HttpApplication app = (HttpApplication)sender;
 303                         if (!IsMonoRailRequest(app.Context)) return;
 304                         IRailsEngineContext mrContext = ObtainContextFromApplication(sender);
 305
 306                         container.extensionManager.RaiseAuthorizeRequest(mrContext);
 307                 }
 308
 309                 private void OnEndRequest(object sender, EventArgs e)
 310                 {
 311                         HttpApplication app = (HttpApplication)sender;
 312                         if (!IsMonoRailRequest(app.Context)) return;
 313                         IRailsEngineContext mrContext = ObtainContextFromApplication(sender);
 314
 315                         container.extensionManager.RaiseContextDisposed(mrContext);
 316                 }
 317
 318                 private void OnAcquireRequestState(object sender, EventArgs e)
 319                 {
 320                         HttpApplication app = (HttpApplication)sender;
 321                         if (!IsMonoRailRequest(app.Context)) return;
 322                         IRailsEngineContext mrContext = ObtainContextFromApplication(sender);
 323
 324                         container.extensionManager.RaiseAcquireRequestState(mrContext);
 325                 }
 326
 327                 private void OnReleaseRequestState(object sender, EventArgs e)
 328                 {
 329                         HttpApplication app = (HttpApplication)sender;
 330                         if (!IsMonoRailRequest(app.Context)) return;
 331                         IRailsEngineContext mrContext = ObtainContextFromApplication(sender);
 332
 333                         container.extensionManager.RaiseReleaseRequestState(mrContext);
 334                 }
 335
 336                 private void OnPreRequestHandlerExecute(object sender, EventArgs e)
 337                 {
 338                         HttpApplication app = (HttpApplication)sender;
 339                         if (!IsMonoRailRequest(app.Context)) return;
 340                         IRailsEngineContext mrContext = ObtainContextFromApplication(sender);
 341
 342                         container.extensionManager.RaisePreProcess(mrContext);
 343                 }
 344
 345                 private void OnPostRequestHandlerExecute(object sender, EventArgs e)
 346                 {
 347                         HttpApplication app = (HttpApplication)sender;
 348                         if (!IsMonoRailRequest(app.Context)) return;
 349                         IRailsEngineContext mrContext = ObtainContextFromApplication(sender);
 350
 351                         container.extensionManager.RaisePostProcess(mrContext);
 352                 }
 353
 354                 private void OnError(object sender, EventArgs e)
 355                 {
 356                         HttpApplication app = (HttpApplication)sender;
 357                         if (!IsMonoRailRequest(app.Context)) return;
 358                         IRailsEngineContext mrContext = ObtainContextFromApplication(sender);
 359
 360                         if (mrContext != null)
 361                         {
 362                                 mrContext.LastException = mrContext.UnderlyingContext.Server.GetLastError();
 363
 364                                 container.extensionManager.RaiseUnhandledError(mrContext);
 365                         }
 366                 }
 367
 368                 private void OnResolveRequestCache(object sender, EventArgs e)
 369                 {
 370                         HttpApplication app = (HttpApplication)sender;
 371                         if (!IsMonoRailRequest(app.Context)) return;
 372                         IRailsEngineContext mrContext = ObtainContextFromApplication(sender);
 373
 374                         container.extensionManager.RaiseResolveRequestCache(mrContext);
 375                 }
 376
 377                 private void OnUpdateRequestCache(object sender, EventArgs e)
 378                 {
 379                         HttpApplication app = (HttpApplication)sender;
 380                         if (!IsMonoRailRequest(app.Context)) return;
 381                         IRailsEngineContext mrContext = ObtainContextFromApplication(sender);
 382
 383                         container.extensionManager.RaiseUpdateRequestCache(mrContext);
 384                 }
 385
 386                 #endregion
 387
 388                 private IRailsEngineContext CreateRailsEngineContext(HttpContext context)
 389                 {
 390                         IRailsEngineContext mrContext = ObtainRailsEngineContext(context);
 391
 392                         if (mrContext == null)
 393                         {
 394                                 IUrlTokenizer urlTokenizer = (IUrlTokenizer) container.GetService(typeof(IUrlTokenizer));
 395
 396                                 HttpRequest req = context.Request;
 397
 398                                 UrlInfo urlInfo = urlTokenizer.TokenizeUrl(req.FilePath, req.PathInfo, req.Url, req.IsLocal, req.ApplicationPath);
 399
 400                                 IServiceProvider userServiceProvider = ServiceProviderLocator.Instance.LocateProvider();
 401
 402                                 DefaultRailsEngineContext newContext = new DefaultRailsEngineContext(container, urlInfo, context, userServiceProvider);
 403
 404                                 context.Items[RailsContextKey] = newContext;
 405
 406                                 newContext.AddService(typeof(IRailsEngineContext), newContext);
 407
 408                                 mrContext = newContext;
 409                         }
 410
 411                         return mrContext;
 412                 }
 413
 414                 private static IRailsEngineContext ObtainContextFromApplication(object sender)
 415                 {
 416                         HttpApplication app = (HttpApplication) sender;
 417                         HttpContext context = app.Context;
 418
 419                         return ObtainRailsEngineContext(context);
 420                 }
 421
 422                 internal static bool Initialized
 423                 {
 424                         get { return container != null; }
 425                 }
 426
 427                 internal static IRailsEngineContext ObtainRailsEngineContext(HttpContext context)
 428                 {
 429                         return (IRailsEngineContext) context.Items[RailsContextKey];
 430                 }
 431         }
 432 }