</dependency>
</dependencies>
-<!-- checkstyle and spotbugds enforced by odlparent since Magnesium -->
- <properties>
- <!-- odlparent.checkstyle.enforce>false</odlparent.checkstyle.enforce -->
- <odlparent.spotbugs.enforce>false</odlparent.spotbugs.enforce>
- </properties>
-
</project>
package org.opendaylight.transportpce.renderer;
import com.google.common.util.concurrent.ListenableFuture;
+
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+
+
public final class ModelMappingUtils {
private static final Logger LOG = LoggerFactory.getLogger(ModelMappingUtils.class);
public static ServicePowerSetupInput createServicePowerSetupInput(List<Nodes> olmList,
ServiceImplementationRequestInput input) {
ServicePowerSetupInputBuilder olmSetupBldr = new ServicePowerSetupInputBuilder()
- .setNodes(olmList)
- .setWaveNumber(input.getPathDescription().getAToZDirection().getAToZWavelengthNumber());
+ .setNodes(olmList);
+ if (input != null && input.getPathDescription() != null
+ && input.getPathDescription().getAToZDirection() != null) {
+ olmSetupBldr.setWaveNumber(
+ input.getPathDescription().getAToZDirection().getAToZWavelengthNumber());
+ }
return olmSetupBldr.build();
}
}
int[] pos = findTheLongestSubstring(nodeID, tpID);
- //TODO: do not rely on nodeId to be integer
- int id = Integer.parseInt(sortId);
- treeMap.put(id, new NodeIdPair(nodeID.substring(0, pos[0] - 1), tpID));
- } else if (resourceType.equals("Link")) {
+ if (pos != null) {
+ //TODO: do not rely on nodeId to be integer
+ int id = Integer.parseInt(sortId);
+ treeMap.put(id, new NodeIdPair(nodeID.substring(0, pos[0] - 1), tpID));
+ }
+ } else if ("Link".equals(resourceType)) {
LOG.info("The type is link");
} else {
LOG.info("The type is not indentified: {}", resourceType);
}
} catch (IllegalArgumentException | SecurityException e) {
- // TODO Auto-generated catch block
LOG.error("Dont find the getResource method", e);
}
}
- String desID = null;
- String srcID = null;
- for (NodeIdPair values : treeMap.values()) {
- if (srcID == null) {
- srcID = values.getTpID();
- } else if (desID == null) {
- desID = values.getTpID();
- NodesBuilder nb = new NodesBuilder()
- .withKey(new NodesKey(values.getNodeID()))
- .setDestTp(desID)
- .setSrcTp(srcID);
- list.add(nb.build());
-
- NodesBuilder olmNb = new NodesBuilder()
- .setNodeId(values.getNodeID())
- .setDestTp(desID)
- .setSrcTp(srcID);
- olmList.add(olmNb.build());
- srcID = null;
- desID = null;
- } else {
- LOG.warn("both, the source and destination id are null!");
- }
- }
+ populateNodeLists(treeMap, list, olmList);
return new NodeLists(olmList, list);
}
}
int[] pos = findTheLongestSubstring(nodeID, tpID);
- //TODO: do not rely on nodeId to be integer
- int id = Integer.parseInt(sortId);
- treeMap.put(id, new NodeIdPair(nodeID.substring(0, pos[0] - 1), tpID));
- } else if (resourceType.equals("Link")) {
+ if (pos != null) {
+ //TODO: do not rely on nodeId to be integer
+ int id = Integer.parseInt(sortId);
+ treeMap.put(id, new NodeIdPair(nodeID.substring(0, pos[0] - 1), tpID));
+ }
+ } else if ("Link".equals(resourceType)) {
LOG.info("The type is link");
} else {
LOG.info("The type is not indentified: {}", resourceType);
}
}
+ populateNodeLists(treeMap, list, olmList);
+ return new NodeLists(olmList, list);
+ }
+
+ @edu.umd.cs.findbugs.annotations.SuppressFBWarnings(
+ value = {"NP_LOAD_OF_KNOWN_NULL_VALUE","RCN_REDUNDANT_NULLCHECK_OF_NULL_VALUE"},
+ justification = "loop when value is not always null - "
+ + "TODO: check if something exists in Java lib")
+ private static void populateNodeLists(Map<Integer, NodeIdPair> treeMap,
+ List<Nodes> list, List<Nodes> olmList) {
String desID = null;
String srcID = null;
for (NodeIdPair values : treeMap.values()) {
LOG.warn("both, the source and destination id are null!");
}
}
- return new NodeLists(olmList, list);
}
+ @edu.umd.cs.findbugs.annotations.SuppressFBWarnings(
+ value = "PZLA_PREFER_ZERO_LENGTH_ARRAYS",
+ justification = "not relevant to return and zero length array"
+ + " as we need real pos")
public static int[] findTheLongestSubstring(String s1, String s2) {
if ((s1 == null) || (s2 == null)) {
return null;
import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200128.network.nodes.Mapping;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev161014.PowerDBm;
-
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.InterfaceBuilder;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.InterfaceKey;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.OrgOpenroadmDevice;
import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev161014.Interface1;
import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev161014.Interface1Builder;
import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev161014.ethernet.container.EthernetBuilder;
-
import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev161014.EthernetCsmacd;
import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev161014.InterfaceType;
import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev161014.OpenROADMOpticalMultiplex;
public class OpenRoadmInterface121 {
+ private static final String MAPPING_MSG_ERROR =
+ "Unable to get mapping from PortMapping for node % and logical connection port %s";
private final PortMapping portMapping;
private final OpenRoadmInterfaces openRoadmInterfaces;
- private static final Logger LOG = LoggerFactory.getLogger(OpenRoadmInterfaceFactory.class);
+ private static final Logger LOG = LoggerFactory.getLogger(OpenRoadmInterface121.class);
public OpenRoadmInterface121(PortMapping portMapping, OpenRoadmInterfaces openRoadmInterfaces) {
this.portMapping = portMapping;
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(MAPPING_MSG_ERROR, nodeId, logicalConnPoint));
}
// Ethernet interface specific data
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(MAPPING_MSG_ERROR, nodeId, logicalConnPoint));
}
// Create generic interface
InterfaceBuilder otuInterfaceBldr = createGenericInterfaceBuilder(portMap, OtnOtu.class, logicalConnPoint
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(MAPPING_MSG_ERROR, nodeId, logicalConnPoint));
}
InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(portMap, OtnOdu.class, logicalConnPoint
+ "-ODU");
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
+import java.util.Locale;
import java.util.Optional;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
OduBuilder oduIfBuilder = new OduBuilder()
.setRate(ODU4.class)
.setMonitoringMode(OduAttributes.MonitoringMode.Terminated);
- if (!nodeId.toLowerCase().contains("eci")) {
+ if (!nodeId.toLowerCase(Locale.getDefault()).contains("eci")) {
oduIfBuilder.setTxDapi("");
oduIfBuilder.setTxSapi("");
}
public class OpenRoadmInterfaceFactory {
+ private static final String OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG =
+ "OTN funtions are not supported by Openroadm models 1.2.1";
private static final Logger LOG = LoggerFactory.getLogger(OpenRoadmInterfaceFactory.class);
private final MappingUtils mappingUtils;
private final OpenRoadmInterface121 openRoadmInterface121;
}
}
- public boolean isUsedbyXc(String nodeId, String interfaceName, String xc,
+ public boolean isUsedByXc(String nodeId, String interfaceName, String xc,
DeviceTransactionManager deviceTransactionManager) {
switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
}
}
- public boolean isUsedbyOtnXc(String nodeId, String interfaceName, String xc,
+ public boolean isUsedByOtnXc(String nodeId, String interfaceName, String xc,
DeviceTransactionManager deviceTransactionManager) {
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");
+ LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG);
return false;
case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
return openRoadmInterface221.isUsedByOtnXc(nodeId, interfaceName, xc, deviceTransactionManager);
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");
+ 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 openRoadmOtnInterface.createOpenRoadmEth1GInterface(nodeId, logicalConnPoint);
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");
+ 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 openRoadmOtnInterface.createOpenRoadmEth10GInterface(nodeId, 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");
+ 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 openRoadmOtnInterface.createOpenRoadmOdu0Interface(
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");
+ 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 openRoadmOtnInterface.createOpenRoadmOdu2Interface(
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");
+ 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 openRoadmOtnInterface.createOpenRoadmOdu2eInterface(
private final PortMapping portMapping;
private final OpenRoadmInterfaces openRoadmInterfaces;
- private static final Logger LOG = LoggerFactory.getLogger(OpenRoadmOtnInterface221.class);
+ private static final Logger LOG = LoggerFactory
+ .getLogger(OpenRoadmOtnInterface221.class);
- public OpenRoadmOtnInterface221(PortMapping portMapping, OpenRoadmInterfaces openRoadmInterfaces) {
+ public OpenRoadmOtnInterface221(PortMapping portMapping,
+ OpenRoadmInterfaces openRoadmInterfaces) {
this.portMapping = portMapping;
this.openRoadmInterfaces = openRoadmInterfaces;
}
- public String createOpenRoadmEth1GInterface(String nodeId, String logicalConnPoint)
- throws OpenRoadmInterfaceException {
+ public String createOpenRoadmEth1GInterface(String nodeId,
+ String logicalConnPoint) 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));
+ throwException(nodeId, logicalConnPoint);
}
// Ethernet interface specific data
EthernetBuilder ethIfBuilder = new EthernetBuilder();
- //ethIfBuilder.setAutoNegotiation(EthAttributes.AutoNegotiation.Disabled);
ethIfBuilder.setSpeed(1000L);
- InterfaceBuilder ethInterfaceBldr =
- createGenericInterfaceBuilder(portMap, EthernetCsmacd.class, logicalConnPoint + "-ETHERNET1G");
+ InterfaceBuilder ethInterfaceBldr = createGenericInterfaceBuilder(
+ portMap, EthernetCsmacd.class,
+ logicalConnPoint + "-ETHERNET1G");
// Create Interface1 type object required for adding as augmentation
- Interface1Builder ethIf1Builder = new Interface1Builder();
- ethInterfaceBldr.addAugmentation(Interface1.class, ethIf1Builder.setEthernet(ethIfBuilder.build()).build());
+ Interface1Builder ethIf1Builder = new Interface1Builder();
+ ethInterfaceBldr.addAugmentation(Interface1.class,
+ ethIf1Builder.setEthernet(ethIfBuilder.build()).build());
// Post interface on the device
this.openRoadmInterfaces.postOTNInterface(nodeId, ethInterfaceBldr);
// Post the equipment-state change on the device circuit-pack
- this.openRoadmInterfaces.postOTNEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true);
- this.portMapping.updateMapping(nodeId,portMap);
+ this.openRoadmInterfaces.postOTNEquipmentState(nodeId,
+ portMap.getSupportingCircuitPackName(), true);
+ this.portMapping.updateMapping(nodeId, portMap);
String ethernetInterfaceName = ethInterfaceBldr.getName();
return ethernetInterfaceName;
}
+ private void throwException(String nodeId, String logicalConnPoint)
+ throws OpenRoadmInterfaceException {
+ throw new OpenRoadmInterfaceException(String.format(
+ "Unable to get mapping from PortMapping for node % and logical connection port %s",
+ nodeId, logicalConnPoint));
+ }
+
private InterfaceBuilder createGenericInterfaceBuilder(Mapping portMap,
Class<? extends InterfaceType> type, String key) {
InterfaceBuilder interfaceBuilder = new InterfaceBuilder()
- //.setDescription(" TBD ")
- //.setCircuitId(" TBD ")
- .setSupportingCircuitPackName(portMap.getSupportingCircuitPackName())
- .setSupportingPort(portMap.getSupportingPort())
- .setAdministrativeState(AdminStates.InService)
- //TODO get rid of unchecked cast warning
- .setType(
- (Class<? extends InterfaceType>)
- type
- )
- .setName(key)
- .withKey(new InterfaceKey(key));
+ // .setDescription(" TBD ")
+ // .setCircuitId(" TBD ")
+ .setSupportingCircuitPackName(
+ portMap.getSupportingCircuitPackName())
+ .setSupportingPort(portMap.getSupportingPort())
+ .setAdministrativeState(AdminStates.InService)
+ // TODO get rid of unchecked cast warning
+ .setType(type).setName(key).withKey(new InterfaceKey(key));
return interfaceBuilder;
}
- public String createOpenRoadmEth10GInterface(String nodeId, String logicalConnPoint)
- throws OpenRoadmInterfaceException {
+ public String createOpenRoadmEth10GInterface(String nodeId,
+ String logicalConnPoint) 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));
+ throwException(nodeId, logicalConnPoint);
}
// Ethernet interface specific data
EthernetBuilder ethIfBuilder = new EthernetBuilder()
- //.setAutoNegotiation(EthAttributes.AutoNegotiation.Disabled)
- .setSpeed(10000L);
+ // .setAutoNegotiation(EthAttributes.AutoNegotiation.Disabled)
+ .setSpeed(10000L);
// Create Interface1 type object required for adding as augmentation
- Interface1Builder ethIf1Builder = new Interface1Builder();
- InterfaceBuilder ethInterfaceBldr =
- createGenericInterfaceBuilder(portMap, EthernetCsmacd.class, logicalConnPoint + "-ETHERNET10G")
- .addAugmentation(Interface1.class, ethIf1Builder.setEthernet(ethIfBuilder.build()).build());
+ Interface1Builder ethIf1Builder = new Interface1Builder();
+ InterfaceBuilder ethInterfaceBldr = createGenericInterfaceBuilder(portMap, EthernetCsmacd.class,
+ logicalConnPoint + "-ETHERNET10G").addAugmentation(Interface1.class,
+ ethIf1Builder.setEthernet(ethIfBuilder.build()).build());
// Post interface on the device
this.openRoadmInterfaces.postOTNInterface(nodeId, ethInterfaceBldr);
// Post the equipment-state change on the device circuit-pack
- this.openRoadmInterfaces.postOTNEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true);
- this.portMapping.updateMapping(nodeId,portMap);
+ this.openRoadmInterfaces.postOTNEquipmentState(nodeId,
+ portMap.getSupportingCircuitPackName(), true);
+ this.portMapping.updateMapping(nodeId, portMap);
String ethernetInterfaceName = ethInterfaceBldr.getName();
return ethernetInterfaceName;
}
-
- public String createOpenRoadmOdu2eInterface(
- String nodeId, String logicalConnPoint, String serviceName,
- String payLoad, boolean isNetworkPort, int tribPortNumber, int tribSlotIndex)
+ 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));
+ throwException(nodeId, logicalConnPoint);
}
String supportingInterface = null;
if (supportingInterface == null) {
throw new OpenRoadmInterfaceException(
- "Interface Creation failed because of missing supported ODU4 on network end or Eth iface on client");
+ "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);
+ InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(
+ portMap, OtnOdu.class,
+ logicalConnPoint + "-ODU2e-" + serviceName)
+ .setSupportingInterface(supportingInterface);
// ODU interface specific data
- OduBuilder oduIfBuilder = new OduBuilder()
- .setRate(ODU2e.class)
- .setOduFunction(ODUTTPCTP.class)
- .setMonitoringMode(OduAttributes.MonitoringMode.Terminated);
- LOG.debug("Inside the ODU2e creation {} {} {}",isNetworkPort,tribPortNumber,tribSlotIndex);
+ OduBuilder oduIfBuilder = new OduBuilder().setRate(ODU2e.class)
+ .setOduFunction(ODUTTPCTP.class)
+ .setMonitoringMode(OduAttributes.MonitoringMode.Terminated);
+ LOG.debug("Inside the ODU2e creation {} {} {}", isNetworkPort,
+ tribPortNumber, tribSlotIndex);
if (isNetworkPort) {
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))
- );
+ IntStream.range(tribSlotIndex, tribSlotIndex + 8)
+ .forEach(nbr -> tribSlots.add(Uint16.valueOf(nbr)));
ParentOduAllocationBuilder parentOduAllocationBuilder = new ParentOduAllocationBuilder()
- .setTribPortNumber(tribPortNumber)
- .setTribSlots(tribSlots);
+ .setTribPortNumber(tribPortNumber).setTribSlots(tribSlots);
oduIfBuilder.setOduFunction(ODUCTP.class)
.setMonitoringMode(OduAttributes.MonitoringMode.Monitored)
.setParentOduAllocation(parentOduAllocationBuilder.build());
- }
- else {
+ } else {
// Set Opu attributes
OpuBuilder opuBldr = new OpuBuilder()
.setPayloadType(new PayloadTypeDef(payLoad))
}
// 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
+ 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());
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;
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));
+ throwException(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
- OduBuilder oduIfBuilder = new OduBuilder()
- .setRate(ODU0.class)
- .setOduFunction(ODUTTPCTP.class)
- .setMonitoringMode(OduAttributes.MonitoringMode.Terminated);
+ OduBuilder oduIfBuilder = new OduBuilder().setRate(ODU0.class)
+ .setOduFunction(ODUTTPCTP.class)
+ .setMonitoringMode(OduAttributes.MonitoringMode.Terminated);
if (isNetworkPort) {
LOG.debug("Network port is true");
List<Uint16> tribSlots = new ArrayList<>();
- tribSlots.add(Uint16.valueOf(tribSlot)); //add trib slots
+ // add trib slots
+ tribSlots.add(Uint16.valueOf(tribSlot));
ParentOduAllocationBuilder parentOduAllocationBuilder = new ParentOduAllocationBuilder()
- //set trib port numbers
- .setTribPortNumber(tribPortNumber)
- .setTribSlots(tribSlots);
+ // set trib port numbers
+ .setTribPortNumber(tribPortNumber).setTribSlots(tribSlots);
oduIfBuilder.setOduFunction(ODUCTP.class)
.setMonitoringMode(OduAttributes.MonitoringMode.Monitored)
.setParentOduAllocation(parentOduAllocationBuilder.build());
oduIfBuilder.getParentOduAllocation().getTribSlots(),
oduIfBuilder.getRate(),
oduIfBuilder.getParentOduAllocation().getTribPortNumber());
- }
- else {
+ } else {
LOG.debug("Current port is a client port");
OpuBuilder opuBldr = new OpuBuilder()
.setPayloadType(new PayloadTypeDef(payLoad))
}
// 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
+ 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());
return oduInterfaceBldr.getName();
}
-
- public String createOpenRoadmOdu2Interface(
- String nodeId, String logicalConnPoint, String serviceName,
- String payLoad, boolean isNetworkPort, int tribPortNumber, int tribSlotIndex)
+ 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 (isNetworkPort) {
- supportingInterface = portMap.getSupportingOdu4();
+ if (portMap != null) {
+ if (isNetworkPort) {
+ supportingInterface = portMap.getSupportingOdu4();
+ } else {
+ supportingInterface = portMap.getSupportingEthernet();
+ }
} 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));
+ throwException(nodeId, logicalConnPoint);
}
- InterfaceBuilder oduInterfaceBldr =
- createGenericInterfaceBuilder(portMap, OtnOdu.class, logicalConnPoint + "-ODU2-" + serviceName)
- .setSupportingInterface(supportingInterface);
+ 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);
+ OduBuilder oduIfBuilder = new OduBuilder().setRate(ODU2.class)
+ .setOduFunction(ODUTTPCTP.class)
+ .setMonitoringMode(OduAttributes.MonitoringMode.Terminated);
if (isNetworkPort) {
List<Uint16> tribSlots = new ArrayList<>();
- IntStream.range(tribSlotIndex, tribSlotIndex + 8).forEach(
- nbr -> tribSlots.add(Uint16.valueOf(nbr))
- );
+ IntStream.range(tribSlotIndex, tribSlotIndex + 8)
+ .forEach(nbr -> tribSlots.add(Uint16.valueOf(nbr)));
ParentOduAllocationBuilder parentOduAllocationBuilder = new ParentOduAllocationBuilder()
- //set trib port numbers
- .setTribPortNumber(tribPortNumber)
- .setTribSlots(tribSlots);
+ // set trib port numbers
+ .setTribPortNumber(tribPortNumber).setTribSlots(tribSlots);
oduIfBuilder.setOduFunction(ODUCTP.class)
.setMonitoringMode(OduAttributes.MonitoringMode.Monitored)
.setParentOduAllocation(parentOduAllocationBuilder.build());
- }
- else {
+ } else {
// Set Opu attributes
OpuBuilder opuBldr = new OpuBuilder()
.setPayloadType(new PayloadTypeDef(payLoad))
// 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 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
+ 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());
import com.google.common.collect.Sets;
import com.google.common.util.concurrent.FluentFuture;
+
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicBoolean;
+
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.ReadTransaction;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+
+
public class DeviceRendererServiceImpl implements DeviceRendererService {
+ private static final String ODU4 = "-ODU4";
private static final Logger LOG = LoggerFactory.getLogger(DeviceRendererServiceImpl.class);
private final DataBroker dataBroker;
private final DeviceTransactionManager deviceTransactionManager;
private ConcurrentLinkedQueue<String> processErrorMessage(String message, ForkJoinPool forkJoinPool,
ConcurrentLinkedQueue<String> messages) {
- LOG.warn(message);
+ LOG.warn("Received error message {}", message);
messages.add(message);
forkJoinPool.shutdown();
return messages;
}
// if the node is currently mounted then proceed.
if (this.deviceTransactionManager.isDeviceMounted(nodeId)) {
- if (destTp.contains(StringConstants.NETWORK_TOKEN)
- || srcTp.contains(StringConstants.CLIENT_TOKEN)
- || srcTp.contains(StringConstants.NETWORK_TOKEN)
- || destTp.contains(StringConstants.CLIENT_TOKEN)) {
- if (destTp.contains(StringConstants.NETWORK_TOKEN)) {
- try {
- if (this.openRoadmInterfaces.getInterface(nodeId, destTp + "-ODU").isPresent()) {
- interfacesToDelete.add(destTp + "-ODU");
- }
- if (this.openRoadmInterfaces.getInterface(nodeId, destTp + "-ODU4").isPresent()) {
- interfacesToDelete.add(destTp + "-ODU4");
- }
- }
- catch (OpenRoadmInterfaceException e) {
- LOG.error("impossible to get interface {} or {}", destTp + "-ODU", destTp + "-ODU4", e);
- }
- interfacesToDelete.add(destTp + "-OTU");
- interfacesToDelete.add(
- this.openRoadmInterfaceFactory.createOpenRoadmOchInterfaceName(destTp, waveNumber));
- }
- if (srcTp.contains(StringConstants.NETWORK_TOKEN)) {
- interfacesToDelete.add(srcTp + "-ODU");
- interfacesToDelete.add(srcTp + "-OTU");
- interfacesToDelete
- .add(this.openRoadmInterfaceFactory.createOpenRoadmOchInterfaceName(srcTp, waveNumber));
- }
- if (srcTp.contains(StringConstants.CLIENT_TOKEN)) {
- interfacesToDelete.add(srcTp + "-ETHERNET");
- }
- if (destTp.contains(StringConstants.CLIENT_TOKEN)) {
- interfacesToDelete.add(destTp + "-ETHERNET");
- }
- } else {
- String connectionNumber = srcTp + "-" + destTp + "-" + waveNumber;
- List<String> intToDelete = this.crossConnect.deleteCrossConnect(nodeId, connectionNumber, false);
- connectionNumber = destTp + "-" + srcTp + "-" + waveNumber;
- if (intToDelete != null) {
- for (String interf : intToDelete) {
- if (!this.openRoadmInterfaceFactory.isUsedbyXc(nodeId, interf, connectionNumber,
- this.deviceTransactionManager)) {
- interfacesToDelete.add(interf);
- }
- }
- }
- }
+ interfacesToDelete.addAll(getInterfaces2delete(nodeId, srcTp, destTp, waveNumber));
} else {
String result = nodeId + " is not mounted on the controller";
results.add(result);
}
}
+ private List<String> getInterfaces2delete(
+ String nodeId, String srcTp, String destTp, Long waveNumber) {
+ List<String> interfacesToDelete = new LinkedList<>();
+ if (destTp.contains(StringConstants.NETWORK_TOKEN)
+ || srcTp.contains(StringConstants.CLIENT_TOKEN)
+ || srcTp.contains(StringConstants.NETWORK_TOKEN)
+ || destTp.contains(StringConstants.CLIENT_TOKEN)) {
+ if (destTp.contains(StringConstants.NETWORK_TOKEN)) {
+ try {
+ if (this.openRoadmInterfaces.getInterface(nodeId, destTp + "-ODU").isPresent()) {
+ interfacesToDelete.add(destTp + "-ODU");
+ }
+ if (this.openRoadmInterfaces.getInterface(nodeId, destTp + ODU4).isPresent()) {
+ interfacesToDelete.add(destTp + ODU4);
+ }
+ }
+ catch (OpenRoadmInterfaceException e) {
+ LOG.error("impossible to get interface {} or {}", destTp + "-ODU", destTp + ODU4, e);
+ }
+ interfacesToDelete.add(destTp + "-OTU");
+ interfacesToDelete.add(
+ this.openRoadmInterfaceFactory.createOpenRoadmOchInterfaceName(destTp, waveNumber));
+ }
+ if (srcTp.contains(StringConstants.NETWORK_TOKEN)) {
+ interfacesToDelete.add(srcTp + "-ODU");
+ interfacesToDelete.add(srcTp + "-OTU");
+ interfacesToDelete
+ .add(this.openRoadmInterfaceFactory.createOpenRoadmOchInterfaceName(srcTp, waveNumber));
+ }
+ if (srcTp.contains(StringConstants.CLIENT_TOKEN)) {
+ interfacesToDelete.add(srcTp + "-ETHERNET");
+ }
+ if (destTp.contains(StringConstants.CLIENT_TOKEN)) {
+ interfacesToDelete.add(destTp + "-ETHERNET");
+ }
+ } else {
+ String connectionNumber = srcTp + "-" + destTp + "-" + waveNumber;
+ List<String> intToDelete = this.crossConnect.deleteCrossConnect(nodeId, connectionNumber, false);
+ connectionNumber = destTp + "-" + srcTp + "-" + waveNumber;
+ if (intToDelete != null) {
+ for (String interf : intToDelete) {
+ if (!this.openRoadmInterfaceFactory.isUsedByXc(nodeId, interf, connectionNumber,
+ this.deviceTransactionManager)) {
+ interfacesToDelete.add(interf);
+ }
+ }
+ }
+ }
+ return interfacesToDelete;
+ }
+
@Override
public RendererRollbackOutput rendererRollback(RendererRollbackInput input) {
boolean success = true;
}
} else {
result = input.getNodeId() + " is not mounted on the controller";
- LOG.warn(result);
+ LOG.warn("{} is not mounted on the controller",input.getNodeId());
}
return output.setResult(result).setSuccess(success).build();
}
import org.slf4j.LoggerFactory;
public class OtnDeviceRendererServiceImpl implements OtnDeviceRendererService {
+ private static final String ODU2E = "-ODU2e-";
private static final Logger LOG = LoggerFactory.getLogger(OtnDeviceRendererServiceImpl.class);
private final OpenRoadmInterfaceFactory openRoadmInterfaceFactory;
private final CrossConnect crossConnect;
String connectionNumber = "";
switch (input.getServiceRate()) {
case("10G"):
- connectionNumber = srcTp + "-ODU2e-" + input.getServiceName() + "-x-" + destTp
- + "-ODU2e-" + input.getServiceName();
+ connectionNumber = srcTp + ODU2E + input.getServiceName() + "-x-" + destTp
+ + ODU2E + input.getServiceName();
break;
case("1G"):
connectionNumber = srcTp + "-ODU0-" + input.getServiceName() + "-x-" + destTp
- + "-ODU2e-" + input.getServiceName();
+ + ODU2E + input.getServiceName();
break;
default:
LOG.error("service rate {} not managed yet", input.getServiceRate());
List<String> intToDelete = this.crossConnect.deleteCrossConnect(nodeId, connectionNumber, true);
if (intToDelete != null) {
for (String interf : intToDelete) {
- if (!this.openRoadmInterfaceFactory.isUsedbyOtnXc(nodeId, interf, connectionNumber,
+ if (!this.openRoadmInterfaceFactory.isUsedByOtnXc(nodeId, interf, connectionNumber,
this.deviceTransactionManager)) {
interfacesToDelete.add(interf);
if (!getSupportedInterface(nodeId, interf).contains("ODU4")) {
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.ListeningExecutorService;
import com.google.common.util.concurrent.MoreExecutors;
+
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
+
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.mdsal.binding.api.ReadTransaction;
public class RendererServiceOperationsImpl implements RendererServiceOperations {
+ private static final String DEVICE_RENDERING_ROLL_BACK_MSG =
+ "Device rendering was not successful! Rendering will be rolled back.";
+ private static final String OLM_ROLL_BACK_MSG =
+ "OLM power setup was not successful! Rendering and OLM will be rolled back.";
+ private static final String RENDERING_DEVICES_A_Z_MSG = "Rendering devices A-Z";
+ private static final String TURNING_DOWN_POWER_ON_A_TO_Z_PATH_MSG = "Turning down power on A-to-Z path";
private static final Logger LOG = LoggerFactory.getLogger(RendererServiceOperationsImpl.class);
private static final String FAILED = "Failed";
private static final String OPERATION_FAILED = "Operation Failed";
deviceRendering(rollbackProcessor, servicePathInputDataAtoZ, servicePathInputDataZtoA);
if (rollbackProcessor.rollbackAllIfNecessary() > 0) {
sendNotifications(ServicePathNotificationTypes.ServiceImplementationRequest, input.getServiceName(),
- RpcStatusEx.Failed, "Device rendering was not successful! Rendering will be rolled back.");
+ RpcStatusEx.Failed, DEVICE_RENDERING_ROLL_BACK_MSG);
return ModelMappingUtils.createServiceImplResponse(ResponseCodes.RESPONSE_FAILED, OPERATION_FAILED);
}
ServicePowerSetupInput olmPowerSetupInputAtoZ =
if (rollbackProcessor.rollbackAllIfNecessary() > 0) {
sendNotifications(ServicePathNotificationTypes.ServiceImplementationRequest, input.getServiceName(),
RpcStatusEx.Failed,
- "OLM power setup was not successful! Rendering and OLM will be rolled back.");
+ OLM_ROLL_BACK_MSG);
return ModelMappingUtils.createServiceImplResponse(ResponseCodes.RESPONSE_FAILED, OPERATION_FAILED);
}
// run service activation test twice - once on source node and once on
});
}
+ @Override
@SuppressWarnings("checkstyle:IllegalCatch")
public OperationResult reserveResource(PathDescription pathDescription) {
return OperationResult.ok("Resources reserved successfully in network model");
}
+ @Override
@SuppressWarnings("checkstyle:IllegalCatch")
public OperationResult freeResource(PathDescription pathDescription) {
ModelMappingUtils.rendererCreateServiceInputZToA(serviceName, pathDescription);
// OLM turn down power
try {
- LOG.debug("Turning down power on A-to-Z path");
+ LOG.debug(TURNING_DOWN_POWER_ON_A_TO_Z_PATH_MSG);
sendNotifications(ServicePathNotificationTypes.ServiceDelete,
- input.getServiceName(), RpcStatusEx.Pending, "Turning down power on A-to-Z path");
+ input.getServiceName(), RpcStatusEx.Pending, TURNING_DOWN_POWER_ON_A_TO_Z_PATH_MSG);
ServicePowerTurndownOutput atozPowerTurndownOutput = olmPowerTurndown(servicePathInputDataAtoZ);
// TODO add some flag rather than string
if (FAILED.equals(atozPowerTurndownOutput.getResult())) {
}
+ @edu.umd.cs.findbugs.annotations.SuppressFBWarnings(
+ value = "UPM_UNCALLED_PRIVATE_METHOD",
+ justification = "call in call() method")
private ServicePowerTurndownOutput olmPowerTurndown(ServicePathInputData servicePathInputData)
throws InterruptedException, ExecutionException, TimeoutException {
- LOG.debug("Turning down power on A-to-Z path");
+ LOG.debug(TURNING_DOWN_POWER_ON_A_TO_Z_PATH_MSG);
Future<RpcResult<ServicePowerTurndownOutput>> powerTurndownFuture = this.olmService.servicePowerTurndown(
new ServicePowerTurndownInputBuilder(servicePathInputData.getServicePathInput()).build());
return powerTurndownFuture.get(Timeouts.DATASTORE_READ, TimeUnit.MILLISECONDS).getResult();
}
+ @edu.umd.cs.findbugs.annotations.SuppressFBWarnings(
+ value = "UPM_UNCALLED_PRIVATE_METHOD",
+ justification = "call in call() method")
private Optional<PathDescription> getPathDescriptionFromDatastore(String serviceName) {
InstanceIdentifier<PathDescription> pathDescriptionIID = InstanceIdentifier.create(ServicePathList.class)
.child(ServicePaths.class, new ServicePathsKey(serviceName)).child(PathDescription.class);
}
}
+ @edu.umd.cs.findbugs.annotations.SuppressFBWarnings(
+ value = "UPM_UNCALLED_PRIVATE_METHOD",
+ justification = "call in call() method")
private List<DeviceRenderingResult> deviceRendering(RollbackProcessor rollbackProcessor,
ServicePathInputData servicePathDataAtoZ, ServicePathInputData servicePathDataZtoA) {
- LOG.info("Rendering devices A-Z");
+ LOG.info(RENDERING_DEVICES_A_Z_MSG);
sendNotifications(ServicePathNotificationTypes.ServiceImplementationRequest,
servicePathDataAtoZ.getServicePathInput().getServiceName(), RpcStatusEx.Pending,
- "Rendering devices A-Z");
+ RENDERING_DEVICES_A_Z_MSG);
ListenableFuture<DeviceRenderingResult> atozrenderingFuture =
this.executor.submit(new DeviceRenderingTask(this.deviceRenderer, servicePathDataAtoZ,
ServicePathDirection.A_TO_Z));
LOG.info("Rendering devices Z-A");
sendNotifications(ServicePathNotificationTypes.ServiceImplementationRequest,
servicePathDataAtoZ.getServicePathInput().getServiceName(), RpcStatusEx.Pending,
- "Rendering devices A-Z");
+ RENDERING_DEVICES_A_Z_MSG);
ListenableFuture<DeviceRenderingResult> ztoarenderingFuture =
this.executor.submit(new DeviceRenderingTask(this.deviceRenderer, servicePathDataZtoA,
ServicePathDirection.Z_TO_A));
LOG.info("Waiting for A-Z and Z-A device renderers ...");
renderingResults = renderingCombinedFuture.get(Timeouts.RENDERING_TIMEOUT, TimeUnit.MILLISECONDS);
} catch (InterruptedException | ExecutionException | TimeoutException e) {
- LOG.warn("Device rendering was not successful! Rendering will be rolled back.", e);
+ LOG.warn(DEVICE_RENDERING_ROLL_BACK_MSG, e);
sendNotifications(ServicePathNotificationTypes.ServiceImplementationRequest,
servicePathDataAtoZ.getServicePathInput().getServiceName(), RpcStatusEx.Pending,
- "Device rendering was not successful! Rendering will be rolled back.");
+ DEVICE_RENDERING_ROLL_BACK_MSG);
//FIXME we can't do rollback here, because we don't have rendering results.
return renderingResults;
}
return renderingResults;
}
+ @edu.umd.cs.findbugs.annotations.SuppressFBWarnings(
+ value = "UPM_UNCALLED_PRIVATE_METHOD",
+ justification = "call in call() method")
private void olmPowerSetup(RollbackProcessor rollbackProcessor, ServicePowerSetupInput powerSetupInputAtoZ,
ServicePowerSetupInput powerSetupInputZtoA) {
LOG.info("Olm power setup A-Z");
LOG.info("Waiting for A-Z and Z-A OLM power setup ...");
olmResults = olmFutures.get(Timeouts.OLM_TIMEOUT, TimeUnit.MILLISECONDS);
} catch (InterruptedException | ExecutionException | TimeoutException e) {
- LOG.warn("OLM power setup was not successful! Rendering and OLM will be rolled back.", e);
+ LOG.warn(OLM_ROLL_BACK_MSG, e);
sendNotifications(ServicePathNotificationTypes.ServiceImplementationRequest,
powerSetupInputAtoZ.getServiceName(), RpcStatusEx.Pending,
- "OLM power setup was not successful! Rendering and OLM will be rolled back.");
+ OLM_ROLL_BACK_MSG);
rollbackProcessor.addTask(new OlmPowerSetupRollbackTask("AtoZOLMTask", true,
this.olmService, powerSetupInputAtoZ));
rollbackProcessor.addTask(new OlmPowerSetupRollbackTask("ZtoAOLMTask", true,
this.olmService, powerSetupInputZtoA));
}
+ @edu.umd.cs.findbugs.annotations.SuppressFBWarnings(
+ value = "UPM_UNCALLED_PRIVATE_METHOD",
+ justification = "call in call() method")
private boolean isServiceActivated(String nodeId, String tpId) {
LOG.info("Starting service activation test on node {} and tp {}", nodeId, tpId);
for (int i = 0; i < 3; i++) {
package org.opendaylight.transportpce.renderer.provisiondevice.otn;
import java.util.List;
+
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.CircuitPacks;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.OduSwitchingPools;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.odu.switching.pools.non.blocking.list.PortList;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.port.capability.rev181019.port.group.restriction.grp.PortGroupRestriction;
public interface OtnDeviceOperations {
/**
* This method checks if the client port can be used or not.
- *
- * @param nodeID unique identifier of a device
* @param circuitPackName circuit pack name of the client port
* @param portName port name of the client port
* @param capacity rate of the service needed
+ * @param portGroupRestriction TODO
+ *
* @return String which states whether the client port is valid or not
*/
- String validateClientPort(String nodeID, String circuitPackName, String portName, String capacity);
+ String validateClientPort(String circuitPackName, String portName, String capacity,
+ PortGroupRestriction portGroupRestriction);
/**
* This method retrieves the possible network ports.
*</p>
* @param circuitPackName Circuit pack name of the client port
* @param portName port name of the client port
+ * @param oduSwitchingPools TODO
+ * @param circuitPacks TODO
* @return List of all possible network ports
*/
- List<PortList> getPossibleNetworkPorts(String circuitPackName, String portName);
+ List<PortList> getPossibleNetworkPorts(String circuitPackName, String portName,
+ OduSwitchingPools oduSwitchingPools, CircuitPacks circuitPacks);
}
*/
package org.opendaylight.transportpce.renderer.provisiondevice.otn;
+import java.util.ArrayList;
import java.util.List;
+
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.CircuitPacks;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.circuit.pack.Ports;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.OduSwitchingPools;
public class OtnDeviceOperationsImpl implements OtnDeviceOperations {
@Override
- public String validateClientPort(String nodeID, String circuitPackName, String portName, String capacity) {
-
- PortGroupRestriction portGroupRestriction = null; //should not be initiated as null
- List<PortBandwidthSharing> portBandwidthSharingList = portGroupRestriction.getPortBandwidthSharing();
- for (PortBandwidthSharing portBandwidthSharing: portBandwidthSharingList) {
- List<PortList> portLists = portBandwidthSharing.getPortList();
- for (PortList portList: portLists) {
- if (portList.getCircuitPackName().equals(circuitPackName) && portList.getPortName().equals(portName)) {
- if (!usageOfOtherPorts(portBandwidthSharing,
- getConfigID(portBandwidthSharing, circuitPackName, portName))) {
- return "valid port";
- }
- else {
- return "not a valid port";
+ public String validateClientPort(String circuitPackName, String portName, String capacity,
+ PortGroupRestriction portGroupRestriction) {
+
+ List<PortBandwidthSharing> portBandwidthSharingList = portGroupRestriction
+ .getPortBandwidthSharing();
+ if (portGroupRestriction.getPortBandwidthSharing() != null) {
+ for (PortBandwidthSharing portBandwidthSharing : portBandwidthSharingList) {
+ List<PortList> portLists = portBandwidthSharing.getPortList();
+ for (PortList portList : portLists) {
+ if (portList.getCircuitPackName().equals(circuitPackName)
+ && portList.getPortName().equals(portName)) {
+ if (!usageOfOtherPorts(portBandwidthSharing,
+ getConfigID(portBandwidthSharing,
+ circuitPackName, portName))) {
+ return "valid port";
+ } else {
+ return "not a valid port";
+ }
}
}
}
}
- return "not valid circuitPackName or portName"; // if the client port is not found at all throw exception
+ // if the client port is not found at all throw exception
+ return "not valid circuitPackName or portName";
}
private Integer getConfigID(PortBandwidthSharing portBandwidthSharing, String circuitPackName, String portName) {
}
}
}
- return null; // throw exception if not able to get config id
+ // throw exception if not able to get config id
+ return null;
}
@Override
public List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org
.openroadm.device.container.org.openroadm.device.odu.switching.pools.non.blocking.list.PortList>
- getPossibleNetworkPorts(String circuitPackName, String portName) {
+ getPossibleNetworkPorts(String circuitPackName, String portName, OduSwitchingPools oduSwitchingPools,
+ CircuitPacks circuitPacks) {
List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org
.openroadm.device.container.org.openroadm.device.odu.switching
- .pools.non.blocking.list.PortList> networkPortList = null;
-
- //need a method to get swtiching pool object from device
-
- OduSwitchingPools oduSwitchingPools = null; // should not be initiated as null
+ .pools.non.blocking.list.PortList> networkPortList = new ArrayList<>();
List<NonBlockingList> nonBlockingLists = oduSwitchingPools.getNonBlockingList();
if (port.getCircuitPackName().equals(circuitPackName) && port.getPortName().equals(portName)) {
org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device
.container.org.openroadm.device.odu.switching.pools.non.blocking.list
- .PortList networkPort = checkNetworkPorts(nonBlockingList.getPortList());
+ .PortList networkPort = checkNetworkPorts(nonBlockingList.getPortList(), circuitPacks);
if (networkPort != null) {
networkPortList.add(networkPort);
}
private org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device
.container.org.openroadm.device.odu.switching.pools.non.blocking.list.PortList
checkNetworkPorts(List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org
- .openroadm.device.container.org.openroadm.device.odu.switching.pools.non.blocking.list.PortList> portList) {
- CircuitPacks circuitPacks = null;
-
+ .openroadm.device.container.org.openroadm.device.odu.switching.pools.non.blocking.list.PortList> portList,
+ CircuitPacks circuitPacks) {
List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.circuit.packs
.CircuitPacks> circuitPackList = circuitPacks.getCircuitPacks();
return searchNetworkPort(port, circuitPack);
}
}
- return null; // throw exception if no available network ports
+ // TODO: throw exception if no available network ports
+ return null;
}
private org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container
org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.circuit.packs.CircuitPacks circuitPack) {
if (port.getCircuitPackName().equals(circuitPack.getCircuitPackName())) {
for (Ports prt : circuitPack.getPorts()) {
- if (port.getPortName().equals(prt.getPortName()) && prt.getPortQual().equals("xpdr-network")) {
+ if (prt.getPortQual() != null
+ && port.getPortName().equals(prt.getPortName())
+ && "xpdr-network".equals(prt.getPortQual().getName())) {
return port;
}
}
}
- return null; // throw exception
+ // TODO: throw exception
+ return null;
}
import java.util.List;
import java.util.concurrent.Callable;
+
import org.opendaylight.transportpce.renderer.ServicePathInputData;
import org.opendaylight.transportpce.renderer.provisiondevice.DeviceRendererService;
import org.opendaylight.transportpce.renderer.provisiondevice.DeviceRenderingResult;
public DeviceRenderingResult call() throws Exception {
ServicePathOutput output = this.deviceRenderer.setupServicePath(this.servicePathInputData.getServicePathInput(),
this.direction);
- if (! output.isSuccess()) {
+ if (!output.isSuccess()) {
LOG.warn("Device rendering not successfully finished.");
return DeviceRenderingResult.failed("Operation Failed");
}
package org.opendaylight.transportpce.renderer.rpcs;
import com.google.common.util.concurrent.ListenableFuture;
+
import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException;
import org.opendaylight.transportpce.renderer.provisiondevice.DeviceRendererService;
import org.opendaylight.transportpce.renderer.provisiondevice.OtnDeviceRendererService;
*/
@Override
public ListenableFuture<RpcResult<ServicePathOutput>> servicePath(ServicePathInput input) {
- if (input.getOperation().getIntValue() == 1) {
- LOG.info("Create operation request received");
- return RpcResultBuilder.success(this.deviceRenderer.setupServicePath(input, null)).buildFuture();
- } else if (input.getOperation().getIntValue() == 2) {
- LOG.info("Delete operation request received");
- return RpcResultBuilder.success(this.deviceRenderer.deleteServicePath(input)).buildFuture();
+ if (input.getOperation() != null) {
+ if (input.getOperation().getIntValue() == 1) {
+ LOG.info("Create operation request received");
+ return RpcResultBuilder.success(
+ this.deviceRenderer.setupServicePath(input, null))
+ .buildFuture();
+ } else if (input.getOperation().getIntValue() == 2) {
+ LOG.info("Delete operation request received");
+ return RpcResultBuilder
+ .success(this.deviceRenderer.deleteServicePath(input))
+ .buildFuture();
+ }
}
return RpcResultBuilder.success(new ServicePathOutputBuilder().setResult("Invalid operation")).buildFuture();
}
@Override
public ListenableFuture<RpcResult<OtnServicePathOutput>> otnServicePath(OtnServicePathInput input) {
- if (input.getOperation().getIntValue() == 1) {
- LOG.info("Create operation request received");
- return RpcResultBuilder.success(this.otnDeviceRendererService.setupOtnServicePath(input)).buildFuture();
- } else if (input.getOperation().getIntValue() == 2) {
- LOG.info("Delete operation request received");
- return RpcResultBuilder.success(this.otnDeviceRendererService.deleteOtnServicePath(input)).buildFuture();
+ if (input.getOperation() != null) {
+ if (input.getOperation().getIntValue() == 1) {
+ LOG.info("Create operation request received");
+ return RpcResultBuilder.success(this.otnDeviceRendererService
+ .setupOtnServicePath(input)).buildFuture();
+ } else if (input.getOperation().getIntValue() == 2) {
+ LOG.info("Delete operation request received");
+ return RpcResultBuilder.success(this.otnDeviceRendererService
+ .deleteOtnServicePath(input)).buildFuture();
+ }
}
return RpcResultBuilder.success(new OtnServicePathOutputBuilder().setResult("Invalid operation")).buildFuture();
}
try {
output = this.rendererServiceOperations.serviceDelete(input).get();
} catch (InterruptedException | ExecutionException e) {
- LOG.error("RPC service delete failed !");
+ LOG.error("RPC service delete failed !", e);
}
return ModelMappingUtils.createServiceDeleteRpcResponse(output);
}
try {
output = this.rendererServiceOperations.serviceImplementation(input).get();
} catch (InterruptedException | ExecutionException e) {
- LOG.error("RPC service implementation failed !");
+ LOG.error("RPC service implementation failed !", e);
}
return ModelMappingUtils.createServiceImplementationRpcResponse(output);
}
package org.opendaylight.transportpce.renderer.stub;
import java.util.Optional;
+
import javax.annotation.Nonnull;
+
import org.opendaylight.mdsal.binding.api.BindingService;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.MountPoint;
import org.opendaylight.mdsal.binding.api.RpcConsumerRegistry;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-public class MountPointStub implements MountPoint {
+public class MountPointStub implements MountPoint {
private DataBroker dataBroker;
this.dataBroker = dataBroker;
}
- public void setRpcConsumerRegistry(RpcConsumerRegistry rpcConsumerRegistry) {
+ public void setRpcConsumerRegistry(
+ RpcConsumerRegistry rpcConsumerRegistry) {
this.rpcConsumerRegistry = rpcConsumerRegistry;
}
@SuppressWarnings("unchecked")
public <T extends BindingService> Optional<T> getService(Class<T> service) {
if (service.isInstance(dataBroker)) {
- return Optional.ofNullable((T)dataBroker);
+ return Optional.ofNullable((T) dataBroker);
}
if (service.isInstance(rpcConsumerRegistry)) {
- return Optional.ofNullable((T)rpcConsumerRegistry);
+ return Optional.ofNullable((T) rpcConsumerRegistry);
}
return Optional.empty();
}
@Nonnull
@Override
public InstanceIdentifier<?> getIdentifier() {
- return null;
+ throw new UnsupportedOperationException();
}
}
Code Review / transportpce.git / commitdiff