| /* |
| * Copyright (c) 2004, 2008, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| package sun.tools.jconsole.inspector; |
| |
| import java.io.IOException; |
| import java.util.*; |
| import javax.management.*; |
| import javax.swing.*; |
| import javax.swing.tree.*; |
| import sun.tools.jconsole.JConsole; |
| import sun.tools.jconsole.MBeansTab; |
| import sun.tools.jconsole.Messages; |
| import sun.tools.jconsole.inspector.XNodeInfo; |
| import static sun.tools.jconsole.inspector.XNodeInfo.Type; |
| |
| @SuppressWarnings("serial") |
| public class XTree extends JTree { |
| |
| private static final List<String> orderedKeyPropertyList = |
| new ArrayList<String>(); |
| |
| static { |
| String keyPropertyList = |
| System.getProperty("com.sun.tools.jconsole.mbeans.keyPropertyList"); |
| if (keyPropertyList == null) { |
| orderedKeyPropertyList.add("type"); |
| orderedKeyPropertyList.add("j2eeType"); |
| } else { |
| StringTokenizer st = new StringTokenizer(keyPropertyList, ","); |
| while (st.hasMoreTokens()) { |
| orderedKeyPropertyList.add(st.nextToken()); |
| } |
| } |
| } |
| private MBeansTab mbeansTab; |
| private Map<String, DefaultMutableTreeNode> nodes = |
| new HashMap<String, DefaultMutableTreeNode>(); |
| |
| public XTree(MBeansTab mbeansTab) { |
| this(new DefaultMutableTreeNode("MBeanTreeRootNode"), mbeansTab); |
| } |
| |
| public XTree(TreeNode root, MBeansTab mbeansTab) { |
| super(root, true); |
| this.mbeansTab = mbeansTab; |
| setRootVisible(false); |
| setShowsRootHandles(true); |
| ToolTipManager.sharedInstance().registerComponent(this); |
| } |
| |
| /** |
| * This method removes the node from its parent |
| */ |
| // Call on EDT |
| private synchronized void removeChildNode(DefaultMutableTreeNode child) { |
| DefaultTreeModel model = (DefaultTreeModel) getModel(); |
| model.removeNodeFromParent(child); |
| } |
| |
| /** |
| * This method adds the child to the specified parent node |
| * at specific index. |
| */ |
| // Call on EDT |
| private synchronized void addChildNode( |
| DefaultMutableTreeNode parent, |
| DefaultMutableTreeNode child, |
| int index) { |
| DefaultTreeModel model = (DefaultTreeModel) getModel(); |
| model.insertNodeInto(child, parent, index); |
| } |
| |
| /** |
| * This method adds the child to the specified parent node. |
| * The index where the child is to be added depends on the |
| * child node being Comparable or not. If the child node is |
| * not Comparable then it is added at the end, i.e. right |
| * after the current parent's children. |
| */ |
| // Call on EDT |
| private synchronized void addChildNode( |
| DefaultMutableTreeNode parent, DefaultMutableTreeNode child) { |
| int childCount = parent.getChildCount(); |
| if (childCount == 0) { |
| addChildNode(parent, child, 0); |
| return; |
| } |
| if (child instanceof ComparableDefaultMutableTreeNode) { |
| ComparableDefaultMutableTreeNode comparableChild = |
| (ComparableDefaultMutableTreeNode) child; |
| for (int i = childCount - 1; i >= 0; i--) { |
| DefaultMutableTreeNode brother = |
| (DefaultMutableTreeNode) parent.getChildAt(i); |
| // expr1: child node must be inserted after metadata nodes |
| // - OR - |
| // expr2: "child >= brother" |
| if ((i <= 2 && isMetadataNode(brother)) || |
| comparableChild.compareTo(brother) >= 0) { |
| addChildNode(parent, child, i + 1); |
| return; |
| } |
| } |
| // "child < all brothers", add at the beginning |
| addChildNode(parent, child, 0); |
| return; |
| } |
| // "child not comparable", add at the end |
| addChildNode(parent, child, childCount); |
| } |
| |
| /** |
| * This method removes all the displayed nodes from the tree, |
| * but does not affect actual MBeanServer contents. |
| */ |
| // Call on EDT |
| @Override |
| public synchronized void removeAll() { |
| DefaultTreeModel model = (DefaultTreeModel) getModel(); |
| DefaultMutableTreeNode root = (DefaultMutableTreeNode) model.getRoot(); |
| root.removeAllChildren(); |
| model.nodeStructureChanged(root); |
| nodes.clear(); |
| } |
| |
| // Call on EDT |
| public synchronized void removeMBeanFromView(ObjectName mbean) { |
| // We assume here that MBeans are removed one by one (on MBean |
| // unregistered notification). Deletes the tree node associated |
| // with the given MBean and recursively all the node parents |
| // which are leaves and non XMBean. |
| // |
| DefaultMutableTreeNode node = null; |
| Dn dn = new Dn(mbean); |
| if (dn.getTokenCount() > 0) { |
| DefaultTreeModel model = (DefaultTreeModel) getModel(); |
| Token token = dn.getToken(0); |
| String hashKey = dn.getHashKey(token); |
| node = nodes.get(hashKey); |
| if ((node != null) && (!node.isRoot())) { |
| if (hasNonMetadataNodes(node)) { |
| removeMetadataNodes(node); |
| String label = token.getValue(); |
| XNodeInfo userObject = new XNodeInfo( |
| Type.NONMBEAN, label, |
| label, token.getTokenValue()); |
| changeNodeValue(node, userObject); |
| } else { |
| DefaultMutableTreeNode parent = |
| (DefaultMutableTreeNode) node.getParent(); |
| model.removeNodeFromParent(node); |
| nodes.remove(hashKey); |
| removeParentFromView(dn, 1, parent); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Returns true if any of the children nodes is a non MBean metadata node. |
| */ |
| private boolean hasNonMetadataNodes(DefaultMutableTreeNode node) { |
| for (Enumeration<?> e = node.children(); e.hasMoreElements();) { |
| DefaultMutableTreeNode n = (DefaultMutableTreeNode) e.nextElement(); |
| Object uo = n.getUserObject(); |
| if (uo instanceof XNodeInfo) { |
| switch (((XNodeInfo) uo).getType()) { |
| case ATTRIBUTES: |
| case NOTIFICATIONS: |
| case OPERATIONS: |
| break; |
| default: |
| return true; |
| } |
| } else { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Returns true if any of the children nodes is an MBean metadata node. |
| */ |
| public boolean hasMetadataNodes(DefaultMutableTreeNode node) { |
| for (Enumeration<?> e = node.children(); e.hasMoreElements();) { |
| DefaultMutableTreeNode n = (DefaultMutableTreeNode) e.nextElement(); |
| Object uo = n.getUserObject(); |
| if (uo instanceof XNodeInfo) { |
| switch (((XNodeInfo) uo).getType()) { |
| case ATTRIBUTES: |
| case NOTIFICATIONS: |
| case OPERATIONS: |
| return true; |
| default: |
| break; |
| } |
| } else { |
| return false; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Returns true if the given node is an MBean metadata node. |
| */ |
| public boolean isMetadataNode(DefaultMutableTreeNode node) { |
| Object uo = node.getUserObject(); |
| if (uo instanceof XNodeInfo) { |
| switch (((XNodeInfo) uo).getType()) { |
| case ATTRIBUTES: |
| case NOTIFICATIONS: |
| case OPERATIONS: |
| return true; |
| default: |
| return false; |
| } |
| } else { |
| return false; |
| } |
| } |
| |
| /** |
| * Remove the metadata nodes associated with a given MBean node. |
| */ |
| // Call on EDT |
| private void removeMetadataNodes(DefaultMutableTreeNode node) { |
| Set<DefaultMutableTreeNode> metadataNodes = |
| new HashSet<DefaultMutableTreeNode>(); |
| DefaultTreeModel model = (DefaultTreeModel) getModel(); |
| for (Enumeration<?> e = node.children(); e.hasMoreElements();) { |
| DefaultMutableTreeNode n = (DefaultMutableTreeNode) e.nextElement(); |
| Object uo = n.getUserObject(); |
| if (uo instanceof XNodeInfo) { |
| switch (((XNodeInfo) uo).getType()) { |
| case ATTRIBUTES: |
| case NOTIFICATIONS: |
| case OPERATIONS: |
| metadataNodes.add(n); |
| break; |
| default: |
| break; |
| } |
| } |
| } |
| for (DefaultMutableTreeNode n : metadataNodes) { |
| model.removeNodeFromParent(n); |
| } |
| } |
| |
| /** |
| * Removes only the parent nodes which are non MBean and leaf. |
| * This method assumes the child nodes have been removed before. |
| */ |
| // Call on EDT |
| private DefaultMutableTreeNode removeParentFromView( |
| Dn dn, int index, DefaultMutableTreeNode node) { |
| if ((!node.isRoot()) && node.isLeaf() && |
| (!(((XNodeInfo) node.getUserObject()).getType().equals(Type.MBEAN)))) { |
| DefaultMutableTreeNode parent = |
| (DefaultMutableTreeNode) node.getParent(); |
| removeChildNode(node); |
| String hashKey = dn.getHashKey(dn.getToken(index)); |
| nodes.remove(hashKey); |
| removeParentFromView(dn, index + 1, parent); |
| } |
| return node; |
| } |
| |
| // Call on EDT |
| public synchronized void addMBeansToView(Set<ObjectName> mbeans) { |
| Set<Dn> dns = new TreeSet<Dn>(); |
| for (ObjectName mbean : mbeans) { |
| Dn dn = new Dn(mbean); |
| dns.add(dn); |
| } |
| for (Dn dn : dns) { |
| ObjectName mbean = dn.getObjectName(); |
| XMBean xmbean = new XMBean(mbean, mbeansTab); |
| addMBeanToView(mbean, xmbean, dn); |
| } |
| } |
| |
| // Call on EDT |
| public synchronized void addMBeanToView(ObjectName mbean) { |
| // Build XMBean for the given MBean |
| // |
| XMBean xmbean = new XMBean(mbean, mbeansTab); |
| // Build Dn for the given MBean |
| // |
| Dn dn = new Dn(mbean); |
| // Add the new nodes to the MBean tree from leaf to root |
| // |
| addMBeanToView(mbean, xmbean, dn); |
| } |
| |
| // Call on EDT |
| private synchronized void addMBeanToView( |
| ObjectName mbean, XMBean xmbean, Dn dn) { |
| |
| DefaultMutableTreeNode childNode = null; |
| DefaultMutableTreeNode parentNode = null; |
| |
| // Add the node or replace its user object if already added |
| // |
| Token token = dn.getToken(0); |
| String hashKey = dn.getHashKey(token); |
| if (nodes.containsKey(hashKey)) { |
| // Found existing node previously created when adding another node |
| // |
| childNode = nodes.get(hashKey); |
| // Replace user object to reflect that this node is an MBean |
| // |
| Object data = createNodeValue(xmbean, token); |
| String label = data.toString(); |
| XNodeInfo userObject = |
| new XNodeInfo(Type.MBEAN, data, label, mbean.toString()); |
| changeNodeValue(childNode, userObject); |
| return; |
| } |
| |
| // Create new leaf node |
| // |
| childNode = createDnNode(dn, token, xmbean); |
| nodes.put(hashKey, childNode); |
| |
| // Add intermediate non MBean nodes |
| // |
| for (int i = 1; i < dn.getTokenCount(); i++) { |
| token = dn.getToken(i); |
| hashKey = dn.getHashKey(token); |
| if (nodes.containsKey(hashKey)) { |
| // Intermediate node already present, add new node as child |
| // |
| parentNode = nodes.get(hashKey); |
| addChildNode(parentNode, childNode); |
| return; |
| } else { |
| // Create new intermediate node |
| // |
| if ("domain".equals(token.getTokenType())) { |
| parentNode = createDomainNode(dn, token); |
| DefaultMutableTreeNode root = |
| (DefaultMutableTreeNode) getModel().getRoot(); |
| addChildNode(root, parentNode); |
| } else { |
| parentNode = createSubDnNode(dn, token); |
| } |
| nodes.put(hashKey, parentNode); |
| addChildNode(parentNode, childNode); |
| } |
| childNode = parentNode; |
| } |
| } |
| |
| // Call on EDT |
| private synchronized void changeNodeValue( |
| DefaultMutableTreeNode node, XNodeInfo nodeValue) { |
| if (node instanceof ComparableDefaultMutableTreeNode) { |
| // should it stay at the same place? |
| DefaultMutableTreeNode clone = |
| (DefaultMutableTreeNode) node.clone(); |
| clone.setUserObject(nodeValue); |
| if (((ComparableDefaultMutableTreeNode) node).compareTo(clone) == 0) { |
| // the order in the tree didn't change |
| node.setUserObject(nodeValue); |
| DefaultTreeModel model = (DefaultTreeModel) getModel(); |
| model.nodeChanged(node); |
| } else { |
| // delete the node and re-order it in case the |
| // node value modifies the order in the tree |
| DefaultMutableTreeNode parent = |
| (DefaultMutableTreeNode) node.getParent(); |
| removeChildNode(node); |
| node.setUserObject(nodeValue); |
| addChildNode(parent, node); |
| } |
| } else { |
| // not comparable stays at the same place |
| node.setUserObject(nodeValue); |
| DefaultTreeModel model = (DefaultTreeModel) getModel(); |
| model.nodeChanged(node); |
| } |
| // Load the MBean metadata if type is MBEAN |
| if (nodeValue.getType().equals(Type.MBEAN)) { |
| removeMetadataNodes(node); |
| TreeNode[] treeNodes = node.getPath(); |
| TreePath path = new TreePath(treeNodes); |
| if (isExpanded(path)) { |
| addMetadataNodes(node); |
| } |
| } |
| // Clear the current selection and set it |
| // again so valueChanged() gets called |
| if (node == getLastSelectedPathComponent()) { |
| TreePath selectionPath = getSelectionPath(); |
| clearSelection(); |
| setSelectionPath(selectionPath); |
| } |
| } |
| |
| /** |
| * Creates the domain node. |
| */ |
| private DefaultMutableTreeNode createDomainNode(Dn dn, Token token) { |
| DefaultMutableTreeNode node = new ComparableDefaultMutableTreeNode(); |
| String label = dn.getDomain(); |
| XNodeInfo userObject = |
| new XNodeInfo(Type.NONMBEAN, label, label, label); |
| node.setUserObject(userObject); |
| return node; |
| } |
| |
| /** |
| * Creates the node corresponding to the whole Dn, i.e. an MBean. |
| */ |
| private DefaultMutableTreeNode createDnNode( |
| Dn dn, Token token, XMBean xmbean) { |
| DefaultMutableTreeNode node = new ComparableDefaultMutableTreeNode(); |
| Object data = createNodeValue(xmbean, token); |
| String label = data.toString(); |
| XNodeInfo userObject = new XNodeInfo(Type.MBEAN, data, label, |
| xmbean.getObjectName().toString()); |
| node.setUserObject(userObject); |
| return node; |
| } |
| |
| /** |
| * Creates the node corresponding to a subDn, i.e. a non-MBean |
| * intermediate node. |
| */ |
| private DefaultMutableTreeNode createSubDnNode(Dn dn, Token token) { |
| DefaultMutableTreeNode node = new ComparableDefaultMutableTreeNode(); |
| String label = isKeyValueView() ? token.getTokenValue() : token.getValue(); |
| XNodeInfo userObject = |
| new XNodeInfo(Type.NONMBEAN, label, label, token.getTokenValue()); |
| node.setUserObject(userObject); |
| return node; |
| } |
| |
| private Object createNodeValue(XMBean xmbean, Token token) { |
| String label = isKeyValueView() ? token.getTokenValue() : token.getValue(); |
| xmbean.setText(label); |
| return xmbean; |
| } |
| |
| /** |
| * Parses the MBean ObjectName comma-separated properties string and puts |
| * the individual key/value pairs into the map. Key order in the properties |
| * string is preserved by the map. |
| */ |
| private static Map<String, String> extractKeyValuePairs( |
| String props, ObjectName mbean) { |
| Map<String, String> map = new LinkedHashMap<String, String>(); |
| int eq = props.indexOf("="); |
| while (eq != -1) { |
| String key = props.substring(0, eq); |
| String value = mbean.getKeyProperty(key); |
| map.put(key, value); |
| props = props.substring(key.length() + 1 + value.length()); |
| if (props.startsWith(",")) { |
| props = props.substring(1); |
| } |
| eq = props.indexOf("="); |
| } |
| return map; |
| } |
| |
| /** |
| * Returns the ordered key property list that will be used to build the |
| * MBean tree. If the "com.sun.tools.jconsole.mbeans.keyPropertyList" system |
| * property is not specified, then the ordered key property list used |
| * to build the MBean tree will be the one returned by the method |
| * ObjectName.getKeyPropertyListString() with "type" as first key, |
| * and "j2eeType" as second key, if present. If any of the keys specified |
| * in the comma-separated key property list does not apply to the given |
| * MBean then it will be discarded. |
| */ |
| private static String getKeyPropertyListString(ObjectName mbean) { |
| String props = mbean.getKeyPropertyListString(); |
| Map<String, String> map = extractKeyValuePairs(props, mbean); |
| StringBuilder sb = new StringBuilder(); |
| // Add the key/value pairs to the buffer following the |
| // key order defined by the "orderedKeyPropertyList" |
| for (String key : orderedKeyPropertyList) { |
| if (map.containsKey(key)) { |
| sb.append(key + "=" + map.get(key) + ","); |
| map.remove(key); |
| } |
| } |
| // Add the remaining key/value pairs to the buffer |
| for (Map.Entry<String, String> entry : map.entrySet()) { |
| sb.append(entry.getKey() + "=" + entry.getValue() + ","); |
| } |
| String orderedKeyPropertyListString = sb.toString(); |
| orderedKeyPropertyListString = orderedKeyPropertyListString.substring( |
| 0, orderedKeyPropertyListString.length() - 1); |
| return orderedKeyPropertyListString; |
| } |
| |
| // Call on EDT |
| public void addMetadataNodes(DefaultMutableTreeNode node) { |
| XMBean mbean = (XMBean) ((XNodeInfo) node.getUserObject()).getData(); |
| DefaultTreeModel model = (DefaultTreeModel) getModel(); |
| MBeanInfoNodesSwingWorker sw = |
| new MBeanInfoNodesSwingWorker(model, node, mbean); |
| if (sw != null) { |
| sw.execute(); |
| } |
| } |
| |
| private static class MBeanInfoNodesSwingWorker |
| extends SwingWorker<Object[], Void> { |
| |
| private final DefaultTreeModel model; |
| private final DefaultMutableTreeNode node; |
| private final XMBean mbean; |
| |
| public MBeanInfoNodesSwingWorker( |
| DefaultTreeModel model, |
| DefaultMutableTreeNode node, |
| XMBean mbean) { |
| this.model = model; |
| this.node = node; |
| this.mbean = mbean; |
| } |
| |
| @Override |
| public Object[] doInBackground() throws InstanceNotFoundException, |
| IntrospectionException, ReflectionException, IOException { |
| Object result[] = new Object[2]; |
| // Retrieve MBeanInfo for this MBean |
| result[0] = mbean.getMBeanInfo(); |
| // Check if this MBean is a notification emitter |
| result[1] = mbean.isBroadcaster(); |
| return result; |
| } |
| |
| @Override |
| protected void done() { |
| try { |
| Object result[] = get(); |
| MBeanInfo mbeanInfo = (MBeanInfo) result[0]; |
| Boolean isBroadcaster = (Boolean) result[1]; |
| if (mbeanInfo != null) { |
| addMBeanInfoNodes(model, node, mbean, mbeanInfo, isBroadcaster); |
| } |
| } catch (Exception e) { |
| Throwable t = Utils.getActualException(e); |
| if (JConsole.isDebug()) { |
| t.printStackTrace(); |
| } |
| } |
| } |
| |
| // Call on EDT |
| private void addMBeanInfoNodes( |
| DefaultTreeModel tree, DefaultMutableTreeNode node, |
| XMBean mbean, MBeanInfo mbeanInfo, Boolean isBroadcaster) { |
| MBeanAttributeInfo[] ai = mbeanInfo.getAttributes(); |
| MBeanOperationInfo[] oi = mbeanInfo.getOperations(); |
| MBeanNotificationInfo[] ni = mbeanInfo.getNotifications(); |
| |
| // Insert the Attributes/Operations/Notifications metadata nodes as |
| // the three first children of this MBean node. This is only useful |
| // when this MBean node denotes an MBean but it's not a leaf in the |
| // MBean tree |
| // |
| int childIndex = 0; |
| |
| // MBeanAttributeInfo node |
| // |
| if (ai != null && ai.length > 0) { |
| DefaultMutableTreeNode attributes = new DefaultMutableTreeNode(); |
| XNodeInfo attributesUO = new XNodeInfo(Type.ATTRIBUTES, mbean, |
| Messages.ATTRIBUTES, null); |
| attributes.setUserObject(attributesUO); |
| node.insert(attributes, childIndex++); |
| for (MBeanAttributeInfo mbai : ai) { |
| DefaultMutableTreeNode attribute = new DefaultMutableTreeNode(); |
| XNodeInfo attributeUO = new XNodeInfo(Type.ATTRIBUTE, |
| new Object[]{mbean, mbai}, mbai.getName(), null); |
| attribute.setUserObject(attributeUO); |
| attribute.setAllowsChildren(false); |
| attributes.add(attribute); |
| } |
| } |
| // MBeanOperationInfo node |
| // |
| if (oi != null && oi.length > 0) { |
| DefaultMutableTreeNode operations = new DefaultMutableTreeNode(); |
| XNodeInfo operationsUO = new XNodeInfo(Type.OPERATIONS, mbean, |
| Messages.OPERATIONS, null); |
| operations.setUserObject(operationsUO); |
| node.insert(operations, childIndex++); |
| for (MBeanOperationInfo mboi : oi) { |
| // Compute the operation's tool tip text: |
| // "operationname(param1type,param2type,...)" |
| // |
| StringBuilder sb = new StringBuilder(); |
| for (MBeanParameterInfo mbpi : mboi.getSignature()) { |
| sb.append(mbpi.getType() + ","); |
| } |
| String signature = sb.toString(); |
| if (signature.length() > 0) { |
| // Remove the trailing ',' |
| // |
| signature = signature.substring(0, signature.length() - 1); |
| } |
| String toolTipText = mboi.getName() + "(" + signature + ")"; |
| // Create operation node |
| // |
| DefaultMutableTreeNode operation = new DefaultMutableTreeNode(); |
| XNodeInfo operationUO = new XNodeInfo(Type.OPERATION, |
| new Object[]{mbean, mboi}, mboi.getName(), toolTipText); |
| operation.setUserObject(operationUO); |
| operation.setAllowsChildren(false); |
| operations.add(operation); |
| } |
| } |
| // MBeanNotificationInfo node |
| // |
| if (isBroadcaster != null && isBroadcaster.booleanValue()) { |
| DefaultMutableTreeNode notifications = new DefaultMutableTreeNode(); |
| XNodeInfo notificationsUO = new XNodeInfo(Type.NOTIFICATIONS, mbean, |
| Messages.NOTIFICATIONS, null); |
| notifications.setUserObject(notificationsUO); |
| node.insert(notifications, childIndex++); |
| if (ni != null && ni.length > 0) { |
| for (MBeanNotificationInfo mbni : ni) { |
| DefaultMutableTreeNode notification = |
| new DefaultMutableTreeNode(); |
| XNodeInfo notificationUO = new XNodeInfo(Type.NOTIFICATION, |
| mbni, mbni.getName(), null); |
| notification.setUserObject(notificationUO); |
| notification.setAllowsChildren(false); |
| notifications.add(notification); |
| } |
| } |
| } |
| // Update tree model |
| // |
| model.reload(node); |
| } |
| } |
| // |
| // Tree preferences |
| // |
| private static boolean treeView; |
| private static boolean treeViewInit = false; |
| |
| private static boolean isTreeView() { |
| if (!treeViewInit) { |
| treeView = getTreeViewValue(); |
| treeViewInit = true; |
| } |
| return treeView; |
| } |
| |
| private static boolean getTreeViewValue() { |
| String tv = System.getProperty("treeView"); |
| return ((tv == null) ? true : !(tv.equals("false"))); |
| } |
| // |
| // MBean key-value preferences |
| // |
| private boolean keyValueView = Boolean.getBoolean("keyValueView"); |
| |
| private boolean isKeyValueView() { |
| return keyValueView; |
| } |
| |
| // |
| // Utility classes |
| // |
| private static class ComparableDefaultMutableTreeNode |
| extends DefaultMutableTreeNode |
| implements Comparable<DefaultMutableTreeNode> { |
| |
| public int compareTo(DefaultMutableTreeNode node) { |
| return (this.toString().compareTo(node.toString())); |
| } |
| } |
| |
| private static class Dn implements Comparable<Dn> { |
| |
| private ObjectName mbean; |
| private String domain; |
| private String keyPropertyList; |
| private String hashDn; |
| private List<Token> tokens = new ArrayList<Token>(); |
| |
| public Dn(ObjectName mbean) { |
| this.mbean = mbean; |
| this.domain = mbean.getDomain(); |
| this.keyPropertyList = getKeyPropertyListString(mbean); |
| |
| if (isTreeView()) { |
| // Tree view |
| Map<String, String> map = |
| extractKeyValuePairs(keyPropertyList, mbean); |
| for (Map.Entry<String, String> entry : map.entrySet()) { |
| tokens.add(new Token("key", entry.getKey() + "=" + entry.getValue())); |
| } |
| } else { |
| // Flat view |
| tokens.add(new Token("key", "properties=" + keyPropertyList)); |
| } |
| |
| // Add the domain as the first token in the Dn |
| tokens.add(0, new Token("domain", "domain=" + domain)); |
| |
| // Reverse the Dn (from leaf to root) |
| Collections.reverse(tokens); |
| |
| // Compute hash for Dn |
| computeHashDn(); |
| } |
| |
| public ObjectName getObjectName() { |
| return mbean; |
| } |
| |
| public String getDomain() { |
| return domain; |
| } |
| |
| public String getKeyPropertyList() { |
| return keyPropertyList; |
| } |
| |
| public Token getToken(int index) { |
| return tokens.get(index); |
| } |
| |
| public int getTokenCount() { |
| return tokens.size(); |
| } |
| |
| public String getHashDn() { |
| return hashDn; |
| } |
| |
| public String getHashKey(Token token) { |
| final int begin = hashDn.indexOf(token.getTokenValue()); |
| return hashDn.substring(begin, hashDn.length()); |
| } |
| |
| private void computeHashDn() { |
| if (tokens.isEmpty()) { |
| return; |
| } |
| final StringBuilder hdn = new StringBuilder(); |
| for (int i = 0; i < tokens.size(); i++) { |
| hdn.append(tokens.get(i).getTokenValue()); |
| hdn.append(","); |
| } |
| hashDn = hdn.substring(0, hdn.length() - 1); |
| } |
| |
| @Override |
| public String toString() { |
| return domain + ":" + keyPropertyList; |
| } |
| |
| public int compareTo(Dn dn) { |
| return this.toString().compareTo(dn.toString()); |
| } |
| } |
| |
| private static class Token { |
| |
| private String tokenType; |
| private String tokenValue; |
| private String key; |
| private String value; |
| |
| public Token(String tokenType, String tokenValue) { |
| this.tokenType = tokenType; |
| this.tokenValue = tokenValue; |
| buildKeyValue(); |
| } |
| |
| public String getTokenType() { |
| return tokenType; |
| } |
| |
| public String getTokenValue() { |
| return tokenValue; |
| } |
| |
| public String getKey() { |
| return key; |
| } |
| |
| public String getValue() { |
| return value; |
| } |
| |
| private void buildKeyValue() { |
| int index = tokenValue.indexOf("="); |
| if (index < 0) { |
| key = tokenValue; |
| value = tokenValue; |
| } else { |
| key = tokenValue.substring(0, index); |
| value = tokenValue.substring(index + 1, tokenValue.length()); |
| } |
| } |
| } |
| } |
