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.18 2001/02/26 00:25:00 ajm4 Exp $
 */
public class ConnectionHandler extends Thread {

//---FINAL ATTRIBUTES---

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


    /**
     * 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").equals("0")) {
            _actionQueue.add(new Integer(CONNECT));
        }
        if(!_configuration.getProperty("data.onstartconnect").equals("0")) {
            _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!
                            getConfigFromServer();
                        } 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:
                    getConfigFromServer();
                    break;
            }
        }
    }
    
    /**
     * This method allows other classes 
     * to shutdown this connection handler.
     */
    public void shutdown() {
        _running = false;
    }
    
//---PRIVATE METHODS---

    /**
     * This method performs the STARTCONFIG command on 
     * the server. this method is called after a CONNECT,
     * and when a GETCONFIGURATION command is called.
     */
    private void getConfigFromServer() {
        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);
            }
        }
    }

    /**
     * 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 useFirewall = _configuration.getProperty("useFirewall");
        String firewallCommandWait = _configuration.getProperty("firewall.commandwait");
        String firewallServer = _configuration.getProperty("firewall.server");
        // if we are running firewall support...then lets start it
        if (!useFirewall.equals("0")) {
            // 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.equals("")) {
                    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) {
            firewallProcess.destroy();
            firewallProcess = 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.19
Committed:	Tue Feb 27 03:09:58 2001 UTC (23 years, 3 months ago) by ajm
Branch:	MAIN
Changes since 1.18:	+7 -6 lines
Log Message:	Now has fully support for configuration modification, saving and loading. Note there are still bugs, namely the server config is NOT treated seperately from local config, as well as concurrency issues of loading in a config as its changing. Also not present is support for checking all REQUIRED configuration options are present, so that will need to be done.