Update for one-way bus configuration so that if a bus name is specifi…

…ed in the configuration, the name is used as the bases for the esent storage directory instead of the default "one_way.esent"
hibernating-rhinos · Jul 25, 2011 · d197c71 · d197c71
1 parent 8817adc
commit d197c71
Show file tree

Hide file tree

Showing 10 changed files with 95 additions and 27 deletions.
diff --git a/Rhino.ServiceBus.Autofac/AutofacBuilder.cs b/Rhino.ServiceBus.Autofac/AutofacBuilder.cs
@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.IO;
 using System.Linq;
 using System.Messaging;
 using Autofac;
@@ -220,19 +219,19 @@ public void RegisterMsmqOneWay()
             builder.Update(container);
         }
 
-        public void RegisterRhinoQueuesTransport(string path, string name, bool enablePerformanceCounters)
+        public void RegisterRhinoQueuesTransport(string path, bool enablePerformanceCounters)
         {
             var builder = new ContainerBuilder();
             builder.RegisterType<PhtSubscriptionStorage>()
-                .WithParameter("subscriptionPath", Path.Combine(path, name + "_subscriptions.esent"))
+                .WithParameter("subscriptionPath", path + "_subscriptions.esent")
                 .As<ISubscriptionStorage>()
                 .SingleInstance();
             builder.RegisterType<RhinoQueuesTransport>()
                 .WithParameter("threadCount", config.ThreadCount)
                 .WithParameter("endpoint", config.Endpoint)
                 .WithParameter("queueIsolationLevel", config.IsolationLevel)
                 .WithParameter("numberOfRetries", config.NumberOfRetries)
-                .WithParameter("path", Path.Combine(path, name + ".esent"))
+                .WithParameter("path", path + ".esent")
                 .WithParameter("enablePerformanceCounters", enablePerformanceCounters)
                 .As<ITransport>()
                 .SingleInstance();
@@ -252,7 +251,7 @@ public void RegisterRhinoQueuesOneWay()
                 .SingleInstance();
             builder.RegisterType<RhinoQueuesOneWayBus>()
                 .WithParameter("messageOwners", oneWayConfig.MessageOwners)
-                .WithParameter("path", Path.Combine(busConfig.Path, "one_way.esent"))
+                .WithParameter("path", busConfig.ConstructedPath + ".esent")
                 .WithParameter("enablePerformanceCounters", busConfig.EnablePerformanceCounters)
                 .As<IOnewayBus>()
                 .SingleInstance();

diff --git a/Rhino.ServiceBus.Castle/CastleBuilder.cs b/Rhino.ServiceBus.Castle/CastleBuilder.cs
@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.IO;
 using System.Linq;
 using System.Messaging;
 using Castle.Core;
@@ -253,15 +252,15 @@ public void RegisterMsmqOneWay()
                        .DependsOn(new { messageOwners = oneWayConfig.MessageOwners }));
         }
 
-        public void RegisterRhinoQueuesTransport(string path, string name, bool enablePerformanceCounters)
+        public void RegisterRhinoQueuesTransport(string path, bool enablePerformanceCounters)
         {
             container.Register(
                 Component.For<ISubscriptionStorage>()
                     .LifeStyle.Is(LifestyleType.Singleton)
                     .ImplementedBy(typeof(PhtSubscriptionStorage))
                     .DependsOn(new
                     {
-                        subscriptionPath = Path.Combine(path, name + "_subscriptions.esent")
+                        subscriptionPath = path + "_subscriptions.esent"
                     }),
                 Component.For<ITransport>()
                     .LifeStyle.Is(LifestyleType.Singleton)
@@ -272,7 +271,7 @@ public void RegisterRhinoQueuesTransport(string path, string name, bool enablePe
                         endpoint = config.Endpoint,
                         queueIsolationLevel = config.IsolationLevel,
                         numberOfRetries = config.NumberOfRetries,
-                        path = Path.Combine(path, name + ".esent"),
+                        path = path + ".esent",
                         enablePerformanceCounters
                     }),
                 Component.For<IMessageBuilder<MessagePayload>>()
@@ -295,7 +294,7 @@ public void RegisterRhinoQueuesOneWay()
                         .DependsOn(new
                         {
                             messageOwners = oneWayConfig.MessageOwners.ToArray(),
-                            path = Path.Combine(busConfig.Path,  "one_way.esent"),
+                            path = busConfig.ConstructedPath + ".esent",
                             enablePerformanceCounters = busConfig.EnablePerformanceCounters
                         })
                     );

