Examples with ManagedAsync org.glassfish.jersey.server.ManagedAsync used on opensource projects

Example 1 with ManagedAsync

use of org.glassfish.jersey.server.ManagedAsync in project jersey by jersey.

the class AsyncAgentResource method async.

@GET
@ManagedAsync
public void async(@Suspended final AsyncResponse async) {
    final long time = System.nanoTime();
    final AgentResponse response = new AgentResponse();
    final CountDownLatch outerLatch = new CountDownLatch(2);
    final Queue<String> errors = new ConcurrentLinkedQueue<>();
    // Obtain visited destinations.
    destination.path("visited").request().header("Rx-User", "Async").async().get(new InvocationCallback<List<Destination>>() {

        @Override
        public void completed(final List<Destination> destinations) {
            response.setVisited(destinations);
            outerLatch.countDown();
        }

        @Override
        public void failed(final Throwable throwable) {
            errors.offer("Visited: " + throwable.getMessage());
            outerLatch.countDown();
        }
    });
    // Obtain recommended destinations. (does not depend on visited ones)
    destination.path("recommended").request().header("Rx-User", "Async").async().get(new InvocationCallback<List<Destination>>() {

        @Override
        public void completed(final List<Destination> recommended) {
            final CountDownLatch innerLatch = new CountDownLatch(recommended.size() * 2);
            // Forecasts. (depend on recommended destinations)
            final Map<String, Forecast> forecasts = Collections.synchronizedMap(new HashMap<>());
            for (final Destination dest : recommended) {
                forecast.resolveTemplate("destination", dest.getDestination()).request().async().get(new InvocationCallback<Forecast>() {

                    @Override
                    public void completed(final Forecast forecast) {
                        forecasts.put(dest.getDestination(), forecast);
                        innerLatch.countDown();
                    }

                    @Override
                    public void failed(final Throwable throwable) {
                        errors.offer("Forecast: " + throwable.getMessage());
                        innerLatch.countDown();
                    }
                });
            }
            // Calculations. (depend on recommended destinations)
            final List<Future<Calculation>> futures = recommended.stream().map(dest -> calculation.resolveTemplate("from", "Moon").resolveTemplate("to", dest.getDestination()).request().async().get(Calculation.class)).collect(Collectors.toList());
            final Map<String, Calculation> calculations = new HashMap<>();
            while (!futures.isEmpty()) {
                final Iterator<Future<Calculation>> iterator = futures.iterator();
                while (iterator.hasNext()) {
                    final Future<Calculation> f = iterator.next();
                    if (f.isDone()) {
                        try {
                            final Calculation calculation = f.get();
                            calculations.put(calculation.getTo(), calculation);
                            innerLatch.countDown();
                        } catch (final Throwable t) {
                            errors.offer("Calculation: " + t.getMessage());
                            innerLatch.countDown();
                        } finally {
                            iterator.remove();
                        }
                    }
                }
            }
            // Have to wait here for dependent requests ...
            try {
                if (!innerLatch.await(10, TimeUnit.SECONDS)) {
                    errors.offer("Inner: Waiting for requests to complete has timed out.");
                }
            } catch (final InterruptedException e) {
                errors.offer("Inner: Waiting for requests to complete has been interrupted.");
            }
            // Recommendations.
            final List<Recommendation> recommendations = new ArrayList<>(recommended.size());
            for (final Destination dest : recommended) {
                final Forecast fore = forecasts.get(dest.getDestination());
                final Calculation calc = calculations.get(dest.getDestination());
                recommendations.add(new Recommendation(dest.getDestination(), fore != null ? fore.getForecast() : "N/A", calc != null ? calc.getPrice() : -1));
            }
            response.setRecommended(recommendations);
            outerLatch.countDown();
        }

        @Override
        public void failed(final Throwable throwable) {
            errors.offer("Recommended: " + throwable.getMessage());
            outerLatch.countDown();
        }
    });
    // ... and have to wait also here for independent requests.
    try {
        if (!outerLatch.await(10, TimeUnit.SECONDS)) {
            errors.offer("Outer: Waiting for requests to complete has timed out.");
        }
    } catch (final InterruptedException e) {
        errors.offer("Outer: Waiting for requests to complete has been interrupted.");
    }
    // Do something with errors.
    // ...
    response.setProcessingTime((System.nanoTime() - time) / 1000000);
    async.resume(response);
}

Example 2 with ManagedAsync

use of org.glassfish.jersey.server.ManagedAsync in project jersey by jersey.

the class ChatResource method postMessage.

@POST
@ManagedAsync
public String postMessage(final Message message) throws InterruptedException {
    final AsyncResponse asyncResponse = suspended.take();
    asyncResponse.resume(message);
    return "Sent!";
}

Example 3 with ManagedAsync

use of org.glassfish.jersey.server.ManagedAsync in project jersey by jersey.

the class ListenableFutureAgentResource method listenable.

@GET
@ManagedAsync
public void listenable(@Suspended final AsyncResponse async) {
    final long time = System.nanoTime();
    final AgentResponse response = new AgentResponse();
    // Obtain and set visited and recommended places to create a response ...
    final ListenableFuture<List<AgentResponse>> successful = Futures.successfulAsList(Arrays.asList(visited(response), recommended(response)));
    // ... and when we have them, return response to the client.
    Futures.addCallback(successful, new FutureCallback<List<AgentResponse>>() {

        @Override
        public void onSuccess(final List<AgentResponse> result) {
            response.setProcessingTime((System.nanoTime() - time) / 1000000);
            async.resume(response);
        }

        @Override
        public void onFailure(final Throwable t) {
            async.resume(t);
        }
    });
}