Java NodeHeartbeatRequest.setNodeStatus方法代码示例

import org.apache.hadoop.yarn.server.api.protocolrecords.NodeHeartbeatRequest; //导入方法依赖的package包/类
public void run() {
  int lastResponseID = 0;
  while (!stopT) {
    try {
      org.apache.hadoop.yarn.server.api.records.NodeStatus nodeStatus =
          recordFactory
              .newRecordInstance(org.apache.hadoop.yarn.server.api.records.NodeStatus.class);
      nodeStatus.setNodeId(request3.getNodeId());
      nodeStatus.setResponseId(lastResponseID);
      nodeStatus.setNodeHealthStatus(recordFactory.newRecordInstance(NodeHealthStatus.class));
      nodeStatus.getNodeHealthStatus().setIsNodeHealthy(true);

      NodeHeartbeatRequest request = recordFactory
          .newRecordInstance(NodeHeartbeatRequest.class);
      request.setNodeStatus(nodeStatus);
      lastResponseID = resourceTrackerService.nodeHeartbeat(request)
          .getResponseId();

      Thread.sleep(1000);
    } catch(Exception e) {
      LOG.info("failed to heartbeat ", e);
    }
  }
}
 

import org.apache.hadoop.yarn.server.api.protocolrecords.NodeHeartbeatRequest; //导入方法依赖的package包/类
public void heartbeat() throws IOException, YarnException {
  NodeStatus nodeStatus = 
    org.apache.hadoop.yarn.server.resourcemanager.NodeManager.createNodeStatus(
        nodeId, getContainerStatuses(containers));
  nodeStatus.setResponseId(responseID);
  NodeHeartbeatRequest request = recordFactory
      .newRecordInstance(NodeHeartbeatRequest.class);
  request.setNodeStatus(nodeStatus);
  NodeHeartbeatResponse response = resourceTrackerService
      .nodeHeartbeat(request);
  responseID = response.getResponseId();
}
 

import org.apache.hadoop.yarn.server.api.protocolrecords.NodeHeartbeatRequest; //导入方法依赖的package包/类
public NodeHeartbeatResponse nodeHeartbeat(Map<ApplicationId,
    List<ContainerStatus>> conts, boolean isHealthy, int resId) throws Exception {
  NodeHeartbeatRequest req = Records.newRecord(NodeHeartbeatRequest.class);
  NodeStatus status = Records.newRecord(NodeStatus.class);
  status.setResponseId(resId);
  status.setNodeId(nodeId);
  for (Map.Entry<ApplicationId, List<ContainerStatus>> entry : conts.entrySet()) {
    Log.info("entry.getValue() " + entry.getValue());
    status.setContainersStatuses(entry.getValue());
  }
  NodeHealthStatus healthStatus = Records.newRecord(NodeHealthStatus.class);
  healthStatus.setHealthReport("");
  healthStatus.setIsNodeHealthy(isHealthy);
  healthStatus.setLastHealthReportTime(1);
  status.setNodeHealthStatus(healthStatus);
  req.setNodeStatus(status);
  req.setLastKnownContainerTokenMasterKey(this.currentContainerTokenMasterKey);
  req.setLastKnownNMTokenMasterKey(this.currentNMTokenMasterKey);
  NodeHeartbeatResponse heartbeatResponse =
      resourceTracker.nodeHeartbeat(req);
  
  MasterKey masterKeyFromRM = heartbeatResponse.getContainerTokenMasterKey();
  if (masterKeyFromRM != null
      && masterKeyFromRM.getKeyId() != this.currentContainerTokenMasterKey
          .getKeyId()) {
    this.currentContainerTokenMasterKey = masterKeyFromRM;
  }

  masterKeyFromRM = heartbeatResponse.getNMTokenMasterKey();
  if (masterKeyFromRM != null
      && masterKeyFromRM.getKeyId() != this.currentNMTokenMasterKey
          .getKeyId()) {
    this.currentNMTokenMasterKey = masterKeyFromRM;
  }
  
  return heartbeatResponse;
}
 

