jeapplicationmbean.java

这是个爬虫和lucece相结合最好了

/*-
* See the file LICENSE for redistribution information.
*
* Copyright (c) 2002-2005
*      Sleepycat Software.  All rights reserved.
*
* $Id: JEApplicationMBean.java 4644 2006-09-20 22:40:21Z paul_jack $
*/

package org.archive.util;

import java.lang.reflect.Constructor;
import java.util.List;

import javax.management.Attribute;
import javax.management.AttributeList;
import javax.management.AttributeNotFoundException;
import javax.management.DynamicMBean;
import javax.management.InvalidAttributeValueException;
import javax.management.MBeanAttributeInfo;
import javax.management.MBeanConstructorInfo;
import javax.management.MBeanException;
import javax.management.MBeanInfo;
import javax.management.MBeanNotificationInfo;
import javax.management.MBeanOperationInfo;

import com.sleepycat.je.DatabaseException;
import com.sleepycat.je.Environment;

/**
 * JEApplicationMBean is an example of how a JE application can incorporate JE
 * monitoring into its existing MBean.  It may be installed as is, or used as a
 * starting point for building a MBean which includes JE support.
 * <p>
 * JE management is divided between the JEApplicationMBean class and
 * JEMBeanHelper class. JEApplicationMBean contains an instance of
 * JEMBeanHelper, which knows about JE attributes, operations and
 * notifications. JEApplicationMBean itself has the responsibility of
 * configuring, opening and closing the JE environment along with any other
 * resources used by the application, and maintains a
 * com.sleepycat.je.Environment handle.
 * <p>
 * The approach taken for accessing the environment is an application specific
 * choice. Some of the salient considerations are:
 * <ul>
 * <li>Applications may open one or many Environment objects per process 
 * against a given environment.</li> 
 *
 * <li>All Environment handles reference the same underlying JE environment
 * implementation object.</li>

 * <li> The first Environment object instantiated in the process does the real
 * work of configuring and opening the environment. Follow-on instantiations of
 * Environment merely increment a reference count. Likewise,
 * Environment.close() only does real work when it's called by the last
 * Environment object in the process. </li>
 * </ul>
 * <p>
 * Another MBean approach for environment access can be seen in
 * com.sleepycat.je.jmx.JEMonitor. That MBean does not take responsibility for
 * opening and closing environments, and can only operate against already-open
 * environments.
 * <p>This bean was copied from bdb je 2.0 source and modified so could pass
 * in and monitor an environment created externally.  Also added toString
 * versions of the locks and stats calls since the objects don't seem to
 * make it over the RMI divide (Not serializable.  St.Ack
 */

public class JEApplicationMBean implements DynamicMBean {

    private static final String DESCRIPTION = 
        "A MBean for an application which uses JE. Provides open and close " +
        "operations which configure and open a JE environment as part of the "+
        "applications's resources. Also supports general JE monitoring.";

    private MBeanInfo mbeanInfo;    // this MBean's visible interface.
    private JEMBeanHelper jeHelper; // gets JE management interface
    private Environment targetEnv;  // saved environment handle

    /**
     * This MBean provides an open operation to open the JE environment.
     */
    public  static final String OP_OPEN = "openJE";

    /**
     * This MBean provides a close operation to release the JE environment.
     * Note that environments must be closed to release resources.
     */
    public static final String OP_CLOSE = "closeJE";

    /**
     * Instantiate a JEApplicationMBean
     *
     * @param env Environment to use.  Externally managed.
     * @throws DatabaseException
     */
    public JEApplicationMBean(Environment env) throws DatabaseException {
        this.targetEnv = env;
        jeHelper = new JEMBeanHelper(env.getConfig(), env.getHome(), true);
        resetMBeanInfo();
    }

    /**
     * @see DynamicMBean#getAttribute
     */
    public Object getAttribute(String attributeName)
        throws AttributeNotFoundException,
               MBeanException {
        
    	return jeHelper.getAttribute(targetEnv, attributeName);
    }

    /**
     * @see DynamicMBean#setAttribute
     */
    public void setAttribute(Attribute attribute)
        throws AttributeNotFoundException,
               InvalidAttributeValueException {
               
        jeHelper.setAttribute(targetEnv, attribute);
    }

