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