FileToRbnb.java

/*
 * Created on July 29, 2004
 */
package org.nees.rbnb;

import java.io.*;
import java.util.StringTokenizer;
import java.util.Vector;
import java.util.Enumeration;

import org.nees.daq.ISOtoRbnbTime;

import com.rbnb.sapi.*;
//import COM.Creare.Utility.ArgHandler; //for argument parsing
import com.rbnb.utility.ArgHandler; //for argument parsing

public class FileToRbnb  extends RBNBBase {

    private static final String SOURCE_NAME_NAME = "SourceName";
    private static final String SOURCE_NAME = "FileDump";
    private static final String CHANNEL_NAME_NAME = "ChannelName";
    private static final String CHANNEL_NAME = "data.txt";
    private static final String CACHE_SIZE_NAME = "CacheSize";  
    private static final int DEFAULT_CACHE_SIZE=100;

    private final String ARCHIVE_DIRECTORY_NAME = "ArchiveDirectory";
    private final String DATA_FILE_NAME_NAME = "DataFileName";

    private static final String ARCHIVE_DIRECTORY = ".";
    private static final String DATA_FILE_NAME = "Data.txt";

    private String sourceName = SOURCE_NAME;
    private String channelName = CHANNEL_NAME;
    private int cacheSize = DEFAULT_CACHE_SIZE;

    private String archiveDirectory = ARCHIVE_DIRECTORY;
    private String dataFileName = DATA_FILE_NAME;
    private BufferedReader rd;
    
    Source source = null;
    ChannelMap sMap;
    int index;
    boolean connected = false;
    
    Thread timerThread;
    boolean runit = false;
    
    private String[] parameterNameArray;
    private String[] parameterTypeArray;
    private Object[] parameterDefaultArray;
    
    public static void main(String[] args) {
        // start from command line
        FileToRbnb w = new FileToRbnb();
        if (w.setArgs(args))
        {
            w.connect();
            w.startThread();
        }
    }
    
    public FileToRbnb()
    {
        setParamterArrays();
        initialize();
    }

    public void printUsage() {
        System.out.println("FileToRbnb: usage is...");      
        System.out.println("FileToRbnb ");
        super.printUsage();  // uses h, s, p
        System.out.println("[-n source_name *" + SOURCE_NAME + "] ");
        System.out.println("[-c channel_name *" + CHANNEL_NAME + "] ");
        System.out.println("[-d Archive directory root *" + ARCHIVE_DIRECTORY + "]");
        System.out.println("[-D Data input file name *" + DATA_FILE_NAME + "]");
        System.out.println("[-z cache size *" + DEFAULT_CACHE_SIZE + "]");
        System.out.println();
    }

    protected boolean setInstanceArgs(String[] args) throws IllegalArgumentException
    {
        //parse args
        try {
            ArgHandler ah=new ArgHandler(args);
            if (ah.checkFlag('n')) {
                String a=ah.getOption('n');
                if (a!=null) sourceName=a;
            }
            if (ah.checkFlag('c')) {
                String a=ah.getOption('c');
                if (a!=null) channelName=a;
            }
            if (ah.checkFlag('d')) {
                String a=ah.getOption('d');
                if (a!=null) archiveDirectory=a;
            }
            if (ah.checkFlag('D')) {
                String a=ah.getOption('D');
                if (a!=null) dataFileName=a;
            }
            if (ah.checkFlag('z')) {
                String a=ah.getOption('z');
                if (a!=null)
                try
                {
                    Integer i =  new Integer(a);
                    int value = i.intValue();
                    cacheSize = value;
                    System.out.println("sizes " + cacheSize + "," + value);
                }
                catch (Exception ignore) {} 
            }
        } catch (Exception e) {
            throw new IllegalArgumentException("Argument Exception: " + e);
        }
        
        System.out.println("Starting FileToRbnb on " + getServer()
            + " as " + sourceName);
        System.out.println("  Channel name = " + channelName
            + "  Cache Size = " + cacheSize);
        System.out.println("  Use FileToRbnb -h to see optional parameters");
        
        return true;
    }
    
