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.Collection;
import java.util.concurrent.CopyOnWriteArraySet;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
+
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.apache.commons.lang3.tuple.Pair;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.clustering.EntityOwnershipService;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.genius.mdsalutil.NwConstants;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.genius.utils.hwvtep.HwvtepSouthboundConstants;
import org.opendaylight.genius.utils.hwvtep.HwvtepSouthboundUtils;
import org.opendaylight.genius.utils.hwvtep.HwvtepUtils;
-import org.opendaylight.netvirt.dhcpservice.api.DHCPMConstants;
+import org.opendaylight.netvirt.dhcpservice.api.DhcpMConstants;
import org.opendaylight.netvirt.elanmanager.utils.ElanL2GwCacheUtils;
import org.opendaylight.netvirt.neutronvpn.api.l2gw.L2GatewayDevice;
import org.opendaylight.netvirt.neutronvpn.api.l2gw.utils.L2GatewayCacheUtils;
public class DhcpExternalTunnelManager {
- private static final Logger logger = LoggerFactory.getLogger(DhcpExternalTunnelManager.class);
+ private static final Logger LOG = LoggerFactory.getLogger(DhcpExternalTunnelManager.class);
public static final String UNKNOWN_DMAC = "00:00:00:00:00:00";
private final DataBroker broker;
private final IMdsalApiManager mdsalUtil;
private final ItmRpcService itmRpcService;
private final EntityOwnershipService entityOwnershipService;
+ private final IInterfaceManager interfaceManager;
- private ConcurrentMap<BigInteger, Set<Pair<IpAddress, String>>> designatedDpnsToTunnelIpElanNameCache = new ConcurrentHashMap<>();
- private ConcurrentMap<Pair<IpAddress, String>, Set<String>> tunnelIpElanNameToVmMacCache = new ConcurrentHashMap<>();
- private ConcurrentMap<Pair<IpAddress, String>, Set<String>> availableVMCache = new ConcurrentHashMap<>();
- private ConcurrentMap<Pair<BigInteger, String>, Port> vniMacAddressToPortCache = new ConcurrentHashMap<>();
+ private final ConcurrentMap<BigInteger, Set<Pair<IpAddress, String>>> designatedDpnsToTunnelIpElanNameCache =
+ new ConcurrentHashMap<>();
+ private final ConcurrentMap<Pair<IpAddress, String>, Set<String>> tunnelIpElanNameToVmMacCache =
+ new ConcurrentHashMap<>();
+ private final ConcurrentMap<Pair<IpAddress, String>, Set<String>> availableVMCache = new ConcurrentHashMap<>();
+ private final ConcurrentMap<Pair<BigInteger, String>, Port> vniMacAddressToPortCache = new ConcurrentHashMap<>();
public DhcpExternalTunnelManager(final DataBroker broker,
final IMdsalApiManager mdsalUtil, final ItmRpcService itmRpcService,
- final EntityOwnershipService entityOwnershipService) {
+ final EntityOwnershipService entityOwnershipService, final IInterfaceManager interfaceManager) {
this.broker = broker;
this.mdsalUtil = mdsalUtil;
this.itmRpcService = itmRpcService;
this.entityOwnershipService = entityOwnershipService;
+ this.interfaceManager = interfaceManager;
}
public void init() {
}
private void initilizeCaches() {
- logger.trace("Loading designatedDpnsToTunnelIpElanNameCache");
- InstanceIdentifier<DesignatedSwitchesForExternalTunnels> instanceIdentifier = InstanceIdentifier.builder(DesignatedSwitchesForExternalTunnels.class).build();
- Optional<DesignatedSwitchesForExternalTunnels> designatedSwitchForTunnelOptional = MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, instanceIdentifier);
+ LOG.trace("Loading designatedDpnsToTunnelIpElanNameCache");
+ InstanceIdentifier<DesignatedSwitchesForExternalTunnels> instanceIdentifier =
+ InstanceIdentifier.builder(DesignatedSwitchesForExternalTunnels.class).build();
+ Optional<DesignatedSwitchesForExternalTunnels> designatedSwitchForTunnelOptional =
+ MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, instanceIdentifier);
if (designatedSwitchForTunnelOptional.isPresent()) {
- List<DesignatedSwitchForTunnel> list = designatedSwitchForTunnelOptional.get().getDesignatedSwitchForTunnel();
+ List<DesignatedSwitchForTunnel> list =
+ designatedSwitchForTunnelOptional.get().getDesignatedSwitchForTunnel();
for (DesignatedSwitchForTunnel designatedSwitchForTunnel : list) {
- Set<Pair<IpAddress, String>> setOfTunnelIpElanNamePair = designatedDpnsToTunnelIpElanNameCache.get(designatedSwitchForTunnel.getDpId());
+ Set<Pair<IpAddress, String>> setOfTunnelIpElanNamePair =
+ designatedDpnsToTunnelIpElanNameCache.get(designatedSwitchForTunnel.getDpId());
if (setOfTunnelIpElanNamePair == null) {
setOfTunnelIpElanNamePair = new CopyOnWriteArraySet<>();
}
- Pair<IpAddress, String> tunnelIpElanNamePair = new ImmutablePair<>(designatedSwitchForTunnel.getTunnelRemoteIpAddress(), designatedSwitchForTunnel.getElanInstanceName());
+ Pair<IpAddress, String> tunnelIpElanNamePair =
+ new ImmutablePair<>(designatedSwitchForTunnel.getTunnelRemoteIpAddress(),
+ designatedSwitchForTunnel.getElanInstanceName());
setOfTunnelIpElanNamePair.add(tunnelIpElanNamePair);
- designatedDpnsToTunnelIpElanNameCache.put(BigInteger.valueOf(designatedSwitchForTunnel.getDpId()), setOfTunnelIpElanNamePair);
+ designatedDpnsToTunnelIpElanNameCache.put(BigInteger.valueOf(designatedSwitchForTunnel.getDpId()),
+ setOfTunnelIpElanNamePair);
}
}
- logger.trace("Loading vniMacAddressToPortCache");
+ LOG.trace("Loading vniMacAddressToPortCache");
InstanceIdentifier<Ports> inst = InstanceIdentifier.builder(Neutron.class).child(Ports.class).build();
Optional<Ports> optionalPorts = MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, inst);
if (optionalPorts.isPresent()) {
List<Port> list = optionalPorts.get().getPort();
for (Port port : list) {
- if(NeutronUtils.isPortVnicTypeNormal(port)) {
+ if (NeutronUtils.isPortVnicTypeNormal(port)) {
continue;
}
String macAddress = port.getMacAddress().getValue();
updateVniMacToPortCache(new BigInteger(segmentationId), macAddress, port);
}
}
-
}
-
- public BigInteger designateDpnId(IpAddress tunnelIp,
- String elanInstanceName, List<BigInteger> dpns) {
+ public BigInteger designateDpnId(IpAddress tunnelIp, String elanInstanceName, List<BigInteger> dpns) {
BigInteger designatedDpnId = readDesignatedSwitchesForExternalTunnel(tunnelIp, elanInstanceName);
- if (designatedDpnId != null && !designatedDpnId.equals(DHCPMConstants.INVALID_DPID)) {
- logger.trace("Dpn {} already designated for tunnelIp - elan : {} - {}", designatedDpnId, tunnelIp, elanInstanceName);
+ if (designatedDpnId != null && !designatedDpnId.equals(DhcpMConstants.INVALID_DPID)) {
+ LOG.trace("Dpn {} already designated for tunnelIp - elan : {} - {}", designatedDpnId, tunnelIp,
+ elanInstanceName);
return designatedDpnId;
}
return chooseDpn(tunnelIp, elanInstanceName, dpns);
}
- public void installDhcpFlowsForVms(IpAddress tunnelIp, String elanInstanceName, List<BigInteger> dpns,
- BigInteger designatedDpnId, String vmMacAddress ) {
- logger.trace("In installDhcpFlowsForVms ipAddress {}, elanInstanceName {}, dpn {}, vmMacAddress {}", tunnelIp, elanInstanceName, designatedDpnId, vmMacAddress);
- synchronized (getTunnelIpDpnKey(tunnelIp, designatedDpnId)) {
- installDhcpEntries(designatedDpnId, vmMacAddress, entityOwnershipService);
- dpns.remove(designatedDpnId);
- for (BigInteger dpn : dpns) {
- installDhcpDropAction(dpn, vmMacAddress, entityOwnershipService);
+ public void installDhcpFlowsForVms(final IpAddress tunnelIp, String elanInstanceName, final List<BigInteger> dpns,
+ final BigInteger designatedDpnId, final String vmMacAddress) {
+ LOG.trace("In installDhcpFlowsForVms ipAddress {}, elanInstanceName {}, dpn {}, vmMacAddress {}", tunnelIp,
+ elanInstanceName, designatedDpnId, vmMacAddress);
+ // TODO: Make use a util that directly tells if this is the owner or not rather than making use of callbacks.
+ ListenableFuture<Boolean> checkEntityOwnerFuture = ClusteringUtils.checkNodeEntityOwner(
+ entityOwnershipService, HwvtepSouthboundConstants.ELAN_ENTITY_TYPE,
+ HwvtepSouthboundConstants.ELAN_ENTITY_NAME);
+ Futures.addCallback(checkEntityOwnerFuture, new FutureCallback<Boolean>() {
+ @Override
+ public void onSuccess(Boolean isOwner) {
+ if (isOwner) {
+ synchronized (getTunnelIpDpnKey(tunnelIp, designatedDpnId)) {
+ WriteTransaction tx = broker.newWriteOnlyTransaction();
+ dpns.remove(designatedDpnId);
+ for (BigInteger dpn : dpns) {
+ installDhcpDropAction(dpn, vmMacAddress, tx);
+ }
+ installDhcpEntries(designatedDpnId, vmMacAddress, tx);
+ DhcpServiceUtils.submitTransaction(tx);
+ }
+ } else {
+ LOG.trace("Exiting installDhcpEntries since this cluster node is not the owner for dpn");
+ }
}
- updateLocalCache(tunnelIp, elanInstanceName, vmMacAddress);
- }
+
+ @Override
+ public void onFailure(Throwable error) {
+ LOG.error("Error while fetching checkNodeEntityOwner", error);
+ }
+ });
+ updateLocalCache(tunnelIp, elanInstanceName, vmMacAddress);
}
- public void installDhcpFlowsForVms(BigInteger designatedDpnId, Set<String> listVmMacAddress) {
+ public void installDhcpFlowsForVms(BigInteger designatedDpnId, Set<String> listVmMacAddress, WriteTransaction tx) {
for (String vmMacAddress : listVmMacAddress) {
- installDhcpEntries(designatedDpnId, vmMacAddress);
+ installDhcpEntries(designatedDpnId, vmMacAddress, tx);
}
}
removeFromLocalCache(elanInstanceName, vmMacAddress);
}
+ public void unInstallDhcpFlowsForVms(String elanInstanceName, IpAddress tunnelIp, List<BigInteger> dpns) {
+ Pair<IpAddress, String> tunnelIpElanNamePair = new ImmutablePair<>(tunnelIp, elanInstanceName);
+ Set<String> vmMacs = tunnelIpElanNameToVmMacCache.get(tunnelIpElanNamePair);
+ LOG.trace("In unInstallFlowsForVms elanInstanceName {}, tunnelIp {}, dpns {}, vmMacs {}",
+ elanInstanceName, tunnelIp, dpns, vmMacs);
+ if (vmMacs == null) {
+ return;
+ }
+ for (String vmMacAddress : vmMacs) {
+ unInstallDhcpEntriesOnDpns(dpns, vmMacAddress);
+ }
+ tunnelIpElanNameToVmMacCache.remove(tunnelIpElanNamePair);
+ }
+
public BigInteger readDesignatedSwitchesForExternalTunnel(IpAddress tunnelIp, String elanInstanceName) {
if (tunnelIp == null || elanInstanceName == null || elanInstanceName.isEmpty()) {
return null;
}
- InstanceIdentifier<DesignatedSwitchForTunnel> instanceIdentifier = InstanceIdentifier.builder(DesignatedSwitchesForExternalTunnels.class).child(DesignatedSwitchForTunnel.class, new DesignatedSwitchForTunnelKey(elanInstanceName, tunnelIp)).build();
- Optional<DesignatedSwitchForTunnel> designatedSwitchForTunnelOptional = MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, instanceIdentifier);
+ InstanceIdentifier<DesignatedSwitchForTunnel> instanceIdentifier =
+ InstanceIdentifier.builder(DesignatedSwitchesForExternalTunnels.class)
+ .child(DesignatedSwitchForTunnel.class,
+ new DesignatedSwitchForTunnelKey(elanInstanceName, tunnelIp)).build();
+ Optional<DesignatedSwitchForTunnel> designatedSwitchForTunnelOptional =
+ MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, instanceIdentifier);
if (designatedSwitchForTunnelOptional.isPresent()) {
return BigInteger.valueOf(designatedSwitchForTunnelOptional.get().getDpId());
}
return null;
}
- public void writeDesignatedSwitchForExternalTunnel(BigInteger dpnId, IpAddress tunnelIp, String elanInstanceName) {
- DesignatedSwitchForTunnelKey designatedSwitchForTunnelKey = new DesignatedSwitchForTunnelKey(elanInstanceName, tunnelIp);
- InstanceIdentifier<DesignatedSwitchForTunnel> instanceIdentifier = InstanceIdentifier.builder(DesignatedSwitchesForExternalTunnels.class).child(DesignatedSwitchForTunnel.class, designatedSwitchForTunnelKey).build();
- DesignatedSwitchForTunnel designatedSwitchForTunnel = new DesignatedSwitchForTunnelBuilder().setDpId(dpnId.longValue()).setElanInstanceName(elanInstanceName).setTunnelRemoteIpAddress(tunnelIp).setKey(designatedSwitchForTunnelKey).build();
- logger.trace("Writing into CONFIG DS tunnelIp {}, elanInstanceName {}, dpnId {}", tunnelIp, elanInstanceName, dpnId);
+ public void writeDesignatedSwitchForExternalTunnel(BigInteger dpnId, IpAddress tunnelIp,
+ String elanInstanceName) {
+ DesignatedSwitchForTunnelKey designatedSwitchForTunnelKey =
+ new DesignatedSwitchForTunnelKey(elanInstanceName, tunnelIp);
+ InstanceIdentifier<DesignatedSwitchForTunnel> instanceIdentifier =
+ InstanceIdentifier.builder(DesignatedSwitchesForExternalTunnels.class)
+ .child(DesignatedSwitchForTunnel.class, designatedSwitchForTunnelKey).build();
+ DesignatedSwitchForTunnel designatedSwitchForTunnel =
+ new DesignatedSwitchForTunnelBuilder().setDpId(dpnId.longValue())
+ .setElanInstanceName(elanInstanceName).setTunnelRemoteIpAddress(tunnelIp)
+ .setKey(designatedSwitchForTunnelKey).build();
+ LOG.trace("Writing into CONFIG DS tunnelIp {}, elanInstanceName {}, dpnId {}", tunnelIp, elanInstanceName,
+ dpnId);
MDSALUtil.syncUpdate(broker, LogicalDatastoreType.CONFIGURATION, instanceIdentifier, designatedSwitchForTunnel);
updateLocalCache(dpnId, tunnelIp, elanInstanceName);
}
- public void removeDesignatedSwitchForExternalTunnel(BigInteger dpnId, IpAddress tunnelIp, String elanInstanceName) {
- DesignatedSwitchForTunnelKey designatedSwitchForTunnelKey = new DesignatedSwitchForTunnelKey(elanInstanceName, tunnelIp);
- InstanceIdentifier<DesignatedSwitchForTunnel> instanceIdentifier = InstanceIdentifier.builder(DesignatedSwitchesForExternalTunnels.class).child(DesignatedSwitchForTunnel.class, designatedSwitchForTunnelKey).build();
- logger.trace("Removing from CONFIG DS tunnelIp {}, elanInstanceName {}, dpnId {}", tunnelIp, elanInstanceName, dpnId);
+ public void removeDesignatedSwitchForExternalTunnel(BigInteger dpnId, IpAddress tunnelIp,
+ String elanInstanceName) {
+ DesignatedSwitchForTunnelKey designatedSwitchForTunnelKey =
+ new DesignatedSwitchForTunnelKey(elanInstanceName, tunnelIp);
+ InstanceIdentifier<DesignatedSwitchForTunnel> instanceIdentifier =
+ InstanceIdentifier.builder(DesignatedSwitchesForExternalTunnels.class)
+ .child(DesignatedSwitchForTunnel.class, designatedSwitchForTunnelKey).build();
+ LOG.trace("Removing from CONFIG DS tunnelIp {}, elanInstanceName {}, dpnId {}", tunnelIp,
+ elanInstanceName, dpnId);
MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, instanceIdentifier);
removeFromLocalCache(dpnId, tunnelIp, elanInstanceName);
}
public void installDhcpDropActionOnDpn(BigInteger dpId) {
List<String> vmMacs = getAllVmMacs();
- logger.trace("Installing drop actions to this new DPN {} VMs {}", dpId, vmMacs);
+ LOG.trace("Installing drop actions to this new DPN {} VMs {}", dpId, vmMacs);
+ WriteTransaction tx = broker.newWriteOnlyTransaction();
for (String vmMacAddress : vmMacs) {
- installDhcpDropAction(dpId, vmMacAddress);
+ installDhcpDropAction(dpId, vmMacAddress, tx);
}
+ DhcpServiceUtils.submitTransaction(tx);
}
private List<String> getAllVmMacs() {
tunnelIpElanNameSet = new CopyOnWriteArraySet<>();
}
tunnelIpElanNameSet.add(tunnelIpElanName);
- logger.trace("Updating designatedDpnsToTunnelIpElanNameCache for designatedDpn {} value {}", designatedDpnId, tunnelIpElanNameSet);
+ LOG.trace("Updating designatedDpnsToTunnelIpElanNameCache for designatedDpn {} value {}", designatedDpnId,
+ tunnelIpElanNameSet);
designatedDpnsToTunnelIpElanNameCache.put(designatedDpnId, tunnelIpElanNameSet);
}
setOfExistingVmMacAddress = new CopyOnWriteArraySet<>();
}
setOfExistingVmMacAddress.add(vmMacAddress);
- logger.trace("Updating tunnelIpElanNameToVmMacCache for tunnelIpElanName {} value {}", tunnelIpElanName, setOfExistingVmMacAddress);
+ LOG.trace("Updating tunnelIpElanNameToVmMacCache for tunnelIpElanName {} value {}", tunnelIpElanName,
+ setOfExistingVmMacAddress);
tunnelIpElanNameToVmMacCache.put(tunnelIpElanName, setOfExistingVmMacAddress);
updateExistingVMTunnelIPCache(tunnelIp, elanInstanceName, vmMacAddress);
}
public void updateExistingVMTunnelIPCache(IpAddress tunnelIp, String elanInstanceName, String vmMacAddress) {
- Pair<IpAddress, String> tunnelIpElanName = new ImmutablePair<IpAddress, String>(tunnelIp, elanInstanceName);
+ Pair<IpAddress, String> tunnelIpElanName = new ImmutablePair<>(tunnelIp, elanInstanceName);
Set<String> listExistingVmMacAddress;
listExistingVmMacAddress = availableVMCache.get(tunnelIpElanName);
- if (null == listExistingVmMacAddress) {
+ if (listExistingVmMacAddress == null) {
listExistingVmMacAddress = new CopyOnWriteArraySet<>();
}
listExistingVmMacAddress.add(vmMacAddress);
- logger.trace("Updating availableVMCache for tunnelIpElanName {} value {}", tunnelIpElanName,
+ LOG.trace("Updating availableVMCache for tunnelIpElanName {} value {}", tunnelIpElanName,
listExistingVmMacAddress);
availableVMCache.put(tunnelIpElanName, listExistingVmMacAddress);
}
public void handleDesignatedDpnDown(BigInteger dpnId, List<BigInteger> listOfDpns) {
- logger.trace("In handleDesignatedDpnDown dpnId {}, listOfDpns {}", dpnId, listOfDpns);
+ LOG.trace("In handleDesignatedDpnDown dpnId {}, listOfDpns {}", dpnId, listOfDpns);
try {
Set<Pair<IpAddress, String>> setOfTunnelIpElanNamePairs = designatedDpnsToTunnelIpElanNameCache.get(dpnId);
- if (!dpnId.equals(DHCPMConstants.INVALID_DPID)) {
+ WriteTransaction tx = broker.newWriteOnlyTransaction();
+ if (!dpnId.equals(DhcpMConstants.INVALID_DPID)) {
List<String> listOfVms = getAllVmMacs();
for (String vmMacAddress : listOfVms) {
- unInstallDhcpEntries(dpnId, vmMacAddress);
+ unInstallDhcpEntries(dpnId, vmMacAddress, tx);
}
}
if (setOfTunnelIpElanNamePairs == null || setOfTunnelIpElanNamePairs.isEmpty()) {
- logger.trace("No tunnelIpElanName to handle for dpn {}. Returning", dpnId);
+ LOG.trace("No tunnelIpElanName to handle for dpn {}. Returning", dpnId);
return;
}
for (Pair<IpAddress, String> pair : setOfTunnelIpElanNamePairs) {
- updateCacheAndInstallNewFlows(dpnId, listOfDpns, pair);
+ updateCacheAndInstallNewFlows(dpnId, listOfDpns, pair, tx);
}
- } catch (Exception e) {
- logger.error("Error in handleDesignatedDpnDown {}", e);
+ DhcpServiceUtils.submitTransaction(tx);
+ } catch (ExecutionException e) {
+ LOG.error("Error in handleDesignatedDpnDown {}", e);
}
}
public void updateCacheAndInstallNewFlows(BigInteger dpnId,
- List<BigInteger> listOfDpns, Pair<IpAddress, String> pair)
+ List<BigInteger> listOfDpns, Pair<IpAddress, String> pair, WriteTransaction tx)
throws ExecutionException {
BigInteger newDesignatedDpn = chooseDpn(pair.getLeft(), pair.getRight(), listOfDpns);
- if (newDesignatedDpn.equals(DHCPMConstants.INVALID_DPID)) {
+ if (newDesignatedDpn.equals(DhcpMConstants.INVALID_DPID)) {
return;
}
Set<String> setOfVmMacs = tunnelIpElanNameToVmMacCache.get(pair);
if (setOfVmMacs != null && !setOfVmMacs.isEmpty()) {
- logger.trace("Updating DHCP flows for VMs {} with new designated DPN {}", setOfVmMacs, newDesignatedDpn);
- installDhcpFlowsForVms(newDesignatedDpn, setOfVmMacs);
+ LOG.trace("Updating DHCP flows for VMs {} with new designated DPN {}", setOfVmMacs, newDesignatedDpn);
+ installDhcpFlowsForVms(newDesignatedDpn, setOfVmMacs, tx);
}
}
- private void changeExistingFlowToDrop(Pair<IpAddress, String> tunnelIpElanNamePair, BigInteger dpnId) {
- try {
- Set<String> setOfVmMacAddress = tunnelIpElanNameToVmMacCache.get(tunnelIpElanNamePair);
- if (setOfVmMacAddress == null || setOfVmMacAddress.isEmpty()) {
- return;
- }
- for (String vmMacAddress : setOfVmMacAddress) {
- installDhcpDropAction(dpnId, vmMacAddress);
- }
- } catch (Exception e) {
- logger.error("Error in uninstallExistingFlows {}", e);
+ private void changeExistingFlowToDrop(Pair<IpAddress, String> tunnelIpElanNamePair, BigInteger dpnId,
+ WriteTransaction tx) {
+ Set<String> setOfVmMacAddress = tunnelIpElanNameToVmMacCache.get(tunnelIpElanNamePair);
+ if (setOfVmMacAddress == null || setOfVmMacAddress.isEmpty()) {
+ return;
+ }
+ for (String vmMacAddress : setOfVmMacAddress) {
+ installDhcpDropAction(dpnId, vmMacAddress, tx);
}
}
/**
* Choose a dpn among the list of elanDpns such that it has lowest count of being the designated dpn.
- * @param tunnelIp
- * @param elanInstanceName
- * @param dpns
- * @return
+ * @param tunnelIp The tunnel Ip address
+ * @param elanInstanceName The elan instance name
+ * @param dpns The data path nodes
+ * @return The designated dpn
*/
private BigInteger chooseDpn(IpAddress tunnelIp, String elanInstanceName,
List<BigInteger> dpns) {
- BigInteger designatedDpnId = DHCPMConstants.INVALID_DPID;
+ BigInteger designatedDpnId = DhcpMConstants.INVALID_DPID;
if (dpns != null && dpns.size() != 0) {
List<BigInteger> candidateDpns = DhcpServiceUtils.getDpnsForElan(elanInstanceName, broker);
candidateDpns.retainAll(dpns);
- logger.trace("Choosing new dpn for tunnelIp {}, elanInstanceName {}, among elanDpns {}", tunnelIp, elanInstanceName, candidateDpns);
+ LOG.trace("Choosing new dpn for tunnelIp {}, elanInstanceName {}, among elanDpns {}",
+ tunnelIp, elanInstanceName, candidateDpns);
boolean elanDpnAvailableFlag = true;
if (candidateDpns == null || candidateDpns.isEmpty()) {
candidateDpns = dpns;
int size = 0;
L2GatewayDevice device = getDeviceFromTunnelIp(elanInstanceName, tunnelIp);
if (device == null) {
- logger.trace("Could not find any device for elanInstanceName {} and tunnelIp {}", elanInstanceName, tunnelIp);
+ LOG.trace("Could not find any device for elanInstanceName {} and tunnelIp {}",
+ elanInstanceName, tunnelIp);
handleUnableToDesignateDpn(tunnelIp, elanInstanceName);
return designatedDpnId;
}
String hwvtepNodeId = device.getHwvtepNodeId();
if (!elanDpnAvailableFlag) {
if (!isTunnelConfigured(dpn, hwvtepNodeId)) {
- logger.trace("Tunnel is not configured on dpn {} to TOR {}", dpn, hwvtepNodeId);
+ LOG.trace("Tunnel is not configured on dpn {} to TOR {}", dpn, hwvtepNodeId);
continue;
}
} else if (!isTunnelUp(hwvtepNodeId, dpn)) {
- logger.trace("Tunnel is not up between dpn {} and TOR {}", dpn, hwvtepNodeId);
+ LOG.trace("Tunnel is not up between dpn {} and TOR {}", dpn, hwvtepNodeId);
continue;
}
Set<Pair<IpAddress, String>> tunnelIpElanNameSet = designatedDpnsToTunnelIpElanNameCache.get(dpn);
}
private void handleUnableToDesignateDpn(IpAddress tunnelIp, String elanInstanceName) {
- writeDesignatedSwitchForExternalTunnel(DHCPMConstants.INVALID_DPID, tunnelIp, elanInstanceName);
+ writeDesignatedSwitchForExternalTunnel(DhcpMConstants.INVALID_DPID, tunnelIp, elanInstanceName);
}
- public void installDhcpEntries(BigInteger dpnId, String vmMacAddress) {
- DhcpServiceUtils.setupDhcpFlowEntry(dpnId, NwConstants.DHCP_TABLE_EXTERNAL_TUNNEL, vmMacAddress, NwConstants.ADD_FLOW, mdsalUtil);
+ private void installDhcpEntries(BigInteger dpnId, String vmMacAddress, WriteTransaction tx) {
+ DhcpServiceUtils.setupDhcpFlowEntry(dpnId, NwConstants.DHCP_TABLE_EXTERNAL_TUNNEL,
+ vmMacAddress, NwConstants.ADD_FLOW, mdsalUtil, tx);
}
- public void installDhcpEntries(final BigInteger dpnId, final String vmMacAddress, EntityOwnershipService eos) {
- final String nodeId = DhcpServiceUtils.getNodeIdFromDpnId(dpnId);
- ListenableFuture<Boolean> checkEntityOwnerFuture = ClusteringUtils.checkNodeEntityOwner(
- eos, HwvtepSouthboundConstants.ELAN_ENTITY_TYPE,
- HwvtepSouthboundConstants.ELAN_ENTITY_NAME);
- Futures.addCallback(checkEntityOwnerFuture, new FutureCallback<Boolean>() {
- @Override
- public void onSuccess(Boolean isOwner) {
- if (isOwner) {
- installDhcpEntries(dpnId, vmMacAddress);
- } else {
- logger.trace("Exiting installDhcpEntries since this cluster node is not the owner for dpn {}", nodeId);
- }
- }
-
- @Override
- public void onFailure(Throwable error) {
- logger.error("Error while fetching checkNodeEntityOwner", error);
- }
- });
+ public void unInstallDhcpEntries(BigInteger dpnId, String vmMacAddress, WriteTransaction tx) {
+ DhcpServiceUtils.setupDhcpFlowEntry(dpnId, NwConstants.DHCP_TABLE_EXTERNAL_TUNNEL,
+ vmMacAddress, NwConstants.DEL_FLOW, mdsalUtil, tx);
}
- public void unInstallDhcpEntries(BigInteger dpnId, String vmMacAddress) {
- DhcpServiceUtils.setupDhcpFlowEntry(dpnId, NwConstants.DHCP_TABLE_EXTERNAL_TUNNEL, vmMacAddress, NwConstants.DEL_FLOW, mdsalUtil);
+ private void installDhcpDropAction(BigInteger dpn, String vmMacAddress, WriteTransaction tx) {
+ DhcpServiceUtils.setupDhcpDropAction(dpn, NwConstants.DHCP_TABLE_EXTERNAL_TUNNEL,
+ vmMacAddress, NwConstants.ADD_FLOW, mdsalUtil, tx);
}
- public void unInstallDhcpEntries(final BigInteger dpnId, final String vmMacAddress, EntityOwnershipService eos) {
- final String nodeId = DhcpServiceUtils.getNodeIdFromDpnId(dpnId);
- // TODO: Make use a util that directly tells if this is the owner or not rather than making use of callbacks.
- ListenableFuture<Boolean> checkEntityOwnerFuture = ClusteringUtils.checkNodeEntityOwner(
- eos, HwvtepSouthboundConstants.ELAN_ENTITY_TYPE,
- HwvtepSouthboundConstants.ELAN_ENTITY_NAME);
- Futures.addCallback(checkEntityOwnerFuture, new FutureCallback<Boolean>() {
- @Override
- public void onSuccess(Boolean isOwner) {
- if (isOwner) {
- unInstallDhcpEntries(dpnId, vmMacAddress);
- } else {
- logger.trace("Exiting unInstallDhcpEntries since this cluster node is not the owner for dpn {}", nodeId);
- }
- }
-
- @Override
- public void onFailure(Throwable error) {
- logger.error("Error while fetching checkNodeEntityOwner", error);
- }
- });
- }
-
- public void installDhcpDropAction(BigInteger dpn, String vmMacAddress) {
- DhcpServiceUtils.setupDhcpDropAction(dpn, NwConstants.DHCP_TABLE_EXTERNAL_TUNNEL, vmMacAddress, NwConstants.ADD_FLOW, mdsalUtil);
- }
-
- public void installDhcpDropAction(final BigInteger dpnId, final String vmMacAddress, EntityOwnershipService eos) {
- final String nodeId = DhcpServiceUtils.getNodeIdFromDpnId(dpnId);
- ListenableFuture<Boolean> checkEntityOwnerFuture = ClusteringUtils.checkNodeEntityOwner(
- eos, HwvtepSouthboundConstants.ELAN_ENTITY_TYPE,
- HwvtepSouthboundConstants.ELAN_ENTITY_NAME);
- Futures.addCallback(checkEntityOwnerFuture, new FutureCallback<Boolean>() {
- @Override
- public void onSuccess(Boolean isOwner) {
- if (isOwner) {
- installDhcpDropAction(dpnId, vmMacAddress);
- } else {
- logger.trace("Exiting installDhcpDropAction since this cluster node is not the owner for dpn {}", nodeId);
- }
- }
-
- @Override
- public void onFailure(Throwable error) {
- logger.error("Error while fetching checkNodeEntityOwner", error);
- }
- });
- }
-
- public void handleTunnelStateDown(IpAddress tunnelIp, BigInteger interfaceDpn) {
- logger.trace("In handleTunnelStateDown tunnelIp {}, interfaceDpn {}", tunnelIp, interfaceDpn);
+ public void handleTunnelStateDown(IpAddress tunnelIp, BigInteger interfaceDpn,
+ List<ListenableFuture<Void>> futures) {
+ LOG.trace("In handleTunnelStateDown tunnelIp {}, interfaceDpn {}", tunnelIp, interfaceDpn);
if (interfaceDpn == null) {
return;
}
try {
synchronized (getTunnelIpDpnKey(tunnelIp, interfaceDpn)) {
- Set<Pair<IpAddress, String>> tunnelElanPairSet = designatedDpnsToTunnelIpElanNameCache.get(interfaceDpn);
+ Set<Pair<IpAddress, String>> tunnelElanPairSet =
+ designatedDpnsToTunnelIpElanNameCache.get(interfaceDpn);
if (tunnelElanPairSet == null || tunnelElanPairSet.isEmpty()) {
return;
}
+ WriteTransaction tx = broker.newWriteOnlyTransaction();
for (Pair<IpAddress, String> tunnelElanPair : tunnelElanPairSet) {
IpAddress tunnelIpInDpn = tunnelElanPair.getLeft();
if (tunnelIpInDpn.equals(tunnelIp)) {
if (!checkL2GatewayConnection(tunnelElanPair)) {
- logger.trace("Couldn't find device for given tunnelIpElanPair {} in L2GwConnCache", tunnelElanPair);
+ LOG.trace("Couldn't find device for given tunnelIpElanPair {} in L2GwConnCache",
+ tunnelElanPair);
return;
}
List<BigInteger> dpns = DhcpServiceUtils.getListOfDpns(broker);
dpns.remove(interfaceDpn);
- changeExistingFlowToDrop(tunnelElanPair, interfaceDpn);
- updateCacheAndInstallNewFlows(interfaceDpn, dpns, tunnelElanPair);
+ changeExistingFlowToDrop(tunnelElanPair, interfaceDpn, tx);
+ updateCacheAndInstallNewFlows(interfaceDpn, dpns, tunnelElanPair, tx);
}
}
+ futures.add(tx.submit());
}
- } catch (Exception e) {
- logger.error("Error in handleTunnelStateDown {}", e.getMessage());
- logger.trace("Exception details {}", e);
+ } catch (ExecutionException e) {
+ LOG.error("Error in handleTunnelStateDown {}", e.getMessage());
+ LOG.trace("Exception details {}", e);
}
}
private boolean checkL2GatewayConnection(Pair<IpAddress, String> tunnelElanPair) {
- ConcurrentMap<String, L2GatewayDevice> l2GwDevices = ElanL2GwCacheUtils.getInvolvedL2GwDevices(tunnelElanPair.getRight());
+ ConcurrentMap<String, L2GatewayDevice> l2GwDevices =
+ ElanL2GwCacheUtils.getInvolvedL2GwDevices(tunnelElanPair.getRight());
for (L2GatewayDevice device : l2GwDevices.values()) {
if (device.getTunnelIp().equals(tunnelElanPair.getLeft())) {
return true;
}
private String getTunnelIpDpnKey(IpAddress tunnelIp, BigInteger interfaceDpn) {
- return new StringBuffer().append(tunnelIp.toString()).append(interfaceDpn).toString().intern();
+ return tunnelIp.toString() + interfaceDpn;
}
private void removeFromLocalCache(String elanInstanceName, String vmMacAddress) {
if (setOfExistingVmMacAddress == null || setOfExistingVmMacAddress.isEmpty()) {
continue;
}
- logger.trace("Removing vmMacAddress {} from listOfMacs {} for elanInstanceName {}", vmMacAddress, setOfExistingVmMacAddress, elanInstanceName);
+ LOG.trace("Removing vmMacAddress {} from listOfMacs {} for elanInstanceName {}", vmMacAddress,
+ setOfExistingVmMacAddress, elanInstanceName);
setOfExistingVmMacAddress.remove(vmMacAddress);
if (setOfExistingVmMacAddress.size() > 0) {
tunnelIpElanNameToVmMacCache.put(pair, setOfExistingVmMacAddress);
Set<Pair<IpAddress, String>> tunnelIpElanNameSet;
tunnelIpElanNameSet = designatedDpnsToTunnelIpElanNameCache.get(designatedDpnId);
if (tunnelIpElanNameSet != null) {
- logger.trace("Removing tunnelIpElan {} from designatedDpnsToTunnelIpElanNameCache. Existing list {} for designatedDpnId {}", tunnelIpElanName, tunnelIpElanNameSet, designatedDpnId);
+ LOG.trace("Removing tunnelIpElan {} from designatedDpnsToTunnelIpElanNameCache. Existing list {} for "
+ + "designatedDpnId {}",
+ tunnelIpElanName, tunnelIpElanNameSet, designatedDpnId);
tunnelIpElanNameSet.remove(tunnelIpElanName);
if (tunnelIpElanNameSet.size() != 0) {
designatedDpnsToTunnelIpElanNameCache.put(designatedDpnId, tunnelIpElanNameSet);
return;
}
Pair<BigInteger, String> vniMacAddressPair = new ImmutablePair<>(vni, macAddress.toUpperCase());
- logger.trace("Updating vniMacAddressToPortCache with vni {} , mac {} , pair {} and port {}", vni, macAddress.toUpperCase(), vniMacAddressPair, port);
+ LOG.trace("Updating vniMacAddressToPortCache with vni {} , mac {} , pair {} and port {}", vni,
+ macAddress.toUpperCase(), vniMacAddressPair, port);
vniMacAddressToPortCache.put(vniMacAddressPair, port);
}
return null;
}
Pair<BigInteger, String> vniMacAddressPair = new ImmutablePair<>(vni, macAddress.toUpperCase());
- logger.trace("Reading vniMacAddressToPortCache with vni {} , mac {} , pair {} and port {}", vni, macAddress.toUpperCase(), vniMacAddressPair, vniMacAddressToPortCache.get(vniMacAddressPair));
+ LOG.trace("Reading vniMacAddressToPortCache with vni {} , mac {} , pair {} and port {}",
+ vni, macAddress.toUpperCase(), vniMacAddressPair, vniMacAddressToPortCache.get(vniMacAddressPair));
return vniMacAddressToPortCache.get(vniMacAddressPair);
}
RpcResult<GetExternalTunnelInterfaceNameOutput> rpcResult = output.get();
if (rpcResult.isSuccessful()) {
tunnelInterfaceName = rpcResult.getResult().getInterfaceName();
- logger.debug("Tunnel interface name: {}", tunnelInterfaceName);
+ LOG.trace("Tunnel interface name: {}", tunnelInterfaceName);
} else {
- logger.warn("RPC call to ITM.GetExternalTunnelInterfaceName failed with error: {}",
- rpcResult.getErrors());
+ LOG.warn("RPC call to ITM.GetExternalTunnelInterfaceName failed with error: {}", rpcResult.getErrors());
}
} catch (NullPointerException | InterruptedException | ExecutionException e) {
- logger.error("Failed to get external tunnel interface name for sourceNode: {} and dstNode: {}: {} ",
+ LOG.error("Failed to get external tunnel interface name for sourceNode: {} and dstNode: {}: {} ",
sourceNode, dstNode, e);
}
return tunnelInterfaceName;
public static Optional<Node> getNode(DataBroker dataBroker, String physicalSwitchNodeId) {
InstanceIdentifier<Node> psNodeId = HwvtepSouthboundUtils
.createInstanceIdentifier(new NodeId(physicalSwitchNodeId));
- Optional<Node> physicalSwitchOptional = MDSALUtil.read(LogicalDatastoreType.CONFIGURATION, psNodeId, dataBroker);
- return physicalSwitchOptional;
+ return MDSALUtil.read(LogicalDatastoreType.CONFIGURATION, psNodeId, dataBroker);
}
public RemoteMcastMacs createRemoteMcastMac(Node dstDevice, String logicalSwitchName, IpAddress internalTunnelIp) {
return remoteUcastMacs;
}
- private WriteTransaction putRemoteMcastMac(WriteTransaction transaction, String elanName, L2GatewayDevice device, IpAddress internalTunnelIp) {
+ private WriteTransaction putRemoteMcastMac(WriteTransaction transaction, String elanName,
+ L2GatewayDevice device, IpAddress internalTunnelIp) {
Optional<Node> optionalNode = getNode(broker, device.getHwvtepNodeId());
Node dstNode = optionalNode.get();
if (dstNode == null) {
- logger.debug("could not get device node {} ", device.getHwvtepNodeId());
+ LOG.trace("could not get device node {} ", device.getHwvtepNodeId());
return null;
}
RemoteMcastMacs macs = createRemoteMcastMac(dstNode, elanName, internalTunnelIp);
return transaction;
}
- public void installRemoteMcastMac(final BigInteger designatedDpnId, final IpAddress tunnelIp, final String elanInstanceName) {
- if (designatedDpnId.equals(DHCPMConstants.INVALID_DPID)) {
+ public void installRemoteMcastMac(final BigInteger designatedDpnId, final IpAddress tunnelIp,
+ final String elanInstanceName) {
+ if (designatedDpnId.equals(DhcpMConstants.INVALID_DPID)) {
return;
}
- ListenableFuture<Boolean> checkEntityOwnerFuture = ClusteringUtils.checkNodeEntityOwner(entityOwnershipService, HwvtepSouthboundConstants.ELAN_ENTITY_TYPE, HwvtepSouthboundConstants.ELAN_ENTITY_NAME);
+ ListenableFuture<Boolean> checkEntityOwnerFuture = ClusteringUtils.checkNodeEntityOwner(entityOwnershipService,
+ HwvtepSouthboundConstants.ELAN_ENTITY_TYPE, HwvtepSouthboundConstants.ELAN_ENTITY_NAME);
Futures.addCallback(checkEntityOwnerFuture, new FutureCallback<Boolean>() {
@Override
public void onSuccess(Boolean isOwner) {
if (isOwner) {
- logger.info("Installing remote McastMac");
+ LOG.info("Installing remote McastMac");
L2GatewayDevice device = getDeviceFromTunnelIp(elanInstanceName, tunnelIp);
- String tunnelInterfaceName = getExternalTunnelInterfaceName(String.valueOf(designatedDpnId), device.getHwvtepNodeId());
+ String tunnelInterfaceName = getExternalTunnelInterfaceName(String.valueOf(designatedDpnId),
+ device.getHwvtepNodeId());
IpAddress internalTunnelIp = null;
if (tunnelInterfaceName != null) {
- Interface tunnelInterface = DhcpServiceUtils.getInterfaceFromConfigDS(tunnelInterfaceName, broker);
+ Interface tunnelInterface =
+ interfaceManager.getInterfaceInfoFromConfigDataStore(tunnelInterfaceName);
if (tunnelInterface == null) {
- logger.trace("Tunnel Interface is not present {}", tunnelInterfaceName);
+ LOG.trace("Tunnel Interface is not present {}", tunnelInterfaceName);
return;
}
internalTunnelIp = tunnelInterface.getAugmentation(IfTunnel.class).getTunnelSource();
}
}
} else {
- logger.info("Installing remote McastMac is not executed for this node.");
+ LOG.info("Installing remote McastMac is not executed for this node.");
}
}
@Override
public void onFailure(Throwable error) {
- logger.error("Failed to install remote McastMac", error);
+ LOG.error("Failed to install remote McastMac", error);
}
});
}
private L2GatewayDevice getDeviceFromTunnelIp(String elanInstanceName, IpAddress tunnelIp) {
ConcurrentMap<String, L2GatewayDevice> devices = L2GatewayCacheUtils.getCache();
- logger.trace("In getDeviceFromTunnelIp devices {}", devices);
+ LOG.trace("In getDeviceFromTunnelIp devices {}", devices);
for (L2GatewayDevice device : devices.values()) {
if (tunnelIp.equals(device.getTunnelIp())) {
return device;
}
private boolean isTunnelUp(String nodeName, BigInteger dpn) {
- boolean isTunnelUp = false;
String tunnelInterfaceName = getExternalTunnelInterfaceName(String.valueOf(dpn), nodeName);
if (tunnelInterfaceName == null) {
- logger.debug("Tunnel Interface is not present {}", tunnelInterfaceName);
- return isTunnelUp;
+ LOG.trace("Tunnel Interface is not present on node {} with dpn {}", nodeName, dpn);
+ return false;
}
- org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface tunnelInterface = DhcpServiceUtils.getInterfaceFromOperationalDS(tunnelInterfaceName, broker);
+ org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state
+ .Interface tunnelInterface =
+ DhcpServiceUtils.getInterfaceFromOperationalDS(tunnelInterfaceName, broker);
if (tunnelInterface == null) {
- logger.debug("Interface {} is not present in interface state", tunnelInterfaceName);
- return isTunnelUp;
+ LOG.trace("Interface {} is not present in interface state", tunnelInterfaceName);
+ return false;
}
- isTunnelUp = (tunnelInterface.getOperStatus() == OperStatus.Up);
- return isTunnelUp;
+ return tunnelInterface.getOperStatus() == OperStatus.Up;
}
- public void handleTunnelStateUp(IpAddress tunnelIp, BigInteger interfaceDpn) {
- logger.trace("In handleTunnelStateUp tunnelIp {}, interfaceDpn {}", tunnelIp, interfaceDpn);
- try {
- synchronized (getTunnelIpDpnKey(tunnelIp, interfaceDpn)) {
- Set<Pair<IpAddress, String>> tunnelIpElanPair = designatedDpnsToTunnelIpElanNameCache.get(DHCPMConstants.INVALID_DPID);
- List<BigInteger> dpns = DhcpServiceUtils.getListOfDpns(broker);
- if (tunnelIpElanPair == null || tunnelIpElanPair.isEmpty()) {
- logger.trace("There are no undesignated DPNs");
- return;
- }
- for (Pair<IpAddress, String> pair : tunnelIpElanPair) {
- if (tunnelIp.equals(pair.getLeft())) {
- BigInteger newDesignatedDpn = designateDpnId(tunnelIp, pair.getRight(), dpns);
- if (newDesignatedDpn != null && !newDesignatedDpn.equals(DHCPMConstants.INVALID_DPID)) {
- Set<String> vmMacAddress = tunnelIpElanNameToVmMacCache.get(pair);
- if (vmMacAddress != null && !vmMacAddress.isEmpty()) {
- logger.trace("Updating DHCP flow for macAddress {} with newDpn {}", vmMacAddress, newDesignatedDpn);
- installDhcpFlowsForVms(newDesignatedDpn, vmMacAddress);
- }
+ public void handleTunnelStateUp(IpAddress tunnelIp, BigInteger interfaceDpn, List<ListenableFuture<Void>> futures) {
+ LOG.trace("In handleTunnelStateUp tunnelIp {}, interfaceDpn {}", tunnelIp, interfaceDpn);
+ synchronized (getTunnelIpDpnKey(tunnelIp, interfaceDpn)) {
+ Set<Pair<IpAddress, String>> tunnelIpElanPair =
+ designatedDpnsToTunnelIpElanNameCache.get(DhcpMConstants.INVALID_DPID);
+ List<BigInteger> dpns = DhcpServiceUtils.getListOfDpns(broker);
+ if (tunnelIpElanPair == null || tunnelIpElanPair.isEmpty()) {
+ LOG.trace("There are no undesignated DPNs");
+ return;
+ }
+ WriteTransaction tx = broker.newWriteOnlyTransaction();
+ for (Pair<IpAddress, String> pair : tunnelIpElanPair) {
+ if (tunnelIp.equals(pair.getLeft())) {
+ BigInteger newDesignatedDpn = designateDpnId(tunnelIp, pair.getRight(), dpns);
+ if (newDesignatedDpn != null && !newDesignatedDpn.equals(DhcpMConstants.INVALID_DPID)) {
+ Set<String> vmMacAddress = tunnelIpElanNameToVmMacCache.get(pair);
+ if (vmMacAddress != null && !vmMacAddress.isEmpty()) {
+ LOG.trace("Updating DHCP flow for macAddress {} with newDpn {}",
+ vmMacAddress, newDesignatedDpn);
+ installDhcpFlowsForVms(newDesignatedDpn, vmMacAddress, tx);
}
}
}
}
- } catch (Exception e) {
- logger.error("Error in handleTunnelStateUp {}", e.getMessage());
- logger.trace("Exception details {}", e);
+ futures.add(tx.submit());
}
}
if (tunnelInterfaceName == null) {
return false;
}
- Interface tunnelInterface = DhcpServiceUtils.getInterfaceFromConfigDS(tunnelInterfaceName, broker);
+ Interface tunnelInterface = interfaceManager.getInterfaceInfoFromConfigDataStore(tunnelInterfaceName);
if (tunnelInterface == null) {
- logger.debug("Tunnel Interface is not present {}", tunnelInterfaceName);
+ LOG.trace("Tunnel Interface is not present {}", tunnelInterfaceName);
return false;
}
return true;
}
- public void unInstallDhcpFlowsForVms(String elanInstanceName, IpAddress tunnelIp, List<BigInteger> dpns) {
- Pair<IpAddress, String> tunnelIpElanNamePair = new ImmutablePair<>(tunnelIp, elanInstanceName);
- Set<String> vmMacs = tunnelIpElanNameToVmMacCache.get(tunnelIpElanNamePair);
- logger.trace("In unInstallFlowsForVms elanInstanceName {}, tunnelIp {}, dpns {}, vmMacs {}",
- elanInstanceName, tunnelIp, dpns, vmMacs);
- if (vmMacs == null) {
- return;
- }
- for (String vmMacAddress : vmMacs) {
- unInstallDhcpEntriesOnDpns(dpns, vmMacAddress);
- }
- tunnelIpElanNameToVmMacCache.remove(tunnelIpElanNamePair);
- }
-
public void removeFromAvailableCache(Pair<IpAddress, String> tunnelIpElanName) {
availableVMCache.remove(tunnelIpElanName);
}
- private void unInstallDhcpEntriesOnDpns(List<BigInteger> dpns, String vmMacAddress) {
- for (BigInteger dpn : dpns) {
- unInstallDhcpEntries(dpn, vmMacAddress, entityOwnershipService);
- }
+ private void unInstallDhcpEntriesOnDpns(final List<BigInteger> dpns, final String vmMacAddress) {
+ // TODO: Make use a util that directly tells if this is the owner or not rather than making use of callbacks.
+ ListenableFuture<Boolean> checkEntityOwnerFuture = ClusteringUtils.checkNodeEntityOwner(
+ entityOwnershipService, HwvtepSouthboundConstants.ELAN_ENTITY_TYPE,
+ HwvtepSouthboundConstants.ELAN_ENTITY_NAME);
+ Futures.addCallback(checkEntityOwnerFuture, new FutureCallback<Boolean>() {
+ @Override
+ public void onSuccess(Boolean isOwner) {
+ if (isOwner) {
+ WriteTransaction tx = broker.newWriteOnlyTransaction();
+ for (final BigInteger dpn : dpns) {
+ unInstallDhcpEntries(dpn, vmMacAddress, tx);
+ }
+ DhcpServiceUtils.submitTransaction(tx);
+ } else {
+ LOG.trace("Exiting unInstallDhcpEntries since this cluster node is not the owner for dpn");
+ }
+ }
+
+ @Override
+ public void onFailure(Throwable error) {
+ LOG.error("Error while fetching checkNodeEntityOwner", error);
+ }
+ });
}
public IpAddress getTunnelIpBasedOnElan(String elanInstanceName, String vmMacAddress) {
- if (logger.isTraceEnabled()) {
- logger.trace("DhcpExternalTunnelManager getTunnelIpBasedOnElan elanInstanceName " + elanInstanceName);
- }
+ LOG.trace("DhcpExternalTunnelManager getTunnelIpBasedOnElan elanInstanceName {}", elanInstanceName);
IpAddress tunnelIp = null;
Set<Pair<IpAddress, String>> tunnelElanKeySet = availableVMCache.keySet();
Set<String> listExistingVmMacAddress;
for (Pair<IpAddress, String> pair : tunnelElanKeySet) {
- if (logger.isTraceEnabled()) {
- logger.trace("DhcpExternalTunnelManager getTunnelIpBasedOnElan left " + pair.getLeft() + " right:" +
- pair.getRight());
- }
+ LOG.trace("DhcpExternalTunnelManager getTunnelIpBasedOnElan left {} right {}", pair.getLeft(),
+ pair.getRight());
if (pair.getRight().trim().equalsIgnoreCase(elanInstanceName.trim())) {
listExistingVmMacAddress = availableVMCache.get(pair);
- if (listExistingVmMacAddress != null && !listExistingVmMacAddress.isEmpty() &&
- listExistingVmMacAddress.contains(vmMacAddress)) {
+ if (listExistingVmMacAddress != null && !listExistingVmMacAddress.isEmpty()
+ && listExistingVmMacAddress.contains(vmMacAddress)) {
tunnelIp = pair.getLeft();
break;
}
}
}
- if (logger.isTraceEnabled()) {
- logger.trace("DhcpExternalTunnelManager getTunnelIpBasedOnElan returned tunnelIP " + tunnelIp);
- }
+ LOG.trace("DhcpExternalTunnelManager getTunnelIpBasedOnElan returned tunnelIP {}", tunnelIp);
return tunnelIp;
}
}
Code Review / netvirt.git / blobdiff