path: root/core/java12/com/vladium/emma/data/DataFactory.java

/* Copyright (C) 2003 Vladimir Roubtsov. All rights reserved.
 * 
 * This program and the accompanying materials are made available under
 * the terms of the Common Public License v1.0 which accompanies this distribution,
 * and is available at http://www.eclipse.org/legal/cpl-v10.html
 * 
 * $Id: DataFactory.java,v 1.1.1.1.2.3 2004/07/16 23:32:29 vlad_r Exp $
 */
package com.vladium.emma.data;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInput;
import java.io.DataInputStream;
import java.io.DataOutput;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileDescriptor;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.RandomAccessFile;
import java.net.URL;
import java.net.URLConnection;

import com.vladium.logging.Logger;
import com.vladium.util.asserts.$assert;
import com.vladium.emma.IAppConstants;

// ----------------------------------------------------------------------------
/**
 * @author Vlad Roubtsov, (C) 2003
 */
public
abstract class DataFactory
{
    // public: ................................................................
    
    // TODO: file compaction
    // TODO: file locking
    
    // TODO: what's the best place for these?
    
    public static final byte TYPE_METADATA          = 0x0; // must start with 0
    public static final byte TYPE_COVERAGEDATA      = 0x1; // must be consistent with mergeload()
    
    
    public static IMergeable [] load (final File file)
        throws IOException
    {
        if (file == null) throw new IllegalArgumentException ("null input: file");
        
        return mergeload (file);
    }
    
    public static void persist (final IMetaData data, final File file, final boolean merge)
        throws IOException
    {
        if (data == null) throw new IllegalArgumentException ("null input: data");
        if (file == null) throw new IllegalArgumentException ("null input: file");
        
        if (! merge && file.exists ())
        {
            if (! file.delete ())
                throw new IOException ("could not delete file [" + file.getAbsolutePath () + "]");
        }
        
        persist (data, TYPE_METADATA, file);
    }
    
    public static void persist (final ICoverageData data, final File file, final boolean merge)
        throws IOException
    {
        if (data == null) throw new IllegalArgumentException ("null input: data");
        if (file == null) throw new IllegalArgumentException ("null input: file");
        
        if (! merge && file.exists ())
        {
            if (! file.delete ())
                throw new IOException ("could not delete file [" + file.getAbsolutePath () + "]");
        }
        
        persist (data, TYPE_COVERAGEDATA, file);
    } 
    
    public static void persist (final ISessionData data, final File file, final boolean merge)
        throws IOException
    {
        if (data == null) throw new IllegalArgumentException ("null input: data");
        if (file == null) throw new IllegalArgumentException ("null input: file");
        
        if (! merge && file.exists ())
        {
            if (! file.delete ())
                throw new IOException ("could not delete file [" + file.getAbsolutePath () + "]");
        }
        
        persist (data.getMetaData (), TYPE_METADATA, file); 
        persist (data.getCoverageData (), TYPE_COVERAGEDATA, file);
    }

    
    public static IMetaData newMetaData (final CoverageOptions options)
    {
        return new MetaData (options);
    }
    
    public static ICoverageData newCoverageData ()
    {
        return new CoverageData (); 
    }

    public static IMetaData readMetaData (final URL url)
        throws IOException, ClassNotFoundException
    {
        ObjectInputStream oin = null;
        
        try
        {
            oin = new ObjectInputStream (new BufferedInputStream (url.openStream (), 32 * 1024));
            
            return (IMetaData) oin.readObject ();
        }
        finally
        {
            if (oin != null) try { oin.close (); } catch (Exception ignore) {} 
        }
    }
    
    public static void writeMetaData (final IMetaData data, final OutputStream out)
        throws IOException
    {
        ObjectOutputStream oout = new ObjectOutputStream (out);
        oout.writeObject (data);
    }
    
    public static void writeMetaData (final IMetaData data, final URL url)
        throws IOException
    {
        final URLConnection connection = url.openConnection ();
        connection.setDoOutput (true);
        
        OutputStream out = null;
        try
        {
            out = connection.getOutputStream ();
            
            writeMetaData (data, out);
            out.flush ();
        }
        finally
        {
            if (out != null) try { out.close (); } catch (Exception ignore) {} 
        }
    }
    
    public static ICoverageData readCoverageData (final URL url)
        throws IOException, ClassNotFoundException
    {
        ObjectInputStream oin = null;
        
        try
        {
            oin = new ObjectInputStream (new BufferedInputStream (url.openStream (), 32 * 1024));
            
            return (ICoverageData) oin.readObject ();
        }
        finally
        {
            if (oin != null) try { oin.close (); } catch (Exception ignore) {} 
        }
    }
    
