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(ListenableFuture<V> future, FutureCallback<? super V> callback)

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.facebook.presto.operator.NestedLoopJoinPagesSupplier.java

public void release() {
    if (referenceCount.decrementAndGet() == 0) {
        // We own the shared pageSource, so we need to free their memory
        Futures.addCallback(pagesFuture, new FutureCallback<NestedLoopJoinPages>() {
            @Override//  ww  w  .j a v a 2  s  .  c  om
            public void onSuccess(NestedLoopJoinPages result) {
                result.freeMemory();
            }

            @Override
            public void onFailure(Throwable t) {
                // ignored
            }
        });
    }
}

From source file:com.uber.tchannel.api.TFuture.java

@SuppressWarnings({ "unchecked" })
public void addCallback(final TFutureCallback<V> callback) {
    Futures.addCallback(this, new FutureCallback<V>() {
        @Override//  w  w  w .  j a va 2  s  . co  m
        public void onSuccess(V response) {
            callback.onResponse(response);
        }

        @Override
        public void onFailure(Throwable throwable) {
            callback.onResponse(
                    (V) Response.build(argScheme, 0, ErrorType.UnexpectedError, throwable.getMessage()));
        }
    });
}

From source file:com.chenchengzhi.windtalkers.server.WindChannelHandler.java

/**
 * {@inheritDoc}//  w  w  w  .  ja va 2s .  co m
 */
@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent event) {
    HttpRequest request = (HttpRequest) event.getMessage();
    final Message message = messageFactory.parse(request);
    WindTalkerID talkerId = message.getTalkerID();
    for (final Talker talker : talkers) {
        if (talker.getID().equals(talkerId)) {
            Callable<Message> callable = new Callable<Message>() {

                @Override
                public Message call() throws Exception {
                    return talker.reply(message);
                }

            };
            ListenableFuture<Message> response = executor.submit(callable);

            Futures.addCallback(response, new ResponseCallback(event, message));
            return;
        }
    }
    event.getChannel().write(new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.NOT_FOUND));
}

From source file:org.apache.twill.internal.ZKMessages.java

/**
 * Creates a message node in zookeeper. The message node created is a PERSISTENT_SEQUENTIAL node.
 *
 * @param zkClient The ZooKeeper client for interacting with ZooKeeper.
 * @param messagePathPrefix ZooKeeper path prefix for the message node.
 * @param message The {@link Message} object for the content of the message node.
 * @param completion A {@link SettableFuture} to reflect the result of message process completion.
 * @param completionResult Object to set to the result future when the message is processed.
 * @param <V> Type of the completion result.
 *///from   ww w.j  a  v a2s. c om
public static <V> void sendMessage(final ZKClient zkClient, String messagePathPrefix, Message message,
        final SettableFuture<V> completion, final V completionResult) {

    // Creates a message and watch for its deletion for completion.
    Futures.addCallback(
            zkClient.create(messagePathPrefix, MessageCodec.encode(message), CreateMode.PERSISTENT_SEQUENTIAL),
            new FutureCallback<String>() {
                @Override
                public void onSuccess(String path) {
                    Futures.addCallback(ZKOperations.watchDeleted(zkClient, path),
                            new FutureCallback<String>() {
                                @Override
                                public void onSuccess(String result) {
                                    completion.set(completionResult);
                                }

                                @Override
                                public void onFailure(Throwable t) {
                                    completion.setException(t);
                                }
                            });
                }

                @Override
                public void onFailure(Throwable t) {
                    completion.setException(t);
                }
            });
}

From source file:org.opendaylight.nic.gbp.renderer.impl.GBPRenderer.java

private void deleteNode(InstanceIdentifier<?> iid) {
    WriteTransaction writeTransactionNodes = dataBroker.newWriteOnlyTransaction();
    writeTransactionNodes.delete(LogicalDatastoreType.OPERATIONAL, iid);
    Futures.addCallback(writeTransactionNodes.submit(), new FutureCallback<Void>() {
        @Override/*from www  .ja v a 2 s  .  c  o  m*/
        public void onSuccess(Void result) {
            LOG.debug("Delete result: " + result);
        }

        @Override
        public void onFailure(Throwable throwable) {
            LOG.error("Delete failed", throwable);
        }
    });
}

From source file:com.github.nethad.clustermeister.example.async.Async.java

