server/client/Register.java

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

//---IMPORTS---
import uk.ac.ukc.iscream.util.*;
import uk.ac.ukc.iscream.componentmanager.*;

/**
 * The Register class holds theshold values,
 * the last level of alert for each attribute for a monitor
 * and the time of last alert sent for each alert level for
 * each attribute in this register.
 *
 * This class is used by monitor classes so they can determine
 * how often they should send alerts when breaching alert levels.
 * It also stores (and keeps uptodate (via the configuration proxy)
 * the threshold values for the monitor.
 *
 * @author  $Author: tdb1 $
 * @version $Id: Register.java,v 1.4 2001/03/05 23:14:53 tdb1 Exp $
 */
public class Register {

//---FINAL ATTRIBUTES---

    /**
     * The current CVS revision of this class
     */
    public static final String REVISION = "$Revision: 1.4 $";
    
//---STATIC METHODS---

//---CONSTRUCTORS---
    
    /**
     * Construct a Register with the hostname and monitorName 
     * (for obtaining the threshold values), and the number of
     * attributes we are keeping track of.
     *
     * @param hostname the hostname this register is for
     * @param monitorName the monitor this register is for
     * @param numAttributes the number of attributes to track
     */
    public Register(String hostname, String monitorName, int numAttributes) {
        _hostname = hostname;
        _monitorName = monitorName;
        _lastAlertLevels = new int[numAttributes];
        _lastThresholdLevels = new int[numAttributes];
        _lastAlertTimeout = new long[numAttributes];
        _times = new long[numAttributes][Alert.alertLevels.length];
        // initialise the arrays to 0
        for (int x = 0; x < _lastAlertLevels.length; x++) {
            _lastAlertLevels[x] = 0;
            _lastThresholdLevels[x] = 0;
            _lastAlertTimeout[x] = 0;
            for(int y = 0; y < Alert.alertLevels.length; y++) {
                _times[x][y] = 0;
            }
        }
    }

//---PUBLIC METHODS---

//---PRIVATE METHODS---

//---ACCESSOR/MUTATOR METHODS---
    
    /**
     * Gets the last alert level for the 
     * given attribute.
     *
     * @param attributeNum the attribute to get
     *
     * @return the last alert level
     */
    public int getLastAlertLevel(int attributeNum) {
        return _lastAlertLevels[attributeNum];
    }
    
    /**
     * Sets the last threshold level for the 
     * given attribute.
     *
     * @param attributeNum the attribute to set
     * @param level the new last threshold level
     */
    public void setLastThresholdLevel(int attributeNum, int level) {
        _lastThresholdLevels[attributeNum] = level;
    }
    
        /**
     * Gets the last threshold level for the 
     * given attribute.
     *
     * @param attributeNum the attribute to get
     *
     * @return the last threshold level
     */
    public int getLastThresholdLevel(int attributeNum) {
        return _lastThresholdLevels[attributeNum];
    }
    
    /**
     * Sets the last alert level for the 
     * given attribute.
     *
     * Note that if this is setting to an OK
     * level alert, it resets _maxLevelCount.
     *
     * @param attributeNum the attribute to set
     * @param level the new last alert level
     */
    public void setLastAlertLevel(int attributeNum, int level) {
        _lastAlertLevels[attributeNum] = level;
        if (level == Alert.alertOK) {
            _maxLevelCount = 0;
        }
    }
    
    /**
     * Gets the time an alert was sent for the
     * given attribute at the given level.
     *
     * @param attributeNum the attribute to get
     * @param level the alert level to get
     *
     * @return the time last sent
     */
    public long getTimeLastSent(int attributeNum) {
        return _times[attributeNum][getLastAlertLevel(attributeNum)];
    }
    
    /**
     * Gets the time an alert was sent for the
     * given attribute at the given level.
     *
     * @param attributeNum the attribute to get
     * @param level the alert level to get
     * @param value the new time
     */
    public void setTimeLastSent(int attributeNum, long value) {
        _times[attributeNum][getLastAlertLevel(attributeNum)] = value;
    }
    
