}
public String createOpenRoadmOdu4HOInterface(String nodeId, String logicalConnPoint, boolean isCTP,
- AEndApiInfo apiInfoA, ZEndApiInfo apiInfoZ, String payload) throws OpenRoadmInterfaceException {
+ AEndApiInfo apiInfoA, ZEndApiInfo apiInfoZ, String payloadType) throws OpenRoadmInterfaceException {
Mapping mapping = portMapping.getMapping(nodeId, logicalConnPoint);
if (mapping == null) {
throw new OpenRoadmInterfaceException(
oduFunction = ODUTTP.class;
monitoringMode = MonitoringMode.Terminated;
opu = new OpuBuilder()
- .setPayloadType(PayloadTypeDef.getDefaultInstance(payload))
- .setExpPayloadType(PayloadTypeDef.getDefaultInstance(payload))
+ .setPayloadType(PayloadTypeDef.getDefaultInstance(payloadType))
+ .setExpPayloadType(PayloadTypeDef.getDefaultInstance(payloadType))
.build();
}
OduBuilder oduIfBuilder = new OduBuilder()
import org.opendaylight.transportpce.common.mapping.PortMapping;
import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException;
import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev211004.az.api.info.AEndApiInfo;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev211004.az.api.info.ZEndApiInfo;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210927.mapping.Mapping;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.attributes.rev200327.TrailTraceOther.TimDetectMode;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.attributes.rev200327.parent.odu.allocation.ParentOduAllocationBuilder;
}
public String createOpenRoadmOtucnInterface(String nodeId, String logicalConnPoint,
- String supportingOtsiGroupInterface)
+ String supportingOtsiGroupInterface, AEndApiInfo apiInfoA, ZEndApiInfo apiInfoZ)
throws OpenRoadmInterfaceException {
- Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
- if (portMap == null) {
+ Mapping mapping = portMapping.getMapping(nodeId, logicalConnPoint);
+ if (mapping == null) {
throw new OpenRoadmInterfaceException(
String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
nodeId, logicalConnPoint));
.setDegmIntervals(Uint8.valueOf(2))
.setDegthrPercentage(Uint16.valueOf(100))
.setMaintLoopback(maintLoopbackBuilder.build());
-
- InterfaceBuilder otuInterfaceBuilder = createGenericInterfaceBuilder(portMap, OtnOtu.class,
- logicalConnPoint + "-OTUC4");
-
- // Create a list
- List<String> listSupportingOtsiGroupInterface = new ArrayList<>();
- listSupportingOtsiGroupInterface.add(supportingOtsiGroupInterface);
-
- otuInterfaceBuilder.setSupportingInterfaceList(listSupportingOtsiGroupInterface);
- org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev200529.Interface1Builder otuIf1Builder =
- new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev200529.Interface1Builder();
-
- otuInterfaceBuilder.addAugmentation(otuIf1Builder.setOtu(otuBuilder.build()).build());
-
- // Post interface on the device
- openRoadmInterfaces.postInterface(nodeId, otuInterfaceBuilder);
-
- // Post the equipment-state change on the device circuit-pack if xpdr node
- if (portMap.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
- this.openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true);
- }
-
- return otuInterfaceBuilder.getName();
-
- }
-
- // Adding method to have SAPI/DAPI information for the OTUCn
- public String createOpenRoadmOtucnInterface(String anodeId, String alogicalConnPoint,
- String supportingOtsiGroupInterface, String znodeId, String zlogicalConnPoint)
- throws OpenRoadmInterfaceException {
- Mapping portMapA = portMapping.getMapping(anodeId, alogicalConnPoint);
- Mapping portMapZ = portMapping.getMapping(znodeId, zlogicalConnPoint);
- if (portMapA == null) {
- throw new OpenRoadmInterfaceException(
- String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
- anodeId, alogicalConnPoint));
+ if (apiInfoA != null) {
+ otuBuilder.setTxSapi(apiInfoA.getSapi())
+ .setTxDapi(apiInfoA.getDapi())
+ .setExpectedSapi(apiInfoA.getExpectedSapi())
+ .setExpectedDapi(apiInfoA.getExpectedDapi());
}
- // On the Zside
- if (portMapZ == null) {
- throw new OpenRoadmInterfaceException(
- String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
- znodeId, zlogicalConnPoint));
-
+ if (apiInfoZ != null) {
+ otuBuilder.setTxSapi(apiInfoZ.getSapi())
+ .setTxDapi(apiInfoZ.getDapi())
+ .setExpectedSapi(apiInfoZ.getExpectedSapi())
+ .setExpectedDapi(apiInfoZ.getExpectedDapi());
}
- // Create an OTUCn object
- MaintLoopbackBuilder maintLoopbackBuilder = new MaintLoopbackBuilder();
- maintLoopbackBuilder.setEnabled(false);
- OtuBuilder otuBuilder = new OtuBuilder()
- .setRate(OTUCn.class)
- .setOtucnNRate(Uint16.valueOf(4))
- .setTimActEnabled(false)
- .setTimDetectMode(TimDetectMode.Disabled)
- .setDegmIntervals(Uint8.valueOf(2))
- .setDegthrPercentage(Uint16.valueOf(100))
- .setMaintLoopback(maintLoopbackBuilder.build())
- .setTxSapi(portMapA.getLcpHashVal())
- .setTxDapi(portMapZ.getLcpHashVal())
- // setting expected SAPI and DAPI values
- .setExpectedDapi(portMapA.getLcpHashVal())
- .setExpectedSapi(portMapZ.getLcpHashVal());
- InterfaceBuilder otuInterfaceBuilder = createGenericInterfaceBuilder(portMapA, OtnOtu.class,
- alogicalConnPoint + "-OTUC4");
+ InterfaceBuilder otuInterfaceBuilder = createGenericInterfaceBuilder(mapping, OtnOtu.class,
+ logicalConnPoint + "-OTUC4");
// Create a list
List<String> listSupportingOtsiGroupInterface = new ArrayList<>();
otuInterfaceBuilder.addAugmentation(otuIf1Builder.setOtu(otuBuilder.build()).build());
// Post interface on the device
- openRoadmInterfaces.postInterface(anodeId, otuInterfaceBuilder);
-
+ openRoadmInterfaces.postInterface(nodeId, otuInterfaceBuilder);
// Post the equipment-state change on the device circuit-pack if xpdr node
- if (portMapA.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
- this.openRoadmInterfaces.postEquipmentState(anodeId, portMapA.getSupportingCircuitPackName(), true);
+ if (mapping.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
+ this.openRoadmInterfaces.postEquipmentState(nodeId, mapping.getSupportingCircuitPackName(), true);
}
-
+ this.portMapping.updateMapping(nodeId, mapping);
return otuInterfaceBuilder.getName();
-
}
- public String createOpenRoadmOducnInterface(String nodeId, String logicalConnPoint,
- String supportingOtucn)
+ public String createOpenRoadmOducnInterface(String nodeId, String logicalConnPoint)
throws OpenRoadmInterfaceException {
- Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
- if (portMap == null) {
+ Mapping mapping = portMapping.getMapping(nodeId, logicalConnPoint);
+ if (mapping == null) {
throw new OpenRoadmInterfaceException(
String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
nodeId, logicalConnPoint));
.setOpu(opuBuilder.build())
.setMaintTestsignal(maintTestsignal.build());
- InterfaceBuilder oduInterfaceBuilder = createGenericInterfaceBuilder(portMap, OtnOdu.class,
- logicalConnPoint + ODUC4);
+ InterfaceBuilder oduInterfaceBuilder = createGenericInterfaceBuilder(mapping, OtnOdu.class,
+ logicalConnPoint + "-ODUC4");
// Create a list
List<String> listSupportingOtucnInterface = new ArrayList<>();
- listSupportingOtucnInterface.add(supportingOtucn);
+ if (mapping.getSupportingOtuc4() != null) {
+ listSupportingOtucnInterface.add(mapping.getSupportingOtuc4());
+ }
oduInterfaceBuilder.setSupportingInterfaceList(listSupportingOtucnInterface);
org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder oduIf1Builder =
openRoadmInterfaces.postInterface(nodeId, oduInterfaceBuilder);
// Post the equipment-state change on the device circuit-pack if xpdr node
- if (portMap.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
- this.openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true);
+ if (mapping.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
+ this.openRoadmInterfaces.postEquipmentState(nodeId, mapping.getSupportingCircuitPackName(), true);
}
return oduInterfaceBuilder.getName();
}
}
- /**
- * This methods creates an ODU interface on the given termination point.
- *
- * @param nodeId node ID
- * @param logicalConnPoint logical connection point
- * @param supportingOtuInterface supporting OTU interface
- * @return Name of the interface if successful, otherwise return null.
- * @throws OpenRoadmInterfaceException OpenRoadm interface exception
- */
-
- public String createOpenRoadmOdu4Interface(String nodeId, String logicalConnPoint, String supportingOtuInterface)
- throws OpenRoadmInterfaceException {
- switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
- case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
- return openRoadmInterface121.createOpenRoadmOdu4Interface(nodeId, logicalConnPoint);
- case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
- return openRoadmInterface221.createOpenRoadmOdu4Interface(nodeId, logicalConnPoint,
- supportingOtuInterface);
- case StringConstants.OPENROADM_DEVICE_VERSION_7_1:
- // Here ODUCn and ODUflex are combined
- String interfaceNameOduc4 = openRoadmInterface710.createOpenRoadmOducnInterface(nodeId,
- logicalConnPoint, supportingOtuInterface);
- return openRoadmInterface710.createOpenRoadmOduflexInterface(nodeId, logicalConnPoint,
- interfaceNameOduc4);
- default:
- return null;
- }
- }
-
- /**
- * This methods creates an ODU interface on the given termination point.
- *
- * @param anodeId node ID for A side
- * @param alogicalConnPoint logical connection point for A side
- * @param asupportingOtuInterface supporting OTU interface
- * @param znodeId node ID for Z side
- * @param zlogicalConnPoint logical connection point for Z side
- * @return Name of the interface if successful, otherwise return null.
- * @throws OpenRoadmInterfaceException OpenRoadm interface exception
- */
-
- public String createOpenRoadmOdu4Interface(String anodeId, String alogicalConnPoint, String asupportingOtuInterface,
- String znodeId, String zlogicalConnPoint)
- throws OpenRoadmInterfaceException {
- switch (mappingUtils.getOpenRoadmVersion(anodeId)) {
- case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
- return openRoadmInterface121.createOpenRoadmOdu4Interface(anodeId, alogicalConnPoint);
- case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
- return openRoadmInterface221.createOpenRoadmOdu4Interface(anodeId, alogicalConnPoint,
- asupportingOtuInterface, znodeId, zlogicalConnPoint);
- case StringConstants.OPENROADM_DEVICE_VERSION_7_1:
- // Here ODUCn and ODUflex are combined
- String interfaceNameOduc4 = openRoadmInterface710.createOpenRoadmOducnInterface(anodeId,
- alogicalConnPoint, asupportingOtuInterface, znodeId, zlogicalConnPoint);
- return openRoadmInterface710.createOpenRoadmOduflexInterface(anodeId, alogicalConnPoint,
- interfaceNameOduc4, znodeId, zlogicalConnPoint);
- default:
- return null;
- }
- }
-
/**
* This methods creates an ODU interface on the given termination point.
*
* @param isCTP to distinguish with a TTP odu interface
* @param apiInfoA sapi and dapi for A end of the service
* @param apiInfoZ sapi and dapi for Z end of the service
- * @param payload payload type of the OPU container
+ * @param payloadType payload type of the opu when terminated
* @return Name of the interface if successful, otherwise return null.
* @throws OpenRoadmInterfaceException OpenRoadm interface exception
*/
public String createOpenRoadmOdu4HOInterface(String nodeId, String logicalConnPoint, boolean isCTP,
- AEndApiInfo apiInfoA, ZEndApiInfo apiInfoZ, String payload) throws OpenRoadmInterfaceException {
+ AEndApiInfo apiInfoA, ZEndApiInfo apiInfoZ, String payloadType)
+ throws OpenRoadmInterfaceException {
+
switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
return openRoadmInterface121.createOpenRoadmOdu4Interface(nodeId, logicalConnPoint);
case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
return openRoadmInterface221.createOpenRoadmOdu4HOInterface(nodeId, logicalConnPoint, isCTP,
- apiInfoA, apiInfoZ, payload);
+ apiInfoA, apiInfoZ, payloadType);
+ case StringConstants.OPENROADM_DEVICE_VERSION_7_1:
+ return openRoadmInterface710.createOpenRoadmOducnInterface(nodeId, logicalConnPoint);
default:
return null;
}
* @param supportOchInterface supporting OCH interface
* @param apiInfoA sapi and dapi for A end of the service
* @param apiInfoZ sapi and dapi for Z end of the service
+ * @return Name of the interface if successful, otherwise return null.
* @throws OpenRoadmInterfaceException OpenRoadm interface exception
*/
public String createOpenRoadmOtu4Interface(String nodeId, String logicalConnPoint, String supportOchInterface,
- AEndApiInfo apiInfoA, ZEndApiInfo apiInfoZ) throws OpenRoadmInterfaceException {
+ AEndApiInfo apiInfoA, ZEndApiInfo apiInfoZ)
+ throws OpenRoadmInterfaceException {
+
switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
return openRoadmInterface121
apiInfoA, apiInfoZ);
case StringConstants.OPENROADM_DEVICE_VERSION_7_1:
return openRoadmInterface710.createOpenRoadmOtucnInterface(nodeId, logicalConnPoint,
- supportOchInterface);
+ supportOchInterface, apiInfoA, apiInfoZ);
default:
return null;
}
}
}
- public String createOpenRoadmEth1GInterface(String nodeId,
- String logicalConnPoint) throws OpenRoadmInterfaceException {
+ public String createOpenRoadmEth1GInterface(String nodeId,String logicalConnPoint)
+ throws OpenRoadmInterfaceException {
+
switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG);
}
}
- public String createOpenRoadmEth10GInterface(String nodeId,
- String logicalConnPoint) throws OpenRoadmInterfaceException {
+ public String createOpenRoadmEth10GInterface(String nodeId, String logicalConnPoint)
+ throws OpenRoadmInterfaceException {
+
switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG);
default:
return null;
}
-
}
- public String createOpenRoadmEth100GInterface(String nodeId,
- String logicalConnPoint) throws OpenRoadmInterfaceException {
+ public String createOpenRoadmEth100GInterface(String nodeId, String logicalConnPoint)
+ throws OpenRoadmInterfaceException {
switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
default:
return null;
}
-
}
public String createOpenRoadmOdu0Interface(String nodeId, String logicalConnPoint, String servicename,
- String payLoad, boolean isNetworkPort, int tribPortNumber, int tribSlot)
+ boolean isCTP, int tribPortNumber, int tribSlotIndex, AEndApiInfo apiInfoA, ZEndApiInfo apiInfoZ,
+ String payLoadType)
throws OpenRoadmInterfaceException {
+
switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG);
return null;
case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
- return openRoadmOtnInterface221.createOpenRoadmOdu0Interface(
- nodeId, logicalConnPoint, servicename, payLoad, isNetworkPort, tribPortNumber, tribSlot);
+ return openRoadmOtnInterface221.createOpenRoadmOdu0Interface(nodeId, logicalConnPoint, servicename,
+ isCTP, tribPortNumber, tribSlotIndex, apiInfoA, apiInfoZ, payLoadType);
default:
return null;
}
}
public String createOpenRoadmOdu2Interface(String nodeId, String logicalConnPoint, String servicename,
- String payLoad, boolean isNetworkPort, int tribPortNumber, int tribSlotIndex)
+ boolean isCTP, int tribPortNumber, int tribSlotIndex, AEndApiInfo apiInfoA, ZEndApiInfo apiInfoZ,
+ String payLoadType)
throws OpenRoadmInterfaceException {
switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG);
return null;
case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
- return openRoadmOtnInterface221.createOpenRoadmOdu2Interface(
- nodeId, logicalConnPoint, servicename, payLoad, isNetworkPort, tribPortNumber, tribSlotIndex);
+ return openRoadmOtnInterface221.createOpenRoadmOdu2Interface(nodeId, logicalConnPoint, servicename,
+ isCTP, tribPortNumber, tribSlotIndex, apiInfoA, apiInfoZ, payLoadType);
default:
return null;
}
}
public String createOpenRoadmOdu2eInterface(String nodeId, String logicalConnPoint, String servicename,
- boolean isCTP, int tribPortNumber, int tribSlotIndex, AEndApiInfo apiInfoA, ZEndApiInfo apiInfoZ)
+ boolean isCTP, int tribPortNumber, int tribSlotIndex, AEndApiInfo apiInfoA, ZEndApiInfo apiInfoZ,
+ String payLoadType)
throws OpenRoadmInterfaceException {
+
switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG);
return null;
case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
return openRoadmOtnInterface221.createOpenRoadmOdu2eInterface(nodeId, logicalConnPoint, servicename,
- isCTP, tribPortNumber, tribSlotIndex, apiInfoA, apiInfoZ);
+ isCTP, tribPortNumber, tribSlotIndex, apiInfoA, apiInfoZ, payLoadType);
default:
return null;
}
-
}
public String createOpenRoadmOtnOdu4LoInterface(String nodeId, String logicalConnPoint,
}
}
- public String createOpenRoadmOtnOdu4Interface(String nodeId, String logicalConnPoint, String supportingOtuInterface)
- throws OpenRoadmInterfaceException {
- switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
- case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
- return openRoadmInterface221
- .createOpenRoadmOtnOdu4Interface(nodeId, logicalConnPoint, supportingOtuInterface);
- default:
- return null;
- }
- }
public String createOpenRoadmOtnOdu4Interface(String anodeId, String alogicalConnPoint,
String asupportingOtuInterface, String znodeId, String zlogicalConnPoint)
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.OduFunctionIdentity;
import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.PayloadTypeDef;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.OduAttributes;
import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.OduAttributes.MonitoringMode;
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.odu.interfaces.rev181019.opu.Opu;
}
public String createOpenRoadmOdu2eInterface(String nodeId, String logicalConnPoint, String serviceName,
- boolean isCTP, int tribPortNumber, int tribSlotIndex, AEndApiInfo apiInfoA, ZEndApiInfo apiInfoZ)
- throws OpenRoadmInterfaceException {
+ boolean isCTP, int tribPortNumber, int tribSlotIndex, AEndApiInfo apiInfoA, ZEndApiInfo apiInfoZ,
+ String payloadType) throws OpenRoadmInterfaceException {
Mapping mapping = this.portMapping.getMapping(nodeId, logicalConnPoint);
if (mapping == null) {
oduFunction = ODUTTPCTP.class;
monitoringMode = MonitoringMode.Terminated;
opu = new OpuBuilder()
- .setPayloadType(PayloadTypeDef.getDefaultInstance("03"))
- .setExpPayloadType(PayloadTypeDef.getDefaultInstance("03"))
+ .setPayloadType(PayloadTypeDef.getDefaultInstance(payloadType))
+ .setExpPayloadType(PayloadTypeDef.getDefaultInstance(payloadType))
.build();
}
OduBuilder oduIfBuilder = new OduBuilder()
return oduInterfaceBldr.getName();
}
- public String createOpenRoadmOdu0Interface(String nodeId,
- String logicalConnPoint, String serviceName, String payLoad,
- boolean isNetworkPort, int tribPortNumber, int tribSlot)
- throws OpenRoadmInterfaceException {
- Mapping portMap = this.portMapping.getMapping(nodeId, logicalConnPoint);
- String supportingInterface = null;
+ public String createOpenRoadmOdu0Interface(String nodeId, String logicalConnPoint, String serviceName,
+ boolean isCTP, int tribPortNumber, int tribSlotIndex, AEndApiInfo apiInfoA, ZEndApiInfo apiInfoZ,
+ String payloadType) throws OpenRoadmInterfaceException {
- if (isNetworkPort) {
- supportingInterface = portMap.getSupportingOdu4();
- } else {
- supportingInterface = logicalConnPoint + "-ETHERNET1G";
+ Mapping mapping = this.portMapping.getMapping(nodeId, logicalConnPoint);
+ if (mapping == null) {
+ throw new OpenRoadmInterfaceException(
+ String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
}
- if (portMap == null) {
- throwException(nodeId, logicalConnPoint);
+ InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(mapping, OtnOdu.class,
+ logicalConnPoint + "-ODU0-" + serviceName);
+ if (mapping.getSupportingOdu4() != null) {
+ oduInterfaceBldr.setSupportingInterface(mapping.getSupportingOdu4());
+ }
+ if (mapping.getSupportingEthernet() != null) {
+ oduInterfaceBldr.setSupportingInterface(mapping.getSupportingEthernet());
}
- InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(
- portMap, OtnOdu.class,
- logicalConnPoint + "-ODU0-" + serviceName);
- oduInterfaceBldr.setSupportingInterface(supportingInterface);
- // ODU interface specific data
- OduBuilder oduIfBuilder = new OduBuilder().setRate(ODU0.class)
- .setOduFunction(ODUTTPCTP.class)
- .setMonitoringMode(OduAttributes.MonitoringMode.Terminated);
- if (isNetworkPort) {
- LOG.debug("Network port is true");
+ Class<? extends OduFunctionIdentity> oduFunction;
+ MonitoringMode monitoringMode;
+ Opu opu = null;
+ ParentOduAllocation parentOduAllocation = null;
+ if (isCTP) {
+ oduFunction = ODUCTP.class;
+ monitoringMode = MonitoringMode.Monitored;
List<Uint16> tribSlots = new ArrayList<>();
- // add trib slots
- tribSlots.add(Uint16.valueOf(tribSlot));
- ParentOduAllocationBuilder parentOduAllocationBuilder = new ParentOduAllocationBuilder()
- // set trib port numbers
+ Uint16 newIdx = Uint16.valueOf(tribSlotIndex);
+ tribSlots.add(newIdx);
+ IntStream.range(tribSlotIndex, tribSlotIndex + 8)
+ .forEach(nbr -> tribSlots.add(Uint16.valueOf(nbr)));
+ parentOduAllocation = new ParentOduAllocationBuilder()
.setTribPortNumber(Uint16.valueOf(tribPortNumber))
- .setTribSlots(tribSlots);
- oduIfBuilder.setOduFunction(ODUCTP.class)
- .setMonitoringMode(OduAttributes.MonitoringMode.Monitored)
- .setParentOduAllocation(parentOduAllocationBuilder.build());
- LOG.debug("Network port is true {} {} {}",
- oduIfBuilder.getParentOduAllocation().getTribSlots(),
- oduIfBuilder.getRate(),
- oduIfBuilder.getParentOduAllocation().getTribPortNumber());
+ .setTribSlots(tribSlots)
+ .build();
} else {
- LOG.debug("Current port is a client port");
- OpuBuilder opuBldr = new OpuBuilder()
- .setPayloadType(new PayloadTypeDef(payLoad))
- .setExpPayloadType(new PayloadTypeDef(payLoad));
- oduIfBuilder.setOpu(opuBldr.build());
+ oduFunction = ODUTTPCTP.class;
+ monitoringMode = MonitoringMode.Terminated;
+ opu = new OpuBuilder()
+ .setPayloadType(PayloadTypeDef.getDefaultInstance(payloadType))
+ .setExpPayloadType(PayloadTypeDef.getDefaultInstance(payloadType))
+ .build();
+ }
+ OduBuilder oduIfBuilder = new OduBuilder()
+ .setRate(ODU0.class)
+ .setOduFunction(oduFunction)
+ .setMonitoringMode(monitoringMode)
+ .setOpu(opu)
+ .setParentOduAllocation(parentOduAllocation);
+ if (apiInfoA != null) {
+ oduIfBuilder.setTxSapi(apiInfoA.getSapi())
+ .setTxDapi(apiInfoA.getDapi())
+ .setExpectedSapi(apiInfoA.getExpectedSapi())
+ .setExpectedDapi(apiInfoA.getExpectedDapi());
+ }
+ if (apiInfoZ != null) {
+ oduIfBuilder.setTxSapi(apiInfoZ.getSapi())
+ .setTxDapi(apiInfoZ.getDapi())
+ .setExpectedSapi(apiInfoZ.getExpectedSapi())
+ .setExpectedDapi(apiInfoZ.getExpectedDapi());
}
// Create Interface1 type object required for adding as augmentation
// TODO look at imports of different versions of class
org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder
oduIf1Builder = new
- org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder();
+ org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder();
oduInterfaceBldr.addAugmentation(oduIf1Builder.setOdu(oduIfBuilder.build()).build());
// Post interface on the device
this.openRoadmInterfaces.postOTNInterface(nodeId, oduInterfaceBldr);
- LOG.info("returning the ODU0 inteface {}", oduInterfaceBldr.getName());
+ if (!isCTP) {
+ LOG.info("{}-{} updating mapping with interface {}", nodeId, logicalConnPoint, oduInterfaceBldr.getName());
+ this.portMapping.updateMapping(nodeId, mapping);
+ }
return oduInterfaceBldr.getName();
}
- public String createOpenRoadmOdu2Interface(String nodeId,
- String logicalConnPoint, String serviceName, String payLoad,
- boolean isNetworkPort, int tribPortNumber, int tribSlotIndex)
- throws OpenRoadmInterfaceException {
- Mapping portMap = this.portMapping.getMapping(nodeId, logicalConnPoint);
- String supportingInterface = null;
+ public String createOpenRoadmOdu2Interface(String nodeId, String logicalConnPoint, String serviceName,
+ boolean isCTP, int tribPortNumber, int tribSlotIndex, AEndApiInfo apiInfoA, ZEndApiInfo apiInfoZ,
+ String payloadType) throws OpenRoadmInterfaceException {
- if (portMap != null) {
- if (isNetworkPort) {
- supportingInterface = portMap.getSupportingOdu4();
- } else {
- supportingInterface = portMap.getSupportingEthernet();
- }
- } else {
- throwException(nodeId, logicalConnPoint);
+ Mapping mapping = this.portMapping.getMapping(nodeId, logicalConnPoint);
+ if (mapping == null) {
+ throw new OpenRoadmInterfaceException(
+ String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
+ }
+ InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(mapping, OtnOdu.class,
+ logicalConnPoint + "-ODU2-" + serviceName);
+ if (mapping.getSupportingOdu4() != null) {
+ oduInterfaceBldr.setSupportingInterface(mapping.getSupportingOdu4());
+ }
+ if (mapping.getSupportingEthernet() != null) {
+ oduInterfaceBldr.setSupportingInterface(mapping.getSupportingEthernet());
}
- InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(
- portMap, OtnOdu.class,
- logicalConnPoint + "-ODU2-" + serviceName)
- .setSupportingInterface(supportingInterface);
- OduBuilder oduIfBuilder = new OduBuilder().setRate(ODU2.class)
- .setOduFunction(ODUTTPCTP.class)
- .setMonitoringMode(OduAttributes.MonitoringMode.Terminated);
- if (isNetworkPort) {
+ Class<? extends OduFunctionIdentity> oduFunction;
+ MonitoringMode monitoringMode;
+ Opu opu = null;
+ ParentOduAllocation parentOduAllocation = null;
+ if (isCTP) {
+ oduFunction = ODUCTP.class;
+ monitoringMode = MonitoringMode.Monitored;
List<Uint16> tribSlots = new ArrayList<>();
+ Uint16 newIdx = Uint16.valueOf(tribSlotIndex);
+ tribSlots.add(newIdx);
IntStream.range(tribSlotIndex, tribSlotIndex + 8)
.forEach(nbr -> tribSlots.add(Uint16.valueOf(nbr)));
- ParentOduAllocationBuilder parentOduAllocationBuilder = new ParentOduAllocationBuilder()
- // set trib port numbers
+ parentOduAllocation = new ParentOduAllocationBuilder()
.setTribPortNumber(Uint16.valueOf(tribPortNumber))
- .setTribSlots(tribSlots);
- oduIfBuilder.setOduFunction(ODUCTP.class)
- .setMonitoringMode(OduAttributes.MonitoringMode.Monitored)
- .setParentOduAllocation(parentOduAllocationBuilder.build());
+ .setTribSlots(tribSlots)
+ .build();
} else {
- // Set Opu attributes
- OpuBuilder opuBldr = new OpuBuilder()
- .setPayloadType(new PayloadTypeDef(payLoad))
- .setExpPayloadType(new PayloadTypeDef(payLoad));
- oduIfBuilder.setOpu(opuBldr.build());
+ oduFunction = ODUTTPCTP.class;
+ monitoringMode = MonitoringMode.Terminated;
+ opu = new OpuBuilder()
+ .setPayloadType(PayloadTypeDef.getDefaultInstance(payloadType))
+ .setExpPayloadType(PayloadTypeDef.getDefaultInstance(payloadType))
+ .build();
+ }
+ OduBuilder oduIfBuilder = new OduBuilder()
+ .setRate(ODU2.class)
+ .setOduFunction(oduFunction)
+ .setMonitoringMode(monitoringMode)
+ .setOpu(opu)
+ .setParentOduAllocation(parentOduAllocation);
+ if (apiInfoA != null) {
+ oduIfBuilder.setTxSapi(apiInfoA.getSapi())
+ .setTxDapi(apiInfoA.getDapi())
+ .setExpectedSapi(apiInfoA.getExpectedSapi())
+ .setExpectedDapi(apiInfoA.getExpectedDapi());
+ }
+ if (apiInfoZ != null) {
+ oduIfBuilder.setTxSapi(apiInfoZ.getSapi())
+ .setTxDapi(apiInfoZ.getDapi())
+ .setExpectedSapi(apiInfoZ.getExpectedSapi())
+ .setExpectedDapi(apiInfoZ.getExpectedDapi());
}
-
- // Create Interface1 type object required for adding as augmentation
- // TODO look at imports of different versions of class
// Create Interface1 type object required for adding as augmentation
// TODO look at imports of different versions of class
org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder
// Post interface on the device
this.openRoadmInterfaces.postOTNInterface(nodeId, oduInterfaceBldr);
- LOG.info("returning the ODU2 inteface {}", oduInterfaceBldr.getName());
+ if (!isCTP) {
+ LOG.info("{}-{} updating mapping with interface {}", nodeId, logicalConnPoint, oduInterfaceBldr.getName());
+ this.portMapping.updateMapping(nodeId, mapping);
+ }
return oduInterfaceBldr.getName();
}
}
public class DeviceRendererServiceImpl implements DeviceRendererService {
private static final String IS_NOT_MOUNTED_ON_THE_CONTROLLER = " is not mounted on the controller";
private static final Logger LOG = LoggerFactory.getLogger(DeviceRendererServiceImpl.class);
+ private static final String PT_07 = "07";
private final DataBroker dataBroker;
private final DeviceTransactionManager deviceTransactionManager;
private final OpenRoadmInterfaceFactory openRoadmInterfaceFactory;
otnLinkTps.add(new LinkTpBuilder().setNodeId(nodeId).setTpId(destTp).build());
} else {
createdOduInterfaces.add(this.openRoadmInterfaceFactory.createOpenRoadmOdu4HOInterface(
- nodeId, destTp, false, apiInfoA, apiInfoZ, "07"));
+ nodeId, destTp, false, apiInfoA, apiInfoZ, PT_07));
}
}
if ((srcTp != null) && srcTp.contains(StringConstants.CLIENT_TOKEN)) {
String supportingOtuInterface = this.openRoadmInterfaceFactory.createOpenRoadmOtu4Interface(
nodeId, srcTp, supportingOchInterface, apiInfoA, apiInfoZ);
createdOtuInterfaces.add(supportingOtuInterface);
- createdOduInterfaces.add(this.openRoadmInterfaceFactory.createOpenRoadmOdu4Interface(
- nodeId, srcTp, supportingOtuInterface));
- Mapping mapping = this.portMapping.getMapping(nodeId,srcTp);
- createdOduInterfaces.add(
- mapping != null
- && mapping.getXponderType() != null
- && (mapping.getXponderType().getIntValue() == 3
- || mapping.getXponderType().getIntValue() == 2)
- ? this.openRoadmInterfaceFactory.createOpenRoadmOtnOdu4Interface(
- nodeId, destTp, supportingOtuInterface)
- : this.openRoadmInterfaceFactory.createOpenRoadmOdu4Interface(
- nodeId, destTp, supportingOtuInterface));
+ if (destTp == null) {
+ otnLinkTps.add(new LinkTpBuilder().setNodeId(nodeId).setTpId(srcTp).build());
+ } else {
+ createdOduInterfaces.add(this.openRoadmInterfaceFactory.createOpenRoadmOdu4HOInterface(
+ nodeId, srcTp, false, apiInfoA, apiInfoZ, PT_07));
+ }
}
if ((destTp != null) && destTp.contains(StringConstants.CLIENT_TOKEN)) {
LOG.info("Adding supporting EThernet interface for node {}, dest tp {}", nodeId, destTp);
createdOduInterfaces.add(
// suppporting interface?, payload ?
openRoadmInterfaceFactory.createOpenRoadmOdu0Interface(node.getNodeId(), node.getClientTp(),
- input.getServiceName(), PT_07, false, input.getTribPortNumber(), input.getTribSlot()));
+ input.getServiceName(), false, input.getTribPortNumber(), input.getTribSlot(), apiInfoA,
+ apiInfoZ, PT_07));
}
createdOduInterfaces.add(
openRoadmInterfaceFactory.createOpenRoadmOdu0Interface(node.getNodeId(), node.getNetworkTp(),
- input.getServiceName(), PT_07, true, input.getTribPortNumber(), input.getTribSlot()));
+ input.getServiceName(), true, input.getTribPortNumber(), input.getTribSlot(), null, null,
+ null));
linkTpList.add(
new LinkTpBuilder().setNodeId(node.getNodeId()).setTpId(node.getNetworkTp()).build());
if (node.getNetwork2Tp() != null) {
createdOduInterfaces.add(
// supporting interface? payload ?
openRoadmInterfaceFactory.createOpenRoadmOdu0Interface(node.getNodeId(),
- node.getNetwork2Tp(), input.getServiceName(), PT_07, true, input.getTribPortNumber(),
- input.getTribSlot()));
+ node.getNetwork2Tp(), input.getServiceName(), true, input.getTribPortNumber(),
+ input.getTribSlot(), null, null, null));
linkTpList.add(
new LinkTpBuilder().setNodeId(node.getNodeId()).setTpId(node.getNetworkTp()).build());
}
// suppporting interface?, payload ?
openRoadmInterfaceFactory.createOpenRoadmOdu2eInterface(node.getNodeId(),
node.getClientTp(), input.getServiceName(), false, input.getTribPortNumber(),
- input.getTribSlot(), apiInfoA, apiInfoZ));
+ input.getTribSlot(), apiInfoA, apiInfoZ, PT_03));
}
createdOduInterfaces.add(
// supporting interface? payload ?
openRoadmInterfaceFactory.createOpenRoadmOdu2eInterface(node.getNodeId(), node.getNetworkTp(),
- input.getServiceName(), true, input.getTribPortNumber(), input.getTribSlot(), apiInfoA,
- apiInfoZ));
+ input.getServiceName(), true, input.getTribPortNumber(), input.getTribSlot(), null,
+ null, null));
linkTpList.add(
new LinkTpBuilder().setNodeId(node.getNodeId()).setTpId(node.getNetworkTp()).build());
if (node.getNetwork2Tp() != null) {
// supporting interface? payload ?
openRoadmInterfaceFactory.createOpenRoadmOdu2eInterface(node.getNodeId(),
node.getNetwork2Tp(), input.getServiceName(), true, input.getTribPortNumber(),
- input.getTribSlot(), apiInfoA, apiInfoZ));
+ input.getTribSlot(), null, null, null));
linkTpList.add(
new LinkTpBuilder().setNodeId(node.getNodeId()).setTpId(node.getNetworkTp()).build());
}
node.getNodeId(), node.getClientTp(), false, apiInfoA, apiInfoZ, "21"));
// supporting interface? payload ?
createdOduInterfaces.add(openRoadmInterfaceFactory.createOpenRoadmOdu4HOInterface(
- node.getNodeId(), node.getNetworkTp(), true, null, null, "21"));
+ node.getNodeId(), node.getNetworkTp(), true, null, null, null));
linkTpList.add(new LinkTpBuilder().setNodeId(node.getNodeId()).setTpId(node.getClientTp())
.build());
}
if (node.getClientTp() == null && node.getNetwork2Tp() != null) {
// supporting interface? payload ?
createdOduInterfaces.add(openRoadmInterfaceFactory.createOpenRoadmOdu4HOInterface(
- node.getNodeId(), node.getNetworkTp(), true, null, null, "21"));
+ node.getNodeId(), node.getNetworkTp(), true, null, null, null));
createdOduInterfaces.add(openRoadmInterfaceFactory.createOpenRoadmOdu4HOInterface(
- node.getNodeId(), node.getNetwork2Tp(), true, null, null, "21"));
+ node.getNodeId(), node.getNetwork2Tp(), true, null, null, null));
}
break;
default:
print("all processes killed")
def setUp(self):
- time.sleep(5)
+ time.sleep(2)
- def test_01_connect_spdrA(self):
+ def test_001_connect_spdrA(self):
response = test_utils.mount_device("SPDR-SA1", ('spdra', self.NODE_VERSION))
self.assertEqual(response.status_code,
requests.codes.created, test_utils.CODE_SHOULD_BE_201)
- def test_02_connect_spdrB(self):
+ def test_002_connect_spdrB(self):
response = test_utils.mount_device("SPDR-SB1", ('spdrb', self.NODE_VERSION))
self.assertEqual(response.status_code,
requests.codes.created, test_utils.CODE_SHOULD_BE_201)
- def test_03_connect_spdrC(self):
+ def test_003_connect_spdrC(self):
response = test_utils.mount_device("SPDR-SC1", ('spdrc', self.NODE_VERSION))
self.assertEqual(response.status_code,
requests.codes.created, test_utils.CODE_SHOULD_BE_201)
- def test_04_connect_rdmA(self):
+ def test_004_connect_rdmA(self):
response = test_utils.mount_device("ROADM-A1", ('roadma', self.NODE_VERSION))
self.assertEqual(response.status_code,
requests.codes.created, test_utils.CODE_SHOULD_BE_201)
- def test_05_connect_rdmB(self):
+ def test_005_connect_rdmB(self):
response = test_utils.mount_device("ROADM-B1", ('roadmb', self.NODE_VERSION))
self.assertEqual(response.status_code,
requests.codes.created, test_utils.CODE_SHOULD_BE_201)
- def test_06_connect_rdmC(self):
+ def test_006_connect_rdmC(self):
response = test_utils.mount_device("ROADM-C1", ('roadmc', self.NODE_VERSION))
self.assertEqual(response.status_code,
requests.codes.created, test_utils.CODE_SHOULD_BE_201)
- def test_07_connect_sprdA_2_N1_to_roadmA_PP3(self):
+ def test_007_connect_sprdA_2_N1_to_roadmA_PP3(self):
response = test_utils.connect_xpdr_to_rdm_request("SPDR-SA1", "2", "1",
"ROADM-A1", "1", "SRG1-PP3-TXRX")
self.assertEqual(response.status_code, requests.codes.ok)
res["output"]["result"])
time.sleep(2)
- def test_08_connect_roadmA_PP3_to_spdrA_2_N1(self):
+ def test_008_connect_roadmA_PP3_to_spdrA_2_N1(self):
response = test_utils.connect_rdm_to_xpdr_request("SPDR-SA1", "2", "1",
"ROADM-A1", "1", "SRG1-PP3-TXRX")
self.assertEqual(response.status_code, requests.codes.ok)
res["output"]["result"])
time.sleep(2)
- def test_09_connect_sprdC_2_N1_to_roadmC_PP3(self):
+ def test_009_connect_sprdC_2_N1_to_roadmC_PP3(self):
response = test_utils.connect_xpdr_to_rdm_request("SPDR-SC1", "2", "1",
"ROADM-C1", "1", "SRG1-PP3-TXRX")
self.assertEqual(response.status_code, requests.codes.ok)
res["output"]["result"])
time.sleep(2)
- def test_10_connect_roadmC_PP3_to_spdrC_2_N1(self):
+ def test_010_connect_roadmC_PP3_to_spdrC_2_N1(self):
response = test_utils.connect_rdm_to_xpdr_request("SPDR-SC1", "2", "1",
"ROADM-C1", "1", "SRG1-PP3-TXRX")
self.assertEqual(response.status_code, requests.codes.ok)
res["output"]["result"])
time.sleep(2)
- def test_11_connect_sprdB_2_N1_to_roadmB_PP1(self):
+ def test_011_connect_sprdB_2_N1_to_roadmB_PP1(self):
response = test_utils.connect_xpdr_to_rdm_request("SPDR-SB1", "2", "1",
"ROADM-B1", "1", "SRG1-PP1-TXRX")
self.assertEqual(response.status_code, requests.codes.ok)
res["output"]["result"])
time.sleep(2)
- def test_12_connect_roadmB_PP1_to_spdrB_2_N1(self):
+ def test_012_connect_roadmB_PP1_to_spdrB_2_N1(self):
response = test_utils.connect_rdm_to_xpdr_request("SPDR-SB1", "2", "1",
"ROADM-B1", "1", "SRG1-PP1-TXRX")
self.assertEqual(response.status_code, requests.codes.ok)
res["output"]["result"])
time.sleep(2)
- def test_13_connect_sprdB_2_N2_to_roadmB_PP2(self):
+ def test_013_connect_sprdB_2_N2_to_roadmB_PP2(self):
response = test_utils.connect_xpdr_to_rdm_request("SPDR-SB1", "2", "2",
"ROADM-B1", "1", "SRG1-PP2-TXRX")
self.assertEqual(response.status_code, requests.codes.ok)
res["output"]["result"])
time.sleep(2)
- def test_14_connect_roadmB_PP2_to_spdrB_2_N2(self):
+ def test_014_connect_roadmB_PP2_to_spdrB_2_N2(self):
response = test_utils.connect_rdm_to_xpdr_request("SPDR-SB1", "2", "2",
"ROADM-B1", "1", "SRG1-PP2-TXRX")
self.assertEqual(response.status_code, requests.codes.ok)
res["output"]["result"])
time.sleep(2)
- def test_15_add_omsAttributes_ROADMA_ROADMB(self):
+ def test_015_add_omsAttributes_ROADMA_ROADMB(self):
# Config ROADMA-ROADMB oms-attributes
data = {"span": {
"auto-spanloss": "true",
"ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX", data)
self.assertEqual(response.status_code, requests.codes.created)
- def test_16_add_omsAttributes_ROADMB_ROADMA(self):
+ def test_016_add_omsAttributes_ROADMB_ROADMA(self):
# Config ROADMB-ROADMA oms-attributes
data = {"span": {
"auto-spanloss": "true",
"ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX", data)
self.assertEqual(response.status_code, requests.codes.created)
- def test_17_add_omsAttributes_ROADMB_ROADMC(self):
+ def test_017_add_omsAttributes_ROADMB_ROADMC(self):
# Config ROADMB-ROADMC oms-attributes
data = {"span": {
"auto-spanloss": "true",
"ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX", data)
self.assertEqual(response.status_code, requests.codes.created)
- def test_18_add_omsAttributes_ROADMC_ROADMB(self):
+ def test_018_add_omsAttributes_ROADMC_ROADMB(self):
# Config ROADMC-ROADMB oms-attributes
data = {"span": {
"auto-spanloss": "true",
"ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX", data)
self.assertEqual(response.status_code, requests.codes.created)
- def test_19_create_OTS_ROADMA_DEG1(self):
+ def test_019_create_OTS_ROADMA_DEG1(self):
response = test_utils.create_ots_oms_request("ROADM-A1", "DEG1-TTP-TXRX")
time.sleep(10)
self.assertEqual(response.status_code, requests.codes.ok)
self.assertIn('Interfaces OTS-DEG1-TTP-TXRX - OMS-DEG1-TTP-TXRX successfully created on node ROADM-A1',
res["output"]["result"])
- def test_20_create_OTS_ROADMB_DEG1(self):
+ def test_020_create_OTS_ROADMB_DEG1(self):
response = test_utils.create_ots_oms_request("ROADM-B1", "DEG1-TTP-TXRX")
time.sleep(10)
self.assertEqual(response.status_code, requests.codes.ok)
self.assertIn('Interfaces OTS-DEG1-TTP-TXRX - OMS-DEG1-TTP-TXRX successfully created on node ROADM-B1',
res["output"]["result"])
- def test_21_create_OTS_ROADMB_DEG2(self):
+ def test_021_create_OTS_ROADMB_DEG2(self):
response = test_utils.create_ots_oms_request("ROADM-B1", "DEG2-TTP-TXRX")
time.sleep(10)
self.assertEqual(response.status_code, requests.codes.ok)
self.assertIn('Interfaces OTS-DEG2-TTP-TXRX - OMS-DEG2-TTP-TXRX successfully created on node ROADM-B1',
res["output"]["result"])
- def test_22_create_OTS_ROADMC_DEG2(self):
+ def test_022_create_OTS_ROADMC_DEG2(self):
response = test_utils.create_ots_oms_request("ROADM-C1", "DEG2-TTP-TXRX")
time.sleep(10)
self.assertEqual(response.status_code, requests.codes.ok)
self.assertIn('Interfaces OTS-DEG2-TTP-TXRX - OMS-DEG2-TTP-TXRX successfully created on node ROADM-C1',
res["output"]["result"])
- def test_23_calculate_span_loss_base_all(self):
+ def test_023_calculate_span_loss_base_all(self):
url = "{}/operations/transportpce-olm:calculate-spanloss-base"
data = {
"input": {
}, res["output"]["spans"])
time.sleep(5)
- def test_24_check_otn_topology(self):
+ def test_024_check_otn_topology(self):
response = test_utils.get_otn_topo_request()
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
'otn-topology should have no link')
# test service-create for OCH-OTU4 service from spdrA to spdrB
- def test_25_create_OCH_OTU4_service_AB(self):
+ def test_025_create_OCH_OTU4_service_AB(self):
response = test_utils.service_create_request(self.cr_serv_sample_data)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
res['output']['configuration-response-common']['response-message'])
time.sleep(self.WAITING)
- def test_26_get_OCH_OTU4_service_AB(self):
+ def test_026_get_OCH_OTU4_service_AB(self):
response = test_utils.get_service_list_request(
"services/service-OCH-OTU4-AB")
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(2)
# Check correct configuration of devices
- def test_27_check_interface_och_spdra(self):
+ def test_027_check_interface_och_spdra(self):
response = test_utils.check_netconf_node_request(
"SPDR-SA1", "interface/XPDR2-NETWORK1-761:768")
self.assertEqual(response.status_code, requests.codes.ok)
'transmit-power': -5, 'modulation-format': 'dp-qpsk'},
res['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
- def test_28_check_interface_OTU4_spdra(self):
+ def test_028_check_interface_OTU4_spdra(self):
response = test_utils.check_netconf_node_request(
"SPDR-SA1", "interface/XPDR2-NETWORK1-OTU")
self.assertEqual(response.status_code, requests.codes.ok)
self.assertDictEqual(input_dict_2,
res['interface'][0]
['org-openroadm-otn-otu-interfaces:otu'])
-
- def test_29_check_interface_och_spdrB(self):
+ response2 = test_utils.check_netconf_node_request(
+ "SPDR-SB1", "interface/XPDR2-NETWORK1-OTU/otu")
+ self.assertEqual(response2.status_code, requests.codes.ok)
+ res2 = response2.json()['org-openroadm-otn-otu-interfaces:otu']
+ self.assertEqual(input_dict_2['tx-sapi'], res2['tx-dapi'])
+ self.assertEqual(input_dict_2['tx-sapi'], res2['expected-sapi'])
+ self.assertEqual(input_dict_2['tx-dapi'], res2['tx-sapi'])
+ self.assertEqual(input_dict_2['tx-dapi'], res2['expected-dapi'])
+
+ def test_029_check_interface_och_spdrB(self):
response = test_utils.check_netconf_node_request(
"SPDR-SB1", "interface/XPDR2-NETWORK1-761:768")
self.assertEqual(response.status_code, requests.codes.ok)
'transmit-power': -5, 'modulation-format': 'dp-qpsk'},
res['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
- def test_30_check_interface_OTU4_spdrB(self):
+ def test_030_check_interface_OTU4_spdrB(self):
response = test_utils.check_netconf_node_request(
"SPDR-SB1", "interface/XPDR2-NETWORK1-OTU")
self.assertEqual(response.status_code, requests.codes.ok)
self.assertDictEqual(input_dict_2,
res['interface'][0]
['org-openroadm-otn-otu-interfaces:otu'])
+ response2 = test_utils.check_netconf_node_request(
+ "SPDR-SA1", "interface/XPDR2-NETWORK1-OTU/otu")
+ self.assertEqual(response.status_code, requests.codes.ok)
+ res2 = response2.json()['org-openroadm-otn-otu-interfaces:otu']
+ self.assertEqual(input_dict_2['tx-sapi'], res2['tx-dapi'])
+ self.assertEqual(input_dict_2['tx-sapi'], res2['expected-sapi'])
+ self.assertEqual(input_dict_2['tx-dapi'], res2['tx-sapi'])
+ self.assertEqual(input_dict_2['tx-dapi'], res2['expected-dapi'])
- def test_31_check_no_interface_ODU4_spdra(self):
+ def test_031_check_no_interface_ODU4_spdra(self):
response = test_utils.check_netconf_node_request(
"SPDR-SA1", "interface/XPDR2-NETWORK1-ODU4")
self.assertEqual(response.status_code, requests.codes.conflict)
"error-message": "Request could not be completed because the relevant data model content does not exist"},
res['errors']['error'])
- def test_32_check_openroadm_topo_spdra(self):
+ def test_032_check_openroadm_topo_spdra(self):
response = test_utils.get_ordm_topo_request("node/SPDR-SA1-XPDR2")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
ele['org-openroadm-network-topology:xpdr-network-attributes']['tail-equipment-id'])
time.sleep(3)
- def test_33_check_openroadm_topo_ROADMA_SRG(self):
+ def test_033_check_openroadm_topo_ROADMA_SRG(self):
response = test_utils.get_ordm_topo_request("node/ROADM-A1-SRG1")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertNotIn('avail-freq-maps', dict.keys(ele))
time.sleep(3)
- def test_33_check_openroadm_topo_ROADMA_DEG1(self):
+ def test_034_check_openroadm_topo_ROADMA_DEG1(self):
response = test_utils.get_ordm_topo_request("node/ROADM-A1-DEG1")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(freq_map_array[95], 0, "Lambda 1 should not be available")
time.sleep(3)
- def test_34_check_otn_topo_otu4_links(self):
+ def test_035_check_otn_topo_otu4_links(self):
response = test_utils.get_otn_topo_request()
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn(
link['org-openroadm-common-network:opposite-link'], listLinkId)
+
# test service-create for OCH-OTU4 service from spdrB to spdrC
- def test_35_create_OCH_OTU4_service_BC(self):
+
+ def test_036_create_OCH_OTU4_service_BC(self):
# pylint: disable=line-too-long
self.cr_serv_sample_data["input"]["service-name"] = "service-OCH-OTU4-BC"
self.cr_serv_sample_data["input"]["service-a-end"]["node-id"] = "SPDR-SB1"
res['output']['configuration-response-common']['response-message'])
time.sleep(self.WAITING)
- def test_36_get_OCH_OTU4_service_BC(self):
+ def test_037_get_OCH_OTU4_service_BC(self):
response = test_utils.get_service_list_request(
"services/service-OCH-OTU4-BC")
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(2)
# Check correct configuration of devices
- def test_37_check_interface_och_spdrB(self):
+ def test_038_check_interface_och_spdrB(self):
response = test_utils.check_netconf_node_request(
"SPDR-SB1", "interface/XPDR2-NETWORK2-753:760")
self.assertEqual(response.status_code, requests.codes.ok)
'transmit-power': -5, 'modulation-format': 'dp-qpsk'},
res['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
- def test_38_check_interface_OTU4_spdrB(self):
+ def test_039_check_interface_OTU4_spdrB(self):
response = test_utils.check_netconf_node_request(
"SPDR-SB1", "interface/XPDR2-NETWORK2-OTU")
self.assertEqual(response.status_code, requests.codes.ok)
self.assertDictEqual(input_dict_2,
res['interface'][0]
['org-openroadm-otn-otu-interfaces:otu'])
+ response2 = test_utils.check_netconf_node_request(
+ "SPDR-SC1", "interface/XPDR2-NETWORK1-OTU/otu")
+ self.assertEqual(response.status_code, requests.codes.ok)
+ res2 = response2.json()['org-openroadm-otn-otu-interfaces:otu']
+ self.assertEqual(input_dict_2['tx-sapi'], res2['tx-dapi'])
+ self.assertEqual(input_dict_2['tx-sapi'], res2['expected-sapi'])
+ self.assertEqual(input_dict_2['tx-dapi'], res2['tx-sapi'])
+ self.assertEqual(input_dict_2['tx-dapi'], res2['expected-dapi'])
- def test_39_check_interface_och_spdrC(self):
+ def test_040_check_interface_och_spdrC(self):
response = test_utils.check_netconf_node_request(
"SPDR-SC1", "interface/XPDR2-NETWORK1-753:760")
self.assertEqual(response.status_code, requests.codes.ok)
'transmit-power': -5, 'modulation-format': 'dp-qpsk'},
res['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
- def test_40_check_interface_OTU4_spdrC(self):
+ def test_041_check_interface_OTU4_spdrC(self):
response = test_utils.check_netconf_node_request(
"SPDR-SC1", "interface/XPDR2-NETWORK1-OTU")
self.assertEqual(response.status_code, requests.codes.ok)
self.assertDictEqual(input_dict_2,
res['interface'][0]
['org-openroadm-otn-otu-interfaces:otu'])
+ response2 = test_utils.check_netconf_node_request(
+ "SPDR-SB1", "interface/XPDR2-NETWORK2-OTU/otu")
+ self.assertEqual(response.status_code, requests.codes.ok)
+ res2 = response2.json()['org-openroadm-otn-otu-interfaces:otu']
+ self.assertEqual(input_dict_2['tx-sapi'], res2['tx-dapi'])
+ self.assertEqual(input_dict_2['tx-sapi'], res2['expected-sapi'])
+ self.assertEqual(input_dict_2['tx-dapi'], res2['tx-sapi'])
+ self.assertEqual(input_dict_2['tx-dapi'], res2['expected-dapi'])
- def test_41_check_no_interface_ODU4_spdrB(self):
+ def test_042_check_no_interface_ODU4_spdrB(self):
response = test_utils.check_netconf_node_request(
"SPDR-SB1", "interface/XPDR2-NETWORK1-ODU4")
self.assertEqual(response.status_code, requests.codes.conflict)
"error-message": "Request could not be completed because the relevant data model content does not exist"},
res['errors']['error'])
- def test_42_check_openroadm_topo_spdrB(self):
+ def test_043_check_openroadm_topo_spdrB(self):
response = test_utils.get_ordm_topo_request("node/SPDR-SB1-XPDR2")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertNotIn('org-openroadm-network-topology:xpdr-network-attributes', dict.keys(ele))
time.sleep(3)
- def test_43_check_openroadm_topo_ROADMB_SRG1(self):
+ def test_044_check_openroadm_topo_ROADMB_SRG1(self):
response = test_utils.get_ordm_topo_request("node/ROADM-B1-SRG1")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertNotIn('avail-freq-maps', dict.keys(ele))
time.sleep(3)
- def test_44_check_openroadm_topo_ROADMB_DEG2(self):
+ def test_045_check_openroadm_topo_ROADMB_DEG2(self):
response = test_utils.get_ordm_topo_request("node/ROADM-B1-DEG2")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(freq_map_array[94], 0, "Lambda 1 should not be available")
time.sleep(3)
- def test_45_check_otn_topo_otu4_links(self):
+ def test_046_check_otn_topo_otu4_links(self):
response = test_utils.get_otn_topo_request()
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
link['org-openroadm-common-network:opposite-link'], listLinkId)
# test service-create for 100GE service from spdrA to spdrC via spdrB
- def test_46_create_100GE_service_ABC(self):
+ def test_047_create_100GE_service_ABC(self):
# pylint: disable=line-too-long
self.cr_serv_sample_data["input"]["service-name"] = "service-100GE-ABC"
self.cr_serv_sample_data["input"]["connection-type"] = "service"
res['output']['configuration-response-common']['response-message'])
time.sleep(self.WAITING)
- def test_47_get_100GE_service_ABC(self):
+ def test_048_get_100GE_service_ABC(self):
response = test_utils.get_service_list_request(
"services/service-100GE-ABC")
self.assertEqual(response.status_code, requests.codes.ok)
res['services'][0]['lifecycle-state'], 'planned')
time.sleep(2)
- def test_48_check_interface_100GE_CLIENT_spdra(self):
+ def test_049_check_interface_100GE_CLIENT_spdra(self):
response = test_utils.check_netconf_node_request(
"SPDR-SA1", "interface/XPDR2-CLIENT1-ETHERNET")
self.assertEqual(response.status_code, requests.codes.ok)
'fec': 'off'},
res['interface'][0]['org-openroadm-ethernet-interfaces:ethernet'])
- def test_49_check_interface_ODU4_CLIENT_spdra(self):
+ def test_050_check_interface_ODU4_CLIENT_spdra(self):
response = test_utils.check_netconf_node_request(
"SPDR-SA1", "interface/XPDR2-CLIENT1-ODU4")
self.assertEqual(response.status_code, requests.codes.ok)
self.assertDictEqual(
{'payload-type': '21', 'exp-payload-type': '21'},
res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
+ response2 = test_utils.check_netconf_node_request(
+ "SPDR-SC1", "interface/XPDR2-CLIENT1-ODU4")
+ self.assertEqual(response.status_code, requests.codes.ok)
+ res2 = response2.json()['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
+ self.assertEqual(input_dict_2['tx-sapi'], res2['tx-dapi'])
+ self.assertEqual(input_dict_2['tx-sapi'], res2['expected-sapi'])
+ self.assertEqual(input_dict_2['tx-dapi'], res2['tx-sapi'])
+ self.assertEqual(input_dict_2['tx-dapi'], res2['expected-dapi'])
- def test_50_check_interface_ODU4_NETWORK_spdra(self):
+ def test_051_check_interface_ODU4_NETWORK_spdra(self):
response = test_utils.check_netconf_node_request(
"SPDR-SA1", "interface/XPDR2-NETWORK1-ODU4")
self.assertEqual(response.status_code, requests.codes.ok)
self.assertNotIn('opu',
dict.keys(res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']))
- def test_51_check_ODU4_connection_spdra(self):
+ def test_052_check_ODU4_connection_spdra(self):
response = test_utils.check_netconf_node_request(
"SPDR-SA1",
"odu-connection/XPDR2-CLIENT1-ODU4-x-XPDR2-NETWORK1-ODU4")
self.assertDictEqual({'src-if': 'XPDR2-CLIENT1-ODU4'},
res['odu-connection'][0]['source'])
- def test_52_check_interface_100GE_CLIENT_spdrc(self):
+ def test_053_check_interface_100GE_CLIENT_spdrc(self):
response = test_utils.check_netconf_node_request(
"SPDR-SC1", "interface/XPDR2-CLIENT1-ETHERNET")
self.assertEqual(response.status_code, requests.codes.ok)
'fec': 'off'},
res['interface'][0]['org-openroadm-ethernet-interfaces:ethernet'])
- def test_53_check_interface_ODU4_CLIENT_spdrc(self):
+ def test_054_check_interface_ODU4_CLIENT_spdrc(self):
response = test_utils.check_netconf_node_request(
"SPDR-SC1", "interface/XPDR2-CLIENT1-ODU4")
self.assertEqual(response.status_code, requests.codes.ok)
self.assertDictEqual(
{'payload-type': '21', 'exp-payload-type': '21'},
res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
+ response2 = test_utils.check_netconf_node_request(
+ "SPDR-SA1", "interface/XPDR2-CLIENT1-ODU4")
+ self.assertEqual(response.status_code, requests.codes.ok)
+ res2 = response2.json()['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
+ self.assertEqual(input_dict_2['tx-sapi'], res2['tx-dapi'])
+ self.assertEqual(input_dict_2['tx-sapi'], res2['expected-sapi'])
+ self.assertEqual(input_dict_2['tx-dapi'], res2['tx-sapi'])
+ self.assertEqual(input_dict_2['tx-dapi'], res2['expected-dapi'])
- def test_54_check_interface_ODU4_NETWORK_spdrc(self):
+ def test_055_check_interface_ODU4_NETWORK_spdrc(self):
response = test_utils.check_netconf_node_request(
"SPDR-SC1", "interface/XPDR2-NETWORK1-ODU4")
self.assertEqual(response.status_code, requests.codes.ok)
self.assertNotIn('opu',
dict.keys(res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']))
- def test_55_check_ODU4_connection_spdrc(self):
+ def test_056_check_ODU4_connection_spdrc(self):
response = test_utils.check_netconf_node_request(
"SPDR-SC1",
"odu-connection/XPDR2-CLIENT1-ODU4-x-XPDR2-NETWORK1-ODU4")
self.assertDictEqual({'src-if': 'XPDR2-CLIENT1-ODU4'},
res['odu-connection'][0]['source'])
- def test_56_check_interface_ODU4_NETWORK1_spdrb(self):
+ def test_057_check_interface_ODU4_NETWORK1_spdrb(self):
response = test_utils.check_netconf_node_request(
"SPDR-SB1", "interface/XPDR2-NETWORK1-ODU4")
self.assertEqual(response.status_code, requests.codes.ok)
self.assertNotIn('opu',
dict.keys(res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']))
- def test_57_check_interface_ODU4_NETWORK2_spdrb(self):
+ def test_058_check_interface_ODU4_NETWORK2_spdrb(self):
response = test_utils.check_netconf_node_request(
"SPDR-SB1", "interface/XPDR2-NETWORK2-ODU4")
self.assertEqual(response.status_code, requests.codes.ok)
self.assertNotIn('opu',
dict.keys(res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']))
- def test_58_check_ODU4_connection_spdrb(self):
+ def test_059_check_ODU4_connection_spdrb(self):
response = test_utils.check_netconf_node_request(
"SPDR-SB1",
"odu-connection/XPDR2-NETWORK1-ODU4-x-XPDR2-NETWORK2-ODU4")
self.assertDictEqual({'src-if': 'XPDR2-NETWORK1-ODU4'},
res['odu-connection'][0]['source'])
- def test_59_check_otn_topo_links(self):
+ def test_060_check_otn_topo_links(self):
response = test_utils.get_otn_topo_request()
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(
link['org-openroadm-otn-network-topology:used-bandwidth'], 100000)
- def test_60_delete_service_100GE_ABC(self):
+ def test_061_delete_service_100GE_ABC(self):
response = test_utils.service_delete_request("service-100GE-ABC")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
res['output']['configuration-response-common']['response-message'])
time.sleep(self.WAITING)
- def test_61_check_service_list(self):
+ def test_062_check_service_list(self):
response = test_utils.get_service_list_request("")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(len(res['service-list']['services']), 2)
time.sleep(2)
- def test_62_check_no_ODU4_connection_spdra(self):
+ def test_063_check_no_ODU4_connection_spdra(self):
response = test_utils.check_netconf_node_request("SPDR-SA1", "")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertNotIn(['odu-connection'][0], res['org-openroadm-device'])
time.sleep(1)
- def test_63_check_no_interface_ODU4_NETWORK_spdra(self):
+ def test_064_check_no_interface_ODU4_NETWORK_spdra(self):
response = test_utils.check_netconf_node_request(
"SPDR-SA1", "interface/XPDR2-NETWORK1-ODU4")
self.assertEqual(response.status_code, requests.codes.conflict)
- def test_64_check_no_interface_ODU4_CLIENT_spdra(self):
+ def test_065_check_no_interface_ODU4_CLIENT_spdra(self):
response = test_utils.check_netconf_node_request(
"SPDR-SA1", "interface/XPDR2-CLIENT1-ODU4")
self.assertEqual(response.status_code, requests.codes.conflict)
- def test_65_check_no_interface_100GE_CLIENT_spdra(self):
+ def test_066_check_no_interface_100GE_CLIENT_spdra(self):
response = test_utils.check_netconf_node_request(
"SPDR-SA1", "interface/XPDR2-CLIENT1-ETHERNET")
self.assertEqual(response.status_code, requests.codes.conflict)
- def test_66_check_otn_topo_links(self):
- self.test_45_check_otn_topo_otu4_links()
+ def test_067_check_otn_topo_links(self):
+ self.test_046_check_otn_topo_otu4_links()
- def test_67_delete_OCH_OTU4_service_AB(self):
+ def test_068_delete_OCH_OTU4_service_AB(self):
response = test_utils.service_delete_request("service-OCH-OTU4-AB")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
res['output']['configuration-response-common']['response-message'])
time.sleep(self.WAITING)
- def test_68_delete_OCH_OTU4_service_BC(self):
+ def test_069_delete_OCH_OTU4_service_BC(self):
response = test_utils.service_delete_request("service-OCH-OTU4-BC")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
res['output']['configuration-response-common']['response-message'])
time.sleep(self.WAITING)
- def test_69_get_no_service(self):
+ def test_070_get_no_service(self):
response = test_utils.get_service_list_request("")
self.assertEqual(response.status_code, requests.codes.conflict)
res = response.json()
res['errors']['error'])
time.sleep(1)
- def test_70_check_no_interface_OTU4_spdra(self):
+ def test_071_check_no_interface_OTU4_spdra(self):
response = test_utils.check_netconf_node_request(
"SPDR-SA1", "interface/XPDR2-NETWORK1-OTU")
self.assertEqual(response.status_code, requests.codes.conflict)
- def test_71_check_no_interface_OCH_spdra(self):
+ def test_072_check_no_interface_OCH_spdra(self):
response = test_utils.check_netconf_node_request(
"SPDR-SA1", "interface/XPDR2-NETWORK1-761:768")
self.assertEqual(response.status_code, requests.codes.conflict)
- def test_72_getLinks_OtnTopology(self):
+ def test_073_getLinks_OtnTopology(self):
response = test_utils.get_otn_topo_request()
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertNotIn('ietf-network-topology:link', res['network'][0])
- def test_73_check_openroadm_topo_spdra(self):
+ def test_074_check_openroadm_topo_spdra(self):
response = test_utils.get_ordm_topo_request("node/SPDR-SA1-XPDR2")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
tp['org-openroadm-network-topology:xpdr-network-attributes']))
time.sleep(3)
- def test_74_check_openroadm_topo_ROADMB_SRG1(self):
+ def test_075_check_openroadm_topo_ROADMB_SRG1(self):
response = test_utils.get_ordm_topo_request("node/ROADM-B1-SRG1")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(freq_map_array[94], 255, "Lambda 1 should be available")
time.sleep(3)
- def test_75_check_openroadm_topo_ROADMB_DEG1(self):
+ def test_076_check_openroadm_topo_ROADMB_DEG1(self):
response = test_utils.get_ordm_topo_request("node/ROADM-B1-DEG1")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(freq_map_array[95], 255, "Lambda 1 should be available")
time.sleep(3)
- def test_76_check_openroadm_topo_ROADMB_DEG2(self):
+ def test_077_check_openroadm_topo_ROADMB_DEG2(self):
response = test_utils.get_ordm_topo_request("node/ROADM-B1-DEG2")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(freq_map_array[95], 255, "Lambda 1 should be available")
time.sleep(3)
- def test_77_disconnect_xponders_from_roadm(self):
+ def test_078_disconnect_xponders_from_roadm(self):
url = "{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:link/"
response = test_utils.get_ordm_topo_request("")
self.assertEqual(response.status_code, requests.codes.ok)
response = test_utils.delete_request(url+link_name)
self.assertEqual(response.status_code, requests.codes.ok)
- def test_78_disconnect_spdrB(self):
+ def test_079_disconnect_spdrB(self):
response = test_utils.unmount_device("SPDR-SB1")
self.assertEqual(response.status_code, requests.codes.ok,
test_utils.CODE_SHOULD_BE_200)
- def test_79_disconnect_roadmB(self):
+ def test_080_disconnect_roadmB(self):
response = test_utils.unmount_device("ROADM-B1")
self.assertEqual(response.status_code, requests.codes.ok,
test_utils.CODE_SHOULD_BE_200)
- def test_80_remove_roadm_to_roadm_links(self):
+ def test_081_remove_roadm_to_roadm_links(self):
url = "{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:link/"
response = test_utils.get_ordm_topo_request("")
self.assertEqual(response.status_code, requests.codes.ok)
response = test_utils.delete_request(url+link_name)
self.assertEqual(response.status_code, requests.codes.ok)
- def test_81_add_omsAttributes_ROADMA_ROADMC(self):
+ def test_082_add_omsAttributes_ROADMA_ROADMC(self):
# Config ROADMA-ROADMC oms-attributes
data = {"span": {
"auto-spanloss": "true",
"ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX", data)
self.assertEqual(response.status_code, requests.codes.created)
- def test_82_add_omsAttributes_ROADMC_ROADMA(self):
+ def test_083_add_omsAttributes_ROADMC_ROADMA(self):
# Config ROADMC-ROADMA oms-attributes
data = {"span": {
"auto-spanloss": "true",
"ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX", data)
self.assertEqual(response.status_code, requests.codes.created)
- def test_83_create_OCH_OTU4_service_AC(self):
+ def test_084_create_OCH_OTU4_service_AC(self):
# pylint: disable=line-too-long
self.cr_serv_sample_data["input"]["service-name"] = "service-OCH-OTU4-AC"
self.cr_serv_sample_data["input"]["connection-type"] = "infrastructure"
res['output']['configuration-response-common']['response-message'])
time.sleep(self.WAITING)
- def test_84_get_OCH_OTU4_service_AC(self):
+ def test_085_get_OCH_OTU4_service_AC(self):
response = test_utils.get_service_list_request(
"services/service-OCH-OTU4-AC")
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(2)
# test service-create for 100GE service from spdrA to spdrC via spdrB
- def test_85_create_100GE_service_AC(self):
+ def test_086_create_100GE_service_AC(self):
# pylint: disable=line-too-long
self.cr_serv_sample_data["input"]["service-name"] = "service-100GE-AC"
self.cr_serv_sample_data["input"]["connection-type"] = "service"
res['output']['configuration-response-common']['response-message'])
time.sleep(self.WAITING)
- def test_86_get_100GE_service_AC(self):
+ def test_087_get_100GE_service_AC(self):
response = test_utils.get_service_list_request("services/service-100GE-AC")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
res['services'][0]['lifecycle-state'], 'planned')
time.sleep(2)
- def test_87_check_configuration_spdra(self):
- self.test_48_check_interface_100GE_CLIENT_spdra()
- self.test_49_check_interface_ODU4_CLIENT_spdra()
- self.test_50_check_interface_ODU4_NETWORK_spdra()
- self.test_51_check_ODU4_connection_spdra()
+ def test_088_check_interface_OTU4_spdra(self):
+ response = test_utils.check_netconf_node_request(
+ "SPDR-SA1", "interface/XPDR2-NETWORK1-OTU")
+ self.assertEqual(response.status_code, requests.codes.ok)
+ res = response.json()
+ input_dict_1 = {'name': 'XPDR2-NETWORK1-OTU',
+ 'administrative-state': 'inService',
+ 'supporting-circuit-pack-name': 'CP5-CFP',
+ 'supporting-interface': 'XPDR2-NETWORK1-761:768',
+ 'type': 'org-openroadm-interfaces:otnOtu',
+ 'supporting-port': 'CP5-CFP-P1'
+ }
+ input_dict_2 = {'tx-sapi': 'AOQxIv+6nCD+',
+ 'expected-dapi': 'AOQxIv+6nCD+',
+ 'tx-dapi': 'ALvne1QI5jo4',
+ 'expected-sapi': 'ALvne1QI5jo4',
+ 'rate': 'org-openroadm-otn-common-types:OTU4',
+ 'fec': 'scfec'
+ }
+ self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
+ res['interface'][0])
+
+ self.assertDictEqual(input_dict_2,
+ res['interface'][0]
+ ['org-openroadm-otn-otu-interfaces:otu'])
+ response2 = test_utils.check_netconf_node_request(
+ "SPDR-SC1", "interface/XPDR2-NETWORK1-OTU/otu")
+ self.assertEqual(response.status_code, requests.codes.ok)
+ res2 = response2.json()['org-openroadm-otn-otu-interfaces:otu']
+ self.assertEqual(input_dict_2['tx-sapi'], res2['tx-dapi'])
+ self.assertEqual(input_dict_2['tx-sapi'], res2['expected-sapi'])
+ self.assertEqual(input_dict_2['tx-dapi'], res2['tx-sapi'])
+ self.assertEqual(input_dict_2['tx-dapi'], res2['expected-dapi'])
- def test_88_check_configuration_spdrc(self):
- self.test_52_check_interface_100GE_CLIENT_spdrc()
- self.test_53_check_interface_ODU4_CLIENT_spdrc()
- self.test_54_check_interface_ODU4_NETWORK_spdrc()
- self.test_55_check_ODU4_connection_spdrc()
+ def test_089_check_interface_OTU4_spdrC(self):
+ response = test_utils.check_netconf_node_request(
+ "SPDR-SC1", "interface/XPDR2-NETWORK1-OTU")
+ self.assertEqual(response.status_code, requests.codes.ok)
+ res = response.json()
+ input_dict_1 = {'name': 'XPDR2-NETWORK1-OTU',
+ 'administrative-state': 'inService',
+ 'supporting-circuit-pack-name': 'CP5-CFP',
+ 'supporting-interface': 'XPDR2-NETWORK1-753:760',
+ 'type': 'org-openroadm-interfaces:otnOtu',
+ 'supporting-port': 'CP5-CFP-P1'
+ }
+ input_dict_2 = {'tx-dapi': 'AOQxIv+6nCD+',
+ 'expected-sapi': 'AOQxIv+6nCD+',
+ 'tx-sapi': 'ALvne1QI5jo4',
+ 'expected-dapi': 'ALvne1QI5jo4',
+ 'rate': 'org-openroadm-otn-common-types:OTU4',
+ 'fec': 'scfec'
+ }
- def test_89_check_otn_topo_links(self):
+ self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
+ res['interface'][0])
+ self.assertDictEqual(input_dict_2,
+ res['interface'][0]
+ ['org-openroadm-otn-otu-interfaces:otu'])
+ response2 = test_utils.check_netconf_node_request(
+ "SPDR-SA1", "interface/XPDR2-NETWORK1-OTU/otu")
+ self.assertEqual(response.status_code, requests.codes.ok)
+ res2 = response2.json()['org-openroadm-otn-otu-interfaces:otu']
+ self.assertEqual(input_dict_2['tx-sapi'], res2['tx-dapi'])
+ self.assertEqual(input_dict_2['tx-sapi'], res2['expected-sapi'])
+ self.assertEqual(input_dict_2['tx-dapi'], res2['tx-sapi'])
+ self.assertEqual(input_dict_2['tx-dapi'], res2['expected-dapi'])
+
+ def test_090_check_configuration_spdra(self):
+ self.test_049_check_interface_100GE_CLIENT_spdra()
+ self.test_050_check_interface_ODU4_CLIENT_spdra()
+ self.test_051_check_interface_ODU4_NETWORK_spdra()
+ self.test_052_check_ODU4_connection_spdra()
+
+ def test_091_check_configuration_spdrc(self):
+ self.test_053_check_interface_100GE_CLIENT_spdrc()
+ self.test_054_check_interface_ODU4_CLIENT_spdrc()
+ self.test_055_check_interface_ODU4_NETWORK_spdrc()
+ self.test_056_check_ODU4_connection_spdrc()
+
+ def test_092_check_otn_topo_links(self):
response = test_utils.get_otn_topo_request()
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(
link['org-openroadm-otn-network-topology:used-bandwidth'], 100000)
- def test_90_delete_100GE_service_AC(self):
+ def test_093_delete_100GE_service_AC(self):
response = test_utils.service_delete_request("service-100GE-AC")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
res['output']['configuration-response-common']['response-message'])
time.sleep(self.WAITING)
- def test_91_check_service_list(self):
+ def test_094_check_service_list(self):
response = test_utils.get_service_list_request("")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(len(res['service-list']['services']), 1)
time.sleep(2)
- def test_92_check_configuration_spdra(self):
- self.test_62_check_no_ODU4_connection_spdra()
- self.test_63_check_no_interface_ODU4_NETWORK_spdra()
- self.test_64_check_no_interface_ODU4_CLIENT_spdra()
- self.test_65_check_no_interface_100GE_CLIENT_spdra()
+ def test_095_check_configuration_spdra(self):
+ self.test_063_check_no_ODU4_connection_spdra()
+ self.test_064_check_no_interface_ODU4_NETWORK_spdra()
+ self.test_065_check_no_interface_ODU4_CLIENT_spdra()
+ self.test_066_check_no_interface_100GE_CLIENT_spdra()
- def test_93_check_otn_topo_links(self):
+ def test_096_check_otn_topo_links(self):
response = test_utils.get_otn_topo_request()
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(
link['org-openroadm-otn-network-topology:used-bandwidth'], 0)
- def test_94_disconnect_xponders_from_roadm(self):
+ def test_097_disconnect_xponders_from_roadm(self):
url = "{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:link/"
response = test_utils.get_ordm_topo_request("")
self.assertEqual(response.status_code, requests.codes.ok)
response = test_utils.delete_request(url+link_name)
self.assertEqual(response.status_code, requests.codes.ok)
- def test_95_disconnect_spdrA(self):
+ def test_098_disconnect_spdrA(self):
response = test_utils.unmount_device("SPDR-SA1")
self.assertEqual(response.status_code, requests.codes.ok,
test_utils.CODE_SHOULD_BE_200)
- def test_96_disconnect_spdrC(self):
+ def test_099_disconnect_spdrC(self):
response = test_utils.unmount_device("SPDR-SC1")
self.assertEqual(response.status_code, requests.codes.ok,
test_utils.CODE_SHOULD_BE_200)
- def test_97_disconnect_roadmA(self):
+ def test_100_disconnect_roadmA(self):
response = test_utils.unmount_device("ROADM-A1")
self.assertEqual(response.status_code, requests.codes.ok,
test_utils.CODE_SHOULD_BE_200)
- def test_98_disconnect_roadmC(self):
+ def test_101_disconnect_roadmC(self):
response = test_utils.unmount_device("ROADM-C1")
self.assertEqual(response.status_code, requests.codes.ok,
test_utils.CODE_SHOULD_BE_200)
'type': 'org-openroadm-interfaces:otnOtu',
'supporting-port': 'L1'
}
- input_dict_2 = {'rate': 'org-openroadm-otn-common-types:OTUCn',
+ input_dict_2 = {'tx-sapi': 'G54UFNImtOE=',
+ 'expected-dapi': 'G54UFNImtOE=',
+ 'tx-dapi': 'J/FIUzQc+4M=',
+ 'expected-sapi': 'J/FIUzQc+4M=',
+ 'rate': 'org-openroadm-otn-common-types:OTUCn',
'degthr-percentage': 100,
'degm-intervals': 2,
'otucn-n-rate': 4
'type': 'org-openroadm-interfaces:otnOtu',
'supporting-port': 'L1'
}
- input_dict_2 = {'rate': 'org-openroadm-otn-common-types:OTUCn',
+ input_dict_2 = {'tx-dapi': 'G54UFNImtOE=',
+ 'expected-sapi': 'G54UFNImtOE=',
+ 'tx-sapi': 'J/FIUzQc+4M=',
+ 'expected-dapi': 'J/FIUzQc+4M=',
+ 'rate': 'org-openroadm-otn-common-types:OTUCn',
'degthr-percentage': 100,
'degm-intervals': 2,
'otucn-n-rate': 4
links = res['network'][0]['ietf-network-topology:link']
self.assertEqual(22, len(links), 'Topology should contain 22 links')
- def test_68_connect_xprda2_2_N1_to_roadma_PP2(self):
+ def test_68_connect_xprda2_1_N1_to_roadma_PP2(self):
response = test_utils.connect_xpdr_to_rdm_request("XPDR-A2", "1", "1",
"ROADM-A1", "1", "SRG1-PP1-TXRX")
self.assertEqual(response.status_code, requests.codes.ok)
res["output"]["result"])
time.sleep(2)
- def test_69_connect_roadma_PP2_to_xpdra2_2_N1(self):
+ def test_69_connect_roadma_PP2_to_xpdra2_1_N1(self):
response = test_utils.connect_rdm_to_xpdr_request("XPDR-A2", "1", "1",
"ROADM-A1", "1", "SRG1-PP1-TXRX")
self.assertEqual(response.status_code, requests.codes.ok)
res["output"]["result"])
time.sleep(2)
- def test_70_connect_xprdc2_2_N1_to_roadmc_PP2(self):
+ def test_70_connect_xprdc2_1_N1_to_roadmc_PP2(self):
response = test_utils.connect_xpdr_to_rdm_request("XPDR-C2", "1", "1",
"ROADM-C1", "1", "SRG1-PP1-TXRX")
self.assertEqual(response.status_code, requests.codes.ok)
res["output"]["result"])
time.sleep(2)
- def test_71_connect_roadmc_PP2_to_xpdrc2_2_N1(self):
+ def test_71_connect_roadmc_PP2_to_xpdrc2_1_N1(self):
response = test_utils.connect_rdm_to_xpdr_request("XPDR-C2", "1", "1",
"ROADM-C1", "1", "SRG1-PP1-TXRX")
self.assertEqual(response.status_code, requests.codes.ok)
['supporting-interface-list'][0]: 'XPDR1-NETWORK1-OTSI-GROUP',
'type': 'org-openroadm-interfaces:otnOtu',
'supporting-port': 'L1'}
- input_dict_2 = {"rate": "org-openroadm-otn-common-types:OTUCn",
+ input_dict_2 = {"tx-sapi": "ANeUjNzWtDLV",
+ "expected-dapi": "ANeUjNzWtDLV",
+ 'tx-dapi': 'AKsqPmWceByv',
+ 'expected-sapi': 'AKsqPmWceByv',
+ "rate": "org-openroadm-otn-common-types:OTUCn",
"degthr-percentage": 100,
"tim-detect-mode": "Disabled",
"otucn-n-rate": 4,
**res['interface'][0]['org-openroadm-otn-otu-interfaces:otu']),
res['interface'][0]['org-openroadm-otn-otu-interfaces:otu'])
- @unittest.skip("Temporary skipped waiting for the rest of the functionality in change 97834")
def test_82_check_interface_ODUC4_xpdra2(self):
response = test_utils.check_netconf_node_request(
"XPDR-A2", "interface/XPDR1-NETWORK1-ODUC4")
input_dict_1 = {'name': 'XPDR1-NETWORK1-ODUC4',
'administrative-state': 'inService',
'supporting-circuit-pack-name': '1/1/2-PLUG-NET',
- ['supporting-interface-list'][0]: 'XPDR1-NETWORK1-OTSI-GROUP',
+ ['supporting-interface-list'][0]: 'XPDR1-NETWORK1-OTUC4',
'type': 'org-openroadm-interfaces:otnOdu',
- 'supporting-port': 'L1'}
+ 'supporting-port': 'L1',
+ 'circuit-id': 'TBD',
+ 'description': 'TBD'}
input_dict_2 = {"odu-function": "org-openroadm-otn-common-types:ODU-TTP",
"tim-detect-mode": "Disabled",
"degm-intervals": 2,
self.assertDictEqual(dict(input_dict_3,
**res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu']),
res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
+ self.assertEqual('XPDR1-NETWORK1-OTUC4', res['interface'][0]['supporting-interface-list'][0])
def test_83_delete_400GE_service(self):
response = test_utils.service_delete_request("service-400GE")