org.apache.hadoop.hbase.io.hfile

Class HFileBlock

java.lang.Object

org.apache.hadoop.hbase.io.hfile.HFileBlock

All Implemented Interfaces:

HeapSize, Cacheable

@InterfaceAudience.Private
public class HFileBlock
extends Object
implements Cacheable

Cacheable Blocks of an HFile version 2 file. Version 2 was introduced in hbase-0.92.0.

Version 1 was the original file block. Version 2 was introduced when we changed the hbase file format to support multi-level block indexes and compound bloom filters (HBASE-3857). Support for Version 1 was removed in hbase-1.3.0.

HFileBlock: Version 2

In version 2, a block is structured as follows:

• Header: See Writer#putHeader() for where header is written; header total size is HFILEBLOCK_HEADER_SIZE
  • 0. blockType: Magic record identifying the BlockType (8 bytes): e.g. DATABLK*
  • 1. onDiskSizeWithoutHeader: Compressed -- a.k.a 'on disk' -- block size, excluding header, but including tailing checksum bytes (4 bytes)
  • 2. uncompressedSizeWithoutHeader: Uncompressed block size, excluding header, and excluding checksum bytes (4 bytes)
  • 3. prevBlockOffset: The offset of the previous block of the same type (8 bytes). This is used to navigate to the previous block without having to go to the block index
  • 4: For minorVersions >=1, the ordinal describing checksum type (1 byte)
  • 5: For minorVersions >=1, the number of data bytes/checksum chunk (4 bytes)
  • 6: onDiskDataSizeWithHeader: For minorVersions >=1, the size of data 'on disk', including header, excluding checksums (4 bytes)
• Raw/Compressed/Encrypted/Encoded data: The compression algorithm is the same for all the blocks in an HFile. If compression is NONE, this is just raw, serialized Cells.
• Tail: For minorVersions >=1, a series of 4 byte checksums, one each for the number of bytes specified by bytesPerChecksum.

Caching

Caches cache whole blocks with trailing checksums if any. We then tag on some metadata, the content of BLOCK_METADATA_SPACE which will be flag on if we are doing 'hbase' checksums and then the offset into the file which is needed when we re-make a cache key when we return the block to the cache as 'done'. See Cacheable.serialize(ByteBuffer, boolean) and Cacheable.getDeserializer().

TODO: Should we cache the checksums? Down in Writer#getBlockForCaching(CacheConfig) where we make a block to cache-on-write, there is an attempt at turning off checksums. This is not the only place we get blocks to cache. We also will cache the raw return from an hdfs read. In this case, the checksums may be present. If the cache is backed by something that doesn't do ECC, say an SSD, we might want to preserve checksums. For now this is open question.

TODO: Over in BucketCache, we save a block allocation by doing a custom serialization. Be sure to change it if serialization changes in here. Could we add a method here that takes an IOEngine and that then serializes to it rather than expose our internals over in BucketCache? IOEngine is in the bucket subpackage. Pull it up? Then this class knows about bucketcache. Ugh.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
(package private) static interface	HFileBlock.BlockIterator Iterator for HFileBlocks.
(package private) static interface	HFileBlock.BlockWritable Something that can be written into a block.
(package private) static interface	HFileBlock.FSReader An HFile block reader with iteration ability.
(package private) static class	HFileBlock.FSReaderImpl Reads version 2 HFile blocks from the filesystem.
(package private) static class	HFileBlock.Header
private static class	HFileBlock.PrefetchedHeader Data-structure to use caching the header of the NEXT block.
(package private) static class	HFileBlock.Writer Unified version 2 HFile block writer.

Nested classes/interfaces inherited from interface org.apache.hadoop.hbase.io.hfile.Cacheable

Cacheable.MemoryType

Field Summary

Fields