private void execute() {
    try {//ww  w.  ja  va  2  s .co m
        if (clustermeister == null) {
            clustermeister = ClustermeisterFactory.create();
        }
        Job<Integer> job = JobFactory.create("CM Async", null);
        for (int i = 0; i < NUMBER_OF_TASKS; i++) {
            job.addTask(new ReturnNumberTask(i));
        }
        ListenableFuture<List<Integer>> resultFuture = clustermeister.executeJobAsync(job);

        logger.info("Returns immediately");
        Futures.addCallback(resultFuture, new FutureCallback<List<Integer>>() {
            public void onSuccess(List<Integer> result) {
                logger.info("Got list successfully, it contains {} items.", result.size());
                String resultAsString = Joiner.on(", ").useForNull("null").join(result);
                logger.info("Result: {}", resultAsString);
                monitor.enter();
                try {
                    futureCallbackDone.set(true);
                } finally {
                    monitor.leave();
                }
            }

            public void onFailure(Throwable t) {
                logger.info("Could not execute job.", t);
                try {
                    futureCallbackDone.set(true);
                } finally {
                    monitor.leave();
                }
            }
        });
        logger.info("Registered callback, waiting for it to be finished.");
        monitor.enter();
        try {
            monitor.waitFor(futureCallbackGuard);
            logger.info("Future callback done.");
        } finally {
            monitor.leave();
        }
    } catch (Exception ex) {
        logger.warn("Exception while executing example.", ex);
    } finally {
        if (clustermeister != null) {
            logger.info("Shutting down.");
            clustermeister.shutdown();
        }
    }
}

From source file:io.radiowitness.kinesis.producer.KinesisRecordProducer.java

private PutRecordTask nextTask() {
    Futures.addCallback(queuedFuture, this);
    PutRecordTask task = taskFactory.create(queuedFuture, partitionKey, sequenceNumber);
    queuedFuture = SettableFuture.create();
    return task;//w w  w. jav  a 2s .c  o m
}

From source file:org.anhonesteffort.p25.chnlzr.SamplesSourceHandler.java

public SamplesSourceHandler(ChannelHandlerContext context, Capabilities.Reader capabilities,
        ChannelState.Reader state) {
    this.capabilities = capabilities;
    this.state = state;
    closePromise = SettableFuture.create();

    context.channel().closeFuture().addListener(close -> {
        if (close.isSuccess()) {
            closePromise.set(null);// w  w  w. ja  va 2s.  c  o  m
        } else {
            closePromise.setException(close.cause());
        }
    });

    Futures.addCallback(closePromise, new FutureCallback<Void>() {
        @Override
        public void onSuccess(Void aVoid) {
            context.close();
        }

        @Override
        public void onFailure(@Nonnull Throwable error) {
            context.close();
        }
    });
}

From source file:io.v.todos.persistence.syncbase.MainListTracker.java

public MainListTracker(VContext vContext, Database database, final Id listId,
        ListEventListener<ListMetadata> listener) {
    collection = database.getCollection(listId);
    mListener = listener;//from  w w w . j  av  a  2 s  . c  om
    InputChannel<WatchChange> watch = database.watch(vContext,
            ImmutableList.of(Util.rowPrefixPattern(collection.id(), "")));
    watchFuture = InputChannels.withCallback(watch, new InputChannelCallback<WatchChange>() {
        @Override
        public ListenableFuture<Void> onNext(WatchChange change) {
            processWatchChange(change);
            return null;
        }
    });

    // If the watch fails with NoExistException, the collection has been deleted.
    Futures.addCallback(watchFuture, new FutureCallback<Void>() {
        @Override
        public void onSuccess(@Nullable Void result) {
        }

        @Override
        public void onFailure(@NonNull Throwable t) {
            if (t instanceof NoExistException && mListExistsLocally) {
                Log.d(TAG, getNameFromId() + " destroyed");
                mListener.onItemDelete(getNameFromId());
            }
        }
    });
}

From source file:org.opendaylight.md.controller.topology.manager.OperationProcessor.java

@Override
public void run() {
    try {/*  w  ww  . j av a2  s .c o m*/
        for (;;) {
            TopologyOperation op = queue.take();

            LOG.debug("New operations available, starting transaction");
            final ReadWriteTransaction tx = dataBroker.newReadWriteTransaction();

            int ops = 0;
            do {
                op.applyOperation(tx);

                ops++;
                if (ops < MAX_TRANSACTION_OPERATIONS) {
                    op = queue.poll();
                } else {
                    op = null;
                }
            } while (op != null);

            LOG.debug("Processed {} operations, submitting transaction", ops);

            final CheckedFuture txResultFuture = tx.submit();
            Futures.addCallback(txResultFuture, new FutureCallback() {
                @Override
                public void onSuccess(Object o) {
                    LOG.debug("Topology export successful for tx :{}", tx.getIdentifier());
                }

                @Override
                public void onFailure(Throwable throwable) {
                    LOG.error("Topology export transaction {} failed", tx.getIdentifier(),
                            throwable.getCause());
                }
            });
        }
    } catch (InterruptedException e) {
        LOG.info("Interrupted processing, terminating", e);
    }

    // Drain all events, making sure any blocked threads are unblocked
    while (!queue.isEmpty()) {
        queue.poll();
    }
}