org.apache.hadoop.hbase.regionserver.wal

Class AsyncFSWAL

java.lang.Object

org.apache.hadoop.hbase.regionserver.wal.AbstractFSWAL<WALProvider.AsyncWriter>

org.apache.hadoop.hbase.regionserver.wal.AsyncFSWAL

All Implemented Interfaces:

Closeable, AutoCloseable, WALFileLengthProvider, WAL

@InterfaceAudience.LimitedPrivate(value="Configuration")
public class AsyncFSWAL
extends AbstractFSWAL<WALProvider.AsyncWriter>

An asynchronous implementation of FSWAL.

Here 'waitingConsumePayloads' acts as the RingBuffer in FSHLog.

For append, we process it as follow:

1. In the caller thread(typically, in the rpc handler thread):
   1. Insert the entry into 'waitingConsumePayloads'. Use ringbuffer sequence as txid.
   2. Schedule the consumer task if needed. See shouldScheduleConsumer() for more details.
2. In the consumer task(executed in a single threaded thread pool)
   1. Poll the entry from waitingConsumePayloads and insert it into toWriteAppends
   2. Poll the entry from toWriteAppends, append it to the AsyncWriter, and insert it into unackedAppends
   3. If the buffered size reaches batchSize, or there is a sync request, then we call sync on the AsyncWriter.
   4. In the callback methods:
      • If succeeded, poll the entry from unackedAppends and drop it.
      • If failed, add all the entries in unackedAppends back to toWriteAppends and wait for writing them again.

For sync, the processing stages are almost same. And different from FSHLog, we will open a new writer and rewrite unacked entries to the new writer and sync again if we hit a sync error.

Here we only describe the logic of doReplaceWriter. The main logic of rollWriter is same with FSHLog.
For a normal roll request(for example, we have reached the log roll size):

1. In the log roller thread, we will set waitingRoll(int) to true and readyForRolling to false, and then wait on readyForRolling(see waitForSafePoint()).
2. In the consumer thread, we will stop polling entries from waitingConsumePayloads if waitingRoll(int) is true, and also stop writing the entries in toWriteAppends out.
3. If there are unflush data in the writer, sync them.
4. When all out-going sync request is finished, i.e, the unackedAppends is empty, signal the readyForRollingCond.
5. Back to the log roller thread, now we can confirm that there are no out-going entries, i.e., we reach a safe point. So it is safe to replace old writer with new writer now.
6. Set writerBroken(int) and waitingRoll(int) to false.
7. Schedule the consumer task.
8. Schedule a background task to close the old writer.

For a broken writer roll request, the only difference is that we can bypass the wait for safe point stage.

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
static String	ASYNC_WAL_USE_SHARED_EVENT_LOOP
static String	ASYNC_WAL_WAIT_ON_SHUTDOWN_IN_SECONDS
static boolean	DEFAULT_ASYNC_WAL_USE_SHARED_EVENT_LOOP
static int	DEFAULT_ASYNC_WAL_WAIT_ON_SHUTDOWN_IN_SECONDS
static long	DEFAULT_WAL_BATCH_SIZE
static String	WAL_BATCH_SIZE

Fields inherited from class org.apache.hadoop.hbase.regionserver.wal.AbstractFSWAL

blocksize, closed, conf, coprocessorHost, DEFAULT_SLOW_SYNC_TIME_MS, filenum, fs, highestSyncedTxid, highestUnsyncedTxid, implClassName, listeners, logrollsize, maxLogs, numEntries, ourFiles, prefixPathStr, rollWriterLock, sequenceIdAccounting, shutdown, slowSyncNs, totalLogSize, walArchiveDir, walDir, walFile2Props, walFilePrefix, walFileSuffix

Constructor Summary

Constructors

Constructor and Description

AsyncFSWAL(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, org.apache.hbase.thirdparty.io.netty.channel.EventLoopGroup eventLoopGroup, Class<? extends org.apache.hbase.thirdparty.io.netty.channel.Channel> channelClass)

Method Summary

