@Test(timeout=10000) public void testDispatchStopOnTimeout() throws Exception { BlockingQueue<Event> eventQueue = new LinkedBlockingQueue<Event>(); eventQueue = spy(eventQueue); // simulate dispatcher is not drained. when(eventQueue.isEmpty()).thenReturn(false); YarnConfiguration conf = new YarnConfiguration(); conf.setInt(YarnConfiguration.DISPATCHER_DRAIN_EVENTS_TIMEOUT, 2000); DrainDispatcher disp = new DrainDispatcher(eventQueue); disp.init(conf); disp.setDrainEventsOnStop(); disp.start(); disp.waitForEventThreadToWait(); disp.close(); }
public boolean unregisterHandlerForEvent(Class<? extends Enum> eventType, boolean drain) { if (drain) { await(); } EventHandler eventHandler = eventDispatchers.remove(eventType); return eventHandler != null; } }
@SuppressWarnings({ "rawtypes", "unchecked" }) @Override public EventHandler<Event> getEventHandler() { class EventArgMatcher extends ArgumentMatcher<AbstractEvent> { @Override public boolean matches(Object argument) { if (argument instanceof RMAppNodeUpdateEvent) { ApplicationId appid = ((RMAppNodeUpdateEvent) argument).getApplicationId(); applist.add(appid); } return false; } } EventHandler handler = spy(super.getEventHandler()); doNothing().when(handler).handle(argThat(new EventArgMatcher())); return handler; } };
@Override public void run() { while (!isStopped() && !Thread.currentThread().isInterrupted()) { synchronized (mutex) { // !drained if dispatch queued new events on this dispatcher drained = queue.isEmpty(); } Event event; try { event = queue.take(); } catch (InterruptedException ie) { return; } if (event != null) { dispatch(event); } } } };
conf.set(MRJobConfig.MR_AM_COMMITTER_CANCEL_TIMEOUT_MS, "1000"); DrainDispatcher dispatcher = new DrainDispatcher(); dispatcher.init(conf); dispatcher.start(); OutputCommitter committer = Mockito.mock(OutputCommitter.class); CommitterEventHandler commitHandler = dispatcher.await(); assertJobState(job, JobStateInternal.FAILED); dispatcher.stop();
conf.setInt(YarnConfiguration.RM_AM_MAX_ATTEMPTS, 1); conf.setInt(YarnConfiguration.CLIENT_NM_CONNECT_RETRY_INTERVAL_MS, 1); final DrainDispatcher dispatcher = new DrainDispatcher(); MockRM rm = new MockRMWithCustomAMLauncher(conf, null) { @Override dispatcher.await();
@Override protected AsyncDispatcher createDispatcher() { dispatcher = new DrainDispatcher(); return dispatcher; }
final DrainDispatcher dispatcher = new DrainDispatcher(); MockRM rm1 = new MockRM() { @Override dispatcher.waitForEventThreadToWait();
dispatcher = new DrainDispatcher(); rmTimelineCollectorManager = new RMTimelineCollectorManager(rm); when(rmContext.getRMTimelineCollectorManager()).thenReturn( dispatcher.init(conf); dispatcher.start();
rm.start(); DrainDispatcher privateDispatcher = new DrainDispatcher(); privateDispatcher.disableExitOnDispatchException(); SleepHandler sleepHandler = new SleepHandler(); ResourceTrackerService privateResourceTrackerService = request1.setResource(capability); privateResourceTrackerService.registerNodeManager(request1); privateDispatcher.await(); Resource clusterResource = rm.getResourceScheduler().getClusterResource(); privateDispatcher.await(); Assert.assertEquals("Cluster resources don't match", newCapability, rm.getResourceScheduler().getClusterResource());
/** * Busy loop waiting for all queued events to drain. */ public void await() { while (!isDrained()) { Thread.yield(); } }
@SuppressWarnings("rawtypes") @Override protected void dispatch(Event event) { if (event.getType() == RMFatalEventType.TRANSITION_TO_ACTIVE_FAILED) { eventreceived++; } else { super.dispatch(event); } }
dispatcher.waitForEventThreadToWait(); rm.drainEvents(); dispatcher.waitForEventThreadToWait(); rm.drainEvents();
conf.set(MRJobConfig.MR_AM_STAGING_DIR, stagingDir); conf.setInt(MRJobConfig.NUM_REDUCES, 1); DrainDispatcher dispatcher = new DrainDispatcher(); dispatcher.init(conf); final List<TaskEvent> killedEvents = Collections.synchronizedList(new ArrayList<TaskEvent>()); dispatcher.register(TaskEventType.class, new EventHandler<TaskEvent>() { @Override public void handle(TaskEvent event) { dispatcher.start(); CyclicBarrier syncBarrier = new CyclicBarrier(2); OutputCommitter committer = new TestingOutputCommitter(syncBarrier, true); dispatcher.await();
final DrainDispatcher dispatcher = new DrainDispatcher(); MockRM rm = new MockRM() { @Override am.allocate("127.0.0.1" , 1000, request, new ArrayList<ContainerId>()); dispatcher.await(); conts = am.allocate(new ArrayList<ResourceRequest>(), new ArrayList<ContainerId>()).getAllocatedContainers(); dispatcher.await(); contReceived += conts.size(); nm1.nodeHeartbeat(true); release.add(conts.get(0).getId()); am.allocate(new ArrayList<ResourceRequest>(), release); dispatcher.await();
@Override protected Dispatcher createDispatcher() { return new DrainDispatcher(); } protected ContainerAllocator createContainerAllocator(
final DrainDispatcher disp = new DrainDispatcher(); MockRM rm1 = new MockRM(conf) { @Override 1 * GB, rm1.getResourceScheduler().getRMContainer(containerId2) .getAllocatedResource().getMemorySize()); disp.waitForEventThreadToWait();
/** * Busy loop waiting for all queued events to drain. */ public void await() { while (!isDrained()) { Thread.yield(); } }
@SuppressWarnings("rawtypes") @Override protected void dispatch(Event event) { if (event.getType() == RMFatalEventType.TRANSITION_TO_ACTIVE_FAILED) { eventreceived++; } else { super.dispatch(event); } }