Java MockRM.registerNode方法代码示例

import org.apache.hadoop.yarn.server.resourcemanager.MockRM; //导入方法依赖的package包/类
@Test
public void testMaxPriorityValidation() throws Exception {

  Configuration conf = new Configuration();
  conf.setClass(YarnConfiguration.RM_SCHEDULER, CapacityScheduler.class,
      ResourceScheduler.class);
  // Set Max Application Priority as 10
  conf.setInt(YarnConfiguration.MAX_CLUSTER_LEVEL_APPLICATION_PRIORITY, 10);
  Priority maxPriority = Priority.newInstance(10);
  MockRM rm = new MockRM(conf);
  rm.start();

  Priority appPriority1 = Priority.newInstance(15);
  rm.registerNode("127.0.0.1:1234", 8 * GB);
  RMApp app1 = rm.submitApp(1 * GB, appPriority1);

  // Application submission should be successful and verify priority
  Assert.assertEquals(app1.getApplicationSubmissionContext().getPriority(),
      maxPriority);
  rm.stop();
}
 

import org.apache.hadoop.yarn.server.resourcemanager.MockRM; //导入方法依赖的package包/类
@Test
public void testExistenceOfResourceRequestInRMContainer() throws Exception {
  Configuration conf = new Configuration();
  MockRM rm1 = new MockRM(conf);
  rm1.start();
  MockNM nm1 = rm1.registerNode("unknownhost:1234", 8000);
  RMApp app1 = rm1.submitApp(1024);
  MockAM am1 = MockRM.launchAndRegisterAM(app1, rm1, nm1);
  ResourceScheduler scheduler = rm1.getResourceScheduler();

  // request a container.
  am1.allocate("127.0.0.1", 1024, 1, new ArrayList<ContainerId>());
  ContainerId containerId2 = ContainerId.newContainerId(
      am1.getApplicationAttemptId(), 2);
  rm1.waitForState(nm1, containerId2, RMContainerState.ALLOCATED);

  // Verify whether list of ResourceRequest is present in RMContainer
  // while moving to ALLOCATED state
  Assert.assertNotNull(scheduler.getRMContainer(containerId2)
      .getResourceRequests());

  // Allocate container
  am1.allocate(new ArrayList<ResourceRequest>(), new ArrayList<ContainerId>())
      .getAllocatedContainers();
  rm1.waitForState(nm1, containerId2, RMContainerState.ACQUIRED);

  // After RMContainer moving to ACQUIRED state, list of ResourceRequest will
  // be empty
  Assert.assertNull(scheduler.getRMContainer(containerId2)
      .getResourceRequests());
}
 

import org.apache.hadoop.yarn.server.resourcemanager.MockRM; //导入方法依赖的package包/类
@Test
public void testContainerTokenGeneratedOnPullRequest() throws Exception {
  MockRM rm1 = new MockRM(conf);
  rm1.start();
  MockNM nm1 = rm1.registerNode("127.0.0.1:1234", 8000);
  RMApp app1 = rm1.submitApp(200);
  MockAM am1 = MockRM.launchAndRegisterAM(app1, rm1, nm1);
  // request a container.
  am1.allocate("127.0.0.1", 1024, 1, new ArrayList<ContainerId>());
  ContainerId containerId2 =
      ContainerId.newContainerId(am1.getApplicationAttemptId(), 2);
  rm1.waitForState(nm1, containerId2, RMContainerState.ALLOCATED);

  RMContainer container =
      rm1.getResourceScheduler().getRMContainer(containerId2);
  // no container token is generated.
  Assert.assertEquals(containerId2, container.getContainerId());
  Assert.assertNull(container.getContainer().getContainerToken());

  // acquire the container.
  List<Container> containers =
      am1.allocate(new ArrayList<ResourceRequest>(),
        new ArrayList<ContainerId>()).getAllocatedContainers();
  Assert.assertEquals(containerId2, containers.get(0).getId());
  // container token is generated.
  Assert.assertNotNull(containers.get(0).getContainerToken());
  rm1.stop();
}
 

