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

List of usage examples for com.google.common.util.concurrent AsyncFunction AsyncFunction

Introduction

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

Prototype

AsyncFunction

Source Link

Usage

From source file:org.opendaylight.centinel.impl.CentinelAlertConditionImpl.java

@Override
public Future<RpcResult<DeleteAlertFieldContentRuleOutput>> deleteAlertFieldContentRule(
        DeleteAlertFieldContentRuleInput input) {
    final ReadWriteTransaction tx = dataProvider.newReadWriteTransaction();
    final SettableFuture<RpcResult<DeleteAlertFieldContentRuleOutput>> futureResult = SettableFuture.create();
    boolean idMatches = false;
    if (input.getStreamID() == null || input.getStreamID().isEmpty() || input.getStreamID().trim().isEmpty()
            || input.getRuleID() == null || input.getRuleID().isEmpty() || input.getRuleID().trim().isEmpty()) {
        LOG.debug("Invalid Parameters for DeleteAlertFieldContentRule");
        return Futures.immediateFailedCheckedFuture(
                new TransactionCommitFailedException("inalid-input", RpcResultBuilder.newError(
                        ErrorType.APPLICATION, "invalid-input", "StreamId and RuleId are mandatory fields")));
    }// www  .ja v  a 2 s.  c o  m
    final DeleteAlertFieldContentRuleOutputBuilder deleteAlertFieldContentRuleOutputBuilder = new DeleteAlertFieldContentRuleOutputBuilder();
    deleteAlertFieldContentRuleOutputBuilder.setFieldContentBacklog(input.getFieldContentBacklog());
    deleteAlertFieldContentRuleOutputBuilder
            .setFieldContentCompareToValue(input.getFieldContentCompareToValue());
    deleteAlertFieldContentRuleOutputBuilder.setFieldContentField(input.getFieldContentField());
    deleteAlertFieldContentRuleOutputBuilder.setFieldContentGrace(input.getFieldContentGrace());
    deleteAlertFieldContentRuleOutputBuilder.setRuleTypeClassifier(input.getRuleTypeClassifier());
    deleteAlertFieldContentRuleOutputBuilder.setRuleID(input.getRuleID());
    deleteAlertFieldContentRuleOutputBuilder.setNodeType(input.getNodeType());
    deleteAlertFieldContentRuleOutputBuilder.setStreamID(input.getStreamID());
    deleteAlertFieldContentRuleOutputBuilder.setTimeStamp(input.getTimeStamp());
    deleteAlertFieldContentRuleOutputBuilder.setAlertTypeClassifier(input.getAlertTypeClassifier());
    deleteAlertFieldContentRuleOutputBuilder.setAlertName(input.getAlertName());
    deleteAlertFieldContentRuleOutputBuilder.setConfigID(input.getConfigID());

    ListenableFuture<Optional<AlertFieldContentRuleRecord>> readFutureOperational = tx
            .read(LogicalDatastoreType.OPERATIONAL, alertFeildContentRuleRecordId);

    ListenableFuture<Optional<AlertFieldContentRuleRecord>> readFutureConfigure = tx
            .read(LogicalDatastoreType.CONFIGURATION, alertFeildContentRuleRecordId);

    String configId = null;

    try {

        Optional<AlertFieldContentRuleRecord> record = readFutureOperational.get();
        if (record.isPresent()) {
            AlertFieldContentRuleRecord operationalRecord = readFutureOperational.get().get();
            List<StreamAlertFieldContentRuleList> streamAlertRuleList = new ArrayList<StreamAlertFieldContentRuleList>();

            if (!operationalRecord.getStreamAlertFieldContentRuleList().isEmpty()) {

                streamAlertRuleList = operationalRecord.getStreamAlertFieldContentRuleList();
                Iterator<StreamAlertFieldContentRuleList> itearator = streamAlertRuleList.iterator();

                StreamAlertFieldContentRuleList operationalObject = null;

                while (itearator.hasNext()) {

                    operationalObject = itearator.next();
                    if (operationalObject.getRuleID().equalsIgnoreCase(input.getRuleID())
                            && operationalObject.getStreamID().equalsIgnoreCase(input.getStreamID())) {

                        configId = operationalObject.getConfigID();
                        idMatches = true;

                    }
                }
                if (!idMatches) {
                    return Futures.immediateFailedCheckedFuture(new TransactionCommitFailedException(
                            "invalid-input", RpcResultBuilder.newError(ErrorType.APPLICATION, "invalid-input",
                                    "Invalid Stream/Rule id or The stream/rule is not present in operational data store")));

                }

            }

        } else {
            return Futures.immediateFailedCheckedFuture(new TransactionCommitFailedException("invalid-input",
                    RpcResultBuilder.newError(ErrorType.APPLICATION, "invalid-input",
                            "Record is not present in operational data store")));
        }
    } catch (InterruptedException | ExecutionException e) {

        futureResult.set(RpcResultBuilder.<DeleteAlertFieldContentRuleOutput>failed()
                .withRpcErrors(((TransactionCommitFailedException) e).getErrorList()).build());
        return futureResult;

    }
    final String configID = configId;
    final ListenableFuture<Void> commitFuture = Futures.transform(readFutureConfigure,
            new AsyncFunction<Optional<AlertFieldContentRuleRecord>, Void>() {

                @Override
                public ListenableFuture<Void> apply(
                        final Optional<AlertFieldContentRuleRecord> alertFieldContentRuleRecord)
                        throws Exception {

                    List<StreamAlertFieldContentRuleList> streamAlertRuleList = new ArrayList<StreamAlertFieldContentRuleList>();

                    if (alertFieldContentRuleRecord.isPresent()) {

                        streamAlertRuleList = alertFieldContentRuleRecord.get()
                                .getStreamAlertFieldContentRuleList();
                        StreamAlertFieldContentRuleList configObject = null;
                        Iterator<StreamAlertFieldContentRuleList> iterator = streamAlertRuleList.iterator();

                        while (iterator.hasNext()) {

                            configObject = iterator.next();

                            if (configObject.getConfigID().equalsIgnoreCase(configID)) {

                                tx.delete(LogicalDatastoreType.CONFIGURATION, alertFeildContentRuleRecordId
                                        .child(StreamAlertFieldContentRuleList.class, configObject.getKey()));

                            }
                        }

                    }

                    return tx.submit();
                }

            });
    Futures.addCallback(commitFuture, new FutureCallback<Void>() {
        @Override
        public void onSuccess(final Void result) {

            futureResult.set(RpcResultBuilder.<DeleteAlertFieldContentRuleOutput>success(
                    deleteAlertFieldContentRuleOutputBuilder.build()).build());
        }

        @Override
        public void onFailure(final Throwable ex) {

            LOG.info("Failed to commit Rule", ex);

            futureResult.set(RpcResultBuilder.<DeleteAlertFieldContentRuleOutput>failed()
                    .withRpcErrors(((TransactionCommitFailedException) ex).getErrorList()).build());

        }
    });

    return futureResult;
}

