import org.apache.hadoop.yarn.server.resourcemanager.rmcontainer.RMContainer; //导入依赖的package包/类
@Override
public void handle(ContainerPreemptEvent event) {
  ApplicationAttemptId aid = event.getAppId();
  RMContainer container = event.getContainer();
  switch (event.getType()) {
  case DROP_RESERVATION:
    scheduler.dropContainerReservation(container);
    break;
  case PREEMPT_CONTAINER:
    scheduler.preemptContainer(aid, container);
    break;
  case KILL_CONTAINER:
    scheduler.killContainer(container);
    break;
  }
}
 

import org.apache.hadoop.yarn.server.resourcemanager.rmcontainer.RMContainer; //导入依赖的package包/类
private static RMContainer createRMContainer(ContainerId containerId) {
  RMContainer container = mock(RMContainer.class);
  when(container.getContainerId()).thenReturn(containerId);
  when(container.getAllocatedNode()).thenReturn(
    NodeId.newInstance("test host", -100));
  when(container.getAllocatedResource()).thenReturn(
    Resource.newInstance(-1, -1, -1));
  when(container.getAllocatedPriority()).thenReturn(Priority.UNDEFINED);
  when(container.getCreationTime()).thenReturn(0L);
  when(container.getFinishTime()).thenReturn(1L);
  when(container.getDiagnosticsInfo()).thenReturn("test diagnostics info");
  when(container.getLogURL()).thenReturn("test log url");
  when(container.getContainerExitStatus()).thenReturn(-1);
  when(container.getContainerState()).thenReturn(ContainerState.COMPLETE);
  return container;
}
 

import org.apache.hadoop.yarn.server.resourcemanager.rmcontainer.RMContainer; //导入依赖的package包/类
public synchronized void recoverContainer(SchedulerNode node,
    RMContainer rmContainer) {
  // recover app scheduling info
  appSchedulingInfo.recoverContainer(rmContainer);

  if (rmContainer.getState().equals(RMContainerState.COMPLETED)) {
    return;
  }
  LOG.info("SchedulerAttempt " + getApplicationAttemptId()
    + " is recovering container " + rmContainer.getContainerId());
  liveContainers.put(rmContainer.getContainerId(), rmContainer);
  attemptResourceUsage.incUsed(node.getPartition(), rmContainer
      .getContainer().getResource());
  
  // resourceLimit: updated when LeafQueue#recoverContainer#allocateResource
  // is called.
  // newlyAllocatedContainers.add(rmContainer);
  // schedulingOpportunities
  // lastScheduledContainer
}
 

import org.apache.hadoop.yarn.server.resourcemanager.rmcontainer.RMContainer; //导入依赖的package包/类
RMContainer mockContainer(ApplicationAttemptId appAttId, int id,
    Resource r, int cpriority) {
  ContainerId cId = ContainerId.newContainerId(appAttId, id);
  Container c = mock(Container.class);
  when(c.getResource()).thenReturn(r);
  when(c.getPriority()).thenReturn(Priority.create(cpriority));
  RMContainer mC = mock(RMContainer.class);
  when(mC.getContainerId()).thenReturn(cId);
  when(mC.getContainer()).thenReturn(c);
  when(mC.getApplicationAttemptId()).thenReturn(appAttId);
  if (priority.AMCONTAINER.getValue() == cpriority) {
    when(mC.isAMContainer()).thenReturn(true);
  }
  if (priority.LABELEDCONTAINER.getValue() == cpriority) {
    when(mC.getAllocatedNode()).thenReturn(NodeId.newInstance("node1", 0));
  }
  return mC;
}
 

import org.apache.hadoop.yarn.server.resourcemanager.rmcontainer.RMContainer; //导入依赖的package包/类
private synchronized void unreserveInternal(
    Priority priority, FSSchedulerNode node) {
  Map<NodeId, RMContainer> reservedContainers = 
      this.reservedContainers.get(priority);
  RMContainer reservedContainer = reservedContainers.remove(node.getNodeID());
  if (reservedContainers.isEmpty()) {
    this.reservedContainers.remove(priority);
  }
  
  // Reset the re-reservation count
  resetReReservations(priority);

  Resource resource = reservedContainer.getContainer().getResource();
  this.attemptResourceUsage.decReserved(resource);

  LOG.info("Application " + getApplicationId() + " unreserved " + " on node "
      + node + ", currently has " + reservedContainers.size()
      + " at priority " + priority + "; currentReservation "
      + this.attemptResourceUsage.getReserved());
}
 

