Merge

--HG--
branch : dev

src/Orchard.Tests.Modules/Setup/SetupControllerTests.cs

@@ -5,8 +5,8 @@ using System.Web.Routing;
 using Autofac;
 using NUnit.Framework;
 using Orchard.Environment;
+using Orchard.Environment.AutofacUtil;
 using Orchard.Environment.Configuration;
-using Orchard.Environment.ShellBuilders;
 using Orchard.Setup.Controllers;
 using Orchard.Setup.ViewModels;
 using Orchard.UI.Notify;

src/Orchard.Tests/ContentManagement/ContentPartDriverHandlerTests.cs

@@ -6,7 +6,7 @@ using NUnit.Framework;
 using Orchard.ContentManagement;
 using Orchard.ContentManagement.Drivers;
 using Orchard.ContentManagement.Handlers;
-using Orchard.Environment.ShellBuilders;
+using Orchard.Environment.AutofacUtil;
 using Orchard.Mvc.ViewModels;
 using Orchard.UI.Zones;
 

src/Orchard.Tests/Environment/AutofacUtil/DynamicProxy2/DynamicProxyTests.cs

@@ -0,0 +1,141 @@
+using System;
+using Autofac;
+using Autofac.Core;
+using Autofac.Features.Metadata;
+using Castle.Core.Interceptor;
+using NUnit.Framework;
+using Orchard.Environment.AutofacUtil.DynamicProxy2;
+
+namespace Orchard.Tests.Environment.AutofacUtil.DynamicProxy2 {
+    [TestFixture]
+    public class DynamicProxyTests {
+        [Test]
+        public void ContextAddedToMetadataWhenRegistered() {
+            var context = new DynamicProxyContext();
+
+            var builder = new ContainerBuilder();
+            builder.RegisterType<SimpleComponent>().EnableDynamicProxy(context);
+
+            var container = builder.Build();
+
+            var meta = container.Resolve<Meta<SimpleComponent>>();
+            Assert.That(meta.Metadata, Has.Some.Property("Key").EqualTo("Orchard.Environment.AutofacUtil.DynamicProxy2.DynamicProxyContext.ProxyContextKey"));
+            Assert.That(meta.Metadata["Orchard.Environment.AutofacUtil.DynamicProxy2.DynamicProxyContext.ProxyContextKey"], Is.SameAs(context));
+        }
+
+        [Test]
+        public void ProxyContextReturnsTrueIfTypeHasBeenProxied() {
+            var context = new DynamicProxyContext();
+
+            Type proxyType;
+            Assert.That(context.TryGetProxy(typeof(SimpleComponent), out proxyType), Is.False);
+            Assert.That(context.TryGetProxy(typeof(SimpleComponent), out proxyType), Is.False);
+            Assert.That(proxyType, Is.Null);
+
+            context.AddProxy(typeof(SimpleComponent));
+            Assert.That(context.TryGetProxy(typeof(SimpleComponent), out proxyType), Is.True);
+            Assert.That(context.TryGetProxy(typeof(SimpleComponent), out proxyType), Is.True);
+            Assert.That(proxyType, Is.Not.Null);
+        }
+
+        [Test]
+        public void AddProxyCanBeCalledMoreThanOnce() {
+            var context = new DynamicProxyContext();
+            context.AddProxy(typeof(SimpleComponent));
+
+            Type proxyType;
+            Assert.That(context.TryGetProxy(typeof(SimpleComponent), out proxyType), Is.True);
+            Assert.That(proxyType, Is.Not.Null);
+
+            Type proxyType2;
+            context.AddProxy(typeof(SimpleComponent));
+            Assert.That(context.TryGetProxy(typeof(SimpleComponent), out proxyType2), Is.True);
+
+            Assert.That(proxyType2, Is.SameAs(proxyType));
+        }
+
+        [Test]
+        public void InterceptorAddedToContextFromModules() {
+            var context = new DynamicProxyContext();
+
+            var builder = new ContainerBuilder();
+            builder.RegisterType<SimpleComponent>().EnableDynamicProxy(context);
+            builder.RegisterModule(new SimpleInterceptorModule());
+
+            builder.Build();
+
+            Type proxyType;
+            Assert.That(context.TryGetProxy(typeof(SimpleComponent), out proxyType), Is.True);
+            Assert.That(proxyType, Is.Not.Null);
+        }
+
+        [Test]
+        public void ResolvedObjectIsSubclass() {
+            var context = new DynamicProxyContext();
+
+            var builder = new ContainerBuilder();
+            builder.RegisterType<SimpleComponent>().EnableDynamicProxy(context);
+            builder.RegisterModule(new SimpleInterceptorModule());
+
+            var container = builder.Build();
+
+            var simpleComponent = container.Resolve<SimpleComponent>();
+            Assert.That(simpleComponent, Is.InstanceOf<SimpleComponent>());
+            Assert.That(simpleComponent, Is.Not.TypeOf<SimpleComponent>());
+        }
+
+        [Test]
+        public void InterceptorCatchesMethodCallOnlyFromContainerWithInterceptor() {
+            var context = new DynamicProxyContext();
+
+            var builder1 = new ContainerBuilder();
+            builder1.RegisterType<SimpleComponent>().EnableDynamicProxy(context);
+            builder1.RegisterModule(new SimpleInterceptorModule());
+            var container1 = builder1.Build();
+
+            var simple1 = container1.Resolve<SimpleComponent>();
+
+            var builder2 = new ContainerBuilder();
+            builder2.RegisterType<SimpleComponent>().EnableDynamicProxy(context);
+            var container2 = builder2.Build();
+
+            var simple2 = container2.Resolve<SimpleComponent>();
+
+            Assert.That(simple2.SimpleMethod(), Is.EqualTo("default return value"));
+            Assert.That(simple1.SimpleMethod(), Is.EqualTo("different return value"));
+        }
+    }
+
+    public class SimpleComponent {
+        public virtual string SimpleMethod() {
+            return "default return value";
+        }
+    }
+
+    public class SimpleInterceptorModule : Module {
+        protected override void Load(ContainerBuilder builder) {
+            builder.RegisterType<SimpleInterceptor>();
+
+            base.Load(builder);
+        }
+
+        protected override void AttachToComponentRegistration(
+            IComponentRegistry componentRegistry,
+            IComponentRegistration registration) {
+
+            if (DynamicProxyContext.From(registration) != null)
+                registration.InterceptedBy<SimpleInterceptor>();
+        }
+    }
+
+    public class SimpleInterceptor : IInterceptor {
+        public void Intercept(IInvocation invocation) {
+            if (invocation.Method.Name == "SimpleMethod") {
+                invocation.ReturnValue = "different return value";
+            }
+            else {
+                invocation.Proceed();
+            }
+        }
+    }
+}

