/*

 * 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 javax.management.monitor;

import static com.sun.jmx.defaults.JmxProperties.MONITOR_LOGGER;

import java.util.logging.Level;

import javax.management.ObjectName;

import javax.management.MBeanNotificationInfo;

import static javax.management.monitor.Monitor.NumericalType.*;

import static javax.management.monitor.MonitorNotification.*;

/**

 * Defines a monitor MBean designed to observe the values of a counter

 * attribute.

 *

 * <P> A counter monitor sends a {@link

 * MonitorNotification#THRESHOLD_VALUE_EXCEEDED threshold

 * notification} when the value of the counter reaches or exceeds a

 * threshold known as the comparison level.  The notify flag must be

 * set to <CODE>true</CODE>.

 *

 * <P> In addition, an offset mechanism enables particular counting

 * intervals to be detected.  If the offset value is not zero,

 * whenever the threshold is triggered by the counter value reaching a

 * comparison level, that comparison level is incremented by the

 * offset value.  This is regarded as taking place instantaneously,

 * that is, before the count is incremented.  Thus, for each level,

 * the threshold triggers an event notification every time the count

 * increases by an interval equal to the offset value.

 *

 * <P> If the counter can wrap around its maximum value, the modulus

 * needs to be specified.  The modulus is the value at which the

 * counter is reset to zero.

 *

 * <P> If the counter difference mode is used, the value of the

 * derived gauge is calculated as the difference between the observed

 * counter values for two successive observations.  If this difference

 * is negative, the value of the derived gauge is incremented by the

 * value of the modulus.  The derived gauge value (V[t]) is calculated

 * using the following method:

 *

 * <UL>

 * <LI>if (counter[t] - counter[t-GP]) is positive then

 * V[t] = counter[t] - counter[t-GP]

 * <LI>if (counter[t] - counter[t-GP]) is negative then

 * V[t] = counter[t] - counter[t-GP] + MODULUS

 * </UL>

 *

 * This implementation of the counter monitor requires the observed

 * attribute to be of the type integer (<CODE>Byte</CODE>,

 * <CODE>Integer</CODE>, <CODE>Short</CODE>, <CODE>Long</CODE>).

 *

 *

 * @since 1.5

 */

public class CounterMonitor extends Monitor implements CounterMonitorMBean {

    /*

     * ------------------------------------------

     *  PACKAGE CLASSES

     * ------------------------------------------

     */

    static class CounterMonitorObservedObject extends ObservedObject {

        public CounterMonitorObservedObject(ObjectName observedObject) {

            super(observedObject);

        }

        public final synchronized Number getThreshold() {

            return threshold;

        }

        public final synchronized void setThreshold(Number threshold) {

            this.threshold = threshold;

        }

        public final synchronized Number getPreviousScanCounter() {

            return previousScanCounter;

        }

        public final synchronized void setPreviousScanCounter(

                                                  Number previousScanCounter) {

            this.previousScanCounter = previousScanCounter;

        }

        public final synchronized boolean getModulusExceeded() {

            return modulusExceeded;

        }

        public final synchronized void setModulusExceeded(

                                                 boolean modulusExceeded) {

            this.modulusExceeded = modulusExceeded;

        }

        public final synchronized Number getDerivedGaugeExceeded() {

            return derivedGaugeExceeded;

        }

        public final synchronized void setDerivedGaugeExceeded(

                                                 Number derivedGaugeExceeded) {

            this.derivedGaugeExceeded = derivedGaugeExceeded;

        }

        public final synchronized boolean getDerivedGaugeValid() {

            return derivedGaugeValid;

        }

        public final synchronized void setDerivedGaugeValid(

                                                 boolean derivedGaugeValid) {

            this.derivedGaugeValid = derivedGaugeValid;

        }

        public final synchronized boolean getEventAlreadyNotified() {

            return eventAlreadyNotified;

        }

        public final synchronized void setEventAlreadyNotified(

                                               boolean eventAlreadyNotified) {

            this.eventAlreadyNotified = eventAlreadyNotified;

        }

        public final synchronized NumericalType getType() {

            return type;

        }

        public final synchronized void setType(NumericalType type) {

            this.type = type;

        }

        private Number threshold;

        private Number previousScanCounter;

        private boolean modulusExceeded;

        private Number derivedGaugeExceeded;

        private boolean derivedGaugeValid;

        private boolean eventAlreadyNotified;

        private NumericalType type;

    }

    /*

     * ------------------------------------------

     *  PRIVATE VARIABLES

     * ------------------------------------------

     */

    /**

     * Counter modulus.

     * <BR>The default value is a null Integer object.

     */

    private Number modulus = INTEGER_ZERO;

    /**

     * Counter offset.

     * <BR>The default value is a null Integer object.

     */

    private Number offset = INTEGER_ZERO;

