Examples with ReadWriteTransaction org.opendaylight.mdsal.binding.api.ReadWriteTransaction used on opensource projects

Example 1 with ReadWriteTransaction

use of org.opendaylight.mdsal.binding.api.ReadWriteTransaction in project netvirt by opendaylight.

the class TestUtil method verifyHAOpNode.

static void verifyHAOpNode(Node d1GlobalOpNode, Node haGlobalOpNode, Node d1PsOpNode, Node haPsOpNode, InstanceIdentifier<Node> haId, InstanceIdentifier<Node> d1PsId, InstanceIdentifier<Node> haPsId, DataBroker dataBroker) throws ReadFailedException {
    ReadWriteTransaction transaction = dataBroker.newReadWriteTransaction();
    TestComparators.compareLogicalSwitches(d1GlobalOpNode, haGlobalOpNode, haId);
    // TestComparators.compareRemoteUcastMacs(d1GlobalOpNode, haGlobalOpNode, haId);
    // TestComparators.compareRemoteMcastMacs(d1GlobalOpNode, haGlobalOpNode, haId);
    TestComparators.compareLocalUcastMacs(d1GlobalOpNode, haGlobalOpNode, haId);
    // TestComparators.compareLocalMcastMacs(d1GlobalOpNode, haGlobalOpNode, haId);
    TestComparators.verifySwitches(haGlobalOpNode, haPsOpNode);
    TestComparators.verifySwitches(d1GlobalOpNode, d1PsOpNode);
// TestComparators.comparePhysicalSwitches(d1PsOpNode, haPsOpNode, d1PsId, haPsId, transaction, "s3",
// d1GlobalOpNode, haGlobalOpNode);
}

Example 2 with ReadWriteTransaction

use of org.opendaylight.mdsal.binding.api.ReadWriteTransaction in project controller by opendaylight.

the class OpendaylightToaster method checkStatusAndMakeToast.

private void checkStatusAndMakeToast(final MakeToastInput input, final SettableFuture<RpcResult<MakeToastOutput>> futureResult, final int tries) {
    // Read the ToasterStatus and, if currently Up, try to write the status to Down.
    // If that succeeds, then we essentially have an exclusive lock and can proceed
    // to make toast.
    final ReadWriteTransaction tx = dataBroker.newReadWriteTransaction();
    FluentFuture<Optional<Toaster>> readFuture = tx.read(OPERATIONAL, TOASTER_IID);
    final ListenableFuture<? extends CommitInfo> commitFuture = Futures.transformAsync(readFuture, toasterData -> {
        ToasterStatus toasterStatus = ToasterStatus.Up;
        if (toasterData.isPresent()) {
            toasterStatus = toasterData.get().getToasterStatus();
        }
        LOG.debug("Read toaster status: {}", toasterStatus);
        if (toasterStatus == ToasterStatus.Up) {
            if (outOfBread()) {
                LOG.debug("Toaster is out of bread");
                tx.cancel();
                return Futures.immediateFailedFuture(new TransactionCommitFailedException("", makeToasterOutOfBreadError()));
            }
            LOG.debug("Setting Toaster status to Down");
            // We're not currently making toast - try to update the status to Down
            // to indicate we're going to make toast. This acts as a lock to prevent
            // concurrent toasting.
            tx.put(OPERATIONAL, TOASTER_IID, buildToaster(ToasterStatus.Down));
            return tx.commit();
        }
        LOG.debug("Oops - already making toast!");
        // Return an error since we are already making toast. This will get
        // propagated to the commitFuture below which will interpret the null
        // TransactionStatus in the RpcResult as an error condition.
        tx.cancel();
        return Futures.immediateFailedFuture(new TransactionCommitFailedException("", makeToasterInUseError()));
    }, MoreExecutors.directExecutor());
    Futures.addCallback(commitFuture, new FutureCallback<CommitInfo>() {

        @Override
        public void onSuccess(final CommitInfo result) {
            // OK to make toast
            currentMakeToastTask.set(executor.submit(new MakeToastTask(input, futureResult)));
        }

        @Override
        public void onFailure(final Throwable ex) {
            if (ex instanceof OptimisticLockFailedException) {
                if (tries - 1 > 0) {
                    LOG.debug("Got OptimisticLockFailedException - trying again");
                    checkStatusAndMakeToast(input, futureResult, tries - 1);
                } else {
                    futureResult.set(RpcResultBuilder.<MakeToastOutput>failed().withError(ErrorType.APPLICATION, ex.getMessage()).build());
                }
            } else if (ex instanceof TransactionCommitFailedException) {
                LOG.debug("Failed to commit Toaster status", ex);
                // Probably already making toast.
                futureResult.set(RpcResultBuilder.<MakeToastOutput>failed().withRpcErrors(((TransactionCommitFailedException) ex).getErrorList()).build());
            } else {
                LOG.debug("Unexpected error committing Toaster status", ex);
                futureResult.set(RpcResultBuilder.<MakeToastOutput>failed().withError(ErrorType.APPLICATION, "Unexpected error committing Toaster status", ex).build());
            }
        }
    }, MoreExecutors.directExecutor());
}

