<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>8.0.7</version>
+ <version>8.0.11</version>
<relativePath/>
</parent>
module transportpce-olm {
- yang-version 1;
+ yang-version 1.1;
namespace "http://org/opendaylight/transportpce/olm";
prefix org-opendaylight-transportpce-olm;
description
"This RPC can be used by PM monitoring to calculate spanloss
periodically";
- input;
+ // input;
output {
leaf result {
type string;
<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>8.0.7</version>
+ <version>8.0.11</version>
<relativePath />
</parent>
<dependency>
<groupId>org.opendaylight.netconf</groupId>
<artifactId>netconf-artifacts</artifactId>
- <version>2.0.11</version>
+ <version>2.0.14</version>
<scope>import</scope>
<type>pom</type>
</dependency>
public static final String SERVICE_TYPE_ODUC4 = "ODUC4";
+ public static final String SERVICE_DIRECTION_AZ = "aToz";
+ public static final String SERVICE_DIRECTION_ZA = "zToa";
+
private StringConstants() {
// hiding the default constructor
}
public class JsonStringConverter<T extends DataObject> {
private static final Logger LOG = LoggerFactory.getLogger(JsonStringConverter.class);
- private static final JsonParser PARSER = new JsonParser();
- private BindingDOMCodecServices bindingDOMCodecServices;
+ private BindingDOMCodecServices bindingDOMCodecServices;
public JsonStringConverter(BindingDOMCodecServices bindingDOMCodecServices) {
this.bindingDOMCodecServices = bindingDOMCodecServices;
nodeWriter.write(bindingDOMCodecServices.toNormalizedNode(id, dataObject).getValue());
nodeWriter.flush();
}
- JsonObject asJsonObject = PARSER.parse(writer.toString()).getAsJsonObject();
+ JsonObject asJsonObject = JsonParser.parseString(writer.toString()).getAsJsonObject();
return new Gson().toJson(asJsonObject);
} catch (IOException e) {
LOG.error("Cannot convert object {} to string ", dataObject);
private static Table<Uint32, ModulationFormat, String> initFrequencyWidthTable() {
Table<Uint32, ModulationFormat, String> frequencyWidthTable = HashBasedTable.create();
frequencyWidthTable.put(ServiceRateConstant.RATE_100, ModulationFormat.DpQpsk, String.valueOf(WIDTH_40));
- frequencyWidthTable.put(ServiceRateConstant.RATE_200, ModulationFormat.DpQpsk, String.valueOf(WIDTH_80));
- frequencyWidthTable.put(ServiceRateConstant.RATE_300, ModulationFormat.DpQam8, String.valueOf(WIDTH_80));
+ frequencyWidthTable.put(ServiceRateConstant.RATE_200, ModulationFormat.DpQpsk, String.valueOf(WIDTH_75));
+ frequencyWidthTable.put(ServiceRateConstant.RATE_300, ModulationFormat.DpQam8, String.valueOf(WIDTH_75));
frequencyWidthTable.put(ServiceRateConstant.RATE_400, ModulationFormat.DpQam16, String.valueOf(WIDTH_75));
return frequencyWidthTable;
}
import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev161014.Protocols1;
import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev161014.lldp.container.Lldp;
import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev161014.lldp.container.lldp.PortConfig;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev170929.SupportedIfCapability;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.Uint16;
import org.opendaylight.yangtools.yang.common.Uint32;
for (Entry<Integer, List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.srg.CircuitPacks>>
srgCpEntry : getSrgCps(nodeId, deviceInfo).entrySet()) {
List<String> keys = new ArrayList<>();
+ int portIndex = 1;
for (org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.srg.CircuitPacks
cp : srgCpEntry.getValue()) {
String circuitPackName = cp.getCircuitPackName();
List<Ports> portList = getPortList(circuitPackName, nodeId);
Collections.sort(portList, new SortPort121ByName());
- int portIndex = 1;
for (Ports port : portList) {
if (!checkPortQual(port, circuitPackName, nodeId)) {
continue;
private Mapping createNewXpdrMapping(String nodeId, Ports port, String circuitPackName,
String logicalConnectionPoint, String partnerLcp) {
+ List<Class<? extends org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev200327
+ .SupportedIfCapability>> supportedIntf = new ArrayList<>();
+ for (String sup: getSupIfCapList(port)) {
+ if (MappingUtilsImpl.convertSupIfCapa(sup) != null) {
+ supportedIntf.add(MappingUtilsImpl.convertSupIfCapa(sup));
+ }
+ }
MappingBuilder mpBldr = new MappingBuilder()
.withKey(new MappingKey(logicalConnectionPoint))
.setLogicalConnectionPoint(logicalConnectionPoint)
.setSupportingPort(port.getPortName())
.setPortDirection(port.getPortDirection().getName())
.setXponderType(XpdrNodeTypes.Tpdr)
- .setLcpHashVal(PortMappingUtils.fnv1size64(nodeId + "-" + logicalConnectionPoint));
+ .setLcpHashVal(PortMappingUtils.fnv1size64(nodeId + "-" + logicalConnectionPoint))
+ .setSupportedInterfaceCapability(supportedIntf);
if (port.getPortQual() != null) {
mpBldr.setPortQual(port.getPortQual().getName());
}
return mpBldr.build();
}
+ private List<String> getSupIfCapList(Ports port) {
+ List<Class<? extends SupportedIfCapability>> supIfCapClassList = port.getSupportedInterfaceCapability();
+ return
+ supIfCapClassList == null
+ ? Collections.emptyList()
+ : supIfCapClassList
+ .stream().map(e -> e.getSimpleName())
+ .collect(Collectors.toList());
+ }
+
private Ports getPort2(Ports port, String nodeId, String circuitPackName, StringBuilder circuitPackName2,
//circuitPackName2 will be updated by reference contrary to circuitPackName
List<CircuitPacks> circuitPackList, Map<String, String> lcpMap) {
import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev181019.Protocols1;
import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev181019.lldp.container.Lldp;
import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev181019.lldp.container.lldp.PortConfig;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.port.capability.rev181019.Ports1;
import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev181019.SupportedIfCapability;
import org.opendaylight.yang.gen.v1.http.org.openroadm.switching.pool.types.rev191129.SwitchingPoolTypes;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
for (Entry<Integer, List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.srg.CircuitPacks>>
srgCpEntry : getSrgCps(nodeId, deviceInfo).entrySet()) {
List<String> keys = new ArrayList<>();
+ int portIndex = 1;
for (org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.srg.CircuitPacks
cp : srgCpEntry.getValue()) {
String circuitPackName = cp.getCircuitPackName();
List<Ports> portList = getPortList(circuitPackName, nodeId);
Collections.sort(portList, new SortPort221ByName());
- int portIndex = 1;
for (Ports port : portList) {
if (!checkPortQual(port, circuitPackName, nodeId)) {
continue;
private Mapping createNewXpdrMapping(String nodeId, Ports port, String circuitPackName,
String logicalConnectionPoint, String partnerLcp, XpdrNodeTypes xpdrNodeType) {
+ List<Class<? extends org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev200327
+ .SupportedIfCapability>> supportedIntf = new ArrayList<>();
+ for (String sup: getSupIfCapList(port)) {
+ if (MappingUtilsImpl.convertSupIfCapa(sup) != null) {
+ supportedIntf.add(MappingUtilsImpl.convertSupIfCapa(sup));
+ }
+ }
MappingBuilder mpBldr = new MappingBuilder()
.withKey(new MappingKey(logicalConnectionPoint))
.setLogicalConnectionPoint(logicalConnectionPoint)
.setSupportingCircuitPackName(circuitPackName)
.setSupportingPort(port.getPortName())
.setPortDirection(port.getPortDirection().getName())
- .setLcpHashVal(PortMappingUtils.fnv1size64(nodeId + "-" + logicalConnectionPoint));
+ .setLcpHashVal(PortMappingUtils.fnv1size64(nodeId + "-" + logicalConnectionPoint))
+ .setSupportedInterfaceCapability(supportedIntf);
if (port.getPortQual() != null) {
mpBldr.setPortQual(port.getPortQual().getName());
}
if (partnerLcp != null) {
mpBldr.setPartnerLcp(partnerLcp);
}
- if (port.getSupportedInterfaceCapability() != null) {
- List<Class<? extends org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev200327
- .SupportedIfCapability>> supportedIntf = new ArrayList<>();
- for (Class<? extends SupportedIfCapability> sup: port.getSupportedInterfaceCapability()) {
- if (MappingUtilsImpl.convertSupIfCapa(sup.getSimpleName()) != null) {
- supportedIntf.add(MappingUtilsImpl.convertSupIfCapa(sup.getSimpleName()));
- }
- }
- mpBldr.setSupportedInterfaceCapability(supportedIntf);
- }
if (port.getAdministrativeState() != null) {
mpBldr.setPortAdminState(port.getAdministrativeState().name());
}
return mpBldr.build();
}
+ private List<String> getSupIfCapList(Ports port) {
+ List<Class<? extends SupportedIfCapability>> supIfCapClassList = port.getSupportedInterfaceCapability();
+ if (supIfCapClassList != null) {
+ return supIfCapClassList
+ .stream().map(e -> e.getSimpleName())
+ .collect(Collectors.toList());
+ }
+ Ports1 ports1 = port.augmentation(Ports1.class);
+ if (ports1 != null && ports1.getPortCapabilities() != null) {
+ return ports1.getPortCapabilities().getSupportedInterfaceCapability()
+ .values().stream().map(e -> e.getIfCapType().getSimpleName())
+ .collect(Collectors.toList());
+ }
+ return Collections.emptyList();
+ }
+
private Ports getPort2(Ports port, String nodeId, String circuitPackName, StringBuilder circuitPackName2,
//circuitPackName2 will be updated by reference contrary to circuitPackName
List<CircuitPacks> circuitPackList, Map<String, String> lcpMap) {
for (Entry<Integer, List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.srg.CircuitPacks>>
srgCpEntry : getSrgCps(nodeId, deviceInfo).entrySet()) {
List<String> keys = new ArrayList<>();
+ int portIndex = 1;
for (org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.srg.CircuitPacks
cp : srgCpEntry.getValue()) {
String circuitPackName = cp.getCircuitPackName();
List<Ports> portList = getPortList(circuitPackName, nodeId);
Collections.sort(portList, new SortPort710ByName());
- int portIndex = 1;
for (Ports port : portList) {
if (!checkPortQual(port, circuitPackName, nodeId)) {
continue;
private MappingBuilder updateMappingInterfaces(String nodeId, MappingBuilder mpBldr, Ports port) {
mpBldr.setSupportingOtu4(null)
- .setSupportingOdu4(null);
+ .setSupportingOdu4(null)
+ .setSupportingOducn(null)
+ .setSupportingOtucn(null);
for (Interfaces interfaces : port.getInterfaces()) {
Optional<Interface> openRoadmInterface = getInterfaceFromDevice(nodeId,
interfaces.getInterfaceName());
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.port.Interfaces;
import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev161014.AdminStates;
import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev161014.States;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev161014.OtnOdu;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev161014.OtnOtu;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.maintenance.loopback.rev161014.maint.loopback.MaintLoopbackBuilder;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.maintenance.testsignal.rev161014.maint.testsignal.MaintTestsignalBuilder;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev161014.Interface1;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev161014.Interface1Builder;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev161014.odu.container.OduBuilder;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev161014.otu.container.OtuBuilder;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
import org.slf4j.Logger;
};
try {
txSubmitFuture.get();
- LOG.info("Successfully posted interface {} on node {}", ifBuilder.getName(), nodeId);
- boolean devicePortIsUptodated = false;
- while (!devicePortIsUptodated) {
- devicePortIsUptodated = checkIfDevicePortIsUpdatedWithInterface(nodeId, ifBuilder);
+ LOG.info("Successfully posted/deleted interface {} on node {}", ifBuilder.getName(), nodeId);
+ // this check is not needed during the delete operation
+ // during the delete operation, ifBuilder does not contain supporting-cp and supporting-port
+ if (ifBuilder.getSupportingCircuitPackName() != null && ifBuilder.getSupportingPort() != null) {
+ boolean devicePortIsUptodated = false;
+ while (!devicePortIsUptodated) {
+ devicePortIsUptodated = checkIfDevicePortIsUpdatedWithInterface(nodeId, ifBuilder);
+ }
+ LOG.info("{} - {} - interface {} updated on port {}", nodeId, ifBuilder.getSupportingCircuitPackName(),
+ ifBuilder.getName(), ifBuilder.getSupportingPort());
}
- LOG.info("{} - {} - interface {} updated on port {}", nodeId, ifBuilder.getSupportingCircuitPackName(),
- ifBuilder.getName(), ifBuilder.getSupportingPort());
timer.interrupt();
} catch (InterruptedException | ExecutionException e) {
throw new OpenRoadmInterfaceException(String.format("Failed to post interface %s on node %s!", ifBuilder
if (intf2DeleteOpt.isPresent()) {
Interface intf2Delete = intf2DeleteOpt.get();
// State admin state to out of service
- InterfaceBuilder ifBuilder = new InterfaceBuilder(intf2Delete);
- if (ifBuilder.getType() == OtnOdu.class) {
- Interface1Builder oduBuilder = new Interface1Builder(intf2Delete.augmentation(Interface1.class));
- OduBuilder odu = new OduBuilder(oduBuilder.getOdu());
- if (odu.getMaintTestsignal() != null) {
- MaintTestsignalBuilder maintSignalBuilder = new MaintTestsignalBuilder();
- maintSignalBuilder.setEnabled(false);
- odu.setMaintTestsignal(maintSignalBuilder.build());
- }
- oduBuilder.setOdu(odu.build());
- ifBuilder.addAugmentation(oduBuilder.build());
- } else if (ifBuilder.getType() == OtnOtu.class) {
- org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev161014.Interface1Builder
- otuBuilder =
- new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev161014.Interface1Builder(
- intf2Delete.augmentation(
- org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev161014.Interface1
- .class));
- OtuBuilder otu = new OtuBuilder(otuBuilder.getOtu());
- if (otu.getMaintLoopback() != null) {
- MaintLoopbackBuilder maintLoopBackBuilder = new MaintLoopbackBuilder();
- maintLoopBackBuilder.setEnabled(false);
- otu.setMaintLoopback(maintLoopBackBuilder.build());
- }
- otuBuilder.setOtu(otu.build());
- ifBuilder.addAugmentation(otuBuilder.build());
- }
- ifBuilder.setAdministrativeState(AdminStates.OutOfService);
+ InterfaceBuilder ifBuilder = new InterfaceBuilder()
+ .setAdministrativeState(AdminStates.OutOfService)
+ .setName(intf2Delete.getName())
+ .setType(intf2Delete.getType());
// post interface with updated admin state
try {
postInterface(nodeId, ifBuilder);
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.port.Interfaces;
import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev171215.AdminStates;
import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev171215.States;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.OtnOdu;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.OtnOtu;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.maintenance.loopback.rev171215.maint.loopback.MaintLoopbackBuilder;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.maintenance.testsignal.rev171215.maint.testsignal.MaintTestsignalBuilder;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.odu.container.OduBuilder;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.otu.container.OtuBuilder;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
import org.slf4j.Logger;
};
try {
txSubmitFuture.get();
- LOG.info("Successfully posted interface {} on node {}", ifBuilder.getName(), nodeId);
- boolean devicePortIsUptodated = false;
- while (!devicePortIsUptodated) {
- devicePortIsUptodated = checkIfDevicePortIsUpdatedWithInterface(nodeId, ifBuilder);
+ LOG.info("Successfully posted/deleted interface {} on node {}", ifBuilder.getName(), nodeId);
+ // this check is not needed during the delete operation
+ // during the delete operation, ifBuilder does not contain supporting-cp and supporting-port
+ if (ifBuilder.getSupportingCircuitPackName() != null && ifBuilder.getSupportingPort() != null) {
+ boolean devicePortIsUptodated = false;
+ while (!devicePortIsUptodated) {
+ devicePortIsUptodated = checkIfDevicePortIsUpdatedWithInterface(nodeId, ifBuilder);
+ }
+ LOG.info("{} - {} - interface {} updated on port {}", nodeId, ifBuilder.getSupportingCircuitPackName(),
+ ifBuilder.getName(), ifBuilder.getSupportingPort());
}
- LOG.info("{} - {} - interface {} updated on port {}", nodeId, ifBuilder.getSupportingCircuitPackName(),
- ifBuilder.getName(), ifBuilder.getSupportingPort());
timer.interrupt();
} catch (InterruptedException | ExecutionException e) {
throw new OpenRoadmInterfaceException(String.format("Failed to post interface %s on node %s!", ifBuilder
if (intf2DeleteOpt.isPresent()) {
Interface intf2Delete = intf2DeleteOpt.get();
// State admin state to out of service
- InterfaceBuilder ifBuilder = new InterfaceBuilder(intf2Delete);
- if (ifBuilder.getType() == OtnOdu.class) {
- Interface1Builder oduBuilder = new Interface1Builder(intf2Delete.augmentation(Interface1.class));
- OduBuilder odu = new OduBuilder(oduBuilder.getOdu());
- if (odu.getMaintTestsignal() != null) {
- MaintTestsignalBuilder maintSignalBuilder = new MaintTestsignalBuilder();
- maintSignalBuilder.setEnabled(false);
- odu.setMaintTestsignal(maintSignalBuilder.build());
- }
- oduBuilder.setOdu(odu.build());
- ifBuilder.addAugmentation(oduBuilder.build());
- } else if (ifBuilder.getType() == OtnOtu.class) {
- org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.Interface1Builder
- otuBuilder =
- new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.Interface1Builder(
- intf2Delete.augmentation(
- org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.Interface1
- .class));
- OtuBuilder otu = new OtuBuilder(otuBuilder.getOtu());
- if (otu.getMaintLoopback() != null) {
- MaintLoopbackBuilder maintLoopBackBuilder = new MaintLoopbackBuilder();
- maintLoopBackBuilder.setEnabled(false);
- otu.setMaintLoopback(maintLoopBackBuilder.build());
- }
- otuBuilder.setOtu(otu.build());
- ifBuilder.addAugmentation(otuBuilder.build());
- }
- ifBuilder.setAdministrativeState(AdminStates.OutOfService);
+ InterfaceBuilder ifBuilder = new InterfaceBuilder()
+ .setAdministrativeState(AdminStates.OutOfService)
+ .setName(intf2Delete.getName())
+ .setType(intf2Delete.getType());
// post interface with updated admin state
try {
postInterface(nodeId, ifBuilder);
import org.opendaylight.transportpce.common.Timeouts;
import org.opendaylight.transportpce.common.device.DeviceTransaction;
import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
+import org.opendaylight.transportpce.common.mapping.PortMapping;
+import org.opendaylight.transportpce.common.mapping.PortMappingVersion710;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev220114.mapping.Mapping;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.circuit.pack.Ports;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.circuit.pack.PortsKey;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.circuit.packs.CircuitPacks;
private static final Logger LOG = LoggerFactory.getLogger(OpenRoadmInterfacesImpl710.class);
private final DeviceTransactionManager deviceTransactionManager;
+ private final PortMapping portMapping;
+ private final PortMappingVersion710 portMapping710;
- public OpenRoadmInterfacesImpl710(DeviceTransactionManager deviceTransactionManager) {
+ public OpenRoadmInterfacesImpl710(DeviceTransactionManager deviceTransactionManager,
+ PortMapping portMapping, PortMappingVersion710 portMapping710) {
this.deviceTransactionManager = deviceTransactionManager;
+ this.portMapping = portMapping;
+ this.portMapping710 = portMapping710;
}
public void postInterface(String nodeId, InterfaceBuilder ifBuilder) throws OpenRoadmInterfaceException {
};
try {
txSubmitFuture.get();
- LOG.info("Successfully posted interface {} on node {}", ifBuilder.getName(), nodeId);
- boolean devicePortIsUptodated = false;
- while (!devicePortIsUptodated) {
- devicePortIsUptodated = checkIfDevicePortIsUpdatedWithInterface(nodeId, ifBuilder);
+ LOG.info("Successfully posted/deleted interface {} on node {}", ifBuilder.getName(), nodeId);
+ // this check is not needed during the delete operation
+ // during the delete operation, ifBuilder does not contain supporting-cp and supporting-port
+ if (ifBuilder.getSupportingCircuitPackName() != null && ifBuilder.getSupportingPort() != null) {
+ boolean devicePortIsUptodated = false;
+ while (!devicePortIsUptodated) {
+ devicePortIsUptodated = checkIfDevicePortIsUpdatedWithInterface(nodeId, ifBuilder);
+ }
+ LOG.info("{} - {} - interface {} updated on port {}", nodeId, ifBuilder.getSupportingCircuitPackName(),
+ ifBuilder.getName(), ifBuilder.getSupportingPort());
}
- LOG.info("{} - {} - interface {} updated on port {}", nodeId, ifBuilder.getSupportingCircuitPackName(),
- ifBuilder.getName(), ifBuilder.getSupportingPort());
timer.interrupt();
} catch (InterruptedException | ExecutionException e) {
throw new OpenRoadmInterfaceException(String.format("Failed to post interface %s on node %s!", ifBuilder
// Though these could be redundant, but 'when' statements are causing problem,
// when deleting the interfaces trying to be deleted
.setName(intf2Delete.getName())
- .setType(intf2Delete.getType())
- // CP name and the ports are needed, since the post interface is validated
- .setSupportingCircuitPackName(intf2Delete.getSupportingCircuitPackName())
- .setSupportingPort(intf2Delete.getSupportingPort());
+ .setType(intf2Delete.getType());
// post interface with updated admin state
try {
if (intf2Delete.getName().contains(StringConstants.CLIENT_TOKEN) || intf2Delete.getName().contains(
StringConstants.NETWORK_TOKEN)) {
postEquipmentState(nodeId, intf2Delete.getSupportingCircuitPackName(), false);
+ // Here we update the port-mapping data after the interface delete
+ Mapping oldMapping = this.portMapping.getMapping(
+ nodeId, intf2Delete.getSupportingCircuitPackName(), intf2Delete.getSupportingPort());
+ this.portMapping.deleteMapping(nodeId, oldMapping.getLogicalConnectionPoint());
+ this.portMapping710.updateMapping(nodeId, oldMapping);
}
} else {
<bean id="openRoadmInterfaces710" class="org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl710" >
<argument ref="deviceTransactionManager" />
+ <argument ref="portMapping" />
+ <argument ref="portMapping710" />
</bean>
<bean id="openRoadmInterfaces" class="org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl" >
<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>8.0.7</version>
+ <version>8.0.11</version>
<relativePath />
</parent>
<groupId>org.opendaylight.transportpce</groupId>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>9.0.8</version>
+ <version>9.0.13</version>
<relativePath />
</parent>
<groupId>org.opendaylight.transportpce</groupId>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>9.0.8</version>
+ <version>9.0.13</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>9.0.8</version>
+ <version>9.0.13</version>
<relativePath />
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>9.0.8</version>
+ <version>9.0.13</version>
<relativePath/>
</parent>
<name>OpenDaylight :: transportpce :: swagger</name>
<properties>
- <netconf.version>2.0.11</netconf.version>
+ <netconf.version>2.0.14</netconf.version>
<configfile.directory>etc/opendaylight/karaf</configfile.directory>
</properties>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>9.0.8</version>
+ <version>9.0.13</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>9.0.8</version>
+ <version>9.0.13</version>
<relativePath/>
</parent>
<name>OpenDaylight :: transportpce</name>
<properties>
- <netconf.version>2.0.11</netconf.version>
+ <netconf.version>2.0.14</netconf.version>
<configfile.directory>etc/opendaylight/karaf</configfile.directory>
</properties>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>9.0.8</version>
+ <version>9.0.13</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>8.0.7</version>
+ <version>8.0.11</version>
<relativePath />
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>karaf4-parent</artifactId>
- <version>9.0.8</version>
+ <version>9.0.13</version>
<relativePath/>
</parent>
OpenRoadmInterfacesImpl221 openRoadmInterfacesImpl221 = new OpenRoadmInterfacesImpl221(
deviceTransactionManager, portMapping, portMapping.getPortMappingVersion221());
OpenRoadmInterfacesImpl710 openRoadmInterfacesImpl710 = new OpenRoadmInterfacesImpl710(
- deviceTransactionManager);
+ deviceTransactionManager, portMapping, portMapping.getPortMappingVersion710());
return new OpenRoadmInterfacesImpl(deviceTransactionManager, mappingUtils, openRoadmInterfacesImpl121,
openRoadmInterfacesImpl221, openRoadmInterfacesImpl710);
}
<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>8.0.7</version>
+ <version>8.0.11</version>
<relativePath />
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>bundle-parent</artifactId>
- <version>9.0.8</version>
+ <version>9.0.13</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-artifacts</artifactId>
- <version>8.0.7</version>
+ <version>8.0.11</version>
<scope>import</scope>
<type>pom</type>
</dependency>
import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.OduRateIdentity;
import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.Link1;
import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.Link1Builder;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.Node1;
import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.Node1Builder;
import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.TerminationPoint1;
import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.TerminationPoint1Builder;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.networks.network.node.SwitchingPools;
import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.networks.network.node.SwitchingPoolsBuilder;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.networks.network.node.TpBandwidthSharing;
import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.networks.network.node.TpBandwidthSharingBuilder;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.networks.network.node.XpdrAttributes;
import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.networks.network.node.XpdrAttributesBuilder;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.networks.network.node.termination.point.TpSupportedInterfaces;
import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.networks.network.node.termination.point.TpSupportedInterfacesBuilder;
import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.networks.network.node.termination.point.XpdrTpPortConnectionAttributesBuilder;
import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev200327.SupportedIfCapability;
private static final String CLIENT = "-CLIENT";
private static final String NETWORK = "-NETWORK";
private static final String XPDR = "-XPDR";
+ private static final String OTN_PARAMS_ERROR = "Error with otn parameters of supported link {}";
private static final int NB_TRIB_PORTS = 80;
private static final int NB_TRIB_SLOTS = 80;
- private static final int NB_TRIB_SLOT_PER_10GE = 8;
+
+ private static final Map<String, Class<? extends OduRateIdentity>> RATE_MAP = Map.of(
+ "If100GEODU4", ODU4.class,
+ "IfOCHOTU4ODU4", ODU4.class,
+ "If1GEODU0", ODU0.class,
+ "If10GEODU2", ODU2.class,
+ "If10GEODU2e", ODU2e.class);
+ private static final Map<OtnLinkType, Long> OTNLINKTYPE_BW_MAP = Map.of(
+ OtnLinkType.ODTU4, 100000L,
+ OtnLinkType.ODUC4, 400000L,
+ OtnLinkType.ODUC3, 300000L,
+ OtnLinkType.ODUC2, 200000L);
+ private static final Map<OtnLinkType, Long> OTNLINKTYPE_OTU_BW_MAP = Map.of(
+ OtnLinkType.OTU4, 100000L,
+ OtnLinkType.OTUC4, 400000L);
+ private static final Map<Uint32, Long> SERVICERATE_BWINCR_MAP = Map.of(
+ Uint32.valueOf(1), 1000L,
+ Uint32.valueOf(10), 10000L,
+ Uint32.valueOf(100), 100000L);
+ private static final Map<Uint32, Class<? extends OdtuTypeIdentity>> SERVICERATE_ODTUTYPECLASS_MAP = Map.of(
+ Uint32.valueOf(1), ODTU4TsAllocated.class,
+ Uint32.valueOf(10), ODTU4TsAllocated.class,
+ Uint32.valueOf(100), ODTUCnTs.class);
private OpenRoadmOtnTopology() {
}
}
public static TopologyShard createOtnLinks(String nodeA, String tpA, String nodeZ, String tpZ,
- OtnLinkType linkType) {
- List<Link> links = null;
- if (OtnLinkType.OTU4.equals(linkType) || OtnLinkType.OTUC4.equals(linkType)) {
- links = initialiseOtnLinks(nodeA, tpA, nodeZ, tpZ, linkType);
- }
- return new TopologyShard(null, links);
+ OtnLinkType linkType) {
+
+ return new TopologyShard(
+ null,
+ OTNLINKTYPE_OTU_BW_MAP.containsKey(linkType)
+ ? initialiseOtnLinks(nodeA, tpA, nodeZ, tpZ, linkType)
+ : null);
}
public static TopologyShard createOtnLinks(
.Link notifLink,
OtnLinkType linkType) {
- return new TopologyShard(null, initialiseOtnLinks(notifLink.getATermination().getNodeId(),
- notifLink.getATermination().getTpId(), notifLink.getZTermination().getNodeId(),
- notifLink.getZTermination().getTpId(), linkType));
+ return new TopologyShard(
+ null,
+ initialiseOtnLinks(notifLink.getATermination().getNodeId(),
+ notifLink.getATermination().getTpId(),
+ notifLink.getZTermination().getNodeId(),
+ notifLink.getZTermination().getTpId(),
+ linkType));
}
public static TopologyShard createOtnLinks(
org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev210915.renderer.rpc.result.sp
.Link notifLink,
- List<Link> supportedOtu4links,
- List<TerminationPoint> supportedTPs,
- OtnLinkType linkType) {
+ List<Link> supportedOtu4links, List<TerminationPoint> supportedTPs, OtnLinkType linkType) {
- List<Link> links;
- switch (linkType) {
- case OTU4:
- case OTUC4:
- links = initialiseOtnLinks(
- notifLink.getATermination().getNodeId(), notifLink.getATermination().getTpId(),
- notifLink.getZTermination().getNodeId(), notifLink.getZTermination().getTpId(), linkType);
- return new TopologyShard(null, links);
- case ODTU4:
- case ODUC4:
- links = initialiseOtnLinks(
+ if (OTNLINKTYPE_OTU_BW_MAP.containsKey(linkType)) {
+ return new TopologyShard(
+ null,
+ initialiseOtnLinks(
notifLink.getATermination().getNodeId(), notifLink.getATermination().getTpId(),
- notifLink.getZTermination().getNodeId(), notifLink.getZTermination().getTpId(), linkType);
- links.addAll(updateOtnLinkBwParameters(supportedOtu4links, linkType));
- List<TerminationPoint> updatedTPs = new ArrayList<>();
- for (TerminationPoint tp : supportedTPs) {
- updatedTPs.add(updateTp(tp, true, linkType));
- }
- return new TopologyShard(null, links, updatedTPs);
- default:
- return null;
+ notifLink.getZTermination().getNodeId(), notifLink.getZTermination().getTpId(), linkType));
+ } else if (OTNLINKTYPE_BW_MAP.containsKey(linkType)) {
+ List<Link> links = initialiseOtnLinks(
+ notifLink.getATermination().getNodeId(), notifLink.getATermination().getTpId(),
+ notifLink.getZTermination().getNodeId(), notifLink.getZTermination().getTpId(), linkType);
+ links.addAll(updateOtnLinkBwParameters(supportedOtu4links, linkType));
+ List<TerminationPoint> updatedTPs = new ArrayList<>();
+ for (TerminationPoint tp : supportedTPs) {
+ updatedTPs.add(updateTp(tp, true, linkType));
+ }
+ return new TopologyShard(null, links, updatedTPs);
+ } else {
+ return null;
}
}
public static TopologyShard createOtnLinks(List<Link> suppOtuLinks, List<TerminationPoint> oldTps,
OtnLinkType linkType) {
+
List<Link> links = new ArrayList<>();
for (Link link : suppOtuLinks) {
if (link.augmentation(Link1.class) == null) {
- LOG.error("Error with otn parameters of supported link {}", link.getLinkId().getValue());
+ LOG.error("Error with OTN parameters of supported link {}", link.getLinkId().getValue());
continue;
}
- if (OtnLinkType.ODTU4.equals(linkType)
- && link.augmentation(Link1.class).getAvailableBandwidth().equals(Uint32.valueOf(100000))) {
- links.add(updateOtnLinkBwParameters(link, 0L, 100000L));
- } else if (OtnLinkType.ODUC4.equals(linkType)
- && link.augmentation(Link1.class).getAvailableBandwidth().equals(Uint32.valueOf(400000))) {
- links.add(updateOtnLinkBwParameters(link, 0L, 400000L));
- } else if (OtnLinkType.ODUC3.equals(linkType)
- && link.augmentation(Link1.class).getAvailableBandwidth().equals(Uint32.valueOf(300000))) {
- links.add(updateOtnLinkBwParameters(link, 0L, 300000L));
- } else if (OtnLinkType.ODUC2.equals(linkType)
- && link.augmentation(Link1.class).getAvailableBandwidth().equals(Uint32.valueOf(200000))) {
- links.add(updateOtnLinkBwParameters(link, 0L, 200000L));
- } else {
- LOG.error("Unsupported OTN Link Type link or unsufficient available bandwith: {}",
- link.getLinkId().getValue());
+ if (!OTNLINKTYPE_BW_MAP.containsKey(linkType)) {
+ LOG.error("Error with link {} : unsupported OTN link type", link.getLinkId().getValue());
+ continue;
}
- //TODO use a Map here instead of multiple else-if-blocks
+ if (link.augmentation(Link1.class).getAvailableBandwidth().longValue() < OTNLINKTYPE_BW_MAP.get(linkType)) {
+ LOG.error("Error with link {} : unsufficient available bandwith", link.getLinkId().getValue());
+ continue;
+ }
+ links.add(updateOtnLinkBwParameters(link, 0L, OTNLINKTYPE_BW_MAP.get(linkType)));
}
if (links.size() == 2) {
links.addAll(initialiseOtnLinks(suppOtuLinks.get(0).getSource().getSourceNode().getValue(),
for (TerminationPoint tp : oldTps) {
tps.add(updateTp(tp, true, linkType));
}
- if (links.size() == 4 && tps.size() == 2) {
- return new TopologyShard(null, links, tps);
- } else {
- return new TopologyShard(null, null, null);
- }
+ return links.size() == 4 && tps.size() == 2
+ ? new TopologyShard(null, links, tps)
+ : new TopologyShard(null, null, null);
}
public static TopologyShard updateOtnLinks(List<Link> suppOduLinks, List<TerminationPoint> oldTps,
- Uint32 serviceRate, Short tribPortNb, Short minTribSlotNb, Short maxTribSlotNb, boolean isDeletion) {
+ Uint32 serviceRate, Short tribPortNb, Short minTribSlotNb, Short maxTribSlotNb, boolean isDeletion) {
+
List<Link> links = new ArrayList<>();
- Long bwIncr;
- switch (serviceRate.intValue()) {
- case 1:
- bwIncr = 1000L;
- break;
- case 10:
- bwIncr = 10000L;
- break;
- case 100:
- bwIncr = 100000L;
- break;
- default:
- LOG.warn("Error with not managed service rate {}", serviceRate.toString());
- return new TopologyShard(null, null, null);
+ if (!SERVICERATE_BWINCR_MAP.containsKey(serviceRate)) {
+ LOG.warn("Error with not managed service rate {}", serviceRate.toString());
+ return new TopologyShard(null, null, null);
}
+ Long bwIncr = SERVICERATE_BWINCR_MAP.get(serviceRate);
for (Link link : suppOduLinks) {
- if (link.augmentation(Link1.class) != null && link.augmentation(Link1.class).getAvailableBandwidth() != null
- && link.augmentation(Link1.class).getUsedBandwidth() != null) {
+ if (link.augmentation(Link1.class) == null
+ || link.augmentation(Link1.class).getAvailableBandwidth() == null
+ || link.augmentation(Link1.class).getUsedBandwidth() == null) {
+ LOG.error(OTN_PARAMS_ERROR, link.getLinkId().getValue());
+ } else {
Uint32 avlBw = link.augmentation(Link1.class).getAvailableBandwidth();
Uint32 usedBw = link.augmentation(Link1.class).getUsedBandwidth();
if (avlBw.toJava() < bwIncr) {
bwIncr = 0L;
}
- if (isDeletion) {
- links.add(updateOtnLinkBwParameters(link, avlBw.toJava() + bwIncr,
- usedBw.toJava() - bwIncr));
- } else {
- links.add(updateOtnLinkBwParameters(link, avlBw.toJava() - bwIncr,
- usedBw.toJava() + bwIncr));
- }
- } else {
- LOG.error("Error with otn parameters of supported link {}", link.getLinkId().getValue());
+ links.add(
+ isDeletion
+ ? updateOtnLinkBwParameters(link, avlBw.toJava() + bwIncr, usedBw.toJava() - bwIncr)
+ : updateOtnLinkBwParameters(link, avlBw.toJava() - bwIncr, usedBw.toJava() + bwIncr)
+ );
}
}
List<TerminationPoint> tps = new ArrayList<>();
for (TerminationPoint tp : oldTps) {
- if (bwIncr != 0) {
+ if (bwIncr > 0L) {
tps.add(updateNodeTpTsPool(tp, serviceRate, tribPortNb, minTribSlotNb, maxTribSlotNb, isDeletion));
}
}
- if (!links.isEmpty() && !tps.isEmpty()) {
- return new TopologyShard(null, links, tps);
- } else {
+ if (links.isEmpty() || tps.isEmpty()) {
LOG.error("unable to update otn links");
return new TopologyShard(null, null, null);
+ } else {
+ return new TopologyShard(null, links, tps);
}
}
public static TopologyShard updateOtnLinks(List<Link> suppOtuLinks, boolean isDeletion) {
+
List<Link> links = new ArrayList<>();
for (Link link : suppOtuLinks) {
if (link.augmentation(Link1.class) == null
|| link.augmentation(Link1.class).getAvailableBandwidth() == null
|| link.augmentation(Link1.class).getUsedBandwidth() == null) {
- LOG.error("Error with otn parameters of supported link {}", link.getLinkId().getValue());
+ LOG.error(OTN_PARAMS_ERROR, link.getLinkId().getValue());
} else {
- if (isDeletion) {
- links.add(updateOtnLinkBwParameters(link, Long.valueOf(100000), Long.valueOf(0)));
- } else {
- links.add(updateOtnLinkBwParameters(link, Long.valueOf(0), Long.valueOf(100000)));
- }
+ links.add(
+ isDeletion
+ ? updateOtnLinkBwParameters(link, Long.valueOf(100000), Long.valueOf(0))
+ : updateOtnLinkBwParameters(link, Long.valueOf(0), Long.valueOf(100000))
+ );
}
}
if (links.isEmpty()) {
public static TopologyShard deleteOtnLinks(List<Link> suppOtuLinks, List<TerminationPoint> oldTps,
OtnLinkType linkType) {
+
List<Link> links = new ArrayList<>();
- OtnLinkType otnLinkType = null;
for (Link link : suppOtuLinks) {
- if (link.augmentation(Link1.class) != null && link.augmentation(
- org.opendaylight.yang.gen.v1.http.transportpce.topology.rev220123.Link1.class) != null) {
- otnLinkType = link.augmentation(
- org.opendaylight.yang.gen.v1.http.transportpce.topology.rev220123.Link1.class).getOtnLinkType();
- if (OtnLinkType.OTU4.equals(otnLinkType)) {
- links.add(updateOtnLinkBwParameters(link, 100000L, 0L));
- } else if (OtnLinkType.OTUC4.equals(otnLinkType)) {
- links.add(updateOtnLinkBwParameters(link, 400000L, 0L));
- } else {
- LOG.warn("Unexpected otn-link-type {} for link {}", otnLinkType, link.getLinkId());
- }
- } else {
- LOG.error("Error with otn parameters of supported link {}", link.getLinkId().getValue());
+ if (link.augmentation(Link1.class) == null
+ || link.augmentation(
+ org.opendaylight.yang.gen.v1.http.transportpce.topology.rev220123.Link1.class) == null) {
+ LOG.error(OTN_PARAMS_ERROR, link.getLinkId().getValue());
return new TopologyShard(null, null, null);
}
+ OtnLinkType otnLinkType = link.augmentation(
+ org.opendaylight.yang.gen.v1.http.transportpce.topology.rev220123.Link1.class).getOtnLinkType();
+ if (!OTNLINKTYPE_OTU_BW_MAP.containsKey(otnLinkType)) {
+ //TODO shouldn't other link type listed in OTNLINKTYPE_BW_MAP be handled too ?
+ LOG.warn("Unexpected otn-link-type {} for link {}", otnLinkType, link.getLinkId());
+ continue;
+ }
+ links.add(updateOtnLinkBwParameters(link, OTNLINKTYPE_OTU_BW_MAP.get(otnLinkType) , 0L));
}
List<TerminationPoint> tps = new ArrayList<>();
for (TerminationPoint tp : oldTps) {
tps.add(updateTp(tp, false, linkType));
}
- if (!links.isEmpty() && !tps.isEmpty()) {
- return new TopologyShard(null, links, tps);
- } else {
- return new TopologyShard(null, null, null);
- }
+ return
+ links.isEmpty() || tps.isEmpty()
+ ? new TopologyShard(null, null, null)
+ : new TopologyShard(null, links, tps);
}
private static List<Link> initialiseOtnLinks(String nodeA, String tpA, String nodeZ, String tpZ,
OtnLinkType linkType) {
+
List<Link> links = new ArrayList<>();
String nodeATopo = formatNodeName(nodeA, tpA);
String nodeZTopo = formatNodeName(nodeZ, tpZ);
org.opendaylight.yang.gen.v1.http.transportpce.topology.rev220123.Link1 tpceLink1
= new org.opendaylight.yang.gen.v1.http.transportpce.topology.rev220123.Link1Builder()
- .setOtnLinkType(linkType).build();
+ .setOtnLinkType(linkType).build();
Link1Builder otnLink1Bldr = new Link1Builder()
.setUsedBandwidth(Uint32.valueOf(0));
- switch (linkType) {
- case OTU4:
- case ODTU4:
- otnLink1Bldr.setAvailableBandwidth(Uint32.valueOf(100000));
- break;
- case OTUC4:
- case ODUC4:
- otnLink1Bldr.setAvailableBandwidth(Uint32.valueOf(400000));
- break;
- default:
- LOG.error("unable to set available bandwidth to unknown link type");
- break;
+ if (OTNLINKTYPE_OTU_BW_MAP.containsKey(linkType)) {
+ otnLink1Bldr.setAvailableBandwidth(Uint32.valueOf(OTNLINKTYPE_OTU_BW_MAP.get(linkType)));
+ } else if (OTNLINKTYPE_BW_MAP.containsKey(linkType)) {
+ otnLink1Bldr.setAvailableBandwidth(Uint32.valueOf(OTNLINKTYPE_BW_MAP.get(linkType)));
+ } else {
+ LOG.error("unable to set available bandwidth to unknown link type");
}
// create link A-Z
LinkBuilder ietfLinkAZBldr = TopologyUtils.createLink(nodeATopo, nodeZTopo, tpA, tpZ, linkType.getName());
- ietfLinkAZBldr
+ links.add(ietfLinkAZBldr
.addAugmentation(tpceLink1)
.addAugmentation(otnLink1Bldr.build())
.addAugmentation(
new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Link1Builder(
ietfLinkAZBldr.augmentation(
org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Link1.class))
- .setLinkType(OpenroadmLinkType.OTNLINK)
- .setOperationalState(State.InService)
- .setAdministrativeState(AdminStates.InService)
- .build());
- links.add(ietfLinkAZBldr.build());
+ .setLinkType(OpenroadmLinkType.OTNLINK)
+ .setOperationalState(State.InService)
+ .setAdministrativeState(AdminStates.InService)
+ .build())
+ .build());
// create link Z-A
LinkBuilder ietfLinkZABldr = TopologyUtils.createLink(nodeZTopo, nodeATopo, tpZ, tpA, linkType.getName());
- ietfLinkZABldr
+ links.add(ietfLinkZABldr
.addAugmentation(tpceLink1)
.addAugmentation(otnLink1Bldr.build())
.addAugmentation(
new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Link1Builder(
ietfLinkZABldr.augmentation(
org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Link1.class))
- .setLinkType(OpenroadmLinkType.OTNLINK)
- .setOperationalState(State.InService)
- .setAdministrativeState(AdminStates.InService)
- .build());
- links.add(ietfLinkZABldr.build());
+ .setLinkType(OpenroadmLinkType.OTNLINK)
+ .setOperationalState(State.InService)
+ .setAdministrativeState(AdminStates.InService)
+ .build())
+ .build());
return links;
}
private static Link updateOtnLinkBwParameters(Link link, Long availBw, Long usedBw) {
+
LOG.debug("in updateOtnLinkBwParameters with availBw = {}, usedBw = {}", availBw, usedBw);
- LinkBuilder updatedLinkBldr = new LinkBuilder(link);
- Link1Builder updatedLink1Bldr = new Link1Builder(link.augmentation(Link1.class))
- .setAvailableBandwidth(Uint32.valueOf(availBw))
- .setUsedBandwidth(Uint32.valueOf(usedBw));
- updatedLinkBldr.addAugmentation(updatedLink1Bldr.build());
- return updatedLinkBldr.build();
+ return new LinkBuilder(link)
+ .addAugmentation(
+ new Link1Builder(link.augmentation(Link1.class))
+ .setAvailableBandwidth(Uint32.valueOf(availBw))
+ .setUsedBandwidth(Uint32.valueOf(usedBw))
+ .build())
+ .build();
}
private static List<Link> updateOtnLinkBwParameters(List<Link> supportedLinks, OtnLinkType linkType) {
+
LOG.debug("in updateOtnLinkBwParameters with supportedLinks = {}, linkType = {}", supportedLinks, linkType);
- Uint32 usedBw;
- switch (linkType) {
- case ODTU4:
- usedBw = Uint32.valueOf(100000);
- break;
- case ODUC4:
- usedBw = Uint32.valueOf(400000);
- break;
- default:
- usedBw = Uint32.valueOf(0);
- break;
- }
List<Link> updatedlinks = new ArrayList<>();
for (Link link : supportedLinks) {
- LinkBuilder updatedLinkBldr = new LinkBuilder(link);
- updatedLinkBldr.addAugmentation(new Link1Builder(link.augmentation(Link1.class))
- .setAvailableBandwidth(Uint32.valueOf(0))
- .setUsedBandwidth(usedBw)
- .build());
- updatedlinks.add(updatedLinkBldr.build());
+ updatedlinks.add(
+ new LinkBuilder(link)
+ .addAugmentation(new Link1Builder(link.augmentation(Link1.class))
+ .setAvailableBandwidth(Uint32.valueOf(0))
+ .setUsedBandwidth(
+ OTNLINKTYPE_BW_MAP.containsKey(linkType)
+ ? Uint32.valueOf(OTNLINKTYPE_BW_MAP.get(linkType))
+ : Uint32.valueOf(0))
+ .build())
+ .build());
}
return updatedlinks;
}
private static TerminationPoint updateTp(TerminationPoint originalTp, boolean addingTsTpnPoolTermination,
OtnLinkType linkType) {
+
LOG.debug("in updateTp");
TerminationPointBuilder tpBldr = new TerminationPointBuilder(originalTp);
- TerminationPoint1Builder otnTp1Bldr = new TerminationPoint1Builder(
- tpBldr.augmentation(TerminationPoint1.class));
- XpdrTpPortConnectionAttributesBuilder xtpcaBldr = new XpdrTpPortConnectionAttributesBuilder(otnTp1Bldr
- .getXpdrTpPortConnectionAttributes());
+ TerminationPoint1Builder otnTp1Bldr =
+ new TerminationPoint1Builder(tpBldr.augmentation(TerminationPoint1.class));
+ XpdrTpPortConnectionAttributesBuilder xtpcaBldr =
+ new XpdrTpPortConnectionAttributesBuilder(otnTp1Bldr.getXpdrTpPortConnectionAttributes());
if (addingTsTpnPoolTermination) {
List<Uint16> tsPool = new ArrayList<>();
for (int i = 1; i <= NB_TRIB_SLOTS; i++) {
for (int i = 1; i <= nbTribPort; i++) {
tpnPool.add(Uint16.valueOf(i));
}
- OdtuTpnPool oduTpnPool = new OdtuTpnPoolBuilder().setOdtuType(ODTU4TsAllocated.class)
- .setTpnPool(tpnPool).build();
+ OdtuTpnPool oduTpnPool = new OdtuTpnPoolBuilder()
+ .setOdtuType(ODTU4TsAllocated.class)
+ .setTpnPool(tpnPool)
+ .build();
xtpcaBldr.setOdtuTpnPool(ImmutableMap.of(oduTpnPool.key(),oduTpnPool));
} else {
xtpcaBldr.setTsPool(null);
}
private static TerminationPoint updateNodeTpTsPool(TerminationPoint tp, Uint32 serviceRate, Short tribPortNb,
- Short minTribSlotNb, Short maxTribSlotNb, boolean isDeletion) {
+ Short minTribSlotNb, Short maxTribSlotNb, boolean isDeletion) {
+
LOG.debug("in updateNodeTpTsPool");
TerminationPointBuilder tpBldr = new TerminationPointBuilder(tp);
@Nullable
- XpdrTpPortConnectionAttributesBuilder xtpcaBldr = new XpdrTpPortConnectionAttributesBuilder(
- tpBldr.augmentation(TerminationPoint1.class).getXpdrTpPortConnectionAttributes());
+ XpdrTpPortConnectionAttributesBuilder xtpcaBldr =
+ new XpdrTpPortConnectionAttributesBuilder(
+ tpBldr.augmentation(TerminationPoint1.class).getXpdrTpPortConnectionAttributes());
List<Uint16> tsPool = new ArrayList<>(xtpcaBldr.getTsPool());
if (isDeletion) {
for (int i = minTribSlotNb; i <= maxTribSlotNb; i++) {
xtpcaBldr.setTsPool(tsPool);
List<Uint16> tpnPool;
List<OdtuTpnPool> odtuTpnPoolValues = new ArrayList<>(xtpcaBldr.getOdtuTpnPool().values());
- if (odtuTpnPoolValues.get(0).getTpnPool() != null) {
+ if (odtuTpnPoolValues.get(0).getTpnPool() == null) {
+ tpnPool = new ArrayList<>();
+ } else {
tpnPool = new ArrayList<>(odtuTpnPoolValues.get(0).getTpnPool());
if (isDeletion) {
tpnPool.add(Uint16.valueOf(tribPortNb));
} else {
tpnPool.remove(Uint16.valueOf(tribPortNb));
}
- } else {
- tpnPool = new ArrayList<>();
}
- Class<? extends OdtuTypeIdentity> odtuType = null;
- switch (serviceRate.intValue()) {
- case 1:
- case 10:
- odtuType = ODTU4TsAllocated.class;
- break;
- case 100:
- odtuType = ODTUCnTs.class;
- break;
- default:
- LOG.warn("Unable to set the odtu-type");
- break;
+ Class<? extends OdtuTypeIdentity> odtuType;
+ if (SERVICERATE_ODTUTYPECLASS_MAP.containsKey(serviceRate)) {
+ odtuType = SERVICERATE_ODTUTYPECLASS_MAP.get(serviceRate);
+ } else {
+ odtuType = null;
+ LOG.warn("Unable to set the odtu-type");
}
- OdtuTpnPool odtuTpnPool = new OdtuTpnPoolBuilder().setOdtuType(odtuType)
- .setTpnPool(tpnPool).build();
- xtpcaBldr.setOdtuTpnPool(ImmutableMap.of(odtuTpnPool.key(),odtuTpnPool));
-
- tpBldr.addAugmentation(new TerminationPoint1Builder(tp.augmentation(TerminationPoint1.class))
- .setXpdrTpPortConnectionAttributes(xtpcaBldr.build()).build());
- return tpBldr.build();
+ OdtuTpnPool odtuTpnPool = new OdtuTpnPoolBuilder()
+ .setOdtuType(odtuType)
+ .setTpnPool(tpnPool)
+ .build();
+ return tpBldr
+ .addAugmentation(
+ new TerminationPoint1Builder(tp.augmentation(TerminationPoint1.class))
+ .setXpdrTpPortConnectionAttributes(
+ xtpcaBldr
+ .setOdtuTpnPool(ImmutableMap.of(odtuTpnPool.key(),odtuTpnPool))
+ .build())
+ .build())
+ .build();
}
private static Map<Integer, OtnTopoNode> convertPortMappingToOtnNodeList(Nodes mappingNode) {
- List<Mapping> networkMappings = mappingNode.nonnullMapping().values()
- .stream().filter(k -> k.getLogicalConnectionPoint()
- .contains("NETWORK")).collect(Collectors.toList());
+
+ List<Mapping> networkMappings =
+ mappingNode.nonnullMapping().values().stream()
+ .filter(k -> k.getLogicalConnectionPoint().contains("NETWORK"))
+ .collect(Collectors.toList());
Map<Integer, OtnTopoNode> xpdrMap = new HashMap<>();
for (Mapping mapping : networkMappings) {
Integer xpdrNb = Integer.parseInt(mapping.getLogicalConnectionPoint().split("XPDR")[1].split("-")[0]);
if (!xpdrMap.containsKey(xpdrNb)) {
- List<Mapping> xpdrNetMaps = mappingNode.nonnullMapping().values()
- .stream().filter(k -> k.getLogicalConnectionPoint()
- .contains("XPDR" + xpdrNb + NETWORK)).collect(Collectors.toList());
- List<Mapping> xpdrClMaps = mappingNode.nonnullMapping().values()
- .stream().filter(k -> k.getLogicalConnectionPoint()
- .contains("XPDR" + xpdrNb + CLIENT)).collect(Collectors.toList());
- OtnTopoNode otnNode = null;
- if (mapping.getXponderType() != null) {
- otnNode = new OtnTopoNode(mappingNode.getNodeId(), mappingNode.getNodeInfo().getNodeClli(), xpdrNb,
- mapping.getXponderType(), fillConnectionMapLcp(xpdrNetMaps), fillConnectionMapLcp(xpdrClMaps),
- xpdrNetMaps, xpdrClMaps);
- } else {
- otnNode = new OtnTopoNode(mappingNode.getNodeId(), mappingNode.getNodeInfo().getNodeClli(), xpdrNb,
- XpdrNodeTypes.Tpdr, fillConnectionMapLcp(xpdrNetMaps), fillConnectionMapLcp(xpdrClMaps),
- xpdrNetMaps, xpdrClMaps);
- }
- xpdrMap.put(xpdrNb, otnNode);
+ List<Mapping> xpdrNetMaps =
+ mappingNode.nonnullMapping().values().stream()
+ .filter(k -> k.getLogicalConnectionPoint().contains("XPDR" + xpdrNb + NETWORK))
+ .collect(Collectors.toList());
+ List<Mapping> xpdrClMaps =
+ mappingNode.nonnullMapping().values().stream()
+ .filter(k -> k.getLogicalConnectionPoint().contains("XPDR" + xpdrNb + CLIENT))
+ .collect(Collectors.toList());
+ xpdrMap.put(
+ xpdrNb,
+ new OtnTopoNode(
+ mappingNode.getNodeId(),
+ mappingNode.getNodeInfo().getNodeClli(),
+ xpdrNb,
+ mapping.getXponderType() == null
+ ? XpdrNodeTypes.Tpdr
+ : mapping.getXponderType(),
+ fillConnectionMapLcp(xpdrNetMaps),
+ fillConnectionMapLcp(xpdrClMaps),
+ xpdrNetMaps,
+ xpdrClMaps
+ ));
}
}
LOG.debug("there are {} xpdr to build", xpdrMap.size());
- xpdrMap.forEach((k, v) -> LOG.debug("xpdr {} = {} - {} - {} - {}", k, v.getNodeId(), v.getNodeType(),
- v.getNbTpClient(), v.getNbTpNetwork()));
+ xpdrMap.forEach((k, v) -> LOG.debug("xpdr {} = {} - {} - {} - {}",
+ k, v.getNodeId(), v.getNodeType(), v.getNbTpClient(), v.getNbTpNetwork()));
return xpdrMap;
}
private static Map<String, String> fillConnectionMapLcp(List<Mapping> mappingList) {
+
Map<String, String> xpdrConnectionMap = new HashMap<>();
for (Mapping map : mappingList) {
- if (map.getConnectionMapLcp() != null) {
- xpdrConnectionMap.put(map.getLogicalConnectionPoint(), map.getConnectionMapLcp());
- } else {
- xpdrConnectionMap.put(map.getLogicalConnectionPoint(), null);
- }
+ xpdrConnectionMap.put(map.getLogicalConnectionPoint(), map.getConnectionMapLcp());
}
return xpdrConnectionMap;
}
private static Node createTpdr(OtnTopoNode node) {
- // create otn-topology node augmentation
- XpdrAttributes xpdrAttr = new XpdrAttributesBuilder()
- .setXpdrNumber(Uint16.valueOf(node.getXpdrNb()))
- .build();
- Node1 otnNodeAug = new Node1Builder()
- .setXpdrAttributes(xpdrAttr)
- .build();
- org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Node1 ocnNodeAug =
- new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Node1Builder()
- .setNodeType(OpenroadmNodeType.TPDR)
- .setOperationalState(State.InService)
- .setAdministrativeState(AdminStates.InService)
- .build();
- // create ietf node augmentation to add TP list
+
+ // prepare ietf node augmentation to add TP list
Map<TerminationPointKey,TerminationPoint> tpMap = new HashMap<>();
- // creation of tps
createTP(tpMap, node, OpenroadmTpType.XPONDERCLIENT, false);
createTP(tpMap, node, OpenroadmTpType.XPONDERNETWORK, true);
-
- org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1 ietfNodeAug =
- new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1Builder()
- .setTerminationPoint(tpMap)
- .build();
-
// return ietfNode
return new NodeBuilder()
.setNodeId(new NodeId(node.getNodeId() + XPDR + node.getXpdrNb()))
.withKey(new NodeKey(new NodeId(node.getNodeId() + XPDR + node.getXpdrNb())))
.setSupportingNode(createSupportingNodes(node))
- .addAugmentation(otnNodeAug)
- .addAugmentation(ocnNodeAug)
- .addAugmentation(ietfNodeAug)
+ .addAugmentation(
+ new Node1Builder()
+ .setXpdrAttributes(
+ new XpdrAttributesBuilder()
+ .setXpdrNumber(Uint16.valueOf(node.getXpdrNb()))
+ .build())
+ .build())
+ .addAugmentation(
+ new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Node1Builder()
+ .setNodeType(OpenroadmNodeType.TPDR)
+ .setOperationalState(State.InService)
+ .setAdministrativeState(AdminStates.InService)
+ .build())
+ .addAugmentation(
+ new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
+ .Node1Builder()
+ .setTerminationPoint(tpMap)
+ .build())
.build();
}
private static Node createMuxpdr(OtnTopoNode node) {
- // create otn-topology node augmentation
- // TODO: will need to be completed
- TpBandwidthSharing tpBwSh = new TpBandwidthSharingBuilder().build();
- XpdrAttributes xpdrAttr = new XpdrAttributesBuilder()
- .setXpdrNumber(Uint16.valueOf(node.getXpdrNb()))
- .build();
+ // prepare otn-topology node augmentation
+ // TODO: will need to be completed
Map<NonBlockingListKey, NonBlockingList> nbMap = new HashMap<>();
for (int i = 1; i <= node.getNbTpClient(); i++) {
List<TpId> tpList = new ArrayList<>();
- TpId tpId = new TpId("XPDR" + node.getXpdrNb() + CLIENT + i);
- tpList.add(tpId);
- tpId = new TpId("XPDR" + node.getXpdrNb() + "-NETWORK1");
- tpList.add(tpId);
+ tpList.add(new TpId("XPDR" + node.getXpdrNb() + CLIENT + i));
+ tpList.add(new TpId("XPDR" + node.getXpdrNb() + "-NETWORK1"));
NonBlockingList nbl = new NonBlockingListBuilder()
.setNblNumber(Uint16.valueOf(i))
.setTpList(tpList)
.setSwitchingPoolType(SwitchingPoolTypes.NonBlocking)
.setNonBlockingList(nbMap)
.build();
- SwitchingPools switchingPools = new SwitchingPoolsBuilder()
- .setOduSwitchingPools(Map.of(oduSwitchPool.key(),oduSwitchPool))
- .build();
- Node1 otnNodeAug = new Node1Builder()
- .setTpBandwidthSharing(tpBwSh)
- .setXpdrAttributes(xpdrAttr)
- .setSwitchingPools(switchingPools)
- .build();
- org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Node1 ocnNodeAug =
- new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Node1Builder()
- .setNodeType(OpenroadmNodeType.MUXPDR)
- .setAdministrativeState(AdminStates.InService)
- .setOperationalState(State.InService)
- .build();
-
- // create ietf node augmentation to add TP list
+ // prepare ietf node augmentation to add TP list
Map<TerminationPointKey, TerminationPoint> tpMap = new HashMap<>();
- // creation of tps
createTP(tpMap, node, OpenroadmTpType.XPONDERCLIENT, true);
createTP(tpMap, node, OpenroadmTpType.XPONDERNETWORK, true);
-
- org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1 ietfNodeAug =
- new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1Builder()
- .setTerminationPoint(tpMap)
- .build();
-
// return ietfNode
return new NodeBuilder()
.setNodeId(new NodeId(node.getNodeId() + XPDR + node.getXpdrNb()))
.withKey(new NodeKey(new NodeId(node.getNodeId() + XPDR + node.getXpdrNb())))
.setSupportingNode(createSupportingNodes(node))
- .addAugmentation(otnNodeAug)
- .addAugmentation(ocnNodeAug)
- .addAugmentation(ietfNodeAug)
+ .addAugmentation(
+ new Node1Builder()
+ .setTpBandwidthSharing(new TpBandwidthSharingBuilder().build())
+ .setXpdrAttributes(
+ new XpdrAttributesBuilder()
+ .setXpdrNumber(Uint16.valueOf(node.getXpdrNb()))
+ .build())
+ .setSwitchingPools(
+ new SwitchingPoolsBuilder()
+ .setOduSwitchingPools(Map.of(oduSwitchPool.key(),oduSwitchPool))
+ .build())
+ .build())
+ .addAugmentation(
+ new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Node1Builder()
+ .setNodeType(OpenroadmNodeType.MUXPDR)
+ .setAdministrativeState(AdminStates.InService)
+ .setOperationalState(State.InService)
+ .build())
+ .addAugmentation(
+ new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
+ .Node1Builder()
+ .setTerminationPoint(tpMap)
+ .build())
.build();
}
private static Node createSwitch(OtnTopoNode node) {
+
List<TpId> tpl = new ArrayList<>();
- TpId tpId = null;
for (int i = 1; i <= node.getNbTpClient(); i++) {
- tpId = new TpId("XPDR" + node.getXpdrNb() + CLIENT + i);
- tpl.add(tpId);
+ tpl.add(new TpId("XPDR" + node.getXpdrNb() + CLIENT + i));
}
for (int i = 1; i <= node.getNbTpNetwork(); i++) {
- tpId = new TpId("XPDR" + node.getXpdrNb() + NETWORK + i);
- tpl.add(tpId);
+ tpl.add(new TpId("XPDR" + node.getXpdrNb() + NETWORK + i));
}
Map<NonBlockingListKey, NonBlockingList> nbMap = new HashMap<>();
NonBlockingList nbl = new NonBlockingListBuilder()
.setTpList(tpl)
.build();
nbMap.put(nbl.key(),nbl);
-
OduSwitchingPools oduSwitchPool = new OduSwitchingPoolsBuilder()
.setSwitchingPoolNumber(Uint16.valueOf(1))
.setSwitchingPoolType(SwitchingPoolTypes.NonBlocking)
.build();
Map<OduSwitchingPoolsKey, OduSwitchingPools> oduSwitchPoolList = new HashMap<>();
oduSwitchPoolList.put(oduSwitchPool.key(),oduSwitchPool);
- SwitchingPools switchingPools = new SwitchingPoolsBuilder()
- .setOduSwitchingPools(oduSwitchPoolList)
- .build();
-
- // create otn-topology node augmentation
- // TODO: will need to be completed
- TpBandwidthSharing tpBwSh = new TpBandwidthSharingBuilder().build();
- XpdrAttributes xpdrAttr = new XpdrAttributesBuilder()
- .setXpdrNumber(Uint16.valueOf(node.getXpdrNb()))
- .build();
-
- Node1 otnNodeAug = new Node1Builder()
- .setTpBandwidthSharing(tpBwSh)
- .setXpdrAttributes(xpdrAttr)
- .setSwitchingPools(switchingPools)
- .build();
- org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Node1 ocnNodeAug =
- new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Node1Builder()
- .setNodeType(OpenroadmNodeType.SWITCH)
- .setOperationalState(State.InService)
- .setAdministrativeState(AdminStates.InService)
- .build();
-
- // create ietf node augmentation to add TP list
+ // prepare ietf node augmentation to add TP list
Map<TerminationPointKey, TerminationPoint> tpMap = new HashMap<>();
- // creation of tps
createTP(tpMap, node, OpenroadmTpType.XPONDERCLIENT, true);
createTP(tpMap, node, OpenroadmTpType.XPONDERNETWORK, true);
- org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1 ietfNodeAug =
- new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1Builder()
- .setTerminationPoint(tpMap)
- .build();
-
// return ietfNode
return new NodeBuilder()
.setNodeId(new NodeId(node.getNodeId() + XPDR + node.getXpdrNb()))
.withKey(new NodeKey(new NodeId(node.getNodeId() + XPDR + node.getXpdrNb())))
.setSupportingNode(createSupportingNodes(node))
- .addAugmentation(otnNodeAug)
- .addAugmentation(ocnNodeAug)
- .addAugmentation(ietfNodeAug)
+ .addAugmentation(
+ new Node1Builder()
+ .setTpBandwidthSharing(new TpBandwidthSharingBuilder().build())
+ .setXpdrAttributes(
+ new XpdrAttributesBuilder()
+ .setXpdrNumber(Uint16.valueOf(node.getXpdrNb()))
+ .build())
+ .setSwitchingPools(
+ new SwitchingPoolsBuilder()
+ .setOduSwitchingPools(oduSwitchPoolList)
+ .build())
+ .build())
+ .addAugmentation(
+ new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Node1Builder()
+ .setNodeType(OpenroadmNodeType.SWITCH)
+ .setOperationalState(State.InService)
+ .setAdministrativeState(AdminStates.InService)
+ .build())
+ .addAugmentation(
+ new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
+ .Node1Builder()
+ .setTerminationPoint(tpMap)
+ .build())
.build();
}
private static void createTP(Map<TerminationPointKey, TerminationPoint> tpMap,
OtnTopoNode node, OpenroadmTpType tpType, boolean withRate) {
+
List<Mapping> mappings = null;
switch (tpType) {
case XPONDERNETWORK:
private static void fillTpMap(Map<TerminationPointKey, TerminationPoint> tpMap, OtnTopoNode node,
OpenroadmTpType tpType, boolean withRate, List<Mapping> mappings) {
+
for (Mapping mapping : mappings) {
// openroadm-otn-topoology augmentation
Map<SupportedInterfaceCapabilityKey, SupportedInterfaceCapability> supIfMap = new HashMap<>();
TerminationPoint1Builder otnTp1Bldr = new TerminationPoint1Builder();
- if (mapping.getSupportedInterfaceCapability() != null) {
+ if (mapping.getSupportedInterfaceCapability() == null) {
+ LOG.warn("mapping {} of node {} has no if-cap-type",
+ mapping.getLogicalConnectionPoint(), node.getNodeId());
+ } else {
XpdrTpPortConnectionAttributesBuilder xtpcaBldr = new XpdrTpPortConnectionAttributesBuilder();
for (Class<? extends SupportedIfCapability> supInterCapa : mapping.getSupportedInterfaceCapability()) {
SupportedInterfaceCapability supIfCapa = new SupportedInterfaceCapabilityBuilder()
.build();
supIfMap.put(supIfCapa.key(), supIfCapa);
}
- TpSupportedInterfaces tpSupIf = new TpSupportedInterfacesBuilder()
- .setSupportedInterfaceCapability(supIfMap)
- .build();
- otnTp1Bldr.setTpSupportedInterfaces(tpSupIf);
+ otnTp1Bldr.setTpSupportedInterfaces(
+ new TpSupportedInterfacesBuilder()
+ .setSupportedInterfaceCapability(supIfMap)
+ .build()
+ );
//TODO: It is not logical to assign a priori one of the possible rate to the TP.
//Would be worth assigning per default "unallocated" at the tp creation step,
//and updating it with correct rate when it supports a specific service.
if (withRate) {
- xtpcaBldr.setRate(fixRate(mapping.getSupportedInterfaceCapability()));
- otnTp1Bldr.setXpdrTpPortConnectionAttributes(xtpcaBldr.build());
+ otnTp1Bldr.setXpdrTpPortConnectionAttributes(
+ xtpcaBldr.setRate(fixRate(mapping.getSupportedInterfaceCapability())).build());
}
- } else {
- LOG.warn("mapping {} of node {} has no if-cap-type", mapping.getLogicalConnectionPoint(),
- node.getNodeId());
}
- org.opendaylight.yang.gen.v1.http.transportpce.topology.rev220123.TerminationPoint1Builder tpceTp1Bldr =
- new org.opendaylight.yang.gen.v1.http.transportpce.topology.rev220123.TerminationPoint1Builder();
- TpId tpId = new TpId(mapping.getLogicalConnectionPoint());
- setclientNwTpAttr(tpMap, node, tpId, tpType, otnTp1Bldr.build(), tpceTp1Bldr, mapping);
+ setclientNwTpAttr(
+ tpMap,
+ node,
+ new TpId(mapping.getLogicalConnectionPoint()),
+ tpType,
+ otnTp1Bldr.build(),
+ new org.opendaylight.yang.gen.v1.http.transportpce.topology.rev220123.TerminationPoint1Builder(),
+ mapping);
}
}
OpenroadmTpType tpType, TerminationPoint1 otnTp1,
org.opendaylight.yang.gen.v1.http.transportpce.topology.rev220123.TerminationPoint1Builder tpceTp1Bldr,
Mapping mapping) {
+
switch (tpType) {
case XPONDERNETWORK:
if (node.getXpdrNetConnectionMap().get(tpId.getValue()) != null) {
.setNodeRef(new NodeId(node.getNodeId() + XPDR + node.getXpdrNb()))
.setTpRef(tpId)
.build();
- TerminationPoint ietfTpNw = buildIetfTp(tpceTp1Bldr, otnTp1, tpType, tpId, Map.of(stp.key(), stp),
- mapping);
+ TerminationPoint ietfTpNw =
+ buildIetfTp(tpceTp1Bldr, otnTp1, tpType, tpId, Map.of(stp.key(), stp), mapping);
tpMap.put(ietfTpNw.key(),ietfTpNw);
break;
case XPONDERCLIENT:
}
private static Class<? extends OduRateIdentity> fixRate(List<Class<? extends SupportedIfCapability>> list) {
- Map<String, Class<? extends OduRateIdentity>> rateMap = Map.of(
- "If100GEODU4", ODU4.class,
- "IfOCHOTU4ODU4", ODU4.class,
- "If1GEODU0", ODU0.class,
- "If10GEODU2", ODU2.class,
- "If10GEODU2e", ODU2e.class);
+
for (Class<? extends SupportedIfCapability> class1 : list) {
- if (rateMap.containsKey(class1.getSimpleName())) {
- return rateMap.get(class1.getSimpleName());
+ if (RATE_MAP.containsKey(class1.getSimpleName())) {
+ return RATE_MAP.get(class1.getSimpleName());
}
}
return null;
}
private static Map<SupportingNodeKey,SupportingNode> createSupportingNodes(OtnTopoNode node) {
+
SupportingNode suppNode1 = new SupportingNodeBuilder()
.setNetworkRef(new NetworkId(NetworkUtils.UNDERLAY_NETWORK_ID))
.setNodeRef(new NodeId(node.getNodeId()))
- .withKey(new SupportingNodeKey(new NetworkId(NetworkUtils.UNDERLAY_NETWORK_ID),
- new NodeId(node.getNodeId())))
+ .withKey(
+ new SupportingNodeKey(
+ new NetworkId(NetworkUtils.UNDERLAY_NETWORK_ID),
+ new NodeId(node.getNodeId())))
.build();
SupportingNode suppNode2 = new SupportingNodeBuilder()
.setNetworkRef(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID))
.setNodeRef(new NodeId(node.getNodeId() + XPDR + node.getXpdrNb()))
- .withKey(new SupportingNodeKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID),
- new NodeId(node.getNodeId() + XPDR + node.getXpdrNb())))
+ .withKey(
+ new SupportingNodeKey(
+ new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID),
+ new NodeId(node.getNodeId() + XPDR + node.getXpdrNb())))
.build();
SupportingNode suppNode3 = new SupportingNodeBuilder()
.setNetworkRef(new NetworkId(NetworkUtils.CLLI_NETWORK_ID))
.setNodeRef(new NodeId(node.getClli()))
- .withKey(new SupportingNodeKey(new NetworkId(NetworkUtils.CLLI_NETWORK_ID),
- new NodeId(node.getClli())))
+ .withKey(
+ new SupportingNodeKey(
+ new NetworkId(NetworkUtils.CLLI_NETWORK_ID),
+ new NodeId(node.getClli())))
.build();
Map<SupportingNodeKey,SupportingNode> suppNodeMap = new HashMap<>();
suppNodeMap.put(suppNode1.key(),suppNode1);
}
private static TerminationPoint buildIetfTp(
- org.opendaylight.yang.gen.v1.http.transportpce.topology.rev220123.TerminationPoint1Builder tpceTp1Bldr,
- TerminationPoint1 otnTp1, OpenroadmTpType tpType, TpId tpId,
- Map<SupportingTerminationPointKey, SupportingTerminationPoint> supportTpMap, Mapping mapping) {
+ org.opendaylight.yang.gen.v1.http.transportpce.topology.rev220123.TerminationPoint1Builder tpceTp1Bldr,
+ TerminationPoint1 otnTp1, OpenroadmTpType tpType, TpId tpId,
+ Map<SupportingTerminationPointKey, SupportingTerminationPoint> supportTpMap, Mapping mapping) {
TerminationPointBuilder ietfTpBldr = new TerminationPointBuilder();
if (tpceTp1Bldr.getAssociatedConnectionMapPort() != null) {
if (supportTpMap != null) {
ietfTpBldr.setSupportingTerminationPoint(supportTpMap);
}
- org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.TerminationPoint1 ocnTp =
- new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.TerminationPoint1Builder()
+ return ietfTpBldr
+ .setTpId(tpId)
+ .withKey(new TerminationPointKey(tpId))
+ .addAugmentation(otnTp1)
+ .addAugmentation(
+ new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.TerminationPoint1Builder()
.setTpType(tpType)
.setAdministrativeState(TopologyUtils.setNetworkAdminState(mapping.getPortAdminState()))
.setOperationalState(TopologyUtils.setNetworkOperState(mapping.getPortOperState()))
- .build();
-
- return ietfTpBldr.setTpId(tpId)
- .withKey(new TerminationPointKey(tpId))
- .addAugmentation(otnTp1)
- .addAugmentation(ocnTp)
- .build();
+ .build())
+ .build();
}
private static String formatNodeName(String nodeName, String tpName) {
+
return nodeName.contains(XPDR)
? nodeName
: new StringBuilder(nodeName).append("-").append(tpName.split("-")[0]).toString();
<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>8.0.7</version>
+ <version>8.0.11</version>
<relativePath/>
</parent>
private static final BigDecimal DEFAULT_TPDR_PWR_100G = new BigDecimal(-5);
private static final BigDecimal DEFAULT_TPDR_PWR_400G = new BigDecimal(0);
private static final String INTERFACE_NOT_PRESENT = "Interface {} on node {} is not present!";
+ private static final double MC_WIDTH_GRAN = 2 * GridConstant.GRANULARITY;
private long timer1 = 120000;
// openroadm spec value is 120000, functest value is 3000
destTpId, nodeId, openroadmVersion.getIntValue());
LOG.info("Spanloss TX is {}", spanLossTx);
- if (spanLossTx == null || spanLossTx.intValue() <= 0 || spanLossTx.intValue() > 28) {
- LOG.error("Power Value is null: spanLossTx null or out of openROADM range ]0,28] {}",
- spanLossTx);
+ // TODO: The span-loss limits should be obtained from optical specifications
+ if (spanLossTx == null || spanLossTx.intValue() <= 0 || spanLossTx.intValue() > 27) {
+ LOG.error("Power Value is null: spanLossTx null or out of openROADM range ]0,27] {}",
+ spanLossTx);
return false;
}
BigDecimal powerValue = getRdmPowerValue(spanLossTx, input);
private BigDecimal getRdmPowerValue(BigDecimal spanLossTx, ServicePowerSetupInput input) {
- BigDecimal powerValue = spanLossTx.subtract(BigDecimal.valueOf(9)).min(BigDecimal.valueOf(2));
+ // TODO: These values will be obtained from the specifications
+ // power-value here refers to the Pin[50GHz]
+ BigDecimal powerValue;
+ if (spanLossTx.doubleValue() >= 23.0) {
+ powerValue = BigDecimal.valueOf(2.0);
+ } else if (spanLossTx.doubleValue() >= 8.0) {
+ powerValue = BigDecimal.valueOf(- (8.0 - spanLossTx.doubleValue()) / 3.0 - 3.0);
+ } else if (spanLossTx.doubleValue() >= 6.0) {
+ powerValue = BigDecimal.valueOf(-3.0);
+ } else {
+ powerValue = spanLossTx.subtract(BigDecimal.valueOf(9));
+ }
+ // target-output-power yang precision is 2, so we limit here to 2
+ powerValue = powerValue.setScale(2, RoundingMode.CEILING);
+ LOG.info("P1[50GHz]={} dBm for spanloss {} based on OpenROADM-5.0 specs power target mask", powerValue,
+ spanLossTx);
// we work at constant power spectral density (50 GHz channel width @-20dBm=37.5GHz)
// 87.5 GHz channel width @-20dBm=75GHz
if (input.getMcWidth() != null) {
- LOG.debug("Input Gridsize is {}",input.getMcWidth().getValue());
- if (input.getMcWidth().getValue().equals(GridConstant.WIDTH_80)) {
- powerValue = powerValue.add(BigDecimal.valueOf(3));
- } else if (input.getMcWidth().getValue().equals(GridConstant.SLOT_WIDTH_87_5)) {
- BigDecimal logVal = GridConstant.SLOT_WIDTH_87_5.divide(new BigDecimal(50));
- double pdsVal = 10 * Math.log10(logVal.doubleValue());
- powerValue = powerValue.add(new BigDecimal(pdsVal, new MathContext(3, RoundingMode.HALF_EVEN)));
- }
+ // Units of MC-wdith are in GHz, meaning it should be 40/50/87.5GHz
+ // TODO: Should we validate this units before proceeding?
+ LOG.debug("Input Grid size is {}",input.getMcWidth().getValue());
+
+ // We round-off the mc-width to the nearest grid-value based on the granularity of 12.5 GHz
+ double nbrMcSlots = Math.ceil(input.getMcWidth().getValue().doubleValue() / MC_WIDTH_GRAN);
+ LOG.debug("Nearest (ceil) number of slots {}", nbrMcSlots);
+ BigDecimal mcWidth = new BigDecimal(MC_WIDTH_GRAN * nbrMcSlots);
+ LOG.info("Given mc-width={}, Rounded mc-width={}", input.getMcWidth().getValue(), mcWidth);
+
+ BigDecimal logVal = mcWidth.divide(new BigDecimal(50));
+ double pdsVal = 10 * Math.log10(logVal.doubleValue());
+ // Addition of PSD value will give Pin[87.5 GHz]
+ powerValue = powerValue.add(new BigDecimal(pdsVal, new MathContext(3,
+ RoundingMode.HALF_EVEN)));
+ LOG.info("P1[{}GHz]={} dB will be used for OSNR calculation", mcWidth, powerValue);
}
// FIXME compliancy with OpenROADM MSA and approximations used -- should be addressed with powermask update
// cf JIRA ticket https://jira.opendaylight.org/browse/TRNSPRTPCE-494
- LOG.info("Power Value is {}", powerValue);
+ LOG.info("The power value is {} for spanloss {}", powerValue, spanLossTx);
return powerValue;
}
this.openRoadmInterfacesImpl121 = new OpenRoadmInterfacesImpl121(deviceTransactionManager);
this.openRoadmInterfacesImpl22 = new OpenRoadmInterfacesImpl221(deviceTransactionManager, this.portMapping,
this.portMappingVersion22);
- this.openRoadmInterfacesImpl710 = new OpenRoadmInterfacesImpl710(deviceTransactionManager);
+ this.openRoadmInterfacesImpl710 = new OpenRoadmInterfacesImpl710(deviceTransactionManager, this.portMapping,
+ this.portMappingVersion710);
this.openRoadmInterfaces = new OpenRoadmInterfacesImpl((this.deviceTransactionManager),
this.mappingUtils,this.openRoadmInterfacesImpl121,this.openRoadmInterfacesImpl22,
this.openRoadmInterfacesImpl710);
this.openRoadmInterfacesImpl121 = new OpenRoadmInterfacesImpl121(deviceTransactionManager);
this.openRoadmInterfacesImpl22 = new OpenRoadmInterfacesImpl221(deviceTransactionManager, this.portMapping,
this.portMappingVersion22);
- this.openRoadmInterfacesImpl710 = new OpenRoadmInterfacesImpl710(deviceTransactionManager);
+ this.openRoadmInterfacesImpl710 = new OpenRoadmInterfacesImpl710(deviceTransactionManager, this.portMapping,
+ this.portMappingVersion710);
this.openRoadmInterfaces = new OpenRoadmInterfacesImpl((this.deviceTransactionManager),
this.mappingUtils,this.openRoadmInterfacesImpl121,this.openRoadmInterfacesImpl22,
this.openRoadmInterfacesImpl710);
this.openRoadmInterfacesImpl121 = new OpenRoadmInterfacesImpl121(deviceTransactionManager);
this.openRoadmInterfacesImpl22 = new OpenRoadmInterfacesImpl221(deviceTransactionManager, this.portMapping,
this.portMappingVersion22);
- this.openRoadmInterfacesImpl710 = new OpenRoadmInterfacesImpl710(deviceTransactionManager);
+ this.openRoadmInterfacesImpl710 = new OpenRoadmInterfacesImpl710(deviceTransactionManager, this.portMapping,
+ this.portMappingVersion710);
this.openRoadmInterfaces = new OpenRoadmInterfacesImpl((this.deviceTransactionManager),
this.mappingUtils,this.openRoadmInterfacesImpl121,this.openRoadmInterfacesImpl22,
this.openRoadmInterfacesImpl710);
this.openRoadmInterfacesImpl121 = new OpenRoadmInterfacesImpl121(deviceTransactionManager);
this.openRoadmInterfacesImpl22 = new OpenRoadmInterfacesImpl221(deviceTransactionManager, this.portMapping,
this.portMappingVersion22);
- this.openRoadmInterfacesImpl710 = new OpenRoadmInterfacesImpl710(deviceTransactionManager);
+ this.openRoadmInterfacesImpl710 = new OpenRoadmInterfacesImpl710(deviceTransactionManager, this.portMapping,
+ this.portMappingVersion710);
this.openRoadmInterfaces = new OpenRoadmInterfacesImpl((this.deviceTransactionManager),
this.mappingUtils,this.openRoadmInterfacesImpl121,this.openRoadmInterfacesImpl22,
this.openRoadmInterfacesImpl710);
<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>8.0.7</version>
+ <version>8.0.11</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>8.0.7</version>
+ <version>8.0.11</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.netconf</groupId>
<artifactId>netconf-artifacts</artifactId>
- <version>2.0.11</version>
+ <version>2.0.14</version>
<scope>import</scope>
<type>pom</type>
</dependency>
<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>8.0.7</version>
+ <version>8.0.11</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>8.0.7</version>
+ <version>8.0.11</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>8.0.7</version>
+ <version>8.0.11</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>8.0.7</version>
+ <version>8.0.11</version>
<relativePath />
</parent>
if (validateNodeConstraints(pceNode).equals(ConstraintTypes.HARD_EXCLUDE)) {
return;
}
- if (endPceNode(nodeType, pceNode.getNodeId(), pceNode) && this.aendPceNode == null
- && isAZendPceNode(this.serviceFormatA, pceNode, anodeId, "A")) {
- this.aendPceNode = pceNode;
- }
- if (endPceNode(nodeType, pceNode.getNodeId(), pceNode) && this.zendPceNode == null
- && isAZendPceNode(this.serviceFormatZ, pceNode, znodeId, "Z")) {
- this.zendPceNode = pceNode;
+
+ if (endPceNode(nodeType, pceNode.getNodeId(), pceNode)) {
+ if (this.aendPceNode == null && isAZendPceNode(this.serviceFormatA, pceNode, anodeId, "A")) {
+ // Added to ensure A-node has a addlink in the topology
+ List<Link> links = this.allLinks.stream()
+ .filter(x -> x.getSource().getSourceNode().getValue().contains(pceNode.getNodeId().getValue()))
+ .collect(Collectors.toList());
+ if (links.size() > 0) {
+ this.aendPceNode = pceNode;
+ }
+ }
+ if (this.zendPceNode == null && isAZendPceNode(this.serviceFormatZ, pceNode, znodeId, "Z")) {
+ // Added to ensure Z-node has a droplink in the topology
+ List<Link> links = this.allLinks.stream()
+ .filter(x -> x.getDestination().getDestNode().getValue().contains(pceNode.getNodeId().getValue()))
+ .collect(Collectors.toList());
+ if (links.size() > 0) {
+ this.zendPceNode = pceNode;
+ }
+ }
}
allPceNodes.put(pceNode.getNodeId(), pceNode);
}
OpenroadmNodeType nodeType = node.augmentation(Node1.class).getNodeType();
-
- PceOtnNode pceOtnNode = new PceOtnNode(node, nodeType, node.getNodeId(), "otn", serviceType);
+ String clientPort = null;
+ if (node.getNodeId().getValue().equals(anodeId)
+ && this.aendPceNode == null
+ && input.getServiceAEnd() != null
+ && input.getServiceAEnd().getRxDirection() != null
+ && input.getServiceAEnd().getRxDirection().getPort() != null
+ && input.getServiceAEnd().getRxDirection().getPort().getPortName() != null) {
+ clientPort = input.getServiceAEnd().getRxDirection().getPort().getPortName();
+ } else if (node.getNodeId().getValue().equals(znodeId)
+ && this.zendPceNode == null
+ && input.getServiceZEnd() != null
+ && input.getServiceZEnd().getRxDirection() != null
+ && input.getServiceZEnd().getRxDirection().getPort() != null
+ && input.getServiceZEnd().getRxDirection().getPort().getPortName() != null) {
+ clientPort = input.getServiceZEnd().getRxDirection().getPort().getPortName();
+ }
+
+ PceOtnNode pceOtnNode = new PceOtnNode(node, nodeType, node.getNodeId(), "otn", serviceType, clientPort);
pceOtnNode.validateXponder(anodeId, znodeId);
if (!pceOtnNode.isValid()) {
pcelink.getlinkType(), pcelink);
break;
case ADDLINK:
- pcelink.setClient(source.getRdmSrgClient(pcelink.getSourceTP().getValue()));
+ pcelink.setClient(
+ source.getRdmSrgClient(pcelink.getSourceTP().getValue(), StringConstants.SERVICE_DIRECTION_AZ));
addLinks.add(pcelink);
LOG.debug("validateLink: ADD-LINK saved {}", pcelink);
break;
case DROPLINK:
- pcelink.setClient(dest.getRdmSrgClient(pcelink.getDestTP().getValue()));
+ pcelink.setClient(
+ dest.getRdmSrgClient(pcelink.getDestTP().getValue(), StringConstants.SERVICE_DIRECTION_ZA));
dropLinks.add(pcelink);
LOG.debug("validateLink: DROP-LINK saved {}", pcelink);
break;
void addOutgoingLink(PceLink outLink);
- String getRdmSrgClient(String tp);
+ String getRdmSrgClient(String tp, String direction);
String getXpdrClient(String tp);
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.IfOCHOTU4ODU4;
import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev200327.IfOtsiOtsigroup;
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;
case "100GE":
if (mapping.getSupportedInterfaceCapability().contains(
org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev181019.IfOCH.class)
- || mapping.getSupportedInterfaceCapability().contains(IfOCH.class)) {
+ || mapping.getSupportedInterfaceCapability().contains(IfOCH.class)
+ || mapping.getSupportedInterfaceCapability().contains(IfOCHOTU4ODU4.class)) {
return true;
} else {
return false;
}
@Override
- public String getRdmSrgClient(String tp) {
+ public String getRdmSrgClient(String tp, String direction) {
LOG.info("getRdmSrgClient: Getting PP client for tp '{}' on node : {}", tp, this.nodeId);
OpenroadmTpType srgType = null;
OpenroadmTpType cpType = this.availableSrgCp.get(tp);
switch (cpType) {
case SRGTXRXCP:
LOG.info("getRdmSrgClient: Getting BI Directional PP port ...");
- srgType = OpenroadmTpType.SRGTXRXPP;
+ // Take the first-element in the available PP key set
+ if (availableSrgPp.entrySet().iterator().next().getKey()
+ // and check if the port is bidirectional
+ .contains("TXRX")) {
+ srgType = OpenroadmTpType.SRGTXRXPP;
+ } else if (direction.equalsIgnoreCase("aToz")) {
+ srgType = OpenroadmTpType.SRGRXPP;
+ } else {
+ srgType = OpenroadmTpType.SRGTXPP;
+ }
break;
case SRGTXCP:
LOG.info("getRdmSrgClient: Getting UNI Rx PP port ...");
import java.util.Map;
import java.util.TreeMap;
import java.util.stream.Collectors;
-import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.transportpce.common.StringConstants;
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.otn.network.topology.rev200529.Node1;
import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.TerminationPoint1;
import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.networks.network.node.SwitchingPools;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.networks.network.node.termination.point.XpdrTpPortConnectionAttributes;
import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev200327.If100GEODU4;
import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev200327.If10GEODU2e;
import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev200327.If1GEODU0;
import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev200327.IfOCHOTU4ODU4;
import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev200327.IfOtsiOtsigroup;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev200327.SupportedIfCapability;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.xponder.rev200529.xpdr.otn.tp.attributes.OdtuTpnPool;
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;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.TpId;
import org.slf4j.LoggerFactory;
public class PceOtnNode implements PceNode {
- /* Logging. */
- private static final Logger LOG = LoggerFactory.getLogger(PceOtnNode.class);
////////////////////////// OTN NODES ///////////////////////////
/*
* For This Class the node passed shall be at the otn-openroadm Layer
*/
+ private static final Logger LOG = LoggerFactory.getLogger(PceOtnNode.class);
+ private static final List<String> SERVICE_TYPE_ODU_LIST = List.of(
+ StringConstants.SERVICE_TYPE_ODU4,
+ StringConstants.SERVICE_TYPE_ODUC4,
+ StringConstants.SERVICE_TYPE_ODUC3,
+ StringConstants.SERVICE_TYPE_ODUC2);
+ private static final List<OpenroadmNodeType> VALID_NODETYPES_LIST = List.of(
+ OpenroadmNodeType.MUXPDR,
+ OpenroadmNodeType.SWITCH,
+ OpenroadmNodeType.TPDR);
+ private static final Map<String, Class<? extends SupportedIfCapability>> SERVICE_TYPE_ETH_CLASS_MAP = Map.of(
+ StringConstants.SERVICE_TYPE_1GE, If1GEODU0.class,
+ StringConstants.SERVICE_TYPE_10GE, If10GEODU2e.class,
+ StringConstants.SERVICE_TYPE_100GE_M, If100GEODU4.class,
+ StringConstants.SERVICE_TYPE_100GE_S, If100GEODU4.class);
+ private static final Map<String, Integer> SERVICE_TYPE_ETH_TS_NB_MAP = Map.of(
+ StringConstants.SERVICE_TYPE_1GE, 1,
+ StringConstants.SERVICE_TYPE_10GE, 10,
+ StringConstants.SERVICE_TYPE_100GE_M, 20);
+ private static final Map<String, String> SERVICE_TYPE_ETH_ODU_STRING_MAP = Map.of(
+ StringConstants.SERVICE_TYPE_1GE, "ODU0",
+ StringConstants.SERVICE_TYPE_10GE, "ODU2e",
+ StringConstants.SERVICE_TYPE_100GE_M, "ODU4");
+
private boolean valid = true;
private final Node node;
private List<PceLink> outgoingLinks = new ArrayList<>();
private Map<String, String> clientPerNwTp = new HashMap<>();
+ private String clientPort;
- public PceOtnNode(Node node, OpenroadmNodeType nodeType, NodeId nodeId, String pceNodeType, String serviceType) {
+ public PceOtnNode(Node node, OpenroadmNodeType nodeType, NodeId nodeId, String pceNodeType, String serviceType,
+ String clientPort) {
this.node = node;
this.nodeId = nodeId;
this.nodeType = nodeType;
this.usedXpdrClientTps.clear();
this.availableXpdrClientTps = new ArrayList<>();
this.usableXpdrClientTps = new ArrayList<>();
- this.adminStates = node.augmentation(org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529
- .Node1.class).getAdministrativeState();
- this.state = node.augmentation(org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529
- .Node1.class).getOperationalState();
+ this.adminStates = node
+ .augmentation(org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Node1.class)
+ .getAdministrativeState();
+ this.state = node
+ .augmentation(org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Node1.class)
+ .getOperationalState();
this.tpAvailableTribPort.clear();
checkAvailableTribPort();
this.tpAvailableTribSlot.clear();
checkAvailableTribSlot();
- if ((node == null) || (nodeId == null) || (nodeType != OpenroadmNodeType.MUXPDR)
- && (nodeType != OpenroadmNodeType.SWITCH) && (nodeType != OpenroadmNodeType.TPDR)) {
+ this.clientPort = clientPort;
+ if (node == null || nodeId == null || nodeType == null || !VALID_NODETYPES_LIST.contains(nodeType)) {
LOG.error("PceOtnNode: one of parameters is not populated : nodeId, node type");
this.valid = false;
}
+ if (!SERVICE_TYPE_ETH_CLASS_MAP.containsKey(serviceType)
+ && !SERVICE_TYPE_ODU_LIST.contains(serviceType)) {
+ LOG.error("PceOtnNode: unsupported OTN Service Type {}", serviceType);
+ this.valid = false;
+ }
}
public void initXndrTps(String mode) {
LOG.info("PceOtnNode: initXndrTps for node {}", this.nodeId.getValue());
this.availableXponderTp.clear();
-
this.modeType = mode;
-
- org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1 nodeTp
- = this.node.augmentation(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
- .ietf.network.topology.rev180226.Node1.class);
- List<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network
- .node.TerminationPoint> allTps = new ArrayList<>(nodeTp.nonnullTerminationPoint().values());
+ List<TerminationPoint> allTps =
+ new ArrayList<>(
+ this.node.augmentation(
+ org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
+ .Node1.class)
+ .nonnullTerminationPoint()
+ .values());
this.valid = false;
if (allTps.isEmpty()) {
LOG.error("PceOtnNode: initXndrTps: XPONDER TerminationPoint list is empty for node {}", this);
return;
}
-
- for (org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network
- .node.TerminationPoint tp : allTps) {
- org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.@Nullable TerminationPoint1 ocnTp1
+ for (TerminationPoint tp : allTps) {
+ org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.TerminationPoint1 ocnTp1
= tp.augmentation(org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529
- .TerminationPoint1.class);
- //TODO many nested if-structures below, this needs to be reworked
- if (OpenroadmTpType.XPONDERNETWORK.equals(ocnTp1.getTpType())) {
- TerminationPoint1 ontTp1;
- if (tp.augmentation(TerminationPoint1.class) != null) {
- ontTp1 = tp.augmentation(TerminationPoint1.class);
- } else {
- continue;
- }
- switch (this.otnServiceType) {
- case StringConstants.SERVICE_TYPE_100GE_S:
- // TODO verify the capability of network port to support ODU4 CTP interface creation
- case StringConstants.SERVICE_TYPE_ODU4:
- case StringConstants.SERVICE_TYPE_ODUC2:
- case StringConstants.SERVICE_TYPE_ODUC3:
- case StringConstants.SERVICE_TYPE_ODUC4:
+ .TerminationPoint1.class);
+ if (ocnTp1 == null) {
+ LOG.warn("null ocn TP {}", tp);
+ continue;
+ }
+ //TODO many nested structures below, this needs to be reworked
+ switch (ocnTp1.getTpType()) {
+ case XPONDERNETWORK:
+ if (tp.augmentation(TerminationPoint1.class) == null) {
+ continue;
+ }
+ TerminationPoint1 ontTp1 = tp.augmentation(TerminationPoint1.class);
+ if (SERVICE_TYPE_ODU_LIST.contains(this.otnServiceType)
+ || StringConstants.SERVICE_TYPE_100GE_S.equals(this.otnServiceType)) {
+ // TODO verify the capability of network port to support ODU4 CTP interface creation
if (!checkTpForOdtuTermination(ontTp1)) {
LOG.error("TP {} of {} does not allow ODU4 termination creation",
tp.getTpId().getValue(), node.getNodeId().getValue());
continue;
}
- break;
-
- case StringConstants.SERVICE_TYPE_10GE:
- if (!checkOdtuTTPforLoOduCreation(ontTp1, 10)) {
- LOG.error("TP {} of {} does not allow OD2e termination creation",
- tp.getTpId().getValue(), node.getNodeId().getValue());
+ } else if (SERVICE_TYPE_ETH_TS_NB_MAP.containsKey(this.otnServiceType)) {
+ if (!checkOdtuTTPforLoOduCreation(
+ ontTp1, SERVICE_TYPE_ETH_TS_NB_MAP.get(this.otnServiceType))) {
+ LOG.error("TP {} of {} does not allow {} termination creation",
+ tp.getTpId().getValue(),
+ SERVICE_TYPE_ETH_ODU_STRING_MAP.get(this.otnServiceType),
+ node.getNodeId().getValue());
continue;
}
- break;
- case StringConstants.SERVICE_TYPE_100GE_M:
- if (!checkOdtuTTPforLoOduCreation(ontTp1, 20)) {
- LOG.error("TP {} of {} does not allow ODU4 termination creation",
- tp.getTpId().getValue(), node.getNodeId().getValue());
+ } else {
+ LOG.error("TP {} of {} does not allow any termination creation",
+ tp.getTpId().getValue(), node.getNodeId().getValue());
+ continue;
+ }
+ LOG.info("TP {} of XPONDER {} is validated", tp.getTpId(), node.getNodeId().getValue());
+ this.availableXpdrNWTps.add(tp.getTpId());
+ break;
+
+ case XPONDERCLIENT:
+ if (SERVICE_TYPE_ETH_CLASS_MAP.containsKey(otnServiceType)) {
+ if (tp.augmentation(TerminationPoint1.class) == null) {
continue;
}
- break;
- case StringConstants.SERVICE_TYPE_1GE:
- if (!checkOdtuTTPforLoOduCreation(ontTp1, 1)) {
- LOG.error("TP {} of {} does not allow ODU0 termination creation",
+ if (checkClientTp(tp.augmentation(TerminationPoint1.class))) {
+ LOG.info("TP {} of XPONDER {} is validated", tp.getTpId(), node.getNodeId().getValue());
+ this.availableXpdrClientTps.add(tp.getTpId());
+ } else {
+ LOG.error("TP {} of {} does not allow lo-ODU (ODU2e or ODU0) termination creation",
tp.getTpId().getValue(), node.getNodeId().getValue());
- continue;
}
- break;
+ }
+ break;
- default:
- LOG.error("TP {} of {} does not allow any termination creation",
- tp.getTpId().getValue(), node.getNodeId().getValue());
- continue;
- }
- LOG.info("TP {} of XPONDER {} is validated", tp.getTpId(), node.getNodeId().getValue());
- this.availableXpdrNWTps.add(tp.getTpId());
- } else if (OpenroadmTpType.XPONDERCLIENT.equals(ocnTp1.getTpType())
- && (StringConstants.SERVICE_TYPE_10GE.equals(this.otnServiceType)
- || StringConstants.SERVICE_TYPE_100GE_M.equals(this.otnServiceType)
- || StringConstants.SERVICE_TYPE_100GE_S.equals(this.otnServiceType)
- || StringConstants.SERVICE_TYPE_1GE.equals(this.otnServiceType))) {
- TerminationPoint1 ontTp1;
- if (tp.augmentation(TerminationPoint1.class) != null) {
- ontTp1 = tp.augmentation(TerminationPoint1.class);
- } else {
- continue;
- }
- if (checkClientTp(ontTp1)) {
- LOG.info("TP {} of XPONDER {} is validated", tp.getTpId(), node.getNodeId().getValue());
- this.availableXpdrClientTps.add(tp.getTpId());
- } else {
- LOG.error("TP {} of {} does not allow lo-ODU (ODU2e or ODU0) termination creation",
- tp.getTpId().getValue(), node.getNodeId().getValue());
- }
+ default:
+ LOG.debug("unsupported ocn TP type {}", ocnTp1.getTpType());
}
}
+ this.valid = SERVICE_TYPE_ODU_LIST.contains(this.otnServiceType)
+ || SERVICE_TYPE_ETH_CLASS_MAP.containsKey(this.otnServiceType)
+ && checkSwPool(availableXpdrNWTps, availableXpdrClientTps);
+ }
- if ((StringConstants.SERVICE_TYPE_ODU4.equals(this.otnServiceType)
- || StringConstants.SERVICE_TYPE_ODUC4.equals(this.otnServiceType)
- || StringConstants.SERVICE_TYPE_ODUC3.equals(this.otnServiceType)
- || StringConstants.SERVICE_TYPE_ODUC2.equals(this.otnServiceType))
- || ((StringConstants.SERVICE_TYPE_10GE.equals(this.otnServiceType)
- || StringConstants.SERVICE_TYPE_100GE_M.equals(this.otnServiceType)
- || StringConstants.SERVICE_TYPE_1GE.equals(this.otnServiceType))
- && ((mode.equals("AZ") && checkSwPool(availableXpdrClientTps, availableXpdrNWTps, 1, 1))
- || (mode.equals("intermediate") && checkSwPool(null, availableXpdrNWTps, 0, 2)))
- )
- || (StringConstants.SERVICE_TYPE_100GE_S.equals(this.otnServiceType)
- && (mode.equals("AZ") && checkSwPool(availableXpdrClientTps, availableXpdrNWTps, 1, 1)))
- || (StringConstants.SERVICE_TYPE_100GE_S.equals(this.otnServiceType)
- && (mode.equals("intermediate") && checkSwPool(availableXpdrClientTps, availableXpdrNWTps, 0, 2)))
- ) {
- this.valid = true;
- } else {
- this.valid = false;
+ private boolean checkSwPool(List<TpId> netwTps, List<TpId> clientTps) {
+
+ if (netwTps == null) {
+ return false;
}
- }
+ Node1 node1 = node.augmentation(Node1.class);
+ if (node1 == null) {
+ return false;
+ }
+ List<NonBlockingList> nblList = new ArrayList<>(
+ node1.getSwitchingPools().nonnullOduSwitchingPools()
+ .values().stream().findFirst().get()
+ .getNonBlockingList().values());
+ if (nblList == null) {
+ return false;
+ }
+ netwTps.sort(Comparator.comparing(TpId::getValue));
+
+ switch (modeType) {
- private boolean checkSwPool(List<TpId> clientTps, List<TpId> netwTps, int nbClient, int nbNetw) {
- if (clientTps != null && netwTps != null && nbClient == 1 && nbNetw == 1) {
- clientTps.sort(Comparator.comparing(TpId::getValue));
- netwTps.sort(Comparator.comparing(TpId::getValue));
- for (TpId nwTp : netwTps) {
- for (TpId clTp : clientTps) {
- @Nullable
- List<NonBlockingList> nblList = new ArrayList<>(node.augmentation(Node1.class).getSwitchingPools()
- .nonnullOduSwitchingPools().values().stream().findFirst().get().getNonBlockingList().values());
- for (NonBlockingList nbl : nblList) {
- if (nbl.getTpList().contains(clTp) && nbl.getTpList().contains(nwTp)) {
- usableXpdrClientTps.add(clTp);
+ case "intermediate":
+ for (NonBlockingList nbl: nblList) {
+ for (TpId nwTp : netwTps) {
+ if (nbl.getTpList().contains(nwTp)) {
usableXpdrNWTps.add(nwTp);
}
- if (usableXpdrClientTps.size() >= nbClient && usableXpdrNWTps.size() >= nbNetw) {
- clientPerNwTp.put(nwTp.getValue(), clTp.getValue());
+ if (usableXpdrNWTps.size() >= 2) {
return true;
}
}
}
- }
+ return false;
- }
- if (netwTps != null && nbClient == 0 && nbNetw == 2) {
- netwTps.sort(Comparator.comparing(TpId::getValue));
- @Nullable
- List<NonBlockingList> nblList = new ArrayList<>(node.augmentation(Node1.class).getSwitchingPools()
- .nonnullOduSwitchingPools().values().stream().findFirst().get().getNonBlockingList().values());
- for (NonBlockingList nbl : nblList) {
- for (TpId nwTp : netwTps) {
- if (nbl.getTpList().contains(nwTp)) {
- usableXpdrNWTps.add(nwTp);
- }
- if (usableXpdrNWTps.size() >= nbNetw) {
- return true;
+ case "AZ":
+ if (clientTps == null) {
+ return false;
+ }
+ clientTps.sort(Comparator.comparing(TpId::getValue));
+ for (NonBlockingList nbl: nblList) {
+ for (TpId nwTp : netwTps) {
+ for (TpId clTp : clientTps) {
+ if (nbl.getTpList().contains(clTp) && nbl.getTpList().contains(nwTp)) {
+ usableXpdrClientTps.add(clTp);
+ usableXpdrNWTps.add(nwTp);
+ }
+ if (usableXpdrClientTps.size() >= 1 && usableXpdrNWTps.size() >= 1
+ && (this.clientPort == null || this.clientPort.equals(clTp.getValue()))) {
+ clientPerNwTp.put(nwTp.getValue(), clTp.getValue());
+ return true;
+ }
+ }
}
}
- }
+ return false;
+
+ default:
+ LOG.error("Unsupported mode type {}", modeType);
+ return false;
}
- return false;
}
private boolean checkTpForOdtuTermination(TerminationPoint1 ontTp1) {
}
private boolean checkOdtuTTPforLoOduCreation(TerminationPoint1 ontTp1, int tsNb) {
- return (ontTp1.getXpdrTpPortConnectionAttributes() != null
- && ontTp1.getXpdrTpPortConnectionAttributes().getTsPool() != null
- && ontTp1.getXpdrTpPortConnectionAttributes().getOdtuTpnPool() != null
- && (ontTp1.getXpdrTpPortConnectionAttributes().getOdtuTpnPool().values()
- .stream().findFirst().get().getOdtuType()
- .equals(ODTU4TsAllocated.class)
- ||
- ontTp1.getXpdrTpPortConnectionAttributes().getOdtuTpnPool().values()
- .stream().findFirst().get().getOdtuType()
- .equals(ODTUCnTs.class))
- && !ontTp1.getXpdrTpPortConnectionAttributes().getOdtuTpnPool().values()
- .stream().findFirst().get().getTpnPool().isEmpty()
- && (ontTp1.getXpdrTpPortConnectionAttributes().getTsPool().size() >= tsNb));
+ XpdrTpPortConnectionAttributes portConAttr = ontTp1.getXpdrTpPortConnectionAttributes();
+ if (portConAttr == null
+ || portConAttr.getTsPool() == null
+ || portConAttr.getTsPool().size() < tsNb
+ || portConAttr.getOdtuTpnPool() == null) {
+ return false;
+ }
+ return checkFirstOdtuTpn(portConAttr.getOdtuTpnPool().values().stream().findFirst().get());
+ }
+
+ private boolean checkFirstOdtuTpn(OdtuTpnPool otPool) {
+ return (otPool.getOdtuType().equals(ODTU4TsAllocated.class)
+ || otPool.getOdtuType().equals(ODTUCnTs.class))
+ && !otPool.getTpnPool().isEmpty();
}
private boolean checkClientTp(TerminationPoint1 ontTp1) {
for (SupportedInterfaceCapability sic : ontTp1.getTpSupportedInterfaces().getSupportedInterfaceCapability()
.values()) {
LOG.debug("in checkTpForOduTermination - sic = {}", sic.getIfCapType());
- switch (otnServiceType) {
- case StringConstants.SERVICE_TYPE_1GE:
- // we could also check the administrative status of the tp
- if (sic.getIfCapType().equals(If1GEODU0.class)) {
- return true;
- }
- break;
- case StringConstants.SERVICE_TYPE_10GE:
- if (sic.getIfCapType().equals(If10GEODU2e.class)) {
- return true;
- }
- break;
- case StringConstants.SERVICE_TYPE_100GE_T:
- case StringConstants.SERVICE_TYPE_100GE_M:
- case StringConstants.SERVICE_TYPE_100GE_S:
- if (sic.getIfCapType().equals(If100GEODU4.class)) {
- return true;
- }
- break;
- default:
- break;
+ // we could also check the administrative status of the tp
+ if (SERVICE_TYPE_ETH_CLASS_MAP.containsKey(otnServiceType)
+ && sic.getIfCapType().equals(SERVICE_TYPE_ETH_CLASS_MAP.get(otnServiceType))) {
+ return true;
}
}
return false;
}
}
- public boolean validateSwitchingPoolBandwidth(
- org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
- .ietf.network.topology.rev180226.networks.network.node.TerminationPoint tp1,
- org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
- .ietf.network.topology.rev180226.networks.network.node.TerminationPoint tp2,
- Long neededBW) {
+ public boolean validateSwitchingPoolBandwidth(TerminationPoint tp1, TerminationPoint tp2, Long neededBW) {
if (this.nodeType != OpenroadmNodeType.TPDR) {
return true;
}
- org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.Node1 node1 =
- node.augmentation(
- org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.Node1.class);
+ Node1 node1 = node.augmentation(Node1.class);
SwitchingPools sp = node1.getSwitchingPools();
List<OduSwitchingPools> osp = new ArrayList<>(sp.nonnullOduSwitchingPools().values());
for (OduSwitchingPools ospx : osp) {
}
}
}
-
LOG.debug("validateSwitchingPoolBandwidth: No valid Switching pool for crossconnecting tp {} and {}",
tp1.getTpId(), tp2.getTpId());
return false;
-
}
public void validateIntermediateSwitch() {
}
// Validate switch for use as an intermediate XPONDER on the path
initXndrTps("intermediate");
- if (!this.valid) {
- LOG.debug("validateIntermediateSwitch: Switch unusable for transit == {}", nodeId.getValue());
- } else {
+ if (this.valid) {
LOG.info("validateIntermediateSwitch: Switch usable for transit == {}", nodeId.getValue());
+ } else {
+ LOG.debug("validateIntermediateSwitch: Switch unusable for transit == {}", nodeId.getValue());
}
}
public void checkAvailableTribPort() {
- List<TerminationPoint> networkTpList = node.augmentation(
- org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1.class)
- .getTerminationPoint().values().stream()
- .filter(type -> type
- .augmentation(
- org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.TerminationPoint1.class)
- .getTpType().equals(OpenroadmTpType.XPONDERNETWORK))
- .collect(Collectors.toList());
-
- for (TerminationPoint tp : networkTpList) {
- if (tp.augmentation(TerminationPoint1.class).getXpdrTpPortConnectionAttributes() != null
- && tp.augmentation(TerminationPoint1.class).getXpdrTpPortConnectionAttributes().getOdtuTpnPool() != null
- && (tp.augmentation(TerminationPoint1.class).getXpdrTpPortConnectionAttributes().getOdtuTpnPool()
- .values().stream().findFirst().get().getOdtuType().equals(ODTU4TsAllocated.class)
- || tp.augmentation(TerminationPoint1.class).getXpdrTpPortConnectionAttributes().getOdtuTpnPool()
- .values().stream().findFirst().get().getOdtuType().equals(ODTUCnTs.class))) {
- @Nullable
- List<Uint16> tpnPool = tp.augmentation(TerminationPoint1.class).getXpdrTpPortConnectionAttributes()
- .getOdtuTpnPool().values().stream().findFirst().get().getTpnPool();
- if (tpnPool != null) {
- tpAvailableTribPort.put(tp.getTpId().getValue(), tpnPool);
+ for (TerminationPoint tp :
+ node.augmentation(
+ org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
+ .Node1.class)
+ .getTerminationPoint().values().stream()
+ .filter(type -> type
+ .augmentation(
+ org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529
+ .TerminationPoint1.class)
+ .getTpType()
+ .equals(OpenroadmTpType.XPONDERNETWORK))
+ .collect(Collectors.toList())) {
+ XpdrTpPortConnectionAttributes portConAttr =
+ tp.augmentation(TerminationPoint1.class).getXpdrTpPortConnectionAttributes();
+ if (portConAttr != null && portConAttr.getOdtuTpnPool() != null) {
+ OdtuTpnPool otPool = portConAttr.getOdtuTpnPool().values().stream().findFirst().get();
+ if (checkFirstOdtuTpn(otPool)) {
+ tpAvailableTribPort.put(tp.getTpId().getValue(), otPool.getTpnPool());
}
}
}
}
public void checkAvailableTribSlot() {
- List<TerminationPoint> networkTpList = node.augmentation(
- org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1.class)
+ for (TerminationPoint tp :
+ node.augmentation(
+ org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1.class)
.getTerminationPoint().values().stream()
.filter(type -> type
.augmentation(
org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.TerminationPoint1.class)
.getTpType().equals(OpenroadmTpType.XPONDERNETWORK))
- .collect(Collectors.toList());
-
- for (TerminationPoint tp : networkTpList) {
- if (tp.augmentation(TerminationPoint1.class).getXpdrTpPortConnectionAttributes() != null
- && tp.augmentation(TerminationPoint1.class).getXpdrTpPortConnectionAttributes().getTsPool() != null) {
- @Nullable
- List<Uint16> tsPool = tp.augmentation(TerminationPoint1.class).getXpdrTpPortConnectionAttributes()
- .getTsPool();
- tpAvailableTribSlot.put(tp.getTpId().getValue(), tsPool);
+ .collect(Collectors.toList())
+ ) {
+ XpdrTpPortConnectionAttributes portConAttr =
+ tp.augmentation(TerminationPoint1.class).getXpdrTpPortConnectionAttributes();
+ if (portConAttr != null && portConAttr.getTsPool() != null) {
+ tpAvailableTribSlot.put(tp.getTpId().getValue(), portConAttr.getTsPool());
}
}
}
public boolean isValid() {
- if ((node == null) || (nodeId == null) || (nodeType == null) || (this.getSupNetworkNodeId() == null)
- || (this.getSupClliNodeId() == null)) {
+ if (nodeId == null || nodeType == null
+ || this.getSupNetworkNodeId() == null || this.getSupClliNodeId() == null) {
LOG.error("PceNode: one of parameters is not populated : nodeId, node type, supporting nodeId");
valid = false;
}
return valid;
}
- public boolean isPceOtnNodeValid(final PceOtnNode pceOtnNode) {
- if (pceOtnNode == null || pceOtnNode.node == null
- || pceOtnNode.getNodeId() == null || pceOtnNode.nodeType == null || pceOtnNode.getSupNetworkNodeId() == null
- || pceOtnNode.getSupClliNodeId() == null || pceOtnNode.otnServiceType == null) {
- LOG.error(
- "PceOtnNode: one of parameters is not populated : nodeId, node type, supporting nodeId, otnServiceType"
- );
- return false;
- }
-
- if (!isNodeTypeValid(pceOtnNode)) {
- LOG.error("PceOtnNode node type: node type isn't one of MUXPDR or SWITCH or TPDR");
- return false;
- }
-
- return isOtnServiceTypeValid(pceOtnNode);
- }
-
- private boolean isOtnServiceTypeValid(PceOtnNode pceOtnNode) {
- if (pceOtnNode.modeType == null) {
- return false;
- }
-
- //Todo refactor Strings (mode and otnServiceType ) to enums
- if ((pceOtnNode.otnServiceType.equals(StringConstants.SERVICE_TYPE_ODU4)
- && pceOtnNode.modeType.equals("AZ"))) {
- return true;
- }
-
- return ((pceOtnNode.otnServiceType.equals(StringConstants.SERVICE_TYPE_10GE)
- || pceOtnNode.otnServiceType.equals(StringConstants.SERVICE_TYPE_1GE)
- || pceOtnNode.otnServiceType.equals(StringConstants.SERVICE_TYPE_100GE_S))
- && (isAz(pceOtnNode) || isIntermediate(pceOtnNode)));
- }
-
- private boolean isIntermediate(PceOtnNode pceOtnNode) {
- return pceOtnNode.modeType.equals("intermediate")
- && checkSwPool(null, pceOtnNode.availableXpdrNWTps, 0, 2);
- }
-
- private boolean isAz(PceOtnNode pceOtnNode) {
- return pceOtnNode.modeType.equals("AZ")
- && checkSwPool(pceOtnNode.availableXpdrClientTps, pceOtnNode.availableXpdrNWTps, 1, 1);
- }
-
- private boolean isNodeTypeValid(final PceOtnNode pceOtnNode) {
- return (pceOtnNode.nodeType == OpenroadmNodeType.MUXPDR)
- || (pceOtnNode.nodeType == OpenroadmNodeType.SWITCH)
- || (pceOtnNode.nodeType == OpenroadmNodeType.TPDR);
- }
-
@Override
public void addOutgoingLink(PceLink outLink) {
this.outgoingLinks.add(outLink);
}
@Override
- public String getRdmSrgClient(String tp) {
+ public String getRdmSrgClient(String tp, String direction) {
return null;
}
node = NodeUtils.getOTNNodeBuilder(NodeUtils.geSupportingNodes(), OpenroadmTpType.XPONDERNETWORK).build();
PceOtnNode pceOtnNode = new PceOtnNode(node, OpenroadmNodeType.MUXPDR,
- new NodeId("optical"), ServiceFormat.OTU.getName(), "DEGREE");
+ new NodeId("optical"), ServiceFormat.OTU.getName(), "serviceType", null);
pceOtnNode.validateXponder("optical", "sl");
pceOtnNode.validateXponder("not optical", "sl");
pceOtnNode.initXndrTps("AZ");
PceOtnNode pceOtnNode2 = new PceOtnNode(node, OpenroadmNodeType.MUXPDR,
- new NodeId("optical2"), ServiceFormat.OTU.getName(), "DEGREE");
+ new NodeId("optical2"), ServiceFormat.OTU.getName(), "serviceType", null);
pceOtnNode2.validateXponder("optical", "sl");
pceOtnNode2.validateXponder("not optical", "sl");
pceOtnNode2.initXndrTps("AZ");
Assert.assertNotNull(node.augmentation(Node1.class));
// OpenroadmNodeType nodeType = node.augmentation(Node1.class).;
- PceOtnNode pceOtnNode = new PceOtnNode(node, OpenroadmNodeType.SRG, node.getNodeId(), "otn", "serviceType");
+ PceOtnNode pceOtnNode = new PceOtnNode(node, OpenroadmNodeType.SRG, node.getNodeId(), "otn", "serviceType",
+ null);
}
OpenroadmNodeType.ROADM, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1,
GridConstant.SLOT_WIDTH_50, GridConstant.SLOT_WIDTH_50);
pceOpticalNode.initSrgTps();
- Assert.assertNull(pceOpticalNode.getRdmSrgClient("7"));
+ Assert.assertNull(pceOpticalNode.getRdmSrgClient("7", StringConstants.SERVICE_DIRECTION_AZ));
Assert.assertFalse(pceOpticalNode.isValid());
Assert.assertNull(pceOpticalNode.getBitSetData());
Assert.assertTrue(pceOpticalNode.checkTP("testTP"));
pceOpticalNode.initSrgTps();
pceOpticalNode.initFrequenciesBitSet();
pceOpticalNode.initXndrTps(ServiceFormat.OMS);
- Assert.assertNull(pceOpticalNode.getRdmSrgClient("7"));
+ Assert.assertNull(pceOpticalNode.getRdmSrgClient("7" ,StringConstants.SERVICE_DIRECTION_AZ));
Assert.assertFalse(pceOpticalNode.isValid());
Assert.assertNull(pceOpticalNode.getBitSetData());
Assert.assertTrue(pceOpticalNode.checkTP("testTP"));
OpenroadmNodeType.DEGREE, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1,
GridConstant.SLOT_WIDTH_50, GridConstant.SLOT_WIDTH_50);
pceOpticalNode.initSrgTps();
- Assert.assertNull(pceOpticalNode.getRdmSrgClient("7"));
+ Assert.assertNull(pceOpticalNode.getRdmSrgClient("7" ,StringConstants.SERVICE_DIRECTION_AZ));
Assert.assertFalse(pceOpticalNode.isValid());
Assert.assertNull(pceOpticalNode.getBitSetData());
Assert.assertTrue(pceOpticalNode.checkTP("testTP"));
Assert.assertFalse(pceOpticalNode.isValid());
Assert.assertNull(pceOpticalNode.getBitSetData());
Assert.assertTrue(pceOpticalNode.checkTP("testTP"));
- Assert.assertNull(pceOpticalNode.getRdmSrgClient("5"));
+ Assert.assertNull(pceOpticalNode.getRdmSrgClient("5", StringConstants.SERVICE_DIRECTION_AZ));
}
@Test
OpenroadmNodeType.ROADM, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1,
GridConstant.SLOT_WIDTH_50, GridConstant.SLOT_WIDTH_50);
pceOpticalNode.initSrgTps();
- Assert.assertNull(pceOpticalNode.getRdmSrgClient("2"));
+ Assert.assertNull(pceOpticalNode.getRdmSrgClient("2" ,StringConstants.SERVICE_DIRECTION_AZ));
Assert.assertFalse(pceOpticalNode.isValid());
Assert.assertNull(pceOpticalNode.getBitSetData());
Assert.assertTrue(pceOpticalNode.checkTP("testTP"));
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
-import org.mockito.Mockito;
import org.opendaylight.transportpce.common.NetworkUtils;
import org.opendaylight.transportpce.common.StringConstants;
import org.opendaylight.transportpce.common.fixedflex.GridUtils;
@Test
public void testInitXndrTpsODU4() {
pceOtnNode = new PceOtnNode(node, OpenroadmNodeType.MUXPDR,
- new NodeId("optical"), ServiceFormat.OMS.getName(), StringConstants.SERVICE_TYPE_ODU4);
+ new NodeId("optical"), ServiceFormat.OMS.getName(), StringConstants.SERVICE_TYPE_ODU4, null);
pceOtnNode.initXndrTps("AZ");
pceOtnNode.checkAvailableTribPort();
pceOtnNode.checkAvailableTribSlot();
@Test
public void testInitXndrTps10GE() {
pceOtnNode = new PceOtnNode(node, OpenroadmNodeType.MUXPDR,
- new NodeId("optical"), ServiceFormat.OMS.getName(), StringConstants.SERVICE_TYPE_10GE);
+ new NodeId("optical"), ServiceFormat.OMS.getName(), StringConstants.SERVICE_TYPE_10GE, null);
pceOtnNode.initXndrTps("mode");
pceOtnNode.checkAvailableTribPort();
pceOtnNode.checkAvailableTribSlot();
public void testInitXndrTps10GXponderClient1() {
node = getNodeBuilder(geSupportingNodes(), OpenroadmTpType.XPONDERCLIENT).build();
pceOtnNode = new PceOtnNode(node, OpenroadmNodeType.ROADM,
- new NodeId("optical"), ServiceFormat.OMS.getName(), StringConstants.SERVICE_TYPE_10GE);
+ new NodeId("optical"), ServiceFormat.OMS.getName(), StringConstants.SERVICE_TYPE_10GE, null);
pceOtnNode.initXndrTps("mode");
pceOtnNode.checkAvailableTribPort();
pceOtnNode.checkAvailableTribSlot();
public void testInitXndrTps1GXponderClient() {
node = getNodeBuilder(geSupportingNodes(), OpenroadmTpType.XPONDERCLIENT).build();
pceOtnNode = new PceOtnNode(node, OpenroadmNodeType.MUXPDR,
- new NodeId("optical"), ServiceFormat.OMS.getName(), StringConstants.SERVICE_TYPE_1GE);
+ new NodeId("optical"), ServiceFormat.OMS.getName(), StringConstants.SERVICE_TYPE_1GE, null);
pceOtnNode.initXndrTps("mode");
pceOtnNode.checkAvailableTribPort();
pceOtnNode.checkAvailableTribSlot();
@Test
public void testInitXndrTps10GXponderClient() {
pceOtnNode = new PceOtnNode(node, OpenroadmNodeType.MUXPDR,
- new NodeId("optical"), ServiceFormat.OMS.getName(), StringConstants.SERVICE_TYPE_10GE);
+ new NodeId("optical"), ServiceFormat.OMS.getName(), StringConstants.SERVICE_TYPE_10GE, null);
pceOtnNode.validateXponder("optical", "sl");
pceOtnNode.validateXponder("not optical", "sl");
pceOtnNode.initXndrTps("AZ");
}
- @Test
- public void testIsPceOtnNodeValid() {
- pceOtnNode = new PceOtnNode(node, OpenroadmNodeType.MUXPDR,
- new NodeId("optical"), ServiceFormat.OMS.getName(), StringConstants.SERVICE_TYPE_10GE);
- pceOtnNode.initXndrTps("AZ");
- pceOtnNode.checkAvailableTribPort();
- pceOtnNode.checkAvailableTribSlot();
- Assert.assertFalse("not valid otn service Type" , pceOtnNode.isPceOtnNodeValid(pceOtnNode));
- }
-
- @Test
- public void testIsPceOtnNodeValidNode() {
- pceOtnNode = new PceOtnNode(node, OpenroadmNodeType.DEGREE,
- new NodeId("optical"), ServiceFormat.OMS.getName(), StringConstants.SERVICE_TYPE_100GE_M);
- pceOtnNode.initXndrTps("AZ");
- pceOtnNode.checkAvailableTribPort();
- pceOtnNode.checkAvailableTribSlot();
- pceOtnNode = Mockito.spy(pceOtnNode);
- Mockito.when(pceOtnNode.getNodeId()).thenReturn(null);
- Assert.assertFalse("not valid node , nodeId is null" , pceOtnNode.isPceOtnNodeValid(pceOtnNode));
-
- }
-
- @Test
- public void testIsPceOtnNodeValidNodeTypeNull() {
- pceOtnNode = new PceOtnNode(node, null,
- new NodeId("optical"), ServiceFormat.OMS.getName(), StringConstants.SERVICE_TYPE_100GE_M);
- pceOtnNode.initXndrTps("AZ");
- pceOtnNode.checkAvailableTribPort();
- pceOtnNode.checkAvailableTribSlot();
- Assert.assertFalse("not valid type, nodeType is null " , pceOtnNode.isPceOtnNodeValid(pceOtnNode));
- }
-
- @Test
- public void testIsPceOtnNodeValidNodeTypeDeg() {
- pceOtnNode = new PceOtnNode(node, OpenroadmNodeType.DEGREE,
- new NodeId("optical"), ServiceFormat.OMS.getName(), StringConstants.SERVICE_TYPE_100GE_M);
- pceOtnNode.initXndrTps("AZ");
- Assert.assertFalse("not valid node , its type isn't one of MUXPDR or SWITCH or TPDR" ,
- pceOtnNode.isPceOtnNodeValid(pceOtnNode));
- }
-
- @Test
- public void testIsPceOtnNodeValidTrue() {
- pceOtnNode = new PceOtnNode(node, OpenroadmNodeType.MUXPDR,
- new NodeId("optical"), ServiceFormat.OMS.getName(), StringConstants.SERVICE_TYPE_ODU4);
- pceOtnNode.initXndrTps("AZ");
- pceOtnNode.checkAvailableTribPort();
- pceOtnNode.checkAvailableTribSlot();
- Assert.assertTrue("valid otn service type ", pceOtnNode.isPceOtnNodeValid(pceOtnNode));
- }
-
- @Test
- public void testIsPceOtnNodeValidChecksw() {
- node = getNodeBuilder(geSupportingNodes(), OpenroadmTpType.XPONDERCLIENT).build();
- pceOtnNode = new PceOtnNode(node, OpenroadmNodeType.MUXPDR,
- new NodeId("optical"), ServiceFormat.OMS.getName(), StringConstants.SERVICE_TYPE_1GE);
- pceOtnNode.initXndrTps("mode");
- Assert.assertFalse("not valid otn service Type" , pceOtnNode.isPceOtnNodeValid(pceOtnNode));
- }
-
private Map<SupportingNodeKey, SupportingNode> geSupportingNodes() {
Map<SupportingNodeKey, SupportingNode> supportingNodes1 = new HashMap<>();
SupportingNode supportingNode1 = new SupportingNodeBuilder()
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent</artifactId>
- <version>9.0.8</version>
+ <version>9.0.13</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>8.0.7</version>
+ <version>8.0.11</version>
<relativePath/>
</parent>
package org.opendaylight.transportpce.renderer;
import com.google.common.util.concurrent.ListenableFuture;
+import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
olmSetupBldr.setWaveNumber(atoZDirection.getAToZWavelengthNumber());
if (atoZDirection.getAToZMinFrequency() != null) {
olmSetupBldr.setLowerSpectralSlotNumber(Uint32
- .valueOf(GridUtils
- .getLowerSpectralIndexFromFrequency(atoZDirection.getAToZMinFrequency().getValue())));
+ .valueOf(GridUtils
+ .getLowerSpectralIndexFromFrequency(atoZDirection.getAToZMinFrequency().getValue())));
}
if (atoZDirection.getAToZMaxFrequency() != null) {
olmSetupBldr.setHigherSpectralSlotNumber(Uint32
- .valueOf(GridUtils
- .getHigherSpectralIndexFromFrequency(atoZDirection.getAToZMaxFrequency().getValue())));
+ .valueOf(GridUtils
+ .getHigherSpectralIndexFromFrequency(atoZDirection.getAToZMaxFrequency().getValue())));
}
+ // Set the MC-width for the OLM
+ olmSetupBldr.setMcWidth(new FrequencyGHz(atoZDirection.getAToZMaxFrequency().getValue()
+ .subtract(atoZDirection.getAToZMinFrequency().getValue()).multiply(new BigDecimal(1000))));
}
return olmSetupBldr.build();
}
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.OduConnectionKey;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.RoadmConnections;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.RoadmConnectionsKey;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.types.rev191129.XpdrNodeTypes;
import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev171215.AdminStates;
import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev181019.EthAttributes;
import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev181019.Interface1Builder;
import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.ODU4;
import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.ODUCTP;
import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.ODUTTP;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.ODUTTPCTP;
import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.OTU4;
import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.OduFunctionIdentity;
import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.PayloadTypeDef;
throw new OpenRoadmInterfaceException(
String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
}
+
InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(mapping, OtnOdu.class,
logicalConnPoint + "-ODU4");
if (mapping.getSupportingOtu4() != null) {
oduFunction = ODUCTP.class;
monitoringMode = MonitoringMode.Monitored;
} else {
- oduFunction = ODUTTP.class;
+ // For TPDR it can be both CTP and TTP
+ if (mapping.getXponderType() == XpdrNodeTypes.Tpdr) {
+ oduFunction = ODUTTPCTP.class;
+ // For switch-ponder we still use TTP
+ } else {
+ oduFunction = ODUTTP.class;
+ }
monitoringMode = MonitoringMode.Terminated;
opu = new OpuBuilder()
.setPayloadType(PayloadTypeDef.getDefaultInstance(payloadType))
import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev191129.OtnOtu;
import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev191129.Otsi;
import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev191129.OtsiGroup;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.maintenance.loopback.rev191129.maint.loopback.MaintLoopbackBuilder;
import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev200529.och.container.OchBuilder;
import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.tributary.signal.interfaces.rev200529.otsi.attributes.FlexoBuilder;
import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.tributary.signal.interfaces.rev200529.otsi.container.OtsiBuilder;
nodeId, logicalConnPoint));
}
// Create an OTUCn object
- MaintLoopbackBuilder maintLoopbackBuilder = new MaintLoopbackBuilder();
- maintLoopbackBuilder.setEnabled(false);
OtuBuilder otuBuilder = new OtuBuilder()
.setRate(OTUCn.class)
.setTimActEnabled(false)
.setTimDetectMode(TimDetectMode.Disabled)
.setDegmIntervals(Uint8.valueOf(2))
- .setDegthrPercentage(Uint16.valueOf(100))
- .setMaintLoopback(maintLoopbackBuilder.build());
+ .setDegthrPercentage(Uint16.valueOf(100));
+
if (apiInfoA != null) {
otuBuilder.setTxSapi(apiInfoA.getSapi())
.setTxDapi(apiInfoA.getDapi())
nodeOpenRoadmVersion.equals(OpenroadmNodeVersion._71)
? Map.of(
// We don't need ODUC2, ODUC3 here, since they are handled in OTN service-path
- "ODU", List.of("ODU4", "ODUC4", "ODUFLEX"),
+ // This has to be in an order of deletion
+ "ODU", List.of("ODU4", "ODUFLEX", "ODUC4"),
// Add intermediate OTUCn rates (OTUC2, OTUC3)
// OTU4 is used in 100G service on 7.1 model
"other", List.of("OTU4", "OTUC2", "OTUC3", "OTUC4",
<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>8.0.7</version>
+ <version>8.0.11</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>8.0.7</version>
+ <version>8.0.11</version>
<relativePath/>
</parent>
.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.ConnectionKey,
org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.Connection>
connectionFullMap; // this variable is for complete connection objects
- private Map<String, Map<String, Boolean>> networkMap = new HashMap<>();
private final NetworkTransactionService networkTransactionService;
// TODO -> handle cases for which node id is ROADM-A1 and not ROADMA01 or XPDR-A1 and not XPDRA01
String rxPortName = txPortName;
LOG.debug("Node z id = {}, txportDeviceName = {}, txPortName = {}", nodeid, txPortDeviceName, txPortName);
LOG.debug("Node z id = {}, rxportDeviceName = {}, rxPortName = {}", nodeid, rxPortDeviceName, rxPortName);
- if (serviceFormat.equals(ServiceFormat.ODU)) {
- // TODO --> populate network map
- populateNetworkMap(nodeid, txPortName);
- }
- if (serviceFormat.equals(ServiceFormat.Ethernet)) {
- // TODO --> choose from network Map un network port which hasnt been used yet by another service.
- // Set boolean to true and update txportName and so on
- String updTxName = findFreeConfiguredNetworkPort(nodeid);
- if (updTxName != null) {
- txPortName = updTxName;
- rxPortName = txPortName;
- }
- }
// TODO --> get clli from datastore?
String clli = "NodeSC";
LOG.info("Node z id = {}, txportDeviceName = {}, txPortName = {}", nodeid, txPortDeviceName, txPortName);
String rxPortName = txPortName;
LOG.debug("Node a id = {}, txportDeviceName = {}, txPortName = {}", nodeid, txPortDeviceName, txPortName);
LOG.debug("Node a id = {}, rxportDeviceName = {}, rxPortName = {}", nodeid, rxPortDeviceName, rxPortName);
- if (serviceFormat.equals(ServiceFormat.ODU)) {
- // TODO --> populate network map
- populateNetworkMap(nodeid, txPortName);
- }
- if (serviceFormat.equals(ServiceFormat.Ethernet)) {
- // TODO --> choose from network Map un network port which hasnt been used yet by another service.
- // Set boolean to true and update txportName and so on
- String updTxName = findFreeConfiguredNetworkPort(nodeid);
- if (updTxName != null) {
- txPortName = updTxName;
- rxPortName = txPortName;
- }
- }
// TODO --> get clli from datastore?
String clli = "NodeSA";
LOG.info("Node a id = {}, txportDeviceName = {}, txPortName = {}", nodeid, txPortDeviceName, txPortName);
return serviceAEndBuilder.build();
}
- private String findFreeConfiguredNetworkPort(String nodeid) {
- if (!this.networkMap.containsKey(nodeid)) {
- return null;
- }
- Map<String, Boolean> netMap = this.networkMap.get(nodeid);
- for (Map.Entry<String, Boolean> entry : netMap.entrySet()) {
- if (!entry.getValue()) {
- this.networkMap.get(nodeid).put(entry.getKey(), true);
- return entry.getKey();
- }
- }
- return null;
- }
-
- private void populateNetworkMap(String nodeid, String txPortName) {
- Map<String, Boolean> netMap = new HashMap<>();
- netMap.put(txPortName, false);
- if (!this.networkMap.containsKey(nodeid)) {
- this.networkMap.put(nodeid, netMap);
- } else if (!this.networkMap.get(nodeid).containsKey(txPortName)) {
- this.networkMap.get(nodeid).putAll(netMap);
- }
- }
-
private ConnectionType getConnectionTypePhtnc(Collection<org.opendaylight.yang.gen.v1.urn
.onf.otcc.yang.tapi.connectivity.rev181210.create.connectivity.service.input.EndPoint> endPoints) {
if (endPoints.stream().anyMatch(ep -> ep.getName().values().stream()
<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>8.0.7</version>
+ <version>8.0.11</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>8.0.7</version>
+ <version>8.0.11</version>
<relativePath />
</parent>
<dependency>
<groupId>org.opendaylight.netconf</groupId>
<artifactId>netconf-artifacts</artifactId>
- <version>2.0.11</version>
+ <version>2.0.14</version>
<scope>import</scope>
<type>pom</type>
</dependency>
</xponder>
<odu-switching-pools>
<switching-pool-number>1</switching-pool-number>
- <switching-pool-type xmlns:org-openroadm-switching-pool-types="http://org/openroadm/switching-pool-types">non-blocking</switching-pool-type>
+ <switching-pool-type xmlns:org-openroadm-switching-pool-types="http://org/openroadm/switching-pool-types">blocking</switching-pool-type>
<non-blocking-list>
<nbl-number>1</nbl-number>
<interconnect-bandwidth-unit>1000000000</interconnect-bandwidth-unit>
</odu-switching-pools>
<odu-switching-pools>
<switching-pool-number>3</switching-pool-number>
- <switching-pool-type xmlns:org-openroadm-switching-pool-types="http://org/openroadm/switching-pool-types">non-blocking</switching-pool-type>
+ <switching-pool-type xmlns:org-openroadm-switching-pool-types="http://org/openroadm/switching-pool-types">blocking</switching-pool-type>
<non-blocking-list>
<nbl-number>1</nbl-number>
<interconnect-bandwidth-unit>1000000000</interconnect-bandwidth-unit>
</xponder>
<odu-switching-pools>
<switching-pool-number>1</switching-pool-number>
- <switching-pool-type xmlns:org-openroadm-switching-pool-types="http://org/openroadm/switching-pool-types">non-blocking</switching-pool-type>
+ <switching-pool-type xmlns:org-openroadm-switching-pool-types="http://org/openroadm/switching-pool-types">blocking</switching-pool-type>
<non-blocking-list>
<nbl-number>1</nbl-number>
<interconnect-bandwidth-unit>1000000000</interconnect-bandwidth-unit>
</odu-switching-pools>
<odu-switching-pools>
<switching-pool-number>3</switching-pool-number>
- <switching-pool-type xmlns:org-openroadm-switching-pool-types="http://org/openroadm/switching-pool-types">non-blocking</switching-pool-type>
+ <switching-pool-type xmlns:org-openroadm-switching-pool-types="http://org/openroadm/switching-pool-types">blocking</switching-pool-type>
<non-blocking-list>
<nbl-number>1</nbl-number>
<interconnect-bandwidth-unit>1000000000</interconnect-bandwidth-unit>
</xponder>
<odu-switching-pools>
<switching-pool-number>1</switching-pool-number>
- <switching-pool-type xmlns:org-openroadm-switching-pool-types="http://org/openroadm/switching-pool-types">non-blocking</switching-pool-type>
+ <switching-pool-type xmlns:org-openroadm-switching-pool-types="http://org/openroadm/switching-pool-types">blocking</switching-pool-type>
<non-blocking-list>
<nbl-number>1</nbl-number>
<interconnect-bandwidth-unit>1000000000</interconnect-bandwidth-unit>
</odu-switching-pools>
<odu-switching-pools>
<switching-pool-number>3</switching-pool-number>
- <switching-pool-type xmlns:org-openroadm-switching-pool-types="http://org/openroadm/switching-pool-types">non-blocking</switching-pool-type>
+ <switching-pool-type xmlns:org-openroadm-switching-pool-types="http://org/openroadm/switching-pool-types">blocking</switching-pool-type>
<non-blocking-list>
<nbl-number>1</nbl-number>
<interconnect-bandwidth-unit>1000000000</interconnect-bandwidth-unit>
</xponder>
<odu-switching-pools>
<switching-pool-number>1</switching-pool-number>
- <switching-pool-type xmlns:org-openroadm-switching-pool-types="http://org/openroadm/switching-pool-types">non-blocking</switching-pool-type>
+ <switching-pool-type xmlns:org-openroadm-switching-pool-types="http://org/openroadm/switching-pool-types">blocking</switching-pool-type>
<non-blocking-list>
<nbl-number>1</nbl-number>
<interconnect-bandwidth-unit>1000000000</interconnect-bandwidth-unit>
</xponder>
<odu-switching-pools>
<switching-pool-number>1</switching-pool-number>
- <switching-pool-type xmlns:org-openroadm-switching-pool-types="http://org/openroadm/switching-pool-types">non-blocking</switching-pool-type>
+ <switching-pool-type xmlns:org-openroadm-switching-pool-types="http://org/openroadm/switching-pool-types">blocking</switching-pool-type>
<non-blocking-list>
<nbl-number>1</nbl-number>
<interconnect-bandwidth-unit>1000000000</interconnect-bandwidth-unit>
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual("gainLoss", res['roadm-connections'][0]['opticalControlMode'])
- self.assertEqual(2, res['roadm-connections'][0]['target-output-power'])
+ self.assertEqual(-0.63, res['roadm-connections'][0]['target-output-power'])
def test_26_service_power_turndown_XPDRA_XPDRC(self):
url = "{}/operations/transportpce-olm:service-power-turndown"
@classmethod
def setUpClass(cls):
cls.processes = test_utils_rfc8040.start_tpce()
- cls.processes = test_utils_rfc8040.start_sims([('xpdra', cls.NODE_VERSION), ('roadma', cls.NODE_VERSION)])
+ cls.processes = test_utils_rfc8040.start_sims([('xpdra', cls.NODE_VERSION), ('roadma', cls.NODE_VERSION),
+ ('spdra', cls.NODE_VERSION)])
@classmethod
def tearDownClass(cls):
def setUp(self):
# pylint: disable=consider-using-f-string
print("execution of {}".format(self.id().split(".")[-1]))
- time.sleep(10)
+ time.sleep(1)
def test_01_rdm_device_connection(self):
response = test_utils_rfc8040.mount_device("ROADM-A1", ('roadma', self.NODE_VERSION))
response = test_utils_rfc8040.check_device_connection("ROADM-A1")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['connection-status'], 'connected')
- time.sleep(10)
def test_03_rdm_portmapping_info(self):
response = test_utils_rfc8040.get_portmapping_node_info("ROADM-A1")
'node-vendor': 'vendorA',
'node-model': 'model2'},
response['node-info'])
- time.sleep(3)
def test_04_rdm_portmapping_DEG1_TTP_TXRX(self):
response = test_utils_rfc8040.portmapping_request("ROADM-A1", "DEG1-TTP-TXRX")
response = test_utils_rfc8040.check_device_connection("XPDR-A1")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['connection-status'], 'connected')
- time.sleep(10)
def test_10_xpdr_portmapping_info(self):
response = test_utils_rfc8040.get_portmapping_node_info("XPDR-A1")
'node-vendor': 'vendorA',
'node-model': 'model2'},
response['node-info'])
- time.sleep(3)
def test_11_xpdr_portmapping_NETWORK1(self):
response = test_utils_rfc8040.portmapping_request("XPDR-A1", "XPDR1-NETWORK1")
'port-admin-state': 'InService', 'port-oper-state': 'InService'},
response['mapping'])
- def test_15_xpdr_device_disconnection(self):
+ def test_15_spdr_device_connection(self):
+ response = test_utils_rfc8040.mount_device("SPDR-SA1", ('spdra', self.NODE_VERSION))
+ self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+
+ def test_16_spdr_device_connected(self):
+ response = test_utils_rfc8040.check_device_connection("SPDR-SA1")
+ self.assertEqual(response['status_code'], requests.codes.ok)
+ self.assertEqual(response['connection-status'], 'connected')
+
+ def test_17_spdr_portmapping_info(self):
+ response = test_utils_rfc8040.get_portmapping_node_info("SPDR-SA1")
+ self.assertEqual(response['status_code'], requests.codes.ok)
+ self.assertEqual(
+ {'node-type': 'xpdr',
+ 'node-ip-address': '1.2.3.4',
+ 'node-clli': 'NodeSA',
+ 'openroadm-version': '2.2.1',
+ 'node-vendor': 'vendorA',
+ 'node-model': 'universal-switchponder'},
+ response['node-info'])
+
+ def test_18_spdr_switching_pool_1(self):
+ response = test_utils_rfc8040.portmapping_switching_pool_request("SPDR-SA1", "1")
+ self.assertEqual(response['status_code'], requests.codes.ok)
+ self.assertEqual("blocking",
+ response['switching_pool'][0]['switching-pool-type'])
+ self.assertEqual(4,
+ len(response['switching_pool'][0]['non-blocking-list']))
+ self.assertIn(
+ {'nbl-number': 11,
+ 'interconnect-bandwidth': 0,
+ 'interconnect-bandwidth-unit': 1000000000,
+ 'lcp-list': ['XPDR1-NETWORK1', 'XPDR1-CLIENT1']},
+ response['switching_pool'][0]['non-blocking-list'])
+
+ def test_19_spdr_switching_pool_2(self):
+ response = test_utils_rfc8040.portmapping_switching_pool_request("SPDR-SA1", "2")
+ self.assertEqual(response['status_code'], requests.codes.ok)
+ self.assertEqual("non-blocking",
+ response['switching_pool'][0]['switching-pool-type'])
+ self.assertEqual(1,
+ len(response['switching_pool'][0]['non-blocking-list']))
+ self.assertIn(
+ {'nbl-number': 2,
+ 'interconnect-bandwidth': 0,
+ 'interconnect-bandwidth-unit': 1000000000,
+ 'lcp-list': ["XPDR2-CLIENT3", "XPDR2-CLIENT4", "XPDR2-NETWORK4",
+ "XPDR2-NETWORK1", "XPDR2-NETWORK3", "XPDR2-NETWORK2",
+ "XPDR2-CLIENT1", "XPDR2-CLIENT2"]},
+ response['switching_pool'][0]['non-blocking-list'])
+
+ def test_20_spdr_switching_pool_3(self):
+ response = test_utils_rfc8040.portmapping_switching_pool_request("SPDR-SA1", "3")
+ self.assertEqual(response['status_code'], requests.codes.ok)
+ self.assertEqual("blocking",
+ response['switching_pool'][0]['switching-pool-type'])
+ self.assertEqual(4,
+ len(response['switching_pool'][0]['non-blocking-list']))
+ self.assertIn(
+ {'nbl-number': 83,
+ 'interconnect-bandwidth': 0,
+ 'interconnect-bandwidth-unit': 1000000000,
+ 'lcp-list': ['XPDR3-NETWORK1', 'XPDR3-CLIENT3']},
+ response['switching_pool'][0]['non-blocking-list'])
+
+ def test_21_spdr_portmapping_mappings(self):
+ response = test_utils_rfc8040.get_portmapping("SPDR-SA1")
+ self.assertEqual(response['status_code'], requests.codes.ok)
+ self.assertEqual(18, len(response['nodes'][0]['mapping']))
+
+ def test_22_spdr_portmapping_XPDR1_CLIENT1(self):
+ response = test_utils_rfc8040.portmapping_request("SPDR-SA1", "XPDR1-CLIENT1")
+ self.assertEqual(response['status_code'], requests.codes.ok)
+ self.assertIn(
+ {"logical-connection-point": "XPDR1-CLIENT1",
+ "supporting-circuit-pack-name": "CP1-SFP1",
+ "supported-interface-capability": ["org-openroadm-port-types:if-10GE-ODU2e",
+ "org-openroadm-port-types:if-10GE-ODU2"],
+ "supporting-port": "CP1-SFP1-P1",
+ "lcp-hash-val": "FqlcrxV7p30=",
+ "port-direction": "bidirectional",
+ "port-admin-state": "InService",
+ "xponder-type": "mpdr",
+ "port-qual": "xpdr-client",
+ "port-oper-state": "InService"},
+ response['mapping'])
+
+ def test_23_spdr_portmapping_XPDR1_NETWORK1(self):
+ response = test_utils_rfc8040.portmapping_request("SPDR-SA1", "XPDR1-NETWORK1")
+ self.assertEqual(response['status_code'], requests.codes.ok)
+ self.assertIn(
+ {"logical-connection-point": "XPDR1-NETWORK1",
+ "supporting-circuit-pack-name": "CP1-CFP0",
+ "supported-interface-capability": ["org-openroadm-port-types:if-OCH-OTU4-ODU4"],
+ "supporting-port": "CP1-CFP0-P1",
+ "lcp-hash-val": "Swfw02qXGyI=",
+ "port-direction": "bidirectional",
+ "port-admin-state": "InService",
+ "xponder-type": "mpdr",
+ "port-qual": "xpdr-network",
+ "port-oper-state": "InService"},
+ response['mapping'])
+
+ def test_24_spdr_portmapping_XPDR2_CLIENT2(self):
+ response = test_utils_rfc8040.portmapping_request("SPDR-SA1", "XPDR2-CLIENT2")
+ self.assertEqual(response['status_code'], requests.codes.ok)
+ self.assertIn(
+ {"logical-connection-point": "XPDR2-CLIENT2",
+ "supporting-circuit-pack-name": "CP2-QSFP2",
+ "supported-interface-capability": ["org-openroadm-port-types:if-100GE-ODU4",
+ "org-openroadm-port-types:if-100GE"],
+ "supporting-port": "CP2-QSFP2-P1",
+ "lcp-hash-val": "AN/WSSRXne3t",
+ "port-direction": "bidirectional",
+ "port-admin-state": "InService",
+ "xponder-type": "switch",
+ "port-qual": "switch-client",
+ "port-oper-state": "InService"},
+ response['mapping'])
+
+ def test_25_spdr_portmapping_XPDR2_NETWORK2(self):
+ response = test_utils_rfc8040.portmapping_request("SPDR-SA1", "XPDR2-NETWORK2")
+ self.assertEqual(response['status_code'], requests.codes.ok)
+ self.assertIn(
+ {"logical-connection-point": "XPDR2-NETWORK2",
+ "supporting-circuit-pack-name": "CP6-CFP",
+ "supported-interface-capability": ["org-openroadm-port-types:if-OCH-OTU4-ODU4"],
+ "supporting-port": "CP6-CFP-P1",
+ "lcp-hash-val": "exT821pFtOQ=",
+ "port-direction": "bidirectional",
+ "port-admin-state": "InService",
+ "xponder-type": "switch",
+ "port-qual": "switch-network",
+ "port-oper-state": "InService"},
+ response['mapping'])
+
+ def test_26_spdr_portmapping_XPDR3_CLIENT3(self):
+ response = test_utils_rfc8040.portmapping_request("SPDR-SA1", "XPDR3-CLIENT3")
+ self.assertEqual(response['status_code'], requests.codes.ok)
+ self.assertIn(
+ {"logical-connection-point": "XPDR3-CLIENT3",
+ "supporting-circuit-pack-name": "CP3-SFP3",
+ "supported-interface-capability": ["org-openroadm-port-types:if-1GE-ODU0"],
+ "supporting-port": "CP3-SFP3-P1",
+ "lcp-hash-val": "AKsQ/HRQdtdN",
+ "port-direction": "bidirectional",
+ "port-admin-state": "InService",
+ "xponder-type": "mpdr",
+ "port-qual": "xpdr-client",
+ "port-oper-state": "InService"},
+ response['mapping'])
+
+ def test_27_spdr_portmapping_XPDR3_NETWORK1(self):
+ response = test_utils_rfc8040.portmapping_request("SPDR-SA1", "XPDR3-NETWORK1")
+ self.assertEqual(response['status_code'], requests.codes.ok)
+ self.assertIn(
+ {"logical-connection-point": "XPDR3-NETWORK1",
+ "supporting-circuit-pack-name": "CP3-CFP0",
+ "supported-interface-capability": ["org-openroadm-port-types:if-OCH-OTU4-ODU4"],
+ "supporting-port": "CP3-CFP0-P1",
+ "lcp-hash-val": "ANnxoi7K8q30",
+ "port-direction": "bidirectional",
+ "port-admin-state": "InService",
+ "xponder-type": "mpdr",
+ "port-qual": "xpdr-network",
+ "port-oper-state": "InService"},
+ response['mapping'])
+
+ def test_28_spdr_device_disconnection(self):
+ response = test_utils_rfc8040.unmount_device("SPDR-SA1")
+ self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
+
+ def test_29_xpdr_device_disconnected(self):
+ response = test_utils_rfc8040.check_device_connection("SPDR-SA1")
+ self.assertEqual(response['status_code'], requests.codes.conflict)
+ self.assertIn(response['connection-status']['error-type'], ('protocol', 'application'))
+ self.assertEqual(response['connection-status']['error-tag'], 'data-missing')
+ self.assertEqual(response['connection-status']['error-message'],
+ 'Request could not be completed because the relevant data model content does not exist')
+
+ def test_30_xpdr_device_disconnection(self):
response = test_utils_rfc8040.unmount_device("XPDR-A1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
- def test_16_xpdr_device_disconnected(self):
+ def test_31_xpdr_device_disconnected(self):
response = test_utils_rfc8040.check_device_connection("XPDR-A1")
self.assertEqual(response['status_code'], requests.codes.conflict)
self.assertIn(response['connection-status']['error-type'], ('protocol', 'application'))
self.assertEqual(response['connection-status']['error-message'],
'Request could not be completed because the relevant data model content does not exist')
- def test_17_xpdr_device_not_connected(self):
+ def test_32_xpdr_device_not_connected(self):
response = test_utils_rfc8040.get_portmapping_node_info("XPDR-A1")
self.assertEqual(response['status_code'], requests.codes.conflict)
self.assertIn(response['node-info']['error-type'], ('protocol', 'application'))
self.assertEqual(response['node-info']['error-message'],
'Request could not be completed because the relevant data model content does not exist')
- def test_18_rdm_device_disconnection(self):
+ def test_33_rdm_device_disconnection(self):
response = test_utils_rfc8040.unmount_device("ROADM-A1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
- def test_19_rdm_device_disconnected(self):
+ def test_34_rdm_device_disconnected(self):
response = test_utils_rfc8040.check_device_connection("ROADM-A1")
self.assertEqual(response['status_code'], requests.codes.conflict)
self.assertIn(response['connection-status']['error-type'], ('protocol', 'application'))
self.assertEqual(response['connection-status']['error-message'],
'Request could not be completed because the relevant data model content does not exist')
- def test_20_rdm_device_not_connected(self):
+ def test_35_rdm_device_not_connected(self):
response = test_utils_rfc8040.get_portmapping_node_info("ROADM-A1")
self.assertEqual(response['status_code'], requests.codes.conflict)
self.assertIn(response['node-info']['error-type'], ('protocol', 'application'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual("gainLoss", res['roadm-connections'][0]['opticalControlMode'])
- self.assertEqual(2.0, res['roadm-connections'][0]['target-output-power'])
+ self.assertEqual(0.21, res['roadm-connections'][0]['target-output-power'])
def test_22_get_roadmconnection_ROADMC(self):
response = test_utils.check_netconf_node_request(
self.cr_serv_sample_data["input"]["service-z-end"]["service-rate"] = "10"
self.cr_serv_sample_data["input"]["service-z-end"]["service-format"] = "Ethernet"
del self.cr_serv_sample_data["input"]["service-z-end"]["odu-service-rate"]
- self.cr_serv_sample_data["input"]["service-z-end"]["tx-direction"]["port"]["port-name"] = "XPDR1-NETWORK1"
- self.cr_serv_sample_data["input"]["service-z-end"]["rx-direction"]["port"]["port-name"] = "XPDR1-NETWORK1"
+ self.cr_serv_sample_data["input"]["service-z-end"]["tx-direction"]["port"]["port-name"] = "XPDR1-CLIENT1"
+ self.cr_serv_sample_data["input"]["service-z-end"]["rx-direction"]["port"]["port-name"] = "XPDR1-CLIENT1"
response = test_utils.service_create_request(self.cr_serv_sample_data)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
def setUp(self):
# pylint: disable=consider-using-f-string
print("execution of {}".format(self.id().split(".")[-1]))
- time.sleep(10)
+ time.sleep(1)
def test_01_xpdr_device_connection(self):
response = test_utils_rfc8040.mount_device("XPDR-A2",
response = test_utils_rfc8040.check_device_connection("XPDR-A2")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['connection-status'], 'connected')
- time.sleep(10)
# Check node info in the port-mappings
def test_03_xpdr_portmapping_info(self):
'node-vendor': 'vendorA',
'node-model': 'model'},
response['node-info'])
- time.sleep(3)
# Check the if-capabilities and the other details for network
def test_04_tpdr_portmapping_NETWORK1(self):
self.assertEqual(str(res['mc-capabilities'][0]['center-freq-granularity']), '3.125')
self.assertEqual(str(res['mc-capabilities'][0]['slot-width-granularity']), '6.25')
- def test_09_xpdr_device_disconnection(self):
+ def test_09_mpdr_switching_pool(self):
+ response = test_utils_rfc8040.portmapping_switching_pool_request("XPDR-A2", "1")
+ self.assertEqual(response['status_code'], requests.codes.ok)
+ self.assertEqual("blocking",
+ response['switching_pool'][0]['switching-pool-type'])
+ self.assertEqual(2,
+ len(response['switching_pool'][0]['non-blocking-list']))
+ self.assertIn(
+ {'nbl-number': 2,
+ 'interconnect-bandwidth': 0,
+ 'lcp-list': ['XPDR2-NETWORK1', 'XPDR2-CLIENT2']},
+ response['switching_pool'][0]['non-blocking-list'])
+
+ def test_10_xpdr_device_disconnection(self):
response = test_utils_rfc8040.unmount_device("XPDR-A2")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
- def test_10_xpdr_device_disconnected(self):
+ def test_11_xpdr_device_disconnected(self):
response = test_utils_rfc8040.check_device_connection("XPDR-A2")
self.assertEqual(response['status_code'], requests.codes.conflict)
self.assertIn(response['connection-status']['error-type'], ('protocol', 'application'))
self.assertEqual(response['connection-status']['error-message'],
'Request could not be completed because the relevant data model content does not exist')
- def test_11_xpdr_device_not_connected(self):
+ def test_12_xpdr_device_not_connected(self):
response = test_utils_rfc8040.get_portmapping_node_info("XPDR-A2")
self.assertEqual(response['status_code'], requests.codes.conflict)
self.assertIn(response['node-info']['error-type'], ('protocol', 'application'))
})
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn('Request processed', response['output']['result'])
+ # Here you have remove the added oducn supporting port interface
+ del self.NETWORK2_CHECK_DICT["supporting-oducn"]
def test_21_check_no_interface_oduc2(self):
response = test_utils_rfc8040.check_node_attribute_request("XPDR-A2", "interface", "XPDR2-NETWORK1-ODUC2")
self.assertEqual(response['status_code'], requests.codes.conflict)
+ # Check if port-mapping data is updated, where the supporting-oducn is deleted
+ def test_21a_check_no_oduc2(self):
+ response = test_utils_rfc8040.portmapping_request("XPDR-A2", "XPDR2-NETWORK1")
+ self.assertRaises(KeyError, lambda: response["supporting-oducn"])
+
# 1f) Delete OTUC2 device interfaces
+
def test_22_service_path_delete_otuc2(self):
response = test_utils_rfc8040.device_renderer_service_path_request(
{
})
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn('Request processed', response['output']['result'])
+ del self.NETWORK2_CHECK_DICT["supporting-otucn"]
def test_23_check_no_interface_otuc2(self):
response = test_utils_rfc8040.check_node_attribute_request("XPDR-A1", "interface", "XPDR2-NETWORK1-OTUC2")
response = test_utils_rfc8040.check_node_attribute_request("XPDR-A1", "interface", "XPDR2-NETWORK1-755:768")
self.assertEqual(response['status_code'], requests.codes.conflict)
+ def test_25a_check_no_otuc2(self):
+ response = test_utils_rfc8040.portmapping_request("XPDR-A2", "XPDR2-NETWORK1")
+ self.assertRaises(KeyError, lambda: response["supporting-otucn"])
+
# 2a) create a OTUC3 device renderer
def test_26_service_path_create_otuc3(self):
response = test_utils_rfc8040.device_renderer_service_path_request(
})
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn('Request processed', response['output']['result'])
+ del self.NETWORK2_CHECK_DICT["supporting-oducn"]
def test_35_check_no_interface_oduc3(self):
response = test_utils_rfc8040.check_node_attribute_request("XPDR-A2", "interface", "XPDR2-NETWORK1-ODUC3")
self.assertEqual(response['status_code'], requests.codes.conflict)
+ def test_35a_check_no_oduc3(self):
+ response = test_utils_rfc8040.portmapping_request("XPDR-A2", "XPDR2-NETWORK1")
+ self.assertRaises(KeyError, lambda: response["supporting-oducn"])
+
# 2f) Delete OTUC3 device interfaces
def test_36_service_path_delete_otuc3(self):
response = test_utils_rfc8040.device_renderer_service_path_request(
})
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn('Request processed', response['output']['result'])
+ del self.NETWORK2_CHECK_DICT["supporting-otucn"]
def test_37_check_no_interface_otuc3(self):
response = test_utils_rfc8040.check_node_attribute_request("XPDR-A1", "interface", "XPDR2-NETWORK1-OTUC3")
response = test_utils_rfc8040.check_node_attribute_request("XPDR-A1", "interface", "XPDR2-NETWORK1-755:768")
self.assertEqual(response['status_code'], requests.codes.conflict)
+ def test_39a_check_no_otuc3(self):
+ response = test_utils_rfc8040.portmapping_request("XPDR-A2", "XPDR2-NETWORK1")
+ self.assertRaises(KeyError, lambda: response["supporting-otucn"])
+
# 3a) create a OTUC4 device renderer
- def test_40_service_path_create_otuc3(self):
+ def test_40_service_path_create_otuc4(self):
response = test_utils_rfc8040.device_renderer_service_path_request(
{
'service-name': 'service_OTUC4',
})
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn('Request processed', response['output']['result'])
+ del self.NETWORK2_CHECK_DICT["supporting-oducn"]
def test_49_check_no_interface_oduc4(self):
response = test_utils_rfc8040.check_node_attribute_request("XPDR-A2", "interface", "XPDR2-NETWORK1-ODUC4")
self.assertEqual(response['status_code'], requests.codes.conflict)
+ def test_49a_check_no_oduc4(self):
+ response = test_utils_rfc8040.portmapping_request("XPDR-A2", "XPDR2-NETWORK1")
+ self.assertRaises(KeyError, lambda: response["supporting-oducn"])
+
# 3f) Delete OTUC4 device interfaces
def test_50_service_path_delete_otuc4(self):
response = test_utils_rfc8040.device_renderer_service_path_request(
})
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn('Request processed', response['output']['result'])
+ del self.NETWORK2_CHECK_DICT["supporting-otucn"]
def test_51_check_no_interface_otuc4(self):
response = test_utils_rfc8040.check_node_attribute_request("XPDR-A1", "interface", "XPDR2-NETWORK1-OTUC4")
response = test_utils_rfc8040.check_node_attribute_request("XPDR-A1", "interface", "XPDR2-NETWORK1-755:768")
self.assertEqual(response['status_code'], requests.codes.conflict)
+ def test_53a_check_no_otuc4(self):
+ response = test_utils_rfc8040.portmapping_request("XPDR-A2", "XPDR2-NETWORK1")
+ self.assertRaises(KeyError, lambda: response["supporting-otucn"])
+
# Disconnect the XPDR
def test_54_xpdr_device_disconnection(self):
response = test_utils_rfc8040.unmount_device("XPDR-A2")
'mapping': mapping}
+def portmapping_switching_pool_request(node: str, switching_pool: str):
+ url = {'rfc8040': '{}/data/transportpce-portmapping:network/nodes={}/switching-pool-lcp={}',
+ 'draft-bierman02': '{}/config/transportpce-portmapping:network/nodes/{}/switching-pool-lcp/{}'}
+ response = get_request(url[RESTCONF_VERSION].format('{}', node, switching_pool))
+ res = response.json()
+ return_key = {'rfc8040': 'transportpce-portmapping:switching-pool-lcp',
+ 'draft-bierman02': 'switching-pool-lcp'}
+ switching_pool = res[return_key[RESTCONF_VERSION]]
+ return {'status_code': response.status_code,
+ 'switching_pool': switching_pool}
+
+
def portmapping_mc_capa_request(node: str, mc_capa: str):
url = {'rfc8040': '{}/data/transportpce-portmapping:network/nodes={}/mc-capabilities={}',
'draft-bierman02': '{}/config/transportpce-portmapping:network/nodes/{}/mc-capabilities/{}'}