Example usage for com.google.common.util.concurrent JdkFutureAdapters listenInPoolThread

Introduction

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

Prototype

public static <V> ListenableFuture<V> listenInPoolThread(Future<V> future, Executor executor) 

Source Link

Document

Submits a blocking task for the given Future to provide ListenableFuture functionality.

Usage

From source file:org.opendaylight.infrautils.utils.concurrent.JdkFutures.java

/**
 * Converts a Java 5 {@link Future} to a Guava {@link ListenableFuture}.
 *
 * <p>See also Guava's {@link JdkFutureAdapters} utility, which is used internally here
 *     (with an Executor that would log any possible issues, and which will be metric monitored).
 *//*from ww  w  .ja  va2  s  . co  m*/
public static <V> ListenableFuture<V> toListenableFuture(Future<V> future) {
    return JdkFutureAdapters.listenInPoolThread(future, DEFAULT_EXECUTOR);
}

---

From source file:org.opendaylight.infrautils.utils.concurrent.JdkFutures.java

/**
 * Converts a Java 5 {@link Future} to a Guava {@link ListenableFuture}, using your own Executor.
 *
 * <p>It's typically a bad idea to pass a directExector here, because then the
 * {@link ListenableFuture#addListener(Runnable, Executor)} will become blocking
 * and one might as well just use the Future's blocking get() instead of this.
 *//*from ww  w  .  j  av a  2 s. co  m*/
public static <V> ListenableFuture<V> toListenableFuture(Future<V> future, Executor executor) {
    return JdkFutureAdapters.listenInPoolThread(future, executor);
}

---

From source file:xyz.cloudbans.bukkit.command.UnbanCommand.java

@Override
public boolean onCommand(final CommandSender sender, Command command, String label, final String[] args) {
    // unban <player> <reason>
    if (!sender.hasPermission("cloudbans.ban.unban")) {
        sender.sendMessage(ChatColor.RED + "You don't have enough permissions for that.");
        return true;
    }//www.  j  a  v a  2 s.c  om

    if (args.length < 1) {
        sender.sendMessage(ChatColor.RED + "Your missing arguments for this command.");
        return false;
    }

    if (sender instanceof BlockCommandSender) {
        sender.sendMessage(ChatColor.RED
                + "For security reasons this command can only executed by a player or the console!");
        return true;
    }

    Future<BanResponse> future = client.getActiveBan(config.getServerUuid(), args[0]);
    Futures.addCallback(JdkFutureAdapters.listenInPoolThread(future, executor),
            new FutureCallback<BanResponse>() {
                @Override
                public void onSuccess(BanResponse result) {
                    BanRequestBuilder builder = new BanRequestBuilder();
                    builder.setId(result.getBan().getId());
                    if (args.length > 2) {
                        String[] reason = Arrays.copyOfRange(args, 2, args.length);
                        String unbanReason = Joiner.on(" ").join(reason);
                        builder.setDescription(result.getBan().getDescription() + " Unban: " + unbanReason);
                    }
                    builder.setEnabled(false);
                    BanRequest request = builder.build();
                    Future<BanResponse> unbanResponseFuture = client.updateBan(request);
                    Futures.addCallback(JdkFutureAdapters.listenInPoolThread(unbanResponseFuture, executor),
                            new FutureCallback<BanResponse>() {
                                @Override
                                public void onSuccess(BanResponse result) {
                                    switch (result.getBan().getDelayState()) {
                                    case EXECUTED:
                                        sender.sendMessage(ChatColor.GREEN + "Unban executed");
                                        break;
                                    case QUEUED:
                                        sender.sendMessage(ChatColor.GREEN + "Unban will be executed soon.");
                                        break;
                                    }
                                }

                                @Override
                                public void onFailure(Throwable t) {
                                    sender.sendMessage(ChatColor.RED + "Unban was not executed successfully.");
                                    LOGGER.log(Level.SEVERE, "An error occurred while executing unban request.",
                                            t);
                                }
                            });
                }

                @Override
                public void onFailure(Throwable t) {

                }
            });
    return true;
}

---

From source file:org.opendaylight.controller.sample.kitchen.impl.KitchenServiceImpl.java