import org.apache.hadoop.yarn.server.api.protocolrecords.NodeHeartbeatRequest; //导入方法依赖的package包/类
public NodeHeartbeatResponse nodeHeartbeat(Map<ApplicationId,
    List<ContainerStatus>> conts, boolean isHealthy, int resId) throws Exception {
  NodeHeartbeatRequest req = Records.newRecord(NodeHeartbeatRequest.class);
  NodeStatus status = Records.newRecord(NodeStatus.class);
  status.setResponseId(resId);
  status.setNodeId(nodeId);
  for (Map.Entry<ApplicationId, List<ContainerStatus>> entry : conts.entrySet()) {
    status.setContainersStatuses(entry.getValue());
  }
  NodeHealthStatus healthStatus = Records.newRecord(NodeHealthStatus.class);
  healthStatus.setHealthReport("");
  healthStatus.setIsNodeHealthy(isHealthy);
  healthStatus.setLastHealthReportTime(1);
  status.setNodeHealthStatus(healthStatus);
  req.setNodeStatus(status);
  req.setLastKnownContainerTokenMasterKey(this.currentContainerTokenMasterKey);
  req.setLastKnownNMTokenMasterKey(this.currentNMTokenMasterKey);
  NodeHeartbeatResponse heartbeatResponse =
      resourceTracker.nodeHeartbeat(req);
  
  MasterKey masterKeyFromRM = heartbeatResponse.getContainerTokenMasterKey();
  if (masterKeyFromRM != null
      && masterKeyFromRM.getKeyId() != this.currentContainerTokenMasterKey
          .getKeyId()) {
    this.currentContainerTokenMasterKey = masterKeyFromRM;
  }

  masterKeyFromRM = heartbeatResponse.getNMTokenMasterKey();
  if (masterKeyFromRM != null
      && masterKeyFromRM.getKeyId() != this.currentNMTokenMasterKey
          .getKeyId()) {
    this.currentNMTokenMasterKey = masterKeyFromRM;
  }
  
  return heartbeatResponse;
}
 

import org.apache.hadoop.yarn.server.api.protocolrecords.NodeHeartbeatRequest; //导入方法依赖的package包/类
@Test
public void testRPCResponseId() throws IOException, YarnException {
  String node = "localhost";
  Resource capability = BuilderUtils.newResource(1024, 1, 1);
  RegisterNodeManagerRequest request = recordFactory.newRecordInstance(RegisterNodeManagerRequest.class);
  nodeId = NodeId.newInstance(node, 1234);
  request.setNodeId(nodeId);
  request.setHttpPort(0);
  request.setResource(capability);

  RegisterNodeManagerRequest request1 = recordFactory
      .newRecordInstance(RegisterNodeManagerRequest.class);
  request1.setNodeId(nodeId);
  request1.setHttpPort(0);
  request1.setResource(capability);
  resourceTrackerService.registerNodeManager(request1);

  org.apache.hadoop.yarn.server.api.records.NodeStatus nodeStatus = recordFactory.
    newRecordInstance(org.apache.hadoop.yarn.server.api.records.NodeStatus.class);
  nodeStatus.setNodeId(nodeId);
  NodeHealthStatus nodeHealthStatus = recordFactory.newRecordInstance(NodeHealthStatus.class);
  nodeHealthStatus.setIsNodeHealthy(true);
  nodeStatus.setNodeHealthStatus(nodeHealthStatus);
  NodeHeartbeatRequest nodeHeartBeatRequest = recordFactory
      .newRecordInstance(NodeHeartbeatRequest.class);
  nodeHeartBeatRequest.setNodeStatus(nodeStatus);

  nodeStatus.setResponseId(0);
  NodeHeartbeatResponse response = resourceTrackerService.nodeHeartbeat(
      nodeHeartBeatRequest);
  Assert.assertTrue(response.getResponseId() == 1);

  nodeStatus.setResponseId(response.getResponseId());
  response = resourceTrackerService.nodeHeartbeat(nodeHeartBeatRequest);
  Assert.assertTrue(response.getResponseId() == 2);   

  /* try calling with less response id */
  response = resourceTrackerService.nodeHeartbeat(nodeHeartBeatRequest);
  Assert.assertTrue(response.getResponseId() == 2);

  nodeStatus.setResponseId(0);
  response = resourceTrackerService.nodeHeartbeat(nodeHeartBeatRequest);
  Assert.assertTrue(NodeAction.RESYNC.equals(response.getNodeAction()));
  Assert.assertEquals("Too far behind rm response id:2 nm response id:0",
    response.getDiagnosticsMessage());
}
 

