package org.opendaylight.groupbasedpolicy.renderer.vpp.lisp;
+import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import com.google.common.collect.Lists;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ExecutionException;
+
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.lisp.AbstractLispCommand;
import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.lisp.LispCommandWrapper;
import org.opendaylight.groupbasedpolicy.renderer.vpp.config.ConfigUtil;
import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.exception.LispConfigCommandFailedException;
import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.exception.LispNotFoundException;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.flat.overlay.FlatOverlayManager;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.HostRelatedInfoContainer;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.states.PhysicalInterfaces;
import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.mappers.NeutronTenantToVniMapper;
import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.util.ConfigManagerHelper;
-import org.opendaylight.groupbasedpolicy.renderer.vpp.util.General;
-import org.opendaylight.groupbasedpolicy.renderer.vpp.util.MountedDataBrokerProvider;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.util.GbpNetconfTransaction;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.util.LispUtil;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.util.VppIidFactory;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev170511.IpPrefixType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.endpoints.AddressEndpointWithLocation;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.gpe.rev170518.gpe.feature.data.grouping.GpeFeatureData;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.Lisp;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.dp.subtable.grouping.local.mappings.LocalMapping;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.dp.subtable.grouping.local.mappings.local.mapping.Eid;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.eid.table.grouping.eid.table.VniTable;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.lisp.feature.data.grouping.LispFeatureData;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.locator.sets.grouping.locator.sets.LocatorSet;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.register.grouping.MapRegister;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.resolvers.grouping.map.resolvers.MapResolver;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.servers.grouping.map.servers.MapServer;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.gpe.rev170801.NativeForwardPathsTables;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.gpe.rev170801._native.forward.paths.tables._native.forward.paths.table.NativeForwardPath;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.gpe.rev170801.gpe.feature.data.grouping.GpeFeatureData;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev171013.Lisp;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev171013.dp.subtable.grouping.LocalMappings;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev171013.dp.subtable.grouping.local.mappings.LocalMapping;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev171013.dp.subtable.grouping.local.mappings.local.mapping.Eid;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev171013.eid.table.grouping.EidTable;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev171013.eid.table.grouping.eid.table.VniTable;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev171013.eid.table.grouping.eid.table.VniTableKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev171013.eid.table.grouping.eid.table.vni.table.VrfSubtable;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev171013.itr.remote.locator.sets.grouping.ItrRemoteLocatorSet;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev171013.lisp.feature.data.grouping.LispFeatureData;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev171013.locator.sets.grouping.LocatorSets;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev171013.locator.sets.grouping.locator.sets.LocatorSet;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev171013.map.register.grouping.MapRegister;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev171013.map.resolvers.grouping.MapResolvers;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev171013.map.resolvers.grouping.map.resolvers.MapResolver;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev171013.map.servers.grouping.MapServers;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev171013.map.servers.grouping.map.servers.MapServer;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import javax.annotation.Nonnull;
-import java.util.HashMap;
-import java.util.concurrent.ExecutionException;
-
-/**
- * Created by Shakib Ahmed on 3/29/17.
- */
public class LispStateManager {
private static final Logger LOG = LoggerFactory.getLogger(LispStateManager.class);
- private HashMap<String, LispState> lispStateMapper;
- private MountedDataBrokerProvider mountedDataBrokerProvider;
+ private HostRelatedInfoContainer hostRelatedInfoContainer;
private ConfigManagerHelper lispStateHelper;
private NeutronTenantToVniMapper neutronTenantToVniMapper;
private static final short DEFAULT_WEIGHT = 1;
public static final String DEFAULT_XTR_KEY = "admin";
public static final String DEFAULT_LOCATOR_SET_NAME_PREFIX = "LS";
- public static final String DEFAULT_MAPPINGRECORD_NAME_PREFIX = "MR";
-
- public LispStateManager(@Nonnull MountedDataBrokerProvider mountedDataBrokerProvider) {
- Preconditions.checkNotNull(mountedDataBrokerProvider,
- "MountedDataBrokerProvider found to be null!");
- lispStateMapper = new HashMap<>();
- this.mountedDataBrokerProvider= mountedDataBrokerProvider;
- this.lispStateHelper = new ConfigManagerHelper(this.mountedDataBrokerProvider);
+ public static final String DEFAULT_MAPPING_RECORD_NAME_PREFIX = "MR_";
+
+ // Node ID, VRF ID, route count
+ private Map<String, List<Long>> vnisByHostname = new HashMap<>();
+
+ public LispStateManager() {
+ hostRelatedInfoContainer = HostRelatedInfoContainer.getInstance();
+ this.lispStateHelper = new ConfigManagerHelper();
neutronTenantToVniMapper = NeutronTenantToVniMapper.getInstance();
}
- public synchronized void configureEndPoint(AddressEndpointWithLocation addressEp) {
- try {
- if (lispStateHelper.isMetadataPort(addressEp)) {
- return;
- }
- DataBroker dataBroker = lispStateHelper.getPotentialExternalDataBroker(addressEp).get();
- String hostName = lispStateHelper.getHostName(addressEp).get();
- LispState lispStateOfNode = configureHostIfNeeded(hostName, dataBroker);
+ public synchronized void processCreateEndPoint(AddressEndpointWithLocation addressEp) {
+ if (!addressEp.getAddressType().equals(IpPrefixType.class)) {
+ return;
+ }
+ Map<String, String> intfcsByHostname = FlatOverlayManager.resolveIntfcsByHosts(addressEp);
- long vni = getVni(addressEp.getTenant().getValue());
- long vrf = vni;
- addVniToVrfMappingIfNeeded(dataBroker, lispStateOfNode, vni, vrf);
+ intfcsByHostname.forEach((hostname, interfaceName) -> {
+ try {
+ configureHostIfNeeded(hostname);
- Eid eid = lispStateHelper.getEid(addressEp, vni);
+ long vni = getVni(addressEp.getTenant().getValue());
+ long vrf = vni;
- if(!lispStateOfNode.eidSetContains(eid)) {
- addEidInEidTable(dataBroker, lispStateOfNode, eid);
+ Eid eid = lispStateHelper.getEid(addressEp, vni);
+ String eidMappingName = lispStateHelper.constructEidMappingName(addressEp, interfaceName);
+
+ addVniSpecificConfigurationsIfNeeded(hostname, vni, vrf);
+ if (!ConfigManagerHelper.isMetadataPort(addressEp)) {
+ if (!addEidInEidTable(hostname, eid, eidMappingName)) {
+ LOG.warn("Failed to add Eid: {}, eidMappingName: {} to table on host: {}", eid, eidMappingName,
+ hostname);
+ }
+ }
+ } catch (LispConfigCommandFailedException e) {
+ LOG.warn("Lisp endpoint configuration failed for address endpoint: {}", addressEp);
}
+ });
+
- } catch (LispConfigCommandFailedException e) {
- LOG.warn("Lisp endpoint configuration failed for address endpoint: {}", addressEp);
- }
}
- public synchronized LispState configureHostIfNeeded(String hostName, DataBroker vppDataBroker) throws LispConfigCommandFailedException {
- LispState lispStateOfNode = lispStateMapper.get(hostName);
+ private synchronized void configureHostIfNeeded(String hostName)
+ throws LispConfigCommandFailedException {
- if (lispStateOfNode == null) {
- lispStateOfNode = new LispState(hostName);
- try {
- enableLispForNode(vppDataBroker, lispStateOfNode);
+ if ((vnisByHostname.get(hostName) == null)) {
- if (ConfigUtil.getInstance().isL3FlatEnabled()) {
- enableGpeForNode(vppDataBroker, lispStateOfNode);
+ LOG.debug("Configuring host {} for LISP", hostName);
+
+ try {
+ boolean lispEnabled = enableLispOnHost(hostName);
+ Optional<GpeFeatureData> gpeFeatureDataOptional =
+ GbpNetconfTransaction.read(VppIidFactory.getNetconfNodeIid(new NodeId(hostName)),
+ LogicalDatastoreType.CONFIGURATION, VppIidFactory.getGpeFeatureDataIid(),
+ GbpNetconfTransaction.RETRY_COUNT);
+
+ LOG.trace("configureHostIfNeeded -> GpeOnHostFeatureData: {}", gpeFeatureDataOptional);
+
+ if (!gpeFeatureDataOptional.isPresent() || !gpeFeatureDataOptional.get().isEnable()) {
+ if (!enableGpeOnHostIfNeeded(hostName)) {
+ LOG.trace("configureHostIfNeeded -> Gpe on host: {} cannot be enabled.", hostName);
+ }
+ LOG.trace("configureHostIfNeeded -> GpeOnHostFeatureData were cleared");
}
- addLocatorSet(vppDataBroker, lispStateOfNode);
- addMapResolver(vppDataBroker, lispStateOfNode);
- if (ConfigUtil.getInstance().isLispMapRegisterEnabled()) {
- enableMapRegister(vppDataBroker, lispStateOfNode);
- addMapServer(vppDataBroker, lispStateOfNode);
+ if (lispEnabled) {
+ addLocatorSetOnHost(hostName);
+ if (!addMapResolverOnHost(hostName)) {
+ LOG.warn("Failed to add MAP resolver for host: {}", hostName);
+ }
+ enableMapRegistrationOnHostIfNeeded(hostName);
+ vnisByHostname.computeIfAbsent(hostName, k -> Lists.newArrayList());
+ } else {
+ LOG.warn("Failed to enable LISP or GPE on host: {}", hostName);
}
- lispStateMapper.put(hostName, lispStateOfNode);
+
} catch (LispNotFoundException e) {
LOG.warn("Lisp host configuration failed: ", e.getMessage());
throw new LispConfigCommandFailedException("Failed LISP configuration!");
}
}
- return lispStateOfNode;
}
- public synchronized void deleteLispConfigurationForEndpoint(AddressEndpointWithLocation addressEp) {
- try {
- DataBroker vppDataBroker = lispStateHelper.getPotentialExternalDataBroker(addressEp).get();
- String hostName = lispStateHelper.getHostName(addressEp).get();
-
- LispState lispState = lispStateMapper.get(hostName);
-
- if (lispState == null) {
- LOG.debug("Endpoint not configured for LISP. EndPoint: {}", addressEp);
- } else {
- long vni = getVni(addressEp.getTenant().getValue());
- Eid eid = lispStateHelper.getEid(addressEp, vni);
-
- if (lispState.eidSetContains(eid)) {
- deleteEidFromEidTable(vppDataBroker, lispState, eid);
- }
+ private boolean enableGpeOnHostIfNeeded(String hostName) {
+ return enableGpeForHost(hostName);
+ }
- if (lispState.eidCount() == 0) {
- deleteLispStatesInEndPoints(vppDataBroker, lispState);
- }
+ private void enableMapRegistrationOnHostIfNeeded(String hostName)
+ throws LispConfigCommandFailedException {
+ if (ConfigUtil.getInstance().isLispMapRegisterEnabled()) {
+ enableMapRegister(hostName);
+ if (!addMapServer(hostName)) {
+ LOG.warn("Failed to add Map server for host: {}", hostName);
}
- } catch (LispConfigCommandFailedException e) {
- LOG.warn("Lisp command execution failed: {}", e.getMessage());
}
}
- private void enableLispForNode(DataBroker vppDataBroker, LispState lispState) throws LispConfigCommandFailedException {
- AbstractLispCommand<Lisp>
- lispEnableCommand = LispCommandWrapper.enableLisp();
- if (LispStateCommandExecutor.executePutCommand(vppDataBroker, lispEnableCommand)) {
- lispState.setLispEnabled(true);
- } else {
- throw new LispConfigCommandFailedException("Lisp Enable Command failed execution!");
- }
+ private boolean enableLispOnHost(String hostName) {
+ LOG.debug("Enabling LISP on host {}", hostName);
+ AbstractLispCommand<Lisp> lispEnableCommand = LispCommandWrapper.enableLisp();
+ return LispStateCommandExecutor.executePutCommand(hostName, lispEnableCommand);
}
- private void enableGpeForNode(DataBroker vppDataBroker, LispState lispState) throws LispConfigCommandFailedException {
- AbstractLispCommand<GpeFeatureData>
- gpeEnableCommand = LispCommandWrapper.enableGpe();
- if (LispStateCommandExecutor.executePutCommand(vppDataBroker, gpeEnableCommand)) {
- lispState.setGpeEnabled(true);
- } else {
- throw new LispConfigCommandFailedException("GPE Enable Command failed execution!");
- }
+ private boolean enableGpeForHost(String hostName) {
+ AbstractLispCommand<GpeFeatureData> gpeEnableCommand = LispCommandWrapper.enableGpe();
+ return LispStateCommandExecutor.executeMergeCommand(hostName, gpeEnableCommand);
}
- private void addLocatorSet(DataBroker vppDataBroker, LispState lispState) throws LispNotFoundException, LispConfigCommandFailedException {
+ private void addLocatorSetOnHost(String hostName) throws LispNotFoundException, LispConfigCommandFailedException {
try {
- String locatorSetName = lispStateHelper.constructLocatorSetName(lispState.getLocatorCount());
- String interfaceName = lispStateHelper.readRlocInterface(lispState.getHostName(), vppDataBroker).get();
+ //TODO locator is set to constant value, it has to be investigated further
+ String locatorSetName = lispStateHelper.constructLocatorSetName(1);
+ String lispDataInterfaceName = lispStateHelper
+ .getLispDataRlocInterfaceName(hostName).get();
AbstractLispCommand<LocatorSet> addLocatorSetCommand = LispCommandWrapper.addLocatorSet(locatorSetName,
- interfaceName, DEFAULT_PRIORITY, DEFAULT_WEIGHT);
- if (LispStateCommandExecutor.executePutCommand(vppDataBroker, addLocatorSetCommand)) {
- lispState.setLocIntfToLocSetNameMapping(interfaceName, locatorSetName);
+ lispDataInterfaceName, DEFAULT_PRIORITY, DEFAULT_WEIGHT);
+
+ if (LispStateCommandExecutor.executePutCommand(hostName, addLocatorSetCommand)) {
+ addExtraItrRlocLocatorSetIfNeeded(hostName, lispDataInterfaceName);
} else {
- throw new LispConfigCommandFailedException("Lisp add locator set failed for host "
- + lispState.getHostName() + " and locator interface " + interfaceName);
+ LOG.warn("Failed to write locator set: {} -> {} to host: {}", locatorSetName, lispDataInterfaceName,
+ hostName);
}
} catch (InterruptedException | ExecutionException e) {
throw new LispNotFoundException("No interface with Ip Address found!");
}
+ }
+
+ private void addExtraItrRlocLocatorSetIfNeeded(String hostName, String lispDataInterfaceName)
+ throws LispNotFoundException, LispConfigCommandFailedException {
+ String lispCpRlocInterfaceName = lispStateHelper.getLispCpRlocInterfaceName(hostName);
+ if (lispCpRlocInterfaceName == null || lispCpRlocInterfaceName.isEmpty()
+ || lispCpRlocInterfaceName.equals(lispDataInterfaceName)) {
+ return;
+ }
+ addItrLocatorSet(hostName, lispCpRlocInterfaceName);
}
- private void addMapResolver(DataBroker vppDataBroker, LispState lispState) throws LispConfigCommandFailedException {
- IpAddress mapResolverIpAddress = ConfigUtil.getInstance().getOdlTenantIp();
+ private void addItrLocatorSet(String hostName, String lispCpInterfaceName)
+ throws LispNotFoundException, LispConfigCommandFailedException {
+ String locatorSetName = lispStateHelper.constructLocatorSetNameForItrRloc();
+ AbstractLispCommand<LocatorSet> addLocatorSetCommand = LispCommandWrapper.addLocatorSet(locatorSetName,
+ lispCpInterfaceName, DEFAULT_PRIORITY, DEFAULT_WEIGHT);
+ if (!LispStateCommandExecutor.executePutCommand(hostName, addLocatorSetCommand)) {
+ throw new LispConfigCommandFailedException("Lisp add locator set failed for host "
+ + hostName + " and locator interface " + lispCpInterfaceName);
+ } else {
+ AbstractLispCommand<ItrRemoteLocatorSet> addItrRlocCommand = LispCommandWrapper.addItrRloc(locatorSetName);
+ if (!LispStateCommandExecutor.executePutCommand(hostName, addItrRlocCommand)) {
+ throw new LispConfigCommandFailedException(
+ "Lisp add Itr Rloc command failed for host " + hostName + " and locator set " + locatorSetName);
+ }
+ }
+ }
+
+ private boolean addMapResolverOnHost(String hostname) {
+ IpAddress mapResolverIpAddress = ConfigUtil.getInstance().getOdlIp();
Preconditions.checkNotNull(mapResolverIpAddress, "Map Resolver ip not properly configured!");
AbstractLispCommand<MapResolver> addMapResolverCommand = LispCommandWrapper.
addMapResolver(mapResolverIpAddress);
- if (LispStateCommandExecutor.executePutCommand(vppDataBroker, addMapResolverCommand)) {
- lispState.addInMapResolverSet(mapResolverIpAddress);
- } else {
- throw new LispConfigCommandFailedException("Lisp add map resolver for host " + lispState.getHostName()
- + " failed for ODL ip " + mapResolverIpAddress);
+ return LispStateCommandExecutor.executePutCommand(hostname, addMapResolverCommand);
+ }
+
+ private void enableMapRegister(String hostName)
+ throws LispConfigCommandFailedException {
+ AbstractLispCommand<MapRegister> enableMapRegisterCommand = LispCommandWrapper.enableMapRegister();
+
+ if (!LispStateCommandExecutor.executePutCommand(hostName, enableMapRegisterCommand)) {
+ throw new LispConfigCommandFailedException("Lisp enable map registration for host "
+ + hostName + " failed!");
}
+
}
- private void addMapServer(DataBroker vppDataBroker, LispState lispState) throws LispConfigCommandFailedException {
- IpAddress mapServerIpAddress = ConfigUtil.getInstance().getOdlTenantIp();
+ private boolean addMapServer(String hostName) throws LispConfigCommandFailedException {
+ IpAddress mapServerIpAddress = ConfigUtil.getInstance().getOdlIp();
Preconditions.checkNotNull(mapServerIpAddress, "Mapserver ip not properly configured!");
AbstractLispCommand<MapServer> addMapServerCommand = LispCommandWrapper.addMapServer(mapServerIpAddress);
- if (LispStateCommandExecutor.executePutCommand(vppDataBroker, addMapServerCommand)) {
- lispState.addInMapServerSet(mapServerIpAddress);
- } else {
- throw new LispConfigCommandFailedException("Lisp add map server for host " + lispState.getHostName()
- + " failed for ODL ip " + mapServerIpAddress);
- }
+ return LispStateCommandExecutor.executePutCommand(hostName, addMapServerCommand);
}
- private void enableMapRegister(DataBroker vppDataBroker, LispState lispState) throws LispConfigCommandFailedException {
- AbstractLispCommand<MapRegister> enableMapRegisterCommand = LispCommandWrapper.enableMapRegister();
+ private void addVniSpecificConfigurationsIfNeeded(String hostName, long vni, long vrf) {
- if (LispStateCommandExecutor.executePutCommand(vppDataBroker, enableMapRegisterCommand)) {
- lispState.setMapRegisteredEnabled(true);
- } else {
- throw new LispConfigCommandFailedException("Lisp enable mapregistration for host "
- + lispState.getHostName() + " failed!");
+ if (vnisByHostname.get(hostName) != null && !vnisByHostname.get(hostName).contains(vni)) {
+ if (addVniToVrfMapping(hostName, vni, vrf)) {
+ if (!addGpeNativeForwardPath(hostName, vrf, hostRelatedInfoContainer.getPhysicalInterfaceState(hostName)
+ .getIp(PhysicalInterfaces.PhysicalInterfaceType.PUBLIC))) {
+ LOG.warn("Configure GPE native forward failed for host: {} and vni: {}", hostName, vni);
+ }
+ if (vnisByHostname.get(hostName) != null) {
+ vnisByHostname.get(hostName).add(vni);
+ }
+ }
}
+ }
+ private boolean addVniToVrfMapping(String hostName, long vni, long vrf) {
+ AbstractLispCommand<VniTable> addVniToVrfMapping = LispCommandWrapper.mapVniToVrf(vni, vrf);
+ return (LispStateCommandExecutor.executePutCommand(hostName, addVniToVrfMapping));
}
- private void addVniToVrfMappingIfNeeded(DataBroker vppDataBroker,
- LispState lispState,
- long vni, long vrf) throws LispConfigCommandFailedException {
- if (!lispState.vniSetContains(vni)) {
- AbstractLispCommand<VniTable> addVniToVrfMapping = LispCommandWrapper.mapVniToVrf(vni, vrf);
- addVniToVrfMapping.setOptions(General.Operations.PUT);
- if (LispStateCommandExecutor.executePutCommand(vppDataBroker, addVniToVrfMapping)) {
- lispState.addInVniSet(vni);
- } else {
- throw new LispConfigCommandFailedException("Lisp add vrf " + vrf +" for vni " +vni
- + " command failed!");
- }
- }
+ private boolean addGpeNativeForwardPath(String hostname, long vrf, IpAddress nativeForwardIp){
+ AbstractLispCommand<NativeForwardPath> addNativeForwardingIp =
+ LispCommandWrapper.addNativeForwardEntry(vrf, nativeForwardIp);
+ return LispStateCommandExecutor.executePutCommand(hostname, addNativeForwardingIp);
}
- private void addEidInEidTable(DataBroker vppDataBroker,
- LispState lispState,
- Eid eid) throws LispConfigCommandFailedException {
- String mappingId = lispStateHelper.constructMappingName(lispState.getInterfaceId());
+ private boolean addEidInEidTable(String hostName, Eid eid, String eidMappingName)
+ throws LispConfigCommandFailedException {
AbstractLispCommand<LocalMapping> addLocalMappingInEidTableCommand = LispCommandWrapper
- .addLocalMappingInEidTable(mappingId,
+ .addLocalMappingInEidTable(eidMappingName,
eid,
- lispStateHelper.getFirstLocatorSetName(lispState),
+ lispStateHelper.constructLocatorSetName(1),
lispStateHelper.getDefaultHmacKey());
- if (LispStateCommandExecutor.executePutCommand(vppDataBroker, addLocalMappingInEidTableCommand)) {
- lispState.addInEidSet(eid, mappingId);
- } else {
- throw new LispConfigCommandFailedException("Lisp add local mapping for eid " + eid + "failed!");
- }
+ return LispStateCommandExecutor.executePutCommand(hostName, addLocalMappingInEidTableCommand);
}
- private void deleteLispStatesInEndPoints(DataBroker vppDataBroker,
- LispState lispState) throws LispConfigCommandFailedException {
- AbstractLispCommand<LispFeatureData> deleteLispFeatureData = LispCommandWrapper.deleteLispFeatureData();
-
- if (LispStateCommandExecutor.executeDeleteCommand(vppDataBroker, deleteLispFeatureData)) {
- String computeNode = lispState.getHostName();
- lispStateMapper.remove(computeNode);
- } else {
- throw new LispConfigCommandFailedException("Lisp delete feature data command failed!");
+ public synchronized void processDeleteEndpoint(AddressEndpointWithLocation addressEp) {
+ if (!addressEp.getAddressType().equals(IpPrefixType.class)) {
+ return;
}
+ Map<String, String> intfcsByHostname = FlatOverlayManager.resolveIntfcsByHosts(addressEp);
+
+ intfcsByHostname.forEach((hostname, interfaceName) -> {
+ try {
+
+ long vni = getVni(addressEp.getTenant().getValue());
+ Eid eid = lispStateHelper.getEid(addressEp, vni);
+ String eidMappingName = lispStateHelper.constructEidMappingName(addressEp, interfaceName);
+ if (!ConfigManagerHelper.isMetadataPort(addressEp)) {
+ if (!deleteEidFromLocalEidTableOfHost(hostname, eid, eidMappingName)) {
+ LOG.warn("Failed to delete Eid : {}, eidMappingName: {} on host: {}", eid, eidMappingName,
+ hostname);
+ }
+ }
+
+ Optional<LocalMappings> localMappingsOptional =
+ GbpNetconfTransaction.read(VppIidFactory.getNetconfNodeIid(new NodeId(hostname)),
+ LogicalDatastoreType.CONFIGURATION, VppIidFactory.getLocalMappings(new VniTableKey(vni)),
+ GbpNetconfTransaction.RETRY_COUNT);
+
+ if (!localMappingsOptional.isPresent() || localMappingsOptional.get().getLocalMapping() == null
+ || localMappingsOptional.get().getLocalMapping().size() == 0) {
+
+ //remove mapping table for VNI
+ if (GbpNetconfTransaction.netconfSyncedDelete(VppIidFactory.getNetconfNodeIid(new NodeId(hostname)),
+ VppIidFactory.getVniTableIid(new VniTableKey(vni)), GbpNetconfTransaction.RETRY_COUNT)) {
+ Preconditions.checkNotNull(hostname);
+ if (vnisByHostname.get(hostname) != null) {
+ vnisByHostname.get(hostname).remove(vni);
+ }
+ }
+ }
+ if (vnisByHostname.get(hostname)!= null && vnisByHostname.get(hostname).size() == 0) {
+ //safe to delete lisp
+ deleteLispStatesFromHost(hostname);
+ if (!deleteNativeForwardPathsTables(hostname)) {
+ LOG.warn("Failed to delete native forward paths tables from host: {}", hostname);
+ }
+ vnisByHostname.remove(hostname);
+
+ }
+ } catch (LispConfigCommandFailedException e) {
+ LOG.warn("Lisp command execution failed: {}", e.getMessage());
+ }
+ });
}
- private void deleteEidFromEidTable(DataBroker vppDataBroker,
- LispState lispState,
- Eid eid) throws LispConfigCommandFailedException {
- String mappingId = lispState.getEidMapping(eid);
+
+
+ private boolean deleteEidFromLocalEidTableOfHost(String hostName, Eid eid, String eidMappingName)
+ throws LispConfigCommandFailedException {
long value = eid.getVirtualNetworkId().getValue();
AbstractLispCommand<LocalMapping> deleteLocalMappingCommand = LispCommandWrapper
- .deleteLocalMappingFromEidTable(mappingId, value);
+ .deleteLocalMappingFromEidTable(eidMappingName, value);
- if (LispStateCommandExecutor.executeDeleteCommand(vppDataBroker, deleteLocalMappingCommand)) {
- lispState.deleteEid(eid);
- } else {
- throw new LispConfigCommandFailedException("Lisp delete local mapping command failed!");
+ return (LispStateCommandExecutor.executeDeleteCommand(hostName, deleteLocalMappingCommand));
+ }
+
+
+ private void deleteLispStatesFromHost(String hostname) throws LispConfigCommandFailedException {
+ //Todo workaround to delete only inside data not whole lisp-feature-data at once
+ // (causes VPP to crash https://jira.fd.io/browse/HC2VPP-242) remove when fixed
+ InstanceIdentifier<Node> nodeIid = LispUtil.hostnameToIid(hostname);
+ Optional<Lisp> lispOptional =
+ GbpNetconfTransaction.read(nodeIid, LogicalDatastoreType.CONFIGURATION,
+ InstanceIdentifier.create(Lisp.class), GbpNetconfTransaction.RETRY_COUNT);
+ if (lispOptional.isPresent()) {
+ LispFeatureData lispFeatureData = lispOptional.get().getLispFeatureData();
+
+ if (lispFeatureData == null || nodeIid == null) {
+ return;
+ }
+ LOG.trace("Removing all Eids from host: {}", hostname);
+ if (lispFeatureData.getEidTable() != null && lispFeatureData.getEidTable().getVniTable() != null) {
+
+ lispFeatureData.getEidTable().getVniTable().forEach(vniTable -> {
+ if (vniTable.getVrfSubtable() != null && vniTable.getVrfSubtable().getLocalMappings() != null
+ && vniTable.getVrfSubtable().getLocalMappings().getLocalMapping() != null)
+ //remove all mapping from vni table
+ vniTable.getVrfSubtable().getLocalMappings().getLocalMapping().forEach(localMapping -> {
+ GbpNetconfTransaction.netconfSyncedDelete(nodeIid,
+ InstanceIdentifier.builder(Lisp.class)
+ .child(LispFeatureData.class)
+ .child(EidTable.class)
+ .child(VniTable.class, vniTable.getKey())
+ .child(VrfSubtable.class)
+ .child(LocalMappings.class)
+ .child(LocalMapping.class, localMapping.getKey())
+ .build(),
+ GbpNetconfTransaction.RETRY_COUNT);
+ });
+ //remove EID VNI table
+ GbpNetconfTransaction.netconfSyncedDelete(nodeIid, InstanceIdentifier.builder(Lisp.class)
+ .child(LispFeatureData.class)
+ .child(EidTable.class)
+ .child(VniTable.class, vniTable.getKey())
+ .build(), GbpNetconfTransaction.RETRY_COUNT);
+ });
+ //remove EID table
+ GbpNetconfTransaction.netconfSyncedDelete(nodeIid,
+ InstanceIdentifier.builder(Lisp.class).child(LispFeatureData.class).child(EidTable.class).build(),
+ GbpNetconfTransaction.RETRY_COUNT);
+
+ }
+ LOG.trace("Removing ItrRemoteLocatorSet from host: {}", hostname);
+ if (lispFeatureData.getItrRemoteLocatorSet() != null) {
+ GbpNetconfTransaction.netconfSyncedDelete(nodeIid, InstanceIdentifier.builder(Lisp.class)
+ .child(LispFeatureData.class)
+ .child(ItrRemoteLocatorSet.class)
+ .build(), GbpNetconfTransaction.RETRY_COUNT);
+ }
+ LOG.trace("Removing all locators from host: {}", hostname);
+ if (lispFeatureData.getLocatorSets() != null) {
+
+ List<LocatorSet> locatorSetList = lispFeatureData.getLocatorSets().getLocatorSet();
+ if (locatorSetList == null || locatorSetList.isEmpty()) {
+ return;
+ }
+
+ for (LocatorSet locatorSet : locatorSetList) {
+ GbpNetconfTransaction.netconfSyncedDelete(nodeIid, InstanceIdentifier.builder(Lisp.class)
+ .child(LispFeatureData.class)
+ .child(LocatorSets.class)
+ .child(LocatorSet.class, locatorSet.getKey())
+ .build(), GbpNetconfTransaction.RETRY_COUNT);
+ }
+
+ }
+ LOG.trace("Removing MapResolvers from host: {}", hostname);
+ if (lispFeatureData.getMapResolvers() != null) {
+ GbpNetconfTransaction.netconfSyncedDelete(nodeIid, InstanceIdentifier.builder(Lisp.class)
+ .child(LispFeatureData.class)
+ .child(MapResolvers.class)
+ .build(), GbpNetconfTransaction.RETRY_COUNT);
+ }
+ LOG.trace("Removing MapServers from host: {}", hostname);
+ if (lispFeatureData.getMapServers() != null) {
+ GbpNetconfTransaction.netconfSyncedDelete(nodeIid, InstanceIdentifier.builder(Lisp.class)
+ .child(LispFeatureData.class)
+ .child(MapServers.class)
+ .build(), GbpNetconfTransaction.RETRY_COUNT);
+ }
+ LOG.trace("Removing MapServers from host: {}", hostname);
+ if (lispFeatureData.getMapRegister() != null) {
+ GbpNetconfTransaction.netconfSyncedDelete(nodeIid, InstanceIdentifier.builder(Lisp.class)
+ .child(LispFeatureData.class)
+ .child(MapRegister.class)
+ .build(), GbpNetconfTransaction.RETRY_COUNT);
+ }
+
+ LOG.trace("Removing all locators from host: {}", hostname);
+
+ cleanLisp(hostname);
}
+
+ }
+
+ private boolean deleteNativeForwardPathsTables(String hostname)
+ throws LispConfigCommandFailedException {
+ AbstractLispCommand<NativeForwardPathsTables> deleteNativeForwardPathsTables = LispCommandWrapper
+ .deleteNativeForwardPathsTables();
+
+ return LispStateCommandExecutor.executeDeleteCommand(hostname, deleteNativeForwardPathsTables);
}
private long getVni(String tenantUuid) {
return neutronTenantToVniMapper.getVni(tenantUuid);
}
+
+ private static void cleanLisp(String hostName)
+ throws LispConfigCommandFailedException {
+ if (LispStateCommandExecutor.executeDeleteCommand(hostName, LispCommandWrapper.deleteLispFeatureData())) {
+ LOG.debug("Deleted all lisp data for host {}",hostName);
+ } else {
+ throw new LispConfigCommandFailedException("Lisp delete feature data command failed!");
+ }
+ }
}
Code Review / groupbasedpolicy.git / blobdiff