Java NodeType.OFF_SWITCH属性代码示例

private int getMaxAllocatableContainers(FiCaSchedulerApp application,
    Priority priority, FiCaSchedulerNode node, NodeType type) {
  int maxContainers = 0;
  
  ResourceRequest offSwitchRequest = 
    application.getResourceRequest(priority, ResourceRequest.ANY);
  if (offSwitchRequest != null) {
    maxContainers = offSwitchRequest.getNumContainers();
  }

  if (type == NodeType.OFF_SWITCH) {
    return maxContainers;
  }

  if (type == NodeType.RACK_LOCAL) {
    ResourceRequest rackLocalRequest = 
      application.getResourceRequest(priority, node.getRMNode().getRackName());
    if (rackLocalRequest == null) {
      return maxContainers;
    }

    maxContainers = Math.min(maxContainers, rackLocalRequest.getNumContainers());
  }

  if (type == NodeType.NODE_LOCAL) {
    ResourceRequest nodeLocalRequest = 
      application.getResourceRequest(priority, node.getRMNode().getNodeAddress());
    if (nodeLocalRequest != null) {
      maxContainers = Math.min(maxContainers, nodeLocalRequest.getNumContainers());
    }
  }

  return maxContainers;
}
 

/**
 * Return the level at which we are allowed to schedule containers, given the
 * current size of the cluster and thresholds indicating how many nodes to
 * fail at (as a fraction of cluster size) before relaxing scheduling
 * constraints.
 */
public synchronized NodeType getAllowedLocalityLevel(Priority priority,
    int numNodes, double nodeLocalityThreshold, double rackLocalityThreshold) {
  // upper limit on threshold
  if (nodeLocalityThreshold > 1.0) { nodeLocalityThreshold = 1.0; }
  if (rackLocalityThreshold > 1.0) { rackLocalityThreshold = 1.0; }

  // If delay scheduling is not being used, can schedule anywhere
  if (nodeLocalityThreshold < 0.0 || rackLocalityThreshold < 0.0) {
    return NodeType.OFF_SWITCH;
  }

  // Default level is NODE_LOCAL
  if (!allowedLocalityLevel.containsKey(priority)) {
    allowedLocalityLevel.put(priority, NodeType.NODE_LOCAL);
    return NodeType.NODE_LOCAL;
  }

  NodeType allowed = allowedLocalityLevel.get(priority);

  // If level is already most liberal, we're done
  if (allowed.equals(NodeType.OFF_SWITCH)) return NodeType.OFF_SWITCH;

  double threshold = allowed.equals(NodeType.NODE_LOCAL) ? nodeLocalityThreshold :
    rackLocalityThreshold;

  // Relax locality constraints once we've surpassed threshold.
  if (getSchedulingOpportunities(priority) > (numNodes * threshold)) {
    if (allowed.equals(NodeType.NODE_LOCAL)) {
      allowedLocalityLevel.put(priority, NodeType.RACK_LOCAL);
      resetSchedulingOpportunities(priority);
    }
    else if (allowed.equals(NodeType.RACK_LOCAL)) {
      allowedLocalityLevel.put(priority, NodeType.OFF_SWITCH);
      resetSchedulingOpportunities(priority);
    }
  }
  return allowedLocalityLevel.get(priority);
}
 

private boolean reservationExceedsThreshold(FSSchedulerNode node,
                                               NodeType type) {
  // Only if not node-local
  if (type != NodeType.NODE_LOCAL) {
    int existingReservations = getNumReservations(node.getRackName(),
            type == NodeType.OFF_SWITCH);
    int totalAvailNodes =
            (type == NodeType.OFF_SWITCH) ? scheduler.getNumClusterNodes() :
                    scheduler.getNumNodesInRack(node.getRackName());
    int numAllowedReservations =
            (int)Math.ceil(
                    totalAvailNodes * scheduler.getReservableNodesRatio());
    if (existingReservations >= numAllowedReservations) {
      DecimalFormat df = new DecimalFormat();
      df.setMaximumFractionDigits(2);
      if (LOG.isDebugEnabled()) {
        LOG.debug("Reservation Exceeds Allowed number of nodes:" +
                " app_id=" + getApplicationId() +
                " existingReservations=" + existingReservations +
                " totalAvailableNodes=" + totalAvailNodes +
                " reservableNodesRatio=" + df.format(
                                        scheduler.getReservableNodesRatio()) +
                " numAllowedReservations=" + numAllowedReservations);
      }
      return true;
    }
  }
  return false;
}
 

