private void handleRegionOverStuckWarningThreshold(final RegionInfo regionInfo) { final RegionStateNode regionNode = regionStates.getRegionStateNode(regionInfo); //if (regionNode.isStuck()) { LOG.warn("STUCK Region-In-Transition {}", regionNode); }
public void offlineRegion(final RegionInfo regionInfo) { // TODO used by MasterRpcServices RegionStateNode node = regionStates.getRegionStateNode(regionInfo); if (node != null) { node.offline(); } }
public RegionState getRegionState(final RegionInfo regionInfo) { RegionStateNode regionStateNode = getRegionStateNode(regionInfo); return regionStateNode == null ? null : regionStateNode.toRegionState(); }
/** * Set the region states to MERGING state */ private void setRegionStateToMerging(final MasterProcedureEnv env) { // Set State.MERGING to regions to be merged RegionStates regionStates = env.getAssignmentManager().getRegionStates(); regionStates.getRegionStateNode(regionsToMerge[0]).setState(State.MERGING); regionStates.getRegionStateNode(regionsToMerge[1]).setState(State.MERGING); }
private boolean isCarryingRegion(final ServerName serverName, final RegionInfo regionInfo) { // TODO: check for state? final RegionStateNode node = regionStates.getRegionStateNode(regionInfo); return(node != null && serverName.equals(node.getRegionLocation())); }
private RegionStateNode getRegionNode(MasterProcedureEnv env) { return env.getAssignmentManager().getRegionStates().getRegionStateNode(region); }
public boolean isRegionInState(RegionInfo regionInfo, State... state) { RegionStateNode regionNode = getRegionStateNode(regionInfo); if (regionNode != null) { regionNode.lock(); try { return regionNode.isInState(state); } finally { regionNode.unlock(); } } return false; }
public Map<ServerName, List<RegionInfo>> getSnapShotOfAssignment( final Collection<RegionInfo> regions) { final Map<ServerName, List<RegionInfo>> result = new HashMap<ServerName, List<RegionInfo>>(); if (regions != null) { for (RegionInfo hri : regions) { final RegionStateNode node = getRegionStateNode(hri); if (node == null) { continue; } createSnapshot(node, result); } } else { for (RegionStateNode node : regionsMap.values()) { if (node == null) { continue; } createSnapshot(node, result); } } return result; }
public ServerName getRegionServerOfRegion(RegionInfo regionInfo) { RegionStateNode regionNode = getRegionStateNode(regionInfo); if (regionNode != null) { regionNode.lock(); try { ServerName server = regionNode.getRegionLocation(); return server != null ? server : regionNode.getLastHost(); } finally { regionNode.unlock(); } } return null; }
private boolean canSchedule(MasterProcedureEnv env, HRegionLocation loc) { if (loc.getSeqNum() < 0) { return false; } RegionStateNode regionNode = env.getAssignmentManager().getRegionStates().getRegionStateNode(loc.getRegion()); // If the region node is null, then at least in the next round we can remove this region to make // progress. And the second condition is a normal one, if there are no TRSP with it then we can // schedule one to make progress. return regionNode == null || !regionNode.isInTransition(); }
/** * Check region is online. */ protected static void checkOnline(MasterProcedureEnv env, RegionInfo ri) throws DoNotRetryRegionException { RegionStateNode regionNode = env.getAssignmentManager().getRegionStates().getRegionStateNode(ri); if (regionNode == null) { throw new UnknownRegionException("No RegionState found for " + ri.getEncodedName()); } regionNode.checkOnline(); } }
@Test public void testCreateUnassignProcedureForSplitFail() throws IOException { RegionInfo region = getPrimaryRegions().get(0); AM.getRegionStates().getRegionStateNode(region) .setProcedure(TransitRegionStateProcedure.unassign(ENV, region)); try { AssignmentManagerUtil.createUnassignProceduresForSplitOrMerge(ENV, Stream.of(region), REGION_REPLICATION); fail("Should fail as the region is in transition"); } catch (HBaseIOException e) { // expected } }
@Test public void testCreateUnassignProceduresForMergeFail() throws IOException { List<RegionInfo> regions = getPrimaryRegions(); RegionInfo regionA = regions.get(0); RegionInfo regionB = regions.get(1); AM.getRegionStates().getRegionStateNode(regionB) .setProcedure(TransitRegionStateProcedure.unassign(ENV, regionB)); try { AssignmentManagerUtil.createUnassignProceduresForSplitOrMerge(ENV, Stream.of(regionA, regionB), REGION_REPLICATION); fail("Should fail as the region is in transition"); } catch (HBaseIOException e) { // expected } IntStream.range(0, REGION_REPLICATION) .mapToObj(i -> RegionReplicaUtil.getRegionInfoForReplica(regionA, i)) .map(AM.getRegionStates()::getRegionStateNode).forEachOrdered( rn -> assertFalse("Should have unset the proc for " + rn, rn.isInTransition())); } }
private TransitRegionStateProcedure createMoveRegionProcedure(RegionInfo regionInfo, ServerName targetServer) throws HBaseIOException { RegionStateNode regionNode = this.regionStates.getRegionStateNode(regionInfo); if (regionNode == null) { throw new UnknownRegionException("No RegionState found for " + regionInfo.getEncodedName()); } TransitRegionStateProcedure proc; regionNode.lock(); try { preTransitCheck(regionNode, STATES_EXPECTED_ON_UNASSIGN_OR_MOVE); regionNode.checkOnline(); proc = TransitRegionStateProcedure.move(getProcedureEnvironment(), regionInfo, targetServer); regionNode.setProcedure(proc); } finally { regionNode.unlock(); } return proc; }
@After public void tearDownAfterTest() throws IOException { for (RegionInfo region : UTIL.getAdmin().getRegions(TABLE_NAME)) { RegionStateNode regionNode = AM.getRegionStates().getRegionStateNode(region); // confirm that we have released the lock assertFalse(((ReentrantLock) regionNode.lock).isLocked()); TransitRegionStateProcedure proc = regionNode.getProcedure(); if (proc != null) { regionNode.unsetProcedure(proc); } } }
public long unassign(RegionInfo regionInfo) throws IOException { RegionStateNode regionNode = regionStates.getRegionStateNode(regionInfo); if (regionNode == null) { throw new UnknownRegionException("No RegionState found for " + regionInfo.getEncodedName()); } TransitRegionStateProcedure proc; regionNode.lock(); try { preTransitCheck(regionNode, STATES_EXPECTED_ON_UNASSIGN_OR_MOVE); proc = TransitRegionStateProcedure.unassign(getProcedureEnvironment(), regionInfo); regionNode.setProcedure(proc); } finally { regionNode.unlock(); } ProcedureSyncWait.submitAndWaitProcedure(master.getMasterProcedureExecutor(), proc); return proc.getProcId(); }
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()); } } }
private void testRecoveryAndDoubleExcution(TransitRegionStateProcedure proc) throws Exception { HMaster master = UTIL.getHBaseCluster().getMaster(); AssignmentManager am = master.getAssignmentManager(); RegionStateNode regionNode = am.getRegionStates().getRegionStateNode(proc.getRegion()); assertFalse(regionNode.isInTransition()); regionNode.setProcedure(proc); assertTrue(regionNode.isInTransition()); ProcedureExecutor<MasterProcedureEnv> procExec = master.getMasterProcedureExecutor(); ProcedureTestingUtility.setKillAndToggleBeforeStoreUpdate(procExec, true); long procId = procExec.submitProcedure(proc); MasterProcedureTestingUtility.testRecoveryAndDoubleExecution(procExec, procId); regionNode = am.getRegionStates().getRegionStateNode(proc.getRegion()); assertFalse(regionNode.isInTransition()); }
protected TransitRegionStateProcedure createUnassignProcedure(RegionInfo hri) { RegionStateNode regionNode = am.getRegionStates().getRegionStateNode(hri); TransitRegionStateProcedure proc; regionNode.lock(); try { assertFalse(regionNode.isInTransition()); proc = TransitRegionStateProcedure .unassign(master.getMasterProcedureExecutor().getEnvironment(), hri); regionNode.setProcedure(proc); } finally { regionNode.unlock(); } return proc; }
@Test public void testInfiniteLoop() throws IOException { HMaster master = UTIL.getMiniHBaseCluster().getMaster(); AssignmentManager am = master.getAssignmentManager(); ProcedureExecutor<MasterProcedureEnv> exec = master.getMasterProcedureExecutor(); RegionInfo regionInfo = UTIL.getAdmin().getRegions(TABLE_NAME).get(0); RegionStateNode regionNode = am.getRegionStates().getRegionStateNode(regionInfo); long procId; ReopenTableRegionsProcedure proc = new ReopenTableRegionsProcedure(TABLE_NAME); regionNode.lock(); try { procId = exec.submitProcedure(proc); UTIL.waitFor(30000, () -> proc.hasLock()); TransitRegionStateProcedure trsp = TransitRegionStateProcedure.reopen(exec.getEnvironment(), regionInfo); regionNode.setProcedure(trsp); exec.submitProcedure(trsp); } finally { regionNode.unlock(); } UTIL.waitFor(60000, () -> exec.isFinished(procId)); } }