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

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