Java SchedulerApplication.getCurrentAppAttempt方法代码示例

import org.apache.hadoop.yarn.server.resourcemanager.scheduler.SchedulerApplication; //导入方法依赖的package包/类
private void checkFifoQueue(SchedulerApplication schedulerApp,
    Resource usedResources, Resource availableResources) throws Exception {
  FifoScheduler scheduler = (FifoScheduler) rm2.getResourceScheduler();
  // ************ check cluster used Resources ********
  assertEquals(usedResources, scheduler.getUsedResource());

  // ************ check app headroom ****************
  SchedulerApplicationAttempt schedulerAttempt =
      schedulerApp.getCurrentAppAttempt();
  assertEquals(availableResources, schedulerAttempt.getHeadroom());

  // ************ check queue metrics ****************
  QueueMetrics queueMetrics = scheduler.getRootQueueMetrics();
  asserteMetrics(queueMetrics, 1, 0, 1, 0, 2, availableResources.getMemory(),
    availableResources.getVirtualCores(), usedResources.getMemory(),
    usedResources.getVirtualCores());
}
 

import org.apache.hadoop.yarn.server.resourcemanager.scheduler.SchedulerApplication; //导入方法依赖的package包/类
@Override
public synchronized String moveApplication(ApplicationId appId,
    String queueName) throws YarnException {
  SchedulerApplication<FSAppAttempt> app = applications.get(appId);
  if (app == null) {
    throw new YarnException("App to be moved " + appId + " not found.");
  }
  FSAppAttempt attempt = (FSAppAttempt) app.getCurrentAppAttempt();
  // To serialize with FairScheduler#allocate, synchronize on app attempt
  synchronized (attempt) {
    FSLeafQueue oldQueue = (FSLeafQueue) app.getQueue();
    String destQueueName = handleMoveToPlanQueue(queueName);
    FSLeafQueue targetQueue = queueMgr.getLeafQueue(destQueueName, false);
    if (targetQueue == null) {
      throw new YarnException("Target queue " + queueName
          + " not found or is not a leaf queue.");
    }
    if (targetQueue == oldQueue) {
      return oldQueue.getQueueName();
    }
    
    if (oldQueue.isRunnableApp(attempt)) {
      verifyMoveDoesNotViolateConstraints(attempt, oldQueue, targetQueue);
    }
    
    executeMove(app, attempt, oldQueue, targetQueue);
    return targetQueue.getQueueName();
  }
}
 

import org.apache.hadoop.yarn.server.resourcemanager.scheduler.SchedulerApplication; //导入方法依赖的package包/类
private void checkCSQueue(MockRM rm,
    SchedulerApplication<SchedulerApplicationAttempt> app,
    Resource clusterResource, Resource queueResource, Resource usedResource,
    int numContainers)
    throws Exception {
  checkCSLeafQueue(rm, app, clusterResource, queueResource, usedResource,
      numContainers);

  LeafQueue queue = (LeafQueue) app.getQueue();
  Resource availableResources =
      Resources.subtract(queueResource, usedResource);
  // ************ check app headroom ****************
  SchedulerApplicationAttempt schedulerAttempt = app.getCurrentAppAttempt();
  assertEquals(availableResources, schedulerAttempt.getHeadroom());

  // ************* check Queue metrics ************
  QueueMetrics queueMetrics = queue.getMetrics();
  assertMetrics(queueMetrics, 1, 0, 1, 0, 2, availableResources.getMemory(),
      availableResources.getVirtualCores(), usedResource.getMemory(),
      usedResource.getVirtualCores());

  // ************ check user metrics ***********
  QueueMetrics userMetrics =
      queueMetrics.getUserMetrics(app.getUser());
  assertMetrics(userMetrics, 1, 0, 1, 0, 2, availableResources.getMemory(),
      availableResources.getVirtualCores(), usedResource.getMemory(),
      usedResource.getVirtualCores());
}
 

