/// <summary>
/// Use database as the messaging backplane for scaling out of ASP.NET SignalR applications in a web farm.
/// </summary>
/// <param name="resolver">The dependency resolver.</param>
/// <param name="connectionString">The database connection string.</param>
/// <param name="providerType"></param>
/// <returns>The dependency resolver.</returns>
public static IDependencyResolver UseFluentNHibernate(this IDependencyResolver resolver,
string connectionString, ProviderTypeEnum providerType)
{
var config = new FNHScaleoutConfiguration(connectionString, providerType);
return(UseFluentNHibernate(resolver, config));
}
/// <summary>
/// Use database as the messaging backplane for scaling out of ASP.NET SignalR applications in a web farm.
/// </summary>
/// <param name="resolver">The dependency resolver.</param>
/// <param name="configuration">The SQL scale-out configuration options.</param>
/// <param name="serviceProvider"></param>
/// <returns>The dependency resolver.</returns>
public static IDependencyResolver UseFluentNHibernate(this IDependencyResolver resolver,
FNHScaleoutConfiguration configuration, IServiceProvider serviceProvider = null)
{
if (resolver == null)
{
throw new ArgumentNullException(nameof(resolver));
}
if (serviceProvider == null)
{
var sc = new ServiceCollection();
sc.AddLogging();
serviceProvider = sc.BuildServiceProvider();
}
else
{
var test = serviceProvider.GetService <ILogger <KoreMessageBus> >();
if (test == null)
{
throw new ArgumentException(
$"Configured service provider must provide logging ({typeof(ILogger).FullName})");
}
}
var bus =
new KoreMessageBus(resolver, configuration, serviceProvider).WithRepository(c =>
new FluentNHibernateMessageRepository(configuration, serviceProvider.GetService <ILogger <FluentNHibernateMessageRepository> >()));
bus.Start();
resolver.Register(typeof(IMessageBus), () => bus);
return(resolver);
}
internal FNHMessageBus(IDependencyResolver resolver, FNHScaleoutConfiguration configuration)
: base(resolver, configuration)
{
_configuration = configuration ?? throw new ArgumentNullException("configuration");
var traceManager = resolver.Resolve <ITraceManager>();
_trace = traceManager[typeof(FNHMessageBus).FullName];
ThreadPool.QueueUserWorkItem(Initialize);
}
/// <summary>
/// Use database as the messaging backplane for scaling out of ASP.NET SignalR applications in a web farm.
/// </summary>
/// <param name="resolver">The dependency resolver.</param>
/// <param name="configuration">The SQL scale-out configuration options.</param>
/// <returns>The dependency resolver.</returns>
public static IDependencyResolver UseFluentNHibernate(this IDependencyResolver resolver,
FNHScaleoutConfiguration configuration)
{
if (resolver == null)
{
throw new ArgumentNullException("resolver");
}
var bus = new Lazy <FNHMessageBus>(() => { return(new FNHMessageBus(resolver, configuration)); });
resolver.Register(typeof(IMessageBus), () => bus.Value);
return(resolver);
}
/// <summary>
/// </summary>
/// <param name="configuration"></param>
/// <param name="logger"></param>
public FluentNHibernateMessageRepository(FNHScaleoutConfiguration configuration,
ILogger <FluentNHibernateMessageRepository> logger)
{
_configuration = configuration;
var sessionFactoryInfo = SessionFactoryBuilder.GetFromAssemblyOf <MessagePayloadMap_0>(
configuration.ProviderType, configuration.ConnectionString,
new FluentNHibernatePersistenceBuilderOptions {
DefaultSchema = configuration.DefaultSchema
});
_logger = logger;
_sessionFactory = sessionFactoryInfo.SessionFactory;
for (var streamIndex = 0; streamIndex < configuration.StreamCount; streamIndex++)
{
_streamInfos[streamIndex] = new StreamInfo(streamIndex);
}
}