    public static void writeCoverageData (final ICoverageData data, final OutputStream out)
        throws IOException
    {
        // TODO: prevent concurrent modification problems here
        
        ObjectOutputStream oout = new ObjectOutputStream (out);
        oout.writeObject (data);
    }
    
    public static int [] readIntArray (final DataInput in)
        throws IOException
    {
        final int length = in.readInt ();
        if (length == NULL_ARRAY_LENGTH)
            return null;
        else
        {
            final int [] result = new int [length];
            
            // read array in reverse order:
            for (int i = length; -- i >= 0; )
            {
                result [i] = in.readInt ();
            }
            
            return result;
        }
    }
    
    public static boolean [] readBooleanArray (final DataInput in)
        throws IOException
    {
        final int length = in.readInt ();
        if (length == NULL_ARRAY_LENGTH)
            return null;
        else
        {
            final boolean [] result = new boolean [length];
            
            // read array in reverse order:
            for (int i = length; -- i >= 0; )
            {
                result [i] = in.readBoolean ();
            }
            
            return result;
        }
    }
    
    public static void writeIntArray (final int [] array, final DataOutput out)
        throws IOException
    {
        if (array == null)
            out.writeInt (NULL_ARRAY_LENGTH);
        else
        {
            final int length = array.length;
            out.writeInt (length);
            
            // write array in reverse order:
            for (int i = length; -- i >= 0; )
            {
                out.writeInt (array [i]);
            }
        }
    }
    
    public static void writeBooleanArray (final boolean [] array, final DataOutput out)
        throws IOException
    {
        if (array == null)
            out.writeInt (NULL_ARRAY_LENGTH);
        else
        {
            final int length = array.length;
            out.writeInt (length);
            
            // write array in reverse order:
            for (int i = length; -- i >= 0; )
            {
                out.writeBoolean (array [i]);
            }
        }
    }
    
    // protected: .............................................................

    // package: ...............................................................
    
    // private: ...............................................................


    private static final class UCFileInputStream extends FileInputStream
    {
        public void close ()
        {
        }
        
        UCFileInputStream (final FileDescriptor fd)
        {
            super (fd);
            
            if ($assert.ENABLED) $assert.ASSERT (fd.valid (), "UCFileInputStream.<init>: FD invalid");
        }
        
    } // end of nested class

    private static final class UCFileOutputStream extends FileOutputStream
    {
        public void close ()
        {
        }
        
        UCFileOutputStream (final FileDescriptor fd)
        {
            super (fd);
            
            if ($assert.ENABLED) $assert.ASSERT (fd.valid (), "UCFileOutputStream.<init>: FD invalid");
        }
        
    } // end of nested class

    
    private static final class RandomAccessFileInputStream extends BufferedInputStream
    {
        public final int read () throws IOException
        {
            final int rc = super.read ();
            if (rc >= 0) ++ m_count;
            
            return rc;
        }

        public final int read (final byte [] b, final int off, final int len)
            throws IOException
        {
            final int rc = super.read (b, off, len);
            if (rc >= 0) m_count += rc;
            
            return rc;
        }

        public final int read (final byte [] b) throws IOException
        {
            final int rc = super.read (b);
            if (rc >= 0) m_count += rc;
            
            return rc;
        }
        
        public void close ()
        {
        }        


        RandomAccessFileInputStream (final RandomAccessFile raf, final int bufSize)
            throws IOException
        {
            super (new UCFileInputStream (raf.getFD ()), bufSize);
        }
        
        final long getCount ()
        {
            return m_count;
        }
        
        private long m_count;

    } // end of nested class
    
    private static final class RandomAccessFileOutputStream extends BufferedOutputStream
    {
        public final void write (final byte [] b, final int off, final int len) throws IOException
        {
            super.write (b, off, len);
            m_count += len;
        }

        public final void write (final byte [] b) throws IOException
        {
            super.write (b);
            m_count += b.length;
        }

        public final void write (final int b) throws IOException
        {
            super.write (b);
            ++ m_count;
        }
        
        public void close ()
        {
        }
        
        
        RandomAccessFileOutputStream (final RandomAccessFile raf, final int bufSize)
            throws IOException
        {
            super (new UCFileOutputStream (raf.getFD ()), bufSize);
        }
        
        final long getCount ()
        {
            return m_count;
        }
        
