server/filter/FilterMain.java

//---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.32 2002/03/19 16:37:28 tdb Exp $
 */
public class FilterMain implements Component {

//---FINAL ATTRIBUTES---

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