host/java/Config.java

/* 
 * i-scream central monitoring system
 * http://www.i-scream.org.uk
 * Copyright (C) 2000-2002 i-scream
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */

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