diff --git a/Rhino.ServiceBus.Spring/SpringBuilder.cs b/Rhino.ServiceBus.Spring/SpringBuilder.cs
@@ -1,5 +1,4 @@
 using System;
-using System.IO;
 using System.Linq;
 using System.Messaging;
 
@@ -204,17 +203,17 @@ public void RegisterMsmqOneWay()
             applicationContext.RegisterSingleton<IOnewayBus>(() => new MsmqOnewayBus(oneWayConfig.MessageOwners, applicationContext.Get<IMessageBuilder<Message>>()));
         }
 
-        public void RegisterRhinoQueuesTransport(string path, string name, bool enablePerformanceCounters)
+        public void RegisterRhinoQueuesTransport(string path, bool enablePerformanceCounters)
         {
-            applicationContext.RegisterSingleton<ISubscriptionStorage>(() => new PhtSubscriptionStorage(Path.Combine(path, name + "_subscriptions.esent"),
+            applicationContext.RegisterSingleton<ISubscriptionStorage>(() => new PhtSubscriptionStorage(path + "_subscriptions.esent",
                                                                                   applicationContext.Get<IMessageSerializer>(),
                                                                                   applicationContext.Get<IReflection>()));
 
             applicationContext.RegisterSingleton<ITransport>(typeof (RhinoQueuesTransport).FullName, () => new RhinoQueuesTransport(config.Endpoint,
                                                                                                                                     applicationContext.Get<IEndpointRouter>(),
                                                                                                                                     applicationContext.Get<IMessageSerializer>(),
                                                                                                                                     config.ThreadCount,
-                                                                                                                                    Path.Combine(path, name + ".esent"),
+                                                                                                                                    path + ".esent",
                                                                                                                                     config.IsolationLevel,
                                                                                                                                     config.NumberOfRetries,
                                                                                                                                     enablePerformanceCounters,
@@ -229,7 +228,7 @@ public void RegisterRhinoQueuesOneWay()
             var busConfig = config.ConfigurationSection.Bus;
 
             applicationContext.RegisterSingleton<IMessageBuilder<MessagePayload>>(() => new RhinoQueuesMessageBuilder(applicationContext.Get<IMessageSerializer>()));
-            applicationContext.RegisterSingleton<IOnewayBus>(() => new RhinoQueuesOneWayBus(oneWayConfig.MessageOwners, applicationContext.Get<IMessageSerializer>(), busConfig.Path, busConfig.EnablePerformanceCounters, applicationContext.Get<IMessageBuilder<MessagePayload>>()));
+            applicationContext.RegisterSingleton<IOnewayBus>(() => new RhinoQueuesOneWayBus(oneWayConfig.MessageOwners, applicationContext.Get<IMessageSerializer>(), busConfig.ConstructedPath + ".esent", busConfig.EnablePerformanceCounters, applicationContext.Get<IMessageBuilder<MessagePayload>>()));
         }
 
         public void RegisterSecurity(byte[] key)

diff --git a/Rhino.ServiceBus.StructureMap/StructureMapBuilder.cs b/Rhino.ServiceBus.StructureMap/StructureMapBuilder.cs
@@ -1,5 +1,4 @@
 using System;
-using System.IO;
 using System.Linq;
 using System.Messaging;
 using System.Transactions;
@@ -188,18 +187,18 @@ public void RegisterMsmqOneWay()
             });
         }
 
-        public void RegisterRhinoQueuesTransport(string path, string name, bool enablePerformanceCounters)
+        public void RegisterRhinoQueuesTransport(string path, bool enablePerformanceCounters)
         {
             container.Configure(c =>
             {
                 c.For<ISubscriptionStorage>().Singleton().Use<PhtSubscriptionStorage>()
-                    .Ctor<string>().Is(Path.Combine(path, name + "_subscriptions.esent"));
+                    .Ctor<string>().Is(path + "_subscriptions.esent");
                 c.For<ITransport>().Singleton().Use<RhinoQueuesTransport>()
                     .Ctor<int>("threadCount").Is(config.ThreadCount)
                     .Ctor<Uri>().Is(config.Endpoint)
                     .Ctor<IsolationLevel>().Is(config.IsolationLevel)
                     .Ctor<int>("numberOfRetries").Is(config.NumberOfRetries)
-                    .Ctor<string>().Is(Path.Combine(path, name + ".esent"))
+                    .Ctor<string>().Is(path + ".esent")
                     .Ctor<bool>().Is(enablePerformanceCounters);
                 c.For<IMessageBuilder<MessagePayload>>().Singleton().Use<RhinoQueuesMessageBuilder>();
             });
@@ -215,7 +214,7 @@ public void RegisterRhinoQueuesOneWay()
                 c.For<IMessageBuilder<MessagePayload>>().Singleton().Use<RhinoQueuesMessageBuilder>();
                 c.For<IOnewayBus>().Singleton().Use<RhinoQueuesOneWayBus>()
                     .Ctor<MessageOwner[]>().Is(oneWayConfig.MessageOwners)
-                    .Ctor<string>().Is(Path.Combine(busConfig.Path, "one_way.esent"))
+                    .Ctor<string>().Is(busConfig.ConstructedPath + ".esent")
                     .Ctor<bool>().Is(busConfig.EnablePerformanceCounters);
             });
         }

