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.33 2002/03/20 13:05:49 tdb Exp $
 */
public class FilterMain implements Component {

//---FINAL ATTRIBUTES---

    /**
     * The current CVS revision of this class
     */
    public static final String REVISION = "$Revision: 1.33 $";
    
//---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.34
Committed:	Fri Mar 22 10:43:06 2002 UTC (22 years, 2 months ago) by tdb
Branch:	MAIN
Changes since 1.33:	+8 -3 lines
Log Message:	Split the CORBA side of the filter in two. The Filter interface still does the receiving of data, just like it used to. This can optionally be turned off in the configuration if required. The new interface, FilterInfo, is used to provide information (host and ports) to other parts of the server about the Filter - namely the FilterManager. This split has been done so that the data receiving part of the Filter can be turned off, without breaking the FilterManager.
#	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.33 2002/03/20 13:05:49 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.33 $";
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(queue);
180	_refman.bindToOrb(filterServant, "iscream.Filter." + FilterMain.NAME);
181	}
182
183	// FilterInfoServant start (to provide filter information to the server)
184	_logger.write(toString(), Logger.SYSINIT, "starting Servant to provide filter information");
185	FilterInfoServant filterInfoServant = new FilterInfoServant(TCPListenPort, UDPListenPort);
186	_refman.bindToOrb(filterInfoServant, "iscream.FilterInfo." + FilterMain.NAME);
187
188	_logger.write(toString(), Logger.SYSINIT, "started");
189	}
190
191	/**
192	* Does a dependency check. Used mainly at startup to
193	* see if the required dependencies (components) are up
194	* and running.
195	*
196	* @return a boolean value, true if the depdencies are satisfied
197	*/
198	public boolean depCheck() {
199	try {
200	org.omg.CORBA.Object obj;
201	// first check the ConfigurationManager is alive
202	obj = _refman.getCORBARef("iscream.ConfigurationManager");
203	// then suss out our parent filter
204	ConfigurationProxy cp = ConfigurationProxy.getInstance();
205	String parentFilterName = cp.getProperty("Filter." + FilterMain.NAME, "Filter.parentFilter");
206	// finally check the parent filter is alive
207	obj = _refman.getCORBARef("iscream.Filter." + parentFilterName);
208	} catch(ComponentCORBAException e) {
209	System.err.println(toString() + ": Dependency Failure: "+e);
210	return false;
211	} catch(PropertyNotFoundException e) {
212	System.err.println(toString() + ": Unable to obtain configuration: "+e);
213	return false;
214	}
215	// dependency check suceeded
216	return true;
217	}
218
219	/**
220	* Overrides the {@link java.lang.Object#toString() Object.toString()}
221	* method to provide clean logging (every class should have this).
222	*
223	* This uses the uk.org.iscream.cms.server.util.NameFormat class
224	* to format the toString()
225	*
226	* @return the name of this class and its CVS revision
227	*/
228	public String toString() {
229	return FormatName.getName(
230	NAME,
231	getClass().getName(),
232	REVISION);
233	}
234
235	//---PRIVATE METHODS---
236
237	//---ACCESSOR/MUTATOR METHODS---
238
239	//---ATTRIBUTES---
240
241	/**
242	* This holds a reference to the
243	* system logger that is being used.
244	*/
245	private Logger _logger;
246
247	/**
248	* A reference to the reference manager in use
249	*/
250	private ReferenceManager _refman = ReferenceManager.getInstance();
251
252	//---STATIC ATTRIBUTES---
253
254	/**
255	* The friendly name for this component, used by
256	* all related classes.
257	* This is set from the configuration.
258	*/
259	public static String NAME;
260
261	}