/* 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
// ----------------------------------------------------------------------------
|