Example 3 with ReadWriteTransaction

use of org.opendaylight.mdsal.binding.api.ReadWriteTransaction in project bgpcep by opendaylight.

the class AbstractStatementRegistryTest method loadStatement.

protected List<Statement> loadStatement(final String policyName) throws ExecutionException, InterruptedException {
    final ReadWriteTransaction rt = getDataBroker().newReadWriteTransaction();
    final PolicyDefinition policy = rt.read(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(RoutingPolicy.class).child(PolicyDefinitions.class).child(PolicyDefinition.class, new PolicyDefinitionKey(policyName))).get().get();
    return policy.getStatements().getStatement();
}

Example 4 with ReadWriteTransaction

use of org.opendaylight.mdsal.binding.api.ReadWriteTransaction in project bgpcep by opendaylight.

the class ConnectedGraphServer method addToDataStore.

/**
 * Add Graph or Graph components to the Data Store.
 *
 * @param <T>   As a generic method, T must be a Graph, Vertex, Edge or Prefix.
 * @param id    Instance Identifier of the Data Object
 * @param data  Data Object (Graph, Vertex, Edge or Prefix)
 * @param info  Information to be logged
 */
private synchronized <T extends DataObject> void addToDataStore(final InstanceIdentifier<T> id, final T data, final String info) {
    final ReadWriteTransaction trans = this.chain.newReadWriteTransaction();
    trans.put(LogicalDatastoreType.OPERATIONAL, id, data);
    trans.commit().addCallback(new FutureCallback<CommitInfo>() {

        @Override
        public void onSuccess(final CommitInfo result) {
            LOG.info("GraphModel: {} has been published in operational datastore ", info);
        }

        @Override
        public void onFailure(final Throwable throwable) {
            LOG.error("GrahModel: Cannot write {} to the operational datastore (transaction: {})", info, trans.getIdentifier());
        }
    }, MoreExecutors.directExecutor());
}

Example 5 with ReadWriteTransaction

use of org.opendaylight.mdsal.binding.api.ReadWriteTransaction in project bgpcep by opendaylight.

the class ConnectedGraphServer method updateToDataStore.

/**
 * Update Graph components (Vertex, Edge or Prefix ) to the Data Store. Old value identified by its Instance ID
 * will be remove first before adding the new value.
 *
 * @param <T>   As a generic method, T must be a Vertex, Edge or Prefix.
 * @param id    Instance Identifier of the Data Object
 * @param data  Data Object (Vertex, Edge or Prefix)
 * @param old   Instance Identifier of the previous version of the Data Object
 * @param info  Information to be logged
 */
private synchronized <T extends DataObject> void updateToDataStore(final InstanceIdentifier<T> id, final T data, final InstanceIdentifier<T> old, final String info) {
    final ReadWriteTransaction trans = this.chain.newReadWriteTransaction();
    if (old != null) {
        trans.delete(LogicalDatastoreType.OPERATIONAL, old);
    }
    trans.put(LogicalDatastoreType.OPERATIONAL, id, data);
    trans.commit().addCallback(new FutureCallback<CommitInfo>() {

        @Override
        public void onSuccess(final CommitInfo result) {
            LOG.info("GraphModel: {} has been published in operational datastore ", info);
        }

        @Override
        public void onFailure(final Throwable throwable) {
            LOG.error("GrahModel: Cannot write {} to the operational datastore (transaction: {})", info, trans.getIdentifier());
        }
    }, MoreExecutors.directExecutor());
}