package org.opendaylight.genius.interfacemanager.listeners;
import com.google.common.util.concurrent.ListenableFuture;
-
import java.util.List;
import java.util.concurrent.Callable;
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.opendaylight.genius.datastoreutils.hwvtep.HwvtepAbstractDataTreeChangeListener;
import org.opendaylight.genius.interfacemanager.renderer.hwvtep.statehelpers.HwVTEPInterfaceStateUpdateHelper;
import org.opendaylight.genius.srm.RecoverableListener;
import org.opendaylight.genius.srm.ServiceRecoveryRegistry;
+import org.opendaylight.genius.utils.hwvtep.HwvtepNodeHACache;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.PhysicalSwitchAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical._switch.attributes.Tunnels;
@Inject
public HwVTEPTunnelsStateListener(final DataBroker dataBroker, final JobCoordinator coordinator,
final InterfaceServiceRecoveryHandler interfaceServiceRecoveryHandler,
- final ServiceRecoveryRegistry serviceRecoveryRegistry) {
- super(Tunnels.class, HwVTEPTunnelsStateListener.class);
+ final ServiceRecoveryRegistry serviceRecoveryRegistry,
+ final HwvtepNodeHACache hwvtepNodeHACache) {
+ super(Tunnels.class, HwVTEPTunnelsStateListener.class, hwvtepNodeHACache);
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.coordinator = coordinator;
this.dataBroker = dataBroker;
<reference id="serviceRecoveryRegistry"
interface="org.opendaylight.genius.srm.ServiceRecoveryRegistry"/>
+ <reference id="hwvtepNodeHACache"
+ interface="org.opendaylight.genius.utils.hwvtep.HwvtepNodeHACache"/>
+
<odl:rpc-implementation ref="interfaceManagerRpcService" />
<odl:clustered-app-config id="ifmConfig"
import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
import org.opendaylight.genius.utils.hwvtep.HwvtepHACache;
+import org.opendaylight.genius.utils.hwvtep.HwvtepNodeHACache;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
public abstract class HwvtepAbstractDataTreeChangeListener<T extends DataObject,K extends DataTreeChangeListener<T>>
extends AsyncDataTreeChangeListenerBase<T,K> {
+ private final HwvtepNodeHACache hwvtepNodeHACache;
+
+ @Deprecated
public HwvtepAbstractDataTreeChangeListener(Class<T> clazz, Class<K> eventClazz) {
- super(clazz,eventClazz);
+ this(clazz, eventClazz, HwvtepHACache.getInstance());
+ }
+
+ public HwvtepAbstractDataTreeChangeListener(Class<T> clazz, Class<K> eventClazz,
+ HwvtepNodeHACache hwvtepNodeHACache) {
+ super(clazz, eventClazz);
+ this.hwvtepNodeHACache = hwvtepNodeHACache;
}
@Override
protected void remove(InstanceIdentifier<T> identifier, T del) {
- if (HwvtepHACache.getInstance().isHAEnabledDevice(identifier)) {
+ if (hwvtepNodeHACache.isHAEnabledDevice(identifier)) {
return;
}
removed(identifier, del);
@Override
protected void update(InstanceIdentifier<T> identifier, T original, T update) {
- if (HwvtepHACache.getInstance().isHAEnabledDevice(identifier)) {
+ if (hwvtepNodeHACache.isHAEnabledDevice(identifier)) {
return;
}
updated(identifier,original,update);
@Override
protected void add(InstanceIdentifier<T> identifier, T add) {
- if (HwvtepHACache.getInstance().isHAEnabledDevice(identifier)) {
+ if (hwvtepNodeHACache.isHAEnabledDevice(identifier)) {
return;
}
added(identifier,add);
import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
import org.opendaylight.genius.utils.hwvtep.HwvtepHACache;
+import org.opendaylight.genius.utils.hwvtep.HwvtepNodeHACache;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
T extends DataObject, K extends ClusteredDataTreeChangeListener<T>>
extends AsyncClusteredDataTreeChangeListenerBase<T, K> {
+ private final HwvtepNodeHACache hwvtepNodeHACache;
+
+ @Deprecated
public HwvtepClusteredDataTreeChangeListener(Class<T> clazz, Class<K> eventClazz) {
+ this(clazz, eventClazz, HwvtepHACache.getInstance());
+ }
+
+ public HwvtepClusteredDataTreeChangeListener(Class<T> clazz, Class<K> eventClazz,
+ HwvtepNodeHACache hwvtepNodeHACache) {
super(clazz, eventClazz);
+ this.hwvtepNodeHACache = hwvtepNodeHACache;
}
@Override
protected void remove(InstanceIdentifier<T> identifier, T del) {
- if (HwvtepHACache.getInstance().isHAEnabledDevice(identifier)) {
+ if (hwvtepNodeHACache.isHAEnabledDevice(identifier)) {
return;
}
removed(identifier,del);
@Override
protected void update(InstanceIdentifier<T> identifier, T original, T update) {
- if (HwvtepHACache.getInstance().isHAEnabledDevice(identifier)) {
+ if (hwvtepNodeHACache.isHAEnabledDevice(identifier)) {
return;
}
updated(identifier,original, update);
@Override
protected void add(InstanceIdentifier<T> identifier, T add) {
- if (HwvtepHACache.getInstance().isHAEnabledDevice(identifier)) {
+ if (hwvtepNodeHACache.isHAEnabledDevice(identifier)) {
return;
}
added(identifier, add);
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.InstanceIdentifier;
-public class HwvtepHACache {
+@Deprecated
+public class HwvtepHACache implements HwvtepNodeHACache {
private static final int MAX_EVENT_BUFFER_SIZE = 500000;
private static final int EVENT_DRAIN_BUFFER_SIZE = 100000;
return instance;
}
+ @Override
public synchronized void addChild(InstanceIdentifier<Node> parent, InstanceIdentifier<Node> child) {
if (parent == null || child == null) {
return;
addDebugEvent(new NodeEvent.ChildAddedEvent(childNodeId));
}
+ @Override
public boolean isHAEnabledDevice(InstanceIdentifier<?> iid) {
if (iid == null) {
return false;
return enabled;
}
+ @Override
public boolean isHAParentNode(InstanceIdentifier<Node> node) {
return parentToChildMap.containsKey(node);
}
+ @Override
public Set<InstanceIdentifier<Node>> getChildrenForHANode(InstanceIdentifier<Node> parent) {
if (parent != null && parentToChildMap.containsKey(parent)) {
return new HashSet<>(parentToChildMap.get(parent));
}
}
+ @Override
public Set<InstanceIdentifier<Node>> getHAParentNodes() {
return parentToChildMap.keySet();
}
+ @Override
public Set<InstanceIdentifier<Node>> getHAChildNodes() {
return childToParentMap.keySet();
}
+ @Override
public InstanceIdentifier<Node> getParent(InstanceIdentifier<Node> child) {
if (child != null) {
return childToParentMap.get(child);
return null;
}
+ @Override
+ public void removeParent(InstanceIdentifier<Node> parent) {
+ cleanupParent(parent);
+ }
+
public synchronized void cleanupParent(InstanceIdentifier<Node> parent) {
if (parent == null) {
return;
parentToChildMap.remove(parent);
}
+ @Override
public void updateConnectedNodeStatus(InstanceIdentifier<Node> iid) {
String nodeId = iid.firstKeyOf(Node.class).getNodeId().getValue();
connectedNodes.put(nodeId, true);
addDebugEvent(event);
}
+ @Override
public void updateDisconnectedNodeStatus(InstanceIdentifier<Node> iid) {
String nodeId = iid.firstKeyOf(Node.class).getNodeId().getValue();
connectedNodes.put(nodeId, false);
public List<DebugEvent> getNodeEvents() {
return ImmutableList.copyOf(debugEvents);
}
+
+ @Override
+ public Map<String, Boolean> getNodeConnectionStatuses() {
+ return getConnectedNodes();
+ }
}
--- /dev/null
+/*
+ * Copyright (c) 2017 Inocybe Technologies and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.genius.utils.hwvtep;
+
+import java.util.Map;
+import java.util.Set;
+import javax.annotation.Nonnull;
+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.InstanceIdentifier;
+
+/**
+ * Caches hwvtep Node HA info.
+ *
+ * @author Thomas Pantelis
+ */
+public interface HwvtepNodeHACache {
+ void addChild(InstanceIdentifier<Node> parentId, InstanceIdentifier<Node> childId);
+
+ boolean isHAEnabledDevice(InstanceIdentifier<?> nodeId);
+
+ boolean isHAParentNode(InstanceIdentifier<Node> nodeId);
+
+ // Commented out for now - causes findbugs violation in netvirt
+ //@Nonnull
+ Set<InstanceIdentifier<Node>> getChildrenForHANode(InstanceIdentifier<Node> parentId);
+
+ @Nonnull
+ Set<InstanceIdentifier<Node>> getHAParentNodes();
+
+ @Nonnull
+ Set<InstanceIdentifier<Node>> getHAChildNodes();
+
+ InstanceIdentifier<Node> getParent(InstanceIdentifier<Node> childId);
+
+ void removeParent(InstanceIdentifier<Node> parentId);
+
+ void updateConnectedNodeStatus(InstanceIdentifier<Node> nodeId);
+
+ void updateDisconnectedNodeStatus(InstanceIdentifier<Node> nodeId);
+
+ @Nonnull
+ Map<String, Boolean> getNodeConnectionStatuses();
+}
<groupId>org.apache.aries.blueprint</groupId>
<artifactId>blueprint-maven-plugin</artifactId>
</plugin>
+ <plugin>
+ <groupId>org.apache.felix</groupId>
+ <artifactId>maven-bundle-plugin</artifactId>
+ <extensions>true</extensions>
+ <configuration>
+ <instructions>
+ <Import-Package>
+ *;
+ org.opendaylight.genius.utils.hwvtep
+ </Import-Package>
+ </instructions>
+ </configuration>
+ </plugin>
</plugins>
</build>
</project>
update-strategy="none">
</odl:clustered-app-config>
+ <bean id="hwvtepHACache" class="org.opendaylight.genius.utils.hwvtep.HwvtepHACache"
+ factory-method="getInstance"/>
+
+ <service ref="hwvtepHACache"
+ interface="org.opendaylight.genius.utils.hwvtep.HwvtepNodeHACache"/>
+
</blueprint>