private int getMaxAllocatableContainers(FiCaSchedulerApp application,
    Priority priority, FiCaSchedulerNode node, NodeType type) {
  ResourceRequest offSwitchRequest = 
    application.getResourceRequest(priority, ResourceRequest.ANY);
  int maxContainers = offSwitchRequest.getNumContainers();

  if (type == NodeType.OFF_SWITCH) {
    return maxContainers;
  }

  if (type == NodeType.RACK_LOCAL) {
    ResourceRequest rackLocalRequest = 
      application.getResourceRequest(priority, node.getRMNode().getRackName());
    if (rackLocalRequest == null) {
      return maxContainers;
    }

    maxContainers = Math.min(maxContainers, rackLocalRequest.getNumContainers());
  }

  if (type == NodeType.NODE_LOCAL) {
    ResourceRequest nodeLocalRequest = 
      application.getResourceRequest(priority, node.getRMNode().getNodeAddress());
    if (nodeLocalRequest != null) {
      maxContainers = Math.min(maxContainers, nodeLocalRequest.getNumContainers());
    }
  }

  return maxContainers;
}
 

/**
 * Return the level at which we are allowed to schedule containers.
 * Given the thresholds indicating how much time passed before relaxing
 * scheduling constraints.
 */
public synchronized NodeType getAllowedLocalityLevelByTime(Priority priority,
        long nodeLocalityDelayMs, long rackLocalityDelayMs,
        long currentTimeMs) {

  // if not being used, can schedule anywhere
  if (nodeLocalityDelayMs < 0 || rackLocalityDelayMs < 0) {
    return NodeType.OFF_SWITCH;
  }

  // default level is NODE_LOCAL
  if (! allowedLocalityLevel.containsKey(priority)) {
    allowedLocalityLevel.put(priority, NodeType.NODE_LOCAL);
    return NodeType.NODE_LOCAL;
  }

  NodeType allowed = allowedLocalityLevel.get(priority);

  // if level is already most liberal, we're done
  if (allowed.equals(NodeType.OFF_SWITCH)) {
    return NodeType.OFF_SWITCH;
  }

  // check waiting time
  long waitTime = currentTimeMs;
  if (lastScheduledContainer.containsKey(priority)) {
    waitTime -= lastScheduledContainer.get(priority);
  } else {
    waitTime -= getStartTime();
  }

  long thresholdTime = allowed.equals(NodeType.NODE_LOCAL) ?
          nodeLocalityDelayMs : rackLocalityDelayMs;

  if (waitTime > thresholdTime) {
    if (allowed.equals(NodeType.NODE_LOCAL)) {
      allowedLocalityLevel.put(priority, NodeType.RACK_LOCAL);
      resetSchedulingOpportunities(priority, currentTimeMs);
    } else if (allowed.equals(NodeType.RACK_LOCAL)) {
      allowedLocalityLevel.put(priority, NodeType.OFF_SWITCH);
      resetSchedulingOpportunities(priority, currentTimeMs);
    }
  }
  return allowedLocalityLevel.get(priority);
}
 

