import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import static org.opendaylight.netvirt.elan.utils.ElanUtils.isVxlanNetworkOrVxlanSegment;
+import com.google.common.util.concurrent.FluentFuture;
+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.Arrays;
import java.util.Collection;
+import java.util.HashSet;
import java.util.List;
import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.concurrent.ExecutionException;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.utils.hwvtep.HwvtepUtils;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
import org.opendaylight.infrautils.utils.concurrent.LoggingFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.netvirt.elan.l2gw.jobs.HwvtepDeviceMcastMacUpdateJob;
import org.opendaylight.netvirt.elan.l2gw.jobs.McastUpdateJob;
import org.opendaylight.netvirt.elan.utils.ElanClusterUtils;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointBuilder;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private final ElanUtils elanUtils;
private final IMdsalApiManager mdsalManager;
private final IInterfaceManager interfaceManager;
+ private final ElanRefUtil elanRefUtil;
private final ElanClusterUtils elanClusterUtils;
private final Scheduler scheduler;
+
@Inject
- public ElanL2GatewayMulticastUtils(DataBroker broker, ElanItmUtils elanItmUtils, JobCoordinator jobCoordinator,
- ElanUtils elanUtils, IMdsalApiManager mdsalManager,
- IInterfaceManager interfaceManager, ElanClusterUtils elanClusterUtils,
- Scheduler scheduler) {
- this.broker = broker;
- this.txRunner = new ManagedNewTransactionRunnerImpl(broker);
+ public ElanL2GatewayMulticastUtils(ElanItmUtils elanItmUtils, ElanUtils elanUtils, IMdsalApiManager mdsalManager,
+ IInterfaceManager interfaceManager, ElanRefUtil elanRefUtil) {
+ this.elanRefUtil = elanRefUtil;
+ this.broker = elanRefUtil.getDataBroker();
+ this.txRunner = new ManagedNewTransactionRunnerImpl(elanRefUtil.getDataBroker());
this.elanItmUtils = elanItmUtils;
- this.jobCoordinator = jobCoordinator;
+ this.jobCoordinator = elanRefUtil.getJobCoordinator();
this.elanUtils = elanUtils;
this.mdsalManager = mdsalManager;
this.interfaceManager = interfaceManager;
- this.elanClusterUtils = elanClusterUtils;
- this.scheduler = scheduler;
+ this.elanClusterUtils = elanRefUtil.getElanClusterUtils();
+ this.scheduler = elanRefUtil.getScheduler();
}
/**
*/
public void updateRemoteMcastMacOnElanL2GwDevices(String elanName) {
for (L2GatewayDevice device : ElanL2GwCacheUtils.getInvolvedL2GwDevices(elanName)) {
- prepareRemoteMcastMacUpdateOnDevice(elanName, device);
+ prepareRemoteMcastMacUpdateOnDevice(elanName, device, false, null);
}
}
* the device
*/
public void updateRemoteMcastMacOnElanL2GwDevice(String elanName, L2GatewayDevice device) {
- prepareRemoteMcastMacUpdateOnDevice(elanName, device);
+ prepareRemoteMcastMacUpdateOnDevice(elanName, device, false, null);
}
- public ListenableFuture<Void> prepareRemoteMcastMacUpdateOnDevice(String elanName, L2GatewayDevice device) {
+ public ListenableFuture<Void> prepareRemoteMcastMacUpdateOnDevice(String elanName, L2GatewayDevice device,
+ boolean addCase, IpAddress removedDstTep) {
+ NodeId dstNodeId = new NodeId(device.getHwvtepNodeId());
+ RemoteMcastMacs existingMac = null;
+ try {
+ Optional<RemoteMcastMacs> mac = elanRefUtil.getConfigMcastCache().get(getRemoteMcastIid(dstNodeId,
+ elanName));
+ if (mac.isPresent()) {
+ existingMac = mac.get();
+ }
+ } catch (ReadFailedException e) {
+ LOG.error("Failed to read iid for elan {}", elanName, e);
+ }
+
+ if (!addCase && removedDstTep != null) {
+ LOG.debug(" RemoteMcast update delete tep {} of elan {} ", removedDstTep.getIpv4Address().getValue(),
+ elanName);
+ //incase of dpn flap immediately after cluster reboot just remove its tep alone
+ if (existingMac != null) {
+ return deleteLocatorFromMcast(elanName, dstNodeId, removedDstTep, existingMac);
+ }
+ }
Collection<L2GatewayDevice> elanL2gwDevices = ElanL2GwCacheUtils.getInvolvedL2GwDevices(elanName);
- List<DpnInterfaces> dpns = elanUtils.getElanDPNByName(elanName);
+ Collection<DpnInterfaces> dpns = elanRefUtil.getElanInstanceDpnsCache().get(elanName);
List<IpAddress> dpnsTepIps = getAllTepIpsOfDpns(device, dpns);
List<IpAddress> l2GwDevicesTepIps = getAllTepIpsOfL2GwDevices(elanL2gwDevices);
- return prepareRemoteMcastMacEntry(elanName, device, dpnsTepIps, l2GwDevicesTepIps);
+ return prepareRemoteMcastMacEntry(elanName, device, dpnsTepIps, l2GwDevicesTepIps, addCase);
+ }
+
+ private ListenableFuture<Void> deleteLocatorFromMcast(String elanName, NodeId dstNodeId,
+ IpAddress removedDstTep,
+ RemoteMcastMacs existingMac) {
+
+ LocatorSet tobeDeleted = buildLocatorSet(dstNodeId, removedDstTep);
+ RemoteMcastMacsBuilder newMacBuilder = new RemoteMcastMacsBuilder(existingMac);
+
+ List<LocatorSet> locatorList = new ArrayList<>(existingMac.nonnullLocatorSet());
+ locatorList.remove(tobeDeleted);
+ newMacBuilder.setLocatorSet(locatorList);
+ RemoteMcastMacs mac = newMacBuilder.build();
+ //configMcastCache.add(macIid, mac);
+ InstanceIdentifier<RemoteMcastMacs> macIid = HwvtepSouthboundUtils
+ .createRemoteMcastMacsInstanceIdentifier(dstNodeId, existingMac.key());
+ return ResourceBatchingManager.getInstance().put(
+ ResourceBatchingManager.ShardResource.CONFIG_TOPOLOGY, macIid, mac);
+ }
+
+ LocatorSet buildLocatorSet(NodeId nodeId, IpAddress tepIp) {
+ HwvtepPhysicalLocatorAugmentation phyLocatorAug = HwvtepSouthboundUtils
+ .createHwvtepPhysicalLocatorAugmentation(tepIp.stringValue());
+ HwvtepPhysicalLocatorRef phyLocRef = new HwvtepPhysicalLocatorRef(
+ HwvtepSouthboundUtils.createPhysicalLocatorInstanceIdentifier(nodeId, phyLocatorAug));
+ return new LocatorSetBuilder().setLocatorRef(phyLocRef).build();
}
/**
}
}
- public void updateRemoteBroadcastGroupForAllElanDpns(ElanInstance elanInfo,
+ public void updateRemoteBroadcastGroupForAllElanDpns(ElanInstance elanInfo, boolean createCase,
TypedWriteTransaction<Datastore.Configuration> confTx) {
List<DpnInterfaces> dpns = elanUtils.getInvolvedDpnsInElan(elanInfo.getElanInstanceName());
for (DpnInterfaces dpn : dpns) {
- setupElanBroadcastGroups(elanInfo, dpn.getDpId(), confTx);
+ setupStandardElanBroadcastGroups(elanInfo, null, dpn.getDpId(), createCase, confTx);
}
}
- public void setupElanBroadcastGroups(ElanInstance elanInfo, BigInteger dpnId,
+ public void setupElanBroadcastGroups(ElanInstance elanInfo, Uint64 dpnId,
TypedWriteTransaction<Datastore.Configuration> confTx) {
setupElanBroadcastGroups(elanInfo, null, dpnId, confTx);
}
- public void setupElanBroadcastGroups(ElanInstance elanInfo, @Nullable DpnInterfaces dpnInterfaces, BigInteger dpnId,
- TypedWriteTransaction<Datastore.Configuration> confTx) {
+ public void setupElanBroadcastGroups(ElanInstance elanInfo, @Nullable DpnInterfaces dpnInterfaces, Uint64 dpnId,
+ TypedWriteTransaction<Datastore.Configuration> confTx) {
setupStandardElanBroadcastGroups(elanInfo, dpnInterfaces, dpnId, confTx);
setupLeavesEtreeBroadcastGroups(elanInfo, dpnInterfaces, dpnId, confTx);
}
+ public void setupStandardElanBroadcastGroups(ElanInstance elanInfo, DpnInterfaces dpnInterfaces, Uint64 dpnId,
+ TypedWriteTransaction<Datastore.Configuration> confTx) {
+ setupStandardElanBroadcastGroups(elanInfo, dpnInterfaces, dpnId, true, confTx);
+ }
+
public void setupStandardElanBroadcastGroups(ElanInstance elanInfo, @Nullable DpnInterfaces dpnInterfaces,
- BigInteger dpnId, TypedWriteTransaction<Datastore.Configuration> confTx) {
+ Uint64 dpnId, boolean createCase, TypedWriteTransaction<Datastore.Configuration> confTx) {
List<Bucket> listBucket = new ArrayList<>();
int bucketId = 0;
int actionKey = 0;
- Long elanTag = elanInfo.getElanTag();
+ Long elanTag = elanInfo.getElanTag().toJava();
List<Action> listAction = new ArrayList<>();
listAction.add(new ActionGroup(ElanUtils.getElanLocalBCGId(elanTag)).buildAction(++actionKey));
listBucket.add(MDSALUtil.buildBucket(listAction, MDSALUtil.GROUP_WEIGHT, bucketId, MDSALUtil.WATCH_PORT,
Group group = MDSALUtil.buildGroup(groupId, elanInfo.getElanInstanceName(), GroupTypes.GroupAll,
MDSALUtil.buildBucketLists(listBucket));
LOG.trace("Installing the remote BroadCast Group:{}", group);
- mdsalManager.addGroup(confTx, dpnId, group);
+ if (createCase) {
+ elanUtils.syncUpdateGroup(dpnId, group, ElanConstants.DELAY_TIME_IN_MILLISECOND, confTx);
+ } else {
+ mdsalManager.addGroup(confTx, dpnId, group);
+ }
}
public void setupLeavesEtreeBroadcastGroups(ElanInstance elanInfo, @Nullable DpnInterfaces dpnInterfaces,
- BigInteger dpnId, TypedWriteTransaction<Datastore.Configuration> confTx) {
+ Uint64 dpnId, TypedWriteTransaction<Datastore.Configuration> confTx) {
EtreeInstance etreeInstance = elanInfo.augmentation(EtreeInstance.class);
if (etreeInstance != null) {
- long etreeLeafTag = etreeInstance.getEtreeLeafTagVal().getValue();
+ long etreeLeafTag = etreeInstance.getEtreeLeafTagVal().getValue().toJava();
List<Bucket> listBucket = new ArrayList<>();
int bucketId = 0;
int actionKey = 0;
}
@Nullable
- private static DpnInterfaces getDpnInterfaces(ElanDpnInterfacesList elanDpns, BigInteger dpnId) {
+ private static DpnInterfaces getDpnInterfaces(ElanDpnInterfacesList elanDpns, Uint64 dpnId) {
if (elanDpns != null) {
for (DpnInterfaces dpnInterface : elanDpns.nonnullDpnInterfaces()) {
if (Objects.equals(dpnInterface.getDpId(), dpnId)) {
}
private List<Bucket> getRemoteBCGroupExternalPortBuckets(ElanDpnInterfacesList elanDpns,
- DpnInterfaces dpnInterfaces, BigInteger dpnId, int bucketId) {
+ DpnInterfaces dpnInterfaces, Uint64 dpnId, int bucketId) {
DpnInterfaces currDpnInterfaces = dpnInterfaces != null ? dpnInterfaces : getDpnInterfaces(elanDpns, dpnId);
if (currDpnInterfaces == null || !elanUtils.isDpnPresent(currDpnInterfaces.getDpId())
|| currDpnInterfaces.getInterfaces() == null || currDpnInterfaces.getInterfaces().isEmpty()) {
@NonNull
public List<Bucket> getRemoteBCGroupBuckets(ElanInstance elanInfo, @Nullable DpnInterfaces dpnInterfaces,
- BigInteger dpnId, int bucketId, long elanTag) {
+ Uint64 dpnId, int bucketId, long elanTag) {
List<Bucket> listBucketInfo = new ArrayList<>();
ElanDpnInterfacesList elanDpns = elanUtils.getElanDpnInterfacesList(elanInfo.getElanInstanceName());
if (isVxlanNetworkOrVxlanSegment(elanInfo)) {
+ // Adding 270000 to avoid collision between LPort and elan for broadcast group actions
listBucketInfo.addAll(getRemoteBCGroupTunnelBuckets(elanDpns, dpnId, bucketId,
elanUtils.isOpenstackVniSemanticsEnforced()
- ? ElanUtils.getVxlanSegmentationId(elanInfo) : elanTag));
+ ? ElanUtils.getVxlanSegmentationId(elanInfo).longValue() : elanTag
+ + ElanConstants.ELAN_TAG_ADDEND));
}
listBucketInfo.addAll(getRemoteBCGroupExternalPortBuckets(elanDpns, dpnInterfaces, dpnId,
getNextAvailableBucketId(listBucketInfo.size())));
return listBucketInfo;
}
- public List<Bucket> getRemoteBCGroupBucketsOfElanL2GwDevices(ElanInstance elanInfo, BigInteger dpnId,
+ public List<Bucket> getRemoteBCGroupBucketsOfElanL2GwDevices(ElanInstance elanInfo, Uint64 dpnId,
int bucketId) {
List<Bucket> listBucketInfo = new ArrayList<>();
for (L2GatewayDevice device : ElanL2GwCacheUtils.getInvolvedL2GwDevices(elanInfo.getElanInstanceName())) {
continue;
}
List<Action> listActionInfo = elanItmUtils.buildTunnelItmEgressActions(interfaceName,
- ElanUtils.getVxlanSegmentationId(elanInfo), true);
+ ElanUtils.getVxlanSegmentationId(elanInfo).longValue(), true);
listBucketInfo.add(MDSALUtil.buildBucket(listActionInfo, MDSALUtil.GROUP_WEIGHT, bucketId,
MDSALUtil.WATCH_PORT, MDSALUtil.WATCH_GROUP));
bucketId++;
return listBucketInfo;
}
- public List<Bucket> getRemoteBCGroupBucketsOfElanExternalTeps(ElanInstance elanInfo, BigInteger dpnId,
+ public List<Bucket> getRemoteBCGroupBucketsOfElanExternalTeps(ElanInstance elanInfo, Uint64 dpnId,
int bucketId) {
ElanInstance operElanInstance = null;
try {
operElanInstance = new SingleTransactionDataBroker(broker).syncReadOptional(
LogicalDatastoreType.OPERATIONAL,
InstanceIdentifier.builder(ElanInstances.class).child(ElanInstance.class, elanInfo.key())
- .build()).orNull();
- } catch (ReadFailedException e) {
+ .build()).orElse(null);
+ } catch (InterruptedException | ExecutionException e) {
LOG.error("Failed to read elan instance operational path {}", elanInfo, e);
return emptyList();
}
continue;
}
List<Action> listActionInfo = elanItmUtils.buildTunnelItmEgressActions(interfaceName,
- ElanUtils.getVxlanSegmentationId(elanInfo), false);
+ ElanUtils.getVxlanSegmentationId(elanInfo).longValue(), false);
listBucketInfo.add(MDSALUtil.buildBucket(listActionInfo, MDSALUtil.GROUP_WEIGHT, bucketId,
MDSALUtil.WATCH_PORT, MDSALUtil.WATCH_GROUP));
bucketId++;
}
@SuppressWarnings("checkstyle:IllegalCatch")
- private List<Bucket> getRemoteBCGroupTunnelBuckets(ElanDpnInterfacesList elanDpns, BigInteger dpnId, int bucketId,
+ private List<Bucket> getRemoteBCGroupTunnelBuckets(ElanDpnInterfacesList elanDpns, Uint64 dpnId, int bucketId,
long elanTagOrVni) {
List<Bucket> listBucketInfo = new ArrayList<>();
if (elanDpns != null) {
try {
List<Action> listActionInfo = elanItmUtils.getInternalTunnelItmEgressAction(dpnId,
dpnInterface.getDpId(), elanTagOrVni);
+ LOG.trace("configuring broadcast group for elan {} for source DPN {} and destination DPN {} "
+ + "with actions {}", elanTagOrVni, dpnId, dpnInterface.getDpId(), listActionInfo);
if (listActionInfo.isEmpty()) {
continue;
}
*/
private ListenableFuture<Void> prepareRemoteMcastMacEntry(String elanName,
L2GatewayDevice device, List<IpAddress> dpnsTepIps,
- List<IpAddress> l2GwDevicesTepIps) {
+ List<IpAddress> l2GwDevicesTepIps, boolean addCase) {
NodeId nodeId = new NodeId(device.getHwvtepNodeId());
ArrayList<IpAddress> remoteTepIps = new ArrayList<>(l2GwDevicesTepIps);
String logicalSwitchName = ElanL2GatewayUtils.getLogicalSwitchFromElan(elanName);
LOG.info("Adding RemoteMcastMac for node: {} with physical locators: {}", device.getHwvtepNodeId(),
remoteTepIps);
- return putRemoteMcastMac(nodeId, logicalSwitchName, remoteTepIps);
+ return putRemoteMcastMac(nodeId, logicalSwitchName, remoteTepIps, addCase);
}
/**
* @param tepIps
* the tep ips
*/
- private static ListenableFuture<Void> putRemoteMcastMac(NodeId nodeId, String logicalSwitchName,
- ArrayList<IpAddress> tepIps) {
+ private ListenableFuture<Void> putRemoteMcastMac(NodeId nodeId, String logicalSwitchName,
+ ArrayList<IpAddress> tepIps, boolean addCase) {
List<LocatorSet> locators = new ArrayList<>();
for (IpAddress tepIp : tepIps) {
HwvtepPhysicalLocatorAugmentation phyLocatorAug = HwvtepSouthboundUtils
HwvtepLogicalSwitchRef lsRef = new HwvtepLogicalSwitchRef(HwvtepSouthboundUtils
.createLogicalSwitchesInstanceIdentifier(nodeId, new HwvtepNodeName(logicalSwitchName)));
- RemoteMcastMacs remoteMcastMac = new RemoteMcastMacsBuilder()
+ RemoteMcastMacs newRemoteMcastMac = new RemoteMcastMacsBuilder()
.setMacEntryKey(new MacAddress(ElanConstants.UNKNOWN_DMAC)).setLogicalSwitchRef(lsRef)
.setLocatorSet(locators).build();
InstanceIdentifier<RemoteMcastMacs> iid = HwvtepSouthboundUtils.createRemoteMcastMacsInstanceIdentifier(nodeId,
- remoteMcastMac.key());
+ newRemoteMcastMac.key());
+ RemoteMcastMacs existingRemoteMcastMac = null;
+ try {
+ Optional<RemoteMcastMacs> mac = elanRefUtil.getConfigMcastCache().get(iid);
+ if (mac.isPresent()) {
+ existingRemoteMcastMac = mac.get();
+ }
+ } catch (ReadFailedException e) {
+ LOG.error("Failed to read iid {}", iid, e);
+ }
+
+ if (addCase && areLocatorsAlreadyConfigured(existingRemoteMcastMac, newRemoteMcastMac)) {
+ return Futures.immediateFuture(null);
+ }
+
return ResourceBatchingManager.getInstance().put(ResourceBatchingManager.ShardResource.CONFIG_TOPOLOGY,
- iid, remoteMcastMac);
+ iid, newRemoteMcastMac);
}
+ private boolean areLocatorsAlreadyConfigured(RemoteMcastMacs existingMac, RemoteMcastMacs newMac) {
+ if (existingMac == null) {
+ return false;
+ }
+ Set existingLocators = new HashSet<>(existingMac.getLocatorSet());
+ List newLocators = newMac.getLocatorSet();
+ return existingLocators.containsAll(newLocators);
+ }
+
+ private InstanceIdentifier<RemoteMcastMacs> getRemoteMcastIid(NodeId nodeId, String logicalSwitchName) {
+ HwvtepLogicalSwitchRef lsRef = new HwvtepLogicalSwitchRef(HwvtepSouthboundUtils
+ .createLogicalSwitchesInstanceIdentifier(nodeId, new HwvtepNodeName(logicalSwitchName)));
+ RemoteMcastMacs remoteMcastMac = new RemoteMcastMacsBuilder()
+ .setMacEntryKey(new MacAddress(ElanConstants.UNKNOWN_DMAC)).setLogicalSwitchRef(lsRef)
+ .build();
+ return HwvtepSouthboundUtils.createRemoteMcastMacsInstanceIdentifier(nodeId,
+ remoteMcastMac.key());
+ }
+
/**
* Gets all the tep ips of dpns.
*
* the dpns
* @return the all tep ips of dpns and devices
*/
- private List<IpAddress> getAllTepIpsOfDpns(L2GatewayDevice l2GwDevice, List<DpnInterfaces> dpns) {
+ private List<IpAddress> getAllTepIpsOfDpns(L2GatewayDevice l2GwDevice, Collection<DpnInterfaces> dpns) {
List<IpAddress> tepIps = new ArrayList<>();
for (DpnInterfaces dpn : dpns) {
IpAddress internalTunnelIp = elanItmUtils.getSourceDpnTepIp(dpn.getDpId(),
* the l2 gateway device
* @return the listenable future
*/
- public List<ListenableFuture<Void>> handleMcastForElanL2GwDeviceDelete(String elanName,
+ public List<FluentFuture<?>> handleMcastForElanL2GwDeviceDelete(String elanName,
L2GatewayDevice l2GatewayDevice) {
- ListenableFuture<Void> deleteTepFuture =
+ FluentFuture<?> deleteTepFuture =
txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION,
tx -> tx.delete(buildExternalTepPath(elanName, l2GatewayDevice.getTunnelIp())));
updateMcastMacsForAllElanDevices(elanName, l2GatewayDevice, false/* updateThisDevice */);
- ListenableFuture<Void> deleteRemoteMcastMacFuture = deleteRemoteMcastMac(
+ FluentFuture<?> deleteRemoteMcastMacFuture = deleteRemoteMcastMac(
new NodeId(l2GatewayDevice.getHwvtepNodeId()), elanName);
return Arrays.asList(deleteRemoteMcastMacFuture, deleteTepFuture);
}
* the logical switch name
* @return the listenable future
*/
- public ListenableFuture<Void> deleteRemoteMcastMac(NodeId nodeId, String logicalSwitchName) {
+ public FluentFuture<? extends @NonNull CommitInfo> deleteRemoteMcastMac(NodeId nodeId, String logicalSwitchName) {
InstanceIdentifier<LogicalSwitches> logicalSwitch = HwvtepSouthboundUtils
.createLogicalSwitchesInstanceIdentifier(nodeId, new HwvtepNodeName(logicalSwitchName));
RemoteMcastMacsKey remoteMcastMacsKey = new RemoteMcastMacsKey(new HwvtepLogicalSwitchRef(logicalSwitch),
DesignatedSwitchForTunnel desgSwitch = getDesignatedSwitchForExternalTunnel(l2GwDevice.getTunnelIp(),
elanInstanceName);
if (desgSwitch != null) {
- tepIp = elanItmUtils.getSourceDpnTepIp(BigInteger.valueOf(desgSwitch.getDpId()),
+ tepIp = elanItmUtils.getSourceDpnTepIp(Uint64.valueOf(desgSwitch.getDpId()),
new NodeId(l2GwDevice.getHwvtepNodeId()));
}
return tepIp;
*/
public DesignatedSwitchForTunnel getDesignatedSwitchForExternalTunnel(IpAddress tunnelIp,
String elanInstanceName) {
- InstanceIdentifier<DesignatedSwitchForTunnel> instanceIdentifier = InstanceIdentifier
+ try {
+ InstanceIdentifier<DesignatedSwitchForTunnel> instanceIdentifier = InstanceIdentifier
.builder(DesignatedSwitchesForExternalTunnels.class)
- .child(DesignatedSwitchForTunnel.class, new DesignatedSwitchForTunnelKey(elanInstanceName, tunnelIp))
+ .child(DesignatedSwitchForTunnel.class,
+ new DesignatedSwitchForTunnelKey(elanInstanceName, tunnelIp))
.build();
- return MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, instanceIdentifier).orNull();
+ return MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, instanceIdentifier)
+ .orElse(null);
+ } catch (ExecutionException e) {
+ LOG.error("Exception while retriving DesignatedSwitch for elan {} and tunnel {}",
+ elanInstanceName, tunnelIp, e);
+ } catch (InterruptedException e) {
+ LOG.error("Exception while retriving DesignatedSwitch for elan {} and tunnel {}",
+ elanInstanceName, tunnelIp, e);
+ }
+ return null;
}
}
Code Review / netvirt.git / blobdiff