From source file:org.opendaylight.centinel.impl.CentinelAlertConditionImpl.java

@Override
public Future<RpcResult<DeleteAlertFieldValueRuleOutput>> deleteAlertFieldValueRule(
        final DeleteAlertFieldValueRuleInput input) {
    final ReadWriteTransaction tx = dataProvider.newReadWriteTransaction();
    final SettableFuture<RpcResult<DeleteAlertFieldValueRuleOutput>> futureResult = SettableFuture.create();
    boolean idMatches = false;
    if (input.getStreamID() == null || input.getStreamID().isEmpty() || input.getStreamID().trim().isEmpty()
            || input.getRuleID() == null || input.getRuleID().isEmpty() || input.getRuleID().trim().isEmpty()) {
        LOG.debug("Invalid Parameters for DeleteAlertFieldValueRule");
        return Futures.immediateFailedCheckedFuture(
                new TransactionCommitFailedException("inalid-input", RpcResultBuilder.newError(
                        ErrorType.APPLICATION, "invalid-input", "StreamId and RuleId are mandatory fields")));
    }/*w w w .  ja v a 2  s .com*/
    final DeleteAlertFieldValueRuleOutputBuilder deleteAlertFieldValueRuleOutputBuilder = new DeleteAlertFieldValueRuleOutputBuilder();
    deleteAlertFieldValueRuleOutputBuilder
            .setStreamID("The alert with this" + input.getStreamID() + "is deleted");

    ListenableFuture<Optional<AlertFieldValueRuleRecord>> readFutureOperational = tx
            .read(LogicalDatastoreType.OPERATIONAL, alertFieldValueRuleRecordId);

    ListenableFuture<Optional<AlertFieldValueRuleRecord>> readFutureConfigure = tx
            .read(LogicalDatastoreType.CONFIGURATION, alertFieldValueRuleRecordId);

    String configId = null;

    try {
        Optional<AlertFieldValueRuleRecord> record = readFutureOperational.get();
        if (record.isPresent()) {
            AlertFieldValueRuleRecord operationalRecord = readFutureOperational.get().get();
            List<StreamAlertFieldValueRuleList> streamAlertRuleList = new ArrayList<StreamAlertFieldValueRuleList>();

            if (!operationalRecord.getStreamAlertFieldValueRuleList().isEmpty()) {
                streamAlertRuleList = operationalRecord.getStreamAlertFieldValueRuleList();
                Iterator<StreamAlertFieldValueRuleList> itearator = streamAlertRuleList.iterator();
                StreamAlertFieldValueRuleList operationalObject = null;

                while (itearator.hasNext()) {
                    operationalObject = itearator.next();
                    if (operationalObject.getRuleID().equalsIgnoreCase(input.getRuleID())
                            && operationalObject.getStreamID().equalsIgnoreCase(input.getStreamID())) {
                        configId = operationalObject.getConfigID();
                        idMatches = true;

                    }
                }
                if (!idMatches) {
                    return Futures.immediateFailedCheckedFuture(new TransactionCommitFailedException(
                            "invalid-input", RpcResultBuilder.newError(ErrorType.APPLICATION, "invalid-input",
                                    "Invalid Stream/Rule id or The stream/rule is not present in operational data store")));

                }

            }

        } else {
            return Futures.immediateFailedCheckedFuture(new TransactionCommitFailedException("invalid-input",
                    RpcResultBuilder.newError(ErrorType.APPLICATION, "invalid-input",
                            "Record is not present in operational data store")));
        }
    } catch (InterruptedException | ExecutionException e) {
        deleteAlertFieldValueRuleOutputBuilder
                .setStreamID("The alert with this" + input.getStreamID() + "is not present");
        futureResult.set(RpcResultBuilder.<DeleteAlertFieldValueRuleOutput>failed()
                .withRpcErrors(((TransactionCommitFailedException) e).getErrorList()).build());
        return futureResult;

    }
    final String configID = configId;
    final ListenableFuture<Void> commitFuture = Futures.transform(readFutureConfigure,
            new AsyncFunction<Optional<AlertFieldValueRuleRecord>, Void>() {

                @Override
                public ListenableFuture<Void> apply(
                        final Optional<AlertFieldValueRuleRecord> alertFieldValueRuleRecord) throws Exception {

                    List<StreamAlertFieldValueRuleList> streamAlertRuleList = new ArrayList<StreamAlertFieldValueRuleList>();

                    if (alertFieldValueRuleRecord.isPresent()) {

                        streamAlertRuleList = alertFieldValueRuleRecord.get()
                                .getStreamAlertFieldValueRuleList();
                        StreamAlertFieldValueRuleList configObject = null;
                        Iterator<StreamAlertFieldValueRuleList> iterator = streamAlertRuleList.iterator();
                        while (iterator.hasNext()) {
                            configObject = iterator.next();

                            if (configObject.getConfigID().equalsIgnoreCase(configID)) {

                                tx.delete(LogicalDatastoreType.CONFIGURATION, alertFieldValueRuleRecordId
                                        .child(StreamAlertFieldValueRuleList.class, configObject.getKey()));

                            }
                        }

                    }

                    return tx.submit();
                }

            });
    Futures.addCallback(commitFuture, new FutureCallback<Void>() {

        @Override
        public void onSuccess(final Void result) {

            futureResult.set(RpcResultBuilder
                    .<DeleteAlertFieldValueRuleOutput>success(deleteAlertFieldValueRuleOutputBuilder.build())
                    .build());
        }

        @Override
        public void onFailure(final Throwable ex) {

            LOG.info("Failed to commit Rule", ex);

            futureResult.set(RpcResultBuilder.<DeleteAlertFieldValueRuleOutput>failed()
                    .withRpcErrors(((TransactionCommitFailedException) ex).getErrorList()).build());

        }
    });

    return futureResult;
}