        private long m_count;

    } // end of nested class
    
    
    private DataFactory () {} // prevent subclassing   

    /*
     * input checked by the caller
     */
    private static IMergeable [] mergeload (final File file)
        throws IOException
    {
        final Logger log = Logger.getLogger ();
        final boolean trace1 = log.atTRACE1 ();
        final boolean trace2 = log.atTRACE2 ();
        final String method = "mergeload";
        
        long start = 0, end;
        
        if (trace1) start = System.currentTimeMillis ();
        
        final IMergeable [] result = new IMergeable [2];
        
        if (! file.exists ())
        {
            throw new IOException ("input file does not exist: [" + file.getAbsolutePath () +  "]");
        }
        else
        {
            RandomAccessFile raf = null;
            try
            {
                raf = new RandomAccessFile (file, "r");
                
                // 'file' is a valid existing file, but it could still be of 0 length or otherwise corrupt:
                final long length = raf.length ();
                if (trace1) log.trace1 (method, "[" + file + "]: file length = " + length);
                
                if (length < FILE_HEADER_LENGTH)
                {
                    throw new IOException ("file [" + file.getAbsolutePath () + "] is corrupt or was not created by " + IAppConstants.APP_NAME);
                }
                else
                {
                    // TODO: data version checks parallel to persist()
                    
                    if (length > FILE_HEADER_LENGTH) // return {null, null} in case of equality
                    {
                        raf.seek (FILE_HEADER_LENGTH);
                                
                        // [assertion: file length > FILE_HEADER_LENGTH]
                        
                        // read entries until the first corrupt entry or the end of the file:
                        
                        long position = FILE_HEADER_LENGTH;
                        long entryLength;
                        
                        long entrystart = 0;
                        
                        while (true)
                        {
                            if (trace2) log.trace2 (method, "[" + file + "]: position " + raf.getFilePointer ());
                            if (position >= length) break;
                            
                            entryLength = raf.readLong ();
                            
                            if ((entryLength <= 0) || (position + entryLength + ENTRY_HEADER_LENGTH > length))
                                break;
                            else
                            {
                                final byte type = raf.readByte ();
                                if ((type < 0) || (type >= result.length))
                                    break;
                                    
                                if (trace2) log.trace2 (method, "[" + file + "]: found valid entry of size " + entryLength + " and type " + type);
                                {
                                    if (trace2) entrystart = System.currentTimeMillis ();
                                    final IMergeable data = readEntry (raf, type, entryLength);
                                    if (trace2) log.trace2 (method, "entry read in " + (System.currentTimeMillis () - entrystart) + " ms");                                    
                                    
                                    final IMergeable current = result [type];
                                    
                                    if (current == null)
                                        result [type] = data;
                                    else
                                        result [type] = current.merge (data); // note: later entries overrides earlier entries
                                }
                                
                                position += entryLength + ENTRY_HEADER_LENGTH;
                                
                                if ($assert.ENABLED) $assert.ASSERT (raf.getFD ().valid (), "FD invalid"); 
                                raf.seek (position);
                            }
                        }                        
                    }
                }
            }
            finally
            {
                if (raf != null) try { raf.close (); } catch (Throwable ignore) {}
                raf = null;
            }
        }
        
        if (trace1)
        {
            end = System.currentTimeMillis ();
            
            log.trace1 (method, "[" + file + "]: file processed in " + (end - start) + " ms"); 
        }
        
        return result;
    }