@Override
public synchronized CSAssignment assignContainers(Resource clusterResource,
    FiCaSchedulerNode node, ResourceLimits resourceLimits) {
  CSAssignment assignment = 
      new CSAssignment(Resources.createResource(0, 0, 0), NodeType.NODE_LOCAL);
  Set<String> nodeLabels = node.getLabels();
  
  // if our queue cannot access this node, just return
  if (!SchedulerUtils.checkQueueAccessToNode(accessibleLabels, nodeLabels)) {
    return assignment;
  }
  
  while (canAssign(clusterResource, node)) {
    if (LOG.isDebugEnabled()) {
      LOG.debug("Trying to assign containers to child-queue of "
        + getQueueName());
    }
    
    // Are we over maximum-capacity for this queue?
    // This will also consider parent's limits and also continuous reservation
    // looking
    if (!super.canAssignToThisQueue(clusterResource, nodeLabels, resourceLimits,
        minimumAllocation, Resources.createResource(getMetrics()
            .getReservedMB(), getMetrics().getReservedVirtualCores(), getMetrics().getReservedGpuCores()))) {
      break;
    }
    
    // Schedule
    CSAssignment assignedToChild = 
        assignContainersToChildQueues(clusterResource, node, resourceLimits);
    assignment.setType(assignedToChild.getType());
    
    // Done if no child-queue assigned anything
    if (Resources.greaterThan(
            resourceCalculator, clusterResource, 
            assignedToChild.getResource(), Resources.none())) {
      // Track resource utilization for the parent-queue
      super.allocateResource(clusterResource, assignedToChild.getResource(),
          nodeLabels);
      
      // Track resource utilization in this pass of the scheduler
      Resources.addTo(assignment.getResource(), assignedToChild.getResource());
      
      LOG.info("assignedContainer" +
          " queue=" + getQueueName() + 
          " usedCapacity=" + getUsedCapacity() +
          " absoluteUsedCapacity=" + getAbsoluteUsedCapacity() +
          " used=" + queueUsage.getUsed() + 
          " cluster=" + clusterResource);

    } else {
      break;
    }

    if (LOG.isDebugEnabled()) {
      LOG.debug("ParentQ=" + getQueueName()
        + " assignedSoFarInThisIteration=" + assignment.getResource()
        + " usedCapacity=" + getUsedCapacity()
        + " absoluteUsedCapacity=" + getAbsoluteUsedCapacity());
    }

    // Do not assign more than one container if this isn't the root queue
    // or if we've already assigned an off-switch container
    if (!rootQueue || assignment.getType() == NodeType.OFF_SWITCH) {
      if (LOG.isDebugEnabled()) {
        if (rootQueue && assignment.getType() == NodeType.OFF_SWITCH) {
          LOG.debug("Not assigning more than one off-switch container," +
              " assignments so far: " + assignment);
        }
      }
      break;
    }
  } 
  
  return assignment;
}
 

/**
 * Return the level at which we are allowed to schedule containers.
 * Given the thresholds indicating how much time passed before relaxing
 * scheduling constraints.
 */
public synchronized NodeType getAllowedLocalityLevelByTime(Priority priority,
        long nodeLocalityDelayMs, long rackLocalityDelayMs,
        long currentTimeMs) {

  // if not being used, can schedule anywhere
  if (nodeLocalityDelayMs < 0 || rackLocalityDelayMs < 0) {
    return NodeType.OFF_SWITCH;
  }

  // default level is NODE_LOCAL
  if (! allowedLocalityLevel.containsKey(priority)) {
    // add the initial time of priority to prevent comparing with FsApp
    // startTime and allowedLocalityLevel degrade
    lastScheduledContainer.put(priority, currentTimeMs);
    if (LOG.isDebugEnabled()) {
      LOG.debug("Init the lastScheduledContainer time, priority: " + priority
          + ", time: " + currentTimeMs);
    }
    allowedLocalityLevel.put(priority, NodeType.NODE_LOCAL);
    return NodeType.NODE_LOCAL;
  }

  NodeType allowed = allowedLocalityLevel.get(priority);

  // if level is already most liberal, we're done
  if (allowed.equals(NodeType.OFF_SWITCH)) {
    return NodeType.OFF_SWITCH;
  }

  // check waiting time
  long waitTime = currentTimeMs;
  if (lastScheduledContainer.containsKey(priority)) {
    waitTime -= lastScheduledContainer.get(priority);
  } else {
    waitTime -= getStartTime();
  }

  long thresholdTime = allowed.equals(NodeType.NODE_LOCAL) ?
          nodeLocalityDelayMs : rackLocalityDelayMs;

  if (waitTime > thresholdTime) {
    if (allowed.equals(NodeType.NODE_LOCAL)) {
      allowedLocalityLevel.put(priority, NodeType.RACK_LOCAL);
      resetSchedulingOpportunities(priority, currentTimeMs);
    } else if (allowed.equals(NodeType.RACK_LOCAL)) {
      allowedLocalityLevel.put(priority, NodeType.OFF_SWITCH);
      resetSchedulingOpportunities(priority, currentTimeMs);
    }
  }
  return allowedLocalityLevel.get(priority);
}
 

