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, 605 insertions, 0 deletions

diff --git a/qpid/java/management/eclipse-plugin/src/main/java/org/apache/qpid/management/ui/views/MBeanView.java b/qpid/java/management/eclipse-plugin/src/main/java/org/apache/qpid/management/ui/views/MBeanView.java
new file mode 100644
index 0000000000..65615a6d18
--- /dev/null
+++ b/qpid/java/management/eclipse-plugin/src/main/java/org/apache/qpid/management/ui/views/MBeanView.java
@@ -0,0 +1,605 @@
+/*
+ *
+ * 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.views;
+
+import java.util.LinkedList;
+
+import javax.management.MBeanServerConnection;
+
+import static org.apache.qpid.management.ui.Constants.*;
+
+import org.apache.qpid.management.ui.ApiVersion;
+import org.apache.qpid.management.ui.ApplicationRegistry;
+import org.apache.qpid.management.ui.ManagedBean;
+import org.apache.qpid.management.ui.ManagedServer;
+import org.apache.qpid.management.ui.ServerRegistry;
+import org.apache.qpid.management.ui.actions.BackAction;
+import org.apache.qpid.management.ui.jmx.JMXManagedObject;
+import org.apache.qpid.management.ui.jmx.JMXServerRegistry;
+import org.apache.qpid.management.ui.jmx.MBeanUtility;
+import org.eclipse.jface.viewers.ISelection;
+import org.eclipse.jface.viewers.IStructuredSelection;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.graphics.Image;
+import org.eclipse.swt.layout.FormAttachment;
+import org.eclipse.swt.layout.FormData;
+import org.eclipse.swt.layout.FormLayout;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.TabFolder;
+import org.eclipse.swt.widgets.TabItem;
+import org.eclipse.ui.IActionBars;
+import org.eclipse.ui.ISelectionListener;
+import org.eclipse.ui.IWorkbenchPart;
+import org.eclipse.ui.forms.widgets.Form;
+import org.eclipse.ui.forms.widgets.FormToolkit;
+import org.eclipse.ui.part.ViewPart;
+
+/**
+ * MBean View create appropriate view based on the user selection on the Navigation View.
+ */
+public class MBeanView extends ViewPart
+{
+    public static final String ID = "org.apache.qpid.management.ui.mbeanView";
+    
+    private FormToolkit  _toolkit = null;
+    private Form _form = null;
+    private String _formText = APPLICATION_NAME;
+    private static ManagedServer _server = null;
+    private TreeObject _selectedNode = null;
+    private ManagedBean _mbean = null;
+    private static String _virtualHostName = null;
+    private static MBeanServerConnection _mbsc = null;
+    private TabFolder _tabFolder = null;
+    private ISelectionListener _selectionListener = new SelectionListenerImpl();
+
+    // TabFolder to list all the mbeans for a given mbeantype(eg Connection, Queue, Exchange)
+    private TabFolder _typeTabFolder = null;
+    
+    private TabFolder _notificationTabFolder = null;
+
+    private LinkedList<Object> _backHistory;
+    private BackAction _backAction;
+    
+    /*
+     * Listener for the selection events in the navigation view
+     */ 
+    private class SelectionListenerImpl implements ISelectionListener
+    {
+        public void selectionChanged(IWorkbenchPart part, ISelection sel)
+        {
+            if (!(sel instanceof IStructuredSelection))
+                return;
+
+            IStructuredSelection ss = (IStructuredSelection) sel;
+            _selectedNode = (TreeObject)ss.getFirstElement();
+            
+            
+            // mbean should be set to null. A selection done on the navigation view can be either an mbean or
+            // an mbeantype. For mbeantype selection(eg Connection, Queue, Exchange) _mbean will remain null.
+            _mbean = null;
+            clearView();
+            
+            //clear the back history, it is only for use when opening subsequent mbeans not in the nav tree
+            _backHistory.clear();
+            _backAction.setEnabled(false);
+            
+            // If a selected node(mbean) gets unregistered from mbean server, mbeanview should 
+            // make the tabfolber for that mbean invisible
+            if (_selectedNode == null)
+            {
+                return;
+            }
+            
+            setServer();
+            
+            if(!ApplicationRegistry.isServerConnected(_server))
+            {
+                return;
+            }
+            
+            if (MBEAN.equals(_selectedNode.getType()))
+            {
+                _mbean = (ManagedBean)_selectedNode.getManagedObject();
+            }
+            
+            setFormTitle();                
+            showRelevantTabView();
+        }
+    }
+    
+    public void openMBean(ManagedBean mbean)
+    {
+        openMBean(mbean, false);
+    }
+    
+    private void openMBean(ManagedBean mbean, boolean undoing)
+    {
+        if(mbean == null)
+        {
+            return;
+        }
+        
+        //if an mbean is about to be opened (but not returning to using back) from the mbean view,
+        //then record the current viewed area/object as a means of back history
+        if(!undoing)
+        {
+            if(_backHistory.isEmpty())
+            {
+                //ensure the button is enabled if this is to be the first history item
+                _backAction.setEnabled(true);
+            }
+            
+            if(_mbean == null)
+            {
+                //queue etc selection area is open, record the tree object
+                _backHistory.addLast(_selectedNode);
+            }
+            else
+            {
+                _backHistory.addLast(_mbean); 
+            }
+        }
+        
+        _mbean = mbean;
+        
+        try
+        {
+            clearView();
+            
+            setFormTitle();
+            showMBean(mbean);
+            
+            _form.layout(true);
+            _form.getBody().layout(true, true);
+        }
+        catch(Exception ex)
+        {
+            MBeanUtility.handleException(mbean, ex);
+        }
+    }
+    
+    private void setFormTitle()
+    {
+        if (_mbean != null)
+        {
+            _formText = _mbean.getType();
+            if ((_mbean.getVirtualHostName() != null) && (!DEFAULT_VH.equals(_mbean.getVirtualHostName())) )
+            {
+                _formText = _formText.replaceFirst(VIRTUAL_HOST, _mbean.getVirtualHostName());
+                if (_mbean.getName() != null && _mbean.getName().length() != 0)
+                {
+                    _formText = _formText + ": " + _mbean.getName();
+                }
+            }
+        }
+        else if ((_selectedNode.getVirtualHost() != null) && (!DEFAULT_VH.equals(_selectedNode.getVirtualHost())))
+        {
+            _formText = _selectedNode.getVirtualHost();
+        }
+        else
+        {
+            _formText = APPLICATION_NAME;
+        }
+        _form.setText(_formText);
+    }
+    
+    public void showRelevantTabView()
+    {
+        try
+        {
+            if (_selectedNode == null)
+            {
+                return;
+            }
+            
+            String mbeanType = _selectedNode.getType();
+            
+            if (NODE_TYPE_TYPEINSTANCE.equals(mbeanType))
+            {
+                // An virtual host instance is selected
+                generateTypeTabFolder();
+            }
+            else if (NODE_TYPE_MBEANTYPE.equals(mbeanType))
+            {
+                showTypeTabFolder(_selectedNode.getName());
+            } 
+            else if (NOTIFICATIONS.equals(mbeanType))
+            {
+                refreshNotificationPage();
+            }
+            else if (MBEAN.equals(mbeanType))
+            {
+                showMBean(_mbean);
+            }
+            else if(NODE_TYPE_SERVER.equals(mbeanType))
+            {
+                ServerRegistry serverReg = ApplicationRegistry.getServerRegistry(_server);
+                
+                //check the server is connected
+                if(serverReg != null)
+                {
+                    //post a message if the server supports a newer API version.
+                    ApiVersion serverAPI = serverReg.getManagementApiVersion();
+                    int supportedMajor = ApplicationRegistry.SUPPORTED_QPID_JMX_API_MAJOR_VERSION;
+                    int supportedMinor = ApplicationRegistry.SUPPORTED_QPID_JMX_API_MINOR_VERSION;
+                    
+                    if(serverAPI.greaterThan(supportedMajor, supportedMinor))
+                    {
+                        _form.setText("The server supports an updated management API and may offer " +
+                        		"functionality not available with this console. " +
+                        		"Please check for an updated console release.");
+                    }
+                    
+                }
+            }
+            else
+            {
+                return;
+            }
+            
+            _form.layout(true);
+            _form.getBody().layout(true, true);
+        }
+        catch(Exception ex)
+        {
+            MBeanUtility.handleException(_mbean, ex);
+        }
+    }
+
+    /**
+     * Sets the managedServer based on the selection in the navigation view
+     * At any given time MBeanView will be displaying information for an mbean of mbeantype
+     * for a specifiv managed server. This server information will be used by the tab controllers
+     * to get server registry.
+     */
+    private void setServer()
+    {
+        if (NODE_TYPE_SERVER.equals(_selectedNode.getType()))
+        {
+            _server = (ManagedServer)_selectedNode.getManagedObject();
+            _virtualHostName = null;
+        }
+        else
+        {
+            TreeObject parent = _selectedNode.getParent();
+            while (parent != null && !parent.getType().equals(NODE_TYPE_SERVER))
+            {
+                parent = parent.getParent();
+            }
+            
+            if (parent != null && parent.getType().equals(NODE_TYPE_SERVER))
+                _server = (ManagedServer)parent.getManagedObject();
+            
+            _virtualHostName = _selectedNode.getVirtualHost();
+        }
+        
+        JMXServerRegistry serverRegistry = (JMXServerRegistry)ApplicationRegistry.getServerRegistry(_server);
+        if(serverRegistry != null){
+            _mbsc = serverRegistry.getServerConnection();
+        }
+    }
+    
+    public static ManagedServer getServer()
+    {
+        return _server;
+    }
+    
+    public static String getVirtualHost()
+    {
+        return _virtualHostName;
+    }
+    
+    private void showMBean(ManagedBean mbean) throws Exception
+    {           
+        try
+        {                
+            MBeanUtility.getMBeanInfo(mbean);     
+        }
+        catch(Exception ex)
+        {
+            MBeanUtility.handleException(mbean, ex);
+            return;
+        }
+
+        if (_tabFolder != null && !_tabFolder.isDisposed())
+        {
+            _tabFolder.dispose();
+        }
+        
+        _tabFolder = MBeanTabFolderFactory.generateMBeanTabFolder(_form.getBody(),(JMXManagedObject)mbean,_mbsc);
+        
+        int tabIndex = 0;
+        if (NOTIFICATIONS.equals(_selectedNode.getType()))
+        {
+            tabIndex = _tabFolder.getItemCount() -1;
+        }
+       
+        TabItem tab = _tabFolder.getItem(tabIndex);
+        // If folder is being set as visible after tab refresh, then the tab 
+        // doesn't have the focus.                  
+        _tabFolder.setSelection(tabIndex);
+        refreshTab(tab);
+    }
+    
+    public void createPartControl(Composite parent)
+    {
+        // Create the Form
+        _toolkit = new FormToolkit(parent.getDisplay());
+        _form = _toolkit.createForm(parent);
+        _form.getBody().setLayout(new FormLayout());
+        _form.setText(APPLICATION_NAME);
+        
+        // Add selection listener for selection events in the Navigation view
+        getSite().getPage().addSelectionListener(NavigationView.ID, _selectionListener); 
+
+        createNotificationsTabFolder();
+        
+        ViewUtility.setMBeanView(this);
+        
+        _backAction = new BackAction();
+        getViewSite().getActionBars().getToolBarManager().add(_backAction);
+        _backAction.setEnabled(false);
+        _backHistory = new LinkedList<Object>();
+    }
+    
+    private void refreshTab(TabItem tab)
+    {
+        if (tab == null)
+        {
+            return;
+        }
+        
+        TabControl controller = (TabControl)tab.getData(TabControl.CONTROLLER);
+        if(controller != null)
+        {
+            controller.refresh(_mbean);
+        }
+    }
+    
+    public void setFocus()
+    {   
+        //_form.setFocus();
+    }
+
+    public void dispose()
+    {
+        _toolkit.dispose();
+        super.dispose();
+    }
+    
+    
+    private void createNotificationsTabFolder()
+    {
+        _notificationTabFolder = new TabFolder(_form.getBody(), SWT.NONE);
+        FormData layoutData = new FormData();
+        layoutData.left = new FormAttachment(0);
+        layoutData.top = new FormAttachment(0);
+        layoutData.right = new FormAttachment(100);
+        layoutData.bottom = new FormAttachment(100);
+        _notificationTabFolder.setLayoutData(layoutData);
+        _notificationTabFolder.setVisible(false);
+        
+        VHNotificationsTabControl controller = new VHNotificationsTabControl(_notificationTabFolder);       
+        TabItem tab = new TabItem(_notificationTabFolder, SWT.NONE);
+        tab.setText(NOTIFICATIONS);
+        tab.setData(TabControl.CONTROLLER, controller);
+        tab.setControl(controller.getControl());
+    }
+    
+    private void refreshNotificationPage()
+    {        
+        TabItem tab = _notificationTabFolder.getItem(0);
+        VHNotificationsTabControl controller = (VHNotificationsTabControl)tab.getData(TabControl.CONTROLLER);
+        controller.refresh();
+        _notificationTabFolder.setVisible(true);
+    }
+    
+
+
+    private void generateTypeTabFolder() throws Exception
+    {
+        if (_typeTabFolder != null && !_typeTabFolder.isDisposed())
+        {
+            _typeTabFolder.dispose();
+        }
+        
+        //Generates the full Queue/Connection/Exchange selection tab set
+        _typeTabFolder = MBeanTabFolderFactory.generateMBeanTypeTabFolder(
+                                            _form.getBody(), getServer(), getVirtualHost());
+        refreshTab(_typeTabFolder.getItem(0));
+    }
+    
+    private void showTypeTabFolder(String type) throws Exception
+    {
+        if (_typeTabFolder != null && !_typeTabFolder.isDisposed())
+        {
+            _typeTabFolder.dispose();
+        }
+        
+        if (CONNECTION.equals(type))
+        {
+            //Generates the Connection selection tab
+            _typeTabFolder = MBeanTabFolderFactory.generateConnectionTypeTabFolder(
+                    _form.getBody(), getServer(), getVirtualHost());
+            refreshTab(_typeTabFolder.getItem(0));
+        }
+        else if (EXCHANGE.equals(type))
+        {
+            //Generates the Exchange selection tab
+            _typeTabFolder = MBeanTabFolderFactory.generateExchangeTypeTabFolder(
+                    _form.getBody(), getServer(), getVirtualHost());
+            refreshTab(_typeTabFolder.getItem(0));
+        }
+        else if (QUEUE.equals(type))
+        {
+            //Generates the Queue selection tab
+            _typeTabFolder = MBeanTabFolderFactory.generateQueueTypeTabFolder(
+                    _form.getBody(), getServer(), getVirtualHost());
+            refreshTab(_typeTabFolder.getItem(0));
+        }
+    }
+
+    private void clearView()
+    {
+        if (_tabFolder != null && !_tabFolder.isDisposed())
+        {
+            _tabFolder.setVisible(false);
+        }
+        
+        if (_typeTabFolder != null && !_typeTabFolder.isDisposed())
+        {
+            _typeTabFolder.setVisible(false);
+        }
+        
+        if (_notificationTabFolder != null && !_notificationTabFolder.isDisposed())
+        {
+            _notificationTabFolder.setVisible(false);
+        }
+        
+        _form.setText(APPLICATION_NAME);
+        clearStatusBar();
+    }
+    
+    public void mbeanUnregistered(ManagedBean mbean)
+    {
+        //if the mbean is actually open, clear the view and empty the Back history
+        if(mbean == _mbean)
+        {
+            clearView();
+            _backHistory.clear();
+            _backAction.setEnabled(false);
+            ViewUtility.popupInfoMessage("MBean Unregistered", 
+                    "The open MBean was unregistered from the server.");
+        }
+    }
+    
+    public void refresh()
+    {
+        if(!ApplicationRegistry.isServerConnected(_server))
+        {
+            return;
+        }
+        
+        if (_tabFolder != null && !_tabFolder.isDisposed())
+        {
+            if(_tabFolder.getVisible())
+            {
+                int selectedTab = _tabFolder.getSelectionIndex();
+                TabItem tab = _tabFolder.getItem(selectedTab);
+                TabControl controller = (TabControl) tab.getData(TabControl.CONTROLLER);
+                if(controller != null)
+                {
+                    controller.refresh(_mbean);
+                }
+                return;
+            }
+        }
+        
+        if (_typeTabFolder != null && !_typeTabFolder.isDisposed())
+        {
+            
+            if(_typeTabFolder.getVisible())
+            {
+                int selectedTab = _typeTabFolder.getSelectionIndex();
+                TabItem tab = _typeTabFolder.getItem(selectedTab);
+                TabControl controller = (TabControl) tab.getData(TabControl.CONTROLLER);
+                if(controller != null)
+                {
+                    controller.refresh(_mbean);
+                }
+                return;
+            }
+        }
+        
+        if (_notificationTabFolder != null && !_notificationTabFolder.isDisposed())
+        {
+            if(_notificationTabFolder.getVisible())
+            {
+                int selectedTab = _notificationTabFolder.getSelectionIndex();
+                TabItem tab = _notificationTabFolder.getItem(selectedTab);
+                TabControl controller = (TabControl) tab.getData(TabControl.CONTROLLER);
+                if(controller != null)
+                {
+                    controller.refresh(_mbean);
+                }
+                return;
+            }
+        }
+    }
+    
+    public void populateStatusBar(Image icon, String message)
+    {
+        IActionBars bars = getViewSite().getActionBars();
+        bars.getStatusLineManager().setMessage(icon, message);
+    }
+    
+    public void populateStatusBar(String message)
+    {
+        IActionBars bars = getViewSite().getActionBars();
+        bars.getStatusLineManager().setMessage(message);
+    }
+    
+    public void clearStatusBar()
+    {
+        populateStatusBar("");
+    }
+
+    public void back() throws Exception
+    {
+        if(_backHistory.isEmpty())
+        {
+            return;
+        }
+        
+        Object previous = _backHistory.removeLast();
+        if(_backHistory.isEmpty())
+        {
+            //if this is the last history item, disable the action button
+            _backAction.setEnabled(false);
+        }
+        
+        if(previous instanceof ManagedBean)
+        {
+            openMBean((ManagedBean)previous, true);
+        }
+        else if (previous instanceof TreeObject)
+        {
+            _mbean = null;
+            clearView();
+            setFormTitle();
+            
+            TreeObject node = (TreeObject) previous;
+            String mbeanType = node.getType();
+            
+            if (NODE_TYPE_TYPEINSTANCE.equals(mbeanType))
+            {
+                generateTypeTabFolder();
+            }
+            else if (NODE_TYPE_MBEANTYPE.equals(mbeanType))
+            {
+                showTypeTabFolder(node.getName());
+            }
+        }
+        
+        _form.layout(true);
+        _form.getBody().layout(true, true);
+    }
+}