org.apache.hadoop.hbase.regionserver.wal

Class AbstractFSWAL<W extends WALProvider.WriterBase>

java.lang.Object

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

All Implemented Interfaces:

Closeable, AutoCloseable, WALFileLengthProvider, WAL

Direct Known Subclasses:

AsyncFSWAL, FSHLog

@InterfaceAudience.Private
public abstract class AbstractFSWAL<W extends WALProvider.WriterBase>
extends Object
implements WAL

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).

Nested Class Summary

Nested classes/interfaces inherited from interface org.apache.hadoop.hbase.wal.WAL

WAL.Entry, WAL.Reader

Field Summary

Fields

Modifier and Type	Field and Description
protected boolean	closed
protected org.apache.hadoop.conf.Configuration	conf conf object
protected WALCoprocessorHost	coprocessorHost
protected static int	DEFAULT_SLOW_SYNC_TIME_MS
protected AtomicLong	filenum
protected org.apache.hadoop.fs.FileSystem	fs file system instance
protected 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 String	implClassName The class name of the runtime implementation, used as prefix for logging/tracing.
protected List<WALActionsListener>	listeners Listeners that are called on WAL events.
protected long	logrollsize
protected int	maxLogs
protected AtomicInteger	numEntries
protected org.apache.hadoop.fs.PathFilter	ourFiles Matches just those wal files that belong to this wal instance.
protected String	prefixPathStr Prefix used when checking for wal membership.
protected 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 AtomicBoolean	shutdown
protected long	slowSyncNs
protected AtomicLong	totalLogSize The total size of wal
protected org.apache.hadoop.fs.Path	walArchiveDir dir path where old logs are kept.
protected org.apache.hadoop.fs.Path	walDir WAL directory, where all WAL files would be placed.
protected ConcurrentNavigableMap<org.apache.hadoop.fs.Path,org.apache.hadoop.hbase.regionserver.wal.AbstractFSWAL.WalProps>	walFile2Props Map of WAL log file to properties.
protected String	walFilePrefix Prefix of a WAL file, usually the region server name it is hosted on.
protected String	walFileSuffix Suffix included on generated wal file names

Constructor Summary

Constructors

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

Method Summary

