View Javadoc
   /*
    * JBoss, the OpenSource J2EE webOS
    *
    * Distributable under LGPL license.
    * See terms of license at gnu.org.
    */
   package net.sf.panoptes.model.component.registry;
   
   import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.Hashtable;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  
  import net.sf.panoptes.model.component.Component;
  import net.sf.panoptes.model.node.Node;
  
  import org.apache.log4j.Logger;
  
  /***
   * The registry for component name - component reference mapping. Original code
   * from JBoss.
   * 
   * @see net.sf.panoptes.model.component.IComponent
   * @see net.sf.panoptes.model.component.registry.ComponentEntry
   * 
   */
  public class ComponentRegistry {
  	// Attributes ----------------------------------------------------
  
  	/***
  	 * A map of domain name to another map containing object name canonical
  	 * key properties to registry entries.
  	 * domain -> canonicalKeyProperties -> MBeanEntry
  	 */
  	private Map domainMap = new HashMap();
  
  	/***
  	 * The default domain for this registry
  	 */
  	private String defaultDomain;
  
  	/***
  	 * Sequence number for the MBeanComponent server registration notifications.
  	 */
  	private long registrationNotificationSequence = 1;
  
  	/***
  	 * Sequence number for the MBeanComponent server unregistration notifications.
  	 */
  	private long unregistrationNotificationSequence = 1;
  
  	// Static --------------------------------------------------------
  
  	/***
  	 * The logger
  	 */
  	private static Logger log = Logger.getLogger(ComponentRegistry.class);
  
  	// Constructors --------------------------------------------------
  
  	/***
  	 * Constructs a new ComponentRegistry.<p>
  	 *
  	 */
  	public ComponentRegistry() {
  	}
  
  	// MBeanRegistry Implementation ----------------------------------
  
  	public void registerComponent(Component component, ComponentName name)
  		throws ComponentAlreadyExistsException {
  		boolean registrationDone = true;
  		ComponentName regName = name;
  		try {
  			regName = validateAndQualifyName(regName);
  
  			try {
  
  				ComponentEntry entry = new ComponentEntry(regName, component);
  				add(entry);
  				component.setComponentName(name);
  				component.setComponentRegistry(this);
  				component.init();
  
  				try {
  					long sequence;
  					synchronized (this) {
  						sequence = registrationNotificationSequence++;
  					}
  
  				} catch (Throwable t) {
  					// Problem, remove the mbean from the registry
  					remove(regName);
  
  					throw t;
  				}
  			}
 			// Thrown by the registry
 			catch (ComponentAlreadyExistsException e) {
 				throw e;
 			} catch (Throwable t) {
 				// Something is broken
 				log.error("Unexpected Exception:", t);
 
 				throw t;
 			}
 		} catch (ComponentAlreadyExistsException e) {
 			// It was already registered
 			registrationDone = false;
 			throw e;
 		} catch (Throwable t) {
 			// Some other error
 			registrationDone = false;
 		}
 	}
 
 	public void unregisterMBean(ComponentName name) throws ComponentNotFoundException {
 		ComponentEntry entry = get(name);
 		Object resource = entry.getComponent();
 
 		// It is no longer registered
 		remove(name);
 	}
 
 	public synchronized ComponentEntry get(ComponentName name) throws ComponentNotFoundException {
 		if (name == null)
 			throw new ComponentNotFoundException("null object name");
 
 		// Determine the domain and retrieve its entries
 		String domain = name.getDomain();
 
 		if (domain.length() == 0)
 			domain = defaultDomain;
 
 		String props = name.getCanonicalKeyPropertyListString();
 		Map mbeanMap = (Map) domainMap.get(domain);
 
 		// Retrieve the mbean entry
 		Object o = null;
 		if (null == mbeanMap || null == (o = mbeanMap.get(props)))
 			throw new ComponentNotFoundException(name + " is not registered.");
 
 		// We are done
 		return (ComponentEntry) o;
 	}
 
 	public String getDefaultDomain() {
 		return defaultDomain;
 	}
 
 	public synchronized Node getObjectInstance(ComponentName name) throws ComponentNotFoundException {
 		if (!contains(name))
 			throw new ComponentNotFoundException(name + " not registered.");
 
 		return get(name).getComponent();
 	}
 
 
 	public synchronized boolean contains(ComponentName name) {
 		// null safety check
 		if (name == null)
 			return false;
 
 		// Determine the domain and retrieve its entries
 		String domain = name.getDomain();
 
 		if (domain.length() == 0)
 			domain = defaultDomain;
 
 		String props = name.getCanonicalKeyPropertyListString();
 		Map mbeanMap = (Map) domainMap.get(domain);
 
 		// Return the result
 		return (null != mbeanMap && mbeanMap.containsKey(props));
 	}
 
 	public synchronized int getSize() {
 		int retval = 0;
 
 		for (Iterator iterator = domainMap.values().iterator(); iterator.hasNext();) {
 			retval += ((Map) iterator.next()).size();
 		}
 		return retval;
 	}
 
 	public synchronized List findEntries(ComponentName pattern) {
 		ArrayList retval = new ArrayList();
 
 		// There are a couple of shortcuts we can employ to make this a
 		// bit faster - they're commented.
 
 		// First, if pattern == null or pattern.getCanonicalName() == "*:*" we want the
 		// set of all MBeans.
 		if (pattern == null || pattern.getCanonicalName().equals("*:*")) {
 			for (Iterator domainIter = domainMap.values().iterator(); domainIter.hasNext();) {
 				for (Iterator mbeanIter = ((Map) domainIter.next()).values().iterator(); mbeanIter.hasNext();) {
 					retval.add(mbeanIter.next());
 				}
 			}
 		}
 		// Next, if !pattern.isPattern() then we are doing a simple get (maybe defaultDomain).
 		else if (!pattern.isPattern()) {
 			// simple get
 			try {
 				retval.add(get(pattern));
 			} catch (ComponentNotFoundException e) {
 				// we don't care
 			}
 		}
 		// Now we have to do a brute force, oh well.
 		else {
 			String patternDomain = pattern.getDomain();
 			if (patternDomain.length() == 0)
 				patternDomain = defaultDomain;
 			boolean patternIsPropertyPattern = true; pattern.isPropertyPattern();
 			String patternCanonicalKPS = pattern.getCanonicalKeyPropertyListString();
 			Object[] propkeys = null;
 			Object[] propvals = null;
 
 			// prebuild arrays of keys and values for quick comparison
 			// when isPropertyPattern().
 			if (patternIsPropertyPattern) {
 				Hashtable patternKPList = pattern.getKeyPropertyList();
 				propkeys = new Object[patternKPList.size()];
 				propvals = new Object[propkeys.length];
 
 				int i = 0;
 				for (Iterator iterator = patternKPList.entrySet().iterator(); iterator.hasNext(); i++) {
 					Map.Entry mapEntry = (Map.Entry) iterator.next();
 					propkeys[i] = mapEntry.getKey();
 					propvals[i] = mapEntry.getValue();
 				}
 			}
 
 			// Here we go, step through every domain and see if our pattern matches before optionally checking
 			// each ObjectName's properties for a match.
 			for (Iterator domainIter = domainMap.entrySet().iterator(); domainIter.hasNext();) {
 				Map.Entry mapEntry = (Map.Entry) domainIter.next();
 				if (domainMatches((String) mapEntry.getKey(), patternDomain)) {
 					// yes it's a label, sue me.
 					CHOOSE_MBEAN : for (
 						Iterator mbeanIter = ((Map) mapEntry.getValue()).values().iterator(); mbeanIter.hasNext();) {
 						ComponentEntry entry = (ComponentEntry) mbeanIter.next();
 						ComponentName name = entry.getComponentName();
 
 						if (patternIsPropertyPattern) {
 							// another shortcut - we only compare the key properties list of the registered MBeanComponent
 							// if properties have been specifed in the pattern (i.e. something other than just "*")
 							if (propkeys.length > 0) {
 								Hashtable nameKPList = name.getKeyPropertyList();
 
 								for (int i = 0; i < propkeys.length; i++) {
 									// skip the current MBeanComponent if there isn't a match
 									if (!propvals[i].equals(nameKPList.get(propkeys[i]))) {
 										continue CHOOSE_MBEAN;
 									}
 								}
 							}
 							retval.add(entry);
 						} else {
 							// Ok, it's a like-for-like comparison of the keyProperties.
 							// Knowing how our implementation of ObjectName works, it's *much*
 							// faster to compare the canonicalKeyProperties strings than it
 							// is to compare the two hashtables.
 							if (patternCanonicalKPS.equals(name.getCanonicalKeyPropertyListString())) {
 								retval.add(entry);
 							}
 						}
 					}
 				}
 			}
 		}
 
 		return retval;
 	}
 
 	/***
 	 * Compare the src and pat strings where ? and * chars are significant.
 	 *
 	 * @author  <a href="mailto:trevor@protocool.com">Trevor Squires</a>.
 	 */
 	protected boolean domainMatches(String src, String pat) {
 		if (src.equals("*")) // no point doing more that we have to...
 			{
 			return true;
 		}
 		return domainMatches(src.toCharArray(), 0, pat.toCharArray(), 0);
 	}
 
 	/***
 	 * Compare the src and pat char arrays where ? and * chars are significant.
 	 *
 	 * I arrived at this solution after quite a bit of trial and error - it's
 	 * all a bit interwoven.  Obviously I'm no good at parsers and there must
 	 * be a clearer or more elegant way to do this.  I'm suitably in awe of
 	 * the perl regex hackers now.
 	 *
 	 * @author  <a href="mailto:trevor@protocool.com">Trevor Squires</a>.
 	 */
 	protected boolean domainMatches(char[] src, int spos, char[] pat, int ppos) {
 		int slen = src.length;
 		int plen = pat.length;
 
 		while (ppos < plen) {
 			char c = pat[ppos++];
 			if ('?' == c) {
 				// eat a src character and make sure we're not
 				// already at the end
 				if (spos++ == slen) {
 					return false;
 				}
 			} else if ('*' == c) {
 				if (ppos == plen) // shortcut - * at the end of the pattern
 					{
 					return true;
 				}
 
 				// hammer the src chars recursively until we
 				// get a match or we drop off the end of src
 				do {
 					if (domainMatches(src, spos, pat, ppos)) {
 						return true;
 					}
 				} while (++spos < slen);
 			} else if (spos == slen || c != src[spos++]) {
 				return false;
 			}
 		}
 		// fell through with no falses so make sure all of src was examined
 		return (spos == slen);
 	}
 
 	/***
 	 * Adds an MBeanComponent entry<p>
 	 *
 	 * WARNING: The object name should be fully qualified.
 	 *
 	 * @param entry the MBeanComponent entry to add
 	 * @exception InstanceAlreadyExistsException when the MBeanComponent's object name
 	 *            is already registered
 	 */
 	protected synchronized void add(ComponentEntry entry) throws ComponentAlreadyExistsException {
 		// Determine the components's name and properties
 		ComponentName name = entry.getComponentName();
 		String domain = name.getDomain();
 		String props = name.getCanonicalKeyPropertyListString();
 
 		// Create a properties -> entry map if we don't have one
 		Map mbeanMap = (Map) domainMap.get(domain);
 		if (mbeanMap == null) {
 			mbeanMap = new HashMap();
 			domainMap.put(domain, mbeanMap);
 		}
 
 		// Make sure we aren't already registered
 		if (mbeanMap.get(props) != null)
 			throw new ComponentAlreadyExistsException(name + " already registered.");
 
 		// Ok, we are registered
 		mbeanMap.put(props, entry);
 	}
 
 	/***
 	 * Removes an MBeanComponent entry
 	 *
 	 * WARNING: The object name should be fully qualified.
 	 *
 	 * @param name the object name of the entry to remove
 	 * @exception InstanceNotFoundException when the object name is not
 	 *            registered
 	 */
 	protected synchronized void remove(ComponentName name) throws ComponentNotFoundException {
 		// Determine the MBeanComponent's name and properties
 		String domain = name.getDomain();
 		String props = name.getCanonicalKeyPropertyListString();
 		Map mbeanMap = (Map) domainMap.get(domain);
 
 		// Remove the entry, raise an exception when it didn't exist
 		if (null == mbeanMap || null == mbeanMap.remove(props))
 			throw new ComponentNotFoundException(name + " not registered.");
 	}
 
 	/***
 	 * Validates and qualifies an MBeanComponent<p>
 	 *
 	 * Validates the name is not a pattern.<p>
 	 *
 	 * Adds the default domain if no domain is specified.<p>
 	 *
 	 * Checks the name is not in the reserved domain JMImplementation when
 	 * the magicToken is not {@link org.jboss.mx.server.ServerConstants#JMI_DOMAIN JMI_DOMAIN}
 	 *
 	 * @param name the name to validate
 	 * @param magicToken used to get access to the reserved domain
 	 * @return the original name or the name prepended with the default domain
 	 *         if no domain is specified.
 	 * @exception RuntimeOperationException containing an
 	 *            IllegalArgumentException for a problem with the name
 	 */
 	protected ComponentName validateAndQualifyName(ComponentName name) {
 		// Check for qualification
 		ComponentName result = qualifyName(name);
 		return result;
 	}
 
 	protected ComponentName qualifyName(ComponentName name) {
 		try {
 			if (name.getDomain().length() == 0)
 				return new ComponentName(defaultDomain + ":" + name.getCanonicalKeyPropertyListString());
 			else
 				return name;
 		} catch (MalformedComponentNameException e) {
 			throw new IllegalArgumentException(e.toString());
 		}
 	}
 
 }