    protected void setParamterArrays() {

        String [] pNameArray = super.getBaseParameterNameArray();
        String [] pTypeArray = super.getBaseParameterTypeArray();
        Object [] pDefaultArray = super.getBaseParameterDefaultArray();
        
        int base = pNameArray.length;
        int numberOfparameters = 5;
        parameterNameArray = new String[base + numberOfparameters];
        parameterTypeArray = new String[base + numberOfparameters];
        parameterDefaultArray = new Object[base + numberOfparameters];
        
        for (int i = 0; i < base; i++)
        {
            parameterNameArray[i] = pNameArray[i];
            parameterTypeArray[i] = pTypeArray[i];
            parameterDefaultArray[i] = pDefaultArray[i];
        }

        parameterNameArray[base + 0] = SOURCE_NAME_NAME;
        parameterTypeArray[base + 0] = RBNBBaseParameterHolder.STRING_TYPE;
        parameterDefaultArray[base + 0] = new String(SOURCE_NAME);      

        parameterNameArray[base + 1] = CHANNEL_NAME_NAME;
        parameterTypeArray[base + 1] = RBNBBaseParameterHolder.STRING_TYPE;
        parameterDefaultArray[base + 1] = new String(CHANNEL_NAME);     

        parameterNameArray[base + 2] = CACHE_SIZE_NAME;
        parameterTypeArray[base + 2] = RBNBBaseParameterHolder.INTEGER_TYPE;
        parameterDefaultArray[base + 2] = new Integer(DEFAULT_CACHE_SIZE);      

        parameterNameArray[base + 3] = ARCHIVE_DIRECTORY_NAME;
        parameterTypeArray[base + 3] = RBNBBaseParameterHolder.STRING_TYPE;
        parameterDefaultArray[base + 3] = new String(ARCHIVE_DIRECTORY);        

        parameterNameArray[base + 4] = DATA_FILE_NAME_NAME;
        parameterTypeArray[base + 4] = RBNBBaseParameterHolder.STRING_TYPE;
        parameterDefaultArray[base + 4] = new String(DATA_FILE_NAME);       
    }
    
    /* (non-Javadoc)
     * @see org.nees.rbnb.RBNBBase#setVariablesFromParameters()
     */
    public void setVariablesFromParameters() {
        super.setBaseVarialbesFromParametes();
        
        sourceName = SOURCE_NAME;
        try{
            Object obj = getValueWithDefault(SOURCE_NAME_NAME, SOURCE_NAME);
            sourceName = (String)obj;
        } catch (Throwable ignore){}

        channelName = CHANNEL_NAME;
        try{
            Object obj = getValueWithDefault(CHANNEL_NAME_NAME, CHANNEL_NAME);
            channelName = (String)obj;
        } catch (Throwable ignore){}

        cacheSize = DEFAULT_CACHE_SIZE;
        try{
            Integer i = new Integer(DEFAULT_CACHE_SIZE);
            Object obj = getValueWithDefault(CACHE_SIZE_NAME, i);
            cacheSize = ((Integer)obj).intValue();
        } catch (Throwable ignore){}

        archiveDirectory = ARCHIVE_DIRECTORY;
        try{
            Object obj = getValueWithDefault(ARCHIVE_DIRECTORY_NAME, ARCHIVE_DIRECTORY);
            archiveDirectory = (String)obj;
        } catch (Throwable ignore){}

        dataFileName = DATA_FILE_NAME;
        try{
            Object obj = getValueWithDefault(DATA_FILE_NAME_NAME, DATA_FILE_NAME);
            dataFileName = (String)obj;
        } catch (Throwable ignore){}

    }

    public void connect()
    {
        System.out.println("FileToRbnb: Attempting to connect to server = "
            + getServer() + " as " + sourceName + " with " + channelName + ".");
        try {
            // Create a source and connect:
            source=new Source(cacheSize, "none", 0);
            source.OpenRBNBConnection(getServer(),sourceName);
            connected = true;
            System.out.println("FileToRbnb: Connection made to server = "
                + getServer() + " as " + sourceName + " with " + channelName + ".");
        } catch (SAPIException se) { se.printStackTrace(); }
        
        if (connected)
        {
            // attmpt to open file
            String path = archiveDirectory + "/" + dataFileName;
            File probe = new File(path);

            // does it exist and is it readable
            if (probe != null && probe.exists() && probe.canRead())
            {
                if (rd != null)
                {
                    try {
                        rd.close();
                    } catch (IOException ignore) {}
                    rd = null;
                }
                try
                {
                    rd = new BufferedReader(new FileReader(probe));
                    System.out.println("Sucessfully connected to " + path);
                }
                catch (IOException e)
                {
                    e.printStackTrace();
                    disconnect();
                }
                if (rd == null)
                {
                    System.out.println("Failed to open file stream " + path);
                    disconnect();
                }
            }
            else // data not available
            {
                System.out.println("Data unavailable: path...");
                if (probe == null)
                    System.out.println("Could not open file.");
                else if (!probe.exists())
                    System.out.println("File does not exist");
                else if (!probe.canRead())
                    System.out.println("File is unreadable");
                disconnect();
            }
        }
    }

