source: tmcsimulator/trunk/src/tmcsim/paramicscommunicator/ParamicsFileWriter.java @ 2

package tmcsim.paramicscommunicator;





import java.io.File;

import java.io.FileWriter;

import java.io.IOException;

import java.util.LinkedList;

import java.util.Observable;

import java.util.Timer;

import java.util.TimerTask;

import java.util.logging.Level;

import java.util.logging.Logger;



import org.apache.xml.serialize.OutputFormat;

import org.apache.xml.serialize.XMLSerializer;

import org.w3c.dom.Element;



import tmcsim.paramicscommunicator.FileIOUpdate.IO_TYPE;



/**

 * The ParamicsFileWriter handles writing messages to a target file which

 * is read by Paramics.  Messages are received through the writeMessage() method.

 * This object handles queueing messages and writing as the file becomes

 * available.  New data is written to the target file when it has been

 * modified (cleared) by Paramics.  If this does not happen, messages

 * are queued and a timer is used to periodically determine if the

 * file has become available for writing.

 * 

 * @author Matthew Cechini

 * @version

 */

public class ParamicsFileWriter extends Observable {

    

    /** 

     * Duration (in  ms) that the TimerTask will be scheduled to

     * retry writing to the target file. Default = 2000ms

     */

    private static long TIMER_DURATION = 2000;

    

    /** Error Logger. */

    private Logger paramLogger = Logger.getLogger("tmcsim.paramicscommunicator");

    

    /** Linked List of messages that have been received */

    private LinkedList<Element> queuedMessages = null;

    

    /**  */

    private String writerID = null;



    /** File name of the file where data is written */

    private String outputFile = null;

    

    /** FileWriter used to write data to the output file. */

    private FileWriter fileWriter = null;

    

    /** Value (seconds since 1/1/1970) of output file's last modifcation time */

    private long lastModified = 0;  

    

    /** Timer used to schedule file writing tasks. */

    private Timer writerTimer = null;

    

    /**

     * A TimerTask to retry writing messages that have been queued within this

     * ParamicsWriter.  If a message has been queued, see if the target file

     * has been modified since last write.  If so, write the first queued message

     * to the file and remove the message from the queue.  If writing is unsuccessful,

     * do not remove the message from the queue.  If there are no more messages in 

     * the queue, cancel this timer.

     */

    private class WriterTimerTask extends TimerTask {

        public void run() {



            synchronized(lock) {

            

                //if we've queued something, continue.

                if(queuedMessages.size() > 0) {         

                    

                    //if file has been modified, write to it

                    if(lastModified < new File(outputFile).lastModified())

                    {       

                        try {

                            writeToFile(queuedMessages.getFirst());

                            queuedMessages.remove(0);

                        }

                        catch (IOException ioe) {

                            paramLogger.logp(Level.SEVERE, "ParamicsFileWriter.WriterTimerTask", 

                                    "run()", "Exception in writing to the target file: " + 

                                    outputFile + ".  Queue size = " + queuedMessages.size(), ioe);

                        }

                        

                        //all queued messages gone, cancel timer

                        if(queuedMessages.size() == 0)

                            this.cancel();

                    }   

                }

            }               

        }

    }

    

    /** Synchronizing lock to protect File IO and message queuing. */

    private Object lock = null;     

    

    /**

     * Constructor.  Initialize data objects.  If the target file exists, delete 

     * it, and then create a new file.  

     *

     * @param workingDir Directory path where the output file is to be written

     * @param mess The ParamicsCommMessage containing the outputFile filename.

     */

    public ParamicsFileWriter(String id, String workingDir, String targetFile) {



        try {

            writerID = id;

    

            queuedMessages  = new LinkedList<Element>();    

            lock            = new Object();

                        

            outputFile      = workingDir + targetFile;  

            

            File tempFile = new File(outputFile);           

            if(tempFile.exists()) {

                tempFile.delete();

            }



            tempFile.createNewFile();           

                                                

            writerTimer     = new Timer();

            

        } catch (IOException ioe) {

            paramLogger.logp(Level.SEVERE, "ParamicsFileWriter", "Constructor", 

                    "Unable to create Paramics File Writer.", ioe);

        }

        

    }

    

    

    /**

     * Method is called when a message has been received from the CAD Simulator.

     * If the message queue is not empty, add the new message to the queue.

     * If the output file has not been modified (read) since last write,

     * add the message to the queue and set a timer to repeatedly check for 

     * modification to the output file.  Else, write the new message to the file.  

     * If there is an error in writing the data, queue the message start a timer

     * to retry the writing.

     *

     * @param newMessage The received message which is to be written to 

     * the output file.

     */

    public void writeMessage(Element messageElem) {

        

        synchronized(lock) {

            

            //messages already queued... get in line.           

            if(queuedMessages.size() > 0) {

                queuedMessages.add(messageElem);



                paramLogger.log(Level.INFO, "Queueing message, new queue " +

                        "size = " + queuedMessages.size());

            }               

            //No modification since last write. (first queue)               

            else if (lastModified >= new File(outputFile).lastModified()) {

                queuedMessages.add(messageElem);                

                                

                writerTimer.scheduleAtFixedRate(new WriterTimerTask(), 

                        0L, TIMER_DURATION);



                paramLogger.log(Level.INFO, "First message queued");

            }           

            //free and clear, write.

            else {

                try {

                    writeToFile(messageElem);

                }

                catch(IOException ioe) {

                    paramLogger.logp(Level.SEVERE, "ParamicsFileWriter", 

                            "writeMessage()", "Exception in writing to the " +

                            "target file: " + outputFile, ioe);

                    

                    queuedMessages.add(messageElem);

                    

                    writerTimer.scheduleAtFixedRate(new WriterTimerTask(), 

                            0L, TIMER_DURATION);

                }

            }

        }

    }

        

    /**

     * Method writes data to the output file.

     * 

     * @param output Data to be written to the file.

     */

    private void writeToFile(Element output) throws IOException {       

        

        fileWriter = new FileWriter(outputFile);

        

        OutputFormat of = new OutputFormat("XML","ISO-8859-1",true);

        of.setIndent(1);

        of.setIndenting(true);

        

        XMLSerializer serializer = new XMLSerializer(fileWriter, of);

        serializer.asDOMSerializer();

        serializer.serialize(output);



        /** Added by Nathaniel Lehrer */

        try {

            java.io.ByteArrayOutputStream outputStream = new java.io.ByteArrayOutputStream();

            new XMLSerializer(outputStream, of).serialize(output);

            tmcsim.paramicslog.ParamicsLog.getInstance().writeToLog(outputStream.toString());

        } catch(Exception e) {

            System.out.println(e);

        }

        /** End Add by Nathaniel Lehrer */

        

        fileWriter.flush();

        fileWriter.close();

        

        lastModified = new File(outputFile).lastModified();     

        

        setChanged();

        notifyObservers(new FileIOUpdate(IO_TYPE.WRITE, writerID, new File(outputFile).length()));

                            

    }               

}