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

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

  1. HOME
  2. Java
  3. com.google.common
  4. com.google.common.util.concurrent.*
  5. CheckedFuture
  6. 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:org.opendaylight.sfc.util.openflow.transactional_writer.FlowSetWriterTask.java

@Override
public void run() {
    WriteTransaction trans = tx == null ? dataProvider.newWriteOnlyTransaction() : tx;

    LOG.debug("FlowSetWriterTask: starting addition of {} flows", flowsToWrite.size());

    for (FlowDetails f : flowsToWrite) {
        NodeKey theKey = new NodeKey(new NodeId(f.getSffNodeName()));

        InstanceIdentifier<Flow> iidFlow = InstanceIdentifier.builder(Nodes.class).child(Node.class, theKey)
                .augmentation(FlowCapableNode.class).child(Table.class, f.getTableKey())
                .child(Flow.class, f.getFlowKey()).build();

        trans.put(LogicalDatastoreType.CONFIGURATION, iidFlow, f.getFlow(), true);
    }//from ww w. j  a v  a 2s. com

    CheckedFuture<Void, TransactionCommitFailedException> submitFuture = trans.submit();

    try {
        submitFuture.checkedGet();
    } catch (TransactionCommitFailedException e) {
        LOG.error("deleteTransactionAPI: Transaction failed. Message: {}", e.getMessage(), e);
    }
}

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

/**
 * This method builds test data for delete operation
 *///  w ww. ja  v a  2  s .co  m
public boolean buildTestInnerList() {
    List<OuterList> outerLists = buildOuterList();
    WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
    for (OuterList outerList : outerLists) {
        InstanceIdentifier<OuterList> outerListIid = InstanceIdentifier.create(DatastoreTestData.class)
                .child(OuterList.class, outerList.getKey());

        transaction.put(LogicalDatastoreType.CONFIGURATION, outerListIid, outerList);
        CheckedFuture<Void, TransactionCommitFailedException> submitFuture = transaction.submit();

        try {
            submitFuture.checkedGet();
        } catch (Exception e) {
            return false;
        }
        transaction = dataBroker.newWriteOnlyTransaction();
    }
    return true;
}

From source file:org.opendaylight.netvirt.statemanager.StateManager.java

/**
 * Executes put as a blocking transaction.
 *
 * @param logicalDatastoreType {@link LogicalDatastoreType} which should be modified
 * @param path {@link InstanceIdentifier} for path to read
 * @param <D> the data object type
 * @return the result of the request/* w ww  .  ja va 2  s . co m*/
 */
public <D extends org.opendaylight.yangtools.yang.binding.DataObject> boolean put(
        final LogicalDatastoreType logicalDatastoreType, final InstanceIdentifier<D> path, D data) {
    boolean result = false;
    final WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
    transaction.put(logicalDatastoreType, path, data, true);
    CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
    try {
        future.checkedGet();
        result = true;
    } catch (TransactionCommitFailedException e) {
        LOG.warn("StateManager failed to put {} ", path, e);
    }
    return result;
}

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

public void configInterface() {
    WriteTransaction xrNodeWriteTx = null;
    for (int i = 1; i <= input.getLoop(); i++) {
        xrNodeWriteTx = xrNodeBroker.newWriteOnlyTransaction();

        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();

        xrNodeWriteTx.put(LogicalDatastoreType.CONFIGURATION, specificInterfaceCfgIid, config);
        CheckedFuture<Void, TransactionCommitFailedException> submitFut = xrNodeWriteTx.submit();
        try {//from   w ww . ja v a2  s . c  om
            submitFut.checkedGet();
        } catch (TransactionCommitFailedException e) {
            LOG.trace("Can't build interface {}", subIfName.toString());
        }
    }
}

From source file:org.opendaylight.controller.netconf.mdsal.connector.TransactionProvider.java

public synchronized boolean commitRunningTransaction(DOMDataReadWriteTransaction tx)
        throws NetconfDocumentedException {
    allOpenReadWriteTransactions.remove(tx);

    CheckedFuture<Void, TransactionCommitFailedException> future = tx.submit();
    try {/* ww w.  ja v  a  2s . co  m*/
        future.checkedGet();
    } catch (TransactionCommitFailedException e) {
        LOG.debug("Transaction {} failed on", tx, e);
        throw new NetconfDocumentedException(
                "Transaction commit failed on " + e.getMessage() + " " + netconfSessionIdForReporting,
                ErrorType.application, ErrorTag.operation_failed, ErrorSeverity.error);
    }

    return true;
}

From source file:org.opendaylight.unimgr.utils.OvsdbUtils.java

/**
 * Create and write QoS forn an OVSDB node, copying from UNI entry.
 * @param dataBroker the data broker//from  w w w .ja v  a2s .c o m
 * @param uni the UNI to copy data from
 * @return null
 */
