Merge pull request #454 from FranciscoBorges/Branch_2_2_AS7

HORNETQ-1020 Fix leak: TemporaryTopic must use temporary-queues.

src/main/org/hornetq/jms/client/HornetQSession.java

@@ -747,7 +747,7 @@ public TemporaryTopic createTemporaryTopic() throws JMSException
          // does not exist - otherwise we would not be able to distinguish from a non existent topic and one with no
          // subscriptions - core has no notion of a topic
 
-         session.createQueue(simpleAddress, simpleAddress, HornetQSession.REJECTING_FILTER, false);
+         session.createTemporaryQueue(simpleAddress, simpleAddress, HornetQSession.REJECTING_FILTER);
 
          connection.addTemporaryQueue(simpleAddress);
 

tests/src/org/hornetq/tests/integration/jms/connection/CloseDestroyedConnectionTest.java

@@ -13,6 +13,7 @@
 package org.hornetq.tests.integration.jms.connection;
 
 import javax.jms.Connection;
+import javax.jms.JMSException;
 import javax.jms.MessageConsumer;
 import javax.jms.MessageProducer;
 import javax.jms.Queue;
@@ -23,12 +24,14 @@
 
 import org.hornetq.api.core.HornetQException;
 import org.hornetq.api.core.TransportConfiguration;
+import org.hornetq.api.core.client.ClientSession;
 import org.hornetq.api.jms.HornetQJMSClient;
 import org.hornetq.api.jms.JMSFactoryType;
 import org.hornetq.core.client.impl.ClientSessionInternal;
 import org.hornetq.core.logging.Logger;
 import org.hornetq.jms.client.HornetQConnectionFactory;
 import org.hornetq.jms.client.HornetQSession;
+import org.hornetq.jms.client.HornetQTemporaryTopic;
 import org.hornetq.spi.core.protocol.RemotingConnection;
 import org.hornetq.tests.util.JMSTestBase;
 
@@ -42,43 +45,82 @@
  */
 public class CloseDestroyedConnectionTest extends JMSTestBase
 {
-   private static final Logger log = Logger.getLogger(CloseDestroyedConnectionTest.class);
-
    private HornetQConnectionFactory cf;
 
+   private Connection conn;
+   private Connection conn2;
+   private HornetQSession session2;
+   private HornetQSession session1;
+
    @Override
    protected void setUp() throws Exception
    {
       super.setUp();
 
-      cf = (HornetQConnectionFactory) HornetQJMSClient.createConnectionFactoryWithoutHA(JMSFactoryType.CF, new TransportConfiguration("org.hornetq.core.remoting.impl.invm.InVMConnectorFactory"));
+      cf = (HornetQConnectionFactory)HornetQJMSClient.createConnectionFactoryWithoutHA(JMSFactoryType.CF,
+                                                                                       new TransportConfiguration("org.hornetq.core.remoting.impl.invm.InVMConnectorFactory"));
       cf.setBlockOnDurableSend(true);
       cf.setPreAcknowledge(true);
    }
 
    @Override
    protected void tearDown() throws Exception
    {
+      if (session1 != null)
+         session1.close();
+      if (session2 != null)
+         session2.close();
+      if (conn != null)
+         conn.close();
+      if (conn2 != null)
+         conn2.close();
       cf = null;
 
       super.tearDown();
    }
 
+   public void testClosingTemporaryTopicDeletesQueue() throws JMSException, HornetQException
+   {
+      conn = cf.createConnection();
+
+      Assert.assertEquals(1, server.getRemotingService().getConnections().size());
+
+      session1 = (HornetQSession)conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
+      HornetQTemporaryTopic topic = (HornetQTemporaryTopic)session1.createTemporaryTopic();
+      String address = topic.getAddress();
+      session1.close();
+      conn.close();
+      conn2 = cf.createConnection();
+      session2 = (HornetQSession)conn2.createSession(false, Session.AUTO_ACKNOWLEDGE);
+
+      ClientSession cs = session2.getCoreSession();
+      try
+      {
+         cs.createConsumer(address);
+         fail("the address from the TemporaryTopic still exists!");
+      }
+      catch (HornetQException e)
+      {
+         assertEquals("expecting 'queue does not exist'", HornetQException.QUEUE_DOES_NOT_EXIST, e.getCode());
+      }
+   }
+
    /*
     * Closing a connection that is destroyed should cleanly close everything without throwing exceptions
     */
+   @SuppressWarnings("unused")
    public void testCloseDestroyedConnection() throws Exception
    {
       long connectionTTL = 500;
       cf.setClientFailureCheckPeriod(connectionTTL / 2);
       // Need to set connection ttl to a low figure so connections get removed quickly on the server
       cf.setConnectionTTL(connectionTTL);
 
-      Connection conn = cf.createConnection();
+      conn = cf.createConnection();
 
       Assert.assertEquals(1, server.getRemotingService().getConnections().size());
 
-      Session sess = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
+      session1 = (HornetQSession)conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
 
       // Give time for the initial ping to reach the server before we fail (it has connection TTL in it)
       Thread.sleep(500);
@@ -89,15 +131,15 @@ public void testCloseDestroyedConnection() throws Exception
 
       super.createQueue(queueName);
 
-      MessageConsumer consumer = sess.createConsumer(queue);
+      MessageConsumer consumer = session1.createConsumer(queue);
 
-      MessageProducer producer = sess.createProducer(queue);
+      MessageProducer producer = session1.createProducer(queue);
 
-      QueueBrowser browser = sess.createBrowser(queue);
+      QueueBrowser browser = session1.createBrowser(queue);
 
       // Now fail the underlying connection
 
-      ClientSessionInternal sessi = (ClientSessionInternal)((HornetQSession)sess).getCoreSession();
+      ClientSessionInternal sessi = (ClientSessionInternal)((HornetQSession)session1).getCoreSession();
 
       RemotingConnection rc = sessi.getConnection();