Creating a branch for experimenting with some ideas for JMS client.rajith_jms_client

git-svn-id: https://svn.apache.org/repos/asf/qpid/branches/rajith_jms_client@1128369 13f79535-47bb-0310-9956-ffa450edef68

1 files changed, 619 insertions, 0 deletions

diff --git a/qpid/java/management/eclipse-plugin/src/main/java/org/apache/qpid/management/ui/jmx/MBeanUtility.java b/qpid/java/management/eclipse-plugin/src/main/java/org/apache/qpid/management/ui/jmx/MBeanUtility.java
new file mode 100644
index 0000000000..6d6aa80f4d
--- /dev/null
+++ b/qpid/java/management/eclipse-plugin/src/main/java/org/apache/qpid/management/ui/jmx/MBeanUtility.java
@@ -0,0 +1,619 @@
+/*
+ *
+ * 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.management.ui.jmx;
+
+import java.io.IOException;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+
+import javax.management.Attribute;
+import javax.management.AttributeList;
+import javax.management.InstanceNotFoundException;
+import javax.management.JMException;
+import javax.management.MBeanAttributeInfo;
+import javax.management.MBeanException;
+import javax.management.MBeanInfo;
+import javax.management.MBeanNotificationInfo;
+import javax.management.MBeanOperationInfo;
+import javax.management.MBeanServerConnection;
+import javax.management.MBeanServerInvocationHandler;
+import javax.management.MalformedObjectNameException;
+import javax.management.ObjectInstance;
+import javax.management.ObjectName;
+import javax.management.ReflectionException;
+
+import org.apache.qpid.management.common.mbeans.ServerInformation;
+import org.apache.qpid.management.ui.ApiVersion;
+import org.apache.qpid.management.ui.ApplicationRegistry;
+import org.apache.qpid.management.ui.Constants;
+import org.apache.qpid.management.ui.ManagedBean;
+import org.apache.qpid.management.ui.ManagedServer;
+import org.apache.qpid.management.ui.exceptions.ManagementConsoleException;
+import org.apache.qpid.management.ui.model.AttributeData;
+import org.apache.qpid.management.ui.model.ManagedAttributeModel;
+import org.apache.qpid.management.ui.model.NotificationInfoModel;
+import org.apache.qpid.management.ui.model.OperationData;
+import org.apache.qpid.management.ui.model.OperationDataModel;
+import org.apache.qpid.management.ui.model.ParameterData;
+import org.apache.qpid.management.ui.views.ViewUtility;
+
+/**
+ * Utility class for all mbeanserver related operations. Keeps all JMX code out from view and model classes
+ * @author Bhupendra Bhardwaj
+ */
+public class MBeanUtility
+{
+    public static final BigInteger MAX_LONG = BigInteger.valueOf(Long.MAX_VALUE);
+    public static final BigInteger MAX_INT = BigInteger.valueOf(Integer.MAX_VALUE);
+    /**
+     * Retrieves the MBeanInfo from MBeanServer and stores in the application registry
+     * @param mbean  managed bean
+     * @return MBeanInfo
+     * @throws Exception, if server connection is null or if server throws Exception
+     */
+    public static MBeanInfo getMBeanInfo(ManagedBean mbean) throws Exception
+    {
+        ManagedServer server = mbean.getServer();
+        JMXServerRegistry serverRegistry = (JMXServerRegistry)ApplicationRegistry.getServerRegistry(server);
+
+        MBeanServerConnection mbsc = serverRegistry.getServerConnection();
+        if (mbsc == null)
+        {
+            throw new ManagementConsoleException("Server connection is broken");
+        }
+        
+        JMXManagedObject jmxbean = (JMXManagedObject)mbean;
+        MBeanInfo mbeanInfo = mbsc.getMBeanInfo(jmxbean.getObjectName());
+        serverRegistry.putMBeanInfo(mbean, mbeanInfo);
+        
+        // populate the server registry with attribute and operation info
+        getAttributes(mbean);
+        getOperations(mbean);
+        
+        return mbeanInfo;
+    }
+    
+    /**
+     * executes the MBean operation
+     * @param mbean
+     * @param opData
+     * @return MBean operation return value
+     * @throws Exception if server connection is broken or if operation execution fails on the mbean server
+     */
+    public static Object execute(ManagedBean mbean, OperationData opData) throws Exception
+    {
+        String opName = opData.getName();
+        Object[] values = null;
+        String[] signature = null;
+        
+        List<ParameterData> params = opData.getParameters();
+        if (params != null && !params.isEmpty())
+        {
+            signature = new String[params.size()];;
+            values = new Object[params.size()];
+            for (int i = 0; i < params.size(); i++)
+            {
+                signature[i] = params.get(i).getType();
+                values[i] = params.get(i).getValue();
+            }
+        }
+        
+        ManagedServer server = mbean.getServer();
+        JMXServerRegistry serverRegistry = (JMXServerRegistry)ApplicationRegistry.getServerRegistry(server);
+
+        MBeanServerConnection mbsc = serverRegistry.getServerConnection();
+        if (mbsc == null)
+        {
+            throw new ManagementConsoleException("Server connection is broken");
+            // TODO
+            // try and get the connection again if it was disconnected
+        }
+        JMXManagedObject jmxbean = (JMXManagedObject)mbean;
+        return mbsc.invoke(jmxbean.getObjectName(), opName, values, signature);
+    }
+    
+    /**
+     * @see MBeanUtility#handleException(ManagedBean, Exception)
+     */
+    public static void handleException(Exception ex)
+    {
+        handleException(null, ex);
+    }
+    
+    /**
+     * handels the exception received. Shows the exception to the user in best suitable way
+     * @param mbean managed bean
+     * @param ex   Exception
+     */
+    public static void handleException(ManagedBean mbean, Throwable ex)
+    {
+        if (mbean == null)
+        {
+            ViewUtility.popupErrorMessage("Error", "Managed Object is null \n" + ex.toString());
+            printStackTrace(ex);
+        }
+        else if (ex instanceof ReflectionException)
+        {
+            ViewUtility.popupErrorMessage(mbean.getInstanceName(), "Server has thrown error \n" + ex.toString());
+            printStackTrace(ex);
+        }
+        else if (ex instanceof InstanceNotFoundException)
+        {
+            ViewUtility.popupErrorMessage(mbean.getInstanceName(), "Managed Object Not Found \n" + ex.toString());
+            printStackTrace(ex);
+        }
+        else if (ex instanceof MBeanException)
+        {
+            String cause = ((MBeanException)ex).getTargetException().getMessage();
+            if (cause == null)
+                cause = ex.toString();
+            ViewUtility.popupInfoMessage(mbean.getInstanceName(), cause);
+        }
+        else if (ex instanceof JMException)
+        {
+            ViewUtility.popupErrorMessage(mbean.getInstanceName(), "Management Exception occured \n" + ex.toString());
+        }
+        else if (ex instanceof ManagementConsoleException)
+        {
+            ViewUtility.popupErrorMessage(mbean.getInstanceName(), ex.getMessage());
+        }
+        else if (ex instanceof SecurityException)
+        {
+            ViewUtility.popupErrorMessage(mbean.getInstanceName(), ex.getMessage());
+        }
+        else 
+        {
+            if (ex.getCause() != null)
+            {
+                handleException(mbean, ex.getCause());
+            }
+            else
+            {
+                String msg = ex.getMessage();
+                if (msg == null)
+                {
+                    msg = ex.toString();
+                }
+                ViewUtility.popupErrorMessage(mbean.getInstanceName(), msg);
+                printStackTrace(ex);
+            }
+        }
+        
+    }
+    
+    /**
+     * Registers the notification listener with the MBeanServer
+     * @param mbean   managed bean
+     * @param name    notification name
+     * @param type    notification type
+     * @throws Exception  if server connection is broken or if listener could not be created 
+     */
+    public static void createNotificationlistener(ManagedBean mbean, String name, String type)
+        throws Exception
+    {
+        JMXManagedObject jmxbean = (JMXManagedObject)mbean;
+        JMXServerRegistry serverRegistry = (JMXServerRegistry)ApplicationRegistry.getServerRegistry(mbean);
+        serverRegistry.addNotificationListener(mbean, name, type);
+        MBeanServerConnection mbsc = serverRegistry.getServerConnection();
+        
+        if (mbsc == null)
+        {
+            throw new ManagementConsoleException("Server connection is broken");
+        }
+        mbsc.addNotificationListener(jmxbean.getObjectName(), serverRegistry.getNotificationListener(), null, null);
+    }
+    
+    public static void removeNotificationListener(ManagedBean mbean, String name, String type) throws Exception
+    {
+        JMXServerRegistry serverRegistry = (JMXServerRegistry)ApplicationRegistry.getServerRegistry(mbean);
+        serverRegistry.removeNotificationListener(mbean, name, type);
+    }
+    
+    /**
+     * Checks if the server registry contains attribute information for this mbean. If not then it queries the
+     * mbean server for complete mbean information, else it gets the latest value of the given attribute
+     * from mbean server.
+     * @return attribute data for the given mbean attribute
+     */
+    public static AttributeData getAttributeData(ManagedBean mbean, String attribute) throws Exception
+    {
+        JMXServerRegistry serverRegistry = (JMXServerRegistry)ApplicationRegistry.getServerRegistry(mbean);
+        ManagedAttributeModel attributeModel = serverRegistry.getAttributeModel(mbean);
+        if (attributeModel == null)
+        {
+            // If process is here, it means the mbeanInfo is not retrieved from mbean server even once for this mbean
+            getMBeanInfo(mbean);
+        }
+        else
+        {
+            // refresh attribute value from mbean server
+            refreshAttribute(mbean, attribute);
+        }
+        attributeModel = serverRegistry.getAttributeModel(mbean);
+        return attributeModel.getAttribute(attribute);
+    }
+    
+    /**
+     * Retrieves the latest attribute value from mbean server for the given mbean attribute
+     * and also sets that value in the attribute model in the server registry
+     * @return latest attribute value for the given mbean attribute
+     */
+    public static Object refreshAttribute(ManagedBean mbean, String attribute) throws Exception
+    {
+        JMXServerRegistry serverRegistry = (JMXServerRegistry)ApplicationRegistry.getServerRegistry(mbean);
+        MBeanServerConnection mbsc = serverRegistry.getServerConnection();
+        
+        if (mbsc == null)
+        {
+            throw new ManagementConsoleException("Server connection is broken");
+        }
+        
+        Object value = mbsc.getAttribute(((JMXManagedObject)mbean).getObjectName(), attribute);
+        // update the attribute data in server registry for this attribute
+        ManagedAttributeModel attributeModel = serverRegistry.getAttributeModel(mbean);
+        attributeModel.setAttributeValue(attribute, value);
+        return value;
+    }
+    
+
+    /**
+     * Returns a List of Object arrays containing the requested attribute values (in the same sequence requested) for each queue in the virtualhost.
+     * If a particular attribute cant be found or raises an mbean/reflection exception whilst being gathered its value is substituted with the String "-".
+     */
+    public static List<List<Object>> getQueueAttributes(List<ManagedBean> mbeans, String[] attributes)
+    {
+        List<List<Object>> results = new ArrayList<List<Object>>();
+        
+        MBeanServerConnection mbsc = null;
+        if(mbeans.isEmpty())
+        {
+            return results;
+        }
+        else
+        {
+            ManagedBean mbean = mbeans.get(0);
+            JMXServerRegistry serverRegistry = (JMXServerRegistry)ApplicationRegistry.getServerRegistry(mbean);
+            mbsc = serverRegistry.getServerConnection();
+        }
+        
+        if(mbsc == null)
+        {
+            return results;
+        }
+        
+        for(ManagedBean mbean : mbeans)
+        {
+            HashMap<String,Object> tempResults = new HashMap<String,Object>();
+            
+            ObjectName objName = ((JMXManagedObject)mbean).getObjectName();
+            try
+            {
+                AttributeList list = mbsc.getAttributes(objName, attributes);
+                
+                for (Attribute attr : list.toArray(new Attribute[0]))
+                {
+                    tempResults.put(attr.getName(), attr.getValue());
+                }
+                
+                List<Object> attributeValues = new ArrayList<Object>(attributes.length);
+                
+                for(int i = 0; i <attributes.length; i++)
+                {
+                    if(tempResults.containsKey(attributes[i]))
+                    {
+                        attributeValues.add(tempResults.get(attributes[i]));
+                    }
+                    else
+                    {
+                        attributeValues.add("-");
+                    }
+                }
+                
+                results.add(attributeValues);
+            }
+            catch (Exception ignore)
+            {
+                continue;
+            }
+        }
+        
+        return results;
+    }
+    
+    
+    /**
+     * Retrieves the attribute values from MBeanSever and stores in the server registry.
+     * @param mbean
+     * @return the attribute model
+     * @throws Exception if attributes can not be retrieved from MBeanServer
+     */
+    public static ManagedAttributeModel getAttributes(ManagedBean mbean) throws Exception
+    {
+        ObjectName objName = ((JMXManagedObject)mbean).getObjectName();
+        String[] attributes = null;
+        AttributeList list = null;
+        
+        JMXServerRegistry serverRegistry = (JMXServerRegistry)ApplicationRegistry.getServerRegistry(mbean);
+        MBeanServerConnection mbsc = serverRegistry.getServerConnection();
+        MBeanAttributeInfo[] attributesInfo = null;
+        ManagedAttributeModel attributeModel = serverRegistry.getAttributeModel(mbean);
+        
+        if (attributeModel == null)
+        {
+            // If the process is here, then it means the attribute values are not retrieved from mbean server
+            // even once for this mbean. Create attribute model, retrieve values from mbean server and 
+            // set the attribute model in server registry for this mbean
+            attributeModel = new ManagedAttributeModel();
+            attributesInfo = serverRegistry.getMBeanInfo(mbean).getAttributes();
+            attributes = new String[attributesInfo.length];
+            for (int i = 0; i< attributesInfo.length ; i++)
+            {
+                attributes[i] = attributesInfo[i].getName();
+                attributeModel.setAttributeDescription(attributes[i], attributesInfo[i].getDescription());
+                attributeModel.setAttributeWritable(attributes[i], attributesInfo[i].isWritable());
+                attributeModel.setAttributeReadable(attributes[i], attributesInfo[i].isReadable());
+            }
+        }  
+        else
+        {
+            attributes = attributeModel.getAttributeNames().toArray(new String[0]);
+        }
+        
+        if (attributes.length != 0)
+        {
+            list = mbsc.getAttributes(objName, attributes);
+            for (Iterator itr = list.iterator(); itr.hasNext();)
+            {
+                Attribute attrib = (Attribute)itr.next();
+                attributeModel.setAttributeValue(attrib.getName(), attrib.getValue());
+            }
+        }               
+        
+        serverRegistry.setAttributeModel(mbean, attributeModel);       
+        return attributeModel;
+    }
+    
+    /**
+     * Updates the attribute value of an MBean
+     * @param mbean
+     * @param attribute
+     * @param value
+     * @throws Exception if MBeanServer throws exception in updating the attribute value
+     */
+    public static void updateAttribute(ManagedBean mbean, AttributeData attribute, String value) throws Exception
+    {
+        JMXManagedObject jmxbean = (JMXManagedObject)mbean;
+        JMXServerRegistry serverRegistry = (JMXServerRegistry)ApplicationRegistry.getServerRegistry(mbean);
+
+        MBeanServerConnection mbsc = serverRegistry.getServerConnection();
+        
+        Object newValue = value;
+        if (attribute.getDataType().equals(Long.class.getName()))
+        {
+            if (MAX_LONG.compareTo(new BigInteger(value)) == -1)
+            {
+                throw new ManagementConsoleException("Entered value is too big for \"" +
+                                                     ViewUtility.getDisplayText(attribute.getName()) + "\"");
+            }
+            newValue = Long.parseLong(value);
+        }
+        else if (attribute.getDataType().equals(Integer.class.getName()))
+        {
+            if (MAX_INT.compareTo(new BigInteger(value)) == -1)
+            {
+                throw new ManagementConsoleException("Entered value is too big for " + attribute.getName());
+            }
+            newValue = Integer.parseInt(value);
+        }
+        else if (attribute.getDataType().equals(Boolean.class.getName()))
+        {
+            if (!value.equalsIgnoreCase("true") && !value.equalsIgnoreCase("false"))
+            {
+                throw new ManagementConsoleException("Entered value was not true or false");
+            }
+
+            newValue = Boolean.valueOf(value); 
+        }
+        
+        mbsc.setAttribute(jmxbean.getObjectName(), new Attribute(attribute.getName(), newValue));           
+        // Update the value in the registry, to avoid refreshing from mbsc
+        ManagedAttributeModel attributeModel = serverRegistry.getAttributeModel(mbean);
+        attributeModel.setAttributeValue(attribute.getName(), newValue);
+    }
+    
+    /**
+     * populates the operation data model in server registry for given mbean
+     * @param mbean
+     * @return operation data model
+     */
+    public static OperationDataModel getOperations(ManagedBean mbean)
+    {
+        JMXServerRegistry serverRegistry = (JMXServerRegistry)ApplicationRegistry.getServerRegistry(mbean);
+        OperationDataModel dataModel = serverRegistry.getOperationModel(mbean);
+        if (dataModel == null)
+        {
+            // Create operation model and set it in server registry for this mbean
+            MBeanOperationInfo[] operationsInfo = serverRegistry.getMBeanInfo(mbean).getOperations();
+            dataModel = new OperationDataModel();
+            
+            for (int i = 0; i < operationsInfo.length; i++)
+            {
+                dataModel.addOperation(operationsInfo[i]);
+            }
+            
+            serverRegistry.setOperationModel(mbean, dataModel);
+        }
+        return dataModel;
+    }
+    
+    /**
+     * populates the notification in the server registry for given mbean
+     * @param mbean
+     * @return notification info model
+     */
+    public static NotificationInfoModel[] getNotificationInfo(ManagedBean mbean)
+    {
+        JMXServerRegistry serverRegistry = (JMXServerRegistry)ApplicationRegistry.getServerRegistry(mbean);
+        MBeanNotificationInfo[] info = serverRegistry.getMBeanInfo(mbean).getNotifications();
+        
+        // Check if this mbean sends any notification
+        if (info == null || info.length == 0)
+            return null;
+        
+        // Create notification model if not already set in the server registry for this mbean
+        List<NotificationInfoModel> list = serverRegistry.getNotificationInfo(mbean);
+        if (list != null) 
+            return list.toArray(new NotificationInfoModel[0]);
+        else
+            list = new ArrayList<NotificationInfoModel>();
+        
+        for (int i = 0; i < info.length; i++)
+        {
+            list.add(new NotificationInfoModel(info[i].getName(), info[i].getDescription(), info[i].getNotifTypes()));
+        }
+        
+        // Set the notification model in the server registry for this mbean
+        serverRegistry.setNotificationInfo(mbean, list);
+        return list.toArray(new NotificationInfoModel[0]);
+    }
+    
+    /**
+     * Retrieves all the MBeans from mbean server for a given domain
+     * @return list of ManagedBeans
+     */
+    public static List<ManagedBean> getManagedObjectsForDomain(ManagedServer server, String domain) throws MalformedObjectNameException, NullPointerException, IOException
+    {
+        JMXServerRegistry serverRegistry = (JMXServerRegistry)ApplicationRegistry.getServerRegistry(server);
+        return getManagedObjectsForDomain(server,serverRegistry, domain);
+    }
+
+    /**
+     * Retrieves all the MBeans from mbean server for a given domain
+     * @return list of ManagedBeans
+     */
+    public static List<ManagedBean> getManagedObjectsForDomain(ManagedServer server, JMXServerRegistry serverRegistry, String domain) throws MalformedObjectNameException, NullPointerException, IOException
+    {
+        List<ManagedBean> mbeans = new ArrayList<ManagedBean>();
+
+        MBeanServerConnection mbsc = serverRegistry.getServerConnection();
+        ObjectName objName = new ObjectName(domain + ":*"); 
+        Set objectInstances = mbsc.queryMBeans(objName, null);
+
+        for (Iterator itr = objectInstances.iterator(); itr.hasNext();)
+        {
+            ObjectInstance instance = (ObjectInstance)itr.next();
+            ManagedBean obj = new JMXManagedObject(instance.getObjectName());
+            mbeans.add(obj);
+        }
+        
+        return mbeans;
+    }
+    
+    /**
+     * Classifies the management API version of the given server
+     * @return list of ManagedBeans
+     * @throws NullPointerException 
+     * @throws ManagementConsoleException
+     * @throws MalformedObjectNameException 
+     * @throws IOException 
+     */
+    public static void classifyManagementApiVersion(ManagedServer server, JMXServerRegistry serverRegistry) 
+         throws MalformedObjectNameException, NullPointerException, IOException
+    {
+        MBeanServerConnection mbsc = serverRegistry.getServerConnection();
+        
+        //Detect if the ServerInformation MBean is present, and use it to retrieve the API version.
+        ObjectName objName = new ObjectName(server.getDomain() + ":type="+ ServerInformation.TYPE + ",*");
+        Set<ObjectName> objectInstances = mbsc.queryNames(objName, null);
+        
+        if(objectInstances.size() != 0)
+        {
+            for (Iterator<ObjectName> itr = objectInstances.iterator(); itr.hasNext();)
+            {
+                ObjectName instance = (ObjectName)itr.next();
+                ServerInformation simb = (ServerInformation)
+                                         MBeanServerInvocationHandler.newProxyInstance(mbsc, 
+                                                     instance, ServerInformation.class, false);
+
+                    int major = simb.getManagementApiMajorVersion();
+                    int minor = simb.getManagementApiMinorVersion();
+                    
+                    serverRegistry.setManagementApiVersion(new ApiVersion(major, minor));
+            }
+            
+            return;
+        }
+        
+        //ServerInformation mbean was not present, so this is a older pre-v1.3 API server.
+        
+        //Detect the value of the 'version' key property on the UserManagement MBean ObjectName.
+        //If present, we have a v1.2 API server. If null, we have a v1.1 API server.
+        ObjectName umMBeanObjectName = null;
+        List<ManagedBean> mbeans = getManagedObjectsForDomain(server, serverRegistry, Constants.DEFAULT_DOMAIN);
+        for(ManagedBean mbean: mbeans)
+        {
+            if("UserManagement".equalsIgnoreCase(mbean.getType()))
+            {
+                umMBeanObjectName = ((JMXManagedObject) mbean).getObjectName();
+                break;
+            }
+        }
+        
+        if(umMBeanObjectName != null)
+        {
+            //UserManagement MBean was present, determine if it has a version key
+            if(umMBeanObjectName.getKeyProperty("version") != null)
+            {
+                serverRegistry.setManagementApiVersion(new ApiVersion(1, 2));
+            }
+            else
+            {
+                //no version key, 
+                serverRegistry.setManagementApiVersion(new ApiVersion(1, 1));
+            }
+            
+            return;
+        }
+
+        //UserManagement MBean was not present, connected to an old server: classify as v1.0 API
+        serverRegistry.setManagementApiVersion(new ApiVersion(1, 0));
+    }
+    
+    public static void printOutput(String statement)
+    {
+        if (ApplicationRegistry.debug)
+        {
+            System.out.println(statement);
+        }
+    }
+    
+    public static void printStackTrace(Throwable ex)
+    {
+        if (ApplicationRegistry.debug)
+        {
+            ex.printStackTrace();
+        }
+    }
+}