Refine search
@Test public void testFlushRegionServer() throws Exception { try (Admin admin = TEST_UTIL.getAdmin()) { for (HRegionServer rs : TEST_UTIL.getHBaseCluster() .getLiveRegionServerThreads() .stream().map(JVMClusterUtil.RegionServerThread::getRegionServer) .collect(Collectors.toList())) { admin.flushRegionServer(rs.getServerName()); assertFalse(getRegionInfo(rs).stream().anyMatch(r -> r.getMemStoreDataSize() != 0)); } } }
@Test public void testAsyncFlushRegionServer() throws Exception { AsyncAdmin admin = asyncConn.getAdmin(); for (HRegionServer rs : TEST_UTIL.getHBaseCluster() .getLiveRegionServerThreads() .stream().map(JVMClusterUtil.RegionServerThread::getRegionServer) .collect(Collectors.toList())) { admin.flushRegionServer(rs.getServerName()).get(); assertFalse(getRegionInfo(rs).stream().anyMatch(r -> r.getMemStoreDataSize() != 0)); } }
@Test public void testMapHostNameToServerName() throws Exception { List<String> topHosts = new ArrayList<>(); for (int i = 0; i < ServerNum; i++) { HRegionServer server = cluster.getRegionServer(i); String serverHost = server.getServerName().getHostname(); if (!topHosts.contains(serverHost)) { topHosts.add(serverHost); } } List<ServerName> servers = finder.mapHostNameToServerName(topHosts); // mini cluster, all rs in one host assertEquals(1, topHosts.size()); for (int i = 0; i < ServerNum; i++) { ServerName server = cluster.getRegionServer(i).getServerName(); assertTrue(servers.contains(server)); } }
@Test public void testOnlineConfigChange() throws IOException { LOG.debug("Starting the test"); Admin admin = TEST_UTIL.getAdmin(); ServerName server = TEST_UTIL.getHBaseCluster().getRegionServer(0).getServerName(); admin.updateConfiguration(server); }
@Test public void testScheduleSCP() throws Exception { HRegionServer testRs = TEST_UTIL.getRSForFirstRegionInTable(TABLE_NAME); TEST_UTIL.loadTable(TEST_UTIL.getConnection().getTable(TABLE_NAME), Bytes.toBytes("family1"), true); ServerName serverName = testRs.getServerName(); Hbck hbck = getHbck(); List<Long> pids = hbck.scheduleServerCrashProcedure(Arrays.asList(ProtobufUtil.toServerName(serverName))); assertTrue(pids.get(0) > 0); LOG.info("pid is {}", pids.get(0)); pids = hbck.scheduleServerCrashProcedure(Arrays.asList(ProtobufUtil.toServerName(serverName))); assertTrue(pids.get(0) == -1); LOG.info("pid is {}", pids.get(0)); }
@Test public void testRegionServerCoprocessorServiceError() throws Exception { final ServerName serverName = TEST_UTIL.getHBaseCluster().getRegionServer(0).getServerName(); DummyRegionServerEndpointProtos.DummyRequest request = DummyRegionServerEndpointProtos.DummyRequest.getDefaultInstance(); try { admin .<DummyRegionServerEndpointProtos.DummyService.Stub, DummyRegionServerEndpointProtos.DummyResponse> coprocessorService( DummyRegionServerEndpointProtos.DummyService::newStub, (s, c, done) -> s.dummyThrow(c, request, done), serverName).get(); fail("Should have thrown an exception"); } catch (Exception e) { assertTrue(e.getCause() instanceof RetriesExhaustedException); assertTrue(e.getCause().getMessage().contains(WHAT_TO_THROW.getClass().getName().trim())); } }
@Test public void testRegionServerPort() { MiniHBaseCluster cluster = TEST_UTIL.getHBaseCluster(); HRegionServer regionServer = cluster.getRegionServer(0); String rsName = regionServer.getServerName().getHostname(); final int PORT = 16021; Configuration conf = TEST_UTIL.getConfiguration(); String originalPort = conf.get(HConstants.REGIONSERVER_PORT); conf.set(HConstants.REGIONSERVER_PORT, Integer.toString(PORT)); RegionMoverBuilder rmBuilder = new RegionMoverBuilder(rsName, conf); assertEquals(PORT, rmBuilder.port); if (originalPort != null) { conf.set(HConstants.REGIONSERVER_PORT, originalPort); } }
@Test public void testGetOnlineRegions() throws Exception { createTableAndGetOneRegion(tableName); AtomicInteger regionServerCount = new AtomicInteger(0); TEST_UTIL .getHBaseCluster() .getLiveRegionServerThreads() .stream() .map(rsThread -> rsThread.getRegionServer()) .forEach( rs -> { ServerName serverName = rs.getServerName(); try { assertEquals(admin.getRegions(serverName).get().size(), rs .getRegions().size()); } catch (Exception e) { fail("admin.getOnlineRegions() method throws a exception: " + e.getMessage()); } regionServerCount.incrementAndGet(); }); assertEquals(2, regionServerCount.get()); }
@Test public void testRollWALWALWriter() throws Exception { setUpforLogRolling(); String className = this.getClass().getName(); StringBuilder v = new StringBuilder(className); while (v.length() < 1000) { v.append(className); } byte[] value = Bytes.toBytes(v.toString()); HRegionServer regionServer = startAndWriteData(tableName, value); LOG.info("after writing there are " + AbstractFSWALProvider.getNumRolledLogFiles(regionServer.getWAL(null)) + " log files"); // flush all regions for (HRegion r : regionServer.getOnlineRegionsLocalContext()) { r.flush(true); } admin.rollWALWriter(regionServer.getServerName()).join(); int count = AbstractFSWALProvider.getNumRolledLogFiles(regionServer.getWAL(null)); LOG.info("after flushing all regions and rolling logs there are " + count + " log files"); assertTrue(("actual count: " + count), count <= 2); }
@Test public void test() throws InterruptedException, ExecutionException { SLEEP_MS = 1000; long startNs = System.nanoTime(); try { LOCATOR.getRegionLocation(TABLE_NAME, EMPTY_START_ROW, RegionLocateType.CURRENT, TimeUnit.MILLISECONDS.toNanos(500)).get(); fail(); } catch (ExecutionException e) { e.printStackTrace(); assertThat(e.getCause(), instanceOf(TimeoutIOException.class)); } long costMs = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startNs); assertTrue(costMs >= 500); assertTrue(costMs < 1000); // wait for the background task finish Thread.sleep(2000); // Now the location should be in cache, so we will not visit meta again. HRegionLocation loc = LOCATOR.getRegionLocation(TABLE_NAME, EMPTY_START_ROW, RegionLocateType.CURRENT, TimeUnit.MILLISECONDS.toNanos(500)).get(); assertEquals(loc.getServerName(), TEST_UTIL.getHBaseCluster().getRegionServer(0).getServerName()); } }
@Test public void testSingleRegionTable() throws IOException, InterruptedException, ExecutionException { createSingleRegionTable(); ServerName serverName = TEST_UTIL.getRSForFirstRegionInTable(TABLE_NAME).getServerName(); for (RegionLocateType locateType : RegionLocateType.values()) { assertLocEquals(EMPTY_START_ROW, EMPTY_END_ROW, serverName, getDefaultRegionLocation(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, getDefaultRegionLocation(TABLE_NAME, randKey, locateType, false).get()); } }
@Test public void testLocateAfter() throws IOException, InterruptedException, ExecutionException { byte[] row = Bytes.toBytes("1"); byte[] splitKey = Arrays.copyOf(row, 2); TEST_UTIL.createTable(TABLE_NAME, FAMILY, new byte[][] { splitKey }); TEST_UTIL.waitTableAvailable(TABLE_NAME); HRegionLocation currentLoc = getDefaultRegionLocation(TABLE_NAME, row, RegionLocateType.CURRENT, false).get(); ServerName currentServerName = TEST_UTIL.getRSForFirstRegionInTable(TABLE_NAME).getServerName(); assertLocEquals(EMPTY_START_ROW, splitKey, currentServerName, currentLoc); HRegionLocation afterLoc = getDefaultRegionLocation(TABLE_NAME, row, RegionLocateType.AFTER, false).get(); ServerName afterServerName = TEST_UTIL.getHBaseCluster().getRegionServerThreads().stream().map(t -> t.getRegionServer()) .filter(rs -> rs.getRegions(TABLE_NAME).stream() .anyMatch(r -> Bytes.equals(splitKey, r.getRegionInfo().getStartKey()))) .findAny().get().getServerName(); assertLocEquals(splitKey, EMPTY_END_ROW, afterServerName, afterLoc); assertSame(afterLoc, getDefaultRegionLocation(TABLE_NAME, row, RegionLocateType.AFTER, false).get()); }
@Test public void testScanAll() throws Exception { List<Result> results = doScan(createScan()); // make sure all scanners are closed at RS side TEST_UTIL.getHBaseCluster().getRegionServerThreads().stream().map(t -> t.getRegionServer()) .forEach( rs -> assertEquals( "The scanner count of " + rs.getServerName() + " is " + rs.getRSRpcServices().getScannersCount(), 0, rs.getRSRpcServices().getScannersCount())); assertEquals(COUNT, results.size()); IntStream.range(0, COUNT).forEach(i -> { Result result = results.get(i); assertEquals(String.format("%03d", i), Bytes.toString(result.getRow())); assertEquals(i, Bytes.toInt(result.getValue(FAMILY, CQ1))); }); }
@Test public void testWALRollWriting() throws Exception { setUpforLogRolling(); String className = this.getClass().getName(); StringBuilder v = new StringBuilder(className); while (v.length() < 1000) { v.append(className); } byte[] value = Bytes.toBytes(v.toString()); HRegionServer regionServer = startAndWriteData(TableName.valueOf(name.getMethodName()), value); LOG.info("after writing there are " + AbstractFSWALProvider.getNumRolledLogFiles(regionServer.getWAL(null)) + " log files"); // flush all regions for (HRegion r : regionServer.getOnlineRegionsLocalContext()) { r.flush(true); } admin.rollWALWriter(regionServer.getServerName()); int count = AbstractFSWALProvider.getNumRolledLogFiles(regionServer.getWAL(null)); LOG.info("after flushing all regions and rolling logs there are " + count + " log files"); assertTrue(("actual count: " + count), count <= 2); }
/** * UT for HBASE-21746 */ @Test public void testLoadMetaRegion() throws Exception { HRegionServer rsWithMeta = TEST_UTIL.getMiniHBaseCluster().getRegionServerThreads().stream() .map(t -> t.getRegionServer()) .filter(rs -> rs.getRegions(TableName.META_TABLE_NAME).size() > 0).findFirst().get(); int onlineRegions = rsWithMeta.getNumberOfOnlineRegions(); String rsName = rsWithMeta.getServerName().getAddress().toString(); try (RegionMover rm = new RegionMoverBuilder(rsName, TEST_UTIL.getConfiguration()).ack(true).build()) { LOG.info("Unloading " + rsWithMeta.getServerName()); rm.unload(); assertEquals(0, rsWithMeta.getNumberOfOnlineRegions()); LOG.info("Loading " + rsWithMeta.getServerName()); rm.load(); assertEquals(onlineRegions, rsWithMeta.getNumberOfOnlineRegions()); } }
@Test public void testGetWALsToSplit() throws Exception { TEST_UTIL.createTable(TABLE_NAME, FAMILY, TEST_UTIL.KEYS_FOR_HBA_CREATE_TABLE); // load table TEST_UTIL.loadTable(TEST_UTIL.getConnection().getTable(TABLE_NAME), FAMILY); ServerName metaServer = TEST_UTIL.getHBaseCluster().getServerHoldingMeta(); List<FileStatus> metaWals = splitWALManager.getWALsToSplit(metaServer, true); Assert.assertEquals(1, metaWals.size()); List<FileStatus> wals = splitWALManager.getWALsToSplit(metaServer, false); Assert.assertEquals(1, wals.size()); ServerName testServer = TEST_UTIL.getHBaseCluster().getRegionServerThreads().stream() .map(rs -> rs.getRegionServer().getServerName()).filter(rs -> rs != metaServer).findAny() .get(); metaWals = splitWALManager.getWALsToSplit(testServer, true); Assert.assertEquals(0, metaWals.size()); }
@Test public void testRegionServerCoprocessorService() throws Exception { final ServerName serverName = TEST_UTIL.getHBaseCluster().getRegionServer(0).getServerName(); DummyRegionServerEndpointProtos.DummyRequest request = DummyRegionServerEndpointProtos.DummyRequest.getDefaultInstance(); DummyRegionServerEndpointProtos.DummyResponse response = admin .<DummyRegionServerEndpointProtos.DummyService.Stub, DummyRegionServerEndpointProtos.DummyResponse> coprocessorService( DummyRegionServerEndpointProtos.DummyService::newStub, (s, c, done) -> s.dummyCall(c, request, done), serverName).get(); assertEquals(DUMMY_VALUE, response.getValue()); }
@Test public void testRegionMove() throws IOException, InterruptedException, ExecutionException { createSingleRegionTable(); ServerName serverName = TEST_UTIL.getRSForFirstRegionInTable(TABLE_NAME).getServerName(); HRegionLocation loc = getDefaultRegionLocation(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)).findAny() .get(); TEST_UTIL.getAdmin().move(Bytes.toBytes(loc.getRegion().getEncodedName()), Bytes.toBytes(newServerName.getServerName())); while (!TEST_UTIL.getRSForFirstRegionInTable(TABLE_NAME).getServerName() .equals(newServerName)) { Thread.sleep(100); } // Should be same as it is in cache assertSame(loc, getDefaultRegionLocation(TABLE_NAME, EMPTY_START_ROW, RegionLocateType.CURRENT, false).get()); LOCATOR.updateCachedLocationOnError(loc, null); // null error will not trigger a cache cleanup assertSame(loc, getDefaultRegionLocation(TABLE_NAME, EMPTY_START_ROW, RegionLocateType.CURRENT, false).get()); LOCATOR.updateCachedLocationOnError(loc, new NotServingRegionException()); assertLocEquals(EMPTY_START_ROW, EMPTY_END_ROW, newServerName, getDefaultRegionLocation(TABLE_NAME, EMPTY_START_ROW, RegionLocateType.CURRENT, false).get()); }
@Test public void testSplitLogs() throws Exception { TEST_UTIL.createTable(TABLE_NAME, FAMILY, TEST_UTIL.KEYS_FOR_HBA_CREATE_TABLE); // load table TEST_UTIL.loadTable(TEST_UTIL.getConnection().getTable(TABLE_NAME), FAMILY); ProcedureExecutor<MasterProcedureEnv> masterPE = master.getMasterProcedureExecutor(); ServerName metaServer = TEST_UTIL.getHBaseCluster().getServerHoldingMeta(); ServerName testServer = TEST_UTIL.getHBaseCluster().getRegionServerThreads().stream() .map(rs -> rs.getRegionServer().getServerName()).filter(rs -> rs != metaServer).findAny() .get(); List<Procedure> procedures = splitWALManager.splitWALs(testServer, false); Assert.assertEquals(1, procedures.size()); ProcedureTestingUtility.submitAndWait(masterPE, procedures.get(0)); Assert.assertEquals(0, splitWALManager.getWALsToSplit(testServer, false).size()); procedures = splitWALManager.splitWALs(metaServer, true); Assert.assertEquals(1, procedures.size()); ProcedureTestingUtility.submitAndWait(masterPE, procedures.get(0)); Assert.assertEquals(0, splitWALManager.getWALsToSplit(metaServer, true).size()); Assert.assertEquals(1, splitWALManager.getWALsToSplit(metaServer, false).size()); }
@Test(expected = UnknownHostException.class) public void testGetClientBadHostname() throws Exception { // verify that we can get an instance with the cluster hostname ServerName rs = testUtil.getHBaseCluster().getRegionServer(0).getServerName(); try { conn.getClient(rs); } catch (UnknownHostException uhe) { fail("Obtaining client to the cluster regionserver should have succeeded"); } // test that we fail to get a client to an unresolvable hostname, which // means it won't be cached ServerName badHost = ServerName.valueOf("unknownhost.invalid:" + HConstants.DEFAULT_REGIONSERVER_PORT, System.currentTimeMillis()); conn.getAdmin(badHost); fail("Obtaining client to unresolvable hostname should have failed"); } }