Modifier and Type	Field and Description
(package private) static CacheableDeserializer<Cacheable>	BLOCK_DESERIALIZER Used deserializing blocks from Cache.
(package private) static int	BLOCK_METADATA_SPACE Space for metadata on a block that gets stored along with the block when we cache it.
private BlockType	blockType Type of block.
private ByteBuff	buf The in-memory representation of the hfile block.
(package private) static int	CHECKSUM_SIZE Each checksum value is an integer that can be stored in 4 bytes.
(package private) static int	CHECKSUM_VERIFICATION_NUM_IO_THRESHOLD On a checksum failure, do these many succeeding read requests using hdfs checksums before auto-reenabling hbase checksum verification.
private static int	DESERIALIZER_IDENTIFIER
static boolean	DONT_FILL_HEADER
(package private) static byte[]	DUMMY_HEADER_NO_CHECKSUM
private HFileContext	fileContext Meta data that holds meta information on the hfileblock.
static boolean	FILL_HEADER
private static org.slf4j.Logger	LOG
private Cacheable.MemoryType	memType
static int	MULTI_BYTE_BUFFER_HEAP_SIZE
private int	nextBlockOnDiskSize The on-disk size of the next block, including the header and checksums if present.
private long	offset The offset of this block in the file.
private int	onDiskDataSizeWithHeader Size on disk of header + data.
private int	onDiskSizeWithoutHeader Size on disk excluding header, including checksum.
private long	prevBlockOffset The offset of the previous block on disk.
private int	uncompressedSizeWithoutHeader Size of pure data.
private static int	UNSET

Constructor Summary

Constructors

Modifier	Constructor and Description
	HFileBlock(BlockType blockType, int onDiskSizeWithoutHeader, int uncompressedSizeWithoutHeader, long prevBlockOffset, ByteBuffer b, boolean fillHeader, long offset, int nextBlockOnDiskSize, int onDiskDataSizeWithHeader, HFileContext fileContext) Creates a new HFile block from the given fields.
(package private)	HFileBlock(ByteBuff buf, boolean usesHBaseChecksum, Cacheable.MemoryType memType, long offset, int nextBlockOnDiskSize, HFileContext fileContext) Creates a block from an existing buffer starting with a header.
private	HFileBlock(HFileBlock that) Copy constructor.
private	HFileBlock(HFileBlock that, boolean bufCopy) Copy constructor.

Method Summary

Modifier and Type	Method and Description
private ByteBuffer	addMetaData(ByteBuffer destination, boolean includeNextBlockMetadata) Adds metadata at current position (position is moved forward).
private void	allocateBuffer() Always allocates a new buffer of the correct size.
HFileBlock	deepClone()
boolean	equals(Object comparison)
BlockType	getBlockType()
ByteBuff	getBufferReadOnly() Returns a read-only duplicate of the buffer this block stores internally ready to be read.
ByteBuff	getBufferWithoutHeader() Returns a buffer that does not include the header or checksum.
(package private) int	getBytesPerChecksum()
(package private) DataInputStream	getByteStream()
(package private) byte	getChecksumType()
(package private) DataBlockEncoding	getDataBlockEncoding()
(package private) short	getDataBlockEncodingId()
CacheableDeserializer<Cacheable>	getDeserializer() Returns CacheableDeserializer instance which reconstructs original object from ByteBuffer.
(package private) byte[]	getDummyHeaderForVersion() Return the appropriate DUMMY_HEADER for the minor version
private static byte[]	getDummyHeaderForVersion(boolean usesHBaseChecksum) Return the appropriate DUMMY_HEADER for the minor version
(package private) HFileContext	getHFileContext()
Cacheable.MemoryType	getMemoryType()
ByteBuffer	getMetaData() For use by bucketcache.
(package private) int	getNextBlockOnDiskSize()
(package private) long	getOffset() Cannot be UNSET.
(package private) int	getOnDiskDataSizeWithHeader()
int	getOnDiskSizeWithHeader()
private static int	getOnDiskSizeWithHeader(ByteBuffer headerBuf, boolean verifyChecksum) Parse total on disk size including header and checksum.
(package private) int	getOnDiskSizeWithoutHeader()
(package private) long	getPrevBlockOffset()
int	getSerializedLength() Returns the length of the ByteBuffer required to serialized the object.
(package private) int	getUncompressedSizeWithoutHeader()
int	hashCode()
int	headerSize() Returns the size of this block header.
static int	headerSize(boolean usesHBaseChecksum) Maps a minor version to the size of the header.
long	heapSize()
private void	init(BlockType blockType, int onDiskSizeWithoutHeader, int uncompressedSizeWithoutHeader, long prevBlockOffset, long offset, int onDiskDataSizeWithHeader, int nextBlockOnDiskSize, HFileContext fileContext) Called from constructors.
boolean	isUnpacked() Return true when this block's buffer has been unpacked, false otherwise.
private void	overwriteHeader() Rewinds buf and writes first 4 header fields.
(package private) static boolean	positionalReadWithExtra(org.apache.hadoop.fs.FSDataInputStream in, long position, byte[] buf, int bufOffset, int necessaryLen, int extraLen) Read from an input stream at least necessaryLen and if possible, extraLen also if available.
(package private) static boolean	readWithExtra(InputStream in, byte[] buf, int bufOffset, int necessaryLen, int extraLen) Read from an input stream at least necessaryLen and if possible, extraLen also if available.
(package private) void	sanityCheck() Checks if the block is internally consistent, i.e.
private void	sanityCheckAssertion(BlockType valueFromBuf, BlockType valueFromField)
private void	sanityCheckAssertion(long valueFromBuf, long valueFromField, String fieldName)
(package private) void	sanityCheckUncompressed() An additional sanity-check in case no compression or encryption is being used.
(package private) void	sanityCheckUncompressedSize() An additional sanity-check in case no compression or encryption is being used.
void	serialize(ByteBuffer destination, boolean includeNextBlockMetadata) Serializes its data into destination.
String	toString()
(package private) static String	toStringHeader(ByteBuff buf) Convert the contents of the block header into a human readable string.
(package private) int	totalChecksumBytes() Calculate the number of bytes required to store all the checksums for this block.
(package private) HFileBlock	unpack(HFileContext fileContext, HFileBlock.FSReader reader) Retrieves the decompressed/decrypted view of this block.
(package private) boolean	usesSharedMemory()

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Field Detail

