public MockNM unRegisterNode(MockNM nm) throws Exception { nm.unRegisterNode(); drainEventsImplicitly(); return nm; }
public void updateReservationState(ReservationUpdateRequest request) throws IOException, YarnException { ApplicationClientProtocol client = getClientRMService(); client.updateReservation(request); drainEventsImplicitly(); }
public MockNM registerNode(String nodeIdStr, int memory) throws Exception { MockNM nm = new MockNM(nodeIdStr, memory, getResourceTrackerService()); nm.registerNode(); drainEventsImplicitly(); return nm; }
public FailApplicationAttemptResponse failApplicationAttempt( ApplicationAttemptId attemptId) throws Exception { ApplicationClientProtocol client = getClientRMService(); FailApplicationAttemptRequest req = FailApplicationAttemptRequest.newInstance(attemptId); FailApplicationAttemptResponse response = client.failApplicationAttempt(req); drainEventsImplicitly(); return response; }
public void signalToContainer(ContainerId containerId, SignalContainerCommand command) throws Exception { ApplicationClientProtocol client = getClientRMService(); SignalContainerRequest req = SignalContainerRequest.newInstance(containerId, command); client.signalToContainer(req); drainEventsImplicitly(); }
public MockNM registerNode(String nodeIdStr, int memory, int vCores) throws Exception { MockNM nm = new MockNM(nodeIdStr, memory, vCores, getResourceTrackerService()); nm.registerNode(); drainEventsImplicitly(); return nm; }
public KillApplicationResponse killApp(ApplicationId appId) throws Exception { ApplicationClientProtocol client = getClientRMService(); KillApplicationRequest req = KillApplicationRequest.newInstance(appId); KillApplicationResponse response = client.forceKillApplication(req); drainEventsImplicitly(); return response; }
public MockNM registerNode(String nodeIdStr, Resource nodeCapability) throws Exception { MockNM nm = new MockNM(nodeIdStr, nodeCapability, getResourceTrackerService()); nm.registerNode(); drainEventsImplicitly(); return nm; }
public void waitForContainerToComplete(RMAppAttempt attempt, NMContainerStatus completedContainer) throws InterruptedException { drainEventsImplicitly(); int timeWaiting = 0; while (timeWaiting < TIMEOUT_MS_FOR_CONTAINER_AND_NODE) { List<ContainerStatus> containers = attempt.getJustFinishedContainers(); LOG.info("Received completed containers " + containers); for (ContainerStatus container : containers) { if (container.getContainerId().equals( completedContainer.getContainerId())) { return; } } Thread.sleep(WAIT_MS_PER_LOOP); timeWaiting += WAIT_MS_PER_LOOP; } }
private void waitForState(ApplicationId appId, EnumSet<RMAppState> finalStates) throws InterruptedException { drainEventsImplicitly(); RMApp app = getRMContext().getRMApps().get(appId); Assert.assertNotNull("app shouldn't be null", app); final int timeoutMsecs = 80 * SECOND; int timeWaiting = 0; while (!finalStates.contains(app.getState())) { if (timeWaiting >= timeoutMsecs) { break; } LOG.info("App : " + appId + " State is : " + app.getState() + " Waiting for state : " + finalStates); Thread.sleep(WAIT_MS_PER_LOOP); timeWaiting += WAIT_MS_PER_LOOP; } LOG.info("App State is : " + app.getState()); Assert.assertTrue("App State is not correct (timeout).", finalStates.contains(app.getState())); }
public MockNM registerNode(String nodeIdStr, int memory, int vCores, List<ApplicationId> runningApplications) throws Exception { MockNM nm = new MockNM(nodeIdStr, memory, vCores, getResourceTrackerService(), YarnVersionInfo.getVersion()); nm.registerNode(runningApplications); drainEventsImplicitly(); return nm; }
@SuppressWarnings("rawtypes") private static void waitForSchedulerAppAttemptAdded( ApplicationAttemptId attemptId, MockRM rm) throws InterruptedException { int tick = 0; rm.drainEventsImplicitly(); // Wait for at most 5 sec while (null == ((AbstractYarnScheduler) rm.getResourceScheduler()) .getApplicationAttempt(attemptId) && tick < 50) { Thread.sleep(100); if (tick % 10 == 0) { LOG.info("waiting for SchedulerApplicationAttempt=" + attemptId + " added."); } tick++; } Assert.assertNotNull("Timed out waiting for SchedulerApplicationAttempt=" + attemptId + " to be added.", ((AbstractYarnScheduler) rm.getResourceScheduler()).getApplicationAttempt(attemptId)); }
public void sendNodeStarted(MockNM nm) throws Exception { RMNodeImpl node = (RMNodeImpl) getRMContext().getRMNodes().get( nm.getNodeId()); node.handle(new RMNodeStartedEvent(nm.getNodeId(), null, null)); drainEventsImplicitly(); }
public void sendNodeLost(MockNM nm) throws Exception { RMNodeImpl node = (RMNodeImpl) getRMContext().getRMNodes().get( nm.getNodeId()); node.handle(new RMNodeEvent(nm.getNodeId(), RMNodeEventType.EXPIRE)); drainEventsImplicitly(); }
/** * NOTE: nm.nodeHeartbeat is explicitly invoked, * don't invoke it before calling launchAM */ public static MockAM launchAM(RMApp app, MockRM rm, MockNM nm) throws Exception { rm.drainEventsImplicitly(); RMAppAttempt attempt = waitForAttemptScheduled(app, rm); LOG.info("Launch AM " + attempt.getAppAttemptId()); nm.nodeHeartbeat(true); ((AbstractYarnScheduler)rm.getResourceScheduler()).update(); rm.drainEventsImplicitly(); nm.nodeHeartbeat(true); MockAM am = rm.sendAMLaunched(attempt.getAppAttemptId()); rm.waitForState(attempt.getAppAttemptId(), RMAppAttemptState.LAUNCHED); return am; }
/** * Wait until an attempt has reached a specified state. * The timeout can be specified by the parameter. * @param attemptId the id of an attempt * @param finalState the attempt state waited * @param timeoutMsecs the length of timeout in milliseconds * @throws InterruptedException * if interrupted while waiting for the state transition */ public void waitForState(ApplicationAttemptId attemptId, RMAppAttemptState finalState, int timeoutMsecs) throws InterruptedException { drainEventsImplicitly(); RMApp app = getRMContext().getRMApps().get(attemptId.getApplicationId()); Assert.assertNotNull("app shouldn't be null", app); RMAppAttempt attempt = app.getRMAppAttempt(attemptId); MockRM.waitForState(attempt, finalState, timeoutMsecs); }
public static MockAM launchUAM(RMApp app, MockRM rm, MockNM nm) throws Exception { rm.drainEventsImplicitly(); // UAMs go directly to LAUNCHED state rm.waitForState(app.getApplicationId(), RMAppState.ACCEPTED); RMAppAttempt attempt = app.getCurrentAppAttempt(); waitForSchedulerAppAttemptAdded(attempt.getAppAttemptId(), rm); LOG.info("Launch AM " + attempt.getAppAttemptId()); nm.nodeHeartbeat(true); ((AbstractYarnScheduler)rm.getResourceScheduler()).update(); rm.drainEventsImplicitly(); nm.nodeHeartbeat(true); MockAM am = new MockAM(rm.getRMContext(), rm.masterService, attempt.getAppAttemptId()); rm.waitForState(attempt.getAppAttemptId(), RMAppAttemptState.LAUNCHED); return am; }
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(); }
public static void finishAMAndVerifyAppState(RMApp rmApp, MockRM rm, MockNM nm, MockAM am) throws Exception { FinishApplicationMasterRequest req = FinishApplicationMasterRequest.newInstance( FinalApplicationStatus.SUCCEEDED, "", ""); am.unregisterAppAttempt(req,true); rm.waitForState(am.getApplicationAttemptId(), RMAppAttemptState.FINISHING); nm.nodeHeartbeat(am.getApplicationAttemptId(), 1, ContainerState.COMPLETE); rm.drainEventsImplicitly(); rm.waitForState(am.getApplicationAttemptId(), RMAppAttemptState.FINISHED); rm.waitForState(rmApp.getApplicationId(), RMAppState.FINISHED); }
/** * recommend to use launchAM, or use sendAMLaunched like: * 1, wait RMAppAttempt scheduled * 2, send node heartbeat * 3, sendAMLaunched */ public MockAM sendAMLaunched(ApplicationAttemptId appAttemptId) throws Exception { MockAM am = new MockAM(getRMContext(), masterService, appAttemptId); ((AbstractYarnScheduler)scheduler).update(); waitForState(appAttemptId, RMAppAttemptState.ALLOCATED); //create and set AMRMToken Token<AMRMTokenIdentifier> amrmToken = this.rmContext.getAMRMTokenSecretManager().createAndGetAMRMToken( appAttemptId); ((RMAppAttemptImpl) this.rmContext.getRMApps() .get(appAttemptId.getApplicationId()).getRMAppAttempt(appAttemptId)) .setAMRMToken(amrmToken); getRMContext() .getDispatcher() .getEventHandler() .handle( new RMAppAttemptEvent(appAttemptId, RMAppAttemptEventType.LAUNCHED)); drainEventsImplicitly(); return am; }