    /*
     * input checked by the caller
     */
    private static void persist (final IMergeable data, final byte type, final File file)
        throws IOException
    {
        final Logger log = Logger.getLogger ();
        final boolean trace1 = log.atTRACE1 ();
        final boolean trace2 = log.atTRACE2 ();
        final String method = "persist";
        
        long start = 0, end;
        
        if (trace1) start = System.currentTimeMillis ();
        
        // TODO: 1.4 adds some interesting RAF open mode options as well
        // TODO: will this benefit from extra buffering?
        
        // TODO: data version checks

        RandomAccessFile raf = null;
        try
        {
            boolean overwrite = false;
            boolean truncate = false;
                        
            if (file.exists ())
            {
                // 'file' exists:
                
                if (! file.isFile ()) throw new IOException ("can persist in normal files only: " + file.getAbsolutePath ());
                
                raf = new RandomAccessFile (file, "rw");
                
                // 'file' is a valid existing file, but it could still be of 0 length or otherwise corrupt:
                final long length = raf.length ();
                if (trace1) log.trace1 (method, "[" + file + "]: existing file length = " + length);
                
                
                if (length < 4)
                {
                    overwrite = true;
                    truncate = (length > 0);
                }
                else
                {
                    // [assertion: file length >= 4]
                    
                    // check header info before reading further:
                    final int magic = raf.readInt ();
                    if (magic != MAGIC)
                        throw new IOException ("cannot overwrite [" + file.getAbsolutePath () + "]: not created by " + IAppConstants.APP_NAME);
                    
                    if (length < FILE_HEADER_LENGTH)
                    {
                        // it's our file, but the header is corrupt: overwrite
                        overwrite = true;
                        truncate = true;
                    }  
                    else
                    {
                        // [assertion: file length >= FILE_HEADER_LENGTH]
                        
//                        if (! append)
//                        {
//                            // overwrite any existing data:
//                            
//                            raf.seek (FILE_HEADER_LENGTH);
//                            writeEntry (raf, FILE_HEADER_LENGTH, data, type);
//                        }
//                        else
                        {
                            // check data format version info:
                            final long dataVersion = raf.readLong ();
                            
                            if (dataVersion != IAppConstants.DATA_FORMAT_VERSION)
                            {
                                // read app version info for the error message:
                                
                                int major = 0, minor = 0, build = 0;
                                boolean gotAppVersion = false;
                                try
                                {
                                    major = raf.readInt ();
                                    minor = raf.readInt ();
                                    build = raf.readInt ();
                                    
                                    gotAppVersion = true;
                                }
                                catch (Throwable ignore) {}
                                
                                // TODO: error code here?
                                if (gotAppVersion)
                                {
                                    throw new IOException ("cannot merge new data into [" + file.getAbsolutePath () + "]: created by another " + IAppConstants.APP_NAME + " version [" + makeAppVersion (major, minor, build) + "]");
                                }
                                else
                                {
                                    throw new IOException ("cannot merge new data into [" + file.getAbsolutePath () + "]: created by another " + IAppConstants.APP_NAME + " version"); 
                                }
                            }
                            else
                            {
                                // [assertion: file header is valid and data format version is consistent]
                                
                                raf.seek (FILE_HEADER_LENGTH);
                                
                                if (length == FILE_HEADER_LENGTH)
                                {
                                    // no previous data entries: append 'data'
                                    
                                    writeEntry (log, raf, FILE_HEADER_LENGTH, data, type);
                                }
                                else
                                {
                                    // [assertion: file length > FILE_HEADER_LENGTH]
                                    
                                    // write 'data' starting with the first corrupt entry or the end of the file:
                                    
                                    long position = FILE_HEADER_LENGTH;
                                    long entryLength;
                                    
                                    while (true)
                                    {
                                        if (trace2) log.trace2 (method, "[" + file + "]: position " + raf.getFilePointer ());
                                        if (position >= length) break;
                                        
                                        entryLength = raf.readLong ();
                                        
                                        if ((entryLength <= 0) || (position + entryLength + ENTRY_HEADER_LENGTH > length))
                                            break;
                                        else
                                        {
                                            if (trace2) log.trace2 (method, "[" + file + "]: found valid entry of size " + entryLength);
                                            
                                            position += entryLength + ENTRY_HEADER_LENGTH; 
                                            raf.seek (position);
                                        }
                                    }
                                    
                                    if (trace2) log.trace2 (method, "[" + file + "]: adding entry at position " + position);
                                    writeEntry (log, raf, position, data, type);
                                }
                            }
                        }
                    }
                }
            }
            else
            {
                // 'file' does not exist:
                
                if (trace1) log.trace1 (method, "[" + file + "]: creating a new file");
                
                final File parent = file.getParentFile ();
                if (parent != null) parent.mkdirs ();
                
                raf = new RandomAccessFile (file, "rw");
                
                overwrite = true;
            }
            
            
            if (overwrite)
            {
                // persist starting from 0 offset:
                
                if ($assert.ENABLED) $assert.ASSERT (raf != null, "raf = null");
                
                if (truncate) raf.seek (0);
                writeFileHeader (raf);
                if ($assert.ENABLED) $assert.ASSERT (raf.getFilePointer () == FILE_HEADER_LENGTH, "invalid header length: " + raf.getFilePointer ());
                
                writeEntry (log, raf, FILE_HEADER_LENGTH, data, type);
            }
        }
        finally
        {
            if (raf != null) try { raf.close (); } catch (Throwable ignore) {}
            raf = null;
        }
        
        if (trace1)
        {
            end = System.currentTimeMillis ();
            
            log.trace1 (method, "[" + file + "]: file processed in " + (end - start) + " ms"); 
        }
    }
    