private ContainerAllocation assignContainersOnNode(Resource clusterResource,
    FiCaSchedulerNode node, Priority priority, RMContainer reservedContainer,
    SchedulingMode schedulingMode, ResourceLimits currentResoureLimits) {

  ContainerAllocation allocation;

  NodeType requestType = null;
  // Data-local
  ResourceRequest nodeLocalResourceRequest =
      application.getResourceRequest(priority, node.getNodeName());
  if (nodeLocalResourceRequest != null) {
    requestType = NodeType.NODE_LOCAL;
    allocation =
        assignNodeLocalContainers(clusterResource, nodeLocalResourceRequest,
            node, priority, reservedContainer, schedulingMode,
            currentResoureLimits);
    if (Resources.greaterThan(rc, clusterResource,
        allocation.getResourceToBeAllocated(), Resources.none())) {
      allocation.requestNodeType = requestType;
      return allocation;
    }
  }

  // Rack-local
  ResourceRequest rackLocalResourceRequest =
      application.getResourceRequest(priority, node.getRackName());
  if (rackLocalResourceRequest != null) {
    if (!rackLocalResourceRequest.getRelaxLocality()) {
      return ContainerAllocation.PRIORITY_SKIPPED;
    }

    if (requestType != NodeType.NODE_LOCAL) {
      requestType = NodeType.RACK_LOCAL;
    }

    allocation =
        assignRackLocalContainers(clusterResource, rackLocalResourceRequest,
            node, priority, reservedContainer, schedulingMode,
            currentResoureLimits);
    if (Resources.greaterThan(rc, clusterResource,
        allocation.getResourceToBeAllocated(), Resources.none())) {
      allocation.requestNodeType = requestType;
      return allocation;
    }
  }

  // Off-switch
  ResourceRequest offSwitchResourceRequest =
      application.getResourceRequest(priority, ResourceRequest.ANY);
  if (offSwitchResourceRequest != null) {
    if (!offSwitchResourceRequest.getRelaxLocality()) {
      return ContainerAllocation.PRIORITY_SKIPPED;
    }
    if (requestType != NodeType.NODE_LOCAL
        && requestType != NodeType.RACK_LOCAL) {
      requestType = NodeType.OFF_SWITCH;
    }

    allocation =
        assignOffSwitchContainers(clusterResource, offSwitchResourceRequest,
            node, priority, reservedContainer, schedulingMode,
            currentResoureLimits);
    allocation.requestNodeType = requestType;
    
    // When a returned allocation is LOCALITY_SKIPPED, since we're in
    // off-switch request now, we will skip this app w.r.t priorities 
    if (allocation.state == AllocationState.LOCALITY_SKIPPED) {
      allocation.state = AllocationState.APP_SKIPPED;
    }

    return allocation;
  }

  return ContainerAllocation.PRIORITY_SKIPPED;
}
 

ContainerAllocation doAllocation(ContainerAllocation allocationResult,
    Resource clusterResource, FiCaSchedulerNode node,
    SchedulingMode schedulingMode, Priority priority,
    RMContainer reservedContainer) {
  // Create the container if necessary
  Container container =
      getContainer(reservedContainer, node,
          allocationResult.getResourceToBeAllocated(), priority);

  // something went wrong getting/creating the container
  if (container == null) {
    application
        .updateAppSkipNodeDiagnostics("Scheduling of container failed. ");
    LOG.warn("Couldn't get container for allocation!");
    return ContainerAllocation.APP_SKIPPED;
  }

  if (allocationResult.getAllocationState() == AllocationState.ALLOCATED) {
    // When allocating container
    allocationResult =
        handleNewContainerAllocation(allocationResult, node, priority,
            reservedContainer, container);
  } else {
    // When reserving container
    application.reserve(priority, node, reservedContainer, container);
  }
  allocationResult.updatedContainer = container;

  // Only reset opportunities when we FIRST allocate the container. (IAW, When
  // reservedContainer != null, it's not the first time)
  if (reservedContainer == null) {
    // Don't reset scheduling opportunities for off-switch assignments
    // otherwise the app will be delayed for each non-local assignment.
    // This helps apps with many off-cluster requests schedule faster.
    if (allocationResult.containerNodeType != NodeType.OFF_SWITCH) {
      if (LOG.isDebugEnabled()) {
        LOG.debug("Resetting scheduling opportunities");
      }
      // Only reset scheduling opportunities for RACK_LOCAL if configured
      // to do so. Not resetting means we will continue to schedule
      // RACK_LOCAL without delay.
      if (allocationResult.containerNodeType == NodeType.NODE_LOCAL
          || application.getCSLeafQueue().getRackLocalityFullReset()) {
        application.resetSchedulingOpportunities(priority);
      }
    }

    // Non-exclusive scheduling opportunity is different: we need reset
    // it every time to make sure non-labeled resource request will be
    // most likely allocated on non-labeled nodes first.
    application.resetMissedNonPartitionedRequestSchedulingOpportunity(priority);
  }

  return allocationResult;
}
 

