From d50b37922f66766887017667347ee3fa23d26659 Mon Sep 17 00:00:00 2001 From: shweta Date: Wed, 12 Dec 2018 17:41:28 -0500 Subject: [PATCH] Update Renderer Module - introduce support for ordm 2.2 - update OLM unit tests to support render and common module changes - update portmapping to trigger roadm-to-roadm link discovery with lldp Change-Id: I955b00e903a1124a24668d27955bbc02cd5d651a Signed-off-by: shweta Co-authored-by: Christophe Betoule Co-authored-by: Gilles Thouenon --- .../transportpce/common/NetworkUtils.java | 2 + .../transportpce/common/StringConstants.java | 11 +- .../common/mapping/MappingUtilsImpl.java | 4 +- .../common/mapping/PortMappingVersion121.java | 26 +- .../common/mapping/PortMappingVersion22.java | 18 +- .../network/NetworkTransactionService.java | 1 + .../OpenRoadmInterfacesImpl.java | 7 - .../OSGI-INF/blueprint/common-blueprint.xml | 67 +++- .../org-openroadm-amplifier@2017-12-15.yang | 136 +++++++ .../yang/org-openroadm-degree@2017-12-15.yang | 112 ++++++ ...enroadm-external-pluggable@2017-12-15.yang | 110 ++++++ .../yang/org-openroadm-link@2017-12-15.yang | 200 ++++++++++ ...adm-network-topology-types@2017-12-15.yang | 139 +++++++ ...openroadm-network-topology@2017-12-15.yang | 307 +++++++++++++++ ...rg-openroadm-network-types@2017-12-15.yang | 249 ++++++++++++ .../org-openroadm-network@2017-12-15.yang | 168 ++++++++ ...roadm-otn-network-topology@2017-12-15.yang | 185 +++++++++ .../yang/org-openroadm-roadm@2017-12-15.yang | 77 ++++ .../yang/org-openroadm-srg@2017-12-15.yang | 94 +++++ .../org-openroadm-xponder@2017-12-15.yang | 156 ++++++++ .../renderer/ModelMappingUtils.java | 11 +- .../NetworkModelWavelengthServiceImpl.java | 109 +++--- .../OpenRoadmInterface121.java | 324 ++++++++++++++++ .../OpenRoadmInterface22.java | 362 ++++++++++++++++++ .../OpenRoadmInterfaceFactory.java | 341 ++++------------- .../DeviceRendererServiceImpl.java | 38 +- .../RendererServiceOperations.java | 6 + .../RendererServiceOperationsImpl.java | 85 +++- .../tasks/OlmPowerSetupRollbackTask.java | 2 +- .../OSGI-INF/blueprint/renderer-blueprint.xml | 25 +- ...NetworkModelWaveLengthServiceFreeTest.java | 56 +-- .../NetworkModelWaveLengthServiceUseTest.java | 51 +-- ...ceRendererServiceImplCreateOtsOmsTest.java | 31 +- .../DeviceRendererServiceImplDeleteTest.java | 59 +-- ...DeviceRendererServiceImplRollbackTest.java | 50 ++- .../DeviceRendererServiceImplSetupTest.java | 75 ++-- ...ndererServiceOperationsImplDeleteTest.java | 60 +-- .../RendererServiceOperationsImplTest.java | 111 +++--- .../utils/WaveLengthServiceUtils.java | 14 +- .../stub/StubRendererServiceOperations.java | 14 + 40 files changed, 3282 insertions(+), 611 deletions(-) create mode 100644 ordmodels/network/src/main/yang/org-openroadm-amplifier@2017-12-15.yang create mode 100644 ordmodels/network/src/main/yang/org-openroadm-degree@2017-12-15.yang create mode 100644 ordmodels/network/src/main/yang/org-openroadm-external-pluggable@2017-12-15.yang create mode 100644 ordmodels/network/src/main/yang/org-openroadm-link@2017-12-15.yang create mode 100644 ordmodels/network/src/main/yang/org-openroadm-network-topology-types@2017-12-15.yang create mode 100644 ordmodels/network/src/main/yang/org-openroadm-network-topology@2017-12-15.yang create mode 100644 ordmodels/network/src/main/yang/org-openroadm-network-types@2017-12-15.yang create mode 100644 ordmodels/network/src/main/yang/org-openroadm-network@2017-12-15.yang create mode 100644 ordmodels/network/src/main/yang/org-openroadm-otn-network-topology@2017-12-15.yang create mode 100644 ordmodels/network/src/main/yang/org-openroadm-roadm@2017-12-15.yang create mode 100644 ordmodels/network/src/main/yang/org-openroadm-srg@2017-12-15.yang create mode 100644 ordmodels/network/src/main/yang/org-openroadm-xponder@2017-12-15.yang create mode 100644 renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterface121.java create mode 100644 renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterface22.java diff --git a/common/src/main/java/org/opendaylight/transportpce/common/NetworkUtils.java b/common/src/main/java/org/opendaylight/transportpce/common/NetworkUtils.java index ef0751cdc..08e3f705b 100644 --- a/common/src/main/java/org/opendaylight/transportpce/common/NetworkUtils.java +++ b/common/src/main/java/org/opendaylight/transportpce/common/NetworkUtils.java @@ -13,7 +13,9 @@ public final class NetworkUtils { } public static final String CLLI_NETWORK_ID = "clli-network"; + public static final String UNDERLAY_NETWORK_ID = "openroadm-network"; + public static final String OVERLAY_NETWORK_ID = "openroadm-topology"; public enum Operation { diff --git a/common/src/main/java/org/opendaylight/transportpce/common/StringConstants.java b/common/src/main/java/org/opendaylight/transportpce/common/StringConstants.java index 1fc3731eb..5e618ef1b 100644 --- a/common/src/main/java/org/opendaylight/transportpce/common/StringConstants.java +++ b/common/src/main/java/org/opendaylight/transportpce/common/StringConstants.java @@ -11,12 +11,19 @@ package org.opendaylight.transportpce.common; public final class StringConstants { public static final String OPENROADM_DEVICE_MODEL_NAME = "org-openroadm-device"; + public static final String DEFAULT_NETCONF_NODEID = "controller-config"; + public static final String OPENROADM_DEVICE_VERSION_2_2 = "(http://org/openroadm/device?revision=2017-12-15)org-openroadm-device"; + public static final String OPENROADM_DEVICE_VERSION_1_2_1 = "(http://org/openroadm/device?revision=2017-02-06)org-openroadm-device"; - public static final String NETWORK_TOKEN = "XPDR1-NETWORK"; + + public static final String NETWORK_TOKEN = "NETWORK"; + public static final String TTP_TOKEN = "TTP"; - public static final String CLIENT_TOKEN = "XPDR1-CLIENT"; + + public static final String CLIENT_TOKEN = "CLIENT"; + public static final String PP_TOKEN = "PP"; private StringConstants() { diff --git a/common/src/main/java/org/opendaylight/transportpce/common/mapping/MappingUtilsImpl.java b/common/src/main/java/org/opendaylight/transportpce/common/mapping/MappingUtilsImpl.java index 3e2d055f3..b87971a1f 100644 --- a/common/src/main/java/org/opendaylight/transportpce/common/mapping/MappingUtilsImpl.java +++ b/common/src/main/java/org/opendaylight/transportpce/common/mapping/MappingUtilsImpl.java @@ -52,8 +52,8 @@ public class MappingUtilsImpl implements MappingUtils { return StringConstants.OPENROADM_DEVICE_VERSION_1_2_1; } } else { - LOG.warn("Could not find mapping for nodeId {}", - nodeId); + LOG.warn("Could not find mapping for nodeId {}", nodeId); + return StringConstants.OPENROADM_DEVICE_VERSION_1_2_1; } } catch (InterruptedException | ExecutionException ex) { LOG.error("Unable to read mapping for nodeId {}",nodeId, ex); 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 32cd7b3ed..9a0c9b49c 100644 --- a/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion121.java +++ b/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion121.java @@ -25,7 +25,6 @@ import org.opendaylight.transportpce.common.Timeouts; import org.opendaylight.transportpce.common.device.DeviceTransactionManager; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces; -import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl; import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev170228.Network; import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev170228.NetworkBuilder; import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev170228.network.Nodes; @@ -330,7 +329,7 @@ public class PortMappingVersion121 { .setSupportingCircuitPackName(circuitPackName).setSupportingPort(port.getPortName()); // Get OMS and OTS interface provisioned on the TTP's - if (logicalConnectionPoint.contains(OpenRoadmInterfacesImpl.TTP_TOKEN) && (port.getInterfaces() != null)) { + if (logicalConnectionPoint.contains(StringConstants.TTP_TOKEN) && (port.getInterfaces() != null)) { for (Interfaces interfaces : port.getInterfaces()) { try { Optional openRoadmInterface = this.openRoadmInterfaces.getInterface(nodeId, @@ -388,13 +387,20 @@ public class PortMappingVersion121 { private Map getEthInterfaceList(String nodeId) { LOG.info("It is calling get ethernet interface"); Map cpToInterfaceMap = new HashMap<>(); - InstanceIdentifier lldpIID = InstanceIdentifier.create(OrgOpenroadmDevice.class) - .child(Protocols.class).augmentation(Protocols1.class).child(Lldp.class); - Optional lldpObject = this.deviceTransactionManager.getDataFromDevice(nodeId, - LogicalDatastoreType.OPERATIONAL, lldpIID, + InstanceIdentifier protocolIID = InstanceIdentifier.create(OrgOpenroadmDevice.class) + .child(Protocols.class); + Optional protocolOptional = this.deviceTransactionManager.getDataFromDevice(nodeId, + LogicalDatastoreType.OPERATIONAL, protocolIID, Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT); - if (lldpObject.isPresent() && (lldpObject.get().getPortConfig() != null)) { - for (PortConfig portConfig : lldpObject.get().getPortConfig()) { + Lldp lldp = null; + if (protocolOptional.isPresent()) { + lldp = protocolOptional.get().augmentation(Protocols1.class).getLldp(); + } else { + LOG.warn("Couldnt find protocol operational data for Node : {}", nodeId); + } + + if (lldp != null && lldp.getPortConfig() != null) { + for (PortConfig portConfig : lldp.getPortConfig()) { if (portConfig.getAdminStatus().equals(PortConfig.AdminStatus.Txandrx)) { InstanceIdentifier interfaceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class) .child(Interface.class, new InterfaceKey(portConfig.getIfName())); @@ -526,11 +532,11 @@ public class PortMappingVersion121 { for (Ports port : cp.getPorts()) { if (Port.PortQual.XpdrNetwork.equals(port.getPortQual())) { portMapList.add(createMappingObject(nodeId, port, circuitPackName, - StringConstants.NETWORK_TOKEN + line)); + "XPDR1-" + StringConstants.NETWORK_TOKEN + line)); line++; } else if (Port.PortQual.XpdrClient.equals(port.getPortQual())) { portMapList.add(createMappingObject(nodeId, port, circuitPackName, - StringConstants.CLIENT_TOKEN + client)); + "XPDR1-" + StringConstants.CLIENT_TOKEN + client)); client++; } else { LOG.warn("Not supported type of port! Port type: {}", port.getPortQual()); diff --git a/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion22.java b/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion22.java index f22d2db11..aa61ace73 100644 --- a/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion22.java +++ b/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion22.java @@ -1,13 +1,13 @@ /* - * Copyright © 2017 AT&T and others. All rights reserved. + * Copyright © 2017 Orange, Inc. 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.mapping; import com.google.common.util.concurrent.CheckedFuture; - import java.util.ArrayList; import java.util.Comparator; import java.util.HashMap; @@ -26,7 +26,6 @@ import org.opendaylight.transportpce.common.Timeouts; import org.opendaylight.transportpce.common.device.DeviceTransactionManager; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces; -import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl; import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev170228.Network; import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev170228.NetworkBuilder; import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev170228.network.Nodes; @@ -56,6 +55,7 @@ import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev171215.org.open import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev171215.org.openroadm.device.container.org.openroadm.device.SharedRiskGroup; import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev171215.org.openroadm.device.container.org.openroadm.device.SharedRiskGroupKey; import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev171215.port.Interfaces; + 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; @@ -184,7 +184,7 @@ public class PortMappingVersion22 { int line = 1; // Variable to keep track of number of client ports int client = 1; - if (!deviceObject.isPresent() || (deviceObject.get().getCircuitPacks() == null)) { + if (!deviceObject.isPresent() || deviceObject.get().getCircuitPacks() == null) { LOG.warn("Circuit Packs are not present for {}", nodeId); return false; // TODO return false or continue? } @@ -201,11 +201,11 @@ public class PortMappingVersion22 { for (Ports port : cp.getPorts()) { if (Port.PortQual.XpdrNetwork.equals(port.getPortQual())) { portMapList.add(createMappingObject(nodeId, port, circuitPackName, - StringConstants.NETWORK_TOKEN + line)); + "XPDR1-" + StringConstants.NETWORK_TOKEN + line)); line++; } else if (Port.PortQual.XpdrClient.equals(port.getPortQual())) { portMapList.add(createMappingObject(nodeId, port, circuitPackName, - StringConstants.CLIENT_TOKEN + client)); + "XPDR1-" + StringConstants.CLIENT_TOKEN + client)); client++; } else { LOG.warn("Not supported type of port! Port type: {}", port.getPortQual()); @@ -471,12 +471,12 @@ public class PortMappingVersion22 { .setSupportingCircuitPackName(circuitPackName).setSupportingPort(port.getPortName()); // Get OMS and OTS interface provisioned on the TTP's - if (logicalConnectionPoint.contains(OpenRoadmInterfacesImpl.TTP_TOKEN) && (port.getInterfaces() != null)) { + if (logicalConnectionPoint.contains(StringConstants.TTP_TOKEN) && (port.getInterfaces() != null)) { for (Interfaces interfaces : port.getInterfaces()) { try { Optional - openRoadmInterface = this.openRoadmInterfaces - .getInterface(nodeId, interfaces.getInterfaceName()); + openRoadmInterface = this.openRoadmInterfaces.getInterface(nodeId, + interfaces.getInterfaceName()); if (openRoadmInterface.isPresent()) { Class interfaceType = (Class) openRoadmInterface.get().getType(); diff --git a/common/src/main/java/org/opendaylight/transportpce/common/network/NetworkTransactionService.java b/common/src/main/java/org/opendaylight/transportpce/common/network/NetworkTransactionService.java index 4313df181..23dc9b542 100644 --- a/common/src/main/java/org/opendaylight/transportpce/common/network/NetworkTransactionService.java +++ b/common/src/main/java/org/opendaylight/transportpce/common/network/NetworkTransactionService.java @@ -9,6 +9,7 @@ package org.opendaylight.transportpce.common.network; import com.google.common.base.Optional; + import com.google.common.util.concurrent.CheckedFuture; import com.google.common.util.concurrent.ListenableFuture; diff --git a/common/src/main/java/org/opendaylight/transportpce/common/openroadminterfaces/OpenRoadmInterfacesImpl.java b/common/src/main/java/org/opendaylight/transportpce/common/openroadminterfaces/OpenRoadmInterfacesImpl.java index eba991d2f..33b33f373 100644 --- a/common/src/main/java/org/opendaylight/transportpce/common/openroadminterfaces/OpenRoadmInterfacesImpl.java +++ b/common/src/main/java/org/opendaylight/transportpce/common/openroadminterfaces/OpenRoadmInterfacesImpl.java @@ -28,13 +28,6 @@ public class OpenRoadmInterfacesImpl implements OpenRoadmInterfaces { OpenRoadmInterfacesImpl22 openRoadmInterfacesImpl22; MappingUtils mappingUtils; - // TODO move somewhere to constants - public static final String NETWORK_TOKEN = "NETWORK"; - public static final String TTP_TOKEN = "TTP"; - public static final String CLIENT_TOKEN = "CLIENT"; - public static final String PP_TOKEN = "PP"; - - public OpenRoadmInterfacesImpl(DeviceTransactionManager deviceTransactionManager,MappingUtils mappingUtils, OpenRoadmInterfacesImpl121 openRoadmInterfacesImpl121,OpenRoadmInterfacesImpl22 openRoadmInterfacesImpl22) { this.deviceTransactionManager = deviceTransactionManager; 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 a65c62477..c28990fae 100644 --- a/common/src/main/resources/OSGI-INF/blueprint/common-blueprint.xml +++ b/common/src/main/resources/OSGI-INF/blueprint/common-blueprint.xml @@ -8,8 +8,8 @@ terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html --> + xmlns:odl="http://opendaylight.org/xmlns/blueprint/v1.0.0" + odl:use-default-for-reference-types="true"> @@ -20,25 +20,57 @@ and is available at http://www.eclipse.org/legal/epl-v10.html + + + + + + + + + + + + + + + - + - + - + + + + + + + - + + + + + + + + + + + + @@ -49,24 +81,21 @@ and is available at http://www.eclipse.org/legal/epl-v10.html - - - - - - - - - + + - + + - - + + + + + - + \ No newline at end of file diff --git a/ordmodels/network/src/main/yang/org-openroadm-amplifier@2017-12-15.yang b/ordmodels/network/src/main/yang/org-openroadm-amplifier@2017-12-15.yang new file mode 100644 index 000000000..d6643a2ca --- /dev/null +++ b/ordmodels/network/src/main/yang/org-openroadm-amplifier@2017-12-15.yang @@ -0,0 +1,136 @@ +module org-openroadm-amplifier { + namespace "http://org/openroadm/amplifier"; + prefix amp; + + import org-openroadm-common-types { + prefix org-openroadm-common-types; + revision-date 2017-12-15; + } + + organization + "Open ROADM MSA"; + contact + "OpenROADM.org."; + description + "YANG definitions for an amplifier in Network Model + + + Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2017, + AT&T Intellectual Property. All other rights reserved. + + Redistribution and use in source and binary forms, with or without modification, + are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation and/or + other materials provided with the distribution. + * Neither the Members of the Open ROADM MSA Agreement nor the names of its + contributors may be used to endorse or promote products derived from this software + without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS'' + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE."; + + revision 2017-12-15 { + description + "Version 2.2"; + } + revision 2017-09-29 { + description + "Version 2.1"; + } + revision 2017-07-28 { + description + "Version 2.0.1 - added revision-date to imports"; + } + revision 2017-06-17 { + description + "Version 2.0"; + } + + grouping amplifier-node-attributes { + description + "Defines the group of amplifier attributes"; + leaf amp-type { + type org-openroadm-common-types:amplifier-types; + config true; + mandatory true; + description + "Amplifier type"; + } + leaf amp-gain-range { + type org-openroadm-common-types:amplifier-gain-range; + config true; + description + "Amplifier gain-range (gain-range 1 to 4 for switched gain amplifiers) + gain-range-1 for standard amplifiers"; + } + leaf ingress-span-loss-aging-margin { + type org-openroadm-common-types:ratio-dB; + config true; + description + "Span-loss margin used to set optical amplifier gain and output-voa + extracted from corresponding device OTS interface container, optional + since it concerns only line facing amp"; + } + leaf gain { + type org-openroadm-common-types:ratio-dB; + config true; + mandatory true; + description + "Overall Amplifier Signal gain, excluding ASE, including VOA attenuation + retrieved from operational value (PM)"; + } + leaf initially-planned-gain { + type org-openroadm-common-types:ratio-dB; + config true; + description + "Overall Amplifier Signal gain, excluding ASE, including VOA attenuation: + value coming from planning tool initial design"; + } + leaf tilt { + type org-openroadm-common-types:ratio-dB; + config true; + description + "Tilt of smart EDFA retrieved from operational value (PM)"; + } + leaf initially-planned-tilt { + type org-openroadm-common-types:ratio-dB; + config true; + description + "Tilt of smart EDFA: + value coming from planning tool initial design"; + } + leaf out-voa-att { + type org-openroadm-common-types:ratio-dB; + config true; + description + "output VOA attenuation"; + } + leaf initially-planned-out-voa-att { + type org-openroadm-common-types:ratio-dB; + config true; + description + "output VOA attenuation: value coming from planning tool initial design. + As in R2.0, output VOA can not be configured by controller, this parameter may be used by the controller + to check that value set by amplifiers is in the range of calculated value and take relevant decision if not"; + } + leaf eol-max-load-pIn { + type org-openroadm-common-types:power-dBm; + config true; + description + "End Of Life Total input power at maximum load used for amplifier and VOA setting + extracted from corresponding device OTS interface container"; + } + } +} diff --git a/ordmodels/network/src/main/yang/org-openroadm-degree@2017-12-15.yang b/ordmodels/network/src/main/yang/org-openroadm-degree@2017-12-15.yang new file mode 100644 index 000000000..8bb5880fd --- /dev/null +++ b/ordmodels/network/src/main/yang/org-openroadm-degree@2017-12-15.yang @@ -0,0 +1,112 @@ +module org-openroadm-degree { + namespace "http://org/openroadm/degree"; + prefix dgr; + + import org-openroadm-common-types { + prefix org-openroadm-common-types; + revision-date 2017-12-15; + } + import org-openroadm-network-types { + prefix org-openroadm-network-types; + revision-date 2017-12-15; + } + + organization + "Open ROADM MSA"; + contact + "OpenROADM.org."; + description + "YANG definitions for a Degree in Network Model + + + Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016, + AT&T Intellectual Property. All other rights reserved. + + Redistribution and use in source and binary forms, with or without modification, + are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation and/or + other materials provided with the distribution. + * Neither the Members of the Open ROADM MSA Agreement nor the names of its + contributors may be used to endorse or promote products derived from this software + without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS'' + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE."; + + revision 2017-12-15 { + description + "Version 2.2"; + } + revision 2017-09-29 { + description + "Version 2.1"; + } + revision 2017-07-28 { + description + "Version 2.0.1 - added revision-date to imports"; + } + revision 2017-06-26 { + description + "Version 2.0"; + } + revision 2016-10-14 { + description + "Version 1.2"; + } + + grouping degree-used-wavelengths { + description + "This list is created to accommodate fixed grid (1.2.1) as well as flex grid (2.0 above). In case of fixed grid + index number will refer to one of the 96 WL defined in the wavelength map file. In case of flex grid this + will hold list of used spectrums"; + list used-wavelengths { + key "index"; + uses org-openroadm-network-types:wavelengths; + } + } + + grouping degree-node-attributes { + description + "Defines the group of degree attributes"; + leaf degree-number { + type uint16; + } + leaf max-wavelengths { + type uint32; + description + "maximum # of wavelengths"; + } + list available-wavelengths { + key "index"; + description + "This list is created to accommodate fixed grid (1.2.1) as well as flex grid (2.0 above). In case of fixed grid + index number will refer to one of the 96 WL defined in the wavelength map file. In case of flex grid this + will hold list of available spectrums"; + uses org-openroadm-network-types:wavelengths; + } + leaf ingress-span-loss-aging-margin { + type org-openroadm-common-types:ratio-dB; + config true; + description + "Span-loss margin extracted from corresponding device OTS interface container, optional"; + } + leaf eol-max-load-pIn { + type org-openroadm-common-types:power-dBm; + config true; + description + "End Of Life Total input power at maximum load extracted from corresponding device OTS interface container"; + } + } +} diff --git a/ordmodels/network/src/main/yang/org-openroadm-external-pluggable@2017-12-15.yang b/ordmodels/network/src/main/yang/org-openroadm-external-pluggable@2017-12-15.yang new file mode 100644 index 000000000..4cf91392a --- /dev/null +++ b/ordmodels/network/src/main/yang/org-openroadm-external-pluggable@2017-12-15.yang @@ -0,0 +1,110 @@ +module org-openroadm-external-pluggable { + namespace "http://org/openroadm/external/pluggable"; + prefix plg; + + import org-openroadm-common-types { + prefix org-openroadm-common-types; + revision-date 2017-12-15; + } + + organization + "OPEN ROADM MSA"; + contact + "OpenROADM.org."; + description + "YANG definitions for External Pluggable + + + Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016, + AT&T Intellectual Property. All other rights reserved. + + Redistribution and use in source and binary forms, with or without modification, + are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation and/or + other materials provided with the distribution. + * Neither the Members of the Open ROADM MSA Agreement nor the names of its + contributors may be used to endorse or promote products derived from this software + without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS'' + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE."; + + revision 2017-12-15 { + description + "Version 2.2"; + } + revision 2017-09-29 { + description + "Version 2.1"; + } + revision 2017-07-28 { + description + "Version 2.0.1 - added revision-date to imports"; + } + revision 2017-06-26 { + description + "Version 2.0"; + } + revision 2016-10-14 { + description + "Version 1.2"; + } + + grouping pluggable-node-attributes { + leaf pluggable-id { + type string; + description + "Network-wide unique identifier for a pluggable"; + } + leaf customer-code { + type string; + description + "Owner of the pluggable"; + } + container tail { + leaf client-equipment { + type string; + } + leaf client-equipment-id { + type string; + } + leaf clfi { + type string; + } + } + } + + grouping pluggable-tp-attributes { + leaf rate { + type identityref { + base org-openroadm-common-types:och-rate-identity; + } + description + "rate"; + } + leaf modulation-format { + type org-openroadm-common-types:modulation-format; + } + leaf optic { + type org-openroadm-common-types:optic-types; + } + leaf state { + type org-openroadm-common-types:state; + description + "A xponder can be in one of the following + states"; + } + } +} diff --git a/ordmodels/network/src/main/yang/org-openroadm-link@2017-12-15.yang b/ordmodels/network/src/main/yang/org-openroadm-link@2017-12-15.yang new file mode 100644 index 000000000..4fad13e44 --- /dev/null +++ b/ordmodels/network/src/main/yang/org-openroadm-link@2017-12-15.yang @@ -0,0 +1,200 @@ +module org-openroadm-link { + namespace "http://org/openroadm/link"; + prefix link; + + import org-openroadm-common-types { + prefix org-openroadm-common-types; + revision-date 2017-12-15; + } + import org-openroadm-amplifier { + prefix org-openroadm-amplifier; + revision-date 2017-12-15; + } + + organization + "Open ROADM MSA"; + contact + "OpenROADM.org."; + description + "YANG definitions for an amplifier in Network Model + + + Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2017, + AT&T Intellectual Property. All other rights reserved. + + Redistribution and use in source and binary forms, with or without modification, + are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation and/or + other materials provided with the distribution. + * Neither the Members of the Open ROADM MSA Agreement nor the names of its + contributors may be used to endorse or promote products derived from this software + without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS'' + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE."; + + revision 2017-12-15 { + description + "Version 2.2"; + } + revision 2017-09-29 { + description + "Version 2.1"; + } + revision 2017-07-28 { + description + "Version 2.0.1 - added revision-date to imports"; + } + revision 2017-06-17 { + description + "Version 2.0"; + } + + grouping OMS-attributes { + leaf TE-metric { + type uint32; + } + } + + grouping span-attributes { + leaf clfi { + type string; + } + leaf auto-spanloss { + type boolean; + default "true"; + description + "Flag to enable/disable automatic spanloss measurement"; + } + leaf spanloss-base { + type org-openroadm-common-types:ratio-dB; + description + "Baseline ROADM span loss measured and accepted during + degree turn-up. May be re-set to current value after a fiber repair or change."; + } + leaf spanloss-current { + type org-openroadm-common-types:ratio-dB; + description + "Current ROADM span loss measured and accepted during + degree turn-up. Updated periodically if auto-spanloss is enabled."; + } + leaf engineered-spanloss { + type org-openroadm-common-types:ratio-dB; + description + "ROADM span loss provided by an external system"; + } + list link-concatenation { + key "SRLG-Id"; + leaf SRLG-Id { + type uint32; + description + "unique identifier for SRLG"; + } + leaf fiber-type { + type enumeration { + enum "smf" { + value 0; + description + "Single Mode Fiber"; + } + enum "eleaf" { + value 1; + description + "ELEAF"; + } + enum "oleaf" { + value 2; + description + "OLEAF"; + } + enum "dsf" { + value 3; + description + "DSF"; + } + enum "truewave" { + value 4; + description + "TRUEWAVE Reduced Slope"; + } + enum "truewavec" { + value 5; + description + "TRUEWAVE Classic"; + } + enum "nz-dsf" { + value 6; + description + "NZ-DSF"; + } + enum "ull" { + value 7; + description + "Ultra Low Loss (ULL)"; + } + } + } + leaf SRLG-length { + type uint32; + description + "fiber length in meters"; + } + leaf pmd { + type org-openroadm-common-types:fiber-pmd; + description + "Total PMD"; + } + } + } + + grouping amplified-link-attributes { + list amplified-link { + key "section-elt-number"; + description + "defines the spans and the amplifier blocks of the amplified lines"; + leaf section-elt-number { + type uint16; + description + "Id of the section element (whether it's a Span or an Amp)"; + } + container section-element { + choice section-element { + case ila { + container ila { + uses org-openroadm-amplifier:amplifier-node-attributes; + leaf node-id { + type org-openroadm-common-types:node-id-type; + mandatory true; + description + "Node id corresponding to the amplifier "; + } + leaf administrative-state { + type org-openroadm-common-types:state; + } + } + } + case span { + container span { + uses link:span-attributes; + leaf administrative-state { + type org-openroadm-common-types:state; + } + } + } + } + } + } + } +} diff --git a/ordmodels/network/src/main/yang/org-openroadm-network-topology-types@2017-12-15.yang b/ordmodels/network/src/main/yang/org-openroadm-network-topology-types@2017-12-15.yang new file mode 100644 index 000000000..7d50e5fda --- /dev/null +++ b/ordmodels/network/src/main/yang/org-openroadm-network-topology-types@2017-12-15.yang @@ -0,0 +1,139 @@ +module org-openroadm-network-topology-types { + namespace "http://org/openroadm/network/topology/types"; + prefix org-openroadm-network-topology-types; + + import ietf-network { + prefix nd; + revision-date 2015-06-08; + } + import ietf-network-topology { + prefix nwt; + revision-date 2015-06-08; + } + import org-openroadm-switching-pool-types { + prefix org-openroadm-switching-pool-types; + revision-date 2017-12-15; + } + + organization + "OPEN ROADM MSA"; + contact + "www.OpenROADM.org."; + description + "Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016, + AT&T Intellectual Property. All other rights reserved. + + Redistribution and use in source and binary forms, with or without modification, + are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation and/or + other materials provided with the distribution. + * Neither the Members of the Open ROADM MSA Agreement nor the names of its + contributors may be used to endorse or promote products derived from this software + without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS'' + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE."; + + revision 2017-12-15 { + description + "Version 2.2"; + } + + grouping xpdr-tp-bandwidth-sharing { + list tp-bandwidth-sharing { + key "tp-sharing-id"; + leaf tp-sharing-id { + type uint16; + } + leaf-list tp-list { + type nwt:tp-id; + } + leaf shared-bandwidth { + type uint16; + units "Gbps"; + } + } + } + + grouping xpdr-odu-switching-pools { + list odu-switching-pools { + key "switching-pool-number"; + leaf switching-pool-number { + type uint16; + description + "Unique identifier for this odu-switching-pool"; + } + leaf switching-pool-type { + type org-openroadm-switching-pool-types:switching-pool-types; + } + list non-blocking-list { + key "nbl-number"; + description + "List of ports in a non-blocking switch element"; + leaf nbl-number { + type uint16; + description + "Identifier for this non-blocking-list. Unique within odu-switching-pool"; + } + leaf interconnect-bandwidth-unit { + type uint32; + description + "Switch fabric interconnect bandwidth unit rate in bits per second. + Represents granularity of switch fabric"; + } + leaf capable-interconnect-bandwidth { + type uint32; + description + "Total interconnect bandwidth for a non-blocking element expressed as + number of inter-connect-bandwidth units"; + } + leaf available-interconnect-bandwidth { + type uint32; + description + "Total interconnect bandwidth available for a non-blocking element can use as + number of inter-connect-bandwidth units"; + } + leaf-list tp-list { + type nwt:tp-id; + description + "Termination point. Unique within device"; + } + } + } + } + + grouping xpdr-otn-tail-attributes { + leaf tp-id { + type nwt:tp-id; + } + leaf network-ref { + type leafref { + path "/nd:network/nd:network-id"; + } + description + "Used to reference a network, for example an underlay + network."; + } + leaf node-ref { + type leafref { + path "/nd:network[nd:network-id=current()/../network-ref]/nd:node/nd:node-id"; + } + description + "Used to reference a node. + Nodes are identified relative to the network they are + contained in."; + } + } +} diff --git a/ordmodels/network/src/main/yang/org-openroadm-network-topology@2017-12-15.yang b/ordmodels/network/src/main/yang/org-openroadm-network-topology@2017-12-15.yang new file mode 100644 index 000000000..4b015b6c1 --- /dev/null +++ b/ordmodels/network/src/main/yang/org-openroadm-network-topology@2017-12-15.yang @@ -0,0 +1,307 @@ +module org-openroadm-network-topology { + namespace "http://org/openroadm/network/topology"; + prefix topo; + + import ietf-network { + prefix nd; + revision-date 2015-06-08; + } + import ietf-network-topology { + prefix nwt; + revision-date 2015-06-08; + } + import org-openroadm-network-types { + prefix org-openroadm-network-types; + revision-date 2017-12-15; + } + import org-openroadm-srg { + prefix srg; + revision-date 2017-12-15; + } + import org-openroadm-degree { + prefix dgr; + revision-date 2017-12-15; + } + import org-openroadm-xponder { + prefix xpdr; + revision-date 2017-12-15; + } + import org-openroadm-external-pluggable { + prefix plg; + revision-date 2017-12-15; + } + import org-openroadm-link { + prefix link; + revision-date 2017-12-15; + } + import org-openroadm-common-types { + prefix ct; + revision-date 2017-12-15; + } + + organization + "OPEN ROADM MSA"; + contact + "OpenROADM.org."; + description + "YANG definitions for network view of a ROADM + + Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016, + AT&T Intellectual Property. All other rights reserved. + + Redistribution and use in source and binary forms, with or without modification, + are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation and/or + other materials provided with the distribution. + * Neither the Members of the Open ROADM MSA Agreement nor the names of its + contributors may be used to endorse or promote products derived from this software + without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS'' + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE."; + + revision 2017-12-15 { + description + "Version 2.2"; + } + revision 2017-09-29 { + description + "Version 2.1"; + } + revision 2017-07-28 { + description + "Version 2.0.1 - added revision-date to imports"; + } + revision 2017-06-26 { + description + "Version 2.0"; + } + + augment "/nd:network/nd:network-types" { + description + "Introduce new network type for the Open ROADM optical + ` network topology"; + container openroadm-topology { + presence "indicates optical network topology for Open ROADMs"; + } + } + augment "/nd:network/nd:node" { + when "../nd:network-types/openroadm-topology"; + description + "This augmentations adds the ROADM Node type to the generic node + definition and defines node-sepcific attributes for each node type + in the ROADM Topology."; + leaf node-type { + type org-openroadm-network-types:openroadm-node-type; + must + "(../node-type = 'DEGREE' or ../node-type = 'SRG' or ../node-type = 'TPDR' or ../node-type = 'SWITCH' or + ../node-type = 'REGEN' or ../node-type = 'REGEN-UNI' or ../node-type = 'EXT-PLUGGABLE' or + ../node-type = 'MUXPDR')" { + error-message "Invalid node type for openroadm-topology"; + } + description + "The type of a node in the ROADM topology. Valid node types are 'SRG', 'DEGREE', + 'TPDR', 'SWITCH', 'REGEN', 'REGEN-UNI', 'EXT-PLUGGABLE' and 'MUXPDR'"; + } + container srg-attributes { + when "../node-type = 'SRG'"; + description + "Topology-related attributes for SRG nodes"; + uses srg:srg-node-attributes; + } + container degree-attributes { + when "../node-type = 'DEGREE'"; + description + "Topology-related attributes for degree nodes"; + uses dgr:degree-node-attributes; + } + container xpdr-attributes { + when + "../node-type = 'TPDR' or ../node-type = 'MUXPDR' or ../node-type = 'REGEN' or + ../node-type = 'REGEN-UNI' or ../node-type = 'SWITCH'"; + description + "Topology-related attributes for Xponder nodes"; + uses xpdr:xpdr-topo-node-attributes; + } + } + augment "/nd:network/nd:node/nwt:termination-point" { + when "../../nd:network-types/openroadm-topology"; + description + "Defines the type of a termination point in the ROADM topology and + TP-specific attributes for each termination point type."; + leaf tp-type { + type org-openroadm-network-types:openroadm-tp-type; + must + "../../topo:node-type != 'DEGREE' or (../../topo:node-type = 'DEGREE' and + (../topo:tp-type = 'DEGREE-TX-TTP' or ../topo:tp-type = 'DEGREE-RX-TTP' or ../topo:tp-type = 'DEGREE-TXRX-TTP' or + ../topo:tp-type = 'DEGREE-TX-CTP' or ../topo:tp-type = 'DEGREE-RX-CTP' or ../topo:tp-type = 'DEGREE-TXRX-CTP'))" { + error-message "Invalid TP for node type 'DEGREE'"; + } + must + "../../topo:node-type != 'SRG' or (../../topo:node-type = 'SRG' and + (../topo:tp-type = 'SRG-TX-CP' or ../topo:tp-type = 'SRG-RX-CP' or ../topo:tp-type = 'SRG-TXRX-CP' or + ../topo:tp-type = 'SRG-RX-PP' or ../topo:tp-type = 'SRG-TX-PP' or ../topo:tp-type = 'SRG-TXRX-PP'))" { + error-message "Invalid TP for node type 'SRG'"; + } + must + " (../../topo:node-type != 'TPDR' and ../../topo:node-type != 'MUXPDR' and ../../topo:node-type != 'REGEN' and + ../../topo:node-type != 'REGEN-UNI' and ../../topo:node-type != 'SWITCH') + or ((../../topo:node-type = 'TPDR' or ../../topo:node-type = 'MUXPDR' or ../../topo:node-type = 'REGEN' or + ../../topo:node-type = 'REGEN-UNI' or ../../topo:node-type = 'SWITCH') and + (../topo:tp-type = 'XPONDER-NETWORK' or ../topo:tp-type = 'XPONDER-CLIENT' or ../topo:tp-type = 'XPONDER-PORT'))" { + error-message "Invalid TP for node type 'XPONDER'"; + } + must "../../topo:node-type != 'EXT-PLUGGABLE' or (../../topo:node-type = 'EXT-PLUGGABLE' and ../topo:tp-type = 'EXT-PLUGGABLE-TP')" { + error-message "Invalid TP for node type 'EXT-PLUGGABLE'"; + } + description + "The TP type; also defines which TP types can be instantiated + on which Node types"; + } + container tx-ttp-attributes { + when "../tp-type = 'DEGREE-TX-TTP' or ../tp-type = 'DEGREE-TXRX-TTP'"; + description + "There must be only one TP of type DEGREE-TX-TTP in any given + degree node"; + uses dgr:degree-used-wavelengths; + } + container rx-ttp-attributes { + when "../tp-type = 'DEGREE-RX-TTP'"; + description + "There must be only one TP of type DEGREE-RX-TTP in any given + degree node"; + uses dgr:degree-used-wavelengths; + } + container ctp-attributes { + when "../tp-type = 'DEGREE-TX-CTP' or ../tp-type = 'DEGREE-RX-CTP' or ../tp-type = 'DEGREE-TXRX-CTP'"; + uses dgr:degree-used-wavelengths; + } + container cp-attributes { + when "../tp-type = 'SRG-TX-CP' or ../tp-type = 'SRG-RX-CP' or ../tp-type = 'SRG-TXRX-CP'"; + description + "This list is created to accommodate fixed grid (1.2.1) as well as flex grid (2.0 above). In case of fixed grid + index number will refer to one of the 96 WL defined in the wavelength map file. In case of flex grid this + will hold list of used spectrums"; + list used-wavelengths { + key "index"; + uses org-openroadm-network-types:wavelengths; + } + } + container pp-attributes { + when "../tp-type = 'SRG-TXRX-PP' or ../tp-type = 'SRG-TX-PP' or ../tp-type = 'SRG-RX-PP' "; + description + "This list is created to accommodate fixed grid (1.2.1) as well as flex grid (2.0 above). In case of fixed grid + index number will refer to one of the 96 WL defined in the wavelength map file. In case of flex grid this + will hold list of used spectrums"; + list used-wavelength { + key "index"; + uses org-openroadm-network-types:wavelengths; + } + } + leaf eqpt-srg-id { + when + "../tp-type = 'XPONDER-CLIENT' or ../tp-type = 'XPONDER-NETWORK' or ../tp-type = 'EXT-PLUGGABLE-TP' or + ../tp-type = 'XPONDER-PORT'"; + type uint32; + description + "Shared Risk Group identifier. All ports in a circuit-pack will have same srg-id"; + } + container xpdr-client-attributes { + when "../tp-type = 'XPONDER-CLIENT'"; + uses xpdr:xpdr-connection-attributes; + uses xpdr:xpdr-port-connection-attributes; + } + container xpdr-network-attributes { + when "../tp-type = 'XPONDER-NETWORK'"; + uses xpdr:xpdr-connection-attributes; + uses xpdr:xpdr-port-connection-attributes; + } + container xpdr-port-attributes { + when "../tp-type = 'XPONDER-PORT'"; + uses xpdr:xpdr-connection-attributes; + uses xpdr:xpdr-port-connection-attributes; + } + container ext-pluggable-attributes { + when "../tp-type = 'EXT-PLUGGABLE-TP'"; + uses plg:pluggable-tp-attributes; + } + } + augment "/nd:network/nwt:link" { + when "../nd:network-types/openroadm-topology"; + description + "This augmentation defines ROADM link types in the ROADM topology"; + leaf link-type { + type org-openroadm-network-types:openroadm-link-type; + must + "(../link-type = 'ROADM-TO-ROADM' or ../link-type = 'ADD-LINK' or ../link-type = 'DROP-LINK' or + ../link-type = 'EXPRESS-LINK' or ../link-type = 'XPONDER-INPUT' or ../link-type = 'XPONDER-OUTPUT')" { + error-message "Invalid link type for openroadm-topology"; + } + } + leaf link-length { + type decimal64 { + fraction-digits 2; + } + } + leaf administrative-group { + type uint32; + description + "according to RFC 3630 definition"; + } + leaf operational-state { + type ct:state; + } + leaf administrative-state { + type ct:state; + } + leaf link-latency { + type uint32; + description + "Latency of a link"; + } + leaf amplified { + when "../link-type = 'ROADM-TO-ROADM'"; + type boolean; + description + "defines whether an ROADM-TO-ROADM Link includes line amplifiers or not"; + } + container OMS-attributes { + when "../link-type = 'ROADM-TO-ROADM'"; + description + ""; + uses link:OMS-attributes; + leaf opposite-link { + type leafref { + path "../../../nwt:link/nwt:link-id"; + } + description + "optional - pointer to reverse link in case of bidirectional link"; + } + container span { + when "../../amplified = 'false'"; + description + ""; + uses link:span-attributes; + } + container amplified-link { + when "../../amplified = 'true'"; + description + "when amplified is set to true, rather than a simple OMS section + we have an amplified link"; + uses link:amplified-link-attributes; + } + } + } +} diff --git a/ordmodels/network/src/main/yang/org-openroadm-network-types@2017-12-15.yang b/ordmodels/network/src/main/yang/org-openroadm-network-types@2017-12-15.yang new file mode 100644 index 000000000..39828047c --- /dev/null +++ b/ordmodels/network/src/main/yang/org-openroadm-network-types@2017-12-15.yang @@ -0,0 +1,249 @@ +module org-openroadm-network-types { + namespace "http://org/openroadm/network/types"; + prefix nt; + + import ietf-yang-types { + prefix yang; + revision-date 2013-07-15; + } + import org-openroadm-common-types { + prefix org-openroadm-common-types; + revision-date 2017-12-15; + } + import org-openroadm-port-types { + prefix org-openroadm-port-types; + revision-date 2017-12-15; + } + + organization + "OPEN ROADM MSA"; + contact + "www.OpenROADM.org."; + description + "Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016, + AT&T Intellectual Property. All other rights reserved. + + Redistribution and use in source and binary forms, with or without modification, + are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation and/or + other materials provided with the distribution. + * Neither the Members of the Open ROADM MSA Agreement nor the names of its + contributors may be used to endorse or promote products derived from this software + without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS'' + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE."; + + revision 2017-12-15 { + description + "Version 2.2"; + } + revision 2017-09-29 { + description + "Version 2.1"; + } + revision 2017-07-28 { + description + "Version 2.0.1 - added revision-date to imports"; + } + revision 2017-06-26 { + description + "Version 2.0"; + } + + typedef openroadm-node-type { + type enumeration { + enum "ROADM" { + value 1; + } + enum "DEGREE" { + value 11; + } + enum "SRG" { + value 12; + } + enum "XPONDER" { + value 3; + } + enum "EXT-PLUGGABLE" { + value 4; + } + enum "TPDR" { + value 13; + } + enum "MUXPDR" { + value 14; + } + enum "REGEN" { + value 15; + } + enum "REGEN-UNI" { + value 16; + } + enum "SWITCH" { + value 17; + } + } + } + + typedef openroadm-tp-type { + type enumeration { + enum "DEGREE-TX-TTP" { + value 1; + } + enum "DEGREE-RX-TTP" { + value 2; + } + enum "DEGREE-TX-CTP" { + value 3; + } + enum "DEGREE-RX-CTP" { + value 4; + } + enum "SRG-TX-CP" { + value 5; + } + enum "SRG-RX-CP" { + value 6; + } + enum "SRG-TXRX-PP" { + value 7; + } + enum "SRG-RX-PP" { + value 8; + } + enum "SRG-TX-PP" { + value 9; + } + enum "XPONDER-NETWORK" { + value 10; + } + enum "XPONDER-CLIENT" { + value 11; + } + enum "EXT-PLUGGABLE-TP" { + value 12; + } + enum "DEGREE-TXRX-TTP" { + value 13; + } + enum "SRG-TXRX-CP" { + value 14; + } + enum "XPONDER-PORT" { + value 15; + } + enum "DEGREE-TXRX-CTP" { + value 16; + } + } + } + + typedef openroadm-link-type { + type enumeration { + enum "EXPRESS-LINK" { + value 1; + } + enum "ADD-LINK" { + value 2; + } + enum "DROP-LINK" { + value 3; + } + enum "ROADM-TO-ROADM" { + value 4; + } + enum "XPONDER-INPUT" { + value 5; + } + enum "XPONDER-OUTPUT" { + value 6; + } + enum "OTN-LINK" { + value 7; + } + } + } + + typedef openroadm-node-status { + type enumeration { + enum "PLANNED" { + value 1; + } + enum "DEPLOYED" { + value 2; + } + enum "MAINTENANCE" { + value 3; + } + } + } + + grouping wavelengths { + leaf index { + type uint32; + } + uses flex-wave; + } + + grouping flex-wave { + leaf frequency { + type org-openroadm-common-types:frequency-THz; + config true; + description + "Center Frequency in THz"; + } + leaf width { + type org-openroadm-common-types:frequency-GHz; + config true; + description + "Frequency width in GHz."; + } + } + + grouping xpdr-tp-supported-interfaces { + list supported-interface-capability { + key "if-cap-type"; + description + "Supported interface capability on the port."; + leaf if-cap-type { + type identityref { + base org-openroadm-port-types:supported-if-capability; + } + description + "Interface type/hierarchy/rate supported on this port"; + } + } + } + + grouping node-due-date-list { + list due-dates { + key "id"; + leaf id { + type uint16; + } + leaf start-date { + type yang:date-and-time; + description + "date and time node will begin maintenance status or date when node is planned"; + } + leaf end-date { + type yang:date-and-time; + description + "date and time node will end maintenance or date when node is deployed"; + } + } + } +} diff --git a/ordmodels/network/src/main/yang/org-openroadm-network@2017-12-15.yang b/ordmodels/network/src/main/yang/org-openroadm-network@2017-12-15.yang new file mode 100644 index 000000000..e4690e8b4 --- /dev/null +++ b/ordmodels/network/src/main/yang/org-openroadm-network@2017-12-15.yang @@ -0,0 +1,168 @@ +module org-openroadm-network { + namespace "http://org/openroadm/network"; + prefix net; + + import ietf-network { + prefix nd; + revision-date 2015-06-08; + } + import org-openroadm-network-types { + prefix nt; + revision-date 2017-12-15; + } + import org-openroadm-roadm { + prefix roadm; + revision-date 2017-12-15; + } + import org-openroadm-external-pluggable { + prefix plg; + revision-date 2017-12-15; + } + import org-openroadm-xponder { + prefix xpdr; + revision-date 2017-12-15; + } + import ietf-inet-types { + prefix inet; + revision-date 2013-07-15; + } + + organization + "OPEN ROADM MSA"; + contact + "www.OpenROADM.org."; + description + "Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016, + AT&T Intellectual Property. All other rights reserved. + + Redistribution and use in source and binary forms, with or without modification, + are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation and/or + other materials provided with the distribution. + * Neither the Members of the Open ROADM MSA Agreement nor the names of its + contributors may be used to endorse or promote products derived from this software + without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS'' + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE."; + + revision 2017-12-15 { + description + "Version 2.2"; + } + revision 2017-09-29 { + description + "Version 2.1"; + } + revision 2017-07-28 { + description + "Version 2.0.1 - added revision-date to imports"; + } + revision 2017-06-26 { + description + "Version 2.0"; + } + revision 2016-10-14 { + description + "Version 1.2"; + } + + augment "/nd:network/nd:network-types" { + description + "Introduce new network type for the Open ROADM optical network"; + container openroadm-network { + presence "indicates optical network of Open ROADMs"; + description + "The presence of the container node indicates Open ROADM + network"; + } + } + augment "/nd:network/nd:node" { + when "../nd:network-types/openroadm-network"; + description + "Augment the generic network node with Open ROADM attributes."; + leaf node-type { + type nt:openroadm-node-type; + must "(../node-type = 'ROADM' or ../node-type = 'XPONDER' or ../node-type = 'EXT-PLUGGABLE')" { + error-message "Invalid node type for openroadm-network"; + } + description + "A component of the network topology. + Valid node types are XPONDER, EXT-PLUGGABLE and ROADM. + Once the node-type is configured, it should not be modified."; + } + leaf software-version { + type string; + description + "Vendor software version"; + } + leaf openroadm-version { + type string; + description + "OpenROADM software version"; + } + leaf vendor { + type string; + description + "Identifier of the supplier"; + } + leaf model { + type string; + description + "Identifier of the supplier's equipment"; + } + leaf domain-subnetwork { + type string; + description + "Specific Domain-Subnetwork in which the node resides"; + } + leaf ip { + type inet:ip-address; + description + "IP address assigned to the node"; + } + leaf relay-rack { + type string; + description + "Frame Identification Code (FIC)"; + } + leaf shelf { + type string; + } + leaf node-status { + type nt:openroadm-node-status; + } + container roadm-attributes { + when "../node-type = 'ROADM'"; + description + "Attributes for the ROADM Node."; + uses roadm:roadm-node-attributes; + } + container xpdr-attributes { + when "../node-type = 'XPONDER'"; + uses xpdr:xpdr-node-attributes; + } + container pluggable-attributes { + when "../node-type = 'EXT-PLUGGABLE'"; + uses plg:pluggable-node-attributes; + } + container plan-due-dates { + uses nt:node-due-date-list; + } + container node-maintenance-schedule { + uses nt:node-due-date-list; + } + } +} diff --git a/ordmodels/network/src/main/yang/org-openroadm-otn-network-topology@2017-12-15.yang b/ordmodels/network/src/main/yang/org-openroadm-otn-network-topology@2017-12-15.yang new file mode 100644 index 000000000..9651c346b --- /dev/null +++ b/ordmodels/network/src/main/yang/org-openroadm-otn-network-topology@2017-12-15.yang @@ -0,0 +1,185 @@ +module org-openroadm-otn-network-topology { + namespace "http://org/openroadm/otn/network/topology"; + prefix otn-topo; + + import ietf-network { + prefix nd; + revision-date 2015-06-08; + } + import ietf-network-topology { + prefix nwt; + revision-date 2015-06-08; + } + import org-openroadm-network-types { + prefix org-openroadm-network-types; + revision-date 2017-12-15; + } + import org-openroadm-network-topology-types { + prefix org-openroadm-network-topology-types; + revision-date 2017-12-15; + } + import org-openroadm-xponder { + prefix xpdr; + revision-date 2017-12-15; + } + import org-openroadm-common-types { + prefix ct; + revision-date 2017-12-15; + } + + organization + "OPEN ROADM MSA"; + contact + "OpenROADM.org."; + description + "YANG definitions for network view of a ROADM + + Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016, + AT&T Intellectual Property. All other rights reserved. + + Redistribution and use in source and binary forms, with or without modification, + are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation and/or + other materials provided with the distribution. + * Neither the Members of the Open ROADM MSA Agreement nor the names of its + contributors may be used to endorse or promote products derived from this software + without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS'' + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE."; + + revision 2017-12-15 { + description + "Version 2.2"; + } + revision 2017-09-29 { + description + "Version 2.1"; + } + + augment "/nd:network/nd:network-types" { + description + "Introduce new network type for the Open ROADM OTN + ` network topology"; + container otn-topology { + presence "indicates OTN topology for Muxponder, Switchponder and OTN-switch"; + } + } + augment "/nd:network/nd:node" { + when "../nd:network-types/otn-topology"; + description + "This augmentations adds the OTN Node type to the generic node + definition and defines node-sepcific attributes for each node type + in the OTN Topology."; + leaf node-type { + type org-openroadm-network-types:openroadm-node-type; + must "(../node-type = 'SWITCH' or ../node-type = 'MUXPDR')" { + error-message "Invalid node type for otn-topology"; + } + description + "The type of a node in the OTN topology. Valid node types are 'MUXPDR' and 'SWITCH'"; + } + container tp-bandwidth-sharing { + when "../node-type = 'MUXPDR' or ../node-type = 'SWITCH'"; + uses org-openroadm-network-topology-types:xpdr-tp-bandwidth-sharing; + } + container switching-pools { + when "../node-type = 'MUXPDR' or ../node-type = 'SWITCH'"; + description + "ODU Switching pool"; + uses org-openroadm-network-topology-types:xpdr-odu-switching-pools; + } + container xpdr-attributes { + when "../node-type = 'MUXPDR' or ../node-type = 'SWITCH'"; + description + "Topology-related attributes for Xponder nodes"; + uses xpdr:xpdr-topo-node-attributes; + } + } + augment "/nd:network/nd:node/nwt:termination-point" { + when "../../nd:network-types/otn-topology"; + description + "Defines the type of a termination point in the OTN topology and + TP-specific attributes for each termination point type."; + leaf tp-type { + type org-openroadm-network-types:openroadm-tp-type; + must + "(../../otn-topo:node-type != 'MUXPDR' and ../../otn-topo:node-type != 'SWITCH') or + ((../../otn-topo:node-type = 'MUXPDR' or ../../otn-topo:node-type = 'SWITCH') and + (../otn-topo:tp-type = 'XPONDER-NETWORK' or ../otn-topo:tp-type = 'XPONDER-CLIENT' or ../otn-topo:tp-type = 'XPONDER-PORT'))" { + error-message "Invalid TP for node type Xponder"; + } + description + "The TP type; also defines which TP types can be instantiated + on which Node types"; + } + leaf eqpt-srg-id { + type uint32; + description + "Shared Risk Group identifier. All ports in a circuit-pack will have same srg-id"; + } + container tp-supported-interfaces { + when "../tp-type = 'XPONDER-NETWORK' or ../tp-type = 'XPONDER-CLIENT' or ../tp-type = 'XPONDER-PORT'"; + description + "Supported interface capability on the port."; + uses org-openroadm-network-types:xpdr-tp-supported-interfaces; + } + container xpdr-tp-port-connection-attributes { + when "../tp-type = 'XPONDER-NETWORK' or ../tp-type = 'XPONDER-CLIENT' or ../tp-type = 'XPONDER-PORT'"; + description + "Topology-related attributes for Xpdr nodes"; + uses xpdr:xpdr-otn-tp-attributes; + uses xpdr:xpdr-port-connection-attributes; + uses org-openroadm-network-topology-types:xpdr-otn-tail-attributes; + } + } + augment "/nd:network/nwt:link" { + when "../nd:network-types/otn-topology"; + description + "This augmentation defines Logical link types in the OTN topology connecting OTN elements"; + leaf link-type { + type org-openroadm-network-types:openroadm-link-type; + must "(../link-type = 'OTN-LINK')" { + error-message "Invalid link type for otn-topology"; + } + } + leaf administrative-group { + type uint32; + description + "according to RFC 3630 definition"; + } + leaf operational-state { + type ct:state; + } + leaf administrative-state { + type ct:state; + } + leaf available-bandwidth { + type uint32; + description + "Availabled bandwidth between OTN elements"; + } + leaf used-bandwidth { + type uint32; + description + "Used bandwidth between OTN elements"; + } + leaf ODU-protected { + type boolean; + description + "ODU protection flag"; + } + } +} diff --git a/ordmodels/network/src/main/yang/org-openroadm-roadm@2017-12-15.yang b/ordmodels/network/src/main/yang/org-openroadm-roadm@2017-12-15.yang new file mode 100644 index 000000000..2f11b5f90 --- /dev/null +++ b/ordmodels/network/src/main/yang/org-openroadm-roadm@2017-12-15.yang @@ -0,0 +1,77 @@ +module org-openroadm-roadm { + namespace "http://org/openroadm/roadm"; + prefix roadm; + + organization + "OPEN ROADM MSA"; + contact + "OpenROADM.org."; + description + "YANG definitions for network view of a ROADM + + Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016, + AT&T Intellectual Property. All other rights reserved. + + Redistribution and use in source and binary forms, with or without modification, + are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation and/or + other materials provided with the distribution. + * Neither the Members of the Open ROADM MSA Agreement nor the names of its + contributors may be used to endorse or promote products derived from this software + without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS'' + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE."; + + revision 2017-12-15 { + description + "Version 2.2"; + } + revision 2017-09-29 { + description + "Version 2.1"; + } + revision 2017-06-26 { + description + "Version 2.0"; + } + revision 2016-10-14 { + description + "Version 1.2"; + } + + grouping roadm-node-attributes { + leaf max-degrees { + type uint16; + description + "Max no. of degrees supported by the node"; + } + leaf max-srgs { + type uint16; + description + "Max no. of SRGs supported by the node"; + } + leaf current-degrees { + type uint16; + description + "Current no. of degrees supported by the node"; + } + leaf current-srgs { + type uint16; + description + "Current no. of SRGs supported by the node"; + } + } +} diff --git a/ordmodels/network/src/main/yang/org-openroadm-srg@2017-12-15.yang b/ordmodels/network/src/main/yang/org-openroadm-srg@2017-12-15.yang new file mode 100644 index 000000000..cbc528d8a --- /dev/null +++ b/ordmodels/network/src/main/yang/org-openroadm-srg@2017-12-15.yang @@ -0,0 +1,94 @@ +module org-openroadm-srg { + namespace "http://org/openroadm/srg"; + prefix srg; + + import org-openroadm-network-types { + prefix org-openroadm-network-types; + revision-date 2017-12-15; + } + import org-openroadm-common-types { + prefix org-openroadm-common-types; + revision-date 2017-12-15; + } + + organization + "OPEN ROADM MSA"; + contact + "OpenROADM.org."; + description + "YANG definitions for an Add/Drop group in Network Model + + Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016, + AT&T Intellectual Property. All other rights reserved. + + Redistribution and use in source and binary forms, with or without modification, + are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation and/or + other materials provided with the distribution. + * Neither the Members of the Open ROADM MSA Agreement nor the names of its + contributors may be used to endorse or promote products derived from this software + without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS'' + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE."; + + revision 2017-12-15 { + description + "Version 2.2"; + } + revision 2017-09-29 { + description + "Version 2.1"; + } + revision 2017-07-28 { + description + "Version 2.0.1 - added revision-date to imports"; + } + revision 2017-06-26 { + description + "Version 2.0"; + } + revision 2016-10-14 { + description + "Version 1.2"; + } + + grouping srg-node-attributes { + leaf srg-number { + type uint16; + } + leaf max-pp { + type uint32; + description + "Maximum number of add/drop port pairs in an SRG"; + } + leaf current-provisioned-pp { + type uint32; + description + "current provisioned number of port pair in a given SRG"; + } + list available-wavelengths { + key "index"; + description + "This list is created to accommodate fix grid (1.2.1) as well as flex grid (2.0 above). In case of fixed grid + index number will refer to one of the 96 WL defined in the wavelength map file. In case of flex grid this + will hold list of available spectrums"; + uses org-openroadm-network-types:wavelengths; + } + leaf wavelength-duplication { + type org-openroadm-common-types:wavelength-duplication-type; + } + } +} diff --git a/ordmodels/network/src/main/yang/org-openroadm-xponder@2017-12-15.yang b/ordmodels/network/src/main/yang/org-openroadm-xponder@2017-12-15.yang new file mode 100644 index 000000000..25a61acd1 --- /dev/null +++ b/ordmodels/network/src/main/yang/org-openroadm-xponder@2017-12-15.yang @@ -0,0 +1,156 @@ +module org-openroadm-xponder { + namespace "http://org/openroadm/xponder"; + prefix xpndr; + + import org-openroadm-network-types { + prefix org-openroadm-network-types; + revision-date 2017-12-15; + } + import org-openroadm-common-types { + prefix org-openroadm-common-types; + revision-date 2017-12-15; + } + import org-openroadm-otn-common-types { + prefix org-openroadm-otn-common-types; + revision-date 2017-12-15; + } + + organization + "OPEN ROADM MSA"; + contact + "OpenROADM.org."; + description + "YANG definitions for xponder + + Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016, + AT&T Intellectual Property. All other rights reserved. + + Redistribution and use in source and binary forms, with or without modification, + are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation and/or + other materials provided with the distribution. + * Neither the Members of the Open ROADM MSA Agreement nor the names of its + contributors may be used to endorse or promote products derived from this software + without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS'' + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE."; + + revision 2017-12-15 { + description + "Version 2.2"; + } + revision 2017-09-29 { + description + "Version 2.1"; + } + revision 2017-07-28 { + description + "Version 2.0.1 - added revision-date to imports"; + } + revision 2017-06-26 { + description + "Version 2.0"; + } + revision 2016-10-14 { + description + "Version 1.2"; + } + + grouping xpdr-node-attributes { + leaf customer-code { + type string; + description + "Owner of the xponder"; + } + } + + grouping xpdr-topo-node-attributes { + leaf xpdr-number { + type uint16; + } + } + + grouping xpdr-connection-attributes { + leaf local-lgx { + type string; + } + leaf rate { + type identityref { + base org-openroadm-common-types:och-rate-identity; + } + description + "rate"; + } + leaf modulation-format { + type org-openroadm-common-types:modulation-format; + } + leaf optic { + type org-openroadm-common-types:optic-types; + } + leaf state { + type org-openroadm-common-types:state; + description + "A xponder can be in one of the following + states"; + } + } + + grouping xpdr-port-connection-attributes { + container wavelength { + uses org-openroadm-network-types:wavelengths; + } + leaf tail-equipment { + type string; + } + leaf tail-equipment-id { + type string; + } + leaf tail-clfi { + type string; + } + } + + grouping xpdr-otn-tp-attributes { + leaf rate { + type identityref { + base org-openroadm-otn-common-types:odu-rate-identity; + } + description + "rate identity of the ODU. 'identityref' is used + to allow to extend for future higher rates"; + } + list odtu-tpn-pool { + key "odtu-type"; + leaf odtu-type { + type identityref { + base org-openroadm-otn-common-types:odtu-type-identity; + } + description + "ODTU type, part of the MSI (Multiplex Structure Identifier)"; + } + leaf-list tpn-pool { + type uint16; + description + "Tributary Port Number (0-based), part of the MSI"; + } + } + leaf-list ts-pool { + type uint16; + description + "Timeslots used by port"; + } + } +} diff --git a/renderer/src/main/java/org/opendaylight/transportpce/renderer/ModelMappingUtils.java b/renderer/src/main/java/org/opendaylight/transportpce/renderer/ModelMappingUtils.java index 2309750cd..093729ac5 100644 --- a/renderer/src/main/java/org/opendaylight/transportpce/renderer/ModelMappingUtils.java +++ b/renderer/src/main/java/org/opendaylight/transportpce/renderer/ModelMappingUtils.java @@ -13,7 +13,8 @@ import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.TreeMap; -import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl; + +import org.opendaylight.transportpce.common.StringConstants; import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerSetupInput; import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerSetupInputBuilder; import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.device.rev170228.ServicePathInput; @@ -215,10 +216,10 @@ public final class ModelMappingUtils { if (tpID.contains("CTP") || tpID.contains("CP")) { continue; } - if (!tpID.contains(OpenRoadmInterfacesImpl.TTP_TOKEN) - && !tpID.contains(OpenRoadmInterfacesImpl.PP_TOKEN) - && !tpID.contains(OpenRoadmInterfacesImpl.NETWORK_TOKEN) - && !tpID.contains(OpenRoadmInterfacesImpl.CLIENT_TOKEN)) { + if (!tpID.contains(StringConstants.TTP_TOKEN) + && !tpID.contains(StringConstants.PP_TOKEN) + && !tpID.contains(StringConstants.NETWORK_TOKEN) + && !tpID.contains(StringConstants.CLIENT_TOKEN)) { continue; } diff --git a/renderer/src/main/java/org/opendaylight/transportpce/renderer/NetworkModelWavelengthServiceImpl.java b/renderer/src/main/java/org/opendaylight/transportpce/renderer/NetworkModelWavelengthServiceImpl.java index 138ff8e3a..97acdbf9c 100644 --- a/renderer/src/main/java/org/opendaylight/transportpce/renderer/NetworkModelWavelengthServiceImpl.java +++ b/renderer/src/main/java/org/opendaylight/transportpce/renderer/NetworkModelWavelengthServiceImpl.java @@ -20,40 +20,41 @@ import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; import org.opendaylight.transportpce.common.NetworkUtils; import org.opendaylight.transportpce.common.Timeouts; -import org.opendaylight.yang.gen.v1.http.org.openroadm.degree.rev170929.degree.node.attributes.AvailableWavelengthsKey; -import org.opendaylight.yang.gen.v1.http.org.openroadm.degree.rev170929.degree.used.wavelengths.UsedWavelengths; -import org.opendaylight.yang.gen.v1.http.org.openroadm.degree.rev170929.degree.used.wavelengths.UsedWavelengthsBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.degree.rev170929.degree.used.wavelengths.UsedWavelengthsKey; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.Node1; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.TerminationPoint1; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.TerminationPoint1Builder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.DegreeAttributes; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.DegreeAttributesBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.SrgAttributes; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.SrgAttributesBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.termination.point.CpAttributes; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.termination.point.CpAttributesBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.termination.point.CtpAttributes; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.termination.point.CtpAttributesBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.termination.point.PpAttributes; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.termination.point.PpAttributesBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.termination.point.RxTtpAttributes; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.termination.point.RxTtpAttributesBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.termination.point.TxTtpAttributes; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.termination.point.TxTtpAttributesBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.termination.point.XpdrClientAttributes; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.termination.point.XpdrClientAttributesBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.termination.point.XpdrNetworkAttributes; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.termination.point.XpdrNetworkAttributesBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.termination.point.XpdrPortAttributes; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.termination.point.XpdrPortAttributesBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.termination.point.pp.attributes.UsedWavelength; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.termination.point.pp.attributes.UsedWavelengthBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.termination.point.pp.attributes.UsedWavelengthKey; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev170929.OpenroadmTpType; -import org.opendaylight.yang.gen.v1.http.org.openroadm.srg.rev170929.srg.node.attributes.AvailableWavelengthsBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.xponder.rev170929.xpdr.port.connection.attributes.Wavelength; -import org.opendaylight.yang.gen.v1.http.org.openroadm.xponder.rev170929.xpdr.port.connection.attributes.WavelengthBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.degree.rev171215.degree.node.attributes.AvailableWavelengthsKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.degree.rev171215.degree.used.wavelengths.UsedWavelengths; +import org.opendaylight.yang.gen.v1.http.org.openroadm.degree.rev171215.degree.used.wavelengths.UsedWavelengthsBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.degree.rev171215.degree.used.wavelengths.UsedWavelengthsKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.Node1; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.Node1Builder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.TerminationPoint1; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.TerminationPoint1Builder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.DegreeAttributes; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.DegreeAttributesBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.SrgAttributes; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.SrgAttributesBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.termination.point.CpAttributes; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.termination.point.CpAttributesBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.termination.point.CtpAttributes; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.termination.point.CtpAttributesBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.termination.point.PpAttributes; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.termination.point.PpAttributesBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.termination.point.RxTtpAttributes; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.termination.point.RxTtpAttributesBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.termination.point.TxTtpAttributes; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.termination.point.TxTtpAttributesBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.termination.point.XpdrClientAttributes; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.termination.point.XpdrClientAttributesBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.termination.point.XpdrNetworkAttributes; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.termination.point.XpdrNetworkAttributesBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.termination.point.XpdrPortAttributes; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.termination.point.XpdrPortAttributesBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.termination.point.pp.attributes.UsedWavelength; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.termination.point.pp.attributes.UsedWavelengthBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.termination.point.pp.attributes.UsedWavelengthKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev171215.OpenroadmTpType; +import org.opendaylight.yang.gen.v1.http.org.openroadm.srg.rev171215.srg.node.attributes.AvailableWavelengthsBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.xponder.rev171215.xpdr.port.connection.attributes.Wavelength; +import org.opendaylight.yang.gen.v1.http.org.openroadm.xponder.rev171215.xpdr.port.connection.attributes.WavelengthBuilder; import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev171017.PathDescription; import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev171017.path.description.atoz.direction.AToZ; import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev171017.path.description.ztoa.direction.ZToA; @@ -152,15 +153,14 @@ public class NetworkModelWavelengthServiceImpl implements NetworkModelWavelength .builder(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID))) .child(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev150608 .network.Node.class, new NodeKey(new NodeId(nodeId))) - .augmentation(org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929 - .Node1.class) + .augmentation(Node1.class) .build(); } private Optional getNode1FromDatastore(String nodeId) { - InstanceIdentifier + InstanceIdentifier nodeIID = createNode1IID(nodeId); - Optional nodeOpt; + Optional nodeOpt; try (ReadOnlyTransaction nodeReadTx = this.dataBroker.newReadOnlyTransaction()) { nodeOpt = nodeReadTx.read(LogicalDatastoreType.CONFIGURATION, nodeIID) .get(Timeouts.DATASTORE_READ, TimeUnit.MILLISECONDS); @@ -174,9 +174,9 @@ public class NetworkModelWavelengthServiceImpl implements NetworkModelWavelength private void addAvailableWL(List nodeIds, Long wavelengthNumber) { WriteTransaction nodeWriteTx = this.dataBroker.newWriteOnlyTransaction(); for (String nodeId : nodeIds) { - Optional nodeOpt = + Optional nodeOpt = getNode1FromDatastore(nodeId); - org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.Node1 node; + Node1 node; if (nodeOpt.isPresent()) { node = nodeOpt.get(); } else { @@ -185,9 +185,7 @@ public class NetworkModelWavelengthServiceImpl implements NetworkModelWavelength continue; } - org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.Node1Builder - node1Builder = new org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929 - .Node1Builder(node); + Node1Builder node1Builder = new Node1Builder(node); switch (node.getNodeType()) { case DEGREE: @@ -198,14 +196,14 @@ public class NetworkModelWavelengthServiceImpl implements NetworkModelWavelength } else { degreeAttributesBuilder = new DegreeAttributesBuilder(degreeAttributes); } - List availableDegreeWLs = degreeAttributesBuilder.getAvailableWavelengths(); if (availableDegreeWLs == null) { availableDegreeWLs = new ArrayList<>(); degreeAttributesBuilder.setAvailableWavelengths(availableDegreeWLs); } - availableDegreeWLs.add(new org.opendaylight.yang.gen.v1.http.org.openroadm.degree.rev170929.degree + availableDegreeWLs.add(new org.opendaylight.yang.gen.v1.http.org.openroadm.degree.rev171215.degree .node.attributes.AvailableWavelengthsBuilder().setIndex(wavelengthNumber).build()); node1Builder.setDegreeAttributes(degreeAttributesBuilder.build()); break; @@ -217,7 +215,7 @@ public class NetworkModelWavelengthServiceImpl implements NetworkModelWavelength } else { srgAttributesBuilder = new SrgAttributesBuilder(srgAttributes); } - List availableSrgWLs = srgAttributesBuilder.getAvailableWavelengths(); if (availableSrgWLs == null) { availableSrgWLs = new ArrayList<>(); @@ -243,9 +241,8 @@ public class NetworkModelWavelengthServiceImpl implements NetworkModelWavelength private void deleteAvailableWL(List nodeIds, Long wavelengthNumber) { WriteTransaction nodeWriteTx = this.dataBroker.newWriteOnlyTransaction(); for (String nodeId : nodeIds) { - Optional nodeOpt = - getNode1FromDatastore(nodeId); - org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.Node1 node; + Optional nodeOpt = getNode1FromDatastore(nodeId); + Node1 node; if (nodeOpt.isPresent()) { node = nodeOpt.get(); } else { @@ -262,16 +259,16 @@ public class NetworkModelWavelengthServiceImpl implements NetworkModelWavelength switch (node.getNodeType()) { case DEGREE: availableWlIID = nodeIIDBuilder.child(DegreeAttributes.class) - .child(org.opendaylight.yang.gen.v1.http.org.openroadm.degree.rev170929.degree.node + .child(org.opendaylight.yang.gen.v1.http.org.openroadm.degree.rev171215.degree.node .attributes.AvailableWavelengths.class, new AvailableWavelengthsKey(wavelengthNumber)) .build(); break; case SRG: availableWlIID = nodeIIDBuilder.child(SrgAttributes.class) - .child(org.opendaylight.yang.gen.v1.http.org.openroadm.srg.rev170929.srg.node.attributes + .child(org.opendaylight.yang.gen.v1.http.org.openroadm.srg.rev171215.srg.node.attributes .AvailableWavelengths.class, - new org.opendaylight.yang.gen.v1.http.org.openroadm.srg.rev170929.srg.node + new org.opendaylight.yang.gen.v1.http.org.openroadm.srg.rev171215.srg.node .attributes.AvailableWavelengthsKey(wavelengthNumber)) .build(); break; @@ -354,9 +351,9 @@ public class NetworkModelWavelengthServiceImpl implements NetworkModelWavelength case SRGRXCP: case SRGTXRXCP: usedWlIID = usedWlIIDBuilder.child(CpAttributes.class).child(org.opendaylight.yang.gen.v1.http.org - .openroadm.network.topology.rev170929.network.node.termination.point.cp.attributes + .openroadm.network.topology.rev171215.network.node.termination.point.cp.attributes .UsedWavelengths.class, - new org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node + new org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node .termination.point.cp.attributes.UsedWavelengthsKey( wavelengthIndex)).build(); break; @@ -473,14 +470,14 @@ public class NetworkModelWavelengthServiceImpl implements NetworkModelWavelength } else { cpAttributesBuilder = new CpAttributesBuilder(cpAttributes); } - List usedDegreeCpWls = cpAttributesBuilder.getUsedWavelengths(); if (usedDegreeCpWls == null) { usedDegreeCpWls = new ArrayList<>(); cpAttributesBuilder.setUsedWavelengths(usedDegreeCpWls); } - usedDegreeCpWls.add(new org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929 + usedDegreeCpWls.add(new org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215 .network.node.termination.point.cp.attributes.UsedWavelengthsBuilder() .setIndex(wavelengthIndex).build()); tp1Builder.setCpAttributes(cpAttributesBuilder.build()); 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 new file mode 100644 index 000000000..9b6c40d3a --- /dev/null +++ b/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterface121.java @@ -0,0 +1,324 @@ +/* + * Copyright © 2017 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.math.BigDecimal; +import java.util.ArrayList; +import java.util.List; + +import org.opendaylight.transportpce.common.StringConstants; +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.rev170228.network.nodes.Mapping; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev161014.PowerDBm; + +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.InterfaceBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.InterfaceKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev161014.AdminStates; +import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev161014.EthAttributes; +import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev161014.Interface1; +import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev161014.Interface1Builder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev161014.ethernet.container.EthernetBuilder; + +import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev161014.EthernetCsmacd; +import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev161014.InterfaceType; +import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev161014.OpenROADMOpticalMultiplex; +import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev161014.OpticalChannel; +import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev161014.OpticalTransport; +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.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; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev161014.ODU4; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev161014.OduAttributes; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev161014.odu.container.OduBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev161014.opu.OpuBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev161014.OTU4; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev161014.OtuAttributes; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev161014.otu.container.OtuBuilder; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + + +public class OpenRoadmInterface121 { + private final PortMapping portMapping; + private final OpenRoadmInterfaces openRoadmInterfaces; + private static final Logger LOG = LoggerFactory.getLogger(OpenRoadmInterfaceFactory.class); + + public OpenRoadmInterface121(PortMapping portMapping, OpenRoadmInterfaces openRoadmInterfaces) { + this.portMapping = portMapping; + this.openRoadmInterfaces = openRoadmInterfaces; + } + + public String createOpenRoadmEthInterface(String nodeId, String logicalConnPoint) + throws OpenRoadmInterfaceException { + Mapping portMap = this.portMapping.getMapping(nodeId, logicalConnPoint); + if (portMap == null) { + throw new OpenRoadmInterfaceException(String.format("Unable to get mapping from PortMapping for node % and" + + " logical connection port %s", nodeId, logicalConnPoint)); + } + + // Ethernet interface specific data + EthernetBuilder ethIfBuilder = new EthernetBuilder(); + ethIfBuilder.setAutoNegotiation(EthAttributes.AutoNegotiation.Enabled); + ethIfBuilder.setDuplex(EthAttributes.Duplex.Full); + ethIfBuilder.setFec(EthAttributes.Fec.Off); + ethIfBuilder.setSpeed(100000L); + ethIfBuilder.setMtu(9000L); + + InterfaceBuilder ethInterfaceBldr = createGenericInterfaceBuilder(portMap, EthernetCsmacd.class, + logicalConnPoint + "-ETHERNET"); + + // Create Interface1 type object required for adding as augmentation + Interface1Builder ethIf1Builder = new Interface1Builder(); + ethInterfaceBldr.addAugmentation(Interface1.class, ethIf1Builder.setEthernet(ethIfBuilder.build()).build()); + + // Post interface on the device + this.openRoadmInterfaces.postInterface(nodeId, ethInterfaceBldr); + + // Post the equipment-state change on the device circuit-pack + this.openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true); + + return ethInterfaceBldr.getName(); + } + + private InterfaceBuilder createGenericInterfaceBuilder(Mapping portMap, Class type, + String key) { + InterfaceBuilder interfaceBuilder = new InterfaceBuilder(); + interfaceBuilder.setDescription(" TBD "); + interfaceBuilder.setCircuitId(" TBD "); + interfaceBuilder.setSupportingCircuitPackName(portMap.getSupportingCircuitPackName()); + interfaceBuilder.setSupportingPort(portMap.getSupportingPort()); + interfaceBuilder.setAdministrativeState(AdminStates.InService); + interfaceBuilder.setType(type); + interfaceBuilder.setName(key); + interfaceBuilder.withKey(new InterfaceKey(key)); + return interfaceBuilder; + } + /** + * This methods creates an OTU interface on the given termination point. + * + * @param nodeId node ID + * @param logicalConnPoint logical Connection Point + * @param supportOchInterface support OCH Interface + * + * @return Name of the interface if successful, otherwise return null. + * @throws OpenRoadmInterfaceException OpenRoadmInterfaceException + */ + + public String createOpenRoadmOtu4Interface(String nodeId, String logicalConnPoint, String supportOchInterface) + throws OpenRoadmInterfaceException { + Mapping portMap = this.portMapping.getMapping(nodeId, logicalConnPoint); + if (portMap == null) { + throw new OpenRoadmInterfaceException(String.format("Unable to get mapping from PortMapping for node % and" + + " logical connection port %s", nodeId, logicalConnPoint)); + } + // Create generic interface + InterfaceBuilder otuInterfaceBldr = createGenericInterfaceBuilder(portMap, OtnOtu.class, logicalConnPoint + + "-OTU"); + otuInterfaceBldr.setSupportingInterface(supportOchInterface); + + // OTU interface specific data + OtuBuilder otuIfBuilder = new OtuBuilder(); + otuIfBuilder.setFec(OtuAttributes.Fec.Scfec); + otuIfBuilder.setRate(OTU4.class); + + // Create Interface1 type object required for adding as augmentation + // TODO look at imports of different versions of class + org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev161014.Interface1Builder otuIf1Builder = + new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev161014.Interface1Builder(); + otuInterfaceBldr.addAugmentation( + org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev161014.Interface1.class, + otuIf1Builder.setOtu(otuIfBuilder.build()).build()); + + // Post interface on the device + this.openRoadmInterfaces.postInterface(nodeId, otuInterfaceBldr); + return otuInterfaceBldr.getName(); + } + + /** + * This methods creates an ODU interface on the given termination point. + * + * @param nodeId node ID + * @param logicalConnPoint logical Connection Point + * @param supportingOtuInterface supporting OTU Interface + * + * @return Name of the interface if successful, otherwise return null. + * @throws OpenRoadmInterfaceException OpenRoadmInterfaceException + */ + + public String createOpenRoadmOdu4Interface(String nodeId, String logicalConnPoint, String supportingOtuInterface) + throws OpenRoadmInterfaceException { + Mapping portMap = this.portMapping.getMapping(nodeId, logicalConnPoint); + if (portMap == null) { + throw new OpenRoadmInterfaceException(String.format("Unable to get mapping from PortMapping for node % and" + + " logical connection port %s", nodeId, logicalConnPoint)); + } + InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(portMap, OtnOdu.class, logicalConnPoint + + "-ODU"); + oduInterfaceBldr.setSupportingInterface(supportingOtuInterface); + + // ODU interface specific data + OduBuilder oduIfBuilder = new OduBuilder(); + oduIfBuilder.setRate(ODU4.class); + oduIfBuilder.setMonitoringMode(OduAttributes.MonitoringMode.Terminated); + + // Set Opu attributes + OpuBuilder opuBldr = new OpuBuilder(); + opuBldr.setPayloadType("07"); + opuBldr.setExpPayloadType("07"); + oduIfBuilder.setOpu(opuBldr.build()); + + // Create Interface1 type object required for adding as augmentation + // TODO look at imports of different versions of class + org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev161014.Interface1Builder oduIf1Builder = + new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev161014.Interface1Builder(); + oduInterfaceBldr.addAugmentation( + org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev161014.Interface1.class, + oduIf1Builder.setOdu(oduIfBuilder.build()).build()); + + // Post interface on the device + this.openRoadmInterfaces.postInterface(nodeId, oduInterfaceBldr); + return oduInterfaceBldr.getName(); + } + /** + * This methods creates an OCH interface on the given termination point on + * Roadm. + * + * @param waveNumber wavelength number of the OCH interface. + * @return Name of the interface if successful, otherwise return null. + */ + + public List createOpenRoadmOchInterface(String nodeId, String logicalConnPoint, Long waveNumber) + throws OpenRoadmInterfaceException { + + Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint); + if (portMap == null) { + throw new OpenRoadmInterfaceException(String.format("Unable to get mapping from PortMapping for node %s and" + + " logical connection port %s", nodeId, logicalConnPoint)); + } + // Create generic interface + InterfaceBuilder ochInterfaceBldr = createGenericInterfaceBuilder(portMap, OpticalChannel.class, + createOpenRoadmOchInterfaceName(logicalConnPoint, waveNumber)); + + // OCH interface specific data + OchBuilder ocIfBuilder = new OchBuilder(); + ocIfBuilder.setWavelengthNumber(waveNumber); + + // Add supporting OMS interface + if (portMap.getSupportingOms() != null) { + ochInterfaceBldr.setSupportingInterface(portMap.getSupportingOms()); + } + // Create Interface1 type object required for adding as augmentation + // TODO look at imports of different versions of class + org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev161014.Interface1Builder + ochIf1Builder = new org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces + .rev161014.Interface1Builder(); + ochInterfaceBldr.addAugmentation( + org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev161014.Interface1.class, + ochIf1Builder.setOch(ocIfBuilder.build()).build()); + + List interfacesCreated = new ArrayList<>(); + // Post interface on the device + openRoadmInterfaces.postInterface(nodeId, ochInterfaceBldr); + interfacesCreated.add(ochInterfaceBldr.getName()); + return interfacesCreated; + } + + public String createOpenRoadmOchInterface(String nodeId, String logicalConnPoint, Long waveNumber, Class< + ? extends RateIdentity> rate, 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" + + " logical connection port %s", nodeId, logicalConnPoint)); + } + + // OCH interface specific data + OchBuilder ocIfBuilder = new OchBuilder(); + ocIfBuilder.setWavelengthNumber(waveNumber); + ocIfBuilder.setModulationFormat(format); + ocIfBuilder.setRate(rate); + ocIfBuilder.setTransmitPower(new PowerDBm(new BigDecimal("-5"))); + + // Create Interface1 type object required for adding as augmentation + // TODO look at imports of different versions of class + org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev161014 + .Interface1Builder ochIf1Builder = new org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel + .interfaces.rev161014.Interface1Builder(); + // Create generic interface + InterfaceBuilder ochInterfaceBldr = createGenericInterfaceBuilder(portMap, OpticalChannel.class, + createOpenRoadmOchInterfaceName(logicalConnPoint, waveNumber)); + ochInterfaceBldr.addAugmentation( + org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev161014.Interface1.class, + ochIf1Builder.setOch(ocIfBuilder.build()).build()); + + // Post interface on the device + this.openRoadmInterfaces.postInterface(nodeId, ochInterfaceBldr); + + // Post the equipment-state change on the device circuit-pack if xpdr node + if (portMap.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) { + this.openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true); + } + return ochInterfaceBldr.getName(); + } + + public String createOpenRoadmOchInterfaceName(String logicalConnectionPoint, Long waveNumber) { + return logicalConnectionPoint + "-" + waveNumber; + } + + public String createOpenRoadmOmsInterface(String nodeId, Mapping mapping) throws OpenRoadmInterfaceException { + if (mapping.getSupportingOms() == null) { + // Create generic interface + InterfaceBuilder omsInterfaceBldr = createGenericInterfaceBuilder(mapping, OpenROADMOpticalMultiplex.class, + "OMS-" + mapping.getLogicalConnectionPoint()); + if (mapping.getSupportingOts() != null) { + omsInterfaceBldr.setSupportingInterface(mapping.getSupportingOts()); + } else { + LOG.error("Unable to get ots interface from mapping {} - {}", nodeId, + mapping.getLogicalConnectionPoint()); + return null; + } + this.openRoadmInterfaces.postInterface(nodeId, omsInterfaceBldr); + this.portMapping.updateMapping(nodeId, mapping); + return omsInterfaceBldr.build().getName(); + } else { + return mapping.getSupportingOms(); + } + } + + public String createOpenRoadmOtsInterface(String nodeId, Mapping mapping) throws OpenRoadmInterfaceException { + if (mapping.getSupportingOts() == null) { + // Create generic interface + InterfaceBuilder otsInterfaceBldr = createGenericInterfaceBuilder(mapping, OpticalTransport.class, "OTS-" + + mapping.getLogicalConnectionPoint()); + // OTS interface augmentation specific data + OtsBuilder otsIfBuilder = new OtsBuilder(); + otsIfBuilder.setFiberType(OtsAttributes.FiberType.Smf); + + // Create Interface1 type object required for adding as + // augmentation + org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev161014 + .Interface1Builder otsIf1Builder = new org.opendaylight.yang.gen.v1.http.org.openroadm + .optical.transport.interfaces.rev161014.Interface1Builder(); + otsInterfaceBldr.addAugmentation( + org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev161014 + .Interface1.class, + otsIf1Builder.setOts(otsIfBuilder.build()).build()); + this.openRoadmInterfaces.postInterface(nodeId, otsInterfaceBldr); + this.portMapping.updateMapping(nodeId, mapping); + return otsInterfaceBldr.build().getName(); + } else { + return mapping.getSupportingOts(); + } + } +} diff --git a/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterface22.java b/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterface22.java new file mode 100644 index 000000000..bf63ecdbf --- /dev/null +++ b/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterface22.java @@ -0,0 +1,362 @@ +/* + * Copyright © 2017 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.math.BigDecimal; +import java.util.ArrayList; +import java.util.List; + +import org.opendaylight.transportpce.common.fixedflex.FixedFlexInterface; +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.rev170228.network.nodes.Mapping; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev171215.FrequencyGHz; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev171215.FrequencyTHz; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev171215.ModulationFormat; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev171215.PowerDBm; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev171215.R100G; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev171215.interfaces.grp.InterfaceBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev171215.interfaces.grp.InterfaceKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev171215.AdminStates; +import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev171215.EthAttributes; +import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev171215.Interface1; +import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev171215.Interface1Builder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev171215.ethernet.container.EthernetBuilder; +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.MediaChannelTrailTerminationPoint; +import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.NetworkMediaChannelConnectionTerminationPoint; +import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.OpenROADMOpticalMultiplex; +import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.OpticalChannel; +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.interfaces.rev170626.OtnOtu; +import org.opendaylight.yang.gen.v1.http.org.openroadm.media.channel.interfaces.rev171215.mc.ttp.container.McTtpBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.media.channel.interfaces.rev171215.nmc.ctp.container.NmcCtpBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev171215.och.container.OchBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev171215.OtsAttributes; +import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev171215.ots.container.OtsBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.ODU4; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.OTU4; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.PayloadTypeDef; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev171215.OduAttributes; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev171215.odu.container.OduBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev171215.opu.OpuBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev171215.OtuAttributes; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev171215.otu.container.OtuBuilder; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + + + +public class OpenRoadmInterface22 { + private final PortMapping portMapping; + private final OpenRoadmInterfaces openRoadmInterfaces; + private FixedFlexInterface fixedFlex; + private static final Logger LOG = LoggerFactory.getLogger(OpenRoadmInterfaceFactory.class); + + public OpenRoadmInterface22(PortMapping portMapping, OpenRoadmInterfaces openRoadmInterfaces, + FixedFlexInterface fixedFlex) { + this.portMapping = portMapping; + this.openRoadmInterfaces = openRoadmInterfaces; + this.fixedFlex = fixedFlex; + } + + public String createOpenRoadmEthInterface(String nodeId, + String logicalConnPoint) throws OpenRoadmInterfaceException { + Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint); + if (portMap == null) { + throw new OpenRoadmInterfaceException(String.format("Unable to get mapping from PortMapping for node % and" + + " logical connection port %s", nodeId, logicalConnPoint)); + } + + // Ethernet interface specific data + EthernetBuilder ethIfBuilder = new EthernetBuilder(); + ethIfBuilder.setAutoNegotiation(EthAttributes.AutoNegotiation.Enabled); + ethIfBuilder.setDuplex(EthAttributes.Duplex.Full); + ethIfBuilder.setFec(EthAttributes.Fec.Off); + ethIfBuilder.setSpeed(100000L); + ethIfBuilder.setMtu(9000L); + + InterfaceBuilder ethInterfaceBldr = createGenericInterfaceBuilder(portMap, EthernetCsmacd.class, + logicalConnPoint + "-ETHERNET"); + // Create Interface1 type object required for adding as augmentation + Interface1Builder ethIf1Builder = new Interface1Builder(); + ethInterfaceBldr.addAugmentation(Interface1.class, ethIf1Builder.setEthernet(ethIfBuilder.build()).build()); + + // Post interface on the device + openRoadmInterfaces.postInterface(nodeId, ethInterfaceBldr); + return ethInterfaceBldr.getName(); + } + + /** + * This methods creates an OCH interface on the given termination point on + * Roadm. + * + * @param waveNumber wavelength number of the OCH interface. + * @return Name of the interface if successful, otherwise return null. + */ + + public List createFlexOCH(String nodeId, String logicalConnPoint, Long waveNumber) + throws OpenRoadmInterfaceException { + + List interfacesCreated = new ArrayList<>(); + + String nmcInterfaceCreated = createNMCInterface(nodeId,logicalConnPoint,waveNumber); + interfacesCreated.add(nmcInterfaceCreated); + + String mcInterfaceCreated = createMCInterface(nodeId, logicalConnPoint, waveNumber); + interfacesCreated.add(mcInterfaceCreated); + + return interfacesCreated; + } + + public String createMCInterface(String nodeId, String logicalConnPoint, Long waveNumber) + throws OpenRoadmInterfaceException { + + //TODO : Check this method + + fixedFlex = fixedFlex.getFixedFlexWaveMapping(waveNumber.shortValue()); + + Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint); + if (portMap == null) { + throw new OpenRoadmInterfaceException(String.format("Unable to get mapping from PortMapping for node % and" + + " logical connection port %s", nodeId, logicalConnPoint)); + } + + //TODO : Check this method + + InterfaceBuilder mcInterfaceBldr = createGenericInterfaceBuilder(portMap, + MediaChannelTrailTerminationPoint.class, logicalConnPoint + "-mc"); + mcInterfaceBldr.setSupportingInterface(portMap.getSupportingOms()); + + McTtpBuilder mcTtpBuilder = new McTtpBuilder(); + mcTtpBuilder.setMinFreq(FrequencyTHz.getDefaultInstance(String.valueOf(fixedFlex.getStart()))); + mcTtpBuilder.setMaxFreq(FrequencyTHz.getDefaultInstance(String.valueOf(fixedFlex.getStop()))); + + // Create Interface1 type object required for adding as augmentation + org.opendaylight.yang.gen.v1.http.org.openroadm.media.channel.interfaces.rev171215.Interface1Builder + interface1Builder = new org.opendaylight.yang.gen.v1.http.org.openroadm.media.channel + .interfaces.rev171215.Interface1Builder(); + interface1Builder.setMcTtp(mcTtpBuilder.build()); + mcInterfaceBldr.addAugmentation(org.opendaylight.yang.gen.v1.http.org.openroadm.media.channel + .interfaces.rev171215.Interface1.class,interface1Builder.build()); + + // Post interface on the device + openRoadmInterfaces.postInterface(nodeId, mcInterfaceBldr); + return mcInterfaceBldr.getName(); + } + + public String createNMCInterface(String nodeId, String logicalConnPoint, Long waveNumber) + throws OpenRoadmInterfaceException { + + //TODO : Check this method + + fixedFlex = fixedFlex.getFixedFlexWaveMapping(waveNumber.shortValue()); + + Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint); + if (portMap == null) { + throw new OpenRoadmInterfaceException(String.format("Unable to get mapping from PortMapping for node % and" + + " logical connection port %s", nodeId, logicalConnPoint)); + } + + //TODO : Check this method + InterfaceBuilder nmcInterfaceBldr = createGenericInterfaceBuilder(portMap, + NetworkMediaChannelConnectionTerminationPoint.class, logicalConnPoint + "-nmc"); + nmcInterfaceBldr.setSupportingInterface(logicalConnPoint + "-mc"); + + NmcCtpBuilder nmcCtpIfBuilder = new NmcCtpBuilder(); + + nmcCtpIfBuilder.setFrequency(FrequencyTHz.getDefaultInstance(String.valueOf(fixedFlex.getCenterFrequency()))); + nmcCtpIfBuilder.setWidth(FrequencyGHz.getDefaultInstance(String.valueOf(fixedFlex.getWavelength()))); + + // Create Interface1 type object required for adding as augmentation + org.opendaylight.yang.gen.v1.http.org.openroadm.network.media.channel.interfaces.rev171215 + .Interface1Builder nmcCtpI1fBuilder = new org.opendaylight.yang.gen.v1.http + .org.openroadm.network.media.channel.interfaces.rev171215.Interface1Builder(); + nmcCtpI1fBuilder.setNmcCtp(nmcCtpIfBuilder.build()); + nmcInterfaceBldr.addAugmentation(org.opendaylight.yang.gen.v1.http.org.openroadm.network + .media.channel.interfaces.rev171215.Interface1.class,nmcCtpI1fBuilder.build()); + + // Post interface on the device + openRoadmInterfaces.postInterface(nodeId, nmcInterfaceBldr); + return nmcInterfaceBldr.getName(); + } + + public String createOpenRoadmOchInterface(String nodeId, String logicalConnPoint, Long waveNumber) + throws OpenRoadmInterfaceException { + //TODO : Check this method + + fixedFlex = fixedFlex.getFixedFlexWaveMapping(waveNumber.shortValue()); + + Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint); + if (portMap == null) { + throw new OpenRoadmInterfaceException(String.format("Unable to get mapping from PortMapping for node %s and" + + " logical connection port %s", nodeId, logicalConnPoint)); + } + + // OCH interface specific data + OchBuilder ocIfBuilder = new OchBuilder(); + + ocIfBuilder.setFrequency(FrequencyTHz.getDefaultInstance(String.valueOf(fixedFlex.getCenterFrequency()))); + ocIfBuilder.setWidth(FrequencyGHz.getDefaultInstance(String.valueOf(fixedFlex.getWavelength()))); + ocIfBuilder.setModulationFormat(ModulationFormat.DpQpsk); + ocIfBuilder.setRate(R100G.class); + ocIfBuilder.setTransmitPower(new PowerDBm(new BigDecimal("-5"))); + + // Create generic interface + InterfaceBuilder ochInterfaceBldr = createGenericInterfaceBuilder(portMap, OpticalChannel.class, + createOpenRoadmOchInterfaceName(logicalConnPoint, waveNumber)); + // Create Interface1 type object required for adding as augmentation + // TODO look at imports of different versions of class + org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev171215.Interface1Builder + ochIf1Builder = new org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces + .rev171215.Interface1Builder(); + ochInterfaceBldr.addAugmentation( + org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev171215.Interface1.class, + ochIf1Builder.setOch(ocIfBuilder.build()).build()); + + // Post interface on the device + openRoadmInterfaces.postInterface(nodeId, ochInterfaceBldr); + return ochInterfaceBldr.getName(); + } + + public String createOpenRoadmOdu4Interface(String nodeId, String logicalConnPoint, String supportingOtuInterface) + throws OpenRoadmInterfaceException { + Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint); + if (portMap == null) { + throw new OpenRoadmInterfaceException(String.format("Unable to get mapping from PortMapping for node % and" + + " logical connection port %s", nodeId, logicalConnPoint)); + } + InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(portMap, OtnOdu.class, + logicalConnPoint + "-ODU"); + oduInterfaceBldr.setSupportingInterface(supportingOtuInterface); + + // ODU interface specific data + OduBuilder oduIfBuilder = new OduBuilder(); + oduIfBuilder.setRate(ODU4.class); + oduIfBuilder.setMonitoringMode(OduAttributes.MonitoringMode.Terminated); + + //Set Opu attributes + OpuBuilder opuBldr = new OpuBuilder(); + opuBldr.setPayloadType(PayloadTypeDef.getDefaultInstance("07")); + opuBldr.setExpPayloadType(PayloadTypeDef.getDefaultInstance("07")); + oduIfBuilder.setOpu(opuBldr.build()); + + + // Create Interface1 type object required for adding as augmentation + // TODO look at imports of different versions of class + org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev171215.Interface1Builder oduIf1Builder = + new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev171215.Interface1Builder(); + oduInterfaceBldr.addAugmentation( + org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev171215.Interface1.class, + oduIf1Builder.setOdu(oduIfBuilder.build()).build()); + + // Post interface on the device + openRoadmInterfaces.postInterface(nodeId, oduInterfaceBldr); + return oduInterfaceBldr.getName(); + } + + public String createOpenRoadmOtu4Interface(String nodeId, String logicalConnPoint, String supportOchInterface) + throws OpenRoadmInterfaceException { + Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint); + if (portMap == null) { + throw new OpenRoadmInterfaceException(String.format("Unable to get mapping from PortMapping for node % and" + + " logical connection port %s", nodeId, logicalConnPoint)); + } + // Create generic interface + InterfaceBuilder otuInterfaceBldr = createGenericInterfaceBuilder(portMap, OtnOtu.class, + logicalConnPoint + "-OTU"); + otuInterfaceBldr.setSupportingInterface(supportOchInterface); + + // OTU interface specific data + OtuBuilder otuIfBuilder = new OtuBuilder(); + otuIfBuilder.setFec(OtuAttributes.Fec.Scfec); + otuIfBuilder.setRate(OTU4.class); + + // Create Interface1 type object required for adding as augmentation + // TODO look at imports of different versions of class + org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev171215.Interface1Builder otuIf1Builder = + new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev171215.Interface1Builder(); + otuInterfaceBldr.addAugmentation( + org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev171215.Interface1.class, + otuIf1Builder.setOtu(otuIfBuilder.build()).build()); + + // Post interface on the device + openRoadmInterfaces.postInterface(nodeId, otuInterfaceBldr); + return otuInterfaceBldr.getName(); + } + + public String createOpenRoadmOchInterfaceName(String logicalConnectionPoint, Long waveNumber) { + return logicalConnectionPoint + "-" + waveNumber; + } + + private InterfaceBuilder createGenericInterfaceBuilder(Mapping portMap, Class type, + String key) { + InterfaceBuilder interfaceBuilder = new InterfaceBuilder(); + interfaceBuilder.setDescription(" TBD "); + interfaceBuilder.setCircuitId(" TBD "); + interfaceBuilder.setSupportingCircuitPackName(portMap.getSupportingCircuitPackName()); + interfaceBuilder.setSupportingPort(portMap.getSupportingPort()); + interfaceBuilder.setAdministrativeState(AdminStates.InService); + interfaceBuilder.setType(type); + interfaceBuilder.setName(key); + interfaceBuilder.withKey(new InterfaceKey(key)); + return interfaceBuilder; + } + + public String createOpenRoadmOmsInterface(String nodeId, Mapping mapping) throws OpenRoadmInterfaceException { + if (mapping.getSupportingOms() == null) { + // Create generic interface + InterfaceBuilder omsInterfaceBldr = createGenericInterfaceBuilder(mapping, OpenROADMOpticalMultiplex.class, + "OMS-" + mapping.getLogicalConnectionPoint()); + if (mapping.getSupportingOts() != null) { + omsInterfaceBldr.setSupportingInterface(mapping.getSupportingOts()); + } else { + LOG.error("Unable to get ots interface from mapping {} - {}", nodeId, + mapping.getLogicalConnectionPoint()); + return null; + } + this.openRoadmInterfaces.postInterface(nodeId, omsInterfaceBldr); + this.portMapping.updateMapping(nodeId, mapping); + return omsInterfaceBldr.build().getName(); + } else { + return mapping.getSupportingOms(); + } + } + + public String createOpenRoadmOtsInterface(String nodeId, Mapping mapping) throws OpenRoadmInterfaceException { + if (mapping.getSupportingOts() == null) { + // Create generic interface + InterfaceBuilder otsInterfaceBldr = createGenericInterfaceBuilder(mapping, OpticalTransport.class, "OTS-" + + mapping.getLogicalConnectionPoint()); + // OTS interface augmentation specific data + OtsBuilder otsIfBuilder = new OtsBuilder(); + otsIfBuilder.setFiberType(OtsAttributes.FiberType.Smf); + + // Create Interface1 type object required for adding as + // augmentation + org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev171215 + .Interface1Builder otsIf1Builder = new org.opendaylight.yang.gen.v1.http.org + .openroadm.optical.transport + .interfaces.rev171215.Interface1Builder(); + otsInterfaceBldr.addAugmentation( + org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev171215 + .Interface1.class, + otsIf1Builder.setOts(otsIfBuilder.build()).build()); + this.openRoadmInterfaces.postInterface(nodeId, otsInterfaceBldr); + this.portMapping.updateMapping(nodeId, mapping); + return otsInterfaceBldr.build().getName(); + } else { + return mapping.getSupportingOts(); + } + } + +} 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 70abad7dc..51a4e102d 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 @@ -8,318 +8,145 @@ package org.opendaylight.transportpce.renderer.openroadminterface; -import java.math.BigDecimal; -import org.opendaylight.transportpce.common.mapping.PortMapping; +import java.util.List; + +import org.opendaylight.transportpce.common.StringConstants; +import org.opendaylight.transportpce.common.mapping.MappingUtils; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException; -import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces; -import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl; import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev170228.network.nodes.Mapping; -import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev161014.PowerDBm; -import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.InterfaceBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.InterfaceKey; -import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev161014.AdminStates; -import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev161014.EthAttributes; -import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev161014.Interface1; -import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev161014.Interface1Builder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev161014.ethernet.container.EthernetBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev161014.EthernetCsmacd; -import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev161014.InterfaceType; -import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev161014.OpenROADMOpticalMultiplex; -import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev161014.OpticalChannel; -import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev161014.OpticalTransport; -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.och.container.OchBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev161014.OtsAttributes.FiberType; -import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev161014.ots.container.OtsBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev161014.ODU4; -import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev161014.OduAttributes; -import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev161014.odu.container.OduBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev161014.opu.OpuBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev161014.OTU4; -import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev161014.OtuAttributes; -import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev161014.otu.container.OtuBuilder; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; public class OpenRoadmInterfaceFactory { - private final PortMapping portMapping; - private final OpenRoadmInterfaces openRoadmInterfaces; - private static final Logger LOG = LoggerFactory.getLogger(OpenRoadmInterfaceFactory.class); - - public OpenRoadmInterfaceFactory(PortMapping portMapping, OpenRoadmInterfaces openRoadmInterfaces) { - this.portMapping = portMapping; - this.openRoadmInterfaces = openRoadmInterfaces; - } - - public String createOpenRoadmEthInterface(String nodeId, String logicalConnPoint) - throws OpenRoadmInterfaceException { - Mapping portMap = this.portMapping.getMapping(nodeId, logicalConnPoint); - if (portMap == null) { - throw new OpenRoadmInterfaceException(String.format("Unable to get mapping from PortMapping for node % and" - + " logical connection port %s", nodeId, logicalConnPoint)); - } - - // Ethernet interface specific data - EthernetBuilder ethIfBuilder = new EthernetBuilder(); - ethIfBuilder.setAutoNegotiation(EthAttributes.AutoNegotiation.Enabled); - ethIfBuilder.setDuplex(EthAttributes.Duplex.Full); - ethIfBuilder.setFec(EthAttributes.Fec.Off); - ethIfBuilder.setSpeed(100000L); - ethIfBuilder.setMtu(9000L); - InterfaceBuilder ethInterfaceBldr = createGenericInterfaceBuilder(portMap, EthernetCsmacd.class, - logicalConnPoint + "-ETHERNET"); + private final MappingUtils mappingUtils; + private final OpenRoadmInterface121 openRoadmInterface121; + private final OpenRoadmInterface22 openRoadmInterface22; - // Create Interface1 type object required for adding as augmentation - Interface1Builder ethIf1Builder = new Interface1Builder(); - ethInterfaceBldr.addAugmentation(Interface1.class, ethIf1Builder.setEthernet(ethIfBuilder.build()).build()); - // Post interface on the device - this.openRoadmInterfaces.postInterface(nodeId, ethInterfaceBldr); + public OpenRoadmInterfaceFactory(MappingUtils mappingUtils, OpenRoadmInterface121 openRoadmInterface121, + OpenRoadmInterface22 openRoadmInterface22) { + this.mappingUtils = mappingUtils; + this.openRoadmInterface121 = openRoadmInterface121; + this.openRoadmInterface22 = openRoadmInterface22; + } - // Post the equipment-state change on the device circuit-pack - this.openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true); + public String createOpenRoadmEthInterface(String nodeId, + String logicalConnPoint) throws OpenRoadmInterfaceException { - return ethInterfaceBldr.getName(); + switch (mappingUtils.getOpenRoadmVersion(nodeId)) { + case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1: + return openRoadmInterface121.createOpenRoadmEthInterface(nodeId, logicalConnPoint); + case StringConstants.OPENROADM_DEVICE_VERSION_2_2: + return openRoadmInterface22.createOpenRoadmEthInterface(nodeId, logicalConnPoint); + default: + return null; + } } + /** * This methods creates an OCH interface on the given termination point on * Roadm. * - * @param nodeId node ID - * @param logicalConnPoint logical Connection Point - * @param waveNumber wavelength number of the OCH interface - * + * @param waveNumber wavelength number of the OCH interface. * @return Name of the interface if successful, otherwise return null. - * @throws OpenRoadmInterfaceException OpenRoadmInterfaceException */ - public String createOpenRoadmOchInterface(String nodeId, String logicalConnPoint, Long waveNumber) + public List createOpenRoadmOchInterface(String nodeId, String logicalConnPoint, Long waveNumber) 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" - + " logical connection port %s", nodeId, logicalConnPoint)); - } - // Create generic interface - InterfaceBuilder ochInterfaceBldr = createGenericInterfaceBuilder(portMap, OpticalChannel.class, - createOpenRoadmOchInterfaceName(logicalConnPoint, waveNumber)); - - // OCH interface specific data - OchBuilder ocIfBuilder = new OchBuilder(); - ocIfBuilder.setWavelengthNumber(waveNumber); - // Add supporting OMS interface - if (portMap.getSupportingOms() != null) { - ochInterfaceBldr.setSupportingInterface(portMap.getSupportingOms()); - } - // Create Interface1 type object required for adding as augmentation - // TODO look at imports of different versions of class - org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev161014 - .Interface1Builder ochIf1Builder = new org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel - .interfaces.rev161014.Interface1Builder(); - ochInterfaceBldr.addAugmentation( - org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev161014.Interface1.class, - ochIf1Builder.setOch(ocIfBuilder.build()).build()); - - // Post interface on the device - this.openRoadmInterfaces.postInterface(nodeId, ochInterfaceBldr); - - // Post the equipment-state change on the device circuit-pack if xpdr node - if (portMap.getLogicalConnectionPoint().contains(OpenRoadmInterfacesImpl.NETWORK_TOKEN)) { - this.openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true); + switch (mappingUtils.getOpenRoadmVersion(nodeId)) { + case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1: + return openRoadmInterface121.createOpenRoadmOchInterface(nodeId, logicalConnPoint,waveNumber); + case StringConstants.OPENROADM_DEVICE_VERSION_2_2: + return openRoadmInterface22.createFlexOCH(nodeId, logicalConnPoint,waveNumber); + default: + return null; } - return ochInterfaceBldr.getName(); } - public String createOpenRoadmOchInterface(String nodeId, String logicalConnPoint, Long waveNumber, Class< - ? extends RateIdentity> rate, 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" - + " logical connection port %s", nodeId, logicalConnPoint)); - } - - // OCH interface specific data - OchBuilder ocIfBuilder = new OchBuilder(); - ocIfBuilder.setWavelengthNumber(waveNumber); - ocIfBuilder.setModulationFormat(format); - ocIfBuilder.setRate(rate); - ocIfBuilder.setTransmitPower(new PowerDBm(new BigDecimal("-5"))); - - // Create Interface1 type object required for adding as augmentation - // TODO look at imports of different versions of class - org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev161014 - .Interface1Builder ochIf1Builder = new org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel - .interfaces.rev161014.Interface1Builder(); - // Create generic interface - InterfaceBuilder ochInterfaceBldr = createGenericInterfaceBuilder(portMap, OpticalChannel.class, - createOpenRoadmOchInterfaceName(logicalConnPoint, waveNumber)); - ochInterfaceBldr.addAugmentation( - org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev161014.Interface1.class, - ochIf1Builder.setOch(ocIfBuilder.build()).build()); - // Post interface on the device - this.openRoadmInterfaces.postInterface(nodeId, ochInterfaceBldr); - - // Post the equipment-state change on the device circuit-pack if xpdr node - if (portMap.getLogicalConnectionPoint().contains(OpenRoadmInterfacesImpl.NETWORK_TOKEN)) { - this.openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true); + public String createOpenRoadmOchInterface(String nodeId, String logicalConnPoint, Long waveNumber, + Class rate, OchAttributes.ModulationFormat format) throws OpenRoadmInterfaceException { + switch (mappingUtils.getOpenRoadmVersion(nodeId)) { + case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1: + return openRoadmInterface121.createOpenRoadmOchInterface(nodeId, logicalConnPoint, waveNumber, + rate, format); + case StringConstants.OPENROADM_DEVICE_VERSION_2_2: + return openRoadmInterface22.createOpenRoadmOchInterface(nodeId,logicalConnPoint,waveNumber); + default: + return null; } - return ochInterfaceBldr.getName(); - } - - public String createOpenRoadmOchInterfaceName(String logicalConnectionPoint, Long waveNumber) { - return logicalConnectionPoint + "-" + waveNumber; } /** * This methods creates an ODU interface on the given termination point. * - * @param nodeId node ID - * @param logicalConnPoint logical Connection Point - * @param supportingOtuInterface supporting OTU Interface - * * @return Name of the interface if successful, otherwise return null. - * @throws OpenRoadmInterfaceException OpenRoadmInterfaceException */ public String createOpenRoadmOdu4Interface(String nodeId, String logicalConnPoint, String supportingOtuInterface) - throws OpenRoadmInterfaceException { - Mapping portMap = this.portMapping.getMapping(nodeId, logicalConnPoint); - if (portMap == null) { - throw new OpenRoadmInterfaceException(String.format("Unable to get mapping from PortMapping for node % and" - + " logical connection port %s", nodeId, logicalConnPoint)); + throws OpenRoadmInterfaceException { + switch (mappingUtils.getOpenRoadmVersion(nodeId)) { + case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1: + return openRoadmInterface121.createOpenRoadmOdu4Interface(nodeId, logicalConnPoint, + supportingOtuInterface); + case StringConstants.OPENROADM_DEVICE_VERSION_2_2: + return openRoadmInterface22.createOpenRoadmOdu4Interface(nodeId, logicalConnPoint, + supportingOtuInterface); + default: + return null; } - InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(portMap, OtnOdu.class, logicalConnPoint - + "-ODU"); - oduInterfaceBldr.setSupportingInterface(supportingOtuInterface); - - // ODU interface specific data - OduBuilder oduIfBuilder = new OduBuilder(); - oduIfBuilder.setRate(ODU4.class); - oduIfBuilder.setMonitoringMode(OduAttributes.MonitoringMode.Terminated); - - // Set Opu attributes - OpuBuilder opuBldr = new OpuBuilder(); - opuBldr.setPayloadType("07"); - opuBldr.setExpPayloadType("07"); - oduIfBuilder.setOpu(opuBldr.build()); - - // Create Interface1 type object required for adding as augmentation - // TODO look at imports of different versions of class - org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev161014.Interface1Builder oduIf1Builder = - new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev161014.Interface1Builder(); - oduInterfaceBldr.addAugmentation( - org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev161014.Interface1.class, oduIf1Builder - .setOdu(oduIfBuilder.build()).build()); - - // Post interface on the device - this.openRoadmInterfaces.postInterface(nodeId, oduInterfaceBldr); - return oduInterfaceBldr.getName(); } /** * This methods creates an OTU interface on the given termination point. * - * @param nodeId node ID - * @param logicalConnPoint logical Connection Point - * @param supportOchInterface support OCH Interface - * * @return Name of the interface if successful, otherwise return null. - * @throws OpenRoadmInterfaceException OpenRoadmInterfaceException */ public String createOpenRoadmOtu4Interface(String nodeId, String logicalConnPoint, String supportOchInterface) - throws OpenRoadmInterfaceException { - Mapping portMap = this.portMapping.getMapping(nodeId, logicalConnPoint); - if (portMap == null) { - throw new OpenRoadmInterfaceException(String.format("Unable to get mapping from PortMapping for node % and" - + " logical connection port %s", nodeId, logicalConnPoint)); + throws OpenRoadmInterfaceException { + switch (mappingUtils.getOpenRoadmVersion(nodeId)) { + case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1: + return openRoadmInterface121.createOpenRoadmOtu4Interface(nodeId, + logicalConnPoint,supportOchInterface); + case StringConstants.OPENROADM_DEVICE_VERSION_2_2: + return openRoadmInterface22.createOpenRoadmOtu4Interface(nodeId,logicalConnPoint, supportOchInterface); + default: + return null; } - // Create generic interface - InterfaceBuilder otuInterfaceBldr = createGenericInterfaceBuilder(portMap, OtnOtu.class, logicalConnPoint - + "-OTU"); - otuInterfaceBldr.setSupportingInterface(supportOchInterface); - - // OTU interface specific data - OtuBuilder otuIfBuilder = new OtuBuilder(); - otuIfBuilder.setFec(OtuAttributes.Fec.Scfec); - otuIfBuilder.setRate(OTU4.class); - - // Create Interface1 type object required for adding as augmentation - // TODO look at imports of different versions of class - org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev161014.Interface1Builder otuIf1Builder = - new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev161014.Interface1Builder(); - otuInterfaceBldr.addAugmentation( - org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev161014.Interface1.class, otuIf1Builder - .setOtu(otuIfBuilder.build()).build()); - - // Post interface on the device - this.openRoadmInterfaces.postInterface(nodeId, otuInterfaceBldr); - return otuInterfaceBldr.getName(); } - public String createOpenRoadmOtsInterface(String nodeId, Mapping mapping) throws OpenRoadmInterfaceException { - if (mapping.getSupportingOts() == null) { - // Create generic interface - InterfaceBuilder otsInterfaceBldr = createGenericInterfaceBuilder(mapping, OpticalTransport.class, "OTS-" - + mapping.getLogicalConnectionPoint()); - // OTS interface augmentation specific data - OtsBuilder otsIfBuilder = new OtsBuilder(); - otsIfBuilder.setFiberType(FiberType.Smf); - - // Create Interface1 type object required for adding as - // augmentation - org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev161014 - .Interface1Builder otsIf1Builder = new org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport - .interfaces.rev161014.Interface1Builder(); - otsInterfaceBldr.addAugmentation( - org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev161014.Interface1.class, - otsIf1Builder.setOts(otsIfBuilder.build()).build()); - this.openRoadmInterfaces.postInterface(nodeId, otsInterfaceBldr); - this.portMapping.updateMapping(nodeId, mapping); - return otsInterfaceBldr.build().getName(); - } else { - return mapping.getSupportingOts(); - } + public String createOpenRoadmOchInterfaceName(String logicalConnectionPoint, Long waveNumber) { + return logicalConnectionPoint + "-" + waveNumber; } public String createOpenRoadmOmsInterface(String nodeId, Mapping mapping) throws OpenRoadmInterfaceException { - if (mapping.getSupportingOms() == null) { - // Create generic interface - InterfaceBuilder omsInterfaceBldr = createGenericInterfaceBuilder(mapping, OpenROADMOpticalMultiplex.class, - "OMS-" + mapping.getLogicalConnectionPoint()); - if (mapping.getSupportingOts() != null) { - omsInterfaceBldr.setSupportingInterface(mapping.getSupportingOts()); - } else { - LOG.error("Unable to get ots interface from mapping {} - {}", nodeId, - mapping.getLogicalConnectionPoint()); + switch (mappingUtils.getOpenRoadmVersion(nodeId)) { + case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1: + return openRoadmInterface121.createOpenRoadmOmsInterface(nodeId,mapping); + case StringConstants.OPENROADM_DEVICE_VERSION_2_2: + return openRoadmInterface22.createOpenRoadmOmsInterface(nodeId,mapping); + default: return null; - } - this.openRoadmInterfaces.postInterface(nodeId, omsInterfaceBldr); - this.portMapping.updateMapping(nodeId, mapping); - return omsInterfaceBldr.build().getName(); - } else { - return mapping.getSupportingOms(); } } - private InterfaceBuilder createGenericInterfaceBuilder(Mapping portMap, Class type, - String key) { - InterfaceBuilder interfaceBuilder = new InterfaceBuilder(); - interfaceBuilder.setDescription(" TBD "); - interfaceBuilder.setCircuitId(" TBD "); - interfaceBuilder.setSupportingCircuitPackName(portMap.getSupportingCircuitPackName()); - interfaceBuilder.setSupportingPort(portMap.getSupportingPort()); - interfaceBuilder.setAdministrativeState(AdminStates.InService); - interfaceBuilder.setType(type); - interfaceBuilder.setName(key); - interfaceBuilder.withKey(new InterfaceKey(key)); - return interfaceBuilder; + public String createOpenRoadmOtsInterface(String nodeId, Mapping mapping) throws OpenRoadmInterfaceException { + switch (mappingUtils.getOpenRoadmVersion(nodeId)) { + case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1: + return openRoadmInterface121.createOpenRoadmOtsInterface(nodeId,mapping); + case StringConstants.OPENROADM_DEVICE_VERSION_2_2: + return openRoadmInterface22.createOpenRoadmOtsInterface(nodeId,mapping); + default: + return null; + } } + + + + + } 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 ef2cf9a59..239c2762c 100644 --- a/renderer/src/main/java/org/opendaylight/transportpce/renderer/provisiondevice/DeviceRendererServiceImpl.java +++ b/renderer/src/main/java/org/opendaylight/transportpce/renderer/provisiondevice/DeviceRendererServiceImpl.java @@ -27,13 +27,13 @@ import org.opendaylight.controller.md.sal.binding.api.DataBroker; import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction; import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.transportpce.common.StringConstants; import org.opendaylight.transportpce.common.Timeouts; import org.opendaylight.transportpce.common.crossconnect.CrossConnect; import org.opendaylight.transportpce.common.device.DeviceTransactionManager; import org.opendaylight.transportpce.common.mapping.PortMapping; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces; -import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl; import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterfaceFactory; import org.opendaylight.transportpce.renderer.provisiondevice.servicepath.ServiceListTopology; import org.opendaylight.transportpce.renderer.provisiondevice.servicepath.ServicePathDirection; @@ -120,7 +120,7 @@ public class DeviceRendererServiceImpl implements DeviceRendererService { String srcTp = node.getSrcTp(); String destTp = node.getDestTp(); Long waveNumber = input.getWaveNumber(); - if ((destTp != null) && destTp.contains(OpenRoadmInterfacesImpl.NETWORK_TOKEN)) { + if ((destTp != null) && destTp.contains(StringConstants.NETWORK_TOKEN)) { crossConnectFlag++; // create OpenRoadm Xponder Line Interfaces String supportingOchInterface = this.openRoadmInterfaceFactory.createOpenRoadmOchInterface( @@ -132,13 +132,13 @@ public class DeviceRendererServiceImpl implements DeviceRendererService { createdOduInterfaces.add(this.openRoadmInterfaceFactory.createOpenRoadmOdu4Interface(nodeId, destTp, supportingOtuInterface)); } - if ((srcTp != null) && srcTp.contains(OpenRoadmInterfacesImpl.CLIENT_TOKEN)) { + if ((srcTp != null) && srcTp.contains(StringConstants.CLIENT_TOKEN)) { crossConnectFlag++; // create OpenRoadm Xponder Client Interfaces createdEthInterfaces.add( this.openRoadmInterfaceFactory.createOpenRoadmEthInterface(nodeId, srcTp)); } - if ((srcTp != null) && srcTp.contains(OpenRoadmInterfacesImpl.NETWORK_TOKEN)) { + if ((srcTp != null) && srcTp.contains(StringConstants.NETWORK_TOKEN)) { crossConnectFlag++; // create OpenRoadm Xponder Line Interfaces String supportingOchInterface = this.openRoadmInterfaceFactory.createOpenRoadmOchInterface( @@ -150,21 +150,21 @@ public class DeviceRendererServiceImpl implements DeviceRendererService { createdOduInterfaces.add(this.openRoadmInterfaceFactory.createOpenRoadmOdu4Interface(nodeId, srcTp, supportingOtuInterface)); } - if ((destTp != null) && destTp.contains(OpenRoadmInterfacesImpl.CLIENT_TOKEN)) { + if ((destTp != null) && destTp.contains(StringConstants.CLIENT_TOKEN)) { crossConnectFlag++; // create OpenRoadm Xponder Client Interfaces createdEthInterfaces.add( this.openRoadmInterfaceFactory.createOpenRoadmEthInterface(nodeId, destTp)); } - if ((srcTp != null) && (srcTp.contains(OpenRoadmInterfacesImpl.TTP_TOKEN) - || srcTp.contains(OpenRoadmInterfacesImpl.PP_TOKEN))) { - createdOchInterfaces.add( + if ((srcTp != null) && (srcTp.contains(StringConstants.TTP_TOKEN) + || srcTp.contains(StringConstants.PP_TOKEN))) { + createdOchInterfaces.addAll( this.openRoadmInterfaceFactory .createOpenRoadmOchInterface(nodeId, srcTp, waveNumber)); } - if ((destTp != null) && (destTp.contains(OpenRoadmInterfacesImpl.TTP_TOKEN) - || destTp.contains(OpenRoadmInterfacesImpl.PP_TOKEN))) { - createdOchInterfaces.add( + if ((destTp != null) && (destTp.contains(StringConstants.TTP_TOKEN) + || destTp.contains(StringConstants.PP_TOKEN))) { + createdOchInterfaces.addAll( this.openRoadmInterfaceFactory .createOpenRoadmOchInterface(nodeId, destTp, waveNumber)); } @@ -263,26 +263,26 @@ public class DeviceRendererServiceImpl implements DeviceRendererService { } // if the node is currently mounted then proceed. if (this.deviceTransactionManager.isDeviceMounted(nodeId)) { - if (destTp.contains(OpenRoadmInterfacesImpl.NETWORK_TOKEN) - || srcTp.contains(OpenRoadmInterfacesImpl.CLIENT_TOKEN) - || srcTp.contains(OpenRoadmInterfacesImpl.NETWORK_TOKEN) - || destTp.contains(OpenRoadmInterfacesImpl.CLIENT_TOKEN)) { - if (destTp.contains(OpenRoadmInterfacesImpl.NETWORK_TOKEN)) { + if (destTp.contains(StringConstants.NETWORK_TOKEN) + || srcTp.contains(StringConstants.CLIENT_TOKEN) + || srcTp.contains(StringConstants.NETWORK_TOKEN) + || destTp.contains(StringConstants.CLIENT_TOKEN)) { + if (destTp.contains(StringConstants.NETWORK_TOKEN)) { interfacesToDelete.add(destTp + "-ODU"); interfacesToDelete.add(destTp + "-OTU"); interfacesToDelete.add( this.openRoadmInterfaceFactory.createOpenRoadmOchInterfaceName(destTp, waveNumber)); } - if (srcTp.contains(OpenRoadmInterfacesImpl.NETWORK_TOKEN)) { + if (srcTp.contains(StringConstants.NETWORK_TOKEN)) { interfacesToDelete.add(srcTp + "-ODU"); interfacesToDelete.add(srcTp + "-OTU"); interfacesToDelete .add(this.openRoadmInterfaceFactory.createOpenRoadmOchInterfaceName(srcTp, waveNumber)); } - if (srcTp.contains(OpenRoadmInterfacesImpl.CLIENT_TOKEN)) { + if (srcTp.contains(StringConstants.CLIENT_TOKEN)) { interfacesToDelete.add(srcTp + "-ETHERNET"); } - if (destTp.contains(OpenRoadmInterfacesImpl.CLIENT_TOKEN)) { + if (destTp.contains(StringConstants.CLIENT_TOKEN)) { interfacesToDelete.add(destTp + "-ETHERNET"); } } else { diff --git a/renderer/src/main/java/org/opendaylight/transportpce/renderer/provisiondevice/RendererServiceOperations.java b/renderer/src/main/java/org/opendaylight/transportpce/renderer/provisiondevice/RendererServiceOperations.java index 2ba2583d8..b9eb46378 100644 --- a/renderer/src/main/java/org/opendaylight/transportpce/renderer/provisiondevice/RendererServiceOperations.java +++ b/renderer/src/main/java/org/opendaylight/transportpce/renderer/provisiondevice/RendererServiceOperations.java @@ -9,10 +9,12 @@ package org.opendaylight.transportpce.renderer.provisiondevice; import com.google.common.util.concurrent.ListenableFuture; +import org.opendaylight.transportpce.common.OperationResult; import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev171017.ServiceDeleteInput; import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev171017.ServiceDeleteOutput; import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev171017.ServiceImplementationRequestInput; import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev171017.ServiceImplementationRequestOutput; +import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev171016.service.path.PathDescription; public interface RendererServiceOperations { @@ -21,4 +23,8 @@ public interface RendererServiceOperations { ListenableFuture serviceDelete(ServiceDeleteInput input); + OperationResult reserveResource(PathDescription pathDescription); + + OperationResult freeResource(PathDescription pathDescription); + } diff --git a/renderer/src/main/java/org/opendaylight/transportpce/renderer/provisiondevice/RendererServiceOperationsImpl.java b/renderer/src/main/java/org/opendaylight/transportpce/renderer/provisiondevice/RendererServiceOperationsImpl.java index 831efbcd8..c6eabd273 100644 --- a/renderer/src/main/java/org/opendaylight/transportpce/renderer/provisiondevice/RendererServiceOperationsImpl.java +++ b/renderer/src/main/java/org/opendaylight/transportpce/renderer/provisiondevice/RendererServiceOperationsImpl.java @@ -26,9 +26,10 @@ import org.opendaylight.controller.md.sal.binding.api.DataBroker; import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService; import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.transportpce.common.OperationResult; import org.opendaylight.transportpce.common.ResponseCodes; +import org.opendaylight.transportpce.common.StringConstants; import org.opendaylight.transportpce.common.Timeouts; -import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl; import org.opendaylight.transportpce.renderer.ModelMappingUtils; import org.opendaylight.transportpce.renderer.NetworkModelWavelengthService; import org.opendaylight.transportpce.renderer.ServicePathInputData; @@ -109,6 +110,58 @@ public class RendererServiceOperationsImpl implements RendererServiceOperations } } +/* @Override + public ServiceImplementationRequestOutput serviceImplementation(ServiceImplementationRequestInput input) { + LOG.info("Calling service impl request {} {}", input.getServiceName()); + RollbackProcessor rollbackProcessor = new RollbackProcessor(); + + ServicePathInputData servicePathInputDataAtoZ + = ModelMappingUtils.rendererCreateServiceInputAToZ(input.getServiceName(), + input.getPathDescription()); + ServicePathInputData servicePathInputDataZtoA + = ModelMappingUtils.rendererCreateServiceInputZToA(input.getServiceName(), + input.getPathDescription()); + List renderingResults = deviceRendering(rollbackProcessor, servicePathInputDataAtoZ, + servicePathInputDataZtoA); + if (rollbackProcessor.rollbackAllIfNecessary() > 0) { + return ModelMappingUtils.createServiceImplResponse(ResponseCodes.RESPONSE_FAILED, OPERATION_FAILED); + } + + ServicePowerSetupInput olmPowerSetupInputAtoZ = ModelMappingUtils.createServicePowerSetupInput( + renderingResults.get(0).getOlmList(), input); + ServicePowerSetupInput olmPowerSetupInputZtoA = ModelMappingUtils.createServicePowerSetupInput( + renderingResults.get(1).getOlmList(), input); + olmPowerSetup(rollbackProcessor, olmPowerSetupInputAtoZ, olmPowerSetupInputZtoA); + if (rollbackProcessor.rollbackAllIfNecessary() > 0) { + return ModelMappingUtils.createServiceImplResponse(ResponseCodes.RESPONSE_FAILED, OPERATION_FAILED); + } + + // run service activation test twice - once on source node and once on destination node + List nodes = servicePathInputDataAtoZ.getServicePathInput().getNodes(); + Nodes sourceNode = nodes.get(0); + Nodes destNode = nodes.get(nodes.size() - 1); + + String srcNetworkTp; + String dstNetowrkTp; + + if (sourceNode.getDestTp().contains(StringConstants.NETWORK_TOKEN)) { + srcNetworkTp = sourceNode.getDestTp(); + } else { + srcNetworkTp = sourceNode.getSrcTp(); + } + if (destNode.getDestTp().contains(StringConstants.NETWORK_TOKEN)) { + dstNetowrkTp = destNode.getDestTp(); + } else { + dstNetowrkTp = destNode.getSrcTp(); + } + + if (!isServiceActivated(sourceNode.getNodeId(), srcNetworkTp) + || !isServiceActivated(destNode.getNodeId(), dstNetowrkTp)) { + rollbackProcessor.rollbackAll(); + return ModelMappingUtils.createServiceImplResponse(ResponseCodes.RESPONSE_FAILED, OPERATION_FAILED); + } + } */ + @Override public ListenableFuture serviceImplementation(ServiceImplementationRequestInput input) { @@ -149,12 +202,14 @@ public class RendererServiceOperationsImpl implements RendererServiceOperations Nodes destNode = nodes.get(nodes.size() - 1); String srcNetworkTp; String dstNetowrkTp; - if (sourceNode.getDestTp().contains(OpenRoadmInterfacesImpl.NETWORK_TOKEN)) { + //if (sourceNode.getDestTp().contains(OpenRoadmInterfacesImpl.NETWORK_TOKEN)) { + if (sourceNode.getDestTp().contains(StringConstants.NETWORK_TOKEN)) { srcNetworkTp = sourceNode.getDestTp(); } else { srcNetworkTp = sourceNode.getSrcTp(); } - if (destNode.getDestTp().contains(OpenRoadmInterfacesImpl.NETWORK_TOKEN)) { + //if (destNode.getDestTp().contains(OpenRoadmInterfacesImpl.NETWORK_TOKEN)) { + if (destNode.getDestTp().contains(StringConstants.NETWORK_TOKEN)) { dstNetowrkTp = destNode.getDestTp(); } else { dstNetowrkTp = destNode.getSrcTp(); @@ -176,6 +231,30 @@ public class RendererServiceOperationsImpl implements RendererServiceOperations } + @SuppressWarnings("checkstyle:IllegalCatch") + public OperationResult reserveResource(PathDescription pathDescription) { + + try { + LOG.info("Reserving resources in network model"); + networkModelWavelengthService.useWavelengths(pathDescription); + } catch (Exception e) { + LOG.warn("Reserving resources in network model failed"); + return OperationResult.failed("Resources reserve failed in network model"); + } + return OperationResult.ok("Resources reserved successfully in network model"); + } + + @SuppressWarnings("checkstyle:IllegalCatch") + public OperationResult freeResource(PathDescription pathDescription) { + + try { + networkModelWavelengthService.freeWavelengths(pathDescription); + } catch (Exception e) { + return OperationResult.failed("Resources reserve failed in network model"); + } + return OperationResult.ok("Resources reserved successfully in network model"); + } + @Override public ListenableFuture serviceDelete(ServiceDeleteInput input) { String serviceName = input.getServiceName(); diff --git a/renderer/src/main/java/org/opendaylight/transportpce/renderer/provisiondevice/tasks/OlmPowerSetupRollbackTask.java b/renderer/src/main/java/org/opendaylight/transportpce/renderer/provisiondevice/tasks/OlmPowerSetupRollbackTask.java index 7ce0a7a3d..165dc8810 100644 --- a/renderer/src/main/java/org/opendaylight/transportpce/renderer/provisiondevice/tasks/OlmPowerSetupRollbackTask.java +++ b/renderer/src/main/java/org/opendaylight/transportpce/renderer/provisiondevice/tasks/OlmPowerSetupRollbackTask.java @@ -26,7 +26,7 @@ public class OlmPowerSetupRollbackTask extends RollbackTask { private final ServicePowerSetupInput powerSetupInput; public OlmPowerSetupRollbackTask(String id, boolean isRollbackNecessary, TransportpceOlmService olmService, - ServicePowerSetupInput powerSetupInput) { + ServicePowerSetupInput powerSetupInput) { super(id); this.isRollbackNecessary = isRollbackNecessary; this.olmService = olmService; 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 90747b71d..868ebb21c 100644 --- a/renderer/src/main/resources/OSGI-INF/blueprint/renderer-blueprint.xml +++ b/renderer/src/main/resources/OSGI-INF/blueprint/renderer-blueprint.xml @@ -21,13 +21,30 @@ and is available at http://www.eclipse.org/legal/epl-v10.html + + - - - + + + + + + + + + + + + + + + @@ -39,7 +56,7 @@ and is available at http://www.eclipse.org/legal/epl-v10.html - + diff --git a/renderer/src/test/java/org/opendaylight/transportpce/renderer/NetworkModelWaveLengthServiceFreeTest.java b/renderer/src/test/java/org/opendaylight/transportpce/renderer/NetworkModelWaveLengthServiceFreeTest.java index e5c593f86..f3b753d9a 100644 --- a/renderer/src/test/java/org/opendaylight/transportpce/renderer/NetworkModelWaveLengthServiceFreeTest.java +++ b/renderer/src/test/java/org/opendaylight/transportpce/renderer/NetworkModelWaveLengthServiceFreeTest.java @@ -19,6 +19,7 @@ import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.Parameterized; import org.opendaylight.controller.md.sal.binding.api.MountPointService; +import org.opendaylight.transportpce.common.StringConstants; import org.opendaylight.transportpce.common.device.DeviceTransactionManager; import org.opendaylight.transportpce.common.device.DeviceTransactionManagerImpl; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl; @@ -27,25 +28,26 @@ import org.opendaylight.transportpce.renderer.stub.MountPointStub; import org.opendaylight.transportpce.renderer.utils.ServiceDeleteDataUtils; import org.opendaylight.transportpce.renderer.utils.WaveLengthServiceUtils; import org.opendaylight.transportpce.test.AbstractTest; -import org.opendaylight.yang.gen.v1.http.org.openroadm.degree.rev170929.degree.used.wavelengths.UsedWavelengthsBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.Node1; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.Node1Builder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.TerminationPoint1; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.TerminationPoint1Builder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.DegreeAttributesBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.SrgAttributesBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.termination.point.CpAttributesBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.termination.point.CtpAttributesBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.termination.point.PpAttributesBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.termination.point.RxTtpAttributesBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.termination.point.TxTtpAttributesBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.termination.point.XpdrClientAttributesBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.termination.point.XpdrNetworkAttributesBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.termination.point.XpdrPortAttributesBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.termination.point.pp.attributes.UsedWavelengthBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev170929.OpenroadmNodeType; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev170929.OpenroadmTpType; -import org.opendaylight.yang.gen.v1.http.org.openroadm.xponder.rev170929.xpdr.port.connection.attributes.WavelengthBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.degree.rev171215.degree.used.wavelengths.UsedWavelengthsBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.Node1; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.Node1Builder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.TerminationPoint1; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.DegreeAttributes; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.TerminationPoint1Builder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.DegreeAttributesBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.SrgAttributesBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.termination.point.CpAttributesBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.termination.point.CtpAttributesBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.termination.point.PpAttributesBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.termination.point.RxTtpAttributesBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.termination.point.TxTtpAttributesBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.termination.point.XpdrClientAttributesBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.termination.point.XpdrNetworkAttributesBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.termination.point.XpdrPortAttributesBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.termination.point.pp.attributes.UsedWavelengthBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev171215.OpenroadmNodeType; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev171215.OpenroadmTpType; +import org.opendaylight.yang.gen.v1.http.org.openroadm.xponder.rev171215.xpdr.port.connection.attributes.WavelengthBuilder; import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev171017.PathDescription; @RunWith(Parameterized.class) @@ -70,13 +72,13 @@ public class NetworkModelWaveLengthServiceFreeTest extends AbstractTest { List parameters = new ArrayList<>(); PathDescription pathDescription = - ServiceDeleteDataUtils.createTransactionPathDescription(OpenRoadmInterfacesImpl.TTP_TOKEN); + ServiceDeleteDataUtils.createTransactionPathDescription(StringConstants.TTP_TOKEN); TerminationPoint1Builder terminationPoint1Builder = new TerminationPoint1Builder(); terminationPoint1Builder.setCtpAttributes((new CtpAttributesBuilder()).setUsedWavelengths(Collections .singletonList((new UsedWavelengthsBuilder()).setIndex(WAVE_LENGTH).build())).build()); terminationPoint1Builder.setCpAttributes((new CpAttributesBuilder()).setUsedWavelengths(Collections - .singletonList((new org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network + .singletonList((new org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network .node.termination.point.cp.attributes.UsedWavelengthsBuilder()) .setIndex(WAVE_LENGTH).build())).build()); terminationPoint1Builder.setTxTtpAttributes((new TxTtpAttributesBuilder()).setUsedWavelengths(Collections @@ -130,17 +132,17 @@ public class NetworkModelWaveLengthServiceFreeTest extends AbstractTest { @Test public void freeWavelengthsTest() throws ExecutionException, InterruptedException { - WaveLengthServiceUtils.putTerminationPoint1ToDatastore("node1" + OpenRoadmInterfacesImpl.TTP_TOKEN, - OpenRoadmInterfacesImpl.TTP_TOKEN, + WaveLengthServiceUtils.putTerminationPoint1ToDatastore("node1" + StringConstants.TTP_TOKEN, + StringConstants.TTP_TOKEN, this.terminationPoint1, this.deviceTransactionManager); - WaveLengthServiceUtils.putNode1ToDatastore("node1" + OpenRoadmInterfacesImpl.TTP_TOKEN, this.node1, + WaveLengthServiceUtils.putNode1ToDatastore("node1" + StringConstants.TTP_TOKEN, this.node1, this.deviceTransactionManager); this.networkModelWavelengthService.freeWavelengths(this.pathDescription); - Node1 updatedNode1 = WaveLengthServiceUtils.getNode1FromDatastore("node1" + OpenRoadmInterfacesImpl.TTP_TOKEN, + Node1 updatedNode1 = WaveLengthServiceUtils.getNode1FromDatastore("node1" + StringConstants.TTP_TOKEN, this.deviceTransactionManager); TerminationPoint1 updatedTerminationPoint1 = - WaveLengthServiceUtils.getTerminationPoint1FromDatastore("node1" + OpenRoadmInterfacesImpl.TTP_TOKEN, - OpenRoadmInterfacesImpl.TTP_TOKEN, this.deviceTransactionManager); + WaveLengthServiceUtils.getTerminationPoint1FromDatastore("node1" + StringConstants.TTP_TOKEN, + StringConstants.TTP_TOKEN, this.deviceTransactionManager); switch (updatedTerminationPoint1.getTpType()) { case DEGREETXRXCTP: case DEGREETXCTP: diff --git a/renderer/src/test/java/org/opendaylight/transportpce/renderer/NetworkModelWaveLengthServiceUseTest.java b/renderer/src/test/java/org/opendaylight/transportpce/renderer/NetworkModelWaveLengthServiceUseTest.java index bbe3c914e..fe08e9883 100644 --- a/renderer/src/test/java/org/opendaylight/transportpce/renderer/NetworkModelWaveLengthServiceUseTest.java +++ b/renderer/src/test/java/org/opendaylight/transportpce/renderer/NetworkModelWaveLengthServiceUseTest.java @@ -19,6 +19,7 @@ import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.Parameterized; import org.opendaylight.controller.md.sal.binding.api.MountPointService; +import org.opendaylight.transportpce.common.StringConstants; import org.opendaylight.transportpce.common.device.DeviceTransactionManager; import org.opendaylight.transportpce.common.device.DeviceTransactionManagerImpl; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl; @@ -27,23 +28,23 @@ import org.opendaylight.transportpce.renderer.stub.MountPointStub; import org.opendaylight.transportpce.renderer.utils.ServiceDeleteDataUtils; import org.opendaylight.transportpce.renderer.utils.WaveLengthServiceUtils; import org.opendaylight.transportpce.test.AbstractTest; -import org.opendaylight.yang.gen.v1.http.org.openroadm.degree.rev170929.degree.node.attributes.AvailableWavelengthsBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.Node1; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.Node1Builder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.TerminationPoint1; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.TerminationPoint1Builder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.DegreeAttributesBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.SrgAttributesBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.termination.point.CpAttributesBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.termination.point.CtpAttributesBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.termination.point.PpAttributesBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.termination.point.RxTtpAttributesBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.termination.point.TxTtpAttributesBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.termination.point.XpdrClientAttributesBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.termination.point.XpdrNetworkAttributesBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.termination.point.XpdrPortAttributesBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev170929.OpenroadmNodeType; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev170929.OpenroadmTpType; +import org.opendaylight.yang.gen.v1.http.org.openroadm.degree.rev171215.degree.node.attributes.AvailableWavelengthsBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.Node1; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.Node1Builder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.TerminationPoint1; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.TerminationPoint1Builder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.DegreeAttributesBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.SrgAttributesBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.termination.point.CpAttributesBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.termination.point.CtpAttributesBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.termination.point.PpAttributesBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.termination.point.RxTtpAttributesBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.termination.point.TxTtpAttributesBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.termination.point.XpdrClientAttributesBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.termination.point.XpdrNetworkAttributesBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.network.node.termination.point.XpdrPortAttributesBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev171215.OpenroadmNodeType; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev171215.OpenroadmTpType; import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev171016.service.path.PathDescription; @RunWith(Parameterized.class) @@ -75,7 +76,7 @@ public class NetworkModelWaveLengthServiceUseTest extends AbstractTest { List parameters = new ArrayList<>(); PathDescription pathDescription = - ServiceDeleteDataUtils.createTransactionPathDescription(OpenRoadmInterfacesImpl.TTP_TOKEN); + ServiceDeleteDataUtils.createTransactionPathDescription(StringConstants.TTP_TOKEN); TerminationPoint1Builder terminationPoint1Builder = new TerminationPoint1Builder(); terminationPoint1Builder @@ -97,7 +98,7 @@ public class NetworkModelWaveLengthServiceUseTest extends AbstractTest { .setAvailableWavelengths(Collections.singletonList(new AvailableWavelengthsBuilder().setIndex(20L).build())) .build()); node1Builder.setSrgAttributes((new SrgAttributesBuilder()).setAvailableWavelengths(Collections.singletonList( - new org.opendaylight.yang.gen.v1.http.org.openroadm.srg.rev170929.srg.node.attributes + new org.opendaylight.yang.gen.v1.http.org.openroadm.srg.rev171215.srg.node.attributes .AvailableWavelengthsBuilder().setIndex(20L).build())).build()); for (OpenroadmNodeType nodeType : Arrays @@ -119,17 +120,17 @@ public class NetworkModelWaveLengthServiceUseTest extends AbstractTest { @Test public void freeWavelengthsTest() throws ExecutionException, InterruptedException { WaveLengthServiceUtils - .putTerminationPoint1ToDatastore("node1" + OpenRoadmInterfacesImpl.TTP_TOKEN, - OpenRoadmInterfacesImpl.TTP_TOKEN, + .putTerminationPoint1ToDatastore("node1" + StringConstants.TTP_TOKEN, + StringConstants.TTP_TOKEN, this.terminationPoint1, this.deviceTransactionManager); - WaveLengthServiceUtils.putNode1ToDatastore("node1" + OpenRoadmInterfacesImpl.TTP_TOKEN, this.node1, + WaveLengthServiceUtils.putNode1ToDatastore("node1" + StringConstants.TTP_TOKEN, this.node1, this.deviceTransactionManager); this.networkModelWavelengthService.useWavelengths(this.pathDescription); - Node1 updatedNode1 = WaveLengthServiceUtils.getNode1FromDatastore("node1" + OpenRoadmInterfacesImpl.TTP_TOKEN, + Node1 updatedNode1 = WaveLengthServiceUtils.getNode1FromDatastore("node1" + StringConstants.TTP_TOKEN, this.deviceTransactionManager); TerminationPoint1 updatedTerminationPoint1 = WaveLengthServiceUtils - .getTerminationPoint1FromDatastore("node1" + OpenRoadmInterfacesImpl.TTP_TOKEN, - OpenRoadmInterfacesImpl.TTP_TOKEN, + .getTerminationPoint1FromDatastore("node1" + StringConstants.TTP_TOKEN, + StringConstants.TTP_TOKEN, this.deviceTransactionManager); switch (updatedTerminationPoint1.getTpType()) { 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 848981fd2..d9d92d346 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 @@ -15,12 +15,15 @@ import org.junit.Test; import org.mockito.Mockito; import org.opendaylight.controller.md.sal.binding.api.MountPoint; import org.opendaylight.controller.md.sal.binding.api.MountPointService; +import org.opendaylight.transportpce.common.StringConstants; 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.CrossConnectImpl22; import org.opendaylight.transportpce.common.device.DeviceTransactionManager; import org.opendaylight.transportpce.common.device.DeviceTransactionManagerImpl; +import org.opendaylight.transportpce.common.fixedflex.FixedFlexImpl; +import org.opendaylight.transportpce.common.fixedflex.FixedFlexInterface; import org.opendaylight.transportpce.common.mapping.MappingUtils; import org.opendaylight.transportpce.common.mapping.MappingUtilsImpl; import org.opendaylight.transportpce.common.mapping.PortMapping; @@ -32,6 +35,8 @@ import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfa import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl121; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl22; +import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterface121; +import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterface22; import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterfaceFactory; import org.opendaylight.transportpce.renderer.stub.MountPointServiceStub; import org.opendaylight.transportpce.renderer.utils.CreateOtsOmsDataUtils; @@ -61,20 +66,30 @@ public class DeviceRendererServiceImplCreateOtsOmsTest extends AbstractTest { this.openRoadmInterfacesImpl121 = new OpenRoadmInterfacesImpl121(this.deviceTransactionManager); this.openRoadmInterfacesImpl22 = new OpenRoadmInterfacesImpl22(this.deviceTransactionManager); this.mappingUtils = new MappingUtilsImpl(getDataBroker()); + this.mappingUtils = Mockito.spy(MappingUtils.class); + + Mockito.doReturn(StringConstants.OPENROADM_DEVICE_VERSION_1_2_1).when(mappingUtils) + .getOpenRoadmVersion(Mockito.anyString()); this.openRoadmInterfaces = new OpenRoadmInterfacesImpl(deviceTransactionManager, mappingUtils, - openRoadmInterfacesImpl121, openRoadmInterfacesImpl22); + openRoadmInterfacesImpl121, openRoadmInterfacesImpl22); this.openRoadmInterfaces = Mockito.spy(this.openRoadmInterfaces); this.portMappingVersion22 = new PortMappingVersion22(getDataBroker(), this.deviceTransactionManager, - this.openRoadmInterfaces); + this.openRoadmInterfaces); this.portMappingVersion121 = new PortMappingVersion121(getDataBroker(), this.deviceTransactionManager, - this.openRoadmInterfaces); + this.openRoadmInterfaces); PortMapping portMapping = new PortMappingImpl(getDataBroker(), this.portMappingVersion22, this.mappingUtils, - this.portMappingVersion121); - this.openRoadmInterfaceFactory = new OpenRoadmInterfaceFactory(portMapping, this.openRoadmInterfaces); + this.portMappingVersion121); + FixedFlexInterface fixedFlexInterface = new FixedFlexImpl(); + OpenRoadmInterface121 openRoadmInterface121 = new OpenRoadmInterface121(portMapping,openRoadmInterfaces); + OpenRoadmInterface22 openRoadmInterface22 = new OpenRoadmInterface22(portMapping,openRoadmInterfaces, + fixedFlexInterface); + this.openRoadmInterfaceFactory = new OpenRoadmInterfaceFactory(this.mappingUtils,openRoadmInterface121, + openRoadmInterface22); + this.crossConnectImpl121 = new CrossConnectImpl121(this.deviceTransactionManager); this.crossConnectImpl22 = new CrossConnectImpl22(this.deviceTransactionManager); this.crossConnect = new CrossConnectImpl(this.deviceTransactionManager, this.mappingUtils, - this.crossConnectImpl121, this.crossConnectImpl22); + this.crossConnectImpl121, this.crossConnectImpl22); this.crossConnect = Mockito.spy(this.crossConnect); this.deviceRendererService = new DeviceRendererServiceImpl(this.getDataBroker(), this.deviceTransactionManager, this.openRoadmInterfaceFactory, this.openRoadmInterfaces, @@ -88,7 +103,7 @@ public class DeviceRendererServiceImplCreateOtsOmsTest extends AbstractTest { CreateOtsOmsOutput result = this.deviceRendererService.createOtsOms(input); Assert.assertFalse(result.isSuccess()); Assert.assertEquals("node 1 is not mounted on the controller", - result.getResult()); + result.getResult()); } @Test @@ -116,4 +131,4 @@ public class DeviceRendererServiceImplCreateOtsOmsTest extends AbstractTest { ); } -} +} \ No newline at end of file diff --git a/renderer/src/test/java/org/opendaylight/transportpce/renderer/provisiondevice/DeviceRendererServiceImplDeleteTest.java b/renderer/src/test/java/org/opendaylight/transportpce/renderer/provisiondevice/DeviceRendererServiceImplDeleteTest.java index fc6bdf6b0..67a1efa94 100644 --- a/renderer/src/test/java/org/opendaylight/transportpce/renderer/provisiondevice/DeviceRendererServiceImplDeleteTest.java +++ b/renderer/src/test/java/org/opendaylight/transportpce/renderer/provisiondevice/DeviceRendererServiceImplDeleteTest.java @@ -18,12 +18,15 @@ import org.mockito.Mockito; import org.opendaylight.controller.md.sal.binding.api.MountPoint; import org.opendaylight.controller.md.sal.binding.api.MountPointService; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.transportpce.common.StringConstants; 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.CrossConnectImpl22; import org.opendaylight.transportpce.common.device.DeviceTransactionManager; import org.opendaylight.transportpce.common.device.DeviceTransactionManagerImpl; +import org.opendaylight.transportpce.common.fixedflex.FixedFlexImpl; +import org.opendaylight.transportpce.common.fixedflex.FixedFlexInterface; import org.opendaylight.transportpce.common.mapping.MappingUtils; import org.opendaylight.transportpce.common.mapping.MappingUtilsImpl; import org.opendaylight.transportpce.common.mapping.PortMapping; @@ -35,6 +38,8 @@ import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfa import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl121; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl22; +import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterface121; +import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterface22; import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterfaceFactory; import org.opendaylight.transportpce.renderer.stub.MountPointServiceStub; import org.opendaylight.transportpce.renderer.utils.MountPointUtils; @@ -74,19 +79,25 @@ public class DeviceRendererServiceImplDeleteTest extends AbstractTest { this.openRoadmInterfacesImpl22 = new OpenRoadmInterfacesImpl22(this.deviceTransactionManager); this.mappingUtils = new MappingUtilsImpl(getDataBroker()); this.openRoadmInterfaces = new OpenRoadmInterfacesImpl(deviceTransactionManager, mappingUtils, - openRoadmInterfacesImpl121, openRoadmInterfacesImpl22); + openRoadmInterfacesImpl121, openRoadmInterfacesImpl22); this.openRoadmInterfaces = Mockito.spy(this.openRoadmInterfaces); this.portMappingVersion22 = new PortMappingVersion22(getDataBroker(), this.deviceTransactionManager, - this.openRoadmInterfaces); + this.openRoadmInterfaces); this.portMappingVersion121 = new PortMappingVersion121(getDataBroker(), this.deviceTransactionManager, - this.openRoadmInterfaces); + this.openRoadmInterfaces); PortMapping portMapping = new PortMappingImpl(getDataBroker(), this.portMappingVersion22, this.mappingUtils, - this.portMappingVersion121); - this.openRoadmInterfaceFactory = new OpenRoadmInterfaceFactory(portMapping, this.openRoadmInterfaces); + this.portMappingVersion121); + FixedFlexInterface fixedFlexInterface = new FixedFlexImpl(); + OpenRoadmInterface121 openRoadmInterface121 = new OpenRoadmInterface121(portMapping,openRoadmInterfaces); + OpenRoadmInterface22 openRoadmInterface22 = new OpenRoadmInterface22(portMapping,openRoadmInterfaces, + fixedFlexInterface); + this.openRoadmInterfaceFactory = new OpenRoadmInterfaceFactory(this.mappingUtils,openRoadmInterface121, + openRoadmInterface22); + this.crossConnectImpl121 = new CrossConnectImpl121(this.deviceTransactionManager); this.crossConnectImpl22 = new CrossConnectImpl22(this.deviceTransactionManager); this.crossConnect = new CrossConnectImpl(this.deviceTransactionManager, this.mappingUtils, - this.crossConnectImpl121, this.crossConnectImpl22); + this.crossConnectImpl121, this.crossConnectImpl22); this.crossConnect = Mockito.spy(this.crossConnect); this.deviceRendererService = new DeviceRendererServiceImpl(this.getDataBroker(), this.deviceTransactionManager, this.openRoadmInterfaceFactory, this.openRoadmInterfaces, @@ -100,17 +111,17 @@ public class DeviceRendererServiceImplDeleteTest extends AbstractTest { ServicePathOutput servicePathOutput = deviceRendererService.deleteServicePath(servicePathInput); Assert.assertFalse(servicePathOutput.isSuccess()); Assert.assertEquals("node1 is not mounted on the controller", - servicePathOutput.getResult()); + servicePathOutput.getResult()); } @Test public void testDeleteServiceSuccess() throws OpenRoadmInterfaceException { setMountPoint(MountPointUtils.getMountPoint(new ArrayList<>(), getDataBroker())); String [] interfaceTokens = { - OpenRoadmInterfacesImpl.NETWORK_TOKEN, - OpenRoadmInterfacesImpl.CLIENT_TOKEN, - OpenRoadmInterfacesImpl.TTP_TOKEN, - OpenRoadmInterfacesImpl.PP_TOKEN + StringConstants.NETWORK_TOKEN, + StringConstants.CLIENT_TOKEN, + StringConstants.TTP_TOKEN, + StringConstants.PP_TOKEN }; String nodeId = "node1"; @@ -137,12 +148,10 @@ public class DeviceRendererServiceImplDeleteTest extends AbstractTest { public void testDeleteServiceFailure() throws OpenRoadmInterfaceException { setMountPoint(MountPointUtils.getMountPoint(new ArrayList<>(), getDataBroker())); String [] interfaceTokens = { - OpenRoadmInterfacesImpl.NETWORK_TOKEN, - OpenRoadmInterfacesImpl.CLIENT_TOKEN, - OpenRoadmInterfacesImpl.TTP_TOKEN, - OpenRoadmInterfacesImpl.PP_TOKEN - }; - + StringConstants.NETWORK_TOKEN, + StringConstants.CLIENT_TOKEN, + StringConstants.TTP_TOKEN, + StringConstants.PP_TOKEN }; String nodeId = "node1"; Mockito.doReturn(true).when(this.crossConnect).deleteCrossConnect(Mockito.eq(nodeId), Mockito.anyString()); Mockito.doThrow(OpenRoadmInterfaceException.class).when(this.openRoadmInterfaces) @@ -171,11 +180,11 @@ public class DeviceRendererServiceImplDeleteTest extends AbstractTest { String nodeId = "node1"; Mockito.doReturn(false).when(this.crossConnect).deleteCrossConnect(Mockito.eq(nodeId), Mockito.anyString()); Mockito.doThrow(OpenRoadmInterfaceException.class).when(this.openRoadmInterfaces) - .deleteInterface(Mockito.eq(nodeId), Mockito.anyString()); + .deleteInterface(Mockito.eq(nodeId), Mockito.anyString()); List nodes = new ArrayList<>(); nodes.add(ServiceImplementationDataUtils.createNode(nodeId, null, null)); - nodes.add(ServiceImplementationDataUtils.createNode(nodeId, "src-" + OpenRoadmInterfacesImpl.PP_TOKEN, null)); + nodes.add(ServiceImplementationDataUtils.createNode(nodeId, "src-" + StringConstants.PP_TOKEN, null)); ServicePathInput servicePathInput = ServiceImplementationDataUtils.buildServicePathInputs(nodes); ServicePathOutput servicePathOutput = deviceRendererService.deleteServicePath(servicePathInput); @@ -192,8 +201,8 @@ public class DeviceRendererServiceImplDeleteTest extends AbstractTest { Mockito.doReturn(false).when(this.crossConnect).deleteCrossConnect(Mockito.eq(nodeId), Mockito.anyString()); Mockito.doNothing().when(this.openRoadmInterfaces).deleteInterface(Mockito.eq(nodeId), Mockito.anyString()); - String srcTP = "src-" + OpenRoadmInterfacesImpl.TTP_TOKEN; - String dstTp = "dst-" + OpenRoadmInterfacesImpl.PP_TOKEN; + String srcTP = "src-" + StringConstants.TTP_TOKEN; + String dstTp = "dst-" + StringConstants.PP_TOKEN; List nodes = new ArrayList<>(); nodes.add(ServiceImplementationDataUtils.createNode(nodeId, srcTP, dstTp)); @@ -215,8 +224,8 @@ public class DeviceRendererServiceImplDeleteTest extends AbstractTest { Mockito.doThrow(OpenRoadmInterfaceException.class).when(this.openRoadmInterfaces) .deleteInterface(Mockito.eq(nodeId), Mockito.anyString()); - String srcTp = "src-" + OpenRoadmInterfacesImpl.PP_TOKEN; - String dstTp = "dst-" + OpenRoadmInterfacesImpl.TTP_TOKEN; + String srcTp = "src-" + StringConstants.PP_TOKEN; + String dstTp = "dst-" + StringConstants.TTP_TOKEN; Long waveNumber = 20L; String connectionNumber = dstTp + "-" + srcTp + "-" + waveNumber; @@ -229,7 +238,7 @@ public class DeviceRendererServiceImplDeleteTest extends AbstractTest { roadmConnectionsBuilder.setWavelengthNumber(20L); roadmConnectionsBuilder.setDestination((new DestinationBuilder()).setDstIf(interfaceName).build()); InstanceIdentifier xciid = InstanceIdentifier.create(OrgOpenroadmDevice.class) - .child(RoadmConnections.class, new RoadmConnectionsKey(connectionNumber)); + .child(RoadmConnections.class, new RoadmConnectionsKey(connectionNumber)); TransactionUtils.writeTransaction(this.deviceTransactionManager, nodeId, LogicalDatastoreType.CONFIGURATION, xciid, roadmConnectionsBuilder.build()); @@ -241,4 +250,4 @@ public class DeviceRendererServiceImplDeleteTest extends AbstractTest { Assert.assertTrue(servicePathOutput.isSuccess()); Assert.assertEquals("Request processed", servicePathOutput.getResult()); } -} +} \ No newline at end of file diff --git a/renderer/src/test/java/org/opendaylight/transportpce/renderer/provisiondevice/DeviceRendererServiceImplRollbackTest.java b/renderer/src/test/java/org/opendaylight/transportpce/renderer/provisiondevice/DeviceRendererServiceImplRollbackTest.java index 5bdc6770c..3bb72fc34 100644 --- a/renderer/src/test/java/org/opendaylight/transportpce/renderer/provisiondevice/DeviceRendererServiceImplRollbackTest.java +++ b/renderer/src/test/java/org/opendaylight/transportpce/renderer/provisiondevice/DeviceRendererServiceImplRollbackTest.java @@ -23,6 +23,8 @@ import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl121; import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl22; import org.opendaylight.transportpce.common.device.DeviceTransactionManager; import org.opendaylight.transportpce.common.device.DeviceTransactionManagerImpl; +import org.opendaylight.transportpce.common.fixedflex.FixedFlexImpl; +import org.opendaylight.transportpce.common.fixedflex.FixedFlexInterface; import org.opendaylight.transportpce.common.mapping.MappingUtils; import org.opendaylight.transportpce.common.mapping.MappingUtilsImpl; import org.opendaylight.transportpce.common.mapping.PortMapping; @@ -34,6 +36,8 @@ import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfa import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl121; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl22; +import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterface121; +import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterface22; import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterfaceFactory; import org.opendaylight.transportpce.renderer.stub.MountPointServiceStub; import org.opendaylight.transportpce.renderer.stub.MountPointStub; @@ -67,23 +71,29 @@ public class DeviceRendererServiceImplRollbackTest extends AbstractTest { this.mappingUtils = new MappingUtilsImpl(getDataBroker()); this.mappingUtils = Mockito.spy(this.mappingUtils); this.openRoadmInterfaces = new OpenRoadmInterfacesImpl(deviceTransactionManager, mappingUtils, - openRoadmInterfacesImpl121, openRoadmInterfacesImpl22); + openRoadmInterfacesImpl121, openRoadmInterfacesImpl22); this.openRoadmInterfaces = Mockito.spy(this.openRoadmInterfaces); this.portMappingVersion22 = - new PortMappingVersion22(getDataBroker(), deviceTransactionManager, this.openRoadmInterfaces); + new PortMappingVersion22(getDataBroker(), deviceTransactionManager, this.openRoadmInterfaces); this.portMappingVersion121 = new PortMappingVersion121(getDataBroker(), deviceTransactionManager, - this.openRoadmInterfaces); + this.openRoadmInterfaces); this.crossConnectImpl121 = new CrossConnectImpl121(deviceTransactionManager); this.crossConnectImpl22 = new CrossConnectImpl22(deviceTransactionManager); this.crossConnect = new CrossConnectImpl(deviceTransactionManager, this.mappingUtils, this.crossConnectImpl121, - this.crossConnectImpl22); + this.crossConnectImpl22); this.crossConnect = Mockito.spy(this.crossConnect); PortMapping portMapping = new PortMappingImpl(getDataBroker(), this.portMappingVersion22, this.mappingUtils, - this.portMappingVersion121); - OpenRoadmInterfaceFactory openRoadmInterfaceFactory = - new OpenRoadmInterfaceFactory(portMapping, this.openRoadmInterfaces); + this.portMappingVersion121); + FixedFlexInterface fixedFlexInterface = new FixedFlexImpl(); + OpenRoadmInterface121 openRoadmInterface121 = new OpenRoadmInterface121(portMapping,openRoadmInterfaces); + OpenRoadmInterface22 openRoadmInterface22 = new OpenRoadmInterface22(portMapping,openRoadmInterfaces, + fixedFlexInterface); + OpenRoadmInterfaceFactory openRoadmInterfaceFactory = new OpenRoadmInterfaceFactory(this.mappingUtils, + openRoadmInterface121,openRoadmInterface22); + + this.deviceRendererService = new DeviceRendererServiceImpl(this.getDataBroker(), - deviceTransactionManager, openRoadmInterfaceFactory, this.openRoadmInterfaces, this.crossConnect, + deviceTransactionManager, openRoadmInterfaceFactory, this.openRoadmInterfaces, this.crossConnect, portMapping); } @@ -94,7 +104,7 @@ public class DeviceRendererServiceImplRollbackTest extends AbstractTest { setMountPoint(new MountPointStub(getDataBroker())); RendererRollbackInput rendererRollbackInput = ServiceImplementationDataUtils.buildRendererRollbackInput(); RendererRollbackOutput rendererRollbackOutput = - this.deviceRendererService.rendererRollback(rendererRollbackInput); + this.deviceRendererService.rendererRollback(rendererRollbackInput); Assert.assertTrue(rendererRollbackOutput.isSuccess()); Assert.assertTrue(rendererRollbackOutput.getFailedToRollback().isEmpty()); } @@ -114,9 +124,9 @@ public class DeviceRendererServiceImplRollbackTest extends AbstractTest { RendererRollbackInputBuilder rendererRollbackInputBuilder = new RendererRollbackInputBuilder(); rendererRollbackInputBuilder.setNodeInterface(nodeInterfaces); Mockito.doReturn(StringConstants.OPENROADM_DEVICE_VERSION_1_2_1).when(this.mappingUtils) - .getOpenRoadmVersion("node1"); + .getOpenRoadmVersion("node1"); RendererRollbackOutput rendererRollbackOutput = - this.deviceRendererService.rendererRollback(rendererRollbackInputBuilder.build()); + this.deviceRendererService.rendererRollback(rendererRollbackInputBuilder.build()); Assert.assertFalse(rendererRollbackOutput.isSuccess()); Assert.assertEquals(1, rendererRollbackOutput.getFailedToRollback().size()); Assert.assertEquals("node1", rendererRollbackOutput.getFailedToRollback().get(0).getNodeId()); @@ -139,7 +149,7 @@ public class DeviceRendererServiceImplRollbackTest extends AbstractTest { Mockito.doReturn(true).when(this.crossConnect).deleteCrossConnect("node1", connectionID.get(0)); RendererRollbackOutput rendererRollbackOutput = - this.deviceRendererService.rendererRollback(rendererRollbackInputBuilder.build()); + this.deviceRendererService.rendererRollback(rendererRollbackInputBuilder.build()); Assert.assertTrue("Rollback must success when cross connect returns true", rendererRollbackOutput.isSuccess()); Assert.assertEquals(1, rendererRollbackOutput.getFailedToRollback().size()); Assert.assertTrue("There must not be any failed interfaces when cross connect returns true", @@ -147,7 +157,7 @@ public class DeviceRendererServiceImplRollbackTest extends AbstractTest { Mockito.doReturn(false).when(this.crossConnect).deleteCrossConnect("node1", connectionID.get(0)); rendererRollbackOutput = - this.deviceRendererService.rendererRollback(rendererRollbackInputBuilder.build()); + this.deviceRendererService.rendererRollback(rendererRollbackInputBuilder.build()); Assert.assertFalse("Rollback must fail when cross connect returns false",rendererRollbackOutput.isSuccess()); Assert.assertEquals(1, rendererRollbackOutput.getFailedToRollback().size()); Assert.assertFalse(rendererRollbackOutput.getFailedToRollback().get(0).getInterface().isEmpty()); @@ -165,13 +175,13 @@ public class DeviceRendererServiceImplRollbackTest extends AbstractTest { nodeInterfaceBuilder.withKey(new NodeInterfaceKey("node1")); nodeInterfaceBuilder.setConnectionId(new ArrayList<>()); List oduInterfacesId = new ArrayList<>(); - oduInterfacesId.add("node1-" + OpenRoadmInterfacesImpl.NETWORK_TOKEN + "-ODU"); + oduInterfacesId.add("node1-" + StringConstants.NETWORK_TOKEN + "-ODU"); nodeInterfaceBuilder.setOduInterfaceId(oduInterfacesId); List otuInterfacesId = new ArrayList<>(); - otuInterfacesId.add("node1-" + OpenRoadmInterfacesImpl.NETWORK_TOKEN + "-OTU"); + otuInterfacesId.add("node1-" + StringConstants.NETWORK_TOKEN + "-OTU"); nodeInterfaceBuilder.setOtuInterfaceId(otuInterfacesId); List ochInterfacesId = new ArrayList<>(); - ochInterfacesId.add("node1-" + OpenRoadmInterfacesImpl.NETWORK_TOKEN + "-20"); + ochInterfacesId.add("node1-" + StringConstants.NETWORK_TOKEN + "-20"); nodeInterfaceBuilder.setOchInterfaceId(ochInterfacesId); List nodeInterfaces = new ArrayList<>(); nodeInterfaces.add(nodeInterfaceBuilder.build()); @@ -180,7 +190,7 @@ public class DeviceRendererServiceImplRollbackTest extends AbstractTest { Mockito.doNothing().when(this.openRoadmInterfaces).deleteInterface(Mockito.eq("node1"), Mockito.anyString()); RendererRollbackOutput rendererRollbackOutput = - this.deviceRendererService.rendererRollback(rendererRollbackInputBuilder.build()); + this.deviceRendererService.rendererRollback(rendererRollbackInputBuilder.build()); Assert.assertTrue(rendererRollbackOutput.isSuccess()); Assert.assertFalse(rendererRollbackOutput.getFailedToRollback().isEmpty()); Assert.assertTrue(rendererRollbackOutput.getFailedToRollback().get(0).getInterface().isEmpty()); @@ -199,7 +209,7 @@ public class DeviceRendererServiceImplRollbackTest extends AbstractTest { nodeInterfaceBuilder.withKey(new NodeInterfaceKey("node1")); nodeInterfaceBuilder.setConnectionId(new ArrayList<>()); List ethInterfacesId = new ArrayList<>(); - ethInterfacesId.add("node1-" + OpenRoadmInterfacesImpl.CLIENT_TOKEN + "-ETHERNET"); + ethInterfacesId.add("node1-" + StringConstants.CLIENT_TOKEN + "-ETHERNET"); nodeInterfaceBuilder.setEthInterfaceId(ethInterfacesId); List nodeInterfaces = new ArrayList<>(); nodeInterfaces.add(nodeInterfaceBuilder.build()); @@ -209,7 +219,7 @@ public class DeviceRendererServiceImplRollbackTest extends AbstractTest { Mockito.doThrow(OpenRoadmInterfaceException.class).when(this.openRoadmInterfaces) .deleteInterface(Mockito.eq("node1"), Mockito.anyString()); RendererRollbackOutput rendererRollbackOutput = - this.deviceRendererService.rendererRollback(rendererRollbackInputBuilder.build()); + this.deviceRendererService.rendererRollback(rendererRollbackInputBuilder.build()); Assert.assertFalse(rendererRollbackOutput.isSuccess()); Assert.assertEquals(1,rendererRollbackOutput.getFailedToRollback().size()); Assert.assertEquals(1, rendererRollbackOutput.getFailedToRollback().get(0).getInterface().size()); @@ -220,4 +230,4 @@ public class DeviceRendererServiceImplRollbackTest extends AbstractTest { Mockito.verify(this.openRoadmInterfaces, Mockito.times(1)) .deleteInterface("node1",ethInterfacesId.get(0)); } -} +} \ No newline at end of file diff --git a/renderer/src/test/java/org/opendaylight/transportpce/renderer/provisiondevice/DeviceRendererServiceImplSetupTest.java b/renderer/src/test/java/org/opendaylight/transportpce/renderer/provisiondevice/DeviceRendererServiceImplSetupTest.java index 584c336ef..7c3242b30 100644 --- a/renderer/src/test/java/org/opendaylight/transportpce/renderer/provisiondevice/DeviceRendererServiceImplSetupTest.java +++ b/renderer/src/test/java/org/opendaylight/transportpce/renderer/provisiondevice/DeviceRendererServiceImplSetupTest.java @@ -23,8 +23,9 @@ import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl121; import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl22; import org.opendaylight.transportpce.common.device.DeviceTransactionManager; import org.opendaylight.transportpce.common.device.DeviceTransactionManagerImpl; +import org.opendaylight.transportpce.common.fixedflex.FixedFlexImpl; +import org.opendaylight.transportpce.common.fixedflex.FixedFlexInterface; import org.opendaylight.transportpce.common.mapping.MappingUtils; -import org.opendaylight.transportpce.common.mapping.MappingUtilsImpl; import org.opendaylight.transportpce.common.mapping.PortMapping; import org.opendaylight.transportpce.common.mapping.PortMappingImpl; import org.opendaylight.transportpce.common.mapping.PortMappingVersion121; @@ -34,6 +35,8 @@ import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfa import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl121; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl22; +import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterface121; +import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterface22; import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterfaceFactory; import org.opendaylight.transportpce.renderer.provisiondevice.servicepath.ServicePathDirection; import org.opendaylight.transportpce.renderer.stub.MountPointServiceStub; @@ -66,27 +69,37 @@ public class DeviceRendererServiceImplSetupTest extends AbstractTest { this.deviceTransactionManager = new DeviceTransactionManagerImpl(mountPointService, 3000); this.openRoadmInterfacesImpl121 = new OpenRoadmInterfacesImpl121(deviceTransactionManager); this.openRoadmInterfacesImpl22 = new OpenRoadmInterfacesImpl22(deviceTransactionManager); - this.mappingUtils = new MappingUtilsImpl(getDataBroker()); - this.mappingUtils = Mockito.spy(this.mappingUtils); + this.mappingUtils = Mockito.spy(MappingUtils.class); + + Mockito.doReturn(StringConstants.OPENROADM_DEVICE_VERSION_1_2_1).when(mappingUtils) + .getOpenRoadmVersion(Mockito.anyString()); + this.openRoadmInterfaces = new OpenRoadmInterfacesImpl(deviceTransactionManager, mappingUtils, - openRoadmInterfacesImpl121, openRoadmInterfacesImpl22); + openRoadmInterfacesImpl121, openRoadmInterfacesImpl22); this.openRoadmInterfaces = Mockito.spy(this.openRoadmInterfaces); this.portMappingVersion22 = - new PortMappingVersion22(getDataBroker(), deviceTransactionManager, this.openRoadmInterfaces); + new PortMappingVersion22(getDataBroker(), deviceTransactionManager, this.openRoadmInterfaces); this.portMappingVersion121 = - new PortMappingVersion121(getDataBroker(), deviceTransactionManager, this.openRoadmInterfaces); + new PortMappingVersion121(getDataBroker(), deviceTransactionManager, this.openRoadmInterfaces); this.portMapping = new PortMappingImpl(getDataBroker(), this.portMappingVersion22, this.mappingUtils, - this.portMappingVersion121); + this.portMappingVersion121); this.portMapping = Mockito.spy(this.portMapping); this.crossConnectImpl121 = new CrossConnectImpl121(deviceTransactionManager); this.crossConnectImpl22 = new CrossConnectImpl22(deviceTransactionManager); this.crossConnect = new CrossConnectImpl(deviceTransactionManager, this.mappingUtils, this.crossConnectImpl121, - this.crossConnectImpl22); + this.crossConnectImpl22); this.crossConnect = Mockito.spy(this.crossConnect); - OpenRoadmInterfaceFactory openRoadmInterfaceFactory = - new OpenRoadmInterfaceFactory(this.portMapping, this.openRoadmInterfaces); + + + FixedFlexInterface fixedFlexInterface = new FixedFlexImpl(); + OpenRoadmInterface121 openRoadmInterface121 = new OpenRoadmInterface121(portMapping,openRoadmInterfaces); + OpenRoadmInterface22 openRoadmInterface22 = new OpenRoadmInterface22(portMapping,openRoadmInterfaces, + fixedFlexInterface); + OpenRoadmInterfaceFactory openRoadmInterfaceFactory = new OpenRoadmInterfaceFactory(this.mappingUtils, + openRoadmInterface121,openRoadmInterface22); + this.deviceRendererService = new DeviceRendererServiceImpl(this.getDataBroker(), - this.deviceTransactionManager, openRoadmInterfaceFactory, openRoadmInterfaces, crossConnect, + this.deviceTransactionManager, openRoadmInterfaceFactory, openRoadmInterfaces, crossConnect, portMapping); } @@ -107,14 +120,14 @@ public class DeviceRendererServiceImplSetupTest extends AbstractTest { public void testSetupServicemptyPorts() { setMountPoint(MountPointUtils.getMountPoint(new ArrayList<>(), getDataBroker())); String nodeId = "node1"; - String srcTP = OpenRoadmInterfacesImpl.TTP_TOKEN; - String dstTp = OpenRoadmInterfacesImpl.PP_TOKEN; + String srcTP = StringConstants.TTP_TOKEN; + String dstTp = StringConstants.PP_TOKEN; List nodes = new ArrayList<>(); nodes.add(ServiceImplementationDataUtils.createNode(nodeId, srcTP, dstTp)); ServicePathInput servicePathInput = ServiceImplementationDataUtils.buildServicePathInputs(nodes); for (ServicePathDirection servicePathDirection : ServicePathDirection.values()) { ServicePathOutput servicePathOutput = deviceRendererService.setupServicePath(servicePathInput, - servicePathDirection); + servicePathDirection); Assert.assertFalse(servicePathOutput.isSuccess()); } } @@ -123,19 +136,19 @@ public class DeviceRendererServiceImplSetupTest extends AbstractTest { public void testSetupServiceCannotCrossConnect() { setMountPoint(MountPointUtils.getMountPoint(new ArrayList<>(), getDataBroker())); String nodeId = "node1"; - String srcTP = OpenRoadmInterfacesImpl.TTP_TOKEN; - String dstTp = OpenRoadmInterfacesImpl.PP_TOKEN; + String srcTP = StringConstants.TTP_TOKEN; + String dstTp = StringConstants.PP_TOKEN; MountPointUtils.writeMapping(nodeId, srcTP, this.deviceTransactionManager); MountPointUtils.writeMapping(nodeId, dstTp, this.deviceTransactionManager); List nodes = new ArrayList<>(); nodes.add(ServiceImplementationDataUtils.createNode(nodeId, srcTP, dstTp)); ServicePathInput servicePathInput = ServiceImplementationDataUtils.buildServicePathInputs(nodes); Mockito.doReturn(StringConstants.OPENROADM_DEVICE_VERSION_1_2_1).when(this.mappingUtils) - .getOpenRoadmVersion("node1"); + .getOpenRoadmVersion("node1"); Mockito.doReturn(java.util.Optional.empty()).when(this.crossConnect).postCrossConnect(nodeId, 20L, srcTP, dstTp); ServicePathOutput servicePathOutput = deviceRendererService.setupServicePath(servicePathInput, - ServicePathDirection.A_TO_Z); + ServicePathDirection.A_TO_Z); Assert.assertFalse(servicePathOutput.isSuccess()); } @@ -145,10 +158,10 @@ public class DeviceRendererServiceImplSetupTest extends AbstractTest { Mockito.doNothing().when(this.openRoadmInterfaces).postEquipmentState(Mockito.anyString(), Mockito.anyString(), Mockito.anyBoolean()); String [] interfaceTokens = { - OpenRoadmInterfacesImpl.NETWORK_TOKEN, - OpenRoadmInterfacesImpl.CLIENT_TOKEN, - OpenRoadmInterfacesImpl.TTP_TOKEN, - OpenRoadmInterfacesImpl.PP_TOKEN + StringConstants.NETWORK_TOKEN, + StringConstants.CLIENT_TOKEN, + StringConstants.TTP_TOKEN, + StringConstants.PP_TOKEN }; String nodeId = "node1"; @@ -161,12 +174,12 @@ public class DeviceRendererServiceImplSetupTest extends AbstractTest { MountPointUtils.writeMapping(nodeId, dstTp, this.deviceTransactionManager); boolean connectingUsingCrossConnect = true; - if (OpenRoadmInterfacesImpl.NETWORK_TOKEN.equals(srcToken) - || OpenRoadmInterfacesImpl.CLIENT_TOKEN.equals(srcToken)) { + if (StringConstants.NETWORK_TOKEN.equals(srcToken) + || StringConstants.CLIENT_TOKEN.equals(srcToken)) { connectingUsingCrossConnect = false; } - if (OpenRoadmInterfacesImpl.NETWORK_TOKEN.equals(dstToken) - || OpenRoadmInterfacesImpl.CLIENT_TOKEN.equals(dstToken)) { + if (StringConstants.NETWORK_TOKEN.equals(dstToken) + || StringConstants.CLIENT_TOKEN.equals(dstToken)) { connectingUsingCrossConnect = false; } @@ -174,10 +187,10 @@ public class DeviceRendererServiceImplSetupTest extends AbstractTest { nodes.add(ServiceImplementationDataUtils.createNode(nodeId, srcTP, dstTp)); ServicePathInput servicePathInput = ServiceImplementationDataUtils.buildServicePathInputs(nodes); Mockito.doReturn(StringConstants.OPENROADM_DEVICE_VERSION_1_2_1).when(this.mappingUtils) - .getOpenRoadmVersion("node1"); + .getOpenRoadmVersion("node1"); for (ServicePathDirection servicePathDirection : ServicePathDirection.values()) { ServicePathOutput servicePathOutput = deviceRendererService.setupServicePath(servicePathInput, - servicePathDirection); + servicePathDirection); Assert.assertTrue(servicePathOutput.isSuccess()); String expectedResult = "Roadm-connection successfully created for nodes: "; if (connectingUsingCrossConnect) { @@ -206,10 +219,10 @@ public class DeviceRendererServiceImplSetupTest extends AbstractTest { nodes.add(ServiceImplementationDataUtils.createNode(nodeId, srcTP, dstTp)); ServicePathInput servicePathInput = ServiceImplementationDataUtils.buildServicePathInputs(nodes); Mockito.doReturn(StringConstants.OPENROADM_DEVICE_VERSION_1_2_1).when(this.mappingUtils) - .getOpenRoadmVersion("node1"); + .getOpenRoadmVersion("node1"); for (ServicePathDirection servicePathDirection : ServicePathDirection.values()) { ServicePathOutput servicePathOutput = deviceRendererService.setupServicePath(servicePathInput, - servicePathDirection); + servicePathDirection); Assert.assertTrue(servicePathOutput.isSuccess()); String expectedResult = "Roadm-connection successfully created for nodes: "; expectedResult = expectedResult + nodeId; @@ -218,4 +231,4 @@ public class DeviceRendererServiceImplSetupTest extends AbstractTest { Assert.assertEquals(nodeId, servicePathOutput.getNodeInterface().get(0).getNodeId()); } } -} +} \ No newline at end of file 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 820982fb0..aeef8d0fb 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 @@ -23,12 +23,15 @@ import org.opendaylight.controller.md.sal.binding.api.MountPointService; import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; import org.opendaylight.transportpce.common.ResponseCodes; +import org.opendaylight.transportpce.common.StringConstants; 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.CrossConnectImpl22; import org.opendaylight.transportpce.common.device.DeviceTransactionManager; import org.opendaylight.transportpce.common.device.DeviceTransactionManagerImpl; +import org.opendaylight.transportpce.common.fixedflex.FixedFlexImpl; +import org.opendaylight.transportpce.common.fixedflex.FixedFlexInterface; import org.opendaylight.transportpce.common.mapping.MappingUtils; import org.opendaylight.transportpce.common.mapping.MappingUtilsImpl; import org.opendaylight.transportpce.common.mapping.PortMapping; @@ -41,6 +44,8 @@ import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfa import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl22; import org.opendaylight.transportpce.renderer.NetworkModelWavelengthService; import org.opendaylight.transportpce.renderer.NetworkModelWavelengthServiceImpl; +import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterface121; +import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterface22; import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterfaceFactory; import org.opendaylight.transportpce.renderer.stub.MountPointServiceStub; import org.opendaylight.transportpce.renderer.stub.MountPointStub; @@ -87,23 +92,28 @@ public class RendererServiceOperationsImplDeleteTest extends AbstractTest { this.openRoadmInterfacesImpl22 = new OpenRoadmInterfacesImpl22(deviceTransactionManager); this.mappingUtils = new MappingUtilsImpl(getDataBroker()); this.openRoadmInterfaces = new OpenRoadmInterfacesImpl(deviceTransactionManager, mappingUtils, - openRoadmInterfacesImpl121, openRoadmInterfacesImpl22); + openRoadmInterfacesImpl121, openRoadmInterfacesImpl22); this.openRoadmInterfaces = Mockito.spy(this.openRoadmInterfaces); this.portMappingVersion22 = - new PortMappingVersion22(getDataBroker(), deviceTransactionManager, this.openRoadmInterfaces); + new PortMappingVersion22(getDataBroker(), deviceTransactionManager, this.openRoadmInterfaces); this.portMappingVersion121 = - new PortMappingVersion121(getDataBroker(), deviceTransactionManager, this.openRoadmInterfaces); + new PortMappingVersion121(getDataBroker(), deviceTransactionManager, this.openRoadmInterfaces); this.portMapping = new PortMappingImpl(getDataBroker(), this.portMappingVersion22, this.mappingUtils, - this.portMappingVersion121); + this.portMappingVersion121); this.crossConnectImpl121 = new CrossConnectImpl121(deviceTransactionManager); this.crossConnectImpl22 = new CrossConnectImpl22(deviceTransactionManager); this.crossConnect = new CrossConnectImpl(deviceTransactionManager, this.mappingUtils, this.crossConnectImpl121, - this.crossConnectImpl22); + this.crossConnectImpl22); this.crossConnect = Mockito.spy(crossConnect); - OpenRoadmInterfaceFactory openRoadmInterfaceFactory = - new OpenRoadmInterfaceFactory(portMapping, openRoadmInterfaces); + FixedFlexInterface fixedFlexInterface = new FixedFlexImpl(); + OpenRoadmInterface121 openRoadmInterface121 = new OpenRoadmInterface121(portMapping,openRoadmInterfaces); + OpenRoadmInterface22 openRoadmInterface22 = new OpenRoadmInterface22(portMapping,openRoadmInterfaces, + fixedFlexInterface); + OpenRoadmInterfaceFactory openRoadmInterfaceFactory = new OpenRoadmInterfaceFactory(this.mappingUtils, + openRoadmInterface121,openRoadmInterface22); + this.deviceRenderer = new DeviceRendererServiceImpl(this.getDataBroker(), - this.deviceTransactionManager, openRoadmInterfaceFactory, openRoadmInterfaces, crossConnect, + this.deviceTransactionManager, openRoadmInterfaceFactory, openRoadmInterfaces, crossConnect, this.portMapping); } @@ -113,7 +123,7 @@ public class RendererServiceOperationsImplDeleteTest extends AbstractTest { this.olmService = new OlmServiceStub(); this.olmService = Mockito.spy(this.olmService); ListeningExecutorService executor = - MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(NUMBER_OF_THREADS)); + MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(NUMBER_OF_THREADS)); this.networkModelWavelengthService = new NetworkModelWavelengthServiceImpl(getDataBroker()); NotificationPublishService notificationPublishService = new NotificationPublishServiceMock(); this.rendererServiceOperations = new RendererServiceOperationsImpl(this.deviceRenderer, olmService, @@ -128,12 +138,12 @@ public class RendererServiceOperationsImplDeleteTest extends AbstractTest { ServiceDeleteInputBuilder serviceDeleteInputBuilder = new ServiceDeleteInputBuilder(); serviceDeleteInputBuilder.setServiceName("service 1"); serviceDeleteInputBuilder.setServiceHandlerHeader((new ServiceHandlerHeaderBuilder()) - .setRequestId("request1").build()); + .setRequestId("request1").build()); Mockito.doReturn(true).when(this.crossConnect).deleteCrossConnect(Mockito.anyString(), Mockito.anyString()); ServiceDeleteOutput serviceDeleteOutput = this.rendererServiceOperations.serviceDelete(serviceDeleteInputBuilder.build()).get(); Assert.assertEquals(ResponseCodes.RESPONSE_OK, - serviceDeleteOutput.getConfigurationResponseCommon().getResponseCode()); + serviceDeleteOutput.getConfigurationResponseCommon().getResponseCode()); Mockito.verify(this.crossConnect, Mockito.times(2)).deleteCrossConnect(Mockito.any(), Mockito.any()); } @@ -144,7 +154,7 @@ public class RendererServiceOperationsImplDeleteTest extends AbstractTest { ServiceDeleteOutput serviceDeleteOutput = this.rendererServiceOperations.serviceDelete(serviceDeleteInputBuilder.build()).get(); Assert.assertEquals(ResponseCodes.RESPONSE_FAILED, - serviceDeleteOutput.getConfigurationResponseCommon().getResponseCode()); + serviceDeleteOutput.getConfigurationResponseCommon().getResponseCode()); Mockito.verify(this.crossConnect, Mockito.times(0)).deleteCrossConnect(Mockito.any(), Mockito.any()); } @@ -152,7 +162,7 @@ public class RendererServiceOperationsImplDeleteTest extends AbstractTest { public void serviceDeleteOperationTearDownFailedAtoZ() throws ExecutionException, InterruptedException { Mockito.doReturn(true).when(this.crossConnect).deleteCrossConnect(Mockito.anyString(), Mockito.anyString()); Mockito.doReturn(RpcResultBuilder.success((new ServicePowerTurndownOutputBuilder()) - .setResult("Failed").build()).buildFuture()).when(this.olmService).servicePowerTurndown(Mockito.any()); + .setResult("Failed").build()).buildFuture()).when(this.olmService).servicePowerTurndown(Mockito.any()); writePathDescription(); ServiceDeleteInputBuilder serviceDeleteInputBuilder = new ServiceDeleteInputBuilder(); @@ -172,20 +182,20 @@ public class RendererServiceOperationsImplDeleteTest extends AbstractTest { public void serviceDeleteOperationTearDownFailedZtoA() throws ExecutionException, InterruptedException { Mockito.doReturn(true).when(this.crossConnect).deleteCrossConnect(Mockito.anyString(), Mockito.anyString()); Mockito.when(this.olmService.servicePowerTurndown(Mockito.any())) - .thenReturn(RpcResultBuilder.success((new ServicePowerTurndownOutputBuilder()) - .setResult("Success").build()).buildFuture()) - .thenReturn(RpcResultBuilder.success((new ServicePowerTurndownOutputBuilder()) - .setResult("Failed").build()).buildFuture()); + .thenReturn(RpcResultBuilder.success((new ServicePowerTurndownOutputBuilder()) + .setResult("Success").build()).buildFuture()) + .thenReturn(RpcResultBuilder.success((new ServicePowerTurndownOutputBuilder()) + .setResult("Failed").build()).buildFuture()); writePathDescription(); ServiceDeleteInputBuilder serviceDeleteInputBuilder = new ServiceDeleteInputBuilder(); serviceDeleteInputBuilder.setServiceName("service 1"); serviceDeleteInputBuilder.setServiceHandlerHeader((new ServiceHandlerHeaderBuilder()) - .setRequestId("request1").build()); + .setRequestId("request1").build()); ServiceDeleteOutput serviceDeleteOutput = this.rendererServiceOperations.serviceDelete(serviceDeleteInputBuilder.build()).get(); Assert.assertEquals(ResponseCodes.RESPONSE_FAILED, - serviceDeleteOutput.getConfigurationResponseCommon().getResponseCode()); + 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()); @@ -194,7 +204,7 @@ public class RendererServiceOperationsImplDeleteTest extends AbstractTest { private void writePathDescription() throws ExecutionException, InterruptedException { ServicePathsBuilder servicePathsBuilder = new ServicePathsBuilder(); servicePathsBuilder.setPathDescription(ServiceDeleteDataUtils - .createTransactionPathDescription(OpenRoadmInterfacesImpl.PP_TOKEN)); + .createTransactionPathDescription(StringConstants.PP_TOKEN)); servicePathsBuilder.setServiceAEnd(ServiceDeleteDataUtils.getServiceAEndBuild().build()) .setServiceZEnd(ServiceDeleteDataUtils.getServiceZEndBuild().build()); servicePathsBuilder.withKey(new ServicePathsKey("service 1")); @@ -203,10 +213,10 @@ public class RendererServiceOperationsImplDeleteTest extends AbstractTest { InstanceIdentifier servicePathsInstanceIdentifier = InstanceIdentifier.create( ServicePathList.class).child(ServicePaths.class, new ServicePathsKey("service 1")); TransactionUtils.writeTransaction( - this.deviceTransactionManager, - "node1" + OpenRoadmInterfacesImpl.PP_TOKEN, - LogicalDatastoreType.OPERATIONAL, - servicePathsInstanceIdentifier, - servicePathsBuilder.build()); + this.deviceTransactionManager, + "node1" + StringConstants.PP_TOKEN, + LogicalDatastoreType.OPERATIONAL, + servicePathsInstanceIdentifier, + servicePathsBuilder.build()); } } 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 be4d641ca..ba7707e30 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 @@ -19,12 +19,15 @@ import org.opendaylight.controller.md.sal.binding.api.MountPoint; import org.opendaylight.controller.md.sal.binding.api.MountPointService; import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService; import org.opendaylight.transportpce.common.ResponseCodes; +import org.opendaylight.transportpce.common.StringConstants; 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.CrossConnectImpl22; import org.opendaylight.transportpce.common.device.DeviceTransactionManager; import org.opendaylight.transportpce.common.device.DeviceTransactionManagerImpl; +import org.opendaylight.transportpce.common.fixedflex.FixedFlexImpl; +import org.opendaylight.transportpce.common.fixedflex.FixedFlexInterface; import org.opendaylight.transportpce.common.mapping.MappingUtils; import org.opendaylight.transportpce.common.mapping.MappingUtilsImpl; import org.opendaylight.transportpce.common.mapping.PortMapping; @@ -38,6 +41,8 @@ import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfa import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl22; import org.opendaylight.transportpce.renderer.NetworkModelWavelengthService; import org.opendaylight.transportpce.renderer.NetworkModelWavelengthServiceImpl; +import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterface121; +import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterface22; import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterfaceFactory; import org.opendaylight.transportpce.renderer.stub.MountPointServiceStub; import org.opendaylight.transportpce.renderer.stub.MountPointStub; @@ -88,20 +93,24 @@ public class RendererServiceOperationsImplTest extends AbstractTest { this.openRoadmInterfacesImpl22 = new OpenRoadmInterfacesImpl22(deviceTransactionManager); this.mappingUtils = new MappingUtilsImpl(getDataBroker()); this.openRoadmInterfaces = new OpenRoadmInterfacesImpl(deviceTransactionManager, mappingUtils, - openRoadmInterfacesImpl121, openRoadmInterfacesImpl22); + openRoadmInterfacesImpl121, openRoadmInterfacesImpl22); this.openRoadmInterfaces = Mockito.spy(this.openRoadmInterfaces); this.portMappingVersion22 = - new PortMappingVersion22(getDataBroker(), deviceTransactionManager, this.openRoadmInterfaces); + new PortMappingVersion22(getDataBroker(), deviceTransactionManager, this.openRoadmInterfaces); this.portMappingVersion121 = - new PortMappingVersion121(getDataBroker(), deviceTransactionManager, this.openRoadmInterfaces); + new PortMappingVersion121(getDataBroker(), deviceTransactionManager, this.openRoadmInterfaces); this.portMapping = new PortMappingImpl(getDataBroker(), this.portMappingVersion22, this.mappingUtils, - this.portMappingVersion121); - this.openRoadmInterfaceFactory = new OpenRoadmInterfaceFactory(portMapping, - openRoadmInterfaces); + this.portMappingVersion121); + FixedFlexInterface fixedFlexInterface = new FixedFlexImpl(); + OpenRoadmInterface121 openRoadmInterface121 = new OpenRoadmInterface121(portMapping,openRoadmInterfaces); + OpenRoadmInterface22 openRoadmInterface22 = new OpenRoadmInterface22(portMapping,openRoadmInterfaces, + fixedFlexInterface); + this.openRoadmInterfaceFactory = new OpenRoadmInterfaceFactory(this.mappingUtils,openRoadmInterface121, + openRoadmInterface22); this.crossConnectImpl121 = new CrossConnectImpl121(deviceTransactionManager); this.crossConnectImpl22 = new CrossConnectImpl22(deviceTransactionManager); this.crossConnect = new CrossConnectImpl(deviceTransactionManager, this.mappingUtils, this.crossConnectImpl121, - this.crossConnectImpl22); + this.crossConnectImpl22); } @Before @@ -130,8 +139,8 @@ public class RendererServiceOperationsImplTest extends AbstractTest { public void serviceImplementationTerminationPointAsResourceTtp() throws InterruptedException, ExecutionException { ServiceImplementationRequestInput input = ServiceDataUtils - .buildServiceImplementationRequestInputTerminationPointResource(OpenRoadmInterfacesImpl.TTP_TOKEN); - writePortMapping(input, OpenRoadmInterfacesImpl.TTP_TOKEN); + .buildServiceImplementationRequestInputTerminationPointResource(StringConstants.TTP_TOKEN); + writePortMapping(input, StringConstants.TTP_TOKEN); ServicePathOutputBuilder mockOutputBuilder = new ServicePathOutputBuilder().setResult("success") .setSuccess(true); Mockito.doReturn(mockOutputBuilder.build()).when(this.deviceRenderer).setupServicePath(Mockito.any(), @@ -145,8 +154,8 @@ public class RendererServiceOperationsImplTest extends AbstractTest { public void serviceImplementationTerminationPointAsResourceTtp2() throws InterruptedException, ExecutionException { ServiceImplementationRequestInput input = ServiceDataUtils - .buildServiceImplementationRequestInputTerminationPointResource(OpenRoadmInterfacesImpl.TTP_TOKEN); - writePortMapping(input, OpenRoadmInterfacesImpl.TTP_TOKEN); + .buildServiceImplementationRequestInputTerminationPointResource(StringConstants.TTP_TOKEN); + writePortMapping(input, StringConstants.TTP_TOKEN); ServicePathOutputBuilder mockOutputBuilder = new ServicePathOutputBuilder().setResult("success") .setSuccess(true); Mockito.doReturn(mockOutputBuilder.build()).when(this.deviceRenderer).setupServicePath(Mockito.any(), @@ -162,8 +171,8 @@ public class RendererServiceOperationsImplTest extends AbstractTest { public void serviceImplementationTerminationPointAsResourcePp() throws InterruptedException, ExecutionException { ServiceImplementationRequestInput input = ServiceDataUtils - .buildServiceImplementationRequestInputTerminationPointResource(OpenRoadmInterfacesImpl.PP_TOKEN); - writePortMapping(input, OpenRoadmInterfacesImpl.PP_TOKEN); + .buildServiceImplementationRequestInputTerminationPointResource(StringConstants.PP_TOKEN); + writePortMapping(input, StringConstants.PP_TOKEN); ServicePathOutputBuilder mockOutputBuilder = new ServicePathOutputBuilder().setResult("success") .setSuccess(true); Mockito.doReturn(mockOutputBuilder.build()).when(this.deviceRenderer).setupServicePath(Mockito.any(), @@ -178,8 +187,8 @@ public class RendererServiceOperationsImplTest extends AbstractTest { throws InterruptedException, ExecutionException { ServiceImplementationRequestInput input = ServiceDataUtils - .buildServiceImplementationRequestInputTerminationPointResource(OpenRoadmInterfacesImpl.NETWORK_TOKEN); - writePortMapping(input, OpenRoadmInterfacesImpl.NETWORK_TOKEN); + .buildServiceImplementationRequestInputTerminationPointResource(StringConstants.NETWORK_TOKEN); + writePortMapping(input, StringConstants.NETWORK_TOKEN); ServicePathOutputBuilder mockOutputBuilder = new ServicePathOutputBuilder().setResult("success") .setSuccess(true); Mockito.doReturn(mockOutputBuilder.build()).when(this.deviceRenderer).setupServicePath(Mockito.any(), @@ -194,8 +203,10 @@ public class RendererServiceOperationsImplTest extends AbstractTest { throws InterruptedException, ExecutionException { ServiceImplementationRequestInput input = ServiceDataUtils - .buildServiceImplementationRequestInputTerminationPointResource(OpenRoadmInterfacesImpl.CLIENT_TOKEN); - writePortMapping(input, OpenRoadmInterfacesImpl.CLIENT_TOKEN); + // .buildServiceImplementationRequestInputTerminationPointResource(OpenRoadmInterfacesImpl.CLIENT_TOKEN); + .buildServiceImplementationRequestInputTerminationPointResource(StringConstants.CLIENT_TOKEN); + // writePortMapping(input, OpenRoadmInterfacesImpl.CLIENT_TOKEN); + writePortMapping(input, StringConstants.CLIENT_TOKEN); ServiceImplementationRequestOutput result = this.rendererServiceOperations.serviceImplementation(input).get(); Assert.assertEquals(ResponseCodes.RESPONSE_OK, result.getConfigurationResponseCommon().getResponseCode()); } @@ -205,10 +216,10 @@ public class RendererServiceOperationsImplTest extends AbstractTest { throws InterruptedException, ExecutionException { String[] interfaceTokens = { - OpenRoadmInterfacesImpl.NETWORK_TOKEN, - OpenRoadmInterfacesImpl.CLIENT_TOKEN, - OpenRoadmInterfacesImpl.TTP_TOKEN, - OpenRoadmInterfacesImpl.PP_TOKEN + StringConstants.NETWORK_TOKEN, + StringConstants.CLIENT_TOKEN, + StringConstants.TTP_TOKEN, + StringConstants.PP_TOKEN }; ServicePathOutputBuilder mockOutputBuilder = new ServicePathOutputBuilder().setResult("failed") @@ -222,7 +233,7 @@ public class RendererServiceOperationsImplTest extends AbstractTest { ServiceImplementationRequestOutput result = this.rendererServiceOperations.serviceImplementation(input).get(); Assert.assertEquals(ResponseCodes.RESPONSE_FAILED, - result.getConfigurationResponseCommon().getResponseCode()); + result.getConfigurationResponseCommon().getResponseCode()); } } @@ -233,16 +244,16 @@ public class RendererServiceOperationsImplTest extends AbstractTest { this.deviceTransactionManager ); MountPointUtils.writeMapping( - input.getServiceZEnd().getNodeId(), - input.getServiceZEnd().getNodeId() + "-" - + input.getServiceAEnd().getNodeId() + "-" + tpToken, - this.deviceTransactionManager + input.getServiceZEnd().getNodeId(), + input.getServiceZEnd().getNodeId() + "-" + + input.getServiceAEnd().getNodeId() + "-" + tpToken, + this.deviceTransactionManager ); MountPointUtils.writeMapping( - input.getServiceAEnd().getNodeId(), - input.getServiceAEnd().getNodeId() + "-" - + input.getServiceZEnd().getNodeId() + "-" + tpToken, - this.deviceTransactionManager + input.getServiceAEnd().getNodeId(), + input.getServiceAEnd().getNodeId() + "-" + + input.getServiceZEnd().getNodeId() + "-" + tpToken, + this.deviceTransactionManager ); MountPointUtils.writeMapping( input.getServiceZEnd().getNodeId(), @@ -255,8 +266,8 @@ public class RendererServiceOperationsImplTest extends AbstractTest { public void serviceImplementationRollbackAllNecessary() throws InterruptedException, ExecutionException { ServiceImplementationRequestInput input = ServiceDataUtils - .buildServiceImplementationRequestInputTerminationPointResource(OpenRoadmInterfacesImpl.NETWORK_TOKEN); - writePortMapping(input, OpenRoadmInterfacesImpl.NETWORK_TOKEN); + .buildServiceImplementationRequestInputTerminationPointResource(StringConstants.NETWORK_TOKEN); + writePortMapping(input, StringConstants.NETWORK_TOKEN); Mockito.doReturn(RpcResultBuilder.failed().buildFuture()).when(this.olmService) .servicePowerSetup(Mockito.any()); ServiceImplementationRequestOutput result = this.rendererServiceOperations.serviceImplementation(input).get(); @@ -279,8 +290,8 @@ public class RendererServiceOperationsImplTest extends AbstractTest { public void serviceImplementationServiceInActive() throws InterruptedException, ExecutionException { ServiceImplementationRequestInput input = ServiceDataUtils - .buildServiceImplementationRequestInputTerminationPointResource(OpenRoadmInterfacesImpl.NETWORK_TOKEN); - writePortMapping(input, OpenRoadmInterfacesImpl.NETWORK_TOKEN); + .buildServiceImplementationRequestInputTerminationPointResource(StringConstants.NETWORK_TOKEN); + writePortMapping(input, StringConstants.NETWORK_TOKEN); Measurements measurements = new MeasurementsBuilder().setPmparameterName("FECUncorrectableBlocks") .setPmparameterValue("1").build(); List measurementsList = new ArrayList(); @@ -298,8 +309,8 @@ public class RendererServiceOperationsImplTest extends AbstractTest { public void serviceImplementationServiceInActive2() throws InterruptedException, ExecutionException { ServiceImplementationRequestInput input = ServiceDataUtils - .buildServiceImplementationRequestInputTerminationPointResource(OpenRoadmInterfacesImpl.NETWORK_TOKEN); - writePortMapping(input, OpenRoadmInterfacesImpl.NETWORK_TOKEN); + .buildServiceImplementationRequestInputTerminationPointResource(StringConstants.NETWORK_TOKEN); + writePortMapping(input, StringConstants.NETWORK_TOKEN); Measurements measurements = new MeasurementsBuilder().setPmparameterName("FECUncorrectableBlocks") .setPmparameterValue("1").build(); List measurementsList = new ArrayList(); @@ -320,21 +331,21 @@ public class RendererServiceOperationsImplTest extends AbstractTest { public void serviceImplementationServiceInActive3() throws InterruptedException, ExecutionException { ServiceImplementationRequestInput input = ServiceDataUtils - .buildServiceImplementationRequestInputTerminationPointResource(OpenRoadmInterfacesImpl.NETWORK_TOKEN); - writePortMapping(input, OpenRoadmInterfacesImpl.NETWORK_TOKEN); + .buildServiceImplementationRequestInputTerminationPointResource(StringConstants.NETWORK_TOKEN); + writePortMapping(input, StringConstants.NETWORK_TOKEN); Measurements measurements = new MeasurementsBuilder().setPmparameterName("FECUncorrectableBlocks") .setPmparameterValue("1").build(); List measurementsList = new ArrayList(); measurementsList.add(measurements); GetPmOutput getPmOutput = new GetPmOutputBuilder() - .setNodeId("node1").setMeasurements(measurementsList).build(); + .setNodeId("node1").setMeasurements(measurementsList).build(); GetPmOutput getPmOutput2 = new GetPmOutputBuilder() - .setNodeId("node1").setMeasurements(new ArrayList<>()).build(); + .setNodeId("node1").setMeasurements(new ArrayList<>()).build(); GetPmInput getPmInputZ = createGetPmInput("XPONDER-2-3", - OpenRoadmInterfacesImpl.NETWORK_TOKEN); + StringConstants.NETWORK_TOKEN); GetPmInput getPmInputA = createGetPmInput("XPONDER-1-2", - OpenRoadmInterfacesImpl.NETWORK_TOKEN); + StringConstants.NETWORK_TOKEN); Mockito.when(this.olmService.getPm(Mockito.eq(getPmInputZ))) .thenReturn(RpcResultBuilder.success(getPmOutput2).buildFuture()); @@ -349,8 +360,8 @@ public class RendererServiceOperationsImplTest extends AbstractTest { public void serviceImplementationServiceActive() throws InterruptedException, ExecutionException { ServiceImplementationRequestInput input = ServiceDataUtils - .buildServiceImplementationRequestInputTerminationPointResource(OpenRoadmInterfacesImpl.NETWORK_TOKEN); - writePortMapping(input, OpenRoadmInterfacesImpl.NETWORK_TOKEN); + .buildServiceImplementationRequestInputTerminationPointResource(StringConstants.NETWORK_TOKEN); + writePortMapping(input, StringConstants.NETWORK_TOKEN); GetPmOutput getPmOutput = new GetPmOutputBuilder() .setNodeId("node1").setMeasurements(new ArrayList<>()).build(); GetPmOutput getPmOutput1 = null; @@ -369,8 +380,8 @@ public class RendererServiceOperationsImplTest extends AbstractTest { public void serviceImplementationServiceActive2() throws InterruptedException, ExecutionException { ServiceImplementationRequestInput input = ServiceDataUtils - .buildServiceImplementationRequestInputTerminationPointResource(OpenRoadmInterfacesImpl.NETWORK_TOKEN); - writePortMapping(input, OpenRoadmInterfacesImpl.NETWORK_TOKEN); + .buildServiceImplementationRequestInputTerminationPointResource(StringConstants.NETWORK_TOKEN); + writePortMapping(input, StringConstants.NETWORK_TOKEN); GetPmOutput getPmOutput = new GetPmOutputBuilder().setMeasurements(new ArrayList<>()).build(); Mockito.when(this.olmService.getPm(Mockito.any())).thenReturn(RpcResultBuilder.success(getPmOutput) .buildFuture()); @@ -387,8 +398,8 @@ public class RendererServiceOperationsImplTest extends AbstractTest { public void serviceImplementationServiceInActive4() throws InterruptedException, ExecutionException { ServiceImplementationRequestInput input = ServiceDataUtils - .buildServiceImplementationRequestInputTerminationPointResource(OpenRoadmInterfacesImpl.NETWORK_TOKEN); - writePortMapping(input, OpenRoadmInterfacesImpl.NETWORK_TOKEN); + .buildServiceImplementationRequestInputTerminationPointResource(StringConstants.NETWORK_TOKEN); + writePortMapping(input, StringConstants.NETWORK_TOKEN); Measurements measurements = new MeasurementsBuilder().setPmparameterName("preFECCorrectedErrors") .setPmparameterValue("1").build(); List measurementsList = new ArrayList(); @@ -411,8 +422,8 @@ public class RendererServiceOperationsImplTest extends AbstractTest { public void serviceImplementationServiceInActive5() throws InterruptedException, ExecutionException { ServiceImplementationRequestInput input = ServiceDataUtils - .buildServiceImplementationRequestInputTerminationPointResource(OpenRoadmInterfacesImpl.NETWORK_TOKEN); - writePortMapping(input, OpenRoadmInterfacesImpl.NETWORK_TOKEN); + .buildServiceImplementationRequestInputTerminationPointResource(StringConstants.NETWORK_TOKEN); + writePortMapping(input, StringConstants.NETWORK_TOKEN); Measurements measurements = new MeasurementsBuilder().setPmparameterName("preFECCorrectedErrors") .setPmparameterValue("112000000000d").build(); List measurementsList = new ArrayList(); diff --git a/renderer/src/test/java/org/opendaylight/transportpce/renderer/utils/WaveLengthServiceUtils.java b/renderer/src/test/java/org/opendaylight/transportpce/renderer/utils/WaveLengthServiceUtils.java index 0b24ce466..ab43d437b 100644 --- a/renderer/src/test/java/org/opendaylight/transportpce/renderer/utils/WaveLengthServiceUtils.java +++ b/renderer/src/test/java/org/opendaylight/transportpce/renderer/utils/WaveLengthServiceUtils.java @@ -12,8 +12,11 @@ import java.util.concurrent.ExecutionException; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; import org.opendaylight.transportpce.common.NetworkUtils; import org.opendaylight.transportpce.common.device.DeviceTransactionManager; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.Node1; -import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.TerminationPoint1; +//import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.Node1; +//import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.TerminationPoint1; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.Node1; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.TerminationPoint1; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev171215.TerminationPoint1Builder; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev150608.Network; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev150608.NetworkId; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev150608.NetworkKey; @@ -63,15 +66,14 @@ public final class WaveLengthServiceUtils { .builder(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID))) .child(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev150608 .network.Node.class, new NodeKey(new NodeId(nodeId))) - .augmentation(org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929 - .Node1.class) + .augmentation(Node1.class) .build(); } public static void putNode1ToDatastore(String nodeId, Node1 node1, DeviceTransactionManager deviceTransactionManager) throws ExecutionException, InterruptedException { - InstanceIdentifier + InstanceIdentifier nodeIID = createNode1IID(nodeId); TransactionUtils .writeTransaction(deviceTransactionManager, nodeId, @@ -80,7 +82,7 @@ public final class WaveLengthServiceUtils { public static Node1 getNode1FromDatastore(String nodeId, DeviceTransactionManager deviceTransactionManager) throws ExecutionException, InterruptedException { - InstanceIdentifier + InstanceIdentifier nodeIID = createNode1IID(nodeId); return (Node1) TransactionUtils .readTransaction(deviceTransactionManager, nodeId, LogicalDatastoreType.CONFIGURATION, nodeIID); diff --git a/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/stub/StubRendererServiceOperations.java b/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/stub/StubRendererServiceOperations.java index c18f1aaa8..4fc9c4b09 100644 --- a/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/stub/StubRendererServiceOperations.java +++ b/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/stub/StubRendererServiceOperations.java @@ -25,6 +25,8 @@ import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; import org.opendaylight.transportpce.common.ResponseCodes; import org.opendaylight.transportpce.common.Timeouts; import org.opendaylight.transportpce.renderer.NetworkModelWavelengthService; + +import org.opendaylight.transportpce.common.OperationResult; import org.opendaylight.transportpce.renderer.provisiondevice.RendererServiceOperations; import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev171017.ServiceDeleteInput; import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev171017.ServiceDeleteOutput; @@ -45,6 +47,8 @@ import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.servicepath.rev171017.service.path.list.ServicePathsKey; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; import org.opendaylight.yangtools.yang.binding.Notification; +import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev171016.service.path.PathDescription; +import org.opendaylight.yangtools.yang.common.RpcResult; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -253,4 +257,14 @@ public class StubRendererServiceOperations implements RendererServiceOperations public void setIsnetworkModelWlService(Boolean isnetworkModelWlService) { this.isnetworkModelWlService = isnetworkModelWlService; } + + @Override + public OperationResult reserveResource(PathDescription pathDescription) { + return null; + } + + @Override + public OperationResult freeResource(PathDescription pathDescription) { + return null; + } } -- 2.36.6