    /**
     * Gets the threshold value for the given
     * level of alert.
     *
     * If there is no alert threshold for a 
     * given level, this returns -1.0
     *
     * @param level the alert level
     */
    public double getThreshold(int level) {
        // -1.0 means we don't use an alert level
        double threshold = -1.0;
        try {
            String thresholdString = _cp.getProperty("Host." + _hostname, "Monitor." + _monitorName + ".threshold." + Alert.thresholdLevels[level]);
            threshold = Double.parseDouble(thresholdString);
        } catch (PropertyNotFoundException e) {
            threshold = -1.0;
        } catch (NumberFormatException e) {
            threshold = -1.0;
        }
        return threshold;
    }
    
    /**
     * Gets the alert timeout value for the given
     * level of alert.  This value is in millis,
     * and is converted from the value in the config,
     * which should be seconds.
     *
     * Note that this is dependant on the threshold value
     * given, the timeout is obatined from the config, then
     * divided by the threshold value, this allows alerts to
     * progress faster should a higher threshold value be passed
     *
     * If there is no alert timeout for a 
     * given level, this returns 0
     *
     * @param level the alert level
     * @param thresholdLevel the threshold leve we are on
     */
    public long getAlertTimeout(int level, int attributeNum) {
        // 0 means we don't use this value
        long timeout = 0;
        try {
            String timeoutString = _cp.getProperty("Host." + _hostname, "Monitor." + _monitorName + ".alertTimeout." + Alert.alertLevels[level]);
            int threshold = getLastThresholdLevel(attributeNum);
            if (threshold > 0) {
                timeout = (Long.parseLong(timeoutString) / threshold) * 1000;
            }
        } catch (PropertyNotFoundException e) {
            timeout = 0;
        } catch (NumberFormatException e) {
            timeout = 0;
        }
        return timeout;
    }
    
    /**
     * Either advances to the next alert level, or if
     * the maximum alert level has been reached, simply returns
     * that.
     *
     * Note this method will NEVER reach the last alert level
     * in the list, this is assumed to be FINAL, and special
     * logic is in place to handle that.
     *
     * @param attributeNum the attribute to get next alert for
     */
    public int getNextAlertLevel(int attributeNum) {
        if((getLastAlertLevel(attributeNum) + 1) > (Alert.alertLevels.length - 2)) {
            return getLastAlertLevel(attributeNum);
        }
        return getLastAlertLevel(attributeNum) + 1;
    }

    /**
     * Gets the timeout value of the last alert
     * sent
     *
     * @param attrubuteNum the attribute to get the last timeout for
     * @return the last timeout value
     */
    public long getLastAlertTimeout(int attributeNum) {
        return _lastAlertTimeout[attributeNum];
    }
    
    /**
     * Sets the timeout value of the last alert
     * sent
     *
     * @param attrubuteNum the attribute to get the last timeout for
     * @param timeout the new value
     */
    public void setLastAlertTimeout(int attributeNum, long timeout) {
        _lastAlertTimeout[attributeNum] = timeout;
    }

    /**
     * Advances the alert level to the next one up.
     *
     * This keeps track of the number of the number
     * of times the highest NON-FINAL alert level
     * has been reached.  Note this isn't a specific
     * level, just the highest, so you could configure
     * more levels and not affect this.
     *
     * If the count exceeds the number of times
     * set in the configuration, it escalates to 
     * a FINAL alert if we're using FINAL's.
     *
     * It determines if to use FINAL's from the config
     * entry reachFINALcount, when the count exceeds
     * this value, it escalates to a FINAL.  If that attribute
     * is mis-read or is not configured.  It will NEVER reach
     * a FINAL.
     *
     * @param attributeNum the attribute to advance the alert for 
     */
    public void escalateAlert(int attributeNum) {
        setLastAlertLevel(attributeNum, getNextAlertLevel(attributeNum));
        try {
            // note if we fail to get this value, we won't process the res of this
            int reachFINALcount = Integer.parseInt(_cp.getProperty("Host." + _hostname, "Monitor." + _monitorName + ".reachFINALcount"));
            if ((getLastAlertLevel(attributeNum) == Alert.alertLevels.length - 2) && (_maxLevelCount < reachFINALcount) ) {
                _maxLevelCount++;
            } else {
                setLastAlertLevel(attributeNum, Alert.alertFINAL);
            }
        } catch (PropertyNotFoundException e) {
            // we NEVER reach FINAL in this case
        } catch (NumberFormatException e) {
            // we NEVER reach FINAL in this case
        }
    }

//---ATTRIBUTES---

