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.
 *
 * 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.10 2001/03/06 20:26:27 tdb1 Exp $
 */
public class Register {

//---FINAL ATTRIBUTES---

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

//---CONSTRUCTORS---
    
    /**
     * Construct a Register with the hostname and monitorName 
     * (for obtaining the threshold values).
     *
     * @param hostname the hostname this register is for
     * @param monitorName the monitor this register is for

     */
    public Register(String hostname, String monitorName) {
        _hostname = hostname;
        _monitorName = monitorName;
        _lastAlertLevel = 0;
        _lastThresholdLevel = 0;
        _initialAlertTime= 0;
        _lastAlertTimeout = 0;
        _times = new long[Alert.alertLevels.length];
        // initialise the arrays to 0
        for(int x = 0; x < Alert.alertLevels.length; x++) {
            _times[x] = 0;
        }
    }

//---PUBLIC METHODS---

//---PRIVATE METHODS---

//---ACCESSOR/MUTATOR METHODS---
    
    /**
     * Gets the last alert level
     *
     * @return the last alert level
     */
    public int getLastAlertLevel() {
        return _lastAlertLevel;
    }
    
    /**
     * Sets the last threshold level
     *
     * @param level the new last threshold level
     */
    public void setLastThresholdLevel(int level) {
        _lastThresholdLevel = level;
    }
    
    /**
     * Gets the last threshold level
     *
     * @return the last threshold level
     */
    public int getLastThresholdLevel() {
        return _lastThresholdLevel;
    }
    
    /**
     * Sets the last alert level
     *
     * Note that if this is setting to an OK
     * level alert, it resets _maxLevelCount.
     *
     * This also sets the "initialAlertTime" 
     * if the next alert after OK is set.
     * And resets it to 0 if it IS an OK.
     *
     * @param level the new last alert level
     */
    public void setLastAlertLevel(int level) {
        _lastAlertLevel = level;
        if (level == Alert.alertOK) {
            _maxLevelCount = 0;
            _initialAlertTime = 0;
        }
        if (level == Alert.alertOK + 1) {
            _initialAlertTime = System.currentTimeMillis();
        }
    }
    
    /**
     * Gets the time an alert was sent at the given level.
     *
     * @param level the alert level to get
     *
     * @return the time last sent
     */
    public long getTimeLastSent() {
        return _times[getLastAlertLevel()];
    }
    
    /**
     * Gets the time an alert was sent at the given level.
     *
     * @param level the alert level to get
     * @param value the new time
     */
    public void setTimeLastSent(long value) {
        _times[getLastAlertLevel()] = 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) {
        // 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();
            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.
     *
     */
    public int getNextAlertLevel() {
        if((getLastAlertLevel() + 1) > (Alert.alertLevels.length - 2)) {
            return getLastAlertLevel();
        }
        return getLastAlertLevel() + 1;
    }

    /**
     * Gets the timeout value of the last alert
     * sent
     *
     * @return the last timeout value
     */
    public long getLastAlertTimeout() {
        return _lastAlertTimeout;
    }
    
    /**
     * Sets the timeout value of the last alert
     * sent
     *
     * @param timeout the new value
     */
    public void setLastAlertTimeout(long timeout) {
        _lastAlertTimeout = timeout;
    }

    /**
     * Returns the time that the first alert was sent
     * for an attribute that has passed a threshold value
     *
     */
    public long getInitialAlertTime() {
        return _initialAlertTime;
    }

    /**
     * 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.
     *
     */
    public void escalateAlert() {
        // don't escalate if we're already on the last alert
        if(getLastAlertLevel() != Alert.alertLevels.length -1) {
            setLastAlertLevel(getNextAlertLevel());
        }
        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() == Alert.alertLevels.length - 2) {
                _maxLevelCount++;
                if(_maxLevelCount > reachFINALcount) {
                    setLastAlertLevel(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 _lastAlertLevel;
    
    /**
     * An array of last threshold levels for
     * each attribute this register is looking
     * after.
     */
    private int _lastThresholdLevel;
    
    /**
     * 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;
    
    /**
     * Initial times that an alert was first
     * raised.
     */
    private long _initialAlertTime;

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