Java 类java.io.SyncFailedException 实例源码

private void createFolder(final File folder2Create, final String name) throws IOException {
    boolean isSupported = new FileInfo(folder2Create).isSupportedFile();
    ProvidedExtensions extensions =  getProvidedExtensions();

    if (!isSupported) { 
        extensions.createFailure(this, folder2Create.getName(), true);
        FSException.io("EXC_CannotCreateFolder", folder2Create.getName(), getPath());// NOI18N   
    } else if (FileChangedManager.getInstance().exists(folder2Create)) {
        extensions.createFailure(this, folder2Create.getName(), true);            
        SyncFailedException sfe = new SyncFailedException(folder2Create.getAbsolutePath()); // NOI18N               
        String msg = NbBundle.getMessage(FileBasedFileSystem.class, "EXC_CannotCreateFolder", folder2Create.getName(), getPath()); // NOI18N
        Exceptions.attachLocalizedMessage(sfe, msg);
        throw sfe;
    } else if (!folder2Create.mkdirs()) {
        extensions.createFailure(this, folder2Create.getName(), true);
        FSException.io("EXC_CannotCreateFolder", folder2Create.getName(), getPath());// NOI18N               
    }
    LogRecord r = new LogRecord(Level.FINEST, "FolderCreated: "+ folder2Create.getAbsolutePath());
    r.setParameters(new Object[] {folder2Create});
    Logger.getLogger("org.netbeans.modules.masterfs.filebasedfs.fileobjects.FolderObj").log(r);
}

private void createData(final File file2Create) throws IOException {
    boolean isSupported = new FileInfo(file2Create).isSupportedFile();                        
    ProvidedExtensions extensions =  getProvidedExtensions();

    if (!isSupported) {             
        extensions.createFailure(this, file2Create.getName(), false);
        FSException.io("EXC_CannotCreateData", file2Create.getName(), getPath());// NOI18N
    } else if (FileChangedManager.getInstance().exists(file2Create)) {
        extensions.createFailure(this, file2Create.getName(), false);
        SyncFailedException sfe = new SyncFailedException(file2Create.getAbsolutePath()); // NOI18N               
        String msg = NbBundle.getMessage(FileBasedFileSystem.class, "EXC_CannotCreateData", file2Create.getName(), getPath()); // NOI18N
        Exceptions.attachLocalizedMessage(sfe, msg);
        throw sfe;
    } else if (!file2Create.createNewFile()) {
        extensions.createFailure(this, file2Create.getName(), false);            
        FSException.io("EXC_CannotCreateData", file2Create.getName(), getPath());// NOI18N
    }        
    LogRecord r = new LogRecord(Level.FINEST, "DataCreated: "+ file2Create.getAbsolutePath());
    r.setParameters(new Object[] {file2Create});
    Logger.getLogger("org.netbeans.modules.masterfs.filebasedfs.fileobjects.FolderObj").log(r);        
}

@ObfuscatedName("k")
@ObfuscatedSignature(
   signature = "(ZI)V",
   garbageValue = "-1673795207"
)
@Export("closeSync")
public final void closeSync(boolean var1) throws IOException {
   if(this.file != null) {
      if(var1) {
         try {
            this.file.getFD().sync();
         } catch (SyncFailedException var3) {
            ;
         }
      }

      this.file.close();
      this.file = null;
   }

}

public void commitTransactionStage1() throws SyncFailedException, IOException
{
    //System.out.println("commitTransactionStage1: "+this);
    //stage 1
    //flush and sync everything
    insertRecordOut.flush();
    insertRecordFileOut.getFD().sync();
    insertRecordOut.close();

    rollForwardOut.flush();
    rollForwardFileOut.getFD().sync();
    rollForwardOut.close();

    //mark the roll back file as a real roll back file
    getRollForwardFile(true).renameTo(getRollForwardFile(false));
    //System.out.println("commitTransactionStage1 end: "+this);
}

/**
 * release the application lock
 * @param request the HTTP request
 * @param requestor the HTTP requestor
 * @return
 * @throws SyncFailedException
 * @throws SecurityException
 */
