Examples with ReadWriteTransaction org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction used on opensource projects

Example 56 with ReadWriteTransaction

use of org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction in project openflowplugin by opendaylight.

the class OpenflowPluginBulkTransactionProvider method writeFlow.

private void writeFlow(final CommandInterpreter ci, FlowBuilder flow, FlowBuilder flow1, FlowBuilder flow2, FlowBuilder flow3, NodeBuilder nodeBuilder) {
    ReadWriteTransaction modification = dataBroker.newReadWriteTransaction();
    InstanceIdentifier<Flow> path1 = InstanceIdentifier.create(Nodes.class).child(Node.class, nodeBuilder.getKey()).augmentation(FlowCapableNode.class).child(Table.class, new TableKey(flow.getTableId())).child(Flow.class, flow.getKey());
    modification.merge(LogicalDatastoreType.OPERATIONAL, nodeBuilderToInstanceId(nodeBuilder), nodeBuilder.build(), true);
    modification.merge(LogicalDatastoreType.OPERATIONAL, path1, flow.build(), true);
    modification.merge(LogicalDatastoreType.CONFIGURATION, nodeBuilderToInstanceId(nodeBuilder), nodeBuilder.build(), true);
    modification.merge(LogicalDatastoreType.CONFIGURATION, path1, flow.build(), true);
    InstanceIdentifier<Flow> path2 = InstanceIdentifier.create(Nodes.class).child(Node.class, nodeBuilder.getKey()).augmentation(FlowCapableNode.class).child(Table.class, new TableKey(flow1.getTableId())).child(Flow.class, flow1.getKey());
    modification.merge(LogicalDatastoreType.OPERATIONAL, nodeBuilderToInstanceId(nodeBuilder), nodeBuilder.build(), true);
    modification.merge(LogicalDatastoreType.OPERATIONAL, path2, flow1.build(), true);
    modification.merge(LogicalDatastoreType.CONFIGURATION, nodeBuilderToInstanceId(nodeBuilder), nodeBuilder.build(), true);
    modification.merge(LogicalDatastoreType.CONFIGURATION, path2, flow1.build(), true);
    InstanceIdentifier<Flow> path3 = InstanceIdentifier.create(Nodes.class).child(Node.class, nodeBuilder.getKey()).augmentation(FlowCapableNode.class).child(Table.class, new TableKey(flow2.getTableId())).child(Flow.class, flow2.getKey());
    modification.merge(LogicalDatastoreType.OPERATIONAL, nodeBuilderToInstanceId(nodeBuilder), nodeBuilder.build(), true);
    modification.merge(LogicalDatastoreType.OPERATIONAL, path3, flow2.build(), true);
    modification.merge(LogicalDatastoreType.CONFIGURATION, nodeBuilderToInstanceId(nodeBuilder), nodeBuilder.build(), true);
    modification.merge(LogicalDatastoreType.CONFIGURATION, path3, flow2.build(), true);
    InstanceIdentifier<Flow> path4 = InstanceIdentifier.create(Nodes.class).child(Node.class, nodeBuilder.getKey()).augmentation(FlowCapableNode.class).child(Table.class, new TableKey(flow3.getTableId())).child(Flow.class, flow3.getKey());
    modification.merge(LogicalDatastoreType.OPERATIONAL, nodeBuilderToInstanceId(nodeBuilder), nodeBuilder.build(), true);
    modification.merge(LogicalDatastoreType.OPERATIONAL, path4, flow3.build(), true);
    modification.merge(LogicalDatastoreType.CONFIGURATION, nodeBuilderToInstanceId(nodeBuilder), nodeBuilder.build(), true);
    modification.merge(LogicalDatastoreType.CONFIGURATION, path4, flow3.build(), true);
    CheckedFuture<Void, TransactionCommitFailedException> commitFuture = modification.submit();
    Futures.addCallback(commitFuture, new FutureCallback<Void>() {

        @Override
        public void onSuccess(Void notUsed) {
            ci.println("Status of Group Data Loaded Transaction: success.");
        }

        @Override
        public void onFailure(Throwable throwable) {
            LOG.error(throwable.getMessage(), throwable);
            ci.println(String.format("Status of Group Data Loaded Transaction : failure. Reason : %s", throwable));
        }
    }, MoreExecutors.directExecutor());
}

Example 57 with ReadWriteTransaction

use of org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction in project openflowplugin by opendaylight.

the class OpenflowPluginBulkTransactionProvider method _removeFlows.

