From: Shakib Ahmed Date: Fri, 14 Jul 2017 18:52:57 +0000 (-0700) Subject: Simplify overlay information mappers and managers X-Git-Tag: release/nitrogen~16^2 X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=commitdiff_plain;h=4f9b8b6e3372a05b4a88af35f01799382cedc1a0;p=groupbasedpolicy.git Simplify overlay information mappers and managers Change-Id: I4be03130fbacee642efb4281fa5e6ed681c1af70 Signed-off-by: Shakib Ahmed --- diff --git a/renderers/vpp/src/main/java/org/opendaylight/controller/config/yang/config/vpp_provider/impl/VppRenderer.java b/renderers/vpp/src/main/java/org/opendaylight/controller/config/yang/config/vpp_provider/impl/VppRenderer.java index 4926fcfc2..ecb78abbe 100644 --- a/renderers/vpp/src/main/java/org/opendaylight/controller/config/yang/config/vpp_provider/impl/VppRenderer.java +++ b/renderers/vpp/src/main/java/org/opendaylight/controller/config/yang/config/vpp_provider/impl/VppRenderer.java @@ -143,12 +143,13 @@ public class VppRenderer implements AutoCloseable, BindingAwareProvider { EventBus dtoEventBus = new EventBus((exception, context) -> LOG.error("Could not dispatch event: {} to {}", context.getSubscriber(), context.getSubscriberMethod(), exception)); - interfaceManager = new InterfaceManager(mountDataProvider, dataBroker); - AclManager aclManager = new AclManager(mountDataProvider); - NatManager natManager = new NatManager(dataBroker, mountDataProvider); LispStateManager lispStateManager = new LispStateManager(mountDataProvider); FlatOverlayManager flatOverlayManager = new FlatOverlayManager(dataBroker, mountDataProvider); LoopbackManager loopbackManager = new LoopbackManager(mountDataProvider); + + interfaceManager = new InterfaceManager(mountDataProvider, dataBroker, flatOverlayManager); + AclManager aclManager = new AclManager(mountDataProvider); + NatManager natManager = new NatManager(dataBroker, mountDataProvider); subnetEventManager = new GbpSubnetEventManager(loopbackManager); dtoEventBus.register(interfaceManager); dtoEventBus.register(subnetEventManager); diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/iface/InterfaceManager.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/iface/InterfaceManager.java index 5e3ae920e..810ec51ef 100644 --- a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/iface/InterfaceManager.java +++ b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/iface/InterfaceManager.java @@ -32,6 +32,7 @@ import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.VhostUserCommand. import org.opendaylight.groupbasedpolicy.renderer.vpp.config.ConfigUtil; import org.opendaylight.groupbasedpolicy.renderer.vpp.event.NodeOperEvent; import org.opendaylight.groupbasedpolicy.renderer.vpp.event.VppEndpointConfEvent; +import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.flat.overlay.FlatOverlayManager; import org.opendaylight.groupbasedpolicy.renderer.vpp.policy.acl.AccessListWrapper; import org.opendaylight.groupbasedpolicy.renderer.vpp.util.GbpNetconfTransaction; import org.opendaylight.groupbasedpolicy.renderer.vpp.util.General.Operations; @@ -77,10 +78,13 @@ public class InterfaceManager implements AutoCloseable { private final MountedDataBrokerProvider mountDataProvider; private final VppEndpointLocationProvider vppEndpointLocationProvider; private final SetMultimap excludedFromPolicy = HashMultimap.create(); + private final FlatOverlayManager flatOverlayManager; - public InterfaceManager(@Nonnull MountedDataBrokerProvider mountDataProvider, @Nonnull DataBroker dataProvider) { + public InterfaceManager(@Nonnull MountedDataBrokerProvider mountDataProvider, @Nonnull DataBroker dataProvider, + FlatOverlayManager flatOverlayManager) { this.mountDataProvider = Preconditions.checkNotNull(mountDataProvider); this.vppEndpointLocationProvider = new VppEndpointLocationProvider(dataProvider); + this.flatOverlayManager = flatOverlayManager; } @Subscribe @@ -261,6 +265,7 @@ public class InterfaceManager implements AutoCloseable { } } + if (!potentialIfaceCommand.isPresent()) { LOG.debug("Interface/DELETE command was not created for VppEndpoint point {}", vppEndpoint); return Futures.immediateFuture(null); @@ -274,6 +279,11 @@ public class InterfaceManager implements AutoCloseable { return Futures.immediateFailedFuture(new VppRendererProcessingException(message)); } DataBroker vppDataBroker = potentialVppDataProvider.get(); + + if (ConfigUtil.getInstance().isL3FlatEnabled()) { + flatOverlayManager.handleInterfaceDeleteForFlatOverlay(vppDataBroker, vppEndpoint); + } + return deleteIfaceOnVpp(ifaceWithoutBdCommand, vppDataBroker, vppEndpoint, vppNodeIid); } diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/InterfaceInfo.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/InterfaceInfo.java deleted file mode 100644 index 291a02186..000000000 --- a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/InterfaceInfo.java +++ /dev/null @@ -1,31 +0,0 @@ -/* - * Copyright (c) 2017 Cisco Systems. All rights reserved. - * - * This program and the accompanying materials are made available under the - * terms of the Eclipse Public License v1.0 which accompanies this distribution, - * and is available at http://www.eclipse.org/legal/epl-v10.html - */ -package org.opendaylight.groupbasedpolicy.renderer.vpp.lisp; - -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress; - -/** - * Created by Shakib Ahmed on 6/23/17. - */ -public class InterfaceInfo { - private String interfaceName; - private IpAddress interfaceIp; - - public InterfaceInfo(String interfaceName, IpAddress interfaceIp) { - this.interfaceName = interfaceName; - this.interfaceIp = interfaceIp; - } - - public String getInterfaceName() { - return interfaceName; - } - - public IpAddress getInterfaceIp() { - return interfaceIp; - } -} diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/LispStateManager.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/LispStateManager.java index c6090e60e..4277bd024 100644 --- a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/LispStateManager.java +++ b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/LispStateManager.java @@ -15,8 +15,12 @@ import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.lisp.LispCommandW 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.info.container.EndpointHost; +import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.HostRelatedInfoContainer; +import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.states.LispState; import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.mappers.NeutronTenantToVniMapper; import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.util.ConfigManagerHelper; +import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.util.Constants; import org.opendaylight.groupbasedpolicy.renderer.vpp.util.General; import org.opendaylight.groupbasedpolicy.renderer.vpp.util.MountedDataBrokerProvider; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress; @@ -35,7 +39,6 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; import javax.annotation.Nonnull; -import java.util.HashMap; import java.util.concurrent.ExecutionException; /** @@ -44,7 +47,7 @@ import java.util.concurrent.ExecutionException; public class LispStateManager { private static final Logger LOG = LoggerFactory.getLogger(LispStateManager.class); - private HashMap lispStateMapper; + private HostRelatedInfoContainer hostRelatedInfoContainer; private MountedDataBrokerProvider mountedDataBrokerProvider; private ConfigManagerHelper lispStateHelper; @@ -54,125 +57,124 @@ public class LispStateManager { 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 static final String DEFAULT_MAPPINGRECORD_NAME_PREFIX = "MR_"; public LispStateManager(@Nonnull MountedDataBrokerProvider mountedDataBrokerProvider) { Preconditions.checkNotNull(mountedDataBrokerProvider, "MountedDataBrokerProvider found to be null!"); - lispStateMapper = new HashMap<>(); + hostRelatedInfoContainer = HostRelatedInfoContainer.getInstance(); this.mountedDataBrokerProvider= mountedDataBrokerProvider; this.lispStateHelper = new ConfigManagerHelper(this.mountedDataBrokerProvider); neutronTenantToVniMapper = NeutronTenantToVniMapper.getInstance(); } - public synchronized void configureEndPoint(AddressEndpointWithLocation addressEp) { + public synchronized void processCreateEndPoint(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); + EndpointHost endpointHost = lispStateHelper.getEndpointHostInformation(addressEp); + LispState lispStateOfHost = configureHostIfNeeded(endpointHost); long vni = getVni(addressEp.getTenant().getValue()); long vrf = vni; - addVniToVrfMappingIfNeeded(dataBroker, lispStateOfNode, vni, vrf); Eid eid = lispStateHelper.getEid(addressEp, vni); + String eidMappingName = lispStateHelper.constructEidMappingName(addressEp); - if(!lispStateOfNode.eidSetContains(eid)) { - addEidInEidTable(dataBroker, lispStateOfNode, eid); + addVniToVrfMappingIfNeeded(endpointHost.getHostDataBroker(), lispStateOfHost, vni, vrf); + + if (lispStateHelper.getInterfaceIp(addressEp).getValue().equals(Constants.METADATA_IP)) { + return; } + addEidOnHostIfNeeded(endpointHost, lispStateOfHost, eid, eidMappingName); } 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 void addEidOnHostIfNeeded(EndpointHost endpointHost, LispState lispStateOfNode, Eid eid, + String eidMappingName) + throws LispConfigCommandFailedException { + if(!lispStateOfNode.eidSetContains(eid)) { + addEidInEidTable(endpointHost.getHostDataBroker(), lispStateOfNode, eid, eidMappingName); + } + } - if (lispStateOfNode == null) { - lispStateOfNode = new LispState(hostName); - try { - enableLispForNode(vppDataBroker, lispStateOfNode); + private synchronized LispState configureHostIfNeeded(EndpointHost endpointHost) + throws LispConfigCommandFailedException { + LispState lispStateOfHost = hostRelatedInfoContainer.getLispStateOfHost(endpointHost.getHostName()); - if (ConfigUtil.getInstance().isL3FlatEnabled()) { - enableGpeForNode(vppDataBroker, lispStateOfNode); - } + if (lispStateOfHost == null) { + LOG.debug("Configuring host {} for LISP", endpointHost.getHostName()); + lispStateOfHost = new LispState(); + try { + enableLispOnHost(endpointHost, lispStateOfHost); + enableGpeOnHostIfNeeded(endpointHost, lispStateOfHost); + addLocatorSetOnHost(endpointHost, lispStateOfHost); + addMapResolverOnHost(endpointHost, lispStateOfHost); + enableMapRegistrationOnHostIfNeeded(endpointHost, lispStateOfHost); - addLocatorSet(vppDataBroker, lispStateOfNode); - addMapResolver(vppDataBroker, lispStateOfNode); - if (ConfigUtil.getInstance().isLispMapRegisterEnabled()) { - enableMapRegister(vppDataBroker, lispStateOfNode); - addMapServer(vppDataBroker, lispStateOfNode); - } - lispStateMapper.put(hostName, lispStateOfNode); + hostRelatedInfoContainer.setLispStateOfHost(endpointHost.getHostName(), lispStateOfHost); } catch (LispNotFoundException e) { LOG.warn("Lisp host configuration failed: ", e.getMessage()); throw new LispConfigCommandFailedException("Failed LISP configuration!"); } } - return lispStateOfNode; + return lispStateOfHost; } - 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 void enableGpeOnHostIfNeeded(EndpointHost endpointHost, LispState lispStateOfHost) + throws LispConfigCommandFailedException { + if (ConfigUtil.getInstance().isL3FlatEnabled()) { + enableGpeForHost(endpointHost, lispStateOfHost); + } + } - if (lispState.eidCount() == 0) { - deleteLispStatesInEndPoints(vppDataBroker, lispState); - } - } - } catch (LispConfigCommandFailedException e) { - LOG.warn("Lisp command execution failed: {}", e.getMessage()); + private void enableMapRegistrationOnHostIfNeeded(EndpointHost endpointHost, LispState lispStateOfHost) + throws LispConfigCommandFailedException { + if (ConfigUtil.getInstance().isLispMapRegisterEnabled()) { + enableMapRegister(endpointHost); + addMapServer(endpointHost, lispStateOfHost); } } - private void enableLispForNode(DataBroker vppDataBroker, LispState lispState) throws LispConfigCommandFailedException { + private void enableLispOnHost(EndpointHost endpointHost, LispState lispState) + throws LispConfigCommandFailedException { AbstractLispCommand lispEnableCommand = LispCommandWrapper.enableLisp(); - if (LispStateCommandExecutor.executePutCommand(vppDataBroker, lispEnableCommand)) { + if (LispStateCommandExecutor.executePutCommand(endpointHost.getHostDataBroker(), lispEnableCommand)) { lispState.setLispEnabled(true); } else { throw new LispConfigCommandFailedException("Lisp Enable Command failed execution!"); } } - private void enableGpeForNode(DataBroker vppDataBroker, LispState lispState) throws LispConfigCommandFailedException { + private void enableGpeForHost(EndpointHost endpointHost, LispState lispState) + throws LispConfigCommandFailedException { AbstractLispCommand gpeEnableCommand = LispCommandWrapper.enableGpe(); - if (LispStateCommandExecutor.executePutCommand(vppDataBroker, gpeEnableCommand)) { + if (LispStateCommandExecutor.executePutCommand(endpointHost.getHostDataBroker(), gpeEnableCommand)) { lispState.setGpeEnabled(true); } else { throw new LispConfigCommandFailedException("GPE Enable Command failed execution!"); } } - private void addLocatorSet(DataBroker vppDataBroker, LispState lispState) throws LispNotFoundException, LispConfigCommandFailedException { + private void addLocatorSetOnHost(EndpointHost endpointHost, LispState lispState) + throws LispNotFoundException, LispConfigCommandFailedException { try { String locatorSetName = lispStateHelper.constructLocatorSetName(lispState.getLocatorCount()); - String interfaceName = lispStateHelper.readRlocInterface(lispState.getHostName(), vppDataBroker).get(); + String interfaceName = lispStateHelper + .readRlocInterface(endpointHost.getHostName(), endpointHost.getHostDataBroker()).get(); AbstractLispCommand addLocatorSetCommand = LispCommandWrapper.addLocatorSet(locatorSetName, interfaceName, DEFAULT_PRIORITY, DEFAULT_WEIGHT); - if (LispStateCommandExecutor.executePutCommand(vppDataBroker, addLocatorSetCommand)) { + if (LispStateCommandExecutor.executePutCommand(endpointHost.getHostDataBroker(), addLocatorSetCommand)) { lispState.setLocIntfToLocSetNameMapping(interfaceName, locatorSetName); } else { throw new LispConfigCommandFailedException("Lisp add locator set failed for host " - + lispState.getHostName() + " and locator interface " + interfaceName); + + endpointHost.getHostName() + " and locator interface " + interfaceName); } } catch (InterruptedException | ExecutionException e) { throw new LispNotFoundException("No interface with Ip Address found!"); @@ -180,49 +182,50 @@ public class LispStateManager { } - private void addMapResolver(DataBroker vppDataBroker, LispState lispState) throws LispConfigCommandFailedException { + private void addMapResolverOnHost(EndpointHost endpointHost, LispState lispState) + throws LispConfigCommandFailedException { IpAddress mapResolverIpAddress = ConfigUtil.getInstance().getOdlTenantIp(); Preconditions.checkNotNull(mapResolverIpAddress, "Map Resolver ip not properly configured!"); AbstractLispCommand addMapResolverCommand = LispCommandWrapper. addMapResolver(mapResolverIpAddress); - if (LispStateCommandExecutor.executePutCommand(vppDataBroker, addMapResolverCommand)) { + if (LispStateCommandExecutor.executePutCommand(endpointHost.getHostDataBroker(), addMapResolverCommand)) { lispState.addInMapResolverSet(mapResolverIpAddress); } else { - throw new LispConfigCommandFailedException("Lisp add map resolver for host " + lispState.getHostName() + throw new LispConfigCommandFailedException("Lisp add map resolver for host " + endpointHost.getHostName() + " failed for ODL ip " + mapResolverIpAddress); } } - private void addMapServer(DataBroker vppDataBroker, LispState lispState) throws LispConfigCommandFailedException { - IpAddress mapServerIpAddress = ConfigUtil.getInstance().getOdlTenantIp(); - Preconditions.checkNotNull(mapServerIpAddress, "Mapserver ip not properly configured!"); - AbstractLispCommand addMapServerCommand = LispCommandWrapper.addMapServer(mapServerIpAddress); + private void enableMapRegister(EndpointHost endpointHost) + throws LispConfigCommandFailedException { + AbstractLispCommand enableMapRegisterCommand = LispCommandWrapper.enableMapRegister(); - if (LispStateCommandExecutor.executePutCommand(vppDataBroker, addMapServerCommand)) { - lispState.addInMapServerSet(mapServerIpAddress); + if (LispStateCommandExecutor.executePutCommand(endpointHost.getHostDataBroker(), enableMapRegisterCommand)) { } else { - throw new LispConfigCommandFailedException("Lisp add map server for host " + lispState.getHostName() - + " failed for ODL ip " + mapServerIpAddress); + throw new LispConfigCommandFailedException("Lisp enable mapregistration for host " + + endpointHost.getHostName() + " failed!"); } + } - private void enableMapRegister(DataBroker vppDataBroker, LispState lispState) throws LispConfigCommandFailedException { - AbstractLispCommand enableMapRegisterCommand = LispCommandWrapper.enableMapRegister(); + private void addMapServer(EndpointHost endpointHost, LispState lispState) throws LispConfigCommandFailedException { + IpAddress mapServerIpAddress = ConfigUtil.getInstance().getOdlTenantIp(); + Preconditions.checkNotNull(mapServerIpAddress, "Mapserver ip not properly configured!"); + AbstractLispCommand addMapServerCommand = LispCommandWrapper.addMapServer(mapServerIpAddress); - if (LispStateCommandExecutor.executePutCommand(vppDataBroker, enableMapRegisterCommand)) { - lispState.setMapRegisteredEnabled(true); + if (LispStateCommandExecutor.executePutCommand(endpointHost.getHostDataBroker(), addMapServerCommand)) { + lispState.addInMapServerSet(mapServerIpAddress); } else { - throw new LispConfigCommandFailedException("Lisp enable mapregistration for host " - + lispState.getHostName() + " failed!"); + throw new LispConfigCommandFailedException("Lisp add map server for host " + endpointHost.getHostName() + + " failed for ODL ip " + mapServerIpAddress); } - } private void addVniToVrfMappingIfNeeded(DataBroker vppDataBroker, LispState lispState, long vni, long vrf) throws LispConfigCommandFailedException { - if (!lispState.vniSetContains(vni)) { + if (!lispState.isVniConfigured(vni)) { AbstractLispCommand addVniToVrfMapping = LispCommandWrapper.mapVniToVrf(vni, vrf); addVniToVrfMapping.setOptions(General.Operations.PUT); if (LispStateCommandExecutor.executePutCommand(vppDataBroker, addVniToVrfMapping)) { @@ -236,48 +239,85 @@ public class LispStateManager { private void addEidInEidTable(DataBroker vppDataBroker, LispState lispState, - Eid eid) throws LispConfigCommandFailedException { - String mappingId = lispStateHelper.constructMappingName(lispState.getInterfaceId()); + Eid eid, + String eidMappingName) throws LispConfigCommandFailedException { AbstractLispCommand addLocalMappingInEidTableCommand = LispCommandWrapper - .addLocalMappingInEidTable(mappingId, + .addLocalMappingInEidTable(eidMappingName, eid, lispStateHelper.getFirstLocatorSetName(lispState), lispStateHelper.getDefaultHmacKey()); if (LispStateCommandExecutor.executePutCommand(vppDataBroker, addLocalMappingInEidTableCommand)) { - lispState.addInEidSet(eid, mappingId); + lispState.addEidInEidSet(eid); } else { throw new LispConfigCommandFailedException("Lisp add local mapping for eid " + eid + "failed!"); } } - private void deleteLispStatesInEndPoints(DataBroker vppDataBroker, - LispState lispState) throws LispConfigCommandFailedException { - AbstractLispCommand deleteLispFeatureData = LispCommandWrapper.deleteLispFeatureData(); + public synchronized void processDeleteEndpoint(AddressEndpointWithLocation addressEp) { + try { - if (LispStateCommandExecutor.executeDeleteCommand(vppDataBroker, deleteLispFeatureData)) { - String computeNode = lispState.getHostName(); - lispStateMapper.remove(computeNode); - } else { - throw new LispConfigCommandFailedException("Lisp delete feature data command failed!"); + if (lispStateHelper.isMetadataPort(addressEp)) { + return; + } + + EndpointHost endpointHost = lispStateHelper.getEndpointHostInformation(addressEp); + + LispState lispState = hostRelatedInfoContainer.getLispStateOfHost(endpointHost.getHostName()); + + 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); + String eidMappingName = lispStateHelper.constructEidMappingName(addressEp); + + deleteEidFromLocalEidTableOfHostIfNeeded(endpointHost, lispState, eid, eidMappingName); + + if (lispState.eidCount() == 0) { + deleteLispStatesFromHost(endpointHost); + } + } + } catch (LispConfigCommandFailedException e) { + LOG.warn("Lisp command execution failed: {}", e.getMessage()); + } + } + + private void deleteEidFromLocalEidTableOfHostIfNeeded(EndpointHost endpointHost, LispState lispState, Eid eid, String eidMappingName) throws LispConfigCommandFailedException { + if (lispState.eidSetContains(eid)) { + deleteEidFromLocalEidTableOfHost(endpointHost, lispState, eid, eidMappingName); } } - private void deleteEidFromEidTable(DataBroker vppDataBroker, + private void deleteEidFromLocalEidTableOfHost(EndpointHost endpointHost, LispState lispState, - Eid eid) throws LispConfigCommandFailedException { - String mappingId = lispState.getEidMapping(eid); + Eid eid, + String eidMappingName) throws LispConfigCommandFailedException { long value = eid.getVirtualNetworkId().getValue(); AbstractLispCommand deleteLocalMappingCommand = LispCommandWrapper - .deleteLocalMappingFromEidTable(mappingId, value); + .deleteLocalMappingFromEidTable(eidMappingName, value); - if (LispStateCommandExecutor.executeDeleteCommand(vppDataBroker, deleteLocalMappingCommand)) { + if (LispStateCommandExecutor + .executeDeleteCommand(endpointHost.getHostDataBroker(), deleteLocalMappingCommand)) { + LOG.debug("Successfully deleted eid {} from host {}", eid, endpointHost.getHostName()); lispState.deleteEid(eid); } else { throw new LispConfigCommandFailedException("Lisp delete local mapping command failed!"); } } + + private void deleteLispStatesFromHost(EndpointHost endpointHost) throws LispConfigCommandFailedException { + AbstractLispCommand deleteLispFeatureData = LispCommandWrapper.deleteLispFeatureData(); + + if (LispStateCommandExecutor.executeDeleteCommand(endpointHost.getHostDataBroker(), deleteLispFeatureData)) { + hostRelatedInfoContainer.deleteLispStateOfHost(endpointHost.getHostName()); + LOG.debug("Deleted all lisp data for host {}", endpointHost.getHostName()); + } else { + throw new LispConfigCommandFailedException("Lisp delete feature data command failed!"); + } + } + private long getVni(String tenantUuid) { return neutronTenantToVniMapper.getVni(tenantUuid); } diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/event/manager/GbpSubnetEventManager.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/event/manager/GbpSubnetEventManager.java index a4c438ec5..5169bcf1b 100644 --- a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/event/manager/GbpSubnetEventManager.java +++ b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/event/manager/GbpSubnetEventManager.java @@ -65,6 +65,5 @@ public class GbpSubnetEventManager { private void processSubnetDeleted(String subnetUuid) { subnetUuidToGbpSubnetInfoMapper.removeSubnetInfo(subnetUuid); - loopbackManager.deleteLoopbackIfExists(subnetUuid); } } diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/flat/overlay/FlatOverlayManager.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/flat/overlay/FlatOverlayManager.java index 24c6d8bed..352befd4b 100644 --- a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/flat/overlay/FlatOverlayManager.java +++ b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/flat/overlay/FlatOverlayManager.java @@ -14,11 +14,16 @@ import com.google.common.base.Preconditions; import org.opendaylight.controller.md.sal.binding.api.DataBroker; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.StaticArpCommand; -import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.mappers.HostIdToMetadataInterfaceMapper; -import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.mappers.HostVrfRoutingInformationMapper; -import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.mappers.InterfaceNameToStaticInfoMapper; +import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.EndpointHost; +import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.HostRelatedInfoContainer; +import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.states.PortInterfaces; +import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.states.PortRouteState; +import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.states.SubnetState; +import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.states.VrfHolder; +import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.states.VrfState; import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.mappers.NeutronTenantToVniMapper; import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.util.ConfigManagerHelper; +import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.util.Constants; import org.opendaylight.groupbasedpolicy.renderer.vpp.util.GbpNetconfTransaction; import org.opendaylight.groupbasedpolicy.renderer.vpp.util.General; import org.opendaylight.groupbasedpolicy.renderer.vpp.util.MountedDataBrokerProvider; @@ -51,23 +56,19 @@ public class FlatOverlayManager { private DataBroker dataBroker; private NeutronTenantToVniMapper neutronTenantToVniMapper = NeutronTenantToVniMapper.getInstance(); - private HostVrfRoutingInformationMapper hostVrfInfo = HostVrfRoutingInformationMapper.getInstance(); - private HostIdToMetadataInterfaceMapper - hostIdToMetadataInterfaceMapper = HostIdToMetadataInterfaceMapper.getInstance(); - - private InterfaceNameToStaticInfoMapper interfaceNameToStaticInfoMapper; + private HostRelatedInfoContainer hostRelatedInfoContainer = HostRelatedInfoContainer.getInstance(); private StaticRoutingHelper staticRoutingHelper; - public FlatOverlayManager(@Nonnull DataBroker dataBroker, @Nonnull MountedDataBrokerProvider mountedDataBrokerProvider) { + public FlatOverlayManager(@Nonnull DataBroker dataBroker, + @Nonnull MountedDataBrokerProvider mountedDataBrokerProvider) { this.overlayHelper = new ConfigManagerHelper(mountedDataBrokerProvider); - this.interfaceNameToStaticInfoMapper = InterfaceNameToStaticInfoMapper.getInstance(); - staticRoutingHelper = new StaticRoutingHelper(interfaceNameToStaticInfoMapper); + staticRoutingHelper = new StaticRoutingHelper(); this.dataBroker = dataBroker; } public void configureEndpointForFlatOverlay(AddressEndpointWithLocation addressEp) { - if (!overlayHelper.isMetadataPort(addressEp)) { + if (!overlayHelper.hasRelativeLocations(addressEp)) { configureInterfaceForFlatOverlay(addressEp); addStaticArp(addressEp); addStaticRoute(addressEp); @@ -80,13 +81,18 @@ public class FlatOverlayManager { long vrf = getVni(addressEp.getTenant().getValue()); - if (!hostIdToMetadataInterfaceMapper.isMetadataInterfaceConfigured(hostName, metadataInterfaceName)) { + String metadataSubnetUuid = Constants.METADATA_SUBNET_UUID; + + PortInterfaces portInterfacesOfHost = hostRelatedInfoContainer.getPortInterfaceStateOfHost(hostName); + + if (!portInterfacesOfHost.isInterfaceConfiguredForMetadata(metadataInterfaceName)) { DataBroker vppDataBroker = overlayHelper.getPotentialExternalDataBroker(externalLocation).get(); - addInterfaceInVrf(vppDataBroker, metadataInterfaceName, vrf); + addInterfaceInVrf(new EndpointHost(vppDataBroker, hostName), metadataInterfaceName, vrf); String physicalAddress = resolvePhysicalAddress(hostName, metadataInterfaceName); addStaticArp(vppDataBroker, hostName, metadataInterfaceName, physicalAddress, metadataIp); - addStaticRoute(vppDataBroker, hostName, vrf, metadataIp, metadataIpPrefix, metadataInterfaceName); - hostIdToMetadataInterfaceMapper.addMetadataInterfaceInHost(hostName, metadataInterfaceName); + addStaticRoute(vppDataBroker, hostName, vrf, metadataSubnetUuid, metadataIp, + metadataIpPrefix, metadataInterfaceName); + portInterfacesOfHost.addInterfaceInMetadataInterfaceSet(metadataInterfaceName); } }); } @@ -118,28 +124,51 @@ public class FlatOverlayManager { } public void handleEndpointDeleteForFlatOverlay(AddressEndpointWithLocation addressEp) { + if (overlayHelper.hasRelativeLocations(addressEp)) { + // okay to ignore + // routes will be deleted on interface delete + return; + } deleteStaticRoute(addressEp); } + public void handleInterfaceDeleteForFlatOverlay(DataBroker vppDataBroker, VppEndpoint vppEndpoint) { + String hostName = vppEndpoint.getVppNodeId().getValue(); + String interfaceName = vppEndpoint.getVppInterfaceName(); + + staticRoutingHelper.deleteAllRoutesThroughInterface(vppDataBroker, hostName, interfaceName); + + PortInterfaces portInterfaces = hostRelatedInfoContainer.getPortInterfaceStateOfHost(hostName); + portInterfaces.removePortInterface(interfaceName); + } + private void configureInterfaceForFlatOverlay(AddressEndpointWithLocation addressEp) { addInterfaceInVrf(addressEp); } private void addInterfaceInVrf(AddressEndpointWithLocation addressEp) { - DataBroker vppDataBroker = overlayHelper.getPotentialExternalDataBroker(addressEp).get(); + EndpointHost endpointHost = overlayHelper.getEndpointHostInformation(addressEp); long vni = getVni(addressEp.getTenant().getValue()); long vrf = vni; Optional interfaceNameOptional = overlayHelper.getInterfaceName(addressEp); Preconditions.checkArgument(interfaceNameOptional.isPresent()); - addInterfaceInVrf(vppDataBroker, interfaceNameOptional.get(), vrf); + addInterfaceInVrf(endpointHost, interfaceNameOptional.get(), vrf); } - private void addInterfaceInVrf(DataBroker vppDataBroker, String interfaceName, long vrf) { - if (!putVrfInInterface(vppDataBroker, interfaceName, vrf)) { + private void addInterfaceInVrf(EndpointHost endpointHost, String interfaceName, long vrf) { + if (hostRelatedInfoContainer.getPortInterfaceStateOfHost(endpointHost.getHostName()) + .isVrfConfiguredForInterface(interfaceName)) { + return; + } + + if (!putVrfInInterface(endpointHost.getHostDataBroker(), interfaceName, vrf)) { LOG.warn("Failed to put interface {} to vrf {}", interfaceName, vrf); } else { + hostRelatedInfoContainer + .getPortInterfaceStateOfHost(endpointHost.getHostName()) + .initializeRoutingContextForInterface(interfaceName, vrf); LOG.debug("Added interface {} to vrf {}", interfaceName, vrf); } } @@ -207,42 +236,46 @@ public class FlatOverlayManager { long vni = getVni(addressEp.getTenant().getValue()); long vrf = vni; + String portSubnetUuid = overlayHelper.getSubnet(addressEp); + String outgoingInterfaceName = overlayHelper.getInterfaceName(addressEp).get(); Ipv4Address ipWithoutPrefix = overlayHelper.getInterfaceIp(addressEp); + + if (overlayHelper.isMetadataPort(addressEp)) { + //override original port subnet to handle the Absolute location case of address endpoint + portSubnetUuid = Constants.METADATA_SUBNET_UUID; + } + Ipv4Prefix ipv4Prefix = overlayHelper.getInterfaceIpAsPrefix(addressEp); - addStaticRoute(vppDataBroker, hostName, vrf, ipWithoutPrefix, ipv4Prefix, outgoingInterfaceName); + addStaticRoute(vppDataBroker, hostName, vrf, portSubnetUuid, ipWithoutPrefix, ipv4Prefix, outgoingInterfaceName); } - private void addStaticRoute(DataBroker vppDataBroker, String hostName, long vrf, Ipv4Address ipWithoutPrefix, - Ipv4Prefix ipv4Prefix, String outgoingInterfaceName) { + private void addStaticRoute(DataBroker vppDataBroker, String hostName, long vrfId, String hostIpSubnetUuid, + Ipv4Address ipWithoutPrefix, Ipv4Prefix ipv4Prefix, String outgoingInterfaceName) { - if (!hostVrfInfo.vrfExists(hostName, vrf)) { - if (!staticRoutingHelper.addRoutingProtocolForVrf(vppDataBroker, hostName, vrf)) { - LOG.warn("Failed to add Routing protocol for host {} and vrf {}!", hostName, vrf); + VrfHolder vrfHolderOfHost = hostRelatedInfoContainer.getVrfStateOfHost(hostName); + + if (!vrfHolderOfHost.hasVrf(vrfId)) { + if (!staticRoutingHelper.addRoutingProtocolForVrf(vppDataBroker, vrfId, vrfHolderOfHost)) { + LOG.warn("Failed to add Routing protocol for host {} and vrf {}!", hostName, vrfId); } } - if (staticRoutingHelper.endPointRoutingExists(outgoingInterfaceName, ipWithoutPrefix)) { - return; - } + VrfState vrfStateOfVrfId = vrfHolderOfHost.getVrfState(vrfId); - if (staticRoutingHelper.routeAlreadyExistsInHostVrf(hostName, vrf, ipWithoutPrefix)) { - LOG.warn("Ip already exists in host {} vrf {} ip {}", hostName, vrf, ipWithoutPrefix); + if (vrfStateOfVrfId.getSubnetHolder().getSubnetState(hostIpSubnetUuid).isIpPresent(ipWithoutPrefix)) { + LOG.info("Ip already exists in host {} vrf {} ip {}", hostName, vrfId, ipWithoutPrefix); return; } - if (!staticRoutingHelper.addSingleStaticRouteInRoutingProtocol(vppDataBroker, - hostName, - vrf, - ipWithoutPrefix, - ipv4Prefix, - outgoingInterfaceName)) { + if (!staticRoutingHelper.addSingleStaticRouteInRoutingProtocol(vppDataBroker, hostName, vrfId, hostIpSubnetUuid, + ipWithoutPrefix, ipv4Prefix, outgoingInterfaceName)) { LOG.warn("Failed to add routing ({} via {}) in vrf {} in compute host {}!", - ipv4Prefix, outgoingInterfaceName, vrf, hostName); + ipv4Prefix, outgoingInterfaceName, vrfId, hostName); } else { LOG.debug("Added route ({} via {}) in vrf {} in compute host {}", - ipv4Prefix, outgoingInterfaceName, vrf, hostName); + ipv4Prefix, outgoingInterfaceName, vrfId, hostName); } } @@ -252,20 +285,47 @@ public class FlatOverlayManager { String interfaceName = overlayHelper.getInterfaceName(addressEp).get(); long vni = getVni(addressEp.getTenant().getValue()); - long vrf = vni; + long vrfId = vni; + + String ipSubnetUuid = overlayHelper.getSubnet(addressEp); + + if (overlayHelper.isMetadataPort(addressEp)) { + //override original port subnet to handle the Absolute location case of address endpoint + ipSubnetUuid = Constants.METADATA_SUBNET_UUID; + } Ipv4Address ipWithoutPrefix = overlayHelper.getInterfaceIp(addressEp); + PortRouteState portRouteState = hostRelatedInfoContainer + .getPortInterfaceStateOfHost(hostName) + .getPortRouteState(interfaceName); + + SubnetState subnetState = hostRelatedInfoContainer + .getVrfStateOfHost(hostName) + .getVrfState(vrfId) + .getSubnetHolder() + .getSubnetState(ipSubnetUuid); + + if (!subnetState.isIpPresent(ipWithoutPrefix)) { + LOG.debug("Route {} already deleted from vrf {} of host {}", ipWithoutPrefix, vrfId, hostName); + return; + } + + long targetRouteId = portRouteState.getRouteIdOfIp(ipWithoutPrefix); + if (!staticRoutingHelper.deleteSingleStaticRouteFromRoutingProtocol(vppDataBroker, - hostName, - vrf, - interfaceName)) { + hostName, + vrfId, + interfaceName, + targetRouteId)) { LOG.warn("Failed to delete route ({} via {}) from vrf {} from host{}", - ipWithoutPrefix, interfaceName, vrf, hostName); + ipWithoutPrefix, interfaceName, vrfId, hostName); } else { + portRouteState.removeIp(ipWithoutPrefix); + subnetState.removeIp(ipWithoutPrefix); LOG.debug("Delete Static Route ({} via {}) from vrf {} from host {}", - ipWithoutPrefix, interfaceName, vrf, hostName); + ipWithoutPrefix, interfaceName, vrfId, hostName); } } diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/flat/overlay/RoutingInfo.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/flat/overlay/RoutingInfo.java deleted file mode 100644 index 3ca680083..000000000 --- a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/flat/overlay/RoutingInfo.java +++ /dev/null @@ -1,51 +0,0 @@ -/* - * Copyright (c) 2017 Cisco Systems. All rights reserved. - * - * This program and the accompanying materials are made available under the - * terms of the Eclipse Public License v1.0 which accompanies this distribution, - * and is available at http://www.eclipse.org/legal/epl-v10.html - */ -package org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.flat.overlay; - -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address; - -import java.util.HashSet; -import java.util.Set; - -/** - * Created by Shakib Ahmed on 5/4/17. - */ -public class RoutingInfo { - private String ProtocolName; - private int count = 0; - private Set allIpsInVrf; - - public RoutingInfo() { - allIpsInVrf = new HashSet<>(); - } - - public String getProtocolName() { - return ProtocolName; - } - - public void setProtocolName(String protocolName) { - ProtocolName = protocolName; - } - - public int getCount() { - return count; - } - - public void addIpInVrf(Ipv4Address ip) { - allIpsInVrf.add(ip); - incrementCount(); - } - - public boolean ipAlreadyExistsinVrf(Ipv4Address ip) { - return allIpsInVrf.contains(ip); - } - - private void incrementCount() { - count++; - } -} diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/flat/overlay/StaticRoutingHelper.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/flat/overlay/StaticRoutingHelper.java index ca5d7b1b8..0af92ae45 100644 --- a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/flat/overlay/StaticRoutingHelper.java +++ b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/flat/overlay/StaticRoutingHelper.java @@ -7,9 +7,14 @@ */ package org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.flat.overlay; +import com.google.common.base.Preconditions; import org.opendaylight.controller.md.sal.binding.api.DataBroker; -import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.mappers.HostVrfRoutingInformationMapper; -import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.mappers.InterfaceNameToStaticInfoMapper; +import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.HostRelatedInfoContainer; +import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.states.PortInterfaces; +import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.states.PortRouteState; +import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.states.VrfHolder; +import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.states.VrfState; +import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.util.Constants; import org.opendaylight.groupbasedpolicy.renderer.vpp.util.GbpNetconfTransaction; import org.opendaylight.groupbasedpolicy.renderer.vpp.util.VppIidFactory; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address; @@ -43,31 +48,22 @@ import java.util.List; public class StaticRoutingHelper { private static final Logger LOG = LoggerFactory.getLogger(StaticRoutingHelper.class); - private static final String ROUTING_PROTOCOL_NAME_PREFIX = "static-routing-"; - private static final String DEFAULT_DESCRIPTION = "Static route added from GBP for flat L3 overlay"; - - private HostVrfRoutingInformationMapper hostVrfInfo = HostVrfRoutingInformationMapper.getInstance(); - - private InterfaceNameToStaticInfoMapper interfaceNameToStaticInfoMapper; - - public StaticRoutingHelper(InterfaceNameToStaticInfoMapper interfaceNameToStaticInfoMapper) { - this.interfaceNameToStaticInfoMapper = interfaceNameToStaticInfoMapper; - } + private HostRelatedInfoContainer hostRelatedInfoContainer = HostRelatedInfoContainer.getInstance(); public synchronized boolean addRoutingProtocolForVrf(DataBroker vppDataBroker, - String hostId, - long vrf) { - String routingProtocolName = getRoutingProtocolName(vrf); + long vrfId, + VrfHolder vrfHolderOfHost) { + String routingProtocolName = getRoutingProtocolName(vrfId); RoutingProtocolBuilder builder = new RoutingProtocolBuilder(); builder.setKey(new RoutingProtocolKey(routingProtocolName)); builder.setName(routingProtocolName); builder.setType(Static.class); - builder.setDescription(DEFAULT_DESCRIPTION); + builder.setDescription(Constants.DEFAULT_ROUTING_DESCRIPTION); RoutingProtocolVppAttrBuilder vppAugmentationBuilder = new RoutingProtocolVppAttrBuilder(); vppAugmentationBuilder. setVppProtocolAttributes(new VppProtocolAttributesBuilder() - .setPrimaryVrf(new VniReference(vrf)).build()); + .setPrimaryVrf(new VniReference(vrfId)).build()); builder.addAugmentation(RoutingProtocolVppAttr.class, vppAugmentationBuilder.build()); @@ -75,34 +71,34 @@ public class StaticRoutingHelper { .getRoutingInstanceIid(builder.getKey()); if (GbpNetconfTransaction.netconfSyncedWrite(vppDataBroker, iid, builder.build(), GbpNetconfTransaction.RETRY_COUNT)) { - RoutingInfo info = new RoutingInfo(); - info.setProtocolName(routingProtocolName); - hostVrfInfo.addRoutingVrfToHost(hostId, vrf, info); + vrfHolderOfHost.initializeVrfState(vrfId, routingProtocolName); return true; } return false; } - public boolean endPointRoutingExists(String interfaceName, Ipv4Address ip) { - return interfaceNameToStaticInfoMapper.routeAlreadyExists(interfaceName, ip); - } - - public boolean routeAlreadyExistsInHostVrf(String hostId, long vrf, Ipv4Address ip) { - return hostVrfInfo.ipAlreadyExistsInHostVrf(hostId, vrf, ip); - } - public synchronized boolean addSingleStaticRouteInRoutingProtocol(DataBroker vppDataBroker, - String hostId, - long vrf, - Ipv4Address nextHopAddress, - Ipv4Prefix ipPrefix, - String outgoingInterface) { + String hostName, + long portVrfId, + String portSubnetUuid, + Ipv4Address nextHopAddress, + Ipv4Prefix ipPrefix, + String outgoingInterface) { RouteBuilder builder = new RouteBuilder(); - Long routingId = hostVrfInfo.getEndPointCountInVrf(hostId, vrf); + VrfState hostVrfStateForPortVrf = hostRelatedInfoContainer + .getVrfStateOfHost(hostName) + .getVrfState(portVrfId); + + PortInterfaces hostPortInterfaces = hostRelatedInfoContainer + .getPortInterfaceStateOfHost(hostName); + + Preconditions.checkNotNull(hostVrfStateForPortVrf, "Vrf has not been initialized yet"); + + long routeId = hostVrfStateForPortVrf.getNextRouteId(); - builder.setId(routingId); + builder.setId(routeId); builder.setDestinationPrefix(ipPrefix); builder.setKey(new RouteKey(builder.getId())); builder.setNextHopOptions(new SimpleNextHopBuilder() @@ -114,15 +110,18 @@ public class StaticRoutingHelper { Ipv4 ipv4Route = new Ipv4Builder().setRoute(routes).build(); - InstanceIdentifier iid = VppIidFactory. - getRoutingInstanceIid(new RoutingProtocolKey(hostVrfInfo.getProtocolName(hostId, vrf))) + InstanceIdentifier iid = VppIidFactory + .getRoutingInstanceIid(new RoutingProtocolKey(hostVrfStateForPortVrf.getProtocolName())) .child(StaticRoutes.class) .augmentation(StaticRoutes1.class) .child(Ipv4.class); - if (GbpNetconfTransaction.netconfSyncedMerge(vppDataBroker, iid, ipv4Route, GbpNetconfTransaction.RETRY_COUNT)) { - interfaceNameToStaticInfoMapper.addRouteForInterface(outgoingInterface, nextHopAddress, routingId); - hostVrfInfo.addStaticRoute(hostId, vrf, nextHopAddress); + if (GbpNetconfTransaction + .netconfSyncedMerge(vppDataBroker, iid, ipv4Route, + GbpNetconfTransaction.RETRY_COUNT)) { + hostVrfStateForPortVrf.addNewPortIpInVrf(portSubnetUuid, nextHopAddress); + hostPortInterfaces.addRouteToPortInterface(outgoingInterface, portSubnetUuid, + nextHopAddress, routeId); return true; } @@ -130,31 +129,61 @@ public class StaticRoutingHelper { } public synchronized boolean deleteSingleStaticRouteFromRoutingProtocol(DataBroker vppDataBroker, - String hostId, - long vrf, - String outgoingInterface) { - List allRoutingIdsForPort = interfaceNameToStaticInfoMapper.getRoutingIdsAssociatedWithInterface(outgoingInterface); + String hostName, + long vrfId, + String outgoingInterfaceName, + Long routeId) { + VrfState vrfState = hostRelatedInfoContainer.getVrfStateOfHost(hostName).getVrfState(vrfId); + + Preconditions.checkNotNull(vrfState, "Vrf has not been initialized"); + + InstanceIdentifier iid = VppIidFactory + .getRoutingInstanceIid(new RoutingProtocolKey(vrfState.getProtocolName())) + .child(StaticRoutes.class) + .augmentation(StaticRoutes1.class) + .child(Ipv4.class) + .child(Route.class, new RouteKey(routeId)); + + if (!GbpNetconfTransaction.netconfSyncedDelete(vppDataBroker, iid, GbpNetconfTransaction.RETRY_COUNT)) { + LOG.warn("Route delete failed for interface {} from {}", outgoingInterfaceName, hostName); + return false; + } + return true; + } + + public synchronized boolean deleteAllRoutesThroughInterface(DataBroker vppDataBroker, + String hostName, + String outgoingInterfaceName) { + PortRouteState portRouteState = hostRelatedInfoContainer + .getPortInterfaceStateOfHost(hostName) + .getPortRouteState(outgoingInterfaceName); + + long vrfId = hostRelatedInfoContainer.getPortInterfaceStateOfHost(hostName) + .getInterfaceVrfId(outgoingInterfaceName); + + List ipThroughInterface = portRouteState.getAllIps(); boolean allOk = true; - for (Long routingId : allRoutingIdsForPort) { - InstanceIdentifier iid = VppIidFactory. - getRoutingInstanceIid(new RoutingProtocolKey(hostVrfInfo.getProtocolName(hostId, vrf))) - .child(StaticRoutes.class) - .augmentation(StaticRoutes1.class) - .child(Ipv4.class) - .child(Route.class, new RouteKey(routingId)); - if (!GbpNetconfTransaction.netconfSyncedDelete(vppDataBroker, iid, GbpNetconfTransaction.RETRY_COUNT)) { - LOG.warn("Route delete failed for interface {} from {}", outgoingInterface, hostId); - allOk = false; + for (Ipv4Address ip : ipThroughInterface) { + long routeId = portRouteState.getRouteIdOfIp(ip); + String subnetUuidOfIp = portRouteState.getSubnetUuidOfIp(ip); + boolean ok = deleteSingleStaticRouteFromRoutingProtocol(vppDataBroker, hostName, vrfId, + outgoingInterfaceName, routeId); + + if (ok) { + portRouteState.removeIp(ip); + hostRelatedInfoContainer + .getVrfStateOfHost(hostName) + .getVrfState(vrfId) + .removePortIpFromVrf(subnetUuidOfIp, ip); } } - interfaceNameToStaticInfoMapper.clearStaticRoutesForInterface(outgoingInterface); return allOk; } public static String getRoutingProtocolName(long vrf) { - return ROUTING_PROTOCOL_NAME_PREFIX + vrf; + return Constants.ROUTING_PROTOCOL_NAME_PREFIX + vrf; } } diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/info/container/EndpointHost.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/info/container/EndpointHost.java new file mode 100644 index 000000000..885d8802c --- /dev/null +++ b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/info/container/EndpointHost.java @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2017 Cisco Systems. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container; + +import org.opendaylight.controller.md.sal.binding.api.DataBroker; + +/** + * Created by Shakib Ahmed on 7/14/17. + */ +public class EndpointHost { + DataBroker hostDataBroker; + String hostName; + + public EndpointHost(DataBroker hostDataBroker, String hostName) { + this.hostDataBroker = hostDataBroker; + this.hostName = hostName; + } + + public DataBroker getHostDataBroker() { + return hostDataBroker; + } + + public String getHostName() { + return hostName; + } +} diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/info/container/HostRelatedInfoContainer.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/info/container/HostRelatedInfoContainer.java new file mode 100644 index 000000000..1e07a7eba --- /dev/null +++ b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/info/container/HostRelatedInfoContainer.java @@ -0,0 +1,82 @@ +/* + * Copyright (c) 2017 Cisco Systems. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container; + +import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.states.PortInterfaces; +import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.states.LispState; +import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.states.PhysicalInterfaces; +import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.states.VrfHolder; + +import java.util.HashMap; + +/** + * Created by Shakib Ahmed on 7/13/17. + */ +public class HostRelatedInfoContainer { + private HashMap hostNameToLispStateMapper; + private HashMap hostNameToPhysicalInterfacesMapper; + private HashMap hostNameToPortInterfacesMapper; + private HashMap hostNameToVrfHolderMapper; + + private static final HostRelatedInfoContainer INSTANCE = new HostRelatedInfoContainer(); + + private HostRelatedInfoContainer() { + this.hostNameToLispStateMapper = new HashMap<>(); + this.hostNameToPhysicalInterfacesMapper = new HashMap<>(); + this.hostNameToPortInterfacesMapper = new HashMap<>(); + this.hostNameToVrfHolderMapper = new HashMap<>(); + } + + public static HostRelatedInfoContainer getInstance() { + return INSTANCE; + } + + public LispState getLispStateOfHost(String hostName) { + return hostNameToLispStateMapper.get(hostName); + } + + public void setLispStateOfHost(String hostName, LispState lispState) { + hostNameToLispStateMapper.put(hostName, lispState); + } + + public void deleteLispStateOfHost(String hostName) { + hostNameToLispStateMapper.remove(hostName); + } + + public PhysicalInterfaces getPhysicalInterfaceState(String hostName) { + return hostNameToPhysicalInterfacesMapper.get(hostName); + } + + public void setPhysicalInterfaceStateOfHost(String hostName, PhysicalInterfaces physicalInterfaces) { + hostNameToPhysicalInterfacesMapper.put(hostName, physicalInterfaces); + } + + public void removePhysicalInterfaceStateOfHost(String hostName) { + hostNameToPhysicalInterfacesMapper.remove(hostName); + } + + public PortInterfaces getPortInterfaceStateOfHost(String hostName) { + return hostNameToPortInterfacesMapper.computeIfAbsent(hostName, key -> new PortInterfaces()); + } + + public void setVirtualInterfaceStateOfHost(String hostName, PortInterfaces portInterfaces) { + hostNameToPortInterfacesMapper.put(hostName, portInterfaces); + } + + public void removeVirtualInterfaceStateOfHost(String hostName) { + hostNameToPortInterfacesMapper.remove(hostName); + } + + public VrfHolder getVrfStateOfHost(String hostName) { + return hostNameToVrfHolderMapper.computeIfAbsent(hostName, key -> new VrfHolder()); + } + + public void removeVrfStateOfHost(String hostName) { + hostNameToVrfHolderMapper.remove(hostName); + } +} diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/LispState.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/info/container/states/LispState.java similarity index 60% rename from renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/LispState.java rename to renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/info/container/states/LispState.java index 3dd38185c..886c77ffb 100644 --- a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/LispState.java +++ b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/info/container/states/LispState.java @@ -5,8 +5,7 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ - -package org.opendaylight.groupbasedpolicy.renderer.vpp.lisp; +package org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.states; 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.params.xml.ns.yang.lisp.rev170315.dp.subtable.grouping.local.mappings.local.mapping.Eid; @@ -20,31 +19,21 @@ import java.util.Set; * Created by Shakib Ahmed on 3/29/17. */ public class LispState { - private String hostName; private boolean lispEnabled; private boolean gpeEnabled; - private HashMap locIntfToLocSetNameMapping; + private HashMap interfaceNameToLocatorSetNameMapper; private Set mapServerIpAddressSet; private Set mapResolverIpAddressSet; private Set vniSet; - private boolean mapRegisteredEnabled; - private HashMap eidToMappingIdMapper; - private int interfaceCount; + private Set eidSet; - public LispState(String hostName) { - this.hostName = hostName; + public LispState() { lispEnabled = false; - locIntfToLocSetNameMapping = new HashMap<>(); + interfaceNameToLocatorSetNameMapper = new HashMap<>(); mapServerIpAddressSet = new HashSet<>(); mapResolverIpAddressSet = new HashSet<>(); - mapRegisteredEnabled = false; vniSet = new HashSet<>(); - eidToMappingIdMapper = new HashMap<>(); - interfaceCount = 1; - } - - public String getHostName() { - return hostName; + eidSet = new HashSet<>(); } public boolean isLispEnabled() { @@ -64,19 +53,19 @@ public class LispState { } public String getLocIntfToLocSetNameMapping(String locatorIntf) { - return locIntfToLocSetNameMapping.get(locatorIntf); + return interfaceNameToLocatorSetNameMapper.get(locatorIntf); } public void setLocIntfToLocSetNameMapping(String locIntfName, String locSetName) { - locIntfToLocSetNameMapping.put(locIntfName, locSetName); + interfaceNameToLocatorSetNameMapper.put(locIntfName, locSetName); } public Set> getLocatorSetEntry() { - return locIntfToLocSetNameMapping.entrySet(); + return interfaceNameToLocatorSetNameMapper.entrySet(); } public int getLocatorCount() { - return locIntfToLocSetNameMapping.size(); + return interfaceNameToLocatorSetNameMapper.size(); } public boolean mapServerSetContains(IpAddress ip) { @@ -95,7 +84,7 @@ public class LispState { mapResolverIpAddressSet.add(ip); } - public boolean vniSetContains(long vni) { + public boolean isVniConfigured(long vni) { return vniSet.contains(vni); } @@ -103,36 +92,18 @@ public class LispState { vniSet.add(vni); } - public boolean isMapRegisteredEnabled() { - return mapRegisteredEnabled; - } - - public void setMapRegisteredEnabled(boolean mapRegisteredEnabled) { - this.mapRegisteredEnabled = mapRegisteredEnabled; - } - public boolean eidSetContains(Eid eid) { - return eidToMappingIdMapper.containsKey(eid); - } - - public void addInEidSet(Eid eid, String mappingId) { - interfaceCount++; - eidToMappingIdMapper.put(eid, mappingId); + return eidSet.contains(eid); } public int eidCount() { - return eidToMappingIdMapper.size(); + return eidSet.size(); } - public void deleteEid(Eid eid) { - eidToMappingIdMapper.remove(eid); + public void addEidInEidSet(Eid eid) { + eidSet.add(eid); } - - public String getEidMapping(Eid eid) { - return eidToMappingIdMapper.get(eid); - } - - public int getInterfaceId() { - return interfaceCount; + public void deleteEid(Eid eid) { + eidSet.remove(eid); } } diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/info/container/states/PhysicalInterfaces.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/info/container/states/PhysicalInterfaces.java new file mode 100644 index 000000000..2026f73d8 --- /dev/null +++ b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/info/container/states/PhysicalInterfaces.java @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2017 Cisco Systems. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.states; + +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress; + +import java.util.HashMap; + +/** + * Created by Shakib Ahmed on 7/14/17. + */ +public class PhysicalInterfaces { + + public enum PhysicalInterfaceType { + PUBLIC + } + + private HashMap physicalInterfaceTypeToIpMapper; + private HashMap physicalInterfaceTypeToNameMapper; + + + public PhysicalInterfaces() { + physicalInterfaceTypeToIpMapper = new HashMap<>(); + physicalInterfaceTypeToNameMapper = new HashMap<>(); + } + + public void addPhysicalInterfaceInfo(PhysicalInterfaceType physicalInterfaceType, + String interfaceName, + IpAddress interfaceIp) { + physicalInterfaceTypeToNameMapper.put(physicalInterfaceType, interfaceName); + physicalInterfaceTypeToIpMapper.put(physicalInterfaceType, interfaceIp); + } + + public IpAddress getIp(PhysicalInterfaceType physicalInterfaceType) { + return physicalInterfaceTypeToIpMapper.get(physicalInterfaceType); + } + + public String getName(PhysicalInterfaceType physicalInterfaceType) { + return physicalInterfaceTypeToNameMapper.get(physicalInterfaceType); + } +} diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/info/container/states/PortInterfaces.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/info/container/states/PortInterfaces.java new file mode 100644 index 000000000..a1bef1b9a --- /dev/null +++ b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/info/container/states/PortInterfaces.java @@ -0,0 +1,62 @@ +/* + * Copyright (c) 2017 Cisco Systems. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.states; + +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address; + +import java.util.Collection; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +/** + * Created by Shakib Ahmed on 7/14/17. + */ +public class PortInterfaces { + private HashMap interfaceNameToPortRouteStateMapper; + private Set metadataInterfaceSet; + + public PortInterfaces() { + interfaceNameToPortRouteStateMapper = new HashMap<>(); + metadataInterfaceSet = new HashSet<>(); + } + + public void initializeRoutingContextForInterface(String interfaceName, Long vrfId) { + interfaceNameToPortRouteStateMapper.put(interfaceName, new PortRouteState(vrfId)); + } + + public boolean isVrfConfiguredForInterface(String interfaceName) { + return interfaceNameToPortRouteStateMapper.containsKey(interfaceName); + } + + public PortRouteState getPortRouteState(String interfaceName) { + return interfaceNameToPortRouteStateMapper.get(interfaceName); + } + + public void addRouteToPortInterface(String interfaceName, String ipSubnetUuid, Ipv4Address ip, long routeId) { + interfaceNameToPortRouteStateMapper.get(interfaceName).addRouteInfo(ip, routeId, ipSubnetUuid); + } + + public boolean isInterfaceConfiguredForMetadata(String interfaceName) { + return metadataInterfaceSet.contains(interfaceName); + } + + public void addInterfaceInMetadataInterfaceSet(String interfaceName) { + metadataInterfaceSet.add(interfaceName); + } + + public long getInterfaceVrfId(String interfaceName) { + return interfaceNameToPortRouteStateMapper.get(interfaceName).getVrfId(); + } + + public void removePortInterface(String interfaceName) { + metadataInterfaceSet.remove(interfaceName); + interfaceNameToPortRouteStateMapper.remove(interfaceName); + } +} diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/info/container/states/PortRouteState.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/info/container/states/PortRouteState.java new file mode 100644 index 000000000..c5449a98d --- /dev/null +++ b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/info/container/states/PortRouteState.java @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2017 Cisco Systems. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.states; + +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; + +/** + * Created by Shakib Ahmed on 7/17/17. + */ +public class PortRouteState { + private HashMap ipToSubnetUuidMapper; + private HashMap ipToRouteIdMapper; + private Long vrfId; + + public PortRouteState(long vrfId) { + ipToRouteIdMapper = new HashMap<>(); + ipToSubnetUuidMapper = new HashMap<>(); + this.vrfId = vrfId; + } + + public long getVrfId() { + return this.vrfId; + } + + public void addRouteInfo(Ipv4Address ip, Long routeId, String ipSubnetUuid) { + ipToRouteIdMapper.put(ip, routeId); + ipToSubnetUuidMapper.put(ip, ipSubnetUuid); + } + + public long getRouteIdOfIp(Ipv4Address interfaceIp) { + return ipToRouteIdMapper.get(interfaceIp); + } + + public String getSubnetUuidOfIp(Ipv4Address interfaceIp) { + return ipToSubnetUuidMapper.get(interfaceIp); + } + + public void removeIp(Ipv4Address ip) { + ipToRouteIdMapper.remove(ip); + ipToSubnetUuidMapper.remove(ip); + } + + public List getAllIps() { + return new ArrayList<>(ipToRouteIdMapper.keySet()); + } +} diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/info/container/states/RouteState.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/info/container/states/RouteState.java new file mode 100644 index 000000000..9ceac73f5 --- /dev/null +++ b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/info/container/states/RouteState.java @@ -0,0 +1,49 @@ +/* + * Copyright (c) 2017 Cisco Systems. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.states; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; + +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address; + +/** + * Created by Shakib Ahmed on 7/17/17. + */ +public class RouteState { + private HashMap ipToRouteIdMapper; + + public RouteState() { + ipToRouteIdMapper = new HashMap<>(); + } + + public boolean ipExists(Ipv4Address ip) { + return ipToRouteIdMapper.containsKey(ip); + } + + public void addIpToRouteIdInfo(Ipv4Address ip, Long routeId) { + ipToRouteIdMapper.put(ip, routeId); + } + + public long getRouteId(Ipv4Address ip) { + return ipToRouteIdMapper.get(ip); + } + + public void removeIp(Ipv4Address ip) { + ipToRouteIdMapper.remove(ip); + } + + public boolean hasNoIpRoutes() { + return ipToRouteIdMapper.isEmpty(); + } + + public List getAllIps() { + return new ArrayList<>(ipToRouteIdMapper.keySet()); + } +} diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/info/container/states/SubnetHolder.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/info/container/states/SubnetHolder.java new file mode 100644 index 000000000..ee012b1f9 --- /dev/null +++ b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/info/container/states/SubnetHolder.java @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2017 Cisco Systems. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.states; + +import java.util.HashMap; + +/** + * Created by Shakib Ahmed on 7/17/17. + */ +public class SubnetHolder { + private HashMap subnetUuidToSubnetStateMapper; + + public SubnetHolder() { + subnetUuidToSubnetStateMapper = new HashMap<>(); + } + + public SubnetState getSubnetState(String subnetUuid) { + return subnetUuidToSubnetStateMapper.computeIfAbsent(subnetUuid, + key -> new SubnetState()); + } + + public void removeSubnetState(String subnetUuid) { + subnetUuidToSubnetStateMapper.remove(subnetUuid); + } + +} diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/info/container/states/SubnetState.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/info/container/states/SubnetState.java new file mode 100644 index 000000000..4d6885c66 --- /dev/null +++ b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/info/container/states/SubnetState.java @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2017 Cisco Systems. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.states; + +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address; + +import java.util.HashSet; +import java.util.Set; + +/** + * Created by Shakib Ahmed on 7/17/17. + */ +public class SubnetState { + private String gwInterfaceName; + private Set ipsInSubnet; + + public SubnetState() { + ipsInSubnet = new HashSet<>(); + } + + public boolean isGwConfigured() { + return gwInterfaceName != null && !gwInterfaceName.isEmpty(); + } + + public String getGwInterfaceName() { + return gwInterfaceName; + } + + public void setGwInterfaceName(String gwInterfaceName) { + this.gwInterfaceName = gwInterfaceName; + } + + public boolean hasIpsInSubnet() { + return !ipsInSubnet.isEmpty(); + } + + public void addNewIp(Ipv4Address portIp) { + ipsInSubnet.add(portIp); + } + + public boolean isIpPresent(Ipv4Address portIp) { + return ipsInSubnet.contains(portIp); + } + + public void removeIp(Ipv4Address portIp) { + ipsInSubnet.remove(portIp); + } +} diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/info/container/states/VrfHolder.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/info/container/states/VrfHolder.java new file mode 100644 index 000000000..8aa1ba492 --- /dev/null +++ b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/info/container/states/VrfHolder.java @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2017 Cisco Systems. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.states; + +import java.util.HashMap; + +/** + * Created by Shakib Ahmed on 7/17/17. + */ +public class VrfHolder { + HashMap vrfIdToVrfStateMapper; + + public VrfHolder() { + vrfIdToVrfStateMapper = new HashMap<>(); + } + + public VrfState getVrfState(Long vrfId) { + return vrfIdToVrfStateMapper.get(vrfId); + } + + public void initializeVrfState(Long vrfId, String routingProtocolName) { + vrfIdToVrfStateMapper.put(vrfId, new VrfState(routingProtocolName)); + } + + public boolean hasVrf(Long vrfId) { + return vrfIdToVrfStateMapper.containsKey(vrfId); + } +} diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/info/container/states/VrfState.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/info/container/states/VrfState.java new file mode 100644 index 000000000..c3d34663d --- /dev/null +++ b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/info/container/states/VrfState.java @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2017 Cisco Systems. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.states; + +import org.apache.commons.lang3.mutable.MutableLong; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address; + +/** + * Created by Shakib Ahmed on 7/17/17. + */ +public class VrfState { + private SubnetHolder subnetHolder; + private String protocolName; + private MutableLong nextRouteId; + + public VrfState(String routingProtocolName) { + this.subnetHolder = new SubnetHolder(); + this.protocolName = routingProtocolName; + this.nextRouteId = new MutableLong(1L); + } + + public SubnetHolder getSubnetHolder() { + return subnetHolder; + } + + public String getProtocolName() { + return protocolName; + } + + public long getNextRouteId() { + return nextRouteId.getValue(); + } + + public void addNewPortIpInVrf(String portSubnetUuid, Ipv4Address portIp) { + subnetHolder.getSubnetState(portSubnetUuid).addNewIp(portIp); + nextRouteId.increment(); + } + + public void removePortIpFromVrf(String portSubnetUuid, Ipv4Address portIp) { + subnetHolder.getSubnetState(portSubnetUuid).removeIp(portIp); + } +} diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/loopback/LoopbackManager.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/loopback/LoopbackManager.java index 4a752da90..59850e98c 100644 --- a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/loopback/LoopbackManager.java +++ b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/loopback/LoopbackManager.java @@ -19,10 +19,14 @@ import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.lisp.LispCommandW import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.LispStateCommandExecutor; import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.exception.LispConfigCommandFailedException; import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.exception.LispHelperArgumentException; -import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.mappers.LoopbackHostSpecificInfoMapper; +import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.EndpointHost; +import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.HostRelatedInfoContainer; +import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.states.SubnetState; +import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.states.VrfHolder; import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.mappers.NeutronTenantToVniMapper; import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.mappers.SubnetUuidToGbpSubnetMapper; import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.util.ConfigManagerHelper; +import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.util.Constants; import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.util.IpAddressUtil; import org.opendaylight.groupbasedpolicy.renderer.vpp.util.GbpNetconfTransaction; import org.opendaylight.groupbasedpolicy.renderer.vpp.util.General; @@ -47,7 +51,6 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; import javax.annotation.Nonnull; -import java.util.List; /** * Created by Shakib Ahmed on 4/26/17. @@ -57,42 +60,47 @@ public class LoopbackManager { private ConfigManagerHelper loopbackManagerHelper; - private LoopbackHostSpecificInfoMapper subnetHostSpecificInfo; - private NeutronTenantToVniMapper neutronTenantToVniMapper; - private SubnetUuidToGbpSubnetMapper subnetUuidToGbpSubnetMapper; - - private static final String LOOP_NAME_PREFIX = "loop-"; - private static final String GPE_ENTRY_PREFIX = "gpe-entry-"; + private HostRelatedInfoContainer hostRelatedInfoContainer = HostRelatedInfoContainer.getInstance(); + private SubnetUuidToGbpSubnetMapper subnetUuidToGbpSubnetMapper = SubnetUuidToGbpSubnetMapper.getInstance(); + private NeutronTenantToVniMapper neutronTenantToVniMapper = NeutronTenantToVniMapper.getInstance(); public LoopbackManager(@Nonnull MountedDataBrokerProvider mountedDataBrokerProvider) { this.loopbackManagerHelper = new ConfigManagerHelper(mountedDataBrokerProvider); - this.subnetHostSpecificInfo = new LoopbackHostSpecificInfoMapper(); - this.neutronTenantToVniMapper = NeutronTenantToVniMapper.getInstance(); - this.subnetUuidToGbpSubnetMapper = SubnetUuidToGbpSubnetMapper.getInstance(); } public void createBviLoopbackIfNeeded(AddressEndpointWithLocation addressEp, String bridgeDomainName) { try { - DataBroker vppDataBroker = loopbackManagerHelper.getPotentialExternalDataBroker(addressEp).get(); - String hostName = loopbackManagerHelper.getHostName(addressEp).get(); + EndpointHost endpointHost = loopbackManagerHelper.getEndpointHostInformation(addressEp); + long vni = getVni(addressEp.getTenant().getValue()); + long vrfId = vni; String subnetUuid = loopbackManagerHelper.getSubnet(addressEp); - if (subnetHostSpecificInfo.loopbackAlreadyExists(hostName, subnetUuid)) { - subnetHostSpecificInfo.addNewPortInHostSubnet(hostName, subnetUuid); + VrfHolder hostVrfHolder = hostRelatedInfoContainer.getVrfStateOfHost(endpointHost.getHostName()); + + if (!hostVrfHolder.hasVrf(vrfId)) { + //dummy init for bridge domain case + hostVrfHolder.initializeVrfState(vrfId, Constants.DUMMY_PROTOCOL_BRIDGE_DOMAIN); + } + + SubnetState subnetState = hostVrfHolder.getVrfState(vni) + .getSubnetHolder() + .getSubnetState(subnetUuid); + + if (!subnetState.isGwConfigured()) { return; } GbpSubnet gbpSubnetInfo = Preconditions.checkNotNull(getSubnetInfo(subnetUuid), "Subnet UUID {} hasn't been created yet!", subnetUuid); - String interfaceName = LOOP_NAME_PREFIX + subnetHostSpecificInfo.getLoopbackCount(hostName); - long vni = getVni(addressEp.getTenant().getValue()); + String gwInterfaceName = loopbackManagerHelper.getGatewayInterfaceName(Constants.GW_NAME_PREFIX, subnetUuid); LoopbackCommand bviLoopbackCommand = LoopbackCommandWrapper - .bviLoopbackPutCommand(interfaceName, vni, gbpSubnetInfo.getGatewayIp(), gbpSubnetInfo.getCidr(), + .bviLoopbackPutCommand(gwInterfaceName, vni, gbpSubnetInfo.getGatewayIp(), gbpSubnetInfo.getCidr(), bridgeDomainName); - createLoopbackInterface(hostName, subnetUuid, vppDataBroker, bviLoopbackCommand); + createLoopbackInterface(endpointHost.getHostDataBroker(), endpointHost.getHostName(), + subnetState, bviLoopbackCommand); } catch (LispConfigCommandFailedException e) { LOG.warn("LISP couldn't be configured: {}", e.getMessage()); } @@ -102,89 +110,85 @@ public class LoopbackManager { try { if (loopbackManagerHelper.isMetadataPort(addressEp)) { - // if the address endpoint is a metadataport, no proxy arp range needed. return; } DataBroker vppDataBroker = loopbackManagerHelper.getPotentialExternalDataBroker(addressEp).get(); String hostName = loopbackManagerHelper.getHostName(addressEp).get(); + long vni = getVni(addressEp.getTenant().getValue()); + long vrfId = vni; String subnetUuid = loopbackManagerHelper.getSubnet(addressEp); - if (subnetHostSpecificInfo.loopbackAlreadyExists(hostName, subnetUuid)) { - subnetHostSpecificInfo.addNewPortInHostSubnet(hostName, subnetUuid); - String loopbackInterfaceName = subnetHostSpecificInfo - .getInterfaceNameForLoopbackInHost(hostName, subnetUuid); - addUnnumberedInterface(addressEp, loopbackInterfaceName); - return; - } - - String interfaceName = LOOP_NAME_PREFIX + subnetHostSpecificInfo.getLoopbackCount(hostName); - long vni = getVni(addressEp.getTenant().getValue()); - long vrf = vni; + SubnetState stateOfSubnetUuid = hostRelatedInfoContainer + .getVrfStateOfHost(hostName) + .getVrfState(vrfId).getSubnetHolder() + .getSubnetState(subnetUuid); GbpSubnet gbpSubnetInfo = Preconditions.checkNotNull(getSubnetInfo(subnetUuid), "Subnet UUID {} hasn't been created yet!", subnetUuid); - LoopbackCommand simpleLoopbackCommand = LoopbackCommandWrapper - .simpleLoopbackPutCommand(interfaceName, vrf, gbpSubnetInfo.getGatewayIp(), - gbpSubnetInfo.getCidr()); + if (!stateOfSubnetUuid.isGwConfigured()) { + String interfaceName = loopbackManagerHelper.getGatewayInterfaceName(Constants.GW_NAME_PREFIX, + subnetUuid); + LoopbackCommand simpleLoopbackCommand = LoopbackCommandWrapper + .simpleLoopbackPutCommand(interfaceName, vrfId, gbpSubnetInfo.getGatewayIp(), + gbpSubnetInfo.getCidr()); + createLoopbackInterface(vppDataBroker, hostName, stateOfSubnetUuid, simpleLoopbackCommand); + addProxyArpRange(vppDataBroker, hostName, vrfId, gbpSubnetInfo); + addGpeEntry(vppDataBroker, gbpSubnetInfo, vni); + } - createLoopbackInterface(hostName, subnetUuid, vppDataBroker, simpleLoopbackCommand); - addProxyArpRange(vppDataBroker, vrf, gbpSubnetInfo, hostName); - addGpeEntry(vppDataBroker, gbpSubnetInfo, vni); - addUnnumberedInterface(addressEp, interfaceName); + String gwInterfaceName = stateOfSubnetUuid.getGwInterfaceName(); + addUnnumberedInterface(addressEp, gwInterfaceName); } catch (LispConfigCommandFailedException e) { LOG.warn("LISP couldn't be configured: {}", e.getMessage()); } } - private void createLoopbackInterface(String hostName, String subnetUuid, DataBroker vppDataBroker, + private void createLoopbackInterface(DataBroker vppDataBroker, String hostName, + SubnetState subnetState, LoopbackCommand loopbackCommand) throws LispConfigCommandFailedException { if (GbpNetconfTransaction.netconfSyncedWrite(vppDataBroker, loopbackCommand, GbpNetconfTransaction.RETRY_COUNT)) { - subnetHostSpecificInfo.addLoopbackForHost(hostName, subnetUuid, loopbackCommand.getName(), - loopbackCommand.getVrfId()); - subnetHostSpecificInfo.addNewPortInHostSubnet(hostName, subnetUuid); + subnetState.setGwInterfaceName(loopbackCommand.getName()); } else { throw new LispConfigCommandFailedException("BVI could not be created for " + hostName + " and bridge domain " + loopbackCommand.getBridgeDomain()); } } - public void deleteLoopbackIfExists(String subnetUuid) { - - List hostsWithSubnet = subnetHostSpecificInfo.getHostsWithSubnet(subnetUuid); - - hostsWithSubnet.forEach(host -> { - DataBroker vppDataBroker = loopbackManagerHelper.getPotentialExternalDataBroker(host).get(); - String interfaceName = subnetHostSpecificInfo.getInterfaceNameForLoopbackInHost(host, subnetUuid); - - try { - deleteSpecificLoopback(vppDataBroker, interfaceName); - } catch (LispConfigCommandFailedException e) { - e.printStackTrace(); - } - }); + public void handleEndpointDelete(AddressEndpointWithLocation addressEp) { - subnetHostSpecificInfo.clearSubnet(subnetUuid); - } + if (loopbackManagerHelper.isMetadataPort(addressEp)) { + return; + } - public void handleEndpointDelete(AddressEndpointWithLocation addressEp) { DataBroker vppDataBroker = loopbackManagerHelper.getPotentialExternalDataBroker(addressEp).get(); - String hostId = loopbackManagerHelper.getHostName(addressEp).get(); + String hostName = loopbackManagerHelper.getHostName(addressEp).get(); String portSubnetUuid = loopbackManagerHelper.getSubnet(addressEp); - String interfaceName = subnetHostSpecificInfo.getInterfaceNameForLoopbackInHost(hostId, portSubnetUuid); - if (subnetHostSpecificInfo.deletePortFromHostSubnetAndTriggerLoopbackDelete(hostId, portSubnetUuid)) { + long vrfId = getVni(addressEp.getTenant().getValue()); + SubnetState subnetStateForSubnetUuid = hostRelatedInfoContainer + .getVrfStateOfHost(hostName) + .getVrfState(vrfId) + .getSubnetHolder() + .getSubnetState(portSubnetUuid); + + if (!subnetStateForSubnetUuid.hasIpsInSubnet()) { + String gwInterfaceName = subnetStateForSubnetUuid.getGwInterfaceName(); GbpSubnet gbpSubnetInfo = Preconditions.checkNotNull(subnetUuidToGbpSubnetMapper.getSubnetInfo(portSubnetUuid), "Invalid port!"); long vni = getVni(addressEp.getTenant().getValue()); try { - deleteSpecificLoopback(vppDataBroker, interfaceName); - deleteProxyArpRange(vppDataBroker, vni, gbpSubnetInfo, hostId); - deleteGpeEntry(vppDataBroker, GPE_ENTRY_PREFIX + gbpSubnetInfo.getId() + "_1"); - deleteGpeEntry(vppDataBroker, GPE_ENTRY_PREFIX + gbpSubnetInfo.getId() + "_2"); + deleteSpecificLoopback(vppDataBroker, gwInterfaceName); + deleteProxyArpRange(vppDataBroker, hostName, vni, gbpSubnetInfo); + deleteGpeEntry(vppDataBroker, Constants.GPE_ENTRY_PREFIX + gbpSubnetInfo.getId() + "_1"); + deleteGpeEntry(vppDataBroker, Constants.GPE_ENTRY_PREFIX + gbpSubnetInfo.getId() + "_2"); + hostRelatedInfoContainer.getVrfStateOfHost(hostName) + .getVrfState(vrfId) + .getSubnetHolder() + .removeSubnetState(portSubnetUuid); } catch (LispConfigCommandFailedException e) { LOG.warn("Loopback not deleted properly: {}", e.getMessage()); } @@ -201,9 +205,9 @@ public class LoopbackManager { } private void addProxyArpRange(DataBroker vppDataBroker, + String hostName, long vrf, - GbpSubnet gbpSubnetInfo, - String hostName) throws LispConfigCommandFailedException { + GbpSubnet gbpSubnetInfo) throws LispConfigCommandFailedException { Ipv4Prefix subnetPrefix = gbpSubnetInfo.getCidr().getIpv4Prefix(); Preconditions.checkNotNull(subnetPrefix, "Subnet CIDR found to be null for " @@ -224,9 +228,9 @@ public class LoopbackManager { } private void deleteProxyArpRange(DataBroker vppDataBroker, + String hostName, long vrf, - GbpSubnet gbpSubnetInfo, - String hostName) throws LispConfigCommandFailedException { + GbpSubnet gbpSubnetInfo) throws LispConfigCommandFailedException { Ipv4Prefix subnetPrefix = gbpSubnetInfo.getCidr().getIpv4Prefix(); Preconditions.checkNotNull(subnetPrefix, "Subnet CIDR found to be null for " @@ -307,7 +311,7 @@ public class LoopbackManager { RemoteEid firstREid = LispUtil.toRemoteEid(LispUtil.toLispIpv4Prefix(delegatingSubnets.getLeft()), vni, Ipv4PrefixAfi.class); - putGpeEntry(vppDataBroker, GPE_ENTRY_PREFIX + gbpSubnetInfo.getId() + "_1", firstREid, vni, vni); + putGpeEntry(vppDataBroker, Constants.GPE_ENTRY_PREFIX + gbpSubnetInfo.getId() + "_1", firstREid, vni, vni); if (delegatingSubnets.getLeft().equals(delegatingSubnets.getRight())) { return; @@ -317,7 +321,7 @@ public class LoopbackManager { vni, Ipv4PrefixAfi.class); - putGpeEntry(vppDataBroker, GPE_ENTRY_PREFIX + gbpSubnetInfo.getId() + "_2", secondREid, vni, vni); + putGpeEntry(vppDataBroker, Constants.GPE_ENTRY_PREFIX + gbpSubnetInfo.getId() + "_2", secondREid, vni, vni); } catch (LispHelperArgumentException e) { e.printStackTrace(); } diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/mappers/HostIdToInterfaceInfoMapper.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/mappers/HostIdToInterfaceInfoMapper.java deleted file mode 100644 index 1185cd981..000000000 --- a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/mappers/HostIdToInterfaceInfoMapper.java +++ /dev/null @@ -1,54 +0,0 @@ -/* - * Copyright (c) 2017 Cisco Systems. All rights reserved. - * - * This program and the accompanying materials are made available under the - * terms of the Eclipse Public License v1.0 which accompanies this distribution, - * and is available at http://www.eclipse.org/legal/epl-v10.html - */ -package org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.mappers; - -import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.InterfaceInfo; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress; - -import java.util.HashMap; - -/** - * Created by Shakib Ahmed on 6/23/17. - */ -public class HostIdToInterfaceInfoMapper { - - public enum InterfaceType { - PUBLIC - } - - HashMap> hostIdToInterfaceInfoMapper; - - private HostIdToInterfaceInfoMapper() { - hostIdToInterfaceInfoMapper = new HashMap<>(); - } - - private static final HostIdToInterfaceInfoMapper INSTANCE = new HostIdToInterfaceInfoMapper(); - - public static HostIdToInterfaceInfoMapper getInstance() { - return INSTANCE; - } - - public void addInterfaceInfo(String hostId, - InterfaceType interfaceType, - String interfaceName, - IpAddress interfaceIp) { - HashMap typeToInterfaceInfoMapper = - hostIdToInterfaceInfoMapper.computeIfAbsent(hostId, id -> new HashMap<>()); - - typeToInterfaceInfoMapper.put(interfaceType, new InterfaceInfo(interfaceName, interfaceIp)); - } - - public InterfaceInfo getInterfaceInfo(String hostId, InterfaceType interfaceType) { - - if (!hostIdToInterfaceInfoMapper.containsKey(hostId)) { - return null; - } - - return hostIdToInterfaceInfoMapper.get(hostId).get(interfaceType); - } -} diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/mappers/HostIdToMetadataInterfaceMapper.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/mappers/HostIdToMetadataInterfaceMapper.java deleted file mode 100644 index 8cd41eac8..000000000 --- a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/mappers/HostIdToMetadataInterfaceMapper.java +++ /dev/null @@ -1,38 +0,0 @@ -/* - * Copyright (c) 2017 Cisco Systems. All rights reserved. - * - * This program and the accompanying materials are made available under the - * terms of the Eclipse Public License v1.0 which accompanies this distribution, - * and is available at http://www.eclipse.org/legal/epl-v10.html - */ - -package org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.mappers; - -import com.google.common.collect.HashMultimap; -import com.google.common.collect.SetMultimap; - - -/** - * Created by Shakib Ahmed on 7/10/17. - */ -public class HostIdToMetadataInterfaceMapper { - private SetMultimap hostIdToMetadataInterfaceNameMapper; - - private static final HostIdToMetadataInterfaceMapper INSTANCE = new HostIdToMetadataInterfaceMapper(); - - private HostIdToMetadataInterfaceMapper() { - hostIdToMetadataInterfaceNameMapper = HashMultimap.create(); - } - - public static HostIdToMetadataInterfaceMapper getInstance() { - return INSTANCE; - } - - public boolean isMetadataInterfaceConfigured(String hostId, String metadataInterfaceName) { - return hostIdToMetadataInterfaceNameMapper.get(hostId).contains(metadataInterfaceName); - } - - public void addMetadataInterfaceInHost(String hostId, String metadataInterfaceName) { - hostIdToMetadataInterfaceNameMapper.put(hostId, metadataInterfaceName); - } -} diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/mappers/HostVrfRoutingInformationMapper.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/mappers/HostVrfRoutingInformationMapper.java deleted file mode 100644 index 2bcbb0481..000000000 --- a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/mappers/HostVrfRoutingInformationMapper.java +++ /dev/null @@ -1,85 +0,0 @@ -/* - * Copyright (c) 2017 Cisco Systems. All rights reserved. - * - * This program and the accompanying materials are made available under the - * terms of the Eclipse Public License v1.0 which accompanies this distribution, - * and is available at http://www.eclipse.org/legal/epl-v10.html - */ - -package org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.mappers; - - -import com.google.common.base.Preconditions; -import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.flat.overlay.RoutingInfo; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address; - -import java.util.HashMap; - -/** - * Created by Shakib Ahmed on 5/4/17. - */ -public class HostVrfRoutingInformationMapper { - HashMap > mapper; - - private static final HostVrfRoutingInformationMapper INSTANCE = new HostVrfRoutingInformationMapper(); - - private HostVrfRoutingInformationMapper() { - mapper = new HashMap<>(); - } - - public static HostVrfRoutingInformationMapper getInstance() { - return INSTANCE; - } - - public void addRoutingVrfToHost(String hostId, long vrf, RoutingInfo routingInfo) { - HashMap routingInfoMapper = mapper.get(hostId); - - if (routingInfoMapper == null) { - routingInfoMapper = new HashMap<>(); - mapper.put(hostId, routingInfoMapper); - } - - routingInfoMapper.put(vrf, routingInfo); - } - - public boolean vrfExists(String hostId, long vrf) { - return mapper.containsKey(hostId) && mapper.get(hostId).containsKey(vrf); - } - - public String getProtocolName(String hostId, long vrf) { - Preconditions.checkArgument(vrfExists(hostId, vrf)); - - return mapper.get(hostId).get(vrf).getProtocolName(); - } - - public void addStaticRoute(String hostId, long vrf, Ipv4Address ip) { - HashMap routingInfoMapper = mapper.get(hostId); - - Preconditions.checkNotNull(routingInfoMapper, "Routing protocol not created, can't add route entry"); - - RoutingInfo routingInfo = routingInfoMapper.get(vrf); - - Preconditions.checkNotNull(routingInfoMapper, "VRF was not created for this host"); - - routingInfo.addIpInVrf(ip); - } - - public Long getEndPointCountInVrf(String hostId, long vrf) { - int count = 0; - - if (vrfExists(hostId, vrf)) { - count = mapper.get(hostId).get(vrf).getCount(); - } - return (long) (count + 1); - } - - public boolean ipAlreadyExistsInHostVrf(String hostId, long vrf, Ipv4Address ip) { - HashMap routingInfoMapper = mapper.get(hostId); - - Preconditions.checkNotNull(routingInfoMapper, "Routing protocol not created, can't add route entry"); - - RoutingInfo routingInfo = routingInfoMapper.get(vrf); - - return routingInfo.ipAlreadyExistsinVrf(ip); - } -} diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/mappers/InterfaceNameToStaticInfoMapper.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/mappers/InterfaceNameToStaticInfoMapper.java deleted file mode 100644 index 39fdc5825..000000000 --- a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/mappers/InterfaceNameToStaticInfoMapper.java +++ /dev/null @@ -1,63 +0,0 @@ -/* - * Copyright (c) 2017 Cisco Systems. All rights reserved. - * - * This program and the accompanying materials are made available under the - * terms of the Eclipse Public License v1.0 which accompanies this distribution, - * and is available at http://www.eclipse.org/legal/epl-v10.html - */ -package org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.mappers; - -import com.google.common.base.Preconditions; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address; - -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; - -/** - * Created by Shakib Ahmed on 5/26/17. - */ -public class InterfaceNameToStaticInfoMapper { - HashMap interfaceNameToStaticRouteMapper; - - private static final InterfaceNameToStaticInfoMapper INSTANCE = new InterfaceNameToStaticInfoMapper(); - - private InterfaceNameToStaticInfoMapper() { - interfaceNameToStaticRouteMapper = new HashMap<>(); - } - - public static InterfaceNameToStaticInfoMapper getInstance() { - return INSTANCE; - } - - public boolean routeAlreadyExists(String interfaceName, Ipv4Address ip) { - StaticRouteInfoMapper staticRouteInfoMapper = interfaceNameToStaticRouteMapper.get(interfaceName); - - if (staticRouteInfoMapper == null) { - return false; - } - - return staticRouteInfoMapper.routeWithIpExists(ip); - } - - public void addRouteForInterface(String interfaceName, Ipv4Address ip, Long routeId) { - StaticRouteInfoMapper staticRouteInfoMapper = interfaceNameToStaticRouteMapper.get(interfaceName); - - if (staticRouteInfoMapper == null) { - staticRouteInfoMapper = new StaticRouteInfoMapper(); - interfaceNameToStaticRouteMapper.put(interfaceName, staticRouteInfoMapper); - } - - staticRouteInfoMapper.addIpRouteForInterface(ip, routeId); - } - - public List getRoutingIdsAssociatedWithInterface(String interfaceName) { - StaticRouteInfoMapper staticRouteInfoMapper = interfaceNameToStaticRouteMapper.get(interfaceName); - - return staticRouteInfoMapper == null ? new ArrayList<>() : staticRouteInfoMapper.getAllRoutingIds(); - } - - public void clearStaticRoutesForInterface(String interfaceName) { - interfaceNameToStaticRouteMapper.remove(interfaceName); - } -} diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/mappers/LoopbackHostSpecificInfoMapper.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/mappers/LoopbackHostSpecificInfoMapper.java deleted file mode 100644 index 3d6302c1a..000000000 --- a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/mappers/LoopbackHostSpecificInfoMapper.java +++ /dev/null @@ -1,135 +0,0 @@ -/* - * Copyright (c) 2017 Cisco Systems. All rights reserved. - * - * This program and the accompanying materials are made available under the - * terms of the Eclipse Public License v1.0 which accompanies this distribution, - * and is available at http://www.eclipse.org/legal/epl-v10.html - */ - -package org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.mappers; - -import com.google.common.collect.ArrayListMultimap; -import com.google.common.collect.Multimap; -import org.apache.commons.lang3.mutable.MutableInt; -import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.loopback.SubnetHostInfo; - -import java.util.HashMap; -import java.util.List; -import java.util.stream.Collectors; - -/** - * Created by Shakib Ahmed on 4/26/17. - */ -public class LoopbackHostSpecificInfoMapper { - private HashMap> hostIdToSubnetMapper; - private Multimap subnetUuidToHostIdListMapper; - private HashMap hostIdToLoopbackCountMapper; - - public LoopbackHostSpecificInfoMapper() { - hostIdToSubnetMapper = new HashMap<>(); - subnetUuidToHostIdListMapper = ArrayListMultimap.create(); - hostIdToLoopbackCountMapper = new HashMap<>(); - } - - private HashMap getSubnetsOfHost(String hostName) { - return hostIdToSubnetMapper.get(hostName); - } - - public boolean loopbackAlreadyExists(String hostName, String subnetUuid) { - return hostIdToSubnetMapper.containsKey(hostName) && - hostIdToSubnetMapper.get(hostName).containsKey(subnetUuid); - } - - public void addLoopbackForHost(String hostName, String subnetUuid, String interfaceName, long vrf) { - putSubnetInfoOfAHost(hostName, subnetUuid, interfaceName, vrf); - subnetUuidToHostIdListMapper.put(subnetUuid, hostName); - } - - private void putSubnetInfoOfAHost(String hostId, String subnetUuid, String interfaceName, long vrf) { - HashMap subnetsOfAHost = getSubnetsOfHost(hostId); - MutableInt loopbackCount = getMutableIntAfterInitIfNecessary(hostId); - - loopbackCount.add(1); - - if (subnetsOfAHost == null) { - subnetsOfAHost = new HashMap<>(); - hostIdToSubnetMapper.put(hostId, subnetsOfAHost); - } - - SubnetHostInfo subnetHostInfo = new SubnetHostInfo(interfaceName); - subnetsOfAHost.put(subnetUuid, subnetHostInfo); - } - - private MutableInt getMutableIntAfterInitIfNecessary(String hostId) { - MutableInt loopbackCount = hostIdToLoopbackCountMapper.get(hostId); - - if (loopbackCount == null) { - loopbackCount = new MutableInt(); - loopbackCount.setValue(0); - hostIdToLoopbackCountMapper.put(hostId, loopbackCount); - } - return loopbackCount; - } - - public int getLoopbackCount(String hostName) { - MutableInt loopbackCount = getMutableIntAfterInitIfNecessary(hostName); - return loopbackCount.getValue(); - } - - public void clearSubnet(String subnetUuid) { - subnetUuidToHostIdListMapper.get(subnetUuid).forEach(hostId -> { - deleteParticularSubnetFromHost(hostId, subnetUuid); - }); - subnetUuidToHostIdListMapper.get(subnetUuid).clear(); - } - - private void deleteParticularSubnetFromHost(String hostId, String subnetUuid) { - hostIdToSubnetMapper.get(hostId).remove(subnetUuid); - } - - private void deleteHostFromSubnetMap(String subnetUuid, String hostId) { - subnetUuidToHostIdListMapper.get(subnetUuid).remove(hostId); - } - - public List getHostsWithSubnet(String subnetUuid) { - return subnetUuidToHostIdListMapper.get(subnetUuid).stream().collect(Collectors.toList()); - } - - public String getInterfaceNameForLoopbackInHost(String hostId, String subnetUuid) { - if (hostIdToSubnetMapper.get(hostId) != null) { - return hostIdToSubnetMapper.get(hostId).get(subnetUuid).getInterfaceName(); - } else { - return null; - } - } - - public int getPortCount(String hostId, String subnetUuid) { - if (hostIdToSubnetMapper.containsKey(hostId)) { - if (hostIdToSubnetMapper.get(hostId).containsKey(subnetUuid)) { - return hostIdToSubnetMapper.get(hostId).get(subnetUuid).getPortCount(); - } else { - return 0; - } - } else { - return 0; - } - } - - public void addNewPortInHostSubnet(String hostId, String subnetUuid) { - getSubnetsOfHost(hostId).get(subnetUuid).incrementPortCount(); - } - - public boolean deletePortFromHostSubnetAndTriggerLoopbackDelete(String hostId, String subnetUuid) { - if (getSubnetsOfHost(hostId).containsKey(subnetUuid)) { - int count = getSubnetsOfHost(hostId).get(subnetUuid).decrementAndGetPortCount(); - - if (count == 0) { - deleteParticularSubnetFromHost(hostId, subnetUuid); - } - - return count == 0; - } else { - return false; - } - } -} diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/mappers/StaticRouteInfoMapper.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/mappers/StaticRouteInfoMapper.java deleted file mode 100644 index a05060e1b..000000000 --- a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/mappers/StaticRouteInfoMapper.java +++ /dev/null @@ -1,44 +0,0 @@ -/* - * Copyright (c) 2017 Cisco Systems. All rights reserved. - * - * This program and the accompanying materials are made available under the - * terms of the Eclipse Public License v1.0 which accompanies this distribution, - * and is available at http://www.eclipse.org/legal/epl-v10.html - */ -package org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.mappers; - -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address; - -import java.util.HashMap; -import java.util.List; -import java.util.stream.Collectors; - -/** - * Created by Shakib Ahmed on 5/26/17. - */ -public class StaticRouteInfoMapper { - HashMap interfaceIpToRouteIdMapper; - - public StaticRouteInfoMapper() { - interfaceIpToRouteIdMapper = new HashMap<>(); - } - - public void addIpRouteForInterface(Ipv4Address ip, Long routingId) { - interfaceIpToRouteIdMapper.put(ip, routingId); - } - - public boolean routeWithIpExists(Ipv4Address ip) { - return interfaceIpToRouteIdMapper.containsKey(ip); - } - - public Long getRouteIdForIp(Ipv4Address ip) { - return interfaceIpToRouteIdMapper.get(ip); - } - - public List getAllRoutingIds() { - return interfaceIpToRouteIdMapper.entrySet() - .stream() - .map(ipv4AddressLongEntry -> ipv4AddressLongEntry.getValue()) - .collect(Collectors.toList()); - } -} diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/util/ConfigManagerHelper.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/util/ConfigManagerHelper.java index 2432933f0..761949dab 100644 --- a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/util/ConfigManagerHelper.java +++ b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/util/ConfigManagerHelper.java @@ -15,10 +15,12 @@ import com.google.common.util.concurrent.ListenableFuture; import org.opendaylight.controller.md.sal.binding.api.DataBroker; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; import org.opendaylight.groupbasedpolicy.renderer.vpp.iface.VppPathMapper; -import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.LispState; +import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.EndpointHost; +import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.HostRelatedInfoContainer; +import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.states.LispState; import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.LispStateManager; import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.exception.LispNotFoundException; -import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.mappers.HostIdToInterfaceInfoMapper; +import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.states.PhysicalInterfaces; import org.opendaylight.groupbasedpolicy.renderer.vpp.util.GbpNetconfTransaction; import org.opendaylight.groupbasedpolicy.renderer.vpp.util.LispUtil; import org.opendaylight.groupbasedpolicy.renderer.vpp.util.MountedDataBrokerProvider; @@ -73,19 +75,25 @@ import java.util.Set; public class ConfigManagerHelper { private static final Logger LOG = LoggerFactory.getLogger(ConfigManagerHelper.class); - private static final String TENANT_INTERFACE = "tenant-interface"; private MountedDataBrokerProvider mountedDataBrokerProvider; public ConfigManagerHelper(MountedDataBrokerProvider mountedDataBrokerProvider) { this.mountedDataBrokerProvider = mountedDataBrokerProvider; } + public EndpointHost getEndpointHostInformation(AddressEndpointWithLocation addressEpWithLoc) { + DataBroker endpointHostDataBroker = getPotentialExternalDataBroker(addressEpWithLoc).get(); + String hostName = getHostName(addressEpWithLoc).get(); + return new EndpointHost(endpointHostDataBroker, hostName); + } + public Optional getPotentialExternalDataBroker(AddressEndpointWithLocation addressEpWithLoc) { ExternalLocationCase externalLocationCase = resolveAndValidateLocation(addressEpWithLoc); InstanceIdentifier vppNodeIid = externalLocationCase.getExternalNodeMountPoint(); String interfacePath = externalLocationCase.getExternalNodeConnector(); - Optional potentialVppDataProvider = mountedDataBrokerProvider.getDataBrokerForMountPoint(vppNodeIid); + Optional + potentialVppDataProvider = mountedDataBrokerProvider.getDataBrokerForMountPoint(vppNodeIid); Preconditions.checkArgument(potentialVppDataProvider.isPresent(), "Cannot resolve data broker for interface path: {}", interfacePath); @@ -158,8 +166,11 @@ public class ConfigManagerHelper { Preconditions.checkNotNull(hostName, "Hostname is null!"); Preconditions.checkNotNull(vppDataBroker, "Vpp DataBroker is null!"); - String publicInterfaceName = HostIdToInterfaceInfoMapper.getInstance() - .getInterfaceInfo(hostName, HostIdToInterfaceInfoMapper.InterfaceType.PUBLIC).getInterfaceName(); + PhysicalInterfaces physicalInterfaces = HostRelatedInfoContainer.getInstance() + .getPhysicalInterfaceState(hostName); + + String publicInterfaceName = physicalInterfaces == null ? "" : physicalInterfaces + .getName(PhysicalInterfaces.PhysicalInterfaceType.PUBLIC); final Optional opInterfaceState = GbpNetconfTransaction.read(vppDataBroker, LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(InterfacesState.class), @@ -190,7 +201,7 @@ public class ConfigManagerHelper { for (org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508. interfaces.Interface intf : hostInterfaceFromOpDS) { - if (TENANT_INTERFACE.equals(intf.getDescription()) + if (Constants.TENANT_INTERFACE.equals(intf.getDescription()) && ipAddressPresent(intf) && intf.getType().equals(EthernetCsmacd.class)) { return Futures.immediateFuture(intf.getName()); @@ -266,8 +277,10 @@ public class ConfigManagerHelper { return LispStateManager.DEFAULT_LOCATOR_SET_NAME_PREFIX + (locatorSetCount + 1); } - public String constructMappingName(int presentMappingCount) { - return LispStateManager.DEFAULT_MAPPINGRECORD_NAME_PREFIX + (presentMappingCount + 1); + public String constructEidMappingName(AddressEndpointWithLocation addressEp) { + String interfaceName = getInterfaceName(addressEp).get(); + String ipAddress = getInterfaceIp(addressEp).getValue(); + return LispStateManager.DEFAULT_MAPPINGRECORD_NAME_PREFIX + interfaceName + "_" + ipAddress; } public String getSubnet(AddressEndpointWithLocation addressEp) { @@ -362,10 +375,18 @@ public class ConfigManagerHelper { "in address endpoint: " + addressEp); } - public boolean isMetadataPort(AddressEndpointWithLocation addedEp) { + public boolean hasRelativeLocations(AddressEndpointWithLocation addedEp) { return addedEp.getRelativeLocations() != null && addedEp.getRelativeLocations().getExternalLocation() != null; } + public boolean isMetadataPort(AddressEndpointWithLocation addressEp) { + return hasRelativeLocations(addressEp) || IpAddressUtil.isMetadataIp(getInterfaceIp(addressEp)); + } + + public String getGatewayInterfaceName(String gwNamePrefix, String subnetUuid) { + return gwNamePrefix + subnetUuid; + } + public Routing getRouting(long vrf) { return new RoutingBuilder().setIpv4VrfId(vrf).build(); } diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/util/Constants.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/util/Constants.java new file mode 100644 index 000000000..ba40a8b19 --- /dev/null +++ b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/util/Constants.java @@ -0,0 +1,23 @@ +/* + * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.util; + + +/** + * Created by Shakib Ahmed on 7/20/17. + */ +public class Constants { + public static final String METADATA_IP = "169.254.169.254"; + public static final String METADATA_SUBNET_UUID = "dummy-metadata-subet"; + public static final String ROUTING_PROTOCOL_NAME_PREFIX = "static-routing-"; + public static final String DEFAULT_ROUTING_DESCRIPTION = "Static route added from GBP for flat L3 overlay"; + public static final String GW_NAME_PREFIX = "loop-"; + public static final String GPE_ENTRY_PREFIX = "gpe-entry-"; + public static final String DUMMY_PROTOCOL_BRIDGE_DOMAIN = "bridge-domain-dummy-protocol"; + public static final String TENANT_INTERFACE = "tenant-interface"; +} diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/util/IpAddressUtil.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/util/IpAddressUtil.java index 2660b634f..b28104da7 100644 --- a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/util/IpAddressUtil.java +++ b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/lisp/util/IpAddressUtil.java @@ -27,6 +27,10 @@ import java.net.UnknownHostException; public class IpAddressUtil { private static final Logger LOG = LoggerFactory.getLogger(IpAddressUtil.class); + public static boolean isMetadataIp(Ipv4Address ipv4Address) { + return ipv4Address.getValue().equals(Constants.METADATA_IP); + } + public static Pair getStartAndEndIp(Ipv4Prefix ipv4Prefix) { SubnetUtils subnetUtils = new SubnetUtils(ipv4Prefix.getValue()); SubnetUtils.SubnetInfo prefixSubnetInfo = subnetUtils.getInfo(); diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/manager/VppNodeManager.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/manager/VppNodeManager.java index 7ef74057c..fb2c35aa0 100644 --- a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/manager/VppNodeManager.java +++ b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/manager/VppNodeManager.java @@ -38,7 +38,8 @@ import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException; import org.opendaylight.controller.sal.binding.api.BindingAwareBroker; -import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.mappers.HostIdToInterfaceInfoMapper; +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.nat.NatUtil; import org.opendaylight.groupbasedpolicy.renderer.vpp.util.VppIidFactory; import org.opendaylight.groupbasedpolicy.renderer.vpp.util.VppRendererProcessingException; @@ -96,6 +97,7 @@ public class VppNodeManager { private final DataBroker dataBroker; private final List requiredCapabilities; private final MountPointService mountService; + private final HostRelatedInfoContainer hostRelatedInfoContainer = HostRelatedInfoContainer.getInstance(); public VppNodeManager(@Nonnull final DataBroker dataBroker, @Nonnull final BindingAwareBroker.ProviderContext session, @Nullable String physicalInterfaces) { @@ -413,13 +415,20 @@ public class VppNodeManager { phIface.setInterfaceName(iface.getName()); phIface.setType(iface.getType()); phIface.setAddress(resolveIpAddress(iface.getAugmentation(Interface1.class))); + PhysicalInterfaces physicalInterfaces = hostRelatedInfoContainer + .getPhysicalInterfaceState(nodeId.getValue()); + if (physicalInterfaces == null) { + physicalInterfaces = new PhysicalInterfaces(); + hostRelatedInfoContainer.setPhysicalInterfaceStateOfHost(nodeId.getValue(), physicalInterfaces); + } + if (extInterfaces.get(nodeId) != null && extInterfaces.get(nodeId).getInterfaceName().equals(phIface.getInterfaceName())) { phIface.setExternal(true); extInterfaces.put(nodeId, new PhysicalInterfaceKey(iface.getName())); - HostIdToInterfaceInfoMapper.getInstance() - .addInterfaceInfo(nodeId.getValue(), HostIdToInterfaceInfoMapper.InterfaceType.PUBLIC, + physicalInterfaces + .addPhysicalInterfaceInfo(PhysicalInterfaces.PhysicalInterfaceType.PUBLIC, phIface.getInterfaceName(), phIface.getAddress().get(0)); LOG.info("Interface {} is marked as public interface based on bundle configuration.", iface.getName()); @@ -427,8 +436,8 @@ public class VppNodeManager { if (PUBLIC_INTERFACE.equals(iface.getDescription())) { phIface.setExternal(true); extInterfaces.put(nodeId, new PhysicalInterfaceKey(iface.getName())); - HostIdToInterfaceInfoMapper.getInstance() - .addInterfaceInfo(nodeId.getValue(), HostIdToInterfaceInfoMapper.InterfaceType.PUBLIC, + physicalInterfaces + .addPhysicalInterfaceInfo(PhysicalInterfaces.PhysicalInterfaceType.PUBLIC, phIface.getInterfaceName(), phIface.getAddress().get(0)); LOG.info("Interface {} is marked as public interface based on HC configuration.", iface.getName()); diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/policy/ForwardingManager.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/policy/ForwardingManager.java index b0ba5b0dd..9bab01655 100644 --- a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/policy/ForwardingManager.java +++ b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/policy/ForwardingManager.java @@ -212,7 +212,7 @@ public final class ForwardingManager { AddressEndpointWithLocation rEp = policyCtx.getAddrEpByKey().get(KeyFactory.addressEndpointKey(rEpKey)); if (ConfigUtil.getInstance().isLispOverlayEnabled()) { - lispStateManager.configureEndPoint(rEp); + lispStateManager.processCreateEndPoint(rEp); if (ConfigUtil.getInstance().isL3FlatEnabled()) { flatOverlayManager.configureEndpointForFlatOverlay(rEp); loopbackManager.createSimpleLoopbackIfNeeded(rEp); @@ -279,21 +279,21 @@ public final class ForwardingManager { public void removeForwardingForEndpoint(RendererEndpointKey rEpKey, PolicyContext policyCtx) { AddressEndpointWithLocation rEp = policyCtx.getAddrEpByKey().get(KeyFactory.addressEndpointKey(rEpKey)); ExternalLocationCase rEpLoc = resolveAndValidateLocation(rEp); + + if (ConfigUtil.getInstance().isLispOverlayEnabled()) { + lispStateManager.processDeleteEndpoint(rEp); + if (ConfigUtil.getInstance().isL3FlatEnabled()) { + flatOverlayManager.handleEndpointDeleteForFlatOverlay(rEp); + } + loopbackManager.handleEndpointDelete(rEp); + } + if (rEpLoc == null || Strings.isNullOrEmpty(rEpLoc.getExternalNodeConnector())) { // nothing was created for endpoint therefore nothing is removed return; } if (!Strings.isNullOrEmpty(rEpLoc.getExternalNode())) { try { - if (ConfigUtil.getInstance().isLispOverlayEnabled()) { - lispStateManager.deleteLispConfigurationForEndpoint(rEp); - loopbackManager.handleEndpointDelete(rEp); - - if (ConfigUtil.getInstance().isL3FlatEnabled()) { - flatOverlayManager.handleEndpointDeleteForFlatOverlay(rEp); - } - - } ifaceManager.deleteBridgeDomainFromInterface(rEp).get(); LOG.debug("bridge-domain was deleted from interface for endpoint {}", rEp); } catch (InterruptedException | ExecutionException e) { diff --git a/renderers/vpp/src/test/java/org/opendaylight/groupbasedpolicy/renderer/vpp/iface/InterfaceManagerTest.java b/renderers/vpp/src/test/java/org/opendaylight/groupbasedpolicy/renderer/vpp/iface/InterfaceManagerTest.java index 96d1a8c85..b0074f1a9 100644 --- a/renderers/vpp/src/test/java/org/opendaylight/groupbasedpolicy/renderer/vpp/iface/InterfaceManagerTest.java +++ b/renderers/vpp/src/test/java/org/opendaylight/groupbasedpolicy/renderer/vpp/iface/InterfaceManagerTest.java @@ -21,6 +21,7 @@ import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction; import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; import org.opendaylight.groupbasedpolicy.renderer.vpp.event.VppEndpointConfEvent; +import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.flat.overlay.FlatOverlayManager; import org.opendaylight.groupbasedpolicy.renderer.vpp.util.MountedDataBrokerProvider; import org.opendaylight.groupbasedpolicy.test.CustomDataBrokerTest; import org.opendaylight.groupbasedpolicy.util.IidFactory; @@ -66,6 +67,7 @@ public class InterfaceManagerTest extends CustomDataBrokerTest { private final static String SOCKET = "socket1"; private InterfaceManager manager; + private FlatOverlayManager flatOverlayManager; private MountedDataBrokerProvider mountedDataProviderMock; private DataBroker mountPointDataBroker; private DataBroker dataBroker; @@ -79,12 +81,13 @@ public class InterfaceManagerTest extends CustomDataBrokerTest { @Before public void init() throws Exception { mountedDataProviderMock = Mockito.mock(MountedDataBrokerProvider.class); + flatOverlayManager = Mockito.mock(FlatOverlayManager.class); mountPointDataBroker = getDataBroker(); setup(); // initialize new data broker for ODL data store dataBroker = getDataBroker(); Mockito.when(mountedDataProviderMock.getDataBrokerForMountPoint(Mockito.any(InstanceIdentifier.class))) .thenReturn(Optional.of(mountPointDataBroker)); - manager = new InterfaceManager(mountedDataProviderMock, dataBroker); + manager = new InterfaceManager(mountedDataProviderMock, dataBroker, flatOverlayManager); } @Test diff --git a/renderers/vpp/src/test/java/org/opendaylight/groupbasedpolicy/renderer/vpp/policy/VppRendererPolicyManagerTest.java b/renderers/vpp/src/test/java/org/opendaylight/groupbasedpolicy/renderer/vpp/policy/VppRendererPolicyManagerTest.java index f2ac85ffb..150dd5268 100644 --- a/renderers/vpp/src/test/java/org/opendaylight/groupbasedpolicy/renderer/vpp/policy/VppRendererPolicyManagerTest.java +++ b/renderers/vpp/src/test/java/org/opendaylight/groupbasedpolicy/renderer/vpp/policy/VppRendererPolicyManagerTest.java @@ -122,14 +122,14 @@ public class VppRendererPolicyManagerTest extends CustomDataBrokerTest { dataBroker = getDataBroker(); Mockito.when(mountedDataProviderMock.getDataBrokerForMountPoint(Mockito.any(InstanceIdentifier.class))) .thenReturn(Optional.of(mountPointDataBroker)); - ifaceManager = new InterfaceManager(mountedDataProviderMock, dataBroker); + lispStateManager = new LispStateManager(mountedDataProviderMock); + loopbackManager = new LoopbackManager(mountedDataProviderMock); + flatOverlayManager = new FlatOverlayManager(dataBroker, mountedDataProviderMock); + ifaceManager = new InterfaceManager(mountedDataProviderMock, dataBroker, flatOverlayManager); aclManager = new AclManager(mountedDataProviderMock); natManager = new NatManager(dataBroker, mountedDataProviderMock); routingManager = new RoutingManager(dataBroker, mountedDataProviderMock); bdManager = new BridgeDomainManagerImpl(mountPointDataBroker); - lispStateManager = new LispStateManager(mountedDataProviderMock); - loopbackManager = new LoopbackManager(mountedDataProviderMock); - flatOverlayManager = new FlatOverlayManager(dataBroker, mountedDataProviderMock); dhcpRelayHandler = new DhcpRelayHandler(dataBroker, mountedDataProviderMock); fwManager = new ForwardingManager(ifaceManager, aclManager, natManager, routingManager, bdManager, lispStateManager, loopbackManager, flatOverlayManager, dhcpRelayHandler, dataBroker);