import org.apache.hadoop.yarn.server.resourcemanager.MockRM; //导入方法依赖的package包/类
@Test
public void testNormalContainerAllocationWhenDNSUnavailable() throws Exception{
  MockRM rm1 = new MockRM(conf);
  rm1.start();
  MockNM nm1 = rm1.registerNode("unknownhost:1234", 8000);
  RMApp app1 = rm1.submitApp(200);
  MockAM am1 = MockRM.launchAndRegisterAM(app1, rm1, nm1);

  // request a container.
  am1.allocate("127.0.0.1", 1024, 1, new ArrayList<ContainerId>());
  ContainerId containerId2 =
      ContainerId.newContainerId(am1.getApplicationAttemptId(), 2);
  rm1.waitForState(nm1, containerId2, RMContainerState.ALLOCATED);

  // acquire the container.
  SecurityUtilTestHelper.setTokenServiceUseIp(true);
  List<Container> containers =
      am1.allocate(new ArrayList<ResourceRequest>(),
        new ArrayList<ContainerId>()).getAllocatedContainers();
  // not able to fetch the container;
  Assert.assertEquals(0, containers.size());

  SecurityUtilTestHelper.setTokenServiceUseIp(false);
  containers =
      am1.allocate(new ArrayList<ResourceRequest>(),
        new ArrayList<ContainerId>()).getAllocatedContainers();
  // should be able to fetch the container;
  Assert.assertEquals(1, containers.size());
}
 

import org.apache.hadoop.yarn.server.resourcemanager.MockRM; //导入方法依赖的package包/类
@Test
public void testLogAggregationContextPassedIntoContainerToken()
    throws Exception {
  MockRM rm1 = new MockRM(conf);
  rm1.start();
  MockNM nm1 = rm1.registerNode("127.0.0.1:1234", 8000);
  MockNM nm2 = rm1.registerNode("127.0.0.1:2345", 8000);
  // LogAggregationContext is set as null
  Assert
    .assertNull(getLogAggregationContextFromContainerToken(rm1, nm1, null));

  // create a not-null LogAggregationContext
  LogAggregationContext logAggregationContext =
      LogAggregationContext.newInstance(
        "includePattern", "excludePattern",
        "rolledLogsIncludePattern",
        "rolledLogsExcludePattern");
  LogAggregationContext returned =
      getLogAggregationContextFromContainerToken(rm1, nm2,
        logAggregationContext);
  Assert.assertEquals("includePattern", returned.getIncludePattern());
  Assert.assertEquals("excludePattern", returned.getExcludePattern());
  Assert.assertEquals("rolledLogsIncludePattern",
    returned.getRolledLogsIncludePattern());
  Assert.assertEquals("rolledLogsExcludePattern",
    returned.getRolledLogsExcludePattern());
  rm1.stop();
}
 

import org.apache.hadoop.yarn.server.resourcemanager.MockRM; //导入方法依赖的package包/类
@Test(timeout = 30000)
public void testAMContainerAllocationWhenDNSUnavailable() throws Exception {
  MockRM rm1 = new MockRM(conf) {
    @Override
    protected RMSecretManagerService createRMSecretManagerService() {
      return new TestRMSecretManagerService(conf, rmContext);
    }
  };
  rm1.start();

  MockNM nm1 = rm1.registerNode("unknownhost:1234", 8000);
  SecurityUtilTestHelper.setTokenServiceUseIp(true);
  RMApp app1 = rm1.submitApp(200);
  RMAppAttempt attempt = app1.getCurrentAppAttempt();
  nm1.nodeHeartbeat(true);

  // fetching am container will fail, keep retrying 5 times.
  while (numRetries <= 5) {
    nm1.nodeHeartbeat(true);
    Thread.sleep(1000);
    Assert.assertEquals(RMAppAttemptState.SCHEDULED,
      attempt.getAppAttemptState());
    System.out.println("Waiting for am container to be allocated.");
  }

  SecurityUtilTestHelper.setTokenServiceUseIp(false);
  rm1.waitForState(attempt.getAppAttemptId(), RMAppAttemptState.ALLOCATED);
  MockRM.launchAndRegisterAM(app1, rm1, nm1);
}
 