import org.apache.hadoop.yarn.server.resourcemanager.scheduler.SchedulerApplication; //导入方法依赖的package包/类
private void checkFSQueue(ResourceManager rm,
    SchedulerApplication  schedulerApp, Resource usedResources,
    Resource availableResources) throws Exception {
  // waiting for RM's scheduling apps
  int retry = 0;
  Resource assumedFairShare = Resource.newInstance(8192, 8);
  while (true) {
    Thread.sleep(100);
    if (assumedFairShare.equals(((FairScheduler)rm.getResourceScheduler())
        .getQueueManager().getRootQueue().getFairShare())) {
      break;
    }
    retry++;
    if (retry > 30) {
      Assert.fail("Apps are not scheduled within assumed timeout");
    }
  }

  FairScheduler scheduler = (FairScheduler) rm.getResourceScheduler();
  FSParentQueue root = scheduler.getQueueManager().getRootQueue();
  // ************ check cluster used Resources ********
  assertTrue(root.getPolicy() instanceof DominantResourceFairnessPolicy);
  assertEquals(usedResources,root.getResourceUsage());

  // ************ check app headroom ****************
  FSAppAttempt schedulerAttempt =
      (FSAppAttempt) schedulerApp.getCurrentAppAttempt();
  assertEquals(availableResources, schedulerAttempt.getHeadroom());

  // ************ check queue metrics ****************
  QueueMetrics queueMetrics = scheduler.getRootQueueMetrics();
  assertMetrics(queueMetrics, 1, 0, 1, 0, 2, availableResources.getMemory(),
      availableResources.getVirtualCores(), usedResources.getMemory(),
      usedResources.getVirtualCores());
}
 

import org.apache.hadoop.yarn.server.resourcemanager.scheduler.SchedulerApplication; //导入方法依赖的package包/类
@Override
public synchronized String moveApplication(ApplicationId appId,
    String queueName) throws YarnException {
  SchedulerApplication<FSAppAttempt> app = applications.get(appId);
  if (app == null) {
    throw new YarnException("App to be moved " + appId + " not found.");
  }
  FSAppAttempt attempt = (FSAppAttempt) app.getCurrentAppAttempt();
  // To serialize with FairScheduler#allocate, synchronize on app attempt
  synchronized (attempt) {
    FSLeafQueue oldQueue = (FSLeafQueue) app.getQueue();
    FSLeafQueue targetQueue = queueMgr.getLeafQueue(queueName, false);
    if (targetQueue == null) {
      throw new YarnException("Target queue " + queueName
          + " not found or is not a leaf queue.");
    }
    if (targetQueue == oldQueue) {
      return oldQueue.getQueueName();
    }
    
    if (oldQueue.isRunnableApp(attempt)) {
      verifyMoveDoesNotViolateConstraints(attempt, oldQueue, targetQueue);
    }
    
    executeMove(app, attempt, oldQueue, targetQueue);
    return targetQueue.getQueueName();
  }
}
 

import org.apache.hadoop.yarn.server.resourcemanager.scheduler.SchedulerApplication; //导入方法依赖的package包/类
private void checkCSQueue(MockRM rm,
    SchedulerApplication<SchedulerApplicationAttempt> app,
    Resource clusterResource, Resource queueResource, Resource usedResource,
    int numContainers)
    throws Exception {
  checkCSLeafQueue(rm, app, clusterResource, queueResource, usedResource,
      numContainers);

  LeafQueue queue = (LeafQueue) app.getQueue();
  Resource availableResources =
      Resources.subtract(queueResource, usedResource);
  // ************ check app headroom ****************
  SchedulerApplicationAttempt schedulerAttempt = app.getCurrentAppAttempt();
  assertEquals(availableResources, schedulerAttempt.getHeadroom());

  // ************* check Queue metrics ************
  QueueMetrics queueMetrics = queue.getMetrics();
  assertMetrics(queueMetrics, 1, 0, 1, 0, 2, availableResources.getMemorySize(),
      availableResources.getVirtualCores(), usedResource.getMemorySize(),
      usedResource.getVirtualCores());

  // ************ check user metrics ***********
  QueueMetrics userMetrics =
      queueMetrics.getUserMetrics(app.getUser());
  assertMetrics(userMetrics, 1, 0, 1, 0, 2, availableResources.getMemorySize(),
      availableResources.getVirtualCores(), usedResource.getMemorySize(),
      usedResource.getVirtualCores());
}
 