public synchronized static boolean releaseApplicationLock(HttpServletRequest request, Serializable requestor) 
throws SyncFailedException, SecurityException
{       

    if(request == null)
        return false;

    ServletContext application = Web.getApplication(request);

    //get previous
    Serializable previous = (Serializable)application.getAttribute(lockKey); 

    if(previous != null && previous.toString().length() > 0)
    {
        Debugger.printWarn(WebLock.class,"Lock was owner by "+previous+" but release by "+requestor);
    }

    application.setAttribute(lockKey, null);

    return true;
}

/**
 * @tests java.io.SyncFailedException#SyncFailedException(java.lang.String)
 */
@TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "SyncFailedException",
        args = {java.lang.String.class}
    )
public void test_ConstructorLjava_lang_String() {
    try {
        if (true) // To avoid unreachable code compilation error.
            throw new SyncFailedException("Something went wrong.");
        fail("Test 1: SyncFailedException expected.");
    } catch (SyncFailedException e) {
        assertEquals("Test 2: Incorrect message;",
                "Something went wrong.", e.getMessage());
    }
}

/**
 * @tests java.io.SyncFailedException#SyncFailedException(java.lang.String)
 */
public void test_ConstructorLjava_lang_String() throws Exception {
    // Test for method java.io.SyncFailedException(java.lang.String)
               File f = null;
               try {
                   f = new File(System.getProperty("user.dir"), "synfail.tst");
                   FileOutputStream fos = new FileOutputStream(f.getPath());
                   FileDescriptor fd = fos.getFD();
                   fos.close();
                   fd.sync();
    } catch (SyncFailedException e) {
        f.delete();
        return;
    } 

    fail("Failed to generate expected Exception");
}

/**
 * Close the appropriate stream
 *
 * @throws IOException
 */
public void close() throws IOException {
    if (this.isWriting) {
        // To the degree possible, make sure the bytes get forced to the file system,
        // or else cause an exception to be thrown.
        if (this.outputStream instanceof FileOutputStream) {
            this.outputStream.flush();
            FileOutputStream fos = (FileOutputStream)this.outputStream;
            try {
                fos.getFD().sync();
            } catch (SyncFailedException e) {
                // Since the sync is belt-and-suspenders anyway, don't throw an exception if it
                // fails,
                // because on some OSs it will fail for some types of output. E.g. writing to
                // /dev/null
                // on some Unixes.
            }
        }
        this.outputStream.close();
    } else {
        this.inputStream.close();
    }
}

/**
 * @tests java.io.SyncFailedException#SyncFailedException(java.lang.String)
 */
public void test_ConstructorLjava_lang_String() throws Exception {
    // Test for method java.io.SyncFailedException(java.lang.String)
               File f = null;
               try {
                   f = new File(System.getProperty("user.dir"), "synfail.tst");
                   FileOutputStream fos = new FileOutputStream(f.getPath());
                   FileDescriptor fd = fos.getFD();
                   fos.close();
                   fd.sync();
    } catch (SyncFailedException e) {
        f.delete();
        return;
    } 

    fail("Failed to generate expected Exception");
}

/**
 * Check if the exception is something that indicates that we cannot
 * contact/communicate with the server.
 *
 * @param e
 * @return true when exception indicates that the client wasn't able to make contact with server
 */
private boolean isConnectionException(Throwable e) {
  if (e == null)
    return false;
  // This list covers most connectivity exceptions but not all.
  // For example, in SocketOutputStream a plain IOException is thrown
  // at times when the channel is closed.
  return (e instanceof SocketTimeoutException
      || e instanceof ConnectException || e instanceof ClosedChannelException
      || e instanceof SyncFailedException || e instanceof EOFException
      || e instanceof TimeoutException
      || e instanceof ConnectionClosingException || e instanceof FailedServerException);
}

