public Map<ServerName, List<HRegionInfo>> getSnapShotOfAssignment(Collection<HRegionInfo> infos) { return getRegionStates().getRegionAssignments(infos); }
/** * Compute the average load across all region servers. * Currently, this uses a very naive computation - just uses the number of * regions being served, ignoring stats about number of requests. * @return the average load */ public double getAverageLoad() { if (this.assignmentManager == null) { return 0; } RegionStates regionStates = this.assignmentManager.getRegionStates(); if (regionStates == null) { return 0; } return regionStates.getAverageLoad(); }
private int reassignFailedPlans() { List<HRegionInfo> reassigningRegions = new ArrayList<HRegionInfo>(); for (Map.Entry<ServerName, List<HRegionInfo>> e : failedPlans.entrySet()) { LOG.info("Failed assigning " + e.getValue().size() + " regions to server " + e.getKey() + ", reassigning them"); reassigningRegions.addAll(failedPlans.remove(e.getKey())); } RegionStates regionStates = assignmentManager.getRegionStates(); for (HRegionInfo region : reassigningRegions) { if (!regionStates.isRegionOnline(region)) { assignmentManager.invokeAssign(region); } } return reassigningRegions.size(); }
private boolean isTableAssigned() { return !masterServices.getAssignmentManager().getRegionStates(). getRegionsOfTable(TableName.NAMESPACE_TABLE_NAME).isEmpty(); }
private void dumpRIT(HMaster master, PrintWriter out) { AssignmentManager am = master.getAssignmentManager(); if (am == null) { out.println("AssignmentManager is not initialized"); return; } Map<String, RegionState> regionsInTransition = am.getRegionStates().getRegionsInTransition(); for (Map.Entry<String, RegionState> e : regionsInTransition.entrySet()) { String rid = e.getKey(); RegionState rs = e.getValue(); out.println("Region " + rid + ": " + rs.toDescriptiveString()); } }
private void forceRegionsOffline(final List<HRegionInfo> hris) { AssignmentManager am = this.masterServices.getAssignmentManager(); RegionStates states = am.getRegionStates(); if (hris != null) { for (HRegionInfo hri: hris) { states.regionOffline(hri); } } }
/** * Triggers a bulk assignment of the specified regions * * @param assignmentManager the Assignment Manger * @param regionInfos the list of regions to assign * @throws IOException if an error occurred during the assignment */ public static void assignRegions(final AssignmentManager assignmentManager, final List<HRegionInfo> regionInfos) throws IOException { try { assignmentManager.getRegionStates().createRegionStates(regionInfos); assignmentManager.assign(regionInfos); } catch (InterruptedException e) { LOG.error("Caught " + e + " during round-robin assignment"); InterruptedIOException ie = new InterruptedIOException(e.getMessage()); ie.initCause(e); throw ie; } } }
@Override protected boolean waitUntilDone(long timeout) throws InterruptedException { long startTime = System.currentTimeMillis(); long remaining = timeout; List<HRegionInfo> regions = null; long lastLogTime = startTime; while (!server.isStopped() && remaining > 0) { Thread.sleep(waitingTimeForEvents); regions = assignmentManager.getRegionStates().getRegionsOfTable(tableName); long now = System.currentTimeMillis(); // Don't log more than once every ten seconds. Its obnoxious. And only log table regions // if we are waiting a while for them to go down... if (LOG.isDebugEnabled() && ((now - lastLogTime) > 10000)) { lastLogTime = now; LOG.debug("Disable waiting until done; " + remaining + " ms remaining; " + regions); } if (regions.isEmpty()) break; remaining = timeout - (now - startTime); } return regions != null && regions.isEmpty(); } }
@Override protected void populatePool(ExecutorService pool) { RegionStates regionStates = assignmentManager.getRegionStates(); for (final HRegionInfo region : regions) { if (regionStates.isRegionInTransition(region) && !regionStates.isRegionInState(region, RegionState.State.FAILED_CLOSE)) { continue; } pool.execute(Trace.wrap("DisableTableHandler.BulkDisabler", new Runnable() { @Override public void run() { assignmentManager.unassign(region); } })); } }
@Override protected void populatePool(ExecutorService pool) { RegionStates regionStates = assignmentManager.getRegionStates(); for (HRegionInfo region: regions) { if (regionStates.isRegionInTransition(region) && !regionStates.isRegionInState(region, State.FAILED_CLOSE)) { continue; } final HRegionInfo hri = region; pool.execute(Trace.wrap("DisableTableHandler.BulkDisabler",new Runnable() { public void run() { assignmentManager.unassign(hri, true); } })); } }
@Override protected void chore() { try { AssignmentManager am = this.services.getAssignmentManager(); if (this.enabled.get() && am != null && am.isFailoverCleanupDone() && am.getRegionStates().getRegionsInTransition().size() == 0) { scan(); } else { LOG.warn("CatalogJanitor disabled! Not running scan."); } } catch (IOException e) { LOG.warn("Failed scan of catalog table", e); } }
@Override protected boolean waitUntilDone(long timeout) throws InterruptedException { long startTime = EnvironmentEdgeManager.currentTime(); long remaining = timeout; List<HRegionInfo> regions = null; long lastLogTime = startTime; while (!server.isStopped() && remaining > 0) { Thread.sleep(waitingTimeForEvents); regions = assignmentManager.getRegionStates().getRegionsOfTable(tableName); long now = EnvironmentEdgeManager.currentTime(); // Don't log more than once every ten seconds. Its obnoxious. And only log table regions // if we are waiting a while for them to go down... if (LOG.isDebugEnabled() && ((now - lastLogTime) > 10000)) { lastLogTime = now; LOG.debug("Disable waiting until done; " + remaining + " ms remaining; " + regions); } if (regions.isEmpty()) break; remaining = timeout - (now - startTime); } return regions != null && regions.isEmpty(); } }
/** * 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; } AssignmentManager am = services.getAssignmentManager(); if (am == null) { return false; } RegionStates regionStates = am.getRegionStates(); if (regionStates == null) { return false; } Set<HRegionInfo> regions = regionStates.getRegionAssignments().keySet(); boolean includesUserTables = false; for (final HRegionInfo hri : regions) { cache.refresh(hri); includesUserTables = includesUserTables || !hri.isSystemTable(); } return includesUserTables; }
protected static void waitRegionInTransition(final MasterProcedureEnv env, final List<HRegionInfo> regions) throws IOException, CoordinatedStateException { final AssignmentManager am = env.getMasterServices().getAssignmentManager(); final RegionStates states = am.getRegionStates(); for (final HRegionInfo region : regions) { ProcedureSyncWait.waitFor(env, "regions " + region.getRegionNameAsString() + " in transition", new ProcedureSyncWait.Predicate<Boolean>() { @Override public Boolean evaluate() throws IOException { if (states.isRegionInState(region, State.FAILED_OPEN)) { am.regionOffline(region); } return !states.isRegionInTransition(region); } }); } }
private long getRegionSize(HRegionInfo hri) { ServerName sn = masterServices.getAssignmentManager().getRegionStates(). getRegionServerOfRegion(hri); RegionLoad regionLoad = masterServices.getServerManager().getLoad(sn). getRegionsLoad().get(hri.getRegionName()); return regionLoad.getStorefileSizeMB(); } }
/** * @param regionsInMeta * @return List of regions neither in transition nor assigned. * @throws IOException */ private static Map<HRegionInfo, ServerName> regionsToAssignWithServerName( final MasterProcedureEnv env, final List<Pair<HRegionInfo, ServerName>> regionsInMeta) throws IOException { Map<HRegionInfo, ServerName> regionsToAssign = new HashMap<HRegionInfo, ServerName>(regionsInMeta.size()); RegionStates regionStates = env.getMasterServices().getAssignmentManager().getRegionStates(); for (Pair<HRegionInfo, ServerName> regionLocation : regionsInMeta) { HRegionInfo hri = regionLocation.getFirst(); ServerName sn = regionLocation.getSecond(); if (regionStates.isRegionOffline(hri)) { regionsToAssign.put(hri, sn); } else { if (LOG.isDebugEnabled()) { LOG.debug("Skipping assign for the region " + hri + " during enable table " + hri.getTable() + " because its already in tranition or assigned."); } } } return regionsToAssign; }
protected static void deleteAssignmentState(final MasterProcedureEnv env, final TableName tableName) throws HBaseException, IOException { AssignmentManager am = env.getMasterServices().getAssignmentManager(); // Clean up regions of the table in RegionStates. LOG.debug("Removing '" + tableName + "' from region states."); am.getRegionStates().tableDeleted(tableName); // If entry for this table states, remove it. LOG.debug("Marking '" + tableName + "' as deleted."); am.getTableStateManager().setDeletedTable(tableName); }
@Override public void process() { LOG.debug("Handling CLOSED event for " + regionInfo.getEncodedName()); // Check if this table is being disabled or not if (this.assignmentManager.getTableStateManager().isTableState(this.regionInfo.getTable(), ZooKeeperProtos.Table.State.DISABLED, ZooKeeperProtos.Table.State.DISABLING) || assignmentManager.getReplicasToClose().contains(regionInfo)) { assignmentManager.offlineDisabledRegion(regionInfo); return; } // ZK Node is in CLOSED state, assign it. assignmentManager.getRegionStates().updateRegionState( regionInfo, RegionState.State.CLOSED); // This below has to do w/ online enable/disable of a table assignmentManager.removeClosedRegion(regionInfo); assignmentManager.assign(regionInfo, true); } }
private void splitLogs(final MasterProcedureEnv env) throws IOException { if (LOG.isDebugEnabled()) { LOG.debug("Splitting logs from " + serverName + "; region count=" + size(this.regionsOnCrashedServer)); } MasterFileSystem mfs = env.getMasterServices().getMasterFileSystem(); AssignmentManager am = env.getMasterServices().getAssignmentManager(); // TODO: For Matteo. Below BLOCKs!!!! Redo so can relinquish executor while it is running. mfs.splitLog(this.serverName); am.getRegionStates().logSplit(this.serverName); }
private void prepareLogReplay(final MasterProcedureEnv env, final Set<HRegionInfo> regions) throws IOException { if (LOG.isDebugEnabled()) { LOG.debug("Mark " + size(this.regionsOnCrashedServer) + " regions-in-recovery from " + this.serverName); } MasterFileSystem mfs = env.getMasterServices().getMasterFileSystem(); AssignmentManager am = env.getMasterServices().getAssignmentManager(); mfs.prepareLogReplay(this.serverName, regions); am.getRegionStates().logSplit(this.serverName); }