import org.apache.hadoop.yarn.server.resourcemanager.scheduler.SchedulerApplication; //导入方法依赖的package包/类
private void checkFSQueue(ResourceManager rm,
    SchedulerApplication  schedulerApp, Resource usedResources,
    Resource availableResources) throws Exception {
  // waiting for RM's scheduling apps
  int retry = 0;
  Resource assumedFairShare = Resource.newInstance(8192, 8);
  while (true) {
    Thread.sleep(100);
    if (assumedFairShare.equals(((FairScheduler)rm.getResourceScheduler())
        .getQueueManager().getRootQueue().getFairShare())) {
      break;
    }
    retry++;
    if (retry > 30) {
      Assert.fail("Apps are not scheduled within assumed timeout");
    }
  }

  FairScheduler scheduler = (FairScheduler) rm.getResourceScheduler();
  FSParentQueue root = scheduler.getQueueManager().getRootQueue();
  // ************ check cluster used Resources ********
  assertTrue(root.getPolicy() instanceof DominantResourceFairnessPolicy);
  assertEquals(usedResources,root.getResourceUsage());

  // ************ check app headroom ****************
  FSAppAttempt schedulerAttempt =
      (FSAppAttempt) schedulerApp.getCurrentAppAttempt();
  assertEquals(availableResources, schedulerAttempt.getHeadroom());

  // ************ check queue metrics ****************
  QueueMetrics queueMetrics = scheduler.getRootQueueMetrics();
  assertMetrics(queueMetrics, 1, 0, 1, 0, 2, availableResources.getMemorySize(),
      availableResources.getVirtualCores(), usedResources.getMemorySize(),
      usedResources.getVirtualCores());
}
 

import org.apache.hadoop.yarn.server.resourcemanager.scheduler.SchedulerApplication; //导入方法依赖的package包/类
@VisibleForTesting
FiCaSchedulerApp getApplicationAttempt(ApplicationAttemptId applicationAttemptId) {
  SchedulerApplication app =
      applications.get(applicationAttemptId.getApplicationId());
  if (app != null) {
    return (FiCaSchedulerApp) app.getCurrentAppAttempt();
  }
  return null;
}
 

import org.apache.hadoop.yarn.server.resourcemanager.scheduler.SchedulerApplication; //导入方法依赖的package包/类
private FiCaSchedulerApp getCurrentAttemptForContainer(
    ContainerId containerId) {
  SchedulerApplication app =
      applications.get(containerId.getApplicationAttemptId()
        .getApplicationId());
  if (app != null) {
    return (FiCaSchedulerApp) app.getCurrentAppAttempt();
  }
  return null;
}
 

import org.apache.hadoop.yarn.server.resourcemanager.scheduler.SchedulerApplication; //导入方法依赖的package包/类
private FSSchedulerApp getCurrentAttemptForContainer(
    ContainerId containerId) {
  SchedulerApplication app =
      applications.get(containerId.getApplicationAttemptId()
        .getApplicationId());
  if (app != null) {
    return (FSSchedulerApp) app.getCurrentAppAttempt();
  }
  return null;
}
 

import org.apache.hadoop.yarn.server.resourcemanager.scheduler.SchedulerApplication; //导入方法依赖的package包/类
public FSSchedulerApp getSchedulerApp(ApplicationAttemptId appAttemptId) {
  SchedulerApplication app =
      applications.get(appAttemptId.getApplicationId());
  if (app != null) {
    return (FSSchedulerApp) app.getCurrentAppAttempt();
  }
  return null;
}
 

