server/client/MonitorManager.java

//---PACKAGE DECLARATION---
package uk.ac.ukc.iscream.client;

//---IMPORTS---
import uk.ac.ukc.iscream.componentmanager.*;
import uk.ac.ukc.iscream.core.*;
import uk.ac.ukc.iscream.util.*;
import java.util.*;

/**
 * A manager for the Monitors.
 *
 * @author  $Author: ajm4 $
 * @version $Id: MonitorManager.java,v 1.3 2001/03/02 00:15:59 ajm4 Exp $
 */
class MonitorManager extends Thread {

//---FINAL ATTRIBUTES---

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

    /**
     * Return a reference to the single class.
     * Construct it if it does not already exist, otherwise just return the reference.
     */
    public static MonitorManager getInstance() {
        if (_instance == null){
            _instance = new MonitorManager();
        }
        return _instance;
    }

//---CONSTRUCTORS---

    private MonitorManager() {
        _queue = ClientMain._monitorQueue;
        _qID = _queue.getQueue();
        _logger.write(toString(), Logger.SYSINIT, "Initialising");
        _logger.write(toString(), Logger.SYSMSG, "Creating monitor pipeline for plugin monitors ...");
        
        // get the configuration for this plug-in setup
        Configuration config = _refman.getCM().getConfiguration(_name);
        String pluginsPackage = config.getProperty("Monitor.PluginsPackage");
        String pluginsList = config.getProperty("Monitor.Plugins");
        
        StringTokenizer st = new StringTokenizer(pluginsList, ";");
        
        while(st.hasMoreTokens()) {
            String className = pluginsPackage + "." + st.nextToken() + _suffix;
            _logger.write(toString(), Logger.DEBUG, "Attempting to create plugin: "+className);
            
            // Create an instance of the specified PluginMonitor to include
            // within the monitorPipe.  Add it to the monitorPipeline
            try {
                PluginMonitor pm = (PluginMonitor)ClassLoader.getSystemClassLoader().loadClass(className).newInstance();
                _monitorPipeline.add(pm);
                _logger.write(toString(), Logger.DEBUG, "Added monitor: "+className+" ("+pm.getDescription()+")");
            }
            catch (InstantiationException e){
                _logger.write(toString(), Logger.ERROR, "Failed to instantiate "+className+" to the plugin monitor pipeline.");
                _logger.write(toString(), Logger.ERROR, e.getMessage());
            }
            catch (Exception e){
                _logger.write(toString(), Logger.ERROR, "Failed to add "+className+" to the plugin monitor pipeline.");
                _logger.write(toString(), Logger.ERROR, e.toString());
            }
        }
        _logger.write(toString(), Logger.SYSMSG, "The monitor pipeline has been set up with "+_monitorPipeline.size()+" plugin monitors.");
    }

//---PUBLIC METHODS---
    
    public void run() {
        // construct now, and use multiple times
        XMLPacketMaker xmlPacketMaker = new XMLPacketMaker();
        
        boolean run=true;
        while(run) {
            // attempt to get some data from the Queue
            String xml = "";
            try {
                xml = (String) _queue.get(_qID);
            }
            catch(InvalidQueueException e) {
                _logger.write(toString(), Logger.ERROR, "Queue failure: "+e);
            }
            
            // make an XML packet
            XMLPacket packet = null;
            
            try {
                packet = xmlPacketMaker.createXMLPacket(xml);
            } catch(InvalidXMLException e) {
                _logger.write(toString(), Logger.ERROR, "Invalid XML: "+e);
                // skip the rest of this loop iteration
                continue;
            }
                        
            // for each monitor in the pipeline...
            Iterator pluginMonitors = _monitorPipeline.iterator();
            while (pluginMonitors.hasNext()){
                PluginMonitor monitor = (PluginMonitor)pluginMonitors.next();
                monitor.analysePacket(packet);
            }
        }
    }

