/** * @return Maximum number of regions in transition */ private int getMaxRegionsInTransition() { int numRegions = this.assignmentManager.getRegionStates().getRegionAssignments().size(); return Math.max((int) Math.floor(numRegions * this.maxRitPercent), 1); }
/** * 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; }
@Override public Object call() { RegionInfo hri = createRegionInfo(TABLE_NAME, regionId); return stateMap.getRegionState(hri); } });
/** * @return Return online regions of table; does not include OFFLINE or SPLITTING regions. */ public List<RegionInfo> getRegionsOfTable(TableName table, boolean offline) { return getRegionsOfTable(table, state -> include(state, offline)); }
/** * Delete the region states. This is called by "DeleteTable" */ public void deleteTable(final TableName tableName) throws IOException { final ArrayList<RegionInfo> regions = regionStates.getTableRegionsInfo(tableName); regionStateStore.deleteRegions(regions); for (int i = 0; i < regions.size(); ++i) { final RegionInfo regionInfo = regions.get(i); // we expect the region to be offline regionStates.removeFromOfflineRegions(regionInfo); regionStates.deleteRegion(regionInfo); } }
public RegionStateNode getOrCreateRegionStateNode(RegionInfo regionInfo) { RegionStateNode node = getRegionStateNodeFromName(regionInfo.getRegionName()); return node != null ? node : createRegionStateNode(regionInfo); }
@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()); }
public List<RegionStateNode> getRegionsInTransition() { return regionStates.getRegionsInTransition(); }
/** * 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); } } } }
regionStates.getRegionState(region).isFailedOpen()); helper.initialize(); for (RegionStateNode regionState: regionStates.getRegionsInTransition()) { RegionInfo regionInfo = regionState.getRegionInfo(); List<ServerName> newFavoredNodes = helper.generateFavoredNodes(regionInfo);
/** * @return Return online regions of table; does not include OFFLINE or SPLITTING regions. */ public List<RegionInfo> getRegionsOfTable(final TableName table) { return getRegionsOfTable(table, false); }
assertEquals("Expected single region for " + table2, tableRegions.size(), 1); ServerName serverName1 = am.getRegionStates().getRegionServerOfRegion(hri1); ServerName serverName2 = am.getRegionStates().getRegionServerOfRegion(hri2); || dstServer.getRegionsInTransitionInRS().containsKey(encodedRegionNameInBytes) || srcServer.getRegionsInTransitionInRS().containsKey(encodedRegionNameInBytes) || master.getAssignmentManager().getRegionStates().isRegionInTransition(hri2)) { serverName1 = am.getRegionStates().getRegionServerOfRegion(hri1); hri2 = admin.getRegions(TableName.valueOf(table2)).get(0); serverName2 = am.getRegionStates().getRegionServerOfRegion(hri2);
RegionStates regionStates = am.getRegionStates(); long start = EnvironmentEdgeManager.currentTime(); while (!regionStates.isRegionInState(hri, State.SPLIT)) { LOG.debug("Waiting for SPLIT state on: " + hri); assertFalse("Timed out in waiting split parent to be in state SPLIT", Thread.sleep(500); assertTrue(regionStates.isRegionInState(daughters.get(0).getRegionInfo(), State.OPEN)); assertTrue(regionStates.isRegionInState(daughters.get(1).getRegionInfo(), State.OPEN)); assertFalse("Split region can't be assigned", regionStates.isRegionInTransition(hri)); assertTrue(regionStates.isRegionInState(hri, State.SPLIT)); assertFalse("Split region can't be unassigned", regionStates.isRegionInTransition(hri)); assertTrue(regionStates.isRegionInState(hri, State.SPLIT)); } finally { admin.balancerSwitch(true, false);
/** * Create one TransitRegionStateProcedure to assign a region w/o specifying a target server. * This method is specified for HBCK2 */ public TransitRegionStateProcedure createOneAssignProcedure(RegionInfo hri, boolean override) { RegionStateNode regionNode = regionStates.getOrCreateRegionStateNode(hri); return createAssignProcedure(regionNode, null, override); }
@Override public Boolean evaluate() throws IOException { return !states.isRegionInTransition(region); } });
private Map<String, RegionState> rsGroupGetRegionsInTransition(String groupName) throws IOException { Map<String, RegionState> rit = Maps.newTreeMap(); AssignmentManager am = master.getAssignmentManager(); for(TableName tableName : getRSGroupInfo(groupName).getTables()) { for(RegionInfo regionInfo: am.getRegionStates().getRegionsOfTable(tableName)) { RegionState state = am.getRegionStates().getRegionTransitionState(regionInfo); if(state != null) { rit.put(regionInfo.getEncodedName(), state); } } } return rit; }
private void testFailedOpen(final TableName tableName, final MockRSExecutor executor) throws Exception { final RegionInfo hri = createRegionInfo(tableName, 1); // Test Assign operation failure rsDispatcher.setMockRsExecutor(executor); try { waitOnFuture(submitProcedure(createAssignProcedure(hri))); fail("unexpected assign completion"); } catch (RetriesExhaustedException e) { // expected exception LOG.info("REGION STATE " + am.getRegionStates().getRegionStateNode(hri)); LOG.info("expected exception from assign operation: " + e.getMessage(), e); assertEquals(true, am.getRegionStates().getRegionState(hri).isFailedOpen()); } } }
env.getAssignmentManager().getRegionStates().getRegionsOfTable(tableName, true); if (regionInfo.getReplicaId() > (regionReplicaCount - 1)) { env.getAssignmentManager().getRegionStates().deleteRegion(regionInfo);
while (true) { List<RegionInfo> regions = master.getAssignmentManager(). getRegionStates().getRegionsOfTable(table); if (regions.size() > 3) { hri = regions.get(2); RegionStates regionStates = master.getAssignmentManager().getRegionStates(); while (true) { if (regionStates.getRegionByStateOfTable(table) .get(RegionState.State.OFFLINE).contains(hri)) { break;
@Override public ReportRegionStateTransitionResponse reportRegionStateTransition(RpcController c, ReportRegionStateTransitionRequest req) throws ServiceException { ReportRegionStateTransitionResponse resp = super.reportRegionStateTransition(c, req); if (enabled.get() && req.getTransition(0).getTransitionCode() == TransitionCode.READY_TO_MERGE && !resp.hasErrorMessage()) { RegionStates regionStates = myMaster.getAssignmentManager().getRegionStates(); for (RegionState regionState: regionStates.getRegionsStateInTransition()) { // Find the merging_new region and remove it if (regionState.isMergingNew()) { regionStates.deleteRegion(regionState.getRegion()); } } } return resp; } }