Java ServerName.equals方法代码示例

import org.apache.hadoop.hbase.ServerName; //导入方法依赖的package包/类
/**
  * @param sn
  * @return Admin interface for the remote regionserver named <code>sn</code>
  * @throws IOException
  * @throws RetriesExhaustedException wrapping a ConnectException if failed
  */
private AdminService.BlockingInterface getRsAdmin(final ServerName sn)
throws IOException {
  AdminService.BlockingInterface admin = this.rsAdmins.get(sn);
  if (admin == null) {
    LOG.debug("New admin connection to " + sn.toString());
    if (sn.equals(master.getServerName()) && master instanceof HRegionServer) {
      // A master is also a region server now, see HBASE-10569 for details
      admin = ((HRegionServer)master).getRSRpcServices();
    } else {
      admin = this.connection.getAdmin(sn);
    }
    this.rsAdmins.put(sn, admin);
  }
  return admin;
}
 

import org.apache.hadoop.hbase.ServerName; //导入方法依赖的package包/类
private void moveRegionAndWait(HRegionInfo destRegion, ServerName destServer)
    throws InterruptedException, MasterNotRunningException,
    ZooKeeperConnectionException, IOException {
  HMaster master = TEST_UTIL.getMiniHBaseCluster().getMaster();
  TEST_UTIL.getHBaseAdmin().move(
      destRegion.getEncodedNameAsBytes(),
      Bytes.toBytes(destServer.getServerName()));
  while (true) {
    ServerName serverName = master.getAssignmentManager()
        .getRegionStates().getRegionServerOfRegion(destRegion);
    if (serverName != null && serverName.equals(destServer)) {
      TEST_UTIL.assertRegionOnServer(
          destRegion, serverName, 200);
      break;
    }
    Thread.sleep(10);
  }
}
 

import org.apache.hadoop.hbase.ServerName; //导入方法依赖的package包/类
private void moveRegionAndWait(Region destRegion, HRegionServer destServer)
    throws InterruptedException, MasterNotRunningException,
    ZooKeeperConnectionException, IOException {
  HMaster master = TEST_UTIL.getMiniHBaseCluster().getMaster();
  TEST_UTIL.getHBaseAdmin().move(
      destRegion.getRegionInfo().getEncodedNameAsBytes(),
      Bytes.toBytes(destServer.getServerName().getServerName()));
  while (true) {
    ServerName serverName = master.getAssignmentManager()
      .getRegionStates().getRegionServerOfRegion(destRegion.getRegionInfo());
    if (serverName != null && serverName.equals(destServer.getServerName())) {
      TEST_UTIL.assertRegionOnServer(
        destRegion.getRegionInfo(), serverName, 200);
      break;
    }
    Thread.sleep(10);
  }
}
 

import org.apache.hadoop.hbase.ServerName; //导入方法依赖的package包/类
@Override
protected synchronized ServerName createRegionServerStatusStub() {
  sn = super.createRegionServerStatusStub();
  rpcStubCreatedFlag = true;

  // Wait for master switch over. Only do this for the second region server.
  while (!masterChanged) {
    ServerName newSn = super.getMasterAddressTracker().getMasterAddress(true);
    if (newSn != null && !newSn.equals(sn)) {
      masterChanged = true;
      break;
    }
    try {
      Thread.sleep(SLEEP_INTERVAL);
    } catch (InterruptedException e) {
      return null;
    }
    LOG.debug("Waiting for master switch over ... ");
  }
  return sn;
}
 

import org.apache.hadoop.hbase.ServerName; //导入方法依赖的package包/类
@Override
public void perform() throws Exception {
  LOG.info("Performing action: Restart region server holding META");
  ServerName server = cluster.getServerHoldingMeta();
  if (server == null) {
    LOG.warn("No server is holding hbase:meta right now.");
    return;
  }
  ClusterStatus clusterStatus = cluster.getClusterStatus();
  if (server.equals(clusterStatus.getMaster())) {
    // Master holds the meta, so restart the master.
    restartMaster(server, sleepTime);
  } else {
    restartRs(server, sleepTime);
  }
}
 

