MonoRail/Castle.MonoRail.Framework/Extensions/ExtensionManager.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.ComponentModel;
  19         using System.ComponentModel.Design;
  20
  21         /// <summary>
  22         ///
  23         /// </summary>
  24         /// <param name="context"></param>
  25         public delegate void ExtensionHandler(IRailsEngineContext context);
  26
  27         /// <summary>
  28         /// MonoRail's extension manager.
  29         /// It fires events related to MonoRail that can be used to add additional behaviour.
  30         /// </summary>
  31         public class ExtensionManager : MarshalByRefObject
  32         {
  33                 private static readonly object ContextCreatedEvent = new object();
  34                 private static readonly object ContextDisposedEvent = new object();
  35                 private static readonly object ActionExceptionEvent = new object();
  36                 private static readonly object UnhandledExceptionEvent = new object();
  37                 private static readonly object AcquireSessionStateEvent = new object();
  38                 private static readonly object ReleaseSessionStateEvent = new object();
  39                 private static readonly object PreProcessEvent = new object();
  40                 private static readonly object PostProcessEvent = new object();
  41                 private static readonly object AuthorizeRequestEvent = new object();
  42                 private static readonly object AuthenticateRequestEvent = new object();
  43                 private static readonly object ResolveRequestCacheEvent = new object();
  44                 private static readonly object UpdateRequestCacheEvent = new object();
  45
  46                 private EventHandlerList events;
  47
  48                 private IServiceContainer serviceContainer;
  49
  50                 /// <summary>
  51                 /// Initializes a new instance of the <see cref="ExtensionManager"/> class.
  52                 /// </summary>
  53                 /// <param name="serviceContainer">The service container.</param>
  54                 public ExtensionManager(IServiceContainer serviceContainer)
  55                 {
  56                         events = new EventHandlerList();
  57                         this.serviceContainer = serviceContainer;
  58                 }
  59
  60                 /// <summary>
  61                 /// Gets the service container.
  62                 /// </summary>
  63                 /// <value>The service container.</value>
  64                 public IServiceContainer ServiceContainer
  65                 {
  66                         get { return serviceContainer; }
  67                 }
  68
  69                 /// <summary>
  70                 /// Occurs when a context is created.
  71                 /// </summary>
  72                 public event ExtensionHandler ContextCreated
  73                 {
  74                         add { events.AddHandler(ContextCreatedEvent, value); }
  75                         remove { events.RemoveHandler(ContextCreatedEvent, value); }
  76                 }
  77
  78                 /// <summary>
  79                 /// Occurs when a context is disposed.
  80                 /// </summary>
  81                 public event ExtensionHandler ContextDisposed
  82                 {
  83                         add { events.AddHandler(ContextDisposedEvent, value); }
  84                         remove { events.RemoveHandler(ContextDisposedEvent, value); }
  85                 }
  86
  87                 /// <summary>
  88                 /// Occurs when an action throws an exception.
  89                 /// </summary>
  90                 public event ExtensionHandler ActionException
  91                 {
  92                         add { events.AddHandler(ActionExceptionEvent, value); }
  93                         remove { events.RemoveHandler(ActionExceptionEvent, value); }
  94                 }
  95
  96                 /// <summary>
  97                 /// Occurs when an unhandled exception is thrown.
  98                 /// </summary>
  99                 public event ExtensionHandler UnhandledException
 100                 {
 101                         add { events.AddHandler(UnhandledExceptionEvent, value); }
 102                         remove { events.RemoveHandler(UnhandledExceptionEvent, value); }
 103                 }
 104
 105                 /// <summary>
 106                 /// Occurs when a session is adquired.
 107                 /// </summary>
 108                 public event ExtensionHandler AcquireSessionState
 109                 {
 110                         add { events.AddHandler(AcquireSessionStateEvent, value); }
 111                         remove { events.RemoveHandler(AcquireSessionStateEvent, value); }
 112                 }
 113
 114                 /// <summary>
 115                 /// Occurs when a session is released.
 116                 /// </summary>
 117                 public event ExtensionHandler ReleaseSessionState
 118                 {
 119                         add { events.AddHandler(ReleaseSessionStateEvent, value); }
 120                         remove { events.RemoveHandler(ReleaseSessionStateEvent, value); }
 121                 }
 122
 123                 /// <summary>
 124                 /// Occurs before pre process a handler.
 125                 /// </summary>
 126                 public event ExtensionHandler PreProcess
 127                 {
 128                         add { events.AddHandler(PreProcessEvent, value); }
 129                         remove { events.RemoveHandler(PreProcessEvent, value); }
 130                 }
 131
 132                 /// <summary>
 133                 /// Occurs after process a handler.
 134                 /// </summary>
 135                 public event ExtensionHandler PostProcess
 136                 {
 137                         add { events.AddHandler(PostProcessEvent, value); }
 138                         remove { events.RemoveHandler(PostProcessEvent, value); }
 139                 }
 140
 141                 /// <summary>
 142                 /// Occurs when a request needs to authenticate.
 143                 /// </summary>
 144                 public event ExtensionHandler AuthenticateRequest
 145                 {
 146                         add { events.AddHandler(AuthenticateRequestEvent, value); }
 147                         remove { events.RemoveHandler(AuthenticateRequestEvent, value); }
 148                 }
 149
 150                 /// <summary>
 151                 /// Occurs when a request needs to be authorized.
 152                 /// </summary>
 153                 public event ExtensionHandler AuthorizeRequest
 154                 {
 155                         add { events.AddHandler(AuthorizeRequestEvent, value); }
 156                         remove { events.RemoveHandler(AuthorizeRequestEvent, value); }
 157                 }
 158
 159                 /// <summary>
 160                 /// Occurs upon request cache resolval.
 161                 /// </summary>
 162                 public event ExtensionHandler ResolveRequestCache
 163                 {
 164                         add { events.AddHandler(ResolveRequestCacheEvent, value); }
 165                         remove { events.RemoveHandler(ResolveRequestCacheEvent, value); }
 166                 }
 167
 168                 /// <summary>
 169                 /// Occurs when a cache need to be updated.
 170                 /// </summary>
 171                 public event ExtensionHandler UpdateRequestCache
 172                 {
 173                         add { events.AddHandler(UpdateRequestCacheEvent, value); }
 174                         remove { events.RemoveHandler(UpdateRequestCacheEvent, value); }
 175                 }
 176
 177                 internal void RaiseContextCreated(IRailsEngineContext context)
 178                 {
 179                         ExtensionHandler eventDelegate = (ExtensionHandler) events[ContextCreatedEvent];
 180                         if (eventDelegate != null) eventDelegate(context);
 181                 }
 182
 183                 internal void RaiseContextDisposed(IRailsEngineContext context)
 184                 {
 185                         ExtensionHandler eventDelegate = (ExtensionHandler) events[ContextDisposedEvent];
 186                         if (eventDelegate != null) eventDelegate(context);
 187                 }
 188
 189                 internal void RaisePostProcess(IRailsEngineContext context)
 190                 {
 191                         ExtensionHandler eventDelegate = (ExtensionHandler) events[PostProcessEvent];
 192                         if (eventDelegate != null) eventDelegate(context);
 193                 }
 194
 195                 internal void RaisePreProcess(IRailsEngineContext context)
 196                 {
 197                         ExtensionHandler eventDelegate = (ExtensionHandler) events[PreProcessEvent];
 198                         if (eventDelegate != null) eventDelegate(context);
 199                 }
 200
 201                 internal void RaiseReleaseRequestState(IRailsEngineContext context)
 202                 {
 203                         ExtensionHandler eventDelegate = (ExtensionHandler) events[ReleaseSessionStateEvent];
 204                         if (eventDelegate != null) eventDelegate(context);
 205                 }
 206
 207                 internal void RaiseAcquireRequestState(IRailsEngineContext context)
 208                 {
 209                         ExtensionHandler eventDelegate = (ExtensionHandler) events[AcquireSessionStateEvent];
 210                         if (eventDelegate != null) eventDelegate(context);
 211                 }
 212
 213                 internal void RaiseUnhandledError(IRailsEngineContext context)
 214                 {
 215                         ExtensionHandler eventDelegate = (ExtensionHandler) events[UnhandledExceptionEvent];
 216                         if (eventDelegate != null) eventDelegate(context);
 217                 }
 218
 219                 internal void RaiseActionError(IRailsEngineContext context)
 220                 {
 221                         ExtensionHandler eventDelegate = (ExtensionHandler) events[ActionExceptionEvent];
 222                         if (eventDelegate != null) eventDelegate(context);
 223                 }
 224
 225                 internal void RaiseAuthenticateRequest(IRailsEngineContext context)
 226                 {
 227                         ExtensionHandler eventDelegate = (ExtensionHandler) events[AuthenticateRequestEvent];
 228                         if (eventDelegate != null) eventDelegate(context);
 229                 }
 230
 231                 internal void RaiseAuthorizeRequest(IRailsEngineContext context)
 232                 {
 233                         ExtensionHandler eventDelegate = (ExtensionHandler) events[AuthorizeRequestEvent];
 234                         if (eventDelegate != null) eventDelegate(context);
 235                 }
 236
 237                 internal void RaiseResolveRequestCache(IRailsEngineContext context)
 238                 {
 239                         ExtensionHandler eventDelegate = (ExtensionHandler) events[UpdateRequestCacheEvent];
 240                         if (eventDelegate != null) eventDelegate(context);
 241                 }
 242
 243                 internal void RaiseUpdateRequestCache(IRailsEngineContext context)
 244                 {
 245                         ExtensionHandler eventDelegate = (ExtensionHandler) events[UpdateRequestCacheEvent];
 246                         if (eventDelegate != null) eventDelegate(context);
 247                 }
 248         }
 249 }