import org.apache.hadoop.yarn.server.api.protocolrecords.NodeHeartbeatRequest; //导入方法依赖的package包/类
@Override
public void middleStep() throws Exception {
  // we check the lifetime for each running containers
  ContainerSimulator cs = null;
  synchronized(completedContainerList) {
    while ((cs = containerQueue.poll()) != null) {
      runningContainers.remove(cs.getId());
      completedContainerList.add(cs.getId());
      LOG.debug(MessageFormat.format("Container {0} has completed",
              cs.getId()));
    }
  }
  
  // send heart beat
  NodeHeartbeatRequest beatRequest =
          Records.newRecord(NodeHeartbeatRequest.class);
  beatRequest.setLastKnownNMTokenMasterKey(masterKey);
  NodeStatus ns = Records.newRecord(NodeStatus.class);
  
  ns.setContainersStatuses(generateContainerStatusList());
  ns.setNodeId(node.getNodeID());
  ns.setKeepAliveApplications(new ArrayList<ApplicationId>());
  ns.setResponseId(RESPONSE_ID ++);
  ns.setNodeHealthStatus(NodeHealthStatus.newInstance(true, "", 0));
  beatRequest.setNodeStatus(ns);
  NodeHeartbeatResponse beatResponse =
      rm.getResourceTrackerService().nodeHeartbeat(beatRequest);
  if (! beatResponse.getContainersToCleanup().isEmpty()) {
    // remove from queue
    synchronized(releasedContainerList) {
      for (ContainerId containerId : beatResponse.getContainersToCleanup()){
        if (amContainerList.contains(containerId)) {
          // AM container (not killed?, only release)
          synchronized(amContainerList) {
            amContainerList.remove(containerId);
          }
          LOG.debug(MessageFormat.format("NodeManager {0} releases " +
              "an AM ({1}).", node.getNodeID(), containerId));
        } else {
          cs = runningContainers.remove(containerId);
          containerQueue.remove(cs);
          releasedContainerList.add(containerId);
          LOG.debug(MessageFormat.format("NodeManager {0} releases a " +
              "container ({1}).", node.getNodeID(), containerId));
        }
      }
    }
  }
  if (beatResponse.getNodeAction() == NodeAction.SHUTDOWN) {
    lastStep();
  }
}
 

import org.apache.hadoop.yarn.server.api.protocolrecords.NodeHeartbeatRequest; //导入方法依赖的package包/类
@Test
public void testRPCResponseId() throws IOException, YarnException {
  String node = "localhost";
  Resource capability = BuilderUtils.newResource(1024, 1);
  RegisterNodeManagerRequest request = recordFactory.newRecordInstance(RegisterNodeManagerRequest.class);
  nodeId = NodeId.newInstance(node, 1234);
  request.setNodeId(nodeId);
  request.setHttpPort(0);
  request.setResource(capability);

  RegisterNodeManagerRequest request1 = recordFactory
      .newRecordInstance(RegisterNodeManagerRequest.class);
  request1.setNodeId(nodeId);
  request1.setHttpPort(0);
  request1.setResource(capability);
  resourceTrackerService.registerNodeManager(request1);

  org.apache.hadoop.yarn.server.api.records.NodeStatus nodeStatus = recordFactory.
    newRecordInstance(org.apache.hadoop.yarn.server.api.records.NodeStatus.class);
  nodeStatus.setNodeId(nodeId);
  NodeHealthStatus nodeHealthStatus = recordFactory.newRecordInstance(NodeHealthStatus.class);
  nodeHealthStatus.setIsNodeHealthy(true);
  nodeStatus.setNodeHealthStatus(nodeHealthStatus);
  NodeHeartbeatRequest nodeHeartBeatRequest = recordFactory
      .newRecordInstance(NodeHeartbeatRequest.class);
  nodeHeartBeatRequest.setNodeStatus(nodeStatus);

  nodeStatus.setResponseId(0);
  NodeHeartbeatResponse response = resourceTrackerService.nodeHeartbeat(
      nodeHeartBeatRequest);
  Assert.assertTrue(response.getResponseId() == 1);

  nodeStatus.setResponseId(response.getResponseId());
  response = resourceTrackerService.nodeHeartbeat(nodeHeartBeatRequest);
  Assert.assertTrue(response.getResponseId() == 2);   

  /* try calling with less response id */
  response = resourceTrackerService.nodeHeartbeat(nodeHeartBeatRequest);
  Assert.assertTrue(response.getResponseId() == 2);

  nodeStatus.setResponseId(0);
  response = resourceTrackerService.nodeHeartbeat(nodeHeartBeatRequest);
  Assert.assertTrue(NodeAction.RESYNC.equals(response.getNodeAction()));
  Assert.assertEquals("Too far behind rm response id:2 nm response id:0",
    response.getDiagnosticsMessage());
}
 

