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(augmentation);
  73
  74         if (augmentation.getVlanBindings() != null && augmentation.getVlanBindings().size() > 0) {
  75             tpAugmentationBuilder.setVlanBindings(augmentation.nonnullVlanBindings().values().stream().map(
  76                 vlanBindings -> {
  77                     VlanBindingsBuilder vlanBindingsBuilder = new VlanBindingsBuilder(vlanBindings);
  78                     vlanBindingsBuilder.setLogicalSwitchRef(
  79                             HwvtepHAUtil.convertLogicalSwitchRef(vlanBindings.getLogicalSwitchRef(), path));
  80                     return vlanBindingsBuilder.build();
  81                 }).collect(Collectors.toList()));
  82         }
  83
  84         tpBuilder.addAugmentation(HwvtepPhysicalPortAugmentation.class, tpAugmentationBuilder.build());
  85         return tpBuilder.build();
  86     }
  87
  88     @Override
  89     public Identifier getKey(TerminationPoint data) {
  90         return data.key();
  91     }
  92
  93     @Override
  94     public String getDescription() {
  95         return "vlanbindings";
  96     }
  97
  98     @Override
  99     public TerminationPoint withoutUuid(TerminationPoint data) {
 100         return data;
 101     }
 102
 103     @Override
 104     public boolean areEqual(TerminationPoint updated, TerminationPoint orig) {
 105         if (!updated.key().equals(orig.key())) {
 106             return false;
 107         }
 108         HwvtepPhysicalPortAugmentation updatedAugmentation = updated
 109                 .augmentation(HwvtepPhysicalPortAugmentation.class);
 110         HwvtepPhysicalPortAugmentation origAugmentation = orig.augmentation(HwvtepPhysicalPortAugmentation.class);
 111
 112         List<VlanBindings> up = updatedAugmentation != null
 113             ? new ArrayList<>(updatedAugmentation.nonnullVlanBindings().values()) : null;
 114         List<VlanBindings> or = origAugmentation != null
 115             ? new ArrayList<>(origAugmentation.nonnullVlanBindings().values()) : null;
 116         if (!areSameSize(up, or)) {
 117             return false;
 118         }
 119         List<VlanBindings> added = diffOf(up, or, bindingsComparator);
 120         if (added.size() != 0) {
 121             return false;
 122         }
 123         List<VlanBindings> removed = diffOf(or, up, bindingsComparator);
 124         if (removed.size() != 0) {
 125             return false;
 126         }
 127         return true;
 128     }
 129
 130     static BindingsComparator bindingsComparator = new BindingsComparator();
 131
 132     static class BindingsComparator implements Comparator<VlanBindings>, Serializable {
 133         private static final long serialVersionUID = 1L;
 134
 135         @Override
 136         public int compare(VlanBindings updated, VlanBindings orig) {
 137             if (updated == null && orig == null) {
 138                 return 0;
 139             }
 140             if (updated == null) {
 141                 return 1;
 142             }
 143             if (orig == null) {
 144                 return 1;
 145             }
 146             if (updated.key().equals(orig.key())) {
 147                 return 0;
 148             }
 149             updated.key();
 150             return 1;
 151         }
 152     }
 153 /*
 154     @Override
 155     public void transformUpdate(List<TerminationPoint> existing,
 156                                 List<TerminationPoint> updated,
 157                                 List<TerminationPoint> orig,
 158                                 InstanceIdentifier<Node> nodePath,
 159                                 LogicalDatastoreType datastoreType,
 160                                 ReadWriteTransaction tx) {
 161
 162         if (updated == null) {
 163             updated = new ArrayList<>();
 164         }
 165         if (orig == null) {
 166             orig = new ArrayList<>();
 167         }
 168         List<TerminationPoint> added   = new ArrayList<>(updated);
 169
 170         added = diffOf(added, orig);
 171         added = diffOf(added, existing);//do not add the existing data again
 172         if (added != null && added.size() > 0) {
 173             for (TerminationPoint addedItem : added) {
 174                 InstanceIdentifier<TerminationPoint> transformedId = generateId(nodePath, addedItem);
 175                 TerminationPoint transformedItem = transform(nodePath, addedItem);
 176                 LOG.trace("adding vlanbindings id {} ", transformedId
 177                                     .firstKeyOf(TerminationPoint.class).getTpId().getValue());
 178                 tx.put(datastoreType, transformedId, transformedItem, true);
 179             }
 180         }
 181         for (TerminationPoint origItem : orig) {
 182             boolean found = false;
 183             for (TerminationPoint newItem : updated) {
 184                 if (newItem.key().equals(origItem.key())) {
 185                     found = true;
 186                 }
 187             }
 188             if (!found) {
 189                 boolean existsInConfig = false;
 190                 for (TerminationPoint existingItem : existing) {
 191                     if (existingItem.key().equals(origItem.key())) {
 192                         existsInConfig = true;
 193                     }
 194                 }
 195                 if (existsInConfig) {
 196                     InstanceIdentifier<TerminationPoint> transformedId = generateId(nodePath, origItem);
 197                     LOG.trace("deleting vlanbindings id {} ", transformedId.firstKeyOf(TerminationPoint.class)
 198                                                                                 .getTpId().getValue());
 199                     tx.delete(datastoreType, transformedId);
 200                 }
 201             }
 202         }
 203     }
 204 */
 205
 206 }