coe/impl/src/main/java/org/opendaylight/netvirt/coe/utils/CoeUtils.java

   1 /*
   2  * Copyright (c) 2017 - 2018 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.netvirt.coe.utils;
  10
  11 import com.google.common.collect.ImmutableBiMap;
  12
  13 import java.nio.charset.StandardCharsets;
  14 import java.util.ArrayList;
  15 import java.util.Iterator;
  16 import java.util.List;
  17 import java.util.UUID;
  18 import org.apache.commons.lang3.tuple.Pair;
  19 import org.opendaylight.controller.md.sal.binding.api.ReadTransaction;
  20 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
  21 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  22 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  23 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  24
  25 import org.opendaylight.netvirt.neutronvpn.api.enums.IpVersionChoice;
  26 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInstances;
  27 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInterfaces;
  28 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.af.config.VpnTargets;
  29 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.af.config.VpnTargetsBuilder;
  30 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.af.config.vpntargets.VpnTarget;
  31 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.af.config.vpntargets.VpnTargetBuilder;
  32 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.af.config.vpntargets.VpnTargetKey;
  33 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstance;
  34 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstanceBuilder;
  35 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstanceKey;
  36 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.vpn.instance.Ipv4FamilyBuilder;
  37 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.vpn.instance.Ipv6FamilyBuilder;
  38 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterface;
  39 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterfaceBuilder;
  40 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterfaceKey;
  41 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.vpn._interface.VpnInstanceNames;
  42 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.vpn._interface.VpnInstanceNamesBuilder;
  43 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.vpn._interface.VpnInstanceNamesKey;
  44 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev140508.L2vlan;
  45 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
  46 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
  47 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
  48 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceBuilder;
  49 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
  50 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.PhysAddress;
  51 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.coe.northbound.pod.rev170611.NetworkAttributes;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.coe.northbound.pod.rev170611.coe.Pods;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfL2vlan;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfL2vlanBuilder;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.coe.meta.rev180118.PodidentifierInfo;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.coe.meta.rev180118.podidentifier.info.PodIdentifier;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.coe.meta.rev180118.podidentifier.info.PodIdentifierBuilder;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.coe.meta.rev180118.podidentifier.info.PodIdentifierKey;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanInstances;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanInterfaces;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.SegmentTypeBase;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.SegmentTypeFlat;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.SegmentTypeGre;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.SegmentTypeVlan;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.SegmentTypeVxlan;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstance;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstanceBuilder;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstanceKey;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.interfaces.ElanInterface;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.interfaces.ElanInterfaceBuilder;
  72 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.interfaces.ElanInterfaceKey;
  73 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.interfaces.elan._interface.StaticMacEntries;
  74 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.interfaces.elan._interface.StaticMacEntriesBuilder;
  75 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.interfaces.elan._interface.StaticMacEntriesKey;
  76 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.Adjacencies;
  77 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.AdjacenciesBuilder;
  78 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.adjacency.list.Adjacency;
  79 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.adjacency.list.AdjacencyBuilder;
  80 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.adjacency.list.AdjacencyKey;
  81 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
  82 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIds;
  83 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  84 import org.slf4j.Logger;
  85 import org.slf4j.LoggerFactory;
  86
  87 public final class CoeUtils {
  88     private static final Logger LOG = LoggerFactory.getLogger(CoeUtils.class);
  89
  90     private static final String SEPARATOR = ":";
  91     public static final ImmutableBiMap<NetworkAttributes.NetworkType, Class<? extends SegmentTypeBase>>
  92             NETWORK_MAP =
  93             new ImmutableBiMap.Builder<NetworkAttributes.NetworkType, Class<? extends SegmentTypeBase>>()
  94                     .put(NetworkAttributes.NetworkType.FLAT, SegmentTypeFlat.class)
  95                     .put(NetworkAttributes.NetworkType.GRE, SegmentTypeGre.class)
  96                     .put(NetworkAttributes.NetworkType.VLAN, SegmentTypeVlan.class)
  97                     .put(NetworkAttributes.NetworkType.VXLAN, SegmentTypeVxlan.class)
  98                     .build();
  99
 100     private CoeUtils() { }
 101
 102     public static InstanceIdentifier<Interface> buildVlanInterfaceIdentifier(String interfaceName) {
 103         InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508
 104                 .interfaces.Interface> id = InstanceIdentifier.builder(Interfaces.class).child(
 105                 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces
 106                         .Interface.class, new InterfaceKey(interfaceName)).build();
 107         return id;
 108     }
 109
 110     public static String buildInterfaceName(String networkNS, String podName) {
 111         return new StringBuilder().append(networkNS).append(SEPARATOR).append(podName).toString();
 112     }
 113
 114     static org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces
 115             .Interface buildInterface(String interfaceName) {
 116         IfL2vlan.L2vlanMode l2VlanMode = IfL2vlan.L2vlanMode.Trunk;
 117         InterfaceBuilder interfaceBuilder = new InterfaceBuilder();
 118         IfL2vlanBuilder ifL2vlanBuilder = new IfL2vlanBuilder();
 119         ifL2vlanBuilder.setL2vlanMode(l2VlanMode);
 120
 121         interfaceBuilder.setEnabled(true).setName(interfaceName).setType(L2vlan.class)
 122                 .addAugmentation(IfL2vlan.class, ifL2vlanBuilder.build());
 123
 124         return interfaceBuilder.build();
 125     }
 126
 127     static ElanInstance buildElanInstance(String elanInstanceName, Class<? extends SegmentTypeBase> segmentType,
 128                                            String segmentationId,
 129                                            Boolean isExternal) {
 130         ElanInstanceBuilder elanInstanceBuilder = new ElanInstanceBuilder().setElanInstanceName(elanInstanceName);
 131         if (segmentType != null) {
 132             elanInstanceBuilder.setSegmentType(segmentType);
 133             if (segmentationId != null) {
 134                 elanInstanceBuilder.setSegmentationId(Long.valueOf(segmentationId));
 135             }
 136         }
 137
 138         elanInstanceBuilder.setExternal(isExternal);
 139         elanInstanceBuilder.withKey(new ElanInstanceKey(elanInstanceName));
 140         return elanInstanceBuilder.build();
 141     }
 142
 143     public static void createElanInterface(String elanInterfaceName, String elanInstanceName,
 144                                            WriteTransaction wrtConfigTxn) {
 145         InstanceIdentifier<ElanInterface> id = InstanceIdentifier.builder(ElanInterfaces.class).child(ElanInterface
 146                 .class, new ElanInterfaceKey(elanInterfaceName)).build();
 147         ElanInterface elanInterface = new ElanInterfaceBuilder().setElanInstanceName(elanInstanceName)
 148                 .setName(elanInterfaceName).withKey(new ElanInterfaceKey(elanInterfaceName)).build();
 149         wrtConfigTxn.put(LogicalDatastoreType.CONFIGURATION, id, elanInterface);
 150         LOG.debug("Creating new ELAN Interface {}", elanInterface);
 151     }
 152
 153     public static void updateElanInterfaceWithStaticMac(String macAddress, IpAddress ipAddress,
 154                                            String elanInterfaceName,
 155                                            WriteTransaction wrtConfigTxn) {
 156         InstanceIdentifier<ElanInterface> id = InstanceIdentifier.builder(ElanInterfaces.class).child(ElanInterface
 157                 .class, new ElanInterfaceKey(elanInterfaceName)).build();
 158         PhysAddress physAddress = PhysAddress.getDefaultInstance(macAddress);
 159         List<StaticMacEntries> staticMacEntriesList = new ArrayList<>();
 160         StaticMacEntries staticMacEntries = new StaticMacEntriesBuilder().withKey(new StaticMacEntriesKey(
 161                 physAddress)).setMacAddress(physAddress).setIpPrefix(ipAddress).build();
 162         staticMacEntriesList.add(staticMacEntries);
 163         ElanInterface elanInterface = new ElanInterfaceBuilder().setName(elanInterfaceName)
 164                 .withKey(new ElanInterfaceKey(elanInterfaceName)).setStaticMacEntries(staticMacEntriesList).build();
 165         wrtConfigTxn.merge(LogicalDatastoreType.CONFIGURATION, id, elanInterface);
 166         LOG.debug("Updating ELAN Interface with static mac {}", elanInterface);
 167     }
 168
 169     public static void createPodNameToPodUuidMap(String podName, InstanceIdentifier<Pods> pod,
 170                                                  WriteTransaction writeTransaction) {
 171         InstanceIdentifier<PodIdentifier> id = InstanceIdentifier.builder(PodidentifierInfo.class)
 172                 .child(PodIdentifier.class, new PodIdentifierKey(podName)).build();
 173         PodIdentifier podIdentifier = new PodIdentifierBuilder().withKey(new PodIdentifierKey(podName))
 174                 .setPodName(podName).setPodUuid(pod).build();
 175         writeTransaction.put(LogicalDatastoreType.OPERATIONAL, id, podIdentifier);
 176         LOG.debug("Creating podnametouuid map {} to {}", podName, pod);
 177     }
 178
 179     public static void deletePodNameToPodUuidMap(String podName,
 180                                                  WriteTransaction writeTransaction) {
 181         InstanceIdentifier<PodIdentifier> id = InstanceIdentifier.builder(PodidentifierInfo.class)
 182                 .child(PodIdentifier.class, new PodIdentifierKey(podName)).build();
 183         writeTransaction.delete(LogicalDatastoreType.OPERATIONAL, id);
 184         LOG.debug("Deleting podnametouuid map for {}", podName);
 185     }
 186
 187     public static InstanceIdentifier<Pods> getPodUUIDforPodName(String podName,
 188                                             ReadTransaction readTransaction) throws ReadFailedException {
 189         InstanceIdentifier<PodIdentifier> id = InstanceIdentifier.builder(PodidentifierInfo.class)
 190                 .child(PodIdentifier.class, new PodIdentifierKey(podName)).build();
 191         InstanceIdentifier<?> instanceIdentifier = readTransaction.read(LogicalDatastoreType.OPERATIONAL, id)
 192                 .checkedGet().toJavaUtil().map(PodIdentifier::getPodUuid).orElse(null);
 193         if (instanceIdentifier != null) {
 194             return (InstanceIdentifier<Pods>) instanceIdentifier;
 195         }
 196         return null;
 197     }
 198
 199     public static void deleteElanInterface(String elanInterfaceName, WriteTransaction wrtConfigTxn) {
 200         InstanceIdentifier<ElanInterface> id = InstanceIdentifier.builder(ElanInterfaces.class).child(ElanInterface
 201                 .class, new ElanInterfaceKey(elanInterfaceName)).build();
 202         wrtConfigTxn.delete(LogicalDatastoreType.CONFIGURATION, id);
 203         LOG.debug("Deleting ELAN Interface {}", elanInterfaceName);
 204     }
 205
 206     public static String createOfPortInterface(String interfaceName,
 207                                                WriteTransaction wrtConfigTxn) {
 208         org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface inf =
 209                 buildInterface(interfaceName);
 210         String infName = inf.getName();
 211         LOG.info("Creating OFPort Interface {}", infName);
 212         InstanceIdentifier interfaceIdentifier = CoeUtils.buildVlanInterfaceIdentifier(infName);
 213         wrtConfigTxn.put(LogicalDatastoreType.CONFIGURATION, interfaceIdentifier, inf);
 214         return infName;
 215     }
 216
 217     public static void deleteOfPortInterface(String infName, WriteTransaction wrtConfigTxn) {
 218         LOG.debug("Deleting OFPort Interface {}", infName);
 219         InstanceIdentifier interfaceIdentifier = CoeUtils.buildVlanInterfaceIdentifier(infName);
 220         wrtConfigTxn.delete(LogicalDatastoreType.CONFIGURATION, interfaceIdentifier);
 221     }
 222
 223     static InstanceIdentifier<ElanInstance> createElanInstanceIdentifier(String elanInstanceName) {
 224         InstanceIdentifier<ElanInstance> id = InstanceIdentifier.builder(ElanInstances.class).child(ElanInstance.class,
 225                 new ElanInstanceKey(elanInstanceName)).build();
 226         return id;
 227     }
 228
 229     public static Class<? extends SegmentTypeBase> getSegmentTypeFromNetwork(
 230             org.opendaylight.yang.gen.v1.urn.opendaylight.coe.northbound.pod.rev170611.pod_attributes.Interface
 231                     elanInterface) {
 232         return CoeUtils.NETWORK_MAP.get(elanInterface.getNetworkType());
 233     }
 234
 235     public static String buildElanInstanceName(String nodeIp, String networkNS) {
 236         return new StringBuilder().append(nodeIp).append(SEPARATOR).append(networkNS).toString();
 237     }
 238
 239     public static ElanInstance createElanInstanceForTheFirstPodInTheNetwork(String networkNS, String nodeIp,
 240                                                  org.opendaylight.yang.gen.v1.urn.opendaylight.coe.northbound.pod
 241                                                          .rev170611.pod_attributes.Interface podInterface,
 242                                                  ReadWriteTransaction wrtConfigTxn) throws ReadFailedException {
 243         String elanInstanceName = buildElanInstanceName(nodeIp, networkNS);
 244         InstanceIdentifier<ElanInstance> id = createElanInstanceIdentifier(elanInstanceName);
 245         ElanInstance existingElanInstance = wrtConfigTxn.read(LogicalDatastoreType.CONFIGURATION, id)
 246                 .checkedGet().orNull();
 247         if (existingElanInstance != null) {
 248             return existingElanInstance;
 249         }
 250         Class<? extends SegmentTypeBase> segmentType = getSegmentTypeFromNetwork(podInterface);
 251         String segmentationId = String.valueOf(podInterface.getSegmentationId());
 252         //FIXME String physicalNetworkName = ??
 253         // TODO external network support not added currently
 254         Boolean isExternal = false;
 255         ElanInstance elanInstance = CoeUtils.buildElanInstance(elanInstanceName, segmentType,
 256                 segmentationId, isExternal);
 257         wrtConfigTxn.put(LogicalDatastoreType.CONFIGURATION, id, elanInstance);
 258         LOG.info("ELAN instance created for the first pod in the network {}", podInterface.getUid());
 259         return elanInstance;
 260     }
 261
 262     public static Pair<String, String> getAttachedInterfaceAndMac(OvsdbTerminationPointAugmentation ovsdbTp) {
 263         String interfaceName = null;
 264         String macAddress = null;
 265         if (ovsdbTp != null) {
 266             List<InterfaceExternalIds> ifaceExtIds = ovsdbTp.getInterfaceExternalIds();
 267             if (ifaceExtIds != null) {
 268                 Iterator var2 = ifaceExtIds.iterator();
 269                 while (var2.hasNext()) {
 270                     if (interfaceName != null && macAddress != null) {
 271                         break;
 272                     }
 273                     InterfaceExternalIds entry = (InterfaceExternalIds)var2.next();
 274                     if (entry.getExternalIdKey().equals("iface-id")) {
 275                         interfaceName = entry.getExternalIdValue();
 276                         continue;
 277                     }
 278                     if (entry.getExternalIdKey().equals("attached-mac")) {
 279                         macAddress = entry.getExternalIdValue();
 280                         continue;
 281                     }
 282                 }
 283             }
 284         }
 285
 286         return Pair.of(interfaceName, macAddress);
 287     }
 288
 289     public static InstanceIdentifier<PodIdentifier> getPodMetaInstanceId(String externalInterfaceId) {
 290         return InstanceIdentifier.builder(PodidentifierInfo.class)
 291                 .child(PodIdentifier.class, new PodIdentifierKey(externalInterfaceId)).build();
 292     }
 293
 294     public static void createVpnInstance(String vpnName, List<String> rd, List<String> irt, List<String> ert,
 295                                    VpnInstance.Type type, long l3vni, IpVersionChoice ipVersion,
 296                                    ReadWriteTransaction tx) throws ReadFailedException {
 297         List<VpnTarget> vpnTargetList = new ArrayList<>();
 298         LOG.debug("Creating/Updating a new vpn-instance node: {} ", vpnName);
 299
 300         VpnInstanceBuilder builder = new VpnInstanceBuilder().withKey(new VpnInstanceKey(vpnName))
 301                 .setVpnInstanceName(vpnName)
 302                 .setType(type).setL3vni(l3vni);
 303         if (irt != null && !irt.isEmpty()) {
 304             if (ert != null && !ert.isEmpty()) {
 305                 List<String> commonRT = new ArrayList<>(irt);
 306                 commonRT.retainAll(ert);
 307
 308                 for (String common : commonRT) {
 309                     irt.remove(common);
 310                     ert.remove(common);
 311                     VpnTarget vpnTarget =
 312                             new VpnTargetBuilder().withKey(new VpnTargetKey(common)).setVrfRTValue(common)
 313                                     .setVrfRTType(VpnTarget.VrfRTType.Both).build();
 314                     vpnTargetList.add(vpnTarget);
 315                 }
 316             }
 317             for (String importRT : irt) {
 318                 VpnTarget vpnTarget =
 319                         new VpnTargetBuilder().withKey(new VpnTargetKey(importRT)).setVrfRTValue(importRT)
 320                                 .setVrfRTType(VpnTarget.VrfRTType.ImportExtcommunity).build();
 321                 vpnTargetList.add(vpnTarget);
 322             }
 323         }
 324
 325         if (ert != null && !ert.isEmpty()) {
 326             for (String exportRT : ert) {
 327                 VpnTarget vpnTarget =
 328                         new VpnTargetBuilder().withKey(new VpnTargetKey(exportRT)).setVrfRTValue(exportRT)
 329                                 .setVrfRTType(VpnTarget.VrfRTType.ExportExtcommunity).build();
 330                 vpnTargetList.add(vpnTarget);
 331             }
 332         }
 333
 334         VpnTargets vpnTargets = new VpnTargetsBuilder().setVpnTarget(vpnTargetList).build();
 335
 336         Ipv4FamilyBuilder ipv4vpnBuilder = new Ipv4FamilyBuilder().setVpnTargets(vpnTargets);
 337         Ipv6FamilyBuilder ipv6vpnBuilder = new Ipv6FamilyBuilder().setVpnTargets(vpnTargets);
 338
 339         if (rd != null && !rd.isEmpty()) {
 340             ipv4vpnBuilder.setRouteDistinguisher(rd);
 341             ipv6vpnBuilder.setRouteDistinguisher(rd);
 342         }
 343
 344         if (ipVersion != null && ipVersion.isIpVersionChosen(IpVersionChoice.IPV4)) {
 345             builder.setIpv4Family(ipv4vpnBuilder.build());
 346         }
 347         if (ipVersion != null && ipVersion.isIpVersionChosen(IpVersionChoice.IPV6)) {
 348             builder.setIpv6Family(ipv6vpnBuilder.build());
 349         }
 350         if (ipVersion != null && ipVersion.isIpVersionChosen(IpVersionChoice.UNDEFINED)) {
 351             builder.setIpv4Family(ipv4vpnBuilder.build());
 352         }
 353         VpnInstance newVpn = builder.build();
 354         LOG.debug("Creating/Updating vpn-instance for {} ", vpnName);
 355         InstanceIdentifier<VpnInstance> vpnIdentifier = InstanceIdentifier.builder(VpnInstances.class)
 356                 .child(VpnInstance.class, new VpnInstanceKey(vpnName)).build();
 357         tx.put(LogicalDatastoreType.CONFIGURATION, vpnIdentifier, newVpn);
 358     }
 359
 360     static void deleteVpnInstance(String vpnName, WriteTransaction wrtConfigTxn) {
 361         LOG.debug("Deleting vpn-instance for {} ", vpnName);
 362         InstanceIdentifier<VpnInstance> vpnIdentifier = InstanceIdentifier.builder(VpnInstances.class)
 363                 .child(VpnInstance.class, new VpnInstanceKey(vpnName)).build();
 364         wrtConfigTxn.delete(LogicalDatastoreType.CONFIGURATION, vpnIdentifier);
 365     }
 366
 367     static InstanceIdentifier<VpnInterface> buildVpnInterfaceIdentifier(String ifName) {
 368         InstanceIdentifier<VpnInterface> id = InstanceIdentifier.builder(VpnInterfaces.class).child(VpnInterface
 369                 .class, new VpnInterfaceKey(ifName)).build();
 370         return id;
 371     }
 372
 373     public static void createVpnInterface(String vpnName, Pods pod, String interfaceName, String macAddress,
 374                                           boolean isRouterInterface, WriteTransaction wrtConfigTxn) {
 375         LOG.trace("createVpnInterface for Port: {}, isRouterInterface: {}", interfaceName, isRouterInterface);
 376         List<VpnInstanceNames> listVpn = new ArrayList<>();
 377         listVpn.add(new VpnInstanceNamesBuilder().withKey(new VpnInstanceNamesKey(vpnName))
 378                 .setVpnName(vpnName).setAssociatedSubnetType(VpnInstanceNames.AssociatedSubnetType
 379                         .V4Subnet).build());
 380         VpnInterfaceBuilder vpnb = new VpnInterfaceBuilder().withKey(new VpnInterfaceKey(interfaceName))
 381                 .setName(interfaceName)
 382                 .setVpnInstanceNames(listVpn)
 383                 .setRouterInterface(isRouterInterface);
 384         Adjacencies adjs = createPortIpAdjacencies(pod, interfaceName, macAddress, isRouterInterface);
 385         if (adjs != null) {
 386             vpnb.addAugmentation(Adjacencies.class, adjs);
 387         }
 388         VpnInterface vpnIf = vpnb.build();
 389         LOG.info("Creating vpn interface {}", vpnIf);
 390         InstanceIdentifier<VpnInterface> vpnIfIdentifier = buildVpnInterfaceIdentifier(interfaceName);
 391         wrtConfigTxn.put(LogicalDatastoreType.CONFIGURATION, vpnIfIdentifier, vpnIf);
 392
 393     }
 394
 395     public static void deleteVpnInterface(String interfaceName, WriteTransaction wrtConfigTxn) {
 396         LOG.trace("deleteVpnInterface for Pod {}", interfaceName);
 397         InstanceIdentifier<VpnInterface> vpnIfIdentifier = buildVpnInterfaceIdentifier(interfaceName);
 398         wrtConfigTxn.delete(LogicalDatastoreType.CONFIGURATION, vpnIfIdentifier);
 399     }
 400
 401     static Adjacencies createPortIpAdjacencies(Pods pod, String interfaceName, String macAddress,
 402                                                   Boolean isRouterInterface) {
 403         List<Adjacency> adjList = new ArrayList<>();
 404         LOG.trace("create config adjacencies for Port: {}", interfaceName);
 405         IpAddress ip = pod.getInterface().get(0).getIpAddress();
 406         String ipValue = ip.getIpv4Address() != null ? ip.getIpv4Address().getValue() : ip.getIpv6Address().getValue();
 407         String ipPrefix = ip.getIpv4Address() != null ? ipValue + "/32" : ipValue + "/128";
 408         String hostIp = new String(pod.getHostIpAddress().getValue());
 409         UUID subnetId = UUID.nameUUIDFromBytes(hostIp.getBytes(StandardCharsets.UTF_8));
 410         String gatewayIP = ipValue.replaceFirst("\\d+$", "1");
 411         Adjacency vmAdj = new AdjacencyBuilder().withKey(new AdjacencyKey(ipPrefix)).setIpAddress(ipPrefix)
 412                 .setMacAddress(macAddress).setAdjacencyType(Adjacency.AdjacencyType.PrimaryAdjacency)
 413                 .setSubnetId(new Uuid(subnetId.toString())).setSubnetGatewayIp(gatewayIP).build();
 414         if (!adjList.contains(vmAdj)) {
 415             adjList.add(vmAdj);
 416         }
 417
 418         //if (isRouterInterface) {
 419             // TODO
 420             // create extraroute Adjacence for each ipValue,
 421             // because router can have IPv4 and IPv6 subnet ports, or can have
 422             // more that one IPv4 subnet port or more than one IPv6 subnet port
 423             //List<Adjacency> erAdjList = getAdjacencyforExtraRoute(vpnId, routeList, ipValue);
 424             //if (!erAdjList.isEmpty()) {
 425             //    adjList.addAll(erAdjList);
 426             //}
 427         //}
 428         return new AdjacenciesBuilder().setAdjacency(adjList).build();
 429     }
 430
 431 }