import org.apache.hadoop.yarn.server.resourcemanager.scheduler.SchedulerApplication; //导入方法依赖的package包/类
@Override
public synchronized String moveApplication(ApplicationId appId,
    String queueName) throws YarnException {
  SchedulerApplication app = applications.get(appId);
  if (app == null) {
    throw new YarnException("App to be moved " + appId + " not found.");
  }
  FSSchedulerApp attempt = (FSSchedulerApp) app.getCurrentAppAttempt();
  // To serialize with FairScheduler#allocate, synchronize on app attempt
  synchronized (attempt) {
    FSLeafQueue oldQueue = (FSLeafQueue) app.getQueue();
    FSLeafQueue targetQueue = queueMgr.getLeafQueue(queueName, false);
    if (targetQueue == null) {
      throw new YarnException("Target queue " + queueName
          + " not found or is not a leaf queue.");
    }
    if (targetQueue == oldQueue) {
      return oldQueue.getQueueName();
    }
    
    if (oldQueue.getRunnableAppSchedulables().contains(
        attempt.getAppSchedulable())) {
      verifyMoveDoesNotViolateConstraints(attempt, oldQueue, targetQueue);
    }
    
    executeMove(app, attempt, oldQueue, targetQueue);
    return targetQueue.getQueueName();
  }
}
 

import org.apache.hadoop.yarn.server.resourcemanager.scheduler.SchedulerApplication; //导入方法依赖的package包/类
@Lock(Lock.NoLock.class)
@VisibleForTesting
public FiCaSchedulerApp getApplicationAttempt(
    ApplicationAttemptId applicationAttemptId) {
  SchedulerApplication app =
      applications.get(applicationAttemptId.getApplicationId());
  if (app != null) {
    return (FiCaSchedulerApp) app.getCurrentAppAttempt();
  }
  return null;
}
 

import org.apache.hadoop.yarn.server.resourcemanager.scheduler.SchedulerApplication; //导入方法依赖的package包/类
@VisibleForTesting
public FiCaSchedulerApp getCurrentAttemptForContainer(
    ContainerId containerId) {
  SchedulerApplication app =
      applications.get(containerId.getApplicationAttemptId()
        .getApplicationId());
  if (app != null) {
    return (FiCaSchedulerApp) app.getCurrentAppAttempt();
  }
  return null;
}
 

import org.apache.hadoop.yarn.server.resourcemanager.scheduler.SchedulerApplication; //导入方法依赖的package包/类
@Override
public void updateApplicationPriority(Priority newPriority,
    ApplicationId applicationId) throws YarnException {
  Priority appPriority = null;
  SchedulerApplication<FiCaSchedulerApp> application = applications
      .get(applicationId);

  if (application == null) {
    throw new YarnException("Application '" + applicationId
        + "' is not present, hence could not change priority.");
  }

  RMApp rmApp = rmContext.getRMApps().get(applicationId);
  appPriority = checkAndGetApplicationPriority(newPriority, rmApp.getUser(),
      rmApp.getQueue(), applicationId);

  if (application.getPriority().equals(appPriority)) {
    return;
  }

  // Update new priority in Submission Context to keep track in HA
  rmApp.getApplicationSubmissionContext().setPriority(appPriority);

  // Update to state store
  ApplicationStateData appState =
      ApplicationStateData.newInstance(rmApp.getSubmitTime(),
          rmApp.getStartTime(), rmApp.getApplicationSubmissionContext(),
          rmApp.getUser(), rmApp.getCallerContext());
  rmContext.getStateStore().updateApplicationStateSynchronously(appState,
      false);

  // As we use iterator over a TreeSet for OrderingPolicy, once we change
  // priority then reinsert back to make order correct.
  LeafQueue queue = (LeafQueue) getQueue(rmApp.getQueue());
  synchronized (queue) {
    FiCaSchedulerApp attempt = application.getCurrentAppAttempt();
    boolean isActive =
        queue.getOrderingPolicy().removeSchedulableEntity(attempt);
    if (!isActive) {
      queue.getPendingAppsOrderingPolicy().removeSchedulableEntity(attempt);
    }
    // Update new priority in SchedulerApplication
    application.setPriority(appPriority);
    if (isActive) {
      queue.getOrderingPolicy().addSchedulableEntity(attempt);
    } else {
      queue.getPendingAppsOrderingPolicy().addSchedulableEntity(attempt);
    }
  }

  // Update the changed application state to timeline server
  rmContext.getSystemMetricsPublisher().appUpdated(rmApp,
      System.currentTimeMillis());

  LOG.info("Priority '" + appPriority + "' is updated in queue :"
      + rmApp.getQueue() + " for application: " + applicationId
      + " for the user: " + rmApp.getUser());
}