org.apache.hadoop.hbase.regionserver.wal

Class AbstractFSWAL<W extends WriterBase>

java.lang.Object

org.apache.hadoop.hbase.regionserver.wal.AbstractFSWAL<W>

Direct Known Subclasses:

AsyncFSWAL, FSHLog

public abstract class AbstractFSWAL<W extends WriterBase>
extends java.lang.Object

Implementation of WAL to go against FileSystem; i.e. keep WALs in HDFS. Only one WAL is ever being written at a time. When a WAL hits a configured maximum size, it is rolled. This is done internal to the implementation.

As data is flushed from the MemStore to other on-disk structures (files sorted by key, hfiles), a WAL becomes obsolete. We can let go of all the log edits/entries for a given HRegion-sequence id. A bunch of work in the below is done keeping account of these region sequence ids -- what is flushed out to hfiles, and what is yet in WAL and in memory only.

It is only practical to delete entire files. Thus, we delete an entire on-disk file F when all of the edits in F have a log-sequence-id that's older (smaller) than the most-recent flush.

To read an WAL, call WALFactory#createReader(org.apache.hadoop.fs.FileSystem, org.apache.hadoop.fs.Path). *

Failure Semantic

If an exception on append or sync, roll the WAL because the current WAL is now a lame duck; any more appends or syncs will fail also with the same original exception. If we have made successful appends to the WAL and we then are unable to sync them, our current semantic is to return error to the client that the appends failed but also to abort the current context, usually the hosting server. We need to replay the WALs.
TODO: Change this semantic. A roll of WAL may be sufficient as long as we have flagged client that the append failed.
TODO: replication may pick up these last edits though they have been marked as failed append (Need to keep our own file lengths, not rely on HDFS).

Field Summary

Fields

Modifier and Type	Field and Description
protected long	blocksize Block size to use writing files.
protected boolean	closed
protected Configuration	conf conf object
protected WALCoprocessorHost	coprocessorHost
protected static int	DEFAULT_SLOW_SYNC_TIME_MS
protected java.util.concurrent.atomic.AtomicLong	filenum
protected FileSystem	fs file system instance
protected java.util.concurrent.atomic.AtomicLong	highestSyncedTxid Updated to the transaction id of the last successful sync call.
protected long	highestUnsyncedTxid The highest known outstanding unsync'd WALEdit transaction id.
protected java.lang.String	implClassName The class name of the runtime implementation, used as prefix for logging/tracing.
protected java.util.List<WALActionsListener>	listeners Listeners that are called on WAL events.
protected long	logrollsize
protected int	maxLogs
protected java.util.concurrent.atomic.AtomicInteger	numEntries
protected PathFilter	ourFiles Matches just those wal files that belong to this wal instance.
protected java.lang.String	prefixPathStr Prefix used when checking for wal membership.
protected java.util.concurrent.locks.ReentrantLock	rollWriterLock This lock makes sure only one log roll runs at a time.
protected org.apache.hadoop.hbase.regionserver.wal.SequenceIdAccounting	sequenceIdAccounting Class that does accounting of sequenceids in WAL subsystem.
protected java.util.concurrent.atomic.AtomicBoolean	shutdown
protected long	slowSyncNs
protected java.util.concurrent.atomic.AtomicLong	totalLogSize The total size of wal
protected Path	walArchiveDir dir path where old logs are kept.
protected Path	walDir WAL directory, where all WAL files would be placed.
protected java.util.concurrent.ConcurrentNavigableMap<Path,org.apache.hadoop.hbase.regionserver.wal.AbstractFSWAL.WalProps>	walFile2Props Map of WAL log file to properties.
protected java.lang.String	walFilePrefix Prefix of a WAL file, usually the region server name it is hosted on.
protected java.lang.String	walFileSuffix Suffix included on generated wal file names

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	AbstractFSWAL(FileSystem fs, Path rootDir, java.lang.String logDir, java.lang.String archiveDir, Configuration conf, java.util.List<WALActionsListener> listeners, boolean failIfWALExists, java.lang.String prefix, java.lang.String suffix)

Method Summary

