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

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 static int	DEFAULT_FSHLOG_WAIT_ON_SHUTDOWN_IN_SECONDS
private static int	DEFAULT_LOW_REPLICATION_ROLL_LIMIT
private static int	DEFAULT_MAX_BATCH_COUNT
private static int	DEFAULT_ROLL_ERRORS_TOLERATED
private static int	DEFAULT_SYNCER_COUNT
private com.lmax.disruptor.dsl.Disruptor<RingBufferTruck>	disruptor The nexus at which all incoming handlers meet.
static long	FIXED_OVERHEAD
private static String	FSHLOG_WAIT_ON_SHUTDOWN_IN_SECONDS
private org.apache.hadoop.fs.FSDataOutputStream	hdfs_out FSDataOutputStream associated with the current SequenceFile.writer
private static org.slf4j.Logger	LOG
private static String	LOW_REPLICATION_ROLL_LIMIT
private boolean	lowReplicationRollEnabled
private int	lowReplicationRollLimit
private static String	MAX_BATCH_COUNT
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.
private static String	ROLL_ERRORS_TOLERATED
private static String	SYNCER_COUNT
private static String	TOLERABLE_LOW_REPLICATION
private int	waitOnShutdownInSeconds

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

abortable, blocksize, closed, closeExecutor, conf, coprocessorHost, DEFAULT_ROLL_ON_SYNC_TIME_MS, DEFAULT_SLOW_SYNC_ROLL_INTERVAL_MS, DEFAULT_SLOW_SYNC_ROLL_THRESHOLD, DEFAULT_SLOW_SYNC_TIME_MS, DEFAULT_WAL_SHUTDOWN_WAIT_TIMEOUT_MS, DEFAULT_WAL_SYNC_TIMEOUT_MS, filenum, fs, highestSyncedTxid, highestUnsyncedTxid, implClassName, inflightWALClosures, listeners, LOG_NAME_COMPARATOR, logrollsize, MAX_LOGS, maxLogs, numEntries, ourFiles, prefixPathStr, RING_BUFFER_SLOT_COUNT, ROLL_ON_SYNC_TIME_MS, rollOnSyncNs, rollRequested, rollWriterLock, sequenceIdAccounting, shutdown, SLOW_SYNC_ROLL_INTERVAL_MS, SLOW_SYNC_ROLL_THRESHOLD, SLOW_SYNC_TIME_MS, slowSyncCheckInterval, slowSyncCount, slowSyncNs, slowSyncRollThreshold, syncFutureCache, totalLogSize, useHsync, WAL_ROLL_MULTIPLIER, WAL_SHUTDOWN_WAIT_TIMEOUT_MS, WAL_SYNC_TIMEOUT_MS, walArchiveDir, walDir, walFile2Props, walFilePrefix, walFileSuffix, walShutdownTimeout, writer

Constructor Summary

Constructors

Constructor and Description
FSHLog(org.apache.hadoop.fs.FileSystem fs, Abortable abortable, org.apache.hadoop.fs.Path root, String logDir, org.apache.hadoop.conf.Configuration conf)
FSHLog(org.apache.hadoop.fs.FileSystem fs, Abortable abortable, 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.
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)

Method Summary

Modifier and Type	Method and Description
protected void	afterCreatingZigZagLatch() Used to manufacture race condition reliably.
protected long	append(RegionInfo hri, WALKeyImpl key, WALEdit edits, boolean inMemstore) Append a set of edits to the WAL.
protected void	beforeWaitOnSafePoint()
private boolean	checkLogRoll() Schedule a log roll if needed.
private void	closeWriter(WALProvider.Writer writer, org.apache.hadoop.fs.Path path, boolean syncCloseCall)
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() Returns true if number of replicas for the WAL is lower than threshold
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()
protected void	doSync(boolean forceSync)
protected void	doSync(long txid, boolean forceSync)
(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) WALProvider.Writer	getWriter()
(package private) boolean	isLowReplicationRollEnabled()
private void	preemptiveSync(ProtobufLogWriter nextWriter) Run a sync after opening to set up the pipeline.
private SyncFuture	publishSyncOnRingBuffer(boolean forceSync)
protected SyncFuture	publishSyncOnRingBuffer(long sequence, boolean forceSync)
private void	publishSyncThenBlockOnCompletion(boolean forceSync)
(package private) void	setWriter(WALProvider.Writer writer)

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

