client/monitors/NetIO__Monitor.java

/* 
 * i-scream central monitoring system
 * http://www.i-scream.org.uk
 * Copyright (C) 2000-2002 i-scream
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */

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

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

/**
 * This Monitor watches the network IO for all machines
 *
 * @author  $Author$
 * @version $Id$
 */
public class NetIO__Monitor extends MonitorSkeleton {

//---FINAL ATTRIBUTES---

    /**
     * The current CVS revision of this class
     */
    public final String REVISION = "$Revision: 1.1 $";
    
    /**
     * A description of this monitor
     */
    public final String DESC = "Monitors network IO on all hosts.";
    
//---STATIC METHODS---

//---CONSTRUCTORS---

//---PUBLIC METHODS---
    
    /**
     * Analyse a packet of data, and generate an alert if
     * necessary.
     *
     * @param packet the XMLPacket to analyse
     */
    public void analysePacket(XMLPacket packet) {
        String source = packet.getParam("packet.attributes.machine_name");
        if (!_hostsR.containsKey(source)) {
            _hostsR.put(source, new HashMap());
        }
        if (!_hostsW.containsKey(source)) {
            _hostsW.put(source, new HashMap());
        }

        HashMap netRegistersR = (HashMap) _hostsR.get(source);
        HashMap netRegistersW = (HashMap) _hostsW.get(source);
        
        // key prefix
        String keyPrefix = "packet.net.p";
        
        // a temporary holder for all the network interfaces we find
        HashSet netifs = new HashSet();

        // unfortunatly we need to check the whole packet to find
        // the interfaces, and then get the data attributes
        Set packetSet = packet.getSet();
        Iterator i = packetSet.iterator();
        while (i.hasNext()) {
            String dataKey = (String) i.next();
            if(dataKey.startsWith(keyPrefix)) {
                // pos is after "packet.net.p"
                int pos = keyPrefix.length();
                String ifNumber = dataKey.substring(pos, dataKey.indexOf('.', pos));
                String thisIf = keyPrefix.concat(ifNumber);
                
                if(!netifs.contains(thisIf)) {
                    // add the interface to our list
                    netifs.add(thisIf);

                    String name = packet.getParam(thisIf + ".attributes.name");
                    
                    String rxbytes = packet.getParam(thisIf + ".attributes.rx");
                    String txbytes = packet.getParam(thisIf + ".attributes.tx");

                    // check if we've seen this interface before on a previous
                    // run if not, we need to create a register for it
                    if(!netRegistersR.containsKey(name)) {
                        netRegistersR.put(name, new Register(source, _name + ".rxbytes", name));
                    }
                    if(!netRegistersW.containsKey(name)) {
                        netRegistersW.put(name, new Register(source, _name + ".txbytes", name));
                    }

                    // get the register for this interface
                    Register regR = (Register) netRegistersR.get(name);
                    Register regW = (Register) netRegistersW.get(name);

                    // get the packet data
                    int netRbytes, netWbytes;
                    try {
                        if(rxbytes==null || txbytes==null) {
                            throw new NumberFormatException("Network data invalid");
                        }
                        netRbytes = Integer.parseInt(rxbytes);
                        netWbytes = Integer.parseInt(txbytes);
                    } catch (NumberFormatException e) {
                        _logger.write(this.toString(), Logger.WARNING, "Received packet from "+source+" with bad network information: "+e);
                        // don't try to continue and process, try next interface
                        break;
                    }
                    
                    int newThresholdR = checkAttributeThreshold(netRbytes, regR);
                    int newThresholdW = checkAttributeThreshold(netWbytes, regW);

                    // say which disk had the problem
                    String attributeNameR = "Network rx bytes on " + name;
                    String attributeNameW = "Network tx bytes on " + name;

                    processAlert(newThresholdR, attributeNameR, regR, source, String.valueOf(netRbytes));
                    processAlert(newThresholdW, attributeNameW, regW, source, String.valueOf(netWbytes));
                }
            }
        }
    }

    /**
     * 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.cms.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---
    
    /**
     * Checks a piece of current data, and returns the
     * threshold it breaches, if any.
     *
     * @param value the current value
     * @param reg the Register for the host
     * @return the threshold level breached, if any
     */
    private int checkAttributeThreshold(double value, Register reg) {
        for(int thresholdLevel = Alert.thresholdLevels.length - 1; thresholdLevel >= 0; thresholdLevel--) {
            if (reg.getThreshold(thresholdLevel) != -1.0) {
                // normal check - has the value gone *over* the threshold
                if(((double) reg.getThreshold(thresholdLevel)) < value) {
                    return thresholdLevel;
                }
            }
        }
        return Alert.thresholdNORMAL;
    }

//---ACCESSOR/MUTATOR METHODS---
    