diff --git a/Rhino.ServiceBus.Tests/Rhino.ServiceBus.Tests.csproj b/Rhino.ServiceBus.Tests/Rhino.ServiceBus.Tests.csproj
@@ -142,6 +142,7 @@
     <Compile Include="Containers\StructureMap\ContainerTests.cs" />
     <Compile Include="Containers\Unity\Can_host_in_another_app_domain.cs" />
     <Compile Include="Containers\Unity\ContainerTests.cs" />
+    <Compile Include="RhinoQueues\UsingOneWayBusWithBusNameSpecified.cs" />
     <Compile Include="RhinoQueues\CustomizingMessageConstruction.cs" />
     <Compile Include="CanRouteMessageToConsumerThroughContainer.cs" />
     <Compile Include="CanSendMsgsFromOneWayBus.cs" />

diff --git a/Rhino.ServiceBus.Tests/RhinoQueues/UsingOneWayBusWithBusNameSpecified.cs b/Rhino.ServiceBus.Tests/RhinoQueues/UsingOneWayBusWithBusNameSpecified.cs
@@ -0,0 +1,63 @@
+using System;
+using System.IO;
+using Castle.Windsor;
+using Rhino.ServiceBus.Hosting;
+using Rhino.ServiceBus.Impl;
+using Xunit;
+
+namespace Rhino.ServiceBus.Tests.RhinoQueues
+{
+    public class UsingOneWayBusWithBusNameSpecified : WithDebugging, IDisposable
+    {
+        private const string DEFAULT_STORAGE_DIRECTORY = "one_way.esent";
+        private const string ALTERNATE_BUS_NAME = "another_one_way_bus";
+        private const string ALTERNATE_STORAGE_DIRECTORY = ALTERNATE_BUS_NAME + ".esent";
+
+        private readonly IWindsorContainer container;
+        private readonly string baseStorageLocation;
+        private readonly string defaultOneWayDirectory;
+        private readonly string alternateOneWayDirectory;
+
+        public UsingOneWayBusWithBusNameSpecified()
+        {
+            baseStorageLocation = Directory.GetCurrentDirectory();
+
+            defaultOneWayDirectory = Path.Combine(baseStorageLocation, DEFAULT_STORAGE_DIRECTORY);
+            if (Directory.Exists(defaultOneWayDirectory))
+                Directory.Delete(defaultOneWayDirectory, true);
+
+            alternateOneWayDirectory = Path.Combine(baseStorageLocation, ALTERNATE_STORAGE_DIRECTORY);
+            if (Directory.Exists(alternateOneWayDirectory))
+                Directory.Delete(alternateOneWayDirectory, true);
+
+            var hostConfiguration = new RhinoQueuesHostConfiguration()
+                .Bus(null, ALTERNATE_BUS_NAME)
+                .Receive("System.string", "rhino.queues://nowhere/no_queue");
+
+            container = new WindsorContainer();
+            new OnewayRhinoServiceBusConfiguration()
+                .UseConfiguration(hostConfiguration.ToBusConfiguration())
+                .UseCastleWindsor(container)
+                .Configure();
+            container.Resolve<IOnewayBus>();
+
+        }
+
+        [Fact]
+        public void Storage_should_be_created_base_on_bus_name_location()
+        {
+            Assert.True(Directory.Exists(alternateOneWayDirectory), "Expected directory not found:" + alternateOneWayDirectory);
+        }
+
+        [Fact]
+        public void Storage_should_not_be_created_at_default_location()
+        {
+            Assert.False(Directory.Exists(defaultOneWayDirectory), "Unexpected directory found:" + defaultOneWayDirectory);
+        }
+
+        public void Dispose()
+        {
+            container.Dispose();
+        }
+    }
+}
diff --git a/Rhino.ServiceBus.Unity/UnityBuilder.cs b/Rhino.ServiceBus.Unity/UnityBuilder.cs
@@ -1,5 +1,4 @@
 using System;
