host/java/Config.java

//---PACKAGE DECLARATION---

//---IMPORTS---

import java.net.*;
import java.util.*;
import java.io.*;

/**
 * Configurator object for the JavaHost
 * Will connect to the filter manager and collect its specific
 * configuration
 *
 * @author  $Author: tdb1 $
 * @version $Id: Config.java,v 1.7 2001/01/24 01:25:59 tdb1 Exp $
 */
class Config {

//---FINAL ATTRIBUTES---

//---STATIC METHODS---

//---CONSTRUCTORS---

    public Config( String serverName, int serverPort ){
        // takes in the master config settings and creates a connection with
        // this computer, and downloads all the values listed in config.values.txt
        // which should be in the local directory
        
        // read in from the file.
        try {
            System.out.println("Reading Config file");
            BufferedReader inFile = new BufferedReader(new FileReader("config.values.txt"));
            aList = new ArrayList();
            numProperties = 0;
            String tmpIn = inFile.readLine();
            while ( tmpIn != null ){
                aList.add(numProperties, tmpIn);
                numProperties++;
                tmpIn = inFile.readLine();  
            }
            System.out.println("Added "+numProperties+" properties");
        }
        catch ( FileNotFoundException e ){
            // do something
            System.out.println("Config file not found");
        }
        catch ( IOException e ){
            // do something
        }
    
        myProperties = new HashMap();
        configChanged = false;
        
        // time in seconds before first retry
        filterManagerRetryTime = 10;
    
        // do the funky jibble
        connect(serverName, serverPort);
    }

//---PUBLIC METHODS---

    public InetAddress getFilterName(){
        // will return the most recent IP address (if it is dynamic for whatever reason)
        try {
            return InetAddress.getByName(filterName);
        }
        catch ( UnknownHostException e ){
            // do something
            return null;
        }
        
    }
    
    /**
     * Used to retrieve the port to send UDP packets to on the filter
     *
     * @return an integer corresponding to the UDP port of the filter
     */
    public int getFilterUDPPort(){
        
        return filterUDPPort;
    }
    
    /**
     * Used to retrieve the port to send TCP heartbeats to on the filter
     *
     * @return an integer corresponding to the TCP of the filter
     */    
    public int getFilterTCPPort(){
        
        return filterTCPPort;
    }

    /**
     * Used to get the hostname of the filter we are to talk to.
     *
     * @return a string representing the hostname of the filter
     */
    public String getProperty( String name ){
        
        if ( myProperties.containsKey(name) ){
            // its in there, may return ERROR
            return (String) myProperties.get(name);
        }
        else
        {
            // can't have been in the config.values.txt file!
            return "ERROR";
        }
    }


//---PRIVATE METHODS---

    private void connect( String serverName, int serverPort ){
        Socket mySocket;
        configChanged = false;
        
        System.out.println("Establishing connection with filter manager");
        
        // might throw a UnknownHostException
        try {
            mySocket = new Socket( serverName, serverPort );
             // ok we have our socket connected ok. grab their input and output streams
            socketIn = new BufferedReader(new InputStreamReader(mySocket.getInputStream()));
            socketOut = new PrintWriter(mySocket.getOutputStream());
 
            if (sendCommand("STARTCONFIG").equals("OK")){
                // everything is fine
                // sendCommand("LASTMODIFIED");
                lastModified = sendCommand("LASTMODIFIED");
                     
                fileList = sendCommand("FILELIST");
                
                fQDN = sendCommand("FQDN");                
                // get all the properties
                if ( numProperties > 0 ){
                        // sendCommand("CONFIG");
                        for ( int i = 0; i < numProperties; i++ ){
                            String property = (String) aList.get(i);
                            myProperties.put(property, sendCommand(property));  
                        }
                }
                
                sendCommand("ENDCONFIG");
                String filter_data = sendCommand("FILTER");
                StringTokenizer tok = new StringTokenizer(filter_data,";");
                filterName = tok.nextToken();
                filterUDPPort = Integer.parseInt(tok.nextToken());
                filterTCPPort = Integer.parseInt(tok.nextToken());
                                    
                sendCommand("END");         
                 
            }
           
        
            // close the socket
            mySocket.close();
            System.out.println("Completed communication with filter manager");
        
        }
        catch ( UnknownHostException e ){
            // what to do   
            System.out.println("Host not found");    
        }
        catch ( IOException e ){
            // what to do 
            System.out.println("Unable to read from socket, might not be open");
            System.out.println("Retrying in "+filterManagerRetryTime+" seconds");
            configChanged = true;
            try {
                Thread.sleep(filterManagerRetryTime*1000);
            }
            catch( InterruptedException f ){
                System.out.println("Sleep interrupted");
            }
            filterManagerRetryTime = filterManagerRetryTime * 2;
            // warning this WILL cause a stack overflow after a while..
            // need to fix it.
            connect(serverName, serverPort);
        }
            
    } // connect


    public void sendHeartBeat(){
        
        Socket mySocket;
        try {
                 
                mySocket = new Socket( filterName, filterTCPPort );
                // ok we have our socket connected ok. grab their input and output streams
                socketIn = new BufferedReader(new InputStreamReader(mySocket.getInputStream()));
                socketOut = new PrintWriter(mySocket.getOutputStream());
         
                        
                if ( sendCommand("HEARTBEAT").equals("OK") ){
                        if ( sendCommand("CONFIG").equals("OK") ){
                                sendCommand(fileList);
                                if ( sendCommand(lastModified).equals("ERROR") ){
                                        // config has changed
                                        configChanged = true;
                                }
                                sendCommand("ENDHEARTBEAT");
                        }
                }       
        }
        catch ( UnknownHostException e ){
            // what to do   
            System.out.println("Host not found");    
        }
        catch ( IOException e ){
            // what to do 
            System.out.println("Unable to read from socket, might not be open");
            System.out.println("Re-establishing contact with filter manager");
            configChanged = true;
        }
    }

