Example usage for com.google.common.util.concurrent CheckedFuture checkedGet

List of usage examples for com.google.common.util.concurrent CheckedFuture checkedGet

Introduction

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

Prototype

V checkedGet() throws X;

Source Link

Document

Exception checking version of Future#get() that will translate InterruptedException , CancellationException and ExecutionException into application-specific exceptions.

Usage

From source file:com.google.gerrit.server.git.ReceiveCommits.java

private void readChangesForReplace() throws OrmException {
    List<CheckedFuture<Change, OrmException>> futures = Lists.newArrayListWithCapacity(replaceByChange.size());
    for (ReplaceRequest request : replaceByChange.values()) {
        futures.add(db.changes().getAsync(request.ontoChange));
    }/*from   w  ww  . ja  v  a 2  s  .  c o m*/
    for (CheckedFuture<Change, OrmException> f : futures) {
        Change c = f.checkedGet();
        if (c != null) {
            replaceByChange.get(c.getId()).change = c;
        }
    }
}

From source file:com.google.gerrit.server.git.ReceiveCommits.java

private void insertChangesAndPatchSets() {
    int replaceCount = 0;
    int okToInsert = 0;

    for (Map.Entry<Change.Id, ReplaceRequest> e : replaceByChange.entrySet()) {
        ReplaceRequest replace = e.getValue();
        if (magicBranch != null && replace.inputCommand == magicBranch.cmd) {
            replaceCount++;//from w  ww .  j a  va 2 s  . c o m

            if (replace.cmd != null && replace.cmd.getResult() == OK) {
                okToInsert++;
            }
        } else if (replace.cmd != null && replace.cmd.getResult() == OK) {
            try {
                if (replace.insertPatchSet().checkedGet() != null) {
                    replace.inputCommand.setResult(OK);
                }
            } catch (IOException err) {
                reject(replace.inputCommand, "internal server error");
                log.error(
                        String.format("Cannot add patch set to %d of %s", e.getKey().get(), project.getName()),
                        err);
            } catch (OrmException err) {
                reject(replace.inputCommand, "internal server error");
                log.error(
                        String.format("Cannot add patch set to %d of %s", e.getKey().get(), project.getName()),
                        err);
            }
        } else if (replace.inputCommand.getResult() == NOT_ATTEMPTED) {
            reject(replace.inputCommand, "internal server error");
        }
    }

    if (magicBranch == null || magicBranch.cmd.getResult() != NOT_ATTEMPTED) {
        // refs/for/ or refs/drafts/ not used, or it already failed earlier.
        // No need to continue.
        return;
    }

    for (CreateRequest create : newChanges) {
        if (create.cmd.getResult() == OK) {
            okToInsert++;
        }
    }

    if (okToInsert != replaceCount + newChanges.size()) {
        // One or more new references failed to create. Assume the
        // system isn't working correctly anymore and abort.
        reject(magicBranch.cmd, "internal server error");
        log.error(String.format("Only %d of %d new change refs created in %s; aborting", okToInsert,
                replaceCount + newChanges.size(), project.getName()));
        return;
    }

    try {
        List<CheckedFuture<?, OrmException>> futures = Lists.newArrayList();
        for (ReplaceRequest replace : replaceByChange.values()) {
            if (magicBranch != null && replace.inputCommand == magicBranch.cmd) {
                futures.add(replace.insertPatchSet());
            }
        }

        for (CreateRequest create : newChanges) {
            futures.add(create.insertChange());
        }

        for (CheckedFuture<?, OrmException> f : futures) {
            f.checkedGet();
        }
        magicBranch.cmd.setResult(OK);
    } catch (OrmException err) {
        log.error("Can't insert changes for " + project.getName(), err);
        reject(magicBranch.cmd, "internal server error");
    } catch (IOException err) {
        log.error("Can't read commits for " + project.getName(), err);
        reject(magicBranch.cmd, "internal server error");
    }
}

