/** * Creates a procedure. (FOR TESTING) * * {@link Procedure} state to be run by a {@link ProcedureCoordinator}. * @param coord coordinator to call back to for general errors (e.g. * {@link ProcedureCoordinator#rpcConnectionFailure(String, IOException)}). * @param monitor error monitor to check for external errors * @param wakeFreq frequency to check for errors while waiting * @param timeout amount of time to allow the procedure to run before cancelling * @param procName name of the procedure instance * @param args argument data associated with the procedure instance * @param expectedMembers names of the expected members */ public Procedure(ProcedureCoordinator coord, ForeignExceptionDispatcher monitor, long wakeFreq, long timeout, String procName, byte[] args, List<String> expectedMembers) { this.coord = coord; this.acquiringMembers = new ArrayList<>(expectedMembers); this.inBarrierMembers = new ArrayList<>(acquiringMembers.size()); this.dataFromFinishedMembers = new HashMap<>(); this.procName = procName; this.args = args; this.monitor = monitor; this.wakeFrequency = wakeFreq; int count = expectedMembers.size(); this.acquiredBarrierLatch = new CountDownLatch(count); this.releasedBarrierLatch = new CountDownLatch(count); this.completedLatch = new CountDownLatch(1); this.timeoutInjector = new TimeoutExceptionInjector(monitor, timeout); }
this.executionTimeoutTimer = new TimeoutExceptionInjector(monitor, timeout);
/** * Test that a manually triggered timer fires an exception. */ @Test public void testTimerTrigger() { final long time = 10000000; // pick a value that is very far in the future ForeignExceptionListener listener = Mockito.mock(ForeignExceptionListener.class); TimeoutExceptionInjector timer = new TimeoutExceptionInjector(listener, time); timer.start(); timer.trigger(); Mockito.verify(listener, Mockito.times(1)).receive(Mockito.any()); }
/** * Test that a manually triggered exception with data fires with the data in receiveError. */ @Test public void testTimerPassesOnErrorInfo() { final long time = 1000000; ForeignExceptionListener listener = Mockito.mock(ForeignExceptionListener.class); TimeoutExceptionInjector timer = new TimeoutExceptionInjector(listener, time); timer.start(); timer.trigger(); Mockito.verify(listener).receive(Mockito.any()); }
/** * Demonstrate TimeoutExceptionInjector semantics -- completion means no more exceptions passed to * error listener. */ @Test public void testStartAfterComplete() throws InterruptedException { final long time = 10; ForeignExceptionListener listener = Mockito.mock(ForeignExceptionListener.class); TimeoutExceptionInjector timer = new TimeoutExceptionInjector(listener, time); timer.complete(); try { timer.start(); fail("Timer should fail to start after complete."); } catch (IllegalStateException e) { LOG.debug("Correctly failed timer: " + e.getMessage()); } Thread.sleep(time + 1); Mockito.verifyZeroInteractions(listener); }
/** * Demonstrate TimeoutExceptionInjector semantics -- triggering fires exception and completes * the timer. */ @Test public void testStartAfterTrigger() throws InterruptedException { final long time = 10; ForeignExceptionListener listener = Mockito.mock(ForeignExceptionListener.class); TimeoutExceptionInjector timer = new TimeoutExceptionInjector(listener, time); timer.trigger(); try { timer.start(); fail("Timer should fail to start after complete."); } catch (IllegalStateException e) { LOG.debug("Correctly failed timer: " + e.getMessage()); } Thread.sleep(time * 2); Mockito.verify(listener, Mockito.times(1)).receive(Mockito.any()); Mockito.verifyNoMoreInteractions(listener); } }
/** * Test that the dispatcher can receive an error via the timer mechanism. */ @Test public void testAttemptTimer() { ForeignExceptionListener listener1 = Mockito.mock(ForeignExceptionListener.class); ForeignExceptionListener listener2 = Mockito.mock(ForeignExceptionListener.class); ForeignExceptionDispatcher orchestrator = new ForeignExceptionDispatcher(); // add the listeners orchestrator.addListener(listener1); orchestrator.addListener(listener2); // now create a timer and check for that error TimeoutExceptionInjector timer = new TimeoutExceptionInjector(orchestrator, 1000); timer.start(); timer.trigger(); // make sure that we got the timer error Mockito.verify(listener1, Mockito.times(1)).receive(Mockito.any()); Mockito.verify(listener2, Mockito.times(1)).receive(Mockito.any()); } }
@Test public void testSingleDispatcherWithTimer() { ForeignExceptionListener listener1 = Mockito.mock(ForeignExceptionListener.class); ForeignExceptionListener listener2 = Mockito.mock(ForeignExceptionListener.class); ForeignExceptionDispatcher monitor = new ForeignExceptionDispatcher(); // add the listeners monitor.addListener(listener1); monitor.addListener(listener2); TimeoutExceptionInjector timer = new TimeoutExceptionInjector(monitor, 1000); timer.start(); timer.trigger(); assertTrue("Monitor didn't get timeout", monitor.hasException()); // verify that that we propagated the error Mockito.verify(listener1).receive(Mockito.any()); Mockito.verify(listener2).receive(Mockito.any()); }
/** * Creates a procedure. (FOR TESTING) * * {@link Procedure} state to be run by a {@link ProcedureCoordinator}. * @param coord coordinator to call back to for general errors (e.g. * {@link ProcedureCoordinator#rpcConnectionFailure(String, IOException)}). * @param monitor error monitor to check for external errors * @param wakeFreq frequency to check for errors while waiting * @param timeout amount of time to allow the procedure to run before cancelling * @param procName name of the procedure instance * @param args argument data associated with the procedure instance * @param expectedMembers names of the expected members */ public Procedure(ProcedureCoordinator coord, ForeignExceptionDispatcher monitor, long wakeFreq, long timeout, String procName, byte[] args, List<String> expectedMembers) { this.coord = coord; this.acquiringMembers = new ArrayList<String>(expectedMembers); this.inBarrierMembers = new ArrayList<String>(acquiringMembers.size()); this.procName = procName; this.args = args; this.monitor = monitor; this.wakeFrequency = wakeFreq; int count = expectedMembers.size(); this.acquiredBarrierLatch = new CountDownLatch(count); this.releasedBarrierLatch = new CountDownLatch(count); this.completedLatch = new CountDownLatch(1); this.timeoutInjector = new TimeoutExceptionInjector(monitor, timeout); }
/** * Creates a procedure. (FOR TESTING) * * {@link Procedure} state to be run by a {@link ProcedureCoordinator}. * @param coord coordinator to call back to for general errors (e.g. * {@link ProcedureCoordinator#rpcConnectionFailure(String, IOException)}). * @param monitor error monitor to check for external errors * @param wakeFreq frequency to check for errors while waiting * @param timeout amount of time to allow the procedure to run before cancelling * @param procName name of the procedure instance * @param args argument data associated with the procedure instance * @param expectedMembers names of the expected members */ public Procedure(ProcedureCoordinator coord, ForeignExceptionDispatcher monitor, long wakeFreq, long timeout, String procName, byte[] args, List<String> expectedMembers) { this.coord = coord; this.acquiringMembers = new ArrayList<String>(expectedMembers); this.inBarrierMembers = new ArrayList<String>(acquiringMembers.size()); this.dataFromFinishedMembers = new HashMap<String, byte[]>(); this.procName = procName; this.args = args; this.monitor = monitor; this.wakeFrequency = wakeFreq; int count = expectedMembers.size(); this.acquiredBarrierLatch = new CountDownLatch(count); this.releasedBarrierLatch = new CountDownLatch(count); this.completedLatch = new CountDownLatch(1); this.timeoutInjector = new TimeoutExceptionInjector(monitor, timeout); }
/** * Create a snapshot timer for the master which notifies the monitor when an error occurs * @param snapshot snapshot to monitor * @param conf configuration to use when getting the max snapshot life * @param monitor monitor to notify when the snapshot life expires * @return the timer to use update to signal the start and end of the snapshot */ public static TimeoutExceptionInjector getMasterTimerAndBindToMonitor(SnapshotDescription snapshot, Configuration conf, ForeignExceptionListener monitor) { long maxTime = SnapshotDescriptionUtils.getMaxMasterTimeout(conf, snapshot.getType(), SnapshotDescriptionUtils.DEFAULT_MAX_WAIT_TIME); return new TimeoutExceptionInjector(monitor, maxTime); }
this.executionTimeoutTimer = new TimeoutExceptionInjector(monitor, timeout);
this.executionTimeoutTimer = new TimeoutExceptionInjector(monitor, timeout);
/** * Test that a manually triggered timer fires an exception. */ @Test public void testTimerTrigger() { final long time = 10000000; // pick a value that is very far in the future ForeignExceptionListener listener = Mockito.mock(ForeignExceptionListener.class); TimeoutExceptionInjector timer = new TimeoutExceptionInjector(listener, time); timer.start(); timer.trigger(); Mockito.verify(listener, Mockito.times(1)).receive(Mockito.any()); }
/** * Test that a manually triggered exception with data fires with the data in receiveError. */ @Test public void testTimerPassesOnErrorInfo() { final long time = 1000000; ForeignExceptionListener listener = Mockito.mock(ForeignExceptionListener.class); TimeoutExceptionInjector timer = new TimeoutExceptionInjector(listener, time); timer.start(); timer.trigger(); Mockito.verify(listener).receive(Mockito.any()); }
/** * Demonstrate TimeoutExceptionInjector semantics -- triggering fires exception and completes * the timer. */ @Test public void testStartAfterTrigger() throws InterruptedException { final long time = 10; ForeignExceptionListener listener = Mockito.mock(ForeignExceptionListener.class); TimeoutExceptionInjector timer = new TimeoutExceptionInjector(listener, time); timer.trigger(); try { timer.start(); fail("Timer should fail to start after complete."); } catch (IllegalStateException e) { LOG.debug("Correctly failed timer: " + e.getMessage()); } Thread.sleep(time * 2); Mockito.verify(listener, Mockito.times(1)).receive(Mockito.any()); Mockito.verifyNoMoreInteractions(listener); } }
/** * Demonstrate TimeoutExceptionInjector semantics -- completion means no more exceptions passed to * error listener. */ @Test public void testStartAfterComplete() throws InterruptedException { final long time = 10; ForeignExceptionListener listener = Mockito.mock(ForeignExceptionListener.class); TimeoutExceptionInjector timer = new TimeoutExceptionInjector(listener, time); timer.complete(); try { timer.start(); fail("Timer should fail to start after complete."); } catch (IllegalStateException e) { LOG.debug("Correctly failed timer: " + e.getMessage()); } Thread.sleep(time + 1); Mockito.verifyZeroInteractions(listener); }
/** * Test that the dispatcher can receive an error via the timer mechanism. */ @Test public void testAttemptTimer() { ForeignExceptionListener listener1 = Mockito.mock(ForeignExceptionListener.class); ForeignExceptionListener listener2 = Mockito.mock(ForeignExceptionListener.class); ForeignExceptionDispatcher orchestrator = new ForeignExceptionDispatcher(); // add the listeners orchestrator.addListener(listener1); orchestrator.addListener(listener2); // now create a timer and check for that error TimeoutExceptionInjector timer = new TimeoutExceptionInjector(orchestrator, 1000); timer.start(); timer.trigger(); // make sure that we got the timer error Mockito.verify(listener1, Mockito.times(1)).receive(Mockito.any()); Mockito.verify(listener2, Mockito.times(1)).receive(Mockito.any()); } }
@Test public void testSingleDispatcherWithTimer() { ForeignExceptionListener listener1 = Mockito.mock(ForeignExceptionListener.class); ForeignExceptionListener listener2 = Mockito.mock(ForeignExceptionListener.class); ForeignExceptionDispatcher monitor = new ForeignExceptionDispatcher(); // add the listeners monitor.addListener(listener1); monitor.addListener(listener2); TimeoutExceptionInjector timer = new TimeoutExceptionInjector(monitor, 1000); timer.start(); timer.trigger(); assertTrue("Monitor didn't get timeout", monitor.hasException()); // verify that that we propagated the error Mockito.verify(listener1).receive(Mockito.any()); Mockito.verify(listener2).receive(Mockito.any()); }