    private static void writeFileHeader (final DataOutput out)
        throws IOException
    {
        out.writeInt (MAGIC);
        
        out.writeLong (IAppConstants.DATA_FORMAT_VERSION);
        
        out.writeInt (IAppConstants.APP_MAJOR_VERSION);
        out.writeInt (IAppConstants.APP_MINOR_VERSION);
        out.writeInt (IAppConstants.APP_BUILD_ID);
    }
    
    private static void writeEntryHeader (final DataOutput out, final byte type)
        throws IOException
    {
        out.writeLong (UNKNOWN); // length placeholder
        out.writeByte (type);
    }
    
    private static void writeEntry (final Logger log, final RandomAccessFile raf, final long marker, final IMergeable data, final byte type)
        throws IOException
    {
        // [unfinished] entry header:
        writeEntryHeader (raf, type);
        
        // serialize 'data' starting with the current raf position:
        RandomAccessFileOutputStream rafout = new RandomAccessFileOutputStream (raf, IO_BUF_SIZE); // note: no new file descriptors created here
        {
//            ObjectOutputStream oout = new ObjectOutputStream (rafout);
//            
//            oout.writeObject (data);
//            oout.flush ();
//            oout = null;
            
            DataOutputStream dout = new DataOutputStream (rafout);
            switch (type)
            {
                case TYPE_METADATA: MetaData.writeExternal ((MetaData) data, dout);
                    break;
                    
                default /* TYPE_COVERAGEDATA */: CoverageData.writeExternal ((CoverageData) data, dout);
                    break;
                    
            } // end of switch
            dout.flush ();
            dout = null;
            
            // truncate:
            raf.setLength (raf.getFilePointer ());
        }

        // transact this entry [finish the header]:
        raf.seek (marker);
        raf.writeLong (rafout.getCount ());
        if (DO_FSYNC) raf.getFD ().sync ();
        
        if (log.atTRACE2 ()) log.trace2 ("writeEntry", "entry [" + data.getClass ().getName () + "] length: " + rafout.getCount ());
    }
    
    private static IMergeable readEntry (final RandomAccessFile raf, final byte type, final long entryLength)
        throws IOException
    {
        final Object data;
        
        RandomAccessFileInputStream rafin = new RandomAccessFileInputStream (raf, IO_BUF_SIZE); // note: no new file descriptors created here
        {
//           ObjectInputStream oin = new ObjectInputStream (rafin);
//            
//            try
//            {
//                data = oin.readObject ();
//            }
//            catch (ClassNotFoundException cnfe)
//            {
//                // TODO: EMMA exception here
//                throw new IOException ("could not read data entry: " + cnfe.toString ());
//            }

            DataInputStream din = new DataInputStream (rafin);
            switch (type)
            {
                case TYPE_METADATA: data = MetaData.readExternal (din);
                    break;
                    
                default /* TYPE_COVERAGEDATA */: data = CoverageData.readExternal (din);
                    break;
                    
            } // end of switch
        }
        
        if ($assert.ENABLED) $assert.ASSERT (rafin.getCount () == entryLength, "entry length mismatch: " + rafin.getCount () + " != " + entryLength);
        
        return (IMergeable) data;
    }
    
    
    /*
     * This is cloned from EMMAProperties by design, to eliminate a CONSTANT_Class_info
     * dependency between this and EMMAProperties classes.
     */
    private static String makeAppVersion (final int major, final int minor, final int build)
    {
        final StringBuffer buf = new StringBuffer ();
        
        buf.append (major);
        buf.append ('.');
        buf.append (minor);
        buf.append ('.');
        buf.append (build);
        
        return buf.toString ();
    }
    

    private static final int NULL_ARRAY_LENGTH = -1;
    
    private static final int MAGIC = 0x454D4D41; // "EMMA"
    private static final long UNKNOWN = 0L;
    private static final int FILE_HEADER_LENGTH = 4 + 8 + 3 * 4; // IMPORTANT: update on writeFileHeader() changes
    private static final int ENTRY_HEADER_LENGTH = 8 + 1; // IMPORTANT: update on writeEntryHeader() changes
    private static final boolean DO_FSYNC = true;
    private static final int IO_BUF_SIZE = 32 * 1024;
    
} // end of class
// ----------------------------------------------------------------------------