ActiveRecord/Castle.ActiveRecord/Framework/Config/InPlaceConfigurationSource.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.ActiveRecord.Framework.Config
  16 {
  17         using System;
  18         using System.Collections;
  19         using System.Collections.Generic;
  20         using System.Configuration;
  21         using System.Text.RegularExpressions;
  22         using Castle.ActiveRecord.Framework.Scopes;
  23         using Castle.Core.Configuration;
  24
  25         /// <summary>
  26         /// Enum for database types support for configuration construction.
  27         /// Not to be confused by databases supported by ActiveRecord
  28         /// </summary>
  29         public enum DatabaseType
  30         {
  31                 /// <summary>
  32                 /// Microsoft SQL Server
  33                 /// </summary>
  34                 MSSQLServer
  35         }
  36
  37         /// <summary>
  38         /// Usefull for test cases.
  39         /// </summary>
  40         public class InPlaceConfigurationSource : IConfigurationSource
  41         {
  42                 private readonly IDictionary<Type, IConfiguration> _type2Config = new Dictionary<Type, IConfiguration>();
  43                 private Type threadScopeInfoImplementation;
  44                 private Type sessionFactoryHolderImplementation;
  45                 private Type namingStrategyImplementation;
  46                 private bool debug;
  47                 private bool isLazyByDefault;
  48                 private bool pluralizeTableNames;
  49                 private bool verifyModelsAgainstDBSchema;
  50
  51                 /// <summary>
  52                 /// Initializes a new instance of the <see cref="InPlaceConfigurationSource"/> class.
  53                 /// </summary>
  54                 public InPlaceConfigurationSource()
  55                 {
  56                 }
  57
  58                 #region IConfigurationSource Members
  59
  60                 /// <summary>
  61                 /// Return a type that implements
  62                 /// the interface <see cref="IThreadScopeInfo"/>
  63                 /// </summary>
  64                 /// <value></value>
  65                 public Type ThreadScopeInfoImplementation
  66                 {
  67                         get { return threadScopeInfoImplementation; }
  68                         set { threadScopeInfoImplementation = value; }
  69                 }
  70
  71                 /// <summary>
  72                 /// Return a type that implements
  73                 /// the interface <see cref="ISessionFactoryHolder"/>
  74                 /// </summary>
  75                 /// <value></value>
  76                 public Type SessionFactoryHolderImplementation
  77                 {
  78                         get { return sessionFactoryHolderImplementation; }
  79                         set { sessionFactoryHolderImplementation = value; }
  80                 }
  81
  82                 /// <summary>
  83                 /// Return a type that implements
  84                 /// the interface NHibernate.Cfg.INamingStrategy
  85                 /// </summary>
  86                 /// <value></value>
  87                 public Type NamingStrategyImplementation
  88                 {
  89                         get { return namingStrategyImplementation; }
  90                         set { namingStrategyImplementation = value; }
  91                 }
  92
  93                 /// <summary>
  94                 /// Return an <see cref="IConfiguration"/> for the specified type.
  95                 /// </summary>
  96                 /// <param name="type"></param>
  97                 /// <returns></returns>
  98                 public IConfiguration GetConfiguration(Type type)
  99                 {
 100                         IConfiguration configuration;
 101                         _type2Config.TryGetValue(type, out configuration);
 102                         return configuration;
 103                 }
 104
 105                 /// <summary>
 106                 /// Gets a value indicating whether this <see cref="IConfigurationSource"/> produce debug information
 107                 /// </summary>
 108                 /// <value><c>true</c> if debug; otherwise, <c>false</c>.</value>
 109                 public bool Debug
 110                 {
 111                         get { return debug; }
 112                 }
 113
 114                 /// <summary>
 115                 /// Gets a value indicating whether the entities should be lazy by default.
 116                 /// </summary>
 117                 /// <value>
 118                 ///     <c>true</c> if entities should be lazy by default; otherwise, <c>false</c>.
 119                 /// </value>
 120                 public bool IsLazyByDefault
 121                 {
 122                         get { return isLazyByDefault; }
 123                 }
 124
 125                 /// <summary>
 126                 /// Gets a value indicating whether table names are assumed plural by default.
 127                 /// </summary>
 128                 /// <value>
 129                 ///     <c>true</c> if table names should be pluralized by default; otherwise, <c>false</c>.
 130                 /// </value>
 131                 public bool PluralizeTableNames
 132                 {
 133                         get { return pluralizeTableNames; }
 134                         set { pluralizeTableNames = value; }
 135                 }
 136
 137                 /// <summary>
 138                 /// Gets or Sets a value indicating whether the models should be verified against the db schema on Initialisation.
 139                 /// </summary>
 140                 /// <value>
 141                 ///     <c>true</c> if models should be verified; otherwise, <c>false</c>.
 142                 /// </value>
 143                 public bool VerifyModelsAgainstDBSchema
 144                 {
 145                         get { return verifyModelsAgainstDBSchema; }
 146                         set { verifyModelsAgainstDBSchema = value; }
 147                 }
 148
 149                 #endregion
 150
 151                 /// <summary>
 152                 /// Builds a InPlaceConfigurationSource set up to access a MS SQL server database using integrated security.
 153                 /// </summary>
 154                 /// <param name="server">The server.</param>
 155                 /// <param name="initialCatalog">The initial catalog.</param>
 156                 /// <returns></returns>
 157                 public static InPlaceConfigurationSource BuildForMSSqlServer(string server, string initialCatalog)
 158                 {
 159                         if (string.IsNullOrEmpty(server)) throw new ArgumentNullException("server");
 160                         if (string.IsNullOrEmpty(initialCatalog)) throw new ArgumentNullException("initialCatalog");
 161
 162                         return Build(DatabaseType.MSSQLServer, "Server=" + server + ";initial catalog=" + initialCatalog + ";Integrated Security=SSPI");
 163                 }
 164
 165                 /// <summary>
 166                 /// Builds a InPlaceConfigurationSource set up to access a MS SQL server database using the specified username and password.
 167                 /// </summary>
 168                 /// <param name="server">The server.</param>
 169                 /// <param name="initialCatalog">The initial catalog.</param>
 170                 /// <param name="username">The username.</param>
 171                 /// <param name="password">The password.</param>
 172                 /// <returns></returns>
 173                 public static InPlaceConfigurationSource BuildForMSSqlServer(string server, string initialCatalog, string username, string password)
 174                 {
 175                         if (string.IsNullOrEmpty(server)) throw new ArgumentNullException("server");
 176                         if (string.IsNullOrEmpty(initialCatalog)) throw new ArgumentNullException("initialCatalog");
 177                         if (string.IsNullOrEmpty(username)) throw new ArgumentNullException("username");
 178                         if (string.IsNullOrEmpty(password)) throw new ArgumentNullException("password");
 179
 180                         return Build(DatabaseType.MSSQLServer, "Server=" + server + ";initial catalog=" + initialCatalog + ";User id=" + username + ";password=" + password);
 181                 }
 182
 183                 /// <summary>
 184                 /// Builds an InPlaceConfiguratioSource for the specified database.
 185                 /// </summary>
 186                 /// <param name="database">The database.</param>
 187                 /// <param name="connectionString">The connection string.</param>
 188                 /// <returns></returns>
 189                 public static InPlaceConfigurationSource Build(DatabaseType database, string connectionString)
 190                 {
 191                         if (string.IsNullOrEmpty(connectionString)) throw new ArgumentNullException("connectionString");
 192
 193                         InPlaceConfigurationSource config = new InPlaceConfigurationSource();
 194
 195                         Hashtable parameters = new Hashtable();
 196                         parameters["hibernate.connection.provider"] = "NHibernate.Connection.DriverConnectionProvider";
 197
 198                         if (database == DatabaseType.MSSQLServer)
 199                         {
 200                                 parameters["hibernate.connection.driver_class"] = "NHibernate.Driver.SqlClientDriver";
 201                                 parameters["hibernate.dialect"] = "NHibernate.Dialect.MsSql2000Dialect";
 202                                 parameters["hibernate.connection.connection_string"] = connectionString;
 203                         }
 204
 205                         config.Add(typeof(ActiveRecordBase), parameters);
 206
 207                         return config;
 208                 }
 209
 210                 /// <summary>
 211                 /// Sets a value indicating whether this instance is running in web app.
 212                 /// </summary>
 213                 /// <value>
 214                 ///     <c>true</c> if this instance is running in web app; otherwise, <c>false</c>.
 215                 /// </value>
 216                 public bool IsRunningInWebApp
 217                 {
 218                         set { SetUpThreadInfoType(value, null); }
 219                 }
 220
 221                 /// <summary>
 222                 /// Adds the specified type with the properties
 223                 /// </summary>
 224                 /// <param name="type">The type.</param>
 225                 /// <param name="properties">The properties.</param>
 226                 public void Add(Type type, IDictionary properties)
 227                 {
 228                         Add(type, ConvertToConfiguration(properties));
 229                 }
 230
 231                 /// <summary>
 232                 /// Adds the specified type with configuration
 233                 /// </summary>
 234                 /// <param name="type">The type.</param>
 235                 /// <param name="config">The config.</param>
 236                 public void Add(Type type, IConfiguration config)
 237                 {
 238                         ProcessConfiguration(config);
 239
 240                         _type2Config[type] = config;
 241                 }
 242
 243                 /// <summary>
 244                 /// Sets the type of the thread info.
 245                 /// </summary>
 246                 /// <param name="isWeb">if we run in a web context or not</param>
 247                 /// <param name="customType">Type of the custom implementation</param>
 248                 protected void SetUpThreadInfoType(bool isWeb, String customType)
 249                 {
 250                         Type threadInfoType = null;
 251
 252                         if (isWeb)
 253                         {
 254                                 threadInfoType = typeof(WebThreadScopeInfo);
 255                         }
 256
 257                         if (customType != null && customType != String.Empty)
 258                         {
 259                                 String typeName = customType;
 260
 261                                 threadInfoType = Type.GetType(typeName, false, false);
 262
 263                                 if (threadInfoType == null)
 264                                 {
 265                                         String message = String.Format("The type name {0} could not be found", typeName);
 266
 267                                         throw new ActiveRecordException(message);
 268                                 }
 269                         }
 270
 271                         ThreadScopeInfoImplementation = threadInfoType;
 272                 }
 273
 274                 /// <summary>
 275                 /// Sets the type of the session factory holder.
 276                 /// </summary>
 277                 /// <param name="customType">Custom implementation</param>
 278                 protected void SetUpSessionFactoryHolderType(String customType)
 279                 {
 280                         Type sessionFactoryHolderType = typeof(SessionFactoryHolder);
 281
 282                         if (customType != null && customType != String.Empty)
 283                         {
 284                                 String typeName = customType;
 285
 286                                 sessionFactoryHolderType = Type.GetType(typeName, false, false);
 287
 288                                 if (sessionFactoryHolderType == null)
 289                                 {
 290                                         String message = String.Format("The type name {0} could not be found", typeName);
 291
 292                                         throw new ActiveRecordException(message);
 293                                 }
 294                         }
 295
 296                         SessionFactoryHolderImplementation = sessionFactoryHolderType;
 297                 }
 298
 299                 /// <summary>
 300                 /// Sets the type of the naming strategy.
 301                 /// </summary>
 302                 /// <param name="customType">Custom implementation type name</param>
 303                 protected void SetUpNamingStrategyType(String customType)
 304                 {
 305                         if (customType != null && customType != String.Empty)
 306                         {
 307                                 String typeName = customType;
 308
 309                                 Type namingStrategyType = Type.GetType(typeName, false, false);
 310
 311                                 if (namingStrategyType == null)
 312                                 {
 313                                         String message = String.Format("The type name {0} could not be found", typeName);
 314
 315                                         throw new ActiveRecordException(message);
 316                                 }
 317
 318                                 NamingStrategyImplementation = namingStrategyType;
 319                         }
 320                 }
 321
 322                 /// <summary>
 323                 /// Sets the debug flag.
 324                 /// </summary>
 325                 /// <param name="isDebug">if set to <c>true</c> Active Record will produce debug information.</param>
 326                 protected void SetDebugFlag(bool isDebug)
 327                 {
 328                         debug = isDebug;
 329                 }
 330
 331                 /// <summary>
 332                 /// Set whatever entities are lazy by default or not.
 333                 /// </summary>
 334                 protected void SetIsLazyByDefault(bool lazyByDefault)
 335                 {
 336                         isLazyByDefault = lazyByDefault;
 337                 }
 338
 339                 /// <summary>
 340                 /// Sets the debug flag.
 341                 /// </summary>
 342                 /// <param name="verifyModelsAgainstDBSchema">if set to <c>true</c> Active Record will verify the models against the db schema on startup.</param>
 343                 protected void SetVerifyModelsAgainstDBSchema(bool verifyModelsAgainstDBSchema)
 344                 {
 345                         this.verifyModelsAgainstDBSchema = verifyModelsAgainstDBSchema;
 346                 }
 347
 348                 /// <summary>
 349                 /// Sets the pluralizeTableNames flag.
 350                 /// </summary>
 351                 /// <param name="pluralize">if set to <c>true</c> Active Record will pluralize inferred table names.</param>
 352                 protected void SetPluralizeTableNames(bool pluralize)
 353                 {
 354                         pluralizeTableNames = pluralize;
 355                 }
 356
 357                 private static IConfiguration ConvertToConfiguration(IDictionary properties)
 358                 {
 359                         MutableConfiguration conf = new MutableConfiguration("Config");
 360
 361                         foreach(DictionaryEntry entry in properties)
 362                         {
 363                                 conf.Children.Add(new MutableConfiguration(entry.Key.ToString(), entry.Value.ToString()));
 364                         }
 365
 366                         return conf;
 367                 }
 368
 369                 /// <summary>
 370                 /// Processes the configuration applying any substitutions.
 371                 /// </summary>
 372                 /// <param name="config">The configuration</param>
 373                 private static void ProcessConfiguration(IConfiguration config)
 374                 {
 375                         const string ConnectionStringKey = "connection.connection_string";
 376
 377                         for(int i = 0; i < config.Children.Count; ++i)
 378                         {
 379                                 IConfiguration property = config.Children[i];
 380
 381                                 if (property.Name.IndexOf(ConnectionStringKey) >= 0)
 382                                 {
 383                                         String value = property.Value;
 384                                         Regex connectionStringRegex = new Regex(@"ConnectionString\s*=\s*\$\{(?<ConnectionStringName>[^}]+)\}");
 385
 386                                         if (connectionStringRegex.IsMatch(value))
 387                                         {
 388                                                 string connectionStringName = connectionStringRegex.Match(value).
 389                                                         Groups["ConnectionStringName"].Value;
 390                                                 value = ConfigurationManager.ConnectionStrings[connectionStringName].ConnectionString;
 391                                                 config.Children[i] = new MutableConfiguration(property.Name, value);
 392                                         }
 393                                 }
 394                         }
 395                 }
 396         }
 397 }