client/monitors/Heartbeat__Monitor.java

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

//---IMPORTS---
import java.util.HashMap;
import java.util.Iterator;
import uk.org.iscream.client.*;
import uk.org.iscream.core.*;
import uk.org.iscream.util.*;
import uk.org.iscream.componentmanager.*;

/**
 * This Monitor watches heartbeats
 *
 * @author  $Author: ajm4 $
 * @version $Id: Heartbeat__Monitor.java,v 1.16 2001/03/22 23:04:57 ajm4 Exp $
 */
public class Heartbeat__Monitor extends MonitorSkeleton {

//---FINAL ATTRIBUTES---

    /**
     * The current CVS revision of this class
     */
    public final String REVISION = "$Revision: 1.16 $";
    
    public final String DESC = "Monitors Heartbeats.";
    
    public final int DEFAULT_CHECK_PERIOD = 60;
    
//---STATIC METHODS---

//---CONSTRUCTORS---

    public Heartbeat__Monitor() {
        super();
        new HeartbeatWorker().start();
    }

//---PUBLIC METHODS---
    
    public void analysePacket(XMLPacket packet) {
        String source = packet.getParam("packet.attributes.machine_name");
        if (!_hosts.containsKey(source)) {
            synchronized(this) {
                HashMap registerHash = new HashMap();
                registerHash.put(source, new Register(source, _name));
                _hosts.put(source, new HeartbeatHolder(registerHash));
            }
        }
        HeartbeatHolder lastHeartbeat = (HeartbeatHolder) _hosts.get(source);
        lastHeartbeat.setLastHeartbeat(System.currentTimeMillis()/1000);
    }
    
    /**
     * Overrides the {@link java.lang.Object#toString() Object.toString()}
     * method to provide clean logging (every class should have this).
     *
     * This uses the uk.org.iscream.util.NameFormat class
     * to format the toString()
     *
     * @return the name of this class and its CVS revision
     */
    public String toString() {
        return FormatName.getName(
            _name,
            getClass().getName(),
            REVISION);
    }

    /**
     * return the String representation of what the monitor does
     */
    public String getDescription(){
        return DESC;
    }

//---PRIVATE METHODS---
    
    private int checkAttributeThreshold(long timeSinceLastHB, Register reg) {
        for(int thresholdLevel = Alert.thresholdLevels.length - 1; thresholdLevel >= 0; thresholdLevel--) {
            if (reg.getThreshold(thresholdLevel) != -1.0) {
                if (((long) reg.getThreshold(thresholdLevel)) < timeSinceLastHB) {
                    return thresholdLevel;
                }
            }
        }
        return Alert.thresholdNORMAL;
    }

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

    protected Queue getQueue() {
        return MonitorManager.getInstance().getHeartbeatQueue();
    }
    
//---ATTRIBUTES---

    /**
     * This is the friendly identifier of the
     * component this class is running in.
     * eg, a Filter may be called "filter1",
     * If this class does not have an owning
     * component,  a name from the configuration
     * can be placed here.  This name could also
     * be changed to null for utility classes.
     */
    private String _name = "Heartbeat";
    
    /**
     * A reference to the configuration proxy in use
     */
    private ConfigurationProxy _cp = ConfigurationProxy.getInstance();

    private HashMap _hosts = new HashMap();

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

//---STATIC ATTRIBUTES---

//---INNER CLASSES---

    private class HeartbeatHolder {
        
        public HeartbeatHolder(HashMap registerHash) {
            _registerHash = registerHash;
        }
        
        public void setLastHeartbeat(long lastHeartbeat) {
            _lastHeartbeat = lastHeartbeat;
        }
        
        public long getLastHeartbeat() {
            return _lastHeartbeat;
        }
        
        public HashMap getRegisterHash() {
            return _registerHash;
        }
        
        private long _lastHeartbeat;
        private HashMap _registerHash;
    }
    