    /**
     * @see DynamicMBean#getAttributes
     */
    public AttributeList getAttributes(String[] attributes) {

        /* Sanity checking. */
	if (attributes == null) {
	    throw new IllegalArgumentException("Attributes cannot be null");
	}

        /* Get each requested attribute. */
        AttributeList results = new AttributeList();
        for (int i = 0; i < attributes.length; i++) {
            try {
                String name = attributes[i];
                Object value = jeHelper.getAttribute(targetEnv, name);
                results.add(new Attribute(name, value));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return results;
    }

    /**
     * @see DynamicMBean#setAttributes
     */
    public AttributeList setAttributes(AttributeList attributes) {

        /* Sanity checking. */
	if (attributes == null) {
	    throw new IllegalArgumentException("attribute list can't be null");
	}

        /* Set each attribute specified. */
	AttributeList results = new AttributeList();
        for (int i = 0; i < attributes.size(); i++) {
            Attribute attr = (Attribute) attributes.get(i);
            try {
                /* Set new value. */
                jeHelper.setAttribute(targetEnv, attr);

                /* 
                 * Add the name and new value to the result list. Be sure
                 * to ask the MBean for the new value, rather than simply
                 * using attr.getValue(), because the new value may not
                 * be same if it is modified according to the JE 
                 * implementation.
                 */
                String name = attr.getName();
                Object newValue = jeHelper.getAttribute(targetEnv, name); 
                results.add(new Attribute(name, newValue));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return results;
    }

    /**
     * @see DynamicMBean#invoke
     */
    public Object invoke(String actionName,
                         Object[] params,
                         String[] signature)
        throws MBeanException {

        Object result = null;
        
        if (actionName == null) {
            throw new IllegalArgumentException("actionName cannot be null");
        }
// Don't allow opening and closing of environment.  It was created
// externally.  St.Ack
//        
//        if (actionName.equals(OP_OPEN)) {
//            openEnvironment();
//            return null;
//        } else if (actionName.equals(OP_CLOSE)) {
//            closeEnvironment();
//            return null;
//        } else {
            result = jeHelper.invoke(targetEnv, actionName, params, signature);
//        }

        return result;
    }

    /**
     * @see DynamicMBean#getMBeanInfo
     */
    public MBeanInfo getMBeanInfo() {
	return mbeanInfo;
    }

    /**
     * Create the available management interface for this environment.
     * The attributes and operations available vary according to
     * environment configuration.
     *
     */
    private synchronized void resetMBeanInfo() {
        
        /*
         * Get JE attributes, operation and notification information
         * from JEMBeanHelper. An application may choose to add functionality
         * of its own when constructing the MBeanInfo.
         */
        
        /* Attributes. */
        List<MBeanAttributeInfo> attributeList =  jeHelper.getAttributeList(targetEnv);
        MBeanAttributeInfo [] attributeInfo = 
            new MBeanAttributeInfo[attributeList.size()];
        attributeList.toArray(attributeInfo);

        /* Constructors. */
        Constructor [] constructors = this.getClass().getConstructors();
        MBeanConstructorInfo [] constructorInfo =
            new MBeanConstructorInfo[constructors.length];
        for (int i = 0; i < constructors.length; i++) {
            constructorInfo[i] =
                new MBeanConstructorInfo(this.getClass().getName(),
                                         constructors[i]);
        }

        /* Operations. */

        /* 
         * Get the list of operations available from the jeHelper. Then add
         * an open and close operation.
         */
        List<MBeanOperationInfo> operationList = jeHelper.getOperationList(targetEnv);
        /* Don't allow opening or closing remotely.
        if (targetEnv == null) {
            operationList.add(
             new MBeanOperationInfo(OP_OPEN,
                                    "Configure and open the JE environment.",
                                    new MBeanParameterInfo[0], // no params
                                    "java.lang.Boolean",
                                    MBeanOperationInfo.ACTION_INFO));
        } else {
            operationList.add(
             new MBeanOperationInfo(OP_CLOSE,
                                    "Close the JE environment.",
                                    new MBeanParameterInfo[0], // no params
                                    "void",
                                    MBeanOperationInfo.ACTION_INFO));
        }
        */
        
        MBeanOperationInfo [] operationInfo =
            new MBeanOperationInfo[operationList.size()];
        operationList.toArray(operationInfo);

        /* Notifications. */
        MBeanNotificationInfo [] notificationInfo =
            jeHelper.getNotificationInfo(targetEnv);

        /* Generate the MBean description. */
        mbeanInfo = new MBeanInfo(this.getClass().getName(),
                                  DESCRIPTION,
                                  attributeInfo,
                                  constructorInfo,
                                  operationInfo,
                                  notificationInfo);
    }

    /**
     * Open a JE environment using the configuration specified through
     * MBean attributes and recorded within the JEMBeanHelper. 
     */
//    private  void openEnvironment() 
//        throws MBeanException {
//
//        try {
//            if (targetEnv == null) {
//                /* 
//                 * The environment configuration has been set through
//                 * mbean attributes managed by the JEMBeanHelper.
//                 */
//                targetEnv =
//                    new Environment(jeHelper.getEnvironmentHome(),
//                                    jeHelper.getEnvironmentOpenConfig());
//                resetMBeanInfo();
//            }
//        } catch (DatabaseException e) {
//            throw new MBeanException(e);
//        }
//    }

    /**
     * Release the environment handle contained within the MBean to properly
     * release resources.
     */
//    private void closeEnvironment()
//        throws MBeanException {
//
//        try {
//            if (targetEnv != null) {
//                targetEnv.close();
//                targetEnv = null;
//                resetMBeanInfo();
//            }
//        } catch (DatabaseException e) {
//            throw new MBeanException(e);
//        }
//    }
}