hwvtepsouthbound/hwvtepsouthbound-impl/src/main/java/org/opendaylight/ovsdb/hwvtepsouthbound/transact/TransactUtils.java

   1 /*
   2  * Copyright (c) 2015 China Telecom Beijing Research Institute and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.ovsdb.hwvtepsouthbound.transact;
   9
  10 import static org.opendaylight.ovsdb.lib.operations.Operations.op;
  11
  12 import java.util.Collection;
  13 import java.util.HashMap;
  14 import java.util.Map;
  15
  16 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  17 import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
  18 import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
  19 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
  20 import org.opendaylight.controller.md.sal.binding.api.DataObjectModification.ModificationType;
  21 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  22 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  23 import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundConstants;
  24 import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundMapper;
  25 import org.opendaylight.ovsdb.lib.notation.UUID;
  26 import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
  27 import org.opendaylight.ovsdb.lib.schema.typed.TyperUtils;
  28 import org.opendaylight.ovsdb.schema.hardwarevtep.PhysicalLocator;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepPhysicalLocatorAugmentation;
  30 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  31 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  32 import org.slf4j.Logger;
  33 import org.slf4j.LoggerFactory;
  34
  35 import com.google.common.base.Optional;
  36
  37 public class TransactUtils {
  38     private static final Logger LOG = LoggerFactory.getLogger(TransactUtils.class);
  39
  40     public static Node getCreated(DataObjectModification<Node> mod) {
  41         if((mod.getModificationType() == ModificationType.WRITE)
  42                         && (mod.getDataBefore() == null)){
  43             return mod.getDataAfter();
  44         }
  45         return null;
  46     }
  47
  48     public static Node getRemoved(DataObjectModification<Node> mod) {
  49         if(mod.getModificationType() == ModificationType.DELETE){
  50             return mod.getDataBefore();
  51         }
  52         return null;
  53     }
  54
  55     public static Node getUpdated(DataObjectModification<Node> mod) {
  56         Node node = null;
  57         switch(mod.getModificationType()) {
  58             case SUBTREE_MODIFIED:
  59                 node = mod.getDataAfter();
  60                 break;
  61             case WRITE:
  62                 if(mod.getDataBefore() !=  null) {
  63                     node = mod.getDataAfter();
  64                 }
  65                 break;
  66             default:
  67                 break;
  68         }
  69         return node;
  70     }
  71
  72     public static Node getOriginal(DataObjectModification<Node> mod) {
  73         Node node = null;
  74         switch(mod.getModificationType()) {
  75             case SUBTREE_MODIFIED:
  76                 node = mod.getDataBefore();
  77                 break;
  78             case WRITE:
  79                 if(mod.getDataBefore() !=  null) {
  80                     node = mod.getDataBefore();
  81                 }
  82                 break;
  83             case DELETE:
  84                 node = mod.getDataBefore();
  85                 break;
  86             default:
  87                 break;
  88         }
  89         return node;
  90     }
  91
  92     //TODO: change this function to be generic
  93     public static Map<InstanceIdentifier<Node>, Node> extractCreatedOrUpdatedOrRemoved(
  94             Collection<DataTreeModification<Node>> changes, Class<Node> class1) {
  95         Map<InstanceIdentifier<Node>, Node> result = new HashMap<InstanceIdentifier<Node>, Node>();
  96         for(DataTreeModification<Node> change : changes) {
  97             final InstanceIdentifier<Node> key = change.getRootPath().getRootIdentifier();
  98             final DataObjectModification<Node> mod = change.getRootNode();
  99             Node created = getCreated(mod);
 100             if (created != null) {
 101                 result.put(key, created);
 102             }
 103             Node updated = getUpdated(mod);
 104             if (updated != null) {
 105                 result.put(key, updated);
 106             }
 107             Node deleted = getRemoved(mod);
 108             if (deleted != null) {
 109                 result.put(key, deleted);
 110             }
 111         }
 112         return result;
 113     }
 114
 115     /*
 116     public static <T extends Augmentation<Node>> Map<InstanceIdentifier<? extends DataObject>, T> extractCreated(
 117             Collection<DataTreeModification<Node>> changes, Class<T> class1) {
 118         // TODO Auto-generated method stub
 119         Map<InstanceIdentifier<?>, T> result =
 120             new HashMap<InstanceIdentifier<?>, T>();
 121         if(changes != null && !changes.isEmpty()) {
 122             for(DataTreeModification<Node> change : changes) {
 123                 final InstanceIdentifier<Node> key = change.getRootPath().getRootIdentifier();
 124                 final DataObjectModification<Node> mod = change.getRootNode();
 125                 Node created = getCreated(mod);
 126                 if(created != null) {
 127                     T logicalSwitch = created.getAugmentation(class1);
 128                     created.getKey().getNodeId().get
 129                     logicalSwitch.
 130                     InstanceIdentifier<?> iid = change.getRootPath().getRootIdentifier()..augmentation(class1);
 131                     if(logicalSwitch != null) {
 132                         result.put(iid, logicalSwitch);
 133                     }
 134                 }
 135             }
 136         }
 137         return result;
 138     }
 139     */
 140
 141     public static <D extends org.opendaylight.yangtools.yang.binding.DataObject> Optional<D> readNodeFromConfig(
 142             ReadWriteTransaction transaction, final InstanceIdentifier<D> connectionIid) {
 143         Optional<D> node = Optional.absent();
 144         try {
 145             node = transaction.read(LogicalDatastoreType.CONFIGURATION, connectionIid).checkedGet();
 146         } catch (final ReadFailedException e) {
 147             LOG.warn("Read Configration/DS for Node failed! {}", connectionIid, e);
 148         }
 149         return node;
 150     }
 151
 152     public static UUID createPhysicalLocator(TransactionBuilder transaction, HwvtepPhysicalLocatorAugmentation inputLocator) {
 153         LOG.debug("Creating a physical locator: {}", inputLocator.getDstIp());
 154         PhysicalLocator physicalLocator = TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(), PhysicalLocator.class);
 155         setEncapsulationType(physicalLocator, inputLocator);
 156         setDstIp(physicalLocator, inputLocator);
 157         String locatorUuid = "PhysicalLocator_" + HwvtepSouthboundMapper.getRandomUUID();
 158         transaction.add(op.insert(physicalLocator).withId(locatorUuid));
 159         return new UUID(locatorUuid);
 160     }
 161
 162     private static final void setEncapsulationType(PhysicalLocator physicalLocator, HwvtepPhysicalLocatorAugmentation inputLocator) {
 163         if (inputLocator.getEncapsulationType() != null) {
 164             String encapType = HwvtepSouthboundConstants.ENCAPS_TYPE_MAP.get(HwvtepSouthboundMapper.createEncapsulationType(""));
 165             physicalLocator.setEncapsulationType(encapType);
 166         }
 167     }
 168
 169     private static final void setDstIp(PhysicalLocator physicalLocator, HwvtepPhysicalLocatorAugmentation inputLocator) {
 170         if (inputLocator.getDstIp() != null) {
 171             physicalLocator.setDstIp(inputLocator.getDstIp().getIpv4Address().getValue());
 172         }
 173     }
 174 }