/// <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 builder = new NHibernateConfigurationBuilder(context.Settings, "Timeout", "NHibernate.Timeouts.Configuration", "StorageConfiguration");
            builder.AddMappings<TimeoutEntityMap>();
            var config = builder.Build();

            if (RunInstaller(context))
            {
                context.Settings.Get<Installer.SchemaUpdater>().Execute = identity =>
                {
                    new OptimizedSchemaUpdate(config.Configuration).Execute(false, true);
                    return Task.FromResult(0);
                };
            }

            var timeoutsCleanupExecutionInterval = context.Settings.GetOrDefault<TimeSpan?>("NHibernate.Timeouts.CleanupExecutionInterval") ?? TimeSpan.FromMinutes(2);

            context.Container.ConfigureComponent(b =>
            {
                var sessionFactory = config.Configuration.BuildSessionFactory();
                return new TimeoutPersister(
                    context.Settings.EndpointName().ToString(),
                    sessionFactory,
                    new NHibernateSynchronizedStorageAdapter(sessionFactory), new NHibernateSynchronizedStorage(sessionFactory),
                    timeoutsCleanupExecutionInterval);
            }, DependencyLifecycle.SingleInstance);

            context.RegisterStartupTask(new DetectIncorrectIndexesStartupTask(config.Configuration));
        }
        /// <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 builder = new NHibernateConfigurationBuilder(context.Settings, "Subscription", "NHibernate.Subscriptions.Configuration", "StorageConfiguration");

            builder.AddMappings <SubscriptionMap>();
            var config = builder.Build();

            if (RunInstaller(context))
            {
                context.Settings.Get <Installer.SchemaUpdater>().Execute = identity =>
                {
                    new OptimizedSchemaUpdate(config.Configuration).Execute(false, true);

                    return(Task.FromResult(0));
                };
            }

            var sessionFactory = config.Configuration.BuildSessionFactory();
            var persister      = context.Settings.HasSetting(CacheExpirationSettingsKey)
                ? new CachedSubscriptionPersister(sessionFactory, context.Settings.Get <TimeSpan>(CacheExpirationSettingsKey))
                : new SubscriptionPersister(sessionFactory);

            context.Container.ConfigureComponent(b => persister, DependencyLifecycle.SingleInstance);
            context.RegisterStartupTask(new SubscriptionPersisterInitTask(persister));
        }
        /// <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 builder = new NHibernateConfigurationBuilder(context.Settings, "Timeout", "NHibernate.Timeouts.Configuration", "StorageConfiguration");

            builder.AddMappings <TimeoutEntityMap>();
            var config = builder.Build();

            if (RunInstaller(context))
            {
                context.Settings.Get <Installer.SchemaUpdater>().Execute = identity =>
                {
                    new OptimizedSchemaUpdate(config.Configuration).Execute(false, true);
                    return(Task.FromResult(0));
                };
            }

            context.Container.ConfigureComponent(b =>
            {
                var sessionFactory = config.Configuration.BuildSessionFactory();
                return(new TimeoutPersister(
                           context.Settings.EndpointName().ToString(),
                           sessionFactory,
                           new NHibernateSynchronizedStorageAdapter(sessionFactory), new NHibernateSynchronizedStorage(sessionFactory)));
            }, DependencyLifecycle.SingleInstance);
        }
Beispiel #4
0
        /// <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 builder = new NHibernateConfigurationBuilder(context.Settings, "Deduplication", "NHibernate.GatewayDeduplication.Configuration", "StorageConfiguration");

            builder.AddMappings <DeduplicationMessageMap>();
            var config = builder.Build();

            if (RunInstaller(context))
            {
                context.Settings.Get <Installer.SchemaUpdater>().Execute = identity =>
                {
                    new SchemaUpdate(config.Configuration).Execute(false, true);

                    return(Task.FromResult(0));
                };
            }
            context.Container.ConfigureComponent(b => new GatewayDeduplication(config.Configuration.BuildSessionFactory()), DependencyLifecycle.SingleInstance);
        }