package org.opendaylight.transportpce.pce.graph;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.gson.stream.JsonReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.Reader;
+import java.nio.charset.StandardCharsets;
import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.concurrent.ExecutionException;
+import org.eclipse.jdt.annotation.NonNull;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
+import org.mockito.MockitoAnnotations;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.MountPoint;
+import org.opendaylight.mdsal.binding.api.MountPointService;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.transportpce.common.NetworkUtils;
+import org.opendaylight.transportpce.common.StringConstants;
+import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
+import org.opendaylight.transportpce.common.device.DeviceTransactionManagerImpl;
+import org.opendaylight.transportpce.common.mapping.PortMapping;
+import org.opendaylight.transportpce.common.mapping.PortMappingImpl;
+import org.opendaylight.transportpce.common.mapping.PortMappingVersion121;
+import org.opendaylight.transportpce.common.mapping.PortMappingVersion221;
+import org.opendaylight.transportpce.common.mapping.PortMappingVersion710;
+import org.opendaylight.transportpce.common.network.NetworkTransactionImpl;
+import org.opendaylight.transportpce.common.network.NetworkTransactionService;
+import org.opendaylight.transportpce.common.network.RequestProcessor;
import org.opendaylight.transportpce.pce.constraints.PceConstraints;
+import org.opendaylight.transportpce.pce.networkanalyzer.PceCalculation;
import org.opendaylight.transportpce.pce.networkanalyzer.PceLink;
import org.opendaylight.transportpce.pce.networkanalyzer.PceNode;
-import org.opendaylight.transportpce.pce.networkanalyzer.PceOpticalNode;
+//import org.opendaylight.transportpce.pce.networkanalyzer.PceOpticalNode;
+import org.opendaylight.transportpce.pce.networkanalyzer.PceOtnNode;
import org.opendaylight.transportpce.pce.networkanalyzer.PceResult;
+import org.opendaylight.transportpce.pce.utils.JsonUtil;
import org.opendaylight.transportpce.pce.utils.NodeUtils;
-import org.opendaylight.transportpce.pce.utils.PceTestData;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev200128.PathComputationRequestInput;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev181130.OpenroadmNodeType;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.service.format.rev190531.ServiceFormat;
+import org.opendaylight.transportpce.test.AbstractTest;
+import org.opendaylight.transportpce.test.converter.DataObjectConverter;
+import org.opendaylight.transportpce.test.converter.JSONDataObjectConverter;
+import org.opendaylight.transportpce.test.stub.MountPointServiceStub;
+import org.opendaylight.transportpce.test.stub.MountPointStub;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev220808.PathComputationRequestInput;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev220808.PathComputationRequestInputBuilder;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev220808.path.computation.request.input.ServiceAEndBuilder;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev220808.path.computation.request.input.ServiceZEndBuilder;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev211210.service.port.PortBuilder;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.common.state.types.rev191129.State;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev211210.OpenroadmVersionType;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.network.rev211210.Node1Builder;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev211210.TerminationPoint1Builder;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev211210.networks.network.node.termination.point.XpdrNetworkAttributesBuilder;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev211210.OpenroadmNodeType;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev211210.OpenroadmTpType;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.routing.constraints.rev211210.constraints.CoRoutingBuilder;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.routing.constraints.rev211210.constraints.co.routing.ServiceIdentifierListBuilder;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.routing.constraints.rev211210.routing.constraints.HardConstraintsBuilder;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.routing.constraints.rev211210.routing.constraints.SoftConstraintsBuilder;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.service.format.rev191129.ServiceFormat;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.OperationalModeCatalog;
+import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev220118.PceMetric;
+import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev220118.service.endpoint.sp.RxDirectionBuilder;
+import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev220118.service.endpoint.sp.TxDirectionBuilder;
+import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev220118.service.handler.header.ServiceHandlerHeaderBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NetworkId;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.Networks;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NodeId;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.Network;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.NetworkKey;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.Node;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.NodeBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.NodeKey;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.node.SupportingNode;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.node.SupportingNodeBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.node.SupportingNodeKey;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.LinkId;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.TpId;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.Link;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.node.TerminationPoint;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.node.TerminationPointBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.node.TerminationPointKey;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Uint32;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
-
-public class PceGraphTest {
-
- private Link link = null;
+public class PceGraphTest extends AbstractTest {
+ private static final Logger LOG = LoggerFactory.getLogger(PceGraphTest.class);
+ private Link link1 = null;
private Node node = null;
- private PceLink pceLink = null;
+ private PceLink pceLink1 = null;
private PceGraph pceGraph = null;
- private PathComputationRequestInput requestInput = PceTestData.getPCE_test2_request_54();
private PceConstraints pceHardConstraints = null;
private PceResult rc = null;
- private PceOpticalNode pceOpticalNode = null;
- private PceOpticalNode pceOpticalNode2 = null;
private Map<NodeId, PceNode> allPceNodes = null;
+ private Map<LinkId, PceLink> allPceLinks = null;
+ private static final String CATALOG_FILE = "src/test/resources/apidocCatalog10_1OptSpecV5_1.json";
+ private static final String MAPPING_FILE = "src/test/resources/topologyData/portMapping2.json";
+ private static OperationalModeCatalog omCatalog;
+ private static org.opendaylight.yang.gen.v1.http.org.opendaylight
+ .transportpce.portmapping.rev220316.Network networkNode;
+ private DataBroker dataBroker;
+ private MountPoint mountPoint;
+ private MountPointService mountPointService;
+ private DeviceTransactionManager deviceTransactionManager;
+ private PortMappingVersion710 portMappingVersion710;
+ private PortMappingVersion221 portMappingVersion22;
+ private PortMappingVersion121 portMappingVersion121;
+ private PortMapping portMapping;
+ private RequestProcessor reqProc;
+ private NetworkTransactionService netTransServ;
+
+ // Test of integration for PceGraph
@Before
- public void setUp() {
- // Build Link
- link = NodeUtils.createRoadmToRoadm("OpenROADM-3-2-DEG1",
- "OpenROADM-3-1-DEG1",
- "DEG1-TTP-TX", "DEG1-TTP-RX").build();
+ public void setUp() throws InterruptedException, ExecutionException {
+ // PortMapping is instantiated to create the mapping of the different nodes in the topology
+ this.dataBroker = getNewDataBroker();
+ this.mountPoint = new MountPointStub(dataBroker);
+ this.mountPointService = new MountPointServiceStub(mountPoint);
+ this.deviceTransactionManager = new DeviceTransactionManagerImpl(mountPointService, 3000);
+ this.portMappingVersion22 = new PortMappingVersion221(dataBroker, deviceTransactionManager);
+ this.portMappingVersion121 = new PortMappingVersion121(dataBroker, deviceTransactionManager);
+ this.portMappingVersion710 = new PortMappingVersion710(dataBroker, deviceTransactionManager);
+ this.portMapping = new PortMappingImpl(dataBroker, this.portMappingVersion710,
+ this.portMappingVersion22, this.portMappingVersion121);
+ // The catalog of operational mode needs to be loaded so that Ctalog primitives (CatlogUtils)
+ // can retrieve physical parameters of the nodes of the path
+ DataObjectConverter dataObjectConverter = JSONDataObjectConverter
+ .createWithDataStoreUtil(getDataStoreContextUtil());
+ try (Reader reader = new FileReader(CATALOG_FILE, StandardCharsets.UTF_8)) {
+ NormalizedNode normalizedNode = dataObjectConverter
+ .transformIntoNormalizedNode(reader)
+ .get();
+ omCatalog = (OperationalModeCatalog) getDataStoreContextUtil()
+ .getBindingDOMCodecServices()
+ .fromNormalizedNode(
+ YangInstanceIdentifier.of(OperationalModeCatalog.QNAME), normalizedNode)
+ .getValue();
+ @NonNull
+ WriteTransaction newWriteOnlyTransaction = dataBroker.newWriteOnlyTransaction();
+ newWriteOnlyTransaction
+ .put(LogicalDatastoreType.CONFIGURATION,
+ InstanceIdentifier.create(OperationalModeCatalog.class),
+ omCatalog);
+ newWriteOnlyTransaction.commit().get();
+ } catch (IOException e) {
+ LOG.error("Cannot load OpenROADM part of Operational Mode Catalog ", e);
+ fail("Cannot load openROADM operational modes ");
+ }
+ // The mapping corresponding to the topology is directly populated from a file in the Dta Store
+ try (Reader reader = new FileReader(MAPPING_FILE, StandardCharsets.UTF_8)) {
+ NormalizedNode normalizedNode = dataObjectConverter.transformIntoNormalizedNode(reader).get();
+ networkNode = (org.opendaylight.yang.gen.v1.http.org.opendaylight
+ .transportpce.portmapping.rev220316.Network) getDataStoreContextUtil()
+ .getBindingDOMCodecServices()
+ .fromNormalizedNode(
+ YangInstanceIdentifier.of(org.opendaylight.yang.gen.v1.http.org.opendaylight
+ .transportpce.portmapping.rev220316.Network.QNAME), normalizedNode)
+ .getValue();
+ @NonNull
+ WriteTransaction newWriteOnlyTransaction = dataBroker.newWriteOnlyTransaction();
+ newWriteOnlyTransaction
+ .put(LogicalDatastoreType.CONFIGURATION,
+ InstanceIdentifier.create(org.opendaylight.yang.gen.v1.http.org.opendaylight
+ .transportpce.portmapping.rev220316.Network.class),
+ networkNode);
+ newWriteOnlyTransaction.commit().get();
+ } catch (IOException e) {
+ LOG.error("Cannot load OpenROADM part of Operational Mode Catalog ", e);
+ fail("Cannot load openROADM operational modes ");
+ }
+
+ MockitoAnnotations.openMocks(this);
+ // The topology (openROADM-Network and openROADM-topology layers) is loaded from a file
+ JsonReader networkReader = null;
+ JsonReader topoReader = null;
+ try {
+ // load openroadm-network
+ Reader gnpyNetwork = new FileReader("src/test/resources/gnpy/gnpy_network.json", StandardCharsets.UTF_8);
+ networkReader = new JsonReader(gnpyNetwork);
+ Networks networks = (Networks) JsonUtil.getInstance().getDataObjectFromJson(networkReader,
+ QName.create("urn:ietf:params:xml:ns:yang:ietf-network", "2018-02-26", "networks"));
+ saveOpenRoadmNetwork(networks.getNetwork().values().iterator().next(), NetworkUtils.UNDERLAY_NETWORK_ID);
+ // load openroadm-topology
+ Reader gnpyTopo =
+ new FileReader("src/test/resources/topologyData/or-base-topology.json", StandardCharsets.UTF_8);
+ topoReader = new JsonReader(gnpyTopo);
+ networks = (Networks) JsonUtil
+ .getInstance()
+ .getDataObjectFromJson(
+ topoReader,
+ QName.create("urn:ietf:params:xml:ns:yang:ietf-network", "2018-02-26", "networks"));
+ saveOpenRoadmNetwork(networks.getNetwork().values().iterator().next(), NetworkUtils.OVERLAY_NETWORK_ID);
+ } catch (IOException | InterruptedException | ExecutionException e) {
+ LOG.error("Cannot init test ", e);
+ fail("Cannot init test ");
+ } finally {
+ try {
+ if (networkReader != null) {
+ networkReader.close();
+ }
+ if (topoReader != null) {
+ topoReader.close();
+ }
+ } catch (IOException e) {
+ LOG.warn("Cannot close reader ", e);
+ }
+ }
+ // init PceHardContraints
+ pceHardConstraints = new PceConstraints();
+ this.rc = new PceResult();
+ this.reqProc = new RequestProcessor(dataBroker);
+ this.netTransServ = new NetworkTransactionImpl(reqProc);
+ LOG.info("The value of the mapping is {}", portMapping);
- node = NodeUtils.getNodeBuilder(NodeUtils.geSupportingNodes()).build();
+ }
+
+// TOPOLOGY ON WHICH TEST ARE BASED
+// _____ _____ _____
+// | | 20dB, 100km,PMD 2 | | 20dB,100km, PMD 2 | |
+// | 1 |____________________| 2 |_____________________| 5 |
+// | | | | | |
+// |_____| |_____| |_____|
+// |___________ 10km | 20dB,100km,PMD32 / | 100 km
+// | 5dB | _________|_________/ | 25 dB
+// | PMD32 __|__/ __|__PMD 2.0
+// 28dB, 100km,PMD 0 | | | 25dB,100km, PMD 2 | |
+// |__________| 3 |_____________________| 4 |
+// | | | |
+// |_____| |_____|
+//
+ @Test
+ public void clacPath100GE() {
+ PceCalculation pceCalc = new PceCalculation(getPCE1Request(Uint32.valueOf(100), ServiceFormat.Ethernet,
+ "XPONDER-1", "Node1", "Client-1", "XPONDER-3", "Node3", "Client-1"),
+ netTransServ, pceHardConstraints, null, rc, portMapping);
+ pceCalc.retrievePceNetwork();
+ pceGraph = new PceGraph(pceCalc.getaendPceNode(), pceCalc.getzendPceNode(),
+ pceCalc.getAllPceNodes(), pceCalc.getAllPceLinks(), pceHardConstraints,
+ null, rc, StringConstants.SERVICE_TYPE_100GE_T, netTransServ);
+ Assert.assertEquals(pceGraph.calcPath(), true);
+ Assert.assertEquals(Optional.ofNullable(pceGraph.getmargin()),
+ Optional.ofNullable(3.0919881995992924));
+ }
- pceOpticalNode = new PceOpticalNode(node,
- OpenroadmNodeType.SRG, new NodeId("OpenROADM-3-2-DEG1"), ServiceFormat.Ethernet,
- "DEGREE");
+ @Test
+ public void clacPathOTUC2() {
+ PceCalculation pceCalc = new PceCalculation(getPCE1Request(Uint32.valueOf(200), ServiceFormat.Ethernet,
+ "XPONDER-1", "Node1", "XPDR-NW1-TX", "XPONDER-4", "Node4", "XPDR-NW1-RX"),
+ netTransServ, pceHardConstraints, null, rc, portMapping);
+ pceCalc.retrievePceNetwork();
+ pceGraph = new PceGraph(pceCalc.getaendPceNode(), pceCalc.getzendPceNode(),
+ pceCalc.getAllPceNodes(), pceCalc.getAllPceLinks(), pceHardConstraints,
+ null, rc, StringConstants.SERVICE_TYPE_OTUC2, netTransServ);
+ Assert.assertEquals(pceGraph.calcPath(), true);
+ Assert.assertEquals(Optional.ofNullable(pceGraph.getmargin()),
+ Optional.ofNullable(1.1559963686478447));
+ }
- pceOpticalNode2 = new PceOpticalNode(node,
- OpenroadmNodeType.SRG, new NodeId("OpenROADM-3-1-DEG1"), ServiceFormat.Ethernet,
- "DEGREE");
+ @Test
+ public void clacPathOTUC3() {
+ PceCalculation pceCalc = new PceCalculation(getPCE1Request(Uint32.valueOf(300), ServiceFormat.Ethernet,
+ "XPONDER-1", "Node1", "XPDR-NW1-TX", "XPONDER-3", "Node3", "XPDR-NW1-RX"),
+ netTransServ, pceHardConstraints, null, rc, portMapping);
+ pceCalc.retrievePceNetwork();
+ pceGraph = new PceGraph(pceCalc.getaendPceNode(), pceCalc.getzendPceNode(),
+ pceCalc.getAllPceNodes(), pceCalc.getAllPceLinks(), pceHardConstraints,
+ null, rc, StringConstants.SERVICE_TYPE_OTUC3, netTransServ);
+ Assert.assertEquals(pceGraph.calcPath(), true);
+ Assert.assertEquals(Optional.ofNullable(pceGraph.getmargin()),
+ Optional.ofNullable(0.3351048800367167));
+ }
- pceLink = new PceLink(link, pceOpticalNode, pceOpticalNode2);
- pceLink.setClient("XPONDER-CLIENT");
+ @Test
+ public void clacUnfeasiblePath400GE() {
+ PceCalculation pceCalc = new PceCalculation(getPCE1Request(Uint32.valueOf(400), ServiceFormat.Ethernet,
+ "XPONDER-1", "Node1", "Client-1", "XPONDER-3", "Node3", "Client-1"),
+ netTransServ, pceHardConstraints, null, rc, portMapping);
+ pceCalc.retrievePceNetwork();
+ pceGraph = new PceGraph(pceCalc.getaendPceNode(), pceCalc.getzendPceNode(),
+ pceCalc.getAllPceNodes(), pceCalc.getAllPceLinks(), pceHardConstraints,
+ null, rc, StringConstants.SERVICE_TYPE_400GE, netTransServ);
+ Assert.assertEquals(pceGraph.calcPath(), false);
+ Assert.assertEquals(Optional.ofNullable(pceGraph.getmargin()),
+ Optional.ofNullable(0.0));
+ }
- pceLink.getDestId();
- pceOpticalNode.addOutgoingLink(pceLink);
+ @Test
+ public void clacPath400GE() {
+ PceCalculation pceCalc = new PceCalculation(getPCE1Request(Uint32.valueOf(400), ServiceFormat.Ethernet,
+ "XPONDER-1", "Node1", "Client-1", "XPONDER-5", "Node5", "Client-1"),
+ netTransServ, pceHardConstraints, null, rc, portMapping);
+ pceCalc.retrievePceNetwork();
+ pceGraph = new PceGraph(pceCalc.getaendPceNode(), pceCalc.getzendPceNode(),
+ pceCalc.getAllPceNodes(), pceCalc.getAllPceLinks(), pceHardConstraints,
+ null, rc, StringConstants.SERVICE_TYPE_400GE, netTransServ);
+ Assert.assertEquals(pceGraph.calcPath(), true);
+ Assert.assertEquals(Optional.ofNullable(pceGraph.getmargin()),
+ Optional.ofNullable(1.4432381874659086));
+ }
- // init PceHardContraints
- pceHardConstraints = new PceConstraints();
- // pceHardConstraints.setp
- allPceNodes = Map.of(new NodeId("OpenROADM-3-2-DEG1"), pceOpticalNode,
- new NodeId("OpenROADM-3-1-DEG1"), pceOpticalNode2);
- rc = new PceResult();
- pceGraph = new PceGraph(pceOpticalNode, pceOpticalNode2, allPceNodes,
- pceHardConstraints,
- null, rc,
- "ODU4");
+ @Test
+ public void clacPathOTUC4() {
+ PceCalculation pceCalc = new PceCalculation(getPCE1Request(Uint32.valueOf(400), ServiceFormat.Ethernet,
+ "XPONDER-1", "Node1", "XPDR-NW1-TX", "XPONDER-5", "Node5", "XPDR-NW1-RX"),
+ netTransServ, pceHardConstraints, null, rc, portMapping);
+ pceCalc.retrievePceNetwork();
+ pceGraph = new PceGraph(pceCalc.getaendPceNode(), pceCalc.getzendPceNode(),
+ pceCalc.getAllPceNodes(), pceCalc.getAllPceLinks(), pceHardConstraints,
+ null, rc, StringConstants.SERVICE_TYPE_OTUC4, netTransServ);
+ Assert.assertEquals(pceGraph.calcPath(), true);
+ Assert.assertEquals(Optional.ofNullable(pceGraph.getmargin()),
+ Optional.ofNullable(1.4432381874659086));
}
@Test
- public void clacPath() {
+ public void clacOpticalTunnelOTUC4() {
+ PceCalculation pceCalc = new PceCalculation(getPCE1Request(Uint32.valueOf(400), ServiceFormat.OC,
+ "OpenROADM-1", "Node1", "DEG1-PP-TX", "OpenROADM-5", "Node5", "DEG3-PP-TX"),
+ netTransServ, pceHardConstraints, null, rc, portMapping);
+ pceCalc.retrievePceNetwork();
+ pceGraph = new PceGraph(pceCalc.getaendPceNode(), pceCalc.getzendPceNode(),
+ pceCalc.getAllPceNodes(), pceCalc.getAllPceLinks(), pceHardConstraints,
+ null, rc, StringConstants.SERVICE_TYPE_OTUC4, netTransServ);
+ Assert.assertEquals(pceGraph.calcPath(), true);
+ Assert.assertEquals(Optional.ofNullable(pceGraph.getmargin()),
+ Optional.ofNullable(0.0));
+ }
+ @Test
+ public void clacPath100GEnoPort() {
+ PceCalculation pceCalc = new PceCalculation(getPCE2Request(Uint32.valueOf(100), ServiceFormat.Ethernet,
+ "XPONDER-1", "Node1", "Client-1", "XPONDER-3", "Node3", "Client-1"),
+ netTransServ, pceHardConstraints, null, rc, portMapping);
+ pceCalc.retrievePceNetwork();
+ pceGraph = new PceGraph(pceCalc.getaendPceNode(), pceCalc.getzendPceNode(),
+ pceCalc.getAllPceNodes(), pceCalc.getAllPceLinks(), pceHardConstraints,
+ null, rc, StringConstants.SERVICE_TYPE_100GE_T, netTransServ);
Assert.assertEquals(pceGraph.calcPath(), true);
+ Assert.assertEquals(Optional.ofNullable(pceGraph.getmargin()),
+ Optional.ofNullable(3.0919881995992924));
}
@Test
- public void clacPathFalse() {
- pceGraph = new PceGraph(pceOpticalNode, pceOpticalNode2, allPceNodes,
- pceHardConstraints,
- null, rc,
- "100GE");
+ public void clacPathPropagationDelay() {
+ PceCalculation pceCalc = new PceCalculation(getPCE1Request(Uint32.valueOf(100), ServiceFormat.Ethernet,
+ "XPONDER-1", "Node1", "Client-1", "XPONDER-3", "Node3", "Client-1"),
+ netTransServ, pceHardConstraints, null, rc, portMapping);
+ pceCalc.retrievePceNetwork();
+ pceHardConstraints.setPceMetrics(PceMetric.PropagationDelay);
+ pceGraph = new PceGraph(pceCalc.getaendPceNode(), pceCalc.getzendPceNode(),
+ pceCalc.getAllPceNodes(), pceCalc.getAllPceLinks(), pceHardConstraints,
+ null, rc, StringConstants.SERVICE_TYPE_100GE_T, netTransServ);
+ pceGraph.setConstrains(pceHardConstraints, null);
+
+ Assert.assertEquals(pceGraph.calcPath(), true);
+ Assert.assertEquals(Optional.ofNullable(pceGraph.getPathAtoZ().get(2).getLatency()),
+ Optional.ofNullable(1.0));
+ Assert.assertEquals(pceGraph.getReturnStructure().getRate(), 100);
+ }
+ @Test(expected = Exception.class)
+ public void clacPath10GE2() {
+ pceGraph = getOtnPceGraph(StringConstants.SERVICE_TYPE_10GE);
Assert.assertEquals(pceGraph.calcPath(), false);
}
@Test(expected = Exception.class)
public void clacPath1GE() {
- pceGraph = new PceGraph(pceOpticalNode, pceOpticalNode2, allPceNodes,
- pceHardConstraints,
- null, rc,
- "10GE");
-
+ pceGraph = getOtnPceGraph(StringConstants.SERVICE_TYPE_1GE);
Assert.assertEquals(pceGraph.calcPath(), false);
}
-}
+ private PceGraph getOtnPceGraph(String type) {
+ // Build Link
+ link1 = NodeUtils.createRoadmToRoadm("optical",
+ "optical2",
+ "DEG1-TTP-TX", "DEG1-TTP-RX").build();
+
+ node = NodeUtils.getOTNNodeBuilder(NodeUtils.geSupportingNodes(), OpenroadmTpType.XPONDERNETWORK).build();
+
+ PceOtnNode pceOtnNode = new PceOtnNode(node, OpenroadmNodeType.MUXPDR,
+ new NodeId("optical"), ServiceFormat.OTU.getName(), "serviceType", null);
+ pceOtnNode.validateXponder("optical", "sl");
+ pceOtnNode.validateXponder("not optical", "sl");
+ pceOtnNode.initXndrTps("AZ");
+ pceOtnNode.checkAvailableTribPort();
+ pceOtnNode.checkAvailableTribSlot();
+
+ PceOtnNode pceOtnNode2 = new PceOtnNode(node, OpenroadmNodeType.MUXPDR,
+ new NodeId("optical2"), ServiceFormat.OTU.getName(), "serviceType", null);
+ pceOtnNode2.validateXponder("optical", "sl");
+ pceOtnNode2.validateXponder("not optical", "sl");
+ pceOtnNode2.initXndrTps("AZ");
+ pceOtnNode2.initXndrTps("mode");
+ pceOtnNode2.checkAvailableTribPort();
+ pceOtnNode2.checkAvailableTribSlot();
+
+ pceLink1 = new PceLink(link1, pceOtnNode, pceOtnNode2);
+ pceLink1.setClient("XPONDER-CLIENT");
+
+ pceLink1.getDestId();
+ pceOtnNode.addOutgoingLink(pceLink1);
+
+ // init PceHardContraints
+ pceHardConstraints = new PceConstraints();
+ // pceHardConstraints.setp
+ allPceNodes = Map.of(
+ new NodeId("optical"), pceOtnNode,
+ new NodeId("optical2"), pceOtnNode2);
+ return new PceGraph(pceOtnNode, pceOtnNode2, allPceNodes,
+ allPceLinks, pceHardConstraints,
+ null, new PceResult(),
+ type, null);
+ }
+
+ private void saveOpenRoadmNetwork(Network network, String networkId)
+ throws InterruptedException, ExecutionException {
+ InstanceIdentifier<Network> nwInstanceIdentifier = InstanceIdentifier.builder(Networks.class)
+ .child(Network.class, new NetworkKey(new NetworkId(networkId))).build();
+ WriteTransaction dataWriteTransaction = dataBroker.newWriteOnlyTransaction();
+ dataWriteTransaction.put(LogicalDatastoreType.CONFIGURATION, nwInstanceIdentifier, network);
+ dataWriteTransaction.commit().get();
+ }
+
+ public static Node createNetworkNode(String nodeId, OpenroadmNodeType nodeType) {
+ SupportingNode supportingNode = new SupportingNodeBuilder()
+ .setNetworkRef(new NetworkId(NetworkUtils.CLLI_NETWORK_ID))
+ .setNodeRef(new NodeId("node1"))
+ .withKey(new SupportingNodeKey(new NetworkId(NetworkUtils.CLLI_NETWORK_ID),
+ new NodeId("node1")))
+ .build();
+ return new NodeBuilder()
+ .setNodeId(new NodeId(nodeId))
+ .withKey(new NodeKey(new NodeId(nodeId)))
+ .setSupportingNode(ImmutableMap.of(supportingNode.key(), supportingNode))
+ .addAugmentation(
+ new Node1Builder().setOpenroadmVersion(OpenroadmVersionType._221).build())
+ .addAugmentation(
+ new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev211210.Node1Builder()
+ .setNodeType(nodeType).build())
+ .build();
+ }
+
+ public static TerminationPoint createNetworkTp(String nodeId, String tpId) {
+ var nwTpId = new TpId(tpId);
+ return new TerminationPointBuilder()
+ .setTpId(nwTpId)
+ .withKey(new TerminationPointKey(nwTpId))
+ .addAugmentation(new TerminationPoint1Builder()
+ .setXpdrNetworkAttributes(new XpdrNetworkAttributesBuilder().setState(State.InService).build())
+ .build())
+ .build();
+ }
+
+ public static Node createTopologyNode(String nodeId, OpenroadmNodeType nodeType) {
+ SupportingNode supportingNode = new SupportingNodeBuilder()
+ .setNetworkRef(new NetworkId(NetworkUtils.UNDERLAY_NETWORK_ID))
+ .setNodeRef(new NodeId("node1"))
+ .withKey(new SupportingNodeKey(new NetworkId(NetworkUtils.UNDERLAY_NETWORK_ID),
+ new NodeId("node1")))
+ .build();
+ return new NodeBuilder()
+ .setNodeId(new NodeId(nodeId))
+ .withKey(new NodeKey(new NodeId(nodeId)))
+ .setSupportingNode(ImmutableMap.of(supportingNode.key(), supportingNode))
+ .addAugmentation(
+ new org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev211210.Node1Builder()
+ .setXpdrAttributes(null).build())
+ .addAugmentation(
+ new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev211210.Node1Builder()
+ .setNodeType(nodeType).build())
+ .build();
+ }
+
+ public static PathComputationRequestInput getPCE1Request(Uint32 rate, ServiceFormat serviceFormat, String aaNodeId,
+ String aaClliId, String aaPortName, String zzNodeId, String zzClliId, String zzPortName) {
+ return new PathComputationRequestInputBuilder()
+ .setServiceName("service1")
+ .setResourceReserve(true)
+ .setPceRoutingMetric(PceMetric.HopCount)
+ .setServiceHandlerHeader(new ServiceHandlerHeaderBuilder()
+ .setRequestId("request1")
+ .build())
+ .setServiceAEnd(new ServiceAEndBuilder()
+ .setServiceFormat(serviceFormat)
+ .setServiceRate(Uint32.valueOf(100))
+ .setClli(aaClliId)
+ .setNodeId(aaNodeId)
+ .setTxDirection(new TxDirectionBuilder()
+ .setPort(new PortBuilder()
+ .setPortDeviceName(aaNodeId)
+ .setPortType("fixed")
+ .setPortName(aaPortName)
+ .setPortRack("Some port-rack")
+ .setPortShelf("Some port-shelf")
+ .setPortSlot("Some port-slot")
+ .setPortSubSlot("Some port-sub-slot")
+ .build())
+ .build())
+ .setRxDirection(new RxDirectionBuilder()
+ .setPort(new PortBuilder()
+ .setPortDeviceName(aaNodeId)
+ .setPortType("fixed")
+ .setPortName(aaPortName)
+ .setPortRack("Some port-rack")
+ .setPortShelf("Some port-shelf")
+ .setPortSlot("Some port-slot")
+ .setPortSubSlot("Some port-sub-slot")
+ .build())
+ .build())
+ .build())
+ .setServiceZEnd(new ServiceZEndBuilder()
+ .setServiceFormat(serviceFormat)
+ .setServiceRate(Uint32.valueOf(0))
+ .setClli(zzClliId)
+ .setNodeId(zzNodeId)
+ .setTxDirection(new TxDirectionBuilder()
+ .setPort(new PortBuilder()
+ .setPortDeviceName(zzNodeId)
+ .setPortType("fixed")
+ .setPortName(zzPortName)
+ .setPortRack("Some port-rack")
+ .setPortShelf("Some port-shelf")
+ .setPortSlot("Some port-slot")
+ .setPortSubSlot("Some port-sub-slot")
+ .build())
+ .build())
+ .setRxDirection(new RxDirectionBuilder()
+ .setPort(new PortBuilder()
+ .setPortDeviceName(zzNodeId)
+ .setPortType("fixed")
+ .setPortName(zzPortName)
+ .setPortRack("Some port-rack")
+ .setPortShelf("Some port-shelf")
+ .setPortSlot("Some port-slot")
+ .setPortSubSlot("Some port-sub-slot")
+ .build())
+ .build())
+ .build())
+ .setHardConstraints(new HardConstraintsBuilder()
+ .setCustomerCode(Set.of("Some customer-code"))
+ .setCoRouting(new CoRoutingBuilder()
+ .setServiceIdentifierList(Map.of(
+ new org.opendaylight.yang.gen.v1.http.org.openroadm.routing.constraints.rev211210.constraints.co
+ .routing.ServiceIdentifierListKey("Some existing-service"),
+ new ServiceIdentifierListBuilder().setServiceIdentifier("Some existing-service").build()))
+ .build())
+ .build())
+ .setSoftConstraints(new SoftConstraintsBuilder()
+ .setCustomerCode(Set.of("Some customer-code"))
+ .setCoRouting(new CoRoutingBuilder()
+ .setServiceIdentifierList(Map.of(
+ new org.opendaylight.yang.gen.v1.http.org.openroadm.routing.constraints.rev211210.constraints.co
+ .routing.ServiceIdentifierListKey("Some existing-service"),
+ new ServiceIdentifierListBuilder().setServiceIdentifier("Some existing-service").build()))
+ .build())
+ .build())
+ .build();
+ }
+
+ public static PathComputationRequestInput getPCE2Request(Uint32 rate, ServiceFormat serviceFormat, String aaNodeId,
+ String aaClliId, String aaPortName, String zzNodeId, String zzClliId, String zzPortName) {
+ return new PathComputationRequestInputBuilder()
+ .setServiceName("service1")
+ .setResourceReserve(true)
+ .setPceRoutingMetric(PceMetric.HopCount)
+ .setServiceHandlerHeader(new ServiceHandlerHeaderBuilder()
+ .setRequestId("request1")
+ .build())
+ .setServiceAEnd(new ServiceAEndBuilder()
+ .setServiceFormat(serviceFormat)
+ .setServiceRate(Uint32.valueOf(100))
+ .setClli(aaClliId)
+ .setNodeId(aaNodeId)
+ .setTxDirection(new TxDirectionBuilder()
+ .build())
+ .setRxDirection(new RxDirectionBuilder()
+ .build())
+ .build())
+ .setServiceZEnd(new ServiceZEndBuilder()
+ .setServiceFormat(serviceFormat)
+ .setServiceRate(Uint32.valueOf(0))
+ .setClli(zzClliId)
+ .setNodeId(zzNodeId)
+ .setTxDirection(new TxDirectionBuilder()
+ .build())
+ .setRxDirection(new RxDirectionBuilder()
+ .build())
+ .build())
+ .setHardConstraints(new HardConstraintsBuilder()
+ .setCustomerCode(Set.of("Some customer-code"))
+ .setCoRouting(new CoRoutingBuilder()
+ .setServiceIdentifierList(Map.of(
+ new org.opendaylight.yang.gen.v1.http.org.openroadm.routing.constraints.rev211210.constraints.co
+ .routing.ServiceIdentifierListKey("Some existing-service"),
+ new ServiceIdentifierListBuilder().setServiceIdentifier("Some existing-service").build()))
+ .build())
+ .build())
+ .setSoftConstraints(new SoftConstraintsBuilder()
+ .setCustomerCode(Set.of("Some customer-code"))
+ .setCoRouting(new CoRoutingBuilder()
+ .setServiceIdentifierList(Map.of(
+ new org.opendaylight.yang.gen.v1.http.org.openroadm.routing.constraints.rev211210.constraints.co
+ .routing.ServiceIdentifierListKey("Some existing-service"),
+ new ServiceIdentifierListBuilder().setServiceIdentifier("Some existing-service").build()))
+ .build())
+ .build())
+ .build();
+ }
+
+}