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

   1 /*
   2  * Copyright © 2015, 2017 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.HashSet;
  15 import java.util.List;
  16 import java.util.Map;
  17 import java.util.Set;
  18
  19 import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
  20 import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
  21 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
  22 import org.opendaylight.controller.md.sal.binding.api.DataObjectModification.ModificationType;
  23 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  24 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  25 import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepDeviceInfo;
  26 import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundConstants;
  27 import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundMapper;
  28 import org.opendaylight.ovsdb.lib.notation.UUID;
  29 import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
  30 import org.opendaylight.ovsdb.lib.schema.typed.TyperUtils;
  31 import org.opendaylight.ovsdb.schema.hardwarevtep.PhysicalLocator;
  32 import org.opendaylight.ovsdb.schema.hardwarevtep.PhysicalLocatorSet;
  33 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.EncapsulationTypeVxlanOverIpv4;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepNodeName;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepPhysicalLocatorAugmentation;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepPhysicalLocatorAugmentationBuilder;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical.locator.set.attributes.LocatorSet;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LogicalRouters;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LogicalSwitches;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.Acls;
  42 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  43 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
  44 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  45 import org.slf4j.Logger;
  46 import org.slf4j.LoggerFactory;
  47
  48 import com.google.common.base.Optional;
  49
  50 public class TransactUtils {
  51     private static final Logger LOG = LoggerFactory.getLogger(TransactUtils.class);
  52
  53     private TransactUtils(){
  54     }
  55
  56     public static Node getCreated(DataObjectModification<Node> mod) {
  57         if((mod.getModificationType() == ModificationType.WRITE)
  58                         && (mod.getDataBefore() == null)){
  59             return mod.getDataAfter();
  60         }
  61         return null;
  62     }
  63
  64     public static Node getRemoved(DataObjectModification<Node> mod) {
  65         if(mod.getModificationType() == ModificationType.DELETE){
  66             return mod.getDataBefore();
  67         }
  68         return null;
  69     }
  70
  71     public static Node getUpdated(DataObjectModification<Node> mod) {
  72         Node node = null;
  73         switch(mod.getModificationType()) {
  74             case SUBTREE_MODIFIED:
  75                 node = mod.getDataAfter();
  76                 break;
  77             case WRITE:
  78                 if(mod.getDataBefore() !=  null) {
  79                     node = mod.getDataAfter();
  80                 }
  81                 break;
  82             default:
  83                 break;
  84         }
  85         return node;
  86     }
  87
  88     public static Node getOriginal(DataObjectModification<Node> mod) {
  89         Node node = null;
  90         switch(mod.getModificationType()) {
  91             case SUBTREE_MODIFIED:
  92                 node = mod.getDataBefore();
  93                 break;
  94             case WRITE:
  95                 if(mod.getDataBefore() !=  null) {
  96                     node = mod.getDataBefore();
  97                 }
  98                 break;
  99             case DELETE:
 100                 node = mod.getDataBefore();
 101                 break;
 102             default:
 103                 break;
 104         }
 105         return node;
 106     }
 107
 108     //TODO: change this function to be generic
 109     public static Map<InstanceIdentifier<Node>, Node> extractCreatedOrUpdatedOrRemoved(
 110             Collection<DataTreeModification<Node>> changes, Class<Node> class1) {
 111         Map<InstanceIdentifier<Node>, Node> result = new HashMap<>();
 112         for(DataTreeModification<Node> change : changes) {
 113             final InstanceIdentifier<Node> key = change.getRootPath().getRootIdentifier();
 114             final DataObjectModification<Node> mod = change.getRootNode();
 115             Node created = getCreated(mod);
 116             if (created != null) {
 117                 result.put(key, created);
 118             }
 119             Node updated = getUpdated(mod);
 120             if (updated != null) {
 121                 result.put(key, updated);
 122             }
 123             Node deleted = getRemoved(mod);
 124             if (deleted != null) {
 125                 result.put(key, deleted);
 126             }
 127         }
 128         return result;
 129     }
 130
 131     public static <D extends org.opendaylight.yangtools.yang.binding.DataObject> Optional<D> readNodeFromConfig(
 132             ReadWriteTransaction transaction, final InstanceIdentifier<D> connectionIid) {
 133         Optional<D> node = Optional.absent();
 134         try {
 135             node = transaction.read(LogicalDatastoreType.CONFIGURATION, connectionIid).checkedGet();
 136         } catch (final ReadFailedException e) {
 137             LOG.warn("Read Configration/DS for Node failed! {}", connectionIid, e);
 138         }
 139         return node;
 140     }
 141
 142     public static UUID createPhysicalLocatorSet(HwvtepOperationalState hwvtepOperationalState, TransactionBuilder transaction, List<LocatorSet> locatorList) {
 143         Set<UUID> locators = new HashSet<UUID>();
 144         for (LocatorSet locator: locatorList) {
 145             @SuppressWarnings("unchecked")
 146             InstanceIdentifier<TerminationPoint> iid =(InstanceIdentifier<TerminationPoint>) locator.getLocatorRef().getValue();
 147             UUID locatorUuid = createPhysicalLocator(transaction, hwvtepOperationalState, iid);
 148             if (locatorUuid != null) {
 149                 locators.add(locatorUuid);
 150             }
 151         }
 152         PhysicalLocatorSet physicalLocatorSet = TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(), PhysicalLocatorSet.class);
 153         physicalLocatorSet.setLocators(locators);
 154         String locatorSetUuid = "PhysicalLocatorSet_" + HwvtepSouthboundMapper.getRandomUUID();
 155         transaction.add(op.insert(physicalLocatorSet).withId(locatorSetUuid));
 156         return new UUID(locatorSetUuid);
 157     }
 158
 159     public static UUID createPhysicalLocator(TransactionBuilder transaction, HwvtepOperationalState operationalState,
 160                                              InstanceIdentifier<TerminationPoint> iid) {
 161         UUID locatorUuid = null;
 162         HwvtepDeviceInfo.DeviceData deviceData = operationalState.getDeviceInfo().getDeviceOperData(
 163                 TerminationPoint.class, iid);
 164         if (deviceData != null && deviceData.getUuid() != null) {
 165             locatorUuid = deviceData.getUuid();
 166             return locatorUuid;
 167         }
 168         locatorUuid = operationalState.getUUIDFromCurrentTx(TerminationPoint.class, iid);
 169         if (locatorUuid != null) {
 170             return locatorUuid;
 171         }
 172         HwvtepPhysicalLocatorAugmentationBuilder builder = new HwvtepPhysicalLocatorAugmentationBuilder();
 173         HwvtepPhysicalLocatorAugmentation locatorAugmentation = null;
 174         builder.setEncapsulationType(EncapsulationTypeVxlanOverIpv4.class);
 175         String tepKey = iid.firstKeyOf(TerminationPoint.class).getTpId().getValue();
 176         String ip = tepKey.substring(tepKey.indexOf(":")+1);
 177         builder.setDstIp(new IpAddress(ip.toCharArray()));
 178         locatorAugmentation = builder.build();
 179         locatorUuid = TransactUtils.createPhysicalLocator(transaction, locatorAugmentation);
 180         operationalState.updateCurrentTxData(TerminationPoint.class, iid, locatorUuid);
 181         operationalState.getDeviceInfo().markKeyAsInTransit(TerminationPoint.class, iid);
 182         return locatorUuid;
 183     }
 184
 185     public static UUID createPhysicalLocator(TransactionBuilder transaction, HwvtepPhysicalLocatorAugmentation inputLocator) {
 186         LOG.debug("Creating a physical locator: {}", inputLocator.getDstIp());
 187         PhysicalLocator physicalLocator = TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(), PhysicalLocator.class);
 188         setEncapsulationType(physicalLocator, inputLocator);
 189         setDstIp(physicalLocator, inputLocator);
 190         String locatorUuid = "PhysicalLocator_" + HwvtepSouthboundMapper.getRandomUUID();
 191         transaction.add(op.insert(physicalLocator).withId(locatorUuid));
 192         return new UUID(locatorUuid);
 193     }
 194
 195     private static final void setEncapsulationType(PhysicalLocator physicalLocator, HwvtepPhysicalLocatorAugmentation inputLocator) {
 196         if (inputLocator.getEncapsulationType() != null) {
 197             String encapType = HwvtepSouthboundConstants.ENCAPS_TYPE_MAP.get(HwvtepSouthboundMapper.createEncapsulationType(""));
 198             physicalLocator.setEncapsulationType(encapType);
 199         }
 200     }
 201
 202     private static final void setDstIp(PhysicalLocator physicalLocator, HwvtepPhysicalLocatorAugmentation inputLocator) {
 203         if (inputLocator.getDstIp() != null) {
 204             physicalLocator.setDstIp(inputLocator.getDstIp().getIpv4Address().getValue());
 205         }
 206     }
 207
 208     static String sanitizeUUID(HwvtepNodeName hwvtepNodeName) {
 209         return sanitizeUUID(hwvtepNodeName.getValue());
 210     }
 211
 212     static String sanitizeUUID(String nodeName) {
 213         //ovs is not accepting '-' in the named uuids
 214         return nodeName.replaceAll("-", "_");
 215     }
 216
 217     public static String getLogicalSwitchId(LogicalSwitches lswitch){
 218         return HwvtepSouthboundConstants.LOGICALSWITCH_UUID_PREFIX + sanitizeUUID(lswitch.getHwvtepNodeName());
 219     }
 220
 221     public static UUID getLogicalSwitchUUID(InstanceIdentifier<LogicalSwitches> lswitchIid){
 222         return new UUID(HwvtepSouthboundConstants.LOGICALSWITCH_UUID_PREFIX +
 223                 sanitizeUUID(lswitchIid.firstKeyOf(LogicalSwitches.class).getHwvtepNodeName()));
 224     }
 225
 226     public static String getLogicalRouterId(final LogicalRouters lrouter){
 227         return HwvtepSouthboundConstants.LOGICALROUTER_UUID_PREFIX + sanitizeUUID(lrouter.getHwvtepNodeName());
 228     }
 229
 230     public static UUID getAclUUID(final InstanceIdentifier<Acls> aclIid){
 231         return new UUID(HwvtepSouthboundConstants.ACL_UUID_PREFIX +
 232                 sanitizeUUID(aclIid.firstKeyOf(Acls.class).getAclName()));
 233     }
 234 }