public static Node createQoSForOvsdbNode(DataBroker dataBroker, UniAugmentation uni) {
    final Optional<Node> optionalNode = findOvsdbNode(dataBroker, uni);
    if (optionalNode.isPresent()) {
        final NodeId ovsdbNodeId = optionalNode.get().getNodeId();
        final InstanceIdentifier<OvsdbNodeAugmentation> ovsdbNodeAugmentationIid = UnimgrMapper
                .getOvsdbNodeIid(ovsdbNodeId).augmentation(OvsdbNodeAugmentation.class);
        final OvsdbNodeAugmentation ovsdbNodeAugmentation = createOvsdbNodeAugmentation(uni,
                getRemotePort(dataBroker, uni));
        final WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
        transaction.delete(LogicalDatastoreType.CONFIGURATION, ovsdbNodeAugmentationIid);
        transaction.put(LogicalDatastoreType.CONFIGURATION, ovsdbNodeAugmentationIid, ovsdbNodeAugmentation,
                true);
        final CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
        try {
            Thread.sleep(UnimgrConstants.OVSDB_UPDATE_TIMEOUT);
        } catch (final InterruptedException e) {
            LOG.warn("Interrupted while waiting after OVSDB node augmentation {}", ovsdbNodeId, e);
        }
        try {
            future.checkedGet();
            LOG.trace("Update qos and queues to ovsdb for node {} {}", ovsdbNodeId, ovsdbNodeAugmentationIid);
        } catch (final TransactionCommitFailedException e) {
            LOG.warn("Failed to put {} ", ovsdbNodeAugmentationIid, e);
        }
        updateQosEntries(dataBroker, uni);
    }
    return null;
}

From source file:org.opendaylight.ovsdb.utils.mdsal.utils.MdsalUtils.java

/**
 * Executes delete as a blocking transaction.
 *
 * @param store {@link LogicalDatastoreType} which should be modified
 * @param path {@link InstanceIdentifier} to read from
 * @param <D> the data object type
 * @return the result of the request//from ww  w .jav  a  2  s . co m
 */
public <D extends org.opendaylight.yangtools.yang.binding.DataObject> boolean delete(
        final LogicalDatastoreType store, final InstanceIdentifier<D> path) {
    boolean result = false;
    final WriteTransaction transaction = databroker.newWriteOnlyTransaction();
    transaction.delete(store, path);
    CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
    try {
        future.checkedGet();
        result = true;
    } catch (TransactionCommitFailedException e) {
        LOG.warn("Failed to delete {} ", path, e);
    }
    return result;
}

From source file:org.opendaylight.ovsdb.utils.mdsal.utils.MdsalUtils.java

/**
 * Executes merge as a blocking transaction.
 *
 * @param logicalDatastoreType {@link LogicalDatastoreType} which should be modified
 * @param path {@link InstanceIdentifier} for path to read
 * @param <D> the data object type
 * @return the result of the request/* w  w  w  .ja va 2s  .co m*/
 */
public <D extends org.opendaylight.yangtools.yang.binding.DataObject> boolean merge(
        final LogicalDatastoreType logicalDatastoreType, final InstanceIdentifier<D> path, D data) {
    boolean result = false;
    final WriteTransaction transaction = databroker.newWriteOnlyTransaction();
    transaction.merge(logicalDatastoreType, path, data, true);
    CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
    try {
        future.checkedGet();
        result = true;
    } catch (TransactionCommitFailedException e) {
        LOG.warn("Failed to merge {} ", path, e);
    }
    return result;
}

From source file:org.opendaylight.ovsdb.utils.mdsal.utils.MdsalUtils.java

/**
 * Executes put as a blocking transaction.
 *
 * @param logicalDatastoreType {@link LogicalDatastoreType} which should be modified
 * @param path {@link InstanceIdentifier} for path to read
 * @param <D> the data object type
 * @return the result of the request//from  w  w w  .  j a v a  2s .c  o  m
 */
public <D extends org.opendaylight.yangtools.yang.binding.DataObject> boolean put(
        final LogicalDatastoreType logicalDatastoreType, final InstanceIdentifier<D> path, D data) {
    boolean result = false;
    final WriteTransaction transaction = databroker.newWriteOnlyTransaction();
    transaction.put(logicalDatastoreType, path, data, true);
    CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
    try {
        future.checkedGet();
        result = true;
    } catch (TransactionCommitFailedException e) {
        LOG.warn("Failed to put {} ", path, e);
    }
    return result;
}

From source file:org.opendaylight.netconf.mdsal.connector.TransactionProvider.java

public synchronized boolean commitRunningTransaction(DOMDataReadWriteTransaction tx)
        throws DocumentedException {
    allOpenReadWriteTransactions.remove(tx);

    CheckedFuture<Void, TransactionCommitFailedException> future = tx.submit();
    try {/*from   w w  w. j  a v a2s. co  m*/
        future.checkedGet();
    } catch (TransactionCommitFailedException e) {
        LOG.debug("Transaction {} failed on", tx, e);
        throw new DocumentedException(
                "Transaction commit failed on " + e.getMessage() + " " + netconfSessionIdForReporting,
                ErrorType.application, ErrorTag.operation_failed, ErrorSeverity.error);
    }

    return true;
}