Examples with HystrixRuntimeException com.netflix.hystrix.exception.HystrixRuntimeException used on opensource projects

Example 11 with HystrixRuntimeException

use of com.netflix.hystrix.exception.HystrixRuntimeException in project Hystrix by Netflix.

the class HystrixObservableCommandTest method testErrorThrownViaObserve.

/**
     * Test a java.lang.Error being thrown
     *
     * @throws InterruptedException
     */
@Test
public void testErrorThrownViaObserve() throws InterruptedException {
    TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
    CommandWithErrorThrown command = new CommandWithErrorThrown(circuitBreaker, true);
    final AtomicReference<Throwable> t = new AtomicReference<Throwable>();
    final CountDownLatch latch = new CountDownLatch(1);
    try {
        command.observe().subscribe(new Observer<Boolean>() {

            @Override
            public void onCompleted() {
                latch.countDown();
            }

            @Override
            public void onError(Throwable e) {
                t.set(e);
                latch.countDown();
            }

            @Override
            public void onNext(Boolean args) {
            }
        });
    } catch (Exception e) {
        e.printStackTrace();
        fail("we should not get anything thrown, it should be emitted via the Observer#onError method");
    }
    latch.await(1, TimeUnit.SECONDS);
    assertNotNull(t.get());
    t.get().printStackTrace();
    assertTrue(t.get() instanceof HystrixRuntimeException);
    // the actual error is an extra cause level deep because Hystrix needs to wrap Throwable/Error as it's public
    // methods only support Exception and it's not a strong enough reason to break backwards compatibility and jump to version 2.x
    assertEquals("simulated java.lang.Error message", t.get().getCause().getCause().getMessage());
    assertEquals("simulated java.lang.Error message", command.getFailedExecutionException().getCause().getMessage());
    assertTrue(command.getExecutionTimeInMilliseconds() > -1);
    assertTrue(command.isFailedExecution());
    assertCommandExecutionEvents(command, HystrixEventType.FAILURE, HystrixEventType.FALLBACK_MISSING);
    assertNotNull(command.getExecutionException());
    assertEquals(0, circuitBreaker.metrics.getCurrentConcurrentExecutionCount());
    assertFalse(command.isExecutedInThread());
    assertSaneHystrixRequestLog(1);
}

Example 12 with HystrixRuntimeException

use of com.netflix.hystrix.exception.HystrixRuntimeException in project Hystrix by Netflix.

the class HystrixObservableCommandTest method testObservableTimeoutNoFallbackThreadContext.

/**
     * See https://github.com/Netflix/Hystrix/issues/212
     */
@Test
public void testObservableTimeoutNoFallbackThreadContext() {
    TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
    final AtomicReference<Thread> onErrorThread = new AtomicReference<Thread>();
    final AtomicBoolean isRequestContextInitialized = new AtomicBoolean();
    TestHystrixObservableCommand<Integer> command = getCommand(ExecutionIsolationStrategy.SEMAPHORE, AbstractTestHystrixCommand.ExecutionResult.SUCCESS, 200, AbstractTestHystrixCommand.FallbackResult.UNIMPLEMENTED, 100);
    command.toObservable().doOnError(new Action1<Throwable>() {

        @Override
        public void call(Throwable t1) {
            System.out.println("onError: " + t1);
            System.out.println("onError Thread: " + Thread.currentThread());
            System.out.println("ThreadContext in onError: " + HystrixRequestContext.isCurrentThreadInitialized());
            onErrorThread.set(Thread.currentThread());
            isRequestContextInitialized.set(HystrixRequestContext.isCurrentThreadInitialized());
        }
    }).subscribe(ts);
    ts.awaitTerminalEvent();
    assertTrue(isRequestContextInitialized.get());
    assertTrue(onErrorThread.get().getName().startsWith("HystrixTimer"));
    List<Throwable> errors = ts.getOnErrorEvents();
    assertEquals(1, errors.size());
    Throwable e = errors.get(0);
    if (errors.get(0) instanceof HystrixRuntimeException) {
        HystrixRuntimeException de = (HystrixRuntimeException) e;
        assertNotNull(de.getFallbackException());
        assertTrue(de.getFallbackException() instanceof UnsupportedOperationException);
        assertNotNull(de.getImplementingClass());
        assertNotNull(de.getCause());
        assertTrue(de.getCause() instanceof TimeoutException);
    } else {
        fail("the exception should be ExecutionException with cause as HystrixRuntimeException");
    }
    assertTrue(command.getExecutionTimeInMilliseconds() > -1);
    assertTrue(command.isResponseTimedOut());
    assertNotNull(command.getExecutionException());
    assertCommandExecutionEvents(command, HystrixEventType.TIMEOUT, HystrixEventType.FALLBACK_MISSING);
    assertEquals(0, command.metrics.getCurrentConcurrentExecutionCount());
    assertSaneHystrixRequestLog(1);
    assertFalse(command.isExecutedInThread());
}