import org.apache.hadoop.yarn.server.resourcemanager.MockRM; //导入方法依赖的package包/类
@Test (timeout = 180000)
public void testStoreAllContainerMetrics() throws Exception {
  Configuration conf = new Configuration();
  conf.setInt(YarnConfiguration.RM_AM_MAX_ATTEMPTS, 1);
  conf.setBoolean(
      YarnConfiguration.APPLICATION_HISTORY_SAVE_NON_AM_CONTAINER_META_INFO,
      true);
  MockRM rm1 = new MockRM(conf);

  SystemMetricsPublisher publisher = mock(SystemMetricsPublisher.class);
  rm1.getRMContext().setSystemMetricsPublisher(publisher);

  rm1.start();
  MockNM nm1 = rm1.registerNode("unknownhost:1234", 8000);
  RMApp app1 = rm1.submitApp(1024);
  MockAM am1 = MockRM.launchAndRegisterAM(app1, rm1, nm1);
  nm1.nodeHeartbeat(am1.getApplicationAttemptId(), 1, ContainerState.RUNNING);

  // request a container.
  am1.allocate("127.0.0.1", 1024, 1, new ArrayList<ContainerId>());
  ContainerId containerId2 = ContainerId.newContainerId(
      am1.getApplicationAttemptId(), 2);
  rm1.waitForState(nm1, containerId2, RMContainerState.ALLOCATED);
  am1.allocate(new ArrayList<ResourceRequest>(), new ArrayList<ContainerId>())
      .getAllocatedContainers();
  rm1.waitForState(nm1, containerId2, RMContainerState.ACQUIRED);
  nm1.nodeHeartbeat(am1.getApplicationAttemptId(), 2, ContainerState.RUNNING);
  nm1.nodeHeartbeat(am1.getApplicationAttemptId(), 2, ContainerState.COMPLETE);
  nm1.nodeHeartbeat(am1.getApplicationAttemptId(), 1, ContainerState.COMPLETE);
  rm1.waitForState(nm1, containerId2, RMContainerState.COMPLETED);
  rm1.stop();

  // RMContainer should be publishing system metrics for all containers.
  // Since there is 1 AM container and 1 non-AM container, there should be 2
  // container created events and 2 container finished events.
  verify(publisher, times(2)).containerCreated(any(RMContainer.class), anyLong());
  verify(publisher, times(2)).containerFinished(any(RMContainer.class), anyLong());
}
 

import org.apache.hadoop.yarn.server.resourcemanager.MockRM; //导入方法依赖的package包/类
@Test
public void testNormalContainerAllocationWhenDNSUnavailable() throws Exception{
  MockRM rm1 = new MockRM(conf);
  rm1.start();
  MockNM nm1 = rm1.registerNode("unknownhost:1234", 8000);
  RMApp app1 = rm1.submitApp(200);
  MockAM am1 = MockRM.launchAndRegisterAM(app1, rm1, nm1);

  // request a container.
  am1.allocate("127.0.0.1", 1024, 1, new ArrayList<ContainerId>());
  ContainerId containerId2 =
      ContainerId.newContainerId(am1.getApplicationAttemptId(), 2);
  rm1.waitForState(nm1, containerId2, RMContainerState.ALLOCATED);

  // acquire the container.
  SecurityUtilTestHelper.setTokenServiceUseIp(true);
  List<Container> containers;
  try {
    containers =
        am1.allocate(new ArrayList<ResourceRequest>(),
            new ArrayList<ContainerId>()).getAllocatedContainers();
    // not able to fetch the container;
    Assert.assertEquals(0, containers.size());
  } finally {
    SecurityUtilTestHelper.setTokenServiceUseIp(false);
  }
  containers =
      am1.allocate(new ArrayList<ResourceRequest>(),
        new ArrayList<ContainerId>()).getAllocatedContainers();
  // should be able to fetch the container;
  Assert.assertEquals(1, containers.size());
}
 

