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.8 by ab11, Mon Mar 19 17:38:41 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                  
137 +                fQDN = sendCommand("FQDN");                
138                  // get all the properties
139 <                for ( int i = 0; i < numProperties; i++ ){
140 <                    String property = (String) aList.get(i);
141 <                    myProperties.put(property, sendCommand(property));  
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");
# Line 133 | Line 150 | class Config {
150                  filterName = tok.nextToken();
151                  filterUDPPort = Integer.parseInt(tok.nextToken());
152                  filterTCPPort = Integer.parseInt(tok.nextToken());
153 <                    
153 >                                    
154                  sendCommand("END");        
155 <                
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      
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 <            return socketIn.readLine();
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 <
247 >    private boolean configChanged;
248      private String lastModified;
249 +    private String fileList;
250 +    private String fQDN;
251      private int numProperties;
252 <    private Hashtable myProperties;
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
265 > } // class

Diff Legend

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