merge bug26439 into stable

Author: michaelklishin

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

@@ -397,13 +397,19 @@ public bool AutoClose
             }
         }
 
+        protected void EnsureIsOpen()
+        {
+            this.m_delegate.EnsureIsOpen();
+        }
+
         public IModel CreateModel()
         {
+            this.EnsureIsOpen();
             AutorecoveringModel m;
+            m = new AutorecoveringModel(this,
+                                        (RecoveryAwareModel)this.CreateNonRecoveringModel());
             lock(this)
             {
-                m = new AutorecoveringModel(this,
-                                            (RecoveryAwareModel)this.CreateNonRecoveringModel());
                 m_models.Add(m);
             }
             return m;

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

@@ -352,8 +352,17 @@ public bool AutoClose
             }
         }
 
+        public void EnsureIsOpen()
+        {
+            if(!IsOpen)
+            {
+                throw new AlreadyClosedException(this.CloseReason);
+            }
+        }
+
         public IModel CreateModel()
         {
+            this.EnsureIsOpen();
             ISession session = CreateSession();
             IFullModel model = (IFullModel)Protocol.CreateModel(session);
             model._Private_ChannelOpen("");

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

@@ -328,11 +328,25 @@ protected Process ExecRabbitMQCtl(string args)
             }
         }
 
-        protected Process ExecCommand(string ctl, string args)
+        protected Process ExecCommand(string command)
+        {
+            return ExecCommand(command, "");
+        }
+
+        protected Process ExecCommand(string command, string args)
+        {
+            return ExecCommand(command, args, null);
+        }
+
+        protected Process ExecCommand(string ctl, string args, string changeDirTo)
         {
             Process proc = new Process();
             proc.StartInfo.CreateNoWindow  = true;
             proc.StartInfo.UseShellExecute = false;
+            if(changeDirTo != null)
+            {
+                proc.StartInfo.WorkingDirectory = changeDirTo;
+            }
 
             string cmd;
             if(IsRunningOnMono()) {
@@ -466,6 +480,23 @@ protected void CloseConnection(string pid)
                             pid +
                             "\" \"Closed via rabbitmqctl\"");
         }
+
+        protected void RestartRabbitMQ()
+        {
+            StopRabbitMQ();
+            Thread.Sleep(500);
+            StartRabbitMQ();
+        }
+
+        protected void StopRabbitMQ()
+        {
+            ExecRabbitMQCtl("stop_app");
+        }
+
+        protected void StartRabbitMQ()
+        {
+            ExecRabbitMQCtl("start_app");
+        }
     }
 
     public class TimingFixture

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

@@ -44,12 +44,14 @@
 using System.Collections.Generic;
 using System.Text;
 using System.Threading;
+using System.IO;
 
 using RabbitMQ.Client.Impl;
 using RabbitMQ.Client.Framing.Impl;
 using RabbitMQ.Client.Events;
 using RabbitMQ.Client.Exceptions;
 
+#pragma warning disable 0168
 namespace RabbitMQ.Client.Unit {
     [TestFixture]
     public class TestConnectionRecovery : IntegrationFixture {
@@ -715,6 +717,32 @@ public void TestBasicRejectAfterChannelRecovery()
             TestDelayedBasicAckNackAfterChannelRecovery(cons, latch);
         }
 
+        [Test]
+        public void TestCreateModelOnClosedAutorecoveringConnectionDoesNotHang()
+        {
+            // we don't want this to recover quickly in this test
+            var c  = CreateAutorecoveringConnection(TimeSpan.FromSeconds(20));
+
+            try
+            {
+                c.Close();
+                WaitForShutdown(c);
+                Assert.IsFalse(c.IsOpen);
+                c.CreateModel();
+                Assert.Fail("Expected an exception");
+            } catch (AlreadyClosedException ace)
+            {
+                // expected
+            } finally
+            {
+                StartRabbitMQ();
+                if(c.IsOpen)
+                {
+                    c.Abort();
+                }
+            }
+        }
+
         protected void TestDelayedBasicAckNackAfterChannelRecovery(TestBasicConsumer1 cons, AutoResetEvent latch)
         {
             var q = Model.QueueDeclare(GenerateQueueName(), false, false, false, null).QueueName;
@@ -767,7 +795,19 @@ protected void CloseAllAndWaitForRecovery(AutorecoveringConnection conn)
             Wait(rl);
         }
 
-        protected AutoResetEvent PrepareForShutdown(AutorecoveringConnection conn)
+        protected void CloseAndWaitForShutdown(AutorecoveringConnection conn)
+        {
+            var sl = PrepareForShutdown(conn);
+            CloseConnection(conn);
+            Wait(sl);
+        }
+
+        protected void WaitForShutdown(IConnection conn)
+        {
+            Wait(PrepareForShutdown(conn));
+        }
+
+        protected AutoResetEvent PrepareForShutdown(IConnection conn)
         {
             var latch = new AutoResetEvent(false);
             conn.ConnectionShutdown += (c, args) =>
@@ -845,11 +885,22 @@ protected void AssertRecordedExchanges(AutorecoveringConnection c, int n)
             Assert.AreEqual(n, c.RecordedExchanges.Count);
         }
 
+        protected IConnection CreateNonRecoveringConnection()
+        {
+            var cf = new ConnectionFactory();
+            return cf.CreateConnection();
+        }
+
         protected AutorecoveringConnection CreateAutorecoveringConnection()
+        {
+            return CreateAutorecoveringConnection(RECOVERY_INTERVAL);
+        }
+
+       protected AutorecoveringConnection CreateAutorecoveringConnection(TimeSpan interval)
         {
             var cf = new ConnectionFactory();
             cf.AutomaticRecoveryEnabled = true;
-            cf.NetworkRecoveryInterval  = RECOVERY_INTERVAL;
+            cf.NetworkRecoveryInterval  = interval;
             return (AutorecoveringConnection)cf.CreateConnection();
         }
 
@@ -862,4 +913,5 @@ protected AutorecoveringConnection CreateAutorecoveringConnectionWithTopologyRec
             return (AutorecoveringConnection)cf.CreateConnection();
         }
     }
-}
+}
+#pragma warning restore 0168