@Override
public Future<RpcResult<Void>> makeBreakfast(EggsType eggsType, Class<? extends ToastType> toastType,
        int toastDoneness) {

    // Call makeToast and use JdkFutureAdapters to convert the Future to a ListenableFuture,
    // The OpendaylightToaster impl already returns a ListenableFuture so the conversion is
    // actually a no-op.

    ListenableFuture<RpcResult<Void>> makeToastFuture = JdkFutureAdapters
            .listenInPoolThread(makeToast(toastType, toastDoneness), executor);

    ListenableFuture<RpcResult<Void>> makeEggsFuture = makeEggs(eggsType);

    // Combine the 2 ListenableFutures into 1 containing a list of RpcResults.

    ListenableFuture<List<RpcResult<Void>>> combinedFutures = Futures
            .allAsList(ImmutableList.of(makeToastFuture, makeEggsFuture));

    // Then transform the RpcResults into 1.

    return Futures.transform(combinedFutures, new AsyncFunction<List<RpcResult<Void>>, RpcResult<Void>>() {
        @Override// www  .  ja v a  2  s.  c  om
        public ListenableFuture<RpcResult<Void>> apply(List<RpcResult<Void>> results) throws Exception {
            boolean atLeastOneSucceeded = false;
            Builder<RpcError> errorList = ImmutableList.builder();
            for (RpcResult<Void> result : results) {
                if (result.isSuccessful()) {
                    atLeastOneSucceeded = true;
                }

                if (result.getErrors() != null) {
                    errorList.addAll(result.getErrors());
                }
            }

            return Futures.immediateFuture(RpcResultBuilder.<Void>status(atLeastOneSucceeded)
                    .withRpcErrors(errorList.build()).build());
        }
    });
}

---

From source file:xyz.cloudbans.bukkit.command.BanCommand.java

@Override
public boolean onCommand(final CommandSender sender, Command command, String label, String[] args) {
    // /ban <player> <reason>
    if (!sender.hasPermission("cloudbans.ban.ban")) {
        sender.sendMessage(ChatColor.RED + "You don't have enough permissions for that.");
        return true;
    }/*from  w  ww  . j av  a2  s .  c  o m*/

    if (args.length < 2) {
        sender.sendMessage(ChatColor.RED + "Your missing arguments for this command.");
        return false;
    }

    if (sender instanceof BlockCommandSender) {
        sender.sendMessage(ChatColor.RED
                + "For security reasons this command can only executed by a player or the console!");
        return true;
    }

    BanRequestBuilder builder = new BanRequestBuilder();
    builder.setServer(config.getServerUuid());

    if (args.length > 1) {
        String[] reason = Arrays.copyOfRange(args, 1, args.length);
        String finalReason = Joiner.on(" ").join(reason);
        builder.setDescription(finalReason);
    }

    if (sender instanceof Player) {
        builder.setIssuer(((Player) sender).getUniqueId());
    }

    BanRequest request = builder.build();
    CommandUtils.parseTarget(request, args[0]);

    Future<BanResponse> future = client.createBan(request);
    Futures.addCallback(JdkFutureAdapters.listenInPoolThread(future, executor),
            new FutureCallback<BanResponse>() {
                @Override
                public void onSuccess(BanResponse result) {
                    switch (result.getBan().getDelayState()) {
                    case EXECUTED:
                        sender.sendMessage(ChatColor.GREEN + "Ban executed");
                        break;
                    case QUEUED:
                        sender.sendMessage(ChatColor.GREEN + "Ban will be executed soon.");
                        break;
                    }
                }

                @Override
                public void onFailure(Throwable t) {
                    sender.sendMessage(ChatColor.RED + "Ban was not executed successfully.");
                    LOGGER.log(Level.SEVERE, "An error occurred while executing ban request.", t);
                }
            });
    return true;
}

---

From source file:xyz.cloudbans.bukkit.command.NoticeCommand.java

@Override
public boolean onCommand(final CommandSender sender, Command command, String label, String[] args) {
    // /notice <player> <notice>
    if (!sender.hasPermission("cloudbans.notice.notice")) {
        sender.sendMessage(ChatColor.RED + "You don't have enough permissions for that.");
        return true;
    }/*  w ww .  j  a va 2s  .  c  o m*/

    if (args.length < 2) {
        sender.sendMessage(ChatColor.RED + "Your missing arguments for this command.");
        return false;
    }

    if (sender instanceof BlockCommandSender) {
        sender.sendMessage(ChatColor.RED
                + "For security reasons this command can only executed by a player or the console!");
        return true;
    }

    NoticeRequestBuilder builder = new NoticeRequestBuilder();
    builder.setServer(config.getServerUuid());

    if (args.length > 1) {
        String[] notice = Arrays.copyOfRange(args, 1, args.length);
        String finalNotice = Joiner.on(" ").join(notice);
        builder.setNotice(finalNotice);
    }

    if (sender instanceof Player) {
        builder.setIssuer(((Player) sender).getUniqueId());
    }

    final NoticeRequest request = builder.build();
    CommandUtils.parseTarget(request, args[0]);

    Future<NoticeResponse> future = client.createNotice(request);
    Futures.addCallback(JdkFutureAdapters.listenInPoolThread(future, executor),
            new FutureCallback<NoticeResponse>() {
                @Override
                public void onSuccess(NoticeResponse result) {
                    switch (result.getNotice().getDelayState()) {
                    case EXECUTED:
                        sender.sendMessage(ChatColor.GREEN + "Notice executed");
                        break;
                    case QUEUED:
                        sender.sendMessage(ChatColor.GREEN + "Notice will be executed soon.");
                        break;
                    }
                }

                @Override
                public void onFailure(Throwable t) {
                    sender.sendMessage(ChatColor.RED + "Notice was not executed successfully.");
                    LOGGER.log(Level.SEVERE, "An error occured while executing notice request.", t);
                }
            });
    return true;
}