import org.apache.hadoop.hbase.ServerName; //导入方法依赖的package包/类
/**
 * Add a region to RegionStates with the specified state.
 * If the region is already in RegionStates, this call has
 * no effect, and the original state is returned.
 *
 * @param hri the region info to create a state for
 * @param newState the state to the region in set to
 * @param serverName the server the region is transitioning on
 * @param lastHost the last server that hosts the region
 * @return the current state
 */
public synchronized RegionState createRegionState(final HRegionInfo hri,
    State newState, ServerName serverName, ServerName lastHost) {
  if (newState == null || (newState == State.OPEN && serverName == null)) {
    newState =  State.OFFLINE;
  }
  if (hri.isOffline() && hri.isSplit()) {
    newState = State.SPLIT;
    serverName = null;
  }
  String encodedName = hri.getEncodedName();
  RegionState regionState = regionStates.get(encodedName);
  if (regionState != null) {
    LOG.warn("Tried to create a state for a region already in RegionStates, "
      + "used existing: " + regionState + ", ignored new: " + newState);
  } else {
    regionState = new RegionState(hri, newState, serverName);
    putRegionState(regionState);
    if (newState == State.OPEN) {
      if (!serverName.equals(lastHost)) {
        LOG.warn("Open region's last host " + lastHost
          + " should be the same as the current one " + serverName
          + ", ignored the last and used the current one");
        lastHost = serverName;
      }
      lastAssignments.put(encodedName, lastHost);
      regionAssignments.put(hri, lastHost);
    } else if (!regionState.isUnassignable()) {
      regionsInTransition.put(encodedName, regionState);
    }
    if (lastHost != null && newState != State.SPLIT) {
      addToServerHoldings(lastHost, hri);
      if (newState != State.OPEN) {
        oldAssignments.put(encodedName, lastHost);
      }
    }
  }
  return regionState;
}
 

import org.apache.hadoop.hbase.ServerName; //导入方法依赖的package包/类
/**
 * A region is online, won't be in transition any more.
 * We can't confirm it is really online on specified region server
 * because it hasn't been put in region server's online region list yet.
 */
public void regionOnline(final HRegionInfo hri, final ServerName serverName, long openSeqNum) {
  String encodedName = hri.getEncodedName();
  if (!serverManager.isServerOnline(serverName)) {
    // This is possible if the region server dies before master gets a
    // chance to handle ZK event in time. At this time, if the dead server
    // is already processed by SSH, we should ignore this event.
    // If not processed yet, ignore and let SSH deal with it.
    LOG.warn("Ignored, " + encodedName + " was opened on a dead server: " + serverName);
    return;
  }
  updateRegionState(hri, State.OPEN, serverName, openSeqNum);

  synchronized (this) {
    regionsInTransition.remove(encodedName);
    ServerName oldServerName = regionAssignments.put(hri, serverName);
    if (!serverName.equals(oldServerName)) {
      if (LOG.isDebugEnabled()) {
        LOG.debug("Onlined " + hri.getShortNameToLog() + " on " + serverName);
      }
      addToServerHoldings(serverName, hri);
      addToReplicaMapping(hri);
      if (oldServerName == null) {
        oldServerName = oldAssignments.remove(encodedName);
      }
      if (oldServerName != null
          && !oldServerName.equals(serverName)
          && serverHoldings.containsKey(oldServerName)) {
        LOG.info("Offlined " + hri.getShortNameToLog() + " from " + oldServerName);
        removeFromServerHoldings(oldServerName, hri);
      }
    }
  }
}
 