Modifier and Type	Method and Description
long	append(RegionInfo hri, 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 WALProvider.AsyncWriter	createWriterInstance(org.apache.hadoop.fs.Path path)
protected void	doAppend(WALProvider.AsyncWriter writer, org.apache.hadoop.hbase.regionserver.wal.FSWALEntry entry)
protected boolean	doCheckLogLowReplication()
protected void	doReplaceWriter(org.apache.hadoop.fs.Path oldPath, org.apache.hadoop.fs.Path newPath, WALProvider.AsyncWriter nextWriter)
protected void	doShutdown()
void	sync() Sync what we have in the WAL.
void	sync(long txid) Sync the WAL if the txId was not already sync'd.

Methods inherited from class org.apache.hadoop.hbase.regionserver.wal.AbstractFSWAL

abortCacheFlush, append, atHeadOfRingBufferEventHandlerAppend, blockOnSync, checkLogLowReplication, close, completeCacheFlush, computeFilename, getCoprocessorHost, getCurrentFileName, getEarliestMemStoreSeqNum, getEarliestMemStoreSeqNum, getFilenum, getFileNumFromFileName, getLogFileSize, getLogFileSizeIfBeingWritten, getNumLogFiles, getNumRolledLogFiles, getPreallocatedEventCount, getSyncFuture, getWALArchivePath, logRollAndSetupWalProps, main, postSync, registerWALActionsListener, requestLogRoll, requestLogRoll, rollWriter, rollWriter, shutdown, stampSequenceIdAndPublishToRingBuffer, startCacheFlush, startCacheFlush, toString, unregisterWALActionsListener, updateStore

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

WAL_BATCH_SIZE

public static final String WAL_BATCH_SIZE

See Also:

Constant Field Values

DEFAULT_WAL_BATCH_SIZE

public static final long DEFAULT_WAL_BATCH_SIZE

See Also:

Constant Field Values

ASYNC_WAL_USE_SHARED_EVENT_LOOP

public static final String ASYNC_WAL_USE_SHARED_EVENT_LOOP

See Also:

Constant Field Values

DEFAULT_ASYNC_WAL_USE_SHARED_EVENT_LOOP

public static final boolean DEFAULT_ASYNC_WAL_USE_SHARED_EVENT_LOOP

See Also:

Constant Field Values

ASYNC_WAL_WAIT_ON_SHUTDOWN_IN_SECONDS

public static final String ASYNC_WAL_WAIT_ON_SHUTDOWN_IN_SECONDS

See Also:

Constant Field Values

DEFAULT_ASYNC_WAL_WAIT_ON_SHUTDOWN_IN_SECONDS

public static final int DEFAULT_ASYNC_WAL_WAIT_ON_SHUTDOWN_IN_SECONDS

See Also:

Constant Field Values

Constructor Detail

AsyncFSWAL

public AsyncFSWAL(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,
                  org.apache.hbase.thirdparty.io.netty.channel.EventLoopGroup eventLoopGroup,
                  Class<? extends org.apache.hbase.thirdparty.io.netty.channel.Channel> channelClass)
           throws FailedLogCloseException,
                  IOException

Throws:

FailedLogCloseException

IOException

Method Detail

append

public long append(RegionInfo hri,
                   WALKeyImpl key,
                   WALEdit edits,
                   boolean inMemstore)
            throws IOException

Description copied from class: AbstractFSWAL

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

Specified by:

append in class AbstractFSWAL<WALProvider.AsyncWriter>

Parameters:

hri - 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

sync

public void sync()
          throws IOException

Description copied from interface: WAL

Sync what we have in the WAL.

Throws:

IOException

sync

public void sync(long txid)
          throws IOException

Description copied from interface: WAL

Sync the WAL if the txId was not already sync'd.

Parameters:

txid - Transaction id to sync to.

Throws:

IOException

createWriterInstance

protected WALProvider.AsyncWriter createWriterInstance(org.apache.hadoop.fs.Path path)
                                                throws IOException

Specified by:

createWriterInstance in class AbstractFSWAL<WALProvider.AsyncWriter>

Throws:

IOException

doReplaceWriter

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

Specified by:

doReplaceWriter in class AbstractFSWAL<WALProvider.AsyncWriter>

Throws:

IOException

doShutdown

protected void doShutdown()
                   throws IOException

Specified by:

doShutdown in class AbstractFSWAL<WALProvider.AsyncWriter>

Throws:

IOException

doAppend

protected void doAppend(WALProvider.AsyncWriter writer,
                        org.apache.hadoop.hbase.regionserver.wal.FSWALEntry entry)

Specified by:

doAppend in class AbstractFSWAL<WALProvider.AsyncWriter>

doCheckLogLowReplication

protected boolean doCheckLogLowReplication()

Specified by:

doCheckLogLowReplication in class AbstractFSWAL<WALProvider.AsyncWriter>