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