Example usage for com.google.common.util.concurrent Futures addCallback

Introduction

In this page you can find the example usage for com.google.common.util.concurrent Futures addCallback.

Prototype

public static <V> void addCallback(final ListenableFuture<V> future, final FutureCallback<? super V> callback,
        Executor executor) 

Source Link

Document

Registers separate success and failure callbacks to be run when the Future 's computation is java.util.concurrent.Future#isDone() complete or, if the computation is already complete, immediately.

Usage

From source file:com.github.fhuss.storm.cassandra.executor.AsyncExecutor.java

/**
 * Asynchronously executes all statements associated to the specified input. The input will be passed to
 * the {@link #handler} once all queries succeed or failed.
 *///from  w ww.ja  v a  2 s  .  c om
public List<SettableFuture<T>> execAsync(List<Statement> statements, final T input) {
    Stream<SettableFuture<T>> futureStream = statements.stream()
            .map(s -> execAsync(s, input, AsyncResultHandler.NO_OP_HANDLER));

    List<SettableFuture<T>> settableFutures = futureStream.collect(Collectors.toList());
    ListenableFuture<List<T>> allAsList = Futures.allAsList(settableFutures);
    Futures.addCallback(allAsList, new FutureCallback<List<T>>() {
        @Override
        public void onSuccess(List<T> inputs) {
            handler.success(input);
        }

        @Override
        public void onFailure(Throwable t) {
            handler.failure(t, input);
        }
    }, executorService);
    return settableFutures;
}

---

From source file:org.kaaproject.kaa.server.appenders.cdap.appender.CdapLogAppender.java

@Override
public void doAppend(LogEventPack logEventPack, RecordHeader header, LogDeliveryCallback listener) {
    if (!closed) {
        if (streamWriter != null) {
            LOG.debug("[{}] appending {} logs to cdap stream", this.getApplicationToken(),
                    logEventPack.getEvents().size());
            try {
                for (LogEventDto dto : generateLogEvent(logEventPack, header)) {
                    StringBuilder sb = new StringBuilder();
                    sb.append("{\"header\":").append(dto.getHeader()).append(",");
                    sb.append("\"event\":").append(dto.getEvent()).append("}");
                    ListenableFuture<Void> result = streamWriter.write(sb.toString(), UTF8);
                    Futures.addCallback(result, new Callback(listener), callbackExecutor);
                }//from   www. j  a  v  a 2s  .co m
            } catch (IOException e) {
                LOG.debug("[{}] Failed to generate log event.", getName());
                listener.onInternalError();
            }
        } else {
            LOG.info("[{}] Attempted to append to empty streamWriter.", getName());
            listener.onInternalError();
        }
    } else {
        LOG.info("[{}] Attempted to append to closed appender.", getName());
        listener.onInternalError();
    }
}

---

From source file:info.archinnov.achilles.internal.async.AsyncUtils.java

public void maybeAddAsyncListeners(ListenableFuture<?> listenableFuture,
        FutureCallback<Object>[] asyncListeners, ExecutorService executorService) {
    if (ArrayUtils.isNotEmpty(asyncListeners)) {
        for (FutureCallback<Object> callback : asyncListeners) {
            Futures.addCallback(listenableFuture, callback, executorService);
        }/*w w  w.j av  a2s.  com*/
    }
}

---

From source file:c5db.regionserver.RegionServerService.java