Example 13 with HystrixRuntimeException

use of com.netflix.hystrix.exception.HystrixRuntimeException in project Hystrix by Netflix.

the class HystrixCommandTest method testRejectedThreadUsingQueueSize.

/**
     * Test that we can reject a thread using isQueueSpaceAvailable() instead of just when the pool rejects.
     * <p>
     * For example, we have queue size set to 100 but want to reject when we hit 10.
     * <p>
     * This allows us to use FastProperties to control our rejection point whereas we can't resize a queue after it's created.
     */
@Test
public void testRejectedThreadUsingQueueSize() {
    HystrixCommandKey key = HystrixCommandKey.Factory.asKey("Rejection-B");
    TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
    SingleThreadedPoolWithQueue pool = new SingleThreadedPoolWithQueue(10, 1);
    // put 1 item in the queue
    // the thread pool won't pick it up because we're bypassing the pool and adding to the queue directly so this will keep the queue full
    pool.queue.add(new Runnable() {

        @Override
        public void run() {
            System.out.println("**** queue filler1 ****");
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    });
    TestCommandRejection command = new TestCommandRejection(key, circuitBreaker, pool, 500, 600, TestCommandRejection.FALLBACK_NOT_IMPLEMENTED);
    try {
        // this should fail as we already have 1 in the queue
        command.queue();
        fail("we shouldn't get here");
    } catch (Exception e) {
        e.printStackTrace();
        assertTrue(command.isResponseRejected());
        assertFalse(command.isResponseShortCircuited());
        assertFalse(command.isResponseTimedOut());
        assertNotNull(command.getExecutionException());
        if (e instanceof HystrixRuntimeException && e.getCause() instanceof RejectedExecutionException) {
            HystrixRuntimeException de = (HystrixRuntimeException) e;
            assertNotNull(de.getFallbackException());
            assertTrue(de.getFallbackException() instanceof UnsupportedOperationException);
            assertNotNull(de.getImplementingClass());
            assertNotNull(de.getCause());
            assertTrue(de.getCause() instanceof RejectedExecutionException);
        } else {
            fail("the exception should be HystrixRuntimeException with cause as RejectedExecutionException");
        }
    }
    assertCommandExecutionEvents(command, HystrixEventType.THREAD_POOL_REJECTED, HystrixEventType.FALLBACK_MISSING);
    assertEquals(0, circuitBreaker.metrics.getCurrentConcurrentExecutionCount());
    assertSaneHystrixRequestLog(1);
}

Example 14 with HystrixRuntimeException

use of com.netflix.hystrix.exception.HystrixRuntimeException in project Hystrix by Netflix.

the class HystrixCommandTest method testRequestCacheOnTimeoutThrowsException.

@Test
public void testRequestCacheOnTimeoutThrowsException() throws Exception {
    TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
    RequestCacheTimeoutWithoutFallback r1 = new RequestCacheTimeoutWithoutFallback(circuitBreaker);
    try {
        System.out.println("r1 value: " + r1.execute());
        // we should have thrown an exception
        fail("expected a timeout");
    } catch (HystrixRuntimeException e) {
        assertTrue(r1.isResponseTimedOut());
    // what we want
    }
    RequestCacheTimeoutWithoutFallback r2 = new RequestCacheTimeoutWithoutFallback(circuitBreaker);
    try {
        r2.execute();
        // we should have thrown an exception
        fail("expected a timeout");
    } catch (HystrixRuntimeException e) {
        assertTrue(r2.isResponseTimedOut());
    // what we want
    }
    RequestCacheTimeoutWithoutFallback r3 = new RequestCacheTimeoutWithoutFallback(circuitBreaker);
    Future<Boolean> f3 = r3.queue();
    try {
        f3.get();
        // we should have thrown an exception
        fail("expected a timeout");
    } catch (ExecutionException e) {
        e.printStackTrace();
        assertTrue(r3.isResponseTimedOut());
    // what we want
    }
    // timeout on command is set to 200ms
    Thread.sleep(500);
    RequestCacheTimeoutWithoutFallback r4 = new RequestCacheTimeoutWithoutFallback(circuitBreaker);
    try {
        r4.execute();
        // we should have thrown an exception
        fail("expected a timeout");
    } catch (HystrixRuntimeException e) {
        assertTrue(r4.isResponseTimedOut());
        assertFalse(r4.isResponseFromFallback());
    // what we want
    }
    assertCommandExecutionEvents(r1, HystrixEventType.TIMEOUT, HystrixEventType.FALLBACK_MISSING);
    assertCommandExecutionEvents(r2, HystrixEventType.TIMEOUT, HystrixEventType.FALLBACK_MISSING, HystrixEventType.RESPONSE_FROM_CACHE);
    assertCommandExecutionEvents(r3, HystrixEventType.TIMEOUT, HystrixEventType.FALLBACK_MISSING, HystrixEventType.RESPONSE_FROM_CACHE);
    assertCommandExecutionEvents(r4, HystrixEventType.TIMEOUT, HystrixEventType.FALLBACK_MISSING, HystrixEventType.RESPONSE_FROM_CACHE);
    assertEquals(0, circuitBreaker.metrics.getCurrentConcurrentExecutionCount());
    assertSaneHystrixRequestLog(4);
}

Example 15 with HystrixRuntimeException

use of com.netflix.hystrix.exception.HystrixRuntimeException in project Hystrix by Netflix.

the class HystrixObservableCommandTest method testCheckedExceptionViaObserve.

/**
     * Test a java.lang.Error being thrown
     *
     * @throws InterruptedException
     */
@Test
public void testCheckedExceptionViaObserve() throws InterruptedException {
    TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
    CommandWithCheckedException command = new CommandWithCheckedException(circuitBreaker);
    final AtomicReference<Throwable> t = new AtomicReference<Throwable>();
    final CountDownLatch latch = new CountDownLatch(1);
    try {
        command.observe().subscribe(new Observer<Boolean>() {

            @Override
            public void onCompleted() {
                latch.countDown();
            }

            @Override
            public void onError(Throwable e) {
                t.set(e);
                latch.countDown();
            }

            @Override
            public void onNext(Boolean args) {
            }
        });
    } catch (Exception e) {
        e.printStackTrace();
        fail("we should not get anything thrown, it should be emitted via the Observer#onError method");
    }
    latch.await(1, TimeUnit.SECONDS);
    assertNotNull(t.get());
    t.get().printStackTrace();
    assertTrue(t.get() instanceof HystrixRuntimeException);
    assertEquals("simulated checked exception message", t.get().getCause().getMessage());
    assertEquals("simulated checked exception message", command.getFailedExecutionException().getMessage());
    assertTrue(command.getExecutionTimeInMilliseconds() > -1);
    assertTrue(command.isFailedExecution());
    assertCommandExecutionEvents(command, HystrixEventType.FAILURE, HystrixEventType.FALLBACK_MISSING);
    assertNotNull(command.getExecutionException());
    // semaphore isolated
    assertFalse(command.isExecutedInThread());
    assertSaneHystrixRequestLog(1);
}