    private class HeartbeatWorker extends Thread {
        
        public void run() {
            ConfigurationProxy cp = ConfigurationProxy.getInstance();
            while(true) {
                // this cycle period of this monitor's checks
                int checkPeriod = 0;
                try {
                    checkPeriod = Integer.parseInt(cp.getProperty(_name, "Monitor.Heartbeat.checkPeriod"));
                } catch (PropertyNotFoundException e) {
                    checkPeriod = DEFAULT_CHECK_PERIOD;
                    _logger.write(this.toString(), Logger.WARNING, "Monitor.Heartbeat.checkPeriod value unavailable using default of " + checkPeriod + " seconds");
                } catch (NumberFormatException e) {
                    checkPeriod = DEFAULT_CHECK_PERIOD;
                    _logger.write(this.toString(), Logger.WARNING, "Erronous Monitor.Heartbeat.checkPeriod value in configuration using default of " + checkPeriod + " seconds");
                }
                
                synchronized(this) {
                    // perform the checks (use HB hash, although they *should* be the same)
                    Iterator i = _hosts.keySet().iterator();
                    while(i.hasNext()) {
                        // get host
                        String source = (String) i.next();
                        // check it
                        boolean remove = analyseHB(source);
                        if(remove) {
                            i.remove();
                        }
                    }
                }
                
                // wait a while
                try {Thread.sleep(checkPeriod * 1000);} catch (InterruptedException e) {}
            }
        }
        
