cms/conient/ConnectionHandler.java

//---PACKAGE DECLARATION---
package uk.ac.ukc.iscream.conient;

//---IMPORTS---
import uk.ac.ukc.iscream.util.*;
import java.io.*;
import java.net.*;
import javax.swing.JOptionPane;

/**
 * This is the main thread for the client.
 * Once started i continually checks it actionQueue
 * for actions that other areas of the system have placed 
 * there, it then performs those actions.
 *
 * Currently this is the main thread where all non-GUI events
 * are dispatched to.
 *
 * @author  $Author: ajm4 $
 * @version $Id: ConnectionHandler.java,v 1.15 2001/02/04 00:05:24 ajm4 Exp $
 */
public class ConnectionHandler extends Thread {

//---FINAL ATTRIBUTES---

    /**
     * The current CVS revision of this class
     */
    public final String REVISION = "$Revision: 1.15 $";


    /**
     * The hardcoded protocol version that we are using.
     * Used when handshaking with the server
     */
    public final double PROTOCOL_VERSION = 1.0;

    /**
     * Thread action DONOTHING.
     * This is an invalid action, but here for completeness
     * if anything sends this action it will warn appropriately
     * but do what it says, ie, nothing ;)
     */
    public static final int DONOTHING = 0;
    
    /**
     * Thread action CONNECT.
     * Opens the control link to the i-scream server.
     */
    public static final int CONNECT = 1;
    
    /**
     * Thread action STARTDATA.
     * Opens the data link to the i-scream server
     * and prepares all gui data components for data
     * it then starts all relavant threads going.
     */
    public static final int STARTDATA = 2;
    
    /**
     * Thread action STOPDATA.
     * Closes the data link and shuts down all components
     * that update gui for various things.
     */
    public static final int STOPDATA = 3;
    
    /**
     * Thread action DISCONNECT.
     * Checks to see if STOPDATA has been called if not,
     * it will add STOPDATA and then DISCONNECT to
     * the action queue and return.  If STOPDATA has been
     * called it closes down the Control Link and tidies up
     * all relevant threads
     */
    public static final int DISCONNECT = 4;
    
    /**
     * Thread action QUIT.
     * Checks the status of the two links, if either
     * are still up, it queues the appropriate commands
     * to close them down.  It then System.exit(0)'s!
     */
    public static final int QUIT = 5;

    /**
     * Thread action GETCONFIGURATION
     * Starts the command to obtain the configuration
     * from the server. 
     * It then passes the IO to the Configuration object
     * so it can obtain any specific configuration
     */
    public static final int GETCONFIGURATION = 6;

    /**
     * This is the time in seconds that this class
     * should wait on the DataReader class to fully
     * shutdown after calling shutdown() before
     * forcing a shutdown
     */
    public static final int DATAREADER_SHUTDOWN_TIMEOUT = 5;

    /**
     * The default local server to connect to when a 
     * firewall is in use if one is not specified in the server
     */
    public static final String DEFAULT_FIREWALL_SERVER = "localhost";

    /**
     * The default time in seconds to wait for the
     * firewall setup command to execute
     */
    public static final int DEFAULT_FIREWALL_COMMANDWAIT = 5;

//---STATIC METHODS---

//---CONSTRUCTORS---

    /**
     * Constructs new data handler.
     * Needs a reference to the data panel so that
     * it can set it processing inBound data
     * Also gets a reference to the queue that will be
     * used by other areas of the system to send it actions
     *
     * @param data the DataPanel in use
     * @param actionQueue the actionQueue for this class
     */ 
    public ConnectionHandler(DataPanel data, Queue actionQueue) {
        _data = data;
        _actionQueue = actionQueue;
        _myQueue = _actionQueue.getQueue();
    }
    
//---PUBLIC METHODS---


