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