/*
*
* 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 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;
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 static org.apache.qpid.management.ui.Constants.*;
import javax.management.MBeanServerConnection;
import java.util.LinkedList;
/**
* 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);
}
}