    /**
     * The host this register is for
     */
    private String _hostname;
    
    /**
     * The monitor this register is for
     */
    private String _monitorName;

    /**
     * An array of last alert levels for
     * each attribute this register is looking
     * after.
     */
    private int[] _lastAlertLevels;
    
    /**
     * An array of last threshold levels for
     * each attribute this register is looking
     * after.
     */
    private int[] _lastThresholdLevels;
    
    /**
     * An array of last alert timeout levels for
     * each attribute this register is looking
     * after.
     */
    private long[] _lastAlertTimeout;
    
    /**
     * An array of arrays containing
     * time an alert of each level
     * was last sent for each attribute.
     */
    private long[][] _times;

    /**
     * A reference to the configuration proxy in use
     */
    private ConfigurationProxy _cp = ConfigurationProxy.getInstance();
    
    /**
     * The number of times the maximum level alert
     * has occured IN A ROW, this is escalated by
     * the escalate(int) method, and reset by the 
     * setLastAlertLevel(int, int) method
     */
    private int _maxLevelCount = 0;

//---STATIC ATTRIBUTES---

}
Revision:	1.5
Committed:	Tue Mar 6 01:40:24 2001 UTC (23 years, 2 months ago) by ajm
Branch:	MAIN
Changes since 1.4:	+51 -4 lines
Log Message:	Now has support for reaching the FINAL alert level. This counts the number of times the highest alert level has been reached, and then escalates to a FINAL if it exceeds reachFINALcount. If that value isn't configured, or is mis-configured, it will ignore FINAL's.
#	Content
1	//---PACKAGE DECLARATION---
2	package uk.ac.ukc.iscream.client;
3
4	//---IMPORTS---
5	import uk.ac.ukc.iscream.util.*;
6	import uk.ac.ukc.iscream.componentmanager.*;
7
8	/**
9	* The Register class holds theshold values,
10	* the last level of alert for each attribute for a monitor
11	* and the time of last alert sent for each alert level for
12	* each attribute in this register.
13	*
14	* This class is used by monitor classes so they can determine
15	* how often they should send alerts when breaching alert levels.
16	* It also stores (and keeps uptodate (via the configuration proxy)
17	* the threshold values for the monitor.
18	*
19	* @author $Author: tdb1 $
20	* @version $Id: Register.java,v 1.4 2001/03/05 23:14:53 tdb1 Exp $
21	*/
22	public class Register {
23
24	//---FINAL ATTRIBUTES---
25
26	/**
27	* The current CVS revision of this class
28	*/
29	public static final String REVISION = "$Revision: 1.4 $";
30
31	//---STATIC METHODS---
32
33	//---CONSTRUCTORS---
34
35	/**
36	* Construct a Register with the hostname and monitorName
37	* (for obtaining the threshold values), and the number of
38	* attributes we are keeping track of.
39	*
40	* @param hostname the hostname this register is for
41	* @param monitorName the monitor this register is for
42	* @param numAttributes the number of attributes to track
43	*/
44	public Register(String hostname, String monitorName, int numAttributes) {
45	_hostname = hostname;
46	_monitorName = monitorName;
47	_lastAlertLevels = new int[numAttributes];
48	_lastThresholdLevels = new int[numAttributes];
49	_lastAlertTimeout = new long[numAttributes];
50	_times = new long[numAttributes][Alert.alertLevels.length];
51	// initialise the arrays to 0
52	for (int x = 0; x < _lastAlertLevels.length; x++) {
53	_lastAlertLevels[x] = 0;
54	_lastThresholdLevels[x] = 0;
55	_lastAlertTimeout[x] = 0;
56	for(int y = 0; y < Alert.alertLevels.length; y++) {
57	_times[x][y] = 0;
58	}
59	}
60	}
61
62	//---PUBLIC METHODS---
63
64	//---PRIVATE METHODS---
65
66	//---ACCESSOR/MUTATOR METHODS---
67
68	/**
69	* Gets the last alert level for the
70	* given attribute.
71	*
72	* @param attributeNum the attribute to get
73	*
74	* @return the last alert level
75	*/
76	public int getLastAlertLevel(int attributeNum) {
77	return _lastAlertLevels[attributeNum];
78	}
79
80	/**
81	* Sets the last threshold level for the
82	* given attribute.
83	*
84	* @param attributeNum the attribute to set
85	* @param level the new last threshold level
86	*/
87	public void setLastThresholdLevel(int attributeNum, int level) {
88	_lastThresholdLevels[attributeNum] = level;
89	}
90
91	/**
92	* Gets the last threshold level for the
93	* given attribute.
94	*
95	* @param attributeNum the attribute to get
96	*
97	* @return the last threshold level
98	*/
99	public int getLastThresholdLevel(int attributeNum) {
100	return _lastThresholdLevels[attributeNum];
101	}
102
103	/**
104	* Sets the last alert level for the
105	* given attribute.
106	*
107	* Note that if this is setting to an OK
108	* level alert, it resets _maxLevelCount.
109	*
110	* @param attributeNum the attribute to set
111	* @param level the new last alert level
112	*/
113	public void setLastAlertLevel(int attributeNum, int level) {
114	_lastAlertLevels[attributeNum] = level;
115	if (level == Alert.alertOK) {
116	_maxLevelCount = 0;
117	}
118	}
119
120	/**
121	* Gets the time an alert was sent for the
122	* given attribute at the given level.
123	*
124	* @param attributeNum the attribute to get
125	* @param level the alert level to get
126	*
127	* @return the time last sent
128	*/
129	public long getTimeLastSent(int attributeNum) {
130	return _times[attributeNum][getLastAlertLevel(attributeNum)];
131	}
132
133	/**
134	* Gets the time an alert was sent for the
135	* given attribute at the given level.
136	*
137	* @param attributeNum the attribute to get
138	* @param level the alert level to get
139	* @param value the new time
140	*/
141	public void setTimeLastSent(int attributeNum, long value) {
142	_times[attributeNum][getLastAlertLevel(attributeNum)] = value;
143	}
144
145	/**
146	* Gets the threshold value for the given
147	* level of alert.
148	*
149	* If there is no alert threshold for a
150	* given level, this returns -1.0
151	*
152	* @param level the alert level
153	*/
154	public double getThreshold(int level) {
155	// -1.0 means we don't use an alert level
156	double threshold = -1.0;
157	try {
158	String thresholdString = _cp.getProperty("Host." + _hostname, "Monitor." + _monitorName + ".threshold." + Alert.thresholdLevels[level]);
159	threshold = Double.parseDouble(thresholdString);
160	} catch (PropertyNotFoundException e) {
161	threshold = -1.0;
162	} catch (NumberFormatException e) {
163	threshold = -1.0;
164	}
165	return threshold;
166	}
167
168	/**
169	* Gets the alert timeout value for the given
170	* level of alert. This value is in millis,
171	* and is converted from the value in the config,
172	* which should be seconds.
173	*
174	* Note that this is dependant on the threshold value
175	* given, the timeout is obatined from the config, then
176	* divided by the threshold value, this allows alerts to
177	* progress faster should a higher threshold value be passed
178	*
179	* If there is no alert timeout for a
180	* given level, this returns 0
181	*
182	* @param level the alert level
183	* @param thresholdLevel the threshold leve we are on
184	*/
185	public long getAlertTimeout(int level, int attributeNum) {
186	// 0 means we don't use this value
187	long timeout = 0;
188	try {
189	String timeoutString = _cp.getProperty("Host." + _hostname, "Monitor." + _monitorName + ".alertTimeout." + Alert.alertLevels[level]);
190	int threshold = getLastThresholdLevel(attributeNum);
191	if (threshold > 0) {
192	timeout = (Long.parseLong(timeoutString) / threshold) * 1000;
193	}
194	} catch (PropertyNotFoundException e) {
195	timeout = 0;
196	} catch (NumberFormatException e) {
197	timeout = 0;
198	}
199	return timeout;
200	}
201
202	/**
203	* Either advances to the next alert level, or if
204	* the maximum alert level has been reached, simply returns
205	* that.
206	*
207	* Note this method will NEVER reach the last alert level
208	* in the list, this is assumed to be FINAL, and special
209	* logic is in place to handle that.
210	*
211	* @param attributeNum the attribute to get next alert for
212	*/
213	public int getNextAlertLevel(int attributeNum) {
214	if((getLastAlertLevel(attributeNum) + 1) > (Alert.alertLevels.length - 2)) {
215	return getLastAlertLevel(attributeNum);
216	}
217	return getLastAlertLevel(attributeNum) + 1;
218	}
219
220	/**
221	* Gets the timeout value of the last alert
222	* sent
223	*
224	* @param attrubuteNum the attribute to get the last timeout for
225	* @return the last timeout value
226	*/
227	public long getLastAlertTimeout(int attributeNum) {
228	return _lastAlertTimeout[attributeNum];
229	}
230
231	/**
232	* Sets the timeout value of the last alert
233	* sent
234	*
235	* @param attrubuteNum the attribute to get the last timeout for
236	* @param timeout the new value
237	*/
238	public void setLastAlertTimeout(int attributeNum, long timeout) {
239	_lastAlertTimeout[attributeNum] = timeout;
240	}
241
242	/**
243	* Advances the alert level to the next one up.
244	*
245	* This keeps track of the number of the number
246	* of times the highest NON-FINAL alert level
247	* has been reached. Note this isn't a specific
248	* level, just the highest, so you could configure
249	* more levels and not affect this.
250	*
251	* If the count exceeds the number of times
252	* set in the configuration, it escalates to
253	* a FINAL alert if we're using FINAL's.
254	*
255	* It determines if to use FINAL's from the config
256	* entry reachFINALcount, when the count exceeds
257	* this value, it escalates to a FINAL. If that attribute
258	* is mis-read or is not configured. It will NEVER reach
259	* a FINAL.
260	*
261	* @param attributeNum the attribute to advance the alert for
262	*/
263	public void escalateAlert(int attributeNum) {
264	setLastAlertLevel(attributeNum, getNextAlertLevel(attributeNum));
265	try {
266	// note if we fail to get this value, we won't process the res of this
267	int reachFINALcount = Integer.parseInt(_cp.getProperty("Host." + _hostname, "Monitor." + _monitorName + ".reachFINALcount"));
268	if ((getLastAlertLevel(attributeNum) == Alert.alertLevels.length - 2) && (_maxLevelCount < reachFINALcount) ) {
269	_maxLevelCount++;
270	} else {
271	setLastAlertLevel(attributeNum, Alert.alertFINAL);
272	}
273	} catch (PropertyNotFoundException e) {
274	// we NEVER reach FINAL in this case
275	} catch (NumberFormatException e) {
276	// we NEVER reach FINAL in this case
277	}
278	}
279
280	//---ATTRIBUTES---
281
282	/**
283	* The host this register is for
284	*/
285	private String _hostname;
286
287	/**
288	* The monitor this register is for
289	*/
290	private String _monitorName;
291
292	/**
293	* An array of last alert levels for
294	* each attribute this register is looking
295	* after.
296	*/
297	private int[] _lastAlertLevels;
298
299	/**
300	* An array of last threshold levels for
301	* each attribute this register is looking
302	* after.
303	*/
304	private int[] _lastThresholdLevels;
305
306	/**
307	* An array of last alert timeout levels for
308	* each attribute this register is looking
309	* after.
310	*/
311	private long[] _lastAlertTimeout;
312
313	/**
314	* An array of arrays containing
315	* time an alert of each level
316	* was last sent for each attribute.
317	*/
318	private long[][] _times;
319
320	/**
321	* A reference to the configuration proxy in use
322	*/
323	private ConfigurationProxy _cp = ConfigurationProxy.getInstance();
324
325	/**
326	* The number of times the maximum level alert
327	* has occured IN A ROW, this is escalated by
328	* the escalate(int) method, and reset by the
329	* setLastAlertLevel(int, int) method
330	*/
331	private int _maxLevelCount = 0;
332
333	//---STATIC ATTRIBUTES---
334
335	}