@Override
public List<RemoteDataInfo> getRemoteEntries() throws SyncFailedException {
    StringBuilder sb = new StringBuilder();
    sb.append(getBaseFilePath());
    sb.append(ENTRIES);

    List<RemoteDataInfo> dataInfoObjects = new ArrayList<>();

    try {
        List<DropboxAPI.Entry> dropboxEntries = getFileInfo(sb.toString()).contents;

        for (DropboxAPI.Entry entry : dropboxEntries) {
            if ( !entry.isDir ) {
                RemoteDataInfo infoObject = new RemoteDataInfo();
                infoObject.isDirectory = entry.isDir;
                infoObject.isDeleted = entry.isDeleted;
                infoObject.name = entry.fileName().toUpperCase();
                infoObject.modifiedDate = RESTUtility.parseDate(entry.modified).getTime();
                infoObject.revision = entry.rev;
                dataInfoObjects.add(infoObject);
            }
        }

    } catch (Exception e) {
        if (!BuildConfig.DEBUG) Crashlytics.logException(e);
        e.printStackTrace();
        throw new SyncFailedException(e.getMessage());
    }

    return dataInfoObjects;
}

@Override
public List<RemoteDataInfo> getRemotePhotos() throws SyncFailedException {
    StringBuilder sb = new StringBuilder();
    sb.append(getBaseFilePath());
    sb.append(PHOTOS);

    List<RemoteDataInfo> dataInfoObjects = new ArrayList<>();

    try {
        List<DropboxAPI.Entry> dropboxEntries = getFileInfo(sb.toString()).contents;

        for (DropboxAPI.Entry file : dropboxEntries) {
            if ( !file.isDir ) {
                RemoteDataInfo infoObject = new RemoteDataInfo();
                infoObject.isDirectory = file.isDir;
                infoObject.isDeleted = file.isDeleted;
                infoObject.name = file.fileName().toLowerCase();
                infoObject.modifiedDate = RESTUtility.parseDate(file.modified).getTime();
                infoObject.revision = file.rev;
                dataInfoObjects.add(infoObject);
            }
        }

    } catch (Exception e) {
        if (!BuildConfig.DEBUG) Crashlytics.logException(e);
        e.printStackTrace();
        throw new SyncFailedException(e.getMessage());
    }

    return dataInfoObjects;
}

@Override
public  List<RemoteDataInfo> getRemoteEntries() throws SyncFailedException {
    LogUtil.log(getClass().getSimpleName(), "Files in Narrate Drive AppFolder:");
    List<RemoteDataInfo> dataObjects = new ArrayList<>();

    try {
        List<File> contents = getContents();
        if (contents != null) {

            Iterator<File> iter = contents.iterator();
            File f;
            while (iter.hasNext()) {
                f = iter.next();
                LogUtil.log(getClass().getSimpleName(), f.getTitle());
                if (!f.getTitle().equals("photos")) {
                    RemoteDataInfo info = new RemoteDataInfo();
                    info.name = f.getTitle();
                    info.isDirectory = f.getMimeType().equals(FOLDER_MIME);
                    info.isDeleted = f.getLabels().getTrashed();
                    info.modifiedDate = f.getModifiedDate().getValue();
                    info.revision = String.valueOf(f.getVersion());
                    dataObjects.add(info);
                }
            }

            return dataObjects;
        }
    } catch (Exception e) {
        if (!BuildConfig.DEBUG) Crashlytics.logException(e);
        e.printStackTrace();
        throw new SyncFailedException(e.getMessage());
    }

    return null;
}

@Override
public List<RemoteDataInfo> getRemotePhotos() throws SyncFailedException {
    LogUtil.log(DriveSyncService.class.getSimpleName(), "getRemotePhotos()");

    List<RemoteDataInfo> dataObjects = new ArrayList<>();
    try {
        List<File> result = getPhotosContents();

        LogUtil.log(getClass().getSimpleName(), "Files in Narrate Drive Photos Folder:");

        if (result.size() > 0) {
            for (File f : result) {
                LogUtil.log(getClass().getSimpleName(), f.getTitle());
                RemoteDataInfo info = new RemoteDataInfo();
                info.name = f.getTitle();
                info.isDirectory = f.getMimeType().equals(FOLDER_MIME);
                info.isDeleted = f.getLabels().getTrashed();
                info.modifiedDate = f.getModifiedDate().getValue();
                info.revision = String.valueOf(f.getVersion());
                dataObjects.add(info);
            }
        }
    } catch (Exception e) {
        if (!BuildConfig.DEBUG) Crashlytics.logException(e);
        e.printStackTrace();
        throw new SyncFailedException(e.getMessage());
    }

    return dataObjects;
}