import org.apache.hadoop.yarn.server.resourcemanager.MockRM; //导入方法依赖的package包/类
@Test
public void testLogAggregationContextPassedIntoContainerToken()
    throws Exception {
  MockRM rm1 = new MockRM(conf);
  rm1.start();
  MockNM nm1 = rm1.registerNode("127.0.0.1:1234", 8000);
  MockNM nm2 = rm1.registerNode("127.0.0.1:2345", 8000);
  // LogAggregationContext is set as null
  Assert
    .assertNull(getLogAggregationContextFromContainerToken(rm1, nm1, null));

  // create a not-null LogAggregationContext
  LogAggregationContext logAggregationContext =
      LogAggregationContext.newInstance(
        "includePattern", "excludePattern",
        "rolledLogsIncludePattern",
        "rolledLogsExcludePattern",
        "policyClass",
        "policyParameters");
  LogAggregationContext returned =
      getLogAggregationContextFromContainerToken(rm1, nm2,
        logAggregationContext);
  Assert.assertEquals("includePattern", returned.getIncludePattern());
  Assert.assertEquals("excludePattern", returned.getExcludePattern());
  Assert.assertEquals("rolledLogsIncludePattern",
      returned.getRolledLogsIncludePattern());
  Assert.assertEquals("rolledLogsExcludePattern",
      returned.getRolledLogsExcludePattern());
  Assert.assertEquals("policyClass",
      returned.getLogAggregationPolicyClassName());
  Assert.assertEquals("policyParameters",
      returned.getLogAggregationPolicyParameters());
  rm1.stop();
}
 

import org.apache.hadoop.yarn.server.resourcemanager.MockRM; //导入方法依赖的package包/类
@Test(timeout = 30000)
public void testAMContainerAllocationWhenDNSUnavailable() throws Exception {
  MockRM rm1 = new MockRM(conf) {
    @Override
    protected RMSecretManagerService createRMSecretManagerService() {
      return new TestRMSecretManagerService(conf, rmContext);
    }
  };
  rm1.start();

  MockNM nm1 = rm1.registerNode("unknownhost:1234", 8000);
  RMApp app1;
  try {
    SecurityUtilTestHelper.setTokenServiceUseIp(true);
    app1 = rm1.submitApp(200);
    RMAppAttempt attempt = app1.getCurrentAppAttempt();
    nm1.nodeHeartbeat(true);

    // fetching am container will fail, keep retrying 5 times.
    while (numRetries <= 5) {
      nm1.nodeHeartbeat(true);
      Thread.sleep(1000);
      Assert.assertEquals(RMAppAttemptState.SCHEDULED,
          attempt.getAppAttemptState());
      System.out.println("Waiting for am container to be allocated.");
    }
  } finally {
    SecurityUtilTestHelper.setTokenServiceUseIp(false);
  }
  MockRM.launchAndRegisterAM(app1, rm1, nm1);
}
 

import org.apache.hadoop.yarn.server.resourcemanager.MockRM; //导入方法依赖的package包/类
private void testRMWritingMassiveHistory(MockRM rm) throws Exception {
  rm.start();
  MockNM nm = rm.registerNode("127.0.0.1:1234", 1024 * 10100);

  RMApp app = rm.submitApp(1024);
  nm.nodeHeartbeat(true);
  RMAppAttempt attempt = app.getCurrentAppAttempt();
  MockAM am = rm.sendAMLaunched(attempt.getAppAttemptId());
  am.registerAppAttempt();

  int request = 10000;
  am.allocate("127.0.0.1", 1024, request, new ArrayList<ContainerId>());
  nm.nodeHeartbeat(true);
  List<Container> allocated =
      am.allocate(new ArrayList<ResourceRequest>(),
        new ArrayList<ContainerId>()).getAllocatedContainers();
  int waitCount = 0;
  int allocatedSize = allocated.size();
  while (allocatedSize < request && waitCount++ < 200) {
    Thread.sleep(300);
    allocated =
        am.allocate(new ArrayList<ResourceRequest>(),
          new ArrayList<ContainerId>()).getAllocatedContainers();
    allocatedSize += allocated.size();
    nm.nodeHeartbeat(true);
  }
  Assert.assertEquals(request, allocatedSize);

  am.unregisterAppAttempt();
  am.waitForState(RMAppAttemptState.FINISHING);
  nm.nodeHeartbeat(am.getApplicationAttemptId(), 1, ContainerState.COMPLETE);
  am.waitForState(RMAppAttemptState.FINISHED);

  NodeHeartbeatResponse resp = nm.nodeHeartbeat(true);
  List<ContainerId> cleaned = resp.getContainersToCleanup();
  int cleanedSize = cleaned.size();
  waitCount = 0;
  while (cleanedSize < allocatedSize && waitCount++ < 200) {
    Thread.sleep(300);
    resp = nm.nodeHeartbeat(true);
    cleaned = resp.getContainersToCleanup();
    cleanedSize += cleaned.size();
  }
  Assert.assertEquals(allocatedSize, cleanedSize);
  rm.waitForState(app.getApplicationId(), RMAppState.FINISHED);

  rm.stop();
}
 

