Examples with AgentResponse org.glassfish.jersey.examples.rx.domain.AgentResponse used on opensource projects

Example 1 with AgentResponse

use of org.glassfish.jersey.examples.rx.domain.AgentResponse 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 AgentResponse

use of org.glassfish.jersey.examples.rx.domain.AgentResponse in project jersey by jersey.

the class ListenableFutureAgentResource method recommended.

private ListenableFuture<AgentResponse> recommended(final AgentResponse response) {
    destination.register(RxListenableFutureInvokerProvider.class);
    // Get a list of recommended destinations ...
    final ListenableFuture<List<Destination>> destinations = destination.path("recommended").request().header("Rx-User", "Guava").rx(RxListenableFutureInvoker.class).get(new GenericType<List<Destination>>() {
    });
    // ... transform them to Recommendation instances ...
    final ListenableFuture<List<Recommendation>> recommendations = Futures.transform(destinations, (AsyncFunction<List<Destination>, List<Recommendation>>) destinationList -> {
        final List<Recommendation> recommendationList = Lists.newArrayList(Lists.transform(destinationList, destination -> new Recommendation(destination.getDestination(), null, 0)));
        return Futures.immediateFuture(recommendationList);
    });
    // ... add forecasts and calculations ...
    final ListenableFuture<List<List<Recommendation>>> filledRecommendations = Futures.successfulAsList(Arrays.asList(// Add Forecasts to Recommendations.
    forecasts(recommendations), // Add Forecasts to Recommendations.
    calculations(recommendations)));
    // ... and transform the list into agent response with filled recommendations.
    return Futures.transform(filledRecommendations, (AsyncFunction<List<List<Recommendation>>, AgentResponse>) input -> {
        response.setRecommended(input.get(0));
        return Futures.immediateFuture(response);
    });
}

Example 3 with AgentResponse

use of org.glassfish.jersey.examples.rx.domain.AgentResponse in project jersey by jersey.

the class ObservableAgentResource method observable.

@GET
public void observable(@Suspended final AsyncResponse async) {
    final long time = System.nanoTime();
    final Queue<String> errors = new ConcurrentLinkedQueue<>();
    Observable.just(new AgentResponse()).zipWith(visited(errors), (response, visited) -> {
        response.setVisited(visited);
        return response;
    }).zipWith(recommended(errors), (response, recommendations) -> {
        response.setRecommended(recommendations);
        return response;
    }).observeOn(Schedulers.io()).subscribe(response -> {
        response.setProcessingTime((System.nanoTime() - time) / 1000000);
        async.resume(response);
    }, async::resume);
}

Example 4 with AgentResponse

use of org.glassfish.jersey.examples.rx.domain.AgentResponse in project jersey by jersey.

the class SyncAgentResource method sync.

@GET
public AgentResponse sync() {
    final long time = System.nanoTime();
    final AgentResponse response = new AgentResponse();
    final Queue<String> errors = new ConcurrentLinkedQueue<>();
    // Obtain visited destinations.
    try {
        response.setVisited(destination.path("visited").request().header("Rx-User", "Sync").get(new GenericType<List<Destination>>() {
        }));
    } catch (final Throwable throwable) {
        errors.offer("Visited: " + throwable.getMessage());
    }
    // Obtain recommended destinations. (does not depend on visited ones)
    List<Destination> recommended = Collections.emptyList();
    try {
        recommended = destination.path("recommended").request().header("Rx-User", "Sync").get(new GenericType<List<Destination>>() {
        });
    } catch (final Throwable throwable) {
        errors.offer("Recommended: " + throwable.getMessage());
    }
    // Forecasts. (depend on recommended destinations)
    final Map<String, Forecast> forecasts = new HashMap<>();
    for (final Destination dest : recommended) {
        try {
            forecasts.put(dest.getDestination(), forecast.resolveTemplate("destination", dest.getDestination()).request().get(Forecast.class));
        } catch (final Throwable throwable) {
            errors.offer("Forecast: " + throwable.getMessage());
        }
    }
    // Calculations. (depend on recommended destinations)
    final Map<String, Calculation> calculations = new HashMap<>();
    recommended.stream().forEach(destination -> {
        try {
            calculations.put(destination.getDestination(), calculation.resolveTemplate("from", "Moon").resolveTemplate("to", destination.getDestination()).request().get(Calculation.class));
        } catch (final Throwable throwable) {
            errors.offer("Calculation: " + throwable.getMessage());
        }
    });
    // 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));
    }
    // Do something with errors.
    // ...
    response.setRecommended(recommendations);
    response.setProcessingTime((System.nanoTime() - time) / 1000000);
    return response;
}

Example 5 with AgentResponse

use of org.glassfish.jersey.examples.rx.domain.AgentResponse in project jersey by jersey.

the class RxClientsTest method testAsyncClient.

@Test
public void testAsyncClient() throws Exception {
    // warmup
    target("agent").path("async").request().get();
    final Response response = target("agent").path("async").request().get();
    response.bufferEntity();
    final AgentResponse agentResponse = response.readEntity(AgentResponse.class);
    assertThat(agentResponse.getVisited().size(), is(5));
    assertThat(agentResponse.getRecommended().size(), is(5));
    assertThat(agentResponse.getProcessingTime() > 850, is(true));
    assertThat(agentResponse.getProcessingTime() < 4500, is(true));
    System.out.println(response.readEntity(String.class));
    System.out.println("Processing Time: " + agentResponse.getProcessingTime());
}