-using System.IO;
 using System.Linq;
 using System.Messaging;
 using System.Transactions;
@@ -229,12 +228,12 @@ public void RegisterMsmqOneWay()
                     ));
         }
 
-        public void RegisterRhinoQueuesTransport(string path, string name, bool enablePerformanceCounters)
+        public void RegisterRhinoQueuesTransport(string path, bool enablePerformanceCounters)
         {
             container.RegisterType<ISubscriptionStorage, PhtSubscriptionStorage>(
                 new ContainerControlledLifetimeManager(),
                 new InjectionConstructor(
-                    new InjectionParameter<string>(Path.Combine(path, name + "_subscriptions.esent")),
+                    new InjectionParameter<string>(path + "_subscriptions.esent"),
                     new ResolvedParameter<IMessageSerializer>(),
                     new ResolvedParameter<IReflection>()));
 
@@ -245,7 +244,7 @@ public void RegisterRhinoQueuesTransport(string path, string name, bool enablePe
                     new ResolvedParameter<IEndpointRouter>(),
                     new ResolvedParameter<IMessageSerializer>(),
                     new InjectionParameter<int>(config.ThreadCount),
-                    new InjectionParameter<string>(Path.Combine(path, name + ".esent")),
+                    new InjectionParameter<string>(path + ".esent"),
                     new InjectionParameter<IsolationLevel>(config.IsolationLevel),
                     new InjectionParameter<int>(config.NumberOfRetries),
                     new InjectionParameter<bool>(enablePerformanceCounters),
@@ -267,7 +266,7 @@ public void RegisterRhinoQueuesOneWay()
                 new InjectionConstructor(
                     new InjectionParameter<MessageOwner[]>(oneWayConfig.MessageOwners),
                     new ResolvedParameter<IMessageSerializer>(),
-                    new InjectionParameter<string>(Path.Combine(busConfig.Path, "one_way.esent")),
+                    new InjectionParameter<string>(busConfig.ConstructedPath + ".esent"),
                     new InjectionParameter<bool>(busConfig.EnablePerformanceCounters),
                     new ResolvedParameter<IMessageBuilder<MessagePayload>>()));
         }

diff --git a/Rhino.ServiceBus/Config/BusElement.cs b/Rhino.ServiceBus/Config/BusElement.cs
@@ -68,6 +68,15 @@ public string Path
             set { this["path"] = value; }
         }
 
+        public string ConstructedPath
+        {
+            get
+            {
+                //Due to validation checks elsewhere, path should never be null except in the cases of a one-way bus
+                return System.IO.Path.Combine(Path, Name == null || Name.Trim().Length == 0 ? "one_way" : Name);
+            }
+        }
+
         public bool EnablePerformanceCounters
         {
             get { return (bool)this["enablePerformanceCounters"]; }

diff --git a/Rhino.ServiceBus/Config/IBusContainerBuilder.cs b/Rhino.ServiceBus/Config/IBusContainerBuilder.cs
@@ -15,7 +15,7 @@ public interface IBusContainerBuilder
         void RegisterMsmqTransport(Type queueStrategyType);
         void RegisterQueueCreation();
         void RegisterMsmqOneWay();
-        void RegisterRhinoQueuesTransport(string path, string name, bool enablePerformanceCounters);
+        void RegisterRhinoQueuesTransport(string path, bool enablePerformanceCounters);
         void RegisterRhinoQueuesOneWay();
         void RegisterSecurity(byte[] key);
         void RegisterNoSecurity();

diff --git a/Rhino.ServiceBus/Config/RhinoQueuesConfigurationAware.cs b/Rhino.ServiceBus/Config/RhinoQueuesConfigurationAware.cs
@@ -22,7 +22,7 @@ public void Configure(AbstractRhinoServiceBusConfiguration configuration, IBusCo
                 throw new ConfigurationErrorsException(
                     "Could not find attribute 'name' in node 'bus' in configuration");
 
-            builder.RegisterRhinoQueuesTransport(busConfigSection.Path, busConfigSection.Name, busConfigSection.EnablePerformanceCounters);
+            builder.RegisterRhinoQueuesTransport(busConfigSection.ConstructedPath, busConfigSection.EnablePerformanceCounters);
         }
     }
 }