java/systests/src/main/java/org/apache/qpid/test/utils/JMXTestUtils.java - qpid - Git at Google

 /*
  *
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  *
  */
 package org.apache.qpid.test.utils;

 import junit.framework.TestCase;
 import org.apache.commons.configuration.ConfigurationException;

 import org.apache.qpid.management.common.JMXConnnectionFactory;
 import org.apache.qpid.management.common.mbeans.LoggingManagement;
 import org.apache.qpid.management.common.mbeans.ManagedBroker;
 import org.apache.qpid.management.common.mbeans.ManagedConnection;
 import org.apache.qpid.management.common.mbeans.ManagedExchange;
 import org.apache.qpid.management.common.mbeans.ManagedQueue;
 import org.apache.qpid.management.common.mbeans.ServerInformation;
 import org.apache.qpid.management.common.mbeans.UserManagement;
 import org.apache.qpid.server.model.Plugin;
 import org.apache.qpid.server.plugin.PluginFactory;

 import javax.management.InstanceNotFoundException;
 import javax.management.JMException;
 import javax.management.ListenerNotFoundException;
 import javax.management.MBeanException;
 import javax.management.MBeanServerConnection;
 import javax.management.MBeanServerInvocationHandler;
 import javax.management.MalformedObjectNameException;
 import javax.management.NotificationFilter;
 import javax.management.NotificationListener;
 import javax.management.ObjectName;
 import javax.management.remote.JMXConnector;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;

 /**
  * JMX access for tests.
  */
 public class JMXTestUtils
 {
     public static final String DEFAULT_PASSWORD = "admin";
     public static final String DEFAULT_USERID = "admin";

     private MBeanServerConnection _mbsc;
     private JMXConnector _jmxc;

     private final String _user;
     private final String _password;
     private final QpidBrokerTestCase _test;

     public JMXTestUtils(QpidBrokerTestCase test, String user, String password)
     {
         _test = test;
         _user = user;
         _password = password;
     }

     public JMXTestUtils(QpidBrokerTestCase test)
     {
         this(test, DEFAULT_USERID, DEFAULT_PASSWORD);
     }

     public void setUp() throws IOException, ConfigurationException, Exception
     {
         _test.getBrokerConfiguration().addJmxManagementConfiguration();
     }

     public void open() throws Exception
     {
         open(0);  // Zero signifies default broker to QBTC.
     }

     public void open(final int brokerPort) throws Exception
     {
         int actualBrokerPort = _test.getPort(brokerPort);
         int managementPort = _test.getManagementPort(actualBrokerPort);

         _jmxc = JMXConnnectionFactory.getJMXConnection(5000, "127.0.0.1",
                     managementPort, _user, _password);

         _mbsc = _jmxc.getMBeanServerConnection();
     }

     public void close() throws IOException
     {
         if(_jmxc != null)
         {
             _jmxc.close();
         }
     }

     public void addNotificationListener(ObjectName name, NotificationListener listener, NotificationFilter filter, Object handback)
             throws InstanceNotFoundException, IOException
     {
         _mbsc.addNotificationListener(name, listener, filter, handback);
     }

     public void removeNotificationListener(ObjectName name, NotificationListener listener)
             throws InstanceNotFoundException, IOException, ListenerNotFoundException
     {
         _mbsc.removeNotificationListener(name, listener);
     }

     /**
      * Create a non-durable exchange with the requested name
      *
      * @throws JMException if a exchange with this name already exists
      * @throws IOException if there is a problem with the JMX Connection
      * @throws MBeanException if there is another problem creating the exchange
      */
     public void createExchange(String virtualHostName, String name, String type, boolean durable)
             throws JMException, IOException, MBeanException
     {
         ManagedBroker managedBroker = getManagedBroker(virtualHostName);

         managedBroker.createNewExchange(name, type, durable);
     }

     /**
      * Create a non-durable queue (with no owner) that is named after the
      * creating test.
      *
      * @throws JMException if a queue with this name already exists
      * @throws IOException if there is a problem with the JMX Connection
      * @throws MBeanException if there is another problem creating the exchange
      */
     public void createQueue(String virtualHostName, String name, String owner, boolean durable)
             throws JMException, MBeanException, IOException
     {
         ManagedBroker managedBroker = getManagedBroker(virtualHostName);

         managedBroker.createNewQueue(name, owner, durable);
     }

     /**
      * Unregisters all the channels, queuebindings etc and unregisters
      * this exchange from managed objects.
      *
      * @throws JMException if an exchange with this name does not exist
      * @throws IOException if there is a problem with the JMX Connection
      * @throws MBeanException if there is another problem creating the exchange
      */
     public void unregisterExchange(String virtualHostName, String exchange)
             throws IOException, JMException, MBeanException
     {
         ManagedBroker managedBroker = getManagedBroker(virtualHostName);
         managedBroker.unregisterExchange(exchange);
     }

     /**
      * Unregisters the Queue bindings, removes the subscriptions and unregisters
      * from the managed objects.
      *
      * @throws JMException if a queue with this name does not exist
      * @throws IOException if there is a problem with the JMX Connection
      * @throws MBeanException if there is another problem creating the exchange
      */
     public void deleteQueue(String virtualHostName, String queueName)
             throws IOException, JMException, MBeanException
     {
         ManagedBroker managedBroker = getManagedBroker(virtualHostName);
         managedBroker.deleteQueue(queueName);
     }

     /**
      * Sets the logging level.
      *
      * @throws JMException
      * @throws IOException if there is a problem with the JMX Connection
      * @throws MBeanException
      */
     public void setRuntimeLoggerLevel(String logger, String level)
         throws IOException, JMException, MBeanException
     {
         LoggingManagement loggingManagement = getLoggingManagement();
         loggingManagement.setRuntimeLoggerLevel(logger, level);
     }

     /**
      * Reload logging config file.
      *
      * @throws JMException
      * @throws IOException if there is a problem with the JMX Connection
      * @throws MBeanException
      */
     public void reloadConfigFile()
         throws IOException, JMException, MBeanException
     {
         LoggingManagement loggingManagement = getLoggingManagement();
         loggingManagement.reloadConfigFile();
     }

     /**
      * Get list of available logger levels.
      *
      * @throws JMException
      * @throws IOException if there is a problem with the JMX Connection
      * @throws MBeanException
      */
     public String[] getAvailableLoggerLevels()
         throws IOException, JMException, MBeanException
     {
         LoggingManagement loggingManagement = getLoggingManagement();
         return loggingManagement.getAvailableLoggerLevels();
     }

     /**
      * Set root logger level.
      *
      * @throws JMException
      * @throws IOException if there is a problem with the JMX Connection
      * @throws MBeanException
      */
     public void setRuntimeRootLoggerLevel(String level)
         throws IOException, JMException, MBeanException
     {
         LoggingManagement loggingManagement = getLoggingManagement();
         loggingManagement.setRuntimeRootLoggerLevel(level);
     }

     /**
      * Get root logger level.
      *
      * @throws JMException
      * @throws IOException if there is a problem with the JMX Connection
      * @throws MBeanException
      */
     public String getRuntimeRootLoggerLevel()
         throws IOException, JMException, MBeanException
     {
         LoggingManagement loggingManagement = getLoggingManagement();
         return loggingManagement.getRuntimeRootLoggerLevel();
     }

     /**
      * Retrieve the ObjectName for a Virtualhost.
      *
      * This is then used to create a proxy to the ManagedBroker MBean.
      *
      * @param virtualHostName the VirtualHost to retrieve
      * @return the ObjectName for the VirtualHost
      */
     @SuppressWarnings("static-access")
     public ObjectName getVirtualHostManagerObjectName(String vhostName)
     {
         // Get the name of the test manager
         String query = "org.apache.qpid:type=VirtualHost.VirtualHostManager,VirtualHost="
                        + ObjectName.quote(vhostName) + ",*";

         Set<ObjectName> objectNames = queryObjects(query);

         _test.assertNotNull("Null ObjectName Set returned", objectNames);
         _test.assertEquals("Incorrect number test vhosts returned", 1, objectNames.size());

         // We have verified we have only one value in objectNames so return it
         ObjectName objectName = objectNames.iterator().next();
         _test.getLogger().info("Loading: " + objectName);
         return objectName;
     }

     /**
      * Retrieve the ObjectName for the given Queue on a Virtualhost.
      *
      * This is then used to create a proxy to the ManagedQueue MBean.
      *
      * @param virtualHostName the VirtualHost the Queue is on
      * @param queue The Queue to retireve
      * @return the ObjectName for the given queue on the VirtualHost
      */
     @SuppressWarnings("static-access")
     public ObjectName getQueueObjectName(String virtualHostName, String queue)
     {
         // Get the name of the test manager
         String query = getQueueObjectNameString(virtualHostName, queue);

         Set<ObjectName> objectNames = queryObjects(query);

         _test.assertNotNull("Null ObjectName Set returned", objectNames);
         _test.assertEquals("Incorrect number of queues with name '" + queue + "' returned", 1, objectNames.size());

         // We have verified we have only one value in objectNames so return it
         ObjectName objectName = objectNames.iterator().next();
         _test.getLogger().info("Loading: " + objectName);
         return objectName;
     }

 	public String getQueueObjectNameString(String virtualHostName, String queue) {
 	    return "org.apache.qpid:type=VirtualHost.Queue,VirtualHost="
                        + ObjectName.quote(virtualHostName) + ",name="
                        + ObjectName.quote(queue) + ",*";
     }

     /**
      * Generate the ObjectName for the given Exchange on a VirtualHost.
      */
     public String getExchangeObjectName(String virtualHostName, String exchange)
     {
         return "org.apache.qpid:type=VirtualHost.Exchange,VirtualHost="
                        + ObjectName.quote(virtualHostName) + ",name="
                        + ObjectName.quote(exchange) + ",*";
     }

     @SuppressWarnings("static-access")
     public <T> T getManagedObject(Class<T> managedClass, String query)
     {
         Set<ObjectName> objectNames = queryObjects(query);

         _test.assertNotNull("Null ObjectName Set returned", objectNames);
         _test.assertEquals("Unexpected number of objects matching " + managedClass + " returned", 1, objectNames.size());

         ObjectName objectName = objectNames.iterator().next();
         _test.getLogger().info("Loading: " + objectName);
         return getManagedObject(managedClass, objectName);
     }

     public boolean doesManagedObjectExist(String query)
     {
         return !queryObjects(query).isEmpty();
     }

     public int getNumberOfObjects(String query)
     {
         return queryObjects(query).size();
     }

     public <T> T getManagedObject(Class<T> managedClass, ObjectName objectName)
     {
         return MBeanServerInvocationHandler.newProxyInstance(_mbsc, objectName, managedClass, false);
     }

     public <T> List<T> getManagedObjectList(Class<T> managedClass, Set<ObjectName> objectNames)
     {
         List<T> objects = new ArrayList<T>();
         for (ObjectName name : objectNames)
         {
             objects.add(getManagedObject(managedClass, name));
         }
         return objects;
     }

     public ManagedBroker getManagedBroker(String virtualHost)
     {
         return getManagedObject(ManagedBroker.class, getVirtualHostManagerObjectName(virtualHost));
     }

     @SuppressWarnings("static-access")
     public ManagedExchange getManagedExchange(String exchangeName)
     {
         String query = getExchangeObjectName("test", exchangeName);

         Set<ObjectName> objectNames = queryObjects(query);

         _test.assertNotNull("Null ObjectName Set returned", objectNames);
         _test.assertEquals("Incorrect number of exchange with name '" + exchangeName + "' returned", 1, objectNames.size());

         // We have verified we have only one value in objectNames so return an mbean proxy for it
         ObjectName objectName = objectNames.iterator().next();
         _test.getLogger().info("Loading: " + objectName);

         return MBeanServerInvocationHandler.newProxyInstance(_mbsc, objectName, ManagedExchange.class, false);
     }

     public ManagedQueue getManagedQueue(String queueName)
     {
         ObjectName objectName = getQueueObjectName("test", queueName);
         return getManagedObject(ManagedQueue.class, objectName);
     }

     public LoggingManagement getLoggingManagement() throws MalformedObjectNameException
     {
         ObjectName objectName = new ObjectName("org.apache.qpid:type=LoggingManagement,name=LoggingManagement");
         return getManagedObject(LoggingManagement.class, objectName);
     }

     public UserManagement getUserManagement() throws MalformedObjectNameException
     {
         ObjectName objectName = new ObjectName("org.apache.qpid:type=UserManagement,name=UserManagement");
         return getManagedObject(UserManagement.class, objectName);
     }

     /**
      * Retrieve {@link ServerInformation} JMX MBean.
      */
     public ServerInformation getServerInformation()
     {
         // Get the name of the test manager
         String query = "org.apache.qpid:type=ServerInformation,name=ServerInformation,*";

         Set<ObjectName> objectNames = queryObjects(query);

         TestCase.assertNotNull("Null ObjectName Set returned", objectNames);
         TestCase.assertEquals("Incorrect number of objects returned", 1, objectNames.size());

         // We have verified we have only one value in objectNames so return it
         return getManagedObject(ServerInformation.class, objectNames.iterator().next());
     }

     /**
      * Retrieve all {@link ManagedConnection} objects.
      */
     public List<ManagedConnection> getAllManagedConnections()
     {
         // Get the name of the test manager
         String query = "org.apache.qpid:type=VirtualHost.Connection,VirtualHost=*,name=*";

         Set<ObjectName> objectNames = queryObjects(query);

         TestCase.assertNotNull("Null ObjectName Set returned", objectNames);

         return getManagedObjectList(ManagedConnection.class, objectNames);
     }

     /**
      * Retrieve all {@link ManagedConnection} objects for a particular virtual host.
      */
     public List<ManagedConnection> getManagedConnections(String vhost)
     {
         // Get the name of the test manager
         String query = "org.apache.qpid:type=VirtualHost.Connection,VirtualHost=" + ObjectName.quote(vhost) + ",name=*";

         Set<ObjectName> objectNames = queryObjects(query);

         TestCase.assertNotNull("Null ObjectName Set returned", objectNames);

         return getManagedObjectList(ManagedConnection.class, objectNames);
     }

     /**
      * Returns the Set of ObjectNames returned by the broker for the given query.
      */
     private Set<ObjectName> queryObjects(String query)
     {
         try
         {
             return _mbsc.queryNames(new ObjectName(query), null);
         }
         catch (Exception e)
         {
             throw new RuntimeException("Error using query: " + query, e);
         }
     }
 }
	/*
	*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*
	*/
	package org.apache.qpid.test.utils;

	import junit.framework.TestCase;
	import org.apache.commons.configuration.ConfigurationException;

	import org.apache.qpid.management.common.JMXConnnectionFactory;
	import org.apache.qpid.management.common.mbeans.LoggingManagement;
	import org.apache.qpid.management.common.mbeans.ManagedBroker;
	import org.apache.qpid.management.common.mbeans.ManagedConnection;
	import org.apache.qpid.management.common.mbeans.ManagedExchange;
	import org.apache.qpid.management.common.mbeans.ManagedQueue;
	import org.apache.qpid.management.common.mbeans.ServerInformation;
	import org.apache.qpid.management.common.mbeans.UserManagement;
	import org.apache.qpid.server.model.Plugin;
	import org.apache.qpid.server.plugin.PluginFactory;

	import javax.management.InstanceNotFoundException;
	import javax.management.JMException;
	import javax.management.ListenerNotFoundException;
	import javax.management.MBeanException;
	import javax.management.MBeanServerConnection;
	import javax.management.MBeanServerInvocationHandler;
	import javax.management.MalformedObjectNameException;
	import javax.management.NotificationFilter;
	import javax.management.NotificationListener;
	import javax.management.ObjectName;
	import javax.management.remote.JMXConnector;
	import java.io.IOException;
	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;

	/**
	* JMX access for tests.
	*/
	public class JMXTestUtils
	{
	public static final String DEFAULT_PASSWORD = "admin";
	public static final String DEFAULT_USERID = "admin";

	private MBeanServerConnection _mbsc;
	private JMXConnector _jmxc;

	private final String _user;
	private final String _password;
	private final QpidBrokerTestCase _test;

	public JMXTestUtils(QpidBrokerTestCase test, String user, String password)
	{
	_test = test;
	_user = user;
	_password = password;
	}

	public JMXTestUtils(QpidBrokerTestCase test)
	{
	this(test, DEFAULT_USERID, DEFAULT_PASSWORD);
	}

	public void setUp() throws IOException, ConfigurationException, Exception
	{
	_test.getBrokerConfiguration().addJmxManagementConfiguration();
	}

	public void open() throws Exception
	{
	open(0); // Zero signifies default broker to QBTC.
	}

	public void open(final int brokerPort) throws Exception
	{
	int actualBrokerPort = _test.getPort(brokerPort);
	int managementPort = _test.getManagementPort(actualBrokerPort);

	_jmxc = JMXConnnectionFactory.getJMXConnection(5000, "127.0.0.1",
	managementPort, _user, _password);

	_mbsc = _jmxc.getMBeanServerConnection();
	}

	public void close() throws IOException
	{
	if(_jmxc != null)
	{
	_jmxc.close();
	}
	}

	public void addNotificationListener(ObjectName name, NotificationListener listener, NotificationFilter filter, Object handback)
	throws InstanceNotFoundException, IOException
	{
	_mbsc.addNotificationListener(name, listener, filter, handback);
	}

	public void removeNotificationListener(ObjectName name, NotificationListener listener)
	throws InstanceNotFoundException, IOException, ListenerNotFoundException
	{
	_mbsc.removeNotificationListener(name, listener);
	}

	/**
	* Create a non-durable exchange with the requested name
	*
	* @throws JMException if a exchange with this name already exists
	* @throws IOException if there is a problem with the JMX Connection
	* @throws MBeanException if there is another problem creating the exchange
	*/
	public void createExchange(String virtualHostName, String name, String type, boolean durable)
	throws JMException, IOException, MBeanException
	{
	ManagedBroker managedBroker = getManagedBroker(virtualHostName);

	managedBroker.createNewExchange(name, type, durable);
	}

	/**
	* Create a non-durable queue (with no owner) that is named after the
	* creating test.
	*
	* @throws JMException if a queue with this name already exists
	* @throws IOException if there is a problem with the JMX Connection
	* @throws MBeanException if there is another problem creating the exchange
	*/
	public void createQueue(String virtualHostName, String name, String owner, boolean durable)
	throws JMException, MBeanException, IOException
	{
	ManagedBroker managedBroker = getManagedBroker(virtualHostName);

	managedBroker.createNewQueue(name, owner, durable);
	}

	/**
	* Unregisters all the channels, queuebindings etc and unregisters
	* this exchange from managed objects.
	*
	* @throws JMException if an exchange with this name does not exist
	* @throws IOException if there is a problem with the JMX Connection
	* @throws MBeanException if there is another problem creating the exchange
	*/
	public void unregisterExchange(String virtualHostName, String exchange)
	throws IOException, JMException, MBeanException
	{
	ManagedBroker managedBroker = getManagedBroker(virtualHostName);
	managedBroker.unregisterExchange(exchange);
	}

	/**
	* Unregisters the Queue bindings, removes the subscriptions and unregisters
	* from the managed objects.
	*
	* @throws JMException if a queue with this name does not exist
	* @throws IOException if there is a problem with the JMX Connection
	* @throws MBeanException if there is another problem creating the exchange
	*/
	public void deleteQueue(String virtualHostName, String queueName)
	throws IOException, JMException, MBeanException
	{
	ManagedBroker managedBroker = getManagedBroker(virtualHostName);
	managedBroker.deleteQueue(queueName);
	}

	/**
	* Sets the logging level.
	*
	* @throws JMException
	* @throws IOException if there is a problem with the JMX Connection
	* @throws MBeanException
	*/
	public void setRuntimeLoggerLevel(String logger, String level)
	throws IOException, JMException, MBeanException
	{
	LoggingManagement loggingManagement = getLoggingManagement();
	loggingManagement.setRuntimeLoggerLevel(logger, level);
	}

	/**
	* Reload logging config file.
	*
	* @throws JMException
	* @throws IOException if there is a problem with the JMX Connection
	* @throws MBeanException
	*/
	public void reloadConfigFile()
	throws IOException, JMException, MBeanException
	{
	LoggingManagement loggingManagement = getLoggingManagement();
	loggingManagement.reloadConfigFile();
	}

	/**
	* Get list of available logger levels.
	*
	* @throws JMException
	* @throws IOException if there is a problem with the JMX Connection
	* @throws MBeanException
	*/
	public String[] getAvailableLoggerLevels()
	throws IOException, JMException, MBeanException
	{
	LoggingManagement loggingManagement = getLoggingManagement();
	return loggingManagement.getAvailableLoggerLevels();
	}

	/**
	* Set root logger level.
	*
	* @throws JMException
	* @throws IOException if there is a problem with the JMX Connection
	* @throws MBeanException
	*/
	public void setRuntimeRootLoggerLevel(String level)
	throws IOException, JMException, MBeanException
	{
	LoggingManagement loggingManagement = getLoggingManagement();
	loggingManagement.setRuntimeRootLoggerLevel(level);
	}

	/**
	* Get root logger level.
	*
	* @throws JMException
	* @throws IOException if there is a problem with the JMX Connection
	* @throws MBeanException
	*/
	public String getRuntimeRootLoggerLevel()
	throws IOException, JMException, MBeanException
	{
	LoggingManagement loggingManagement = getLoggingManagement();
	return loggingManagement.getRuntimeRootLoggerLevel();
	}

	/**
	* Retrieve the ObjectName for a Virtualhost.
	*
	* This is then used to create a proxy to the ManagedBroker MBean.
	*
	* @param virtualHostName the VirtualHost to retrieve
	* @return the ObjectName for the VirtualHost
	*/
	@SuppressWarnings("static-access")
	public ObjectName getVirtualHostManagerObjectName(String vhostName)
	{
	// Get the name of the test manager
	String query = "org.apache.qpid:type=VirtualHost.VirtualHostManager,VirtualHost="
	+ ObjectName.quote(vhostName) + ",*";

	Set<ObjectName> objectNames = queryObjects(query);

	_test.assertNotNull("Null ObjectName Set returned", objectNames);
	_test.assertEquals("Incorrect number test vhosts returned", 1, objectNames.size());

	// We have verified we have only one value in objectNames so return it
	ObjectName objectName = objectNames.iterator().next();
	_test.getLogger().info("Loading: " + objectName);
	return objectName;
	}

	/**
	* Retrieve the ObjectName for the given Queue on a Virtualhost.
	*
	* This is then used to create a proxy to the ManagedQueue MBean.
	*
	* @param virtualHostName the VirtualHost the Queue is on
	* @param queue The Queue to retireve
	* @return the ObjectName for the given queue on the VirtualHost
	*/
	@SuppressWarnings("static-access")
	public ObjectName getQueueObjectName(String virtualHostName, String queue)
	{
	// Get the name of the test manager
	String query = getQueueObjectNameString(virtualHostName, queue);

	Set<ObjectName> objectNames = queryObjects(query);

	_test.assertNotNull("Null ObjectName Set returned", objectNames);
	_test.assertEquals("Incorrect number of queues with name '" + queue + "' returned", 1, objectNames.size());

	// We have verified we have only one value in objectNames so return it
	ObjectName objectName = objectNames.iterator().next();
	_test.getLogger().info("Loading: " + objectName);
	return objectName;
	}

	public String getQueueObjectNameString(String virtualHostName, String queue) {
	return "org.apache.qpid:type=VirtualHost.Queue,VirtualHost="
	+ ObjectName.quote(virtualHostName) + ",name="
	+ ObjectName.quote(queue) + ",*";
	}

	/**
	* Generate the ObjectName for the given Exchange on a VirtualHost.
	*/
	public String getExchangeObjectName(String virtualHostName, String exchange)
	{
	return "org.apache.qpid:type=VirtualHost.Exchange,VirtualHost="
	+ ObjectName.quote(virtualHostName) + ",name="
	+ ObjectName.quote(exchange) + ",*";
	}

	@SuppressWarnings("static-access")
	public <T> T getManagedObject(Class<T> managedClass, String query)
	{
	Set<ObjectName> objectNames = queryObjects(query);

	_test.assertNotNull("Null ObjectName Set returned", objectNames);
	_test.assertEquals("Unexpected number of objects matching " + managedClass + " returned", 1, objectNames.size());

	ObjectName objectName = objectNames.iterator().next();
	_test.getLogger().info("Loading: " + objectName);
	return getManagedObject(managedClass, objectName);
	}

	public boolean doesManagedObjectExist(String query)
	{
	return !queryObjects(query).isEmpty();
	}

	public int getNumberOfObjects(String query)
	{
	return queryObjects(query).size();
	}

	public <T> T getManagedObject(Class<T> managedClass, ObjectName objectName)
	{
	return MBeanServerInvocationHandler.newProxyInstance(_mbsc, objectName, managedClass, false);
	}

	public <T> List<T> getManagedObjectList(Class<T> managedClass, Set<ObjectName> objectNames)
	{
	List<T> objects = new ArrayList<T>();
	for (ObjectName name : objectNames)
	{
	objects.add(getManagedObject(managedClass, name));
	}
	return objects;
	}

	public ManagedBroker getManagedBroker(String virtualHost)
	{
	return getManagedObject(ManagedBroker.class, getVirtualHostManagerObjectName(virtualHost));
	}

	@SuppressWarnings("static-access")
	public ManagedExchange getManagedExchange(String exchangeName)
	{
	String query = getExchangeObjectName("test", exchangeName);

	Set<ObjectName> objectNames = queryObjects(query);

	_test.assertNotNull("Null ObjectName Set returned", objectNames);
	_test.assertEquals("Incorrect number of exchange with name '" + exchangeName + "' returned", 1, objectNames.size());

	// We have verified we have only one value in objectNames so return an mbean proxy for it
	ObjectName objectName = objectNames.iterator().next();
	_test.getLogger().info("Loading: " + objectName);

	return MBeanServerInvocationHandler.newProxyInstance(_mbsc, objectName, ManagedExchange.class, false);
	}

	public ManagedQueue getManagedQueue(String queueName)
	{
	ObjectName objectName = getQueueObjectName("test", queueName);
	return getManagedObject(ManagedQueue.class, objectName);
	}

	public LoggingManagement getLoggingManagement() throws MalformedObjectNameException
	{
	ObjectName objectName = new ObjectName("org.apache.qpid:type=LoggingManagement,name=LoggingManagement");
	return getManagedObject(LoggingManagement.class, objectName);
	}

	public UserManagement getUserManagement() throws MalformedObjectNameException
	{
	ObjectName objectName = new ObjectName("org.apache.qpid:type=UserManagement,name=UserManagement");
	return getManagedObject(UserManagement.class, objectName);
	}

	/**
	* Retrieve {@link ServerInformation} JMX MBean.
	*/
	public ServerInformation getServerInformation()
	{
	// Get the name of the test manager
	String query = "org.apache.qpid:type=ServerInformation,name=ServerInformation,*";

	Set<ObjectName> objectNames = queryObjects(query);

	TestCase.assertNotNull("Null ObjectName Set returned", objectNames);
	TestCase.assertEquals("Incorrect number of objects returned", 1, objectNames.size());

	// We have verified we have only one value in objectNames so return it
	return getManagedObject(ServerInformation.class, objectNames.iterator().next());
	}

	/**
	* Retrieve all {@link ManagedConnection} objects.
	*/
	public List<ManagedConnection> getAllManagedConnections()
	{
	// Get the name of the test manager
	String query = "org.apache.qpid:type=VirtualHost.Connection,VirtualHost=,name=";

	Set<ObjectName> objectNames = queryObjects(query);

	TestCase.assertNotNull("Null ObjectName Set returned", objectNames);

	return getManagedObjectList(ManagedConnection.class, objectNames);
	}

	/**
	* Retrieve all {@link ManagedConnection} objects for a particular virtual host.
	*/
	public List<ManagedConnection> getManagedConnections(String vhost)
	{
	// Get the name of the test manager
	String query = "org.apache.qpid:type=VirtualHost.Connection,VirtualHost=" + ObjectName.quote(vhost) + ",name=*";

	Set<ObjectName> objectNames = queryObjects(query);

	TestCase.assertNotNull("Null ObjectName Set returned", objectNames);

	return getManagedObjectList(ManagedConnection.class, objectNames);
	}

	/**
	* Returns the Set of ObjectNames returned by the broker for the given query.
	*/
	private Set<ObjectName> queryObjects(String query)
	{
	try
	{
	return _mbsc.queryNames(new ObjectName(query), null);
	}
	catch (Exception e)
	{
	throw new RuntimeException("Error using query: " + query, e);
	}
	}
	}