server/filter/FilterMain.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.filter;

//---IMPORTS---
import uk.org.iscream.cms.server.util.*;
import uk.org.iscream.cms.server.core.*;
import uk.org.iscream.cms.server.componentmanager.*;
import uk.org.iscream.cms.server.filter.*;

/**
 * A Filter Startup Class
 * A filter is an iscream component.
 *
 * @author  $Author: tdb $
 * @version $Id: FilterMain.java,v 1.36 2002/05/21 16:47:17 tdb Exp $
 */
public class FilterMain implements Component {

//---FINAL ATTRIBUTES---

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

//---CONSTRUCTORS---
    
    /**
     * Constructs a Filter with the name given
     *
     * @param givenName the name
     */
    public FilterMain(String givenName) {
        NAME = givenName;
    }

//---PUBLIC METHODS---

    /**
     * Starts the Filter component
     */
    public void start() throws ComponentStartException {
        // get references to key objects
        _logger = _refman.getLogger();
        
        _logger.write(toString(), Logger.SYSINIT, "coming up");
        
        ConfigurationProxy cp = ConfigurationProxy.getInstance();
        
        // which input methods do we need to activate?
        // default to activating them
        boolean activateTCPReader = true;
        boolean activateUDPReader = true;
        boolean activateCORBAReader = true;
        
        // check for TCP Reader
        try {
            int tcp = Integer.parseInt(cp.getProperty("Filter." + FilterMain.NAME, "Filter.ActivateTCPReader"));
            activateTCPReader = (tcp == 1);
        } catch (PropertyNotFoundException e) {
            activateTCPReader = false;
        } catch (NumberFormatException e) {
            activateTCPReader = false;
        }
        // check for UDP Reader
        try {
            int udp = Integer.parseInt(cp.getProperty("Filter." + FilterMain.NAME, "Filter.ActivateUDPReader"));
            activateUDPReader = (udp == 1);
        } catch (PropertyNotFoundException e) {
            activateUDPReader = false;
        } catch (NumberFormatException e) {
            activateUDPReader = false;
        }
        // check for CORBA Reader
        try {
            int corba = Integer.parseInt(cp.getProperty("Filter." + FilterMain.NAME, "Filter.ActivateCORBAReader"));
            activateCORBAReader = (corba == 1);
        } catch (PropertyNotFoundException e) {
            activateCORBAReader = false;
        } catch (NumberFormatException e) {
            activateCORBAReader = false;
        }
        
        // need to use the Queue later on
        Queue queue;
        
        // there's little point starting a Queue and a FilterThread
        // if nothing is going to be giving us any data
        if(activateTCPReader || activateUDPReader || activateCORBAReader) {
            // see if this Queue needs a size limit
            try {
                int queueSizeLimit = Integer.parseInt(cp.getProperty("Filter." + FilterMain.NAME, "Queue.SizeLimit"));
                String queueRemoveAlgorithm = cp.getProperty("Filter." + FilterMain.NAME, "Queue.RemoveAlgorithm");
                int algorithm = StringUtils.getStringPos(queueRemoveAlgorithm, Queue.algorithms);
                if(algorithm != -1) {
                    _logger.write(toString(), Logger.DEBUG, "Starting Queue with size limit of "+queueSizeLimit+", using remove algorithm "+queueRemoveAlgorithm);
                    // we have valid values, so lets start it.
                    queue = new Queue(queueSizeLimit, algorithm);
                }
                else {
                    _logger.write(toString(), Logger.WARNING, "Bad Queue Algorithm configuration, not known: "+queueRemoveAlgorithm);
                    // just don't activate a limit
                    queue = new Queue();
                }
                
            } catch (PropertyNotFoundException e) {
                _logger.write(toString(), Logger.DEBUG, "Optional config not set: "+e);
                // just don't activate a limit
                queue = new Queue();
            } catch (NumberFormatException e) {
                _logger.write(toString(), Logger.WARNING, "Bad Queue SizeLimit configuration: "+e);
                // just don't activate a limit
                queue = new Queue();
            }
            
            // startup a monitor on this queue
            try {
                // try to get the interval, if this fails, we won't start up the monitor
                int queueMonitorInterval = Integer.parseInt(cp.getProperty("Filter." + FilterMain.NAME, "Queue.MonitorInterval"));
                String queueName = NAME + " Filter";
                queue.startMonitor(queueMonitorInterval*1000, queueName);
            } catch (PropertyNotFoundException e) {
                _logger.write(toString(), Logger.WARNING, "failed to find queue monitor config, disabling. " + e);
            }
            
            // Start a filter thread
            _logger.write(toString(), Logger.SYSINIT, "starting Filter Thread / Queue consumer");
            FilterThread filterThread = new FilterThread(queue);
            filterThread.start();
        }
        else {
            // it's pointless carrying on really...
            throw new ComponentStartException("Can't start Filter without any inbound data feeds");            
        }
        
        // the corba listener needs these to be set, so lets
        // make them something obviously invalid initially
        int TCPListenPort = -1;
        int UDPListenPort = -1;
        
        // TCP Reader start (for heartbeats)
        if(activateTCPReader) {
            try {
                // get the port number from the configuration
                TCPListenPort = Integer.parseInt(cp.getProperty("Filter." + FilterMain.NAME, "Filter.TCPListenPort"));
                // start the TCPReader
                _logger.write(toString(), Logger.SYSINIT, "starting Filter TCP listener");
                TCPReader tcpReader = new TCPReader(TCPListenPort, queue);
                tcpReader.start();
            } catch (PropertyNotFoundException e) {
                _logger.write(toString(), Logger.WARNING, "Unable to start TCPReader due to missing configuration: " + e);
            } catch (NumberFormatException e) {
                _logger.write(toString(), Logger.WARNING, "Unable to start TCPReader due to invalid configuration: " + e);
            }
        }
        
        // UDP Reader start (for inbound host data)
        if(activateUDPReader) {
            try {
                // get the port number from the configuration
                UDPListenPort = Integer.parseInt(cp.getProperty("Filter." + FilterMain.NAME, "Filter.UDPListenPort"));
                // start the UDPReader
                _logger.write(toString(), Logger.SYSINIT, "starting Filter UDP listener");
                UDPReader udpReader = new UDPReader(UDPListenPort, queue);
                udpReader.start();
            } catch (PropertyNotFoundException e) {
                _logger.write(toString(), Logger.WARNING, "Unable to start UDPReader due to missing configuration: " + e);
            } catch (NumberFormatException e) {
                _logger.write(toString(), Logger.WARNING, "Unable to start UDPReader due to invalid configuration: " + e);
            }
        }
        
        // FilterServant start (for inbound child filter data)
        if(activateCORBAReader) {
            // start the FilterServant
            _logger.write(toString(), Logger.SYSINIT, "starting Servant to listen for downstream filters");
            FilterServant filterServant = new FilterServant(queue);
            _refman.bindToOrb(filterServant, "iscream.Filter\\." + FilterMain.NAME);
        }
        
        // FilterInfoServant start (to provide filter information to the server)
        _logger.write(toString(), Logger.SYSINIT, "starting Servant to provide filter information");
        FilterInfoServant filterInfoServant = new FilterInfoServant(TCPListenPort, UDPListenPort);
        _refman.bindToOrb(filterInfoServant, "iscream.FilterInfo\\." + FilterMain.NAME);
        
        _logger.write(toString(), Logger.SYSINIT, "started");
    }
    