import org.apache.hadoop.yarn.server.resourcemanager.MockRM; //导入方法依赖的package包/类
@Test(timeout = 30000)
public void testAppReservationWithDominantResourceCalculator() throws Exception {
  CapacitySchedulerConfiguration csconf =
      new CapacitySchedulerConfiguration();
  csconf.setResourceComparator(DominantResourceCalculator.class);

  YarnConfiguration conf = new YarnConfiguration(csconf);
  conf.setClass(YarnConfiguration.RM_SCHEDULER, CapacityScheduler.class,
    ResourceScheduler.class);

  MockRM rm = new MockRM(conf);
  rm.start();

  MockNM nm1 = rm.registerNode("127.0.0.1:1234", 10 * GB, 1, 1);

  // register extra nodes to bump up cluster resource
  MockNM nm2 = rm.registerNode("127.0.0.1:1235", 10 * GB, 4, 4);
  rm.registerNode("127.0.0.1:1236", 10 * GB, 4, 4);

  RMApp app1 = rm.submitApp(1024);
  // kick the scheduling
  nm1.nodeHeartbeat(true);
  RMAppAttempt attempt1 = app1.getCurrentAppAttempt();
  MockAM am1 = rm.sendAMLaunched(attempt1.getAppAttemptId());
  am1.registerAppAttempt();
  SchedulerNodeReport report_nm1 =
      rm.getResourceScheduler().getNodeReport(nm1.getNodeId());

  // check node report
  Assert.assertEquals(1 * GB, report_nm1.getUsedResource().getMemory());
  Assert.assertEquals(9 * GB, report_nm1.getAvailableResource().getMemory());

  // add request for containers
  am1.addRequests(new String[] { "127.0.0.1", "127.0.0.2" }, 1 * GB, 1, 1);
  am1.schedule(); // send the request

  // kick the scheduler, container reservation should not happen
  nm1.nodeHeartbeat(true);
  Thread.sleep(1000);
  AllocateResponse allocResponse = am1.schedule();
  ApplicationResourceUsageReport report =
      rm.getResourceScheduler().getAppResourceUsageReport(
        attempt1.getAppAttemptId());
  Assert.assertEquals(0, allocResponse.getAllocatedContainers().size());
  Assert.assertEquals(0, report.getNumReservedContainers());

  // container should get allocated on this node
  nm2.nodeHeartbeat(true);

  while (allocResponse.getAllocatedContainers().size() == 0) {
    Thread.sleep(100);
    allocResponse = am1.schedule();
  }
  report =
      rm.getResourceScheduler().getAppResourceUsageReport(
        attempt1.getAppAttemptId());
  Assert.assertEquals(1, allocResponse.getAllocatedContainers().size());
  Assert.assertEquals(0, report.getNumReservedContainers());
  rm.stop();
}
 

