Facilities/ActiveRecordIntegration/Castle.Facilities.ActiveRecordIntegration/ActiveRecordFacility.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.Facilities.ActiveRecordIntegration
  16 {
  17         using System;
  18         using System.Reflection;
  19         using System.Collections;
  20         using System.Configuration;
  21
  22         using Castle.ActiveRecord;
  23         using Castle.ActiveRecord.Framework;
  24         using Castle.ActiveRecord.Framework.Config;
  25         using Castle.MicroKernel.Facilities;
  26         using Castle.Core;
  27         using Castle.Core.Configuration;
  28         using Castle.Core.Logging;
  29         using Castle.Services.Transaction;
  30
  31         using TransactionMode = Castle.Services.Transaction.TransactionMode;
  32
  33         /// <summary>
  34         /// Provides integration with ActiveRecord framework.
  35         /// </summary>
  36         public class ActiveRecordFacility : AbstractFacility
  37         {
  38                 private ILogger log = NullLogger.Instance;
  39                 private int sessionFactoryCount, sessionFactoryHolderCount;
  40
  41                 public ActiveRecordFacility()
  42                 {
  43                 }
  44
  45                 protected override void Init()
  46                 {
  47                         if (Kernel.HasComponent(typeof(ILoggerFactory)))
  48                         {
  49                                 log = ((ILoggerFactory) Kernel[typeof(ILoggerFactory)]).Create(GetType());
  50                         }
  51
  52                         log.Debug("Initializing AR Facility");
  53
  54                         if (FacilityConfig == null)
  55                         {
  56                                 log.FatalError("Configuration for AR Facility not found.");
  57                                 throw new FacilityException("Sorry, but the ActiveRecord Facility depends on a proper configuration node.");
  58                         }
  59
  60                         IConfiguration assemblyConfig = FacilityConfig.Children["assemblies"];
  61
  62                         if (assemblyConfig == null || assemblyConfig.Children.Count == 0)
  63                         {
  64                                 log.FatalError("No assembly specified on AR Facility config.");
  65
  66                                 throw new FacilityException("You need to specify at least one assembly that contains " +
  67                                         "the ActiveRecord classes. For example, <assemblies><item>MyAssembly</item></assemblies>");
  68                         }
  69
  70                         ConfigurationCollection assembliyConfigNodes = assemblyConfig.Children;
  71
  72                         ArrayList assemblies = new ArrayList(assembliyConfigNodes.Count);
  73
  74                         foreach(IConfiguration assemblyNode in assembliyConfigNodes)
  75                         {
  76                                 assemblies.Add(ObtainAssembly(assemblyNode.Value));
  77                         }
  78
  79                         Kernel.ComponentCreated += new Castle.MicroKernel.ComponentInstanceDelegate(Kernel_ComponentCreated);
  80
  81                         SetUpTransactionManager();
  82
  83                         InitializeFramework(assemblies);
  84                 }
  85
  86                 public override void Dispose()
  87                 {
  88                         log.Info("AR Facility is being disposed.");
  89                         base.Dispose();
  90                 }
  91
  92                 private void InitializeFramework(ArrayList assemblies)
  93                 {
  94                         log.Info("Initializing ActiveRecord Framework");
  95
  96                         ActiveRecordStarter.ResetInitializationFlag();
  97                         ActiveRecordStarter.SessionFactoryHolderCreated += new SessionFactoryHolderDelegate(OnSessionFactoryHolderCreated);
  98
  99                         try
 100                         {
 101                                 ConfigurationSourceAdapter adapter = new ConfigurationSourceAdapter(FacilityConfig);
 102
 103                                 if (log.IsDebugEnabled)
 104                                 {
 105                                         log.Debug("Is Debug enabled {0}", adapter.Debug);
 106                                         log.Debug("ThreadScopeInfo {0}", adapter.ThreadScopeInfoImplementation);
 107                                         log.Debug("NamingStrategy {0}", adapter.NamingStrategyImplementation);
 108                                         log.Debug("SessionFactoryHolder {0}", adapter.SessionFactoryHolderImplementation);
 109                                 }
 110
 111                                 ActiveRecordStarter.Initialize(
 112                                         (Assembly[]) assemblies.ToArray(typeof(Assembly)), adapter);
 113                         }
 114                         finally
 115                         {
 116                                 ActiveRecordStarter.SessionFactoryHolderCreated -= new SessionFactoryHolderDelegate(OnSessionFactoryHolderCreated);
 117                         }
 118                 }
 119
 120                 private void SetUpTransactionManager()
 121                 {
 122                         if (!Kernel.HasComponent(typeof(ITransactionManager)))
 123                         {
 124                                 log.Info("No Transaction Manager registered on Kernel, registering AR Transaction Manager");
 125
 126                                 Kernel.AddComponent("ar.transaction.manager",
 127                                                     typeof(ITransactionManager), typeof(DefaultTransactionManager));
 128                         }
 129                 }
 130
 131                 private void OnNewTransaction(ITransaction transaction, TransactionMode transactionMode, IsolationMode isolationMode, bool distributedTransaction)
 132                 {
 133                         if (!transaction.DistributedTransaction)
 134                         {
 135                                 transaction.Enlist(new TransactionScopeResourceAdapter(transactionMode));
 136                         }
 137                 }
 138
 139                 private Assembly ObtainAssembly(String assemblyName)
 140                 {
 141                         log.Debug("Loading model assembly '{0}' for AR", assemblyName);
 142                         return Assembly.Load(assemblyName);
 143                 }
 144
 145                 private void Kernel_ComponentCreated(ComponentModel model, object instance)
 146                 {
 147                         if (model.Service != null && model.Service == typeof(ITransactionManager))
 148                         {
 149                                 (instance as ITransactionManager).TransactionCreated += new TransactionCreationInfoDelegate(OnNewTransaction);
 150                         }
 151                 }
 152
 153                 private void OnSessionFactoryHolderCreated(Castle.ActiveRecord.Framework.ISessionFactoryHolder holder)
 154                 {
 155                         holder.OnRootTypeRegistered += new RootTypeHandler(OnRootTypeRegistered);
 156
 157                         string componentName = "activerecord.sessionfactoryholder";
 158
 159                         if (Kernel.HasComponent(componentName))
 160                         {
 161                                 componentName += "." + (++sessionFactoryHolderCount);
 162                         }
 163
 164                         while(Kernel.HasComponent(componentName))
 165                         {
 166                                 componentName =
 167                                         componentName.Substring(0, componentName.LastIndexOf('.'))
 168                                                 + (++sessionFactoryHolderCount);
 169                         }
 170
 171                         log.Info("Registering SessionFactoryHolder named '{0}': {1}", componentName, holder);
 172                         Kernel.AddComponentInstance(
 173                                 componentName, typeof(ISessionFactoryHolder), holder);
 174                 }
 175
 176                 private void OnRootTypeRegistered(object sender, Type rootType)
 177                 {
 178                         string componentName = "activerecord.sessionfactory";
 179
 180                         if (Kernel.HasComponent(componentName))
 181                         {
 182                                 componentName += "." + (++sessionFactoryCount);
 183                         }
 184
 185                         while(Kernel.HasComponent(componentName))
 186                         {
 187                                 componentName =
 188                                         componentName.Substring(0, componentName.LastIndexOf('.'))
 189                                                 + (++sessionFactoryCount);
 190                         }
 191
 192                         log.Info("Registering SessionFactory named '{0}' for the root type {1}: {2}", componentName, rootType, sender);
 193                         Kernel.AddComponentInstance(
 194                                 componentName,
 195                                 typeof(NHibernate.ISessionFactory),
 196                                 new SessionFactoryDelegate((ISessionFactoryHolder) sender, rootType));
 197                 }
 198         }
 199
 200         internal class ConfigurationSourceAdapter : InPlaceConfigurationSource
 201         {
 202                 public ConfigurationSourceAdapter(IConfiguration facilityConfig)
 203                 {
 204                         String isWeb = facilityConfig.Attributes["isWeb"];
 205                         String threadinfotype = facilityConfig.Attributes["threadinfotype"];
 206                         string isDebug = facilityConfig.Attributes["isDebug"];
 207                         string sessionfactoryholdertype = facilityConfig.Attributes["sessionfactoryholdertype"];
 208                         string isLazyByDefault = facilityConfig.Attributes["default-lazy"];
 209                         string pluralize = facilityConfig.Attributes["pluralizeTableNames"];
 210                         string verifyModelsAgainstDBSchema = facilityConfig.Attributes["verifyModelsAgainstDBSchema"];
 211
 212                         SetUpThreadInfoType(ConvertBool(isWeb), threadinfotype);
 213                         SetDebugFlag(ConvertBool(isDebug));
 214                         SetUpSessionFactoryHolderType(sessionfactoryholdertype);
 215                         SetIsLazyByDefault(ConvertBool(isLazyByDefault));
 216                         PluralizeTableNames = ConvertBool(pluralize);
 217                         VerifyModelsAgainstDBSchema = ConvertBool(verifyModelsAgainstDBSchema);
 218
 219                         foreach(IConfiguration config in facilityConfig.Children)
 220                         {
 221                                 if (!"config".Equals(config.Name)) continue;
 222
 223                                 Type type = typeof(ActiveRecordBase);
 224
 225                                 String typeAtt = config.Attributes["type"];
 226
 227                                 if (typeAtt != null)
 228                                 {
 229                                         type = ObtainType(typeAtt);
 230                                 }
 231
 232                                 Add(type, AdjustConfiguration(config));
 233                         }
 234                 }
 235
 236                 private IConfiguration AdjustConfiguration(IConfiguration config)
 237                 {
 238                         MutableConfiguration newConfig = new MutableConfiguration("entry");
 239
 240                         foreach(IConfiguration configNode in config.Children)
 241                         {
 242                                 String key = configNode.Attributes["key"];
 243                                 String value = configNode.Attributes["value"];
 244
 245                                 newConfig.Children.Add(new MutableConfiguration(key, value));
 246                         }
 247
 248                         return newConfig;
 249                 }
 250
 251                 private static Type ObtainType(String typeAtt)
 252                 {
 253                         Type type = Type.GetType(typeAtt, false, false);
 254
 255                         if (type == null)
 256                         {
 257                                 String message = String.Format("Could not obtain type from name {0}", typeAtt);
 258
 259                                 throw new ConfigurationErrorsException(message);
 260                         }
 261
 262                         return type;
 263                 }
 264
 265                 private static bool ConvertBool(string boolString)
 266                 {
 267                         return "true".Equals(boolString, StringComparison.OrdinalIgnoreCase);
 268                 }
 269         }
 270 }