+++ /dev/null
-/*
- * Copyright (c) 2016 Ericsson India Global Services Pvt Ltd. 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.netvirt.vpnmanager;
-
-import java.util.Objects;
-import org.opendaylight.genius.mdsalutil.NwConstants;
-
-public enum ArpReplyOrRequest {
- REQUEST("ARP-REQUEST"), REPLY("ARP-REPLY");
-
- private String name;
-
- ArpReplyOrRequest(String name) {
- this.name = name;
- }
-
- public String getName() {
- return this.name;
- }
-
- public int getArpOperation() {
- int arpOperation =
- (Objects.equals(name, ArpReplyOrRequest.REQUEST.getName())
- ? NwConstants.ARP_REQUEST : NwConstants.ARP_REPLY);
- return arpOperation;
- }
-
- public int calculateConsistentHashCode() {
- if (this.name != null) {
- return this.name.hashCode();
- } else {
- return 0;
- }
- }
-}
import org.opendaylight.infrautils.utils.concurrent.JdkFutures;
import org.opendaylight.netvirt.vpnmanager.api.ICentralizedSwitchProvider;
import org.opendaylight.netvirt.vpnmanager.api.VpnHelper;
+import org.opendaylight.netvirt.vpnmanager.iplearn.ipv4.ArpUtils;
import org.opendaylight.netvirt.vpnmanager.utilities.VpnManagerCounters;
import org.opendaylight.openflowplugin.libraries.liblldp.BitBufferHelper;
import org.opendaylight.openflowplugin.libraries.liblldp.BufferException;
long PER_VPN_INSTANCE_OPDATA_MAX_WAIT_TIME_IN_MILLISECONDS = 180000;
int ELAN_GID_MIN = 200000;
int INVALID_LABEL = 0;
- String ARP_MONITORING_ENTITY = "arpmonitoring";
+
+ String IP_MONITORING_ENTITY = "ipmonitoring";
+ String IP_MONITOR_JOB_PREFIX_KEY = "ip-monitor";
// An IdPool for Pseudo LPort tags, that is, lportTags that are no related to an interface.
// These lportTags must be higher than 170000 to avoid collision with interface LportTags and
import org.opendaylight.netvirt.vpnmanager.api.InterfaceUtils;
import org.opendaylight.netvirt.vpnmanager.api.VpnExtraRouteHelper;
import org.opendaylight.netvirt.vpnmanager.api.VpnHelper;
+import org.opendaylight.netvirt.vpnmanager.iplearn.model.MacEntry;
import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnAfConfig;
import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInstances;
import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInterfaces;
private static final Logger LOG = LoggerFactory.getLogger(VpnUtil.class);
- static final int SINGLE_TRANSACTION_BROKER_NO_RETRY = 1;
+ public static final int SINGLE_TRANSACTION_BROKER_NO_RETRY = 1;
private final DataBroker dataBroker;
private final IdManagerService idManager;
}
}
- void createLearntVpnVipToPort(String vpnName, String fixedIp, String
- portName, String macAddress, TypedWriteTransaction<Operational> writeOperTxn) {
+ public void createLearntVpnVipToPort(String vpnName, String fixedIp, String portName, String macAddress,
+ TypedWriteTransaction<Operational> writeOperTxn) {
synchronized ((vpnName + fixedIp).intern()) {
InstanceIdentifier<LearntVpnVipToPort> id = buildLearntVpnVipToPortIdentifier(vpnName, fixedIp);
LearntVpnVipToPortBuilder builder =
return id;
}
- void removeLearntVpnVipToPortEvent(String eventId, TypedWriteTransaction<Operational> writeOperTxn) {
+ public void removeLearntVpnVipToPortEvent(String eventId, TypedWriteTransaction<Operational> writeOperTxn) {
InstanceIdentifier<LearntVpnVipToPortEvent> id = buildLearntVpnVipToPortEventIdentifier(eventId);
if (writeOperTxn != null) {
writeOperTxn.delete(id);
}
- void removeMipAdjAndLearntIp(String vpnName, String vpnInterface, String prefix) {
+ public void removeMipAdjAndLearntIp(String vpnName, String vpnInterface, String prefix) {
synchronized ((vpnName + prefix).intern()) {
InstanceIdentifier<LearntVpnVipToPort> id = buildLearntVpnVipToPortIdentifier(vpnName, prefix);
MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
return extNetwork != null ? extNetwork.getVpnid() : null;
}
- List<Uuid> getExternalNetworkRouterIds(Uuid networkId) {
+ public List<Uuid> getExternalNetworkRouterIds(Uuid networkId) {
Networks extNetwork = getExternalNetwork(networkId);
return extNetwork != null ? extNetwork.getRouterIds() : Collections.emptyList();
}
}
}
- Optional<IpAddress> getIpv4GatewayAddressFromInterface(String srcInterface) {
+ public Optional<IpAddress> getIpv4GatewayAddressFromInterface(String srcInterface) {
Optional<IpAddress> gatewayIp = Optional.absent();
if (neutronVpnService != null) {
//TODO(Gobinath): Need to fix this as assuming port will belong to only one Subnet would be incorrect"
return gatewayIp;
}
- Optional<String> getGWMacAddressFromInterface(MacEntry macEntry, IpAddress gatewayIp) {
+ public Optional<String> getGWMacAddressFromInterface(MacEntry macEntry, IpAddress gatewayIp) {
Optional<String> gatewayMac = Optional.absent();
long vpnId = getVpnId(macEntry.getVpnName());
InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn
return optionalSubnets.isPresent() ? optionalSubnets.get() : null;
}
- Uuid getSubnetFromExternalRouterByIp(Uuid routerId, String ip) {
+ public Uuid getSubnetFromExternalRouterByIp(Uuid routerId, String ip) {
Routers externalRouter = getExternalRouter(routerId.getValue());
if (externalRouter != null && externalRouter.getExternalIps() != null) {
for (ExternalIps externalIp : externalRouter.getExternalIps()) {
return false;
}
}
+
+ public static String buildIpMonitorJobKey(String ip, String vpnName) {
+ return VpnConstants.IP_MONITOR_JOB_PREFIX_KEY + "-" + vpnName + "-" + ip;
+ }
}
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class AbstractIpLearnNotificationHandler {
+public abstract class AbstractIpLearnNotificationHandler {
private static final Logger LOG = LoggerFactory.getLogger(AbstractIpLearnNotificationHandler.class);
* 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.netvirt.vpnmanager;
+package org.opendaylight.netvirt.vpnmanager.iplearn;
import com.google.common.base.Optional;
import java.util.Map;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.infrautils.utils.concurrent.JdkFutures;
import org.opendaylight.netvirt.neutronvpn.interfaces.INeutronVpnManager;
+import org.opendaylight.netvirt.vpnmanager.VpnUtil;
+import org.opendaylight.netvirt.vpnmanager.iplearn.model.MacEntry;
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.inet.types.rev130715.Ipv4Address;
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.genius.alivenessmonitor.rev160411.AlivenessMonitorService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.EtherTypes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.monitor.profile.create.input.Profile;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.monitor.profile.create.input.ProfileBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.monitor.start.input.ConfigBuilder;
-
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
this.interfaceManager = interfaceManager;
}
- void startArpMonitoring(MacEntry macEntry, Long arpMonitorProfileId) {
+ void startIpMonitoring(MacEntry macEntry, Long ipMonitorProfileId) {
if (interfaceManager.isExternalInterface(macEntry.getInterfaceName())) {
- LOG.debug("ARP monitoring is currently not supported through external interfaces,"
- + "skipping ARP monitoring from interface {} for IP {} (last known MAC {})",
+ LOG.debug("IP monitoring is currently not supported through external interfaces,"
+ + "skipping IP monitoring from interface {} for IP {} (last known MAC {})",
macEntry.getInterfaceName(), macEntry.getIpAddress().getHostAddress(), macEntry.getMacAddress());
return;
}
LOG.error("Error while retrieving GatewayMac for interface{}", macEntry.getInterfaceName());
return;
}
- final PhysAddress gatewayMac = new PhysAddress(gatewayMacOptional.get());
- if (arpMonitorProfileId == null || arpMonitorProfileId.equals(0L)) {
- Optional<Long> profileIdOptional = allocateProfile(ArpConstants.FAILURE_THRESHOLD,
- ArpConstants.ARP_CACHE_TIMEOUT_MILLIS, ArpConstants.MONITORING_WINDOW, EtherTypes.Arp);
+
+ final IpAddress targetIp = new IpAddress(macEntry.getIpAddress().getHostAddress().toCharArray());
+ if (ipMonitorProfileId == null || ipMonitorProfileId.equals(0L)) {
+ Optional<Long> profileIdOptional = allocateIpMonitorProfile(targetIp);
if (!profileIdOptional.isPresent()) {
- LOG.error("Error while allocating Profile Id for alivenessMonitorService");
+ LOG.error("startIpMonitoring: Error while allocating Profile Id for IP={}", targetIp);
return;
}
- arpMonitorProfileId = profileIdOptional.get();
+ ipMonitorProfileId = profileIdOptional.get();
}
- IpAddress targetIp = new IpAddress(new Ipv4Address(macEntry.getIpAddress().getHostAddress()));
- MonitorStartInput arpMonitorInput = new MonitorStartInputBuilder().setConfig(new ConfigBuilder()
+ final PhysAddress gatewayMac = new PhysAddress(gatewayMacOptional.get());
+ MonitorStartInput ipMonitorInput = new MonitorStartInputBuilder().setConfig(new ConfigBuilder()
.setSource(new SourceBuilder().setEndpointType(getSourceEndPointType(macEntry.getInterfaceName(),
gatewayIp, gatewayMac)).build())
.setDestination(new DestinationBuilder().setEndpointType(getEndPointIpAddress(targetIp)).build())
.setMode(MonitoringMode.OneOne)
- .setProfileId(arpMonitorProfileId).build()).build();
+ .setProfileId(ipMonitorProfileId).build()).build();
try {
- Future<RpcResult<MonitorStartOutput>> result = alivenessManager.monitorStart(arpMonitorInput);
+ Future<RpcResult<MonitorStartOutput>> result = alivenessManager.monitorStart(ipMonitorInput);
RpcResult<MonitorStartOutput> rpcResult = result.get();
long monitorId;
if (rpcResult.isSuccessful()) {
monitorId = rpcResult.getResult().getMonitorId();
createOrUpdateInterfaceMonitorIdMap(monitorId, macEntry);
- LOG.trace("Started ARP monitoring with id {}", monitorId);
+ LOG.trace("Started IP monitoring with id {}", monitorId);
} else {
LOG.warn("RPC Call to start monitoring returned with Errors {}", rpcResult.getErrors());
}
}
}
- void stopArpMonitoring(Long monitorId) {
+ void stopIpMonitoring(Long monitorId) {
MonitorStopInput input = new MonitorStopInputBuilder().setMonitorId(monitorId).build();
JdkFutures.addErrorLogging(alivenessManager.monitorStop(input), LOG, "Stop monitoring");
.build();
}
+ private Optional<Long> allocateIpMonitorProfile(IpAddress targetIp) {
+ Optional<Long> profileIdOptional = Optional.absent();
+ if (targetIp.getIpv4Address() != null) {
+ profileIdOptional = allocateProfile(ArpConstants.FAILURE_THRESHOLD,
+ ArpConstants.ARP_CACHE_TIMEOUT_MILLIS, ArpConstants.MONITORING_WINDOW, EtherTypes.Arp);
+ } else if (targetIp.getIpv6Address() != null) {
+ // TODO: handle IPv6 case
+ LOG.warn("allocateIpMonitorProfile: IPv6 address monitoring is not yet supported. targetIp={}", targetIp);
+ }
+ return profileIdOptional;
+ }
+
public Optional<Long> allocateProfile(long failureThreshold, long monitoringInterval, long monitoringWindow,
- EtherTypes etherTypes) {
+ EtherTypes etherTypes) {
MonitorProfileCreateInput input = new MonitorProfileCreateInputBuilder()
.setProfile(new ProfileBuilder().setFailureThreshold(failureThreshold)
.setMonitorInterval(monitoringInterval).setMonitorWindow(monitoringWindow)
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.netvirt.vpnmanager;
+package org.opendaylight.netvirt.vpnmanager.iplearn;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.netvirt.vpnmanager.VpnUtil;
+import org.opendaylight.netvirt.vpnmanager.iplearn.model.MacEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.AlivenessMonitorListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.LivenessState;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorEvent;
* This is used to handle interfaces for base of-ports.
*/
@Singleton
-public class ArpMonitorEventListener implements AlivenessMonitorListener {
- private static final Logger LOG = LoggerFactory.getLogger(ArpMonitorEventListener.class);
+public class IpMonitorEventListener implements AlivenessMonitorListener {
+ private static final Logger LOG = LoggerFactory.getLogger(IpMonitorEventListener.class);
private final DataBroker dataBroker;
private final JobCoordinator jobCoordinator;
private final AlivenessMonitorUtils alivenessMonitorUtils;
private final VpnUtil vpnUtil;
@Inject
- public ArpMonitorEventListener(DataBroker dataBroker, JobCoordinator jobCoordinator,
+ public IpMonitorEventListener(DataBroker dataBroker, JobCoordinator jobCoordinator,
AlivenessMonitorUtils alivenessMonitorUtils, VpnUtil vpnUtil) {
this.dataBroker = dataBroker;
this.jobCoordinator = jobCoordinator;
String learntIp = macEntry.getIpAddress().getHostAddress();
LearntVpnVipToPort vpnVipToPort = vpnUtil.getLearntVpnVipToPort(vpnName, learntIp);
if (vpnVipToPort != null && macEntry.getCreatedTime().equals(vpnVipToPort.getCreationTime())) {
- jobCoordinator.enqueueJob(ArpMonitoringHandler.buildJobKey(macEntry.getIpAddress().getHostAddress(),
- macEntry.getVpnName()), new ArpMonitorStopTask(macEntry, Boolean.TRUE, vpnUtil,
+ String jobKey = VpnUtil.buildIpMonitorJobKey(macEntry.getIpAddress().getHostAddress(),
+ macEntry.getVpnName());
+ jobCoordinator.enqueueJob(jobKey, new IpMonitorStopTask(macEntry, Boolean.TRUE, vpnUtil,
alivenessMonitorUtils));
}
* 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.netvirt.vpnmanager;
+package org.opendaylight.netvirt.vpnmanager.iplearn;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.List;
import java.util.concurrent.Callable;
+import org.opendaylight.netvirt.vpnmanager.iplearn.model.MacEntry;
-public class ArpMonitorStartTask implements Callable<List<ListenableFuture<Void>>> {
+public class IpMonitorStartTask implements Callable<List<ListenableFuture<Void>>> {
private final MacEntry macEntry;
private final Long arpMonitorProfileId;
private final AlivenessMonitorUtils alivenessMonitorUtils;
-
- public ArpMonitorStartTask(MacEntry macEntry, Long profileId, AlivenessMonitorUtils alivenessMonitorUtils) {
+ public IpMonitorStartTask(MacEntry macEntry, Long profileId, AlivenessMonitorUtils alivenessMonitorUtils) {
this.macEntry = macEntry;
this.arpMonitorProfileId = profileId;
this.alivenessMonitorUtils = alivenessMonitorUtils;
@Override
public List<ListenableFuture<Void>> call() {
- alivenessMonitorUtils.startArpMonitoring(macEntry, arpMonitorProfileId);
+ alivenessMonitorUtils.startIpMonitoring(macEntry, arpMonitorProfileId);
return null;
}
}
* 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.netvirt.vpnmanager;
+package org.opendaylight.netvirt.vpnmanager.iplearn;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
-
+import org.opendaylight.netvirt.vpnmanager.VpnUtil;
+import org.opendaylight.netvirt.vpnmanager.iplearn.model.MacEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.learnt.vpn.vip.to.port.data.LearntVpnVipToPort;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class ArpMonitorStopTask implements Callable<List<ListenableFuture<Void>>> {
+public class IpMonitorStopTask implements Callable<List<ListenableFuture<Void>>> {
+ private static final Logger LOG = LoggerFactory.getLogger(IpMonitorStopTask.class);
private MacEntry macEntry;
private final AlivenessMonitorUtils alivenessMonitorUtils;
- private static final Logger LOG = LoggerFactory.getLogger(ArpMonitorStopTask.class);
private boolean isRemoveMipAdjAndLearntIp;
private final VpnUtil vpnUtil;
- public ArpMonitorStopTask(MacEntry macEntry, boolean removeMipAdjAndLearntIp, VpnUtil vpnUtil,
+ public IpMonitorStopTask(MacEntry macEntry, boolean removeMipAdjAndLearntIp, VpnUtil vpnUtil,
AlivenessMonitorUtils alivenessMonitorUtils) {
this.macEntry = macEntry;
this.alivenessMonitorUtils = alivenessMonitorUtils;
final List<ListenableFuture<Void>> futures = new ArrayList<>();
java.util.Optional<Long> monitorIdOptional = AlivenessMonitorUtils.getMonitorIdFromInterface(macEntry);
monitorIdOptional.ifPresent(monitorId -> {
- alivenessMonitorUtils.stopArpMonitoring(monitorId);
+ alivenessMonitorUtils.stopIpMonitoring(monitorId);
});
if (this.isRemoveMipAdjAndLearntIp) {
* 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.netvirt.vpnmanager;
+package org.opendaylight.netvirt.vpnmanager.iplearn;
import com.google.common.base.Optional;
import java.net.InetAddress;
import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.mdsalutil.NWUtil;
-import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.genius.utils.clustering.EntityOwnershipUtils;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
import org.opendaylight.mdsal.eos.binding.api.Entity;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService;
import org.opendaylight.mdsal.eos.common.api.CandidateAlreadyRegisteredException;
import org.opendaylight.netvirt.neutronvpn.interfaces.INeutronVpnManager;
+import org.opendaylight.netvirt.vpnmanager.VpnConstants;
+import org.opendaylight.netvirt.vpnmanager.VpnUtil;
+import org.opendaylight.netvirt.vpnmanager.iplearn.model.MacEntry;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.AlivenessMonitorService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.EtherTypes;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.LearntVpnVipToPortData;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.learnt.vpn.vip.to.port.data.LearntVpnVipToPort;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.LoggerFactory;
@Singleton
-public class ArpMonitoringHandler
- extends AsyncClusteredDataTreeChangeListenerBase<LearntVpnVipToPort, ArpMonitoringHandler> {
- private static final Logger LOG = LoggerFactory.getLogger(ArpMonitoringHandler.class);
+public class IpMonitoringHandler
+ extends AsyncClusteredDataTreeChangeListenerBase<LearntVpnVipToPort, IpMonitoringHandler> {
+ private static final Logger LOG = LoggerFactory.getLogger(IpMonitoringHandler.class);
private final DataBroker dataBroker;
- private final OdlInterfaceRpcService interfaceRpc;
- private final IMdsalApiManager mdsalManager;
private final AlivenessMonitorService alivenessManager;
private final AlivenessMonitorUtils alivenessMonitorUtils;
private final INeutronVpnManager neutronVpnService;
private final JobCoordinator jobCoordinator;
private final VpnUtil vpnUtil;
- private Long arpMonitorProfileId = 0L;
+ private Optional<Long> arpMonitorProfileId = Optional.absent();
private EntityOwnershipCandidateRegistration candidateRegistration;
@Inject
- public ArpMonitoringHandler(final DataBroker dataBroker, final OdlInterfaceRpcService interfaceRpc,
- IMdsalApiManager mdsalManager, AlivenessMonitorService alivenessManager,
+ public IpMonitoringHandler(final DataBroker dataBroker, AlivenessMonitorService alivenessManager,
INeutronVpnManager neutronVpnService, IInterfaceManager interfaceManager,
EntityOwnershipService entityOwnershipService, JobCoordinator jobCoordinator,
- AlivenessMonitorUtils alivenessMonitorUtils, VpnUtil vpnUtil) {
- super(LearntVpnVipToPort.class, ArpMonitoringHandler.class);
+ AlivenessMonitorUtils alivenessMonitorUtils, VpnUtil vpnUtil) {
+ super(LearntVpnVipToPort.class, IpMonitoringHandler.class);
this.dataBroker = dataBroker;
- this.interfaceRpc = interfaceRpc;
- this.mdsalManager = mdsalManager;
this.alivenessManager = alivenessManager;
this.neutronVpnService = neutronVpnService;
this.interfaceManager = interfaceManager;
Optional<Long> profileIdOptional = alivenessMonitorUtils.allocateProfile(ArpConstants.FAILURE_THRESHOLD,
ArpConstants.ARP_CACHE_TIMEOUT_MILLIS, ArpConstants.MONITORING_WINDOW, EtherTypes.Arp);
if (profileIdOptional.isPresent()) {
- arpMonitorProfileId = profileIdOptional.get();
+ arpMonitorProfileId = profileIdOptional;
} else {
LOG.error("Error while allocating Profile Id {}", profileIdOptional);
}
try {
candidateRegistration = entityOwnershipUtils.getEntityOwnershipService().registerCandidate(
- new Entity(VpnConstants.ARP_MONITORING_ENTITY, VpnConstants.ARP_MONITORING_ENTITY));
+ new Entity(VpnConstants.IP_MONITORING_ENTITY, VpnConstants.IP_MONITORING_ENTITY));
} catch (CandidateAlreadyRegisteredException e) {
- LOG.error("failed to register the entity {}", VpnConstants.ARP_MONITORING_ENTITY);
+ LOG.error("failed to register the entity {}", VpnConstants.IP_MONITORING_ENTITY);
}
}
}
@Override
- protected ArpMonitoringHandler getDataTreeChangeListener() {
+ protected IpMonitoringHandler getDataTreeChangeListener() {
return this;
}
@Override
protected void update(InstanceIdentifier<LearntVpnVipToPort> id, LearntVpnVipToPort value,
LearntVpnVipToPort dataObjectModificationAfter) {
- runOnlyInOwnerNode("ArpMonitoringHandler: update event", () -> {
+ runOnlyInOwnerNode("IpMonitoringHandler: update event", () -> {
try {
if (value.getMacAddress() == null || dataObjectModificationAfter.getMacAddress() == null) {
LOG.warn("The mac address received is null for LearntVpnVipIpToPort {}, ignoring the DTCN",
@Override
protected void add(InstanceIdentifier<LearntVpnVipToPort> identifier, LearntVpnVipToPort value) {
- runOnlyInOwnerNode("ArpMonitoringHandler: add event", () -> {
+ runOnlyInOwnerNode("IpMonitoringHandler: add event", () -> {
try {
InetAddress srcInetAddr = InetAddress.getByName(value.getPortFixedip());
if (value.getMacAddress() == null) {
String vpnName = value.getVpnName();
MacEntry macEntry = new MacEntry(vpnName, srcMacAddress, srcInetAddr, value.getPortName(),
value.getCreationTime());
- if (NWUtil.isIpv4Address(value.getPortFixedip())) {
- jobCoordinator.enqueueJob(buildJobKey(srcInetAddr.toString(), vpnName),
- new ArpMonitorStartTask(macEntry, arpMonitorProfileId, alivenessMonitorUtils));
- } else {
- // TODO: Handle for IPv6 case
- LOG.warn("IPv6 address monitoring is not yet supported - add(). LearntVpnVipToPort={}", value);
+
+ Optional<Long> monitorProfileId = getMonitorProfileId(value.getPortFixedip());
+ if (monitorProfileId.isPresent()) {
+ jobCoordinator.enqueueJob(VpnUtil.buildIpMonitorJobKey(srcInetAddr.toString(), vpnName),
+ new IpMonitorStartTask(macEntry, monitorProfileId.get(), alivenessMonitorUtils));
}
} catch (UnknownHostException e) {
LOG.error("Error in deserializing packet {} with exception", value, e);
@Override
protected void remove(InstanceIdentifier<LearntVpnVipToPort> key, LearntVpnVipToPort value) {
- runOnlyInOwnerNode("ArpMonitoringHandler: remove event", () -> {
+ runOnlyInOwnerNode("IpMonitoringHandler: remove event", () -> {
try {
InetAddress srcInetAddr = InetAddress.getByName(value.getPortFixedip());
if (value.getMacAddress() == null) {
String interfaceName = value.getPortName();
MacEntry macEntry = new MacEntry(vpnName, srcMacAddress, srcInetAddr, interfaceName,
value.getCreationTime());
- if (NWUtil.isIpv4Address(value.getPortFixedip())) {
- jobCoordinator.enqueueJob(buildJobKey(srcInetAddr.toString(), vpnName),
- new ArpMonitorStopTask(macEntry, Boolean.FALSE, vpnUtil, alivenessMonitorUtils));
- } else {
- // TODO: Handle for IPv6 case
- LOG.warn("IPv6 address monitoring is not yet supported - remove(). LearntVpnVipToPort={}", value);
- }
+
+ jobCoordinator.enqueueJob(VpnUtil.buildIpMonitorJobKey(srcInetAddr.toString(), vpnName),
+ new IpMonitorStopTask(macEntry, Boolean.FALSE, vpnUtil, alivenessMonitorUtils));
} catch (UnknownHostException e) {
LOG.error("Error in deserializing packet {} with exception", value, e);
}
}
private void runOnlyInOwnerNode(String jobDesc, final Runnable job) {
- entityOwnershipUtils.runOnlyInOwnerNode(VpnConstants.ARP_MONITORING_ENTITY, VpnConstants.ARP_MONITORING_ENTITY,
+ entityOwnershipUtils.runOnlyInOwnerNode(VpnConstants.IP_MONITORING_ENTITY, VpnConstants.IP_MONITORING_ENTITY,
jobCoordinator, jobDesc, job);
}
- static String buildJobKey(String ip, String vpnName) {
- return new StringBuilder(ArpConstants.ARPJOB).append('-').append(vpnName).append('-').append(ip).toString();
+ private Optional<Long> getMonitorProfileId(String ipAddress) {
+ if (NWUtil.isIpv4Address(ipAddress)) {
+ return this.arpMonitorProfileId;
+ } else {
+ // TODO: Handle for IPv6 case
+ LOG.warn("IPv6 address monitoring is not yet supported - getMonitorProfileId(). ipAddress={}", ipAddress);
+ return Optional.absent();
+ }
}
-
}
* 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.netvirt.vpnmanager;
+package org.opendaylight.netvirt.vpnmanager.iplearn;
import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
-
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.Callable;
-
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
-import org.opendaylight.genius.arputil.api.ArpConstants;
import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
-import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.genius.utils.clustering.EntityOwnershipUtils;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
import org.opendaylight.mdsal.eos.binding.api.Entity;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipCandidateRegistration;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService;
import org.opendaylight.mdsal.eos.common.api.CandidateAlreadyRegisteredException;
-import org.opendaylight.netvirt.neutronvpn.interfaces.INeutronVpnManager;
+import org.opendaylight.netvirt.vpnmanager.VpnConstants;
+import org.opendaylight.netvirt.vpnmanager.VpnUtil;
import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterface;
import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterfaceBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.AlivenessMonitorService;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.Adjacencies;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.LearntVpnVipToPortEventAction;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.LearntVpnVipToPortEventData;
private static final Logger LOG = LoggerFactory.getLogger(LearntVpnVipToPortEventProcessor.class);
private final DataBroker dataBroker;
private final ManagedNewTransactionRunner txRunner;
- private final OdlInterfaceRpcService interfaceRpc;
- private final IMdsalApiManager mdsalManager;
- private final AlivenessMonitorService alivenessManager;
- private final INeutronVpnManager neutronVpnService;
private final IInterfaceManager interfaceManager;
- private final IdManagerService idManager;
public static final String MIP_PROCESSING_JOB = "MIP-JOB";
private final JobCoordinator jobCoordinator;
private final EntityOwnershipUtils entityOwnershipUtils;
private final VpnUtil vpnUtil;
@Inject
- public LearntVpnVipToPortEventProcessor(final DataBroker dataBroker, final OdlInterfaceRpcService interfaceRpc,
- IMdsalApiManager mdsalManager, AlivenessMonitorService alivenessManager,
- INeutronVpnManager neutronVpnService, IInterfaceManager interfaceManager,
- EntityOwnershipService entityOwnershipService,
- IdManagerService idManagerService, final JobCoordinator jobCoordinator,
- VpnUtil vpnUtil) {
+ public LearntVpnVipToPortEventProcessor(final DataBroker dataBroker, IInterfaceManager interfaceManager,
+ EntityOwnershipService entityOwnershipService, final JobCoordinator jobCoordinator, VpnUtil vpnUtil) {
super(LearntVpnVipToPortEvent.class, LearntVpnVipToPortEventProcessor.class);
this.dataBroker = dataBroker;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
- this.interfaceRpc = interfaceRpc;
- this.mdsalManager = mdsalManager;
- this.alivenessManager = alivenessManager;
- this.neutronVpnService = neutronVpnService;
this.interfaceManager = interfaceManager;
- this.idManager = idManagerService;
this.jobCoordinator = jobCoordinator;
this.entityOwnershipUtils = new EntityOwnershipUtils(entityOwnershipService);
this.vpnUtil = vpnUtil;
registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
try {
candidateRegistration = entityOwnershipUtils.getEntityOwnershipService()
- .registerCandidate(new Entity(VpnConstants.ARP_MONITORING_ENTITY,
- VpnConstants.ARP_MONITORING_ENTITY));
+ .registerCandidate(new Entity(VpnConstants.IP_MONITORING_ENTITY,
+ VpnConstants.IP_MONITORING_ENTITY));
} catch (CandidateAlreadyRegisteredException e) {
- LOG.error("Failed to register the entity {}", VpnConstants.ARP_MONITORING_ENTITY);
+ LOG.error("Failed to register the entity {}", VpnConstants.IP_MONITORING_ENTITY);
}
}
@Override
protected void add(InstanceIdentifier<LearntVpnVipToPortEvent> identifier, LearntVpnVipToPortEvent value) {
// AFTER PROCESSING THE EVENT, REMOVE THE EVENT FROM THE QUEUE
- entityOwnershipUtils.runOnlyInOwnerNode(VpnConstants.ARP_MONITORING_ENTITY,
- VpnConstants.ARP_MONITORING_ENTITY, jobCoordinator, "LearntVpnVipToPortEvent-Handler", () -> {
+ entityOwnershipUtils.runOnlyInOwnerNode(VpnConstants.IP_MONITORING_ENTITY, VpnConstants.IP_MONITORING_ENTITY,
+ jobCoordinator, "LearntVpnVipToPortEvent-Handler", () -> {
try {
String vpnName = value.getVpnName();
String ipAddress = value.getSrcFixedip();
if (value.getEventAction() == LearntVpnVipToPortEventAction.Add) {
- jobCoordinator.enqueueJob(buildJobKey(ipAddress, vpnName), new AddMipAdjacencyWorker(value));
+ jobCoordinator.enqueueJob(VpnUtil.buildIpMonitorJobKey(ipAddress, vpnName),
+ new AddMipAdjacencyWorker(value));
}
if (value.getEventAction() == LearntVpnVipToPortEventAction.Delete) {
- jobCoordinator.enqueueJob(buildJobKey(ipAddress, vpnName),
+ jobCoordinator.enqueueJob(VpnUtil.buildIpMonitorJobKey(ipAddress, vpnName),
new DeleteMipAdjacencyWorker(value));
}
} finally {
// NOTE: DONOT ADD ANY CODE HERE AND MAKE A CIRCUS
}
- static String buildJobKey(String ip, String vpnName) {
- return new StringBuilder(ArpConstants.ARPJOB).append('-').append(vpnName).append('-').append(ip).toString();
- }
-
private class AddMipAdjacencyWorker implements Callable<List<ListenableFuture<Void>>> {
String vpnName;
String interfaceName;
* 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.netvirt.vpnmanager.iplearn;
+package org.opendaylight.netvirt.vpnmanager.iplearn.ipv4;
import java.math.BigInteger;
import javax.inject.Inject;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.netvirt.vpnmanager.VpnUtil;
+import org.opendaylight.netvirt.vpnmanager.iplearn.AbstractIpLearnNotificationHandler;
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.yang.types.rev130715.MacAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.arputil.rev160406.ArpRequestReceived;
* 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.netvirt.vpnmanager;
+package org.opendaylight.netvirt.vpnmanager.iplearn.ipv4;
import java.math.BigInteger;
import java.util.ArrayList;
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.netvirt.vpnmanager.iplearn;
+package org.opendaylight.netvirt.vpnmanager.iplearn.ipv6;
import java.math.BigInteger;
import javax.inject.Inject;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.netvirt.vpnmanager.VpnUtil;
+import org.opendaylight.netvirt.vpnmanager.iplearn.AbstractIpLearnNotificationHandler;
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.yang.types.rev130715.MacAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
* 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.netvirt.vpnmanager;
+package org.opendaylight.netvirt.vpnmanager.iplearn.model;
import java.net.InetAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
<service ref="vpnFootprintService"
interface="org.opendaylight.netvirt.vpnmanager.api.IVpnFootprintService" />
- <odl:notification-listener ref="arpMonitorEventListener" />
+ <odl:notification-listener ref="ipMonitorEventListener" />
<service ref="subnetRoutePacketInHandler" odl:type="default"
interface="org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingListener" />