Modifier and Type	Method and Description
void	abortCacheFlush(byte[] encodedRegionName)
abstract long	append(RegionInfo info, WALKeyImpl key, WALEdit edits, boolean inMemstore) NOTE: This append, at a time that is usually after this call returns, starts an mvcc transaction by calling 'begin' wherein which we assign this update a sequenceid.
protected boolean	append(W writer, org.apache.hadoop.hbase.regionserver.wal.FSWALEntry entry)
protected void	blockOnSync(org.apache.hadoop.hbase.regionserver.wal.SyncFuture syncFuture)
void	checkLogLowReplication(long checkInterval)
void	close()
void	completeCacheFlush(byte[] encodedRegionName)
protected Path	computeFilename(long filenum) This is a convenience method that computes a new filename with a given file-number.
protected abstract W	createWriterInstance(Path path)
protected abstract void	doAppend(W writer, org.apache.hadoop.hbase.regionserver.wal.FSWALEntry entry)
protected abstract boolean	doCheckLogLowReplication()
protected abstract void	doReplaceWriter(Path oldPath, Path newPath, W nextWriter)
protected abstract void	doShutdown()
WALCoprocessorHost	getCoprocessorHost()
Path	getCurrentFileName() This is a convenience method that computes a new filename with a given using the current WAL file-number
long	getEarliestMemStoreSeqNum(byte[] encodedRegionName)
long	getEarliestMemStoreSeqNum(byte[] encodedRegionName, byte[] familyName)
long	getFilenum()
protected long	getFileNumFromFileName(Path fileName) A log file has a creation timestamp (in ms) in its file name (filenum.
long	getLogFileSize()
java.util.OptionalLong	getLogFileSizeIfBeingWritten(Path path) if the given path is being written currently, then return its length.
int	getNumLogFiles()
int	getNumRolledLogFiles()
protected int	getPreallocatedEventCount()
protected org.apache.hadoop.hbase.regionserver.wal.SyncFuture	getSyncFuture(long sequence)
static Path	getWALArchivePath(Path archiveDir, Path p)
protected void	logRollAndSetupWalProps(Path oldPath, Path newPath, long oldFileLen)
static void	main(java.lang.String[] args) Pass one or more log file names and it will either dump out a text version on stdout or split the specified log files.
protected void	postSync(long timeInNanos, int handlerSyncs)
void	registerWALActionsListener(WALActionsListener listener)
void	requestLogRoll()
protected void	requestLogRoll(boolean tooFewReplicas)
byte[][]	rollWriter()
byte[][]	rollWriter(boolean force)
void	shutdown()
protected long	stampSequenceIdAndPublishToRingBuffer(RegionInfo hri, WALKeyImpl key, WALEdit edits, boolean inMemstore, <any> ringBuffer)
java.lang.Long	startCacheFlush(byte[] encodedRegionName, java.util.Map<byte[],java.lang.Long> familyToSeq)
java.lang.Long	startCacheFlush(byte[] encodedRegionName, java.util.Set<byte[]> families)
java.lang.String	toString()
boolean	unregisterWALActionsListener(WALActionsListener listener)
void	updateStore(byte[] encodedRegionName, byte[] familyName, java.lang.Long sequenceid, boolean onlyIfGreater) updates the sequence number of a specific store.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

DEFAULT_SLOW_SYNC_TIME_MS

protected static final int DEFAULT_SLOW_SYNC_TIME_MS

See Also:

Constant Field Values

fs

protected final FileSystem fs

file system instance

walDir

protected final Path walDir

WAL directory, where all WAL files would be placed.

walArchiveDir

protected final Path walArchiveDir

dir path where old logs are kept.

ourFiles

protected final PathFilter ourFiles

Matches just those wal files that belong to this wal instance.

walFilePrefix

protected final java.lang.String walFilePrefix

Prefix of a WAL file, usually the region server name it is hosted on.

walFileSuffix

protected final java.lang.String walFileSuffix

Suffix included on generated wal file names

prefixPathStr

protected final java.lang.String prefixPathStr

Prefix used when checking for wal membership.

coprocessorHost

protected final WALCoprocessorHost coprocessorHost

conf

protected final Configuration conf

conf object

listeners

protected final java.util.List<WALActionsListener> listeners

Listeners that are called on WAL events.

sequenceIdAccounting

protected final org.apache.hadoop.hbase.regionserver.wal.SequenceIdAccounting sequenceIdAccounting

Class that does accounting of sequenceids in WAL subsystem. Holds oldest outstanding sequence id as yet not flushed as well as the most recent edit sequence id appended to the WAL. Has facility for answering questions such as "Is it safe to GC a WAL?".

slowSyncNs

protected final long slowSyncNs

logrollsize

protected final long logrollsize

blocksize

protected final long blocksize

Block size to use writing files.

maxLogs

protected final int maxLogs

rollWriterLock

protected final java.util.concurrent.locks.ReentrantLock rollWriterLock

This lock makes sure only one log roll runs at a time. Should not be taken while any other lock is held. We don't just use synchronized because that results in bogus and tedious findbugs warning when it thinks synchronized controls writer thread safety. It is held when we are actually rolling the log. It is checked when we are looking to see if we should roll the log or not.

filenum

protected final java.util.concurrent.atomic.AtomicLong filenum

numEntries

protected final java.util.concurrent.atomic.AtomicInteger numEntries

highestUnsyncedTxid

protected volatile long highestUnsyncedTxid

The highest known outstanding unsync'd WALEdit transaction id. Usually, we use a queue to pass WALEdit to background consumer thread, and the transaction id is the sequence number of the corresponding entry in queue.

highestSyncedTxid

protected final java.util.concurrent.atomic.AtomicLong highestSyncedTxid

Updated to the transaction id of the last successful sync call. This can be less than highestUnsyncedTxid for case where we have an append where a sync has not yet come in for it.

totalLogSize

protected final java.util.concurrent.atomic.AtomicLong totalLogSize

The total size of wal

closed

protected volatile boolean closed

shutdown

protected final java.util.concurrent.atomic.AtomicBoolean shutdown

walFile2Props

protected java.util.concurrent.ConcurrentNavigableMap<Path,org.apache.hadoop.hbase.regionserver.wal.AbstractFSWAL.WalProps> walFile2Props

Map of WAL log file to properties. The map is sorted by the log file creation timestamp (contained in the log file name).

implClassName

protected final java.lang.String implClassName

The class name of the runtime implementation, used as prefix for logging/tracing.

Performance testing shows getClass().getSimpleName() might be a bottleneck so we store it here, refer to HBASE-17676 for more details

Constructor Detail

AbstractFSWAL

protected AbstractFSWAL(FileSystem fs,
                        Path rootDir,
                        java.lang.String logDir,
                        java.lang.String archiveDir,
                        Configuration conf,
                        java.util.List<WALActionsListener> listeners,
                        boolean failIfWALExists,
                        java.lang.String prefix,
                        java.lang.String suffix)
                 throws FailedLogCloseException,
                        java.io.IOException

Throws:

FailedLogCloseException

java.io.IOException

Method Detail

getFilenum

public long getFilenum()

getFileNumFromFileName

protected long getFileNumFromFileName(Path fileName)

A log file has a creation timestamp (in ms) in its file name (filenum. This helper method returns the creation timestamp from a given log file. It extracts the timestamp assuming the filename is created with the computeFilename(long filenum) method.

Returns:

timestamp, as in the log file name.

getPreallocatedEventCount

protected final int getPreallocatedEventCount()

registerWALActionsListener

public void registerWALActionsListener(WALActionsListener listener)

unregisterWALActionsListener

public boolean unregisterWALActionsListener(WALActionsListener listener)

getCoprocessorHost

public WALCoprocessorHost getCoprocessorHost()

startCacheFlush

public java.lang.Long startCacheFlush(byte[] encodedRegionName,
                                      java.util.Set<byte[]> families)

startCacheFlush

public java.lang.Long startCacheFlush(byte[] encodedRegionName,
                                      java.util.Map<byte[],java.lang.Long> familyToSeq)

completeCacheFlush

public void completeCacheFlush(byte[] encodedRegionName)

abortCacheFlush

public void abortCacheFlush(byte[] encodedRegionName)

getEarliestMemStoreSeqNum

public long getEarliestMemStoreSeqNum(byte[] encodedRegionName)

getEarliestMemStoreSeqNum

public long getEarliestMemStoreSeqNum(byte[] encodedRegionName,
                                      byte[] familyName)

rollWriter

public byte[][] rollWriter()
                    throws FailedLogCloseException,
                           java.io.IOException

Throws:

FailedLogCloseException

java.io.IOException

computeFilename

protected Path computeFilename(long filenum)

This is a convenience method that computes a new filename with a given file-number.

Parameters:

filenum - to use

Returns:

Path

getCurrentFileName

public Path getCurrentFileName()

This is a convenience method that computes a new filename with a given using the current WAL file-number

Returns:

Path

getNumRolledLogFiles

public int getNumRolledLogFiles()

Returns:

the number of rolled log files

getNumLogFiles

public int getNumLogFiles()

Returns:

the number of log files in use

getWALArchivePath

public static Path getWALArchivePath(Path archiveDir,
                                     Path p)

logRollAndSetupWalProps

protected final void logRollAndSetupWalProps(Path oldPath,
                                             Path newPath,
                                             long oldFileLen)

blockOnSync

protected final void blockOnSync(org.apache.hadoop.hbase.regionserver.wal.SyncFuture syncFuture)
                          throws java.io.IOException

Throws:

java.io.IOException

rollWriter

public byte[][] rollWriter(boolean force)
                    throws FailedLogCloseException,
                           java.io.IOException

Throws:

FailedLogCloseException

java.io.IOException

getLogFileSize

public long getLogFileSize()

Returns:

the size of log files in use

requestLogRoll

public void requestLogRoll()

shutdown

public void shutdown()
              throws java.io.IOException

Throws:

java.io.IOException

close

public void close()
           throws java.io.IOException

Throws:

java.io.IOException

updateStore

public void updateStore(byte[] encodedRegionName,
                        byte[] familyName,
                        java.lang.Long sequenceid,
                        boolean onlyIfGreater)

updates the sequence number of a specific store. depending on the flag: replaces current seq number if the given seq id is bigger, or even if it is lower than existing one

Parameters:

encodedRegionName -

familyName -

sequenceid -

onlyIfGreater -

getSyncFuture

protected final org.apache.hadoop.hbase.regionserver.wal.SyncFuture getSyncFuture(long sequence)

requestLogRoll

protected final void requestLogRoll(boolean tooFewReplicas)

append

protected final boolean append(W writer,
                               org.apache.hadoop.hbase.regionserver.wal.FSWALEntry entry)
                        throws java.io.IOException

Throws:

java.io.IOException

postSync

protected final void postSync(long timeInNanos,
                              int handlerSyncs)

stampSequenceIdAndPublishToRingBuffer

protected final long stampSequenceIdAndPublishToRingBuffer(RegionInfo hri,
                                                           WALKeyImpl key,
                                                           WALEdit edits,
                                                           boolean inMemstore,
                                                           <any> ringBuffer)
                                                    throws java.io.IOException

Throws:

java.io.IOException

toString

public java.lang.String toString()

Overrides:

toString in class java.lang.Object

getLogFileSizeIfBeingWritten

public java.util.OptionalLong getLogFileSizeIfBeingWritten(Path path)

if the given path is being written currently, then return its length.

This is used by replication to prevent replicating unacked log entries. See https://issues.apache.org/jira/browse/HBASE-14004 for more details.

append

public abstract long append(RegionInfo info,
                            WALKeyImpl key,
                            WALEdit edits,
                            boolean inMemstore)
                     throws java.io.IOException

NOTE: This append, at a time that is usually after this call returns, starts an mvcc transaction by calling 'begin' wherein which we assign this update a sequenceid. At assignment time, we stamp all the passed in Cells inside WALEdit with their sequenceId. You must 'complete' the transaction this mvcc transaction by calling MultiVersionConcurrencyControl#complete(...) or a variant otherwise mvcc will get stuck. Do it in the finally of a try/finally block within which this append lives and any subsequent operations like sync or update of memstore, etc. Get the WriteEntry to pass mvcc out of the passed in WALKey walKey parameter. Be warned that the WriteEntry is not immediately available on return from this method. It WILL be available subsequent to a sync of this append; otherwise, you will just have to wait on the WriteEntry to get filled in.

Throws:

java.io.IOException

doAppend

protected abstract void doAppend(W writer,
                                 org.apache.hadoop.hbase.regionserver.wal.FSWALEntry entry)
                          throws java.io.IOException

Throws:

java.io.IOException

createWriterInstance

protected abstract W createWriterInstance(Path path)
                                   throws java.io.IOException,
                                          CommonFSUtils.StreamLacksCapabilityException

Throws:

java.io.IOException

CommonFSUtils.StreamLacksCapabilityException

doReplaceWriter

protected abstract void doReplaceWriter(Path oldPath,
                                        Path newPath,
                                        W nextWriter)
                                 throws java.io.IOException

Throws:

java.io.IOException

doShutdown

protected abstract void doShutdown()
                            throws java.io.IOException

Throws:

java.io.IOException

doCheckLogLowReplication

protected abstract boolean doCheckLogLowReplication()

checkLogLowReplication

public void checkLogLowReplication(long checkInterval)

main

public static void main(java.lang.String[] args)
                 throws java.io.IOException

Pass one or more log file names and it will either dump out a text version on stdout or split the specified log files.

Throws:

java.io.IOException