How to use

ForeignExceptionListener

in

org.apache.hadoop.hbase.errorhandling

/**
 * Sends an exception to all listeners.
 * @param message human readable message passed to the listener
 * @param e {@link ForeignException} containing the cause.  Can be null.
 */
private void dispatch(ForeignException e) {
 // update all the listeners with the passed error
 for (ForeignExceptionListener l: listeners) {
  l.receive(e);
 }
}

 @Override
 public void run() {
  // ensure we don't run this task multiple times
  synchronized (this) {
   // quick exit if we already marked the task complete
   if (TimeoutExceptionInjector.this.complete) return;
   // mark the task is run, to avoid repeats
   TimeoutExceptionInjector.this.complete = true;
  }
  long end = EnvironmentEdgeManager.currentTime();
  TimeoutException tee =  new TimeoutException(
    "Timeout caused Foreign Exception", start, end, maxTime);
  String source = "timer-" + timer;
  listener.receive(new ForeignException(source, tee));
 }
};

/**
 * 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());
}

 /**
  * 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());
 }
}

 /**
  * 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
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());
}

/**
 * Tests that a dispatcher only dispatches only the first exception, and does not propagate
 * subsequent exceptions.
 */
@Test
public void testErrorPropagation() {
 ForeignExceptionListener listener1 = Mockito.mock(ForeignExceptionListener.class);
 ForeignExceptionListener listener2 = Mockito.mock(ForeignExceptionListener.class);
 ForeignExceptionDispatcher dispatcher = new ForeignExceptionDispatcher();
 // add the listeners
 dispatcher.addListener(listener1);
 dispatcher.addListener(listener2);
 // create an artificial error
 dispatcher.receive(EXTEXN);
 // make sure the listeners got the error
 Mockito.verify(listener1, Mockito.times(1)).receive(EXTEXN);
 Mockito.verify(listener2, Mockito.times(1)).receive(EXTEXN);
 // make sure that we get an exception
 try {
  dispatcher.rethrowException();
  fail("Monitor should have thrown an exception after getting error.");
 } catch (ForeignException ex) {
  assertTrue("Got an unexpected exception:" + ex, ex.getCause() == EXTEXN.getCause());
  LOG.debug("Got the testing exception!");
 }
 // push another error, which should be not be passed to listeners
 dispatcher.receive(EXTEXN2);
 Mockito.verify(listener1, Mockito.never()).receive(EXTEXN2);
 Mockito.verify(listener2, Mockito.never()).receive(EXTEXN2);
}

/**
 * Sends an exception to all listeners.
 * @param message human readable message passed to the listener
 * @param e {@link ForeignException} containing the cause.  Can be null.
 */
private void dispatch(ForeignException e) {
 // update all the listeners with the passed error
 for (ForeignExceptionListener l: listeners) {
  l.receive(e);
 }
}

/**
 * Sends an exception to all listeners.
 * @param message human readable message passed to the listener
 * @param e {@link ForeignException} containing the cause.  Can be null.
 */
private void dispatch(ForeignException e) {
 // update all the listeners with the passed error
 for (ForeignExceptionListener l: listeners) {
  l.receive(e);
 }
}

 @Override
 public void run() {
  // ensure we don't run this task multiple times
  synchronized (this) {
   // quick exit if we already marked the task complete
   if (TimeoutExceptionInjector.this.complete) return;
   // mark the task is run, to avoid repeats
   TimeoutExceptionInjector.this.complete = true;
  }
  long end = EnvironmentEdgeManager.currentTimeMillis();
  TimeoutException tee =  new TimeoutException(
    "Timeout caused Foreign Exception", start, end, maxTime);
  String source = "timer-" + timer;
  listener.receive(new ForeignException(source, tee));
 }
};

 @Override
 public void run() {
  // ensure we don't run this task multiple times
  synchronized (this) {
   // quick exit if we already marked the task complete
   if (TimeoutExceptionInjector.this.complete) return;
   // mark the task is run, to avoid repeats
   TimeoutExceptionInjector.this.complete = true;
  }
  long end = EnvironmentEdgeManager.currentTime();
  TimeoutException tee =  new TimeoutException(
    "Timeout caused Foreign Exception", start, end, maxTime);
  String source = "timer-" + timer;
  listener.receive(new ForeignException(source, tee));
 }
};

/**
 * 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());
}

 /**
  * 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());
 }
}

 /**
  * 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);
 }
}

/**
 * Tests that a dispatcher only dispatches only the first exception, and does not propagate
 * subsequent exceptions.
 */
@Test
public void testErrorPropagation() {
 ForeignExceptionListener listener1 = Mockito.mock(ForeignExceptionListener.class);
 ForeignExceptionListener listener2 = Mockito.mock(ForeignExceptionListener.class);
 ForeignExceptionDispatcher dispatcher = new ForeignExceptionDispatcher();
 // add the listeners
 dispatcher.addListener(listener1);
 dispatcher.addListener(listener2);
 // create an artificial error
 dispatcher.receive(EXTEXN);
 // make sure the listeners got the error
 Mockito.verify(listener1, Mockito.times(1)).receive(EXTEXN);
 Mockito.verify(listener2, Mockito.times(1)).receive(EXTEXN);
 // make sure that we get an exception
 try {
  dispatcher.rethrowException();
  fail("Monitor should have thrown an exception after getting error.");
 } catch (ForeignException ex) {
  assertTrue("Got an unexpected exception:" + ex, ex.getCause() == EXTEXN.getCause());
  LOG.debug("Got the testing exception!");
 }
 // push another error, which should be not be passed to listeners
 dispatcher.receive(EXTEXN2);
 Mockito.verify(listener1, Mockito.never()).receive(EXTEXN2);
 Mockito.verify(listener2, Mockito.never()).receive(EXTEXN2);
}

@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());
}