public RegionInfo getRegionInfo() { return regionNode.getRegionInfo(); }
@Override public int compareTo(final RegionStateNode other) { // NOTE: RegionInfo sort by table first, so we are relying on that. // we have a TestRegionState#testOrderedByTable() that check for that. return RegionInfo.COMPARATOR.compare(getRegionInfo(), other.getRegionInfo()); }
@Override public int hashCode() { return getRegionInfo().hashCode(); }
public void addToOfflineRegions(final RegionStateNode regionNode) { LOG.info("Added to offline, CURRENTLY NEVER CLEARED!!! " + regionNode); regionOffline.put(regionNode.getRegionInfo(), regionNode); }
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()); }
/** * @return Return the regions of the table; does not include OFFLINE unless you set * <code>offline</code> to true. Does not include regions that are in the * {@link State#SPLIT} state. */ private List<RegionInfo> getRegionsOfTable(TableName table, Predicate<RegionStateNode> filter) { return getTableRegionStateNodes(table).stream().filter(filter).map(n -> n.getRegionInfo()) .collect(Collectors.toList()); }
public RegionInfo getRegionInfo(final byte[] regionName) { final RegionStateNode regionState = regionStates.getRegionStateNodeFromName(regionName); return regionState != null ? regionState.getRegionInfo() : null; }
public TableName getTable() { return getRegionInfo().getTable(); }
public List<RegionInfo> getAssignedRegions() { final List<RegionInfo> result = new ArrayList<RegionInfo>(); for (RegionStateNode node: regionsMap.values()) { if (!node.isInTransition()) { result.add(node.getRegionInfo()); } } return result; }
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 RegionState getRegionState(final String encodedRegionName) { // TODO: Need a map <encodedName, ...> but it is just dispatch merge... for (RegionStateNode node: regionsMap.values()) { if (node.getRegionInfo().getEncodedName().equals(encodedRegionName)) { return node.toRegionState(); } } return null; }
public Map<RegionState.State, List<RegionInfo>> getRegionByStateOfTable(TableName tableName) { final State[] states = State.values(); final Map<RegionState.State, List<RegionInfo>> tableRegions = new HashMap<State, List<RegionInfo>>(states.length); for (int i = 0; i < states.length; ++i) { tableRegions.put(states[i], new ArrayList<RegionInfo>()); } for (RegionStateNode node: regionsMap.values()) { if (node.getTable().equals(tableName)) { tableRegions.get(node.getState()).add(node.getRegionInfo()); } } return tableRegions; }
public String toDescriptiveString() { return String.format("%s, table=%s, region=%s", toShortString(), getTable(), getRegionInfo().getEncodedName()); }
private void dumpRIT(HMaster master, PrintWriter out) { AssignmentManager am = master.getAssignmentManager(); if (am == null) { out.println("AssignmentManager is not initialized"); return; } for (RegionStateNode rs : am.getRegionsInTransition()) { String rid = rs.getRegionInfo().getEncodedName(); out.println("Region " + rid + ": " + rs.toDescriptiveString()); } }
ArrayList<RegionInfo> getTableRegionsInfo(final TableName tableName) { final ArrayList<RegionInfo> regions = new ArrayList<RegionInfo>(); for (RegionStateNode node: regionsMap.tailMap(tableName.getName()).values()) { if (!node.getTable().equals(tableName)) break; regions.add(node.getRegionInfo()); } return regions; }
public RegionFailedOpen addToFailedOpen(final RegionStateNode regionNode) { final byte[] key = regionNode.getRegionInfo().getRegionName(); RegionFailedOpen node = regionFailedOpen.get(key); if (node == null) { RegionFailedOpen newNode = new RegionFailedOpen(regionNode); RegionFailedOpen oldNode = regionFailedOpen.putIfAbsent(key, newNode); node = oldNode != null ? oldNode : newNode; } return node; }
public RegionState toRegionState() { return new RegionState(getRegionInfo(), getState(), getLastUpdate(), getRegionLocation()); }
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); } }
void regionClosing(RegionStateNode regionNode) throws IOException { transitStateAndUpdate(regionNode, State.CLOSING, STATES_EXPECTED_ON_CLOSING); RegionInfo hri = regionNode.getRegionInfo(); // Set meta has not initialized early. so people trying to create/edit tables will wait if (isMetaRegion(hri)) { setMetaAssigned(hri, false); } regionStates.addRegionToServer(regionNode); // update the operation count metrics metrics.incrementOperationCounter(); }
void regionOpened(RegionStateNode regionNode) throws IOException { // TODO: OPENING Updates hbase:meta too... we need to do both here and there? // That is a lot of hbase:meta writing. transitStateAndUpdate(regionNode, State.OPEN, STATES_EXPECTED_ON_OPEN); RegionInfo hri = regionNode.getRegionInfo(); if (isMetaRegion(hri)) { // Usually we'd set a table ENABLED at this stage but hbase:meta is ALWAYs enabled, it // can't be disabled -- so skip the RPC (besides... enabled is managed by TableStateManager // which is backed by hbase:meta... Avoid setting ENABLED to avoid having to update state // on table that contains state. setMetaAssigned(hri, true); } regionStates.addRegionToServer(regionNode); regionStates.removeFromFailedOpen(hri); }