@Override
public synchronized CSAssignment assignContainers(
    Resource clusterResource, FiCaSchedulerNode node, boolean needToUnreserve) {
  CSAssignment assignment = 
      new CSAssignment(Resources.createResource(0, 0), NodeType.NODE_LOCAL);
  
  // if our queue cannot access this node, just return
  if (!SchedulerUtils.checkQueueAccessToNode(accessibleLabels,
      labelManager.getLabelsOnNode(node.getNodeID()))) {
    return assignment;
  }
  
  while (canAssign(clusterResource, node)) {
    if (LOG.isDebugEnabled()) {
      LOG.debug("Trying to assign containers to child-queue of "
        + getQueueName());
    }
    
    boolean localNeedToUnreserve = false;
    Set<String> nodeLabels = labelManager.getLabelsOnNode(node.getNodeID()); 
    
    // Are we over maximum-capacity for this queue?
    if (!canAssignToThisQueue(clusterResource, nodeLabels)) {
      // check to see if we could if we unreserve first
      localNeedToUnreserve = assignToQueueIfUnreserve(clusterResource);
      if (!localNeedToUnreserve) {
        break;
      }
    }
    
    // Schedule
    CSAssignment assignedToChild = 
        assignContainersToChildQueues(clusterResource, node, localNeedToUnreserve | needToUnreserve);
    assignment.setType(assignedToChild.getType());
    
    // Done if no child-queue assigned anything
    if (Resources.greaterThan(
            resourceCalculator, clusterResource, 
            assignedToChild.getResource(), Resources.none())) {
      // Track resource utilization for the parent-queue
      super.allocateResource(clusterResource, assignedToChild.getResource(),
          nodeLabels);
      
      // Track resource utilization in this pass of the scheduler
      Resources.addTo(assignment.getResource(), assignedToChild.getResource());
      
      LOG.info("assignedContainer" +
          " queue=" + getQueueName() + 
          " usedCapacity=" + getUsedCapacity() +
          " absoluteUsedCapacity=" + getAbsoluteUsedCapacity() +
          " used=" + usedResources + 
          " cluster=" + clusterResource);

    } else {
      break;
    }

    if (LOG.isDebugEnabled()) {
      LOG.debug("ParentQ=" + getQueueName()
        + " assignedSoFarInThisIteration=" + assignment.getResource()
        + " usedCapacity=" + getUsedCapacity()
        + " absoluteUsedCapacity=" + getAbsoluteUsedCapacity());
    }

    // Do not assign more than one container if this isn't the root queue
    // or if we've already assigned an off-switch container
    if (!rootQueue || assignment.getType() == NodeType.OFF_SWITCH) {
      if (LOG.isDebugEnabled()) {
        if (rootQueue && assignment.getType() == NodeType.OFF_SWITCH) {
          LOG.debug("Not assigning more than one off-switch container," +
              " assignments so far: " + assignment);
        }
      }
      break;
    }
  } 
  
  return assignment;
}
 