import org.apache.hadoop.yarn.server.api.protocolrecords.NodeHeartbeatRequest; //导入方法依赖的package包/类
@Test
public void testNodeHeartBeatWithInvalidLabels() throws Exception {
  writeToHostsFile("host2");
  Configuration conf = new Configuration();
  conf.set(YarnConfiguration.RM_NODES_INCLUDE_FILE_PATH,
      hostFile.getAbsolutePath());
  conf.set(YarnConfiguration.NODELABEL_CONFIGURATION_TYPE,
      YarnConfiguration.DISTRIBUTED_NODELABEL_CONFIGURATION_TYPE);

  final RMNodeLabelsManager nodeLabelsMgr = new NullRMNodeLabelsManager();

  rm = new MockRM(conf) {
    @Override
    protected RMNodeLabelsManager createNodeLabelManager() {
      return nodeLabelsMgr;
    }
  };
  rm.start();

  try {
    nodeLabelsMgr.addToCluserNodeLabelsWithDefaultExclusivity(toSet("A", "B", "C"));
  } catch (IOException e) {
    Assert.fail("Caught Exception while intializing");
    e.printStackTrace();
  }

  ResourceTrackerService resourceTrackerService =
      rm.getResourceTrackerService();
  RegisterNodeManagerRequest registerReq =
      Records.newRecord(RegisterNodeManagerRequest.class);
  NodeId nodeId = NodeId.newInstance("host2", 1234);
  Resource capability = BuilderUtils.newResource(1024, 1);
  registerReq.setResource(capability);
  registerReq.setNodeId(nodeId);
  registerReq.setHttpPort(1234);
  registerReq.setNMVersion(YarnVersionInfo.getVersion());
  registerReq.setNodeLabels(toNodeLabelSet("A"));
  RegisterNodeManagerResponse registerResponse =
      resourceTrackerService.registerNodeManager(registerReq);

  NodeHeartbeatRequest heartbeatReq =
      Records.newRecord(NodeHeartbeatRequest.class);
  heartbeatReq.setNodeLabels(toNodeLabelSet("B", "#C")); // Invalid heart beat labels
  heartbeatReq.setNodeStatus(getNodeStatusObject(nodeId));
  heartbeatReq.setLastKnownNMTokenMasterKey(registerResponse
      .getNMTokenMasterKey());
  heartbeatReq.setLastKnownContainerTokenMasterKey(registerResponse
      .getContainerTokenMasterKey());
  NodeHeartbeatResponse nodeHeartbeatResponse =
      resourceTrackerService.nodeHeartbeat(heartbeatReq);

  // response should be NORMAL when RM heartbeat labels are rejected
  Assert.assertEquals("Response should be NORMAL when RM heartbeat labels"
      + " are rejected", NodeAction.NORMAL,
      nodeHeartbeatResponse.getNodeAction());
  Assert.assertFalse(nodeHeartbeatResponse.getAreNodeLabelsAcceptedByRM());
  Assert.assertNotNull(nodeHeartbeatResponse.getDiagnosticsMessage());
  rm.stop();
}
 

