source: tmcsimulator/trunk/src/tmcsim/client/ATMSBatchDriver.java @ 140

package tmcsim.client;



import atmsdriver.ATMSDriver;

import atmsdriver.ConsoleDriver;

import atmsdriver.ExchangeInfo;

import atmsdriver.model.Highways;

import atmsdriver.model.Station;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.rmi.Naming;

import java.rmi.RemoteException;

import java.rmi.server.UnicastRemoteObject;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.ArrayList;

import java.util.Date;

import java.util.HashMap;

import java.util.InputMismatchException;

import java.util.LinkedList;

import java.util.List;

import java.util.Map;

import java.util.Properties;

import java.util.Queue;

import java.util.Scanner;

import java.util.concurrent.TimeUnit;

import java.util.logging.Level;

import java.util.logging.Logger;

import javax.swing.JOptionPane;

import javax.swing.JWindow;

import javax.swing.Timer;

import javax.swing.UIManager;

import tmcsim.common.SimulationException;

import tmcsim.interfaces.CADClientInterface;

import tmcsim.interfaces.CoordinatorInterface;



/**

 * Skeleton for ATMS Driver that reads a "batch" file of highway

 * status update commands. 

 * It operates as a client of the

 * CAD server, using RMI to poll the server every second for the current

 * simulation clock time.  It uses the simulation clock time

 * to fire update commands at the desired time.

 * Note: Sim Mgr must be running before starting this application.

 * TODO: We probably want to be able to "override" a command, to force 

 * clearing an incident.



 * @author jdalbey

 */

public class ATMSBatchDriver extends UnicastRemoteObject implements

        CADClientInterface