    /**

     * Flag indicating if the counter monitor notifies when exceeding

     * the threshold.  The default value is set to

     * <CODE>false</CODE>.

     */

    private boolean notify = false;

    /**

     * Flag indicating if the counter difference mode is used.  If the

     * counter difference mode is used, the derived gauge is the

     * difference between two consecutive observed values.  Otherwise,

     * the derived gauge is directly the value of the observed

     * attribute.  The default value is set to <CODE>false</CODE>.

     */

    private boolean differenceMode = false;

    /**

     * Initial counter threshold.  This value is used to initialize

     * the threshold when a new object is added to the list and reset

     * the threshold to its initial value each time the counter

     * resets.

     */

    private Number initThreshold = INTEGER_ZERO;

    private static final String[] types = {

        RUNTIME_ERROR,

        OBSERVED_OBJECT_ERROR,

        OBSERVED_ATTRIBUTE_ERROR,

        OBSERVED_ATTRIBUTE_TYPE_ERROR,

        THRESHOLD_ERROR,

        THRESHOLD_VALUE_EXCEEDED

    };

    private static final MBeanNotificationInfo[] notifsInfo = {

        new MBeanNotificationInfo(

            types,

            "javax.management.monitor.MonitorNotification",

            "Notifications sent by the CounterMonitor MBean")

    };

    /*

     * ------------------------------------------

     *  CONSTRUCTORS

     * ------------------------------------------

     */

    /**

     * Default constructor.

     */

    public CounterMonitor() {

    }

    /*

     * ------------------------------------------

     *  PUBLIC METHODS

     * ------------------------------------------

     */

    /**

     * Starts the counter monitor.

     */

    public synchronized void start() {

        if (isActive()) {

            MONITOR_LOGGER.logp(Level.FINER, CounterMonitor.class.getName(),

                    "start", "the monitor is already active");

            return;

        }

        // Reset values.

        //

        for (ObservedObject o : observedObjects) {

            final CounterMonitorObservedObject cmo =

                (CounterMonitorObservedObject) o;

            cmo.setThreshold(initThreshold);

            cmo.setModulusExceeded(false);

            cmo.setEventAlreadyNotified(false);

            cmo.setPreviousScanCounter(null);

        }

        doStart();

    }

    /**

     * Stops the counter monitor.

     */

    public synchronized void stop() {

        doStop();

    }

    // GETTERS AND SETTERS

    //--------------------

    /**

     * Gets the derived gauge of the specified object, if this object is

     * contained in the set of observed MBeans, or <code>null</code> otherwise.

     *

     * @param object the name of the object whose derived gauge is to

     * be returned.

     *

     * @return The derived gauge of the specified object.

     *

     */

    public synchronized Number getDerivedGauge(ObjectName object) {

        return (Number) super.getDerivedGauge(object);

    }

    /**

     * Gets the derived gauge timestamp of the specified object, if

     * this object is contained in the set of observed MBeans, or

     * <code>0</code> otherwise.

     *

     * @param object the name of the object whose derived gauge

     * timestamp is to be returned.

     *

     * @return The derived gauge timestamp of the specified object.

     *

     */

    public synchronized long getDerivedGaugeTimeStamp(ObjectName object) {

        return super.getDerivedGaugeTimeStamp(object);

    }

    /**

     * Gets the current threshold value of the specified object, if

     * this object is contained in the set of observed MBeans, or

     * <code>null</code> otherwise.

     *

     * @param object the name of the object whose threshold is to be

     * returned.

     *

     * @return The threshold value of the specified object.

     *

     */

    public synchronized Number getThreshold(ObjectName object) {

        final CounterMonitorObservedObject o =

            (CounterMonitorObservedObject) getObservedObject(object);

        if (o == null)

            return null;

        // If the counter that is monitored rolls over when it reaches a

        // maximum value, then the modulus value needs to be set to that

        // maximum value. The threshold will then also roll over whenever

        // it strictly exceeds the modulus value. When the threshold rolls

        // over, it is reset to the value that was specified through the

        // latest call to the monitor's setInitThreshold method, before

        // any offsets were applied.

        //

        if (offset.longValue() > 0L &&

            modulus.longValue() > 0L &&

            o.getThreshold().longValue() > modulus.longValue()) {

            return initThreshold;

        } else {

            return o.getThreshold();

        }

    }

    /**

     * Gets the initial threshold value common to all observed objects.

     *

     * @return The initial threshold.

     *

     * @see #setInitThreshold

     *

     */

    public synchronized Number getInitThreshold() {

        return initThreshold;

    }

    /**

     * Sets the initial threshold value common to all observed objects.

     *

     * <BR>The current threshold of every object in the set of

     * observed MBeans is updated consequently.

     *

     * @param value The initial threshold value.

     *

     * @exception IllegalArgumentException The specified

     * threshold is null or the threshold value is less than zero.

     *

     * @see #getInitThreshold

     *

     */