import org.apache.hadoop.yarn.server.resourcemanager.MockRM; //导入方法依赖的package包/类
@Test(timeout = 3000000)
public void testExcessReservationThanNodeManagerCapacity() throws Exception {
  @SuppressWarnings("resource")
  MockRM rm = new MockRM(conf);
  rm.start();

  // Register node1
  MockNM nm1 = rm.registerNode("127.0.0.1:1234", 2 * GB, 4, 4);
  MockNM nm2 = rm.registerNode("127.0.0.1:2234", 3 * GB, 4, 4);

  nm1.nodeHeartbeat(true);
  nm2.nodeHeartbeat(true);

  // wait..
  int waitCount = 20;
  int size = rm.getRMContext().getRMNodes().size();
  while ((size = rm.getRMContext().getRMNodes().size()) != 2
      && waitCount-- > 0) {
    LOG.info("Waiting for node managers to register : " + size);
    Thread.sleep(100);
  }
  Assert.assertEquals(2, rm.getRMContext().getRMNodes().size());
  // Submit an application
  RMApp app1 = rm.submitApp(128);

  // kick the scheduling
  nm1.nodeHeartbeat(true);
  RMAppAttempt attempt1 = app1.getCurrentAppAttempt();
  MockAM am1 = rm.sendAMLaunched(attempt1.getAppAttemptId());
  am1.registerAppAttempt();

  LOG.info("sending container requests ");
  am1.addRequests(new String[] {"*"}, 2 * GB, 1, 1);
  AllocateResponse alloc1Response = am1.schedule(); // send the request

  // kick the scheduler
  nm1.nodeHeartbeat(true);
  int waitCounter = 20;
  LOG.info("heartbeating nm1");
  while (alloc1Response.getAllocatedContainers().size() < 1
      && waitCounter-- > 0) {
    LOG.info("Waiting for containers to be created for app 1...");
    Thread.sleep(500);
    alloc1Response = am1.schedule();
  }
  LOG.info("received container : "
      + alloc1Response.getAllocatedContainers().size());

  // No container should be allocated.
  // Internally it should not been reserved.
  Assert.assertTrue(alloc1Response.getAllocatedContainers().size() == 0);

  LOG.info("heartbeating nm2");
  waitCounter = 20;
  nm2.nodeHeartbeat(true);
  while (alloc1Response.getAllocatedContainers().size() < 1
      && waitCounter-- > 0) {
    LOG.info("Waiting for containers to be created for app 1...");
    Thread.sleep(500);
    alloc1Response = am1.schedule();
  }
  LOG.info("received container : "
      + alloc1Response.getAllocatedContainers().size());
  Assert.assertTrue(alloc1Response.getAllocatedContainers().size() == 1);

  rm.stop();
}
 

import org.apache.hadoop.yarn.server.resourcemanager.MockRM; //导入方法依赖的package包/类
@Test (timeout = 300000)
public void testContainerAllocationWithSingleUserLimits() throws Exception {
  final RMNodeLabelsManager mgr = new NullRMNodeLabelsManager();
  mgr.init(conf);

  // set node -> label
  mgr.addToCluserNodeLabels(ImmutableSet.of("x", "y"));
  mgr.addLabelsToNode(ImmutableMap.of(NodeId.newInstance("h1", 0), toSet("x"),
      NodeId.newInstance("h2", 0), toSet("y")));

  // inject node label manager
  MockRM rm1 = new MockRM(TestUtils.getConfigurationWithDefaultQueueLabels(conf)) {
    @Override
    public RMNodeLabelsManager createNodeLabelManager() {
      return mgr;
    }
  };

  rm1.getRMContext().setNodeLabelManager(mgr);
  rm1.start();
  MockNM nm1 = rm1.registerNode("h1:1234", 8000); // label = x
  rm1.registerNode("h2:1234", 8000); // label = y
  MockNM nm3 = rm1.registerNode("h3:1234", 8000); // label = <empty>

  // launch an app to queue a1 (label = x), and check all container will
  // be allocated in h1
  RMApp app1 = rm1.submitApp(200, "app", "user", null, "a1");
  MockAM am1 = MockRM.launchAndRegisterAM(app1, rm1, nm1);
  
  // A has only 10% of x, so it can only allocate one container in label=empty
  ContainerId containerId =
      ContainerId.newContainerId(am1.getApplicationAttemptId(), 2);
  am1.allocate("*", 1024, 1, new ArrayList<ContainerId>(), "");
  Assert.assertTrue(rm1.waitForState(nm3, containerId,
        RMContainerState.ALLOCATED, 10 * 1000));
  // Cannot allocate 2nd label=empty container
  containerId =
      ContainerId.newContainerId(am1.getApplicationAttemptId(), 3);
  am1.allocate("*", 1024, 1, new ArrayList<ContainerId>(), "");
  Assert.assertFalse(rm1.waitForState(nm3, containerId,
        RMContainerState.ALLOCATED, 10 * 1000));

  // A has default user limit = 100, so it can use all resource in label = x
  // We can allocate floor(8000 / 1024) = 7 containers
  for (int id = 3; id <= 8; id++) {
    containerId =
        ContainerId.newContainerId(am1.getApplicationAttemptId(), id);
    am1.allocate("*", 1024, 1, new ArrayList<ContainerId>(), "x");
    Assert.assertTrue(rm1.waitForState(nm1, containerId,
        RMContainerState.ALLOCATED, 10 * 1000));
  }
  rm1.close();
}
 

