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 String toShortString() { // rit= is the current Region-In-Transition State -- see State enum. return String.format("rit=%s, location=%s", getState(), getRegionLocation()); }
public Map<RegionInfo, ServerName> getRegionAssignments() { final HashMap<RegionInfo, ServerName> assignments = new HashMap<RegionInfo, ServerName>(); for (RegionStateNode node: regionsMap.values()) { assignments.put(node.getRegionInfo(), node.getRegionLocation()); } return assignments; }
public ServerStateNode addRegionToServer(final RegionStateNode regionNode) { ServerStateNode serverNode = getOrCreateServer(regionNode.getRegionLocation()); serverNode.addRegion(regionNode); return serverNode; }
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())); }
@Override public RemoteOperation remoteCallBuild(final MasterProcedureEnv env, final ServerName serverName) { assert serverName.equals(getRegionState(env).getRegionLocation()); return new RegionCloseOperation(this, getRegionInfo(), this.destinationServer); }
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 RegionState toRegionState() { return new RegionState(getRegionInfo(), getState(), getLastUpdate(), getRegionLocation()); }
private void openRegion(MasterProcedureEnv env, RegionStateNode regionNode) throws IOException { ServerName loc = regionNode.getRegionLocation(); if (loc == null) { LOG.warn("No location specified for {}, jump back to state {} to get one", getRegion(), RegionStateTransitionState.REGION_STATE_TRANSITION_GET_ASSIGN_CANDIDATE); setNextState(RegionStateTransitionState.REGION_STATE_TRANSITION_GET_ASSIGN_CANDIDATE); return; } env.getAssignmentManager().regionOpening(regionNode); addChildProcedure(new OpenRegionProcedure(getRegion(), loc)); setNextState(RegionStateTransitionState.REGION_STATE_TRANSITION_CONFIRM_OPENED); }
/** * @return List of Regions associated with this <code>server</code>. */ private List<RegionInfo> getRegions(final Address server) { LinkedList<RegionInfo> regions = new LinkedList<>(); for (Map.Entry<RegionInfo, ServerName> el : master.getAssignmentManager().getRegionStates().getRegionAssignments().entrySet()) { if (el.getValue() == null) { continue; } if (el.getValue().getAddress().equals(server)) { addRegion(regions, el.getKey()); } } for (RegionStateNode state : master.getAssignmentManager().getRegionsInTransition()) { if (state.getRegionLocation().getAddress().equals(server)) { addRegion(regions, state.getRegionInfo()); } } return regions; }
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(); } }
private void reportTransitionFailedOpen(MasterProcedureEnv env, RegionStateNode regionNode, ServerName serverName) { if (!isOpening(regionNode, serverName, TransitionCode.FAILED_OPEN)) { return; } // there is no openSeqNum for FAILED_OPEN, so we will check the target server instead 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.FAILED_OPEN, regionNode, serverName, getProcId()); return; } // just wake up the procedure and see if we can retry // Notice that, even if we arrive here, this call could still be a retry, as we may retry // opening on the same server again. And the assumption here is that, once the region state is // OPENING, and the TRSP state is REGION_STATE_TRANSITION_CONFIRM_OPENED, the TRSP must have // been suspended on the procedure event, so after the waking operation here, the TRSP will be // executed and try to schedule new OpenRegionProcedure again. Once there is a successful open // then we are done, so the TRSP will not be stuck. // TODO: maybe we could send the procedure id of the OpenRegionProcedure to the region server // and let the region server send it back when done, so it will be easy to detect whether this // is a retry. regionNode.getProcedureEvent().wake(env.getProcedureScheduler()); }
@Override public RemoteOperation remoteCallBuild(final MasterProcedureEnv env, final ServerName serverName) { assert serverName.equals(getRegionState(env).getRegionLocation()); return new RegionOpenOperation(this, getRegionInfo(), env.getAssignmentManager().getFavoredNodes(getRegionInfo()), false); }
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); } }
return; if (!regionNode.getRegionLocation().equals(serverName)) { LOG.warn( "Received report {} transition from {} for {}, pid={}," +
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); } }
private void closeRegion(MasterProcedureEnv env, RegionStateNode regionNode) throws IOException { if (regionNode.isInState(State.OPEN, State.CLOSING, State.MERGING, State.SPLITTING)) { // this is the normal case env.getAssignmentManager().regionClosing(regionNode); addChildProcedure( new CloseRegionProcedure(getRegion(), regionNode.getRegionLocation(), assignCandidate)); setNextState(RegionStateTransitionState.REGION_STATE_TRANSITION_CONFIRM_CLOSED); } else { forceNewPlan = true; regionNode.setRegionLocation(null); setNextState(RegionStateTransitionState.REGION_STATE_TRANSITION_GET_ASSIGN_CANDIDATE); } }
RESUME_AND_FAIL.set(latch); Future<byte[]> future = am.moveAsync(new RegionPlan(region, rsn.getRegionLocation(), rsn.getRegionLocation())); TransitRegionStateProcedure proc = procExec.getProcedures().stream().filter(p -> p instanceof TransitRegionStateProcedure)
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); } }
RegionStateNode rsn = am.getRegionStates().getRegionStateNode(region); ServerName sn = rsn.getRegionLocation(); ARRIVE = new CountDownLatch(1); HALT = true; EXCLUDE_SERVERS.add(rsn.getRegionLocation()); KILL = true; HMaster activeMaster = UTIL.getMiniHBaseCluster().getMaster();