/// <summary>
/// Executes the installer.
/// </summary>
/// <param name="identity">The user for whom permissions will be given.</param>
public void Install(string identity)
{
if (RunInstaller)
{
var configSection = Configure.GetConfigSection <TimeoutPersisterConfig>();
if (configSection != null)
{
if (configSection.NHibernateProperties.Count == 0)
{
throw new InvalidOperationException(
"No NHibernate properties found. Please specify NHibernateProperties in your TimeoutPersisterConfig section");
}
foreach (var property in configSection.NHibernateProperties.ToProperties())
{
ConfigureNHibernate.TimeoutPersisterProperties[property.Key] = property.Value;
}
}
ConfigureNHibernate.ThrowIfRequiredPropertiesAreMissing(ConfigureNHibernate.TimeoutPersisterProperties);
var configuration = ConfigureNHibernate.CreateConfigurationWith(ConfigureNHibernate.TimeoutPersisterProperties);
ConfigureNHibernate.AddMappings <TimeoutEntityMap>(configuration);
new SchemaUpdate(configuration).Execute(false, true);
}
}
public void UseNHibernateTimeoutPersister_Reads_From_AppSettings_And_ConnectionStrings()
{
NHibernateSettingRetriever.AppSettings = () => new NameValueCollection
{
{
"NServiceBus/Persistence/NHibernate/dialect",
dialect
}
};
NHibernateSettingRetriever.ConnectionStrings = () => new ConnectionStringSettingsCollection
{
new ConnectionStringSettings(
"NServiceBus/Persistence",
connectionString)
};
ConfigureNHibernate.Init();
Configure.With(Enumerable.Empty <Type>())
.DefineEndpointName("Foo")
.DefaultBuilder()
.UseNHibernateTimeoutPersister();
var expected = new Dictionary <string, string>
{
{ "dialect", dialect },
{ "connection.connection_string", connectionString },
};
CollectionAssert.IsSubsetOf(expected, ConfigureNHibernate.TimeoutPersisterProperties);
}
/// <summary>
/// Called when the feature should perform its initialization. This call will only happen if the feature is enabled.
/// </summary>
protected override void Setup(FeatureConfigurationContext context)
{
var configuration = context.Settings.GetOrDefault <Configuration>("NHibernate.Subscriptions.Configuration") ?? context.Settings.GetOrDefault <Configuration>("StorageConfiguration");
if (configuration == null)
{
var properties = new ConfigureNHibernate(context.Settings).SubscriptionStorageProperties;
configuration = new Configuration().SetProperties(properties);
}
ConfigureNHibernate.ThrowIfRequiredPropertiesAreMissing(configuration.Properties);
ConfigureNHibernate.AddMappings <SubscriptionMap>(configuration);
context.Container.ConfigureComponent <Unicast.Subscriptions.NHibernate.Installer.Installer>(DependencyLifecycle.SingleInstance)
.ConfigureProperty(x => x.Configuration, configuration)
.ConfigureProperty(x => x.RunInstaller, RunInstaller(context));
var sessionSource = new SubscriptionStorageSessionProvider(configuration.BuildSessionFactory());
context.Container.RegisterSingleton(sessionSource);
if (context.Settings.HasSetting("NHibernate.Subscriptions.CacheExpiration"))
{
context.Container.RegisterSingleton <ISubscriptionStorage>(new CachedSubscriptionPersister(sessionSource, context.Settings.Get <TimeSpan>("NHibernate.Subscriptions.CacheExpiration")));
}
else
{
context.Container.ConfigureComponent <SubscriptionPersister>(DependencyLifecycle.InstancePerCall);
}
}
public void UseNHibernateSubscriptionPersister_Reads_First_From_DBSubscriptionStorageConfig()
{
NHibernateSettingRetriever.AppSettings = () => new NameValueCollection
{
{
"NServiceBus/Persistence/NHibernate/dialect",
"Shouldn't be this"
}
};
NHibernateSettingRetriever.ConnectionStrings = () => new ConnectionStringSettingsCollection
{
new ConnectionStringSettings(
"NServiceBus/Persistence/NHibernate",
"Shouldn't be this")
};
ConfigureNHibernate.Init();
Configure.ConfigurationSource = new FakeConfigurationSource();
Configure.With(Enumerable.Empty <Type>())
.DefineEndpointName("Foo")
.DefaultBuilder()
.UseNHibernateSubscriptionPersister();
var expected = new Dictionary <string, string>
{
{ "dialect", dialect },
{ "connection.connection_string", connectionString },
};
CollectionAssert.IsSubsetOf(expected, ConfigureNHibernate.SubscriptionStorageProperties);
}
public void Should_assign_overridden_connectionString_if_specified()
{
NHibernateSettingRetriever.AppSettings = () => new NameValueCollection();
NHibernateSettingRetriever.ConnectionStrings = () => new ConnectionStringSettingsCollection
{
new ConnectionStringSettings("NServiceBus/Persistence", connectionString),
new ConnectionStringSettings("NServiceBus/Persistence/NHibernate/Timeout",
"timeout_connection_string")
};
var config = new ConfigureNHibernate(new SettingsHolder());
var expectedForTimeout = new Dictionary<string, string>
{
{"connection.connection_string", "timeout_connection_string"}
};
var expectedDefault = new Dictionary<string, string>
{
{"connection.connection_string", connectionString}
};
CollectionAssert.IsSubsetOf(expectedDefault, config.DistributorPersisterProperties);
CollectionAssert.IsSubsetOf(expectedDefault, config.GatewayDeduplicationProperties);
CollectionAssert.IsSubsetOf(expectedDefault, config.OutboxProperties);
CollectionAssert.IsSubsetOf(expectedDefault, config.SagaPersisterProperties);
CollectionAssert.IsSubsetOf(expectedDefault, config.SubscriptionStorageProperties);
CollectionAssert.IsSubsetOf(expectedForTimeout, config.TimeoutPersisterProperties);
}
public static void Execute()
{
Program.EnsureDatabaseExists("NHibernate.Sessions.DemoApplication.MultipleSessionFactories.TodoItems");
Program.EnsureDatabaseExists("NHibernate.Sessions.DemoApplication.MultipleSessionFactories.Users");
new SchemaExport(getConfiguration(typeof(TodoItems).Name)).Execute(true, true, false);
new SchemaExport(getConfiguration(typeof(Users).Name)).Execute(true, true, false);
var multiSessionFactoryConfigurer = ConfigureNHibernate
.ForMultipleSessionFactories(x =>
{
Console.WriteLine("Building NHibernate configuration for {0}", x);
return(getConfiguration(x));
})
.WithCachedConfiguration(Assembly.GetExecutingAssembly())
.WithBackgroundInitialization()
.WithInitializedCallback(x => Console.WriteLine("{0} initialized", x.GetType().Name))
.WithSessionOpenedCallback(x => Console.WriteLine("{0} opened", x.GetType().Name))
.RegisterSessionFactory <TodoItems>()
.RegisterSessionFactory <Users>();
Console.WriteLine("Creating an {0}", typeof(ILazySessionsScope).Name);
var lazySessionsScoper = multiSessionFactoryConfigurer.CreateLazySessions();
Console.WriteLine("Creating an {0}", typeof(ILazySessionFactories).Name);
var lazySessionFactories = multiSessionFactoryConfigurer.CreateLazySessionFactories();
Console.WriteLine("Creating a {0}", typeof(MultipleSessionFactoriesScenarios).FullName);
using (var scenarios = new MultipleSessionFactoriesScenarios(lazySessionsScoper, lazySessionFactories))
{
Console.WriteLine("Executing various scenarios by using different service types to demonstrate the different usage patterns");
var users = scenarios.ExecuteWithLazySessions(x => x.GetAllUsers());
Console.WriteLine("Found {0} users", users.Count);
users = scenarios.ExecuteWithSessionFuncContexts(x => x.GetAllUsers());
Console.WriteLine("Found {0} users", users.Count);
users = scenarios.ExecuteWithLazySessionScopeContexts(x => x.GetAllUsers());
Console.WriteLine("Found {0} users", users.Count);
var todoItems = scenarios.ExecuteWithLazySessions(x => x.GetAllTodoItems(users[0].Id));
Console.WriteLine("Found {0} todo items", todoItems.Count);
todoItems = scenarios.ExecuteWithSessionFuncContexts(x => x.GetTodoItemsDueThisWeek(users[1].Id));
Console.WriteLine("Found {0} todo items", todoItems.Count);
todoItems = scenarios.ExecuteWithLazySessionScopeContexts(x => x.GetTodoItemsDueThisWeek(users[0].Id));
Console.WriteLine("Found {0} todo items", todoItems.Count);
todoItems = scenarios.ExecuteWithLazySessions(x => x.GetTodoItemsDueThisMonth(users[1].Id));
Console.WriteLine("Found {0} todo items", todoItems.Count);
todoItems = scenarios.ExecuteWithSessionFuncContexts(x => x.GetTodoItemsCompletedLastWeek(users[0].Id));
Console.WriteLine("Found {0} todo items", todoItems.Count);
todoItems = scenarios.ExecuteWithLazySessionScopeContexts(x => x.GetUpcomingTodoItems(users[1].Id, Priority.Urgent));
Console.WriteLine("Found {0} todo items", todoItems.Count);
var success = scenarios.ExecuteWithLazySessions(x => x.CompleteTodoItem(todoItems[0].Id));
Console.WriteLine("TodoItem {0} {1} completed", todoItems[0].Id, success ? "was" : "wasn't");
}
}
public void Should_not_throw_if_connectionstringname_is_used_instead_of_connectionstring()
{
Assert.DoesNotThrow(() => ConfigureNHibernate.ThrowIfRequiredPropertiesAreMissing(new Dictionary <string, string>
{
{ "connection.connection_string_name", "asdad" }
}));
}
/// <summary>
/// Called when the feature should perform its initialization. This call will only happen if the feature is enabled.
/// </summary>
protected override void Setup(FeatureConfigurationContext context)
{
var properties = new ConfigureNHibernate(context.Settings).GatewayDeduplicationProperties;
ConfigureNHibernate.ThrowIfRequiredPropertiesAreMissing(properties);
var configuration = context.Settings.GetOrDefault <Configuration>("NHibernate.GatewayDeduplication.Configuration") ?? context.Settings.GetOrDefault <Configuration>("StorageConfiguration");
if (configuration == null)
{
configuration = new Configuration()
.SetProperties(properties);
}
ConfigureNHibernate.AddMappings <DeduplicationMessageMap>(configuration);
Deduplication.NHibernate.Installer.Installer.configuration = configuration;
if (context.Settings.HasSetting("NHibernate.GatewayDeduplication.AutoUpdateSchema"))
{
Deduplication.NHibernate.Installer.Installer.RunInstaller = context.Settings.Get <bool>("NHibernate.GatewayDeduplication.AutoUpdateSchema");
}
else
{
Deduplication.NHibernate.Installer.Installer.RunInstaller = context.Settings.Get <bool>("NHibernate.Common.AutoUpdateSchema");
}
context.Container.ConfigureComponent <Deduplication.NHibernate.GatewayDeduplication>(DependencyLifecycle.SingleInstance)
.ConfigureProperty(p => p.SessionFactory, configuration.BuildSessionFactory());
}
public void Should_assign_overriden_connectionstring_if_specified()
{
NHibernateSettingRetriever.AppSettings = () => new NameValueCollection {
};
NHibernateSettingRetriever.ConnectionStrings = () => new ConnectionStringSettingsCollection
{
new ConnectionStringSettings("NServiceBus/Persistence", connectionString),
new ConnectionStringSettings("NServiceBus/Persistence/NHibernate/Timeout",
"timeout_connection_string")
};
ConfigureNHibernate.Init();
var expectedForTimeout = new Dictionary <string, string>
{
{ "connection.connection_string", "timeout_connection_string" }
};
var expectedDefault = new Dictionary <string, string>
{
{ "connection.connection_string", connectionString }
};
CollectionAssert.IsSubsetOf(expectedDefault, ConfigureNHibernate.DistributorPersisterProperties);
CollectionAssert.IsSubsetOf(expectedDefault, ConfigureNHibernate.GatewayPersisterProperties);
CollectionAssert.IsSubsetOf(expectedDefault, ConfigureNHibernate.SagaPersisterProperties);
CollectionAssert.IsSubsetOf(expectedDefault, ConfigureNHibernate.SubscriptionStorageProperties);
CollectionAssert.IsSubsetOf(expectedForTimeout, ConfigureNHibernate.TimeoutPersisterProperties);
}
/// <summary>
/// Called when the feature should perform its initialization. This call will only happen if the feature is enabled.
/// </summary>
protected override void Setup(FeatureConfigurationContext context)
{
var configuration = context.Settings.GetOrDefault<Configuration>("NHibernate.Subscriptions.Configuration") ?? context.Settings.GetOrDefault<Configuration>("StorageConfiguration");
if (configuration == null)
{
var properties = new ConfigureNHibernate(context.Settings).SubscriptionStorageProperties;
configuration = new Configuration().SetProperties(properties);
}
ConfigureNHibernate.ThrowIfRequiredPropertiesAreMissing(configuration.Properties);
ConfigureNHibernate.AddMappings<SubscriptionMap>(configuration);
context.Container.ConfigureComponent<Unicast.Subscriptions.NHibernate.Installer.Installer>(DependencyLifecycle.SingleInstance)
.ConfigureProperty(x => x.Configuration, configuration)
.ConfigureProperty(x => x.RunInstaller, RunInstaller(context));
var sessionSource = new SubscriptionStorageSessionProvider(configuration.BuildSessionFactory());
context.Container.RegisterSingleton(sessionSource);
if (context.Settings.HasSetting("NHibernate.Subscriptions.CacheExpiration"))
{
context.Container.RegisterSingleton<ISubscriptionStorage>(new CachedSubscriptionPersister(sessionSource, context.Settings.Get<TimeSpan>("NHibernate.Subscriptions.CacheExpiration")));
}
else
{
context.Container.ConfigureComponent<SubscriptionPersister>(DependencyLifecycle.InstancePerCall);
}
}
public void Should_assign_all_optional_properties_to_all_persisters()
{
NHibernateSettingRetriever.AppSettings = () => new NameValueCollection
{
{ "NServiceBus/Persistence/NHibernate/connection.provider", "provider" },
{ "NServiceBus/Persistence/NHibernate/connection.driver_class", "driver_class" },
};
NHibernateSettingRetriever.ConnectionStrings = () => new ConnectionStringSettingsCollection
{
new ConnectionStringSettings("NServiceBus/Persistence", connectionString)
};
ConfigureNHibernate.Init();
var expected = new Dictionary <string, string>
{
{ "connection.connection_string", connectionString },
{ "connection.provider", "provider" },
{ "connection.driver_class", "driver_class" },
};
CollectionAssert.IsSubsetOf(expected, ConfigureNHibernate.DistributorPersisterProperties);
CollectionAssert.IsSubsetOf(expected, ConfigureNHibernate.GatewayPersisterProperties);
CollectionAssert.IsSubsetOf(expected, ConfigureNHibernate.SagaPersisterProperties);
CollectionAssert.IsSubsetOf(expected, ConfigureNHibernate.SubscriptionStorageProperties);
CollectionAssert.IsSubsetOf(expected, ConfigureNHibernate.TimeoutPersisterProperties);
}
public void Setup()
{
Configure.ConfigurationSource = new DefaultConfigurationSource();
NHibernateSettingRetriever.AppSettings = () => new NameValueCollection
{
{ "NServiceBus/Persistence/NHibernate/dialect", dialect }
};
NHibernateSettingRetriever.ConnectionStrings = () => new ConnectionStringSettingsCollection
{
new ConnectionStringSettings("NServiceBus/Persistence/NHibernate/Timeout", connectionString)
};
ConfigureNHibernate.Init();
Configure.With(Enumerable.Empty <Type>())
.DefineEndpointName("Foo")
.DefaultBuilder()
.UseNHibernateTimeoutPersister();
persister = Configure.Instance.Builder.Build <TimeoutStorage>();
sessionFactory = persister.SessionFactory;
new Installer.Installer().Install(WindowsIdentity.GetCurrent().Name);
}
/// <summary>
/// Called when the feature should perform its initialization. This call will only happen if the feature is enabled.
/// </summary>
protected override void Setup(FeatureConfigurationContext context)
{
var configuration = context.Settings.GetOrDefault<Configuration>("StorageConfiguration");
if (configuration == null)
{
var properties = new ConfigureNHibernate(context.Settings).SagaPersisterProperties;
configuration = new Configuration().SetProperties(properties);
}
ConfigureNHibernate.ThrowIfRequiredPropertiesAreMissing(configuration.Properties);
context.Settings.Get<SharedMappings>().ApplyTo(configuration);
string connString;
if (!configuration.Properties.TryGetValue(Environment.ConnectionString, out connString))
{
string connStringName;
if (configuration.Properties.TryGetValue(Environment.ConnectionStringName, out connStringName))
{
var connectionStringSettings = System.Configuration.ConfigurationManager.ConnectionStrings[connStringName];
connString = connectionStringSettings.ConnectionString;
}
}
context.Container.RegisterSingleton(new SessionFactoryProvider(configuration.BuildSessionFactory()));
var disableConnectionSharing = DisableTransportConnectionSharing(context);
context.Container
.ConfigureProperty<DbConnectionProvider>(p => p.DisableConnectionSharing, disableConnectionSharing)
.ConfigureProperty<DbConnectionProvider>(p => p.DefaultConnectionString, connString);
context.Pipeline.Register<OpenSqlConnectionBehavior.Registration>();
context.Pipeline.Register<OpenSessionBehavior.Registration>();
context.Container.ConfigureComponent<OpenSqlConnectionBehavior>(DependencyLifecycle.InstancePerCall)
.ConfigureProperty(p => p.ConnectionString, connString)
.ConfigureProperty(p => p.DisableConnectionSharing, disableConnectionSharing);
context.Container.ConfigureComponent<OpenSessionBehavior>(DependencyLifecycle.InstancePerCall)
.ConfigureProperty(p => p.ConnectionString, connString)
.ConfigureProperty(p => p.DisableConnectionSharing, disableConnectionSharing)
.ConfigureProperty(p => p.SessionCreator, context.Settings.GetOrDefault<Func<ISessionFactory, string, ISession>>("NHibernate.SessionCreator"));
context.Container.ConfigureComponent(b => new NHibernateStorageContext(b.Build<PipelineExecutor>(), connString), DependencyLifecycle.InstancePerUnitOfWork);
context.Container.ConfigureComponent<SharedConnectionStorageSessionProvider>(DependencyLifecycle.SingleInstance)
.ConfigureProperty(p => p.ConnectionString, connString);
if (context.Settings.GetOrDefault<bool>("NHibernate.RegisterManagedSession"))
{
context.Container.ConfigureComponent(b => b.Build<NHibernateStorageContext>().Session, DependencyLifecycle.InstancePerCall);
}
context.Container.ConfigureComponent<Installer>(DependencyLifecycle.SingleInstance)
.ConfigureProperty(x => x.Configuration, configuration)
.ConfigureProperty(x => x.RunInstaller, context.Settings.Get<bool>("NHibernate.Common.AutoUpdateSchema"));
}
/// <summary>
/// Configures NHibernate Timeout Persister.
/// </summary>
/// <remarks>
/// Reads configuration settings from <a href="http://msdn.microsoft.com/en-us/library/ms228154.aspx"><appSettings> config section</a> and <a href="http://msdn.microsoft.com/en-us/library/bf7sd233"><connectionStrings> config section</a>.
/// </remarks>
/// <example>
/// An example that shows the minimum configuration:
/// <code lang="XML" escaped="true">
/// <appSettings>
/// <!-- other optional settings examples -->
/// <add key="NServiceBus/Persistence/NHibernate/connection.provider" value="NHibernate.Connection.DriverConnectionProvider"/>
/// <add key="NServiceBus/Persistence/NHibernate/connection.driver_class" value="NHibernate.Driver.Sql2008ClientDriver"/>
/// <!-- For more setting see http://www.nhforge.org/doc/nh/en/#configuration-hibernatejdbc and http://www.nhforge.org/doc/nh/en/#configuration-optional -->
/// </appSettings>
///
/// <connectionStrings>
/// <!-- Default connection string for all persisters -->
/// <add name="NServiceBus/Persistence/NHibernate" connectionString="Data Source=.\SQLEXPRESS;Initial Catalog=nservicebus;Integrated Security=True" />
///
/// <!-- Optional overrides per persister -->
/// <add name="NServiceBus/Persistence/NHibernate/Timeout" connectionString="Data Source=.\SQLEXPRESS;Initial Catalog=timeout;Integrated Security=True" />
/// </connectionStrings>
/// </code>
/// </example>
/// <param name="config">The configuration object.</param>
/// <returns>The configuration object.</returns>
public static Configure UseNHibernateTimeoutPersister(this Configure config)
{
var configSection = Configure.GetConfigSection <TimeoutPersisterConfig>();
if (configSection != null)
{
if (configSection.NHibernateProperties.Count == 0)
{
throw new InvalidOperationException(
"No NHibernate properties found. Please specify NHibernateProperties in your TimeoutPersisterConfig section");
}
foreach (var property in configSection.NHibernateProperties.ToProperties())
{
ConfigureNHibernate.TimeoutPersisterProperties[property.Key] = property.Value;
}
}
ConfigureNHibernate.ConfigureSqlLiteIfRunningInDebugModeAndNoConfigPropertiesSet(ConfigureNHibernate.TimeoutPersisterProperties);
var properties = ConfigureNHibernate.TimeoutPersisterProperties;
return(config.UseNHibernateTimeoutPersisterInternal(ConfigureNHibernate.CreateConfigurationWith(properties),
configSection == null || configSection.UpdateSchema));
}
public void Should_not_throw_if_minimum_properties_are_set()
{
Assert.DoesNotThrow(() => ConfigureNHibernate.ThrowIfRequiredPropertiesAreMissing(new Dictionary <string, string>
{
{ "connection.connection_string", "asdad" }
}));
}
public void Should_skip_settings_that_are_not_for_persistence()
{
NHibernateSettingRetriever.AppSettings = () => new NameValueCollection
{
{ "myOtherSetting1", "provider" },
{ "myOtherSetting2", "driver_class" },
};
NHibernateSettingRetriever.ConnectionStrings = () => new ConnectionStringSettingsCollection
{
new ConnectionStringSettings("NServiceBus/Persistence", connectionString)
};
var config = new ConfigureNHibernate(new SettingsHolder());
var expected = new Dictionary <string, string>
{
{ "connection.connection_string", connectionString },
};
CollectionAssert.IsSubsetOf(expected, config.DistributorPersisterProperties);
CollectionAssert.IsSubsetOf(expected, config.GatewayDeduplicationProperties);
CollectionAssert.IsSubsetOf(expected, config.OutboxProperties);
CollectionAssert.IsSubsetOf(expected, config.SagaPersisterProperties);
CollectionAssert.IsSubsetOf(expected, config.SubscriptionStorageProperties);
CollectionAssert.IsSubsetOf(expected, config.TimeoutPersisterProperties);
}
/// <summary>
/// Called when the feature should perform its initialization. This call will only happen if the feature is enabled.
/// </summary>
protected override void Setup(FeatureConfigurationContext context)
{
var configuration = context.Settings.GetOrDefault <Configuration>("StorageConfiguration");
if (configuration == null)
{
var properties = new ConfigureNHibernate(context.Settings).SagaPersisterProperties;
configuration = new Configuration().SetProperties(properties);
}
ConfigureNHibernate.ThrowIfRequiredPropertiesAreMissing(configuration.Properties);
context.Settings.Get <SharedMappings>().ApplyTo(configuration);
string connString;
if (!configuration.Properties.TryGetValue(Environment.ConnectionString, out connString))
{
string connStringName;
if (configuration.Properties.TryGetValue(Environment.ConnectionStringName, out connStringName))
{
var connectionStringSettings = System.Configuration.ConfigurationManager.ConnectionStrings[connStringName];
connString = connectionStringSettings.ConnectionString;
}
}
context.Container.RegisterSingleton(new SessionFactoryProvider(configuration.BuildSessionFactory()));
var disableConnectionSharing = DisableTransportConnectionSharing(context);
context.Container
.ConfigureProperty <DbConnectionProvider>(p => p.DisableConnectionSharing, disableConnectionSharing)
.ConfigureProperty <DbConnectionProvider>(p => p.DefaultConnectionString, connString);
context.Pipeline.Register <OpenSqlConnectionBehavior.Registration>();
context.Pipeline.Register <OpenSessionBehavior.Registration>();
context.Container.ConfigureComponent <OpenSqlConnectionBehavior>(DependencyLifecycle.InstancePerCall)
.ConfigureProperty(p => p.ConnectionString, connString)
.ConfigureProperty(p => p.DisableConnectionSharing, disableConnectionSharing);
context.Container.ConfigureComponent <OpenSessionBehavior>(DependencyLifecycle.InstancePerCall)
.ConfigureProperty(p => p.ConnectionString, connString)
.ConfigureProperty(p => p.DisableConnectionSharing, disableConnectionSharing)
.ConfigureProperty(p => p.SessionCreator, context.Settings.GetOrDefault <Func <ISessionFactory, string, ISession> >("NHibernate.SessionCreator"));
context.Container.ConfigureComponent(b => new NHibernateStorageContext(b.Build <PipelineExecutor>(), connString), DependencyLifecycle.InstancePerUnitOfWork);
context.Container.ConfigureComponent <SharedConnectionStorageSessionProvider>(DependencyLifecycle.SingleInstance)
.ConfigureProperty(p => p.ConnectionString, connString);
if (context.Settings.GetOrDefault <bool>("NHibernate.RegisterManagedSession"))
{
context.Container.ConfigureComponent(b => b.Build <NHibernateStorageContext>().Session, DependencyLifecycle.InstancePerCall);
}
context.Container.ConfigureComponent <Installer>(DependencyLifecycle.SingleInstance)
.ConfigureProperty(x => x.Configuration, configuration)
.ConfigureProperty(x => x.RunInstaller, context.Settings.Get <bool>("NHibernate.Common.AutoUpdateSchema"));
}
public IDictionary <string, string> Execute()
{
var config = new ConfigureNHibernate(new SettingsHolder());
var configuration =
ConfigureNHibernate.CreateConfigurationWith(config.DistributorPersisterProperties);
return(configuration.Properties);
}
public IDictionary <string, string> Execute()
{
ConfigureNHibernate.Init();
var configuration =
ConfigureNHibernate.CreateConfigurationWith(ConfigureNHibernate.DistributorPersisterProperties);
return(configuration.Properties);
}
public static Configure UseNHibernateTimeoutPersisterWithSQLiteAndAutomaticSchemaGeneration(this Configure config)
{
ConfigureNHibernate.TimeoutPersisterProperties["dialect"] = "NHibernate.Dialect.SQLiteDialect";
ConfigureNHibernate.TimeoutPersisterProperties["connection.connection_string"] = "Data Source=.\\NServiceBus.Timeouts.sqlite;Version=3;New=True;";
var configuration = ConfigureNHibernate.CreateConfigurationWith(ConfigureNHibernate.TimeoutPersisterProperties);
return(config.UseNHibernateTimeoutPersisterInternal(configuration, true));
}
/// <summary>
/// Configures NHibernate Gateway Persister.
/// </summary>
/// <remarks>
/// Reads configuration settings from <a href="http://msdn.microsoft.com/en-us/library/ms228154.aspx"><appSettings> config section</a> and <a href="http://msdn.microsoft.com/en-us/library/bf7sd233"><connectionStrings> config section</a>.
/// </remarks>
/// <example>
/// An example that shows the minimum configuration:
/// <code lang="XML" escaped="true">
/// <appSettings>
/// <!-- optional settings examples -->
/// <add key="NServiceBus/Persistence/NHibernate/connection.provider" value="NHibernate.Connection.DriverConnectionProvider"/>
/// <add key="NServiceBus/Persistence/NHibernate/connection.driver_class" value="NHibernate.Driver.Sql2008ClientDriver"/>
/// <!-- For more setting see http://www.nhforge.org/doc/nh/en/#configuration-hibernatejdbc and http://www.nhforge.org/doc/nh/en/#configuration-optional -->
/// </appSettings>
///
/// <connectionStrings>
/// <!-- Default connection string for all persisters -->
/// <add name="NServiceBus/Persistence/NHibernate" connectionString="Data Source=.\SQLEXPRESS;Initial Catalog=nservicebus;Integrated Security=True" />
///
/// <!-- Optional overrides per persister -->
/// <add name="NServiceBus/Persistence/NHibernate/Gateway" connectionString="Data Source=.\SQLEXPRESS;Initial Catalog=gateway;Integrated Security=True" />
/// </connectionStrings>
/// </code>
/// </example>
/// <param name="config">The configuration object.</param>
/// <returns>The configuration object.</returns>
public static Configure UseNHibernateGatewayPersister(this Configure config)
{
ConfigureNHibernate.ConfigureSqlLiteIfRunningInDebugModeAndNoConfigPropertiesSet(ConfigureNHibernate.GatewayPersisterProperties);
var properties = ConfigureNHibernate.GatewayPersisterProperties;
var configuration = ConfigureNHibernate.CreateConfigurationWith(properties);
return(config.UseNHibernateGatewayPersisterInternal(configuration));
}
public static Configure NHibernateSagaPersister(this Configure config, IDictionary <string, string> nhibernateProperties,
bool autoUpdateSchema)
{
foreach (var property in nhibernateProperties)
{
ConfigureNHibernate.SagaPersisterProperties[property.Key] = property.Value;
}
return(config.UseNHibernateSagaPersisterInternal(ConfigureNHibernate.CreateConfigurationWith(ConfigureNHibernate.SagaPersisterProperties), autoUpdateSchema));
}
public static void Start()
{
var container = new UnityContainer();
GlobalConfiguration.Configuration.DependencyResolver = new UnityDependencyResolver(container);
RegisterSettings.Register(container);
ConfigureNHibernate.Configure(container);
RegisterRepositories.Register(container);
}
/// <summary>
/// Executes the installer.
/// </summary>
/// <param name="identity">The user for whom permissions will be given.</param>
public void Install(string identity)
{
if (RunInstaller)
{
ConfigureNHibernate.ThrowIfRequiredPropertiesAreMissing(ConfigureNHibernate.GatewayPersisterProperties);
var configuration = ConfigureNHibernate.CreateConfigurationWith(ConfigureNHibernate.GatewayPersisterProperties);
ConfigureNHibernate.AddMappings <GatewayMessageMap>(configuration);
new SchemaUpdate(configuration).Execute(false, true);
}
}
public void Update_schema_can_be_specified_by_the_user()
{
var builder = new SessionFactoryBuilder(Configure.TypesToScan);
var properties = ConfigureNHibernate.SagaPersisterProperties;
var sessionFactory = builder.Build(ConfigureNHibernate.CreateConfigurationWith(properties));
using (var session = sessionFactory.OpenSession())
{
session.CreateCriteria(typeof(MySaga)).List <MySaga>();
}
}
static Configure UseNHibernateTimeoutPersisterInternal(this Configure config, Configuration configuration, bool autoUpdateSchema)
{
ConfigureNHibernate.ThrowIfRequiredPropertiesAreMissing(ConfigureNHibernate.TimeoutPersisterProperties);
TimeoutPersisters.NHibernate.Installer.Installer.RunInstaller = autoUpdateSchema;
ConfigureNHibernate.AddMappings <TimeoutEntityMap>(configuration);
config.Configurer.ConfigureComponent <TimeoutStorage>(DependencyLifecycle.SingleInstance)
.ConfigureProperty(p => p.SessionFactory, configuration.BuildSessionFactory());
return(config);
}
public static void Execute()
{
Program.EnsureDatabaseExists("NHibernate.Sessions.DemoApplication.SingleSessionFactory");
const string connectionStringName = "SingleSessionFactory";
new SchemaExport(getConfiguration(connectionStringName)).Execute(true, true, false);
Console.WriteLine("Configuring an {0}", typeof(ISingleSessionFactoryConfigurer).Name);
var singleSessionFactoryConfigurer = ConfigureNHibernate
.ForSingleSessionFactory(() =>
{
Console.WriteLine("Building NHibernate configuration for {0}", connectionStringName);
return(getConfiguration(connectionStringName));
})
.WithLazyInitialization()
.WithInitializedCallback(x => Console.WriteLine("{0} initialized", x.GetType().Name))
.WithSessionOpenedCallback(x => Console.WriteLine("{0} opened", x.GetType().Name));
Console.WriteLine("Creating an {0}", typeof(ILazySessionScope).Name);
var lazySessionScoper = singleSessionFactoryConfigurer.CreateLazySession();
Console.WriteLine("Creating an {0}", typeof(ILazySessionFactory).Name);
var lazySessionFactory = singleSessionFactoryConfigurer.CreateLazySessionFactory();
Console.WriteLine("Creating a {0}", typeof(SingleSessionFactoryScenarios).FullName);
using (var scenarios = new SingleSessionFactoryScenarios(lazySessionScoper, lazySessionFactory))
{
var users = scenarios.Execute(x => x.GetAllUsers());
Console.WriteLine("Found {0} users", users.Count);
var todoItems = scenarios.Execute(x => x.GetAllTodoItems(users[0].Id));
Console.WriteLine("Found {0} todo items", todoItems.Count);
todoItems = scenarios.Execute(x => x.GetTodoItemsDueThisWeek(users[1].Id));
Console.WriteLine("Found {0} todo items", todoItems.Count);
todoItems = scenarios.Execute(x => x.GetTodoItemsDueThisWeek(users[0].Id));
Console.WriteLine("Found {0} todo items", todoItems.Count);
todoItems = scenarios.Execute(x => x.GetTodoItemsDueThisMonth(users[1].Id));
Console.WriteLine("Found {0} todo items", todoItems.Count);
todoItems = scenarios.Execute(x => x.GetTodoItemsCompletedLastWeek(users[0].Id));
Console.WriteLine("Found {0} todo items", todoItems.Count);
todoItems = scenarios.Execute(x => x.GetUpcomingTodoItems(users[1].Id, Priority.Urgent));
Console.WriteLine("Found {0} todo items", todoItems.Count);
var success = scenarios.Execute(x => x.CompleteTodoItem(todoItems[0].Id));
Console.WriteLine("TodoItem {0} {1} completed", todoItems[0].Id, success ? "was" : "wasn't");
}
}
public IDictionary <string, string> Execute()
{
NHibernateSettingRetriever.ConnectionStrings = () => new ConnectionStringSettingsCollection
{
new ConnectionStringSettings("NServiceBus/Persistence", "specified")
};
ConfigureNHibernate.Init();
var configuration =
ConfigureNHibernate.CreateConfigurationWith(ConfigureNHibernate.DistributorPersisterProperties);
return(configuration.Properties);
}
public void Should_display_no_warning_and_not_configure_properties_if_debugger_is_not_attached_and_properties_not_set()
{
if (System.Diagnostics.Debugger.IsAttached)
{
Assert.Ignore("Can't run this unit test with debugger attached.");
return;
}
var properties = new Dictionary <string, string>();
ConfigureNHibernate.ConfigureSqlLiteIfRunningInDebugModeAndNoConfigPropertiesSet(properties);
Assert.AreEqual(0, properties.Count);
}
private static Configure UseNHibernateGatewayPersisterInternal(this Configure config, Configuration configuration)
{
ConfigureNHibernate.ThrowIfRequiredPropertiesAreMissing(configuration.Properties);
GatewayPersister.NHibernate.Installer.Installer.RunInstaller = true;
ConfigureNHibernate.AddMappings <GatewayMessageMap>(configuration);
config.Configurer.ConfigureComponent <GatewayPersister.NHibernate.GatewayPersister>(
DependencyLifecycle.SingleInstance)
.ConfigureProperty(p => p.SessionFactory, configuration.BuildSessionFactory());
return(config.RunGateway());
}
public void Should_display_warning_and_configure_properties_if_debugger_is_attached_and_properties_not_set()
{
if (!System.Diagnostics.Debugger.IsAttached)
{
Assert.Ignore("Debugger needs to be attached to run this unit test.");
return;
}
var properties = new Dictionary <string, string>();
ConfigureNHibernate.ConfigureSqlLiteIfRunningInDebugModeAndNoConfigPropertiesSet(properties);
Assert.IsTrue(properties.ContainsKey("dialect"));
Assert.AreEqual("NHibernate.Dialect.SQLiteDialect", properties["dialect"]);
}
static Configure UseNHibernateSubscriptionPersisterInternal(this Configure config, Configuration configuration, bool autoUpdateSchema)
{
ConfigureNHibernate.ThrowIfRequiredPropertiesAreMissing(ConfigureNHibernate.SubscriptionStorageProperties);
Unicast.Subscriptions.NHibernate.Installer.Installer.RunInstaller = autoUpdateSchema;
ConfigureNHibernate.AddMappings <SubscriptionMap>(configuration);
var sessionSource = new SubscriptionStorageSessionProvider(configuration.BuildSessionFactory());
config.Configurer.RegisterSingleton <ISubscriptionStorageSessionProvider>(sessionSource);
config.Configurer.ConfigureComponent <SubscriptionStorage>(DependencyLifecycle.InstancePerCall);
return(config);
}
/// <summary>
/// Called when the feature should perform its initialization. This call will only happen if the feature is enabled.
/// </summary>
protected override void Setup(FeatureConfigurationContext context)
{
var properties = new ConfigureNHibernate(context.Settings)
.TimeoutPersisterProperties;
ConfigureNHibernate.ThrowIfRequiredPropertiesAreMissing(properties);
var configuration = context.Settings.GetOrDefault <Configuration>("NHibernate.Timeouts.Configuration") ?? context.Settings.GetOrDefault <Configuration>("StorageConfiguration");
if (configuration == null)
{
configuration = new Configuration()
.SetProperties(properties);
}
ConfigureNHibernate.AddMappings <TimeoutEntityMap>(configuration);
TimeoutPersisters.NHibernate.Installer.Installer.configuration = configuration;
if (context.Settings.HasSetting("NHibernate.Timeouts.AutoUpdateSchema"))
{
TimeoutPersisters.NHibernate.Installer.Installer.RunInstaller = context.Settings.Get <bool>("NHibernate.Timeouts.AutoUpdateSchema");
}
else
{
TimeoutPersisters.NHibernate.Installer.Installer.RunInstaller = context.Settings.Get <bool>("NHibernate.Common.AutoUpdateSchema");
}
string connString;
if (!configuration.Properties.TryGetValue(Environment.ConnectionString, out connString))
{
string connStringName;
if (configuration.Properties.TryGetValue(Environment.ConnectionStringName, out connStringName))
{
var connectionStringSettings = System.Configuration.ConfigurationManager.ConnectionStrings[connStringName];
connString = connectionStringSettings.ConnectionString;
}
}
context.Container.ConfigureComponent <TimeoutPersister>(DependencyLifecycle.SingleInstance)
.ConfigureProperty(p => p.ConnectionString, connString)
.ConfigureProperty(p => p.SessionFactory, configuration.BuildSessionFactory())
.ConfigureProperty(p => p.EndpointName, context.Settings.EndpointName());
}
/// <summary>
/// Called when the feature should perform its initialization. This call will only happen if the feature is enabled.
/// </summary>
protected override void Setup(FeatureConfigurationContext context)
{
var configuration = context.Settings.GetOrDefault<Configuration>("NHibernate.GatewayDeduplication.Configuration") ?? context.Settings.GetOrDefault<Configuration>("StorageConfiguration");
if (configuration == null)
{
var properties = new ConfigureNHibernate(context.Settings).GatewayDeduplicationProperties;
configuration = new Configuration().SetProperties(properties);
}
ConfigureNHibernate.ThrowIfRequiredPropertiesAreMissing(configuration.Properties);
ConfigureNHibernate.AddMappings<DeduplicationMessageMap>(configuration);
context.Container.ConfigureComponent<Deduplication.NHibernate.Installer.Installer>(DependencyLifecycle.SingleInstance)
.ConfigureProperty(x => x.Configuration, configuration)
.ConfigureProperty(x => x.RunInstaller, RunInstaller(context));
context.Container.ConfigureComponent<Deduplication.NHibernate.GatewayDeduplication>(DependencyLifecycle.SingleInstance)
.ConfigureProperty(p => p.SessionFactory, configuration.BuildSessionFactory());
}
/// <summary>
/// Called when the feature should perform its initialization. This call will only happen if the feature is enabled.
/// </summary>
protected override void Setup(FeatureConfigurationContext context)
{
var configuration = context.Settings.GetOrDefault<Configuration>("NHibernate.Timeouts.Configuration") ?? context.Settings.GetOrDefault<Configuration>("StorageConfiguration");
if (configuration == null)
{
var properties = new ConfigureNHibernate(context.Settings).TimeoutPersisterProperties;
configuration = new Configuration().SetProperties(properties);
}
ConfigureNHibernate.ThrowIfRequiredPropertiesAreMissing(configuration.Properties);
ConfigureNHibernate.AddMappings<TimeoutEntityMap>(configuration);
context.Container.ConfigureComponent<TimeoutPersisters.NHibernate.Installer.Installer>(DependencyLifecycle.SingleInstance)
.ConfigureProperty(x => x.Configuration, configuration)
.ConfigureProperty(x => x.RunInstaller, RunInstaller(context));
string connString;
if (!configuration.Properties.TryGetValue(Environment.ConnectionString, out connString))
{
string connStringName;
if (configuration.Properties.TryGetValue(Environment.ConnectionStringName, out connStringName))
{
var connectionStringSettings = System.Configuration.ConfigurationManager.ConnectionStrings[connStringName];
connString = connectionStringSettings.ConnectionString;
}
}
context.Container.ConfigureComponent<TimeoutPersister>(DependencyLifecycle.SingleInstance)
.ConfigureProperty(p => p.ConnectionString, connString)
.ConfigureProperty(p => p.SessionFactory, configuration.BuildSessionFactory())
.ConfigureProperty(p => p.EndpointName, context.Settings.EndpointName());
}
public void Should_assign_default_properties_to_all_persisters()
{
NHibernateSettingRetriever.AppSettings = () => new NameValueCollection();
NHibernateSettingRetriever.ConnectionStrings = () => new ConnectionStringSettingsCollection
{
new ConnectionStringSettings("NServiceBus/Persistence", connectionString)
};
var config = new ConfigureNHibernate(new SettingsHolder());
var expected = new Dictionary<string, string>
{
{"dialect", ConfigureNHibernate.DefaultDialect},
{"connection.connection_string", connectionString}
};
CollectionAssert.IsSubsetOf(expected, config.DistributorPersisterProperties);
CollectionAssert.IsSubsetOf(expected, config.GatewayDeduplicationProperties);
CollectionAssert.IsSubsetOf(expected, config.OutboxProperties);
CollectionAssert.IsSubsetOf(expected, config.SagaPersisterProperties);
CollectionAssert.IsSubsetOf(expected, config.SubscriptionStorageProperties);
CollectionAssert.IsSubsetOf(expected, config.TimeoutPersisterProperties);
}
public IDictionary<string, string> Execute()
{
var config = new ConfigureNHibernate(new SettingsHolder());
var configuration =
ConfigureNHibernate.CreateConfigurationWith(config.DistributorPersisterProperties);
return configuration.Properties;
}
public IDictionary<string, string> Execute()
{
NHibernateSettingRetriever.ConnectionStrings = () => new ConnectionStringSettingsCollection
{
new ConnectionStringSettings("NServiceBus/Persistence", "specified")
};
var config = new ConfigureNHibernate(new SettingsHolder());
var configuration =
ConfigureNHibernate.CreateConfigurationWith(config.DistributorPersisterProperties);
return configuration.Properties;
}
public void Should_skip_settings_that_are_not_for_persistence()
{
NHibernateSettingRetriever.AppSettings = () => new NameValueCollection
{
{"myOtherSetting1", "provider"},
{"myOtherSetting2", "driver_class"},
};
NHibernateSettingRetriever.ConnectionStrings = () => new ConnectionStringSettingsCollection
{
new ConnectionStringSettings("NServiceBus/Persistence", connectionString)
};
var config = new ConfigureNHibernate(new SettingsHolder());
var expected = new Dictionary<string, string>
{
{"connection.connection_string", connectionString},
};
CollectionAssert.IsSubsetOf(expected, config.DistributorPersisterProperties);
CollectionAssert.IsSubsetOf(expected, config.GatewayDeduplicationProperties);
CollectionAssert.IsSubsetOf(expected, config.OutboxProperties);
CollectionAssert.IsSubsetOf(expected, config.SagaPersisterProperties);
CollectionAssert.IsSubsetOf(expected, config.SubscriptionStorageProperties);
CollectionAssert.IsSubsetOf(expected, config.TimeoutPersisterProperties);
}