public void _removeFlows(final CommandInterpreter ci) {
    ReadWriteTransaction modification = dataBroker.newReadWriteTransaction();
    NodeBuilder tn = createTestNode(ci.nextArgument());
    String flowtype = ci.nextArgument();
    Integer flowcnt = Integer.parseInt(flowtype);
    FlowBuilder tf = null;
    FlowBuilder tf1 = null;
    FlowBuilder tf2 = null;
    FlowBuilder tf3 = null;
    switch(flowcnt) {
        case 1:
            // add case 1
            tf = createTestFlow(tn, "f1", "10");
            tf1 = createTestFlow(tn, "f2", "11");
            tf2 = createTestFlow(tn, "f3", "12");
            tf3 = createTestFlow(tn, "f4", "13");
            break;
        case 2:
            // modify case 1
            tf = createTestFlow(tn, "f82", "10");
            tf1 = createTestFlow(tn, "f83", "11");
            tf2 = createTestFlow(tn, "f84", "12");
            tf3 = createTestFlow(tn, "f85", "13");
            break;
        case 3:
            // add case 2
            tf = createTestFlow(tn, "f3", "3");
            tf1 = createTestFlow(tn, "f4", "4");
            tf2 = createTestFlow(tn, "f5", "5");
            tf3 = createTestFlow(tn, "f6", "6");
            break;
        case 4:
            // modify case 2
            tf = createTestFlow(tn, "f700", "3");
            tf1 = createTestFlow(tn, "f4", "4");
            tf2 = createTestFlow(tn, "f900", "5");
            tf3 = createTestFlow(tn, "f86", "6");
            break;
        case 5:
            // add case 3
            tf = createTestFlow(tn, "f7", "7");
            tf1 = createTestFlow(tn, "f8", "8");
            tf2 = createTestFlow(tn, "f9", "9");
            tf3 = createTestFlow(tn, "f10", "10");
            break;
        case 6:
            // modify case 3
            tf = createTestFlow(tn, "f91", "7");
            tf1 = createTestFlow(tn, "f92", "8");
            tf2 = createTestFlow(tn, "f93", "9");
            tf3 = createTestFlow(tn, "f94", "10");
            break;
        case 7:
            // -ve scenario
            tf = createTestFlow(tn, "f23", "3");
            tf1 = createTestFlow(tn, "f34", "4");
            tf2 = createTestFlow(tn, "f35", "5");
            tf3 = createTestFlow(tn, "f36", "6");
            break;
        case 8:
            // +ve scenario
            // modify case 6 -ve
            tf = createTestFlow(tn, "f23", "3");
            tf1 = createTestFlow(tn, "f99", "4");
            tf2 = createTestFlow(tn, "f100", "5");
            tf3 = createTestFlow(tn, "f101", "6");
            break;
        case 9:
            // modify case 6
            tf = createTestFlow(tn, "f700", "7");
            tf1 = createTestFlow(tn, "f230", "23");
            tf2 = createTestFlow(tn, "f900", "9");
            tf3 = createTestFlow(tn, "f1000", "10");
            break;
        default:
            throw new IllegalArgumentException("Invalid flowtype: " + flowtype);
    }
    InstanceIdentifier<Flow> path1 = InstanceIdentifier.create(Nodes.class).child(Node.class, tn.getKey()).augmentation(FlowCapableNode.class).child(Table.class, new TableKey(tf.getTableId())).child(Flow.class, tf.getKey());
    modification.delete(LogicalDatastoreType.OPERATIONAL, path1);
    modification.delete(LogicalDatastoreType.CONFIGURATION, nodeBuilderToInstanceId(tn));
    modification.delete(LogicalDatastoreType.CONFIGURATION, path1);
    InstanceIdentifier<Flow> path2 = InstanceIdentifier.create(Nodes.class).child(Node.class, tn.getKey()).augmentation(FlowCapableNode.class).child(Table.class, new TableKey(tf1.getTableId())).child(Flow.class, tf1.getKey());
    modification.delete(LogicalDatastoreType.OPERATIONAL, path2);
    modification.delete(LogicalDatastoreType.CONFIGURATION, nodeBuilderToInstanceId(tn));
    modification.delete(LogicalDatastoreType.CONFIGURATION, path2);
    InstanceIdentifier<Flow> path3 = InstanceIdentifier.create(Nodes.class).child(Node.class, tn.getKey()).augmentation(FlowCapableNode.class).child(Table.class, new TableKey(tf2.getTableId())).child(Flow.class, tf2.getKey());
    modification.delete(LogicalDatastoreType.OPERATIONAL, path3);
    modification.delete(LogicalDatastoreType.CONFIGURATION, nodeBuilderToInstanceId(tn));
    modification.delete(LogicalDatastoreType.CONFIGURATION, path3);
    InstanceIdentifier<Flow> path4 = InstanceIdentifier.create(Nodes.class).child(Node.class, tn.getKey()).augmentation(FlowCapableNode.class).child(Table.class, new TableKey(tf3.getTableId())).child(Flow.class, tf3.getKey());
    modification.delete(LogicalDatastoreType.OPERATIONAL, path4);
    modification.delete(LogicalDatastoreType.CONFIGURATION, nodeBuilderToInstanceId(tn));
    modification.delete(LogicalDatastoreType.CONFIGURATION, path4);
    CheckedFuture<Void, TransactionCommitFailedException> commitFuture = modification.submit();
    Futures.addCallback(commitFuture, new FutureCallback<Void>() {

        @Override
        public void onSuccess(Void notUsed) {
            ci.println("Status of Group Data Loaded Transaction: success.");
        }

        @Override
        public void onFailure(Throwable throwable) {
            LOG.error(throwable.getMessage(), throwable);
            ci.println(String.format("Status of Group Data Loaded Transaction : failure. Reason : %s", throwable));
        }
    }, MoreExecutors.directExecutor());
}

