Ensures connection recovery does not keep going after the connection has been manually closed.

Author: kjnilsson

projects/client/RabbitMQ.Client/src/client/impl/AutorecoveringConnection.cs

@@ -397,14 +397,14 @@ public void BeginAutomaticRecovery()
 
                     recoveryTaskFactory.StartNew(() =>
                     {
-                        if(!self.ManuallyClosed)
+                        if (!self.ManuallyClosed)
                         {
                             try
                             {
 #if NETFX_CORE
-                            System.Threading.Tasks.Task.Delay(m_factory.NetworkRecoveryInterval).Wait();
+                                System.Threading.Tasks.Task.Delay(m_factory.NetworkRecoveryInterval).Wait();
 #else
-                            Thread.Sleep(m_factory.NetworkRecoveryInterval);
+                                Thread.Sleep(m_factory.NetworkRecoveryInterval);
 #endif
                                 self.PerformAutomaticRecovery();
                             }
@@ -422,19 +422,21 @@ protected void PerformAutomaticRecovery()
         {
             lock (recoveryLockTarget)
             {
-                RecoverConnectionDelegate();
-                RecoverConnectionShutdownHandlers();
-                RecoverConnectionBlockedHandlers();
-                RecoverConnectionUnblockedHandlers();
-
-                RecoverModels();
-                if (m_factory.TopologyRecoveryEnabled)
+                if (RecoverConnectionDelegate())
                 {
-                    RecoverEntities();
-                    RecoverConsumers();
-                }
+                    RecoverConnectionShutdownHandlers();
+                    RecoverConnectionBlockedHandlers();
+                    RecoverConnectionUnblockedHandlers();
+
+                    RecoverModels();
+                    if (m_factory.TopologyRecoveryEnabled)
+                    {
+                        RecoverEntities();
+                        RecoverConsumers();
+                    }
 
-                RunRecoveryEventHandlers();
+                    RunRecoveryEventHandlers();
+                }
             }
         }
 
@@ -659,56 +661,64 @@ private void Init(IFrameHandler fh)
         public void Abort()
         {
             this.ManuallyClosed = true;
-            m_delegate.Abort();
+            if(m_delegate.IsOpen)
+                m_delegate.Abort();
         }
 
         ///<summary>API-side invocation of connection abort.</summary>
         public void Abort(ushort reasonCode, string reasonText)
         {
             this.ManuallyClosed = true;
-            m_delegate.Abort(reasonCode, reasonText);
+            if (m_delegate.IsOpen)
+                m_delegate.Abort(reasonCode, reasonText);
         }
 
         ///<summary>API-side invocation of connection abort with timeout.</summary>
         public void Abort(int timeout)
         {
             this.ManuallyClosed = true;
-            m_delegate.Abort(timeout);
+            if (m_delegate.IsOpen)
+                m_delegate.Abort(timeout);
         }
 
         ///<summary>API-side invocation of connection abort with timeout.</summary>
         public void Abort(ushort reasonCode, string reasonText, int timeout)
         {
             this.ManuallyClosed = true;
-            m_delegate.Abort(reasonCode, reasonText, timeout);
+            if (m_delegate.IsOpen)
+                m_delegate.Abort(reasonCode, reasonText, timeout);
         }
 
         ///<summary>API-side invocation of connection.close.</summary>
         public void Close()
         {
             this.ManuallyClosed = true;
-            m_delegate.Close();
+            if (m_delegate.IsOpen)
+                m_delegate.Close();
         }
 
         ///<summary>API-side invocation of connection.close.</summary>
         public void Close(ushort reasonCode, string reasonText)
         {
             this.ManuallyClosed = true;
-            m_delegate.Close(reasonCode, reasonText);
+            if (m_delegate.IsOpen)
+                m_delegate.Close(reasonCode, reasonText);
         }
 
         ///<summary>API-side invocation of connection.close with timeout.</summary>
         public void Close(int timeout)
         {
             this.ManuallyClosed = true;
-            m_delegate.Close(timeout);
+            if (m_delegate.IsOpen)
+                m_delegate.Close(timeout);
         }
 
         ///<summary>API-side invocation of connection.close with timeout.</summary>
         public void Close(ushort reasonCode, string reasonText, int timeout)
         {
             this.ManuallyClosed = true;
-            m_delegate.Close(reasonCode, reasonText, timeout);
+            if (m_delegate.IsOpen)
+                m_delegate.Close(reasonCode, reasonText, timeout);
         }
 
         public IModel CreateModel()
@@ -736,7 +746,8 @@ public void HandleConnectionUnblocked()
 
         void IDisposable.Dispose()
         {
-            try {
+            try
+            {
                 Abort();
             }
             finally
@@ -752,6 +763,7 @@ void IDisposable.Dispose()
                         throw entry.Exception;
                     }
                 }
+
                 throw new OperationInterruptedException(null);
             }
         }
@@ -826,16 +838,15 @@ protected void RecoverConnectionBlockedHandlers()
             }
         }
 
-        protected void RecoverConnectionDelegate()
+        protected bool RecoverConnectionDelegate()
         {
-            bool recovering = true;
-            while (recovering)
+            while (!ManuallyClosed)
             {
                 try
                 {
                     var fh = endpoints.SelectOne(m_factory.CreateFrameHandler);
                     m_delegate = new Connection(m_factory, false, fh, this.ClientProvidedName);
-                    recovering = false;
+                    return true;
                 }
                 catch (Exception e)
                 {
@@ -866,6 +877,8 @@ protected void RecoverConnectionDelegate()
                     // TODO: provide a way to handle these exceptions
                 }
             }
+
+            return false;
         }
 
         protected void RecoverConnectionShutdownHandlers()

projects/client/Unit/src/unit/TestConnectionRecovery.cs

@@ -151,7 +151,7 @@ public void TestBasicConnectionRecoveryWithHostnameList()
         public void TestBasicConnectionRecoveryWithHostnameListAndUnreachableHosts()
         {
             using(var c = CreateAutorecoveringConnection(new List<string> { "191.72.44.22", "127.0.0.1", "localhost" }))
-            {        
+            {
                 Assert.IsTrue(c.IsOpen);
                 CloseAndWaitForRecovery(c);
                 Assert.IsTrue(c.IsOpen);
@@ -189,6 +189,24 @@ public void TestBasicConnectionRecoveryErrorEvent()
             }
         }
 
+        [Test]
+        public void TestBasicConnectionRecoveryStopsAfterManualClose()
+        {
+            Assert.IsTrue(Conn.IsOpen);
+            var c = CreateAutorecoveringConnection();
+            var latch = new AutoResetEvent(false);
+            c.ConnectionRecoveryError += (o, args) => latch.Set();
+            StopRabbitMQ();
+            latch.WaitOne(30000); // we got the failed reconnection event.
+            var triedRecoveryAfterClose = false;
+            c.Close();
+            Thread.Sleep(5000);
+            c.ConnectionRecoveryError += (o, args) => triedRecoveryAfterClose = true;
+            Thread.Sleep(10000);
+            Assert.IsFalse(triedRecoveryAfterClose);
+            StartRabbitMQ();
+        }
+
         [Test]
         public void TestBasicConnectionRecoveryWithEndpointListAndUnreachableHosts()
         {