public AssignmentManager getAssignmentManager() { return master.getAssignmentManager(); }
protected Map<ServerName, List<RegionInfo>> getRegionAssignmentsByServer( Collection<RegionInfo> regions) { if (this.services != null && this.services.getAssignmentManager() != null) { return this.services.getAssignmentManager().getSnapShotOfAssignment(regions); } else { return new HashMap<>(); } }
@Override public void postMasterStartupInitialize() { if (services != null && regionFinder != null) { try { Set<RegionInfo> regions = services.getAssignmentManager().getRegionStates().getRegionAssignments().keySet(); regionFinder.refreshAndWait(regions); } catch (Exception e) { LOG.warn("Refreshing region HDFS Block dist failed with exception, ignoring", e); } } }
/** * Moves every region of tables which should be kept on the servers, * but currently they are located on other servers. * @param servers the regions of these servers will be kept on the servers, others will be moved * @param tables the tables that will move to new group * @param targetGroupName the target group name * @throws IOException if moving the region fails */ private void moveRegionsToServers(Set<Address> servers, Set<TableName> tables, String targetGroupName) throws IOException { for (TableName table: tables) { LOG.info("Moving region(s) from " + table + " for table move to " + targetGroupName); for (RegionInfo region : master.getAssignmentManager().getRegionStates() .getRegionsOfTable(table)) { ServerName sn = master.getAssignmentManager().getRegionStates() .getRegionServerOfRegion(region); if (!servers.contains(sn.getAddress())) { master.getAssignmentManager().move(region); } } } }
private void updateFailedAssignments() { // Kick all regions in FAILED_OPEN state List<RegionInfo> stuckAssignments = Lists.newArrayList(); for (RegionStateNode state : masterServices.getAssignmentManager().getRegionStates() .getRegionsInTransition()) { if (state.isStuck()) { stuckAssignments.add(state.getRegionInfo()); } } for (RegionInfo region : stuckAssignments) { LOG.info("Retrying assignment of " + region); try { masterServices.getAssignmentManager().unassign(region); } catch (IOException e) { LOG.warn("Unable to reassign " + region, e); } } }
/** * Regions may have been removed between latest persist of FlushedSequenceIds * and master abort. So after loading FlushedSequenceIds from file, and after * meta loaded, we need to remove the deleted region according to RegionStates. */ public void removeDeletedRegionFromLoadedFlushedSequenceIds() { RegionStates regionStates = master.getAssignmentManager().getRegionStates(); Iterator<byte[]> it = flushedSequenceIdByRegion.keySet().iterator(); while(it.hasNext()) { byte[] regionEncodedName = it.next(); if (regionStates.getRegionState(Bytes.toStringBinary(regionEncodedName)) == null) { it.remove(); storeFlushedSequenceIdsByRegion.remove(regionEncodedName); } } }
protected static void deleteAssignmentState(final MasterProcedureEnv env, final TableName tableName) throws IOException { // Clean up regions of the table in RegionStates. LOG.debug("Removing '" + tableName + "' from region states."); env.getMasterServices().getAssignmentManager().deleteTable(tableName); // If entry for this table states, remove it. LOG.debug("Marking '" + tableName + "' as deleted."); env.getMasterServices().getTableStateManager().setDeletedTable(tableName); }
Map<TableName, Map<ServerName, List<RegionInfo>>> assignments = Maps.newHashMap(); for(Map.Entry<RegionInfo, ServerName> entry: master.getAssignmentManager().getRegionStates().getRegionAssignments().entrySet()) { TableName currTable = entry.getKey().getTable(); ServerName currServer = entry.getValue();
/** * Create assign procedure for offline regions. * Just follow the old processofflineServersWithOnlineRegions method. Since now we do not need to * deal with dead server any more, we only deal with the regions in OFFLINE state in this method. * And this is a bit strange, that for new regions, we will add it in CLOSED state instead of * OFFLINE state, and usually there will be a procedure to track them. The * processofflineServersWithOnlineRegions is a legacy from long ago, as things are going really * different now, maybe we do not need this method any more. Need to revisit later. */ // Public so can be run by the Master as part of the startup. Needs hbase:meta to be online. // Needs to be done after the table state manager has been started. public void processOfflineRegions() { List<RegionInfo> offlineRegions = regionStates.getRegionStates().stream() .filter(RegionState::isOffline).filter(s -> isTableEnabled(s.getRegion().getTable())) .map(RegionState::getRegion).collect(Collectors.toList()); if (!offlineRegions.isEmpty()) { master.getMasterProcedureExecutor().submitProcedures( master.getAssignmentManager().createRoundRobinAssignProcedures(offlineRegions)); } }
protected static MasterServices getMockedMaster() throws IOException { TableDescriptors tds = Mockito.mock(TableDescriptors.class); Mockito.when(tds.get(tables[0])).thenReturn(tableDescs.get(0)); Mockito.when(tds.get(tables[1])).thenReturn(tableDescs.get(1)); Mockito.when(tds.get(tables[2])).thenReturn(tableDescs.get(2)); Mockito.when(tds.get(tables[3])).thenReturn(tableDescs.get(3)); MasterServices services = Mockito.mock(HMaster.class); Mockito.when(services.getTableDescriptors()).thenReturn(tds); AssignmentManager am = Mockito.mock(AssignmentManager.class); Mockito.when(services.getAssignmentManager()).thenReturn(am); return services; }
/** * @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 ServerName getParentRegionServerName(final MasterProcedureEnv env) { return env.getMasterServices().getAssignmentManager().getRegionStates() .getRegionServerOfRegion(getParentRegion()); }
private void splitMetaLogs(MasterProcedureEnv env) throws IOException { LOG.debug("Splitting meta WALs {}", this); MasterWalManager mwm = env.getMasterServices().getMasterWalManager(); AssignmentManager am = env.getMasterServices().getAssignmentManager(); am.getRegionStates().metaLogSplitting(serverName); mwm.splitMetaLog(serverName); am.getRegionStates().metaLogSplit(serverName); LOG.debug("Done splitting meta WALs {}", this); }
private long getRegionSize(RegionInfo hri) { ServerName sn = masterServices.getAssignmentManager().getRegionStates(). getRegionServerOfRegion(hri); RegionMetrics regionLoad = masterServices.getServerManager().getLoad(sn). getRegionMetrics().get(hri.getRegionName()); if (regionLoad == null) { LOG.debug(hri.getRegionNameAsString() + " was not found in RegionsLoad"); return -1; } return (long) regionLoad.getStoreFileSize().get(Size.Unit.MEGABYTE); } }
private void splitLogs(final MasterProcedureEnv env) throws IOException { LOG.debug("Splitting WALs {}", this); MasterWalManager mwm = env.getMasterServices().getMasterWalManager(); AssignmentManager am = env.getMasterServices().getAssignmentManager(); // TODO: For Matteo. Below BLOCKs!!!! Redo so can relinquish executor while it is running. // PROBLEM!!! WE BLOCK HERE. am.getRegionStates().logSplitting(this.serverName); mwm.splitLog(this.serverName); if (!carryingMeta) { mwm.archiveMetaLog(this.serverName); } am.getRegionStates().logSplit(this.serverName); LOG.debug("Done splitting WALs {}", this); }
@Override protected void chore() { try { AssignmentManager am = this.services.getAssignmentManager(); if (this.enabled.get() && !this.services.isInMaintenanceMode() && !this.services.getServerManager().isClusterShutdown() && am != null && am.isMetaLoaded() && !am.hasRegionsInTransition()) { scan(); } else { LOG.warn("CatalogJanitor is disabled! Enabled=" + this.enabled.get() + ", maintenanceMode=" + this.services.isInMaintenanceMode() + ", am=" + am + ", metaLoaded=" + (am != null && am.isMetaLoaded()) + ", hasRIT=" + (am != null && am.hasRegionsInTransition()) + " clusterShutDown=" + this.services .getServerManager().isClusterShutdown()); } } catch (IOException e) { LOG.warn("Failed scan of catalog table", e); } }
/** * Refresh all the region locations. * * @return true if user created regions got refreshed. */ private boolean scheduleFullRefresh() { // Protect from anything being null while starting up. if (services == null) { return false; } final AssignmentManager am = services.getAssignmentManager(); if (am == null) { return false; } // TODO: Should this refresh all the regions or only the ones assigned? boolean includesUserTables = false; for (final RegionInfo hri : am.getAssignedRegions()) { cache.refresh(hri); includesUserTables = includesUserTables || !hri.getTable().isSystemTable(); } return includesUserTables; }
private Map<String, RegionState> rsGroupGetRegionsInTransition(String groupName) throws IOException { Map<String, RegionState> rit = Maps.newTreeMap(); AssignmentManager am = master.getAssignmentManager(); for(TableName tableName : getRSGroupInfo(groupName).getTables()) { for(RegionInfo regionInfo: am.getRegionStates().getRegionsOfTable(tableName)) { RegionState state = am.getRegionStates().getRegionTransitionState(regionInfo); if(state != null) { rit.put(regionInfo.getEncodedName(), state); } } } return rit; }
mergedRegion, regionA, regionB)); this.services.getAssignmentManager().getRegionStates().deleteRegion(regionA); this.services.getAssignmentManager().getRegionStates().deleteRegion(regionB); this.services.getServerManager().removeRegion(regionA); this.services.getServerManager().removeRegion(regionB);
AssignmentManager am = env.getMasterServices().getAssignmentManager(); for (RegionInfo region : regions) { RegionStateNode regionNode = am.getRegionStates().getOrCreateRegionStateNode(region);