/**
 * Guarantee all writes up to the last call to flushLogAccessFile on disk.
 * <p>
 * A call for clients of LogAccessFile to insure that all data written
 * up to the last call to flushLogAccessFile() are written to disk.
 * This call will not return until those writes have hit disk.
 * <p>
 * Note that this routine may block waiting for I/O to complete so 
 * callers should limit the number of resource held locked while this
 * operation is called.  It is expected that the caller
 * Note that this routine only "writes" the data to the file, this does not
 * mean that the data has been synced to disk.  The only way to insure that
 * is to first call switchLogBuffer() and then follow by a call of sync().
 *
 **/
public void syncLogAccessFile() 
    throws IOException, StandardException
{
    for( int i=0; ; )
    {
        // 3311: JVM sync call sometimes fails under high load against NFS 
        // mounted disk.  We re-try to do this 20 times.
        try
        {
            synchronized( this)
            {
                log.sync( false);
            }

            // the sync succeed, so return
            break;
        }
        catch( SyncFailedException sfe )
        {
            i++;
            try
            {
                // wait for .2 of a second, hopefully I/O is done by now
                // we wait a max of 4 seconds before we give up
                Thread.sleep( 200 ); 
            }
            catch( InterruptedException ie )
            {   //does not matter weather I get interrupted or not
            }

            if( i > 20 )
                throw StandardException.newException(
                    SQLState.LOG_FULL, sfe);
        }
    }
}

/**
 * Force any changes out to the persistent store.
 *
 * @param metaData If true then this method is required to force changes to both the file's
 *          content and metadata to be written to storage; otherwise, it need only force content changes
 *          to be written.
 *
 * @exception IOException If an IO error occurs.
 */
public void sync( boolean metaData) throws IOException
{
    try
    {
        getChannel().force( metaData);
    }
    catch( ClosedChannelException cce) { throw cce;}
    catch( IOException ioe)
    {
        SyncFailedException sne = new SyncFailedException( ioe.getMessage());
        sne.initCause( ioe);
        throw sne;
    }
}

public static void convertTableSaveFile(char delimiter,
        Integer[] partitions, final File outfile, final File infile)
        throws FileNotFoundException, IOException, InterruptedException,
        SyncFailedException {
    final FileOutputStream fos = new FileOutputStream(outfile, true);
    try {
        final CSVTableSaveFile converter = new CSVTableSaveFile(infile,
                delimiter, partitions);
        try {
            while (true) {
                final byte bytes[] = converter.read();
                if (bytes.length == 0) {
                    break;
                }
                fos.write(bytes);
            }
        } finally {
            try {
                converter.close();
            } finally {
                fos.getFD().sync();
            }
        }
    } finally {
        fos.close();
    }
}

/**
 * Guarantee all writes up to the last call to flushLogAccessFile on disk.
 * <p>
 * A call for clients of LogAccessFile to insure that all data written
 * up to the last call to flushLogAccessFile() are written to disk.
 * This call will not return until those writes have hit disk.
 * <p>
 * Note that this routine may block waiting for I/O to complete so 
 * callers should limit the number of resource held locked while this
 * operation is called.  It is expected that the caller
 * Note that this routine only "writes" the data to the file, this does not
 * mean that the data has been synced to disk.  The only way to insure that
 * is to first call switchLogBuffer() and then follow by a call of sync().
 *
 **/
public void syncLogAccessFile() 
    throws IOException, StandardException
{
    for( int i=0; ; )
    {
        // 3311: JVM sync call sometimes fails under high load against NFS 
        // mounted disk.  We re-try to do this 20 times.
        try
        {
            synchronized( this)
            {
                log.sync( false);
            }

            // the sync succeed, so return
            break;
        }
        catch( SyncFailedException sfe )
        {
            i++;
            try
            {
                // wait for .2 of a second, hopefully I/O is done by now
                // we wait a max of 4 seconds before we give up
                Thread.sleep( 200 ); 
            }
            catch( InterruptedException ie )
            {   //does not matter weather I get interrupted or not
            }

            if( i > 20 )
                throw StandardException.newException(
                    SQLState.LOG_FULL, sfe);
        }
    }
}