From source file:org.apache.qpid.server.virtualhost.AbstractVirtualHost.java

@StateTransition(currentState = { State.STOPPED }, desiredState = State.ACTIVE)
private ListenableFuture<Void> onRestart() {
    resetStatistics();//from  ww w  . j  a  va  2  s  .  c o m
    createHousekeepingExecutor();

    final List<ConfiguredObjectRecord> records = new ArrayList<>();

    // Transitioning to STOPPED will have closed all our children.  Now we are transition
    // back to ACTIVE, we need to recover and re-open them.

    getDurableConfigurationStore().reload(new ConfiguredObjectRecordHandler() {

        @Override
        public void handle(final ConfiguredObjectRecord record) {
            records.add(record);
        }

    });

    new GenericRecoverer(this).recover(records, false);

    final List<ListenableFuture<Void>> childOpenFutures = new ArrayList<>();

    Subject.doAs(getSubjectWithAddedSystemRights(), new PrivilegedAction<Object>() {
        @Override
        public Object run() {
            applyToChildren(new Action<ConfiguredObject<?>>() {
                @Override
                public void performAction(final ConfiguredObject<?> child) {
                    final ListenableFuture<Void> childOpenFuture = child.openAsync();
                    childOpenFutures.add(childOpenFuture);

                    addFutureCallback(childOpenFuture, new FutureCallback<Void>() {
                        @Override
                        public void onSuccess(final Void result) {
                        }

                        @Override
                        public void onFailure(final Throwable t) {
                            _logger.error("Exception occurred while opening {} : {}",
                                    child.getClass().getSimpleName(), child.getName(), t);
                        }

                    }, getTaskExecutor());
                }
            });
            return null;
        }
    });

    ListenableFuture<List<Void>> combinedFuture = Futures.allAsList(childOpenFutures);
    return Futures.transform(combinedFuture, new AsyncFunction<List<Void>, Void>() {
        @Override
        public ListenableFuture<Void> apply(final List<Void> input) throws Exception {
            return onActivate();
        }
    });
}