import org.apache.hadoop.yarn.server.resourcemanager.MockRM; //导入方法依赖的package包/类
@Test (timeout = 120000)
public void testContainerAllocateWithLabels() throws Exception {
  // set node -> label
  mgr.addToCluserNodeLabels(ImmutableSet.of("x", "y"));
  mgr.addLabelsToNode(ImmutableMap.of(NodeId.newInstance("h1", 0), toSet("x"),
      NodeId.newInstance("h2", 0), toSet("y")));

  // inject node label manager
  MockRM rm1 = new MockRM(getConfigurationWithQueueLabels(conf)) {
    @Override
    public RMNodeLabelsManager createNodeLabelManager() {
      return mgr;
    }
  };

  rm1.getRMContext().setNodeLabelManager(mgr);
  rm1.start();
  MockNM nm1 = rm1.registerNode("h1:1234", 8000); // label = x
  MockNM nm2 = rm1.registerNode("h2:1234", 8000); // label = y
  MockNM nm3 = rm1.registerNode("h3:1234", 8000); // label = <empty>
  
  ContainerId containerId;

  // launch an app to queue a1 (label = x), and check all container will
  // be allocated in h1
  RMApp app1 = rm1.submitApp(200, "app", "user", null, "a1");
  MockAM am1 = MockRM.launchAndRegisterAM(app1, rm1, nm3);

  // request a container.
  am1.allocate("*", 1024, 1, new ArrayList<ContainerId>(), "x");
  containerId =
      ContainerId.newContainerId(am1.getApplicationAttemptId(), 2);
  Assert.assertFalse(rm1.waitForState(nm2, containerId,
      RMContainerState.ALLOCATED, 10 * 1000));
  Assert.assertTrue(rm1.waitForState(nm1, containerId,
      RMContainerState.ALLOCATED, 10 * 1000));
  checkTaskContainersHost(am1.getApplicationAttemptId(), containerId, rm1,
      "h1");

  // launch an app to queue b1 (label = y), and check all container will
  // be allocated in h2
  RMApp app2 = rm1.submitApp(200, "app", "user", null, "b1");
  MockAM am2 = MockRM.launchAndRegisterAM(app2, rm1, nm3);

  // request a container.
  am2.allocate("*", 1024, 1, new ArrayList<ContainerId>(), "y");
  containerId = ContainerId.newContainerId(am2.getApplicationAttemptId(), 2);
  Assert.assertFalse(rm1.waitForState(nm1, containerId,
      RMContainerState.ALLOCATED, 10 * 1000));
  Assert.assertTrue(rm1.waitForState(nm2, containerId,
      RMContainerState.ALLOCATED, 10 * 1000));
  checkTaskContainersHost(am2.getApplicationAttemptId(), containerId, rm1,
      "h2");
  
  // launch an app to queue c1 (label = ""), and check all container will
  // be allocated in h3
  RMApp app3 = rm1.submitApp(200, "app", "user", null, "c1");
  MockAM am3 = MockRM.launchAndRegisterAM(app3, rm1, nm3);

  // request a container.
  am3.allocate("*", 1024, 1, new ArrayList<ContainerId>());
  containerId = ContainerId.newContainerId(am3.getApplicationAttemptId(), 2);
  Assert.assertFalse(rm1.waitForState(nm2, containerId,
      RMContainerState.ALLOCATED, 10 * 1000));
  Assert.assertTrue(rm1.waitForState(nm3, containerId,
      RMContainerState.ALLOCATED, 10 * 1000));
  checkTaskContainersHost(am3.getApplicationAttemptId(), containerId, rm1,
      "h3");

  rm1.close();
}