org.apache.hadoop.hbase.regionserver.wal

Class FSHLog

java.lang.Object

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

org.apache.hadoop.hbase.regionserver.wal.FSHLog

All Implemented Interfaces:

Closeable, AutoCloseable, WALFileLengthProvider, WAL

@InterfaceAudience.Private
public class FSHLog
extends AbstractFSWAL<WALProvider.Writer>

The default implementation of FSWAL.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
(package private) class	FSHLog.RingBufferEventHandler Handler that is run by the disruptor ringbuffer consumer.
(package private) static class	FSHLog.RingBufferExceptionHandler Exception handler to pass the disruptor ringbuffer.
(package private) static class	FSHLog.SafePointZigZagLatch This class is used coordinating two threads holding one thread at a 'safe point' while the orchestrating thread does some work that requires the first thread paused: e.g.
private class	FSHLog.SyncRunner Thread to runs the hdfs sync call.

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
private AtomicInteger	closeErrorCount
private int	closeErrorsTolerated Number of log close errors tolerated before we abort
private AtomicInteger	consecutiveLogRolls
private com.lmax.disruptor.dsl.Disruptor<RingBufferTruck>	disruptor The nexus at which all incoming handlers meet.
static long	FIXED_OVERHEAD
private org.apache.hadoop.fs.FSDataOutputStream	hdfs_out FSDataOutputStream associated with the current SequenceFile.writer
private static org.slf4j.Logger	LOG
private boolean	lowReplicationRollEnabled
private int	lowReplicationRollLimit
private int	minTolerableReplication
private FSHLog.RingBufferEventHandler	ringBufferEventHandler This fellow is run by the above appendExecutor service but it is all about batching up appends and syncs; it may shutdown without cleaning out the last few appends or syncs.

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, LOG_NAME_COMPARATOR, logrollsize, maxLogs, numEntries, ourFiles, prefixPathStr, rollRequested, rollWriterLock, sequenceIdAccounting, shutdown, slowSyncNs, totalLogSize, walArchiveDir, walDir, walFile2Props, walFilePrefix, walFileSuffix, writer

Constructor Summary

Constructors

Constructor and Description
FSHLog(org.apache.hadoop.fs.FileSystem fs, org.apache.hadoop.fs.Path root, String logDir, org.apache.hadoop.conf.Configuration conf) Constructor.
FSHLog(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) Create an edit log at the given dir location.

Method Summary

Modifier and Type	Method and Description
protected void	afterCreatingZigZagLatch() Used to manufacture race condition reliably.
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 void	beforeWaitOnSafePoint()
private void	checkLogRoll() Schedule a log roll if needed.
protected WALProvider.Writer	createWriterInstance(org.apache.hadoop.fs.Path path) This method allows subclasses to inject different writers without having to extend other methods like rollWriter().
protected void	doAppend(WALProvider.Writer writer, FSWALEntry entry)
protected boolean	doCheckLogLowReplication()
protected void	doReplaceWriter(org.apache.hadoop.fs.Path oldPath, org.apache.hadoop.fs.Path newPath, WALProvider.Writer nextWriter) Notice that you need to clear the AbstractFSWAL.rollRequested flag in this method, as the new writer will begin to work before returning from this method.
protected void	doShutdown()
(package private) int	getLogReplication() This method gets the datanode replication count for the current WAL.
(package private) OutputStream	getOutputStream() Currently, we need to expose the writer's OutputStream to tests so that they can manipulate the default behavior (such as setting the maxRecoveryErrorCount value).
(package private) org.apache.hadoop.hdfs.protocol.DatanodeInfo[]	getPipeline() This method gets the pipeline for the current WAL.
protected long	getSequenceOnRingBuffer()
(package private) boolean	isLowReplicationRollEnabled()
private void	preemptiveSync(ProtobufLogWriter nextWriter) Run a sync after opening to set up the pipeline.
private SyncFuture	publishSyncOnRingBuffer()
protected SyncFuture	publishSyncOnRingBuffer(long sequence)
private void	publishSyncThenBlockOnCompletion(org.apache.htrace.core.TraceScope scope)
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, findRegionsToForceFlush, getCoprocessorHost, getCurrentFileName, getEarliestMemStoreSeqNum, getEarliestMemStoreSeqNum, getFilenum, getFileNumFromFileName, getFiles, getLogFileSize, getLogFileSizeIfBeingWritten, getNumLogFiles, getNumRolledLogFiles, getOldPath, getPreallocatedEventCount, getSyncFuture, getUnflushedEntriesCount, getWALArchivePath, isLogRollRequested, isUnflushedEntries, logRollAndSetupWalProps, main, postSync, registerWALActionsListener, replaceWriter, 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

Field Detail

LOG

private static final org.slf4j.Logger LOG

disruptor

private final com.lmax.disruptor.dsl.Disruptor<RingBufferTruck> disruptor