From source file:org.opendaylight.vpnservice.natservice.internal.ExternalRoutersListener.java

private void clrRtsFromBgpAndDelFibTs(final BigInteger dpnId, long routerId, String extIp,
        final String vpnName) {
    //Inform BGP about the route removal
    String rd = NatUtil.getVpnRd(dataBroker, vpnName);
    NatUtil.removePrefixFromBGP(bgpManager, rd, extIp, LOG);

    LOG.debug("Removing fib entry for externalIp {} in routerId {}", extIp, routerId);
    //Get IPMaps from the DB for the router ID
    List<IpMap> dbIpMaps = NaptManager.getIpMapList(dataBroker, routerId);
    if (dbIpMaps == null || dbIpMaps.isEmpty()) {
        LOG.error("NAT Service : IPMaps not found for router {}", routerId);
        return;/*from   w w w  . j a  va2 s.  co  m*/
    }

    long tempLabel = NatConstants.INVALID_ID;
    for (IpMap dbIpMap : dbIpMaps) {
        String dbExternalIp = dbIpMap.getExternalIp();
        LOG.debug("Retrieved dbExternalIp {} for router id {}", dbExternalIp, routerId);
        //Select the IPMap, whose external IP is the IP for which FIB is installed
        if (extIp.equals(dbExternalIp)) {
            tempLabel = dbIpMap.getLabel();
            LOG.debug("Retrieved label {} for dbExternalIp {} with router id {}", tempLabel, dbExternalIp,
                    routerId);
            break;
        }
    }
    if (tempLabel < 0 || tempLabel == NatConstants.INVALID_ID) {
        LOG.error("NAT Service : Label not found for externalIp {} with router id {}", extIp, routerId);
        return;
    }

    final long label = tempLabel;
    final String externalIp = extIp;

    RemoveFibEntryInput input = new RemoveFibEntryInputBuilder().setVpnName(vpnName).setSourceDpid(dpnId)
            .setIpAddress(externalIp).setServiceId(label).build();
    Future<RpcResult<Void>> future = fibService.removeFibEntry(input);

    ListenableFuture<RpcResult<Void>> labelFuture = Futures.transform(
            JdkFutureAdapters.listenInPoolThread(future),
            new AsyncFunction<RpcResult<Void>, RpcResult<Void>>() {

                @Override
                public ListenableFuture<RpcResult<Void>> apply(RpcResult<Void> result) throws Exception {
                    //Release label
                    if (result.isSuccessful()) {
                        removeTunnelTableEntry(dpnId, label);
                        removeLFibTableEntry(dpnId, label);
                        RemoveVpnLabelInput labelInput = new RemoveVpnLabelInputBuilder().setVpnName(vpnName)
                                .setIpPrefix(externalIp).build();
                        Future<RpcResult<Void>> labelFuture = vpnService.removeVpnLabel(labelInput);
                        return JdkFutureAdapters.listenInPoolThread(labelFuture);
                    } else {
                        String errMsg = String.format(
                                "RPC call to remove custom FIB entries on dpn %s for prefix %s Failed - %s",
                                dpnId, externalIp, result.getErrors());
                        LOG.error(errMsg);
                        return Futures.immediateFailedFuture(new RuntimeException(errMsg));
                    }
                }

            });

    Futures.addCallback(labelFuture, new FutureCallback<RpcResult<Void>>() {

        @Override
        public void onFailure(Throwable error) {
            LOG.error("NAT Service : Error in removing the label or custom fib entries", error);
        }

        @Override
        public void onSuccess(RpcResult<Void> result) {
            if (result.isSuccessful()) {
                LOG.debug("NAT Service : Successfully removed the label for the prefix {} from VPN {}",
                        externalIp, vpnName);
            } else {
                LOG.error("NAT Service : Error in removing the label for prefix {} from VPN {}, {}", externalIp,
                        vpnName, result.getErrors());
            }
        }
    });
}