DisabledWALProvider.DisabledWAL (Apache HBase 1.2.12 API)

java.lang.Object
- org.apache.hadoop.hbase.wal.DisabledWALProvider.DisabledWAL

All Implemented Interfaces:

Closeable, AutoCloseable, WAL

Enclosing class:

DisabledWALProvider
```
private static class DisabledWALProvider.DisabledWAL
extends Object
implements WAL
```

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 AtomicBoolean`	`closed`
`protected WALCoprocessorHost`	`coprocessorHost`
`protected List<WALActionsListener>`	`listeners`
`protected org.apache.hadoop.fs.Path`	`path`

Constructor Summary

Constructors
Constructor and Description
`DisabledWALProvider.DisabledWAL(org.apache.hadoop.fs.Path path, org.apache.hadoop.conf.Configuration conf, List<WALActionsListener> listeners)`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`abortCacheFlush(byte[] encodedRegionName)` Abort a cache flush.
`long`	`append(HTableDescriptor htd, HRegionInfo info, WALKey key, WALEdit edits, boolean inMemstore)` 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)` 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.
`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

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - listeners
```
protected final List<WALActionsListener> listeners
```
  - path
```
protected final org.apache.hadoop.fs.Path path
```
  - coprocessorHost
```
protected final WALCoprocessorHost coprocessorHost
```
  - closed
```
protected final AtomicBoolean closed
```
- Constructor Detail
  - DisabledWALProvider.DisabledWAL
```
public DisabledWALProvider.DisabledWAL(org.apache.hadoop.fs.Path path,
                               org.apache.hadoop.conf.Configuration conf,
                               List<WALActionsListener> listeners)
```
- Method Detail
  - 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
  - rollWriter
```
public byte[][] rollWriter()
```
    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 HRegionInfo.getEncodedName()
  - rollWriter
```
public byte[][] rollWriter(boolean force)
```
    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 HRegionInfo.getEncodedName()
  - shutdown
```
public void shutdown()
```
    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
  - close
```
public void close()
```
    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
  - append
```
public long append(HTableDescriptor htd,
          HRegionInfo info,
          WALKey key,
          WALEdit edits,
          boolean inMemstore)
            throws IOException
```
    Description copied from interface: WAL
    
    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.
    
    Specified by:
    
    append in interface WAL
    
    Parameters:
    htd - used to give scope for replication TODO refactor out in favor of table name and 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.
    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()
```
    Description copied from interface: WAL
    
    Sync what we have in the WAL.
    
    Specified by:
    
    sync in interface WAL
  - sync
```
public void sync(long txid)
```
    Description copied from interface: WAL
    
    Sync the WAL if the txId was not already sync'd.
    
    Specified by:
    
    sync in interface WAL
    
    Parameters:
    txid - Transaction id to sync to.
  - startCacheFlush
```
public Long startCacheFlush(byte[] encodedRegionName,
                   Set<byte[]> flushedFamilyNames)
```
    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
    
    flushedFamilyNames - 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[])
  - 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.
  - getCoprocessorHost
```
public WALCoprocessorHost getCoprocessorHost()
```
    Specified by:
    
    getCoprocessorHost in interface WAL
    
    Returns:
    Coprocessor host.
  - 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.
  - 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

Class DisabledWALProvider.DisabledWAL

Nested Class Summary

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

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

listeners

path

coprocessorHost

closed

Constructor Detail

DisabledWALProvider.DisabledWAL

Method Detail

registerWALActionsListener

unregisterWALActionsListener

rollWriter

rollWriter

shutdown

close

append

sync

sync

startCacheFlush

completeCacheFlush

abortCacheFlush

getCoprocessorHost

getEarliestMemstoreSeqNum

getEarliestMemstoreSeqNum

toString