.getOrDefault(Uint32.valueOf(rc.getRate()), ModulationFormat.DpQpsk).getName())
.setAToZ(atozMap);
switch (rc.getServiceType()) {
+ case StringConstants.SERVICE_TYPE_400GE:
case StringConstants.SERVICE_TYPE_100GE:
case StringConstants.SERVICE_TYPE_OTU4:
atoZDirectionBldr.setAToZMaxFrequency(new FrequencyTHz(rc.getMaxFreq()));
}
break;
default:
+ LOG.warn("unknown service type : unable to set Min/Max frequencies");
break;
}
return atoZDirectionBldr;
.getOrDefault(Uint32.valueOf(rc.getRate()), ModulationFormat.DpQpsk).getName())
.setZToA(ztoaMap);
switch (rc.getServiceType()) {
+ case StringConstants.SERVICE_TYPE_400GE:
case StringConstants.SERVICE_TYPE_100GE:
case StringConstants.SERVICE_TYPE_OTU4:
ztoADirectionBldr.setZToAMaxFrequency(new FrequencyTHz(rc.getMaxFreq()));
}
break;
default:
+ LOG.warn("unknown service type : unable to set Min/Max frequencies");
break;
}
return ztoADirectionBldr;
package org.opendaylight.transportpce.pce;
import org.opendaylight.transportpce.common.ResponseCodes;
+import org.opendaylight.transportpce.common.mapping.PortMapping;
import org.opendaylight.transportpce.common.network.NetworkTransactionService;
import org.opendaylight.transportpce.pce.constraints.PceConstraints;
import org.opendaylight.transportpce.pce.constraints.PceConstraintsCalc;
private String message;
private String responseCode;
private final GnpyConsumer gnpyConsumer;
+ private PortMapping portMapping;
public PceSendingPceRPCs(GnpyConsumer gnpyConsumer) {
setPathDescription(null);
}
public PceSendingPceRPCs(PathComputationRequestInput input,
- NetworkTransactionService networkTransaction, GnpyConsumer gnpyConsumer) {
+ NetworkTransactionService networkTransaction, GnpyConsumer gnpyConsumer, PortMapping portMapping) {
this.gnpyConsumer = gnpyConsumer;
setPathDescription(null);
// TODO compliance check to check that input is not empty
this.input = input;
this.networkTransaction = networkTransaction;
+ this.portMapping = portMapping;
}
public void cancelResourceReserve() {
public void pathComputationWithConstraints(PceConstraints hardConstraints, PceConstraints softConstraints) {
PceCalculation nwAnalizer =
- new PceCalculation(input, networkTransaction, hardConstraints, softConstraints, rc);
+ new PceCalculation(input, networkTransaction, hardConstraints, softConstraints, rc, portMapping);
nwAnalizer.retrievePceNetwork();
rc = nwAnalizer.getReturnStructure();
String serviceType = nwAnalizer.getServiceType();
pceResult.getResponseCode(), ResponseCodes.RESPONSE_OK);
if (!pceResult.getResponseCode().equals(ResponseCodes.RESPONSE_OK)) {
- LOG.info("In calcPath: post algo validations DROPPED the path {}", path);
+ LOG.warn("In calcPath: post algo validations DROPPED the path {}", path);
continue;
}
switch (serviceType) {
case StringConstants.SERVICE_TYPE_100GE:
+ case StringConstants.SERVICE_TYPE_400GE:
case StringConstants.SERVICE_TYPE_OTU4:
LOG.info(
"In calcPath Path FOUND path for wl [{}], min Freq assignment {}, max Freq assignment {},"
return pceResult;
}
int tribSlotNb = 1;
+ int spectralWidthSlotNumber = GridConstant.SPECTRAL_WIDTH_SLOT_NUMBER_MAP
+ .getOrDefault(serviceType, GridConstant.NB_SLOTS_100G);
+ SpectrumAssignment spectrumAssignment = null;
//variable to deal with 1GE (Nb=1) and 10GE (Nb=10) cases
switch (serviceType) {
-
+ case StringConstants.SERVICE_TYPE_400GE:
+ spectralWidthSlotNumber = GridConstant.SPECTRAL_WIDTH_SLOT_NUMBER_MAP
+ .getOrDefault(serviceType, GridConstant.NB_SLOTS_400G);
+ //fallthrough
case StringConstants.SERVICE_TYPE_100GE:
case StringConstants.SERVICE_TYPE_OTU4:
- int spectralWidthSlotNumber = GridConstant.SPECTRAL_WIDTH_SLOT_NUMBER_MAP
- .getOrDefault(serviceType, GridConstant.NB_SLOTS_100G);
- SpectrumAssignment spectrumAssignment = getSpectrumAssignment(path,
+ spectrumAssignment = getSpectrumAssignment(path,
allPceNodes, spectralWidthSlotNumber);
pceResult.setServiceType(serviceType);
if (spectrumAssignment.getBeginIndex() == 0 && spectrumAssignment.getStopIndex() == 0) {
pceResult.setRC(ResponseCodes.RESPONSE_OK);
pceResult.setLocalCause(PceResult.LocalCause.NONE);
-
break;
-
case StringConstants.SERVICE_TYPE_10GE:
tribSlotNb = 8;
//fallthrough
tribPort, tribSlot, tribSlotNb);
}
break;
-
case StringConstants.SERVICE_TYPE_ODU4:
pceResult.setRC(ResponseCodes.RESPONSE_OK);
LOG.info("In PostAlgoPathValidator: ODU4 path found {}", path);
break;
-
default:
pceResult.setRC(ResponseCodes.RESPONSE_FAILED);
LOG.warn("In PostAlgoPathValidator checkPath: unsupported serviceType {} found {}",
serviceType, path);
break;
}
-
return pceResult;
}
import org.opendaylight.transportpce.common.fixedflex.GridConstant;
import org.opendaylight.transportpce.common.mapping.MappingUtils;
import org.opendaylight.transportpce.common.mapping.MappingUtilsImpl;
+import org.opendaylight.transportpce.common.mapping.PortMapping;
import org.opendaylight.transportpce.common.network.NetworkTransactionService;
import org.opendaylight.transportpce.pce.constraints.PceConstraints;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev200128.PathComputationRequestInput;
private Map<LinkId, PceLink> allPceLinks = new HashMap<>();
private Set<LinkId> linksToExclude = new HashSet<>();
private PceResult returnStructure;
+ private PortMapping portMapping;
private enum ConstraintTypes {
NONE, HARD_EXCLUDE, HARD_INCLUDE, HARD_DIVERSITY, SOFT_EXCLUDE, SOFT_INCLUDE, SOFT_DIVERSITY;
private MappingUtils mappingUtils;
public PceCalculation(PathComputationRequestInput input, NetworkTransactionService networkTransactionService,
- PceConstraints pceHardConstraints, PceConstraints pceSoftConstraints, PceResult rc) {
+ PceConstraints pceHardConstraints, PceConstraints pceSoftConstraints, PceResult rc,
+ PortMapping portMapping) {
this.input = input;
this.networkTransactionService = networkTransactionService;
this.returnStructure = rc;
this.pceHardConstraints = pceHardConstraints;
this.mappingUtils = new MappingUtilsImpl(networkTransactionService.getDataBroker());
+ this.portMapping = portMapping;
parseInput();
}
//Maybe HashMap and similar options should also be considered here.
} else if ("Ethernet".equals(serviceFormatA)) {
//only rate 100L is currently supported except in Ethernet
- if (serviceRate == 10L) {
+ if (serviceRate == 400L) {
+ serviceType = StringConstants.SERVICE_TYPE_400GE;
+ } else if (serviceRate == 10L) {
serviceType = StringConstants.SERVICE_TYPE_10GE;
} else if (serviceRate == 1L) {
serviceType = StringConstants.SERVICE_TYPE_1GE;
private boolean readMdSal() {
InstanceIdentifier<Network> nwInstanceIdentifier = null;
Network nw = null;
- if (("OC".equals(serviceFormatA)) || ("OTU".equals(serviceFormatA)) || (("Ethernet".equals(serviceFormatA))
- && (serviceRate == 100L))) {
-
+ if (("OC".equals(serviceFormatA)) || ("OTU".equals(serviceFormatA))
+ || ("Ethernet".equals(serviceFormatA) && ((serviceRate == 100L) || (serviceRate == 400L)))) {
LOG.info("readMdSal: network {}", NetworkUtils.OVERLAY_NETWORK_ID);
nwInstanceIdentifier = InstanceIdentifier.builder(Networks.class)
.child(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID))).build();
- } else if ("ODU".equals(serviceFormatA) || ("Ethernet".equals(serviceFormatA) && serviceRate == 10L)
- || ("Ethernet".equals(serviceFormatA) && serviceRate == 1L)) {
+ } else if ("ODU".equals(serviceFormatA)
+ || ("Ethernet".equals(serviceFormatA) && ((serviceRate == 10L) || (serviceRate == 1L)))) {
LOG.info("readMdSal: network {}", NetworkUtils.OTN_NETWORK_ID);
nwInstanceIdentifier = InstanceIdentifier.builder(Networks.class)
.child(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OTN_NETWORK_ID))).build();
LOG.debug("analyzeNw: allNodes size {}, allLinks size {}", allNodes.size(), allLinks.size());
- if ((StringConstants.SERVICE_TYPE_100GE.equals(serviceType))
- || (StringConstants.SERVICE_TYPE_OTU4.equals(serviceType))) {
+ if (StringConstants.SERVICE_TYPE_100GE.equals(serviceType)
+ || StringConstants.SERVICE_TYPE_OTU4.equals(serviceType)
+ || StringConstants.SERVICE_TYPE_400GE.equals(serviceType)) {
// 100GE service and OTU4 service are handled at the openroadm-topology layer
for (Node node : allNodes) {
validateNode(node);
return false;
}
- if ((StringConstants.SERVICE_TYPE_100GE.equals(serviceType))
- || (StringConstants.SERVICE_TYPE_OTU4.equals(serviceType))) {
- // 100GE or OTU4 services are handled at WDM Layer
+ if (StringConstants.SERVICE_TYPE_100GE.equals(serviceType)
+ || StringConstants.SERVICE_TYPE_OTU4.equals(serviceType)
+ || StringConstants.SERVICE_TYPE_400GE.equals(serviceType)) {
+ // 100GE or 400GE or OTU4 services are handled at WDM Layer
PceLink pcelink = new PceLink(link, source, dest);
if (!pcelink.isValid()) {
dropOppositeLink(link);
}
- private boolean validateNode(Node node) {
+ private void validateNode(Node node) {
LOG.debug("validateNode: node {} ", node);
// PceNode will be used in Graph algorithm
Node1 node1 = node.augmentation(Node1.class);
if (node1 == null) {
LOG.error("getNodeType: no Node1 (type) Augmentation for node: [{}]. Node is ignored", node.getNodeId());
- return false;
+ return;
}
if (State.OutOfService.equals(node1.getOperationalState())) {
LOG.error("getNodeType: node is ignored due to operational state - {}", node1.getOperationalState()
.getName());
- return false;
+ return;
}
OpenroadmNodeType nodeType = node1.getNodeType();
String deviceNodeId = MapUtils.getSupNetworkNode(node);
if (deviceNodeId == null || deviceNodeId.isBlank()) {
deviceNodeId = node.getNodeId().getValue();
}
+
LOG.info("Device node id {} for {}", deviceNodeId, node);
- PceOpticalNode pceNode = new PceOpticalNode(node, nodeType, mappingUtils.getOpenRoadmVersion(deviceNodeId),
- getSlotWidthGranularity(deviceNodeId, node.getNodeId()));
+ PceOpticalNode pceNode = new PceOpticalNode(deviceNodeId, this.serviceType, portMapping, node, nodeType,
+ mappingUtils.getOpenRoadmVersion(deviceNodeId), getSlotWidthGranularity(deviceNodeId, node.getNodeId()));
pceNode.validateAZxponder(anodeId, znodeId, input.getServiceAEnd().getServiceFormat());
pceNode.initFrequenciesBitSet();
if (!pceNode.isValid()) {
LOG.warn(" validateNode: Node is ignored");
- return false;
+ return;
}
if (validateNodeConstraints(pceNode).equals(ConstraintTypes.HARD_EXCLUDE)) {
- return false;
+ return;
}
if (endPceNode(nodeType, pceNode.getNodeId(), pceNode) && this.aendPceNode == null
&& isAZendPceNode(this.serviceFormatA, pceNode, anodeId, "A")) {
allPceNodes.put(pceNode.getNodeId(), pceNode);
LOG.debug("validateNode: node is saved {}", pceNode.getNodeId().getValue());
- return true;
+ return;
}
private boolean isAZendPceNode(String serviceFormat, PceOpticalNode pceNode, String azNodeId, String azEndPoint) {
}
}
- private boolean validateOtnNode(Node node) {
+ private void validateOtnNode(Node node) {
LOG.info("validateOtnNode: {} ", node.getNodeId().getValue());
// PceOtnNode will be used in Graph algorithm
if (node.augmentation(Node1.class) != null) {
if (!pceOtnNode.isValid()) {
LOG.warn(" validateOtnNode: Node {} is ignored", node.getNodeId().getValue());
- return false;
+ return;
}
if (validateNodeConstraints(pceOtnNode).equals(ConstraintTypes.HARD_EXCLUDE)) {
- return false;
+ return;
}
if (pceOtnNode.getNodeId().getValue().equals(anodeId) && this.aendPceNode == null) {
this.aendPceNode = pceOtnNode;
}
allPceNodes.put(pceOtnNode.getNodeId(), pceOtnNode);
LOG.info("validateOtnNode: node {} is saved", node.getNodeId().getValue());
- return true;
+ return;
} else {
LOG.error("ValidateOtnNode: no node-type augmentation. Node {} is ignored", node.getNodeId().getValue());
- return false;
+ return;
}
}
import java.util.Optional;
import java.util.TreeMap;
import org.opendaylight.transportpce.common.fixedflex.GridConstant;
+import org.opendaylight.transportpce.common.mapping.PortMapping;
import org.opendaylight.transportpce.pce.SortPortsByName;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.Mapping;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.TerminationPoint1;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.state.types.rev191129.State;
import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev191129.AdminStates;
import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev200529.OpenroadmNodeType;
import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev200529.OpenroadmTpType;
import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev200529.available.freq.map.AvailFreqMapsKey;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev200327.IfOCH;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev200327.IfOTUCnODUCn;
import org.opendaylight.yang.gen.v1.http.org.openroadm.service.format.rev190531.ServiceFormat;
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.Node;
private Node node;
private NodeId nodeId;
+ private String deviceNodeId;
private OpenroadmNodeType nodeType;
private AdminStates adminStates;
private State state;
+ private String serviceType;
+ private PortMapping portMapping;
private Map<String, OpenroadmTpType> availableSrgPp = new TreeMap<>();
private Map<String, OpenroadmTpType> availableSrgCp = new TreeMap<>();
private String version;
private BigDecimal slotWidthGranularity;
- public PceOpticalNode(Node node, OpenroadmNodeType nodeType, String version, BigDecimal slotWidthGranularity) {
- if (node != null
+ public PceOpticalNode(String deviceNodeId, String serviceType, PortMapping portMapping, Node node,
+ OpenroadmNodeType nodeType, String version, BigDecimal slotWidthGranularity) {
+ if (deviceNodeId != null
+ && serviceType != null
+ && portMapping != null
+ && node != null
&& node.getNodeId() != null
&& nodeType != null
&& version != null
&& slotWidthGranularity != null) {
+ this.deviceNodeId = deviceNodeId;
+ this.serviceType = serviceType;
+ this.portMapping = portMapping;
this.node = node;
this.nodeId = node.getNodeId();
this.nodeType = nodeType;
availableByteArray);
}
+ private boolean isTpWithGoodCapabilities(
+ org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.node
+ .TerminationPoint tp) {
+ Mapping mapping = this.portMapping.getMapping(deviceNodeId, tp.getTpId().getValue());
+ if (mapping == null || mapping.getSupportedInterfaceCapability() == null) {
+ return true;
+ }
+ switch (this.serviceType) {
+ case "400GE":
+ if (mapping.getSupportedInterfaceCapability().contains(IfOTUCnODUCn.class)) {
+ return true;
+ } else {
+ return false;
+ }
+ case "100GE":
+ if (mapping.getSupportedInterfaceCapability().contains(
+ org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev181019.IfOCH.class)
+ || mapping.getSupportedInterfaceCapability().contains(IfOCH.class)) {
+ return true;
+ } else {
+ return false;
+ }
+ default:
+ return true;
+ }
+ }
+
public void initFrequenciesBitSet() {
if (!isValid()) {
return;
for (org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network
.node.TerminationPoint tp : allTps) {
TerminationPoint1 cntp1 = tp.augmentation(TerminationPoint1.class);
- org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev200529.TerminationPoint1 nttp1 = tp
- .augmentation(org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev200529
- .TerminationPoint1.class);
if (cntp1.getTpType() != OpenroadmTpType.XPONDERNETWORK) {
LOG.warn("initXndrTps: {} is not an Xponder network port", cntp1.getTpType().getName());
continue;
}
+ if (!isTpWithGoodCapabilities(tp)) {
+ LOG.warn("initXndrTps: {} network port has not correct if-capabilities", tp.getTpId().getValue());
+ continue;
+ }
if (!State.InService.equals(cntp1.getOperationalState())) {
LOG.warn("initXndrTps: XPONDER tp = {} is OOS/degraded", tp.getTpId().getValue());
this.valid = false;
continue;
}
+ org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev200529.TerminationPoint1 nttp1 = tp
+ .augmentation(org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev200529
+ .TerminationPoint1.class);
if (nttp1 != null && nttp1.getXpdrNetworkAttributes().getWavelength() != null) {
this.usedXpndrNWTps.add(tp.getTpId().getValue());
LOG.info("initXndrTps: XPONDER tp = {} is used", tp.getTpId().getValue());
import java.util.concurrent.Executors;
import java.util.stream.Collectors;
import org.opendaylight.mdsal.binding.api.NotificationPublishService;
+import org.opendaylight.transportpce.common.mapping.PortMapping;
import org.opendaylight.transportpce.common.network.NetworkTransactionService;
import org.opendaylight.transportpce.pce.PceComplianceCheck;
import org.opendaylight.transportpce.pce.PceComplianceCheckResult;
private final ListeningExecutorService executor;
private ServicePathRpcResult notification = null;
private final GnpyConsumer gnpyConsumer;
+ private PortMapping portMapping;
public PathComputationServiceImpl(NetworkTransactionService networkTransactionService,
NotificationPublishService notificationPublishService,
- GnpyConsumer gnpyConsumer) {
+ GnpyConsumer gnpyConsumer, PortMapping portMapping) {
this.notificationPublishService = notificationPublishService;
this.networkTransactionService = networkTransactionService;
this.executor = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(5));
this.gnpyConsumer = gnpyConsumer;
+ this.portMapping = portMapping;
}
public void init() {
String message = "";
String responseCode = "";
PceSendingPceRPCs sendingPCE = new PceSendingPceRPCs(input, networkTransactionService,
- gnpyConsumer);
+ gnpyConsumer, portMapping);
sendingPCE.pathComputation();
message = sendingPCE.getMessage();
responseCode = sendingPCE.getResponseCode();
</cm:property-placeholder>
<reference id="networkTransactionImpl" interface="org.opendaylight.transportpce.common.network.NetworkTransactionService" />
-
<reference id="bindingDOMCodecServices" interface="org.opendaylight.mdsal.binding.dom.codec.spi.BindingDOMCodecServices" />
-
-
- <reference id="dataBroker"
- interface="org.opendaylight.mdsal.binding.api.DataBroker"/>
-
- <reference id="rpcService"
- interface="org.opendaylight.mdsal.binding.api.RpcProviderService"/>
-
- <reference id="notificationPublishService"
- interface="org.opendaylight.mdsal.binding.api.NotificationPublishService"/>
+ <reference id="dataBroker" interface="org.opendaylight.mdsal.binding.api.DataBroker"/>
+ <reference id="rpcService" interface="org.opendaylight.mdsal.binding.api.RpcProviderService"/>
+ <reference id="notificationPublishService" interface="org.opendaylight.mdsal.binding.api.NotificationPublishService"/>
+ <reference id="portMapping" interface="org.opendaylight.transportpce.common.mapping.PortMapping"/>
<bean id="pceServiceImpl"
class="org.opendaylight.transportpce.pce.service.PathComputationServiceImpl"
<argument ref="networkTransactionImpl"/>
<argument ref="notificationPublishService" />
<argument ref="gnpyConsumer" />
+ <argument ref="portMapping" />
</bean>
<bean id="gnpyConsumer"
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
import org.opendaylight.transportpce.common.StringConstants;
import org.opendaylight.transportpce.common.fixedflex.GridConstant;
+import org.opendaylight.transportpce.common.mapping.PortMapping;
import org.opendaylight.transportpce.common.network.NetworkTransactionImpl;
import org.opendaylight.transportpce.common.network.RequestProcessor;
import org.opendaylight.transportpce.pce.constraints.PceConstraints;
private PceLink pceLink = null;
private Link link = null;
private Node node = null;
+ private String deviceNodeId = "device node";
+ private String serviceType = "100GE";
+ @Mock
+ private PortMapping portMapping;
@Before
public void setUp() {
+ MockitoAnnotations.initMocks(this);
// Build Link
link = NodeUtils.createRoadmToRoadm("OpenROADM-3-2-DEG1",
"OpenROADM-3-1-DEG1",
NodeBuilder node1Builder = NodeUtils.getNodeBuilder(NodeUtils.geSupportingNodes());
node = node1Builder.setNodeId(new NodeId("test")).build();
- PceOpticalNode pceOpticalNode = new PceOpticalNode(node,
+ PceOpticalNode pceOpticalNode = new PceOpticalNode(deviceNodeId, serviceType, portMapping, node,
OpenroadmNodeType.SRG, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50);
- PceOpticalNode pceOpticalNode2 = new PceOpticalNode(node,
+ PceOpticalNode pceOpticalNode2 = new PceOpticalNode(deviceNodeId, serviceType, portMapping, node,
OpenroadmNodeType.SRG, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50);
pceLink = new PceLink(link, pceOpticalNode, pceOpticalNode2);
Map<LinkId, PceLink> map = Map.of(new LinkId("OpenROADM-3-1-DEG1-to-OpenROADM-3-2-DEG1"), pceLink);
pcePathDescription = new PcePathDescription(List.of(pceLink),
map, pceResult);
-
}
// TODO fix opposite link
import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.dom.codec.spi.BindingDOMCodecServices;
+import org.opendaylight.transportpce.common.mapping.PortMapping;
import org.opendaylight.transportpce.common.network.NetworkTransactionImpl;
import org.opendaylight.transportpce.common.network.RequestProcessor;
import org.opendaylight.transportpce.pce.gnpy.JerseyServer;
private JerseyServer jerseyServer = new JerseyServer();
private DataBroker dataBroker;
private GnpyConsumer gnpyConsumer;
+ @Mock
+ private PortMapping portMapping;
@Before
gnpyConsumer = new GnpyConsumerImpl("http://localhost:9998",
"mylogin", "mypassword", getDataStoreContextUtil().getBindingDOMCodecServices());
pceSendingPceRPCs = new PceSendingPceRPCs(PceTestData.getPCE_test1_request_54(),
- networkTransaction, gnpyConsumer);
+ networkTransaction, gnpyConsumer, portMapping);
}
@Test
jerseyServer.setUp();
pceSendingPceRPCs =
new PceSendingPceRPCs(PceTestData.getGnpyPCERequest("XPONDER-1", "XPONDER-2"),
- networkTransaction, gnpyConsumer);
+ networkTransaction, gnpyConsumer, portMapping);
pceSendingPceRPCs.pathComputation();
Assert.assertTrue(gnpyConsumer.isAvailable());
@Test
public void getIncludePceNodesTest() {
Assert.assertTrue(pceConstraints.getIncludePceNodes().size() == 0);
- pceConstraints.setIncludePceNode(new PceOpticalNode(null, null, null, null));
+ pceConstraints.setIncludePceNode(new PceOpticalNode(null, null, null, null, null, null, null));
Assert.assertTrue(pceConstraints.getIncludePceNodes().size() == 1);
}
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
import org.opendaylight.transportpce.common.StringConstants;
import org.opendaylight.transportpce.common.fixedflex.GridConstant;
+import org.opendaylight.transportpce.common.mapping.PortMapping;
import org.opendaylight.transportpce.pce.networkanalyzer.PceLink;
import org.opendaylight.transportpce.pce.networkanalyzer.PceOpticalNode;
import org.opendaylight.transportpce.pce.utils.NodeUtils;
private Node node = null;
private PceLink pceLink = null;
private PceGraphEdge pceGraphEdge = null;
+ private String deviceNodeId = "device node";
+ private String serviceType = "100GE";
+ @Mock
+ private PortMapping portMapping;
@Before
public void setUp() {
+ MockitoAnnotations.initMocks(this);
// Build Link
link = NodeUtils.createRoadmToRoadm("OpenROADM-3-2-DEG1",
"OpenROADM-3-1-DEG1",
// Link link=genereateLinkBuilder();
node = NodeUtils.getNodeBuilder(NodeUtils.geSupportingNodes()).build();
- PceOpticalNode pceOpticalNode = new PceOpticalNode(node,
+ PceOpticalNode pceOpticalNode = new PceOpticalNode(deviceNodeId, serviceType, portMapping, node,
OpenroadmNodeType.SRG, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50);
- PceOpticalNode pceOpticalNode2 = new PceOpticalNode(node,
+ PceOpticalNode pceOpticalNode2 = new PceOpticalNode(deviceNodeId, serviceType, portMapping, node,
OpenroadmNodeType.SRG, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50);
pceLink = new PceLink(link, pceOpticalNode, pceOpticalNode2);
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
import org.opendaylight.transportpce.common.StringConstants;
import org.opendaylight.transportpce.common.fixedflex.GridConstant;
+import org.opendaylight.transportpce.common.mapping.PortMapping;
import org.opendaylight.transportpce.pce.constraints.PceConstraints;
import org.opendaylight.transportpce.pce.networkanalyzer.PceLink;
import org.opendaylight.transportpce.pce.networkanalyzer.PceNode;
private PceOpticalNode pceOpticalNode = null;
private PceOpticalNode pceOpticalNode2 = null;
private Map<NodeId, PceNode> allPceNodes = null;
+ private String deviceNodeId = "device node";
+ private String serviceType = "100GE";
+ @Mock
+ private PortMapping portMapping;
@Before
public void setUp() {
+ MockitoAnnotations.initMocks(this);
// Build Link
link = NodeUtils.createRoadmToRoadm("OpenROADM-3-2-DEG1",
"OpenROADM-3-1-DEG1",
node = NodeUtils.getNodeBuilder(NodeUtils.geSupportingNodes())
.setNodeId(nodeId).withKey(new NodeKey(nodeId))
.build();
- pceOpticalNode = new PceOpticalNode(node,
+ pceOpticalNode = new PceOpticalNode(deviceNodeId, serviceType, portMapping, node,
OpenroadmNodeType.DEGREE, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50);
NodeId nodeId2 = new NodeId("OpenROADM-3-1-DEG1");
Node node2 = NodeUtils.getNodeBuilder(NodeUtils.geSupportingNodes())
.setNodeId(nodeId2).withKey(new NodeKey(nodeId2)).build();
- pceOpticalNode2 = new PceOpticalNode(node2,
+ pceOpticalNode2 = new PceOpticalNode(deviceNodeId, serviceType, portMapping, node2,
OpenroadmNodeType.DEGREE, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50);
pceLink = new PceLink(link, pceOpticalNode, pceOpticalNode2);
pceLink.setClient("XPONDER-CLIENT");
requestProcessor = Mockito.mock(RequestProcessor.class);
networkTransaction = new NetworkTransactionImpl(requestProcessor);
pathComputationService = new PathComputationServiceImpl(networkTransaction, notificationPublishService,
- null);
+ null, null);
pceProvider = new PceProvider(rpcService, pathComputationService);
}
import java.util.concurrent.ExecutionException;
import org.junit.Before;
import org.junit.Test;
+import org.mockito.Mock;
import org.opendaylight.mdsal.binding.api.NotificationPublishService;
+import org.opendaylight.transportpce.common.mapping.PortMapping;
import org.opendaylight.transportpce.common.network.NetworkTransactionImpl;
import org.opendaylight.transportpce.common.network.RequestProcessor;
import org.opendaylight.transportpce.pce.service.PathComputationService;
private NotificationPublishService notificationPublishService;
private NetworkTransactionImpl networkTransaction;
private PceServiceRPCImpl pceServiceRPC;
+ @Mock
+ private PortMapping portMapping;
@Before
public void setUp() throws ExecutionException, InterruptedException {
notificationPublishService = new NotificationPublishServiceMock();
networkTransaction = new NetworkTransactionImpl(new RequestProcessor(this.getDataBroker()));
pathComputationService = new PathComputationServiceImpl(networkTransaction, notificationPublishService,
- null);
+ null, portMapping);
pceServiceRPC = new PceServiceRPCImpl(pathComputationService);
}
new NetworkTransactionImpl(new RequestProcessor(this.getDataBroker())),
pceConstraintsCalc.getPceHardConstraints(),
pceConstraintsCalc.getPceSoftConstraints(),
- pceResult);
+ pceResult,
+ null);
}
@Test
new NetworkTransactionImpl(new RequestProcessor(this.getDataBroker())),
pceConstraintsCalc.getPceHardConstraints(),
pceConstraintsCalc.getPceSoftConstraints(),
- pceResult);
+ pceResult, null);
pceCalculation.retrievePceNetwork();
Assert.assertEquals(StringConstants.SERVICE_TYPE_100GE, pceCalculation.getServiceType());
Assert.assertNotNull(pceCalculation.getReturnStructure());
new NetworkTransactionImpl(new RequestProcessor(this.getDataBroker())),
pceConstraintsCalc.getPceHardConstraints(),
pceConstraintsCalc.getPceSoftConstraints(),
- pceResult);
+ pceResult, null);
pceCalculation.retrievePceNetwork();
// Assert.assertEquals(StringConstants.SERVICE_TYPE_100GE, pceCalculation.getServiceType());
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
import org.opendaylight.transportpce.common.NetworkUtils;
import org.opendaylight.transportpce.common.StringConstants;
import org.opendaylight.transportpce.common.fixedflex.GridConstant;
+import org.opendaylight.transportpce.common.mapping.PortMapping;
import org.opendaylight.transportpce.test.AbstractTest;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.link.types.rev191129.RatioDB;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Link1Builder;
private static final String LINK_ID_FORMAT = "%1$s-%2$sto%3$s-%4$s";
private PceLink pceLink = null;
+ private String deviceNodeId = "device node";
+ private String serviceType = "100GE";
+ @Mock
+ private PortMapping portMapping;
@Before
public void setup() {
-
+ MockitoAnnotations.initMocks(this);
}
@Test
"srcTp", "destTp").build();
NodeBuilder node1Builder = getNodeBuilder(geSupportingNodes());
Node node = node1Builder.setNodeId(new NodeId("test")).build();
- PceOpticalNode pceOpticalNode = new PceOpticalNode(node,
+ PceOpticalNode pceOpticalNode = new PceOpticalNode(deviceNodeId, serviceType, portMapping, node,
OpenroadmNodeType.SRG, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50);
pceLink = new PceLink(link, pceOpticalNode, pceOpticalNode);
}
NodeBuilder node1Builder = getNodeBuilder(geSupportingNodes());
Node node = node1Builder.setNodeId(new NodeId("test")).build();
- PceOpticalNode pceOpticalNode = new PceOpticalNode(node,
+ PceOpticalNode pceOpticalNode = new PceOpticalNode(deviceNodeId, serviceType, portMapping, node,
OpenroadmNodeType.SRG, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50);
pceLink = new PceLink(link, pceOpticalNode, pceOpticalNode);
}
NodeBuilder node1Builder = getNodeBuilder(geSupportingNodes());
Node node = node1Builder.setNodeId(new NodeId("test")).build();
- PceOpticalNode pceOpticalNode = new PceOpticalNode(node,
+ PceOpticalNode pceOpticalNode = new PceOpticalNode(deviceNodeId, serviceType, portMapping, node,
OpenroadmNodeType.SRG, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50);
pceLink = new PceLink(link, pceOpticalNode, pceOpticalNode);
NodeBuilder node1Builder = getNodeBuilder(geSupportingNodes());
Node node = node1Builder.setNodeId(new NodeId("test")).build();
- PceOpticalNode pceOpticalNode = new PceOpticalNode(node,
+ PceOpticalNode pceOpticalNode = new PceOpticalNode(deviceNodeId, serviceType, portMapping, node,
OpenroadmNodeType.SRG, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50);
pceLink = new PceLink(link, pceOpticalNode, pceOpticalNode);
}
NodeBuilder node1Builder = getNodeBuilder(geSupportingNodes());
Node node = node1Builder.setNodeId(new NodeId("test")).build();
- PceOpticalNode pceOpticalNode = new PceOpticalNode(node,
+ PceOpticalNode pceOpticalNode = new PceOpticalNode(deviceNodeId, serviceType, portMapping, node,
OpenroadmNodeType.SRG, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50);
pceLink = new PceLink(link, pceOpticalNode, pceOpticalNode);
Assert.assertNotNull(MapUtils.getOmsAttributesSpan(link));
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
import org.opendaylight.transportpce.common.NetworkUtils;
import org.opendaylight.transportpce.common.StringConstants;
import org.opendaylight.transportpce.common.fixedflex.GridConstant;
import org.opendaylight.transportpce.common.fixedflex.GridUtils;
+import org.opendaylight.transportpce.common.mapping.PortMapping;
import org.opendaylight.transportpce.test.AbstractTest;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Node1;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.TerminationPoint1Builder;
private Node node;
private BitSet usedBitSet = new BitSet(8);
private BitSet availableBitSet = new BitSet(8);
+ private String deviceNodeId = "device node";
+ private String serviceType = "100GE";
+ @Mock
+ private PortMapping portMapping;
@Before
public void setUp() {
NodeBuilder node1Builder = getNodeBuilder(geSupportingNodes(), OpenroadmTpType.SRGTXRXPP);
node = node1Builder.setNodeId(new NodeId("test")).build();
availableBitSet.set(0,8);
+ MockitoAnnotations.initMocks(this);
}
@Test
public void isValidTest() {
OpenroadmNodeType nodeType = OpenroadmNodeType.ROADM;
- pceOpticalNode = new PceOpticalNode(node, nodeType, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1,
- GridConstant.SLOT_WIDTH_50);
+ pceOpticalNode = new PceOpticalNode(deviceNodeId, serviceType, portMapping, node, nodeType,
+ StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50);
Assert.assertTrue(pceOpticalNode.isValid());
}
@Test
public void testInitSrgTps() {
- pceOpticalNode = new PceOpticalNode(node,
+ pceOpticalNode = new PceOpticalNode(deviceNodeId, serviceType, portMapping, node,
OpenroadmNodeType.ROADM, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50);
pceOpticalNode.initSrgTps();
pceOpticalNode.initXndrTps(ServiceFormat.OMS);
public void testInitXndrTpSrgTypes() {
NodeBuilder node1Builder = getNodeBuilder(geSupportingNodes(), OpenroadmTpType.XPONDERNETWORK);
Node specificNode = node1Builder.build();
- pceOpticalNode = new PceOpticalNode(specificNode,
+ pceOpticalNode = new PceOpticalNode(deviceNodeId, serviceType, portMapping, specificNode,
OpenroadmNodeType.SRG, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50);
pceOpticalNode.initFrequenciesBitSet();
Assert.assertTrue(pceOpticalNode.isValid());
@Test
public void testInitXndrTpDegTypes() {
- pceOpticalNode = new PceOpticalNode(node,
+ pceOpticalNode = new PceOpticalNode(deviceNodeId, serviceType, portMapping, node,
OpenroadmNodeType.DEGREE, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50);
pceOpticalNode.initFrequenciesBitSet();
Assert.assertTrue(pceOpticalNode.isValid());
@Test
public void testInitXndrTpXpondrTypes() {
- pceOpticalNode = new PceOpticalNode(node,
+ pceOpticalNode = new PceOpticalNode(deviceNodeId, serviceType, portMapping, node,
OpenroadmNodeType.XPONDER, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50);
pceOpticalNode.initFrequenciesBitSet();
Assert.assertTrue(pceOpticalNode.isValid());
@Test
public void testinitFrequenciesBitSet() {
- pceOpticalNode = new PceOpticalNode(node,
+ pceOpticalNode = new PceOpticalNode(null, null, null, node,
OpenroadmNodeType.ROADM, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50);
pceOpticalNode.initXndrTps(ServiceFormat.OMS);
pceOpticalNode.initFrequenciesBitSet();
@Test
public void testGetRdmSrgClient() {
- pceOpticalNode = new PceOpticalNode(node,
+ pceOpticalNode = new PceOpticalNode(null, null, null, node,
OpenroadmNodeType.ROADM, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50);
pceOpticalNode.initSrgTps();
Assert.assertNull(pceOpticalNode.getRdmSrgClient("7"));
public void testGetRdmSrgClientEmpty() {
NodeBuilder node1Builder = getNodeBuilderEmpty(geSupportingNodes(), OpenroadmTpType.SRGTXRXPP);
Node specificNode = node1Builder.setNodeId(new NodeId("test")).build();
- pceOpticalNode = new PceOpticalNode(specificNode,
+ pceOpticalNode = new PceOpticalNode(null, null, null, specificNode,
OpenroadmNodeType.ROADM, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50);
pceOpticalNode.initSrgTps();
pceOpticalNode.initFrequenciesBitSet();
@Test
public void testGetRdmSrgClientDeg() {
- pceOpticalNode = new PceOpticalNode(node,
+ pceOpticalNode = new PceOpticalNode(null, null, null, node,
OpenroadmNodeType.DEGREE, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50);
pceOpticalNode.initSrgTps();
Assert.assertNull(pceOpticalNode.getRdmSrgClient("7"));
public void testGetRdmSrgClientsrgtxcp() {
NodeBuilder node1Builder = getNodeBuilder(geSupportingNodes(), OpenroadmTpType.SRGTXCP);
Node specificNode = node1Builder.build();
- pceOpticalNode = new PceOpticalNode(specificNode,
+ pceOpticalNode = new PceOpticalNode(null, null, null, specificNode,
OpenroadmNodeType.ROADM, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50);
pceOpticalNode.initSrgTps();
Assert.assertFalse(pceOpticalNode.isValid());
public void testGetRdmSrgClientDegreerxtpp() {
NodeBuilder node1Builder = getNodeBuilder(geSupportingNodes(), OpenroadmTpType.DEGREERXTTP);
node = node1Builder.build();
- pceOpticalNode = new PceOpticalNode(node,
+ pceOpticalNode = new PceOpticalNode(null, null, null, node,
OpenroadmNodeType.ROADM, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50);
pceOpticalNode.initSrgTps();
Assert.assertNull(pceOpticalNode.getRdmSrgClient("2"));
gnpyResult = Mockito.mock(GnpyResult.class);
pathComputationServiceImpl = new PathComputationServiceImpl(
networkTransactionService,
- this.getNotificationPublishService(), null);
+ this.getNotificationPublishService(), null, null);
pathComputationServiceImpl.init();
}