@Override
protected void doStart() {
    fiber.start();/*from  w  w w.j  a va  2  s. c  o m*/

    fiber.execute(() -> {
        // we need the tablet module:
        ListenableFuture<C5Module> f = server.getModule(ModuleType.Tablet);
        Futures.addCallback(f, new FutureCallback<C5Module>() {
            @Override
            public void onSuccess(final C5Module result) {
                tabletModule = (TabletModule) result;
                bootstrap.group(acceptGroup, workerGroup).option(ChannelOption.SO_REUSEADDR, true)
                        .childOption(ChannelOption.TCP_NODELAY, true).channel(NioServerSocketChannel.class)
                        .childHandler(new ChannelInitializer<SocketChannel>() {
                            @Override
                            protected void initChannel(SocketChannel ch) throws Exception {
                                ChannelPipeline p = ch.pipeline();
                                p.addLast("http-server-codec", new HttpServerCodec());
                                p.addLast("http-agg",
                                        new HttpObjectAggregator(C5ServerConstants.MAX_CALL_SIZE));
                                p.addLast("websocket-agg",
                                        new WebSocketFrameAggregator(C5ServerConstants.MAX_CALL_SIZE));
                                p.addLast("decoder", new WebsocketProtostuffDecoder("/websocket"));
                                p.addLast("encoder", new WebsocketProtostuffEncoder());
                                p.addLast("handler", new RegionServerHandler(RegionServerService.this));
                            }
                        });

                bootstrap.bind(port).addListener(new ChannelFutureListener() {
                    @Override
                    public void operationComplete(ChannelFuture future) throws Exception {
                        if (future.isSuccess()) {
                            listenChannel = future.channel();
                            notifyStarted();
                        } else {
                            LOG.error("Unable to find Region Server to {} {}", port, future.cause());
                            notifyFailed(future.cause());
                        }
                    }
                });
            }

            @Override
            public void onFailure(Throwable t) {
                notifyFailed(t);
            }
        }, fiber);
    });
}

---

From source file:com.newlandframework.rpc.netty.RpcServerLoader.java

public void load(String serverAddress, RpcSerializeProtocol serializeProtocol) {
    String[] ipAddr = serverAddress.split(RpcServerLoader.DELIMITER);
    if (ipAddr.length == 2) {
        String host = ipAddr[0];//from  ww w .j av  a  2  s . c om
        int port = Integer.parseInt(ipAddr[1]);
        final InetSocketAddress remoteAddr = new InetSocketAddress(host, port);

        System.out.printf("[author tangjie] Netty RPC Client start success!\nip:%s\nport:%d\nprotocol:%s\n\n",
                host, port, serializeProtocol);

        ListenableFuture<Boolean> listenableFuture = threadPoolExecutor
                .submit(new MessageSendInitializeTask(eventLoopGroup, remoteAddr, serializeProtocol));

        Futures.addCallback(listenableFuture, new FutureCallback<Boolean>() {
            public void onSuccess(Boolean result) {
                try {
                    lock.lock();

                    if (messageSendHandler == null) {
                        handlerStatus.await();
                    }

                    if (result == Boolean.TRUE && messageSendHandler != null) {
                        connectStatus.signalAll();
                    }
                } catch (InterruptedException ex) {
                    Logger.getLogger(RpcServerLoader.class.getName()).log(Level.SEVERE, null, ex);
                } finally {
                    lock.unlock();
                }
            }

            public void onFailure(Throwable t) {
                t.printStackTrace();
            }
        }, threadPoolExecutor);
    }
}

---

From source file:io.prestosql.metadata.RemoteNodeState.java

public synchronized void asyncRefresh() {
    Duration sinceUpdate = nanosSince(lastUpdateNanos.get());
    if (nanosSince(lastWarningLogged.get()).toMillis() > 1_000 && sinceUpdate.toMillis() > 10_000
            && future.get() != null) {
        log.warn("Node state update request to %s has not returned in %s", stateInfoUri,
                sinceUpdate.toString(SECONDS));
        lastWarningLogged.set(System.nanoTime());
    }/*from   w w w.  ja  v a 2s .  c  o  m*/
    if (sinceUpdate.toMillis() > 1_000 && future.get() == null) {
        Request request = prepareGet().setUri(stateInfoUri).setHeader(CONTENT_TYPE, JSON_UTF_8.toString())
                .build();
        HttpResponseFuture<JsonResponse<NodeState>> responseFuture = httpClient.executeAsync(request,
                createFullJsonResponseHandler(jsonCodec(NodeState.class)));
        future.compareAndSet(null, responseFuture);

        Futures.addCallback(responseFuture, new FutureCallback<JsonResponse<NodeState>>() {
            @Override
            public void onSuccess(@Nullable JsonResponse<NodeState> result) {
                lastUpdateNanos.set(System.nanoTime());
                future.compareAndSet(responseFuture, null);
                if (result != null) {
                    if (result.hasValue()) {
                        nodeState.set(Optional.ofNullable(result.getValue()));
                    }
                    if (result.getStatusCode() != OK.code()) {
                        log.warn("Error fetching node state from %s returned status %d: %s", stateInfoUri,
                                result.getStatusCode(), result.getStatusMessage());
                        return;
                    }
                }
            }

            @Override
            public void onFailure(Throwable t) {
                log.warn("Error fetching node state from %s: %s", stateInfoUri, t.getMessage());
                lastUpdateNanos.set(System.nanoTime());
                future.compareAndSet(responseFuture, null);
            }
        }, directExecutor());
    }
}