Example 58 with ReadWriteTransaction

use of org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction in project genius by opendaylight.

the class AlivenessMonitor method monitorProfileDelete.

@Override
public Future<RpcResult<Void>> monitorProfileDelete(final MonitorProfileDeleteInput input) {
    LOG.debug("Monitor Profile delete for Id: {}", input.getProfileId());
    final SettableFuture<RpcResult<Void>> result = SettableFuture.create();
    final Long profileId = input.getProfileId();
    final ReadWriteTransaction tx = dataBroker.newReadWriteTransaction();
    ListenableFuture<Optional<MonitorProfile>> readFuture = tx.read(LogicalDatastoreType.OPERATIONAL, getMonitorProfileId(profileId));
    ListenableFuture<RpcResult<Void>> writeFuture = Futures.transformAsync(readFuture, optProfile -> {
        if (optProfile.isPresent()) {
            tx.delete(LogicalDatastoreType.OPERATIONAL, getMonitorProfileId(profileId));
            Futures.addCallback(tx.submit(), new FutureCallback<Void>() {

                @Override
                public void onFailure(Throwable error) {
                    String msg = String.format("Error when removing monitor profile %d from datastore", profileId);
                    LOG.error("Error when removing monitor profile {} from datastore", profileId, error);
                    result.set(RpcResultBuilder.<Void>failed().withError(ErrorType.APPLICATION, msg, error).build());
                }

                @Override
                public void onSuccess(Void noarg) {
                    MonitorProfile profile = optProfile.get();
                    String id = getUniqueProfileKey(profile.getFailureThreshold(), profile.getMonitorInterval(), profile.getMonitorWindow(), profile.getProtocolType());
                    releaseId(id);
                    result.set(RpcResultBuilder.<Void>success().build());
                }
            }, callbackExecutorService);
        } else {
            String msg = String.format("Monitor profile with Id: %d does not exist", profileId);
            LOG.info(msg);
            result.set(RpcResultBuilder.<Void>success().withWarning(ErrorType.PROTOCOL, "invalid-value", msg).build());
        }
        return result;
    }, callbackExecutorService);
    Futures.addCallback(writeFuture, new FutureCallback<RpcResult<Void>>() {

        @Override
        public void onFailure(Throwable error) {
            String msg = String.format("Error when removing monitor profile %d from datastore", profileId);
            LOG.error("Error when removing monitor profile {} from datastore", profileId, error);
            result.set(RpcResultBuilder.<Void>failed().withError(ErrorType.APPLICATION, msg, error).build());
        }

        @Override
        public void onSuccess(RpcResult<Void> noarg) {
            LOG.debug("Successfully removed Monitor Profile {}", profileId);
        }
    }, callbackExecutorService);
    return result;
}

Example 59 with ReadWriteTransaction

use of org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction in project genius by opendaylight.

the class AlivenessMonitor method updateMonitorStatusTo.

