org.apache.hadoop.hbase.wal

Interface WAL

All Known Implementing Classes:

FaultyFSLog, FSHLog

@InterfaceAudience.Private
 @InterfaceStability.Evolving
public interface WAL

A Write Ahead Log (WAL) provides service for reading, writing waledits. This interface provides APIs for WAL users (such as RegionServer) to use the WAL (do append, sync, etc). Note that some internals, such as log rolling and performance evaluation tools, will use WAL.equals to determine if they have already seen a given WAL.

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	WAL.Entry Utility class that lets us keep track of the edit with it's key.
static interface	WAL.Reader When outside clients need to consume persisted WALs, they rely on a provided Reader.

Method Summary

Modifier and Type	Method and Description
void	abortCacheFlush(byte[] encodedRegionName) Abort a cache flush.
long	append(HTableDescriptor htd, HRegionInfo info, WALKey key, WALEdit edits, AtomicLong sequenceId, boolean inMemstore, List<Cell> memstoreKVs) Append a set of edits to the WAL.
void	close() Caller no longer needs any edits from this WAL.
void	completeCacheFlush(byte[] encodedRegionName) Complete the cache flush.
WALCoprocessorHost	getCoprocessorHost()
long	getEarliestMemstoreSeqNum(byte[] encodedRegionName) Deprecated. Since version 1.1.1. Removing because not used and exposes subtle internal workings. Use getEarliestMemstoreSeqNum(byte[], byte[])
long	getEarliestMemstoreSeqNum(byte[] encodedRegionName, byte[] familyName) Gets the earliest sequence number in the memstore for this particular region and store.
void	registerWALActionsListener(WALActionsListener listener) Registers WALActionsListener
byte[][]	rollWriter() Roll the log writer.
byte[][]	rollWriter(boolean force) Roll the log writer.
void	shutdown() Stop accepting new writes.
Long	startCacheFlush(byte[] encodedRegionName, Set<byte[]> flushedFamilyNames) 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.
void	sync() Sync what we have in the WAL.
void	sync(long txid) Sync the WAL if the txId was not already sync'd.
String	toString() Human readable identifying information about the state of this WAL.
boolean	unregisterWALActionsListener(WALActionsListener listener) Unregisters WALActionsListener

Method Detail

registerWALActionsListener

void registerWALActionsListener(WALActionsListener listener)

Registers WALActionsListener

unregisterWALActionsListener

boolean unregisterWALActionsListener(WALActionsListener listener)

Unregisters WALActionsListener

rollWriter

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

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.

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 HRegionInfo.getEncodedName()

Throws:

FailedLogCloseException

IOException

rollWriter

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

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.

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 HRegionInfo.getEncodedName()

Throws:

FailedLogCloseException

IOException

shutdown

void shutdown()
       throws IOException

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.

Throws:

IOException

close

void close()
    throws IOException

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.

Throws:

IOException

append

long append(HTableDescriptor htd,
            HRegionInfo info,
            WALKey key,
            WALEdit edits,
            AtomicLong sequenceId,
            boolean inMemstore,
            List<Cell> memstoreKVs)
     throws IOException

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.

Parameters:

info -

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.

htd - used to give scope for replication TODO refactor out in favor of table name and info

sequenceId - A reference to the atomic long the info region is using as source of its incrementing edits sequence id. Inside in this call we will increment it and attach the sequence to the edit we apply the WAL.

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.

memstoreKVs - list of KVs added into memstore

Returns:

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

Throws:

IOException

sync

void sync()
   throws IOException

Sync what we have in the WAL.

Throws:

IOException

sync

void sync(long txid)
   throws IOException

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

Parameters:

txid - Transaction id to sync to.

Throws:

IOException

startCacheFlush

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

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.

Parameters:

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:

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

completeCacheFlush

void completeCacheFlush(byte[] encodedRegionName)

Complete the cache flush.

Parameters:

encodedRegionName - Encoded region name.

abortCacheFlush

void abortCacheFlush(byte[] encodedRegionName)

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

Parameters:

encodedRegionName - Encoded region name.

getCoprocessorHost

WALCoprocessorHost getCoprocessorHost()

Returns:

Coprocessor host.

getEarliestMemstoreSeqNum

@Deprecated
long getEarliestMemstoreSeqNum(byte[] encodedRegionName)

Deprecated. Since version 1.1.1. Removing because not used and exposes subtle internal workings. Use getEarliestMemstoreSeqNum(byte[], byte[])

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

Parameters:

encodedRegionName - The region to get the number for.

Returns:

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

getEarliestMemstoreSeqNum

long getEarliestMemstoreSeqNum(byte[] encodedRegionName,
                               byte[] familyName)

Gets the earliest sequence number in the memstore for this particular region and store.

Parameters:

encodedRegionName - The region to get the number for.

familyName - The family to get the number for.

Returns:

The number if present, HConstants.NO_SEQNUM if absent.

toString

String toString()

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.

Overrides:

toString in class Object