vpnmanager/impl/src/main/java/org/opendaylight/netvirt/vpnmanager/iplearn/IpMonitoringHandler.java

   1 /*
   2  * Copyright (c) 2015 Ericsson India Global Services Pvt Ltd. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.netvirt.vpnmanager.iplearn;
   9
  10 import com.google.common.base.Optional;
  11 import java.net.InetAddress;
  12 import java.net.UnknownHostException;
  13 import javax.annotation.PostConstruct;
  14 import javax.annotation.PreDestroy;
  15 import javax.inject.Inject;
  16 import javax.inject.Singleton;
  17 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  18 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  19 import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
  20 import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
  21 import org.opendaylight.genius.mdsalutil.NWUtil;
  22 import org.opendaylight.genius.utils.clustering.EntityOwnershipUtils;
  23 import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
  24 import org.opendaylight.mdsal.eos.binding.api.Entity;
  25 import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipCandidateRegistration;
  26 import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService;
  27 import org.opendaylight.mdsal.eos.common.api.CandidateAlreadyRegisteredException;
  28 import org.opendaylight.netvirt.neutronvpn.interfaces.INeutronVpnManager;
  29 import org.opendaylight.netvirt.vpnmanager.VpnConstants;
  30 import org.opendaylight.netvirt.vpnmanager.VpnUtil;
  31 import org.opendaylight.netvirt.vpnmanager.iplearn.model.MacEntry;
  32 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.AlivenessMonitorService;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.LearntVpnVipToPortData;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.learnt.vpn.vip.to.port.data.LearntVpnVipToPort;
  36 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  37 import org.opendaylight.yangtools.yang.common.Uint32;
  38 import org.slf4j.Logger;
  39 import org.slf4j.LoggerFactory;
  40
  41 @Singleton
  42 public class IpMonitoringHandler
  43         extends AsyncClusteredDataTreeChangeListenerBase<LearntVpnVipToPort, IpMonitoringHandler> {
  44     private static final Logger LOG = LoggerFactory.getLogger(IpMonitoringHandler.class);
  45     private final DataBroker dataBroker;
  46     private final AlivenessMonitorService alivenessManager;
  47     private final AlivenessMonitorUtils alivenessMonitorUtils;
  48     private final INeutronVpnManager neutronVpnService;
  49     private final IInterfaceManager interfaceManager;
  50     private final EntityOwnershipUtils entityOwnershipUtils;
  51     private final JobCoordinator jobCoordinator;
  52     private final VpnUtil vpnUtil;
  53
  54     private Optional<Uint32> arpMonitorProfileId = Optional.absent();
  55     private Optional<Uint32> ipv6NdMonitorProfileId = Optional.absent();
  56     private EntityOwnershipCandidateRegistration candidateRegistration;
  57
  58     @Inject
  59     public IpMonitoringHandler(final DataBroker dataBroker, AlivenessMonitorService alivenessManager,
  60             INeutronVpnManager neutronVpnService, IInterfaceManager interfaceManager,
  61             EntityOwnershipService entityOwnershipService, JobCoordinator jobCoordinator,
  62             AlivenessMonitorUtils alivenessMonitorUtils, VpnUtil vpnUtil) {
  63         super(LearntVpnVipToPort.class, IpMonitoringHandler.class);
  64         this.dataBroker = dataBroker;
  65         this.alivenessManager = alivenessManager;
  66         this.neutronVpnService = neutronVpnService;
  67         this.interfaceManager = interfaceManager;
  68         this.entityOwnershipUtils = new EntityOwnershipUtils(entityOwnershipService);
  69         this.jobCoordinator = jobCoordinator;
  70         this.alivenessMonitorUtils = alivenessMonitorUtils;
  71         this.vpnUtil = vpnUtil;
  72     }
  73
  74     @PostConstruct
  75     public void start() {
  76         this.arpMonitorProfileId = alivenessMonitorUtils.allocateArpMonitorProfile();
  77         this.ipv6NdMonitorProfileId = alivenessMonitorUtils.allocateIpv6NaMonitorProfile();
  78         if (this.arpMonitorProfileId == null || this.ipv6NdMonitorProfileId == null) {
  79             LOG.error("Error while allocating ARP and IPv6 ND Profile Ids: ARP={}, IPv6ND={}", arpMonitorProfileId,
  80                     ipv6NdMonitorProfileId);
  81         }
  82         registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
  83
  84         try {
  85             candidateRegistration = entityOwnershipUtils.getEntityOwnershipService().registerCandidate(
  86                     new Entity(VpnConstants.IP_MONITORING_ENTITY, VpnConstants.IP_MONITORING_ENTITY));
  87         } catch (CandidateAlreadyRegisteredException e) {
  88             LOG.error("failed to register the entity {}", VpnConstants.IP_MONITORING_ENTITY);
  89         }
  90     }
  91
  92     @Override
  93     @PreDestroy
  94     public void close() {
  95         super.close();
  96
  97         if (candidateRegistration != null) {
  98             candidateRegistration.close();
  99         }
 100     }
 101
 102     @Override
 103     protected InstanceIdentifier<LearntVpnVipToPort> getWildCardPath() {
 104         return InstanceIdentifier.create(LearntVpnVipToPortData.class).child(LearntVpnVipToPort.class);
 105     }
 106
 107     @Override
 108     protected IpMonitoringHandler getDataTreeChangeListener() {
 109         return this;
 110     }
 111
 112     // TODO Clean up the exception handling
 113     @SuppressWarnings("checkstyle:IllegalCatch")
 114     @Override
 115     protected void update(InstanceIdentifier<LearntVpnVipToPort> id, LearntVpnVipToPort value,
 116             LearntVpnVipToPort dataObjectModificationAfter) {
 117         runOnlyInOwnerNode("IpMonitoringHandler: update event", () -> {
 118             try {
 119                 if (value.getMacAddress() == null || dataObjectModificationAfter.getMacAddress() == null) {
 120                     LOG.warn("The mac address received is null for LearntVpnVipIpToPort {}, ignoring the DTCN",
 121                             dataObjectModificationAfter);
 122                     return;
 123                 }
 124                 remove(id, value);
 125                 add(id, dataObjectModificationAfter);
 126             } catch (Exception e) {
 127                 LOG.error("Error in handling update to LearntVpnVipIpToPort for vpnName {} and IP Address {}",
 128                         value.getVpnName(), value.getPortFixedip(), e);
 129             }
 130         });
 131     }
 132
 133     @Override
 134     protected void add(InstanceIdentifier<LearntVpnVipToPort> identifier, LearntVpnVipToPort value) {
 135         runOnlyInOwnerNode("IpMonitoringHandler: add event", () -> {
 136             try {
 137                 InetAddress srcInetAddr = InetAddress.getByName(value.getPortFixedip());
 138                 if (value.getMacAddress() == null) {
 139                     LOG.warn("The mac address received is null for VpnPortipToPort {}, ignoring the DTCN", value);
 140                     return;
 141                 }
 142                 MacAddress srcMacAddress = MacAddress.getDefaultInstance(value.getMacAddress());
 143                 String vpnName =  value.getVpnName();
 144                 MacEntry macEntry = new MacEntry(vpnName, srcMacAddress, srcInetAddr, value.getPortName(),
 145                         value.getCreationTime());
 146
 147                 Optional<Uint32> monitorProfileId = getMonitorProfileId(value.getPortFixedip());
 148                 if (monitorProfileId.isPresent()) {
 149                     jobCoordinator.enqueueJob(VpnUtil.buildIpMonitorJobKey(srcInetAddr.toString(), vpnName),
 150                             new IpMonitorStartTask(macEntry, monitorProfileId.get().toJava(), alivenessMonitorUtils));
 151                 }
 152             } catch (UnknownHostException e) {
 153                 LOG.error("Error in deserializing packet {} with exception", value, e);
 154             }
 155         });
 156     }
 157
 158     @Override
 159     protected void remove(InstanceIdentifier<LearntVpnVipToPort> key, LearntVpnVipToPort value) {
 160         runOnlyInOwnerNode("IpMonitoringHandler: remove event", () -> {
 161             try {
 162                 InetAddress srcInetAddr = InetAddress.getByName(value.getPortFixedip());
 163                 if (value.getMacAddress() == null) {
 164                     LOG.warn("The mac address received is null for LearntVpnVipToPort {}, ignoring the DTCN", value);
 165                     return;
 166                 }
 167                 String vpnName =  value.getVpnName();
 168                 String learntIp = srcInetAddr.getHostAddress();
 169                 LearntVpnVipToPort vpnVipToPort = vpnUtil.getLearntVpnVipToPort(vpnName, learntIp);
 170                 if (vpnVipToPort != null && !vpnVipToPort.getCreationTime().equals(value.getCreationTime())) {
 171                     LOG.warn("The MIP {} over vpn {} has been learnt again and processed. "
 172                             + "Ignoring this remove event.", learntIp, vpnName);
 173                     return;
 174                 }
 175                 MacAddress srcMacAddress = MacAddress.getDefaultInstance(value.getMacAddress());
 176                 String interfaceName =  value.getPortName();
 177                 MacEntry macEntry = new MacEntry(vpnName, srcMacAddress, srcInetAddr, interfaceName,
 178                         value.getCreationTime());
 179
 180                 jobCoordinator.enqueueJob(VpnUtil.buildIpMonitorJobKey(srcInetAddr.toString(), vpnName),
 181                         new IpMonitorStopTask(macEntry, dataBroker, Boolean.FALSE, vpnUtil, alivenessMonitorUtils));
 182             } catch (UnknownHostException e) {
 183                 LOG.error("Error in deserializing packet {} with exception", value, e);
 184             }
 185         });
 186     }
 187
 188     private void runOnlyInOwnerNode(String jobDesc, final Runnable job) {
 189         entityOwnershipUtils.runOnlyInOwnerNode(VpnConstants.IP_MONITORING_ENTITY, VpnConstants.IP_MONITORING_ENTITY,
 190                 jobCoordinator, jobDesc, job);
 191     }
 192
 193     private Optional<Uint32> getMonitorProfileId(String ipAddress) {
 194         if (NWUtil.isIpv4Address(ipAddress)) {
 195             return this.arpMonitorProfileId;
 196         } else {
 197             return this.ipv6NdMonitorProfileId;
 198         }
 199     }
 200 }
 201