import org.apache.hadoop.hbase.ServerName; //导入方法依赖的package包/类
@Test
public void testMetaAddressChange() throws Exception {
  // checks that even when the meta's location changes, the various
  // caches update themselves. Uses the master operations to test
  // this
  Configuration conf = TEST_UTIL.getConfiguration();
  ZooKeeperWatcher zkw = TEST_UTIL.getZooKeeperWatcher();
  String baseZNode = conf.get(HConstants.ZOOKEEPER_ZNODE_PARENT,
      HConstants.DEFAULT_ZOOKEEPER_ZNODE_PARENT);
  String primaryMetaZnode = ZKUtil.joinZNode(baseZNode,
      conf.get("zookeeper.znode.metaserver", "meta-region-server"));
  // check that the data in the znode is parseable (this would also mean the znode exists)
  byte[] data = ZKUtil.getData(zkw, primaryMetaZnode);
  ServerName currentServer = ServerName.parseFrom(data);
  Collection<ServerName> liveServers = TEST_UTIL.getHBaseAdmin().getClusterStatus().getServers();
  ServerName moveToServer = null;
  for (ServerName s : liveServers) {
    if (!currentServer.equals(s)) {
      moveToServer = s;
    }
  }
  assert(moveToServer != null);
  String tableName = "randomTable5678";
  TEST_UTIL.createTable(TableName.valueOf(tableName), "f");
  assertTrue(TEST_UTIL.getHBaseAdmin().tableExists(tableName));
  TEST_UTIL.getHBaseAdmin().move(HRegionInfo.FIRST_META_REGIONINFO.getEncodedNameAsBytes(),
      Bytes.toBytes(moveToServer.getServerName()));
  int i = 0;
  do {
    Thread.sleep(10);
    data = ZKUtil.getData(zkw, primaryMetaZnode);
    currentServer = ServerName.parseFrom(data);
    i++;
  } while (!moveToServer.equals(currentServer) && i < 1000); //wait for 10 seconds overall
  assert(i != 1000);
  TEST_UTIL.getHBaseAdmin().disableTable("randomTable5678");
  assertTrue(TEST_UTIL.getHBaseAdmin().isTableDisabled("randomTable5678"));
}
 

import org.apache.hadoop.hbase.ServerName; //导入方法依赖的package包/类
@Test (timeout=300000)
public void testPreWALRestoreSkip() throws Exception {
  LOG.info(TestRegionObserverInterface.class.getName() + ".testPreWALRestoreSkip");
  TableName tableName = TableName.valueOf(SimpleRegionObserver.TABLE_SKIPPED);
  HTable table = util.createTable(tableName, new byte[][] { A, B, C });

  JVMClusterUtil.RegionServerThread rs1 = cluster.startRegionServer();
  ServerName sn2 = rs1.getRegionServer().getServerName();
  String regEN = table.getRegionLocations().firstEntry().getKey().getEncodedName();

  util.getHBaseAdmin().move(regEN.getBytes(), sn2.getServerName().getBytes());
  while (!sn2.equals(table.getRegionLocations().firstEntry().getValue())) {
    Thread.sleep(100);
  }

  Put put = new Put(ROW);
  put.add(A, A, A);
  put.add(B, B, B);
  put.add(C, C, C);
  table.put(put);
  table.flushCommits();

  cluster.killRegionServer(rs1.getRegionServer().getServerName());
  Threads.sleep(20000); // just to be sure that the kill has fully started.
  util.waitUntilAllRegionsAssigned(tableName);

  verifyMethodResult(SimpleRegionObserver.class, new String[] { "getCtPreWALRestore",
      "getCtPostWALRestore", "getCtPreWALRestoreDeprecated", "getCtPostWALRestoreDeprecated"},
      tableName,
      new Integer[] {0, 0, 0, 0});

  util.deleteTable(tableName);
  table.close();
}
 

import org.apache.hadoop.hbase.ServerName; //导入方法依赖的package包/类
@Override
public void perform() throws Exception {
  int tries = 10;

  while (tries-- > 0 && getCurrentServers().length > 1) {
    ServerName server = PolicyBasedChaosMonkey.selectRandomItem(getCurrentServers());
    ServerName metaServer = cluster.getServerHoldingMeta();
    if (server != null && !server.equals(metaServer)) {
      restartRs(server, sleepTime);
      break;
    }
  }
}
 

