Class LogAccessFile
-
Field Summary
FieldsModifier and TypeFieldDescriptionprivate long
private int
private ChecksumOperation
private LogRecord
private int
private LogAccessFileBuffer
private boolean
private LinkedList
<LogAccessFileBuffer> private boolean
private LinkedList
<LogAccessFileBuffer> (package private) boolean
(package private) boolean
private final StorageRandomAccessFile
private static final int
private static final int
The fixed size of a log record is 16 bytes: int length : 4 bytes long instant : 8 bytes int trailing length : 4 bytesprivate static final int
private static final int
private LogToFile
private final Object
private FormatIdOutputStream
private ArrayOutputStream
(package private) MasterFactory
(package private) static int
(package private) static int
private boolean
-
Constructor Summary
ConstructorsConstructorDescriptionLogAccessFile
(LogToFile logFactory, StorageRandomAccessFile log, int bufferSize) -
Method Summary
Modifier and TypeMethodDescriptionprivate int
appendLogRecordToBuffer
(byte[] buff, int pos, int length, long instant, byte[] data, int data_offset, byte[] optional_data, int optional_data_offset, int optional_data_length) Append a log record to a byte[].void
close()
void
corrupt()
The database is being marked corrupted, get rid of file pointer without writing out anything more.protected void
Write data from all dirty buffers into the log file.void
int
Return the length of a checksum recordprotected long
reserveSpaceForChecksum
(int length, long logFileNumber, long currentPosition) reserve the space for the checksum log record in the log file.protected void
setReplicationMasterRole
(MasterFactory masterFac) Make this LogAccessFile pass chunks of log records (byte[]) to the MasterFactory when the chunks are written to disk.protected void
Method to put this LogAccessFile object in replication slave mode, effectively disabling checksum writes.protected void
Stop this LogAccessFile from passing chunks of log records to the MasterFactory.void
Appends the current Buffer to the dirty Buffer list and assigns a free buffer to be the currrent active buffer .void
Guarantee all writes up to the last call to flushLogAccessFile on disk.void
write
(byte[] b, int off, int len) void
write
(int b) private void
writeChecksumLogRecord
(byte[] buffer) Generate the checkum log record and write it into the log buffer.protected void
writeEndMarker
(int marker) void
writeInt
(int i) private final int
writeInt
(int i, byte[] b, int p) void
writeLogRecord
(int length, long instant, byte[] data, int data_offset, byte[] optional_data, int optional_data_offset, int optional_data_length) Write a single log record to the stream.void
writeLong
(long l) private final int
writeLong
(long l, byte[] b, int p) private void
writeToLog
(byte[] b, int off, int len, long highestInstant)
-
Field Details
-
LOG_RECORD_FIXED_OVERHEAD_SIZE
private static final int LOG_RECORD_FIXED_OVERHEAD_SIZEThe fixed size of a log record is 16 bytes: int length : 4 bytes long instant : 8 bytes int trailing length : 4 bytes- See Also:
-
LOG_RECORD_HEADER_SIZE
private static final int LOG_RECORD_HEADER_SIZE- See Also:
-
LOG_RECORD_TRAILER_SIZE
private static final int LOG_RECORD_TRAILER_SIZE- See Also:
-
LOG_NUMBER_LOG_BUFFERS
private static final int LOG_NUMBER_LOG_BUFFERS- See Also:
-
freeBuffers
-
dirtyBuffers
-
currentBuffer
-
flushInProgress
private boolean flushInProgress -
log
-
logFileSemaphore
-
mon_numWritesToLog
static int mon_numWritesToLog -
mon_numBytesToLog
static int mon_numBytesToLog -
masterFac
MasterFactory masterFac -
inReplicationMasterMode
boolean inReplicationMasterMode -
inReplicationSlaveMode
boolean inReplicationSlaveMode -
logOutputBuffer
-
logicalOut
-
checksumInstant
private long checksumInstant -
checksumLength
private int checksumLength -
checksumLogRecordSize
private int checksumLogRecordSize -
writeChecksum
private boolean writeChecksum -
checksumLogOperation
-
checksumLogRecord
-
logFactory
-
databaseEncrypted
private boolean databaseEncrypted
-
-
Constructor Details
-
LogAccessFile
-
-
Method Details
-
writeLogRecord
public void writeLogRecord(int length, long instant, byte[] data, int data_offset, byte[] optional_data, int optional_data_offset, int optional_data_length) throws StandardException, IOException Write a single log record to the stream.For performance pass all parameters rather into a specialized routine rather than maintaining the writeInt, writeLong, and write interfaces that this class provides as a standard OutputStream. It will make it harder to use other OutputStream implementations, but makes for less function calls and allows optimizations knowing when to switch buffers.
This routine handles all log records which are smaller than one log buffer. If a log record is bigger than a log buffer it calls writeUnbufferedLogRecord().
The log record written will always look the same as if the following code had been executed: writeInt(length) writeLong(instant) write(data, data_offset, (length - optional_data_length) ) if (optional_data_length != 0) write(optional_data, optional_data_offset, optional_data_length) writeInt(length)
- Parameters:
length
- (data + optional_data) length bytes to writeinstant
- the log address of this log record.data
- "from" array to copy "data" portion of recdata_offset
- offset in "data" to start copying from.optional_data
- "from" array to copy "optional data" fromoptional_data_offset
- offset in "optional_data" to start copy fromoptional_data_length
- length of optional data to copy.- Throws:
StandardException
- Standard exception policy.IOException
-
appendLogRecordToBuffer
private int appendLogRecordToBuffer(byte[] buff, int pos, int length, long instant, byte[] data, int data_offset, byte[] optional_data, int optional_data_offset, int optional_data_length) Append a log record to a byte[]. Typically, the byte[] will be currentBuffer, but if a log record that is too big to fit in a buffer is added, buff will be a newly allocated byte[].- Parameters:
buff
- The byte[] the log record is appended topos
- The position in buff where the method will start to append tolength
- (data + optional_data) length bytes to writeinstant
- the log address of this log record.data
- "from" array to copy "data" portion of recdata_offset
- offset in "data" to start copying from.optional_data
- "from" array to copy "optional data" fromoptional_data_offset
- offset in "optional_data" to start copy fromoptional_data_length
- length of optional data to copy.- See Also:
-
writeInt
private final int writeInt(int i, byte[] b, int p) -
writeLong
private final int writeLong(long l, byte[] b, int p) -
writeInt
public void writeInt(int i) -
writeLong
public void writeLong(long l) -
write
public void write(int b) -
write
public void write(byte[] b, int off, int len) -
flushDirtyBuffers
Write data from all dirty buffers into the log file.A call for clients of LogAccessFile to insure that all privately buffered data has been writen to the file - so that reads on the file using one of the various scan classes will see all the data which has been writen to this point.
Note that this routine only "writes" the data to the file, this does not mean that the data has been synced to disk unless file was opened in WRITE SYNC mode(rws/rwd). The only way to insure that is by calling is to call syncLogAccessFile() after this call in Non-WRITE sync mode(rw)
MT-Safe : parallel thereads can call this function, only one threads does the flush and the other threads waits for the one that is doing the flush to finish. Currently there are two possible threads that can call this function in parallel 1) A Thread that is doing the commit 2) A Thread that is writing to the log and log buffers are full or a log records does not fit in a buffer. (Log Buffers full(switchLogBuffer() or a log record size that is greater than logbuffer size has to be writtern through writeToLog call directlty) Note: writeToLog() is not synchronized on the semaphore that is used to do buffer management to allow writes to the free buffers when flush is in progress.
- Throws:
IOException
-
flushLogAccessFile
- Throws:
IOException
StandardException
-
switchLogBuffer
Appends the current Buffer to the dirty Buffer list and assigns a free buffer to be the currrent active buffer . Flushing of the buffer to disk is delayed if there is a free buffer available. dirty buffers will be flushed to the disk when flushDirtyBuffers() is invoked by a commit call or when no more free buffers are available.- Throws:
IOException
StandardException
-
syncLogAccessFile
Guarantee all writes up to the last call to flushLogAccessFile on disk.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.
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().
- Throws:
IOException
StandardException
-
corrupt
The database is being marked corrupted, get rid of file pointer without writing out anything more.- Throws:
IOException
-
close
- Throws:
IOException
StandardException
-
setReplicationMasterRole
Make this LogAccessFile pass chunks of log records (byte[]) to the MasterFactory when the chunks are written to disk.- Parameters:
masterFac
- The MasterFactory service responsible for controlling the master side replication behaviour.
-
stopReplicationMasterRole
protected void stopReplicationMasterRole()Stop this LogAccessFile from passing chunks of log records to the MasterFactory. -
setReplicationSlaveRole
protected void setReplicationSlaveRole()Method to put this LogAccessFile object in replication slave mode, effectively disabling checksum writes. Because checksums are received from the replication master, the slave can not be allowed to add it's own checksums - that would invalidate the checksums and would stop the database from recovering. Replication slave mode must therefore be set before LogAccessFile decides whether to write it's own checksums, and this method is therefore indirectly called from the constructor of this class by calling LogFactory.checkForReplication If replication slave mode for the database is stopped after this object has been created, checksums cannot be reenabled without creating a new instance of this class. That is conveniently handled as LogToFile.recover completes (which automatically happens once replication slave mode is no longer active)- See Also:
-
writeToLog
- Throws:
IOException
-
reserveSpaceForChecksum
protected long reserveSpaceForChecksum(int length, long logFileNumber, long currentPosition) throws StandardException, IOException reserve the space for the checksum log record in the log file.- Parameters:
length
- the length of the log record to be writtenlogFileNumber
- current log file numbercurrentPosition
- current position in the log file.- Returns:
- the space that is needed to write a checksum log record.
- Throws:
StandardException
IOException
-
writeChecksumLogRecord
Generate the checkum log record and write it into the log buffer. The checksum applies to all bytes from this checksum log record to the next one.- Parameters:
buffer
- The byte[] the checksum is written to. The checksum is always written at the beginning of buffer.- Throws:
IOException
StandardException
-
getChecksumLogRecordSize
public int getChecksumLogRecordSize()Return the length of a checksum record -
writeEndMarker
- Throws:
IOException
StandardException
-