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 void updateRegionState(RegionInfo regionInfo, State state) { RegionStateNode regionNode = getOrCreateRegionStateNode(regionInfo); regionNode.lock(); try { regionNode.setState(state); } finally { regionNode.unlock(); } }
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(); } }
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; }
@Override public void remoteCallFailed(MasterProcedureEnv env, ServerName remote, IOException exception) { RegionStateNode regionNode = getRegionNode(env); regionNode.lock(); try { ProcedureEvent<?> event = regionNode.getProcedureEvent(); if (event.isReady()) { LOG.warn( "The procedure event of procedure {} for region {} to server {} is not suspended, " + "usually this should not happen, but anyway let's skip the following wake up code, ", this, region, targetServer); return; } LOG.warn("The remote operation {} for region {} to server {} failed", this, region, targetServer, exception); event.wake(env.getProcedureScheduler()); } finally { regionNode.unlock(); } }
@SuppressWarnings("rawtypes") @Override protected Procedure[] execute(MasterProcedureEnv env) throws ProcedureSuspendedException, ProcedureYieldException, InterruptedException { RegionStateNode regionNode = env.getAssignmentManager().getRegionStates().getOrCreateRegionStateNode(getRegion()); regionNode.lock(); try { return super.execute(env); } finally { regionNode.unlock(); } }
/** * Called by DisableTableProcedure to unassign all the regions for a table. */ public TransitRegionStateProcedure[] createUnassignProceduresForDisabling(TableName tableName) { return regionStates.getTableRegionStateNodes(tableName).stream().map(regionNode -> { regionNode.lock(); try { if (!regionStates.include(regionNode, false) || regionStates.isRegionOffline(regionNode.getRegionInfo())) { return null; } // As in DisableTableProcedure, we will hold the xlock for table, so we can make sure that // this procedure has not been executed yet, as TRSP will hold the shared lock for table all // the time. So here we will unset it and when it is actually executed, it will find that // the attach procedure is not itself and quit immediately. if (regionNode.getProcedure() != null) { regionNode.unsetProcedure(regionNode.getProcedure()); } TransitRegionStateProcedure proc = TransitRegionStateProcedure .unassign(getProcedureEnvironment(), regionNode.getRegionInfo()); regionNode.setProcedure(proc); return proc; } finally { regionNode.unlock(); } }).filter(p -> p != null).toArray(TransitRegionStateProcedure[]::new); }
regionNode.lock(); try { if (!reportTransition(regionNode, serverNode, state, seqId)) {
public void start() throws IOException, KeeperException { if (!running.compareAndSet(false, true)) { return; } LOG.trace("Starting assignment manager"); // Start the Assignment Thread startAssignmentThread(); // load meta region state ZKWatcher zkw = master.getZooKeeper(); // it could be null in some tests if (zkw != null) { RegionState regionState = MetaTableLocator.getMetaRegionState(zkw); RegionStateNode regionNode = regionStates.getOrCreateRegionStateNode(RegionInfoBuilder.FIRST_META_REGIONINFO); regionNode.lock(); try { regionNode.setRegionLocation(regionState.getServerName()); regionNode.setState(regionState.getState()); setMetaAssigned(regionState.getRegion(), regionState.getState() == State.OPEN); } finally { regionNode.unlock(); } } }
regionNode.lock(); try { if (!shouldDispatch(regionNode)) {
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(); }
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 TransitRegionStateProcedure createUnassignProcedure(RegionStateNode regionNode, boolean override) { TransitRegionStateProcedure proc; regionNode.lock(); try { if(override && regionNode.getProcedure() != null) { regionNode.unsetProcedure(regionNode.getProcedure()); } assert regionNode.getProcedure() == null; proc = TransitRegionStateProcedure.unassign(getProcedureEnvironment(), regionNode.getRegionInfo()); regionNode.setProcedure(proc); } finally { regionNode.unlock(); } return proc; }
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; }
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 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(); } }
for (RegionInfo region : regions) { RegionStateNode regionNode = am.getRegionStates().getOrCreateRegionStateNode(region); regionNode.lock(); try { if (regionNode.getProcedure() != null) {
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)); } }
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; } }