---

From source file:com.proofpoint.concurrent.AsyncSemaphore.java

private void runNext() {
    final QueuedTask<T> queuedTask = queuedTasks.poll();
    ListenableFuture<?> future = submitTask(queuedTask.getTask());
    FutureCallback<Object> callback = new FutureCallback<Object>() {
        @Override/*from   w  w  w  .  j a v a 2 s  .co  m*/
        public void onSuccess(Object result) {
            queuedTask.markCompleted();
            releasePermit();
        }

        @Override
        public void onFailure(Throwable t) {
            queuedTask.markFailure(t);
            releasePermit();
        }
    };
    Futures.addCallback(future, callback, directExecutor());
}

---

From source file:io.v.v23.InputChannels.java

/**
 * Returns a new {@link ListenableFuture} whose result is available when the provided
 * {@link InputChannel} has exhausted all of its elements.
 * <p>//  w w  w  .j  av a2  s .  com
 * The returned future will be executed on the provided {@code executor}.
 */
@CheckReturnValue
public static <T> ListenableFuture<Void> asDone(final InputChannel<T> channel, Executor executor) {
    final SettableFuture<Void> future = SettableFuture.create();
    Futures.addCallback(channel.recv(), newCallbackForDone(channel, future, executor), executor);
    return future;
}

---

From source file:org.apache.storm.cassandra.executor.AsyncExecutor.java

/**
 * Asynchronously executes all statements associated to the specified input.
 * The input will be passed to handler#onSuccess once all queries succeed or to handler#onFailure if any one of them fails.
 *//*from  ww  w. j a v  a  2s.  c o  m*/
public List<SettableFuture<T>> execAsync(List<Statement> statements, final T input) {

    List<SettableFuture<T>> settableFutures = new ArrayList<>(statements.size());

    for (Statement s : statements)
        settableFutures.add(execAsync(s, input, AsyncResultHandler.NO_OP_HANDLER));

    ListenableFuture<List<T>> allAsList = Futures.allAsList(settableFutures);
    Futures.addCallback(allAsList, new FutureCallback<List<T>>() {
        @Override
        public void onSuccess(List<T> inputs) {
            handler.success(input);
        }

        @Override
        public void onFailure(Throwable t) {
            handler.failure(t, input);
        }
    }, executorService);
    return settableFutures;
}

---

From source file:com.google.gerrit.server.index.change.ReindexAfterRefUpdate.java

@Override
public void onGitReferenceUpdated(final Event event) {
    if (!enabled || event.getRefName().startsWith(RefNames.REFS_CHANGES)
            || event.getRefName().startsWith(RefNames.REFS_DRAFT_COMMENTS)
            || event.getRefName().startsWith(RefNames.REFS_USERS)) {
        return;/*from w  ww .j  a va 2 s .  c o m*/
    }
    Futures.addCallback(executor.submit(new GetChanges(event)), new FutureCallback<List<Change>>() {
        @Override
        public void onSuccess(List<Change> changes) {
            for (Change c : changes) {
                // Don't retry indefinitely; if this fails changes may be stale.
                @SuppressWarnings("unused")
                Future<?> possiblyIgnoredError = executor.submit(new Index(event, c.getId()));
            }
        }

        @Override
        public void onFailure(Throwable ignored) {
            // Logged by {@link GetChanges#call()}.
        }
    }, directExecutor());
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• »