hwvtepsouthbound/hwvtepsouthbound-impl/src/main/java/org/opendaylight/ovsdb/hwvtepsouthbound/transact/HwvtepOperationalState.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
   9 package org.opendaylight.ovsdb.hwvtepsouthbound.transact;
  10
  11 import java.util.Collection;
  12 import java.util.HashMap;
  13 import java.util.List;
  14 import java.util.Map;
  15 import java.util.Map.Entry;
  16
  17 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  18 import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
  19 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
  20 import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundUtil;
  21 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.EncapsulationTypeBase;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepGlobalAugmentation;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepNodeName;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepPhysicalLocatorAugmentation;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepPhysicalPortAugmentation;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.PhysicalSwitchAugmentation;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LocalMcastMacs;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LocalMcastMacsKey;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LocalUcastMacs;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LocalUcastMacsKey;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LogicalSwitches;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LogicalSwitchesKey;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteMcastMacs;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteMcastMacsKey;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteUcastMacs;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteUcastMacsKey;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.Switches;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical._switch.attributes.Tunnels;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical._switch.attributes.TunnelsKey;
  41 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  42 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
  43 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  44 import org.slf4j.Logger;
  45 import org.slf4j.LoggerFactory;
  46
  47 import com.google.common.base.Optional;
  48 import com.google.common.base.Preconditions;
  49
  50 //TODO: need to be optimized, get entry by iid not name
  51 public class HwvtepOperationalState {
  52     private static final Logger LOG = LoggerFactory.getLogger(HwvtepOperationalState.class);
  53     private Map<InstanceIdentifier<Node>, Node> operationalNodes = new HashMap<>();
  54     ReadWriteTransaction transaction;
  55
  56     public HwvtepOperationalState(DataBroker db, Collection<DataTreeModification<Node>> changes) {
  57         Map<InstanceIdentifier<Node>, Node> nodeCreateOrUpdate =
  58             TransactUtils.extractCreatedOrUpdatedOrRemoved(changes, Node.class);
  59         if (nodeCreateOrUpdate != null) {
  60             transaction = db.newReadWriteTransaction();
  61             for (Entry<InstanceIdentifier<Node>, Node> entry: nodeCreateOrUpdate.entrySet()) {
  62                 Optional<Node> readNode = HwvtepSouthboundUtil.readNode(transaction, entry.getKey());
  63                 //add related globalNode or physicalSwitchNode to operationalNodes map
  64                 //for example, when creating physical port, logical switch is needed
  65                 //but logical switch is in HwvtepGlobalAugmentation rather than PhysicalSwitchAugmentation
  66                 if (readNode.isPresent()) {
  67                     operationalNodes.put(entry.getKey(), readNode.get());
  68                     HwvtepGlobalAugmentation hgAugmentation = readNode.get().getAugmentation(HwvtepGlobalAugmentation.class);
  69                     PhysicalSwitchAugmentation psAugmentation = readNode.get().getAugmentation(PhysicalSwitchAugmentation.class);
  70                     if (hgAugmentation != null && hgAugmentation.getSwitches() != null) {
  71                         for (Switches pswitch : hgAugmentation.getSwitches()) {
  72                             @SuppressWarnings("unchecked")
  73                             InstanceIdentifier<Node> psNodeIid = (InstanceIdentifier<Node>) pswitch.getSwitchRef().getValue();
  74                             Optional<Node> psNode = HwvtepSouthboundUtil.readNode(transaction, psNodeIid);
  75                             if (psNode.isPresent()) {
  76                                 operationalNodes.put(psNodeIid, psNode.get());
  77                             }
  78                         }
  79                     }
  80                     if (psAugmentation != null) {
  81                         @SuppressWarnings("unchecked")
  82                         InstanceIdentifier<Node> hgNodeIid = (InstanceIdentifier<Node>) psAugmentation.getManagedBy().getValue();
  83                         Optional<Node> hgNode = HwvtepSouthboundUtil.readNode(transaction, hgNodeIid);
  84                         if (hgNode.isPresent()) {
  85                             operationalNodes.put(hgNodeIid, hgNode.get());
  86                         }
  87                     }
  88                 }
  89             }
  90         }
  91     }
  92
  93     private Optional<Node> getGlobalNode(InstanceIdentifier<?> iid) {
  94         InstanceIdentifier<Node> nodeIid = iid.firstIdentifierOf(Node.class);
  95         return Optional.fromNullable(operationalNodes.get(nodeIid));
  96     }
  97
  98     public Optional<HwvtepGlobalAugmentation> getHwvtepGlobalAugmentation(InstanceIdentifier<?> iid) {
  99         Preconditions.checkNotNull(iid);
 100         Optional<Node> nodeOptional = getGlobalNode(iid);
 101         if (nodeOptional.isPresent()) {
 102             return Optional.fromNullable(nodeOptional.get().getAugmentation(HwvtepGlobalAugmentation.class));
 103         }
 104         return Optional.absent();
 105     }
 106
 107     public Optional<PhysicalSwitchAugmentation> getPhysicalSwitchAugmentation(InstanceIdentifier<?> iid) {
 108         Preconditions.checkNotNull(iid);
 109         Optional<Node> nodeOptional = getGlobalNode(iid);
 110         if (nodeOptional.isPresent()) {
 111             return Optional.fromNullable(nodeOptional.get().getAugmentation(PhysicalSwitchAugmentation.class));
 112         }
 113         return Optional.absent();
 114     }
 115
 116     public Optional<List<TerminationPoint>> getTerminationPointList(InstanceIdentifier<?> iid) {
 117         Preconditions.checkNotNull(iid);
 118         Optional<Node> nodeOptional = getGlobalNode(iid);
 119         if (nodeOptional.isPresent() && nodeOptional.get().getTerminationPoint() != null) {
 120             return Optional.fromNullable(nodeOptional.get().getTerminationPoint());
 121         }
 122         return Optional.absent();
 123     }
 124
 125     public Optional<LogicalSwitches> getLogicalSwitches(InstanceIdentifier<?> iid, LogicalSwitchesKey logicalSwitchesKey) {
 126         Preconditions.checkNotNull(iid);
 127         Optional<HwvtepGlobalAugmentation> nodeOptional = getHwvtepGlobalAugmentation(iid);
 128         if (nodeOptional.isPresent()) {
 129             HwvtepGlobalAugmentation hgAugmentation = nodeOptional.get();
 130             List<LogicalSwitches> lswitchList = null;
 131             if (hgAugmentation != null) {
 132                 lswitchList = hgAugmentation.getLogicalSwitches();
 133             }
 134             if (lswitchList != null) {
 135                 for (LogicalSwitches lswitch: lswitchList) {
 136                     if (lswitch.getKey().equals(logicalSwitchesKey)) {
 137                         return Optional.fromNullable(lswitch);
 138                     }
 139                 }
 140             }
 141         }
 142         return Optional.absent();
 143     }
 144
 145     public Optional<Tunnels> getTunnels(InstanceIdentifier<?> iid, TunnelsKey tunnelsKey) {
 146         Preconditions.checkNotNull(iid);
 147         Optional<PhysicalSwitchAugmentation> psOptional = getPhysicalSwitchAugmentation(iid);
 148         if (psOptional.isPresent()) {
 149             PhysicalSwitchAugmentation psAugmentation = psOptional.get();
 150             List<Tunnels> tunnelList = null;
 151             if (psAugmentation != null) {
 152                 tunnelList = psAugmentation.getTunnels();
 153             }
 154             if (tunnelList != null) {
 155                 for (Tunnels tunnel: tunnelList) {
 156                     if (tunnel.getKey().equals(tunnelsKey)) {
 157                         return Optional.fromNullable(tunnel);
 158                     }
 159                 }
 160             }
 161         }
 162         return Optional.absent();
 163     }
 164
 165     public Optional<HwvtepPhysicalPortAugmentation> getPhysicalPortAugmentation(InstanceIdentifier<?> iid,
 166             HwvtepNodeName hwvtepNodeName) {
 167         Preconditions.checkNotNull(iid);
 168         Optional<List<TerminationPoint>> nodeOptional = getTerminationPointList(iid);
 169         if (nodeOptional.isPresent()) {
 170             List<TerminationPoint> tpList = nodeOptional.get();
 171             for (TerminationPoint tp : tpList) {
 172                 HwvtepPhysicalPortAugmentation hppAugmentation = tp.getAugmentation(HwvtepPhysicalPortAugmentation.class);
 173                 if (hppAugmentation.getHwvtepNodeName().equals(hwvtepNodeName)) {
 174                     return Optional.fromNullable(hppAugmentation);
 175                 }
 176             }
 177         }
 178         return Optional.absent();
 179     }
 180
 181     public Optional<HwvtepPhysicalLocatorAugmentation> getPhysicalLocatorAugmentation(InstanceIdentifier<?> iid,
 182             IpAddress dstIp, Class<? extends EncapsulationTypeBase> encapType) {
 183         Preconditions.checkNotNull(iid);
 184         Optional<List<TerminationPoint>> nodeOptional = getTerminationPointList(iid);
 185         if (nodeOptional.isPresent()) {
 186             List<TerminationPoint> tpList = nodeOptional.get();
 187             for (TerminationPoint tp : tpList) {
 188                 HwvtepPhysicalLocatorAugmentation hppAugmentation = tp.getAugmentation(HwvtepPhysicalLocatorAugmentation.class);
 189                 if (hppAugmentation.getDstIp().equals(dstIp)
 190                         && hppAugmentation.getEncapsulationType().equals(encapType)) {
 191                     return Optional.fromNullable(hppAugmentation);
 192                 }
 193             }
 194         }
 195         return Optional.absent();
 196     }
 197
 198     public Optional<LocalMcastMacs> getLocalMcastMacs(InstanceIdentifier<?> iid, LocalMcastMacsKey key) {
 199         Preconditions.checkNotNull(iid);
 200         Optional<HwvtepGlobalAugmentation> nodeOptional = getHwvtepGlobalAugmentation(iid);
 201         if (nodeOptional.isPresent()) {
 202             HwvtepGlobalAugmentation hgAugmentation = nodeOptional.get();
 203             List<LocalMcastMacs> macList = null;
 204             if (hgAugmentation != null) {
 205                 macList = hgAugmentation.getLocalMcastMacs();
 206             }
 207             if (macList != null) {
 208                 for (LocalMcastMacs mac: macList) {
 209                     if (mac.getKey().equals(key)) {
 210                         return Optional.fromNullable(mac);
 211                     }
 212                 }
 213             }
 214         }
 215         return Optional.absent();
 216     }
 217
 218     public Optional<RemoteMcastMacs> getRemoteMcastMacs(InstanceIdentifier<?> iid, RemoteMcastMacsKey key) {
 219         Preconditions.checkNotNull(iid);
 220         Optional<HwvtepGlobalAugmentation> nodeOptional = getHwvtepGlobalAugmentation(iid);
 221         if (nodeOptional.isPresent()) {
 222             HwvtepGlobalAugmentation hgAugmentation = nodeOptional.get();
 223             List<RemoteMcastMacs> macList = null;
 224             if (hgAugmentation != null) {
 225                 macList = hgAugmentation.getRemoteMcastMacs();
 226             }
 227             if (macList != null) {
 228                 for (RemoteMcastMacs mac: macList) {
 229                     if (mac.getKey().equals(key)) {
 230                         return Optional.fromNullable(mac);
 231                     }
 232                 }
 233             }
 234         }
 235         return Optional.absent();
 236     }
 237
 238     public Optional<LocalUcastMacs> getLocalUcastMacs(InstanceIdentifier<?> iid, LocalUcastMacsKey key) {
 239         Preconditions.checkNotNull(iid);
 240         Optional<HwvtepGlobalAugmentation> nodeOptional = getHwvtepGlobalAugmentation(iid);
 241         if (nodeOptional.isPresent()) {
 242             HwvtepGlobalAugmentation hgAugmentation = nodeOptional.get();
 243             List<LocalUcastMacs> macList = null;
 244             if (hgAugmentation != null) {
 245                 macList = hgAugmentation.getLocalUcastMacs();
 246             }
 247             if (macList != null) {
 248                 for (LocalUcastMacs mac: macList) {
 249                     if (mac.getKey().equals(key)) {
 250                         return Optional.fromNullable(mac);
 251                     }
 252                 }
 253             }
 254         }
 255         return Optional.absent();
 256     }
 257
 258     public Optional<RemoteUcastMacs> getRemoteUcastMacs(InstanceIdentifier<?> iid, RemoteUcastMacsKey key) {
 259         Preconditions.checkNotNull(iid);
 260         Optional<HwvtepGlobalAugmentation> nodeOptional = getHwvtepGlobalAugmentation(iid);
 261         if (nodeOptional.isPresent()) {
 262             HwvtepGlobalAugmentation hgAugmentation = nodeOptional.get();
 263             List<RemoteUcastMacs> macList = null;
 264             if (hgAugmentation != null) {
 265                 macList = hgAugmentation.getRemoteUcastMacs();
 266             }
 267             if (macList != null) {
 268                 for (RemoteUcastMacs mac: macList) {
 269                     if (mac.getKey().equals(key)) {
 270                         return Optional.fromNullable(mac);
 271                     }
 272                 }
 273             }
 274         }
 275         return Optional.absent();
 276     }
 277
 278     public Optional<HwvtepPhysicalLocatorAugmentation> getPhysicalLocatorAugmentation(InstanceIdentifier<TerminationPoint> iid) {
 279         Optional<TerminationPoint> tp = HwvtepSouthboundUtil.readNode(transaction, iid);
 280         if (tp.isPresent()) {
 281             return Optional.fromNullable(tp.get().getAugmentation(HwvtepPhysicalLocatorAugmentation.class));
 282         }
 283         return Optional.absent();
 284     }
 285
 286     public Optional<LogicalSwitches> getLogicalSwitches(InstanceIdentifier<LogicalSwitches> iid) {
 287         Optional<LogicalSwitches> lswitch = HwvtepSouthboundUtil.readNode(transaction, iid);
 288         return lswitch;
 289     }
 290
 291     public Optional<Tunnels> getTunnels(InstanceIdentifier<Tunnels> iid) {
 292         Optional<Tunnels> tunnels = HwvtepSouthboundUtil.readNode(transaction, iid);
 293         return tunnels;
 294     }
 295
 296     public ReadWriteTransaction getReadWriteTransaction() {
 297         return transaction;
 298     }
 299 }