*/
package org.opendaylight.netvirt.elan.l2gw.listeners;
+import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
+import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
+
import com.google.common.collect.Sets;
-import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
-import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.function.Predicate;
-import javax.annotation.Nullable;
import javax.annotation.PostConstruct;
import javax.inject.Inject;
import javax.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.utils.batching.ResourceBatchingManager;
-import org.opendaylight.genius.utils.hwvtep.HwvtepHACache;
+import org.opendaylight.genius.utils.hwvtep.HwvtepNodeHACache;
import org.opendaylight.genius.utils.hwvtep.HwvtepSouthboundUtils;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
-import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
+import org.opendaylight.infrautils.utils.concurrent.LoggingFutures;
+import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.elan.cache.ElanInstanceCache;
import org.opendaylight.netvirt.elan.l2gw.ha.HwvtepHAUtil;
import org.opendaylight.netvirt.elan.l2gw.ha.listeners.HAOpClusteredListener;
+import org.opendaylight.netvirt.elan.l2gw.recovery.impl.L2GatewayServiceRecoveryHandler;
import org.opendaylight.netvirt.elan.l2gw.utils.ElanL2GatewayUtils;
import org.opendaylight.netvirt.elanmanager.utils.ElanL2GwCacheUtils;
import org.opendaylight.netvirt.neutronvpn.api.l2gw.L2GatewayDevice;
+import org.opendaylight.serviceutils.srm.RecoverableListener;
+import org.opendaylight.serviceutils.srm.ServiceRecoveryRegistry;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.IetfYangUtil;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstance;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepGlobalAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LocalUcastMacs;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LogicalSwitches;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
-import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Singleton
public class LocalUcastMacListener extends ChildListener<Node, LocalUcastMacs, String>
- implements ClusteredDataTreeChangeListener<Node> {
+ implements ClusteredDataTreeChangeListener<Node>, RecoverableListener {
private static final Logger LOG = LoggerFactory.getLogger(LocalUcastMacListener.class);
public static final String NODE_CHECK = "physical";
private static final Predicate<InstanceIdentifier<Node>> IS_PS_NODE_IID =
(iid) -> iid.firstKeyOf(Node.class).getNodeId().getValue().contains(NODE_CHECK);
- private static final Predicate<InstanceIdentifier<Node>> IS_NOT_HA_CHILD =
- (iid) -> !HwvtepHACache.getInstance().isHAEnabledDevice(iid)
- && !iid.firstKeyOf(Node.class).getNodeId().getValue().contains(HwvtepHAUtil.PHYSICALSWITCH);
-
- private static final Predicate<InstanceIdentifier<Node>> IS_HA_CHILD =
- (iid) -> HwvtepHACache.getInstance().isHAEnabledDevice(iid);
-
private final ManagedNewTransactionRunner txRunner;
private final ElanL2GatewayUtils elanL2GatewayUtils;
private final HAOpClusteredListener haOpClusteredListener;
private final JobCoordinator jobCoordinator;
private final ElanInstanceCache elanInstanceCache;
+ private final HwvtepNodeHACache hwvtepNodeHACache;
@Inject
public LocalUcastMacListener(final DataBroker dataBroker,
final HAOpClusteredListener haOpClusteredListener,
final ElanL2GatewayUtils elanL2GatewayUtils,
final JobCoordinator jobCoordinator,
- final ElanInstanceCache elanInstanceCache) {
+ final ElanInstanceCache elanInstanceCache,
+ final HwvtepNodeHACache hwvtepNodeHACache,
+ final L2GatewayServiceRecoveryHandler l2GatewayServiceRecoveryHandler,
+ final ServiceRecoveryRegistry serviceRecoveryRegistry) {
super(dataBroker, false);
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.elanL2GatewayUtils = elanL2GatewayUtils;
this.haOpClusteredListener = haOpClusteredListener;
this.jobCoordinator = jobCoordinator;
this.elanInstanceCache = elanInstanceCache;
+ this.hwvtepNodeHACache = hwvtepNodeHACache;
+ serviceRecoveryRegistry.addRecoverableListener(l2GatewayServiceRecoveryHandler.buildServiceRegistryKey(), this);
}
@Override
public void init() throws Exception {
ResourceBatchingManager.getInstance().registerDefaultBatchHandlers(this.dataBroker);
super.init();
+ registerListener();
+ }
+
+ @Override
+ @SuppressWarnings("all")
+ public void registerListener() {
+ try {
+ LOG.info("Registering LocalUcastMacListener");
+ registerListener(LogicalDatastoreType.OPERATIONAL, getParentWildCardPath());
+ } catch (Exception e) {
+ LOG.error("Local Ucast Mac register listener error");
+ }
+ }
+
+ public void deregisterListener() {
+ LOG.info("Deregistering LocalUcastMacListener");
+ super.close();
}
@Override
protected boolean proceed(final InstanceIdentifier<Node> parent) {
- return IS_NOT_HA_CHILD.test(parent);
+ return isNotHAChild(parent);
}
protected String getElanName(final LocalUcastMacs mac) {
public void removed(final InstanceIdentifier<LocalUcastMacs> identifier, final LocalUcastMacs macRemoved) {
String hwvtepNodeId = identifier.firstKeyOf(Node.class).getNodeId().getValue();
- String macAddress = macRemoved.getMacEntryKey().getValue().toLowerCase(Locale.getDefault());
+ MacAddress macAddress = IetfYangUtil.INSTANCE.canonizeMacAddress(macRemoved.getMacEntryKey());
- LOG.trace("LocalUcastMacs {} removed from {}", macAddress, hwvtepNodeId);
+ LOG.trace("LocalUcastMacs {} removed from {}", macAddress.getValue(), hwvtepNodeId);
ResourceBatchingManager.getInstance().delete(ResourceBatchingManager.ShardResource.CONFIG_TOPOLOGY,
identifier);
}
elanL2GwDevice.removeUcastLocalMac(macRemoved);
- ElanInstance elanInstance = elanInstanceCache.get(elanName).orNull();
+ ElanInstance elanInstance = elanInstanceCache.get(elanName).orElse(null);
elanL2GatewayUtils.unInstallL2GwUcastMacFromL2gwDevices(elanName, elanL2GwDevice,
- Collections.singletonList(new MacAddress(macAddress.toLowerCase(Locale.getDefault()))));
+ Collections.singletonList(macAddress));
elanL2GatewayUtils.unInstallL2GwUcastMacFromElanDpns(elanInstance, elanL2GwDevice,
- Collections.singletonList(new MacAddress(macAddress.toLowerCase(Locale.getDefault()))));
+ Collections.singletonList(macAddress));
return null;
});
}
identifier, macAdded);
String hwvtepNodeId = identifier.firstKeyOf(Node.class).getNodeId().getValue();
- String macAddress = macAdded.getMacEntryKey().getValue().toLowerCase(Locale.getDefault());
+ String macAddress = IetfYangUtil.INSTANCE.canonizeMacAddress(macAdded.getMacEntryKey()).getValue();
String elanName = getElanName(macAdded);
LOG.trace("LocalUcastMacs {} added to {}", macAddress, hwvtepNodeId);
- ElanInstance elan = elanInstanceCache.get(elanName).orNull();
+ ElanInstance elan = elanInstanceCache.get(elanName).orElse(null);
if (elan == null) {
LOG.warn("Could not find ELAN for mac {} being added", macAddress);
return;
}
elanL2GwDevice.addUcastLocalMac(macAdded);
- elanL2GatewayUtils.installL2GwUcastMacInElan(elan, elanL2GwDevice,
- macAddress.toLowerCase(), macAdded, null);
+ elanL2GatewayUtils.installL2GwUcastMacInElan(elan, elanL2GwDevice, macAddress, macAdded, null);
return null;
});
}
DataObjectModification<HwvtepGlobalAugmentation> aug = mod.getModifiedAugmentation(
HwvtepGlobalAugmentation.class);
if (aug != null && getModificationType(aug) != null) {
- Collection<DataObjectModification<? extends DataObject>> children = aug.getModifiedChildren();
- children.stream()
+ aug.getModifiedChildren().stream()
.filter(childMod -> getModificationType(childMod) != null)
.filter(childMod -> childMod.getDataType() == LocalUcastMacs.class)
.forEach(childMod -> {
LocalUcastMacs mac = afterMac != null ? afterMac : (LocalUcastMacs)childMod.getDataBefore();
InstanceIdentifier<LocalUcastMacs> iid = parentIid
.augmentation(HwvtepGlobalAugmentation.class)
- .child(LocalUcastMacs.class, mac.getKey());
+ .child(LocalUcastMacs.class, mac.key());
result.put(iid, (DataObjectModification<LocalUcastMacs>) childMod);
});
}
if (IS_PS_NODE_IID.test(nodeIid)) {
return;
}
- ListenableFutures.addErrorLogging(txRunner.callWithNewReadWriteTransactionAndSubmit(tx -> {
- haOpClusteredListener.onGlobalNodeAdd(nodeIid, modification.getRootNode().getDataAfter(), tx);
- if (!IS_HA_CHILD.test(nodeIid)) {
+ // TODO skitt we're only using read transactions here
+ LoggingFutures.addErrorLogging(txRunner.callWithNewReadWriteTransactionAndSubmit(OPERATIONAL,
+ tx -> haOpClusteredListener.onGlobalNodeAdd(nodeIid, modification.getRootNode().getDataAfter(), tx)), LOG,
+ "Error processing added parent");
+ if (!isHAChild(nodeIid)) {
+ LoggingFutures.addErrorLogging(txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION, tx -> {
LOG.trace("On parent add {}", nodeIid);
Node operNode = modification.getRootNode().getDataAfter();
- Set<LocalUcastMacs> configMacs =
- getMacs(tx.read(LogicalDatastoreType.CONFIGURATION, nodeIid).checkedGet().orNull());
+ Set<LocalUcastMacs> configMacs = getMacs(tx.read(nodeIid).get().orElse(null));
Set<LocalUcastMacs> operMacs = getMacs(operNode);
Set<LocalUcastMacs> staleMacs = Sets.difference(configMacs, operMacs);
staleMacs.forEach(staleMac -> removed(getMacIid(nodeIid, staleMac), staleMac));
- }
- }), LOG, "Error processing added parent");
+ }), LOG, "Error processing added parent");
+ }
}
InstanceIdentifier<LocalUcastMacs> getMacIid(InstanceIdentifier<Node> nodeIid, LocalUcastMacs mac) {
return nodeIid.augmentation(HwvtepGlobalAugmentation.class)
- .child(LocalUcastMacs.class, mac.getKey());
+ .child(LocalUcastMacs.class, mac.key());
}
- private Set<LocalUcastMacs> getMacs(@Nullable Node node) {
+ private static Set<LocalUcastMacs> getMacs(@Nullable Node node) {
if (node != null) {
- HwvtepGlobalAugmentation augmentation = node.getAugmentation(HwvtepGlobalAugmentation.class);
+ HwvtepGlobalAugmentation augmentation = node.augmentation(HwvtepGlobalAugmentation.class);
if (augmentation != null && augmentation.getLocalUcastMacs() != null) {
return new HashSet<>(augmentation.getLocalUcastMacs());
}
return HwvtepSouthboundUtils.createHwvtepTopologyInstanceIdentifier()
.child(Node.class);
}
+
+ private boolean isNotHAChild(InstanceIdentifier<Node> nodeId) {
+ return !hwvtepNodeHACache.isHAEnabledDevice(nodeId)
+ && !nodeId.firstKeyOf(Node.class).getNodeId().getValue().contains(HwvtepHAUtil.PHYSICALSWITCH);
+ }
+
+ private boolean isHAChild(InstanceIdentifier<Node> nodeId) {
+ return hwvtepNodeHACache.isHAEnabledDevice(nodeId);
+ }
}
Code Review / netvirt.git / blobdiff