package org.opendaylight.netvirt.elan.internal;
-import com.google.common.base.Optional;
+import static java.util.Collections.emptyMap;
+
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
+import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.Future;
import java.util.function.BiFunction;
-import javax.annotation.Nonnull;
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.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.genius.interfacemanager.exceptions.InterfaceAlreadyExistsException;
import org.opendaylight.genius.interfacemanager.globals.IfmConstants;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
-import org.opendaylight.genius.mdsalutil.MatchInfoBase;
-import org.opendaylight.genius.mdsalutil.MetaDataUtil;
import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
-import org.opendaylight.genius.mdsalutil.nxmatches.NxMatchRegister;
import org.opendaylight.genius.utils.ServiceIndex;
import org.opendaylight.genius.utils.hwvtep.HwvtepSouthboundConstants;
import org.opendaylight.infrautils.inject.AbstractLifecycle;
+import org.opendaylight.infrautils.utils.concurrent.LoggingFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.util.Datastore;
+import org.opendaylight.mdsal.binding.util.ManagedNewTransactionRunner;
+import org.opendaylight.mdsal.binding.util.ManagedNewTransactionRunnerImpl;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
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.netvirt.elan.utils.ElanUtils;
import org.opendaylight.netvirt.elanmanager.api.ElanHelper;
import org.opendaylight.netvirt.elanmanager.api.IElanService;
-import org.opendaylight.netvirt.elanmanager.exceptions.MacNotFoundException;
import org.opendaylight.ovsdb.utils.southbound.utils.SouthboundUtils;
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.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
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.flow.inventory.rev130819.tables.table.Flow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfL2vlan;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.etree.rev160614.EtreeInstance;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.interfaces.elan._interface.StaticMacEntriesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.state.Elan;
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.MacEntryKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.opendaylight.yangtools.yang.common.Uint32;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private final IdManagerService idManager;
private final IInterfaceManager interfaceManager;
- private final ElanInstanceManager elanInstanceManager;
private final ElanBridgeManager bridgeMgr;
private final DataBroker broker;
+ private final ManagedNewTransactionRunner txRunner;
private final ElanUtils elanUtils;
private final SouthboundUtils southboundUtils;
private final IMdsalApiManager mdsalManager;
@Inject
public ElanServiceProvider(IdManagerService idManager, IInterfaceManager interfaceManager,
- ElanInstanceManager elanInstanceManager, ElanBridgeManager bridgeMgr,
+ ElanBridgeManager bridgeMgr,
DataBroker dataBroker,
- ElanInterfaceManager elanInterfaceManager,
ElanUtils elanUtils,
EntityOwnershipService entityOwnershipService,
SouthboundUtils southboundUtils, ElanInstanceCache elanInstanceCache,
ElanInterfaceCache elanInterfaceCache, IMdsalApiManager mdsalManager) {
this.idManager = idManager;
this.interfaceManager = interfaceManager;
- this.elanInstanceManager = elanInstanceManager;
this.bridgeMgr = bridgeMgr;
this.broker = dataBroker;
+ this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.elanUtils = elanUtils;
this.southboundUtils = southboundUtils;
this.elanInstanceCache = elanInstanceCache;
candidateRegistration = registerCandidate(entityOwnershipService);
}
+ @Nullable
private static EntityOwnershipCandidateRegistration registerCandidate(
EntityOwnershipService entityOwnershipService) {
try {
private void createIdPool() throws Exception {
CreateIdPoolInput createPool = new CreateIdPoolInputBuilder().setPoolName(ElanConstants.ELAN_ID_POOL_NAME)
.setLow(ElanConstants.ELAN_ID_LOW_VALUE).setHigh(ElanConstants.ELAN_ID_HIGH_VALUE).build();
- Future<RpcResult<Void>> result = idManager.createIdPool(createPool);
+ Future<RpcResult<CreateIdPoolOutput>> result = idManager.createIdPool(createPool);
if (result != null && result.get().isSuccessful()) {
LOG.debug("ELAN Id Pool is created successfully");
}
@Override
public boolean createElanInstance(String elanInstanceName, long macTimeout, String description) {
- ElanInstance existingElanInstance = elanInstanceManager.getElanInstanceByName(elanInstanceName);
+ Optional<ElanInstance> existingElanInstance = elanInstanceCache.get(elanInstanceName);
boolean isSuccess = true;
- if (existingElanInstance != null) {
- if (compareWithExistingElanInstance(existingElanInstance, macTimeout, description)) {
+ if (existingElanInstance.isPresent()) {
+ if (compareWithExistingElanInstance(existingElanInstance.get(), macTimeout, description)) {
LOG.debug("Elan Instance is already present in the Operational DS {}", existingElanInstance);
return true;
} else {
ElanInstance updateElanInstance = new ElanInstanceBuilder().setElanInstanceName(elanInstanceName)
.setDescription(description).setMacTimeout(macTimeout)
- .setKey(new ElanInstanceKey(elanInstanceName)).build();
+ .withKey(new ElanInstanceKey(elanInstanceName)).build();
MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION,
ElanHelper.getElanInstanceConfigurationDataPath(elanInstanceName), updateElanInstance);
- LOG.debug("Updating the Elan Instance {} with MAC TIME-OUT %l and Description %s ",
+ LOG.debug("Updating the Elan Instance {} with MAC TIME-OUT {} and Description {}",
updateElanInstance, macTimeout, description);
}
} else {
ElanInstance elanInstance = new ElanInstanceBuilder().setElanInstanceName(elanInstanceName)
- .setMacTimeout(macTimeout).setDescription(description).setKey(new ElanInstanceKey(elanInstanceName))
- .build();
+ .setMacTimeout(macTimeout).setDescription(description)
+ .withKey(new ElanInstanceKey(elanInstanceName)).build();
MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION,
ElanHelper.getElanInstanceConfigurationDataPath(elanInstanceName), elanInstance);
LOG.debug("Creating the new Elan Instance {}", elanInstance);
@Override
public boolean createEtreeInstance(String elanInstanceName, long macTimeout, String description) {
- ElanInstance existingElanInstance = elanInstanceManager.getElanInstanceByName(elanInstanceName);
+ Optional<ElanInstance> existingElanInstance = elanInstanceCache.get(elanInstanceName);
boolean isSuccess = true;
- if (existingElanInstance != null) {
- if (compareWithExistingElanInstance(existingElanInstance, macTimeout, description)) {
+ if (existingElanInstance.isPresent()) {
+ if (compareWithExistingElanInstance(existingElanInstance.get(), macTimeout, description)) {
LOG.warn("Etree Instance is already present in the Operational DS {}", existingElanInstance);
return true;
} else {
EtreeInstance etreeInstance = new EtreeInstanceBuilder().build();
ElanInstance updateElanInstance = new ElanInstanceBuilder().setElanInstanceName(elanInstanceName)
.setDescription(description).setMacTimeout(macTimeout)
- .setKey(new ElanInstanceKey(elanInstanceName))
+ .withKey(new ElanInstanceKey(elanInstanceName))
.addAugmentation(EtreeInstance.class, etreeInstance).build();
MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION,
ElanHelper.getElanInstanceConfigurationDataPath(elanInstanceName), updateElanInstance);
- LOG.debug("Updating the Etree Instance {} with MAC TIME-OUT %l and Description %s ",
+ LOG.debug("Updating the Etree Instance {} with MAC TIME-OUT {} and Description {} ",
updateElanInstance, macTimeout, description);
}
} else {
EtreeInstance etreeInstance = new EtreeInstanceBuilder().build();
ElanInstance elanInstance = new ElanInstanceBuilder().setElanInstanceName(elanInstanceName)
- .setMacTimeout(macTimeout).setDescription(description).setKey(new ElanInstanceKey(elanInstanceName))
+ .setMacTimeout(macTimeout).setDescription(description)
+ .withKey(new ElanInstanceKey(elanInstanceName))
.addAugmentation(EtreeInstance.class, etreeInstance).build();
MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION,
ElanHelper.getElanInstanceConfigurationDataPath(elanInstanceName), elanInstance);
}
@Override
+ @Nullable
public EtreeInterface getEtreeInterfaceByElanInterfaceName(String elanInterface) {
- return elanInterfaceCache.getEtreeInterface(elanInterface).orNull();
+ return elanInterfaceCache.getEtreeInterface(elanInterface).orElse(null);
}
public static boolean compareWithExistingElanInstance(ElanInstance existingElanInstance, long macTimeOut,
String description) {
boolean isEqual = false;
- if (existingElanInstance.getMacTimeout() == macTimeOut
- && existingElanInstance.getDescription().equals(description)) {
+ if (existingElanInstance.getMacTimeout().longValue() == macTimeOut
+ && Objects.equals(existingElanInstance.getDescription(), description)) {
isEqual = true;
}
return isEqual;
@Override
public boolean deleteElanInstance(String elanInstanceName) {
- boolean isSuccess = false;
- ElanInstance existingElanInstance = elanInstanceManager.getElanInstanceByName(elanInstanceName);
- if (existingElanInstance == null) {
+ Optional<ElanInstance> existingElanInstance = elanInstanceCache.get(elanInstanceName);
+ if (!existingElanInstance.isPresent()) {
LOG.debug("Elan Instance is not present for {}", elanInstanceName);
- return isSuccess;
+ return false;
}
LOG.debug("Deletion of the existing Elan Instance {}", existingElanInstance);
ElanUtils.delete(broker, LogicalDatastoreType.CONFIGURATION,
ElanHelper.getElanInstanceConfigurationDataPath(elanInstanceName));
- isSuccess = true;
- return isSuccess;
+ return true;
}
@Override
public void addEtreeInterface(String etreeInstanceName, String interfaceName, EtreeInterfaceType interfaceType,
List<String> staticMacAddresses, String description) {
- ElanInstance existingElanInstance = elanInstanceManager.getElanInstanceByName(etreeInstanceName);
- if (existingElanInstance != null && existingElanInstance.getAugmentation(EtreeInstance.class) != null) {
+ Optional<ElanInstance> existingElanInstance = elanInstanceCache.get(etreeInstanceName);
+ if (existingElanInstance.isPresent()
+ && existingElanInstance.get().augmentation(EtreeInstance.class) != null) {
EtreeInterface etreeInterface = new EtreeInterfaceBuilder().setEtreeInterfaceType(interfaceType).build();
ElanInterface elanInterface;
if (staticMacAddresses == null) {
elanInterface = new ElanInterfaceBuilder().setElanInstanceName(etreeInstanceName)
- .setDescription(description).setName(interfaceName).setKey(new ElanInterfaceKey(interfaceName))
+ .setDescription(description).setName(interfaceName).withKey(new ElanInterfaceKey(interfaceName))
.addAugmentation(EtreeInterface.class, etreeInterface).build();
} else {
List<StaticMacEntries> staticMacEntries = ElanUtils.getStaticMacEntries(staticMacAddresses);
elanInterface = new ElanInterfaceBuilder().setElanInstanceName(etreeInstanceName)
.setDescription(description).setName(interfaceName)
.setStaticMacEntries(staticMacEntries)
- .setKey(new ElanInterfaceKey(interfaceName))
+ .withKey(new ElanInterfaceKey(interfaceName))
.addAugmentation(EtreeInterface.class, etreeInterface).build();
}
MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION,
}
@Override
- public void addElanInterface(String elanInstanceName, String interfaceName, List<String> staticMacAddresses,
- String description) {
- ElanInstance existingElanInstance = elanInstanceManager.getElanInstanceByName(elanInstanceName);
- if (existingElanInstance != null) {
+ public void addElanInterface(String elanInstanceName, String interfaceName,
+ @Nullable List<String> staticMacAddresses, @Nullable String description) {
+ Optional<ElanInstance> existingElanInstance = elanInstanceCache.get(elanInstanceName);
+ if (existingElanInstance.isPresent()) {
ElanInterfaceBuilder elanInterfaceBuilder = new ElanInterfaceBuilder()
.setElanInstanceName(elanInstanceName)
.setDescription(description).setName(interfaceName)
- .setKey(new ElanInterfaceKey(interfaceName));
+ .withKey(new ElanInterfaceKey(interfaceName));
if (staticMacAddresses != null) {
List<StaticMacEntries> staticMacEntries = ElanUtils.getStaticMacEntries(staticMacAddresses);
elanInterfaceBuilder.setStaticMacEntries(staticMacEntries);
LOG.debug("updating the ElanInterface with new Mac Entries {}", updatedStaticMacAddresses);
ElanInterface elanInterface = new ElanInterfaceBuilder().setElanInstanceName(elanInstanceName)
.setName(interfaceName).setDescription(newDescription).setStaticMacEntries(updatedStaticMacEntries)
- .setKey(new ElanInterfaceKey(interfaceName)).build();
+ .withKey(new ElanInterfaceKey(interfaceName)).build();
MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION,
ElanUtils.getElanInterfaceConfigurationDataPathId(interfaceName), elanInterface);
}
@Override
- public void deleteEtreeInterface(String elanInstanceName, String interfaceName) {
- deleteElanInterface(elanInstanceName, interfaceName);
+ public void deleteEtreeInterface(String interfaceName) {
+ deleteElanInterface(interfaceName);
LOG.debug("deleting the Etree Interface {}", interfaceName);
}
@Override
- public void deleteElanInterface(String elanInstanceName, String interfaceName) {
+ public void deleteElanInterface(String interfaceName) {
Optional<ElanInterface> existingElanInterface = elanInterfaceCache.get(interfaceName);
if (existingElanInterface.isPresent()) {
ElanUtils.delete(broker, LogicalDatastoreType.CONFIGURATION,
}
@Override
- public void addStaticMacAddress(String elanInstanceName, String interfaceName, String macAddress) {
+ public void addStaticMacAddress(String interfaceName, String macAddress) {
Optional<ElanInterface> existingElanInterface = elanInterfaceCache.get(interfaceName);
if (existingElanInterface.isPresent()) {
StaticMacEntriesBuilder staticMacEntriesBuilder = new StaticMacEntriesBuilder();
}
@Override
- public void deleteStaticMacAddress(String elanInstanceName, String interfaceName, String macAddress)
- throws MacNotFoundException {
+ public void deleteStaticMacAddress(String interfaceName, String macAddress) {
Optional<ElanInterface> existingElanInterface = elanInterfaceCache.get(interfaceName);
if (existingElanInterface.isPresent()) {
InstanceIdentifier<StaticMacEntries> staticMacEntriesIdentifier =
ElanInterfaceMac elanInterfaceMac = elanUtils.getElanInterfaceMacByInterfaceName(elanInterface);
if (elanInterfaceMac != null && elanInterfaceMac.getMacEntry() != null
&& elanInterfaceMac.getMacEntry().size() > 0) {
- macAddress.addAll(elanInterfaceMac.getMacEntry());
+ macAddress.addAll(elanInterfaceMac.nonnullMacEntry().values());
}
}
}
for (String elanInterface : elanInterfaces) {
ElanInterfaceMac elanInterfaceMac = elanUtils.getElanInterfaceMacByInterfaceName(elanInterface);
if (elanInterfaceMac.getMacEntry() != null && elanInterfaceMac.getMacEntry().size() > 0) {
- List<MacEntry> macEntries = elanInterfaceMac.getMacEntry();
- for (MacEntry macEntry : macEntries) {
- try {
- deleteStaticMacAddress(elanInstanceName, elanInterface, macEntry.getMacAddress().getValue());
- } catch (MacNotFoundException e) {
- LOG.error("Mac Not Found Exception {}", e);
- }
+ Map<MacEntryKey, MacEntry> macEntries = elanInterfaceMac.nonnullMacEntry();
+ for (MacEntry macEntry : macEntries.values()) {
+ deleteStaticMacAddress(elanInterface, macEntry.getMacAddress().getValue());
}
}
}
}
@Override
+ @Nullable
public ElanInstance getElanInstance(String elanName) {
- return elanInstanceCache.get(elanName).orNull();
+ return elanInstanceCache.get(elanName).orElse(null);
}
@Override
public List<ElanInstance> getElanInstances() {
InstanceIdentifier<ElanInstances> elanInstancesIdentifier = InstanceIdentifier.builder(ElanInstances.class)
.build();
- return ElanUtils.read(broker, LogicalDatastoreType.CONFIGURATION, elanInstancesIdentifier).toJavaUtil().map(
- ElanInstances::getElanInstance).orElse(Collections.emptyList());
+ return new ArrayList<>(ElanUtils.read(broker, LogicalDatastoreType.CONFIGURATION, elanInstancesIdentifier).map(
+ ElanInstances::nonnullElanInstance).orElse(emptyMap()).values());
}
@Override
- @Nonnull
+ @NonNull
public List<String> getElanInterfaces(String elanInstanceName) {
List<String> elanInterfaces = new ArrayList<>();
InstanceIdentifier<ElanInterfaces> elanInterfacesIdentifier = InstanceIdentifier.builder(ElanInterfaces.class)
if (!elanInterfacesOptional.isPresent()) {
return elanInterfaces;
}
- List<ElanInterface> elanInterfaceList = elanInterfacesOptional.get().getElanInterface();
- for (ElanInterface elanInterface : elanInterfaceList) {
- if (elanInterface.getElanInstanceName().equals(elanInstanceName)) {
+ Map<ElanInterfaceKey, ElanInterface> elanInterfaceList = elanInterfacesOptional.get().nonnullElanInterface();
+ for (ElanInterface elanInterface : elanInterfaceList.values()) {
+ if (Objects.equals(elanInterface.getElanInstanceName(), elanInstanceName)) {
elanInterfaces.add(elanInterface.getName());
}
}
});
}
- protected void createExternalElanNetwork(ElanInstance elanInstance, BigInteger dpId) {
+ protected void createExternalElanNetwork(ElanInstance elanInstance, Uint64 dpId) {
String providerIntfName = bridgeMgr.getProviderInterfaceName(dpId, elanInstance.getPhysicalNetworkName());
String intfName = providerIntfName + IfmConstants.OF_URI_SEPARATOR + elanInstance.getSegmentationId();
Interface memberIntf = interfaceManager.getInterfaceInfoFromConfigDataStore(intfName);
});
}
- protected void deleteExternalElanNetwork(ElanInstance elanInstance, BigInteger dpnId) {
+ protected void deleteExternalElanNetwork(ElanInstance elanInstance, Uint64 dpnId) {
String providerIntfName = bridgeMgr.getProviderInterfaceName(dpnId, elanInstance.getPhysicalNetworkName());
String intfName = providerIntfName + IfmConstants.OF_URI_SEPARATOR + elanInstance.getSegmentationId();
Interface memberIntf = interfaceManager.getInterfaceInfoFromConfigDataStore(intfName);
if (memberIntf != null) {
- deleteElanInterface(elanInstance.getElanInstanceName(), intfName);
+ deleteElanInterface(intfName);
deleteIetfInterface(intfName);
LOG.debug("delete vlan prv intf {} in elan {}, dpID {}", intfName,
elanInstance.getElanInstanceName(), dpnId);
if (shouldDeleteTrunk(trunkInterfaceName, elanInterface)) {
deleteIetfInterface(trunkInterfaceName);
}
- deleteElanInterface(elanInstanceName, elanInterface);
+ deleteElanInterface(elanInterface);
}
}
}
return;
}
- LOG.debug("updateExternalElanNetworks, orig bridge {} . updated bridge {}", origNode, updatedNode);
+ LOG.trace("updateExternalElanNetworks, orig bridge {} . updated bridge {}", origNode, updatedNode);
Map<String, String> origProviderMappping = getMapFromOtherConfig(origNode,
ElanBridgeManager.PROVIDER_MAPPINGS_KEY);
boolean hasDatapathIdOnOrigNode = bridgeMgr.hasDatapathID(origNode);
boolean hasDatapathIdOnUpdatedNode = bridgeMgr.hasDatapathID(updatedNode);
- BigInteger origDpnID = bridgeMgr.getDatapathId(origNode);
+ Uint64 origDpnID = bridgeMgr.getDatapathId(origNode);
for (ElanInstance elanInstance : elanInstances) {
String physicalNetworkName = elanInstance.getPhysicalNetworkName();
}
}
- private boolean hasDatapathIdAdded(boolean hasDatapathIdOnOrigNode, boolean hasDatapathIdOnUpdatedNode) {
+ private static boolean hasDatapathIdAdded(boolean hasDatapathIdOnOrigNode, boolean hasDatapathIdOnUpdatedNode) {
return !hasDatapathIdOnOrigNode && hasDatapathIdOnUpdatedNode;
}
- private boolean hasPortNameUpdated(String origPortName, String updatedPortName) {
+ private static boolean hasPortNameUpdated(String origPortName, String updatedPortName) {
return updatedPortName != null && !updatedPortName.equals(origPortName);
}
- private boolean hasPortNameRemoved(String origPortName, String updatedPortName) {
+ private static boolean hasPortNameRemoved(String origPortName, String updatedPortName) {
return origPortName != null && !origPortName.equals(updatedPortName);
}
}
@Override
- public String getExternalElanInterface(String elanInstanceName, BigInteger dpnId) {
+ public String getExternalElanInterface(String elanInstanceName, Uint64 dpnId) {
return elanUtils.getExternalElanInterface(elanInstanceName, dpnId);
}
}
@Override
+ @Nullable
public ElanInterface getElanInterfaceByElanInterfaceName(String interfaceName) {
- return elanInterfaceCache.get(interfaceName).orNull();
+ return elanInterfaceCache.get(interfaceName).orElse(null);
}
@Override
LOG.trace("ELAN service is after L3VPN in the Netvirt pipeline skip known L3DMAC flows installation");
return;
}
- ElanInstance elanInstance = elanInstanceCache.get(elanInstanceName).orNull();
+ ElanInstance elanInstance = elanInstanceCache.get(elanInstanceName).orElse(null);
if (elanInstance == null) {
LOG.warn("Null elan instance {}", elanInstanceName);
return;
}
- List<BigInteger> dpnsIdsForElanInstance = elanUtils.getParticipatingDpnsInElanInstance(elanInstanceName);
+ List<Uint64> dpnsIdsForElanInstance = elanUtils.getParticipatingDpnsInElanInstance(elanInstanceName);
if (dpnsIdsForElanInstance.isEmpty()) {
LOG.warn("No DPNs for elan instance {}", elanInstance);
return;
LOG.trace("ELAN service is after L3VPN in the Netvirt pipeline skip known L3DMAC flows installation");
return;
}
- ElanInstance elanInstance = elanInstanceCache.get(elanInstanceName).orNull();
+ ElanInstance elanInstance = elanInstanceCache.get(elanInstanceName).orElse(null);
if (elanInstance == null) {
LOG.warn("Null elan instance {}", elanInstanceName);
return;
}
- List<BigInteger> dpnsIdsForElanInstance = elanUtils.getParticipatingDpnsInElanInstance(elanInstanceName);
+ List<Uint64> dpnsIdsForElanInstance = elanUtils.getParticipatingDpnsInElanInstance(elanInstanceName);
if (dpnsIdsForElanInstance.isEmpty()) {
LOG.warn("No DPNs for elan instance {}", elanInstance);
return;
}
- elanUtils.removeDmacRedirectToDispatcherFlows(elanInstance.getElanTag(), macAddress, dpnsIdsForElanInstance);
- }
-
- @Override
- public List<MatchInfoBase> getEgressMatchesForElanInstance(String elanInstanceName) {
- ElanInstance elanInstance = getElanInstance(elanInstanceName);
- if (elanInstance == null) {
- LOG.debug("No ELAN instance found for {}", elanInstanceName);
- return Collections.emptyList();
- }
-
- Long elanTag = elanInstance.getElanTag();
- if (elanTag == null) {
- LOG.debug("No ELAN tag found for {}", elanInstanceName);
- return Collections.emptyList();
- }
- return Collections.singletonList(
- new NxMatchRegister(ElanConstants.ELAN_REG_ID, elanTag, MetaDataUtil.getElanMaskForReg()));
+ elanUtils.removeDmacRedirectToDispatcherFlows(elanInstance.getElanTag(),
+ macAddress, dpnsIdsForElanInstance);
}
/**
if (ElanUtils.isFlat(elanInstance)) {
interfaceName = trunkName;
} else if (ElanUtils.isVlan(elanInstance)) {
- Long segmentationId = elanInstance.getSegmentationId();
+ Long segmentationId = elanInstance.getSegmentationId().toJava();
interfaceName = parentRef + IfmConstants.OF_URI_SEPARATOR + segmentationId;
interfaceManager.createVLANInterface(interfaceName, trunkName, segmentationId.intValue(), null,
IfL2vlan.L2vlanMode.TrunkMember, true);
private void handleExternalElanNetwork(ElanInstance elanInstance, boolean update,
BiFunction<ElanInstance, String, Void> function) {
String elanInstanceName = elanInstance.getElanInstanceName();
+ boolean isFlatOrVlanNetwork = (ElanUtils.isFlat(elanInstance) || ElanUtils.isVlan(elanInstance));
+ if (!isFlatOrVlanNetwork) {
+ LOG.error("Network is not of type FLAT/VLAN."
+ + "Ignoring Elan-interface creation for given ProviderInterface {}",
+ elanInstance.getPhysicalNetworkName());
+ return;
+ }
if (elanInstance.getPhysicalNetworkName() == null) {
LOG.trace("No physical network attached to {}", elanInstanceName);
return;
}
- List<Node> nodes = southboundUtils.getOvsdbNodes();
+ Map<NodeKey, Node> nodes = southboundUtils.getOvsdbNodes();
if (nodes == null || nodes.isEmpty()) {
LOG.trace("No OVS nodes found while creating external network for ELAN {}",
elanInstance.getElanInstanceName());
return;
}
- for (Node node : nodes) {
+ for (Node node : nodes.values()) {
if (bridgeMgr.isIntegrationBridge(node)) {
if (update && !elanInstance.isExternal()) {
DpnInterfaces dpnInterfaces = elanUtils.getElanInterfaceInfoByElanDpn(elanInstanceName,
}
}
- private String getTrunkInterfaceName(String parentRef) {
+ private static String getTrunkInterfaceName(String parentRef) {
return parentRef + IfmConstants.OF_URI_SEPARATOR + "trunk";
}
String macAddress = arpResponderInput.getSha();
String ipAddress = arpResponderInput.getSpa();
int lportTag = arpResponderInput.getLportTag();
- BigInteger dpnId = arpResponderInput.getDpId();
+ Uint64 dpnId = Uint64.valueOf(arpResponderInput.getDpId());
LOG.info("Installing the ARP responder flow on DPN {} for Interface {} with MAC {} & IP {}", dpnId,
ingressInterfaceName, macAddress, ipAddress);
Optional<ElanInterface> elanIface = elanInterfaceCache.get(ingressInterfaceName);
ElanInstance elanInstance = elanIface.isPresent()
- ? elanInstanceCache.get(elanIface.get().getElanInstanceName()).orNull() : null;
+ ? elanInstanceCache.get(elanIface.get().getElanInstanceName()).orElse(null) : null;
if (elanInstance == null) {
- LOG.debug("addArpResponderFlow: elanInstance is null, Failed to install arp responder flow for Interface {}"
- + " with MAC {} & IP {}", dpnId,
- ingressInterfaceName, macAddress, ipAddress);
+ LOG.debug("addArpResponderFlow: elanInstance is null, Failed to install arp responder flow for dpnId {}"
+ + "for Interface {} with MAC {} & IP {}", dpnId, ingressInterfaceName, macAddress, ipAddress);
return;
}
String flowId = ArpResponderUtil.getFlowId(lportTag, ipAddress);
- ArpResponderUtil.installFlow(mdsalManager, dpnId, flowId, flowId, NwConstants.DEFAULT_ARP_FLOW_PRIORITY,
+ Map<org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionKey,
+ org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction>
+ arpResponderInputInstructionsMap = new HashMap<>();
+ int instructionKey = 0;
+ for (org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction
+ instructionObj : arpResponderInput.getInstructions()) {
+ arpResponderInputInstructionsMap.put(new org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types
+ .rev131026.instruction.list.InstructionKey(++instructionKey), instructionObj);
+ }
+ Flow flowEntity =
+ MDSALUtil.buildFlowNew(NwConstants.ARP_RESPONDER_TABLE, flowId, NwConstants.DEFAULT_ARP_FLOW_PRIORITY,
+ flowId, 0, 0,
ArpResponderUtil.generateCookie(lportTag, ipAddress),
ArpResponderUtil.getMatchCriteria(lportTag, elanInstance, ipAddress),
- arpResponderInput.getInstructions());
+ arpResponderInputInstructionsMap);
+ LoggingFutures.addErrorLogging(txRunner.callWithNewWriteOnlyTransactionAndSubmit(Datastore.CONFIGURATION,
+ tx -> mdsalManager.addFlow(tx, dpnId, flowEntity)), LOG, "Error adding flow {}", flowEntity);
LOG.info("Installed the ARP Responder flow for Interface {}", ingressInterfaceName);
}
@Override
public void addExternalTunnelArpResponderFlow(ArpResponderInput arpResponderInput, String elanInstanceName) {
- BigInteger dpnId = arpResponderInput.getDpId();
+ Uint64 dpnId = Uint64.valueOf(arpResponderInput.getDpId());
String ipAddress = arpResponderInput.getSpa();
String macAddress = arpResponderInput.getSha();
LOG.trace("Installing the ExternalTunnel ARP responder flow on DPN {} for ElanInstance {} with MAC {} & IP {}",
dpnId, elanInstanceName, macAddress, ipAddress);
- ElanInstance elanInstance = elanInstanceCache.get(elanInstanceName).orNull();
+ ElanInstance elanInstance = elanInstanceCache.get(elanInstanceName).orElse(null);
if (elanInstance == null) {
LOG.warn("Null elan instance {}", elanInstanceName);
return;
int lportTag = arpResponderInput.getLportTag();
String flowId = ArpResponderUtil.getFlowId(lportTag, ipAddress);
- ArpResponderUtil.installFlow(mdsalManager, dpnId, flowId, flowId, NwConstants.DEFAULT_ARP_FLOW_PRIORITY,
- ArpResponderUtil.generateCookie(lportTag, ipAddress), ArpResponderUtil.getMatchCriteria(lportTag,
- elanInstance, ipAddress), arpResponderInput.getInstructions());
+
+ Map<org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionKey,
+ org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction>
+ arpResponderInputInstructionsMap = new HashMap<>();
+ int instructionKey = 0;
+ for (org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction
+ instructionObj : arpResponderInput.getInstructions()) {
+ arpResponderInputInstructionsMap.put(new org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types
+ .rev131026.instruction.list.InstructionKey(++instructionKey), instructionObj);
+ }
+
+ Flow flowEntity =
+ MDSALUtil.buildFlowNew(NwConstants.ARP_RESPONDER_TABLE, flowId, NwConstants.DEFAULT_ARP_FLOW_PRIORITY,
+ flowId, 0, 0,
+ ArpResponderUtil.generateCookie(lportTag, ipAddress),
+ ArpResponderUtil.getMatchCriteria(lportTag, elanInstance, ipAddress),
+ arpResponderInputInstructionsMap);
+ LoggingFutures.addErrorLogging(txRunner.callWithNewWriteOnlyTransactionAndSubmit(Datastore.CONFIGURATION,
+ tx -> mdsalManager.addFlow(tx, dpnId, flowEntity)), LOG, "Error adding flow {}", flowEntity);
LOG.trace("Installed the ExternalTunnel ARP Responder flow for ElanInstance {}", elanInstanceName);
}
@Override
public void removeArpResponderFlow(ArpResponderInput arpResponderInput) {
- elanUtils.removeArpResponderFlow(arpResponderInput.getDpId(), arpResponderInput.getInterfaceName(),
+ elanUtils.removeArpResponderFlow(Uint64.valueOf(arpResponderInput.getDpId()),
+ arpResponderInput.getInterfaceName(),
arpResponderInput.getSpa(), arpResponderInput.getLportTag());
}
* @return the integer
*/
@Override
- public Long retrieveNewElanTag(String idKey) {
- return elanUtils.retrieveNewElanTag(idManager, idKey);
+ public Uint32 retrieveNewElanTag(String idKey) {
+ return ElanUtils.retrieveNewElanTag(idManager, idKey);
}
@Override
public InstanceIdentifier<DpnInterfaces> getElanDpnInterfaceOperationalDataPath(
- String elanInstanceName, BigInteger dpnId) {
+ String elanInstanceName, Uint64 dpnId) {
return ElanUtils.getElanDpnInterfaceOperationalDataPath(elanInstanceName, dpnId);
}
@Override
- public DpnInterfaces getElanInterfaceInfoByElanDpn(String elanInstanceName, BigInteger dpId) {
+ public DpnInterfaces getElanInterfaceInfoByElanDpn(String elanInstanceName, Uint64 dpId) {
return elanUtils.getElanInterfaceInfoByElanDpn(elanInstanceName, dpId);
}
Code Review / netvirt.git / blobdiff