pce/src/test/java/org/opendaylight/transportpce/pce/graph/PceGraphTest.java

   1 /*
   2  * Copyright © 2020 Orange, Inc. and others.  All rights reserved.
   3  *
   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
   7  */
   8
   9 package org.opendaylight.transportpce.pce.graph;
  10
  11 import static org.junit.Assert.fail;
  12
  13 import com.google.common.collect.ImmutableMap;
  14 import com.google.gson.stream.JsonReader;
  15 import java.io.FileReader;
  16 import java.io.IOException;
  17 import java.io.Reader;
  18 import java.nio.charset.StandardCharsets;
  19 import java.util.Map;
  20 import java.util.Optional;
  21 import java.util.Set;
  22 import java.util.concurrent.ExecutionException;
  23 import org.eclipse.jdt.annotation.NonNull;
  24 import org.junit.Assert;
  25 import org.junit.Before;
  26 import org.junit.Test;
  27 import org.mockito.MockitoAnnotations;
  28 import org.opendaylight.mdsal.binding.api.DataBroker;
  29 import org.opendaylight.mdsal.binding.api.MountPoint;
  30 import org.opendaylight.mdsal.binding.api.MountPointService;
  31 import org.opendaylight.mdsal.binding.api.WriteTransaction;
  32 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  33 import org.opendaylight.transportpce.common.NetworkUtils;
  34 import org.opendaylight.transportpce.common.StringConstants;
  35 import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
  36 import org.opendaylight.transportpce.common.device.DeviceTransactionManagerImpl;
  37 import org.opendaylight.transportpce.common.mapping.PortMapping;
  38 import org.opendaylight.transportpce.common.mapping.PortMappingImpl;
  39 import org.opendaylight.transportpce.common.mapping.PortMappingVersion121;
  40 import org.opendaylight.transportpce.common.mapping.PortMappingVersion221;
  41 import org.opendaylight.transportpce.common.mapping.PortMappingVersion710;
  42 import org.opendaylight.transportpce.common.network.NetworkTransactionImpl;
  43 import org.opendaylight.transportpce.common.network.NetworkTransactionService;
  44 import org.opendaylight.transportpce.pce.constraints.PceConstraints;
  45 import org.opendaylight.transportpce.pce.networkanalyzer.PceCalculation;
  46 import org.opendaylight.transportpce.pce.networkanalyzer.PceLink;
  47 import org.opendaylight.transportpce.pce.networkanalyzer.PceNode;
  48 //import org.opendaylight.transportpce.pce.networkanalyzer.PceOpticalNode;
  49 import org.opendaylight.transportpce.pce.networkanalyzer.PceOtnNode;
  50 import org.opendaylight.transportpce.pce.networkanalyzer.PceResult;
  51 import org.opendaylight.transportpce.pce.utils.JsonUtil;
  52 import org.opendaylight.transportpce.pce.utils.NodeUtils;
  53 import org.opendaylight.transportpce.test.AbstractTest;
  54 import org.opendaylight.transportpce.test.converter.DataObjectConverter;
  55 import org.opendaylight.transportpce.test.converter.JSONDataObjectConverter;
  56 import org.opendaylight.transportpce.test.stub.MountPointServiceStub;
  57 import org.opendaylight.transportpce.test.stub.MountPointStub;
  58 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev220808.PathComputationRequestInput;
  59 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev220808.PathComputationRequestInputBuilder;
  60 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev220808.path.computation.request.input.ServiceAEndBuilder;
  61 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev220808.path.computation.request.input.ServiceZEndBuilder;
  62 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev211210.service.port.PortBuilder;
  63 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.state.types.rev191129.State;
  64 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev211210.OpenroadmVersionType;
  65 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.rev211210.Node1Builder;
  66 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev211210.TerminationPoint1Builder;
  67 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev211210.networks.network.node.termination.point.XpdrNetworkAttributesBuilder;
  68 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev211210.OpenroadmNodeType;
  69 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev211210.OpenroadmTpType;
  70 import org.opendaylight.yang.gen.v1.http.org.openroadm.routing.constraints.rev211210.constraints.CoRoutingBuilder;
  71 import org.opendaylight.yang.gen.v1.http.org.openroadm.routing.constraints.rev211210.constraints.co.routing.ServiceIdentifierListBuilder;
  72 import org.opendaylight.yang.gen.v1.http.org.openroadm.routing.constraints.rev211210.routing.constraints.HardConstraintsBuilder;
  73 import org.opendaylight.yang.gen.v1.http.org.openroadm.routing.constraints.rev211210.routing.constraints.SoftConstraintsBuilder;
  74 import org.opendaylight.yang.gen.v1.http.org.openroadm.service.format.rev191129.ServiceFormat;
  75 import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.OperationalModeCatalog;
  76 import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev220118.PceMetric;
  77 import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev220118.service.endpoint.sp.RxDirectionBuilder;
  78 import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev220118.service.endpoint.sp.TxDirectionBuilder;
  79 import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev220118.service.handler.header.ServiceHandlerHeaderBuilder;
  80 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NetworkId;
  81 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.Networks;
  82 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NodeId;
  83 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.Network;
  84 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.NetworkKey;
  85 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.Node;
  86 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.NodeBuilder;
  87 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.NodeKey;
  88 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.node.SupportingNode;
  89 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.node.SupportingNodeBuilder;
  90 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.node.SupportingNodeKey;
  91 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.LinkId;
  92 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.TpId;
  93 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.Link;
  94 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.node.TerminationPoint;
  95 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.node.TerminationPointBuilder;
  96 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.node.TerminationPointKey;
  97 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  98 import org.opendaylight.yangtools.yang.common.QName;
  99 import org.opendaylight.yangtools.yang.common.Uint32;
 100 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 101 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
 102 import org.slf4j.Logger;
 103 import org.slf4j.LoggerFactory;
 104
 105 public class PceGraphTest extends AbstractTest {
 106     private static final Logger LOG = LoggerFactory.getLogger(PceGraphTest.class);
 107     private Link link1 = null;
 108     private Node node = null;
 109     private PceLink pceLink1 = null;
 110     private PceGraph pceGraph = null;
 111     private PceConstraints pceHardConstraints = null;
 112     private PceResult rc = null;
 113     private Map<NodeId, PceNode> allPceNodes = null;
 114     private Map<LinkId, PceLink> allPceLinks = null;
 115     private static final String CATALOG_FILE = "src/test/resources/apidocCatalog10_1OptSpecV5_1.json";
 116     private static final String MAPPING_FILE = "src/test/resources/topologyData/portMapping2.json";
 117     private static OperationalModeCatalog omCatalog;
 118     private static org.opendaylight.yang.gen.v1.http.org.opendaylight
 119             .transportpce.portmapping.rev220316.Network networkNode;
 120     private DataBroker dataBroker;
 121     private MountPoint mountPoint;
 122     private MountPointService mountPointService;
 123     private DeviceTransactionManager deviceTransactionManager;
 124     private PortMappingVersion710 portMappingVersion710;
 125     private PortMappingVersion221 portMappingVersion22;
 126     private PortMappingVersion121 portMappingVersion121;
 127     private PortMapping portMapping;
 128     private NetworkTransactionService netTransServ;
 129
 130     // Test of integration for PceGraph
 131
 132     @Before
 133     public void setUp() throws InterruptedException, ExecutionException {
 134         // PortMapping is instantiated to create the mapping of the different nodes in the topology
 135         this.dataBroker =  getNewDataBroker();
 136         this.mountPoint = new MountPointStub(dataBroker);
 137         this.mountPointService = new MountPointServiceStub(mountPoint);
 138         this.deviceTransactionManager = new DeviceTransactionManagerImpl(mountPointService, 3000);
 139         this.portMappingVersion22 = new PortMappingVersion221(dataBroker, deviceTransactionManager);
 140         this.portMappingVersion121 = new PortMappingVersion121(dataBroker, deviceTransactionManager);
 141         this.portMappingVersion710 = new PortMappingVersion710(dataBroker, deviceTransactionManager);
 142         this.portMapping = new PortMappingImpl(dataBroker, this.portMappingVersion710,
 143             this.portMappingVersion22, this.portMappingVersion121);
 144         //  The catalog of operational mode needs to be loaded so that Ctalog primitives (CatlogUtils)
 145         // can retrieve physical parameters of the nodes of the path
 146         DataObjectConverter dataObjectConverter = JSONDataObjectConverter
 147             .createWithDataStoreUtil(getDataStoreContextUtil());
 148         try (Reader reader = new FileReader(CATALOG_FILE, StandardCharsets.UTF_8)) {
 149             NormalizedNode normalizedNode = dataObjectConverter
 150                 .transformIntoNormalizedNode(reader)
 151                 .get();
 152             omCatalog = (OperationalModeCatalog) getDataStoreContextUtil()
 153                 .getBindingDOMCodecServices()
 154                 .fromNormalizedNode(
 155                     YangInstanceIdentifier.of(OperationalModeCatalog.QNAME), normalizedNode)
 156                 .getValue();
 157             @NonNull
 158             WriteTransaction newWriteOnlyTransaction = dataBroker.newWriteOnlyTransaction();
 159             newWriteOnlyTransaction
 160                 .put(LogicalDatastoreType.CONFIGURATION,
 161                     InstanceIdentifier.create(OperationalModeCatalog.class),
 162                     omCatalog);
 163             newWriteOnlyTransaction.commit().get();
 164         } catch (IOException e) {
 165             LOG.error("Cannot load OpenROADM part of Operational Mode Catalog ", e);
 166             fail("Cannot load openROADM operational modes ");
 167         }
 168         // The mapping corresponding to the topology is directly populated from a file in the Dta Store
 169         try (Reader reader = new FileReader(MAPPING_FILE, StandardCharsets.UTF_8)) {
 170             NormalizedNode normalizedNode = dataObjectConverter.transformIntoNormalizedNode(reader).get();
 171             networkNode = (org.opendaylight.yang.gen.v1.http.org.opendaylight
 172                     .transportpce.portmapping.rev220316.Network) getDataStoreContextUtil()
 173                 .getBindingDOMCodecServices()
 174                 .fromNormalizedNode(
 175                     YangInstanceIdentifier.of(org.opendaylight.yang.gen.v1.http.org.opendaylight
 176                         .transportpce.portmapping.rev220316.Network.QNAME), normalizedNode)
 177                 .getValue();
 178             @NonNull
 179             WriteTransaction newWriteOnlyTransaction = dataBroker.newWriteOnlyTransaction();
 180             newWriteOnlyTransaction
 181                 .put(LogicalDatastoreType.CONFIGURATION,
 182                     InstanceIdentifier.create(org.opendaylight.yang.gen.v1.http.org.opendaylight
 183                         .transportpce.portmapping.rev220316.Network.class),
 184                     networkNode);
 185             newWriteOnlyTransaction.commit().get();
 186         } catch (IOException e) {
 187             LOG.error("Cannot load OpenROADM part of Operational Mode Catalog ", e);
 188             fail("Cannot load openROADM operational modes ");
 189         }
 190
 191         MockitoAnnotations.openMocks(this);
 192         // The topology (openROADM-Network and openROADM-topology layers) is loaded from a file
 193         JsonReader networkReader = null;
 194         JsonReader topoReader = null;
 195         try {
 196             // load openroadm-network
 197             Reader gnpyNetwork = new FileReader("src/test/resources/gnpy/gnpy_network.json", StandardCharsets.UTF_8);
 198             networkReader = new JsonReader(gnpyNetwork);
 199             Networks networks = (Networks) JsonUtil.getInstance().getDataObjectFromJson(networkReader,
 200                     QName.create("urn:ietf:params:xml:ns:yang:ietf-network", "2018-02-26", "networks"));
 201             saveOpenRoadmNetwork(networks.getNetwork().values().iterator().next(), NetworkUtils.UNDERLAY_NETWORK_ID);
 202             // load openroadm-topology
 203             Reader gnpyTopo =
 204                 new FileReader("src/test/resources/topologyData/or-base-topology.json", StandardCharsets.UTF_8);
 205             topoReader = new JsonReader(gnpyTopo);
 206             networks = (Networks) JsonUtil
 207                 .getInstance()
 208                 .getDataObjectFromJson(
 209                     topoReader,
 210                     QName.create("urn:ietf:params:xml:ns:yang:ietf-network", "2018-02-26", "networks"));
 211             saveOpenRoadmNetwork(networks.getNetwork().values().iterator().next(), NetworkUtils.OVERLAY_NETWORK_ID);
 212         } catch (IOException | InterruptedException | ExecutionException e) {
 213             LOG.error("Cannot init test ", e);
 214             fail("Cannot init test ");
 215         } finally {
 216             try {
 217                 if (networkReader != null) {
 218                     networkReader.close();
 219                 }
 220                 if (topoReader != null) {
 221                     topoReader.close();
 222                 }
 223             } catch (IOException e) {
 224                 LOG.warn("Cannot close reader ", e);
 225             }
 226         }
 227         // init PceHardContraints
 228         pceHardConstraints = new PceConstraints();
 229         this.rc = new PceResult();
 230         this.netTransServ = new NetworkTransactionImpl(dataBroker);
 231
 232         LOG.info("The value of the mapping is {}", portMapping);
 233
 234     }
 235
 236 //                       TOPOLOGY ON WHICH TEST ARE BASED
 237 //           _____                      _____                       _____
 238 //          |     | 20dB, 100km,PMD 2  |     | 20dB,100km, PMD 2   |     |
 239 //          |  1  |____________________|  2  |_____________________|  5  |
 240 //          |     |                    |     |                     |     |
 241 //          |_____|                    |_____|                     |_____|
 242 //              |___________      10km    |   20dB,100km,PMD32    /   |  100 km
 243 //                          |      5dB    |   _________|_________/    |  25 dB
 244 //                          |     PMD32 __|__/                      __|__PMD 2.0
 245 //        28dB, 100km,PMD 0 |          |     | 25dB,100km, PMD 2   |     |
 246 //                          |__________|  3  |_____________________|  4  |
 247 //                                     |     |                     |     |
 248 //                                     |_____|                     |_____|
 249 //
 250     @Test
 251     public void clacPath100GE() {
 252         PceCalculation pceCalc = new PceCalculation(getPCE1Request(Uint32.valueOf(100), ServiceFormat.Ethernet,
 253             "XPONDER-1", "Node1", "Client-1", "XPONDER-3", "Node3", "Client-1"),
 254             netTransServ, pceHardConstraints, null, rc, portMapping);
 255         pceCalc.retrievePceNetwork();
 256         pceGraph = new PceGraph(pceCalc.getaendPceNode(), pceCalc.getzendPceNode(),
 257             pceCalc.getAllPceNodes(), pceCalc.getAllPceLinks(), pceHardConstraints,
 258             null, rc, StringConstants.SERVICE_TYPE_100GE_T, netTransServ);
 259         Assert.assertEquals(pceGraph.calcPath(), true);
 260         Assert.assertEquals(Optional.ofNullable(pceGraph.getmargin()),
 261             Optional.ofNullable(3.0919881995992924));
 262     }
 263
 264     @Test
 265     public void clacPathOTUC2() {
 266         PceCalculation pceCalc = new PceCalculation(getPCE1Request(Uint32.valueOf(200), ServiceFormat.Ethernet,
 267             "XPONDER-1", "Node1", "XPDR-NW1-TX", "XPONDER-4", "Node4", "XPDR-NW1-RX"),
 268             netTransServ, pceHardConstraints, null, rc, portMapping);
 269         pceCalc.retrievePceNetwork();
 270         pceGraph = new PceGraph(pceCalc.getaendPceNode(), pceCalc.getzendPceNode(),
 271             pceCalc.getAllPceNodes(), pceCalc.getAllPceLinks(), pceHardConstraints,
 272             null, rc, StringConstants.SERVICE_TYPE_OTUC2, netTransServ);
 273         Assert.assertEquals(pceGraph.calcPath(), true);
 274         Assert.assertEquals(Optional.ofNullable(pceGraph.getmargin()),
 275             Optional.ofNullable(1.1559963686478447));
 276     }
 277
 278     @Test
 279     public void clacPathOTUC3() {
 280         PceCalculation pceCalc = new PceCalculation(getPCE1Request(Uint32.valueOf(300), ServiceFormat.Ethernet,
 281             "XPONDER-1", "Node1", "XPDR-NW1-TX", "XPONDER-3", "Node3", "XPDR-NW1-RX"),
 282             netTransServ, pceHardConstraints, null, rc, portMapping);
 283         pceCalc.retrievePceNetwork();
 284         pceGraph = new PceGraph(pceCalc.getaendPceNode(), pceCalc.getzendPceNode(),
 285             pceCalc.getAllPceNodes(), pceCalc.getAllPceLinks(), pceHardConstraints,
 286             null, rc, StringConstants.SERVICE_TYPE_OTUC3, netTransServ);
 287         Assert.assertEquals(pceGraph.calcPath(), true);
 288         Assert.assertEquals(Optional.ofNullable(pceGraph.getmargin()),
 289             Optional.ofNullable(0.3351048800367167));
 290     }
 291
 292     @Test
 293     public void clacUnfeasiblePath400GE() {
 294         PceCalculation pceCalc = new PceCalculation(getPCE1Request(Uint32.valueOf(400), ServiceFormat.Ethernet,
 295             "XPONDER-1", "Node1", "Client-1", "XPONDER-3", "Node3", "Client-1"),
 296             netTransServ, pceHardConstraints, null, rc, portMapping);
 297         pceCalc.retrievePceNetwork();
 298         pceGraph = new PceGraph(pceCalc.getaendPceNode(), pceCalc.getzendPceNode(),
 299             pceCalc.getAllPceNodes(), pceCalc.getAllPceLinks(), pceHardConstraints,
 300             null, rc, StringConstants.SERVICE_TYPE_400GE, netTransServ);
 301         Assert.assertEquals(pceGraph.calcPath(), false);
 302         Assert.assertEquals(Optional.ofNullable(pceGraph.getmargin()),
 303             Optional.ofNullable(0.0));
 304     }
 305
 306     @Test
 307     public void clacPath400GE() {
 308         PceCalculation pceCalc = new PceCalculation(getPCE1Request(Uint32.valueOf(400), ServiceFormat.Ethernet,
 309             "XPONDER-1", "Node1", "Client-1", "XPONDER-5", "Node5", "Client-1"),
 310             netTransServ, pceHardConstraints, null, rc, portMapping);
 311         pceCalc.retrievePceNetwork();
 312         pceGraph = new PceGraph(pceCalc.getaendPceNode(), pceCalc.getzendPceNode(),
 313             pceCalc.getAllPceNodes(), pceCalc.getAllPceLinks(), pceHardConstraints,
 314             null, rc, StringConstants.SERVICE_TYPE_400GE, netTransServ);
 315         Assert.assertEquals(pceGraph.calcPath(), true);
 316         Assert.assertEquals(Optional.ofNullable(pceGraph.getmargin()),
 317             Optional.ofNullable(1.4432381874659086));
 318     }
 319
 320     @Test
 321     public void clacPathOTUC4() {
 322         PceCalculation pceCalc = new PceCalculation(getPCE1Request(Uint32.valueOf(400), ServiceFormat.Ethernet,
 323             "XPONDER-1", "Node1", "XPDR-NW1-TX", "XPONDER-5", "Node5", "XPDR-NW1-RX"),
 324             netTransServ, pceHardConstraints, null, rc, portMapping);
 325         pceCalc.retrievePceNetwork();
 326         pceGraph = new PceGraph(pceCalc.getaendPceNode(), pceCalc.getzendPceNode(),
 327             pceCalc.getAllPceNodes(), pceCalc.getAllPceLinks(), pceHardConstraints,
 328             null, rc, StringConstants.SERVICE_TYPE_OTUC4, netTransServ);
 329         Assert.assertEquals(pceGraph.calcPath(), true);
 330         Assert.assertEquals(Optional.ofNullable(pceGraph.getmargin()),
 331             Optional.ofNullable(1.4432381874659086));
 332     }
 333
 334     @Test
 335     public void clacOpticalTunnelOTUC4() {
 336         PceCalculation pceCalc = new PceCalculation(getPCE1Request(Uint32.valueOf(400), ServiceFormat.OC,
 337             "OpenROADM-1", "Node1", "DEG1-PP-TX", "OpenROADM-5", "Node5", "DEG3-PP-TX"),
 338             netTransServ, pceHardConstraints, null, rc, portMapping);
 339         pceCalc.retrievePceNetwork();
 340         pceGraph = new PceGraph(pceCalc.getaendPceNode(), pceCalc.getzendPceNode(),
 341             pceCalc.getAllPceNodes(), pceCalc.getAllPceLinks(), pceHardConstraints,
 342             null, rc, StringConstants.SERVICE_TYPE_OTUC4, netTransServ);
 343         Assert.assertEquals(pceGraph.calcPath(), true);
 344         Assert.assertEquals(Optional.ofNullable(pceGraph.getmargin()),
 345             Optional.ofNullable(0.0));
 346     }
 347
 348     @Test
 349     public void clacPath100GEnoPort() {
 350         PceCalculation pceCalc = new PceCalculation(getPCE2Request(Uint32.valueOf(100), ServiceFormat.Ethernet,
 351             "XPONDER-1", "Node1", "Client-1", "XPONDER-3", "Node3", "Client-1"),
 352             netTransServ, pceHardConstraints, null, rc, portMapping);
 353         pceCalc.retrievePceNetwork();
 354         pceGraph = new PceGraph(pceCalc.getaendPceNode(), pceCalc.getzendPceNode(),
 355             pceCalc.getAllPceNodes(), pceCalc.getAllPceLinks(), pceHardConstraints,
 356             null, rc, StringConstants.SERVICE_TYPE_100GE_T, netTransServ);
 357         Assert.assertEquals(pceGraph.calcPath(), true);
 358         Assert.assertEquals(Optional.ofNullable(pceGraph.getmargin()),
 359             Optional.ofNullable(3.0919881995992924));
 360     }
 361
 362     @Test
 363     public void clacPathPropagationDelay() {
 364         PceCalculation pceCalc = new PceCalculation(getPCE1Request(Uint32.valueOf(100), ServiceFormat.Ethernet,
 365             "XPONDER-1", "Node1", "Client-1", "XPONDER-3", "Node3", "Client-1"),
 366             netTransServ, pceHardConstraints, null, rc, portMapping);
 367         pceCalc.retrievePceNetwork();
 368         pceHardConstraints.setPceMetrics(PceMetric.PropagationDelay);
 369         pceGraph = new PceGraph(pceCalc.getaendPceNode(), pceCalc.getzendPceNode(),
 370             pceCalc.getAllPceNodes(), pceCalc.getAllPceLinks(), pceHardConstraints,
 371             null, rc, StringConstants.SERVICE_TYPE_100GE_T, netTransServ);
 372         pceGraph.setConstrains(pceHardConstraints, null);
 373
 374         Assert.assertEquals(pceGraph.calcPath(), true);
 375         Assert.assertEquals(Optional.ofNullable(pceGraph.getPathAtoZ().get(2).getLatency()),
 376             Optional.ofNullable(1.0));
 377         Assert.assertEquals(pceGraph.getReturnStructure().getRate(), 100);
 378     }
 379
 380     @Test(expected = Exception.class)
 381     public void clacPath10GE2() {
 382         pceGraph = getOtnPceGraph(StringConstants.SERVICE_TYPE_10GE);
 383         Assert.assertEquals(pceGraph.calcPath(), false);
 384     }
 385
 386     @Test(expected = Exception.class)
 387     public void clacPath1GE() {
 388         pceGraph = getOtnPceGraph(StringConstants.SERVICE_TYPE_1GE);
 389         Assert.assertEquals(pceGraph.calcPath(), false);
 390     }
 391
 392     private PceGraph getOtnPceGraph(String type) {
 393         // Build Link
 394         link1 = NodeUtils.createRoadmToRoadm("optical",
 395             "optical2",
 396             "DEG1-TTP-TX", "DEG1-TTP-RX").build();
 397
 398         node = NodeUtils.getOTNNodeBuilder(NodeUtils.geSupportingNodes(), OpenroadmTpType.XPONDERNETWORK).build();
 399
 400         PceOtnNode pceOtnNode = new PceOtnNode(node, OpenroadmNodeType.MUXPDR,
 401             new NodeId("optical"), ServiceFormat.OTU.getName(), "serviceType", null);
 402         pceOtnNode.validateXponder("optical", "sl");
 403         pceOtnNode.validateXponder("not optical", "sl");
 404         pceOtnNode.initXndrTps("AZ");
 405         pceOtnNode.checkAvailableTribPort();
 406         pceOtnNode.checkAvailableTribSlot();
 407
 408         PceOtnNode pceOtnNode2 = new PceOtnNode(node, OpenroadmNodeType.MUXPDR,
 409             new NodeId("optical2"), ServiceFormat.OTU.getName(), "serviceType", null);
 410         pceOtnNode2.validateXponder("optical", "sl");
 411         pceOtnNode2.validateXponder("not optical", "sl");
 412         pceOtnNode2.initXndrTps("AZ");
 413         pceOtnNode2.initXndrTps("mode");
 414         pceOtnNode2.checkAvailableTribPort();
 415         pceOtnNode2.checkAvailableTribSlot();
 416
 417         pceLink1 = new PceLink(link1, pceOtnNode, pceOtnNode2);
 418         pceLink1.setClient("XPONDER-CLIENT");
 419
 420         pceLink1.getDestId();
 421         pceOtnNode.addOutgoingLink(pceLink1);
 422
 423         // init PceHardContraints
 424         pceHardConstraints = new PceConstraints();
 425         // pceHardConstraints.setp
 426         allPceNodes = Map.of(
 427             new NodeId("optical"), pceOtnNode,
 428             new NodeId("optical2"), pceOtnNode2);
 429         return new PceGraph(pceOtnNode, pceOtnNode2, allPceNodes,
 430             allPceLinks, pceHardConstraints,
 431             null, new PceResult(),
 432             type, null);
 433     }
 434
 435     private void saveOpenRoadmNetwork(Network network, String networkId)
 436             throws InterruptedException, ExecutionException {
 437         InstanceIdentifier<Network> nwInstanceIdentifier = InstanceIdentifier.builder(Networks.class)
 438             .child(Network.class, new NetworkKey(new NetworkId(networkId))).build();
 439         WriteTransaction dataWriteTransaction = dataBroker.newWriteOnlyTransaction();
 440         dataWriteTransaction.put(LogicalDatastoreType.CONFIGURATION, nwInstanceIdentifier, network);
 441         dataWriteTransaction.commit().get();
 442     }
 443
 444     public static Node createNetworkNode(String nodeId, OpenroadmNodeType nodeType) {
 445         SupportingNode supportingNode = new SupportingNodeBuilder()
 446             .setNetworkRef(new NetworkId(NetworkUtils.CLLI_NETWORK_ID))
 447             .setNodeRef(new NodeId("node1"))
 448             .withKey(new SupportingNodeKey(new NetworkId(NetworkUtils.CLLI_NETWORK_ID),
 449                 new NodeId("node1")))
 450             .build();
 451         return new NodeBuilder()
 452             .setNodeId(new NodeId(nodeId))
 453             .withKey(new NodeKey(new NodeId(nodeId)))
 454             .setSupportingNode(ImmutableMap.of(supportingNode.key(), supportingNode))
 455             .addAugmentation(
 456                 new Node1Builder().setOpenroadmVersion(OpenroadmVersionType._221).build())
 457             .addAugmentation(
 458                 new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev211210.Node1Builder()
 459                     .setNodeType(nodeType).build())
 460             .build();
 461     }
 462
 463     public static TerminationPoint createNetworkTp(String nodeId, String tpId) {
 464         var nwTpId = new TpId(tpId);
 465         return new TerminationPointBuilder()
 466             .setTpId(nwTpId)
 467             .withKey(new TerminationPointKey(nwTpId))
 468             .addAugmentation(new TerminationPoint1Builder()
 469                 .setXpdrNetworkAttributes(new XpdrNetworkAttributesBuilder().setState(State.InService).build())
 470                 .build())
 471             .build();
 472     }
 473
 474     public static Node createTopologyNode(String nodeId, OpenroadmNodeType nodeType) {
 475         SupportingNode supportingNode = new SupportingNodeBuilder()
 476             .setNetworkRef(new NetworkId(NetworkUtils.UNDERLAY_NETWORK_ID))
 477             .setNodeRef(new NodeId("node1"))
 478             .withKey(new SupportingNodeKey(new NetworkId(NetworkUtils.UNDERLAY_NETWORK_ID),
 479                 new NodeId("node1")))
 480             .build();
 481         return new NodeBuilder()
 482             .setNodeId(new NodeId(nodeId))
 483             .withKey(new NodeKey(new NodeId(nodeId)))
 484             .setSupportingNode(ImmutableMap.of(supportingNode.key(), supportingNode))
 485             .addAugmentation(
 486                 new org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev211210.Node1Builder()
 487                     .setXpdrAttributes(null).build())
 488             .addAugmentation(
 489                 new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev211210.Node1Builder()
 490                     .setNodeType(nodeType).build())
 491             .build();
 492     }
 493
 494     public static PathComputationRequestInput getPCE1Request(Uint32 rate, ServiceFormat serviceFormat, String aaNodeId,
 495             String aaClliId, String aaPortName, String zzNodeId, String zzClliId, String zzPortName) {
 496         return new PathComputationRequestInputBuilder()
 497             .setServiceName("service1")
 498             .setResourceReserve(true)
 499             .setPceRoutingMetric(PceMetric.HopCount)
 500             .setServiceHandlerHeader(new ServiceHandlerHeaderBuilder()
 501                 .setRequestId("request1")
 502                 .build())
 503             .setServiceAEnd(new ServiceAEndBuilder()
 504                 .setServiceFormat(serviceFormat)
 505                 .setServiceRate(Uint32.valueOf(100))
 506                 .setClli(aaClliId)
 507                 .setNodeId(aaNodeId)
 508                 .setTxDirection(new TxDirectionBuilder()
 509                     .setPort(new PortBuilder()
 510                         .setPortDeviceName(aaNodeId)
 511                         .setPortType("fixed")
 512                         .setPortName(aaPortName)
 513                         .setPortRack("Some port-rack")
 514                         .setPortShelf("Some port-shelf")
 515                         .setPortSlot("Some port-slot")
 516                         .setPortSubSlot("Some port-sub-slot")
 517                         .build())
 518                     .build())
 519                 .setRxDirection(new RxDirectionBuilder()
 520                     .setPort(new PortBuilder()
 521                         .setPortDeviceName(aaNodeId)
 522                         .setPortType("fixed")
 523                         .setPortName(aaPortName)
 524                         .setPortRack("Some port-rack")
 525                         .setPortShelf("Some port-shelf")
 526                         .setPortSlot("Some port-slot")
 527                         .setPortSubSlot("Some port-sub-slot")
 528                         .build())
 529                     .build())
 530                 .build())
 531             .setServiceZEnd(new ServiceZEndBuilder()
 532                 .setServiceFormat(serviceFormat)
 533                 .setServiceRate(Uint32.valueOf(0))
 534                 .setClli(zzClliId)
 535                 .setNodeId(zzNodeId)
 536                 .setTxDirection(new TxDirectionBuilder()
 537                     .setPort(new PortBuilder()
 538                         .setPortDeviceName(zzNodeId)
 539                         .setPortType("fixed")
 540                         .setPortName(zzPortName)
 541                         .setPortRack("Some port-rack")
 542                         .setPortShelf("Some port-shelf")
 543                         .setPortSlot("Some port-slot")
 544                         .setPortSubSlot("Some port-sub-slot")
 545                         .build())
 546                     .build())
 547                 .setRxDirection(new RxDirectionBuilder()
 548                     .setPort(new PortBuilder()
 549                         .setPortDeviceName(zzNodeId)
 550                         .setPortType("fixed")
 551                         .setPortName(zzPortName)
 552                         .setPortRack("Some port-rack")
 553                         .setPortShelf("Some port-shelf")
 554                         .setPortSlot("Some port-slot")
 555                         .setPortSubSlot("Some port-sub-slot")
 556                         .build())
 557                     .build())
 558                 .build())
 559             .setHardConstraints(new HardConstraintsBuilder()
 560                 .setCustomerCode(Set.of("Some customer-code"))
 561                 .setCoRouting(new CoRoutingBuilder()
 562                     .setServiceIdentifierList(Map.of(
 563                         new org.opendaylight.yang.gen.v1.http.org.openroadm.routing.constraints.rev211210.constraints.co
 564                                 .routing.ServiceIdentifierListKey("Some existing-service"),
 565                         new ServiceIdentifierListBuilder().setServiceIdentifier("Some existing-service").build()))
 566                     .build())
 567                 .build())
 568             .setSoftConstraints(new SoftConstraintsBuilder()
 569                 .setCustomerCode(Set.of("Some customer-code"))
 570                 .setCoRouting(new CoRoutingBuilder()
 571                     .setServiceIdentifierList(Map.of(
 572                         new org.opendaylight.yang.gen.v1.http.org.openroadm.routing.constraints.rev211210.constraints.co
 573                                 .routing.ServiceIdentifierListKey("Some existing-service"),
 574                         new ServiceIdentifierListBuilder().setServiceIdentifier("Some existing-service").build()))
 575                     .build())
 576                 .build())
 577             .build();
 578     }
 579
 580     public static PathComputationRequestInput getPCE2Request(Uint32 rate, ServiceFormat serviceFormat, String aaNodeId,
 581             String aaClliId, String aaPortName, String zzNodeId, String zzClliId, String zzPortName) {
 582         return new PathComputationRequestInputBuilder()
 583             .setServiceName("service1")
 584             .setResourceReserve(true)
 585             .setPceRoutingMetric(PceMetric.HopCount)
 586             .setServiceHandlerHeader(new ServiceHandlerHeaderBuilder()
 587                 .setRequestId("request1")
 588                 .build())
 589             .setServiceAEnd(new ServiceAEndBuilder()
 590                 .setServiceFormat(serviceFormat)
 591                 .setServiceRate(Uint32.valueOf(100))
 592                 .setClli(aaClliId)
 593                 .setNodeId(aaNodeId)
 594                 .setTxDirection(new TxDirectionBuilder()
 595                   .build())
 596                 .setRxDirection(new RxDirectionBuilder()
 597                     .build())
 598                 .build())
 599             .setServiceZEnd(new ServiceZEndBuilder()
 600                 .setServiceFormat(serviceFormat)
 601                 .setServiceRate(Uint32.valueOf(0))
 602                 .setClli(zzClliId)
 603                 .setNodeId(zzNodeId)
 604                 .setTxDirection(new TxDirectionBuilder()
 605                     .build())
 606                 .setRxDirection(new RxDirectionBuilder()
 607                     .build())
 608                 .build())
 609             .setHardConstraints(new HardConstraintsBuilder()
 610                 .setCustomerCode(Set.of("Some customer-code"))
 611                 .setCoRouting(new CoRoutingBuilder()
 612                     .setServiceIdentifierList(Map.of(
 613                         new org.opendaylight.yang.gen.v1.http.org.openroadm.routing.constraints.rev211210.constraints.co
 614                                 .routing.ServiceIdentifierListKey("Some existing-service"),
 615                         new ServiceIdentifierListBuilder().setServiceIdentifier("Some existing-service").build()))
 616                     .build())
 617                 .build())
 618             .setSoftConstraints(new SoftConstraintsBuilder()
 619                 .setCustomerCode(Set.of("Some customer-code"))
 620                 .setCoRouting(new CoRoutingBuilder()
 621                     .setServiceIdentifierList(Map.of(
 622                         new org.opendaylight.yang.gen.v1.http.org.openroadm.routing.constraints.rev211210.constraints.co
 623                                 .routing.ServiceIdentifierListKey("Some existing-service"),
 624                         new ServiceIdentifierListBuilder().setServiceIdentifier("Some existing-service").build()))
 625                     .build())
 626                 .build())
 627                     .build();
 628     }
 629
 630 }