src/Orchard.Tests/Environment/DefaultOrchardHostTests.cs

@@ -9,8 +9,8 @@ using Autofac.Integration.Web;
 using Moq;
 using NUnit.Framework;
 using Orchard.Environment;
+using Orchard.Environment.AutofacUtil;
 using Orchard.Environment.Configuration;
-using Orchard.Environment.ShellBuilders;
 using Orchard.Mvc;
 using Orchard.Mvc.ModelBinders;
 using Orchard.Mvc.Routes;

src/Orchard.Tests/Orchard.Tests.csproj

@@ -43,6 +43,14 @@
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\lib\autofac\Autofac.Integration.Web.Mvc.dll</HintPath>
     </Reference>
+    <Reference Include="Castle.Core, Version=1.2.0.0, Culture=neutral, PublicKeyToken=407dd0808d44fbdc, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\lib\Castle Windsor 2.0\bin\Castle.Core.dll</HintPath>
+    </Reference>
+    <Reference Include="Castle.DynamicProxy2, Version=2.1.0.0, Culture=neutral, PublicKeyToken=407dd0808d44fbdc, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\lib\Castle Windsor 2.0\bin\Castle.DynamicProxy2.dll</HintPath>
+    </Reference>
     <Reference Include="FluentNHibernate, Version=1.0.0.593, Culture=neutral, PublicKeyToken=8aa435e3cb308880, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\lib\fluentnhibernate\FluentNHibernate.dll</HintPath>