import org.apache.hadoop.yarn.server.resourcemanager.rmcontainer.RMContainer; //导入依赖的package包/类
@Override
public void attachContainer(Resource clusterResource,
    FiCaSchedulerApp application, RMContainer rmContainer) {
  if (application != null) {
    FiCaSchedulerNode node =
        scheduler.getNode(rmContainer.getContainer().getNodeId());
    allocateResource(clusterResource, application, rmContainer.getContainer()
        .getResource(), node.getLabels());
    LOG.info("movedContainer" + " container=" + rmContainer.getContainer()
        + " resource=" + rmContainer.getContainer().getResource()
        + " queueMoveIn=" + this + " usedCapacity=" + getUsedCapacity()
        + " absoluteUsedCapacity=" + getAbsoluteUsedCapacity() + " used="
        + queueUsage.getUsed() + " cluster=" + clusterResource);
    // Inform the parent queue
    getParent().attachContainer(clusterResource, application, rmContainer);
  }
}
 

import org.apache.hadoop.yarn.server.resourcemanager.rmcontainer.RMContainer; //导入依赖的package包/类
/**
 * Called when this application already has an existing reservation on the
 * given node.  Sees whether we can turn the reservation into an allocation.
 * Also checks whether the application needs the reservation anymore, and
 * releases it if not.
 *
 * @param node
 *     Node that the application has an existing reservation on
 */
public Resource assignReservedContainer(FSSchedulerNode node) {
  RMContainer rmContainer = node.getReservedContainer();
  Priority priority = rmContainer.getReservedPriority();

  // Make sure the application still needs requests at this priority
  if (getTotalRequiredResources(priority) == 0) {
    unreserve(priority, node);
    return Resources.none();
  }

  // Fail early if the reserved container won't fit.
  // Note that we have an assumption here that there's only one container size
  // per priority.
  if (!Resources.fitsIn(node.getReservedContainer().getReservedResource(),
      node.getAvailableResource())) {
    return Resources.none();
  }

  return assignContainer(node, true);
}
 

import org.apache.hadoop.yarn.server.resourcemanager.rmcontainer.RMContainer; //导入依赖的package包/类
@Override
public void detachContainer(Resource clusterResource,
    FiCaSchedulerApp application, RMContainer rmContainer) {
  if (application != null) {
    FiCaSchedulerNode node =
        scheduler.getNode(rmContainer.getContainer().getNodeId());
    releaseResource(clusterResource, application, rmContainer.getContainer()
        .getResource(), node.getLabels());
    LOG.info("movedContainer" + " container=" + rmContainer.getContainer()
        + " resource=" + rmContainer.getContainer().getResource()
        + " queueMoveOut=" + this + " usedCapacity=" + getUsedCapacity()
        + " absoluteUsedCapacity=" + getAbsoluteUsedCapacity() + " used="
        + queueUsage.getUsed() + " cluster=" + clusterResource);
    // Inform the parent queue
    getParent().detachContainer(clusterResource, application, rmContainer);
  }
}
 

import org.apache.hadoop.yarn.server.resourcemanager.rmcontainer.RMContainer; //导入依赖的package包/类
/**
 * Preempt a running container according to the priority
 */
@Override
public RMContainer preemptContainer() {
  if (LOG.isDebugEnabled()) {
    LOG.debug("App " + getName() + " is going to preempt a running " +
        "container");
  }

  RMContainer toBePreempted = null;
  for (RMContainer container : getLiveContainers()) {
    if (!getPreemptionContainers().contains(container) &&
        (toBePreempted == null ||
            comparator.compare(toBePreempted, container) > 0)) {
      toBePreempted = container;
    }
  }
  return toBePreempted;
}
 

import org.apache.hadoop.yarn.server.resourcemanager.rmcontainer.RMContainer; //导入依赖的package包/类
public synchronized void recoverContainer(RMContainer rmContainer) {
  QueueMetrics metrics = queue.getMetrics();
  if (pending) {
    // If there was any container to recover, the application was
    // running from scheduler's POV.
    pending = false;
    metrics.runAppAttempt(applicationId, user);
  }

  // Container is completed. Skip recovering resources.
  if (rmContainer.getState().equals(RMContainerState.COMPLETED)) {
    return;
  }

  metrics.allocateResources(user, 1, rmContainer.getAllocatedResource(),
    false);
}
 

