ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/i-scream/projects/cms/source/host/java/Config.java
(Generate patch)

Comparing projects/cms/source/host/java/Config.java (file contents):
Revision 1.2 by ab11, Mon Nov 27 20:36:13 2000 UTC vs.
Revision 1.7 by tdb, Wed Jan 24 01:25:59 2001 UTC

# Line 8 | Line 8 | import java.io.*;
8  
9   /**
10   * Configurator object for the JavaHost
11 < * Will connect to the configurator manager and collect its specific
11 > * Will connect to the filter manager and collect its specific
12   * configuration
13   *
14   * @author  $Author$
# Line 29 | Line 29 | class Config {
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(tmpIn);
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      }
# Line 53 | Line 62 | class Config {
62   //---PUBLIC METHODS---
63  
64      public InetAddress getFilterName(){
65 <        // will return the most recient IP address (if it is dynamic for whatever reason
65 >        // will return the most recent IP address (if it is dynamic for whatever reason)
66          try {
67              return InetAddress.getByName(filterName);
68          }
# Line 67 | Line 76 | class Config {
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
79 >     * @return an integer corresponding to the UDP port of the filter
80       */
81      public int getFilterUDPPort(){
82          
# Line 77 | Line 86 | class Config {
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
89 >     * @return an integer corresponding to the TCP of the filter
90       */    
91      public int getFilterTCPPort(){
92          
# Line 107 | Line 116 | class Config {
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
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 <        
119 <            if (sendCommand("STARTCONFIG") == "OK"){
129 >
130 >            if (sendCommand("STARTCONFIG").equals("OK")){
131                  // everything is fine
132 <                sendCommand("LASTMODIFIED");
133 <                sendCommand("FILELIST");
132 >                // sendCommand("LASTMODIFIED");
133 >                lastModified = sendCommand("LASTMODIFIED");
134                  
135 +                fileList = sendCommand("FILELIST");
136                  // get all the properties
137 <                for ( int i = 0; i < numProperties; i++ ){
138 <                    String property = (String) aList.get(i);
139 <                    myProperties.put(property, sendCommand(property));  
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");
# Line 133 | Line 148 | class Config {
148                  filterName = tok.nextToken();
149                  filterUDPPort = Integer.parseInt(tok.nextToken());
150                  filterTCPPort = Integer.parseInt(tok.nextToken());
151 <                    
151 >                                    
152                  sendCommand("END");        
153 <                
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      
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 +            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      private String sendCommand(String command){
221          
222 +        // System.out.println("Writing command: "+command);
223          socketOut.println(command);
224 +        socketOut.flush();
225          try {
226 <            return socketIn.readLine();
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   //---ACCESSOR/MUTATOR METHODS---
238  
239 +    public boolean reloadConfig(){
240 +        return configChanged;
241 +    }
242 +
243   //---ATTRIBUTES---
244  
245 <
245 >    private boolean configChanged;
246      private String lastModified;
247 +    private String fileList;
248      private int numProperties;
249 <    private Hashtable myProperties;
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
262 > } // class

Diff Legend

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