LOG

private static final org.slf4j.Logger LOG

blockType

private BlockType blockType

Type of block. Header field 0.

onDiskSizeWithoutHeader

private int onDiskSizeWithoutHeader

Size on disk excluding header, including checksum. Header field 1.

See Also:

HFileBlock.Writer.putHeader(byte[], int, int, int, int)

uncompressedSizeWithoutHeader

private int uncompressedSizeWithoutHeader

Size of pure data. Does not include header or checksums. Header field 2.

See Also:

HFileBlock.Writer.putHeader(byte[], int, int, int, int)

prevBlockOffset

private long prevBlockOffset

The offset of the previous block on disk. Header field 3.

See Also:

HFileBlock.Writer.putHeader(byte[], int, int, int, int)

onDiskDataSizeWithHeader

private int onDiskDataSizeWithHeader

Size on disk of header + data. Excludes checksum. Header field 6, OR calculated from onDiskSizeWithoutHeader when using HDFS checksum.

See Also:

HFileBlock.Writer.putHeader(byte[], int, int, int, int)

buf

private ByteBuff buf

The in-memory representation of the hfile block. Can be on or offheap. Can be backed by a single ByteBuffer or by many. Make no assumptions.

Be careful reading from this buf. Duplicate and work on the duplicate or if not, be sure to reset position and limit else trouble down the road.

TODO: Make this read-only once made.

We are using the ByteBuff type. ByteBuffer is not extensible yet we need to be able to have a ByteBuffer-like API across multiple ByteBuffers reading from a cache such as BucketCache. So, we have this ByteBuff type. Unfortunately, it is spread all about HFileBlock. Would be good if could be confined to cache-use only but hard-to-do.

fileContext

private HFileContext fileContext

Meta data that holds meta information on the hfileblock.

offset

private long offset

The offset of this block in the file. Populated by the reader for convenience of access. This offset is not part of the block header.

memType

private Cacheable.MemoryType memType

nextBlockOnDiskSize

private int nextBlockOnDiskSize

The on-disk size of the next block, including the header and checksums if present. UNSET if unknown. Blocks try to carry the size of the next block to read in this data member. Usually we get block sizes from the hfile index but sometimes the index is not available: e.g. when we read the indexes themselves (indexes are stored in blocks, we do not have an index for the indexes). Saves seeks especially around file open when there is a flurry of reading in hfile metadata.

CHECKSUM_VERIFICATION_NUM_IO_THRESHOLD

static final int CHECKSUM_VERIFICATION_NUM_IO_THRESHOLD

On a checksum failure, do these many succeeding read requests using hdfs checksums before auto-reenabling hbase checksum verification.

See Also:

Constant Field Values

UNSET

private static int UNSET

FILL_HEADER

public static final boolean FILL_HEADER

See Also:

Constant Field Values

DONT_FILL_HEADER

public static final boolean DONT_FILL_HEADER

See Also:

Constant Field Values

MULTI_BYTE_BUFFER_HEAP_SIZE

public static final int MULTI_BYTE_BUFFER_HEAP_SIZE

BLOCK_METADATA_SPACE

