transcriber/src/main/java/org/opendaylight/neutron/transcriber/AbstractNeutronInterface.java

   1 package org.opendaylight.neutron.transcriber;
   2
   3 import java.util.concurrent.ExecutionException;
   4
   5 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
   6 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
   7 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
   8 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
   9 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
  10 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
  11 import org.opendaylight.yangtools.yang.binding.DataObject;
  12 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  13 import org.slf4j.Logger;
  14 import org.slf4j.LoggerFactory;
  15
  16 import com.google.common.base.Preconditions;
  17 import com.google.common.base.Predicates;
  18 import com.google.common.util.concurrent.CheckedFuture;
  19
  20 public abstract class AbstractNeutronInterface<T extends DataObject,S> implements AutoCloseable {
  21     private static final Logger LOGGER = LoggerFactory.getLogger(AbstractNeutronInterface.class);
  22     private static final int DEDASHED_UUID_LENGTH = 32;
  23     private static final int DEDASHED_UUID_START = 0;
  24     private static final int DEDASHED_UUID_DIV1 = 8;
  25     private static final int DEDASHED_UUID_DIV2 = 12;
  26     private static final int DEDASHED_UUID_DIV3 = 16;
  27     private static final int DEDASHED_UUID_DIV4 = 20;
  28
  29
  30     private ProviderContext providerContext;
  31     private DataBroker db;
  32
  33     AbstractNeutronInterface(ProviderContext providerContext) {
  34         this.providerContext = providerContext;
  35         this.db = providerContext.getSALService(DataBroker.class);
  36     }
  37
  38     public DataBroker getDataBroker() {
  39         return db;
  40     }
  41
  42     protected abstract InstanceIdentifier<T> createInstanceIdentifier(T item);
  43
  44     protected abstract T toMd(S neutronObject);
  45
  46     protected abstract T toMd(String uuid);
  47
  48     protected boolean addMd(S neutronObject) {
  49         // TODO think about adding existence logic
  50         WriteTransaction transaction = getDataBroker().newWriteOnlyTransaction();
  51         T item = toMd(neutronObject);
  52         InstanceIdentifier<T> iid = createInstanceIdentifier(item);
  53         transaction.put(LogicalDatastoreType.CONFIGURATION, iid, item,true);
  54         CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
  55         try {
  56             future.get();
  57         } catch (InterruptedException | ExecutionException e) {
  58             LOGGER.warn("Transation failed ",e);
  59             return false;
  60         }
  61         return true;
  62     }
  63
  64     protected boolean updateMd(S neutronObject) {
  65         WriteTransaction transaction = getDataBroker().newWriteOnlyTransaction();
  66         T item = toMd(neutronObject);
  67         InstanceIdentifier<T> iid = createInstanceIdentifier(item);
  68         transaction.put(LogicalDatastoreType.CONFIGURATION, iid, item,true);
  69         CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
  70         try {
  71             future.get();
  72         } catch (InterruptedException | ExecutionException e) {
  73             LOGGER.warn("Transation failed ",e);
  74             return false;
  75         }
  76         return true;
  77     }
  78
  79     protected boolean removeMd(T item) {
  80         WriteTransaction transaction = getDataBroker().newWriteOnlyTransaction();
  81         InstanceIdentifier<T> iid = createInstanceIdentifier(item);
  82         transaction.delete(LogicalDatastoreType.CONFIGURATION, iid);
  83         CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
  84         return true;
  85     }
  86
  87     protected Uuid toUuid(String uuid) {
  88         Preconditions.checkNotNull(uuid);
  89         Uuid result;
  90         try {
  91             result = new Uuid(uuid);
  92         } catch(IllegalArgumentException e) {
  93             // OK... someone didn't follow RFC 4122... lets try this the hard way
  94             String dedashed = uuid.replace("-", "");
  95             if(dedashed.length() == DEDASHED_UUID_LENGTH) {
  96                 String redashed = dedashed.substring(DEDASHED_UUID_START, DEDASHED_UUID_DIV1) // 8 chars
  97                         + "-"
  98                         + dedashed.substring(DEDASHED_UUID_DIV1, DEDASHED_UUID_DIV2) // 4 chars
  99                         + "-"
 100                         + dedashed.substring(DEDASHED_UUID_DIV2, DEDASHED_UUID_DIV3) // 4 chars
 101                         + "-"
 102                         + dedashed.substring(DEDASHED_UUID_DIV3, DEDASHED_UUID_DIV4) // 4 chars
 103                         + "-"
 104                         + dedashed.substring(DEDASHED_UUID_DIV4, DEDASHED_UUID_LENGTH); // 12 chars
 105                 result = new Uuid(redashed);
 106             } else {
 107                 throw e;
 108             }
 109         }
 110         return result;
 111     }
 112
 113     @Override
 114     public void close() throws Exception {
 115         // TODO Auto-generated method stub
 116
 117     }
 118
 119 }