Package org.apache.derby.impl.store.raw.log

Class FileLogger

java.lang.Object

org.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:

LogRecord

Field Summary

Fields

Modifier and Type	Field	Description
protected byte[]	encryptionBuffer
private LogToFile	logFactory
private FormatIdOutputStream	logicalOut
private ArrayInputStream	logIn
private DynamicByteArrayOutputStream	logOutputBuffer
private LogRecord	logRecord

Constructor Summary

Constructors

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

Method Summary

Modifier and Type	Method	Description
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 - Derby 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 - Derby 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 Derby 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 Derby 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.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 Derby error policy

java.lang.ClassNotFoundException - log corrupted