    /**
     * Starts this ConnectionHandler running.
     * This basically runs until told to stop, it gets "actions"
     * from its actionQueue and switch's on them do determine
     * what it should do it then carries out the action
     *
     * For details on what each action does see the action
     * types.
     */
    public void run() {
        if(_configuration.getProperty("control.onstartconnect") != null) {
            _actionQueue.add(new Integer(CONNECT));
        }
        if(_configuration.getProperty("data.onstartconnect") != null) {
            _actionQueue.add(new Integer(STARTDATA));
        }
        while(_running) {
            // we wait for a call...
            int action = 0;
            try {
                action = ((Integer) _actionQueue.get(_myQueue)).intValue();
            } catch (InvalidQueueException e) {
                // we 're never going to get this
                // but if we do we should do something nasty
                throw new RuntimeException("unable to retrieve events from actionQueue!");
            }
            
            // examine our action...
            // if it was to connect...then we connect...
            switch(action) {
                case CONNECT:
                    if (_controlLink == null) {
                        try {
                            // get the server name from the config
                            _configuredServer = _configuration.getProperty("control.server");
                                                                                    
                            if (_configuredServer == null) {
                                throw new IOException("no i-scream server in current configuration");
                            }
                                                        
                            // open the socket to the server and bind the IO
                            // get the port from the config
                            String portString = _configuration.getProperty("control.port");
                            if (portString == null) {
                                throw new IOException("no i-scream server port in current configuration");
                            }
                            int port = 0;
                            try {
                                port = Integer.parseInt(portString);
                            } catch (NumberFormatException e) {
                                throw new IOException("no valid i-scream server port in current configuration");
                            }
                            
                            // start firewall if needed
                            _server = handleFirewall(_configuredServer, port, _controlFirewallProcess);
                            
                            Conient.setControlStatus("Connecting to - " + _server);                           
                            _controlLink = new Socket(_server, port);
                            _inBound = new BufferedReader(new InputStreamReader(_controlLink.getInputStream()));
                            _outBound = new PrintWriter(_controlLink.getOutputStream());
                            Conient.setControlStatus("Connection Established - " + _server);

                            String response;
                            response = _inBound.readLine();
                            
                            // check the servers Protocol Identity against our own
                            // we SHOULD be backwards compatible, so we can continue if
                            // they are using a newer protocol, anything else then we die
                            if (!(Double.parseDouble(response.substring(10, response.length())) > PROTOCOL_VERSION)) {
                                Conient.addMessage("WARNING{control link}: server is using a newer protocol (" + response + "), please update your client, continuing with old protocol (PROTOCOL " + PROTOCOL_VERSION + ")" );
                            } else if (!(Double.parseDouble(response.substring(10, response.length())) < PROTOCOL_VERSION)) {
                                // tidy up
                                throw new IOException("incompatible protocol version");
                            }
                            
                            // send the name of the client
                            _outBound.println(_configuration.getProperty("clientname"));
                            _outBound.flush();
                            response = _inBound.readLine();
                            if (!response.equals("OK")) {
                                // tidy up
                                
                                throw new IOException("client name rejected - " + _configuration.getProperty("clientname"));
                            }
                            // get the config...we are connected now!
                            _actionQueue.add(new Integer(GETCONFIGURATION));
                        } catch (IOException e) {
                            // print the error and tidy up what's left
                            Conient.addMessage("ERROR{control link}: " + e);
                            _controlLink = null;
                            // and the firewall handler if there is one
                            closeFirewall(_controlFirewallProcess);
                            _actionQueue.clearQueue(_myQueue);
                            Conient.setControlStatus("Disconnected");
                        }
                    } else {
                        Conient.addMessage("WARNING{control link}: already established");
                    }
                    break;
                case STARTDATA:
                    // as long as the data link hasn't been established
                    // we want to establish it
                    if (_dataLink == null) {
                        // check that the control link is open, if it isn't we
                        // might want to sort that problemo out
                        // we do this by simply queueing the event to occour, then
                        // this event to run again ;-)
                        if(_controlLink == null) {
                            Conient.addMessage("WARNING{data link}: control link not established - queueing start events");
                            _actionQueue.add(new Integer(CONNECT));
                            _actionQueue.add(new Integer(STARTDATA));
                        } else {
                            try {
                                                           
                                // ask the server to start the data link
                                String response;
                                _outBound.println("STARTDATA");
                                _outBound.flush();
                                response = _inBound.readLine();
                                
                                // see if the server suggested a good port
                                if (response.equals("ERROR")) {
                                    throw new IOException("server unable to start data link at this time");
                                }
                                int port = 0;
                                try {
                                    port = Integer.parseInt(response);
                                } catch (NumberFormatException e) {
                                    throw new IOException("invalid data port suggested by server - " + response);
                                }
                                
                                // start firewall if needed
                                _server = handleFirewall(_configuredServer, port, _dataFirewallProcess);
                                Conient.setDataStatus("Connecting to - " + _server + ":" + response);                                
                                
                                _dataLink = new Socket(_server, port);
                                                                
                                response = _inBound.readLine();
                                if (!response.equals("OK")) {
                                    throw new IOException("server reported error establishing data channel");
                                }
                                
                                // if the socket was ok, then we attack our IO hooks
                                _dataInBound = new BufferedReader(new InputStreamReader(_dataLink.getInputStream()));
                                _dataOutBound = new PrintWriter(_dataLink.getOutputStream());
                                Conient.setDataStatus("Connection Established - " + _server);
                                // now we want to start reading the data in
                                // so we start the appropriate components on their way
                                // we create a queue to give to both the reader and the
                                // displayer
                                Queue theQueue = new Queue();
                                _dataReader = new DataReader(_dataInBound, theQueue);
                                _data.setQueue(theQueue);
                                _data.cleanUpTabs();
                                
                                // start the data rocking
                                new Thread(_data).start();
                                _dataReader.start();
                                // finished for us....
                            } catch (IOException e) {
                                // print the error and tidy up what's left
                                Conient.addMessage("ERROR{data link}: " + e);
                                _dataLink = null;
                                // and the firewall handler if there is one
                                closeFirewall(_dataFirewallProcess);
                                _actionQueue.clearQueue(_myQueue);
                                Conient.setDataStatus("Disconnected");
                            }
                        }
                    } else {
                        Conient.addMessage("WARNING{data link}: already established");
                    }
                    break;
                case STOPDATA:
                    if(_dataLink != null) {
                        try {
                            String response;
                            // shut down the data link
                            Conient.setDataStatus("Disconnecting - " + _server);
                            
                            // close the reader
                            _dataReader.shutdown();
                            // wait for it to close
                            boolean dirtyShutdown = true;
                            long startTime = System.currentTimeMillis();
                            while((System.currentTimeMillis() - startTime) < (DATAREADER_SHUTDOWN_TIMEOUT * 1000)) {
                                if (!_dataReader.isAlive()) {
                                    dirtyShutdown = false;
                                    break;
                                }
                            }
                            // warn if it didn't shutdown in time
                            if (dirtyShutdown) {
                                Conient.addMessage("WARNING{data link}: data reader thread did not close within timeout, killing its IO anyway!");
                            }
                            
                            // tell the server
                            _outBound.println("STOPDATA");
                            _outBound.flush();
                            response = _inBound.readLine();
                            
                            // check the server was ok with our request...
                            // even if it wasn't we will go anyway!
                            if (!response.equals("OK")) {
                                throw new IOException("server didn't OK request to stop data channel - stopping anyway");
                            }
                            
                            
                            // close the lot down
                            _dataInBound.close();
                            _dataOutBound.close();
                            _dataLink.close();
                            // get rid of the socket
                            _dataLink = null;
                            
                            // and the firewall handler if there is one
                            closeFirewall(_dataFirewallProcess);
                            
                            Conient.setDataStatus("Disconnected");
                        } catch (IOException e) {
                            // print the error and tidy up what's left
                            Conient.addMessage("ERROR{data link}: " + e);
                            try {
                                _dataOutBound.close();
                                _dataInBound.close();
                                _dataLink.close();
                                // and the firewall handler if there is one
                                closeFirewall(_dataFirewallProcess);
                            } catch (IOException e2) {
                                    Conient.addMessage("CRITICAL{control link}: unable to close socket - " + e2);
                            }
                            _dataLink = null;
                            _actionQueue.clearQueue(_myQueue);
                            Conient.setDataStatus("Disconnected");
                        }
                    } else {
                        Conient.addMessage("WARNING{data link}: already disconnected");
                    }
                    break;
                case DISCONNECT:
                    if (_controlLink != null) {
                        if (_dataLink != null) {
                                // we want to tell ourselves to stop it
                                Conient.addMessage("WARNING{control link}: data link not disconnected - queueing stop events");
                                _actionQueue.add(new Integer(STOPDATA));
                                _actionQueue.add(new Integer(DISCONNECT));
                        } else {
                            try {
                                // request the server to disconnect
                                String response;
                                _outBound.println("DISCONNECT");
                                _outBound.flush();
                                response = _inBound.readLine();
                                
                                // check the server was ok with our request...
                                // even if it wasn't we will go anyway!
                                if (!response.equals("OK")) {
                                    throw new IOException("server didn't OK request to stop control channel - stopping anyway");
                                }
                                
                                // then lets shutdown the link
                                Conient.setControlStatus("Disconnecting - " + _server);
                                _inBound.close();
                                _outBound.close();
                                _controlLink.close();
                                // for good measure
                                _controlLink = null;
                                
                                // and the firewall handler if there is one
                                closeFirewall(_controlFirewallProcess);
                                
                                Conient.setControlStatus("Disconnected");
                            } catch (IOException e) {
                                Conient.addMessage("ERROR{control link}: " + e);
                                try {
                                    _inBound.close();
                                    _outBound.close();
                                    _controlLink.close();
                                    // and the firewall handler if there is one
                                    closeFirewall(_controlFirewallProcess);
                                } catch (IOException e2) {
                                    Conient.addMessage("CRITICAL{control link}: unable to close socket - " + e2);
                                }
                                _controlLink = null;
                                _actionQueue.clearQueue(_myQueue);
                                Conient.setControlStatus("Disconnected");
                            }
                        }
                    } else {
                        Conient.addMessage("WARNING{control link}: already disconnected");
                    }
                    break;
                case QUIT:
                    Conient.addMessage("Exiting.");
                    try {
                        // stop data and control if data up
                        if (_dataLink != null) {
                            _actionQueue.add(new Integer(STOPDATA));
                            _actionQueue.add(new Integer(DISCONNECT));
                            _actionQueue.add(new Integer(QUIT));
                            throw new IOException();
                        }                            
                        // stop control
                        if (_controlLink != null) {
                            _actionQueue.add(new Integer(DISCONNECT));
                            _actionQueue.add(new Integer(QUIT));
                            throw new IOException();
                        }
                        Conient.addMessage("Finished.");
                        // go!
                        System.exit(0);
                    } catch (IOException e) {
                        Conient.addMessage("WARNING: open connections detected - queueing stop events");
                    }
                    break;
                case GETCONFIGURATION:
                    if(_controlLink != null) {
                        try {
                            String response = null;
                            _outBound.println("STARTCONFIG");
                            _outBound.flush();
                            response = _inBound.readLine();
                            if (!response.equals("OK")) {
                                throw new IOException("server refused (" + response + ")");
                            }
                            _configuration.readServerConfiguration(_inBound, _outBound);
                            _outBound.println("ENDCONFIG");
                            _outBound.flush();
                            response = _inBound.readLine();
                            if (!response.equals("OK")) {
                                throw new IOException("server reported error when finishing configuration");
                            }
                        } catch (IOException e) {
                            Conient.addMessage("ERROR{control link}: when getting configuration - " + e);
                        }
                    }
                    break;
            }
        }
    }
    