    private void disconnect() {
        source.Detach();
        connected = false;
        source = null;
        if (rd != null)
            {
                try {
                    rd.close();
                } catch (IOException ignore) {}
                rd = null;
            }
        }

    public void startThread()
    {
        
        if (!connected) return;
        
        // Use this inner class to hide the public run method
        Runnable r = new Runnable() {
            public void run() {
              runWork();
            }
        };
        runit = true;
        timerThread = new Thread(r, "Timer");
        timerThread.start();
        System.out.println("FileToRbnb: Started thread.");
    }

    public void stopThread()
    {
        runit = false;
        timerThread.interrupt();
        System.out.println("FileToRbnb: Stopped thread.");
    }
    
    private void runWork ()
    {
        if (!isRunning()) return;
        
        int lineCount = 0;
        String in = "";
        boolean header = true;
        
        try {
            // read one line ahead 
            
            while(header && ((in = rd.readLine()) != null) && isRunning())
            {
                if (!   in.startsWith("Time"))
                {
                    System.out.println("Skipping header line: " + in);
                    continue;
                }
                else
                    header = false;
            }
            
            if (!isRunning()) return;
            if (in == null)
            {
                System.out.println("Unexpected end of file.");
            }
            
            // the first non-header line should be a list of channel names
            System.out.println("Channel list line: " + in);
            
            // parse out the channel names and discard any path information
            // e.q. FromDaq/LoadCell_z will be sent as LoadCell_z
            StringTokenizer st = new StringTokenizer(in," "); // seperated by blanks
            Vector channelNames = new Vector();

            while (st.hasMoreTokens())
                channelNames.add(st.nextToken());
                
            String[] channelNameArray = new String[channelNames.size()];
            
            Enumeration en = channelNames.elements();
            int pos,i = 0;
            String name;
            while (en.hasMoreElements())
            {
                name = (String)en.nextElement();
                pos = name.lastIndexOf('/');
                if (pos > -1) name = name.substring(pos+1);
                channelNameArray[i] = name;
                i++;
            }
        
            // set up channels  
            int[] channalIndexArray = new int[channelNameArray.length];
            ChannelMap map = new ChannelMap();
            for (int n = 0; n < channelNameArray.length; n++)
            {
                channalIndexArray[n] = map.Add(channelNameArray[n]);
                System.out.println("Added Channel " + channelNameArray[n] 
                    +  " with index = " + channalIndexArray[n]);
            }
            source.Register(map);
                    
            while(((in = rd.readLine()) != null) && isRunning())
            {
                st = new StringTokenizer(in," ");

                // the first token is the time stamp                
                String tsString = st.nextToken();
                ISOtoRbnbTime timestamp = new ISOtoRbnbTime(tsString);
                if (!timestamp.is_valid)
                {
                    System.out.println("Warning: timestamp not valid: " + tsString);
                }
                double time = timestamp.getValue();
                map.PutTime(time,0.0);
                
                // The rest of line is floting point data values
                i = 0;
                double[] data = new double[1]; 
                while (st.hasMoreTokens())
                {
                    // post data to channel i
                    data[0] = Double.parseDouble(st.nextToken());
                    map.PutDataAsFloat64(channalIndexArray[i],data);
                    i++;
                }
                source.Flush(map);                  
            }
        }
        catch (Exception e) {
            System.out.println("IO Error: " + e);
        }
        
        stop();
    }
    
    public boolean isRunning()
    {
        return (connected && runit);
    }

    /* (non-Javadoc)
     * @see org.nees.rbnb.RBNBBase#getParameterNameArray()
     */
    public String[] getParameterNameArray() {
        return parameterNameArray;
    }

    /* (non-Javadoc)
     * @see org.nees.rbnb.RBNBBase#getParameterTypeArray()
     */
    public String[] getParameterTypeArray() {
        return parameterTypeArray;
    }

    /* (non-Javadoc)
     * @see org.nees.rbnb.RBNBBase#getParameterDefaultArray()
     */
    public Object[] getParameterDefaultArray() {
        return parameterDefaultArray;
    }

    /* (non-Javadoc)
     * @see org.nees.rbnb.RBNBBase#start()
     */
    public boolean start() {
        if (isRunning()) return false;
        if (connected) disconnect();
        setVariablesFromParameters();
        connect();
        if (!connected) return false;
        startThread();
        return true;
    }

    /* (non-Javadoc)
     * @see org.nees.rbnb.RBNBBase#stop()
     */
    public boolean stop() {
        if (!isRunning()) return false;
        stopThread();
        disconnect();
        return true;
    }

}

---