X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=elanmanager%2Felanmanager-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fvpnservice%2Felan%2Finternal%2FElanPacketInHandler.java;fp=elanmanager%2Felanmanager-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fvpnservice%2Felan%2Finternal%2FElanPacketInHandler.java;h=04de7e3a953a858e4cb01425c574ff0dab4391b4;hb=3510292a1184e25751f8690ea49a8c2312bba4b3;hp=0000000000000000000000000000000000000000;hpb=00b0d63ef8325f3b9b32b4dbee0c11a51eed1440;p=vpnservice.git diff --git a/elanmanager/elanmanager-impl/src/main/java/org/opendaylight/vpnservice/elan/internal/ElanPacketInHandler.java b/elanmanager/elanmanager-impl/src/main/java/org/opendaylight/vpnservice/elan/internal/ElanPacketInHandler.java new file mode 100755 index 00000000..04de7e3a --- /dev/null +++ b/elanmanager/elanmanager-impl/src/main/java/org/opendaylight/vpnservice/elan/internal/ElanPacketInHandler.java @@ -0,0 +1,155 @@ +/* + * 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.vpnservice.elan.internal; + +import org.opendaylight.controller.md.sal.binding.api.DataBroker; +import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.vpnservice.elan.utils.ElanConstants; +import org.opendaylight.vpnservice.elan.utils.ElanUtils; +//import org.opendaylight.vpnservice.interfacemgr.globals.InterfaceInfo; +import org.opendaylight.vpnservice.interfacemgr.globals.InterfaceInfo; +import org.opendaylight.vpnservice.interfacemgr.interfaces.IInterfaceManager; +import org.opendaylight.vpnservice.mdsalutil.MDSALUtil; +import org.opendaylight.vpnservice.mdsalutil.MetaDataUtil; +import org.opendaylight.vpnservice.mdsalutil.NWUtil; +import org.opendaylight.controller.liblldp.NetUtils; +import org.opendaylight.vpnservice.mdsalutil.packet.Ethernet; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.MacAddress; +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.packet.service.rev130709.NoMatch; +import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketInReason; +import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingListener; +import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketReceived; +import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.elan.rev150602.elan.instances.ElanInstance; +import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.elan.rev150602.elan.state.Elan; +import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.elan.rev150602.elan.tag.name.map.ElanTagName; +import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.elan.rev150602.forwarding.entries.MacEntry; +import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.elan.rev150602.forwarding.entries.MacEntryBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.elan.rev150602.forwarding.entries.MacEntryKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.meta.rev151007._if.indexes._interface.map.IfIndexInterface; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.math.BigInteger; + +public class ElanPacketInHandler implements PacketProcessingListener { + + private final DataBroker broker; + private IInterfaceManager interfaceManager; + + private static final Logger logger = LoggerFactory.getLogger(ElanPacketInHandler.class); + + public ElanPacketInHandler(DataBroker dataBroker) { + broker = dataBroker; + } + + public void setInterfaceManager(IInterfaceManager interfaceManager) { + this.interfaceManager = interfaceManager; + } + + @Override + public void onPacketReceived(PacketReceived notification) { + Class pktInReason = notification.getPacketInReason(); + short tableId = notification.getTableId().getValue(); + if(pktInReason == NoMatch.class && tableId == ElanConstants.ELAN_SMAC_TABLE) { + try { + byte[] data = notification.getPayload(); + Ethernet res = new Ethernet(); + + res.deserialize(data, 0, data.length * NetUtils.NumBitsInAByte); + + byte[] srcMac = res.getSourceMACAddress(); + String macAddress = NWUtil.toStringMacAddress(srcMac); + PhysAddress physAddress = new PhysAddress(macAddress); + BigInteger metadata = notification.getMatch().getMetadata().getMetadata(); + long elanTag = MetaDataUtil.getElanTagFromMetadata(metadata); + + long portTag = MetaDataUtil.getLportFromMetadata(metadata).intValue(); + + IfIndexInterface interfaceInfo = ElanUtils.getInterfaceInfoByInterfaceTag(portTag); + if (interfaceInfo == null) { + logger.warn("There is no interface for given portTag {}", portTag); + return; + } + String interfaceName = interfaceInfo.getInterfaceName(); + ElanTagName elanTagName = ElanUtils.getElanInfoByElanTag(elanTag); + String elanName = elanTagName.getName(); + Elan elanInfo = ElanUtils.getElanByName(elanName); + MacEntry macEntry = ElanUtils.getInterfaceMacEntriesOperationalDataPath(interfaceName, physAddress); + if(macEntry != null && macEntry.getInterface() == interfaceName) { + BigInteger macTimeStamp = macEntry.getControllerLearnedForwardingEntryTimestamp(); + if (System.currentTimeMillis() > macTimeStamp.longValue()+2000) { + /* + * Protection time expired. Even though the MAC has been learnt (it is in the cache) + * the packets are punted to controller. Which means, the the flows were not successfully + * created in the DPN, but the MAC entry has been added successfully in the cache. + * + * So, the cache has to be cleared and the flows and cache should be recreated (clearing + * of cache is required so that the timestamp is updated). + */ + InstanceIdentifier macEntryId = ElanUtils.getInterfaceMacEntriesIdentifierOperationalDataPath(interfaceName, physAddress); + ElanUtils.delete(broker, LogicalDatastoreType.OPERATIONAL, macEntryId); + } else { + // Protection time running. Ignore packets for 2 seconds + return; + } + } else if(macEntry != null) { + // MAC address has moved. Overwrite the mapping and replace MAC flows + long macTimeStamp = macEntry.getControllerLearnedForwardingEntryTimestamp().longValue(); + if (System.currentTimeMillis() > macTimeStamp+1000) { + + InstanceIdentifier macEntryId = ElanUtils.getInterfaceMacEntriesIdentifierOperationalDataPath(interfaceName, physAddress); + ElanUtils.delete(broker, LogicalDatastoreType.OPERATIONAL, macEntryId); + tryAndRemoveInvalidMacEntry(elanName, macEntry); + } else { + // New FEs flood their packets on all interfaces. This can lead + // to many contradicting packet_ins. Ignore all packets received + // within 1s after the first packet_in + return; + } + } + BigInteger timeStamp = new BigInteger(String.valueOf((long)System.currentTimeMillis())); + macEntry = new MacEntryBuilder().setInterface(interfaceName).setMacAddress(physAddress).setKey(new MacEntryKey(physAddress)).setControllerLearnedForwardingEntryTimestamp(timeStamp).setIsStaticAddress(false).build(); + InstanceIdentifier macEntryId = ElanUtils.getInterfaceMacEntriesIdentifierOperationalDataPath(interfaceName, physAddress); + MDSALUtil.syncWrite(broker, LogicalDatastoreType.OPERATIONAL, macEntryId, macEntry); + InstanceIdentifier elanMacEntryId = ElanUtils.getMacEntryOperationalDataPath(elanName, physAddress); + MDSALUtil.syncWrite(broker, LogicalDatastoreType.OPERATIONAL, elanMacEntryId, macEntry); + ElanInstance elanInstance = ElanUtils.getElanInstanceByName(elanName); + ElanUtils.setupMacFlows(elanInstance, interfaceManager.getInterfaceInfo(interfaceName), elanInstance.getMacTimeout(), macAddress); + } catch (Exception e) { + logger.trace("Failed to decode packet: {}", e); + } + } + + } + + + /* + * Though this method is a little costlier because it uses try-catch construct, it is used + * only in rare scenarios like MAC movement or invalid Static MAC having been added on a + * wrong ELAN. + */ + private void tryAndRemoveInvalidMacEntry(String elanName, MacEntry macEntry) { + ElanInstance elanInfo = ElanUtils.getElanInstanceByName(elanName); + if (elanInfo == null) { + logger.warn(String.format("MAC %s is been added (either statically or dynamically) for an invalid Elan %s. " + + "Manual cleanup may be necessary", macEntry.getMacAddress(), elanName)); + return; + } + + InterfaceInfo oldInterfaceLport = interfaceManager.getInterfaceInfo(macEntry.getInterface()); + if (oldInterfaceLport == null) { + logger.warn(String.format("MAC %s is been added (either statically or dynamically) on an invalid Logical Port %s. " + + "Manual cleanup may be necessary", macEntry.getMacAddress(), macEntry.getInterface())); + return; + } + ElanUtils.deleteMacFlows(elanInfo, oldInterfaceLport, macEntry); + } + +}