{

    private static final String CONFIG_FILE_NAME = "cad_client_config.properties";

    private final static int ONE_SECOND = 1000;

    private static final int FEPSIM_INTERVAL = 30000;

    private final static SimpleDateFormat formatter = new SimpleDateFormat("HH:mm:ss");

    /**

     * Error logger.

     */

    private static Logger cadClientLogger = Logger.getLogger("tmcsim.client");



    @Override

    public void refresh() throws RemoteException

    {

        System.out.println("ATMSBatchDriver.refresh() was invoked.");

    }



    /**

     * Enumeration containing properties name values. See CADClient class

     * description for more information.

     *

     * @author Matthew Cechini

     * @see CADClient

     */

    private static enum PROPERTIES

    {

        CAD_SIM_HOST("CADSimulatorHost"), CAD_SIM_PORT("CADSimulatorSocketPort"), CAD_RMI_PORT(

        "CADRmiPort"), CLIENT_CAD_POS("CADPosition"), CLIENT_USER_ID(

        "CADUserID"), KEYBOARD_TYPE("KeyboardType"), DISPLAY_TYPE(

        "DisplayType");

        public String name;



        private PROPERTIES(String n)

        {

            name = n;

        }

    }

    /**

     * CADClientSocket Object to handle socket communication between the Client

     * and CAD Simulator.

     */

    private CADClientSocket theClientSocket;



    /**

     * Properties object for the CADClient class.

     */

    private Properties cadClientProp;

    /**

     * RMI interface for communication with the remote Coordinator.

     */

    private static CoordinatorInterface theCoorInt;

    /**

     * reference to itself to be used for disconnecting from CADSimulator

     */

    private CADClientInterface client = this;



    /**

     * Highways in traffic network

     */

    final private Highways highways;

    

    /** 

     * Queue of batch events

     */

    private Queue<String> eventQueue;

    /**

     * Map of incidents to events

     */

    private Map<String, List<String>> incidents;

    

    /** Instance of ConsoleDriver that contains the highway model */

    private ConsoleDriver console;

    

    /** GUI for this driver */

    private ATMSBatchViewer theView;

    

    /**

     * Constructor. Initialize data from parsed properties file. Create a socket

     * connection to the CADSimulator.

     *

     * @param propertiesFile File path (absolute or relative) to the properties

     * file containing configuration data.

     */

    public ATMSBatchDriver(String propertiesFile) throws SimulationException,

            RemoteException

    {

        if (!verifyProperties(propertiesFile))

        {

            System.exit(0);

        }

        incidents = new HashMap<String, List<String>> ();

        highways = new Highways(

        "config/vds_data/lds.txt",

        "config/vds_data/loop.txt",

        "config/vds_data/highwaysMeta.txt",

        "192.168.251.46", 8080);  //IP address of FEP Sim Linux VM

//        "localhost", 8080);

        // Create console driver but don't start run() method

        console = new ConsoleDriver(highways);

        

        connect(cadClientProp.getProperty(PROPERTIES.CAD_SIM_HOST.name).trim(),

                cadClientProp.getProperty(PROPERTIES.CAD_RMI_PORT.name).trim());



        // READ THE BATCH FILE OF COMMANDS and put in a queue

        readBatchFile();

        // Launch the display

        theView = new ATMSBatchViewer(this, new ArrayList<String>(incidents.keySet()));

        theView.setVisible(true);

        theView.update("0:00", eventQueue);



        // Create a timer that fetches the simulation time every second.

        Timer timer = new Timer(ONE_SECOND, new ActionListener()

        {

            // Every second, see if an event should be launched

            public void actionPerformed(ActionEvent e)

            {

                String currentClock = "";

                Date simClock = new Date();                

                // Obtain the simulation time from the CAD server

                try

                {

                    long simtime = theCoorInt.getCurrentSimulationTime();

                    currentClock = formatInterval(simtime);

                    try {

                        simClock = formatter.parse(currentClock);

                    } catch (ParseException ex) {

                        Logger.getLogger(ATMSBatchDriver.class.getName()).log(Level.SEVERE, null, ex);

                        System.out.println("Invalid simulation clock time found in ATMSDriverClient");

                        System.exit(-1);

                    }                    

                    //System.out.println("Current clock: " + currentClock);

                } catch (RemoteException ex)

                {

                    Logger.getLogger(ATMSBatchDriver.class.getName()).log(Level.SEVERE, null, ex);

                }

                // If we have any events left to process

                if (!eventQueue.isEmpty())

                {

                    // Get the time to launch the next event

                    String nextEvent = eventQueue.peek();

//                    String eventTimeField = nextEvent.substring(0,8);

                    Scanner evtScan = new Scanner(nextEvent);

                    String inci = evtScan.next();      

                    String eventTimeField = evtScan.next();

                    Date eventTime = new Date();

                    try {

                        eventTime = formatter.parse(eventTimeField);

                    } catch (ParseException ex) {

                        Logger.getLogger(ATMSBatchDriver.class.getName()).log(Level.WARNING, null, ex);

                        System.out.println("Unable to parse event time: " + nextEvent + " skipping.");

                        eventQueue.remove();

                    }

                    //System.out.println("Next event will be launched at: " + formatter.format(eventTime));

                    // Check the queue of events to see if the first

                    // item should be launched.  IF so, 

                    // issue that command and remove it from queue.

                    if (eventTime.before(simClock) || eventTime.equals(simClock))

                    {

                        System.out.println("LAUNCHING EVENT at " + nextEvent );

                        // Extract fields from event and prepare them 

                        Scanner lineScan = new Scanner(nextEvent);

                        try

                        {

                        lineScan.next(); // skip incident number field

                        lineScan.next(); // skip time field

                        int routeNumber = lineScan.nextInt();

                        Station.DIRECTION dir = Station.DIRECTION.toDirection(lineScan.next());

                        double postmile = lineScan.nextDouble();

                        double range = lineScan.nextDouble();

                        ConsoleDriver.DOTCOLOR dotcolor = ConsoleDriver.DOTCOLOR.toDotColor(lineScan.next());

                        // apply colorization to highways

                        console.applyColorToHighwayStretch(routeNumber, dir, postmile, range, dotcolor);

                        // Remove this event from the queue, we're done with it.

                        eventQueue.remove();

                        }

                        catch (InputMismatchException ex)

                        {

                            System.out.println("Wrong format data in batch event file: " + nextEvent + " \nskipping.");

                            eventQueue.remove();

                        }

                    }

                    theView.update(currentClock, eventQueue);

                }

            }

        });

        timer.start();



        // Start the FEP thread (to update ATMS every 30 sec). (See class def below)

        Thread wtfep = new WriteToFEPThread();

        wtfep.start();



        ensureProperShutdown();

    }



    private void readBatchFile()

    {

        FileInputStream fis;

        try {

            fis = new FileInputStream("config/vds_data/atmsBatchEvents.txt");

            eventQueue = new LinkedList<String>();

            // Read all lines from the file of events

            Scanner scan = new Scanner(fis);

            while (scan.hasNext())

            {

                // Read a line and add it to the event queue

                String line = scan.nextLine();

                if (line.charAt(0) != '#')

                {

                    eventQueue.add(line);

                    // Parse the incident from the line

                    Scanner lineScan = new Scanner(line);

                    String incident = lineScan.next();

                    // Add the line to the list for the corresponding incident

                    List evtList;

                    if (incidents.containsKey(incident))

                    {

                        evtList = incidents.get(incident);

                    }

                    else

                    {

                        evtList = new ArrayList<String>();

                    }               

                    evtList.add(line);

                    // and put it back in the map

                    incidents.put(incident, evtList);

                }

            }

        } catch (FileNotFoundException ex) {

            Logger.getLogger(ATMSBatchDriver.class.getName()).log(Level.SEVERE, null, ex);

        }

        System.out.println("Events file read, " + eventQueue.size() + " events queued.");

    }

    

    /** Clear an incident.  For each event associated with an incident,

     * turn the dots in its range Green and remove it from the event queue.

     * @param incidentNumber incident to be cleared.

     */

    public void clearIncident(String incidentNumber)

    {

        boolean ok = incidents.containsKey(incidentNumber);

        if (!ok) 

        {

            System.out.println("Sorry, that incident number isn't found.");

            return;

        }

        System.out.println("Clearing incident " + incidentNumber);

        List<String> events = incidents.get(incidentNumber);

        // Process each event associated with this incident 

        for (String event: events)

        {

            System.out.println("Event: " + event + " cleared.");

            eventQueue.remove(event);

            // Extract fields from event and prepare them 

            Scanner lineScan = new Scanner(event);

            try

            {

                lineScan.next(); // skip incident number field

                lineScan.next(); // skip time field

                int routeNumber = lineScan.nextInt();

                Station.DIRECTION dir = Station.DIRECTION.toDirection(lineScan.next());

                double postmile = lineScan.nextDouble();

                double range = lineScan.nextDouble();

                // apply colorization to highways, forcing to green, indicating cleared

                console.applyColorToHighwayStretch(routeNumber, dir, postmile, range, ConsoleDriver.DOTCOLOR.GREEN);

            }

            catch (InputMismatchException ex)

            {

                System.out.println("Internal error, please report to programmers." + event);

            }

            

        }

        // Now refresh the view with the updated queue of events

        theView.update("0:00", eventQueue);

    }

    

    /**

     * Connect to the Coordinator's RMI object, and register this object for

     * callback with the Coordinator.

     *

     * @param hostname Host name of the CAD Simulator.

     * @param portNumber Port number of the CAD Simulator RMI communication.

     * @throws SimulationException if there is an error creating the RMI

     * connection.

     */

    protected void connect(String hostname, String portNumber)

            throws SimulationException

    {



        String coorIntURL = "";



        try

        {

            coorIntURL = "rmi://" + hostname + ":" + portNumber

                    + "/coordinator";

            theCoorInt = (CoordinatorInterface) Naming.lookup(coorIntURL);

            theCoorInt.registerForCallback(this);

        } catch (Exception e)

        {

            throw new SimulationException(SimulationException.CAD_SIM_CONNECT,

                    e);

        }

    }



    /**

     * This method verifies that the CAD Simulator Host and Port values are not

     * null. Also, if a CAD Position or User ID do not exist in the properties

     * file, the user is prompted to enter values. These values are written to

     * the properties file. If the user cancels the process of entering these

     * values, the verification fails.

     *

     * @param propertiesFile File path (absolute or relative) to the properties

     * file containing configuration data.

     * @return True if the properties file is valid, false if not.

     * @throws SimulationException if there is an exception in verifying the

     * properties file, or if the user cancels input.

     */

    private boolean verifyProperties(String propertiesFile)

            throws SimulationException

    {



        // Load the properties file.

        try

        {

            cadClientProp = new Properties();

            cadClientProp.load(new FileInputStream(propertiesFile));

        } catch (Exception e)

        {

            cadClientLogger.logp(Level.SEVERE, "SimulationManager",

                    "Constructor", "Exception in reading properties file.", e);



            throw new SimulationException(SimulationException.INITIALIZE_ERROR,

                    e);

        }





        // Ensure that the properties file does not have null values for the

        // CAD Simulator's connection information.

        if (cadClientProp.getProperty(PROPERTIES.CAD_SIM_HOST.name) == null

                || cadClientProp.getProperty(PROPERTIES.CAD_SIM_PORT.name) == null)

        {

            cadClientLogger.logp(Level.SEVERE, "SimulationManager",

                    "Constructor", "Null value in properties file.");

            throw new SimulationException(SimulationException.INITIALIZE_ERROR);

        }



        return true;

    }



    /**

     * Format a time in seconds as HH:MM:SS

     *

     * @param l

     * @return

     */

    private String formatInterval(final long l)

    {

        final long hr = TimeUnit.SECONDS.toHours(l);

        final long min = TimeUnit.SECONDS.toMinutes(l - TimeUnit.HOURS.toSeconds(hr));

        final long sec = TimeUnit.SECONDS.toSeconds(l - TimeUnit.HOURS.toSeconds(hr) - TimeUnit.MINUTES.toSeconds(min));

        return String.format("%02d:%02d:%02d", hr, min, sec);

    }



    public void ensureProperShutdown()

    {

        Runtime.getRuntime().addShutdownHook(new Thread()

        {

            public void run()

            {

                try

                {

                    theCoorInt.unregisterForCallback(client);

                } catch (RemoteException e)

                {

                    e.printStackTrace();

                }

            }

        });

    }



    /**

     * Construct the CADClient with the properties file path, either from the

     * command line arguments or default.

     *

     * @param args Command line arguments.

     */

    public static void main(String[] args)

    {

        if (System.getProperty("CONFIG_DIR") == null)

        {

            System.setProperty("CONFIG_DIR", "config");

        }



        try

        {

            UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());

            new ATMSBatchDriver(System.getProperty("CONFIG_DIR") + System.getProperty("file.separator") + CONFIG_FILE_NAME);



        } catch (Exception e)

        {

            cadClientLogger.logp(Level.SEVERE, "SimulationManager", "Main",

                    "Error initializing application.");



            JOptionPane.showMessageDialog(new JWindow(), e.getMessage(),

                    "Error - Program Exiting", JOptionPane.ERROR_MESSAGE);



            System.exit(-1);

        }



    }



    class WriteToFEPThread extends Thread

    {



        public void run()

        {

            System.out.println("WriteToFEP Thread starting.");

            // Run indefinitely

            while (true)

            {

                try {

                    // Write the highway network status to the FEP Simulator

                    highways.writeToFEP();

                } catch (SimulationException ex) 

                {

                    System.out.println("Skipping writeToFEP...");

                }



                // Wait for FEP Sim to process the data we just sent

                try

                {

                    Thread.sleep(FEPSIM_INTERVAL);

                }

                catch (InterruptedException ie)

                {

                    ie.printStackTrace();

                }

            }



        }

    }

}