FileDocCategorySizeDatePackage
StringMonitor.javaAPI DocJava SE 5 API20518Fri Aug 26 14:57:36 BST 2005javax.management.monitor

StringMonitor

public class StringMonitor extends Monitor implements StringMonitorMBean
Defines a monitor MBean designed to observe the values of a string attribute.

A string monitor sends notifications as follows:

  • if the attribute value matches the string to compare value, a {@link MonitorNotification#STRING_TO_COMPARE_VALUE_MATCHED match notification} is sent. The notify match flag must be set to true.
    Subsequent matchings of the string to compare values do not cause further notifications unless the attribute value differs from the string to compare value.
  • if the attribute value differs from the string to compare value, a {@link MonitorNotification#STRING_TO_COMPARE_VALUE_DIFFERED differ notification} is sent. The notify differ flag must be set to true.
    Subsequent differences from the string to compare value do not cause further notifications unless the attribute value matches the string to compare value.
version
4.41 05/18/04
author
Sun Microsystems, Inc
since
1.5

Fields Summary
private static final String[]
types
private static final MBeanNotificationInfo[]
notifsInfo
private String
stringToCompare
String to compare with the observed attribute.
The default value is an empty character sequence.
private boolean
notifyMatch
Flag indicating if the string monitor notifies when matching the string to compare.
The default value is set to false.
private boolean
notifyDiffer
Flag indicating if the string monitor notifies when differing from the string to compare.
The default value is set to false.
private String[]
derivedGauge
Derived gauges.
Each element in this array corresponds to an observed object in the list.
private long[]
derivedGaugeTimestamp
Derived gauge timestamps.
Each element in this array corresponds to an observed object in the list.
private int[]
status
This attribute is used to handle the matching/differing mechanism.
Each element in this array corresponds to an observed object in the list.
private static final int
MATCHING
private static final int
DIFFERING
private static final int
MATCHING_OR_DIFFERING
private transient Timer
timer
Timer.
Constructors Summary
public StringMonitor()
Default constructor.



    /*
     * ------------------------------------------
     *  CONSTRUCTORS
     * ------------------------------------------
     */

           
      
	dbgTag = makeDebugTag();
    
Methods Summary
public synchronized java.lang.StringgetDerivedGauge(javax.management.ObjectName object)
Gets the derived gauge of the specified object, if this object is contained in the set of observed MBeans, or null otherwise.

param
object the name of the MBean whose derived gauge is required.
return
The derived gauge of the specified object.
since.unbundled
JMX 1.2

        int index = indexOf(object);
        if (index != -1)
            return derivedGauge[index];
        else
            return null;
    
public synchronized java.lang.StringgetDerivedGauge()
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)}

        return derivedGauge[0];
    
public synchronized longgetDerivedGaugeTimeStamp(javax.management.ObjectName object)
Gets the derived gauge timestamp of the specified object, if this object is contained in the set of observed MBeans, or null otherwise.

param
object the name of the MBean whose derived gauge timestamp is required.
return
The derived gauge timestamp of the specified object.
since.unbundled
JMX 1.2

        int index = indexOf(object);
        if (index != -1)
            return derivedGaugeTimestamp[index];
        else
            return 0;
    
public synchronized longgetDerivedGaugeTimeStamp()
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)}

        return derivedGaugeTimestamp[0];
    
public javax.management.MBeanNotificationInfo[]getNotificationInfo()
Returns a NotificationInfo object containing the name of the Java class of the notification and the notification types sent by the string monitor.

        return notifsInfo;
    
public synchronized booleangetNotifyDiffer()
Gets the differing notification's on/off switch value common to all observed MBeans.

return
true if the string monitor notifies when differing from the string to compare, false otherwise.
see
#setNotifyDiffer

        return notifyDiffer;
    
public synchronized booleangetNotifyMatch()
Gets the matching notification's on/off switch value common to all observed MBeans.

return
true if the string monitor notifies when matching the string to compare, false otherwise.
see
#setNotifyMatch

        return notifyMatch;
    
public synchronized java.lang.StringgetStringToCompare()
Gets the string to compare with the observed attribute common to all observed MBeans.

return
The string value.
see
#setStringToCompare

        return stringToCompare;
    
synchronized voidinsertSpecificElementAt(int index)
This method is called when adding a new observed object in the vector. It updates all the string specific arrays.

param
index The index of the observed object.

        // Update derivedGauge, derivedGaugeTimestamp, and status arrays.
        //

	if (index != elementCount)
	    throw new Error("Internal error: index != elementCount");

	if (elementCount >= derivedGauge.length) {
	    derivedGauge = expandArray(derivedGauge);
	    derivedGaugeTimestamp = expandArray(derivedGaugeTimestamp);
	    status = expandArray(status);
	}

	derivedGauge[index] = "";
	derivedGaugeTimestamp[index] = System.currentTimeMillis();
	status[index] = MATCHING_OR_DIFFERING;
    
java.lang.StringmakeDebugTag()

        return "StringMonitor";
    
voidnotifyAlarmClock(int index)
This method is called by the string monitor each time the granularity period has been exceeded.