@@ -143,6 +151,7 @@
     <Compile Include="Data\Builders\SessionFactoryBuilderTests.cs" />
     <Compile Include="Data\RepositoryTests.cs" />
     <Compile Include="Data\StubLocator.cs" />
+    <Compile Include="Environment\AutofacUtil\DynamicProxy2\DynamicProxyTests.cs" />
     <Compile Include="Environment\Configuration\AppDataFolderTests.cs" />
     <Compile Include="Environment\DefaultCompositionStrategyTests.cs" />
     <Compile Include="Environment\DefaultOrchardHostTests.cs" />

src/Orchard/Environment/AutofacUtil/ContainerUpdater.cs

@@ -3,9 +3,9 @@ using System.Collections.Generic;
 using Autofac;
 using Autofac.Core;
 
-namespace Orchard.Environment.ShellBuilders {
+namespace Orchard.Environment.AutofacUtil {
     public class ContainerUpdater : ContainerBuilder {
-        ICollection<Action<IComponentRegistry>> _configurationActions = new List<Action<IComponentRegistry>>();
+        readonly ICollection<Action<IComponentRegistry>> _configurationActions = new List<Action<IComponentRegistry>>();
 
         public override void RegisterCallback(Action<IComponentRegistry> configurationAction) {
             _configurationActions.Add(configurationAction);

src/Orchard/Environment/AutofacUtil/DynamicProxy2/ConstructorFinderWrapper.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using Autofac.Core.Activators.Reflection;
+
+namespace Orchard.Environment.AutofacUtil.DynamicProxy2 {
+    class ConstructorFinderWrapper : IConstructorFinder {
+        private readonly IConstructorFinder _constructorFinder;
+        private readonly DynamicProxyContext _dynamicProxyContext;
+
+        public ConstructorFinderWrapper(IConstructorFinder constructorFinder, DynamicProxyContext dynamicProxyContext) {
+            _constructorFinder = constructorFinder;
+            _dynamicProxyContext = dynamicProxyContext;
+        }
+
+        public IEnumerable<ConstructorInfo> FindConstructors(Type targetType) {
+            Type proxyType;
+            if (_dynamicProxyContext.TryGetProxy(targetType, out proxyType)) {
+                return _constructorFinder.FindConstructors(proxyType);
+            }
+            return _constructorFinder.FindConstructors(targetType);
+        }
+    }
+}

src/Orchard/Environment/AutofacUtil/DynamicProxy2/DynamicProxyContext.cs

@@ -0,0 +1,97 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Autofac;
+using Autofac.Builder;
+using Autofac.Core;
+using Castle.Core.Interceptor;
+using Castle.DynamicProxy;
+
+namespace Orchard.Environment.AutofacUtil.DynamicProxy2 {
+    public class DynamicProxyContext {
+        const string ProxyContextKey = "Orchard.Environment.AutofacUtil.DynamicProxy2.DynamicProxyContext.ProxyContextKey";
+        const string InterceptorServicesKey = "Orchard.Environment.AutofacUtil.DynamicProxy2.DynamicProxyContext.InterceptorServicesKey";
+
+        readonly IProxyBuilder _proxyBuilder = new DefaultProxyBuilder();
+        readonly IDictionary<Type, Type> _cache = new Dictionary<Type, Type>();
+
+        /// <summary>
+        /// Static method to resolve the context for a component registration. The context is set
+        /// by using the registration builder extension method EnableDynamicProxy(context).
+        /// </summary>
+        public static DynamicProxyContext From(IComponentRegistration registration) {
+            object value;
+            if (registration.Metadata.TryGetValue(ProxyContextKey, out value))
+                return value as DynamicProxyContext;
+            return null;
+        }
+
+        /// <summary>
+        /// Called indirectly from the EnableDynamicProxy extension method.
+        /// Modifies a registration to support dynamic interception if needed, and act as a normal type otherwise.
+        /// </summary>
+        public void EnableDynamicProxy<TLimit, TConcreteReflectionActivatorData, TRegistrationStyle>(
+            IRegistrationBuilder<TLimit, TConcreteReflectionActivatorData, TRegistrationStyle> registrationBuilder)
+            where TConcreteReflectionActivatorData : ConcreteReflectionActivatorData {
+
+            // associate this context. used later by static DynamicProxyContext.From() method.
+            registrationBuilder.WithMetadata(ProxyContextKey, this);
+
+            // put a shim in place. this will return constructors for the proxy class if it interceptors have been added.
+            registrationBuilder.ActivatorData.ConstructorFinder = new ConstructorFinderWrapper(
+                registrationBuilder.ActivatorData.ConstructorFinder, this);
+
+            // when component is being resolved, this even handler will place the array of appropriate interceptors as the first argument
+            registrationBuilder.OnPreparing(e => {
+                object value;
+                if (e.Component.Metadata.TryGetValue(InterceptorServicesKey, out value)) {
+                    var interceptorServices = (IEnumerable<Service>)value;
+                    var interceptors = interceptorServices.Select(service => e.Context.Resolve(service)).Cast<IInterceptor>().ToArray();
+                    var parameter = new PositionalParameter(0, interceptors);
+                    e.Parameters = new[] { parameter }.Concat(e.Parameters).ToArray();
+                }
+            });
+        }
+
+        /// <summary>
+        /// Called indirectly from the InterceptedBy extension method.
+        /// Adds services to the componenent's list of interceptors, activating the need for dynamic proxy
+        /// </summary>
+        public void AddInterceptorService(IComponentRegistration registration, Service service) {
+            AddProxy(registration.Activator.LimitType);
+
+            var interceptorServices = Enumerable.Empty<Service>();
+            object value;
+            if (registration.Metadata.TryGetValue(InterceptorServicesKey, out value)) {
+                interceptorServices = (IEnumerable<Service>)value;
+            }
+
+            registration.Metadata[InterceptorServicesKey] = interceptorServices.Concat(new[] { service }).Distinct().ToArray();
+        }
+
+
+        /// <summary>
+        /// Ensures that a proxy has been generated for the particular type in this context
+        /// </summary>
+        public void AddProxy(Type type) {
+            Type proxyType;
+            if (_cache.TryGetValue(type, out proxyType))
+                return;
+
+            lock (_cache) {
+                if (_cache.TryGetValue(type, out proxyType))
+                    return;
+
+                _cache[type] = _proxyBuilder.CreateClassProxy(type, ProxyGenerationOptions.Default);
+            }
+        }
+
+        /// <summary>
+        /// Determines if a proxy has been generated for the given type, and returns it.
+        /// </summary>
+        public bool TryGetProxy(Type type, out Type proxyType) {
+            return _cache.TryGetValue(type, out proxyType);
+        }
+
+    }
+}

src/Orchard/Environment/AutofacUtil/DynamicProxy2/DynamicProxyExtensions.cs

@@ -0,0 +1,35 @@
+using System;
+using Autofac.Builder;
+using Autofac.Core;
+using Autofac.Features.Scanning;
+
+namespace Orchard.Environment.AutofacUtil.DynamicProxy2 {
+    public static class DynamicProxyExtensions {
+
+        public static IRegistrationBuilder<TLimit, TConcreteReflectionActivatorData, TRegistrationStyle> EnableDynamicProxy<TLimit, TConcreteReflectionActivatorData, TRegistrationStyle>(
+            this IRegistrationBuilder<TLimit, TConcreteReflectionActivatorData, TRegistrationStyle> rb,
+            DynamicProxyContext dynamicProxyContext)
+            where TConcreteReflectionActivatorData : ConcreteReflectionActivatorData {
+
+            dynamicProxyContext.EnableDynamicProxy(rb);
+
+            return rb;
+        }
+
+        public static IRegistrationBuilder<TLimit, ScanningActivatorData, TRegistrationStyle> EnableDynamicProxy<TLimit, TRegistrationStyle>(
+           this IRegistrationBuilder<TLimit, ScanningActivatorData, TRegistrationStyle> rb,
+            DynamicProxyContext dynamicProxyContext) {
+
+            rb.ActivatorData.ConfigurationActions.Add((t, rb2) => rb2.EnableDynamicProxy(dynamicProxyContext));
+            return rb;
+        }
+
+        public static void InterceptedBy<TService>(this IComponentRegistration cr) {
+            var dynamicProxyContext = DynamicProxyContext.From(cr);
+            if (dynamicProxyContext == null)
+                throw new ApplicationException(string.Format("Component {0} was not registered with EnableDynamicProxy", cr.Activator.LimitType));
+
+            dynamicProxyContext.AddInterceptorService(cr, new TypedService(typeof(TService)));
+        }
+    }
+}

src/Orchard/Environment/ExtensibleInterceptionModule.cs

@@ -1,28 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-using Autofac;
-using Autofac.Core;
-using AutofacContrib.DynamicProxy2;
-
-namespace Orchard.Environment {
-    //public class ExtensibleInterceptionModule : InterceptionModule {
-    //    public ExtensibleInterceptionModule(IEnumerable<IComponentInterceptorProvider> providers)
-    //        : base(new CombinedProvider(providers.Concat(new[] { new FlexibleInterceptorProvider() })), new FlexibleInterceptorAttacher()) {
-    //    }
-
-    //    class CombinedProvider : IComponentInterceptorProvider {
-    //        private readonly IEnumerable<IComponentInterceptorProvider> _providers;
-
-    //        public CombinedProvider(IEnumerable<IComponentInterceptorProvider> providers) {
-    //            _providers = providers;
-    //        }
-
-    //        public IEnumerable<Service> GetInterceptorServices(IComponentDescriptor descriptor) {
-    //            return _providers
-    //                .SelectMany(x => x.GetInterceptorServices(descriptor))
-    //                .Distinct()
-    //                .ToList();
-    //        }
-    //    }
-    //}
-}

src/Orchard/Environment/FiniteContainerProvider.cs

@@ -1,6 +1,6 @@
 using Autofac;
 using Autofac.Integration.Web;
-using Orchard.Environment.ShellBuilders;
+using Orchard.Environment.AutofacUtil;
 
 namespace Orchard.Environment {
 

src/Orchard/Environment/OrchardStarter.cs

@@ -3,6 +3,7 @@ using Autofac;
 using Autofac.Builder;
 using Autofac.Core;
 using Autofac.Integration.Web;
+using Orchard.Environment.AutofacUtil;
 using Orchard.Environment.Configuration;
 using Orchard.Environment.ShellBuilders;
 using Orchard.Extensions;

src/Orchard/Environment/ShellBuilders/DefaultShellContainerFactory.cs

@@ -1,6 +1,8 @@
 using System.Collections.Generic;
 using Autofac;
 using Autofac.Core;
+using Orchard.Environment.AutofacUtil;
+using Orchard.Environment.AutofacUtil.DynamicProxy2;
 using Orchard.Environment.Configuration;
 
 namespace Orchard.Environment.ShellBuilders {
@@ -19,9 +21,12 @@ namespace Orchard.Environment.ShellBuilders {
                 return null;
             }
 
+            var dynamicProxyContext = new DynamicProxyContext();
+
             // add module types to container being built
             var addingModulesAndServices = new ContainerUpdater();
             addingModulesAndServices.RegisterInstance(settings).As<IShellSettings>();
+            addingModulesAndServices.RegisterInstance(dynamicProxyContext);
             addingModulesAndServices.RegisterType<DefaultOrchardShell>().As<IOrchardShell>().SingleInstance();
 
             foreach (var moduleType in _compositionStrategy.GetModuleTypes()) {
@@ -32,7 +37,7 @@ namespace Orchard.Environment.ShellBuilders {
             foreach (var serviceType in _compositionStrategy.GetDependencyTypes()) {
                 foreach (var interfaceType in serviceType.GetInterfaces()) {
                     if (typeof(IDependency).IsAssignableFrom(interfaceType)) {
-                        var registrar = addingModulesAndServices.RegisterType(serviceType).As(interfaceType);
+                        var registrar = addingModulesAndServices.RegisterType(serviceType).As(interfaceType).EnableDynamicProxy(dynamicProxyContext);
                         if (typeof(ISingletonDependency).IsAssignableFrom(interfaceType)) {
                             registrar.SingleInstance();
                         }

src/Orchard/Environment/ShellBuilders/SafeModeShellContainerFactory.cs

@@ -10,6 +10,8 @@ using Autofac.Core;
 using Orchard.ContentManagement;
 using Orchard.ContentManagement.Handlers;
 using Orchard.Data.Builders;
+using Orchard.Environment.AutofacUtil;
+using Orchard.Environment.AutofacUtil.DynamicProxy2;
 using Orchard.Environment.Configuration;
 using Orchard.Extensions;
 using Orchard.Localization;
@@ -39,9 +41,12 @@ namespace Orchard.Environment.ShellBuilders {
                 return null;
             }
 
+            var dynamicProxyContext = new DynamicProxyContext();
+
             var shellScope = _container.BeginLifetimeScope();
             var builder = new ContainerUpdater();
             // standard services needed in safe mode
+            builder.RegisterInstance(dynamicProxyContext);
             builder.RegisterType<DefaultOrchardShell>().As<IOrchardShell>().InstancePerLifetimeScope();
             builder.RegisterType<RoutePublisher>().As<IRoutePublisher>().InstancePerLifetimeScope();
             builder.RegisterType<ModelBinderPublisher>().As<IModelBinderPublisher>().InstancePerLifetimeScope();
@@ -67,7 +72,7 @@ namespace Orchard.Environment.ShellBuilders {
             foreach (var serviceType in dependencies) {
                 foreach (var interfaceType in serviceType.GetInterfaces()) {
                     if (typeof(IDependency).IsAssignableFrom(interfaceType)) {
-                        var registrar = builder.RegisterType(serviceType).As(interfaceType);
+                        var registrar = builder.RegisterType(serviceType).As(interfaceType).EnableDynamicProxy(dynamicProxyContext);
                         if (typeof(ISingletonDependency).IsAssignableFrom(interfaceType)) {
                             registrar.SingleInstance();
                         }

src/Orchard/Mvc/MvcModule.cs

@@ -6,6 +6,7 @@ using System.Web.Routing;
 using Autofac;
 using Autofac.Integration.Web;
 using Autofac.Integration.Web.Mvc;
+using Orchard.Environment.AutofacUtil.DynamicProxy2;
 using Orchard.Mvc.Filters;
 using Orchard.Extensions;
 using Autofac.Core;
@@ -13,9 +14,11 @@ using Autofac.Core;
 namespace Orchard.Mvc {
     public class MvcModule : Module {
         private readonly IExtensionManager _extensionManager;
+        private readonly DynamicProxyContext _dynamicProxyContext;
 
-        public MvcModule(IExtensionManager extensionManager) {
+        public MvcModule(IExtensionManager extensionManager, DynamicProxyContext dynamicProxyContext) {
             _extensionManager = extensionManager;
+            _dynamicProxyContext = dynamicProxyContext;
         }
 
         protected override void Load(ContainerBuilder moduleBuilder) {
@@ -25,6 +28,7 @@ namespace Orchard.Mvc {
             moduleBuilder.RegisterType<FilterResolvingActionInvoker>().As(actionInvokerService).InstancePerDependency();
 
             moduleBuilder.RegisterControllers(new OrchardControllerIdentificationStrategy(extensions), assemblies.ToArray())
+                .EnableDynamicProxy(_dynamicProxyContext)
                 .InjectActionInvoker(actionInvokerService).InstancePerDependency();
 
             moduleBuilder.Register(ctx => HttpContextBaseFactory(ctx)).As<HttpContextBase>().InstancePerDependency();

src/Orchard/Orchard.csproj

@@ -43,14 +43,14 @@
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\lib\autofac\Autofac.Integration.Web.Mvc.dll</HintPath>
     </Reference>
-    <Reference Include="AutofacContrib.DynamicProxy2, Version=2.1.13.813, Culture=neutral, PublicKeyToken=17863af14b0044da, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\lib\autofac-contrib\AutofacContrib.DynamicProxy2.dll</HintPath>
-    </Reference>
     <Reference Include="Castle.Core, Version=1.1.0.0, Culture=neutral, PublicKeyToken=407dd0808d44fbdc, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\lib\Castle Windsor 2.0\bin\Castle.Core.dll</HintPath>
     </Reference>
+    <Reference Include="Castle.DynamicProxy2, Version=2.1.0.0, Culture=neutral, PublicKeyToken=407dd0808d44fbdc, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\lib\Castle Windsor 2.0\bin\Castle.DynamicProxy2.dll</HintPath>
+    </Reference>
     <Reference Include="FluentNHibernate, Version=1.0.0.593, Culture=neutral, PublicKeyToken=8aa435e3cb308880, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\lib\fluentnhibernate\FluentNHibernate.dll</HintPath>
@@ -150,10 +150,12 @@
     <Compile Include="Data\Builders\SqlServerBuilder.cs" />
     <Compile Include="Data\Conventions\StringLengthConvention.cs" />
     <Compile Include="Data\SessionFactoryHolder.cs" />
+    <Compile Include="Environment\AutofacUtil\DynamicProxy2\DynamicProxyContext.cs" />
+    <Compile Include="Environment\AutofacUtil\DynamicProxy2\DynamicProxyExtensions.cs" />
+    <Compile Include="Environment\AutofacUtil\DynamicProxy2\ConstructorFinderWrapper.cs" />
     <Compile Include="Environment\Configuration\AppDataFolder.cs" />
     <Compile Include="Environment\Configuration\ShellSettingsLoader.cs" />
-    <Compile Include="Environment\ExtensibleInterceptionModule.cs" />
+    <Compile Include="Environment\AutofacUtil\ContainerUpdater.cs" />
-    <Compile Include="Environment\ShellBuilders\ContainerUpdater.cs" />
     <Compile Include="Environment\ShellBuilders\DefaultShellContainerFactory.cs" />
     <Compile Include="Environment\ShellBuilders\IShellContainerFactory.cs" />
     <Compile Include="Environment\ShellBuilders\SafeModeShellContainerFactory.cs" />

src/Orchard/Security/SecurityModule.cs

@@ -1,43 +1,30 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Reflection;
-using Autofac;
 using Autofac.Core;
-using AutofacContrib.DynamicProxy2;
 using Castle.Core.Interceptor;
+using Orchard.Environment.AutofacUtil.DynamicProxy2;
 using Module = Autofac.Module;
 
 namespace Orchard.Security {
-    //public class SecurityModule : Module {
+    public class SecurityModule : Module {
-    //    protected override void AttachToComponentRegistration(IComponentRegistry componentRegistry, IComponentRegistration registration) {
+        protected override void AttachToComponentRegistration(IComponentRegistry componentRegistry, IComponentRegistration registration) {
-    //        var implementationType = registration.Activator.LimitType;
+            var implementationType = registration.Activator.LimitType;
-    //        var property = FindProperty(implementationType);
+            var property = FindProperty(implementationType);
 
-    //        if (property != null) {
+            if (property != null) {
-                
+                registration.InterceptedBy<ISecurityModuleInterceptor>();
-    //        }
+            }
-    //    }
+        }
 
-    //    public IEnumerable<Service> GetInterceptorServices(IComponentDescriptor descriptor) {
+        private static PropertyInfo FindProperty(Type type) {
-    //        var property = FindProperty(descriptor.BestKnownImplementationType);
+            return type.GetProperty("CurrentUser",
-    //        if (property != null) {
+                BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance,
-    //            if (property.GetGetMethod(true).IsVirtual == false) {
+                null,
-    //                throw new ApplicationException(string.Format("CurrentUser property must be virtual on class {0}", descriptor.BestKnownImplementationType.FullName));
+                typeof(IUser),
-    //            }
+                new Type[0],
-    //            yield return new TypedService(typeof(ISecurityModuleInterceptor));
+                null);
-    //        }
+        }
-    //    }
+    }
-
-    //    private static PropertyInfo FindProperty(Type type) {
-    //        return type.GetProperty("CurrentUser",
-    //            BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance,
-    //            null,
-    //            typeof(IUser),
-    //            new Type[0],
-    //            null);
-    //    }
-    //}
 
     public interface ISecurityModuleInterceptor : IInterceptor, IDependency {
 

src/Orchard/Settings/SettingsModule.cs

@@ -1,34 +1,30 @@
 using System;
-using System.Collections.Generic;
 using System.Reflection;
-using Autofac;
 using Autofac.Core;
-using AutofacContrib.DynamicProxy2;
 using Castle.Core.Interceptor;
-using Orchard.Security;
+using Orchard.Environment.AutofacUtil.DynamicProxy2;
 using Module = Autofac.Module;
 
 namespace Orchard.Settings {
-    //public class SettingsModule : Module, IComponentInterceptorProvider {
+    public class SettingsModule : Module {
-    //    public IEnumerable<Service> GetInterceptorServices(IComponentDescriptor descriptor) {
+        protected override void AttachToComponentRegistration(IComponentRegistry componentRegistry, IComponentRegistration registration) {
-    //        var property = FindProperty(descriptor.BestKnownImplementationType);
+            var implementationType = registration.Activator.LimitType;
-    //        if (property != null) {
+            var property = FindProperty(implementationType);
-    //            if (property.GetGetMethod(true).IsVirtual == false) {
-    //                throw new ApplicationException(string.Format("CurrentSite property must be virtual on class {0}", descriptor.BestKnownImplementationType.FullName));
-    //            }
-    //            yield return new TypedService(typeof(ISettingsModuleInterceptor));
-    //        }
-    //    }
 
-    //    private static PropertyInfo FindProperty(Type type) {
+            if (property != null) {
-    //        return type.GetProperty("CurrentSite",
+                registration.InterceptedBy<ISettingsModuleInterceptor>();
-    //            BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance,
+            }
-    //            null,
+        }
-    //            typeof(ISite),
+
-    //            new Type[0],
+        private static PropertyInfo FindProperty(Type type) {
-    //            null);
+            return type.GetProperty("CurrentSite",
-    //    }        
+                BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance,
-    //}
+                null,
+                typeof(ISite),
+                new Type[0],
+                null);
+        }
+    }
 
     public interface ISettingsModuleInterceptor : IInterceptor, IDependency {