    private String sendCommand(String command){
        
        // System.out.println("Writing command: "+command);
        socketOut.println(command);
        socketOut.flush();
        try {
           String response = socketIn.readLine();
           // System.out.println("Got: "+response);
           return response;
        }
        catch ( IOException e ){
            // something went wrong
            System.out.println("Error recieving response");
            return "ERROR";   
        }
    }

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

    public boolean reloadConfig(){
        return configChanged;
    } 

//---ATTRIBUTES---

    private boolean configChanged;
    private String lastModified;
    private String fileList;
    private String fQDN;
    private int numProperties;
    private HashMap myProperties;
    private String filterName;
    private int filterUDPPort;
    private int filterTCPPort;
    private ArrayList aList;
    private BufferedReader socketIn;
    private PrintWriter socketOut;
    private int filterManagerRetryTime;
    

//---STATIC ATTRIBUTES---

} // class
Revision:	1.8
Committed:	Mon Mar 19 17:38:41 2001 UTC (23 years, 6 months ago) by ab11
Branch:	MAIN
CVS Tags:	PROJECT_COMPLETION
Changes since 1.7:	+5 -2 lines
Log Message:	Added the FQDN part to the initial configuation process to make it conform to the protocol.
#	Content
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: tdb1 $
15	* @version $Id: Config.java,v 1.7 2001/01/24 01:25:59 tdb1 Exp $
16	*/
17	class Config {
18
19	//---FINAL ATTRIBUTES---
20
21	//---STATIC METHODS---
22
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	// 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 recent 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 corresponding 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 corresponding 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
137	fQDN = sendCommand("FQDN");
138	// get all the properties
139	if ( numProperties > 0 ){
140	// sendCommand("CONFIG");
141	for ( int i = 0; i < numProperties; i++ ){
142	String property = (String) aList.get(i);
143	myProperties.put(property, sendCommand(property));
144	}
145	}
146
147	sendCommand("ENDCONFIG");
148	String filter_data = sendCommand("FILTER");
149	StringTokenizer tok = new StringTokenizer(filter_data,";");
150	filterName = tok.nextToken();
151	filterUDPPort = Integer.parseInt(tok.nextToken());
152	filterTCPPort = Integer.parseInt(tok.nextToken());
153
154	sendCommand("END");
155
156	}
157
158
159	// close the socket
160	mySocket.close();
161	System.out.println("Completed communication with filter manager");
162
163	}
164	catch ( UnknownHostException e ){
165	// what to do
166	System.out.println("Host not found");
167	}
168	catch ( IOException e ){
169	// what to do
170	System.out.println("Unable to read from socket, might not be open");
171	System.out.println("Retrying in "+filterManagerRetryTime+" seconds");
172	configChanged = true;
173	try {
174	Thread.sleep(filterManagerRetryTime*1000);
175	}
176	catch( InterruptedException f ){
177	System.out.println("Sleep interrupted");
178	}
179	filterManagerRetryTime = filterManagerRetryTime * 2;
180	// warning this WILL cause a stack overflow after a while..
181	// need to fix it.
182	connect(serverName, serverPort);
183	}
184
185	} // connect
186
187
188	public void sendHeartBeat(){
189
190	Socket mySocket;
191	try {
192
193	mySocket = new Socket( filterName, filterTCPPort );
194	// ok we have our socket connected ok. grab their input and output streams
195	socketIn = new BufferedReader(new InputStreamReader(mySocket.getInputStream()));
196	socketOut = new PrintWriter(mySocket.getOutputStream());
197
198
199	if ( sendCommand("HEARTBEAT").equals("OK") ){
200	if ( sendCommand("CONFIG").equals("OK") ){
201	sendCommand(fileList);
202	if ( sendCommand(lastModified).equals("ERROR") ){
203	// config has changed
204	configChanged = true;
205	}
206	sendCommand("ENDHEARTBEAT");
207	}
208	}
209	}
210	catch ( UnknownHostException e ){
211	// what to do
212	System.out.println("Host not found");
213	}
214	catch ( IOException e ){
215	// what to do
216	System.out.println("Unable to read from socket, might not be open");
217	System.out.println("Re-establishing contact with filter manager");
218	configChanged = true;
219	}
220	}
221
222	private String sendCommand(String command){
223
224	// System.out.println("Writing command: "+command);
225	socketOut.println(command);
226	socketOut.flush();
227	try {
228	String response = socketIn.readLine();
229	// System.out.println("Got: "+response);
230	return response;
231	}
232	catch ( IOException e ){
233	// something went wrong
234	System.out.println("Error recieving response");
235	return "ERROR";
236	}
237	}
238
239	//---ACCESSOR/MUTATOR METHODS---
240
241	public boolean reloadConfig(){
242	return configChanged;
243	}
244
245	//---ATTRIBUTES---
246
247	private boolean configChanged;
248	private String lastModified;
249	private String fileList;
250	private String fQDN;
251	private int numProperties;
252	private HashMap myProperties;
253	private String filterName;
254	private int filterUDPPort;
255	private int filterTCPPort;
256	private ArrayList aList;
257	private BufferedReader socketIn;
258	private PrintWriter socketOut;
259	private int filterManagerRetryTime;
260
261
262
263	//---STATIC ATTRIBUTES---
264
265	} // class