import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.manager.NodeManager;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import static org.opendaylight.sfc.provider.SfcProviderDebug.printTraceStart;
-public class IosXeCapableNodeListenerImpl implements DataTreeChangeListener<NetworkTopology>, AutoCloseable {
+public class IosXeCapableNodeListenerImpl implements DataTreeChangeListener<Node>, AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(IosXeCapableNodeListenerImpl.class);
private final NodeManager nodeManager;
public IosXeCapableNodeListenerImpl(final DataBroker dataBroker, final NodeManager nodeManager) {
this.nodeManager = Preconditions.checkNotNull(nodeManager);
- final DataTreeIdentifier<NetworkTopology> networkTopologyPath = new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL,
- InstanceIdentifier.builder(NetworkTopology.class).build());
+ final DataTreeIdentifier<Node> networkTopologyPath = new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL,
+ InstanceIdentifier.builder(NetworkTopology.class).child(Topology.class).child(Node.class).build());
listenerRegistration = Preconditions.checkNotNull(dataBroker
.registerDataTreeChangeListener(networkTopologyPath, this));
LOG.info("network-topology listener registered");
}
@Override
- public void onDataTreeChanged(@Nonnull Collection<DataTreeModification<NetworkTopology>> changes) {
+ public void onDataTreeChanged(@Nonnull Collection<DataTreeModification<Node>> changes) {
printTraceStart(LOG);
- for (DataTreeModification<NetworkTopology> modification : changes) {
- DataObjectModification<NetworkTopology> rootNode = modification.getRootNode();
- NetworkTopology dataAfter = rootNode.getDataAfter();
- NetworkTopology dataBefore = rootNode.getDataBefore();
- if (dataAfter != null && dataBefore == null) {
- nodeManager.syncNodes(dataAfter.getTopology(), null);
- }
- else if (dataAfter == null && dataBefore != null) {
- nodeManager.syncNodes(null, dataBefore.getTopology());
- }
- else if (dataAfter != null) {
- nodeManager.syncNodes(dataAfter.getTopology(), dataBefore.getTopology());
- }
+ for (DataTreeModification<Node> modification : changes) {
+ DataObjectModification<Node> rootNode = modification.getRootNode();
+ Node dataAfter = rootNode.getDataAfter();
+ Node dataBefore = rootNode.getDataBefore();
+ nodeManager.syncNodes(dataAfter, dataBefore);
}
}
import org.opendaylight.controller.md.sal.binding.api.MountPointService;
import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
import org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.util.NodeWriter;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.RendererName;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.nodes.RendererNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.nodes.RendererNodeBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.nodes.RendererNodeKey;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import static org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNodeConnectionStatus.ConnectionStatus.Connected;
+import static org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNodeConnectionStatus.ConnectionStatus.Connecting;
+import static org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNodeConnectionStatus.ConnectionStatus.UnableToConnect;
+
public class NodeManager {
+ public static final RendererName iosXeRenderer = new RendererName("ios-xe-renderer");
+ private static final TopologyId TOPOLOGY_ID = new TopologyId("topology-netconf");
private static final Logger LOG = LoggerFactory.getLogger(NodeManager.class);
- private static Map<InstanceIdentifier, DataBroker> netconfNodeCache = new HashMap<>();
+ private static final Map<InstanceIdentifier, DataBroker> netconfNodeCache = new HashMap<>();
private final DataBroker dataBroker;
- private MountPointService mountService;
+ private final MountPointService mountService;
+ private final List<String> requiredCapabilities;
public NodeManager(final DataBroker dataBroker, BindingAwareBroker.ProviderContext session) {
this.dataBroker = Preconditions.checkNotNull(dataBroker);
mountService = Preconditions.checkNotNull(session.getSALService(MountPointService.class));
+ requiredCapabilities = new RequiredCapabilities().initializeRequiredCapabilities();
}
- public static DataBroker getDataBrokerFromCache(InstanceIdentifier iid) {
+ static DataBroker getDataBrokerFromCache(InstanceIdentifier iid) {
return netconfNodeCache.get(iid); // TODO read from DS
}
- public void syncNodes(List<Topology> dataAfter, List<Topology> dataBefore) {
- if (dataAfter != null && !dataAfter.isEmpty()) {
- updateNodes(dataAfter);
+ public void syncNodes(Node dataAfter, Node dataBefore) {
+ // New node
+ if (dataBefore == null && dataAfter != null) {
+ createNode(dataAfter);
+ }
+ // Connected/disconnected node
+ if (dataBefore != null && dataAfter != null) {
+ updateNode(dataAfter);
+ }
+ // Removed node
+ if (dataBefore != null && dataAfter == null) {
+ removeNode(dataBefore);
}
}
- private void updateNodes(List<Topology> data) {
- // WRITE
- NodeWriter nodeWriter = new NodeWriter();
- for (Topology topology : data) {
- if (topology.getNode() == null || topology.getNode().isEmpty()) {
- continue;
+ private void createNode(Node node) {
+ LOG.info("Registering new node {}", node.getNodeId().getValue());
+ NetconfNode netconfNode = getNodeAugmentation(node);
+ if (netconfNode == null) {
+ return;
+ }
+ NetconfNodeConnectionStatus.ConnectionStatus connectionStatus = netconfNode.getConnectionStatus();
+ switch (connectionStatus) {
+ case Connecting: {
+ LOG.info("Connecting device {} ...", node.getNodeId().getValue());
+ break;
}
- topology.getNode().stream().filter(this::isNetconfDevice).forEach(node -> {
- DataBroker mountpoint = getNodeMountPoint(topology.getTopologyId(), node);
- if (mountpoint != null) {
- netconfNodeCache.put(getMountpointIid(topology.getTopologyId(), node), mountpoint);
- RendererNode rendererNode = remap(topology.getTopologyId(), node);
- nodeWriter.write(rendererNode);
- }
- });
+ case Connected: {
+ resolveConnectedNode(node, netconfNode);
+ LOG.info("Node {} is ready, added to available nodes for IOS-XE Renderer", node.getNodeId().getValue());
+ }
+ case UnableToConnect: {
+ LOG.info("Unable to connect device {}", node.getNodeId().getValue());
+ break;
+ }
+ }
+ }
+
+ private void updateNode(Node node) {
+ NetconfNode netconfNode = getNodeAugmentation(node);
+ if (netconfNode == null || netconfNode.getConnectionStatus() == null) {
+ return;
+ }
+ NetconfNodeConnectionStatus.ConnectionStatus afterNodeStatus = netconfNode.getConnectionStatus();
+ if (afterNodeStatus.equals(Connected)) {
+ resolveConnectedNode(node, netconfNode);
+ LOG.info("Node {} is ready, added to available nodes for IOS-XE Renderer", node.getNodeId().getValue());
+ }
+ if (afterNodeStatus.equals(Connecting)) {
+ resolveDisconnectedNode(node);
+ LOG.info("Node {} has been disconnected, removing from available nodes", node.getNodeId().getValue());
+ }
+ if (afterNodeStatus.equals(UnableToConnect)) {
+ resolveDisconnectedNode(node);
+ LOG.info("Unable to connect node {}, removing from available nodes", node.getNodeId().getValue());
+ }
+ }
+
+ private void removeNode(Node node) {
+ resolveDisconnectedNode(node);
+ LOG.info("Node {} has been removed", node.getNodeId().getValue());
+ }
+
+ private void resolveConnectedNode(Node node, NetconfNode netconfNode) {
+ InstanceIdentifier mountPointIid = getMountpointIid(node);
+ // Mountpoint iid == path in renderer-node
+ RendererNode rendererNode = remapNode(mountPointIid);
+ DataBroker mountpoint = getNodeMountPoint(mountPointIid);
+ NodeWriter nodeWriter = new NodeWriter();
+ nodeWriter.cache(rendererNode);
+ if (isCapableNetconfDevice(node, netconfNode)) {
+ return;
}
nodeWriter.commitToDatastore(dataBroker);
+ netconfNodeCache.put(mountPointIid, mountpoint);
}
- private DataBroker getNodeMountPoint(TopologyId topologyId, Node node) {
- NetconfNode netconfNode = node.getAugmentation(NetconfNode.class);
- if (netconfNode == null) {
- return null;
+ private void resolveDisconnectedNode(Node node) {
+ InstanceIdentifier mountPointIid = getMountpointIid(node);
+ RendererNode rendererNode = remapNode(mountPointIid);
+ NodeWriter nodeWriter = new NodeWriter();
+ nodeWriter.cache(rendererNode);
+ nodeWriter.removeFromDatastore(dataBroker);
+ netconfNodeCache.remove(mountPointIid);
+ }
+
+ private RendererNode remapNode(InstanceIdentifier path) {
+ RendererNodeBuilder rendererNodeBuilder = new RendererNodeBuilder();
+ rendererNodeBuilder.setKey(new RendererNodeKey(path))
+ .setNodePath(path);
+ return rendererNodeBuilder.build();
+ }
+
+ private InstanceIdentifier getMountpointIid(Node node) {
+ return InstanceIdentifier.builder(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(TOPOLOGY_ID))
+ .child(Node.class, new NodeKey(node.getNodeId())).build();
+ }
+
+ private boolean isCapableNetconfDevice(Node node, NetconfNode netconfAugmentation) {
+ if (netconfAugmentation.getAvailableCapabilities() == null ||
+ netconfAugmentation.getAvailableCapabilities().getAvailableCapability() == null ||
+ netconfAugmentation.getAvailableCapabilities().getAvailableCapability().isEmpty()) {
+ LOG.warn("Node {} does not contain any capabilities", node.getNodeId().getValue());
+ return true;
+ }
+ if (!capabilityCheck(netconfAugmentation.getAvailableCapabilities().getAvailableCapability())) {
+ LOG.warn("Node {} does not contain all capabilities required by io-xe-renderer",
+ node.getNodeId().getValue());
+ return true;
}
- InstanceIdentifier mountPointIid = getMountpointIid(topologyId, node);
+ return false;
+ }
+
+ private boolean capabilityCheck(final List<String> capabilities) {
+ for (String requiredCapability : requiredCapabilities) {
+ if (!capabilities.contains(requiredCapability)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ private DataBroker getNodeMountPoint(InstanceIdentifier mountPointIid) {
Optional<MountPoint> optionalObject = mountService.getMountPoint(mountPointIid);
MountPoint mountPoint;
if (optionalObject.isPresent()) {
return null;
}
- private InstanceIdentifier getMountpointIid(TopologyId topologyId, Node node) {
- return InstanceIdentifier.builder(NetworkTopology.class)
- .child(Topology.class, new TopologyKey(topologyId))
- .child(Node.class, new NodeKey(node.getNodeId())).build();
+ private NetconfNode getNodeAugmentation(Node node) {
+ NetconfNode netconfNode = node.getAugmentation(NetconfNode.class);
+ if (netconfNode == null) {
+ LOG.warn("Node {} is not a netconf device", node.getNodeId().getValue());
+ return null;
+ }
+ return netconfNode;
}
- private RendererNode remap(TopologyId topologyId, Node node) {
- InstanceIdentifier<Node> nodeIid = InstanceIdentifier.builder(NetworkTopology.class)
- .child(Topology.class, new TopologyKey(topologyId))
- .child(Node.class, new NodeKey(node.getNodeId())).build();
- RendererNodeBuilder rendererNodeBuilder = new RendererNodeBuilder();
- rendererNodeBuilder.setKey(new RendererNodeKey(nodeIid))
- .setNodePath(nodeIid);
- return rendererNodeBuilder.build();
- }
+ private class RequiredCapabilities {
- private boolean isNetconfDevice(Node node) {
- NetconfNode netconfAugmentation = node.getAugmentation(NetconfNode.class);
- if (netconfAugmentation == null) {
- LOG.debug("Node {} is not a netconf device", node.getNodeId().getValue());
- return false;
- }
- if (netconfAugmentation.getConnectionStatus().equals(NetconfNodeConnectionStatus.ConnectionStatus.Connected)) {
- LOG.info("Node {} ready", node.getNodeId().getValue());
- return true;
+ private static final String ned = "(urn:ios?revision=2016-03-08)ned";
+ private static final String tailfCommon = "(http://tail-f.com/yang/common?revision=2015-05-22)tailf-common";
+ private static final String tailfCliExtension = "(http://tail-f.com/yang/common?revision=2015-03-19)tailf-cli-extensions";
+ private static final String tailfMetaExtension = "(http://tail-f.com/yang/common?revision=2013-11-07)tailf-meta-extensions";
+ private static final String ietfYangTypes = "(urn:ietf:params:xml:ns:yang:ietf-yang-types?revision=2013-07-15)ietf-yang-types";
+ private static final String ietfInetTypes = "(urn:ietf:params:xml:ns:yang:ietf-inet-types?revision=2013-07-15)ietf-inet-types";
+
+ /**
+ * Initialize all common capabilities required by IOS-XE renderer. Any connected node is examined whether it's
+ * an appropriate device to handle configuration created by this renderer. A device must support all capabilities
+ * in list below.
+ *
+ * @return list of string representations of required capabilities
+ */
+ List<String> initializeRequiredCapabilities() {
+ String writableDataStore = "urn:ietf:params:netconf:capability:writable-running:1.0";
+ String capabilityEntries[] = {ned, tailfCommon, tailfCliExtension, tailfMetaExtension, ietfYangTypes,
+ ietfInetTypes, writableDataStore};
+ return Arrays.asList(capabilityEntries);
}
- LOG.info("Node {} not connected yet", node.getNodeId().getValue());
- return false;
}
}
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.manager.NodeManager;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.RendererName;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.Renderers;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.Renderer;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.RendererNodes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.RendererNodesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.nodes.RendererNode;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.nodes.RendererNodeKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
rendererNodesCache = new ArrayList<>();
}
- public void write(RendererNode node) {
+ public void cache(RendererNode node) {
rendererNodesCache.add(node);
}
+ /**
+ * Put all cached items to data store
+ *
+ * @param dataBroker appropriate data provider
+ */
public void commitToDatastore(DataBroker dataBroker) {
RendererNodes rendererNodes = buildRendererNodes();
WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
- InstanceIdentifier<RendererNodes> Iid = InstanceIdentifier.builder(Renderers.class)
- .child(Renderer.class, new RendererKey(new RendererName("ios-xe-renderer"))) // TODO unify renderer name
- .child(RendererNodes.class)
- .build();
+ InstanceIdentifier<RendererNodes> iid = buildRendererNodesIid();
try {
- wtx.merge(LogicalDatastoreType.OPERATIONAL, Iid, rendererNodes, true);
+ wtx.merge(LogicalDatastoreType.OPERATIONAL, iid, rendererNodes, true);
CheckedFuture<Void, TransactionCommitFailedException> submitFuture = wtx.submit();
submitFuture.checkedGet();
// Clear cache
}
}
+ /**
+ * Removes all cached items from data store
+ *
+ * @param dataBroker appropriate data provider
+ */
+ public void removeFromDatastore(DataBroker dataBroker) {
+ WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
+ for (RendererNode nodeToRemove : rendererNodesCache) {
+ InstanceIdentifier<RendererNode> iid = buildRendererNodeIid(nodeToRemove);
+ try {
+ wtx.delete(LogicalDatastoreType.OPERATIONAL, iid);
+ CheckedFuture<Void, TransactionCommitFailedException> submitFuture = wtx.submit();
+ submitFuture.checkedGet();
+ // Clear cache
+ } catch (TransactionCommitFailedException e) {
+ LOG.error("Write transaction failed to {}", e.getMessage());
+ } catch (Exception e) {
+ LOG.error("Failed to .. {}", e.getMessage());
+ }
+ }
+ rendererNodesCache.clear();
+ }
+
+ private InstanceIdentifier<RendererNodes> buildRendererNodesIid() {
+ return InstanceIdentifier.builder(Renderers.class)
+ .child(Renderer.class, new RendererKey(new RendererName(NodeManager.iosXeRenderer))) // TODO unify renderer name
+ .child(RendererNodes.class)
+ .build();
+ }
+
+ private InstanceIdentifier<RendererNode> buildRendererNodeIid(RendererNode rendererNode) {
+ return InstanceIdentifier.builder(Renderers.class)
+ .child(Renderer.class, new RendererKey(new RendererName(NodeManager.iosXeRenderer))) // TODO unify renderer name
+ .child(RendererNodes.class)
+ .child(RendererNode.class, new RendererNodeKey(rendererNode.getNodePath()))
+ .build();
+ }
+
private RendererNodes buildRendererNodes() {
RendererNodesBuilder rendererNodesBuilder = new RendererNodesBuilder();
rendererNodesBuilder.setRendererNode(new ArrayList<>(rendererNodesCache));
return rendererNodesBuilder.build();
}
-
}
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.manager.NodeManager;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopologyBuilder;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyBuilder;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
+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.NodeBuilder;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
/**
@Mock
private NodeManager nodeManager;
@Mock
- private ListenerRegistration<DataTreeChangeListener<NetworkTopology>> listenerRegistration;
+ private ListenerRegistration<DataTreeChangeListener<Node>> listenerRegistration;
@Mock
- private DataTreeModification<NetworkTopology> dataTreeModification;
+ private DataTreeModification<Node> dataTreeModification;
@Mock
- private DataObjectModification<NetworkTopology> rootNode;
+ private DataObjectModification<Node> rootNode;
private IosXeCapableNodeListenerImpl listener;
@Before
public void setUp() throws Exception {
Mockito.when(dataBroker.registerDataTreeChangeListener(
- Matchers.<DataTreeIdentifier<NetworkTopology>>any(),
- Matchers.<DataTreeChangeListener<NetworkTopology>>any()))
+ Matchers.<DataTreeIdentifier<Node>>any(),
+ Matchers.<DataTreeChangeListener<Node>>any()))
.thenReturn(listenerRegistration);
listener = new IosXeCapableNodeListenerImpl(dataBroker, nodeManager);
Mockito.verify(dataBroker).registerDataTreeChangeListener(
@Test
public void testOnDataTreeChanged_add() throws Exception {
- final NetworkTopology networkTopology = createNetworkTopology("topology-id-1");
+ final Node topologyNode = createNetworkTopologyNode("topology-node-id-1");
Mockito.when(dataTreeModification.getRootNode()).thenReturn(rootNode);
- Mockito.when(rootNode.getDataBefore()).thenReturn(networkTopology);
+ Mockito.when(rootNode.getDataBefore()).thenReturn(topologyNode);
Mockito.when(rootNode.getDataAfter()).thenReturn(null);
listener.onDataTreeChanged(Collections.singleton(dataTreeModification));
- Mockito.verify(nodeManager).syncNodes(null, networkTopology.getTopology());
+ Mockito.verify(nodeManager).syncNodes(null, topologyNode);
}
@Test
public void testOnDataTreeChanged_update() throws Exception {
- final NetworkTopology networkTopologyBefore = createNetworkTopology("topology-id-1");
- final NetworkTopology networkTopologyAfter = createNetworkTopology("topology-id-2");
+ final Node topologyNodeBefore = createNetworkTopologyNode("topology-node-id-1");
+ final Node topologyNodeAfter = createNetworkTopologyNode("topology-node-id-2");
Mockito.when(dataTreeModification.getRootNode()).thenReturn(rootNode);
- Mockito.when(rootNode.getDataBefore()).thenReturn(networkTopologyBefore);
- Mockito.when(rootNode.getDataAfter()).thenReturn(networkTopologyAfter);
+ Mockito.when(rootNode.getDataBefore()).thenReturn(topologyNodeBefore);
+ Mockito.when(rootNode.getDataAfter()).thenReturn(topologyNodeAfter);
listener.onDataTreeChanged(Collections.singleton(dataTreeModification));
- Mockito.verify(nodeManager).syncNodes(networkTopologyAfter.getTopology(), networkTopologyBefore.getTopology());
+ Mockito.verify(nodeManager).syncNodes(topologyNodeAfter, topologyNodeBefore);
}
@Test
public void testOnDataTreeChanged_remove() throws Exception {
- final NetworkTopology networkTopology = createNetworkTopology("topology-id-2");
+ final Node topologyNode = createNetworkTopologyNode("topology-node-id-2");
Mockito.when(dataTreeModification.getRootNode()).thenReturn(rootNode);
Mockito.when(rootNode.getDataBefore()).thenReturn(null);
- Mockito.when(rootNode.getDataAfter()).thenReturn(networkTopology);
+ Mockito.when(rootNode.getDataAfter()).thenReturn(topologyNode);
listener.onDataTreeChanged(Collections.singleton(dataTreeModification));
- Mockito.verify(nodeManager).syncNodes(networkTopology.getTopology(), null);
+ Mockito.verify(nodeManager).syncNodes(topologyNode, null);
}
- private NetworkTopology createNetworkTopology(final String topologyId) {
- return new NetworkTopologyBuilder()
- .setTopology(Collections.singletonList(new TopologyBuilder()
- .setTopologyId(new TopologyId(topologyId))
- .build()))
+ private Node createNetworkTopologyNode(final String nodeId) {
+ return new NodeBuilder()
+ .setNodeId(new NodeId(nodeId))
.build();
}
Code Review / groupbasedpolicy.git / commitdiff