| Methods Summary |
|---|
| public synchronized java.lang.Number | getDerivedGauge(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.
int index = indexOf(object);
if (index != -1)
return derivedGauge[index];
else
return null;
|
| public synchronized java.lang.Number | getDerivedGauge()Returns the derived gauge of the first object in the set of
observed MBeans.
return derivedGauge[0];
|
| public synchronized long | getDerivedGaugeTimeStamp(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.
int index = indexOf(object);
if (index != -1)
return derivedGaugeTimestamp[index];
else
return 0;
|
| public synchronized long | getDerivedGaugeTimeStamp()Gets the derived gauge timestamp of the first object in the set
of observed MBeans.
return derivedGaugeTimestamp[0];
|
| public synchronized boolean | getDifferenceMode()Gets the difference mode flag value common to all observed MBeans.
return differenceMode;
|
| public synchronized java.lang.Number | getHighThreshold()Gets the high threshold value common to all observed MBeans.
return highThreshold;
|
| public synchronized java.lang.Number | getLowThreshold()Gets the low threshold value common to all observed MBeans.
return lowThreshold;
|
| 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 gauge monitor.
String[] types = { MonitorNotification.RUNTIME_ERROR,
MonitorNotification.OBSERVED_OBJECT_ERROR,
MonitorNotification.OBSERVED_ATTRIBUTE_ERROR,
MonitorNotification.OBSERVED_ATTRIBUTE_TYPE_ERROR,
MonitorNotification.THRESHOLD_ERROR,
MonitorNotification.THRESHOLD_HIGH_VALUE_EXCEEDED,
MonitorNotification.THRESHOLD_LOW_VALUE_EXCEEDED};
MBeanNotificationInfo[] notifsInfo = {
new MBeanNotificationInfo(types,
"javax.management.monitor.MonitorNotification",
"Notifications sent by the GaugeMonitor MBean")
};
return notifsInfo;
|
| public synchronized boolean | getNotifyHigh()Gets the high notification's on/off switch value common to all
observed MBeans.
return notifyHigh;
|
| public synchronized boolean | getNotifyLow()Gets the low notification's on/off switch value common to all
observed MBeans.
return notifyLow;
|
| synchronized void | insertSpecificElementAt(int index)This method is called when adding a new observed object in the vector.
It updates all the gauge specific arrays.
// Update derivedGauge, derivedGaugeTimestamp, previousScanGauge,
// status and type values.
if (index != elementCount)
throw new Error("Internal error: index != elementCount");
if (elementCount >= derivedGauge.length) {
derivedGauge = expandArray(derivedGauge);
previousScanGauge = expandArray(previousScanGauge);
derivedGaugeTimestamp = expandArray(derivedGaugeTimestamp);
status = expandArray(status);
type = expandArray(type);
}
derivedGauge[index] = INTEGER_ZERO;
previousScanGauge[index] = null;
derivedGaugeTimestamp[index] = System.currentTimeMillis();
status[index] = RISING_OR_FALLING;
type[index] = INTEGER;
|
| private boolean | isFirstGreaterThanLast(java.lang.Number greater, java.lang.Number less, int type)Tests if the first specified Number is greater than or equal to
the last. Both integer and floating-point types are allowed.
switch(type) {
case INTEGER:
case BYTE:
case SHORT:
case LONG:
return (greater.longValue() >= less.longValue());
case FLOAT:
case DOUBLE:
return (greater.doubleValue() >= less.doubleValue());
default:
// Should never occur...
if (isDebugOn()) {
debug("isFirstGreaterThanLast",
"the threshold type is invalid");
}
return false;
}
|
| private boolean | isFirstStrictlyGreaterThanLast(java.lang.Number greater, java.lang.Number less, java.lang.String className)Tests if the first specified Number is strictly greater than the last.
Both integer and floating-point types are allowed.
if (className.equals("java.lang.Integer") ||
className.equals("java.lang.Byte") ||
className.equals("java.lang.Short") ||
className.equals("java.lang.Long")) {
return (greater.longValue() > less.longValue());
}
else if (className.equals("java.lang.Float") ||
className.equals("java.lang.Double")) {
return (greater.doubleValue() > less.doubleValue());
}
else {
// Should never occur...
if (isDebugOn()) {
debug("isFirstStrictlyGreaterThanLast",
"the threshold type is invalid");
}
return false;
}
|
| private synchronized boolean | isThresholdTypeValid(int index)Tests if the threshold high and threshold low are both of the
same type as the gauge. Both integer and floating-point types
are allowed.
Note:
If the optional lowThreshold or highThreshold have not been
initialized, their default value is an Integer object with
a value equal to zero.
switch(type[index]) {
case INTEGER:
return (((highThreshold == INTEGER_ZERO) ||
(highThreshold instanceof Integer)) &&
((lowThreshold == INTEGER_ZERO) ||
(lowThreshold instanceof Integer)));
case BYTE:
return (((highThreshold == INTEGER_ZERO) ||
(highThreshold instanceof Byte)) &&
((lowThreshold == INTEGER_ZERO) ||
(lowThreshold instanceof Byte)));
case SHORT:
return (((highThreshold == INTEGER_ZERO) ||
(highThreshold instanceof Short)) &&
((lowThreshold == INTEGER_ZERO) ||
(lowThreshold instanceof Short)));
case LONG:
return (((highThreshold == INTEGER_ZERO) ||
(highThreshold instanceof Long)) &&
((lowThreshold == INTEGER_ZERO) ||
(lowThreshold instanceof Long)));
case FLOAT:
return (((highThreshold == INTEGER_ZERO) ||
(highThreshold instanceof Float)) &&
((lowThreshold == INTEGER_ZERO) ||
(lowThreshold instanceof Float)));
case DOUBLE:
return (((highThreshold == INTEGER_ZERO) ||
(highThreshold instanceof Double)) &&
((lowThreshold == INTEGER_ZERO) ||
(lowThreshold instanceof Double)));
default:
// Should never occur...
if (isDebugOn()) {
debug("isThresholdTypeValid", "The threshold type is invalid");
}
return false;
}
|
| java.lang.String | makeDebugTag()
// TRACES & DEBUG
//---------------
return "GaugeMonitor";
|
| void | notifyAlarmClock(int index)This method is called by the gauge monitor each time
the granularity period has been exceeded.
long timeStamp = 0;
String msg = null;
Object derGauge = null;
Object scan_gauge = 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_gauge = server.getAttribute(getObservedObject(index),
getObservedAttribute());
if (scan_gauge == 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 gauge 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 either of type
// "Integer" or "Float".
//
if (scan_gauge instanceof Integer) {
type[index] = INTEGER;
} else if (scan_gauge instanceof Byte) {
type[index] = BYTE;
} else if (scan_gauge instanceof Short) {
type[index] = SHORT;
} else if (scan_gauge instanceof Long) {
type[index] = LONG;
} else if (scan_gauge instanceof Float) {
type[index] = FLOAT;
} else if (scan_gauge instanceof Double) {
type[index] = DOUBLE;
} else {
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 an " +
"integer type or a floating-point type.";
}
}
}
if (msg == null) {
// Check that threshold high and threshold low are of
// the same type as the gauge.
//
if (!isThresholdTypeValid(index)) {
if (alreadyNotified(index, THRESHOLD_ERROR_NOTIFIED))
return;
else {
notif_type = MonitorNotification.THRESHOLD_ERROR;
setAlreadyNotified(index, THRESHOLD_ERROR_NOTIFIED);
msg =
"The threshold high and threshold low must be " +
"of the same type as the gauge.";
}
}
}
if (msg == null) {
// Clear all already notified flags.
//
resetAllAlreadyNotified(index);
// Update the derived gauge attributes and check
// the validity of the new value. The derived
// gauge value is invalid when the differenceMode
// flag is set to true and it is the first
// notification (so we haven't 2 consecutive
// values to update the derived gauge).
//
boolean is_derived_gauge_valid =
updateDerivedGauge(scan_gauge, index);
// Notify the listeners if the updated derived
// gauge value is valid.
//
if (is_derived_gauge_valid)
updateNotifications(index);
} else {
// msg != null, will send an error notification
timeStamp = derivedGaugeTimestamp[index];
derGauge = derivedGauge[index];
// Reset values.
//
status[index] = RISING_OR_FALLING;
previousScanGauge[index] = null;
}
}
if (msg != null) {
sendNotification(notif_type,
timeStamp,
msg,
derGauge,
null,
index);
}
|
| synchronized void | removeSpecificElementAt(int index)This method is called when removing an observed object from the vector.
It updates all the gauge specific arrays.
if (index < 0 || index >= elementCount)
return;
// Update derivedGauge, derivedGaugeTimestamp, previousScanGauge,
// status and type arrays.
//
removeElementAt(derivedGauge, index);
removeElementAt(previousScanGauge, index);
removeElementAt(derivedGaugeTimestamp, index);
removeElementAt(status, index);
removeElementAt(type, index);
|
| private synchronized void | setDerivedGaugeWithDifference(java.lang.Number scanGauge, int index)Sets the derived gauge when the differenceMode flag is set to
true. Both integer and floating-point types are
allowed.
Number prev = previousScanGauge[index];
Number der;
switch (type[index]) {
case INTEGER:
der = new Integer(((Integer)scanGauge).intValue() -
((Integer)prev).intValue());
break;
case BYTE:
der = new Byte((byte)(((Byte)scanGauge).byteValue() -
((Byte)prev).byteValue()));
break;
case SHORT:
der = new Short((short)(((Short)scanGauge).shortValue() -
((Short)prev).shortValue()));
break;
case LONG:
der = new Long(((Long)scanGauge).longValue() -
((Long)prev).longValue());
break;
case FLOAT:
der = new Float(((Float)scanGauge).floatValue() -
((Float)prev).floatValue());
break;
case DOUBLE:
der = new Double(((Double)scanGauge).doubleValue() -
((Double)prev).doubleValue());
default:
// Should never occur...
if (isDebugOn()) {
debug("setDerivedGaugeWithDifference",
"the threshold type is invalid");
}
return;
}
derivedGauge[index] = der;
|
| public synchronized void | setDifferenceMode(boolean value)Sets the difference mode flag value common to all observed MBeans.
differenceMode = value;
// Reset values.
//
for (int i = 0; i < elementCount; i++) {
status[i] = RISING_OR_FALLING;
previousScanGauge[i] = null;
}
|
| public synchronized void | setGranularityPeriod(long period)Sets the granularity period (in milliseconds).
The default value of the granularity period is 10 seconds.
super.setGranularityPeriod(period);
// Reschedule timer task if timer is already running
//
if (isActive()) {
timer.cancel();
timer = new Timer();
timer.schedule(new GaugeAlarmClock(this), getGranularityPeriod(),
getGranularityPeriod());
}
|
| public synchronized void | setNotifyHigh(boolean value)Sets the high notification's on/off switch value common to all
observed MBeans.
notifyHigh = value;
|
| public synchronized void | setNotifyLow(boolean value)Sets the low notification's on/off switch value common to all
observed MBeans.
notifyLow = value;
|
| public synchronized void | setThresholds(java.lang.Number highValue, java.lang.Number lowValue)Sets the high and the low threshold values common to all
observed MBeans.
if ((highValue == null) || (lowValue == null)) {
throw new IllegalArgumentException("Null threshold value");
}
if (highValue.getClass() != lowValue.getClass()) {
throw new IllegalArgumentException("Different type " +
"threshold values");
}
if (isFirstStrictlyGreaterThanLast(lowValue, highValue,
highValue.getClass().getName())) {
throw new IllegalArgumentException("High threshold less than " +
"low threshold");
}
highThreshold = highValue;
lowThreshold = lowValue;
for (int i = 0; i < elementCount; i++) {
resetAlreadyNotified(i, THRESHOLD_ERROR_NOTIFIED);
// Reset values.
//
status[i] = RISING_OR_FALLING;
}
|
| public void | start()Starts the gauge monitor.
if (isTraceOn()) {
trace("start", "start the gauge monitor");
}
synchronized(this) {
if (isActive) {
if (isTraceOn()) {
trace("start", "the gauge monitor is already activated");
}
return;
}
isActive = true;
// Reset values.
//
for (int i = 0; i < elementCount; i++) {
status[i] = RISING_OR_FALLING;
previousScanGauge[i] = null;
}
// Start the AlarmClock.
//
timer = new Timer();
timer.schedule(new GaugeAlarmClock(this), getGranularityPeriod(),
getGranularityPeriod());
}
|
| public void | stop()Stops the gauge monitor.
trace("stop", "stop the gauge monitor");
synchronized(this) {
if (!isActive) {
if (isTraceOn()) {
trace("stop", "the counter monitor is already started");
}
return;
}
isActive = false;
// Stop the AlarmClock.
//
if (timer != null) {
timer.cancel();
timer = null;
}
}
|
| private synchronized boolean | updateDerivedGauge(java.lang.Object scanGauge, int index)Updates the derived gauge and the derived gauge timestamp attributes
of the observed object at the specified index.
boolean is_derived_gauge_valid;
derivedGaugeTimestamp[index] = System.currentTimeMillis();
// The gauge difference mode is used.
//
if (differenceMode) {
// The previous scan gauge has been initialized.
//
if (previousScanGauge[index] != null) {
setDerivedGaugeWithDifference((Number)scanGauge, index);
is_derived_gauge_valid = true;
}
// The previous scan gauge has not been initialized.
// We cannot update the derived gauge...
//
else {
is_derived_gauge_valid = false;
}
previousScanGauge[index] = (Number)scanGauge;
}
// The gauge difference mode is not used.
//
else {
derivedGauge[index] = (Number)scanGauge;
is_derived_gauge_valid = true;
}
return is_derived_gauge_valid;
|
| private void | updateNotifications(int index)Updates the notification attribute of the observed object at the
specified index and notifies the listeners only once if the notify flag
is set to true.
boolean sendNotify = false;
String notifType = null;
long timeStamp = 0;
String msg = null;
Object derGauge = null;
Object trigger = null;
// Send high notification if notifyHigh is true.
// Send low notification if notifyLow is true.
//
synchronized(this) {
if (status[index] == RISING_OR_FALLING) {
if (isFirstGreaterThanLast(derivedGauge[index], highThreshold,
type[index])) {
if (notifyHigh) {
sendNotify = true;
notifType =
MonitorNotification.THRESHOLD_HIGH_VALUE_EXCEEDED;
timeStamp = derivedGaugeTimestamp[index];
msg = "";
derGauge = derivedGauge[index];
trigger = highThreshold;
}
status[index] = FALLING;
} else if (isFirstGreaterThanLast(lowThreshold,
derivedGauge[index],
type[index])) {
if (notifyLow) {
sendNotify = true;
notifType =
MonitorNotification.THRESHOLD_LOW_VALUE_EXCEEDED;
timeStamp = derivedGaugeTimestamp[index];
msg ="";
derGauge = derivedGauge[index];
trigger = lowThreshold;
}
status[index] = RISING;
}
} else {
if (status[index] == RISING) {
if (isFirstGreaterThanLast(derivedGauge[index],
highThreshold,
type[index])) {
if (notifyHigh) {
sendNotify = true;
notifType =
MonitorNotification.THRESHOLD_HIGH_VALUE_EXCEEDED;
timeStamp = derivedGaugeTimestamp[index];
msg = "";
derGauge = derivedGauge[index];
trigger = highThreshold;
}
status[index] = FALLING;
}
} else if (status[index] == FALLING) {
if (isFirstGreaterThanLast(lowThreshold,
derivedGauge[index],
type[index])) {
if (notifyLow) {
sendNotify = true;
notifType =
MonitorNotification.THRESHOLD_LOW_VALUE_EXCEEDED;
timeStamp = derivedGaugeTimestamp[index];
msg = "";
derGauge = derivedGauge[index];
trigger = lowThreshold;
}
status[index] = RISING;
}
}
}
}
if (sendNotify) {
sendNotification(notifType, timeStamp, msg, derGauge, trigger, index);
}
|
