server/client/MonitorSkeleton.java

//---PACKAGE DECLARATION---
package uk.ac.ukc.iscream.client;

//---IMPORTS---
import java.util.HashMap;
import uk.ac.ukc.iscream.client.*;
import uk.ac.ukc.iscream.core.*;
import uk.ac.ukc.iscream.util.*;
import uk.ac.ukc.iscream.componentmanager.*;

/**
 * Skeleton class for Monitors
 *
 * @author  $Author: tdb1 $
 * @version $Id: MonitorSkeleton.java,v 1.2 2001/03/07 23:17:02 tdb1 Exp $
 */
public abstract class MonitorSkeleton implements PluginMonitor {

//---FINAL ATTRIBUTES---
    
//---STATIC METHODS---

//---CONSTRUCTORS---

//---PUBLIC METHODS---

    public abstract void analysePacket(XMLPacket packet);

    public void processAlert(int newThreshold, String attributeName, Register reg, String source, String currentValue) {
        // decide what threshold level we're on, if we've changed, record that
        if (newThreshold != reg.getLastThresholdLevel()) {
            reg.setLastThresholdLevel(newThreshold);
        }
        // as long as this isn't a normal level
        if(reg.getLastThresholdLevel() != Alert.thresholdNORMAL) {
            // if the time since the last alert is more than the time for
            // its timeout, fire an alert, escalate the alert
            long timeout = reg.getLastAlertTimeout();
            if ((timeout > 0) && (reg.getTimeLastSent() > 0)) {
                if((System.currentTimeMillis() - reg.getTimeLastSent()) > timeout) {
                    int lastAlert = reg.getLastAlertLevel();
                    reg.escalateAlert();
                    reg.setTimeLastSent( System.currentTimeMillis());
                    reg.setLastAlertTimeout(reg.getAlertTimeout(reg.getLastAlertLevel()));
                    fireAlert(reg, lastAlert, source, currentValue, attributeName);
                }
            // if we don't have a timeout configured...we got STRAIGHT to the next level
            } else {
                int lastAlert = reg.getLastAlertLevel();
                reg.escalateAlert();
                reg.setTimeLastSent( System.currentTimeMillis());
                reg.setLastAlertTimeout(reg.getAlertTimeout(reg.getLastAlertLevel()));
                fireAlert(reg, lastAlert, source, currentValue, attributeName);
            }
                
        // we must be on ok, check the timeout value for this
        } else {
            // if we were on an OK alert before, then we don't do anything
            // but if we weren't we only set OK, once the timout of the last 
            // alert has occourd
            if (reg.getLastAlertLevel() != Alert.alertOK) {
                long timeout = reg.getLastAlertTimeout();
                if ((timeout > 0) && (reg.getTimeLastSent() > 0)) {
                    if ((System.currentTimeMillis() - reg.getTimeLastSent()) > timeout) {
                        int lastAlert = reg.getLastAlertLevel();
                        reg.setLastAlertLevel(Alert.alertOK);
                        reg.setTimeLastSent(System.currentTimeMillis());
                        reg.setLastAlertTimeout(timeout);
                        fireAlert(reg, lastAlert,  source, currentValue, attributeName);
                    }
                }
            }
        }
    }

    /**
     * return the String representation of what the monitor does
     */
    public abstract String getDescription();


//---PRIVATE METHODS---

    protected void fireAlert(Register reg, int lastAlert, String source, String currentValue, String attributeName) {
        int alertLevel = reg.getLastAlertLevel();
        int thresholdLevel = reg.getLastThresholdLevel();
        String thresholdValue = String.valueOf(reg.getThreshold(thresholdLevel));
        String timeout = String.valueOf(reg.getAlertTimeout(reg.getLastAlertLevel()) / 1000);
        if (thresholdLevel == Alert.thresholdNORMAL) {
            thresholdValue = "-";
        }
        if (alertLevel == Alert.alertOK) {
            timeout = "0";
        }
        Alert alert = new Alert(alertLevel, lastAlert, thresholdLevel, source, thresholdValue, currentValue, attributeName, timeout, reg.getInitialAlertTime());
        _alerterQueue.add(alert);
        _logger.write(toString(), Logger.DEBUG, "Fired alert for source:" + source + " at alert level:" + Alert.alertLevels[alertLevel] + " on:" + attributeName + " for threshold level:" + Alert.thresholdLevels[thresholdLevel] + " at:" +  currentValue + " exceeding threshold of:" +thresholdValue + " next alert sent in:" + timeout + "secs");
    }

//---ACCESSOR/MUTATOR METHODS---

//---ATTRIBUTES---

    protected Logger _logger = ReferenceManager.getInstance().getLogger();

