Add durable and expires properties to responder configuration (#1037)

* add durable and expires properties to responder configuration

* int? -> int

* add xml docs

* fix typos to trigger rebuild

Author: sungam3r

Source/EasyNetQ.Tests.Tasks/Tasks/SimpleRequester/LatencyRecorder.cs

@@ -51,11 +51,11 @@ public void Report(object status)
             var ticksTenSecondsAgo = DateTime.Now.AddSeconds(-10).Ticks;
             var lateResponses = requests.Where(x => (!x.Value.HasResponded) && (x.Value.Ticks < ticksTenSecondsAgo));
 
-            var reponded = requests.Count(x => x.Value.HasResponded);
+            var responded = requests.Count(x => x.Value.HasResponded);
 
-            Console.WriteLine("Total: {0}, reponded: {1} over 10 seconds late: [{2}]", 
+            Console.WriteLine("Total: {0}, responded: {1} over 10 seconds late: [{2}]", 
                 requests.Count,
-                reponded,
+                responded,
                 string.Join(",", lateResponses.Select(x => x.Value.Id.ToString())));
         }
     }
@@ -79,4 +79,4 @@ public void Respond()
         public bool HasResponded { get; private set; }
         public long ResponseTimeTicks { get; private set; }
     }
-}
+}

Source/EasyNetQ.Tests.Tasks/Tasks/TestSimpleService.cs

@@ -46,7 +46,7 @@ public Task Run(CancellationToken cancellationToken)
 
         private static Task<TestAsyncResponseMessage> HandleAsyncRequest(TestAsyncRequestMessage request)
         {
-            Console.Out.WriteLine("Got aysnc request '{0}'", request.Text);
+            Console.Out.WriteLine("Got async request '{0}'", request.Text);
 
             return RunDelayed(1000, () =>
             {

Source/EasyNetQ.Tests/MessageVersioningTests/VersionedExchangeDeclareStrategyTests.cs

@@ -50,7 +50,7 @@ public void Should_declare_exchange_again_if_first_attempt_failed()
 
 
         // Unversioned message - exchange declared
-        // Versioned message - superceded exchange declared, then superceding, then bind
+        // Versioned message - superseded exchange declared, then superseding, then bind
         [Fact]
         public void When_declaring_exchanges_for_unversioned_message_one_exchange_created()
         {

Source/EasyNetQ/FluentConfiguration/ISubscriptionConfiguration.cs

@@ -9,38 +9,37 @@ namespace EasyNetQ.FluentConfiguration
     /// e.g.
     /// x => x.WithTopic("*.brighton")
     /// </summary>
-    /// <typeparam name="T">The message type to be published</typeparam>
     public interface ISubscriptionConfiguration
     {
         /// <summary>
         /// Add a topic for the queue binding
         /// </summary>
         /// <param name="topic">The topic to add</param>
-        /// <returns></returns>
+        /// <returns>Reference to the same <see cref="ISubscriptionConfiguration"/> to allow methods chaining.</returns>
         ISubscriptionConfiguration WithTopic(string topic);
 
         /// <summary>
         /// Configures the queue's durability
         /// </summary>
-        /// <returns></returns>
+        /// <returns>Reference to the same <see cref="ISubscriptionConfiguration"/> to allow methods chaining.</returns>
         ISubscriptionConfiguration WithAutoDelete(bool autoDelete = true);
 
         /// <summary>
         /// Configures the queue's durability
         /// </summary>
-        /// <returns></returns>
+        /// <returns>Reference to the same <see cref="ISubscriptionConfiguration"/> to allow methods chaining.</returns>
         ISubscriptionConfiguration WithDurable(bool durable = true);
 
         /// <summary>
         /// Configures the consumer's priority
         /// </summary>
-        /// <returns></returns>
+        /// <returns>Reference to the same <see cref="ISubscriptionConfiguration"/> to allow methods chaining.</returns>
         ISubscriptionConfiguration WithPriority(int priority);
 
         /// <summary>
         /// Configures the consumer's prefetch count
         /// </summary>
-        /// <returns></returns>
+        /// <returns>Reference to the same <see cref="ISubscriptionConfiguration"/> to allow methods chaining.</returns>
         ISubscriptionConfiguration WithPrefetchCount(ushort prefetchCount);
 
         /// <summary>
@@ -53,38 +52,40 @@ public interface ISubscriptionConfiguration
         /// Leases of durable queues restart when the server restarts.
         /// </summary>
         /// <param name="expires">The value of the x-expires argument or expires policy describes the expiration period in milliseconds and is subject to the same constraints as x-message-ttl and cannot be zero. Thus a value of 1000 means a queue which is unused for 1 second will be deleted.</param>
-        /// <returns></returns>
+        /// <returns>Reference to the same <see cref="ISubscriptionConfiguration"/> to allow methods chaining.</returns>
         ISubscriptionConfiguration WithExpires(int expires);
 
         /// <summary>
         /// Configures the consumer's to be exclusive
         /// </summary>
-        /// <returns></returns>
+        /// <returns>Reference to the same <see cref="ISubscriptionConfiguration"/> to allow methods chaining.</returns>
         ISubscriptionConfiguration AsExclusive(bool isExclusive = true);
 
         /// <summary>
         /// Configures the queue's maxPriority
         /// </summary>
-        /// <returns></returns>
+        /// <returns>Reference to the same <see cref="ISubscriptionConfiguration"/> to allow methods chaining.</returns>
         ISubscriptionConfiguration WithMaxPriority(byte priority);
 
         /// <summary>
         /// Sets the queue name
         /// </summary>
         /// <param name="queueName"></param>
-        /// <returns></returns>
+        /// <returns>Reference to the same <see cref="ISubscriptionConfiguration"/> to allow methods chaining.</returns>
         ISubscriptionConfiguration WithQueueName(string queueName);
 
         /// <summary>
         /// The maximum number of ready messages that may exist on the queue. 
         /// Messages will be dropped or dead-lettered from the front of the queue to make room for new messages once the limit is reached.
         /// </summary>
+        /// <returns>Reference to the same <see cref="ISubscriptionConfiguration"/> to allow methods chaining.</returns>
         ISubscriptionConfiguration WithMaxLength(int maxLength);
 
         /// <summary>
         /// The maximum size of the queue in bytes.
         /// Messages will be dropped or dead-lettered from the front of the queue to make room for new messages once the limit is reached
         /// </summary>
+        /// <returns>Reference to the same <see cref="ISubscriptionConfiguration"/> to allow methods chaining.</returns>
         ISubscriptionConfiguration WithMaxLengthBytes(int maxLengthBytes);
     }
 
@@ -179,4 +180,4 @@ public ISubscriptionConfiguration WithMaxLengthBytes(int maxLengthBytes)
             return this;
         }
     }
-}
+}