import org.apache.hadoop.yarn.server.api.protocolrecords.NodeHeartbeatRequest; //导入方法依赖的package包/类
@Test
public void testNodeHeartbeatWithCentralLabelConfig() throws Exception {
  writeToHostsFile("host2");
  Configuration conf = new Configuration();
  conf.set(YarnConfiguration.RM_NODES_INCLUDE_FILE_PATH,
      hostFile.getAbsolutePath());
  conf.set(YarnConfiguration.NODELABEL_CONFIGURATION_TYPE,
      YarnConfiguration.DEFAULT_NODELABEL_CONFIGURATION_TYPE);

  final RMNodeLabelsManager nodeLabelsMgr = new NullRMNodeLabelsManager();

  rm = new MockRM(conf) {
    @Override
    protected RMNodeLabelsManager createNodeLabelManager() {
      return nodeLabelsMgr;
    }
  };
  rm.start();

  ResourceTrackerService resourceTrackerService =
      rm.getResourceTrackerService();
  RegisterNodeManagerRequest req =
      Records.newRecord(RegisterNodeManagerRequest.class);
  NodeId nodeId = NodeId.newInstance("host2", 1234);
  Resource capability = BuilderUtils.newResource(1024, 1);
  req.setResource(capability);
  req.setNodeId(nodeId);
  req.setHttpPort(1234);
  req.setNMVersion(YarnVersionInfo.getVersion());
  req.setNodeLabels(toNodeLabelSet("A", "B", "C"));
  RegisterNodeManagerResponse registerResponse =
      resourceTrackerService.registerNodeManager(req);

  NodeHeartbeatRequest heartbeatReq =
      Records.newRecord(NodeHeartbeatRequest.class);
  heartbeatReq.setNodeLabels(toNodeLabelSet("B")); // Valid heart beat labels
  heartbeatReq.setNodeStatus(getNodeStatusObject(nodeId));
  heartbeatReq.setLastKnownNMTokenMasterKey(registerResponse
      .getNMTokenMasterKey());
  heartbeatReq.setLastKnownContainerTokenMasterKey(registerResponse
      .getContainerTokenMasterKey());
  NodeHeartbeatResponse nodeHeartbeatResponse =
      resourceTrackerService.nodeHeartbeat(heartbeatReq);

  // response should be ok but the RMacceptNodeLabelsUpdate should be false
  Assert.assertEquals(NodeAction.NORMAL,
      nodeHeartbeatResponse.getNodeAction());
  // no change in the labels,
  Assert.assertNull(nodeLabelsMgr.getNodeLabels().get(nodeId));
  // heartbeat labels rejected
  Assert.assertFalse("Invalid Node Labels should not accepted by RM",
      nodeHeartbeatResponse.getAreNodeLabelsAcceptedByRM());
  if (rm != null) {
    rm.stop();
  }
}
 

import org.apache.hadoop.yarn.server.api.protocolrecords.NodeHeartbeatRequest; //导入方法依赖的package包/类
public NodeHeartbeatResponse nodeHeartbeat(List<ContainerStatus> updatedStats,
    List<Container> increasedConts, boolean isHealthy, int resId)
        throws Exception {
  NodeHeartbeatRequest req = Records.newRecord(NodeHeartbeatRequest.class);
  NodeStatus status = Records.newRecord(NodeStatus.class);
  status.setResponseId(resId);
  status.setNodeId(nodeId);
  ArrayList<ContainerId> completedContainers = new ArrayList<ContainerId>();
  for (ContainerStatus stat : updatedStats) {
    if (stat.getState() == ContainerState.COMPLETE) {
      completedContainers.add(stat.getContainerId());
    }
    containerStats.put(stat.getContainerId(), stat);
  }
  status.setContainersStatuses(
      new ArrayList<ContainerStatus>(containerStats.values()));
  for (ContainerId cid : completedContainers) {
    containerStats.remove(cid);
  }
  status.setIncreasedContainers(increasedConts);
  NodeHealthStatus healthStatus = Records.newRecord(NodeHealthStatus.class);
  healthStatus.setHealthReport("");
  healthStatus.setIsNodeHealthy(isHealthy);
  healthStatus.setLastHealthReportTime(1);
  status.setNodeHealthStatus(healthStatus);
  req.setNodeStatus(status);
  req.setLastKnownContainerTokenMasterKey(this.currentContainerTokenMasterKey);
  req.setLastKnownNMTokenMasterKey(this.currentNMTokenMasterKey);
  NodeHeartbeatResponse heartbeatResponse =
      resourceTracker.nodeHeartbeat(req);
  
  MasterKey masterKeyFromRM = heartbeatResponse.getContainerTokenMasterKey();
  if (masterKeyFromRM != null
      && masterKeyFromRM.getKeyId() != this.currentContainerTokenMasterKey
          .getKeyId()) {
    this.currentContainerTokenMasterKey = masterKeyFromRM;
  }

  masterKeyFromRM = heartbeatResponse.getNMTokenMasterKey();
  if (masterKeyFromRM != null
      && masterKeyFromRM.getKeyId() != this.currentNMTokenMasterKey
          .getKeyId()) {
    this.currentNMTokenMasterKey = masterKeyFromRM;
  }

  Resource newResource = heartbeatResponse.getResource();
  if (newResource != null) {
    memory = newResource.getMemory();
    vCores = newResource.getVirtualCores();
  }

  return heartbeatResponse;
}
 