import org.apache.hadoop.yarn.server.resourcemanager.rmcontainer.RMContainer; //导入依赖的package包/类
public synchronized List<Container> getTransferredContainers(
    ApplicationAttemptId currentAttempt) {
  ApplicationId appId = currentAttempt.getApplicationId();
  SchedulerApplication<T> app = applications.get(appId);
  List<Container> containerList = new ArrayList<Container>();
  RMApp appImpl = this.rmContext.getRMApps().get(appId);
  if (appImpl.getApplicationSubmissionContext().getUnmanagedAM()) {
    return containerList;
  }
  Collection<RMContainer> liveContainers =
      app.getCurrentAppAttempt().getLiveContainers();
  ContainerId amContainerId =
      rmContext.getRMApps().get(appId).getCurrentAppAttempt()
        .getMasterContainer().getId();
  for (RMContainer rmContainer : liveContainers) {
    if (!rmContainer.getContainerId().equals(amContainerId)) {
      containerList.add(rmContainer.getContainer());
    }
  }
  return containerList;
}
 

import org.apache.hadoop.yarn.server.resourcemanager.rmcontainer.RMContainer; //导入依赖的package包/类
protected void releaseContainers(List<ContainerId> containers,
    SchedulerApplicationAttempt attempt) {
  for (ContainerId containerId : containers) {
    RMContainer rmContainer = getRMContainer(containerId);
    if (rmContainer == null) {
      if (System.currentTimeMillis() - ResourceManager.getClusterTimeStamp()
          < nmExpireInterval) {
        LOG.info(containerId + " doesn't exist. Add the container"
            + " to the release request cache as it maybe on recovery.");
        synchronized (attempt) {
          attempt.getPendingRelease().add(containerId);
        }
      } else {
        RMAuditLogger.logFailure(attempt.getUser(),
          AuditConstants.RELEASE_CONTAINER,
          "Unauthorized access or invalid container", "Scheduler",
          "Trying to release container not owned by app or with invalid id.",
          attempt.getApplicationId(), containerId);
      }
    }
    completedContainer(rmContainer,
      SchedulerUtils.createAbnormalContainerStatus(containerId,
        SchedulerUtils.RELEASED_CONTAINER), RMContainerEventType.RELEASED);
  }
}
 

import org.apache.hadoop.yarn.server.resourcemanager.rmcontainer.RMContainer; //导入依赖的package包/类
/**
 * Compare by reversed priority order first, and then reversed containerId
 * order
 * @param containers
 */
@VisibleForTesting
static void sortContainers(List<RMContainer> containers){
  Collections.sort(containers, new Comparator<RMContainer>() {
    @Override
    public int compare(RMContainer a, RMContainer b) {
      Comparator<Priority> c = new org.apache.hadoop.yarn.server
          .resourcemanager.resource.Priority.Comparator();
      int priorityComp = c.compare(b.getContainer().getPriority(),
                                   a.getContainer().getPriority());
      if (priorityComp != 0) {
        return priorityComp;
      }
      return b.getContainerId().compareTo(a.getContainerId());
    }
  });
}
 

import org.apache.hadoop.yarn.server.resourcemanager.rmcontainer.RMContainer; //导入依赖的package包/类
@Override
public void recoverContainer(Resource clusterResource,
    SchedulerApplicationAttempt attempt, RMContainer rmContainer) {
  if (rmContainer.getState().equals(RMContainerState.COMPLETED)) {
    return;
  }
  // Careful! Locking order is important! 
  synchronized (this) {
    FiCaSchedulerNode node =
        scheduler.getNode(rmContainer.getContainer().getNodeId());
    super.allocateResource(clusterResource, rmContainer.getContainer()
        .getResource(), node.getLabels());
  }
  if (parent != null) {
    parent.recoverContainer(clusterResource, attempt, rmContainer);
  }
}
 

