ViewVC Help

View File | Revision Log | Show Annotations | Revision Graph | Root Listing

root/i-scream/projects/cms/source/server/uk/org/iscream/cms/server/filter/FilterMain.java

Comparing projects/cms/source/server/uk/org/iscream/cms/server/filter/FilterMain.java (file contents):
Revision 1.10 by tdb, Mon Nov 27 21:46:25 2000 UTC vs.
Revision 1.30 by tdb, Fri Mar 16 16:11:32 2001 UTC

#	Line 1 | Line 1
1		//---PACKAGE DECLARATION---
2	+	package uk.org.iscream.filter;
3
4		//---IMPORTS---
5	<	import uk.ac.ukc.iscream.core.*;
6	<	import uk.ac.ukc.iscream.filter.*;
7	<	import org.omg.CORBA.*;
8	<	import org.omg.CosNaming.*;
8	<	import org.omg.PortableServer.*;
5	>	import uk.org.iscream.util.*;
6	>	import uk.org.iscream.core.*;
7	>	import uk.org.iscream.componentmanager.*;
8	>	import uk.org.iscream.filter.*;
9
10		/**
11		* A Filter Startup Class
12	+	* A filter is an iscream component.
13		*
14		* @author  $Author$
15		* @version $Id$
16		*/
17	<	class FilterMain {
17	>	public class FilterMain implements Component {
18
19		//---FINAL ATTRIBUTES---
20
#	Line 24 | Line 25 | class FilterMain {
25
26		//---STATIC METHODS---
27
28	<	public static void main(String[] args) {
29	<	System.setProperty("org.omg.CORBA.ORBClass","jacorb.orb.ORB");
30	<	System.setProperty("org.omg.CORBA.ORBSingletonClass","jacorb.orb.ORBSingleton");
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	<	// get our name from the command line
32	<	String ourName = "";
33	<	if (args.length == 1) {
34	<	ourName = args[0];
35	<	}
36	<	else {
37	<	usage();
38	<	}
48	>	_logger.write(toString(), Logger.SYSINIT, "coming up");
49
50	<	// can't have a real toString() :)
41	<	String toString = "Filter{" + ourName + "}(" + REVISION.substring(11, REVISION.length() - 2) + ")";
50	>	ConfigurationProxy cp = ConfigurationProxy.getInstance();
51
52	<	try {
53	<	ORB orb = ORB.init(args, null);
54	<
55	<	// something to hold objects
56	<	org.omg.CORBA.Object objRef = null;
57	<
58	<	// get the Root POA
59	<	objRef = orb.resolve_initial_references("RootPOA");
60	<	POA poa = POAHelper.narrow(objRef);
61	<
62	<	// get a hook to the name service
63	<	objRef = orb.resolve_initial_references("NameService");
64	<	NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef);
65	<
66	<	// get a ref to the ConfigurationManager, Logger & the FilterManager
67	<
68	<	objRef = ncRef.resolve(ncRef.to_name("iscream.ConfigurationManager"));
69	<	ConfigurationManager configManager = ConfigurationManagerHelper.narrow(objRef);
70	<
62	<	objRef = ncRef.resolve(ncRef.to_name("iscream.Logger"));
63	<	Logger logger = LoggerHelper.narrow(objRef);
64	<
65	<	logger.write(toString, Logger.SYSINIT, "coming up");
66	<
67	<
68	<	// **** THIS SECTION WILL NEED CHANGING TO GET RELEVANT CONFIG
69	<	// **** Please ignore this block of code, it's just "copy/paste" :)
70	<
71	<	// get the config
72	<	Configuration myConfig = configManager.getConfiguration(ourName);
73	<
74	<	// read some config here
75	<	int UDPport = 0;
76	<	int TCPport = 0;
77	<	String parentFilterName = null;
78	<
79	<	// did we?
80	<	if (myConfig == null) {
81	<	System.out.println("Failed: is it there?, can you read it?");
82	<	System.exit(1);
83	<	} else {
84	<
85	<	// get the property
86	<	try {
87	<	//QUERY HERE.... ???
88	<	UDPport = new Integer(myConfig.getProperty("Filter.UDPlistenPort")).intValue();
89	<	TCPport = new Integer(myConfig.getProperty("Filter.TCPlistenPort")).intValue();
90	<	parentFilterName = myConfig.getProperty("Filter.parentFilter");
91	<	} catch (org.omg.CORBA.MARSHAL e) {
92	<	System.out.println("Caught org.omg.CORBA.MARSHAL, must be a null we got back");
93	<	//System.exit(1);
94	<	}
52	>	int UDPListenPort, TCPListenPort;
53	>	try {
54	>	UDPListenPort = Integer.parseInt(cp.getProperty(FilterMain.NAME, "Filter.UDPListenPort"));
55	>	TCPListenPort = Integer.parseInt(cp.getProperty(FilterMain.NAME, "Filter.TCPListenPort"));
56	>	} catch (PropertyNotFoundException e) {
57	>	throw new ComponentStartException("Unable to obtain requried configuration property for component: " + e);
58	>	}
59	>
60	>	// setup a queue
61	>	Queue queue;
62	>	// see if this Queue needs a size limit
63	>	try {
64	>	int queueSizeLimit = Integer.parseInt(cp.getProperty(FilterMain.NAME, "Queue.SizeLimit"));
65	>	String queueRemoveAlgorithm = cp.getProperty(FilterMain.NAME, "Queue.RemoveAlgorithm");
66	>	int algorithm = StringUtils.getStringPos(queueRemoveAlgorithm, Queue.algorithms);
67	>	if(algorithm != -1) {
68	>	_logger.write(toString(), Logger.DEBUG, "Starting Queue with size limit of "+queueSizeLimit+", using remove algorithm "+queueRemoveAlgorithm);
69	>	// we have valid values, so lets start it.
70	>	queue = new Queue(queueSizeLimit, algorithm);
71		}
72	+	else {
73	+	_logger.write(toString(), Logger.WARNING, "Bad Queue Algorithm configuration, not known: "+queueRemoveAlgorithm);
74	+	// just don't activate a limit
75	+	queue = new Queue();
76	+	}
77
78	<	logger.write(toString, Logger.SYSINIT, "configured");
79	<
80	<	// **** END COMMENT
81	<
82	<	// **** INITIAL FILTER MANAGER COMMUNICATIONS HERE
83	<
84	<	// get a root (CHANGE to use FilterManager)
85	<	objRef = ncRef.resolve(ncRef.to_name("iscream.Filter." + parentFilterName));
86	<	Filter parentFilter = FilterHelper.narrow(objRef);
78	>	} catch (PropertyNotFoundException e) {
79	>	_logger.write(toString(), Logger.DEBUG, "Optional config not set: "+e);
80	>	// just don't activate a limit
81	>	queue = new Queue();
82	>	} catch (NumberFormatException e) {
83	>	_logger.write(toString(), Logger.WARNING, "Bad Queue SizeLimit configuration: "+e);
84	>	// just don't activate a limit
85	>	queue = new Queue();
86	>	}
87	>
88	>	// startup a monitor on this queue
89	>	try {
90	>	// try to get the interval, if this fails, we won't start up the monitor
91	>	int queueMonitorInterval = Integer.parseInt(cp.getProperty(FilterMain.NAME, "Queue.MonitorInterval"));
92	>	String queueName = NAME + " Filter";
93	>	queue.startMonitor(queueMonitorInterval*1000, queueName);
94	>	} catch (PropertyNotFoundException e) {
95	>	_logger.write(toString(), Logger.WARNING, "failed to find queue monitor config, disabling. " + e);
96	>	}
97	>
98	>	// Start a filter thread
99	>	_logger.write(toString(), Logger.SYSINIT, "starting Filter Thread / Queue consumer");
100	>	FilterThread filterThread = new FilterThread(queue);
101	>	filterThread.start();
102	>
103	>	// FilterServant start (for inbound child filter data)
104	>	_logger.write(toString(), Logger.DEBUG, "starting Servant to listen for downstream filters");
105	>	FilterServant filterServant = new FilterServant(TCPListenPort, UDPListenPort, queue);
106	>	_refman.bindToOrb(filterServant, "iscream.Filter." + FilterMain.NAME);
107
108	<	// SETUP our Servant
109	<
110	<	// create the FilterServant
111	<	FilterServant filterServant = new FilterServant(logger, parentFilter, ourName, new Integer(TCPport).toString() , new Integer(UDPport).toString());
108	>	// UDL Reader start (for inbound host data)
109	>	_logger.write(toString(), Logger.SYSINIT, "starting Filter UDP listener");
110	>	UDPReader udpReader = new UDPReader(UDPListenPort, queue);
111	>	udpReader.start();
112
113	<	// register ourselves
114	<
115	<	// and advertise it to the naming context
116	<	objRef = poa.servant_to_reference(filterServant);
117	<	ncRef.bind(ncRef.to_name("iscream.Filter."+ourName), objRef);
118	<
119	<	// **** END COMMENT
120	<
121	<	// END SETUP
122	<
123	<
124	<	/**************************************************************
125	<	Here would be an ideal place to start another thread to do
126	<	the listening part of the Filter. Ideally it should just be
127	<	created and then run(). It may be necessary to pass some of
128	<	the following parameters into the thread by the constructor.
129	<
130	<	Logger logger
131	<	- a reference to a Logger object
132	<	FilterManager filterManager
133	<	- a reference to the system filter manager
134	<	ConfigurationManager configManager
135	<	- a reference to the system configuration manager
136	<	Configuration myConfig
137	<	- a reference to the configuration object for this
138	<	filter instance
139	<	String ourName
140	<	- our "identifier" name
141	<
142	<	**************************************************************/
143	<
143	<	logger.write(toString, Logger.SYSINIT, "starting Filter UDP listener");
144	<	UDPReader udpReader = new UDPReader(UDPport, parentFilter, logger);
145	<	udpReader.start();
146	<	logger.write(toString, Logger.SYSINIT, "Filter UDP listener started");
147	<
148	<	logger.write(toString, Logger.SYSINIT, "starting Filter TCP listener");
149	<	TCPReader tcpReader = new TCPReader(logger, configManager, TCPport, parentFilter);
150	<	tcpReader.start();
151	<	logger.write(toString, Logger.SYSINIT, "Filter TCP listener started");
152	<
153	<	// TEST
154	<	//parentFilter.receiveXML("<?xml version=\"1.0\" encoding=\"ISO8859-1\"?><packet><test>This is just a debugging test, we ("+ourName+") are live on UDPport: "+UDPport+"</test></packet>");
155	<
156	<	// start the POA off
157	<	poa.the_POAManager().activate();
158	<
159	<	logger.write(toString, Logger.SYSINIT, "started");
160	<
161	<	// now we are running, we just need to serve
162	<	// so we ask the orb to block for us until it has finished
163	<	orb.run();
164	<
165	<	} catch (Exception e) {
166	<	System.err.println("FILTER ERROR: " + e);
167	<	e.printStackTrace(System.out);
113	>	// TCP Reader start (for heartbeats)
114	>	_logger.write(toString(), Logger.SYSINIT, "starting Filter TCP listener");
115	>	TCPReader tcpReader = new TCPReader(TCPListenPort, queue);
116	>	tcpReader.start();
117	>
118	>	_logger.write(toString(), Logger.SYSINIT, "started");
119	>	}
120	>
121	>	/**
122	>	* Does a dependency check. Used mainly at startup to
123	>	* see if the required dependencies (components) are up
124	>	* and running.
125	>	*
126	>	* @return a boolean value, true if the depdencies are satisfied
127	>	*/
128	>	public boolean depCheck() {
129	>	try {
130	>	org.omg.CORBA.Object obj;
131	>	// first check the ConfigurationManager is alive
132	>	obj = _refman.getCORBARef("iscream.ConfigurationManager");
133	>	// then suss out our parent filter
134	>	ConfigurationProxy cp = ConfigurationProxy.getInstance();
135	>	String parentFilterName = cp.getProperty(NAME, "Filter.parentFilter");
136	>	// finally check the parent filter is alive
137	>	obj = _refman.getCORBARef("iscream.Filter." + parentFilterName);
138	>	} catch(ComponentCORBAException e) {
139	>	System.err.println(toString() + ": Dependency Failure: "+e);
140	>	return false;
141	>	} catch(PropertyNotFoundException e) {
142	>	System.err.println(toString() + ": Unable to obtain configuration: "+e);
143	>	return false;
144		}
145	+	// dependency check suceeded
146	+	return true;
147		}
148	<
149	<	/**
150	<	* A simple method to print the usage of this class.
151	<	* It never returns, but instead exits to the system
152	<	* with a value 1, to indicate the system did not start
153	<	* properly.
148	>
149	>	/**
150	>	* Overrides the {@link java.lang.Object#toString() Object.toString()}
151	>	* method to provide clean logging (every class should have this).
152	>	*
153	>	* This uses the uk.org.iscream.util.NameFormat class
154	>	* to format the toString()
155	>	*
156	>	* @return the name of this class and its CVS revision
157		*/
158	<	public static void usage() {
159	<	System.out.println("USAGE: java FilterMain <name>");
160	<	System.out.println("WHERE <name>:");
161	<	System.out.println("      The unique identifier for the Filter in the system.");
162	<	System.exit(1);
158	>	public String toString() {
159	>	return FormatName.getName(
160	>	NAME,
161	>	getClass().getName(),
162	>	REVISION);
163		}
164
184	–	//---CONSTRUCTORS---
185	–
186	–	//---PUBLIC METHODS---
187	–
165		//---PRIVATE METHODS---
166
167		//---ACCESSOR/MUTATOR METHODS---
168
169		//---ATTRIBUTES---
170
171	+	/**
172	+	* This holds a reference to the
173	+	* system logger that is being used.
174	+	*/
175	+	private Logger _logger;
176	+
177	+	/**
178	+	* A reference to the reference manager in use
179	+	*/
180	+	private ReferenceManager _refman = ReferenceManager.getInstance();
181	+
182		//---STATIC ATTRIBUTES---
183
184	<	}
184	>	/**
185	>	* The friendly name for this component, used by
186	>	* all related classes.
187	>	* This is set from the configuration.
188	>	*/
189	>	public static String NAME;
190	>
191	>	}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines