hwvtepsouthbound/hwvtepsouthbound-impl/src/main/java/org/opendaylight/ovsdb/hwvtepsouthbound/transactions/md/PhysicalPortUpdateCommand.java

   1 /*
   2  * Copyright (c) 2015 Ericsson India Global Services Pvt Ltd. 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.transactions.md;
  10
  11 import java.util.ArrayList;
  12 import java.util.List;
  13 import java.util.Map;
  14 import java.util.Map.Entry;
  15 import java.util.Set;
  16
  17 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
  18 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  19 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  20 import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionInstance;
  21 import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundMapper;
  22 import org.opendaylight.ovsdb.lib.message.TableUpdates;
  23 import org.opendaylight.ovsdb.lib.notation.UUID;
  24 import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
  25 import org.opendaylight.ovsdb.lib.schema.typed.TyperUtils;
  26 import org.opendaylight.ovsdb.schema.hardwarevtep.LogicalSwitch;
  27 import org.opendaylight.ovsdb.schema.hardwarevtep.PhysicalPort;
  28 import org.opendaylight.ovsdb.schema.hardwarevtep.PhysicalSwitch;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepGlobalAugmentation;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepLogicalSwitchRef;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepNodeName;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepPhysicalPortAugmentation;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepPhysicalPortAugmentationBuilder;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.PhysicalSwitchAugmentation;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.Switches;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical.port.attributes.PhysicalPortIdBuilder;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical.port.attributes.VlanBindings;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical.port.attributes.VlanBindingsBuilder;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical.port.attributes.VlanBindingsKey;
  41 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
  42 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TpId;
  43 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  44 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
  45 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointBuilder;
  46 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
  47 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  48 import org.slf4j.Logger;
  49 import org.slf4j.LoggerFactory;
  50
  51 import com.google.common.base.Optional;
  52
  53 public class PhysicalPortUpdateCommand extends AbstractTransactionCommand {
  54
  55     private static final Logger LOG = LoggerFactory.getLogger(PhysicalPortUpdateCommand.class);
  56     private Map<UUID, PhysicalPort> updatedPPRows;
  57     private Map<UUID, PhysicalPort> oldPPRows;
  58     private Map<UUID, PhysicalSwitch> switchUpdatedRows;
  59     private Map<UUID, LogicalSwitch> lSwitchUpdatedRows;
  60
  61     public PhysicalPortUpdateCommand(HwvtepConnectionInstance key, TableUpdates updates,
  62             DatabaseSchema dbSchema) {
  63         super(key, updates, dbSchema);
  64         updatedPPRows = TyperUtils.extractRowsUpdated(PhysicalPort.class, getUpdates(),getDbSchema());
  65         oldPPRows = TyperUtils.extractRowsOld(PhysicalPort.class, getUpdates(),getDbSchema());
  66         switchUpdatedRows = TyperUtils.extractRowsUpdated(PhysicalSwitch.class, getUpdates(),getDbSchema());
  67         lSwitchUpdatedRows = TyperUtils.extractRowsUpdated(LogicalSwitch.class, getUpdates(),getDbSchema());
  68     }
  69
  70     @Override
  71     public void execute(ReadWriteTransaction transaction) {
  72         final InstanceIdentifier<Node> connectionIId = getOvsdbConnectionInstance().getInstanceIdentifier();
  73         if ( updatedPPRows == null
  74                 || updatedPPRows.isEmpty()) {
  75             return;
  76         }
  77         LOG.trace("PhysicalPortTable updated: {}", updatedPPRows);
  78         Optional<Node> node = readNode(transaction, connectionIId);
  79         if (node.isPresent()) {
  80             updateTerminationPoints(transaction, node.get());
  81             //TODO: Handle Deletion of VLAN Bindings
  82         }
  83     }
  84
  85     private void updateTerminationPoints(ReadWriteTransaction transaction, Node node) {
  86         for (Entry<UUID, PhysicalPort> pPortUpdate : updatedPPRows.entrySet()) {
  87             String portName = null;
  88             portName = pPortUpdate.getValue().getNameColumn().getData();
  89             Optional<InstanceIdentifier<Node>> switchIid = getTerminationPointSwitch(pPortUpdate.getKey());
  90             if (!switchIid.isPresent()) {
  91                 switchIid = getTerminationPointSwitch( transaction, node, portName);
  92             }
  93             if (switchIid.isPresent()) {
  94                 NodeId switchId = HwvtepSouthboundMapper.createManagedNodeId(switchIid.get());
  95                 TerminationPointKey tpKey = new TerminationPointKey(new TpId(portName));
  96                 TerminationPointBuilder tpBuilder = new TerminationPointBuilder();
  97                 tpBuilder.setKey(tpKey);
  98                 tpBuilder.setTpId(tpKey.getTpId());
  99                 InstanceIdentifier<TerminationPoint> tpPath =
 100                         getInstanceIdentifier(switchIid.get(), pPortUpdate.getValue());
 101                 HwvtepPhysicalPortAugmentationBuilder tpAugmentationBuilder =
 102                         new HwvtepPhysicalPortAugmentationBuilder();
 103                 buildTerminationPoint(tpAugmentationBuilder,pPortUpdate.getValue());
 104                 tpBuilder.addAugmentation(HwvtepPhysicalPortAugmentation.class, tpAugmentationBuilder.build());
 105                 if (oldPPRows.containsKey(pPortUpdate.getKey())) {
 106                     transaction.merge(LogicalDatastoreType.OPERATIONAL,
 107                             tpPath, tpBuilder.build());
 108                 } else {
 109                     transaction.put(LogicalDatastoreType.OPERATIONAL,
 110                             tpPath, tpBuilder.build());
 111                 }
 112             }
 113         }
 114     }
 115
 116     private void buildTerminationPoint(HwvtepPhysicalPortAugmentationBuilder tpAugmentationBuilder,
 117                     PhysicalPort portUpdate) {
 118         updatePhysicalPortId(portUpdate, tpAugmentationBuilder);
 119         updatePort(portUpdate, tpAugmentationBuilder);
 120     }
 121
 122     private void updatePort(PhysicalPort portUpdate,
 123                     HwvtepPhysicalPortAugmentationBuilder tpAugmentationBuilder) {
 124         updateVlanBindings(portUpdate, tpAugmentationBuilder);
 125     }
 126
 127     private void updatePhysicalPortId(PhysicalPort portUpdate,
 128                     HwvtepPhysicalPortAugmentationBuilder tpAugmentationBuilder) {
 129         PhysicalPortIdBuilder portIdBuilder = new PhysicalPortIdBuilder();
 130         portIdBuilder.setHwvtepNodeName(new HwvtepNodeName(portUpdate.getName()));
 131         if(portUpdate.getDescription() != null) {
 132             portIdBuilder.setHwvtepNodeDescription(portUpdate.getDescription());
 133         }
 134
 135         tpAugmentationBuilder.setPhysicalPortId(portIdBuilder.build());
 136     }
 137
 138     private void updateVlanBindings(PhysicalPort portUpdate,
 139                     HwvtepPhysicalPortAugmentationBuilder tpAugmentationBuilder) {
 140         Map<Long, UUID> vlanBindings = portUpdate.getVlanBindingsColumn().getData();
 141         if(vlanBindings != null && !vlanBindings.isEmpty()) {
 142             Set<Long> vlanBindingsKeys = vlanBindings.keySet();
 143             List<VlanBindings> vlanBindingsList = new ArrayList<>();
 144             UUID vlanBindingValue = null;
 145             for(Long vlanBindingKey: vlanBindingsKeys) {
 146                 vlanBindingValue = vlanBindings.get(vlanBindingKey);
 147                 if(vlanBindingValue != null && vlanBindingKey != null) {
 148                     vlanBindingsList.add(createVlanBinding(portUpdate, vlanBindingKey, vlanBindingValue));
 149                 }
 150             }
 151             tpAugmentationBuilder.setVlanBindings(vlanBindingsList);
 152         }
 153     }
 154
 155     private VlanBindings createVlanBinding(PhysicalPort portUpdate, Long key, UUID value) {
 156         VlanBindingsBuilder vbBuilder = new VlanBindingsBuilder();
 157         VlanBindingsKey vbKey = new VlanBindingsKey(new VlanId(key.intValue()));
 158         vbBuilder.setKey(vbKey);
 159         vbBuilder.setVlanIdKey(vbKey.getVlanIdKey());
 160         HwvtepLogicalSwitchRef lSwitchRef = this.getLogicalSwitchRef(value, portUpdate.getUuid());
 161         vbBuilder.setLogicalSwitch(lSwitchRef);
 162         return vbBuilder.build();
 163     }
 164
 165     private HwvtepLogicalSwitchRef getLogicalSwitchRef( UUID switchUUID, UUID portUUID) {
 166             if (lSwitchUpdatedRows.get(switchUUID) != null) {
 167                 Optional<InstanceIdentifier<Node>> optSwitchIid = Optional.of(HwvtepSouthboundMapper.createInstanceIdentifier(getOvsdbConnectionInstance(),
 168                         this.lSwitchUpdatedRows.get(switchUUID)));
 169                 if(optSwitchIid.isPresent()) {
 170                     return new HwvtepLogicalSwitchRef(optSwitchIid.get());
 171                 }
 172             }
 173         return null;
 174     }
 175
 176     private Optional<InstanceIdentifier<Node>> getTerminationPointSwitch( UUID portUUID) {
 177         for (UUID switchUUID : this.switchUpdatedRows.keySet()) {
 178             if (this.switchUpdatedRows.get(switchUUID).getPortsColumn().getData().contains(portUUID)) {
 179                 return Optional.of(HwvtepSouthboundMapper.createInstanceIdentifier(getOvsdbConnectionInstance(),
 180                         this.switchUpdatedRows.get(switchUUID)));
 181             }
 182         }
 183         return Optional.absent();
 184     }
 185
 186     private Optional<InstanceIdentifier<Node>> getTerminationPointSwitch(
 187                     final ReadWriteTransaction transaction, Node node, String tpName) {
 188                 HwvtepGlobalAugmentation hwvtepNode = node.getAugmentation(HwvtepGlobalAugmentation.class);
 189                 List<Switches> switchNodes = hwvtepNode.getSwitches();
 190                 for ( Switches managedNodeEntry : switchNodes ) {
 191                     @SuppressWarnings("unchecked")
 192                     Node switchNode = readNode(transaction,
 193                             (InstanceIdentifier<Node>)managedNodeEntry.getSwitchRef().getValue()).get();
 194                     TerminationPointBuilder tpBuilder = new TerminationPointBuilder();
 195                     TerminationPointKey tpKey = new TerminationPointKey(new TpId(tpName));
 196                     tpBuilder.setKey(tpKey);
 197                     if (switchNode.getTerminationPoint() != null
 198                             && switchNode.getTerminationPoint().contains(tpBuilder.build())) {
 199                         PhysicalSwitchAugmentation pSwitchAugment
 200                             = switchNode.getAugmentation(PhysicalSwitchAugmentation.class);
 201                         return Optional.of((InstanceIdentifier<Node>)managedNodeEntry.getSwitchRef().getValue());
 202                     }
 203                 }
 204                 return Optional.absent();
 205             }
 206
 207     private Optional<Node> readNode(final ReadWriteTransaction transaction, final InstanceIdentifier<Node> nodePath) {
 208         Optional<Node> node = Optional.absent();
 209         try {
 210             node = transaction.read(
 211                     LogicalDatastoreType.OPERATIONAL, nodePath)
 212                     .checkedGet();
 213         } catch (final ReadFailedException e) {
 214             LOG.warn("Read Operational/DS for Node fail! {}",
 215                     nodePath, e);
 216         }
 217         return node;
 218     }
 219
 220     private InstanceIdentifier<TerminationPoint> getInstanceIdentifier(InstanceIdentifier<Node> switchIid,
 221                     PhysicalPort pPort) {
 222         return switchIid.child(TerminationPoint.class, new TerminationPointKey(new TpId(pPort.getName())));
 223     }
 224
 225 }