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