param
index The index of the observed object.

	boolean sendNotify = false;
	String type = null;
	long timeStamp = 0;
	String msg = null;
	Object derGauge = null;
	Object trigger = null;

        Object  scan_string = null;
        String  notif_type = null;

	synchronized(this) {
	    if (!isActive)
		return;

	    // Check if the observed object and observed attribute are valid.
	    //

	    // Check that neither the observed object nor the observed
	    // attribute are null.  If the observed object or observed
	    // attribute is null, this means that the monitor started
	    // before a complete initialization and nothing is done.
	    //
	    if ((getObservedObject(index) == null) ||
		(getObservedAttribute() == null))
		return;

	    // Check that the observed object is registered in the
	    // MBean server and that the observed attribute belongs to
	    // the observed object.
	    //
	    try {
		scan_string = server.getAttribute(getObservedObject(index),
						  getObservedAttribute());
		if (scan_string == null)
		    return;
	    } catch (NullPointerException np_ex) {
		if (alreadyNotified(index, RUNTIME_ERROR_NOTIFIED))
		    return;
		else {
		    notif_type = MonitorNotification.RUNTIME_ERROR;
		    setAlreadyNotified(index, RUNTIME_ERROR_NOTIFIED);
		    msg =
			"The string monitor must be registered in " +
			"the MBean server.";
		}
	    } catch (InstanceNotFoundException inf_ex) {
		if (alreadyNotified(index, OBSERVED_OBJECT_ERROR_NOTIFIED))
		    return;
		else {
		    notif_type = MonitorNotification.OBSERVED_OBJECT_ERROR;
		    setAlreadyNotified(index, OBSERVED_OBJECT_ERROR_NOTIFIED);
		    msg =
			"The observed object must be registered in " +
			"the MBean server.";
		}
	    } catch (AttributeNotFoundException anf_ex) {
		if (alreadyNotified(index, OBSERVED_ATTRIBUTE_ERROR_NOTIFIED))
		    return;
		else {
		    notif_type = MonitorNotification.OBSERVED_ATTRIBUTE_ERROR;
		    setAlreadyNotified(index,
				       OBSERVED_ATTRIBUTE_ERROR_NOTIFIED);
		    msg =
			"The observed attribute must be accessible in " +
			"the observed object.";
		}
	    } catch (MBeanException mb_ex) {
		if (alreadyNotified(index, RUNTIME_ERROR_NOTIFIED))
		    return;
		else {
		    notif_type = MonitorNotification.RUNTIME_ERROR;
		    setAlreadyNotified(index, RUNTIME_ERROR_NOTIFIED);
		    msg = mb_ex.getMessage();
		}
	    } catch (ReflectionException ref_ex) {
		if (alreadyNotified(index, OBSERVED_ATTRIBUTE_ERROR_NOTIFIED))
		    return;
		else {
		    notif_type = MonitorNotification.OBSERVED_ATTRIBUTE_ERROR;
		    setAlreadyNotified(index, OBSERVED_ATTRIBUTE_ERROR_NOTIFIED);
		    msg = ref_ex.getMessage();
		}
	    }

	    if (msg == null) {
		// Check that the observed attribute is of type "String".
		//
		if (!(scan_string instanceof String)) {
		    if (alreadyNotified(index,
					OBSERVED_ATTRIBUTE_TYPE_ERROR_NOTIFIED))
			return;
		    else {
			notif_type =
			    MonitorNotification.OBSERVED_ATTRIBUTE_TYPE_ERROR;
			setAlreadyNotified(index,
					   OBSERVED_ATTRIBUTE_TYPE_ERROR_NOTIFIED);
			msg =
			    "The observed attribute type must be " +
			    "a string type.";
		    }
		}
	    }

	    if (msg == null) {

		// Clear all already notified flags.
		//
		resetAllAlreadyNotified(index);

		// Update the derived gauge attributes.
		//
		updateDerivedGauge(scan_string, index);

		// Notify the listeners.
		//
		updateNotifications(index);

	    } else {

		// msg != null, will send the monitor error notification.

		timeStamp = derivedGaugeTimestamp[index];
                derGauge = derivedGauge[index];

		// Reset values.
		//
		status[index] = MATCHING_OR_DIFFERING;
	    }
	}

	if (msg != null) {
	    sendNotification(type, timeStamp, msg, derGauge, null, index);
	}
    
synchronized voidremoveSpecificElementAt(int index)
This method is called when removing an observed object from the vector. It updates all the string specific arrays.

param
index The index of the observed object.

	if (index < 0 || index >= elementCount)
	    return;

        // Update derivedGauge, derivedGaugeTimestamp, and status arrays.
        //
        removeElementAt(derivedGauge, index);
        removeElementAt(derivedGaugeTimestamp, index);
        removeElementAt(status, index);
    
public synchronized voidsetGranularityPeriod(long period)
Sets the granularity period (in milliseconds).
The default value of the granularity period is 10 seconds.

