/** * The procedure could be restarted from a different machine. If the variable is null, we need to * retrieve it. * @param env MasterProcedureEnv * @return serverName */ private ServerName getServerName(final MasterProcedureEnv env) { if (regionLocation == null) { regionLocation = env.getAssignmentManager().getRegionStates(). getRegionServerOfRegion(regionsToMerge[0]); // May still be null here but return null and let caller deal. // Means we lost the in-memory-only location. We are in recovery // or so. The caller should be able to deal w/ a null ServerName. // Let them go to the Balancer to find one to use instead. } return regionLocation; }
private ServerName getParentRegionServerName(final MasterProcedureEnv env) { return env.getMasterServices().getAssignmentManager().getRegionStates() .getRegionServerOfRegion(getParentRegion()); }
private long getRegionSize(RegionInfo hri) { ServerName sn = masterServices.getAssignmentManager().getRegionStates(). getRegionServerOfRegion(hri); RegionMetrics regionLoad = masterServices.getServerManager().getLoad(sn). getRegionMetrics().get(hri.getRegionName()); if (regionLoad == null) { LOG.debug(hri.getRegionNameAsString() + " was not found in RegionsLoad"); return -1; } return (long) regionLoad.getStoreFileSize().get(Size.Unit.MEGABYTE); } }
/** * Moves every region of tables which should be kept on the servers, * but currently they are located on other servers. * @param servers the regions of these servers will be kept on the servers, others will be moved * @param tables the tables that will move to new group * @param targetGroupName the target group name * @throws IOException if moving the region fails */ private void moveRegionsToServers(Set<Address> servers, Set<TableName> tables, String targetGroupName) throws IOException { for (TableName table: tables) { LOG.info("Moving region(s) from " + table + " for table move to " + targetGroupName); for (RegionInfo region : master.getAssignmentManager().getRegionStates() .getRegionsOfTable(table)) { ServerName sn = master.getAssignmentManager().getRegionStates() .getRegionServerOfRegion(region); if (!servers.contains(sn.getAddress())) { master.getAssignmentManager().move(region); } } } }
getRegionsOfTable(any())).thenReturn(RegionInfo); when(masterServices.getAssignmentManager().getRegionStates(). getRegionServerOfRegion(any())).thenReturn(sn);
@Test public void testMoveToPreviouslyAssignedRS() throws IOException, InterruptedException { MiniHBaseCluster cluster = TEST_UTIL.getHBaseCluster(); HMaster master = cluster.getMaster(); final TableName tableName = TableName.valueOf(name.getMethodName()); Admin localAdmin = createTable(tableName); List<RegionInfo> tableRegions = localAdmin.getRegions(tableName); RegionInfo hri = tableRegions.get(0); AssignmentManager am = master.getAssignmentManager(); ServerName server = am.getRegionStates().getRegionServerOfRegion(hri); localAdmin.move(hri.getEncodedNameAsBytes(), Bytes.toBytes(server.getServerName())); assertEquals("Current region server and region server before move should be same.", server, am.getRegionStates().getRegionServerOfRegion(hri)); }
private void checkFavoredNodeAssignments(TableName tableName, FavoredNodesManager fnm, RegionStates regionStates) throws IOException { for (RegionInfo hri : admin.getTableRegions(tableName)) { ServerName host = regionStates.getRegionServerOfRegion(hri); assertNotNull("Region: " + hri.getEncodedName() + " not on FN, current: " + host + " FN list: " + fnm.getFavoredNodes(hri), FavoredNodesPlan.getFavoredServerPosition(fnm.getFavoredNodes(hri), host)); } }
private List<RegionInfo> getRegionsThatCanBeMoved(TableName tableName, ServerName serverName) { List<RegionInfo> regions = Lists.newArrayList(); RegionStates rst = cluster.getMaster().getAssignmentManager().getRegionStates(); FavoredNodesManager fnm = cluster.getMaster().getFavoredNodesManager(); for (RegionInfo regionInfo : fnm.getRegionsOfFavoredNode(serverName)) { if (regionInfo.getTable().equals(tableName) && !ServerName.isSameAddress(rst.getRegionServerOfRegion(regionInfo), serverName)) { regions.add(regionInfo); } } return regions; }
/** * Move region to destination server and wait till region is completely moved and online * * @param destRegion region to move * @param destServer destination server of the region * @throws InterruptedException * @throws IOException */ public void moveRegionAndWait(RegionInfo destRegion, ServerName destServer) throws InterruptedException, IOException { HMaster master = getMiniHBaseCluster().getMaster(); // TODO: Here we start the move. The move can take a while. getAdmin().move(destRegion.getEncodedNameAsBytes(), Bytes.toBytes(destServer.getServerName())); while (true) { ServerName serverName = master.getAssignmentManager().getRegionStates() .getRegionServerOfRegion(destRegion); if (serverName != null && serverName.equals(destServer)) { assertRegionOnServer(destRegion, serverName, 2000); break; } Thread.sleep(10); } }
.getAssignmentManager().getRegionStates().getRegionServerOfRegion(entry.getKey()); Pair<ServerName, ServerName> secondaryTertiaryServers = entry.getValue(); LOG.debug("New destination for region " + entry.getKey().getEncodedName() +
final ServerName current = regionStates.getRegionServerOfRegion(misplacedRegion); assertNull("Misplaced region is still hosted on favored node, not expected.", FavoredNodesPlan.getFavoredServerPosition(fnm.getFavoredNodes(misplacedRegion), current));
.getRegionInfoForReplica(RegionInfoBuilder.FIRST_META_REGIONINFO, replicaId); AssignmentTestingUtil.waitForAssignment(am, h); ServerName sn = am.getRegionStates().getRegionServerOfRegion(h); assertNotNull(sn); LOG.info("HBASE:META DEPLOY: " + h.getRegionNameAsString() + " on " + sn);
public static ServerName getServerHoldingRegion(final HBaseTestingUtility util, final RegionInfo hri) throws Exception { ServerName serverName = util.getMiniHBaseCluster().getServerHoldingRegion( hri.getTable(), hri.getRegionName()); ServerName amServerName = getMaster(util).getAssignmentManager().getRegionStates() .getRegionServerOfRegion(hri); // Make sure AM and MiniCluster agrees on the Server holding the region // and that the server is online. assertEquals(amServerName, serverName); assertEquals(true, getMaster(util).getServerManager().isServerOnline(serverName)); return serverName; }
ServerName serverName = TEST_UTIL.getHBaseCluster().getMaster().getAssignmentManager().getRegionStates() .getRegionServerOfRegion(hri); HRegionServer regionServer = TEST_UTIL.getHBaseCluster().getLiveRegionServerThreads().stream()
@Test public void testAssignRegionAndUnassignRegion() throws Exception { createTableWithDefaultConf(tableName); // assign region. HMaster master = TEST_UTIL.getHBaseCluster().getMaster(); AssignmentManager am = master.getAssignmentManager(); RegionInfo hri = am.getRegionStates().getRegionsOfTable(tableName).get(0); // assert region on server RegionStates regionStates = am.getRegionStates(); ServerName serverName = regionStates.getRegionServerOfRegion(hri); TEST_UTIL.assertRegionOnServer(hri, serverName, 200); assertTrue(regionStates.getRegionState(hri).isOpened()); // Region is assigned now. Let's assign it again. // Master should not abort, and region should stay assigned. try { admin.assign(hri.getRegionName()).get(); fail("Should fail when assigning an already onlined region"); } catch (ExecutionException e) { // Expected assertThat(e.getCause(), instanceOf(DoNotRetryRegionException.class)); } assertFalse(am.getRegionStates().getRegionStateNode(hri).isInTransition()); assertTrue(regionStates.getRegionState(hri).isOpened()); // unassign region admin.unassign(hri.getRegionName(), true).get(); assertFalse(am.getRegionStates().getRegionStateNode(hri).isInTransition()); assertTrue(regionStates.getRegionState(hri).isClosed()); }
HMaster master = cluster.getMaster(); RegionStates regionStates = master.getAssignmentManager().getRegionStates(); ServerName metaServerName = regionStates.getRegionServerOfRegion( HRegionInfo.FIRST_META_REGIONINFO); if (master.getServerName().equals(metaServerName) || metaServerName == null Bytes.toBytes(metaServerName.getServerName())); TEST_UTIL.waitUntilNoRegionsInTransition(60000); metaServerName = regionStates.getRegionServerOfRegion(HRegionInfo.FIRST_META_REGIONINFO); metaState.getState()); assertEquals("Meta should be assigned", metaState.getServerName(), regionStates.getRegionServerOfRegion(HRegionInfo.FIRST_META_REGIONINFO)); assertNotEquals("Meta should be assigned on a different server", metaState.getServerName(), metaServerName);
ProcedureTestingUtility.waitAllProcedures(cluster.getMaster().getMasterProcedureExecutor()); RegionStates regionStates = master.getAssignmentManager().getRegionStates(); ServerName regionServerOfRegion = regionStates.getRegionServerOfRegion(hri); assertEquals(null, regionServerOfRegion); } finally {
ServerName serverName = am.getRegionStates().getRegionServerOfRegion(hRegionInfo); if (!serverToRegionsList.containsKey(serverName)) { serverToRegionsList.put(serverName, new ArrayList<HRegionInfo>()); ServerName serverName = am.getRegionStates().getRegionServerOfRegion(hRegionInfo); if (!serverNames.contains(serverName)) { serverNames.add(serverName);
assertEquals("Expected single region for " + table2, tableRegions.size(), 1); ServerName serverName1 = am.getRegionStates().getRegionServerOfRegion(hri1); ServerName serverName2 = am.getRegionStates().getRegionServerOfRegion(hri2); serverName1 = am.getRegionStates().getRegionServerOfRegion(hri1); hri2 = admin.getRegions(TableName.valueOf(table2)).get(0); serverName2 = am.getRegionStates().getRegionServerOfRegion(hri2);
private void moveRegionAndWait(MiniHBaseCluster miniHBaseCluster,HRegion destRegion, HRegionServer destRegionServer) throws IOException, InterruptedException { HMaster master = miniHBaseCluster.getMaster(); getUtility().getHBaseAdmin().move( destRegion.getRegionInfo().getEncodedNameAsBytes(), Bytes.toBytes(destRegionServer.getServerName().getServerName())); while (true) { ServerName currentRegionServerName = master.getAssignmentManager().getRegionStates().getRegionServerOfRegion(destRegion.getRegionInfo()); if (currentRegionServerName != null && currentRegionServerName.equals(destRegionServer.getServerName())) { getUtility().assertRegionOnServer( destRegion.getRegionInfo(), currentRegionServerName, 200); break; } Thread.sleep(10); } } }