MonoRail/Castle.MonoRail.Framework/MonoRailServiceContainer.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.Collections.Specialized;
  20         using System.ComponentModel;
  21         using System.Configuration;
  22         using System.IO;
  23         using System.Xml;
  24         using Castle.Components.Validator;
  25         using Castle.Core;
  26         using Castle.MonoRail.Framework.Configuration;
  27         using Castle.MonoRail.Framework.Internal;
  28         using Castle.MonoRail.Framework.Services;
  29         using Castle.MonoRail.Framework.Services.AjaxProxyGenerator;
  30
  31         /// <summary>
  32         /// Parent Service container for the MonoRail framework
  33         /// </summary>
  34         public class MonoRailServiceContainer : AbstractServiceContainer
  35         {
  36                 /// <summary></summary>
  37                 private static string mrExtension = ".castle";
  38
  39                 /// <summary>The only one Extension Manager</summary>
  40                 protected internal ExtensionManager extensionManager;
  41
  42                 /// <summary>Prevents GC from collecting the extensions</summary>
  43                 private IList extensions = new ArrayList();
  44
  45                 /// <summary>Keeps only one copy of the config</summary>
  46                 private MonoRailConfiguration config;
  47
  48
  49                 /// <summary>
  50                 /// Initializes a new instance of the <see cref="MonoRailServiceContainer"/> class.
  51                 /// </summary>
  52                 public MonoRailServiceContainer()
  53                 {
  54                 }
  55
  56                 /// <summary>
  57                 /// Initializes a new instance of the <see cref="MonoRailServiceContainer"/> class.
  58                 /// </summary>
  59                 /// <param name="config">The config.</param>
  60                 public MonoRailServiceContainer(MonoRailConfiguration config) : this()
  61                 {
  62                         this.config = config;
  63                 }
  64
  65                 /// <summary>
  66                 /// Allows registration without the configuration
  67                 /// </summary>
  68                 public void RegisterBaseService(Type service, object instance)
  69                 {
  70                         InvokeServiceEnabled(instance);
  71                         InvokeInitialize(instance);
  72
  73                         AddService(service, instance);
  74                 }
  75
  76                 /// <summary>
  77                 /// Initializes the container state and its services
  78                 /// </summary>
  79                 public void Start()
  80                 {
  81                         DiscoverHttpHandlerExtensions();
  82
  83                         InitConfiguration();
  84
  85                         MonoRailConfiguration config = ObtainConfiguration();
  86
  87                         InitExtensions(config);
  88                         InitServices(config);
  89                 }
  90
  91                 /// <summary>
  92                 /// Checks whether the specified URL is to be handled by MonoRail
  93                 /// </summary>
  94                 /// <param name="url">The URL.</param>
  95                 /// <returns>
  96                 /// <see langword="true"/> if it is a MonoRail request; otherwise, <see langword="false"/>.
  97                 /// </returns>
  98                 public bool IsMonoRailRequest(String url)
  99                 {
 100                         String extension = Path.GetExtension(url);
 101
 102                         return string.Compare(mrExtension, extension, StringComparison.InvariantCultureIgnoreCase) == 0;
 103                 }
 104
 105                 /// <summary></summary>
 106                 public static string MonoRailExtension
 107                 {
 108                         get { return mrExtension; }
 109                 }
 110
 111                 private static void DiscoverHttpHandlerExtensions()
 112                 {
 113                         XmlDocument webConfig = new XmlDocument();
 114                         webConfig.Load(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "web.config"));
 115
 116                         XmlNodeList addNodes = webConfig.DocumentElement.SelectNodes(
 117                                 "/configuration/system.web/httpHandlers/add");
 118
 119                         if (addNodes.Count == 0)
 120                         {
 121                                 // Possibly the web.config configuration node is using a namespace declaration
 122
 123                                 XmlElement systemWebElem = webConfig.DocumentElement["system.web"];
 124                                 XmlElement handlers = systemWebElem["httpHandlers"];
 125                                 addNodes = handlers.ChildNodes;
 126                         }
 127
 128                         bool found = false;
 129
 130                         foreach(XmlNode addNode in addNodes)
 131                         {
 132                                 if (addNode.NodeType != XmlNodeType.Element)
 133                                 {
 134                                         continue;
 135                                 }
 136
 137                                 XmlElement addElem = (XmlElement) addNode;
 138
 139                                 String type = addElem.GetAttribute("type");
 140
 141                                 if (type.StartsWith("Castle.MonoRail.Framework.MonoRailHttpHandlerFactory"))
 142                                 {
 143                                         mrExtension = addElem.GetAttribute("path").Substring(1);
 144                                         found = true;
 145                                 }
 146                         }
 147
 148                         if (!found)
 149                         {
 150                                 throw new RailsException("We inspected the web.config httpHandlers section and " +
 151                                                          "couldn't find an extension that mapped to MonoRailHttpHandlerFactory. " +
 152                                                          "Is your configuration right to use MonoRail?");
 153                         }
 154                 }
 155
 156                 /// <summary>
 157                 /// Reads the configuration and initializes
 158                 /// registered extensions.
 159                 /// </summary>
 160                 /// <param name="config">The configuration object</param>
 161                 private void InitExtensions(MonoRailConfiguration config)
 162                 {
 163                         extensionManager = new ExtensionManager(this);
 164
 165                         foreach(ExtensionEntry entry in config.ExtensionEntries)
 166                         {
 167                                 AssertImplementsService(typeof(IMonoRailExtension), entry.ExtensionType);
 168
 169                                 IMonoRailExtension extension = (IMonoRailExtension) ActivateService(entry.ExtensionType);
 170
 171                                 extension.SetExtensionConfigNode(entry.ExtensionNode);
 172
 173                                 extensions.Add(extension);
 174                         }
 175                 }
 176
 177                 /// <summary>
 178                 /// Coordinates the instantiation, registering and initialization (lifecycle-wise)
 179                 /// of the services used by MonoRail.
 180                 /// </summary>
 181                 /// <param name="config">The configuration object</param>
 182                 private void InitServices(MonoRailConfiguration config)
 183                 {
 184                         AddService(typeof(ExtensionManager), extensionManager);
 185                         AddService(typeof(MonoRailConfiguration), config);
 186
 187                         IList services = InstantiateAndRegisterServices(config.ServiceEntries);
 188
 189                         LifecycleService(services);
 190                         LifecycleService(extensions);
 191
 192                         LifecycleInitialize(services);
 193                         LifecycleInitialize(extensions);
 194                 }
 195
 196                 /// <summary>
 197                 /// Checks for services that implements <see cref="IInitializable"/>
 198                 /// or <see cref="ISupportInitialize"/> and initialize them through the interface
 199                 /// </summary>
 200                 /// <param name="services">List of MonoRail's services</param>
 201                 private void LifecycleInitialize(IList services)
 202                 {
 203                         foreach(object instance in services)
 204                         {
 205                                 InvokeInitialize(instance);
 206                         }
 207                 }
 208
 209                 /// <summary>
 210                 /// Checks for services that implements <see cref="IServiceEnabledComponent"/>
 211                 /// and invoke <see cref="IServiceEnabledComponent.Service"/> on them
 212                 /// </summary>
 213                 /// <param name="services">List of MonoRail's services</param>
 214                 private void LifecycleService(IList services)
 215                 {
 216                         foreach(object instance in services)
 217                         {
 218                                 InvokeServiceEnabled(instance);
 219                         }
 220                 }
 221
 222                 /// <summary>
 223                 /// Instantiates and registers the services used by MonoRail.
 224                 /// </summary>
 225                 /// <param name="services">The service's registry</param>
 226                 /// <returns>List of service's instances</returns>
 227                 private IList InstantiateAndRegisterServices(ServiceEntryCollection services)
 228                 {
 229                         IList instances = new ArrayList();
 230
 231                         // Builtin services
 232
 233                         foreach(DictionaryEntry entry in services.ServiceImplMap)
 234                         {
 235                                 Type service = (Type) entry.Key;
 236                                 Type impl = (Type) entry.Value;
 237
 238                                 AssertImplementsService(service, impl);
 239
 240                                 object instance = ActivateService(impl);
 241
 242                                 AddService(service, instance);
 243
 244                                 instances.Add(instance);
 245                         }
 246
 247                         // Custom services
 248
 249                         foreach(Type type in services.CustomServices)
 250                         {
 251                                 object instance = ActivateService(type);
 252
 253                                 AddService(type, instance);
 254
 255                                 instances.Add(instance);
 256                         }
 257
 258                         return instances;
 259                 }
 260
 261                 /// <summary>
 262                 /// Registers the default implementation of services, if
 263                 /// they are not registered
 264                 /// </summary>
 265                 private void InitConfiguration()
 266                 {
 267                         config = ObtainConfiguration();
 268
 269                         RegisterMissingServices(config);
 270                 }
 271
 272                 /// <summary>
 273                 /// Checks whether non-optional services were supplied
 274                 /// through the configuration, and if not, register the
 275                 /// default implementation.
 276                 /// </summary>
 277                 /// <param name="config">The configuration object</param>
 278                 private void RegisterMissingServices(MonoRailConfiguration config)
 279                 {
 280                         ServiceEntryCollection services = config.ServiceEntries;
 281
 282                         services.RegisterService(ServiceIdentification.ViewEngineManager,
 283                                                  typeof(DefaultViewEngineManager));
 284
 285
 286                         if (!services.HasService(ServiceIdentification.ViewSourceLoader))
 287                         {
 288                                 services.RegisterService(ServiceIdentification.ViewSourceLoader,
 289                                                          typeof(FileAssemblyViewSourceLoader));
 290                         }
 291                         if (!services.HasService(ServiceIdentification.ScaffoldingSupport))
 292                         {
 293                                 Type defaultScaffoldingType =
 294                                         TypeLoadUtil.GetType(
 295                                                 TypeLoadUtil.GetEffectiveTypeName(
 296                                                         "Castle.MonoRail.ActiveRecordScaffold.ScaffoldingSupport, Castle.MonoRail.ActiveRecordScaffold"), true);
 297
 298                                 if (defaultScaffoldingType != null)
 299                                 {
 300                                         services.RegisterService(ServiceIdentification.ScaffoldingSupport, defaultScaffoldingType);
 301                                 }
 302                         }
 303                         if (!services.HasService(ServiceIdentification.ControllerFactory))
 304                         {
 305                                 if (config.ControllersConfig.CustomControllerFactory != null)
 306                                 {
 307                                         services.RegisterService(ServiceIdentification.ControllerFactory,
 308                                                                  config.ControllersConfig.CustomControllerFactory);
 309                                 }
 310                                 else
 311                                 {
 312                                         services.RegisterService(ServiceIdentification.ControllerFactory,
 313                                                                  typeof(DefaultControllerFactory));
 314                                 }
 315                         }
 316                         if (!services.HasService(ServiceIdentification.ViewComponentFactory))
 317                         {
 318                                 if (config.ViewComponentsConfig.CustomViewComponentFactory != null)
 319                                 {
 320                                         services.RegisterService(ServiceIdentification.ViewComponentFactory,
 321                                                                  config.ViewComponentsConfig.CustomViewComponentFactory);
 322                                 }
 323                                 else
 324                                 {
 325                                         services.RegisterService(ServiceIdentification.ViewComponentFactory,
 326                                                                  typeof(DefaultViewComponentFactory));
 327                                 }
 328                         }
 329                         if (!services.HasService(ServiceIdentification.FilterFactory))
 330                         {
 331                                 if (config.CustomFilterFactory != null)
 332                                 {
 333                                         services.RegisterService(ServiceIdentification.FilterFactory,
 334                                                                  config.CustomFilterFactory);
 335                                 }
 336                                 else
 337                                 {
 338                                         services.RegisterService(ServiceIdentification.FilterFactory,
 339                                                                  typeof(DefaultFilterFactory));
 340                                 }
 341                         }
 342                         if (!services.HasService(ServiceIdentification.ResourceFactory))
 343                         {
 344                                 services.RegisterService(ServiceIdentification.ResourceFactory, typeof(DefaultResourceFactory));
 345                         }
 346                         if (!services.HasService(ServiceIdentification.EmailSender))
 347                         {
 348                                 services.RegisterService(ServiceIdentification.EmailSender, typeof(MonoRailSmtpSender));
 349                         }
 350                         if (!services.HasService(ServiceIdentification.ControllerDescriptorProvider))
 351                         {
 352                                 services.RegisterService(ServiceIdentification.ControllerDescriptorProvider,
 353                                                          typeof(DefaultControllerDescriptorProvider));
 354                         }
 355                         if (!services.HasService(ServiceIdentification.ResourceDescriptorProvider))
 356                         {
 357                                 services.RegisterService(ServiceIdentification.ResourceDescriptorProvider, typeof(DefaultResourceDescriptorProvider));
 358                         }
 359                         if (!services.HasService(ServiceIdentification.RescueDescriptorProvider))
 360                         {
 361                                 services.RegisterService(ServiceIdentification.RescueDescriptorProvider, typeof(DefaultRescueDescriptorProvider));
 362                         }
 363                         if (!services.HasService(ServiceIdentification.LayoutDescriptorProvider))
 364                         {
 365                                 services.RegisterService(ServiceIdentification.LayoutDescriptorProvider, typeof(DefaultLayoutDescriptorProvider));
 366                         }
 367                         if (!services.HasService(ServiceIdentification.HelperDescriptorProvider))
 368                         {
 369                                 services.RegisterService(ServiceIdentification.HelperDescriptorProvider, typeof(DefaultHelperDescriptorProvider));
 370                         }
 371                         if (!services.HasService(ServiceIdentification.FilterDescriptorProvider))
 372                         {
 373                                 services.RegisterService(ServiceIdentification.FilterDescriptorProvider, typeof(DefaultFilterDescriptorProvider));
 374                         }
 375                         if (!services.HasService(ServiceIdentification.EmailTemplateService))
 376                         {
 377                                 services.RegisterService(ServiceIdentification.EmailTemplateService, typeof(EmailTemplateService));
 378                         }
 379                         if (!services.HasService(ServiceIdentification.ControllerTree))
 380                         {
 381                                 services.RegisterService(ServiceIdentification.ControllerTree, typeof(DefaultControllerTree));
 382                         }
 383                         if (!services.HasService(ServiceIdentification.CacheProvider))
 384                         {
 385                                 services.RegisterService(ServiceIdentification.CacheProvider, typeof(DefaultCacheProvider));
 386                         }
 387                         if (!services.HasService(ServiceIdentification.ExecutorFactory))
 388                         {
 389                                 services.RegisterService(ServiceIdentification.ExecutorFactory, typeof(DefaultControllerLifecycleExecutorFactory));
 390
 391                                 if (!services.HasService(ServiceIdentification.TransformationFilterFactory))
 392                                 {
 393                                         services.RegisterService(ServiceIdentification.TransformationFilterFactory, typeof(DefaultTransformFilterFactory));
 394                                 }
 395                                 if (!services.HasService(ServiceIdentification.TransformFilterDescriptorProvider))
 396                                 {
 397                                         services.RegisterService(ServiceIdentification.TransformFilterDescriptorProvider,
 398                                                                  typeof(DefaultTransformFilterDescriptorProvider));
 399                                 }
 400                         }
 401                         if (!services.HasService(ServiceIdentification.UrlBuilder))
 402                         {
 403                                 services.RegisterService(ServiceIdentification.UrlBuilder, typeof(DefaultUrlBuilder));
 404                         }
 405                         if (!services.HasService(ServiceIdentification.UrlTokenizer))
 406                         {
 407                                 services.RegisterService(ServiceIdentification.UrlTokenizer, typeof(DefaultUrlTokenizer));
 408                         }
 409                         if (!services.HasService(ServiceIdentification.ValidatorRegistry))
 410                         {
 411                                 services.RegisterService(ServiceIdentification.ValidatorRegistry, typeof(CachedValidationRegistry));
 412                         }
 413
 414                         if (!services.HasService(ServiceIdentification.AjaxProxyGenerator))
 415                         {
 416                                 services.RegisterService(ServiceIdentification.AjaxProxyGenerator, typeof(PrototypeAjaxProxyGenerator));
 417                         }
 418                 }
 419
 420                 private object ActivateService(Type type)
 421                 {
 422                         try
 423                         {
 424                                 return Activator.CreateInstance(type);
 425                         }
 426                         catch(Exception ex)
 427                         {
 428                                 String message = String.Format("Initialization Exception: " +
 429                                                                "Could not instantiate {0}", type.FullName);
 430                                 throw new ConfigurationErrorsException(message, ex);
 431                         }
 432                 }
 433
 434                 private void InvokeInitialize(object instance)
 435                 {
 436                         IInitializable initializable = instance as IInitializable;
 437
 438                         if (initializable != null)
 439                         {
 440                                 initializable.Initialize();
 441                         }
 442
 443                         ISupportInitialize suppInitialize = instance as ISupportInitialize;
 444
 445                         if (suppInitialize != null)
 446                         {
 447                                 suppInitialize.BeginInit();
 448                                 suppInitialize.EndInit();
 449                         }
 450                 }
 451
 452                 private void InvokeServiceEnabled(object instance)
 453                 {
 454                         IServiceEnabledComponent serviceEnabled = instance as IServiceEnabledComponent;
 455
 456                         if (serviceEnabled != null)
 457                         {
 458                                 serviceEnabled.Service(this);
 459                         }
 460                 }
 461
 462                 private MonoRailConfiguration ObtainConfiguration()
 463                 {
 464                         if (config == null)
 465                         {
 466                                 config = MonoRailConfiguration.GetConfig();
 467                         }
 468
 469                         return config;
 470                 }
 471
 472                 private void AssertImplementsService(Type service, Type impl)
 473                 {
 474                         if (!service.IsAssignableFrom(impl))
 475                         {
 476                                 String message = String.Format("Initialization Exception: " +
 477                                                                "Service {0} does not implement or extend {1}", impl.FullName, service.FullName);
 478                                 throw new ConfigurationErrorsException(message);
 479                         }
 480                 }
 481         }
 482 }