private void updateMonitorStatusTo(final Long monitorId, final MonitorStatus newStatus, final Predicate<MonitorStatus> isValidStatus) {
    final String monitorKey = monitorIdKeyCache.getUnchecked(monitorId);
    if (monitorKey == null) {
        LOG.warn("No monitor Key associated with id {} to change the monitor status to {}", monitorId, newStatus);
        return;
    }
    final ReadWriteTransaction tx = dataBroker.newReadWriteTransaction();
    ListenableFuture<Optional<MonitoringState>> readResult = tx.read(LogicalDatastoreType.OPERATIONAL, getMonitorStateId(monitorKey));
    ListenableFuture<Void> writeResult = Futures.transformAsync(readResult, optState -> {
        if (optState.isPresent()) {
            MonitoringState state = optState.get();
            if (isValidStatus.apply(state.getStatus())) {
                MonitoringState updatedState = new MonitoringStateBuilder().setMonitorKey(monitorKey).setStatus(newStatus).build();
                tx.merge(LogicalDatastoreType.OPERATIONAL, getMonitorStateId(monitorKey), updatedState);
            } else {
                LOG.warn("Invalid Monitoring status {}, cannot be updated to {} for monitorId {}", state.getStatus(), newStatus, monitorId);
            }
        } else {
            LOG.warn("No associated monitoring state data available to update the status to {} for {}", newStatus, monitorId);
        }
        return tx.submit();
    }, MoreExecutors.directExecutor());
    Futures.addCallback(writeResult, new FutureCallbackImpl(String.format("Monitor status update for %d to %s", monitorId, newStatus.toString())), MoreExecutors.directExecutor());
}

Example 60 with ReadWriteTransaction

use of org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction in project genius by opendaylight.

the class AlivenessMonitor method monitorProfileCreate.

@Override
public Future<RpcResult<MonitorProfileCreateOutput>> monitorProfileCreate(final MonitorProfileCreateInput input) {
    LOG.debug("Monitor Profile Create operation - {}", input.getProfile());
    final SettableFuture<RpcResult<MonitorProfileCreateOutput>> returnFuture = SettableFuture.create();
    Profile profile = input.getProfile();
    final Long failureThreshold = profile.getFailureThreshold();
    final Long monitorInterval = profile.getMonitorInterval();
    final Long monitorWindow = profile.getMonitorWindow();
    final EtherTypes ethType = profile.getProtocolType();
    String idKey = getUniqueProfileKey(failureThreshold, monitorInterval, monitorWindow, ethType);
    final Long profileId = (long) getUniqueId(idKey);
    final ReadWriteTransaction tx = dataBroker.newReadWriteTransaction();
    ListenableFuture<Optional<MonitorProfile>> readFuture = tx.read(LogicalDatastoreType.OPERATIONAL, getMonitorProfileId(profileId));
    ListenableFuture<RpcResult<MonitorProfileCreateOutput>> resultFuture = Futures.transformAsync(readFuture, optProfile -> {
        if (optProfile.isPresent()) {
            tx.cancel();
            MonitorProfileCreateOutput output = new MonitorProfileCreateOutputBuilder().setProfileId(profileId).build();
            String msg = String.format("Monitor profile %s already present for the given input", input);
            LOG.warn(msg);
            returnFuture.set(RpcResultBuilder.success(output).withWarning(ErrorType.PROTOCOL, "profile-exists", msg).build());
        } else {
            final MonitorProfile monitorProfile = new MonitorProfileBuilder().setId(profileId).setFailureThreshold(failureThreshold).setMonitorInterval(monitorInterval).setMonitorWindow(monitorWindow).setProtocolType(ethType).build();
            tx.put(LogicalDatastoreType.OPERATIONAL, getMonitorProfileId(profileId), monitorProfile, CREATE_MISSING_PARENT);
            Futures.addCallback(tx.submit(), new FutureCallback<Void>() {

                @Override
                public void onFailure(Throwable error) {
                    String msg = String.format("Error when storing monitorprofile %s in datastore", monitorProfile);
                    LOG.error("Error when storing monitorprofile {} in datastore", monitorProfile, error);
                    returnFuture.set(RpcResultBuilder.<MonitorProfileCreateOutput>failed().withError(ErrorType.APPLICATION, msg, error).build());
                }

                @Override
                public void onSuccess(Void noarg) {
                    MonitorProfileCreateOutput output = new MonitorProfileCreateOutputBuilder().setProfileId(profileId).build();
                    returnFuture.set(RpcResultBuilder.success(output).build());
                }
            }, callbackExecutorService);
        }
        return returnFuture;
    }, callbackExecutorService);
    Futures.addCallback(resultFuture, new FutureCallback<RpcResult<MonitorProfileCreateOutput>>() {

        @Override
        public void onFailure(Throwable error) {
            // This would happen when any error happens during reading for
            // monitoring profile
            String msg = String.format("Error in creating monitorprofile - %s", input);
            returnFuture.set(RpcResultBuilder.<MonitorProfileCreateOutput>failed().withError(ErrorType.APPLICATION, msg, error).build());
            LOG.error("Error in creating monitorprofile - {} ", input, error);
        }

        @Override
        public void onSuccess(RpcResult<MonitorProfileCreateOutput> result) {
            LOG.debug("Successfully created monitor Profile {} ", input);
        }
    }, callbackExecutorService);
    return returnFuture;
}