/** * To clear any dead server with same host name and port of any online server */ void clearDeadServersWithSameHostNameAndPortOfOnlineServer() { for (ServerName serverName : getOnlineServersList()) { deadservers.cleanAllPreviousInstances(serverName); } }
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; }
/** * 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; }
protected final void refreshPeer(MasterProcedureEnv env, PeerOperationType type) { addChildProcedure(env.getMasterServices().getServerManager().getOnlineServersList().stream() .map(sn -> new RefreshPeerProcedure(peerId, type, sn)).toArray(RefreshPeerProcedure[]::new)); }
private List<ServerName> getOnlineRS() throws IOException { if (masterServices != null) { return masterServices.getServerManager().getOnlineServersList(); } LOG.debug("Reading online RS from zookeeper"); List<ServerName> servers = new LinkedList<>(); try { for (String el : ZKUtil.listChildrenNoWatch(watcher, watcher.getZNodePaths().rsZNode)) { servers.add(ServerName.parseServerName(el)); } } catch (KeeperException e) { throw new IOException("Failed to retrieve server list from zookeeper", e); } return servers; }
/** * Get a list of servers that this region cannot be assigned to. * For system tables, we must assign them to a server with highest version. */ public List<ServerName> getExcludedServersForSystemTable() { // TODO: This should be a cached list kept by the ServerManager rather than calculated on each // move or system region assign. The RegionServerTracker keeps list of online Servers with // RegionServerInfo that includes Version. List<Pair<ServerName, String>> serverList = master.getServerManager().getOnlineServersList() .stream() .map((s)->new Pair<>(s, master.getRegionServerVersion(s))) .collect(Collectors.toList()); if (serverList.isEmpty()) { return Collections.emptyList(); } String highestVersion = Collections.max(serverList, (o1, o2) -> VersionInfo.compareVersion(o1.getSecond(), o2.getSecond())).getSecond(); return serverList.stream() .filter((p)->!p.getSecond().equals(highestVersion)) .map(Pair::getFirst) .collect(Collectors.toList()); }
/** * 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); }
List<ServerName> serverNames = master.getServerManager().getOnlineServersList(); List<String> servers = new ArrayList<>(); for (ServerName sn : serverNames) {
case SWITCH_RPC_THROTTLE_ON_RS: SwitchRpcThrottleRemoteProcedure[] subProcedures = env.getMasterServices().getServerManager().getOnlineServersList().stream() .map(sn -> new SwitchRpcThrottleRemoteProcedure(sn, rpcThrottleEnabled)) .toArray(SwitchRpcThrottleRemoteProcedure[]::new);
@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; }
if (serverManager != null) { deadServers = serverManager.getDeadServers().copyServerNames(); servers = serverManager.getOnlineServersList();
List<ServerName> serverNames = master.getServerManager().getOnlineServersList(); List<String> servers = new ArrayList<>(); for (ServerName sn : serverNames) {
@Test public void testNewStartedRegionServerVersion() throws Exception { UTIL.startMiniCluster(1); // Start 3 new region server Thread t = new Thread(() -> { for (int i = 0; i < 3; i++) { try { JVMClusterUtil.RegionServerThread newRS = UTIL.getMiniHBaseCluster().startRegionServer(); newRS.waitForServerOnline(); } catch (IOException e) { LOG.error("Failed to start a new RS", e); } } }); t.start(); HMaster master = UTIL.getMiniHBaseCluster().getMaster(); while (t.isAlive()) { List<ServerName> serverNames = master.getServerManager().getOnlineServersList(); for (ServerName serverName : serverNames) { assertNotEquals(0, master.getServerManager().getVersionNumber(serverName)); } Thread.sleep(100); } }
@Test public void testRewritingClusterIdToPB() throws Exception { TEST_UTIL.startMiniZKCluster(); TEST_UTIL.startMiniDFSCluster(1); TEST_UTIL.createRootDir(); Path rootDir = FSUtils.getRootDir(TEST_UTIL.getConfiguration()); FileSystem fs = rootDir.getFileSystem(TEST_UTIL.getConfiguration()); Path filePath = new Path(rootDir, HConstants.CLUSTER_ID_FILE_NAME); FSDataOutputStream s = null; try { s = fs.create(filePath); s.writeUTF(TEST_UTIL.getRandomUUID().toString()); } finally { if (s != null) { s.close(); } } TEST_UTIL.startMiniHBaseCluster(); HMaster master = TEST_UTIL.getHBaseCluster().getMaster(); int expected = LoadBalancer.isTablesOnMaster(TEST_UTIL.getConfiguration())? 2: 1; assertEquals(expected, master.getServerManager().getOnlineServersList().size()); }
public void markRegionAsSplit(final RegionInfo parent, final ServerName serverName, final RegionInfo daughterA, final RegionInfo daughterB) throws IOException { // Update hbase:meta. Parent will be marked offline and split up in hbase:meta. // The parent stays in regionStates until cleared when removed by CatalogJanitor. // Update its state in regionStates to it shows as offline and split when read // later figuring what regions are in a table and what are not: see // regionStates#getRegionsOfTable final RegionStateNode node = regionStates.getOrCreateRegionStateNode(parent); node.setState(State.SPLIT); final RegionStateNode nodeA = regionStates.getOrCreateRegionStateNode(daughterA); nodeA.setState(State.SPLITTING_NEW); final RegionStateNode nodeB = regionStates.getOrCreateRegionStateNode(daughterB); nodeB.setState(State.SPLITTING_NEW); regionStateStore.splitRegion(parent, daughterA, daughterB, serverName); if (shouldAssignFavoredNodes(parent)) { List<ServerName> onlineServers = this.master.getServerManager().getOnlineServersList(); ((FavoredNodesPromoter)getBalancer()). generateFavoredNodesForDaughter(onlineServers, parent, daughterA, daughterB); } }
assertEquals(backupMaster.getMaster().getServerManager().getOnlineServersList().size(), tablesOnMaster? 3: 2);
/** * Call this restart method only after running MockMasterServices#start() * The RSs can be differentiated by the port number, see * ServerName in MockMasterServices#start() method above. * Restart of region server will have new startcode in server name * * @param serverName Server name to be restarted */ public void restartRegionServer(ServerName serverName) throws IOException { List<ServerName> onlineServers = serverManager.getOnlineServersList(); long startCode = -1; for (ServerName s : onlineServers) { if (s.getAddress().equals(serverName.getAddress())) { startCode = s.getStartcode() + 1; break; } } if (startCode == -1) { return; } ServerName sn = ServerName.valueOf(serverName.getAddress().toString(), startCode); serverManager.regionServerReport(sn, ServerMetricsBuilder.of(sn)); }
UTIL.getHBaseCluster().getMaster().getServerManager().getOnlineServersList().stream() .map(serverName -> serverName.getPort()).collect(Collectors.toList()); LOG.info("Shutting down cluster");
try { Table t = TEST_UTIL.createMultiRegionTable(tn, HConstants.CATALOG_FAMILY, REGIONS); LOG.info("Server: " + cluster.getMaster().getServerManager().getOnlineServersList()); List<HRegion> regions = cluster.getMaster().getRegions(); int mActualCount = regions.size();
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);