static final int BLOCK_METADATA_SPACE

Space for metadata on a block that gets stored along with the block when we cache it. There are a few bytes stuck on the end of the HFileBlock that we pull in from HDFS. 8 bytes are for the offset of this block (long) in the file. Offset is important because is is used when we remake the CacheKey when we return block to the cache when done. There is also a flag on whether checksumming is being done by hbase or not. See class comment for note on uncertain state of checksumming of blocks that come out of cache (should we or should we not?). Finally there are 4 bytes to hold the length of the next block which can save a seek on occasion if available. (This EXTRA info came in with original commit of the bucketcache, HBASE-7404. It was formerly known as EXTRA_SERIALIZATION_SPACE).

See Also:

Constant Field Values

CHECKSUM_SIZE

static final int CHECKSUM_SIZE

Each checksum value is an integer that can be stored in 4 bytes.

See Also:

Constant Field Values

DUMMY_HEADER_NO_CHECKSUM

static final byte[] DUMMY_HEADER_NO_CHECKSUM

BLOCK_DESERIALIZER

static final CacheableDeserializer<Cacheable> BLOCK_DESERIALIZER

Used deserializing blocks from Cache. ++++++++++++++ + HFileBlock + ++++++++++++++ + Checksums + <= Optional ++++++++++++++ + Metadata! + <= See note on BLOCK_METADATA_SPACE above. ++++++++++++++

See Also:

#serialize(ByteBuffer)

DESERIALIZER_IDENTIFIER

private static final int DESERIALIZER_IDENTIFIER

Constructor Detail

HFileBlock

private HFileBlock(HFileBlock that)

Copy constructor. Creates a shallow copy of that's buffer.

HFileBlock

private HFileBlock(HFileBlock that,
                   boolean bufCopy)

Copy constructor. Creates a shallow/deep copy of that's buffer as per the boolean param.

HFileBlock

public HFileBlock(BlockType blockType,
                  int onDiskSizeWithoutHeader,
                  int uncompressedSizeWithoutHeader,
                  long prevBlockOffset,
                  ByteBuffer b,
                  boolean fillHeader,
                  long offset,
                  int nextBlockOnDiskSize,
                  int onDiskDataSizeWithHeader,
                  HFileContext fileContext)

Creates a new HFile block from the given fields. This constructor is used only while writing blocks and caching, and is sitting in a byte buffer and we want to stuff the block into cache. See HFileBlock.Writer.getBlockForCaching(CacheConfig).

TODO: The caller presumes no checksumming required of this block instance since going into cache; checksum already verified on underlying block data pulled in from filesystem. Is that correct? What if cache is SSD?

Parameters:

blockType - the type of this block, see BlockType

onDiskSizeWithoutHeader - see onDiskSizeWithoutHeader

uncompressedSizeWithoutHeader - see uncompressedSizeWithoutHeader

prevBlockOffset - see prevBlockOffset

b - block header (HConstants.HFILEBLOCK_HEADER_SIZE bytes)

fillHeader - when true, write the first 4 header fields into passed buffer.

offset - the file offset the block was read from

onDiskDataSizeWithHeader - see onDiskDataSizeWithHeader

fileContext - HFile meta data

HFileBlock

HFileBlock(ByteBuff buf,
           boolean usesHBaseChecksum,
           Cacheable.MemoryType memType,
           long offset,
           int nextBlockOnDiskSize,
           HFileContext fileContext)
    throws IOException

Creates a block from an existing buffer starting with a header. Rewinds and takes ownership of the buffer. By definition of rewind, ignores the buffer position, but if you slice the buffer beforehand, it will rewind to that point.

Parameters:

buf - Has header, content, and trailing checksums if present.

Throws:

IOException

Method Detail

init

private void init(BlockType blockType,
                  int onDiskSizeWithoutHeader,
                  int uncompressedSizeWithoutHeader,
                  long prevBlockOffset,
                  long offset,
                  int onDiskDataSizeWithHeader,
                  int nextBlockOnDiskSize,
                  HFileContext fileContext)

Called from constructors.

getOnDiskSizeWithHeader

private static int getOnDiskSizeWithHeader(ByteBuffer headerBuf,
                                           boolean verifyChecksum)

Parse total on disk size including header and checksum.

Parameters:

headerBuf - Header ByteBuffer. Presumed exact size of header.

verifyChecksum - true if checksum verification is in use.

Returns:

Size of the block with header included.