    protected Queue _alerterQueue = ClientMain._alerterQueue;

//---STATIC ATTRIBUTES---

}
Revision:	1.3
Committed:	Fri Mar 9 03:30:54 2001 UTC (23 years, 2 months ago) by ajm
Branch:	MAIN
Changes since 1.2:	+32 -32 lines
Log Message:	TOTALLY re-wrote the Register class and made appropriate changes thoughout. It is now much more obvious what is going on in many places. The problem was probably caused by doing CPU as a first monitor and hard coding the number of attributes a Register stores. Now if a monitor wants to store multiple attributes, it has to do that itself. This makes alot of things much more readable and inteligable as a result.
#	Content
1	//---PACKAGE DECLARATION---
2	package uk.ac.ukc.iscream.client;
3
4	//---IMPORTS---
5	import java.util.HashMap;
6	import uk.ac.ukc.iscream.client.*;
7	import uk.ac.ukc.iscream.core.*;
8	import uk.ac.ukc.iscream.util.*;
9	import uk.ac.ukc.iscream.componentmanager.*;
10
11	/**
12	* Skeleton class for Monitors
13	*
14	* @author $Author: tdb1 $
15	* @version $Id: MonitorSkeleton.java,v 1.2 2001/03/07 23:17:02 tdb1 Exp $
16	*/
17	public abstract class MonitorSkeleton implements PluginMonitor {
18
19	//---FINAL ATTRIBUTES---
20
21	//---STATIC METHODS---
22
23	//---CONSTRUCTORS---
24
25	//---PUBLIC METHODS---
26
27	public abstract void analysePacket(XMLPacket packet);
28
29	public void processAlert(int newThreshold, String attributeName, Register reg, String source, String currentValue) {
30	// decide what threshold level we're on, if we've changed, record that
31	if (newThreshold != reg.getLastThresholdLevel()) {
32	reg.setLastThresholdLevel(newThreshold);
33	}
34	// as long as this isn't a normal level
35	if(reg.getLastThresholdLevel() != Alert.thresholdNORMAL) {
36	// if the time since the last alert is more than the time for
37	// its timeout, fire an alert, escalate the alert
38	long timeout = reg.getLastAlertTimeout();
39	if ((timeout > 0) && (reg.getTimeLastSent() > 0)) {
40	if((System.currentTimeMillis() - reg.getTimeLastSent()) > timeout) {
41	int lastAlert = reg.getLastAlertLevel();
42	reg.escalateAlert();
43	reg.setTimeLastSent( System.currentTimeMillis());
44	reg.setLastAlertTimeout(reg.getAlertTimeout(reg.getLastAlertLevel()));
45	fireAlert(reg, lastAlert, source, currentValue, attributeName);
46	}
47	// if we don't have a timeout configured...we got STRAIGHT to the next level
48	} else {
49	int lastAlert = reg.getLastAlertLevel();
50	reg.escalateAlert();
51	reg.setTimeLastSent( System.currentTimeMillis());
52	reg.setLastAlertTimeout(reg.getAlertTimeout(reg.getLastAlertLevel()));
53	fireAlert(reg, lastAlert, source, currentValue, attributeName);
54	}
55
56	// we must be on ok, check the timeout value for this
57	} else {
58	// if we were on an OK alert before, then we don't do anything
59	// but if we weren't we only set OK, once the timout of the last
60	// alert has occourd
61	if (reg.getLastAlertLevel() != Alert.alertOK) {
62	long timeout = reg.getLastAlertTimeout();
63	if ((timeout > 0) && (reg.getTimeLastSent() > 0)) {
64	if ((System.currentTimeMillis() - reg.getTimeLastSent()) > timeout) {
65	int lastAlert = reg.getLastAlertLevel();
66	reg.setLastAlertLevel(Alert.alertOK);
67	reg.setTimeLastSent(System.currentTimeMillis());
68	reg.setLastAlertTimeout(timeout);
69	fireAlert(reg, lastAlert, source, currentValue, attributeName);
70	}
71	}
72	}
73	}
74	}
75
76	/**
77	* return the String representation of what the monitor does
78	*/
79	public abstract String getDescription();
80
81
82	//---PRIVATE METHODS---
83
84	protected void fireAlert(Register reg, int lastAlert, String source, String currentValue, String attributeName) {
85	int alertLevel = reg.getLastAlertLevel();
86	int thresholdLevel = reg.getLastThresholdLevel();
87	String thresholdValue = String.valueOf(reg.getThreshold(thresholdLevel));
88	String timeout = String.valueOf(reg.getAlertTimeout(reg.getLastAlertLevel()) / 1000);
89	if (thresholdLevel == Alert.thresholdNORMAL) {
90	thresholdValue = "-";
91	}
92	if (alertLevel == Alert.alertOK) {
93	timeout = "0";
94	}
95	Alert alert = new Alert(alertLevel, lastAlert, thresholdLevel, source, thresholdValue, currentValue, attributeName, timeout, reg.getInitialAlertTime());
96	_alerterQueue.add(alert);
97	_logger.write(toString(), Logger.DEBUG, "Fired alert for source:" + source + " at alert level:" + Alert.alertLevels[alertLevel] + " on:" + attributeName + " for threshold level:" + Alert.thresholdLevels[thresholdLevel] + " at:" + currentValue + " exceeding threshold of:" +thresholdValue + " next alert sent in:" + timeout + "secs");
98	}
99
100	//---ACCESSOR/MUTATOR METHODS---
101
102	//---ATTRIBUTES---
103
104	protected Logger _logger = ReferenceManager.getInstance().getLogger();
105
106	protected Queue _alerterQueue = ClientMain._alerterQueue;
107
108	//---STATIC ATTRIBUTES---
109
110	}