elanmanager/impl/src/main/java/org/opendaylight/netvirt/elan/l2gw/ha/commands/TerminationPointCmd.java

   1 /*
   2  * Copyright (c) 2016, 2017 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 package org.opendaylight.netvirt.elan.l2gw.ha.commands;
   9
  10 import java.io.Serializable;
  11 import java.util.ArrayList;
  12 import java.util.Comparator;
  13 import java.util.List;
  14 import java.util.stream.Collectors;
  15 import org.eclipse.jdt.annotation.Nullable;
  16 import org.opendaylight.netvirt.elan.l2gw.ha.HwvtepHAUtil;
  17 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepPhysicalPortAugmentation;
  18 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepPhysicalPortAugmentationBuilder;
  19 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical.port.attributes.VlanBindings;
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical.port.attributes.VlanBindingsBuilder;
  21 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  22 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
  23 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
  24 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointBuilder;
  25 import org.opendaylight.yangtools.yang.binding.Identifier;
  26 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  27 import org.slf4j.Logger;
  28 import org.slf4j.LoggerFactory;
  29
  30 public class TerminationPointCmd extends MergeCommand<TerminationPoint, NodeBuilder, Node> {
  31
  32     private static final Logger LOG = LoggerFactory.getLogger(TerminationPointCmd.class);
  33
  34     public TerminationPointCmd() {
  35     }
  36
  37     @Override
  38     @Nullable
  39     public List<TerminationPoint> getData(Node node) {
  40         if (node != null && node.nonnullTerminationPoint() != null) {
  41             return new ArrayList<TerminationPoint>(node.nonnullTerminationPoint().values());
  42         }
  43         return null;
  44     }
  45
  46     @Override
  47     public void setData(NodeBuilder builder, List<TerminationPoint> data) {
  48         builder.setTerminationPoint(data);
  49     }
  50
  51     @Override
  52     public InstanceIdentifier<TerminationPoint> generateId(InstanceIdentifier<Node> id, TerminationPoint node) {
  53         return id.child(TerminationPoint.class, node.key());
  54     }
  55
  56     @Override
  57     public TerminationPoint transform(InstanceIdentifier<Node> nodePath, TerminationPoint src) {
  58         HwvtepPhysicalPortAugmentation augmentation = src.augmentation(HwvtepPhysicalPortAugmentation.class);
  59         if (augmentation == null) {
  60             return new TerminationPointBuilder(src).build();
  61         }
  62         String nodeIdVal = nodePath.firstKeyOf(Node.class).getNodeId().getValue();
  63         int idx = nodeIdVal.indexOf("/physicalswitch");
  64         if (idx > 0) {
  65             nodeIdVal = nodeIdVal.substring(0, idx);
  66             nodePath = HwvtepHAUtil.convertToInstanceIdentifier(nodeIdVal);
  67         }
  68         final InstanceIdentifier<Node> path = nodePath;
  69         TerminationPointBuilder tpBuilder = new TerminationPointBuilder(src);
  70         tpBuilder.removeAugmentation(HwvtepPhysicalPortAugmentation.class);
  71         HwvtepPhysicalPortAugmentationBuilder tpAugmentationBuilder =
  72                 new HwvtepPhysicalPortAugmentationBuilder();
  73         tpAugmentationBuilder.setAclBindings(augmentation.getAclBindings());
  74         tpAugmentationBuilder.setHwvtepNodeDescription(augmentation.getHwvtepNodeDescription());
  75         tpAugmentationBuilder.setHwvtepNodeName(augmentation.getHwvtepNodeName());
  76         tpAugmentationBuilder.setPhysicalPortUuid(augmentation.getPhysicalPortUuid());
  77         tpAugmentationBuilder.setVlanStats(augmentation.getVlanStats());
  78         if (augmentation.getVlanBindings() != null && augmentation.getVlanBindings().size() > 0) {
  79             tpAugmentationBuilder.setVlanBindings(augmentation.nonnullVlanBindings().values().stream().map(
  80                 vlanBindings -> {
  81                     if (vlanBindings.getLogicalSwitchRef() == null) {
  82                         LOG.error("Failed to get logical switch ref for vlan binding {} {} ", path, src);
  83                     }
  84                     VlanBindingsBuilder vlanBindingsBuilder = new VlanBindingsBuilder(vlanBindings);
  85                     vlanBindingsBuilder.setLogicalSwitchRef(
  86                             HwvtepHAUtil.convertLogicalSwitchRef(vlanBindings.getLogicalSwitchRef(), path));
  87                     return vlanBindingsBuilder.build();
  88                 }).collect(Collectors.toList()));
  89         }
  90
  91         tpBuilder.addAugmentation(tpAugmentationBuilder.build());
  92         return tpBuilder.build();
  93     }
  94
  95     @Override
  96     public Identifier getKey(TerminationPoint data) {
  97         return data.key();
  98     }
  99
 100     @Override
 101     public String getDescription() {
 102         return "vlanbindings";
 103     }
 104
 105     @Override
 106     public TerminationPoint withoutUuid(TerminationPoint data) {
 107         return data;
 108     }
 109
 110     @Override
 111     public boolean areEqual(TerminationPoint updated, TerminationPoint orig) {
 112         if (!updated.key().equals(orig.key())) {
 113             return false;
 114         }
 115         HwvtepPhysicalPortAugmentation updatedAugmentation = updated
 116                 .augmentation(HwvtepPhysicalPortAugmentation.class);
 117         HwvtepPhysicalPortAugmentation origAugmentation = orig.augmentation(HwvtepPhysicalPortAugmentation.class);
 118
 119         List<VlanBindings> up = updatedAugmentation != null
 120             ? new ArrayList<>(updatedAugmentation.nonnullVlanBindings().values()) : null;
 121         List<VlanBindings> or = origAugmentation != null
 122             ? new ArrayList<>(origAugmentation.nonnullVlanBindings().values()) : null;
 123         if (!areSameSize(up, or)) {
 124             return false;
 125         }
 126         List<VlanBindings> added = diffOf(up, or, bindingsComparator);
 127         if (added.size() != 0) {
 128             return false;
 129         }
 130         List<VlanBindings> removed = diffOf(or, up, bindingsComparator);
 131         if (removed.size() != 0) {
 132             return false;
 133         }
 134         return true;
 135     }
 136
 137     static BindingsComparator bindingsComparator = new BindingsComparator();
 138
 139     static class BindingsComparator implements Comparator<VlanBindings>, Serializable {
 140         private static final long serialVersionUID = 1L;
 141
 142         @Override
 143         public int compare(VlanBindings updated, VlanBindings orig) {
 144             if (updated == null && orig == null) {
 145                 return 0;
 146             }
 147             if (updated == null) {
 148                 return 1;
 149             }
 150             if (orig == null) {
 151                 return 1;
 152             }
 153             if (updated.key().equals(orig.key())) {
 154                 return 0;
 155             }
 156             updated.key();
 157             return 1;
 158         }
 159     }
 160 /*
 161     @Override
 162     public void transformUpdate(List<TerminationPoint> existing,
 163                                 List<TerminationPoint> updated,
 164                                 List<TerminationPoint> orig,
 165                                 InstanceIdentifier<Node> nodePath,
 166                                 LogicalDatastoreType datastoreType,
 167                                 ReadWriteTransaction tx) {
 168
 169         if (updated == null) {
 170             updated = new ArrayList<>();
 171         }
 172         if (orig == null) {
 173             orig = new ArrayList<>();
 174         }
 175         List<TerminationPoint> added   = new ArrayList<>(updated);
 176
 177         added = diffOf(added, orig);
 178         added = diffOf(added, existing);//do not add the existing data again
 179         if (added != null && added.size() > 0) {
 180             for (TerminationPoint addedItem : added) {
 181                 InstanceIdentifier<TerminationPoint> transformedId = generateId(nodePath, addedItem);
 182                 TerminationPoint transformedItem = transform(nodePath, addedItem);
 183                 LOG.trace("adding vlanbindings id {} ", transformedId
 184                                     .firstKeyOf(TerminationPoint.class).getTpId().getValue());
 185                 tx.put(datastoreType, transformedId, transformedItem, true);
 186             }
 187         }
 188         for (TerminationPoint origItem : orig) {
 189             boolean found = false;
 190             for (TerminationPoint newItem : updated) {
 191                 if (newItem.key().equals(origItem.key())) {
 192                     found = true;
 193                 }
 194             }
 195             if (!found) {
 196                 boolean existsInConfig = false;
 197                 for (TerminationPoint existingItem : existing) {
 198                     if (existingItem.key().equals(origItem.key())) {
 199                         existsInConfig = true;
 200                     }
 201                 }
 202                 if (existsInConfig) {
 203                     InstanceIdentifier<TerminationPoint> transformedId = generateId(nodePath, origItem);
 204                     LOG.trace("deleting vlanbindings id {} ", transformedId.firstKeyOf(TerminationPoint.class)
 205                                                                                 .getTpId().getValue());
 206                     tx.delete(datastoreType, transformedId);
 207                 }
 208             }
 209         }
 210     }
 211 */
 212
 213 }