repositorysupport.java

JAVA的一些源码 JAVA2 STANDARD EDITION DEVELOPMENT KIT 5.0

/*
 * @(#)RepositorySupport.java	1.65 03/12/19
 * 
 * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */

package com.sun.jmx.mbeanserver;


// java import
import java.util.Hashtable;
import java.util.Enumeration;
import java.util.Set;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Vector;

// RI import
import javax.management.* ; 
import com.sun.jmx.defaults.ServiceName;
import com.sun.jmx.trace.Trace;

/**
 * The RepositorySupport  implements the Repository interface.
 * This repository does not support persistency.
 *
 * @since 1.5
 */
public class RepositorySupport  implements  Repository { 
    
    // Private fields -------------------------------------------->

    /**
     * An object name for query describing the whole set of mbeans.
     * Optimization helper for queries.
     */
    private final static ObjectName _WholeWordQueryObjectName;
    static {
	try {
	    _WholeWordQueryObjectName = new ObjectName("*:*");
	} catch (MalformedObjectNameException e) {
	    throw new UnsupportedOperationException(e.getMessage());
	}
    }
    
    /**
     * two int utilities to minimize wildmatch method stack frame overhead
     * during recursions.
     */
    private static int _slen;
    private static int _plen;

    /**
     * The structure for storing the objects is very basic .
     * A Hashtable is used for storing the different domains
     * For each domain, a hashtable contains the instances with
     * canonical key property list string as key and named object
     * aggregated from given object name and mbean instance as value.
     */
    private final Hashtable domainTb;
    
    /**
     * Number of elements contained in the Repository
     */
    private int nbElements = 0;
  
    /**
     * Domain name of the server the repository is attached to.
     * It is quicker to store the information in the repository rather
     * than querying the framework each time the info is required.
     */
    private final String domain;
    
    /** The name of this class to be used for tracing */
    private final static String dbgTag = "Repository";

    // Private fields <=============================================
    

    // Private methods --------------------------------------------->

    // TRACES & DEBUG
    //---------------
    
    private final static boolean isTraceOn() {
	return Trace.isSelected(Trace.LEVEL_TRACE, Trace.INFO_MBEANSERVER);
    }
    
    private final static void trace(String clz, String func, String info) {
	Trace.send(Trace.LEVEL_TRACE, Trace.INFO_MBEANSERVER, clz, func, 
		   info);
    }
    
    private final static void trace(String func, String info) {
        trace(dbgTag, func, info);
    }
    
    private final static boolean isDebugOn() {
        return Trace.isSelected(Trace.LEVEL_DEBUG, Trace.INFO_MBEANSERVER);
    }
    
    private final static void debug(String clz, String func, String info) {
        Trace.send(Trace.LEVEL_DEBUG, Trace.INFO_MBEANSERVER, clz, func, 
		   info);
    }
    
    private final static void debug(String func, String info) {
        debug(dbgTag, func, info);
    }
    
    /* This class is used to match an ObjectName against a pattern. */
    private final static class ObjectNamePattern {
        private final char[]   domain;
        private final String[] keys;
        private final String[] values;
        private final String   properties;
        private final boolean  isPropertyPattern;
        
        /**
         * The ObjectName pattern against which ObjectNames are matched.
         **/
        public  final  ObjectName pattern;
        
        /**
         * Builds a new ObjectNamePattern object from an ObjectName pattern.
         * @param pattern The ObjectName pattern under examination.
         **/
        public ObjectNamePattern(ObjectName pattern) {
            this(pattern.isPattern(),pattern.getDomain(),
                 pattern.isPropertyPattern(),
                 pattern.getCanonicalKeyPropertyListString(),
                 pattern.getKeyPropertyList(),pattern);
        }

        /**
         * Builds a new ObjectNamePattern object from an ObjectName pattern
         * constituents.
         * @param domainPattern pattern.isPattern().
         * @param domain pattern.getDomain().
         * @param propertyPattern pattern.isPropertyPattern().
         * @param canonicalProps pattern.getCanonicalKeyPropertyListString()
         * @param keyPropertyList pattern.getKeyPropertyList()
         * @param pattern The ObjectName pattern under examination.
         **/
        ObjectNamePattern(boolean domainPattern, String domain, 
                          boolean propertyPattern, String canonicalProps,
                          Hashtable keyPropertyList, ObjectName pattern) {
            final int len = (keyPropertyList==null?0:keyPropertyList.size());
            final Enumeration e = 
                (keyPropertyList==null?null:keyPropertyList.keys());
            this.domain = (domain == null?null:domain.toCharArray());
            this.keys   = new String[len];
            this.values = new String[len];
            for (int i = 0 ; i < len ; i++ ) {
                final String k = (String)e.nextElement();
                keys[i]   = k;
                values[i] = (String)keyPropertyList.get(k);
            }
            this.properties = canonicalProps;
            this.isPropertyPattern = propertyPattern;
            this.pattern = pattern;
        }