private CSAssignment assignContainersOnNode(Resource clusterResource,
    FiCaSchedulerNode node, FiCaSchedulerApp application, Priority priority,
    RMContainer reservedContainer, boolean needToUnreserve) {
  Resource assigned = Resources.none();

  // Data-local
  ResourceRequest nodeLocalResourceRequest =
      application.getResourceRequest(priority, node.getNodeName());
  if (nodeLocalResourceRequest != null) {
    assigned = 
        assignNodeLocalContainers(clusterResource, nodeLocalResourceRequest, 
            node, application, priority, reservedContainer, needToUnreserve); 
    if (Resources.greaterThan(resourceCalculator, clusterResource, 
        assigned, Resources.none())) {
      return new CSAssignment(assigned, NodeType.NODE_LOCAL);
    }
  }

  // Rack-local
  ResourceRequest rackLocalResourceRequest =
      application.getResourceRequest(priority, node.getRackName());
  if (rackLocalResourceRequest != null) {
    if (!rackLocalResourceRequest.getRelaxLocality()) {
      return SKIP_ASSIGNMENT;
    }
    
    assigned = 
        assignRackLocalContainers(clusterResource, rackLocalResourceRequest, 
            node, application, priority, reservedContainer, needToUnreserve);
    if (Resources.greaterThan(resourceCalculator, clusterResource, 
        assigned, Resources.none())) {
      return new CSAssignment(assigned, NodeType.RACK_LOCAL);
    }
  }
  
  // Off-switch
  ResourceRequest offSwitchResourceRequest =
      application.getResourceRequest(priority, ResourceRequest.ANY);
  if (offSwitchResourceRequest != null) {
    if (!offSwitchResourceRequest.getRelaxLocality()) {
      return SKIP_ASSIGNMENT;
    }

    return new CSAssignment(
        assignOffSwitchContainers(clusterResource, offSwitchResourceRequest,
            node, application, priority, reservedContainer, needToUnreserve), 
            NodeType.OFF_SWITCH);
  }
  
  return SKIP_ASSIGNMENT;
}
 

@Override
public synchronized CSAssignment assignContainers(
    Resource clusterResource, FiCaSchedulerNode node) {
  CSAssignment assignment = 
      new CSAssignment(Resources.createResource(0, 0), NodeType.NODE_LOCAL);
  
  while (canAssign(clusterResource, node)) {
    if (LOG.isDebugEnabled()) {
      LOG.debug("Trying to assign containers to child-queue of "
        + getQueueName());
    }
    
    // Are we over maximum-capacity for this queue?
    if (!assignToQueue(clusterResource)) {
      break;
    }
    
    // Schedule
    CSAssignment assignedToChild = 
        assignContainersToChildQueues(clusterResource, node);
    assignment.setType(assignedToChild.getType());
    
    // Done if no child-queue assigned anything
    if (Resources.greaterThan(
            resourceCalculator, clusterResource, 
            assignedToChild.getResource(), Resources.none())) {
      // Track resource utilization for the parent-queue
      allocateResource(clusterResource, assignedToChild.getResource());
      
      // Track resource utilization in this pass of the scheduler
      Resources.addTo(assignment.getResource(), assignedToChild.getResource());
      
      LOG.info("assignedContainer" +
          " queue=" + getQueueName() + 
          " usedCapacity=" + getUsedCapacity() +
          " absoluteUsedCapacity=" + getAbsoluteUsedCapacity() +
          " used=" + usedResources + 
          " cluster=" + clusterResource);

    } else {
      break;
    }

    if (LOG.isDebugEnabled()) {
      LOG.debug("ParentQ=" + getQueueName()
        + " assignedSoFarInThisIteration=" + assignment.getResource()
        + " usedCapacity=" + getUsedCapacity()
        + " absoluteUsedCapacity=" + getAbsoluteUsedCapacity());
    }

    // Do not assign more than one container if this isn't the root queue
    // or if we've already assigned an off-switch container
    if (!rootQueue || assignment.getType() == NodeType.OFF_SWITCH) {
      if (LOG.isDebugEnabled()) {
        if (rootQueue && assignment.getType() == NodeType.OFF_SWITCH) {
          LOG.debug("Not assigning more than one off-switch container," +
              " assignments so far: " + assignment);
        }
      }
      break;
    }
  } 
  
  return assignment;
}
 

