Beispiel #1
0
 /**
  * Get any runnable node that is not one of the excluded nodes
  *
  * @param excluded the list of nodes to ignore
  * @return the runnable node, null if no runnable node can be found
  */
 public ClusterNode getRunnableNodeForAny(Set<String> excluded) {
   double avgLoad = loadManager.getAverageLoad(type);
   // Make two passes over the nodes. In the first pass, try to find a
   // node that has lower than average number of grants on it. If that does
   // not find a node, try looking at all nodes.
   for (int pass = 0; pass < 2; pass++) {
     for (Map.Entry<String, NodeContainer> e : hostToRunnableNodes.entrySet()) {
       NodeContainer nodeContainer = e.getValue();
       if (nodeContainer == null) {
         continue;
       }
       synchronized (nodeContainer) {
         if (nodeContainer.isEmpty()) {
           continue;
         }
         for (ClusterNode node : nodeContainer) {
           if (excluded == null || !excluded.contains(node.getHost())) {
             if (resourceLimit.hasEnoughResource(node)) {
               // When pass == 0, try to average out the load.
               if (pass == 0) {
                 if (node.getGrantCount(type) < avgLoad) {
                   return node;
                 }
               } else {
                 return node;
               }
             }
           }
         }
       }
     }
   }
   return null;
 }
Beispiel #2
0
    /**
     * Get a runnable node in the given rack that is not present in the excluded list
     *
     * @param requestedNode the node to look up rack locality for
     * @param excluded the list of nodes to ignore
     * @return the runnable node from the rack satisfying conditions, null if the node was not found
     */
    public ClusterNode getRunnableNodeForRack(RequestedNode requestedNode, Set<String> excluded) {

      NodeContainer nodeContainer = requestedNode.getRackNodes();
      getRunnableNodeForRackCounter += 1;
      if (nodeContainer == null) {
        return null;
      }
      synchronized (nodeContainer) {
        if (nodeContainer.isEmpty()) {
          return null;
        }
        if (getRunnableNodeForRackCounter % RACK_SHUFFLE_PERIOD == 0) {
          // This balances more evenly across nodes in a rack
          nodeContainer.shuffle();
        }
        for (ClusterNode node : nodeContainer) {
          if (excluded == null || !excluded.contains(node.getHost())) {
            if (resourceLimit.hasEnoughResource(node)) {
              return node;
            }
          }
        }
      }
      return null;
    }
Beispiel #3
0
 /**
  * Create a snapshot of runnable nodes.
  *
  * @return The snapshot.
  */
 public NodeSnapshot getNodeSnapshot() {
   int nodeCount = 0;
   Map<String, NodeContainer> hostRunnables = new HashMap<String, NodeContainer>();
   for (Map.Entry<String, NodeContainer> entry : hostToRunnableNodes.entrySet()) {
     NodeContainer value = entry.getValue();
     synchronized (value) {
       if (!value.isEmpty()) {
         hostRunnables.put(entry.getKey(), value.copy());
         nodeCount += value.size();
       }
     }
   }
   Map<Node, NodeContainer> rackRunnables = new HashMap<Node, NodeContainer>();
   for (Map.Entry<Node, NodeContainer> entry : rackToRunnableNodes.entrySet()) {
     NodeContainer value = entry.getValue();
     synchronized (value) {
       if (!value.isEmpty()) {
         rackRunnables.put(entry.getKey(), value.copy());
       }
     }
   }
   return new NodeSnapshot(topologyCache, hostRunnables, rackRunnables, nodeCount);
 }
Beispiel #4
0
 /**
  * Get runnable node local to the given host
  *
  * @param requestedNode the requested node that needs local scheduling
  * @return the node that is local to the host, null if there are no runnable nodes local to the
  *     host
  */
 public ClusterNode getRunnableNodeForHost(RequestedNode requestedNode) {
   // there should only be one node per host in the common case
   NodeContainer nodeContainer = requestedNode.getHostNodes();
   if (nodeContainer == null) {
     return null;
   }
   synchronized (nodeContainer) {
     if (nodeContainer.isEmpty()) {
       return null;
     }
     for (ClusterNode node : nodeContainer) {
       if (resourceLimit.hasEnoughResource(node)) {
         return node;
       }
     }
   }
   return null;
 }
Beispiel #5
0
 /**
  * Checks if a node is present as runnable in this index. Should be called while holding the
  * node lock.
  *
  * @param clusterNode The node.
  * @return A boolean indicating if the node is present.
  */
 public boolean hasRunnable(ClusterNode clusterNode) {
   String host = clusterNode.getHost();
   NodeContainer nodeContainer = hostToRunnableNodes.get(host);
   return (nodeContainer != null) && !nodeContainer.isEmpty();
 }