You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hbase.apache.org by zh...@apache.org on 2017/07/11 03:54:02 UTC
hbase git commit: HBASE-18348 The implementation of
AsyncTableRegionLocator does not follow the javadoc
Repository: hbase
Updated Branches:
refs/heads/master 43492d2d3 -> f8e892d7a
HBASE-18348 The implementation of AsyncTableRegionLocator does not follow the javadoc
Project: http://git-wip-us.apache.org/repos/asf/hbase/repo
Commit: http://git-wip-us.apache.org/repos/asf/hbase/commit/f8e892d7
Tree: http://git-wip-us.apache.org/repos/asf/hbase/tree/f8e892d7
Diff: http://git-wip-us.apache.org/repos/asf/hbase/diff/f8e892d7
Branch: refs/heads/master
Commit: f8e892d7aaa752db7a835f8969a676a9028c8448
Parents: 43492d2
Author: zhangduo <zh...@apache.org>
Authored: Mon Jul 10 15:47:25 2017 +0800
Committer: zhangduo <zh...@apache.org>
Committed: Tue Jul 11 11:43:35 2017 +0800
----------------------------------------------------------------------
.../hbase/client/AsyncMetaRegionLocator.java | 10 +-
.../hbase/client/AsyncNonMetaRegionLocator.java | 24 +++--
.../hadoop/hbase/client/AsyncRegionLocator.java | 21 ++--
.../client/AsyncTableRegionLocatorImpl.java | 2 +-
.../client/TestAsyncMetaRegionLocator.java | 102 +++++++++++++++++++
.../client/TestAsyncNonMetaRegionLocator.java | 86 ++++++++++++----
...syncNonMetaRegionLocatorConcurrenyLimit.java | 2 +-
7 files changed, 203 insertions(+), 44 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/hbase/blob/f8e892d7/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncMetaRegionLocator.java
----------------------------------------------------------------------
diff --git a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncMetaRegionLocator.java b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncMetaRegionLocator.java
index 6e7dba7..600af34 100644
--- a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncMetaRegionLocator.java
+++ b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncMetaRegionLocator.java
@@ -45,11 +45,13 @@ class AsyncMetaRegionLocator {
this.registry = registry;
}
- CompletableFuture<HRegionLocation> getRegionLocation() {
+ CompletableFuture<HRegionLocation> getRegionLocation(boolean reload) {
for (;;) {
- HRegionLocation metaRegionLocation = this.metaRegionLocation.get();
- if (metaRegionLocation != null) {
- return CompletableFuture.completedFuture(metaRegionLocation);
+ if (!reload) {
+ HRegionLocation metaRegionLocation = this.metaRegionLocation.get();
+ if (metaRegionLocation != null) {
+ return CompletableFuture.completedFuture(metaRegionLocation);
+ }
}
if (LOG.isTraceEnabled()) {
LOG.trace("Meta region location cache is null, try fetching from registry.");
http://git-wip-us.apache.org/repos/asf/hbase/blob/f8e892d7/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncNonMetaRegionLocator.java
----------------------------------------------------------------------
diff --git a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncNonMetaRegionLocator.java b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncNonMetaRegionLocator.java
index 3dc9537..31f369c 100644
--- a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncNonMetaRegionLocator.java
+++ b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncNonMetaRegionLocator.java
@@ -392,22 +392,26 @@ class AsyncNonMetaRegionLocator {
// placed before it. Used for reverse scan. See the comment of
// AsyncRegionLocator.getPreviousRegionLocation.
private CompletableFuture<HRegionLocation> getRegionLocationInternal(TableName tableName,
- byte[] row, RegionLocateType locateType) {
+ byte[] row, RegionLocateType locateType, boolean reload) {
// AFTER should be convert to CURRENT before calling this method
assert !locateType.equals(RegionLocateType.AFTER);
TableCache tableCache = getTableCache(tableName);
- HRegionLocation loc = locateInCache(tableCache, tableName, row, locateType);
- if (loc != null) {
- return CompletableFuture.completedFuture(loc);
+ if (!reload) {
+ HRegionLocation loc = locateInCache(tableCache, tableName, row, locateType);
+ if (loc != null) {
+ return CompletableFuture.completedFuture(loc);
+ }
}
CompletableFuture<HRegionLocation> future;
LocateRequest req;
boolean sendRequest = false;
synchronized (tableCache) {
// check again
- loc = locateInCache(tableCache, tableName, row, locateType);
- if (loc != null) {
- return CompletableFuture.completedFuture(loc);
+ if (!reload) {
+ HRegionLocation loc = locateInCache(tableCache, tableName, row, locateType);
+ if (loc != null) {
+ return CompletableFuture.completedFuture(loc);
+ }
}
req = new LocateRequest(row, locateType);
future = tableCache.allRequests.get(req);
@@ -427,16 +431,16 @@ class AsyncNonMetaRegionLocator {
}
CompletableFuture<HRegionLocation> getRegionLocation(TableName tableName, byte[] row,
- RegionLocateType locateType) {
+ RegionLocateType locateType, boolean reload) {
if (locateType.equals(RegionLocateType.BEFORE)) {
- return getRegionLocationInternal(tableName, row, locateType);
+ return getRegionLocationInternal(tableName, row, locateType, reload);
} else {
// as we know the exact row after us, so we can just create the new row, and use the same
// algorithm to locate it.
if (locateType.equals(RegionLocateType.AFTER)) {
row = createClosestRowAfter(row);
}
- return getRegionLocationInternal(tableName, row, RegionLocateType.CURRENT);
+ return getRegionLocationInternal(tableName, row, RegionLocateType.CURRENT, reload);
}
}
http://git-wip-us.apache.org/repos/asf/hbase/blob/f8e892d7/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncRegionLocator.java
----------------------------------------------------------------------
diff --git a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncRegionLocator.java b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncRegionLocator.java
index 1c65472..1114e2c 100644
--- a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncRegionLocator.java
+++ b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncRegionLocator.java
@@ -79,23 +79,28 @@ class AsyncRegionLocator {
}
CompletableFuture<HRegionLocation> getRegionLocation(TableName tableName, byte[] row,
- RegionLocateType type, long timeoutNs) {
+ RegionLocateType type, boolean reload, long timeoutNs) {
// meta region can not be split right now so we always call the same method.
// Change it later if the meta table can have more than one regions.
CompletableFuture<HRegionLocation> future =
- tableName.equals(META_TABLE_NAME) ? metaRegionLocator.getRegionLocation()
- : nonMetaRegionLocator.getRegionLocation(tableName, row, type);
+ tableName.equals(META_TABLE_NAME) ? metaRegionLocator.getRegionLocation(reload)
+ : nonMetaRegionLocator.getRegionLocation(tableName, row, type, reload);
return withTimeout(future, timeoutNs,
- () -> "Timeout(" + TimeUnit.NANOSECONDS.toMillis(timeoutNs)
- + "ms) waiting for region location for " + tableName + ", row='"
- + Bytes.toStringBinary(row) + "'");
+ () -> "Timeout(" + TimeUnit.NANOSECONDS.toMillis(timeoutNs) +
+ "ms) waiting for region location for " + tableName + ", row='" +
+ Bytes.toStringBinary(row) + "'");
+ }
+
+ CompletableFuture<HRegionLocation> getRegionLocation(TableName tableName, byte[] row,
+ RegionLocateType type, long timeoutNs) {
+ return getRegionLocation(tableName, row, type, false, timeoutNs);
}
static boolean canUpdate(HRegionLocation loc, HRegionLocation oldLoc) {
// Do not need to update if no such location, or the location is newer, or the location is not
// same with us
- return oldLoc != null && oldLoc.getSeqNum() <= loc.getSeqNum()
- && oldLoc.getServerName().equals(loc.getServerName());
+ return oldLoc != null && oldLoc.getSeqNum() <= loc.getSeqNum() &&
+ oldLoc.getServerName().equals(loc.getServerName());
}
static void updateCachedLocation(HRegionLocation loc, Throwable exception,
http://git-wip-us.apache.org/repos/asf/hbase/blob/f8e892d7/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncTableRegionLocatorImpl.java
----------------------------------------------------------------------
diff --git a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncTableRegionLocatorImpl.java b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncTableRegionLocatorImpl.java
index 1986962..4412a3d 100644
--- a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncTableRegionLocatorImpl.java
+++ b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncTableRegionLocatorImpl.java
@@ -45,6 +45,6 @@ class AsyncTableRegionLocatorImpl implements AsyncTableRegionLocator {
@Override
public CompletableFuture<HRegionLocation> getRegionLocation(byte[] row, boolean reload) {
- return locator.getRegionLocation(tableName, row, RegionLocateType.CURRENT, -1L);
+ return locator.getRegionLocation(tableName, row, RegionLocateType.CURRENT, reload, -1L);
}
}
http://git-wip-us.apache.org/repos/asf/hbase/blob/f8e892d7/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAsyncMetaRegionLocator.java
----------------------------------------------------------------------
diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAsyncMetaRegionLocator.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAsyncMetaRegionLocator.java
new file mode 100644
index 0000000..c56305a
--- /dev/null
+++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAsyncMetaRegionLocator.java
@@ -0,0 +1,102 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.hadoop.hbase.client;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.Optional;
+
+import org.apache.commons.io.IOUtils;
+import org.apache.hadoop.hbase.HBaseTestingUtility;
+import org.apache.hadoop.hbase.HRegionInfo;
+import org.apache.hadoop.hbase.ServerName;
+import org.apache.hadoop.hbase.TableName;
+import org.apache.hadoop.hbase.Waiter.ExplainingPredicate;
+import org.apache.hadoop.hbase.master.balancer.BaseLoadBalancer;
+import org.apache.hadoop.hbase.testclassification.ClientTests;
+import org.apache.hadoop.hbase.testclassification.MediumTests;
+import org.apache.hadoop.hbase.util.Bytes;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+@Category({ MediumTests.class, ClientTests.class })
+public class TestAsyncMetaRegionLocator {
+
+ private static final HBaseTestingUtility TEST_UTIL = new HBaseTestingUtility();
+
+ private static AsyncRegistry REGISTRY;
+
+ private static AsyncMetaRegionLocator LOCATOR;
+
+ @BeforeClass
+ public static void setUp() throws Exception {
+ TEST_UTIL.getConfiguration().set(BaseLoadBalancer.TABLES_ON_MASTER, "none");
+ TEST_UTIL.startMiniCluster(3);
+ TEST_UTIL.waitUntilAllSystemRegionsAssigned();
+ TEST_UTIL.getAdmin().setBalancerRunning(false, true);
+ REGISTRY = AsyncRegistryFactory.getRegistry(TEST_UTIL.getConfiguration());
+ LOCATOR = new AsyncMetaRegionLocator(REGISTRY);
+ }
+
+ @AfterClass
+ public static void tearDown() throws Exception {
+ IOUtils.closeQuietly(REGISTRY);
+ TEST_UTIL.shutdownMiniCluster();
+ }
+
+ private Optional<ServerName> getRSCarryingMeta() {
+ return TEST_UTIL.getHBaseCluster().getRegionServerThreads().stream()
+ .map(t -> t.getRegionServer())
+ .filter(rs -> !rs.getOnlineRegions(TableName.META_TABLE_NAME).isEmpty()).findAny()
+ .map(rs -> rs.getServerName());
+ }
+
+ @Test
+ public void testReload() throws Exception {
+ ServerName serverName = getRSCarryingMeta().get();
+ assertEquals(serverName, LOCATOR.getRegionLocation(false).get().getServerName());
+
+ ServerName newServerName = TEST_UTIL.getHBaseCluster().getRegionServerThreads().stream()
+ .map(t -> t.getRegionServer().getServerName()).filter(sn -> !sn.equals(serverName))
+ .findAny().get();
+ TEST_UTIL.getAdmin().move(HRegionInfo.FIRST_META_REGIONINFO.getEncodedNameAsBytes(),
+ Bytes.toBytes(newServerName.getServerName()));
+ TEST_UTIL.waitFor(30000, new ExplainingPredicate<Exception>() {
+
+ @Override
+ public boolean evaluate() throws Exception {
+ Optional<ServerName> newServerName = getRSCarryingMeta();
+ return newServerName.isPresent() && !newServerName.get().equals(serverName);
+ }
+
+ @Override
+ public String explainFailure() throws Exception {
+ return HRegionInfo.FIRST_META_REGIONINFO.getRegionNameAsString() + " is still on " +
+ serverName;
+ }
+ });
+ // The cached location will not change
+ assertEquals(serverName, LOCATOR.getRegionLocation(false).get().getServerName());
+ // should get the new location when reload = true
+ assertEquals(newServerName, LOCATOR.getRegionLocation(true).get().getServerName());
+ // the cached location should be replaced
+ assertEquals(newServerName, LOCATOR.getRegionLocation(false).get().getServerName());
+ }
+}
http://git-wip-us.apache.org/repos/asf/hbase/blob/f8e892d7/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAsyncNonMetaRegionLocator.java
----------------------------------------------------------------------
diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAsyncNonMetaRegionLocator.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAsyncNonMetaRegionLocator.java
index e0a32d1..0bb192b 100644
--- a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAsyncNonMetaRegionLocator.java
+++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAsyncNonMetaRegionLocator.java
@@ -51,6 +51,7 @@ import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.experimental.categories.Category;
+import org.apache.hadoop.hbase.Waiter.ExplainingPredicate;
@Category({ MediumTests.class, ClientTests.class })
public class TestAsyncNonMetaRegionLocator {
@@ -108,7 +109,7 @@ public class TestAsyncNonMetaRegionLocator {
public void testNoTable() throws InterruptedException {
for (RegionLocateType locateType : RegionLocateType.values()) {
try {
- LOCATOR.getRegionLocation(TABLE_NAME, EMPTY_START_ROW, locateType).get();
+ LOCATOR.getRegionLocation(TABLE_NAME, EMPTY_START_ROW, locateType, false).get();
} catch (ExecutionException e) {
assertThat(e.getCause(), instanceOf(TableNotFoundException.class));
}
@@ -121,7 +122,7 @@ public class TestAsyncNonMetaRegionLocator {
TEST_UTIL.getAdmin().disableTable(TABLE_NAME);
for (RegionLocateType locateType : RegionLocateType.values()) {
try {
- LOCATOR.getRegionLocation(TABLE_NAME, EMPTY_START_ROW, locateType).get();
+ LOCATOR.getRegionLocation(TABLE_NAME, EMPTY_START_ROW, locateType, false).get();
} catch (ExecutionException e) {
assertThat(e.getCause(), instanceOf(TableNotFoundException.class));
}
@@ -143,13 +144,13 @@ public class TestAsyncNonMetaRegionLocator {
ServerName serverName = TEST_UTIL.getRSForFirstRegionInTable(TABLE_NAME).getServerName();
for (RegionLocateType locateType : RegionLocateType.values()) {
assertLocEquals(EMPTY_START_ROW, EMPTY_END_ROW, serverName,
- LOCATOR.getRegionLocation(TABLE_NAME, EMPTY_START_ROW, locateType).get());
+ LOCATOR.getRegionLocation(TABLE_NAME, EMPTY_START_ROW, locateType, false).get());
}
byte[] randKey = new byte[ThreadLocalRandom.current().nextInt(128)];
ThreadLocalRandom.current().nextBytes(randKey);
for (RegionLocateType locateType : RegionLocateType.values()) {
assertLocEquals(EMPTY_START_ROW, EMPTY_END_ROW, serverName,
- LOCATOR.getRegionLocation(TABLE_NAME, randKey, locateType).get());
+ LOCATOR.getRegionLocation(TABLE_NAME, randKey, locateType, false).get());
}
}
@@ -191,8 +192,8 @@ public class TestAsyncNonMetaRegionLocator {
IntStream.range(0, 2).forEach(n -> IntStream.range(0, startKeys.length).forEach(i -> {
try {
assertLocEquals(startKeys[i], i == startKeys.length - 1 ? EMPTY_END_ROW : startKeys[i + 1],
- serverNames[i],
- LOCATOR.getRegionLocation(TABLE_NAME, startKeys[i], RegionLocateType.CURRENT).get());
+ serverNames[i], LOCATOR
+ .getRegionLocation(TABLE_NAME, startKeys[i], RegionLocateType.CURRENT, false).get());
} catch (InterruptedException | ExecutionException e) {
throw new RuntimeException(e);
}
@@ -203,7 +204,7 @@ public class TestAsyncNonMetaRegionLocator {
try {
assertLocEquals(startKeys[i], i == startKeys.length - 1 ? EMPTY_END_ROW : startKeys[i + 1],
serverNames[i],
- LOCATOR.getRegionLocation(TABLE_NAME, startKeys[i], RegionLocateType.AFTER).get());
+ LOCATOR.getRegionLocation(TABLE_NAME, startKeys[i], RegionLocateType.AFTER, false).get());
} catch (InterruptedException | ExecutionException e) {
throw new RuntimeException(e);
}
@@ -214,7 +215,8 @@ public class TestAsyncNonMetaRegionLocator {
n -> IntStream.range(0, endKeys.length).map(i -> endKeys.length - 1 - i).forEach(i -> {
try {
assertLocEquals(i == 0 ? EMPTY_START_ROW : endKeys[i - 1], endKeys[i], serverNames[i],
- LOCATOR.getRegionLocation(TABLE_NAME, endKeys[i], RegionLocateType.BEFORE).get());
+ LOCATOR.getRegionLocation(TABLE_NAME, endKeys[i], RegionLocateType.BEFORE, false)
+ .get());
} catch (InterruptedException | ExecutionException e) {
throw new RuntimeException(e);
}
@@ -225,8 +227,8 @@ public class TestAsyncNonMetaRegionLocator {
public void testRegionMove() throws IOException, InterruptedException, ExecutionException {
createSingleRegionTable();
ServerName serverName = TEST_UTIL.getRSForFirstRegionInTable(TABLE_NAME).getServerName();
- HRegionLocation loc =
- LOCATOR.getRegionLocation(TABLE_NAME, EMPTY_START_ROW, RegionLocateType.CURRENT).get();
+ HRegionLocation loc = LOCATOR
+ .getRegionLocation(TABLE_NAME, EMPTY_START_ROW, RegionLocateType.CURRENT, false).get();
assertLocEquals(EMPTY_START_ROW, EMPTY_END_ROW, serverName, loc);
ServerName newServerName = TEST_UTIL.getHBaseCluster().getRegionServerThreads().stream()
.map(t -> t.getRegionServer().getServerName()).filter(sn -> !sn.equals(serverName))
@@ -239,15 +241,15 @@ public class TestAsyncNonMetaRegionLocator {
Thread.sleep(100);
}
// Should be same as it is in cache
- assertSame(loc,
- LOCATOR.getRegionLocation(TABLE_NAME, EMPTY_START_ROW, RegionLocateType.CURRENT).get());
+ assertSame(loc, LOCATOR
+ .getRegionLocation(TABLE_NAME, EMPTY_START_ROW, RegionLocateType.CURRENT, false).get());
LOCATOR.updateCachedLocation(loc, null);
// null error will not trigger a cache cleanup
- assertSame(loc,
- LOCATOR.getRegionLocation(TABLE_NAME, EMPTY_START_ROW, RegionLocateType.CURRENT).get());
+ assertSame(loc, LOCATOR
+ .getRegionLocation(TABLE_NAME, EMPTY_START_ROW, RegionLocateType.CURRENT, false).get());
LOCATOR.updateCachedLocation(loc, new NotServingRegionException());
- assertLocEquals(EMPTY_START_ROW, EMPTY_END_ROW, newServerName,
- LOCATOR.getRegionLocation(TABLE_NAME, EMPTY_START_ROW, RegionLocateType.CURRENT).get());
+ assertLocEquals(EMPTY_START_ROW, EMPTY_END_ROW, newServerName, LOCATOR
+ .getRegionLocation(TABLE_NAME, EMPTY_START_ROW, RegionLocateType.CURRENT, false).get());
}
// usually locate after will return the same result, so we add a test to make it return different
@@ -259,12 +261,12 @@ public class TestAsyncNonMetaRegionLocator {
TEST_UTIL.createTable(TABLE_NAME, FAMILY, new byte[][] { splitKey });
TEST_UTIL.waitTableAvailable(TABLE_NAME);
HRegionLocation currentLoc =
- LOCATOR.getRegionLocation(TABLE_NAME, row, RegionLocateType.CURRENT).get();
+ LOCATOR.getRegionLocation(TABLE_NAME, row, RegionLocateType.CURRENT, false).get();
ServerName currentServerName = TEST_UTIL.getRSForFirstRegionInTable(TABLE_NAME).getServerName();
assertLocEquals(EMPTY_START_ROW, splitKey, currentServerName, currentLoc);
HRegionLocation afterLoc =
- LOCATOR.getRegionLocation(TABLE_NAME, row, RegionLocateType.AFTER).get();
+ LOCATOR.getRegionLocation(TABLE_NAME, row, RegionLocateType.AFTER, false).get();
ServerName afterServerName =
TEST_UTIL.getHBaseCluster().getRegionServerThreads().stream().map(t -> t.getRegionServer())
.filter(rs -> rs.getOnlineRegions(TABLE_NAME).stream()
@@ -272,7 +274,8 @@ public class TestAsyncNonMetaRegionLocator {
.findAny().get().getServerName();
assertLocEquals(splitKey, EMPTY_END_ROW, afterServerName, afterLoc);
- assertSame(afterLoc, LOCATOR.getRegionLocation(TABLE_NAME, row, RegionLocateType.AFTER).get());
+ assertSame(afterLoc,
+ LOCATOR.getRegionLocation(TABLE_NAME, row, RegionLocateType.AFTER, false).get());
}
// For HBASE-17402
@@ -286,7 +289,7 @@ public class TestAsyncNonMetaRegionLocator {
LOCATOR.clearCache(TABLE_NAME);
List<CompletableFuture<HRegionLocation>> futures = IntStream.range(0, 1000)
.mapToObj(n -> String.format("%03d", n)).map(s -> Bytes.toBytes(s))
- .map(r -> LOCATOR.getRegionLocation(TABLE_NAME, r, RegionLocateType.CURRENT))
+ .map(r -> LOCATOR.getRegionLocation(TABLE_NAME, r, RegionLocateType.CURRENT, false))
.collect(toList());
for (int j = 0; j < 1000; j++) {
int index = Math.min(8, j / 111);
@@ -294,4 +297,47 @@ public class TestAsyncNonMetaRegionLocator {
}
}
}
+
+ @Test
+ public void testReload() throws Exception {
+ createSingleRegionTable();
+ ServerName serverName = TEST_UTIL.getRSForFirstRegionInTable(TABLE_NAME).getServerName();
+ for (RegionLocateType locateType : RegionLocateType.values()) {
+ assertLocEquals(EMPTY_START_ROW, EMPTY_END_ROW, serverName,
+ LOCATOR.getRegionLocation(TABLE_NAME, EMPTY_START_ROW, locateType, false).get());
+ }
+ ServerName newServerName = TEST_UTIL.getHBaseCluster().getRegionServerThreads().stream()
+ .map(t -> t.getRegionServer().getServerName()).filter(sn -> !sn.equals(serverName))
+ .findAny().get();
+ Admin admin = TEST_UTIL.getAdmin();
+ HRegionInfo region = admin.getTableRegions(TABLE_NAME).stream().findAny().get();
+ admin.move(region.getEncodedNameAsBytes(), Bytes.toBytes(newServerName.getServerName()));
+ TEST_UTIL.waitFor(30000, new ExplainingPredicate<Exception>() {
+
+ @Override
+ public boolean evaluate() throws Exception {
+ ServerName newServerName = TEST_UTIL.getRSForFirstRegionInTable(TABLE_NAME).getServerName();
+ return newServerName != null && !newServerName.equals(serverName);
+ }
+
+ @Override
+ public String explainFailure() throws Exception {
+ return region.getRegionNameAsString() + " is still on " + serverName;
+ }
+
+ });
+ // The cached location will not change
+ for (RegionLocateType locateType : RegionLocateType.values()) {
+ assertLocEquals(EMPTY_START_ROW, EMPTY_END_ROW, serverName,
+ LOCATOR.getRegionLocation(TABLE_NAME, EMPTY_START_ROW, locateType, false).get());
+ }
+ // should get the new location when reload = true
+ assertLocEquals(EMPTY_START_ROW, EMPTY_END_ROW, newServerName,
+ LOCATOR.getRegionLocation(TABLE_NAME, EMPTY_START_ROW, RegionLocateType.CURRENT, true).get());
+ // the cached location should be replaced
+ for (RegionLocateType locateType : RegionLocateType.values()) {
+ assertLocEquals(EMPTY_START_ROW, EMPTY_END_ROW, newServerName,
+ LOCATOR.getRegionLocation(TABLE_NAME, EMPTY_START_ROW, locateType, false).get());
+ }
+ }
}
http://git-wip-us.apache.org/repos/asf/hbase/blob/f8e892d7/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAsyncNonMetaRegionLocatorConcurrenyLimit.java
----------------------------------------------------------------------
diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAsyncNonMetaRegionLocatorConcurrenyLimit.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAsyncNonMetaRegionLocatorConcurrenyLimit.java
index 501c146..70df318 100644
--- a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAsyncNonMetaRegionLocatorConcurrenyLimit.java
+++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAsyncNonMetaRegionLocatorConcurrenyLimit.java
@@ -148,7 +148,7 @@ public class TestAsyncNonMetaRegionLocatorConcurrenyLimit {
public void test() throws InterruptedException, ExecutionException {
List<CompletableFuture<HRegionLocation>> futures =
IntStream.range(0, 256).mapToObj(i -> Bytes.toBytes(String.format("%02x", i)))
- .map(r -> LOCATOR.getRegionLocation(TABLE_NAME, r, RegionLocateType.CURRENT))
+ .map(r -> LOCATOR.getRegionLocation(TABLE_NAME, r, RegionLocateType.CURRENT, false))
.collect(toList());
assertLocs(futures);
assertTrue(MAX_CONCURRENCY.get() <= MAX_ALLOWED);