server/client/Register.java

//---PACKAGE DECLARATION---
package uk.org.iscream.client;

//---IMPORTS---
import uk.org.iscream.util.*;
import uk.org.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: ajm4 $
 * @version $Id: Register.java,v 1.15 2001/03/22 00:31:24 ajm4 Exp $
 */
public class Register {

//---FINAL ATTRIBUTES---

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

//---CONSTRUCTORS---
    
    /**
     * Construct a Register with the hostname and monitorName 
     * (for obtaining the threshold values).
     * This constructs a generic register for a specific monitor.
     *
     * @param hostname the hostname this register is for
     * @param monitorName the monitor this register is for
     */
    public Register(String hostname, String monitorName) {
        this(hostname, monitorName, null);    
    }

    /**
     * Construct a Register with the hostname and monitorName 
     * (for obtaining the threshold values).
     * This constructs a register for a specific attribute check
     * by a monitor.
     *
     * @param hostname the hostname this register is for
     * @param monitorName the monitor this register is for
     * @param attributeName the specific attribute this register is for
     */
    public Register(String hostname, String monitorName, String attributeName) {
        _hostname = hostname;
        _monitorName = monitorName;
        _attributeName = attributeName;
        _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---

    /**
     * Obtains a threshold value from the configuration for a given level.
     * The attribute name specifies which property to get.
     * eg, attributeName = idle it will look for
     *     Monitor.<monitor name>.idle.threshold.<alert level>
     * eg, attributeName = null
     *     Monitor.<monitor name>.threshold.<alert level>
     *
     * Note that if its null, this will get the threshold for the monitor
     * as a whole, not the specific attribute.
     *
     * @param level the alert level to get the attribute for
     * @param attributeName the attribute to get the threshold for
     *
     * @return the threshold obtained
     */    
    private String getThresholdConfig(int level, String attributeName) throws PropertyNotFoundException {
        String temp = "";
        if (attributeName != null) {
            temp = "." + attributeName;
        }
        return _cp.getProperty("Host." + _hostname, "Monitor." + _monitorName + temp + ".threshold." + Alert.thresholdLevels[level]);
    }

//---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;
            // we won't do this, so OK's still have the initialAlertTime
            // of the original alert they're OK'ing
            //_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 = "";
            try {
                thresholdString = getThresholdConfig(level, _attributeName);
            } catch (PropertyNotFoundException e) {
                thresholdString = getThresholdConfig(level, null);
            }
            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 if the alert timeout for the current monitor
     * is not configured, it will try to obtain the default
     * timeout for all Monitor's.  If there is no alert timeout
     * for either the monitor or a default setting this returns 0.
     *
     * 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
     *
     * @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;
            try {
                timeoutString = _cp.getProperty("Host." + _hostname, "Monitor." + _monitorName + ".alertTimeout." + Alert.alertLevels[level]);
            } catch (PropertyNotFoundException e) {
                // if there is no timeout for the monitor
                // check for a default
                timeoutString = _cp.getProperty("Host." + _hostname, "Monitor.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;
    
    /**
     * The attribute name, as obtained from
     * the configuration.
     * eg, idle or /var
     */
    private String _attributeName;

    /**
     * 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.16
Committed:	Thu Mar 22 02:08:58 2001 UTC (23 years, 2 months ago) by ajm
Branch:	MAIN
CVS Tags:	PROJECT_COMPLETION
Changes since 1.15:	+15 -6 lines
Log Message:	Now allows the use of a default timeout value for all Monitors
#	Content
1	//---PACKAGE DECLARATION---
2	package uk.org.iscream.client;
3
4	//---IMPORTS---
5	import uk.org.iscream.util.*;
6	import uk.org.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: ajm4 $
19	* @version $Id: Register.java,v 1.15 2001/03/22 00:31:24 ajm4 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.15 $";
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	* This constructs a generic register for a specific monitor.
38	*
39	* @param hostname the hostname this register is for
40	* @param monitorName the monitor this register is for
41	*/
42	public Register(String hostname, String monitorName) {
43	this(hostname, monitorName, null);
44	}
45
46	/**
47	* Construct a Register with the hostname and monitorName
48	* (for obtaining the threshold values).
49	* This constructs a register for a specific attribute check
50	* by a monitor.
51	*
52	* @param hostname the hostname this register is for
53	* @param monitorName the monitor this register is for
54	* @param attributeName the specific attribute this register is for
55	*/
56	public Register(String hostname, String monitorName, String attributeName) {
57	_hostname = hostname;
58	_monitorName = monitorName;
59	_attributeName = attributeName;
60	_lastAlertLevel = 0;
61	_lastThresholdLevel = 0;
62	_initialAlertTime= 0;
63	_lastAlertTimeout = 0;
64	_times = new long[Alert.alertLevels.length];
65	// initialise the arrays to 0
66	for(int x = 0; x < Alert.alertLevels.length; x++) {
67	_times[x] = 0;
68	}
69	}
70
71
72	//---PUBLIC METHODS---
73
74	//---PRIVATE METHODS---
75
76	/**
77	* Obtains a threshold value from the configuration for a given level.
78	* The attribute name specifies which property to get.
79	* eg, attributeName = idle it will look for
80	* Monitor.<monitor name>.idle.threshold.<alert level>
81	* eg, attributeName = null
82	* Monitor.<monitor name>.threshold.<alert level>
83	*
84	* Note that if its null, this will get the threshold for the monitor
85	* as a whole, not the specific attribute.
86	*
87	* @param level the alert level to get the attribute for
88	* @param attributeName the attribute to get the threshold for
89	*
90	* @return the threshold obtained
91	*/
92	private String getThresholdConfig(int level, String attributeName) throws PropertyNotFoundException {
93	String temp = "";
94	if (attributeName != null) {
95	temp = "." + attributeName;
96	}
97	return _cp.getProperty("Host." + _hostname, "Monitor." + _monitorName + temp + ".threshold." + Alert.thresholdLevels[level]);
98	}
99
100	//---ACCESSOR/MUTATOR METHODS---
101
102	/**
103	* Gets the last alert level
104	*
105	* @return the last alert level
106	*/
107	public int getLastAlertLevel() {
108	return _lastAlertLevel;
109	}
110
111	/**
112	* Sets the last threshold level
113	*
114	* @param level the new last threshold level
115	*/
116	public void setLastThresholdLevel(int level) {
117	_lastThresholdLevel = level;
118	}
119
120	/**
121	* Gets the last threshold level
122	*
123	* @return the last threshold level
124	*/
125	public int getLastThresholdLevel() {
126	return _lastThresholdLevel;
127	}
128
129	/**
130	* Sets the last alert level
131	*
132	* Note that if this is setting to an OK
133	* level alert, it resets _maxLevelCount.
134	*
135	* This also sets the "initialAlertTime"
136	* if the next alert after OK is set.
137	* And resets it to 0 if it IS an OK.
138	*
139	* @param level the new last alert level
140	*/
141	public void setLastAlertLevel(int level) {
142	_lastAlertLevel = level;
143	if (level == Alert.alertOK) {
144	_maxLevelCount = 0;
145	// we won't do this, so OK's still have the initialAlertTime
146	// of the original alert they're OK'ing
147	//_initialAlertTime = 0;
148	}
149	if (level == Alert.alertOK + 1) {
150	_initialAlertTime = System.currentTimeMillis();
151	}
152	}
153
154	/**
155	* Gets the time an alert was sent at the given level.
156	*
157	* @param level the alert level to get
158	*
159	* @return the time last sent
160	*/
161	public long getTimeLastSent() {
162	return _times[getLastAlertLevel()];
163	}
164
165	/**
166	* Gets the time an alert was sent at the given level.
167	*
168	* @param level the alert level to get
169	* @param value the new time
170	*/
171	public void setTimeLastSent(long value) {
172	_times[getLastAlertLevel()] = value;
173	}
174
175	/**
176	* Gets the threshold value for the given
177	* level of alert.
178	*
179	* If there is no alert threshold for a
180	* given level, this returns -1.0
181	*
182	* @param level the alert level
183	*/
184	public double getThreshold(int level) {
185	// -1.0 means we don't use an alert level
186	double threshold = -1.0;
187	try {
188	String thresholdString = "";
189	try {
190	thresholdString = getThresholdConfig(level, _attributeName);
191	} catch (PropertyNotFoundException e) {
192	thresholdString = getThresholdConfig(level, null);
193	}
194	threshold = Double.parseDouble(thresholdString);
195	} catch (PropertyNotFoundException e) {
196	threshold = -1.0;
197	} catch (NumberFormatException e) {
198	threshold = -1.0;
199	}
200	return threshold;
201	}
202
203	/**
204	* Gets the alert timeout value for the given
205	* level of alert. This value is in millis,
206	* and is converted from the value in the config,
207	* which should be seconds.
208	*
209	* Note that if the alert timeout for the current monitor
210	* is not configured, it will try to obtain the default
211	* timeout for all Monitor's. If there is no alert timeout
212	* for either the monitor or a default setting this returns 0.
213	*
214	* Note that this is dependant on the threshold value
215	* given, the timeout is obatined from the config, then
216	* divided by the threshold value, this allows alerts to
217	* progress faster should a higher threshold value be passed
218	*
219	* @param level the alert level
220	* @param thresholdLevel the threshold leve we are on
221	*/
222	public long getAlertTimeout(int level) {
223	// 0 means we don't use this value
224	long timeout = 0;
225	try {
226	String timeoutString;
227	try {
228	timeoutString = _cp.getProperty("Host." + _hostname, "Monitor." + _monitorName + ".alertTimeout." + Alert.alertLevels[level]);
229	} catch (PropertyNotFoundException e) {
230	// if there is no timeout for the monitor
231	// check for a default
232	timeoutString = _cp.getProperty("Host." + _hostname, "Monitor.alertTimeout." + Alert.alertLevels[level]);
233	}
234	int threshold = getLastThresholdLevel();
235	if (threshold > 0) {
236	timeout = (Long.parseLong(timeoutString) / threshold) * 1000;
237	}
238	} catch (PropertyNotFoundException e) {
239	timeout = 0;
240	} catch (NumberFormatException e) {
241	timeout = 0;
242	}
243	return timeout;
244	}
245
246	/**
247	* Either advances to the next alert level, or if
248	* the maximum alert level has been reached, simply returns
249	* that.
250	*
251	* Note this method will NEVER reach the last alert level
252	* in the list, this is assumed to be FINAL, and special
253	* logic is in place to handle that.
254	*
255	*/
256	public int getNextAlertLevel() {
257	if((getLastAlertLevel() + 1) > (Alert.alertLevels.length - 2)) {
258	return getLastAlertLevel();
259	}
260	return getLastAlertLevel() + 1;
261	}
262
263	/**
264	* Gets the timeout value of the last alert
265	* sent
266	*
267	* @return the last timeout value
268	*/
269	public long getLastAlertTimeout() {
270	return _lastAlertTimeout;
271	}
272
273	/**
274	* Sets the timeout value of the last alert
275	* sent
276	*
277	* @param timeout the new value
278	*/
279	public void setLastAlertTimeout(long timeout) {
280	_lastAlertTimeout = timeout;
281	}
282
283	/**
284	* Returns the time that the first alert was sent
285	* for an attribute that has passed a threshold value
286	*
287	*/
288	public long getInitialAlertTime() {
289	return _initialAlertTime;
290	}
291
292	/**
293	* Advances the alert level to the next one up.
294	*
295	* This keeps track of the number of the number
296	* of times the highest NON-FINAL alert level
297	* has been reached. Note this isn't a specific
298	* level, just the highest, so you could configure
299	* more levels and not affect this.
300	*
301	* If the count exceeds the number of times
302	* set in the configuration, it escalates to
303	* a FINAL alert if we're using FINAL's.
304	*
305	* It determines if to use FINAL's from the config
306	* entry reachFINALcount, when the count exceeds
307	* this value, it escalates to a FINAL. If that attribute
308	* is mis-read or is not configured. It will NEVER reach
309	* a FINAL.
310	*
311	*/
312	public void escalateAlert() {
313	// don't escalate if we're already on the last alert
314	if(getLastAlertLevel() != Alert.alertLevels.length -1) {
315	setLastAlertLevel(getNextAlertLevel());
316	}
317	try {
318	// note if we fail to get this value, we won't process the res of this
319	int reachFINALcount = Integer.parseInt(_cp.getProperty("Host." + _hostname, "Monitor." + _monitorName + ".reachFINALcount"));
320	if (getLastAlertLevel() == Alert.alertLevels.length - 2) {
321	_maxLevelCount++;
322	if(_maxLevelCount > reachFINALcount) {
323	setLastAlertLevel(Alert.alertFINAL);
324	}
325	}
326	} catch (PropertyNotFoundException e) {
327	// we NEVER reach FINAL in this case
328	} catch (NumberFormatException e) {
329	// we NEVER reach FINAL in this case
330	}
331	}
332
333	//---ATTRIBUTES---
334
335	/**
336	* The host this register is for
337	*/
338	private String _hostname;
339
340	/**
341	* The monitor this register is for
342	*/
343	private String _monitorName;
344
345	/**
346	* The attribute name, as obtained from
347	* the configuration.
348	* eg, idle or /var
349	*/
350	private String _attributeName;
351
352	/**
353	* An array of last alert levels for
354	* each attribute this register is looking
355	* after.
356	*/
357	private int _lastAlertLevel;
358
359	/**
360	* An array of last threshold levels for
361	* each attribute this register is looking
362	* after.
363	*/
364	private int _lastThresholdLevel;
365
366	/**
367	* An array of last alert timeout levels for
368	* each attribute this register is looking
369	* after.
370	*/
371	private long _lastAlertTimeout;
372
373	/**
374	* An array of arrays containing
375	* time an alert of each level
376	* was last sent for each attribute.
377	*/
378	private long[] _times;
379
380	/**
381	* Initial times that an alert was first
382	* raised.
383	*/
384	private long _initialAlertTime;
385
386	/**
387	* A reference to the configuration proxy in use
388	*/
389	private ConfigurationProxy _cp = ConfigurationProxy.getInstance();
390
391	/**
392	* The number of times the maximum level alert
393	* has occured IN A ROW, this is escalated by
394	* the escalate(int) method, and reset by the
395	* setLastAlertLevel(int, int) method
396	*/
397	private int _maxLevelCount = 0;
398
399	//---STATIC ATTRIBUTES---
400
401	}