Example usage for com.google.common.util.concurrent FutureCallback FutureCallback

Introduction

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

Prototype

FutureCallback

Source Link

Usage

From source file:de.xaniox.heavyspleef.commands.CommandRename.java

@Command(name = "rename", descref = Messages.Help.Description.RENAME, permission = Permissions.PERMISSION_RENAME, minArgs = 2, usage = "/spleef rename <game> <to>")
public void onRenameCommand(CommandContext context, HeavySpleef heavySpleef) throws CommandException {
    final CommandSender sender = context.getSender() instanceof Player
            ? heavySpleef.getSpleefPlayer(context.getSender())
            : context.getSender();//from  w w w .  j a  v  a2  s.  c  o m

    final String from = context.getString(0);
    final String to = context.getString(1);

    GameManager manager = heavySpleef.getGameManager();

    CommandValidate.isTrue(manager.hasGame(from),
            i18n.getVarString(Messages.Command.GAME_DOESNT_EXIST).setVariable("game", from).toString());
    CommandValidate.isTrue(!manager.hasGame(to), i18n.getString(Messages.Command.GAME_ALREADY_EXIST));

    Game game = manager.getGame(from);
    final String oldName = game.getName();

    manager.renameGame(game, to, new FutureCallback<Void>() {

        @Override
        public void onSuccess(Void result) {
            sender.sendMessage(i18n.getVarString(Messages.Command.GAME_RENAMED).setVariable("from", oldName)
                    .setVariable("to", to).toString());
        }

        @Override
        public void onFailure(Throwable t) {
            sender.sendMessage(i18n.getVarString(Messages.Command.ERROR_ON_SAVE)
                    .setVariable("detail-message", t.toString()).toString());
        }
    });
}

---

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/*from   ww w .ja  v a2 s. com*/
        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:demos.BatchInsert.java

public void run() {
    try {/*from   w  ww .j av  a  2s  . c o  m*/
        logger.info("Preparing to insert metric data points");

        Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();
        Session session = cluster.connect("demo");
        PreparedStatement insert = session
                .prepare("insert into metric_data (metric_id, time, value) values (?, ?, ?)");
        Random random = new Random();
        DateTime time = DateTime.now().minusYears(1);
        final CountDownLatch latch = new CountDownLatch(NUM_INSERTS / BATCH_SIZE);

        FutureCallback<ResultSet> callback = new FutureCallback<ResultSet>() {
            @Override
            public void onSuccess(ResultSet result) {
                latch.countDown();
            }

            @Override
            public void onFailure(Throwable t) {
                logger.warn("There was an error inserting data", t);
                latch.countDown();
            }
        };

        Stopwatch stopwatch = new Stopwatch().start();
        BatchStatement batch = new BatchStatement();
        for (int i = 0; i < NUM_INSERTS; ++i) {
            String metricId = "metric-" + Math.abs(random.nextInt() % NUM_METRICS);
            double value = random.nextDouble();
            batch.add(insert.bind(metricId, time.toDate(), value));
            time = time.plusSeconds(10);
            if (batch.size() == BATCH_SIZE) {
                ResultSetFuture future = session.executeAsync(batch);
                Futures.addCallback(future, callback);
                batch = new BatchStatement();
            }
        }
        latch.await();
        stopwatch.stop();

        logger.info("Finished inserting {} data points in {} ms", NUM_INSERTS,
                stopwatch.elapsed(TimeUnit.MILLISECONDS));
    } catch (InterruptedException e) {
        logger.info("There was an interrupt while waiting for inserts to complete");
    }
}

---

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/*  w  ww.ja  v  a 2s . c  o m*/
            public void onSuccess(NestedLoopJoinPages result) {
                result.freeMemory();
            }

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

---

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

private void execute() {
    try {/*from w w w.  j  ava2 s  .c o m*/
        if (clustermeister == null) {
            clustermeister = ClustermeisterFactory.create();
        }
        Job<String> job = JobFactory.create("CM AsyncTasks", null);
        for (int i = 0; i < NUMBER_OF_TASKS; i++) {
            job.addTask(new ReturnNumberTaskWithSleep(i, 2000));
        }
        List<ListenableFuture<String>> resultFutures = clustermeister.executeJobAsyncTasks(job);
        FutureCallback<String> callback = new FutureCallback<String>() {
            public void onSuccess(String result) {
                logger.info("Got result {}", result);
                monitor.enter();
                try {
                    callbackCounter.incrementAndGet();
                } finally {
                    monitor.leave();
                }
            }

            public void onFailure(Throwable t) {
                logger.warn("Failure.", t);
                monitor.enter();
                try {
                    callbackCounter.incrementAndGet();
                } finally {
                    monitor.leave();
                }
            }
        };

        for (ListenableFuture<String> listenableFuture : resultFutures) {
            Futures.addCallback(listenableFuture, callback);
        }

        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:com.spotify.apollo.test.experimental.ResponseTimeMetric.java

private <T> FutureCallback<T> createCallback(final long t0, final int rate) {
    activeTracked.incrementAndGet();//  w w w  .  j a v  a  2s. c o m
    return new FutureCallback<T>() {
        @Override
        public void onSuccess(T result) {
            long elapsed = nanoTime() - t0;

            responseTimes.offer(elapsed);
            totalResponses.incrementAndGet();
            activeTracked.decrementAndGet();

            if (callback != null) {
                callback.apply(new CallResult(elapsed, true, rate));
            }
        }

        @Override
        public void onFailure(Throwable t) {
            LOG.error("Failed execution", t);
            totalResponses.incrementAndGet();
            totalFailed.incrementAndGet();
            activeTracked.decrementAndGet();
        }
    };
}

---

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

private void execute() {
    try {// ww w  . j a v a 2  s  .  c  om
        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:com.spotify.futures.FuturesExtra.java

/**
 * Returns a future that fails with a {@link TimeoutException} if the parent future has not
 * finished before the timeout. The new returned future will always be executed on the provided
 * scheduledExecutorService, even when the parent future does not timeout.
 *
 * @param scheduledExecutorService executor that runs the timeout code. If the future times out,
 *                                 this is also the thread any callbacks will run on.
 * @param future                   the future to wrap as a timeout future.
 * @param timeout                  how long to wait before timing out a future
 * @param unit                     unit of the timeout
 * @return a future that may timeout before the parent future is done.
 *//*www  . j  av  a 2 s . c  o m*/
public static <T> ListenableFuture<T> makeTimeoutFuture(ScheduledExecutorService scheduledExecutorService,
        ListenableFuture<T> future, final long timeout, final TimeUnit unit) {
    final SettableFuture<T> promise = SettableFuture.create();

    scheduledExecutorService.schedule(new Runnable() {
        @Override
        public void run() {
            String message = "Future timed out after " + timeout + " " + unit.name();
            promise.setException(new TimeoutException(message));
        }
    }, timeout, unit);

    Futures.addCallback(future, new FutureCallback<T>() {
        @Override
        public void onSuccess(T result) {
            promise.set(result);
        }

        @Override
        public void onFailure(Throwable t) {
            promise.setException(t);
        }
    }, scheduledExecutorService);

    return promise;
}

---

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  w  w  w.  j  a  v a2s . c  om*/
        public void onSuccess(Void result) {
            LOG.debug("Delete result: " + result);
        }

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

---

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);/*from w w w.ja v a  2  s .  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();
        }
    });
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• »