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