---

From source file:xyz.cloudbans.bukkit.command.TempNoticeCommand.java

@Override
public boolean onCommand(final CommandSender sender, Command command, String label, String[] args) {
    // /tempnotice <player> <duration> <notice>
    if (!sender.hasPermission("cloudbans.notice.tempnotice")) {
        sender.sendMessage(ChatColor.RED + "You don't have enough permissions for that.");
        return true;
    }//from   w  ww .j a v  a  2s. c o m

    if (args.length < 2) {
        sender.sendMessage(ChatColor.RED + "Your missing arguments for this command.");
        return false;
    }

    if (sender instanceof BlockCommandSender) {
        sender.sendMessage(ChatColor.RED
                + "For security reasons this command can only executed by a player or the console!");
        return true;
    }

    NoticeRequestBuilder builder = new NoticeRequestBuilder();
    builder.setServer(config.getServerUuid());

    if (args.length > 2) {
        String[] notice = Arrays.copyOfRange(args, 2, args.length);
        String finalNotice = Joiner.on(" ").join(notice);
        builder.setNotice(finalNotice);
    }

    if (sender instanceof Player) {
        builder.setIssuer(((Player) sender).getUniqueId());
    }

    final NoticeRequest request = builder.build();
    CommandUtils.parseTarget(request, args[0]);

    Future<NoticeResponse> future = client.createNotice(request);
    Futures.addCallback(JdkFutureAdapters.listenInPoolThread(future, executor),
            new FutureCallback<NoticeResponse>() {
                @Override
                public void onSuccess(NoticeResponse result) {
                    switch (result.getNotice().getDelayState()) {
                    case EXECUTED:
                        sender.sendMessage(ChatColor.GREEN + "Notice executed");
                        break;
                    case QUEUED:
                        sender.sendMessage(ChatColor.GREEN + "Notice will be executed soon.");
                        break;
                    }
                }

                @Override
                public void onFailure(Throwable t) {
                    sender.sendMessage(ChatColor.RED + "Notice was not executed successfully.");
                    LOGGER.log(Level.SEVERE, "An error occured while executing notice request.", t);
                }
            });
    return true;
}

---

From source file:xyz.cloudbans.bukkit.command.TempBanCommand.java

@Override
public boolean onCommand(final CommandSender sender, Command command, String label, String[] args) {
    // /tempban <player> <duration> <reason>
    if (!sender.hasPermission("cloudbans.ban.tempban")) {
        sender.sendMessage(ChatColor.RED + "You don't have enough permissions for that.");
        return true;
    }/*from w w w  .  j a v  a  2s . c o  m*/

    if (args.length < 2) {
        sender.sendMessage(ChatColor.RED + "Your missing arguments for this command.");
        return false;
    }

    if (sender instanceof BlockCommandSender) {
        sender.sendMessage(ChatColor.RED
                + "For security reasons this command can only executed by a player or the console!");
        return true;
    }

    BanRequestBuilder builder = new BanRequestBuilder();
    builder.setServer(config.getServerUuid());

    if (args.length > 2) {
        String[] reason = Arrays.copyOfRange(args, 2, args.length);
        String finalReason = Joiner.on(" ").join(reason);
        builder.setDescription(finalReason);
    }

    if (sender instanceof Player) {
        builder.setIssuer(((Player) sender).getUniqueId());
    }

    try {
        builder.setValidUntil(TimeParser.addToNow(args[1]));
    } catch (NumberFormatException exception) {
        sender.sendMessage(ChatColor.RED + "The given time is invalid.");
    }

    BanRequest request = builder.build();
    CommandUtils.parseTarget(request, args[0]);

    Future<BanResponse> future = client.createBan(request);
    Futures.addCallback(JdkFutureAdapters.listenInPoolThread(future, executor),
            new FutureCallback<BanResponse>() {
                @Override
                public void onSuccess(BanResponse result) {
                    switch (result.getBan().getDelayState()) {
                    case EXECUTED:
                        sender.sendMessage(ChatColor.GREEN + "Ban executed");
                        break;
                    case QUEUED:
                        sender.sendMessage(ChatColor.GREEN + "Ban will be executed soon.");
                        break;
                    }
                }

                @Override
                public void onFailure(Throwable t) {
                    sender.sendMessage(ChatColor.RED + "Ban was not executed successfully.");
                    LOGGER.log(Level.SEVERE, "An error occurred while executing ban request.", t);
                }
            });
    return true;
}