/**
 * Force any changes out to the persistent store.
 *
 * @param metaData If true then this method is required to force changes to both the file's
 *          content and metadata to be written to storage; otherwise, it need only force content changes
 *          to be written.
 *
 * @exception IOException If an IO error occurs.
 */
public void sync( boolean metaData) throws IOException
{
    try
    {
        getChannel().force( metaData);
    }
    catch( ClosedChannelException cce) { throw cce;}
    catch( IOException ioe)
    {
        SyncFailedException sne = new SyncFailedException( ioe.getMessage());
        sne.initCause( ioe);
        throw sne;
    }
}

public static TimmyDatabase createTimmyDb() throws SyncFailedException, IOException {
        TimmyDatabase timmyDb = new TimmyDatabase(GTG.getExternalStorageDirectory()+"/"+TIMMY_DB_FILENAME);
        timmyDb
        .addRollBackTimmyTable(
                GTG.getExternalStorageDirectory()+ "/"
                        + APCACHE_TIMMY_TABLE_FILENAME,
                GTG.crypt.crypt
                        .getNumOutputBytesForEncryption(AreaPanel.DATA_LENGTH));
        timmyDb
                .addRollBackTimmyTable(
                        GTG.getExternalStorageDirectory()+ "/"
                                + TIME_TREE_TIMMY_TABLE_FILENAME,
                                GTG.crypt.crypt
                                .getNumOutputBytesForEncryption(TimeTree.DATA_LENGTH));
        timmyDb
        .addTimmyTable(
                GTG.getExternalStorageDirectory()+ "/"
                        + MEDIA_LOC_TIME_TIMMY_TABLE_FILENAME,
                        GTG.crypt.crypt
                        .getNumOutputBytesForEncryption(MediaLocTime.DATA_LENGTH));
//      timmyDb
//      .addTimmyTable(
//              context.getExternalFilesDir(null) + "/"
//                      + MEDIA_LOC_TIME_PLUS_TIMMY_TABLE_FILENAME,
//              crypt.crypt
//                      .getNumOutputBytesForEncryption(MediaLocTime.DATA_LENGTH)
//                      + EncryptedRow.EXTRA_BYTES_FOR_USER_DATA_KEY);
        return timmyDb;
    }

public PropertyTimmyTable(String dbFilename, int nameSize,
        int valueSize, TimmyDatabase d) throws SyncFailedException, IOException {
    super(dbFilename, nameSize+valueSize, d);

    this.nameSize = nameSize;
    this.valueSize = valueSize;

    buf = new byte[super.getRecordSize()];
}

/**
 * Created by TimmmyDatabase
 */
protected TimmyTable(String filename, int recordSize, TimmyDatabase d)
        throws SyncFailedException, IOException {
    ////System.out.println("new: "+this);
    this.filename = filename;

    this.database = d;
    reopenRaf(recordSize);

    //System.out.println("new end: "+this);
}

private void createHeader(int recordSize) throws SyncFailedException,
        IOException {
    rwRaf.setLength(HEADER_SIZE);
    rwRaf.seek(0);
    rwRaf.write(MAGIC);
    rwRaf.write(VERSION);
    rwRaf.writeInt(0); // nextRowId;
    rwRaf.writeInt(recordSize);
    rwRaf.getFD().sync();

    this.recordSize = recordSize;
}

private void createHeader(int recordSize) throws SyncFailedException,
        IOException {
    rwRaf.setLength(HEADER_SIZE);
    rwRaf.seek(0);
    rwRaf.write(MAGIC);
    rwRaf.write(VERSION);
    rwRaf.writeInt(0); // nextRowId;
    rwRaf.writeInt(recordSize);
    rwRaf.getFD().sync();

    this.recordSize = recordSize;
}

