2 * Copyright © 2020 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.CoreMatchers.hasItem;
13 import static org.hamcrest.CoreMatchers.hasItems;
14 import static org.hamcrest.MatcherAssert.assertThat;
15 import static org.junit.Assert.assertEquals;
16 import static org.junit.Assert.assertNull;
17 import static org.junit.Assert.fail;
19 import com.google.common.util.concurrent.FluentFuture;
20 import java.nio.charset.Charset;
21 import java.util.ArrayList;
22 import java.util.HashMap;
23 import java.util.Iterator;
24 import java.util.List;
26 import java.util.Optional;
27 import java.util.UUID;
28 import java.util.concurrent.ExecutionException;
29 import java.util.stream.Collectors;
30 import org.eclipse.jdt.annotation.Nullable;
31 import org.junit.BeforeClass;
32 import org.junit.Test;
33 import org.opendaylight.mdsal.binding.api.DataBroker;
34 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
35 import org.opendaylight.transportpce.common.InstanceIdentifiers;
36 import org.opendaylight.transportpce.tapi.utils.TapiTopologyDataUtils;
37 import org.opendaylight.transportpce.test.AbstractTest;
38 import org.opendaylight.transportpce.test.utils.TopologyDataUtils;
39 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Link1;
40 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Link1Builder;
41 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.TerminationPoint1;
42 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.TerminationPoint1Builder;
43 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.state.types.rev191129.State;
44 import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev191129.AdminStates;
45 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev200529.OpenroadmTpType;
46 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NetworkId;
47 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.Networks;
48 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NodeId;
49 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.NetworkKey;
50 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.Node;
51 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.NodeBuilder;
52 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.NodeKey;
53 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.LinkId;
54 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Network1;
55 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1;
56 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.TpId;
57 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.LinkKey;
58 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.node.TerminationPoint;
59 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.node.TerminationPointBuilder;
60 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.node.TerminationPointKey;
61 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.AdministrativeState;
62 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.CapacityUnit;
63 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.ForwardingDirection;
64 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.LayerProtocolName;
65 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.LifecycleState;
66 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.OperationalState;
67 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.PortDirection;
68 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.PortRole;
69 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.TerminationDirection;
70 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.TerminationState;
71 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.Uuid;
72 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.global._class.Name;
73 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.global._class.NameKey;
74 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.dsr.rev181210.DIGITALSIGNALTYPE100GigE;
75 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.dsr.rev181210.DIGITALSIGNALTYPE10GigELAN;
76 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.odu.rev181210.ODUTYPEODU2;
77 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.odu.rev181210.ODUTYPEODU2E;
78 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.odu.rev181210.ODUTYPEODU4;
79 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.photonic.media.rev181210.PHOTONICLAYERQUALIFIEROMS;
80 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.photonic.media.rev181210.PHOTONICLAYERQUALIFIEROTSi;
81 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.ForwardingRule;
82 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.RuleType;
83 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.NodeRuleGroup;
84 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.OwnedNodeEdgePoint;
85 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.OwnedNodeEdgePointKey;
86 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.rule.group.NodeEdgePoint;
87 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.rule.group.Rule;
88 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Link;
89 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
90 import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
91 import org.opendaylight.yangtools.yang.common.Uint64;
92 import org.slf4j.Logger;
93 import org.slf4j.LoggerFactory;
95 public class ConvertORTopoToTapiTopoTest extends AbstractTest {
96 private static final Logger LOG = LoggerFactory.getLogger(ConvertORTopoToTapiTopoTest.class);
98 private static Node otnMuxA;
99 private static Node otnMuxC;
100 private static Node otnSwitch;
101 private static Node tpdr100G;
102 private static Map<LinkKey,org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
103 .networks.network.Link> otnLinks;
104 private static Uuid topologyUuid;
105 private static DataBroker dataBroker = getDataBroker();
108 public static void setUp() throws InterruptedException, ExecutionException {
109 TopologyDataUtils.writeTopologyFromFileToDatastore(getDataStoreContextUtil(),
110 TapiTopologyDataUtils.OPENROADM_TOPOLOGY_FILE, InstanceIdentifiers.OVERLAY_NETWORK_II);
111 TopologyDataUtils.writeTopologyFromFileToDatastore(getDataStoreContextUtil(),
112 TapiTopologyDataUtils.OTN_TOPOLOGY_FILE, InstanceIdentifiers.OTN_NETWORK_II);
113 TopologyDataUtils.writePortmappingFromFileToDatastore(getDataStoreContextUtil(),
114 TapiTopologyDataUtils.PORTMAPPING_FILE);
116 KeyedInstanceIdentifier<Node, NodeKey> muxAIID = InstanceIdentifier.create(Networks.class)
117 .child(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.Network
118 .class, new NetworkKey(new NetworkId("otn-topology")))
119 .child(Node.class, new NodeKey(new NodeId("SPDR-SA1-XPDR1")));
120 FluentFuture<Optional<Node>> muxAFuture = dataBroker.newReadOnlyTransaction()
121 .read(LogicalDatastoreType.CONFIGURATION, muxAIID);
122 KeyedInstanceIdentifier<Node, NodeKey> muxCIID = InstanceIdentifier.create(Networks.class)
123 .child(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.Network
124 .class, new NetworkKey(new NetworkId("otn-topology")))
125 .child(Node.class, new NodeKey(new NodeId("SPDR-SC1-XPDR1")));
126 FluentFuture<Optional<Node>> muxCFuture = dataBroker.newReadOnlyTransaction()
127 .read(LogicalDatastoreType.CONFIGURATION, muxCIID);
128 KeyedInstanceIdentifier<Node, NodeKey> switchIID = InstanceIdentifier.create(Networks.class)
129 .child(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.Network
130 .class, new NetworkKey(new NetworkId("otn-topology")))
131 .child(Node.class, new NodeKey(new NodeId("SPDR-SA1-XPDR2")));
132 FluentFuture<Optional<Node>> switchFuture = dataBroker.newReadOnlyTransaction()
133 .read(LogicalDatastoreType.CONFIGURATION, switchIID);
135 otnMuxA = muxAFuture.get().get();
136 otnMuxC = muxCFuture.get().get();
137 otnSwitch = switchFuture.get().get();
139 KeyedInstanceIdentifier<Node, NodeKey> tpdrIID = InstanceIdentifier.create(Networks.class)
140 .child(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.Network
141 .class, new NetworkKey(new NetworkId("otn-topology")))
142 .child(Node.class, new NodeKey(new NodeId("XPDR-A1-XPDR1")));
143 FluentFuture<Optional<Node>> tpdrFuture = dataBroker.newReadOnlyTransaction()
144 .read(LogicalDatastoreType.CONFIGURATION, tpdrIID);
145 tpdr100G = tpdrFuture.get().get();
147 InstanceIdentifier<Network1> linksIID = InstanceIdentifier.create(Networks.class)
148 .child(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.Network
149 .class, new NetworkKey(new NetworkId("otn-topology")))
150 .augmentation(Network1.class);
151 FluentFuture<Optional<Network1>> linksFuture = dataBroker.newReadOnlyTransaction()
152 .read(LogicalDatastoreType.CONFIGURATION, linksIID);
153 otnLinks = linksFuture.get().get().getLink();
155 topologyUuid = new Uuid(UUID.nameUUIDFromBytes(TopologyUtils.T0_MULTILAYER.getBytes(Charset.forName("UTF-8")))
157 LOG.info("TEST SETUP READY");
161 public void convertNodeWhenNoStates() {
162 Node tpdr = changeTerminationPointState(tpdr100G, "XPDR1-NETWORK1", null, null);
163 List<String> networkPortList = new ArrayList<>();
164 for (TerminationPoint tp : tpdr100G.augmentation(Node1.class).getTerminationPoint().values()) {
165 if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)) {
166 networkPortList.add(tp.getTpId().getValue());
169 ConvertORTopoToTapiTopo tapiFactory = new ConvertORTopoToTapiTopo(topologyUuid);
170 tapiFactory.convertNode(tpdr, networkPortList);
172 Uuid dsrNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+DSR".getBytes(Charset.forName("UTF-8")))
174 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node dsrNode = tapiFactory
175 .getTapiNodes().get(new
176 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.NodeKey(dsrNodeUuid));
177 Uuid networkNepUuid = new Uuid(
178 UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+DSR+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
180 OwnedNodeEdgePoint nepN = dsrNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(networkNepUuid));
181 assertNull("Administrative State should not be present", nepN.getAdministrativeState());
182 assertNull("Operational State should not be present", nepN.getOperationalState());
184 Uuid otsiNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+OTSi".getBytes(Charset.forName("UTF-8")))
186 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node otsiNode = tapiFactory
187 .getTapiNodes().get(new
188 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.NodeKey(otsiNodeUuid));
189 Uuid enepUuid = new Uuid(
190 UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+eOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
192 Uuid inepUuid = new Uuid(
193 UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
195 OwnedNodeEdgePoint enep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(enepUuid));
196 assertNull("Administrative State should not be present", enep.getAdministrativeState());
197 assertNull("Operational State should not be present", enep.getOperationalState());
199 OwnedNodeEdgePoint inep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(inepUuid));
200 assertNull("Administrative State should not be present", inep.getAdministrativeState());
201 assertNull("Operational State should not be present", inep.getOperationalState());
205 public void convertNodeWhenBadStates1() {
206 Node tpdr = changeTerminationPointState(tpdr100G, "XPDR1-NETWORK1", AdminStates.OutOfService,
208 List<String> networkPortList = new ArrayList<>();
209 for (TerminationPoint tp : tpdr100G.augmentation(Node1.class).getTerminationPoint().values()) {
210 if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)) {
211 networkPortList.add(tp.getTpId().getValue());
214 ConvertORTopoToTapiTopo tapiFactory = new ConvertORTopoToTapiTopo(topologyUuid);
215 tapiFactory.convertNode(tpdr, networkPortList);
217 Uuid dsrNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+DSR".getBytes(Charset.forName("UTF-8")))
219 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node dsrNode = tapiFactory
220 .getTapiNodes().get(new
221 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.NodeKey(dsrNodeUuid));
222 Uuid networkNepUuid = new Uuid(
223 UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+DSR+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
225 OwnedNodeEdgePoint nepN = dsrNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(networkNepUuid));
226 assertEquals("Administrative State should be Locked",
227 AdministrativeState.LOCKED, nepN.getAdministrativeState());
228 assertEquals("Operational State should be Disabled",
229 OperationalState.DISABLED, nepN.getOperationalState());
231 Uuid otsiNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+OTSi".getBytes(Charset.forName("UTF-8")))
233 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node otsiNode = tapiFactory
234 .getTapiNodes().get(new
235 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.NodeKey(otsiNodeUuid));
236 Uuid enepUuid = new Uuid(
237 UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+eOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
239 Uuid inepUuid = new Uuid(
240 UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
242 OwnedNodeEdgePoint enep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(enepUuid));
243 assertEquals("Administrative State should be Locked",
244 AdministrativeState.LOCKED, enep.getAdministrativeState());
245 assertEquals("Operational State should be Disabled",
246 OperationalState.DISABLED, enep.getOperationalState());
248 OwnedNodeEdgePoint inep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(inepUuid));
249 assertEquals("Administrative State should be Locked",
250 AdministrativeState.LOCKED, inep.getAdministrativeState());
251 assertEquals("Operational State should be Disabled",
252 OperationalState.DISABLED, inep.getOperationalState());
256 public void convertNodeWhenBadStates2() {
257 Node tpdr = changeTerminationPointState(tpdr100G, "XPDR1-NETWORK1", AdminStates.Maintenance,
259 List<String> networkPortList = new ArrayList<>();
260 for (TerminationPoint tp : tpdr100G.augmentation(Node1.class).getTerminationPoint().values()) {
261 if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)) {
262 networkPortList.add(tp.getTpId().getValue());
265 ConvertORTopoToTapiTopo tapiFactory = new ConvertORTopoToTapiTopo(topologyUuid);
266 tapiFactory.convertNode(tpdr, networkPortList);
268 Uuid dsrNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+DSR".getBytes(Charset.forName("UTF-8")))
270 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node dsrNode = tapiFactory
271 .getTapiNodes().get(new
272 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.NodeKey(dsrNodeUuid));
273 Uuid networkNepUuid = new Uuid(
274 UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+DSR+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
276 OwnedNodeEdgePoint nepN = dsrNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(networkNepUuid));
277 assertEquals("Administrative State should be Locked",
278 AdministrativeState.LOCKED, nepN.getAdministrativeState());
279 assertEquals("Operational State should be Disabled",
280 OperationalState.DISABLED, nepN.getOperationalState());
282 Uuid otsiNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+OTSi".getBytes(Charset.forName("UTF-8")))
284 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node otsiNode = tapiFactory
285 .getTapiNodes().get(new
286 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.NodeKey(otsiNodeUuid));
287 Uuid enepUuid = new Uuid(
288 UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+eOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
290 Uuid inepUuid = new Uuid(
291 UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
293 OwnedNodeEdgePoint enep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(enepUuid));
294 assertEquals("Administrative State should be Locked",
295 AdministrativeState.LOCKED, enep.getAdministrativeState());
296 assertEquals("Operational State should be Disabled",
297 OperationalState.DISABLED, enep.getOperationalState());
299 OwnedNodeEdgePoint inep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(inepUuid));
300 assertEquals("Administrative State should be Locked",
301 AdministrativeState.LOCKED, inep.getAdministrativeState());
302 assertEquals("Operational State should be Disabled",
303 OperationalState.DISABLED, inep.getOperationalState());
307 public void convertOtnLinkWhenNoState() {
308 HashMap<LinkKey, org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
309 .networks.network.Link> otnLinksAlt = new HashMap<>(otnLinks);
310 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.Link
311 link = changeOtnLinkState(otnLinks.get(new LinkKey(
312 new LinkId("ODU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1"))), null, null);
313 otnLinksAlt.replace(link.key(), link);
315 ConvertORTopoToTapiTopo tapiFactory = new ConvertORTopoToTapiTopo(topologyUuid);
316 List<String> networkPortListA = new ArrayList<>();
317 for (TerminationPoint tp : otnMuxA.augmentation(Node1.class).getTerminationPoint().values()) {
318 if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)) {
319 networkPortListA.add(tp.getTpId().getValue());
322 tapiFactory.convertNode(otnMuxA, networkPortListA);
323 List<String> networkPortListC = new ArrayList<>();
324 for (TerminationPoint tp : otnMuxC.augmentation(Node1.class).getTerminationPoint().values()) {
325 if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)) {
326 networkPortListC.add(tp.getTpId().getValue());
329 tapiFactory.convertNode(otnMuxC, networkPortListC);
330 tapiFactory.convertLinks(otnLinksAlt);
332 List<Link> tapiLinks = tapiFactory.getTapiLinks().values().stream()
333 .sorted((l1, l2) -> l1.getUuid().getValue().compareTo(l2.getUuid().getValue()))
334 .collect(Collectors.toList());
335 assertNull("Administrative State should not be present", tapiLinks.get(0).getAdministrativeState());
336 assertEquals("Administrative state should be UNLOCKED",
337 AdministrativeState.UNLOCKED, tapiLinks.get(2).getAdministrativeState());
338 assertNull("Operational State should not be present", tapiLinks.get(0).getOperationalState());
339 assertEquals("Operational state should be ENABLED",
340 OperationalState.ENABLED, tapiLinks.get(2).getOperationalState());
344 public void convertOtnLinkWhenNoStateOnOppositeLink() {
345 HashMap<LinkKey, org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
346 .networks.network.Link> otnLinksAlt = new HashMap<>(otnLinks);
347 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.Link
348 link = changeOtnLinkState(otnLinks.get(new LinkKey(
349 new LinkId("ODU4-SPDR-SC1-XPDR1-XPDR1-NETWORK1toSPDR-SA1-XPDR1-XPDR1-NETWORK1"))), null, null);
350 otnLinksAlt.replace(link.key(), link);
352 ConvertORTopoToTapiTopo tapiFactory = new ConvertORTopoToTapiTopo(topologyUuid);
353 List<String> networkPortListA = new ArrayList<>();
354 for (TerminationPoint tp : otnMuxA.augmentation(Node1.class).getTerminationPoint().values()) {
355 if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)) {
356 networkPortListA.add(tp.getTpId().getValue());
359 tapiFactory.convertNode(otnMuxA, networkPortListA);
360 List<String> networkPortListC = new ArrayList<>();
361 for (TerminationPoint tp : otnMuxC.augmentation(Node1.class).getTerminationPoint().values()) {
362 if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)) {
363 networkPortListC.add(tp.getTpId().getValue());
366 tapiFactory.convertNode(otnMuxC, networkPortListC);
367 tapiFactory.convertLinks(otnLinksAlt);
369 List<Link> tapiLinks = tapiFactory.getTapiLinks().values().stream()
370 .sorted((l1, l2) -> l1.getUuid().getValue().compareTo(l2.getUuid().getValue()))
371 .collect(Collectors.toList());
372 assertNull("Administrative State should not be present", tapiLinks.get(0).getAdministrativeState());
373 assertEquals("Administrative state should be UNLOCKED",
374 AdministrativeState.UNLOCKED, tapiLinks.get(2).getAdministrativeState());
375 assertNull("Operational State should not be present", tapiLinks.get(0).getOperationalState());
376 assertEquals("Operational state should be ENABLED",
377 OperationalState.ENABLED, tapiLinks.get(2).getOperationalState());
381 public void convertOtnLinkWhenBadState1() {
382 HashMap<LinkKey, org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
383 .networks.network.Link> otnLinksAlt = new HashMap<>(otnLinks);
384 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.Link
385 link = changeOtnLinkState(otnLinks.get(new LinkKey(
386 new LinkId("ODU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1"))),
387 AdminStates.OutOfService, State.OutOfService);
388 otnLinksAlt.replace(link.key(), link);
390 ConvertORTopoToTapiTopo tapiFactory = new ConvertORTopoToTapiTopo(topologyUuid);
391 List<String> networkPortListA = new ArrayList<>();
392 for (TerminationPoint tp : otnMuxA.augmentation(Node1.class).getTerminationPoint().values()) {
393 if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)) {
394 networkPortListA.add(tp.getTpId().getValue());
397 tapiFactory.convertNode(otnMuxA, networkPortListA);
398 List<String> networkPortListC = new ArrayList<>();
399 for (TerminationPoint tp : otnMuxC.augmentation(Node1.class).getTerminationPoint().values()) {
400 if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)) {
401 networkPortListC.add(tp.getTpId().getValue());
404 tapiFactory.convertNode(otnMuxC, networkPortListC);
405 tapiFactory.convertLinks(otnLinksAlt);
407 List<Link> tapiLinks = tapiFactory.getTapiLinks().values().stream()
408 .sorted((l1, l2) -> l1.getUuid().getValue().compareTo(l2.getUuid().getValue()))
409 .collect(Collectors.toList());
410 assertEquals("Administrative state should be LOCKED",
411 AdministrativeState.LOCKED, tapiLinks.get(0).getAdministrativeState());
412 assertEquals("Administrative state should be UNLOCKED",
413 AdministrativeState.UNLOCKED, tapiLinks.get(2).getAdministrativeState());
414 assertEquals("Operational state should be DISABLED",
415 OperationalState.DISABLED, tapiLinks.get(0).getOperationalState());
416 assertEquals("Operational state should be ENABLED",
417 OperationalState.ENABLED, tapiLinks.get(2).getOperationalState());
421 public void convertOtnLinkWhenBadState2() {
422 HashMap<LinkKey, org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
423 .networks.network.Link> otnLinksAlt = new HashMap<>(otnLinks);
424 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.Link
425 link = changeOtnLinkState(otnLinks.get(new LinkKey(
426 new LinkId("ODU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1"))),
427 AdminStates.Maintenance, State.Degraded);
428 otnLinksAlt.replace(link.key(), link);
430 ConvertORTopoToTapiTopo tapiFactory = new ConvertORTopoToTapiTopo(topologyUuid);
431 List<String> networkPortListA = new ArrayList<>();
432 for (TerminationPoint tp : otnMuxA.augmentation(Node1.class).getTerminationPoint().values()) {
433 if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)) {
434 networkPortListA.add(tp.getTpId().getValue());
437 tapiFactory.convertNode(otnMuxA, networkPortListA);
438 List<String> networkPortListC = new ArrayList<>();
439 for (TerminationPoint tp : otnMuxC.augmentation(Node1.class).getTerminationPoint().values()) {
440 if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)) {
441 networkPortListC.add(tp.getTpId().getValue());
444 tapiFactory.convertNode(otnMuxC, networkPortListC);
445 tapiFactory.convertLinks(otnLinksAlt);
447 List<Link> tapiLinks = tapiFactory.getTapiLinks().values().stream()
448 .sorted((l1, l2) -> l1.getUuid().getValue().compareTo(l2.getUuid().getValue()))
449 .collect(Collectors.toList());
450 assertEquals("Administrative state should be LOCKED",
451 AdministrativeState.LOCKED, tapiLinks.get(0).getAdministrativeState());
452 assertEquals("Administrative state should be UNLOCKED",
453 AdministrativeState.UNLOCKED, tapiLinks.get(2).getAdministrativeState());
454 assertEquals("Operational state should be DISABLED",
455 OperationalState.DISABLED, tapiLinks.get(0).getOperationalState());
456 assertEquals("Operational state should be ENABLED",
457 OperationalState.ENABLED, tapiLinks.get(2).getOperationalState());
461 public void convertOtnLinkWhenBadStateOnOppositeLink() {
462 HashMap<LinkKey, org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
463 .networks.network.Link> otnLinksAlt = new HashMap<>(otnLinks);
464 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.Link
465 link = changeOtnLinkState(otnLinks.get(new LinkKey(
466 new LinkId("ODU4-SPDR-SC1-XPDR1-XPDR1-NETWORK1toSPDR-SA1-XPDR1-XPDR1-NETWORK1"))),
467 AdminStates.OutOfService, State.OutOfService);
468 otnLinksAlt.replace(link.key(), link);
470 ConvertORTopoToTapiTopo tapiFactory = new ConvertORTopoToTapiTopo(topologyUuid);
471 List<String> networkPortListA = new ArrayList<>();
472 for (TerminationPoint tp : otnMuxA.augmentation(Node1.class).getTerminationPoint().values()) {
473 if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)) {
474 networkPortListA.add(tp.getTpId().getValue());
477 tapiFactory.convertNode(otnMuxA, networkPortListA);
478 List<String> networkPortListC = new ArrayList<>();
479 for (TerminationPoint tp : otnMuxC.augmentation(Node1.class).getTerminationPoint().values()) {
480 if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)) {
481 networkPortListC.add(tp.getTpId().getValue());
484 tapiFactory.convertNode(otnMuxC, networkPortListC);
485 tapiFactory.convertLinks(otnLinksAlt);
487 List<Link> tapiLinks = tapiFactory.getTapiLinks().values().stream()
488 .sorted((l1, l2) -> l1.getUuid().getValue().compareTo(l2.getUuid().getValue()))
489 .collect(Collectors.toList());
490 assertEquals("Administrative state should be LOCKED",
491 AdministrativeState.LOCKED, tapiLinks.get(0).getAdministrativeState());
492 assertEquals("Administrative state should be UNLOCKED",
493 AdministrativeState.UNLOCKED, tapiLinks.get(2).getAdministrativeState());
494 assertEquals("Operational state should be DISABLED",
495 OperationalState.DISABLED, tapiLinks.get(0).getOperationalState());
496 assertEquals("Operational state should be ENABLED",
497 OperationalState.ENABLED, tapiLinks.get(2).getOperationalState());
501 public void convertNodeForTransponder100G() {
502 ConvertORTopoToTapiTopo tapiFactory = new ConvertORTopoToTapiTopo(topologyUuid);
503 List<String> networkPortList = new ArrayList<>();
504 for (TerminationPoint tp : tpdr100G.augmentation(Node1.class).getTerminationPoint().values()) {
505 if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)) {
506 networkPortList.add(tp.getTpId().getValue());
509 tapiFactory.convertNode(tpdr100G, networkPortList);
510 List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node> tapiNodes
511 = tapiFactory.getTapiNodes().values().stream()
512 .sorted((n1, n2) -> n1.getUuid().getValue().compareTo(n2.getUuid().getValue()))
513 .collect(Collectors.toList());
515 assertEquals("Node list size should be 2", 2, tapiFactory.getTapiNodes().size());
516 assertEquals("Link list size should be 2", 2, tapiFactory.getTapiLinks().size());
518 Uuid dsrNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+DSR".getBytes(Charset.forName("UTF-8")))
520 checkDsrNode(tapiNodes.get(1), dsrNodeUuid, "tpdr", "XPDR-A1-XPDR1");
521 Uuid otsiNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+OTSi".getBytes(Charset.forName("UTF-8")))
523 checkOtsiNode(tapiNodes.get(0), otsiNodeUuid, "tpdr", "XPDR-A1-XPDR1");
525 List<Link> tapiLinks = tapiFactory.getTapiLinks().values().stream()
526 .sorted((l1, l2) -> l1.getUuid().getValue().compareTo(l2.getUuid().getValue()))
527 .collect(Collectors.toList());
528 checkTransitionalLink(tapiLinks.get(1), dsrNodeUuid, otsiNodeUuid,
529 "XPDR-A1-XPDR1+DSR+XPDR1-NETWORK1", "XPDR-A1-XPDR1+iOTSi+XPDR1-NETWORK1", "XPDR-A1-XPDR1");
533 public void convertNodeForOtnMuxponder() {
534 ConvertORTopoToTapiTopo tapiFactory = new ConvertORTopoToTapiTopo(topologyUuid);
535 List<String> networkPortList = new ArrayList<>();
536 for (TerminationPoint tp : otnMuxA.augmentation(Node1.class).getTerminationPoint().values()) {
537 if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)) {
538 networkPortList.add(tp.getTpId().getValue());
541 tapiFactory.convertNode(otnMuxA, networkPortList);
542 List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node> tapiNodes
543 = tapiFactory.getTapiNodes().values().stream()
544 .sorted((n1, n2) -> n1.getUuid().getValue().compareTo(n2.getUuid().getValue()))
545 .collect(Collectors.toList());
547 assertEquals("Node list size should be 2", 2, tapiFactory.getTapiNodes().size());
548 assertEquals("Link list size should be 1", 1, tapiFactory.getTapiLinks().size());
549 Uuid dsrNodeUuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+DSR".getBytes(Charset.forName("UTF-8")))
551 checkDsrNode(tapiNodes.get(0), dsrNodeUuid, "mux", "SPDR-SA1-XPDR1");
552 Uuid otsiNodeUuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+OTSi".getBytes(Charset.forName("UTF-8")))
554 checkOtsiNode(tapiNodes.get(1), otsiNodeUuid, "mux", "SPDR-SA1-XPDR1");
556 List<Link> tapiLinks = tapiFactory.getTapiLinks().values().stream()
557 .sorted((l1, l2) -> l1.getUuid().getValue().compareTo(l2.getUuid().getValue()))
558 .collect(Collectors.toList());
559 checkTransitionalLink(tapiLinks.get(0), dsrNodeUuid, otsiNodeUuid,
560 "SPDR-SA1-XPDR1+DSR+XPDR1-NETWORK1", "SPDR-SA1-XPDR1+iOTSi+XPDR1-NETWORK1", "SPDR-SA1-XPDR1");
564 public void convertNodeForOtnSwitch() {
565 ConvertORTopoToTapiTopo tapiFactory = new ConvertORTopoToTapiTopo(topologyUuid);
566 List<String> networkPortList = new ArrayList<>();
567 for (TerminationPoint tp : otnSwitch.augmentation(Node1.class).getTerminationPoint().values()) {
568 if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)) {
569 networkPortList.add(tp.getTpId().getValue());
572 tapiFactory.convertNode(otnSwitch, networkPortList);
573 List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node> tapiNodes
574 = tapiFactory.getTapiNodes().values().stream()
575 .sorted((n1, n2) -> n1.getUuid().getValue().compareTo(n2.getUuid().getValue()))
576 .collect(Collectors.toList());
578 assertEquals("Node list size should be 2", 2, tapiFactory.getTapiNodes().size());
579 assertEquals("Link list size should be 4", 4, tapiFactory.getTapiLinks().size());
581 Uuid dsrNodeUuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR2+DSR".getBytes(Charset.forName("UTF-8")))
583 checkDsrNode(tapiNodes.get(0), dsrNodeUuid, "switch", "SPDR-SA1-XPDR2");
584 Uuid otsiNodeUuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR2+OTSi".getBytes(Charset.forName("UTF-8")))
586 checkOtsiNode(tapiNodes.get(1), otsiNodeUuid, "switch", "SPDR-SA1-XPDR2");
588 List<Link> tapiLinks = tapiFactory.getTapiLinks().values().stream()
589 .sorted((l1, l2) -> l1.getUuid().getValue().compareTo(l2.getUuid().getValue()))
590 .collect(Collectors.toList());
591 checkTransitionalLink(tapiLinks.get(0), dsrNodeUuid, otsiNodeUuid,
592 "SPDR-SA1-XPDR2+DSR+XPDR2-NETWORK4", "SPDR-SA1-XPDR2+iOTSi+XPDR2-NETWORK4", "SPDR-SA1-XPDR2");
596 public void convertOtnLink() {
597 ConvertORTopoToTapiTopo tapiFactory = new ConvertORTopoToTapiTopo(topologyUuid);
598 List<String> networkPortListA = new ArrayList<>();
599 for (TerminationPoint tp : otnMuxA.augmentation(Node1.class).getTerminationPoint().values()) {
600 if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)) {
601 networkPortListA.add(tp.getTpId().getValue());
604 tapiFactory.convertNode(otnMuxA, networkPortListA);
605 List<String> networkPortListC = new ArrayList<>();
606 for (TerminationPoint tp : otnMuxC.augmentation(Node1.class).getTerminationPoint().values()) {
607 if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)) {
608 networkPortListC.add(tp.getTpId().getValue());
611 tapiFactory.convertNode(otnMuxC, networkPortListC);
612 tapiFactory.convertLinks(otnLinks);
613 assertEquals("Link list size should be 4", 4, tapiFactory.getTapiLinks().size());
615 Uuid node1Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+DSR".getBytes(Charset.forName("UTF-8")))
617 Uuid node2Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SC1-XPDR1+DSR".getBytes(Charset.forName("UTF-8")))
619 Uuid node3Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+OTSi".getBytes(Charset.forName("UTF-8")))
621 Uuid node4Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SC1-XPDR1+OTSi".getBytes(Charset.forName("UTF-8")))
623 Uuid tp1Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+DSR+XPDR1-NETWORK1"
624 .getBytes(Charset.forName("UTF-8"))).toString());
625 Uuid tp2Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SC1-XPDR1+DSR+XPDR1-NETWORK1"
626 .getBytes(Charset.forName("UTF-8"))).toString());
627 Uuid tp3Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+iOTSi+XPDR1-NETWORK1"
628 .getBytes(Charset.forName("UTF-8"))).toString());
629 Uuid tp4Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SC1-XPDR1+iOTSi+XPDR1-NETWORK1"
630 .getBytes(Charset.forName("UTF-8"))).toString());
632 new Uuid(UUID.nameUUIDFromBytes("ODU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1"
633 .getBytes(Charset.forName("UTF-8"))).toString());
635 new Uuid(UUID.nameUUIDFromBytes("OTU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1"
636 .getBytes(Charset.forName("UTF-8"))).toString());
638 List<Link> links = tapiFactory.getTapiLinks().values().stream()
639 .sorted((l1, l2) -> l1.getUuid().getValue().compareTo(l2.getUuid().getValue()))
640 .collect(Collectors.toList());
641 checkOtnLink(links.get(0), node1Uuid, node2Uuid, tp1Uuid, tp2Uuid, link1Uuid,
642 "ODU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1");
643 checkOtnLink(links.get(2), node3Uuid, node4Uuid, tp3Uuid, tp4Uuid, link2Uuid,
644 "OTU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1");
648 public void convertRoadmInfrastructureWhenNoXponderAttached() {
649 ConvertORTopoToTapiTopo tapiFactory = new ConvertORTopoToTapiTopo(topologyUuid);
650 tapiFactory.convertRoadmInfrastructure();
652 assertEquals("Node list size should be 1", 1, tapiFactory.getTapiNodes().size());
653 assertEquals("Link list size should be empty", 0, tapiFactory.getTapiLinks().size());
654 List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node> tapiNodes
655 = tapiFactory.getTapiNodes().values().stream().collect(Collectors.toList());
656 Uuid otsiNodeUuid = new Uuid(UUID.nameUUIDFromBytes("ROADM-infra".getBytes(Charset.forName("UTF-8")))
658 checkOtsiNode(tapiNodes.get(0), otsiNodeUuid, "infra", "ROADM-infra");
662 public void convertRoadmInfrastructureWhenOtnMuxAttached() {
663 ConvertORTopoToTapiTopo tapiFactory = new ConvertORTopoToTapiTopo(topologyUuid);
664 List<String> networkPortListA = new ArrayList<>();
665 for (TerminationPoint tp : otnMuxA.augmentation(Node1.class).getTerminationPoint().values()) {
666 if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERNETWORK)) {
667 networkPortListA.add(tp.getTpId().getValue());
670 tapiFactory.convertNode(otnMuxA, networkPortListA);
671 tapiFactory.convertRoadmInfrastructure();
673 assertEquals("Node list size should be 3", 3, tapiFactory.getTapiNodes().size());
674 assertEquals("Link list size should be 2", 2, tapiFactory.getTapiLinks().size());
675 List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node> tapiNodes
676 = tapiFactory.getTapiNodes().values().stream()
677 .sorted((n1, n2) -> n1.getUuid().getValue().compareTo(n2.getUuid().getValue()))
678 .collect(Collectors.toList());
679 Uuid otsiNodeUuid = new Uuid(UUID.nameUUIDFromBytes("ROADM-infra".getBytes(Charset.forName("UTF-8")))
681 checkOtsiNode(tapiNodes.get(2), otsiNodeUuid, "infra", "ROADM-infra");
683 List<Link> links = tapiFactory.getTapiLinks().values().stream()
684 .sorted((l1, l2) -> l1.getUuid().getValue().compareTo(l2.getUuid().getValue()))
685 .collect(Collectors.toList());
686 Uuid node1Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+OTSi".getBytes(Charset.forName("UTF-8")))
688 Uuid node2Uuid = new Uuid(UUID.nameUUIDFromBytes("ROADM-infra".getBytes(Charset.forName("UTF-8")))
690 Uuid tp1Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+eOTSi+XPDR1-NETWORK1"
691 .getBytes(Charset.forName("UTF-8"))).toString());
692 Uuid tp2Uuid = new Uuid(UUID.nameUUIDFromBytes(("roadm node+nep+1")
693 .getBytes(Charset.forName("UTF-8"))).toString());
695 new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1--XPDR1-NETWORK1 and ROADM-infra--NodeEdgePoint_1"
696 .getBytes(Charset.forName("UTF-8"))).toString());
697 checkOmsLink(links.get(0), node1Uuid, node2Uuid, tp1Uuid, tp2Uuid, linkUuid,
698 "SPDR-SA1-XPDR1--XPDR1-NETWORK1 and ROADM-infra--NodeEdgePoint_1");
701 private void checkDsrNode(org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node node,
702 Uuid nodeUuid, String dsrNodeType, String nodeId) {
703 assertEquals("incorrect node uuid", nodeUuid, node.getUuid());
704 assertEquals("incorrect node name", nodeId, node.getName().get(new NameKey("dsr/odu node name")).getValue());
705 assertEquals("administrative state should be UNLOCKED",
706 AdministrativeState.UNLOCKED, node.getAdministrativeState());
707 assertEquals("life-cycle state should be INSTALLED", LifecycleState.INSTALLED, node.getLifecycleState());
708 assertEquals("operational state should be ENABLED", OperationalState.ENABLED, node.getOperationalState());
709 assertEquals("value-name should be 'dsr/odu node name'",
710 "dsr/odu node name", node.nonnullName().values().stream().findFirst().get().getValueName());
711 assertEquals("dsr node should manage 2 protocol layers : dsr and odu",
712 2, node.getLayerProtocolName().size());
713 assertThat("dsr node should manage 2 protocol layers : dsr and odu",
714 node.getLayerProtocolName(), hasItems(LayerProtocolName.DSR, LayerProtocolName.ODU));
715 List<OwnedNodeEdgePoint> nepsN = node.nonnullOwnedNodeEdgePoint().values().stream()
716 .filter(n -> n.getName().containsKey(new NameKey("NodeEdgePoint_N")))
717 .sorted((nep1, nep2) -> nep1.getUuid().getValue().compareTo(nep2.getUuid().getValue()))
718 .collect(Collectors.toList());
719 List<OwnedNodeEdgePoint> nepsC;
720 switch (dsrNodeType) {
722 nepsC = node.nonnullOwnedNodeEdgePoint().values().stream()
723 .filter(n -> n.getName().containsKey(new NameKey("NodeEdgePoint_C")))
724 .sorted((nep1, nep2) -> nep1.getUuid().getValue().compareTo(nep2.getUuid().getValue()))
725 .collect(Collectors.toList());
726 assertEquals("Switch-DSR node should have 4 NEPs network", 4, nepsN.size());
727 assertEquals("Switch-DSR node should have 4 NEPs client", 4, nepsC.size());
728 OwnedNodeEdgePoint nep1 = nepsC.get(2);
729 Uuid client4NepUuid = new Uuid(
730 UUID.nameUUIDFromBytes((nodeId + "+DSR+XPDR2-CLIENT4").getBytes(Charset.forName("UTF-8")))
732 checkNepClient100GSwitch(nep1, client4NepUuid, "XPDR2-CLIENT4", "NodeEdgePoint_C");
733 OwnedNodeEdgePoint nep2 = nepsN.get(1);
734 Uuid networkNepUuid = new Uuid(
735 UUID.nameUUIDFromBytes((nodeId + "+DSR+XPDR2-NETWORK1").getBytes(Charset.forName("UTF-8")))
737 checkNepNetworkODU4(nep2, networkNepUuid, "XPDR2-NETWORK1", "NodeEdgePoint_N");
738 List<NodeRuleGroup> nrgList = node.nonnullNodeRuleGroup().values().stream()
739 .sorted((nrg1, nrg2) -> nrg1.getUuid().getValue().compareTo(nrg2.getUuid().getValue()))
740 .collect(Collectors.toList());
741 checkNodeRuleGroupForSwitchDSR(nrgList, client4NepUuid, networkNepUuid, nodeUuid);
744 nepsC = node.nonnullOwnedNodeEdgePoint().values().stream()
745 .filter(n -> n.getName().containsKey(new NameKey("NodeEdgePoint_C")))
746 .sorted((nep3, nep4) -> nep3.getUuid().getValue().compareTo(nep4.getUuid().getValue()))
747 .collect(Collectors.toList());
748 assertEquals("Mux-DSR node should have 1 NEP network", 1, nepsN.size());
749 assertEquals("Mux-DSR node should have 4 NEPs client", 4, nepsC.size());
750 OwnedNodeEdgePoint nep3 = nepsC.get(2);
751 Uuid client3NepUuid = new Uuid(
752 UUID.nameUUIDFromBytes((nodeId + "+DSR+XPDR1-CLIENT3").getBytes(Charset.forName("UTF-8")))
754 checkNepClient10G(nep3, client3NepUuid, "XPDR1-CLIENT3", "NodeEdgePoint_C");
756 OwnedNodeEdgePoint nep4 = nepsN.get(0);
757 Uuid networkNepUuid2 = new Uuid(
758 UUID.nameUUIDFromBytes((nodeId + "+DSR+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
760 checkNepNetworkODU4(nep4, networkNepUuid2, "XPDR1-NETWORK1", "NodeEdgePoint_N");
761 List<NodeRuleGroup> nrgList2 = node.nonnullNodeRuleGroup().values().stream()
762 .sorted((nrg1, nrg2) -> nrg1.getUuid().getValue().compareTo(nrg2.getUuid().getValue()))
763 .collect(Collectors.toList());
764 checkNodeRuleGroupForMuxDSR(nrgList2, client3NepUuid, networkNepUuid2, nodeUuid);
767 nepsC = node.nonnullOwnedNodeEdgePoint().values().stream()
768 .filter(n -> n.getName().containsKey(new NameKey("100G-tpdr")))
769 .sorted((nep5, nep6) -> nep5.getUuid().getValue().compareTo(nep6.getUuid().getValue()))
770 .collect(Collectors.toList());
771 assertEquals("Tpdr-DSR node should have 2 NEPs network", 2, nepsN.size());
772 assertEquals("Tpdr-DSR node should have 2 NEPs client", 2, nepsC.size());
773 OwnedNodeEdgePoint nep5 = nepsC.get(0);
774 Uuid client1NepUuid = new Uuid(
775 UUID.nameUUIDFromBytes((nodeId + "+DSR+XPDR1-CLIENT1").getBytes(Charset.forName("UTF-8")))
777 checkNepClient100GTpdr(nep5, client1NepUuid, "XPDR1-CLIENT1", "100G-tpdr");
779 OwnedNodeEdgePoint nep6 = nepsN.get(0);
780 Uuid networkNepUuid3 = new Uuid(
781 UUID.nameUUIDFromBytes((nodeId + "+DSR+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
783 checkNepNetworkODU4(nep6, networkNepUuid3, "XPDR1-NETWORK1", "NodeEdgePoint_N");
784 List<NodeRuleGroup> nrgList3 = node.nonnullNodeRuleGroup().values().stream()
785 .sorted((nrg1, nrg2) -> nrg1.getUuid().getValue().compareTo(nrg2.getUuid().getValue()))
786 .collect(Collectors.toList());
787 checkNodeRuleGroupForTpdrDSR(nrgList3, client1NepUuid, networkNepUuid3, nodeUuid);
795 private void checkOtsiNode(
796 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node node,
797 Uuid nodeUuid, String otsiNodeType, String nodeId) {
798 assertEquals("incorrect node uuid", nodeUuid, node.getUuid());
799 assertEquals("incorrect node name", nodeId, node.getName().get(new NameKey("otsi node name")).getValue());
800 assertEquals("administrative state should be UNLOCKED",
801 AdministrativeState.UNLOCKED, node.getAdministrativeState());
802 assertEquals("life-cycle state should be INSTALLED", LifecycleState.INSTALLED, node.getLifecycleState());
803 assertEquals("operational state should be ENABLED", OperationalState.ENABLED, node.getOperationalState());
804 assertEquals("value-name should be 'dsr/odu node name'",
805 "otsi node name", node.nonnullName().values().stream().findFirst().get().getValueName());
806 assertEquals("otsi node should manage a single protocol layer : PHOTONIC_MEDIA",
807 1, node.getLayerProtocolName().size());
808 assertEquals("otsi node should manage a single protocol layer : PHOTONIC_MEDIA",
809 LayerProtocolName.PHOTONICMEDIA, node.getLayerProtocolName().get(0));
810 List<OwnedNodeEdgePoint> nepsI = node.nonnullOwnedNodeEdgePoint().values().stream()
811 .filter(n -> n.getName().containsKey(new NameKey("iNodeEdgePoint")))
812 .sorted((nep1, nep2) -> nep1.getUuid().getValue().compareTo(nep2.getUuid().getValue()))
813 .collect(Collectors.toList());
814 List<OwnedNodeEdgePoint> nepsE = node.nonnullOwnedNodeEdgePoint().values().stream()
815 .filter(n -> n.getName().containsKey(new NameKey("eNodeEdgePoint")))
816 .sorted((nep1, nep2) -> nep1.getUuid().getValue().compareTo(nep2.getUuid().getValue()))
817 .collect(Collectors.toList());
818 switch (otsiNodeType) {
820 assertEquals("Switch-OTSi node should have 4 eNEPs", 4, nepsE.size());
821 assertEquals("Switch-OTSi node should have 4 iNEPs", 4, nepsI.size());
822 OwnedNodeEdgePoint nep1 = nepsI.get(1);
823 Uuid inepUuid = new Uuid(
824 UUID.nameUUIDFromBytes((nodeId + "+iOTSi+XPDR2-NETWORK2").getBytes(Charset.forName("UTF-8")))
826 checkNepOtsiNode(nep1, inepUuid, "XPDR2-NETWORK2", "iNodeEdgePoint");
827 OwnedNodeEdgePoint nep2 = nepsE.get(0);
828 Uuid enepUuid = new Uuid(
829 UUID.nameUUIDFromBytes((nodeId + "+eOTSi+XPDR2-NETWORK2").getBytes(Charset.forName("UTF-8")))
831 checkNepOtsiNode(nep2, enepUuid, "XPDR2-NETWORK2", "eNodeEdgePoint");
832 List<NodeRuleGroup> nrgList = node.nonnullNodeRuleGroup().values().stream()
833 .sorted((nrg1, nrg2) -> nrg1.getUuid().getValue().compareTo(nrg2.getUuid().getValue()))
834 .collect(Collectors.toList());
835 checkNodeRuleGroupForSwitchOTSi(nrgList, enepUuid, inepUuid, nodeUuid);
838 assertEquals("Mux-OTSi node should have 1 eNEP", 1, nepsE.size());
839 assertEquals("Mux-OTSi node should have 1 iNEPs", 1, nepsI.size());
840 OwnedNodeEdgePoint nep3 = nepsE.get(0);
841 Uuid enepUuid2 = new Uuid(
842 UUID.nameUUIDFromBytes((nodeId + "+eOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
844 checkNepOtsiNode(nep3, enepUuid2, "XPDR1-NETWORK1", "eNodeEdgePoint");
845 OwnedNodeEdgePoint nep4 = nepsI.get(0);
846 Uuid inepUuid2 = new Uuid(
847 UUID.nameUUIDFromBytes((nodeId + "+iOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
849 checkNepOtsiNode(nep4, inepUuid2, "XPDR1-NETWORK1", "iNodeEdgePoint");
850 List<NodeRuleGroup> nrgList2 = node.nonnullNodeRuleGroup().values().stream()
851 .sorted((nrg1, nrg2) -> nrg1.getUuid().getValue().compareTo(nrg2.getUuid().getValue()))
852 .collect(Collectors.toList());
853 checkNodeRuleGroupForMuxOTSi(nrgList2, enepUuid2, inepUuid2, nodeUuid);
856 assertEquals("Tpdr-OTSi node should have 2 eNEPs", 2, nepsE.size());
857 assertEquals("Tpdr-OTSi node should have 2 iNEPs", 2, nepsI.size());
858 OwnedNodeEdgePoint nep5 = nepsE.get(0);
859 Uuid enepUuid3 = new Uuid(
860 UUID.nameUUIDFromBytes((nodeId + "+eOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
862 checkNepOtsiNode(nep5, enepUuid3, "XPDR1-NETWORK1", "eNodeEdgePoint");
863 OwnedNodeEdgePoint nep6 = nepsI.get(0);
864 Uuid inepUuid3 = new Uuid(
865 UUID.nameUUIDFromBytes((nodeId + "+iOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
867 checkNepOtsiNode(nep6, inepUuid3, "XPDR1-NETWORK1", "iNodeEdgePoint");
868 List<NodeRuleGroup> nrgList3 = node.nonnullNodeRuleGroup().values().stream()
869 .sorted((nrg1, nrg2) -> nrg1.getUuid().getValue().compareTo(nrg2.getUuid().getValue()))
870 .collect(Collectors.toList());
871 checkNodeRuleGroupForTpdrOTSi(nrgList3, enepUuid3, inepUuid3, nodeUuid);
874 Iterator<OwnedNodeEdgePoint> nepIterator = node.nonnullOwnedNodeEdgePoint().values().iterator();
876 while (nepIterator.hasNext()) {
877 OwnedNodeEdgePoint nep = nepIterator.next();
878 Uuid nepUuid = new Uuid(
879 UUID.nameUUIDFromBytes((String.join("+", "roadm node", "nep", String.valueOf(count)))
880 .getBytes(Charset.forName("UTF-8"))).toString());
881 checkNepOtsiRdmNode(nep, nepUuid, new StringBuilder("NodeEdgePoint_").append(count).toString(),
882 "NodeEdgePoint name");
885 List<NodeRuleGroup> nrgList4 = node.nonnullNodeRuleGroup().values().stream()
886 .sorted((nrg1, nrg2) -> nrg1.getUuid().getValue().compareTo(nrg2.getUuid().getValue()))
887 .collect(Collectors.toList());
888 checkNodeRuleGroupForRdmInfra(nrgList4, count - 1);
893 private void checkNepClient10G(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName) {
894 assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid());
895 List<Name> nameList = new ArrayList<>(nep.nonnullName().values());
896 Name name = nameList.get(0);
897 assertEquals("value of client nep should be '" + portName + "'",
898 portName, name.getValue());
899 assertEquals("value-name of client nep for '" + portName + "' should be '" + nepName + "'",
900 nepName, name.getValueName());
901 assertEquals("Client nep should support 3 kind of cep",
902 3, nep.getSupportedCepLayerProtocolQualifier().size());
903 assertThat("client nep should support 3 kind of cep",
904 nep.getSupportedCepLayerProtocolQualifier(),
905 hasItems(ODUTYPEODU2.class, ODUTYPEODU2E.class, DIGITALSIGNALTYPE10GigELAN.class));
906 assertEquals("client nep should be of ETH protocol type", LayerProtocolName.ETH, nep.getLayerProtocolName());
907 checkCommonPartOfNep(nep, false);
910 private void checkNepNetworkODU4(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName) {
911 assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid());
912 List<Name> nameList = new ArrayList<>(nep.nonnullName().values());
913 Name name = nameList.get(0);
914 assertEquals("value of network nep should be '" + portName + "'",
915 portName, name.getValue());
916 assertEquals("value-name of network nep for '" + portName + "' should be '" + nepName + "'",
917 nepName, name.getValueName());
918 assertEquals("Network nep should support 1 kind of cep",
919 1, nep.getSupportedCepLayerProtocolQualifier().size());
920 assertThat("network nep should support 1 kind of cep",
921 nep.getSupportedCepLayerProtocolQualifier(),
922 hasItem(ODUTYPEODU4.class));
923 assertEquals("network nep should be of ODU protocol type", LayerProtocolName.ODU, nep.getLayerProtocolName());
924 checkCommonPartOfNep(nep, false);
927 private void checkNodeRuleGroupForTpdrDSR(List<NodeRuleGroup> nrgList, Uuid clientNepUuid, Uuid networkNepUuid,
929 assertEquals("transponder DSR should contain 2 node rule group", 2, nrgList.size());
930 for (NodeRuleGroup nodeRuleGroup : nrgList) {
931 assertEquals("each node-rule-group should contain 2 NEP for transponder DSR",
932 2, nodeRuleGroup.getNodeEdgePoint().size());
934 List<NodeEdgePoint> nodeEdgePointList = new ArrayList<>(nrgList.get(0).nonnullNodeEdgePoint().values());
935 assertThat("node-rule-group nb 1 should be between nep-client1 and nep-network1",
936 nodeEdgePointList.get(0).getNodeEdgePointUuid().getValue(),
937 either(containsString(networkNepUuid.getValue())).or(containsString(clientNepUuid.getValue())));
938 assertThat("node-rule-group nb 1 should be between nep-client1 and nep-network1",
939 nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(),
940 either(containsString(networkNepUuid.getValue())).or(containsString(clientNepUuid.getValue())));
941 assertEquals("node-rule-group nb 1 should be between nep-client1 and nep-network1 of the same node",
942 nodeEdgePointList.get(0).getNodeUuid(), nodeUuid);
943 assertEquals("node-rule-group nb 1 should be between nep-client1 and nep-network1 of the same node",
944 nodeEdgePointList.get(1).getNodeUuid(), nodeUuid);
945 List<Rule> rule = new ArrayList<>(nrgList.get(1).nonnullRule().values());
946 assertEquals("node-rule-group nb 1 should contain a single rule", 1, rule.size());
947 assertEquals("local-id of the rule should be 'forward'",
948 "forward", rule.get(0).getLocalId());
949 assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'",
950 ForwardingRule.MAYFORWARDACROSSGROUP, rule.get(0).getForwardingRule());
951 assertEquals("the rule type should be 'FORWARDING'",
952 RuleType.FORWARDING, rule.get(0).getRuleType());
955 private void checkNodeRuleGroupForMuxDSR(List<NodeRuleGroup> nrgList, Uuid clientNepUuid, Uuid networkNepUuid,
957 assertEquals("muxponder DSR should contain 4 node rule group", 4, nrgList.size());
958 for (NodeRuleGroup nodeRuleGroup : nrgList) {
959 assertEquals("each node-rule-group should contain 2 NEP for muxponder DSR",
960 2, nodeRuleGroup.getNodeEdgePoint().size());
962 List<NodeEdgePoint> nodeEdgePointList = new ArrayList<>(nrgList.get(0).nonnullNodeEdgePoint().values());
963 assertThat("node-rule-group nb 2 should be between nep-client4 and nep-network1",
964 nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(),
965 either(containsString(networkNepUuid.getValue())).or(containsString(clientNepUuid.getValue())));
966 assertThat("node-rule-group nb 2 should be between nep-client4 and nep-network1",
967 nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(),
968 either(containsString(networkNepUuid.getValue())).or(containsString(clientNepUuid.getValue())));
969 assertEquals("node-rule-group nb 2 should be between nep-client4 and nep-network1 of the same node",
970 nodeEdgePointList.get(0).getNodeUuid(), nodeUuid);
971 assertEquals("node-rule-group nb 2 should be between nep-client4 and nep-network1 of the same node",
972 nodeEdgePointList.get(1).getNodeUuid(), nodeUuid);
973 List<Rule> rule = new ArrayList<>(nrgList.get(1).nonnullRule().values());
974 assertEquals("node-rule-group nb 2 should contain a single rule", 1, rule.size());
975 assertEquals("local-id of the rule should be 'forward'",
976 "forward", rule.get(0).getLocalId());
977 assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'",
978 ForwardingRule.MAYFORWARDACROSSGROUP, rule.get(0).getForwardingRule());
979 assertEquals("the rule type should be 'FORWARDING'",
980 RuleType.FORWARDING, rule.get(0).getRuleType());
983 private void checkNodeRuleGroupForSwitchDSR(List<NodeRuleGroup> nrgList, Uuid clientNepUuid, Uuid networkNepUuid,
985 assertEquals("Switch-DSR should contain a single node rule group", 1, nrgList.size());
986 assertEquals("Switch-DSR node-rule-group should contain 8 NEP", 8, nrgList.get(0).getNodeEdgePoint().size());
987 List<NodeEdgePoint> nrg = nrgList.get(0).nonnullNodeEdgePoint().values().stream()
988 .sorted((nrg1, nrg2) -> nrg1.getNodeEdgePointUuid().getValue()
989 .compareTo(nrg2.getNodeEdgePointUuid().getValue()))
990 .collect(Collectors.toList());
991 assertEquals("in the sorted node-rule-group, nep number 2 should be XPDR2-NETWORK1",
992 networkNepUuid, nrg.get(4).getNodeEdgePointUuid());
993 assertEquals("in the sorted node-rule-group, nep number 6 should be XPDR2-CLIENT4",
994 clientNepUuid, nrg.get(3).getNodeEdgePointUuid());
995 assertEquals("any item of the node-rule-group should have the same nodeUuid",
996 nodeUuid, nrg.get(4).getNodeUuid());
997 assertEquals("any item of the node-rule-group should have the same nodeUuid",
998 nodeUuid, nrg.get(3).getNodeUuid());
1000 List<Rule> ruleList = new ArrayList<>(nrgList.get(0).nonnullRule().values());
1001 assertEquals("node-rule-group should contain a single rule", 1, ruleList.size());
1002 assertEquals("local-id of the rule should be 'forward'",
1003 "forward", ruleList.get(0).getLocalId());
1004 assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'",
1005 ForwardingRule.MAYFORWARDACROSSGROUP, ruleList.get(0).getForwardingRule());
1006 assertEquals("the rule type should be 'FORWARDING'",
1007 RuleType.FORWARDING, ruleList.get(0).getRuleType());
1010 private void checkNodeRuleGroupForRdmInfra(List<NodeRuleGroup> nrgList, int nbNeps) {
1011 assertEquals("RDM infra node - OTSi should contain a single node rule groups", 1, nrgList.size());
1013 List<NodeEdgePoint> nodeEdgePointList = new ArrayList<>(nrgList.get(0).getNodeEdgePoint().values());
1014 assertEquals("RDM infra node -rule-group should contain " + nbNeps + " NEP",
1015 nbNeps, nodeEdgePointList.size());
1017 assertNull("RDM infra node -rule-group should contain no NEP", nrgList.get(0).getNodeEdgePoint());
1019 List<Rule> ruleList = new ArrayList<>(nrgList.get(0).nonnullRule().values());
1020 assertEquals("node-rule-group should contain a single rule", 1, ruleList.size());
1021 assertEquals("local-id of the rule should be 'forward'",
1022 "forward", ruleList.get(0).getLocalId());
1023 assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'",
1024 ForwardingRule.MAYFORWARDACROSSGROUP, ruleList.get(0).getForwardingRule());
1025 assertEquals("the rule type should be 'FORWARDING'",
1026 RuleType.FORWARDING, ruleList.get(0).getRuleType());
1029 private void checkNodeRuleGroupForTpdrOTSi(List<NodeRuleGroup> nrgList, Uuid enepUuid, Uuid inepUuid,
1031 assertEquals("Tpdr-OTSi should contain two node rule groups", 2, nrgList.size());
1032 List<NodeEdgePoint> nodeEdgePointList = new ArrayList<>(nrgList.get(0).getNodeEdgePoint().values());
1033 assertEquals("Tpdr-OTSi node-rule-group should contain 2 NEP", 2, nodeEdgePointList.size());
1034 assertThat("Tpdr-OTSi node-rule-group should be between eNEP and iNEP of XPDR1-NETWORK1",
1035 nodeEdgePointList.get(0).getNodeEdgePointUuid().getValue(),
1036 either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue())));
1037 assertThat("Tpdr-OTSi node-rule-group should be between eNEP and iNEP of XPDR1-NETWORK1",
1038 nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(),
1039 either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue())));
1040 assertEquals("any item of the node-rule-group should have the same nodeUuid",
1041 nodeUuid, nodeEdgePointList.get(0).getNodeUuid());
1042 assertEquals("any item of the node-rule-group should have the same nodeUuid",
1043 nodeUuid, nodeEdgePointList.get(1).getNodeUuid());
1044 List<Rule> ruleList = new ArrayList<>(nrgList.get(0).nonnullRule().values());
1045 assertEquals("node-rule-group should contain a single rule", 1, ruleList.size());
1046 assertEquals("local-id of the rule should be 'forward'",
1047 "forward", ruleList.get(0).getLocalId());
1048 assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'",
1049 ForwardingRule.MAYFORWARDACROSSGROUP, ruleList.get(0).getForwardingRule());
1050 assertEquals("the rule type should be 'FORWARDING'",
1051 RuleType.FORWARDING, ruleList.get(0).getRuleType());
1054 private void checkNodeRuleGroupForMuxOTSi(List<NodeRuleGroup> nrgList, Uuid enepUuid, Uuid inepUuid,
1056 assertEquals("Mux-OTSi should contain a single node rule group", 1, nrgList.size());
1057 List<NodeEdgePoint> nodeEdgePointList = new ArrayList<>(nrgList.get(0).getNodeEdgePoint().values());
1058 assertEquals("Mux-OTSi node-rule-group should contain 2 NEP", 2, nodeEdgePointList.size());
1059 assertThat("Mux-OTSi node-rule-group should be between eNEP and iNEP of XPDR1-NETWORK1",
1060 nodeEdgePointList.get(0).getNodeEdgePointUuid().getValue(),
1061 either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue())));
1062 assertThat("Mux-OTSi node-rule-group should be between eNEP and iNEP of XPDR1-NETWORK1",
1063 nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(),
1064 either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue())));
1065 assertEquals("any item of the node-rule-group should have the same nodeUuid",
1066 nodeUuid, nodeEdgePointList.get(0).getNodeUuid());
1067 assertEquals("any item of the node-rule-group should have the same nodeUuid",
1068 nodeUuid, nodeEdgePointList.get(1).getNodeUuid());
1069 List<Rule> ruleList = new ArrayList<>(nrgList.get(0).nonnullRule().values());
1070 assertEquals("node-rule-group should contain a single rule", 1, ruleList.size());
1071 assertEquals("local-id of the rule should be 'forward'",
1072 "forward", ruleList.get(0).getLocalId());
1073 assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'",
1074 ForwardingRule.MAYFORWARDACROSSGROUP, ruleList.get(0).getForwardingRule());
1075 assertEquals("the rule type should be 'FORWARDING'",
1076 RuleType.FORWARDING, ruleList.get(0).getRuleType());
1079 private void checkNodeRuleGroupForSwitchOTSi(List<NodeRuleGroup> nrgList, Uuid enepUuid, Uuid inepUuid,
1081 assertEquals("Switch-OTSi should contain 4 node rule group", 4, nrgList.size());
1082 for (NodeRuleGroup nodeRuleGroup : nrgList) {
1083 assertEquals("each node-rule-group should contain 2 NEP for Switch-OTSi",
1084 2, nodeRuleGroup.getNodeEdgePoint().size());
1086 List<NodeEdgePoint> nodeEdgePointList1 = new ArrayList<>(nrgList.get(3).nonnullNodeEdgePoint().values());
1087 assertThat("Switch-OTSi node-rule-group nb 4 should be between eNEP and iNEP of XPDR2-NETWORK2",
1088 nodeEdgePointList1.get(0).getNodeEdgePointUuid().getValue(),
1089 either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue())));
1090 assertThat("Switch-OTSi node-rule-group nb 4 should be between eNEP and iNEP of XPDR2-NETWORK2",
1091 nodeEdgePointList1.get(1).getNodeEdgePointUuid().getValue(),
1092 either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue())));
1093 List<NodeEdgePoint> nodeEdgePointList0 = new ArrayList<>(nrgList.get(0).getNodeEdgePoint().values());
1094 assertEquals("any item of the node-rule-group should have the same nodeUuid",
1095 nodeUuid, nodeEdgePointList0.get(0).getNodeUuid());
1096 assertEquals("any item of the node-rule-group should have the same nodeUuid",
1097 nodeUuid, nodeEdgePointList0.get(1).getNodeUuid());
1098 List<Rule> ruleList0 = new ArrayList<>(nrgList.get(0).nonnullRule().values());
1099 assertEquals("node-rule-group should contain a single rule", 1, ruleList0.size());
1100 assertEquals("local-id of the rule should be 'forward'",
1101 "forward", ruleList0.get(0).getLocalId());
1102 assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'",
1103 ForwardingRule.MAYFORWARDACROSSGROUP, ruleList0.get(0).getForwardingRule());
1104 assertEquals("the rule type should be 'FORWARDING'",
1105 RuleType.FORWARDING, ruleList0.get(0).getRuleType());
1108 private void checkNepClient100GSwitch(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName) {
1109 assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid());
1110 List<Name> nameList = new ArrayList<>(nep.nonnullName().values());
1111 assertEquals("value of client nep should be '" + portName + "'",
1112 portName, nameList.get(0).getValue());
1113 assertEquals("value-name of client nep for '" + portName + "' should be '" + nepName + "'",
1114 nepName, nameList.get(0).getValueName());
1115 assertEquals("Client nep should support 2 kind of cep",
1116 2, nep.getSupportedCepLayerProtocolQualifier().size());
1117 assertThat("client nep should support 2 kind of cep",
1118 nep.getSupportedCepLayerProtocolQualifier(),
1119 hasItems(ODUTYPEODU4.class, DIGITALSIGNALTYPE100GigE.class));
1120 assertEquals("client nep should be of ETH protocol type", LayerProtocolName.ETH, nep.getLayerProtocolName());
1121 checkCommonPartOfNep(nep, false);
1124 private void checkNepClient100GTpdr(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName) {
1125 assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid());
1126 List<Name> nameList = new ArrayList<>(nep.nonnullName().values());
1127 assertEquals("value of client nep should be '" + portName + "'",
1128 portName, nameList.get(0).getValue());
1129 assertEquals("value-name of client nep for '" + portName + "' should be 100G-tpdr'",
1130 nepName, nameList.get(0).getValueName());
1131 assertEquals("Client nep should support 1 kind of cep",
1132 1, nep.getSupportedCepLayerProtocolQualifier().size());
1133 assertThat("client nep should support 2 kind of cep",
1134 nep.getSupportedCepLayerProtocolQualifier(),
1135 hasItems(DIGITALSIGNALTYPE100GigE.class));
1136 assertEquals("client nep should be of ETH protocol type", LayerProtocolName.ETH, nep.getLayerProtocolName());
1137 checkCommonPartOfNep(nep, false);
1140 private void checkNepOtsiNode(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName) {
1141 assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid());
1142 List<Name> nameList = new ArrayList<>(nep.nonnullName().values());
1143 assertEquals("value of OTSi nep should be '" + portName + "'",
1144 portName, nameList.get(0).getValue());
1145 assertEquals("value-name of OTSi nep should be '" + nepName + "'",
1146 nepName, nameList.get(0).getValueName());
1147 assertEquals("OTSi nep should support 2 kind of cep",
1148 2, nep.getSupportedCepLayerProtocolQualifier().size());
1149 assertThat("OTSi nep should support 2 kind of cep",
1150 nep.getSupportedCepLayerProtocolQualifier(),
1151 hasItems(PHOTONICLAYERQUALIFIEROMS.class, PHOTONICLAYERQUALIFIEROTSi.class));
1152 assertEquals("OTSi nep should be of PHOTONIC_MEDIA protocol type",
1153 LayerProtocolName.PHOTONICMEDIA, nep.getLayerProtocolName());
1154 assertEquals("OTSi nep should support one SIP", 1, nep.getMappedServiceInterfacePoint().size());
1155 checkCommonPartOfNep(nep, false);
1158 private void checkNepOtsiRdmNode(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName) {
1159 assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid());
1160 List<Name> nameList = new ArrayList<>(nep.nonnullName().values());
1161 assertEquals("value of OTSi nep should be '" + portName + "'",
1162 portName, nameList.get(0).getValue());
1163 assertEquals("value-name of OTSi nep should be '" + nepName + "'",
1164 nepName, nameList.get(0).getValueName());
1165 assertEquals("OTSi nep of RDM infra node should support only 1 kind of cep",
1166 1, nep.getSupportedCepLayerProtocolQualifier().size());
1167 assertThat("OTSi nep should support 2 kind of cep",
1168 nep.getSupportedCepLayerProtocolQualifier(),
1169 hasItems(PHOTONICLAYERQUALIFIEROMS.class));
1170 assertEquals("OTSi nep should be of PHOTONIC_MEDIA protocol type",
1171 LayerProtocolName.PHOTONICMEDIA, nep.getLayerProtocolName());
1172 assertEquals("OTSi nep of RDM infra should support no SIP", 0, nep.nonnullMappedServiceInterfacePoint().size());
1173 checkCommonPartOfNep(nep, true);
1176 private void checkCommonPartOfNep(OwnedNodeEdgePoint nep, boolean isRdm) {
1177 assertEquals("link port direction should be DIRECTIONAL",
1178 PortDirection.BIDIRECTIONAL, nep.getLinkPortDirection());
1179 assertEquals("administrative state should be UNLOCKED",
1180 AdministrativeState.UNLOCKED, nep.getAdministrativeState());
1181 assertEquals("termination state should be TERMINATED BIDIRECTIONAL",
1182 TerminationState.TERMINATEDBIDIRECTIONAL, nep.getTerminationState());
1183 assertEquals("life-cycle state should be INSTALLED", LifecycleState.INSTALLED, nep.getLifecycleState());
1185 assertEquals("client nep should support 1 SIP", 1, nep.getMappedServiceInterfacePoint().size());
1187 assertEquals("termination direction should be BIDIRECTIONAL",
1188 TerminationDirection.BIDIRECTIONAL, nep.getTerminationDirection());
1189 assertEquals("operational state of client nep should be ENABLED",
1190 OperationalState.ENABLED, nep.getOperationalState());
1191 assertEquals("link-port-role of client nep should be SYMMETRIC",
1192 PortRole.SYMMETRIC, nep.getLinkPortRole());
1195 private void checkTransitionalLink(Link link, Uuid node1Uuid, Uuid node2Uuid, String tp1, String tp2,
1196 String ietfNodeId) {
1197 Uuid linkUuid = new Uuid(UUID.nameUUIDFromBytes((ietfNodeId + "--" + tp1 + "--" + tp2)
1198 .getBytes(Charset.forName("UTF-8"))).toString());
1199 assertEquals("bad uuid for link between DSR node " + tp1 + " and iOTSI port " + tp2, linkUuid, link.getUuid());
1200 assertEquals("Available capacity unit should be GBPS",
1201 CapacityUnit.GBPS, link.getAvailableCapacity().getTotalSize().getUnit());
1202 assertEquals("Available capacity -total size value should be 100",
1203 Uint64.valueOf(100), link.getAvailableCapacity().getTotalSize().getValue());
1204 assertEquals("transitional link should be between 2 nodes of protocol layers ODU and PHOTONIC_MEDIA",
1205 2, link.getTransitionedLayerProtocolName().size());
1206 assertThat("transitional link should be between 2 nodes of protocol layers ODU and PHOTONIC_MEDIA",
1207 link.getTransitionedLayerProtocolName(),
1208 hasItems(LayerProtocolName.ODU.getName(), LayerProtocolName.PHOTONICMEDIA.getName()));
1209 assertEquals("transitional link should be BIDIRECTIONAL",
1210 ForwardingDirection.BIDIRECTIONAL, link.getDirection());
1211 List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210
1212 .link.NodeEdgePoint> nodeEdgePointList = new ArrayList<>(link.nonnullNodeEdgePoint().values());
1213 assertEquals("topology uuid should be the same for the two termination point of the link",
1214 topologyUuid, nodeEdgePointList.get(0).getTopologyUuid());
1215 assertEquals("topology uuid should be the same for the two termination point of the link",
1216 topologyUuid, nodeEdgePointList.get(1).getTopologyUuid());
1217 assertThat("transitional links should terminate on DSR node and Photonic node",
1218 nodeEdgePointList.get(0).getNodeUuid().getValue(),
1219 either(containsString(node1Uuid.getValue())).or(containsString(node2Uuid.getValue())));
1220 assertThat("transitional links should terminate on DSR node and Photonic node",
1221 nodeEdgePointList.get(1).getNodeUuid().getValue(),
1222 either(containsString(node1Uuid.getValue())).or(containsString(node2Uuid.getValue())));
1223 Uuid nep1Uuid = new Uuid(UUID.nameUUIDFromBytes(tp1.getBytes(Charset.forName("UTF-8"))).toString());
1224 Uuid nep2Uuid = new Uuid(UUID.nameUUIDFromBytes(tp2.getBytes(Charset.forName("UTF-8"))).toString());
1225 assertThat("transitional links should terminate on " + tp1 + " and " + tp2 + " neps",
1226 nodeEdgePointList.get(0).getNodeEdgePointUuid().getValue(),
1227 either(containsString(nep1Uuid.getValue())).or(containsString(nep2Uuid.getValue())));
1228 assertThat("transitional links should terminate on DSR node and Photonic node",
1229 nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(),
1230 either(containsString(nep1Uuid.getValue())).or(containsString(nep2Uuid.getValue())));
1233 private void checkOtnLink(Link link, Uuid node1Uuid, Uuid node2Uuid, Uuid tp1Uuid, Uuid tp2Uuid, Uuid linkUuid,
1235 assertEquals("bad name for the link", linkName, link.getName().get(new NameKey("otn link name")).getValue());
1236 assertEquals("bad uuid for link", linkUuid, link.getUuid());
1237 assertEquals("Available capacity unit should be MBPS",
1238 CapacityUnit.MBPS, link.getAvailableCapacity().getTotalSize().getUnit());
1239 String prefix = linkName.split("-")[0];
1240 if ("OTU4".equals(prefix)) {
1241 assertEquals("Available capacity -total size value should be 0",
1242 Uint64.valueOf(0), link.getAvailableCapacity().getTotalSize().getValue());
1243 } else if ("ODU4".equals(prefix)) {
1244 assertEquals("Available capacity -total size value should be 100 000",
1245 Uint64.valueOf(100000), link.getAvailableCapacity().getTotalSize().getValue());
1247 assertEquals("Total capacity unit should be GBPS",
1248 CapacityUnit.GBPS, link.getTotalPotentialCapacity().getTotalSize().getUnit());
1249 assertEquals("Total capacity -total size value should be 100",
1250 Uint64.valueOf(100), link.getTotalPotentialCapacity().getTotalSize().getValue());
1251 if ("OTU4".equals(prefix)) {
1252 assertEquals("otn link should be between 2 nodes of protocol layers PHOTONIC_MEDIA",
1253 LayerProtocolName.PHOTONICMEDIA.getName(), link.getLayerProtocolName().get(0).getName());
1254 } else if ("ODU4".equals(prefix)) {
1255 assertEquals("otn link should be between 2 nodes of protocol layers ODU",
1256 LayerProtocolName.ODU.getName(), link.getLayerProtocolName().get(0).getName());
1258 assertEquals("otn tapi link should be BIDIRECTIONAL",
1259 ForwardingDirection.BIDIRECTIONAL, link.getDirection());
1260 List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210
1261 .link.NodeEdgePoint> nodeEdgePointList = new ArrayList<>(link.nonnullNodeEdgePoint().values());
1262 assertEquals("topology uuid should be the same for the two termination point of the link",
1263 topologyUuid, nodeEdgePointList.get(0).getTopologyUuid());
1264 assertEquals("topology uuid should be the same for the two termination point of the link",
1265 topologyUuid, nodeEdgePointList.get(1).getTopologyUuid());
1266 assertThat("otn links should terminate on two distinct nodes",
1267 nodeEdgePointList.get(0).getNodeUuid().getValue(),
1268 either(containsString(node1Uuid.getValue())).or(containsString(node2Uuid.getValue())));
1269 assertThat("otn links should terminate on two distinct nodes",
1270 nodeEdgePointList.get(1).getNodeUuid().getValue(),
1271 either(containsString(node1Uuid.getValue())).or(containsString(node2Uuid.getValue())));
1272 assertThat("otn links should terminate on two distinct tps",
1273 nodeEdgePointList.get(0).getNodeEdgePointUuid().getValue(),
1274 either(containsString(tp1Uuid.getValue())).or(containsString(tp2Uuid.getValue())));
1275 assertThat("otn links should terminate on two distinct tps",
1276 nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(),
1277 either(containsString(tp1Uuid.getValue())).or(containsString(tp2Uuid.getValue())));
1278 assertEquals("operational state should be ENABLED",
1279 OperationalState.ENABLED, link.getOperationalState());
1280 assertEquals("administrative state should be UNLOCKED",
1281 AdministrativeState.UNLOCKED, link.getAdministrativeState());
1284 private void checkOmsLink(Link link, Uuid node1Uuid, Uuid node2Uuid, Uuid tp1Uuid, Uuid tp2Uuid, Uuid linkUuid,
1286 assertEquals("bad name for the link", linkName, link.getName().get(new NameKey("OMS link name")).getValue());
1287 assertEquals("bad uuid for link", linkUuid, link.getUuid());
1288 assertEquals("oms link should be between 2 nodes of protocol layers PHOTONIC_MEDIA",
1289 LayerProtocolName.PHOTONICMEDIA.getName(), link.getLayerProtocolName().get(0).getName());
1290 assertEquals("otn tapi link should be BIDIRECTIONAL",
1291 ForwardingDirection.BIDIRECTIONAL, link.getDirection());
1292 List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210
1293 .link.NodeEdgePoint> nodeEdgePointList = new ArrayList<>(link.nonnullNodeEdgePoint().values());
1294 assertEquals("oms link should be between 2 neps",2 , nodeEdgePointList.size());
1295 assertEquals("topology uuid should be the same for the two termination point of the link",
1296 topologyUuid, nodeEdgePointList.get(0).getTopologyUuid());
1297 assertEquals("topology uuid should be the same for the two termination point of the link",
1298 topologyUuid, nodeEdgePointList.get(1).getTopologyUuid());
1299 assertThat("oms links should terminate on two distinct nodes",
1300 nodeEdgePointList.get(0).getNodeUuid().getValue(),
1301 either(containsString(node1Uuid.getValue())).or(containsString(node2Uuid.getValue())));
1302 assertThat("oms links should terminate on two distinct nodes",
1303 nodeEdgePointList.get(1).getNodeUuid().getValue(),
1304 either(containsString(node1Uuid.getValue())).or(containsString(node2Uuid.getValue())));
1305 assertThat("oms links should terminate on two distinct tps",
1306 nodeEdgePointList.get(0).getNodeEdgePointUuid().getValue(),
1307 either(containsString(tp1Uuid.getValue())).or(containsString(tp2Uuid.getValue())));
1308 assertThat("oms links should terminate on two distinct tps",
1309 nodeEdgePointList.get(1).getNodeEdgePointUuid().getValue(),
1310 either(containsString(tp1Uuid.getValue())).or(containsString(tp2Uuid.getValue())));
1313 private Node changeTerminationPointState(Node initialNode, String tpid, AdminStates admin, State oper) {
1314 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1Builder tpdr1Bldr
1315 = new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1Builder(
1316 initialNode.augmentation(Node1.class));
1317 Map<TerminationPointKey, TerminationPoint> tps = new HashMap<>(tpdr1Bldr.getTerminationPoint());
1318 TerminationPointBuilder tpBldr = new TerminationPointBuilder(
1319 tps.get(new TerminationPointKey(new TpId(tpid))));
1320 TerminationPoint1Builder tp1Bldr = new TerminationPoint1Builder(tpBldr.augmentation(TerminationPoint1.class));
1321 tp1Bldr.setAdministrativeState(admin)
1322 .setOperationalState(oper);
1323 tpBldr.addAugmentation(tp1Bldr.build());
1324 tps.replace(tpBldr.key(), tpBldr.build());
1325 tpdr1Bldr.setTerminationPoint(tps);
1326 return new NodeBuilder(initialNode).addAugmentation(tpdr1Bldr.build()).build();
1329 private org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network
1330 .Link changeOtnLinkState(
1331 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network
1332 .Link initiallink, AdminStates admin, State oper) {
1334 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network
1335 .LinkBuilder linkBldr = new
1336 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network
1337 .LinkBuilder(initiallink);
1338 Link1Builder link1Bldr = new Link1Builder(linkBldr.augmentation(Link1.class));
1339 link1Bldr.setAdministrativeState(admin)
1340 .setOperationalState(oper);
1341 linkBldr.addAugmentation(link1Bldr.build());
1342 return linkBldr.build();