    /**
     * This method allows other classes 
     * to shutdown this connection handler.
     */
    public void shutdown() {
        _running = false;
    }
    
//---PRIVATE METHODS---

    /**
     * Handles opening pipes through firewalls.
     * It checks the configuration for various entries
     * to set up the link or not.
     *
     * If a link is setup it will return the name of the 
     * new server to connect to, if a link is NOT setup,
     * it will simply return the original server name.
     *
     * The name of the machine that the pipe is setup on
     * defaults to "localhost", unless the configuration
     * specifies otherwise.
     *
     * Once it has run the firewall command it then waits
     * a set period according to the config for the firewall
     * pipe to be set up.
     *
     * The firewall process should be destroyed when the 
     * link is finished with.
     *
     * @param server the name of the server to open up the pipe to
     * @param port the port number to open up the pipe to
     * @param firewallProcess the holder for the new firewall process
     * @return the server to connect to, as determined by this routine
     */
    private String handleFirewall(String server, int port, Process firewallProcess) {
        String firewallCommand = _configuration.getProperty("firewall.command");
        String firewallCommandWait = _configuration.getProperty("firewall.commandwait");
        String firewallServer = _configuration.getProperty("firewall.server");
        // if we are running firewall support...then lets start it
        if (firewallCommand != null) {
            // clean up the command with what we want
            firewallCommand = replaceText(firewallCommand, "%PORT%", new Integer(port).toString());
            firewallCommand = replaceText(firewallCommand, "%SERVER%", server);
            Conient.addMessage("WARNING{firewall}: firewall pipes requested, running pipe setup command \"" + firewallCommand + "\"");
            try {
                // run the command
                firewallProcess = Runtime.getRuntime().exec(firewallCommand);
                
                // work out how long we should wait before carrying on                
                int time = 0;
                try {
                    time = Integer.parseInt(firewallCommandWait);
                } catch (NumberFormatException e) {
                    time = 0;
                }
                if (time == 0) {
                    time = DEFAULT_FIREWALL_COMMANDWAIT;
                }
                Conient.addMessage("WARNING{firewall}: waiting " + time + " seconds for command to complete!");
                // wait for the command to finish
                try {
                    Thread.sleep(time * 1000);
                } catch (InterruptedException e) {
                }
            
                // set the server we want to return
                server = firewallServer;
                if (server == null) {
                    server = DEFAULT_FIREWALL_SERVER;
                }
            } catch (IOException e) {
                Conient.addMessage("ERROR{firewall}: unable to start pipe to i-scream server");
            }
        }        
        return server;
    }

