1. 包列表
  2. 类列表
  3. org.apache.hadoop.hbase.master.handler.MetaServerShutdownHandler

Java 类org.apache.hadoop.hbase.master.handler.MetaServerShutdownHandler 实例源码

项目：LCIndex-HBase-0.94.16    文件：ServerManager.java    
public synchronized void expireServer(final ServerName serverName) {
  boolean carryingRoot = services.getAssignmentManager().isCarryingRoot(serverName);
  if (!services.isServerShutdownHandlerEnabled() && (!carryingRoot || !this.isSSHForRootEnabled)) {
    LOG.info("Master doesn't enable ServerShutdownHandler during initialization, "
        + "delay expiring server " + serverName);
    this.deadNotExpiredServers.add(serverName);
    return;
  }
  if (!this.onlineServers.containsKey(serverName)) {
    LOG.warn("Received expiration of " + serverName +
      " but server is not currently online");
  }
  if (this.deadservers.contains(serverName)) {
    // TODO: Can this happen?  It shouldn't be online in this case?
    LOG.warn("Received expiration of " + serverName +
        " but server shutdown is already in progress");
    return;
  }
  // Remove the server from the known servers lists and update load info BUT
  // add to deadservers first; do this so it'll show in dead servers list if
  // not in online servers list.
  this.deadservers.add(serverName);
  this.onlineServers.remove(serverName);
  synchronized (onlineServers) {
    onlineServers.notifyAll();
  }
  this.serverConnections.remove(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);
  if (carryingRoot || carryingMeta) {
    this.services.getExecutorService().submit(new MetaServerShutdownHandler(this.master,
      this.services, this.deadservers, serverName, carryingRoot, carryingMeta));
  } else {
    this.services.getExecutorService().submit(new ServerShutdownHandler(this.master,
      this.services, this.deadservers, serverName, true));
  }
  LOG.debug("Added=" + serverName +
    " to dead servers, submitted shutdown handler to be executed, root=" +
      carryingRoot + ", meta=" + carryingMeta);
}
项目：pbase    文件：ServerManager.java    
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.isServerShutdownHandlerEnabled()) {
    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;
  }
  synchronized (onlineServers) {
    if (!this.onlineServers.containsKey(serverName)) {
      LOG.warn("Expiration of " + serverName + " but server not online");
    }
    // Remove the server from the known servers lists and update load info BUT
    // add to deadservers first; do this so it'll show in dead servers list if
    // not in online servers list.
    this.deadservers.add(serverName);
    this.onlineServers.remove(serverName);
    onlineServers.notifyAll();
  }
  this.rsAdmins.remove(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);
  if (carryingMeta) {
    this.services.getExecutorService().submit(new MetaServerShutdownHandler(this.master,
      this.services, this.deadservers, serverName));
  } else {
    this.services.getExecutorService().submit(new ServerShutdownHandler(this.master,
      this.services, this.deadservers, serverName, true));
  }
  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);
    }
  }
}
项目：HIndex    文件：ServerManager.java    
public synchronized void expireServer(final ServerName serverName) {
  if (!services.isServerShutdownHandlerEnabled()) {
    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;
  }
  synchronized (onlineServers) {
    if (!this.onlineServers.containsKey(serverName)) {
      LOG.warn("Expiration of " + serverName + " but server not online");
    }
    // Remove the server from the known servers lists and update load info BUT
    // add to deadservers first; do this so it'll show in dead servers list if
    // not in online servers list.
    this.deadservers.add(serverName);
    this.onlineServers.remove(serverName);
    onlineServers.notifyAll();
  }
  this.rsAdmins.remove(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);
  if (carryingMeta) {
    this.services.getExecutorService().submit(new MetaServerShutdownHandler(this.master,
      this.services, this.deadservers, serverName));
  } else {
    this.services.getExecutorService().submit(new ServerShutdownHandler(this.master,
      this.services, this.deadservers, serverName, true));
  }
  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);
    }
  }
}
项目：IRIndex    文件：ServerManager.java    
public synchronized void expireServer(final ServerName serverName) {
  boolean carryingRoot = services.getAssignmentManager().isCarryingRoot(serverName);
  if (!services.isServerShutdownHandlerEnabled() && (!carryingRoot || !this.isSSHForRootEnabled)) {
    LOG.info("Master doesn't enable ServerShutdownHandler during initialization, "
        + "delay expiring server " + serverName);
    this.deadNotExpiredServers.add(serverName);
    return;
  }
  if (!this.onlineServers.containsKey(serverName)) {
    LOG.warn("Received expiration of " + serverName +
      " but server is not currently online");
  }
  if (this.deadservers.contains(serverName)) {
    // TODO: Can this happen?  It shouldn't be online in this case?
    LOG.warn("Received expiration of " + serverName +
        " but server shutdown is already in progress");
    return;
  }
  // Remove the server from the known servers lists and update load info BUT
  // add to deadservers first; do this so it'll show in dead servers list if
  // not in online servers list.
  this.deadservers.add(serverName);
  this.onlineServers.remove(serverName);
  synchronized (onlineServers) {
    onlineServers.notifyAll();
  }
  this.serverConnections.remove(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);
  if (carryingRoot || carryingMeta) {
    this.services.getExecutorService().submit(new MetaServerShutdownHandler(this.master,
      this.services, this.deadservers, serverName, carryingRoot, carryingMeta));
  } else {
    this.services.getExecutorService().submit(new ServerShutdownHandler(this.master,
      this.services, this.deadservers, serverName, true));
  }
  LOG.debug("Added=" + serverName +
    " to dead servers, submitted shutdown handler to be executed, root=" +
      carryingRoot + ", meta=" + carryingMeta);
}
项目：RStore    文件：ServerManager.java    
public synchronized void expireServer(final ServerName serverName) {
  if (!this.onlineServers.containsKey(serverName)) {
    LOG.warn("Received expiration of " + serverName +
      " but server is not currently online");
    return;
  }
  if (this.deadservers.contains(serverName)) {
    // TODO: Can this happen?  It shouldn't be online in this case?
    LOG.warn("Received expiration of " + serverName +
        " but server shutdown is already in progress");
    return;
  }
  // Remove the server from the known servers lists and update load info BUT
  // add to deadservers first; do this so it'll show in dead servers list if
  // not in online servers list.
  this.deadservers.add(serverName);
  this.onlineServers.remove(serverName);
  this.serverConnections.remove(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 carryingRoot = services.getAssignmentManager().isCarryingRoot(serverName);
  boolean carryingMeta = services.getAssignmentManager().isCarryingMeta(serverName);
  if (carryingRoot || carryingMeta) {
    this.services.getExecutorService().submit(new MetaServerShutdownHandler(this.master,
      this.services, this.deadservers, serverName, carryingRoot, carryingMeta));
  } else {
    this.services.getExecutorService().submit(new ServerShutdownHandler(this.master,
      this.services, this.deadservers, serverName, true));
  }
  LOG.debug("Added=" + serverName +
    " to dead servers, submitted shutdown handler to be executed, root=" +
      carryingRoot + ", meta=" + carryingMeta);
}
项目：PyroDB    文件：ServerManager.java    
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.isServerShutdownHandlerEnabled()) {
    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;
  }
  synchronized (onlineServers) {
    if (!this.onlineServers.containsKey(serverName)) {
      LOG.warn("Expiration of " + serverName + " but server not online");
    }
    // Remove the server from the known servers lists and update load info BUT
    // add to deadservers first; do this so it'll show in dead servers list if
    // not in online servers list.
    this.deadservers.add(serverName);
    this.onlineServers.remove(serverName);
    onlineServers.notifyAll();
  }
  this.rsAdmins.remove(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);
  if (carryingMeta) {
    this.services.getExecutorService().submit(new MetaServerShutdownHandler(this.master,
      this.services, this.deadservers, serverName));
  } else {
    this.services.getExecutorService().submit(new ServerShutdownHandler(this.master,
      this.services, this.deadservers, serverName, true));
  }
  LOG.debug("Added=" + serverName +
    " to dead servers, submitted shutdown handler to be executed meta=" + carryingMeta);
}
项目：c5    文件：ServerManager.java    
public synchronized void expireServer(final ServerName serverName) {
  if (!services.isServerShutdownHandlerEnabled()) {
    LOG.info("Master doesn't enable ServerShutdownHandler during initialization, "
        + "delay expiring server " + serverName);
    this.queuedDeadServers.add(serverName);
    return;
  }
  if (!this.onlineServers.containsKey(serverName)) {
    LOG.warn("Expiration of " + serverName +
      " but server not online");
  }
  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;
  }
  // Remove the server from the known servers lists and update load info BUT
  // add to deadservers first; do this so it'll show in dead servers list if
  // not in online servers list.
  this.deadservers.add(serverName);
  this.onlineServers.remove(serverName);
  synchronized (onlineServers) {
    onlineServers.notifyAll();
  }
  this.rsAdmins.remove(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);
  if (carryingMeta) {
    this.services.getExecutorService().submit(new MetaServerShutdownHandler(this.master,
      this.services, this.deadservers, serverName));
  } else {
    this.services.getExecutorService().submit(new ServerShutdownHandler(this.master,
      this.services, this.deadservers, serverName, true));
  }
  LOG.debug("Added=" + serverName +
    " to dead servers, submitted shutdown handler to be executed meta=" + carryingMeta);
}
项目：HBase-Research    文件：ServerManager.java    
public synchronized void expireServer(final ServerName serverName) {
  boolean carryingRoot = services.getAssignmentManager().isCarryingRoot(serverName);
  if (!services.isServerShutdownHandlerEnabled() && (!carryingRoot || !this.isSSHForRootEnabled)) {
    LOG.info("Master doesn't enable ServerShutdownHandler during initialization, "
        + "delay expiring server " + serverName);
    this.deadNotExpiredServers.add(serverName);
    return;
  }
  if (!this.onlineServers.containsKey(serverName)) {
    LOG.warn("Received expiration of " + serverName +
      " but server is not currently online");
  }
  if (this.deadservers.contains(serverName)) {
    // TODO: Can this happen?  It shouldn't be online in this case?
    LOG.warn("Received expiration of " + serverName +
        " but server shutdown is already in progress");
    return;
  }
  // Remove the server from the known servers lists and update load info BUT
  // add to deadservers first; do this so it'll show in dead servers list if
  // not in online servers list.
  this.deadservers.add(serverName);
  this.onlineServers.remove(serverName);
  synchronized (onlineServers) {
    onlineServers.notifyAll();
  }
  this.serverConnections.remove(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);
  if (carryingRoot || carryingMeta) {
    this.services.getExecutorService().submit(new MetaServerShutdownHandler(this.master,
      this.services, this.deadservers, serverName, carryingRoot, carryingMeta));
  } else {
    this.services.getExecutorService().submit(new ServerShutdownHandler(this.master,
      this.services, this.deadservers, serverName, true));
  }
  LOG.debug("Added=" + serverName +
    " to dead servers, submitted shutdown handler to be executed, root=" +
      carryingRoot + ", meta=" + carryingMeta);
}
项目：hbase-0.94.8-qod    文件：ServerManager.java    
public synchronized void expireServer(final ServerName serverName) {
  boolean carryingRoot = services.getAssignmentManager().isCarryingRoot(serverName);
  if (!services.isServerShutdownHandlerEnabled() && (!carryingRoot || !this.isSSHForRootEnabled)) {
    LOG.info("Master doesn't enable ServerShutdownHandler during initialization, "
        + "delay expiring server " + serverName);
    this.deadNotExpiredServers.add(serverName);
    return;
  }
  if (!this.onlineServers.containsKey(serverName)) {
    LOG.warn("Received expiration of " + serverName +
      " but server is not currently online");
  }
  if (this.deadservers.contains(serverName)) {
    // TODO: Can this happen?  It shouldn't be online in this case?
    LOG.warn("Received expiration of " + serverName +
        " but server shutdown is already in progress");
    return;
  }
  // Remove the server from the known servers lists and update load info BUT
  // add to deadservers first; do this so it'll show in dead servers list if
  // not in online servers list.
  this.deadservers.add(serverName);
  this.onlineServers.remove(serverName);
  synchronized (onlineServers) {
    onlineServers.notifyAll();
  }
  this.serverConnections.remove(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);
  if (carryingRoot || carryingMeta) {
    this.services.getExecutorService().submit(new MetaServerShutdownHandler(this.master,
      this.services, this.deadservers, serverName, carryingRoot, carryingMeta));
  } else {
    this.services.getExecutorService().submit(new ServerShutdownHandler(this.master,
      this.services, this.deadservers, serverName, true));
  }
  LOG.debug("Added=" + serverName +
    " to dead servers, submitted shutdown handler to be executed, root=" +
      carryingRoot + ", meta=" + carryingMeta);
}
项目：hbase-0.94.8-qod    文件：ServerManager.java    
public synchronized void expireServer(final ServerName serverName) {
  boolean carryingRoot = services.getAssignmentManager().isCarryingRoot(serverName);
  if (!services.isServerShutdownHandlerEnabled() && (!carryingRoot || !this.isSSHForRootEnabled)) {
    LOG.info("Master doesn't enable ServerShutdownHandler during initialization, "
        + "delay expiring server " + serverName);
    this.deadNotExpiredServers.add(serverName);
    return;
  }
  if (!this.onlineServers.containsKey(serverName)) {
    LOG.warn("Received expiration of " + serverName +
      " but server is not currently online");
  }
  if (this.deadservers.contains(serverName)) {
    // TODO: Can this happen?  It shouldn't be online in this case?
    LOG.warn("Received expiration of " + serverName +
        " but server shutdown is already in progress");
    return;
  }
  // Remove the server from the known servers lists and update load info BUT
  // add to deadservers first; do this so it'll show in dead servers list if
  // not in online servers list.
  this.deadservers.add(serverName);
  this.onlineServers.remove(serverName);
  synchronized (onlineServers) {
    onlineServers.notifyAll();
  }
  this.serverConnections.remove(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);
  if (carryingRoot || carryingMeta) {
    this.services.getExecutorService().submit(new MetaServerShutdownHandler(this.master,
      this.services, this.deadservers, serverName, carryingRoot, carryingMeta));
  } else {
    this.services.getExecutorService().submit(new ServerShutdownHandler(this.master,
      this.services, this.deadservers, serverName, true));
  }
  LOG.debug("Added=" + serverName +
    " to dead servers, submitted shutdown handler to be executed, root=" +
      carryingRoot + ", meta=" + carryingMeta);
}
项目：DominoHBase    文件：ServerManager.java    
public synchronized void expireServer(final ServerName serverName) {
  if (!services.isServerShutdownHandlerEnabled()) {
    LOG.info("Master doesn't enable ServerShutdownHandler during initialization, "
        + "delay expiring server " + serverName);
    this.queuedDeadServers.add(serverName);
    return;
  }
  if (!this.onlineServers.containsKey(serverName)) {
    LOG.warn("Received expiration of " + serverName +
      " but server is not currently online");
  }
  if (this.deadservers.contains(serverName)) {
    // TODO: Can this happen?  It shouldn't be online in this case?
    LOG.warn("Received expiration of " + serverName +
        " but server shutdown is already in progress");
    return;
  }
  // Remove the server from the known servers lists and update load info BUT
  // add to deadservers first; do this so it'll show in dead servers list if
  // not in online servers list.
  this.deadservers.add(serverName);
  this.onlineServers.remove(serverName);
  synchronized (onlineServers) {
    onlineServers.notifyAll();
  }
  this.serverConnections.remove(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 carryingRoot = services.getAssignmentManager().isCarryingRoot(serverName);
  boolean carryingMeta = services.getAssignmentManager().isCarryingMeta(serverName);
  if (carryingRoot || carryingMeta) {
    this.services.getExecutorService().submit(new MetaServerShutdownHandler(this.master,
      this.services, this.deadservers, serverName, carryingRoot, carryingMeta));
  } else {
    this.services.getExecutorService().submit(new ServerShutdownHandler(this.master,
      this.services, this.deadservers, serverName, true));
  }
  LOG.debug("Added=" + serverName +
    " to dead servers, submitted shutdown handler to be executed, root=" +
      carryingRoot + ", meta=" + carryingMeta);
}
项目：hindex    文件：ServerManager.java    
public synchronized void expireServer(final ServerName serverName) {
  boolean carryingRoot = services.getAssignmentManager().isCarryingRoot(serverName);
  if (!services.isServerShutdownHandlerEnabled() && (!carryingRoot || !this.isSSHForRootEnabled)) {
    LOG.info("Master doesn't enable ServerShutdownHandler during initialization, "
        + "delay expiring server " + serverName);
    this.deadNotExpiredServers.add(serverName);
    return;
  }
  if (!this.onlineServers.containsKey(serverName)) {
    LOG.warn("Received expiration of " + serverName +
      " but server is not currently online");
  }
  if (this.deadservers.contains(serverName)) {
    // TODO: Can this happen?  It shouldn't be online in this case?
    LOG.warn("Received expiration of " + serverName +
        " but server shutdown is already in progress");
    return;
  }
  // Remove the server from the known servers lists and update load info BUT
  // add to deadservers first; do this so it'll show in dead servers list if
  // not in online servers list.
  this.deadservers.add(serverName);
  this.onlineServers.remove(serverName);
  synchronized (onlineServers) {
    onlineServers.notifyAll();
  }
  this.serverConnections.remove(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);
  if (carryingRoot || carryingMeta) {
    this.services.getExecutorService().submit(new MetaServerShutdownHandler(this.master,
      this.services, this.deadservers, serverName, carryingRoot, carryingMeta));
  } else {
    this.services.getExecutorService().submit(new ServerShutdownHandler(this.master,
      this.services, this.deadservers, serverName, true));
  }
  LOG.debug("Added=" + serverName +
    " to dead servers, submitted shutdown handler to be executed, root=" +
      carryingRoot + ", meta=" + carryingMeta);
}