ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/i-scream/projects/cms/source/server/uk/org/iscream/cms/server/client/monitors/CPU__Monitor.java
(Generate patch)

Comparing projects/cms/source/server/uk/org/iscream/cms/server/client/monitors/CPU__Monitor.java (file contents):
Revision 1.9 by ajm, Fri Mar 2 03:57:06 2001 UTC vs.
Revision 1.11 by ajm, Sun Mar 4 02:41:16 2001 UTC

# Line 29 | Line 29 | public class CPU__Monitor implements PluginMonitor {
29  
30   //---CONSTRUCTORS---
31  
32 –    public CPU__Monitor() {
33 –        _alerterQueue = ClientMain._alerterQueue;
34 –        // get the configuration for this plug-in
35 –        Configuration config = _refman.getCM().getConfiguration(_name);
36 –        _levels = new double[(Alert.alerts).length];
37 –        for (int x = 0; x < Alert.alerts.length; x++) {
38 –            try {
39 –                _levels[x] = Double.parseDouble(config.getProperty("Monitor.CPU.level." + x));
40 –            } catch (NumberFormatException e) {
41 –                _logger.write(toString(), Logger.ERROR, "Invalid configured value for alert level " + x + " - ignoring level.");
42 –                _levels[x] = -1;
43 –            } catch (org.omg.CORBA.MARSHAL e2) {
44 –                _logger.write(toString(), Logger.WARNING, "Alert level " + x + " unused.");
45 –                _levels[x] = -1;
46 –            }
47 –            
48 –        }
49 –    }
50 –
32   //---PUBLIC METHODS---
33  
34      public void analysePacket(XMLPacket packet) {
35          if (packet.getParam("packet.attributes.type").equals("data")) {
36              String source = packet.getParam("packet.attributes.machine_name");
37              if (!_hosts.containsKey(source)) {
38 <                _hosts.put(source, new Register(_attributes.length));
38 >                _hosts.put(source, new Register(source, _name, _attributes.length));
39              }
40              
41              Register reg = (Register) _hosts.get(source);
42 <            for(int x = 0; x < _attributes.length; x++) {
43 <                int result = checkAttribute(packet, _attributes[x]);
44 <                if (result != reg.getRegister(x)) {
45 <                    reg.setRegister(x, result);
46 <                    fireAlert(result, source, packet.getParam(_attributes[x]), _attributeNames[x]);
47 <                }
48 <            }          
42 >            for(int attributeNum = 0; attributeNum < _attributes.length; attributeNum++) {
43 >                // find out the threshold level we're at
44 >                int result = checkAttributeThreshold(packet.getParam(_attributes[attributeNum]), reg);
45 >                
46 >                // decide what threshold level we're on, if we've changed, record that
47 >                if (result != reg.getLastThresholdLevel(attributeNum)) {
48 >                    reg.setLastThresholdLevel(attributeNum, result);
49 >                }
50 >                // as long as this isn't a normal level
51 >                if(reg.getLastThresholdLevel(attributeNum) != Alert.thresholdNORMAL) {
52 >                    // if the time since the last alert is more than the time for
53 >                    // its timeout, fire an alert, escalate the alert
54 >                    long timeout = reg.getAlertTimeout(reg.getLastAlertLevel(attributeNum), attributeNum);
55 >                    if ((timeout > 0) && (reg.getTimeLastSent(attributeNum) > 0)) {
56 >                        if((System.currentTimeMillis() - reg.getTimeLastSent(attributeNum)) > timeout) {
57 >                            reg.escalateAlert(attributeNum);
58 >                            reg.setTimeLastSent(attributeNum, System.currentTimeMillis());
59 >                            fireAlert(reg, packet, attributeNum);
60 >                        }
61 >                    // if we don't have a timeout configured...we got STRAIGHT to the next level
62 >                    } else {
63 >                        reg.escalateAlert(attributeNum);
64 >                        reg.setTimeLastSent(attributeNum, System.currentTimeMillis());
65 >                        fireAlert(reg, packet, attributeNum);
66 >                    }
67 >                        
68 >                // we must be on ok, check the timeout value for this
69 >                } else {
70 >                    // if we were on an OK alert before, then we don't do anything
71 >                    // but if we weren't we only set OK, once the timout of the last
72 >                    // alert has occourd
73 >                    if (reg.getLastAlertLevel(attributeNum) != Alert.alertOK) {
74 >                        long timeout = reg.getAlertTimeout(reg.getLastAlertLevel(attributeNum), attributeNum);
75 >                        if ((timeout > 0) && (reg.getTimeLastSent(attributeNum) > 0)) {
76 >                            if ((System.currentTimeMillis() - reg.getTimeLastSent(attributeNum)) > timeout) {
77 >                                reg.setLastAlertLevel(attributeNum, Alert.alertOK);
78 >                                reg.setTimeLastSent(attributeNum, System.currentTimeMillis());
79 >                                fireAlert(reg, packet, attributeNum);
80 >                            }
81 >                        } else {
82 >                            reg.setLastAlertLevel(attributeNum, Alert.alertOK);
83 >                            reg.setTimeLastSent(attributeNum, System.currentTimeMillis());
84 >                            fireAlert(reg, packet, attributeNum);
85 >                        }
86 >                    }
87 >                }
88 >            }
89          }
90      }
91  
# Line 85 | Line 106 | public class CPU__Monitor implements PluginMonitor {
106      }
107  
108      /**
109 <     * return the String representation of what the filter does
109 >     * return the String representation of what the monitor does
110       */
111      public String getDescription(){
112          return DESC;
# Line 93 | Line 114 | public class CPU__Monitor implements PluginMonitor {
114  
115   //---PRIVATE METHODS---
116  
117 <    private int checkAttribute(XMLPacket packet, String packetAttribute) {
118 <        for(int x= _levels.length; x > 0; x--) {
119 <            if (_levels[x] != -1) {
120 <                if(packet.getParam(packetAttribute) != null) {
121 <                    double attribute = Double.parseDouble(packet.getParam(packetAttribute));
122 <                    if (_levels[x] < attribute) return x;
117 >    private int checkAttributeThreshold(String attributeString, Register reg) {
118 >        for(int thresholdLevel = Alert.thresholdLevels.length - 1; thresholdLevel >= 0; thresholdLevel--) {
119 >            if (reg.getThreshold(thresholdLevel) != -1.0) {
120 >                if(attributeString != null) {
121 >                    try {
122 >                        double attribute = Double.parseDouble(attributeString);
123 >                        if (reg.getThreshold(thresholdLevel) < attribute) return thresholdLevel;
124 >                    } catch (NumberFormatException e) {
125 >                        // we got some duff data in the packet, but we shouldn't have
126 >                        _logger.write(toString(), Logger.DEBUG, "possible errenous packet data, should be double value - " + attributeString);
127 >                    }
128                  }
129              }
130          }
131          return 0;
132      }
133  
134 <    private void fireAlert(int alertLevel, String source, String currentValue, String attributeName) {
135 <        String thresholdValue = Double.toString(_levels[alertLevel]);
136 <        Alert alert = new Alert(alertLevel, source, thresholdValue, currentValue, attributeName);
134 >    private void fireAlert(Register reg, XMLPacket packet, int attributeNum) {
135 >        int alertLevel = reg.getLastAlertLevel(attributeNum);
136 >        int thresholdLevel = reg.getLastThresholdLevel(attributeNum);
137 >        String source = packet.getParam("packet.attributes.machine_name");
138 >        String currentValue = packet.getParam(_attributes[attributeNum]);
139 >        String attributeName = _attributeNames[attributeNum];
140 >        String thresholdValue = Double.toString(reg.getThreshold(thresholdLevel));
141 >        String time = Long.toString(reg.getAlertTimeout(reg.getLastAlertLevel(attributeNum), attributeNum) / 1000);
142 >        if (thresholdLevel == Alert.thresholdNORMAL) {
143 >            thresholdValue = "-";
144 >        }
145 >        if (alertLevel == Alert.alertOK) {
146 >            time = "0";
147 >        }
148 >        Alert alert = new Alert(alertLevel, thresholdLevel, source, thresholdValue, currentValue, attributeName, time);
149          _alerterQueue.add(alert);
150 <        _logger.write(toString(), Logger.DEBUG, "Fired alert for source:" + source + " at alert level:" + alertLevel + " on:" + attributeName + " at:" +  currentValue + " exceeding threshold:" + _levels[alertLevel]);
150 >        _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");
151      }
152  
153   //---ACCESSOR/MUTATOR METHODS---
# Line 125 | Line 163 | public class CPU__Monitor implements PluginMonitor {
163       * can be placed here.  This name could also
164       * be changed to null for utility classes.
165       */
166 <    private String _name = ClientMain.NAME;
166 >    private String _name = "CPU";
167  
168      /**
169       * This holds a reference to the
# Line 133 | Line 171 | public class CPU__Monitor implements PluginMonitor {
171       */
172      private Logger _logger = ReferenceManager.getInstance().getLogger();
173      
174 <    private double[] _levels;
137 <
138 <    private Queue _alerterQueue;
174 >    private Queue _alerterQueue = ClientMain._alerterQueue;
175      
176      /**
177 <     * A reference to the reference manager in use
177 >     * A reference to the configuration proxy in use
178       */
179 <    private ReferenceManager _refman = ReferenceManager.getInstance();
179 >    private ConfigurationProxy _cp = ConfigurationProxy.getInstance();
180  
181      private HashMap _hosts = new HashMap();
182  

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines