import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev181019.OtsAttributes;
import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev181019.ots.container.OtsBuilder;
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.ODUTTP;
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.PayloadTypeDef;
import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.OduAttributes;
private final PortMapping portMapping;
private final OpenRoadmInterfaces openRoadmInterfaces;
private FixedFlexInterface fixedFlex;
- private static final Logger LOG = LoggerFactory.getLogger(OpenRoadmInterfaceFactory.class);
+ private static final Logger LOG = LoggerFactory.getLogger(OpenRoadmInterface221.class);
public OpenRoadmInterface221(PortMapping portMapping, OpenRoadmInterfaces openRoadmInterfaces,
FixedFlexInterface fixedFlex) {
return false;
}
+ public String createOpenRoadmOtnOdu4Interface(String nodeId, String logicalConnPoint, String supportingOtuInterface)
+ throws OpenRoadmInterfaceException {
+ Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
+ if (portMap == null) {
+ throw new OpenRoadmInterfaceException(
+ String.format("Unable to get mapping from PortMapping for node % and logical connection port %s",
+ nodeId, logicalConnPoint));
+ }
+ InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(portMap, OtnOdu.class,
+ logicalConnPoint + "-ODU4");
+ oduInterfaceBldr.setSupportingInterface(supportingOtuInterface);
+
+ // ODU interface specific data
+ OduBuilder oduIfBuilder = new OduBuilder();
+ oduIfBuilder.setRate(ODU4.class);
+ oduIfBuilder.setMonitoringMode(OduAttributes.MonitoringMode.Terminated);
+ if (!nodeId.toLowerCase().contains("eci")) {
+ oduIfBuilder.setTxDapi("");
+ oduIfBuilder.setTxSapi("");
+ }
+ oduIfBuilder.setOduFunction(ODUTTP.class);
+
+ // Set Opu attributes
+ OpuBuilder opuBldr = new OpuBuilder();
+ opuBldr.setPayloadType(PayloadTypeDef.getDefaultInstance("21"));
+ opuBldr.setExpPayloadType(PayloadTypeDef.getDefaultInstance("21"));
+ oduIfBuilder.setOpu(opuBldr.build());
+
+ // 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();
+ oduInterfaceBldr.addAugmentation(
+ org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1.class,
+ oduIf1Builder.setOdu(oduIfBuilder.build()).build());
+
+ // Post interface on the device
+ openRoadmInterfaces.postInterface(nodeId, oduInterfaceBldr);
+ this.portMapping.updateMapping(nodeId, portMap);
+ return oduInterfaceBldr.getName();
+ }
+
}
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200128.network.nodes.Mapping;
import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev161014.OchAttributes;
import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev161014.RateIdentity;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public class OpenRoadmInterfaceFactory {
+ private static final Logger LOG = LoggerFactory.getLogger(OpenRoadmInterfaceFactory.class);
private final MappingUtils mappingUtils;
private final OpenRoadmInterface121 openRoadmInterface121;
private final OpenRoadmInterface221 openRoadmInterface221;
- private final OpenRoadmOTNInterface openRoadmOTNInterface;
+ private final OpenRoadmOtnInterface221 openRoadmOtnInterface;
public OpenRoadmInterfaceFactory(MappingUtils mappingUtils, OpenRoadmInterface121 openRoadmInterface121,
- OpenRoadmInterface221 openRoadmInterface221, OpenRoadmOTNInterface openRoadmOTNInterface) {
+ OpenRoadmInterface221 openRoadmInterface221, OpenRoadmOtnInterface221 openRoadmOTNInterface) {
this.mappingUtils = mappingUtils;
this.openRoadmInterface121 = openRoadmInterface121;
this.openRoadmInterface221 = openRoadmInterface221;
- this.openRoadmOTNInterface = openRoadmOTNInterface;
+ this.openRoadmOtnInterface = openRoadmOTNInterface;
}
public String createOpenRoadmEthInterface(String nodeId, String logicalConnPoint)
- throws OpenRoadmInterfaceException {
+ throws OpenRoadmInterfaceException {
switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
* This methods creates an OCH interface on the given termination point on
* Roadm.
*
- * @param nodeId node ID
+ * @param nodeId node ID
* @param logicalConnPoint logical connection point
- * @param waveNumber wavelength number of the OCH interface.
- *
+ * @param waveNumber wavelength number of the OCH interface.
* @return Name of the interface if successful, otherwise return null.
- *
* @throws OpenRoadmInterfaceException OpenRoadm interface exception
*/
public List<String> createOpenRoadmOchInterface(String nodeId, String logicalConnPoint, Long waveNumber)
- throws OpenRoadmInterfaceException {
+ throws OpenRoadmInterfaceException {
switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
- return openRoadmInterface121.createOpenRoadmOchInterface(nodeId, logicalConnPoint,waveNumber);
+ return openRoadmInterface121.createOpenRoadmOchInterface(nodeId, logicalConnPoint, waveNumber);
case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
- return openRoadmInterface221.createFlexOCH(nodeId, logicalConnPoint,waveNumber);
+ return openRoadmInterface221.createFlexOCH(nodeId, logicalConnPoint, waveNumber);
default:
return null;
}
public String createOpenRoadmOchInterface(String nodeId, String logicalConnPoint, Long waveNumber,
- Class<? extends RateIdentity> rate, OchAttributes.ModulationFormat format) throws OpenRoadmInterfaceException {
+ Class<? extends RateIdentity> rate, OchAttributes.ModulationFormat format)
+ throws OpenRoadmInterfaceException {
switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
return openRoadmInterface121.createOpenRoadmOchInterface(nodeId, logicalConnPoint, waveNumber,
- rate, format);
+ rate, format);
case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
- return openRoadmInterface221.createOpenRoadmOchInterface(nodeId,logicalConnPoint,waveNumber);
+ return openRoadmInterface221.createOpenRoadmOchInterface(nodeId, logicalConnPoint, waveNumber);
default:
return null;
}
/**
* This methods creates an ODU interface on the given termination point.
*
- * @param nodeId node ID
- * @param logicalConnPoint logical connection 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
*/
switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
return openRoadmInterface121.createOpenRoadmOdu4Interface(nodeId, logicalConnPoint,
- supportingOtuInterface);
+ supportingOtuInterface);
case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
return openRoadmInterface221.createOpenRoadmOdu4Interface(nodeId, logicalConnPoint,
- supportingOtuInterface);
+ supportingOtuInterface);
default:
return null;
}
/**
* This methods creates an OTU interface on the given termination point.
*
- * @param nodeId node ID
- * @param logicalConnPoint logical connection point
+ * @param nodeId node ID
+ * @param logicalConnPoint logical connection point
* @param supportOchInterface supporting OCH interface
- *
* @return Name of the interface if successful, otherwise return null.
- *
* @throws OpenRoadmInterfaceException OpenRoadm interface exception
*/
throws OpenRoadmInterfaceException {
switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
- return openRoadmInterface121.createOpenRoadmOtu4Interface(nodeId,
- logicalConnPoint,supportOchInterface);
+ return openRoadmInterface121
+ .createOpenRoadmOtu4Interface(nodeId, logicalConnPoint, supportOchInterface);
case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
- return openRoadmInterface221.createOpenRoadmOtu4Interface(nodeId,logicalConnPoint, supportOchInterface);
+ return openRoadmInterface221
+ .createOpenRoadmOtu4Interface(nodeId, logicalConnPoint, supportOchInterface);
default:
return null;
}
public String createOpenRoadmOmsInterface(String nodeId, Mapping mapping) throws OpenRoadmInterfaceException {
switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
- return openRoadmInterface121.createOpenRoadmOmsInterface(nodeId,mapping);
+ return openRoadmInterface121.createOpenRoadmOmsInterface(nodeId, mapping);
case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
- return openRoadmInterface221.createOpenRoadmOmsInterface(nodeId,mapping);
+ return openRoadmInterface221.createOpenRoadmOmsInterface(nodeId, mapping);
default:
return null;
}
public String createOpenRoadmOtsInterface(String nodeId, Mapping mapping) throws OpenRoadmInterfaceException {
switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
- return openRoadmInterface121.createOpenRoadmOtsInterface(nodeId,mapping);
+ return openRoadmInterface121.createOpenRoadmOtsInterface(nodeId, mapping);
case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
- return openRoadmInterface221.createOpenRoadmOtsInterface(nodeId,mapping);
+ return openRoadmInterface221.createOpenRoadmOtsInterface(nodeId, mapping);
default:
return null;
}
}
public boolean isUsedbyXc(String nodeId, String interfaceName, String xc,
- DeviceTransactionManager deviceTransactionManager) {
+ DeviceTransactionManager deviceTransactionManager) {
switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
return openRoadmInterface121.isUsedByXc(nodeId, interfaceName, xc, deviceTransactionManager);
public String createOpenRoadmEth1GInterface(String nodeId,
String logicalConnPoint) throws OpenRoadmInterfaceException {
- return openRoadmOTNInterface.createOpenRoadmEth1GInterface(nodeId,logicalConnPoint);
+ 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");
+ return null;
+ case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
+ return openRoadmOtnInterface.createOpenRoadmEth1GInterface(nodeId, logicalConnPoint);
+ default:
+ return null;
+ }
}
public String createOpenRoadmEth10GInterface(String nodeId,
String logicalConnPoint) throws OpenRoadmInterfaceException {
- return openRoadmOTNInterface.createOpenRoadmEth10GInterface(nodeId,logicalConnPoint);
+ 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");
+ return null;
+ case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
+ return openRoadmOtnInterface.createOpenRoadmEth10GInterface(nodeId, logicalConnPoint);
+ default:
+ return null;
+ }
+
}
public String createOpenRoadmOdu0Interface(String nodeId, String logicalConnPoint, String servicename,
String payLoad, boolean isNetworkPort, int tribPortNumber, int tribSlot)
throws OpenRoadmInterfaceException {
- return openRoadmOTNInterface.createOpenRoadmOdu0Interface(nodeId, logicalConnPoint, servicename, payLoad,
- isNetworkPort, tribPortNumber, tribSlot);
+ 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");
+ return null;
+ case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
+ return openRoadmOtnInterface.createOpenRoadmOdu0Interface(
+ nodeId, logicalConnPoint, servicename, payLoad, isNetworkPort, tribPortNumber, tribSlot);
+ default:
+ return null;
+ }
}
public String createOpenRoadmOdu2Interface(String nodeId, String logicalConnPoint, String servicename,
- String payLoad, boolean isNetworkPort)
+ String payLoad, boolean isNetworkPort, int tribPortNumber, int tribSlotIndex)
throws OpenRoadmInterfaceException {
- return openRoadmOTNInterface.createOpenRoadmOdu2Interface(nodeId, logicalConnPoint, servicename, payLoad,
- isNetworkPort);
+ 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");
+ return null;
+ case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
+ return openRoadmOtnInterface.createOpenRoadmOdu2Interface(
+ nodeId, logicalConnPoint, servicename, payLoad, isNetworkPort, tribPortNumber, tribSlotIndex);
+ default:
+ return null;
+ }
}
public String createOpenRoadmOdu2eInterface(String nodeId, String logicalConnPoint, String servicename,
- String payLoad, boolean isNetworkPort)
+ String payLoad, boolean isNetworkPort, int tribPortNumber, int tribSlotIndex)
throws OpenRoadmInterfaceException {
- return openRoadmOTNInterface.createOpenRoadmOdu2eInterface(nodeId, logicalConnPoint, servicename, payLoad,
- isNetworkPort);
+ 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");
+ return null;
+ case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
+ return openRoadmOtnInterface.createOpenRoadmOdu2eInterface(
+ nodeId, logicalConnPoint, servicename, payLoad, isNetworkPort, tribPortNumber, tribSlotIndex);
+ default:
+ return null;
+ }
+
}
+ 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;
+ }
+ }
}
import java.util.ArrayList;
import java.util.List;
+import java.util.stream.IntStream;
+
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.openroadm.device.rev181019.interfaces.grp.InterfaceBuilder;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.interfaces.grp.InterfaceKey;
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.Interface1;
import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev181019.Interface1Builder;
import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev181019.ethernet.container.EthernetBuilder;
import org.slf4j.LoggerFactory;
-public class OpenRoadmOTNInterface {
+public class OpenRoadmOtnInterface221 {
private final PortMapping portMapping;
private final OpenRoadmInterfaces openRoadmInterfaces;
- private static final Logger LOG = LoggerFactory.getLogger(OpenRoadmInterfaceFactory.class);
+ private static final Logger LOG = LoggerFactory.getLogger(OpenRoadmOtnInterface221.class);
- public OpenRoadmOTNInterface(PortMapping portMapping, OpenRoadmInterfaces openRoadmInterfaces) {
+ public OpenRoadmOtnInterface221(PortMapping portMapping, OpenRoadmInterfaces openRoadmInterfaces) {
this.portMapping = portMapping;
this.openRoadmInterfaces = openRoadmInterfaces;
}
throws OpenRoadmInterfaceException {
Mapping portMap = this.portMapping.getMapping(nodeId, logicalConnPoint);
if (portMap == null) {
- throw new OpenRoadmInterfaceException(String.format("Unable to get mapping from PortMapping for node % and"
- + " logical connection port %s", nodeId, logicalConnPoint));
+ throw new OpenRoadmInterfaceException(String.format(
+ "Unable to get mapping from PortMapping for node % and logical connection port %s",
+ nodeId, logicalConnPoint));
}
// Ethernet interface specific data
- EthernetBuilder ethIfBuilder = new EthernetBuilder()
- .setAutoNegotiation(EthAttributes.AutoNegotiation.Disabled)
- .setSpeed(1000L)
- .setMtu(9000L);
- //.setCurrSpeed("1000L")
- //.setCurrDuplex("FULL");
+ EthernetBuilder ethIfBuilder = new EthernetBuilder();
+ //ethIfBuilder.setAutoNegotiation(EthAttributes.AutoNegotiation.Disabled);
+ ethIfBuilder.setSpeed(1000L);
InterfaceBuilder ethInterfaceBldr =
createGenericInterfaceBuilder(portMap, EthernetCsmacd.class, logicalConnPoint + "-ETHERNET1G");
// Create Interface1 type object required for adding as augmentation
}
private InterfaceBuilder createGenericInterfaceBuilder(Mapping portMap,
- Class<? extends InterfaceType> type, String key) {
+ Class<? extends InterfaceType> type, String key) {
InterfaceBuilder interfaceBuilder = new InterfaceBuilder()
//.setDescription(" TBD ")
//.setCircuitId(" TBD ")
// Ethernet interface specific data
EthernetBuilder ethIfBuilder = new EthernetBuilder()
- .setAutoNegotiation(EthAttributes.AutoNegotiation.Disabled)
- .setSpeed(10000L)
- .setMtu(9000L);
- //.setCurrSpeed("1000L")
- //.setCurrDuplex("FULL");
+ //.setAutoNegotiation(EthAttributes.AutoNegotiation.Disabled)
+ .setSpeed(10000L);
// Create Interface1 type object required for adding as augmentation
Interface1Builder ethIf1Builder = new Interface1Builder();
InterfaceBuilder ethInterfaceBldr =
}
- public String createOpenRoadmOdu2eInterface(String nodeId, String logicalConnPoint, String serviceName,
- String payLoad, boolean isNetworkPort)
+ public String createOpenRoadmOdu2eInterface(
+ String nodeId, String logicalConnPoint, String serviceName,
+ String payLoad, boolean isNetworkPort, int tribPortNumber, int tribSlotIndex)
throws OpenRoadmInterfaceException {
Mapping portMap = this.portMapping.getMapping(nodeId, logicalConnPoint);
if (portMap == null) {
- throw new OpenRoadmInterfaceException(
- String.format("Unable to get mapping from PortMapping for node % and logical connection port %s",
- nodeId, logicalConnPoint));
+ throw new OpenRoadmInterfaceException(String.format(
+ "Unable to get mapping from PortMapping for node % and logical connection port %s",
+ nodeId, logicalConnPoint));
}
String supportingInterface = null;
if (isNetworkPort) {
supportingInterface = portMap.getSupportingOdu4();
-
} else {
- // supportingInterface = portMap.getSupportingEthernet();
supportingInterface = logicalConnPoint + "-ETHERNET10G";
}
+
+ if (supportingInterface == null) {
+ throw new OpenRoadmInterfaceException(
+ "Interface Creation failed because of missing supported ODU4 on network end or Eth iface on client");
+ }
+
InterfaceBuilder oduInterfaceBldr =
createGenericInterfaceBuilder(portMap, OtnOdu.class, logicalConnPoint + "-ODU2e-" + serviceName)
.setSupportingInterface(supportingInterface);
.setRate(ODU2e.class)
.setOduFunction(ODUTTPCTP.class)
.setMonitoringMode(OduAttributes.MonitoringMode.Terminated);
+ LOG.debug("Inside the ODU2e creation {} {} {}",isNetworkPort,tribPortNumber,tribSlotIndex);
if (isNetworkPort) {
List<Integer> tribSlots = new ArrayList<>();
- //add trib slots
- tribSlots.add(45);
+ int newIdx = tribSlotIndex;
+ tribSlots.add(newIdx);
+ IntStream.range(tribSlotIndex, tribSlotIndex + 8).forEach(
+ nbr -> tribSlots.add(nbr)
+ );
ParentOduAllocationBuilder parentOduAllocationBuilder = new ParentOduAllocationBuilder()
- //set trib port numbers
- .setTribPortNumber(24)
+ .setTribPortNumber(tribPortNumber)
.setTribSlots(tribSlots);
oduIfBuilder.setOduFunction(ODUCTP.class)
- .setMonitoringMode(OduAttributes.MonitoringMode.NotTerminated)
+ .setMonitoringMode(OduAttributes.MonitoringMode.Monitored)
.setParentOduAllocation(parentOduAllocationBuilder.build());
}
else {
// Set Opu attributes
OpuBuilder opuBldr = new OpuBuilder()
- .setPayloadType(new PayloadTypeDef(payLoad))
- .setExpPayloadType(new PayloadTypeDef(payLoad));
- //.setRxPayloadType("07")
- //.setPayloadInterface(payLoad);
+ .setPayloadType(new PayloadTypeDef(payLoad))
+ .setExpPayloadType(new PayloadTypeDef(payLoad));
oduIfBuilder.setOpu(opuBldr.build());
}
// 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();
+ new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder();
oduInterfaceBldr.addAugmentation(
org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1.class,
oduIf1Builder.setOdu(oduIfBuilder.build()).build());
return oduInterfaceBldr.getName();
}
- public String createOpenRoadmOdu0Interface(String nodeId, String logicalConnPoint, String serviceName,
- String payLoad, boolean isNetworkPort, int tribPortNumber, int tribSlot)
+ 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;
if (isNetworkPort) {
supportingInterface = portMap.getSupportingOdu4();
} else {
- // supportingInterface = portMap.getSupportingEthernet();
supportingInterface = logicalConnPoint + "-ETHERNET1G";
}
if (portMap == null) {
- throw new OpenRoadmInterfaceException(
- String.format("Unable to get mapping from PortMapping for node % and logical connection port %s",
- nodeId, logicalConnPoint));
+ throw new OpenRoadmInterfaceException(String.format(
+ "Unable to get mapping from PortMapping for node % and logical connection port %s",
+ nodeId, logicalConnPoint));
}
- InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(portMap, OtnOdu.class, logicalConnPoint
- + "-ODU0-" + serviceName);
+ InterfaceBuilder oduInterfaceBldr =
+ createGenericInterfaceBuilder(portMap, OtnOdu.class, logicalConnPoint + "-ODU0-" + serviceName);
oduInterfaceBldr.setSupportingInterface(supportingInterface);
// ODU interface specific data
.setOduFunction(ODUTTPCTP.class)
.setMonitoringMode(OduAttributes.MonitoringMode.Terminated);
if (isNetworkPort) {
+ LOG.debug("Network port is true");
List<Integer> tribSlots = new ArrayList<>();
tribSlots.add(tribSlot); //add trib slots
ParentOduAllocationBuilder parentOduAllocationBuilder = new ParentOduAllocationBuilder()
.setTribPortNumber(tribPortNumber)
.setTribSlots(tribSlots);
oduIfBuilder.setOduFunction(ODUCTP.class)
- .setMonitoringMode(OduAttributes.MonitoringMode.NotTerminated)
+ .setMonitoringMode(OduAttributes.MonitoringMode.Monitored)
.setParentOduAllocation(parentOduAllocationBuilder.build());
+ LOG.debug("Network port is true {} {} {}",
+ oduIfBuilder.getParentOduAllocation().getTribSlots(),
+ oduIfBuilder.getRate(),
+ oduIfBuilder.getParentOduAllocation().getTribPortNumber());
}
else {
- // Set Opu attributes
+ LOG.debug("Current port is a client port");
OpuBuilder opuBldr = new OpuBuilder()
- .setPayloadType(new PayloadTypeDef(payLoad))
- .setExpPayloadType(new PayloadTypeDef(payLoad));
- //.setRxPayloadType("07")
- //.setPayloadInterface(payLoad);
+ .setPayloadType(new PayloadTypeDef(payLoad))
+ .setExpPayloadType(new PayloadTypeDef(payLoad));
oduIfBuilder.setOpu(opuBldr.build());
}
// 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();
+ new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder();
oduInterfaceBldr.addAugmentation(
- org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1.class,
- oduIf1Builder.setOdu(oduIfBuilder.build()).build());
+ org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1.class,
+ oduIf1Builder.setOdu(oduIfBuilder.build()).build());
// Post interface on the device
this.openRoadmInterfaces.postOTNInterface(nodeId, oduInterfaceBldr);
return oduInterfaceBldr.getName();
}
- public String createOpenRoadmOdu2Interface(String nodeId, String logicalConnPoint, String serviceName,
- String payLoad, boolean isNetworkPort)
+
+ 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;
- if (portMap == null) {
- throw new OpenRoadmInterfaceException(
- String.format("Unable to get mapping from PortMapping for node % and logical connection port %s",
- nodeId, logicalConnPoint));
- }
+
if (isNetworkPort) {
supportingInterface = portMap.getSupportingOdu4();
} else {
supportingInterface = portMap.getSupportingEthernet();
}
+ if (portMap == null) {
+ throw new OpenRoadmInterfaceException(
+ String.format("Unable to get mapping from PortMapping for node % and logical connection port %s",
+ nodeId, logicalConnPoint));
+ }
InterfaceBuilder oduInterfaceBldr =
createGenericInterfaceBuilder(portMap, OtnOdu.class, logicalConnPoint + "-ODU2-" + serviceName)
.setSupportingInterface(supportingInterface);
.setMonitoringMode(OduAttributes.MonitoringMode.Terminated);
if (isNetworkPort) {
List<Integer> tribSlots = new ArrayList<>();
- tribSlots.add(45); //add trib slots
+ IntStream.range(tribSlotIndex, tribSlotIndex + 8).forEach(
+ nbr -> tribSlots.add(nbr)
+ );
ParentOduAllocationBuilder parentOduAllocationBuilder = new ParentOduAllocationBuilder()
//set trib port numbers
- .setTribPortNumber(24)
+ .setTribPortNumber(tribPortNumber)
.setTribSlots(tribSlots);
oduIfBuilder.setOduFunction(ODUCTP.class)
- .setMonitoringMode(OduAttributes.MonitoringMode.NotTerminated)
+ .setMonitoringMode(OduAttributes.MonitoringMode.Monitored)
.setParentOduAllocation(parentOduAllocationBuilder.build());
}
else {
// Set Opu attributes
OpuBuilder opuBldr = new OpuBuilder()
- .setPayloadType(new PayloadTypeDef(payLoad))
- .setExpPayloadType(new PayloadTypeDef(payLoad));
- //.setRxPayloadType("07")
- //.setPayloadInterface(payLoad);
+ .setPayloadType(new PayloadTypeDef(payLoad))
+ .setExpPayloadType(new PayloadTypeDef(payLoad));
oduIfBuilder.setOpu(opuBldr.build());
}
// 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();
+ new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder();
oduInterfaceBldr.addAugmentation(
- org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1.class,
- oduIf1Builder.setOdu(oduIfBuilder.build()).build());
+ org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1.class,
+ oduIf1Builder.setOdu(oduIfBuilder.build()).build());
// Post interface on the device
this.openRoadmInterfaces.postOTNInterface(nodeId, oduInterfaceBldr);
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.device.rev200128.renderer.rollback.output.FailedToRollbackBuilder;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.device.rev200128.renderer.rollback.output.FailedToRollbackKey;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.service.Topology;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.XpdrNodeTypes;
import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev161014.OchAttributes.ModulationFormat;
import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev161014.R100G;
import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.ServiceList;
Long waveNumber = input.getWaveNumber();
if ((destTp != null) && destTp.contains(StringConstants.NETWORK_TOKEN)) {
crossConnectFlag++;
- // create OpenRoadm Xponder Line Interfaces
+ Mapping mapping = this.portMapping.getMapping(nodeId,destTp);
String supportingOchInterface = this.openRoadmInterfaceFactory.createOpenRoadmOchInterface(
nodeId, destTp, waveNumber, R100G.class, ModulationFormat.DpQpsk);
createdOchInterfaces.add(supportingOchInterface);
String supportingOtuInterface = this.openRoadmInterfaceFactory
.createOpenRoadmOtu4Interface(nodeId, destTp, supportingOchInterface);
createdOtuInterfaces.add(supportingOtuInterface);
- createdOduInterfaces.add(this.openRoadmInterfaceFactory.createOpenRoadmOdu4Interface(nodeId,
- destTp, supportingOtuInterface));
+ if (mapping != null && mapping.getXponderType() != null
+ && (mapping.getXponderType().getIntValue() == 3
+ || mapping.getXponderType().getIntValue() == 2)) {
+ createdOduInterfaces.add(this.openRoadmInterfaceFactory
+ .createOpenRoadmOtnOdu4Interface(nodeId,destTp, supportingOtuInterface));
+ } else {
+ createdOduInterfaces.add(this.openRoadmInterfaceFactory.createOpenRoadmOdu4Interface(nodeId,
+ destTp, supportingOtuInterface));
+ }
}
if ((srcTp != null) && srcTp.contains(StringConstants.CLIENT_TOKEN)) {
crossConnectFlag++;
}
if ((srcTp != null) && srcTp.contains(StringConstants.NETWORK_TOKEN)) {
crossConnectFlag++;
+ Mapping mapping = this.portMapping.getMapping(nodeId,srcTp);
// create OpenRoadm Xponder Line Interfaces
String supportingOchInterface = this.openRoadmInterfaceFactory.createOpenRoadmOchInterface(
nodeId, srcTp, waveNumber, R100G.class, ModulationFormat.DpQpsk);
createdOtuInterfaces.add(supportingOtuInterface);
createdOduInterfaces.add(this.openRoadmInterfaceFactory.createOpenRoadmOdu4Interface(nodeId,
srcTp, supportingOtuInterface));
+ if (mapping != null && mapping.getXponderType() != null
+ && (mapping.getXponderType().getIntValue() == 3
+ || mapping.getXponderType().getIntValue() == 2)) {
+ createdOduInterfaces.add(this.openRoadmInterfaceFactory
+ .createOpenRoadmOtnOdu4Interface(nodeId, destTp, supportingOtuInterface));
+ } else {
+ createdOduInterfaces.add(this.openRoadmInterfaceFactory.createOpenRoadmOdu4Interface(nodeId,
+ destTp, supportingOtuInterface));
+ }
}
if ((destTp != null) && destTp.contains(StringConstants.CLIENT_TOKEN)) {
crossConnectFlag++;
package org.opendaylight.transportpce.renderer.provisiondevice;
import java.util.ArrayList;
+import java.util.LinkedList;
import java.util.List;
import java.util.Optional;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ForkJoinPool;
+import java.util.concurrent.ForkJoinTask;
+import java.util.concurrent.atomic.AtomicBoolean;
+
import org.opendaylight.transportpce.common.crossconnect.CrossConnect;
+import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException;
+import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces;
import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterfaceFactory;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.device.rev200128.OtnServicePathInput;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.device.rev200128.OtnServicePathOutput;
private static final Logger LOG = LoggerFactory.getLogger(OtnDeviceRendererServiceImpl.class);
private final OpenRoadmInterfaceFactory openRoadmInterfaceFactory;
private final CrossConnect crossConnect;
+ private final OpenRoadmInterfaces openRoadmInterfaces;
+ private final DeviceTransactionManager deviceTransactionManager;
+
- public OtnDeviceRendererServiceImpl(OpenRoadmInterfaceFactory openRoadmInterfaceFactory,
- CrossConnect crossConnect) {
+ public OtnDeviceRendererServiceImpl(OpenRoadmInterfaceFactory openRoadmInterfaceFactory, CrossConnect crossConnect,
+ OpenRoadmInterfaces openRoadmInterfaces,
+ DeviceTransactionManager deviceTransactionManager) {
this.openRoadmInterfaceFactory = openRoadmInterfaceFactory;
this.crossConnect = crossConnect;
+ this.openRoadmInterfaces = openRoadmInterfaces;
+ this.deviceTransactionManager = deviceTransactionManager;
}
@Override
public OtnServicePathOutput setupOtnServicePath(OtnServicePathInput input) {
+ LOG.info("Calling setup service path");
boolean success = true;
List<NodeInterface> nodeInterfaces = new ArrayList<>();
List<String> results = new ArrayList<>();
if (input.getServiceType().equals("Ethernet")) {
try {
+ LOG.info("Calling Node interfaces {} {} {} {} {} {} {}",
+ input.getServiceRate(),input.getEthernetEncoding(),
+ input.getServiceType(),input.getOperation(),input.getTribPortNumber(),
+ input.getTribSlot(),input.getNodes());
nodeInterfaces = createInterface(input);
+ LOG.info("Node interfaces created just fine ");
}
catch (OpenRoadmInterfaceException e) {
//handle exception
- LOG.warn("Set up service path failed");
+ LOG.warn("Set up service path failed {}", e.toString());
success = false;
}
+
}
if (success) {
+ LOG.info("Result is success");
for (NodeInterface nodeInterface: nodeInterfaces) {
results.add("Otn Service path was set up successfully for node :" + nodeInterface.getNodeId());
}
+ //TODO Add otn topology links
}
OtnServicePathOutputBuilder otnServicePathOutputBuilder = new OtnServicePathOutputBuilder()
- .setSuccess(success)
- .setNodeInterface(nodeInterfaces)
- .setResult(String.join("\n", results));
+ .setSuccess(success)
+ .setNodeInterface(nodeInterfaces)
+ .setResult(String.join("\n", results));
return otnServicePathOutputBuilder.build();
}
@Override
public OtnServicePathOutput deleteOtnServicePath(OtnServicePathInput input) {
- OtnServicePathOutputBuilder otnServicePathOutputBuilder = new OtnServicePathOutputBuilder()
- .setResult("deleteServicePath was called");
- return otnServicePathOutputBuilder.build();
+ List<Nodes> nodes = input.getNodes();
+ AtomicBoolean success = new AtomicBoolean(true);
+ ConcurrentLinkedQueue<String> results = new ConcurrentLinkedQueue<>();
+ ForkJoinPool forkJoinPool = new ForkJoinPool();
+ ForkJoinTask forkJoinTask = forkJoinPool.submit(() -> nodes.parallelStream().forEach(node -> {
+ List<String> interfacesToDelete = new LinkedList<>();
+ String nodeId = node.getNodeId();
+ LOG.info("Deleting service setup on node {}", nodeId);
+ String srcTp = node.getClientTp();
+ String destTp = node.getNetworkTp();
+ if ((srcTp == null) || (destTp == null) || input.getServiceRate() == null) {
+ LOG.error("Source ({}) or destination ({}) termination point is null.", srcTp, destTp);
+ return;
+ }
+ // if the node is currently mounted then proceed.
+ if (this.deviceTransactionManager.isDeviceMounted(nodeId)) {
+ switch (input.getServiceRate()) {
+ case("10G"):
+ interfacesToDelete.add(srcTp + "-ODU2e-" + input.getServiceName());
+ interfacesToDelete.add(destTp + "-ODU2e-" + input.getServiceName());
+ case("1G"):
+ interfacesToDelete.add(srcTp + "-ODU0-" + input.getServiceName());
+ interfacesToDelete.add(destTp + "-ODU0-" + input.getServiceName());
+ }
+ String connectionNumber = interfacesToDelete.get(0) + "-x-" + interfacesToDelete.get(1);
+ List<String> intToDelete = this.crossConnect.deleteCrossConnect(nodeId, connectionNumber);
+ if (intToDelete != null) {
+ for (String interf : intToDelete) {
+ if (!this.openRoadmInterfaceFactory.isUsedbyXc(nodeId, interf, connectionNumber,
+ this.deviceTransactionManager)) {
+ interfacesToDelete.add(interf);
+ }
+ }
+ }
+ } else {
+ String result = nodeId + " is not mounted on the controller";
+ results.add(result);
+ success.set(false);
+ LOG.warn(result);
+ forkJoinPool.shutdown();
+ return;
+ //TODO should deletion end here?
+ }
+ for (String interfaceId : interfacesToDelete) {
+ try {
+ this.openRoadmInterfaces.deleteInterface(nodeId, interfaceId);
+ } catch (OpenRoadmInterfaceException e) {
+ String result = String.format("Failed to delete interface %s on node %s!", interfaceId, nodeId);
+ success.set(false);
+ LOG.error(result, e);
+ results.add(result);
+ }
+ }
+ }));
+ try {
+ forkJoinTask.get();
+ } catch (InterruptedException | ExecutionException e) {
+ LOG.error("Error while deleting service paths!", e);
+ }
+ forkJoinPool.shutdown();
+ OtnServicePathOutputBuilder delServBldr = new OtnServicePathOutputBuilder();
+ delServBldr.setSuccess(success.get());
+ if (results.isEmpty()) {
+ return delServBldr.setResult("Request processed").build();
+ } else {
+ return delServBldr.setResult(String.join("\n", results)).build();
+ }
+
}
private List<NodeInterface> createInterface(OtnServicePathInput input) throws OpenRoadmInterfaceException {
List<NodeInterface> nodeInterfaces = new ArrayList<>();
+ LOG.info("Calling Create Interface entry for OTN service path");
if (input.getServiceRate().equals("1G")) {
for (Nodes node: input.getNodes()) {
+ LOG.info("Input service is 1G");
//check if the node is mounted or not?
+ List<String> createdConnections = new ArrayList<>();
List<String> createdEthInterfaces = new ArrayList<>();
List<String> createdOduInterfaces = new ArrayList<>();
- createdEthInterfaces.add(openRoadmInterfaceFactory.createOpenRoadmEth1GInterface(node.getNodeId(),
- node.getClientTp()));
- LOG.info("created ethernet interface");
- createdOduInterfaces.add(openRoadmInterfaceFactory.createOpenRoadmOdu0Interface(node.getNodeId(),
- node.getClientTp(), input.getServiceName(),"07", false, input.getTribPortNumber(),
- input.getTribSlot())); //suppporting interface?, payload ?
- LOG.info("Created odu interface client side");
- createdOduInterfaces.add(openRoadmInterfaceFactory.createOpenRoadmOdu0Interface(node.getNodeId(),
- node.getNetworkTp(), input.getServiceName(),"07", true, input.getTribPortNumber(),
- input.getTribSlot()));
- LOG.info("created odu inteface network side");
+ createdEthInterfaces.add(
+ openRoadmInterfaceFactory.createOpenRoadmEth1GInterface(node.getNodeId(), node.getClientTp()));
+ LOG.debug("created ethernet interface {}",createdEthInterfaces.get(0));
+ createdOduInterfaces.add(
+ //suppporting interface?, payload ?
+ openRoadmInterfaceFactory.createOpenRoadmOdu0Interface(node.getNodeId(), node.getClientTp(),
+ input.getServiceName(), "07", false, input.getTribPortNumber(), input.getTribSlot()));
+ LOG.debug("Created odu interface client side {}",createdOduInterfaces.get(0));
+ createdOduInterfaces.add(
+ openRoadmInterfaceFactory.createOpenRoadmOdu0Interface(node.getNodeId(), node.getNetworkTp(),
+ input.getServiceName(), "07", true, input.getTribPortNumber(), input.getTribSlot()));
+ LOG.debug("created odu inteface network side {} {}",createdOduInterfaces.get(0),createdOduInterfaces.get(1));
- //implement cross connect
+ //implement cross connect
Optional<String> connectionNameOpt = postCrossConnect(createdOduInterfaces, node);
- List<String> createdConnections = new ArrayList<>();
createdConnections.add(connectionNameOpt.get());
LOG.info("Created cross connects");
NodeInterfaceBuilder nodeInterfaceBuilder = new NodeInterfaceBuilder()
- .withKey(new NodeInterfaceKey(node.getNodeId()))
- .setNodeId(node.getNodeId())
- .setConnectionId(createdConnections)
- .setEthInterfaceId(createdEthInterfaces)
- .setOduInterfaceId(createdOduInterfaces);
+ .withKey(new NodeInterfaceKey(input.getServiceName() + "-" + node.getNodeId()))
+ .setNodeId(input.getServiceName() + "-" + node.getNodeId())
+ .setConnectionId(createdConnections)
+ .setEthInterfaceId(createdEthInterfaces)
+ .setOduInterfaceId(createdOduInterfaces);
nodeInterfaces.add(nodeInterfaceBuilder.build());
}
}
// implementing ODU2e for now
for (Nodes node: input.getNodes()) {
+ LOG.info("Input service is 10G");
//check if the node is mounted or not?
+ List<String> createdConnections = new ArrayList<>();
List<String> createdEthInterfaces = new ArrayList<>();
List<String> createdOduInterfaces = new ArrayList<>();
- createdEthInterfaces.add(openRoadmInterfaceFactory.createOpenRoadmEth10GInterface(node.getNodeId(),
- node.getClientTp()));
- createdOduInterfaces.add(openRoadmInterfaceFactory.createOpenRoadmOdu2eInterface(node.getNodeId(),
- node.getClientTp(), input.getServiceName(),"03", false)); //suppporting interface?, payload ?
- createdOduInterfaces.add(openRoadmInterfaceFactory.createOpenRoadmOdu2eInterface(node.getNodeId(),
- node.getNetworkTp(), input.getServiceName(),"03" , true));// supporting interface? payload ?
-
+ createdEthInterfaces.add(
+ openRoadmInterfaceFactory.createOpenRoadmEth10GInterface(node.getNodeId(), node.getClientTp()));
+ createdOduInterfaces.add(
+ //suppporting interface?, payload ?
+ openRoadmInterfaceFactory.createOpenRoadmOdu2eInterface(node.getNodeId(), node.getClientTp(),
+ input.getServiceName(),"03", false ,input.getTribPortNumber(),input.getTribSlot()));
+ createdOduInterfaces.add(
+ // supporting interface? payload ?
+ openRoadmInterfaceFactory.createOpenRoadmOdu2eInterface(node.getNodeId(), node.getNetworkTp(),
+ input.getServiceName(),"03" , true ,input.getTribPortNumber(),input.getTribSlot()));
//implement cross connect
Optional<String> connectionNameOpt = postCrossConnect(createdOduInterfaces, node);
- List<String> createdConnections = new ArrayList<>();
createdConnections.add(connectionNameOpt.get());
LOG.info("Created cross connects");
+ LOG.info("Now creating node interface builder");
NodeInterfaceBuilder nodeInterfaceBuilder = new NodeInterfaceBuilder();
- nodeInterfaceBuilder.withKey(new NodeInterfaceKey(node.getNodeId()))
- .setNodeId(node.getNodeId())
- .setConnectionId(createdConnections)
- .setEthInterfaceId(createdEthInterfaces)
- .setOduInterfaceId(createdOduInterfaces);
+ LOG.info("Now Created node interface builder");
+ nodeInterfaceBuilder.withKey(new NodeInterfaceKey(input.getServiceName() + "-" + node.getNodeId()));
+ nodeInterfaceBuilder.setNodeId(input.getServiceName() + "-" + node.getNodeId());
+ LOG.info("Now Ids are set");
+ nodeInterfaceBuilder.setConnectionId(createdConnections);
+ LOG.info("Now connections are set");
+ nodeInterfaceBuilder.setEthInterfaceId(createdEthInterfaces);
+ nodeInterfaceBuilder.setOduInterfaceId(createdOduInterfaces);
+ LOG.info("Now Interfaces are set");
nodeInterfaces.add(nodeInterfaceBuilder.build());
+ LOG.info("Everythiong is done and now returning ");
}
}
return nodeInterfaces;
}
private Optional<String> postCrossConnect(List<String> createdOduInterfaces, Nodes node)
- throws OpenRoadmInterfaceException {
+ throws OpenRoadmInterfaceException {
return this.crossConnect.postOtnCrossConnect(createdOduInterfaces,node);
}
}
</bean>
<bean id="openRoadmOtnInterface"
- class="org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmOTNInterface">
+ class="org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmOtnInterface221">
<argument ref="portMapping"/>
<argument ref="openRoadmInterfaces"/>
</bean>
<bean id="otnDeviceRenderer" class="org.opendaylight.transportpce.renderer.provisiondevice.OtnDeviceRendererServiceImpl" >
<argument ref="openRoadmInterfaceFactory" />
<argument ref="crossConnect" />
+ <argument ref="openRoadmInterfaces" />
+ <argument ref="deviceTransactionManager" />
</bean>
<bean id="deviceRendererRPCImpl" class="org.opendaylight.transportpce.renderer.rpcs.DeviceRendererRPCImpl" >
import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterface121;
import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterface221;
import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterfaceFactory;
-import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmOTNInterface;
+import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmOtnInterface221;
import org.opendaylight.transportpce.renderer.stub.MountPointServiceStub;
import org.opendaylight.transportpce.renderer.utils.CreateOtsOmsDataUtils;
import org.opendaylight.transportpce.renderer.utils.MountPointUtils;
OpenRoadmInterface121 openRoadmInterface121 = new OpenRoadmInterface121(portMapping,openRoadmInterfaces);
OpenRoadmInterface221 openRoadmInterface221 = new OpenRoadmInterface221(portMapping,openRoadmInterfaces,
fixedFlexInterface);
- OpenRoadmOTNInterface openRoadmOTNInterface = new OpenRoadmOTNInterface(portMapping, openRoadmInterfaces);
+ OpenRoadmOtnInterface221 openRoadmOTNInterface = new OpenRoadmOtnInterface221(portMapping, openRoadmInterfaces);
this.openRoadmInterfaceFactory = new OpenRoadmInterfaceFactory(this.mappingUtils,openRoadmInterface121,
openRoadmInterface221, openRoadmOTNInterface);
import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterface121;
import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterface221;
import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterfaceFactory;
-import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmOTNInterface;
+import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmOtnInterface221;
import org.opendaylight.transportpce.renderer.stub.MountPointServiceStub;
import org.opendaylight.transportpce.renderer.stub.MountPointStub;
import org.opendaylight.transportpce.renderer.stub.OlmServiceStub;
OpenRoadmInterface121 openRoadmInterface121 = new OpenRoadmInterface121(portMapping,openRoadmInterfaces);
OpenRoadmInterface221 openRoadmInterface221 = new OpenRoadmInterface221(portMapping,openRoadmInterfaces,
fixedFlexInterface);
- OpenRoadmOTNInterface openRoadmOTNInterface = new OpenRoadmOTNInterface(portMapping, openRoadmInterfaces);
+ OpenRoadmOtnInterface221 openRoadmOTNInterface = new OpenRoadmOtnInterface221(portMapping, openRoadmInterfaces);
OpenRoadmInterfaceFactory openRoadmInterfaceFactory = new OpenRoadmInterfaceFactory(this.mappingUtils,
openRoadmInterface121, openRoadmInterface221, openRoadmOTNInterface);
import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterface121;
import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterface221;
import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterfaceFactory;
-import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmOTNInterface;
+import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmOtnInterface221;
import org.opendaylight.transportpce.renderer.stub.MountPointServiceStub;
import org.opendaylight.transportpce.renderer.stub.MountPointStub;
import org.opendaylight.transportpce.renderer.stub.OlmServiceStub;
OpenRoadmInterface121 openRoadmInterface121 = new OpenRoadmInterface121(portMapping,openRoadmInterfaces);
OpenRoadmInterface221 openRoadmInterface221 = new OpenRoadmInterface221(portMapping,openRoadmInterfaces,
fixedFlexInterface);
- OpenRoadmOTNInterface openRoadmOTNInterface = new OpenRoadmOTNInterface(portMapping, openRoadmInterfaces);
+ OpenRoadmOtnInterface221 openRoadmOTNInterface = new OpenRoadmOtnInterface221(portMapping, openRoadmInterfaces);
this.openRoadmInterfaceFactory = new OpenRoadmInterfaceFactory(this.mappingUtils,openRoadmInterface121,
openRoadmInterface221, openRoadmOTNInterface);
this.crossConnectImpl121 = new CrossConnectImpl121(deviceTransactionManager);
Code Review / transportpce.git / commitdiff