import org.apache.hadoop.yarn.server.api.protocolrecords.NodeHeartbeatRequest; //导入方法依赖的package包/类
@Test
public void testDistributedNodeHeartBeat() throws Exception {
  testDistributedNodeRegistrationSuccess();
  ResourceTrackerService resourceTrackerService = rm.getResourceTrackerService();
  NodeHeartbeatRequest request = Records.newRecord(NodeHeartbeatRequest.class);
  NodeId nodeId = NodeId.newInstance("host2", 1234);
  NodeStatus status = NodeStatus.newInstance(nodeId, 0, new ArrayList<ContainerStatus>(),
          new ArrayList<ApplicationId>(), NodeHealthStatus.newInstance(true, "healthreport", 0),null, null, null);
  request.setNodeStatus(status);
  request.setLastKnownContainerTokenMasterKey(new MasterKeyPBImpl());
  request.setLastKnownNMTokenMasterKey(new MasterKeyPBImpl());
  resourceTrackerService.nodeHeartbeat(request);
  
  request = Records.newRecord(NodeHeartbeatRequest.class);
  List<ContainerStatus> containerStatuses = new ArrayList<>();
  ContainerStatus containerStatus = ContainerStatus.newInstance(ContainerId.newContainerId(
          ApplicationAttemptId.newInstance(ApplicationId.newInstance(0, 0), 1), 1),
          ContainerState.RUNNING, "ras", 0);
  containerStatuses.add(containerStatus);
  status = NodeStatus.newInstance(nodeId, 1, containerStatuses,
          new ArrayList<ApplicationId>(), NodeHealthStatus.
                  newInstance(true, "healthreport", 0),null, null, null);
  request.setNodeStatus(status);
  request.setLastKnownContainerTokenMasterKey(new MasterKeyPBImpl());
  request.setLastKnownNMTokenMasterKey(new MasterKeyPBImpl());
  resourceTrackerService.nodeHeartbeat(request);
  Thread.sleep(100);
  
  List<PendingEvent> pendingEventsInDB = DBUtilityTests.getAllPendingEvents();
  Assert.assertEquals(3, pendingEventsInDB.size());
  for (PendingEvent pendingEvent: pendingEventsInDB){
    if(pendingEvent.getId().getEventId()==2){
      Assert.assertEquals(PendingEvent.Status.SCHEDULER_FINISHED_PROCESSING, pendingEvent.getStatus());
      Assert.assertEquals( PendingEvent.Type.NODE_UPDATED, pendingEvent.getType());
    }
    if(pendingEvent.getId().getEventId()==3){
      Assert.assertEquals(PendingEvent.Status.SCHEDULER_NOT_FINISHED_PROCESSING, pendingEvent.getStatus());
      Assert.assertEquals(PendingEvent.Type.NODE_UPDATED, pendingEvent.getType());
    }
  }
  
  Map<String, Map<Integer, List<UpdatedContainerInfo>>> uciInDB = DBUtilityTests.getAllUCIs();
  Assert.assertEquals(1, uciInDB.size());
  Map<Integer, List<UpdatedContainerInfo>> subMap = uciInDB.get(nodeId.toString());
  Assert.assertEquals(1, subMap.size());
  List<UpdatedContainerInfo> subList = subMap.get(1);
  Assert.assertEquals(1, subList.size());
  UpdatedContainerInfo uci = subList.get(0);
  Assert.assertEquals(3, uci.getPendingEventId());
  Assert.assertEquals(containerStatus.getContainerId().toString(), uci.getContainerId());
  
  Map<String, io.hops.metadata.yarn.entity.ContainerStatus> containersStatusInDB = DBUtilityTests.getAllContainerStatus();
  Assert.assertEquals(1, containersStatusInDB.size());
  io.hops.metadata.yarn.entity.ContainerStatus cs = containersStatusInDB.get(
          containerStatus.getContainerId().toString());
  Assert.assertEquals(containerStatus.getState().toString(), cs.getState());
  Assert.assertEquals(3, cs.getPendingEventId());
}