getNextBlockOnDiskSize

int getNextBlockOnDiskSize()

Returns:

the on-disk size of the next block (including the header size and any checksums if present) read by peeking into the next block's header; use as a hint when doing a read of the next block when scanning or running over a file.

getBlockType

public BlockType getBlockType()

Specified by:

getBlockType in interface Cacheable

Returns:

the block type of this cached HFile block

getDataBlockEncodingId

short getDataBlockEncodingId()

Returns:

get data block encoding id that was used to encode this block

getOnDiskSizeWithHeader

public int getOnDiskSizeWithHeader()

Returns:

the on-disk size of header + data part + checksum.

getOnDiskSizeWithoutHeader

int getOnDiskSizeWithoutHeader()

Returns:

the on-disk size of the data part + checksum (header excluded).

getUncompressedSizeWithoutHeader

int getUncompressedSizeWithoutHeader()

Returns:

the uncompressed size of data part (header and checksum excluded).

getPrevBlockOffset

long getPrevBlockOffset()

Returns:

the offset of the previous block of the same type in the file, or -1 if unknown

overwriteHeader

private void overwriteHeader()

Rewinds buf and writes first 4 header fields. buf position is modified as side-effect.

getBufferWithoutHeader

public ByteBuff getBufferWithoutHeader()

Returns a buffer that does not include the header or checksum.

Returns:

the buffer with header skipped and checksum omitted.

getBufferReadOnly

public ByteBuff getBufferReadOnly()

Returns a read-only duplicate of the buffer this block stores internally ready to be read. Clients must not modify the buffer object though they may set position and limit on the returned buffer since we pass back a duplicate. This method has to be public because it is used in CompoundBloomFilter to avoid object creation on every Bloom filter lookup, but has to be used with caution. Buffer holds header, block content, and any follow-on checksums if present.

Returns:

the buffer of this block for read-only operations

sanityCheckAssertion

private void sanityCheckAssertion(long valueFromBuf,
                                  long valueFromField,
                                  String fieldName)
                           throws IOException

Throws:

IOException

sanityCheckAssertion

private void sanityCheckAssertion(BlockType valueFromBuf,
                                  BlockType valueFromField)
                           throws IOException

Throws:

IOException

sanityCheck

void sanityCheck()
          throws IOException

Checks if the block is internally consistent, i.e. the first HConstants.HFILEBLOCK_HEADER_SIZE bytes of the buffer contain a valid header consistent with the fields. Assumes a packed block structure. This function is primary for testing and debugging, and is not thread-safe, because it alters the internal buffer pointer. Used by tests only.

Throws:

IOException

toString

public String toString()

Overrides:

toString in class Object

unpack

HFileBlock unpack(HFileContext fileContext,
                  HFileBlock.FSReader reader)
           throws IOException

Retrieves the decompressed/decrypted view of this block. An encoded block remains in its encoded structure. Internal structures are shared between instances where applicable.

Throws:

IOException

allocateBuffer

private void allocateBuffer()

Always allocates a new buffer of the correct size. Copies header bytes from the existing buffer. Does not change header fields. Reserve room to keep checksum bytes too.

isUnpacked

public boolean isUnpacked()

Return true when this block's buffer has been unpacked, false otherwise. Note this is a calculated heuristic, not tracked attribute of the block.

sanityCheckUncompressedSize

void sanityCheckUncompressedSize()
                          throws IOException

An additional sanity-check in case no compression or encryption is being used.

Throws:

IOException

getOffset

long getOffset()

Cannot be UNSET. Must be a legitimate value. Used re-making the BlockCacheKey when block is returned to the cache.

Returns:

the offset of this block in the file it was read from

getByteStream

DataInputStream getByteStream()

Returns:

a byte stream reading the data + checksum of this block

heapSize

public long heapSize()

Specified by:

heapSize in interface HeapSize

Returns:

Approximate 'exclusive deep size' of implementing object. Includes count of payload and hosting object sizings.

readWithExtra

static boolean readWithExtra(InputStream in,
                             byte[] buf,
                             int bufOffset,
                             int necessaryLen,
                             int extraLen)
                      throws IOException

Read from an input stream at least necessaryLen and if possible, extraLen also if available. Analogous to IOUtils.readFully(InputStream, byte[], int, int), but specifies a number of "extra" bytes to also optionally read.

Parameters:

in - the input stream to read from

buf - the buffer to read into

bufOffset - the destination offset in the buffer

