List<ServerName> drainingServers = master.getServerManager().getDrainingServersList(); for (ServerName server : master.getServerManager().getOnlineServers().keySet()) { for(ServerName server: master.getServerManager().getDeadServers().copyServerNames()) { deadServers.add(server.getAddress());
public synchronized Optional<ServerName> acquire() { List<ServerName> serverList = master.getServerManager().getOnlineServersList(); Collections.shuffle(serverList); Optional<ServerName> worker = serverList.stream().filter( serverName -> !currentWorkers.containsKey(serverName) || currentWorkers.get(serverName) > 0) .findAny(); if (worker.isPresent()) { currentWorkers.compute(worker.get(), (serverName, availableWorker) -> availableWorker == null ? maxSplitTasks - 1 : availableWorker - 1); } return worker; }
return false; if (serverManager.areDeadServersInProgress()) { LOG.debug("Not running balancer because processing dead regionserver(s): " + serverManager.getDeadServers()); return false;
/** * Creates a list of possible destinations for a region. It contains the online servers, but not * the draining or dying servers. * @param serversToExclude can be null if there is no server to exclude */ public List<ServerName> createDestinationServersList(final List<ServerName> serversToExclude){ final List<ServerName> destServers = getOnlineServersList(); if (serversToExclude != null) { destServers.removeAll(serversToExclude); } // Loop through the draining server list and remove them from the server list final List<ServerName> drainingServersCopy = getDrainingServersList(); destServers.removeAll(drainingServersCopy); return destServers; }
@Override public boolean start() { if (!super.start()) { return false; } master.getServerManager().registerListener(this); procedureEnv = master.getMasterProcedureExecutor().getEnvironment(); for (ServerName serverName: master.getServerManager().getOnlineServersList()) { addNode(serverName); } return true; }
public Optional<ServerName> acquire(ServerManager serverManager) { Optional<ServerName> worker = serverManager.getOnlineServers().keySet().stream() .filter(server -> !usedWorkers.contains(server)).findAny(); worker.ifPresent(usedWorkers::add); return worker; }
final List<ServerName> servers = this.serverManager.getOnlineServersList(); final List<ServerName> drainingServers = this.serverManager.getDrainingServersList(); "an existing plan) for " + state.getRegion().getRegionNameAsString() + " so generated a random one; " + randomPlan + "; " + serverManager.countOfRegionServers() + " (online=" + serverManager.getOnlineServers().size() + ", available=" + servers.size() + ") available servers"); return randomPlan;
if (!force || metaInTransition) return false; if (this.serverManager.areDeadServersInProgress()) { LOG.info("Not running balancer because processing dead regionserver(s): " + this.serverManager.getDeadServers()); return false; serverMap.keySet().removeAll(this.serverManager.getDrainingServersList());
assertEquals(master.getMasterStartTime(), info.getStartTime()); assertEquals(master.getMasterCoprocessors().length, info.getCoprocessors().length); assertEquals(master.getServerManager().getOnlineServersList().size(), info.getNumRegionServers()); int regionServerCount = NUM_RS + (LoadBalancer.isTablesOnMaster(TEST_UTIL.getConfiguration())? 1: 0); while (TEST_UTIL.getHBaseCluster().getMaster().getServerManager().getOnlineServers().size() == regionServerCount ) { Threads.sleep(10);
/** * Split a server's log and expire it if we find it is one of the online * servers. * @param sn ServerName to check. * @throws IOException */ private void splitLogAndExpireIfOnline(final ServerName sn) throws IOException { if (sn == null || !serverManager.isServerOnline(sn)) { return; } LOG.info("Forcing splitLog and expire of " + sn); fileSystemManager.splitLog(sn); serverManager.expireServer(sn); }
UTIL.getHBaseCluster().getMaster().getServerManager().getOnlineServersList().stream() .map(serverName -> serverName.getPort()).collect(Collectors.toList()); LOG.info("Shutting down cluster"); LOG.info("start to submit the SCP for the same serverName {} which should fail", testServer); Assert.assertFalse( UTIL.getHBaseCluster().getMaster().getServerManager().expireServer(testServer)); Procedure procedure = UTIL.getHBaseCluster().getMaster().getProcedures().stream() .filter(p -> (p instanceof ServerCrashProcedure) testServer); Assert.assertFalse( UTIL.getHBaseCluster().getMaster().getServerManager().expireServer(testServer)); serverNode = UTIL.getHBaseCluster().getMaster().getAssignmentManager().getRegionStates() .getServerNode(testServer);
/** * Calls {@link #createDestinationServersList} without server to exclude. */ public List<ServerName> createDestinationServersList(){ return createDestinationServersList(null); }
Mockito.doReturn(1.0).when(serverManager).getAverageLoad(); Mockito.doReturn(serverManager).when(master).getServerManager(); Mockito.doReturn(deadServer).when(serverManager).getDeadServers();
onlineSvrs = serverManager.getOnlineServers(); List<ServerName> drainingServers = this.serverManager.getDrainingServersList(); for (Map<ServerName, List<HRegionInfo>> map: result.values()) { for (ServerName svr: onlineSvrs.keySet()) {
ServerManager serverManager = master.getServerManager(); if (serverManager != null) { deadServers = serverManager.getDeadServers().copyServerNames(); servers = serverManager.getOnlineServersList();
ServerManager serverManager = mock(ServerManager.class); doAnswer(inv -> listeners.add(inv.getArgument(0))).when(serverManager) .registerListener(any(ServerListener.class)); ServerMetrics serverMetrics = mock(ServerMetrics.class); doAnswer(inv -> onlineServers.stream() .collect(Collectors.toMap(Function.identity(), k -> serverMetrics))).when(serverManager) .getOnlineServers();
@Override public String getDeadRegionServers() { ServerManager serverManager = this.master.getServerManager(); if (serverManager == null) { return ""; } return StringUtils.join(serverManager.getDeadServers().copyServerNames(), ";"); }
/** * Create round-robin assigns. Use on table creation to distribute out regions across cluster. * @return AssignProcedures made out of the passed in <code>hris</code> and a call to the balancer * to populate the assigns with targets chosen using round-robin (default balancer * scheme). If at assign-time, the target chosen is no longer up, thats fine, the * AssignProcedure will ask the balancer for a new target, and so on. */ public TransitRegionStateProcedure[] createRoundRobinAssignProcedures(List<RegionInfo> hris, List<ServerName> serversToExclude) { if (hris.isEmpty()) { return new TransitRegionStateProcedure[0]; } if (serversToExclude != null && this.master.getServerManager().getOnlineServersList().size() == 1) { LOG.debug("Only one region server found and hence going ahead with the assignment"); serversToExclude = null; } try { // Ask the balancer to assign our regions. Pass the regions en masse. The balancer can do // a better job if it has all the assignments in the one lump. Map<ServerName, List<RegionInfo>> assignments = getBalancer().roundRobinAssignment(hris, this.master.getServerManager().createDestinationServersList(serversToExclude)); // Return mid-method! return createAssignProcedures(assignments); } catch (HBaseIOException hioe) { LOG.warn("Failed roundRobinAssignment", hioe); } // If an error above, fall-through to this simpler assign. Last resort. return createAssignProcedures(hris); }
/** * Creates a list of possible destinations for a region. It contains the online servers, but not * the draining or dying servers. * @param serverToExclude can be null if there is no server to exclude */ public List<ServerName> createDestinationServersList(final ServerName serverToExclude){ final List<ServerName> destServers = getOnlineServersList(); if (serverToExclude != null){ destServers.remove(serverToExclude); } // Loop through the draining server list and remove them from the server list final List<ServerName> drainingServersCopy = getDrainingServersList(); if (!drainingServersCopy.isEmpty()) { for (final ServerName server: drainingServersCopy) { destServers.remove(server); } } // Remove the deadNotExpired servers from the server list. removeDeadNotExpiredServers(destServers); return destServers; }
if (!masterRecovery) { this.executorService = new ExecutorService(getServerName().toString()); this.serverManager = new ServerManager(this, this); this.serverManager.waitForRegionServers(status); if (!this.serverManager.isServerOnline(sn)) { this.serverManager.recordNewServer(sn, HServerLoad.EMPTY_HSERVERLOAD); this.serverManager.clearDeadServersWithSameHostNameAndPortOfOnlineServer();