Examples with ThreadFactoryBuilder org.glassfish.jersey.internal.guava.ThreadFactoryBuilder used on opensource projects

Example 16 with ThreadFactoryBuilder

use of org.glassfish.jersey.internal.guava.ThreadFactoryBuilder in project jersey by jersey.

the class AsyncServletResourceTest method testAsyncRequestCanceling.

/**
     * Test canceling of an async request to a servlet-deployed resource.
     *
     * @throws InterruptedException in case the waiting for all requests to complete was interrupted.
     */
@Test
public void testAsyncRequestCanceling() throws InterruptedException {
    final WebTarget resourceTarget = target("async/canceled");
    resourceTarget.register(LoggingFeature.class);
    final int MAX_MESSAGES = 10;
    final int LATCH_WAIT_TIMEOUT = 10;
    final boolean debugMode = false;
    final boolean sequentialGet = false;
    final boolean sequentialPost = false;
    final Object sequentialGetLock = new Object();
    final Object sequentialPostLock = new Object();
    final ExecutorService executor = Executors.newCachedThreadPool(new ThreadFactoryBuilder().setNameFormat("async-canceled-resource-test-%d").setUncaughtExceptionHandler(new JerseyProcessingUncaughtExceptionHandler()).build());
    final Map<Integer, String> postResponses = new ConcurrentHashMap<>();
    final Map<Integer, String> getResponses = new ConcurrentHashMap<>();
    final CountDownLatch postRequestLatch = new CountDownLatch(MAX_MESSAGES);
    final CountDownLatch getRequestLatch = new CountDownLatch(MAX_MESSAGES);
    try {
        for (int i = 0; i < MAX_MESSAGES; i++) {
            final int requestId = i;
            executor.submit(new Runnable() {

                @Override
                public void run() {
                    //noinspection PointlessBooleanExpression,ConstantConditions
                    if (debugMode || sequentialGet) {
                        synchronized (sequentialGetLock) {
                            get();
                        }
                    } else {
                        get();
                    }
                }

                private void get() {
                    try {
                        final String response = resourceTarget.queryParam("id", requestId).request().get(String.class);
                        getResponses.put(requestId, response);
                    } catch (final WebApplicationException ex) {
                        final Response response = ex.getResponse();
                        getResponses.put(requestId, response.getStatus() + ": " + response.readEntity(String.class));
                    } finally {
                        getRequestLatch.countDown();
                    }
                }
            });
            executor.submit(new Runnable() {

                @Override
                public void run() {
                    //noinspection PointlessBooleanExpression,ConstantConditions
                    if (debugMode || sequentialPost) {
                        synchronized (sequentialPostLock) {
                            post();
                        }
                    } else {
                        post();
                    }
                }

                private void post() throws ProcessingException {
                    try {
                        final String response = resourceTarget.request().post(Entity.text("" + requestId), String.class);
                        postResponses.put(requestId, response);
                    } finally {
                        postRequestLatch.countDown();
                    }
                }
            });
        }
        //noinspection ConstantConditions
        if (debugMode) {
            postRequestLatch.await();
            getRequestLatch.await();
        } else {
            assertTrue("Waiting for all POST requests to complete has timed out.", postRequestLatch.await(LATCH_WAIT_TIMEOUT * getAsyncTimeoutMultiplier(), TimeUnit.SECONDS));
            assertTrue("Waiting for all GET requests to complete has timed out.", getRequestLatch.await(LATCH_WAIT_TIMEOUT * getAsyncTimeoutMultiplier(), TimeUnit.SECONDS));
        }
    } finally {
        executor.shutdownNow();
    }
    final StringBuilder messageBuilder = new StringBuilder();
    for (final Map.Entry<Integer, String> postResponseEntry : postResponses.entrySet()) {
        messageBuilder.append("POST response for message ").append(postResponseEntry.getKey()).append(": ").append(postResponseEntry.getValue()).append('\n');
    }
    messageBuilder.append('\n');
    for (final Map.Entry<Integer, String> getResponseEntry : getResponses.entrySet()) {
        messageBuilder.append("GET response for message ").append(getResponseEntry.getKey()).append(": ").append(getResponseEntry.getValue()).append('\n');
    }
    LOGGER.info(messageBuilder.toString());
    assertEquals(MAX_MESSAGES, postResponses.size());
    for (final Map.Entry<Integer, String> postResponseEntry : postResponses.entrySet()) {
        assertTrue("Unexpected POST notification response for message " + postResponseEntry.getKey(), postResponseEntry.getValue().startsWith(AsyncServletResource.CANCELED));
    }
    assertEquals(MAX_MESSAGES, getResponses.size());
    final Collection<Integer> getResponseKeys = getResponses.keySet();
    for (int i = 0; i < MAX_MESSAGES; i++) {
        assertTrue("Detected a GET message response loss: " + i, getResponseKeys.contains(i));
        final String getResponseEntry = getResponses.get(i);
        assertTrue("Unexpected canceled GET response status for request " + i, getResponseEntry.startsWith("503: "));
    }
}