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 configurator manager and collect its specific
 * configuration
 *
 * @author  $Author: ab11 $
 * @version $Id: Config.java,v 1.1 2000/11/27 20:10 ab11 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 {
            BufferedReader inFile = new BufferedReader(new FileReader("config.values.txt"));
            aList = new ArrayList();
            numProperties = 0;
            String tmpIn = inFile.readLine();
            while ( tmpIn != null ){
                aList.add(tmpIn);
                numProperties++;
                tmpIn = inFile.readLine();  
            }
        }
        catch ( FileNotFoundException e ){
            // do something
        }
        catch ( IOException e ){
            // do something
        }
    
        // do the funky jibble
        connect(serverName, serverPort);
    }

//---PUBLIC METHODS---

    public InetAddress getFilterName(){
        // will return the most recient 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 corrisponding 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 corrisponding 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;
        
        // 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") == "OK"){
                // everything is fine
                sendCommand("LASTMODIFIED");
                sendCommand("FILELIST");
                
                // get all the properties
                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();
        
        }
        catch ( UnknownHostException e ){
            // what to do       
        }
        catch ( IOException e ){
            // what to do 
        }
            
    } // connect


    private String sendCommand(String command){
        
        socketOut.println(command);
        try {
            return socketIn.readLine();
        }
        catch ( IOException e ){
            // something went wrong
            return "ERROR";   
        }
    }

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

//---ATTRIBUTES---


    private String lastModified;
    private int numProperties;
    private Hashtable myProperties;
    private String filterName;
    private int filterUDPPort;
    private int filterTCPPort;
    private ArrayList aList;
    private BufferedReader socketIn;
    private PrintWriter socketOut;
    

//---STATIC ATTRIBUTES---

} // class
Revision:	1.2
Committed:	Mon Nov 27 20:36:13 2000 UTC (24 years ago) by ab11
Branch:	MAIN
Changes since 1.1:	+178 -133 lines
Log Message:	changed the layout so it conforms to the Templateclass.java
#	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 configurator manager and collect its specific
12	* configuration
13	*
14	* @author $Author: ab11 $
15	* @version $Id: Config.java,v 1.1 2000/11/27 20:10 ab11 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	BufferedReader inFile = new BufferedReader(new FileReader("config.values.txt"));
33	aList = new ArrayList();
34	numProperties = 0;
35	String tmpIn = inFile.readLine();
36	while ( tmpIn != null ){
37	aList.add(tmpIn);
38	numProperties++;
39	tmpIn = inFile.readLine();
40	}
41	}
42	catch ( FileNotFoundException e ){
43	// do something
44	}
45	catch ( IOException e ){
46	// do something
47	}
48
49	// do the funky jibble
50	connect(serverName, serverPort);
51	}
52
53	//---PUBLIC METHODS---
54
55	public InetAddress getFilterName(){
56	// will return the most recient IP address (if it is dynamic for whatever reason
57	try {
58	return InetAddress.getByName(filterName);
59	}
60	catch ( UnknownHostException e ){
61	// do something
62	return null;
63	}
64
65	}
66
67	/**
68	* Used to retrieve the port to send UDP packets to on the filter
69	*
70	* @return an integer corrisponding to the UDP port of the filter
71	*/
72	public int getFilterUDPPort(){
73
74	return filterUDPPort;
75	}
76
77	/**
78	* Used to retrieve the port to send TCP heartbeats to on the filter
79	*
80	* @return an integer corrisponding to the TCP of the filter
81	*/
82	public int getFilterTCPPort(){
83
84	return filterTCPPort;
85	}
86
87	/**
88	* Used to get the hostname of the filter we are to talk to.
89	*
90	* @return a string representing the hostname of the filter
91	*/
92	public String getProperty( String name ){
93
94	if ( myProperties.containsKey(name) ){
95	// its in there, may return ERROR
96	return (String) myProperties.get(name);
97	}
98	else
99	{
100	// can't have been in the config.values.txt file!
101	return "ERROR";
102	}
103	}
104
105
106	//---PRIVATE METHODS---
107
108	private void connect( String serverName, int serverPort ){
109	Socket mySocket;
110
111	// might throw a UnknownHostException
112	try {
113	mySocket = new Socket(serverName, serverPort );
114	// ok we have our socket connected ok. grab their input and output streams
115	socketIn = new BufferedReader(new InputStreamReader(mySocket.getInputStream()));
116	socketOut = new PrintWriter(mySocket.getOutputStream());
117
118
119	if (sendCommand("STARTCONFIG") == "OK"){
120	// everything is fine
121	sendCommand("LASTMODIFIED");
122	sendCommand("FILELIST");
123
124	// get all the properties
125	for ( int i = 0; i < numProperties; i++ ){
126	String property = (String) aList.get(i);
127	myProperties.put(property, sendCommand(property));
128	}
129
130	sendCommand("ENDCONFIG");
131	String filter_data = sendCommand("FILTER");
132	StringTokenizer tok = new StringTokenizer(filter_data,";");
133	filterName = tok.nextToken();
134	filterUDPPort = Integer.parseInt(tok.nextToken());
135	filterTCPPort = Integer.parseInt(tok.nextToken());
136
137	sendCommand("END");
138
139	}
140
141	// close the socket
142	mySocket.close();
143
144	}
145	catch ( UnknownHostException e ){
146	// what to do
147	}
148	catch ( IOException e ){
149	// what to do
150	}
151
152	} // connect
153
154
155	private String sendCommand(String command){
156
157	socketOut.println(command);
158	try {
159	return socketIn.readLine();
160	}
161	catch ( IOException e ){
162	// something went wrong
163	return "ERROR";
164	}
165	}
166
167	//---ACCESSOR/MUTATOR METHODS---
168
169	//---ATTRIBUTES---
170
171
172	private String lastModified;
173	private int numProperties;
174	private Hashtable myProperties;
175	private String filterName;
176	private int filterUDPPort;
177	private int filterTCPPort;
178	private ArrayList aList;
179	private BufferedReader socketIn;
180	private PrintWriter socketOut;
181
182
183
184	//---STATIC ATTRIBUTES---
185
186	} // class