sdnr/wireless-transport/code-Carbon-SR1/apps/devicemanager/impl/src/main/java/org/opendaylight/mwtn/base/netconf/GenericTransactionUtils.java

   1 package org.opendaylight.mwtn.base.netconf;
   2
   3 import java.util.NoSuchElementException;
   4 import java.util.concurrent.CancellationException;
   5 import java.util.concurrent.ExecutionException;
   6 import java.util.concurrent.atomic.AtomicBoolean;
   7 import java.util.concurrent.atomic.AtomicReference;
   8
   9 import javax.annotation.Nullable;
  10
  11 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  12 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  13 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  14 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  15 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  16 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  17 import org.opendaylight.yangtools.yang.binding.DataObject;
  18 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  19 import org.slf4j.Logger;
  20 import org.slf4j.LoggerFactory;
  21
  22 import com.google.common.base.Optional;
  23 import com.google.common.base.Preconditions;
  24 import com.google.common.util.concurrent.CheckedFuture;
  25
  26 public final class GenericTransactionUtils {
  27     static final Logger logger = LoggerFactory.getLogger(GenericTransactionUtils.class);
  28
  29     public static <T extends DataObject> boolean writeData(DataBroker dataBroker, LogicalDatastoreType logicalDatastoreType,
  30             InstanceIdentifier<T> iid, T dataObject, boolean isAdd) {
  31         Preconditions.checkNotNull(dataBroker);
  32         WriteTransaction modification = dataBroker.newWriteOnlyTransaction();
  33         if (isAdd) {
  34             if (dataObject == null) {
  35                 logger.warn("Invalid attempt to add a non-existent object to path {}", iid);
  36                 return false;
  37             }
  38             modification.merge(logicalDatastoreType, iid, dataObject, true /*createMissingParents*/);
  39         }
  40         else {
  41             modification.delete(LogicalDatastoreType.CONFIGURATION, iid);
  42         }
  43         CheckedFuture<Void, TransactionCommitFailedException> commitFuture = modification.submit();
  44         try {
  45             commitFuture.checkedGet();
  46             logger.debug("Transaction success for {} of object {}", isAdd ? "add" : "delete", dataObject);
  47             return true;
  48         } catch (Exception e) {
  49             logger.warn("Transaction failed with error {} for {} of object {}", e.getMessage(), isAdd ? "add" : "delete", dataObject);
  50             modification.cancel();
  51             return false;
  52         }
  53     }
  54
  55      /*
  56      /**
  57      * Deliver the data back or null
  58      * @param dataBroker for accessing data
  59      * @param dataStoreType to address datastore
  60      * @param iid id to access data
  61      * @return Optional for the data
  62      * /
  63     private static <T extends DataObject> Optional<T> readDataOptional(DataBroker dataBroker, LogicalDatastoreType dataStoreType, InstanceIdentifier<T> iid) {
  64
  65         Preconditions.checkNotNull(dataBroker);
  66         ReadOnlyTransaction readTransaction = dataBroker.newReadOnlyTransaction();
  67         try {
  68             CheckedFuture<Optional<T>, ReadFailedException> od = readTransaction.read(dataStoreType, iid);
  69             Optional<T> optionalData = od.get();
  70             readTransaction.close();
  71             return optionalData;
  72         } catch (CancellationException | ExecutionException | InterruptedException | NoSuchElementException e) {
  73             logger.warn("Read transaction for identifier "+iid+" failed with error "+e.getMessage());
  74             readTransaction.close();
  75             return Optional.fromNullable(null);
  76         }
  77     } /**/
  78
  79     /**
  80      * Deliver the data back or null. Warning
  81      * @param <T> SubType of the DataObject to be handled
  82      * @param dataBroker for accessing data
  83      * @param dataStoreType to address datastore
  84      * @param iid id to access data
  85      * @return null or object
  86      */
  87     @Nullable
  88     public static <T extends DataObject> T readData(DataBroker dataBroker, LogicalDatastoreType dataStoreType, InstanceIdentifier<T> iid) {
  89         //return readDataOptional(dataBroker, dataStoreType, iid).orNull();
  90         AtomicBoolean noErrorIndication = new AtomicBoolean();
  91         AtomicReference<String> statusText = new AtomicReference<>();
  92
  93         T obj = readDataOptionalWithStatus(dataBroker, dataStoreType, iid, noErrorIndication, statusText);
  94
  95         if (! noErrorIndication.get()) {
  96             logger.warn("Read transaction for identifier "+iid+" failed with error "+statusText.get());
  97         }
  98
  99         return obj;
 100     }
 101
 102     /**
 103      * Deliver the data back or null
 104      * @param <T> SubType of the DataObject to be handled
 105      * @param dataBroker for accessing data
 106      * @param dataStoreType to address datastore
 107      * @param iid id to access data
 108      * @param noErrorIndication (Output) true if data could be read and are available and is not null
 109      * @param statusIndicator (Output) String with status indications during the read.
 110      * @return null or object
 111      */
 112     @Nullable
 113     public static <T extends DataObject> T readDataOptionalWithStatus(DataBroker dataBroker, LogicalDatastoreType dataStoreType, InstanceIdentifier<T> iid, AtomicBoolean noErrorIndication, AtomicReference<String> statusIndicator) {
 114
 115         T data = null;
 116         noErrorIndication.set(false);
 117         statusIndicator.set("Preconditions");
 118         Preconditions.checkNotNull(dataBroker);
 119         statusIndicator.set("Create Read Transaction");
 120         ReadOnlyTransaction readTransaction = dataBroker.newReadOnlyTransaction();
 121
 122         try {
 123             CheckedFuture<Optional<T>, ReadFailedException> od = readTransaction.read(dataStoreType, iid);
 124             statusIndicator.set("Read done");
 125             if (od != null) {
 126                 statusIndicator.set("Unwrap checkFuture done");
 127                 Optional<T> optionalData = od.get();
 128                 if (optionalData != null) {
 129                     statusIndicator.set("Unwrap optional done");
 130                         data = optionalData.orNull();
 131                         statusIndicator.set("Read transaction done");
 132                         noErrorIndication.set(true);
 133                 }
 134             }
 135         } catch (CancellationException | ExecutionException | InterruptedException | NoSuchElementException e) {
 136             statusIndicator.set("Read transaction for identifier "+iid+" failed with error "+e.getMessage());
 137         }
 138
 139         readTransaction.close();
 140         return data;
 141     }
 142
 143
 144 }