How to use

PlacementManager

in

org.apache.hadoop.yarn.server.resourcemanager.placement

@VisibleForTesting
ApplicationPlacementContext placeApplication(
  PlacementManager placementManager, ApplicationSubmissionContext context,
  String user, boolean isRecovery) throws YarnException {
 ApplicationPlacementContext placementContext = null;
 if (placementManager != null) {
  try {
   placementContext = placementManager.placeApplication(context, user);
  } catch (YarnException e) {
   // Placement could also fail if the user doesn't exist in system
   // skip if the user is not found during recovery.
   if (isRecovery) {
    LOG.warn("PlaceApplication failed,skipping on recovery of rm");
    return placementContext;
   }
   throw e;
  }
 }
 if (placementContext == null && (context.getQueue() == null) || context
   .getQueue().isEmpty()) {
  String msg = "Failed to place application " + context.getApplicationId()
    + " to queue and specified " + "queue is invalid : " + context
    .getQueue();
  LOG.error(msg);
  throw new YarnException(msg);
 }
 return placementContext;
}

rmContext.getQueuePlacementManager().updateRules(placementRules);

 private void checkQMapping(QueueMapping expected)
     throws IOException {
  UserGroupMappingPlacementRule rule =
    (UserGroupMappingPlacementRule) cs.getRMContext()
      .getQueuePlacementManager().getPlacementRules().get(0);
  QueueMapping queueMapping = rule.getQueueMappings().get(0);
  Assert.assertEquals(queueMapping, expected);
 }
}

  false, Arrays.asList(userQueueMapping), null);
queuePlacementRules.add(ugRule);
pm.updateRules(queuePlacementRules);
  pm.placeApplication(asc, USER2));
QueueMappingEntity queueMappingEntity = new QueueMappingEntity(APP_NAME,
  USER1, PARENT_QUEUE);
  Arrays.asList(queueMappingEntity));
queuePlacementRules.add(anRule);
pm.updateRules(queuePlacementRules);
try {
 ApplicationPlacementContext pc = pm.placeApplication(asc, USER2);
 Assert.assertNotNull(pc);
} catch (Exception e) {

@Private
@Unstable
public RMActiveServiceContext(Dispatcher rmDispatcher,
  ContainerAllocationExpirer containerAllocationExpirer,
  AMLivelinessMonitor amLivelinessMonitor,
  AMLivelinessMonitor amFinishingMonitor,
  DelegationTokenRenewer delegationTokenRenewer,
  AMRMTokenSecretManager appTokenSecretManager,
  RMContainerTokenSecretManager containerTokenSecretManager,
  NMTokenSecretManagerInRM nmTokenSecretManager,
  ClientToAMTokenSecretManagerInRM clientToAMTokenSecretManager,
  ResourceScheduler scheduler) {
 this();
 this.setContainerAllocationExpirer(containerAllocationExpirer);
 this.setAMLivelinessMonitor(amLivelinessMonitor);
 this.setAMFinishingMonitor(amFinishingMonitor);
 this.setDelegationTokenRenewer(delegationTokenRenewer);
 this.setAMRMTokenSecretManager(appTokenSecretManager);
 this.setContainerTokenSecretManager(containerTokenSecretManager);
 this.setNMTokenSecretManager(nmTokenSecretManager);
 this.setClientToAMTokenSecretManager(clientToAMTokenSecretManager);
 this.setScheduler(scheduler);
 RMStateStore nullStore = new NullRMStateStore();
 nullStore.setRMDispatcher(rmDispatcher);
 try {
  nullStore.init(new YarnConfiguration());
  setStateStore(nullStore);
 } catch (Exception e) {
  assert false;

@Test
public void testRMAppSubmitWithQueueChanged() throws Exception {
 // Setup a PlacementManager returns a new queue
 PlacementManager placementMgr = mock(PlacementManager.class);
 doAnswer(new Answer<ApplicationPlacementContext>() {
  @Override
  public ApplicationPlacementContext answer(InvocationOnMock invocation)
    throws Throwable {
   return new ApplicationPlacementContext("newQueue");
  }
 }).when(placementMgr).placeApplication(
   any(ApplicationSubmissionContext.class), any(String.class));
 rmContext.setQueuePlacementManager(placementMgr);
 asContext.setQueue("oldQueue");
 appMonitor.submitApplication(asContext, "test");
 RMApp app = rmContext.getRMApps().get(appId);
 RMAppEvent event = new RMAppEvent(appId, RMAppEventType.START);
 rmContext.getRMApps().get(appId).handle(event);
 event = new RMAppEvent(appId, RMAppEventType.APP_NEW_SAVED);
 rmContext.getRMApps().get(appId).handle(event);
 Assert.assertNotNull("app is null", app);
 Assert.assertEquals("newQueue", asContext.getQueue());
 // wait for event to be processed
 int timeoutSecs = 0;
 while ((getAppEventType() == RMAppEventType.KILL) && timeoutSecs++ < 20) {
  Thread.sleep(1000);
 }
 Assert.assertEquals("app event type sent is wrong", RMAppEventType.START,
   getAppEventType());
}

 @Test
 public void testUpdatePlacementRulesFactory() throws Exception {
  CapacitySchedulerConfiguration conf = new CapacitySchedulerConfiguration();
  setupQueueConfiguration(conf);
  conf.setClass(YarnConfiguration.RM_SCHEDULER, CapacityScheduler.class,
    ResourceScheduler.class);

  // init queue mapping for UserGroupMappingRule and AppNameMappingRule
  setupQueueMappingsForRules(conf, PARENT_QUEUE, true, new int[] {1, 2, 3});

  mockRM = new MockRM(conf);
  CapacityScheduler cs = (CapacityScheduler) mockRM.getResourceScheduler();
  cs.updatePlacementRules();
  mockRM.start();
  cs.start();

  List<PlacementRule> rules = cs.getRMContext()
    .getQueuePlacementManager().getPlacementRules();

  List<String> placementRuleNames = new ArrayList<>();
  for (PlacementRule pr : rules) {
   placementRuleNames.add(pr.getName());
  }

  // verify both placement rules were added successfully
  assertThat(placementRuleNames, hasItems(QUEUE_MAPPING_RULE_USER_GROUP));
  assertThat(placementRuleNames, hasItems(QUEUE_MAPPING_RULE_APP_NAME));
 }
}

PlacementManager placementMgr = mock(PlacementManager.class);
doThrow(new YarnException("No groups for user")).when(placementMgr)
  .placeApplication(any(ApplicationSubmissionContext.class),
    any(String.class));
MockRM rm2 = new MockRM(conf, memStore) {

}).when(placementMgr).placeApplication(
  any(ApplicationSubmissionContext.class), matches("test1"));
doAnswer(new Answer<ApplicationPlacementContext>() {
}).when(placementMgr).placeApplication(
  any(ApplicationSubmissionContext.class), matches("test2"));

}).when(placementMgr).placeApplication(
  any(ApplicationSubmissionContext.class), matches("test"));

}).when(placementMgr).placeApplication(
  any(ApplicationSubmissionContext.class), matches("user1|user2"));