| java.lang.Object
 org.apache.derby.impl.store.raw.log.FileLogger
| FileLogger | | public class FileLogger implements Logger(Code) | | 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 |
| Method Summary | |
| public void | close()
Close the logger. | | public void | flush(LogInstant where)
Flush the log up to the given log instant. | | public void | flushAll()
Flush all outstanding log to disk. | | public synchronized 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.
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. | | public 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.
MT - Not needed. | | protected Loggable | readLogRecord(StreamLogScan scan, int size)
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. | | protected long | redo(RawTransaction recoveryTransaction, TransactionFactory transFactory, StreamLogScan redoScan, long redoLWM, long ttabInstant)
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. | | public void | reprepare(RawTransaction t, TransactionId prepareId, LogInstant prepareStopAt, LogInstant prepareStartAt)
During recovery re-prepare a transaction.
After redo() and undo(), this routine is called on all outstanding
in-doubt (prepared) transactions. | | public void | undo(RawTransaction t, TransactionId undoId, LogInstant undoStopAt, LogInstant undoStartAt)
Undo a part of or the entire transaction. |
| encryptionBuffer | | protected byte[] encryptionBuffer(Code) | | |
| FileLogger | | public FileLogger(LogToFile logFactory)(Code) | | Make a new Logger with its own log record buffers
MT - not needed for constructor
|
| close | | public void close() throws IOException(Code) | | Close the logger.
MT - caller provide synchronization
(RESOLVE: not called by anyone ??)
|
| logAndDo | | public synchronized LogInstant logAndDo(RawTransaction xact, Loggable operation) throws StandardException(Code) | | 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.
Parameters:
xact - the transaction logging the change
Parameters:
operation - the log operation the instant in the log that can be used to identify the logrecord
exception:
StandardException - Cloudscape Standard error policy |
| logAndUndo | | public LogInstant logAndUndo(RawTransaction xact, Compensation compensation, LogInstant undoInstant, LimitObjectInput in) throws StandardException(Code) | | 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.
Parameters:
xact - the transaction logging the change
Parameters:
compensation - the compensation log operation
Parameters:
undoInstant - the log instant of the operation that is to berolled back
Parameters:
in - optional data input for the compenastion doMe method the instant in the log that can be used to identify the logrecord
exception:
StandardException - Cloudscape Standard error policy |
| readLogRecord | | protected Loggable readLogRecord(StreamLogScan scan, int size) throws IOException, StandardException, ClassNotFoundException(Code) | | 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
Parameters:
size - estimated size of the log record the log operation that is the next in the scan, or null if nomore log operation in the log scan
exception:
IOException - Error reading the log file
exception:
StandardException - Standard Cloudscape error policy
exception:
ClassNotFoundException - log corrupted |
| redo | | protected long redo(RawTransaction recoveryTransaction, TransactionFactory transFactory, StreamLogScan redoScan, long redoLWM, long ttabInstant) throws IOException, StandardException, ClassNotFoundException(Code) | | 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:
- if it isFirst(), then the transaction factory is called upon to
create a new transaction object.
- 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).
- if it isComplete(), then the transaction object is closed.
MT - caller provides synchronization
Parameters:
transFactory - - the transaction factory
Parameters:
redoLWM - - if checkpoint seen, starting from this pointon, apply redo if necessary the log instant of the next log record (or the instant justafter the last log record). This is used to determine where the logtruly ends
exception:
StandardException - Standard Cloudscape error policy
exception:
IOException - error reading log file
exception:
ClassNotFoundException - log file corrupted
See Also: LogToFile.recover |
| reprepare | | public void reprepare(RawTransaction t, TransactionId prepareId, LogInstant prepareStopAt, LogInstant prepareStartAt) throws StandardException(Code) | | 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.
Parameters:
t - is the transaction performing the re-prepare
Parameters:
prepareId - is the transaction ID to be re-prepared
Parameters:
prepareStopAt - is where the log instant (inclusive) where the re-prepare should stop.
Parameters:
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.
exception:
StandardException - Standard exception policy. |
| undo | | public void undo(RawTransaction t, TransactionId undoId, LogInstant undoStopAt, LogInstant undoStartAt) throws StandardException(Code) | | 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.
Parameters:
t - the transaction that needs to be rolled back
Parameters:
undoId - the transaction ID
Parameters:
undoStopAt - the last log record that should be rolled back
Parameters:
undoStartAt - the first log record that should be rolled back
exception:
StandardException - Standard Cloudscape error policy
See Also: Logger.undo |
|
|