The format of a log record that is not a compensation operation is
LogRecord
| Modifier and Type | Field and Description |
|---|---|
| protected byte[] | |
| private LogToFile | |
| private FormatIdOutputStream | |
| private ArrayInputStream | |
| private DynamicByteArrayOutputStream | |
| private LogRecord |
| Access | Constructor and Description |
|---|---|
| public | FileLogger(LogToFile logFactory)
Make a new Logger with its own log record buffers MT - not needed for constructor |
| Modifier and Type | Method and Description |
|---|---|
| public void | |
| public void | flush(LogInstant
flush log up to here where)Implements org. Flush the log up to the given log instant. |
| public void | flushAll()
Implements org. Flush all outstanding log to disk. |
| public synchronized LogInstant | Returns: the instant in the log that can be used to identify the log recordthe transaction logging the change xact, Loggable the log operation operation)Implements org. Writes out a log record to the log stream, and call its doMe method to apply the change to the rawStore. |
| public LogInstant | Returns: the instant in the log that can be used to identify the log recordthe transaction logging the change xact, Compensation the compensation log operation compensation, LogInstant the log instant of the operation that is to be
rolled back undoInstant, LimitObjectInput optional data input for the compenastion doMe method in)Implements org. 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 | Returns: the log operation that is the next in the scan, or null if no more log operation in the log scanan opened log scan scan, int estimated size of the log record size)Read the next log record from the scan. |
| protected long | 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- the transaction factory transFactory, StreamLogScan redoScan, long - if checkpoint seen, starting from this point
on, apply redo if necessary redoLWM, long ttabInstant)Recovery Redo loop. |
| public void | reprepare(RawTransaction
is the transaction performing the re-prepare t, TransactionId is the transaction ID to be re-prepared prepareId, LogInstant is where the log instant (inclusive) where the
re-prepare should stop. prepareStopAt, LogInstant 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. prepareStartAt)Implements org. During recovery re-prepare a transaction. |
| public void | undo(RawTransaction
the transaction that needs to be rolled back t, TransactionId the transaction ID undoId, LogInstant the last log record that should be rolled back undoStopAt, LogInstant the first log record that should be rolled back undoStartAt)Implements org. Undo a part of or the entire transaction. |
| encryptionBuffer | back to summary |
|---|---|
| protected byte[] encryptionBuffer | |
| logFactory | back to summary |
|---|---|
| private LogToFile logFactory | |
| logicalOut | back to summary |
|---|---|
| private FormatIdOutputStream logicalOut | |
| logIn | back to summary |
|---|---|
| private ArrayInputStream logIn | |
| logOutputBuffer | back to summary |
|---|---|
| private DynamicByteArrayOutputStream logOutputBuffer | |
| logRecord | back to summary |
|---|---|
| private LogRecord logRecord | |
| FileLogger | back to summary |
|---|---|
| public FileLogger(LogToFile logFactory) Make a new Logger with its own log record buffers MT - not needed for constructor | |
| close | back to summary |
|---|---|
| public void close() throws IOException Close the logger. MT - caller provide synchronization (RESOLVE: not called by anyone ??) | |
| flush | back to summary |
|---|---|
| public void flush(LogInstant where) throws StandardException Implements org. Flush the log up to the given log instant. MT - not needed, wrapper method
| |
| flushAll | back to summary |
|---|---|
| public void flushAll() throws StandardException Implements org. Flush all outstanding log to disk. MT - not needed, wrapper method
| |
| logAndDo | back to summary |
|---|---|
| public synchronized LogInstant logAndDo(RawTransaction xact, Loggable operation) throws StandardException Implements org. Writes out a log record to the log stream, and call its doMe method to
apply the change to the rawStore.
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.
| |
| logAndUndo | back to summary |
|---|---|
| public LogInstant logAndUndo(RawTransaction xact, Compensation compensation, LogInstant undoInstant, LimitObjectInput in) throws StandardException Implements org. 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.
| |
| readLogRecord | back to summary |
|---|---|
| protected Loggable readLogRecord(StreamLogScan scan, int size) throws IOException, StandardException, 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).
| |
| redo | back to summary |
|---|---|
| protected long redo(RawTransaction recoveryTransaction, TransactionFactory transFactory, StreamLogScan redoScan, long redoLWM, long ttabInstant) throws IOException, StandardException, 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:
MT - caller provides synchronization
| |
| reprepare | back to summary |
|---|---|
| public void reprepare(RawTransaction t, TransactionId prepareId, LogInstant prepareStopAt, LogInstant prepareStartAt) throws StandardException Implements org. 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.
| |
| undo | back to summary |
|---|---|
| public void undo(RawTransaction t, TransactionId undoId, LogInstant undoStopAt, LogInstant undoStartAt) throws StandardException Implements org. 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.
| |