import org.apache.hadoop.hbase.ServerName; //导入方法依赖的package包/类
@Override
public List<RegionPlan> balanceCluster(Map<ServerName, List<HRegionInfo>> clusterState)  {
  //TODO. Look at is whether Stochastic loadbalancer can be integrated with this
  List<RegionPlan> plans = new ArrayList<RegionPlan>();
  //perform a scan of the meta to get the latest updates (if any)
  SnapshotOfRegionAssignmentFromMeta snaphotOfRegionAssignment =
      new SnapshotOfRegionAssignmentFromMeta(super.services.getConnection());
  try {
    snaphotOfRegionAssignment.initialize();
  } catch (IOException ie) {
    LOG.warn("Not running balancer since exception was thrown " + ie);
    return plans;
  }
  globalFavoredNodesAssignmentPlan = snaphotOfRegionAssignment.getExistingAssignmentPlan();
  Map<ServerName, ServerName> serverNameToServerNameWithoutCode =
      new HashMap<ServerName, ServerName>();
  Map<ServerName, ServerName> serverNameWithoutCodeToServerName =
      new HashMap<ServerName, ServerName>();
  ServerManager serverMgr = super.services.getServerManager();
  for (ServerName sn: serverMgr.getOnlineServersList()) {
    ServerName s = ServerName.valueOf(sn.getHostname(), sn.getPort(), ServerName.NON_STARTCODE);
    serverNameToServerNameWithoutCode.put(sn, s);
    serverNameWithoutCodeToServerName.put(s, sn);
  }
  for (Map.Entry<ServerName, List<HRegionInfo>> entry : clusterState.entrySet()) {
    ServerName currentServer = entry.getKey();
    //get a server without the startcode for the currentServer
    ServerName currentServerWithoutStartCode = ServerName.valueOf(currentServer.getHostname(),
        currentServer.getPort(), ServerName.NON_STARTCODE);
    List<HRegionInfo> list = entry.getValue();
    for (HRegionInfo region : list) {
      if(region.getTable().getNamespaceAsString()
          .equals(NamespaceDescriptor.SYSTEM_NAMESPACE_NAME_STR)) {
        continue;
      }
      List<ServerName> favoredNodes = globalFavoredNodesAssignmentPlan.getFavoredNodes(region);
      if (favoredNodes == null || favoredNodes.get(0).equals(currentServerWithoutStartCode)) {
        continue; //either favorednodes does not exist or we are already on the primary node
      }
      ServerName destination = null;
      //check whether the primary is available
      destination = serverNameWithoutCodeToServerName.get(favoredNodes.get(0));
      if (destination == null) {
        //check whether the region is on secondary/tertiary
        if (currentServerWithoutStartCode.equals(favoredNodes.get(1)) ||
            currentServerWithoutStartCode.equals(favoredNodes.get(2))) {
          continue;
        }
        //the region is currently on none of the favored nodes
        //get it on one of them if possible
        ServerLoad l1 = super.services.getServerManager().getLoad(
            serverNameWithoutCodeToServerName.get(favoredNodes.get(1)));
        ServerLoad l2 = super.services.getServerManager().getLoad(
            serverNameWithoutCodeToServerName.get(favoredNodes.get(2)));
        if (l1 != null && l2 != null) {
          if (l1.getLoad() > l2.getLoad()) {
            destination = serverNameWithoutCodeToServerName.get(favoredNodes.get(2));
          } else {
            destination = serverNameWithoutCodeToServerName.get(favoredNodes.get(1));
          }
        } else if (l1 != null) {
          destination = serverNameWithoutCodeToServerName.get(favoredNodes.get(1));
        } else if (l2 != null) {
          destination = serverNameWithoutCodeToServerName.get(favoredNodes.get(2));
        }
      }

      if (destination != null) {
        RegionPlan plan = new RegionPlan(region, currentServer, destination);
        plans.add(plan);
      }
    }
  }
  return plans;
}
 

