| 1 |
|
//---PACKAGE DECLARATION--- |
| 2 |
< |
package uk.ac.ukc.iscream.client.monitors; |
| 2 |
> |
package uk.org.iscream.client.monitors; |
| 3 |
|
|
| 4 |
|
//---IMPORTS--- |
| 5 |
|
import java.util.HashMap; |
| 6 |
|
import java.util.Iterator; |
| 7 |
< |
import uk.ac.ukc.iscream.client.*; |
| 8 |
< |
import uk.ac.ukc.iscream.core.*; |
| 9 |
< |
import uk.ac.ukc.iscream.util.*; |
| 10 |
< |
import uk.ac.ukc.iscream.componentmanager.*; |
| 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 |
| 15 |
|
* @author $Author$ |
| 16 |
|
* @version $Id$ |
| 17 |
|
*/ |
| 18 |
< |
public class Heartbeat__Monitor implements PluginMonitor, Runnable { |
| 18 |
> |
public class Heartbeat__Monitor extends MonitorSkeleton { |
| 19 |
|
|
| 20 |
|
//---FINAL ATTRIBUTES--- |
| 21 |
|
|
| 33 |
|
//---CONSTRUCTORS--- |
| 34 |
|
|
| 35 |
|
public Heartbeat__Monitor() { |
| 36 |
< |
new Thread(this).start(); |
| 36 |
> |
super(); |
| 37 |
> |
new HeartbeatWorker().start(); |
| 38 |
|
} |
| 39 |
|
|
| 40 |
|
//---PUBLIC METHODS--- |
| 41 |
|
|
| 41 |
– |
public void run() { |
| 42 |
– |
ConfigurationProxy cp = ConfigurationProxy.getInstance(); |
| 43 |
– |
while(true) { |
| 44 |
– |
// this cycle period of this monitor's checks |
| 45 |
– |
int checkPeriod = 0; |
| 46 |
– |
try { |
| 47 |
– |
checkPeriod = Integer.parseInt(cp.getProperty(_name, "Monitor.Heartbeat.checkPeriod")); |
| 48 |
– |
} catch (PropertyNotFoundException e) { |
| 49 |
– |
checkPeriod = DEFAULT_CHECK_PERIOD; |
| 50 |
– |
_logger.write(toString(), Logger.WARNING, "Monitor.Heartbeat.checkPeriod value unavailable using default of " + checkPeriod + " seconds"); |
| 51 |
– |
} catch (NumberFormatException e) { |
| 52 |
– |
checkPeriod = DEFAULT_CHECK_PERIOD; |
| 53 |
– |
_logger.write(toString(), Logger.WARNING, "Erronous Monitor.Heartbeat.checkPeriod value in configuration using default of " + checkPeriod + " seconds"); |
| 54 |
– |
} |
| 55 |
– |
|
| 56 |
– |
// perform the checks (use HB hash, although they *should* be the same) |
| 57 |
– |
Iterator i = _hostsHB.keySet().iterator(); |
| 58 |
– |
while(i.hasNext()) { |
| 59 |
– |
// get host |
| 60 |
– |
String source = (String) i.next(); |
| 61 |
– |
// check it |
| 62 |
– |
analyseHB(source); |
| 63 |
– |
} |
| 64 |
– |
|
| 65 |
– |
// wait a while |
| 66 |
– |
try {Thread.sleep(checkPeriod * 1000);} catch (InterruptedException e) {} |
| 67 |
– |
} |
| 68 |
– |
} |
| 69 |
– |
|
| 70 |
– |
// only use attribute num 0 :) |
| 71 |
– |
public void analyseHB(String source) { |
| 72 |
– |
ConfigurationProxy cp = ConfigurationProxy.getInstance(); |
| 73 |
– |
Register reg = (Register) _hostsReg.get(source); |
| 74 |
– |
|
| 75 |
– |
// get host's HB interval (seconds) |
| 76 |
– |
// this should always exist, thus we set to 0 |
| 77 |
– |
int hostHBinterval = 0; |
| 78 |
– |
try { |
| 79 |
– |
hostHBinterval = Integer.parseInt(cp.getProperty("Host."+source, "TCPUpdateTime")); |
| 80 |
– |
} catch (PropertyNotFoundException e) { |
| 81 |
– |
hostHBinterval = 0; |
| 82 |
– |
_logger.write(toString(), Logger.WARNING, "TCPUpdateTime value unavailable using default of " + hostHBinterval + " seconds"); |
| 83 |
– |
} catch (NumberFormatException e) { |
| 84 |
– |
hostHBinterval = 0; |
| 85 |
– |
_logger.write(toString(), Logger.WARNING, "Erronous TCPUpdateTime value in configuration using default of " + hostHBinterval + " seconds"); |
| 86 |
– |
} |
| 87 |
– |
|
| 88 |
– |
// get host's last HB time (seconds) |
| 89 |
– |
long lastHeartbeat = ((HeartbeatHolder) _hostsHB.get(source)).getLastHeartbeat(); |
| 90 |
– |
// time since last heartbeat (seconds) |
| 91 |
– |
long timeSinceLastHB = (System.currentTimeMillis()/1000) - lastHeartbeat; |
| 92 |
– |
|
| 93 |
– |
// find out the threshold level we're at |
| 94 |
– |
int result = checkAttributeThreshold(timeSinceLastHB, reg); |
| 95 |
– |
|
| 96 |
– |
// decide what threshold level we're on, if we've changed, record that |
| 97 |
– |
if (result != reg.getLastThresholdLevel(0)) { |
| 98 |
– |
reg.setLastThresholdLevel(0, result); |
| 99 |
– |
} |
| 100 |
– |
|
| 101 |
– |
// as long as this isn't a normal level |
| 102 |
– |
if(reg.getLastThresholdLevel(0) != Alert.thresholdNORMAL) { |
| 103 |
– |
// if the time since the last alert is more than the time for |
| 104 |
– |
// its timeout, fire an alert, escalate the alert |
| 105 |
– |
long timeout = reg.getLastAlertTimeout(0); |
| 106 |
– |
if ((timeout > 0) && (reg.getTimeLastSent(0) > 0)) { |
| 107 |
– |
if((System.currentTimeMillis() - reg.getTimeLastSent(0)) > timeout) { |
| 108 |
– |
int lastAlert = reg.getLastAlertLevel(0); |
| 109 |
– |
reg.escalateAlert(0); |
| 110 |
– |
reg.setTimeLastSent(0, System.currentTimeMillis()); |
| 111 |
– |
reg.setLastAlertTimeout(0, reg.getAlertTimeout(reg.getLastAlertLevel(0), 0)); |
| 112 |
– |
// -- SEND |
| 113 |
– |
fireAlert(source, timeSinceLastHB, reg, lastAlert); |
| 114 |
– |
} |
| 115 |
– |
// if we don't have a timeout configured...we got STRAIGHT to the next level |
| 116 |
– |
} else { |
| 117 |
– |
int lastAlert = reg.getLastAlertLevel(0); |
| 118 |
– |
reg.escalateAlert(0); |
| 119 |
– |
reg.setTimeLastSent(0, System.currentTimeMillis()); |
| 120 |
– |
reg.setLastAlertTimeout(0, reg.getAlertTimeout(reg.getLastAlertLevel(0), 0)); |
| 121 |
– |
// -- SEND |
| 122 |
– |
fireAlert(source, timeSinceLastHB, reg, lastAlert); |
| 123 |
– |
} |
| 124 |
– |
|
| 125 |
– |
// we must be on ok, check the timeout value for this |
| 126 |
– |
} else { |
| 127 |
– |
// if we were on an OK alert before, then we don't do anything |
| 128 |
– |
// but if we weren't we only set OK, once the timeout of the last |
| 129 |
– |
// alert has occourd |
| 130 |
– |
if (reg.getLastAlertLevel(0) != Alert.alertOK) { |
| 131 |
– |
long timeout = reg.getLastAlertTimeout(0); |
| 132 |
– |
if ((timeout > 0) && (reg.getTimeLastSent(0) > 0)) { |
| 133 |
– |
if ((System.currentTimeMillis() - reg.getTimeLastSent(0)) > timeout) { |
| 134 |
– |
int lastAlert = reg.getLastAlertLevel(0); |
| 135 |
– |
reg.setLastAlertLevel(0, Alert.alertOK); |
| 136 |
– |
reg.setTimeLastSent(0, System.currentTimeMillis()); |
| 137 |
– |
reg.setLastAlertTimeout(0, timeout); |
| 138 |
– |
// -- SEND |
| 139 |
– |
fireAlert(source, timeSinceLastHB, reg, lastAlert); |
| 140 |
– |
} |
| 141 |
– |
} |
| 142 |
– |
} |
| 143 |
– |
} |
| 144 |
– |
} |
| 145 |
– |
|
| 42 |
|
public void analysePacket(XMLPacket packet) { |
| 43 |
< |
if (packet.getParam("packet.attributes.type").equals("heartbeat")) { |
| 44 |
< |
String source = packet.getParam("packet.attributes.machine_name"); |
| 45 |
< |
if (!_hostsHB.containsKey(source)) { |
| 46 |
< |
_hostsReg.put(source, new Register(source, _name, 1)); |
| 47 |
< |
_hostsHB.put(source, new HeartbeatHolder()); |
| 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 |
|
} |
| 153 |
– |
HeartbeatHolder lastHeartbeat = (HeartbeatHolder) _hostsHB.get(source); |
| 154 |
– |
lastHeartbeat.setLastHeartbeat(System.currentTimeMillis()/1000); |
| 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.ac.ukc.iscream.util.NameFormat class |
| 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 |
| 85 |
|
} |
| 86 |
|
} |
| 87 |
|
} |
| 88 |
< |
return 0; |
| 88 |
> |
return Alert.thresholdNORMAL; |
| 89 |
|
} |
| 193 |
– |
|
| 194 |
– |
private void fireAlert(String source, long timeSinceLastHB, Register reg, int lastAlert) { |
| 195 |
– |
int alertLevel = reg.getLastAlertLevel(0); |
| 196 |
– |
int thresholdLevel = reg.getLastThresholdLevel(0); |
| 197 |
– |
String currentValue = String.valueOf(timeSinceLastHB); |
| 198 |
– |
String attributeName = "Heartbeat"; |
| 199 |
– |
String thresholdValue = String.valueOf(reg.getThreshold(thresholdLevel)); |
| 200 |
– |
String time = Long.toString(reg.getAlertTimeout(reg.getLastAlertLevel(0), 0) / 1000); |
| 201 |
– |
if (thresholdLevel == Alert.thresholdNORMAL) { |
| 202 |
– |
thresholdValue = "-"; |
| 203 |
– |
} |
| 204 |
– |
if (alertLevel == Alert.alertOK) { |
| 205 |
– |
time = "0"; |
| 206 |
– |
} |
| 207 |
– |
Alert alert = new Alert(alertLevel, lastAlert, thresholdLevel, source, thresholdValue, currentValue, attributeName, time); |
| 208 |
– |
_alerterQueue.add(alert); |
| 209 |
– |
_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:" + time + "secs"); |
| 210 |
– |
} |
| 90 |
|
|
| 91 |
|
//---ACCESSOR/MUTATOR METHODS--- |
| 92 |
|
|
| 93 |
+ |
protected Queue getQueue() { |
| 94 |
+ |
return MonitorManager.getInstance().getHeartbeatQueue(); |
| 95 |
+ |
} |
| 96 |
+ |
|
| 97 |
|
//---ATTRIBUTES--- |
| 98 |
|
|
| 99 |
|
/** |
| 106 |
|
* be changed to null for utility classes. |
| 107 |
|
*/ |
| 108 |
|
private String _name = "Heartbeat"; |
| 226 |
– |
|
| 227 |
– |
/** |
| 228 |
– |
* This holds a reference to the |
| 229 |
– |
* system logger that is being used. |
| 230 |
– |
*/ |
| 231 |
– |
private Logger _logger = ReferenceManager.getInstance().getLogger(); |
| 109 |
|
|
| 233 |
– |
private Queue _alerterQueue = ClientMain._alerterQueue; |
| 234 |
– |
|
| 110 |
|
/** |
| 111 |
|
* A reference to the configuration proxy in use |
| 112 |
|
*/ |
| 113 |
|
private ConfigurationProxy _cp = ConfigurationProxy.getInstance(); |
| 114 |
|
|
| 115 |
< |
private HashMap _hostsHB = new HashMap(); |
| 241 |
< |
private HashMap _hostsReg = new HashMap(); |
| 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 |
|
} |
| 134 |
|
return _lastHeartbeat; |
| 135 |
|
} |
| 136 |
|
|
| 137 |
+ |
public HashMap getRegisterHash() { |
| 138 |
+ |
return _registerHash; |
| 139 |
+ |
} |
| 140 |
+ |
|
| 141 |
|
private long _lastHeartbeat; |
| 142 |
< |
} |
| 143 |
< |
|
| 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 |
> |
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 |
|
} |