---

From source file:org.opendaylight.genius.arputil.internal.ArpUtilImpl.java

@Override
public Future<RpcResult<GetMacOutput>> getMac(GetMacInput input) {
    try {//from   w  ww .  j  a  v a  2s .com
        final String dstIpAddress = getIpAddressInString(input.getIpaddress());
        LOG.trace("getMac rpc invoked for ip {}", dstIpAddress);
        if (macAddrs.get(dstIpAddress) != null) {
            if (LOG.isInfoEnabled()) {
                LOG.info("get mac already in progress for the ip {}", dstIpAddress);
            }
            return macAddrs.get(dstIpAddress);
        }
        SendArpRequestInputBuilder builder = new SendArpRequestInputBuilder()
                .setInterfaceAddress(input.getInterfaceAddress()).setIpaddress(input.getIpaddress());
        Future<RpcResult<Void>> arpReqFt = sendArpRequest(builder.build());
        final SettableFuture<RpcResult<GetMacOutput>> ft = SettableFuture.create();

        Futures.addCallback(JdkFutureAdapters.listenInPoolThread(arpReqFt, threadPool),
                new FutureCallback<RpcResult<Void>>() {
                    @Override
                    public void onFailure(Throwable ex) {
                        RpcResultBuilder<GetMacOutput> resultBuilder = RpcResultBuilder.<GetMacOutput>failed()
                                .withError(ErrorType.APPLICATION, ex.getMessage(), ex);
                        ft.set(resultBuilder.build());
                    }

                    @Override
                    public void onSuccess(RpcResult<Void> result) {
                        LOG.trace("Successfully sent the arp pkt out for ip {}", dstIpAddress);
                    }
                });

        macAddrs.put(dstIpAddress, ft);
        return ft;
    } catch (UnknownHostException e) {
        LOG.error("Failed to handle getMac request for {}", input.getIpaddress(), e);
        RpcResultBuilder<GetMacOutput> resultBuilder = RpcResultBuilder.<GetMacOutput>failed()
                .withError(ErrorType.APPLICATION, e.getMessage(), e);
        return Futures.immediateFuture(resultBuilder.build());
    }
}

---

From source file:org.opendaylight.vpnservice.arputil.internal.ArpUtilImpl.java

public Future<RpcResult<GetMacOutput>> getMac(GetMacInput input) {

    try {/*from w ww  .  ja  v  a  2  s.c o  m*/
        final String dstIpAddress = getIpAddressInString(input.getIpaddress());
        if (LOGGER.isTraceEnabled()) {
            LOGGER.trace("getMac rpc invoked for ip " + dstIpAddress);
        }
        if (getMacFutures.get(dstIpAddress) != null) {
            if (LOGGER.isInfoEnabled()) {
                LOGGER.info("get mac already in progress for the ip " + dstIpAddress);
            }
            return getMacFutures.get(dstIpAddress);
        }
        SendArpRequestInputBuilder builder = new SendArpRequestInputBuilder()
                .setInterfaceAddress(input.getInterfaceAddress()).setIpaddress(input.getIpaddress());
        Future<RpcResult<Void>> arpReqFt = sendArpRequest(builder.build());
        final SettableFuture<RpcResult<GetMacOutput>> ft = SettableFuture.create();

        Futures.addCallback(JdkFutureAdapters.listenInPoolThread(arpReqFt, threadPool),
                new FutureCallback<RpcResult<Void>>() {
                    @Override
                    public void onFailure(Throwable e) {
                        RpcResultBuilder<GetMacOutput> resultBuilder = RpcResultBuilder.<GetMacOutput>failed()
                                .withError(ErrorType.APPLICATION, e.getMessage(), e);
                        ft.set(resultBuilder.build());
                    }

                    @Override
                    public void onSuccess(RpcResult<Void> result) {
                        LOGGER.trace("Successfully sent the arp pkt out for ip " + dstIpAddress);
                    }
                });

        getMacFutures.put(dstIpAddress, ft);
        return ft;
    } catch (Exception e) {
        LOGGER.trace("failed to handle getMac request for {} {}", input.getIpaddress(), e);
        RpcResultBuilder<GetMacOutput> resultBuilder = RpcResultBuilder.<GetMacOutput>failed()
                .withError(ErrorType.APPLICATION, e.getMessage(), e);
        return Futures.immediateFuture(resultBuilder.build());
    }
}

---