    /**
     * Checks to see if the given firewall process 
     * has been created.  If it has it calls destroy()
     * on it.
     *
     * @param firewallProcess the process to check
     */
    private void closeFirewall(Process firewallProcess) {
        if (firewallProcess != null) {
            _dataFirewallProcess.destroy();
            _dataFirewallProcess = null;
            Conient.addMessage("WARNING{firewall}: firewall process destroyed");
        }
    }

    /**
     * Searches a string and replaces all occurences 
     * of the given search text with the given replacement
     * text.
     *
     * @param text the text to search and replace in
     * @param search the string to look for and replace
     * @param replace the text to replace with
     * @return the updated version of text
     */
    private String replaceText(String text, String search, String replace) {
        StringBuffer textBuffer = new StringBuffer(text);
        int currIndex = 0;
        currIndex = text.indexOf(search, currIndex);
        while(currIndex != -1) {
            if (currIndex != -1) {
                textBuffer.delete(currIndex, currIndex + search.length());
                textBuffer.insert(currIndex, replace);
            }
            text = textBuffer.toString();
            currIndex = text.indexOf(search, currIndex + search.length());
        }
        return new String(textBuffer);
    }
//---ACCESSOR/MUTATOR METHODS---

//---ATTRIBUTES---       

    /**
     * The state if this thread
     */
    private boolean _running = true;
    
