org.apache.derby.impl.store.raw.log
Class FileLogger

java.lang.Object
  extended byorg.apache.derby.impl.store.raw.log.FileLogger
All Implemented Interfaces:
Logger

public class FileLogger
extends java.lang.Object
implements Logger

Write log records to a log file as a stream (ie. log records added to the end of the file, no concept of pages).

The format of a log record that is not a compensation operation is

See Also:
LogRecordno formatId, format is implied by the log file format and the log record content.undo a previous log recordLog Record that contains the compenstation operation (see org.apache.derby.impl.store.raw.log.LogRecord) undoInstant(long) the log instant of the operation that is to be rolled back The undo instant is logically part of the LogRecord but is written by the logger because it is used and controlled by the rollback code but not by the log operation. There is no optional data in a compensation operation, all data necessary for the rollback must be stored in the operation being undone.
Format IDno formatId, format is implied by the log file format and the log record content.
Purposethe log record and optional data
Upgrade
Disk LayoutLog Record (see org.apache.derby.impl.store.raw.log.LogRecord) length(int) length of optional data optionalData(byte[length]) optional data written by the log record

Field Summary
protected  byte[] encryptionBuffer
           
private  LogToFile logFactory
           
private  FormatIdOutputStream logicalOut
           
private  ArrayInputStream logIn
           
private  DynamicByteArrayOutputStream logOutputBuffer
           
private  LogRecord logRecord
           
 
Constructor Summary
FileLogger(LogToFile logFactory)
          Make a new Logger with its own log record buffers MT - not needed for constructor
 
Method Summary
 void close()
          Close the logger.
 void flush(LogInstant where)
          Flush the log up to the given log instant.
 void flushAll()
          Flush all outstanding log to disk.
 LogInstant logAndDo(RawTransaction xact, Loggable operation)
          Writes out a log record to the log stream, and call its doMe method to apply the change to the rawStore.
 LogInstant logAndUndo(RawTransaction xact, Compensation compensation, LogInstant undoInstant, LimitObjectInput in)
          Writes out a compensation log record to the log stream, and call its doMe method to undo the change of a previous log operation.
protected  Loggable readLogRecord(StreamLogScan scan, int size)
          Read the next log record from the scan.
protected  long redo(RawTransaction recoveryTransaction, TransactionFactory transFactory, StreamLogScan redoScan, long redoLWM, long ttabInstant)
          Recovery Redo loop.
 void reprepare(RawTransaction t, TransactionId prepareId, LogInstant prepareStopAt, LogInstant prepareStartAt)
          During recovery re-prepare a transaction.
 void undo(RawTransaction t, TransactionId undoId, LogInstant undoStopAt, LogInstant undoStartAt)
          Undo a part of or the entire transaction.
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Field Detail

logRecord

private LogRecord logRecord

encryptionBuffer

protected byte[] encryptionBuffer

logOutputBuffer

private DynamicByteArrayOutputStream logOutputBuffer

logicalOut

private FormatIdOutputStream logicalOut

logIn

private ArrayInputStream logIn

logFactory

private LogToFile logFactory
Constructor Detail

FileLogger

public FileLogger(LogToFile logFactory)
Make a new Logger with its own log record buffers MT - not needed for constructor

Method Detail

close

public void close()
           throws java.io.IOException
Close the logger. MT - caller provide synchronization (RESOLVE: not called by anyone ??)

Throws:
java.io.IOException

logAndDo

public LogInstant logAndDo(RawTransaction xact,
                           Loggable operation)
                    throws StandardException
Writes out a log record to the log stream, and call its doMe method to apply the change to the rawStore.
Any optional data the doMe method need is first written to the log stream using operation.writeOptionalData, then whatever is written to the log stream is passed back to the operation for the doMe method.

MT - there could be multiple threads running in the same raw transactions and they can be calling the same logger to log different log operations. This whole method is synchronized to make sure log records are logged one at a time.

Specified by:
logAndDo in interface Logger
Parameters:
xact - the transaction logging the change
operation - the log operation
Returns:
the instant in the log that can be used to identify the log record
Throws:
StandardException - Cloudscape Standard error policy

logAndUndo

public LogInstant logAndUndo(RawTransaction xact,
                             Compensation compensation,
                             LogInstant undoInstant,
                             LimitObjectInput in)
                      throws StandardException
Writes out a compensation log record to the log stream, and call its doMe method to undo the change of a previous log operation.

MT - Not needed. A transaction must be single threaded thru undo, each RawTransaction has its own logger, therefore no need to synchronize. The RawTransaction must handle synchronizing with multiple threads during rollback.

Specified by:
logAndUndo in interface Logger
Parameters:
xact - the transaction logging the change
compensation - the compensation log operation
undoInstant - the log instant of the operation that is to be rolled back
in - optional data input for the compenastion doMe method
Returns:
the instant in the log that can be used to identify the log record
Throws:
StandardException - Cloudscape Standard error policy