necessaryLen - the number of bytes that are absolutely necessary to read

extraLen - the number of extra bytes that would be nice to read

Returns:

true if succeeded reading the extra bytes

Throws:

IOException - if failed to read the necessary bytes

positionalReadWithExtra

static boolean positionalReadWithExtra(org.apache.hadoop.fs.FSDataInputStream in,
                                       long position,
                                       byte[] buf,
                                       int bufOffset,
                                       int necessaryLen,
                                       int extraLen)
                                throws IOException

Read from an input stream at least necessaryLen and if possible, extraLen also if available. Analogous to IOUtils.readFully(InputStream, byte[], int, int), but uses positional read and specifies a number of "extra" bytes that would be desirable but not absolutely necessary to read.

Parameters:

in - the input stream to read from

position - the position within the stream from which to start reading

buf - the buffer to read into

bufOffset - the destination offset in the buffer

necessaryLen - the number of bytes that are absolutely necessary to read

extraLen - the number of extra bytes that would be nice to read

Returns:

true if and only if extraLen is > 0 and reading those extra bytes was successful

Throws:

IOException - if failed to read the necessary bytes

sanityCheckUncompressed

void sanityCheckUncompressed()
                      throws IOException

An additional sanity-check in case no compression or encryption is being used.

Throws:

IOException

getSerializedLength

public int getSerializedLength()

Description copied from interface: Cacheable

Returns the length of the ByteBuffer required to serialized the object. If the object cannot be serialized, it should return 0.

Specified by:

getSerializedLength in interface Cacheable

Returns:

int length in bytes of the serialized form or 0 if the object cannot be cached.

serialize

public void serialize(ByteBuffer destination,
                      boolean includeNextBlockMetadata)

Description copied from interface: Cacheable

Serializes its data into destination.

Specified by:

serialize in interface Cacheable

Parameters:

destination - Where to serialize to

includeNextBlockMetadata - Whether to include nextBlockMetadata in the Cache block.

getMetaData

public ByteBuffer getMetaData()

For use by bucketcache. This exposes internals.

addMetaData

private ByteBuffer addMetaData(ByteBuffer destination,
                               boolean includeNextBlockMetadata)

Adds metadata at current position (position is moved forward). Does not flip or reset.

Returns:

The passed destination with metadata added.

getDeserializer

public CacheableDeserializer<Cacheable> getDeserializer()

Description copied from interface: Cacheable

Returns CacheableDeserializer instance which reconstructs original object from ByteBuffer.

Specified by:

getDeserializer in interface Cacheable

Returns:

CacheableDeserialzer instance.

hashCode

public int hashCode()

Overrides:

hashCode in class Object

equals

public boolean equals(Object comparison)

Overrides:

equals in class Object

getDataBlockEncoding

DataBlockEncoding getDataBlockEncoding()

getChecksumType

byte getChecksumType()

getBytesPerChecksum

int getBytesPerChecksum()

getOnDiskDataSizeWithHeader

int getOnDiskDataSizeWithHeader()

Returns:

the size of data on disk + header. Excludes checksum.

totalChecksumBytes

int totalChecksumBytes()

Calculate the number of bytes required to store all the checksums for this block. Each checksum value is a 4 byte integer.

headerSize

public int headerSize()

Returns the size of this block header.

headerSize

public static int headerSize(boolean usesHBaseChecksum)

Maps a minor version to the size of the header.

getDummyHeaderForVersion

byte[] getDummyHeaderForVersion()

Return the appropriate DUMMY_HEADER for the minor version

getDummyHeaderForVersion

private static byte[] getDummyHeaderForVersion(boolean usesHBaseChecksum)

Return the appropriate DUMMY_HEADER for the minor version

getHFileContext

HFileContext getHFileContext()

Returns:

This HFileBlocks fileContext which will a derivative of the fileContext for the file from which this block's data was originally read.

getMemoryType

public Cacheable.MemoryType getMemoryType()

Specified by:

getMemoryType in interface Cacheable

Returns:

the MemoryType of this Cacheable

usesSharedMemory

boolean usesSharedMemory()

Returns:

true if this block is backed by a shared memory area(such as that of a BucketCache).

toStringHeader

static String toStringHeader(ByteBuff buf)
                      throws IOException

Convert the contents of the block header into a human readable string. This is mostly helpful for debugging. This assumes that the block has minor version > 0.

Throws:

IOException

deepClone

public HFileBlock deepClone()