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         WriteTransaction transaction = getDataBroker().newWriteOnlyTransaction();
  49         T item = toMd(neutronObject);
  50         InstanceIdentifier<T> iid = createInstanceIdentifier(item);
  51         transaction.put(LogicalDatastoreType.CONFIGURATION, iid, item,true);
  52         CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
  53         try {
  54             future.get();
  55         } catch (InterruptedException | ExecutionException e) {
  56             LOGGER.warn("Transation failed ",e);
  57             return false;
  58         }
  59         return true;
  60     }
  61
  62     protected boolean updateMd(S neutronObject) {
  63         WriteTransaction transaction = getDataBroker().newWriteOnlyTransaction();
  64         T item = toMd(neutronObject);
  65         InstanceIdentifier<T> iid = createInstanceIdentifier(item);
  66         transaction.put(LogicalDatastoreType.CONFIGURATION, iid, item,true);
  67         CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
  68         try {
  69             future.get();
  70         } catch (InterruptedException | ExecutionException e) {
  71             LOGGER.warn("Transation failed ",e);
  72             return false;
  73         }
  74         return true;
  75     }
  76
  77     protected boolean removeMd(T item) {
  78         WriteTransaction transaction = getDataBroker().newWriteOnlyTransaction();
  79         InstanceIdentifier<T> iid = createInstanceIdentifier(item);
  80         transaction.delete(LogicalDatastoreType.CONFIGURATION, iid);
  81         CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
  82         return true;
  83     }
  84
  85     protected Uuid toUuid(String uuid) {
  86         Preconditions.checkNotNull(uuid);
  87         Uuid result;
  88         try {
  89             result = new Uuid(uuid);
  90         } catch(IllegalArgumentException e) {
  91             // OK... someone didn't follow RFC 4122... lets try this the hard way
  92             String dedashed = uuid.replace("-", "");
  93             if(dedashed.length() == DEDASHED_UUID_LENGTH) {
  94                 String redashed = dedashed.substring(DEDASHED_UUID_START, DEDASHED_UUID_DIV1)
  95                         + "-"
  96                         + dedashed.substring(DEDASHED_UUID_DIV1, DEDASHED_UUID_DIV2)
  97                         + "-"
  98                         + dedashed.substring(DEDASHED_UUID_DIV2, DEDASHED_UUID_DIV3)
  99                         + "-"
 100                         + dedashed.substring(DEDASHED_UUID_DIV3, DEDASHED_UUID_DIV4)
 101                         + "-"
 102                         + dedashed.substring(DEDASHED_UUID_DIV4, DEDASHED_UUID_LENGTH);
 103                 result = new Uuid(redashed);
 104             } else {
 105                 throw e;
 106             }
 107         }
 108         return result;
 109     }
 110
 111     // this method uses reflection to update an object from it's delta.
 112
 113     protected boolean overwrite(Object target, Object delta) {
 114         Method[] methods = target.getClass().getMethods();
 115
 116         for(Method toMethod: methods){
 117             if(toMethod.getDeclaringClass().equals(target.getClass())
 118                     && toMethod.getName().startsWith("set")){
 119
 120                 String toName = toMethod.getName();
 121                 String fromName = toName.replace("set", "get");
 122
 123                 try {
 124                     Method fromMethod = delta.getClass().getMethod(fromName);
 125                     Object value = fromMethod.invoke(delta, (Object[])null);
 126                     if(value != null){
 127                         toMethod.invoke(target, value);
 128                     }
 129                 } catch (Exception e) {
 130                     LOGGER.error("Error in overwrite", e);
 131                     return false;
 132                 }
 133             }
 134         }
 135         return true;
 136     }
 137
 138     @Override
 139     public void close() throws Exception {
 140         // TODO Auto-generated method stub
 141
 142     }
 143
 144 }