AclManager aclManager = new AclManager(mountDataProvider);
NatManager natManager = new NatManager(dataBroker, mountDataProvider);
LispStateManager lispStateManager = new LispStateManager(mountDataProvider);
- FlatOverlayManager flatOverlayManager = new FlatOverlayManager(mountDataProvider);
+ FlatOverlayManager flatOverlayManager = new FlatOverlayManager(dataBroker, mountDataProvider);
LoopbackManager loopbackManager = new LoopbackManager(mountDataProvider);
subnetEventManager = new GbpSubnetEventManager(loopbackManager);
dtoEventBus.register(interfaceManager);
private PhysAddress linkLayerAddress;
private InterfaceKey interfaceKey;
- public StaticArpCommand(NeighborCommandBuilder builder) {
+ public StaticArpCommand(StaticArpCommandBuilder builder) {
this.operation = builder.getOperation();
this.ip = builder.getIp();
this.linkLayerAddress = builder.getLinkLayerAddress();
this.interfaceKey = builder.getInterfaceKey();
}
- public static NeighborCommandBuilder builder() {
- return new NeighborCommandBuilder();
+ public static StaticArpCommandBuilder builder() {
+ return new StaticArpCommandBuilder();
}
@Override
.setLinkLayerAddress(this.linkLayerAddress);
}
- public static class NeighborCommandBuilder {
+ public static class StaticArpCommandBuilder {
private General.Operations operation;
private Ipv4AddressNoZone ip;
private PhysAddress linkLayerAddress;
public synchronized void configureEndPoint(AddressEndpointWithLocation addressEp) {
try {
+ if (lispStateHelper.isMetadataPort(addressEp)) {
+ return;
+ }
DataBroker dataBroker = lispStateHelper.getPotentialExternalDataBroker(addressEp).get();
String hostName = lispStateHelper.getHostName(addressEp).get();
LispState lispStateOfNode = configureHostIfNeeded(hostName, dataBroker);
import com.google.common.base.Optional;
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.mappers.NeutronTenantToVniMapper;
import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.util.ConfigManagerHelper;
import org.opendaylight.groupbasedpolicy.renderer.vpp.util.GbpNetconfTransaction;
import org.opendaylight.groupbasedpolicy.renderer.vpp.util.General;
import org.opendaylight.groupbasedpolicy.renderer.vpp.util.MountedDataBrokerProvider;
import org.opendaylight.groupbasedpolicy.renderer.vpp.util.VppIidFactory;
+import org.opendaylight.groupbasedpolicy.util.DataStoreHelper;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4AddressNoZone;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.PhysAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.endpoints.AddressEndpointWithLocation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.Config;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425._interface.attributes._interface.type.choice.TapCase;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpoint;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.interfaces._interface.Routing;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.interfaces._interface.RoutingBuilder;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
private static final Logger LOG = LoggerFactory.getLogger(FlatOverlayManager.class);
private ConfigManagerHelper overlayHelper;
+ private DataBroker dataBroker;
private NeutronTenantToVniMapper neutronTenantToVniMapper = NeutronTenantToVniMapper.getInstance();
private HostVrfRoutingInformationMapper hostVrfInfo = HostVrfRoutingInformationMapper.getInstance();
+ private HostIdToMetadataInterfaceMapper
+ hostIdToMetadataInterfaceMapper = HostIdToMetadataInterfaceMapper.getInstance();
+
+ private InterfaceNameToStaticInfoMapper interfaceNameToStaticInfoMapper;
private StaticRoutingHelper staticRoutingHelper;
- public FlatOverlayManager(@Nonnull MountedDataBrokerProvider mountedDataBrokerProvider) {
+ public FlatOverlayManager(@Nonnull DataBroker dataBroker, @Nonnull MountedDataBrokerProvider mountedDataBrokerProvider) {
this.overlayHelper = new ConfigManagerHelper(mountedDataBrokerProvider);
- staticRoutingHelper = new StaticRoutingHelper();
+ this.interfaceNameToStaticInfoMapper = InterfaceNameToStaticInfoMapper.getInstance();
+ staticRoutingHelper = new StaticRoutingHelper(interfaceNameToStaticInfoMapper);
+ this.dataBroker = dataBroker;
}
public void configureEndpointForFlatOverlay(AddressEndpointWithLocation addressEp) {
- configureInterfaceForFlatOverlay(addressEp);
- addStaticArp(addressEp);
- addStaticRoute(addressEp);
+ if (!overlayHelper.isMetadataPort(addressEp)) {
+ configureInterfaceForFlatOverlay(addressEp);
+ addStaticArp(addressEp);
+ addStaticRoute(addressEp);
+ } else {
+ Ipv4Address metadataIp = overlayHelper.getInterfaceIp(addressEp);
+ Ipv4Prefix metadataIpPrefix = overlayHelper.getInterfaceIpAsPrefix(addressEp);
+ addressEp.getRelativeLocations().getExternalLocation().forEach(externalLocation -> {
+ String hostName = overlayHelper.getHostName(externalLocation).get();
+ String metadataInterfaceName = overlayHelper.getInterfaceName(externalLocation).get();
+
+ long vrf = getVni(addressEp.getTenant().getValue());
+
+ if (!hostIdToMetadataInterfaceMapper.isMetadataInterfaceConfigured(hostName, metadataInterfaceName)) {
+ DataBroker vppDataBroker = overlayHelper.getPotentialExternalDataBroker(externalLocation).get();
+ addInterfaceInVrf(vppDataBroker, metadataInterfaceName, vrf);
+ String physicalAddress = resolvePhysicalAddress(hostName, metadataInterfaceName);
+ addStaticArp(vppDataBroker, hostName, metadataInterfaceName, physicalAddress, metadataIp);
+ addStaticRoute(vppDataBroker, hostName, vrf, metadataIp, metadataIpPrefix, metadataInterfaceName);
+ hostIdToMetadataInterfaceMapper.addMetadataInterfaceInHost(hostName, metadataInterfaceName);
+ }
+ });
+ }
+ }
+
+ private String resolvePhysicalAddress(String hostName, String metadataInterfaceName) {
+ String physAddress = null;
+ Optional<Config> configOptional =
+ DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION, VppIidFactory.getVppRendererConfig(),
+ dataBroker.newReadOnlyTransaction());
+ if (configOptional.isPresent() && configOptional.get().getVppEndpoint() != null) {
+ java.util.Optional<VppEndpoint> vppEndpointOptional = configOptional.get().getVppEndpoint().stream()
+ .filter(vppEndpoint -> vppEndpoint.getVppNodeId().getValue().equals(hostName))
+ .filter(vppEndpoint -> vppEndpoint.getVppInterfaceName().equals(metadataInterfaceName))
+ .findFirst();
+ if (vppEndpointOptional.isPresent() && vppEndpointOptional.get()
+ .getInterfaceTypeChoice() instanceof TapCase) {
+ TapCase tapCase = (TapCase) vppEndpointOptional.get().getInterfaceTypeChoice();
+ physAddress = tapCase.getPhysicalAddress().getValue();
+ LOG.trace("Resolved PhysicalAddress : {} for metadataInterfaceName: {}, on node: {}", physAddress
+ , metadataInterfaceName, hostName);
+ } else {
+ LOG.warn("PhysicalAddress was not resolved for metadataInterfaceName: {}, on node: {}",
+ metadataInterfaceName, hostName);
+ }
+ }
+
+ return physAddress;
}
public void handleEndpointDeleteForFlatOverlay(AddressEndpointWithLocation addressEp) {
Preconditions.checkArgument(interfaceNameOptional.isPresent());
- if (!putVrfInInterface(vppDataBroker, interfaceNameOptional.get(), vrf)) {
- LOG.warn("Failed to put interface {} to vrf {}", interfaceNameOptional.get(), vrf);
+ addInterfaceInVrf(vppDataBroker, interfaceNameOptional.get(), vrf);
+ }
+
+ private void addInterfaceInVrf(DataBroker vppDataBroker, String interfaceName, long vrf) {
+ if (!putVrfInInterface(vppDataBroker, interfaceName, vrf)) {
+ LOG.warn("Failed to put interface {} to vrf {}", interfaceName, vrf);
} else {
- LOG.debug("Added interface {} to vrf {}", interfaceNameOptional.get(), vrf);
+ LOG.debug("Added interface {} to vrf {}", interfaceName, vrf);
}
}
Preconditions.checkArgument(interfaceNameOptional.isPresent());
String interfaceName = interfaceNameOptional.get();
- InterfaceKey interfaceKey = new InterfaceKey(interfaceName);
- Ipv4AddressNoZone ip = new Ipv4AddressNoZone(overlayHelper.getInterfaceIp(addressEp));
+ addStaticArp(vppDataBroker, hostName, interfaceName, physicalAddress, overlayHelper.getInterfaceIp(addressEp));
+ }
- if (!putIpv4Neighbor(vppDataBroker, interfaceKey, new PhysAddress(physicalAddress), ip)) {
- LOG.warn("Failed to put static arp with interface {} for ip={} and physical-address={}", interfaceName,
- ip, physicalAddress);
+ private void addStaticArp(DataBroker vppDataBroker,
+ String hostName,
+ String interfaceName,
+ String physicalAddress,
+ Ipv4Address ipv4Address) {
+ Ipv4AddressNoZone ip = new Ipv4AddressNoZone(ipv4Address);
+ InterfaceKey interfaceKey = new InterfaceKey(interfaceName);
+ if (!putStaticArp(vppDataBroker,
+ interfaceKey,
+ new PhysAddress(physicalAddress),
+ ip)) {
+ LOG.warn("Failed to put static arp with interface {} for ip={} and physical-address={}",
+ interfaceName, ip, physicalAddress);
} else {
LOG.debug("Added Static arp ({} {}) in host {} for interface {}", ip, physicalAddress, hostName,
interfaceName);
}
}
- private boolean putIpv4Neighbor(DataBroker vppDataBroker,
+ private boolean putStaticArp(DataBroker vppDataBroker,
InterfaceKey interfaceKey,
PhysAddress physAddress,
Ipv4AddressNoZone ip) {
- StaticArpCommand.NeighborCommandBuilder neighborCommandBuilder = new StaticArpCommand.NeighborCommandBuilder();
+ StaticArpCommand.StaticArpCommandBuilder staticArpCommandBuilder = new StaticArpCommand.StaticArpCommandBuilder();
- neighborCommandBuilder.setOperation(General.Operations.PUT);
- neighborCommandBuilder.setInterfaceKey(interfaceKey);
- neighborCommandBuilder.setIp(ip);
- neighborCommandBuilder.setLinkLayerAddress(physAddress);
+ staticArpCommandBuilder.setOperation(General.Operations.PUT);
+ staticArpCommandBuilder.setInterfaceKey(interfaceKey);
+ staticArpCommandBuilder.setIp(ip);
+ staticArpCommandBuilder.setLinkLayerAddress(physAddress);
return GbpNetconfTransaction.netconfSyncedWrite(vppDataBroker,
- neighborCommandBuilder.build(), GbpNetconfTransaction.RETRY_COUNT);
+ staticArpCommandBuilder.build(), GbpNetconfTransaction.RETRY_COUNT);
}
private void addStaticRoute(AddressEndpointWithLocation addressEp) {
long vni = getVni(addressEp.getTenant().getValue());
long vrf = vni;
+ String outgoingInterfaceName = overlayHelper.getInterfaceName(addressEp).get();
+ Ipv4Address ipWithoutPrefix = overlayHelper.getInterfaceIp(addressEp);
+ Ipv4Prefix ipv4Prefix = overlayHelper.getInterfaceIpAsPrefix(addressEp);
+
+ addStaticRoute(vppDataBroker, hostName, vrf, ipWithoutPrefix, ipv4Prefix, outgoingInterfaceName);
+ }
+
+ private void addStaticRoute(DataBroker vppDataBroker, String hostName, long vrf, 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);
}
}
- String outgoingInterfaceName = overlayHelper.getInterfaceName(addressEp).get();
- Ipv4Address ipWithoutPrefix = overlayHelper.getInterfaceIp(addressEp);
-
if (staticRoutingHelper.endPointRoutingExists(outgoingInterfaceName, ipWithoutPrefix)) {
return;
}
- Ipv4Prefix ipv4Prefix = overlayHelper.getInterfaceIpAsPrefix(addressEp);
+ if (staticRoutingHelper.routeAlreadyExistsInHostVrf(hostName, vrf, ipWithoutPrefix)) {
+ LOG.warn("Ip already exists in host {} vrf {} ip {}", hostName, vrf, ipWithoutPrefix);
+ return;
+ }
if (!staticRoutingHelper.addSingleStaticRouteInRoutingProtocol(vppDataBroker,
- hostName,
- vrf,
- ipWithoutPrefix,
- ipv4Prefix,
- outgoingInterfaceName)) {
+ hostName,
+ vrf,
+ ipWithoutPrefix,
+ ipv4Prefix,
+ outgoingInterfaceName)) {
LOG.warn("Failed to add routing ({} via {}) in vrf {} in compute host {}!",
ipv4Prefix, outgoingInterfaceName, vrf, hostName);
} else {
*/
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<Ipv4Address> allIpsInVrf;
+
+ public RoutingInfo() {
+ allIpsInVrf = new HashSet<>();
+ }
public String getProtocolName() {
return ProtocolName;
return count;
}
- public void incrementCount() {
+ public void addIpInVrf(Ipv4Address ip) {
+ allIpsInVrf.add(ip);
+ incrementCount();
+ }
+
+ public boolean ipAlreadyExistsinVrf(Ipv4Address ip) {
+ return allIpsInVrf.contains(ip);
+ }
+
+ private void incrementCount() {
count++;
}
}
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.InterfaceNameToRouteInfoMapper;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.mappers.InterfaceNameToStaticInfoMapper;
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;
private HostVrfRoutingInformationMapper hostVrfInfo = HostVrfRoutingInformationMapper.getInstance();
- private InterfaceNameToRouteInfoMapper interfaceNameToRouteInfoMapper;
+ private InterfaceNameToStaticInfoMapper interfaceNameToStaticInfoMapper;
- public StaticRoutingHelper() {
- interfaceNameToRouteInfoMapper = new InterfaceNameToRouteInfoMapper();
+ public StaticRoutingHelper(InterfaceNameToStaticInfoMapper interfaceNameToStaticInfoMapper) {
+ this.interfaceNameToStaticInfoMapper = interfaceNameToStaticInfoMapper;
}
public synchronized boolean addRoutingProtocolForVrf(DataBroker vppDataBroker,
}
public boolean endPointRoutingExists(String interfaceName, Ipv4Address ip) {
- return interfaceNameToRouteInfoMapper.routeAlreadyExists(interfaceName, 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,
.child(Ipv4.class);
if (GbpNetconfTransaction.netconfSyncedMerge(vppDataBroker, iid, ipv4Route, GbpNetconfTransaction.RETRY_COUNT)) {
- interfaceNameToRouteInfoMapper.addRouteForInterface(outgoingInterface, nextHopAddress, routingId);
- hostVrfInfo.addStaticRoute(hostId, vrf);
+ interfaceNameToStaticInfoMapper.addRouteForInterface(outgoingInterface, nextHopAddress, routingId);
+ hostVrfInfo.addStaticRoute(hostId, vrf, nextHopAddress);
return true;
}
String hostId,
long vrf,
String outgoingInterface) {
- List<Long> allRoutingIdsForPort = interfaceNameToRouteInfoMapper.getRoutingIdsAssociatedWithInterface(outgoingInterface);
+ List<Long> allRoutingIdsForPort = interfaceNameToStaticInfoMapper.getRoutingIdsAssociatedWithInterface(outgoingInterface);
boolean allOk = true;
}
}
- interfaceNameToRouteInfoMapper.clearStaticRoutesForInterface(outgoingInterface);
+ interfaceNameToStaticInfoMapper.clearStaticRoutesForInterface(outgoingInterface);
return allOk;
}
public void createSimpleLoopbackIfNeeded(AddressEndpointWithLocation addressEp) {
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();
String subnetUuid = loopbackManagerHelper.getSubnet(addressEp);
}
private void createLoopbackInterface(String hostName, String subnetUuid, DataBroker vppDataBroker,
- LoopbackCommand loopbackCommand) throws LispConfigCommandFailedException {
+ LoopbackCommand loopbackCommand) throws LispConfigCommandFailedException {
if (GbpNetconfTransaction.netconfSyncedWrite(vppDataBroker,
- loopbackCommand,
- GbpNetconfTransaction.RETRY_COUNT)) {
+ loopbackCommand,
+ GbpNetconfTransaction.RETRY_COUNT)) {
subnetHostSpecificInfo.addLoopbackForHost(hostName, subnetUuid, loopbackCommand.getName(),
loopbackCommand.getVrfId());
subnetHostSpecificInfo.addNewPortInHostSubnet(hostName, subnetUuid);
Ipv4Prefix subnetPrefix = gbpSubnetInfo.getCidr().getIpv4Prefix();
Preconditions.checkNotNull(subnetPrefix, "Subnet CIDR found to be null for "
- + "subnet uuid =" + gbpSubnetInfo.getId() + "!");
+ + "subnet uuid =" + gbpSubnetInfo.getId() + "!");
Pair<Ipv4Address, Ipv4Address> startAndEndAddress = IpAddressUtil.getStartAndEndIp(subnetPrefix);
if (!putArpRangesCommand(vppDataBroker,
- vrf,
- startAndEndAddress.getLeft(),
- startAndEndAddress.getRight())) {
+ vrf,
+ startAndEndAddress.getLeft(),
+ startAndEndAddress.getRight())) {
throw new LispConfigCommandFailedException("Proxy arp configuration failed for subnet uuid: " +
- gbpSubnetInfo.getId() + "!");
+ gbpSubnetInfo.getId() + "!");
} else {
LOG.debug("Configured proxy arp for range {} to {} on node : {}!", startAndEndAddress.getLeft(),
startAndEndAddress.getRight(), hostName);
}
private void deleteProxyArpRange(DataBroker vppDataBroker,
- long vrf,
- GbpSubnet gbpSubnetInfo,
- String hostName) throws LispConfigCommandFailedException {
+ long vrf,
+ GbpSubnet gbpSubnetInfo,
+ String hostName) throws LispConfigCommandFailedException {
Ipv4Prefix subnetPrefix = gbpSubnetInfo.getCidr().getIpv4Prefix();
Preconditions.checkNotNull(subnetPrefix, "Subnet CIDR found to be null for "
Pair<Ipv4Address, Ipv4Address> startAndEndAddress = IpAddressUtil.getStartAndEndIp(subnetPrefix);
if (!deleteArpRangesCommand(vppDataBroker,
- vrf,
- startAndEndAddress.getLeft(),
- startAndEndAddress.getRight())) {
+ vrf,
+ startAndEndAddress.getLeft(),
+ startAndEndAddress.getRight())) {
throw new LispConfigCommandFailedException("Proxy arp configuration failed for subnet uuid: " +
gbpSubnetInfo.getId() + "!");
} else {
builder.setEndAddress(end);
return GbpNetconfTransaction.netconfSyncedWrite(vppDataBroker,
- builder.build(),
- GbpNetconfTransaction.RETRY_COUNT);
+ builder.build(),
+ GbpNetconfTransaction.RETRY_COUNT);
}
private boolean deleteArpRangesCommand(DataBroker vppDataBroker,
builder.setEndAddress(end);
return GbpNetconfTransaction.netconfSyncedDelete(vppDataBroker,
- builder.build(),
- GbpNetconfTransaction.RETRY_COUNT);
+ builder.build(),
+ GbpNetconfTransaction.RETRY_COUNT);
}
private void addUnnumberedInterface(AddressEndpointWithLocation addressEp, String loopbackName) throws LispConfigCommandFailedException {
.getSmallerSubnet(gbpSubnetInfo.getCidr().getIpv4Prefix());
RemoteEid firstREid = LispUtil.toRemoteEid(LispUtil.toLispIpv4Prefix(delegatingSubnets.getLeft()),
- vni,
- Ipv4PrefixAfi.class);
+ vni,
+ Ipv4PrefixAfi.class);
putGpeEntry(vppDataBroker, GPE_ENTRY_PREFIX + gbpSubnetInfo.getId() + "_1", firstREid, vni, vni);
if (delegatingSubnets.getLeft().equals(delegatingSubnets.getRight())) {
}
RemoteEid secondREid = LispUtil.toRemoteEid(LispUtil.toLispIpv4Prefix(delegatingSubnets.getRight()),
- vni,
- Ipv4PrefixAfi.class);
+ vni,
+ Ipv4PrefixAfi.class);
putGpeEntry(vppDataBroker, GPE_ENTRY_PREFIX + gbpSubnetInfo.getId() + "_2", secondREid, vni, vni);
} catch (LispHelperArgumentException e) {
--- /dev/null
+/*
+ * 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<String, String> 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);
+ }
+}
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;
return mapper.get(hostId).get(vrf).getProtocolName();
}
- public void addStaticRoute(String hostId, long vrf) {
+ public void addStaticRoute(String hostId, long vrf, Ipv4Address ip) {
HashMap<Long, RoutingInfo> routingInfoMapper = mapper.get(hostId);
Preconditions.checkNotNull(routingInfoMapper, "Routing protocol not created, can't add route entry");
Preconditions.checkNotNull(routingInfoMapper, "VRF was not created for this host");
- routingInfo.incrementCount();
+ routingInfo.addIpInVrf(ip);
}
public Long getEndPointCountInVrf(String hostId, long vrf) {
}
return (long) (count + 1);
}
+
+ public boolean ipAlreadyExistsInHostVrf(String hostId, long vrf, Ipv4Address ip) {
+ HashMap<Long, RoutingInfo> 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);
+ }
}
*/
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;
/**
* Created by Shakib Ahmed on 5/26/17.
*/
-public class InterfaceNameToRouteInfoMapper {
+public class InterfaceNameToStaticInfoMapper {
HashMap<String, StaticRouteInfoMapper> interfaceNameToStaticRouteMapper;
- public InterfaceNameToRouteInfoMapper() {
+ 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);
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.absolute.location.LocationType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.absolute.location.location.type.ExternalLocationCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.child.endpoints.ChildEndpoint;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.relative.location.relative.locations.ExternalLocation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev170511.IpPrefixType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev170511.MacAddressType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.ParentEndpointChoice;
return potentialVppDataProvider;
}
+ public Optional<DataBroker> getPotentialExternalDataBroker(ExternalLocation externalLocation) {
+ InstanceIdentifier<?> vppNodeIid = externalLocation.getExternalNodeMountPoint();
+
+ Optional<DataBroker> potentialVppDataProvider;
+ potentialVppDataProvider = mountedDataBrokerProvider.getDataBrokerForMountPoint(vppNodeIid);
+
+ Preconditions.checkState(potentialVppDataProvider.isPresent(), "Data Broker missing");
+
+ return potentialVppDataProvider;
+ }
+
public Optional<DataBroker> getPotentialExternalDataBroker(VppEndpoint vppEp) {
InstanceIdentifier<Node> vppNodeIid = VppIidFactory.getNetconfNodeIid(vppEp.getVppNodeId());
Optional<DataBroker> potentialVppDataProvider =
return Optional.fromNullable(hostId);
}
+ public Optional<String> getHostName(ExternalLocation externalLocation) {
+ NodeKey nodeKey = externalLocation.getExternalNodeMountPoint().firstKeyOf(Node.class);
+ String hostId = Preconditions.checkNotNull(nodeKey.getNodeId().getValue(),
+ "Host Id extraction failed from address endpoint: {}", externalLocation);
+
+ return Optional.fromNullable(hostId);
+ }
+
public ExternalLocationCase resolveAndValidateLocation(AddressEndpointWithLocation addrEpWithLoc) {
+ Preconditions.checkNotNull(addrEpWithLoc.getAbsoluteLocation(), "Absolute location for " +
+ "AddressEndpointWithLocation missing: " + addrEpWithLoc.toString() );
LocationType locationType = addrEpWithLoc.getAbsoluteLocation().getLocationType();
if (!(locationType instanceof ExternalLocationCase)) {
throw new IllegalArgumentException("Endpoint does not have external location " + addrEpWithLoc);
return VppPathMapper.interfacePathToInterfaceName(interfacePath);
}
+ public Optional<String> getInterfaceName(ExternalLocation externalLocation) {
+ String interfacePath = externalLocation.getExternalNodeConnector();
+ return VppPathMapper.interfacePathToInterfaceName(interfacePath);
+ }
+
public HmacKey getDefaultHmacKey() {
return LispUtil.toHmacKey(HmacKeyType.Sha196Key, LispStateManager.DEFAULT_XTR_KEY);
}
"in address endpoint: " + addressEp);
}
+ public boolean isMetadataPort(AddressEndpointWithLocation addedEp) {
+ return addedEp.getRelativeLocations() != null && addedEp.getRelativeLocations().getExternalLocation() != null;
+ }
+
public Routing getRouting(long vrf) {
return new RoutingBuilder().setIpv4VrfId(vrf).build();
}
public void createForwardingForEndpoint(RendererEndpointKey rEpKey, PolicyContext policyCtx) {
AddressEndpointWithLocation rEp = policyCtx.getAddrEpByKey().get(KeyFactory.addressEndpointKey(rEpKey));
- ExternalLocationCase rEpLoc = resolveAndValidateLocation(rEp);
- if (Strings.isNullOrEmpty(rEpLoc.getExternalNodeConnector())) {
- // TODO add it to the status for renderer manager
- LOG.info("Renderer endpoint does not have external-node-connector therefore it is ignored {}", rEp);
- return;
- }
if (ConfigUtil.getInstance().isLispOverlayEnabled()) {
lispStateManager.configureEndPoint(rEp);
if (ConfigUtil.getInstance().isL3FlatEnabled()) {
loopbackManager.createSimpleLoopbackIfNeeded(rEp);
}
}
+
+ ExternalLocationCase rEpLoc = resolveAndValidateLocation(rEp);
+ if (rEpLoc == null || Strings.isNullOrEmpty(rEpLoc.getExternalNodeConnector())) {
+ // TODO add it to the status for renderer manager
+ LOG.info("Renderer endpoint does not have external-node-connector therefore it is ignored {}", rEp);
+ return;
+ }
+
if (Strings.isNullOrEmpty(rEpLoc.getExternalNode())) {
java.util.Optional<String> optL2FloodDomain = resolveL2FloodDomain(rEp, policyCtx);
if (!optL2FloodDomain.isPresent()) {
private final AclManager aclManager;
public VppRendererPolicyManager(@Nonnull ForwardingManager fwManager, @Nonnull AclManager aclManager,
- @Nonnull DataBroker dataProvider) {
+ @Nonnull DataBroker dataProvider) {
this.fwManager = Preconditions.checkNotNull(fwManager);
this.dataProvider = Preconditions.checkNotNull(dataProvider);
this.aclManager = Preconditions.checkNotNull(aclManager);
SetMultimap<String, NodeId> removedVppNodesByL2Fd = HashMultimap.create();
SetMultimap<String, NodeId> createdVppNodesByL2Fd = HashMultimap.create();
for (Entry<String, ValueDifference<Collection<NodeId>>> entry : vppNodesByL2FlDiff.entriesDiffering()
- .entrySet()) {
+ .entrySet()) {
String bridgeDomain = entry.getKey();
Collection<NodeId> beforeNodes = entry.getValue().leftValue();
Collection<NodeId> afterNodes = entry.getValue().rightValue();
RendererForwarding rendererForwardingBefore = rPolicyBefore.getConfiguration().getRendererForwarding();
SetMultimap<String, NodeId> vppNodesByL2FdBefore =
- resolveVppNodesByL2Fd(policyCtxBefore.getPolicyTable().rowKeySet(), policyCtxBefore);
+ resolveVppNodesByL2Fd(policyCtxBefore.getPolicyTable().rowKeySet(), policyCtxBefore);
if (!vppNodesByL2FdBefore.isEmpty()) {
LOG.debug("Deleting DhcpRelay for forwarding: {}, on VPP nodes: {}", rendererForwardingBefore,
- vppNodesByL2FdBefore);
+ vppNodesByL2FdBefore);
fwManager.deleteDhcpRelay(rendererForwardingBefore, vppNodesByL2FdBefore);
}
}
if (rPolicyAfter.getConfiguration() != null) {
RendererForwarding rendererForwardingAfter = rPolicyAfter.getConfiguration().getRendererForwarding();
SetMultimap<String, NodeId> vppNodesByL2FdAfter =
- resolveVppNodesByL2Fd(policyCtxAfter.getPolicyTable().rowKeySet(), policyCtxAfter);
+ resolveVppNodesByL2Fd(policyCtxAfter.getPolicyTable().rowKeySet(), policyCtxAfter);
if (!vppNodesByL2FdAfter.isEmpty()) {
LOG.debug("Creating DhcpRelay for forwarding: {}, on VPP nodes: {}", rendererForwardingAfter,
- vppNodesByL2FdAfter);
+ vppNodesByL2FdAfter);
fwManager.createDhcpRelay(rendererForwardingAfter, vppNodesByL2FdAfter);
}
}
continue;
}
policy.getPolicy()
- .getConfiguration()
- .getRendererEndpoints()
- .getRendererEndpoint()
- .stream()
- .filter(rEp -> !updates.contains(rEp.getKey()))
- .forEach(rEp -> {
- for (PeerEndpoint pEp : rEp.getPeerEndpoint()) {
- for (RuleGroupWithRendererEndpointParticipation rg : pEp
- .getRuleGroupWithRendererEndpointParticipation()) {
- if (!diffRuleGroups.contains(
- new RuleGroupKey(rg.getContractId(), rg.getSubjectName(), rg.getTenantId()))) {
- continue;
- }
- if (!policy.equals(policyCtxBefore)) {
- updates.add(rEp.getKey());
- AddressEndpointKey k1 = AddressEndpointUtils.fromPeerEpKey(pEp.getKey());
- updates.add(AddressEndpointUtils.toRendererEpKey(k1));
+ .getConfiguration()
+ .getRendererEndpoints()
+ .getRendererEndpoint()
+ .stream()
+ .filter(rEp -> !updates.contains(rEp.getKey()))
+ .forEach(rEp -> {
+ for (PeerEndpoint pEp : rEp.getPeerEndpoint()) {
+ for (RuleGroupWithRendererEndpointParticipation rg : pEp
+ .getRuleGroupWithRendererEndpointParticipation()) {
+ if (!diffRuleGroups.contains(
+ new RuleGroupKey(rg.getContractId(), rg.getSubjectName(), rg.getTenantId()))) {
+ continue;
+ }
+ if (!policy.equals(policyCtxBefore)) {
+ updates.add(rEp.getKey());
+ AddressEndpointKey k1 = AddressEndpointUtils.fromPeerEpKey(pEp.getKey());
+ updates.add(AddressEndpointUtils.toRendererEpKey(k1));
+ }
}
}
- }
- });
+ });
}
for (RendererEndpointKey rEpKey : updates) {
aclManager.updateAclsForRendEp(rEpKey, policyCtxAfter);
}
private static MapDifference<String, Collection<NodeId>> createDiffForVppNodesByL2Fd(PolicyContext policyCtxBefore,
- PolicyContext policyCtxAfter) {
+ PolicyContext policyCtxAfter) {
ImmutableSet<RendererEndpointKey> rendEpsBefore = policyCtxBefore.getPolicyTable().rowKeySet();
ImmutableSet<RendererEndpointKey> rendEpsAfter = policyCtxAfter.getPolicyTable().rowKeySet();
SetMultimap<String, NodeId> vppNodesByL2FdBefore = resolveVppNodesByL2Fd(rendEpsBefore, policyCtxBefore);
}
private static SetMultimap<String, NodeId> resolveVppNodesByL2Fd(Set<RendererEndpointKey> rEpKeys,
- PolicyContext policyCtx) {
+ PolicyContext policyCtx) {
SetMultimap<String, NodeId> vppNodesByL2Fd = HashMultimap.create();
rEpKeys.stream()
- .map(rEpKey -> KeyFactory.addressEndpointKey(rEpKey))
- .map(addrEpKey -> policyCtx.getAddrEpByKey().get(addrEpKey))
- .collect(Collectors.toSet())
- .forEach(addrEpWithLoc -> {
- java.util.Optional<String> optL2Fd = ForwardingManager.resolveL2FloodDomain(addrEpWithLoc, policyCtx);
- if (optL2Fd.isPresent()) {
- ExternalLocationCase rEpLoc = ForwardingManager.resolveAndValidateLocation(addrEpWithLoc);
- if (rEpLoc != null) {
- InstanceIdentifier<?> externalNodeMountPoint = rEpLoc.getExternalNodeMountPoint();
- NodeId vppNode = externalNodeMountPoint.firstKeyOf(Node.class).getNodeId();
- vppNodesByL2Fd.put(optL2Fd.get(), vppNode);
+ .map(rEpKey -> KeyFactory.addressEndpointKey(rEpKey))
+ .map(addrEpKey -> policyCtx.getAddrEpByKey().get(addrEpKey))
+ .collect(Collectors.toSet())
+ .forEach(addrEpWithLoc -> {
+ java.util.Optional<String> optL2Fd = ForwardingManager.resolveL2FloodDomain(addrEpWithLoc, policyCtx);
+ if (optL2Fd.isPresent()) {
+ ExternalLocationCase rEpLoc = ForwardingManager.resolveAndValidateLocation(addrEpWithLoc);
+ if (rEpLoc != null) {
+ InstanceIdentifier<?> externalNodeMountPoint = rEpLoc.getExternalNodeMountPoint();
+ NodeId vppNode = externalNodeMountPoint.firstKeyOf(Node.class).getNodeId();
+ vppNodesByL2Fd.put(optL2Fd.get(), vppNode);
+ }
}
- }
- });
+ });
return vppNodesByL2Fd;
}
bdManager = new BridgeDomainManagerImpl(mountPointDataBroker);
lispStateManager = new LispStateManager(mountedDataProviderMock);
loopbackManager = new LoopbackManager(mountedDataProviderMock);
- flatOverlayManager = new FlatOverlayManager(mountedDataProviderMock);
+ flatOverlayManager = new FlatOverlayManager(dataBroker, mountedDataProviderMock);
dhcpRelayHandler = new DhcpRelayHandler(dataBroker, mountedDataProviderMock);
fwManager = new ForwardingManager(ifaceManager, aclManager, natManager, routingManager, bdManager,
lispStateManager, loopbackManager, flatOverlayManager, dhcpRelayHandler, dataBroker);
Code Review / groupbasedpolicy.git / commitdiff