        /**
         * Return true if the given ObjectName matches the ObjectName pattern
         * for which this object has been built.
         * WARNING: domain name is not considered here because it is supposed
         *          not to be wildcard when called. PropertyList is also 
	 *          supposed not to be zero-length.
         * @param name The ObjectName we want to match against the pattern.
         * @return true if <code>name</code> matches the pattern.
         **/
        public boolean matchKeys(ObjectName name) {
            if (isPropertyPattern) {
                // Every property inside pattern should exist in name 
                for (int i= keys.length -1; i >= 0 ; i--) {

                    // find value in given object name for key at current 
		    // index in receiver
                    String v = name.getKeyProperty(keys[i]);

                    // did we find a value for this key ?
                    if (v == null) return false; 
                    
                    // if this property is ok (same key, same value), 
		    // go to next
                    if (v.equals(values[i])) continue; 
                    return false;
                }
                return true;
            } else {
                if (keys.length != name.getKeyPropertyList().size()) 
		    return false;
                final String p1 = name.getCanonicalKeyPropertyListString();
                final String p2 = properties;
                // if (p1 == null) return (p2 == null);
                // if (p2 == null) return p1.equals("");
                return (p1.equals(p2));
            }
        }
    }

    /**
     * Add all the matching objects from the given hashtable in the 
     * result set for the given ObjectNamePattern
     * Do not check whether the domains match (only check for matching
     * key property lists - see <i>matchKeys()</i>)
     **/
    private final void addAllMatching(final Hashtable moiTb, final Set result,
				      final ObjectNamePattern pattern) {
	synchronized (moiTb) {
	    for (Enumeration e = moiTb.elements(); e.hasMoreElements();) {   
		final NamedObject no = (NamedObject) e.nextElement();
                final ObjectName on = no.getName();

		// if all couples (property, value) are contained 
		if (pattern.matchKeys(on)) result.add(no);
	    }
	}
    }
    
    private final void addNewDomMoi(final Object object, final String dom, 
				    final ObjectName name) {
	final Hashtable moiTb= new Hashtable();
	domainTb.put(dom, moiTb);
	moiTb.put(name.getCanonicalKeyPropertyListString(), 
		  new NamedObject(name, object));
	nbElements++;
    }
    
    /*
     * Tests whether string s is matched by pattern p.
     * Supports "?", "*" each of which may be escaped with "\";
     * Not yet supported: internationalization; "\" inside brackets.<P>
     * Wildcard matching routine by Karl Heuer.  Public Domain.<P>
     */  
    private static boolean wildmatch(char[] s, char[] p, int si, int pi) {
        char c;
	// Be careful: this is dangerous: it works because wildmatch
	// is protected by a synchronized block on domainTb
        _slen = s.length;
        _plen = p.length;
	// end of comment.

        while (pi < _plen) {            // While still string
            c = p[pi++];
            if (c == '?') {
                if (++si > _slen) return false;
            } else if (c == '*') {        // Wildcard
                if (pi >= _plen) return true;
                do {
                    if (wildmatch(s,p,si,pi)) return true;
                } while (++si < _slen);
                return false;
            } else {
                if (si >= _slen || c != s[si++]) return false;
            }
        }
        return (si == _slen);
    }

    /**
     * Retrieves the named object contained in repository
     * from the given objectname.
     */
    private NamedObject retrieveNamedObject(ObjectName name) {

        // No patterns inside reposit
	if (name.isPattern() == true) return null;

	// Extract the domain name.       
	String dom= name.getDomain().intern();

        // Default domain case
	if (dom.length() == 0) {
            dom = domain;
        }

        Object tmp_object = domainTb.get(dom);
	if (tmp_object == null) {
            return null; // No domain containing registered object names
        }

        // If name exists in repository, we will get it now 
	Hashtable moiTb= (Hashtable) tmp_object;
            
        Object o = moiTb.get(name.getCanonicalKeyPropertyListString());
        if (o != null ) {
            return (NamedObject) o;
        }
        else return null;
    }

    // Private methods <=============================================

    // Protected methods --------------------------------------------->
    // Protected methods <=============================================


    // Public methods --------------------------------------------->

    /**
     * Construct a new repository with the given default domain.
     *
     */
    public RepositorySupport(String domain) {
	domainTb= new Hashtable(5);
        
	if (domain != null && domain.length() != 0) 
	    this.domain = domain;
	else 
	    this.domain = ServiceName.DOMAIN;

        // Creates an new hastable for the default domain
	domainTb.put(this.domain.intern(), new Hashtable());

	// ------------------------------ 
	// ------------------------------
    }	
    
    /**
     * The purpose of this method is to provide a unified way to provide 
     * whatever configuration information is needed by the specific 
     * underlying implementation of the repository.
     *
     * @param configParameters An list containing the configuration 
     *        parameters needed by the specific Repository Service 
     *        implementation.
     */
    public void setConfigParameters(ArrayList configParameters) {
	return;
    } 

    /**
     * Returns the list of domains in which any MBean is currently
     * registered.
     *
     * @since.unbundled JMX RI 1.2