View Javadoc
   package net.sf.panoptes.module.jmx;
   
   import java.io.IOException;
   import java.util.HashMap;
   import java.util.Iterator;
   import java.util.Set;
   
   import javax.management.InstanceNotFoundException;
   import javax.management.MBeanException;
  import javax.management.MBeanInfo;
  import javax.management.MBeanServerConnection;
  import javax.management.ObjectInstance;
  import javax.management.ObjectName;
  import javax.management.ReflectionException;
  
  import net.sf.panoptes.model.component.ComponentQuery;
  import net.sf.panoptes.model.component.ComponentUtil;
  import net.sf.panoptes.model.component.registry.ComponentAlreadyExistsException;
  import net.sf.panoptes.model.component.registry.ComponentName;
  import net.sf.panoptes.model.component.registry.MalformedComponentNameException;
  import net.sf.panoptes.model.node.Node;
  import net.sf.panoptes.model.node.NodeDescriptor;
  import net.sf.panoptes.module.jmx.connector.MBeanServerConnector;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.eclipse.swt.graphics.Image;
  
  /***
   * MBeanServerComponent.java
   * 
   * Wraps a <code>MBeanServerConnection</code>. No uniform way to identify or name
   * such connections exist since there are various connector types and protocols, but to 
   * give earch connection a <code>ComponentName</code>, we require a hostname
   * and a name for each component. These two combined must be unique. It would be 
   * possible to generate a unique ID (e.g and GUID) instead, but this would break
   * the possibility to store configuration settings for a specific MBeanServer from
   * session to session.
   * 
   * All domains and MBeans that belongs to a MBeanServer will inherit the attributes
   * identifying the server instance so that domains and MBeans can be queried. 
   * (This class is really just a <code>ComponentQuery</code> that returns all domains
   * matching the server's attribtues).
   * 
   * @author Dag Liodden
   * @version 0.1
   */
  public class MBeanServerComponent extends ComponentQuery {
  
  	private String name;
  	private String hostName;
  	private MBeanServerConnection serverConnection = null;
  	private MBeanComponent[] mBeans = new MBeanComponent[0];
  	private HashMap domains = new HashMap();
  	private MBeanServerConnector connector;
  	private Log log = LogFactory.getLog(getClass());
  
  
  
  	/***
  	 * Constructor for MBeanServerComponent.
  	 */
  	public MBeanServerComponent(MBeanServerConnector connector) {
  		this.connector = connector;
  	}
  	
  	public void init() {
  		ComponentName query;
  		try {
  			query = ComponentUtil.createMBeanServerName(this);
  			query.setDomain(ComponentName.DOMAIN_MBEAN_DOMAIN);
  			setQuery(new ComponentName(query.toString() + ",*"));
  		} catch (MalformedComponentNameException e) {
  			e.printStackTrace();
  		}
  	}
  	
  	public void connect() throws Exception {
  		setServer(connector.connect());
  	}
  
  	protected void setServer(MBeanServerConnection connection) {
  		this.serverConnection = connection;
  		refresh();
  	}
  	
  	/***
  	 * Returns the host.
  	 * @return String
  	 */
  	public String getHostName() {
  		return hostName;
  	}
  
  	/***
  	 * Returns the name.
  	 * @return String
  	 */
  	public String getName() {
 		return name;
 	}
 
 	/***
 	 * Sets the host.
 	 * @param host The host to set
 	 */
 	public void setHostName(String host) {
 		this.hostName = host;
 	}
 
 	/***
 	 * Sets the name.
 	 * @param name The name to set
 	 */
 	public void setName(String name) {
 		this.name = name;
 	}
 
 	/***
 	 * Returns the server.
 	 * @return MBeanServerConnection
 	 */
 	public MBeanServerConnection getServerConnection() {
 		return serverConnection;
 	}
 
 	public void refresh() {
 		try {
 		
 			Set s = serverConnection.queryMBeans(new ObjectName("*:*"), null);
 
 			Iterator it = s.iterator();
 			domains.clear();
 
 			int i = 0;
 			while (it.hasNext()) {
 				ObjectInstance instance = (ObjectInstance) it.next();
 				ObjectName objectName = instance.getObjectName();
 				/***
 				 * Instanciate domains
 				 */
 				DomainComponent domain;
 				String domainName = objectName.getDomain();
 				if (!domains.containsKey(domainName)) {
 					
 					// Create the query that return the MBeans in this comain
 					ComponentName query = ComponentUtil.createDomainMBeanQuery(this, domainName);
 					//System.out.println(query.toString());
 					
 					// Create the domain component
 					domain = new DomainComponent();
 					domain.setQuery(query);
 					domain.setDomainName(domainName);
 					
 					// Cache it
 					domains.put(domainName, domain);
 					
 					// Register the domain component
 					ComponentName componentName = ComponentUtil.createDomainName(this, domainName);
 					getComponentRegistry().registerComponent(domain, componentName);
 				} else {
 					domain = (DomainComponent) domains.get(domainName);
 				}
 
 				// Create and register the MBean Component
 				MBeanInfo info = serverConnection.getMBeanInfo(objectName);
 				MBeanComponent mBean = new MBeanComponent();
 				mBean.setMBeanInfo(info);
 				mBean.setMBeanServerComponent(this);
 				mBean.setMBeanName(objectName);
 								
 				ComponentName componentName = ComponentUtil.createMBeanName(this, domain, objectName);
 				try {
 					getComponentRegistry().registerComponent(mBean, componentName);
 				} catch (ComponentAlreadyExistsException e) {
 					log.warn("Component " + componentName.toString() + " was is already registered in the registry.");
 				}
 				
 			}
 		} catch (Exception e) {
 			e.printStackTrace();
 			mBeans = new MBeanComponent[0];
 
 		}
 	}
 
 	/***
 	 * @see com.gllt.troodon.console.Node#getIconName()
 	 */
 	public Image getIcon() {
 		return Node.ICON_SERVER;
 	}
 
 	/***
 	 * @see com.gllt.troodon.console.Node#getConfigDescriptor()
 	 */
 	public NodeDescriptor getConfigDescriptor() {
 		return new NodeDescriptor(name, "Connection to " + getHostName() + " on host " + getHostName());
 	}
 
 	/* (non-Javadoc)
 	 * @see net.sf.panoptes.view.configurator.Node#acceptsChildren()
 	 */
 	public boolean acceptsChildren() {
 		return false;
 	}
 	
 	
 	public Object invoke(ObjectName objectName, String operation, Object[] params, String[] paramClasses) throws InstanceNotFoundException, MBeanException, ReflectionException, IOException {
 		serverConnection.invoke(objectName, operation, params, paramClasses);
 		return null;
 	}
 }