The nexus at which all incoming handlers meet. Does appends and sync with an ordering. Appends and syncs are each put on the ring which means handlers need to smash up against the ring twice (can we make it once only? ... maybe not since time to append is so different from time to sync and sometimes we don't want to sync or we want to async the sync). The ring is where we make sure of our ordering and it is also where we do batching up of handler sync calls.

ringBufferEventHandler

private final FSHLog.RingBufferEventHandler ringBufferEventHandler

This fellow is run by the above appendExecutor service but it is all about batching up appends and syncs; it may shutdown without cleaning out the last few appends or syncs. To guard against this, keep a reference to this handler and do explicit close on way out to make sure all flushed out before we exit.

hdfs_out

private org.apache.hadoop.fs.FSDataOutputStream hdfs_out

FSDataOutputStream associated with the current SequenceFile.writer

minTolerableReplication

private final int minTolerableReplication

consecutiveLogRolls

private final AtomicInteger consecutiveLogRolls

lowReplicationRollLimit

private final int lowReplicationRollLimit

lowReplicationRollEnabled

private volatile boolean lowReplicationRollEnabled

closeErrorsTolerated

private final int closeErrorsTolerated

Number of log close errors tolerated before we abort

closeErrorCount

private final AtomicInteger closeErrorCount

FIXED_OVERHEAD

public static final long FIXED_OVERHEAD

Constructor Detail

FSHLog

public FSHLog(org.apache.hadoop.fs.FileSystem fs,
              org.apache.hadoop.fs.Path root,
              String logDir,
              org.apache.hadoop.conf.Configuration conf)
       throws IOException

Constructor.

Parameters:

fs - filesystem handle

root - path for stored and archived wals

logDir - dir where wals are stored

conf - configuration to use

Throws:

IOException

FSHLog

public FSHLog(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 IOException

Create an edit log at the given dir location. You should never have to load an existing log. If there is a log at startup, it should have already been processed and deleted by the time the WAL object is started up.

Parameters:

fs - filesystem handle

rootDir - path to where logs and oldlogs

logDir - dir where wals are stored

archiveDir - dir where wals are archived

conf - configuration to use

listeners - Listeners on WAL events. Listeners passed here will be registered before we do anything else; e.g. the Constructor AbstractFSWAL.rollWriter().

failIfWALExists - If true IOException will be thrown if files related to this wal already exist.

prefix - should always be hostname and port in distributed env and it will be URL encoded before being used. If prefix is null, "wal" will be used

suffix - will be url encoded. null is treated as empty. non-empty must start with AbstractFSWALProvider.WAL_FILE_NAME_DELIMITER

Throws:

IOException

Method Detail

getOutputStream

OutputStream getOutputStream()

Currently, we need to expose the writer's OutputStream to tests so that they can manipulate the default behavior (such as setting the maxRecoveryErrorCount value). This is done using reflection on the underlying HDFS OutputStream. NOTE: This could be removed once Hadoop1 support is removed.

Returns:

null if underlying stream is not ready.

preemptiveSync

private void preemptiveSync(ProtobufLogWriter nextWriter)

Run a sync after opening to set up the pipeline.

createWriterInstance

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

This method allows subclasses to inject different writers without having to extend other methods like rollWriter().

Specified by:

createWriterInstance in class AbstractFSWAL<WALProvider.Writer>

Returns:

Writer instance

Throws:

IOException

afterCreatingZigZagLatch

protected void afterCreatingZigZagLatch()

Used to manufacture race condition reliably. For testing only.

See Also:

beforeWaitOnSafePoint()

beforeWaitOnSafePoint

protected void beforeWaitOnSafePoint()

See Also:

afterCreatingZigZagLatch()

doAppend

protected void doAppend(WALProvider.Writer writer,
                        FSWALEntry entry)
                 throws IOException

Specified by:

doAppend in class AbstractFSWAL<WALProvider.Writer>

Throws:

IOException

doReplaceWriter

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

Description copied from class: AbstractFSWAL

Notice that you need to clear the AbstractFSWAL.rollRequested flag in this method, as the new writer will begin to work before returning from this method. If we clear the flag after returning from this call, we may miss a roll request. The implementation class should choose a proper place to clear the AbstractFSWAL.rollRequested flag so we do not miss a roll request, typically before you start writing to the new writer.

Specified by:

doReplaceWriter in class AbstractFSWAL<WALProvider.Writer>

Throws:

IOException

doShutdown

protected void doShutdown()
                   throws IOException

Specified by:

doShutdown in class AbstractFSWAL<WALProvider.Writer>

Throws:

IOException

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

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

checkLogRoll

private void checkLogRoll()

Schedule a log roll if needed.

doCheckLogLowReplication

protected boolean doCheckLogLowReplication()

Specified by:

doCheckLogLowReplication in class AbstractFSWAL<WALProvider.Writer>

Returns:

true if number of replicas for the WAL is lower than threshold

getSequenceOnRingBuffer

protected long getSequenceOnRingBuffer()

publishSyncOnRingBuffer

private SyncFuture publishSyncOnRingBuffer()

publishSyncOnRingBuffer

protected SyncFuture publishSyncOnRingBuffer(long sequence)

publishSyncThenBlockOnCompletion

private void publishSyncThenBlockOnCompletion(org.apache.htrace.core.TraceScope scope)
                                       throws IOException

Throws:

IOException

getLogReplication

int getLogReplication()

This method gets the datanode replication count for the current WAL.

If the pipeline isn't started yet or is empty, you will get the default replication factor. Therefore, if this function returns 0, it means you are not properly running with the HDFS-826 patch.

Specified by:

getLogReplication in class AbstractFSWAL<WALProvider.Writer>

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

isLowReplicationRollEnabled

boolean isLowReplicationRollEnabled()

getPipeline

org.apache.hadoop.hdfs.protocol.DatanodeInfo[] getPipeline()

This method gets the pipeline for the current WAL.

Specified by:

getPipeline in class AbstractFSWAL<WALProvider.Writer>