From ed0789eb5b14e334c5750e73e456157d9076b1bc Mon Sep 17 00:00:00 2001 From: Balagangadhar Bathula Date: Tue, 4 May 2021 12:58:12 -0400 Subject: [PATCH] Device renderer for muxponder - Add device provisioning for network ODUC4 (ODU-TTP), ODU4 (ODU-CTP) and client ODU4 interface (ODU-TTP-CTP) - Add provisioning for Ethernet 100G - Add ODU-connection (OTN cross-connect) - Modify the classes, unit-tests wherever necessary JIRA: TRNSPRTPCE-451 Change-Id: Ide493b46dea6480fc2016fa3c89289b188ad8a0b Signed-off-by: Balagangadhar Bathula --- .../common/crossconnect/CrossConnectImpl.java | 24 ++- .../crossconnect/CrossConnectImpl710.java | 153 +++++++++++++++ .../common/mapping/PortMappingVersion710.java | 11 +- .../OSGI-INF/blueprint/common-blueprint.xml | 5 + .../crossconnect/CrossConnectImplTest.java | 5 +- .../tpce/module/TransportPCEImpl.java | 10 +- .../olm/OlmPowerServiceRpcImplTest.java | 5 +- .../olm/power/PowerMgmtPowerMockTest.java | 4 +- .../transportpce/olm/power/PowerMgmtTest.java | 4 +- .../olm/service/OlmPowerServiceImplTest.java | 4 +- .../OpenRoadmInterface710.java | 144 ++++++++++++++- .../OpenRoadmInterfaceFactory.java | 92 +++++++-- .../OpenRoadmOtnInterface710.java | 174 ++++++++++++++++++ .../OtnDeviceRendererServiceImpl.java | 130 +++++++++++-- .../OSGI-INF/blueprint/renderer-blueprint.xml | 11 +- ...ceRendererServiceImplCreateOtsOmsTest.java | 12 +- ...ndererServiceOperationsImplDeleteTest.java | 13 +- .../RendererServiceOperationsImplTest.java | 12 +- 18 files changed, 759 insertions(+), 54 deletions(-) create mode 100644 common/src/main/java/org/opendaylight/transportpce/common/crossconnect/CrossConnectImpl710.java create mode 100644 renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmOtnInterface710.java 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 2e2773f5e..4c9d32721 100644 --- a/common/src/main/java/org/opendaylight/transportpce/common/crossconnect/CrossConnectImpl.java +++ b/common/src/main/java/org/opendaylight/transportpce/common/crossconnect/CrossConnectImpl.java @@ -10,6 +10,7 @@ package org.opendaylight.transportpce.common.crossconnect; import static org.opendaylight.transportpce.common.StringConstants.OPENROADM_DEVICE_VERSION_1_2_1; import static org.opendaylight.transportpce.common.StringConstants.OPENROADM_DEVICE_VERSION_2_2_1; +import static org.opendaylight.transportpce.common.StringConstants.OPENROADM_DEVICE_VERSION_7_1; import java.math.BigDecimal; import java.util.List; @@ -31,13 +32,16 @@ public class CrossConnectImpl implements CrossConnect { private final MappingUtils mappingUtils; private CrossConnectImpl121 crossConnectImpl121; private CrossConnectImpl221 crossConnectImpl221; + private CrossConnectImpl710 crossConnectImpl710; public CrossConnectImpl(DeviceTransactionManager deviceTransactionManager, MappingUtils mappingUtils, CrossConnectImpl121 crossConnectImpl121, - CrossConnectImpl221 crossConnectImpl221) { + CrossConnectImpl221 crossConnectImpl221, + CrossConnectImpl710 crossConnectImpl710) { this.mappingUtils = mappingUtils; this.crossConnectImpl121 = crossConnectImpl121; this.crossConnectImpl221 = crossConnectImpl221; + this.crossConnectImpl710 = crossConnectImpl710; this.crossConnect = null; } @@ -84,6 +88,14 @@ public class CrossConnectImpl implements CrossConnect { return null; } + public List deleteCrossConnect(String nodeId, String connectionNumber) { + String openRoadmVersion = mappingUtils.getOpenRoadmVersion(nodeId); + if (OPENROADM_DEVICE_VERSION_7_1.equals(openRoadmVersion)) { + return crossConnectImpl710.deleteOtnCrossConnect(nodeId, connectionNumber); + } + return null; + } + public List getConnectionPortTrail(String nodeId, String srcTp, String destTp, int lowerSpectralSlotNumber, int higherSpectralSlotNumber) throws OpenRoadmInterfaceException { @@ -118,6 +130,14 @@ public class CrossConnectImpl implements CrossConnect { @Override public Optional postOtnCrossConnect(List createdOduInterfaces, Nodes node) throws OpenRoadmInterfaceException { - return crossConnectImpl221.postOtnCrossConnect(createdOduInterfaces, node); + String openRoadmVersion = mappingUtils.getOpenRoadmVersion(node.getNodeId()); + + if (OPENROADM_DEVICE_VERSION_2_2_1.equals(openRoadmVersion)) { + return crossConnectImpl221.postOtnCrossConnect(createdOduInterfaces, node); + } + else if (OPENROADM_DEVICE_VERSION_7_1.equals(openRoadmVersion)) { + return crossConnectImpl710.postOtnCrossConnect(createdOduInterfaces, node); + } + return Optional.empty(); } } diff --git a/common/src/main/java/org/opendaylight/transportpce/common/crossconnect/CrossConnectImpl710.java b/common/src/main/java/org/opendaylight/transportpce/common/crossconnect/CrossConnectImpl710.java new file mode 100644 index 000000000..e85a84551 --- /dev/null +++ b/common/src/main/java/org/opendaylight/transportpce/common/crossconnect/CrossConnectImpl710.java @@ -0,0 +1,153 @@ +/* + * Copyright © 2021 AT&T and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +package org.opendaylight.transportpce.common.crossconnect; + +import com.google.common.util.concurrent.FluentFuture; +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.Future; +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.mdsal.common.api.CommitInfo; +import org.opendaylight.mdsal.common.api.LogicalDatastoreType; +import org.opendaylight.transportpce.common.Timeouts; +import org.opendaylight.transportpce.common.device.DeviceTransaction; +import org.opendaylight.transportpce.common.device.DeviceTransactionManager; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.OduConnection.Direction; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.OrgOpenroadmDevice; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.OduConnectionBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.OduConnectionKey; +import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev201211.otn.renderer.input.Nodes; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class CrossConnectImpl710 { + + private static final Logger LOG = LoggerFactory.getLogger(CrossConnectImpl710.class); + private final DeviceTransactionManager deviceTransactionManager; + + public CrossConnectImpl710(DeviceTransactionManager deviceTransactionManager) { + this.deviceTransactionManager = deviceTransactionManager; + } + + public Optional getOtnCrossConnect(String deviceId, String connectionNumber) { + + return deviceTransactionManager.getDataFromDevice(deviceId, LogicalDatastoreType.OPERATIONAL, + generateOduConnectionIID(connectionNumber), Timeouts.DEVICE_READ_TIMEOUT, + Timeouts.DEVICE_READ_TIMEOUT_UNIT); + } + + private InstanceIdentifier generateOduConnectionIID(String connectionNumber) { + + return InstanceIdentifier.create(OrgOpenroadmDevice.class).child(org.opendaylight.yang.gen.v1.http.org + .openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.OduConnection.class, + new OduConnectionKey(connectionNumber)); + } + + public Optional postOtnCrossConnect(List createdOduInterfaces, Nodes node) { + String deviceId = node.getNodeId(); + String srcTp = createdOduInterfaces.get(0); + String dstTp = createdOduInterfaces.get(1); + + OduConnectionBuilder oduConnectionBuilder = new OduConnectionBuilder() + .setConnectionName(srcTp + "-x-" + dstTp) + .setDestination(new org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.odu.connection + .DestinationBuilder().setDstIf(dstTp).build()) + .setSource(new org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.odu.connection + .SourceBuilder().setSrcIf(srcTp).build()) + .setDirection(Direction.Bidirectional); + + InstanceIdentifier oduConnectionIID = + InstanceIdentifier.create( + org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container + .OrgOpenroadmDevice.class) + .child(org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device + .container.org.openroadm.device.OduConnection.class, + new OduConnectionKey(oduConnectionBuilder.getConnectionName()) + ); + + Future> deviceTxFuture = deviceTransactionManager.getDeviceTransaction(deviceId); + DeviceTransaction deviceTx; + try { + Optional deviceTxOpt = deviceTxFuture.get(); + if (deviceTxOpt.isPresent()) { + deviceTx = deviceTxOpt.get(); + } else { + LOG.error("Device transaction for device {} was not found!", deviceId); + return Optional.empty(); + } + } catch (InterruptedException | ExecutionException e) { + LOG.error("Unable to obtain device transaction for device {}!", deviceId, e); + return Optional.empty(); + } + + // post the cross connect on the device + deviceTx.merge(LogicalDatastoreType.CONFIGURATION, oduConnectionIID, oduConnectionBuilder.build()); + FluentFuture commit = + deviceTx.commit(Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT); + try { + commit.get(); + LOG.info("Otn-connection successfully created: {}-{}", srcTp, dstTp); + return Optional.of(srcTp + "-x-" + dstTp); + } catch (InterruptedException | ExecutionException e) { + LOG.warn("Failed to post {}.", oduConnectionBuilder.build(), e); + } + return Optional.empty(); + + } + + public List deleteOtnCrossConnect(String deviceId, String connectionName) { + List interfList = new ArrayList<>(); + Optional otnXc = getOtnCrossConnect(deviceId, connectionName); + + 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", connectionName); + return null; + } + Future> deviceTxFuture = deviceTransactionManager.getDeviceTransaction(deviceId); + DeviceTransaction deviceTx; + try { + Optional deviceTxOpt = deviceTxFuture.get(); + if (deviceTxOpt.isPresent()) { + deviceTx = deviceTxOpt.get(); + } else { + LOG.error("Device transaction for device {} was not found!", deviceId); + return null; + } + } catch (InterruptedException | ExecutionException e) { + LOG.error("Unable to obtain device transaction for device {}!", deviceId, e); + return null; + } + + deviceTx.delete(LogicalDatastoreType.CONFIGURATION, generateOduConnectionIID(connectionName)); + + // delete the cross connect on the device + deviceTx.delete(LogicalDatastoreType.CONFIGURATION, generateOduConnectionIID(connectionName)); + FluentFuture commit = + deviceTx.commit(Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT); + try { + commit.get(); + LOG.info("Connection {} successfully deleted on {}", connectionName, deviceId); + return interfList; + } catch (InterruptedException | ExecutionException e) { + LOG.warn("Failed to delete {}", connectionName, e); + } + return null; + } + +} diff --git a/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion710.java b/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion710.java index 8d85f8e49..6b9030e7a 100644 --- a/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion710.java +++ b/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion710.java @@ -892,9 +892,18 @@ public class PortMappingVersion710 { if (interfaceType.equals(OpticalTransport.class)) { mpBldr.setSupportingOts(interfaces.getInterfaceName()); } - if (interfaceType.equals(OtnOdu.class)) { + String interfaceName = interfaces.getInterfaceName(); + if (interfaceType.equals(OtnOdu.class) + && (interfaceName.substring(interfaceName.lastIndexOf("-") + 1) + .equals("ODU"))) { mpBldr.setSupportingOdu4(interfaces.getInterfaceName()); } + if ((interfaceType.equals(OtnOdu.class)) + && (interfaceName.substring(interfaceName.lastIndexOf("-") + 1) + .equals("ODUC4"))) { + mpBldr.setSupportingOduc4(interfaces.getInterfaceName()); + } + } catch (OpenRoadmInterfaceException ex) { LOG.warn("{} : Error while getting interface {} - ", nodeId, interfaces.getInterfaceName(), ex); diff --git a/common/src/main/resources/OSGI-INF/blueprint/common-blueprint.xml b/common/src/main/resources/OSGI-INF/blueprint/common-blueprint.xml index 6260594a5..e3a05ade0 100644 --- a/common/src/main/resources/OSGI-INF/blueprint/common-blueprint.xml +++ b/common/src/main/resources/OSGI-INF/blueprint/common-blueprint.xml @@ -85,11 +85,16 @@ and is available at http://www.eclipse.org/legal/epl-v10.html + + + + + diff --git a/common/src/test/java/org/opendaylight/transportpce/common/crossconnect/CrossConnectImplTest.java b/common/src/test/java/org/opendaylight/transportpce/common/crossconnect/CrossConnectImplTest.java index 96b8beb44..12fd45954 100644 --- a/common/src/test/java/org/opendaylight/transportpce/common/crossconnect/CrossConnectImplTest.java +++ b/common/src/test/java/org/opendaylight/transportpce/common/crossconnect/CrossConnectImplTest.java @@ -30,6 +30,7 @@ public class CrossConnectImplTest { private static DeviceTransactionManager deviceTransactionManager; private CrossConnectImpl121 crossConnectImpl121 = null; private CrossConnectImpl221 crossConnectImpl221 = null; + private CrossConnectImpl710 crossConnectImpl710 = null; private MappingUtils mappingUtils = null; @Before @@ -37,9 +38,11 @@ public class CrossConnectImplTest { deviceTransactionManager = mock(DeviceTransactionManager.class); crossConnectImpl121 = mock(CrossConnectImpl121.class); crossConnectImpl221 = mock(CrossConnectImpl221.class); + crossConnectImpl710 = mock(CrossConnectImpl710.class); mappingUtils = mock(MappingUtils.class); crossConnectImpl = - new CrossConnectImpl(deviceTransactionManager, mappingUtils, crossConnectImpl121, crossConnectImpl221); + new CrossConnectImpl(deviceTransactionManager, mappingUtils, crossConnectImpl121, + crossConnectImpl221, crossConnectImpl710); } @Before diff --git a/lighty/src/main/java/io/lighty/controllers/tpce/module/TransportPCEImpl.java b/lighty/src/main/java/io/lighty/controllers/tpce/module/TransportPCEImpl.java index cee0fba65..439a2c501 100644 --- a/lighty/src/main/java/io/lighty/controllers/tpce/module/TransportPCEImpl.java +++ b/lighty/src/main/java/io/lighty/controllers/tpce/module/TransportPCEImpl.java @@ -16,6 +16,7 @@ import org.opendaylight.transportpce.common.crossconnect.CrossConnect; import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl; import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl121; import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl221; +import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl710; import org.opendaylight.transportpce.common.device.DeviceTransactionManagerImpl; import org.opendaylight.transportpce.common.mapping.MappingUtils; import org.opendaylight.transportpce.common.mapping.MappingUtilsImpl; @@ -60,6 +61,7 @@ import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterf import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterfaceFactory; // Adding OTN interface import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmOtnInterface221; +import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmOtnInterface710; import org.opendaylight.transportpce.renderer.provisiondevice.DeviceRendererService; import org.opendaylight.transportpce.renderer.provisiondevice.DeviceRendererServiceImpl; import org.opendaylight.transportpce.renderer.provisiondevice.OtnDeviceRendererService; @@ -305,8 +307,10 @@ public class TransportPCEImpl extends AbstractLightyModule implements TransportP OpenRoadmInterface710 openRoadmInterface710 = new OpenRoadmInterface710(portMapping, openRoadmInterfaces); OpenRoadmOtnInterface221 openRoadmOtnInterface221 = new OpenRoadmOtnInterface221(portMapping, openRoadmInterfaces); + OpenRoadmOtnInterface710 openRoadmOtnInterface710 = new OpenRoadmOtnInterface710(portMapping, + openRoadmInterfaces); return new OpenRoadmInterfaceFactory(mappingUtils, openRoadmInterface121, openRoadmInterface221, - openRoadmInterface710, openRoadmOtnInterface221); + openRoadmInterface710, openRoadmOtnInterface221, openRoadmOtnInterface710); } private PortMapping initPortMapping(LightyServices lightyServices, OpenRoadmInterfaces openRoadmInterfaces) { @@ -334,6 +338,8 @@ public class TransportPCEImpl extends AbstractLightyModule implements TransportP private CrossConnect initCrossConnect(MappingUtils mappingUtils) { CrossConnectImpl121 crossConnectImpl121 = new CrossConnectImpl121(deviceTransactionManager); CrossConnectImpl221 crossConnectImpl221 = new CrossConnectImpl221(deviceTransactionManager); - return new CrossConnectImpl(deviceTransactionManager, mappingUtils, crossConnectImpl121, crossConnectImpl221); + CrossConnectImpl710 crossConnectImpl710 = new CrossConnectImpl710(deviceTransactionManager); + return new CrossConnectImpl(deviceTransactionManager, mappingUtils, crossConnectImpl121, crossConnectImpl221, + crossConnectImpl710); } } diff --git a/olm/src/test/java/org/opendaylight/transportpce/olm/OlmPowerServiceRpcImplTest.java b/olm/src/test/java/org/opendaylight/transportpce/olm/OlmPowerServiceRpcImplTest.java index 656418772..3c6e699e1 100644 --- a/olm/src/test/java/org/opendaylight/transportpce/olm/OlmPowerServiceRpcImplTest.java +++ b/olm/src/test/java/org/opendaylight/transportpce/olm/OlmPowerServiceRpcImplTest.java @@ -26,6 +26,7 @@ import org.opendaylight.transportpce.common.crossconnect.CrossConnect; import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl; import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl121; import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl221; +import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl710; import org.opendaylight.transportpce.common.device.DeviceTransactionManager; import org.opendaylight.transportpce.common.device.DeviceTransactionManagerImpl; import org.opendaylight.transportpce.common.mapping.MappingUtils; @@ -91,6 +92,7 @@ public class OlmPowerServiceRpcImplTest extends AbstractTest { private OlmPowerServiceRpcImpl olmPowerServiceRpc; private CrossConnectImpl121 crossConnectImpl121; private CrossConnectImpl221 crossConnectImpl22; + private CrossConnectImpl710 crossConnectImpl710; private MappingUtils mappingUtils; private OpenRoadmInterfacesImpl121 openRoadmInterfacesImpl121; private OpenRoadmInterfacesImpl221 openRoadmInterfacesImpl22; @@ -110,8 +112,9 @@ public class OlmPowerServiceRpcImplTest extends AbstractTest { this.deviceTransactionManager = new DeviceTransactionManagerImpl(mountPointService, 3000); this.crossConnectImpl121 = new CrossConnectImpl121(deviceTransactionManager); this.crossConnectImpl22 = new CrossConnectImpl221(deviceTransactionManager); + this.crossConnectImpl710 = new CrossConnectImpl710(deviceTransactionManager); this.crossConnect = new CrossConnectImpl(deviceTransactionManager, this.mappingUtils, this.crossConnectImpl121, - this.crossConnectImpl22); + this.crossConnectImpl22, this.crossConnectImpl710); this.openRoadmInterfacesImpl121 = new OpenRoadmInterfacesImpl121(deviceTransactionManager); this.openRoadmInterfacesImpl22 = new OpenRoadmInterfacesImpl221(deviceTransactionManager); this.openRoadmInterfacesImpl710 = new OpenRoadmInterfacesImpl710(deviceTransactionManager); diff --git a/olm/src/test/java/org/opendaylight/transportpce/olm/power/PowerMgmtPowerMockTest.java b/olm/src/test/java/org/opendaylight/transportpce/olm/power/PowerMgmtPowerMockTest.java index 637530f58..f211bc165 100644 --- a/olm/src/test/java/org/opendaylight/transportpce/olm/power/PowerMgmtPowerMockTest.java +++ b/olm/src/test/java/org/opendaylight/transportpce/olm/power/PowerMgmtPowerMockTest.java @@ -26,6 +26,7 @@ import org.opendaylight.transportpce.common.crossconnect.CrossConnect; import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl; import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl121; import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl221; +import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl710; import org.opendaylight.transportpce.common.device.DeviceTransactionManager; import org.opendaylight.transportpce.common.device.DeviceTransactionManagerImpl; import org.opendaylight.transportpce.common.mapping.MappingUtils; @@ -84,6 +85,7 @@ public class PowerMgmtPowerMockTest extends AbstractTest { private PowerMgmt powerMgmt; private CrossConnectImpl121 crossConnectImpl121; private CrossConnectImpl221 crossConnectImpl22; + private CrossConnectImpl710 crossConnectImpl710; private MappingUtils mappingUtils; private OpenRoadmInterfacesImpl121 openRoadmInterfacesImpl121; private OpenRoadmInterfacesImpl221 openRoadmInterfacesImpl22; @@ -104,7 +106,7 @@ public class PowerMgmtPowerMockTest extends AbstractTest { this.crossConnectImpl121 = new CrossConnectImpl121(deviceTransactionManager); this.crossConnectImpl22 = new CrossConnectImpl221(deviceTransactionManager); this.crossConnect = new CrossConnectImpl(deviceTransactionManager, this.mappingUtils, this.crossConnectImpl121, - this.crossConnectImpl22); + this.crossConnectImpl22, this.crossConnectImpl710); this.openRoadmInterfacesImpl121 = new OpenRoadmInterfacesImpl121(deviceTransactionManager); this.openRoadmInterfacesImpl22 = new OpenRoadmInterfacesImpl221(deviceTransactionManager); this.openRoadmInterfacesImpl710 = new OpenRoadmInterfacesImpl710(deviceTransactionManager); diff --git a/olm/src/test/java/org/opendaylight/transportpce/olm/power/PowerMgmtTest.java b/olm/src/test/java/org/opendaylight/transportpce/olm/power/PowerMgmtTest.java index db22852fb..bdaaf6a73 100644 --- a/olm/src/test/java/org/opendaylight/transportpce/olm/power/PowerMgmtTest.java +++ b/olm/src/test/java/org/opendaylight/transportpce/olm/power/PowerMgmtTest.java @@ -21,6 +21,7 @@ import org.opendaylight.transportpce.common.crossconnect.CrossConnect; import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl; import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl121; import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl221; +import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl710; import org.opendaylight.transportpce.common.device.DeviceTransactionManager; import org.opendaylight.transportpce.common.device.DeviceTransactionManagerImpl; import org.opendaylight.transportpce.common.mapping.MappingUtils; @@ -54,6 +55,7 @@ public class PowerMgmtTest extends AbstractTest { private PowerMgmt powerMgmt; private CrossConnectImpl121 crossConnectImpl121; private CrossConnectImpl221 crossConnectImpl22; + private CrossConnectImpl710 crossConnectImpl710; private MappingUtils mappingUtils; private OpenRoadmInterfacesImpl121 openRoadmInterfacesImpl121; private OpenRoadmInterfacesImpl221 openRoadmInterfacesImpl22; @@ -76,7 +78,7 @@ public class PowerMgmtTest extends AbstractTest { this.crossConnectImpl121 = new CrossConnectImpl121(deviceTransactionManager); this.crossConnectImpl22 = new CrossConnectImpl221(deviceTransactionManager); this.crossConnect = new CrossConnectImpl(deviceTransactionManager, this.mappingUtils, this.crossConnectImpl121, - this.crossConnectImpl22); + this.crossConnectImpl22, this.crossConnectImpl710); this.openRoadmInterfacesImpl121 = new OpenRoadmInterfacesImpl121(deviceTransactionManager); this.openRoadmInterfacesImpl22 = new OpenRoadmInterfacesImpl221(deviceTransactionManager); this.openRoadmInterfacesImpl710 = new OpenRoadmInterfacesImpl710(deviceTransactionManager); diff --git a/olm/src/test/java/org/opendaylight/transportpce/olm/service/OlmPowerServiceImplTest.java b/olm/src/test/java/org/opendaylight/transportpce/olm/service/OlmPowerServiceImplTest.java index cbfe928eb..8a17e7ab0 100644 --- a/olm/src/test/java/org/opendaylight/transportpce/olm/service/OlmPowerServiceImplTest.java +++ b/olm/src/test/java/org/opendaylight/transportpce/olm/service/OlmPowerServiceImplTest.java @@ -24,6 +24,7 @@ import org.opendaylight.transportpce.common.crossconnect.CrossConnect; import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl; import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl121; import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl221; +import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl710; import org.opendaylight.transportpce.common.device.DeviceTransactionManager; import org.opendaylight.transportpce.common.device.DeviceTransactionManagerImpl; import org.opendaylight.transportpce.common.mapping.MappingUtils; @@ -84,6 +85,7 @@ public class OlmPowerServiceImplTest extends AbstractTest { private PowerMgmt powerMgmt; private CrossConnectImpl121 crossConnectImpl121; private CrossConnectImpl221 crossConnectImpl22; + private CrossConnectImpl710 crossConnectImpl710; private MappingUtils mappingUtils; private OpenRoadmInterfacesImpl121 openRoadmInterfacesImpl121; private OpenRoadmInterfacesImpl221 openRoadmInterfacesImpl22; @@ -112,7 +114,7 @@ public class OlmPowerServiceImplTest extends AbstractTest { this.crossConnectImpl121 = new CrossConnectImpl121(deviceTransactionManager); this.crossConnectImpl22 = new CrossConnectImpl221(deviceTransactionManager); this.crossConnect = new CrossConnectImpl(deviceTransactionManager, this.mappingUtils, this.crossConnectImpl121, - this.crossConnectImpl22); + this.crossConnectImpl22, this.crossConnectImpl710); this.openRoadmInterfacesImpl121 = new OpenRoadmInterfacesImpl121(deviceTransactionManager); this.openRoadmInterfacesImpl22 = new OpenRoadmInterfacesImpl221(deviceTransactionManager); this.openRoadmInterfacesImpl710 = new OpenRoadmInterfacesImpl710(deviceTransactionManager); diff --git a/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterface710.java b/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterface710.java index 04a5000ee..51bb5aeda 100644 --- a/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterface710.java +++ b/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterface710.java @@ -324,7 +324,8 @@ public class OpenRoadmInterface710 { .setPayloadType(PayloadTypeDef.getDefaultInstance("22")); // Maint test signal MaintTestsignalBuilder maintTestsignal = new MaintTestsignalBuilder() - .setTestPattern(TestPattern.PRBS23) + // PRBS value should be PRBS31 if enabled is true + .setTestPattern(TestPattern.PRBS31) .setEnabled(false); // Create an ODUC4 object @@ -390,7 +391,8 @@ public class OpenRoadmInterface710 { .setPayloadType(PayloadTypeDef.getDefaultInstance("22")); // Maint test signal MaintTestsignalBuilder maintTestsignal = new MaintTestsignalBuilder() - .setTestPattern(TestPattern.PRBS23) + // PRBS value should be PRBS31 if enabled is true + .setTestPattern(TestPattern.PRBS31) .setEnabled(false); // Create an ODUC4 object @@ -434,6 +436,138 @@ public class OpenRoadmInterface710 { return oduInterfaceBuilder.getName(); } + public String createOpenRoadmOtnOducnInterface(String nodeId, String logicalConnPoint, + String supportingOtucn) + throws OpenRoadmInterfaceException { + Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint); + if (portMap == null) { + throw new OpenRoadmInterfaceException( + String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, + nodeId, logicalConnPoint)); + } + // Create ODUcn object + // Start with OPU object + // OPU payload + OpuBuilder opuBuilder = new OpuBuilder() + .setExpPayloadType(PayloadTypeDef.getDefaultInstance("22")) + .setPayloadType(PayloadTypeDef.getDefaultInstance("22")); + // Maint test signal + MaintTestsignalBuilder maintTestsignal = new MaintTestsignalBuilder() + // PRBS value should be PRBS31 if enabled is true + .setTestPattern(TestPattern.PRBS31) + .setEnabled(false); + + // Create an ODUC4 object + OduBuilder oduBuilder = new OduBuilder() + .setRate(ODUCn.class) + .setOducnNRate(Uint16.valueOf(4)) + .setOduFunction(ODUTTP.class) + .setMonitoringMode(MonitoringMode.Terminated) + .setTimActEnabled(false) + .setTimDetectMode(TimDetectMode.Disabled) + .setDegmIntervals(Uint8.valueOf(2)) + .setDegthrPercentage(Uint16.valueOf(100)) + .setOpu(opuBuilder.build()) + .setMaintTestsignal(maintTestsignal.build()); + + InterfaceBuilder oduInterfaceBuilder = createGenericInterfaceBuilder(portMap, OtnOdu.class, + logicalConnPoint + "-ODUC4"); + + // Create a list + List listSupportingOtucnInterface = new ArrayList<>(); + listSupportingOtucnInterface.add(supportingOtucn); + + oduInterfaceBuilder.setSupportingInterfaceList(listSupportingOtucnInterface); + org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder oduIf1Builder = + new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder(); + + oduInterfaceBuilder.addAugmentation(oduIf1Builder.setOdu(oduBuilder.build()).build()); + + // Post interface on the device + openRoadmInterfaces.postInterface(nodeId, oduInterfaceBuilder); + + // Post the equipment-state change on the device circuit-pack if xpdr node + if (portMap.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) { + this.openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true); + } + // Update the port-mapping with the interface information + this.portMapping.updateMapping(nodeId, portMap); + return oduInterfaceBuilder.getName(); + } + + + // With SAPI and DAPI information + public String createOpenRoadmOtnOducnInterface(String anodeId, String alogicalConnPoint, + String supportingOtucn, String znodeId, String zlogicalConnPoint) + throws OpenRoadmInterfaceException { + Mapping portMapA = portMapping.getMapping(anodeId, alogicalConnPoint); + Mapping portMapZ = portMapping.getMapping(znodeId, zlogicalConnPoint); + if (portMapA == null) { + throw new OpenRoadmInterfaceException( + String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, + anodeId, alogicalConnPoint)); + } + // On the Zside + if (portMapZ == null) { + throw new OpenRoadmInterfaceException( + String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, + znodeId, zlogicalConnPoint)); + + } + // Create ODUcn object + // Start with OPU object + // OPU payload + OpuBuilder opuBuilder = new OpuBuilder() + .setExpPayloadType(PayloadTypeDef.getDefaultInstance("22")) + .setPayloadType(PayloadTypeDef.getDefaultInstance("22")); + // Maint test signal + MaintTestsignalBuilder maintTestsignal = new MaintTestsignalBuilder() + // PRBS value should be PRBS31 if enabled is true + .setTestPattern(TestPattern.PRBS31) + .setEnabled(false); + + // Create an ODUC4 object + OduBuilder oduBuilder = new OduBuilder() + .setRate(ODUCn.class) + .setOducnNRate(Uint16.valueOf(4)) + .setOduFunction(ODUTTP.class) + .setMonitoringMode(MonitoringMode.Terminated) + .setTimActEnabled(false) + .setTimDetectMode(TimDetectMode.Disabled) + .setDegmIntervals(Uint8.valueOf(2)) + .setDegthrPercentage(Uint16.valueOf(100)) + .setOpu(opuBuilder.build()) + .setTxSapi(portMapA.getLcpHashVal()) + .setTxDapi(portMapZ.getLcpHashVal()) + .setExpectedSapi(portMapZ.getLcpHashVal()) + .setExpectedDapi(portMapZ.getLcpHashVal()) + .setMaintTestsignal(maintTestsignal.build()); + + InterfaceBuilder oduInterfaceBuilder = createGenericInterfaceBuilder(portMapA, OtnOdu.class, + alogicalConnPoint + "-ODUC4"); + + // Create a list + List listSupportingOtucnInterface = new ArrayList<>(); + listSupportingOtucnInterface.add(supportingOtucn); + + oduInterfaceBuilder.setSupportingInterfaceList(listSupportingOtucnInterface); + org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder oduIf1Builder = + new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder(); + + oduInterfaceBuilder.addAugmentation(oduIf1Builder.setOdu(oduBuilder.build()).build()); + + // Post interface on the device + openRoadmInterfaces.postInterface(anodeId, oduInterfaceBuilder); + + // Post the equipment-state change on the device circuit-pack if xpdr node + if (portMapA.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) { + this.openRoadmInterfaces.postEquipmentState(anodeId, portMapA.getSupportingCircuitPackName(), true); + } + // Update the port-mapping with the interface information + this.portMapping.updateMapping(anodeId, portMapA); + return oduInterfaceBuilder.getName(); + } + // This is only for transponder public String createOpenRoadmOduflexInterface(String nodeId, String logicalConnPoint, String supportingOducn) @@ -451,7 +585,8 @@ public class OpenRoadmInterface710 { // Maint test signal MaintTestsignalBuilder maintTestsignal = new MaintTestsignalBuilder() - .setTestPattern(TestPattern.PRBS23) + // PRBS value should be PRBS31 if enabled is true + .setTestPattern(TestPattern.PRBS31) .setEnabled(false); // Parent Odu-allocation @@ -529,7 +664,8 @@ public class OpenRoadmInterface710 { // Maint test signal MaintTestsignalBuilder maintTestsignal = new MaintTestsignalBuilder() - .setTestPattern(TestPattern.PRBS23) + // PRBS value should be PRBS31 if enabled is true + .setTestPattern(TestPattern.PRBS31) .setEnabled(false); // Parent Odu-allocation 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 d053bac6f..9e49ca1d1 100644 --- 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,28 +16,33 @@ import org.opendaylight.transportpce.common.fixedflex.SpectrumInformation; 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.rev210426.mapping.Mapping; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.OpucnTribSlotDef; import org.slf4j.Logger; import org.slf4j.LoggerFactory; 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"; + "OTN functions are not supported by Openroadm models 1.2.1"; + private static final String OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_2_2_1_MSG = + "OTN functions are not supported by Openroadm models 2.2.1"; private static final Logger LOG = LoggerFactory.getLogger(OpenRoadmInterfaceFactory.class); private final MappingUtils mappingUtils; private final OpenRoadmInterface121 openRoadmInterface121; private final OpenRoadmInterface221 openRoadmInterface221; private final OpenRoadmInterface710 openRoadmInterface710; - private final OpenRoadmOtnInterface221 openRoadmOtnInterface; + private final OpenRoadmOtnInterface221 openRoadmOtnInterface221; + private final OpenRoadmOtnInterface710 openRoadmOtnInterface710; public OpenRoadmInterfaceFactory(MappingUtils mappingUtils, OpenRoadmInterface121 openRoadmInterface121, OpenRoadmInterface221 openRoadmInterface221, OpenRoadmInterface710 openRoadmInterface710, - OpenRoadmOtnInterface221 openRoadmOTNInterface) { + OpenRoadmOtnInterface221 openRoadmOTNInterface221, OpenRoadmOtnInterface710 openRoadmOtnInterface710) { this.mappingUtils = mappingUtils; this.openRoadmInterface121 = openRoadmInterface121; this.openRoadmInterface221 = openRoadmInterface221; this.openRoadmInterface710 = openRoadmInterface710; - this.openRoadmOtnInterface = openRoadmOTNInterface; + this.openRoadmOtnInterface221 = openRoadmOTNInterface221; + this.openRoadmOtnInterface710 = openRoadmOtnInterface710; } public String createOpenRoadmEthInterface(String nodeId, String logicalConnPoint) @@ -248,7 +253,7 @@ public class OpenRoadmInterfaceFactory { } public boolean isUsedByXc(String nodeId, String interfaceName, String xc, - DeviceTransactionManager deviceTransactionManager) { + DeviceTransactionManager deviceTransactionManager) { switch (mappingUtils.getOpenRoadmVersion(nodeId)) { case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1: return openRoadmInterface121.isUsedByXc(nodeId, interfaceName, xc, deviceTransactionManager); @@ -273,26 +278,44 @@ public class OpenRoadmInterfaceFactory { } public String createOpenRoadmEth1GInterface(String nodeId, - String logicalConnPoint) throws OpenRoadmInterfaceException { + String logicalConnPoint) throws OpenRoadmInterfaceException { switch (mappingUtils.getOpenRoadmVersion(nodeId)) { case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1: LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG); return null; case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1: - return openRoadmOtnInterface.createOpenRoadmEth1GInterface(nodeId, logicalConnPoint); + return openRoadmOtnInterface221.createOpenRoadmEth1GInterface(nodeId, logicalConnPoint); default: return null; } } public String createOpenRoadmEth10GInterface(String nodeId, - String logicalConnPoint) throws OpenRoadmInterfaceException { + String logicalConnPoint) throws OpenRoadmInterfaceException { switch (mappingUtils.getOpenRoadmVersion(nodeId)) { case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1: LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG); return null; case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1: - return openRoadmOtnInterface.createOpenRoadmEth10GInterface(nodeId, logicalConnPoint); + return openRoadmOtnInterface221.createOpenRoadmEth10GInterface(nodeId, logicalConnPoint); + default: + return null; + } + + } + + public String createOpenRoadmEth100GInterface(String nodeId, + String logicalConnPoint) throws OpenRoadmInterfaceException { + + switch (mappingUtils.getOpenRoadmVersion(nodeId)) { + case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1: + LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG); + return null; + case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1: + LOG.warn("Use Ethernet interface creation for 2.2.1, instead this method of Ether 100G"); + return openRoadmInterface221.createOpenRoadmEthInterface(nodeId, logicalConnPoint); + case StringConstants.OPENROADM_DEVICE_VERSION_7_1: + return openRoadmOtnInterface710.createOpenRoadmEth100GInterface(nodeId, logicalConnPoint); default: return null; } @@ -307,7 +330,7 @@ public class OpenRoadmInterfaceFactory { 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( + return openRoadmOtnInterface221.createOpenRoadmOdu0Interface( nodeId, logicalConnPoint, servicename, payLoad, isNetworkPort, tribPortNumber, tribSlot); default: return null; @@ -322,7 +345,7 @@ public class OpenRoadmInterfaceFactory { 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( + return openRoadmOtnInterface221.createOpenRoadmOdu2Interface( nodeId, logicalConnPoint, servicename, payLoad, isNetworkPort, tribPortNumber, tribSlotIndex); default: return null; @@ -337,7 +360,7 @@ public class OpenRoadmInterfaceFactory { 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( + return openRoadmOtnInterface221.createOpenRoadmOdu2eInterface( nodeId, logicalConnPoint, servicename, payLoad, isNetworkPort, tribPortNumber, tribSlotIndex); default: return null; @@ -345,6 +368,26 @@ public class OpenRoadmInterfaceFactory { } + public String createOpenRoadmOtnOdu4LoInterface(String nodeId, String logicalConnPoint, + String serviceName, String payLoad, boolean isNetworkPort, + OpucnTribSlotDef minTribSlotNumber, OpucnTribSlotDef maxTribSlotNumber) + throws OpenRoadmInterfaceException { + + switch (mappingUtils.getOpenRoadmVersion(nodeId)) { + case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1: + LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG); + return null; + case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1: + LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_2_2_1_MSG); + return null; + case StringConstants.OPENROADM_DEVICE_VERSION_7_1: + return openRoadmOtnInterface710.createOpenRoadmOdu4Interface(nodeId, logicalConnPoint, serviceName, + payLoad, isNetworkPort, minTribSlotNumber, maxTribSlotNumber); + default: + return null; + } + } + public String createOpenRoadmOtnOdu4Interface(String nodeId, String logicalConnPoint, String supportingOtuInterface) throws OpenRoadmInterfaceException { switch (mappingUtils.getOpenRoadmVersion(nodeId)) { @@ -368,4 +411,29 @@ public class OpenRoadmInterfaceFactory { return null; } } + + public String createOpenRoadmOtnOduc4Interface(String nodeId, String logicalConnPoint, + String supportingOtuInterface) + throws OpenRoadmInterfaceException { + switch (mappingUtils.getOpenRoadmVersion(nodeId)) { + case StringConstants.OPENROADM_DEVICE_VERSION_7_1: + return openRoadmInterface710 + .createOpenRoadmOtnOducnInterface(nodeId, logicalConnPoint, supportingOtuInterface); + default: + return null; + } + } + + public String createOpenRoadmOtnOduc4Interface(String anodeId, String alogicalConnPoint, + String asupportingOtuInterface, String znodeId, String zlogicalConnPoint) + throws OpenRoadmInterfaceException { + switch (mappingUtils.getOpenRoadmVersion(anodeId)) { + case StringConstants.OPENROADM_DEVICE_VERSION_7_1: + return openRoadmInterface710 + .createOpenRoadmOtnOducnInterface(anodeId, alogicalConnPoint, asupportingOtuInterface, + znodeId, zlogicalConnPoint); + default: + return null; + } + } } diff --git a/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmOtnInterface710.java b/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmOtnInterface710.java new file mode 100644 index 000000000..52ba7bbe8 --- /dev/null +++ b/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmOtnInterface710.java @@ -0,0 +1,174 @@ +/* + * Copyright © 2021 AT&T and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.transportpce.renderer.openroadminterface; + +import java.util.ArrayList; +import java.util.List; +import java.util.stream.IntStream; +import org.opendaylight.transportpce.common.mapping.PortMapping; +import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException; +import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.mapping.Mapping; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.attributes.rev200327.parent.odu.allocation.ParentOduAllocationBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.attributes.rev200327.parent.odu.allocation.parent.odu.allocation.trib.slots.choice.OpucnBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev200529.Off; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.interfaces.grp.InterfaceBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.interfaces.grp.InterfaceKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev191129.AdminStates; +import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev200529.Interface1Builder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev200529.ethernet.container.EthernetBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev191129.EthernetCsmacd; +import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev191129.InterfaceType; +import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev191129.OtnOdu; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.ODU4; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.ODUCTP; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.ODUTTPCTP; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.OpucnTribSlotDef; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.PayloadTypeDef; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.OduAttributes.MonitoringMode; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.odu.container.OduBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.opu.OpuBuilder; +import org.opendaylight.yangtools.yang.common.Uint16; +import org.opendaylight.yangtools.yang.common.Uint32; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class OpenRoadmOtnInterface710 { + private final PortMapping portMapping; + private final OpenRoadmInterfaces openRoadmInterfaces; + private static final Logger LOG = LoggerFactory + .getLogger(OpenRoadmOtnInterface710.class); + + public OpenRoadmOtnInterface710(PortMapping portMapping, + OpenRoadmInterfaces openRoadmInterfaces) { + this.portMapping = portMapping; + this.openRoadmInterfaces = openRoadmInterfaces; + } + + public String createOpenRoadmEth100GInterface(String nodeId, + String logicalConnPoint) throws OpenRoadmInterfaceException { + + Mapping portMap = this.portMapping.getMapping(nodeId, logicalConnPoint); + if (portMap == null) { + throwException(nodeId, logicalConnPoint); + } + + // Ethernet interface specific data + EthernetBuilder ethIfBuilder = new EthernetBuilder() + .setFec(Off.class) + .setSpeed(Uint32.valueOf(100000)); + InterfaceBuilder ethInterfaceBldr = createGenericInterfaceBuilder( + portMap, EthernetCsmacd.class, + logicalConnPoint + "-ETHERNET100G"); + // Create Interface1 type object required for adding as augmentation + Interface1Builder ethIf1Builder = new Interface1Builder(); + ethInterfaceBldr.addAugmentation(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); + 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)); + } + + public String createOpenRoadmOdu4Interface(String nodeId, String logicalConnPoint, + String serviceName, String payLoad, + boolean isNetworkPort, OpucnTribSlotDef minTribSlotNumber, OpucnTribSlotDef maxTribSlotNumber) + throws OpenRoadmInterfaceException { + Mapping portMap = this.portMapping.getMapping(nodeId, logicalConnPoint); + if (portMap == null) { + throwException(nodeId, logicalConnPoint); + } + List supportingInterfaceList = new ArrayList<>(); + String supportingInterface = null; + if (isNetworkPort) { + supportingInterface = portMap.getSupportingOduc4(); + } else { + supportingInterface = logicalConnPoint + "-ETHERNET100G"; + } + + if (supportingInterface == null) { + throw new OpenRoadmInterfaceException( + "Interface Creation failed because of missing supported " + + "ODU4 on network end or Ethernet on client"); + } + // Supporting interface is a list for B100G (7.1) device models + supportingInterfaceList.add(supportingInterface); + + InterfaceBuilder oduIfBuilder = createGenericInterfaceBuilder( + portMap, OtnOdu.class, logicalConnPoint + "-ODU4-" + serviceName) + .setSupportingInterfaceList(supportingInterfaceList); + // Agument ODU4 specific interface data + OduBuilder oduBuilder = new OduBuilder().setRate(ODU4.class) + .setOduFunction(ODUTTPCTP.class) + .setMonitoringMode(MonitoringMode.Terminated); + LOG.debug("Inside the ODU4 creation {} {} {}", isNetworkPort, minTribSlotNumber.getValue(), + maxTribSlotNumber.getValue()); + // If it is a network port we have fill the required trib-slots and trib-ports + if (isNetworkPort) { + List opucnTribSlotDefList = new ArrayList<>(); + // Escape characters are used to here to take the literal dot + Uint16 tribPortNumber = Uint16.valueOf(minTribSlotNumber.getValue().split("\\.")[0]); + Uint16 startTribSlot = Uint16.valueOf(minTribSlotNumber.getValue().split("\\.")[1]); + Uint16 endTribSlot = Uint16.valueOf(maxTribSlotNumber.getValue().split("\\.")[1]); + + IntStream.range(startTribSlot.intValue(), endTribSlot.intValue() + 1) + .forEach( + nbr -> opucnTribSlotDefList.add(OpucnTribSlotDef.getDefaultInstance(tribPortNumber + "." + nbr)) + ); + ParentOduAllocationBuilder parentOduAllocationBuilder = new ParentOduAllocationBuilder() + .setTribPortNumber(tribPortNumber) + .setTribSlotsChoice(new OpucnBuilder().setOpucnTribSlots(opucnTribSlotDefList).build()); + // reset the ODU function as ODUCTP and the monitoring moode + oduBuilder.setOduFunction(ODUCTP.class) + .setMonitoringMode(MonitoringMode.NotTerminated) + .setParentOduAllocation(parentOduAllocationBuilder.build()); + } + else { + // This is for the client side of the ODU (ODU-TTP-CTP) + // Set Opu attributes + OpuBuilder opuBuilder = new OpuBuilder() + .setExpPayloadType(new PayloadTypeDef(payLoad)) + .setPayloadType(new PayloadTypeDef(payLoad)); + oduBuilder.setOpu(opuBuilder.build()); + } + + org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder + oduIf1Builder = new + org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder(); + oduIfBuilder.addAugmentation(oduIf1Builder.setOdu(oduBuilder.build()).build()); + // Post interface on the device + this.openRoadmInterfaces.postOTNInterface(nodeId, oduIfBuilder); + LOG.info("Returning the ODU4 inteface {}", oduIfBuilder.getName()); + return oduIfBuilder.getName(); + } + + private InterfaceBuilder createGenericInterfaceBuilder(Mapping portMap, + Class type, String key) { + return new InterfaceBuilder() + // .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)); + } +} 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 ec8ff8a82..676f15570 100644 --- a/renderer/src/main/java/org/opendaylight/transportpce/renderer/provisiondevice/OtnDeviceRendererServiceImpl.java +++ b/renderer/src/main/java/org/opendaylight/transportpce/renderer/provisiondevice/OtnDeviceRendererServiceImpl.java @@ -30,6 +30,7 @@ import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.re import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev200128.OtnServicePathOutput; import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev200128.OtnServicePathOutputBuilder; import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.interfaces.grp.Interface; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.OpucnTribSlotDef; import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev201211.node.interfaces.NodeInterface; import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev201211.node.interfaces.NodeInterfaceBuilder; import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev201211.node.interfaces.NodeInterfaceKey; @@ -84,28 +85,28 @@ public class OtnDeviceRendererServiceImpl implements OtnDeviceRendererService { nodeInterfaces = createInterface(input); LOG.info("Node interfaces created just fine "); - List nodesToUpdate = new ArrayList<>(); - if (!nodeInterfaces.isEmpty()) { - for (NodeInterface nodeInterf : nodeInterfaces) { - if (nodeInterf.getOduInterfaceId() != null) { - List interList = nodeInterf.getOduInterfaceId().stream() - .filter(id -> id.contains("NETWORK")).collect(Collectors.toList()); - if (!interList.isEmpty()) { - for (String inter : interList) { - String tp = inter.split("-ODU")[0]; - String nodeTopo = nodeInterf.getNodeId() + "-" + tp.split("-")[0]; - nodesToUpdate.add(nodeTopo + "--" + tp); - } - } - } - } - } + List nodesToUpdate = updateOduNodes(nodeInterfaces, "ODU"); updateOtnTopology(null, nodesToUpdate, input.getServiceRate(), input.getTribPortNumber(), input.getTribSlot(), false); } catch (OpenRoadmInterfaceException e) { LOG.warn("Set up service path failed", e); success = false; } + } else if ("100G".equals(input.getServiceRate())) { + try { + LOG.info("Calling Node interfaces {} {} {} {} {} {}", + input.getServiceRate(), input.getEthernetEncoding(), + input.getServiceType(), input.getOperation(), input.getOpucnTribSlots(), input.getNodes()); + nodeInterfaces = createInterface(input); + LOG.info("Node interfaces created just fine for 100G OTN "); + // TODO: Update the OTN topology accordingly with Opucn-Trib-slots + // List nodesToUpdate = updateOduNodes(nodeInterfaces, "ODUC4"); + // updateOtnTopology(null, nodesToUpdate, input.getServiceRate(), input.getTribPortNumber(), + // input.getTribSlot(), false); + } catch (OpenRoadmInterfaceException e) { + LOG.warn("Set up service path failed", e); + success = false; + } } else { LOG.warn("Unsupported service-rate for service-type Ethernet"); } @@ -119,6 +120,14 @@ public class OtnDeviceRendererServiceImpl implements OtnDeviceRendererService { LOG.warn("Set up service path failed", e); success = false; } + } else if ("400G".equals(input.getServiceRate())) { + try { + createOduc4TtpInterface(input, nodeInterfaces, otnNodesProvisioned); + updateOtnTopology(otnNodesProvisioned, null, null, null, null, false); + } catch (OpenRoadmInterfaceException e) { + LOG.warn("Set up service path failed", e); + success = false; + } } else { LOG.warn("Unsupported service-rate for service-type ODU"); } @@ -283,11 +292,37 @@ public class OtnDeviceRendererServiceImpl implements OtnDeviceRendererService { } } + private List updateOduNodes(List nodeInterfaceList, String deLimiter) { + List nodesToUpdate = new ArrayList<>(); + if (!(deLimiter.equals("ODU")) || !(deLimiter.equals("ODUC4"))) { + LOG.error("ODU node list update will be incorrect"); + } + + if (!nodeInterfaceList.isEmpty()) { + for (NodeInterface nodeInterf : nodeInterfaceList) { + if (nodeInterf.getOduInterfaceId() != null) { + List interList = nodeInterf.getOduInterfaceId().stream() + .filter(id -> id.contains("NETWORK")).collect(Collectors.toList()); + if (!interList.isEmpty()) { + for (String inter : interList) { + String tp = inter.split("-" + deLimiter)[0]; + String nodeTopo = nodeInterf.getNodeId() + "-" + tp.split("-")[0]; + nodesToUpdate.add(nodeTopo + "--" + tp); + } + } + } + } + } + + return nodesToUpdate; + } + private List createInterface(OtnServicePathInput input) throws OpenRoadmInterfaceException { List nodeInterfaces = new ArrayList<>(); LOG.info("Calling Create Interface entry for OTN service path"); if (input.getServiceRate() == null - || !("1G".equals(input.getServiceRate()) || "10G".equals(input.getServiceRate()))) { + || !("1G".equals(input.getServiceRate()) || "10G".equals(input.getServiceRate()) + || "100G".equals(input.getServiceRate()))) { LOG.error("Service rate {} not managed yet", input.getServiceRate()); } else { createLowOrderInterfaces(input, nodeInterfaces); @@ -352,6 +387,37 @@ public class OtnDeviceRendererServiceImpl implements OtnDeviceRendererService { input.getTribSlot())); } break; + case ("100G"): + LOG.info("Input service is 100G"); + // Take the first and last value in the list of OpucnTribSlot (assuming SH would provide + // min and max value only, size two) + OpucnTribSlotDef minOpucnTs = OpucnTribSlotDef.getDefaultInstance( + input.getOpucnTribSlots().get(0).getValue()); + OpucnTribSlotDef maxOpucnTs = OpucnTribSlotDef.getDefaultInstance( + input.getOpucnTribSlots().get(1).getValue()); + if (node.getClientTp() != null) { + createdEthInterfaces.add(openRoadmInterfaceFactory.createOpenRoadmEth100GInterface( + node.getNodeId(), node.getClientTp())); + // OPUCn trib information is optional when creating ODU4 ethernet (client) interface + createdOduInterfaces.add( + openRoadmInterfaceFactory.createOpenRoadmOtnOdu4LoInterface(node.getNodeId(), + node.getClientTp(), input.getServiceName(), PT_07, false, minOpucnTs, + maxOpucnTs)); + } + // Here payload-type is optional and is not used for interface creation (especially for network) + createdOduInterfaces.add( + openRoadmInterfaceFactory.createOpenRoadmOtnOdu4LoInterface(node.getNodeId(), + node.getNetworkTp(), input.getServiceName(), PT_07, true, minOpucnTs, + maxOpucnTs)); + // Here payload-type is optional and is not used for service creation + // This is needed if there is an intermediate node + if (node.getNetwork2Tp() != null) { + createdOduInterfaces.add( + openRoadmInterfaceFactory.createOpenRoadmOtnOdu4LoInterface(node.getNodeId(), + node.getNetwork2Tp(), input.getServiceName(), PT_07, true, minOpucnTs, + maxOpucnTs)); + } + break; default: LOG.error("service rate {} not managed yet", input.getServiceRate()); return; @@ -374,6 +440,36 @@ public class OtnDeviceRendererServiceImpl implements OtnDeviceRendererService { } } + private void createOduc4TtpInterface(OtnServicePathInput input, List nodeInterfaces, + CopyOnWriteArrayList otnNodesProvisioned) throws OpenRoadmInterfaceException { + if (input.getNodes() == null) { + return; + } + LOG.info("Creation of ODUC4 TTP interface in OTN service path {}", input); + for (int i = 0; i < input.getNodes().size(); i++) { + Nodes node = input.getNodes().get(i); + String supportingOtuInterface = node.getNetworkTp() + "-OTUC4"; + List createdOduc4Interfaces = new ArrayList<>(); + // Adding SAPI/DAPI information to the + Nodes tgtNode = null; + if (i + 1 == input.getNodes().size()) { + // For the end node, tgtNode becomes the first node in the list + tgtNode = input.getNodes().get(0); + } else { + tgtNode = input.getNodes().get(i + 1); + } + createdOduc4Interfaces.add(openRoadmInterfaceFactory.createOpenRoadmOtnOduc4Interface(node.getNodeId(), + node.getNetworkTp(), supportingOtuInterface, tgtNode.getNodeId(), tgtNode.getNetworkTp())); + + NodeInterfaceBuilder nodeInterfaceBuilder = new NodeInterfaceBuilder() + .withKey(new NodeInterfaceKey(node.getNodeId())) + .setNodeId(node.getNodeId()) + .setOduInterfaceId(createdOduc4Interfaces); // though this is odu, actually it has ODUC4 interfaces + nodeInterfaces.add(nodeInterfaceBuilder.build()); + otnNodesProvisioned.add(node); + } + } + private void createODU4TtpInterface(OtnServicePathInput input, List nodeInterfaces, CopyOnWriteArrayList otnNodesProvisioned) throws OpenRoadmInterfaceException { if (input.getNodes() == null) { diff --git a/renderer/src/main/resources/OSGI-INF/blueprint/renderer-blueprint.xml b/renderer/src/main/resources/OSGI-INF/blueprint/renderer-blueprint.xml index 2bae23d83..b93e7cf37 100644 --- a/renderer/src/main/resources/OSGI-INF/blueprint/renderer-blueprint.xml +++ b/renderer/src/main/resources/OSGI-INF/blueprint/renderer-blueprint.xml @@ -43,19 +43,26 @@ and is available at http://www.eclipse.org/legal/epl-v10.html - + + + + + - + + diff --git a/renderer/src/test/java/org/opendaylight/transportpce/renderer/provisiondevice/DeviceRendererServiceImplCreateOtsOmsTest.java b/renderer/src/test/java/org/opendaylight/transportpce/renderer/provisiondevice/DeviceRendererServiceImplCreateOtsOmsTest.java index 9c3c0c236..f236801bf 100644 --- a/renderer/src/test/java/org/opendaylight/transportpce/renderer/provisiondevice/DeviceRendererServiceImplCreateOtsOmsTest.java +++ b/renderer/src/test/java/org/opendaylight/transportpce/renderer/provisiondevice/DeviceRendererServiceImplCreateOtsOmsTest.java @@ -23,6 +23,7 @@ import org.opendaylight.transportpce.common.crossconnect.CrossConnect; import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl; import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl121; import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl221; +import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl710; import org.opendaylight.transportpce.common.device.DeviceTransactionManager; import org.opendaylight.transportpce.common.device.DeviceTransactionManagerImpl; import org.opendaylight.transportpce.common.mapping.MappingUtils; @@ -43,6 +44,7 @@ import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterf import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterface710; import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterfaceFactory; import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmOtnInterface221; +import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmOtnInterface710; import org.opendaylight.transportpce.renderer.utils.CreateOtsOmsDataUtils; import org.opendaylight.transportpce.renderer.utils.MountPointUtils; import org.opendaylight.transportpce.test.AbstractTest; @@ -75,6 +77,7 @@ public class DeviceRendererServiceImplCreateOtsOmsTest extends AbstractTest { private PortMappingVersion121 portMappingVersion121; private CrossConnectImpl121 crossConnectImpl121; private CrossConnectImpl221 crossConnectImpl221; + private CrossConnectImpl710 crossConnectImpl710; private void setMountPoint(MountPoint mountPoint) { MountPointService mountPointService = new MountPointServiceStub(mountPoint); @@ -102,14 +105,17 @@ public class DeviceRendererServiceImplCreateOtsOmsTest extends AbstractTest { OpenRoadmInterface121 openRoadmInterface121 = new OpenRoadmInterface121(portMapping,openRoadmInterfaces); OpenRoadmInterface221 openRoadmInterface221 = new OpenRoadmInterface221(portMapping,openRoadmInterfaces); OpenRoadmInterface710 openRoadmInterface710 = new OpenRoadmInterface710(portMapping, openRoadmInterfaces); - OpenRoadmOtnInterface221 openRoadmOTNInterface = new OpenRoadmOtnInterface221(portMapping, openRoadmInterfaces); + OpenRoadmOtnInterface221 openRoadmOTNInterface221 = new OpenRoadmOtnInterface221(portMapping, + openRoadmInterfaces); + OpenRoadmOtnInterface710 openRoadmOtnInterface710 = new OpenRoadmOtnInterface710(portMapping, + openRoadmInterfaces); this.openRoadmInterfaceFactory = new OpenRoadmInterfaceFactory(this.mappingUtils,openRoadmInterface121, - openRoadmInterface221, openRoadmInterface710, openRoadmOTNInterface); + openRoadmInterface221, openRoadmInterface710, openRoadmOTNInterface221, openRoadmOtnInterface710); this.crossConnectImpl121 = new CrossConnectImpl121(this.deviceTransactionManager); this.crossConnectImpl221 = new CrossConnectImpl221(this.deviceTransactionManager); this.crossConnect = new CrossConnectImpl(this.deviceTransactionManager, this.mappingUtils, - this.crossConnectImpl121, this.crossConnectImpl221); + this.crossConnectImpl121, this.crossConnectImpl221, this.crossConnectImpl710); this.crossConnect = Mockito.spy(this.crossConnect); this.deviceRendererService = new DeviceRendererServiceImpl(this.getDataBroker(), this.deviceTransactionManager, this.openRoadmInterfaceFactory, this.openRoadmInterfaces, 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 8517c7981..6efbbe22c 100644 --- a/renderer/src/test/java/org/opendaylight/transportpce/renderer/provisiondevice/RendererServiceOperationsImplDeleteTest.java +++ b/renderer/src/test/java/org/opendaylight/transportpce/renderer/provisiondevice/RendererServiceOperationsImplDeleteTest.java @@ -29,6 +29,7 @@ import org.opendaylight.transportpce.common.crossconnect.CrossConnect; import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl; import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl121; import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl221; +import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl710; import org.opendaylight.transportpce.common.device.DeviceTransactionManager; import org.opendaylight.transportpce.common.device.DeviceTransactionManagerImpl; import org.opendaylight.transportpce.common.mapping.MappingUtils; @@ -48,6 +49,7 @@ import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterf import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterface710; import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterfaceFactory; import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmOtnInterface221; +import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmOtnInterface710; import org.opendaylight.transportpce.renderer.stub.OlmServiceStub; import org.opendaylight.transportpce.renderer.utils.NotificationPublishServiceMock; import org.opendaylight.transportpce.renderer.utils.ServiceDeleteDataUtils; @@ -94,6 +96,7 @@ public class RendererServiceOperationsImplDeleteTest extends AbstractTest { private PortMappingVersion121 portMappingVersion121; private CrossConnectImpl121 crossConnectImpl121; private CrossConnectImpl221 crossConnectImpl221; + private CrossConnectImpl710 crossConnectImpl710; private OtnDeviceRendererService otnDeviceRendererService; private void setMountPoint(MountPoint mountPoint) { @@ -117,14 +120,18 @@ public class RendererServiceOperationsImplDeleteTest extends AbstractTest { this.crossConnectImpl121 = new CrossConnectImpl121(deviceTransactionManager); this.crossConnectImpl221 = new CrossConnectImpl221(deviceTransactionManager); this.crossConnect = new CrossConnectImpl(deviceTransactionManager, this.mappingUtils, this.crossConnectImpl121, - this.crossConnectImpl221); + this.crossConnectImpl221, this.crossConnectImpl710); this.crossConnect = Mockito.spy(crossConnect); OpenRoadmInterface121 openRoadmInterface121 = new OpenRoadmInterface121(portMapping,openRoadmInterfaces); OpenRoadmInterface221 openRoadmInterface221 = new OpenRoadmInterface221(portMapping,openRoadmInterfaces); OpenRoadmInterface710 openRoadmInterface710 = new OpenRoadmInterface710(portMapping,openRoadmInterfaces); - OpenRoadmOtnInterface221 openRoadmOTNInterface = new OpenRoadmOtnInterface221(portMapping, openRoadmInterfaces); + OpenRoadmOtnInterface221 openRoadmOTNInterface221 = new OpenRoadmOtnInterface221(portMapping, + openRoadmInterfaces); + OpenRoadmOtnInterface710 openRoadmOtnInterface710 = new OpenRoadmOtnInterface710(portMapping, + openRoadmInterfaces); OpenRoadmInterfaceFactory openRoadmInterfaceFactory = new OpenRoadmInterfaceFactory(this.mappingUtils, - openRoadmInterface121, openRoadmInterface221, openRoadmInterface710, openRoadmOTNInterface); + openRoadmInterface121, openRoadmInterface221, openRoadmInterface710, openRoadmOTNInterface221, + openRoadmOtnInterface710); this.deviceRenderer = new DeviceRendererServiceImpl(getDataBroker(), this.deviceTransactionManager, openRoadmInterfaceFactory, openRoadmInterfaces, crossConnect, diff --git a/renderer/src/test/java/org/opendaylight/transportpce/renderer/provisiondevice/RendererServiceOperationsImplTest.java b/renderer/src/test/java/org/opendaylight/transportpce/renderer/provisiondevice/RendererServiceOperationsImplTest.java index 25b112ccf..e5a9f50ff 100644 --- a/renderer/src/test/java/org/opendaylight/transportpce/renderer/provisiondevice/RendererServiceOperationsImplTest.java +++ b/renderer/src/test/java/org/opendaylight/transportpce/renderer/provisiondevice/RendererServiceOperationsImplTest.java @@ -24,6 +24,7 @@ import org.opendaylight.transportpce.common.crossconnect.CrossConnect; import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl; import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl121; import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl221; +import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl710; import org.opendaylight.transportpce.common.device.DeviceTransactionManager; import org.opendaylight.transportpce.common.device.DeviceTransactionManagerImpl; import org.opendaylight.transportpce.common.mapping.MappingUtils; @@ -44,6 +45,7 @@ import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterf import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterface710; import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterfaceFactory; import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmOtnInterface221; +import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmOtnInterface710; import org.opendaylight.transportpce.renderer.stub.OlmServiceStub; import org.opendaylight.transportpce.renderer.utils.MountPointUtils; import org.opendaylight.transportpce.renderer.utils.NotificationPublishServiceMock; @@ -88,6 +90,7 @@ public class RendererServiceOperationsImplTest extends AbstractTest { private PortMappingVersion121 portMappingVersion121; private CrossConnectImpl121 crossConnectImpl121; private CrossConnectImpl221 crossConnectImpl221; + private CrossConnectImpl710 crossConnectImpl710; private void setMountPoint(MountPoint mountPoint) { this.mountPointService = new MountPointServiceStub(mountPoint); @@ -110,13 +113,16 @@ public class RendererServiceOperationsImplTest extends AbstractTest { OpenRoadmInterface121 openRoadmInterface121 = new OpenRoadmInterface121(portMapping,openRoadmInterfaces); OpenRoadmInterface221 openRoadmInterface221 = new OpenRoadmInterface221(portMapping,openRoadmInterfaces); OpenRoadmInterface710 openRoadmInterface710 = new OpenRoadmInterface710(portMapping,openRoadmInterfaces); - OpenRoadmOtnInterface221 openRoadmOTNInterface = new OpenRoadmOtnInterface221(portMapping, openRoadmInterfaces); + OpenRoadmOtnInterface221 openRoadmOTNInterface221 = new OpenRoadmOtnInterface221(portMapping, + openRoadmInterfaces); + OpenRoadmOtnInterface710 openRoadmOtnInterface710 = new OpenRoadmOtnInterface710(portMapping, + openRoadmInterfaces); this.openRoadmInterfaceFactory = new OpenRoadmInterfaceFactory(this.mappingUtils,openRoadmInterface121, - openRoadmInterface221, openRoadmInterface710, openRoadmOTNInterface); + openRoadmInterface221, openRoadmInterface710, openRoadmOTNInterface221, openRoadmOtnInterface710); this.crossConnectImpl121 = new CrossConnectImpl121(deviceTransactionManager); this.crossConnectImpl221 = new CrossConnectImpl221(deviceTransactionManager); this.crossConnect = new CrossConnectImpl(deviceTransactionManager, this.mappingUtils, this.crossConnectImpl121, - this.crossConnectImpl221); + this.crossConnectImpl221, this.crossConnectImpl710); } @Before -- 2.36.6