renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/LispStateManager.java

   1 /*
   2  * Copyright (c) 2017 Cisco Systems. 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.groupbasedpolicy.renderer.vpp.lisp;
  10
  11 import com.google.common.base.Optional;
  12 import com.google.common.base.Preconditions;
  13 import com.google.common.collect.Lists;
  14
  15 import java.util.HashMap;
  16 import java.util.List;
  17 import java.util.Map;
  18 import java.util.concurrent.ExecutionException;
  19
  20 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  21 import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.lisp.AbstractLispCommand;
  22 import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.lisp.LispCommandWrapper;
  23 import org.opendaylight.groupbasedpolicy.renderer.vpp.config.ConfigUtil;
  24 import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.exception.LispConfigCommandFailedException;
  25 import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.exception.LispNotFoundException;
  26 import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.flat.overlay.FlatOverlayManager;
  27 import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.HostRelatedInfoContainer;
  28 import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.states.PhysicalInterfaces;
  29 import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.mappers.NeutronTenantToVniMapper;
  30 import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.util.ConfigManagerHelper;
  31 import org.opendaylight.groupbasedpolicy.renderer.vpp.util.GbpNetconfTransaction;
  32 import org.opendaylight.groupbasedpolicy.renderer.vpp.util.LispUtil;
  33 import org.opendaylight.groupbasedpolicy.renderer.vpp.util.VppIidFactory;
  34 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev170511.IpPrefixType;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.endpoints.AddressEndpointWithLocation;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.gpe.rev170801.NativeForwardPathsTables;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.gpe.rev170801._native.forward.paths.tables._native.forward.paths.table.NativeForwardPath;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.gpe.rev170801.gpe.feature.data.grouping.GpeFeatureData;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev171013.Lisp;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev171013.dp.subtable.grouping.LocalMappings;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev171013.dp.subtable.grouping.local.mappings.LocalMapping;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev171013.dp.subtable.grouping.local.mappings.local.mapping.Eid;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev171013.eid.table.grouping.EidTable;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev171013.eid.table.grouping.eid.table.VniTable;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev171013.eid.table.grouping.eid.table.VniTableKey;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev171013.eid.table.grouping.eid.table.vni.table.VrfSubtable;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev171013.itr.remote.locator.sets.grouping.ItrRemoteLocatorSet;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev171013.lisp.feature.data.grouping.LispFeatureData;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev171013.locator.sets.grouping.LocatorSets;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev171013.locator.sets.grouping.locator.sets.LocatorSet;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev171013.map.register.grouping.MapRegister;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev171013.map.resolvers.grouping.MapResolvers;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev171013.map.resolvers.grouping.map.resolvers.MapResolver;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev171013.map.servers.grouping.MapServers;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev171013.map.servers.grouping.map.servers.MapServer;
  57 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
  58 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  59 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  60 import org.slf4j.Logger;
  61 import org.slf4j.LoggerFactory;
  62
  63 public class LispStateManager {
  64     private static final Logger LOG = LoggerFactory.getLogger(LispStateManager.class);
  65
  66     private HostRelatedInfoContainer hostRelatedInfoContainer;
  67     private ConfigManagerHelper lispStateHelper;
  68
  69     private NeutronTenantToVniMapper neutronTenantToVniMapper;
  70
  71     private static final short DEFAULT_PRIORITY = 1;
  72     private static final short DEFAULT_WEIGHT = 1;
  73     public static final String DEFAULT_XTR_KEY = "admin";
  74     public static final String DEFAULT_LOCATOR_SET_NAME_PREFIX = "LS";
  75     public static final String DEFAULT_MAPPING_RECORD_NAME_PREFIX = "MR_";
  76
  77     // Node ID, VRF ID, route count
  78     private Map<String, List<Long>> vnisByHostname = new HashMap<>();
  79
  80     public LispStateManager() {
  81         hostRelatedInfoContainer = HostRelatedInfoContainer.getInstance();
  82         this.lispStateHelper = new ConfigManagerHelper();
  83         neutronTenantToVniMapper = NeutronTenantToVniMapper.getInstance();
  84     }
  85
  86     public synchronized void processCreateEndPoint(AddressEndpointWithLocation addressEp) {
  87         if (!addressEp.getAddressType().equals(IpPrefixType.class)) {
  88             return;
  89         }
  90         Map<String, String> intfcsByHostname = FlatOverlayManager.resolveIntfcsByHosts(addressEp);
  91
  92         intfcsByHostname.forEach((hostname, interfaceName) -> {
  93             try {
  94                 configureHostIfNeeded(hostname);
  95
  96                 long vni = getVni(addressEp.getTenant().getValue());
  97                 long vrf = vni;
  98
  99                 Eid eid = lispStateHelper.getEid(addressEp, vni);
 100                 String eidMappingName = lispStateHelper.constructEidMappingName(addressEp, interfaceName);
 101
 102                 addVniSpecificConfigurationsIfNeeded(hostname, vni, vrf);
 103                 if (!ConfigManagerHelper.isMetadataPort(addressEp)) {
 104                     if (!addEidInEidTable(hostname, eid, eidMappingName)) {
 105                         LOG.warn("Failed to add Eid: {}, eidMappingName: {} to table on host: {}", eid, eidMappingName,
 106                             hostname);
 107                     }
 108                 }
 109             } catch (LispConfigCommandFailedException e) {
 110                 LOG.warn("Lisp endpoint configuration failed for address endpoint: {}", addressEp);
 111             }
 112         });
 113
 114
 115     }
 116
 117     private synchronized void configureHostIfNeeded(String hostName)
 118             throws LispConfigCommandFailedException {
 119
 120         if ((vnisByHostname.get(hostName) == null)) {
 121
 122             LOG.debug("Configuring host {} for LISP", hostName);
 123
 124             try {
 125                 boolean lispEnabled = enableLispOnHost(hostName);
 126                 Optional<GpeFeatureData> gpeFeatureDataOptional =
 127                     GbpNetconfTransaction.read(VppIidFactory.getNetconfNodeIid(new NodeId(hostName)),
 128                         LogicalDatastoreType.CONFIGURATION, VppIidFactory.getGpeFeatureDataIid(),
 129                         GbpNetconfTransaction.RETRY_COUNT);
 130
 131                 LOG.trace("configureHostIfNeeded -> GpeOnHostFeatureData: {}", gpeFeatureDataOptional);
 132
 133                 if (!gpeFeatureDataOptional.isPresent() || !gpeFeatureDataOptional.get().isEnable()) {
 134                     if (!enableGpeOnHostIfNeeded(hostName)) {
 135                         LOG.trace("configureHostIfNeeded -> Gpe on host: {} cannot be enabled.", hostName);
 136                     }
 137                     LOG.trace("configureHostIfNeeded -> GpeOnHostFeatureData were cleared");
 138                 }
 139
 140                 if (lispEnabled) {
 141                     addLocatorSetOnHost(hostName);
 142                     if (!addMapResolverOnHost(hostName)) {
 143                         LOG.warn("Failed to add MAP resolver for host: {}", hostName);
 144                     }
 145                     enableMapRegistrationOnHostIfNeeded(hostName);
 146                     vnisByHostname.computeIfAbsent(hostName, k -> Lists.newArrayList());
 147                 } else {
 148                     LOG.warn("Failed to enable LISP or GPE on host: {}", hostName);
 149                 }
 150
 151             } catch (LispNotFoundException e) {
 152                 LOG.warn("Lisp host configuration failed: ", e.getMessage());
 153                 throw new LispConfigCommandFailedException("Failed LISP configuration!");
 154             }
 155         }
 156     }
 157
 158     private boolean enableGpeOnHostIfNeeded(String hostName) {
 159         return enableGpeForHost(hostName);
 160     }
 161
 162     private void enableMapRegistrationOnHostIfNeeded(String hostName)
 163             throws LispConfigCommandFailedException {
 164         if (ConfigUtil.getInstance().isLispMapRegisterEnabled()) {
 165             enableMapRegister(hostName);
 166             if (!addMapServer(hostName)) {
 167                 LOG.warn("Failed to add Map server for host: {}", hostName);
 168             }
 169         }
 170     }
 171
 172     private boolean enableLispOnHost(String hostName) {
 173         LOG.debug("Enabling LISP on host {}", hostName);
 174         AbstractLispCommand<Lisp> lispEnableCommand = LispCommandWrapper.enableLisp();
 175         return LispStateCommandExecutor.executePutCommand(hostName, lispEnableCommand);
 176     }
 177
 178     private boolean enableGpeForHost(String hostName) {
 179         AbstractLispCommand<GpeFeatureData> gpeEnableCommand = LispCommandWrapper.enableGpe();
 180         return LispStateCommandExecutor.executeMergeCommand(hostName, gpeEnableCommand);
 181     }
 182
 183     private void addLocatorSetOnHost(String hostName) throws LispNotFoundException, LispConfigCommandFailedException {
 184         try {
 185             //TODO locator is set to constant value, it has to be investigated further
 186             String locatorSetName = lispStateHelper.constructLocatorSetName(1);
 187             String lispDataInterfaceName = lispStateHelper
 188                     .getLispDataRlocInterfaceName(hostName).get();
 189             AbstractLispCommand<LocatorSet> addLocatorSetCommand = LispCommandWrapper.addLocatorSet(locatorSetName,
 190                     lispDataInterfaceName, DEFAULT_PRIORITY, DEFAULT_WEIGHT);
 191
 192             if (LispStateCommandExecutor.executePutCommand(hostName, addLocatorSetCommand)) {
 193                 addExtraItrRlocLocatorSetIfNeeded(hostName, lispDataInterfaceName);
 194             } else {
 195                 LOG.warn("Failed to write locator set: {} -> {} to host: {}", locatorSetName, lispDataInterfaceName,
 196                     hostName);
 197             }
 198         } catch (InterruptedException | ExecutionException e) {
 199             throw new LispNotFoundException("No interface with Ip Address found!");
 200         }
 201     }
 202
 203     private void addExtraItrRlocLocatorSetIfNeeded(String hostName, String lispDataInterfaceName)
 204             throws LispNotFoundException, LispConfigCommandFailedException {
 205         String lispCpRlocInterfaceName = lispStateHelper.getLispCpRlocInterfaceName(hostName);
 206         if (lispCpRlocInterfaceName == null || lispCpRlocInterfaceName.isEmpty()
 207                 || lispCpRlocInterfaceName.equals(lispDataInterfaceName)) {
 208             return;
 209         }
 210
 211         addItrLocatorSet(hostName, lispCpRlocInterfaceName);
 212     }
 213
 214     private void addItrLocatorSet(String hostName, String lispCpInterfaceName)
 215             throws LispNotFoundException, LispConfigCommandFailedException {
 216         String locatorSetName = lispStateHelper.constructLocatorSetNameForItrRloc();
 217         AbstractLispCommand<LocatorSet> addLocatorSetCommand = LispCommandWrapper.addLocatorSet(locatorSetName,
 218                 lispCpInterfaceName, DEFAULT_PRIORITY, DEFAULT_WEIGHT);
 219         if (!LispStateCommandExecutor.executePutCommand(hostName, addLocatorSetCommand)) {
 220             throw new LispConfigCommandFailedException("Lisp add locator set failed for host "
 221                     + hostName + " and locator interface " + lispCpInterfaceName);
 222         } else {
 223             AbstractLispCommand<ItrRemoteLocatorSet> addItrRlocCommand = LispCommandWrapper.addItrRloc(locatorSetName);
 224             if (!LispStateCommandExecutor.executePutCommand(hostName, addItrRlocCommand)) {
 225                 throw new LispConfigCommandFailedException(
 226                     "Lisp add Itr Rloc command failed for host " + hostName + " and locator set " + locatorSetName);
 227             }
 228         }
 229     }
 230
 231     private boolean addMapResolverOnHost(String hostname) {
 232         IpAddress mapResolverIpAddress = ConfigUtil.getInstance().getOdlIp();
 233         Preconditions.checkNotNull(mapResolverIpAddress, "Map Resolver ip not properly configured!");
 234
 235         AbstractLispCommand<MapResolver> addMapResolverCommand = LispCommandWrapper.
 236                 addMapResolver(mapResolverIpAddress);
 237         return LispStateCommandExecutor.executePutCommand(hostname, addMapResolverCommand);
 238     }
 239
 240     private void enableMapRegister(String hostName)
 241             throws LispConfigCommandFailedException {
 242         AbstractLispCommand<MapRegister> enableMapRegisterCommand = LispCommandWrapper.enableMapRegister();
 243
 244         if (!LispStateCommandExecutor.executePutCommand(hostName, enableMapRegisterCommand)) {
 245             throw new LispConfigCommandFailedException("Lisp enable map registration for host "
 246                     + hostName + " failed!");
 247         }
 248
 249     }
 250
 251     private boolean addMapServer(String hostName) throws LispConfigCommandFailedException {
 252         IpAddress mapServerIpAddress = ConfigUtil.getInstance().getOdlIp();
 253         Preconditions.checkNotNull(mapServerIpAddress, "Mapserver ip not properly configured!");
 254         AbstractLispCommand<MapServer> addMapServerCommand = LispCommandWrapper.addMapServer(mapServerIpAddress);
 255
 256         return LispStateCommandExecutor.executePutCommand(hostName, addMapServerCommand);
 257     }
 258
 259     private void addVniSpecificConfigurationsIfNeeded(String hostName, long vni, long vrf) {
 260
 261         if (vnisByHostname.get(hostName) != null && !vnisByHostname.get(hostName).contains(vni)) {
 262             if (addVniToVrfMapping(hostName, vni, vrf)) {
 263                 if (!addGpeNativeForwardPath(hostName, vrf, hostRelatedInfoContainer.getPhysicalInterfaceState(hostName)
 264                         .getIp(PhysicalInterfaces.PhysicalInterfaceType.PUBLIC))) {
 265                     LOG.warn("Configure GPE native forward failed for host: {} and vni: {}", hostName, vni);
 266                 }
 267                 if (vnisByHostname.get(hostName) != null) {
 268                     vnisByHostname.get(hostName).add(vni);
 269                 }
 270             }
 271         }
 272     }
 273
 274     private boolean addVniToVrfMapping(String hostName, long vni, long vrf) {
 275         AbstractLispCommand<VniTable> addVniToVrfMapping = LispCommandWrapper.mapVniToVrf(vni, vrf);
 276         return (LispStateCommandExecutor.executePutCommand(hostName, addVniToVrfMapping));
 277     }
 278
 279     private boolean addGpeNativeForwardPath(String hostname, long vrf, IpAddress nativeForwardIp){
 280         AbstractLispCommand<NativeForwardPath> addNativeForwardingIp =
 281                 LispCommandWrapper.addNativeForwardEntry(vrf, nativeForwardIp);
 282         return LispStateCommandExecutor.executePutCommand(hostname, addNativeForwardingIp);
 283     }
 284
 285     private boolean addEidInEidTable(String hostName, Eid eid, String eidMappingName)
 286         throws LispConfigCommandFailedException {
 287         AbstractLispCommand<LocalMapping> addLocalMappingInEidTableCommand = LispCommandWrapper
 288                 .addLocalMappingInEidTable(eidMappingName,
 289                         eid,
 290                         lispStateHelper.constructLocatorSetName(1),
 291                         lispStateHelper.getDefaultHmacKey());
 292         return LispStateCommandExecutor.executePutCommand(hostName, addLocalMappingInEidTableCommand);
 293     }
 294
 295     public synchronized void processDeleteEndpoint(AddressEndpointWithLocation addressEp) {
 296         if (!addressEp.getAddressType().equals(IpPrefixType.class)) {
 297             return;
 298         }
 299         Map<String, String> intfcsByHostname = FlatOverlayManager.resolveIntfcsByHosts(addressEp);
 300
 301         intfcsByHostname.forEach((hostname, interfaceName) -> {
 302             try {
 303
 304                 long vni = getVni(addressEp.getTenant().getValue());
 305                 Eid eid = lispStateHelper.getEid(addressEp, vni);
 306                 String eidMappingName = lispStateHelper.constructEidMappingName(addressEp, interfaceName);
 307                 if (!ConfigManagerHelper.isMetadataPort(addressEp)) {
 308                     if (!deleteEidFromLocalEidTableOfHost(hostname, eid, eidMappingName)) {
 309                         LOG.warn("Failed to delete Eid : {}, eidMappingName: {} on host: {}", eid, eidMappingName,
 310                             hostname);
 311                     }
 312                 }
 313
 314                 Optional<LocalMappings> localMappingsOptional =
 315                     GbpNetconfTransaction.read(VppIidFactory.getNetconfNodeIid(new NodeId(hostname)),
 316                         LogicalDatastoreType.CONFIGURATION, VppIidFactory.getLocalMappings(new VniTableKey(vni)),
 317                         GbpNetconfTransaction.RETRY_COUNT);
 318
 319                 if (!localMappingsOptional.isPresent() || localMappingsOptional.get().getLocalMapping() == null
 320                     || localMappingsOptional.get().getLocalMapping().size() == 0) {
 321
 322                     //remove mapping table for VNI
 323                     if (GbpNetconfTransaction.netconfSyncedDelete(VppIidFactory.getNetconfNodeIid(new NodeId(hostname)),
 324                         VppIidFactory.getVniTableIid(new VniTableKey(vni)), GbpNetconfTransaction.RETRY_COUNT)) {
 325                         Preconditions.checkNotNull(hostname);
 326                         if (vnisByHostname.get(hostname) != null) {
 327                             vnisByHostname.get(hostname).remove(vni);
 328                         }
 329                     }
 330                 }
 331                 if (vnisByHostname.get(hostname)!= null && vnisByHostname.get(hostname).size() == 0) {
 332                     //safe to delete lisp
 333                     deleteLispStatesFromHost(hostname);
 334                     if (!deleteNativeForwardPathsTables(hostname)) {
 335                         LOG.warn("Failed to delete native forward paths tables from host: {}", hostname);
 336                     }
 337                     vnisByHostname.remove(hostname);
 338
 339                 }
 340             } catch (LispConfigCommandFailedException e) {
 341                 LOG.warn("Lisp command execution failed: {}", e.getMessage());
 342             }
 343         });
 344     }
 345
 346
 347
 348     private boolean deleteEidFromLocalEidTableOfHost(String hostName, Eid eid, String eidMappingName)
 349         throws LispConfigCommandFailedException {
 350         long value = eid.getVirtualNetworkId().getValue();
 351
 352         AbstractLispCommand<LocalMapping> deleteLocalMappingCommand = LispCommandWrapper
 353                 .deleteLocalMappingFromEidTable(eidMappingName, value);
 354
 355         return (LispStateCommandExecutor.executeDeleteCommand(hostName, deleteLocalMappingCommand));
 356     }
 357
 358
 359     private void deleteLispStatesFromHost(String hostname) throws LispConfigCommandFailedException {
 360         //Todo workaround to delete only inside data not whole lisp-feature-data at once
 361         // (causes VPP to crash https://jira.fd.io/browse/HC2VPP-242) remove when fixed
 362         InstanceIdentifier<Node> nodeIid = LispUtil.hostnameToIid(hostname);
 363         Optional<Lisp> lispOptional =
 364             GbpNetconfTransaction.read(nodeIid, LogicalDatastoreType.CONFIGURATION,
 365                 InstanceIdentifier.create(Lisp.class), GbpNetconfTransaction.RETRY_COUNT);
 366         if (lispOptional.isPresent()) {
 367             LispFeatureData lispFeatureData = lispOptional.get().getLispFeatureData();
 368
 369             if (lispFeatureData == null || nodeIid == null) {
 370                 return;
 371             }
 372             LOG.trace("Removing all Eids from host: {}", hostname);
 373             if (lispFeatureData.getEidTable() != null && lispFeatureData.getEidTable().getVniTable() != null) {
 374
 375                 lispFeatureData.getEidTable().getVniTable().forEach(vniTable -> {
 376                     if (vniTable.getVrfSubtable() != null && vniTable.getVrfSubtable().getLocalMappings() != null
 377                         && vniTable.getVrfSubtable().getLocalMappings().getLocalMapping() != null)
 378                         //remove all mapping from vni table
 379                     vniTable.getVrfSubtable().getLocalMappings().getLocalMapping().forEach(localMapping -> {
 380                         GbpNetconfTransaction.netconfSyncedDelete(nodeIid,
 381                             InstanceIdentifier.builder(Lisp.class)
 382                                 .child(LispFeatureData.class)
 383                                 .child(EidTable.class)
 384                                 .child(VniTable.class, vniTable.getKey())
 385                                 .child(VrfSubtable.class)
 386                                 .child(LocalMappings.class)
 387                                 .child(LocalMapping.class, localMapping.getKey())
 388                                 .build(),
 389                             GbpNetconfTransaction.RETRY_COUNT);
 390                     });
 391                     //remove EID VNI table
 392                     GbpNetconfTransaction.netconfSyncedDelete(nodeIid, InstanceIdentifier.builder(Lisp.class)
 393                         .child(LispFeatureData.class)
 394                         .child(EidTable.class)
 395                         .child(VniTable.class, vniTable.getKey())
 396                         .build(), GbpNetconfTransaction.RETRY_COUNT);
 397                 });
 398                 //remove EID table
 399                 GbpNetconfTransaction.netconfSyncedDelete(nodeIid,
 400                     InstanceIdentifier.builder(Lisp.class).child(LispFeatureData.class).child(EidTable.class).build(),
 401                     GbpNetconfTransaction.RETRY_COUNT);
 402
 403             }
 404             LOG.trace("Removing ItrRemoteLocatorSet from host: {}", hostname);
 405             if (lispFeatureData.getItrRemoteLocatorSet() != null) {
 406                 GbpNetconfTransaction.netconfSyncedDelete(nodeIid, InstanceIdentifier.builder(Lisp.class)
 407                     .child(LispFeatureData.class)
 408                     .child(ItrRemoteLocatorSet.class)
 409                     .build(), GbpNetconfTransaction.RETRY_COUNT);
 410             }
 411             LOG.trace("Removing all locators from host: {}", hostname);
 412             if (lispFeatureData.getLocatorSets() != null) {
 413
 414                 List<LocatorSet> locatorSetList = lispFeatureData.getLocatorSets().getLocatorSet();
 415                 if (locatorSetList == null || locatorSetList.isEmpty()) {
 416                     return;
 417                 }
 418
 419                 for (LocatorSet locatorSet : locatorSetList) {
 420                         GbpNetconfTransaction.netconfSyncedDelete(nodeIid, InstanceIdentifier.builder(Lisp.class)
 421                             .child(LispFeatureData.class)
 422                             .child(LocatorSets.class)
 423                             .child(LocatorSet.class, locatorSet.getKey())
 424                             .build(), GbpNetconfTransaction.RETRY_COUNT);
 425                 }
 426
 427             }
 428             LOG.trace("Removing MapResolvers from host: {}", hostname);
 429             if (lispFeatureData.getMapResolvers() != null) {
 430                 GbpNetconfTransaction.netconfSyncedDelete(nodeIid, InstanceIdentifier.builder(Lisp.class)
 431                     .child(LispFeatureData.class)
 432                     .child(MapResolvers.class)
 433                     .build(), GbpNetconfTransaction.RETRY_COUNT);
 434             }
 435             LOG.trace("Removing MapServers from host: {}", hostname);
 436             if (lispFeatureData.getMapServers() != null) {
 437                 GbpNetconfTransaction.netconfSyncedDelete(nodeIid, InstanceIdentifier.builder(Lisp.class)
 438                     .child(LispFeatureData.class)
 439                     .child(MapServers.class)
 440                     .build(), GbpNetconfTransaction.RETRY_COUNT);
 441             }
 442             LOG.trace("Removing MapServers from host: {}", hostname);
 443             if (lispFeatureData.getMapRegister() != null) {
 444                 GbpNetconfTransaction.netconfSyncedDelete(nodeIid, InstanceIdentifier.builder(Lisp.class)
 445                     .child(LispFeatureData.class)
 446                     .child(MapRegister.class)
 447                     .build(), GbpNetconfTransaction.RETRY_COUNT);
 448             }
 449
 450             LOG.trace("Removing all locators from host: {}", hostname);
 451
 452             cleanLisp(hostname);
 453         }
 454
 455     }
 456
 457     private boolean deleteNativeForwardPathsTables(String hostname)
 458             throws LispConfigCommandFailedException {
 459         AbstractLispCommand<NativeForwardPathsTables> deleteNativeForwardPathsTables = LispCommandWrapper
 460                 .deleteNativeForwardPathsTables();
 461
 462         return LispStateCommandExecutor.executeDeleteCommand(hostname, deleteNativeForwardPathsTables);
 463     }
 464
 465     private long getVni(String tenantUuid) {
 466         return neutronTenantToVniMapper.getVni(tenantUuid);
 467     }
 468
 469     private static void cleanLisp(String hostName)
 470         throws LispConfigCommandFailedException {
 471         if (LispStateCommandExecutor.executeDeleteCommand(hostName, LispCommandWrapper.deleteLispFeatureData())) {
 472             LOG.debug("Deleted all lisp data for host {}",hostName);
 473         } else {
 474             throw new LispConfigCommandFailedException("Lisp delete feature data command failed!");
 475         }
 476     }
 477 }