/**
 * After this is called, all soft updates must be rerun as hard updates.
 * At that point the memory associated with update may be removed.
 * There may be no more inserts after this is called
 * @throws SyncFailedException
 * @throws IOException
 */
protected void softCommitTransaction() throws SyncFailedException, IOException
{
    //System.out.println("commitTransactionStage1: "+this);
    //stage 1
    //flush and sync rollback file      

    rollBackOut.flush();
    rollBackFileOut.getFD().sync();

    if(softModeSavedRows.size() != 0)
    {
        //record the actualy number of rows in this commit block (at the beginning of it)
        RandomAccessFile rbRaf = new RandomAccessFile(getRollBackFile(), "rws");
        rbRaf.seek(SOFT_COMMIT_NUM_ROWS_INDEX);
        rbRaf.writeInt(softModeSavedRows.size());
        rbRaf.getFD().sync();
        rbRaf.close();
    }

    rollBackOut.close();

    rollBackOut = null; rollBackFileOut = null;

    hardWriteMode = true;

}

/**
 * This or addRollBackTimmyTable must be called for all tables in database before open()
 * @param filename
 * @param recordSize
 * @return
 * @throws SyncFailedException
 * @throws IOException
 */
public TimmyTable addTimmyTable(String filename, int recordSize)
throws SyncFailedException, IOException {
    if(isOpen)
        throw new IllegalStateException("table can't be added after database is open");

    TimmyTable tt = new TimmyTable(filename, recordSize, this);

    tables.add(tt);

    return tt;
}

public RollBackTimmyTable addRollBackTimmyTable(String filename, int recordSize)
throws SyncFailedException, IOException {
    if(isOpen)
        throw new IllegalStateException("table can't be added after database is open");

    RollBackTimmyTable tt = new RollBackTimmyTable(filename, recordSize, this);

    tables.add(tt);

    return tt;
}

/**
 * Check if the exception is something that indicates that we cannot
 * contact/communicate with the server.
 *
 * @param e
 * @return true when exception indicates that the client wasn't able to make contact with server
 */
private boolean isConnectionException(Throwable e) {
  if (e == null)
    return false;
  // This list covers most connectivity exceptions but not all.
  // For example, in SocketOutputStream a plain IOException is thrown
  // at times when the channel is closed.
  return (e instanceof SocketTimeoutException
      || e instanceof ConnectException || e instanceof ClosedChannelException
      || e instanceof SyncFailedException || e instanceof EOFException
      || e instanceof TimeoutException
      || e instanceof ConnectionClosingException || e instanceof FailedServerException);
}

private void persistPlayersTable() throws IOException {
    if (playersTable != null && playerIDs != null) {
        if (debug) {
            plugin.getLogger().info("DEBUG: Saving players to ".concat(playersTable.getAbsolutePath()));
        }
        try (ObjectOutputStream oos = new ObjectOutputStream(
                new FileOutputStream(playersTable.getCanonicalPath(), false))) {
            oos.writeObject(playerIDs);
            oos.close();
        }
    } else {
        throw new SyncFailedException("Unable to persist player database.");
    }
}

public void sync() throws SyncFailedException {
    try {
        SimulationThread.stopTime(0);
        if (st == null)
            return;
        SimulationThread current = SimulationThread.currentSimulationThread();
        long syncDelay = st.getSyncTarget() - current.getTimeline().getTime();
        if (syncDelay > 0)
            if (current.idle(syncDelay, false, false))
                throw new SyncFailedException("thread interrupted");
    } finally {
        SimulationThread.startTime(0);
    }
}

/**
 * Check if the exception is something that indicates that we cannot
 * contact/communicate with the server.
 *
 * @param e exception to check
 * @return true when exception indicates that the client wasn't able to make contact with server
 */
public static boolean isConnectionException(Throwable e) {
  if (e == null) {
    return false;
  }
  // This list covers most connectivity exceptions but not all.
  // For example, in SocketOutputStream a plain IOException is thrown
  // at times when the channel is closed.
  return (e instanceof SocketTimeoutException || e instanceof ConnectException
    || e instanceof ClosedChannelException || e instanceof SyncFailedException
    || e instanceof EOFException || e instanceof TimeoutException
    || e instanceof CallTimeoutException || e instanceof ConnectionClosingException
    || e instanceof FailedServerException);
}

