/*
* Copyright 2004-2006 Sun Microsystems, Inc. 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. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*/
package sun.tools.jconsole.inspector;
import java.awt.EventQueue;
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.Resources;
import sun.tools.jconsole.inspector.XNodeInfo;
import 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);
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) {
// Tree does not show up when there is only the root node
//
DefaultTreeModel model = (DefaultTreeModel) getModel();
DefaultMutableTreeNode root = (DefaultMutableTreeNode) model.getRoot();
boolean rootLeaf = root.isLeaf();
model.insertNodeInto(child, parent, index);
if (rootLeaf) {
model.nodeStructureChanged(root);
}
}
/**
* 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);
} else if (child instanceof ComparableDefaultMutableTreeNode) {
ComparableDefaultMutableTreeNode comparableChild =
(ComparableDefaultMutableTreeNode)child;
int i = 0;
for (; i < childCount; i++) {
DefaultMutableTreeNode brother =
(DefaultMutableTreeNode) parent.getChildAt(i);
//child < brother
if (comparableChild.compareTo(brother) < 0) {
addChildNode(parent, child, i);
break;
}
//child = brother
else if (comparableChild.compareTo(brother) == 0) {
addChildNode(parent, child, i);
break;
}
}
//child < all brothers
if (i == childCount) {
addChildNode(parent, child, childCount);
}
} else {
//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
public synchronized void removeAll() {
DefaultTreeModel model = (DefaultTreeModel) getModel();
DefaultMutableTreeNode root = (DefaultMutableTreeNode) model.getRoot();
root.removeAllChildren();
model.nodeStructureChanged(root);
nodes.clear();
}
public void delMBeanFromView(final ObjectName mbean) {
EventQueue.invokeLater(new Runnable() {
public void run() {
// 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.
//
synchronized (XTree.this) {
DefaultMutableTreeNode node = null;
Dn dn = buildDn(mbean);
if (dn.size() > 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 (hasMBeanChildren(node)) {
removeNonMBeanChildren(node);
String label = token.getValue().toString();
XNodeInfo userObject = new XNodeInfo(
Type.NONMBEAN, label,
label, token.toString());
changeNodeValue(node, userObject);
} else {
DefaultMutableTreeNode parent =
(DefaultMutableTreeNode) node.getParent();
model.removeNodeFromParent(node);
nodes.remove(hashKey);
delParentFromView(dn, 1, parent);
}
}
}
}
}
});
}
/**
* Returns true if any of the children nodes is an MBean.
*/
private boolean hasMBeanChildren(DefaultMutableTreeNode node) {
for (Enumeration e = node.children(); e.hasMoreElements(); ) {
DefaultMutableTreeNode n = (DefaultMutableTreeNode) e.nextElement();
if (((XNodeInfo) n.getUserObject()).getType().equals(Type.MBEAN)) {
return true;
}
}
return false;
}
/**
* Remove all the children nodes which are not MBean.
*/
private void removeNonMBeanChildren(DefaultMutableTreeNode node) {
Set<DefaultMutableTreeNode> metadataNodes =
new HashSet<DefaultMutableTreeNode>();
DefaultTreeModel model = (DefaultTreeModel) getModel();
for (Enumeration e = node.children(); e.hasMoreElements(); ) {
DefaultMutableTreeNode n = (DefaultMutableTreeNode) e.nextElement();
if (!((XNodeInfo) n.getUserObject()).getType().equals(Type.MBEAN)) {
metadataNodes.add(n);
}
}
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.
*/
private DefaultMutableTreeNode delParentFromView(
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);
delParentFromView(dn, index + 1, parent);
}
return node;
}
public synchronized void addMBeanToView(final ObjectName mbean) {
final XMBean xmbean;
try {
xmbean = new XMBean(mbean, mbeansTab);
if (xmbean == null) {
return;
}
} catch (Exception e) {
// Got exception while trying to retrieve the
// given MBean from the underlying MBeanServer
//
if (JConsole.isDebug()) {
e.printStackTrace();
}
return;
}
EventQueue.invokeLater(new Runnable() {
public void run() {
synchronized (XTree.this) {
// Add the new nodes to the MBean tree from leaf to root
Dn dn = buildDn(mbean);
if (dn.size() == 0) return;
Token token = dn.getToken(0);
DefaultMutableTreeNode node = null;
boolean nodeCreated = true;
//
// Add the node or replace its user object if already added
//
String hashKey = dn.getHashKey(token);
if (nodes.containsKey(hashKey)) {
//already in the tree, means it has been created previously
//when adding another node
node = nodes.get(hashKey);
//sets the user object
final Object data = createNodeValue(xmbean, token);
final String label = data.toString();
final XNodeInfo userObject =
new XNodeInfo(Type.MBEAN, data, label, mbean.toString());
changeNodeValue(node, userObject);
nodeCreated = false;
} else {
//create a new node
node = createDnNode(dn, token, xmbean);
if (node != null) {
nodes.put(hashKey, node);
nodeCreated = true;
} else {
return;
}
}
//
// Add (virtual) nodes without user object if necessary
//
for (int i = 1; i < dn.size(); i++) {
DefaultMutableTreeNode currentNode = null;
token = dn.getToken(i);
hashKey = dn.getHashKey(token);
if (nodes.containsKey(hashKey)) {
//node already present
if (nodeCreated) {
//previous node created, link to do
currentNode = nodes.get(hashKey);
addChildNode(currentNode, node);
return;
} else {
//both nodes already present
return;
}
} else {
//creates the node that can be a virtual one
if (token.getKeyDn().equals("domain")) {
//better match on keyDn that on Dn
currentNode = createDomainNode(dn, token);
if (currentNode != null) {
final DefaultMutableTreeNode root =
(DefaultMutableTreeNode) getModel().getRoot();
addChildNode(root, currentNode);
}
} else {
currentNode = createSubDnNode(dn, token);
if (currentNode == null) {
//skip
continue;
}
}
nodes.put(hashKey, currentNode);
addChildNode(currentNode, node);
nodeCreated = true;
}
node = currentNode;
}
}
}
});
}
// Call on EDT
private synchronized void changeNodeValue(
final 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)) {
XMBeanInfo.loadInfo(node);
DefaultTreeModel model = (DefaultTreeModel) getModel();
model.nodeStructureChanged(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, called on a domain token
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
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);
XMBeanInfo.loadInfo(node);
return node;
}
//creates a node with the token value, call for each non domain sub
//dn token
private DefaultMutableTreeNode createSubDnNode(Dn dn, Token token) {
DefaultMutableTreeNode node = new ComparableDefaultMutableTreeNode();
String label = isKeyValueView() ? token.toString() :
token.getValue().toString();
XNodeInfo userObject =
new XNodeInfo(Type.NONMBEAN, label, label, token.toString());
node.setUserObject(userObject);
return node;
}
private Object createNodeValue(XMBean xmbean, Token token) {
String label = isKeyValueView() ? token.toString() :
token.getValue().toString();
xmbean.setText(label);
return xmbean;
}
/**
* Parses MBean ObjectName comma-separated properties string and put the
* individual key/value pairs into the map. Key order in the properties
* string is preserved by the map.
*/
private Map<String,String> extractKeyValuePairs(
String properties, ObjectName mbean) {
String props = properties;
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 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;
}
/**
* Builds the Dn for the given MBean.
*/
private Dn buildDn(ObjectName mbean) {
String domain = mbean.getDomain();
String globalDn = getKeyPropertyListString(mbean);
Dn dn = buildDn(domain, globalDn, mbean);
//update the Dn tokens to add the domain
dn.updateDn();
//reverse the Dn (from leaf to root)
dn.reverseOrder();
//compute the hashDn
dn.computeHashDn();
return dn;
}
/**
* Builds the Dn for the given MBean.
*/
private Dn buildDn(String domain, String globalDn, ObjectName mbean) {
Dn dn = new Dn(domain, globalDn);
String keyDn = "no_key";
if (isTreeView()) {
String props = globalDn;
Map<String,String> map = extractKeyValuePairs(props, mbean);
for (Map.Entry<String,String> entry : map.entrySet()) {
dn.addToken(new Token(keyDn,
entry.getKey() + "=" + entry.getValue()));
}
} else {
//flat view
dn.addToken(new Token(keyDn, "properties=" + globalDn));
}
return dn;
}
//
//utility objects
//
public static class ComparableDefaultMutableTreeNode
extends DefaultMutableTreeNode
implements Comparable<DefaultMutableTreeNode> {
public int compareTo(DefaultMutableTreeNode node) {
return (this.toString().compareTo(node.toString()));
}
}
//
//tree preferences
//
private boolean treeView;
private boolean treeViewInit = false;
public boolean isTreeView() {
if (!treeViewInit) {
treeView = getTreeViewValue();
treeViewInit = true;
}
return treeView;
}
private boolean getTreeViewValue() {
String treeView = System.getProperty("treeView");
return ((treeView == null) ? true : !(treeView.equals("false")));
}
//
//MBean key-value preferences
//
private boolean keyValueView = Boolean.getBoolean("keyValueView");
public boolean isKeyValueView() {
return keyValueView;
}
//
//utility classes
//
public static class Dn {
private String domain;
private String dn;
private String hashDn;
private ArrayList<Token> tokens = new ArrayList<Token>();
public Dn(String domain, String dn) {
this.domain = domain;
this.dn = dn;
}
public void clearTokens() {
tokens.clear();
}
public void addToken(Token token) {
tokens.add(token);
}
public void addToken(int index, Token token) {
tokens.add(index, token);
}
public void setToken(int index, Token token) {
tokens.set(index, token);
}
public void removeToken(int index) {
tokens.remove(index);
}
public Token getToken(int index) {
return tokens.get(index);
}
public void reverseOrder() {
ArrayList<Token> newOrder = new ArrayList<Token>(tokens.size());
for (int i = tokens.size() - 1; i >= 0; i--) {
newOrder.add(tokens.get(i));
}
tokens = newOrder;
}
public int size() {
return tokens.size();
}
public String getDomain() {
return domain;
}
public String getDn() {
return dn;
}
public String getHashDn() {
return hashDn;
}
public String getHashKey(Token token) {
final int begin = getHashDn().indexOf(token.getHashToken());
return getHashDn().substring(begin, getHashDn().length());
}
public void computeHashDn() {
final StringBuilder hashDn = new StringBuilder();
final int tokensSize = tokens.size();
for (int i = 0; i < tokensSize; i++) {
Token token = tokens.get(i);
String hashToken = token.getHashToken();
if (hashToken == null) {
hashToken = token.getToken() + (tokensSize - i);
token.setHashToken(hashToken);
}
hashDn.append(hashToken);
hashDn.append(",");
}
if (tokensSize > 0) {
this.hashDn = hashDn.substring(0, hashDn.length() - 1);
} else {
this.hashDn = "";
}
}
/**
* Adds the domain as the first token in the Dn.
*/
public void updateDn() {
addToken(0, new Token("domain", "domain=" + getDomain()));
}
public String toString() {
return tokens.toString();
}
}
public static class Token {
private String keyDn;
private String token;
private String hashToken;
private String key;
private String value;
public Token(String keyDn, String token) {
this.keyDn = keyDn;
this.token = token;
buildKeyValue();
}
public Token(String keyDn, String token, String hashToken) {
this.keyDn = keyDn;
this.token = token;
this.hashToken = hashToken;
buildKeyValue();
}
public String getKeyDn() {
return keyDn;
}
public String getToken() {
return token;
}
public void setValue(String value) {
this.value = value;
this.token = key + "=" + value;
}
public void setKey(String key) {
this.key = key;
this.token = key + "=" + value;
}
public void setKeyDn(String keyDn) {
this.keyDn = keyDn;
}
public void setHashToken(String hashToken) {
this.hashToken = hashToken;
}
public String getHashToken() {
return hashToken;
}
public String getKey() {
return key;
}
public String getValue() {
return value;
}
public String toString(){
return getToken();
}
public boolean equals(Object object) {
if (object instanceof Token) {
return token.equals(((Token) object));
} else {
return false;
}
}
private void buildKeyValue() {
int index = token.indexOf("=");
if (index < 0) {
key = token;
value = token;
} else {
key = token.substring(0, index);
value = token.substring(index + 1, token.length());
}
}
}
}