/** * Wait until an attempt has reached a specified state. * The timeout is 40 seconds. * @param attemptId the id of an attempt * @param finalState the attempt state waited * @throws InterruptedException * if interrupted while waiting for the state transition */ public void waitForState(ApplicationAttemptId attemptId, RMAppAttemptState finalState) throws InterruptedException { waitForState(attemptId, finalState, TIMEOUT_MS_FOR_ATTEMPT); }
public boolean waitForState(MockNM nm, ContainerId containerId, RMContainerState containerState) throws Exception { // default is wait for 30,000 ms return waitForState(nm, containerId, containerState, 30 * 1000); }
private void waitforContainerCompletion(MockRM rm, MockNM nm, ContainerId amContainerId, RMContainer container) throws Exception { ContainerId containerId = container.getContainerId(); if (null != rm.scheduler.getRMContainer(containerId)) { if (containerId.equals(amContainerId)) { rm.waitForState(nm, containerId, RMContainerState.COMPLETED); } else { rm.waitForState(nm, containerId, RMContainerState.KILLED); } } else { rm.drainEvents(); } }
public static MockAM launchAndRegisterAM(RMApp app, MockRM rm, MockNM nm, Map<Set<String>, PlacementConstraint> constraints) throws Exception { MockAM am = launchAM(app, rm, nm); for (Map.Entry<Set<String>, PlacementConstraint> e : constraints.entrySet()) { am.addPlacementConstraint(e.getKey(), e.getValue()); } am.registerAppAttempt(); rm.waitForState(app.getApplicationId(), RMAppState.RUNNING); return am; }
private void makeAMContainerExit(MockRM rm, ContainerId amContainer, MockNM node, int exitStatus) throws Exception, InterruptedException { ContainerStatus containerStatus = BuilderUtils.newContainerStatus(amContainer, ContainerState.COMPLETE, "", exitStatus, Resources.createResource(200)); node.containerStatus(containerStatus); ApplicationAttemptId amAttemptID = amContainer.getApplicationAttemptId(); rm.waitForState(amAttemptID, RMAppAttemptState.FAILED); rm.waitForState(amAttemptID.getApplicationId(), RMAppState.ACCEPTED); }
private void waitContainerAllocated(MockAM am, int mem, int nContainer, int startContainerId, MockRM rm, MockNM nm) throws Exception { for (int cId = startContainerId; cId < startContainerId + nContainer; cId++) { am.allocate("*", mem, 1, new ArrayList<ContainerId>()); ContainerId containerId = ContainerId.newContainerId(am.getApplicationAttemptId(), cId); Assert.assertTrue(rm.waitForState(nm, containerId, RMContainerState.ALLOCATED)); } }
private void waitContainerAllocated(MockAM am, int mem, int nContainer, int startContainerId, MockRM rm, MockNM nm) throws Exception { for (int cId = startContainerId; cId < startContainerId + nContainer; cId++) { am.allocate("*", mem, 1, new ArrayList<ContainerId>()); ContainerId containerId = ContainerId.newContainerId(am.getApplicationAttemptId(), cId); Assert.assertTrue(rm.waitForState(nm, containerId, RMContainerState.ALLOCATED, 10 * 1000)); } }
public static MockAM launchAndRegisterAM(RMApp app, MockRM rm, MockNM nm) throws Exception { MockAM am = launchAM(app, rm, nm); am.registerAppAttempt(); rm.waitForState(app.getApplicationId(), RMAppState.RUNNING); return am; }
public static MockAM launchAM(RMApp app, MockRM rm, MockNM nm) throws Exception { rm.waitForState(app.getApplicationId(), RMAppState.ACCEPTED); RMAppAttempt attempt = app.getCurrentAppAttempt(); System.out.println("Launch AM " + attempt.getAppAttemptId()); nm.nodeHeartbeat(true); MockAM am = rm.sendAMLaunched(attempt.getAppAttemptId()); rm.waitForState(attempt.getAppAttemptId(), RMAppAttemptState.LAUNCHED); return am; }
private void syncNodeGracefulDecommission( MockNM nm, int timeout) throws Exception { rm.sendNodeGracefulDecommission(nm, timeout); rm.waitForState(nm.getNodeId(), NodeState.DECOMMISSIONING); rm.drainEvents(); }
private void verifyKillAppSuccess(String submitter, String killer, String queueName, boolean setupACLs) throws Exception { ApplicationId applicationId = submitAppAndGetAppId(submitter, queueName, setupACLs); final KillApplicationRequest finishAppRequest = KillApplicationRequest.newInstance(applicationId); ApplicationClientProtocol ownerClient = getRMClientForUser(killer); // Kill app as killer ownerClient.forceKillApplication(finishAppRequest); resourceManager.waitForState(applicationId, RMAppState.KILLED); }
private void submitAppToRMWithValidAcl(String submitter, ApplicationSubmissionContext appSubmissionContext) throws YarnException, IOException, InterruptedException { ApplicationClientProtocol submitterClient = getRMClientForUser(submitter); SubmitApplicationRequest submitRequest = SubmitApplicationRequest .newInstance(appSubmissionContext); submitterClient.submitApplication(submitRequest); resourceManager.waitForState(appSubmissionContext.getApplicationId(), RMAppState.ACCEPTED); }
private void syncNodeLost(MockNM nm) throws Exception { rm.sendNodeStarted(nm); rm.waitForState(nm.getNodeId(), NodeState.RUNNING); rm.sendNodeLost(nm); rm.drainEvents(); }
private void verifyKillAppSuccess(String submitter, String killer, String queueName, boolean setupACLs) throws Exception { ApplicationId applicationId = submitAppAndGetAppId(submitter, queueName, setupACLs); final KillApplicationRequest finishAppRequest = KillApplicationRequest.newInstance(applicationId); ApplicationClientProtocol ownerClient = getRMClientForUser(killer); // Kill app as killer ownerClient.forceKillApplication(finishAppRequest); resourceManager.waitForState(applicationId, RMAppState.KILLED); }
protected MockAM launchAM(RMApp app, MockRM rm, MockNM nm) throws Exception { RMAppAttempt attempt = app.getCurrentAppAttempt(); nm.nodeHeartbeat(true); MockAM am = rm.sendAMLaunched(attempt.getAppAttemptId()); am.registerAppAttempt(); rm.waitForState(app.getApplicationId(), RMAppState.RUNNING); rm.waitForState(app.getCurrentAppAttempt().getAppAttemptId(), RMAppAttemptState.RUNNING); return am; }
private MockAM launchAM(RMApp app, MockRM rm, MockNM nm) throws Exception { RMAppAttempt attempt = MockRM.waitForAttemptScheduled(app, rm); nm.nodeHeartbeat(true); MockAM am = rm.sendAMLaunched(attempt.getAppAttemptId()); am.registerAppAttempt(); rm.waitForState(app.getApplicationId(), RMAppState.RUNNING); return am; }
private MockAM launchAM(RMApp app, MockRM rm, MockNM nm) throws Exception { RMAppAttempt attempt = app.getCurrentAppAttempt(); nm.nodeHeartbeat(true); MockAM am = rm.sendAMLaunched(attempt.getAppAttemptId()); am.registerAppAttempt(); rm.waitForState(app.getApplicationId(), RMAppState.RUNNING); return am; }
private MockAM launchAM(RMApp app, MockRM rm, MockNM nm) throws Exception { RMAppAttempt attempt = app.getCurrentAppAttempt(); nm.nodeHeartbeat(true); MockAM am = rm.sendAMLaunched(attempt.getAppAttemptId()); am.registerAppAttempt(); rm.waitForState(app.getApplicationId(), RMAppState.RUNNING); return am; }
public static void finishAMAndVerifyAppState(RMApp rmApp, MockRM rm, MockNM nm, MockAM am) throws Exception { FinishApplicationMasterRequest req = FinishApplicationMasterRequest.newInstance( FinalApplicationStatus.SUCCEEDED, "", ""); am.unregisterAppAttempt(req,true); am.waitForState(RMAppAttemptState.FINISHING); nm.nodeHeartbeat(am.getApplicationAttemptId(), 1, ContainerState.COMPLETE); am.waitForState(RMAppAttemptState.FINISHED); rm.waitForState(rmApp.getApplicationId(), RMAppState.FINISHED); }
public void sendAMLaunchFailed(ApplicationAttemptId appAttemptId) throws Exception { MockAM am = new MockAM(getRMContext(), masterService, appAttemptId); waitForState(am.getApplicationAttemptId(), RMAppAttemptState.ALLOCATED); getRMContext().getDispatcher().getEventHandler() .handle(new RMAppAttemptEvent(appAttemptId, RMAppAttemptEventType.LAUNCH_FAILED, "Failed")); drainEventsImplicitly(); }