private TransitRegionStateProcedure createAssignProcedure(RegionStateNode regionNode, ServerName targetServer, boolean override) { TransitRegionStateProcedure proc; regionNode.lock(); try { if(override && regionNode.getProcedure() != null) { regionNode.unsetProcedure(regionNode.getProcedure()); } assert regionNode.getProcedure() == null; proc = TransitRegionStateProcedure.assign(getProcedureEnvironment(), regionNode.getRegionInfo(), targetServer); regionNode.setProcedure(proc); } finally { regionNode.unlock(); } return proc; }
private HRegionLocation createRegionForReopen(RegionStateNode node) { node.lock(); try { if (!include(node, false)) { return null; } if (node.isInState(State.OPEN)) { return new HRegionLocation(node.getRegionInfo(), node.getRegionLocation(), node.getOpenSeqNum()); } else if (node.isInState(State.OPENING)) { return new HRegionLocation(node.getRegionInfo(), node.getRegionLocation(), -1); } else { return null; } } finally { node.unlock(); } }
public void updateRegionLocation(RegionStateNode regionStateNode) throws IOException { if (regionStateNode.getRegionInfo().isMetaRegion()) { updateMetaLocation(regionStateNode.getRegionInfo(), regionStateNode.getRegionLocation(), regionStateNode.getState()); } else { long openSeqNum = regionStateNode.getState() == State.OPEN ? regionStateNode.getOpenSeqNum() : HConstants.NO_SEQNUM; updateUserRegionLocation(regionStateNode.getRegionInfo(), regionStateNode.getState(), regionStateNode.getRegionLocation(), openSeqNum, // The regionStateNode may have no procedure in a test scenario; allow for this. regionStateNode.getProcedure() != null ? regionStateNode.getProcedure().getProcId() : Procedure.NO_PROC_ID); } }
public boolean isStuck() { return isInState(State.FAILED_OPEN) && getProcedure() != null; }
public String toShortString() { // rit= is the current Region-In-Transition State -- see State enum. return String.format("rit=%s, location=%s", getState(), getRegionLocation()); }
public RegionState getRegionTransitionState(RegionInfo hri) { RegionStateNode node = regionInTransition.get(hri); if (node == null) { return null; } node.lock(); try { return node.isInTransition() ? node.toRegionState() : null; } finally { node.unlock(); } }
.map(regionNode -> { TransitRegionStateProcedure proc = TransitRegionStateProcedure.assign(env, regionNode.getRegionInfo(), targetServer); regionNode.lock(); try { if (ignoreIfInTransition) { if (regionNode.isInTransition()) { return null; assert !regionNode.isInTransition(); regionNode.setProcedure(proc); } finally { regionNode.unlock();
TransitRegionStateProcedure.unassign(procExec.getEnvironment(), regionInfo); long openSeqNum; regionNode.lock(); try { openSeqNum = regionNode.getOpenSeqNum(); regionNode.setState(State.OPENING); regionNode.setOpenSeqNum(-1L); regionNode.setProcedure(trsp); } finally { regionNode.unlock(); regionNode.lock(); try { regionNode.setState(State.OPEN); regionNode.setOpenSeqNum(openSeqNum); regionNode.unsetProcedure(trsp); } finally { regionNode.unlock(); assertTrue(regionNode.getOpenSeqNum() > openSeqNum);
void regionClosed(RegionStateNode regionNode, boolean normally) throws IOException { RegionState.State state = regionNode.getState(); ServerName regionLocation = regionNode.getRegionLocation(); if (normally) { regionNode.transitionState(State.CLOSED, STATES_EXPECTED_ON_CLOSED); } else { // For SCP regionNode.transitionState(State.ABNORMALLY_CLOSED); } regionNode.setRegionLocation(null); boolean succ = false; try { regionStateStore.updateRegionLocation(regionNode); succ = true; } finally { if (!succ) { // revert regionNode.setState(state); regionNode.setRegionLocation(regionLocation); } } if (regionLocation != null) { regionNode.setLastHost(regionLocation); regionStates.removeRegionFromServer(regionLocation, regionNode); } }
public RegionState toRegionState() { return new RegionState(getRegionInfo(), getState(), getLastUpdate(), getRegionLocation()); }
continue; regionNode.lock(); try { long diff = EnvironmentEdgeManager.currentTime() - regionNode.getLastUpdate(); if (regionNode.isInState(State.OPENING, State.OPEN)) { if (!regionNode.getRegionLocation().equals(serverName) && diff > 1000) { LOG.warn("{} reported OPEN on server={} but state has otherwise", regionNode, serverName); } else if (!regionNode.isInState(State.CLOSING, State.SPLITTING)) { regionNode.unlock();
" transition openSeqNum=" + openSeqNum + ", " + regionNode + ", proc=" + this); if (openSeqNum < regionNode.getOpenSeqNum()) { " is less than the current one {}, should be a retry, ignore", TransitionCode.OPENED, serverName, regionNode, getProcId(), openSeqNum, regionNode.getOpenSeqNum()); return; if (!regionNode.getRegionLocation().equals(serverName)) { LOG.warn("Received report {} transition from {} for {}, pid={} but the region is not on it," + " should be a retry, ignore", TransitionCode.OPENED, serverName, regionNode, getProcId()); return; regionNode.setOpenSeqNum(openSeqNum); env.getAssignmentManager().regionOpened(regionNode); if (lastState == RegionStateTransitionState.REGION_STATE_TRANSITION_CONFIRM_OPENED) { regionNode.unsetProcedure(this); regionNode.getProcedureEvent().wake(env.getProcedureScheduler());
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; }
public static boolean waitForAssignment(AssignmentManager am, RegionInfo regionInfo) throws IOException { // This method can be called before the regionInfo has made it into the regionStateMap // so wait around here a while. Waiter.waitFor(am.getConfiguration(), 10000, () -> am.getRegionStates().getRegionStateNode(regionInfo) != null); RegionStateNode regionNode = am.getRegionStates().getRegionStateNode(regionInfo); // Wait until the region has already been open, or we have a TRSP along with it. Waiter.waitFor(am.getConfiguration(), 30000, () -> regionNode.isInState(State.OPEN) || regionNode.isInTransition()); TransitRegionStateProcedure proc = regionNode.getProcedure(); regionNode.lock(); try { if (regionNode.isInState(State.OPEN)) { return true; } proc = regionNode.getProcedure(); } finally { regionNode.unlock(); } assertNotNull(proc); ProcedureSyncWait.waitForProcedureToCompleteIOE(am.getMaster().getMasterProcedureExecutor(), proc, 5L * 60 * 1000); return true; } }
private void createSnapshot(RegionStateNode node, Map<ServerName, List<RegionInfo>> result) { final ServerName serverName = node.getRegionLocation(); if (serverName == null) { return; } List<RegionInfo> serverRegions = result.get(serverName); if (serverRegions == null) { serverRegions = new ArrayList<RegionInfo>(); result.put(serverName, serverRegions); } serverRegions.add(node.getRegionInfo()); }
public long assign(RegionInfo regionInfo, ServerName sn) throws IOException { // TODO: should we use getRegionStateNode? RegionStateNode regionNode = regionStates.getOrCreateRegionStateNode(regionInfo); TransitRegionStateProcedure proc; regionNode.lock(); try { preTransitCheck(regionNode, STATES_EXPECTED_ON_ASSIGN); proc = TransitRegionStateProcedure.assign(getProcedureEnvironment(), regionInfo, sn); regionNode.setProcedure(proc); } finally { regionNode.unlock(); } ProcedureSyncWait.submitAndWaitProcedure(master.getMasterProcedureExecutor(), proc); return proc.getProcId(); }
RegionStateNode regionNode = regionNodes.get(i); TransitRegionStateProcedure proc = TransitRegionStateProcedure.unassign(env, regionNode.getRegionInfo()); if (regionNode.getProcedure() != null) { throw new HBaseIOException( "The parent region " + regionNode + " is currently in transition, give up"); regionNode.setProcedure(proc); procs[i] = proc; regionNode.unsetProcedure(procs[i]);
for (RegionInfo region : regions) { RegionStateNode regionNode = am.getRegionStates().getOrCreateRegionStateNode(region); regionNode.lock(); try { if (regionNode.getProcedure() != null) { LOG.info("{} found RIT {}; {}", this, regionNode.getProcedure(), regionNode); regionNode.getProcedure().serverCrashed(env, regionNode, getServerName()); } else { if (env.getMasterServices().getTableStateManager().isTableState(regionNode.getTable(), TableState.State.DISABLING, TableState.State.DISABLED)) { continue; regionNode.setProcedure(proc); addChildProcedure(proc); regionNode.unlock();
void regionFailedOpen(RegionStateNode regionNode, boolean giveUp) throws IOException { RegionState.State state = regionNode.getState(); ServerName regionLocation = regionNode.getRegionLocation(); if (giveUp) { regionNode.setState(State.FAILED_OPEN); regionNode.setRegionLocation(null); boolean succ = false; try { regionStateStore.updateRegionLocation(regionNode); succ = true; } finally { if (!succ) { // revert regionNode.setState(state); regionNode.setRegionLocation(regionLocation); } } } if (regionLocation != null) { regionStates.removeRegionFromServer(regionLocation, regionNode); } }
public RegionInfo getRegionInfo() { return regionNode.getRegionInfo(); }