From source file:org.opendaylight.netvirt.elan.utils.ElanUtils.java

public <T extends DataObject> Optional<T> read2(LogicalDatastoreType datastoreType, InstanceIdentifier<T> path)
        throws ReadFailedException {
    try (ReadOnlyTransaction tx = broker.newReadOnlyTransaction()) {
        CheckedFuture<Optional<T>, ReadFailedException> checkedFuture = tx.read(datastoreType, path);
        return checkedFuture.checkedGet();
    }/*www.j a  v a2 s . c  om*/
}

From source file:org.opendaylight.distributed.tx.it.provider.DistributedTxProviderImpl.java

/**
 * DTx mixed providers integration test/*from   w ww  . j  a  v  a  2  s .c  o  m*/
 * normal test: DTx can write to netconf and datastore nodes at the same time
 * rollback-on-failure test: DTx can rollback on netconf and datastore nodes when submit fails
 * rollback: DTx can rollback manually before submit
 */
@Override
public Future<RpcResult<MixedProviderTestOutput>> mixedProviderTest(MixedProviderTestInput input) {
    int putsPerTx = input.getPutsPerTx();
    int innerElements = input.getNumberOfTxs(), outerElements = 1; //Test data for mixed providers test only has one outerList
    int counter = 0;
    boolean testSucceed = true;
    OperationType operation = input.getOperation();

    Map<DTXLogicalTXProviderType, Set<InstanceIdentifier<?>>> nodesMap = new HashMap<>();

    //Get netconf nodeId set
    List<NodeId> nodeIdList = new ArrayList(nodeIdSet);
    Set<InstanceIdentifier<?>> netconfNodeIdSet = new HashSet<>();
    NodeId nodeId = nodeIdList.get(0);
    InstanceIdentifier netconfNodeId = NETCONF_TOPO_IID.child(Node.class, new NodeKey(nodeId));
    InstanceIdentifier<InterfaceConfigurations> netconfIid = InstanceIdentifier
            .create(InterfaceConfigurations.class);
    netconfNodeIdSet.add(netconfNodeId);

    //Get datastore nodeId set
    Set<InstanceIdentifier<?>> dataStoreNodeIdSet = new HashSet<>();
    InstanceIdentifier<DatastoreTestData> dsNodeId = InstanceIdentifier.create(DatastoreTestData.class);
    dataStoreNodeIdSet.add(dsNodeId);

    nodesMap.put(DTXLogicalTXProviderType.DATASTORE_TX_PROVIDER, dataStoreNodeIdSet);
    nodesMap.put(DTXLogicalTXProviderType.NETCONF_TX_PROVIDER, netconfNodeIdSet);

    DataStoreListBuilder dsListBuilder = new DataStoreListBuilder(dataBroker, outerElements, innerElements);
    List<OuterList> outerLists = dsListBuilder.buildOuterList();
    OuterList outerList = outerLists.get(0);
    //Mixed providers test only manipulate one netconf node, get its xrNodeBroker from the map
    DataBroker xrNodeBroker = xrNodeBrokerMap.get(DTXITConstants.XRV_NAME1);

    LOG.info("Start DTx mixed providers test");
    if (mixedProviderTestStatus.compareAndSet(TestStatus.ExecStatus.Idle,
            TestStatus.ExecStatus.Executing) == false) {
        return RpcResultBuilder
                .success(new MixedProviderTestOutputBuilder().setStatus(StatusType.TESTINPROGRESS).build())
                .buildFuture();
    }
    //Initialize datastore for the test
    if (!initializeDataStoreTestData(outerElements)) {
        LOG.info("Can't initialize datastore test data");
        mixedProviderTestStatus.set(TestStatus.ExecStatus.Idle);
        return RpcResultBuilder
                .success(new MixedProviderTestOutputBuilder().setStatus(StatusType.FAILED).build())
                .buildFuture();
    }
    //Delete existing subInterfaces for the test
    deleteInterfaces(xrNodeBroker, input.getNumberOfTxs());

    if (input.getOperation() == OperationType.DELETE) {
        if (!buildTestInterfaces(xrNodeBroker, input.getNumberOfTxs())) {
            LOG.info("Can't build test data for DTx MixedProvider NetConf delete test");
            mixedProviderTestStatus.set(TestStatus.ExecStatus.Idle);
            return RpcResultBuilder
                    .success(new MixedProviderTestOutputBuilder().setStatus(StatusType.FAILED).build())
                    .buildFuture();
        }
        if (!dsListBuilder.buildTestInnerList()) {
            LOG.info("Can't initialize test data for Dtx MixedProvider DataStore delete test");
            mixedProviderTestStatus.set(TestStatus.ExecStatus.Idle);
            return RpcResultBuilder
                    .success(new MixedProviderTestOutputBuilder().setStatus(StatusType.FAILED).build())
                    .buildFuture();
        }
    }

    DTx dtx = dTxProvider.newTx(nodesMap);

    if (input.getType() != TestType.NORMAL) {
        if (input.getType() == TestType.ROLLBACKONFAILURE) {
            LOG.info("Start DTx Mixed Provider RollbackOnFailure test");
            /**
             * DTx write to netconf and datastore nodes
             * one of datastore operations fails for nonexistent parent node
             * DTx submit fails and performs rollback on both netconf and datastore nodes
             * ensure data in nodes is correct after rollback
             */
            int errorOccur = (int) (putsPerTx * Math.random()) + 1;

            InstanceIdentifier<InnerList> errorInnerIid = InstanceIdentifier.create(DatastoreTestData.class)
                    .child(OuterList.class, new OuterListKey(outerElements))
                    .child(InnerList.class, new InnerListKey(0));

            InnerList errorInnerlist = new InnerListBuilder().setKey(new InnerListKey(0))
                    .setValue("Error InnerList").setName(0).build();

            for (int i = 1; i <= input.getNumberOfTxs(); i++) {
                InterfaceName subIfName = new InterfaceName(DTXITConstants.INTERFACE_NAME_PREFIX + i);
                KeyedInstanceIdentifier<InterfaceConfiguration, InterfaceConfigurationKey> specificInterfaceCfgIid = netconfIid
                        .child(InterfaceConfiguration.class, new InterfaceConfigurationKey(
                                new InterfaceActive(DTXITConstants.INTERFACE_ACTIVE), subIfName));
                InterfaceConfigurationBuilder interfaceConfigurationBuilder = new InterfaceConfigurationBuilder();
                interfaceConfigurationBuilder.setInterfaceName(subIfName);
                interfaceConfigurationBuilder.setActive(new InterfaceActive(DTXITConstants.INTERFACE_ACTIVE));
                InterfaceConfiguration config = interfaceConfigurationBuilder.build();

                InnerList innerList = outerList.getInnerList().get(i - 1);
                InstanceIdentifier<InnerList> innerIid = getInstanceIdentifier(outerList, innerList);

                //Write to subInterfaces netconf node
                CheckedFuture<Void, DTxException> netconfWriteFuture = writeData(dtx, operation,
                        DTXLogicalTXProviderType.NETCONF_TX_PROVIDER, LogicalDatastoreType.CONFIGURATION,
                        specificInterfaceCfgIid, netconfNodeId, config);
                //Write to datastore node with data iid
                CheckedFuture<Void, DTxException> dataStoreWriteFuture = writeData(dtx, operation,
                        DTXLogicalTXProviderType.DATASTORE_TX_PROVIDER, LogicalDatastoreType.CONFIGURATION,
                        innerIid, dsNodeId, innerList);

                try {
                    netconfWriteFuture.checkedGet();
                } catch (Exception e) {
                    LOG.trace("Netconf write failed for {}", e.toString());
                }

                try {
                    dataStoreWriteFuture.checkedGet();
                } catch (Exception e) {
                    LOG.trace("Datastore write failed for {}", e.toString());
                }

                counter++;
                if (counter == errorOccur) {
                    dataStoreWriteFuture = writeData(dtx, operation,
                            DTXLogicalTXProviderType.DATASTORE_TX_PROVIDER, LogicalDatastoreType.CONFIGURATION,
                            errorInnerIid, dsNodeId, errorInnerlist);
                    try {
                        dataStoreWriteFuture.checkedGet();
                    } catch (Exception e) {
                        LOG.trace("Datastore write failed for {}", e.toString());
                    }
                }

                if (counter == putsPerTx) {
                    CheckedFuture<Void, TransactionCommitFailedException> submitFuture = dtx.submit();
                    try {
                        submitFuture.checkedGet();
                        testSucceed = false;
                    } catch (TransactionCommitFailedException e) {
                        //Submit fails
                        LOG.trace("Get submit exception {}", e.toString());
                    }
                    counter = 0;
                    dtx = dTxProvider.newTx(nodesMap);
                }
            }
        } else {
            LOG.info("Start DTx Mixed Provider rollback test");
            /**
             * DTx write to netconf and datastore nodes
             * manually rollback all operations
             * ensure data in nodes is correct after rollback
             */
            for (int i = 1; i <= input.getNumberOfTxs(); i++) {
                InterfaceName subIfName = new InterfaceName(DTXITConstants.INTERFACE_NAME_PREFIX + i);
                KeyedInstanceIdentifier<InterfaceConfiguration, InterfaceConfigurationKey> specificInterfaceCfgIid = netconfIid
                        .child(InterfaceConfiguration.class, new InterfaceConfigurationKey(
                                new InterfaceActive(DTXITConstants.INTERFACE_ACTIVE), subIfName));
                InterfaceConfigurationBuilder interfaceConfigurationBuilder = new InterfaceConfigurationBuilder();
                interfaceConfigurationBuilder.setInterfaceName(subIfName);
                interfaceConfigurationBuilder.setActive(new InterfaceActive(DTXITConstants.INTERFACE_ACTIVE));
                InterfaceConfiguration config = interfaceConfigurationBuilder.build();

                InnerList innerList = outerList.getInnerList().get(i - 1);
                InstanceIdentifier<InnerList> innerIid = getInstanceIdentifier(outerList, innerList);
                //Write to subInterfaces of netconf node
                CheckedFuture<Void, DTxException> netconfWriteFuture = writeData(dtx, operation,
                        DTXLogicalTXProviderType.NETCONF_TX_PROVIDER, LogicalDatastoreType.CONFIGURATION,
                        specificInterfaceCfgIid, netconfNodeId, config);
                //Write to datastore node with data iid
                CheckedFuture<Void, DTxException> dataStoreWriteFuture = writeData(dtx, operation,
                        DTXLogicalTXProviderType.DATASTORE_TX_PROVIDER, LogicalDatastoreType.CONFIGURATION,
                        innerIid, dsNodeId, innerList);

                try {
                    netconfWriteFuture.checkedGet();
                } catch (Exception e) {
                    LOG.trace("Netconf write failed for {}", e.toString());
                }

                try {
                    dataStoreWriteFuture.checkedGet();
                } catch (Exception e) {
                    LOG.trace("Datastore write failed for {}", e.toString());
                }

                counter++;

                if (counter == putsPerTx) {
                    //Manually trigger rollback
                    CheckedFuture<Void, DTxException.RollbackFailedException> rollbackFuture = dtx.rollback();
                    try {
                        rollbackFuture.checkedGet();
                    } catch (DTxException.RollbackFailedException e) {
                        LOG.trace("Mixed provider rollback test failed for {}", e.toString());
                        testSucceed = false;
                    }
                    counter = 0;
                    dtx = dTxProvider.newTx(nodesMap);
                }
            }
        }

        CheckedFuture<Void, TransactionCommitFailedException> restSubmitFuture = dtx.submit();
        try {
            restSubmitFuture.checkedGet();
        } catch (TransactionCommitFailedException e) {
            LOG.trace("Get outstanding submit exception {}", e.toString());
        }
        //Check whether rollback succeed
        for (int i = 1; i <= input.getNumberOfTxs(); i++) {
            InterfaceName subIfname = new InterfaceName(DTXITConstants.INTERFACE_NAME_PREFIX + i);
            KeyedInstanceIdentifier<InterfaceConfiguration, InterfaceConfigurationKey> specificInterfaceCfgIid = netconfIid
                    .child(InterfaceConfiguration.class, new InterfaceConfigurationKey(
                            new InterfaceActive(DTXITConstants.INTERFACE_ACTIVE), subIfname));
            InstanceIdentifier<InnerList> innerIid = getInstanceIdentifier(outerList,
                    outerList.getInnerList().get(i - 1));

            ReadOnlyTransaction netconfTransaction = xrNodeBroker.newReadOnlyTransaction(),
                    datastoreTransaction = dataBroker.newReadOnlyTransaction();

            //Read data from netconf node
            CheckedFuture<Optional<InterfaceConfiguration>, ReadFailedException> netconfReadFuture = netconfTransaction
                    .read(LogicalDatastoreType.CONFIGURATION, specificInterfaceCfgIid);
            //Read data from datastore node
            CheckedFuture<Optional<InnerList>, ReadFailedException> datastoreReadFuture = datastoreTransaction
                    .read(LogicalDatastoreType.CONFIGURATION, innerIid);
            Optional<InterfaceConfiguration> netconfResult = Optional.absent();
            Optional<InnerList> datastoreResult = Optional.absent();

            try {
                netconfResult = netconfReadFuture.checkedGet();
            } catch (ReadFailedException e) {
                LOG.trace("Can't read the data from netconf device");
                testSucceed = false;
            }

            try {
                datastoreResult = datastoreReadFuture.checkedGet();
            } catch (ReadFailedException e) {
                LOG.trace("Can't read the data from datastore node");
                testSucceed = false;
            }

            if (input.getOperation() != OperationType.DELETE) {
                if (netconfResult.isPresent() || datastoreResult.isPresent()) {
                    testSucceed = false;
                }
            } else {
                if (!netconfResult.isPresent() || !datastoreResult.isPresent()) {
                    testSucceed = false;
                }
            }
        }
    } else {
        LOG.info("Start DTx Mixed Provider normal test");
        /**
         * DTx write data to both netconf and datastore node
         * ensure data has been written to all the nodes
         */
        for (int i = 1; i <= input.getNumberOfTxs(); i++) {
            InterfaceName subIfName = new InterfaceName(DTXITConstants.INTERFACE_NAME_PREFIX + i);
            KeyedInstanceIdentifier<InterfaceConfiguration, InterfaceConfigurationKey> specificInterfaceCfgIid = netconfIid
                    .child(InterfaceConfiguration.class, new InterfaceConfigurationKey(
                            new InterfaceActive(DTXITConstants.INTERFACE_ACTIVE), subIfName));
            InterfaceConfigurationBuilder interfaceConfigurationBuilder = new InterfaceConfigurationBuilder();
            interfaceConfigurationBuilder.setInterfaceName(subIfName);
            interfaceConfigurationBuilder.setActive(new InterfaceActive(DTXITConstants.INTERFACE_ACTIVE));
            InterfaceConfiguration config = interfaceConfigurationBuilder.build();

            InnerList innerList = outerList.getInnerList().get(i - 1);
            InstanceIdentifier<InnerList> innerIid = getInstanceIdentifier(outerList, innerList);
            //Write to subInterfaces of netconf node
            CheckedFuture<Void, DTxException> netconfWriteFuture = writeData(dtx, operation,
                    DTXLogicalTXProviderType.NETCONF_TX_PROVIDER, LogicalDatastoreType.CONFIGURATION,
                    specificInterfaceCfgIid, netconfNodeId, config);
            //Write to datastore with data iid
            CheckedFuture<Void, DTxException> datastoreWriteFuture = writeData(dtx, operation,
                    DTXLogicalTXProviderType.DATASTORE_TX_PROVIDER, LogicalDatastoreType.CONFIGURATION,
                    innerIid, dsNodeId, innerList);
            counter++;

            try {
                netconfWriteFuture.checkedGet();
            } catch (Exception e) {
                LOG.trace("Netconf write failed for {}", e.toString());
            }

            try {
                datastoreWriteFuture.checkedGet();
            } catch (Exception e) {
                LOG.trace("Datastore write failed for {}", e.toString());
            }

            if (counter == putsPerTx) {
                CheckedFuture<Void, TransactionCommitFailedException> submitFuture = dtx.submit();
                try {
                    submitFuture.checkedGet();
                } catch (TransactionCommitFailedException e) {
                    LOG.trace("Get submit exception {}", e.toString());
                }
                counter = 0;
                dtx = dTxProvider.newTx(nodesMap);
            }
        }

        CheckedFuture<Void, TransactionCommitFailedException> restSubmitFuture = dtx.submit();
        try {
            restSubmitFuture.checkedGet();
        } catch (TransactionCommitFailedException e) {
            LOG.trace("Get outstanding submit exception {}", e.toString());
        }
        //Ensure all data has been written to all the nodes
        for (int i = 1; i <= input.getNumberOfTxs(); i++) {
            InterfaceName subIfName = new InterfaceName(DTXITConstants.INTERFACE_NAME_PREFIX + i);
            KeyedInstanceIdentifier<InterfaceConfiguration, InterfaceConfigurationKey> specificInterfaceCfgIid = netconfIid
                    .child(InterfaceConfiguration.class, new InterfaceConfigurationKey(
                            new InterfaceActive(DTXITConstants.INTERFACE_ACTIVE), subIfName));
            InstanceIdentifier<InnerList> innerIid = getInstanceIdentifier(outerList,
                    outerList.getInnerList().get(i - 1));
            ReadOnlyTransaction netconfTx = xrNodeBroker.newReadOnlyTransaction(),
                    dataStoreTx = dataBroker.newReadOnlyTransaction();
            //Read data from netconf node
            CheckedFuture<Optional<InterfaceConfiguration>, ReadFailedException> netconfReadFuture = netconfTx
                    .read(LogicalDatastoreType.CONFIGURATION, specificInterfaceCfgIid);
            //Read data from datastore node
            CheckedFuture<Optional<InnerList>, ReadFailedException> datastoreReadFuture = dataStoreTx
                    .read(LogicalDatastoreType.CONFIGURATION, innerIid);
            Optional<InterfaceConfiguration> netconfResult = Optional.absent();
            Optional<InnerList> datastoreResult = Optional.absent();

            try {
                netconfResult = netconfReadFuture.checkedGet();
            } catch (ReadFailedException e) {
                LOG.trace("Can't read the data from netconf device");
                testSucceed = false;
            }

            try {
                datastoreResult = datastoreReadFuture.checkedGet();
            } catch (ReadFailedException e) {
                LOG.trace("Can't read the data from datastore node");
                testSucceed = false;
            }

            if (operation != OperationType.DELETE) {
                if (!netconfResult.isPresent() && !datastoreResult.isPresent()) {
                    testSucceed = false;
                }
            } else {
                if (netconfResult.isPresent() && datastoreResult.isPresent()) {
                    testSucceed = false;
                }
            }
        }
    }
    LOG.info("DTx mixed providers test finishs");
    mixedProviderTestStatus.set(TestStatus.ExecStatus.Idle);
    if (testSucceed == true) {
        return RpcResultBuilder.success(new MixedProviderTestOutputBuilder().setStatus(StatusType.OK).build())
                .buildFuture();
    } else {
        return RpcResultBuilder
                .success(new MixedProviderTestOutputBuilder().setStatus(StatusType.FAILED).build())
                .buildFuture();
    }
}