From: Gilles Thouenon Date: Sat, 13 Jun 2020 14:24:02 +0000 (+0200) Subject: UUID stabilization in TAPI Topology abstraction X-Git-Tag: 2.0.0~94 X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=transportpce.git;a=commitdiff_plain;h=227a39b7f2adf915fc6b8dc5277c1e8fe0b2b4ed UUID stabilization in TAPI Topology abstraction - make UUID generation deterministics instead of being randomly generated - update existing JUnit tests taking into acount this evolution - add new JUnit test to validate the TAPI abstraction for OTN topology TRNSPRTPCE-186 Signed-off-by: Gilles Thouenon Co-authored-by: Christophe Betoule Change-Id: Ia8541282799c10c5de0ad4bb263eb33ec6eb87a1 --- diff --git a/tapi/src/main/java/org/opendaylight/transportpce/tapi/topology/ConvertORTopoObjectToTapiTopoObject.java b/tapi/src/main/java/org/opendaylight/transportpce/tapi/topology/ConvertORTopoObjectToTapiTopoObject.java index 657ed265f..8c760b236 100644 --- a/tapi/src/main/java/org/opendaylight/transportpce/tapi/topology/ConvertORTopoObjectToTapiTopoObject.java +++ b/tapi/src/main/java/org/opendaylight/transportpce/tapi/topology/ConvertORTopoObjectToTapiTopoObject.java @@ -7,6 +7,7 @@ */ package org.opendaylight.transportpce.tapi.topology; +import java.nio.charset.Charset; import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; @@ -106,7 +107,8 @@ public class ConvertORTopoObjectToTapiTopoObject { public void convertNode() { // node creation [DSR/ODU] LOG.info("creation of a DSR/ODU node"); - Uuid nodeUuid = new Uuid(UUID.randomUUID().toString()); + Uuid nodeUuid = new Uuid(UUID.nameUUIDFromBytes((this.ietfNodeId + PLUS_DSR).getBytes(Charset.forName("UTF-8"))) + .toString()); this.uuidMap.put(this.ietfNodeId + PLUS_DSR, nodeUuid); List dsrNodeNames = Arrays.asList( new NameBuilder() @@ -121,7 +123,8 @@ public class ConvertORTopoObjectToTapiTopoObject { // node creation [otsi] LOG.info("creation of an OTSi node"); - nodeUuid = new Uuid(UUID.randomUUID().toString()); + nodeUuid = new Uuid(UUID.nameUUIDFromBytes((this.ietfNodeId + OT_SI).getBytes(Charset.forName("UTF-8"))) + .toString()); this.uuidMap.put(this.ietfNodeId + OT_SI, nodeUuid); List otsiNodeNames = Arrays.asList( new NameBuilder() @@ -179,7 +182,9 @@ public class ConvertORTopoObjectToTapiTopoObject { nodeUuid = this.uuidMap.get(this.ietfNodeId + OT_SI); // iNep creation on otsi node for (int i = 0; i < oorNetworkPortList.size(); i++) { - Uuid nepUuid1 = new Uuid(UUID.randomUUID().toString()); + Uuid nepUuid1 = new Uuid(UUID.nameUUIDFromBytes( + (I_OT_SI + oorNetworkPortList.get(i).getTpId().getValue()).getBytes(Charset.forName("UTF-8"))) + .toString()); this.uuidMap.put(I_OT_SI + oorNetworkPortList.get(i).getTpId().getValue(), nepUuid1); List onedNames = Arrays.asList( new NameBuilder() @@ -193,7 +198,9 @@ public class ConvertORTopoObjectToTapiTopoObject { } // eNep creation on otsi node for (int i = 0; i < oorNetworkPortList.size(); i++) { - Uuid nepUuid2 = new Uuid(UUID.randomUUID().toString()); + Uuid nepUuid2 = new Uuid(UUID.nameUUIDFromBytes( + (E_OT_SI + oorNetworkPortList.get(i).getTpId().getValue()).getBytes(Charset.forName("UTF-8"))) + .toString()); this.uuidMap.put(E_OT_SI + oorNetworkPortList.get(i).getTpId().getValue(), nepUuid2); List onedNames = Arrays.asList( new NameBuilder() @@ -207,6 +214,7 @@ public class ConvertORTopoObjectToTapiTopoObject { } // create NodeRuleGroup for (TerminationPoint tp : this.oorNetworkPortList) { + int count = 1; List nepList = new ArrayList<>(); org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.rule.group @@ -226,11 +234,13 @@ public class ConvertORTopoObjectToTapiTopoObject { nepList.add(inep); nepList.add(enep); NodeRuleGroup nodeRuleGroup = new NodeRuleGroupBuilder() - .setUuid(new Uuid(UUID.randomUUID().toString())) + .setUuid(new Uuid( + UUID.nameUUIDFromBytes(("node rule group " + count).getBytes(Charset.forName("UTF-8"))).toString())) .setRule(ruleList) .setNodeEdgePoint(nepList) .build(); nodeRuleGroupList.add(nodeRuleGroup); + count++; } return nodeUuid; } @@ -241,7 +251,8 @@ public class ConvertORTopoObjectToTapiTopoObject { nodeUuid = this.uuidMap.get(this.ietfNodeId + PLUS_DSR); // client nep creation on DSR/ODU node for (int i = 0; i < oorClientPortList.size(); i++) { - Uuid nepUuid = new Uuid(UUID.randomUUID().toString()); + Uuid nepUuid = new Uuid(UUID.nameUUIDFromBytes((DSR_PLUS + oorClientPortList.get(i).getTpId().getValue()) + .getBytes(Charset.forName("UTF-8"))).toString()); this.uuidMap.put(DSR_PLUS + oorClientPortList.get(i).getTpId().getValue(), nepUuid); List onedNames = Arrays.asList( new NameBuilder() @@ -255,7 +266,8 @@ public class ConvertORTopoObjectToTapiTopoObject { } // network nep creation on DSR/ODU node for (int i = 0; i < oorNetworkPortList.size(); i++) { - Uuid nepUuid = new Uuid(UUID.randomUUID().toString()); + Uuid nepUuid = new Uuid(UUID.nameUUIDFromBytes((DSR_PLUS + oorNetworkPortList.get(i).getTpId().getValue()) + .getBytes(Charset.forName("UTF-8"))).toString()); this.uuidMap.put(DSR_PLUS + oorNetworkPortList.get(i).getTpId().getValue(), nepUuid); List onedNames = Arrays.asList( new NameBuilder() @@ -269,6 +281,7 @@ public class ConvertORTopoObjectToTapiTopoObject { } // create NodeRuleGroup for (NonBlockingList nbl : this.oorOduSwitchingPool.getNonBlockingList()) { + int count = 1; List nepList = new ArrayList<>(); for (TpId tp : nbl.getTpList()) { @@ -282,11 +295,13 @@ public class ConvertORTopoObjectToTapiTopoObject { nepList.add(nep); } NodeRuleGroup nodeRuleGroup = new NodeRuleGroupBuilder() - .setUuid(new Uuid(UUID.randomUUID().toString())) + .setUuid(new Uuid( + UUID.nameUUIDFromBytes(("node rule group " + count).getBytes(Charset.forName("UTF-8"))).toString())) .setRule(ruleList) .setNodeEdgePoint(nepList) .build(); nodeRuleGroupList.add(nodeRuleGroup); + count++; } return nodeUuid; } @@ -372,7 +387,9 @@ public class ConvertORTopoObjectToTapiTopoObject { .build(); nepList.add(destNep); LinkBuilder transiLinkBldr = new LinkBuilder() - .setUuid(new Uuid(UUID.randomUUID().toString())) + .setUuid(new Uuid( + UUID.nameUUIDFromBytes((sourceKey + "--" + destKey).getBytes(Charset.forName("UTF-8"))) + .toString())) .setTransitionedLayerProtocolName(Arrays.asList(LayerProtocolName.ODU.getName(), LayerProtocolName.PHOTONICMEDIA.getName())) .setNodeEdgePoint(nepList) diff --git a/tapi/src/main/java/org/opendaylight/transportpce/tapi/topology/TapiTopologyImpl.java b/tapi/src/main/java/org/opendaylight/transportpce/tapi/topology/TapiTopologyImpl.java index 59773c083..0943a8961 100644 --- a/tapi/src/main/java/org/opendaylight/transportpce/tapi/topology/TapiTopologyImpl.java +++ b/tapi/src/main/java/org/opendaylight/transportpce/tapi/topology/TapiTopologyImpl.java @@ -9,6 +9,7 @@ package org.opendaylight.transportpce.tapi.topology; import com.google.common.util.concurrent.FluentFuture; import com.google.common.util.concurrent.ListenableFuture; +import java.nio.charset.Charset; import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; @@ -80,6 +81,8 @@ import org.slf4j.LoggerFactory; public class TapiTopologyImpl implements TapiTopologyService { private static final Logger LOG = LoggerFactory.getLogger(TapiTopologyImpl.class); + private static final String ETH_TOPO = "Ethernet Topology"; + private static final String T0_MULTI_LAYER_TOPO = "T0 - Multi-layer topology"; private final DataBroker dataBroker; public TapiTopologyImpl(DataBroker dataBroker) { @@ -179,8 +182,8 @@ public class TapiTopologyImpl implements TapiTopologyService { List goodTpList = extractGoodTpList(clientPortMap); // tapi topology creation List names = new ArrayList<>(); - names.add(new NameBuilder().setValue("topo ethernet").setValueName("Topo Name").build()); - Uuid uuid = new Uuid(UUID.randomUUID().toString()); + names.add(new NameBuilder().setValue(ETH_TOPO).setValueName("Topo Name").build()); + Uuid uuid = new Uuid(UUID.nameUUIDFromBytes(ETH_TOPO.getBytes(Charset.forName("UTF-8"))).toString()); List tapiNodeList = new ArrayList<>(); tapiNodeList.add(createTapiNode(goodTpList)); @@ -223,7 +226,8 @@ public class TapiTopologyImpl implements TapiTopologyService { new ArrayList<>(); List tapiLinkList = new ArrayList<>(); - Uuid topoUuid = new Uuid(UUID.randomUUID().toString()); + Uuid topoUuid = new Uuid(UUID.nameUUIDFromBytes(T0_MULTI_LAYER_TOPO.getBytes(Charset.forName("UTF-8"))) + .toString()); for (Node node : otnNodeList) { ConvertORTopoObjectToTapiTopoObject tapiFactory = new ConvertORTopoObjectToTapiTopoObject(node, null, topoUuid); @@ -232,7 +236,7 @@ public class TapiTopologyImpl implements TapiTopologyService { tapiLinkList.addAll(tapiFactory.getTapiLinks()); } return new TopologyBuilder() - .setName(Arrays.asList(new NameBuilder().setValue("T0 - Multi-layer topology") + .setName(Arrays.asList(new NameBuilder().setValue(T0_MULTI_LAYER_TOPO) .setValueName("TAPI Topology Name").build())) .setUuid(topoUuid) .setNode(tapiNodeList) @@ -264,7 +268,7 @@ public class TapiTopologyImpl implements TapiTopologyService { private org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node createTapiNode(List< String> tpList) { List names = new ArrayList<>(); - Name name = new NameBuilder().setValueName("node name").setValue("TapiNode1").build(); + Name name = new NameBuilder().setValueName("node name").setValue("TAPI Ethernet Node").build(); names.add(name); List layerProtocols = new ArrayList<>(); layerProtocols.add(LayerProtocolName.ETH); @@ -272,7 +276,9 @@ public class TapiTopologyImpl implements TapiTopologyService { for (int i = 0; i < tpList.size(); i++) { List onedNames = new ArrayList<>(); onedNames.add(new NameBuilder().setValueName("OwnedNodeEdgePoint " + i).setValue(tpList.get(i)).build()); - OwnedNodeEdgePoint onep = new OwnedNodeEdgePointBuilder().setUuid(new Uuid(UUID.randomUUID().toString())) + OwnedNodeEdgePoint onep = new OwnedNodeEdgePointBuilder() + .setUuid(new Uuid(UUID.nameUUIDFromBytes(("OwnedNodeEdgePoint " + i).getBytes(Charset.forName("UTF-8"))) + .toString())) .setLayerProtocolName(LayerProtocolName.ETH).setMappedServiceInterfacePoint(createSIP(1)) .setLinkPortDirection(PortDirection.BIDIRECTIONAL).setLinkPortRole(PortRole.SYMMETRIC) .setAdministrativeState(AdministrativeState.UNLOCKED).setOperationalState(OperationalState.ENABLED) @@ -283,7 +289,8 @@ public class TapiTopologyImpl implements TapiTopologyService { } return new NodeBuilder() - .setUuid(new Uuid(UUID.randomUUID().toString())) + .setUuid(new Uuid(UUID.nameUUIDFromBytes(name.getValue().getBytes(Charset.forName("UTF-8"))) + .toString())) .setName(names).setLayerProtocolName(layerProtocols) .setAdministrativeState(AdministrativeState.UNLOCKED) .setOperationalState(OperationalState.ENABLED) diff --git a/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/TapiTopologyImplTest.java b/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/TapiTopologyImplTest.java index eec94e321..86edb516b 100644 --- a/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/TapiTopologyImplTest.java +++ b/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/TapiTopologyImplTest.java @@ -7,26 +7,62 @@ */ package org.opendaylight.transportpce.tapi.topology; +import static org.hamcrest.CoreMatchers.containsString; +import static org.hamcrest.CoreMatchers.either; +import static org.hamcrest.CoreMatchers.hasItem; +import static org.hamcrest.CoreMatchers.hasItems; +import static org.hamcrest.MatcherAssert.assertThat; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; import com.google.common.util.concurrent.ListenableFuture; import com.google.common.util.concurrent.ListeningExecutorService; import com.google.common.util.concurrent.MoreExecutors; +import java.nio.charset.Charset; +import java.util.List; +import java.util.UUID; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutionException; import java.util.concurrent.Executors; +import java.util.stream.Collectors; import org.eclipse.jdt.annotation.Nullable; -import org.junit.Before; +import org.junit.BeforeClass; import org.junit.Test; import org.opendaylight.transportpce.common.DataStoreContext; import org.opendaylight.transportpce.common.DataStoreContextImpl; +import org.opendaylight.transportpce.common.InstanceIdentifiers; +import org.opendaylight.transportpce.common.NetworkUtils; import org.opendaylight.transportpce.tapi.utils.TopologyDataUtils; import org.opendaylight.transportpce.test.AbstractTest; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.AdministrativeState; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.CapacityUnit; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.ForwardingDirection; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.LayerProtocolName; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.LifecycleState; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.OperationalState; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.PortDirection; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.PortRole; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.TerminationDirection; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.TerminationState; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.Uuid; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.dsr.rev181210.DIGITALSIGNALTYPE100GigE; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.dsr.rev181210.DIGITALSIGNALTYPE10GigELAN; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.odu.rev181210.ODUTYPEODU2E; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.odu.rev181210.ODUTYPEODU4; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.photonic.media.rev181210.PHOTONICLAYERQUALIFIEROMS; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.photonic.media.rev181210.PHOTONICLAYERQUALIFIEROTSi; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.ForwardingRule; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.GetTopologyDetailsInput; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.GetTopologyDetailsOutput; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.RuleType; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.get.topology.details.output.Topology; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.NodeRuleGroup; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.OwnedNodeEdgePoint; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.rule.group.NodeEdgePoint; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Link; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node; import org.opendaylight.yangtools.yang.common.RpcResult; +import org.opendaylight.yangtools.yang.common.Uint64; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -34,24 +70,27 @@ import org.slf4j.LoggerFactory; public class TapiTopologyImplTest extends AbstractTest { private static final Logger LOG = LoggerFactory.getLogger(TapiTopologyImplTest.class); - private ListeningExecutorService executorService; - private CountDownLatch endSignal; + private static ListeningExecutorService executorService; + private static CountDownLatch endSignal; private static final int NUM_THREADS = 3; - private DataStoreContext dataStoreContextUtil; + private static DataStoreContext dataStoreContextUtil; - @Before - public void setUp() throws InterruptedException { + @BeforeClass + public static void setUp() throws InterruptedException { executorService = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(NUM_THREADS)); endSignal = new CountDownLatch(1); dataStoreContextUtil = new DataStoreContextImpl(); - TopologyDataUtils.writeTopologyFromFileToDatastore(dataStoreContextUtil); + TopologyDataUtils.writeTopologyFromFileToDatastore(dataStoreContextUtil, + TopologyDataUtils.OPENROADM_TOPOLOGY_FILE, InstanceIdentifiers.OVERLAY_NETWORK_II); + TopologyDataUtils.writeTopologyFromFileToDatastore(dataStoreContextUtil, + TopologyDataUtils.OTN_TOPOLOGY_FILE, InstanceIdentifiers.OTN_NETWORK_II); TopologyDataUtils.writePortmappingFromFileToDatastore(dataStoreContextUtil); LOG.info("setup done"); } @Test - public void getTopologyDetailsWhenSuccessful() throws ExecutionException, InterruptedException { - GetTopologyDetailsInput input = TopologyDataUtils.buildGetTopologyDetailsInput(); + public void getTopologyDetailsForOpenroadmTopologyWhenSuccessful() throws ExecutionException, InterruptedException { + GetTopologyDetailsInput input = TopologyDataUtils.buildGetTopologyDetailsInput(NetworkUtils.OVERLAY_NETWORK_ID); TapiTopologyImpl tapiTopoImpl = new TapiTopologyImpl(dataStoreContextUtil.getDataBroker()); ListenableFuture> result = tapiTopoImpl.getTopologyDetails(input); result.addListener(new Runnable() { @@ -64,13 +103,376 @@ public class TapiTopologyImplTest extends AbstractTest { RpcResult rpcResult = result.get(); @Nullable Topology topology = rpcResult.getResult().getTopology(); - LOG.info("topo TAPI returned = {}", topology); + assertNotNull("Topology should not be null", topology); + assertEquals("Nodes list size should be 1", 1, topology.getNode().size()); + assertEquals("Node name should be TAPI Ethernet Node", + "TAPI Ethernet Node", topology.getNode().get(0).getName().get(0).getValue()); + Uuid topoUuid = new Uuid(UUID.nameUUIDFromBytes("Ethernet Topology".getBytes()).toString()); + Uuid nodeUuid = new Uuid(UUID.nameUUIDFromBytes("TAPI Ethernet Node".getBytes()).toString()); + assertEquals("incorrect topology uuid", topoUuid, topology.getUuid()); + assertEquals("incorrect node uuid", nodeUuid, topology.getNode().get(0).getUuid()); + Uuid onep1Uuid = new Uuid(UUID.nameUUIDFromBytes("OwnedNodeEdgePoint 0".getBytes()).toString()); + Uuid onep2Uuid = new Uuid(UUID.nameUUIDFromBytes("OwnedNodeEdgePoint 1".getBytes()).toString()); + assertEquals("incorrect uuid for nep1", + onep1Uuid, topology.getNode().get(0).getOwnedNodeEdgePoint().get(0).getUuid()); + assertEquals("incorrect uuid for nep1", + onep2Uuid, topology.getNode().get(0).getOwnedNodeEdgePoint().get(1).getUuid()); + } + @Test + public void getTopologyDetailsForOtnTopologyWhenSuccessful() throws ExecutionException, InterruptedException { + GetTopologyDetailsInput input = TopologyDataUtils.buildGetTopologyDetailsInput(NetworkUtils.OTN_NETWORK_ID); + TapiTopologyImpl tapiTopoImpl = new TapiTopologyImpl(dataStoreContextUtil.getDataBroker()); + ListenableFuture> result = tapiTopoImpl.getTopologyDetails(input); + result.addListener(new Runnable() { + @Override + public void run() { + endSignal.countDown(); + } + }, executorService); + endSignal.await(); + RpcResult rpcResult = result.get(); + @Nullable + Topology topology = rpcResult.getResult().getTopology(); assertNotNull("Topology should not be null", topology); - assertEquals("Nodes list size should be 1", - 1, topology.getNode().size()); - assertEquals("Node name should be TapiNode1", - "TapiNode1", topology.getNode().get(0).getName().get(0).getValue()); + assertEquals("Node list size should be 4", 4, topology.getNode().size()); + assertEquals("Link list size should be 5", 5, topology.getLink().size()); + Uuid topoUuid = new Uuid(UUID.nameUUIDFromBytes("T0 - Multi-layer topology".getBytes()).toString()); + assertEquals("incorrect topology uuid", topoUuid, topology.getUuid()); + assertEquals("topology name should be T0 - Multi-layer topology", + "T0 - Multi-layer topology", + topology.getName().get(0).getValue()); + + List nodes = topology.getNode().stream() + .sorted((n1,n2) -> n1.getUuid().getValue().compareTo(n2.getUuid().getValue())) + .collect(Collectors.toList()); + Uuid node1Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+DSR".getBytes(Charset.forName("UTF-8"))) + .toString()); + checkDsrNode(nodes.get(0), node1Uuid, false); + Uuid node2Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR2+DSR".getBytes(Charset.forName("UTF-8"))) + .toString()); + checkDsrNode(nodes.get(1), node2Uuid, true); + Uuid node3Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+OTSi".getBytes(Charset.forName("UTF-8"))) + .toString()); + checkOtsiNode(nodes.get(2), node3Uuid, false); + Uuid node4Uuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR2+OTSi".getBytes(Charset.forName("UTF-8"))) + .toString()); + checkOtsiNode(nodes.get(3), node4Uuid, true); + + List links = topology.getLink().stream() + .sorted((l1, l2) -> l1.getUuid().getValue().compareTo(l2.getUuid().getValue())) + .collect(Collectors.toList()); + checkTransitionalLink(links.get(0), topoUuid, node1Uuid, node3Uuid, "DSR+XPDR1-NETWORK1", + "iOTSi+XPDR1-NETWORK1"); + checkTransitionalLink(links.get(1), topoUuid, node2Uuid, node4Uuid, "DSR+XPDR2-NETWORK1", + "iOTSi+XPDR2-NETWORK1"); } -} + private void checkDsrNode(Node node, Uuid nodeUuid, boolean isSwitch) { + assertEquals("incorrect node uuid", nodeUuid, node.getUuid()); + assertEquals("administrative state should be UNLOCKED", + AdministrativeState.UNLOCKED, node.getAdministrativeState()); + assertEquals("life-cycle state should be INSTALLED", LifecycleState.INSTALLED, node.getLifecycleState()); + assertEquals("operational state should be ENABLED", OperationalState.ENABLED, node.getOperationalState()); + assertEquals("value-name should be 'dsr/odu node name'", + "dsr/odu node name", node.getName().get(0).getValueName()); + assertEquals("dsr node should manage 2 protocol layers : dsr and odu", + 2, node.getLayerProtocolName().size()); + assertThat("dsr node should manage 2 protocol layers : dsr and odu", + node.getLayerProtocolName(), hasItems(LayerProtocolName.DSR, LayerProtocolName.ODU)); + List neps = node.getOwnedNodeEdgePoint().stream() + .sorted((nep1, nep2) -> nep1.getUuid().getValue().compareTo(nep2.getUuid().getValue())) + .collect(Collectors.toList()); + if (isSwitch) { + assertEquals("Switch-DSR node should have 8 NEPs", 8, neps.size()); + OwnedNodeEdgePoint nep1 = neps.get(5); + Uuid client4NepUuid = new Uuid( + UUID.nameUUIDFromBytes("DSR+XPDR2-CLIENT4".getBytes(Charset.forName("UTF-8"))).toString()); + checkNepClient100G(nep1, client4NepUuid, "XPDR2-CLIENT4", "NodeEdgePoint_C4"); + OwnedNodeEdgePoint nep2 = neps.get(1); + Uuid networkNepUuid = new Uuid( + UUID.nameUUIDFromBytes("DSR+XPDR2-NETWORK1".getBytes(Charset.forName("UTF-8"))).toString()); + checkNepNetworkODU4(nep2, networkNepUuid, "XPDR2-NETWORK1", "NodeEdgePoint_N1"); + List nrgList = node.getNodeRuleGroup().stream() + .sorted((nrg1, nrg2) -> nrg1.getUuid().getValue().compareTo(nrg2.getUuid().getValue())) + .collect(Collectors.toList()); + checkNodeRuleGroupForSwitchDSR(nrgList, client4NepUuid, networkNepUuid, nodeUuid); + } else { + assertEquals("Mux-DSR node should have 5 NEPs", 5, neps.size()); + OwnedNodeEdgePoint nep1 = neps.get(0); + Uuid client4NepUuid = new Uuid( + UUID.nameUUIDFromBytes("DSR+XPDR1-CLIENT4".getBytes(Charset.forName("UTF-8"))).toString()); + checkNepClient10G(nep1, client4NepUuid, "XPDR1-CLIENT4", "NodeEdgePoint_C4"); + + OwnedNodeEdgePoint nep2 = neps.get(1); + Uuid networkNepUuid = new Uuid( + UUID.nameUUIDFromBytes("DSR+XPDR1-NETWORK1".getBytes(Charset.forName("UTF-8"))).toString()); + checkNepNetworkODU4(nep2, networkNepUuid, "XPDR1-NETWORK1", "NodeEdgePoint_N1"); + List nrgList = node.getNodeRuleGroup().stream() + .sorted((nrg1, nrg2) -> nrg1.getUuid().getValue().compareTo(nrg2.getUuid().getValue())) + .collect(Collectors.toList()); + checkNodeRuleGroupForMuxDSR(nrgList, client4NepUuid, networkNepUuid, nodeUuid); + } + } + + private void checkOtsiNode(Node node, Uuid nodeUuid, boolean isSwitch) { + assertEquals("incorrect node uuid", nodeUuid, node.getUuid()); + assertEquals("administrative state should be UNLOCKED", + AdministrativeState.UNLOCKED, node.getAdministrativeState()); + assertEquals("life-cycle state should be INSTALLED", LifecycleState.INSTALLED, node.getLifecycleState()); + assertEquals("operational state should be ENABLED", OperationalState.ENABLED, node.getOperationalState()); + assertEquals("value-name should be 'dsr/odu node name'", + "otsi node name", node.getName().get(0).getValueName()); + assertEquals("otsi node should manage a single protocol layer : PHOTONIC_MEDIA", + 1, node.getLayerProtocolName().size()); + assertEquals("otsi node should manage a single protocol layer : PHOTONIC_MEDIA", + LayerProtocolName.PHOTONICMEDIA, node.getLayerProtocolName().get(0)); + List neps = node.getOwnedNodeEdgePoint().stream() + .sorted((nep1, nep2) -> nep1.getUuid().getValue().compareTo(nep2.getUuid().getValue())) + .collect(Collectors.toList()); + if (isSwitch) { + assertEquals("Switch-OTSi node should have 8 NEPs", 8, neps.size()); + OwnedNodeEdgePoint nep1 = neps.get(0); + Uuid inepUuid = new Uuid( + UUID.nameUUIDFromBytes("iOTSi+XPDR2-NETWORK2".getBytes(Charset.forName("UTF-8"))).toString()); + checkNepOtsiNode(nep1, inepUuid, "XPDR2-NETWORK2", "iNodeEdgePoint_2"); + OwnedNodeEdgePoint nep2 = neps.get(5); + Uuid enepUuid = new Uuid( + UUID.nameUUIDFromBytes("eOTSi+XPDR2-NETWORK2".getBytes(Charset.forName("UTF-8"))).toString()); + checkNepOtsiNode(nep2, enepUuid, "XPDR2-NETWORK2", "eNodeEdgePoint_2"); + List nrgList = node.getNodeRuleGroup().stream() + .sorted((nrg1, nrg2) -> nrg1.getUuid().getValue().compareTo(nrg2.getUuid().getValue())) + .collect(Collectors.toList()); + checkNodeRuleGroupForSwitchOTSi(nrgList, enepUuid, inepUuid, nodeUuid); + } else { + assertEquals("Mux-OTSi node should have 2 NEPs", 2, neps.size()); + OwnedNodeEdgePoint nep1 = neps.get(0); + Uuid enepUuid = new Uuid( + UUID.nameUUIDFromBytes("eOTSi+XPDR1-NETWORK1".getBytes(Charset.forName("UTF-8"))).toString()); + checkNepOtsiNode(nep1, enepUuid, "XPDR1-NETWORK1", "eNodeEdgePoint_1"); + OwnedNodeEdgePoint nep2 = neps.get(1); + Uuid inepUuid = new Uuid( + UUID.nameUUIDFromBytes("iOTSi+XPDR1-NETWORK1".getBytes(Charset.forName("UTF-8"))).toString()); + checkNepOtsiNode(nep2, inepUuid, "XPDR1-NETWORK1", "iNodeEdgePoint_1"); + List nrgList = node.getNodeRuleGroup().stream() + .sorted((nrg1, nrg2) -> nrg1.getUuid().getValue().compareTo(nrg2.getUuid().getValue())) + .collect(Collectors.toList()); + checkNodeRuleGroupForMuxOTSi(nrgList, enepUuid, inepUuid, nodeUuid); + } + } + + private void checkNepClient10G(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName) { + assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid()); + assertEquals("value of client nep should be '" + portName + "'", + portName, nep.getName().get(0).getValue()); + assertEquals("value-name of client nep for '" + portName + "' should be '" + nepName + "'", + nepName, nep.getName().get(0).getValueName()); + assertEquals("Client nep should support 2 kind of cep", + 2, nep.getSupportedCepLayerProtocolQualifier().size()); + assertThat("client nep should support 2 kind of cep", + nep.getSupportedCepLayerProtocolQualifier(), + hasItems(ODUTYPEODU2E.class, DIGITALSIGNALTYPE10GigELAN.class)); + assertEquals("client nep should be of ETH protocol type", LayerProtocolName.ETH, nep.getLayerProtocolName()); + checkCommonPartOfNep(nep); + } + + private void checkNepNetworkODU4(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName) { + assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid()); + assertEquals("value of network nep should be '" + portName + "'", + portName, nep.getName().get(0).getValue()); + assertEquals("value-name of client nep for '" + portName + "' should be '" + nepName + "'", + nepName, nep.getName().get(0).getValueName()); + assertEquals("Network nep should support 1 kind of cep", + 1, nep.getSupportedCepLayerProtocolQualifier().size()); + assertThat("network nep should support 1 kind of cep", + nep.getSupportedCepLayerProtocolQualifier(), + hasItem(ODUTYPEODU4.class)); + assertEquals("network nep should be of ODU protocol type", LayerProtocolName.ODU, nep.getLayerProtocolName()); + checkCommonPartOfNep(nep); + } + + private void checkNodeRuleGroupForMuxDSR(List nrgList, Uuid clientNepUuid, Uuid networkNepUuid, + Uuid nodeUuid) { + assertEquals("muxponder DSR should contain 4 node rule group", 4, nrgList.size()); + for (NodeRuleGroup nodeRuleGroup : nrgList) { + assertEquals("each node-rule-group should contain 2 NEP for muxponder DSR", + 2, nodeRuleGroup.getNodeEdgePoint().size()); + } + assertThat("node-rule-group nb 2 should be between nep-client4 and nep-network1", + nrgList.get(1).getNodeEdgePoint().get(0).getNodeEdgePointUuid().getValue(), + either(containsString(networkNepUuid.getValue())).or(containsString(clientNepUuid.getValue()))); + assertThat("node-rule-group nb 2 should be between nep-client4 and nep-network1", + nrgList.get(1).getNodeEdgePoint().get(1).getNodeEdgePointUuid().getValue(), + either(containsString(networkNepUuid.getValue())).or(containsString(clientNepUuid.getValue()))); + assertEquals("node-rule-group nb 2 should be between nep-client4 and nep-network1 of the same node", + nrgList.get(1).getNodeEdgePoint().get(0).getNodeUuid(), nodeUuid); + assertEquals("node-rule-group nb 2 should be between nep-client4 and nep-network1 of the same node", + nrgList.get(1).getNodeEdgePoint().get(1).getNodeUuid(), nodeUuid); + assertEquals("node-rule-group nb 2 should contain a single rule", 1, nrgList.get(1).getRule().size()); + assertEquals("local-id of the rule should be 'forward'", + "forward", nrgList.get(1).getRule().get(0).getLocalId()); + assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'", + ForwardingRule.MAYFORWARDACROSSGROUP, nrgList.get(1).getRule().get(0).getForwardingRule()); + assertEquals("the rule type should be 'FORWARDING'", + RuleType.FORWARDING, nrgList.get(1).getRule().get(0).getRuleType()); + } + + private void checkNodeRuleGroupForSwitchDSR(List nrgList, Uuid clientNepUuid, Uuid networkNepUuid, + Uuid nodeUuid) { + assertEquals("Switch-DSR should contain a single node rule group", 1, nrgList.size()); + assertEquals("Switch-DSR node-rule-group should contain 8 NEP", 8, nrgList.get(0).getNodeEdgePoint().size()); + List nrg = nrgList.get(0).getNodeEdgePoint().stream() + .sorted((nrg1, nrg2) -> nrg1.getNodeEdgePointUuid().getValue() + .compareTo(nrg2.getNodeEdgePointUuid().getValue())) + .collect(Collectors.toList()); + assertEquals("in the sorted node-rule-group, nep number 2 should be XPDR2-NETWORK1", + networkNepUuid, nrg.get(1).getNodeEdgePointUuid()); + assertEquals("in the sorted node-rule-group, nep number 6 should be XPDR2-CLIENT4", + clientNepUuid, nrg.get(5).getNodeEdgePointUuid()); + assertEquals("any item of the node-rule-group should have the same nodeUuid", + nodeUuid, nrg.get(1).getNodeUuid()); + assertEquals("any item of the node-rule-group should have the same nodeUuid", + nodeUuid, nrg.get(5).getNodeUuid()); + assertEquals("node-rule-group should contain a single rule", 1, nrgList.get(0).getRule().size()); + assertEquals("local-id of the rule should be 'forward'", + "forward", nrgList.get(0).getRule().get(0).getLocalId()); + assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'", + ForwardingRule.MAYFORWARDACROSSGROUP, nrgList.get(0).getRule().get(0).getForwardingRule()); + assertEquals("the rule type should be 'FORWARDING'", + RuleType.FORWARDING, nrgList.get(0).getRule().get(0).getRuleType()); + } + + private void checkNodeRuleGroupForMuxOTSi(List nrgList, Uuid enepUuid, Uuid inepUuid, + Uuid nodeUuid) { + assertEquals("Mux-OTSi should contain a single node rule group", 1, nrgList.size()); + assertEquals("Mux-OTSi node-rule-group should contain 2 NEP", 2, nrgList.get(0).getNodeEdgePoint().size()); + assertThat("Mux-OTSi node-rule-group should be between eNEP and iNEP of XPDR1-NETWORK1", + nrgList.get(0).getNodeEdgePoint().get(0).getNodeEdgePointUuid().getValue(), + either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue()))); + assertThat("Mux-OTSi node-rule-group should be between eNEP and iNEP of XPDR1-NETWORK1", + nrgList.get(0).getNodeEdgePoint().get(1).getNodeEdgePointUuid().getValue(), + either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue()))); + assertEquals("any item of the node-rule-group should have the same nodeUuid", + nodeUuid, nrgList.get(0).getNodeEdgePoint().get(0).getNodeUuid()); + assertEquals("any item of the node-rule-group should have the same nodeUuid", + nodeUuid, nrgList.get(0).getNodeEdgePoint().get(1).getNodeUuid()); + assertEquals("node-rule-group should contain a single rule", 1, nrgList.get(0).getRule().size()); + assertEquals("local-id of the rule should be 'forward'", + "forward", nrgList.get(0).getRule().get(0).getLocalId()); + assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'", + ForwardingRule.MAYFORWARDACROSSGROUP, nrgList.get(0).getRule().get(0).getForwardingRule()); + assertEquals("the rule type should be 'FORWARDING'", + RuleType.FORWARDING, nrgList.get(0).getRule().get(0).getRuleType()); + } + + private void checkNodeRuleGroupForSwitchOTSi(List nrgList, Uuid enepUuid, Uuid inepUuid, + Uuid nodeUuid) { + assertEquals("Switch-OTSi should contain 4 node rule group", 4, nrgList.size()); + for (NodeRuleGroup nodeRuleGroup : nrgList) { + assertEquals("each node-rule-group should contain 2 NEP for Switch-OTSi", + 2, nodeRuleGroup.getNodeEdgePoint().size()); + } + assertThat("Switch-OTSi node-rule-group nb 4 should be between eNEP and iNEP of XPDR2-NETWORK2", + nrgList.get(1).getNodeEdgePoint().get(0).getNodeEdgePointUuid().getValue(), + either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue()))); + assertThat("Switch-OTSi node-rule-group nb 4 should be between eNEP and iNEP of XPDR2-NETWORK2", + nrgList.get(1).getNodeEdgePoint().get(1).getNodeEdgePointUuid().getValue(), + either(containsString(enepUuid.getValue())).or(containsString(inepUuid.getValue()))); + assertEquals("any item of the node-rule-group should have the same nodeUuid", + nodeUuid, nrgList.get(0).getNodeEdgePoint().get(0).getNodeUuid()); + assertEquals("any item of the node-rule-group should have the same nodeUuid", + nodeUuid, nrgList.get(0).getNodeEdgePoint().get(1).getNodeUuid()); + assertEquals("node-rule-group should contain a single rule", 1, nrgList.get(0).getRule().size()); + assertEquals("local-id of the rule should be 'forward'", + "forward", nrgList.get(0).getRule().get(0).getLocalId()); + assertEquals("the forwarding rule should be 'MAYFORWARDACROSSGROUP'", + ForwardingRule.MAYFORWARDACROSSGROUP, nrgList.get(0).getRule().get(0).getForwardingRule()); + assertEquals("the rule type should be 'FORWARDING'", + RuleType.FORWARDING, nrgList.get(0).getRule().get(0).getRuleType()); + } + + private void checkNepClient100G(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName) { + assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid()); + assertEquals("value of client nep should be '" + portName + "'", + portName, nep.getName().get(0).getValue()); + assertEquals("value-name of client nep for '" + portName + "' should be '" + nepName + "'", + nepName, nep.getName().get(0).getValueName()); + assertEquals("Client nep should support 2 kind of cep", + 2, nep.getSupportedCepLayerProtocolQualifier().size()); + assertThat("client nep should support 2 kind of cep", + nep.getSupportedCepLayerProtocolQualifier(), + hasItems(ODUTYPEODU4.class, DIGITALSIGNALTYPE100GigE.class)); + assertEquals("client nep should be of ETH protocol type", LayerProtocolName.ETH, nep.getLayerProtocolName()); + checkCommonPartOfNep(nep); + } + + private void checkNepOtsiNode(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName) { + assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid()); + assertEquals("value of OTSi nep should be '" + portName + "'", + portName, nep.getName().get(0).getValue()); + assertEquals("value-name of OTSi nep should be '" + nepName + "'", + nepName, nep.getName().get(0).getValueName()); + assertEquals("OTSi nep should support 2 kind of cep", + 2, nep.getSupportedCepLayerProtocolQualifier().size()); + assertThat("OTSi nep should support 2 kind of cep", + nep.getSupportedCepLayerProtocolQualifier(), + hasItems(PHOTONICLAYERQUALIFIEROMS.class, PHOTONICLAYERQUALIFIEROTSi.class)); + assertEquals("OTSi nep should be of PHOTONIC_MEDIA protocol type", + LayerProtocolName.PHOTONICMEDIA, nep.getLayerProtocolName()); + assertEquals("OTSi nep should support one SIP", 1, nep.getMappedServiceInterfacePoint().size()); + checkCommonPartOfNep(nep); + } + + private void checkCommonPartOfNep(OwnedNodeEdgePoint nep) { + assertEquals("link port direction should be DIRECTIONAL", + PortDirection.BIDIRECTIONAL, nep.getLinkPortDirection()); + assertEquals("administrative state should be UNLOCKED", + AdministrativeState.UNLOCKED, nep.getAdministrativeState()); + assertEquals("termination state should be TERMINATED BIDIRECTIONAL", + TerminationState.TERMINATEDBIDIRECTIONAL, nep.getTerminationState()); + assertEquals("life-cycle state should be INSTALLED", LifecycleState.INSTALLED, nep.getLifecycleState()); + assertEquals("client nep should support 1 SIP", 1, nep.getMappedServiceInterfacePoint().size()); + assertEquals("termination direction should be BIDIRECTIONAL", + TerminationDirection.BIDIRECTIONAL, nep.getTerminationDirection()); + assertEquals("operational state of client nep should be ENABLED", + OperationalState.ENABLED, nep.getOperationalState()); + assertEquals("link-port-role of client nep should be SYMMETRIC", + PortRole.SYMMETRIC, nep.getLinkPortRole()); + } + + private void checkTransitionalLink(Link link, Uuid topoUuid, Uuid node1Uuid, Uuid node2Uuid, String tp1, + String tp2) { + Uuid linkUuid = new Uuid(UUID.nameUUIDFromBytes((tp1 + "--" + tp2).getBytes(Charset.forName("UTF-8"))) + .toString()); + assertEquals("bad uuid for link between DSR node " + tp1 + " and iOTSI port " + tp2, linkUuid, link.getUuid()); + assertEquals("Available capacity unit should be GBPS", + CapacityUnit.GBPS, link.getAvailableCapacity().getTotalSize().getUnit()); + assertEquals("Available capacity -total size value should be 100", + Uint64.valueOf(100), link.getAvailableCapacity().getTotalSize().getValue()); + assertEquals("transitional link should be between 2 nodes of protocol layers ODU and PHOTONIC_MEDIA", + 2, link.getTransitionedLayerProtocolName().size()); + assertThat("transitional link should be between 2 nodes of protocol layers ODU and PHOTONIC_MEDIA", + link.getTransitionedLayerProtocolName(), + hasItems(LayerProtocolName.ODU.getName(), LayerProtocolName.PHOTONICMEDIA.getName())); + assertEquals("transitional link should be BIDIRECTIONAL", + ForwardingDirection.BIDIRECTIONAL, link.getDirection()); + assertEquals("topology uuid should be the same for the two termination point of the link", + topoUuid, link.getNodeEdgePoint().get(0).getTopologyUuid()); + assertEquals("topology uuid should be the same for the two termination point of the link", + topoUuid, link.getNodeEdgePoint().get(1).getTopologyUuid()); + assertThat("transitional links should terminate on DSR node and Photonic node", + link.getNodeEdgePoint().get(0).getNodeUuid().getValue(), + either(containsString(node1Uuid.getValue())).or(containsString(node2Uuid.getValue()))); + assertThat("transitional links should terminate on DSR node and Photonic node", + link.getNodeEdgePoint().get(1).getNodeUuid().getValue(), + either(containsString(node1Uuid.getValue())).or(containsString(node2Uuid.getValue()))); + Uuid nep1Uuid = new Uuid(UUID.nameUUIDFromBytes(tp1.getBytes(Charset.forName("UTF-8"))).toString()); + Uuid nep2Uuid = new Uuid(UUID.nameUUIDFromBytes(tp2.getBytes(Charset.forName("UTF-8"))).toString()); + assertThat("transitional links should terminate on " + tp1 + " and " + tp2 + " neps", + link.getNodeEdgePoint().get(0).getNodeEdgePointUuid().getValue(), + either(containsString(nep1Uuid.getValue())).or(containsString(nep2Uuid.getValue()))); + assertThat("transitional links should terminate on DSR node and Photonic node", + link.getNodeEdgePoint().get(1).getNodeEdgePointUuid().getValue(), + either(containsString(nep1Uuid.getValue())).or(containsString(nep2Uuid.getValue()))); + } +} \ No newline at end of file diff --git a/tapi/src/test/java/org/opendaylight/transportpce/tapi/utils/TopologyDataUtils.java b/tapi/src/test/java/org/opendaylight/transportpce/tapi/utils/TopologyDataUtils.java index 226b57d4f..1227c3eeb 100644 --- a/tapi/src/test/java/org/opendaylight/transportpce/tapi/utils/TopologyDataUtils.java +++ b/tapi/src/test/java/org/opendaylight/transportpce/tapi/utils/TopologyDataUtils.java @@ -31,20 +31,20 @@ import org.slf4j.LoggerFactory; public final class TopologyDataUtils { private static final Logger LOG = LoggerFactory.getLogger(TopologyDataUtils.class); - private static final String TOPOLOGY_FILE = - "src/test/resources/openroadm-topology2.xml"; - private static final String PORTMAPPING_FILE = - "src/test/resources/portmapping-example.xml"; + public static final String OPENROADM_TOPOLOGY_FILE = "src/test/resources/openroadm-topology2.xml"; + public static final String OTN_TOPOLOGY_FILE = "src/test/resources/otn-topology.xml"; + public static final String PORTMAPPING_FILE = "src/test/resources/portmapping-example.xml"; - public static GetTopologyDetailsInput buildGetTopologyDetailsInput() { + public static GetTopologyDetailsInput buildGetTopologyDetailsInput(String topoName) { GetTopologyDetailsInputBuilder builtInput = new GetTopologyDetailsInputBuilder(); - builtInput.setTopologyIdOrName("openroadm-topology"); + builtInput.setTopologyIdOrName(topoName); return builtInput.build(); } - public static void writeTopologyFromFileToDatastore(DataStoreContext dataStoreContextUtil) { - Networks result = null; - File topoFile = new File(TOPOLOGY_FILE); + public static void writeTopologyFromFileToDatastore(DataStoreContext dataStoreContextUtil, String file, + InstanceIdentifier ii) { + Networks networks = null; + File topoFile = new File(file); if (topoFile.exists()) { String fileName = topoFile.getName(); InputStream targetStream; @@ -62,7 +62,7 @@ public final class TopologyDataUtils { if (!dataObject.isPresent()) { throw new IllegalStateException("Could not transform normalized nodes into data object"); } else { - result = (Networks) dataObject.get(); + networks = (Networks) dataObject.get(); } } catch (FileNotFoundException e) { LOG.error("File not found : {} at {}", e.getMessage(), e.getLocalizedMessage()); @@ -70,10 +70,8 @@ public final class TopologyDataUtils { } else { LOG.error("xml file {} not found at {}", topoFile.getName(), topoFile.getAbsolutePath()); } - LOG.info("Storing openroadm-topology in datastore"); - InstanceIdentifier ietfNetworksIID = InstanceIdentifier.builder(Networks.class).build(); - writeTransaction(dataStoreContextUtil.getDataBroker(), ietfNetworksIID, result); - LOG.info("openroadm-topology stored with success in datastore"); + writeTransaction(dataStoreContextUtil.getDataBroker(), ii, networks.getNetwork().get(0)); + LOG.info("extraction from {} stored with success in datastore", topoFile.getName()); } @SuppressWarnings("unchecked") @@ -120,7 +118,6 @@ public final class TopologyDataUtils { } private TopologyDataUtils() { - } } diff --git a/tapi/src/test/resources/otn-topology.xml b/tapi/src/test/resources/otn-topology.xml new file mode 100644 index 000000000..2db86fd75 --- /dev/null +++ b/tapi/src/test/resources/otn-topology.xml @@ -0,0 +1,282 @@ + + + + otn-topology + + + + + SPDR-SA1-XPDR2 + + XPDR2-NETWORK2 + + openroadm-topology + SPDR-SA1-XPDR2 + XPDR2-NETWORK2 + + + + x:if-OCH-OTU4-ODU4 + + + + x:ODU4 + + XPONDER-NETWORK + + + XPDR2-NETWORK1 + + openroadm-topology + SPDR-SA1-XPDR2 + XPDR2-NETWORK1 + + + + x:if-OCH-OTU4-ODU4 + + + + x:ODU4 + + XPONDER-NETWORK + + + XPDR2-NETWORK4 + + openroadm-topology + SPDR-SA1-XPDR2 + XPDR2-NETWORK4 + + + + x:if-OCH-OTU4-ODU4 + + + + x:ODU4 + + XPONDER-NETWORK + + + XPDR2-NETWORK3 + + openroadm-topology + SPDR-SA1-XPDR2 + XPDR2-NETWORK3 + + + + x:if-OCH-OTU4-ODU4 + + + + x:ODU4 + + XPONDER-NETWORK + + + XPDR2-CLIENT4 + + + x:if-100GE-ODU4 + + + + x:ODU4 + + XPONDER-CLIENT + + + XPDR2-CLIENT2 + + + x:if-100GE-ODU4 + + + + x:ODU4 + + XPONDER-CLIENT + + + XPDR2-CLIENT3 + + + x:if-100GE-ODU4 + + + + x:ODU4 + + XPONDER-CLIENT + + + XPDR2-CLIENT1 + + + x:if-100GE-ODU4 + + + + x:ODU4 + + XPONDER-CLIENT + + SWITCH + + + 2 + + + + 1 + non-blocking + + 1 + XPDR2-NETWORK4 + XPDR2-CLIENT1 + XPDR2-NETWORK3 + XPDR2-CLIENT4 + XPDR2-CLIENT2 + XPDR2-NETWORK2 + XPDR2-CLIENT3 + XPDR2-NETWORK1 + + + + + clli-network + NodeSA + + + openroadm-topology + SPDR-SA1-XPDR2 + + + openroadm-network + SPDR-SA1 + + + + SPDR-SA1-XPDR1 + + XPDR1-CLIENT2 + + + x:if-10GE-ODU2e + + + + x:ODU2e + + XPONDER-CLIENT + + + XPDR1-CLIENT1 + + + x:if-10GE-ODU2e + + + + x:ODU2e + + XPONDER-CLIENT + + + XPDR1-CLIENT4 + + + x:if-10GE-ODU2e + + + + x:ODU2e + + XPONDER-CLIENT + + + XPDR1-NETWORK1 + + openroadm-topology + SPDR-SA1-XPDR1 + XPDR1-NETWORK1 + + + + x:if-OCH-OTU4-ODU4 + + + + x:ODU4 + + XPONDER-NETWORK + + + XPDR1-CLIENT3 + + + x:if-10GE-ODU2e + + + + x:ODU2e + + XPONDER-CLIENT + + MUXPDR + + + 1 + + + + 1 + non-blocking + + 3 + 10 + 1000000000 + XPDR1-NETWORK1 + XPDR1-CLIENT3 + + + 4 + 10 + 1000000000 + XPDR1-CLIENT4 + XPDR1-NETWORK1 + + + 1 + 10 + 1000000000 + XPDR1-NETWORK1 + XPDR1-CLIENT1 + + + 2 + 10 + 1000000000 + XPDR1-NETWORK1 + XPDR1-CLIENT2 + + + + + clli-network + NodeSA + + + openroadm-topology + SPDR-SA1-XPDR1 + + + openroadm-network + SPDR-SA1 + + + + + \ No newline at end of file