import org.apache.hadoop.hbase.ServerName; //导入方法依赖的package包/类
public synchronized void expireServer(final ServerName serverName) {
  if (serverName.equals(master.getServerName())) {
    if (!(master.isAborted() || master.isStopped())) {
      master.stop("We lost our znode?");
    }
    return;
  }
  if (!services.isServerCrashProcessingEnabled()) {
    LOG.info("Master doesn't enable ServerShutdownHandler during initialization, "
        + "delay expiring server " + serverName);
    this.queuedDeadServers.add(serverName);
    return;
  }
  if (this.deadservers.isDeadServer(serverName)) {
    // TODO: Can this happen?  It shouldn't be online in this case?
    LOG.warn("Expiration of " + serverName +
        " but server shutdown already in progress");
    return;
  }
  moveFromOnelineToDeadServers(serverName);

  // If cluster is going down, yes, servers are going to be expiring; don't
  // process as a dead server
  if (this.clusterShutdown) {
    LOG.info("Cluster shutdown set; " + serverName +
      " expired; onlineServers=" + this.onlineServers.size());
    if (this.onlineServers.isEmpty()) {
      master.stop("Cluster shutdown set; onlineServer=0");
    }
    return;
  }

  boolean carryingMeta = services.getAssignmentManager().isCarryingMeta(serverName) ==
      AssignmentManager.ServerHostRegion.HOSTING_REGION;
  this.services.getMasterProcedureExecutor().
    submitProcedure(new ServerCrashProcedure(serverName, true, carryingMeta));
  LOG.debug("Added=" + serverName +
    " to dead servers, submitted shutdown handler to be executed meta=" + carryingMeta);

  // Tell our listeners that a server was removed
  if (!this.listeners.isEmpty()) {
    for (ServerListener listener : this.listeners) {
      listener.serverRemoved(serverName);
    }
  }
}
 

import org.apache.hadoop.hbase.ServerName; //导入方法依赖的package包/类
/**
 * Update the location with the new value (if the exception is a RegionMovedException)
 * or delete it from the cache. Does nothing if we can be sure from the exception that
 * the location is still accurate, or if the cache has already been updated.
 * @param exception an object (to simplify user code) on which we will try to find a nested
 *                  or wrapped or both RegionMovedException
 * @param source server that is the source of the location update.
 */
@Override
public void updateCachedLocations(final TableName tableName, byte[] regionName, byte[] rowkey,
  final Object exception, final ServerName source) {
  if (rowkey == null || tableName == null) {
    LOG.warn("Coding error, see method javadoc. row=" + (rowkey == null ? "null" : rowkey) +
        ", tableName=" + (tableName == null ? "null" : tableName));
    return;
  }

  if (source == null) {
    // This should not happen, but let's secure ourselves.
    return;
  }

  if (regionName == null) {
    // we do not know which region, so just remove the cache entry for the row and server
    metaCache.clearCache(tableName, rowkey, source);
    return;
  }

  // Is it something we have already updated?
  final RegionLocations oldLocations = getCachedLocation(tableName, rowkey);
  HRegionLocation oldLocation = null;
  if (oldLocations != null) {
    oldLocation = oldLocations.getRegionLocationByRegionName(regionName);
  }
  if (oldLocation == null || !source.equals(oldLocation.getServerName())) {
    // There is no such location in the cache (it's been removed already) or
    // the cache has already been refreshed with a different location.  => nothing to do
    return;
  }

  HRegionInfo regionInfo = oldLocation.getRegionInfo();
  Throwable cause = ClientExceptionsUtil.findException(exception);
  if (cause != null) {
    if (!ClientExceptionsUtil.isMetaClearingException(cause)) {
      // We know that the region is still on this region server
      return;
    }

    if (cause instanceof RegionMovedException) {
      RegionMovedException rme = (RegionMovedException) cause;
      if (LOG.isTraceEnabled()) {
        LOG.trace("Region " + regionInfo.getRegionNameAsString() + " moved to " +
            rme.getHostname() + ":" + rme.getPort() +
            " according to " + source.getHostAndPort());
      }
      // We know that the region is not anymore on this region server, but we know
      //  the new location.
      updateCachedLocation(
          regionInfo, source, rme.getServerName(), rme.getLocationSeqNum());
      return;
    }
  }

  // If we're here, it means that can cannot be sure about the location, so we remove it from
  // the cache. Do not send the source because source can be a new server in the same host:port
  metaCache.clearCache(regionInfo);
}
 

import org.apache.hadoop.hbase.ServerName; //导入方法依赖的package包/类
/**
 * Clean out crashed server removing any assignments.
 * @param sn Server that went down.
 * @return list of regions in transition on this server
 */
