MonoRail/Castle.MonoRail.Framework/BaseHttpHandler.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.Collections;
  19         using System.Web;
  20         using System.Web.SessionState;
  21         using Adapters;
  22
  23         /// <summary>
  24         /// Pendent
  25         /// </summary>
  26         public abstract class BaseHttpHandler : IHttpHandler
  27         {
  28                 private readonly IController controller;
  29                 private readonly IControllerContext controllerContext;
  30                 private readonly IEngineContext engineContext;
  31                 private readonly bool sessionless;
  32
  33                 /// <summary>
  34                 /// Initializes a new instance of the <see cref="BaseHttpHandler"/> class.
  35                 /// </summary>
  36                 /// <param name="engineContext">The engine context.</param>
  37                 /// <param name="controller">The controller.</param>
  38                 /// <param name="controllerContext">The controller context.</param>
  39                 /// <param name="sessionless">if set to <c>true</c> then we wont have a session to work.</param>
  40                 protected BaseHttpHandler(IEngineContext engineContext,
  41                                                                   IController controller, IControllerContext controllerContext, bool sessionless)
  42                 {
  43                         this.controller = controller;
  44                         this.controllerContext = controllerContext;
  45                         this.engineContext = engineContext;
  46                         this.sessionless = sessionless;
  47                 }
  48
  49                 #region IHttpHandler
  50
  51                 /// <summary>
  52                 /// Pendent
  53                 /// </summary>
  54                 /// <param name="context"></param>
  55                 public void ProcessRequest(HttpContext context)
  56                 {
  57                         Process(context);
  58                 }
  59
  60                 /// <summary>
  61                 /// Pendent
  62                 /// </summary>
  63                 public bool IsReusable
  64                 {
  65                         get { return false; }
  66                 }
  67
  68                 #endregion
  69
  70                 /// <summary>
  71                 /// Performs the base work of MonoRail. Extracts
  72                 /// the information from the URL, obtain the controller
  73                 /// that matches this information and dispatch the execution
  74                 /// to it.
  75                 /// </summary>
  76                 /// <param name="context">The context.</param>
  77                 public virtual void Process(HttpContext context)
  78                 {
  79                         if (!sessionless)
  80                         {
  81                                 // Now we have a session
  82                                 engineContext.Session = ResolveSession(context);
  83                         }
  84
  85                         IDictionary session = engineContext.Session;
  86
  87                         Flash flash;
  88
  89                         if (session != null)
  90                         {
  91                                 flash = new Flash((Flash) session[Flash.FlashKey]);
  92                         }
  93                         else
  94                         {
  95                                 flash = new Flash();
  96                         }
  97
  98                         engineContext.Flash = flash;
  99
 100                         // items added to be used by the test context
 101                         context.Items["mr.controller"] = controller;
 102                         context.Items["mr.flash"] = engineContext.Flash;
 103                         context.Items["mr.propertybag"] = controllerContext.PropertyBag;
 104                         context.Items["mr.session"] = context.Session;
 105
 106                         AcquireCustomSession();
 107
 108                         try
 109                         {
 110                                 engineContext.Services.ExtensionManager.RaisePreProcessController(engineContext);
 111
 112                                 controller.Process(engineContext, controllerContext);
 113
 114                                 engineContext.Services.ExtensionManager.RaisePostProcessController(engineContext);
 115                         }
 116                         catch(Exception ex)
 117                         {
 118                                 HttpResponse response = context.Response;
 119
 120                                 if (response.StatusCode == 200)
 121                                 {
 122                                         response.StatusCode = 500;
 123                                 }
 124
 125                                 engineContext.LastException = ex;
 126
 127                                 engineContext.Services.ExtensionManager.RaiseUnhandledError(engineContext);
 128
 129                                 throw new MonoRailException("Error processing MonoRail request. Action " +
 130                                                             controllerContext.Action + " on controller " + controllerContext.Name, ex);
 131                         }
 132                         finally
 133                         {
 134                                 if (!sessionless)
 135                                 {
 136                                         PersistFlashItems();
 137                                 }
 138
 139                                 PersistCustomSession();
 140
 141                                 ReleaseController(controller);
 142                         }
 143                 }
 144
 145                 /// <summary>
 146                 /// Resolves the session.
 147                 /// </summary>
 148                 /// <param name="context">The context.</param>
 149                 /// <returns></returns>
 150                 protected virtual IDictionary ResolveSession(HttpContext context)
 151                 {
 152                         object session;
 153
 154                         if (context.Items["AspSession"] != null)
 155                         {
 156                                 // Windows and Testing
 157                                 session = context.Items["AspSession"];
 158                         }
 159                         else
 160                         {
 161                                 // Mono
 162                                 session = context.Session;
 163                         }
 164
 165                         if (session is HttpSessionState)
 166                         {
 167                                 return new SessionAdapter(session as HttpSessionState);
 168                         }
 169                         else
 170                         {
 171                                 return (IDictionary)session;
 172                         }
 173                 }
 174
 175                 /// <summary>
 176                 /// Acquires the custom session from the custom session.
 177                 /// </summary>
 178                 protected virtual void AcquireCustomSession()
 179                 {
 180                         engineContext.Services.ExtensionManager.RaiseAcquireRequestState(engineContext);
 181                 }
 182
 183                 /// <summary>
 184                 /// Persists the custom session to the custom session.
 185                 /// </summary>
 186                 protected virtual void PersistCustomSession()
 187                 {
 188                         engineContext.Services.ExtensionManager.RaiseReleaseRequestState(engineContext);
 189                 }
 190
 191                 private void ReleaseController(IController controller)
 192                 {
 193                         engineContext.Services.ControllerFactory.Release(controller);
 194                 }
 195
 196                 private void PersistFlashItems()
 197                 {
 198                         Flash currentFlash = engineContext.Flash;
 199
 200                         if (currentFlash == null) return;
 201
 202                         currentFlash.Sweep();
 203
 204                         if (currentFlash.HasItemsToKeep)
 205                         {
 206                                 engineContext.Session[Flash.FlashKey] = currentFlash;
 207                         }
 208                         else if (engineContext.Session.Contains(Flash.FlashKey))
 209                         {
 210                                 engineContext.Session.Remove(Flash.FlashKey);
 211                         }
 212                 }
 213         }
 214 }