param
period The granularity period value.
exception
java.lang.IllegalArgumentException The granularity period is less than or equal to zero.
see
Monitor#setGranularityPeriod(long)

        super.setGranularityPeriod(period);

        // Reschedule timer task if timer is already running
        //
	if (isActive) {
	    timer.cancel();
	    timer = new Timer();
	    timer.schedule(new StringAlarmClock(this),
			   getGranularityPeriod(), getGranularityPeriod());
	}
    
public synchronized voidsetNotifyDiffer(boolean value)
Sets the differing notification's on/off switch value common to all observed MBeans.

param
value The differing notification's on/off switch value.
see
#getNotifyDiffer

        notifyDiffer = value;
    
public synchronized voidsetNotifyMatch(boolean value)
Sets the matching notification's on/off switch value common to all observed MBeans.

param
value The matching notification's on/off switch value.
see
#getNotifyMatch

        notifyMatch = value;
    
public synchronized voidsetStringToCompare(java.lang.String value)
Sets the string to compare with the observed attribute common to all observed MBeans.

param
value The string value.
exception
java.lang.IllegalArgumentException The specified string to compare is null.
see
#getStringToCompare


        if (value == null) {
	    throw new IllegalArgumentException("Null string to compare");
        }

        stringToCompare = value;

        // Reset values.
        //
        for (int i = 0; i < elementCount; i++) {
          status[i] = MATCHING_OR_DIFFERING;
        }
    
public synchronized voidstart()
Starts the string monitor.


        if (isTraceOn()) {
            trace("start", "start the string monitor");
        }

	if (isActive) {
	    if (isTraceOn()) {
		trace("start", "the string monitor is already activated");
	    }

	    return;
	}

	isActive = true;

	// Reset values.
	//
	for (int i = 0; i < elementCount; i++) {
	    status[i] = MATCHING_OR_DIFFERING;
	}

	// Start the AlarmClock.
	//
	timer = new Timer();
	timer.schedule(new StringAlarmClock(this),
		       getGranularityPeriod(), getGranularityPeriod());
    
public voidstop()
Stops the string monitor.


        if (isTraceOn()) {
            trace("stop", "stop the string monitor");
        }

        synchronized(this) {
	    if (!isActive) {
		if (isTraceOn()) {
		    trace("stop", "the string monitor is already deactivated");
		}

		return;
	    }

            isActive = false;

            // Stop the AlarmClock.
            //
            if (timer != null) {
		timer.cancel();
		timer = null;
            }
	}
    
private synchronized voidupdateDerivedGauge(java.lang.Object scanString, int index)
Updates the derived gauge and the derived gauge timestamp attributes of the observed object at the specified index.

param
scanString The value of the observed attribute.
param
index The index of the observed object.

        derivedGaugeTimestamp[index] = System.currentTimeMillis();
        derivedGauge[index] = (String)scanString;
    
private voidupdateNotifications(int index)
Updates the notification attributes of the observed object at the specified index and notifies the listeners only once if the notifyMatch/notifyDiffer flag is set to true.

param
index The index of the observed object.

	boolean sendNotify = false;
	String type = null;
	long timeStamp = 0;
	String msg = null;
	Object derGauge = null;
	Object trigger = null;

	synchronized(this) {
	    // Send matching notification if notifyMatch is true.
	    // Send differing notification if notifyDiffer is true.
	    //
	    if (status[index] == MATCHING_OR_DIFFERING) {
		if (derivedGauge[index].equals(stringToCompare)) {
		    if (notifyMatch) {
			sendNotify = true;
			type =
			    MonitorNotification.STRING_TO_COMPARE_VALUE_MATCHED;
			timeStamp = derivedGaugeTimestamp[index];
			msg = "";
			derGauge = derivedGauge[index];
			trigger = stringToCompare;
		    }

		    status[index] = DIFFERING;
		} else {
		    if (notifyDiffer) {
			sendNotify = true;
			type =
			    MonitorNotification.STRING_TO_COMPARE_VALUE_DIFFERED;
			timeStamp = derivedGaugeTimestamp[index];
			msg = "";
			derGauge = derivedGauge[index];
			trigger = stringToCompare;
		    }
		    status[index] = MATCHING;
		}
	    } else {
		if (status[index] == MATCHING) {
		    if (derivedGauge[index].equals(stringToCompare)) {
			if (notifyMatch) {
			    sendNotify = true;
			    type =
				MonitorNotification.STRING_TO_COMPARE_VALUE_MATCHED;
			    timeStamp = derivedGaugeTimestamp[index];
			    msg = "";
			    derGauge = derivedGauge[index];
			    trigger = stringToCompare;

			}
			status[index] = DIFFERING;
		    }
		} else if (status[index] == DIFFERING) {
		    if (!derivedGauge[index].equals(stringToCompare)) {
			if (notifyDiffer) {
			    sendNotify = true;
			    type =
				MonitorNotification.STRING_TO_COMPARE_VALUE_DIFFERED;
			    timeStamp = derivedGaugeTimestamp[index];
			    msg = "";
			    derGauge = derivedGauge[index];
			    trigger = stringToCompare;
			}
			status[index] = MATCHING;
		    }
		}
	    }
	}

	if (sendNotify) {
	    sendNotification(type, timeStamp, msg, derGauge, trigger, index);
	}