    /**
     * A reference to the displaying class DataPanel
     */
    private DataPanel _data;
    
    /**
     * The queue that actions are added to by other parts of the system
     */
    private Queue _actionQueue;
    
    /**
     * The queue number that we are reading from on the action queue
     */
    private int _myQueue;
    
    /**
     * The control link socket
     */
    private Socket _controlLink;
    
    /**
     * The data link socket
     */
    private Socket _dataLink;
    
    /**
     * The input for the control link
     */
    private BufferedReader _inBound;
    
    /**
     * The output for the control link
     */
    private PrintWriter _outBound;
    
    /**
     * The input for the data link
     */
    private BufferedReader _dataInBound;
    
    /**
     * The output for the data link
     */
    private PrintWriter _dataOutBound;
    
    /**
     * A reference to the DataReader in use
     */
    private DataReader _dataReader;

    /**
     * A reference to the system configuration component
     */
    private Configuration _configuration = Configuration.getInstance();

    /**
     * The server we will be connecting to
     */
    private String _server = null;
    
    /**
     * The server that the config says we should connect to
     */
    private String _configuredServer = null;

    /**
     * The process used to start the firewall pipe
     * for the control link.
     */
    private Process _controlFirewallProcess = null;
    
    /**
     * The process used to start the firewall pipe
     * for the data link.
     */
    private Process _dataFirewallProcess = null;
    
//---STATIC ATTRIBUTES---

}
Revision:	1.16
Committed:	Sun Feb 4 23:46:08 2001 UTC (23 years, 4 months ago) by ajm
Branch:	MAIN
Changes since 1.15:	+24 -27 lines
Log Message:	now has a firewallClose handler