public List<HRegionInfo> cleanOutCrashedServerReferences(final ServerName sn) {
  // Clean out any existing assignment plans for this server
  synchronized (this.regionPlans) {
    for (Iterator <Map.Entry<String, RegionPlan>> i = this.regionPlans.entrySet().iterator();
        i.hasNext();) {
      Map.Entry<String, RegionPlan> e = i.next();
      ServerName otherSn = e.getValue().getDestination();
      // The name will be null if the region is planned for a random assign.
      if (otherSn != null && otherSn.equals(sn)) {
        // Use iterator's remove else we'll get CME
        i.remove();
      }
    }
  }
  List<HRegionInfo> regions = regionStates.serverOffline(watcher, sn);
  for (Iterator<HRegionInfo> it = regions.iterator(); it.hasNext(); ) {
    HRegionInfo hri = it.next();
    String encodedName = hri.getEncodedName();

    // We need a lock on the region as we could update it
    Lock lock = locker.acquireLock(encodedName);
    try {
      RegionState regionState = regionStates.getRegionTransitionState(encodedName);
      if (regionState == null
          || (regionState.getServerName() != null && !regionState.isOnServer(sn))
          || !(regionState.isFailedClose() || regionState.isOffline()
            || regionState.isPendingOpenOrOpening())) {
        LOG.info("Skip " + regionState + " since it is not opening/failed_close"
          + " on the dead server any more: " + sn);
        it.remove();
      } else {
        try {
          // Delete the ZNode if exists
          ZKAssign.deleteNodeFailSilent(watcher, hri);
        } catch (KeeperException ke) {
          server.abort("Unexpected ZK exception deleting node " + hri, ke);
        }
        if (tableStateManager.isTableState(hri.getTable(),
            ZooKeeperProtos.Table.State.DISABLED, ZooKeeperProtos.Table.State.DISABLING)) {
          regionStates.regionOffline(hri);
          it.remove();
          continue;
        }
        // Mark the region offline and assign it again by SSH
        regionStates.updateRegionState(hri, State.OFFLINE);
      }
    } finally {
      lock.unlock();
    }
  }
  return regions;
}
 

import org.apache.hadoop.hbase.ServerName; //导入方法依赖的package包/类
/**
 * Get the current master from ZooKeeper and open the RPC connection to it.
 * To get a fresh connection, the current rssStub must be null.
 * Method will block until a master is available. You can break from this
 * block by requesting the server stop.
 *
 * @return master + port, or null if server has been stopped
 */
@VisibleForTesting protected synchronized ServerName createRegionServerStatusStub() {
  if (rssStub != null) {
    return masterAddressTracker.getMasterAddress();
  }
  ServerName sn = null;
  long previousLogTime = 0;
  boolean refresh = false; // for the first time, use cached data
  RegionServerStatusService.BlockingInterface intf = null;
  boolean interrupted = false;
  try {
    while (keepLooping()) {
      sn = this.masterAddressTracker.getMasterAddress(refresh);
      if (sn == null) {
        if (!keepLooping()) {
          // give up with no connection.
          LOG.debug("No master found and cluster is stopped; bailing out");
          return null;
        }
        if (System.currentTimeMillis() > (previousLogTime + 1000)) {
          LOG.debug("No master found; retry");
          previousLogTime = System.currentTimeMillis();
        }
        refresh = true; // let's try pull it from ZK directly
        if (sleep(200)) {
          interrupted = true;
        }
        continue;
      }

      // If we are on the active master, use the shortcut
      if (this instanceof HMaster && sn.equals(getServerName())) {
        intf = ((HMaster) this).getMasterRpcServices();
        break;
      }
      try {
        BlockingRpcChannel channel = this.rpcClient
            .createBlockingRpcChannel(sn, userProvider.getCurrent(), shortOperationTimeout);
        intf = RegionServerStatusService.newBlockingStub(channel);
        break;
      } catch (IOException e) {
        if (System.currentTimeMillis() > (previousLogTime + 1000)) {
          e = e instanceof RemoteException ? ((RemoteException) e).unwrapRemoteException() : e;
          if (e instanceof ServerNotRunningYetException) {
            LOG.info("Master isn't available yet, retrying");
          } else {
            LOG.warn("Unable to connect to master. Retrying. Error was:", e);
          }
          previousLogTime = System.currentTimeMillis();
        }
        if (sleep(200)) {
          interrupted = true;
        }
      }
    }
  } finally {
    if (interrupted) {
      Thread.currentThread().interrupt();
    }
  }
  rssStub = intf;
  return sn;
}