/** * Be judicious calling this method. Do it on server register ONLY otherwise * you could mess up online server accounting. TOOD: Review usage and convert * to {@link #getServerNode(ServerName)} where we can. */ public ServerStateNode getOrCreateServer(final ServerName serverName) { ServerStateNode node = serverMap.get(serverName); if (node == null) { node = new ServerStateNode(serverName); ServerStateNode oldNode = serverMap.putIfAbsent(serverName, node); node = oldNode != null ? oldNode : node; } return node; }
@Override public boolean equals(final Object other) { if (this == other) { return true; } if (!(other instanceof ServerStateNode)) { return false; } return compareTo((ServerStateNode) other) == 0; }
public double getAverageLoad() { int numServers = 0; int totalLoad = 0; for (ServerStateNode node: serverMap.values()) { totalLoad += node.getRegionCount(); numServers++; } return numServers == 0 ? 0.0: (double)totalLoad / (double)numServers; }
serverNode.writeLock().lock(); try { ProcedureExecutor<MasterProcedureEnv> procExec = this.master.getMasterProcedureExecutor(); carryingMeta = isCarryingMeta(serverName); if (!serverNode.isInState(ServerState.ONLINE)) { LOG.info( "Skip to add SCP for {} with meta= {}, " + return -1; } else { serverNode.setState(ServerState.CRASHED); pid = procExec.submitProcedure(new ServerCrashProcedure(procExec.getEnvironment(), serverName, shouldSplitWal, carryingMeta)); serverNode.writeLock().unlock();
/** * This is an EXPENSIVE clone. Cloning though is the safest thing to do. * Can't let out original since it can change and at least the load balancer * wants to iterate this exported list. We need to synchronize on regions * since all access to this.servers is under a lock on this.regions. * @param forceByCluster a flag to force to aggregate the server-load to the cluster level * @return A clone of current assignments by table. */ public Map<TableName, Map<ServerName, List<RegionInfo>>> getAssignmentsByTable( final boolean forceByCluster) { if (!forceByCluster) return getAssignmentsByTable(); final HashMap<ServerName, List<RegionInfo>> ensemble = new HashMap<ServerName, List<RegionInfo>>(serverMap.size()); for (ServerStateNode serverNode: serverMap.values()) { ensemble.put(serverNode.getServerName(), serverNode.getRegionInfoList()); } // TODO: can we use Collections.singletonMap(HConstants.ENSEMBLE_TABLE_NAME, ensemble)? final Map<TableName, Map<ServerName, List<RegionInfo>>> result = new HashMap<TableName, Map<ServerName, List<RegionInfo>>>(1); result.put(HConstants.ENSEMBLE_TABLE_NAME, ensemble); return result; }
@Override public String toString() { return String.format("ServerStateNode(%s)", getServerName()); } }
Assert.assertNotNull(serverNode); Assert.assertTrue("serverNode should be ONLINE when cluster runs normally", serverNode.isInState(ServerState.ONLINE)); UTIL.createMultiRegionTable(tableName, FAMILY); UTIL.waitTableEnabled(tableName); .getServerNode(testServer); Assert.assertNotNull("serverNode should not be null when restart whole cluster", serverNode); Assert.assertFalse(serverNode.isInState(ServerState.ONLINE)); LOG.info("start to find the procedure of SCP for the severName we choose"); UTIL.waitFor(20000, && ((ServerCrashProcedure) procedure).getServerName().equals(testServer))); Assert.assertFalse("serverNode should not be ONLINE during SCP processing", serverNode.isInState(ServerState.ONLINE)); LOG.info("start to submit the SCP for the same serverName {} which should fail", testServer); Assert.assertFalse(
private List<RegionInfo> getSystemTables(ServerName serverName) { ServerStateNode serverNode = regionStates.getServerNode(serverName); if (serverNode == null) { return Collections.emptyList(); } return serverNode.getSystemRegionInfoList(); }
/** * Returns the regions hosted by the specified server. * <p/> * Notice that, for SCP, after we submit the SCP, no one can change the region list for the * ServerStateNode so we do not need any locks here. And for other usage, this can only give you a * snapshot of the current region list for this server, which means, right after you get the * region list, new regions may be moved to this server or some regions may be moved out from this * server, so you should not use it critically if you need strong consistency. */ public List<RegionInfo> getRegionsOnServer(ServerName serverName) { ServerStateNode serverInfo = regionStates.getServerNode(serverName); if (serverInfo == null) { return Collections.emptyList(); } return serverInfo.getRegionInfoList(); }
public ServerStateNode addRegionToServer(final RegionStateNode regionNode) { ServerStateNode serverNode = getOrCreateServer(regionNode.getRegionLocation()); serverNode.addRegion(regionNode); return serverNode; }
@Override public int compareTo(final ServerStateNode other) { return getServerName().compareTo(other.getServerName()); }
@Override public int hashCode() { return getServerName().hashCode(); }
private boolean reportTransition(RegionStateNode regionNode, ServerStateNode serverNode, TransitionCode state, long seqId) throws IOException { ServerName serverName = serverNode.getServerName(); TransitRegionStateProcedure proc = regionNode.getProcedure(); if (proc == null) { return false; } proc.reportTransition(master.getMasterProcedureExecutor().getEnvironment(), regionNode, serverName, state, seqId); return true; }
private void checkOnlineRegionsReport(ServerStateNode serverNode, Set<byte[]> regionNames) { ServerName serverName = serverNode.getServerName(); for (byte[] regionName : regionNames) { if (!isRunning()) {