Modifier and Type	Method and Description
void	abortCacheFlush(byte[] encodedRegionName) Abort a cache flush.
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() Caller no longer needs any edits from this WAL.
void	completeCacheFlush(byte[] encodedRegionName) Complete the cache flush.
protected org.apache.hadoop.fs.Path	computeFilename(long filenum) This is a convenience method that computes a new filename with a given file-number.
protected abstract W	createWriterInstance(org.apache.hadoop.fs.Path path)
protected abstract void	doAppend(W writer, org.apache.hadoop.hbase.regionserver.wal.FSWALEntry entry)
protected abstract boolean	doCheckLogLowReplication()
protected abstract void	doReplaceWriter(org.apache.hadoop.fs.Path oldPath, org.apache.hadoop.fs.Path newPath, W nextWriter)
protected abstract void	doShutdown()
WALCoprocessorHost	getCoprocessorHost()
org.apache.hadoop.fs.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) Gets the earliest unflushed sequence id in the memstore for the region.
long	getEarliestMemStoreSeqNum(byte[] encodedRegionName, byte[] familyName) Gets the earliest unflushed sequence id in the memstore for the store.
long	getFilenum()
protected long	getFileNumFromFileName(org.apache.hadoop.fs.Path fileName) A log file has a creation timestamp (in ms) in its file name (filenum.
long	getLogFileSize()
OptionalLong	getLogFileSizeIfBeingWritten(org.apache.hadoop.fs.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 org.apache.hadoop.fs.Path	getWALArchivePath(org.apache.hadoop.fs.Path archiveDir, org.apache.hadoop.fs.Path p)
protected void	logRollAndSetupWalProps(org.apache.hadoop.fs.Path oldPath, org.apache.hadoop.fs.Path newPath, long oldFileLen)
static void	main(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) Registers WALActionsListener
void	requestLogRoll()
protected void	requestLogRoll(boolean tooFewReplicas)
byte[][]	rollWriter() Roll the log writer.
byte[][]	rollWriter(boolean force) Roll the log writer.
void	shutdown() Stop accepting new writes.
protected long	stampSequenceIdAndPublishToRingBuffer(RegionInfo hri, WALKeyImpl key, WALEdit edits, boolean inMemstore, com.lmax.disruptor.RingBuffer<org.apache.hadoop.hbase.regionserver.wal.RingBufferTruck> ringBuffer)
Long	startCacheFlush(byte[] encodedRegionName, Map<byte[],Long> familyToSeq)
Long	startCacheFlush(byte[] encodedRegionName, Set<byte[]> families) WAL keeps track of the sequence numbers that are as yet not flushed im memstores in order to be able to do accounting to figure which WALs can be let go.
String	toString() Human readable identifying information about the state of this WAL.
boolean	unregisterWALActionsListener(WALActionsListener listener) Unregisters WALActionsListener
void	updateStore(byte[] encodedRegionName, byte[] familyName, 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

Methods inherited from interface org.apache.hadoop.hbase.wal.WAL

sync, sync

Field Detail

DEFAULT_SLOW_SYNC_TIME_MS

protected static final int DEFAULT_SLOW_SYNC_TIME_MS

See Also:

Constant Field Values

fs

protected final org.apache.hadoop.fs.FileSystem fs

file system instance

walDir

protected final org.apache.hadoop.fs.Path walDir

WAL directory, where all WAL files would be placed.

walArchiveDir

protected final org.apache.hadoop.fs.Path walArchiveDir

dir path where old logs are kept.

ourFiles

protected final org.apache.hadoop.fs.PathFilter ourFiles

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

walFilePrefix

protected final String walFilePrefix

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

walFileSuffix

protected final String walFileSuffix

Suffix included on generated wal file names

prefixPathStr

protected final String prefixPathStr

Prefix used when checking for wal membership.

coprocessorHost

protected final WALCoprocessorHost coprocessorHost

conf

protected final org.apache.hadoop.conf.Configuration conf

conf object

listeners

protected final 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

maxLogs

protected final int maxLogs

rollWriterLock

protected final 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 AtomicLong filenum

numEntries

protected final 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 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 AtomicLong totalLogSize

The total size of wal

closed

protected volatile boolean closed

shutdown

protected final AtomicBoolean shutdown

walFile2Props

protected ConcurrentNavigableMap<org.apache.hadoop.fs.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 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(org.apache.hadoop.fs.FileSystem fs,
                        org.apache.hadoop.fs.Path rootDir,
                        String logDir,
                        String archiveDir,
                        org.apache.hadoop.conf.Configuration conf,
                        List<WALActionsListener> listeners,
                        boolean failIfWALExists,
                        String prefix,
                        String suffix)
                 throws FailedLogCloseException,
                        IOException

Throws:

FailedLogCloseException

IOException

Method Detail

getFilenum

public long getFilenum()

getFileNumFromFileName

protected long getFileNumFromFileName(org.apache.hadoop.fs.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)

Description copied from interface: WAL

Registers WALActionsListener

Specified by:

registerWALActionsListener in interface WAL

unregisterWALActionsListener

public boolean unregisterWALActionsListener(WALActionsListener listener)

Description copied from interface: WAL

Unregisters WALActionsListener

Specified by:

unregisterWALActionsListener in interface WAL

getCoprocessorHost

public WALCoprocessorHost getCoprocessorHost()

Specified by:

getCoprocessorHost in interface WAL

Returns:

Coprocessor host.

startCacheFlush

public Long startCacheFlush(byte[] encodedRegionName,
                            Set<byte[]> families)

Description copied from interface: WAL

WAL keeps track of the sequence numbers that are as yet not flushed im memstores in order to be able to do accounting to figure which WALs can be let go. This method tells WAL that some region is about to flush. The flush can be the whole region or for a column family of the region only.

Currently, it is expected that the update lock is held for the region; i.e. no concurrent appends while we set up cache flush.

Specified by:

startCacheFlush in interface WAL

families - Families to flush. May be a subset of all families in the region.

Returns:

Returns HConstants.NO_SEQNUM if we are flushing the whole region OR if we are flushing a subset of all families but there are no edits in those families not being flushed; in other words, this is effectively same as a flush of all of the region though we were passed a subset of regions. Otherwise, it returns the sequence id of the oldest/lowest outstanding edit.

See Also:

WAL.completeCacheFlush(byte[]), WAL.abortCacheFlush(byte[])

startCacheFlush

public Long startCacheFlush(byte[] encodedRegionName,
                            Map<byte[],Long> familyToSeq)

Specified by:

startCacheFlush in interface WAL

completeCacheFlush

public void completeCacheFlush(byte[] encodedRegionName)

Description copied from interface: WAL

Complete the cache flush.

Specified by:

completeCacheFlush in interface WAL

Parameters:

encodedRegionName - Encoded region name.

See Also:

WAL.startCacheFlush(byte[], Set), WAL.abortCacheFlush(byte[])

abortCacheFlush

public void abortCacheFlush(byte[] encodedRegionName)

Description copied from interface: WAL

Abort a cache flush. Call if the flush fails. Note that the only recovery for an aborted flush currently is a restart of the regionserver so the snapshot content dropped by the failure gets restored to the memstore.

Specified by:

abortCacheFlush in interface WAL

Parameters:

encodedRegionName - Encoded region name.

getEarliestMemStoreSeqNum

public long getEarliestMemStoreSeqNum(byte[] encodedRegionName)

Description copied from interface: WAL

Gets the earliest unflushed sequence id in the memstore for the region.

Specified by:

getEarliestMemStoreSeqNum in interface WAL

Parameters:

encodedRegionName - The region to get the number for.

Returns:

The earliest/lowest/oldest sequence id if present, HConstants.NO_SEQNUM if absent.

getEarliestMemStoreSeqNum

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

Description copied from interface: WAL

Gets the earliest unflushed sequence id in the memstore for the store.

Specified by:

getEarliestMemStoreSeqNum in interface WAL

Parameters:

encodedRegionName - The region to get the number for.

familyName - The family to get the number for.

Returns:

The earliest/lowest/oldest sequence id if present, HConstants.NO_SEQNUM if absent.

rollWriter

public byte[][] rollWriter()
                    throws FailedLogCloseException,
                           IOException

Description copied from interface: WAL

Roll the log writer. That is, start writing log messages to a new file.

The implementation is synchronized in order to make sure there's one rollWriter running at any given time.

Specified by:

rollWriter in interface WAL

Returns:

If lots of logs, flush the returned regions so next time through we can clean logs. Returns null if nothing to flush. Names are actual region names as returned by RegionInfo.getEncodedName()

Throws:

FailedLogCloseException

IOException

computeFilename

protected org.apache.hadoop.fs.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 org.apache.hadoop.fs.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 org.apache.hadoop.fs.Path getWALArchivePath(org.apache.hadoop.fs.Path archiveDir,
                                                          org.apache.hadoop.fs.Path p)

logRollAndSetupWalProps

protected final void logRollAndSetupWalProps(org.apache.hadoop.fs.Path oldPath,
                                             org.apache.hadoop.fs.Path newPath,
                                             long oldFileLen)

blockOnSync

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

Throws:

IOException

rollWriter

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

Description copied from interface: WAL

Roll the log writer. That is, start writing log messages to a new file.

The implementation is synchronized in order to make sure there's one rollWriter running at any given time.

Specified by:

rollWriter in interface WAL

Parameters:

force - If true, force creation of a new writer even if no entries have been written to the current writer

Returns:

If lots of logs, flush the returned regions so next time through we can clean logs. Returns null if nothing to flush. Names are actual region names as returned by RegionInfo.getEncodedName()

Throws:

FailedLogCloseException

IOException

getLogFileSize

public long getLogFileSize()

Returns:

the size of log files in use

requestLogRoll

public void requestLogRoll()

shutdown

public void shutdown()
              throws IOException

Description copied from interface: WAL

Stop accepting new writes. If we have unsynced writes still in buffer, sync them. Extant edits are left in place in backing storage to be replayed later.

Specified by:

shutdown in interface WAL

Throws:

IOException

close

public void close()
           throws IOException

Description copied from interface: WAL

Caller no longer needs any edits from this WAL. Implementers are free to reclaim underlying resources after this call; i.e. filesystem based WALs can archive or delete files.

Specified by:

close in interface Closeable

Specified by:

close in interface AutoCloseable

Specified by:

close in interface WAL

Throws:

IOException

updateStore

public void updateStore(byte[] encodedRegionName,
                        byte[] familyName,
                        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

Specified by:

updateStore in interface WAL

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 IOException

Throws:

IOException

postSync

protected final void postSync(long timeInNanos,
                              int handlerSyncs)

stampSequenceIdAndPublishToRingBuffer

protected final long stampSequenceIdAndPublishToRingBuffer(RegionInfo hri,
                                                           WALKeyImpl key,
                                                           WALEdit edits,
                                                           boolean inMemstore,
                                                           com.lmax.disruptor.RingBuffer<org.apache.hadoop.hbase.regionserver.wal.RingBufferTruck> ringBuffer)
                                                    throws IOException

Throws:

IOException

toString

public String toString()

Description copied from interface: WAL

Human readable identifying information about the state of this WAL. Implementors are encouraged to include information appropriate for debugging. Consumers are advised not to rely on the details of the returned String; it does not have a defined structure.

Specified by:

toString in interface WAL

Overrides:

toString in class Object

getLogFileSizeIfBeingWritten

public OptionalLong getLogFileSizeIfBeingWritten(org.apache.hadoop.fs.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.

Specified by:

getLogFileSizeIfBeingWritten in interface WALFileLengthProvider

append

public abstract long append(RegionInfo info,
                            WALKeyImpl key,
                            WALEdit edits,
                            boolean inMemstore)
                     throws 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.

Specified by:

append in interface WAL

Parameters:

info - the regioninfo associated with append

key - Modified by this call; we add to it this edits region edit/sequence id.

edits - Edits to append. MAY CONTAIN NO EDITS for case where we want to get an edit sequence id that is after all currently appended edits.

inMemstore - Always true except for case where we are writing a compaction completion record into the WAL; in this case the entry is just so we can finish an unfinished compaction -- it is not an edit for memstore.

Returns:

Returns a 'transaction id' and key will have the region edit/sequence id in it.

Throws:

IOException

doAppend

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

Throws:

IOException

createWriterInstance

protected abstract W createWriterInstance(org.apache.hadoop.fs.Path path)
                                   throws IOException,
                                          CommonFSUtils.StreamLacksCapabilityException

Throws:

IOException

CommonFSUtils.StreamLacksCapabilityException

doReplaceWriter

protected abstract void doReplaceWriter(org.apache.hadoop.fs.Path oldPath,
                                        org.apache.hadoop.fs.Path newPath,
                                        W nextWriter)
                                 throws IOException

Throws:

IOException

doShutdown

protected abstract void doShutdown()
                            throws IOException

Throws:

IOException

doCheckLogLowReplication

protected abstract boolean doCheckLogLowReplication()

checkLogLowReplication

public void checkLogLowReplication(long checkInterval)

main

public static void main(String[] args)
                 throws 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:

IOException