abortCacheFlush, appendData, appendEntry, appendMarker, archive, archiveLogFile, atHeadOfRingBufferEventHandlerAppend, blockOnSync, checkLogLowReplication, close, completeCacheFlush, computeFilename, doCheckSlowSync, findRegionsToForceFlush, getCoprocessorHost, getCurrentFileName, getEarliestMemStoreSeqNum, getEarliestMemStoreSeqNum, getFilenum, getFileNumFromFileName, getFiles, getInflightWALCloseCount, getLogFileSize, getLogFileSizeIfBeingWritten, getNumLogFiles, getNumRolledLogFiles, getOldPath, getPreallocatedEventCount, getSyncFuture, getUnflushedEntriesCount, getWALArchivePath, init, isLogRollRequested, isUnflushedEntries, logRollAndSetupWalProps, main, markClosedAndClean, postSync, registerWALActionsListener, replaceWriter, requestLogRoll, requestLogRoll, rollWriter, rollWriter, shutdown, stampSequenceIdAndPublishToRingBuffer, startCacheFlush, startCacheFlush, sync, sync, sync, sync, 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

TOLERABLE_LOW_REPLICATION

private static final String TOLERABLE_LOW_REPLICATION

See Also:

Constant Field Values

LOW_REPLICATION_ROLL_LIMIT

private static final String LOW_REPLICATION_ROLL_LIMIT

See Also:

Constant Field Values

DEFAULT_LOW_REPLICATION_ROLL_LIMIT

private static final int DEFAULT_LOW_REPLICATION_ROLL_LIMIT

See Also:

Constant Field Values

ROLL_ERRORS_TOLERATED

private static final String ROLL_ERRORS_TOLERATED

See Also:

Constant Field Values

DEFAULT_ROLL_ERRORS_TOLERATED

private static final int DEFAULT_ROLL_ERRORS_TOLERATED

See Also:

Constant Field Values

SYNCER_COUNT

private static final String SYNCER_COUNT

See Also:

Constant Field Values

DEFAULT_SYNCER_COUNT

private static final int DEFAULT_SYNCER_COUNT

See Also:

Constant Field Values

MAX_BATCH_COUNT

private static final String MAX_BATCH_COUNT

See Also:

Constant Field Values

DEFAULT_MAX_BATCH_COUNT

private static final int DEFAULT_MAX_BATCH_COUNT

See Also:

Constant Field Values

FSHLOG_WAIT_ON_SHUTDOWN_IN_SECONDS

private static final String FSHLOG_WAIT_ON_SHUTDOWN_IN_SECONDS

See Also:

Constant Field Values

DEFAULT_FSHLOG_WAIT_ON_SHUTDOWN_IN_SECONDS

private static final int DEFAULT_FSHLOG_WAIT_ON_SHUTDOWN_IN_SECONDS

See Also:

Constant Field Values

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

waitOnShutdownInSeconds

private final int waitOnShutdownInSeconds

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,
              Abortable abortable,
              org.apache.hadoop.fs.Path root,
              String logDir,
              org.apache.hadoop.conf.Configuration conf)
       throws IOException

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

Throws:

IOException

FSHLog

public FSHLog(org.apache.hadoop.fs.FileSystem fs,
              Abortable abortable,
              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

abortable - Abortable - the server here

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

closeWriter

private void closeWriter(WALProvider.Writer writer,
                         org.apache.hadoop.fs.Path path,
                         boolean syncCloseCall)
                  throws IOException

Throws:

IOException

doShutdown

protected void doShutdown()
                   throws IOException

Specified by:

doShutdown in class AbstractFSWAL<WALProvider.Writer>

Throws:

IOException

append

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

Description copied from class: AbstractFSWAL

Append a set of edits to the WAL.

The WAL is not flushed/sync'd after this transaction completes BUT on return this edit must have its region edit/sequence id assigned else it messes up our unification of mvcc and sequenceid. On return key will have the region edit/sequence id filled in.

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 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 region event meta marker edit, for example, a compaction completion record into the WAL or noting a Region Open event. In these cases the entry is just so we can finish an unfinished compaction after a crash when the new Server reads the WAL on recovery, etc. These transition event 'Markers' do not go via the memstore. When memstore is false, we presume a Marker event edit.

Returns:

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

Throws:

IOException

checkLogRoll

private boolean checkLogRoll()

Schedule a log roll if needed.

doCheckLogLowReplication

protected boolean doCheckLogLowReplication()

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

Specified by:

doCheckLogLowReplication in class AbstractFSWAL<WALProvider.Writer>

getSequenceOnRingBuffer

protected long getSequenceOnRingBuffer()

publishSyncOnRingBuffer

private SyncFuture publishSyncOnRingBuffer(boolean forceSync)

publishSyncOnRingBuffer

protected SyncFuture publishSyncOnRingBuffer(long sequence,
                                             boolean forceSync)

publishSyncThenBlockOnCompletion

private void publishSyncThenBlockOnCompletion(boolean forceSync)
                                       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>

doSync

protected void doSync(boolean forceSync)
               throws IOException

Specified by:

doSync in class AbstractFSWAL<WALProvider.Writer>

Throws:

IOException

doSync

protected void doSync(long txid,
                      boolean forceSync)
               throws IOException

Specified by:

doSync in class AbstractFSWAL<WALProvider.Writer>

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>

getWriter

WALProvider.Writer getWriter()

setWriter

void setWriter(WALProvider.Writer writer)