Source/EasyNetQ/Producer/IResponderConfiguration.cs

@@ -1,9 +1,40 @@
 namespace EasyNetQ.Producer
 {
+    /// <summary>
+    /// Allows configuration to be fluently extended without adding overloads to IBus
+    /// 
+    /// e.g.
+    /// x => x.WithPrefetchCount(50)
+    /// </summary>
     public interface IResponderConfiguration
     {
         IResponderConfiguration WithPrefetchCount(ushort prefetchCount);
+
+        /// <summary>
+        /// Sets the queue name
+        /// </summary>
+        /// <param name="queueName"></param>
+        /// <returns>Reference to the same <see cref="IResponderConfiguration"/> to allow methods chaining.</returns>
         IResponderConfiguration WithQueueName(string queueName);
+
+        /// <summary>
+        /// Configures the queue's durability
+        /// </summary>
+        /// <returns>Reference to the same <see cref="IResponderConfiguration"/> to allow methods chaining.</returns>
+        IResponderConfiguration WithDurable(bool durable = true);
+
+        /// <summary>
+        /// Expiry time can be set for a given queue by setting the x-expires argument to queue.declare, or by setting the expires policy. 
+        /// This controls for how long a queue can be unused before it is automatically deleted. 
+        /// Unused means the queue has no consumers, the queue has not been redeclared, and basic.get has not been invoked for a duration of at least the expiration period. 
+        /// This can be used, for example, for RPC-style reply queues, where many queues can be created which may never be drained.
+        /// The server guarantees that the queue will be deleted, if unused for at least the expiration period. 
+        /// No guarantee is given as to how promptly the queue will be removed after the expiration period has elapsed. 
+        /// Leases of durable queues restart when the server restarts.
+        /// </summary>
+        /// <param name="expires">The value of the x-expires argument or expires policy describes the expiration period in milliseconds and is subject to the same constraints as x-message-ttl and cannot be zero. Thus a value of 1000 means a queue which is unused for 1 second will be deleted.</param>
+        /// <returns>Reference to the same <see cref="IResponderConfiguration"/> to allow methods chaining.</returns>
+        IResponderConfiguration WithExpires(int expires);
     }
 
     public class ResponderConfiguration : IResponderConfiguration
@@ -14,8 +45,19 @@ public ResponderConfiguration(ushort defaultPrefetchCount)
         }
 
         public ushort PrefetchCount { get; private set; }
+
         public string QueueName { get; private set; }
 
+        /// <summary>
+        /// Durable queues remain active when a server restarts.
+        /// </summary>
+        public bool Durable { get; private set; } = true;
+
+        /// <summary>
+        /// Determines how long (in milliseconds) a queue can remain unused before it is automatically deleted by the server.
+        /// </summary>
+        public int? Expires { get; private set; }
+
         public IResponderConfiguration WithPrefetchCount(ushort prefetchCount)
         {
             PrefetchCount = prefetchCount;
@@ -27,5 +69,17 @@ public IResponderConfiguration WithQueueName(string queueName)
             QueueName = queueName;
             return this;
         }
+
+        public IResponderConfiguration WithDurable(bool durable = true)
+        {
+            Durable = durable;
+            return this;
+        }
+
+        public IResponderConfiguration WithExpires(int expires)
+        {
+            Expires = expires;
+            return this;
+        }
     }
-}
+}

Source/EasyNetQ/Producer/Rpc.cs

@@ -255,7 +255,10 @@ public virtual IDisposable Respond<TRequest, TResponse>(Func<TRequest, Task<TRes
 
             var routingKey = configuration.QueueName ?? conventions.RpcRoutingKeyNamingConvention(requestType);
 
-            var queue = advancedBus.QueueDeclare(routingKey);
+            var queue = advancedBus.QueueDeclare(
+                routingKey,
+                durable: configuration.Durable,
+                expires: configuration.Expires);
 
             var exchange = DeclareAndBindRpcExchange(
                     conventions.RpcRequestExchangeNamingConvention(requestType),