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