import org.apache.hadoop.yarn.server.resourcemanager.rmcontainer.RMContainer; //导入依赖的package包/类
@Override
public void attachContainer(Resource clusterResource,
    FiCaSchedulerApp application, RMContainer rmContainer) {
  if (application != null) {
    FiCaSchedulerNode node =
        scheduler.getNode(rmContainer.getContainer().getNodeId());
    super.allocateResource(clusterResource, rmContainer.getContainer()
        .getResource(), node.getLabels());
    LOG.info("movedContainer" + " queueMoveIn=" + getQueueName()
        + " usedCapacity=" + getUsedCapacity() + " absoluteUsedCapacity="
        + getAbsoluteUsedCapacity() + " used=" + queueUsage.getUsed() + " cluster="
        + clusterResource);
    // Inform the parent
    if (parent != null) {
      parent.attachContainer(clusterResource, application, rmContainer);
    }
  }
}
 

import org.apache.hadoop.yarn.server.resourcemanager.rmcontainer.RMContainer; //导入依赖的package包/类
private synchronized CSAssignment assignReservedContainer(
    FiCaSchedulerApp application, FiCaSchedulerNode node,
    RMContainer rmContainer, Resource clusterResource) {
  // Do we still need this reservation?
  Priority priority = rmContainer.getReservedPriority();
  if (application.getTotalRequiredResources(priority) == 0) {
    // Release
    return new CSAssignment(application, rmContainer);
  }

  // Try to assign if we have sufficient resources
  assignContainersOnNode(clusterResource, node, application, priority, 
      rmContainer, new ResourceLimits(Resources.none()));
  
  // Doesn't matter... since it's already charged for at time of reservation
  // "re-reservation" is *free*
  return new CSAssignment(Resources.none(), NodeType.NODE_LOCAL);
}
 

import org.apache.hadoop.yarn.server.resourcemanager.rmcontainer.RMContainer; //导入依赖的package包/类
private static RMContainer createRMContainer(ContainerId containerId) {
  RMContainer container = mock(RMContainer.class);
  when(container.getContainerId()).thenReturn(containerId);
  when(container.getAllocatedNode()).thenReturn(
      NodeId.newInstance("test host", -100));
  when(container.getAllocatedResource()).thenReturn(
      Resource.newInstance(-1, -1, -1));
  when(container.getAllocatedPriority()).thenReturn(Priority.UNDEFINED);
  when(container.getCreationTime()).thenReturn(Integer.MAX_VALUE + 1L);
  when(container.getFinishTime()).thenReturn(Integer.MAX_VALUE + 2L);
  when(container.getDiagnosticsInfo()).thenReturn("test diagnostics info");
  when(container.getContainerExitStatus()).thenReturn(-1);
  when(container.getContainerState()).thenReturn(ContainerState.COMPLETE);
  Container mockContainer = mock(Container.class);
  when(container.getContainer()).thenReturn(mockContainer);
  when(mockContainer.getNodeHttpAddress())
    .thenReturn("http://localhost:1234");
  return container;
}
 

import org.apache.hadoop.yarn.server.resourcemanager.rmcontainer.RMContainer; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public void containerCreated(RMContainer container, long createdTime) {
  if (publishSystemMetrics) {
    dispatcher.getEventHandler().handle(
        new ContainerCreatedEvent(
            container.getContainerId(),
            container.getAllocatedResource(),
            container.getAllocatedNode(),
            container.getAllocatedPriority(),
            createdTime, container.getNodeHttpAddress()));
  }
}
 

import org.apache.hadoop.yarn.server.resourcemanager.rmcontainer.RMContainer; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public void containerStarted(RMContainer container) {
  if (historyServiceEnabled) {
    dispatcher.getEventHandler().handle(
      new WritingContainerStartEvent(container.getContainerId(),
        ContainerStartData.newInstance(container.getContainerId(),
          container.getAllocatedResource(), container.getAllocatedNode(),
          container.getAllocatedPriority(), container.getCreationTime())));
  }
}
 

import org.apache.hadoop.yarn.server.resourcemanager.rmcontainer.RMContainer; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public void containerFinished(RMContainer container) {
  if (historyServiceEnabled) {
    dispatcher.getEventHandler().handle(
      new WritingContainerFinishEvent(container.getContainerId(),
        ContainerFinishData.newInstance(container.getContainerId(),
          container.getFinishTime(), container.getDiagnosticsInfo(),
          container.getContainerExitStatus(),
          container.getContainerState())));
  }
}