    public synchronized void setInitThreshold(Number value)

        throws IllegalArgumentException {

        if (value == null) {

            throw new IllegalArgumentException("Null threshold");

        }

        if (value.longValue() < 0L) {

            throw new IllegalArgumentException("Negative threshold");

        }

        if (initThreshold.equals(value))

            return;

        initThreshold = value;

        // Reset values.

        //

        int index = 0;

        for (ObservedObject o : observedObjects) {

            resetAlreadyNotified(o, index++, THRESHOLD_ERROR_NOTIFIED);

            final CounterMonitorObservedObject cmo =

                (CounterMonitorObservedObject) o;

            cmo.setThreshold(value);

            cmo.setModulusExceeded(false);

            cmo.setEventAlreadyNotified(false);

        }

    }

    /**

     * Returns the derived gauge of the first object in the set of

     * observed MBeans.

     *

     * @return The derived gauge.

     *

     * @deprecated As of JMX 1.2, replaced by

     * {@link #getDerivedGauge(ObjectName)}

     */

    @Deprecated

    public synchronized Number getDerivedGauge() {

        if (observedObjects.isEmpty()) {

            return null;

        } else {

            return (Number) observedObjects.get(0).getDerivedGauge();

        }

    }

    /**

     * Gets the derived gauge timestamp of the first object in the set

     * of observed MBeans.

     *

     * @return The derived gauge timestamp.

     *

     * @deprecated As of JMX 1.2, replaced by

     * {@link #getDerivedGaugeTimeStamp(ObjectName)}

     */

    @Deprecated

    public synchronized long getDerivedGaugeTimeStamp() {

        if (observedObjects.isEmpty()) {

            return 0;

        } else {

            return observedObjects.get(0).getDerivedGaugeTimeStamp();

        }

    }

    /**

     * Gets the threshold value of the first object in the set of

     * observed MBeans.

     *

     * @return The threshold value.

     *

     * @see #setThreshold

     *

     * @deprecated As of JMX 1.2, replaced by {@link #getThreshold(ObjectName)}

     */

    @Deprecated

    public synchronized Number getThreshold() {

        return getThreshold(getObservedObject());

    }

    /**

     * Sets the initial threshold value.

     *

     * @param value The initial threshold value.

     *

     * @exception IllegalArgumentException The specified threshold is

     * null or the threshold value is less than zero.

     *

     * @see #getThreshold()

     *

     * @deprecated As of JMX 1.2, replaced by {@link #setInitThreshold}

     */

    @Deprecated

    public synchronized void setThreshold(Number value)

        throws IllegalArgumentException {

        setInitThreshold(value);

    }

    /**

     * Gets the offset value common to all observed MBeans.

     *

     * @return The offset value.

     *

     * @see #setOffset

     */

    public synchronized Number getOffset() {

        return offset;

    }

    /**

     * Sets the offset value common to all observed MBeans.

     *

     * @param value The offset value.

     *

     * @exception IllegalArgumentException The specified

     * offset is null or the offset value is less than zero.

     *

     * @see #getOffset

     */

    public synchronized void setOffset(Number value)

        throws IllegalArgumentException {

        if (value == null) {

            throw new IllegalArgumentException("Null offset");

        }

        if (value.longValue() < 0L) {

            throw new IllegalArgumentException("Negative offset");

        }

        if (offset.equals(value))

            return;

        offset = value;

        int index = 0;

        for (ObservedObject o : observedObjects) {

            resetAlreadyNotified(o, index++, THRESHOLD_ERROR_NOTIFIED);

        }

    }

    /**

     * Gets the modulus value common to all observed MBeans.

     *

     * @see #setModulus

     *

     * @return The modulus value.

     */

    public synchronized Number getModulus() {

        return modulus;

    }

    /**

     * Sets the modulus value common to all observed MBeans.

     *

     * @param value The modulus value.

     *

     * @exception IllegalArgumentException The specified

     * modulus is null or the modulus value is less than zero.

     *

     * @see #getModulus

     */

    public synchronized void setModulus(Number value)

        throws IllegalArgumentException {

        if (value == null) {

            throw new IllegalArgumentException("Null modulus");

        }

        if (value.longValue() < 0L) {

            throw new IllegalArgumentException("Negative modulus");

        }

        if (modulus.equals(value))

            return;

        modulus = value;

        // Reset values.

        //

        int index = 0;

        for (ObservedObject o : observedObjects) {

            resetAlreadyNotified(o, index++, THRESHOLD_ERROR_NOTIFIED);

            final CounterMonitorObservedObject cmo =

                (CounterMonitorObservedObject) o;

            cmo.setModulusExceeded(false);

        }

    }