        private boolean analyseHB(String source) {
            ConfigurationProxy cp = ConfigurationProxy.getInstance();
            HeartbeatHolder hbHolder = (HeartbeatHolder) _hosts.get(source);
            Register reg = (Register) ((HashMap) hbHolder.getRegisterHash()).get(source);
            
            // get host's HB interval (seconds)
            // this should always exist, thus we set to 0
            int hostHBinterval = 0;
            try {
                hostHBinterval = Integer.parseInt(cp.getProperty("Host."+source, "Host.TCPUpdateTime"));
            } catch (PropertyNotFoundException e) {
                hostHBinterval = 0;
                _logger.write(this.toString(), Logger.WARNING, "TCPUpdateTime value unavailable using default of " + hostHBinterval + " seconds");
            } catch (NumberFormatException e) {
                hostHBinterval = 0;
                _logger.write(this.toString(), Logger.WARNING, "Erronous TCPUpdateTime value in configuration using default of " + hostHBinterval + " seconds");
            }
            
            // get host's last HB time (seconds)
            long lastHeartbeat = hbHolder.getLastHeartbeat();
            // time since last heartbeat (seconds)
            long timeSinceLastHB = (System.currentTimeMillis()/1000) - lastHeartbeat;
            // time since (or until if negative) the expected heartbeat
            long timeSinceExpectedHB = timeSinceLastHB - (long) hostHBinterval;
            
            // best do a check in case the expected heartbeat is in the future
            if(timeSinceExpectedHB < 0) {
                timeSinceExpectedHB = 0;
            }
            
            // find out the threshold level we're at
            int newThreshold = checkAttributeThreshold(timeSinceExpectedHB, reg);
            
            // process the alert
            Heartbeat__Monitor.this.processAlert(newThreshold, "Heartbeat", reg, source, String.valueOf(timeSinceExpectedHB));
            
            if(reg.getLastAlertLevel() == Alert.alertFINAL) {
                return true;
            }
            return false;
        }
    }
}
Revision:	1.17
Committed:	Fri Mar 23 01:08:00 2001 UTC (23 years, 2 months ago) by ajm
Branch:	MAIN
Changes since 1.16:	+4 -4 lines
Log Message:	Fixed inheritance bug.
#	Content
1	//---PACKAGE DECLARATION---
2	package uk.org.iscream.client.monitors;
3
4	//---IMPORTS---
5	import java.util.HashMap;
6	import java.util.Iterator;
7	import uk.org.iscream.client.*;
8	import uk.org.iscream.core.*;
9	import uk.org.iscream.util.*;
10	import uk.org.iscream.componentmanager.*;
11
12	/**
13	* This Monitor watches heartbeats
14	*
15	* @author $Author: ajm4 $
16	* @version $Id: Heartbeat__Monitor.java,v 1.16 2001/03/22 23:04:57 ajm4 Exp $
17	*/
18	public class Heartbeat__Monitor extends MonitorSkeleton {
19
20	//---FINAL ATTRIBUTES---
21
22	/**
23	* The current CVS revision of this class
24	*/
25	public final String REVISION = "$Revision: 1.16 $";
26
27	public final String DESC = "Monitors Heartbeats.";
28
29	public final int DEFAULT_CHECK_PERIOD = 60;
30
31	//---STATIC METHODS---
32
33	//---CONSTRUCTORS---
34
35	public Heartbeat__Monitor() {
36	super();
37	new HeartbeatWorker().start();
38	}
39
40	//---PUBLIC METHODS---
41
42	public void analysePacket(XMLPacket packet) {
43	String source = packet.getParam("packet.attributes.machine_name");
44	if (!_hosts.containsKey(source)) {
45	synchronized(this) {
46	HashMap registerHash = new HashMap();
47	registerHash.put(source, new Register(source, _name));
48	_hosts.put(source, new HeartbeatHolder(registerHash));
49	}
50	}
51	HeartbeatHolder lastHeartbeat = (HeartbeatHolder) _hosts.get(source);
52	lastHeartbeat.setLastHeartbeat(System.currentTimeMillis()/1000);
53	}
54
55	/**
56	* Overrides the {@link java.lang.Object#toString() Object.toString()}
57	* method to provide clean logging (every class should have this).
58	*
59	* This uses the uk.org.iscream.util.NameFormat class
60	* to format the toString()
61	*
62	* @return the name of this class and its CVS revision
63	*/
64	public String toString() {
65	return FormatName.getName(
66	_name,
67	getClass().getName(),
68	REVISION);
69	}
70
71	/**
72	* return the String representation of what the monitor does
73	*/
74	public String getDescription(){
75	return DESC;
76	}
77
78	//---PRIVATE METHODS---
79
80	private int checkAttributeThreshold(long timeSinceLastHB, Register reg) {
81	for(int thresholdLevel = Alert.thresholdLevels.length - 1; thresholdLevel >= 0; thresholdLevel--) {
82	if (reg.getThreshold(thresholdLevel) != -1.0) {
83	if (((long) reg.getThreshold(thresholdLevel)) < timeSinceLastHB) {
84	return thresholdLevel;
85	}
86	}
87	}
88	return Alert.thresholdNORMAL;
89	}
90
91	//---ACCESSOR/MUTATOR METHODS---
92
93	protected Queue getQueue() {
94	return MonitorManager.getInstance().getHeartbeatQueue();
95	}
96
97	//---ATTRIBUTES---
98
99	/**
100	* This is the friendly identifier of the
101	* component this class is running in.
102	* eg, a Filter may be called "filter1",
103	* If this class does not have an owning
104	* component, a name from the configuration
105	* can be placed here. This name could also
106	* be changed to null for utility classes.
107	*/
108	private String _name = "Heartbeat";
109
110	/**
111	* A reference to the configuration proxy in use
112	*/
113	private ConfigurationProxy _cp = ConfigurationProxy.getInstance();
114
115	private HashMap _hosts = new HashMap();
116
117	private Logger _logger = ReferenceManager.getInstance().getLogger();
118
119	//---STATIC ATTRIBUTES---
120
121	//---INNER CLASSES---
122
123	private class HeartbeatHolder {
124
125	public HeartbeatHolder(HashMap registerHash) {
126	_registerHash = registerHash;
127	}
128
129	public void setLastHeartbeat(long lastHeartbeat) {
130	_lastHeartbeat = lastHeartbeat;
131	}
132
133	public long getLastHeartbeat() {
134	return _lastHeartbeat;
135	}
136
137	public HashMap getRegisterHash() {
138	return _registerHash;
139	}
140
141	private long _lastHeartbeat;
142	private HashMap _registerHash;
143	}
144
145	private class HeartbeatWorker extends Thread {
146
147	public void run() {
148	ConfigurationProxy cp = ConfigurationProxy.getInstance();
149	while(true) {
150	// this cycle period of this monitor's checks
151	int checkPeriod = 0;
152	try {
153	checkPeriod = Integer.parseInt(cp.getProperty(_name, "Monitor.Heartbeat.checkPeriod"));
154	} catch (PropertyNotFoundException e) {
155	checkPeriod = DEFAULT_CHECK_PERIOD;
156	_logger.write(this.toString(), Logger.WARNING, "Monitor.Heartbeat.checkPeriod value unavailable using default of " + checkPeriod + " seconds");
157	} catch (NumberFormatException e) {
158	checkPeriod = DEFAULT_CHECK_PERIOD;
159	_logger.write(this.toString(), Logger.WARNING, "Erronous Monitor.Heartbeat.checkPeriod value in configuration using default of " + checkPeriod + " seconds");
160	}
161
162	synchronized(this) {
163	// perform the checks (use HB hash, although they should be the same)
164	Iterator i = _hosts.keySet().iterator();
165	while(i.hasNext()) {
166	// get host
167	String source = (String) i.next();
168	// check it
169	boolean remove = analyseHB(source);
170	if(remove) {
171	i.remove();
172	}
173	}
174	}
175
176	// wait a while
177	try {Thread.sleep(checkPeriod * 1000);} catch (InterruptedException e) {}
178	}
179	}
180
181	private boolean analyseHB(String source) {
182	ConfigurationProxy cp = ConfigurationProxy.getInstance();
183	HeartbeatHolder hbHolder = (HeartbeatHolder) _hosts.get(source);
184	Register reg = (Register) ((HashMap) hbHolder.getRegisterHash()).get(source);
185
186	// get host's HB interval (seconds)
187	// this should always exist, thus we set to 0
188	int hostHBinterval = 0;
189	try {
190	hostHBinterval = Integer.parseInt(cp.getProperty("Host."+source, "Host.TCPUpdateTime"));
191	} catch (PropertyNotFoundException e) {
192	hostHBinterval = 0;
193	_logger.write(this.toString(), Logger.WARNING, "TCPUpdateTime value unavailable using default of " + hostHBinterval + " seconds");
194	} catch (NumberFormatException e) {
195	hostHBinterval = 0;
196	_logger.write(this.toString(), Logger.WARNING, "Erronous TCPUpdateTime value in configuration using default of " + hostHBinterval + " seconds");
197	}
198
199	// get host's last HB time (seconds)
200	long lastHeartbeat = hbHolder.getLastHeartbeat();
201	// time since last heartbeat (seconds)
202	long timeSinceLastHB = (System.currentTimeMillis()/1000) - lastHeartbeat;
203	// time since (or until if negative) the expected heartbeat
204	long timeSinceExpectedHB = timeSinceLastHB - (long) hostHBinterval;
205
206	// best do a check in case the expected heartbeat is in the future
207	if(timeSinceExpectedHB < 0) {
208	timeSinceExpectedHB = 0;
209	}
210
211	// find out the threshold level we're at
212	int newThreshold = checkAttributeThreshold(timeSinceExpectedHB, reg);
213
214	// process the alert
215	Heartbeat__Monitor.this.processAlert(newThreshold, "Heartbeat", reg, source, String.valueOf(timeSinceExpectedHB));
216
217	if(reg.getLastAlertLevel() == Alert.alertFINAL) {
218	return true;
219	}
220	return false;
221	}
222	}
223	}