flush

public void flush(LogInstant where)
           throws StandardException
Flush the log up to the given log instant.

MT - not needed, wrapper method

Specified by:
flush in interface Logger
Parameters:
where - flush log up to here
Throws:
StandardException - cannot sync log file

flushAll

public void flushAll()
              throws StandardException
Flush all outstanding log to disk.

MT - not needed, wrapper method

Specified by:
flushAll in interface Logger
Throws:
StandardException - cannot sync log file

reprepare

public void reprepare(RawTransaction t,
                      TransactionId prepareId,
                      LogInstant prepareStopAt,
                      LogInstant prepareStartAt)
               throws StandardException
During recovery re-prepare a transaction.

After redo() and undo(), this routine is called on all outstanding in-doubt (prepared) transactions. This routine re-acquires all logical write locks for operations in the xact, and then modifies the transaction table entry to make the transaction look as if it had just been prepared following startup after recovery.

Specified by:
reprepare in interface Logger
Parameters:
t - is the transaction performing the re-prepare
prepareId - is the transaction ID to be re-prepared
prepareStopAt - is where the log instant (inclusive) where the re-prepare should stop.
prepareStartAt - is the log instant (inclusive) where re-prepare should begin, this is normally the log instant of the last log record of the transaction that is to be re-prepare. If null, then re-prepare starts from the end of the log.
Throws:
StandardException - Standard exception policy.

undo

public void undo(RawTransaction t,
                 TransactionId undoId,
                 LogInstant undoStopAt,
                 LogInstant undoStartAt)
          throws StandardException
Undo a part of or the entire transaction. Begin rolling back the log record at undoStartAt and stopping at (inclusive) the log record at undoStopAt.

MT - Not needed. A transaction must be single threaded thru undo, each RawTransaction has its own logger, therefore no need to synchronize. The RawTransaction must handle synchronizing with multiple threads during rollback.

Specified by:
undo in interface Logger
Parameters:
t - the transaction that needs to be rolled back
undoId - the transaction ID
undoStopAt - the last log record that should be rolled back
undoStartAt - the first log record that should be rolled back
Throws:
StandardException - Standard Cloudscape error policy
See Also:
Logger.undo(org.apache.derby.iapi.store.raw.xact.RawTransaction, org.apache.derby.iapi.store.raw.xact.TransactionId, org.apache.derby.iapi.store.raw.log.LogInstant, org.apache.derby.iapi.store.raw.log.LogInstant)

redo

protected long redo(RawTransaction recoveryTransaction,
                    TransactionFactory transFactory,
                    StreamLogScan redoScan,
                    long redoLWM,
                    long ttabInstant)
             throws java.io.IOException,
                    StandardException,
                    java.lang.ClassNotFoundException
Recovery Redo loop.

The log stream is scanned from the beginning (or from the undo low water mark of a checkpoint) forward until the end. The purpose of the redo pass is to repeat history, i.e, to repeat exactly the same set of changes the rawStore went thru right before it stopped. With each log record that is encountered in the redo pass:

  1. if it isFirst(), then the transaction factory is called upon to create a new transaction object.
  2. if it needsRedo(), its doMe() is called (if it is a compensation operation, then the undoable operation needs to be created first before the doMe is called).
  3. if it isComplete(), then the transaction object is closed.

MT - caller provides synchronization

Parameters:
transFactory - - the transaction factory
redoLWM - - if checkpoint seen, starting from this point on, apply redo if necessary
Returns:
the log instant of the next log record (or the instant just after the last log record). This is used to determine where the log truly ends
Throws:
StandardException - Standard Cloudscape error policy
java.io.IOException - error reading log file
java.lang.ClassNotFoundException - log file corrupted
See Also:
LogToFile.recover(org.apache.derby.iapi.store.raw.RawStoreFactory, org.apache.derby.iapi.store.raw.data.DataFactory, org.apache.derby.iapi.store.raw.xact.TransactionFactory)

readLogRecord

protected Loggable readLogRecord(StreamLogScan scan,
                                 int size)
                          throws java.io.IOException,
                                 StandardException,
                                 java.lang.ClassNotFoundException
Read the next log record from the scan.

MT - caller must provide synchronization (right now, it is only called in recovery to find the checkpoint log record. When this method is called by a more general audience, MT must be revisited).

Parameters:
scan - an opened log scan
size - estimated size of the log record
Returns:
the log operation that is the next in the scan, or null if no more log operation in the log scan
Throws:
java.io.IOException - Error reading the log file
StandardException - Standard Cloudscape error policy
java.lang.ClassNotFoundException - log corrupted


Apache Derby V10.0 Engine Documentation - Copyright © 1997,2004 The Apache Software Foundation or its licensors, as applicable.