Removing obsolete eventbus interface, firing shell activated/terminated events in isolated scope, fixing tests

--HG--
branch : dev

src/Orchard.Core.Tests/Orchard.Core.Tests.csproj

@@ -52,6 +52,7 @@
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <PlatformTarget>x86</PlatformTarget>
   </PropertyGroup>
   <ItemGroup>
     <Reference Include="Autofac, Version=2.1.13.813, Culture=neutral, PublicKeyToken=17863af14b0044da, processorArchitecture=MSIL">

src/Orchard.Tests.Modules/Orchard.Tests.Modules.csproj

@@ -52,6 +52,7 @@
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <PlatformTarget>x86</PlatformTarget>
   </PropertyGroup>
   <ItemGroup>
     <Reference Include="Autofac, Version=2.1.13.813, Culture=neutral, PublicKeyToken=17863af14b0044da, processorArchitecture=MSIL">

src/Orchard.Tests.Modules/Settings/Topology/ShellDescriptorManagerTests.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Linq;
 using Autofac;
 using NUnit.Framework;
+using Orchard.Core.Settings.State;
 using Orchard.Core.Settings.Topology;
 using Orchard.Core.Settings.Topology.Records;
 using Orchard.Environment.State;
@@ -14,7 +15,8 @@ namespace Orchard.Tests.Modules.Settings.Topology {
     [TestFixture]
     public class ShellDescriptorManagerTests : DatabaseEnabledTestsBase {
         public override void Register(ContainerBuilder builder) {
-            builder.RegisterType<ShellDescriptorManager>().As<IShellDescriptorManager>();
+            builder.RegisterType<ShellDescriptorManager>().As<IShellDescriptorManager>().SingleInstance();
+            builder.RegisterType<ShellStateManager>().As<IShellStateManager>().SingleInstance();
             builder.RegisterType<StubEventBus>().As<IEventBus>().SingleInstance();
             builder.RegisterSource(new EventsRegistrationSource());
         }

src/Orchard.Tests/Environment/DefaultOrchardHostTests.cs

@@ -72,6 +72,9 @@ namespace Orchard.Tests.Environment {
             _container.Mock<IShellDescriptorManager>()
                 .Setup(cp => cp.GetShellDescriptor()).Returns(default(ShellDescriptor));
 
+            _container.Mock<IOrchardShellEvents>()
+                .Setup(e=>e.Activated());
+
             var temp = Path.GetTempFileName();
             File.Delete(temp);
             Directory.CreateDirectory(temp);

src/Orchard.Tests/Events/EventTests.cs

@@ -9,15 +9,12 @@ namespace Orchard.Tests.Events {
     public class EventTests {
         private IContainer _container;
         private IEventBus _eventBus;
-        private StubEventBusHandler _eventBusHandler;
         private StubEventHandler _eventHandler;
 
         [SetUp]
         public void Init() {
             var builder = new ContainerBuilder();
-            _eventBusHandler = new StubEventBusHandler();
             _eventHandler = new StubEventHandler();
-            builder.RegisterInstance(_eventBusHandler).As<IEventBusHandler>();
             builder.RegisterInstance(_eventHandler).As<IEventHandler>();
             builder.RegisterType<DefaultOrchardEventBus>().As<IEventBus>();
             _container = builder.Build();
@@ -181,23 +178,5 @@ namespace Orchard.Tests.Events {
             }
         }
 
-        [Test]
-        public void EventsAreCorrectlyDispatchedToHandlers_Obsolete() {
-            Assert.That(_eventBusHandler.LastMessageName, Is.Null);
-            _eventBus.Notify_Obsolete("Notification", new Dictionary<string, string>());
-            Assert.That(_eventBusHandler.LastMessageName, Is.EqualTo("Notification"));
-        }
-
-        public class StubEventBusHandler : IEventBusHandler {
-            public string LastMessageName { get; set; }
-
-            #region Implementation of IEventBusHandler
-
-            public void Process(string messageName, IDictionary<string, string> eventData) {
-                LastMessageName = messageName;
-            }
-
-            #endregion
-        }
     }
 }

src/Orchard.Web/Core/Settings/State/ShellStateManager.cs

@@ -21,7 +21,7 @@ namespace Orchard.Core.Settings.State {
         public ShellState GetShellState() {
             var stateRecord = _shellStateRepository.Get(x => true) ?? new ShellStateRecord();
             var descriptor = _shellDescriptorManager.GetShellDescriptor();
-            var extraFeatures = descriptor.Features
+            var extraFeatures = descriptor == null ? Enumerable.Empty<string>() : descriptor.Features
                 .Select(r => r.Name)
                 .Except(stateRecord.Features.Select(r => r.Name));
 

src/Orchard/Data/SessionLocator.cs

@@ -1,5 +1,9 @@
 using System;
+using System.Collections;
+using System.Data;
 using NHibernate;
+using NHibernate.SqlCommand;
+using NHibernate.Type;
 using Orchard.Logging;
 
 namespace Orchard.Data {
@@ -29,10 +33,85 @@ namespace Orchard.Data {
                 _transactionManager.Demand();
 
                 Logger.Information("Openning database session");
-                _session = sessionFactory.OpenSession();
+                _session = sessionFactory.OpenSession(new SessionInterceptor(this));
             }
             return _session;
         }
 
+        class SessionInterceptor : IInterceptor {
+            private readonly SessionLocator _sessionLocator;
+            private ISession _session;
+
+            public SessionInterceptor(SessionLocator sessionLocator) {
+                _sessionLocator = sessionLocator;
+            }
+
+            bool IInterceptor.OnLoad(object entity, object id, object[] state, string[] propertyNames, IType[] types) {
+                return true;
+            }
+
+            bool IInterceptor.OnFlushDirty(object entity, object id, object[] currentState, object[] previousState, string[] propertyNames, IType[] types) {
+                return true;
+            }
+
+            bool IInterceptor.OnSave(object entity, object id, object[] state, string[] propertyNames, IType[] types) {
+                return true;
+            }
+
+            void IInterceptor.OnDelete(object entity, object id, object[] state, string[] propertyNames, IType[] types) {
+            }
+
+            void IInterceptor.OnCollectionRecreate(object collection, object key) {
+            }
+
+            void IInterceptor.OnCollectionRemove(object collection, object key) {
+            }
+
+            void IInterceptor.OnCollectionUpdate(object collection, object key) {
+            }
+
+            void IInterceptor.PreFlush(ICollection entities) {
+            }
+
+            void IInterceptor.PostFlush(ICollection entities) {
+            }
+
+            bool? IInterceptor.IsTransient(object entity) {
+                return null;
+            }
+
+            int[] IInterceptor.FindDirty(object entity, object id, object[] currentState, object[] previousState, string[] propertyNames, IType[] types) {
+                return null;
+            }
+
+            object IInterceptor.Instantiate(string entityName, EntityMode entityMode, object id) {
+                return null;
+            }
+
+            string IInterceptor.GetEntityName(object entity) {
+                return null;
+            }
+
+            object IInterceptor.GetEntity(string entityName, object id) {
+                return null;
+            }
+
+            void IInterceptor.AfterTransactionBegin(ITransaction tx) {
+            }
+
+            void IInterceptor.BeforeTransactionCompletion(ITransaction tx) {
+            }
+
+            void IInterceptor.AfterTransactionCompletion(ITransaction tx) {
+            }
+
+            SqlString IInterceptor.OnPrepareStatement(SqlString sql) {
+                return sql;
+            }
+
+            void IInterceptor.SetSession(ISession session) {
+                _session = session;
+            }
+        }
     }
 }

src/Orchard/Environment/DefaultOrchardHost.cs

@@ -4,6 +4,7 @@ using System.Threading;
 using System.Web.Mvc;
 using Autofac;
 using System.Collections.Generic;
+using Autofac.Features.OwnedInstances;
 using Orchard.Environment.Configuration;
 using Orchard.Environment.Extensions;
 using Orchard.Environment.ShellBuilders;
@@ -98,8 +99,6 @@ namespace Orchard.Environment {
         private void ActivateShell(ShellContext context) {
             context.Shell.Activate();
             _runningShellTable.Add(context.Settings);
-            //refactor:lifecycle
-            //HackSimulateExtensionActivation(context.LifetimeScope);
         }
 
         ShellContext CreateSetupContext() {
@@ -121,31 +120,26 @@ namespace Orchard.Environment {
             BuildCurrent();
         }
 
+
+        // the exit gate is temporary, until better control strategy is in place
+        private readonly ManualResetEvent _exitGate = new ManualResetEvent(true);
+
         protected virtual void EndRequest() {
             if (_processingEngine.AreTasksPending()) {
+                _exitGate.Reset();
                 ThreadPool.QueueUserWorkItem(state => {
                     while (_processingEngine.AreTasksPending()) {
                         _processingEngine.ExecuteNextTask();
+                        if (!_processingEngine.AreTasksPending()) {
+                            _exitGate.Set();
+                        }
                     }
                 });
             }
+
+            _exitGate.WaitOne(250);
         }
 
-        //refactor:lifecycle
-        //private void HackSimulateExtensionActivation(ILifetimeScope shellContainer) {
-        //    var containerProvider = new FiniteContainerProvider(shellContainer);
-        //    try {
-        //        var requestContainer = containerProvider.RequestLifetime;
-
-        //        var hackInstallationGenerator = requestContainer.Resolve<IHackInstallationGenerator>();
-        //        hackInstallationGenerator.GenerateActivateEvents();
-        //    }
-        //    finally {
-        //        containerProvider.EndRequestLifetime();
-        //    }
-        //}
-
-
         void IShellSettingsManagerEventHandler.Saved(ShellSettings settings) {
             _current = null;
         }

src/Orchard/Environment/DefaultOrchardShell.cs

@@ -1,7 +1,9 @@
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Web.Mvc;
+using Autofac.Features.OwnedInstances;
 using Orchard.Environment.Extensions.Models;
 using Orchard.Logging;
 using Orchard.Mvc.ModelBinders;
@@ -9,21 +11,21 @@ using Orchard.Mvc.Routes;
 
 namespace Orchard.Environment {
     public class DefaultOrchardShell : IOrchardShell {
+        private readonly Func<Owned<IOrchardShellEvents>> _eventsFactory;
         private readonly IEnumerable<IRouteProvider> _routeProviders;
         private readonly IRoutePublisher _routePublisher;
         private readonly IEnumerable<IModelBinderProvider> _modelBinderProviders;
         private readonly IModelBinderPublisher _modelBinderPublisher;
         private readonly ViewEngineCollection _viewEngines;
-        private readonly IOrchardShellEvents _events;
 
         public DefaultOrchardShell(
-            IOrchardShellEvents events,
+            Func<Owned<IOrchardShellEvents>> eventsFactory,
             IEnumerable<IRouteProvider> routeProviders,
             IRoutePublisher routePublisher,
             IEnumerable<IModelBinderProvider> modelBinderProviders,
             IModelBinderPublisher modelBinderPublisher,
             ViewEngineCollection viewEngines) {
-            _events = events;
+            _eventsFactory = eventsFactory;
             _routeProviders = routeProviders;
             _routePublisher = routePublisher;
             _modelBinderProviders = modelBinderProviders;
@@ -41,11 +43,15 @@ namespace Orchard.Environment {
 
             AddOrchardLocationsFormats();
 
-            _events.Activated();
+            using (var events = _eventsFactory()) {
+                events.Value.Activated();
+            }
         }
 
         public void Terminate() {
-            _events.Terminating();
+             using (var events = _eventsFactory()) {
+                events.Value.Terminating();
+            }
         }
 
         /// <summary>

src/Orchard/Events/DefaultOrchardEventBus.cs

@@ -7,11 +7,9 @@ using Orchard.Logging;
 
 namespace Orchard.Events {
     public class DefaultOrchardEventBus : IEventBus {
-        private readonly Func<IEnumerable<IEventBusHandler>> _handlers;
         private readonly Func<IEnumerable<IEventHandler>> _eventHandlers;
 
-        public DefaultOrchardEventBus(Func<IEnumerable<IEventBusHandler>> handlers, Func<IEnumerable<IEventHandler>> eventHandlers) {
+        public DefaultOrchardEventBus(Func<IEnumerable<IEventHandler>> eventHandlers) {
-            _handlers = handlers;
             _eventHandlers = eventHandlers;
             Logger = NullLogger.Instance;
             T = NullLocalizer.Instance;
@@ -22,10 +20,6 @@ namespace Orchard.Events {
 
         #region Implementation of IEventBus
 
-        public void Notify_Obsolete(string messageName, IDictionary<string, string> eventData) {
-            _handlers().Invoke(handler => handler.Process(messageName, eventData), Logger);
-        }
-
         public void Notify(string messageName, Dictionary<string, object> eventData) {
             string[] parameters = messageName.Split('.');
             if (parameters.Length != 2) {
@@ -41,7 +35,7 @@ namespace Orchard.Events {
                 }
                 catch(Exception ex) {
                         Logger.Error(ex, "{2} thrown from {0} by {1}",
-                            interfaceName + "." +methodName,
+                            messageName,
                             eventHandler.GetType().FullName,
                             ex.GetType().Name);
                 }

src/Orchard/Events/IEventBus.cs

@@ -2,7 +2,6 @@
 
 namespace Orchard.Events {
     public interface IEventBus : IDependency {
-        void Notify_Obsolete(string messageName, IDictionary<string, string> eventData);
         void Notify(string messageName, Dictionary<string, object> eventData);
     }
 }