ViewVC Help

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

root/i-scream/projects/cms/source/host/java/Config.java

Comparing projects/cms/source/host/java/Config.java (file contents):
Revision 1.1 by ab11, Mon Nov 27 19:49:00 2000 UTC vs.
Revision 1.5 by tdb, Thu Dec 7 23:18:28 2000 UTC

#	Line 1 | Line 1
1	+	//---PACKAGE DECLARATION---
2	+
3	+	//---IMPORTS---
4	+
5		import java.net.*;
6		import java.util.*;
7		import java.io.*;
8
9	+	/**
10	+	* Configurator object for the JavaHost
11	+	* Will connect to the filter manager and collect its specific
12	+	* configuration
13	+	*
14	+	* @author  $Author$
15	+	* @version $Id$
16	+	*/
17		class Config {
18
19	<	private String lastModified;
8	<	private int numProperties;
9	<	private Hashtable myProperties;
10	<	private String filterName;
11	<	private int filterUDPPort;
12	<	private int filterTCPPort;
13	<	private ArrayList aList;
14	<	private BufferedReader socketIn;
15	<	private PrintWriter socketOut;
16	<
19	>	//---FINAL ATTRIBUTES---
20
21	<	public Config( String serverName, int serverPort ){
19	<	// takes in the master config settings and creates a connection with
20	<	// this computer, and downloads all the values listed in config.values.txt
21	<	// which should be in the local directory
22	<
23	<	// read in from the file.
24	<	try {
25	<	BufferedReader inFile = new BufferedReader(new FileReader("config.values.txt"));
26	<	aList = new ArrayList();
27	<	numProperties = 0;
28	<	String tmpIn = inFile.readLine();
29	<	while ( tmpIn != null ){
30	<	aList.add(tmpIn);
31	<	numProperties++;
32	<	tmpIn = inFile.readLine();
33	<	}
34	<	}
35	<	catch ( FileNotFoundException e ){
36	<	// do something
37	<	}
38	<	catch ( IOException e ){
39	<	// do something
40	<	}
41	<
42	<	// do the funky jibble
43	<	connect(serverName, serverPort);
44	<
45	<
46	<	}
21	>	//---STATIC METHODS---
22
23	<	private void connect( String serverName, int serverPort ){
24	<	Socket mySocket;
25	<
26	<	// might throw a UnknownHostException
27	<	try {
28	<	mySocket = new Socket(serverName, serverPort );
29	<	// ok we have our socket connected ok. grab their input and output streams
30	<	socketIn = new BufferedReader(new InputStreamReader(mySocket.getInputStream()));
31	<	socketOut = new PrintWriter(mySocket.getOutputStream());
32	<
33	<
34	<	if (sendCommand("STARTCONFIG") == "OK"){
35	<	// everything is fine
36	<	sendCommand("LASTMODIFIED");
37	<	sendCommand("FILELIST");
38	<
39	<	// get all the properties
40	<	for ( int i = 0; i < numProperties; i++ ){
41	<	String property = (String) aList.get(i);
42	<	myProperties.put(property, sendCommand(property));
43	<	}
44	<
45	<	sendCommand("ENDCONFIG");
46	<	String filter_data = sendCommand("FILTER");
47	<	StringTokenizer tok = new StringTokenizer(filter_data,";");
48	<	filterName = tok.nextToken();
49	<	filterUDPPort = Integer.parseInt(tok.nextToken());
50	<	filterTCPPort = Integer.parseInt(tok.nextToken());
51	<
52	<	sendCommand("END");
53	<
79	<	}
23	>	//---CONSTRUCTORS---
24	>
25	>	public Config( String serverName, int serverPort ){
26	>	// takes in the master config settings and creates a connection with
27	>	// this computer, and downloads all the values listed in config.values.txt
28	>	// which should be in the local directory
29	>
30	>	// read in from the file.
31	>	try {
32	>	System.out.println("Reading Config file");
33	>	BufferedReader inFile = new BufferedReader(new FileReader("config.values.txt"));
34	>	aList = new ArrayList();
35	>	numProperties = 0;
36	>	String tmpIn = inFile.readLine();
37	>	while ( tmpIn != null ){
38	>	aList.add(numProperties, tmpIn);
39	>	numProperties++;
40	>	tmpIn = inFile.readLine();
41	>	}
42	>	System.out.println("Added "+numProperties+" properties");
43	>	}
44	>	catch ( FileNotFoundException e ){
45	>	// do something
46	>	System.out.println("Config file not found");
47	>	}
48	>	catch ( IOException e ){
49	>	// do something
50	>	}
51	>
52	>	myProperties = new HashMap();
53	>	configChanged = false;
54
55	<	// close the socket
56	<	mySocket.close();
55	>	// time in seconds before first retry
56	>	filterManagerRetryTime = 10;
57	>
58	>	// do the funky jibble
59	>	connect(serverName, serverPort);
60	>	}
61	>
62	>	//---PUBLIC METHODS---
63	>
64	>	public InetAddress getFilterName(){
65	>	// will return the most recient IP address (if it is dynamic for whatever reason
66	>	try {
67	>	return InetAddress.getByName(filterName);
68	>	}
69	>	catch ( UnknownHostException e ){
70	>	// do something
71	>	return null;
72	>	}
73	>
74	>	}
75	>
76	>	/**
77	>	* Used to retrieve the port to send UDP packets to on the filter
78	>	*
79	>	* @return an integer corrisponding to the UDP port of the filter
80	>	*/
81	>	public int getFilterUDPPort(){
82	>
83	>	return filterUDPPort;
84	>	}
85	>
86	>	/**
87	>	* Used to retrieve the port to send TCP heartbeats to on the filter
88	>	*
89	>	* @return an integer corrisponding to the TCP of the filter
90	>	*/
91	>	public int getFilterTCPPort(){
92	>
93	>	return filterTCPPort;
94	>	}
95	>
96	>	/**
97	>	* Used to get the hostname of the filter we are to talk to.
98	>	*
99	>	* @return a string representing the hostname of the filter
100	>	*/
101	>	public String getProperty( String name ){
102	>
103	>	if ( myProperties.containsKey(name) ){
104	>	// its in there, may return ERROR
105	>	return (String) myProperties.get(name);
106	>	}
107	>	else
108	>	{
109	>	// can't have been in the config.values.txt file!
110	>	return "ERROR";
111	>	}
112	>	}
113	>
114	>
115	>	//---PRIVATE METHODS---
116	>
117	>	private void connect( String serverName, int serverPort ){
118	>	Socket mySocket;
119	>	configChanged = false;
120	>
121	>	System.out.println("Establishing connection with filter manager");
122	>
123	>	// might throw a UnknownHostException
124	>	try {
125	>	mySocket = new Socket( serverName, serverPort );
126	>	// ok we have our socket connected ok. grab their input and output streams
127	>	socketIn = new BufferedReader(new InputStreamReader(mySocket.getInputStream()));
128	>	socketOut = new PrintWriter(mySocket.getOutputStream());
129	>
130	>	if (sendCommand("STARTCONFIG").equals("OK")){
131	>	// everything is fine
132	>	// sendCommand("LASTMODIFIED");
133	>	lastModified = sendCommand("LASTMODIFIED");
134	>
135	>	fileList = sendCommand("FILELIST");
136	>	// get all the properties
137	>	if ( numProperties > 0 ){
138	>	// sendCommand("CONFIG");
139	>	for ( int i = 0; i < numProperties; i++ ){
140	>	String property = (String) aList.get(i);
141	>	myProperties.put(property, sendCommand(property));
142	>	}
143	>	}
144	>
145	>	sendCommand("ENDCONFIG");
146	>	String filter_data = sendCommand("FILTER");
147	>	StringTokenizer tok = new StringTokenizer(filter_data,";");
148	>	filterName = tok.nextToken();
149	>	filterUDPPort = Integer.parseInt(tok.nextToken());
150	>	filterTCPPort = Integer.parseInt(tok.nextToken());
151	>
152	>	sendCommand("END");
153	>
154	>	}
155	>
156	>
157	>	// close the socket
158	>	mySocket.close();
159	>	System.out.println("Completed communication with filter manager");
160	>
161	>	}
162	>	catch ( UnknownHostException e ){
163	>	// what to do
164	>	System.out.println("Host not found");
165	>	}
166	>	catch ( IOException e ){
167	>	// what to do
168	>	System.out.println("Unable to read from socket, might not be open");
169	>	System.out.println("Retrying in "+filterManagerRetryTime+" seconds");
170	>	configChanged = true;
171	>	try {
172	>	Thread.sleep(filterManagerRetryTime*1000);
173	>	}
174	>	catch( InterruptedException f ){
175	>	System.out.println("Sleep interrupted");
176	>	}
177	>	filterManagerRetryTime = filterManagerRetryTime * 2;
178	>	// warning this WILL cause a stack overflow after a while..
179	>	// need to fix it.
180	>	connect(serverName, serverPort);
181	>	}
182	>
183	>	} // connect
184	>
185	>
186	>	public void sendHeartBeat(){
187
188	+	Socket mySocket;
189	+	try {
190	+
191	+	mySocket = new Socket( filterName, filterTCPPort );
192	+	// ok we have our socket connected ok. grab their input and output streams
193	+	socketIn = new BufferedReader(new InputStreamReader(mySocket.getInputStream()));
194	+	socketOut = new PrintWriter(mySocket.getOutputStream());
195	+
196	+
197	+	if ( sendCommand("HEARTBEAT").equals("OK") ){
198	+	if ( sendCommand("CONFIG").equals("OK") ){
199	+	sendCommand(fileList);
200	+	if ( sendCommand(lastModified).equals("ERROR") ){
201	+	// config has changed
202	+	configChanged = true;
203	+	}
204	+	sendCommand("ENDHEARTBEAT");
205	+	}
206	+	}
207		}
208	<	catch ( UnknownHostException e ){
209	<	// what to do
210	<	}
211	<	catch ( IOException e ){
212	<	// what to do
213	<	}
214	<
215	<	} // connect
208	>	catch ( UnknownHostException e ){
209	>	// what to do
210	>	System.out.println("Host not found");
211	>	}
212	>	catch ( IOException e ){
213	>	// what to do
214	>	System.out.println("Unable to read from socket, might not be open");
215	>	System.out.println("Re-establishing contact with filter manager");
216	>	configChanged = true;
217	>	}
218	>	}
219
220	<	public InetAddress getFilterName(){
221	<	// will return the most recient IP address (if it is dynamic for whatever reason
222	<	try {
223	<	return InetAddress.getByName(filterName);
224	<	}
225	<	catch ( UnknownHostException e ){
226	<	// do something
227	<	return null;
228	<	}
229	<
230	<	}
231	<
232	<	public int getFilterUDPPort(){
233	<
234	<	return filterUDPPort;
235	<	}
110	<
111	<	public int getFilterTCPPort(){
112	<
113	<	return filterTCPPort;
114	<	}
220	>	private String sendCommand(String command){
221	>
222	>	// System.out.println("Writing command: "+command);
223	>	socketOut.println(command);
224	>	socketOut.flush();
225	>	try {
226	>	String response = socketIn.readLine();
227	>	// System.out.println("Got: "+response);
228	>	return response;
229	>	}
230	>	catch ( IOException e ){
231	>	// something went wrong
232	>	System.out.println("Error recieving response");
233	>	return "ERROR";
234	>	}
235	>	}
236
237	<	public String getProperty( String name ){
238	<
239	<	if ( myProperties.containsKey(name) ){
240	<	// its in there, may return ERROR
241	<	return (String) myProperties.get(name);
242	<	}
243	<	else
244	<	{
245	<	// can't have been in the config.values.txt file!
246	<	return "ERROR";
247	<	}
248	<	}
249	<
250	<	private String sendCommand(String command){
251	<
252	<	socketOut.println(command);
253	<	try {
254	<	return socketIn.readLine();
255	<	}
256	<	catch ( IOException e ){
257	<	// something went wrong
258	<	return "ERROR";
259	<	}
260	<	}
237	>	//---ACCESSOR/MUTATOR METHODS---
238	>
239	>	public boolean reloadConfig(){
240	>	return configChanged;
241	>	}
242	>
243	>	//---ATTRIBUTES---
244	>
245	>	private boolean configChanged;
246	>	private String lastModified;
247	>	private String fileList;
248	>	private int numProperties;
249	>	private HashMap myProperties;
250	>	private String filterName;
251	>	private int filterUDPPort;
252	>	private int filterTCPPort;
253	>	private ArrayList aList;
254	>	private BufferedReader socketIn;
255	>	private PrintWriter socketOut;
256	>	private int filterManagerRetryTime;
257	>
258	>
259	>
260	>	//---STATIC ATTRIBUTES---
261
262		} // class

Diff Legend

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