    /**
     * Does a dependency check. Used mainly at startup to
     * see if the required dependencies (components) are up
     * and running.
     *
     * @return a boolean value, true if the depdencies are satisfied
     */
    public boolean depCheck() {
        try {
            org.omg.CORBA.Object obj;
            // first check the ConfigurationManager is alive
            obj = _refman.getCORBARef("iscream.ConfigurationManager");
            // then suss out our parent filter
            ConfigurationProxy cp = ConfigurationProxy.getInstance();
            String parentFilterName = cp.getProperty("Filter." + FilterMain.NAME, "Filter.parentFilter");
            // finally check the parent filter is alive
            obj = _refman.getCORBARef("iscream.Filter\\." + parentFilterName);
        } catch(ComponentCORBAException e) {
            System.err.println(toString() + ": Dependency Failure: "+e);
            return false;
        } catch(PropertyNotFoundException e) {
            System.err.println(toString() + ": Unable to obtain configuration: "+e);
            return false;
        }
        // dependency check suceeded
        return true;
    }
    
    /**
     * 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.server.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);
    }

//---PRIVATE METHODS---

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

//---ATTRIBUTES---

    /**
     * This holds a reference to the
     * system logger that is being used.
     */
    private Logger _logger;

    /**
     * A reference to the reference manager in use
     */
    private ReferenceManager _refman = ReferenceManager.getInstance();

//---STATIC ATTRIBUTES---

    /**
     * The friendly name for this component, used by
     * all related classes.
     * This is set from the configuration.
     */
    public static String NAME;

}
Revision:	1.37
Committed:	Fri Sep 6 15:10:48 2002 UTC (21 years, 9 months ago) by tdb
Branch:	MAIN
Changes since 1.36:	+5 -5 lines
Log Message:	Fix for upgrade to Jacorb 1.4.1. It's our fault actually, we've not been correctly using the names when binding to the Naming Service. This needs to be fixed properly at some point, but for now I've changed changed the code so it "means" the same as it did before the upgrade.
#	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.filter;
23
24	//---IMPORTS---
25	import uk.org.iscream.cms.server.util.*;
26	import uk.org.iscream.cms.server.core.*;
27	import uk.org.iscream.cms.server.componentmanager.*;
28	import uk.org.iscream.cms.server.filter.*;
29
30	/**
31	* A Filter Startup Class
32	* A filter is an iscream component.
33	*
34	* @author $Author: tdb $
35	* @version $Id: FilterMain.java,v 1.36 2002/05/21 16:47:17 tdb Exp $
36	*/
37	public class FilterMain implements Component {
38
39	//---FINAL ATTRIBUTES---
40
41	/**
42	* The current CVS revision of this class
43	*/
44	public static final String REVISION = "$Revision: 1.36 $";
45
46	//---STATIC METHODS---
47
48	//---CONSTRUCTORS---
49
50	/**
51	* Constructs a Filter with the name given
52	*
53	* @param givenName the name
54	*/
55	public FilterMain(String givenName) {
56	NAME = givenName;
57	}
58
59	//---PUBLIC METHODS---
60
61	/**
62	* Starts the Filter component
63	*/
64	public void start() throws ComponentStartException {
65	// get references to key objects
66	_logger = _refman.getLogger();
67
68	_logger.write(toString(), Logger.SYSINIT, "coming up");
69
70	ConfigurationProxy cp = ConfigurationProxy.getInstance();
71
72	// which input methods do we need to activate?
73	// default to activating them
74	boolean activateTCPReader = true;
75	boolean activateUDPReader = true;
76	boolean activateCORBAReader = true;
77
78	// check for TCP Reader
79	try {
80	int tcp = Integer.parseInt(cp.getProperty("Filter." + FilterMain.NAME, "Filter.ActivateTCPReader"));
81	activateTCPReader = (tcp == 1);
82	} catch (PropertyNotFoundException e) {
83	activateTCPReader = false;
84	} catch (NumberFormatException e) {
85	activateTCPReader = false;
86	}
87	// check for UDP Reader
88	try {
89	int udp = Integer.parseInt(cp.getProperty("Filter." + FilterMain.NAME, "Filter.ActivateUDPReader"));
90	activateUDPReader = (udp == 1);
91	} catch (PropertyNotFoundException e) {
92	activateUDPReader = false;
93	} catch (NumberFormatException e) {
94	activateUDPReader = false;
95	}
96	// check for CORBA Reader
97	try {
98	int corba = Integer.parseInt(cp.getProperty("Filter." + FilterMain.NAME, "Filter.ActivateCORBAReader"));
99	activateCORBAReader = (corba == 1);
100	} catch (PropertyNotFoundException e) {
101	activateCORBAReader = false;
102	} catch (NumberFormatException e) {
103	activateCORBAReader = false;
104	}
105
106	// need to use the Queue later on
107	Queue queue;
108
109	// there's little point starting a Queue and a FilterThread
110	// if nothing is going to be giving us any data
111	if(activateTCPReader \|\| activateUDPReader \|\| activateCORBAReader) {
112	// see if this Queue needs a size limit
113	try {
114	int queueSizeLimit = Integer.parseInt(cp.getProperty("Filter." + FilterMain.NAME, "Queue.SizeLimit"));
115	String queueRemoveAlgorithm = cp.getProperty("Filter." + FilterMain.NAME, "Queue.RemoveAlgorithm");
116	int algorithm = StringUtils.getStringPos(queueRemoveAlgorithm, Queue.algorithms);
117	if(algorithm != -1) {
118	_logger.write(toString(), Logger.DEBUG, "Starting Queue with size limit of "+queueSizeLimit+", using remove algorithm "+queueRemoveAlgorithm);
119	// we have valid values, so lets start it.
120	queue = new Queue(queueSizeLimit, algorithm);
121	}
122	else {
123	_logger.write(toString(), Logger.WARNING, "Bad Queue Algorithm configuration, not known: "+queueRemoveAlgorithm);
124	// just don't activate a limit
125	queue = new Queue();
126	}
127
128	} catch (PropertyNotFoundException e) {
129	_logger.write(toString(), Logger.DEBUG, "Optional config not set: "+e);
130	// just don't activate a limit
131	queue = new Queue();
132	} catch (NumberFormatException e) {
133	_logger.write(toString(), Logger.WARNING, "Bad Queue SizeLimit configuration: "+e);
134	// just don't activate a limit
135	queue = new Queue();
136	}
137
138	// startup a monitor on this queue
139	try {
140	// try to get the interval, if this fails, we won't start up the monitor
141	int queueMonitorInterval = Integer.parseInt(cp.getProperty("Filter." + FilterMain.NAME, "Queue.MonitorInterval"));
142	String queueName = NAME + " Filter";
143	queue.startMonitor(queueMonitorInterval*1000, queueName);
144	} catch (PropertyNotFoundException e) {
145	_logger.write(toString(), Logger.WARNING, "failed to find queue monitor config, disabling. " + e);
146	}
147
148	// Start a filter thread
149	_logger.write(toString(), Logger.SYSINIT, "starting Filter Thread / Queue consumer");
150	FilterThread filterThread = new FilterThread(queue);
151	filterThread.start();
152	}
153	else {
154	// it's pointless carrying on really...
155	throw new ComponentStartException("Can't start Filter without any inbound data feeds");
156	}
157
158	// the corba listener needs these to be set, so lets
159	// make them something obviously invalid initially
160	int TCPListenPort = -1;
161	int UDPListenPort = -1;
162
163	// TCP Reader start (for heartbeats)
164	if(activateTCPReader) {
165	try {
166	// get the port number from the configuration
167	TCPListenPort = Integer.parseInt(cp.getProperty("Filter." + FilterMain.NAME, "Filter.TCPListenPort"));
168	// start the TCPReader
169	_logger.write(toString(), Logger.SYSINIT, "starting Filter TCP listener");
170	TCPReader tcpReader = new TCPReader(TCPListenPort, queue);
171	tcpReader.start();
172	} catch (PropertyNotFoundException e) {
173	_logger.write(toString(), Logger.WARNING, "Unable to start TCPReader due to missing configuration: " + e);
174	} catch (NumberFormatException e) {
175	_logger.write(toString(), Logger.WARNING, "Unable to start TCPReader due to invalid configuration: " + e);
176	}
177	}
178
179	// UDP Reader start (for inbound host data)
180	if(activateUDPReader) {
181	try {
182	// get the port number from the configuration
183	UDPListenPort = Integer.parseInt(cp.getProperty("Filter." + FilterMain.NAME, "Filter.UDPListenPort"));
184	// start the UDPReader
185	_logger.write(toString(), Logger.SYSINIT, "starting Filter UDP listener");
186	UDPReader udpReader = new UDPReader(UDPListenPort, queue);
187	udpReader.start();
188	} catch (PropertyNotFoundException e) {
189	_logger.write(toString(), Logger.WARNING, "Unable to start UDPReader due to missing configuration: " + e);
190	} catch (NumberFormatException e) {
191	_logger.write(toString(), Logger.WARNING, "Unable to start UDPReader due to invalid configuration: " + e);
192	}
193	}
194
195	// FilterServant start (for inbound child filter data)
196	if(activateCORBAReader) {
197	// start the FilterServant
198	_logger.write(toString(), Logger.SYSINIT, "starting Servant to listen for downstream filters");
199	FilterServant filterServant = new FilterServant(queue);
200	_refman.bindToOrb(filterServant, "iscream.Filter\\." + FilterMain.NAME);
201	}
202
203	// FilterInfoServant start (to provide filter information to the server)
204	_logger.write(toString(), Logger.SYSINIT, "starting Servant to provide filter information");
205	FilterInfoServant filterInfoServant = new FilterInfoServant(TCPListenPort, UDPListenPort);
206	_refman.bindToOrb(filterInfoServant, "iscream.FilterInfo\\." + FilterMain.NAME);
207
208	_logger.write(toString(), Logger.SYSINIT, "started");
209	}
210
211	/**
212	* Does a dependency check. Used mainly at startup to
213	* see if the required dependencies (components) are up
214	* and running.
215	*
216	* @return a boolean value, true if the depdencies are satisfied
217	*/
218	public boolean depCheck() {
219	try {
220	org.omg.CORBA.Object obj;
221	// first check the ConfigurationManager is alive
222	obj = _refman.getCORBARef("iscream.ConfigurationManager");
223	// then suss out our parent filter
224	ConfigurationProxy cp = ConfigurationProxy.getInstance();
225	String parentFilterName = cp.getProperty("Filter." + FilterMain.NAME, "Filter.parentFilter");
226	// finally check the parent filter is alive
227	obj = _refman.getCORBARef("iscream.Filter\\." + parentFilterName);
228	} catch(ComponentCORBAException e) {
229	System.err.println(toString() + ": Dependency Failure: "+e);
230	return false;
231	} catch(PropertyNotFoundException e) {
232	System.err.println(toString() + ": Unable to obtain configuration: "+e);
233	return false;
234	}
235	// dependency check suceeded
236	return true;
237	}
238
239	/**
240	* Overrides the {@link java.lang.Object#toString() Object.toString()}
241	* method to provide clean logging (every class should have this).
242	*
243	* This uses the uk.org.iscream.cms.server.util.NameFormat class
244	* to format the toString()
245	*
246	* @return the name of this class and its CVS revision
247	*/
248	public String toString() {
249	return FormatName.getName(
250	NAME,
251	getClass().getName(),
252	REVISION);
253	}
254
255	//---PRIVATE METHODS---
256
257	//---ACCESSOR/MUTATOR METHODS---
258
259	//---ATTRIBUTES---
260
261	/**
262	* This holds a reference to the
263	* system logger that is being used.
264	*/
265	private Logger _logger;
266
267	/**
268	* A reference to the reference manager in use
269	*/
270	private ReferenceManager _refman = ReferenceManager.getInstance();
271
272	//---STATIC ATTRIBUTES---
273
274	/**
275	* The friendly name for this component, used by
276	* all related classes.
277	* This is set from the configuration.
278	*/
279	public static String NAME;
280
281	}