    /**
     * Returns a reference to a specific Queue for this
     * monitor. This Queue returns only the data packets
     * (based on type) that we want too look at.
     *
     * @return a reference to a Queue
     */
    protected Queue getQueue() {
        return MonitorManager.getInstance().getDataQueue();
    }
    
//---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 = "NetIO";
    
    /**
     * A reference to the configuration proxy in use
     */
    private ConfigurationProxy _cp = ConfigurationProxy.getInstance();
    
    /**
     * A HashMap of Registers (or groups of Registers), one
     * for each host we're monitoring (reads).
     */
    private HashMap _hostsR = new HashMap();
    
    /**
     * A HashMap of Registers (or groups of Registers), one
     * for each host we're monitoring (writes).
     */
    private HashMap _hostsW = new HashMap();

//---STATIC ATTRIBUTES---

}
Revision:	1.1
Committed:	Sun Mar 9 21:49:13 2003 UTC (21 years, 2 months ago) by tdb
Branch:	MAIN
Log Message:	Added support for all the new stuff that ihost provides us with. Ideally this lot needs to be revamped some day, but for now this brings it all back up to date. The biggest change is in the Disk monitor. It wasn't overly neat before, so I've tidied that up, and also added support for inode monitoring. Created the DiskIO, NetIO, and Paging monitors to support new types of data we now handle. The first two sprung from the Disk monitor, whilst the last is pretty normal. Configuration has been updated to support the new monitors, although I don't really have a feel for thresholds for the new types of data.
#	Content
1	/*
2	* i-scream central monitoring system
3	* http://www.i-scream.org.uk
4	* Copyright (C) 2000-2002 i-scream
5	*
6	* This program is free software; you can redistribute it and/or
7	* modify it under the terms of the GNU General Public License
8	* as published by the Free Software Foundation; either version 2
9	* of the License, or (at your option) any later version.
10	*
11	* This program is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	* GNU General Public License for more details.
15	*
16	* You should have received a copy of the GNU General Public License
17	* along with this program; if not, write to the Free Software
18	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19	*/
20
21	//---PACKAGE DECLARATION---
22	package uk.org.iscream.cms.server.client.monitors;
23
24	//---IMPORTS---
25	import java.util.HashMap;
26	import java.util.HashSet;
27	import java.util.Set;
28	import java.util.Iterator;
29	import uk.org.iscream.cms.server.client.*;
30	import uk.org.iscream.cms.server.core.*;
31	import uk.org.iscream.cms.util.*;
32	import uk.org.iscream.cms.server.componentmanager.*;
33
34	/**
35	* This Monitor watches the network IO for all machines
36	*
37	* @author $Author$
38	* @version $Id$
39	*/
40	public class NetIO__Monitor extends MonitorSkeleton {
41
42	//---FINAL ATTRIBUTES---
43
44	/**
45	* The current CVS revision of this class
46	*/
47	public final String REVISION = "$Revision: 1.1 $";
48
49	/**
50	* A description of this monitor
51	*/
52	public final String DESC = "Monitors network IO on all hosts.";
53
54	//---STATIC METHODS---
55
56	//---CONSTRUCTORS---
57
58	//---PUBLIC METHODS---
59
60	/**
61	* Analyse a packet of data, and generate an alert if
62	* necessary.
63	*
64	* @param packet the XMLPacket to analyse
65	*/
66	public void analysePacket(XMLPacket packet) {
67	String source = packet.getParam("packet.attributes.machine_name");
68	if (!_hostsR.containsKey(source)) {
69	_hostsR.put(source, new HashMap());
70	}
71	if (!_hostsW.containsKey(source)) {
72	_hostsW.put(source, new HashMap());
73	}
74
75	HashMap netRegistersR = (HashMap) _hostsR.get(source);
76	HashMap netRegistersW = (HashMap) _hostsW.get(source);
77
78	// key prefix
79	String keyPrefix = "packet.net.p";
80
81	// a temporary holder for all the network interfaces we find
82	HashSet netifs = new HashSet();
83
84	// unfortunatly we need to check the whole packet to find
85	// the interfaces, and then get the data attributes
86	Set packetSet = packet.getSet();
87	Iterator i = packetSet.iterator();
88	while (i.hasNext()) {
89	String dataKey = (String) i.next();
90	if(dataKey.startsWith(keyPrefix)) {
91	// pos is after "packet.net.p"
92	int pos = keyPrefix.length();
93	String ifNumber = dataKey.substring(pos, dataKey.indexOf('.', pos));
94	String thisIf = keyPrefix.concat(ifNumber);
95
96	if(!netifs.contains(thisIf)) {
97	// add the interface to our list
98	netifs.add(thisIf);
99
100	String name = packet.getParam(thisIf + ".attributes.name");
101
102	String rxbytes = packet.getParam(thisIf + ".attributes.rx");
103	String txbytes = packet.getParam(thisIf + ".attributes.tx");
104
105	// check if we've seen this interface before on a previous
106	// run if not, we need to create a register for it
107	if(!netRegistersR.containsKey(name)) {
108	netRegistersR.put(name, new Register(source, _name + ".rxbytes", name));
109	}
110	if(!netRegistersW.containsKey(name)) {
111	netRegistersW.put(name, new Register(source, _name + ".txbytes", name));
112	}
113
114	// get the register for this interface
115	Register regR = (Register) netRegistersR.get(name);
116	Register regW = (Register) netRegistersW.get(name);
117
118	// get the packet data
119	int netRbytes, netWbytes;
120	try {
121	if(rxbytes==null \|\| txbytes==null) {
122	throw new NumberFormatException("Network data invalid");
123	}
124	netRbytes = Integer.parseInt(rxbytes);
125	netWbytes = Integer.parseInt(txbytes);
126	} catch (NumberFormatException e) {
127	_logger.write(this.toString(), Logger.WARNING, "Received packet from "+source+" with bad network information: "+e);
128	// don't try to continue and process, try next interface
129	break;
130	}
131
132	int newThresholdR = checkAttributeThreshold(netRbytes, regR);
133	int newThresholdW = checkAttributeThreshold(netWbytes, regW);
134
135	// say which disk had the problem
136	String attributeNameR = "Network rx bytes on " + name;
137	String attributeNameW = "Network tx bytes on " + name;
138
139	processAlert(newThresholdR, attributeNameR, regR, source, String.valueOf(netRbytes));
140	processAlert(newThresholdW, attributeNameW, regW, source, String.valueOf(netWbytes));
141	}
142	}
143	}
144	}
145
146	/**
147	* Overrides the {@link java.lang.Object#toString() Object.toString()}
148	* method to provide clean logging (every class should have this).
149	*
150	* This uses the uk.org.iscream.cms.util.NameFormat class
151	* to format the toString()
152	*
153	* @return the name of this class and its CVS revision
154	*/
155	public String toString() {
156	return FormatName.getName(
157	_name,
158	getClass().getName(),
159	REVISION);
160	}
161
162	/**
163	* return the String representation of what the monitor does
164	*/
165	public String getDescription(){
166	return DESC;
167	}
168
169	//---PRIVATE METHODS---
170
171	/**
172	* Checks a piece of current data, and returns the
173	* threshold it breaches, if any.
174	*
175	* @param value the current value
176	* @param reg the Register for the host
177	* @return the threshold level breached, if any
178	*/
179	private int checkAttributeThreshold(double value, Register reg) {
180	for(int thresholdLevel = Alert.thresholdLevels.length - 1; thresholdLevel >= 0; thresholdLevel--) {
181	if (reg.getThreshold(thresholdLevel) != -1.0) {
182	// normal check - has the value gone over the threshold
183	if(((double) reg.getThreshold(thresholdLevel)) < value) {
184	return thresholdLevel;
185	}
186	}
187	}
188	return Alert.thresholdNORMAL;
189	}
190
191	//---ACCESSOR/MUTATOR METHODS---
192
193	/**
194	* Returns a reference to a specific Queue for this
195	* monitor. This Queue returns only the data packets
196	* (based on type) that we want too look at.
197	*
198	* @return a reference to a Queue
199	*/
200	protected Queue getQueue() {
201	return MonitorManager.getInstance().getDataQueue();
202	}
203
204	//---ATTRIBUTES---
205
206	/**
207	* This is the friendly identifier of the
208	* component this class is running in.
209	* eg, a Filter may be called "filter1",
210	* If this class does not have an owning
211	* component, a name from the configuration
212	* can be placed here. This name could also
213	* be changed to null for utility classes.
214	*/
215	private String _name = "NetIO";
216
217	/**
218	* A reference to the configuration proxy in use
219	*/
220	private ConfigurationProxy _cp = ConfigurationProxy.getInstance();
221
222	/**
223	* A HashMap of Registers (or groups of Registers), one
224	* for each host we're monitoring (reads).
225	*/
226	private HashMap _hostsR = new HashMap();
227
228	/**
229	* A HashMap of Registers (or groups of Registers), one
230	* for each host we're monitoring (writes).
231	*/
232	private HashMap _hostsW = new HashMap();
233
234	//---STATIC ATTRIBUTES---
235
236	}