    /**
     * Overrides the {@link java.lang.Object#toString() Object.toString()}
     * method to provide clean logging (every class should have this).
     *
     * This uses the uk.ac.ukc.iscream.util.FormatName 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);
    }

//---PRIVATE METHODS---

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

//---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 = ClientMain.NAME;

    /**
     * This holds a reference to the
     * system logger that is being used.
     */
    private Logger _logger = ReferenceManager.getInstance().getLogger();
    
    /**
     * A reference to the reference manager in use
     */
    private ReferenceManager _refman = ReferenceManager.getInstance();
    
    /**
     * A reference to our Queue
     */
    private Queue _queue;
    
    /**
     * Our queue ID
     */
    private int _qID;
    
    /**
     * file name suffix for plugin monitor classes:
     */
    private final String _suffix = "__Monitor";
    
    /**
     * LinkedList for holding the PluginMonitor objects (the pipeline).
     */
    private LinkedList _monitorPipeline = new LinkedList();

//---STATIC ATTRIBUTES---

    /**
     * A reference to the single instance of this class
     */
    private static MonitorManager _instance;

}
Revision:	1.4
Committed:	Sat Mar 10 04:03:03 2001 UTC (23 years, 2 months ago) by tdb
Branch:	MAIN
Changes since 1.3:	+6 -5 lines
Log Message:	Changes due to the alterations in the XML creation code. The XMLPacketMaker now only needs to be created once, and can then be called multiple times to create XML packets. This should be more efficient in the long run.
#	User	Rev	Content
1	tdb	1.1	//---PACKAGE DECLARATION---
2			package uk.ac.ukc.iscream.client;
3
4			//---IMPORTS---
5			import uk.ac.ukc.iscream.componentmanager.*;
6			import uk.ac.ukc.iscream.core.*;
7			import uk.ac.ukc.iscream.util.*;
8			import java.util.*;
9
10			/**
11			* A manager for the Monitors.
12			*
13	tdb	1.4	* @author $Author: ajm4 $
14			* @version $Id: MonitorManager.java,v 1.3 2001/03/02 00:15:59 ajm4 Exp $
15	tdb	1.1	*/
16	ajm	1.3	class MonitorManager extends Thread {
17	tdb	1.1
18			//---FINAL ATTRIBUTES---
19
20			/**
21			* The current CVS revision of this class
22			*/
23	tdb	1.4	public static final String REVISION = "$Revision: 1.3 $";
24	tdb	1.1
25			//---STATIC METHODS---
26
27	ajm	1.3	/**
28			* Return a reference to the single class.
29			* Construct it if it does not already exist, otherwise just return the reference.
30			*/
31			public static MonitorManager getInstance() {
32			if (_instance == null){
33			_instance = new MonitorManager();
34			}
35			return _instance;
36			}
37
38	tdb	1.1	//---CONSTRUCTORS---
39
40	ajm	1.3	private MonitorManager() {
41			_queue = ClientMain._monitorQueue;
42			_qID = _queue.getQueue();
43			_logger.write(toString(), Logger.SYSINIT, "Initialising");
44			_logger.write(toString(), Logger.SYSMSG, "Creating monitor pipeline for plugin monitors ...");
45
46			// get the configuration for this plug-in setup
47			Configuration config = _refman.getCM().getConfiguration(_name);
48			String pluginsPackage = config.getProperty("Monitor.PluginsPackage");
49			String pluginsList = config.getProperty("Monitor.Plugins");
50
51			StringTokenizer st = new StringTokenizer(pluginsList, ";");
52
53			while(st.hasMoreTokens()) {
54			String className = pluginsPackage + "." + st.nextToken() + _suffix;
55			_logger.write(toString(), Logger.DEBUG, "Attempting to create plugin: "+className);
56
57			// Create an instance of the specified PluginMonitor to include
58			// within the monitorPipe. Add it to the monitorPipeline
59			try {
60			PluginMonitor pm = (PluginMonitor)ClassLoader.getSystemClassLoader().loadClass(className).newInstance();
61			_monitorPipeline.add(pm);
62			_logger.write(toString(), Logger.DEBUG, "Added monitor: "+className+" ("+pm.getDescription()+")");
63			}
64			catch (InstantiationException e){
65			_logger.write(toString(), Logger.ERROR, "Failed to instantiate "+className+" to the plugin monitor pipeline.");
66			_logger.write(toString(), Logger.ERROR, e.getMessage());
67			}
68			catch (Exception e){
69			_logger.write(toString(), Logger.ERROR, "Failed to add "+className+" to the plugin monitor pipeline.");
70			_logger.write(toString(), Logger.ERROR, e.toString());
71			}
72			}
73			_logger.write(toString(), Logger.SYSMSG, "The monitor pipeline has been set up with "+_monitorPipeline.size()+" plugin monitors.");
74	tdb	1.1	}
75
76			//---PUBLIC METHODS---
77
78			public void run() {
79	tdb	1.4	// construct now, and use multiple times
80			XMLPacketMaker xmlPacketMaker = new XMLPacketMaker();
81	ajm	1.3
82	tdb	1.1	boolean run=true;
83			while(run) {
84			// attempt to get some data from the Queue
85			String xml = "";
86			try {
87	ajm	1.3	xml = (String) _queue.get(_qID);
88	tdb	1.1	}
89			catch(InvalidQueueException e) {
90			_logger.write(toString(), Logger.ERROR, "Queue failure: "+e);
91			}
92
93			// make an XML packet
94	tdb	1.2	XMLPacket packet = null;
95	tdb	1.1
96	tdb	1.2	try {
97	tdb	1.4	packet = xmlPacketMaker.createXMLPacket(xml);
98	tdb	1.2	} catch(InvalidXMLException e) {
99			_logger.write(toString(), Logger.ERROR, "Invalid XML: "+e);
100			// skip the rest of this loop iteration
101			continue;
102			}
103
104	ajm	1.3	// for each monitor in the pipeline...
105			Iterator pluginMonitors = _monitorPipeline.iterator();
106			while (pluginMonitors.hasNext()){
107			PluginMonitor monitor = (PluginMonitor)pluginMonitors.next();
108			monitor.analysePacket(packet);
109	tdb	1.1	}
110			}
111			}
112
113			/**
114			* Overrides the {@link java.lang.Object#toString() Object.toString()}
115			* method to provide clean logging (every class should have this).
116			*
117			* This uses the uk.ac.ukc.iscream.util.FormatName class
118			* to format the toString()
119			*
120			* @return the name of this class and its CVS revision
121			*/
122			public String toString() {
123			return FormatName.getName(
124			_name,
125			getClass().getName(),
126			REVISION);
127			}
128
129			//---PRIVATE METHODS---
130
131			//---ACCESSOR/MUTATOR METHODS---
132
133			//---ATTRIBUTES---
134
135			/**
136			* This is the friendly identifier of the
137			* component this class is running in.
138			* eg, a Filter may be called "filter1",
139			* If this class does not have an owning
140			* component, a name from the configuration
141			* can be placed here. This name could also
142			* be changed to null for utility classes.
143			*/
144			private String _name = ClientMain.NAME;
145
146			/**
147			* This holds a reference to the
148			* system logger that is being used.
149			*/
150			private Logger _logger = ReferenceManager.getInstance().getLogger();
151
152			/**
153	ajm	1.3	* A reference to the reference manager in use
154			*/
155			private ReferenceManager _refman = ReferenceManager.getInstance();
156
157			/**
158			* A reference to our Queue
159	tdb	1.1	*/
160			private Queue _queue;
161	ajm	1.3
162			/**
163			* Our queue ID
164			*/
165			private int _qID;
166
167			/**
168			* file name suffix for plugin monitor classes:
169			*/
170			private final String _suffix = "__Monitor";
171
172			/**
173			* LinkedList for holding the PluginMonitor objects (the pipeline).
174			*/
175			private LinkedList _monitorPipeline = new LinkedList();
176	tdb	1.1
177			//---STATIC ATTRIBUTES---
178	ajm	1.3
179			/**
180			* A reference to the single instance of this class
181			*/
182			private static MonitorManager _instance;
183	tdb	1.1
184			}