org.apache.hadoop.hbase.replication.regionserver

Class SerialReplicationChecker

java.lang.Object

org.apache.hadoop.hbase.replication.regionserver.SerialReplicationChecker

@InterfaceAudience.Private
class SerialReplicationChecker
extends Object

Helper class to determine whether we can push a given WAL entry without breaking the replication order. The class is designed to per ReplicationSourceWALReader, so not thread safe.

We record all the open sequence number for a region in a special family in meta, which is called 'rep_barrier', so there will be a sequence of open sequence number (b1, b2, b3, ...). We call [bn, bn+1) a range, and it is obvious that a region will always be on the same RS within a range.

When split and merge, we will also record the parent for the generated region(s) in the special family in meta. And also, we will write an extra 'open sequence number' for the parent region(s), which is the max sequence id of the region plus one.

For each peer, we record the last pushed sequence id for each region. It is managed by the replication storage.

The algorithm works like this:

1. Locate the sequence id we want to push in the barriers
2. If it is before the first barrier, we are safe to push. This usually because we enable serial replication for this table after we create the table and write data into the table.
3. In general, if the previous range is finished, then we are safe to push. The way to determine whether a range is finish is straight-forward: check whether the last pushed sequence id is equal to the end barrier of the range minus 1. There are several exceptions:
   • If it is in the first range, we need to check whether there are parent regions. If so, we need to make sure that the data for parent regions have all been pushed.
   • If it is in the last range, we need to check the region state. If state is OPENING, then we are not safe to push. This is because that, before we call reportRIT to master which update the open sequence number into meta table, we will write a open region event marker to WAL first, and its sequence id is greater than the newest open sequence number(which has not been updated to meta table yet so we do not know). For this scenario, the WAL entry for this open region event marker actually belongs to the range after the 'last' range, so we are not safe to push it. Otherwise the last pushed sequence id will be updated to this value and then we think the previous range has already been finished, but this is not true.
   • Notice that the above two exceptions are not conflicts, since the first range can also be the last range if we only have one range.

And for performance reason, we do not want to check meta for every WAL entry, so we introduce two in memory maps. The idea is simple:

• If a range can be pushed, then put its end barrier into the canPushUnder map.
• Before accessing meta, first check the sequence id stored in the canPushUnder map. If the sequence id of WAL entry is less the one stored in canPushUnder map, then we are safe to push.

And for the last range, we do not have an end barrier, so we use the continuity of sequence id to determine whether we can push. The rule is:

• When an entry is able to push, then put its sequence id into the pushed map.
• Check if the sequence id of WAL entry equals to the one stored in the pushed map plus one. If so, we are safe to push, and also update the pushed map with the sequence id of the WAL entry.

Field Summary

Fields

Modifier and Type	Field and Description
private org.apache.hbase.thirdparty.com.google.common.cache.Cache<String,Long>	canPushUnder
private Connection	conn
private static org.slf4j.Logger	LOG
private String	peerId
private org.apache.hbase.thirdparty.com.google.common.cache.LoadingCache<String,org.apache.commons.lang3.mutable.MutableLong>	pushed
static long	REPLICATION_SERIALLY_WAITING_DEFAULT
static String	REPLICATION_SERIALLY_WAITING_KEY
private ReplicationQueueStorage	storage
private long	waitTimeMs

Constructor Summary

Constructors

Constructor and Description
SerialReplicationChecker(org.apache.hadoop.conf.Configuration conf, ReplicationSource source)

Method Summary

Modifier and Type	Method and Description
private boolean	canPush(WAL.Entry entry, byte[] row)
boolean	canPush(WAL.Entry entry, Cell firstCellInEdit)
private boolean	isLastRangeAndOpening(MetaTableAccessor.ReplicationBarrierResult barrierResult, int index)
private boolean	isParentFinished(byte[] regionName)
private boolean	isRangeFinished(long endBarrier, String encodedRegionName)
private void	recordCanPush(String encodedNameAsString, long seqId, long[] barriers, int index)
void	waitUntilCanPush(WAL.Entry entry, Cell firstCellInEdit)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

LOG

private static final org.slf4j.Logger LOG

REPLICATION_SERIALLY_WAITING_KEY

public static final String REPLICATION_SERIALLY_WAITING_KEY

See Also:

Constant Field Values

REPLICATION_SERIALLY_WAITING_DEFAULT

public static final long REPLICATION_SERIALLY_WAITING_DEFAULT

See Also:

Constant Field Values

peerId

private final String peerId

storage

private final ReplicationQueueStorage storage

conn

private final Connection conn

waitTimeMs

private final long waitTimeMs

pushed

private final org.apache.hbase.thirdparty.com.google.common.cache.LoadingCache<String,org.apache.commons.lang3.mutable.MutableLong> pushed

canPushUnder

private final org.apache.hbase.thirdparty.com.google.common.cache.Cache<String,Long> canPushUnder

Constructor Detail

SerialReplicationChecker

public SerialReplicationChecker(org.apache.hadoop.conf.Configuration conf,
                                ReplicationSource source)

Method Detail

isRangeFinished

private boolean isRangeFinished(long endBarrier,
                                String encodedRegionName)
                         throws IOException

Throws:

IOException

isParentFinished

private boolean isParentFinished(byte[] regionName)
                          throws IOException

Throws:

IOException

isLastRangeAndOpening

private boolean isLastRangeAndOpening(MetaTableAccessor.ReplicationBarrierResult barrierResult,
                                      int index)

recordCanPush

private void recordCanPush(String encodedNameAsString,
                           long seqId,
                           long[] barriers,
                           int index)

canPush

private boolean canPush(WAL.Entry entry,
                        byte[] row)
                 throws IOException

Throws:

IOException

canPush

public boolean canPush(WAL.Entry entry,
                       Cell firstCellInEdit)
                throws IOException

Throws:

IOException

waitUntilCanPush

public void waitUntilCanPush(WAL.Entry entry,
                             Cell firstCellInEdit)
                      throws IOException,
                             InterruptedException

Throws:

IOException

InterruptedException