EventBus dtoEventBus = new EventBus((exception, context) -> LOG.error("Could not dispatch event: {} to {}",
context.getSubscriber(), context.getSubscriberMethod(), exception));
vppEndpointListener = new VppEndpointListener(dataBroker, dtoEventBus);
- LispStateManager lispStateManager = new LispStateManager(mountDataProvider);
+ LispStateManager lispStateManager = new LispStateManager();
FlatOverlayManager flatOverlayManager = new FlatOverlayManager(dataBroker, mountDataProvider, vppEndpointListener);
- LoopbackManager loopbackManager = new LoopbackManager(mountDataProvider);
+ LoopbackManager loopbackManager = new LoopbackManager();
- interfaceManager = new InterfaceManager(mountDataProvider, dataBroker, flatOverlayManager);
+ interfaceManager = new InterfaceManager(mountDataProvider, dataBroker);
AclManager aclManager = new AclManager(mountDataProvider, interfaceManager);
NatManager natManager =
(ConfigUtil.getInstance().isL3FlatEnabled()) ? new DvrNatImpl(dataBroker) : new CentralizedNatImpl(
public class LoopbackCommandWrapper {
- public static LoopbackCommand simpleLoopbackPutCommand(String interfaceName,
- long vrf,
- IpAddress ipAddress,
- IpPrefix cidr) {
+ public static LoopbackCommand simpleLoopbackPutCommand(String interfaceName, long vrf, IpAddress ipAddress,
+ IpPrefix cidr) {
LoopbackCommand.LoopbackCommandBuilder simpleLoopbackCommandBuilder =
- simpleLoopbackCommandBuilder(interfaceName, vrf, ipAddress, cidr);
- simpleLoopbackCommandBuilder.setOperation(General.Operations.PUT);
+ simpleLoopbackCommandBuilder(interfaceName, vrf, ipAddress, cidr).setOperation(General.Operations.PUT);
return simpleLoopbackCommandBuilder.build();
}
- public static LoopbackCommand bviLoopbackPutCommand(String interfaceName,
- long vrf,
- IpAddress ipAddress,
- IpPrefix cidr,
- String bridgeDomainName) {
- LoopbackCommand.LoopbackCommandBuilder bviLoopbackCommandBuilder =
- bviLoopbackCommandBuilder(interfaceName, vrf, ipAddress, cidr, bridgeDomainName);
- bviLoopbackCommandBuilder.setOperation(General.Operations.PUT);
- return bviLoopbackCommandBuilder.build();
- }
-
- private static LoopbackCommand.LoopbackCommandBuilder simpleLoopbackCommandBuilder(String interfaceName,
- long vrf,
- IpAddress ipAddress,
- IpPrefix cidr) {
- LoopbackCommand.LoopbackCommandBuilder loopbackCommandBuilder = new LoopbackCommand.LoopbackCommandBuilder();
- loopbackCommandBuilder.setInterfaceName(interfaceName);
- loopbackCommandBuilder.setEnabled(true);
- loopbackCommandBuilder.setVrfId(vrf);
- loopbackCommandBuilder.setIpAddress(ipAddress);
- loopbackCommandBuilder.setIpPrefix(cidr);
- return loopbackCommandBuilder;
- }
-
- private static LoopbackCommand.LoopbackCommandBuilder bviLoopbackCommandBuilder(String interfaceName,
- long vrf,
- IpAddress ipAddress,
- IpPrefix cidr,
- String bridgeDomainName) {
- LoopbackCommand.LoopbackCommandBuilder simpleLoopbackCommandBuilder =
- simpleLoopbackCommandBuilder(interfaceName, vrf, ipAddress, cidr);
- simpleLoopbackCommandBuilder.setBridgeDomain(bridgeDomainName);
- simpleLoopbackCommandBuilder.setBvi(true);
- return simpleLoopbackCommandBuilder;
+ private static LoopbackCommand.LoopbackCommandBuilder simpleLoopbackCommandBuilder(String interfaceName, long vrf,
+ IpAddress ipAddress, IpPrefix cidr) {
+ return new LoopbackCommand.LoopbackCommandBuilder()
+ .setInterfaceName(interfaceName)
+ .setEnabled(true)
+ .setVrfId(vrf)
+ .setIpAddress(ipAddress)
+ .setIpPrefix(cidr);
}
}
package org.opendaylight.groupbasedpolicy.renderer.vpp.commands;
import com.google.common.base.Preconditions;
+
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.groupbasedpolicy.renderer.vpp.util.General;
}
/**
- * StaticArpCommand build method.
+ * UnnumberedInterfaceCommand build method.
*
* @return UnnumberedInterfaceCommand
* @throws IllegalArgumentException if useInterface or interfaceName is null.
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
public class ConfigureItrRemoteLocatorSetCommand extends AbstractLispCommand<ItrRemoteLocatorSet> {
- ItrRemoteLocatorSetDom itrRemoteLocatorSetDom;
+ private ItrRemoteLocatorSetDom itrRemoteLocatorSetDom;
public ConfigureItrRemoteLocatorSetCommand(ItrRemoteLocatorSetDom itrRemoteLocatorSetDom) {
this.itrRemoteLocatorSetDom = itrRemoteLocatorSetDom;
public class ConfigureLocalMappingInEidTableCommand extends AbstractLispCommand<LocalMapping> {
- LocalMappingDom localMappingDom;
+ private LocalMappingDom localMappingDom;
public ConfigureLocalMappingInEidTableCommand(LocalMappingDom localMappingDom) {
this.localMappingDom = localMappingDom;
public class ConfigureLocatorSetCommand extends AbstractLispCommand<LocatorSet> {
- LocatorSetDom locatorSetDom;
+ private LocatorSetDom locatorSetDom;
public ConfigureLocatorSetCommand(LocatorSetDom locatorSetDom) {
this.locatorSetDom = locatorSetDom;
public class ConfigureMapRegisterStatusCommand extends AbstractLispCommand<MapRegister>{
- MapRegisterDom mapRegisterDom;
+ private MapRegisterDom mapRegisterDom;
public ConfigureMapRegisterStatusCommand(MapRegisterDom mapRegisterDom) {
this.mapRegisterDom = mapRegisterDom;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
public class ConfigureMapResolverCommand extends AbstractLispCommand<MapResolver>{
- MapResolverDom mapResolverDom;
+ private MapResolverDom mapResolverDom;
public ConfigureMapResolverCommand(MapResolverDom mapResolverDom) {
this.mapResolverDom = mapResolverDom;
public class ConfigureVrfToVniMappingCommand extends AbstractLispCommand<VniTable> {
- VniTableDom vniTableDom;
+ private VniTableDom vniTableDom;
public ConfigureVrfToVniMappingCommand(VniTableDom vniTableDom) {
this.vniTableDom = vniTableDom;
+++ /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.commands.lisp;
-
-import org.opendaylight.groupbasedpolicy.renderer.vpp.util.VppIidFactory;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.gpe.rev170801.gpe.feature.data.grouping.GpeFeatureData;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-public class DeleteGpeFeatureDataCommand extends AbstractLispCommand<GpeFeatureData> {
- private static final Logger LOG = LoggerFactory.getLogger(DeleteGpeFeatureDataCommand.class);
-
- @Override
- public InstanceIdentifier<GpeFeatureData> getIid() {
- return VppIidFactory.getGpeFeatureDataIid();
- }
-
- @Override
- public GpeFeatureData getData() {
- LOG.debug("Delete commands should not invoke getData()");
- return null;
- }
-
- @Override public String toString() {
- return "Operation: " + getOperation() + ", Iid: " + this.getIid() + ", " + "DeleteGpeFeatureDataCommand{}";
- }
-}
package org.opendaylight.groupbasedpolicy.renderer.vpp.commands.lisp;
+import java.util.Collections;
+
import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.lisp.dom.GbpGpeEntryDom;
import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.lisp.dom.GpeEnableDom;
import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.lisp.dom.InterfaceDom;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev171013.map.resolvers.grouping.map.resolvers.MapResolver;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev171013.map.servers.grouping.map.servers.MapServer;
-import java.util.Arrays;
-
-/**
- * Created by Shakib Ahmed on 3/21/17.
- */
public class LispCommandWrapper {
public static AbstractLispCommand<Lisp> enableLisp() {
LispDom lispDom = new LispDom();
return new ConfigureLispStatusCommand(lispDom);
}
- public static AbstractLispCommand<LocatorSet> addLocatorSet(String locatorName,
- String interfaceName,
- short priority,
- short weight) {
+ public static AbstractLispCommand<LocatorSet> addLocatorSet(String locatorName, String interfaceName,
+ short priority, short weight) {
InterfaceDom interfaceDom = new InterfaceDom();
interfaceDom.setInterfaceName(interfaceName);
interfaceDom.setPriority(priority);
interfaceDom.setWeight(weight);
LocatorSetDom locatorSetDom = new LocatorSetDom();
- locatorSetDom.setInterfaces(Arrays.asList(interfaceDom.getSALObject()));
+ locatorSetDom.setInterfaces(Collections.singletonList(interfaceDom.getSALObject()));
locatorSetDom.setLocatorName(locatorName);
return new ConfigureLocatorSetCommand(locatorSetDom);
}
return new ConfigureMapServerCommand(mapServerDom);
}
- public static AbstractLispCommand<LocalMapping> addLocalMappingInEidTable(String mappingName,
- Eid eid,
- String locatorName,
- HmacKey hmacKey) {
+ public static AbstractLispCommand<LocalMapping> addLocalMappingInEidTable(String mappingName, Eid eid,
+ String locatorName, HmacKey hmacKey) {
LocalMappingDom localMappingDom = new LocalMappingDom();
localMappingDom.setMappingId(new MappingId(mappingName));
localMappingDom.setEid(eid);
return new ConfigureLocalMappingInEidTableCommand(localMappingDom);
}
- public static AbstractLispCommand<LocalMapping> deleteLocalMappingFromEidTable(String mappingName,
- long vni) {
+ public static AbstractLispCommand<LocalMapping> deleteLocalMappingFromEidTable(String mappingName, long vni) {
LocalMappingDom localMappingDom = new LocalMappingDom();
localMappingDom.setMappingId(new MappingId(mappingName));
localMappingDom.setVni(vni);
return new ConfigureGpeCommand(gpeEnableDom);
}
- public static AbstractLispCommand<GpeEntry> addGpeSendMapregisterAction(String entryName,
- RemoteEid rEid,
- long vni,
- long vrf) {
+ public static AbstractLispCommand<GpeEntry> addGpeSendMapregisterAction(String entryName, RemoteEid rEid, long vni,
+ long vrf) {
GbpGpeEntryDom gpeEntryDom = new GbpGpeEntryDom();
gpeEntryDom.setId(entryName);
gpeEntryDom.setRemoteEid(rEid);
return new ConfigureItrRemoteLocatorSetCommand(itrRemoteLocatorSetDom);
}
- public static AbstractLispCommand<NativeForwardPath> addNativeForwardEntry(long vrf,
- IpAddress nextHopIp) {
+ public static AbstractLispCommand<NativeForwardPath> addNativeForwardEntry(long vrf, IpAddress nextHopIp) {
NativeForwardPathDom nativeForwardPathDom = new NativeForwardPathDom();
nativeForwardPathDom.setVrfId(vrf);
nativeForwardPathDom.setNextHopIp(nextHopIp);
return new ConfigureNativeForwardPathCommand(nativeForwardPathDom);
}
- public static AbstractLispCommand<GpeFeatureData> deleteGpeFeatureData() {
- return new DeleteGpeFeatureDataCommand();
- }
-
public static AbstractLispCommand<NativeForwardPathsTables> deleteNativeForwardPathsTables() {
return new DeleteNativeForwardPathsTablesDeleteCommand();
}
import org.opendaylight.yangtools.yang.binding.DataObject;
-/**
- * Created by Shakib Ahmed on 3/20/17.
- */
public interface CommandModel {
<T extends DataObject> T getSALObject();
}
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;
private final MountedDataBrokerProvider mountDataProvider;
private final VppEndpointLocationProvider vppEndpointLocationProvider;
private final SetMultimap<NodeId, String> excludedFromPolicy = HashMultimap.create();
- private final FlatOverlayManager flatOverlayManager;
- public InterfaceManager(@Nonnull MountedDataBrokerProvider mountDataProvider, @Nonnull DataBroker dataProvider,
- FlatOverlayManager flatOverlayManager) {
+ public InterfaceManager(@Nonnull MountedDataBrokerProvider mountDataProvider, @Nonnull DataBroker dataProvider) {
this.mountDataProvider = Preconditions.checkNotNull(mountDataProvider);
this.vppEndpointLocationProvider = new VppEndpointLocationProvider(dataProvider);
- this.flatOverlayManager = flatOverlayManager;
}
@Subscribe
import org.opendaylight.groupbasedpolicy.renderer.vpp.util.GbpNetconfTransaction;
import org.opendaylight.groupbasedpolicy.renderer.vpp.util.General;
import org.opendaylight.groupbasedpolicy.renderer.vpp.util.LispUtil;
-import org.opendaylight.groupbasedpolicy.renderer.vpp.util.VppIidFactory;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Function;
-
public class LispStateCommandExecutor {
private static final Logger LOG = LoggerFactory.getLogger(LispStateCommandExecutor.class);
return executeCommand(nodeIid, lispStateCommand);
}
- public static <T extends DataObject> boolean executePutCommand(String hostName,
- AbstractLispCommand<T> lispStateCommand) {
+ static <T extends DataObject> boolean executePutCommand(String hostName, AbstractLispCommand<T> lispStateCommand) {
lispStateCommand.setOperation(General.Operations.PUT);
- return executeCommand(LispUtil.HOSTNAME_TO_IID.apply(hostName), lispStateCommand);
+ return executeCommand(LispUtil.hostnameToIid(hostName), lispStateCommand);
}
- public static <T extends DataObject> boolean executeMergeCommand(String hostName,
- AbstractLispCommand<T> lispStateCommand) {
+ static <T extends DataObject> boolean executeMergeCommand(String hostName, AbstractLispCommand<T> lispStateCommand) {
lispStateCommand.setOperation(General.Operations.MERGE);
- return executeCommand(LispUtil.HOSTNAME_TO_IID.apply(hostName), lispStateCommand);
+ return executeCommand(LispUtil.hostnameToIid(hostName), lispStateCommand);
}
public static <T extends DataObject> boolean executeDeleteCommand(InstanceIdentifier<Node> nodeIid,
return executeCommand(nodeIid, lispStateCommand);
}
- public static <T extends DataObject> boolean executeDeleteCommand(String hostName,
- AbstractLispCommand<T> lispStateCommand) {
+ static <T extends DataObject> boolean executeDeleteCommand(String hostName, AbstractLispCommand<T> lispStateCommand) {
lispStateCommand.setOperation(General.Operations.DELETE);
- return executeCommand(LispUtil.HOSTNAME_TO_IID.apply(hostName), lispStateCommand);
+ return executeCommand(LispUtil.hostnameToIid(hostName), lispStateCommand);
}
- public static <T extends DataObject> boolean executeCommand(InstanceIdentifier<Node> nodeIid,
- AbstractLispCommand<T> lispStateCommand) {
+ private static <T extends DataObject> boolean executeCommand(InstanceIdentifier<Node> nodeIid,
+ AbstractLispCommand<T> lispStateCommand) {
final boolean transactionState;
switch (lispStateCommand.getOperation()) {
case MERGE:
import java.util.Map;
import java.util.concurrent.ExecutionException;
-import javax.annotation.Nonnull;
-
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.lisp.AbstractLispCommand;
import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.lisp.LispCommandWrapper;
import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.exception.LispConfigCommandFailedException;
import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.exception.LispNotFoundException;
import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.flat.overlay.FlatOverlayManager;
-import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.flat.overlay.StaticRoutingHelper;
-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.info.container.states.PhysicalInterfaces;
import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.mappers.NeutronTenantToVniMapper;
import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.util.ConfigManagerHelper;
-import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.util.Constants;
import org.opendaylight.groupbasedpolicy.renderer.vpp.util.GbpNetconfTransaction;
import org.opendaylight.groupbasedpolicy.renderer.vpp.util.LispUtil;
-import org.opendaylight.groupbasedpolicy.renderer.vpp.util.MountedDataBrokerProvider;
import org.opendaylight.groupbasedpolicy.renderer.vpp.util.VppIidFactory;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.nat.rev150908.nat.config.nat.instances.nat.instance.MappingTable;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev170511.IpPrefixType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.endpoints.AddressEndpointWithLocation;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.gpe.rev170801.Gpe;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.gpe.rev170801.NativeForwardPathsTables;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.gpe.rev170801._native.forward.paths.tables._native.forward.paths.table.NativeForwardPath;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.gpe.rev170801.gpe.feature.data.grouping.GpeFeatureData;
private static final Logger LOG = LoggerFactory.getLogger(LispStateManager.class);
private HostRelatedInfoContainer hostRelatedInfoContainer;
- private MountedDataBrokerProvider mountedDataBrokerProvider;
private ConfigManagerHelper lispStateHelper;
private NeutronTenantToVniMapper neutronTenantToVniMapper;
// Node ID, VRF ID, route count
private Map<String, List<Long>> vnisByHostname = new HashMap<>();
- public LispStateManager(@Nonnull MountedDataBrokerProvider mountedDataBrokerProvider) {
- Preconditions.checkNotNull(mountedDataBrokerProvider,
- "MountedDataBrokerProvider found to be null!");
+ public LispStateManager() {
hostRelatedInfoContainer = HostRelatedInfoContainer.getInstance();
- this.mountedDataBrokerProvider= mountedDataBrokerProvider;
- this.lispStateHelper = new ConfigManagerHelper(this.mountedDataBrokerProvider);
+ this.lispStateHelper = new ConfigManagerHelper();
neutronTenantToVniMapper = NeutronTenantToVniMapper.getInstance();
}
try {
boolean lispEnabled = enableLispOnHost(hostName);
- Optional<GpeFeatureData> gpeFeatureDataOptional = GbpNetconfTransaction.read(VppIidFactory.getNetconfNodeIid(new NodeId(hostName)),
+ Optional<GpeFeatureData> gpeFeatureDataOptional =
+ GbpNetconfTransaction.read(VppIidFactory.getNetconfNodeIid(new NodeId(hostName)),
LogicalDatastoreType.CONFIGURATION, VppIidFactory.getGpeFeatureDataIid(),
GbpNetconfTransaction.RETRY_COUNT);
LOG.trace("configureHostIfNeeded -> GpeOnHostFeatureData: {}", gpeFeatureDataOptional);
if (!gpeFeatureDataOptional.isPresent() || !gpeFeatureDataOptional.get().isEnable()) {
- enableGpeOnHostIfNeeded(hostName);
+ if (!enableGpeOnHostIfNeeded(hostName)) {
+ LOG.trace("configureHostIfNeeded -> Gpe on host: {} cannot be enabled.", hostName);
+ }
LOG.trace("configureHostIfNeeded -> GpeOnHostFeatureData were cleared");
}
if (LispStateCommandExecutor.executePutCommand(hostName, addLocatorSetCommand)) {
addExtraItrRlocLocatorSetIfNeeded(hostName, lispDataInterfaceName);
} else {
- LOG.warn("Failed to write locator set: {} -> {} to host: {}", locatorSetName, lispDataInterfaceName, hostName);
+ LOG.warn("Failed to write locator set: {} -> {} to host: {}", locatorSetName, lispDataInterfaceName,
+ hostName);
}
} catch (InterruptedException | ExecutionException e) {
throw new LispNotFoundException("No interface with Ip Address found!");
private void addVniSpecificConfigurationsIfNeeded(String hostName, long vni, long vrf) {
- if (vnisByHostname.get(hostName) != null && !vnisByHostname.get(hostName).contains(Long.valueOf(vni))) {
+ if (vnisByHostname.get(hostName) != null && !vnisByHostname.get(hostName).contains(vni)) {
if (addVniToVrfMapping(hostName, vni, vrf)) {
if (!addGpeNativeForwardPath(hostName, vrf, hostRelatedInfoContainer.getPhysicalInterfaceState(hostName)
.getIp(PhysicalInterfaces.PhysicalInterfaceType.PUBLIC))) {
if (vnisByHostname.get(hostname)!= null && vnisByHostname.get(hostname).size() == 0) {
//safe to delete lisp
deleteLispStatesFromHost(hostname);
- deleteNativeForwardPathsTables(hostname);
+ if (!deleteNativeForwardPathsTables(hostname)) {
+ LOG.warn("Failed to delete native forward paths tables from host: {}", hostname);
+ }
vnisByHostname.remove(hostname);
}
private void deleteLispStatesFromHost(String hostname) throws LispConfigCommandFailedException {
- /*AbstractLispCommand<LispFeatureData> deleteLispFeatureData = LispCommandWrapper.deleteLispFeatureData();
-
- if (LispStateCommandExecutor.executeDeleteCommand(endpointHost.getHostName(), deleteLispFeatureData)) {
- hostRelatedInfoContainer.deleteLispStateOfHost(endpointHost.getHostName());
- LOG.debug("Deleted all lisp data {}, for host {}",
- hostRelatedInfoContainer.getLispStateOfHost(endpointHost.getHostName()), endpointHost.getHostName());
- } else {
- throw new LispConfigCommandFailedException("Lisp delete feature data command failed!");
- }
- */
-
- //Todo workaround to delete only inside data not whole lisp-feature-data
+ //Todo workaround to delete only inside data not whole lisp-feature-data at once
// (causes VPP to crash https://jira.fd.io/browse/HC2VPP-242) remove when fixed
- InstanceIdentifier<Node> nodeIid = LispUtil.HOSTNAME_TO_IID.apply(hostname);
+ InstanceIdentifier<Node> nodeIid = LispUtil.hostnameToIid(hostname);
Optional<Lisp> lispOptional =
GbpNetconfTransaction.read(nodeIid, LogicalDatastoreType.CONFIGURATION,
InstanceIdentifier.create(Lisp.class), GbpNetconfTransaction.RETRY_COUNT);
return neutronTenantToVniMapper.getVni(tenantUuid);
}
- public static void cleanLisp(String hostName)
+ private static void cleanLisp(String hostName)
throws LispConfigCommandFailedException {
if (LispStateCommandExecutor.executeDeleteCommand(hostName, LispCommandWrapper.deleteLispFeatureData())) {
LOG.debug("Deleted all lisp data for host {}",hostName);
import com.google.common.base.Preconditions;
import com.google.common.eventbus.Subscribe;
+
+import javax.annotation.Nonnull;
+
import org.opendaylight.groupbasedpolicy.renderer.vpp.event.GbpSubnetEvent;
import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.loopback.LoopbackManager;
-import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.mappers.SubnetUuidToGbpSubnetMapper;
-import org.opendaylight.groupbasedpolicy.renderer.vpp.util.MountedDataBrokerProvider;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.GbpSubnet;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import javax.annotation.Nonnull;
-
-/**
- * Created by Shakib Ahmed on 5/3/17.
- */
public class GbpSubnetEventManager {
private static final Logger LOG = LoggerFactory.getLogger(GbpSubnetEventManager.class);
- private SubnetUuidToGbpSubnetMapper subnetUuidToGbpSubnetInfoMapper;
private LoopbackManager loopbackManager;
public GbpSubnetEventManager(@Nonnull LoopbackManager loopbackManager) {
this.loopbackManager = loopbackManager;
- this.subnetUuidToGbpSubnetInfoMapper = SubnetUuidToGbpSubnetMapper.getInstance();
}
@Subscribe
}
private void processSubnetCreated(String subnetUuid, GbpSubnet subnetInfo) {
- //subnetUuidToGbpSubnetInfoMapper.addSubnetInfo(subnetUuid, subnetInfo);
loopbackManager.gbpSubnetCreated(subnetUuid, subnetInfo);
}
private void processSubnetDeleted(String subnetUuid) {
- //subnetUuidToGbpSubnetInfoMapper.removeSubnetInfo(subnetUuid);
loopbackManager.gbpSubnetdeleted(subnetUuid);
}
}
package org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.exception;
-/**
- * Created by Shakib Ahmed on 3/31/17.
- */
-public class LispHelperArgumentException extends Exception {
- public LispHelperArgumentException(final String message) {
+public class LispArgumentException extends Exception {
+ public LispArgumentException(final String message) {
super(message);
}
}
package org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.flat.overlay;
+import com.google.common.base.Optional;
+
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.StaticArpCommand;
import org.opendaylight.groupbasedpolicy.renderer.vpp.iface.VppPathMapper;
-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.PhysicalInterfaces;
-import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.states.PortInterfaces;
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.lisp.util.IpAddressUtil;
import org.opendaylight.groupbasedpolicy.renderer.vpp.listener.VppEndpointListener;
import org.opendaylight.groupbasedpolicy.renderer.vpp.routing.RoutingManager;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev170511.IpPrefixType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.endpoints.AddressEndpointWithLocation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.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.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpointKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.interfaces._interface.Routing;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
-
public class FlatOverlayManager {
private static final Logger LOG = LoggerFactory.getLogger(FlatOverlayManager.class);
public FlatOverlayManager(@Nonnull DataBroker dataBroker,
@Nonnull MountedDataBrokerProvider mountedDataBrokerProvider,
@Nonnull VppEndpointListener vppEndpointListener) {
- this.overlayHelper = new ConfigManagerHelper(mountedDataBrokerProvider);
+ this.overlayHelper = new ConfigManagerHelper();
staticRoutingHelper = new StaticRoutingHelper();
this.dataBroker = dataBroker;
this.vppEndpointListener = vppEndpointListener;
}
private void addInterfaceInVrf(String hostName, String interfaceName, long vrf) {
- if (hostRelatedInfoContainer.getPortInterfaceStateOfHost(hostName)
- .isVrfConfiguredForInterface(interfaceName)) {
- return;
- }
-
if (!putVrfInInterface(hostName, interfaceName, vrf)) {
LOG.warn("Failed to put interface {} to vrf {}", interfaceName, vrf);
} else {
- hostRelatedInfoContainer
- .getPortInterfaceStateOfHost(hostName)
- .initializeRoutingContextForInterface(interfaceName, vrf);
- LOG.debug("Added interface {} to vrf {}", interfaceName, vrf);
+ LOG.trace("Added interface {} to vrf {}", interfaceName, vrf);
}
}
InstanceIdentifier<Routing> iid = VppIidFactory.getRoutingIid(new InterfaceKey(interfaceName));
RoutingBuilder builder = new RoutingBuilder();
builder.setIpv4VrfId(vrf);
- return GbpNetconfTransaction.netconfSyncedWrite(LispUtil.HOSTNAME_TO_IID.apply(hostName), iid,
+ return GbpNetconfTransaction.netconfSyncedWrite(LispUtil.hostnameToIid(hostName), iid,
builder.build(), GbpNetconfTransaction.RETRY_COUNT);
}
staticArpCommandBuilder.setIp(ip);
staticArpCommandBuilder.setLinkLayerAddress(physAddress);
- return GbpNetconfTransaction.netconfSyncedWrite(LispUtil.HOSTNAME_TO_IID.apply(hostName),
+ return GbpNetconfTransaction.netconfSyncedWrite(LispUtil.hostnameToIid(hostName),
staticArpCommandBuilder.build(), GbpNetconfTransaction.RETRY_COUNT);
}
Map<String, String> hostnamesAndIntfcs = new HashMap<>();
if (addressEp.getRelativeLocations() != null
&& addressEp.getRelativeLocations().getExternalLocation() != null) {
- LOG.trace("deleteStaticRoutingEntry -> addresEp locations: {}", addressEp.getRelativeLocations().getExternalLocation());
+ LOG.trace("deleteStaticRoutingEntry -> addresEp locations: {}",
+ addressEp.getRelativeLocations().getExternalLocation());
addressEp.getRelativeLocations().getExternalLocation().forEach(externalLocation -> {
Optional<String> interfaceOptional =
VppPathMapper.interfacePathToInterfaceName(externalLocation.getExternalNodeConnector());
private boolean addStaticRoute(Long routeId, String hostName, long vrfId, Ipv4Address ipWithoutPrefix,
Ipv4Prefix ipv4Prefix, String outgoingInterfaceName) {
if (vrfsByHostname.get(hostName) == null || !vrfsByHostname.get(hostName).keySet().contains(vrfId)) {
- if (staticRoutingHelper.addRoutingProtocolForVrf(LispUtil.HOSTNAME_TO_IID.apply(hostName), vrfId)) {
+ if (staticRoutingHelper.addRoutingProtocolForVrf(LispUtil.hostnameToIid(hostName), vrfId)) {
addStaticRouteToPublicInterface(hostName, vrfId);
countPlusPlus(hostName, vrfId);
}
Map<String, String> hostnamesAndIntfcs = resolveIntfcsByHosts(addressEp);
LOG.trace("deleteStaticRoutingEntry -> addresEp locations: {}", addressEp);
hostnamesAndIntfcs.entrySet().forEach(intfcsByHost -> {
- LOG.trace("deleteStaticRoutingEntry -> Deleting addresEp: {} for interface: {}, on node: {}", addressEp.getKey(), intfcsByHost.getValue(), intfcsByHost.getKey());
+ LOG.trace("deleteStaticRoutingEntry -> Deleting addresEp: {} for interface: {}, on node: {}",
+ addressEp.getKey(), intfcsByHost.getValue(), intfcsByHost.getKey());
Ipv4Address ipWithoutPrefix = ConfigManagerHelper.getInterfaceIp(addressEp);
- if (!staticRoutingHelper.deleteSingleStaticRouteFromRoutingProtocol(intfcsByHost.getKey(), vrfId, routeId.get())) {
+ if (!staticRoutingHelper.deleteSingleStaticRouteFromRoutingProtocol(intfcsByHost.getKey(), vrfId,
+ routeId.get())) {
LOG.warn("Failed to delete route ({} via {}) from vrf {} from host{}", ipWithoutPrefix,
intfcsByHost.getValue(), vrfId, intfcsByHost);
} else {
- LOG.trace("deletedStaticRoutingEntry -> Deleted addresEp: {} for interface: {}, on node: {}", addressEp.getKey(), intfcsByHost.getValue(), intfcsByHost.getKey());
+ LOG.trace("deletedStaticRoutingEntry -> Deleted addresEp: {} for interface: {}, on node: {}",
+ addressEp.getKey(), intfcsByHost.getValue(), intfcsByHost.getKey());
countMinusMinus(intfcsByHost.getKey(), vrfId);
if (getRouteCount(intfcsByHost.getKey(), vrfId) <= 1) {
LOG.info("deletedStaticRoutingEntry -> Removing route to public int from VRF {}", vrfId);
}
}
LOG.trace("deleteStaticRoutingEntry -> flushPendingVppEndpoint for addresEp: {}", addressEp);
- hostRelatedInfoContainer.deleteRouteFromIntfc(intfcsByHost.getKey(), intfcsByHost.getValue(), routeId.get());
+ hostRelatedInfoContainer.deleteRouteFromIntfc(intfcsByHost.getKey(), intfcsByHost.getValue(),
+ routeId.get());
vppEndpointListener.flushPendingVppEndpoint(intfcsByHost.getKey(), intfcsByHost.getValue());
LOG.debug("Delete Static Route ({} via {}) from vrf {} from host {}", ipWithoutPrefix,
intfcsByHost.getValue(), vrfId, intfcsByHost);
*/
package org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.flat.overlay;
-import com.google.common.base.Preconditions;
-
import java.util.Collections;
import java.util.List;
-import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.LispStateManager;
-import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.exception.LispConfigCommandFailedException;
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.lisp.util.IpAddressUtil;
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;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class StaticRoutingHelper {
+class StaticRoutingHelper {
private static final Logger LOG = LoggerFactory.getLogger(StaticRoutingHelper.class);
private HostRelatedInfoContainer hostRelatedInfoContainer = HostRelatedInfoContainer.getInstance();
InstanceIdentifier<RoutingProtocol> iid = VppIidFactory
.getRoutingInstanceIid(builder.getKey());
- if (GbpNetconfTransaction.netconfSyncedWrite(nodeIid, iid, builder.build(),
- GbpNetconfTransaction.RETRY_COUNT)) {
- return true;
- }
- return false;
+ return GbpNetconfTransaction.netconfSyncedWrite(nodeIid, iid, builder.build(),
+ GbpNetconfTransaction.RETRY_COUNT);
}
synchronized boolean addSingleStaticRouteInRoutingProtocol(Long routeId, String hostName, long portVrfId,
return false;
}
- public synchronized static boolean deleteSingleStaticRouteFromRoutingProtocol(String hostName, long vrfId, Long routeId) {
- LOG.trace("deleteSingleStaticRouteFromRoutingProtocol -> deleting route. id: {}, vrf: {}, hostName: {}", routeId, vrfId, hostName);
+ synchronized boolean deleteSingleStaticRouteFromRoutingProtocol(String hostName, long vrfId, Long routeId) {
+ LOG.trace("deleteSingleStaticRouteFromRoutingProtocol -> deleting route. id: {}, vrf: {}, hostName: {}",
+ routeId, vrfId, hostName);
String protocolName = Constants.ROUTING_PROTOCOL_NAME_PREFIX + vrfId;
InstanceIdentifier<Route> iid = VppIidFactory
GbpNetconfTransaction.RETRY_COUNT);
}
- public static RoutingProtocolKey getRoutingProtocolName(long vrf) {
+ static RoutingProtocolKey getRoutingProtocolName(long vrf) {
return new RoutingProtocolKey(Constants.ROUTING_PROTOCOL_NAME_PREFIX + vrf);
}
}
+++ /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.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;
- }
-}
*/
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 org.opendaylight.groupbasedpolicy.renderer.vpp.listener.VppEndpointListener;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
import com.google.common.base.Preconditions;
import com.google.common.collect.HashBasedTable;
-import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import com.google.common.collect.Table;
import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
import java.util.Set;
-/**
- * Created by Shakib Ahmed on 7/13/17.
- */
+import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.info.container.states.PhysicalInterfaces;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.listener.VppEndpointListener;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
public class HostRelatedInfoContainer {
- private HashMap<String, LispState> hostNameToLispStateMapper;
private HashMap<String, PhysicalInterfaces> hostNameToPhysicalInterfacesMapper;
- private HashMap<String, PortInterfaces> hostNameToPortInterfacesMapper;
- private HashMap<String, VrfHolder> hostNameToVrfHolderMapper;
- //route IDs on an interface on a host
+ //route IDs on an interface on a host
private Table<String, String, Set<Long>> routeIdsByHostByVrf = HashBasedTable.create();
-
+
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 void addRouteToIntfc(String hostname, String intfName, Long routeId) {
}
private static final Logger LOG = LoggerFactory.getLogger(VppEndpointListener.class);
-
+
public boolean intfcIsBusy(String hostname, String intfName) {
Preconditions.checkNotNull(hostname);
Preconditions.checkNotNull(intfName);
if (routeIdsByHostByVrf.get(hostname, intfName) != null) {
int size = routeIdsByHostByVrf.get(hostname, intfName).size();
- LOG.trace("ISPORTBUSY -> hostname: {}, inftName: {}, entries: {}", hostname, intfName, routeIdsByHostByVrf.get(hostname, intfName));
- return (size == 0) ? false : true;
+ LOG.trace("ISPORTBUSY -> hostname: {}, inftName: {}, entries: {}", hostname, intfName,
+ routeIdsByHostByVrf.get(hostname, intfName));
+ return size != 0;
}
LOG.trace("ISPORTBUSY -> not busy interface on hostname: {}, inftName: {}", hostname, intfName);
return false;
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 removePhysicalInterfaceStateOfHost(String hostName) {
+ //TODO should be called when host is removed
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.get(hostName);
- }
-
- public VrfHolder initializeVrfStateOfHost(String hostName) {
- return hostNameToVrfHolderMapper.computeIfAbsent(hostName, key -> new VrfHolder());
- }
-
- public int getVrfStateOfHostCount(String hostName) {
- VrfHolder vrfHolder = hostNameToVrfHolderMapper.get(hostName);
- return vrfHolder != null ? vrfHolder.vrfStateCount() : 0;
- }
-
- public void removeVrfStateOfHost(String hostName) {
- hostNameToVrfHolderMapper.remove(hostName);
- }
}
+++ /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.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.rev171013.dp.subtable.grouping.local.mappings.local.mapping.Eid;
-
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-
-/**
- * Created by Shakib Ahmed on 3/29/17.
- */
-public class LispState {
- private boolean lispEnabled;
- private boolean gpeEnabled;
- private HashMap<String, String> interfaceNameToLocatorSetNameMapper;
- private Set<IpAddress> mapServerIpAddressSet;
- private Set<IpAddress> mapResolverIpAddressSet;
- private Set<Long> vniSet;
- private Set<Eid> eidSet;
-
- public LispState() {
- lispEnabled = false;
- interfaceNameToLocatorSetNameMapper = new HashMap<>();
- mapServerIpAddressSet = new HashSet<>();
- mapResolverIpAddressSet = new HashSet<>();
- vniSet = new HashSet<>();
- eidSet = new HashSet<>();
- }
-
- public boolean isLispEnabled() {
- return lispEnabled;
- }
-
- public void setLispEnabled(boolean lispEnabled) {
- this.lispEnabled = lispEnabled;
- }
-
- public boolean isGpeEnabled() {
- return gpeEnabled;
- }
-
- public void setGpeEnabled(boolean gpeEnabled) {
- this.gpeEnabled = gpeEnabled;
- }
-
- public String getLocIntfToLocSetNameMapping(String locatorIntf) {
- return interfaceNameToLocatorSetNameMapper.get(locatorIntf);
- }
-
- public void setLocIntfToLocSetNameMapping(String locIntfName, String locSetName) {
- interfaceNameToLocatorSetNameMapper.put(locIntfName, locSetName);
- }
-
- public Set<Map.Entry<String, String>> getLocatorSetEntry() {
- return interfaceNameToLocatorSetNameMapper.entrySet();
- }
-
- public int getLocatorCount() {
- return interfaceNameToLocatorSetNameMapper.size();
- }
-
- public boolean mapServerSetContains(IpAddress ip) {
- return mapServerIpAddressSet.contains(ip);
- }
-
- public void addInMapServerSet(IpAddress ip) {
- mapServerIpAddressSet.add(ip);
- }
-
- public boolean mapResolverSetContains(IpAddress ip) {
- return mapResolverIpAddressSet.contains(ip);
- }
-
- public void addInMapResolverSet(IpAddress ip) {
- mapResolverIpAddressSet.add(ip);
- }
-
- public boolean isVniConfigured(long vni) {
- return vniSet.contains(vni);
- }
-
- public int vniSetCount() {
- return vniSet == null ? 0 : vniSet.size();
- }
-
- public void addInVniSet(long vni) {
- vniSet.add(vni);
- }
-
- public boolean eidSetContains(Eid eid) {
- return eidSet.contains(eid);
- }
-
- public int eidCount() {
- return eidSet.size();
- }
-
- public void addEidInEidSet(Eid eid) {
- eidSet.add(eid);
- }
- public void deleteEid(Eid eid) {
- eidSet.remove(eid);
- }
-
- public void deleteEidSet() {
- eidSet.clear();
- }
-
- public void deleteVniSet() {
- vniSet.clear();
- }
-
- public void deleteLocators() {
- interfaceNameToLocatorSetNameMapper.clear();
- }
-
- @Override public String toString() {
- return "LispState{" + "lispEnabled=" + lispEnabled + ", gpeEnabled=" + gpeEnabled
- + ", interfaceNameToLocatorSetNameMapper=" + interfaceNameToLocatorSetNameMapper
- + ", mapServerIpAddressSet=" + mapServerIpAddressSet + ", mapResolverIpAddressSet="
- + mapResolverIpAddressSet + ", vniSet=" + vniSet + ", eidSet=" + eidSet + '}';
- }
-}
+++ /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.info.container.states;
-
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Set;
-
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-public class PortInterfaces {
- private HashMap<String, PortRouteState> interfaceNameToPortRouteStateMapper;
- private Set<String> metadataInterfaceSet;
- private static final Logger LOG = LoggerFactory.getLogger(PortInterfaces.class);
-
-
- 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) {
- PortRouteState portRouteState = interfaceNameToPortRouteStateMapper.get(interfaceName);
- if (portRouteState != null) {
- return portRouteState.getVrfId();
- }
- return null;
- }
-
- public void removePortInterface(String interfaceName) {
- metadataInterfaceSet.remove(interfaceName);
- interfaceNameToPortRouteStateMapper.remove(interfaceName);
- }
-
- public boolean isRoutingContextForInterfaceInitialized(String interfaceName) {
- return interfaceNameToPortRouteStateMapper.get(interfaceName) != null;
- }
-
- @Override public String toString() {
- return "PortInterfaces{" + "interfaceNameToPortRouteStateMapper=" + interfaceNameToPortRouteStateMapper
- + ", metadataInterfaceSet=" + metadataInterfaceSet + '}';
- }
-}
+++ /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.info.container.states;
-
-import com.google.common.collect.Lists;
-
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-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<Ipv4Address, String> ipToSubnetUuidMapper;
- private HashMap<Ipv4Address, Long> 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<Ipv4Address> getAllIps() {
- return new ArrayList<>(ipToRouteIdMapper.keySet());
- }
-
- public boolean isPortRouteStateEmpty() {
- return (ipToRouteIdMapper.size() == 0 && ipToSubnetUuidMapper.size() == 0);
- }
-
- @Override public String toString() {
- return "PortRouteState= {vrfId= " + vrfId + ", ipToSubnetUuidMapper= " + ipToSubnetUuidMapper + ", ipToRouteIdMapper= " + ipToRouteIdMapper + "}";
- }
-}
+++ /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.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<Ipv4Address, Long> 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<Ipv4Address> getAllIps() {
- return new ArrayList<>(ipToRouteIdMapper.keySet());
- }
-
- @Override public String toString() {
- return "RouteState{" + "ipToRouteIdMapper=" + ipToRouteIdMapper + '}';
- }
-}
+++ /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.info.container.states;
-
-import java.util.HashMap;
-
-public class SubnetHolder {
- private HashMap<String, SubnetState> subnetUuidToSubnetStateMapper;
-
- public SubnetHolder() {
- subnetUuidToSubnetStateMapper = new HashMap<>();
- }
-
- public SubnetState getSubnetState(String subnetUuid) {
- return subnetUuidToSubnetStateMapper.get(subnetUuid);
- }
-
- public SubnetState initializeSubnetState (String subnetUuid) {
- return subnetUuidToSubnetStateMapper.computeIfAbsent(subnetUuid,
- key -> new SubnetState());
- }
-
- public void removeSubnetState(String subnetUuid) {
- subnetUuidToSubnetStateMapper.remove(subnetUuid);
- }
-
- public int subnetHolderCount() {
- return subnetUuidToSubnetStateMapper.size();
- }
-
- public boolean subnetStateContains(String subnetUuid) {
- return subnetUuidToSubnetStateMapper.get(subnetUuid) != null;
- }
-
- @Override public String toString() {
- return "SubnetHolder: { subnetUuidToSubnetStateMapper: {}" + subnetUuidToSubnetStateMapper + "}";
- }
-}
+++ /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.info.container.states;
-
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.util.HashSet;
-import java.util.Set;
-
-/**
- * Created by Shakib Ahmed on 7/17/17.
- */
-public class SubnetState {
- private String gwInterfaceName;
- private Set<Ipv4Address> ipsInSubnet;
-
- private static final Logger LOG = LoggerFactory.getLogger(SubnetState.class);
-
-
- 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);
- LOG.trace("SubnetState -> added IP: {} to SubnetState: {}", portIp, this);
- }
-
- public boolean isIpPresent(Ipv4Address portIp) {
- return ipsInSubnet.contains(portIp);
- }
-
- public void removeIp(Ipv4Address portIp) {
- ipsInSubnet.remove(portIp);
- LOG.trace("SubnetState -> removed IP: {} from SubnetState: {}", portIp, this);
- }
-
- public Set<Ipv4Address> getIpsInSubnet() {
- return ipsInSubnet;
- }
-
- @Override public String toString() {
- return "SubnetState{" + "gwInterfaceName='" + gwInterfaceName + '\'' + ", ipsInSubnet=" + ipsInSubnet + '}';
- }
-}
+++ /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.info.container.states;
-
-import java.util.HashMap;
-
-/**
- * Created by Shakib Ahmed on 7/17/17.
- */
-public class VrfHolder {
- HashMap<Long, VrfState> 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 VrfState removeVrfState(Long vrfId) {
- return vrfIdToVrfStateMapper.remove(vrfId);
- }
-
- public boolean hasVrf(Long vrfId) {
- return vrfIdToVrfStateMapper.containsKey(vrfId);
- }
-
- public int vrfStateCount() {
- return vrfIdToVrfStateMapper.size();
- }
-
- @Override public String toString() {
- return "VrfHolder{" + "vrfIdToVrfStateMapper=" + vrfIdToVrfStateMapper + '}';
- }
-}
+++ /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.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;
-
-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) {
- if (subnetHolder.subnetStateContains(portSubnetUuid)) {
- subnetHolder.getSubnetState(portSubnetUuid).removeIp(portIp);
- }
- }
-
- public int subnetCount() {
- return subnetHolder.subnetHolderCount();
- }
-
- @Override public String toString() {
- return "VrfState{" + "subnetHolder=" + subnetHolder + ", protocolName='" + protocolName + '\''
- + ", nextRouteId=" + nextRouteId + '}';
- }
-}
import java.util.List;
import java.util.Map;
-import javax.annotation.Nonnull;
-
import org.apache.commons.lang3.tuple.Pair;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.LoopbackCommand;
import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.lisp.LispCommandWrapper;
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.exception.LispArgumentException;
import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.flat.overlay.FlatOverlayManager;
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.LispUtil;
-import org.opendaylight.groupbasedpolicy.renderer.vpp.util.MountedDataBrokerProvider;
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;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix;
public class LoopbackManager {
private static final Logger LOG = LoggerFactory.getLogger(LoopbackManager.class);
- private ConfigManagerHelper loopbackManagerHelper;
+ private ConfigManagerHelper configManagerHelper;
private Table<NodeKey, String, List<String>> unnumberedCache = HashBasedTable.create();
private NeutronTenantToVniMapper neutronTenantToVniMapper = NeutronTenantToVniMapper.getInstance();
- Map<String, GbpSubnet> GbpSubnetCache = new HashMap<>();
- Map<String, List<LoopBackDetails>> loopBackHostnames = new HashMap<>();
+ private Map<String, GbpSubnet> GbpSubnetCache = new HashMap<>();
+ private Map<String, List<LoopBackDetails>> loopBackHostnames = new HashMap<>();
private class LoopBackDetails {
- LoopbackCommand loopbackCommand;
- String hostName;
+ private LoopbackCommand loopbackCommand;
+ private String hostName;
- public LoopbackCommand getLoopbackCommand() {
+ LoopbackCommand getLoopbackCommand() {
return loopbackCommand;
}
- public void setLoopbackCommand(LoopbackCommand loopbackCommand) {
+ void setLoopbackCommand(LoopbackCommand loopbackCommand) {
this.loopbackCommand = loopbackCommand;
}
- public String getHostName() {
+ String getHostName() {
return hostName;
}
- public void setHostName(String hostName) {
+ void setHostName(String hostName) {
this.hostName = hostName;
}
}
- public LoopbackManager(@Nonnull MountedDataBrokerProvider mountedDataBrokerProvider) {
- this.loopbackManagerHelper = new ConfigManagerHelper(mountedDataBrokerProvider);
+ public LoopbackManager() {
+ this.configManagerHelper = new ConfigManagerHelper();
}
public void createSimpleLoopbackIfNeeded(AddressEndpointWithLocation addressEp) {
try {
long vni = getVni(addressEp.getTenant().getValue());
long vrfId = vni;
- String subnetUuid = loopbackManagerHelper.getSubnet(addressEp);
+ String subnetUuid = configManagerHelper.getSubnet(addressEp);
GbpSubnet gbpSubnetInfo = GbpSubnetCache.get(subnetUuid);
String loopIntfcName = Constants.GW_NAME_PREFIX + subnetUuid;
GbpNetconfTransaction.RETRY_COUNT);
if (!optionalLoopback.isPresent()) {
LoopbackCommand simpleLoopbackCommand =
- LoopbackCommandWrapper.simpleLoopbackPutCommand(loopIntfcName, vrfId, gbpSubnetInfo.getGatewayIp(),
- gbpSubnetInfo.getCidr());
+ LoopbackCommandWrapper.simpleLoopbackPutCommand(loopIntfcName, vrfId,
+ gbpSubnetInfo.getGatewayIp(), gbpSubnetInfo.getCidr());
if (createLoopbackInterface(hostname, simpleLoopbackCommand)) {
addGpeEntry(VppIidFactory.getNetconfNodeIid(new NodeId(hostname)), gbpSubnetInfo, vni);
addProxyArpRange(hostname, vrfId, gbpSubnetInfo);
}
}
} else {
- LOG.trace("Loopback already present on host: {} skip update for: {} - {} in vrf: {}", hostname, loopIntfcName, gbpSubnetInfo.getGatewayIp(), vrfId);
+ LOG.trace("Loopback already present on host: {} skip update for: {} - {} in vrf: {}", hostname,
+ loopIntfcName, gbpSubnetInfo.getGatewayIp(), vrfId);
}
}
private boolean addUnnumberedInterface(String hostname, String neutronInterfaceName, String loopbackName) {
InstanceIdentifier<Node> nodeIid = VppIidFactory.getNetconfNodeIid(new NodeId(hostname));
if (neutronInterfaceName.equalsIgnoreCase(loopbackName)) {
- LOG.trace("No need to configure unnumbered for loopback: {} on host: {}. skip processing.", loopbackName, neutronInterfaceName);
+ LOG.trace("No need to configure unnumbered for loopback: {} on host: {}. skip processing.", loopbackName,
+ neutronInterfaceName);
return true;
}
- LOG.trace("Adding unnumbered configuration hostname: {}, interface: {} use : {}", hostname, neutronInterfaceName, loopbackName);
+ LOG.trace("Adding unnumbered configuration hostname: {}, interface: {} use : {}", hostname,
+ neutronInterfaceName, loopbackName);
boolean unnumberWritten = putUnnumberedInterface(nodeIid, neutronInterfaceName, loopbackName);
if (unnumberWritten) {
if (unnumberedCache.get(nodeIid.firstKeyOf(Node.class), loopbackName) != null) {
unnumberedCache.get(nodeIid.firstKeyOf(Node.class), loopbackName).add(neutronInterfaceName);
} else {
- unnumberedCache.put(nodeIid.firstKeyOf(Node.class), loopbackName, Lists.newArrayList(neutronInterfaceName));
+ unnumberedCache.put(nodeIid.firstKeyOf(Node.class), loopbackName,
+ Lists.newArrayList(neutronInterfaceName));
}
LOG.debug("Added Interface {} as unnumbered for {}", loopbackName, neutronInterfaceName);
}
if (!putGpeEntry(iid, Constants.GPE_ENTRY_PREFIX + gbpSubnetInfo.getId() + "_2", secondREid, vni, vni)) {
LOG.warn("Failed to write GPE entry: {}", Constants.GPE_ENTRY_PREFIX + gbpSubnetInfo.getId() + "_2");
}
- } catch (LispHelperArgumentException e) {
+ } catch (LispArgumentException e) {
e.printStackTrace();
}
}
if (loopBackDetails != null) {
loopBackDetails.forEach(loopbackDetail -> {
- InstanceIdentifier<Node> iid = VppIidFactory.getNetconfNodeIid(new NodeId(loopbackDetail.getHostName()));
+ InstanceIdentifier<Node> iid =
+ VppIidFactory.getNetconfNodeIid(new NodeId(loopbackDetail.getHostName()));
if (deleteSpecificLoopback(iid, loopIntfcName)) {
- if (!deleteProxyArpRange(loopbackDetail.getHostName(), loopbackDetail.getLoopbackCommand().getVrfId(), gbpSubnet)) {
- LOG.warn("Failed to delete ProxyArpRange: {} on host: {}", gbpSubnet.getAllocationPools(), loopbackDetail.getHostName());
+ if (!deleteProxyArpRange(loopbackDetail.getHostName(),
+ loopbackDetail.getLoopbackCommand().getVrfId(), gbpSubnet)) {
+ LOG.warn("Failed to delete ProxyArpRange: {} on host: {}", gbpSubnet.getAllocationPools(),
+ loopbackDetail.getHostName());
}
if (!deleteGpeEntry(iid, Constants.GPE_ENTRY_PREFIX + gbpSubnet.getId() + "_1")) {
- LOG.warn("Failed to delete gpeEntry: {} on host: {}", Constants.GPE_ENTRY_PREFIX + gbpSubnet.getId() + "_1", loopbackDetail.getHostName());
+ LOG.warn("Failed to delete gpeEntry: {} on host: {}",
+ Constants.GPE_ENTRY_PREFIX + gbpSubnet.getId() + "_1", loopbackDetail.getHostName());
}
if (!deleteGpeEntry(iid, Constants.GPE_ENTRY_PREFIX + gbpSubnet.getId() + "_2")) {
- LOG.warn("Failed to delete gpeEntry: {} on host: {}", Constants.GPE_ENTRY_PREFIX + gbpSubnet.getId() + "_2", loopbackDetail.getHostName());
+ LOG.warn("Failed to delete gpeEntry: {} on host: {}",
+ Constants.GPE_ENTRY_PREFIX + gbpSubnet.getId() + "_2", loopbackDetail.getHostName());
}
if (!deleteGpeFeatureData(loopbackDetail.getHostName())) {
LOG.warn("Failed to delete gpe configuration: {} on host: {}", loopbackDetail.getHostName());
+++ /dev/null
-/*
- * 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.loopback;
-
-import com.google.common.base.Preconditions;
-
-/**
- * Created by Shakib Ahmed on 5/16/17.
- */
-public class SubnetHostInfo {
- private String interfaceName;
- private int portCount;
-
- public SubnetHostInfo(String interfaceName) {
- this.interfaceName = interfaceName;
- this.portCount = 0;
- }
-
- public String getInterfaceName() {
- return interfaceName;
- }
-
- public void setInterfaceName(String interfaceName) {
- this.interfaceName = interfaceName;
- }
-
- public void incrementPortCount() {
- portCount++;
- }
-
- public void decrementPortCount() {
- Preconditions.checkArgument(portCount > 0, "No port to decrement");
- portCount--;
- }
-
- public int incrementAndGetPortCount() {
- incrementPortCount();
- return portCount;
- }
-
- public int decrementAndGetPortCount() {
- decrementPortCount();
- return portCount;
- }
-
- public int getPortCount() {
- return portCount;
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2017 Cisco Systems, Inc. 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.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.GbpSubnet;
-
-import java.util.HashMap;
-
-/**
- * Created by Shakib Ahmed on 5/3/17.
- */
-public class SubnetUuidToGbpSubnetMapper {
-
- private HashMap<String, GbpSubnet> subnetInformation;
-
- private static SubnetUuidToGbpSubnetMapper INSTANCE = new SubnetUuidToGbpSubnetMapper();
-
- private SubnetUuidToGbpSubnetMapper() {
- subnetInformation = new HashMap<>();
- }
-
- public static SubnetUuidToGbpSubnetMapper getInstance() {
- return INSTANCE;
- }
-
- public void addSubnetInfo(String subnetUuid, GbpSubnet subnetInfo) {
- subnetInformation.put(subnetUuid, subnetInfo);
- }
-
- public GbpSubnet getSubnetInfo(String subnetUuid) {
- return subnetInformation.get(subnetUuid);
- }
-
- public void removeSubnetInfo(String subnetUuid) {
- subnetInformation.remove(subnetUuid);
- }
-}
import com.google.common.util.concurrent.ListenableFuture;
import java.util.List;
-import java.util.Map;
-import java.util.Set;
import javax.annotation.Nonnull;
-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.config.ConfigUtil;
import org.opendaylight.groupbasedpolicy.renderer.vpp.iface.VppPathMapper;
import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.LispStateManager;
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.info.container.states.PhysicalInterfaces;
import org.opendaylight.groupbasedpolicy.renderer.vpp.util.GbpNetconfTransaction;
import org.opendaylight.groupbasedpolicy.renderer.vpp.util.InterfaceUtil;
import org.opendaylight.groupbasedpolicy.renderer.vpp.util.LispUtil;
-import org.opendaylight.groupbasedpolicy.renderer.vpp.util.MountedDataBrokerProvider;
-import org.opendaylight.groupbasedpolicy.renderer.vpp.util.VppIidFactory;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev140508.EthernetCsmacd;
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.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.network.containment.containment.NetworkDomainContainment;
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.base_endpoint.rev160427.parent.child.endpoints.ParentEndpointChoice;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.ParentEndpointCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev170511.L3Context;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev170511.MacAddressType;
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.VppEndpoint;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev171013.HmacKeyType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev171013.dp.subtable.grouping.local.mappings.local.mapping.Eid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev171013.hmac.key.grouping.HmacKey;
-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.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class ConfigManagerHelper {
private static final Logger LOG = LoggerFactory.getLogger(ConfigManagerHelper.class);
- private MountedDataBrokerProvider mountedDataBrokerProvider;
- public ConfigManagerHelper(MountedDataBrokerProvider mountedDataBrokerProvider) {
- this.mountedDataBrokerProvider = mountedDataBrokerProvider;
+ public ConfigManagerHelper() {
}
.getName(PhysicalInterfaces.PhysicalInterfaceType.PUBLIC);
final Optional<InterfacesState> opInterfaceState =
- GbpNetconfTransaction.read(LispUtil.HOSTNAME_TO_IID.apply(hostName), LogicalDatastoreType.OPERATIONAL,
+ GbpNetconfTransaction.read(LispUtil.hostnameToIid(hostName), LogicalDatastoreType.OPERATIONAL,
InstanceIdentifier.create(InterfacesState.class), GbpNetconfTransaction.RETRY_COUNT);
if (!opInterfaceState.isPresent()) {
}
final Optional<Interfaces> opInterfaces =
- GbpNetconfTransaction.read(LispUtil.HOSTNAME_TO_IID.apply(hostName), LogicalDatastoreType.CONFIGURATION,
+ GbpNetconfTransaction.read(LispUtil.hostnameToIid(hostName), LogicalDatastoreType.CONFIGURATION,
InstanceIdentifier.create(Interfaces.class), GbpNetconfTransaction.RETRY_COUNT);
return false;
}
- final org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.Ipv4 ipv4 =
- augIntf.getIpv4();
+ final org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.Ipv4
+ ipv4 = augIntf.getIpv4();
if (ipv4 == null) {
return false;
}
- final List<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.ipv4.Address> addresses =
- ipv4.getAddress();
+ final List<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.ipv4.Address>
+ addresses = ipv4.getAddress();
if (addresses == null || addresses.isEmpty()) {
return false;
}
public String getLispCpRlocInterfaceName(@Nonnull String hostName) {
List<Interface> operationalInterfaceList =
- InterfaceUtil.getOperationalInterfaces(LispUtil.HOSTNAME_TO_IID.apply(hostName));
+ InterfaceUtil.getOperationalInterfaces(LispUtil.hostnameToIid(hostName));
if (operationalInterfaceList == null) {
return null;
}
}
- public String getFirstLocatorSetName(LispState lispState) {
- Set<Map.Entry<String, String >> locatorSet = lispState.getLocatorSetEntry();
- Preconditions.checkNotNull(locatorSet, "No locator set found!");
- if (!locatorSet.iterator().hasNext()) {
- return null;
- }
-
- return locatorSet.iterator().next().getValue();
- }
-
public Optional<String> getInterfaceName(AddressEndpointWithLocation addedEp) {
ExternalLocationCase epLoc = resolveAndValidateLocation(addedEp);
String interfacePath = epLoc.getExternalNodeConnector();
return LispUtil.toHmacKey(HmacKeyType.Sha196Key, LispStateManager.DEFAULT_XTR_KEY);
}
- public String getPhysicalAddress(AddressEndpointWithLocation addressEp) {
- String physicalAddress = null;
-
- if (addressEp.getAddressType().equals(MacAddressType.class)) {
- physicalAddress = addressEp.getAddress();
- } else {
- List<ChildEndpoint> childEndpoints = addressEp.getChildEndpoint();
- for (ChildEndpoint childEndpoint : childEndpoints) {
- if (childEndpoint.getAddressType().equals(MacAddressType.class)) {
- physicalAddress = childEndpoint.getAddress();
- break;
- }
- }
- }
- return Preconditions.checkNotNull(physicalAddress, "Physical address not found " +
- "in address endpoint: " + addressEp);
- }
-
- public boolean hasRelativeLocations(AddressEndpointWithLocation addedEp) {
- return addedEp.getRelativeLocations() != null && addedEp.getRelativeLocations().getExternalLocation() != null;
- }
public static boolean isMetadataPort(AddressEndpointWithLocation addressEp) {
return 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();
- }
}
*/
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 = "local-metadata-subnet";
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";
- public static final String PUBLIC_SUBNET_UUID = "public-interface-subnet-uuid";
}
package org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.util;
import com.google.common.net.InetAddresses;
+
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.apache.commons.lang3.tuple.Pair;
import org.apache.commons.net.util.SubnetUtils;
-import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.exception.LispHelperArgumentException;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.lisp.exception.LispArgumentException;
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.Ipv4Prefix;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import java.net.InetAddress;
-import java.net.UnknownHostException;
-
-/**
- * Created by Shakib Ahmed on 5/3/17.
- */
public class IpAddressUtil {
private static final Logger LOG = LoggerFactory.getLogger(IpAddressUtil.class);
- public static boolean isMetadataIp(Ipv4Address ipv4Address) {
+ static boolean isMetadataIp(Ipv4Address ipv4Address) {
return ipv4Address.getValue().equals(Constants.METADATA_IP);
}
return new ImmutablePair<>(lowIp, highIp);
}
- public static Pair<Ipv4Prefix, Ipv4Prefix> getSmallerSubnet(Ipv4Prefix ipv4Prefix) throws LispHelperArgumentException {
+ public static Pair<Ipv4Prefix, Ipv4Prefix> getSmallerSubnet(Ipv4Prefix ipv4Prefix) throws LispArgumentException {
String cidrNotion = ipv4Prefix.getValue();
SubnetUtils subnetUtils = new SubnetUtils(cidrNotion);
secondSubnet = secondAddress + "/" + maskLen;
} catch (UnknownHostException e) {
LOG.warn("Failed to translate IP address " + cidrNotion+ " to smaller subnet");
- throw new LispHelperArgumentException("Invalid argument for subnet " + cidrNotion);
+ throw new LispArgumentException("Invalid argument for subnet " + cidrNotion);
}
return new ImmutablePair<>(new Ipv4Prefix(firstSubnet), new Ipv4Prefix(secondSubnet));
}
return new Ipv4Prefix(ipv4Address.getValue() + "/32");
}
- public static boolean ipInRange(Ipv4Address ip, String startIpStr, String endIpStr) {
+ static boolean ipInRange(Ipv4Address ip, String startIpStr, String endIpStr) {
String ipStr = ip.getValue();
int startLim = InetAddresses.coerceToInteger(InetAddresses.forString(startIpStr));
return (startUnsigned <= ipNumUnsigned) && (ipNumUnsigned <= endUnsigned);
}
- public static String startIpOfSubnet(String cidrNotion) {
+ static String startIpOfSubnet(String cidrNotion) {
return new SubnetUtils(cidrNotion).getInfo().getLowAddress();
}
- public static String endIpOfSubnet(String cidrNotion) {
+ static String endIpOfSubnet(String cidrNotion) {
return new SubnetUtils(cidrNotion).getInfo().getHighAddress();
}
- public static int maskLen(String cidrNotion) {
+ static int maskLen(String cidrNotion) {
return Integer.valueOf(cidrNotion.split("/")[1]);
}
-}
\ No newline at end of file
+}
package org.opendaylight.groupbasedpolicy.renderer.vpp.listener;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.HashBasedTable;
+import com.google.common.collect.Table;
+import com.google.common.eventbus.EventBus;
+
+import javax.annotation.Nonnull;
+
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
import org.opendaylight.groupbasedpolicy.renderer.vpp.config.ConfigUtil;
import org.opendaylight.groupbasedpolicy.renderer.vpp.event.VppEndpointConfEvent;
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.util.DataTreeChangeHandler;
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.config.VppEndpoint;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Preconditions;
-import com.google.common.collect.HashBasedTable;
-import com.google.common.collect.Table;
-import com.google.common.eventbus.EventBus;
-
-import javax.annotation.Nonnull;
-
public class VppEndpointListener extends DataTreeChangeHandler<VppEndpoint> {
private static final Logger LOG = LoggerFactory.getLogger(VppEndpointListener.class);
InstanceIdentifier<VppEndpoint> rootIdentifier) {
if (ConfigUtil.getInstance().isL3FlatEnabled()) {
VppEndpoint vppEndpointBefore = rootNode.getDataBefore();
+ Preconditions.checkNotNull(vppEndpointBefore, "VppEndpoint cannot be null on delete operation.");
LOG.trace("onDelete -> Vppendpoint deleted: {}", vppEndpointBefore);
Preconditions.checkArgument(vppEndpointBefore.getVppNodeId() != null);
Preconditions.checkArgument(vppEndpointBefore.getVppInterfaceName() != null);
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import com.google.common.base.Function;
-
-/**
- * Created by Shakib Ahmed on 3/21/17.
- */
public class LispUtil {
private LispUtil() {
}
- public static Function<String, InstanceIdentifier<Node>> HOSTNAME_TO_IID = host -> {
- return VppIidFactory.getNetconfNodeIid(new NodeId(host));
- };
+ public static InstanceIdentifier<Node> hostnameToIid(String hostName) {
+ return VppIidFactory.getNetconfNodeIid(new NodeId(hostName));
+ }
public static Eid toEid(Address address, long vni, Class<? extends LispAddressFamily> addressType) {
EidDom eidDom = new EidDom();
dataBroker = getDataBroker();
Mockito.when(mountedDataProviderMock.resolveDataBrokerForMountPoint(Mockito.any(InstanceIdentifier.class)))
.thenReturn(Optional.of(mountPointDataBroker));
- manager = new InterfaceManager(mountedDataProviderMock, dataBroker, flatOverlayManager);
+ manager = new InterfaceManager(mountedDataProviderMock, dataBroker);
}
@Test
Mockito.when(mountedDataProviderMock.resolveDataBrokerForMountPoint(Mockito.any(InstanceIdentifier.class)))
.thenReturn(Optional.of(mountPointDataBroker));
vppEndpointListener = new VppEndpointListener(dataBroker, dtoEventBus);
- lispStateManager = new LispStateManager(mountedDataProviderMock);
- loopbackManager = new LoopbackManager(mountedDataProviderMock);
+ lispStateManager = new LispStateManager();
+ loopbackManager = new LoopbackManager();
flatOverlayManager = new FlatOverlayManager(dataBroker, mountedDataProviderMock, vppEndpointListener);
- ifaceManager = new InterfaceManager(mountedDataProviderMock, dataBroker, flatOverlayManager);
+ ifaceManager = new InterfaceManager(mountedDataProviderMock, dataBroker);
aclManager = new AclManager(mountedDataProviderMock, ifaceManager);
natManager = new CentralizedNatImpl(dataBroker);
routingManager = new RoutingManager(dataBroker, mountedDataProviderMock);
Code Review / groupbasedpolicy.git / commitdiff