@Override
public void commitTransactionStage1() throws SyncFailedException,
        IOException {
    //noop, softCommit should already be run at this point
}

@Message(id = 18, value = "copied content does not match expected hash for item: %s")
SyncFailedException wrongCopiedContent(ContentItem item);

public void fsync() throws SyncFailedException {
  fileDescriptor.sync();
}

/**
 * Test Method to be used only for testing purposes. Gets the underlying File object for the Oplog
 * . Oplog class uses this File object to obtain the RandomAccessFile object. Before returning the
 * File object , the dat present in the buffers of the RandomAccessFile object is flushed.
 * Otherwise, for windows the actual file length does not match with the File size obtained from
 * the File object
 * 
 * @throws IOException
 * @throws SyncFailedException
 */
File getOplogFile() throws SyncFailedException, IOException {
  synchronized (this.crf) {
    if (!this.crf.RAFClosed) {
      this.crf.raf.getFD().sync();
    }
    return this.crf.f;
  }
}

/**
 * Test Method to be used only for testing purposes. Gets the underlying File
 * object for the Oplog . Oplog class uses this File object to obtain the
 * RandomAccessFile object. Before returning the File object , the dat present
 * in the buffers of the RandomAccessFile object is flushed. Otherwise, for
 * windows the actual file length does not match with the File size obtained
 * from the File object
 * 
 * @throws IOException
 * @throws SyncFailedException
 */
File getOplogFile() throws SyncFailedException, IOException
{
  synchronized (this.crf) {
    if (!this.crf.RAFClosed) {
      this.crf.raf.getFD().sync();
    }
    return this.crf.f;
  }
}

/**
 * Test Method to be used only for testing purposes. Gets the underlying File
 * object for the Oplog . Oplog class uses this File object to obtain the
 * RandomAccessFile object. Before returning the File object , the dat present
 * in the buffers of the RandomAccessFile object is flushed. Otherwise, for
 * windows the actual file length does not match with the File size obtained
 * from the File object
 * 
 * @throws IOException
 * @throws SyncFailedException
 */
File getOplogFile() throws SyncFailedException, IOException
{
  // @todo check callers for drf
  synchronized (this.lock/*crf*/) {
    if (!this.crf.RAFClosed) {
      this.crf.raf.getFD().sync();
    }
    return this.crf.f;
  }
}

/**
 * Test Method to be used only for testing purposes. Gets the underlying File
 * object for the Oplog . Oplog class uses this File object to obtain the
 * RandomAccessFile object. Before returning the File object , the dat present
 * in the buffers of the RandomAccessFile object is flushed. Otherwise, for
 * windows the actual file length does not match with the File size obtained
 * from the File object
 * 
 * @throws IOException
 * @throws SyncFailedException
 */
File getOplogFile() throws SyncFailedException, IOException
{
  synchronized (this.crf) {
    if (!this.crf.RAFClosed) {
      this.crf.raf.getFD().sync();
    }
    return this.crf.f;
  }
}

/**
 * Test Method to be used only for testing purposes. Gets the underlying File
 * object for the Oplog . Oplog class uses this File object to obtain the
 * RandomAccessFile object. Before returning the File object , the dat present
 * in the buffers of the RandomAccessFile object is flushed. Otherwise, for
 * windows the actual file length does not match with the File size obtained
 * from the File object
 * 
 * @throws IOException
 * @throws SyncFailedException
 */
File getOplogFile() throws SyncFailedException, IOException
{
  // @todo check callers for drf
  synchronized (this.lock/*crf*/) {
    if (!this.crf.RAFClosed) {
      this.crf.raf.getFD().sync();
    }
    return this.crf.f;
  }
}

/**
 * Created by TimmmyDatabase
 */
protected RollBackTimmyTable(String filename, int recordSize, TimmyDatabase d)
        throws SyncFailedException, IOException {
    this.filename = filename;

    this.database = d;
    reopenRaf(recordSize);

    tempRecordData = new byte[recordSize];

    //System.out.println("new end: "+this);

}