Fix issues in otn renderer

- add timer in OpenRoadmInterface221 to allow update portmapping with
odu supported interface
- manage lo-odu interfaces deletion (odu-connection and associated lo-interfaces)
- manage ho-odu/otu/och interfaces deletion

JIRA: TRNSPRTPCE-174 TRNSPRTPCE-142
Signed-off-by: Gilles Thouenon <gilles.thouenon@orange.com>
Change-Id: I899f9ffb2fe0a98b1d8a4184444fd4d3dfc4f4d5

diff --git a/common/src/main/java/org/opendaylight/transportpce/common/crossconnect/CrossConnect.java b/common/src/main/java/org/opendaylight/transportpce/common/crossconnect/CrossConnect.java
index 3d5c1ae8710c53d0720cb8b27d526b5658f9e9f6..59ea0fb0d717e836deab79b2d102176a904e0129 100644 (file)
--- a/common/src/main/java/org/opendaylight/transportpce/common/crossconnect/CrossConnect.java
+++ b/common/src/main/java/org/opendaylight/transportpce/common/crossconnect/CrossConnect.java
@@ -53,11 +53,12 @@ public interface CrossConnect {
      *            Device id.
      * @param connectionNumber
      *            Name of the cross connect.
+     * @param isOtn
+     *            True for odu-connection, False for roadm-connection.
      *
      * @return true/false based on status of operation.
      */
-
-    List<String> deleteCrossConnect(String deviceId, String connectionNumber);
+    List<String> deleteCrossConnect(String deviceId, String connectionNumber, Boolean isOtn);
 
     /**
      * This public method returns the list of ports (port-trail) for a roadm's

diff --git a/common/src/main/java/org/opendaylight/transportpce/common/crossconnect/CrossConnectImpl.java b/common/src/main/java/org/opendaylight/transportpce/common/crossconnect/CrossConnectImpl.java
index c4bde346fa2fa65b0b03d789609872170718dbcf..0e6774d8aae0e3aec9b66142db8c40d6b524fd03 100644 (file)
--- a/common/src/main/java/org/opendaylight/transportpce/common/crossconnect/CrossConnectImpl.java
+++ b/common/src/main/java/org/opendaylight/transportpce/common/crossconnect/CrossConnectImpl.java
@@ -42,10 +42,10 @@ public class CrossConnectImpl implements CrossConnect {
 
     public Optional<?> getCrossConnect(String nodeId, String connectionNumber) {
         String openRoadmVersion = mappingUtils.getOpenRoadmVersion(nodeId);
-        if (openRoadmVersion.equals(OPENROADM_DEVICE_VERSION_1_2_1)) {
+        if (OPENROADM_DEVICE_VERSION_1_2_1.equals(openRoadmVersion)) {
             return crossConnectImpl121.getCrossConnect(nodeId,connectionNumber);
         }
-        else if (openRoadmVersion.equals(OPENROADM_DEVICE_VERSION_2_2_1)) {
+        else if (OPENROADM_DEVICE_VERSION_2_2_1.equals(openRoadmVersion)) {
             return crossConnectImpl221.getCrossConnect(nodeId,connectionNumber);
         }
         return Optional.empty();
@@ -55,11 +55,11 @@ public class CrossConnectImpl implements CrossConnect {
     public Optional<String> postCrossConnect(String nodeId, Long waveNumber, String srcTp, String destTp) {
         String openRoadmVersion = mappingUtils.getOpenRoadmVersion(nodeId);
         LOG.info("Cross Connect post request received for node {} with version {}",nodeId,openRoadmVersion);
-        if (openRoadmVersion.equals(OPENROADM_DEVICE_VERSION_1_2_1)) {
+        if (OPENROADM_DEVICE_VERSION_1_2_1.equals(openRoadmVersion)) {
             LOG.info("Device Version is 1.2.1");
             return crossConnectImpl121.postCrossConnect(nodeId, waveNumber, srcTp, destTp);
         }
-        else if (openRoadmVersion.equals(OPENROADM_DEVICE_VERSION_2_2_1)) {
+        else if (OPENROADM_DEVICE_VERSION_2_2_1.equals(openRoadmVersion)) {
             LOG.info("Device Version is 2.2");
             return crossConnectImpl221.postCrossConnect(nodeId, waveNumber, srcTp, destTp);
         }
@@ -69,14 +69,14 @@ public class CrossConnectImpl implements CrossConnect {
     }
 
 
-    public List<String> deleteCrossConnect(String nodeId, String connectionNumber) {
+    public List<String> deleteCrossConnect(String nodeId, String connectionNumber, Boolean isOtn) {
 
         String openRoadmVersion = mappingUtils.getOpenRoadmVersion(nodeId);
-        if (openRoadmVersion.equals(OPENROADM_DEVICE_VERSION_1_2_1)) {
+        if (OPENROADM_DEVICE_VERSION_1_2_1.equals(openRoadmVersion)) {
             return crossConnectImpl121.deleteCrossConnect(nodeId, connectionNumber);
         }
-        else if (openRoadmVersion.equals(OPENROADM_DEVICE_VERSION_2_2_1)) {
-            return crossConnectImpl221.deleteCrossConnect(nodeId, connectionNumber);
+        else if (OPENROADM_DEVICE_VERSION_2_2_1.equals(openRoadmVersion)) {
+            return crossConnectImpl221.deleteCrossConnect(nodeId, connectionNumber, isOtn);
         }
         return null;
     }
@@ -84,10 +84,10 @@ public class CrossConnectImpl implements CrossConnect {
     public List<?> getConnectionPortTrail(String nodeId, Long waveNumber, String srcTp, String destTp)
             throws OpenRoadmInterfaceException {
         String openRoadmVersion = mappingUtils.getOpenRoadmVersion(nodeId);
-        if (openRoadmVersion.equals(OPENROADM_DEVICE_VERSION_1_2_1)) {
+        if (OPENROADM_DEVICE_VERSION_1_2_1.equals(openRoadmVersion)) {
             return crossConnectImpl121.getConnectionPortTrail(nodeId, waveNumber, srcTp, destTp);
         }
-        else if (openRoadmVersion.equals(OPENROADM_DEVICE_VERSION_2_2_1)) {
+        else if (OPENROADM_DEVICE_VERSION_2_2_1.equals(openRoadmVersion)) {
             return crossConnectImpl221.getConnectionPortTrail(nodeId, waveNumber, srcTp, destTp);
         }
         return null;
@@ -96,10 +96,10 @@ public class CrossConnectImpl implements CrossConnect {
     public boolean setPowerLevel(String nodeId, Enum mode, BigDecimal powerValue,
                                  String connectionNumber) {
         String openRoadmVersion = mappingUtils.getOpenRoadmVersion(nodeId);
-        if (openRoadmVersion.equals(OPENROADM_DEVICE_VERSION_1_2_1)) {
+        if (OPENROADM_DEVICE_VERSION_1_2_1.equals(openRoadmVersion)) {
             return crossConnectImpl121.setPowerLevel(nodeId,mode,powerValue,connectionNumber);
         }
-        else if (openRoadmVersion.equals(OPENROADM_DEVICE_VERSION_2_2_1)) {
+        else if (OPENROADM_DEVICE_VERSION_2_2_1.equals(openRoadmVersion)) {
             return crossConnectImpl221.setPowerLevel(nodeId,mode,powerValue,connectionNumber);
         }
         return false;

diff --git a/common/src/main/java/org/opendaylight/transportpce/common/crossconnect/CrossConnectImpl221.java b/common/src/main/java/org/opendaylight/transportpce/common/crossconnect/CrossConnectImpl221.java
index 341bd61ecbd601cd2c19b67b96a0f1c1dbfeb901..3141e51422f6cfcd0ab2a179e65466b05b893dde 100644 (file)
--- a/common/src/main/java/org/opendaylight/transportpce/common/crossconnect/CrossConnectImpl221.java
+++ b/common/src/main/java/org/opendaylight/transportpce/common/crossconnect/CrossConnectImpl221.java
@@ -62,6 +62,13 @@ public class CrossConnectImpl221 {
                 Timeouts.DEVICE_READ_TIMEOUT_UNIT);
     }
 
+    public Optional<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org
+        .openroadm.device.OduConnection> getOtnCrossConnect(String deviceId, String connectionNumber) {
+        //TODO Change it to Operational later for real device
+        return deviceTransactionManager.getDataFromDevice(deviceId, LogicalDatastoreType.CONFIGURATION,
+                generateOduConnectionIID(connectionNumber), Timeouts.DEVICE_READ_TIMEOUT,
+                Timeouts.DEVICE_READ_TIMEOUT_UNIT);
+    }
 
     public Optional<String> postCrossConnect(String deviceId, Long waveNumber, String srcTp, String destTp) {
         String connectionNumber = generateConnectionName(srcTp, destTp, waveNumber);
@@ -106,9 +113,11 @@ public class CrossConnectImpl221 {
     }
 
 
-    public List<String> deleteCrossConnect(String deviceId, String connectionName) {
+    public List<String> deleteCrossConnect(String deviceId, String connectionName, boolean isOtn) {
         List<String> interfList = new ArrayList<>();
         Optional<RoadmConnections> xc = getCrossConnect(deviceId, connectionName);
+        Optional<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org
+            .openroadm.device.OduConnection> otnXc = getOtnCrossConnect(deviceId, connectionName);
         //Check if cross connect exists before delete
         if (xc.isPresent()) {
             String name = xc.get().getSource().getSrcIf().replace("nmc", "mc");
@@ -116,8 +125,11 @@ public class CrossConnectImpl221 {
             interfList.add(xc.get().getDestination().getDstIf());
             interfList.add(xc.get().getSource().getSrcIf().replace("nmc", "mc"));
             interfList.add(xc.get().getDestination().getDstIf().replace("nmc", "mc"));
+        } else if (otnXc.isPresent()) {
+            interfList.add(otnXc.get().getSource().getSrcIf());
+            interfList.add(otnXc.get().getDestination().getDstIf());
         } else {
-            LOG.warn("Cross connect does not exist, halting delete");
+            LOG.warn("Cross connect {} does not exist, halting delete", connectionName);
             return null;
         }
         Future<Optional<DeviceTransaction>> deviceTxFuture = deviceTransactionManager.getDeviceTransaction(deviceId);
@@ -136,12 +148,16 @@ public class CrossConnectImpl221 {
         }
 
         // post the cross connect on the device
-        deviceTx.delete(LogicalDatastoreType.CONFIGURATION, generateRdmConnectionIID(connectionName));
+        if (isOtn) {
+            deviceTx.delete(LogicalDatastoreType.CONFIGURATION, generateOduConnectionIID(connectionName));
+        } else {
+            deviceTx.delete(LogicalDatastoreType.CONFIGURATION, generateRdmConnectionIID(connectionName));
+        }
         FluentFuture<? extends @NonNull CommitInfo> commit =
                 deviceTx.commit(Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
         try {
             commit.get();
-            LOG.info("Roadm connection {} successfully deleted on {}", connectionName, deviceId);
+            LOG.info("Connection {} successfully deleted on {}", connectionName, deviceId);
             return interfList;
         } catch (InterruptedException | ExecutionException e) {
             LOG.warn("Failed to delete {}", connectionName, e);
@@ -245,6 +261,13 @@ public class CrossConnectImpl221 {
                 .child(RoadmConnections.class, new RoadmConnectionsKey(connectionNumber));
     }
 
+    private InstanceIdentifier<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device
+        .container.org.openroadm.device.OduConnection> generateOduConnectionIID(String connectionNumber) {
+        return InstanceIdentifier.create(OrgOpenroadmDevice.class).child(org.opendaylight.yang.gen.v1.http.org
+            .openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.OduConnection.class,
+            new OduConnectionKey(connectionNumber));
+    }
+
     private String generateConnectionName(String srcTp, String destTp, Long waveNumber) {
         return srcTp + "-" + destTp + "-" + waveNumber;
     }

diff --git a/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion121.java b/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion121.java
index 2d3a1bb3904dd8bb2f156e02fd692419b0c45320..00033933e212672bb01cd4fae79dea386390cf91 100644 (file)
--- a/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion121.java
+++ b/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion121.java
@@ -142,7 +142,6 @@ public class PortMappingVersion121 {
     }
 
     public boolean updateMapping(String nodeId, Mapping oldMapping) {
-        LOG.info("Updating Mapping Data {} for node {}", oldMapping, nodeId);
         InstanceIdentifier<Ports> portIId = InstanceIdentifier.create(OrgOpenroadmDevice.class)
             .child(CircuitPacks.class, new CircuitPacksKey(oldMapping.getSupportingCircuitPackName()))
             .child(Ports.class, new PortsKey(oldMapping.getSupportingPort()));
@@ -155,7 +154,8 @@ public class PortMappingVersion121 {
                     Ports port = portObject.get();
                     Mapping newMapping = createMappingObject(nodeId, port, oldMapping.getSupportingCircuitPackName(),
                         oldMapping.getLogicalConnectionPoint());
-
+                    LOG.info("Updating old mapping Data {} for {} of {} by new mapping data {}", oldMapping,
+                        oldMapping.getLogicalConnectionPoint(), nodeId, newMapping);
                     final WriteTransaction writeTransaction = this.dataBroker.newWriteOnlyTransaction();
                     InstanceIdentifier<Mapping> mapIID = InstanceIdentifier.create(Network.class)
                         .child(Nodes.class, new NodesKey(nodeId))

diff --git a/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion221.java b/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion221.java
index b867c390d3ae94b1714608501b8f23a4e2d309f2..dd0cd820467dae54e674ee9d269bf79fc2d2ab10 100644 (file)
--- a/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion221.java
+++ b/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion221.java
@@ -74,6 +74,7 @@ import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.xponder.
 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.InterfaceType;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.OpenROADMOpticalMultiplex;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.OpticalTransport;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.OtnOdu;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev181019.Protocols1;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev181019.lldp.container.Lldp;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev181019.lldp.container.lldp.PortConfig;
@@ -148,7 +149,6 @@ public class PortMappingVersion221 {
     }
 
     public boolean updateMapping(String nodeId, Mapping oldMapping) {
-        LOG.info("Updating Mapping Data {} for node {}", oldMapping, nodeId);
         InstanceIdentifier<Ports> portIId = InstanceIdentifier.create(OrgOpenroadmDevice.class)
             .child(CircuitPacks.class, new CircuitPacksKey(oldMapping.getSupportingCircuitPackName()))
             .child(Ports.class, new PortsKey(oldMapping.getSupportingPort()));
@@ -161,7 +161,8 @@ public class PortMappingVersion221 {
                     Ports port = portObject.get();
                     Mapping newMapping = createMappingObject(nodeId, port, oldMapping.getSupportingCircuitPackName(),
                         oldMapping.getLogicalConnectionPoint());
-
+                    LOG.info("Updating old mapping Data {} for {} of {} by new mapping data {}", oldMapping,
+                        oldMapping.getLogicalConnectionPoint(), nodeId, newMapping);
                     final WriteTransaction writeTransaction = this.dataBroker.newWriteOnlyTransaction();
                     InstanceIdentifier<Mapping> mapIID = InstanceIdentifier.create(Network.class)
                         .child(Nodes.class, new NodesKey(nodeId))
@@ -760,12 +761,15 @@ public class PortMappingVersion221 {
             .setPortDirection(port.getPortDirection().getName());
 
         // Get OMS and OTS interface provisioned on the TTP's
-        if (logicalConnectionPoint.contains(StringConstants.TTP_TOKEN) && (port.getInterfaces() != null)) {
+        if ((logicalConnectionPoint.contains(StringConstants.TTP_TOKEN)
+            || logicalConnectionPoint.contains(StringConstants.NETWORK_TOKEN)) && (port.getInterfaces() != null)) {
             for (Interfaces interfaces : port.getInterfaces()) {
                 try {
                     Optional<Interface> openRoadmInterface = this.openRoadmInterfaces.getInterface(nodeId,
                         interfaces.getInterfaceName());
                     if (openRoadmInterface.isPresent()) {
+                        LOG.info("interface get from device is {} and of type {}", openRoadmInterface.get().getName(),
+                            openRoadmInterface.get().getType());
                         Class<? extends InterfaceType> interfaceType
                             = (Class<? extends InterfaceType>) openRoadmInterface.get().getType();
                         // Check if interface type is OMS or OTS
@@ -775,6 +779,9 @@ public class PortMappingVersion221 {
                         if (interfaceType.equals(OpticalTransport.class)) {
                             mpBldr.setSupportingOts(interfaces.getInterfaceName());
                         }
+                        if (interfaceType.equals(OtnOdu.class)) {
+                            mpBldr.setSupportingOdu4(interfaces.getInterfaceName());
+                        }
                     } else {
                         LOG.warn("Interface {} from node {} was null!", interfaces.getInterfaceName(), nodeId);
                     }

diff --git a/common/src/main/java/org/opendaylight/transportpce/common/openroadminterfaces/OpenRoadmInterfacesImpl221.java b/common/src/main/java/org/opendaylight/transportpce/common/openroadminterfaces/OpenRoadmInterfacesImpl221.java
index 3c8c95a1ab09429de9d2a80afc8ec82d8f106b7a..eb01a74c259e6142b5cf06ec1918228e916c704e 100755 (executable)
--- a/common/src/main/java/org/opendaylight/transportpce/common/openroadminterfaces/OpenRoadmInterfacesImpl221.java
+++ b/common/src/main/java/org/opendaylight/transportpce/common/openroadminterfaces/OpenRoadmInterfacesImpl221.java
@@ -9,6 +9,7 @@
 package org.opendaylight.transportpce.common.openroadminterfaces;
 
 import com.google.common.util.concurrent.FluentFuture;
+
 import java.util.Optional;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Future;
@@ -65,7 +66,6 @@ public class OpenRoadmInterfacesImpl221 {
             throw new OpenRoadmInterfaceException(String.format("Failed to obtain device transaction for node %s!",
                 nodeId), e);
         }
-
         InstanceIdentifier<Interface> interfacesIID = InstanceIdentifier.create(OrgOpenroadmDevice.class).child(
             Interface.class, new InterfaceKey(ifBuilder.getName()));
         LOG.info("POST INTERF for {} : InterfaceBuilder : name = {} \t type = {}", nodeId, ifBuilder.getName(),

diff --git a/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterface121.java b/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterface121.java
index c9077803723369441bef40f2ae0cb3638e3b43f4..fb11fe9a256c67929edce70fa895d6232434bab5 100644 (file)
--- a/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterface121.java
+++ b/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterface121.java
@@ -42,7 +42,7 @@ import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev161014.Opti
 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev161014.OtnOdu;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev161014.OtnOtu;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev161014.OchAttributes;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev161014.RateIdentity;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev161014.R100G;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev161014.och.container.OchBuilder;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev161014.OtsAttributes;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev161014.ots.container.OtsBuilder;
@@ -248,8 +248,8 @@ public class OpenRoadmInterface121 {
         return interfacesCreated;
     }
 
-    public String createOpenRoadmOchInterface(String nodeId, String logicalConnPoint, Long waveNumber, Class<
-            ? extends RateIdentity> rate, OchAttributes.ModulationFormat format) throws OpenRoadmInterfaceException {
+    public String createOpenRoadmOchInterface(String nodeId, String logicalConnPoint, Long waveNumber,
+        OchAttributes.ModulationFormat format) 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 %s and"
@@ -260,7 +260,7 @@ public class OpenRoadmInterface121 {
         OchBuilder ocIfBuilder = new OchBuilder();
         ocIfBuilder.setWavelengthNumber(waveNumber);
         ocIfBuilder.setModulationFormat(format);
-        ocIfBuilder.setRate(rate);
+        ocIfBuilder.setRate(R100G.class);
         ocIfBuilder.setTransmitPower(new PowerDBm(new BigDecimal("-5")));
 
         // Create Interface1 type object required for adding as augmentation

diff --git a/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterface221.java b/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterface221.java
index ea97b252c34b7e4d2466069a82b58820595526db..bc77eee117f302a197f8955badce5ccf13793541 100644 (file)
--- a/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterface221.java
+++ b/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterface221.java
@@ -29,6 +29,8 @@ import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.R1
 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.device.rev181019.org.openroadm.device.container.OrgOpenroadmDevice;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.OduConnection;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.OduConnectionKey;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.RoadmConnections;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.RoadmConnectionsKey;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev171215.AdminStates;
@@ -414,6 +416,26 @@ public class OpenRoadmInterface221 {
         return false;
     }
 
+    public boolean isUsedByOtnXc(String nodeId, String interfaceName, String xc,
+        DeviceTransactionManager deviceTransactionManager) {
+        InstanceIdentifier<OduConnection> xciid = InstanceIdentifier.create(OrgOpenroadmDevice.class)
+            .child(OduConnection.class, new OduConnectionKey(xc));
+        LOG.info("reading xc {} in node {}", xc, nodeId);
+        Optional<OduConnection> oduConnectionOpt = deviceTransactionManager.getDataFromDevice(nodeId,
+            LogicalDatastoreType.CONFIGURATION, xciid, Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
+        if (oduConnectionOpt.isPresent()) {
+            OduConnection oduXc = oduConnectionOpt.get();
+            LOG.info("xc {} found", xc);
+            if (oduXc.getSource().getSrcIf().equals(interfaceName)
+                || oduXc.getDestination().getDstIf().equals(interfaceName)) {
+                return true;
+            }
+        } else {
+            LOG.info("xc {} not found !", xc);
+        }
+        return false;
+    }
+
     public String createOpenRoadmOtnOdu4Interface(String nodeId, String logicalConnPoint, String supportingOtuInterface)
             throws OpenRoadmInterfaceException {
         Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
@@ -452,6 +474,11 @@ public class OpenRoadmInterface221 {
 
         // Post interface on the device
         openRoadmInterfaces.postInterface(nodeId, oduInterfaceBldr);
+        try {
+            Thread.sleep(3000);
+        } catch (InterruptedException e) {
+            LOG.error("Error waiting post interface on device", e);
+        }
         this.portMapping.updateMapping(nodeId, portMap);
         return oduInterfaceBldr.getName();
     }

diff --git a/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterfaceFactory.java b/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterfaceFactory.java
index 8412b5c32372f7ef2ce9cd220d05e969c3853279..cf8380386d3d8d26cf74ac006cb6f49201cc6843 100644 (file)
--- a/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterfaceFactory.java
+++ b/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterfaceFactory.java
@@ -16,7 +16,6 @@ import org.opendaylight.transportpce.common.mapping.MappingUtils;
 import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException;
 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;
 
@@ -76,12 +75,11 @@ public class OpenRoadmInterfaceFactory {
 
 
     public String createOpenRoadmOchInterface(String nodeId, String logicalConnPoint, Long waveNumber,
-            Class<? extends RateIdentity> rate, OchAttributes.ModulationFormat format)
+        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);
+                return openRoadmInterface121.createOpenRoadmOchInterface(nodeId, logicalConnPoint, waveNumber, format);
             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
                 return openRoadmInterface221.createOpenRoadmOchInterface(nodeId, logicalConnPoint, waveNumber);
             default:
@@ -175,6 +173,19 @@ public class OpenRoadmInterfaceFactory {
         }
     }
 
+    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");
+                return false;
+            case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
+                return openRoadmInterface221.isUsedByOtnXc(nodeId, interfaceName, xc, deviceTransactionManager);
+            default:
+                return false;
+        }
+    }
+
     public String createOpenRoadmEth1GInterface(String nodeId,
                                                 String logicalConnPoint) throws OpenRoadmInterfaceException {
         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {

diff --git a/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmOtnInterface221.java b/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmOtnInterface221.java
index 997a76c0945e456ecb12c33385bc8807c4bc9ea5..ef16d10400e77b03f5ab0f538626625a4d0973da 100644 (file)
--- a/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmOtnInterface221.java
+++ b/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmOtnInterface221.java
@@ -21,9 +21,9 @@ import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.re
 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.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.OtnOdu;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.EthernetCsmacd;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.InterfaceType;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.OtnOdu;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.ODU0;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.ODU2;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.ODU2e;
@@ -87,7 +87,7 @@ public class OpenRoadmOtnInterface221 {
             .setAdministrativeState(AdminStates.InService)
             //TODO get rid of unchecked cast warning
             .setType(
-                (Class<? extends org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.InterfaceType>)
+                (Class<? extends InterfaceType>)
                 type
             )
             .setName(key)

diff --git a/renderer/src/main/java/org/opendaylight/transportpce/renderer/provisiondevice/DeviceRendererServiceImpl.java b/renderer/src/main/java/org/opendaylight/transportpce/renderer/provisiondevice/DeviceRendererServiceImpl.java
index 790b6639dcc21d6685f4a2ba5a2b8599abfd3f19..f695c36ad0132e554d06005a68b24b4895a032c5 100644 (file)
--- a/renderer/src/main/java/org/opendaylight/transportpce/renderer/provisiondevice/DeviceRendererServiceImpl.java
+++ b/renderer/src/main/java/org/opendaylight/transportpce/renderer/provisiondevice/DeviceRendererServiceImpl.java
@@ -55,9 +55,7 @@ import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.
 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;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.service.list.Services;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.service.list.ServicesBuilder;
@@ -122,7 +120,7 @@ public class DeviceRendererServiceImpl implements DeviceRendererService {
                         crossConnectFlag++;
                         Mapping mapping = this.portMapping.getMapping(nodeId,destTp);
                         String supportingOchInterface = this.openRoadmInterfaceFactory.createOpenRoadmOchInterface(
-                                nodeId, destTp, waveNumber, R100G.class, ModulationFormat.DpQpsk);
+                                nodeId, destTp, waveNumber, ModulationFormat.DpQpsk);
                         createdOchInterfaces.add(supportingOchInterface);
                         String supportingOtuInterface = this.openRoadmInterfaceFactory
                                 .createOpenRoadmOtu4Interface(nodeId, destTp, supportingOchInterface);
@@ -148,7 +146,7 @@ public class DeviceRendererServiceImpl implements DeviceRendererService {
                         Mapping mapping = this.portMapping.getMapping(nodeId,srcTp);
                         // create OpenRoadm Xponder Line Interfaces
                         String supportingOchInterface = this.openRoadmInterfaceFactory.createOpenRoadmOchInterface(
-                                nodeId, srcTp, waveNumber, R100G.class, ModulationFormat.DpQpsk);
+                                nodeId, srcTp, waveNumber, ModulationFormat.DpQpsk);
                         createdOchInterfaces.add(supportingOchInterface);
                         String supportingOtuInterface = this.openRoadmInterfaceFactory
                                 .createOpenRoadmOtu4Interface(nodeId, srcTp, supportingOchInterface);
@@ -262,12 +260,19 @@ public class DeviceRendererServiceImpl implements DeviceRendererService {
             List<String> interfacesToDelete = new LinkedList<>();
             String nodeId = node.getNodeId();
             LOG.info("Deleting service setup on node {}", nodeId);
-            String srcTp = node.getSrcTp();
-            String destTp = node.getDestTp();
+            String srcTp;
+            String destTp;
             Long waveNumber = input.getWaveNumber();
-            if ((srcTp == null) || (destTp == null)) {
-                LOG.error("Source ({}) or destination ({}) termination point is null.", srcTp, destTp);
+            if (node.getDestTp() == null) {
+                LOG.error("Destination termination point must not be null.");
                 return;
+            } else {
+                destTp = node.getDestTp();
+            }
+            if (node.getSrcTp() != null) {
+                srcTp = node.getSrcTp();
+            } else {
+                srcTp = "";
             }
             // if the node is currently mounted then proceed.
             if (this.deviceTransactionManager.isDeviceMounted(nodeId)) {
@@ -276,7 +281,17 @@ public class DeviceRendererServiceImpl implements DeviceRendererService {
                         || srcTp.contains(StringConstants.NETWORK_TOKEN)
                         || destTp.contains(StringConstants.CLIENT_TOKEN)) {
                     if (destTp.contains(StringConstants.NETWORK_TOKEN)) {
-                        interfacesToDelete.add(destTp + "-ODU");
+                        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));
@@ -295,7 +310,7 @@ public class DeviceRendererServiceImpl implements DeviceRendererService {
                     }
                 } else {
                     String connectionNumber = srcTp + "-" + destTp + "-" + waveNumber;
-                    List<String> intToDelete = this.crossConnect.deleteCrossConnect(nodeId, connectionNumber);
+                    List<String> intToDelete = this.crossConnect.deleteCrossConnect(nodeId, connectionNumber, false);
                     connectionNumber = destTp + "-" + srcTp + "-" + waveNumber;
                     if (intToDelete != null) {
                         for (String interf : intToDelete) {
@@ -352,7 +367,7 @@ public class DeviceRendererServiceImpl implements DeviceRendererService {
             List<String> failedInterfaces = new ArrayList<>();
             String nodeId = nodeInterfaces.getNodeId();
             for (String connectionId : nodeInterfaces.getConnectionId()) {
-                List<String> listInter = this.crossConnect.deleteCrossConnect(nodeId, connectionId);
+                List<String> listInter = this.crossConnect.deleteCrossConnect(nodeId, connectionId, false);
                 if (listInter != null) {
                     LOG.info("Cross connect {} on node {} successfully deleted.", connectionId, nodeId);
                 } else {

diff --git a/renderer/src/main/java/org/opendaylight/transportpce/renderer/provisiondevice/OtnDeviceRendererServiceImpl.java b/renderer/src/main/java/org/opendaylight/transportpce/renderer/provisiondevice/OtnDeviceRendererServiceImpl.java
index aee77a643d95e6024e619a74809dbe151b95a582..a14ac03497227932a70842ef9ea809a181952ef0 100644 (file)
--- a/renderer/src/main/java/org/opendaylight/transportpce/renderer/provisiondevice/OtnDeviceRendererServiceImpl.java
+++ b/renderer/src/main/java/org/opendaylight/transportpce/renderer/provisiondevice/OtnDeviceRendererServiceImpl.java
@@ -25,6 +25,7 @@ import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterf
 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;
 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.device.rev200128.OtnServicePathOutputBuilder;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.interfaces.grp.Interface;
 import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200128.node.interfaces.NodeInterface;
 import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200128.node.interfaces.NodeInterfaceBuilder;
 import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200128.node.interfaces.NodeInterfaceKey;
@@ -103,21 +104,28 @@ public class OtnDeviceRendererServiceImpl implements OtnDeviceRendererService {
             }
             // if the node is currently mounted then proceed.
             if (this.deviceTransactionManager.isDeviceMounted(nodeId)) {
+                String connectionNumber = "";
                 switch (input.getServiceRate()) {
                     case("10G"):
-                        interfacesToDelete.add(srcTp + "-ODU2e-" + input.getServiceName());
-                        interfacesToDelete.add(destTp + "-ODU2e-" + input.getServiceName());
+                        connectionNumber = srcTp + "-ODU2e-" + input.getServiceName() + "-x-" + destTp
+                            + "-ODU2e-" + input.getServiceName();
+                        break;
                     case("1G"):
-                        interfacesToDelete.add(srcTp + "-ODU0-" + input.getServiceName());
-                        interfacesToDelete.add(destTp + "-ODU0-" + input.getServiceName());
+                        connectionNumber = srcTp + "-ODU0-" + input.getServiceName() + "-x-" + destTp
+                            + "-ODU2e-" + input.getServiceName();
+                        break;
+                    default:
+                        LOG.error("service rate {} not managed yet", input.getServiceRate());
                 }
-                String connectionNumber = interfacesToDelete.get(0) + "-x-" + interfacesToDelete.get(1);
-                List<String> intToDelete = this.crossConnect.deleteCrossConnect(nodeId, connectionNumber);
+                List<String> intToDelete = this.crossConnect.deleteCrossConnect(nodeId, connectionNumber, true);
                 if (intToDelete != null) {
                     for (String interf : intToDelete) {
-                        if (!this.openRoadmInterfaceFactory.isUsedbyXc(nodeId, interf, connectionNumber,
-                                this.deviceTransactionManager)) {
+                        if (!this.openRoadmInterfaceFactory.isUsedbyOtnXc(nodeId, interf, connectionNumber,
+                            this.deviceTransactionManager)) {
                             interfacesToDelete.add(interf);
+                            if (!getSupportedInterface(nodeId, interf).contains("ODU4")) {
+                                interfacesToDelete.add(getSupportedInterface(nodeId, interf));
+                            }
                         }
                     }
                 }
@@ -157,51 +165,57 @@ public class OtnDeviceRendererServiceImpl implements OtnDeviceRendererService {
 
     }
 
+    private String getSupportedInterface(String nodeId, String interf) {
+        Optional<Interface> supInterfOpt;
+        try {
+            supInterfOpt = this.openRoadmInterfaces.getInterface(nodeId, interf);
+            if (supInterfOpt.isPresent()) {
+                return supInterfOpt.get().getSupportingInterface();
+            } else {
+                return null;
+            }
+        } catch (OpenRoadmInterfaceException e) {
+            LOG.error("error getting Supported Interface of {} - {}", interf, nodeId, e);
+            return null;
+        }
+    }
+
     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()) {
+        if (input.getServiceRate() == null
+            || !("1G".equals(input.getServiceRate()) || "10G".equals(input.getServiceRate()))) {
+            LOG.error("Service rate {} not managed yet", input.getServiceRate());
+        } else {
+            createLowOrderInterfaces(input, nodeInterfaces);
+        }
+        return nodeInterfaces;
+    }
+
+    private Optional<String> postCrossConnect(List<String> createdOduInterfaces, Nodes node)
+            throws OpenRoadmInterfaceException {
+        return this.crossConnect.postOtnCrossConnect(createdOduInterfaces,node);
+    }
+
+    private void createLowOrderInterfaces(OtnServicePathInput input, List<NodeInterface> nodeInterfaces)
+        throws OpenRoadmInterfaceException {
+        for (Nodes node: input.getNodes()) {
+            //check if the node is mounted or not?
+            List<String> createdEthInterfaces = new ArrayList<>();
+            List<String> createdOduInterfaces = new ArrayList<>();
+            if ("1G".equals(input.getServiceRate())) {
                 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.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
-                Optional<String> connectionNameOpt = postCrossConnect(createdOduInterfaces, node);
-                createdConnections.add(connectionNameOpt.get());
-                LOG.info("Created cross connects");
-                NodeInterfaceBuilder nodeInterfaceBuilder = new NodeInterfaceBuilder()
-                        .withKey(new NodeInterfaceKey(input.getServiceName() + "-" + node.getNodeId()))
-                        .setNodeId(input.getServiceName() + "-" + node.getNodeId())
-                        .setConnectionId(createdConnections)
-                        .setEthInterfaceId(createdEthInterfaces)
-                        .setOduInterfaceId(createdOduInterfaces);
-                nodeInterfaces.add(nodeInterfaceBuilder.build());
-            }
-        }
-        else if (input.getServiceRate().equals("10G")) {
-            // implementing ODU2e for now
-
-            for (Nodes node: input.getNodes()) {
+            } else if ("10G".equals(input.getServiceRate())) {
                 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(
@@ -212,30 +226,21 @@ public class OtnDeviceRendererServiceImpl implements OtnDeviceRendererService {
                     // supporting interface? payload ?
                     openRoadmInterfaceFactory.createOpenRoadmOdu2eInterface(node.getNodeId(), node.getNetworkTp(),
                         input.getServiceName(),"03" , true ,input.getTribPortNumber(),input.getTribSlot()));
-                //implement cross connect
+            }
+            //implement cross connect
+            List<String> createdConnections = new ArrayList<>();
+            if (!createdOduInterfaces.isEmpty()) {
                 Optional<String> connectionNameOpt = postCrossConnect(createdOduInterfaces, node);
                 createdConnections.add(connectionNameOpt.get());
                 LOG.info("Created cross connects");
-                LOG.info("Now creating  node interface builder");
-                NodeInterfaceBuilder nodeInterfaceBuilder = new NodeInterfaceBuilder();
-                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 ");
             }
+            NodeInterfaceBuilder nodeInterfaceBuilder = new NodeInterfaceBuilder()
+                    .withKey(new NodeInterfaceKey(input.getServiceName() + "-" + node.getNodeId()))
+                    .setNodeId(input.getServiceName() + "-" + node.getNodeId())
+                    .setConnectionId(createdConnections)
+                    .setEthInterfaceId(createdEthInterfaces)
+                    .setOduInterfaceId(createdOduInterfaces);
+            nodeInterfaces.add(nodeInterfaceBuilder.build());
         }
-        return nodeInterfaces;
-    }
-
-    private Optional<String> postCrossConnect(List<String> createdOduInterfaces, Nodes node)
-            throws OpenRoadmInterfaceException {
-        return this.crossConnect.postOtnCrossConnect(createdOduInterfaces,node);
     }
 }

diff --git a/renderer/src/test/java/org/opendaylight/transportpce/renderer/provisiondevice/RendererServiceOperationsImplDeleteTest.java b/renderer/src/test/java/org/opendaylight/transportpce/renderer/provisiondevice/RendererServiceOperationsImplDeleteTest.java
index 4c86e59a2f7c723475a0506943db8c79c245c219..4ce85b0a6a7ea50b345e79c56bfc93cca67dd87e 100644 (file)
--- a/renderer/src/test/java/org/opendaylight/transportpce/renderer/provisiondevice/RendererServiceOperationsImplDeleteTest.java
+++ b/renderer/src/test/java/org/opendaylight/transportpce/renderer/provisiondevice/RendererServiceOperationsImplDeleteTest.java
@@ -143,12 +143,12 @@ public class RendererServiceOperationsImplDeleteTest extends AbstractTest {
         serviceDeleteInputBuilder.setServiceHandlerHeader((new ServiceHandlerHeaderBuilder())
             .setRequestId("request1").build());
         Mockito.doReturn(Collections.emptyList()).when(this.crossConnect).deleteCrossConnect(Mockito.anyString(),
-            Mockito.anyString());
+            Mockito.anyString(), Mockito.eq(false));
         ServiceDeleteOutput serviceDeleteOutput
                 = this.rendererServiceOperations.serviceDelete(serviceDeleteInputBuilder.build()).get();
         Assert.assertEquals(ResponseCodes.RESPONSE_OK,
             serviceDeleteOutput.getConfigurationResponseCommon().getResponseCode());
-        Mockito.verify(this.crossConnect, Mockito.times(2)).deleteCrossConnect(Mockito.any(), Mockito.any());
+        Mockito.verify(this.crossConnect, Mockito.times(2)).deleteCrossConnect(Mockito.any(), Mockito.any(), Mockito.eq(false));
     }
 
     @Test
@@ -159,13 +159,13 @@ public class RendererServiceOperationsImplDeleteTest extends AbstractTest {
                 = this.rendererServiceOperations.serviceDelete(serviceDeleteInputBuilder.build()).get();
         Assert.assertEquals(ResponseCodes.RESPONSE_FAILED,
             serviceDeleteOutput.getConfigurationResponseCommon().getResponseCode());
-        Mockito.verify(this.crossConnect, Mockito.times(0)).deleteCrossConnect(Mockito.any(), Mockito.any());
+        Mockito.verify(this.crossConnect, Mockito.times(0)).deleteCrossConnect(Mockito.any(), Mockito.any(), Mockito.eq(false));
     }
 
     @Test
     public void serviceDeleteOperationTearDownFailedAtoZ() throws ExecutionException, InterruptedException {
         Mockito.doReturn(Collections.emptyList()).when(this.crossConnect).deleteCrossConnect(Mockito.anyString(),
-            Mockito.anyString());
+            Mockito.anyString(), Mockito.eq(false));
         Mockito.doReturn(RpcResultBuilder.success((new ServicePowerTurndownOutputBuilder())
             .setResult("Failed").build()).buildFuture()).when(this.olmService).servicePowerTurndown(Mockito.any());
 
@@ -179,14 +179,16 @@ public class RendererServiceOperationsImplDeleteTest extends AbstractTest {
         ServiceDeleteOutput output = serviceDeleteOutput.get();
         Assert.assertEquals(ResponseCodes.RESPONSE_FAILED,
                 output.getConfigurationResponseCommon().getResponseCode());
-        Mockito.verify(this.crossConnect, Mockito.times(0)).deleteCrossConnect(Mockito.eq("node1"), Mockito.any());
-        Mockito.verify(this.crossConnect, Mockito.times(0)).deleteCrossConnect(Mockito.eq("node2"), Mockito.any());
+        Mockito.verify(this.crossConnect, Mockito.times(0)).deleteCrossConnect(Mockito.eq("node1"), Mockito.any(),
+            Mockito.eq(false));
+        Mockito.verify(this.crossConnect, Mockito.times(0)).deleteCrossConnect(Mockito.eq("node2"), Mockito.any(),
+            Mockito.eq(false));
     }
 
     @Test
     public void serviceDeleteOperationTearDownFailedZtoA() throws ExecutionException, InterruptedException {
         Mockito.doReturn(Collections.emptyList()).when(this.crossConnect).deleteCrossConnect(Mockito.anyString(),
-            Mockito.anyString());
+            Mockito.anyString(), Mockito.eq(false));
         Mockito.when(this.olmService.servicePowerTurndown(Mockito.any()))
             .thenReturn(RpcResultBuilder.success((new ServicePowerTurndownOutputBuilder())
                 .setResult("Success").build()).buildFuture())
@@ -203,8 +205,10 @@ public class RendererServiceOperationsImplDeleteTest extends AbstractTest {
         Assert.assertEquals(ResponseCodes.RESPONSE_FAILED,
             serviceDeleteOutput.getConfigurationResponseCommon().getResponseCode());
         Mockito.verify(this.olmService, Mockito.times(2)).servicePowerTurndown(Mockito.any());
-        Mockito.verify(this.crossConnect, Mockito.times(0)).deleteCrossConnect(Mockito.eq("node1"), Mockito.any());
-        Mockito.verify(this.crossConnect, Mockito.times(0)).deleteCrossConnect(Mockito.eq("node2"), Mockito.any());
+        Mockito.verify(this.crossConnect, Mockito.times(0)).deleteCrossConnect(Mockito.eq("node1"), Mockito.any(),
+            Mockito.eq(false));
+        Mockito.verify(this.crossConnect, Mockito.times(0)).deleteCrossConnect(Mockito.eq("node2"), Mockito.any(),
+            Mockito.eq(false));
     }
 
     private void writePathDescription() throws ExecutionException, InterruptedException {