import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
+
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
+import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
+
import org.apache.commons.lang3.StringUtils;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.genius.interfacemanager.globals.InterfaceInfo;
import org.opendaylight.genius.interfacemanager.globals.InterfaceServiceUtil;
+import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.itm.globals.ITMConstants;
+import org.opendaylight.genius.mdsalutil.ActionInfo;
+import org.opendaylight.genius.mdsalutil.ActionType;
import org.opendaylight.genius.mdsalutil.FlowEntity;
import org.opendaylight.genius.mdsalutil.InstructionInfo;
import org.opendaylight.genius.mdsalutil.InstructionType;
import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.genius.utils.ServiceIndex;
+import org.opendaylight.netvirt.elan.ElanException;
import org.opendaylight.netvirt.elan.internal.ElanInstanceManager;
import org.opendaylight.netvirt.elan.internal.ElanInterfaceManager;
import org.opendaylight.netvirt.elan.l2gw.utils.ElanL2GatewayMulticastUtils;
import org.opendaylight.netvirt.elan.l2gw.utils.ElanL2GatewayUtils;
import org.opendaylight.netvirt.elan.l2gw.utils.L2GatewayConnectionUtils;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.AdminStatus;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.IfIndexesInterfaceMap;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._if.indexes._interface.map.IfIndexInterface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._if.indexes._interface.map.IfIndexInterfaceKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfExternal;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeVxlan;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetDpidFromInterfaceInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.tag.name.map.ElanTagNameBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.tag.name.map.ElanTagNameKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.forwarding.entries.MacEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.forwarding.entries.MacEntryBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.forwarding.entries.MacEntryKey;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
private final ElanInstanceManager elanInstanceManager;
private final OdlInterfaceRpcService interfaceManagerRpcService;
private final ItmRpcService itmRpcService;
- private ElanL2GatewayUtils elanL2GatewayUtils;
- private ElanL2GatewayMulticastUtils elanL2GatewayMulticastUtils;
- private L2GatewayConnectionUtils l2GatewayConnectionUtils;
+ private final ElanL2GatewayUtils elanL2GatewayUtils;
+ private final ElanL2GatewayMulticastUtils elanL2GatewayMulticastUtils;
+ private final L2GatewayConnectionUtils l2GatewayConnectionUtils;
+ private final IInterfaceManager interfaceManager;
public static final FutureCallback<Void> DEFAULT_CALLBACK = new FutureCallback<Void>() {
@Override
public ElanUtils(DataBroker dataBroker, IMdsalApiManager mdsalManager, ElanInstanceManager elanInstanceManager,
OdlInterfaceRpcService interfaceManagerRpcService, ItmRpcService itmRpcService,
ElanInterfaceManager elanInterfaceManager,
- EntityOwnershipService entityOwnershipService) {
+ EntityOwnershipService entityOwnershipService, IInterfaceManager interfaceManager) {
this.broker = dataBroker;
this.mdsalManager = mdsalManager;
this.elanInstanceManager = elanInstanceManager;
this.interfaceManagerRpcService = interfaceManagerRpcService;
this.itmRpcService = itmRpcService;
+ this.interfaceManager = interfaceManager;
elanL2GatewayMulticastUtils =
new ElanL2GatewayMulticastUtils(broker, elanInstanceManager, elanInterfaceManager, this);
elanL2GatewayUtils = new ElanL2GatewayUtils(broker, itmRpcService, this,
entityOwnershipService, elanL2GatewayMulticastUtils);
+ elanL2GatewayMulticastUtils.setEElanL2GatewayUtils(elanL2GatewayUtils);
l2GatewayConnectionUtils = new L2GatewayConnectionUtils(broker,
elanInstanceManager, entityOwnershipService, this);
}
return elanInstanceLocalCache.get(elanInstanceName);
}
+ public static Set<String> getAllElanNames() {
+ return elanInstanceLocalCache.keySet();
+ }
+
public static void addElanInterfaceIntoCache(String interfaceName, ElanInterface elanInterface) {
elanInterfaceLocalCache.put(interfaceName, elanInterface);
}
Future<RpcResult<Void>> result = idManager.releaseId(releaseIdInput);
}
+ /**
+ * Read utility.
+ *
+ * @deprecated Consider using {@link #read2(LogicalDatastoreType, InstanceIdentifier)} with proper exception
+ * handling instead
+ */
+ @Deprecated
+ @SuppressWarnings("checkstyle:IllegalCatch")
public <T extends DataObject> Optional<T> read(DataBroker broker, LogicalDatastoreType datastoreType,
InstanceIdentifier<T> path) {
ReadOnlyTransaction tx = broker != null ? broker.newReadOnlyTransaction()
result = checkedFuture.get();
} catch (Exception e) {
throw new RuntimeException(e);
+ } finally {
+ tx.close();
}
return result;
}
+ public <T extends DataObject> Optional<T> read2(LogicalDatastoreType datastoreType, InstanceIdentifier<T> path)
+ throws ReadFailedException {
+ ReadOnlyTransaction tx = broker.newReadOnlyTransaction();
+ try {
+ CheckedFuture<Optional<T>, ReadFailedException> checkedFuture = tx.read(datastoreType, path);
+ return checkedFuture.checkedGet();
+ } finally {
+ tx.close();
+ }
+ }
+
public static <T extends DataObject> void delete(DataBroker broker, LogicalDatastoreType datastoreType,
InstanceIdentifier<T> path) {
WriteTransaction tx = broker.newWriteOnlyTransaction();
Futures.addCallback(tx.submit(), DEFAULT_CALLBACK);
}
+ public static <T extends DataObject> void delete(DataBroker broker, LogicalDatastoreType datastoreType,
+ InstanceIdentifier<T> path, FutureCallback<Void> callback) {
+ WriteTransaction tx = broker.newWriteOnlyTransaction();
+ tx.delete(datastoreType, path);
+ Futures.addCallback(tx.submit(), callback);
+ }
+
public static InstanceIdentifier<ElanInstance> getElanInstanceIdentifier() {
return InstanceIdentifier.builder(ElanInstances.class).child(ElanInstance.class).build();
}
return elanObj;
}
InstanceIdentifier<ElanInstance> elanIdentifierId = getElanInstanceConfigurationDataPath(elanInstanceName);
- Optional<ElanInstance> elanInstance = MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION,
- elanIdentifierId);
- if (elanInstance.isPresent()) {
- return elanInstance.get();
- }
- return null;
+ return MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, elanIdentifierId).orNull();
}
public static InstanceIdentifier<ElanInstance> getElanInstanceConfigurationDataPath(String elanInstanceName) {
return elanInterfaceObj;
}
InstanceIdentifier<ElanInterface> elanInterfaceId = getElanInterfaceConfigurationDataPathId(elanInterfaceName);
- Optional<ElanInterface> existingElanInterface = MDSALUtil.read(broker,
- LogicalDatastoreType.CONFIGURATION, elanInterfaceId);
- if (existingElanInterface.isPresent()) {
- return existingElanInterface.get();
- }
- return null;
+ return MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, elanInterfaceId).orNull();
}
public static EtreeInterface getEtreeInterfaceByElanInterfaceName(DataBroker broker, String elanInterfaceName) {
// elan-state Operational container
public static Elan getElanByName(DataBroker broker, String elanInstanceName) {
InstanceIdentifier<Elan> elanIdentifier = getElanInstanceOperationalDataPath(elanInstanceName);
- Optional<Elan> elanInstance = MDSALUtil.read(broker, LogicalDatastoreType.OPERATIONAL,
- elanIdentifier);
- if (elanInstance.isPresent()) {
- return elanInstance.get();
- }
- return null;
+ return MDSALUtil.read(broker, LogicalDatastoreType.OPERATIONAL, elanIdentifier).orNull();
}
public static InstanceIdentifier<Elan> getElanInstanceOperationalDataPath(String elanInstanceName) {
public MacEntry getInterfaceMacEntriesOperationalDataPath(String interfaceName, PhysAddress physAddress) {
InstanceIdentifier<MacEntry> existingMacEntryId = getInterfaceMacEntriesIdentifierOperationalDataPath(
interfaceName, physAddress);
- Optional<MacEntry> existingInterfaceMacEntry = read(broker,
- LogicalDatastoreType.OPERATIONAL, existingMacEntryId);
- if (existingInterfaceMacEntry.isPresent()) {
- return existingInterfaceMacEntry.get();
- }
- return null;
+ return read(broker, LogicalDatastoreType.OPERATIONAL, existingMacEntryId).orNull();
}
public MacEntry getInterfaceMacEntriesOperationalDataPathFromId(InstanceIdentifier identifier) {
Optional<MacEntry> existingInterfaceMacEntry = read(broker,
LogicalDatastoreType.OPERATIONAL, identifier);
- if (existingInterfaceMacEntry.isPresent()) {
- return existingInterfaceMacEntry.get();
- }
- return null;
+ return existingInterfaceMacEntry.orNull();
}
public static InstanceIdentifier<MacEntry> getInterfaceMacEntriesIdentifierOperationalDataPath(String interfaceName,
}
// elan-forwarding-tables Operational container
- public MacEntry getMacTableByElanName(String elanName, PhysAddress physAddress) {
+ public Optional<MacEntry> getMacEntryForElanInstance(String elanName, PhysAddress physAddress) {
InstanceIdentifier<MacEntry> macId = getMacEntryOperationalDataPath(elanName, physAddress);
- Optional<MacEntry> existingElanMacEntry = read(broker,
- LogicalDatastoreType.OPERATIONAL, macId);
- if (existingElanMacEntry.isPresent()) {
- return existingElanMacEntry.get();
- }
- return null;
+ return read(broker, LogicalDatastoreType.OPERATIONAL, macId);
}
public MacEntry getMacEntryFromElanMacId(InstanceIdentifier identifier) {
Optional<MacEntry> existingInterfaceMacEntry = read(broker,
LogicalDatastoreType.OPERATIONAL, identifier);
- if (existingInterfaceMacEntry.isPresent()) {
- return existingInterfaceMacEntry.get();
- }
- return null;
+ return existingInterfaceMacEntry.orNull();
}
public static InstanceIdentifier<MacEntry> getMacEntryOperationalDataPath(String elanName,
public ElanInterfaceMac getElanInterfaceMacByInterfaceName(String interfaceName) {
InstanceIdentifier<ElanInterfaceMac> elanInterfaceId = getElanInterfaceMacEntriesOperationalDataPath(
interfaceName);
- Optional<ElanInterfaceMac> existingElanInterface = read(broker,
- LogicalDatastoreType.OPERATIONAL, elanInterfaceId);
- if (existingElanInterface.isPresent()) {
- return existingElanInterface.get();
- }
- return null;
+ return read(broker, LogicalDatastoreType.OPERATIONAL, elanInterfaceId).orNull();
}
/**
public DpnInterfaces getElanInterfaceInfoByElanDpn(String elanInstanceName, BigInteger dpId) {
InstanceIdentifier<DpnInterfaces> elanDpnInterfacesId = getElanDpnInterfaceOperationalDataPath(elanInstanceName,
dpId);
- Optional<DpnInterfaces> elanDpnInterfaces = read(broker,
- LogicalDatastoreType.OPERATIONAL, elanDpnInterfacesId);
- if (elanDpnInterfaces.isPresent()) {
- return elanDpnInterfaces.get();
- }
- return null;
+ return read(broker, LogicalDatastoreType.OPERATIONAL, elanDpnInterfacesId).orNull();
}
/**
InstanceIdentifier<ElanTagName> elanId = getElanInfoEntriesOperationalDataPath(elanTag);
Optional<ElanTagName> existingElanInfo = read(broker,
LogicalDatastoreType.OPERATIONAL, elanId);
- if (existingElanInfo.isPresent()) {
- return existingElanInfo.get();
- }
- return null;
+ return existingElanInfo.orNull();
}
public EtreeLeafTagName getEtreeLeafTagByElanTag(long elanTag) {
LogicalDatastoreType.OPERATIONAL, elanId);
if (existingElanInfo.isPresent()) {
ElanTagName elanTagName = existingElanInfo.get();
- EtreeLeafTagName etreeAugmentation = elanTagName.getAugmentation(EtreeLeafTagName.class);
- return etreeAugmentation;
+ return elanTagName.getAugmentation(EtreeLeafTagName.class);
}
return null;
}
public ElanDpnInterfacesList getElanDpnInterfacesList(String elanName) {
InstanceIdentifier<ElanDpnInterfacesList> elanDpnInterfaceId = getElanDpnOperationDataPath(elanName);
- Optional<ElanDpnInterfacesList> existingElanDpnInterfaces = read(broker,
- LogicalDatastoreType.OPERATIONAL, elanDpnInterfaceId);
- if (existingElanDpnInterfaces.isPresent()) {
- return existingElanDpnInterfaces.get();
- }
- return null;
+ return read(broker, LogicalDatastoreType.OPERATIONAL, elanDpnInterfaceId).orNull();
+ }
+
+ public ElanDpnInterfaces getElanDpnInterfacesList() {
+ InstanceIdentifier<ElanDpnInterfaces> elanDpnInterfaceId = InstanceIdentifier.builder(ElanDpnInterfaces.class)
+ .build();
+ return read(broker, LogicalDatastoreType.OPERATIONAL, elanDpnInterfaceId).orNull();
}
/**
* the elan instance name
* @return list of dpIds
*/
- public List<BigInteger> getParticipatingDPNsInElanInstance(String elanInstanceName) {
+ public List<BigInteger> getParticipatingDpnsInElanInstance(String elanInstanceName) {
List<BigInteger> dpIds = new ArrayList<>();
InstanceIdentifier<ElanDpnInterfacesList> elanDpnInterfaceId = getElanDpnOperationDataPath(elanInstanceName);
Optional<ElanDpnInterfacesList> existingElanDpnInterfaces = read(broker,
* @return true if dpId is already present, otherwise return false
*/
public boolean isDpnAlreadyPresentInElanInstance(BigInteger dpId, String elanInstanceName) {
- boolean isDpIdPresent = false;
InstanceIdentifier<ElanDpnInterfacesList> elanDpnInterfaceId = getElanDpnOperationDataPath(elanInstanceName);
Optional<ElanDpnInterfacesList> existingElanDpnInterfaces = read(broker,
LogicalDatastoreType.OPERATIONAL, elanDpnInterfaceId);
if (!existingElanDpnInterfaces.isPresent()) {
- return isDpIdPresent;
+ return false;
}
List<DpnInterfaces> dpnInterfaces = existingElanDpnInterfaces.get().getDpnInterfaces();
for (DpnInterfaces dpnInterface : dpnInterfaces) {
if (dpnInterface.getDpId().equals(dpId)) {
- isDpIdPresent = true;
- break;
+ return true;
}
}
- return isDpIdPresent;
- }
-
- public ElanDpnInterfaces getElanDpnInterfacesList() {
- InstanceIdentifier<ElanDpnInterfaces> elanDpnInterfaceId = InstanceIdentifier.builder(ElanDpnInterfaces.class)
- .build();
- Optional<ElanDpnInterfaces> existingElanDpnInterfaces = read(broker,
- LogicalDatastoreType.OPERATIONAL, elanDpnInterfaceId);
- if (existingElanDpnInterfaces.isPresent()) {
- return existingElanDpnInterfaces.get();
- }
- return null;
+ return false;
}
public ElanForwardingTables getElanForwardingList() {
InstanceIdentifier<ElanForwardingTables> elanForwardingTableId = InstanceIdentifier
.builder(ElanForwardingTables.class).build();
- Optional<ElanForwardingTables> existingElanForwardingList = read(broker,
- LogicalDatastoreType.OPERATIONAL, elanForwardingTableId);
- if (existingElanForwardingList.isPresent()) {
- return existingElanForwardingList.get();
- }
- return null;
+ return read(broker, LogicalDatastoreType.OPERATIONAL, elanForwardingTableId).orNull();
+ }
+
+ public static long getElanRemoteBroadCastGroupID(long elanTag) {
+ return ElanConstants.ELAN_GID_MIN + (((elanTag % ElanConstants.ELAN_GID_MIN) * 2));
}
/**
*/
public MacTable getElanMacTable(String elanName) {
InstanceIdentifier<MacTable> elanMacTableId = getElanMacTableOperationalDataPath(elanName);
- Optional<MacTable> existingElanMacTable = read(broker,
- LogicalDatastoreType.OPERATIONAL, elanMacTableId);
- if (existingElanMacTable.isPresent()) {
- return existingElanMacTable.get();
- }
- return null;
+ return read(broker, LogicalDatastoreType.OPERATIONAL, elanMacTableId).orNull();
}
- public static long getElanLocalBCGID(long elanTag) {
+ public static long getElanLocalBCGId(long elanTag) {
return ElanConstants.ELAN_GID_MIN + (elanTag % ElanConstants.ELAN_GID_MIN * 2 - 1);
}
- public static long getElanRemoteBCGID(long elanTag) {
+ public static long getElanRemoteBCGId(long elanTag) {
return ElanConstants.ELAN_GID_MIN + elanTag % ElanConstants.ELAN_GID_MIN * 2;
}
- public static long getEtreeLeafLocalBCGID(long etreeLeafTag) {
+ public static long getEtreeLeafLocalBCGId(long etreeLeafTag) {
return ElanConstants.ELAN_GID_MIN + (etreeLeafTag % ElanConstants.ELAN_GID_MIN * 2 - 1);
}
- public static long getEtreeLeafRemoteBCGID(long etreeLeafTag) {
+ public static long getEtreeLeafRemoteBCGId(long etreeLeafTag) {
return ElanConstants.ELAN_GID_MIN + etreeLeafTag % ElanConstants.ELAN_GID_MIN * 2;
}
}
/**
- * Setting INTERNAL_TUNNEL_TABLE, SMAC, DMAC, UDMAC in this DPN and also in
- * other DPNs.
+ * Setting INTERNAL_TUNNEL_TABLE, SMAC, DMAC, UDMAC in this DPN and optionally in other DPNs.
*
* @param elanInfo
* the elan info
* the mac timeout
* @param macAddress
* the mac address
+ * @param configureRemoteFlows
+ * true if remote dmac flows should be configured as well
* @param writeFlowGroupTx
* the flow group tx
+ * @throws ElanException in case of issues creating the flow objects
*/
- public void setupMacFlows(ElanInstance elanInfo, InterfaceInfo interfaceInfo, long macTimeout,
- String macAddress, WriteTransaction writeFlowGroupTx) {
- synchronized (macAddress) {
- LOG.debug("Acquired lock for mac : " + macAddress + ". Proceeding with install operation.");
+ public void setupMacFlows(ElanInstance elanInfo, InterfaceInfo interfaceInfo,
+ long macTimeout, String macAddress, boolean configureRemoteFlows,
+ WriteTransaction writeFlowGroupTx) throws ElanException {
+ synchronized (getElanMacKey(elanInfo.getElanTag(), macAddress)) {
setupKnownSmacFlow(elanInfo, interfaceInfo, macTimeout, macAddress, mdsalManager,
- writeFlowGroupTx);
- setupOrigDmacFlows(elanInfo, interfaceInfo, macAddress, mdsalManager,
- broker, writeFlowGroupTx);
+ writeFlowGroupTx);
+ setupOrigDmacFlows(elanInfo, interfaceInfo, macAddress, configureRemoteFlows, mdsalManager,
+ broker, writeFlowGroupTx);
}
}
public void setupDMacFlowonRemoteDpn(ElanInstance elanInfo, InterfaceInfo interfaceInfo, BigInteger dstDpId,
- String macAddress, WriteTransaction writeFlowTx) {
- synchronized (macAddress) {
+ String macAddress, WriteTransaction writeFlowTx) throws ElanException {
+ synchronized (getElanMacKey(elanInfo.getElanTag(), macAddress)) {
LOG.debug("Acquired lock for mac : " + macAddress + ". Proceeding with install operation.");
setupOrigDmacFlowsonRemoteDpn(elanInfo, interfaceInfo, dstDpId, macAddress, writeFlowTx);
}
String macAddress, IMdsalApiManager mdsalApiManager, WriteTransaction writeFlowGroupTx) {
FlowEntity flowEntity = buildKnownSmacFlow(elanInfo, interfaceInfo, macTimeout, macAddress);
mdsalApiManager.addFlowToTx(flowEntity, writeFlowGroupTx);
- if (LOG.isDebugEnabled()) {
- LOG.debug("Known Smac flow entry created for elan Name:{}, logical Interface port:{} and mac address:{}",
- elanInfo.getElanInstanceName(), elanInfo.getDescription(), macAddress);
- }
+ LOG.debug("Known Smac flow entry created for elan Name:{}, logical Interface port:{} and mac address:{}",
+ elanInfo.getElanInstanceName(), elanInfo.getDescription(), macAddress);
}
public FlowEntity buildKnownSmacFlow(ElanInstance elanInfo, InterfaceInfo interfaceInfo, long macTimeout,
} else { // Leaf
EtreeInstance etreeInstance = elanInfo.getAugmentation(EtreeInstance.class);
if (etreeInstance == null) {
- LOG.warn("EtreeInterface " + interfaceInfo.getInterfaceName() + " is connected to a non-Etree network: "
- + elanInfo.getElanInstanceName());
+ LOG.warn("EtreeInterface {} is connected to a non-Etree network: {}",
+ interfaceInfo.getInterfaceName(), elanInfo.getElanInstanceName());
return elanInfo.getElanTag();
} else {
return etreeInstance.getEtreeLeafTagVal().getValue();
getTunnelIdMatchForFilterEqualsLPortTag(lportTag),
getInstructionsInPortForOutGroup(interfaceInfo.getInterfaceName()));
mdsalApiManager.addFlowToTx(dpId, flow, writeFlowGroupTx);
- if (LOG.isDebugEnabled()) {
- LOG.debug("Terminating service table flow entry created on dpn:{} for logical Interface port:{}", dpId,
- interfaceInfo.getPortName());
- }
+ LOG.debug("Terminating service table flow entry created on dpn:{} for logical Interface port:{}", dpId,
+ interfaceInfo.getPortName());
}
/**
* the tunnel key
* @return the egress actions for interface
*/
+ @SuppressWarnings("checkstyle:IllegalCatch")
public List<Action> getEgressActionsForInterface(String ifName, Long tunnelKey) {
List<Action> listAction = new ArrayList<>();
try {
List<Action> actions = rpcResult.getResult().getAction();
listAction = actions;
}
- } catch (InterruptedException | ExecutionException e) {
+ } catch (Exception e) {
LOG.warn("Exception when egress actions for interface {}", ifName, e);
}
return listAction;
}
private void setupOrigDmacFlows(ElanInstance elanInfo, InterfaceInfo interfaceInfo, String macAddress,
- IMdsalApiManager mdsalApiManager, DataBroker broker, WriteTransaction writeFlowGroupTx) {
+ boolean configureRemoteFlows, IMdsalApiManager mdsalApiManager,
+ DataBroker broker, WriteTransaction writeFlowGroupTx)
+ throws ElanException {
BigInteger dpId = interfaceInfo.getDpId();
String ifName = interfaceInfo.getInterfaceName();
long ifTag = interfaceInfo.getInterfaceTag();
String elanInstanceName = elanInfo.getElanInstanceName();
+
+ Long elanTag = getElanTag(broker, elanInfo, interfaceInfo);
+
+ setupLocalDmacFlow(elanTag, dpId, ifName, macAddress, elanInstanceName, mdsalApiManager, ifTag,
+ writeFlowGroupTx);
+ LOG.debug("Dmac flow entry created for elan Name:{}, logical port Name:{} mand mac address:{} "
+ + "on dpn:{}", elanInstanceName, interfaceInfo.getPortName(), macAddress, dpId);
+
+ if (!configureRemoteFlows) {
+ return;
+ }
+
List<DpnInterfaces> elanDpns = getInvolvedDpnsInElan(elanInstanceName);
- if (elanDpns != null) {
- // TODO might be bug and should call here just elanInfo.getElanTag()
- Long elanTag = getElanTag(broker, elanInfo, interfaceInfo);
- for (DpnInterfaces elanDpn : elanDpns) {
- if (elanDpn.getDpId().equals(dpId)) {
- // On the local DPN set up a direct output flow
- setupLocalDmacFlow(elanTag, dpId, ifName, macAddress, elanInstanceName, mdsalApiManager, ifTag,
- writeFlowGroupTx);
- LOG.debug("Dmac flow entry created for elan Name:{}, logical port Name:{} mand mac address:{} "
- + "on dpn:{}", elanInstanceName, interfaceInfo.getPortName(), macAddress, dpId);
- } else {
- // Check for the Remote DPN present in Inventory Manager
- if (isDpnPresent(elanDpn.getDpId())) {
- // For remote DPNs a flow is needed to indicate that
- // packets of this ELAN going to this MAC
- // need to be forwarded through the appropiated ITM
- // tunnel
- setupRemoteDmacFlow(elanDpn.getDpId(), // srcDpn (the
- // remote DPN in
- // this case)
- dpId, // dstDpn (the local DPN)
- interfaceInfo.getInterfaceTag(), // lportTag of
- // the local
- // interface
- elanTag, // identifier of the Elan
- macAddress, // MAC to be programmed in remote
- // DPN
- elanInstanceName, writeFlowGroupTx, ifName);
- LOG.debug("Dmac flow entry created for elan Name:{}, logical port Name:{} and mac address:{} on"
- + " dpn:{}", elanInstanceName, interfaceInfo.getPortName(), macAddress,
- elanDpn.getDpId());
- }
- }
+ if (elanDpns == null) {
+ return;
+ }
+
+ for (DpnInterfaces elanDpn : elanDpns) {
+
+ if (elanDpn.getDpId().equals(dpId)) {
+ continue;
+ }
+
+ // Check for the Remote DPN present in Inventory Manager
+ if (!isDpnPresent(elanDpn.getDpId())) {
+ continue;
}
- // TODO: Make sure that the same is performed against the
- // ElanDevices.
+ // For remote DPNs a flow is needed to indicate that
+ // packets of this ELAN going to this MAC
+ // need to be forwarded through the appropiated ITM
+ // tunnel
+ setupRemoteDmacFlow(elanDpn.getDpId(), // srcDpn (the remote DPN in this case)
+ dpId, // dstDpn (the local DPN)
+ interfaceInfo.getInterfaceTag(), // lportTag of the local interface
+ elanTag, // identifier of the Elan
+ macAddress, // MAC to be programmed in remote DPN
+ elanInstanceName, writeFlowGroupTx, ifName, elanInfo);
+ LOG.debug("Dmac flow entry created for elan Name:{}, logical port Name:{} and mac address:{} on"
+ + " dpn:{}", elanInstanceName, interfaceInfo.getPortName(), macAddress, elanDpn.getDpId());
}
+
+ // TODO: Make sure that the same is performed against the ElanDevices.
}
private void setupOrigDmacFlowsonRemoteDpn(ElanInstance elanInfo, InterfaceInfo interfaceInfo,
- BigInteger dstDpId, String macAddress, WriteTransaction writeFlowTx) {
+ BigInteger dstDpId, String macAddress, WriteTransaction writeFlowTx) throws ElanException {
BigInteger dpId = interfaceInfo.getDpId();
String elanInstanceName = elanInfo.getElanInstanceName();
List<DpnInterfaces> remoteFEs = getInvolvedDpnsInElan(elanInstanceName);
if (remoteFE.getDpId().equals(dstDpId)) {
// Check for the Remote DPN present in Inventory Manager
setupRemoteDmacFlow(dstDpId, dpId, interfaceInfo.getInterfaceTag(), elanTag, macAddress,
- elanInstanceName, writeFlowTx, interfaceInfo.getInterfaceName());
- if (LOG.isDebugEnabled()) {
- LOG.debug("Dmac flow entry created for elan Name:{}, logical port Name:{} and mac address {} on"
- + " dpn:{}", elanInstanceName, interfaceInfo.getPortName(), macAddress, remoteFE.getDpId());
- }
+ elanInstanceName, writeFlowTx, interfaceInfo.getInterfaceName(), elanInfo);
+ LOG.debug("Dmac flow entry created for elan Name:{}, logical port Name:{} and mac address {} on dpn:{}",
+ elanInstanceName, interfaceInfo.getPortName(), macAddress, remoteFE.getDpId());
break;
}
}
if (etreeInterface.getEtreeInterfaceType() == EtreeInterfaceType.Root) {
EtreeLeafTagName etreeTagName = getEtreeLeafTagByElanTag(elanTag);
if (etreeTagName == null) {
- LOG.warn("Interface " + ifName + " seems like it belongs to Etree but etreeTagName from elanTag "
- + elanTag + " is null.");
+ LOG.warn("Interface {} seems like it belongs to Etree but etreeTagName from elanTag {} is null",
+ ifName, elanTag);
} else {
Flow flowEntity = buildLocalDmacFlowEntry(etreeTagName.getEtreeLeafTag().getValue(), dpId, ifName,
macAddress, displayName, ifTag);
.toString();
}
+ public static String getKnownDynamicmacFlowRef(short tableId, BigInteger dpId, String macAddress, long elanTag) {
+ return new StringBuffer().append(tableId).append(elanTag).append(dpId).append(macAddress).toString();
+ }
+
private static String getKnownDynamicmacFlowRef(short elanDmacTable, BigInteger dpId, String extDeviceNodeId,
String dstMacAddress, long elanTag, boolean shFlag) {
return new StringBuffer().append(elanDmacTable).append(elanTag).append(dpId).append(extDeviceNodeId)
}
public void setupRemoteDmacFlow(BigInteger srcDpId, BigInteger destDpId, int lportTag, long elanTag,
- String macAddress, String displayName, WriteTransaction writeFlowGroupTx, String interfaceName) {
- Flow flowEntity = buildRemoteDmacFlowEntry(srcDpId, destDpId, lportTag, elanTag, macAddress, displayName);
+ String macAddress, String displayName, WriteTransaction writeFlowGroupTx, String interfaceName,
+ ElanInstance elanInstance) throws ElanException {
+ Flow flowEntity = buildRemoteDmacFlowEntry(srcDpId, destDpId, lportTag, elanTag, macAddress, displayName,
+ elanInstance);
mdsalManager.addFlowToTx(srcDpId, flowEntity, writeFlowGroupTx);
setupEtreeRemoteDmacFlow(srcDpId, destDpId, lportTag, elanTag, macAddress, displayName, interfaceName,
- writeFlowGroupTx);
+ writeFlowGroupTx, elanInstance);
}
private void setupEtreeRemoteDmacFlow(BigInteger srcDpId, BigInteger destDpId, int lportTag, long elanTag,
- String macAddress, String displayName, String interfaceName, WriteTransaction writeFlowGroupTx) {
+ String macAddress, String displayName, String interfaceName,
+ WriteTransaction writeFlowGroupTx, ElanInstance elanInstance) throws ElanException {
Flow flowEntity;
EtreeInterface etreeInterface = getEtreeInterfaceByElanInterfaceName(broker, interfaceName);
if (etreeInterface != null) {
+ " seems like it belongs to Etree but etreeTagName from elanTag " + elanTag + " is null.");
} else {
flowEntity = buildRemoteDmacFlowEntry(srcDpId, destDpId, lportTag,
- etreeTagName.getEtreeLeafTag().getValue(), macAddress, displayName);
+ etreeTagName.getEtreeLeafTag().getValue(), macAddress, displayName, elanInstance);
mdsalManager.addFlowToTx(srcDpId, flowEntity, writeFlowGroupTx);
}
}
* @param displayName
* display Name
* @return the flow remote Dmac
+ * @throws ElanException in case of issues creating the flow objects
*/
+ @SuppressWarnings("checkstyle:IllegalCatch")
public Flow buildRemoteDmacFlowEntry(BigInteger srcDpId, BigInteger destDpId, int lportTag, long elanTag,
- String macAddress, String displayName) {
+ String macAddress, String displayName, ElanInstance elanInstance) throws ElanException {
List<MatchInfo> mkMatches = new ArrayList<>();
mkMatches.add(new MatchInfo(MatchFieldType.metadata,
new BigInteger[] { getElanMetadataLabel(elanTag), MetaDataUtil.METADATA_MASK_SERVICE }));
// List of Action for the provided Source and Destination DPIDs
try {
- List<Action> actions = getInternalTunnelItmEgressAction(srcDpId, destDpId, lportTag);
+ List<Action> actions = null;
+ if (isVlan(elanInstance) || isFlat(elanInstance)) {
+ String interfaceName = getExternalElanInterface(elanInstance.getElanInstanceName(), srcDpId);
+ if (null == interfaceName) {
+ LOG.error("buildRemoteDmacFlowEntry: Could not find interfaceName for {} {}", srcDpId,
+ elanInstance);
+ }
+ actions = getEgressActionsForInterface(interfaceName, null);
+ } else {
+ actions = getInternalTunnelItmEgressAction(srcDpId, destDpId, lportTag);
+ }
mkInstructions.add(MDSALUtil.buildApplyActionsInstruction(actions));
} catch (Exception e) {
- LOG.error("Interface Not Found exception");
+ LOG.error("Could not get egress actions to add to flow for srcDpId=" + srcDpId + ", destDpId=" + destDpId
+ + ", lportTag=" + lportTag, e);
}
Flow flow = MDSALUtil.buildFlowNew(NwConstants.ELAN_DMAC_TABLE,
return;
}
String macAddress = macEntry.getMacAddress().getValue();
- synchronized (macAddress) {
- LOG.debug("Acquired lock for mac : " + macAddress + ". Proceeding with remove operation.");
+ synchronized (getElanMacKey(elanInfo.getElanTag(), macAddress)) {
deleteMacFlows(elanInfo, interfaceInfo, macAddress, /* alsoDeleteSMAC */ true, deleteFlowGroupTx);
}
}
MDSALUtil.buildFlow(NwConstants.ELAN_DMAC_TABLE, getKnownDynamicmacFlowRef(
NwConstants.ELAN_DMAC_TABLE, dstDpId, srcdpId, macAddress, elanTag)),
deleteFlowGroupTx);
- if (LOG.isDebugEnabled()) {
- LOG.debug("Dmac flow entry deleted for elan:{}, logical interface port:{} and mac address:{} on dpn:{}",
- elanInstanceName, interfaceInfo.getPortName(), macAddress, dstDpId);
- }
+ LOG.debug("Dmac flow entry deleted for elan:{}, logical interface port:{} and mac address:{} on dpn:{}",
+ elanInstanceName, interfaceInfo.getPortName(), macAddress, dstDpId);
}
return isFlowsRemovedInSrcDpn;
}
MDSALUtil.buildFlow(NwConstants.ELAN_DMAC_TABLE,
getKnownDynamicmacFlowRef(NwConstants.ELAN_DMAC_TABLE, srcdpId, ifTag, macAddress, elanTag)),
deleteFlowGroupTx);
- if (LOG.isDebugEnabled()) {
- LOG.debug("All the required flows deleted for elan:{}, logical Interface port:{} and MAC address:{} "
- + "on dpn:{}", elanInstanceName, interfaceInfo.getPortName(), macAddress, srcdpId);
- }
+ LOG.debug("All the required flows deleted for elan:{}, logical Interface port:{} and MAC address:{} on dpn:{}",
+ elanInstanceName, interfaceInfo.getPortName(), macAddress, srcdpId);
}
/**
InstanceIdentifier<Node> node = InstanceIdentifier.builder(Nodes.class).child(Node.class, new NodeKey(nodeId))
.build();
- Optional<Node> nodePresent = read(broker, LogicalDatastoreType.OPERATIONAL, node);
- return nodePresent.isPresent();
+ return read(broker, LogicalDatastoreType.OPERATIONAL, node).isPresent();
}
public static ServicesInfo getServiceInfo(String elanInstanceName, long elanTag, String interfaceName) {
return serviceInfo;
}
- public static <T extends DataObject> void delete(DataBroker broker, LogicalDatastoreType datastoreType,
- InstanceIdentifier<T> path, FutureCallback<Void> callback) {
- WriteTransaction tx = broker.newWriteOnlyTransaction();
- tx.delete(datastoreType, path);
- Futures.addCallback(tx.submit(), callback);
- }
-
public static <T extends DataObject> void syncWrite(DataBroker broker, LogicalDatastoreType datastoreType,
InstanceIdentifier<T> path, T data) {
WriteTransaction tx = broker.newWriteOnlyTransaction();
* tunnels, etc.
* @return the list
*/
+ @SuppressWarnings("checkstyle:IllegalCatch")
public List<Action> buildItmEgressActions(String interfaceName, Long tunnelKey) {
List<Action> result = Collections.emptyList();
- GetEgressActionsForInterfaceInput getEgressActInput = new GetEgressActionsForInterfaceInputBuilder()
- .setIntfName(interfaceName).setTunnelKey(tunnelKey).build();
-
- Future<RpcResult<GetEgressActionsForInterfaceOutput>> egressActionsOutputFuture = interfaceManagerRpcService
- .getEgressActionsForInterface(getEgressActInput);
try {
+ GetEgressActionsForInterfaceInput getEgressActInput = new GetEgressActionsForInterfaceInputBuilder()
+ .setIntfName(interfaceName).setTunnelKey(tunnelKey).build();
+
+ Future<RpcResult<GetEgressActionsForInterfaceOutput>> egressActionsOutputFuture = interfaceManagerRpcService
+ .getEgressActionsForInterface(getEgressActInput);
if (egressActionsOutputFuture.get().isSuccessful()) {
GetEgressActionsForInterfaceOutput egressActionsOutput = egressActionsOutputFuture.get().getResult();
result = egressActionsOutput.getAction();
}
- } catch (InterruptedException | ExecutionException e) {
+ } catch (Exception e) {
LOG.error("Error in RPC call getEgressActionsForInterface {}", e);
}
if (output.get().isSuccessful()) {
GetExternalTunnelInterfaceNameOutput tunnelInterfaceNameOutput = output.get().getResult();
String tunnelIfaceName = tunnelInterfaceNameOutput.getInterfaceName();
- if (LOG.isDebugEnabled()) {
- LOG.debug("Received tunnelInterfaceName from getTunnelInterfaceName RPC {}", tunnelIfaceName);
- }
+ LOG.debug("Received tunnelInterfaceName from getTunnelInterfaceName RPC {}", tunnelIfaceName);
result = buildTunnelItmEgressActions(tunnelIfaceName, vni);
}
public static TunnelList buildInternalTunnel(DataBroker broker) {
InstanceIdentifier<TunnelList> tunnelListInstanceIdentifier = InstanceIdentifier.builder(TunnelList.class)
.build();
- Optional<TunnelList> tunnelList = MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION,
- tunnelListInstanceIdentifier);
- if (tunnelList.isPresent()) {
- return tunnelList.get();
- }
- return null;
+ return MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, tunnelListInstanceIdentifier).orNull();
}
/**
*/
public ExternalTunnel getExternalTunnel(String sourceDevice, String destinationDevice,
LogicalDatastoreType datastoreType) {
- ExternalTunnel externalTunnel = null;
Class<? extends TunnelTypeBase> tunType = TunnelTypeVxlan.class;
InstanceIdentifier<ExternalTunnel> iid = InstanceIdentifier.builder(ExternalTunnelList.class)
.child(ExternalTunnel.class, new ExternalTunnelKey(destinationDevice, sourceDevice, tunType)).build();
- Optional<ExternalTunnel> tunnelList = read(broker, datastoreType, iid);
- if (tunnelList.isPresent()) {
- externalTunnel = tunnelList.get();
- }
- return externalTunnel;
+ return read(broker, datastoreType, iid).orNull();
}
/**
* @return the all external tunnels
*/
public List<ExternalTunnel> getAllExternalTunnels(LogicalDatastoreType datastoreType) {
- List<ExternalTunnel> result = null;
InstanceIdentifier<ExternalTunnelList> iid = InstanceIdentifier.builder(ExternalTunnelList.class).build();
- Optional<ExternalTunnelList> tunnelList = read(broker, datastoreType, iid);
- if (tunnelList.isPresent()) {
- result = tunnelList.get().getExternalTunnel();
- }
- if (result == null) {
- result = Collections.emptyList();
- }
- return result;
+ return read(broker, datastoreType, iid).transform(ExternalTunnelList::getExternalTunnel).or(
+ Collections.emptyList());
}
/**
* MAC to be installed in remoteDpId's DMAC table
* @param displayName
* the display name
+ * @throws ElanException in case of issues creating the flow objects
*/
- public void installDmacFlowsToInternalRemoteMac(BigInteger localDpId, BigInteger remoteDpId, long lportTag,
- long elanTag, String macAddress, String displayName) {
+ public void installDmacFlowsToInternalRemoteMac(BigInteger localDpId, BigInteger remoteDpId, int lportTag,
+ long elanTag, String macAddress, String displayName) throws ElanException {
Flow flow = buildDmacFlowForInternalRemoteMac(localDpId, remoteDpId, lportTag, elanTag, macAddress,
displayName);
mdsalManager.installFlow(remoteDpId, flow);
* the interface name
*
* @return the dmac flows
+ * @throws ElanException in case of issues creating the flow objects
*/
public List<ListenableFuture<Void>> installDmacFlowsToExternalRemoteMac(BigInteger dpnId,
String extDeviceNodeId, Long elanTag, Long vni, String macAddress, String displayName,
- String interfaceName) {
+ String interfaceName) throws ElanException {
List<ListenableFuture<Void>> futures = new ArrayList<>();
- synchronized (macAddress) {
+ synchronized (getElanMacKey(elanTag, macAddress)) {
Flow flow = buildDmacFlowForExternalRemoteMac(dpnId, extDeviceNodeId, elanTag, vni, macAddress,
displayName);
futures.add(mdsalManager.installFlow(dpnId, flow));
private void installEtreeDmacFlowsToExternalRemoteMac(BigInteger dpnId, String extDeviceNodeId, Long elanTag,
Long vni, String macAddress, String displayName, String interfaceName,
- List<ListenableFuture<Void>> futures) {
+ List<ListenableFuture<Void>> futures) throws ElanException {
EtreeLeafTagName etreeLeafTag = getEtreeLeafTagByElanTag(elanTag);
if (etreeLeafTag != null) {
buildEtreeDmacFlowDropIfPacketComingFromTunnel(dpnId, extDeviceNodeId, elanTag, macAddress, futures,
private void buildEtreeDmacFlowForExternalRemoteMac(BigInteger dpnId, String extDeviceNodeId, Long vni,
String macAddress, String displayName, String interfaceName, List<ListenableFuture<Void>> futures,
- EtreeLeafTagName etreeLeafTag) {
+ EtreeLeafTagName etreeLeafTag) throws ElanException {
boolean isRoot = false;
if (interfaceName == null) {
isRoot = true;
* @param displayName
* the display name
* @return the flow
+ * @throws ElanException in case of issues creating the flow objects
*/
+ @SuppressWarnings("checkstyle:IllegalCatch")
public Flow buildDmacFlowForExternalRemoteMac(BigInteger dpId, String extDeviceNodeId, long elanTag,
- Long vni, String dstMacAddress, String displayName) {
+ Long vni, String dstMacAddress, String displayName) throws ElanException {
List<MatchInfo> mkMatches = buildMatchesForElanTagShFlagAndDstMac(elanTag, /* shFlag */ false, dstMacAddress);
List<Instruction> mkInstructions = new ArrayList<>();
try {
List<Action> actions = getExternalTunnelItmEgressAction(dpId, new NodeId(extDeviceNodeId), vni);
mkInstructions.add(MDSALUtil.buildApplyActionsInstruction(actions));
} catch (Exception e) {
- LOG.error("Could not get Egress Actions for DpId={} externalNode={}", dpId, extDeviceNodeId);
+ LOG.error("Could not get Egress Actions for DpId=" + dpId + ", externalNode=" + extDeviceNodeId, e);
}
Flow flow = MDSALUtil.buildFlowNew(NwConstants.ELAN_DMAC_TABLE,
* @param displayName
* the display name
* @return the flow
+ * @throws ElanException in case of issues creating the flow objects
*/
- public Flow buildDmacFlowForInternalRemoteMac(BigInteger localDpId, BigInteger remoteDpId, long lportTag,
- long elanTag, String macAddress, String displayName) {
+ @SuppressWarnings("checkstyle:IllegalCatch")
+ public Flow buildDmacFlowForInternalRemoteMac(BigInteger localDpId, BigInteger remoteDpId, int lportTag,
+ long elanTag, String macAddress, String displayName) throws ElanException {
List<MatchInfo> mkMatches = buildMatchesForElanTagShFlagAndDstMac(elanTag, /* shFlag */ false, macAddress);
List<Instruction> mkInstructions = new ArrayList<>();
List<Action> actions = getInternalTunnelItmEgressAction(localDpId, remoteDpId, lportTag);
mkInstructions.add(MDSALUtil.buildApplyActionsInstruction(actions));
} catch (Exception e) {
- LOG.error("Could not get Egress Actions for localDpId={} remoteDpId={} lportTag={}", localDpId,
- remoteDpId, lportTag);
+ LOG.error("Could not get Egress Actions for localDpId=" + localDpId + ", remoteDpId="
+ + remoteDpId + ", lportTag=" + lportTag, e);
}
Flow flow = MDSALUtil.buildFlowNew(NwConstants.ELAN_DMAC_TABLE,
* Indicates if flows must be installed or removed.
* @param interfaceName
* the interface name
+ * @throws ElanException in case of issues creating the flow objects
* @see org.opendaylight.genius.mdsalutil.MDSALUtil.MdsalOp
*/
public void setupDmacFlowsToExternalRemoteMac(BigInteger dpId, String extNodeId, Long elanTag, Long vni,
- String macAddress, String elanInstanceName, MdsalOp addOrRemove, String interfaceName) {
+ String macAddress, String elanInstanceName, MdsalOp addOrRemove, String interfaceName)
+ throws ElanException {
if (addOrRemove == MdsalOp.CREATION_OP) {
installDmacFlowsToExternalRemoteMac(dpId, extNodeId, elanTag, vni, macAddress, elanInstanceName,
interfaceName);
public List<ListenableFuture<Void>> deleteDmacFlowsToExternalMac(long elanTag, BigInteger dpId,
String extDeviceNodeId, String macToRemove) {
List<ListenableFuture<Void>> futures = new ArrayList<>();
- synchronized (macToRemove) {
+ synchronized (getElanMacKey(elanTag, macToRemove)) {
// Removing the flows that sends the packet on an external tunnel
removeFlowThatSendsThePacketOnAnExternalTunnel(elanTag, dpId, extDeviceNodeId, macToRemove, futures);
InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
.ietf.interfaces.rev140508.interfaces.state.Interface> ifStateId = createInterfaceStateInstanceIdentifier(
interfaceName);
- Optional<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
- .ietf.interfaces.rev140508.interfaces.state.Interface> ifStateOptional = MDSALUtil
- .read(dataBroker, LogicalDatastoreType.OPERATIONAL, ifStateId);
- if (ifStateOptional.isPresent()) {
- return ifStateOptional.get();
- }
- return null;
- }
-
- /**
- * Gets the interface from config ds.
- *
- * @param interfaceName
- * the interface name
- * @param dataBroker
- * the data broker
- * @return the interface from config ds
- */
- public static org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
- .ietf.interfaces.rev140508.interfaces.Interface getInterfaceFromConfigDS(
- String interfaceName, DataBroker dataBroker) {
- InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
- .ietf.interfaces.rev140508.interfaces.Interface> ifaceId = createInterfaceInstanceIdentifier(interfaceName);
- Optional<org.opendaylight.yang.gen.v1.urn
- .ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface> iface = MDSALUtil
- .read(dataBroker, LogicalDatastoreType.CONFIGURATION, ifaceId);
- if (iface.isPresent()) {
- return iface.get();
- }
- return null;
+ return MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, ifStateId).orNull();
}
/**
return idBuilder.build();
}
- /**
- * Creates the interface instance identifier.
- *
- * @param interfaceName
- * the interface name
- * @return the instance identifier
- */
- public static InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
- .ietf.interfaces.rev140508.interfaces.Interface> createInterfaceInstanceIdentifier(
- String interfaceName) {
- InstanceIdentifierBuilder<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
- .ietf.interfaces.rev140508.interfaces.Interface> idBuilder = InstanceIdentifier
- .builder(Interfaces.class)
- .child(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
- .ietf.interfaces.rev140508.interfaces.Interface.class,
- new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
- .ietf.interfaces.rev140508.interfaces.InterfaceKey(
- interfaceName));
- return idBuilder.build();
- }
-
public static CheckedFuture<Void, TransactionCommitFailedException> waitForTransactionToComplete(
WriteTransaction tx) {
CheckedFuture<Void, TransactionCommitFailedException> futures = tx.submit();
&& elanInstance.getSegmentType().isAssignableFrom(SegmentTypeFlat.class);
}
- public boolean isExternal(String interfaceName) {
- return isExternal(getInterfaceFromConfigDS(interfaceName, broker));
+ public static boolean isEtreeRootInterfaceByInterfaceName(DataBroker broker, String interfaceName) {
+ EtreeInterface etreeInterface = getEtreeInterfaceByElanInterfaceName(broker, interfaceName);
+ if (etreeInterface != null && etreeInterface.getEtreeInterfaceType() == EtreeInterfaceType.Root) {
+ return true;
+ }
+ return false;
}
- public static boolean isExternal(
- org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
- .ietf.interfaces.rev140508.interfaces.Interface iface) {
- if (iface == null) {
- return false;
+ public void handleDmacRedirectToDispatcherFlows(Long elanTag, String displayName,
+ String macAddress, int addOrRemove, List<BigInteger> dpnIds) {
+ for (BigInteger dpId : dpnIds) {
+ if (addOrRemove == NwConstants.ADD_FLOW) {
+ WriteTransaction writeTx = broker.newWriteOnlyTransaction();
+ mdsalManager.addFlowToTx(buildDmacRedirectToDispatcherFlow(dpId, macAddress, displayName, elanTag),
+ writeTx);
+ writeTx.submit();
+ } else {
+ String flowId = getKnownDynamicmacFlowRef(NwConstants.ELAN_DMAC_TABLE, dpId, macAddress, elanTag);
+ mdsalManager.removeFlow(dpId, MDSALUtil.buildFlow(NwConstants.ELAN_DMAC_TABLE, flowId));
+ }
}
+ }
- IfExternal ifExternal = iface.getAugmentation(IfExternal.class);
- return ifExternal != null && Boolean.TRUE.equals(ifExternal.isExternal());
+ public static FlowEntity buildDmacRedirectToDispatcherFlow(BigInteger dpId, String dstMacAddress,
+ String displayName, long elanTag) {
+ List<MatchInfo> matches = new ArrayList<MatchInfo>();
+ matches.add(new MatchInfo(MatchFieldType.metadata,
+ new BigInteger[] { getElanMetadataLabel(elanTag), MetaDataUtil.METADATA_MASK_SERVICE }));
+ matches.add(new MatchInfo(MatchFieldType.eth_dst, new String[] { dstMacAddress }));
+ List<InstructionInfo> instructions = new ArrayList<InstructionInfo>();
+ List<ActionInfo> actions = new ArrayList<ActionInfo>();
+ actions.add(new ActionInfo(ActionType.nx_resubmit,
+ new String[] { String.valueOf(NwConstants.LPORT_DISPATCHER_TABLE) }));
+
+ instructions.add(new InstructionInfo(InstructionType.apply_actions, actions));
+ String flowId = getKnownDynamicmacFlowRef(NwConstants.ELAN_DMAC_TABLE, dpId, dstMacAddress, elanTag);
+ FlowEntity flow = MDSALUtil.buildFlowEntity(dpId, NwConstants.ELAN_DMAC_TABLE, flowId, 20, displayName, 0, 0,
+ ElanConstants.COOKIE_ELAN_KNOWN_DMAC.add(BigInteger.valueOf(elanTag)),
+ matches, instructions);
+ return flow;
}
- public static boolean isEtreeRootInterfaceByInterfaceName(DataBroker broker, String interfaceName) {
- EtreeInterface etreeInterface = getEtreeInterfaceByElanInterfaceName(broker, interfaceName);
- if (etreeInterface != null && etreeInterface.getEtreeInterfaceType() == EtreeInterfaceType.Root) {
- return true;
+ public static FlowEntity buildDmacRedirectToDispatcherFlowMacNoActions(BigInteger dpId, String dstMacAddress,
+ String displayName, long elanTag) {
+ List<MatchInfo> matches = new ArrayList<MatchInfo>();
+ matches.add(new MatchInfo(MatchFieldType.metadata,
+ new BigInteger[] { getElanMetadataLabel(elanTag), MetaDataUtil.METADATA_MASK_SERVICE }));
+ matches.add(new MatchInfo(MatchFieldType.eth_dst, new String[] { dstMacAddress }));
+
+ String flowId = getKnownDynamicmacFlowRef(NwConstants.ELAN_DMAC_TABLE, dpId, dstMacAddress, elanTag);
+ FlowEntity flow = MDSALUtil.buildFlowEntity(dpId, NwConstants.ELAN_DMAC_TABLE, flowId, 20, displayName, 0, 0,
+ ElanConstants.COOKIE_ELAN_KNOWN_DMAC.add(BigInteger.valueOf(elanTag)),
+ matches, new ArrayList<InstructionInfo>());
+ return flow;
+ }
+
+ /**
+ * Add Mac Address to ElanInterfaceForwardingEntries and ElanForwardingTables
+ * Install SMAC and DMAC flows.
+ */
+ public void addMacEntryToDsAndSetupFlows(IInterfaceManager interfaceManager, String interfaceName,
+ String macAddress, String elanName, WriteTransaction tx, WriteTransaction flowWritetx, int macTimeOut)
+ throws ElanException {
+ LOG.trace("Adding mac address {} and interface name {} to ElanInterfaceForwardingEntries and "
+ + "ElanForwardingTables DS", macAddress, interfaceName);
+ BigInteger timeStamp = new BigInteger(String.valueOf(System.currentTimeMillis()));
+ PhysAddress physAddress = new PhysAddress(macAddress);
+ MacEntry macEntry = new MacEntryBuilder().setInterface(interfaceName).setMacAddress(physAddress)
+ .setKey(new MacEntryKey(physAddress)).setControllerLearnedForwardingEntryTimestamp(timeStamp)
+ .setIsStaticAddress(false).build();
+ InstanceIdentifier<MacEntry> macEntryId = ElanUtils
+ .getInterfaceMacEntriesIdentifierOperationalDataPath(interfaceName, physAddress);
+ tx.put(LogicalDatastoreType.OPERATIONAL, macEntryId, macEntry);
+ InstanceIdentifier<MacEntry> elanMacEntryId = ElanUtils.getMacEntryOperationalDataPath(elanName, physAddress);
+ tx.put(LogicalDatastoreType.OPERATIONAL, elanMacEntryId, macEntry);
+ ElanInstance elanInstance = ElanUtils.getElanInstanceByName(broker, elanName);
+ setupMacFlows(elanInstance, interfaceManager.getInterfaceInfo(interfaceName), macTimeOut, macAddress, true,
+ flowWritetx);
+ }
+
+ /**
+ * Remove Mac Address from ElanInterfaceForwardingEntries and ElanForwardingTables
+ * Remove SMAC and DMAC flows.
+ */
+ public void deleteMacEntryFromDsAndRemoveFlows(IInterfaceManager interfaceManager, String interfaceName,
+ String macAddress, String elanName, WriteTransaction tx, WriteTransaction deleteFlowTx) {
+ LOG.trace("Deleting mac address {} and interface name {} from ElanInterfaceForwardingEntries "
+ + "and ElanForwardingTables DS", macAddress, interfaceName);
+ PhysAddress physAddress = new PhysAddress(macAddress);
+ MacEntry macEntry = getInterfaceMacEntriesOperationalDataPath(interfaceName, physAddress);
+ InterfaceInfo interfaceInfo = interfaceManager.getInterfaceInfo(interfaceName);
+ if (macEntry != null && interfaceInfo != null) {
+ deleteMacFlows(ElanUtils.getElanInstanceByName(broker, elanName), interfaceInfo, macEntry, deleteFlowTx);
+ }
+ tx.delete(LogicalDatastoreType.OPERATIONAL,
+ ElanUtils.getInterfaceMacEntriesIdentifierOperationalDataPath(interfaceName, physAddress));
+ tx.delete(LogicalDatastoreType.OPERATIONAL,
+ ElanUtils.getMacEntryOperationalDataPath(elanName, physAddress));
+ }
+
+ public String getExternalElanInterface(String elanInstanceName, BigInteger dpnId) {
+ DpnInterfaces dpnInterfaces = getElanInterfaceInfoByElanDpn(elanInstanceName, dpnId);
+ if (dpnInterfaces == null || dpnInterfaces.getInterfaces() == null) {
+ LOG.trace("Elan {} does not have interfaces in DPN {}", elanInstanceName, dpnId);
+ return null;
+ }
+
+ for (String dpnInterface : dpnInterfaces.getInterfaces()) {
+ if (interfaceManager.isExternalInterface(dpnInterface)) {
+ return dpnInterface;
+ }
}
- return false;
+
+ LOG.trace("Elan {} does not have any external interace attached to DPN {}", elanInstanceName, dpnId);
+ return null;
+ }
+
+ public static String getElanMacKey(long elanTag, String macAddress) {
+ return ("MAC-" + macAddress + " ELAN_TAG-" + elanTag).intern();
}
}
Code Review / netvirt.git / blobdiff