private CSAssignment assignContainersOnNode(Resource clusterResource, 
    FiCaSchedulerNode node, FiCaSchedulerApp application, 
    Priority priority, RMContainer reservedContainer) {

  Resource assigned = Resources.none();

  // Data-local
  ResourceRequest nodeLocalResourceRequest =
      application.getResourceRequest(priority, node.getHostName());
  if (nodeLocalResourceRequest != null) {
    assigned = 
        assignNodeLocalContainers(clusterResource, nodeLocalResourceRequest, 
            node, application, priority, reservedContainer); 
    if (Resources.greaterThan(resourceCalculator, clusterResource, 
        assigned, Resources.none())) {
      return new CSAssignment(assigned, NodeType.NODE_LOCAL);
    }
  }

  // Rack-local
  ResourceRequest rackLocalResourceRequest =
      application.getResourceRequest(priority, node.getRackName());
  if (rackLocalResourceRequest != null) {
    if (!rackLocalResourceRequest.getRelaxLocality()) {
      return SKIP_ASSIGNMENT;
    }
    
    assigned = 
        assignRackLocalContainers(clusterResource, rackLocalResourceRequest, 
            node, application, priority, reservedContainer);
    if (Resources.greaterThan(resourceCalculator, clusterResource, 
        assigned, Resources.none())) {
      return new CSAssignment(assigned, NodeType.RACK_LOCAL);
    }
  }
  
  // Off-switch
  ResourceRequest offSwitchResourceRequest =
      application.getResourceRequest(priority, ResourceRequest.ANY);
  if (offSwitchResourceRequest != null) {
    if (!offSwitchResourceRequest.getRelaxLocality()) {
      return SKIP_ASSIGNMENT;
    }

    return new CSAssignment(
        assignOffSwitchContainers(clusterResource, offSwitchResourceRequest,
            node, application, priority, reservedContainer), 
            NodeType.OFF_SWITCH);
  }
  
  return SKIP_ASSIGNMENT;
}
 

ContainerAllocation doAllocation(ContainerAllocation allocationResult,
    FiCaSchedulerNode node, Priority priority,
    RMContainer reservedContainer) {
  // Create the container if necessary
  Container container =
      getContainer(reservedContainer, node,
          allocationResult.getResourceToBeAllocated(), priority);

  // something went wrong getting/creating the container
  if (container == null) {
    application
        .updateAppSkipNodeDiagnostics("Scheduling of container failed. ");
    LOG.warn("Couldn't get container for allocation!");
    return ContainerAllocation.APP_SKIPPED;
  }

  if (allocationResult.getAllocationState() == AllocationState.ALLOCATED) {
    // When allocating container
    allocationResult =
        handleNewContainerAllocation(allocationResult, node, priority,
            reservedContainer, container);
  } else {
    // When reserving container
    application.reserve(priority, node, reservedContainer, container);
  }
  allocationResult.updatedContainer = container;

  // Only reset opportunities when we FIRST allocate the container. (IAW, When
  // reservedContainer != null, it's not the first time)
  if (reservedContainer == null) {
    // Don't reset scheduling opportunities for off-switch assignments
    // otherwise the app will be delayed for each non-local assignment.
    // This helps apps with many off-cluster requests schedule faster.
    if (allocationResult.containerNodeType != NodeType.OFF_SWITCH) {
      if (LOG.isDebugEnabled()) {
        LOG.debug("Resetting scheduling opportunities");
      }
      // Only reset scheduling opportunities for RACK_LOCAL if configured
      // to do so. Not resetting means we will continue to schedule
      // RACK_LOCAL without delay.
      if (allocationResult.containerNodeType == NodeType.NODE_LOCAL
          || application.getCSLeafQueue().getRackLocalityFullReset()) {
        application.resetSchedulingOpportunities(priority);
      }
    }

    // Non-exclusive scheduling opportunity is different: we need reset
    // it when:
    // - It allocated on the default partition
    //
    // This is to make sure non-labeled resource request will be
    // most likely allocated on non-labeled nodes first.
    if (StringUtils.equals(node.getPartition(),
        RMNodeLabelsManager.NO_LABEL)) {
      application
          .resetMissedNonPartitionedRequestSchedulingOpportunity(priority);
    }
  }

  return allocationResult;
}