Examples with FutureListener org.jgroups.util.FutureListener used on opensource projects

Example 1 with FutureListener

use of org.jgroups.util.FutureListener in project JGroups by belaban.

the class ExecutingServiceTest2 method testDisconnect.

@Test
public void testDisconnect() throws Exception {
    JChannel channel1 = new JChannel(Util.getTestStack(new CENTRAL_EXECUTOR()));
    JChannel channel2 = new JChannel(Util.getTestStack(new CENTRAL_EXECUTOR()));
    channels.add(channel1);
    channels.add(channel2);
    channel1.connect("test-cluster");
    channel2.connect("test-cluster");
    Util.waitUntilAllChannelsHaveSameView(20000, 1000, channel1, channel2);
    final ExecutionService executionService = new ExecutionService(channel1);
    ExecutionRunner executionRunner1 = new ExecutionRunner(channel1);
    ExecutionRunner executionRunner2 = new ExecutionRunner(channel2);
    Thread runner1 = new Thread(executionRunner1);
    threads.add(runner1);
    runner1.start();
    Thread runner2 = new Thread(executionRunner2);
    threads.add(runner2);
    runner2.start();
    final AtomicInteger submittedTasks = new AtomicInteger();
    final AtomicInteger finishedTasks = new AtomicInteger();
    final FutureListener<Void> listener = future -> {
        finishedTasks.incrementAndGet();
        synchronized (ExecutingServiceTest2.this) {
            ExecutingServiceTest2.this.notify();
        }
    };
    Thread submitter = new Thread(new Runnable() {

        @Override
        public void run() {
            // Two long running tasks that should be sent to each runner
            submit(true);
            submit(true);
            while (!Thread.interrupted()) {
                submit(false);
                // Throttle
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        }

        private void submit(boolean wait) {
            Callable<Void> task = new Wait(wait);
            NotifyingFuture<Void> future = executionService.submit(task);
            submittedTasks.incrementAndGet();
            future.setListener(listener);
        }
    });
    threads.add(submitter);
    submitter.start();
    // Run for 2 seconds
    Thread.sleep(500);
    // Close channel
    channel2.close();
    // Stop submitting
    submitter.interrupt();
    submitter.join();
    // Wait for running tasks to finish
    synchronized (this) {
        int lastFinished = finishedTasks.get();
        while (submittedTasks.get() > finishedTasks.get()) {
            wait(10000);
            if (lastFinished == finishedTasks.get()) {
                assert false : "Tasks still outstanding, none finished in the last 10s";
            }
            lastFinished = finishedTasks.get();
        }
    }
    Assert.assertEquals(submittedTasks.get(), finishedTasks.get(), "Tasks not finished");
}

Example 2 with FutureListener

use of org.jgroups.util.FutureListener in project wildfly by wildfly.

the class ChannelCommandDispatcher method submitOnCluster.

@Override
public <R> Map<Node, Future<R>> submitOnCluster(Command<R, ? super C> command, Node... excludedNodes) throws CommandDispatcherException {
    Map<Node, Future<R>> results = new ConcurrentHashMap<>();
    FutureListener<RspList<R>> listener = future -> {
        try {
            future.get().keySet().stream().map(address -> this.factory.createNode(address)).forEach(node -> results.remove(node));
        } catch (CancellationException e) {
        } catch (ExecutionException e) {
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    };
    Message message = this.createMessage(command);
    RequestOptions options = this.createRequestOptions(excludedNodes);
    try {
        Future<? extends Map<Address, Rsp<R>>> futureResponses = this.dispatcher.castMessageWithFuture(null, message, options, listener);
        Set<Node> excluded = (excludedNodes != null) ? new HashSet<>(Arrays.asList(excludedNodes)) : Collections.<Node>emptySet();
        for (Address address : this.dispatcher.getChannel().getView().getMembers()) {
            Node node = this.factory.createNode(address);
            if (!excluded.contains(node)) {
                Future<R> future = new Future<R>() {

                    @Override
                    public boolean cancel(boolean mayInterruptIfRunning) {
                        return futureResponses.cancel(mayInterruptIfRunning);
                    }

                    @Override
                    public R get() throws InterruptedException, ExecutionException {
                        Map<Address, Rsp<R>> responses = futureResponses.get();
                        Rsp<R> response = responses.get(address);
                        if (response == null) {
                            throw new CancellationException();
                        }
                        return createCommandResponse(response).get();
                    }

                    @Override
                    public R get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
                        Map<Address, Rsp<R>> responses = futureResponses.get(timeout, unit);
                        Rsp<R> response = responses.get(address);
                        if (response == null) {
                            throw new CancellationException();
                        }
                        return createCommandResponse(response).get();
                    }

                    @Override
                    public boolean isCancelled() {
                        return futureResponses.isCancelled();
                    }

                    @Override
                    public boolean isDone() {
                        return futureResponses.isDone();
                    }
                };
                results.put(node, future);
            }
        }
        return results;
    } catch (Exception e) {
        throw new CommandDispatcherException(e);
    }
}