2 * Copyright © 2019 Orange, Inc. and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
8 package org.opendaylight.transportpce.tapi.topology;
10 import static org.hamcrest.CoreMatchers.containsString;
11 import static org.hamcrest.CoreMatchers.either;
12 import static org.hamcrest.MatcherAssert.assertThat;
13 import static org.junit.jupiter.api.Assertions.assertEquals;
14 import static org.junit.jupiter.api.Assertions.assertNotNull;
16 import com.google.common.util.concurrent.ListenableFuture;
17 import com.google.common.util.concurrent.ListeningExecutorService;
18 import com.google.common.util.concurrent.MoreExecutors;
19 import java.nio.charset.Charset;
20 import java.nio.charset.StandardCharsets;
21 import java.util.ArrayList;
22 import java.util.HashMap;
23 import java.util.List;
25 import java.util.UUID;
26 import java.util.concurrent.CountDownLatch;
27 import java.util.concurrent.ExecutionException;
28 import java.util.concurrent.Executors;
29 import java.util.stream.Collectors;
30 import org.eclipse.jdt.annotation.Nullable;
31 import org.junit.jupiter.api.BeforeAll;
32 import org.junit.jupiter.api.Test;
33 import org.opendaylight.transportpce.common.InstanceIdentifiers;
34 import org.opendaylight.transportpce.common.network.NetworkTransactionImpl;
35 import org.opendaylight.transportpce.common.network.NetworkTransactionService;
36 import org.opendaylight.transportpce.servicehandler.service.ServiceDataStoreOperations;
37 import org.opendaylight.transportpce.servicehandler.service.ServiceDataStoreOperationsImpl;
38 import org.opendaylight.transportpce.tapi.TapiStringConstants;
39 import org.opendaylight.transportpce.tapi.connectivity.ConnectivityUtils;
40 import org.opendaylight.transportpce.tapi.utils.TapiContext;
41 import org.opendaylight.transportpce.tapi.utils.TapiInitialORMapping;
42 import org.opendaylight.transportpce.tapi.utils.TapiLink;
43 import org.opendaylight.transportpce.tapi.utils.TapiLinkImpl;
44 import org.opendaylight.transportpce.tapi.utils.TapiTopologyDataUtils;
45 import org.opendaylight.transportpce.test.AbstractTest;
46 import org.opendaylight.transportpce.test.utils.TopologyDataUtils;
47 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.AdministrativeState;
48 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.CAPACITYUNITGBPS;
49 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.ForwardingDirection;
50 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.GetServiceInterfacePointDetailsInput;
51 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.GetServiceInterfacePointDetailsOutput;
52 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.GetServiceInterfacePointListInput;
53 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.GetServiceInterfacePointListOutput;
54 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.LayerProtocolName;
55 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.OperationalState;
56 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.Uuid;
57 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.get.service._interface.point.list.output.Sip;
58 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.get.service._interface.point.list.output.SipKey;
59 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.global._class.Name;
60 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.global._class.NameKey;
61 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.FORWARDINGRULEMAYFORWARDACROSSGROUP;
62 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.GetLinkDetailsInput;
63 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.GetLinkDetailsOutput;
64 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.GetNodeDetailsInput;
65 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.GetNodeDetailsOutput;
66 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.GetNodeEdgePointDetailsInput;
67 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.GetNodeEdgePointDetailsOutput;
68 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.GetTopologyDetailsInput;
69 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.GetTopologyDetailsOutput;
70 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.Node;
71 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.RuleType;
72 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.get.topology.details.output.Topology;
73 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.NodeRuleGroup;
74 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.OwnedNodeEdgePoint;
75 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.NodeEdgePoint;
76 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.Rule;
77 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Link;
78 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.LinkKey;
79 import org.opendaylight.yangtools.yang.common.Decimal64;
80 import org.opendaylight.yangtools.yang.common.RpcResult;
81 import org.opendaylight.yangtools.yang.common.Uint64;
82 import org.slf4j.Logger;
83 import org.slf4j.LoggerFactory;
85 public class TapiTopologyImplTest extends AbstractTest {
86 private static final Logger LOG = LoggerFactory.getLogger(TapiTopologyImplTest.class);
88 private static ListeningExecutorService executorService;
89 private static CountDownLatch endSignal;
90 private static final int NUM_THREADS = 3;
91 private static NetworkTransactionService networkTransactionService;
92 private static TapiContext tapiContext;
93 private static TopologyUtils topologyUtils;
94 private static ConnectivityUtils connectivityUtils;
95 private static ServiceDataStoreOperations serviceDataStoreOperations;
96 private static TapiInitialORMapping tapiInitialORMapping;
97 private static TapiLink tapiLink;
100 static void setUp() throws InterruptedException, ExecutionException {
101 executorService = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(NUM_THREADS));
102 endSignal = new CountDownLatch(1);
103 TopologyDataUtils.writeTopologyFromFileToDatastore(getDataStoreContextUtil(),
104 TapiTopologyDataUtils.OPENROADM_TOPOLOGY_FILE, InstanceIdentifiers.OVERLAY_NETWORK_II);
105 TopologyDataUtils.writeTopologyFromFileToDatastore(getDataStoreContextUtil(),
106 TapiTopologyDataUtils.OPENROADM_NETWORK_FILE, InstanceIdentifiers.UNDERLAY_NETWORK_II);
107 TopologyDataUtils.writeTopologyFromFileToDatastore(getDataStoreContextUtil(),
108 TapiTopologyDataUtils.OTN_TOPOLOGY_FILE, InstanceIdentifiers.OTN_NETWORK_II);
109 TopologyDataUtils.writePortmappingFromFileToDatastore(getDataStoreContextUtil(),
110 TapiTopologyDataUtils.PORTMAPPING_FILE);
111 networkTransactionService = new NetworkTransactionImpl(getDataBroker());
112 tapiLink = new TapiLinkImpl(networkTransactionService);
113 serviceDataStoreOperations = new ServiceDataStoreOperationsImpl(getDataStoreContextUtil().getDataBroker());
114 tapiContext = new TapiContext(networkTransactionService);
115 topologyUtils = new TopologyUtils(networkTransactionService, getDataStoreContextUtil().getDataBroker(),
117 connectivityUtils = new ConnectivityUtils(serviceDataStoreOperations, new HashMap<>(), tapiContext,
118 networkTransactionService);
119 tapiInitialORMapping = new TapiInitialORMapping(topologyUtils, connectivityUtils,
120 tapiContext, serviceDataStoreOperations);
121 tapiInitialORMapping.performTopoInitialMapping();
122 LOG.info("setup done");
126 void getTopologyDetailsForTransponder100GTopologyWhenSuccessful()
127 throws ExecutionException, InterruptedException {
128 Uuid topologyUuid = new Uuid(UUID.nameUUIDFromBytes(TapiStringConstants.TPDR_100G.getBytes(
129 Charset.forName("UTF-8"))).toString());
130 LOG.info("TPDR100GUuid = {}", topologyUuid);
131 GetTopologyDetailsInput input = TapiTopologyDataUtils.buildGetTopologyDetailsInput(topologyUuid);
132 TapiTopologyImpl tapiTopoImpl = new TapiTopologyImpl(networkTransactionService, tapiContext, topologyUtils,
134 ListenableFuture<RpcResult<GetTopologyDetailsOutput>> result = tapiTopoImpl.getTopologyDetails(input);
135 LOG.info("RESULT of getTopoDetailsTopo/name = {}", result.get().getResult().getTopology().getName().toString());
136 result.addListener(new Runnable() {
139 endSignal.countDown();
143 RpcResult<GetTopologyDetailsOutput> rpcResult = result.get();
145 Topology topology = rpcResult.getResult().getTopology();
146 assertNotNull(topology, "Topology should not be null");
147 Uuid topoUuid = new Uuid(UUID.nameUUIDFromBytes(TapiStringConstants.TPDR_100G.getBytes(StandardCharsets.UTF_8))
149 assertEquals(topoUuid, topology.getUuid(), "incorrect topology uuid");
150 assertEquals(1, topology.getNode().size(), "Node list size should be 1");
151 Name nodeName = topology.getNode().values().stream().findFirst().orElseThrow().getName()
152 .get(new NameKey("Tpdr100g node name"));
153 assertEquals("Tpdr100g over WDM node", nodeName.getValue(), "Node name should be 'Tpdr100g over WDM node'");
154 Uuid nodeUuid = new Uuid(UUID.nameUUIDFromBytes(nodeName.getValue().getBytes(StandardCharsets.UTF_8))
156 assertEquals(nodeUuid, topology.getNode().values().stream().findFirst().orElseThrow().getUuid(),
157 "incorrect node uuid");
158 long nb = topology.getNode().values().stream().findFirst().orElseThrow().getOwnedNodeEdgePoint().size();
159 assertEquals(2, nb, "'Transponder 100GE' node should have 2 neps");
160 List<NodeRuleGroup> nrgList = topology.getNode().values().stream().findFirst().orElseThrow()
161 .nonnullNodeRuleGroup().values().stream()
162 .sorted((nrg1, nrg2) -> nrg1.getUuid().getValue().compareTo(nrg2.getUuid().getValue()))
163 .collect(Collectors.toList());
164 assertEquals(1, nrgList.size(), "'Transponder 100GE' node should contain a single node rule groups");
165 List<NodeEdgePoint> nodeEdgePointList = new ArrayList<>(nrgList.get(0).getNodeEdgePoint().values());
166 assertEquals(nb, nodeEdgePointList.size(), "'Transponder 100GE' node -rule-group should contain 2 NEPs");
167 List<Rule> ruleList = new ArrayList<>(nrgList.get(0).nonnullRule().values());
168 assertEquals(1, ruleList.size(), "node-rule-group should contain a single rule");
169 assertEquals("forward", ruleList.get(0).getLocalId(), "local-id of the rule should be 'forward'");
170 assertEquals(FORWARDINGRULEMAYFORWARDACROSSGROUP.VALUE, ruleList.get(0).getForwardingRule(),
171 "the forwarding rule should be 'MAYFORWARDACROSSGROUP'");
172 assertEquals(RuleType.FORWARDING, ruleList.get(0).getRuleType().iterator().next(),
173 "the rule type should be 'FORWARDING'");
177 void getTopologyDetailsForOtnTopologyWithOtnLinksWhenSuccessful()
178 throws ExecutionException, InterruptedException {
179 Uuid topologyUuid = new Uuid(UUID.nameUUIDFromBytes(TapiStringConstants.T0_MULTILAYER.getBytes(
180 Charset.forName("UTF-8"))).toString());
181 LOG.info("T0MultilayerUuid = {}", topologyUuid);
182 GetTopologyDetailsInput input = TapiTopologyDataUtils.buildGetTopologyDetailsInput(topologyUuid);
183 TapiTopologyImpl tapiTopoImpl = new TapiTopologyImpl(networkTransactionService, tapiContext, topologyUtils,
185 ListenableFuture<RpcResult<GetTopologyDetailsOutput>> result = tapiTopoImpl.getTopologyDetails(input);
186 result.addListener(new Runnable() {
189 endSignal.countDown();
193 RpcResult<GetTopologyDetailsOutput> rpcResult = result.get();
195 Topology topology = rpcResult.getResult().getTopology();
196 assertNotNull(topology, "Topology should not be null");
198 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.NodeKey,
199 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Node> entry :
200 topology.getNode().entrySet()) {
201 LOG.debug("NODESDETECTED = {}",entry.getValue().getName().toString());
203 assertEquals(7, topology.getNode().size(), "Node list size should be 7");
204 long nb1 = topology.getNode().values().stream()
205 .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
206 .filter(node -> node.getName().get(new NameKey("dsr/odu node name")).getValue()
207 .equals("XPDR-A1-XPDR1+XPONDER"))
208 .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
209 .filter(nep -> nep.getName().containsKey(new NameKey("100G-tpdr"))))
211 assertEquals(1, nb1, "XPDR-A1-XPDR1 should only have one client nep");
212 long nb2 = topology.getNode().values().stream()
213 .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
214 .filter(node -> node.getName().get(new NameKey("dsr/odu node name")).getValue()
215 .equals("SPDR-SA1-XPDR1+XPONDER"))
216 .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
217 .filter(nep -> nep.getName().containsKey(new NameKey("NodeEdgePoint_C"))))
219 assertEquals(4, nb2, "SPDR-SA1-XPDR1 (mux) should have 4 client neps");
220 long nb3 = topology.getNode().values().stream()
221 .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
222 .filter(node -> node.getName().get(new NameKey("dsr/odu node name")).getValue()
223 .equals("SPDR-SA1-XPDR1+XPONDER"))
224 .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
225 .filter(nep -> nep.getName().containsKey(new NameKey("iNodeEdgePoint_N"))))
227 assertEquals(1, nb3, "SPDR-SA1-XPDR1 (mux) should have a single network nep");
228 long nb4 = topology.getNode().values().stream()
229 .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
230 .filter(node -> node.getName().get(new NameKey("dsr/odu node name")).getValue()
231 .equals("SPDR-SA1-XPDR2+XPONDER"))
232 .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
233 .filter(nep -> nep.getName().containsKey(new NameKey("NodeEdgePoint_C"))))
235 assertEquals(4, nb4, "SPDR-SA1-XPDR2 (switch) should have 4 client neps");
236 long nb5 = topology.getNode().values().stream()
237 .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
238 .filter(node -> node.getName().get(new NameKey("dsr/odu node name")).getValue()
239 .equals("SPDR-SA1-XPDR2+XPONDER"))
240 .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
241 .filter(nep -> nep.getName().containsKey(new NameKey("iNodeEdgePoint_N"))))
243 assertEquals(2, nb5, "SPDR-SA1-XPDR2 (switch) should have 2 network neps");
244 long nb7 = topology.getNode().values().stream()
245 .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.PHOTONICMEDIA)
246 && node.getLayerProtocolName().contains(LayerProtocolName.DSR))
247 .filter(node -> node.getName().get(new NameKey("otsi node name")).getValue()
248 .equals("XPDR-A1-XPDR1+XPONDER"))
249 .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
250 .filter(nep -> nep.getName().containsKey(new NameKey("eNodeEdgePoint"))))
252 assertEquals(1, nb7, "XPDR-A1-XPDR1 should only have 1 OTSI network nep");
253 long nb8 = topology.getNode().values().stream()
254 .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.PHOTONICMEDIA)
255 && node.getLayerProtocolName().contains(LayerProtocolName.DSR))
256 .filter(node -> node.getName().get(new NameKey("otsi node name")).getValue()
257 .equals("SPDR-SA1-XPDR1+XPONDER"))
258 .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
259 .filter(nep -> nep.getName().containsKey(new NameKey("eNodeEdgePoint"))))
261 assertEquals(1, nb8, "SPDR-SA1-XPDR1 (mux) should have a single OTSI network nep");
262 long nb9 = topology.getNode().values().stream()
263 .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.PHOTONICMEDIA)
264 && node.getLayerProtocolName().contains(LayerProtocolName.DSR))
265 .filter(node -> node.getName().get(new NameKey("otsi node name")).getValue()
266 .equals("SPDR-SA1-XPDR2+XPONDER"))
267 .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
268 .filter(nep -> nep.getName().containsKey(new NameKey("eNodeEdgePoint"))))
270 assertEquals(2, nb9, "SPDR-SA1-XPDR2 (switch) should have 2 OTSI network nep");
272 assertEquals(10, topology.getLink().size(), "Link list size should be 10, no more transitionnal links");
273 Uuid topoUuid = new Uuid(UUID.nameUUIDFromBytes("T0 - Multi-layer topology".getBytes()).toString());
274 assertEquals(topoUuid, topology.getUuid(), "incorrect topology uuid");
276 "T0 - Multi-layer topology",
277 topology.nonnullName().values().stream().findFirst().orElseThrow().getValue(),
278 "topology name should be T0 - Multi-layer topology");
280 long nbDsrOduNodes = topology.nonnullNode().values().stream()
281 .filter(n -> n.getName().containsKey(new NameKey("dsr/odu node name"))).count();
282 long nbPhotonicNodes = topology.nonnullNode().values().stream()
283 .filter(n -> n.getName().containsKey(new NameKey("otsi node name"))).count();
284 assertEquals(6, nbDsrOduNodes, "Node list should contain 6 DSR-ODU nodes");
285 assertEquals(7, nbPhotonicNodes, "Node list should contain 7 Photonics node");
286 long nbOtsLinks = topology.getLink().values().stream()
287 .filter(l -> l.getName().containsKey(new NameKey("OTS link name"))).count();
288 long nbOtnLinks = topology.getLink().values().stream()
289 .filter(l -> l.getName().containsKey(new NameKey("otn link name"))).count();
290 assertEquals(8, nbOtsLinks, "Link list should contain 8 OTS links");
291 assertEquals(2, nbOtnLinks, "Link list should contain 2 OTN links");
293 Uuid node1Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+XPONDER".getBytes(StandardCharsets.UTF_8))
295 Uuid node2Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SC1-XPDR1+XPONDER".getBytes(StandardCharsets.UTF_8))
297 Uuid node3Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+XPONDER".getBytes(StandardCharsets.UTF_8))
299 Uuid node4Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SC1-XPDR1+XPONDER".getBytes(StandardCharsets.UTF_8))
301 Uuid tp1Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+eODU+XPDR1-NETWORK1"
302 .getBytes(StandardCharsets.UTF_8)).toString());
303 Uuid tp2Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SC1-XPDR1+eODU+XPDR1-NETWORK1"
304 .getBytes(StandardCharsets.UTF_8)).toString());
305 Uuid tp3Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+iOTSi+XPDR1-NETWORK1"
306 .getBytes(StandardCharsets.UTF_8)).toString());
307 Uuid tp4Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SC1-XPDR1+iOTSi+XPDR1-NETWORK1"
308 .getBytes(StandardCharsets.UTF_8)).toString());
310 new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+iOTSi+XPDR1-NETWORK1toSPDR-SC1-XPDR1+iOTSi+XPDR1-NETWORK1"
311 .getBytes(StandardCharsets.UTF_8)).toString());
313 new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+eODU+XPDR1-NETWORK1toSPDR-SC1-XPDR1+eODU+XPDR1-NETWORK1"
314 .getBytes(StandardCharsets.UTF_8)).toString());
316 List<Link> links = topology.nonnullLink().values().stream()
317 .filter(l -> l.getName().containsKey(new NameKey("otn link name")))
318 .sorted((l1, l2) -> l1.getUuid().getValue().compareTo(l2.getUuid().getValue()))
319 .collect(Collectors.toList());
320 checkOtnLink(links.get(0), topoUuid, node3Uuid, node4Uuid, tp3Uuid, tp4Uuid, link1Uuid,
321 "SPDR-SA1-XPDR1+iOTSi+XPDR1-NETWORK1toSPDR-SC1-XPDR1+iOTSi+XPDR1-NETWORK1");
322 checkOtnLink(links.get(1), topoUuid, node1Uuid, node2Uuid, tp1Uuid, tp2Uuid, link2Uuid,
323 "SPDR-SA1-XPDR1+eODU+XPDR1-NETWORK1toSPDR-SC1-XPDR1+eODU+XPDR1-NETWORK1");
328 void getTopologyDetailsForFullTapiTopologyWithLinksWhenSuccessful()
329 throws ExecutionException, InterruptedException {
330 Uuid topologyUuid = new Uuid(UUID.nameUUIDFromBytes(TapiStringConstants.T0_FULL_MULTILAYER.getBytes(
331 Charset.forName("UTF-8"))).toString());
332 LOG.info("T0FullMultilayerUuid = {}", topologyUuid);
333 GetTopologyDetailsInput input = TapiTopologyDataUtils.buildGetTopologyDetailsInput(topologyUuid);
334 TapiTopologyImpl tapiTopoImpl = new TapiTopologyImpl(networkTransactionService, tapiContext, topologyUtils,
336 ListenableFuture<RpcResult<GetTopologyDetailsOutput>> result = tapiTopoImpl.getTopologyDetails(input);
337 result.addListener(new Runnable() {
340 endSignal.countDown();
344 RpcResult<GetTopologyDetailsOutput> rpcResult = result.get();
346 Topology topology = rpcResult.getResult().getTopology();
347 assertNotNull(topology, "Topology should not be null");
348 // 2 Nodes per Xpdr/Spdr node (DSR-ODU & PHOT) + 3 Node per Roadm
349 assertEquals(10, topology.getNode().size(), "Node list size should be 10");
350 List<Map<NameKey, Name>> nodeNames = topology.getNode().values().stream()
351 .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.PHOTONICMEDIA))
352 .map(Node::getName).collect(Collectors.toList());
353 LOG.info("TopologyNodes = {}", nodeNames.toString());
354 Node nodeTsp = topology.getNode().values().stream()
355 .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
356 .filter(node -> node.getName().get(new NameKey("dsr/odu node name")).getValue()
357 .equals("XPDR-A1-XPDR1+XPONDER"))
358 .findAny().orElseThrow();
359 LOG.debug("XPDRA1 NEPs = {}", nodeTsp.getOwnedNodeEdgePoint().toString());
360 long nb1 = topology.getNode().values().stream()
361 .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
362 .filter(node -> node.getName().get(new NameKey("dsr/odu node name")).getValue()
363 .equals("XPDR-A1-XPDR1+XPONDER"))
364 .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
365 .filter(nep -> nep.getName().containsKey(new NameKey("100G-tpdr"))))
367 // 2 client ports in configuration -> removed the checkTp so we have 2 NEPs
368 assertEquals(2, nb1, "XPDR-A1-XPDR1+XPONDER should only have two client neps");
369 long inb1 = topology.getNode().values().stream()
370 .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
371 .filter(node -> node.getName().get(new NameKey("dsr/odu node name")).getValue()
372 .equals("XPDR-A1-XPDR1+XPONDER"))
373 .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
374 .filter(nep -> nep.getName().containsKey(new NameKey("iNodeEdgePoint_N"))))
376 assertEquals(2, inb1, "XPDR-A1-XPDR1+XPONDER should only have two internal network neps");
377 long enb1 = topology.getNode().values().stream()
378 .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
379 .filter(node -> node.getName().get(new NameKey("dsr/odu node name")).getValue()
380 .equals("XPDR-A1-XPDR1+XPONDER"))
381 .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
382 .filter(nep -> nep.getName().containsKey(new NameKey("eNodeEdgePoint_N"))))
384 assertEquals(2, enb1, "XPDR-A1-XPDR1+XPONDER should only have two external network neps");
385 long nb2 = topology.getNode().values().stream()
386 .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
387 .filter(node -> node.getName().get(new NameKey("dsr/odu node name")).getValue()
388 .equals("SPDR-SA1-XPDR1+XPONDER"))
389 .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
390 .filter(nep -> nep.getName().containsKey(new NameKey("NodeEdgePoint_C"))))
392 assertEquals(4, nb2, "SPDR-SA1-XPDR1+XPONDER (mux) should have 4 client neps");
393 long inb3 = topology.getNode().values().stream()
394 .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
395 .filter(node -> node.getName().get(new NameKey("dsr/odu node name")).getValue()
396 .equals("SPDR-SA1-XPDR1+XPONDER"))
397 .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
398 .filter(nep -> nep.getName().containsKey(new NameKey("iNodeEdgePoint_N"))))
400 assertEquals(1, inb3, "SPDR-SA1-XPDR1+XPONDER (mux) should have a single internal network nep");
401 long enb3 = topology.getNode().values().stream()
402 .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
403 .filter(node -> node.getName().get(new NameKey("dsr/odu node name")).getValue()
404 .equals("SPDR-SA1-XPDR1+XPONDER"))
405 .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
406 .filter(nep -> nep.getName().containsKey(new NameKey("eNodeEdgePoint_N"))))
408 assertEquals(4, enb3, "SPDR-SA1-XPDR1+XPONDER (mux) should have 4 external network nep");
409 long nb4 = topology.getNode().values().stream()
410 .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
411 .filter(node -> node.getName().get(new NameKey("dsr/odu node name")).getValue()
412 .equals("SPDR-SA1-XPDR2+XPONDER"))
413 .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
414 .filter(nep -> nep.getName().containsKey(new NameKey("NodeEdgePoint_C"))))
416 assertEquals(4, nb4, "SPDR-SA1-XPDR2+XPONDER (switch) should have 4 client neps");
417 long inb5 = topology.getNode().values().stream()
418 .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
419 .filter(node -> node.getName().get(new NameKey("dsr/odu node name")).getValue()
420 .equals("SPDR-SA1-XPDR2+XPONDER"))
421 .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
422 .filter(nep -> nep.getName().containsKey(new NameKey("iNodeEdgePoint_N"))))
424 assertEquals(4, inb5, "SPDR-SA1-XPDR2+XPONDER (switch) should have 4 internal network neps");
425 long enb5 = topology.getNode().values().stream()
426 .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
427 .filter(node -> node.getName().get(new NameKey("dsr/odu node name")).getValue()
428 .equals("SPDR-SA1-XPDR1+XPONDER"))
429 .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
430 .filter(nep -> nep.getName().containsKey(new NameKey("eNodeEdgePoint_N"))))
432 assertEquals(4, enb5, "SPDR-SA1-XPDR2+XPONDER (switch) should have 4 external network neps");
434 inb1 = topology.getNode().values().stream()
435 .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
436 .filter(node -> node.getName().get(new NameKey("dsr/odu node name")).getValue()
437 .equals("XPDR-A1-XPDR1+XPONDER"))
438 .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
439 .filter(nep -> nep.getName().containsKey(new NameKey("eNodeEdgePoint_N"))))
441 assertEquals(2, inb1, "XPDR-A1-XPDR1+XPONDER should only have two external network neps");
442 enb1 = topology.getNode().values().stream()
443 .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
444 .filter(node -> node.getName().get(new NameKey("dsr/odu node name")).getValue()
445 .equals("XPDR-A1-XPDR1+XPONDER"))
446 .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
447 .filter(nep -> nep.getName().containsKey(new NameKey("iNodeEdgePoint_N"))))
449 assertEquals(2, enb1, "XPDR-A1-XPDR1+XPONDER should only have two photonic network neps");
450 inb3 = topology.getNode().values().stream()
451 .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
452 .filter(node -> node.getName().get(new NameKey("dsr/odu node name")).getValue()
453 .equals("SPDR-SA1-XPDR1+XPONDER"))
454 .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
455 .filter(nep -> nep.getName().containsKey(new NameKey("eNodeEdgePoint"))))
457 assertEquals(1, inb3, "SPDR-SA1-XPDR1+XPONDER (mux) should have a single external network nep");
458 inb5 = topology.getNode().values().stream()
459 .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
460 .filter(node -> node.getName().get(new NameKey("dsr/odu node name")).getValue()
461 .equals("SPDR-SA1-XPDR2+XPONDER"))
462 .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
463 .filter(nep -> nep.getName().containsKey(new NameKey("eNodeEdgePoint"))))
465 assertEquals(4, inb5, "SPDR-SA1-XPDR2+XPONDER (switch) should have 4 external network neps");
466 long inb6 = topology.getNode().values().stream()
467 .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.PHOTONICMEDIA)
468 && !node.getLayerProtocolName().contains(LayerProtocolName.DSR))
469 .filter(node -> node.getName().get(new NameKey("roadm node name")).getValue()
470 .equals("ROADM-A1+PHOTONIC_MEDIA"))
471 .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
472 .filter(nep -> nep.getName().values().stream().findAny().orElseThrow().getValue().contains("DEG")))
474 assertEquals(4, inb6, "ROADM-A1+PHOTONIC_MEDIA (DEGREE) should have 4 network neps");
475 long enb6 = topology.getNode().values().stream()
476 .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.PHOTONICMEDIA)
477 && !node.getLayerProtocolName().contains(LayerProtocolName.DSR))
478 .filter(node -> node.getName().get(new NameKey("roadm node name")).getValue()
479 .equals("ROADM-A1+PHOTONIC_MEDIA"))
480 .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
481 .filter(nep -> nep.getName().values().stream().findAny().orElseThrow().getValue().contains("SRG")))
483 assertEquals(8, enb6, "ROADM-A1+PHOTONIC_MEDIA (SRG) should have 8 network neps (OTS)");
485 // Links in openroadm topology which include Roadm-to-Roadm and Xpdr-to-Roadm (ortopo / 2)
486 // + transitional links -> 0 per network port of Xpdr + OTN links / 2
487 List<String> linkList = new ArrayList<>();
488 for (Map.Entry<LinkKey, Link> entry : topology.getLink().entrySet()) {
489 linkList.add(entry.getValue().getName().entrySet().iterator().next().getValue().toString());
491 assertEquals(9, topology.getLink().size(), "Link list size should be 8 XPDR To SRG and 1 DEG2A-DEG1C");
492 Uuid topoUuid = new Uuid(UUID.nameUUIDFromBytes("T0 - Full Multi-layer topology".getBytes()).toString());
493 assertEquals(topoUuid, topology.getUuid(), "incorrect topology uuid");
495 "T0 - Full Multi-layer topology",
496 topology.nonnullName().values().stream().findFirst().orElseThrow().getValue(),
497 "topology name should be T0 - Full Multi-layer topology");
499 long nbDsrOduNodes = topology.nonnullNode().values().stream()
500 .filter(n -> n.getName().containsKey(new NameKey("dsr/odu node name"))).count();
501 long nbPhotonicNodes = topology.nonnullNode().values().stream()
502 .filter(n -> n.getName().containsKey(new NameKey("otsi node name"))).count();
503 // In DSR/ODU we create one node per Xpdr (no filtering out)
504 assertEquals(8, nbDsrOduNodes, "Node list should contain 8 DSR-ODU nodes");
505 // We need to add the Roadms as Photonic nodes. Instead of 1 node as roadm infra we have 2 roadm nodes
506 assertEquals(8, nbPhotonicNodes, "Node list should contain 8 Photonics nodes");
508 long nbOmsLinks = topology.getLink().values().stream()
509 .filter(l -> l.getName().containsKey(new NameKey("OMS link name"))).count();
511 long nbOmsLinks1 = topology.getLink().values().stream()
512 .filter(l -> l.getName().containsKey(new NameKey("XPDR-RDM link name"))).count();
513 // 1 OMS per ROADM-to-ROADM link + Existing XPDR-tp-ROADM link in openroadm topology
514 assertEquals(9, nbOmsLinks + nbOmsLinks1, "Link list should contain 9 OMS links");
518 void getNodeAndNepsDetailsWhenSuccessful()
519 throws ExecutionException, InterruptedException {
520 Uuid topologyUuid = new Uuid(UUID.nameUUIDFromBytes(TapiStringConstants.T0_FULL_MULTILAYER.getBytes(
521 Charset.forName("UTF-8"))).toString());
522 GetTopologyDetailsInput input = TapiTopologyDataUtils.buildGetTopologyDetailsInput(topologyUuid);
523 TapiTopologyImpl tapiTopoImpl = new TapiTopologyImpl(networkTransactionService, tapiContext, topologyUtils,
525 ListenableFuture<RpcResult<GetTopologyDetailsOutput>> result = tapiTopoImpl.getTopologyDetails(input);
526 result.addListener(new Runnable() {
529 endSignal.countDown();
533 RpcResult<GetTopologyDetailsOutput> rpcResult = result.get();
535 Topology topology = rpcResult.getResult().getTopology();
536 for (Node node:topology.getNode().values()) {
537 Uuid nodeUuid = node.getUuid();
538 GetNodeDetailsInput input1 = TapiTopologyDataUtils.buildGetNodeDetailsInput(topologyUuid, nodeUuid);
539 ListenableFuture<RpcResult<GetNodeDetailsOutput>> result1 = tapiTopoImpl.getNodeDetails(input1);
540 result.addListener(new Runnable() {
543 endSignal.countDown();
547 RpcResult<GetNodeDetailsOutput> rpcResult1 = result1.get();
549 Node node1 = rpcResult1.getResult().getNode();
550 assertNotNull(node1, "Node should not be null");
551 for (OwnedNodeEdgePoint onep:node1.getOwnedNodeEdgePoint().values()) {
552 Uuid onepUuid = onep.getUuid();
553 GetNodeEdgePointDetailsInput input2 = TapiTopologyDataUtils.buildGetNodeEdgePointDetailsInput(
554 topologyUuid, nodeUuid, onepUuid);
555 ListenableFuture<RpcResult<GetNodeEdgePointDetailsOutput>> result2
556 = tapiTopoImpl.getNodeEdgePointDetails(input2);
557 result.addListener(new Runnable() {
560 endSignal.countDown();
564 RpcResult<GetNodeEdgePointDetailsOutput> rpcResult2 = result2.get();
565 org.opendaylight.yang.gen.v1
566 .urn.onf.otcc.yang.tapi.topology.rev221121.get.node.edge.point.details.output.NodeEdgePoint
567 onep1 = rpcResult2.getResult().getNodeEdgePoint();
568 assertNotNull(onep1, "Node Edge Point should not be null");
574 void getLinkDetailsWhenSuccessful()
575 throws ExecutionException, InterruptedException {
576 Uuid topologyUuid = new Uuid(UUID.nameUUIDFromBytes(TapiStringConstants.T0_FULL_MULTILAYER.getBytes(
577 Charset.forName("UTF-8"))).toString());
578 GetTopologyDetailsInput input = TapiTopologyDataUtils.buildGetTopologyDetailsInput(topologyUuid);
579 TapiTopologyImpl tapiTopoImpl = new TapiTopologyImpl(networkTransactionService, tapiContext, topologyUtils,
581 ListenableFuture<RpcResult<GetTopologyDetailsOutput>> result = tapiTopoImpl.getTopologyDetails(input);
582 result.addListener(new Runnable() {
585 endSignal.countDown();
589 RpcResult<GetTopologyDetailsOutput> rpcResult = result.get();
591 Topology topology = rpcResult.getResult().getTopology();
592 for (Link link:topology.getLink().values()) {
593 Uuid linkUuid = link.getUuid();
594 GetLinkDetailsInput input1 = TapiTopologyDataUtils.buildGetLinkDetailsInput(
595 topologyUuid, linkUuid);
596 ListenableFuture<RpcResult<GetLinkDetailsOutput>> result1 = tapiTopoImpl.getLinkDetails(input1);
597 result.addListener(new Runnable() {
600 endSignal.countDown();
604 RpcResult<GetLinkDetailsOutput> rpcResult1 = result1.get();
605 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.get.link.details.output.Link link1
606 = rpcResult1.getResult().getLink();
607 assertNotNull(link1, "Link should not be null");
612 void getSipDetailsWhenSuccessful()
613 throws ExecutionException, InterruptedException {
614 GetServiceInterfacePointListInput input = TapiTopologyDataUtils.buildServiceInterfacePointListInput();
615 TapiTopologyImpl tapiTopoImpl = new TapiTopologyImpl(networkTransactionService, tapiContext, topologyUtils,
617 ListenableFuture<RpcResult<GetServiceInterfacePointListOutput>> result = tapiTopoImpl
618 .getServiceInterfacePointList(input);
619 result.addListener(new Runnable() {
622 endSignal.countDown();
626 RpcResult<GetServiceInterfacePointListOutput> rpcResult = result.get();
627 Map<SipKey, Sip> sipMap = rpcResult.getResult().getSip();
628 for (Sip sip:sipMap.values()) {
629 Uuid sipUuid = sip.getUuid();
630 GetServiceInterfacePointDetailsInput input1 = TapiTopologyDataUtils
631 .buildGetServiceInterfacePointDetailsInput(sipUuid);
632 ListenableFuture<RpcResult<GetServiceInterfacePointDetailsOutput>> result1
633 = tapiTopoImpl.getServiceInterfacePointDetails(input1);
634 result.addListener(new Runnable() {
637 endSignal.countDown();
641 RpcResult<GetServiceInterfacePointDetailsOutput> rpcResult1 = result1.get();
642 org.opendaylight.yang.gen.v1
643 .urn.onf.otcc.yang.tapi.common.rev221121.get.service._interface.point.details.output.Sip sip1
644 = rpcResult1.getResult().getSip();
645 assertNotNull(sip1, "Sip should not be null");
649 private void checkOtnLink(Link link, Uuid topoUuid, Uuid node1Uuid, Uuid node2Uuid, Uuid tp1Uuid, Uuid tp2Uuid,
650 Uuid linkUuid, String linkName) {
651 assertEquals(linkName, link.getName().get(new NameKey("otn link name")).getValue(), "bad name for the link");
652 assertEquals(linkUuid, link.getUuid(), "bad uuid for link");
653 assertEquals(CAPACITYUNITGBPS.VALUE, link.getAvailableCapacity().getTotalSize().getUnit(),
654 "Available capacity unit should be MBPS");
655 String prefix = linkName.split("-")[0];
656 if ("OTU4".equals(prefix)) {
657 assertEquals(Uint64.valueOf(0), link.getAvailableCapacity().getTotalSize().getValue(),
658 "Available capacity -total size value should be 0");
659 } else if ("ODTU4".equals(prefix)) {
660 assertEquals(Uint64.valueOf(100000), link.getAvailableCapacity().getTotalSize().getValue(),
661 "Available capacity -total size value should be 100 000");
663 assertEquals(CAPACITYUNITGBPS.VALUE, link.getTotalPotentialCapacity().getTotalSize().getUnit(),
664 "Total capacity unit should be GBPS");
665 assertEquals(Decimal64.valueOf("100"), link.getTotalPotentialCapacity().getTotalSize().getValue(),
666 "Total capacity -total size value should be 100");
667 if ("OTU4".equals(prefix)) {
668 assertEquals("otn link should be between 2 nodes of protocol layers PHOTONIC_MEDIA",
669 LayerProtocolName.PHOTONICMEDIA.getName(),
670 link.getLayerProtocolName().stream().findFirst().orElseThrow().getName());
671 } else if ("ODTU4".equals(prefix)) {
672 assertEquals("otn link should be between 2 nodes of protocol layers ODU",
673 LayerProtocolName.ODU.getName(),
674 link.getLayerProtocolName().stream().findFirst().orElseThrow().getName());
676 assertEquals(ForwardingDirection.BIDIRECTIONAL, link.getDirection(),
677 "transitional link should be BIDIRECTIONAL");
678 List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121
679 .link.NodeEdgePoint> nodeEdgePointList = new ArrayList<>(link.nonnullNodeEdgePoint().values());
680 assertEquals(topoUuid, nodeEdgePointList.get(0).getTopologyUuid(),
681 "topology uuid should be the same for the two termination point of the link");
682 assertEquals(topoUuid, nodeEdgePointList.get(1).getTopologyUuid(),
683 "topology uuid should be the same for the two termination point of the link");
684 assertThat("otn links should terminate on two distinct nodes",
685 nodeEdgePointList.get(0).getNodeUuid().getValue(),
686 either(containsString(node1Uuid.getValue())).or(containsString(node2Uuid.getValue())));
687 assertThat("otn links should terminate on two distinct nodes",
688 nodeEdgePointList.get(1).getNodeUuid().getValue(),
689 either(containsString(node1Uuid.getValue())).or(containsString(node2Uuid.getValue())));
690 assertThat("otn links should terminate on two distinct tps",
691 nodeEdgePointList.get(0).getNodeEdgePointUuid().getValue(),
692 either(containsString(tp1Uuid.getValue())).or(containsString(tp2Uuid.getValue())));
693 assertThat("otn links should terminate on two distinct tps",
694 nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(),
695 either(containsString(tp1Uuid.getValue())).or(containsString(tp2Uuid.getValue())));
696 assertEquals(OperationalState.ENABLED, link.getOperationalState(), "operational state should be ENABLED");
697 assertEquals(AdministrativeState.UNLOCKED, link.getAdministrativeState(),
698 "administrative state should be UNLOCKED");